clawt 3.9.0 → 3.9.1

package/README.md

@@ -338,7 +338,7 @@ Configuration file is located at `~/.clawt/config.json`, auto-generated after in
 | `autoPullPush` | `false` | Auto pull/push after merge |
 | `confirmDestructiveOps` | `true` | Confirm before destructive operations |
 | `maxConcurrency` | `0` | Max concurrency for run command, `0` means unlimited |
-| `terminalApp` | `"auto"` | Terminal for batch resume: `auto` / `iterm2` / `terminal` |
+| `terminalApp` | `"auto"` | Terminal for batch resume: `auto` / `iterm2` / `terminal` / `cmux` |
 | `resumeInPlace` | `false` | Resume single selection in current terminal; `false` opens in new tab |
 | `aliases` | `{}` | Command alias mapping (e.g., `{"l": "list", "r": "run"}`) |
 | `autoUpdate` | `true` | Auto-check for new versions (checks npm registry every 24 hours) |

package/dist/index.js

@@ -545,9 +545,9 @@ var COVER_VALIDATE_MESSAGES = {
   /** 无快照，提示先执行 validate */
   COVER_VALIDATE_NO_SNAPSHOT: (branch) => `\u672A\u627E\u5230\u5206\u652F ${branch} \u7684 validate \u5FEB\u7167
   \u8BF7\u5148\u6267\u884C clawt validate -b ${branch} \u521B\u5EFA\u5FEB\u7167`,
-  /** patch 应用失败 */
-  COVER_VALIDATE_APPLY_FAILED: (branch) => `\u8986\u76D6\u53D8\u66F4\u5230 worktree ${branch} \u5931\u8D25\uFF1Apatch \u5E94\u7528\u51FA\u9519
-  \u8BF7\u68C0\u67E5\u76EE\u6807 worktree \u5DE5\u4F5C\u533A\u72B6\u6001\u540E\u91CD\u8BD5`,
+  /** 覆盖失败（tree checkout/clean 失败） */
+  COVER_VALIDATE_COVER_FAILED: (branch) => `\u8986\u76D6\u53D8\u66F4\u5230 worktree ${branch} \u5931\u8D25\uFF1Atree checkout \u6216\u6E05\u7406\u64CD\u4F5C\u51FA\u9519
+  \u8BF7\u68C0\u67E5\u76EE\u6807 worktree \u72B6\u6001\u540E\u91CD\u8BD5`,
   /** 工作区和暂存区无修改，可能为误操作 */
   COVER_VALIDATE_WORKING_DIR_CLEAN: "\u5F53\u524D\u9A8C\u8BC1\u5206\u652F\u7684\u5DE5\u4F5C\u533A\u548C\u6682\u5B58\u533A\u6CA1\u6709\u4EFB\u4F55\u4FEE\u6539\uFF0C\u53EF\u80FD\u4E3A\u8BEF\u64CD\u4F5C",
   /** 覆盖成功 */
@@ -1252,6 +1252,9 @@ function gitResetHard(cwd) {
 function gitCleanForce(cwd) {
   execCommand("git clean -fd", { cwd });
 }
+function gitCheckoutIndexForce(cwd) {
+  execCommand("git checkout-index -f -a", { cwd });
+}
 function gitStashPush(message, cwd) {
   execCommand(`git stash push -m "${message}"`, { cwd });
 }
@@ -5150,7 +5153,7 @@ function findTargetWorktreePath(branchName) {
   }
   return match.path;
 }
-function computeIncrementalPatch(snapshotTreeHash, mainWorktreePath) {
+function computeWorktreeTreeHash(mainWorktreePath) {
   const savedIndexTreeHash = gitWriteTree(mainWorktreePath);
   let currentTreeHash;
   try {
@@ -5159,11 +5162,7 @@ function computeIncrementalPatch(snapshotTreeHash, mainWorktreePath) {
   } finally {
     gitReadTree(savedIndexTreeHash, mainWorktreePath);
   }
-  if (snapshotTreeHash === currentTreeHash) {
-    return null;
-  }
-  const patch = gitDiffTree(snapshotTreeHash, currentTreeHash, mainWorktreePath);
-  return { patch, currentTreeHash };
+  return currentTreeHash;
 }
 async function handleCoverValidate() {
   await runPreChecks({ requireMainWorktree: true, requireHead: true, requireProjectConfig: true });
@@ -5185,18 +5184,20 @@ async function handleCoverValidate() {
     const confirmed = await confirmAction("\u662F\u5426\u7EE7\u7EED\u6267\u884C\u8986\u76D6\uFF1F");
     if (!confirmed) return;
   }
-  const result = computeIncrementalPatch(snapshotTreeHash, mainWorktreePath);
-  if (!result) {
+  const currentTreeHash = computeWorktreeTreeHash(mainWorktreePath);
+  if (snapshotTreeHash === currentTreeHash) {
     printInfo(MESSAGES.COVER_VALIDATE_NO_CHANGES);
     return;
   }
   try {
-    gitApplyFromStdin(result.patch, targetWorktreePath);
+    gitReadTree(currentTreeHash, targetWorktreePath);
+    gitCheckoutIndexForce(targetWorktreePath);
+    gitCleanForce(targetWorktreePath);
   } catch (error) {
-    logger.error(`cover-validate patch apply \u5931\u8D25: ${error}`);
-    throw new ClawtError(MESSAGES.COVER_VALIDATE_APPLY_FAILED(targetBranchName));
+    logger.error(`cover-validate \u8986\u76D6\u5931\u8D25: ${error}`);
+    throw new ClawtError(MESSAGES.COVER_VALIDATE_COVER_FAILED(targetBranchName));
   }
-  writeSnapshot(projectName, targetBranchName, result.currentTreeHash);
+  writeSnapshot(projectName, targetBranchName, currentTreeHash);
   printSuccess(MESSAGES.COVER_VALIDATE_SUCCESS(targetBranchName));
 }
 

package/dist/postinstall.js

@@ -522,9 +522,9 @@ var COVER_VALIDATE_MESSAGES = {
   /** 无快照，提示先执行 validate */
   COVER_VALIDATE_NO_SNAPSHOT: (branch) => `\u672A\u627E\u5230\u5206\u652F ${branch} \u7684 validate \u5FEB\u7167
   \u8BF7\u5148\u6267\u884C clawt validate -b ${branch} \u521B\u5EFA\u5FEB\u7167`,
-  /** patch 应用失败 */
-  COVER_VALIDATE_APPLY_FAILED: (branch) => `\u8986\u76D6\u53D8\u66F4\u5230 worktree ${branch} \u5931\u8D25\uFF1Apatch \u5E94\u7528\u51FA\u9519
-  \u8BF7\u68C0\u67E5\u76EE\u6807 worktree \u5DE5\u4F5C\u533A\u72B6\u6001\u540E\u91CD\u8BD5`,
+  /** 覆盖失败（tree checkout/clean 失败） */
+  COVER_VALIDATE_COVER_FAILED: (branch) => `\u8986\u76D6\u53D8\u66F4\u5230 worktree ${branch} \u5931\u8D25\uFF1Atree checkout \u6216\u6E05\u7406\u64CD\u4F5C\u51FA\u9519
+  \u8BF7\u68C0\u67E5\u76EE\u6807 worktree \u72B6\u6001\u540E\u91CD\u8BD5`,
   /** 工作区和暂存区无修改，可能为误操作 */
   COVER_VALIDATE_WORKING_DIR_CLEAN: "\u5F53\u524D\u9A8C\u8BC1\u5206\u652F\u7684\u5DE5\u4F5C\u533A\u548C\u6682\u5B58\u533A\u6CA1\u6709\u4EFB\u4F55\u4FEE\u6539\uFF0C\u53EF\u80FD\u4E3A\u8BEF\u64CD\u4F5C",
   /** 覆盖成功 */

package/docs/config-file.md

@@ -39,7 +39,7 @@
 | `autoPullPush` | `boolean` | `false` | merge 成功后是否自动执行 git pull 和 git push |
 | `confirmDestructiveOps` | `boolean` | `true` | 执行破坏性操作（reset、validate --clean）前是否提示确认 |
 | `maxConcurrency` | `number` | `0` | run 命令默认最大并发数，`0` 表示不限制 |
-| `terminalApp` | `string` | `"auto"` | 批量 resume 使用的终端应用：`auto`（自动检测）、`iterm2`、`terminal`（macOS） |
+| `terminalApp` | `string` | `"auto"` | 批量 resume 使用的终端应用：`auto`（自动检测）、`iterm2`、`terminal`、`cmux`（macOS） |
 | `resumeInPlace` | `boolean` | `false` | resume 单选时是否在当前终端就地打开，`false` 则通过 `terminalApp` 在新 Tab 中打开 |
 | `aliases` | `Record<string, string>` | `{}` | 命令别名映射，键为别名，值为目标内置命令名 |
 | `autoUpdate` | `boolean` | `true` | 是否启用自动更新检查（每 24 小时通过 npm registry 检查一次新版本） |

package/docs/cover-validate.md

@@ -44,20 +44,25 @@ clawt cover
 
 > 工作区干净时通常意味着用户没有在验证分支上做任何修改就执行了 cover，这大概率是误操作。增加确认提示可以避免不必要的覆盖操作。
 
-##### 步骤 4：计算增量 patch
+##### 步骤 4：计算当前 tree hash
 
-通过 `computeIncrementalPatch()` 计算验证分支上相对于快照的增量变更：
+通过 `computeWorktreeTreeHash()` 计算验证分支当前的完整 tree hash：
 
-1. 保存当前暂存区的 tree hash（`savedIndexTreeHash`），用于后续恢复
-2. `git add .` + `git write-tree` 获取当前工作区的完整 tree hash（`currentTreeHash`）
-3. 通过 `git read-tree` 恢复原始暂存区状态（无论成功失败都执行，在 `finally` 块中）
-4. 比较 `snapshotTreeHash` 与 `currentTreeHash`：
-   - **相同** → 无增量变更，输出提示后返回
-   - **不同** → 通过 `git diff-tree` 生成 patch
+1. 保存当前暂存区的 tree hash，用于后续恢复
+2. `git add .` + `git write-tree` 获取当前工作区的完整 tree hash
+3. 通过 `git read-tree` 恢复原始暂存区状态
 
-##### 步骤 5：应用 patch 到目标 worktree
+比较 snapshotTreeHash 与 currentTreeHash，如果相同则无变更，输出提示后返回。
 
-将增量 patch 通过 `git apply --binary` 应用到目标 worktree 的工作区。如果 patch apply 失败，报错退出并提示用户检查目标 worktree 工作区状态。
+##### 步骤 5：直接覆盖目标 worktree
+
+采用 **直接 checkout tree** 方式，实现真正的覆盖语义：
+
+1. **写入暂存区**：通过 `git read-tree <currentTreeHash>` 将验证分支的完整 tree 写入目标 worktree 的暂存区
+2. **强制检出工作区**：通过 `git checkout-index -f -a` 将暂存区内容强制写入工作区
+3. **清理残留文件**：通过 `git clean -fd` 删除目标 worktree 中未跟踪文件
+
+> **关键优势**：无基准依赖，无条件覆盖目标 worktree，符合 cover 的语义。
 
 ##### 步骤 6：更新快照
 
@@ -78,7 +83,7 @@ clawt cover
 | `COVER_VALIDATE_NO_SNAPSHOT` | 无快照 | 提示先执行 `clawt validate -b <branch>` 创建快照 |
 | `COVER_VALIDATE_NO_CHANGES` | 无增量变更 | 提示无需覆盖 |
 | `COVER_VALIDATE_WORKING_DIR_CLEAN` | 工作区干净 | 提示可能为误操作，需确认是否继续 |
-| `COVER_VALIDATE_APPLY_FAILED` | patch 应用失败 | 提示检查目标 worktree 工作区状态后重试 |
+| `COVER_VALIDATE_COVER_FAILED` | tree checkout/clean 失败 | 提示检查目标 worktree 状态后重试 |
 
 **实现要点：**
 
@@ -87,7 +92,11 @@ clawt cover
 - 辅助函数：
   - `extractTargetBranchName()`：从验证分支名提取目标分支名
   - `findTargetWorktreePath()`：查找目标 worktree 路径
-  - `computeIncrementalPatch()`：计算增量 patch
+  - `computeWorktreeTreeHash()`：计算当前工作区 tree hash（保存并恢复暂存区状态）
+- Git 工具函数：
+  - `gitReadTree()`：将 tree 写入暂存区
+  - `gitCheckoutIndexForce()`：强制检出暂存区到工作区
+  - `gitCleanForce()`：清理未跟踪文件
 - 消息常量：`COVER_VALIDATE_MESSAGES`（`src/constants/messages/cover-validate.ts`）
 - `writeSnapshot` 调用时只传 `treeHash`，利用其可选参数特性保留磁盘上的 `headCommitHash` 和 `stagedTreeHash` 原值
 

package/docs/resume.md

@@ -88,17 +88,18 @@ clawt resume -f tasks.md -c 2
 
 | 配置值     | 行为                                                         |
 | ---------- | ------------------------------------------------------------ |
-| `auto`     | 自动检测：优先检测 cmux 环境（通过 `CMUX_PANEL_ID` 环境变量），在 cmux 环境时在当前 pane 创建新 surface；否则检测 iTerm2 是否已安装，已安装则使用 iTerm2，否则降级到 Terminal.app |
-| `cmux`     | 在当前 cmux pane 中创建新 surface 执行命令                    |
+| `auto`     | 自动检测：优先检测 cmux 环境（通过 `CMUX_WORKSPACE_ID` 环境变量），在 cmux 环境时在当前 workspace 创建新 surface；否则检测 iTerm2 是否已安装，已安装则使用 iTerm2，否则降级到 Terminal.app |
+| `cmux`     | 在当前 cmux workspace 中创建新 surface 执行命令                |
 | `iterm2`   | 强制使用 iTerm2 创建新 Tab                                    |
 | `terminal` | 强制使用 Terminal.app 创建新 Tab                              |
 
 **平台限制：** 批量恢复目前仅支持 macOS 平台。非 macOS 平台会抛出错误。
 
 **cmux 集成说明：**
-- cmux 终端通过 `cmux new-surface --type terminal --pane <pane-id>` 创建新 surface
-- 创建后通过 `cmux send --surface <surface-id> <command>` 发送启动命令
-- 环境变量 `CMUX_PANEL_ID` 用于识别当前 pane，`CMUX_SURFACE_ID` 作为回退
+- 环境检测：通过 `CMUX_WORKSPACE_ID` 环境变量判断是否在 cmux 环境中
+- 创建 surface：使用 `cmux new-split right` 在右侧创建新 surface
+- 执行命令：通过 `cmux send --surface <surface-id> <command>\n` 发送命令（`\n` 触发自动执行）
+- 输出解析：支持简短格式 `surface:24` 和完整格式 `OK surface:24 pane:14 workspace:5`
 
 **权限要求：** Terminal.app 通过 System Events 模拟键盘操作（`Cmd+T`）新建 Tab，需要在「系统设置 → 隐私与安全性 → 辅助功能」中授权终端应用。iTerm2 使用原生 AppleScript 接口，无需辅助功能权限。cmux 通过 CLI 命令操作，无需特殊权限。
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "clawt",
-  "version": "3.9.0",
+  "version": "3.9.1",
   "description": "本地并行执行多个Claude Code Agent任务，融合 Git Worktree 与 Claude Code CLI 的命令行工具",
   "type": "module",
   "main": "dist/index.js",

package/src/commands/cover-validate.ts

@@ -15,8 +15,8 @@ import {
   gitAddAll,
   gitWriteTree,
   gitReadTree,
-  gitDiffTree,
-  gitApplyFromStdin,
+  gitCheckoutIndexForce,
+  gitCleanForce,
   printSuccess,
   printInfo,
   isWorkingDirClean,
@@ -62,15 +62,12 @@ export function findTargetWorktreePath(branchName: string): string {
 }
 
 /**
- * 计算验证分支上相对于快照的增量 patch
+ * 计算验证分支当前的 tree hash（保存并恢复暂存区状态）
  * 操作序列：git write-tree（保存暂存区）→ git add . → git write-tree（获取工作区 tree）→ git read-tree（恢复暂存区）
- * 当 snapshotTreeHash 与当前 tree hash 相同时返回 null 表示无变更
- * @param {string} snapshotTreeHash - 快照中记录的 tree hash
  * @param {string} mainWorktreePath - 主 worktree 路径
- * @returns {{ patch: Buffer; currentTreeHash: string } | null} 增量 patch 和当前 tree hash，无变更时返回 null
+ * @returns {string} 当前工作区对应的 tree hash
  */
-export function computeIncrementalPatch(snapshotTreeHash: string, mainWorktreePath: string): { patch: Buffer; currentTreeHash: string } | null {
-  // 先保存当前暂存区的 tree hash，用于后续恢复
+export function computeWorktreeTreeHash(mainWorktreePath: string): string {
   const savedIndexTreeHash = gitWriteTree(mainWorktreePath);
   let currentTreeHash: string;
 
@@ -78,17 +75,10 @@ export function computeIncrementalPatch(snapshotTreeHash: string, mainWorktreePa
     gitAddAll(mainWorktreePath);
     currentTreeHash = gitWriteTree(mainWorktreePath);
   } finally {
-    // 无论成功或失败，都通过 git read-tree 恢复原始暂存区状态
     gitReadTree(savedIndexTreeHash, mainWorktreePath);
   }
 
-  // 快照 tree 与当前 tree 相同，无增量变更
-  if (snapshotTreeHash === currentTreeHash) {
-    return null;
-  }
-
-  const patch = gitDiffTree(snapshotTreeHash, currentTreeHash, mainWorktreePath);
-  return { patch, currentTreeHash };
+  return currentTreeHash;
 }
 
 /**
@@ -127,23 +117,26 @@ async function handleCoverValidate(): Promise<void> {
     if (!confirmed) return;
   }
 
-  // 步骤 4：计算增量 patch
-  const result = computeIncrementalPatch(snapshotTreeHash, mainWorktreePath);
-  if (!result) {
+  // 步骤 4：计算当前 tree hash
+  const currentTreeHash = computeWorktreeTreeHash(mainWorktreePath);
+
+  if (snapshotTreeHash === currentTreeHash) {
     printInfo(MESSAGES.COVER_VALIDATE_NO_CHANGES);
     return;
   }
 
-  // 步骤 5：应用 patch 到目标 worktree
+  // 步骤 5：直接将 tree 应用到目标 worktree
   try {
-    gitApplyFromStdin(result.patch, targetWorktreePath);
+    gitReadTree(currentTreeHash, targetWorktreePath);
+    gitCheckoutIndexForce(targetWorktreePath);
+    gitCleanForce(targetWorktreePath);
   } catch (error) {
-    logger.error(`cover-validate patch apply 失败: ${error}`);
-    throw new ClawtError(MESSAGES.COVER_VALIDATE_APPLY_FAILED(targetBranchName));
+    logger.error(`cover-validate 覆盖失败: ${error}`);
+    throw new ClawtError(MESSAGES.COVER_VALIDATE_COVER_FAILED(targetBranchName));
   }
 
   // 步骤 6：更新快照 treeHash（使后续再次 cover 的基准正确），HEAD 和 stagedTreeHash 不变
-  writeSnapshot(projectName, targetBranchName, result.currentTreeHash);
+  writeSnapshot(projectName, targetBranchName, currentTreeHash);
 
   printSuccess(MESSAGES.COVER_VALIDATE_SUCCESS(targetBranchName));
 }

package/src/constants/messages/cover-validate.ts

@@ -10,9 +10,9 @@ export const COVER_VALIDATE_MESSAGES = {
   /** 无快照，提示先执行 validate */
   COVER_VALIDATE_NO_SNAPSHOT: (branch: string) =>
     `未找到分支 ${branch} 的 validate 快照\n  请先执行 clawt validate -b ${branch} 创建快照`,
-  /** patch 应用失败 */
-  COVER_VALIDATE_APPLY_FAILED: (branch: string) =>
-    `覆盖变更到 worktree ${branch} 失败：patch 应用出错\n  请检查目标 worktree 工作区状态后重试`,
+  /** 覆盖失败（tree checkout/clean 失败） */
+  COVER_VALIDATE_COVER_FAILED: (branch: string) =>
+    `覆盖变更到 worktree ${branch} 失败：tree checkout 或清理操作出错\n  请检查目标 worktree 状态后重试`,
   /** 工作区和暂存区无修改，可能为误操作 */
   COVER_VALIDATE_WORKING_DIR_CLEAN: '当前验证分支的工作区和暂存区没有任何修改，可能为误操作',
   /** 覆盖成功 */

package/src/utils/git-core.ts

@@ -159,6 +159,14 @@ export function gitCleanForce(cwd?: string): void {
   execCommand('git clean -fd', { cwd });
 }
 
+/**
+ * git checkout-index -f -a，将暂存区内容强制写入工作区（覆盖工作区文件）
+ * @param {string} [cwd] - 工作目录
+ */
+export function gitCheckoutIndexForce(cwd?: string): void {
+  execCommand('git checkout-index -f -a', { cwd });
+}
+
 /**
  * git stash push -m <message>
  * @param {string} message - stash 消息

package/src/utils/index.ts

@@ -22,6 +22,7 @@ export {
   gitPush,
   gitResetHard,
   gitCleanForce,
+  gitCheckoutIndexForce,
   gitStashPush,
   gitStashApply,
   gitStashPop,

package/tests/unit/commands/cover-validate.test.ts

@@ -21,7 +21,7 @@ vi.mock('../../../src/constants/index.js', () => ({
     COVER_VALIDATE_NO_CHANGES: '验证分支上没有相对于快照的增量修改，无需覆盖',
     COVER_VALIDATE_TARGET_NOT_FOUND: (branch: string) => `未找到分支 ${branch} 对应的 worktree`,
     COVER_VALIDATE_NO_SNAPSHOT: (branch: string) => `未找到分支 ${branch} 的 validate 快照`,
-    COVER_VALIDATE_APPLY_FAILED: (branch: string) => `覆盖变更到 worktree ${branch} 失败`,
+    COVER_VALIDATE_COVER_FAILED: (branch: string) => `覆盖变更到 worktree ${branch} 失败`,
     COVER_VALIDATE_SUCCESS: (branch: string) => `✓ 已将验证分支上的修改覆盖到 worktree => ${branch}`,
     COVER_VALIDATE_WORKING_DIR_CLEAN: '当前验证分支的工作区和暂存区没有任何修改，可能为误操作',
   },
@@ -42,8 +42,8 @@ vi.mock('../../../src/utils/index.js', () => ({
   gitAddAll: vi.fn(),
   gitWriteTree: vi.fn().mockReturnValue('current-tree-hash'),
   gitReadTree: vi.fn(),
-  gitDiffTree: vi.fn().mockReturnValue(Buffer.from('fake-patch')),
-  gitApplyFromStdin: vi.fn(),
+  gitCheckoutIndexForce: vi.fn(),
+  gitCleanForce: vi.fn(),
   printSuccess: vi.fn(),
   printInfo: vi.fn(),
   isWorkingDirClean: vi.fn().mockReturnValue(false),
@@ -53,7 +53,7 @@ vi.mock('../../../src/utils/index.js', () => ({
   isNonInteractive: vi.fn().mockReturnValue(false),
 }));
 
-import { registerCoverValidateCommand, extractTargetBranchName, findTargetWorktreePath, computeIncrementalPatch } from '../../../src/commands/cover-validate.js';
+import { registerCoverValidateCommand, extractTargetBranchName, findTargetWorktreePath, computeWorktreeTreeHash } from '../../../src/commands/cover-validate.js';
 import {
   getCurrentBranch,
   getProjectWorktrees,
@@ -64,8 +64,8 @@ import {
   gitAddAll,
   gitWriteTree,
   gitReadTree,
-  gitDiffTree,
-  gitApplyFromStdin,
+  gitCheckoutIndexForce,
+  gitCleanForce,
   printSuccess,
   printInfo,
   isWorkingDirClean,
@@ -81,8 +81,8 @@ const mockedWriteSnapshot = vi.mocked(writeSnapshot);
 const mockedGitAddAll = vi.mocked(gitAddAll);
 const mockedGitWriteTree = vi.mocked(gitWriteTree);
 const mockedGitReadTree = vi.mocked(gitReadTree);
-const mockedGitDiffTree = vi.mocked(gitDiffTree);
-const mockedGitApplyFromStdin = vi.mocked(gitApplyFromStdin);
+const mockedGitCheckoutIndexForce = vi.mocked(gitCheckoutIndexForce);
+const mockedGitCleanForce = vi.mocked(gitCleanForce);
 const mockedPrintSuccess = vi.mocked(printSuccess);
 const mockedPrintInfo = vi.mocked(printInfo);
 const mockedIsWorkingDirClean = vi.mocked(isWorkingDirClean);
@@ -99,7 +99,6 @@ beforeEach(() => {
   mockedIsWorkingDirClean.mockReturnValue(false);
   mockedConfirmAction.mockResolvedValue(true);
   mockedGitWriteTree.mockReturnValue('current-tree-hash');
-  mockedGitDiffTree.mockReturnValue(Buffer.from('fake-patch'));
 });
 
 describe('registerCoverValidateCommand', () => {
@@ -130,27 +129,16 @@ describe('findTargetWorktreePath', () => {
   });
 });
 
-describe('computeIncrementalPatch', () => {
-  it('有增量变更时返回 patch 和 currentTreeHash', () => {
+describe('computeWorktreeTreeHash', () => {
+  it('返回当前工作区的 tree hash', () => {
     mockedGitWriteTree
       .mockReturnValueOnce('saved-index-tree')  // 保存暂存区
       .mockReturnValueOnce('new-tree-hash');     // git add . 后的 tree
 
-    const result = computeIncrementalPatch('snapshot-tree-hash', '/repo');
-    expect(result).not.toBeNull();
-    expect(result!.currentTreeHash).toBe('new-tree-hash');
+    const result = computeWorktreeTreeHash('/repo');
+    expect(result).toBe('new-tree-hash');
     expect(mockedGitAddAll).toHaveBeenCalledWith('/repo');
     expect(mockedGitReadTree).toHaveBeenCalledWith('saved-index-tree', '/repo');
-    expect(mockedGitDiffTree).toHaveBeenCalledWith('snapshot-tree-hash', 'new-tree-hash', '/repo');
-  });
-
-  it('无增量变更时返回 null', () => {
-    mockedGitWriteTree
-      .mockReturnValueOnce('saved-index-tree')
-      .mockReturnValueOnce('snapshot-tree-hash'); // 与快照相同
-
-    const result = computeIncrementalPatch('snapshot-tree-hash', '/repo');
-    expect(result).toBeNull();
   });
 });
 
@@ -163,7 +151,7 @@ describe('handleCoverValidate - 工作区干净检查', () => {
     await program.parseAsync(['cover'], { from: 'user' });
   }
 
-  it('工作区干净且用户取消时不执行 patch', async () => {
+  it('工作区干净且用户取消时不执行覆盖', async () => {
     mockedIsWorkingDirClean.mockReturnValue(true);
     mockedConfirmAction.mockResolvedValue(false);
 
@@ -173,14 +161,14 @@ describe('handleCoverValidate - 工作区干净检查', () => {
     expect(mockedConfirmAction).toHaveBeenCalledWith('是否继续执行覆盖？');
     // 用户取消后不应继续执行后续逻辑
     expect(mockedGitAddAll).not.toHaveBeenCalled();
-    expect(mockedGitApplyFromStdin).not.toHaveBeenCalled();
+    expect(mockedGitCheckoutIndexForce).not.toHaveBeenCalled();
+    expect(mockedGitCleanForce).not.toHaveBeenCalled();
     expect(mockedPrintSuccess).not.toHaveBeenCalled();
   });
 
   it('工作区干净且用户确认继续时正常执行', async () => {
     mockedIsWorkingDirClean.mockReturnValue(true);
     mockedConfirmAction.mockResolvedValue(true);
-    // computeIncrementalPatch 返回有 patch 的结果
     mockedGitWriteTree
       .mockReturnValueOnce('saved-index-tree')
       .mockReturnValueOnce('new-tree-hash');
@@ -188,7 +176,9 @@ describe('handleCoverValidate - 工作区干净检查', () => {
     await runCover();
 
     expect(mockedConfirmAction).toHaveBeenCalledWith('是否继续执行覆盖？');
-    expect(mockedGitApplyFromStdin).toHaveBeenCalled();
+    expect(mockedGitReadTree).toHaveBeenCalledWith('new-tree-hash', '/path/feature');
+    expect(mockedGitCheckoutIndexForce).toHaveBeenCalledWith('/path/feature');
+    expect(mockedGitCleanForce).toHaveBeenCalledWith('/path/feature');
     expect(mockedPrintSuccess).toHaveBeenCalled();
   });
 
@@ -201,7 +191,9 @@ describe('handleCoverValidate - 工作区干净检查', () => {
     await runCover();
 
     expect(mockedConfirmAction).not.toHaveBeenCalled();
-    expect(mockedGitApplyFromStdin).toHaveBeenCalled();
+    expect(mockedGitReadTree).toHaveBeenCalledWith('new-tree-hash', '/path/feature');
+    expect(mockedGitCheckoutIndexForce).toHaveBeenCalledWith('/path/feature');
+    expect(mockedGitCleanForce).toHaveBeenCalledWith('/path/feature');
     expect(mockedPrintSuccess).toHaveBeenCalled();
   });
 });

package/tests/unit/utils/git.test.ts

@@ -36,6 +36,7 @@ import {
   gitPush,
   gitResetHard,
   gitCleanForce,
+  gitCheckoutIndexForce,
   gitStashPush,
   gitStashApply,
   gitStashPop,
@@ -251,6 +252,13 @@ describe('gitCleanForce', () => {
   });
 });
 
+describe('gitCheckoutIndexForce', () => {
+  it('执行 git checkout-index -f -a', () => {
+    gitCheckoutIndexForce('/repo');
+    expect(mockedExecCommand).toHaveBeenCalledWith('git checkout-index -f -a', { cwd: '/repo' });
+  });
+});
+
 describe('gitStashPush', () => {
   it('执行 git stash push -m', () => {
     gitStashPush('auto-stash', '/repo');