sillyspec 3.25.5 → 3.25.6

package/src/task-review.js

@@ -11,6 +11,10 @@
 import { existsSync, readFileSync, mkdirSync, writeFileSync, readdirSync, statSync } from 'fs'
 import { join, resolve } from 'path'
 import { execFileSync } from 'child_process'
+import { pathMatches } from './change-list.js'
+import { parseAllowedPaths } from './stages/plan-postcheck.js'
+import { resolveVerifyChangedFiles } from './verify-postcheck.js'
+import { WorktreeManager } from './worktree.js'
 
 // ── review.json schema version ──
 export const REVIEW_SCHEMA_VERSION = 1
@@ -258,6 +262,34 @@ export function readReview(reviewPath) {
   return { ok: true, review: parsed, errors: [] }
 }
 
+/**
+ * 校验 plan.md 里所有「已勾选 [x]」task 的 review.json 是否 schema 完整（坑 review-json-field-gap）。
+ *
+ * Task Review Gate（validateTaskReviews）只在 execute 整阶段完成时跑，单 task --done 不校验 →
+ * 子代理勾了 checkbox 却漏写/漏字段 review.json，要到收尾才暴露，用户被迫事后批量补。本函数供
+ * enforceReviewJsonGate 在每次 execute --done 调用：已勾 [x] = 声称完成 = 必有完整 review.json；
+ * 未勾 task 不校验（还没做）。readReview 已区分 missing/parseError/schemaError，这里只聚合。
+ *
+ * @param {{ planContent: string, runtimeRoot: string, executeRunId: string }} opts
+ * @returns {{ ok: boolean, failures: Array<{ taskId:string, reviewPath:string, kind:string, errors:string[] }> }}
+ *   kind ∈ missing（review.json 不存在）/ parseError（JSON 坏）/ schemaError（字段缺）
+ */
+export function validateCheckedTaskReviews({ planContent, runtimeRoot, executeRunId }) {
+  const failures = []
+  const re = /^\s*[-*]\s*\[x\]\s*task-(\d+)/gim
+  let m
+  while ((m = re.exec(planContent)) !== null) {
+    const taskId = `task-${m[1].padStart(2, '0')}`
+    const reviewPath = join(runtimeRoot, 'execute-runs', executeRunId, 'tasks', taskId, 'review.json')
+    const r = readReview(reviewPath)
+    if (!r.ok) {
+      const kind = r.parseError ? 'parseError' : (r.schemaError ? 'schemaError' : 'missing')
+      failures.push({ taskId, reviewPath, kind, errors: r.errors })
+    }
+  }
+  return { ok: failures.length === 0, failures }
+}
+
 /**
  * execute --done 时的 task review 总校验
  *
@@ -548,6 +580,133 @@ export function generateExecuteRunId() {
   return `exec-${now.getFullYear()}-${pad(now.getMonth() + 1)}-${pad(now.getDate())}-${pad(now.getHours())}${pad(now.getMinutes())}${pad(now.getSeconds())}`
 }
 
+/**
+ * worktree execute「主 agent 直接实现」模式收尾兜底：per-task review.json 缺失时，
+ * 据 git diff base..head 按 task allowed_paths 归属，自动落盘 cannot_verify 草稿。
+ *
+ * 根因（坑 worktree-execute-apply-friction 坑2）：per-task review.json 无程序化 writer，
+ * 全靠子代理手写；主 agent 统一实现强依赖链/机械 task 时不走子代理 review 流程 →
+ * review.json 全缺，execute --done 的 Task Review Gate 报「task-XX 缺少 review.json」阻断。
+ *
+ * 复用（与 Task Review Gate / verify 同源，单一真相）：
+ *   - resolveVerifyChangedFiles（worktree-aware，meta.json 为权威）→ base..head diff 文件集
+ *   - WorktreeManager.getMeta → baseHash（base）+ worktreePath（决定 head/gitDir，同 gates.js reviewGitDir）
+ *   - parseAllowedPaths + pathMatches（同 worktree-apply Gate2 口径）→ task 文件归属
+ *   - exec-id 解析同 gates.js:269 / autoCheckPlanFromReviews：current-execute-run-id-<change> marker，
+ *     缺失则 generateExecuteRunId + 落盘（保证草稿与后续 gate 读同一 run 目录）
+ *
+ * 行为：
+ *   - 仅 review.json 不存在时写（幂等，已有人工/子代理 verdict 一律跳过，绝不覆盖）
+ *   - changedFiles 为空的 task 不生成（verifyReviewGitEvidence 判空 diff 伪造，留给 agent）
+ *   - 草稿 verdict=cannot_verify + 非空 requiredEvidence（过 schema，流转 verify 阶段兑现）
+ *   - 不属任何 task 的文件累计 unattributed（顺带修复/非源码），不强塞某 task
+ *
+ * fail-open：任何异常 → 返回统计，仅 console.warn，不阻断 execute 完成（草稿是兜底，
+ * 缺了也只是退回原状——gate 报缺 review.json，agent 手补，不比修复前差）。
+ *
+ * @param {{ changeName: string, cwd: string, platformOpts?: object }} opts
+ * @returns {Promise<{ generated: number, skipped: number, unattributed: string[], reason?: string, executeRunId?: string }>}
+ */
+export async function generateTaskReviewDrafts({ changeName, cwd, platformOpts = {} }) {
+  const specBase = platformOpts.specRoot || join(cwd, '.sillyspec')
+  const runtimeRoot = platformOpts.runtimeRoot || join(specBase, '.runtime')
+  const changeDir = join(specBase, 'changes', changeName)
+  const tasksDir = join(changeDir, 'tasks')
+
+  if (!changeName) {
+    return { generated: 0, skipped: 0, unattributed: [], reason: '无 changeName' }
+  }
+  // 无 task 卡片目录 → 非多 task 变更，无需补草稿
+  if (!existsSync(tasksDir)) {
+    return { generated: 0, skipped: 0, unattributed: [], reason: '无 tasks/ 目录' }
+  }
+
+  // exec-id：与 Task Review Gate（gates.js:269）/ autoCheckPlanFromReviews 同源
+  const runIdFile = join(runtimeRoot, 'current-execute-run-id-' + changeName)
+  let executeRunId = ''
+  try { if (existsSync(runIdFile)) executeRunId = readFileSync(runIdFile, 'utf8').trim() } catch {}
+  if (!executeRunId) {
+    executeRunId = generateExecuteRunId()
+    try { mkdirSync(runtimeRoot, { recursive: true }); writeFileSync(runIdFile, executeRunId + '\n') } catch {}
+  }
+
+  // base..head diff 文件集（worktree-aware；null=git 不可用，[]=无 commit diff）
+  const diffFiles = resolveVerifyChangedFiles(cwd, changeName)
+  if (!diffFiles || diffFiles.length === 0) {
+    return { generated: 0, skipped: 0, unattributed: [], executeRunId, reason: 'base..head 无代码 diff（改动未 commit？）' }
+  }
+
+  // base/head + gitDir：与 gates.js reviewGitDir 同源（worktree 优先，in-place 回退 cwd）
+  let base = null
+  let head = null
+  let reviewGitDir = cwd
+  try {
+    const wm = new WorktreeManager({ cwd })
+    const meta = wm.getMeta(changeName)
+    base = (meta && (meta.baselineCommit || meta.baseHash)) || null
+    if (meta && meta.worktreePath && meta.mode !== 'in-place-fallback' && existsSync(meta.worktreePath)) {
+      reviewGitDir = meta.worktreePath
+    }
+  } catch {}
+  if (!base) {
+    return { generated: 0, skipped: 0, unattributed: diffFiles, executeRunId, reason: '无 worktree meta.baseHash（无法定 base/head）' }
+  }
+  try {
+    head = runGit(reviewGitDir, ['rev-parse', 'HEAD'])
+  } catch {
+    return { generated: 0, skipped: 0, unattributed: diffFiles, executeRunId, reason: 'git rev-parse HEAD 失败（' + reviewGitDir + '）' }
+  }
+
+  const taskFiles = readdirSync(tasksDir).filter(f => /^task-\d+\.md$/.test(f)).sort()
+  let generated = 0
+  let skipped = 0
+  const attributed = new Set()
+
+  for (const tf of taskFiles) {
+    const taskId = tf.replace(/\.md$/, '')
+    const reviewDir = join(runtimeRoot, 'execute-runs', executeRunId, 'tasks', taskId)
+    const reviewPath = join(reviewDir, 'review.json')
+
+    // 幂等：review.json 已存在（无论合法/解析错/schema 错）一律跳过，绝不覆盖人工/子代理 verdict
+    const existing = readReview(reviewPath)
+    if (existing.ok || existing.parseError || existing.schemaError) {
+      skipped++
+      continue
+    }
+
+    const content = readFileSync(join(tasksDir, tf), 'utf8')
+    const allowedPaths = parseAllowedPaths(content)
+    const changedFiles = allowedPaths.length > 0
+      ? diffFiles.filter(f => allowedPaths.some(p => pathMatches(f, p)))
+      : []
+
+    // 空 changedFiles 的 task 不生成（verifyReviewGitEvidence 判空 diff 伪造，留给 agent 手补）
+    if (changedFiles.length === 0) {
+      skipped++
+      continue
+    }
+    changedFiles.forEach(f => attributed.add(f))
+
+    const draft = {
+      schemaVersion: REVIEW_SCHEMA_VERSION,
+      task: taskId,
+      base,
+      head,
+      changedFiles,
+      specVerdict: 'cannot_verify',
+      qualityVerdict: 'cannot_verify',
+      requiredEvidence: ['auto-generated draft: 待 agent 对照 ' + taskId + ' brief + diff 复核后升级为 pass/fail'],
+      reviewerNotes: 'auto-generated draft from git diff ' + base.slice(0, 8) + '..' + head.slice(0, 8) + ';verdict=未评审（worktree execute 主 agent 实现模式兜底，坑2）',
+    }
+    mkdirSync(reviewDir, { recursive: true })
+    writeFileSync(reviewPath, JSON.stringify(draft, null, 2) + '\n')
+    generated++
+  }
+
+  const unattributed = diffFiles.filter(f => !attributed.has(f))
+  return { generated, skipped, unattributed, executeRunId }
+}
+
 /**
  * 获取当前（或最新）execute run id
  * 从 runtime 目录下查找 execute-runs/ 子目录

package/src/verify-postcheck.js

@@ -19,6 +19,7 @@ import { execSync } from 'child_process'
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'fs'
 import { join } from 'path'
 import { verifyApiParity } from './contract-matrix.js'
+import { parseFileChangeListDetailed, pathMatches } from './change-list.js'
 
 // 测试命令最长执行时间；超时视为失败（防止 CLI 被挂起的测试卡死）
 const TEST_TIMEOUT_MS = Number(process.env.SILLYSPEC_TEST_TIMEOUT_MS) || 10 * 60 * 1000
@@ -289,9 +290,20 @@ export function judgeWithKnownFailures(exitCode, output, baseReason, knownFailur
       exemptedCount: exempted.length,
     }
   }
-  const detail = remaining.length > 0
-    ? `${remaining.length} 个失败行未命中 known_failures`
-    : '失败输出未检测到可豁免的失败行（保守判 fail）'
+  // 剩余未豁免失败行：列出具体行 + 预存债指引（坑 verify-known-failures-stale-list）。
+  // known_failures 清单常滞后于新预存测试 → 同源预存债漏入清单,agent 跑完才发现要手动补。
+  // 这里点出具体未命中行,让 agent 一眼分辨"补清单 vs 修代码",不替它判断（确定性:列已算出的 remaining）。
+  let detail
+  if (remaining.length > 0) {
+    const sample = remaining.slice(0, 5).map(l => {
+      const t = String(l).trim()
+      return t.length > 120 ? t.slice(0, 120) + '…' : t
+    })
+    const more = remaining.length > 5 ? `\n     …（其余 ${remaining.length - 5} 行见上方测试输出）` : ''
+    detail = `${remaining.length} 个失败行未命中 known_failures 清单：\n     - ${sample.join('\n     - ')}${more}\n   → 若是预存债（变更前就失败），加入 local.yaml 的 known_failures 清单；若是本次变更引入的真实失败，请修复`
+  } else {
+    detail = '失败输出未检测到可豁免的失败行（保守判 fail）'
+  }
   return {
     status: 'failed',
     reason: baseReason ? `${baseReason}（${detail}）` : detail,
@@ -373,6 +385,24 @@ function runGitDiffNameOnly(cwd, refSpec) {
   }
 }
 
+/**
+ * 在指定 cwd 跑 `git diff --name-status <refSpec>`，返回原始文本（调用方按行解析，
+ * 保留状态字母 D/R/C 供删除探针识别删除/重命名）。git 不可用 / 非仓库 / ref 无效 → 返回 null。
+ */
+function runGitDiffNameStatus(cwd, refSpec) {
+  try {
+    const cmd = refSpec ? `git diff --name-status ${refSpec}` : 'git diff --name-status'
+    return execSync(cmd, {
+      cwd,
+      encoding: 'utf8',
+      timeout: 30 * 1000,
+      stdio: ['ignore', 'pipe', 'pipe'],
+    })
+  } catch {
+    return null
+  }
+}
+
 /**
  * 取主工作区 git 变更文件列表（unstaged + staged，相对仓库根）。
  * `git diff --name-only HEAD` 同时覆盖已暂存与未暂存改动（相对 HEAD），
@@ -715,3 +745,118 @@ export function printVerifyParityCheck(result) {
   if (result.missingBackend.length > 20) console.warn(`   …还有 ${result.missingBackend.length - 20} 个`)
   console.warn('   提示：检查是否后端漏实现，或前端调用了尚未实现的端点。确认无误可在 design.md 标注豁免。')
 }
+
+/**
+ * 删除探针（advisory）：用 git 事实客观对账本次变更删除的文件 vs design.md 声明的操作。
+ *
+ * 切斯特顿栅栏护栏——verify 对「agent 静默删除代码」本是盲区：agent 删一段它看不懂的
+ * 旧代码，只要路径合规、不碰风险关键词，5 探针 + 风险分级 + 测试对账全都不会响。本探针
+ * 不信任 agent 自报告，用 `git diff --name-status HEAD` 客观提取删除文件，对账 design
+ * 清单声明的操作（声明「新增/修改」却整文件删除 = 高风险）。warning 不阻断 verify 完成
+ * （advisory 起步）——「检测到删除」是确定性事实（做），「该不该删」是意图（只报不拦）。
+ *
+ * 信号源：apply（git apply --3way）不 commit，verify 时主仓 HEAD 仍是变更前 commit，
+ * 删除的文件在工作树消失但仍在 HEAD → `git diff --name-status HEAD` 显示 D。
+ *
+ * @param {object} opts
+ * @param {string} opts.cwd - 项目根（主仓，代码在此）
+ * @param {string} opts.specBase - .sillyspec（或平台 specRoot）
+ * @param {string|null} [opts.changeName]
+ * @returns {{
+ *   status: 'skipped'|'warning'|'passed',
+ *   highRisk: Array<{path:string, declaredOp:string, reason:string}>,
+ *   mediumRisk: Array<{path:string, reason:string}>,
+ *   compliant: Array<{path:string, declaredOp:string}>,
+ *   summary: string,
+ *   reason: string|null,
+ * }}
+ */
+export function runVerifyDeletionCheck({ cwd, specBase, changeName = null }) {
+  const statusRaw = runGitDiffNameStatus(cwd, 'HEAD')
+  if (statusRaw === null) {
+    return { status: 'skipped', highRisk: [], mediumRisk: [], compliant: [],
+      summary: '', reason: 'git 不可用或非仓库，删除对账跳过' }
+  }
+
+  // 解析 D（删除）；R/C 的旧路径等价删除（防御 committed rename；标准 apply 流程
+  // rename 表现为纯 D，故本探针不加 -M，D 统一处理）。
+  const deletions = []
+  for (const line of statusRaw.split('\n').filter(Boolean)) {
+    const parts = line.split('\t')
+    const st = parts[0]
+    if (!st) continue
+    if (st.startsWith('D')) {
+      deletions.push({ path: parts[1], kind: 'D' })
+    } else if ((st.startsWith('R') || st.startsWith('C')) && parts.length >= 3) {
+      // rename/copy 旧路径（parts[1]）等价删除，新路径 parts[2]
+      deletions.push({ path: parts[1], kind: 'R-old', renamedTo: parts[2] })
+    }
+  }
+
+  // 排除交付物外文件（.sillyspec/ 文档 churn + meta.json），避免污染删除信号。
+  // 内联 filterDeliverableFiles 逻辑（一行，不跨模块耦合）。
+  const deliverable = deletions.filter(d =>
+    !d.path.startsWith('.sillyspec/') && d.path !== 'meta.json')
+
+  if (deliverable.length === 0) {
+    return { status: 'skipped', highRisk: [], mediumRisk: [], compliant: [],
+      summary: '', reason: '本次变更无文件删除（或改动已被 commit，主仓 HEAD 已推进，删除对账无锚点）' }
+  }
+
+  // 读 design 声明（operation）。无清单章节 → []，所有删除归「未声明」。
+  const designPath = changeName
+    ? join(specBase, 'changes', changeName, 'design.md') : null
+  const designEntries = designPath && existsSync(designPath)
+    ? parseFileChangeListDetailed(designPath) : []
+
+  const highRisk = []
+  const mediumRisk = []
+  const compliant = []
+  for (const d of deliverable) {
+    const hit = designEntries.find(e => pathMatches(d.path, e.path))
+    if (!hit) {
+      mediumRisk.push({ path: d.path, reason: d.kind === 'R-old'
+        ? `重命名源文件未在 design 清单（→ ${d.renamedTo}）`
+        : 'design 清单未列出该删除文件' })
+      continue
+    }
+    if (hit.operation === '新增' || hit.operation === '修改') {
+      highRisk.push({ path: d.path, declaredOp: hit.operation,
+        reason: `design 声明「${hit.operation}」但 git 显示整文件删除` })
+    } else if (hit.operation === '删除') {
+      compliant.push({ path: d.path, declaredOp: '删除' })
+    } else {
+      // operation=null（未声明操作）或 重命名：删除发生但声明不明确
+      mediumRisk.push({ path: d.path,
+        reason: `design 列出但操作为「${hit.operation || '未声明'}」，与删除不一致` })
+    }
+  }
+
+  if (highRisk.length > 0 || mediumRisk.length > 0) {
+    return { status: 'warning', highRisk, mediumRisk, compliant,
+      summary: `${highRisk.length} 个高风险删除 + ${mediumRisk.length} 个未声明删除`, reason: null }
+  }
+  return { status: 'passed', highRisk: [], mediumRisk: [], compliant,
+    summary: `所有 ${compliant.length} 个删除均在 design 声明为「删除」`, reason: null }
+}
+
+/** 打印删除对账结果（advisory，不阻断 verify 完成） */
+export function printVerifyDeletionCheck(result) {
+  if (result.status === 'skipped') return  // 静默：无删除 / git 不可用 / 改动已 commit
+  if (result.status === 'passed') {
+    console.log(`\n✅ 删除对账通过：${result.summary}`)
+    return
+  }
+  // warning
+  if (result.highRisk.length > 0) {
+    console.warn(`\n⚠️  删除对账发现 ${result.highRisk.length} 个高风险删除（design 声明新增/修改却被整文件删除，advisory 不阻断）：`)
+    for (const m of result.highRisk.slice(0, 20)) console.warn(`   - ${m.path}  (${m.reason})`)
+    if (result.highRisk.length > 20) console.warn(`   …还有 ${result.highRisk.length - 20} 个`)
+  }
+  if (result.mediumRisk.length > 0) {
+    console.warn(`⚠️  ${result.mediumRisk.length} 个未声明删除（design 清单未列出 / 操作不一致）：`)
+    for (const m of result.mediumRisk.slice(0, 20)) console.warn(`   - ${m.path}  (${m.reason})`)
+    if (result.mediumRisk.length > 20) console.warn(`   …还有 ${result.mediumRisk.length - 20} 个`)
+  }
+  console.warn('   提示：确认删除是否预期。预期删除请在 design.md 清单用「删除」操作显式声明；误删请恢复。')
+}

