sillyspec 3.29.4 → 3.31.0

package/src/run/test-ledger.js

@@ -0,0 +1,264 @@
+/**
+ * test-ledger.js — 测试结果三键指纹账本（P2 / FR-02 / D-001@v1，2026-09-21-r5-efficiency-batch3）
+ *
+ * 背景（batch2 归档实证）：全量测试 ~100s/次，一个收尾事务跑 7 次（必要 2-3 次）；agent 因怕被
+ * --done 拦而恐惧性预跑。本模块按「三键全等才复用」提供 fail-closed 结果账本，消费点=gate
+ * verify 的 verify-test / quick --done 实测门 / gate --full（P1）。
+ *
+ * **fail-closed 三层（红线，D-001@v1）**：
+ *   ① 键分量不可得（git 失败/测试面读不到/配置身份不可解析）→ 不记不复用，永远真跑；
+ *   ② 失败结果永不缓存——只有通过的结果才落账本（失败走真跑修复路径，缓存失败=假绿源）；
+ *   ③ 严格全等——key 为三键分量的 sha256 串比对，无模糊匹配、无时间窗放宽。
+ *
+ * **三键定义**：
+ *   - codeFingerprint：{ head, dirtyDigest }——HEAD commit + porcelain 未提交摘要（路径+内容
+ *     hash 归一）。与 verify-quality-scan 的代码指纹同思想（P0-1 先例），本模块独立实现不耦合
+ *     （quality-scan 是 noAI 步→verify 门单向，本账本多消费点）。
+ *   - testSet（**v2**，P0 修正——fr-test-binding 方案 §3.5 立项前置）：{ runPlan, configDigest,
+ *     testFaceDigest }——runPlan=[{ runner, files }]（runner=实解命令，resolveTestSetIdentity
+ *     经 extractTestCommand 单一解析源解析，调用方不再传字面量；files=段级选中集合，residual
+ *     adapter 落地后入键，现一律 null=整目录摘要兜底）；configDigest=local.yaml 原文摘要
+ *     （local.yaml 是 gitignore 文件——不进 HEAD 也不进 porcelain，v1 键只含调用方硬编码
+ *     'npm test' 字面量，改 commands.test / test_strategy / modules / known_failures 均**不换键**
+ *     =两个不同实际执行映射同一键、跨命令误复用旧绿；v2 起配置任何字节变化都换键——宁可
+ *     多跑一次，不复用错绿）；testFaceDigest=测试面（整目录或选中集合）内容摘要。测试文件
+ *     本身也是代码，改测试=改被测面，必须换键。
+ *   - envProfile：结构化探针（布尔/枚举，**禁裸路径入键**）。探针清单不是拍脑袋列举——
+ *     cwdInsideWorktree 用 detectCwdInsideWorktree 同源判定（batch2 实证：13 个 worktree-cwd
+ *     环境族测试在主 worktree 全挂、在隔离快照全过，其判定信号就是「cwd 路径含
+ *     .sillyspec/.runtime/worktrees/<change> 段」——探针必须捕获该信号，worktree 与主仓天然
+ *     分键）；另收 node 版本/平台名/行为开关 env 集（SILLYSPEC_STEP_GUIDE 等，P4 翻默认后
+ *     直接影响输出形态族）/本地 spec 与平台指针存在性（resolveRuntimeRoot 分流信号）。
+ *
+ * 账本形态：.runtime/test-ledger-<changeName>.json 单条覆盖写（最近一次通过结果；
+ * schemaVersion: 2——v1 旧账 consult 即失效【自然失效，不迁移】，首次通过后按 v2 重建）——
+ * quick 会话名=quick-<hex> 天然 per-change 隔离，无并发互写面；写入走 writeAtomicSync
+ * （meta.json 并发读先例同款约束）。
+ */
+import { createHash } from 'crypto'
+import { existsSync, readFileSync, readdirSync, statSync } from 'fs'
+import { join, relative, isAbsolute } from 'path'
+import { gitQuiet } from '../git-helper.js'
+import { detectCwdInsideWorktree } from './shared.js'
+import { writeAtomicSync } from '../fs-atomic.js'
+import { extractTestCommand } from '../verify-postcheck.js'
+
+const sha256 = (s) => createHash('sha256').update(s).digest('hex')
+
+/** 行为开关 env 集（影响测试结果的 SILLYSPEC_* 键——P4 翻默认后 STEP_GUIDE 直接改 stdout 形态） */
+const BEHAVIOR_ENV_KEYS = [
+  'SILLYSPEC_STEP_GUIDE',
+  'SILLYSPEC_VERIFY_GATE_SNAPSHOT_OFF',
+  'SILLYSPEC_QUICK_TEST_GATE',
+  'SILLYSPEC_VERIFY_QUALITY_SCAN_RERUN',
+]
+
+/**
+ * 环境探针（键分量③）。任何探针异常 → 整体 null（fail-closed 层①）。
+ * @returns {object|null} 结构化探针（JSON 稳定序参与 key）
+ */
+export function computeEnvProfile({ cwd = process.cwd(), env = process.env } = {}) {
+  try {
+    const profile = {
+      cwdInsideWorktree: detectCwdInsideWorktree(cwd) !== null, // 13 环境族测试的真实判定信号（同源）
+      hasLocalSpec: existsSync(join(cwd, '.sillyspec')),
+      hasPlatformPointer: existsSync(join(cwd, '.sillyspec-platform.json')),
+      nodeVersion: process.version,
+      platform: process.platform,
+      behaviorEnv: BEHAVIOR_ENV_KEYS.reduce((acc, k) => {
+        acc[k] = env[k] === undefined ? null : String(env[k])
+        return acc
+      }, {}),
+    }
+    return profile
+  } catch { return null }
+}
+
+/**
+ * 代码指纹（键分量①）：{ head, dirtyDigest }。git 不可达/HEAD 解析失败 → null（fail-closed）。
+ * dirtyDigest = porcelain（含 untracked）行集的排序摘要——任何未提交变化换键。
+ * ignoreFiles：账本自身路径（runtimeRoot 在仓内时）——**排除自污染**：记账写文件会改
+ * porcelain，若不排除，落账瞬间键即漂移、下次查询永 mismatch（自毁键，测试 L1 实证）。
+ * @returns {{ head: string, dirtyDigest: string }|null}
+ */
+export function computeCodeFingerprint(projectRoot, { ignoreFiles = [] } = {}) {
+  try {
+    const head = gitQuiet(projectRoot, ['rev-parse', 'HEAD'])
+    if (!head) return null
+    const status = gitQuiet(projectRoot, ['status', '--porcelain'])
+    if (status === null) return null
+    const ignore = new Set(ignoreFiles)
+    const lines = status.split('\n').filter(Boolean)
+      .filter(l => {
+        const p = l.slice(3).split(' -> ').pop().replace(/^"|"$/g, '')
+        // 两种命中：精确路径（展开的 untracked/已跟踪文件）与目录前缀（git 折叠整棵未跟踪
+        // 目录成 `?? dir/` 一行——排除须向下匹配；账本自污染实测形态，测试 L1）
+        if (ignore.has(p)) return false
+        for (const f of ignore) { if (p.endsWith('/') && f.startsWith(p)) return false }
+        return true
+      })
+      .sort()
+    const dirtyDigest = sha256(lines.join('\n') || '(clean)')
+    return { head: head.trim(), dirtyDigest }
+  } catch { return null }
+}
+
+/** runtimeRoot 相对 projectRoot 的账本路径（仓外 runtimeRoot → null，无需排除） */
+function ledgerIgnorePath(runtimeRoot, changeName, projectRoot) {
+  try {
+    const abs = testLedgerPath(runtimeRoot, changeName)
+    const rel = relative(projectRoot, abs)
+    return rel && !rel.startsWith('..') && !isAbsolute(rel) ? rel.split('\\').join('/') : null
+  } catch { return null }
+}
+
+/**
+ * 测试面摘要（键分量②的输入）：test/ 目录（含一级子目录）文件清单+每文件内容摘要。
+ * 深度帽 2 层、文件数帽 2000（run-tests.mjs 同量级），超帽/读失败 → null（fail-closed——
+ * 测试面不可全知时复用无意义）。
+ * @returns {string|null}
+ */
+export function computeTestFaceDigest(testRoot, depth = 0) {
+  try {
+    if (!existsSync(testRoot) || depth > 2) return null
+    const names = readdirSync(testRoot).filter(n => !n.startsWith('.')).sort()
+    const parts = []
+    let count = 0
+    for (const n of names) {
+      const p = join(testRoot, n)
+      const st = statSync(p)
+      if (st.isDirectory()) {
+        const sub = computeTestFaceDigest(p, depth + 1)
+        if (sub === null) return null
+        parts.push(n + '/:' + sub)
+      } else if (/\.(mjs|js|cjs|json)$/.test(n)) {
+        if (++count > 2000) return null
+        parts.push(n + ':' + sha256(readFileSync(p)))
+      }
+    }
+    return sha256(parts.join('|'))
+  } catch { return null }
+}
+
+/**
+ * 键②身份解析（v2，P0 修正——fr-test-binding 方案 §3.5 立项前置）：runPlan.runner =
+ * 实解命令（extractTestCommand 单一解析源，未配置/unavailable 回退 'npm test'——与
+ * runVerifyTestCheck 主路径同口径）；configDigest = local.yaml 原文摘要（换行归一，EOL-only
+ * 重写不换键）。specBase 未提供/读取异常 → null（fail-closed 层①：身份不可知则键不可得，
+ * 调用方不得回退传字面量命令）。
+ * @returns {{ runPlan: Array<{runner: string, files: string[]|null}>, configDigest: string }|null}
+ */
+export function resolveTestSetIdentity({ specBase } = {}) {
+  try {
+    if (!specBase) return null
+    const yamlPath = join(specBase, 'local.yaml')
+    const text = existsSync(yamlPath) ? readFileSync(yamlPath, 'utf8') : null
+    const runner = extractTestCommand(text) || 'npm test'
+    return {
+      // files 段级选中集合：residual adapter 落地后入键；现一律 null = 整目录摘要兜底（保守向）
+      runPlan: [{ runner, files: null }],
+      configDigest: sha256((text ?? '(no-local.yaml)').replace(/\r\n?/g, '\n')),
+    }
+  } catch { return null }
+}
+
+/**
+ * 选中集合摘要（v2 结构位，P0 第三行）：files 非空 → 仅摘要选中文件内容（未选中测试文件
+ * 改动不再整目录连坐换键）；任一文件缺失/读失败 → null（fail-closed——选中面不可全知时
+ * 复用无意义）。files 空/非数组 → null（调用方走整目录 computeTestFaceDigest 兜底）。
+ * @param {string} testRoot
+ * @param {string[]|null} files 相对 testRoot 的路径
+ * @returns {string|null}
+ */
+export function computeSelectedTestFaceDigest(testRoot, files) {
+  try {
+    if (!Array.isArray(files) || files.length === 0) return null
+    const parts = []
+    for (const f of [...files].sort()) {
+      parts.push(f + ':' + sha256(readFileSync(join(testRoot, f))))
+    }
+    return sha256(parts.join('|'))
+  } catch { return null }
+}
+
+/**
+ * 三键合成（v2）：全部分量就绪才出键；任一 null → null。
+ * testSet = { runPlan, configDigest, testFaceDigest }（resolveTestSetIdentity + 面摘要合成）。
+ * @returns {string|null} sha256 key
+ */
+export function computeTestLedgerKey({ projectRoot, testSet, cwd, env, ignoreFiles = [] }) {
+  const code = computeCodeFingerprint(projectRoot, { ignoreFiles })
+  const profile = computeEnvProfile({ cwd, env })
+  if (!code || !testSet || !testSet.testFaceDigest || !profile) return null
+  return sha256(JSON.stringify({ code, testSet, env: profile }))
+}
+
+/** consult/record 共用键计算（同源防两端口径漂移） */
+function ledgerKeyFor({ runtimeRoot, changeName, projectRoot, testRoot, specBase, cwd, env }) {
+  const selfIgnore = ledgerIgnorePath(runtimeRoot, changeName, projectRoot)
+  const identity = resolveTestSetIdentity({ specBase })
+  if (!identity) return { identity: null, key: null }
+  const face = computeSelectedTestFaceDigest(testRoot, identity.runPlan[0]?.files) || computeTestFaceDigest(testRoot)
+  const key = computeTestLedgerKey({
+    projectRoot,
+    testSet: { runPlan: identity.runPlan, configDigest: identity.configDigest, testFaceDigest: face },
+    cwd, env, ignoreFiles: selfIgnore ? [selfIgnore] : [],
+  })
+  return { identity, key }
+}
+
+/** 账本路径（per-change 单文件） */
+export function testLedgerPath(runtimeRoot, changeName) {
+  return join(runtimeRoot, `test-ledger-${changeName}.json`)
+}
+
+/**
+ * 查询：三键全等且有通过记录 → 复用。任一分量不可得/键不等/账本缺失损坏/版本不符 → 不复用
+ * （fail-closed）。runPlan 随命中回放（供消费方如实展示实际命令）。
+ * @returns {{ reuse: boolean, result?: object, runPlan?: Array<object>|null, reason: string, key?: string }}
+ */
+export function consultTestLedger({ runtimeRoot, changeName, projectRoot, testRoot, specBase, cwd, env }) {
+  const { key } = ledgerKeyFor({ runtimeRoot, changeName, projectRoot, testRoot, specBase, cwd, env })
+  if (!key) return { reuse: false, reason: 'fail-closed: 键分量不可得（git/测试面/环境探针/配置身份任一失败）' }
+  try {
+    const p = testLedgerPath(runtimeRoot, changeName)
+    if (!existsSync(p)) return { reuse: false, reason: 'no-ledger', key }
+    const j = JSON.parse(readFileSync(p, 'utf8'))
+    if (!j || j.schemaVersion !== 2 || !j.key || !j.result || j.result.pass !== true) {
+      return { reuse: false, reason: 'ledger-invalid-or-failed-entry', key }
+    }
+    if (j.key !== key) return { reuse: false, reason: 'key-mismatch', key }
+    return { reuse: true, result: j.result, runPlan: Array.isArray(j.runPlan) ? j.runPlan : null, reason: 'match', key }
+  } catch {
+    return { reuse: false, reason: 'ledger-read-error', key }
+  }
+}
+
+/**
+ * 记账：只有通过结果落账（fail-closed 层②——失败永不缓存）。键不可得 → 不记（下次仍真跑）。
+ * 返回是否落账。
+ */
+export function recordTestLedger({ runtimeRoot, changeName, projectRoot, testRoot, specBase, cwd, env, result }) {
+  if (!result || result.pass !== true) return false
+  const { identity, key } = ledgerKeyFor({ runtimeRoot, changeName, projectRoot, testRoot, specBase, cwd, env })
+  if (!identity || !key) return false
+  try {
+    writeAtomicSync(testLedgerPath(runtimeRoot, changeName), JSON.stringify({
+      schemaVersion: 2,
+      change: changeName,
+      key,
+      // runPlan 回放（审计面：账本声称复用的实际执行身份；不参与键——键已含其摘要）
+      runPlan: identity.runPlan,
+      result: {
+        pass: true,
+        total: result.total ?? null,
+        failed: result.failed ?? [],
+        failedFiles: result.failedFiles ?? [],
+        durationMs: result.durationMs ?? null,
+        strategy: result.strategy ?? null,
+        ranAt: new Date().toISOString(),
+      },
+    }, null, 2) + '\n')
+    return true
+  } catch { return false }
+}

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

