sillyspec 3.28.4 → 3.28.5

package/src/run/complete.js

@@ -19,6 +19,7 @@
 import { join } from 'node:path'
 import { existsSync, readFileSync, mkdirSync, writeFileSync, appendFileSync } from 'node:fs'
 import { writeAtomicSync } from '../fs-atomic.js'
+import { gitQuiet } from '../git-helper.js'
 import { withFileLock } from '../quicklog.js'
 import { triggerSync, WAIT_MARKER_RE, getStageSteps, formatWaitOptions, resolveRuntimeRoot, getOrCreateMultiRepoContext, resolveChangeDir } from './shared.js'
 
@@ -48,7 +49,6 @@ import { formatExecuteSummary } from '../worktree-apply.js'
 import { validateDecisionModuleRefs } from '../design-facts.js'
 import { isEndToEndTaskText } from '../change-risk-profile.js'
 import { deriveTitleFromLinkedChange } from '../quicklog.js'
-import { gitQuiet } from '../git-helper.js'
 
 // validateMetadata / readDesignScale / validateFileLocations 已迁至 ./gates.js（completeStageGates
 // 共享收尾管线，消除 noAI 末步 / continueStep 完成分支绕过 gate 的 S1/S2/S3 不对称）。
@@ -97,6 +97,26 @@ export function resolveWaitingStepWithAnswer(steps, doneAnswer, nowStr) {
   return waitIdx
 }
 
