sillyspec 3.29.4 → 3.31.0

package/src/run/gates.js

@@ -3,7 +3,9 @@
  *
  * 阶段完成校验 gate 级联 + execute deps 硬门 + 完成回滚（自洽叶子模块，仅被 completeStep 调用）：
  *   - runStageCompletionGates：runValidators → verify-test 对账 → Plan→Execute contract →
- *     Stage Review Gate → Execute Task Review Gate，任一失败走 rollbackCompletionAndReturn；
+ *     Stage Review Gate，任一失败走 rollbackCompletionAndReturn（Execute Task Review Gate
+ *     已随 2026-09-26-task-review-retire 退役——R18 实证任务粒度评审在无独立评审者供给时
+ *     全降形式合规、实质拦截为零）；
  *     级联末位追仪式档位摩擦升档检查点（2026-09-18-ceremony-risk-pricing task-03：读
  *     friction-ledger 累计账 → escalateByFriction → .runtime/ceremony-tier-<change>.json
  *     迁移留痕，只升不降、fail-soft 不阻断完成）；verify 检查族末位接 ceremony 双跑收口第一
@@ -33,6 +35,37 @@ import { writeAtomicSync } from '../fs-atomic.js'
 import { triggerSync, resolveChangeDir, resolveRuntimeRoot } from './shared.js'
 import { runValidators } from '../stage-contract.js'
 import { handleScanStageCompleted, handleExecuteWorktreeCleanup } from './complete-handlers.js'
+
+/**
+ * 评审豁免凭据（2026-09-26-review-unsupervised-exit，R18-full 实证驱动）：无嵌套派发能力的
+ * 环境（子代理不能再派子代理）里，阶段评审只能降级自审——三份自审 review.json 全 PASS 零信息
+ * 量纯表演，门仍硬拦形式合规（R18-full 15 次拦截里 5 次是 review 面形式）。诚实出口：agent 写
+ * 变更目录 review-unsupervised.md（一行声明：环境无嵌套派发能力+时间，须含 unsupervised 字样）
+ * → Stage Review Gate / doctor align 门两点共吃（Task Review 层与 --done review.json 硬门
+ * 已随 2026-09-26-task-review-retire 退役）：有效
+ * review.json ‖ 豁免声明二选一放行（warn+遥测，豁免率可观测）；两凭据皆无照旧 fail-closed。
+ * 真独立评审（有派发能力）不受影响——豁免是声明式自曝，不是绕门。
+ */
+export function readReviewUnsupervisedWaiver(changeDir) {
+  try {
+    if (!changeDir) return null
+    const p = join(changeDir, 'review-unsupervised.md')
+    if (!existsSync(p)) return null
+    const t = readFileSync(p, 'utf8')
+    return /unsupervised/i.test(t) ? t.trim().slice(0, 200) : null
+  } catch {
+    return null
+  }
+}
+
+/** 豁免放行的统一回显+遥测（调用点持 runtimeRoot/specBase）。 */
+async function waiveWithTelemetry({ changeName, gate, specBase }) {
+  console.warn(`⚠️ [评审豁免] review-unsupervised.md 在场（${gate}）——环境无嵌套派发能力，阶段评审降级留痕放行（不产自审 review.json 不表演）；声明随归档留痕，可经遥测观测豁免率`)
+  try {
+    const { appendKnowledgeHit } = await import('../knowledge-hits.js')
+    appendKnowledgeHit(join(specBase, '.runtime'), { type: 'review-unsupervised-escape', change: changeName, gate, source: 'gates' })
+  } catch { /* 遥测 fail-soft */ }
+}
 import { detectConcurrentChanges, formatConcurrentWarning, detectCommittedDrift, formatCommittedDriftWarning } from './concurrent-detect.js'
 import { stageRegistry } from '../stages/index.js'
 import { normalizeTaskId } from '../taskcard.js'
