sillyspec 3.25.9 → 3.26.0

package/src/version.js

@@ -0,0 +1,19 @@
+import { readFileSync } from 'fs';
+import { resolve, dirname } from 'path';
+import { fileURLToPath } from 'url';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+
+/**
+ * 读取 package.json 版本号。
+ * 独立轻量模块：只依赖 fs/path/url，不拖入 init.js 的 @inquirer/prompts 等重型交互库。
+ * 供 index.js 顶部静态 import——--version 等高频路径不再为 getVersion 付 init.js 加载税。
+ */
+export function getVersion() {
+  try {
+    const pkg = JSON.parse(readFileSync(resolve(__dirname, '..', 'package.json'), 'utf8'));
+    return pkg.version;
+  } catch {
+    return '?.?.?';
+  }
+}

package/src/worktree-apply.js

@@ -12,29 +12,17 @@
  * 8. 成功后自动 cleanup
  */
 
-import { execSync } from 'child_process';
+import { execFileSync } from 'child_process';
 import { existsSync, unlinkSync, writeFileSync, mkdtempSync, rmSync, readdirSync, readFileSync } from 'fs';
 import { join, resolve } from 'path';
 import { tmpdir } from 'os';
-import { createHash } from 'crypto';
 import { WorktreeManager } from './worktree.js';
 import { parseFileChangeList, parseFileChangeListDetailed, pathMatches } from './change-list.js';
 import { parseAllowedPaths } from './stages/plan-postcheck.js';
+import { git, gitQuiet } from './git-helper.js';
 
 const CHANGES_REL = '.sillyspec/changes';
 
