sillyspec 3.32.1 → 3.32.3

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

@@ -50,9 +50,10 @@ export function qualityScanRecordPath(specBase, changeName) {
  * 指纹非代码面排除：verify 阶段步骤 6 实测 → --done 窗口内的合法产出只有规范文档——
  * 排除后这些写入不再触发失配重跑；src 一动（护栏外行为）立即失配照旧亲测。
  */
-function isNonCodePath(p) {
-  return p.startsWith('.sillyspec/') || p.startsWith('docs/') || p.endsWith('.md')
-}
+// 非代码路径判据已迁 code-face-key.js（口径单点，2026-10-09-verify-reuse-friction FR-03）。
+// 注意单点版 /\.md$/i 大小写不敏感：本文件原 endsWith('.md') 仅小写——统一后大写 .MD 文档
+// 面同样豁免（两处口径互称同源已久，统一是收敛不是语义翻转）。
+import { isNonCodePath, computeCodeTreeKey } from './code-face-key.js'
 
 function porcelainCodeLines(porcelain) {
   return String(porcelain || '')
@@ -64,7 +65,7 @@ function porcelainCodeLines(porcelain) {
 }
 
 /**
- * 代码指纹：sha256(local.yaml commands 段 + test_strategy 行 + git HEAD + 非文档脏集)。
+ * 代码指纹：sha256(local.yaml commands 段 + test_strategy 行 + 代码树内容键 + 非文档脏集)。
  * git 不可用 → null（fail-closed：store 落 null / load 视为无记录，复用窗口关闭）。
  * 配置面口径与 prompt.js {LOCAL_COMMANDS} 注入的块扫描同款（含 unavailable 行剔除）。
  */
@@ -84,12 +85,15 @@ export function computeQualityScanFingerprint({ cwd, specBase }) {
       if (ts) configText += '\n' + ts.trim()
     }
   } catch { /* 读不到按空配置面处理 */ }
-  const head = gitQuiet(cwd, ['rev-parse', 'HEAD'])
+  // 2026-10-09-verify-reuse-friction（D-002@v1）：HEAD 分量替换为代码树内容键（ls-tree 过滤
+  // 哈希，见 code-face-key.js）——纯文档提交不再击穿，代码提交必击穿；git 不可用 → null
+  // （fail-closed：复用窗口关闭，语义与原 HEAD 不可用同向）。
+  const treeKey = computeCodeTreeKey({ cwd })
   const porcelain = gitQuiet(cwd, ['status', '--porcelain'])
-  if (head === null || porcelain === null) return null
+  if (treeKey === null || porcelain === null) return null
   const codeLines = porcelainCodeLines(porcelain)
   return createHash('sha256')
-    .update([configText, head.trim(), codeLines.join('|')].join('\n---\n'))
+    .update([configText, treeKey, codeLines.join('|')].join('\n---\n'))
     .digest('hex')
 }
 