@@ -235,8 +268,9 @@ function isCurrentWaveAllNoDepsVerify(stepName, changeDir) {
  * 只读校验（不自动生成 marker/runId——恢复读场景缺失就是缺失，如实报告）：
  *   1. Stage Review：tier=independent 时须存在有效 execute stage review.json（verdict 非 fail）；
  *      tier=self 放行（与正常 gate 分级一致）。
- *   2. Task Review：所有 task 的 review.json 齐备且 verdict 非 fail（runId 解析同 Task Review Gate：
- *      marker → 含 tasks/ 目录扫描；不 generate）。
+ *   2. Task Review 段已退役（2026-09-26-task-review-retire：R18 实证任务粒度评审在无嵌套
+ *      派发环境全降自审表演、实质拦截为零——豁免通道不足以止损，层整体退役；残存 review.json
+ *      由 task-review.js 保留导出作历史兼容读侧）。
  *
  * @param {{ cwd: string, changeName: string, specBase: string, platformOpts?: object }} opts
  * @returns {Promise<boolean>} true=被门阻断（CLI 应放弃 align 并 exit 1）；false=校验通过可继续
@@ -245,10 +279,16 @@ export async function enforceAlignExecuteReviewGate({ cwd, changeName, specBase,
   const effectiveSpecBase = platformOpts?.specRoot || specBase
   const runtimeRoot = resolveRuntimeRoot(platformOpts, effectiveSpecBase)
   const reviewChangeDir = resolveChangeDir(cwd, { currentChange: changeName }, platformOpts?.specRoot || null)
+  // 豁免凭据（review-unsupervised-exit）：无嵌套派发能力环境两段校验整体降级留痕放行
+  if (readReviewUnsupervisedWaiver(reviewChangeDir)) {
+    await waiveWithTelemetry({ changeName, gate: 'doctor-align', specBase: effectiveSpecBase })
+    console.warn('   ℹ️ align 前置 review 门整体豁免（unsupervised 声明在场）——继续对齐')
+    return false
+  }
   const blocked = (msgs) => {
     console.error('\n❌ doctor --align-execute-progress 前置 review 校验未过——execute 完成审计不能绕过：')
     for (const m of msgs) console.error('   - ' + m)
-    console.error('   解法：补齐上述 review 后重跑 align（stage review：sillyspec register-stage-review --change ' + changeName + ' --stage execute；task review：按报错路径补 review.json）')
+    console.error('   解法：补齐上述 review 后重跑 align（stage review：sillyspec register-stage-review --change ' + changeName + ' --stage execute）')
     return true
   }
 
@@ -285,36 +325,10 @@ export async function enforceAlignExecuteReviewGate({ cwd, changeName, specBase,
     return true
   }
 
-  // 2. Task Review（runId 只读解析：marker → 含 tasks/ 扫描；不 generate）
-  try {
-    const { validateTaskReviews, printReviewResult, resolveLatestExecuteRunIdWithTasks, isValidExecuteRunId } = await import('../task-review.js')
-    const planPath = reviewChangeDir ? join(reviewChangeDir, 'plan.md') : null
-    if (!planPath || !existsSync(planPath)) {
-      return blocked(['plan.md 不存在，Task Review 无从校验（align 的 checkbox 判定依赖同目录，疑似路径解析异常）'])
-    }
-    const planContent = readFileSync(planPath, 'utf8')
-    const runIdFile = join(runtimeRoot, `current-execute-run-id-${changeName}`)
-    let executeRunId = ''
-    try {
-      if (existsSync(runIdFile)) {
-        const c = readFileSync(runIdFile, 'utf8').trim()
-        if (c && isValidExecuteRunId(c)) executeRunId = c
-      }
-    } catch {}
-    if (!executeRunId) {
-      executeRunId = resolveLatestExecuteRunIdWithTasks({ runtimeRoot, changeName }) || ''
-    }
-    if (!executeRunId) {
-      return blocked(['execute runId 无法定位（marker 缺失且 execute-runs/ 无含 review 的 run 目录）——15/N 份 task review 所在 run 不可寻，无法对账'])
-    }
-    const reviewResult = validateTaskReviews({ planContent, runtimeRoot, executeRunId, changeDir: reviewChangeDir, gitDir: cwd })
-    printReviewResult(reviewResult, { runtimeRoot, executeRunId })
-    if (!reviewResult.ok) return true // 报错明细已在 printReviewResult 输出
-    console.log('✅ align 前置 review 校验通过（stage review + task review 均齐备），继续对齐')
-  } catch (e) {
-    console.error('❌ align 前置 Task Review 校验异常，阻断对齐: ' + e.message)
-    return true
-  }
+  // 2. Task Review 段已退役（2026-09-26-task-review-retire）——原「所有 task review.json 齐备
+  //    且 verdict 非 fail」校验随层退役删除；task 粒度审计改由 execute 收口的代码证据核验
+  //    （checkExecuteCodeEvidence）+ verify 测试对账承担。
+  console.log('✅ align 前置 review 校验通过（stage review；task review 段已退役），继续对齐')
   return false
 }
 
@@ -342,7 +356,7 @@ export async function enforceDepsGate(stageName, cwd, changeName, step, steps, c
 
   // main 侧就绪后的跨仓 worktree deps 校验（坑 cross-repo-no-worktree-isolation）：
   // 跨仓仓供给失败同样无构建/测试能力（前端仓无 node_modules 建不了 build）。只校验已建
-  // worktree 的跨仓仓（legacy 直写模式无 meta，维持原语义，下游 Task Review 兜底）。
+  // worktree 的跨仓仓（legacy 直写模式无 meta，维持原语义）。
   // 放行返回 true；跨仓未就绪置 blocked + exit(1)。
   const crossCheckOrExit = async () => {
     let crossFailed = []
@@ -446,85 +460,11 @@ export async function enforceDepsGate(stageName, cwd, changeName, step, steps, c
   process.exit(1)
 }
 
-/**
- * execute --done 硬门：已勾 [x] task 的 review.json 必须 schema 完整（坑 review-json-field-gap）。
- *
- * Task Review Gate（validateTaskReviews）只在 execute 整阶段完成时跑（complete.js 阶段完成分支的
- * actualCompleted===actualTotal 守卫），单 task --done 不校验 → 子代理勾 checkbox 却漏写/漏字段
- * review.json，要到收尾才暴露，用户被迫事后批量补。本门提前到每次 --done：校验 plan 里所有已勾
- * task 的 review.json，缺字段/不存在/JSON 坏 → 置 step=blocked + exit(1)，与 enforceDepsGate 同范式
- * （阻断前经 persist 回调落盘 blocked）。
- * 未勾 task 不校验（还没做）。平台模式/无 marker/无 plan 时放行（下游 Task Review Gate 兜底）。
- */
-export async function enforceReviewJsonGate(stageName, cwd, changeName, step, steps, currentIdx, specBase, platformOpts, persist) {
-  if (stageName !== 'execute' || !changeName) return true
-  // head 锡点自动落盘（2026-08-21 审计项③，D-010 补对称）：跨仓 task base_commit 已在派发时
-  // CLI 落盘，head_commit 此前靠主 agent 按 prompt 手跑 rev-parse 手写（漏抄/抄错炸 review gate）。
-  // 每次 --done 时机幂等补齐（已存在不覆盖）。best-effort：失败只 warn，不阻断 --done 主流程。
-  try {
-    const { stampCrossRepoHeadCommits } = await import('../stages/execute.js')
-    const stamped = await stampCrossRepoHeadCommits({ changeName, cwd, specBase, platformOpts })
-    if (stamped && stamped.stamped > 0) {
-      console.log(`📌 已自动落盘跨仓 task head_commit 锡点：${stamped.stampedTasks.join(', ')}（幂等，此后 --done 不再重复写）`)
-    }
-  } catch (e) {
-    console.warn(`⚠️ head_commit 锡点自动落盘失败（降级留给 agent 手写）: ${e.message}`)
-  }
-  const runtimeRoot = resolveRuntimeRoot(platformOpts, specBase)
-  const runIdFile = join(runtimeRoot, `current-execute-run-id-${changeName}`)
-  const planPath = join(specBase, 'changes', changeName, 'plan.md')
-  if (!existsSync(runIdFile) || !existsSync(planPath)) return true
-  const { validateCheckedTaskReviews, resolveLatestExecuteRunIdWithTasks, isValidExecuteRunId } = await import('../task-review.js')
-  // existsSync 与 read 之间 marker 可能被并发 cleanup/归档删除（多 agent 场景）：读失败按
-  //「marker 缺失」处理，走漂移兜底重定位，不让 ENOENT 冒成顶层 stack（与 :426-435 口径对齐）
-  let executeRunId = ''
-  try {
-    executeRunId = readFileSync(runIdFile, 'utf8').trim()
-  } catch {
-    console.warn('⚠️ execute run marker 读取失败（可能被并发清理），改扫真实 run 目录')
-    executeRunId = resolveLatestExecuteRunIdWithTasks({ runtimeRoot, changeName }) || ''
-  }
-  // marker 是 agent 可写内容：格式校验防注入/穿越，非法视为缺失走漂移兜底重定位
-  if (executeRunId && !isValidExecuteRunId(executeRunId)) {
-    console.warn(`⚠️ execute run marker 内容非法（期望 exec-YYYY-MM-DD-HHMMSS，实得 ${JSON.stringify(executeRunId.slice(0, 60))}），改扫真实 run 目录`)
-    executeRunId = ''
-  }
-  // 2026-08-20-task-truth-unify：已勾 task 清单源迁 tasks.md（勾选唯一落点）；tasks.md 缺失
-  // 回退 planPath 内容（旧变更兼容读侧）。planPath 存在性已在上方把关。
-  const tasksRegistryPath = join(specBase, 'changes', changeName, 'tasks.md')
-  const planContent = existsSync(tasksRegistryPath)
-    ? readFileSync(tasksRegistryPath, 'utf8')
-    : readFileSync(planPath, 'utf8')
-  // marker 读失败且重定位无果（无任何含 tasks/ 的 run）：无 run 可校验，放行（下游 Task Review Gate 兜底）
-  if (!executeRunId) return true
-  // marker 漂移兜底（gate-atom-a 正确修法）：marker 指向的 run 缺 tasks/（generateExecuteRunId 只写
-  // marker 不建目录，漂移后新 run 不继承旧 review）时，无视 marker 改扫 execute-runs/ 取 mtime 最新
-  // 且真正含 tasks/ 的 run，用其齐备的 review.json 校验，避免误报「review.json 不存在」。注意不能用
-  // resolveLatestExecuteRunId——它见 marker 非空即原样返回（不校验目录），恰是本场景要绕开的值。
-  if (executeRunId && !existsSync(join(runtimeRoot, 'execute-runs', executeRunId, 'tasks'))) {
-    const relocated = resolveLatestExecuteRunIdWithTasks({ runtimeRoot, changeName })
-    if (relocated && relocated !== executeRunId) {
-      console.warn(`⚠️ execute run marker 漂移：${executeRunId} 无 tasks/，改用真实含 review 的 run ${relocated}`)
-      executeRunId = relocated
-    }
-  }
-  const result = validateCheckedTaskReviews({ planContent, runtimeRoot, executeRunId })
-  if (result.ok) return true
-  if (steps && steps[currentIdx]) {
-    steps[currentIdx].status = 'blocked'
-    steps[currentIdx].blockReason = 'review.json 字段校验阻断：补齐后重试 --done（backfill-reviews --adopt 可代填 mechanics）'
-  }
-  console.error('❌ ── review.json 字段校验阻断（本次 --done 未完成，进度未推进）──')
-  console.error('   已勾选 [x] 的 task review.json 不完整（铁律：勾 checkbox 前必须先写完整 review.json）:')
-  for (const f of result.failures) {
-    const kindLabel = f.kind === 'missing' ? 'review.json 不存在' : (f.kind === 'parseError' ? 'JSON 解析失败' : '字段缺失')
-    console.error(`   • ${f.taskId}（${kindLabel}）: ${f.reviewPath}`)
-    for (const e of f.errors) console.error(`       - ${e}`)
-  }
-  console.error('   修复：mechanics 字段（base/head/changedFiles/schemaVersion）缺错可跑 sillyspec backfill-reviews --change ' + changeName + ' --adopt 一键代填（verdict 保留）；verdict/证据缺失需人工补全后重跑 execute --done。')
-  if (persist) { try { await persist() } catch { /* 落盘失败不吞阻断语义 */ } }
-  process.exit(1)
-}
+// ── enforceReviewJsonGate 已退役（2026-09-26-task-review-retire）──
+// 原「execute --done 时已勾 [x] task 的 review.json schema 硬门」（坑 review-json-field-gap）
+// 随 Task Review 层整体退役删除：勾选语义回归 agent 手动（完成=实现+测试绿+wt-commit 即勾），
+// review.json 不再是任何门的输入；validateCheckedTaskReviews 纯函数保留在 task-review.js
+// （历史变更 doctor/回放兼容读侧，单元测试 review-json-field-gate.test.mjs 仍覆盖）。
 
 /**
  * 阶段完成校验失败时回滚状态。
@@ -564,7 +504,7 @@ export function rollbackStageCompletion(stageData, steps, currentIdx) {
  * 阶段完成校验失败后的统一收尾：回滚 stage/step 状态 + 落盘 + sync + 返回「未完成」。
  *
  * completeStep 的各 gate（runValidators / verify-test 对账 / plan→execute contract /
- * Stage Review / Execute Task Review）失败时都走这套动作；原先每个失败分支手写重复
+ * Stage Review）失败时都走这套动作；原先每个失败分支手写重复
  * ~7 次（含 lastActive 落盘 + triggerSync + return 结构），统一进来消坑，避免某分支
  * 漏写 triggerSync / 写错 return 结构导致行为分裂。返回 nextPendingIdx=currentIdx，
  * 让上层走「完成但不推进」分支，--done 被拒、agent 修复产物后重跑。
@@ -739,13 +679,21 @@ async function escalateCeremonyTierAtGate({ cwd, specBase, platformOpts, progres
 /**
  * 阶段完成校验 gate 级联（从 completeStep 抽出，行为保持）。仅当所有步骤确实标记为 completed 时
  * 由 completeStep 调用。顺序：runValidators → verify-test 对账 → Plan→Execute contract →
- * Stage Review Gate → Execute Task Review Gate。任一 gate 失败 → rollbackCompletionAndReturn
+ * Stage Review Gate。任一 gate 失败 → rollbackCompletionAndReturn
  * （统一回滚 + 返回 early-return 对象）；全部通过 → 返回 null（completeStep 继续收尾）。
  *
  * @returns {{stageCompleted:false,currentIdx,nextPendingIdx:number}|null}
  */
 export async function runStageCompletionGates({ stageName, cwd, changeName, platformOpts, specBase, progress, pm, stageData, steps, currentIdx, ctx = null }) {
   const projectName = progress.project || basename(cwd)
+  // ── 纯文档门收集模式（R16 减负批次，2026-09-24）──
+  // 对撞 R15 实证「execute 收口连挡 4 次」：多门串行 fail-fast，每次 --done 只暴露一个门，
+  // 修复重跑才见下一个门。纯文档 blocking 门（validators / verify 死信与预填注 / Stage
+  // Review）改为收集：全部跑完 → 一次打印清单 → 统一 rollback 一次（detail 取首门，
+  // 进度库信号语义不变）。实测门（test/lint/parity/probe）保持文档面全清后才跑、内部 fail-fast
+  // 不变——贵的门只为真实代码问题付账。检查点 A=verify 实测门前；B=brainstorm/plan/execute
+  // Stage Review Gate 后（friction 升档前——升档语义=「所有阻断门通过」）。
+  const docGateFailures = []
   // decisions.md header 自动补齐（坑 decisions-header-late-warning，2026-08-24 用户反馈二期）：
   // brainstorm step8 旧模板自带无 frontmatter 的 decisions 样例，存量变更照抄必缺 author/created_at，
   // 拖到平台同步/后续环节才提示。gate 前幂等补机械字段（先例：autoCheckPlanFromReviews 同层写
@@ -818,8 +766,9 @@ export async function runStageCompletionGates({ stageName, cwd, changeName, plat
     console.error(`\n   提示：修复缺失产物后重新完成此步骤（--skip-approval 只跳过阶段转换/审批检查，不能跳过产物校验）`)
     // 产物校验失败必须阻断完成 —— 否则 validator 形同虚设，
     // verify 会带着 FAIL/缺 verify-result.md 被 ✅ 标记完成（历史教训）。
-    // plan/execute 的专项契约校验（下方）在产物齐全后才需要继续跑，故此处先 return。
-    return await rollbackCompletionAndReturn(pm, progress, stageData, steps, currentIdx, cwd, changeName, platformOpts, { type: 'gate_rollback', detail: 'validators' })
+    // 收集模式（R16）：不再直接 return——继续跑完其余纯文档门（review 等）后由检查点统一
+    // rollback，一次 --done 暴露全部缺失面（R15 连挡 4 次的解）。
+    docGateFailures.push({ type: 'gate_rollback', detail: 'validators', label: `产物契约校验未过（${contractResult.errors.length} 条，明细见上）` })
   }
   if (contractResult.warnings.length > 0) {
     console.warn(`\n⚠️ 阶段 ${stageName} 校验警告：`)
@@ -861,6 +810,77 @@ export async function runStageCompletionGates({ stageName, cwd, changeName, plat
     } catch { /* advisory 失败不阻断完成（fail-soft，facade 预检先例同款） */ }
   }
 
+  // ── fail-fast 前置：纯文档 blocking 检查先于 test/lint 实测门（R4-S-F 实证，2026-09-21）──
+  // module-impact 死信与预填注清零 error 门只读文档零外部执行，原先排在 9 分钟级 test+lint
+  // 实测门之后——文档未清时每轮 --done 都先白烧一轮门禁再被拦（R4-S-F 166min 的主要形状）。
+  // 前置到实测门之前：秒级失败秒级返工，贵的门只在文档面已清后才跑。
+  if (stageName === 'verify' && changeName) {
+    // module-impact 死信探针（blocking，债单 D-1/D-5）：更新结果表 pending/待办行 → 阻断 verify。
+    // 与 archive 移动前校验（extractPendingDocSyncRows）同一口径，把死信号从 archive 提前到 verify：
+    // agent 在 verify 阶段就须完成文档同步并回填 done/skipped，而非拖到归档被拦。
+    const verifyChangeDir = resolveChangeDir(cwd, progress, platformOpts?.specRoot)
+    if (verifyChangeDir) {
+      const impactPath = join(verifyChangeDir, 'module-impact.md')
+      if (existsSync(impactPath)) {
+        const { extractPendingDocSyncRows } = await import('./complete-handlers.js')
+        const pendingRows = extractPendingDocSyncRows(readFileSync(impactPath, 'utf8'))
+        if (pendingRows.length > 0) {
+          console.error(`\n❌ verify 阶段被阻断：module-impact.md「更新结果」表存在 ${pendingRows.length} 个未清 pending/待办项（死信）`)
+          for (const row of pendingRows) console.error(`   - ${row}`)
+          console.error('   文档同步是 verify 的收尾义务：请完成模块文档同步并回填状态为 done/skipped（说明原因），再重新完成 verify。')
+          docGateFailures.push({ type: 'gate_rollback', detail: 'verify-contract', label: `module-impact.md 存在 ${pendingRows.length} 个 pending/待办死信（明细见上）` })
+        }
+      }
+    }
+    // 预填注清零 error 门（归档前最后一道；2026-09-18-artifact-prefill task-03 / FR-03 / D-003@v1
+    // 门禁梯度·error 档）：白名单槽宿主文件（design.md + tasks/task-*.md）仍含未删预填注 →
+    // 阻断 verify 完成。brainstorm/plan --done 的 advisory 在此收口为硬门，注在场=预填未确认。
+    // 检测单点 = runProbe10PrefillNoteClearance（不二算）。已知误报面：散文引用注字面量会命中
+    // ——修法是核对后删注/改写散文措辞，不是绕门。
+    try {
+      const { runProbe10PrefillNoteClearance } = await import('../verify-probes.js')
+      const noteClearance = runProbe10PrefillNoteClearance({ specBase, changeName })
+      if (noteClearance.unclearedFiles.length > 0) {
+        console.error(`\n❌ verify 阶段被阻断：预填注清零校验未过（${noteClearance.unclearedFiles.length} 个文件的白名单槽仍含未删预填注——预填≠结论，注在场=未确认）：`)
+        for (const f of noteClearance.unclearedFiles) console.error(`   - ${f}`)
+        console.error('   修复：逐槽核对预填值后删除行尾「(预填：核对后删本注)」注（删注=确认动作）；散文含注字面量的命中改写该处措辞。清零后重新完成 verify（进度不丢）。')
+        docGateFailures.push({ type: 'gate_rollback', detail: 'verify-contract', label: `预填注清零未过（${noteClearance.unclearedFiles.length} 文件，明细见上）` })
+      }
+    } catch (e) {
+      console.warn(`⚠️ 预填注清零校验异常（降级放行，fail-soft——异常不是未清零，ceremony 双跑同款处置）: ${(e && e.message) || e}`)
+    }
+
+    // UI 视觉证据门·error 档（2026-09-27-ui-visual-guidance / 探针 12 分级门的 verify 收尾执法）：
+    // 视觉降级无用户裁决留痕恒拦；ui_visual_gate=error 时缺 visual-evidence.md 亦拦（默认 warn
+    // 只警告不拦）。检测单点 = runUiVisualProbe（与 flow done probes 子步、verify-probes --init
+    // 同源，不二算）。fail-soft 同预填注门。
+    try {
+      const { runUiVisualProbe, readUiVisualGate, UI_EVIDENCE_FILENAME } = await import('../ui-visual.js')
+      const uiProbe = runUiVisualProbe({ changeDir: join(specBase, 'changes', changeName), gate: readUiVisualGate(specBase) })
+      if (uiProbe.level === 'error') {
+        console.error(`
+❌ verify 阶段被阻断：UI 视觉证据门未过（${uiProbe.notes.join('；')}）`)
+        console.error(`   修复：补渲染对照证据到 ${UI_EVIDENCE_FILENAME}；降级项补「用户裁决」留痕段。证据应在执行时按 flow start「UI 变更执行须知」随手产生——收口只验在场。`)
+        docGateFailures.push({ type: 'gate_rollback', detail: 'verify-contract', label: 'UI 视觉证据门未过（探针 12 error 档，明细见上）' })
+      } else if (uiProbe.level === 'warn') {
+        console.warn(`
+⚠️ UI 视觉证据（探针 12 warn 档）：${uiProbe.notes.join('；')}`)
+      }
+    } catch (e) {
+      console.warn(`⚠️ UI 视觉证据探针异常（降级放行，fail-soft）: ${(e && e.message) || e}`)
+    }
+  }
+
+  // ── 收集模式检查点 A（verify）：纯文档门全清后才进入实测门（test/lint/parity/probe 保持
+  //    fail-fast 不变）。brainstorm/plan/execute 不走本检查点（其实测面为空，检查点 B 收口）。──
+  if (stageName === 'verify' && docGateFailures.length > 0) {
+    console.error(`\n❌ verify 收口被 ${docGateFailures.length} 道纯文档门拦截（一次性全列——全部修复后重跑一次 --done，不必逐门连撞）：`)
+    docGateFailures.forEach((f, i) => console.error(`   ${i + 1}. ${f.label}`))
+    console.error(`   （各门明细见上方对应 ❌ 段落；实测门（test/lint）在文档面全清后才执行）`)
+    const firstFail = docGateFailures[0]
+    return await rollbackCompletionAndReturn(pm, progress, stageData, steps, currentIdx, cwd, changeName, platformOpts, { type: firstFail.type, detail: firstFail.detail })
+  }
+
   // verify 产物校验通过 + 结论非 FAIL（否则上面已阻断）。
   // 再由 CLI 亲自执行 local.yaml 的测试命令，与 verify-result.md 的自报告对账：
   // 自报告 PASS 但实测失败 → 阻断（防止"文案通过"绕过验证）。
@@ -911,16 +931,134 @@ export async function runStageCompletionGates({ stageName, cwd, changeName, plat
     const gateCwd = verifyGateSnap ? verifyGateSnap.snapshotRoot : cwd
     const gateSpecBase = verifyGateSnap ? join(verifyGateSnap.snapshotRoot, '.sillyspec') : specBase
     let testCheck
-    if (reusableScan && reusableScan.testResult) {
+    // ── P2 三键账本复用（D-001@v1，2026-09-21-r5-efficiency-batch3 task-01）：代码×测试面×环境
+    //    三键全等且有通过记录 → 免重跑（batch2 实证同码态全量被跑多遍）。fail-closed：键分量
+    //    不可得/键不等/无记录 → 真跑（走下方原路径，行为不变）。咨询异常整体按无账本（fail-open
+    //    不影响门禁）。优先级：P2 账本（三键精确）> P0-1 质量扫描复用 > 真跑。──
+    let ledgerReuse = null
+    // ── 账本停复用护栏（2026-09-24-fr-test-readside task-05，D-006@v1）：trace 含 active 行
+    //    的变更残差并入跑面，v2 键（config+整目录面）不再描述实际执行——fail-closed 跳过
+    //    consult/record（宁多跑一轮不误复用未含残差的旧绿；退役判据=账本键 v3 携 aggregate
+    //    run plan）。空 trace/缺失 → 照用 v2（行为不变）。──
+    let traceHasActiveRows = false
+    try {
+      const { readChangeTrace } = await import('../test-bindings.js')
+      traceHasActiveRows = readChangeTrace(join(specBase, 'changes', changeName)).some(r => r.state === 'active')
+      if (traceHasActiveRows) console.log('ℹ️ 本变更含 active 测试绑定行——账本停复用（残差跑面静态不可键化，fail-closed）')
+    } catch { /* 读失败按无 trace（照用账本） */ }
+    if (!traceHasActiveRows) {
+    try {
+      const { consultTestLedger } = await import('./test-ledger.js')
+      const consult = consultTestLedger({
+        runtimeRoot: resolveRuntimeRoot(platformOpts, specBase),
+        changeName, projectRoot: gateCwd, testRoot: join(gateCwd, 'test'), specBase: gateSpecBase, cwd: gateCwd,
+      })
+      if (consult.reuse) ledgerReuse = consult
+    } catch { /* 账本咨询异常 → 真跑 */ }
+    }
+    if (ledgerReuse) {
+      testCheck = {
+        status: 'passed',
+        reason: `♻️ P2 三键账本复用（代码×测试面×环境全等；实测于 ${ledgerReuse.result.ranAt}，耗时 ${Math.round((ledgerReuse.result.durationMs || 0) / 1000)}s）`,
+        command: `${ledgerReuse.runPlan?.[0]?.runner || 'npm test'} (ledger-reuse)`,
+        exitCode: 0, durationMs: 0, outputTail: null,
+        resultPath: null, strategy: ledgerReuse.result.strategy || null,
+      }
+      console.log(`\n♻️ Verify 测试对账：P2 账本复用（三键全等，免重跑；实测于 ${ledgerReuse.result.ranAt}）`)
+      printVerifyTestCheck(testCheck)
+    } else if (reusableScan && reusableScan.testResult) {
       testCheck = reusableScan.testResult
       console.log(`\n♻️ Verify 测试对账：复用 noAI 质量扫描步的实测结果（代码指纹匹配，免重跑；实测于 ${reusableScan.ranAt || '本变更 verify 期间'}${testCheck.resultPath ? `，台账 ${testCheck.resultPath}` : ''}）`)
       printVerifyTestCheck(testCheck)
     } else {
       // 测试实测是同步 execSync，长套件可跑 2~10min 且中途无输出——先预告避免 agent 误判卡死
       console.log(`\n⏳ Verify 测试对账：CLI 亲自执行 local.yaml 的 commands.test（同步，耗时可能较长，请等待…）`)
-      testCheck = runVerifyTestCheck({ cwd: gateCwd, specBase: gateSpecBase, changeName, ctx })
+      // restrictFiles 接线（2026-09-26-verify-gate-restrictfiles，评审 P2 留痕缺口的清偿）：
+      // quick 门（quick-audit.js:584）传声明文件收窄模块选择，verify 门此前没传——变更全提交后
+      // verify --done 同形下文件面解析 0 命中可能假 skip（该实测没实测）。与 :1135 lint scope
+      // 同源口径（includeWorkingTree 含 worktree 未提交）；空清单不传（restrict 空数组反而制造
+      // 假 skip——空=解析失败应走全量硬门，不降级）。
+      let _restrict = null
+      try {
+        const { resolveVerifyChangedFiles } = await import('../verify-postcheck.js')
+        _restrict = resolveVerifyChangedFiles(cwd, changeName, null, { includeWorkingTree: true, specBase: gateSpecBase })
+      } catch { /* 解析异常走全量（restrictFiles 不传） */ }
+      testCheck = runVerifyTestCheck({ cwd: gateCwd, specBase: gateSpecBase, changeName, ctx, ...(Array.isArray(_restrict) && _restrict.length > 0 ? { restrictFiles: _restrict } : {}) })
       printVerifyTestCheck(testCheck)
+      // 自动绑定补全（full-autopilot-parity，R21 thin 迁移）：测试已跑、test-result.json 已落盘，
+      // verify --done 收口时从测试结果自动补全 requirements.md 的空绑定槽——与 thin 同逻辑（逐行扫描）。
+      try {
+        const { verifyRequirementBindings } = await import('../flow-draft.js')
+        let _rb = verifyRequirementBindings({ changeDir: resolveChangeDir(cwd, { currentChange: changeName }, platformOpts?.specRoot) })
+        if (_rb.applicable && _rb.emptySlots.length > 0) {
+          const _runsDir = join(resolveRuntimeRoot(platformOpts, specBase), 'verify-runs')
+          let _testFiles = new Set()
+          if (existsSync(_runsDir)) {
+            for (const _rd of readdirSync(_runsDir).sort().reverse().slice(0, 3)) {
+              const _tr = join(_runsDir, _rd, 'test-result.json')
+              if (!existsSync(_tr)) continue
+              try {
+                const _j = JSON.parse(readFileSync(_tr, 'utf8'))
+                // P1 修复：从 command 解析测试文件路径（匹配 test_*.py / *.test.ts 等）
+                const _cmd = String(_j.command || '')
+                for (const _fm of _cmd.matchAll(/([\w\/\\.-]+\.\w{1,5})/g)) {
+                  if (/test|spec/i.test(_fm[1])) _testFiles.add(_fm[1].replace(/\\/g, '/'))
+                }
+                if (_testFiles.size > 0) break
+              } catch {}
+            }
+          }
+          if (_testFiles.size > 0) {
+            const _reqPath = join(resolveChangeDir(cwd, { currentChange: changeName }, platformOpts?.specRoot), 'requirements.md')
+            const _lines = readFileSync(_reqPath, 'utf8').split('\n')
+            const _bind = [..._testFiles].slice(0, 3).join('、')
+            let _filled = 0
+            for (let _li = 0; _li < _lines.length - 1; _li++) {
+              if (/^<!--\s*AGENT:测试绑定/.test(_lines[_li]) && !_lines[_li + 1].trim()) {
+                _lines[_li + 1] = _bind; _filled++; _li++
+              }
+            }
+            if (_filled > 0) {
+              const { writeAtomicSync } = await import('../fs-atomic.js')
+              writeAtomicSync(_reqPath, _lines.join('\n'))
+              console.log(`✅ [自动绑定] ${_filled} 个空绑定槽已从测试结果补全（${_bind.slice(0, 60)}）——agent 可覆盖（full-autopilot-parity）`)
+            }
+          }
+        }
+      } catch { /* auto-bind fail-soft */ }
+      // P2 记账（fail-closed 层②：只有通过结果落账本——失败永不缓存，修复后重跑才能记）
+      if (!traceHasActiveRows) {
+      try {
+        const { recordTestLedger } = await import('./test-ledger.js')
+        if (testCheck && testCheck.status === 'passed') {
+          recordTestLedger({
+            runtimeRoot: resolveRuntimeRoot(platformOpts, specBase),
+            changeName, projectRoot: gateCwd, testRoot: join(gateCwd, 'test'), specBase: gateSpecBase, cwd: gateCwd,
+            result: { pass: true, total: testCheck.total ?? null, failedFiles: [], durationMs: testCheck.durationMs ?? null, strategy: testCheck.strategy ?? null },
+          })
+        }
+      } catch { /* 记账异常不影响门禁（下次仍真跑） */ }
+      }
     }
+    // ── trace 晋升（2026-09-24-fr-test-bindings task-04，fr-test-binding §3.2/D-003@v1）：
+    //    verify 门通过点按矩阵判定列晋升 candidate→active（covered/covered-service→active+
+    //    confirmed_by=agent；partial 留；uncovered/non-testable 删行）。fail-open：晋升异常不拦门。──
+    try {
+      const verifyMdForPromo = join(specBase, 'changes', changeName, 'verify-result.md')
+      if (existsSync(verifyMdForPromo)) {
+        const { extractAcceptanceMatrixSlots } = await import('../stage-contract.js')
+        const { promoteTraceFromMatrix } = await import('../test-bindings.js')
+        const slots = extractAcceptanceMatrixSlots(readFileSync(verifyMdForPromo, 'utf8'))
+        if (slots.present && Array.isArray(slots.rows) && slots.rows.length > 0) {
+          const promo = promoteTraceFromMatrix({
+            changeDir: join(specBase, 'changes', changeName), changeName, matrixRows: slots.rows,
+          })
+          if (promo.promoted > 0 || promo.dropped > 0) {
+            console.log(`🔗 绑定晋升：${promo.promoted} 行→active（confirmed_by=agent），${promo.dropped} 行删（uncovered/non-testable），${promo.kept} 行保持`)
+          }
+        }
+      }
+    } catch { /* 晋升 fail-open（不拦 verify 门，归档以 trace 现态为准） */ }
     // tests 段二次回填（2026-09-08-ir-verify-facts FR-03 次序：实测在 runValidators 之后，
     // tests 快照此刻才可得；不参与门禁——供 P3d 追溯）
     try {
@@ -937,6 +1075,20 @@ export async function runStageCompletionGates({ stageName, cwd, changeName, plat
       }
     } catch { /* fail-soft：回填失败不影响门禁 */ }
     if (testCheck.status === 'failed') {
+      // ── 纯超时降档（R4 门禁价值考古 2026-09-21：227 跑 106 败里 36 次 600s 帽杀纯超时假拦
+      //    =失败桶最大单一来源）。超时=未完成非测试挂——所有失败单元 reason 均含超时 → advisory
+      //    放行带处置指引；任一单元真实挂测/退出码 → 维持原硬拦（真拦 12 次的防线不动）。──
+      let timeoutOnly = false
+      try {
+        const { isTimeoutOnlyTestFailure } = await import('../verify-postcheck.js')
+        timeoutOnly = isTimeoutOnlyTestFailure(testCheck)
+      } catch { /* 判定链异常维持硬拦（保守） */ }
+      if (timeoutOnly) {
+        if (verifyGateSnap) { try { verifyGateSnap.cleanup() } catch {} ; verifyGateSnap = null }
+        console.warn('\n⚠️ Verify 实测门未在超时帽内完成（纯超时，无任何挂掉的测试）——降档 advisory 不阻断：')
+        console.warn(`   ${testCheck.reason || ''}`)
+        console.warn('   处置：① local.yaml 配置 modules: 块（name: { path, test }）启用模块子集实测——触碰模块全套测试，时长与超时同步收窄；② 定向复跑触碰模块自证；③ 确需长跑设 SILLYSPEC_TEST_TIMEOUT_MS。')
+      } else {
       if (verifyGateSnap) {
         try { const { printSnapshotFailureHint } = await import('./gate-snapshot.js')
           printSnapshotFailureHint(verifyGateSnap) } catch { /* 提示失败不影响阻断 */ }
@@ -953,6 +1105,7 @@ export async function runStageCompletionGates({ stageName, cwd, changeName, plat
       } catch { /* 归因提示失败不影响阻断语义 */ }
       console.error('   请修复失败的测试并更新 verify-result.md 后重新完成此步骤。')
       return await rollbackCompletionAndReturn(pm, progress, stageData, steps, currentIdx, cwd, changeName, platformOpts, { type: 'gate_rollback', detail: 'verify-test' })
+      } // else（纯超时降档分支）结束——真实测试失败分支的 rollback 语义不变
     }
     // lint 对账（2026-08-21 审查 CLI-1）：test 侧"自报告 PASS 但实测失败→阻断"已闭环，
     // lint 侧此前纯口头——CLI 亲自执行 commands.lint，advisory 起步（失败打印不阻断，观察期后升级）
@@ -983,6 +1136,22 @@ export async function runStageCompletionGates({ stageName, cwd, changeName, plat
     // 逃生 SILLYSPEC_VERIFY_LINT_GATE=advisory）
     const { shouldBlockVerifyLint } = await import('../verify-postcheck.js')
     if (shouldBlockVerifyLint(lintCheck)) {
+      // ── lint 归属鉴定降档（R4-S-F 实证：verify 侧 lint 硬门 7 轮全是 HEAD 存量债——隔离
+      //    快照含基线债文件时恒败，agent 被逼范围外清偿或逃生口）。失败输出提及文件 × 本变更
+      //    文件集零交集 → 存量债 advisory 降档放行（债非本变更引入，硬拦只是制造范围外功）；
+      //    有交集 / 输出无可识别路径（unattributable，纯配置错误类）→ 维持硬拦（保守）。──
+      let lintOwnership = null
+      try {
+        const { triageLintOwnership, resolveVerifyChangedFiles } = await import('../verify-postcheck.js')
+        const lintScopeFiles = (resolveVerifyChangedFiles(cwd, changeName, null, { includeWorkingTree: true, specBase }) || [])
+          .map(f => String(f).replace(/\\/g, '/')).filter(f => !f.startsWith('.sillyspec/'))
+        lintOwnership = triageLintOwnership({ failureFiles: lintCheck.failureFiles || [], changeFiles: lintScopeFiles })
+      } catch { /* 鉴定链异常维持硬拦（保守） */ }
+      if (lintOwnership && lintOwnership.verdict === 'pre-existing') {
+        console.warn('\n⚠️ Verify lint 实测失败，但归属鉴定为 HEAD 存量债（失败提及文件与本变更文件集零交集）——降档 advisory 不阻断 verify 完成：')
+        console.warn(`   存量债文件：${(lintCheck.failureFiles || []).join('、') || '（见上方输出）'}`)
+        console.warn('   处置建议：单独 quick 机械清偿（顺手清债解锁全仓 lint 门），或本变更确认无关时设 SILLYSPEC_VERIFY_LINT_GATE=advisory（审计留痕）。债随基线存在，与本变更交付无关。')
+      } else {
       console.error('\n❌ verify 阶段被阻断：CLI 亲自实测 lint 失败（agent 的 lint 自报告与实测不符时以实测为准）。')
       if (usedSnapInfo) {
         try { const { printSnapshotFailureHint } = await import('./gate-snapshot.js')
@@ -1006,6 +1175,7 @@ export async function runStageCompletionGates({ stageName, cwd, changeName, plat
       }
       console.error('   修复后重跑 --done（进度不丢）；确认要跳过实测请设 SILLYSPEC_VERIFY_LINT_GATE=advisory（审计留痕）。')
       return await rollbackCompletionAndReturn(pm, progress, stageData, steps, currentIdx, cwd, changeName, platformOpts, { type: 'gate_rollback', detail: 'verify-lint' })
+      } // else（pre-existing 降档分支）结束——维持硬拦分支的 rollback 语义不变
     }
     // 契约 parity 对账：扫前端 API 调用 vs execute 提取的 provider endpoint artifact。
     // 接线自 contract-matrix pipeline（verifyApiParity 的 CLI 入口）。
@@ -1018,7 +1188,8 @@ export async function runStageCompletionGates({ stageName, cwd, changeName, plat
     const deletionCheck = runVerifyDeletionCheck({ cwd, specBase, changeName })
     printVerifyDeletionCheck(deletionCheck)
     // ── required-evidence 对账（2026-09-08-ir-verify-facts FR-03：v2 起 cannot_verify 不闭环阻断）──
-    // execute Task Review Gate 把 cannot_verify 任务的 evidence 落盘 verify-required-evidence.json。
+    // verify-required-evidence.json 由退役前的 execute Task Review Gate 写入
+    // （2026-09-26-task-review-retire 起停写；在场则消费=历史变更兼容读，缺席=无 cannot_verify 任务）。
     // v2 槽优先分类核验（FR-02）：blocked = missing 无豁免或 satisfied 核验不过 → 阻断 verify 完成
     // （此前 advisory 只查「提及」——死链不闭环）；无槽存量 md 降级 legacy 子串对账（warning 不阻断）。
     const { runVerifyRequiredEvidenceCheck, printVerifyRequiredEvidenceCheck, trackVerifyResultRegression } = await import('../verify-postcheck.js')
@@ -1076,6 +1247,7 @@ export async function runStageCompletionGates({ stageName, cwd, changeName, plat
     // 放行态），fail-soft 不影响 gate 判定；②类阻断回执同样留档供平台/审计消费
     writeReconcileRunResult({ runtimeRoot: reconcileRuntimeRoot, changeName, envelope: reconcileEnvelope, result: reconcileCheck })
     if (reconcileBlocked) {
+      writeVerifyGatePointer({ runtimeRoot: reconcileRuntimeRoot, changeName, blocked: true, note: 'target_files ②类（missing_declared）阻断' })
       return await rollbackCompletionAndReturn(pm, progress, stageData, steps, currentIdx, cwd, changeName, platformOpts, { type: 'gate_rollback', detail: 'verify-contract' })
     }
     // ── verify-result.md 探针预填段一致性抽查（task-03 / ir-stage-p3b D-002@v1 方案A）──
@@ -1122,8 +1294,29 @@ export async function runStageCompletionGates({ stageName, cwd, changeName, plat
     // 两检查间耦合；各写各的回执、按文件名订阅更干净。fail-soft 不影响 gate 判定
     writeProbeConsistencyRunResult({ runtimeRoot: reconcileRuntimeRoot, changeName, envelope: probeEnvelope, result: probeCheck })
     if (probeBlocked) {
+      writeVerifyGatePointer({ runtimeRoot: reconcileRuntimeRoot, changeName, blocked: true, note: '探针一致性抽查 error 阻断' })
       return await rollbackCompletionAndReturn(pm, progress, stageData, steps, currentIdx, cwd, changeName, platformOpts, { type: 'gate_rollback', detail: 'verify-contract' })
     }
+    // ── verify 填槽制篡改门禁（r5l 方案3 / 评审护栏#2 承重件，v2 件二）──
+    // verify-probes --init --draft 生成的机器预填段（任务完成度/风险等级/测试结果/决策追踪）带
+    // sha256 指纹标记 + .runtime sidecar 台账；--done 对账：标记被删 / 内容哈希失配 → 阻断回滚
+    // （heredoc 整份重写的典型形态——Write 可用与否均免疫，机制修法不做生成侧劝说）。修改机器
+    // 段唯一通道 verify-probes --amend-draft（重锚 + amendment 审计）。无 sidecar（未用 draft /
+    // 存量变更）→ not-applicable 零红；门禁自身异常 fail-soft（对齐探针抽查 degraded 语义）。
+    try {
+      const { checkDraftIntegrity } = await import('../verify-draft.js')
+      const draftCheck = checkDraftIntegrity({
+        mdPath: join(specBase, 'changes', changeName, 'verify-result.md'),
+        changeName, runtimeRoot: reconcileRuntimeRoot,
+      })
+      if (draftCheck.applicable && !draftCheck.ok) {
+        console.error(`\n❌ verify-result.md 机器预填段篡改门禁：${draftCheck.violations.length} 处失配——draft 预填段被整份重写或标记被删/被手工重锚。`)
+        for (const v of draftCheck.violations) console.error(`   - ${v}`)
+        console.error('   修复：还原机器段原文（AGENT 槽——结论枚举/移交项/审查叙述——不受本门限制）；确要修改机器段，跑 sillyspec verify-probes --change ' + changeName + ' --amend-draft 留痕重锚后重新 --done。')
+        writeVerifyGatePointer({ runtimeRoot: reconcileRuntimeRoot, changeName, blocked: true, note: 'draft 篡改门禁阻断' })
+        return await rollbackCompletionAndReturn(pm, progress, stageData, steps, currentIdx, cwd, changeName, platformOpts, { type: 'gate_rollback', detail: 'verify-contract' })
+      }
+    } catch { /* 门禁异常 fail-soft（不是篡改，对齐探针 degraded 放行） */ }
     // ── ceremony 双跑收口·第一出口（2026-09-18-ceremony-risk-pricing task-04 / FR-03 / D-003；
     //    execute 评审 FAIL 项补接线）：声明档（.runtime/ceremony-tier-<change>.json 开跑定价）vs
     //    实际 diff 重跑 blast+span 的事实档，mismatch（severity=error，懒 agent 低报）汇入 verify
@@ -1164,49 +1357,40 @@ export async function runStageCompletionGates({ stageName, cwd, changeName, plat
         }
       }
     } catch { /* 自动重锚失败不影响收尾（docs gate 兜底） */ }
-    // ── module-impact 死信探针（blocking，债单 D-1/D-5）：更新结果表 pending/待办行 → 阻断 verify ──
-    // 与 archive 移动前校验（extractPendingDocSyncRows）同一口径，把死信号从 archive 提前到 verify：
-    // agent 在 verify 阶段就须完成文档同步并回填 done/skipped，而非拖到归档被拦（修复 perf-remediation
-    // 类「verify PASS → archive 才发现 pending」的时序漏洞）。
-    const verifyChangeDir = resolveChangeDir(cwd, progress, platformOpts?.specRoot)
-    if (verifyChangeDir) {
-      const impactPath = join(verifyChangeDir, 'module-impact.md')
-      if (existsSync(impactPath)) {
-        const { extractPendingDocSyncRows } = await import('./complete-handlers.js')
-        const pendingRows = extractPendingDocSyncRows(readFileSync(impactPath, 'utf8'))
-        if (pendingRows.length > 0) {
-          console.error(`\n❌ verify 阶段被阻断：module-impact.md「更新结果」表存在 ${pendingRows.length} 个未清 pending/待办项（死信）`)
-          for (const row of pendingRows) console.error(`   - ${row}`)
-          console.error('   文档同步是 verify 的收尾义务：请完成模块文档同步并回填状态为 done/skipped（说明原因），再重新完成 verify。')
-          return rollbackCompletionAndReturn(pm, progress, stageData, steps, currentIdx, cwd, changeName, platformOpts, { type: 'gate_rollback', detail: 'verify-contract' })
-        }
-      }
-    }
-    // ── 预填注清零 error 门（归档前最后一道；2026-09-18-artifact-prefill task-03 / FR-03 /
-    //    D-003@v1 门禁梯度·error 档）：白名单槽宿主文件（design.md + tasks/task-*.md）仍含
-    //    未删预填注 → 阻断 verify 完成（verify 完成是 archive 前置——「归档前注清零」的落点；
-    //    brainstorm/plan --done 的 advisory 在此收口为硬门，注在场=预填未确认）。检测单点 =
-    //    verify-probes 探针面 runProbe10PrefillNoteClearance（探针 10 --init 预填与本门同一
-    //    实现，不二算）。已知误报面：散文引用注字面量会命中——修法是核对后删注/改写散文
-    //    措辞，不是绕门。──
-    try {
-      const { runProbe10PrefillNoteClearance } = await import('../verify-probes.js')
-      const noteClearance = runProbe10PrefillNoteClearance({ specBase, changeName })
-      if (noteClearance.unclearedFiles.length > 0) {
-        console.error(`\n❌ verify 阶段被阻断：预填注清零校验未过（${noteClearance.unclearedFiles.length} 个文件的白名单槽仍含未删预填注——预填≠结论，注在场=未确认）：`)
-        for (const f of noteClearance.unclearedFiles) console.error(`   - ${f}`)
-        console.error('   修复：逐槽核对预填值后删除行尾「(预填：核对后删本注)」注（删注=确认动作）；散文含注字面量的命中改写该处措辞。清零后重新完成 verify（进度不丢）。')
-        return await rollbackCompletionAndReturn(pm, progress, stageData, steps, currentIdx, cwd, changeName, platformOpts, { type: 'gate_rollback', detail: 'verify-contract' })
-      }
-    } catch (e) {
-      console.warn(`⚠️ 预填注清零校验异常（降级放行，fail-soft——异常不是未清零，ceremony 双跑同款处置）: ${(e && e.message) || e}`)
-    }
+    // ── module-impact 死信探针 + 预填注清零 error 门：已前移至 test/lint 实测门之前 ──
+    // （fail-fast，R4-S-F 实证——纯文档 blocking 检查排在 9 分钟实测门后白烧门禁轮次；
+    //   实现体见上方「fail-fast 前置」块，此处不再重复执行。）
     // ── verify 服务进程回收（坑 verify-service-process-leak；坑 verify-pids-cross-session-kill
     // 见 reapVerifyServices 注释）──
     try {
       reapVerifyServices(platformOpts, specBase, changeName)
     } catch (e) { console.warn(`⚠️ verify 服务进程回收异常（不阻断）: ${e.message}`) }
 
+    // ── 归档就绪度报告（P3 / FR-03 / D-003@batch3，task-04）：构造归 buildArchiveReadinessReport
+    // （本文件下方导出的可测函数），此处只渲染。全只读 fail-open；无发现零输出。──
+    try {
+      const report = await buildArchiveReadinessReport({ cwd, changeName, progress, specBase: platformOpts?.specRoot || specBase })
+      if (report && (report.face.length > 0 || report.manifestGaps.length > 0 || report.impactUnlisted.length > 0 || report.agingHit)) {
+        console.log('\n📋 归档就绪度报告（verify 收口前置——archive 三查预演，全只读）：')
+        if (report.face.length > 0) {
+          console.log('  ⎿ 未-apply 交付面 ' + report.face.length + ' 个文件：' + report.face.slice(0, 5).join('、') + (report.face.length > 5 ? ' 等' : ''))
+          console.log('      建议 archive 前先 apply：sillyspec worktree apply ' + changeName)
+        } else {
+          console.log('  ⎿ 未-apply 交付面：0（干净）')
+        }
+        if (report.manifestGaps.length > 0) {
+          console.log('  ⎿ manifest 缺行草拟【待确认——确认后自行补入 design.md §6，草拟不代写】：')
+          for (const g of report.manifestGaps.slice(0, 5)) console.log('      | 修改 | ' + g + ' | 归档就绪度草拟（verify 收口前置探测） |')
+          if (report.manifestGaps.length > 5) console.log('      … 共 ' + report.manifestGaps.length + ' 个')
+        }
+        if (report.impactUnlisted.length > 0) {
+          console.log('  ⎿ module-impact 归因草拟【待确认——确认后补入未匹配/矩阵章节】：')
+          for (const u of report.impactUnlisted.slice(0, 5)) console.log('      - `' + u + '` → 归因（共位测试/镜像/并行排除…）')
+          if (report.impactUnlisted.length > 5) console.log('      … 共 ' + report.impactUnlisted.length + ' 个')
+        }
+        if (report.agingHit) console.log('  ⚠️ main 已前进且与交付面有交集（基线老化中——等待越久合并面越大，batch2 实证窗口期三方冲突）：建议立即 apply')
+      }
+    } catch { /* 就绪度报告整体 fail-open：异常零输出不影响 verify 收尾 */ }
     console.log('\n✅ 验证通过，下一步：sillyspec run archive')
   }
 
@@ -1260,6 +1444,9 @@ export async function runStageCompletionGates({ stageName, cwd, changeName, plat
 
       if (tier.tier === 'self') {
         console.log('\nℹ️  Stage Review: ' + stageName + ' tier=self（' + tier.reason + '），已降级为当前 agent 自审，不强制独立子代理。')
+      } else if (readReviewUnsupervisedWaiver(reviewChangeDir)) {
+        // 豁免凭据（review-unsupervised-exit）：无嵌套派发能力环境不强制独立审查也不接受自审表演
+        await waiveWithTelemetry({ changeName, gate: 'stage-review:' + stageName, specBase: effectiveSpecBase })
       } else {
         let reviewRunId = getLatestStageReviewRunId(runtimeRoot, stageName, changeName)
         if (!reviewRunId) {
@@ -1293,8 +1480,8 @@ export async function runStageCompletionGates({ stageName, cwd, changeName, plat
         const reviewResult = gated.result
         printStageReviewResult(reviewResult, { stage: stageName, reviewRunId, runtimeRoot, changeName })
         if (!reviewResult.ok) {
-          return await rollbackCompletionAndReturn(pm, progress, stageData, steps, currentIdx, cwd, changeName, platformOpts, { type: 'review_rejected', detail: 'stage-review' })
-        }
+          docGateFailures.push({ type: 'review_rejected', detail: 'stage-review', label: 'Stage Review 未过（stage-review，明细见上）' })
+        } else {
         // 降级自审留痕（2026-09-10 用户反馈①：PI agent 等宿主无 Agent tool，prompt 降级条款允许
         // 当前 agent 自审产出 review.json）。放行但独立性折损必须可见：⚠️ 审计行区分降级 review
         // 与真子代理 review（事后可审计），与 ⚖️/🔍 软归属同哲学——可见的折损优于静默的伪装。
@@ -1315,11 +1502,13 @@ export async function runStageCompletionGates({ stageName, cwd, changeName, plat
         if (hasDelegatedWriteDisclosure(reviewResult.review)) {
           console.warn(`\n⚠️ Stage Review 代落盘披露：${stageName} review 的 reviewerNotes 首行标记「代落盘」——review.json 由主代理代（写通道故障的）审查者落盘，独立性依赖审查者结论回传的忠实性，建议人工抽查关键结论与回传文本一致性。`)
         }
+        }
       }
     } catch (e) {
-      // fail-closed：Gate 自身异常阻断完成，不静默放行（与 Task Review Gate 一致）
+      // fail-closed：Gate 自身异常阻断完成，不静默放行
+      //（收集模式：异常也入列，检查点 B 统一 rollback）
       console.error('❌ Stage Review Gate 异常，阻断 ' + stageName + ' 完成: ' + e.message)
-      return await rollbackCompletionAndReturn(pm, progress, stageData, steps, currentIdx, cwd, changeName, platformOpts, { type: 'review_rejected', detail: 'stage-review' })
+      docGateFailures.push({ type: 'review_rejected', detail: 'stage-review', label: `Stage Review Gate 异常（${e.message}）` })
     }
   }
 
@@ -1343,109 +1532,21 @@ export async function runStageCompletionGates({ stageName, cwd, changeName, plat
     } catch { /* 提示失败不阻断 execute */ }
   }
 
-  // ── Execute Task Review Gate：所有 task 必须有 review.json 且 verdict 通过 ──
-  if (stageName === 'execute') {
-    try {
-      const { validateTaskReviews, printReviewResult, writeVerifyRequiredEvidence } = await import('../task-review.js')
-      const effectiveSpecBase = platformOpts?.specRoot || specBase
-      const planFile = resolveChangeDir(cwd, progress, platformOpts?.specRoot)
-      const planPath = planFile ? join(planFile, 'plan.md') : null
-
-      if (planPath && existsSync(planPath)) {
-        // 2026-08-20-task-truth-unify：任务清单源迁 tasks.md（validateTaskReviews 内按
-        // checkbox 行解析，tasks.md 行格式兼容原正则）；缺失回退 plan.md（旧变更兼容读侧）
-        const tasksRegistryPath = join(planFile, 'tasks.md')
-        const planContent = existsSync(tasksRegistryPath)
-          ? readFileSync(tasksRegistryPath, 'utf8')
-          : readFileSync(planPath, 'utf8')
-        const runtimeRoot = resolveRuntimeRoot(platformOpts, effectiveSpecBase)
-
-        // execute run id：从变更专属标记文件读取（agent 可写内容，格式校验防注入/穿越）
-        const runIdFile = join(runtimeRoot, `current-execute-run-id-${changeName}`)
-        let executeRunId = ''
-        try {
-          if (existsSync(runIdFile)) {
-            const c = readFileSync(runIdFile, 'utf8').trim()
-            const { isValidExecuteRunId } = await import('../task-review.js')
-            if (c && !isValidExecuteRunId(c)) {
-              console.warn(`⚠️ execute run marker 内容非法（期望 exec-YYYY-MM-DD-HHMMSS，实得 ${JSON.stringify(c.slice(0, 60))}），视为缺失回退扫描`)
-            } else {
-              executeRunId = c
-            }
-          }
-        } catch {}
-        if (!executeRunId) {
-          // marker 缺失：先扫描 execute-runs/ 既有目录找回真实 runId（与 getLatestStageReviewRunId
-          // 目录扫描兜底同语义），避免 marker 丢失而 agent 已用旧 runId 落盘时，直接 generate 新 ID
-          // 找不到旧 review、误判缺 review.json。仅当确实无既有 run 才 generate 新 ID 并落盘。
-          const { generateExecuteRunId, resolveLatestExecuteRunId, stampExecuteRunChange, claimExecuteRunId } = await import('../task-review.js')
-          executeRunId = resolveLatestExecuteRunId({ runtimeRoot, changeName }) || ''
-          if (!executeRunId) {
-            executeRunId = generateExecuteRunId(changeName)
-            // 落盘（marker 缺失时 fallback 生成后写盘，保证后续 checkbox/gate 读到同一 ID）
-            // D-001#1 fallback 写入点：mkdir execute-runs/<runId>/tasks 先于 marker（不变量：
-            // marker 在则目录在）。不 try/catch——异常直穿外层 catch 走 fail-closed 阻断
-            //（gate 自身写 run 目录失败不能静默放行完成）。
-            // 排他认领（坑 exec-run-id-same-second-collision）：并行会话同秒碰撞在认领处消解
-            executeRunId = claimExecuteRunId(runtimeRoot, executeRunId)
-            mkdirSync(join(runtimeRoot, 'execute-runs', executeRunId, 'tasks'), { recursive: true })
-            writeAtomicSync(runIdFile, executeRunId + '\n')
-            stampExecuteRunChange(runtimeRoot, executeRunId, changeName)
-          }
-        }
-
-        // git 真实性校验目录：worktree 存在则用 worktree（base/head commit 在其中），否则主仓库。
-        // 跨仓支持（task-07 / design §6 gates 行 + D-013）：
-        //   - 有 ctx（execute 启动入口 task-09 构造的 MultiRepoContext 实例）→ 用
-        //     ctx.resolve('main').gitDir 作为主仓 task 的校验 cwd。ctx 的 main entry 已在
-        //     _buildMainEntry 内统一编码 worktreePath/cwd + in-place-fallback 兜底（与 task-review.js:724
-        //     generateTaskReviewDrafts 的 in-place 逻辑同源），避免两处漂移。Task Review Gate 内部循环
-        //     再按 review.repo ?? 'main' 从 ctx.resolve(repo).gitDir 切跨仓 task 的 gitDir（task-04 实现）。
-        //   - 无 ctx（ctx=null 缺省，单仓 / 旧调用链）→ 走原逻辑（meta.worktreePath 或 cwd），零回归。
-        let reviewGitDir = cwd
-        if (ctx) {
-          const mainEntry = ctx.resolve('main')
-          if (mainEntry?.gitDir) reviewGitDir = mainEntry.gitDir
-        } else {
-          try {
-            const { WorktreeManager } = await import('../worktree.js')
-            const wm = new WorktreeManager({ cwd })
-            const meta = wm.getMeta(changeName)
-            if (meta?.worktreePath && meta.mode !== 'in-place-fallback' && existsSync(meta.worktreePath)) {
-              reviewGitDir = meta.worktreePath
-            }
-          } catch {}
-        }
-
-        const reviewResult = validateTaskReviews({ planContent, runtimeRoot, executeRunId, changeDir: planFile, gitDir: reviewGitDir, ctx })
-        printReviewResult(reviewResult, { runtimeRoot, executeRunId })
-
-        if (!reviewResult.ok) {
-          // Task review 校验失败，阻断 execute 完成
-          // 检查是否存在 checkbox 已勾但 review 不通过的情况
-          const uncheckedTasks = reviewResult.errors.filter(e => e.includes('缺少 review.json'))
-          if (uncheckedTasks.length > 0) {
-            console.error('\n⚠️  部分任务已在 tasks.md 中勾选，但 review.json 不存在。')
-            console.error(`   请取消勾选这些任务的 checkbox，或补充对应的 review.json（execute run ID: ${executeRunId}）。`)
-          }
-          return await rollbackCompletionAndReturn(pm, progress, stageData, steps, currentIdx, cwd, changeName, platformOpts, { type: 'review_rejected', detail: 'task-review' })
-        }
-
-        // cannot_verify 的 requiredEvidence 写入 change 目录，供 verify 阶段消费
-        if (reviewResult.requiredEvidence.length > 0) {
-          const evidencePath = writeVerifyRequiredEvidence(join(effectiveSpecBase, 'changes', changeName), reviewResult.requiredEvidence)
-          if (evidencePath) {
-            console.log(`📄 verify-required-evidence.json 已写入: ${evidencePath}`)
-            console.log('   verify 阶段必须满足这些证据要求。')
-          }
-        }
-      }
-    } catch (e) {
-      // fail-closed：Gate 自身异常时不能默认放行，否则异常成了绕过评审的通道
-      console.error(`❌ Task Review Gate 异常，阻断 execute 完成: ${e.message}`)
-      console.error('   请检查 review.json / plan.md 是否可读，修复后重新完成此步骤。')
-      return await rollbackCompletionAndReturn(pm, progress, stageData, steps, currentIdx, cwd, changeName, platformOpts, { type: 'review_rejected', detail: 'task-review' })
-    }
+  // ── Execute Task Review Gate 已退役（2026-09-26-task-review-retire）──
+  // 原「所有 task 必须有 review.json 且 verdict 通过」块随层整体退役删除：R18 对撞实证该层在
+  // 无嵌套派发环境全降自审表演（15 次拦截 5 次形式合规、实质拦截为零），前置豁免通道
+  // （review-unsupervised-exit）已覆盖无派发环境。task 粒度审计由 execute 收口的代码证据核验
+  // （checkExecuteCodeEvidence，detectExecuteBatchFinish 内）+ verify 测试对账承担；Stage Review
+  // Gate（阶段粒度）保留。残存 review.json 走 task-review.js 保留导出（历史兼容读侧）。
+  // ── 收集模式检查点 B（brainstorm/plan/execute）：纯文档门（validators / Stage Review）
+  //    全量收口——非空则一次打印清单、统一 rollback 一次（R15「连挡 4 次」的解；
+  //    detail 取首门，进度库信号语义不变）。verify 走检查点 A（其实测门在前）。──
+  if (stageName !== 'verify' && docGateFailures.length > 0) {
+    console.error(`\n❌ ${stageName} 收口被 ${docGateFailures.length} 道纯文档门拦截（一次性全列——全部修复后重跑一次 --done，不必逐门连撞）：`)
+    docGateFailures.forEach((f, i) => console.error(`   ${i + 1}. ${f.label}`))
+    console.error(`   （各门明细见上方对应 ❌/⚠️ 段落）`)
+    const firstFail = docGateFailures[0]
+    return await rollbackCompletionAndReturn(pm, progress, stageData, steps, currentIdx, cwd, changeName, platformOpts, { type: firstFail.type, detail: firstFail.detail })
   }
 
   // ── 仪式档位摩擦升档检查点（task-03 / D-008，design 生命周期契约表「阶段门升档」行）──
@@ -1721,6 +1822,27 @@ export async function completeStageGates({ stageName, cwd, changeName, platformO
     }
   }
 
+  // ── full 流程绑定面补齐（2026-09-27-gate-face-binding-parity，R23-full 实证缺口）──
+  // 绑定槽此前只在 thin flow start 收编时追加（flow.js ensureBindingSlots）；full 流程
+  // requirements 由 brainstorm 产出、无绑定面且不经过 flow start → test-trace 恒空 →
+  // FR 入库永远无 tests 绑定，动态门 FR 回归源对 full 出身 FR 失效。此处单源复用
+  // ensureBindingSlots（已有槽/无 FR 块均 no-op），verify --done 的 auto-bind 因槽在场闭环。
+  // best-effort：追加失败只告警不阻断 brainstorm 收尾。
+  if (stageName === 'brainstorm' && changeName) {
+    try {
+      const changeDir = join(specBase, 'changes', changeName)
+      if (existsSync(join(changeDir, 'requirements.md'))) {
+        const { ensureBindingSlots } = await import('../flow-draft.js')
+        const b = ensureBindingSlots({ changeDir })
+        if (b.appended) {
+          console.log(`📌 追加测试绑定槽 ${b.slots} 枚（full 流程 requirements 无绑定面——plan/execute 写测试时作答，verify --done 将从实测结果自动补全空槽）`)
+        }
+      }
+    } catch (e) {
+      console.warn(`⚠️ 绑定槽追加失败（best-effort 不阻断）: ${(e && e.message) || e}`)
+    }
+  }
+
   // scan 平台 manifest + post-check（S1 平台受害者：noAI scanPostcheck 末步 / continueStep 现也走这里）
   const _scanResult = await handleScanStageCompleted({ stageName, currentIdx, cwd, progress, pm, stageData, changeName, outputText, platformOpts })
   if (_scanResult) return _scanResult
@@ -1760,7 +1882,7 @@ export async function completeStageGates({ stageName, cwd, changeName, platformO
     pm._write(cwd, progress, changeName)
   }
 
-  // 阶段完成校验 gate 级联（runValidators → verify-test → Plan→Execute → Stage Review → Task Review）
+  // 阶段完成校验 gate 级联（runValidators → verify-test → Plan→Execute → Stage Review）
   if (settledCount === total && total > 0) {
     const _gateEarlyReturn = await runStageCompletionGates({ stageName, cwd, changeName, platformOpts, specBase, progress, pm, stageData, steps, currentIdx, ctx })
     if (_gateEarlyReturn) return _gateEarlyReturn
@@ -1890,6 +2012,42 @@ export function writeReconcileRunResult({ runtimeRoot, changeName, envelope, res
   }
 }
 
+/**
+ * verify --done 阻断明细稳定锚点（quick-D，2026-09-20 报告问题 D）：ts 目录（verify-runs/<ts>/
+ * reconcile-result.json 等）的可发现性依赖 stdout——宿主把长命令转后台截断输出后，逐条打印的
+ * ②类明细实际取不回（实证：target_files 阻断明细靠推断绕 3 轮才定位）。稳定路径指针（每次
+ * 覆盖、不随 ts 变）指向本轮最新 verify-runs 目录，agent 无 stdout 也能直读。fail-soft：
+ * 写失败只留痕不阻断 gate（对齐 writeReconcileRunResult 口径）。
+ * @param {{ runtimeRoot: string, changeName: string|null, blocked?: boolean, note?: string }} opts
+ * @returns {string|null} 成功返回指针路径；失败返回 null
+ */
+export function writeVerifyGatePointer({ runtimeRoot, changeName, blocked = false, note = '' }) {
+  try {
+    const ts = new Date().toISOString().slice(0, 19).replace(/[-T:]/g, '')
+    const runsDir = join(runtimeRoot, 'verify-runs')
+    const pointerPath = join(runsDir, `gate-last-${changeName || 'change'}.json`)
+    mkdirSync(runsDir, { recursive: true })
+    writeFileSync(pointerPath, JSON.stringify({
+      change: changeName,
+      blocked,
+      note,
+      latest_run_dir: join(runsDir, ts),
+      artifacts_hint: [
+        `${ts}/reconcile-result.json（target_files ②类阻断明细在 missing 数组）`,
+        `${ts}/probe-consistency-result.json（探针一致性抽查明细）`,
+      ],
+      written_at: new Date().toISOString(),
+    }, null, 2) + '\n')
+    if (blocked) {
+      console.error(`\n📄 verify 门失败明细稳定锚点（stdout 被截断时直读此文件）: ${pointerPath}\n   逐条明细在指针文件指向的 verify-runs/<ts>/ 目录（reconcile-result.json 的 missing 数组等）`)
+    }
+    return pointerPath
+  } catch (e) {
+    console.error(`⚠️ verify 门稳定锚点写入失败（不影响 gate）: ${e.message}`)
+    return null
+  }
+}
+
 /**
  * 打印 target_files 对账结果（task-05 接线配套的打印层）。
  *
@@ -2163,7 +2321,7 @@ export function killProcessTree(pid, sig = 'SIGTERM') {
   if (process.platform === 'win32') {
     // /T = 连同子进程树（shell 包装下的 python/node 服务本体）；/F = 强制（长驻服务常吞 SIGTERM 等价物）
     try {
-      execFileSync('taskkill', ['/PID', String(pidNum), '/T', '/F'], { stdio: 'ignore', timeout: 15000 })
+      execFileSync('taskkill', ['/PID', String(pidNum), '/T', '/F'], { stdio: 'ignore', timeout: 15000, windowsHide: true })
       return true
     } catch (e) {
       // taskkill 对不存在进程退出码 128（等价 ESRCH，已退出按回收静默）；其余（拒绝访问等）上抛
@@ -2182,7 +2340,7 @@ export function killProcessTree(pid, sig = 'SIGTERM') {
 /** ps 枚举直接子进程 PID（POSIX；失败返回空——杀不到子进程不阻断父进程回收） */
 function listChildPids(parentPid) {
   try {
-    const out = execFileSync('ps', ['-axo', 'pid=,ppid='], { encoding: 'utf8', timeout: 5000 })
+    const out = execFileSync('ps', ['-axo', 'pid=,ppid='], { encoding: 'utf8', timeout: 5000, windowsHide: true })
     const children = []
     for (const line of String(out).split('\n')) {
       const m = line.trim().match(/^(\d+)\s+(\d+)$/)
@@ -2223,3 +2381,59 @@ export function reapVerifyServices(platformOpts, specBase, changeName) {
   if (failedAll.length > 0) console.warn(`⚠️ 服务进程回收失败 ${failedAll.length} 个：${failedAll.join(', ')} — 手动处理：taskkill /PID <pid> /F（Windows）/ kill -9 <pid>`)
   return { reaped: reapedTotal, receiptPath }
 }
+
+
+/**
+ * buildArchiveReadinessReport —— 归档就绪度报告构造（P3 / FR-03 / D-003@batch3，task-04）。
+ * verify PASS 后、archive 前的三查前置（batch2 实证三查全压 archive 时段首查=15 回合主因）。
+ * 纯读：①未-apply 交付面（applyWorktree checkOnly，含 ql-009②/ql-010 合并感知口径）②manifest
+ * 缺行草拟集（面文件不在 design §6 清单——草拟不代写，agent 确认后自落）③module-impact 归因
+ * 草拟集（面文件不在 module-impact.md 文本）④基线老化命中（main HEAD 前进过 worktree 基点
+ * ∩ 前进文件与交付面有交集）。无 worktree（meta 缺/in-place/native）→ 全空（零噪音）。
+ * fail-open：任一探测异常只置空该项，不抛（渲染层再兜一层）。
+ */
+export async function buildArchiveReadinessReport({ cwd, changeName, progress, specBase }) {
+  const out = { face: [], manifestGaps: [], impactUnlisted: [], agingHit: false }
+  try {
+    const { WorktreeManager } = await import('../worktree.js')
+    const wm = new WorktreeManager({ cwd })
+    const meta = wm.getMeta(changeName)
+    if (!meta || meta.mode === 'in-place-fallback' || meta.mode === 'native-worktree'
+      || !meta.worktreePath || !existsSync(meta.worktreePath)) return out
+    const { applyWorktree } = await import('../worktree-apply.js')
+    const probe = applyWorktree(changeName, { cwd, checkOnly: true })
+    out.face = (probe && Array.isArray(probe.changedFiles)) ? probe.changedFiles : []
+    if (out.face.length === 0) return out
+    // ② manifest 缺行草拟
+    try {
+      const changeDir = resolveChangeDir(cwd, progress || {}, specBase)
+      if (changeDir) {
+        const designPath = join(changeDir, 'design.md')
+        if (existsSync(designPath)) {
+          const { parseFileChangeList } = await import('../change-list.js')
+          const declared = parseFileChangeList(designPath, { keepSillyspecDocs: true })
+          out.manifestGaps = out.face.filter(f => !declared.has(f))
+        }
+      }
+    } catch { /* 草拟失败置空该项 */ }
+    // ③ module-impact 归因草拟
+    try {
+      const changeDir2 = resolveChangeDir(cwd, progress || {}, specBase)
+      const miPath = changeDir2 ? join(changeDir2, 'module-impact.md') : null
+      const miText = (miPath && existsSync(miPath)) ? readFileSync(miPath, 'utf8') : ''
+      out.impactUnlisted = out.face.filter(f => !miText.includes(f))
+    } catch { /* 同上 */ }
+    // ④ 基线老化命中
+    try {
+      if (meta.baseHash) {
+        const { gitQuiet } = await import('../git-helper.js')
+        const advanced = gitQuiet(cwd, ['diff', '--name-only', meta.baseHash + '..HEAD'])
+        if (advanced) {
+          const advSet = new Set(advanced.split('\n').filter(Boolean))
+          out.agingHit = out.face.some(f => advSet.has(f))
+        }
+      }
+    } catch { /* git 失败不提示 */ }
+  } catch { /* 整体 fail-open → 全空 */ }
+  return out
+}