sillyspec 3.25.4 → 3.25.6

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 } from './change-list.js';
+import { parseFileChangeList, parseFileChangeListDetailed, pathMatches } from './change-list.js';
+import { parseAllowedPaths } from './stages/plan-postcheck.js';
 
 const CHANGES_REL = '.sillyspec/changes';
 
@@ -48,6 +49,20 @@ export function filterDeliverableFiles(files) {
   return files.filter(f => !f.startsWith('.sillyspec/') && f !== 'meta.json');
 }
 
+/**
+ * 校验变更文件是否都在 design.md 清单内——容差匹配（与 plan-postcheck validateDesignFileCoverage
+ * 同语义）：design 清单写 glob（双星通配）或目录前缀（如 src/ 子树）也能覆盖 git diff 出的具体路径，
+ * 避免「plan 阶段放过、apply 阶段卡死」逼用户回去补字面文件名。
+ *
+ * @param {string[]} changedFiles  git diff 出的具体变更路径
+ * @param {Set<string>} allowSet   design.md 清单项（可能含 glob / 目录前缀）
+ * @returns {string[]} 不被任何清单项覆盖的文件（违规项，apply 将据此 BLOCK）
+ */
+export function classifyAllowListViolations(changedFiles, allowSet) {
+  const allow = [...allowSet];
+  return changedFiles.filter(f => !allow.some(ap => pathMatches(f, ap)));
+}
+
 /**
  * 批量获取多个文件在某个 treeish 中的 blob hash（一次 git ls-tree 替代 N 次 rev-parse）。
  *
@@ -170,29 +185,32 @@ export function applyWorktree(changeName, { cwd, checkOnly = false, merge = fals
 
   // --- 4. 校验：变更文件 ⊆ 清单（无清单则跳过）---
   if (hasAllowList) {
-    for (const f of changedFiles) {
-      if (!allowSet.has(f)) {
-        result.extraFiles.push(f);
-      }
-    }
-    if (result.extraFiles.length > 0) {
+    const violations = classifyAllowListViolations(changedFiles, allowSet);
+    if (violations.length > 0) {
+      result.extraFiles.push(...violations);
       result.errors.push(
-        `文件清单校验失败：以下变更文件不在 design.md 清单中：\n  ${result.extraFiles.join('\n  ')}`
+        `文件清单校验失败：以下变更文件不在 design.md 清单中：\n  ${violations.join('\n  ')}`
       );
-      return result;
+      // checkOnly（assess）模式不短路：继续跑 Gate3，收集所有道供一次报全（坑 worktree-execute-apply-friction 坑4）。
+      // 真实 apply（checkOnly=false）仍短路，保安全。
+      if (!checkOnly) return result;
     }
   }
 
-  // --- 4.5 校验：主工作区 baseline 是否变化（防 execute 期间主工作区被修改）---
-  // 注意：必须和 computeBaselineHash (worktree.js) 使用相同的排除规则。
+  // --- 4.6 显式 --merge：用户显式选择 git merge 兜底（主干已提交推进重叠时的三方合并） ---
+  // 触发点从「4.5 baseline 漂移自动降级」改为「用户显式 --merge flag」（D-001 保留，触发方式变化）。
+  // 用 --merge 时跳过未提交 dirty 拦截——merge 同样要求工作区相对干净，此处仅提示风险，真正失败由 applyByMerge 报告。
+  if (merge && !checkOnly) {
+    return applyByMerge(result, changeName, projectRoot, wm);
+  }
+
+  // --- 4.5 校验：主工作区是否有「未提交」脏改动（未提交 dirty 是 git apply --3way 危险区，必须拦）---
+  // 分工：4.5（整树 baselineHash）+ 5a（脏∩changedFiles）挡「未提交」dirty；5b 管「已提交」HEAD 分叉（已放宽，见下）。
+  // 实测：主干未提交 dirty 时，git apply --3way 报 `does not match index` 且行为不一致（可能报错/可能半应用，
+  // 哪怕脏文件与 patch 不重叠）——这是 git 硬约束，故此处友好拦截，引导用户先 commit/stash。
   // 排除非交付物的元数据/文档 churn（execute 自身改的 + 多操作者常改的 agent 指引/文档），
   // 否则别人改 CLAUDE.md/docs/.claude → 整树 hash 变 → apply 误阻断（多操作者仓库高频踩坑）。
-  // 安全：放过它们不丢真冲突——下方 step5a(未提交∩changedFiles)+step5b(HEAD blob) 对交付文件
-  // 做精确 per-file 校验，不读这里的 exclude。
-  //   - .sillyspec/：plan/design 蓝图 + runtime 产物
-  //   - .claude/：agent 配置/skills/CLAUDE.md
-  //   - docs/：文档（deliverable 文档冲突由 step5a/5b 兜底）
-  //   - CLAUDE.md：根 agent 指引
+  // 注意：必须和 computeBaselineHash (worktree.js) 使用相同的排除规则。
   if (meta.baselineHash) {
     const exclude = '-- . ":(exclude).sillyspec/" ":(exclude).claude/" ":(exclude)docs/" ":(exclude)CLAUDE.md"';
     const staged = gitQuiet(projectRoot, `diff --cached ${exclude}`) || '';
@@ -201,17 +219,19 @@ export function applyWorktree(changeName, { cwd, checkOnly = false, merge = fals
     const raw = `staged:${staged}\nunstaged:${unstaged}\nuntracked:${untracked}`;
     const currentHash = createHash('sha256').update(raw).digest('hex').slice(0, 16);
     if (currentHash !== meta.baselineHash) {
-      if (merge && !checkOnly) {
-        // baseline 漂移 + --merge 降级（D-001）：跳过步骤 5-7（patch 路径），走 git merge
-        return applyByMerge(result, changeName, projectRoot, wm);
-      }
+      // 未提交 dirty 拦截：列脏文件 + 指引先 commit/stash（git --3way 对 dirty 工作区不稳，merge 同理，故不再提 --merge）
+      const dirtyFiles = [...new Set(
+        ((gitQuiet(projectRoot, 'diff --name-only HEAD') || '').split('\n').filter(Boolean))
+          .concat((gitQuiet(projectRoot, 'ls-files --others --exclude-standard') || '').split('\n').filter(Boolean))
+      )].filter(f => !f.startsWith('.sillyspec/') && f !== 'meta.json');
       result.errors.push(
-        `主工作区 baseline 已变化（execute 前后不一致），不能直接 apply task.patch。\n` +
-        `建议：重新创建 worktree，或用 --merge 降级（git merge sillyspec/${changeName} 替代 patch，会引入合并提交）。\n` +
+        `主工作区有未提交的改动（execute 前后 baseline 不一致），git apply 无法安全应用。\n` +
+        (dirtyFiles.length > 0 ? `未提交文件：\n  ${dirtyFiles.join('\n  ')}\n` : '') +
+        `请先提交或暂存这些改动，再重新 apply：\n  git add -A && git commit -m "..."   或   git stash\n` +
         `execute 前 baseline: ${meta.baselineHash}\n` +
         `当前 baseline: ${currentHash}`
       );
-      return result;
+      if (!checkOnly) return result; // checkOnly 收集不短路（一次报全）；真实 apply 短路
     }
   }
 
@@ -226,13 +246,17 @@ 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 短路
     }
   }
 
   // 5b. 对比 worktree 的 baseHash 和主工作区 HEAD 中每个清单文件的 blob hash
   // 批量化：两次 ls-tree（worktree 的 baseHash + 主仓库 HEAD）各建一张 path→hash Map，
   // 替代 per-file getFileBlobHash × 2（原 2N spawn → 固定 2）。语义等价见 getBlobHashMap。
+  // 放宽（2026-07）：blob 不一致不再 BLOCKED——它意味着主干「已提交」推进改了同文件，
+  // 而 git apply --3way 能自动三路合并这种场景（不同区域直接合，同区域留冲突标记）。
+  // 故仅记录为风险提示（hashMismatchFiles → assess WARNING / summary 展示），放行交 step7 --3way 实测。
+  // 真重叠时 --3way 冲突，由 step7 回滚并提示 --merge 兜底。
   const targetFiles = hasAllowList ? [...allowSet] : changedFiles;
   const wtHashMap = getBlobHashMap(worktreePath, baseHash, targetFiles);
   const mainHashMap = getBlobHashMap(projectRoot, 'HEAD', targetFiles);
@@ -244,17 +268,10 @@ export function applyWorktree(changeName, { cwd, checkOnly = false, merge = fals
     if (wtBlob === null && mainBlob === null) continue;
     // 两者一致 → OK
     if (wtBlob === mainBlob) continue;
-    // 不一致 → 主工作区已被修改
+    // 不一致 → 主干已提交推进改了此文件，记风险提示（不拦截，交 --3way）
     result.hashMismatchFiles.push(f);
   }
 
-  if (result.hashMismatchFiles.length > 0) {
-    result.errors.push(
-      `base hash 不一致：以下文件在主工作区已被修改：\n  ${result.hashMismatchFiles.join('\n  ')}`
-    );
-    return result;
-  }
-
   // --- 6. checkOnly 模式：到此返回 ---
   if (checkOnly) {
     result.ok = true;
@@ -323,19 +340,33 @@ export function applyWorktree(changeName, { cwd, checkOnly = false, merge = fals
 
     writeFileSync(patchPath, patchContent);
 
-    // apply --check 预检
-    try {
-      git(projectRoot, `apply --check ${patchPath}`);
-    } catch (e) {
-      result.errors.push(`patch 预检失败: ${e.message}`);
-      return result;
-    }
+    // apply --check 预检失败不再拦截（--check 只测 clean apply，--3way 能处理 clean apply 失败的
+    // 三路合并场景——主干已提交推进时 --check 恒失败但 --3way 可合）。故跳过 --check，直接试 --3way。
+
+    // 回滚准备：记录 patch 涉及的 tracked 文件（--3way 冲突后需恢复 HEAD 版，不留半成品冲突标记）。
+    // tracked 文件冲突 → git checkout -- <f> 还原；untracked 新建文件（--3way 不会对其冲突）不在回滚范围，
+    // 但若 --3way 部分成功后冲突，已创建的新文件需删，故记录 untracked 集合。
+    const trackedPatchFiles = patchFiles.filter(f => {
+      // 该文件在主仓库 HEAD 存在 → 是 tracked（--3way 冲突时留标记需 checkout 还原）
+      return gitQuiet(projectRoot, `cat-file -e HEAD:${f}`) === null ? false : true;
+    });
+    const newPatchFiles = patchFiles.filter(f => !trackedPatchFiles.includes(f));
 
-    // apply --3way 正式应用
+    // apply --3way 正式应用（主干已提交推进时自动三路合并）
     try {
       git(projectRoot, `apply --3way ${patchPath}`);
     } catch (e) {
-      result.errors.push(`patch apply 失败: ${e.message}`);
+      // --3way 冲突（exit 1，工作区已留冲突标记）：回滚到 apply 前干净状态，不留半成品
+      const rollback = rollbackApply(projectRoot, trackedPatchFiles, newPatchFiles);
+      result.errors.push(
+        `apply --3way 冲突：以下文件与主干「已提交」推进重叠，无法自动合并：\n` +
+        `  ${rollback.conflicts.length > 0 ? rollback.conflicts.join('\n  ') : '(未能获取冲突文件列表)'}\n` +
+        `已回滚工作区到 apply 前状态（无半成品冲突标记）。\n` +
+        `可选：用 --merge 自动三方合并兜底（git merge sillyspec/${changeName}，会引入合并提交）：\n` +
+        `  sillyspec worktree apply ${changeName} --merge\n` +
+        `或手动解决后重试。`
+      );
+      if (rollback.error) result.warnings = (result.warnings || []).concat([`回滚警告: ${rollback.error}`]);
       return result;
     }
 
@@ -360,6 +391,40 @@ export function applyWorktree(changeName, { cwd, checkOnly = false, merge = fals
   return result;
 }
 
+/**
+ * 回滚 --3way 冲突后的工作区到 apply 前状态（不留半成品冲突标记）。
+ * tracked 文件：git checkout -- <f> 还原 HEAD 版（清除冲突标记）。
+ * 新文件（apply 前不存在）：删除（--3way 可能部分创建）。
+ * @param {string} projectRoot
+ * @param {string[]} trackedFiles 主仓库 HEAD 已存在、patch 触及的文件
+ * @param {string[]} newFiles apply 前不存在、patch 可能新建的文件
+ * @returns {{ conflicts: string[], error: string|null }} conflicts=冲突文件列表
+ */
+function rollbackApply(projectRoot, trackedFiles, newFiles) {
+  let error = null;
+  // 冲突文件：git status 里带冲突标记（UU/AA 等）的文件
+  let conflicts = [];
+  try {
+    const unmerged = gitQuiet(projectRoot, 'diff --name-only --diff-filter=U') || '';
+    conflicts = unmerged.split('\n').filter(Boolean);
+  } catch {}
+  // 回滚 tracked 文件到 HEAD（强制从 HEAD 还原——--3way 冲突标记同时污染工作区和 index，
+  // `checkout -- f` 从 index 还原会拿到冲突版，必须 `checkout HEAD -- f` 才能还原干净）
+  for (const f of trackedFiles) {
+    try { gitQuiet(projectRoot, `checkout HEAD -- ${f}`); } catch (e) { error = (error ? error + '; ' : '') + `checkout ${f}: ${e.message}`; }
+  }
+  // 删除 --3way 可能新建的文件（apply 前不存在）
+  for (const f of newFiles) {
+    try {
+      const p = join(projectRoot, f);
+      if (existsSync(p)) unlinkSync(p);
+    } catch (e) { error = (error ? error + '; ' : '') + `delete ${f}: ${e.message}`; }
+  }
+  // 兜底：若 index 处于 unmerged 状态，重置 index（不影响工作区已还原的文件）
+  try { gitQuiet(projectRoot, 'reset --quiet'); } catch {}
+  return { conflicts, error };
+}
+
 /**
  * baseline 漂移时的 merge 降级路径（D-001）。
  *
@@ -456,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: [],
@@ -478,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/src/worktree.js

@@ -138,10 +138,11 @@ function printSyncReport(diag, baseHash, changeName) {
   const ch = changeName || '<change>';
   if (diag.status === 'behind') {
     console.log(`⚠️  base 同步检测：落后 origin/${b} ${diag.behind} 个 commit（base ${short}）`);
-    console.log(`    execute 期间若主仓库对齐 main，apply 回来可能冲突。建议先对齐：`);
+    console.log(`    apply 时 git --3way 会自动三路合并主干已提交推进；只有同文件同区域重叠才冲突。`);
+    console.log(`    建议先对齐以减小冲突面：`);
     console.log(`      git merge --ff-only origin/${b}`);
     console.log(`      sillyspec worktree cleanup ${ch} && sillyspec run execute --change ${ch}`);
-    console.log(`    或继续，apply 时用 --merge 降级（会引入合并提交）。`);
+    console.log(`    或继续，重叠冲突时用 --merge 兜底（会引入合并提交）。`);
   } else if (diag.status === 'diverged') {
     console.log(`⚠️  base 同步检测：与 origin/${b} 分叉（领先 ${diag.ahead} / 落后 ${diag.behind}，base ${short}）`);
     console.log(`    apply 回 main 大概率冲突。建议先在主仓库对齐（rebase 或 merge origin/${b}），`);
@@ -170,11 +171,12 @@ function sleepMs(ms) {
 export function computeBaselineHash(cwd) {
   // 排除非交付物的元数据/文档 churn，避免多操作者仓库里别人改这些 → 整树 hash 变 → apply 误阻断
   // （execute 自身也会改 .sillyspec/docs.sillyspec，否则每个 execute 收尾都因自身改动 BLOCKED）。
-  // 安全：coarse hash 放过这些不丢真冲突——applyWorktree step5a(未提交∩changedFiles)+step5b(HEAD blob)
-  // 对交付文件做精确 per-file 校验，不读这里的 exclude。
+  // 安全：coarse hash 只挡「未提交」dirty（git apply --3way 危险区，实测必拦）；真冲突由
+  // applyWorktree step5a(未提交∩changedFiles 精确点名)+step7(--3way 冲突回滚)兜底，
+  // 「已提交」推进不再拦（step5b 已放宽交 --3way 自动三路合并），不读这里的 exclude。
   //   - .sillyspec/：brainstorm/plan 蓝图 + runtime 产物
   //   - .claude/：agent 配置/skills/CLAUDE.md（多操作者 agent 指引 churn）
-  //   - docs/：文档（非代码交付物；deliverable 文档冲突由 step5a/5b 兜底）
+  //   - docs/：文档（非代码交付物）
   //   - CLAUDE.md：根 agent 指引（多操作者常改）
   // 必须和 applyWorktree step 4.5 (worktree-apply.js) 使用相同的排除规则。
   const exclude = '-- . ":(exclude).sillyspec/" ":(exclude).claude/" ":(exclude)docs/" ":(exclude)CLAUDE.md"';
@@ -247,15 +249,16 @@ export class WorktreeManager {
 
     let root = this.cwd;
     try {
-      // git-common-dir 在主仓库内 = <main>/.git
-      // 在 linked worktree 内 = <main>/.git（git 共享 .git 目录）
+      // git-common-dir 在主仓库内 = <main>/.git，在 linked worktree 内 = <main>/.git（git 共享 .git 目录）。
+      // 但 git 可能返回**相对路径**（如 `.git`）。必须相对 this.cwd 绝对化，否则下面的
+      // existsSync/statSync 会相对 process.cwd() 解析——当 process.cwd 是另一个 git 仓库
+      // （未 chdir 的脚本、或 CLI 在别处跑）时，worktreeBase 会错解析到 process.cwd 仓库，
+      // getMeta 读错位置返回 null。resolve() 对绝对参数原样返回、对相对参数相对 this.cwd 解析，两者皆稳。
       const commonDir = gitQuiet(this.cwd, 'rev-parse --git-common-dir');
-      // commonDir 应该是 <main-repo>/.git
-      // dirname(commonDir) = <main-repo>
-      if (commonDir && existsSync(commonDir)) {
-        const st = statSync(commonDir);
-        if (st.isDirectory()) {
-          root = dirname(commonDir);
+      if (commonDir) {
+        const absCommonDir = resolve(this.cwd, commonDir);
+        if (existsSync(absCommonDir) && statSync(absCommonDir).isDirectory()) {
+          root = dirname(absCommonDir);
         }
       }
     } catch (e) {
@@ -989,7 +992,12 @@ export class WorktreeManager {
   }
 
   /**
-   * 检查 worktree 是否有未 apply 到主工作区的变更
+   * 检查 worktree 是否有尚未落到主工作区的交付变更。
+   *
+   * 语义：worktree 相对 baseline 的交付变更（tracked + untracked，排除 .sillyspec//meta.json）里，
+   * 哪些还没 byte-identical 出现在主工作区 HEAD。全部已在 main HEAD（含 cherry-pick/rebase/merge/apply
+   * 落地）→ hasChanges:false（调用方可安全 cleanup）；否则 hasChanges:true（保留 worktree）。
+   * 检测失败/拿不准 → 保守 hasChanges:true（防误删未落代码）。
    * @param {string} changeName
    * @returns {{ hasChanges: boolean, changedFiles: string[], reason?: string }}
    */