package/src/worktree-apply.js

@@ -18,7 +18,8 @@ import { join, resolve } from 'path';
 import { tmpdir } from 'os';
 import { createHash } from 'crypto';
 import { WorktreeManager } from './worktree.js';
-import { parseFileChangeList, pathMatches } from './change-list.js';
+import { parseFileChangeList, parseFileChangeListDetailed, pathMatches } from './change-list.js';
+import { parseAllowedPaths } from './stages/plan-postcheck.js';
 
 const CHANGES_REL = '.sillyspec/changes';
 
@@ -190,7 +191,9 @@ export function applyWorktree(changeName, { cwd, checkOnly = false, merge = fals
       result.errors.push(
         `文件清单校验失败：以下变更文件不在 design.md 清单中：\n  ${violations.join('\n  ')}`
       );
-      return result;
+      // checkOnly（assess）模式不短路：继续跑 Gate3，收集所有道供一次报全（坑 worktree-execute-apply-friction 坑4）。
+      // 真实 apply（checkOnly=false）仍短路，保安全。
+      if (!checkOnly) return result;
     }
   }
 
@@ -228,7 +231,7 @@ export function applyWorktree(changeName, { cwd, checkOnly = false, merge = fals
         `execute 前 baseline: ${meta.baselineHash}\n` +
         `当前 baseline: ${currentHash}`
       );
-      return result;
+      if (!checkOnly) return result; // checkOnly 收集不短路（一次报全）；真实 apply 短路
     }
   }
 
