sillyspec 3.28.7 → 3.28.9

package/src/task-review.js

@@ -9,13 +9,16 @@
  */
 
 import { existsSync, readFileSync, mkdirSync, writeFileSync, readdirSync, statSync } from 'fs'
-import { join, resolve } from 'path'
+import { join, resolve, basename, dirname } from 'path'
+import { execFileSync } from 'child_process'
 import { git, unquoteGitPath } from './git-helper.js'
 import { pathMatches } from './change-list.js'
 import { parseAllowedPaths, parseRepo, parseBaseCommit, parseHeadCommit } from './stages/plan-postcheck.js'
 import { resolveVerifyChangedFiles } from './verify-postcheck.js'
+import { splitOwnVsForeignDiffFiles } from './foreign-declared.js'
 import { WorktreeManager } from './worktree.js'
 import { resolveRuntimeRoot } from './run/shared.js'
+import { DB } from './db.js'
 
 // ── review.json schema version ──
 //
@@ -30,6 +33,16 @@ import { resolveRuntimeRoot } from './run/shared.js'
 // 跨仓 task 写 review.json 可用 v2 带 repo 字段，单仓/旧 change 仍用 v1。后续可拆分 stage-review 专用
 // 常量，本期遵循 allowed_paths 约束不扩散到 stage-review.js。
 export const REVIEW_SCHEMA_VERSION = 1
+
+/**
+ * review.json 写入溯源戳（坑 review-json-mystery-overwrite，2026-09-12 驾驭第十七批①，
+ * 用户实证 task-04 review 被覆写成空壳、gate 报零改动伪造重写恢复——四个 writer 均有
+ * 覆盖守卫，无堆栈钉不死覆写者）：每次写入附 writtenBy（写入通道 + PID）+ writtenAt，
+ * emptyDiff 伪造 error 直显两字段——下次复现自曝身份，事后可归因。
+ */
+function reviewProvenanceStamp(channel) {
+  return { writtenBy: `${channel}#pid${process.pid}`, writtenAt: new Date().toISOString() }
+}
 const REVIEW_SCHEMA_VERSIONS_ACCEPTED = [1, 2]
 // repo 缺省值（review.repo / task 卡 repo 缺省时统一按 'main' 处理）。design §7.2 / §7.4。
 const DEFAULT_REPO_KEY = 'main'
@@ -323,6 +336,26 @@ export function readReview(reviewPath) {
   return { ok: true, review: parsed, errors: [] }
 }
 
+/**
+ * 判定 review 是否经显式 CLI 命令式写入（`sillyspec review write` → writeTaskReview）。
+ * （ql-20260915-001 修复②，坑 review-write-draft-marker-stuck：execute 期间反复
+ * 「草稿 review changedFiles 为空，跳过自动勾选」，主仓文档面任务自动勾选断链。）
+ *
+ * 判据：reviewProvenanceStamp 落的 writtenBy 以 'writeTaskReview' 开头（含 ':force' 变体）。
+ * 显式写入带 agent 供给的 verdict（非草稿兜底通道），即使 reviewerNotes 字面残留
+ * 'auto-generated draft'（agent 升级草稿时 --notes 引用/复述草稿文案、或 adopt 通道合并
+ * 保留旧 notes 的变体）也一律按非草稿处理——verdict 判定不再受草稿零 diff 守卫限制。
+ *
+ * 无 writtenBy 的存量 review（provenance 机制引入前手写）按非显式处理，走原 notes
+ * 启发式判定（向后兼容，行为不回退）。
+ *
+ * @param {object|null} review readReview 返回的 review 对象
+ * @returns {boolean}
+ */
+export function isExplicitReviewWrite(review) {
+  return typeof review?.writtenBy === 'string' && review.writtenBy.startsWith('writeTaskReview')
+}
+
 /**
  * 校验 plan.md 里所有「已勾选 [x]」task 的 review.json 是否 schema 完整（坑 review-json-field-gap）。
  *
@@ -493,7 +526,11 @@ export function validateTaskReviews(opts) {
       }
     }
     if (reviewGitDir) {
-      const evidence = verifyReviewGitEvidence(review, reviewGitDir, evidenceCache)
+      const evidence = verifyReviewGitEvidence(review, reviewGitDir, evidenceCache, {
+        mainGitDir: gitDir,
+        changeName: changeDir ? basename(changeDir) : null,
+        specBase: changeDir ? dirname(dirname(changeDir)) : null,
+      })
       for (const w of evidence.warnings) warnings.push(`${taskId}: ${w}`)
       if (!evidence.ok) {
         for (const err of evidence.errors) errors.push(`${taskId}: ${err}`)
@@ -515,7 +552,8 @@ export function validateTaskReviews(opts) {
           const scopeNote = Array.isArray(review.diffPaths) && review.diffPaths.length > 0
             ? `（diffPaths 路径限定切片为空——统一 commit 模式下 diffPaths 应为本 task 的 allowed_paths；task 确未实现请把 verdict 回 fail）`
             : ''
-          errors.push(`${taskId}: base..head（${review.base.slice(0, 8)}..${review.head.slice(0, 8)}）无任何代码变更 — 评审了一个零改动的任务，review 疑似伪造${scopeNote}`)
+          const prov = (review.writtenBy || review.writtenAt) ? `［写入溯源：${review.writtenBy || '?'} @ ${review.writtenAt || '?'}］` : '［无写入溯源—— older writer 产物］'
+          errors.push(`${taskId}: base..head（${review.base.slice(0, 8)}..${review.head.slice(0, 8)}）无任何代码变更 — 评审了一个零改动的任务，review 疑似伪造${scopeNote}${prov}`)
           continue
         }
       }
@@ -622,7 +660,7 @@ function parsePorcelainFiles(statusOut) {
  *   一次校验批：working-tree status 是快照语义，跨批复用会读到陈旧状态。
  * @returns {{ ok: boolean, emptyDiff: boolean, errors: string[], warnings: string[], unavailable: boolean }}
  */
