sillyspec 3.31.0 → 3.32.1

package/src/flow-parity.js

@@ -10,13 +10,21 @@
  *    厚道有轻量变更缺的审计资产；机器合成勿手改。
  * ③ harvestSlot4Decision：design 槽4（风险与死路）实质作答收割合成 decisions.md——轻量变更决策
  *    产出为零的补口（死路与风险取舍正是 decisions.md 该记的内容；已有文件不覆盖）。
+ * ④ writeCloseTraceArtifacts / buildThinSnapshotRows：双通道收尾留痕统一写
+ *    （2026-10-07-unify-close-trace）——thin flow done 与 heavy execute --done 共用一处一次
+ *    写齐四件（沉淀资产面 + 对账快照面，sha256 双套同锚），新变更两通道留痕对称。
  */
 import { existsSync, readFileSync, writeFileSync, readdirSync } from 'node:fs'
 import { join, relative } from 'node:path'
+import { createHash } from 'node:crypto'
 import { execFileSync } from 'node:child_process'
-import { splitOwnVsForeignDiffFiles } from './foreign-declared.js'
+import { splitOwnVsForeignDiffFiles, commitAttributionForChange, isForeignByCommit, parseChangeNamesFromSubject } from './foreign-declared.js'
 import { collectModuleMaps, normalizeMapPath } from './module-resolve.js'
 import { writeAtomicSync } from './fs-atomic.js'
+import { readV2SectionAnswer } from './flow-review.js'
+import { DESIGN_QUESTIONS } from './flow-draft.js'
+import { pathMatches } from './change-list.js'
+import { classifyToolScaffold, filterDeliverableFiles } from './worktree-apply.js'
 
 /**
  * 模块文档对账（advisory）+ 结构化落盘面（2026-09-27-thin-module-scope-persist）。
@@ -144,7 +152,13 @@ export function harvestSlot4Decision({ changeDir, change }) {
     if (inSlot && (/^<!--/.test(line) || /^#{1,6}\s/.test(line))) break
     if (inSlot) buf.push(line)
   }
-  const answer = buf.join('\n').trim()
+  let answer = buf.join('\n').trim()
+  // v2 纯 markdown（2026-10-04-thin-docs-v2）：无槽标记时改读「风险与死路」节正文（复用
+  // flow-review 的 v2 节读取——剥离问题原文行；单一源 DESIGN_QUESTIONS 防镜像漂移）
+  if (!inSlot) {
+    const risksSec = DESIGN_QUESTIONS.sections.find((s) => s.key === 'risks')
+    answer = readV2SectionAnswer(dText, risksSec.heading, DESIGN_QUESTIONS)
+  }
   if (!answer || /^不适用/.test(answer)) return { harvested: false, reason: '槽4 空/不适用' }
   const text = [
     '---',
@@ -177,11 +191,61 @@ export default { reconcileModuleDocs, renderVerifyReceipt, harvestSlot4Decision,
  * 非 .sillyspec/ 全留 + 本变更目录（治理工件）+ .sillyspec/docs/ 交付文档（dogfood 模块卡
  * 是交付物——2026-09-27-gate-docs-cleanup 评审 P2 实证旧口径把已提交模块卡漏出审计 patch）。
  * 他侧 .sillyspec/changes/**（quicklog/knowledge WIP）仍滤除。反斜杠归一。
+ *
+ * 提交事实归属补位（2026-10-05-diff-commit-attribution）：现状「已提交即本变更的」前提是
+ * 单会话——多会话共享仓 baseline..HEAD 混入他侧交付（评审 P2 实证：他会话 knowledge-stats
+ * hunk 冻进本变更审计件）。在现状过滤后剔除「窗口内全部提交均属他侧变更名」的交付文件。
+ * 与否决决策 sentinel-evidence-freeze⑤ 的分界：按提交 message 变更名（既成事实）切，不按
+ * 任何变更的声明清单（该决策禁的是陈旧声明的意图抢夺）。best-effort：变更名自 ownPrefix
+ * 反解，baseline 自 flow-state.yaml 读取；不可得（非 git 仓/无 flow-state/git 失败/归档后
+ * 目录已移走）= 行为与旧版完全一致。保守：被无后缀裸提交触碰过的文件不剔（fail-closed）。
  */
