sillyspec 3.27.6 → 3.27.9

package/src/run/complete.js

@@ -23,7 +23,7 @@ import { withFileLock } from '../quicklog.js'
 import { triggerSync, WAIT_MARKER_RE, getStageSteps, formatWaitOptions, resolveRuntimeRoot, getOrCreateMultiRepoContext, resolveChangeDir } from './shared.js'
 import { executeScanPreflight, executeScanPostcheck, computeScanProfile } from './scan-profile.js'
 import { executePlanPostcheck as runPlanPostcheckLib } from '../stages/plan-postcheck.js'
-import { outputStep } from './prompt.js'
+import { outputStep, collectStageWaitHistory } from './prompt.js'
 import { enforceDepsGate, enforceReviewJsonGate, enforceSymbolImpactGate, warnMissingUiPrototype, completeStageGates, readDesignScale } from './gates.js'
 import { handleArchiveConfirmStep, handlePlanGeneratePlanStep, handleScanProjectListStep, handleWorkflowPostCheck, handleQuickStageCompletion, handleExecuteWaveArtifact } from './complete-handlers.js'
 import { formatExecuteSummary } from '../worktree-apply.js'
@@ -80,7 +80,10 @@ export function resolveWaitingStepWithAnswer(steps, doneAnswer, nowStr) {
 
 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 } = options
-  const specBase = platformOpts.specRoot || join(cwd, '.sillyspec')
+  // specRoot(平台) > specDriftAnchor(worktree 漂移锚定主仓) > cwd/.sillyspec(本地)——
+  // 与 prompt.js resolvePromptSpecBase 同序：--done 收尾的 user-inputs.md/超长 artifact 落盘
+  // 必须与 prompt 渲染同一根，否则写进 worktree 副本目录、随 cleanup 整目录删除。
+  const specBase = platformOpts.specRoot || platformOpts.specDriftAnchor || join(cwd, '.sillyspec')
   const stageData = progress.stages[stageName]
 
   // ── WAIT MARKER 硬校验 ──
@@ -100,7 +103,16 @@ export async function completeStep(pm, progress, stageName, cwd, outputText, inp
   }
 
   const steps = stageData.steps
-  let currentIdx = steps.findIndex(s => s.status === 'pending' || s.status === 'in-progress')
+  // blocked（deps/review.json 门控阻断标记）也视为当前步骤（坑 deps-gate-blocked-invisible，
+  // 2026-08-27 实证）：门控阻断时 enforceDepsGate/enforceReviewJsonGate 把当前步置 blocked 后
+  // exit(1)，若谓词漏 blocked，被阻断步骤对 findIndex 永久隐身——重试 --done 落到其后第一个
+  // pending 步骤上（错步记账，DB 显示与事实脱节），且 blocked 步骤无任何恢复路径（状态机卡死，
+  // 只能 --reset 丢进度）。门控本身在下方会重新校验：deps 已修复 → 正常完成；未修复 → 再次
+  // 阻断同一步（幂等，不污染后续步骤）。
+  let currentIdx = steps.findIndex(s => s.status === 'pending' || s.status === 'in-progress' || s.status === 'blocked')
+  if (currentIdx !== -1 && steps[currentIdx].status === 'blocked') {
+    console.log(`⚠️  Step "${steps[currentIdx].name}" 此前被门控阻断（blocked），本次 --done 重新校验门控后继续推进。`)
+  }
   // ── 坑1：--done --answer 解「已 waiting 的步骤」──
   // findIndex 仅查 pending/in-progress，排除 waiting；故 --done --answer 落到已 --wait 暂停的
   // requiresWait 步骤时会跳过它、把 --answer 静默丢弃，步骤永久卡 WAITING、末步报「等待用户输入」。