@@ -1007,36 +1015,102 @@ export class WorktreeManager {
     if (meta.mode === 'in-place-fallback') {
       return { hasChanges: false, changedFiles: [], reason: 'in-place mode' };
     }
+    // native-worktree 是用户外部隔离环境，不纳入"未应用"判定（与 execute 完成路径一致）
+    if (meta.mode === 'native-worktree') {
+      return { hasChanges: false, changedFiles: [], reason: 'native-worktree (external)' };
+    }
 
     const diffBase = meta.baselineCommit || meta.baseHash;
     if (!diffBase) {
       return { hasChanges: false, changedFiles: [], reason: 'no diff base' };
     }
 
+    const isDeliverable = f => f && !f.startsWith('.sillyspec/') && f !== 'meta.json';
     try {
-      // tracked 文件变更
-      const statusRaw = gitQuiet(worktreePath, `diff --name-status ${diffBase}`) || '';
-      const statusFiles = new Set();
-      if (statusRaw) {
-        for (const line of statusRaw.split('\n').filter(Boolean)) {
-          const parts = line.split('\t');
-          if (parts.length >= 2) statusFiles.add(parts[parts.length - 1]);
-          if (parts.length >= 3) statusFiles.add(parts[parts.length - 2]);
+      // 1) 候选交付变更（worktree 工作区相对 diffBase）。--no-renames：rename 退化成 D+A，两侧文件都进集
+      const tracked = (gitQuiet(worktreePath, `diff --no-renames --name-only ${diffBase}`) || '')
+        .split('\n').filter(Boolean).filter(isDeliverable);
+      const untracked = (gitQuiet(worktreePath, `ls-files --others --exclude-standard`) || '')
+        .split('\n').filter(Boolean).filter(isDeliverable);
+
+      if (tracked.length === 0 && untracked.length === 0) {
+        return { hasChanges: false, changedFiles: [], reason: 'no changes in worktree' };
+      }
+
+      // 2) 候选集中尚未落到主工作区 HEAD 的子集
+      const pending = this._changesAlreadyOnMain(worktreePath, tracked, untracked);
+      if (pending.length === 0) {
+        return { hasChanges: false, changedFiles: [], reason: 'all changes already on main HEAD' };
+      }
+      return { hasChanges: true, changedFiles: pending };
+    } catch (e) {
+      // 检测失败时保守处理：视为有变更，保留 worktree
+      return { hasChanges: true, changedFiles: [], reason: `check failed: ${e.message}` };
+    }
+  }
+
+  /**
+   * 判定候选变更里哪些还没到主工作区 HEAD。
+   * - tracked：`git -C worktree diff --no-renames --name-only <mainHead> -- <files>`，
+   *   比较 worktree 工作区（含未提交）vs main HEAD，限定到候选集；空 = 已在 main HEAD。
+   * - untracked：worktree `hash-object`（默认带 filter，与 tree blob 同口径）vs main `ls-tree HEAD` blob；
+   *   不等 = 该新文件未在 main HEAD。HEAD-only，不查 main 工作区未提交副本（防误删）。
+   * 三种 mode 共享主 repo 对象库，mainHead 可在 worktree cwd 解析。
+   * @private
+   * @param {string} worktreePath
+   * @param {string[]} trackedFiles
+   * @param {string[]} untrackedFiles
+   * @returns {string[]} 尚未落到 main HEAD 的文件
+   */
+  _changesAlreadyOnMain(worktreePath, trackedFiles, untrackedFiles) {
+    const mainHead = git(this.cwd, 'rev-parse HEAD'); // 失败即抛 → 外层 catch fail-safe
+    const pending = [];
+
+    if (trackedFiles.length > 0) {
+      const diverged = (gitQuiet(worktreePath,
+        `diff --no-renames --name-only ${mainHead} -- ${trackedFiles.join(' ')}`) || '')
+        .split('\n').filter(Boolean);
+      pending.push(...diverged);
+    }
+
+    if (untrackedFiles.length > 0) {
+      // hash-object 按 argv 顺序逐行输出 blob hash；某文件不存在则整命令失败 → gitQuiet 返回 null
+      const wtHashes = (gitQuiet(worktreePath, `hash-object -- ${untrackedFiles.join(' ')}`) || '')
+        .split('\n');
+      const mainBlobs = this._lsTreeBlobs(this.cwd, 'HEAD', untrackedFiles);
+      for (let i = 0; i < untrackedFiles.length; i++) {
+        // wtHashes[i] 缺失（命令失败/行数不齐）→ 视为未应用，保守保留
+        if (wtHashes[i] !== (mainBlobs.get(untrackedFiles[i]) ?? null)) {
+          pending.push(untrackedFiles[i]);
         }
       }
+    }
 
-      // untracked 文件
-      const untrackedRaw = gitQuiet(worktreePath, `ls-files --others --exclude-standard`) || '';
-      const untrackedFiles = untrackedRaw
-        ? untrackedRaw.split('\n').filter(Boolean).filter(f => !f.startsWith('.sillyspec/') && f !== 'meta.json')
-        : [];
+    return [...new Set(pending)];
+  }
 
-      const changedFiles = [...new Set([...statusFiles, ...untrackedFiles])];
-      return { hasChanges: changedFiles.length > 0, changedFiles };
-    } catch (e) {
-      // 检测失败时保守处理：视为有变更
-      return { hasChanges: true, changedFiles: [], reason: `diff failed: ${e.message}` };
+  /**
+   * 一次 `git ls-tree <treeish> -- <files>` → Map<path, blobHash>（仅 tree 中存在者）。
+   * 与 worktree-apply.js 的 getBlobHashMap 同逻辑；此处内联私有，避免反向 import 循环依赖。
+   * @private
+   * @param {string} cwd
+   * @param {string} treeish
+   * @param {string[]} files
+   * @returns {Map<string, string>}
+   */
+  _lsTreeBlobs(cwd, treeish, files) {
+    const map = new Map();
+    if (!files || files.length === 0) return map; // 空 pathspec 会列整棵树，必须拦
+    const raw = gitQuiet(cwd, `ls-tree ${treeish} -- ${files.join(' ')}`);
+    if (!raw) return map;
+    for (const line of raw.split('\n')) {
+      if (!line) continue;
+      const tab = line.indexOf('\t');
+      if (tab === -1) continue;
+      const hash = line.slice(0, tab).split(' ')[2]; // "<mode> <type> <hash>"
+      if (hash) map.set(line.slice(tab + 1), hash);
     }
+    return map;
   }
 
   /**

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 事实独立复核，谎报无效——务必如实记录