sillyspec 3.26.9 → 3.26.11

package/src/run/complete-handlers.js

@@ -26,7 +26,7 @@ import { basename, join, resolve, relative, isAbsolute } from 'node:path'
 import { existsSync, readdirSync, readFileSync, writeFileSync, mkdirSync, unlinkSync, rmSync } from 'node:fs'
 import { renameSyncRetry, writeAtomicSync } from '../fs-atomic.js'
 import { resolveChangeDir, resolveQuickSessionsDir, safeGit, auditQuickCompletion, triggerSync, isQuickMetadata, resolveRuntimeRoot } from './shared.js'
-import { detectConcurrentChanges, formatConcurrentWarning } from './concurrent-detect.js'
+import { detectConcurrentChanges, formatConcurrentWarning, resolveConcurrentAnchor } from './concurrent-detect.js'
 import { stageRegistry } from '../stages/index.js'
 import { SCAN_STATUS, POINTER_STATUS } from '../constants.js'
 import { printQuickAuditReview } from './quick-audit.js'
@@ -719,7 +719,9 @@ export async function handleWorkflowPostCheck({ stageName, steps, currentIdx, cw
           const icon = impactResult.status === 'pass' ? '✅' : '❌'
           console.log(`${icon} module-impact.md 检查${impactResult.status === 'pass' ? '通过' : '失败'}`)
           for (const f of (result.failures || []).filter(f => f.role_id === 'impact-analyzer')) {
-            console.log(`   └─ ${f}`)
+            // f 是 {level,role_id,output,check,message} 对象——直接 ${f} 打印裸 [object Object]（ql-20260819-006）；
+            // message 才是人类可读 detail（如「缺少章节: …」），缺字段时 stringify 兜底防再退化成不可诊断输出
+            console.log(`   └─ ${f.message ?? JSON.stringify(f)}`)
           }
         }
         const saved = saveWorkflowRun(result, {
@@ -812,10 +814,15 @@ export async function handleQuickStageCompletion({ stageName, steps, currentIdx,
     // D-003），用 ?. + ?? [] 兜底防 spread undefined 抛 TypeError（B-005）。整钩子 try/catch 隔离
     // ——detect 本就 fail-open，保守再包一层，任何异常只吞不 bubble，主完成流程不受影响。
     try {
-      const ownFiles = [
-        ...(review?.changedFiles ?? []),
-        ...(mergedGuard?.baselineFiles ?? []),
-      ]
+      // ownFiles 锚点（2026-08-18 误归属修复）：声明会话 = baselineFiles ∪ allowedFiles（声明即归属），
+      // 不再用 changedFiles 全量——他者窗口文件已被污染进 changedFiles，旧口径自吞致预检对
+      // ql-20260818-003 形态结构性失明。未声明会话维持旧口径（changed ∪ baseline）：无声明无归属
+      // 信息，收窄锚点会把自身未声明改动全误报他者。resolveConcurrentAnchor 纯函数（concurrent-detect）。
+      const ownFiles = resolveConcurrentAnchor({
+        changedFiles: review?.changedFiles ?? [],
+        baselineFiles: mergedGuard?.baselineFiles ?? [],
+        allowedFiles: mergedGuard?.allowedFiles ?? [],
+      })
       const detected = detectConcurrentChanges(cwd, {
         changeName,
         linkedChanges: mergedGuard?.linkedChanges ?? [],
@@ -892,13 +899,37 @@ export async function handleQuickStageCompletion({ stageName, steps, currentIdx,
     try {
       // 回填实际改动文件：review.changedFiles 含 quick 自身元数据（quicklog/.runtime/modules 等），
       // 用 isQuickMetadata 过滤掉，只留真实业务文件。brownfield 无 review → 空数组，文件行不动。
-      const realFiles = Array.isArray(review?.changedFiles)
-        ? review.changedFiles.filter(f => !isQuickMetadata(f, linkedChanges))
-        : []
+      // 归属口径（2026-08-18 误归属修复）：声明会话优先 attributedFiles（窗口∩声明∪同文件并发命中），
+      // 他者窗口文件不进文件行；未声明会话/旧 review 无 attributedFiles → 兜底 changedFiles 全量。
+      const auditFiles = Array.isArray(review?.attributedFiles)
+        ? review.attributedFiles
+        : (Array.isArray(review?.changedFiles) ? review.changedFiles : [])
+      const realFiles = auditFiles.filter(f => !isQuickMetadata(f, linkedChanges))
+      // D-8 落盘（2026-08-18 修）：advisory 欠账信号从「纯打印」升级为「随条目落盘」——修复
+      // 「欠账已记录（QUICKLOG reasons）」的不实承诺（交叉审查实证 reasons 纯 stdout，事后不可审计）。
+      // 两周实测（2026-08-31 裁决，doc-consistency-debt §七）需要分母：信号触发次数必须可追溯。
+      const auditNotes = []
+      if (review?.docSyncHint && review.docSyncHint.touchedSource > 0 && review.docSyncHint.docFiles.length === 0) {
+        const mods = Array.isArray(review.docSyncHint.modules) && review.docSyncHint.modules.length > 0
+          ? `（涉及模块：${review.docSyncHint.modules.map((m) => m.id).join(' · ')}）` : ''
+        auditNotes.push(`📝 文档欠账（D-8）：${review.docSyncHint.touchedSource} 个源码文件改动未同步任何模块文档${mods}`)
+      }
+      if (review?.docsCheckHint && review.docsCheckHint.invalid > 0) {
+        auditNotes.push(`📎 文档引用失效：${review.docsCheckHint.invalid}/${review.docsCheckHint.total} 处 file:line 失效（sillyspec docs check 可复现）`)
+      }
+      // 归属切分注（2026-08-18 误归属修复）：窗口内未声明脏文件不进「文件：」行，但必须落盘可追溯
+      // （多 agent 并发仓他者窗口改动 / 本会话漏声明均可能），防真实改动被静默挤走。
+      if (Array.isArray(review?.undeclaredFiles) && review.undeclaredFiles.length > 0) {
+        const undeclared = review.undeclaredFiles.filter(f => !isQuickMetadata(f, linkedChanges))
+        if (undeclared.length > 0) {
+          auditNotes.push(`⚖️ 归属切分：${undeclared.length} 个窗口内未声明脏文件未计入文件行（并行会话改动或本会话漏声明）：${undeclared.join(', ')}`)
+        }
+      }
       await completeQuicklogEntry(specBase, gitUser, qlId, {
         resultText: outputText || '',
         linkedChanges,
         changedFiles: realFiles,
+        auditNotes,
       })
       console.log(`📝 QUICKLOG 条目 ${qlId} 已标记完成`)
       // 刷新 DB title：从 step3「需求：」提取（agent 可改 title 的途径），覆盖启动时的兜底快照。
@@ -911,6 +942,21 @@ export async function handleQuickStageCompletion({ stageName, steps, currentIdx,
       console.warn(`⚠️ QUICKLOG 完成态写入失败: ${e.message}`)
     }
 
+    // 轻量归档任务已全勾选的关联真实变更
+    try {
+      const closeResult = await closeQuickLinkedChanges({ pm, cwd, specBase, linkedChanges, platformOpts })
+      if (closeResult.closed.length > 0) {
+        console.log(`📦 已自动归档 ${closeResult.closed.length} 个关联变更：${closeResult.closed.join(', ')}`)
+      }
+      if (closeResult.skipped.length > 0) {
+        for (const s of closeResult.skipped) {
+          console.log(`⏭️ 关联变更 ${s.name} 未归档：${s.reason}`)
+        }
+      }
+    } catch (e) {
+      console.warn(`⚠️ 关联变更轻量归档失败（不阻断 quick 完成）: ${e.message}`)
+    }
+
     // 清理 session 目录（rmSync/unlinkSync 容忍不存在）。路径与写入对齐（Q4 resolveQuickSessionsDir）。
     try {
       if (changeName) {
@@ -933,8 +979,151 @@ export async function handleQuickStageCompletion({ stageName, steps, currentIdx,
       }
     }
   }
+
   return null
 }
+
+/**
+ * 判定变更 tasks.md 是否全部勾选完成。
+ * 无 tasks.md 或有未勾选项均返回 false（保守策略）。
+ *
+ * @param {string} specBase - .sillyspec 根目录
+ * @param {string} changeName - 变更名
+ * @returns {boolean}
+ */
+function isChangeTasksComplete(specBase, changeName) {
+  const tasksPath = join(specBase, 'changes', changeName, 'tasks.md')
+  if (!existsSync(tasksPath)) return false
+  try {
+    const content = readFileSync(tasksPath, 'utf8').replace(/\r\n/g, '\n')
+    return !/^-\s*\[\s*\]\s+/m.test(content)
+  } catch {
+    return false
+  }
+}
+
+/**
+ * 对单个已完成的关联真实变更执行轻量归档（不校验 plan.md/module-impact.md）。
+ *
+ * @param {Object} opts
+ * @param {ProgressManager} opts.pm
+ * @param {string} opts.cwd
+ * @param {string} opts.specBase
+ * @param {string} opts.changeName
+ * @param {Object} [opts.platformOpts]
+ * @returns {Promise<{closed:boolean, destDir?:string, reason?:string}>}
+ */
+async function closeSingleQuickLinkedChange({ pm, cwd, specBase, changeName, platformOpts = {} }) {
+  const srcDir = join(specBase, 'changes', changeName)
+  if (!existsSync(srcDir)) {
+    return { closed: false, reason: '源目录不存在' }
+  }
+  const changesDir = join(specBase, 'changes')
+  const archiveDir = join(changesDir, 'archive')
+  const date = new Date().toISOString().slice(0, 10)
+  const destName = archiveDestDirName(date, changeName)
+  const destDir = join(archiveDir, destName)
+
+  // 幂等：目标目录已存在或已在 archive/ 中
+  if (existsSync(destDir) || findAlreadyArchivedDir(archiveDir, changeName)) {
+    return { closed: false, reason: `目标目录已存在（${destName}）` }
+  }
+
+  mkdirSync(archiveDir, { recursive: true })
+  try {
+    renameSyncRetry(srcDir, destDir)
+  } catch (e) {
+    return { closed: false, reason: `移动目录失败：${e.message}` }
+  }
+
+  pm.unregisterChange(cwd, changeName)
+  await archiveWorktreeCleanup(cwd, changeName, specBase, platformOpts)
+  safeGit(cwd, ['add', '--', `.sillyspec/changes/archive/${destName}/`])
+
+  console.log(`📦 关联变更已自动归档：${changeName} → archive/${destName}/`)
+  return { closed: true, destDir }
+}
+
+/**
+ * quick 轻量归档的阶段闸允许集：仅「从未进入完整流程」的变更可被 quick --done 自动归档
+ * （d192f89 原始场景：评估 small 转 quick、停在 brainstorm 的僵尸变更）。execute 完成后
+ * tasks.md 必然全勾选而流程未收尾——不看 current_stage 会把 verify/中途的完整流程变更
+ * 绕过 verify/archive 校验直接归档注销（quick-close-midflight 缺陷）。
+ *
+ * 阶段名允许集之外还有「阶段完成态」闸（ql-20260819-010，quick-done-autoarchive-misfire
+ * 缺陷①）：current_stage=brainstorm 但该阶段 status=completed（brainstorm 收尾到 plan
+ * 开始之间的空窗）≠ 僵尸变更——此时关联 quick --done 会把即将进 plan 的进行中变更误
+ * 轻量归档。stage_status=completed 一律走原流程收尾。
+ */
+const QUICK_CLOSE_ALLOWED_STAGES = new Set(['', 'scan', 'brainstorm'])
+
+/**
+ * quick --done 完成后，自动关闭任务已全部完成的关联真实变更。
+ * quick-<hex> sessionId 自身不在此处理（由调用方单独注销）。
+ * 单个归档失败 catch warn，不阻断 quick 完成。
+ *
+ * 阶段闸（fail-closed）：先查 changes.current_stage——无 DB 记录（未注册目录桩）或停在
+ * scan/brainstorm 才继续 tasks 判定；plan/execute/verify/archive 一律 skip 走原流程收尾。
+ * pm 缺 getChangeStage 接口或查询抛错同样 skip，不静默放行。
+ *
+ * @param {Object} opts
+ * @param {ProgressManager} opts.pm
+ * @param {string} opts.cwd
+ * @param {string} opts.specBase
+ * @param {string[]} [opts.linkedChanges]
+ * @param {Object} [opts.platformOpts]
+ * @returns {Promise<{closed:string[], skipped:{name:string,reason:string}[]}>}
+ */
+export async function closeQuickLinkedChanges({ pm, cwd, specBase, linkedChanges = [], platformOpts = {} }) {
+  const closed = []
+  const skipped = []
+  // 只处理真实变更，跳过 quick 会话 sessionId
+  const realChanges = linkedChanges.filter((name) => !/^quick-[0-9a-f]{8}$/.test(name))
+  for (const changeName of realChanges) {
+    try {
+      if (typeof pm.getChangeStage !== 'function') {
+        skipped.push({ name: changeName, reason: '进度库接口缺失（getChangeStage），无法判定流程阶段，不自动归档' })
+        continue
+      }
+      const stageInfo = pm.getChangeStage(cwd, changeName)
+      if (stageInfo !== null && !QUICK_CLOSE_ALLOWED_STAGES.has(stageInfo.current_stage || '')) {
+        skipped.push({
+          name: changeName,
+          reason: `变更处于完整流程「${stageInfo.current_stage}」阶段（tasks.md 全勾不等于流程收尾），不自动归档——请走原流程收尾（sillyspec progress show 查看进度）`,
+        })
+        continue
+      }
+      // ql-20260819-010（quick-done-autoarchive-misfire 缺陷①）：当前阶段已完成 ≠
+      // 从未进入完整流程的僵尸。brainstorm 收尾到 plan 开始之间的空窗里 current_stage
+      // 仍读 brainstorm，只看阶段名会把即将进 plan 的变更误轻量归档（propose 骨架
+      // tasks.md 除 quick 追加的 ql 行外没有任务行，「无未勾选框=全勾」恒真）。
+      // stage_status=completed 一律原流程收尾；null（无阶段行/brownfield）与旧调用方
+      // mock 缺字段（undefined）均按未完成放行，僵尸逃生通道行为不变。
+      if (stageInfo !== null && stageInfo.stage_status === 'completed') {
+        skipped.push({
+          name: changeName,
+          reason: `变更当前阶段「${stageInfo.current_stage || '(空)'}」已完成（推进/收尾中，非僵尸变更），不自动归档——请走原流程收尾（sillyspec progress show 查看进度）`,
+        })
+        continue
+      }
+      if (!isChangeTasksComplete(specBase, changeName)) {
+        skipped.push({ name: changeName, reason: 'tasks.md 未全勾选或不存在' })
+        continue
+      }
+      const result = await closeSingleQuickLinkedChange({ pm, cwd, specBase, changeName, platformOpts })
+      if (result.closed) {
+        closed.push(changeName)
+      } else {
+        skipped.push({ name: changeName, reason: result.reason || '未知原因' })
+      }
+    } catch (e) {
+      console.warn(`⚠️ 关联变更 ${changeName} 轻量归档失败（不阻断 quick 完成）: ${e.message}`)
+      skipped.push({ name: changeName, reason: e.message })
+    }
+  }
+  return { closed, skipped }
+}
+
 /**
  * execute「Wave N 执行」步骤完成后扫 worktree 提取 provider endpoint artifact（W6 Step6c 从
  * completeStep 内联块抽出）。供 verify 阶段 parity 对账 + consumer task 上游契约注入。

package/src/run/complete.js

@@ -29,11 +29,25 @@ import { handleArchiveConfirmStep, handlePlanGeneratePlanStep, handleScanProject
 import { formatExecuteSummary } from '../worktree-apply.js'
 import { isEndToEndTaskText } from '../change-risk-profile.js'
 import { deriveTitleFromLinkedChange } from '../quicklog.js'
+import { gitQuiet } from '../git-helper.js'
 
 // validateMetadata / readDesignScale / validateFileLocations 已迁至 ./gates.js（completeStageGates
 // 共享收尾管线，消除 noAI 末步 / continueStep 完成分支绕过 gate 的 S1/S2/S3 不对称）。
 // completeStep 阶段完成分支（task-02 接入 completeStageGates）+ brainstorm 下一步提示改 import 自 gates.js。
 
+// 完整流程 change title 刷新：从 proposal/design 首个 # 标题提取中文描述写 changes.title（人类可读
+// 展示元信息）。proposal/design 落盘后的**任意步骤持久化点**都调用——单步 --done（brainstorm
+// step6 design.md 已落盘但阶段未完）与阶段完成同样刷新，治「brainstorm 全程 title 存英文 autoName
+// 兜底」。quick-<hex> 无 proposal/design 目录，deriveTitleFromLinkedChange 返回 '' 不刷新
+// （quick 走 handleQuickStageCompletion 的 extractTitleFromResult）。失败静默（不阻断流程）。
+function refreshChangeTitleFromArtifacts(pm, cwd, specBase, changeName) {
+  if (!changeName || /^quick-[0-9a-f]{8}$/.test(changeName)) return
+  try {
+    const refinedTitle = deriveTitleFromLinkedChange(specBase, changeName)
+    if (refinedTitle) pm.updateChangeMeta(cwd, changeName, { title: refinedTitle })
+  } catch { /* title 刷新失败不阻断 */ }
+}
+
 /**
  * 坑1：用 --done --answer 解掉「已 waiting 的步骤」。
  *
@@ -114,8 +128,28 @@ export async function completeStep(pm, progress, stageName, cwd, outputText, inp
     console.log(`⚠️  Step "${steps[_resolvedWaitIdx].name}" 此前处于 waiting，--done --answer 已补回答并拉回待完成。`)
   }
   if (currentIdx === -1) {
-    console.error(`没有待完成的步骤（阶段 ${stageName} 已无 pending/in-progress 步骤）。当前阶段状态：${stageData?.status ?? '未知'}。用 \`sillyspec run ${stageName} --status\` 查看进度，或 \`sillyspec progress show\` 看全局下一步。`)
-    process.exit(1)
+    // ── reopen stale 收尾路径（坑 reopen-done-escape-hatch-unreachable）──
+    // 全 completed+stale（无 pending/in-progress）时若只有 exit(1)，--done --confirm 逃生门
+    // 永远到不了下方回填门控。修复：有 stale 时——无 confirm 报拦截指引（与门控同文案）；
+    // 带 confirm 把首个 stale 拉回 pending 走完整完成管线，末步后的回填门控 confirm 分支
+    // 收尾其余 stale（--confirm 语义 = 全部 stale 一并确认）。
+    const _staleIdx = steps.findIndex(s => s.status === 'stale')
+    if (_staleIdx !== -1) {
+      const _staleNames = steps.filter(s => s.status === 'stale').map(s => s.name)
+      if (!confirm) {
+        console.error(`\n⏸️  检测到 ${_staleNames.length} 个 stale 步骤（reopen 后未执行）：${_staleNames.join('、')}`)
+        console.error(`   两条出路：`)
+        console.error(`   ① sillyspec run ${stageName}${changeName ? ` --change ${changeName}` : ''} 逐个真实执行（stale 会被转为 pending）`)
+        console.error(`   ② 确认方案未变，一次性回填收尾：sillyspec run ${stageName} --done --confirm${changeName ? ` --change ${changeName}` : ''} --output "..."`)
+        process.exit(1)
+      }
+      steps[_staleIdx].status = 'pending'
+      currentIdx = _staleIdx
+      console.log(`⚠️  --confirm 收尾：把 stale 步骤 "${steps[_staleIdx].name}" 拉回当前步骤走完成管线，其余 stale 由回填门控一并确认。`)
+    } else {
+      console.error(`没有待完成的步骤（阶段 ${stageName} 已无 pending/in-progress 步骤）。当前阶段状态：${stageData?.status ?? '未知'}。用 \`sillyspec run ${stageName} --status\` 查看进度，或 \`sillyspec progress show\` 看全局下一步。`)
+      process.exit(1)
+    }
   }
 
   // ── requiresWait 硬门控 ──
@@ -285,15 +319,40 @@ export async function completeStep(pm, progress, stageName, cwd, outputText, inp
     // completed，否则进度数字与实际步骤明细矛盾（阶段已完成 + 6/8）。
     // 安全边界：仅进入阶段完成分支时才回填（stale 本就被跳过、不回填也照常标 completed），
     // 不改变单步推进行为；stale 若确需重跑，运行流（stage.js:141-148）会先于本分支转 pending 执行。
+    // FR-01 门控：无 --confirm 时不回填，阻断并给两条出路；带 --confirm 时回填并审计。
     const staleSteps = steps.filter(s => s.status === 'stale')
     if (staleSteps.length > 0) {
+      if (!confirm) {
+        // 无 confirm：不回填，阶段不完成，返回 staleBlocked 标记
+        const staleNames = staleSteps.map(s => `Step ${steps.indexOf(s) + 1}(${s.name})`).join(', ')
+        console.error(`⏸️  检测到 ${staleSteps.length} 个 stale 步骤（reopen 后未执行）——两条出路：`)
+        console.error(`   ① sillyspec run ${stageName} 逐个真实执行（首个 stale 自动转 pending）`)
+        console.error(`   ② 确认方案未变用 --done --confirm 一次性回填收尾`)
+        console.error(`   stale 步骤：${staleNames}`)
+        progress.lastActive = new Date().toLocaleString('zh-CN',{hour12:false})
+        pm._write(cwd, progress, changeName)
+        return { stageCompleted: false, currentIdx, nextPendingIdx: -1, staleBlocked: true }
+      }
+      // 带 confirm：按现行回填逻辑 + 审计记录
       const nowStr = new Date().toLocaleString('zh-CN',{hour12:false})
       for (const st of staleSteps) {
         st.status = 'completed'
         st.completedAt = st.completedAt || nowStr
       }
       pm._write(cwd, progress, changeName)
-      console.log(`  ⚠️ 同步回填 ${staleSteps.length} 个 stale 步骤为 completed（reopen --from-step N 后 --done，方案未变）`)
+      console.log(`  ⚠️ 同步回填 ${staleSteps.length} 个 stale 步骤为 completed（reopen --from-step N 后 --done --confirm，方案未变）`)
+      // 审计记录 reopen-stale-backfill
+      try {
+        pm._appendAuditLog(cwd, {
+          action: 'reopen-stale-backfill',
+          stage: stageName,
+          change: changeName,
+          steps: staleSteps.map(s => s.name),
+          confirmedAt: nowStr
+        })
+      } catch (e) {
+        console.warn('⚠️ 回填审计日志写入失败（不阻断）:', e.message)
+      }
     }
 
     stageData.status = 'completed'
@@ -331,15 +390,8 @@ export async function completeStep(pm, progress, stageName, cwd, outputText, inp
     if (_stageGatesResult?.stageCompleted === false) process.exitCode = 1
     if (_stageGatesResult) return _stageGatesResult
 
-    // 完整流程 change title 刷新：proposal/design 落盘后（brainstorm/plan 完成），从 proposal 首个 #
-    // 标题刷新 changes.title（人类可读中文标题，用户可随时刷新）。quick-<hex> 无 proposal 目录 →
-    // deriveTitleFromLinkedChange 返回 '' 不刷新（quick 走 handleQuickStageCompletion 的 extractTitleFromResult）。
-    if (changeName && !/^quick-[0-9a-f]{8}$/.test(changeName)) {
-      try {
-        const refinedTitle = deriveTitleFromLinkedChange(specBase, changeName)
-        if (refinedTitle) pm.updateChangeMeta(cwd, changeName, { title: refinedTitle })
-      } catch { /* title 刷新失败不阻断完成 */ }
-    }
+    // 完整流程 change title 刷新（阶段完成时；proposal/design 已落盘，机制见 refreshChangeTitleFromArtifacts）
+    refreshChangeTitleFromArtifacts(pm, cwd, specBase, changeName)
 
     // gate 全过：persist completed（task-01 移后）。此处到 _write 之间若崩，DB 仍 in-progress（内存已 completed 但未落盘），下次进 CLI 读 DB 即 in-progress，不产生"假 completed"。
     pm._write(cwd, progress, changeName)
@@ -404,6 +456,9 @@ export async function completeStep(pm, progress, stageName, cwd, outputText, inp
   progress.lastActive = new Date().toLocaleString('zh-CN',{hour12:false})
   pm._write(cwd, progress, changeName)
   triggerSync(cwd, changeName, platformOpts)
+  // 单步完成也刷新 change title：design.md 在 brainstorm step6 落盘，此后每次 --done 都该让
+  // changes.title 反映中文描述，不等阶段收尾（机制见 refreshChangeTitleFromArtifacts）。
+  refreshChangeTitleFromArtifacts(pm, cwd, specBase, changeName)
 
   // Append to user-inputs.md
   if (outputText) {
@@ -453,21 +508,90 @@ function readTaskCardText(changeDir, taskNum) {
   try { return readFileSync(join(changeDir, 'tasks', `task-${taskNum}.md`), 'utf8') } catch { return '' }
 }
 
+/**
+ * W2 task-04/05 共用 helper：构造草稿零 diff 校验用的 ctx（与 task-review.js generateTaskReviewDrafts 同源）。
+ * 用于 autoCheckPlanFromReviews（勾选层）和 detectExecuteBatchFinish（批量层）。
+ * 失败返回 null（调用方降级：勾选层不勾、批量层不过滤——向后兼容）。
+ *
+ * @returns {Promise<{gitDir:string, base:string, head:string}|null>}
+ */
+async function buildDraftContext(cwd, changeName) {
+  try {
+    const { WorktreeManager } = await import('../worktree.js')
+    const meta = new WorktreeManager({ cwd }).getMeta(changeName)
+    const base = meta?.baselineCommit || meta?.baseHash || null
+    let gitDir = cwd
+    let head = null
+    if (meta?.worktreePath && meta.mode !== 'in-place-fallback' && existsSync(meta.worktreePath)) {
+      gitDir = meta.worktreePath
+    }
+    if (base) {
+      try {
+        head = gitQuiet(gitDir, ['rev-parse', 'HEAD'])
+      } catch (e) {
+        console.warn(`⚠️ ctx 构造失败（git rev-parse HEAD 失败：${e && e.message ? e.message : e}），跳过草稿 diff 校验`)
+        return null
+      }
+    }
+    if (base && head && gitDir) {
+      return { gitDir, base, head }
+    }
+    return null
+  } catch (e) {
+    console.warn(`⚠️ ctx 构造失败（${e && e.message ? e.message : e}），跳过草稿 diff 校验`)
+    return null
+  }
+}
+
 /**
  * 判定 task 是否该被 autoCheckPlanFromReviews 自动勾选。
  * 端到端/deployment-critical task 要求 review spec+quality 双 pass（cannot_verify 不算，防批量完成
  * 放行未真验的端到端 task）；普通 task 非 fail 即可（保主 agent 直接实现模式体验，其 cannot_verify
  * 草稿仍可批量收尾）。坑 execute-batch-complete-endtoend-checkbox。
- * @param {{ok?:boolean, review?:{specVerdict?:string, qualityVerdict?:string}}} r readReview 结果
+ *
+ * W2 task-04 FR-03：草稿勾选层零 diff 守卫——review 为自动草稿且 ctx 给定时，额外要求
+ * changedFiles 非空且 git diff 实测非空。防 allowed_paths 误归属他人 diff 或陈旧 review.json 导致
+ * 空任务被自动勾选/批量放行。ctx 缺省时保持现行判定（向后兼容）。
+ *
+ * @param {{ok?:boolean, review?:{specVerdict?:string, qualityVerdict?:string, reviewerNotes?:string, changedFiles?:string[]}}} r readReview 结果
  * @param {boolean} endToEnd 是否端到端/deployment-critical task
+ * @param {{gitDir?:string, base?:string, head?:string}|null} [ctx] 实测 diff 上下文；缺省保持现行判定
  * @returns {boolean}
  */
-export function shouldAutoCheckTask(r, endToEnd) {
+export function shouldAutoCheckTask(r, endToEnd, ctx = null) {
   if (!r?.ok) return false
   const spec = r.review?.specVerdict
   const quality = r.review?.qualityVerdict
   if (spec === 'fail' || quality === 'fail') return false
   if (endToEnd) return spec === 'pass' && quality === 'pass'
+
+  // W2 task-04 草稿零 diff 守卫（FR-03）
+  // ctx 给定且 review 为自动草稿时，要求 changedFiles 非空且实测 diff 非空
+  if (ctx && r.review?.reviewerNotes && r.review.reviewerNotes.includes('auto-generated draft')) {
+    const changedFiles = r.review.changedFiles || []
+    if (changedFiles.length === 0) {
+      console.warn(`⚠️ 草稿 review changedFiles 为空，跳过自动勾选`)
+      return false
+    }
+    if (!ctx.gitDir || !ctx.base || !ctx.head) {
+      console.warn(`⚠️ ctx 信息不完整（gitDir=${ctx.gitDir}, base=${ctx.base}, head=${ctx.head}），跳过草稿 diff 校验，保守不勾`)
+      return false
+    }
+    try {
+      // 实测 diff：git diff --name-only <base>..<head> -- <changedFiles>
+      // 用数组参数避免 shell 拆词，复用 git-helper 安全模式
+      const diffResult = gitQuiet(ctx.gitDir, ['diff', '--name-only', `${ctx.base}..${ctx.head}`, '--', ...changedFiles], { trim: true })
+      if (!diffResult || diffResult.trim() === '') {
+        console.warn(`⚠️ 草稿 review 实测 diff 为空（base=${ctx.base.slice(0,8)}, head=${ctx.head.slice(0,8)}, files=${changedFiles.length}），跳过自动勾选`)
+        return false
+      }
+      console.log(`   ✓ 草稿 diff 校验通过（${diffResult.trim().split('\n').length} 个文件有改动）`)
+    } catch (e) {
+      console.warn(`⚠️ 草稿 diff 校验失败（${e && e.message ? e.message : e}），保守不勾`)
+      return false
+    }
+  }
+
   return true
 }
 async function autoCheckPlanFromReviews({ stageName, changeName, cwd, platformOpts }) {
@@ -491,6 +615,10 @@ async function autoCheckPlanFromReviews({ stageName, changeName, cwd, platformOp
       return { autoChecked: false, checkedCount: 0, skippedCount: 0 }
     }
     const executeRunId = c
+
+    // W2 task-04 FR-03：构造 ctx 供草稿零 diff 守卫用（与 task-review.js generateTaskReviewDrafts 同源）
+    const ctx = await buildDraftContext(cwd, changeName)
+
     // plan.md 是 agent 与 CLI 都会写的共享文件（agent 勾 checkbox、此处 autoCheck 也勾选）。
     // 读-改-写必须整体持锁（withFileLock 串行化多进程），否则并发 execute --done / 手动勾选互相覆盖
     // （后到者覆盖先到者）；写入用 writeAtomicSync（tmp+rename 原子），防 Windows 整文件覆盖被读半截
@@ -506,7 +634,7 @@ async function autoCheckPlanFromReviews({ stageName, changeName, cwd, platformOp
         const r = readReview(reviewPath)
         // 端到端 task：必须 pass（cannot_verify 不算）；普通 task：非 fail 即可（坑 execute-batch-complete-endtoend-checkbox）
         const endToEnd = isEndToEndTaskText(match + ' ' + readTaskCardText(changeDir, taskNum))
-        if (shouldAutoCheckTask(r, endToEnd)) {
+        if (shouldAutoCheckTask(r, endToEnd, ctx)) {
           checkedCount++
           return `${p1}x${p2}`   // 勾选
         }
@@ -530,8 +658,11 @@ async function autoCheckPlanFromReviews({ stageName, changeName, cwd, platformOp
  * 复用现成能力：readPlanCheckboxStatus（plan 勾选状态）+ checkExecuteCodeEvidence（代码客观核验，
  * 与 doctor --align-execute-progress 同源，D-002/D-004）。仅在 stageName==='execute' && changeName 触发。
  *
+ * W2 task-05 FR-04：plan 全勾后逐 task 复核——review 缺失或草稿零 diff → 阻断批量，
+ * 返回 blockedTasks 列表（task id 数组），调用方打印 reason。
+ *
  * 安全门：plan 零 checkbox / 未全勾 / 代码零变更（unchanged）均不批量——信任 plan 声明但用代码核验兜底。
- * @returns {Promise<{batched:boolean, aligned:number, reason?:string}>}
+ * @returns {Promise<{batched:boolean, aligned:number, reason?:string, blockedTasks?:string[]}>}
  */
 async function detectExecuteBatchFinish({ pm, stageName, changeName, cwd, specBase, steps }) {
   if (stageName !== 'execute' || !changeName) return { batched: false, aligned: 0 }
@@ -548,6 +679,78 @@ async function detectExecuteBatchFinish({ pm, stageName, changeName, cwd, specBa
     if (evidence.status === 'unchanged') {
       return { batched: false, aligned: 0, reason: `代码零变更（${evidence.detail}）` }
     }
+
+    // W2 task-05 FR-04：逐 task 复核（草稿零 diff 守卫——批量层）
+    // 读取 plan.md 提取已勾 task id 列表（正则 `- [x] task-NN`）
+    const planPath = join(changeDir, 'plan.md')
+    const planContent = readFileSync(planPath, 'utf8')
+    const taskCheckboxRegex = /-\s\[x\]\s+task-(\d+)/gi
+    const taskMatches = [...planContent.matchAll(taskCheckboxRegex)]
+    const taskIds = taskMatches.map(m => `task-${m[1].padStart(2, '0')}`)
+
+    if (taskIds.length === 0) {
+      return { batched: false, aligned: 0, reason: 'plan.md 无已勾 task checkbox' }
+    }
+
+    // 构造 ctx 供草稿零 diff 校验用（与 task-04 同源）
+    const ctx = await buildDraftContext(cwd, changeName)
+    const runtimeRoot = resolveRuntimeRoot({ specRoot: specBase }, specBase)
+    const runIdFile = join(runtimeRoot, `current-execute-run-id-${changeName}`)
+    const blockedTasks = []
+
+    for (const taskId of taskIds) {
+      let review = null
+      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) {
+          blockedTasks.push(taskId)
+          continue
+        }
+        review = r.review
+      } catch {
+        blockedTasks.push(taskId)
+        continue
+      }
+
+      // review 存在：判定是否为自动草稿且零 diff
+      if (review?.reviewerNotes && review.reviewerNotes.includes('auto-generated draft')) {
+        const changedFiles = review.changedFiles || []
+        // 草稿且 changedFiles 为空 → 阻断
+        if (changedFiles.length === 0) {
+          blockedTasks.push(taskId)
+          continue
+        }
+        // 草稿且有 changedFiles → 实测 diff 校验（ctx 与 task-04 同源）
+        if (ctx && ctx.gitDir && ctx.base && ctx.head) {
+          try {
+            const diffResult = gitQuiet(ctx.gitDir, ['diff', '--name-only', `${ctx.base}..${ctx.head}`, '--', ...changedFiles], { trim: true })
+            if (!diffResult || diffResult.trim() === '') {
+              blockedTasks.push(taskId)
+            }
+          } catch (e) {
+            // diff 校验失败保守处理：阻断（避免误批量）
+            blockedTasks.push(taskId)
+          }
+        }
+      }
+    }
+
+    // blockedTasks 非空 → 阻断批量
+    if (blockedTasks.length > 0) {
+      const reason = `以下 task 复核未过（review 缺失或草稿零 diff）：${blockedTasks.join(', ')}`
+      console.warn(`⚠️ 批量完成被阻断：${reason}`)
+      return { batched: false, aligned: 0, reason, blockedTasks }
+    }
+
+    // 全部复核通过 → 批量标 completed
     const now = new Date().toLocaleString('zh-CN', { hour12: false })
     let aligned = 0
     for (const step of steps) {
@@ -558,8 +761,9 @@ async function detectExecuteBatchFinish({ pm, stageName, changeName, cwd, specBa
       }
     }
     return { batched: true, aligned }
-  } catch {
-    return { batched: false, aligned: 0 }
+  } catch (e) {
+    // 异常 fail-open：不批量，reason 带错误信息
+    return { batched: false, aligned: 0, reason: `批量完成检测异常：${e && e.message ? e.message : e}` }
   }
 }
 
@@ -759,6 +963,8 @@ export async function continueStep(pm, progress, stageName, cwd, answer, options
   progress.lastActive = now
   pm._write(cwd, progress, changeName)
   triggerSync(cwd, changeName, platformOpts)
+  // wait 解除持久化点（含 repeatable 多轮）同样刷新 change title——多轮确认期间 design.md 已存在
+  refreshChangeTitleFromArtifacts(pm, cwd, specBase, changeName)
 
   console.log(`✅ Step ${currentIdx + 1}/${stageData.steps.length} 已继续：${currentStep.name}`)
   console.log(`   回答：${answer}`)
@@ -815,12 +1021,7 @@ export async function continueStep(pm, progress, stageName, cwd, answer, options
     if (_stageGatesResult?.stageCompleted === false) process.exitCode = 1
     if (_stageGatesResult) return _stageGatesResult
     // 完整流程 change title 刷新（同 completeStep 完成分支，wait 解除后阶段完成也刷新）。
-    if (changeName && !/^quick-[0-9a-f]{8}$/.test(changeName)) {
-      try {
-        const refinedTitle = deriveTitleFromLinkedChange(specBase, changeName)
-        if (refinedTitle) pm.updateChangeMeta(cwd, changeName, { title: refinedTitle })
-      } catch { /* title 刷新失败不阻断完成 */ }
-    }
+    refreshChangeTitleFromArtifacts(pm, cwd, specBase, changeName)
     // gate 全过：persist completed（task-03 移后；此处无 triggerSync）。
     pm._write(cwd, progress, changeName)
     console.log(`\n✅ ${stageName} 阶段已完成（${stageData.steps.length}/${stageData.steps.length} 步）`)

package/src/run/concurrent-detect.js

@@ -30,6 +30,28 @@ function normalizeGitPath(p) {
   return String(p).replace(/\\/g, '/')
 }
 
+/**
+ * 并发预检 ownFiles 锚点（2026-08-18 误归属修复）。
+ *
+ * 未声明会话（allowedFiles 空）维持旧口径 changedFiles ∪ baselineFiles——无声明即无归属信息，
+ * 收窄锚点会把本会话每次未声明的自身改动全误报他者。声明会话锚点 = baselineFiles ∪ allowedFiles
+ * （声明即归属）：窗口 diff（changedFiles）在多 agent 并发仓库可能含他者污染（ql-20260818-003
+ * 实证：并行会话窗口内改的文件被算进本会话 changedFiles 再被 ownFiles 自吞），超出声明集的
+ * 窗口新脏文件才作为 foreign 信号报出（= 他者或漏声明，歧义由 advisory 文案兜住）。
+ *
+ * 纯函数：不查盘不调 git，调用点（complete-handlers task-02 钩子）传入三个列表。
+ * @param {{ changedFiles?: string[], baselineFiles?: string[], allowedFiles?: string[] }} opts
+ * @returns {string[]} ownFiles 锚点集合（去重）
+ */
+export function resolveConcurrentAnchor({ changedFiles = [], baselineFiles = [], allowedFiles = [] } = {}) {
+  const arr = (x) => (Array.isArray(x) ? x : [])
+  const declared = arr(allowedFiles).map(normalizeGitPath).filter(Boolean)
+  if (declared.length === 0) {
+    return [...arr(changedFiles).map(normalizeGitPath), ...arr(baselineFiles).map(normalizeGitPath)]
+  }
+  return [...new Set([...arr(baselineFiles).map(normalizeGitPath), ...declared])]
+}
+
 /**
  * 检测工作树里的并发他者改动（非阻塞 advisory 用）。
  *