-export function verifyReviewGitEvidence(review, gitDir, cache = null) {
+export function verifyReviewGitEvidence(review, gitDir, cache = null, opts = {}) {
   const errors = []
   const warnings = []
   const c = cache || (cache = {})
@@ -667,7 +705,7 @@ export function verifyReviewGitEvidence(review, gitDir, cache = null) {
       // 可执行指引（坑 review-head-real-commit-late，2026-08-22 实证：head 必须真实 commit 的
       // 要求撞门才知道——报错直接给操作序列：worktree 改动先 commit，取 HEAD 作 head）
       errors.push(`${field} "${hash}" 不是仓库中的真实 commit — review.json 疑似伪造。` +
-        `head/base 必须是 git rev-parse 可解析的 commit hash：worktree 内先 git add -A && git commit -m "<task>"，` +
+        `head/base 必须是 git rev-parse 可解析的 commit hash：worktree 内先 sillyspec wt-commit --change <变更名> -m "<task-NN>" -- <本 task 精确路径>（串行锁 + pathspec，防卷入并行兄弟 WIP；退路 git add -- <精确路径> && git commit，禁 add -A），` +
         `再取 git rev-parse HEAD 作 head（base 用 task 卡锡点或基线 commit）；不要填分支名/伪 hash/working-tree 描述`)
     }
   }
@@ -703,7 +741,22 @@ export function verifyReviewGitEvidence(review, gitDir, cache = null) {
       c.wtStatus.set(gitDir, wtStatus)
     }
     if (wtStatus && wtStatus.trim().length > 0) {
-      const wtFiles = parsePorcelainFiles(wtStatus)
+      let wtFiles = parsePorcelainFiles(wtStatus)
+      // 归属过滤（2026-09-12 审查批 A-①，坑 task-review-foreign-wip-blindspot）：主仓 in-place
+      // 模式下 wtStatus 含**全部**并行会话的未提交文件——他者 WIP 稀释 diffFiles 使 emptyDiff
+      // （零改动→伪造 ERROR）在共享仓永不触发、交叉比对更易混过。对齐 verify-postcheck
+      // resolveMainChangedFiles 的 splitOwnVsForeignDiffFiles 剔除口径（他者声明文件归他者）。
+      // 仅主仓 gitDir 过滤（跨仓/worktree 无主 specBase 声明源，行为不变）；无 opts 零回归。
+      if (wtFiles.length > 0 && opts.mainGitDir && opts.changeName
+          && resolve(gitDir) === resolve(opts.mainGitDir)) {
+        try {
+          const { own, foreign } = splitOwnVsForeignDiffFiles(gitDir, opts.changeName, wtFiles, { specBase: opts.specBase })
+          if (foreign.length > 0) {
+            wtFiles = own
+            warnings.push(`working-tree 并入已排除 ${foreign.length} 个并行会话声明的文件（${foreign.slice(0, 3).map(x => x.file).join(', ')}${foreign.length > 3 ? ' 等' : ''}）`)
+          }
+        } catch { /* 归属过滤失败退回全量并入（fail-open 与旧口径一致） */ }
+      }
       if (wtFiles.length > 0) diffFiles = diffFiles.concat(wtFiles)
       if (commitDiffFiles.length === 0) {
         warnings.push(`base..head 无 commit diff（${review.base.slice(0, 8)}..${review.head.slice(0, 8)}），交叉对账并入 working-tree 未提交改动 ${wtFiles.length} 个文件 —— 按有效改动处理，不判零改动伪造`)
@@ -1072,6 +1125,130 @@ export function resolveExecuteRunForChange({ runtimeRoot, changeName, taskIds =
   }
 }
 
+// ── 归因模式分流（2026-09-14-change-ownership-guards task-03 / D-004@v1 / FR-03）──
+// 草稿/changedFiles 归因的取数源路由：判定源=changes.isolation_mode 列（DB 读，meta 缺失也可判，
+// 与 change-registry.readChangeIsolation 同列；此处直连 db.js 读——task-review 是叶子模块，
+// 静态 import progress.js 会成环 progress→consistency-doctor→task-review）。进程内按
+// dbPath+change 缓存（CLI 短进程生命周期内 isolation_mode 不变，避免重复 open/init）。
+const _isolationModeCache = new Map()
+
+/**
+ * 读 changes.isolation_mode（只读；无库/无行/读失败 → null）。DB 路径候选序：
+ * platformOpts.specRoot > specDriftAnchor > specBase > cwd/.sillyspec（首个存在 sillyspec.db 的根）。
+ * 模块内函数（非 export——check-syntax 22e-b 死码门禁：无跨文件消费不导出）。
+ * @param {{ cwd: string, specBase: string, platformOpts?: object, changeName: string }} opts
+ * @returns {string|null} isolation_mode（'worktree'|'native-worktree'|'in-place-fallback'）或 null
+ */
+function readChangeIsolationMode({ cwd, specBase, platformOpts = {}, changeName }) {
+  if (!changeName) return null
+  const roots = []
+  const addRoot = (r) => { if (r && !roots.includes(r)) roots.push(r) }
+  addRoot(platformOpts && platformOpts.specRoot)
+  addRoot(platformOpts && platformOpts.specDriftAnchor)
+  addRoot(specBase)
+  addRoot(join(cwd, '.sillyspec'))
+  for (const root of roots) {
+    const dbPath = join(root, '.runtime', 'sillyspec.db')
+    if (!existsSync(dbPath)) continue
+    const key = dbPath + '::' + changeName
+    if (_isolationModeCache.has(key)) return _isolationModeCache.get(key)
+    let mode = null
+    try {
+      const db = new DB(dbPath)
+      db.init()
+      const row = db.getDb().prepare('SELECT isolation_mode FROM changes WHERE name = ?').get(changeName)
+      mode = (row && typeof row.isolation_mode === 'string' && row.isolation_mode) || null
+    } catch { mode = null }
+    _isolationModeCache.set(key, mode)
+    return mode
+  }
+  return null
+}
+
+/**
+ * 归因取数源路由（单一入口，草稿生成 generateTaskReviewDrafts 与 mechanics 代算 writeTaskReview
+ * 两处共用）。判定优先级（D-004）：
+ *   1. DB isolation_mode ∈ {worktree, native-worktree} → worktree 归因：worktree 目录活则原口径
+ *      （resolveVerifyChangedFiles meta 路径 + porcelain 并入，零回归）；meta 缺失/in-place meta/
+ *      目录已删 → 分支 ref 口径（merge-base(主仓 HEAD, 分支 tip)..tip 的 commit diff + worktree
+ *      目录在则 porcelain 并入，与 verify reconcile 同口径）。分支 ref 也已删（cleanup 后态）→
+ *      fail-closed 空集 +「不可归因（worktree 已清理）」注记，绝不回退主仓窗口（复审残留①）。
+ *   2. DB in-place-fallback 但 meta 判 worktree 且目录活 → 仍取 worktree（fail-safe：不因 DB 行
+ *      陈旧切向主仓共享脏窗口——归因源只会更隔离不会更共享），注记不一致。
+ *   3. 其余（DB in-place / NULL）→ 主仓窗口原行为零回归；NULL 且 meta 缺失加存量路由注记
+ *      （存量态不追求完美只保安全，D-004 残留②/R-04）。
+ * meta 在时交叉校验不一致以 DB 为准（方向 1 的 worktree 覆盖）；返回 notes 逐条说明路由依据。
+ *
+ * @param {{ cwd: string, changeName: string, specBase: string, platformOpts?: object }} opts
+ * @returns {{ mode: 'worktree'|'worktree-branch'|'worktree-cleaned'|'main-window', diffFiles: string[]|null, notes: string[], meta: object|null, mergeGitDir: string|null, branch?: string, branchBase?: string, branchHead?: string }}
+ */
+function resolveAttributionDiffFiles({ cwd, changeName, specBase, platformOpts = {} }) {
+  const notes = []
+  const wm = new WorktreeManager({ cwd })
+  let meta = null
+  try { meta = wm.getMeta(changeName) } catch { meta = null }
+  const iso = readChangeIsolationMode({ cwd, specBase, platformOpts, changeName })
+  const isoWorktree = iso === 'worktree' || iso === 'native-worktree'
+
+  if (isoWorktree) {
+    const wtGitDir = (meta && meta.worktreePath && meta.mode !== 'in-place-fallback' && existsSync(meta.worktreePath))
+      ? meta.worktreePath
+      : null
+    if (wtGitDir) {
+      if (meta.mode !== iso) notes.push(`meta.mode=${meta.mode} 与 DB isolation_mode=${iso} 不一致——以 DB 为准（同属 worktree 族，归因源不变）`)
+      return { mode: 'worktree', diffFiles: resolveVerifyChangedFiles(cwd, changeName, null, { specBase }), notes, meta, mergeGitDir: wtGitDir }
+    }
+    // meta 缺失 / in-place meta / worktree 目录已删：分支 ref 判定（不落主仓窗口）
+    const branch = (meta && meta.branch) || `sillyspec/${changeName}`
+    let branchTip = null
+    try { branchTip = runGit(cwd, ['rev-parse', '--verify', '--quiet', `refs/heads/${branch}`]) } catch { branchTip = null }
+    if (!branchTip) {
+      notes.push(`不可归因（worktree 已清理）——DB 判 worktree（isolation_mode=${iso}）但分支 ref ${branch} 不存在（cleanup 后态），fail-closed 空集，不回退主仓窗口`)
+      return { mode: 'worktree-cleaned', diffFiles: [], notes, meta, mergeGitDir: null }
+    }
+    let branchBase = null
+    let files = []
+    try {
+      const mainHead = runGit(cwd, ['rev-parse', 'HEAD'])
+      const mb = mainHead ? runGit(cwd, ['merge-base', branchTip, mainHead]) : null
+      branchBase = mb || mainHead || null
+      if (branchBase) {
+        files = String(runGit(cwd, ['diff', '--name-only', branchBase, branchTip]) || '')
+          .split('\n').map(p => p.replace(/^"|"$/g, '').replace(/\\/g, '/').trim())
+          .filter(p => p && p !== '.sillyspec' && !p.startsWith('.sillyspec/'))
+      }
+    } catch { /* 已提交口径 git 失败 → 空集 fail-closed（不回退主仓窗口） */ }
+    // 未提交并入：约定路径 worktree 目录仍在（meta 失联孤儿）→ porcelain（与 verify reconcile 同口径）
+    const wtDirGuess = join(wm.worktreeBase, changeName)
+    if (existsSync(wtDirGuess)) {
+      try {
+        const st = runGit(wtDirGuess, ['status', '--porcelain', '--untracked-files=all'], { trim: false })
+        const wtFiles = parsePorcelainFiles(st)
+          .map(p => String(p).replace(/\\/g, '/'))
+          .filter(p => p !== '.sillyspec' && !p.startsWith('.sillyspec/'))
+        files = [...new Set([...files, ...wtFiles])]
+      } catch { /* porcelain 失败退回 commit diff 口径 */ }
+    }
+    notes.push(`meta 缺失/失效，DB isolation_mode=${iso} 判 worktree——归因源=worktree 分支 ${branch} diff（base..HEAD+porcelain，与 verify reconcile 同口径），不落主仓共享脏窗口`)
+    return { mode: 'worktree-branch', diffFiles: files, notes, meta, mergeGitDir: null, branch, branchBase, branchHead: branchTip }
+  }
+
+  if (iso === 'in-place-fallback' && meta && meta.mode !== 'in-place-fallback'
+    && meta.worktreePath && existsSync(meta.worktreePath)) {
+    notes.push(`DB isolation_mode=in-place-fallback 但 meta.mode=${meta.mode}——worktree 分支仍是隔离归因源（fail-safe：不因 DB 行陈旧切向主仓共享窗口），按 meta 取 worktree 归因`)
+    return { mode: 'worktree', diffFiles: resolveVerifyChangedFiles(cwd, changeName, null, { specBase }), notes, meta, mergeGitDir: meta.worktreePath }
+  }
+
+  // in-place（DB 或 meta）与 NULL 存量：主仓窗口（原行为零回归）
+  if (!meta && iso === null) {
+    notes.push('isolation_mode 未登记（存量变更/无 DB 行）且 worktree meta 缺失——按主仓窗口归因（存量兼容路由，D-004 残留②：不追求完美只保安全）')
+  }
+  const mergeGitDir = meta
+    ? ((meta.worktreePath && meta.mode !== 'in-place-fallback' && existsSync(meta.worktreePath)) ? meta.worktreePath : cwd)
+    : null
+  return { mode: 'main-window', diffFiles: resolveVerifyChangedFiles(cwd, changeName, null, { specBase }), notes, meta, mergeGitDir }
+}
+
 /**
  * worktree execute「主 agent 直接实现」模式收尾兜底：per-task review.json 缺失时，
  * 据 git diff base..head 按 task allowed_paths 归属，自动落盘 cannot_verify 草稿。
@@ -1139,21 +1316,30 @@ export async function generateTaskReviewDrafts({ changeName, cwd, platformOpts =
     }
   }
 
+  // ── 归因模式分流（task-03 / D-004@v1）：判定源=changes.isolation_mode（DB 读）──
+  // worktree 模式（含 meta 缺失回退态）归因唯一源=worktree 分支 diff（绝不落主仓共享脏窗口，
+  // troubleshooting §65 事件②根因）；in-place 维持主仓窗口；NULL 存量按 meta 在场路由。
+  // 分流自身异常 → 退回原 resolveVerifyChangedFiles 口径（fail-open，不比修复前差）。
+  let attribution
+  try {
+    attribution = resolveAttributionDiffFiles({ cwd, changeName, specBase, platformOpts })
+  } catch (e) {
+    attribution = { mode: 'main-window', diffFiles: resolveVerifyChangedFiles(cwd, changeName, null, { specBase }), notes: [`归因分流解析异常（${e && e.message ? e.message : e}）——退回原口径`], meta: null, mergeGitDir: null }
+  }
+  for (const note of attribution.notes) console.log(`[sillyspec] 归因注记：${note}`)
   // base..head diff 文件集（worktree-aware；null=git 不可用，[]=无 commit diff）
-  let diffFiles = resolveVerifyChangedFiles(cwd, changeName, null, { specBase })
+  let diffFiles = attribution.diffFiles
   // ⚠️ 并入 worktree 未提交改动（坑 draft-attribution-uncommitted-worktree，2026-08-21 实证）：
   // 子代理默认不 commit（execute 复盘 a 同源事实），真实改动全在 worktree working-tree——只看
   // base..HEAD commit diff 时归属恒空，9/9 草稿全成「无归属」靠主代理手写升级。与
   // verifyReviewGitEvidence 的 working-tree 并入口径同源：status --porcelain 文件（排除
   // .sillyspec/ 运行时产物）并入归属集，按 allowed_paths 正常路径归属；review.head 仍为 HEAD
   // commit——evidence 校验对「commit diff 空 + working-tree 有改动」明示不判伪造，语义一致。
-  try {
-    const wm = new WorktreeManager({ cwd })
-    const meta = wm.getMeta(changeName)
-    if (meta) {
-      const wtGitDir = (meta.worktreePath && meta.mode !== 'in-place-fallback' && existsSync(meta.worktreePath))
-        ? meta.worktreePath
-        : cwd
+  // D-004 后仅在归因源指向活跃 worktree 目录 / in-place meta（mergeGitDir）时执行——
+  // worktree-branch/cleaned 归因的未提交并入已在 resolveAttributionDiffFiles 内按同口径完成。
+  if (attribution.mergeGitDir) {
+    try {
+      const wtGitDir = attribution.mergeGitDir
       const wtStatus = runGit(wtGitDir, ['status', '--porcelain', '--untracked-files=all'], { trim: false })
       const wtFiles = parsePorcelainFiles(wtStatus)
         .map(p => String(p).replace(/\\/g, '/'))
@@ -1180,12 +1366,19 @@ export async function generateTaskReviewDrafts({ changeName, cwd, platformOpts =
         diffFiles = [...new Set([...(Array.isArray(diffFiles) ? diffFiles : []), ...wtFiles, ...committedFiles])]
         console.log(`[sillyspec] 草稿归属并入 worktree 改动 ${wtFiles.length + committedFiles.length} 个（未提交 ${wtFiles.length} + 已提交 ${committedFiles.length}，按 allowed_paths 归属）`)
       }
-    }
-  } catch { /* working-tree 并入失败退回 commit diff 口径（fail-open，不阻断草稿） */ }
+    } catch { /* working-tree 并入失败退回 commit diff 口径（fail-open，不阻断草稿） */ }
+  }
   // 单仓模式（无 ctx）：主仓无 diff 即无任何 task 可生成 → 提前返回（原逻辑零回归）。
   // 有 ctx：主仓无 diff 不阻断——跨仓 task 的 diff 在跨仓仓根独立取（per-task），主仓 task 自然跳过（空 changedFiles）。