-function git(cwd, args) {
-  return execSync(`git ${args}`, { cwd, encoding: 'utf8', stdio: ['pipe', 'pipe', 'pipe'] }).trim();
-}
-
-function gitQuiet(cwd, args) {
-  try {
-    return execSync(`git ${args}`, { cwd, encoding: 'utf8', stdio: ['pipe', 'pipe', 'pipe'] }).trim();
-  } catch {
-    return null;
-  }
-}
-
 /**
  * 过滤掉 worktree 基础设施文件（非交付物），让 apply 只关心真正的变更产出：
  *   - meta.json：worktree 元数据，baseline commit 中被跟踪、working-tree 被 CLI 改写
@@ -42,11 +30,95 @@ function gitQuiet(cwd, args) {
  *     的锚点，保证 baseline overlay 文件不被误判为变更）。若不排除，modified-tracked 的
  *     meta.json 会落入 changedFiles，触发「不在 design.md 清单」误判，导致每个 execute 的
  *     assess 恒 BLOCKED。
- *   - .sillyspec/：变更文档 / 运行时产物，不属于源码交付。
+ *   - .sillyspec/changes/：变更文档（worktree 专属，apply 回主仓污染进度库）。
+ *   - .sillyspec/.runtime/：运行时产物（进度库/锁/review 产物，非源码）。
+ *   - .sillyspec/quicklog/：quicklog 条目（worktree 进度，非交付物）。
+ *   保留 .sillyspec/docs/（dogfood 模块规范文档 = 交付物，apply 回主仓）。
  * 对 modified-tracked（git diff）与 untracked（ls-files --others）一视同仁。
  */
 export function filterDeliverableFiles(files) {
-  return files.filter(f => !f.startsWith('.sillyspec/') && f !== 'meta.json');
+  return files.filter(f =>
+    !f.startsWith('.sillyspec/changes/') &&
+    !f.startsWith('.sillyspec/.runtime/') &&
+    !f.startsWith('.sillyspec/quicklog/') &&
+    f !== 'meta.json'
+  );
+}
+
+/**
+ * dirty 拦截触发时生成「逐文件 rescue 指令」——旁路 git apply 的安全逃生通道（design §接口定义 generateRescueCommands）。
+ *
+ * 逐文件四分类（按优先级判定，命中即 continue）：
+ *   1. DELETE           ∈ deletedFiles      → rm "<projectRoot>/<f>"（不计 cpFileCount 也不计 excludedCount）
+ *   2. EXCLUDE-DIRTY    ∈ dirtyFiles        → warning（cp 会覆盖 main 工作区未提交改动），excludedCount++
+ *   3. EXCLUDE-MISMATCH ∈ hashMismatchFiles → warning（cp 会回退主干已提交推进改动），excludedCount++
+ *   4. SAFE-CP          其余（main 该文件干净）→ cp "<worktreePath>/<f>" "<projectRoot>/<f>"，cpFileCount++
+ *
+ * 路径用 path.join 拼接后 replace 反斜杠为正斜杠（Git Bash 兼容，规则 13）。
+ *
+ * 纯函数：无 git/fs 调用无副作用，不读 meta/worktree 状态，不 mutate 入参；
+ *        所有 dirtyFiles/hashMismatchFiles/deletedFiles 集合均由调用方（step4.5/5a/assess）算好传入。
+ *
+ * @param {object} args
+ * @param {string[]} args.changedFiles        filterDeliverableFiles 后的实际变更路径
+ * @param {Set<string>|string[]} args.dirtyFiles   main 工作区未提交文件集（统一口径：tracked-modified ∪ untracked，排 .sillyspec/+meta.json）
+ * @param {string[]} args.hashMismatchFiles   主干已提交推进文件（step3.5 前移算，依赖 baseHash/HEAD blob 对比）
+ * @param {string[]} [args.deletedFiles=[]]   worktree 删除文件（git diff name-status D）
+ * @param {string} args.worktreePath
+ * @param {string} args.projectRoot
+ * @returns {{
+ *   commands: string[],      // 可复制粘贴 shell 命令（cp/rm），正斜杠路径
+ *   warnings: string[],      // 被排除文件（dirty/mismatch）的风险标注
+ *   cpFileCount: number,     // SAFE-CP 文件数
+ *   excludedCount: number    // EXCLUDE-DIRTY + EXCLUDE-MISMATCH 数
+ * }}
+ */
+export function generateRescueCommands({ changedFiles, dirtyFiles, hashMismatchFiles, deletedFiles = [], worktreePath, projectRoot }) {
+  // 集合归一：dirtyFiles 接受 Set 或数组（调用方 step4.5/5a 可能传任一形态），其余统一数组→Set
+  const dirtySet = dirtyFiles instanceof Set ? dirtyFiles : new Set(dirtyFiles || []);
+  const mismatchSet = new Set(hashMismatchFiles || []);
+  const deletedSet = new Set(deletedFiles || []);
+
+  const commands = [];
+  const warnings = [];
+  let cpFileCount = 0;
+  let excludedCount = 0;
+
+  for (const f of changedFiles) {
+    // 优先级 1→2→3→4，命中即 continue（DELETE 最先判）
+    if (deletedSet.has(f)) {
+      commands.push(`rm "${join(projectRoot, f).replace(/\\/g, '/')}"`);
+      continue;
+    }
+    if (dirtySet.has(f)) {
+      warnings.push(`跳过 ${f}：EXCLUDE-DIRTY（main 工作区该文件有未提交改动，cp 会覆盖）`);
+      excludedCount++;
+      continue;
+    }
+    if (mismatchSet.has(f)) {
+      warnings.push(`跳过 ${f}：EXCLUDE-MISMATCH（主干已提交推进该文件，cp 会回退他人改动；请先 commit main 未提交改动再正常 apply 走 --3way 合并）`);
+      excludedCount++;
+      continue;
+    }
+    commands.push(`cp "${join(worktreePath, f).replace(/\\/g, '/')}" "${join(projectRoot, f).replace(/\\/g, '/')}"`);
+    cpFileCount++;
+  }
+
+  return { commands, warnings, cpFileCount, excludedCount };
+}
+
+/**
+ * 算 rescue 用的统一 dirtyFiles 口径：main 工作区所有未提交文件 = tracked-modified（git diff HEAD）
+ * ∪ untracked（git ls-files others），再用 filterDeliverableFiles 过滤（排 .sillyspec/changes/.runtime/quicklog
+ * + meta.json，保留 .sillyspec/docs/——对齐 changedFiles 同宇宙，闭合 design Grill 的 .sillyspec/docs/ 残留 gap）。
+ * 注意：此口径与 step4.5「是否触发拦截」的判定口径（排除 .claude/docs/CLAUDE.md）不同，二者不混用（design §dirtyFiles 口径统一）。
+ * @param {string} projectRoot
+ * @returns {string[]} 未提交文件（filterDeliverableFiles 过滤后）
+ */
+export function computeRescueDirtyFiles(projectRoot) {
+  const tracked = (gitQuiet(projectRoot, ['diff', '--name-only', 'HEAD']) || '').split('\n').filter(Boolean);
+  const untracked = (gitQuiet(projectRoot, ['ls-files', '--others', '--exclude-standard']) || '').split('\n').filter(Boolean);
+  return filterDeliverableFiles([...new Set([...tracked, ...untracked])]);
 }
 
 /**
@@ -63,6 +135,23 @@ export function classifyAllowListViolations(changedFiles, allowSet) {
   return changedFiles.filter(f => !allow.some(ap => pathMatches(f, ap)));
 }
 
+/**
+ * 确定进 patch 的文件：有清单取「实际变更 ∩ 清单（pathMatches 容差）」，无清单取全部变更。
+ *
+ * 口径须与 classifyAllowListViolations 一致——否则 design §6 用 glob（如 test_*.py）或多路径
+ * 单 cell 覆盖的文件过 manifest 校验（Gate1 用 pathMatches 放行），却因字面 includes 不在
+ * changedFiles → 被滤出 patchFiles → patch 不含 → 主工作区静默丢失（坑 apply-glob-manifest）。
+ * 以 changedFiles 为基按容差圈定，glob/前缀覆盖的具体文件都能进 patch。
+ *
+ * @param {string[]} changedFiles  filterDeliverableFiles 已过滤的实际变更路径
+ * @param {Set<string>} allowSet   design §6 清单 ∪ task allowed_paths（可含 glob / 目录前缀）
+ * @param {boolean} hasAllowList   是否有清单
+ * @returns {string[]} 进 patch 的文件
+ */
+export function resolvePatchFiles(changedFiles, allowSet, hasAllowList) {
+  if (!hasAllowList) return changedFiles;
+  return changedFiles.filter(f => [...allowSet].some(ap => pathMatches(f, ap)));
+}
 /**
  * 批量获取多个文件在某个 treeish 中的 blob hash（一次 git ls-tree 替代 N 次 rev-parse）。
  *
@@ -71,7 +160,7 @@ export function classifyAllowListViolations(changedFiles, allowSet) {
  *   - 文件不在 tree 中 → 不在 Map 中（调用方 map.get(f) ?? null 得 null，等同 rev-parse 失败→null）
  * ls-tree 输出 "<mode> <type> <hash>\t<path>"。path 恒为文件路径（来自 git diff/ls-files），
  * 非目录，故不带 -r 也正确——文件在 tree 时 rev-parse treeish:path 与 ls-tree 都给同一 hash，
- * 不在时都不给，等价。（沿用 git() 字符串拼接模式，不引入新的引号/空格破法。）
+ * 不在时都不给，等价。（沿用公共 git() 数组形式，不经 shell、不引入引号/空格破法。）
  *
  * @param {string} cwd
  * @param {string} treeish
@@ -81,7 +170,7 @@ export function classifyAllowListViolations(changedFiles, allowSet) {
 function getBlobHashMap(cwd, treeish, files) {
   const map = new Map();
   if (files.length === 0) return map; // 空 pathspec 会让 ls-tree 列出整棵树，必须拦截
-  const raw = gitQuiet(cwd, `ls-tree ${treeish} -- ${files.join(' ')}`);
+  const raw = gitQuiet(cwd, ['ls-tree', treeish, '--', ...files]);
   if (!raw) return map;
   for (const line of raw.split('\n')) {
     if (!line) continue;
@@ -107,7 +196,7 @@ function getBlobHashMap(cwd, treeish, files) {
  * @returns {Set<string>} 并集清单（无 design 清单且无 task 卡片时为空集）
  */
 export function resolveApplyAllowSet(projectRoot, changeName) {
-  const allowSet = parseFileChangeList(join(projectRoot, CHANGES_REL, changeName, 'design.md'));
+  const allowSet = parseFileChangeList(join(projectRoot, CHANGES_REL, changeName, 'design.md'), { keepSillyspecDocs: true });
   const tasksDir = join(projectRoot, CHANGES_REL, changeName, 'tasks');
   if (existsSync(tasksDir)) {
     for (const tf of readdirSync(tasksDir).filter(f => /^task-\d+\.md$/.test(f))) {
@@ -140,6 +229,8 @@ export function applyWorktree(changeName, { cwd, checkOnly = false, merge = fals
     changedFiles: [],
     extraFiles: [],
     hashMismatchFiles: [],
+    deletedFiles: [],
+    rescueCommands: null,
     patchPath: null,
     errors: [],
     merged: false,
@@ -164,9 +255,10 @@ export function applyWorktree(changeName, { cwd, checkOnly = false, merge = fals
   // worktree 内修改可能没有 commit，用 git diff <baseHash>（比较 baseHash 到工作区内容）
   // 同时检测 untracked 新文件（git diff 不包含 untracked）
   let changedFiles;
+  const deletedFiles = [];
   try {
     // 用 --name-status 捕获 rename/delete（--name-only 会丢失 rename 源文件）
-    const statusRaw = git(worktreePath, `diff --name-status ${diffBase}`);
+    const statusRaw = git(worktreePath, ['diff', '--name-status', diffBase]);
     const statusFiles = new Set();
     if (statusRaw) {
       for (const line of statusRaw.split('\n').filter(Boolean)) {
@@ -174,11 +266,13 @@ export function applyWorktree(changeName, { cwd, checkOnly = false, merge = fals
         // R100 old.txt new.txt → 提取两个文件
         if (parts.length >= 2) statusFiles.add(parts[parts.length - 1]);
         if (parts.length >= 3) statusFiles.add(parts[parts.length - 2]);
+        // 删除文件（status D / D100）→ 收集到 deletedFiles（rescue DELETE 分类用，design §逐文件分类）
+        if (parts[0].startsWith('D')) deletedFiles.push(parts[parts.length - 1]);
       }
     }
 
     // untracked 新文件（diffBase 中不存在的文件）
-    const untrackedRaw = gitQuiet(worktreePath, `ls-files --others --exclude-standard`);
+    const untrackedRaw = gitQuiet(worktreePath, ['ls-files', '--others', '--exclude-standard']);
     const untrackedFiles = untrackedRaw ? untrackedRaw.split('\n').filter(Boolean) : [];
 
     // 排除 worktree 基础设施文件（meta.json / .sillyspec/，见 filterDeliverableFiles）。
@@ -191,6 +285,7 @@ export function applyWorktree(changeName, { cwd, checkOnly = false, merge = fals
   }
 
   result.changedFiles = changedFiles;
+  result.deletedFiles = deletedFiles;
 
   if (changedFiles.length === 0) {
     // 没有变更
@@ -205,6 +300,22 @@ export function applyWorktree(changeName, { cwd, checkOnly = false, merge = fals
   const allowSet = resolveApplyAllowSet(projectRoot, changeName);
   const hasAllowList = allowSet.size > 0;
 
+  // --- 3.5 主干已提交推进检测：hashMismatch 前移（Grill P0 修复，design §step 顺序修正）---
+  // 原在 step5b，但 step4.5/5a dirty 拦截短路在 step5b 之前，致 rescue 拿不到 hashMismatchFiles
+  // → EXCLUDE-MISMATCH 失效 → cp 覆盖主干已提交推进。前移到 step4.5 之前（仅依赖 baseHash/HEAD blob
+  // 对比，无 dirty 依赖；allowSet/changedFiles/baseHash 均在本步之前可得，前移安全）。
+  // 仅记录不拦截（交 step7 --3way 实测，真重叠回滚提示 --merge）。
+  const targetFiles = hasAllowList ? [...allowSet] : changedFiles;
+  const wtHashMap = getBlobHashMap(worktreePath, baseHash, targetFiles);
+  const mainHashMap = getBlobHashMap(projectRoot, 'HEAD', targetFiles);
+  for (const f of targetFiles) {
+    const wtBlob = wtHashMap.get(f) ?? null;
+    const mainBlob = mainHashMap.get(f) ?? null;
+    if (wtBlob === null && mainBlob === null) continue;
+    if (wtBlob === mainBlob) continue;
+    result.hashMismatchFiles.push(f);
+  }
+
   // --- 4. 校验：变更文件 ⊆ 清单（无清单则跳过）---
   if (hasAllowList) {
     const violations = classifyAllowListViolations(changedFiles, allowSet);
@@ -227,31 +338,51 @@ export function applyWorktree(changeName, { cwd, checkOnly = false, merge = fals
   }
 
   // --- 4.5 校验：主工作区是否有「未提交」脏改动（未提交 dirty 是 git apply --3way 危险区，必须拦）---
-  // 分工：4.5（整树 baselineHash）+ 5a（脏∩changedFiles）挡「未提交」dirty；5b 管「已提交」HEAD 分叉（已放宽，见下）。
+  // 分工：4.5（排除规则下当前 dirty）+ 5a（脏∩changedFiles）挡「未提交」dirty；5b 管「已提交」HEAD 分叉（已放宽，见下）。
   // 实测：主干未提交 dirty 时，git apply --3way 报 `does not match index` 且行为不一致（可能报错/可能半应用，
-  // 哪怕脏文件与 patch 不重叠）——这是 git 硬约束，故此处友好拦截，引导用户先 commit/stash。
+  // 哪怕脏文件与 patch 不重叠）——这是 Windows/autocrlf 的 CRLF 副作用（非 git 本质限制：
+  // autocrlf off 时 --3way 在不重叠 dirty 树能 Applied cleanly，on 时才报 does not match index）。
+  // 但仓库 CRLF 混用 + 规则13 要求 Windows 兼容，fail-loud 在 Windows 仍有据，故此处友好拦截，引导用户先 commit/stash。
   // 排除非交付物的元数据/文档 churn（execute 自身改的 + 多操作者常改的 agent 指引/文档），
-  // 否则别人改 CLAUDE.md/docs/.claude → 整树 hash 变 → apply 误阻断（多操作者仓库高频踩坑）。
-  // 注意：必须和 computeBaselineHash (worktree.js) 使用相同的排除规则。
+  // 否则别人改 CLAUDE.md/docs/.claude → 判定 dirty → apply 误阻断（多操作者仓库高频踩坑）。
+  // 注意：排除规则必须和 computeBaselineHash (worktree.js) 一致（虽已不比对 hash，仍用同一口径判当前 dirty）。
   if (meta.baselineHash) {
-    const exclude = '-- . ":(exclude).sillyspec/" ":(exclude).claude/" ":(exclude)docs/" ":(exclude)CLAUDE.md"';
-    const staged = gitQuiet(projectRoot, `diff --cached ${exclude}`) || '';
-    const unstaged = gitQuiet(projectRoot, `diff ${exclude}`) || '';
-    const untracked = gitQuiet(projectRoot, `ls-files --others --exclude-standard ${exclude}`) || '';
-    const raw = `staged:${staged}\nunstaged:${unstaged}\nuntracked:${untracked}`;
-    const currentHash = createHash('sha256').update(raw).digest('hex').slice(0, 16);
-    if (currentHash !== meta.baselineHash) {
+    // pathspec：`--` 结束选项，`.` 包含全部，后续 :(exclude) 排除非交付物元数据/文档 churn
+    // （与 computeBaselineHash 同口径）。数组形式逐元素传递，:(exclude) magic 字面直传不经 shell。
+    const exclude = ['--', '.', ':(exclude).sillyspec/', ':(exclude).claude/', ':(exclude)docs/', ':(exclude)CLAUDE.md'];
+    const staged = gitQuiet(projectRoot, ['diff', '--cached', ...exclude]) || '';
+    const unstaged = gitQuiet(projectRoot, ['diff', ...exclude]) || '';
+    const untracked = gitQuiet(projectRoot, ['ls-files', '--others', '--exclude-standard', ...exclude]) || '';
+    // 意图（与 computeBaselineHash 注释一致）：只挡「未提交 dirty」——git apply --3way 对 dirty 工作区不稳。
+    // 不比对 hash 是否等于 execute 启动时 baselineHash：主仓 dirty→clean（execute 期间 commit 无关文件）后
+    // hash 必变，若仍比对会永久死锁（须手改 meta.baselineHash）。改判「排除规则下当前是否有未提交 dirty」。
+    const hasUncommittedDirty = staged !== '' || unstaged !== '' || untracked !== '';
+    if (hasUncommittedDirty) {
       // 未提交 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))
+        ((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');
+      // rescue：dirty 拦截触发时生成逐文件 cp 安全子集（旁路 git apply），写 result.rescueCommands 供 assess/打印器消费
+      const rescueDirty = computeRescueDirtyFiles(projectRoot);
+      result.rescueCommands = generateRescueCommands({
+        changedFiles,
+        dirtyFiles: rescueDirty,
+        hashMismatchFiles: result.hashMismatchFiles,
+        deletedFiles: result.deletedFiles,
+        worktreePath,
+        projectRoot,
+      });
       result.errors.push(
-        `主工作区有未提交的改动（execute 前后 baseline 不一致），git apply 无法安全应用。\n` +
+        `主工作区有未提交的改动，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}`
+        (result.rescueCommands.commands.length > 0 || result.rescueCommands.warnings.length > 0
+          ? `或手动 rescue（旁路 git apply，逐文件 cp 安全子集；cp 后需手动 sillyspec worktree cleanup ${changeName}）：\n` +
+            result.rescueCommands.commands.map(c => `  ${c}`).join('\n') +
+            (result.rescueCommands.warnings.length > 0 ? '\n' + result.rescueCommands.warnings.map(w => `  ${w}`).join('\n') : '') +
+            `\n  （共 ${result.rescueCommands.cpFileCount} 个可安全 cp，${result.rescueCommands.excludedCount} 个被排除）\n`
+          : '')
       );
       if (!checkOnly) return result; // checkOnly 收集不短路（一次报全）；真实 apply 短路
     }
@@ -259,40 +390,31 @@ export function applyWorktree(changeName, { cwd, checkOnly = false, merge = fals
 
   // --- 5. 校验：主工作区文件 base hash 一致 ---
   // 5a. 检查主工作区是否有未 commit 的脏文件（会影响 apply）
-  const mainDirtyRaw = gitQuiet(projectRoot, 'diff --name-only HEAD');
+  const mainDirtyRaw = gitQuiet(projectRoot, ['diff', '--name-only', 'HEAD']);
   const mainDirtyFiles = mainDirtyRaw ? mainDirtyRaw.split('\n').filter(Boolean) : [];
   if (mainDirtyFiles.length > 0) {
     // 如果脏文件和本次 apply 的文件有交集 → 报错
     const conflictDirty = mainDirtyFiles.filter(f => changedFiles.includes(f));
     if (conflictDirty.length > 0) {
+      const rescueDirty5a = computeRescueDirtyFiles(projectRoot);
+      result.rescueCommands = generateRescueCommands({
+        changedFiles, dirtyFiles: rescueDirty5a, hashMismatchFiles: result.hashMismatchFiles,
+        deletedFiles: result.deletedFiles, worktreePath, projectRoot,
+      });
       result.errors.push(
-        `主工作区有以下未 commit 的变更，会影响 apply：\n  ${conflictDirty.join('\n  ')}\n请先 commit 或 stash 这些变更。`
+        `主工作区有以下未 commit 的变更，会影响 apply：\n  ${conflictDirty.join('\n  ')}\n请先 commit 或 stash 这些变更。` +
+        (result.rescueCommands.commands.length > 0 || result.rescueCommands.warnings.length > 0
+          ? `或手动 rescue（旁路 git apply，逐文件 cp 安全子集；cp 后需手动 sillyspec worktree cleanup ${changeName}）：\n` +
+            result.rescueCommands.commands.map(c => `  ${c}`).join('\n') +
+            (result.rescueCommands.warnings.length > 0 ? '\n' + result.rescueCommands.warnings.map(w => `  ${w}`).join('\n') : '') +
+            `\n  （共 ${result.rescueCommands.cpFileCount} 个可安全 cp，${result.rescueCommands.excludedCount} 个被排除）\n`
+          : '')
       );
       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);
-  for (const f of targetFiles) {
-    const wtBlob = wtHashMap.get(f) ?? null;
-    const mainBlob = mainHashMap.get(f) ?? null;
-
-    // 两者都为 null（文件在 base 时不存在）→ OK
-    if (wtBlob === null && mainBlob === null) continue;
-    // 两者一致 → OK
-    if (wtBlob === mainBlob) continue;
-    // 不一致 → 主干已提交推进改了此文件，记风险提示（不拦截，交 --3way）
-    result.hashMismatchFiles.push(f);
-  }
+  // 5b hashMismatch 计算已前移到 step3.5（Grill P0），见上
 
   // --- 6. checkOnly 模式：到此返回 ---
   if (checkOnly) {
@@ -301,10 +423,9 @@ export function applyWorktree(changeName, { cwd, checkOnly = false, merge = fals
   }
 
   // --- 7. 生成 patch 并 apply ---
-  // 确定要包含在 patch 中的文件：有清单用清单交集，无清单用全部变更
-  const patchFiles = hasAllowList
-    ? [...allowSet].filter(f => changedFiles.includes(f))
-    : changedFiles;
+  // 确定要包含在 patch 中的文件：有清单用「实际变更 ∩ 清单（pathMatches 容差）」，无清单用全部变更。
+  // 口径与 classifyAllowListViolations 一致（坑 apply-glob-manifest-passes-check-but-not-patch）。
+  const patchFiles = resolvePatchFiles(changedFiles, allowSet, hasAllowList);
 
   // 创建临时文件
   const tmpDir = mkdtempSync(join(tmpdir(), 'sillyspec-patch-'));
@@ -321,35 +442,36 @@ export function applyWorktree(changeName, { cwd, checkOnly = false, merge = fals
     // ls-files --error-unmatch f 成功 ⟺ f 在 ls-files -- 输出。
     const inTree = getBlobHashMap(worktreePath, diffBase, patchFiles);
     const inIndexList = patchFiles.length > 0
-      ? (gitQuiet(worktreePath, `ls-files -- ${patchFiles.join(' ')}`) || '').split('\n').filter(Boolean)
+      ? (gitQuiet(worktreePath, ['ls-files', '--', ...patchFiles]) || '').split('\n').filter(Boolean)
       : [];
     const inIndex = new Set(inIndexList);
     const trackedFiles = patchFiles.filter(f => inTree.has(f) || inIndex.has(f));
     const trackedSet = new Set(trackedFiles);
     const untrackedPatchFiles = patchFiles.filter(f => !trackedSet.has(f));
 
-    // tracked 文件：git diff baseHash
+    // tracked 文件：git diff baseHash（数组形式，文件名逐个展开为独立 argv，不经 shell；
+    // trim:false 保留二进制补丁原样，timeout 放大到 60s 防大 diff 超时——原裸 execSync 无 timeout）
     if (trackedFiles.length > 0) {
-      const trackedArgs = trackedFiles.length > 0 ? `-- ${trackedFiles.join(' ')}` : '';
-      patchContent += execSync(
-        `git diff --binary ${diffBase} ${trackedArgs}`,
-        { cwd: worktreePath, encoding: 'utf8', stdio: ['pipe', 'pipe', 'pipe'] }
+      patchContent += git(
+        worktreePath,
+        ['diff', '--binary', diffBase, '--', ...trackedFiles],
+        { trim: false, timeout: 60000 }
       );
     }
 
-    // untracked 新文件：git add 到 index，git diff --cached，然后 reset
+    // untracked 新文件：git add 到 index，git diff --cached，然后 reset（均数组形式，文件名逐个展开）
     if (untrackedPatchFiles.length > 0) {
-      const addArgs = untrackedPatchFiles.length > 0 ? `-- ${untrackedPatchFiles.join(' ')}` : '';
-      git(worktreePath, `add ${addArgs}`);
+      git(worktreePath, ['add', '--', ...untrackedPatchFiles]);
       try {
-        const diffCachedArgs = untrackedPatchFiles.length > 0 ? `-- ${untrackedPatchFiles.join(' ')}` : '';
-        patchContent += execSync(
-          `git diff --binary --cached ${diffCachedArgs}`,
-          { cwd: worktreePath, encoding: 'utf8', stdio: ['pipe', 'pipe', 'pipe'] }
+        // trim:false 保留二进制补丁原样，timeout 放大到 60s 防大 diff 超时
+        patchContent += git(
+          worktreePath,
+          ['diff', '--binary', '--cached', '--', ...untrackedPatchFiles],
+          { trim: false, timeout: 60000 }
         );
       } finally {
         // 重置 index（不保留 staged 状态）
-        gitQuiet(worktreePath, `reset HEAD -- ${addArgs}`);
+        gitQuiet(worktreePath, ['reset', 'HEAD', '--', ...untrackedPatchFiles]);
       }
     }
 
@@ -370,13 +492,13 @@ export function applyWorktree(changeName, { cwd, checkOnly = false, merge = fals
     // 但若 --3way 部分成功后冲突，已创建的新文件需删，故记录 untracked 集合。
     const trackedPatchFiles = patchFiles.filter(f => {
       // 该文件在主仓库 HEAD 存在 → 是 tracked（--3way 冲突时留标记需 checkout 还原）
-      return gitQuiet(projectRoot, `cat-file -e HEAD:${f}`) === null ? false : true;
+      return gitQuiet(projectRoot, ['cat-file', '-e', `HEAD:${f}`]) === null ? false : true;
     });
     const newPatchFiles = patchFiles.filter(f => !trackedPatchFiles.includes(f));
 
     // apply --3way 正式应用（主干已提交推进时自动三路合并）
     try {
-      git(projectRoot, `apply --3way ${patchPath}`);
+      git(projectRoot, ['apply', '--3way', patchPath], { timeout: 30000 });
     } catch (e) {
       // --3way 冲突（exit 1，工作区已留冲突标记）：回滚到 apply 前干净状态，不留半成品
       const rollback = rollbackApply(projectRoot, trackedPatchFiles, newPatchFiles);
@@ -427,13 +549,13 @@ function rollbackApply(projectRoot, trackedFiles, newFiles) {
   // 冲突文件：git status 里带冲突标记（UU/AA 等）的文件
   let conflicts = [];
   try {
-    const unmerged = gitQuiet(projectRoot, 'diff --name-only --diff-filter=U') || '';
+    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}`; }
+    try { gitQuiet(projectRoot, ['checkout', 'HEAD', '--', f]); } catch (e) { error = (error ? error + '; ' : '') + `checkout ${f}: ${e.message}`; }
   }
   // 删除 --3way 可能新建的文件（apply 前不存在）
   for (const f of newFiles) {
@@ -443,7 +565,7 @@ function rollbackApply(projectRoot, trackedFiles, newFiles) {
     } catch (e) { error = (error ? error + '; ' : '') + `delete ${f}: ${e.message}`; }
   }
   // 兜底：若 index 处于 unmerged 状态，重置 index（不影响工作区已还原的文件）
-  try { gitQuiet(projectRoot, 'reset --quiet'); } catch {}
+  try { gitQuiet(projectRoot, ['reset', '--quiet']); } catch {}
   return { conflicts, error };
 }
 
@@ -471,15 +593,15 @@ function applyByMerge(result, changeName, projectRoot, wm) {
   const branch = meta.branch || `sillyspec/${changeName}`;
 
   try {
-    git(projectRoot, `merge --no-ff ${branch}`);
+    git(projectRoot, ['merge', '--no-ff', branch], { timeout: 30000 });
   } catch (e) {
     // merge 冲突：取冲突文件列表 + abort 回滚（不 cleanup，保留 worktree）
     let conflictFiles = [];
     try {
-      const cf = gitQuiet(projectRoot, `diff --name-only --diff-filter=U`);
+      const cf = gitQuiet(projectRoot, ['diff', '--name-only', '--diff-filter=U']);
       conflictFiles = cf ? cf.split('\n').filter(Boolean) : [];
     } catch {}
-    try { gitQuiet(projectRoot, `merge --abort`); } catch {}
+    try { gitQuiet(projectRoot, ['merge', '--abort']); } catch {}
     result.errors.push(
       `git merge ${branch} 冲突，请手动解决。冲突文件：\n` +
       (conflictFiles.length ? `  ${conflictFiles.join('\n  ')}\n` : `  (未能获取冲突文件列表)\n`) +
@@ -492,7 +614,7 @@ function applyByMerge(result, changeName, projectRoot, wm) {
   // 分支可能只含 baseline checkpoint（子代理改动未 commit），merge 产生空内容合并，文件零落地。
   // 逐个确认 changedFiles 在 main HEAD 存在。任一缺失 → 不 cleanup（fail-open：保留 worktree 唯一副本）。
   result.merged = true;
-  const notLanded = changedFiles.filter(f => gitQuiet(projectRoot, `cat-file -e HEAD:${f}`) === null);
+  const notLanded = changedFiles.filter(f => gitQuiet(projectRoot, ['cat-file', '-e', `HEAD:${f}`]) === null);
   if (notLanded.length > 0) {
     result.ok = false;
     result.errors.push(
@@ -504,7 +626,7 @@ function applyByMerge(result, changeName, projectRoot, wm) {
   }
 
   result.ok = true;
-  try { result.mergeSummary = git(projectRoot, `log --oneline -1`); } catch {}
+  try { result.mergeSummary = git(projectRoot, ['log', '--oneline', '-1']); } catch {}
   try {
     wm.cleanup(changeName);
   } catch (cleanupErr) {
@@ -553,14 +675,15 @@ export function assessApplyRisk(changeName, { cwd } = {}) {
   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: 'BLOCKED', changedFiles: [], reasons, warnings, stats: { additions: 0, deletions: 0 }, rescueCommands: checkResult.rescueCommands || null };
     }
     return {
       decision: 'SAFE',
       changedFiles: [],
       reasons: ['无变更需要应用'],
       warnings: [],
-      stats: { additions: 0, deletions: 0 }
+      stats: { additions: 0, deletions: 0 },
+      rescueCommands: checkResult.rescueCommands || null
     };
   }
 
@@ -632,7 +755,7 @@ export function assessApplyRisk(changeName, { cwd } = {}) {
   let additions = 0, deletions = 0;
   if (wtPath && diffBase) {
     try {
-      const shortstat = gitQuiet(wtPath, `diff --shortstat ${diffBase}`);
+      const shortstat = gitQuiet(wtPath, ['diff', '--shortstat', diffBase]);
       const insMatch = shortstat?.match(/(\d+) insertion/);
       const delMatch = shortstat?.match(/(\d+) deletion/);
       additions = insMatch ? parseInt(insMatch[1]) : 0;
@@ -653,7 +776,7 @@ export function assessApplyRisk(changeName, { cwd } = {}) {
     decision = 'SAFE';
   }
 
-  return { decision, changedFiles, reasons, warnings, stats: { additions, deletions } };
+  return { decision, changedFiles, reasons, warnings, stats: { additions, deletions }, rescueCommands: checkResult.rescueCommands || null };
 }
 
 /**
@@ -721,7 +844,9 @@ export function formatExecuteSummary({ changeName, stepsCompleted, stepsTotal, a
     // worktree 还在，用 baselineCommit 或 baseHash 做 diff
     try {
       const diffBase = meta.baselineCommit || meta.baseHash;
-      const filesRaw = execSync(`git -C ${meta.worktreePath} diff --name-only ${diffBase} 2>/dev/null`, { encoding: 'utf8' });
+      // execFileSync 数组形式：路径无需引号化（含空格也安全）；stdio stderr=ignore
+      // 替代 `2>/dev/null`（Windows cmd.exe 无法解析该重定向，导致 Windows 上恒抛错→Changed Files 空）
+      const filesRaw = execFileSync('git', ['-C', meta.worktreePath, 'diff', '--name-only', diffBase], { encoding: 'utf8', stdio: ['ignore','pipe','ignore'] });
       const files = filesRaw ? filesRaw.trim().split('\n').filter(Boolean) : [];
       if (files.length > 0) {
         lines.push(``);