@@ -100,7 +104,7 @@ export function computeQualityScanFingerprint({ cwd, specBase }) {
  * 保持 1——存量记录无 smoke 段照常读回（smokeResult 兜底 null）；未配置 smoke 时段形态为
  * configured=false（记录仍写，供 --done PASS 封顶判 not-configured）。
  */
-export function storeQualityScan({ specBase, cwd, changeName, testResult, lintResult, smokeResult, usedSnapshot = false }) {
+export function storeQualityScan({ specBase, cwd, changeName, testResult, lintResult, smokeResult, usedSnapshot = false, missReason = null, scopeDecision = null }) {
   const path = qualityScanRecordPath(specBase, changeName)
   if (!path) return null
   const fingerprint = computeQualityScanFingerprint({ cwd, specBase })
@@ -123,6 +127,11 @@ export function storeQualityScan({ specBase, cwd, changeName, testResult, lintRe
       // 修改）；additive——存量记录无此键 → 闸判 no-passed-key 保守重跑一次后携带
       passedKey: computeQualityScanPassedKey({ cwd, specBase }),
       usedSnapshot: Boolean(usedSnapshot),
+      // 复用观测（2026-10-09-verify-reuse-friction FR-04，additive——存量记录无键读侧兼容）：
+      // missReason=本轮真跑前的闸 miss 原因链；scopeDecision=计划口径 vs 实际口径（快照
+      // 慢性失败时 planned≠actual 的收敛态可从记录直读，取证不再依赖 stdout 考古）。
+      missReason,
+      scopeDecision,
       ranAt: new Date().toISOString(),
       testResult,
       lintResult: lintResult || null,
@@ -624,17 +633,66 @@ export async function executeVerifyQualityScan({ cwd, specBase, changeName, plat
       console.log('ℹ️ SILLYSPEC_VERIFY_QUALITY_SCAN_RERUN=1——强制重跑（上次无失败记录在案，签名闸无事可对）')
     }
   }
-  // ── 失败签名去重（ql-20260920-010 修复一 d）──
+  // ── 隔离快照定向跑（2026-09-11 驾驭第十二批；2026-10-09-verify-reuse-friction 移到复用闸之前）──
+  // noAI 质量扫描是 verify 的第一实测执行点，快照（HEAD + 本变更文件集，native worktree
+  // 定向源）防并行 WIP 弄红无辜变更。**先建后判（D-003@v1）**：下方两道复用闸（失败签名
+  // 去重 / passed 幂等）以「本轮实际口径」Boolean(snap) 对账 lastRecord.usedSnapshot——快照
+  // 创建慢性失败时 false==false 口径一致即收敛命中，断根治「计划口径 vs 实际口径恒失配」的
+  // 死循环（2026-10-09 multi-agent-platform tombstone 取证：13 轮实测中 4 轮纯浪费于此，
+  // 记录 usedSnapshot=false × planned=true 永不收敛）。指纹（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 })
+      if (snap) {
+        console.log(`🧪 noAI 扫描隔离快照（根：${snap.snapshotRoot}）：HEAD + 本变更 ${snap.changeFileCount} 个文件${snap.sourceRoot ? '（overlay 自 worktree——本变更分支内容定向跑）' : ''}（并行会话脏文件不参与判定）`)
+      } else {
+        // FR-02（2026-10-09-verify-reuse-friction）：null 回退与异常回退同等可见 + 记账
+        try {
+          const { reportGateSnapshotFallback } = await import('./gate-snapshot.js')
+          if (typeof reportGateSnapshotFallback === 'function') await reportGateSnapshotFallback({ cwd, changeName, platformOpts, where: 'noAI 质量扫描步', reason: 'createVerifyGateSnapshot 返回 null（变更文件集为空 / 快照基建不可用）' })
+        } catch { /* 报告失败不改变回退行为（含测试 mock 模块缺导出的形态） */ }
+      }
+    } catch (e) {
+      try {
+        const { reportGateSnapshotFallback } = await import('./gate-snapshot.js')
+        if (typeof reportGateSnapshotFallback === 'function') await reportGateSnapshotFallback({ cwd, changeName, platformOpts, where: 'noAI 质量扫描步', reason: e && e.message ? e.message : String(e) })
+      } catch { /* 报告失败不改变回退行为（含测试 mock 模块缺导出的形态） */ }
+    }
+    }
+  }
+  const gateCwd = snap ? snap.snapshotRoot : cwd
+  const gateSpecBase = snap ? join(snap.snapshotRoot, '.sillyspec') : specBase
+  if (!snap) {
+    warnIfMainRepoDirtyForGate(cwd)
+  }
+  // ── 失败签名去重（ql-20260920-010 修复一 d；2026-10-09 起传实际口径）──
   // 复入本步前先对账上次失败：代码指纹 + known_failures 豁免面 + 快照口径都没变 → 失败
   // 必然原样复现，重跑是纯等待（对撞三轮三连 8~10 分钟假红重试的根治）。复用只消费
   // failed 态记录（passed 态 --done 复用归 loadReusableQualityScan），逃生阀
   // SILLYSPEC_VERIFY_QUALITY_SCAN_RERUN=1（闸门见上方签名闸）与 =force（无条件旁路）。
+  // plannedSnapshot 参数自 2026-10-09 起接收「本轮实际口径」Boolean(snap)（先建后判）。
+  // ── 复用观测（2026-10-09-verify-reuse-friction FR-04）：判定原因链落盘——miss 原因随
+  //    本轮 store 记录（missReason），命中轮落 reuse-decisions jsonl，真跑轮随 test-result.json。──
+  let _missReasonParts = []
   if (rerunMode !== '1' && rerunMode !== 'force') {
     const lastRecord = loadLastQualityScanRecord({ specBase, changeName })
     const verdict = shouldReuseLastFailedScan({
       lastRecord,
       currentDedupKey: computeQualityScanDedupKey({ cwd, specBase }),
-      plannedSnapshot: !process.env.SILLYSPEC_VERIFY_GATE_SNAPSHOT_OFF,
+      plannedSnapshot: Boolean(snap),
     })
     if (verdict.reuse) {
       const t = lastRecord.testResult
@@ -651,66 +709,51 @@ export async function executeVerifyQualityScan({ cwd, specBase, changeName, plat
         console.error('      （上次运行早于分诊机制——本次重跑会自动做主树口径对照；如需立即重跑设 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）')
+      if (snap) { try { snap.cleanup() } catch { /* 复用路径快照清理失败不阻断 throw */ } }
+      try {
+        const { appendReuseDecision } = await import('../verify-postcheck.js')
+        appendReuseDecision({ specBase, changeName, decision: { layer: 'noai-failed-gate', hit: true, reason: null, fingerprint: computeQualityScanFingerprint({ cwd, specBase }) } })
+      } catch { /* 观测失败不阻断 */ }
       throw new Error(`noAI 质量扫描复用上次失败结果（失败签名未变，跳过重跑）——${(t.reason || '测试失败').split('\n')[0]}。修复后重跑 sillyspec run verify${changeName ? ` --change ${changeName}` : ''}，或按上方出路处置。`)
     }
+    if (!verdict.reuse && verdict.reason) _missReasonParts.push(`failed闸: ${verdict.reason}`)
   }
-  // ── passed 幂等闸（2026-09-30-quality-scan-passed-idempotent，与失败签名闸对称）──
+  // ── passed 幂等闸（2026-09-30-quality-scan-passed-idempotent，与失败签名闸对称；2026-10-09 起传实际口径）──
   // 上次 passed 且 passedKey（dedupKey × 非文档脏集内容键——内容敏感，同文件未提交修改
   // 即失配）/快照口径全等 → 免重跑直接完成本步骤（verify 收敛循环里 agent 修文档反复重入
   // 本步，码态未变时快照构建+测试+lint 的 ~分钟级全量重跑是纯等待——实证 11 轮 ×~290s）。
   // 复用只做披露，不重写记录（ranAt 不动，--done 读侧 loadReusableQualityScan 口径不变）；
-  // 逃生阀与失败闸同款 RERUN=1/force。
+  // 逃生阀与失败闸同款 RERUN=1/force。plannedSnapshot 参数自 2026-10-09 起接收「本轮实际
+  // 口径」Boolean(snap)（先建后判——死循环根治见上方快照块注释）。
   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,
+      plannedSnapshot: Boolean(snap),
     })
     if (passedVerdict.reuse) {
       console.log(`\n♻️ noAI 质量扫描幂等命中：上次实测 passed 且代码指纹/配置/豁免面/快照口径全等${lastRecord.ranAt ? `（实测于 ${lastRecord.ranAt}）` : ''}——本轮免重跑，--done 对账继续复用该记录；确需重跑设 SILLYSPEC_VERIFY_QUALITY_SCAN_RERUN=1。`)
       console.log(`\n✅ noAI 质量扫描全绿（幂等复用）——本步骤自动完成；代码/配置/豁免面任一变化即 dedupKey 失配自动重测。`)
+      try {
+        const { appendReuseDecision } = await import('../verify-postcheck.js')
+        appendReuseDecision({ specBase, changeName, decision: { layer: 'noai-passed-gate', hit: true, reason: null, fingerprint: computeQualityScanFingerprint({ cwd, specBase }) } })
+      } catch { /* 观测失败不阻断 */ }
+      if (snap) { try { snap.cleanup() } catch { /* 复用路径快照清理失败不阻断返回 */ } }
       return
     }
-  }
-  // ── 隔离快照定向跑（2026-09-11 驾驭第十二批，用户第三次撞上：noAI 质量扫描是 verify 的
-  // 第一实测执行点，第八批只接了 gates.js verify 块——本步仍跑 main 工作区，并行 WIP 在此弄红
-  // 无辜变更）。与 gates.js 同款：createVerifyGateSnapshot（HEAD + 本变更文件集，native worktree
-  // 定向源），ENV 同 SILLYSPEC_VERIFY_GATE_SNAPSHOT_OFF，基建失败 fallback 主仓 + 脏文件在场时
-  // ⚠️ 口径可见。指纹（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 })
-      if (snap) {
-        console.log(`🧪 noAI 扫描隔离快照（根：${snap.snapshotRoot}）：HEAD + 本变更 ${snap.changeFileCount} 个文件${snap.sourceRoot ? '（overlay 自 worktree——本变更分支内容定向跑）' : ''}（并行会话脏文件不参与判定）`)
-      }
-    } catch { /* 快照链路异常 → 主仓现行为 */ }
+    if (passedVerdict.reason) {
+      _missReasonParts.push(`passed闸: ${passedVerdict.reason}`)
+      console.log(`ℹ️ 质量扫描复用未命中：${passedVerdict.reason}——本轮真跑`)
     }
   }