+  // 终态空源（D-004）：worktree-cleaned（DB 判 worktree 但分支 ref 已删）空集的 reason 显式
+  // 注记「不可归因」，与普通「无 diff」区分——绝不回退主仓窗口补救。
   if (!ctx && (!diffFiles || diffFiles.length === 0)) {
-    return { generated: 0, skipped: 0, unattributed: [], executeRunId, reason: 'base..head 无代码 diff（改动未 commit？）' }
+    return {
+      generated: 0, skipped: 0, unattributed: [], executeRunId,
+      reason: attribution.mode === 'worktree-cleaned'
+        ? '不可归因（worktree 已清理）——DB 判 worktree 但分支 ref 已删，fail-closed 空集（不回退主仓窗口）'
+        : 'base..head 无代码 diff（改动未 commit？）',
+    }
   }
 
   // base/head + gitDir：与 gates.js reviewGitDir 同源（worktree 优先，in-place 回退 cwd）
@@ -1217,6 +1410,15 @@ export async function generateTaskReviewDrafts({ changeName, cwd, platformOpts =
       // 有 ctx：主仓 HEAD 失败不阻断跨仓 task；head 留 null，主仓 task 后续按空 changedFiles 跳过
     }
   }
+  // worktree-branch 归因的 base/head 锚定（task-03 / D-004）：meta 缺失但分支 ref 活着时用
+  // merge-base(主仓 HEAD, 分支 tip)=创建锚点..分支 tip 锚定——DB 判 worktree 的回退态仍能
+  // 生成带真实 git 锚点的草稿（否则上方「无 meta.baseHash」早退白费分支归因成果）。分支 ref
+  // 在主仓共享 .git 内，reviewGitDir=cwd 可解析，evidence 校验的 base..head diff 与归因同源。
+  if (!base && attribution.branchBase && attribution.branchHead) {
+    base = attribution.branchBase
+    head = attribution.branchHead
+    reviewGitDir = cwd
+  }
 
   const taskFiles = readdirSync(tasksDir).filter(f => /^task-\d+\.md$/.test(f)).sort()
   let generated = 0