+/**
+ * 事实性步骤摘要合成（P0-2，noai-ir-roadmap §3）：--output 省略时由 CLI 按既有事实合成
+ * ——步骤名 + 变更窗口（git porcelain 计数与前几个路径）+ 门禁以 CLI 校验输出为准。
+ * 纯事实零编造（无「通过/成功」等判断词——判断在 gate，不在摘要）；语义性说明（方案
+ * 取舍/用户反馈）不合成，摘要自带手写指引。长度控制在 MAX_OUTPUT(200) 截断线内。
+ */
+export function synthesizeStepOutput({ stageName, stepName, cwd }) {
+  let windowNote = ''
+  try {
+    const porcelain = gitQuiet(cwd, ['status', '--porcelain'])
+    if (porcelain !== null) {
+      const paths = porcelain.split('\n').filter(Boolean).map((l) => (l.slice(3) || '').trim()).filter(Boolean)
+      windowNote = paths.length === 0
+        ? '；工作区无未提交变更'
+        : `；变更窗口 ${paths.length} 文件（${paths.slice(0, 3).map((p) => p.split(/[\\/]/).pop()).join('、')}${paths.length > 3 ? ' 等' : ''}）`
+    }
+  } catch { /* git 不可读 → 窗口段缺省（摘要仍成立） */ }
+  return `【CLI 合成】步骤「${stepName}」完成${windowNote}；门禁以本次 CLI 校验输出为准（方案取舍等语义说明需 --output 手写）`
+}
+
 export async function completeStep(pm, progress, stageName, cwd, outputText, inputText = null, options = {}) {
   const { printNext = true, confirm = false, changeName, platformOpts = {}, nonInteractive = false, isForceBaseline = false, isAllowNew = false, isAllowDelete = false, quickFiles = [] } = options
   // specRoot(平台) > specDriftAnchor(worktree 漂移锚定主仓) > cwd/.sillyspec(本地)——
@@ -158,6 +178,16 @@ export async function completeStep(pm, progress, stageName, cwd, outputText, inp
     currentIdx = _resolvedWaitIdx
     console.log(`⚠️  Step "${steps[_resolvedWaitIdx].name}" 此前处于 waiting，--done --answer 已补回答并拉回待完成。`)
   }
+
+  // ── P0-2（noai-ir-roadmap §3）：--output 省略 → CLI 按事实合成步骤摘要 ──
+  // agent 手打摘要是每步命中的幻觉源；事实面（步骤名 + 变更窗口 + 门禁以 CLI 校验为准）
+  // CLI 本就持有，纯事实合成零编造（判断词留给 gate）。语义性说明（方案取舍/用户反馈）仍应
+  // --output 手写——合成摘要自带该指引。quick 阶段除外（末步四字段硬契约
+  // validateQuickResult，合成文本过不了四字段校验；quick 的省略提示由其阶段文案承担）。
+  if (!outputText && stageName !== 'quick' && currentIdx !== -1 && steps[currentIdx]) {
+    outputText = synthesizeStepOutput({ stageName, stepName: steps[currentIdx].name, cwd })
+    console.log(`🤖 --output 未提供——CLI 已按事实合成步骤摘要（gate 校验照常；方案取舍等语义说明下次带 --output 手写）。`)
+  }
   // ── waiting 前置守卫（坑 archive-step3-wait-answer-hint-late）──
   // 普通 --done（无 --answer）时若存在 waiting 步骤：currentIdx 会跳过它推进后续步骤
   //（findIndex 只查 pending/in-progress），步骤被静默越过 + --answer 要求要到别处报错才暴露。
@@ -380,6 +410,16 @@ export async function completeStep(pm, progress, stageName, cwd, outputText, inp
     } else if (_cliAction === 'progressConfirm') {
       // 与 stage.js noAI 分支同语义（brainstorm/execute/verify step1 进度确认）
       executeProgressConfirm({ stageName, cwd, stageData, changeName, pm })
+    } else if (_cliAction === 'verifyRunQualityScan') {
+      // 与 stage.js noAI 分支同语义（P0-1 noai-ir-roadmap §3：verify 测试步实测提前 + 指纹复用；
+      // 失败 throw → completeStep 不推进，步骤保持 pending）
+      const { executeVerifyQualityScan } = await import('./verify-quality-scan.js')
+      await executeVerifyQualityScan({ cwd, specBase, changeName, platformOpts })
+    } else if (_cliAction === 'archiveDistill') {
+      // 与 stage.js noAI 分支同语义（P0-4 安全变体：distill 提炼 CLI 机械执行，needsWait 裁决
+      // 收敛到「确认归档 --confirm」；全路径不抛）
+      const { executeArchiveDistill } = await import('./archive-distill.js')
+      await executeArchiveDistill({ cwd, specBase, changeName })
     } else if (_cliAction === 'doctorRunDiagnostics') {
       // 2026-09-09-doctor-noai：与 stage.js 分支同语义（诊断+渲染+落盘）
       const { runDoctorDiagnostics, renderDoctorSummary, writeDoctorDiagnosis } = await import('../doctor-diagnostics.js')
@@ -622,6 +662,10 @@ export async function completeStep(pm, progress, stageName, cwd, outputText, inp
     const total = steps.length
     console.log(`✅ ${stageName} 阶段已完成（${total}/${total} 步）`)
 
+    // task-04（2026-09-10-change-scope-audit）：execute 完成打范围对账全表+落 .runtime 快照 /
+    // verify 完成出一行漂移确认。advisory fail-soft（D-006）——helper 内部全兜，绝不阻断完成。
+    await printStageCompletionScopeAudit({ stageName, cwd, changeName, specBase, platformOpts })
+
     if (stageName === 'execute') {
       // execute run summary：展示真实可得的结构化信息
       try {
@@ -666,6 +710,7 @@ export async function completeStep(pm, progress, stageName, cwd, outputText, inp
       // 走下方 _getNextSuggestion 会因 scan 是 STAGE_ORDER 首位、永未完成而误推 scan（回头路），
       // 与 brainstorm 同类问题（见上注释），故给 quick 专属分支。
       console.log('\n👉 quick 已完成。下一步：提交本次改动（git commit / sillyspec-commit），或 sillyspec run <stage> 继续其他阶段。')
+      console.log('   ⚠️ 多会话共享仓禁目录级 git add / git add -A（会夹带并行会话文件，2026-09-10 实证误删已提交文档）：用显式 pathspec（git add -- 文件…），提交前 git status 核对暂存面。')
     } else {
       // D1 暗衔接修：阶段刚完成，CLI 本就知道状态机下一步是哪个阶段（_getNextSuggestion），
       // 却只丢一句「下一步由你决定」让 agent 自己猜命令。改为按 progress 实际状态给出精确命令。
@@ -729,6 +774,95 @@ export async function completeStep(pm, progress, stageName, cwd, outputText, inp
   return { stageCompleted: false, currentIdx, nextPendingIdx }
 }
 
+// ── 变更范围对账 advisory 注入（2026-09-10-change-scope-audit task-04，FR-03）──
+// execute 完成打全表+落快照、verify 完成出一行漂移确认；completeStep 与 continueStep（wait
+// 解除完成）两路径收敛点同调 printStageCompletionScopeAudit（Grill G-2：单锚 completeStep 会漏
+// wait 解除路径致 verify 假报无快照）。全程 fail-soft（D-006）：任何异常只打单行 ⚠️，不阻断
+// 阶段完成、不进任何门禁判定。scope-audit.js 经动态 import 接入（本文件 runtime-hygiene /
+// design-facts 等同款先例）——只读纯函数模块，模块缓存下零重复加载。
+//   - execute：renderScopeAuditTable 全表（maxRows 60 截断 + 完整表跑 scope-audit 指引 +
+//     ⚠️ 出口指引行——计划外补 design.md 声明或 --output 注明原因，均 renderer 内置）+ 落
+//     .runtime/scope-audit-<change>.json 快照（结构即 ScopeAuditResult + savedAt 落盘时间戳，
+//     只写 .runtime 运行时产物区不动 git 状态）。
+//   - verify：读快照对比文件集差集出一行「变更范围：N 文件 +X/-Y（vs execute 时点：一致|漂移
+//     M 文件：<列表截断>）」。漂移过滤面 = filterDeliverableFiles 结果（resolveReconcileActualFiles
+//     已过、本就保留 docs 子树）再排除 .sillyspec/docs/**——verify 阶段合法文档同步不计漂移
+//     （Grill C-5/P2-②：组合过滤在本侧做，不动 worktree-apply.js 过滤器本体）。快照缺失/降级 →
+//     跳过对比只打当前 totals 一行。
+
+/** 漂移对比排除面：verify 阶段合法文档同步子树（posix 归一后前缀匹配） */
+const SCOPE_DRIFT_EXCLUDE_RE = /^\.sillyspec\/docs\//
+
+/** 快照/当前结果 → 漂移对比用文件集（posix 归一 + docs 子树排除）；畸形结构防御式得空集 */
+function scopeAuditPathSet(result) {
+  const rows = Array.isArray(result?.rows) ? result.rows : []
+  const set = new Set()
+  for (const r of rows) {
+    const p = r && typeof r.path === 'string' ? r.path.replace(/\\/g, '/') : ''
+    if (p && !SCOPE_DRIFT_EXCLUDE_RE.test(p)) set.add(p)
+  }
+  return set
+}
+
+/** execute 完成路径：全表 + 快照落盘（快照写失败只提示，verify 对比按无快照降级） */
+async function printExecuteScopeAudit({ cwd, changeName, specBase, platformOpts, computeChangeScopeAudit, renderScopeAuditTable }) {
+  const result = await computeChangeScopeAudit({ cwd, specBase, changeName, platformOpts })
+  console.log(`\n${renderScopeAuditTable(result, { maxRows: 60 })}`)
+  try {
+    const runtimeRoot = resolveRuntimeRoot(platformOpts, specBase)
+    const snapPath = join(runtimeRoot, `scope-audit-${changeName}.json`)
+    mkdirSync(runtimeRoot, { recursive: true })
+    writeFileSync(snapPath, JSON.stringify({ ...result, savedAt: new Date().toISOString() }, null, 2) + '\n')
+  } catch (e) {
+    console.warn(`   ⚠️ 范围对账快照写入失败（不阻断，verify 漂移对比将按无快照降级）：${e && e.message ? String(e.message).split('\n')[0] : e}`)
+  }
+}
+
+/** verify 完成路径：读 execute 时点快照对比文件集差集，一行结论（行数不比——execute 形态 A 锚
+ *  worktree meta、verify 形态 B 锚 merge-base，基点不同行数天然抖动，比行数必假阳） */
+async function printVerifyScopeDrift({ cwd, changeName, specBase, platformOpts, computeChangeScopeAudit }) {
+  const result = await computeChangeScopeAudit({ cwd, specBase, changeName, platformOpts })
+  const totals = result?.totals && typeof result.totals === 'object' ? result.totals : {}
+  const scopeLine = `变更范围：${totals.files ?? (Array.isArray(result?.rows) ? result.rows.length : 0)} 文件 +${totals.additions ?? 0}/-${totals.deletions ?? 0}`
+  if (result?.ok !== true) {
+    console.log(`   ⚠️ ${scopeLine}（对账降级：${result?.degradedReason || '实际侧文件集解析失败'}——advisory，不影响 verify 完成）`)
+    return
+  }
+  let snapshot = null
+  try {
+    snapshot = JSON.parse(readFileSync(join(resolveRuntimeRoot(platformOpts, specBase), `scope-audit-${changeName}.json`), 'utf8'))
+  } catch { /* 快照缺失/损坏 → 跳过对比只打当前 totals */ }
+  if (!snapshot || snapshot.ok !== true) {
+    console.log(`   ${scopeLine}（无 execute 时点快照可对比——完整表跑 sillyspec scope-audit --change ${changeName}）`)
+    return
+  }
+  const current = scopeAuditPathSet(result)
+  const baseline = scopeAuditPathSet(snapshot)
+  const drift = [...new Set([...current, ...baseline])].filter(p => current.has(p) !== baseline.has(p)).sort()
+  if (drift.length === 0) {
+    console.log(`   ${scopeLine}（vs execute 时点：一致）`)
+  } else {
+    const shown = drift.slice(0, 5).join(', ')
+    const tail = drift.length > 5 ? ` 等 ${drift.length} 个` : ''
+    console.log(`   ${scopeLine}（vs execute 时点：漂移 ${drift.length} 文件：${shown}${tail}——advisory 不阻断，请确认 verify 期改动并按需补 design.md 声明）`)
+  }
+}
+
+/** 两完成路径公共入口（stage 派发 + 动态 import + fail-soft 兜底，D-006） */
+async function printStageCompletionScopeAudit({ stageName, cwd, changeName, specBase, platformOpts }) {
+  try {
+    if (!changeName || (stageName !== 'execute' && stageName !== 'verify')) return
+    const { computeChangeScopeAudit, renderScopeAuditTable } = await import('../scope-audit.js')
+    if (stageName === 'execute') {
+      await printExecuteScopeAudit({ cwd, changeName, specBase, platformOpts, computeChangeScopeAudit, renderScopeAuditTable })
+    } else {
+      await printVerifyScopeDrift({ cwd, changeName, specBase, platformOpts, computeChangeScopeAudit })
+    }
+  } catch (e) {
+    console.warn(`⚠️ 变更范围对账输出异常（advisory，不阻断 ${stageName} 阶段完成）：${e && e.message ? String(e.message).split('\n')[0] : e}`)
+  }
+}
+
 // ── Step 调度兄弟函数（W6 Step7b-2 从 run.js 搬入：skip/wait/continue + formatWaitHistory）──
 /**
  * plan.md checkbox 自动勾选：execute 完成 + 各 task review.json 双 verdict 非 fail → 自动勾选。
@@ -858,7 +992,7 @@ export function shouldAutoCheckTask(r, endToEnd, ctx = null) {
 
   return true
 }
-async function autoCheckPlanFromReviews({ stageName, changeName, cwd, platformOpts }) {
+export async function autoCheckPlanFromReviews({ stageName, changeName, cwd, platformOpts }) {
   if (stageName !== 'execute' || !changeName) {
     return { autoChecked: false, checkedCount: 0, skippedCount: 0 }
   }
@@ -1337,6 +1471,9 @@ export async function continueStep(pm, progress, stageName, cwd, answer, options
     // gate 全过：persist completed（task-03 移后；此处无 triggerSync）。
     pm._write(cwd, progress, changeName)
     console.log(`\n✅ ${stageName} 阶段已完成（${stageData.steps.length}/${stageData.steps.length} 步）`)
+    // task-04：wait 解除完成路径与 completeStep 完成分支同源注入（Grill G-2：本路径不漏，
+    // 否则 execute 快照缺失 → verify 假报「无快照可对比」）。
+    await printStageCompletionScopeAudit({ stageName, cwd, changeName, specBase, platformOpts })
     // 阶段完成后明确下一步（agent 常卡：stageData completed 但不知要 run <下一阶段> 推进 currentStage）
     const nextStageHint = { brainstorm: 'plan', plan: 'execute', execute: 'verify', verify: 'archive' }[stageName]
     if (nextStageHint) {

package/src/run/gate-snapshot.js

@@ -0,0 +1,88 @@
+/**
+ * gate-snapshot.js — quick --done test+lint 门禁的隔离快照执行（2026-09-10 驾驭小结第六批②，
+ * 用户实证「lint 实测对账在主仓跑，被并行会话的脏文件拦门」）。
+ *
+ * 问题：门禁在主仓工作区跑 commands.test/lint——多会话共享仓里并行会话的未提交 src/test
+ * 改动（语法错误/半成品/锚漂）会污染实测结果，把无辜会话的 --done 拦在门上（只能走
+ * advisory 逃生口）。
+ *
+ * 修法：HEAD 干净快照 + 会话文件 overlay——`git worktree add --detach <tmp> HEAD` 取干净
+ * 基线（并行脏文件天然不在），把本会话审计/声明的变更文件覆盖进快照，node_modules 经
+ * junction 复用主仓依赖（零拷贝），local.yaml 从主仓复制（gitignore 不进 HEAD），在快照
+ * cwd 跑对账。快照基建任何失败 → 返回 null，调用方回退主仓现行为（零回归兜底）。
+ *
+ * 快照生命周期：一次门禁一批（create → run → cleanup）；崩溃残留由 git worktree prune /
+ * 临时目录自然回收（OS tmp 清理），不进主仓 .runtime。
+ */
+import { execFileSync } from 'node:child_process'
+import { mkdtempSync, mkdirSync, copyFileSync, writeFileSync, rmSync, existsSync, readdirSync, statSync, symlinkSync, readFileSync } from 'node:fs'
+import { join, dirname, relative, resolve } from 'node:path'
+import { tmpdir } from 'node:os'
+
+function git(cwd, args) {
+  return execFileSync('git', args, { cwd, encoding: 'utf8', stdio: ['ignore', 'pipe', 'pipe'], timeout: 60000 }).trim()
+}
+
+/**
+ * 创建隔离快照：HEAD worktree + 会话文件 overlay + node_modules junction + local.yaml。
+ * @param {{ cwd: string, files: string[] }} opts cwd=主仓根；files=本会话变更文件（仓库根相对 POSIX）
+ * @returns {{ snapshotRoot: string, cleanup: () => void, reason?: string }|null} 失败返回 null（调用方回退主仓）
+ */
+export function createGateSnapshot({ cwd, files }) {
+  let snapshotRoot = null
+  try {
+    // 前置：主仓须是 git 仓且有 HEAD（无 git 环境回退主仓现行为）
+    git(cwd, ['rev-parse', 'HEAD'])
+
+    snapshotRoot = mkdtempSync(join(tmpdir(), 'sillyspec-gate-'))
+    git(cwd, ['worktree', 'add', '--detach', '--quiet', snapshotRoot, 'HEAD'])
+
+    // 会话文件 overlay：主仓工作区版本覆盖进快照（本会话的最新态；文件不存在=已删，跳过）。
+    // .sillyspec/ 跳过面收窄（P2-d 落地实证的快照盲区）：原一刀切跳过整个 .sillyspec/ ——
+    // 会话声明的 tracked docs（module-map 补录/知识库/模块卡）进不了快照，门禁读到 HEAD
+    // 旧版恒误报（src 未录 module-map 的修复在主仓生效、快照里仍然失败）。真正需要隔离的
+    // 是共享运行时面：.runtime/（sqlite 锁/在途 marker）与 quicklog/（跨会话共享账本）；
+    // local.yaml 由下方 cfg 段显式复制（单一来源，不经 overlay）。
+    let overlaid = 0
+    for (const f of files) {
+      const isSillyspecRuntime = typeof f === 'string' && (f.startsWith('.sillyspec/.runtime/') || f.startsWith('.sillyspec/quicklog/') || f === '.sillyspec/local.yaml' || f === '.sillyspec/.sillyspec-platform.json')
+      if (typeof f !== 'string' || f.includes('..') || f.startsWith('/') || isSillyspecRuntime) continue
+      const src = join(cwd, f)
+      if (!existsSync(src)) continue
+      const dst = join(snapshotRoot, f)
+      mkdirSync(dirname(dst), { recursive: true })
+      copyFileSync(src, dst)
+      overlaid++
+    }
+
+    // node_modules junction（依赖主仓安装态；junction Windows 无需特权，POSIX 用 symlink）
+    const nmSrc = join(cwd, 'node_modules')
+    if (existsSync(nmSrc)) {
+      try { symlinkSync(nmSrc, join(snapshotRoot, 'node_modules'), 'junction') }
+      catch { /* 依赖链接失败：test/lint 可能跑不起来 → 仍返回快照，命令层报错走 fallback */ }
+    }
+
+    // local.yaml（gitignore 不进 HEAD；门禁命令配置来源）+ package-lock 保持 HEAD 版（npm test 不装新依赖）
+    for (const cfg of [join('.sillyspec', 'local.yaml')]) {
+      const src = join(cwd, cfg)
+      if (existsSync(src)) {
+        mkdirSync(dirname(join(snapshotRoot, cfg)), { recursive: true })
+        copyFileSync(src, join(snapshotRoot, cfg))
+      }
+    }
+
+    const cleanup = () => {
+      try { git(cwd, ['worktree', 'remove', '--force', '--quiet', snapshotRoot]) } catch {
+        try { rmSync(snapshotRoot, { recursive: true, force: true }) } catch { /* 残留交 OS tmp 清理 */ }
+      }
+    }
+    return { snapshotRoot, cleanup, overlaid }
+  } catch (e) {
+    // 基建失败（worktree add 拒绝/磁盘满/…）：尽力清理后回退主仓
+    if (snapshotRoot) {
+      try { git(cwd, ['worktree', 'remove', '--force', '--quiet', snapshotRoot]) } catch {}
+      try { rmSync(snapshotRoot, { recursive: true, force: true }) } catch {}
+    }
+    return null
+  }
+}

package/src/run/gates.js

@@ -21,6 +21,7 @@
  */
 import { basename, join, relative, dirname } from 'node:path'
 import { createHash } from 'node:crypto'
+import { execFileSync } from 'node:child_process'
 import { existsSync, readFileSync, readdirSync, statSync, mkdirSync, unlinkSync, writeFileSync } from 'node:fs'
 import { writeAtomicSync } from '../fs-atomic.js'
 import { triggerSync, resolveChangeDir, resolveRuntimeRoot } from './shared.js'
@@ -556,12 +557,14 @@ export async function runStageCompletionGates({ stageName, cwd, changeName, plat
   // ── verify 收尾前置：facts slot-backfill + verifyStartAt（2026-09-08-ir-verify-facts FR-03）──
   // 执行次序（design Phase 3）：backfill（结论/证据/回执槽固化）先行 → runValidators（结论门/
   // 集成证据门读得到固化值与 context.verifyStartAt）→ verify 专属块（test 实测 → tests 段二次
-  // 回填 → cannot_verify 硬门）。verifyStartAt = DB execute 行 completed_at（只读；缺省 null →
-  // 证据核验走 R-05 design created_at fallback）。
+  // 回填 → cannot_verify 硬门）。verifyStartAt 锚点（2026-09-10 用户反馈②放宽）：execute 行
+  // **started_at**（证据合法产自 execute 或 verify 两窗口）→ 缺列/旧行退 completed_at →
+  // 再缺走 R-05 design created_at fallback。
   let verifyStartAtIso = null
   if (stageName === 'verify') {
     try {
-      verifyStartAtIso = pm.getStageCompletedAt(cwd, changeName, 'execute')
+      verifyStartAtIso = (pm.getStageStartedAt && pm.getStageStartedAt(cwd, changeName, 'execute'))
+        || pm.getStageCompletedAt(cwd, changeName, 'execute')
     } catch { verifyStartAtIso = null }
     try {
       const verifyMdPath = join(specBase, 'changes', changeName, 'verify-result.md')
@@ -622,10 +625,22 @@ export async function runStageCompletionGates({ stageName, cwd, changeName, plat
   // 自报告 PASS 但实测失败 → 阻断（防止"文案通过"绕过验证）。
   if (stageName === 'verify') {
     const { runVerifyTestCheck, printVerifyTestCheck } = await import('../verify-postcheck.js')
-    // 测试实测是同步 execSync，长套件可跑 2~10min 且中途无输出——先预告避免 agent 误判卡死
-    console.log(`\n⏳ Verify 测试对账：CLI 亲自执行 local.yaml 的 commands.test（同步，耗时可能较长，请等待…）`)
-    const testCheck = runVerifyTestCheck({ cwd, specBase, changeName, ctx })
-    printVerifyTestCheck(testCheck)
+    // P0-1 指纹复用（noai-ir-roadmap §3 前置一·防重复跑）：noAI 质量扫描步已实测且代码指纹
+    // 未变 → 直接复用免重跑（长套件 2~10 分钟不再跑两遍）；无记录/失配/git 不可用 → 照旧
+    // 亲测（本路径语义与产物逐字不变）。
+    const { loadReusableQualityScan } = await import('./verify-quality-scan.js')
+    const reusableScan = loadReusableQualityScan({ specBase, cwd, changeName })
+    let testCheck
+    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, specBase, changeName, ctx })
+      printVerifyTestCheck(testCheck)
+    }
     // tests 段二次回填（2026-09-08-ir-verify-facts FR-03 次序：实测在 runValidators 之后，
     // tests 快照此刻才可得；不参与门禁——供 P3d 追溯）
     try {
@@ -643,44 +658,13 @@ export async function runStageCompletionGates({ stageName, cwd, changeName, plat
     } catch { /* fail-soft：回填失败不影响门禁 */ }
     if (testCheck.status === 'failed') {
       console.error('\n❌ verify 阶段被阻断：verify-result.md 自报告通过，但 CLI 实测测试失败。')
-      // 并行 WIP 归因鉴别（坑 verify-reconcile-foreign-wip）：实测跑在主仓共享工作区，并行会话
-      // 在途 WIP 物理在场——他者文件命中声明集时提示复验归因（EADDRINUSE 鉴别同款风格），不静默背锅。
+      // 并行 WIP 归因鉴别（坑 verify-reconcile-foreign-wip）：单一实现迁至 verify-quality-scan.js
+      // renderVerifyTestAttribution（P0-1 前置二：noAI 质量扫描失败路径与本 --done 路径共用，
+      // 输出逐字保持）——实测跑在主仓共享工作区，并行会话在途 WIP 物理在场，他者文件命中
+      // 声明集时提示复验归因（含判据②生成产物旧基线 / verify-attr2 双过滤），不静默背锅。
       try {
-        const { collectForeignDeclaredFiles } = await import('../verify-postcheck.js')
-        const { gitQuiet } = await import('../git-helper.js')
-        const foreignMap = collectForeignDeclaredFiles(cwd, changeName, { specBase, runtimeRoot: resolveRuntimeRoot(platformOpts, specBase) })
-        // dirty 集提前算好：归因提示①（他者在途）与②（生成产物旧基线）共用
-        const dirty = (gitQuiet(cwd, ['diff', '--name-only', 'HEAD']) || '')
-          .split('\n').filter(Boolean).map(f => f.replace(/\\/g, '/'))
-        const dirtySet = new Set(dirty)
-        if (foreignMap.size > 0) {
-          const hitForeign = dirty.filter(f => foreignMap.has(f))
-          if (hitForeign.length > 0) {
-            console.error(`   ℹ️ 归因提示：主仓检出 ${hitForeign.length} 个并行会话声明的在途文件（${hitForeign.slice(0, 5).join(', ')}${hitForeign.length > 5 ? ' 等' : ''}）——实测失败可能混入他者 WIP 而非本变更问题。待其提交/收尾后复验，仍失败才是本变更的。`)
-          }
-        }
-        // 第二判据（坑 derived-artifact-stale-baseline）：本变更 apply 的文件（apply-pathspec 落盘）
-        // 与主仓近期提交重叠——本变更旧基线的生成产物可能覆盖了已合入内容，先在新基线重跑生成命令再复验。
-        // 坑 verify-attr2-foreign-wip-misdirection（2026-08-28 实证）：并行会话在途/近期收尾文件
-        // 让重叠集虚高（51 文件），每轮误导 agent 重跑 gen:types，实际失败源是他者 WIP。两道过滤：
-        //   - 必须 dirty：apply 落盘的旧内容此刻物理在场（verify gate 时本变更未提交，旧基线覆盖
-        //     必然表现为对 HEAD 的修改）——内容与 HEAD 一致时重跑生成命令改变不了本轮实测；
-        //   - 剔除他者声明集：那是归因提示①的领地（待其收尾后复验），不是生成产物过期。
-        try {
-          const pathspecFile = join(resolveRuntimeRoot(platformOpts, specBase), `apply-pathspec-${changeName}.txt`)
-          if (changeName && existsSync(pathspecFile)) {
-            const ownFiles = new Set(readFileSync(pathspecFile, 'utf8').split('\n').map(l => l.trim()).filter(Boolean).map(f => f.replace(/\\/g, '/')))
-            if (ownFiles.size > 0) {
-              const recent = (gitQuiet(cwd, ['log', '-n', '10', '--name-only', '--pretty=format:']) || '')
-                .split('\n').map(l => l.trim().replace(/\\/g, '/')).filter(Boolean)
-              const overlap = [...new Set(recent)].filter(f => ownFiles.has(f))
-              const actionable = filterStaleBaselineOverlap(overlap, dirtySet, foreignMap)
-              if (actionable.length > 0) {
-                console.error(`   ℹ️ 归因提示②：本变更有 ${actionable.length} 个文件与主仓最近 10 条提交重叠且旧内容仍在工作区（${actionable.slice(0, 5).join(', ')}${actionable.length > 5 ? ' 等' : ''}）——若为生成产物（api-types 等），本变更可能在旧基线生成并覆盖了已合入内容；先在新基线重跑生成命令（如 gen:types）再复验。（重叠共 ${overlap.length} 个，其余未在工作区改动或属他者会话在途文件，已归提示①/无需处理）`)
-              }
-            }
-          }
-        } catch { /* 判据②失败不影响主流程 */ }
+        const { renderVerifyTestAttribution } = await import('./verify-quality-scan.js')
+        await renderVerifyTestAttribution({ cwd, changeName, specBase, runtimeRoot: resolveRuntimeRoot(platformOpts, specBase) })
       } catch { /* 归因提示失败不影响阻断语义 */ }
       console.error('   请修复失败的测试并更新 verify-result.md 后重新完成此步骤。')
       return await rollbackCompletionAndReturn(pm, progress, stageData, steps, currentIdx, cwd, changeName, platformOpts)
@@ -688,9 +672,15 @@ export async function runStageCompletionGates({ stageName, cwd, changeName, plat
     // lint 对账（2026-08-21 审查 CLI-1）：test 侧"自报告 PASS 但实测失败→阻断"已闭环，
     // lint 侧此前纯口头——CLI 亲自执行 commands.lint，advisory 起步（失败打印不阻断，观察期后升级）
     const { runVerifyLintCheck, printVerifyLintCheck } = await import('../verify-postcheck.js')
-    const lintCheck = runVerifyLintCheck({ cwd, specBase })
-    if (lintCheck.status !== 'skipped') {
-      console.log(`\n⏳ Verify lint 对账：CLI 亲自执行 local.yaml 的 commands.lint…`)
+    // P0-1 指纹复用：noAI 质量扫描记录同指纹时 lint 一并复用（lint tally 只记真实执行次数）
+    let lintCheck = (reusableScan && reusableScan.lintResult) || null
+    if (lintCheck) {
+      console.log(`\n♻️ Verify lint 对账：复用 noAI 质量扫描步的实测结果（代码指纹匹配，免重跑）`)
+    } else {
+      lintCheck = runVerifyLintCheck({ cwd, specBase })
+      if (lintCheck.status !== 'skipped') {
+        console.log(`\n⏳ Verify lint 对账：CLI 亲自执行 local.yaml 的 commands.lint…`)
+      }
     }
     printVerifyLintCheck(lintCheck)
     // lint 硬门（2026-09-09 升硬：观察期 14 次 5 败全真阳性，pre-push 本就硬拦——fail-fast 前移；
@@ -720,9 +710,19 @@ export async function runStageCompletionGates({ stageName, cwd, changeName, plat
     // execute Task Review Gate 把 cannot_verify 任务的 evidence 落盘 verify-required-evidence.json。
     // v2 槽优先分类核验（FR-02）：blocked = missing 无豁免或 satisfied 核验不过 → 阻断 verify 完成
     // （此前 advisory 只查「提及」——死链不闭环）；无槽存量 md 降级 legacy 子串对账（warning 不阻断）。
-    const { runVerifyRequiredEvidenceCheck, printVerifyRequiredEvidenceCheck } = await import('../verify-postcheck.js')
+    const { runVerifyRequiredEvidenceCheck, printVerifyRequiredEvidenceCheck, trackVerifyResultRegression } = await import('../verify-postcheck.js')
     const evidenceCheck = runVerifyRequiredEvidenceCheck({ cwd, specBase, changeName, verifyStartAt: verifyStartAtIso })
     printVerifyRequiredEvidenceCheck(evidenceCheck)
+    // verify-result.md 内容回退检测（2026-09-10 用户反馈③：报告被平台同步覆盖回旧版一次，
+    // 只能靠人眼发现重写）：高水位指纹（hash+mtime）检出「内容变且 mtime 回退」→ ⚠️ 告警。
+    // 纯 advisory——真回退也由 agent 决定重写，CLI 只保证可见。
+    try {
+      const vr = trackVerifyResultRegression(specBase, changeName, join(specBase, 'changes', changeName, 'verify-result.md'))
+      if (vr.regressed) {
+        console.warn(`\n⚠️ verify-result.md 疑被覆盖回旧版（内容变化 + mtime 回退至 ${new Date(vr.prevMtime).toLocaleString('zh-CN')} 之前）——平台/daemon 按服务端旧版本回写的指纹。`)
+        console.warn(`   若你刚重写过请忽略本行（下次读取刷新高水位）；否则当前盘上可能是旧内容，需对照记忆/git 重新补写。`)
+      }
+    } catch { /* 检测失败静默（advisory） */ }
     if (evidenceCheck.status === 'blocked') {
       console.error(`\n❌ verify 阶段被阻断：cannot_verify 证据账未闭环（${evidenceCheck.summary}）。`)
       for (const d of (evidenceCheck.detailed || [])) {
@@ -915,6 +915,20 @@ export async function runStageCompletionGates({ stageName, cwd, changeName, plat
         if (!reviewResult.ok) {
           return await rollbackCompletionAndReturn(pm, progress, stageData, steps, currentIdx, cwd, changeName, platformOpts)
         }
+        // 降级自审留痕（2026-09-10 用户反馈①：PI agent 等宿主无 Agent tool，prompt 降级条款允许
+        // 当前 agent 自审产出 review.json）。放行但独立性折损必须可见：⚠️ 审计行区分降级 review
+        // 与真子代理 review（事后可审计），与 ⚖️/🔍 软归属同哲学——可见的折损优于静默的伪装。
+        // channel 识别（2026-09-10 通道优先序批次）：reviewer.channel 结构化落款优先，兼容
+        // reviewerNotes 首行「降级：」约定；platform 通道（P2 review-dispatch 落地后）ℹ️ 留痕
+        // missionId 供追溯，其余通道正常放行。
+        const { classifyReviewerChannel } = await import('../stage-review.js')
+        const reviewChannel = classifyReviewerChannel(reviewResult.review)
+        if (reviewChannel === 'self') {
+          console.warn(`\n⚠️ Stage Review 降级自审（tier=independent 但宿主无 Agent tool）：${stageName} review 按 prompt 降级条款由当前 agent 自审产出——独立性折损已留痕（reviewerNotes 首行「降级：」），结论应附源码锚点补偿，建议人工抽查关键结论。`)
+        } else if (reviewChannel === 'platform') {
+          const mid = reviewResult.review && reviewResult.review.reviewer && reviewResult.review.reviewer.missionId
+          console.log(`\nℹ️ Stage Review 平台派发（channel=platform${mid ? `，missionId=${mid}` : '，missionId 未落款'}）：${stageName} review 由平台独立 worker 产出（独立进程/会话）。`)
+        }
       }
     } catch (e) {
       // fail-closed：Gate 自身异常阻断完成，不静默放行（与 Task Review Gate 一致）
@@ -978,14 +992,16 @@ export async function runStageCompletionGates({ stageName, cwd, changeName, plat
           // marker 缺失：先扫描 execute-runs/ 既有目录找回真实 runId（与 getLatestStageReviewRunId
           // 目录扫描兜底同语义），避免 marker 丢失而 agent 已用旧 runId 落盘时，直接 generate 新 ID
           // 找不到旧 review、误判缺 review.json。仅当确实无既有 run 才 generate 新 ID 并落盘。
-          const { generateExecuteRunId, resolveLatestExecuteRunId, stampExecuteRunChange } = await import('../task-review.js')
+          const { generateExecuteRunId, resolveLatestExecuteRunId, stampExecuteRunChange, claimExecuteRunId } = await import('../task-review.js')
           executeRunId = resolveLatestExecuteRunId({ runtimeRoot, changeName }) || ''
           if (!executeRunId) {
-            executeRunId = generateExecuteRunId()
+            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)
@@ -1263,9 +1279,13 @@ export async function completeStageGates({ stageName, cwd, changeName, platformO
     validateFileLocations(cwd, stageName, progress, changeName, specBase)
   }
 
-  // 辅助阶段完成后重置步骤（scan 等 auxiliary 阶段重置回 pending 可重跑）
+  // 辅助阶段完成后重置步骤（scan 等 auxiliary 阶段重置回 pending 可重跑）。
+  // archive 例外（P0-4 并步补丁）：确认归档成为末步后本重置会与 unregisterChange 的终态
+  // （steps 全 completed + current_stage=archive——平台按步骤数渲染完成度的数据源）互相
+  // 覆盖，把已注销变更抹回 0/N。archive 是终态阶段（变更已注销，不存在「重跑归档」流），
+  // 不参与可重跑重置。
   const stageDef = stageRegistry[stageName]
-  if (stageDef?.auxiliary) {
+  if (stageDef?.auxiliary && stageName !== 'archive') {
     const freshSteps = (stageDef.steps || []).map(s => ({
       name: s.name,
       status: 'pending',
@@ -1615,11 +1635,50 @@ export function printProbeConsistencyCheck(r, envelope = buildProbeConsistencyEn
  * 一天多——verify prompt 要求 PID 按变更分片登记 .runtime/verify-services-<change>.pids。
  * 坑 verify-pids-cross-session-kill（2026-08-23）：原单文件无归属，A 会话 --done 会把 B 正在
  * 收集 Runtime Evidence 的服务一并杀掉——分片后各回收各的；旧单文件兼容回收（升级过渡期）。
+ * 坑 verify-service-process-leak 子进程泄漏（2026-09-10 驾驭小结第三批③，用户实锤 python
+ * 子进程泄漏）：原 process.kill(pid) 只杀登记的 shell 包装进程（`cmd /c` / `sh -c` 起的
+ * uvicorn 等），子进程成了孤儿继续挂机——改 killProcessTree 进程树击杀（win taskkill /T /F
+ * + POSIX 递归枚举子进程）；prompt 指引同步补「优先登记服务本体（叶子）PID」。
  * 回执同样按变更分片（原单份被并行会话后写覆盖），checkIntegrationEvidence（stage-contract）
  * 读分片名注入证据匹配。best-effort：ESRCH（已退出）静默，kill 失败 warn 不阻断 verify。
  *
  * @returns {{ reaped: number, receiptPath: string|null }}
  */
+export function killProcessTree(pid, sig = 'SIGTERM') {
+  const pidNum = parseInt(pid, 10)
+  if (!Number.isInteger(pidNum) || pidNum <= 0) return false
+  if (process.platform === 'win32') {
+    // /T = 连同子进程树（shell 包装下的 python/node 服务本体）；/F = 强制（长驻服务常吞 SIGTERM 等价物）
+    try {
+      execFileSync('taskkill', ['/PID', String(pidNum), '/T', '/F'], { stdio: 'ignore', timeout: 15000 })
+      return true
+    } catch (e) {
+      // taskkill 对不存在进程退出码 128（等价 ESRCH，已退出按回收静默）；其余（拒绝访问等）上抛
+      if (e && (e.status === 128 || /could not be found|找不到/i.test(String(e.stderr || '') + String(e.message || '')))) return false
+      throw e
+    }
+  }
+  // POSIX：先递归杀子进程（shell 包装的子进程是服务本体），再杀登记进程本身
+  for (const child of listChildPids(pidNum)) {
+    try { killProcessTree(child, sig) } catch { /* 子进程已退出/权限不足不连坐父进程回收 */ }
+  }
+  try { process.kill(pidNum, sig); return true }
+  catch (e) { if (e.code === 'ESRCH') return false; throw e }
+}
+
+/** ps 枚举直接子进程 PID（POSIX；失败返回空——杀不到子进程不阻断父进程回收） */
+function listChildPids(parentPid) {
+  try {
+    const out = execFileSync('ps', ['-axo', 'pid=,ppid='], { encoding: 'utf8', timeout: 5000 })
+    const children = []
+    for (const line of String(out).split('\n')) {
+      const m = line.trim().match(/^(\d+)\s+(\d+)$/)
+      if (m && Number(m[2]) === parentPid) children.push(Number(m[1]))
+    }
+    return children
+  } catch { return [] }
+}
+
 export function reapVerifyServices(platformOpts, specBase, changeName) {
   const runtimeDir = resolveRuntimeRoot(platformOpts, specBase)
   const reapFile = (path, label) => {
@@ -1627,11 +1686,12 @@ export function reapVerifyServices(platformOpts, specBase, changeName) {
     const pids = readFileSync(path, 'utf8').split('\n').map(l => l.trim()).filter(l => /^\d+$/.test(l))
     const reaped = []; const failed = []
     for (const pid of pids) {
-      try { process.kill(parseInt(pid, 10), 'SIGTERM'); reaped.push(pid) }
-      catch (e) { if (e.code !== 'ESRCH') failed.push(`${pid}(${e.code || e.message})`) }
+      // 进程树击杀（坑 verify-service-process-leak 子进程泄漏）：连带 shell 包装下的服务本体
+      try { if (killProcessTree(pid)) reaped.push(pid) }
+      catch (e) { if (e.code !== 'ESRCH') failed.push(`${pid}(${e.code || e.status || e.message})`) }
     }
     try { unlinkSync(path) } catch {}
-    if (reaped.length > 0) console.log(`🧹 verify 服务进程已回收 ${reaped.length} 个${label}（PID: ${reaped.join(', ')}）`)
+    if (reaped.length > 0) console.log(`🧹 verify 服务进程已回收 ${reaped.length} 个${label}（PID: ${reaped.join(', ')}，进程树击杀）`)
     return { reaped: reaped.length, failed }
   }
   const own = reapFile(join(runtimeDir, `verify-services-${changeName}.pids`), '')