-export function filterCommittedFace(committedRaw, ownPrefix) {
-  return committedRaw
+export function filterCommittedFace(committedRaw, ownPrefix, opts = {}) {
+  const base = committedRaw
     .map((f) => String(f).replace(/\\/g, '/'))
     .filter((p) => !p.startsWith('.sillyspec/') || p.startsWith(ownPrefix) || p.startsWith('.sillyspec/docs/'))
+  try {
+    const cwd = opts.cwd || process.cwd()
+    const pm = /^\.sillyspec\/changes\/([^/]+)\/$/.exec(String(ownPrefix || ''))
+    if (!pm) return base
+    const specBase = opts.specBase || join(cwd, '.sillyspec')
+    const attr = commitAttributionForChange(cwd, specBase, pm[1], opts.baselineCommit || null)
+    if (!attr) return base
+    return base.filter((p) => {
+      if (p.startsWith('.sillyspec/')) return true // 治理面归属已由上方现状口径裁决
+      return !isForeignByCommit(attr.get(p), pm[1])
+    })
+  } catch { return base }
+}
+
+/**
+ * patch 冻结面漂移检测（2026-10-05-disposition-refreeze-drift，主清单 P1）：处置重入审计
+ * 错位——评审发现处置涉及代码修改后重跑 flow done，patch 子步幂等跳过让 change.patch/
+ * review.json 停在处置前时点（2026-10-05-review-promise-negation 先例 905397ef；
+ * 2026-10-05-flowdone-lintfail-output 收编活体复现：评审 P1 处置提交后不带 --refreeze 重跑，
+ * 归档件缺处置面）。
+ *
+ * 判定：freezeHead（change-patch.json.head 冻结锚）..HEAD 窗口内存在「本变更名后缀提交」即
+ * 漂移——按提交 message 变更名归属（parseChangeNamesFromSubject，与 filterCommittedFace
+ * 同口径的既成事实切分，非声明抢文件）。仅他侧后缀/裸提交不触发（他侧面归属切分另有防线，
+ * 裸提交保守不动作）。检测自身失败按无漂移（退现状幂等跳过行为，fail-safe 不新造阻断面）。
+ * @param {{ cwd: string, change: string, freezeHead: string|null }} opts
+ * @returns {{ drifted: boolean, ownCommits: string[], head: string|null }} ownCommits=本变更后缀提交的 subject 列表（截 80 字）
+ */
+export function detectPatchDrift({ cwd, change, freezeHead }) {
+  try {
+    if (!freezeHead) return { drifted: false, ownCommits: [], head: null }
+    const head = execFileSync('git', ['rev-parse', 'HEAD'], { cwd, encoding: 'utf8', timeout: 30000, windowsHide: true }).trim()
+    if (!head || head === freezeHead) return { drifted: false, ownCommits: [], head }
+    const log = execFileSync('git', ['log', '--format=%x00%s', `${freezeHead}..HEAD`], { cwd, encoding: 'utf8', timeout: 30000, windowsHide: true })
+    const own = []
+    for (const block of String(log).split('\x00')) {
+      const subject = block.split('\n').map((l) => l.trim()).filter(Boolean)[0]
+      if (!subject) continue
+      if (parseChangeNamesFromSubject(subject).includes(change)) own.push(subject.slice(0, 80))
+    }
+    return { drifted: own.length > 0, ownCommits: own, head }
+  } catch { return { drifted: false, ownCommits: [], head: null } }
 }
 
 /**
@@ -194,7 +258,11 @@ export function collectFreezeFiles({ cwd, specBase, change, committed, exclusive
   const deliverable = (f) => !String(f).replace(/\\/g, '/').startsWith('.sillyspec/')
   let dirty = []
   try {
-    const out = execFileSync('git', ['status', '--porcelain'], { cwd, encoding: 'utf8', timeout: 30000, windowsHide: true })
+    // -uall（2026-10-08-thin-done-dirty-gate-and-paren-attribution）：全新目录会折叠成
+    // `dir/` token（porcelain 缺省形态）——readFileSync(目录) 静默 skip，--freeze-dirty
+    // 声称并入却漏目录内交付文件（dg-freeze 夹具实证 src/ 折叠）。逐文件展开与
+    // scope-audit/flow.js 状态采集口径对齐。
+    const out = execFileSync('git', ['status', '--porcelain', '--untracked-files=all'], { cwd, encoding: 'utf8', timeout: 30000, windowsHide: true })
     for (const line of String(out).split('\n')) {
       if (!line || line.length < 4) continue
       const p = line.slice(3).trim().replace(/^"|"$/g, '')
@@ -214,6 +282,132 @@ export function collectFreezeFiles({ cwd, specBase, change, committed, exclusive
   return { files: [...committed], dirtyAdded: [], dirtyWarned: ownDirty }
 }
 
+/**
+ * thin 通道三态行构造（writeCloseTraceArtifacts 的 snapObj.rows 数据源，纯函数）：
+ * ownFiles 过 filterDeliverableFiles（与 scope-audit actual 侧同口径——治理工件目录不进
+ * 快照行）× design 清单 pathMatches 判三态（planned/unplanned；与主链路三态判定同款）；
+ * stats（collectNumstatByPath 产物 Map）缺档落 null 行数（不出伪数据）；planEntries 空/缺省
+ * → 实际侧 only 行（无 verdict，与主链路计划侧降级同语义）。清单条目未命中冻结面 →
+ * untouched 0/0 补行（跨仓条目带 crossRepo 保持 ⊘ 形态，主链路补行同语义）。
+ * @returns {{ rows: Array<object>, totals: { files: number, additions: number, deletions: number } }}
+ */
+export function buildThinSnapshotRows({ ownFiles, stats, planEntries }) {
+  const plan = Array.isArray(planEntries) ? planEntries : []
+  const statMap = stats instanceof Map ? stats : new Map()
+  const rowFiles = filterDeliverableFiles([...new Set((Array.isArray(ownFiles) ? ownFiles : [])
+    .map((f) => String(f).replace(/\\/g, '/')).filter(Boolean))]).sort()
+  const rows = []
+  const matched = new Set()
+  for (const f of rowFiles) {
+    const st = statMap.get(f) || {}
+    const row = {
+      path: f,
+      additions: Number.isFinite(st.additions) ? st.additions : null,
+      deletions: Number.isFinite(st.deletions) ? st.deletions : null,
+      kind: st.kind || 'modified',
+    }
+    if (plan.length > 0) {
+      const entry = plan.find((e) => e && pathMatches(f, e.path))
+      if (entry) {
+        matched.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
+      }
+    }
+    rows.push(row)
+  }
+  for (const e of plan) {
+    if (!e || matched.has(e.path)) continue
+    rows.push({
+      path: e.path, planned: e.operation || null, additions: 0, deletions: 0,
+      kind: 'modified', verdict: 'untouched',
+      ...(e.repo ? { crossRepo: e.repo } : {}),
+    })
+  }
+  let additions = 0
+  let deletions = 0
+  for (const r of rows) {
+    if (Number.isFinite(r.additions)) additions += r.additions
+    if (Number.isFinite(r.deletions)) deletions += r.deletions
+  }
+  return { rows, totals: { files: rows.length, additions, deletions } }
+}
+
+/**
+ * heavy 通道沉淀资产面投影（writeCloseTraceArtifacts 的 files/totals 数据源，纯函数；
+ * 2026-10-07-unify-close-trace，评审 P3 覆盖清偿抽纯函数）：rows → 主仓实改行——
+ * untouched 0/0 是声明不是改动、crossRepo 行 patch 不在主仓，均不入；verdict 缺失行
+ * （计划侧降级形态）按实改保留；null 行数不计合计（不出伪数据）。
+ * @returns {{ rows: object[], files: string[], totals: { files: number, additions: number, deletions: number } }}
+ */
+export function projectTraceFaceRows(rows) {
+  const face = (Array.isArray(rows) ? rows : [])
+    .filter((r) => r && typeof r === 'object' && !r.crossRepo && r.verdict !== 'untouched')
+  let additions = 0
+  let deletions = 0
+  for (const r of face) {
+    if (Number.isFinite(r.additions)) additions += r.additions
+    if (Number.isFinite(r.deletions)) deletions += r.deletions
+  }
+  return { rows: face, files: face.map((r) => r.path), totals: { files: face.length, additions, deletions } }
+}
+
+/**
+ * 双通道收尾留痕统一写（2026-10-07-unify-close-trace，缺陷 thin-flow-done-no-scope-
+ * audit-snapshot 修复方向③）：thin（flow done）与 heavy（execute --done）此前各写各的
+ * 留痕（沉淀资产面 change.patch/change-patch.json vs 对账快照面 scope-audit.patch/
+ * scope-audit.json），消费方各认一份致每类变更恰好一张卡失真——本函数一处写齐四件，
+ * sha256/patchStatus 双套同锚（同一 patchText 一次计算：change.patch ≡ scope-audit.patch
+ * 字节一致、两 json 同 hash，两套留痕不可能漂移）。patchText 空/null → 双套同标 failed、
+ * 不落 patch 文件（heavy 旧「空串当 ok」形态收口）。读侧兼容链（快照 > change-patch
+ * 回放 > 实时区间，2026-10-07-scope-audit-thin-patch-replay）不动——本函数让新变更两套
+ * 齐备，回退退化为存量归档兜底。
+ *
+ * @param {string} changeDir 变更目录（活跃或归档侧——归档竞态由调用方解析）
+ * @param {object} snapObj scope-audit.json 主体（mode/ok/degradedReason/baseAnchor/totals/
+ *   rows/excluded/note[/repos]；closedBy 由调用方携带标收尾通道——读侧回放按它标注，
+ *   缺省 'execute --done' 兼容旧快照）
+ * @param {object} meta change-patch.json 增量键（note/moduleScope 等，展开在 totals 后）
+ * @returns {{ patchStatus: 'ok'|'failed', patchSha256: string|null }}
+ */
+export function writeCloseTraceArtifacts({ changeDir, change, baseline, head, files, metaTotals, patchText, savedAt, snapObj, meta = {} }) {
+  const fileList = Array.isArray(files) ? files : []
+  const patchOk = typeof patchText === 'string' && patchText.length > 0
+  const patchBody = patchOk ? (patchText.endsWith('\n') ? patchText : patchText + '\n') : null
+  const patchSha256 = patchBody
+    ? createHash('sha256').update(patchBody.replace(/\r\n/g, '\n'), 'utf8').digest('hex')
+    : null
+  if (patchOk) {
+    writeFileSync(join(changeDir, 'change.patch'), patchBody)
+    writeFileSync(join(changeDir, 'scope-audit.patch'), patchBody)
+  }
+  writeFileSync(join(changeDir, 'change-patch.json'), JSON.stringify({
+    change,
+    baseline: baseline ?? null,
+    head: head ?? null,
+    files: fileList,
+    totals: metaTotals && typeof metaTotals === 'object'
+      ? metaTotals
+      : { files: fileList.length, additions: 0, deletions: 0 },
+    savedAt,
+    ...meta,
+    ...(patchSha256 ? { patchSha256 } : {}),
+    patchStatus: patchOk ? 'ok' : 'failed',
+  }, null, 2) + '\n')
+  writeFileSync(join(changeDir, 'scope-audit.json'), JSON.stringify({
+    ...snapObj,
+    ...(patchSha256 ? { patchSha256 } : {}),
+    patchStatus: patchOk ? 'ok' : 'failed',
+    savedAt,
+  }, null, 2) + '\n')
+  return { patchStatus: patchOk ? 'ok' : 'failed', patchSha256 }
+}
+
 /**
  * 实测面回填（修复③：ledger 子步断点续跑 skip 后回执不失忆）——从 verify-runs 最近
  * test-result.json（带 change 键）重建摘要；无匹配返回 null。

package/src/flow-review.js

@@ -18,6 +18,7 @@
  */
 import { existsSync, readFileSync } from 'node:fs'
 import { join } from 'node:path'
+import { DESIGN_QUESTIONS as DESIGN_QUESTIONS_FALLBACK } from './flow-draft.js'
 
 /** 高危交付语义承诺词（一票升级）。2026-09-25-platform-feedback-batch2 D 收敛：移除「幂等」
  * （实现手段非交付语义，由 diff 原语面覆盖）；保留的七个词均为面向用户的交付语义承诺。 */
@@ -26,8 +27,34 @@ const PROMISE_RE = /at[- ]least[- ]once|exactly[- ]once|不丢失|不重复|不
 /** adopted（头脑风暴预段）design 无槽时的机制词全文扫描（窄表防误报）。 */
 const MECHANISM_RE = /乱序|并发写|竞态|死锁|事务隔离|AbortSignal|多实例串|游标推进/
 
-/** 交付 diff 危险原语（物证面）。 */
-const PRIMITIVE_RE = /asyncio\.(?:Lock|Event|Queue|gather)|threading\.|with_for_update|IntegrityError|ON CONFLICT|AbortSignal|AbortController|signal\.abort|\.rollback\(|since=|\bcursor\b/i
+/** design 作答面否定语境消解（2026-10-05-review-promise-negation）：盲维第 4 问作答讨论
+ * 作用域风险时，「无串台面」「不会串台」「杜绝串台」等否定短语按字面命中 PROMISE_RE 一票
+ * 升级（实测：两行 console.log 的变更被定档高危起子代理评审）。「串台」是名词性风险词——
+ * 承诺语态必有断言修饰（与「不丢失」类「不X」形态承诺词本质不同），否定前缀 + 短距内的
+ * 「串台」先替换为占位符再扫；「解决串台」「仍有串台」等非否定语境保留一票升级。仅 design
+ * 作答面应用——input/proposal/requirements 承载用户原话，承诺口径零放松。后缀否定
+ * （「串台为零」）不覆盖：中文技术作答主流为前缀否定，为此加规则的复杂度不划算。
+ * 整词「不串台」追加（2026-10-06-review-anchor-and-negation 实测：词表无裸「不」形态，
+ * design 作答「前缀过滤不串台」字面命中一票升级）——只加三字整词不加裸「不」前缀：
+ * 「不排除串台」「不排除有串台」是风险自认（保留升级），裸前缀会把它们误消解。 */
+const NEGATED_CROSSTALK_RE = /(?:不会|不存在|没有|无|零|防|杜绝|避免|不含|免)[^\n]{0,8}?串台|不串台/g
+
+/** 风险自认形态（评审 P2 修复）：「无法杜绝串台」「难免串台」「避免不了串台」否定的是
+ * 「阻止」而非风险本身——语义=承认风险在场，必须保留一票升级。这类形态在场时整段保守
+ * 不消解（宁可多评不可漏报）；「杜绝串台」等安全声明无引导词不受影响。 */
+const RISK_ADMITTING_RE = /(?:无法|未能|没能|不可能不)[^\n]{0,8}?(?:杜绝|避免|防止|阻止|消除|防)[^\n]{0,8}?串台|(?:难免|避免不了|避不了|少不了)[^\n]{0,4}?串台/
+function stripNegatedCrosstalk(text) {
+  const t = String(text || '')
+  if (RISK_ADMITTING_RE.test(t)) return t
+  // 占位符本身禁含「串台」二字——消解产物若残留原词，PROMISE_RE 照样命中（首版实测自坑）
+  return t.replace(NEGATED_CROSSTALK_RE, '〔已消解〕')
+}
+
+/** 交付 diff 危险原语（物证面）。cursor 收窄（2026-10-06-litest-p1-fixes 实测：原 \bcursor\b
+ * 意图抓 DB 游标，却撞上本仓 harness 名 cursor——纯文案变更因测试断言 includes('cursor')
+ * 被判危险原语起子代理评审）：只认 DB-API 方法调用 conn.cursor() 与分页协议词 next_cursor
+ * 用法形态；纯名词 cursor / cursor-agent / detectCursor（本仓既有词汇）不命中。 */
+const PRIMITIVE_RE = /asyncio\.(?:Lock|Event|Queue|gather)|threading\.|with_for_update|IntegrityError|ON CONFLICT|AbortSignal|AbortController|signal\.abort|\.rollback\(|since=|\.cursor\(|\bnext_cursor\b/i
 
 /** 豁免抽查采样：确定性哈希 1/4 定额（SALT 防碰巧连坐，调表需同步核对既有夹具零碰撞）。 */
 const SAMPLE_SALT = 7
@@ -50,6 +77,27 @@ function readSlotAnswer(text, markerRe) {
   return buf.join('\n').trim()
 }
 
+/**
+ * 读 v2 纯 markdown design 节作答（2026-10-04-thin-docs-v2）：节标题行到下一节标题之间的
+ * 非空行，剥离四问原文行（DESIGN_QUESTIONS 单一源同源引入——独立字符串会被评审实证为
+ * 镜像非同源）与引导行（> 开头）。空白返回 ''（调用方按未作答处理）。
+ */
+export function readV2SectionAnswer(text, heading, designQuestions) {
+  const dq = designQuestions || DESIGN_QUESTIONS_FALLBACK
+  const lines = String(text || '').replace(/\r\n/g, '\n').split('\n')
+  const start = lines.findIndex((l) => l.trim() === `## ${heading}`)
+  if (start === -1) return ''
+  let end = lines.findIndex((l, i) => i > start && /^##\s/.test(l))
+  if (end === -1) end = lines.length
+  const qLines = new Set()
+  for (const sec of (dq.sections || [])) {
+    if (sec.heading === heading) for (const q of sec.lines) qLines.add(q)
+  }
+  return lines.slice(start + 1, end)
+    .filter((l) => { const t = l.trim(); return t && !t.startsWith('>') && !t.startsWith('##') && !qLines.has(t) })
+    .join('\n').trim()
+}
+
 /** 剥 MACHINE-DRAFT 机器段（design.md 的问题模板自带「串台」等承诺词字样——模板自污染面，
  * 扫描只看 agent 作答面；proposal/requirements 的机器段承载用户原话不剥）。 */
 function stripMachineSections(text) {
@@ -58,6 +106,23 @@ function stripMachineSections(text) {
     .replace(/<!--\s*MACHINE-DRAFT:[\w.-]+:[^\n]*:begin[^\n]*-->[\s\S]*?<!--\s*MACHINE-DRAFT:[\w.-]+:end\s*-->/g, '')
 }
 
+/**
+ * 剥 v2 纯 markdown 起草的问题文本行（2026-10-04-thin-docs-v2）：四问原文含「串台」承诺词
+ * 与并发机制词——v1 靠 MACHINE-DRAFT 段剥离防模板自污染，v2 无标记可剥，按行删（四问
+ * 原文=DESIGN_QUESTIONS 单一源逐字；节标题/引导行一并删——作答才是扫描面）。
+ */
+function stripV2QuestionLines(text) {
+  const drop = new Set()
+  for (const sec of (DESIGN_QUESTIONS_FALLBACK.sections || [])) {
+    drop.add(`## ${sec.heading}`)
+    for (const q of sec.lines) drop.add(q)
+  }
+  return String(text || '')
+    .split('\n')
+    .filter((l) => { const t = l.trim(); return !(drop.has(t) || t.startsWith('>')) })
+    .join('\n')
+}
+
 /**
  * 危险证据定档。@returns {{required: boolean, reasons: string[], exemptEvidence: string[], sampled: boolean}}
  */
@@ -72,7 +137,7 @@ export function classifyReviewNeed({ changeDir, input = '', patchText = null, ed
   for (const f of ['proposal.md', 'requirements.md', 'design.md']) {
     try {
       const t = readFileSync(join(changeDir, f), 'utf8').replace(/\r\n/g, '\n')
-      texts.push(f === 'design.md' ? stripMachineSections(t) : t)
+      texts.push(f === 'design.md' ? stripNegatedCrosstalk(stripV2QuestionLines(stripMachineSections(t))) : t)
     } catch { /* 缺件由 redraft/槽位门兜底 */ }
   }
   const all = texts.join('\n')
@@ -88,6 +153,12 @@ export function classifyReviewNeed({ changeDir, input = '', patchText = null, ed
       if (!answer) exemptEvidence.push('盲维四问未作答（将由槽位门拦收）')
       else if (/^不适用/.test(answer)) exemptEvidence.push('盲维四问自述不适用')
       else reasons.push('盲维四问有实质作答（存在时序/并发/切换/作用域风险面）')
+    } else if (/^##\s*边界与并发/m.test(dText)) {
+      // v2 纯 markdown（2026-10-04-thin-docs-v2）：边界节正文作答判定（同 v1 三态语义）
+      const answer = readV2SectionAnswer(dText, DESIGN_QUESTIONS_FALLBACK.sections[2].heading, DESIGN_QUESTIONS_FALLBACK)
+      if (!answer) exemptEvidence.push('盲维四问未作答（将由 v2 工件校验拦收）')
+      else if (/^不适用/.test(answer)) exemptEvidence.push('盲维四问自述不适用')
+      else reasons.push('盲维四问有实质作答（存在时序/并发/切换/作用域风险面）')
     } else if (MECHANISM_RE.test(dText)) {
       reasons.push('头脑风暴设计含并发/时序类机制词（adopted 扫描）')
     } else {
@@ -120,17 +191,47 @@ export function classifyReviewNeed({ changeDir, input = '', patchText = null, ed
 /**
  * 评审员任务书（flow done 首次命中需评审时打印——agent 起干净上下文子代理执行）。
  * 材料有界（change.patch 为冻结件；治理工件已含字节帽意识）；请求预算硬帽防失控勘察（R14 教训）。
+ * head（评审对象锚，2026-10-06-review-anchor-and-negation）：调用方传当前 git HEAD——任务书
+ * 印出完整 sha 并要求 review.json 的 reviewedAgainst 照抄；漂移重冻结据此区分「对着旧冻结面的
+ * 过期评审」与「对着当前 HEAD 的刚完成评审」（实测竞态：复审 PASS 落盘 26 秒后被误隔离）。
  */
-export function renderReviewerTaskbook({ change, changeDir }) {
-  return [
+export function renderReviewerTaskbook({ change, changeDir, head = null }) {
+  const headFull = String(head || '').trim()
+  // 前轮 findings 注入（2026-10-07-wave-auto-adopt-review-dedup task-02）：复审场景（前轮 FAIL/
+  // 评审隔离重评）下任务书带上前轮清单——已报项只验修复与回归，重点找新增问题，勿整轮重报
+  // （postmortem 实证评审员两轮报同类问题，多跑一整轮成本）。读不到/无 findings 零注入
+  // （首评任务书与现状逐字一致）。
+  let priorFindingsMd = ''
+  try {
+    const prev = JSON.parse(readFileSync(join(changeDir, 'review.json'), 'utf8'))
+    if (Array.isArray(prev.findings) && prev.findings.length > 0) {
+      priorFindingsMd = [
+        ``,
+        `【前轮评审 findings（${prev.findings.length} 项，前轮 verdict=${String(prev.verdict || '?')}）——本轮是复审】`,
+        ...prev.findings.slice(0, 20).map((f, i) => `  ${i + 1}. [${f && f.severity ? f.severity : '?'}] ${f && f.title ? f.title : String(f).slice(0, 120)}`),
+        ``,
+        `  复审优先级：已报项只验「修复到位 + 未引入回归」（逐条给修复验证锚点），把请求预算主力投向新增问题——`,
+        `  勿把前轮清单原样重报一遍（换视角有独立价值，重复报告挤占 12 次请求预算）。`,
+      ].join('\n')
+    }
+  } catch { /* 无 review.json / 损坏 → 首评形态，零注入 */ }
+  const taskbook = [
     `⚖️ 独立评审任务书 — ${change}`,
     `══════════════════════════════════════`,
     `【角色】你是独立评审员（干净上下文，未参与实现）——拿承诺对代码，不信自述，零误报标准。`,
+    ...(headFull ? [
+      `【评审对象】工作区实态 + git HEAD（${headFull}）——change.patch 冻结面若落后于该 HEAD，以`,
+      `  工作区实态与 git log/show 核对为准；review.json 的 reviewedAgainst 字段照抄上面的完整 sha。`,
+    ] : [
+      `【评审对象】工作区实态 + git HEAD——review.json 的 reviewedAgainst 字段填 git rev-parse HEAD`,
+      `  输出的完整 sha（评审对象锚，缺失时收口漂移检测会把本评审判为过期隔离重评）。`,
+    ]),
     ``,
     `【材料（按需 Read，请求预算硬帽 12 次——超帽即止，包不足以作答写 cannot_verify）】`,
     `  - ${join(changeDir, 'requirements.md')}（FR 承诺 + 每条 FR 的测试绑定作答）`,
     `  - ${join(changeDir, 'design.md')}（设计承诺：做法/接口契约/盲维四问作答/风险）`,
     `  - ${join(changeDir, 'change.patch')}（交付 diff 冻结件——代码事实的唯一来源）`,
+    ...(priorFindingsMd ? priorFindingsMd.split('\n') : []),
     ``,
     `【检查单（逐条作答，P1=承诺被违反或有数据正确性风险）】`,
     `  1. FR↔实现↔测试三方一致：每条 FR 的实现兑现承诺？绑定作答声称的测试真存在且断言该行为？`,
@@ -148,6 +249,7 @@ export function renderReviewerTaskbook({ change, changeDir }) {
     `{`,
     `  "schemaVersion": 1, "change": "${change}", "reviewer": "subagent",`,
     `  "verdict": "PASS" | "FAIL",`,
+    `  "reviewedAgainst": "<评审对象 HEAD 完整 sha——照抄任务书标注的 sha>",`,
     `  "findings": [ { "severity": "P1|P2|P3", "title": "…", "evidence": "代码锚点+机理一句话", "location": "file:line" } ],`,
     `  "dimensionNotes": { "乱序": "ok|finding|n/a", "并发": "ok|finding|n/a", "切换": "ok|finding|n/a", "作用域": "ok|finding|n/a" },`,
     `  "reviewedAt": "<ISO 时间>"`,
@@ -155,10 +257,13 @@ export function renderReviewerTaskbook({ change, changeDir }) {
     ``,
     `完成后由主会话重跑：sillyspec flow done --change ${change}（断点续，已完成子步幂等跳过）`,
   ].join('\n')
+  return taskbook
 }
 
 /**
  * review.json 校验（三态：ok / schema 错误清单）。FAIL 或含 P1 由调用方拦截。
+ * reviewedAgainst（评审对象锚，2026-10-06-review-anchor-and-negation）：可选字段——缺省
+ * 容忍（旧产物向后兼容），存在时须为 7-40 位 hex sha。
  */
 export function validateReviewJson(path) {
   let raw
@@ -168,6 +273,10 @@ export function validateReviewJson(path) {
   const errors = []
   if (r.schemaVersion !== 1) errors.push('schemaVersion 必须为 1')
   if (!['PASS', 'FAIL'].includes(r.verdict)) errors.push('verdict 必须为 PASS|FAIL')
+  if (r.reviewedAgainst !== undefined
+    && (typeof r.reviewedAgainst !== 'string' || !/^[0-9a-f]{7,40}$/i.test(r.reviewedAgainst.trim()))) {
+    errors.push('reviewedAgainst 须为 7-40 位 hex sha（git rev-parse HEAD 输出，照抄任务书标注）')
+  }
   if (!Array.isArray(r.findings)) errors.push('findings 必须为数组')
   else {
     r.findings.forEach((f, i) => {
@@ -181,4 +290,25 @@ export function validateReviewJson(path) {
   return { ok: true, errors: [], review: r }
 }
 
-export default { classifyReviewNeed, renderReviewerTaskbook, validateReviewJson, sampleBucket }
+/**
+ * review.json 是否锚定到指定 HEAD（漂移重冻结隔离前的保留判定，
+ * 2026-10-06-review-anchor-and-negation 实测竞态：复审对着当前 HEAD 做的 PASS 结论
+ * 落盘 26 秒后被「重冻结时刻在场=过期」口径误隔离）。reviewedAgainst 缺省/读失败/
+ * 格式非法一律 false（fail-safe：宁可多评一次，不放行无锚证据）。
+ * 匹配口径：双向前缀（reviewedAgainst 允许短 sha 形态，与完整 head 任一方向前缀命中即锚定）。
+ * @param {string} reviewPath - review.json 路径
+ * @param {string} head - 当前完整 HEAD sha
+ * @returns {boolean}
+ */
+export function reviewAnchoredToHead(reviewPath, head) {
+  const h = String(head || '').trim().toLowerCase()
+  if (!h) return false
+  try {
+    const r = JSON.parse(readFileSync(reviewPath, 'utf8'))
+    const ra = typeof r?.reviewedAgainst === 'string' ? r.reviewedAgainst.trim().toLowerCase() : ''
+    if (!/^[0-9a-f]{7,40}$/.test(ra)) return false
+    return h === ra || h.startsWith(ra) || ra.startsWith(h)
+  } catch { return false }
+}
+
+export default { classifyReviewNeed, renderReviewerTaskbook, validateReviewJson, reviewAnchoredToHead, sampleBucket }