@@ -243,7 +246,7 @@ export function applyWorktree(changeName, { cwd, checkOnly = false, merge = fals
       result.errors.push(
         `主工作区有以下未 commit 的变更，会影响 apply：\n  ${conflictDirty.join('\n  ')}\n请先 commit 或 stash 这些变更。`
       );
-      return result;
+      if (!checkOnly) return result; // checkOnly 收集不短路（一次报全）；真实 apply 短路
     }
   }
 
@@ -518,19 +521,18 @@ export function assessApplyRisk(changeName, { cwd } = {}) {
   // 先跑 --check-only 模式的 applyWorktree 获取变更文件列表
   const checkResult = applyWorktree(changeName, { cwd: projectRoot, checkOnly: true });
 
-  if (checkResult.errors.length > 0) {
-    return {
-      decision: 'BLOCKED',
-      changedFiles: checkResult.changedFiles,
-      reasons: checkResult.errors,
-      warnings: [],
-      stats: { additions: 0, deletions: 0 }
-    };
-  }
+  // applyWorktree(checkOnly) 已收集所有道（Gate1/3 不短路）——其 errors 纳入 reasons，
+  // 继续跑 Gate2/4/6 一次报全（坑 worktree-execute-apply-friction 坑4：原此处提前 return 致逐道挤牙膏）。
+  reasons.push(...checkResult.errors);
+  if (checkResult.warnings?.length) warnings.push(...checkResult.warnings);
 
   const changedFiles = checkResult.changedFiles;
 
   if (changedFiles.length === 0) {
+    // 无变更：若仍有 Gate 错误（如主区 dirty）则 BLOCKED，否则 SAFE
+    if (reasons.length > 0) {
+      return { decision: 'BLOCKED', changedFiles: [], reasons, warnings, stats: { additions: 0, deletions: 0 } };
+    }
     return {
       decision: 'SAFE',
       changedFiles: [],
@@ -540,36 +542,39 @@ export function assessApplyRisk(changeName, { cwd } = {}) {
     };
   }
 
-  // 解析 TaskCard allowed_paths
+  // 解析 TaskCard allowed_paths（复用 plan-postcheck.parseAllowedPaths，消除内联重复实现漂移）
   const wm = new WorktreeManager({ cwd: projectRoot });
   const meta = wm.getMeta(changeName);
   const tasksDir = join(projectRoot, CHANGES_REL, changeName, 'tasks');
   const allowedPaths = new Set();
   if (existsSync(tasksDir)) {
     for (const tf of readdirSync(tasksDir).filter(f => /^task-\d+\.md$/.test(f))) {
-      const content = readFileSync(join(tasksDir, tf), 'utf8');
-      const fmMatch = content.match(/^---\n([\s\S]*?)\n---/);
-      if (!fmMatch) continue;
-      const fm = fmMatch[1];
-      const inline = fm.match(/allowed_paths:\s*\[([^\]]*)\]/);
-      if (inline) {
-        inline[1].split(',').forEach(s => { const v = s.trim().replace(/['"]/g, ''); if (v) allowedPaths.add(v); });
-      }
-      const block = fm.match(/allowed_paths:\s*\n((?:\s+-\s+.+\n?)+)/);
-      if (block) {
-        block[1].match(/-\s+(.+)/g)?.forEach(s => { const v = s.replace(/^-\s+/, '').trim().replace(/['"]/g, ''); if (v) allowedPaths.add(v); });
+      for (const p of parseAllowedPaths(readFileSync(join(tasksDir, tf), 'utf8'))) {
+        if (p) allowedPaths.add(p);
       }
     }
   }
 
-  // 检查 2: 变更在 allowed_paths 内（仅在 TaskCard 存在时）
+  // design §6 标记为「顺带修复」的文件（坑 worktree-execute-apply-friction 坑1）：合规修预存债，
+  // 不属任何 task 边界，assess 豁免 allowed_paths 严格校验（降级 warning），避免被迫 cherry-pick 绕过。
+  const designPath = join(projectRoot, CHANGES_REL, changeName, 'design.md');
+  const incidentalSet = new Set(
+    parseFileChangeListDetailed(designPath).filter(e => e.incidental).map(e => e.path)
+  );
+
+  // 检查 2: 变更在 allowed_paths 内（仅在 TaskCard 存在时）；顺带修复文件豁免。
+  // 匹配换 pathMatches（与 Gate1/plan-postcheck 同语义容差），消除原字面前缀弱匹配漂移。
   if (allowedPaths.size > 0) {
-    const outsidePaths = changedFiles.filter(f => !
-      [...allowedPaths].some(allowed => f === allowed || f.startsWith(allowed.replace(/\*$/, '')))
-    );
+    const isIncidental = f => [...incidentalSet].some(ap => pathMatches(f, ap));
+    const outsideAll = changedFiles.filter(f => ![...allowedPaths].some(allowed => pathMatches(f, allowed)));
+    const outsidePaths = outsideAll.filter(f => !isIncidental(f));
+    const exempted = outsideAll.filter(f => isIncidental(f));
     if (outsidePaths.length > 0) {
       reasons.push(`变更文件超出 allowed_paths：\n  ${outsidePaths.join('\n  ')}`);
     }
+    if (exempted.length > 0) {
+      warnings.push(`顺带修复文件（已豁免 allowed_paths，来源 design §6 标记）：${exempted.join(', ')}`);
+    }
   }
 
   // 检查 4+5: 高风险文件模式

package/templates/prompts/verify-probes.md

@@ -1,5 +1,5 @@
 ### 自动探针（必须先执行）
-在检查前，依次运行以下三个探针，将结果作为验证输入：
+在检查前，依次运行以下六个探针，将结果作为验证输入：
 
 **探针 1：未实现标记扫描（仅变更文件）**
 只扫描本次变更涉及的文件，不要全项目扫描——历史 TODO 与本次变更无关，徒增噪音与 token。变更文件 = design.md「文件变更清单」列出的源码文件（你已在「加载规范」步骤读取 design.md，glob 路径需展开为具体文件）：
@@ -18,7 +18,7 @@ grep -rl "<关键词>" <源码目录>/ --include="*.java" --include="*.js" --inc
 
 **探针 3：验收标准测试覆盖探针**
 1. 读取变更目录下的 tasks.md，提取所有 checkbox 任务
-2. 对每个 task，检查对应模块目录下是否存在测试文件（*test*、*spec*、*Test*、*Spec*）
+2. 对每个 task，**递归**检查对应模块目录及其**所有子目录**下是否存在测试文件（*test*、*spec*、*Test*、*Spec*）——包括模块内 co-located 的 tests/ 目录（如 `backend/app/modules/*/tests/`），**不要只看顶层 `tests/`**，否则会把测试就在模块内部的项目误判为“无测试”
 3. 没有测试文件的 task 标记为 ⚠️ 缺少测试
 
 **探针 4：决策追踪覆盖探针（如存在 decisions.md）**
@@ -51,3 +51,14 @@ grep -rl "<关键词>" <源码目录>/ --include="*.java" --include="*.js" --inc
    | ❌ missing | GET /api/ppm/project-plan/{param}/plan-nodes | — | frontend/src/lib/ppm/plan.ts |
 
 如果发现 Missing backend endpoint，必须在验证报告中标记为 ❌ contract gap。
+
+**探针 6：代码删除对账（切斯特顿栅栏护栏）**
+静默删除代码是 verify 的盲区——agent 删一段它看不懂的旧代码，只要路径合规、不碰风险关键词，其他探针都不会响。用 git 事实客观对账，不要凭记忆：
+1. 运行 `git diff --name-status HEAD`（本次变更已 apply 到主仓、未 commit，删除的文件在工作树消失但仍在 HEAD，显示 `D`）
+2. 筛出状态以 `D` 开头的行（删除）；`R`/`C` 开头的旧路径等价删除
+3. 对每个删除文件，核对 design.md「文件变更清单」声明的操作：
+   - design 声明「删除」→ ✅ 合规（预期删除）
+   - design 声明「新增/修改」却整文件删除 → ❌ 高风险（声明与事实矛盾）
+   - design 清单未列出 → ⚠️ 未声明删除
+4. 排除 `.sillyspec/` 与 `meta.json`（文档 churn 不算删除信号）
+5. verify --done 时 CLI 会用同一 git 事实独立复核，谎报无效——务必如实记录