-  const gateCwd = snap ? snap.snapshotRoot : cwd
-  const gateSpecBase = snap ? join(snap.snapshotRoot, '.sillyspec') : specBase
-  if (!snap) {
-    warnIfMainRepoDirtyForGate(cwd)
-  }
   console.log(`\n⏳ noAI 质量扫描：CLI 亲自实测 commands.test（同步，长套件 2~10 分钟无输出属正常）——结果按代码指纹落盘，最终 --done 对账直接复用免重跑。`)
   let testCheck
   let lintCheck
   let coverageCheck = null
   let smokeResult = null
   try {
-    testCheck = runVerifyTestCheck({ cwd: gateCwd, specBase: gateSpecBase, changeName })
+    testCheck = runVerifyTestCheck({ cwd: gateCwd, specBase: gateSpecBase, changeName, observability: { fingerprint: computeQualityScanFingerprint({ cwd, specBase }), reuse_decision: { layer: 'real-run', hit: false, reason: _missReasonParts.join('；') || null } } })
     // ── 伪影分诊（ql-20260920-010 修复一 a）：失败先分诊，命中 → 主树口径单点复跑对照 ──
     testCheck = applyArtifactTriageRerun({
       testCheck,
@@ -752,7 +795,7 @@ export async function executeVerifyQualityScan({ cwd, specBase, changeName, plat
   } finally {
     if (snap) { try { snap.cleanup() } catch {} }
   }
-  storeQualityScan({ specBase, cwd, changeName, testResult: testCheck, lintResult: lintCheck, smokeResult, coverageCheck, usedSnapshot: Boolean(snap) })
+  storeQualityScan({ specBase, cwd, changeName, testResult: testCheck, lintResult: lintCheck, smokeResult, coverageCheck, usedSnapshot: Boolean(snap), missReason: _missReasonParts.join('；') || null, scopeDecision: { planned: !process.env.SILLYSPEC_VERIFY_GATE_SNAPSHOT_OFF, actual: Boolean(snap) } })
   const testFailed = testCheck.status === 'failed'
   const lintBlocked = shouldBlockVerifyLint(lintCheck)
   // 摩擦计数（friction-signal-hint task-03）：记录条件与 throw 条件**刻意解耦**——advisory 档

package/src/scope-audit.js

@@ -237,12 +237,26 @@ function resolveDiffRoot(sb, changeName, form, cwd) {
 }
 
 /**
- * execute --done 时点快照读取（归档记录态数据源）：结构即 computeFullFlowAudit 返回值 +
- * savedAt。读取链（quick-359a48f1）：变更目录 scope-audit.json（审计级，随归档入库）→
- * .runtime/scope-audit-<change>.json（存量兼容）→ null（调用方降级，不出伪数据）。
+ * 收口时点快照读取（归档记录态数据源）：结构即 computeFullFlowAudit 返回值 + savedAt。
+ * 读取链（2026-10-09-close-trace-single-set）：变更目录 change-patch.json 的 scopeAudit
+ * 子对象（单套新形态——顶级 patchSha256/patchStatus/savedAt 原位注入返回值，下游回放
+ * 注记与 getFileDiff 防篡改锚口径不变）→ 旧 scope-audit.json（存量归档）→ .runtime/
+ * scope-audit-<change>.json（更早存量兼容）→ null（调用方降级，不出伪数据）。
  */
 function readScopeSnapshot(changeDir, runtimeRoot, changeName) {
   if (changeDir) {
+    try {
+      const merged = JSON.parse(readFileSync(join(changeDir, 'change-patch.json'), 'utf8'))
+      if (merged && typeof merged === 'object' && merged.scopeAudit && typeof merged.scopeAudit === 'object'
+        && Array.isArray(merged.scopeAudit.rows)) {
+        return {
+          ...merged.scopeAudit,
+          ...(merged.patchSha256 ? { patchSha256: merged.patchSha256 } : {}),
+          ...(merged.patchStatus ? { patchStatus: merged.patchStatus } : {}),
+          ...(merged.savedAt ? { savedAt: merged.savedAt } : {}),
+        }
+      }
+    } catch { /* 新形态缺失/损坏 → 旧名兜底 */ }
     try {
       const snap = JSON.parse(readFileSync(join(changeDir, 'scope-audit.json'), 'utf8'))
       if (snap && typeof snap === 'object' && Array.isArray(snap.rows)) return snap
@@ -255,18 +269,6 @@ function readScopeSnapshot(changeDir, runtimeRoot, changeName) {
   return null
 }
 
-/**
- * 冻结 patch 读取（审计级存储，--file 已收尾切片的数据源）：变更目录 scope-audit.patch。
- * @returns {string|null}
- */
-function readFrozenPatch(changeDir) {
-  if (!changeDir) return null
-  try {
-    const text = readFileSync(join(changeDir, 'scope-audit.patch'), 'utf8')
-    return text && text.trim() ? text : null
-  } 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
@@ -846,10 +848,19 @@ async function computeFullFlowAudit({ cwd, specBase, changeName, platformOpts, c
   // 审查 C-F02：预执行判定必须排除归档（归档=流程走完，58/77 归档变更三信号全缺被误判
   // 「未执行」实证——tag 只在分支被 review 引用时才打）+ 补四类证据：快照文件本身 /
   // execute-runs change 戳（task-review readExecuteRunChangeStamp 同口径）/ apply-pathspec /
-  // execute-cleanup 回执。任一命中 = 进过 execute。
-  const hasSnapshotFile = changeDirInfo
-    ? existsSync(join(changeDirInfo.dir, 'scope-audit.json')) || existsSync(join(runtimeRoot, `scope-audit-${changeName}.json`))
-    : existsSync(join(runtimeRoot, `scope-audit-${changeName}.json`))
+  // execute-cleanup 回执。任一命中 = 进过 execute。快照存在性（2026-10-09-close-trace-
+  // single-set）：新形态读 change-patch.json 的 scopeAudit 子对象（非文件裸存在——旧 thin
+  // 冻结件无子对象不误判），旧形态 scope-audit.json / .runtime 快照照旧。
+  const hasMergedScopeAudit = changeDirInfo ? (() => {
+    try {
+      const merged = JSON.parse(readFileSync(join(changeDirInfo.dir, 'change-patch.json'), 'utf8'))
+      return !!(merged && typeof merged === 'object' && merged.scopeAudit && typeof merged.scopeAudit === 'object')
+    } catch { return false }
+  })() : false
+  const hasSnapshotFile = hasMergedScopeAudit
+    || (changeDirInfo
+      ? existsSync(join(changeDirInfo.dir, 'scope-audit.json')) || existsSync(join(runtimeRoot, `scope-audit-${changeName}.json`))
+      : existsSync(join(runtimeRoot, `scope-audit-${changeName}.json`)))
   const hasApplyPathspec = existsSync(join(runtimeRoot, `apply-pathspec-${changeName}.txt`))
   const hasCleanupReceipt = existsSync(join(runtimeRoot, `execute-cleanup-${changeName}.json`))
   let hasExecuteRunStamp = false
@@ -1575,19 +1586,34 @@ export async function getFileDiff({ cwd, specBase, changeName, platformOpts, fil
     }
 
     // —— 真·当时内容比对（quick-359a48f1）：已收尾变更优先冻结 patch 切片 ——
-    // ① quick 记录态自带 frozenPatchPath；② full-flow 变更目录 scope-audit.patch。
+    // ① quick 记录态自带 frozenPatchPath；② full-flow 变更目录 change.patch（单套新形态，
+    // 2026-10-09-close-trace-single-set）→ scope-audit.patch（存量 heavy 归档兜底）。
     // patch 冻结在收尾时点，不含后续演进——实时锚 diff 只作 patch 缺失的兜底（口径标注）。
     // A-F01：读取时按 json 记录的 patchSha256 校验，不匹配显式告警（防低级篡改）。
     const patchRecord = result.frozenPatchPath
       ? { path: result.frozenPatchPath, sha: result.patchSha256 || null }
-      : (() => { const d = resolveChangeDir(sb, changeName); return d ? { path: join(d.dir, 'scope-audit.patch'), sha: null } : null })()
+      : (() => {
+          const d = resolveChangeDir(sb, changeName)
+          if (!d) return null
+          for (const name of ['change.patch', 'scope-audit.patch']) {
+            const p = join(d.dir, name)
+            if (existsSync(p)) return { path: p, sha: null }
+          }
+          return null
+        })()
     let recordedSha = patchRecord ? patchRecord.sha : null
     if (patchRecord && !recordedSha && result.rows) {
-      // json 里未直接带回 hash（记录态捷径不透传）→ 读 json 原文取（快照/quick 记录都存该字段）
+      // json 里未直接带回 hash（记录态捷径不透传）→ 读 json 原文取（快照/quick 记录都存该
+      // 字段）。full-flow 伴生 json：change-patch.json（新形态顶级键）优先，旧形态 heavy
+      // 归档（无 change-patch.json）兜底读 scope-audit.json。
       try {
-        const snapRaw = JSON.parse(readFileSync(result.frozenPatchPath
+        const d = resolveChangeDir(sb, changeName)
+        const companionPath = result.frozenPatchPath
           ? result.frozenPatchPath.replace(/\.patch$/, '.json')
-          : join(resolveChangeDir(sb, changeName).dir, 'scope-audit.json'), 'utf8'))
+          : (d && existsSync(join(d.dir, 'change-patch.json'))
+              ? join(d.dir, 'change-patch.json')
+              : join(d.dir, 'scope-audit.json'))
+        const snapRaw = JSON.parse(readFileSync(companionPath, 'utf8'))
         recordedSha = snapRaw.patchSha256 || null
       } catch { /* json 不可读 → 无 hash 可校验（null=不校验） */ }
     }

package/src/sentinel-assertions.js

@@ -25,6 +25,24 @@ function taskTokenRe(id) {
   return new RegExp(`${id}(?!\\d)`);
 }
 
+/**
+ * 提交消息连写 token 组展开（坑 flow-done-sentinel-token-split，2026-10-08 实证）：
+ * `task-01/02/03`、`task-1、2，03` 等自然语言连写组只含首个完整 token——字面匹配判
+ * 其余为零完成证据误拒收。展开为独立规范 token（补零到两位，与判集行锚同形）后再判；
+ * 尾数不跟数字（防 task-013 版本串误切）。纯函数，供哨兵判定与 autopilot 勾选提取共用。
+ */
+export function expandTaskShorthand(messages) {
+  return (Array.isArray(messages) ? messages : []).map((msg) =>
+    String(msg ?? '').replace(
+      /task-(\d{1,2})((?:\s*[\/、，,；;]\s*\d{1,2}(?!\d))+)/gi,
+      (full, first, rest) =>
+        ' ' + [first, ...(rest.match(/\d{1,2}/g) || [])]
+          .map((n) => `task-${String(Number(n)).padStart(2, '0')}`)
+          .join(' ') + ' '
+    )
+  );
+}
+
 /**
  * review.json 在场证据清单（execute-runs 两级遍历；异常/缺失 → []，commit 证据照判）。
  */
@@ -84,11 +102,13 @@ export function detectFakeCheckCompletion({ changeDir, tasksMd, commits, opts =
     return { status: 'none', claimTotal, checked, missing: [] };
   }
   const reviews = listReviewEvidence(changeDir, opts);
+  // 连写组先展开（坑 flow-done-sentinel-token-split）：task-01/02/03 → 独立 token 再字面判
+  const expanded = expandTaskShorthand(messages);
   const missing = entries
     .filter((e) => {
       if (!e.checked) return false;
       const re = taskTokenRe(e.id);
-      const byCommit = messages.some((msg) => re.test(msg));
+      const byCommit = expanded.some((msg) => re.test(msg));
       const byReview = reviews.some((p) => p.includes(`/tasks/${e.id}/`));
       return !(byCommit || byReview);
     })
@@ -109,7 +129,12 @@ export function detectFakeCheckCompletion({ changeDir, tasksMd, commits, opts =
 export function detectBatchCheckCadence(events) {
   const taskEvents = [];
   for (const e of events || []) {
-    if (e && e.kind === 'task-done') taskEvents.push(e);
+    if (!e || e.kind !== 'task-done') continue;
+    // 节奏域过滤（2026-10-08-batch-tick-false-positive）：只认任务队列面（stage='tasks'，缺省
+    // 视同 tasks 兼容 legacy 流）。其他阶段的 task-done（如 design.md 自审预勾的首现计数）不是
+    // tick 信号——混入会把逐格勾选误判成单拍大跳（实证：design 0→8 拒收六次独立 tick）。
+    if (e.stage != null && e.stage !== 'tasks') continue;
+    taskEvents.push(e);
   }
   const parse = (e) => {
     const m = /^checked (\d+)→(\d+)$/.exec(String(e.detail || ''));

package/src/spec-sync.js

@@ -463,6 +463,94 @@ function clearSpecConflictMarker(specRoot, changeName) {
   } catch { /* 清理失败不影响同步结果 */ }
 }
 
+// ── 2026-10-09-tombstone-conflict-root-fix FR-01：纯墓碑拒收按被删变更归因记账 ──
+// 背景（91 条实证）：整树同步被墓碑整批拒收时按「当轮同步标签」落冲突文件——一个
+// 根因（changes/salv 两路径）伪装成 91 个变更的冲突；该批变更归档后永不再以同名
+// 同步成功，clearSpecConflictMarker 永远轮不到 → 记录单调累积。归因记账：从
+// platform_deleted 路径剥被删变更名（真凶），每被删变更一条记录幂等维护。
+
+/**
+ * 从 platform_deleted 路径剥被删变更名：活跃区 changes/<name>/… 与归档区
+ * changes/archive/<name>/… 两前缀；剥不出的路径归 __unattributed__ 聚合桶
+ * （正常不出现——守卫只对 changes/ 前缀写墓碑；出现即提示人工核查）。
+ */
+export function extractTombstonedChanges(platformDeleted) {
+  const byChange = new Map();
+  for (const p of platformDeleted) {
+    let name = '__unattributed__';
+    const m = typeof p === 'string' ? p.match(/^changes\/(?:archive\/)?([^/]+)\//) : null;
+    if (m) name = m[1];
+    const list = byChange.get(name) || [];
+    list.push(p);
+    byChange.set(name, list);
+  }
+  return byChange;
+}
+
+/**
+ * 归因记账落盘（幂等合并）：spec-sync-conflict-<被删变更>.json，created_at 首见
+ * 保持、platform_deleted 路径并集、last_seen 每轮刷新；kind='tombstone' 供
+ * progress show / daemon 摘要按形态区分（stage-machine 优先读 kind 透传 type）。
+ * 返回 { byChange, written } 供横幅单根因叙事。
+ */
+export function writeTombstoneAttribution(specRoot, platformDeleted) {
+  const byChange = extractTombstonedChanges(platformDeleted);
+  const written = [];
+  for (const [name, paths] of byChange) {
+    const filePath = join(specRoot, '.runtime', `spec-sync-conflict-${name}.json`);
+    let prev = null;
+    try { prev = JSON.parse(readFileSync(filePath, 'utf8')); } catch { /* 首见 */ }
+    const record = {
+      change: name,
+      kind: 'tombstone',
+      created_at: (prev && prev.created_at) || new Date().toISOString(),
+      last_seen: new Date().toISOString(),
+      server_versions: {},
+      conflicting_paths: [],
+      platform_deleted: [...new Set([...((prev && prev.platform_deleted) || []), ...paths])],
+      note: '路径被平台删除墓碑拒收（非版本冲突，resolve 重推无效）。恢复通道：平台 manifest-heal 清墓碑后重推；或平台删除变更时 tombstone_cleanup 收敛本机目录（.runtime/tombstone-quarantine/ 隔离区）。',
+    };
+    try {
+      mkdirSync(join(specRoot, '.runtime'), { recursive: true });
+      writeFileSync(filePath, JSON.stringify(record, null, 2) + '\n', 'utf8');
+      written.push(filePath);
+    } catch (e) {
+      console.warn(`[spec-sync] 墓碑冲突文件写入失败（信息仅打印）: ${e.message}`);
+    }
+  }
+  return { byChange, written };
+}
+
+/**
+ * 全绿同步清陈旧纯墓碑记录（2026-10-09 FR-01）：判定式 = conflicting_paths 为空
+ * 且 platform_deleted 非空（kind 无关——覆盖 kind:'tombstone'、现行 kind:'spec-tree'
+ * 纯墓碑与存量旧格式 91 条）；混合形态（conflicting_paths 非空）永不清理。返回
+ * 清理条数。挂在两个全绿点：POST 成功无冲突分支与无差异跳过分支。
+ */
+export function clearStaleTombstoneMarkers(specRoot) {
+  const runtimeDir = join(specRoot, '.runtime');
+  let files = [];
+  try { files = readdirSync(runtimeDir); } catch { return 0; }
+  let cleared = 0;
+  for (const f of files) {
+    if (!f.startsWith('spec-sync-conflict-') || !f.endsWith('.json')) continue;
+    const p = join(runtimeDir, f);
+    try {
+      const j = JSON.parse(readFileSync(p, 'utf8'));
+      const cp = Array.isArray(j.conflicting_paths) ? j.conflicting_paths : null;
+      const pd = Array.isArray(j.platform_deleted) ? j.platform_deleted : null;
+      if (cp !== null && cp.length === 0 && pd !== null && pd.length > 0) {
+        unlinkSync(p);
+        cleared++;
+      }
+    } catch { /* 损坏文件不动 */ }
+  }
+  if (cleared > 0) {
+    console.log(`[spec-sync] 全绿同步清理 ${cleared} 条陈旧墓碑冲突记录（被删变更已收敛）`);
+  }
+  return cleared;
+}
+
 // follower/stale 提示的跨轮去重（坑 spec-sync-follow-banner-spam，2026-09-08 用户反馈③）：
 // 「N 个本地未改动文件自动跟随服务器」的信息只在集合**首次出现/变化**时有价值。基线快照锚定
 // local-at-last-sync（见 writeBaseSnapshot 注释），本地落后于服务器的文件每轮都重新算出同样的
@@ -584,6 +672,7 @@ export async function syncSpecTree(specRoot, platform, changeName, opts = {}) {
 
   if (ops.length === 0) {
     debugLog(`[spec-sync] 无差异，跳过同步: ${changeName}`);
+    clearStaleTombstoneMarkers(specRoot);
     return { synced: 0 };
   }
 
@@ -634,27 +723,15 @@ export async function syncSpecTree(specRoot, platform, changeName, opts = {}) {
       // 纯墓碑形态：版本冲突面为空、拒收全是墓碑 → 不写/不清通用冲突标记（clear 会把
       // 状态洗成「已消解」误导 status），单独落冲突文件 + 正确恢复指引。
       if (realPaths.length === 0 && tombstoned.length > 0) {
-        let tombConflictPath = null;
-        try {
-          const runtimeDir = join(specRoot, '.runtime');
-          mkdirSync(runtimeDir, { recursive: true });
-          tombConflictPath = join(runtimeDir, `spec-sync-conflict-${changeName}.json`);
-          writeFileSync(tombConflictPath, JSON.stringify({
-            change: changeName,
-            kind: 'spec-tree',
-            created_at: new Date().toISOString(),
-            server_versions: {},
-            conflicting_paths: [],
-            platform_deleted: tombstoned,
-            note: '路径被平台删除墓碑拒收（非版本冲突，resolve 重推无效）。恢复通道：平台 manifest-heal 清墓碑后重推，或联系管理员确认删除是否有意。',
-          }, null, 2) + '\n', 'utf8');
-        } catch (e) {
-          console.warn(`[spec-sync] 墓碑冲突文件写入失败（信息仅打印）: ${e.message}`);
-        }
+        // 归因记账（2026-10-09 FR-01）：按被删变更落 spec-sync-conflict-<被删变更>.json
+        // （不再用当轮同步标签——91 条累积根因），幂等合并；横幅按被删变更单根因叙事。
+        const { byChange, written } = writeTombstoneAttribution(specRoot, tombstoned);
         console.warn('');
-        console.warn(`⚠️ [spec-sync] ${tombstoned.length} 个路径被平台删除墓碑拒收（非版本冲突，resolve --keep-local 重推无效）: ${tombstoned.slice(0, 5).join(', ')}${tombstoned.length > 5 ? ' 等' : ''}`);
-        console.warn(`⚠️ 恢复通道：平台 manifest-heal（清墓碑后重推即闭环）；详情: ${tombConflictPath || '(写入失败)'}`);
-        return { synced: 0, conflict: true, serverVersions: {}, tombstoned, conflictPath: tombConflictPath };
+        for (const [name, paths] of byChange) {
+          console.warn(`⚠️ [spec-sync] 变更 ${name} 被平台删除墓碑拒收（${paths.length} 个路径，非版本冲突，resolve --keep-local 重推无效）: ${paths.slice(0, 5).join(', ')}${paths.length > 5 ? ' 等' : ''}`);
+        }
+        console.warn(`⚠️ 恢复通道：平台 manifest-heal（清墓碑后重推即闭环）或 tombstone_cleanup 收敛本机目录；详情: ${written.join(', ') || '(写入失败)'}`);
+        return { synced: 0, conflict: true, serverVersions: {}, tombstoned, conflictPath: written[0] || null, tombstonedChanges: [...byChange.keys()] };
       }
       const tombNote = tombstoned.length > 0
         ? `\n⚠️ 另有 ${tombstoned.length} 个路径被平台删除墓碑拒收（非版本冲突，resolve 无效；恢复走平台 manifest-heal）: ${tombstoned.slice(0, 5).join(', ')}${tombstoned.length > 5 ? ' 等' : ''}`
@@ -717,6 +794,7 @@ export async function syncSpecTree(specRoot, platform, changeName, opts = {}) {
     // 本轮无冲突 = 此前的未决 spec 树冲突已不存在，清残留标记（否则 status 永久红标、
     // 横幅去重单行提示不消——坑 spec-sync-conflict-banner-spam）
     clearSpecConflictMarker(specRoot, changeName);
+    clearStaleTombstoneMarkers(specRoot);
     writeLastSyncTs(specRoot);
     writeBaseSnapshot(specRoot, localFiles);
     return { synced: ops.length };

package/src/stages/brainstorm.js

@@ -220,6 +220,7 @@ sillyspec flow start --change <YYYY-MM-DD-名> --input "<动机与背景>
 3. 定稿前机制词检索（固定动作）：方案引入新机制词（如 分类/词表/枚举/门/协议/状态机——例词为举例非机制，不构成封闭清单）时，先跑 \`sillyspec knowledge search --query "<机制词>"\`，命中条目必读（尤其 status=rejected 的防复潮条目）再定稿方案
 4. 给出推荐方案和理由
 5. 用户选定方案后，把选择结果**当场追加**到 \`{SPEC_ROOT}/changes/<change-name>/decisions.md\`（增量落盘规则同「对话式探索」步：目录/文件缺失先创建、按 D-xxx@vN 判重）：type 用 architecture、source 用 user、question 记方案取舍问题、answer 记用户所选方案与理由要点、evidence 记方案选择轮次——方案选择是本变更最关键的用户决策，必须随答随落盘，不能只留在对话里
+6. 落选方案**各记一条 rejected 条目**（防复潮——蒸馏链 rejected 通道与 knowledge 否决注入只认独立条目，落选理由埋在所选方案 answer 散文里进不了通道）：question 复用同一取舍问句，type 用 architecture、status 用 rejected，否决理由记该方案当轮的劣势与成本，复潮条件记劣势消解或成本反转的前提（如「依赖 X 下线」「改动面降到 Y 以下」）——两字段必填性见「写设计文档」步对账规则
 
 ### 铁律 — 必须等待用户选择方案
 - 列出方案对比表和推荐后必须暂停等用户选择，**不要自己说"推荐方案 A"然后当用户选了**（命令由 CLI 在下方注入）
@@ -382,7 +383,7 @@ design.md 第一行标题必须用中文：# 设计文档（Design）— <变更
    - decisions.md 是本次变更的决策台账，不是长期术语表
    - 只记录有实现/验收影响的决策，闲聊和低风险偏好不记录
    - 已落盘条目按 D-xxx@vN 判重，不重复追加；补全缺失的九字段与可选字段
-   - 前序遗漏未落盘、确有实现影响的决策（增量规则漏网的），此时补写；每条记录必须有稳定版本 ID：D-001@v1、D-002@v1 ...
+   - 前序遗漏未落盘、确有实现影响的决策（增量规则漏网的），此时补写；每条记录必须有稳定版本 ID：D-001@v1、D-002@v1 ...；放弃方案属此类——「提出方案」步的落选方案若未各记 rejected 条目（否决理由/复潮条件必填），此时补记
    - 若后续 Design Grill 修正该决策，新记录使用 D-001@v2，并写明 supersedes: D-001@v1
    - 每条记录必须包含：type、status、source、question、answer、normalized_requirement、impacts、evidence、priority
    - 九字段之外可另加四个可选字段，按需填写、不强制全填（旧格式决策记录缺这些字段不受影响）：

package/src/stages/cmd-existence.js

@@ -18,7 +18,11 @@ import { join, isAbsolute } from 'path'
 // 提取 `npm|pnpm|yarn run <script>` 命令。
 // 对齐 scan-postcheck:136 的 `/npm run (\S+)/g`，扩展包管理器 + 容忍多空白。
 // 捕获组 1 = 包管理器（npm|pnpm|yarn），捕获组 2 = script 名。
-const SCRIPT_CMD_RE = /(npm|pnpm|yarn)\s+run\s+(\S+)/g
+// script 名收敛为合法字符集（2026-10-09-verify-papercuts ①）：原 \S+ 会把紧跟的全角标点
+// （；。，等）/句读拼进 script 名——『verify: npm run test；模块卡 diff 一致』被提取为
+// script=test；模块卡 → 误报「命令不存在」逼 agent 改写法（plan postcheck 实证多跑 3 轮）。
+// npm script 名本身只含字母数字与 : _ - .，按此截断即安全（&& / | / 全角标点自然止步）。
+const SCRIPT_CMD_RE = /(npm|pnpm|yarn)\s+run\s+([A-Za-z0-9:_.\-]+)/g
 
 // 识别紧贴命令前的 `cd <subdir> &&` 前缀（anchored at end of the slice before the command）。
 // subdir token 不含空白与 & ; | 等分隔符；末尾的 `&&` 可带任意空白后接命令。

package/src/stages/explore.js

@@ -15,7 +15,11 @@ export const definition = {
    - \`.sillyspec/docs/<project>/scan/ARCHITECTURE.md\`
    - \`.sillyspec/docs/<project>/scan/CONVENTIONS.md\`
    - \`.sillyspec/changes/<change-name>/design.md\`
-3. 可以用 \`rg\` / \`ls\` / \`cat\` 调查已有结构和集成点
+3. 调查兵器按话题选（话题→兵器映射，全只读）：
+   - 词面考古（"这段代码在哪/怎么写的"）→ \`rg\` / \`ls\` / \`cat\`
+   - 坑史检索（"这话题以前踩过什么坑"）→ \`sillyspec knowledge search --query "<关键词>"\`（四层召回）
+   - 关系面（影响面/历史决策/需求谱系）→ \`sillyspec knowledge graph impact <文件|模块|变更名>\` 多跳闭包与防复潮可达的已否决决策、\`neighbors <锚点>\` / \`path <A> <B>\` 推理链、\`summary\` 知识面健康度——比较方案前先看 impact 的 rejected/⚰️死路条目，已否决的路不重新兜售；全部支持 \`--json\`
+   - 在途面（出方向建议前）→ \`sillyspec status\` 活跃变更一览——结论别跟在途工作撞车
 4. 输出 2-3 个有价值方向、关键风险和下一步建议
 5. 如果用户要求保存结论，先明确保存位置，再写入对应文档
 6. 讨论 UI/交互方案且用户明确要求原型时，按下方「HTML 原型生成」执行

package/src/stages/knowledge.js

@@ -609,6 +609,16 @@ export async function cmdKnowledge(args, dir, opts = {}) {
       return cmdRefresh(dir, args.slice(1), opts)
     case 'propose':
       return cmdPropose(dir, args.slice(1), opts)
+    case 'graph': {
+      // 知识图谱查询面（2026-10-08-knowledge-graph）：neighbors/path/impact/orphans/dangling，
+      // --edges 边型筛选；全 JSON 出口（与 search/validate 同族）。
+      const mod = await tryImportSubcommandImpl('../knowledge-graph.js', 'knowledge-graph.js')
+      if (!mod || typeof mod.cmdKnowledgeGraph !== 'function') {
+        output(false, {}, { code: 'not_implemented', subcommand: 'graph' })
+        return
+      }
+      return mod.cmdKnowledgeGraph(dir, args.slice(1), opts)
+    }
     case 'classify': {
       const mod = await tryImportSubcommandImpl('../knowledge-classify.js', 'knowledge-classify.js')
       if (!mod || typeof mod.cmdKnowledgeClassify !== 'function') {
@@ -665,7 +675,7 @@ export async function cmdKnowledge(args, dir, opts = {}) {
       output(false, {}, {
         code: 'unknown_subcommand',
         subcommand: subCommand,
-        available: ['search', 'inspect', 'validate', 'refresh', 'propose', 'classify', 'inbox', 'stats', 'digest'],
+        available: ['search', 'inspect', 'validate', 'refresh', 'propose', 'classify', 'inbox', 'stats', 'digest', 'graph'],  // dump 随 graph 路由面（2026-10-09-graph-dump-layout）
       })
   }
 }

package/src/test-bindings.js

@@ -157,6 +157,8 @@ export function normalizeRow(row, opts = {}) {
     confirmed_at: row.confirmed_at && row.confirmed_at !== 'null' ? row.confirmed_at : null,
     reconfirm: ['unchanged', 'rebound'].includes(row.reconfirm) ? row.reconfirm : null,
     status: row.status === 'superseded' ? 'superseded' : 'active',
+    // FR-06（2026-10-09-verify-reuse-friction）：行 repo 归属（additive，缺省不落键=主仓）
+    ...(row.repo && row.repo !== 'main' ? { repo: String(row.repo) } : {}),
     source_change: row.source_change && row.source_change !== 'null' ? row.source_change : null,
   }
 }