sillyspec 3.28.6 → 3.28.8

package/src/quicklog.js

@@ -67,6 +67,13 @@ export async function withFileLock(lockPath, fn, opts = {}) {
               if (!restored) { try { unlinkSync(claim) } catch {} }
             }
           } catch {}
+          // 偷锁重试前同样受超时与退避约束（坑 quicklog-lock-steal-spin，2026-09-12 审查批 A-③）：
+          // 旧版 continue 直接跳过下方检查——锁文件被 AV/索引器长期占用、renameSync 持续失败
+          // （每次被外层 catch 吞掉）时忙等自旋：不检查 timeoutMs、不让出 CPU，命令挂死 + 100% CPU。
+          if (Date.now() - start > timeoutMs) {
+            throw new Error(`文件锁超时（${timeoutMs}ms）: ${lockPath}`)
+          }
+          await sleep(retryMs)
           continue
         }
       } catch {}
@@ -80,7 +87,13 @@ export async function withFileLock(lockPath, fn, opts = {}) {
     return await fn()
   } finally {
     try { closeSync(fd) } catch {}
-    try { unlinkSync(lockPath) } catch {} // 释放（容忍已不存在）
+    // 释放前校验持有者身份（坑 quicklog-lock-release-mismatch，2026-09-12 审查批 A-③）：
+    // 本进程临界区超 staleMs 被他进程偷锁后，lockPath 上可能是**他人新建**的锁——无条件
+    // unlink 误删它会让第三方抢锁成功，形成双进程并发临界区。仅内容仍为本会话 myId 才删
+    // （读失败=锁已不在/被偷，容忍——偷锁路径自会回收旧 claim）。
+    try {
+      if (readFileSync(lockPath, 'utf8') === myId) unlinkSync(lockPath)
+    } catch {}
   }
 }
 
