sillyspec 3.28.7 → 3.28.8

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

@@ -1067,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
@@ -1090,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
@@ -1367,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 { /* 摩擦提示失败不影响收尾 */ }
 

package/src/run/complete.js

@@ -673,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 { /* 摩擦提示失败不影响收尾 */ }
     }
@@ -1071,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}`   // 勾选
@@ -1212,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++
       }
     }
@@ -1251,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)
   }
 
@@ -1513,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 { /* 摩擦提示失败不影响收尾 */ }
     }
@@ -1569,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')
@@ -1577,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 定向跑」：

package/src/run/gates.js

@@ -485,8 +485,14 @@ export async function enforceReviewJsonGate(stageName, cwd, changeName, step, st
  * 若校验失败不回滚，DB 会与真实产物不一致（hook/doctor/下游阶段全部误判），
  * 且所有步骤都是 completed 时 agent 无法重新 --done（"没有待完成的步骤"）。
  * 此处将 stage 回滚为 in-progress，最后一步重置为 pending，供修复产物后重做。
+ *
+ * 批量乐观标记一并回滚（坑 execute-batch-rollback-half-state，2026-08-29 用户实证）：execute
+ * 批量完成（detectExecuteBatchFinish）把剩余步骤批量标 completed 后任一收尾 gate 失败，原先只
+ * 回滚 currentIdx → 落库「步骤 11 pending + 12-16 completed」半套状态，步骤序倒挂、要再补一次
+ * --done 才对齐。批量标记打 _batchAligned 戳（内存字段不落库），gate 失败 = 批量完成整体不成立，
+ * 戳上的步骤随当前步一起回滚 pending，下次 --done 满足条件再重新批量标记。
  */
-function rollbackStageCompletion(stageData, steps, currentIdx) {
+export function rollbackStageCompletion(stageData, steps, currentIdx) {
   // 辅助阶段在 validator 前已被重置为 pending（steps 也换成了新数组），不要覆盖
   if (stageData.status === 'completed') {
     stageData.status = 'in-progress'
@@ -496,6 +502,14 @@ function rollbackStageCompletion(stageData, steps, currentIdx) {
     steps[currentIdx].status = 'pending'
     steps[currentIdx].completedAt = null
   }
+  for (const s of steps) {
+    if (!s) continue
+    if (s._batchAligned && s.status === 'completed') {
+      s.status = 'pending'
+      s.completedAt = null
+    }
+    s._batchAligned = false
+  }
 }
 
 /**
@@ -511,7 +525,7 @@ function rollbackCompletionAndReturn(pm, progress, stageData, steps, currentIdx,
   // friction 尾参（friction-signal-hint task-02）：gate 失败摩擦埋点标签 {type, detail}——各调用点
   // 按所属 gate 段传来源标签（审查两段走 review_rejected），未传兜底通用 gate-cascade。
   // recordFrictionEvent 自带静默降级（非法类型/写失败返回 null），不影响回滚/返回语义。
-  recordFrictionEvent({ cwd, changeName, platformOpts, ...(friction || { type: 'gate_rollback', detail: 'gate-cascade' }) })
+  void recordFrictionEvent({ cwd, changeName, platformOpts, ...(friction || { type: 'gate_rollback', detail: 'gate-cascade' }) })
   rollbackStageCompletion(stageData, steps, currentIdx)
   progress.lastActive = new Date().toLocaleString('zh-CN', { hour12: false })
   pm._write(cwd, progress, changeName)
@@ -646,7 +660,7 @@ export async function runStageCompletionGates({ stageName, cwd, changeName, plat
         const { createVerifyGateSnapshot } = await import('./gate-snapshot.js')
         verifyGateSnap = await createVerifyGateSnapshot({ cwd, changeName, specBase, platformOpts })
         if (verifyGateSnap) {
-          console.log(`🧪 Verify 实测隔离快照：HEAD + 本变更 ${verifyGateSnap.changeFileCount} 个文件${verifyGateSnap.sourceRoot ? '（overlay 自 worktree——本变更分支内容定向跑）' : ''}（并行会话脏文件不参与门判定）`)
+          console.log(`🧪 Verify 实测隔离快照（根：${verifyGateSnap.snapshotRoot}）：HEAD + 本变更 ${verifyGateSnap.changeFileCount} 个文件${verifyGateSnap.sourceRoot ? '（overlay 自 worktree——本变更分支内容定向跑）' : ''}（并行会话脏文件不参与门判定）`)
         }
       } catch { /* 快照链路异常 → 主仓现行为 */ }
     }
@@ -679,7 +693,11 @@ export async function runStageCompletionGates({ stageName, cwd, changeName, plat
       }
     } catch { /* fail-soft：回填失败不影响门禁 */ }
     if (testCheck.status === 'failed') {
-      if (verifyGateSnap) { try { verifyGateSnap.cleanup() } catch {} ; verifyGateSnap = null }
+      if (verifyGateSnap) {
+        try { const { printSnapshotFailureHint } = await import('./gate-snapshot.js')
+          printSnapshotFailureHint(verifyGateSnap) } catch { /* 提示失败不影响阻断 */ }
+        try { verifyGateSnap.cleanup() } catch {} ; verifyGateSnap = null
+      }
       console.error('\n❌ verify 阶段被阻断：verify-result.md 自报告通过，但 CLI 实测测试失败。')
       // 并行 WIP 归因鉴别（坑 verify-reconcile-foreign-wip）：单一实现迁至 verify-quality-scan.js
       // renderVerifyTestAttribution（P0-1 前置二：noAI 质量扫描失败路径与本 --done 路径共用，
@@ -700,13 +718,21 @@ export async function runStageCompletionGates({ stageName, cwd, changeName, plat
     if (lintCheck) {
       console.log(`\n♻️ Verify lint 对账：复用 noAI 质量扫描步的实测结果（代码指纹匹配，免重跑）`)
     } else {
-      lintCheck = runVerifyLintCheck({ cwd: gateCwd, specBase: gateSpecBase })
+      lintCheck = runVerifyLintCheck({ cwd: gateCwd, specBase: gateSpecBase, timeoutMs: verifyGateSnap ? 5 * 60 * 1000 : undefined })
+    // 快照 lint 超时回退主仓（2026-09-12 dogfood 两连实证：junction I/O 病态慢，3min/5min 均被
+    // 超时杀——主仓 60~110s 正常。按用户建议「自动回退」而非假败/advisory：主仓复跑保硬门，
+    // 并行噪声混入时失败输出带归属鉴定提示）
+      if (verifyGateSnap && lintCheck.status === 'failed' && /超时/.test(String(lintCheck.reason || ''))) {
+        console.warn('⚠️ 快照 lint 超时（node_modules junction I/O 慢）→ 主仓复跑 lint（并行噪声可能混入——失败先做归属鉴定）')
+        lintCheck = runVerifyLintCheck({ cwd, specBase })
+      }
       if (lintCheck.status !== 'skipped') {
         console.log(`\n⏳ Verify lint 对账：CLI 亲自执行 local.yaml 的 commands.lint…`)
       }
     }
     // 快照收尾（test+lint 两检查都已完成；parity/删除探针走主仓 git 事实不依赖快照）
     const usedSnapshot = Boolean(verifyGateSnap)
+    const usedSnapInfo = verifyGateSnap ? { snapshotRoot: verifyGateSnap.snapshotRoot, changeFileCount: verifyGateSnap.changeFileCount, sourceRoot: verifyGateSnap.sourceRoot } : null
     if (verifyGateSnap) { try { verifyGateSnap.cleanup() } catch {} ; verifyGateSnap = null }
     printVerifyLintCheck(lintCheck)
     // lint 硬门（2026-09-09 升硬：观察期 14 次 5 败全真阳性，pre-push 本就硬拦——fail-fast 前移；
@@ -714,6 +740,10 @@ export async function runStageCompletionGates({ stageName, cwd, changeName, plat
     const { shouldBlockVerifyLint } = await import('../verify-postcheck.js')
     if (shouldBlockVerifyLint(lintCheck)) {
       console.error('\n❌ verify 阶段被阻断：CLI 亲自实测 lint 失败（agent 的 lint 自报告与实测不符时以实测为准）。')
+      if (usedSnapInfo) {
+        try { const { printSnapshotFailureHint } = await import('./gate-snapshot.js')
+          printSnapshotFailureHint(usedSnapInfo) } catch { /* 提示失败不影响阻断 */ }
+      }
       if (lintCheck.outputTail) {
         const tail = lintCheck.outputTail.split('\n').slice(-8).join('\n')
         console.error('   输出（末尾）：')

package/src/run/prompt.js

@@ -22,7 +22,7 @@ import { basename, join } from 'node:path'
 import { existsSync, readFileSync, mkdirSync, readdirSync } from 'node:fs'
 import { writeAtomicSync } from '../fs-atomic.js'
 import { stageRegistry } from '../stages/index.js'
-import { resolvePromptIncludes, resolveRuntimeRoot, safeGit, parsePorcelainPath, WAIT_MARKER_RE, QUICK_SID_RE } from './shared.js'
+import { resolvePromptIncludes, resolveRuntimeRoot, safeGit, parsePorcelainPath, WAIT_MARKER_RE, QUICK_SID_RE, triggerStepStartSync } from './shared.js'
 import { renderSemanticGuardBlock, readSemanticGuardEnabled } from '../semantic-guard.js'
 import { renderStageContract } from '../stage-contract-spec.js'
 import { nowWallClock } from '../datetime.js'
@@ -309,6 +309,14 @@ export async function outputStep(stageName, stepIndex, steps, cwd, changeName, d
     return false
   }
 
+  // X3 渲染侧接线（2026-08-29-change-delete-closure-and-spec-pull 遗留活跃坑收口；曾因并行
+  // 会话提交丢弃一次，2026-09-12 复检重接）：步骤 prompt 渲染即步骤起点——补推一次 progress
+  // 刷新平台 last_pushed_at（停滞判定不再把长步骤误报为「停滞」）。不 await：prompt 渲染不被
+  // 网络阻塞；未连接平台静默 / quick 会话降级跳过 / 8s 熔断 / 失败只 warn，契约全在
+  // triggerStepStartSync 内（shared.js docstring 即本接线点的说明），Node 事件循环保证在飞
+  // POST 落地后进程才退出。
+  triggerStepStartSync(cwd, changeName, platformOpts)
+
   // ── 首个 agent 可见步索引（「首步一次建立」类注入的锚点）──
   // step0 为 noAI（brainstorm/execute/verify 的 step1「进度确认」，2026-09-07）时不渲染 prompt，
   // persona/护栏/完成契约/铁律/平台路径约束等 step0 专属注入须顺延到首个渲染步，否则整段丢失

package/src/run/quick-audit.js

@@ -137,6 +137,17 @@ export function printQuickAuditReview(review) {
     }
     console.warn(`   quick 不强制文档同步，欠账已随本条 QUICKLOG「审计：」行落盘（可事后追溯）。若改动触及接口/契约，建议顺手同步模块文档。`)
   }
+  // spec 共享面他者噪声（坑 foreign-spec-churn-fail-closed）：并行会话归档移动/文档收尾的
+  // 删除与 EOL-only 假 M——软警告点名归因，不再逼 --allow-delete/--allow-new 解锁。
+  if (review.foreignSpecChurn && review.foreignSpecChurn.length > 0) {
+    console.warn(`⚠️ spec 共享面 ${review.foreignSpecChurn.length} 个非本会话声明的删除（.sillyspec/ docs/，疑似并行会话归档移动/收尾——归其会话收口，本会话不阻断）：`)
+    for (const f2 of review.foreignSpecChurn.slice(0, 6)) console.warn(`   - ${f2}`)
+    if (review.foreignSpecChurn.length > 6) console.warn(`   … 共 ${review.foreignSpecChurn.length} 个`)
+  }
+  if (review.eolOnlyFiles && review.eolOnlyFiles.length > 0) {
+    console.warn(`⚠️ ${review.eolOnlyFiles.length} 个文件仅行尾重写（内容零变化，gen:types/编辑器 CRLF 假 M——已剔出本会话审计）：${review.eolOnlyFiles.slice(0, 5).join('、')}${review.eolOnlyFiles.length > 5 ? ' 等' : ''}`)
+    console.warn(`   根治：.gitattributes 声明 text=auto eol=lf（或按文件类型钉死），生成器重写不再制造假 M`)
+  }
   if (review.docsCheckHint && review.docsCheckHint.invalid > 0) {
     console.warn(`\n📎 文档引用失效（docs check）：本次改动的文档含 ${review.docsCheckHint.invalid}/${review.docsCheckHint.total} 处失效 file:line 引用。`)
     // 逐条指名（2026-09-11 用户实证：只报计数不指名哪处，四轮复现才定位——门禁输出
@@ -338,16 +349,28 @@ export async function runQuickTestLintGate({ cwd, specBase, changedFiles = [], d
       if (snapshot) {
         gateCwd = snapshot.snapshotRoot
         gateSpecBase = join(snapshot.snapshotRoot, '.sillyspec')
-        console.log(`🧪 门禁隔离快照：HEAD + 本会话 ${snapshot.overlaid} 个文件（并行会话脏文件不参与判定）`)
+        console.log(`🧪 门禁隔离快照（根：${snapshot.snapshotRoot}）：HEAD + 本会话 ${snapshot.overlaid} 个文件（并行会话脏文件不参与判定）`)
       }
     } catch { /* 快照链路异常 → 主仓现行为 */ }
   }
   try {
     const test = runVerifyTestCheck({ cwd: gateCwd, specBase: gateSpecBase, changeName })
-    const lint = runVerifyLintCheck({ cwd: gateCwd, specBase: gateSpecBase })
+    let lint = runVerifyLintCheck({ cwd: gateCwd, specBase: gateSpecBase, timeoutMs: snapshot ? 5 * 60 * 1000 : undefined })
+    // 快照 lint 超时回退主仓（2026-09-12 dogfood 两连实证：junction I/O 病态慢，3min/5min 均被
+    // 超时杀——主仓 60~110s 正常。按用户建议「自动回退」而非假败/advisory：主仓复跑保硬门，
+    // 并行噪声混入时失败输出带归属鉴定提示）
+    if (snapshot && lint.status === 'failed' && /超时/.test(String(lint.reason || ''))) {
+      console.warn('⚠️ 快照 lint 超时（node_modules junction I/O 慢）→ 主仓复跑 lint（并行噪声可能混入——失败先做归属鉴定）')
+      lint = runVerifyLintCheck({ cwd, specBase })
+    }
     const failed = []
     if (test.status === 'failed') failed.push('test')
     if (lint.status === 'failed') failed.push('lint')
+    if (failed.length > 0 && snapshot) {
+      try { const { printSnapshotFailureHint } = await import('./gate-snapshot.js')
+        printSnapshotFailureHint({ snapshotRoot: snapshot.snapshotRoot, changeFileCount: snapshot.overlaid, sourceRoot: snapshot.sourceRoot || null }, { offEnv: 'SILLYSPEC_QUICK_GATE_SNAPSHOT_OFF' })
+      } catch { /* 提示失败不影响门禁语义 */ }
+    }
     return {
       action: failed.length > 0 ? 'fail' : 'pass',
       failed,