@@ -177,9 +189,10 @@ export async function completeStep(pm, progress, stageName, cwd, outputText, inp
       try {
         const { ensureStageSteps } = await import('./command.js')
         const reseeded = await ensureStageSteps(progress, stageName, cwd, platformOpts?.specRoot || null)
-        if (reseeded && effectiveChange) {
-          pm._write(cwd, progress, effectiveChange)
-          progress = pm.read(cwd, effectiveChange) || progress
+        const reseedChange = changeName || progress.currentChange
+        if (reseeded && reseedChange) {
+          pm._write(cwd, progress, reseedChange)
+          progress = pm.read(cwd, reseedChange) || progress
         }
         const freshSteps = progress?.stages?.[stageName]?.steps || []
         const freshPending = freshSteps.findIndex(s => s.status === 'pending' || s.status === 'in-progress')
@@ -324,7 +337,7 @@ export async function completeStep(pm, progress, stageName, cwd, outputText, inp
   await handleScanProjectListStep({ stageName, steps, currentIdx, outputText, stageData, specBase, cwd, platformOpts })
 
   // execute Wave artifact（W6 Step6c 抽至 complete-handlers.js handleExecuteWaveArtifact）
-  await handleExecuteWaveArtifact({ stageName, steps, currentIdx, changeName, specBase, cwd })
+  await handleExecuteWaveArtifact({ stageName, steps, currentIdx, changeName, specBase, cwd, platformOpts })
 
   // execute 批量完成检测：plan 全勾 + 代码客观核验通过 → 剩余 step 一次性标 completed，
   // 使本次 --done 直接进入阶段完成分支（治"3 Wave 做完仍逐次 +1、需重走 7 次 --done"）。
@@ -337,7 +350,7 @@ export async function completeStep(pm, progress, stageName, cwd, outputText, inp
     if (_ac.skippedCount > 0) {
       console.warn(`   ⚠️ ${_ac.skippedCount} 个 task 未勾（review.json 缺失/fail）→ 批量完成条件不满足，仍按单步推进`)
     }
-    const _bf = await detectExecuteBatchFinish({ pm, stageName, changeName, cwd, specBase, steps })
+    const _bf = await detectExecuteBatchFinish({ pm, stageName, changeName, cwd, specBase, platformOpts, steps })
     if (_bf.batched && _bf.aligned > 0) {
       console.log(`\n🚀 execute 批量完成：plan 全勾 + 代码核验通过，一次性补完 ${_bf.aligned} 个剩余 step → 进入阶段完成分支`)
     }
@@ -556,7 +569,7 @@ export async function completeStep(pm, progress, stageName, cwd, outputText, inp
   if (_wfResult) return _wfResult
 
   if (printNext) {
-    await outputStep(stageName, nextPendingIdx, defSteps, cwd, changeName, progress.project || null, platformOpts)
+    await outputStep(stageName, nextPendingIdx, defSteps, cwd, changeName, progress.project || null, platformOpts, null, collectStageWaitHistory(progress, stageName))
     // task-08：底部锚定行——outputStep 渲染的长 prompt 易被 tail 截断，末尾再打一行推进位置，
     // 让 agent 只看末几行也能知道「推进到第几步」。仅单步推进分支（阶段完成分支已有 ✅ 阶段已完成）。
     // defSteps 越界防御：平台模式 buildPlanSteps 长度漂移时 nextPendingIdx 可能越界
@@ -785,7 +798,7 @@ async function autoCheckPlanFromReviews({ stageName, changeName, cwd, platformOp
  * 安全门：注册表零 checkbox / 未全勾 / 代码零变更（unchanged）均不批量——信任声明但用代码核验兜底。
  * @returns {Promise<{batched:boolean, aligned:number, reason?:string, blockedTasks?:string[]}>}
  */
-async function detectExecuteBatchFinish({ pm, stageName, changeName, cwd, specBase, steps }) {
+async function detectExecuteBatchFinish({ pm, stageName, changeName, cwd, specBase, platformOpts, steps }) {
   if (stageName !== 'execute' || !changeName) return { batched: false, aligned: 0 }
   try {
     const changeDir = join(specBase, 'changes', changeName)
@@ -815,20 +828,27 @@ async function detectExecuteBatchFinish({ pm, stageName, changeName, cwd, specBa
 
     // 构造 ctx 供草稿零 diff 校验用（与 task-04 同源）
     const ctx = prefetchDiffFileSet(await buildDraftContext(cwd, changeName))
-    const runtimeRoot = resolveRuntimeRoot({ specRoot: specBase }, specBase)
+    // runtimeRoot 走 platformOpts 感知解析（与 autoCheckPlanFromReviews 同口径）：
+    // 平台模式 runtimeRoot / worktree 漂移 specDriftAnchor 不透传时 marker 恒读不到
+    // → 每个 task 进 blockedTasks → 批量完成静默失效
+    const runtimeRoot = resolveRuntimeRoot(platformOpts, specBase)
     const runIdFile = join(runtimeRoot, `current-execute-run-id-${changeName}`)
     const blockedTasks = []
+    const { readReview, isValidExecuteRunId } = await import('../task-review.js')
+    // runId marker 对全部 task 恒定：循环外一次读盘（原实现逐 task 重复 readFileSync 同一文件）
+    let executeRunId = null
+    try {
+      const c = readFileSync(runIdFile, 'utf8').trim()
+      if (c && isValidExecuteRunId(c)) executeRunId = c
+    } catch {}
 
     for (const taskId of taskIds) {
       let review = null
+      if (!executeRunId) {
+        blockedTasks.push(taskId)
+        continue
+      }
       try {
-        const { readReview, isValidExecuteRunId } = await import('../task-review.js')
-        const c = readFileSync(runIdFile, 'utf8').trim()
-        if (!c || !isValidExecuteRunId(c)) {
-          blockedTasks.push(taskId)
-          continue
-        }
-        const executeRunId = c
         const reviewPath = join(runtimeRoot, 'execute-runs', executeRunId, 'tasks', taskId, 'review.json')
         const r = readReview(reviewPath)
         if (!r?.ok) {
@@ -1132,7 +1152,9 @@ export async function continueStep(pm, progress, stageName, cwd, answer, options
         changeName,
         progress.project || null,
         platformOpts,
-        formatWaitHistory(currentStep)
+        formatWaitHistory(currentStep),
+        // 跨会话 --continue（新会话直接带回答恢复 waiting 步）时，其他步骤的历史回答同样要回放
+        collectStageWaitHistory(progress, stageName)
       )
     }
     return { stageCompleted: false, currentIdx, nextPendingIdx: currentIdx }
@@ -1195,7 +1217,7 @@ export async function continueStep(pm, progress, stageName, cwd, answer, options
   // 输出下一步
     if (nextPendingIdx !== -1 && defSteps) {
       console.log('')
-    await outputStep(stageName, nextPendingIdx, defSteps, cwd, changeName, progress.project || null, platformOpts, answer)
+    await outputStep(stageName, nextPendingIdx, defSteps, cwd, changeName, progress.project || null, platformOpts, answer, collectStageWaitHistory(progress, stageName))
   } else if (nextWaitingIdx !== -1 && defSteps) {
     // 下一个步骤也在等待状态
     const ws = stageData.steps[nextWaitingIdx]
@@ -1246,7 +1268,7 @@ export async function skipStep(pm, progress, stageName, cwd, changeName, platfor
   const nextPendingIdx = steps.findIndex(s => s.status === 'pending' || s.status === 'in-progress')
   if (nextPendingIdx !== -1 && defSteps) {
     console.log('')
-    await outputStep(stageName, nextPendingIdx, defSteps, cwd, changeName, progress.project || null, platformOpts)
+    await outputStep(stageName, nextPendingIdx, defSteps, cwd, changeName, progress.project || null, platformOpts, null, collectStageWaitHistory(progress, stageName))
   } else {
     const wsIdx = steps.findIndex(s => s.status === 'waiting')
     if (wsIdx !== -1) {

package/src/run/gates.js

@@ -71,7 +71,14 @@ export function validateSymbolImpactReport({ reportContent, planContent }) {
   //（generateSymbolImpactSkeleton），占位未替换即拦——骨架消灭的是「从零手写/漏 task」错误面，
   // 不是把「逐 task 结论」本身变成走过场。
   const report = String(reportContent)
-  const todoPending = taskIds.filter(id => new RegExp(`^[-*]\\s*${id}[^\\n]*<!--TODO-->`, 'm').test(report))
+  // 单遍扫描替代逐 task new RegExp（N 个 task 原实现编译 N 个正则 + 全文扫 N 次）
+  // 捕获 token 排除冒号/逗号：骨架行格式「- task-01: <!--TODO-->」，\S+ 会连冒号一起捕获导致永不命中
+  const idSet = new Set(taskIds)
+  const todoHitIds = new Set()
+  for (const m of report.matchAll(/^[-*][ \t]*([^\s:：,，]+)[^\n]*<!--TODO-->/gm)) {
+    if (idSet.has(m[1])) todoHitIds.add(m[1])
+  }
+  const todoPending = taskIds.filter(id => todoHitIds.has(id))
   for (const id of todoPending) {
     errors.push(`${id} 的结论仍是骨架 <!--TODO--> 占位——替换为真实结论（无签名级变更也显式写「无」）`)
   }
@@ -314,10 +321,42 @@ export async function enforceDepsGate(stageName, cwd, changeName, step, steps, c
     console.warn(`⚠️ worktree meta 读取失败（deps gate 将走物理目录判定）: ${e.message}`)
   }
   const depsStatus = meta?.depsStatus
-  if (['linked', 'installed', 'n/a'].includes(depsStatus)) return true
+  const mainOk = ['linked', 'installed', 'n/a'].includes(depsStatus)
+  if (mainOk) {
+    // ── 跨仓 worktree deps 校验（坑 cross-repo-no-worktree-isolation）──
+    // 跨仓仓供给失败同样无构建/测试能力（前端仓无 node_modules 建不了 build）。只校验已建
+    // worktree 的跨仓仓（legacy 直写模式无 meta，维持原语义，下游 Task Review 兜底）。
+    let crossFailed = []
+    try {
+      const crossSpecBase = platformOpts?.specRoot || join(cwd, '.sillyspec')
+      const { listCrossWorktreeMetas } = await import('../worktree-cross.js')
+      crossFailed = listCrossWorktreeMetas(crossSpecBase, changeName)
+        .filter(({ meta: cm }) => cm.depsStatus && !['linked', 'installed', 'n/a'].includes(cm.depsStatus))
+    } catch (e) {
+      console.warn(`⚠️ 跨仓 worktree deps 校验跳过（${e.message}）`)
+    }
+    if (crossFailed.length === 0) return true
+    if (steps && steps[currentIdx]) {
+      steps[currentIdx].status = 'blocked'
+      steps[currentIdx].blockReason = `跨仓 deps 门控阻断（${crossFailed.map(f => f.repoKey).join(', ')}）：修复后重试 --done`
+    }
+    console.error('❌ ── deps 门控阻断（本次 --done 未完成，进度未推进）──')
+    for (const { repoKey, meta: cm } of crossFailed) {
+      console.error(`   跨仓 repo ${repoKey} 依赖未就绪（depsStatus=${cm.depsStatus || 'unknown'}）——workdir: ${cm.worktreePath}`)
+      if (cm.depsError) console.error(`   上次供给错误：${cm.depsError}`)
+    }
+    console.error('   修复：进上述跨仓 worktree 手动安装依赖（用该仓的包管理器），或重跑 sillyspec run execute 让 CLI 重试供给后 --done。')
+    if (persist) { try { await persist() } catch { /* 落盘失败不吞阻断语义 */ } }
+    process.exit(1)
+  }
   const changeDir = changeName ? join(specBase, 'changes', changeName) : null
   if (isCurrentWaveAllNoDepsVerify(step?.name, changeDir)) return true
-  if (steps && steps[currentIdx]) steps[currentIdx].status = 'blocked'
+  if (steps && steps[currentIdx]) {
+    steps[currentIdx].status = 'blocked'
+    // 阻断原因持久化（坑 deps-gate-blocked-invisible）：--status/诊断时可见，不依赖阻断当刻的
+    // stderr（跨进程即失忆）。completed 时由 completeStep 主流程覆盖整个步骤行，残留字段不外泄。
+    steps[currentIdx].blockReason = `deps 门控阻断（depsStatus=${depsStatus || 'unknown'}）：worktree doctor --fix 修复后重试 --done`
+  }
   // ── 诊断分支（Phase 2，G2/R3 修正：判定基于物理目录而非 !meta）──
   // getMeta 对"目录不存在"与"meta 损坏"都返回 null，后者会误判终态 → 用物理目录存在性判定。
   let worktreeGone = true
@@ -404,7 +443,10 @@ export async function enforceReviewJsonGate(stageName, cwd, changeName, step, st
   }
   const result = validateCheckedTaskReviews({ planContent, runtimeRoot, executeRunId })
   if (result.ok) return true
-  if (steps && steps[currentIdx]) steps[currentIdx].status = 'blocked'
+  if (steps && steps[currentIdx]) {
+    steps[currentIdx].status = 'blocked'
+    steps[currentIdx].blockReason = 'review.json 字段校验阻断：补齐后重试 --done（backfill-reviews --adopt 可代填 mechanics）'
+  }
   console.error('❌ ── review.json 字段校验阻断（本次 --done 未完成，进度未推进）──')
   console.error('   已勾选 [x] 的 task review.json 不完整（铁律：勾 checkbox 前必须先写完整 review.json）:')
   for (const f of result.failures) {
@@ -470,7 +512,7 @@ export async function runStageCompletionGates({ stageName, cwd, changeName, plat
   if (['brainstorm', 'plan', 'verify'].includes(stageName) && changeName) {
     try {
       const { ensureDecisionDocHeader } = await import('../stage-contract.js')
-      ensureDecisionDocHeader(resolveChangeDir(cwd, changeName, platformOpts?.specRoot))
+      ensureDecisionDocHeader(resolveChangeDir(cwd, { currentChange: changeName }, platformOpts?.specRoot))
     } catch { /* 补齐失败不阻断 gate */ }
   }
   // TaskCard 骨架幂等预生成（坑 taskcard-parallel-cli-lock，2026-08-25 用户实证：并行 batch
@@ -490,7 +532,10 @@ export async function runStageCompletionGates({ stageName, cwd, changeName, plat
       console.warn(`⚠️ TaskCard 骨架预生成失败（不阻断 gate，仍可逐卡手动 sillyspec taskcard 生成）: ${e.message}`)
     }
   }
-  const contractResult = runValidators(stageName, cwd, changeName, { projectName, specRoot: platformOpts?.specRoot })
+  // runtimeRoot 进 context（坑 verify-receipt-runtime-split）：verify 回执写入方
+  // reapVerifyServices 落 resolveRuntimeRoot(platformOpts, specBase)，校验器读侧不透传时
+  // 平台/漂移模式恒读不到回执 → 证据门退回纯字面匹配（回执机制正是为消灭它而生）
+  const contractResult = runValidators(stageName, cwd, changeName, { projectName, specRoot: platformOpts?.specRoot, runtimeRoot: resolveRuntimeRoot(platformOpts, specBase) })
   if (contractResult.errors.length > 0) {
     console.error(`\n❌ 阶段 ${stageName} 校验失败：`)
     for (const err of contractResult.errors) {
@@ -530,7 +575,7 @@ export async function runStageCompletionGates({ stageName, cwd, changeName, plat
       try {
         const { collectForeignDeclaredFiles } = await import('../verify-postcheck.js')
         const { gitQuiet } = await import('../git-helper.js')
-        const foreignMap = collectForeignDeclaredFiles(cwd, changeName)
+        const foreignMap = collectForeignDeclaredFiles(cwd, changeName, { specBase, runtimeRoot: resolveRuntimeRoot(platformOpts, specBase) })
         if (foreignMap.size > 0) {
           const dirty = (gitQuiet(cwd, ['diff', '--name-only', 'HEAD']) || '')
             .split('\n').filter(Boolean).map(f => f.replace(/\\/g, '/'))

package/src/run/multi-repo-context.js

@@ -22,6 +22,8 @@
  * 不涉及生命周期契约（design §7.5）：纯内存对象，不跨进程、不持久化、不入库。
  */
 
+import { existsSync, readFileSync } from 'fs';
+import { join } from 'path';
 import { git, gitQuiet } from '../git-helper.js';
 
 /**
@@ -133,7 +135,9 @@ export class MultiRepoContext {
   }
 
   /**
-   * 跨仓 RepoEntry：isMain=false，gitDir=projectRoot=worktreePath=跨仓仓根。
+   * 跨仓 RepoEntry：有 worktree meta（worktree-cross.js 创建）→ gitDir=worktreePath=worktree，
+   * base 锚 meta.baseHash（与主仓同构，坑 cross-repo-no-worktree-isolation）；无 meta（legacy
+   * 直写主干模式）→ gitDir=projectRoot=worktreePath=跨仓仓根，base 靠 taskBaseCommit 锡点。
    * 构造时 `git -C <crossRepo> rev-parse HEAD` 必须 succeed（约束② fail-closed），
    * 路径不存在/非 git 仓 → throw 阻断 execute。
    * @param {string} repoKey
@@ -148,14 +152,26 @@ export class MultiRepoContext {
         `请补全路径（约束② fail-closed）。`
       );
     }
+    // worktree 模式检测：meta 在 = worktree-cross.js 已建隔离（路径公式与其 crossWorktreePath
+    // 保持同步；execute 启动时创建，晚于本构造的调用会命中）。
+    const specBase = (this.platformOpts && this.platformOpts.specRoot) || join(this.cwd, '.sillyspec');
+    let crossMeta = null;
+    try {
+      // 同步读（构造函数是同步的，不 import worktree-cross 避免 shared↔multi-repo-context 循环）
+      const metaPath = join(specBase, '.runtime', 'worktrees', `${this.changeName}--${repoKey}`, 'meta.json');
+      if (existsSync(metaPath)) crossMeta = JSON.parse(readFileSync(metaPath, 'utf8'));
+    } catch { crossMeta = null }
+    const inWorktree = !!(crossMeta && crossMeta.isCross && crossMeta.worktreePath && existsSync(crossMeta.worktreePath));
+    const workRoot = inWorktree ? crossMeta.worktreePath : crossRepoPath;
+
     // 约束②：跨仓 git 必须可达。失败 = 路径不存在 / 非 git 仓 / git 异常，一律阻断。
     // 不沿用主仓 verifyReviewGitEvidence unavailable 降级（design §9 兼容策略表）。
     let headVerify;
     try {
-      headVerify = git(crossRepoPath, ['rev-parse', 'HEAD']);
+      headVerify = git(workRoot, ['rev-parse', 'HEAD']);
     } catch (e) {
       throw new Error(
-        `MultiRepoContext: 跨仓 repo "${repoKey}" git 不可达（路径：${crossRepoPath}）。` +
+        `MultiRepoContext: 跨仓 repo "${repoKey}" git 不可达（路径：${workRoot}${inWorktree ? `（worktree，跨仓根 ${crossRepoPath}）` : ''}）。` +
         `rev-parse HEAD 失败：${e.message}。` +
         `请检查 local.yaml repos: 段路径是否正确、目录是否存在且为 git 仓（约束② fail-closed，配置错误不降级）。`
       );
@@ -164,17 +180,39 @@ export class MultiRepoContext {
       // git() 返回空串属异常态（无 commit 的空仓 rev-parse HEAD 会非零退出，已被 catch 兜底），
       // 此处仅作防御性双保险，触发同样走 fail-closed。
       throw new Error(
-        `MultiRepoContext: 跨仓 repo "${repoKey}"（${crossRepoPath}）rev-parse HEAD 返回空——` +
+        `MultiRepoContext: 跨仓 repo "${repoKey}"（${workRoot}）rev-parse HEAD 返回空——` +
         `疑似空 git 仓（无 commit）。跨仓 task 需仓库已有至少一个 commit（约束② fail-closed）。`
       );
     }
 
+    if (inWorktree) {
+      // worktree 模式：子代理在跨仓 worktree 分支上改+commit，apply 阶段由 CLI patch 回跨仓
+      // 主工作区。base 锚 meta.baseHash（创建时快照），head 实时取 worktree HEAD（子代理
+      // commit 推进后反映最新）；baseCommitHint 供派发侧优先取（HEAD 会推进，不能当 base）。
+      return {
+        repoKey,
+        gitDir: workRoot,
+        worktreePath: workRoot,
+        projectRoot: crossRepoPath,
+        isMain: false,
+        isWorktree: true,
+        baseCommitHint: crossMeta.baseHash || null,
+        resolveHead: () => git(workRoot, ['rev-parse', 'HEAD']),
+        resolveBase: (taskBaseCommit) => crossMeta.baseHash || taskBaseCommit || (() => {
+          throw new Error(
+            `MultiRepoContext: 跨仓 repo "${repoKey}"（worktree 模式）meta.baseHash 缺失且未传 taskBaseCommit。`
+          );
+        })(),
+      };
+    }
+
     return {
       repoKey,
       gitDir: crossRepoPath,
       worktreePath: crossRepoPath,
       projectRoot: crossRepoPath,
       isMain: false,
+      isWorktree: false,
       // 约束①：跨仓 HEAD 实时取，不缓存（task 推进后过期，每次 resolveHead 反映最新 HEAD）。
       resolveHead: () => git(crossRepoPath, ['rev-parse', 'HEAD']),
       // 约束①：跨仓 base = task 卡 base_commit 锡点（必传）。跨仓仓无 meta.json，

package/src/run/next.js

@@ -41,9 +41,10 @@ function countTasks(tasksPath) {
 /**
  * 单个活跃变更的产物推断：返回 { state, next, evidence }
  */
-function inferChange(changeDir, name) {
+function inferChange(changeDir, name, specBase) {
   const has = (f) => existsSync(join(changeDir, f))
-  const ev = (f) => join('.sillyspec', 'changes', name, f)
+  // evidence 用真实 spec 根（平台模式=specRoot 绝对路径，此前硬编码 .sillyspec/ 前缀误导）
+  const ev = (f) => join(specBase, 'changes', name, f)
   const t = countTasks(join(changeDir, 'tasks.md'))
 
   if (!has('proposal.md') && !has('design.md') && !has('tasks.md') && !has('plan.md')) {
@@ -98,7 +99,7 @@ export function detectNextStep({ cwd, specDir = null }) {
   } catch { /* 无 changes/ 目录 */ }
   if (active.length > 0) {
     // 多活跃时逐个推断全报告，next 取第一个（字典序最前）的；调用方输出含全部状态行
-    const inferences = active.map(name => inferChange(join(changesRoot, name), name))
+    const inferences = active.map(name => inferChange(join(changesRoot, name), name, specBase))
     const progress = active.map((name, i) => {
       const t = countTasks(join(changesRoot, name, 'tasks.md'))
       return { name, checked: t.checked, total: t.total, state: inferences[i].state }

package/src/run/prompt.js

@@ -19,7 +19,8 @@
  *   - loadModuleContextIndex/buildModuleContextInjection 内 require('fs'/'path') 改顶部静态 import
  */
 import { basename, join } from 'node:path'
-import { existsSync, readFileSync, mkdirSync, writeFileSync } from 'node:fs'
+import { existsSync, readFileSync, mkdirSync } from 'node:fs'
+import { writeAtomicSync } from '../fs-atomic.js'
 import { stageRegistry } from '../stages/index.js'
 import { resolvePromptIncludes, resolveRuntimeRoot, safeGit, WAIT_MARKER_RE, QUICK_SID_RE } from './shared.js'
 import { renderStageContract } from '../stage-contract-spec.js'
@@ -131,10 +132,53 @@ export function resolvePromptSpecBase(platformOpts, cwd) {
   return platformOpts?.specRoot || platformOpts?.specDriftAnchor || join(cwd, '.sillyspec')
 }
 
+/**
+ * 收集某阶段全部步骤已记录的用户等待回答（跨会话恢复回放数据源）。
+ *
+ * 背景（坑 stage-wait-history-not-replayed）：waitAnswers 从 --continue / --done --answer 起就
+ * 持久化在进度库（steps.wait_answers），但 outputStep 此前只在 --continue 即时路径注入
+ * 「📩 上一步用户回答」（prevStepAnswer）——新会话 `run <stage>` 续跑时历史回答不回放，
+ * agent 只能重问已答过的问题、用户描述随旧会话丢失。此助手把整阶段（含当前步骤多轮）
+ * 的回答按步骤聚合，供 outputStep 恢复渲染；与 complete.js 的 formatWaitHistory（单步、
+ * 带追问指引）分工：本助手面向跨会话恢复语境，只做数据聚合不含指引。
+ *
+ * @param {object|null} progress - ProgressManager.read() 的进度对象
+ * @param {string} stageName - 阶段名
+ * @returns {Array<{stepName: string, rounds: Array<{round: number, answer: string, question: string|null, answeredAt: string|null}>}>|null}
+ *          无进度/无任何回答记录时返回 null（调用方零输出）
+ */
+export function collectStageWaitHistory(progress, stageName) {
+  const steps = progress?.stages?.[stageName]?.steps
+  if (!Array.isArray(steps)) return null
+  const entries = []
+  for (const step of steps) {
+    if (!step || typeof step.name !== 'string') continue
+    const rounds = []
+    if (Array.isArray(step.waitAnswers)) {
+      for (const item of step.waitAnswers) {
+        if (item && typeof item.answer === 'string' && item.answer.trim() !== '') {
+          rounds.push({
+            round: typeof item.round === 'number' ? item.round : rounds.length + 1,
+            answer: item.answer,
+            question: typeof item.question === 'string' && item.question.trim() !== '' ? item.question : null,
+            answeredAt: typeof item.answeredAt === 'string' ? item.answeredAt : null,
+          })
+        }
+      }
+    }
+    // 旧进度/部分路径只写单值列 wait_answer（--done --answer 坑1 路径）：并入为第 1 轮，避免丢
+    if (rounds.length === 0 && typeof step.waitAnswer === 'string' && step.waitAnswer.trim() !== '') {
+      rounds.push({ round: 1, answer: step.waitAnswer, question: null, answeredAt: null })
+    }
+    if (rounds.length > 0) entries.push({ stepName: step.name, rounds })
+  }
+  return entries.length > 0 ? entries : null
+}
+
 /**
  * 输出当前步骤的 prompt
  */
-export async function outputStep(stageName, stepIndex, steps, cwd, changeName, dbProjectName, platformOpts = {}, prevStepAnswer = null) {
+export async function outputStep(stageName, stepIndex, steps, cwd, changeName, dbProjectName, platformOpts = {}, prevStepAnswer = null, waitHistory = null) {
   const step = steps[stepIndex]
   const total = steps.length
   // ── 越界防御 ──
@@ -456,7 +500,7 @@ export async function outputStep(stageName, stepIndex, steps, cwd, changeName, d
       // 注入结果同步落 runtime JSON（与既有 KNOWLEDGE_HIT_REPORT 落盘口径一致）
       const decRuntimeDir = join(decSpecBase, '.runtime')
       mkdirSync(decRuntimeDir, { recursive: true })
-      writeFileSync(join(decRuntimeDir, 'decision-hits.json'), JSON.stringify({ matched: decResult.matched, decisionHits: decResult.decisionHits || [] }, null, 2) + '\n')
+      writeAtomicSync(join(decRuntimeDir, 'decision-hits.json'), JSON.stringify({ matched: decResult.matched, decisionHits: decResult.decisionHits || [] }, null, 2) + '\n')
     } catch (e) {
       promptText = promptText.replace(/\{DECISION_HITS\}/g, `[decisions] 决策命中检测异常（${e.message}），跳过`)
     }
@@ -488,7 +532,7 @@ export async function outputStep(stageName, stepIndex, steps, cwd, changeName, d
       // 写入 runtime JSON
       const runtimeDir = join(effectiveSpecBase, '.runtime')
       mkdirSync(runtimeDir, { recursive: true })
-      writeFileSync(join(runtimeDir, 'knowledge-hit-report.json'), JSON.stringify(knowledgeResult.json, null, 2) + '\n')
+      writeAtomicSync(join(runtimeDir, 'knowledge-hit-report.json'), JSON.stringify(knowledgeResult.json, null, 2) + '\n')
     } catch (e) {
       promptText = promptText.replace(/\{KNOWLEDGE_HIT_REPORT\}/g, 'Status: no matches (error: ' + e.message + ')')
     }
@@ -567,7 +611,7 @@ export async function outputStep(stageName, stepIndex, steps, cwd, changeName, d
       // 目录由下游 review 写入 / 其他写入点补齐）。
       try {
         mkdirSync(join(runtimeRoot, 'execute-runs', runId, 'tasks'), { recursive: true })
-        writeFileSync(runIdFile, runId + '\n')
+        writeAtomicSync(runIdFile, runId + '\n')
       } catch (e) {
         console.error(`[sillyspec] execute run marker/目录写入失败（降级继续，ID ${runId} 仍注入 prompt）: ${e.message}`)
       }
@@ -609,7 +653,7 @@ export async function outputStep(stageName, stepIndex, steps, cwd, changeName, d
         reviewRunId = generateStageReviewRunId()
         try {
           mkdirSync(tierRuntimeRoot, { recursive: true })
-          writeFileSync(reviewRunIdMarker, reviewRunId + '\n')
+          writeAtomicSync(reviewRunIdMarker, reviewRunId + '\n')
           // plan-c: echo 完整 review 目录路径，避免 agent 拿裸 runId 给子代理时漏连字符拼错路径
           const reviewDir = `${tierRuntimeRoot}/stage-reviews/${stageName}-${reviewRunId}`
           console.log(`  📁 Stage Review 写入目录（直接复制给 review 子代理，勿手拼 runId）：${reviewDir}/`)
@@ -745,6 +789,22 @@ export async function outputStep(stageName, stepIndex, steps, cwd, changeName, d
     }
   }
 
+  // ── 跨会话恢复回放（坑 stage-wait-history-not-replayed）──
+  // 整阶段历史等待回答：数据由调用方从进度库 collectStageWaitHistory 聚合传入。与下方
+  // 「📩 上一步用户回答」分工：本块是恢复语境（跨步骤、含多轮），那块是刚收到的最新回答
+  // （更贴近 prompt 末尾）。同一轮内容可能短暂重复出现，属预期——两块框架语义不同。
+  if (waitHistory && waitHistory.length > 0) {
+    console.log(`\n### 📜 本阶段历史用户回答（进度库回放，跨会话恢复用）`)
+    console.log(`以下问答已由用户确认并记录在进度库，续跑时据此恢复上下文——已回答过的问题不要重复追问：`)
+    for (const entry of waitHistory) {
+      console.log(`\n**「${entry.stepName}」**（${entry.rounds.length} 轮）`)
+      for (const r of entry.rounds) {
+        if (r.question) console.log(`   问：${r.question}`)
+        console.log(`   第${r.round}轮答：${r.answer}`)
+      }
+    }
+  }
+
   if (prevStepAnswer) {
     console.log(`\n### 📩 上一步用户回答`)
     console.log(prevStepAnswer)

package/src/run/scan-profile.js

@@ -224,6 +224,7 @@ export async function executeScanPostcheck(cwd, platformOpts, scanProfile) {
   const result = runScanPostCheck({
     cwd,
     specDir,
+    scanProfile: scanProfile || null,
     scanMeta: {
       projectListParsed: true,
       manifestWritten: undefined,

package/src/run/shared.js

@@ -139,7 +139,7 @@ export function resolveSpecDir(cwd, opts = {}) {
 // 只缓存"git root 已找到"的结果——非 git 仓库不缓存，防测试流程中途 git init 后读到陈旧 null。
 const _ancestorCeilingCache = new Map()
 
-function resolveAncestorCeiling(resolved) {
+export function resolveAncestorCeiling(resolved) {
   if (_ancestorCeilingCache.has(resolved)) return _ancestorCeilingCache.get(resolved)
   // 一次 spawn 拿两值（rev-parse 按参数序输出，每值一行）
   const out = safeGit(resolved, ['rev-parse', '--show-toplevel', '--git-common-dir']).value
@@ -515,7 +515,9 @@ export function isSelfReferentialSpecRoot(cwd, specRoot) {
  *
  * 语义：(specRoot || runtimeRoot) 存在且非自指 → 平台模式；自指回环（repo-native
  * junction）按本地模式处理。本模块内平台模式门禁统一经本函数，裸表达式仅此一处
- * （grep 验证：triggerSync/triggerPull/triggerPullActiveChange/checkApproval 四处收敛）。
+ * （grep 验证：triggerPull/triggerPullActiveChange/checkApproval 三处收敛；triggerSync
+ * 已放行——平台模式上行回传经 env 凭据通道（sync.js _getPlatform），下行 pull 与审批
+ * 检查仍跳过，daemon 是权威数据面）。
  * runtimeRoot 落在 specRoot 内，自指判定以 specRoot 为准即可覆盖；runtimeRoot-only
  * 组合无 specRoot 可判，不触发自指豁免（保持平台模式）。
  *
@@ -549,7 +551,7 @@ export function resolveChangeDir(cwd, progress, specDir = null) {
 }
 
 /**
- * 触发 sync（平台模式走自己的链路，跳过；否则 await import sync.js）。
+ * 触发 sync（本地/平台模式都执行：平台模式凭据经 env 通道，见函数头注释）。
  */
 // sync 总超时熔断：sync.js 是 best-effort 后台回传（每请求已有 10s 超时），但 sync() 可能串行多次
 // fetchJson 累积等待、阻塞 --done。给 8s 总超时，超时放弃（best-effort，失败不影响正确性，下次 --done 重试）。
@@ -583,13 +585,17 @@ async function raceWithAbort(op, timeoutMs = SYNC_TOTAL_TIMEOUT_MS) {
 export const QUICK_SID_RE = /^quick-[0-9a-f]{8}$/
 
 export async function triggerSync(cwd, changeName, platformOpts = {}, opts = {}) {
-  // 平台模式（SillyHub）走自己的回传链路，不走 CLI 内置 sync；自指回环（repo-native junction）按本地模式处理
-  if (isPlatformMode(platformOpts, cwd)) return
+  // 平台模式不再整体跳过（2026-08-26 用户决策）：上行回传（进度 + 四件套 + spec 树）
+  // 在平台模式同样执行，凭据经 env SILLYHUB_PLATFORM_URL/TOKEN（daemon 注入通道，
+  // sync.js _getPlatform，链路 D 同款）；未注入 env 且 local.yaml 无 platform 段时
+  // sync() 内部静默跳过（合法状态）。下行 pull / 审批检查仍走平台自有链路（见各自门禁）。
   try {
     // ql-20260818-011：quick 会话按设计无实体变更目录（progress.js initChange 同款
     // 跳过建目录），progress/四件套上行对它是孤儿数据；但 spec 树增量（QUICKLOG/
     // 模块文档的上行通道）以服务器清单为锚，与变更目录无关——降级只推 spec 树。
-    if (changeName && QUICK_SID_RE.test(changeName) && !existsSync(join(cwd, '.sillyspec', 'changes', changeName))) {
+    // 存在性检查按平台 specRoot（A4 同族）：平台模式下实体目录在 specRoot/changes。
+    const tsSpecBase = platformOpts?.specRoot || join(cwd, '.sillyspec')
+    if (changeName && QUICK_SID_RE.test(changeName) && !existsSync(join(tsSpecBase, 'changes', changeName))) {
       // shared.js 在 src/run/，sync.js 在 src/ → 退一层
       const syncMod = await import('../sync.js')
       await raceWithAbort((sig) => syncMod.syncSpecTreeOnly(changeName, cwd, sig), opts.timeoutMs)