@@ -1321,6 +1523,7 @@ export async function generateTaskReviewDrafts({ changeName, cwd, platformOpts =
           ';verdict=未评审（无归属 diff 兜底草稿，坑 task-review-draft-skip-leak）',
       }
       if (draftRepo) draft.repo = draftRepo
+      Object.assign(draft, reviewProvenanceStamp('generateTaskReviewDrafts:no-attribution'))
       // fail-open（对齐函数头契约 + execute-run-dir-fail-loud 测试锁定的「写失败返回统计不抛」）：
       // 无归属草稿写入失败（如 tasks/ 被普通文件占位 ENOTDIR）降级 skipped，不崩整个草稿生成
       try {
@@ -1352,6 +1555,7 @@ export async function generateTaskReviewDrafts({ changeName, cwd, platformOpts =
       reviewerNotes: 'auto-generated draft from git diff ' + taskBase.slice(0, 8) + '..' + taskHead.slice(0, 8) + ';verdict=未评审（worktree execute 主 agent 实现模式兜底，坑2）',
     }
     if (draftRepo) draft.repo = draftRepo
+    Object.assign(draft, reviewProvenanceStamp('generateTaskReviewDrafts'))
     mkdirSync(reviewDir, { recursive: true })
     writeFileSync(reviewPath, JSON.stringify(draft, null, 2) + '\n')
     generated++
@@ -1568,6 +1772,7 @@ export async function adoptTaskReviewMechanics({ changeName, cwd, platformOpts =
 
     try {
       if (mechanicsChanged || verdictTouched || evidenceFilled) {
+        Object.assign(merged, reviewProvenanceStamp('adoptTaskReviewMechanics'))
         writeFileSync(reviewPath, JSON.stringify(merged, null, 2) + '\n')
         adopted++
       } else {
@@ -1618,6 +1823,89 @@ export async function adoptTaskReviewMechanics({ changeName, cwd, platformOpts =
  * @param {object} [opts.platformOpts]
  * @returns {Promise<{ok: boolean, reviewPath?: string, executeRunId?: string, errors: string[], warnings: string[]}>}
  */
+// ── ql-20260915-003 修复③（坑 interrupted-residue-detect，2026-09-15 用户实证：中断的
+// execute 子代理在工作区留下半成品 import 语法坏文件，无自动检测靠人工 diff 发现）──
+//
+// 对 changedFiles 中的 .js/.mjs/.cjs 逐个 `node --check`（子进程数组形式不经 shell，单文件
+// 5s 超时；总数 >60 抽样前 60 并提示——大变更全量查的耗时不可接受）。
+//
+// 判定分层（Node v24 实测：.js 的 file-check 受最近 package.json type 影响——无 type 时
+// ESM 半成品可能静默通过、合法 ESM 又会报 import 语句误错）：
+//   - .mjs/.cjs：file-check 权威（对应 module/commonjs 全量解析）
+//   - .js：file-check **与** stdin `--input-type=module` check 双跑，两者都报 SyntaxError
+//     才判残留（合法 ESM / 合法 CJS（含 sloppy-mode）必有一路通过，零假阳；真断档半成品
+//     两路都挂）。stdin check 不可用/无 SyntaxError 字样 → fail-open 跳过该文件。
+//
+// 语法失败 → 返回「疑似中断残留」warning（advisory：只提醒，不改 verdict / 勾选语义 /
+// 落盘行为——quick --done 的 test/lint 实测硬门才是卡点，这里补「中断半成品」的可见性）。
+// 文件在候选根下不存在（diff 里的删除态文件等）直接跳过；超时（e.killed）无法定论不报警。
+// 仅 review write 时点执行一次，非热路径。
+const SYNTAX_CHECK_EXT_RE = /\.(?:js|mjs|cjs)$/
+const SYNTAX_CHECK_MAX_FILES = 60
+// 严格 .js（.mjs/.cjs 也 endsWith('.js')，须排除——否则 sloppy-mode .cjs 会误入 stdin ESM
+// 复核路径产生假阳）
+const isPlainJs = (f) => f.endsWith('.js') && !f.endsWith('.mjs') && !f.endsWith('.cjs')
+function _syntaxErrLine(e) {
+  const raw = String((e.stderr && e.stderr.toString()) || e.message || '')
+  const line = raw.split('\n').find(l => l.includes('SyntaxError'))
+  return line ? line.trim() : null
+}
+function detectInterruptedSyntaxResidue(changedFiles, candidateRoots) {
+  const warnings = []
+  const jsFiles = (Array.isArray(changedFiles) ? changedFiles : [])
+    .filter(f => typeof f === 'string' && SYNTAX_CHECK_EXT_RE.test(f))
+  if (jsFiles.length === 0) return warnings
+  const overCap = jsFiles.length > SYNTAX_CHECK_MAX_FILES
+  for (const f of overCap ? jsFiles.slice(0, SYNTAX_CHECK_MAX_FILES) : jsFiles) {
+    let abs = null
+    for (const root of candidateRoots) {
+      if (!root) continue
+      const p = join(root, f)
+      if (existsSync(p)) { abs = p; break }
+    }
+    if (!abs) continue
+    try {
+      execFileSync(process.execPath, ['--check', abs], { timeout: 5000, stdio: ['pipe', 'pipe', 'pipe'] })
+      if (isPlainJs(f)) {
+        // 无 type:module 上下文的 .js：file-check 通过不代表语法完整（Node v24 实测假阴），
+        // 再跑 stdin ESM 全量解析兜底——两路都挂才判残留
+        let src = ''
+        try { src = readFileSync(abs, 'utf8') } catch { continue }
+        try {
+          execFileSync(process.execPath, ['--input-type=module', '--check'], { input: src, timeout: 5000, stdio: ['pipe', 'pipe', 'pipe'] })
+        } catch (e2) {
+          if (e2 && e2.killed) continue
+          const line = _syntaxErrLine(e2)
+          if (!line) continue // 非 SyntaxError（如版本不支持 stdin check）→ fail-open
+          warnings.push(`⚠️ 疑似中断残留：${f} 语法错误（${line}）——子代理异常退出可能留下半成品，请 diff 该文件确认还原或补完`)
+        }
+      }
+    } catch (e) {
+      if (e && e.killed) continue // 单文件超时：无法定论，不产假阳 warning
+      if (!isPlainJs(f)) {
+        const line = _syntaxErrLine(e)
+        if (line) warnings.push(`⚠️ 疑似中断残留：${f} 语法错误（${line}）——子代理异常退出可能留下半成品，请 diff 该文件确认还原或补完`)
+        continue
+      }
+      // .js file-check 挂可能是模块口径误错（合法 ESM 在无 type 上下文报 import 语句）——
+      // stdin ESM 解析仲裁：也挂才算真残留
+      let src = ''
+      try { src = readFileSync(abs, 'utf8') } catch { continue }
+      try {
+        execFileSync(process.execPath, ['--input-type=module', '--check'], { input: src, timeout: 5000, stdio: ['pipe', 'pipe', 'pipe'] })
+      } catch (e2) {
+        if (e2 && e2.killed) continue
+        const line = _syntaxErrLine(e2) || _syntaxErrLine(e)
+        if (line) warnings.push(`⚠️ 疑似中断残留：${f} 语法错误（${line}）——子代理异常退出可能留下半成品，请 diff 该文件确认还原或补完`)
+      }
+    }
+  }
+  if (overCap) {
+    warnings.push(`⚠️ 中断残留检测抽样：changedFiles 含 ${jsFiles.length} 个 .js 系文件，仅语法检查前 ${SYNTAX_CHECK_MAX_FILES} 个（interrupted-residue-detect）`)
+  }
+  return warnings
+}
+
 export async function writeTaskReview({
   changeName, cwd, taskId, specVerdict, qualityVerdict,
   reviewerNotes = '', requiredEvidence = [],
@@ -1724,22 +2012,30 @@ export async function writeTaskReview({
     changedFiles = changedFilesOverride.map(p => String(p).replace(/\\/g, '/'))
     warnings.push(`changedFiles 采用显式覆盖（${changedFiles.length} 个）——evidence 校验仍会与 git diff 相交比对`)
   } else {
-    let diffFiles = resolveVerifyChangedFiles(cwd, changeName, null, { specBase })
-    // 并入 worktree 未提交改动（与草稿生成同源口径：子代理默认不 commit）
+    // ── 归因模式分流（task-03 / D-004@v1）：与草稿生成同源路由（判定源=changes.isolation_mode）──
+    // worktree 模式（含 meta 缺失回退态）取 worktree 分支 diff，绝不落主仓共享脏窗口；
+    // in-place/NULL 存量维持主仓窗口原口径。分流异常退回原 resolveVerifyChangedFiles（fail-open）。
+    let attribution
     try {
-      const wm = new WorktreeManager({ cwd })
-      const meta = wm.getMeta(changeName)
-      if (meta) {
-        const wtGitDir = (meta.worktreePath && meta.mode !== 'in-place-fallback' && existsSync(meta.worktreePath))
-          ? meta.worktreePath
-          : cwd
+      attribution = resolveAttributionDiffFiles({ cwd, changeName, specBase, platformOpts })
+    } catch (e) {
+      attribution = { mode: 'main-window', diffFiles: resolveVerifyChangedFiles(cwd, changeName, null, { specBase }), notes: [`归因分流解析异常（${e && e.message ? e.message : e}）——退回原口径`], meta: null, mergeGitDir: null }
+    }
+    for (const note of attribution.notes) warnings.push(`归因注记：${note}`)
+    let diffFiles = attribution.diffFiles
+    // 并入 worktree 未提交改动（与草稿生成同源口径：子代理默认不 commit）。D-004 后仅在
+    // 归因源指向活跃 worktree 目录 / in-place meta（mergeGitDir）时执行——worktree-branch/
+    // cleaned 归因的未提交并入已在 resolveAttributionDiffFiles 内按同口径完成。
+    if (attribution.mergeGitDir) {
+      try {
+        const wtGitDir = attribution.mergeGitDir
         const wtStatus = runGit(wtGitDir, ['status', '--porcelain', '--untracked-files=all'], { trim: false })
         const wtFiles = parsePorcelainFiles(wtStatus)
           .map(p => String(p).replace(/\\/g, '/'))
           .filter(p => p !== '.sillyspec' && !p.startsWith('.sillyspec/'))
         if (wtFiles.length > 0) diffFiles = [...new Set([...(Array.isArray(diffFiles) ? diffFiles : []), ...wtFiles])]
-      }
-    } catch { /* 退回 commit diff 口径 */ }
+      } catch { /* 退回 commit diff 口径 */ }
+    }
     const mainDiff = Array.isArray(diffFiles) ? diffFiles : []
     changedFiles = allowedPaths.length > 0
       ? mainDiff.filter(f => allowedPaths.some(p => pathMatches(f, p)))
@@ -1757,6 +2053,15 @@ export async function writeTaskReview({
     }
   }
 
+  // ── ql-20260915-003 修复③（坑 interrupted-residue-detect）：changedFiles 定稿后的
+  // 语法检查（advisory warning，见 detectInterruptedSyntaxResidue 注释）。候选根依次试
+  // reviewGitDir（meta 活跃时的 worktree 根）、cwd、worktree-branch 归因的孤儿目录兜底。
+  for (const w of detectInterruptedSyntaxResidue(changedFiles, [
+    reviewGitDir,
+    cwd,
+    join(cwd, '.sillyspec', '.runtime', 'worktrees', changeName),
+  ])) warnings.push(w)
+
   // ── 组装 + schema 自检 + 落盘 ──
   const review = {
     schemaVersion: REVIEW_SCHEMA_VERSION,
@@ -1770,6 +2075,7 @@ export async function writeTaskReview({
     ...(requiredEvidence.filter(Boolean).length > 0 ? { requiredEvidence: requiredEvidence.filter(Boolean) } : {}),
     reviewerNotes: reviewerNotes || `written by sillyspec review write (${base.slice(0, 8)}..${head.slice(0, 8)})`,
   }
+  Object.assign(review, reviewProvenanceStamp('writeTaskReview' + (force ? ':force' : '')))
   const schemaResult = validateReviewSchema(review)
   if (!schemaResult.ok) {
     return { ok: false, errors: schemaResult.errors, warnings }

package/src/verify-facts-schema.js

@@ -42,8 +42,15 @@ export function classifyVerifiedFile(path) {
 /** 证据账 task 行：`- task-NN: <status> | verifiedFiles: a, b（豁免：…）`——占位 <待填：*> 不命中（fail-closed） */
 const EVIDENCE_LINE_RE = /^- (task-\d+):\s*(satisfied|missing|partial)\b([^\n]*)$/
 
-/** 回执行：`- claim: … | command: … | exit: 0 | log: path`——四字段行首锚定，占位不命中 */
-const RECEIPT_LINE_RE = /^- claim:\s*([^|]+)\|\s*command:\s*([^|]+)\|\s*exit:\s*(\d+)\s*\|\s*log:\s*([^\s|]+)/
+/**
+ * 回执行：`- claim: … | command: … | exit: 0 | log: path`——四字段行首锚定，占位不命中。
+ * 双宽度容收（坑 receipt-fullwidth-parse，2026-09-12 驾驭第十四批③，用户上一变更实证、
+ * 本次手动避开后要求修根：①分隔符同时认半角 | 与全角 ｜（中文输入法手写回执高频形态，
+ * 全角形态旧正则整行不命中 → 回执槽 0 条 → integration-critical 误报无绿回执）；
+ * ②log 字段 rest-of-line（旧 [^\s|+] 遇含空格/全角括号路径截断——`日志（第 1 次）.log`
+ * 被截成 `日志（第` → 「日志不存在」假红）；log 是末字段，行内若有 ｜/| 尾注取首段剥注。
+ */
+const RECEIPT_LINE_RE = /^- claim:\s*([^|｜\n]+)[|｜]\s*command:\s*([^|｜\n]+)[|｜]\s*exit:\s*(\d+)\s*[|｜]\s*log:\s*(.+)$/
 
 /**
  * 解析 verify-result.md 的两个受控槽段（D-001@v2 slot-backfill 录入界面）。
@@ -101,7 +108,7 @@ export function parseEvidenceSlots(mdText) {
         claim: m[1].trim(),
         command: m[2].trim(),
         exitCode: Number(m[3]),
-        logPath: m[4].trim().replace(/^`|`$/g, ''),
+        logPath: m[4].split(/[|｜]/)[0].trim().replace(/^`|`$/g, ''),
       })
     }
   }

package/src/verify-postcheck.js

@@ -88,7 +88,11 @@ export function extractTestCommand(yamlText) {
   if (quoted && quoted[1]) {
     return quoted[1].toLowerCase() === 'unavailable' ? null : quoted[1].trim()
   }
-  const bare = yamlText.match(/^\s*test:\s*([^\n#"']+?)\s*(?:#.*)?$/m)
+  // bare 值不得排除引号字符（坑 verify-bare-quote-miss，2026-09-12 审查批 B-③）：
+  // `test: cd "C:\proj" && npm test` 是合法 YAML 裸标量，旧 char class [^\n#"'] 对含引号值
+  // 整体不匹配 → 判「未配置」→ 实测硬门静默 skipped（fail-open）。全引号形态已被上方
+  // quoted 分支先行消费，此处的引号只可能是嵌在值中部的。同款修正在 extractLintCommand。
+  const bare = yamlText.match(/^\s*test:[ \t]*([^\n#]+?)[ \t]*(?:#.*)?$/m)
   if (bare && bare[1]) {
     const cmd = bare[1].trim()
     return cmd.toLowerCase() === 'unavailable' ? null : cmd
@@ -109,7 +113,7 @@ function extractLintCommand(yamlText) {
   if (quoted && quoted[1]) {
     return quoted[1].toLowerCase() === 'unavailable' ? null : quoted[1].trim()
   }
-  const bare = yamlText.match(/^\s*lint:\s*([^\n#"']+?)\s*(?:#.*)?$/m)
+  const bare = yamlText.match(/^\s*lint:[ \t]*([^\n#]+?)[ \t]*(?:#.*)?$/m)
   if (bare && bare[1]) {
     const cmd = bare[1].trim()
     return cmd.toLowerCase() === 'unavailable' ? null : cmd
@@ -154,7 +158,7 @@ function recordVerifyLintTally({ specBase, result }) {
  * advisory 起步：失败只打印不阻断（test 门已 fail-closed，lint 门观察期后再升级）。
  * 信任边界与 runVerifyTestCheck 一致：命令只来源于主仓 .sillyspec/local.yaml。
  */
-export function runVerifyLintCheck({ cwd, specBase }) {
+export function runVerifyLintCheck({ cwd, specBase, timeoutMs } = {}) {
   const localYamlPath = join(specBase, 'local.yaml')
   const yamlText = existsSync(localYamlPath) ? readFileSync(localYamlPath, 'utf8') : null
   const command = extractLintCommand(yamlText)
@@ -172,7 +176,9 @@ export function runVerifyLintCheck({ cwd, specBase }) {
     }
   }
 
-  const LINT_TIMEOUT_MS = Number(process.env.SILLYSPEC_LINT_TIMEOUT_MS) || 3 * 60 * 1000
+  // timeoutMs（2026-09-12 驾驭第十七批 dogfood）：门禁快照内 node_modules 经 junction I/O 较慢，
+  // 3min 默认预算实测被超时杀（180.1s 假败）——快照路径显式传 5min；优先级 显式参 > env > 默认
+  const LINT_TIMEOUT_MS = timeoutMs || Number(process.env.SILLYSPEC_LINT_TIMEOUT_MS) || 3 * 60 * 1000
   const startedAt = Date.now()
   let exitCode = 0
   let output = ''
@@ -577,7 +583,12 @@ export function extractModules(yamlText) {
  */
 function parseFlowValue(flowText, key) {
   // 键可能带引号也可能不带：path: "x" 或 "path": "x"
-  const re = new RegExp(String.raw`(?:^|[{,]\s*)"?${key}"?\s*:\s*("(?:[^"\\]|\\.)*"|'(?:[^'\\]|\\.)*'|(?:[^,}]+?))\s*(?=[,}]|$)`)
+  // bare 值的逗号终止是「下一键开始的逗号」而非任意逗号（坑 flow-value-comma-truncate，
+  // 2026-09-12 审查批 C-③）：`test: pytest -k a,b` 旧 [^,}]+? 在第一个逗号截断 → 实测跑
+  // 残损命令 `pytest -k a`（假红/碰巧假绿）。bare 分支与终止 lookahead 双侧同口径：只把
+  // 「后随键形态的逗号」当分隔符——消费侧负向前瞻排除它，终止侧正向前瞻要求它（或 } / 行尾）。
+  const sepComma = String.raw`,\s*"?[A-Za-z0-9_.\-]+"?\s*:`
+  const re = new RegExp(String.raw`(?:^|[{,]\s*)"?${key}"?\s*:\s*("(?:[^"\\]|\\.)*"|'(?:[^'\\]|\\.)*'|(?:[^,}]|,(?!${sepComma.slice(1)}))+?)\s*(?=\}|${sepComma}|$)`)
   const m = flowText.match(re)
   if (!m) return null
   let v = m[1].trim()
@@ -666,7 +677,11 @@ export function extractKnownFailures(yamlText) {
   // CRLF 归一（坑 verify-modules-crlf-blanket-fallback）：块式正则的 `.+`/`\n?` 在 CRLF 行
   // 间失配，只捕获到第一条豁免项就停——归一后整块捕获恢复
   const yaml = normalizeLineEndings(yamlText)
-  const inline = yaml.match(/^known_failures:\s*\[([^\]]*)\]\s*(?:#.*)?$/m)
+  // inline 捕获组用贪婪 .*（坑 known-failures-inline-nested-bracket，2026-09-12 审查批 C-④）：
+  // 旧 [^\]]* 在值内首个 ] 停——豁免项是 glob/pytest id 可含 [] 字符类（tests/\[x\]::case），
+  // 旧版整表静默清空 → 预存失败全落 remaining 假红且难归因。贪婪 .* + 后随 \] 行尾锚，
+  // 吃到最后一个 ]（行尾注释里含 ] 的极端形态会被并入值，远优于静默清空）。
+  const inline = yaml.match(/^known_failures:\s*\[(.*)\]\s*(?:#.*)?$/m)
   if (inline) {
     return inline[1].split(',').map(s => s.trim().replace(/^['"]|['"]$/g, '')).filter(Boolean)
   }
@@ -1148,6 +1163,26 @@ function resolveMainChangedFiles(cwd, changeName, specBase = null) {
           ? meta.worktreePath
           : cwd
         const files = runGitDiffNameOnly(gitDir, `${diffBase}..HEAD`)
+        // 坑 verify-evidence-account-diff-misses-committed-changes（2026-09-13 实证）：
+        // wt-commit 流程把本变更提交落在**主仓 HEAD**，worktree 分支不前移——仅查 worktree
+        // 侧 diffBase..HEAD 时已提交文件全部 miss（7 task diffHit=false 连环假红，verify 两连
+        // 阻断只能走人工豁免）。并集**主仓同区间** diff（对齐 wt-commit 产出形态，坑文档建议的
+        // 「change 基线 commit..HEAD」口径）；主仓区间含并行会话提交 → 过他者声明过滤
+        //（splitOwnVsForeignDiffFiles，与下方 fallback 同款）防 diffHit 假阳。主仓查询失败
+        // 不损原 worktree 结果。
+        if (files !== null && gitDir !== cwd) {
+          try {
+            const mainFiles = runGitDiffNameOnly(cwd, `${diffBase}..HEAD`)
+            if (Array.isArray(mainFiles)) {
+              const merged = [...new Set([...files, ...mainFiles])]
+              const { own, foreign } = splitOwnVsForeignDiffFiles(cwd, changeName, merged, { specBase: sb })
+              if (foreign.length > 0) {
+                console.warn(`⚠️ verify 对账（主仓区间并集）已排除 ${foreign.length} 个并行会话声明的文件：${foreign.slice(0, 5).map(x => `${x.file}←${x.owners[0]}`).join(', ')}${foreign.length > 5 ? ' 等' : ''}`)
+              }
+              return own
+            }
+          } catch { /* 主仓区间查询失败 → 保持 worktree 结果 */ }
+        }
         if (files !== null) return files
         // worktree diff 异常 → 落主仓兜底（保持与原 gitChangedFiles 相同的 null 语义）
       }