@@ -33,6 +33,7 @@ import { join, dirname } from 'node:path'
 import { writeAtomicSync } from '../fs-atomic.js'
 import { gitQuiet } from '../git-helper.js'
 import { resolveRuntimeRoot, parsePorcelainPath } from './shared.js'
+import { computeEnvProfile, computeTestFaceDigest } from './test-ledger.js'
 import { resolveChangeRisk, extractExplicitRiskLevel } from '../change-risk-profile.js'
 import { loadBlastDeclarationsAllProjects } from '../blast-surface.js'
 import { parseFileChangeListDetailed } from '../change-list.js'
@@ -103,6 +104,7 @@ export function storeQualityScan({ specBase, cwd, changeName, testResult, lintRe
   const path = qualityScanRecordPath(specBase, changeName)
   if (!path) return null
   const fingerprint = computeQualityScanFingerprint({ cwd, specBase })
+  const dedupKey = computeQualityScanDedupKey({ cwd, specBase, fingerprint })
   try {
     mkdirSync(dirname(path), { recursive: true })
     writeAtomicSync(path, JSON.stringify({
@@ -112,7 +114,10 @@ export function storeQualityScan({ specBase, cwd, changeName, testResult, lintRe
       fingerprint,
       // 失败签名去重面（ql-20260920-010 修复一 d）：additive 字段，存量记录无这两键 →
       // shouldReuseLastFailedScan 判 no-dedup-key 保守重跑一次，之后新记录即携带
-      dedupKey: computeQualityScanDedupKey({ cwd, specBase, fingerprint }),
+      dedupKey,
+      // RERUN 失败签名（r5l 方案 4）：dedupKey × 测试面 × 环境探针；同样 additive——存量
+      // 记录无此键 → RERUN 签名闸判无签名放行一次（同 no-dedup-key 先例口径）
+      rerunSignature: computeRerunSignature({ cwd, specBase, dedupKey, env: process.env }),
       usedSnapshot: Boolean(usedSnapshot),
       ranAt: new Date().toISOString(),
       testResult,
@@ -173,6 +178,36 @@ export function computeQualityScanDedupKey({ cwd, specBase, fingerprint = null }
   return createHash('sha256').update(fp + '\n##known-failures##\n' + kf).digest('hex')
 }
 
+/**
+ * RERUN 失败签名（r5l-forensic-verdict.md 方案 4 / 评审护栏#6）：dedupKey（代码指纹 ×
+ * known_failures 豁免面）× 测试面 × 环境探针 三路合成，供 SILLYSPEC_VERIFY_QUALITY_SCAN_RERUN=1
+ * 生效前对账——签名未变则拒绝重跑（重跑结果注定相同，R5-L 两次强制重扫各烧 ~8M+10m 的根治）。
+ *
+ * 环境必须入键（护栏#6 五态之「环境变放行」）：环境真变（探针换值）签名才失配，RERUN=1 才
+ * 不会被假拒漏真拦。探针复用 test-ledger computeEnvProfile 同源实现，但剔除
+ * SILLYSPEC_VERIFY_QUALITY_SCAN_RERUN 自身——被测旋钮不是环境（原样入键 = RERUN=1 与历史
+ * 记录恒失配，闸门永不触发）。测试面同理复用 computeTestFaceDigest（test/ 读不到按
+ * 'unavailable' 入键——代码指纹的 HEAD+非文档脏集仍覆盖已提交/未提交的测试文件变更）。
+ *
+ * 任一 fail 分量不可得 → null：签名闸 fail-open（拒跑是危险方向——算不出签名就放行重跑，
+ * 宁可多跑一次不可漏真拦；与复用判定的 fail-closed 方向刻意相反）。
+ */
+export function computeRerunSignature({ cwd, specBase, dedupKey = null, env = process.env }) {
+  const dedup = dedupKey ?? computeQualityScanDedupKey({ cwd, specBase })
+  if (!dedup) return null
+  let testFace = 'unavailable'
+  try {
+    const face = computeTestFaceDigest(join(cwd, 'test'))
+    if (face !== null) testFace = face
+  } catch { /* 测试面读不到 → unavailable 兜底入键 */ }
+  const profile = computeEnvProfile({ cwd, env })
+  if (!profile) return null
+  if (profile.behaviorEnv) delete profile.behaviorEnv.SILLYSPEC_VERIFY_QUALITY_SCAN_RERUN
+  return createHash('sha256')
+    .update(dedup + '\n##test-face##\n' + testFace + '\n##env-probe##\n' + JSON.stringify(profile))
+    .digest('hex')
+}
+
 /**
  * 读回最近一条扫描记录（不论成败）——失败去重重放用。loadReusableQualityScan 拒绝
  * failed 记录（复用是优化不是正确性依赖），去重恰恰要消费 failed 态；schema/source/
@@ -297,7 +332,7 @@ export async function runCoverageExistenceCheck({ cwd, specBase, changeName }) {
   const artifactRel = (yamlText.match(/^\s*coverage_artifact:\s*["']?([^"'\n#]+?)["']?\s*(?:#.*)?$/m) || [])[1] || 'coverage/lcov.info'
   let runNote = ''
   try {
-    execSync(covCmd.trim(), { cwd, encoding: 'utf8', timeout: 10 * 60 * 1000, maxBuffer: 32 * 1024 * 1024, stdio: ['ignore', 'pipe', 'pipe'] })
+    execSync(covCmd.trim(), { cwd, encoding: 'utf8', timeout: 10 * 60 * 1000, maxBuffer: 32 * 1024 * 1024, stdio: ['ignore', 'pipe', 'pipe'], windowsHide: true })
     runNote = '命令退出码 0'
   } catch (e) {
     runNote = `命令退出非 0（${e.status ?? '?'}）——产物若已生成仍按产物判定`
@@ -407,7 +442,7 @@ function runSmokeCheck({ gateCwd, mainCwd, specBase, changeName, inSnapshot }) {
   let r = null
   let spawnError = null
   try {
-    r = spawnSync(command, { shell: true, cwd: gateCwd, timeout: SMOKE_TIMEOUT_MS, encoding: 'utf8', maxBuffer: 32 * 1024 * 1024 })
+    r = spawnSync(command, { shell: true, cwd: gateCwd, timeout: SMOKE_TIMEOUT_MS, encoding: 'utf8', maxBuffer: 32 * 1024 * 1024, windowsHide: true })
   } catch (e) { spawnError = e }
   let timedOut = isSyncTimeout(r)
   let fallbackMainRepo = false
@@ -417,7 +452,7 @@ function runSmokeCheck({ gateCwd, mainCwd, specBase, changeName, inSnapshot }) {
     fallbackMainRepo = true
     console.warn('⚠️ 快照 smoke 超时（node_modules junction I/O 慢）→ 主仓复跑 smoke（并行噪声可能混入——失败先做归属鉴定）')
     try {
-      r = spawnSync(command, { shell: true, cwd: mainCwd, timeout: SMOKE_TIMEOUT_MS, encoding: 'utf8', maxBuffer: 32 * 1024 * 1024 })
+      r = spawnSync(command, { shell: true, cwd: mainCwd, timeout: SMOKE_TIMEOUT_MS, encoding: 'utf8', maxBuffer: 32 * 1024 * 1024, windowsHide: true })
       spawnError = null
       ranCwd = mainCwd
       timedOut = isSyncTimeout(r)
@@ -493,12 +528,43 @@ function warnIfMainRepoDirtyForGate(cwd) {
  */
 export async function executeVerifyQualityScan({ cwd, specBase, changeName, platformOpts }) {
   const { runVerifyTestCheck, printVerifyTestCheck, runVerifyLintCheck, printVerifyLintCheck, shouldBlockVerifyLint, classifyTestFailureArtifact } = await import('../verify-postcheck.js')
+  // ── RERUN 失败签名闸（r5l-forensic-verdict.md 方案 4 / 评审护栏#6 五态）──
+  // R5-L 实证：RERUN=1 两次强制重扫各烧 ~8M 重发 + 10m/6.8m 等待，而失败签名未变——重跑
+  // 结果注定相同。故 RERUN=1 生效前先对账失败签名（dedupKey 已含代码指纹×豁免面，再叠测试
+  // 面×环境探针）：未变 → 拒绝重跑（throw=退出码非 0）；环境真变（探针入键）/代码/豁免/测试
+  // 面变化 → 签名失配自动放行；RERUN=force 无条件放行（真·逃生阀，旧 RERUN=1 的裸语义移到
+  // 此档）。RERUN 未设时本闸不参与——下方既有 dedup 复用判定与 fail-closed 语义一行不动。
+  const rerunMode = process.env.SILLYSPEC_VERIFY_QUALITY_SCAN_RERUN
+  if (rerunMode === 'force') {
+    console.log('ℹ️ SILLYSPEC_VERIFY_QUALITY_SCAN_RERUN=force——无条件强制重跑（RERUN 签名闸与失败签名去重均旁路）')
+  } else if (rerunMode === '1') {
+    const lastRecord = loadLastQualityScanRecord({ specBase, changeName })
+    const lastSig = lastRecord ? lastRecord.rerunSignature : null
+    const lastFailed = lastRecord && lastRecord.testResult && lastRecord.testResult.status === 'failed'
+    if (lastFailed && lastSig) {
+      const sig = computeRerunSignature({ cwd, specBase })
+      if (sig && sig === lastSig) {
+        const t = lastRecord.testResult
+        console.error(`\n🛑 RERUN 签名闸：上次质量扫描失败且失败签名未变（代码指纹 / known_failures 豁免面 / 测试面 / 环境探针均未变${lastRecord.ranAt ? '，上次运行 ' + lastRecord.ranAt : ''}）——重跑结果注定相同，拒绝重跑：`)
+        console.error(`   上次实测：\`${t.command}\` — ${(t.reason || '').split('\n')[0]}`)
+        if (t.outputTail) {
+          for (const line of t.outputTail.split('\n').slice(-8)) console.error(`   | ${line}`)
+        }
+        console.error('   出路（按序）：① 修代码（指纹即失配，下次自动重测）② 补 known_failures 豁免（豁免面即失配）③ 换快照口径（设/删 SILLYSPEC_VERIFY_GATE_SNAPSHOT_OFF，口径变化即失配）④ 环境确已修好后强制重跑：SILLYSPEC_VERIFY_QUALITY_SCAN_RERUN=1（环境探针已入失败签名——环境真变即自动放行；仍被拒=探针未见变化，确要无条件重跑用 SILLYSPEC_VERIFY_QUALITY_SCAN_RERUN=force）')
+        throw new Error(`RERUN 签名闸拒绝重跑（失败签名未变：代码指纹×测试面×环境探针全等）——${(t.reason || '测试失败').split('\n')[0]}。按上方出路处置；确要无条件重跑设 SILLYSPEC_VERIFY_QUALITY_SCAN_RERUN=force。`)
+      }
+    } else if (lastFailed) {
+      console.log('ℹ️ RERUN=1：上次失败记录无 rerunSignature（存量记录）——签名闸放行一次，本次重跑后新记录即携带签名')
+    } else {
+      console.log('ℹ️ SILLYSPEC_VERIFY_QUALITY_SCAN_RERUN=1——强制重跑（上次无失败记录在案，签名闸无事可对）')
+    }
+  }
   // ── 失败签名去重（ql-20260920-010 修复一 d）──
   // 复入本步前先对账上次失败：代码指纹 + known_failures 豁免面 + 快照口径都没变 → 失败
   // 必然原样复现，重跑是纯等待（对撞三轮三连 8~10 分钟假红重试的根治）。复用只消费
   // failed 态记录（passed 态 --done 复用归 loadReusableQualityScan），逃生阀
-  // SILLYSPEC_VERIFY_QUALITY_SCAN_RERUN=1。
-  if (process.env.SILLYSPEC_VERIFY_QUALITY_SCAN_RERUN !== '1') {
+  // SILLYSPEC_VERIFY_QUALITY_SCAN_RERUN=1（闸门见上方签名闸）与 =force（无条件旁路）。
+  if (rerunMode !== '1' && rerunMode !== 'force') {
     const lastRecord = loadLastQualityScanRecord({ specBase, changeName })
     const verdict = shouldReuseLastFailedScan({
       lastRecord,
@@ -519,7 +585,7 @@ export async function executeVerifyQualityScan({ cwd, specBase, changeName, plat
         console.error(`   🔬 失败签名命中伪影形态（${replayTriage.kind}）：${replayTriage.advice}`)
         console.error('      （上次运行早于分诊机制——本次重跑会自动做主树口径对照；如需立即重跑设 SILLYSPEC_VERIFY_QUALITY_SCAN_RERUN=1）')
       }
-      console.error('   出路（按序）：① 修代码（指纹即失配，下次自动重测）② 补 known_failures 豁免（豁免面即失配）③ 换快照口径（设/删 SILLYSPEC_VERIFY_GATE_SNAPSHOT_OFF，口径变化即失配）④ 环境确已修好后强制重跑：SILLYSPEC_VERIFY_QUALITY_SCAN_RERUN=1')
+      console.error('   出路（按序）：① 修代码（指纹即失配，下次自动重测）② 补 known_failures 豁免（豁免面即失配）③ 换快照口径（设/删 SILLYSPEC_VERIFY_GATE_SNAPSHOT_OFF，口径变化即失配）④ 环境确已修好后强制重跑：SILLYSPEC_VERIFY_QUALITY_SCAN_RERUN=1（环境探针已入失败签名——环境真变即放行；仍被拒用 SILLYSPEC_VERIFY_QUALITY_SCAN_RERUN=force）')
       throw new Error(`noAI 质量扫描复用上次失败结果（失败签名未变，跳过重跑）——${(t.reason || '测试失败').split('\n')[0]}。修复后重跑 sillyspec run verify${changeName ? ` --change ${changeName}` : ''}，或按上方出路处置。`)
     }
   }
@@ -530,6 +596,16 @@ export async function executeVerifyQualityScan({ cwd, specBase, changeName, plat
   // ⚠️ 口径可见。指纹（storeQualityScan）仍按主仓 cwd 算——--done 对账复用的指纹匹配口径不变。
   let snap = null
   if (!process.env.SILLYSPEC_VERIFY_GATE_SNAPSHOT_OFF) {
+    // worktree 会话跳快照（2026-09-23 R9/R10 根治）：worktree 已是会话独占隔离——快照只剩
+    // venv junction 冻结/慢 I/O 纯成本（R9 3MB/0CPU 冻结、R10 15min 慢跑实证），直接工作树实测。
+    let skipForWorktree = false
+    try {
+      const { shouldSkipGateSnapshotForWorktree } = await import('./gate-snapshot.js')
+      skipForWorktree = shouldSkipGateSnapshotForWorktree(cwd)
+    } catch { /* 判定异常按不跳走原路 */ }
+    if (skipForWorktree) {
+      console.log('🔀 cwd 是会话专属 worktree——隔离快照冗余（并行会话不在场；快照 venv junction 冻结/慢 I/O 面 R9/R10 双实证），直接在 worktree 实测')
+    } else {
     try {
       const { createVerifyGateSnapshot } = await import('./gate-snapshot.js')
       snap = await createVerifyGateSnapshot({ cwd, changeName, specBase, platformOpts })
@@ -537,6 +613,7 @@ export async function executeVerifyQualityScan({ cwd, specBase, changeName, plat
         console.log(`🧪 noAI 扫描隔离快照（根：${snap.snapshotRoot}）：HEAD + 本变更 ${snap.changeFileCount} 个文件${snap.sourceRoot ? '（overlay 自 worktree——本变更分支内容定向跑）' : ''}（并行会话脏文件不参与判定）`)
       }
     } catch { /* 快照链路异常 → 主仓现行为 */ }
+    }
   }
   const gateCwd = snap ? snap.snapshotRoot : cwd
   const gateSpecBase = snap ? join(snap.snapshotRoot, '.sillyspec') : specBase

package/src/scope-audit.js

@@ -321,7 +321,12 @@ export function buildFrozenPatch(root, files, { baseRef } = {}) {
   const parts = []
   try {
     const r = safeGit(root, ['diff', '--no-color', baseRef], { timeout: 60 * 1000 })
-    const filtered = filterPatchForFiles(r.error ? null : r.value, wanted)
+    // 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
+    // 只剩 proposal.md 一个 hunk 却标 ok。失败即 null（jsdoc 契约：调用方 fail-soft 不落伪 patch））
+    if (r.error) return null
+    const filtered = filterPatchForFiles(r.value, wanted)
     if (filtered) parts.push(filtered)
     const trackedOut = safeGit(root, ['ls-files'], { timeout: 30 * 1000 })
     const trackedSet = new Set(String(trackedOut.value || '').split('\n').map(toPosix).filter(Boolean))

package/src/sentinel-assertions.js

@@ -0,0 +1,114 @@
+/**
+ * sentinel-assertions.js — L0 收口侧纯断言（2026-09-23-sentinel-rules / FR-07 / D-002@v1）。
+ *
+ * 与 watcher 侧哨兵规则（src/watcher.js R1 假勾选）同判据的**硬门版**纯函数：--done 收口
+ * 侧调用拒收「全勾但零完成证据」的假完成主张（L0 升级通道——watcher 恒 advisory 人判，
+ * 收口是唯一拒绝点，符合「守卫必须是验收侧的机制，永远不是生成侧的劝说」设计原则）。
+ *
+ * ⚠️ 本批（task-03）只交付函数+单测，**无任何仓内调用方**——收口接线留下批（避免与并行
+ * 会话改同文件）；测试文件是当前唯一消费方。
+ *
+ * 纯度口径：无副作用（零写盘/零 db），输出由参数+只读盘面（review.json 在场探测）决定；
+ * 盘面探测可经 opts.listReviewsImpl 注入替身（单测零真 fs）。证据判据与 R1 同口径：
+ * commit 消息（标题或正文——2026-09-25 起收口侧取 %B 整条消息）含完整 token task-NN
+ * （负向前瞻，task-01 不证 task-010）或对应 review.json 在场（.runtime/execute-runs
+ * 任意 run 的 tasks 目录下对应任务子目录）。
+ */
+import { join, dirname } from 'path';
+import { existsSync, readdirSync } from 'fs';
+
+/** 判集行锚：`- [x] task-01: …`（id 行才是可验证主张；无 id 勾选行不入判——不可验证不拒收）。 */
+const CHECKED_TASK_LINE_RE = /^[-*] \[( |x|X)\] (task-\d+)/;
+
+/** task id 完整 token 匹配（词边界，与 watcher R1 同口径）。 */
+function taskTokenRe(id) {
+  return new RegExp(`${id}(?!\\d)`);
+}
+
+/**
+ * review.json 在场证据清单（execute-runs 两级遍历；异常/缺失 → []，commit 证据照判）。
+ */
+function listReviewEvidence(changeDir, opts) {
+  if (typeof opts.listReviewsImpl === 'function') {
+    try { return opts.listReviewsImpl(changeDir) || []; } catch { return []; }
+  }
+  if (!changeDir) return [];
+  try {
+    const runsRoot = join(dirname(changeDir), '.runtime', 'execute-runs');
+    const out = [];
+    for (const run of readdirSync(runsRoot)) {
+      let names = [];
+      try { names = readdirSync(join(runsRoot, run, 'tasks')); } catch { continue; }
+      for (const t of names) {
+        if (existsSync(join(runsRoot, run, 'tasks', t, 'review.json'))) {
+          out.push(`execute-runs/${run}/tasks/${t}/review.json`);
+        }
+      }
+    }
+    return out;
+  } catch {
+    return [];
+  }
+}
+
+/**
+ * 假勾选三态判定（L0 收口拒收支点，下批接线）。
+ *
+ * @param {object} args
+ * @param {string|null} args.changeDir 变更目录（推导 specBase 定位 execute-runs；null/探测
+ *   失败按无 review 证据，commit 证据照判）
+ * @param {string|null} args.tasksMd tasks.md 全文（判集=行首 checkbox+task-NN id 行）
+ * @param {Array<string|{message:string}|{subject:string}>} args.commits 提交组（消息含
+ *   task-NN 即该任务证据）
+ * @param {{listReviewsImpl?: Function}} [args.opts] 注入面（测试替身）
+ * @returns {{status:'complete'|'fake'|'none', claimTotal:number, checked:number, missing:string[]}}
+ *   none=无完成主张（判集空或未全勾）；complete=全勾且零 missing；fake=全勾且有零证据
+ *   任务（missing 列其 id，收口侧拒收依据）。
+ */
+export function detectFakeCheckCompletion({ changeDir, tasksMd, commits, opts = {} } = {}) {
+  const entries = [];
+  for (const line of String(tasksMd || '').split(/\r?\n/)) {
+    const m = line.match(CHECKED_TASK_LINE_RE);
+    if (m) entries.push({ id: m[2], checked: m[1].toLowerCase() === 'x' });
+  }
+  const claimTotal = entries.length;
+  const checked = entries.filter((e) => e.checked).length;
+  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) => {
+      const re = taskTokenRe(e.id);
+      const byCommit = messages.some((msg) => re.test(msg));
+      const byReview = reviews.some((p) => p.includes(`/tasks/${e.id}/`));
+      return !(byCommit || byReview);
+    })
+    .map((e) => e.id);
+  return { status: missing.length === 0 ? 'complete' : 'fake', claimTotal, checked, missing };
+}
+
+/**
+ * 勾选节奏检测（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。
+ */
+export function detectBatchCheckCadence(events) {
+  let worst = null;
+  for (const e of events || []) {
+    if (!e || e.kind !== 'task-done') continue;
+    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 worst;
+}
+
+export default { detectFakeCheckCompletion, detectBatchCheckCadence };

package/src/setup.js

@@ -171,7 +171,7 @@ export async function cmdSetup(dir, options = {}) {
     results['全局工具'] = {};
     for (const g of GLOBAL_TOOLS) {
       try {
-        execSync(g.checkCommand, { stdio: 'pipe', encoding: 'utf8' });
+        execSync(g.checkCommand, { stdio: 'pipe', encoding: 'utf8', windowsHide: true });
         results['全局工具'][g.id] = true;
       } catch {
         results['全局工具'][g.id] = false;
@@ -252,7 +252,7 @@ export async function cmdSetup(dir, options = {}) {
   const globalInstalled = new Set();
   for (const tool of GLOBAL_TOOLS) {
     try {
-      execSync(tool.checkCommand, { stdio: 'pipe', encoding: 'utf8' });
+      execSync(tool.checkCommand, { stdio: 'pipe', encoding: 'utf8', windowsHide: true });
       globalInstalled.add(tool.id);
     } catch {}
   }
@@ -379,7 +379,7 @@ export async function cmdSetup(dir, options = {}) {
     for (const tool of selectedGlobal) {
       const spinner = ora(`安装 ${tool.name}...`).start();
       try {
-        execSync(tool.installCommand, { stdio: 'pipe', encoding: 'utf8', timeout: 120000 });
+        execSync(tool.installCommand, { stdio: 'pipe', encoding: 'utf8', timeout: 120000, windowsHide: true });
         spinner.succeed(`${tool.name} 安装完成`);
       } catch (err) {
         spinner.fail(`${tool.name} 安装失败: ${err.message}`);