@@ -718,7 +731,12 @@ export async function allocateQuicklogEntry(specBase, gitUser, { description, li
   const files = Array.isArray(allowedFiles) ? allowedFiles : []
   const today = todayStamp()
 
-  return await withFileLock(lockPath, async () => {
+  // 平台推送在锁外执行（2026-09-11 审查性能包①）：锁内 5s 网络推送 + 逐变更 tasks 锁
+  // （最坏各 10s）可使临界区突破 30s stale 偷锁阈值——他进程偷锁后双写者并发，正是本模块
+  // 头声明要根治的并发丢更新被重新打开。推送 best-effort 不回写本地，锁外语义等同（原注释
+  // 自证），仅放弃「分配即推送」的顺序一致性（平台为 best-effort 面板，乱序窗口极小）。
+  let pushPayload = null
+  const { qlId } = await withFileLock(lockPath, async () => {
     const { maxSeq, usedSuffix } = scanExisting(quicklogDir, today)
     const nextSeq = maxSeq + 1
     // XXXX 4 位 hex 随机后缀（消歧；NNN 已在锁内顺序分配保证唯一，此处仅 belt-and-suspenders）
@@ -744,9 +762,7 @@ export async function allocateQuicklogEntry(specBase, gitUser, { description, li
 
     for (const c of linked) await appendTaskCheckbox(specBase, c, qlId, desc)
 
-    // 平台推送（task-06 / FR-02 / D-003）：锁外语义等同（推送不回写本地），但放锁内
-    // 保证「分配即推送」顺序一致；best-effort 失败不影响返回。
-    await pushQuicklogEntryToPlatform(specBase, {
+    pushPayload = {
       ql_id: qlId,
       timestamp: nowDatetime(),
       title: desc,
@@ -758,10 +774,13 @@ export async function allocateQuicklogEntry(specBase, gitUser, { description, li
       files: files.map(f => ({ path: f, note: null })),
       body_sections: {},
       raw_block: entry,
-    }).catch(() => {}) // pushQuicklogEntryToPlatform 自身已吞错；双保险防未来改动破坏 best-effort 契约
-
+    }
     return { qlId }
   })
+  if (pushPayload) {
+    await pushQuicklogEntryToPlatform(specBase, pushPayload).catch(() => {}) // 自身已吞错；双保险防未来改动破坏 best-effort 契约
+  }
+  return { qlId }
 }
 
 /**
@@ -785,9 +804,11 @@ export async function appendQuicklogEntryWithId(specBase, gitUser, qlId, { descr
   const linked = Array.isArray(linkedChanges) ? linkedChanges : []
   const files = Array.isArray(allowedFiles) ? allowedFiles : []
 
-  return await withFileLock(lockPath, async () => {
+  // 推送出锁（同 allocateQuicklogEntry 性能包①：临界区只留本地写 + tasks 挂载）
+  let pushPayload = null
+  const { existed } = await withFileLock(lockPath, async () => {
     // 双检（锁内）：并发兜底同 ID 只落一条
-    if (findQuicklogEntry(specBase, gitUser, qlId)) return { qlId, existed: true }
+    if (findQuicklogEntry(specBase, gitUser, qlId)) return { existed: true }
     await rotateIfNeeded(userFile, user)
     const entry = [
       '',
@@ -799,7 +820,7 @@ export async function appendQuicklogEntryWithId(specBase, gitUser, qlId, { descr
     ].join('\n')
     appendFileSync(userFile, entry)
     for (const c of linked) await appendTaskCheckbox(specBase, c, qlId, desc)
-    await pushQuicklogEntryToPlatform(specBase, {
+    pushPayload = {
       ql_id: qlId,
       timestamp: nowDatetime(),
       title: desc,
@@ -810,9 +831,13 @@ export async function appendQuicklogEntryWithId(specBase, gitUser, qlId, { descr
       files: files.map(f => ({ path: f, note: null })),
       body_sections: {},
       raw_block: entry,
-    }).catch(() => {})
-    return { qlId, existed: false }
+    }
+    return { existed: false }
   })
+  if (pushPayload && !existed) {
+    await pushQuicklogEntryToPlatform(specBase, pushPayload).catch(() => {})
+  }
+  return { qlId, existed }
 }
 
 /**
@@ -837,10 +862,12 @@ export async function completeQuicklogEntry(specBase, gitUser, qlId, { resultTex
     ? softFiles.filter(Boolean).map((f) => String(f).replace(/\\/g, '/'))
     : []
 
+  // 推送出锁（性能包①）：终态 payload 以锁内落盘结果组装，锁外 best-effort 推送 + sidecar 持久化
+  // （sidecar 与推送同源同解析器，同移锁外不改变「以落盘终态为准」语义）
+  let finalPayload = null
   await withFileLock(lockPath, async () => {
     // 条目可能在主文件或轮转归档中
     let updatedContent = null
-    let updatedFile = null
     for (const f of listQuicklogFiles(quicklogDir)) {
       const filePath = join(quicklogDir, f)
       let content = ''
@@ -850,7 +877,6 @@ export async function completeQuicklogEntry(specBase, gitUser, qlId, { resultTex
       if (updated !== null) {
         await writeAtomic(filePath, updated) // 命中处原子落盘（只改含目标条目的那一个文件）
         updatedContent = updated
-        updatedFile = filePath
         break
       }
     }
@@ -860,16 +886,16 @@ export async function completeQuicklogEntry(specBase, gitUser, qlId, { resultTex
     // （design §5.3：翻完成时标题行被 extractTitleFromResult 刷新，推送须与落盘一致，
     // 不能用入参拼——标题/结果块/文件行都会在 flipEntryInContent 中重写）。
     const rawBlock = extractRawBlock(updatedContent, qlId)
-    const finalPayload = buildPushPayloadFromRaw(rawBlock, {
+    finalPayload = buildPushPayloadFromRaw(rawBlock, {
       ql_id: qlId,
       author_raw: user,
       status: 'completed',
       linked_changes: linked,
     })
-    // P1-4：终态结构 sidecar 持久化（同一解析器产出，md/sidecar 恒一致；fail-soft）
-    writeQuicklogSidecar(specBase, finalPayload)
-    await pushQuicklogEntryToPlatform(specBase, finalPayload).catch(() => {})
   })
+  // P1-4：终态结构 sidecar 持久化（同一解析器产出，md/sidecar 恒一致；fail-soft）
+  writeQuicklogSidecar(specBase, finalPayload)
+  await pushQuicklogEntryToPlatform(specBase, finalPayload).catch(() => {})
 }
 
 /**

package/src/review-dispatch.js

@@ -262,7 +262,13 @@ export async function runReviewDispatch(opts = {}) {
       const probeFn = probe || (await import('./dispatch/probe.js')).probeSillyHub
       const pr = await probeFn({ client, worktreePath: null, cwd })
       if (!pr || pr.available !== true) {
-        return { ok: false, reason: `平台通道不可用（${pr && pr.reason ? pr.reason : 'probe 异常'}）`, guidance: renderFallbackGuidance(cwd) }
+        const why = pr && pr.reason ? pr.reason : 'probe 异常'
+        // token 失效给「重连再配对」出口（2026-09-11 用户实测：gateway/daemon 都活着，
+        // 死的只是凭据——一把 platform connect 就能救活平台通道，比直接降级更对症）。
+        const tokenHint = why === 'mcp-token-invalid'
+          ? `mcp token 已失效（吊销/过期）——重跑 \`sillyspec platform connect ${client && client._url ? client._url : '<平台url>'} --token <user级token>\` 重连（connect 会成对签发 read+dispatch 新 token 自动覆盖写 mcp 段），然后重试平台通道。\n若暂不重连，按通道优先序降级：\n`
+          : ''
+        return { ok: false, reason: `平台通道不可用（${why}）`, guidance: tokenHint + renderFallbackGuidance(cwd) }
       }
       // reviewRunId：优先复用 marker（与 prompt/gate 同链，勿手算）
       let runId = reviewRunId

package/src/run/command.js

@@ -22,6 +22,7 @@
 import { basename, join, resolve, dirname } from 'node:path'
 import { existsSync, readdirSync, mkdirSync, writeFileSync, readFileSync, rmSync, unlinkSync } from 'node:fs'
 import { randomBytes, randomUUID } from 'node:crypto'
+import { fileURLToPath } from 'node:url'
 import { writeAtomicSync } from '../fs-atomic.js'
 import { resolveSpecDir, countAncestorSpecDirs, ancestorSpecDirs, resolveAncestorCeiling, resolveChangeDir, triggerSync, getStageSteps, formatWaitOptions, checkApproval, warnApprovalUnknown, didYouMean, assertSafeChangeName, assertDatedChangeName, detectQuickSessionDrift, detectWorktreeSpecDrift, resolveRuntimeRoot, resolveQuickSessionsDir, writePlatformPointer, checkPlatformManaged, isSelfReferentialSpecRoot, isTempResidueSpecRoot, PLATFORM_MANAGED_FILENAME, warnSelfRefPointerOnce } from './shared.js'
 import { resolveQuickLinkedChanges } from './quick-audit.js'
@@ -819,6 +820,7 @@ export async function runCommand(args, cwd, specDir = null, opts = {}) {
   const knownFlags = new Set([
     '--done', '--skip', '--status', '--reset', '--confirm', '--skip-approval', '--cancel', '--ql',
     '--wait', '--continue', '--non-interactive', '--interactive',
+    '--wait-interactive', // auto 模式 TTY 直通（带值形态 `--wait-interactive true`，autoFlagValue 消费；ql-20260911-029 补注册——此前漏登记，进命令前即被未知参数 exit(2) 拦死，FR-03 整条死路）
     '--reason', '--options', '--answer', '--confirm-mode',
     '--output', '--input', '--change', '--linked-changes',
     '--req', '--cause', '--solution', '--result',
@@ -1286,11 +1288,14 @@ export async function runCommand(args, cwd, specDir = null, opts = {}) {
       console.error('用法: sillyspec run quick --cancel --change <quick-会话ID> [--ql <ql-xxx>]\n  取消误启动的 quick 会话：QUICKLOG 条目翻「已取消」+ tasks.md 挂载行移除 + 会话目录清理 + db 行注销。\n  已完成/已勾选的会话拒绝取消（真实工作记录）')
       process.exit(2)
     }
-    const specBase = resolveSpecDir(cwd, { specDir })
+    // 平台模式对齐（坑 quick-cancel-platform-specbase，2026-09-12 审查批 B-④）：此处原用
+    // resolveSpecDir 本地重建 specBase，遮蔽外层平台感知 specBase（:476 specRoot 优先）——
+    // 平台模式 guard 恒读不到、QUICKLOG 翻态落错库。guard 查找同其他收敛点走
+    // resolveQuickSessionsDir（runtimeRoot 可与 specBase/.runtime 异位，multi-agent-review Q4）。
     // qlId 优先 --ql 显式；否则读会话 guard.json（allocate 时 CLI 写入）；再退 current marker 旁的会话
     let qlId = qlFlag
     if (!qlId) {
-      const guardPath = join(specBase, '.runtime', 'quick-sessions', cancelSessionRaw, 'guard.json')
+      const guardPath = join(resolveQuickSessionsDir(platformOpts, specBase), cancelSessionRaw, 'guard.json')
       try {
         if (existsSync(guardPath)) {
           // 字段名 bug 修复（2026-09-09 §7-5，会话实证：guard 在场仍报「缺失/损坏」）：
@@ -1896,6 +1901,15 @@ async function runAutoMode(pm, progress, cwd, flags, changeName, platformOpts =
  * 无新状态）；任一不满足/异常 → 静默或提示回三段式（fail-open，Grill P2-①时序）。
  * 仅 runAutoMode 的首渲染点消费（--done 推进路径不重收）。
  */
+/**
+ * 本 CLI 入口（bin/sillyspec.js）的绝对路径——wait 直通子进程自调用。
+ * fileURLToPath 解 URL（ql-20260911-029：旧 pathname.replace 手解百分号编码，含空格/中文
+ * 路径 ENOENT；且旧相对层级 ../bin 少一级——src/run/ 到仓根 bin 应为 ../../bin）。导出供单测锁层级。
+ */
+export function resolveBinSelfPath() {
+  return fileURLToPath(new URL('../../bin/sillyspec.js', import.meta.url))
+}
+
 export async function maybeWaitInteractive(stepDef, changeName, stageName, { rlFactory = null } = {}) {
   try {
     if (!globalThis.__ssWaitInteractive) return
@@ -1920,7 +1934,7 @@ export async function maybeWaitInteractive(stepDef, changeName, stageName, { rlF
       console.log(`📩 已接收，自动续行：sillyspec run auto --continue --answer "${answer.trim().slice(0, 60)}${answer.trim().length > 60 ? '…' : ''}" ...`)
       // 复用既有 continue 路径：与 runCommand 的 --continue 同源（子进程自调避免递归锁）
       const { execFileSync } = await import('node:child_process')
-      const binSelf = new URL('../bin/sillyspec.js', import.meta.url).pathname.replace(/^\/([A-Za-z]:)/, '$1')
+      const binSelf = resolveBinSelfPath()
       try {
         execFileSync(process.execPath, [binSelf, 'run', 'auto', '--continue', '--answer', answer.trim(), '--change', changeName], { stdio: 'inherit', cwd: process.cwd() })
       } catch { /* continue 失败（非 waiting 态等）静默——回三段式由 agent 走 */ }

package/src/run/complete-handlers.js

@@ -22,8 +22,9 @@
  * archiveChangeDirectory 的 6 处 process.exit 全 exit(1)：5 个顶层 guard 直接终止；L1325 在 catch 内主动 exit
  * （非被外层吞）；process.exit 不可被 try 捕获 → 搬迁行为完全等价。
  */
-import { basename, join, resolve, relative, isAbsolute } from 'node:path'
+import { basename, dirname, join, resolve, relative, isAbsolute } from 'node:path'
 import { existsSync, readdirSync, readFileSync, writeFileSync, mkdirSync, unlinkSync, rmSync } from 'node:fs'
+import { createHash } from 'node:crypto'
 import { renameSyncRetry, writeAtomicSync } from '../fs-atomic.js'
 import { gitQuiet } from '../git-helper.js'
 import { resolveChangeDir, resolveQuickSessionsDir, safeGit, auditQuickCompletion, triggerSync, isQuickMetadata, isQuicklogFileLineNoise, resolveRuntimeRoot, collectOtherQuickSessionDeclarations, mergeQuickBoundaryFiles } from './shared.js'
@@ -1066,7 +1067,7 @@ export async function handleQuickStageCompletion({ stageName, steps, currentIdx,
         if (outputText) steps[currentIdx].output = null
         // 摩擦计数（friction-signal-hint task-04）：quick 审计被拦也是摩擦信号——exit 前记
         // 一笔（changeName=quick 会话 id，tally 落 session 目录，成功收尾 consume 后随目录清理）。
-        recordFrictionEvent({ cwd, changeName, platformOpts, type: 'gate_rollback', detail: 'quick-audit' })
+        await recordFrictionEvent({ cwd, changeName, platformOpts, type: 'gate_rollback', detail: 'quick-audit' })
         process.exit(1)
       }
       // P0-2（2026-09-02 跨 agent 工单）：触及 src/test 的 quick --done 内置 test+lint
@@ -1089,7 +1090,7 @@ export async function handleQuickStageCompletion({ stageName, steps, currentIdx,
         if (outputText) steps[currentIdx].output = null
         // 摩擦计数（friction-signal-hint task-04）：test/lint 实测门禁拦下同记摩擦——exit 前
         // 落 session tally，与 quick-audit 同款静默降级。
-        recordFrictionEvent({ cwd, changeName, platformOpts, type: 'gate_rollback', detail: 'quick-test-lint' })
+        await recordFrictionEvent({ cwd, changeName, platformOpts, type: 'gate_rollback', detail: 'quick-test-lint' })
         process.exit(1)
       }
       progress.lastQuickReview = review
@@ -1313,20 +1314,26 @@ export async function handleQuickStageCompletion({ stageName, steps, currentIdx,
         if (quickRows && quickRows.length > 0) {
           const patchesDir = join(specBase, 'quicklog', 'patches')
           mkdirSync(patchesDir, { recursive: true })
-          const { ...snapRest } = snapResult || {}
-          delete snapRest.frozenPatch
-          writeFileSync(join(patchesDir, `${qlId}.json`), JSON.stringify({
+          const { frozenPatch: _fp, ...snapRest } = snapResult || {}
+          const snapObj = {
             ...snapRest,
             rows: quickRows,
             totals: { files: quickRows.length, additions: quickRows.reduce((n, r) => n + (Number.isFinite(r.additions) ? r.additions : 0), 0), deletions: quickRows.reduce((n, r) => n + (Number.isFinite(r.deletions) ? r.deletions : 0), 0) },
             qlId,
             sessionId: changeName,
             savedAt: new Date().toISOString(),
-          }, null, 2) + '\n')
+          }
+          snapObj.note = 'quick --done 时点冻结（本文件落盘时采集）'
           if (typeof frozenPatch === 'string' && frozenPatch) {
-            writeFileSync(join(patchesDir, `${qlId}.patch`), frozenPatch.endsWith('\n') ? frozenPatch : frozenPatch + '\n')
+            const patchText = frozenPatch.endsWith('\n') ? frozenPatch : frozenPatch + '\n'
+            writeFileSync(join(patchesDir, `${qlId}.patch`), patchText)
+            snapObj.patchSha256 = createHash('sha256').update(patchText, 'utf8').digest('hex')
+            snapObj.patchStatus = 'ok'
+          } else if (frozenPatch === null) {
+            snapObj.patchStatus = 'failed'
           }
-          console.log(`📦 范围快照已落 quicklog/patches/${qlId}.json${typeof frozenPatch === 'string' && frozenPatch ? ' + .patch（--done 时点冻结）' : ''}`)
+          writeFileSync(join(patchesDir, `${qlId}.json`), JSON.stringify(snapObj, null, 2) + '\n')
+          console.log(`📦 范围快照已落 quicklog/patches/${qlId}.json${snapObj.patchStatus === 'ok' ? ' + .patch（--done 时点冻结，sha256 已锚）' : snapObj.patchStatus === 'failed' ? '——patch 采集失败已留痕' : ''}`)
         }
       } catch (e) {
         console.warn(`   ⚠️ quick 范围快照落盘失败（不阻断收尾）：${e && e.message ? String(e.message).split('\n')[0] : e}`)
@@ -1360,7 +1367,7 @@ export async function handleQuickStageCompletion({ stageName, steps, currentIdx,
     // tally 随目录删除，晚于此就读不到。QUICKLOG 完成打印之后 consume，提示里的 postmortem
     // 建议有落点可循；全零/读失败零输出，摩擦提示失败不影响收尾。
     try {
-      const fr = consumeFrictionHint({ cwd, changeName, platformOpts })
+      const fr = await consumeFrictionHint({ cwd, changeName, platformOpts })
       if (fr && fr.hint) console.log(`\n${fr.hint}`)
     } catch { /* 摩擦提示失败不影响收尾 */ }
 
@@ -1465,6 +1472,10 @@ async function closeSingleQuickLinkedChange({ pm, cwd, specBase, changeName, pla
  */
 const QUICK_CLOSE_ALLOWED_STAGES = new Set(['', 'scan', 'brainstorm'])
 
+/** 时近性闸窗口（缺陷②复潮实现）：最近进度活动 60 分钟内的变更不自动归档——活跃会话
+ * 步进间隔为分钟级（brainstorm 8 步通常 <1h），僵尸的最后活动以小时/天计。 */
+const QUICK_CLOSE_ACTIVITY_WINDOW_MS = 60 * 60 * 1000
+
 /**
  * quick --done 完成后，自动关闭任务已全部完成的关联真实变更。
  * quick-<hex> sessionId 自身不在此处理（由调用方单独注销）。
@@ -1514,6 +1525,25 @@ export async function closeQuickLinkedChanges({ pm, cwd, specBase, linkedChanges
         })
         continue
       }
+      // 时近性闸（quick-done-autoarchive-misfire 缺陷②，D-002@v1 复潮，2026-09-11
+      // cross-change-decision-guard 实证）：阶段态区分不了「活跃在途」与「启动后弃单」——
+      // brainstorm in_progress + tasks.md 仅含他者 quick 行时「全勾」是空洞真值（完整流程
+      // plan 前无自有任务行），关联 quick --done 勾掉 ql 行即触发在途变更被轻量归档。
+      // 信号取时近性：最近一次 stage/step 完成时刻在窗口内 = 会话分钟级在推进（在途），
+      // 不自动归档；僵尸的最后活动必然陈旧（或无完成步 → null），逃生通道语义不变
+      //（既有「真·僵尸 in_progress→closed」行为保留）。pm 无此方法（旧 mock/旧进度库）
+      // 按无近期活动放行——与 getChangeStage 缺失 skip 的 fail-safe 不同向：本闸误放行的
+      // 最坏后果是回到缺陷②现状（有 D-002 防护兜底），误拦截则僵尸永不清——权衡取放行。
+      if (typeof pm.getLatestActivityAt === 'function') {
+        const latest = pm.getLatestActivityAt(cwd, changeName)
+        if (latest && Date.now() - new Date(latest).getTime() < QUICK_CLOSE_ACTIVITY_WINDOW_MS) {
+          skipped.push({
+            name: changeName,
+            reason: `变更 ${Math.round((Date.now() - new Date(latest).getTime()) / 60000)} 分钟内仍有进度活动（在途会话，非僵尸），不自动归档——确已弃单请走原流程收尾或窗口过后重试`,
+          })
+          continue
+        }
+      }
       if (!isChangeTasksComplete(specBase, changeName)) {
         skipped.push({ name: changeName, reason: 'tasks.md 未全勾选或不存在' })
         continue

package/src/run/complete.js

@@ -18,6 +18,7 @@
  */
 import { join } from 'node:path'
 import { existsSync, readFileSync, mkdirSync, writeFileSync, appendFileSync } from 'node:fs'
+import { createHash } from 'node:crypto'
 import { writeAtomicSync } from '../fs-atomic.js'
 import { gitQuiet } from '../git-helper.js'
 import { withFileLock } from '../quicklog.js'
@@ -672,7 +673,7 @@ export async function completeStep(pm, progress, stageName, cwd, outputText, inp
     if (stageName === 'verify') {
       try {
         const { consumeFrictionHint } = await import('../friction-tally.js')
-        const r = consumeFrictionHint({ cwd, changeName, platformOpts })
+        const r = await consumeFrictionHint({ cwd, changeName, platformOpts })
         if (r && r.hint) console.log(`\n${r.hint}`)
       } catch { /* 摩擦提示失败不影响收尾 */ }
     }
@@ -817,28 +818,39 @@ function scopeAuditPathSet(result) {
 
 /** execute 完成路径：全表 + 审计级快照/patch 落盘（quick-359a48f1：changes/<变更名>/ 随归档
  *  入库；patch 为收尾时点全量冻结——--file 真·当时内容比对的数据源。写失败只提示，verify
- *  对比按无快照降级） */
+ *  对比按无快照降级。审查修复：freshActual 绕过 settled 快照捷径防陈旧回写（execute 重跑
+ *  场景 C-F01）；落盘 note 换冻结措辞防「自述漂移」污染（C-F06）；patchSha256/patchStatus
+ *  留防篡改锚与失败痕（A-F01/C-F07） */
 async function printExecuteScopeAudit({ cwd, changeName, specBase, platformOpts, computeChangeScopeAudit, renderScopeAuditTable }) {
-  const result = await computeChangeScopeAudit({ cwd, specBase, changeName, platformOpts, collectPatch: true })
+  const result = await computeChangeScopeAudit({ cwd, specBase, changeName, platformOpts, collectPatch: true, freshActual: true })
   console.log(`\n${renderScopeAuditTable(result, { maxRows: 60 })}`)
   try {
-    const changeDir = join(specBase, 'changes', changeName)
+    // 归档竞态（审查 C-F10）：目录已被并行归档移动 → 写归档侧，不在活跃区重建假目录
+    const activeDir = join(specBase, 'changes', changeName)
+    const changeDir = existsSync(activeDir) ? activeDir : join(specBase, 'changes', 'archive', changeName)
     mkdirSync(changeDir, { recursive: true })
     const { frozenPatch, ...snap } = result
-    writeFileSync(join(changeDir, 'scope-audit.json'), JSON.stringify({ ...snap, savedAt: new Date().toISOString() }, null, 2) + '\n')
+    snap.note = 'execute --done 时点冻结（本文件落盘时采集）'
     if (typeof frozenPatch === 'string') {
-      writeFileSync(join(changeDir, 'scope-audit.patch'), frozenPatch.endsWith('\n') ? frozenPatch : frozenPatch + '\n')
+      const patchText = frozenPatch.endsWith('\n') ? frozenPatch : frozenPatch + '\n'
+      writeFileSync(join(changeDir, 'scope-audit.patch'), patchText)
+      snap.patchSha256 = createHash('sha256').update(patchText, 'utf8').digest('hex')
+      snap.patchStatus = 'ok'
+    } else if (frozenPatch === null) {
+      snap.patchStatus = 'failed'
     }
-    console.log(`   📦 范围快照已落变更目录（scope-audit.json${typeof frozenPatch === 'string' ? ' + scope-audit.patch（收尾时点冻结）' : ''}）`)
+    writeFileSync(join(changeDir, 'scope-audit.json'), JSON.stringify({ ...snap, savedAt: new Date().toISOString() }, null, 2) + '\n')
+    console.log(`   📦 范围快照已落变更目录（scope-audit.json${snap.patchStatus === 'ok' ? ' + scope-audit.patch（收尾时点冻结，sha256 已锚）' : snap.patchStatus === 'failed' ? '——patch 采集失败已留痕' : ''}）`)
   } 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，基点不同行数天然抖动，比行数必假阳） */
+ *  worktree meta、verify 形态 B 锚 merge-base，基点不同行数天然抖动，比行数必假阳）。
+ *  审查 C-F01：current 侧 freshActual——settled 快照捷径会让本函数变成快照比快照恒「一致」 */
 async function printVerifyScopeDrift({ cwd, changeName, specBase, platformOpts, computeChangeScopeAudit }) {
-  const result = await computeChangeScopeAudit({ cwd, specBase, changeName, platformOpts })
+  const result = await computeChangeScopeAudit({ cwd, specBase, changeName, platformOpts, freshActual: true })
   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) {
@@ -1059,8 +1071,14 @@ export async function autoCheckPlanFromReviews({ stageName, changeName, cwd, pla
         const taskNum = match.match(/task-(\d+)/)[1].padStart(2, '0')
         const reviewPath = join(runtimeRoot, 'execute-runs', executeRunId, 'tasks', `task-${taskNum}`, 'review.json')
         const r = readReview(reviewPath)
-        // 端到端 task：必须 pass（cannot_verify 不算）；普通 task：非 fail 即可（坑 execute-batch-complete-endtoend-checkbox）
-        const endToEnd = isEndToEndTaskText(match + ' ' + readTaskCardText(changeDir, taskNum))
+        // 卡片读取延后到 verdict 可用之后（2026-09-11 审查性能包③）：review 缺失或 spec/quality
+        // 已 fail 时 endToEnd 取值不影响 shouldAutoCheckTask 结果（恒 false），先读卡片是纯浪费
+        // ——持 tasks 锁期间每 task 省一次 readFileSync。
+        const verdictUsable = r?.ok
+          && r.review?.specVerdict !== 'fail'
+          && r.review?.qualityVerdict !== 'fail'
+        const endToEnd = verdictUsable
+          && isEndToEndTaskText(match + ' ' + readTaskCardText(changeDir, taskNum))
         if (shouldAutoCheckTask(r, endToEnd, ctx)) {
           checkedCount++
           return `${p1}x${p2}`   // 勾选
@@ -1200,6 +1218,11 @@ async function detectExecuteBatchFinish({ pm, stageName, changeName, cwd, specBa
       if (step.status === 'pending' || step.status === 'in-progress') {
         step.status = 'completed'
         step.completedAt = now
+        // 乐观预标戳：这是本次 --done 的批量乐观标记而非逐步验证的完成。任一收尾 gate 失败时
+        // rollbackStageCompletion 据此一并回滚（坑 execute-batch-rollback-half-state：只回滚
+        // currentIdx 会落库「步骤 11 pending + 12-16 completed」半套状态）。内存字段，_write 只写
+        // 固定列不落库。
+        step._batchAligned = true
         aligned++
       }
     }
@@ -1239,10 +1262,11 @@ export async function waitStep(pm, progress, stageName, cwd, outputText, waitRea
     process.exit(1)
   }
 
-  // 查找下一个 pending 或 in-progress 的步骤
-  const currentIdx = stageData.steps.findIndex(s => s.status === 'pending' || s.status === 'in-progress')
+  // 查找下一个 pending / in-progress / blocked 的步骤（blocked 同为当前步——与 completeStep
+  // 的 findIndex 口径对齐，否则 blocked 后 --wait 落到其后第一个 pending 步上错步记账）
+  const currentIdx = stageData.steps.findIndex(s => s.status === 'pending' || s.status === 'in-progress' || s.status === 'blocked')
   if (currentIdx === -1) {
-    console.error(`没有可以等待的步骤（阶段 ${stageName} 已无 pending/in-progress 步骤）。当前阶段状态：${stageData?.status ?? '未知'}。用 \`sillyspec run ${stageName} --status\` 查看进度，或 \`sillyspec progress show\` 看全局下一步。`)
+    console.error(`没有可以等待的步骤（阶段 ${stageName} 已无 pending/in-progress/blocked 步骤）。当前阶段状态：${stageData?.status ?? '未知'}。用 \`sillyspec run ${stageName} --status\` 查看进度，或 \`sillyspec progress show\` 看全局下一步。`)
     process.exit(1)
   }
 
@@ -1501,7 +1525,7 @@ export async function continueStep(pm, progress, stageName, cwd, answer, options
     if (stageName === 'verify') {
       try {
         const { consumeFrictionHint } = await import('../friction-tally.js')
-        const r = consumeFrictionHint({ cwd, changeName, platformOpts })
+        const r = await consumeFrictionHint({ cwd, changeName, platformOpts })
         if (r && r.hint) console.log(`\n${r.hint}`)
       } catch { /* 摩擦提示失败不影响收尾 */ }
     }
@@ -1557,7 +1581,10 @@ export async function skipStep(pm, progress, stageName, cwd, changeName, platfor
   }
 
   const steps = stageData.steps
-  const currentIdx = steps.findIndex(s => s.status === 'pending' || s.status === 'in-progress')
+  // blocked 同为当前步——与 completeStep 的 findIndex 口径对齐（坑 deps-gate-blocked-invisible
+  // 在 completeStep 修过但此处漏同步：blocked 后 --skip 落到其后第一个 pending 步上，错步跳过
+  // 且 blocked 步永久卡死只能 --reset）
+  const currentIdx = steps.findIndex(s => s.status === 'pending' || s.status === 'in-progress' || s.status === 'blocked')
 
   if (currentIdx === -1) {
     const wsIdx = steps.findIndex(s => s.status === 'waiting')
@@ -1565,11 +1592,15 @@ export async function skipStep(pm, progress, stageName, cwd, changeName, platfor
       console.error(`⏸️  Step ${wsIdx + 1} 正在等待用户输入，不能跳过。`)
       console.error(`   请先使用 --continue --answer "..." 继续，或用 --reset 重置。`)
     } else {
-      console.error(`没有待跳过的步骤（阶段 ${stageName} 已无 pending/in-progress 步骤）。当前阶段状态：${stageData?.status ?? '未知'}。用 \`sillyspec run ${stageName} --status\` 查看进度，或 \`sillyspec progress show\` 看全局下一步。`)
+      console.error(`没有待跳过的步骤（阶段 ${stageName} 已无 pending/in-progress/blocked 步骤）。当前阶段状态：${stageData?.status ?? '未知'}。用 \`sillyspec run ${stageName} --status\` 查看进度，或 \`sillyspec progress show\` 看全局下一步。`)
     }
     process.exit(1)
   }
 
+  if (steps[currentIdx].status === 'blocked') {
+    console.log(`⚠️  Step "${steps[currentIdx].name}" 此前被门控阻断（blocked），本次 --skip 将跳过该步——若门控条件已修复，更宜直接 --done 推进。`)
+  }
+
   const defSteps = await getStageStepsAutoAware(stageName, cwd, progress, platformOpts?.specRoot || null)
   const stepDef = defSteps ? defSteps[currentIdx] : null
   if (stepDef && !stepDef.optional) {

package/src/run/concurrent-detect.js

@@ -151,6 +151,6 @@ export function formatConcurrentWarning(detected) {
     for (const c of otherActiveChanges) lines.push(`  - ${c}`)
   }
 
-  lines.push('提交请用显式 pathspec 隔离本变更文件，勿 git add . 扫入他者工作。')
+  lines.push('提交请用显式 pathspec 隔离本变更文件，勿 git add . 扫入他者工作（execute task 内建议 sillyspec wt-commit 串行提交）。')
   return lines.join('\n')
 }

package/src/run/gate-snapshot.js

@@ -34,6 +34,16 @@ export function createGateSnapshot({ cwd, files, sourceRoot = null }) {
     // 前置：主仓须是 git 仓且有 HEAD（无 git 环境回退主仓现行为）
     git(cwd, ['rev-parse', 'HEAD'])
 
+    // symlink-store 布局探测（坑 gate-snapshot-pnpm-store-break，2026-09-12 驾驭第十七批②，
+    // 用户第三次踩「lint 沙箱临时目录跑 pnpm 必假败」）：pnpm/bun/lerna 的 node_modules 内部
+    // 是指向 store 的符号链接网——junction 进临时目录后跨根解析失效，实测必假败。
+    // 与其让沙箱报无关错误逼 advisory，不如布局命中即作废快照回退主仓（宁可主仓口径）。
+    const layoutHit = detectSymlinkStoreLayout(cwd)
+    if (layoutHit) {
+      console.warn(`⚠️ 门禁快照对 ${layoutHit} 布局不可靠（node_modules 符号链接 store 经 junction 跨根失效，实测必假败）——跳过快照回退主仓实测；主仓失败再做污染归属鉴定`)
+      return null
+    }
+
     snapshotRoot = mkdtempSync(join(tmpdir(), 'sillyspec-gate-'))
     git(cwd, ['worktree', 'add', '--detach', '--quiet', snapshotRoot, 'HEAD'])
 
@@ -58,11 +68,39 @@ export function createGateSnapshot({ cwd, files, sourceRoot = null }) {
       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 */ }
+    // 环境目录链接（坑 gate-snapshot-env-mismatch，2026-09-12 驾驭第十三批③，用户实证：
+    // 沙箱实测 venv 不装 dev 依赖（xdist 缺失）+ node_modules 缺失——快照只链 node_modules 时
+    // Python 项目的 commands.test 在快照内找不到 venv，误伤持续且难归因）。链接面扩 venv 族
+    // （.venv/venv/env——链接后 dev 依赖与主仓同源，不缺 xdist）；链接失败/主仓本就没有时
+    // ⚠️ 显式可见（环境不一致的门禁会持续误伤——宁可吵不可静默错）。
+    // 递归依赖发现（坑 gate-snapshot-monorepo-layout，2026-09-12 驾驭第十五批①，用户实证
+    // 「对 monorepo 依赖布局完全不可用，四次重试才定位」）：pnpm/nx/lerna workspace 的
+    // packages/<pkg>/node_modules 子目录依赖不在根四目录——深度≤3 扫描发现集逐个 junction。
+    const envRelDirs = discoverEnvDirs(cwd)
+    for (const rel of envRelDirs) {
+      const src = join(cwd, rel)
+      const dst = join(snapshotRoot, rel)
+      try {
+        mkdirSync(dirname(dst), { recursive: true })
+        symlinkSync(src, dst, 'junction')
+      } catch (e) {
+        console.warn(`⚠️ 门禁快照环境目录链接失败（${rel}）：${e && e.message ? e.message : e}——快照内实测可能因缺该目录误伤，失败时先核对快照环境`)
+      }
+    }
+    if (envRelDirs.length === 0) {
+      console.warn(`⚠️ 门禁快照：主仓未发现任何环境目录（node_modules / venv 族，含子包递归）——commands.test/lint 若依赖它们将快照/主仓都不可用（环境未安装？）`)
+    }
+
+    // 环境完整性预检（坑 gate-snapshot-env-mismatch 二阶，2026-09-12 驾驭第十四批①，用户
+    // 实证「verify lint 沙箱必挂 node_modules 缺失只能 advisory」）：主仓存在某环境目录而
+    // 快照内缺失（链接失败/布局差异）→ 快照对该仓 commands 是假环境，实测必挂——快照作废
+    // 回退主仓现行为（主仓口径可能被并行脏文件污染，但环境真实；两害取轻 + 回退原因可见）。
+    const envMissing = envDirsLinked(cwd, snapshotRoot)
+    if (envMissing.length > 0) {
+      console.warn(`⚠️ 门禁快照环境不完整（${envMissing.join('、')} 在主仓存在、快照内缺失）——快照作废回退主仓实测（宁可主仓口径不可假沙箱硬挂；回退后失败先做污染归属鉴定）`)
+      try { git(cwd, ['worktree', 'remove', '--force', '--quiet', snapshotRoot]) } catch {}
+      try { rmSync(snapshotRoot, { recursive: true, force: true }) } catch {}
+      return null
     }
 
     // local.yaml（gitignore 不进 HEAD；门禁命令配置来源）+ package-lock 保持 HEAD 版（npm test 不装新依赖）
@@ -90,6 +128,78 @@ export function createGateSnapshot({ cwd, files, sourceRoot = null }) {
   }
 }
 
+
+/** symlink-store 包管理布局探测：命中即 junction 快照不可靠。返回布局名或 null。 */
+export function detectSymlinkStoreLayout(cwd) {
+  try {
+    if (existsSync(join(cwd, 'pnpm-lock.yaml'))) return 'pnpm'
+    if (existsSync(join(cwd, 'bun.lockb')) || existsSync(join(cwd, 'bun.lock'))) return 'bun'
+    if (existsSync(join(cwd, 'lerna.json'))) return 'lerna'
+    try {
+      const pkg = JSON.parse(readFileSync(join(cwd, 'package.json'), 'utf8'))
+      const pm = pkg && pkg.packageManager ? String(pkg.packageManager) : ''
+      if (/pnpm@/.test(pm)) return 'pnpm(packageManager)'
+      if (/yarn@/.test(pm)) return 'yarn(packageManager)'
+      if (/bun@/.test(pm)) return 'bun(packageManager)'
+    } catch { /* 无 package.json/损坏 → 仅锁文件判据 */ }
+    return null
+  } catch { return null }
+}
+
+/** 环境目录名集（根与子包通用） */
+const ENV_DIR_NAMES = new Set(['node_modules', '.venv', 'venv', 'env'])
+
+/**
+ * 递归依赖发现（坑 gate-snapshot-monorepo-layout）：深度 ≤3 扫描（跳过环境目录自身内部/
+ * .git/dist/build/.sillyspec），返回所有环境目录的仓库根相对 POSIX 路径（含根级四目录）。
+ * pnpm/nx/lerna workspace 的 packages/<pkg>/node_modules 覆盖。
+ */
+export function discoverEnvDirs(cwd, { maxDepth = 3 } = {}) {
+  const out = []
+  const skip = new Set(['.git', 'dist', 'build', '.sillyspec', 'out', 'target'])
+  const walk = (dir, rel, depth) => {
+    let entries
+    try { entries = readdirSync(dir, { withFileTypes: true }) } catch { return }
+    for (const e of entries) {
+      if (!e.isDirectory() || skip.has(e.name)) continue
+      const childRel = rel ? rel + '/' + e.name : e.name
+      if (ENV_DIR_NAMES.has(e.name)) {
+        out.push(childRel)
+        continue // 环境目录内部不再下钻（node_modules/node_modules 无意义且巨大）
+      }
+      if (depth < maxDepth) walk(join(dir, e.name), childRel, depth + 1)
+    }
+  }
+  walk(cwd, '', 0)
+  return out
+}
+
+/**
+ * 环境完整性纯检（坑 gate-snapshot-env-mismatch 二阶，发现集口径）：主仓存在（递归发现）
+ * 而快照缺失的环境目录清单。任一命中 = 快照对该仓 commands 是假环境，调用方作废回退主仓。
+ * @returns {string[]} 缺失目录相对路径（空数组 = 完整/主仓本就无环境目录）
+ */
+export function envDirsLinked(cwd, snapshotRoot) {
+  const missing = []
+  for (const rel of discoverEnvDirs(cwd)) {
+    try {
+      if (existsSync(join(cwd, rel)) && !existsSync(join(snapshotRoot, rel))) missing.push(rel)
+    } catch { missing.push(rel) /* 判定异常按缺失算（保守作废快照） */ }
+  }
+  return missing
+}
+
+/**
+ * 快照内实测失败的归属提示（坑 gate-snapshot-monorepo-layout 配套：用户四次重试才从日志
+ * 摸到 Temp\sillyspec-gate-* 路径——失败时路径/疑点/对照复跑出口必须直给）。
+ * 调用方在「快照内执行且失败」的分支打印。
+ */
+export function printSnapshotFailureHint(snapInfo, { offEnv = 'SILLYSPEC_VERIFY_GATE_SNAPSHOT_OFF' } = {}) {
+  if (!snapInfo || !snapInfo.snapshotRoot) return
+  console.error(`   🔬 本次实测执行于隔离快照：${snapInfo.snapshotRoot}（HEAD + 本变更 ${snapInfo.changeFileCount ?? '?'} 个文件${snapInfo.sourceRoot ? '，overlay 自 worktree' : ''}）`)
+  console.error(`   失败疑点排查顺序：① 本变更文件自身的真实失败（最常见）→ 修代码；② 快照环境差异（monorepo 依赖布局/环境目录链接缺失）→ 设 ${offEnv}=1 回退主仓复跑对照——主仓过而快照挂即环境问题；③ 并行污染已被快照隔离，不在疑点内。`)
+}
+
 /**
  * verify 门专用快照（2026-09-10 驾驭小结第八批，用户第二次真实阻塞：verify 实测门跑
  * main 工作区，多会话并发任何人的 WIP 都能弄红别人的门）。等价「--worktree 定向跑」：