clawt 2.5.1 → 2.7.0

package/.claude/agent-memory/docs-sync-updater/MEMORY.md

@@ -9,17 +9,10 @@
 - merge 命令对应 `5.6 合并验证过的分支`，流程按步骤编号描述
 - config 命令对应 `5.10 查看全局配置`，只读展示配置
 - resume 命令对应 `5.11 在已有 Worktree 中恢复会话`，支持模糊匹配和交互式分支选择（-b 可选）
+- validate 命令对应 `5.4 在主 Worktree 验证其他分支`，-b 可选，支持模糊匹配（与 resume 共享匹配逻辑）
 - 配置项说明在 `5.7 默认配置文件` 章节的表格中
 - 更新模式：新增步骤时追加编号，配置项影响范围变化时更新说明列
 
-### CLAUDE.md
-- 面向 Claude Code 的项目架构指引，精简扼要
-- run 命令流程在 `核心流程（run 命令）` 章节，编号列表描述
-- resume 命令流程在独立的 `### resume 命令流程` 章节，编号列表 + 缩进列表描述匹配策略
-- merge 和 run 中断清理在 `validate + merge 工作流` 章节，一行式描述用箭头连接流程
-- utils 目录描述用括号内逗号分隔列举功能模块
-- 更新模式：编号列表追加步骤，箭头链追加阶段，括号内追加关键词
-
 ### README.md
 - 面向用户的使用文档
 - 每个命令一个 `###` 小节，含命令格式、参数表格、简要说明、示例
@@ -46,12 +39,11 @@
 
 ## 配置项同步检查点
 
-配置项变更时需在以下 5 处保持一致：
+配置项变更时需在以下 4 处保持一致：
 1. `src/constants/config.ts` — CONFIG_DEFINITIONS 对象（单一数据源，包含 defaultValue + description）
 2. `src/types/config.ts` — ClawtConfig 接口
 3. `docs/spec.md` — 5.7 默认配置文件章节（JSON 示例 + 配置项表格）
-4. `CLAUDE.md` — 关键约定段落中的配置描述
-5. `README.md` — 配置文件章节（JSON 示例 + 配置项表格）
+4. `README.md` — 配置文件章节（JSON 示例 + 配置项表格）
 
 ## 配置架构
 
@@ -65,7 +57,6 @@
 run 命令有两种模式（自 claudeCodeCommand 特性后）：
 - 不传 `--tasks`：交互式界面模式（单 worktree + `launchInteractiveClaude` + spawnSync）
 - 传 `--tasks`：并行任务模式（多 worktree + `executeClaudeTask` + spawnProcess）
-- CLAUDE.md 中的核心流程按模式分段描述
 
 ## 命令清单（10 个）
 
@@ -75,20 +66,26 @@ Notes:
 - resume 和 run（交互式模式）共用 `launchInteractiveClaude()`，该函数从 run.ts 提取到 src/utils/claude.ts
 - `claudeCodeCommand` 配置项同时影响 run 交互式模式和 resume 命令
 - reset 命令与 validate --clean 的区别：reset 不删除快照文件，validate --clean 会删除快照
-- resume 的 `-b` 参数为可选，核心函数 `resolveTargetWorktree()` 封装匹配策略：精确→模糊（子串，大小写不敏感）→交互选择
-- resume 的交互式选择使用 Enquirer.Select（`promptSelectBranch()`），消息常量在 `MESSAGES.RESUME_*`
+- `resolveTargetWorktree()` 是 resume 和 validate 共用的分支匹配函数（在 src/utils/worktree-matcher.ts）
+- `WorktreeResolveMessages` 接口实现命令间消息解耦，每个命令传入各自的提示文案
+- resume 的消息常量在 `MESSAGES.RESUME_*`，validate 的消息常量在 `MESSAGES.VALIDATE_*`
+- resume 和 validate 的 `-b` 参数均为可选，匹配策略一致：精确→模糊（子串，大小写不敏感）→交互选择
+- validate 的交互式选择和 resume 使用同一个 `promptSelectBranch()`（Enquirer.Select）
 
 ## validate 快照机制
 
 - validate 命令支持首次/增量两种模式，通过 `hasSnapshot()` 判断
-- 快照路径：`~/.clawt/validate-snapshots/<projectName>/<branchName>.tree`（存储 git tree 对象 hash）
+- 快照由两个文件组成：`.tree`（git tree 对象 hash）和 `.head`（快照时主 worktree 的 HEAD commit hash）
+- 快照路径：`~/.clawt/validate-snapshots/<projectName>/<branchName>.tree` 和 `<branchName>.head`
 - 常量 `VALIDATE_SNAPSHOTS_DIR` 定义在 `src/constants/paths.ts`
 - validate 新增 `--clean` 选项（`ValidateOptions.clean?: boolean`）
-- 快照保存：`git add . → git write-tree → git restore --staged .`，将 tree hash 写入 `.tree` 文件
-- 增量模式核心：`git read-tree <旧 tree hash>` 将旧快照载入暂存区 + 新全量变更在工作目录 → `git diff` 可查看增量差异
-- tree 对象不依赖主分支 HEAD，无需一致性校验（旧方案需要 `.head` 文件校验 HEAD 一致性）
-- 增量 read-tree 失败时自动降级为全量模式（tree 对象可能被 git gc 回收）
-- git 层有 `gitWriteTree()`（返回 tree hash）和 `gitReadTree()`（载入暂存区）
+- 快照保存：`git add . → git write-tree → git rev-parse HEAD → git restore --staged .`，tree hash 写入 `.tree`，HEAD commit hash 写入 `.head`
+- 增量模式核心：检测 HEAD 是否变化决定策略
+  - HEAD 未变化：`git read-tree <旧 tree hash>` 直接载入暂存区
+  - HEAD 已变化：提取旧变更 patch（`git diff-tree` 旧 HEAD tree → 旧快照 tree），`git apply --cached` 重放到当前 HEAD 暂存区；有冲突则降级全量
+- 增量 read-tree / apply 失败时自动降级为全量模式
+- git 层工具函数：`gitWriteTree()`、`gitReadTree()`、`getCommitTreeHash()`、`gitDiffTree()`、`gitApplyCachedCheck()`
+- `readSnapshot()` 返回 `{ treeHash, headCommitHash }`，`writeSnapshot()` 接收 4 个参数（含 headCommitHash）
+- `removeSnapshot()` 同时清理 `.tree` 和 `.head` 文件
 - merge 成功后自动清理对应快照；merge 时主 worktree 脏 + 存在快照会输出警告提示
 - docs/spec.md 中 validate 章节（5.4）按 `--clean 模式`、`首次 validate`、`增量 validate` 三段描述
-- CLAUDE.md 中在 validate + merge 工作流章节用缩进列表描述两种模式

package/.claude/agents/docs-sync-updater.md

@@ -1,11 +1,11 @@
 ---
 name: docs-sync-updater
-description: "Use this agent when the user explicitly requests to synchronize documentation files (docs/spec.md, CLAUDE.md, README.md) based on recent code changes in the working area or staging area. This agent must NEVER be called proactively or automatically — it must only be invoked when the user explicitly asks for documentation synchronization.\\n\\nExamples:\\n\\n- Example 1:\\n  user: \"请同步更新文档\"\\n  assistant: \"好的，我来调用文档同步 agent 来根据当前代码变更更新相关文档。\"\\n  <Use the Task tool to launch the docs-sync-updater agent>\\n\\n- Example 2:\\n  user: \"代码改完了，帮我把文档也更新一下\"\\n  assistant: \"收到，我现在使用文档同步 agent 来分析代码变更并更新 docs/spec.md、CLAUDE.md 和 README.md。\"\\n  <Use the Task tool to launch the docs-sync-updater agent>\\n\\n- Example 3:\\n  user: \"update docs based on my changes\"\\n  assistant: \"好的，我来启动文档同步 agent，根据工作区和暂存区的变更同步更新文档。\"\\n  <Use the Task tool to launch the docs-sync-updater agent>\\n\\n- Counter-example (DO NOT do this):\\n  user: \"我刚加了一个新命令\"\\n  assistant: (DO NOT proactively launch this agent. Wait for the user to explicitly request documentation updates.)"
+description: "Use this agent when the user explicitly requests to synchronize documentation files (docs/spec.md, README.md) based on recent code changes in the working area or staging area. This agent must NEVER be called proactively or automatically — it must only be invoked when the user explicitly asks for documentation synchronization.\\n\\nExamples:\\n\\n- Example 1:\\n  user: \"请同步更新文档\"\\n  assistant: \"好的，我来调用文档同步 agent 来根据当前代码变更更新相关文档。\"\\n  <Use the Task tool to launch the docs-sync-updater agent>\\n\\n- Example 2:\\n  user: \"代码改完了，帮我把文档也更新一下\"\\n  assistant: \"收到，我现在使用文档同步 agent 来分析代码变更并更新 docs/spec.md 和 README.md。\"\\n  <Use the Task tool to launch the docs-sync-updater agent>\\n\\n- Example 3:\\n  user: \"update docs based on my changes\"\\n  assistant: \"好的，我来启动文档同步 agent，根据工作区和暂存区的变更同步更新文档。\"\\n  <Use the Task tool to launch the docs-sync-updater agent>\\n\\n- Counter-example (DO NOT do this):\\n  user: \"我刚加了一个新命令\"\\n  assistant: (DO NOT proactively launch this agent. Wait for the user to explicitly request documentation updates.)"
 model: opus
 memory: project
 ---
 
-你是一位资深的技术文档工程师，精通代码变更分析与文档同步维护。你的核心职责是根据当前工作区（working directory）和暂存区（staging area）的代码修改，精准地同步更新项目中的三个关键文档：`docs/spec.md`、`CLAUDE.md` 和 `README.md`。
+你是一位资深的技术文档工程师，精通代码变更分析与文档同步维护。你的核心职责是根据当前工作区（working directory）和暂存区（staging area）的代码修改，精准地同步更新项目中的两个关键文档：`docs/spec.md` 和 `README.md`。
 
 ## 重要约束
 
@@ -33,15 +33,13 @@ memory: project
 ### 第二步：阅读现有文档
 
 1. 读取 `docs/spec.md` 的当前内容（如果存在）。
-2. 读取 `CLAUDE.md` 的当前内容。
-3. 读取 `README.md` 的当前内容（如果存在）。
-4. 理解每个文档的结构、风格和覆盖范围。
+2. 读取 `README.md` 的当前内容（如果存在）。
+3. 理解每个文档的结构、风格和覆盖范围。
 
 ### 第三步：确定需要更新的内容
 
 对每个文档，判断代码变更是否影响其内容：
 
-- **`CLAUDE.md`**：项目架构说明、命令列表、核心流程、目录层级、关键约定、构建命令等。当新增命令、修改架构、调整目录结构、修改构建流程时需要更新。
 - **`docs/spec.md`**：项目规格说明文档。当功能需求、技术规格、API 设计发生变化时需要更新。
 - **`README.md`**：用户面向的项目说明。当用户可见的功能、安装方式、使用方法、命令参数发生变化时需要更新。
 
@@ -83,7 +81,7 @@ memory: project
 - 如果工作区和暂存区都没有变更，检查最近的提交并告知用户当前没有未提交的变更，询问是否基于最近提交更新。
 - 如果某个文档文件不存在，告知用户并询问是否需要创建。
 - 如果变更内容过于复杂或不确定如何反映到文档中，列出你的理解并询问用户确认。
-- 如果变更只涉及代码重构而不改变功能，可能不需要更新面向用户的文档（README.md），但可能需要更新架构文档（CLAUDE.md）。
+- 如果变更只涉及代码重构而不改变功能，可能不需要更新面向用户的文档（README.md），但可能需要更新规格文档（docs/spec.md）。
 
 **Update your agent memory** as you discover documentation patterns, document structure conventions, terminology usage, and relationships between code modules and their documentation sections. This builds up institutional knowledge across conversations. Write concise notes about what you found and where.
 

package/README.md

@@ -107,29 +107,44 @@ clawt resume
 ### `clawt validate` — 在主 worktree 验证分支变更
 
 ```bash
+# 指定分支名（支持模糊匹配）
 clawt validate -b <branchName> [--clean]
+
+# 不指定分支名（列出所有分支供选择）
+clawt validate [--clean]
 ```
 
 | 参数 | 必填 | 说明 |
 | ---- | ---- | ---- |
-| `-b` | 是 | 要验证的分支名 |
+| `-b` | 否 | 要验证的分支名（支持模糊匹配，不传则列出所有分支供选择） |
 | `--clean` | 否 | 清理 validate 状态（重置主 worktree 并删除快照） |
 
 将目标 worktree 的变更通过 `git diff`（三点 diff）迁移到主 worktree，方便在主 worktree 中直接测试，无需重新安装依赖。同时检测未提交修改和已提交 commit，确保所有变更都能被捕获。
 
-支持增量模式：首次 validate 后会自动保存快照（通过 `git write-tree` 将变更存储为 git tree 对象），再次 validate 同一分支时会通过 `git read-tree` 将上次快照载入暂存区、最新变更保留在工作目录，用户可通过 `git diff` 查看两次 validate 之间的增量差异。使用 `--clean` 可清理 validate 状态（重置主 worktree 并删除快照文件）。
+**分支匹配策略：**
+- 传 `-b` 时，优先精确匹配分支名；未精确匹配则进行模糊匹配（子串匹配，大小写不敏感）；模糊匹配到多个时通过交互列表选择；无匹配时报错并列出所有可用分支
+- 不传 `-b` 时，列出当前项目所有可用分支供交互式选择（仅 1 个时自动使用）
+
+支持增量模式：首次 validate 后会自动保存快照（通过 `git write-tree` 将变更存储为 git tree 对象，并记录当前 HEAD commit hash），再次 validate 同一分支时会将上次快照载入暂存区、最新变更保留在工作目录，用户可通过 `git diff` 查看两次 validate 之间的增量差异。当主分支 HEAD 发生变化（如合并了其他分支）时，会自动将旧变更 patch 重放到当前 HEAD 暂存区上，避免 diff 混入 HEAD 变化的内容；若 patch 存在冲突则自动降级为全量模式。使用 `--clean` 可清理 validate 状态（重置主 worktree 并删除快照文件）。
 
 > **提示：** 如果 validate 时 patch apply 失败（目标分支与主分支差异过大），可先执行 `clawt sync -b <branchName>` 同步主分支后重试。
 
 ```bash
-# 首次验证
+# 精确匹配分支名
 clawt validate -b feature-scheme-1
 
+# 模糊匹配（匹配包含 "scheme" 的分支）
+clawt validate -b scheme
+
+# 交互式选择所有分支
+clawt validate
+
 # 再次验证（增量模式，可通过 git diff 查看增量差异）
 clawt validate -b feature-scheme-1
 
-# 清理 validate 状态
+# 清理 validate 状态（同样支持模糊匹配）
 clawt validate -b feature-scheme-1 --clean
+clawt validate --clean
 ```
 
 ### `clawt sync` — 将主分支代码同步到目标 worktree

package/dist/index.js

@@ -134,7 +134,17 @@ ${branches.map((b) => `    - ${b}`).join("\n")}`,
   /** resume 交互选择提示 */
   RESUME_SELECT_BRANCH: "\u8BF7\u9009\u62E9\u8981\u6062\u590D\u7684\u5206\u652F",
   /** resume 模糊匹配到多个结果提示 */
-  RESUME_MULTIPLE_MATCHES: (name) => `"${name}" \u5339\u914D\u5230\u591A\u4E2A\u5206\u652F\uFF0C\u8BF7\u9009\u62E9\uFF1A`
+  RESUME_MULTIPLE_MATCHES: (name) => `"${name}" \u5339\u914D\u5230\u591A\u4E2A\u5206\u652F\uFF0C\u8BF7\u9009\u62E9\uFF1A`,
+  /** validate 无可用 worktree */
+  VALIDATE_NO_WORKTREES: "\u5F53\u524D\u9879\u76EE\u6CA1\u6709\u53EF\u7528\u7684 worktree\uFF0C\u8BF7\u5148\u901A\u8FC7 clawt run \u6216 clawt create \u521B\u5EFA",
+  /** validate 模糊匹配无结果，列出可用分支 */
+  VALIDATE_NO_MATCH: (name, branches) => `\u672A\u627E\u5230\u4E0E "${name}" \u5339\u914D\u7684\u5206\u652F
+  \u53EF\u7528\u5206\u652F\uFF1A
+${branches.map((b) => `    - ${b}`).join("\n")}`,
+  /** validate 交互选择提示 */
+  VALIDATE_SELECT_BRANCH: "\u8BF7\u9009\u62E9\u8981\u9A8C\u8BC1\u7684\u5206\u652F",
+  /** validate 模糊匹配到多个结果提示 */
+  VALIDATE_MULTIPLE_MATCHES: (name) => `"${name}" \u5339\u914D\u5230\u591A\u4E2A\u5206\u652F\uFF0C\u8BF7\u9009\u62E9\uFF1A`
 };
 
 // src/constants/exitCodes.ts
@@ -368,9 +378,15 @@ function getDiffStat(worktreePath) {
   const output = execCommand("git diff --shortstat HEAD", { cwd: worktreePath });
   return parseShortStat(output);
 }
+function gitApplyCachedFromStdin(patchContent, cwd) {
+  execCommandWithInput("git", ["apply", "--cached"], { input: patchContent, cwd });
+}
 function getCurrentBranch(cwd) {
   return execCommand("git rev-parse --abbrev-ref HEAD", { cwd });
 }
+function getHeadCommitHash(cwd) {
+  return execCommand("git rev-parse HEAD", { cwd });
+}
 function gitDiffBinaryAgainstBranch(branchName, cwd) {
   logger.debug(`\u6267\u884C\u547D\u4EE4: git diff HEAD...${branchName} --binary${cwd ? ` (cwd: ${cwd})` : ""}`);
   return execSync2(`git diff HEAD...${branchName} --binary`, {
@@ -405,6 +421,24 @@ function gitWriteTree(cwd) {
 function gitReadTree(treeHash, cwd) {
   execCommand(`git read-tree ${treeHash}`, { cwd });
 }
+function getCommitTreeHash(commitHash, cwd) {
+  return execCommand(`git rev-parse ${commitHash}^{tree}`, { cwd });
+}
+function gitDiffTree(baseTreeHash, targetTreeHash, cwd) {
+  logger.debug(`\u6267\u884C\u547D\u4EE4: git diff-tree -p --binary ${baseTreeHash} ${targetTreeHash}${cwd ? ` (cwd: ${cwd})` : ""}`);
+  return execSync2(`git diff-tree -p --binary ${baseTreeHash} ${targetTreeHash}`, {
+    cwd,
+    stdio: ["pipe", "pipe", "pipe"]
+  });
+}
+function gitApplyCachedCheck(patchContent, cwd) {
+  try {
+    execCommandWithInput("git", ["apply", "--cached", "--check"], { input: patchContent, cwd });
+    return true;
+  } catch {
+    return false;
+  }
+}
 
 // src/utils/formatter.ts
 import chalk from "chalk";
@@ -667,27 +701,40 @@ import { existsSync as existsSync5, readFileSync as readFileSync2, writeFileSync
 function getSnapshotPath(projectName, branchName) {
   return join3(VALIDATE_SNAPSHOTS_DIR, projectName, `${branchName}.tree`);
 }
+function getSnapshotHeadPath(projectName, branchName) {
+  return join3(VALIDATE_SNAPSHOTS_DIR, projectName, `${branchName}.head`);
+}
 function hasSnapshot(projectName, branchName) {
   return existsSync5(getSnapshotPath(projectName, branchName));
 }
-function readSnapshotTreeHash(projectName, branchName) {
+function readSnapshot(projectName, branchName) {
   const snapshotPath = getSnapshotPath(projectName, branchName);
+  const headPath = getSnapshotHeadPath(projectName, branchName);
   logger.debug(`\u8BFB\u53D6 validate \u5FEB\u7167: ${snapshotPath}`);
-  return readFileSync2(snapshotPath, "utf-8").trim();
+  const treeHash = existsSync5(snapshotPath) ? readFileSync2(snapshotPath, "utf-8").trim() : "";
+  const headCommitHash = existsSync5(headPath) ? readFileSync2(headPath, "utf-8").trim() : "";
+  return { treeHash, headCommitHash };
 }
-function writeSnapshot(projectName, branchName, treeHash) {
+function writeSnapshot(projectName, branchName, treeHash, headCommitHash) {
   const snapshotPath = getSnapshotPath(projectName, branchName);
+  const headPath = getSnapshotHeadPath(projectName, branchName);
   const snapshotDir = join3(VALIDATE_SNAPSHOTS_DIR, projectName);
   ensureDir(snapshotDir);
   writeFileSync2(snapshotPath, treeHash, "utf-8");
-  logger.info(`\u5DF2\u4FDD\u5B58 validate \u5FEB\u7167: ${snapshotPath}`);
+  writeFileSync2(headPath, headCommitHash, "utf-8");
+  logger.info(`\u5DF2\u4FDD\u5B58 validate \u5FEB\u7167: ${snapshotPath}, ${headPath}`);
 }
 function removeSnapshot(projectName, branchName) {
   const snapshotPath = getSnapshotPath(projectName, branchName);
+  const headPath = getSnapshotHeadPath(projectName, branchName);
   if (existsSync5(snapshotPath)) {
     unlinkSync(snapshotPath);
     logger.info(`\u5DF2\u5220\u9664 validate \u5FEB\u7167: ${snapshotPath}`);
   }
+  if (existsSync5(headPath)) {
+    unlinkSync(headPath);
+    logger.info(`\u5DF2\u5220\u9664 validate \u5FEB\u7167: ${headPath}`);
+  }
 }
 function removeProjectSnapshots(projectName) {
   const projectDir = join3(VALIDATE_SNAPSHOTS_DIR, projectName);
@@ -705,6 +752,50 @@ function removeProjectSnapshots(projectName) {
   logger.info(`\u5DF2\u5220\u9664\u9879\u76EE ${projectName} \u7684\u6240\u6709 validate \u5FEB\u7167`);
 }
 
+// src/utils/worktree-matcher.ts
+import Enquirer2 from "enquirer";
+function findExactMatch(worktrees, branchName) {
+  return worktrees.find((wt) => wt.branch === branchName);
+}
+function findFuzzyMatches(worktrees, keyword) {
+  const lowerKeyword = keyword.toLowerCase();
+  return worktrees.filter((wt) => wt.branch.toLowerCase().includes(lowerKeyword));
+}
+async function promptSelectBranch(worktrees, message) {
+  const selectedBranch = await new Enquirer2.Select({
+    message,
+    choices: worktrees.map((wt) => ({
+      name: wt.branch,
+      message: wt.branch
+    }))
+  }).run();
+  return worktrees.find((wt) => wt.branch === selectedBranch);
+}
+async function resolveTargetWorktree(worktrees, messages, branchName) {
+  if (worktrees.length === 0) {
+    throw new ClawtError(messages.noWorktrees);
+  }
+  if (!branchName) {
+    if (worktrees.length === 1) {
+      return worktrees[0];
+    }
+    return promptSelectBranch(worktrees, messages.selectBranch);
+  }
+  const exactMatch = findExactMatch(worktrees, branchName);
+  if (exactMatch) {
+    return exactMatch;
+  }
+  const fuzzyMatches = findFuzzyMatches(worktrees, branchName);
+  if (fuzzyMatches.length === 1) {
+    return fuzzyMatches[0];
+  }
+  if (fuzzyMatches.length > 1) {
+    return promptSelectBranch(fuzzyMatches, messages.multipleMatches(branchName));
+  }
+  const allBranches = worktrees.map((wt) => wt.branch);
+  throw new ClawtError(messages.noMatch(branchName, allBranches));
+}
+
 // src/commands/list.ts
 import chalk2 from "chalk";
 function registerListCommand(program2) {
@@ -1022,68 +1113,36 @@ async function handleRun(options) {
 }
 
 // src/commands/resume.ts
-import Enquirer2 from "enquirer";
+var RESUME_RESOLVE_MESSAGES = {
+  noWorktrees: MESSAGES.RESUME_NO_WORKTREES,
+  selectBranch: MESSAGES.RESUME_SELECT_BRANCH,
+  multipleMatches: MESSAGES.RESUME_MULTIPLE_MATCHES,
+  noMatch: MESSAGES.RESUME_NO_MATCH
+};
 function registerResumeCommand(program2) {
   program2.command("resume").description("\u5728\u5DF2\u6709 worktree \u4E2D\u6062\u590D Claude Code \u4EA4\u4E92\u5F0F\u4F1A\u8BDD").option("-b, --branch <branchName>", "\u8981\u6062\u590D\u7684\u5206\u652F\u540D\uFF08\u652F\u6301\u6A21\u7CCA\u5339\u914D\uFF0C\u4E0D\u4F20\u5219\u5217\u51FA\u6240\u6709\u5206\u652F\uFF09").action(async (options) => {
     await handleResume(options);
   });
 }
-function findExactMatch(worktrees, branchName) {
-  return worktrees.find((wt) => wt.branch === branchName);
-}
-function findFuzzyMatches(worktrees, keyword) {
-  const lowerKeyword = keyword.toLowerCase();
-  return worktrees.filter((wt) => wt.branch.toLowerCase().includes(lowerKeyword));
-}
-async function promptSelectBranch(worktrees, message) {
-  const selectedBranch = await new Enquirer2.Select({
-    message,
-    choices: worktrees.map((wt) => ({
-      name: wt.branch,
-      message: wt.branch
-    }))
-  }).run();
-  return worktrees.find((wt) => wt.branch === selectedBranch);
-}
-async function resolveTargetWorktree(branchName) {
-  const worktrees = getProjectWorktrees();
-  if (worktrees.length === 0) {
-    throw new ClawtError(MESSAGES.RESUME_NO_WORKTREES);
-  }
-  if (!branchName) {
-    if (worktrees.length === 1) {
-      return worktrees[0];
-    }
-    return promptSelectBranch(worktrees, MESSAGES.RESUME_SELECT_BRANCH);
-  }
-  const exactMatch = findExactMatch(worktrees, branchName);
-  if (exactMatch) {
-    return exactMatch;
-  }
-  const fuzzyMatches = findFuzzyMatches(worktrees, branchName);
-  if (fuzzyMatches.length === 1) {
-    return fuzzyMatches[0];
-  }
-  if (fuzzyMatches.length > 1) {
-    return promptSelectBranch(fuzzyMatches, MESSAGES.RESUME_MULTIPLE_MATCHES(branchName));
-  }
-  const allBranches = worktrees.map((wt) => wt.branch);
-  throw new ClawtError(MESSAGES.RESUME_NO_MATCH(branchName, allBranches));
-}
 async function handleResume(options) {
   validateMainWorktree();
   validateClaudeCodeInstalled();
   logger.info(`resume \u547D\u4EE4\u6267\u884C\uFF0C\u5206\u652F: ${options.branch ?? "(\u672A\u6307\u5B9A)"}`);
-  const worktree = await resolveTargetWorktree(options.branch);
+  const worktrees = getProjectWorktrees();
+  const worktree = await resolveTargetWorktree(worktrees, RESUME_RESOLVE_MESSAGES, options.branch);
   launchInteractiveClaude(worktree);
 }
 
 // src/commands/validate.ts
-import { join as join4 } from "path";
-import { existsSync as existsSync6 } from "fs";
 import Enquirer3 from "enquirer";
+var VALIDATE_RESOLVE_MESSAGES = {
+  noWorktrees: MESSAGES.VALIDATE_NO_WORKTREES,
+  selectBranch: MESSAGES.VALIDATE_SELECT_BRANCH,
+  multipleMatches: MESSAGES.VALIDATE_MULTIPLE_MATCHES,
+  noMatch: MESSAGES.VALIDATE_NO_MATCH
+};
 function registerValidateCommand(program2) {
-  program2.command("validate").description("\u5728\u4E3B worktree \u9A8C\u8BC1\u67D0\u4E2A worktree \u5206\u652F\u7684\u53D8\u66F4").requiredOption("-b, --branch <branchName>", "\u8981\u9A8C\u8BC1\u7684\u5206\u652F\u540D").option("--clean", "\u6E05\u7406 validate \u72B6\u6001\uFF08\u91CD\u7F6E\u4E3B worktree \u5E76\u5220\u9664\u5FEB\u7167\uFF09").action(async (options) => {
+  program2.command("validate").description("\u5728\u4E3B worktree \u9A8C\u8BC1\u67D0\u4E2A worktree \u5206\u652F\u7684\u53D8\u66F4").option("-b, --branch <branchName>", "\u8981\u9A8C\u8BC1\u7684\u5206\u652F\u540D\uFF08\u652F\u6301\u6A21\u7CCA\u5339\u914D\uFF0C\u4E0D\u4F20\u5219\u5217\u51FA\u6240\u6709\u5206\u652F\uFF09").option("--clean", "\u6E05\u7406 validate \u72B6\u6001\uFF08\u91CD\u7F6E\u4E3B worktree \u5E76\u5220\u9664\u5FEB\u7167\uFF09").action(async (options) => {
     await handleValidate(options);
   });
 }
@@ -1158,18 +1217,22 @@ function saveCurrentSnapshotTree(mainWorktreePath, projectName, branchName) {
   gitAddAll(mainWorktreePath);
   const treeHash = gitWriteTree(mainWorktreePath);
   gitRestoreStaged(mainWorktreePath);
-  writeSnapshot(projectName, branchName, treeHash);
+  const headCommitHash = getHeadCommitHash(mainWorktreePath);
+  writeSnapshot(projectName, branchName, treeHash, headCommitHash);
   return treeHash;
 }
 async function handleValidateClean(options) {
   validateMainWorktree();
   const projectName = getProjectName();
   const mainWorktreePath = getGitTopLevel();
-  logger.info(`validate --clean \u6267\u884C\uFF0C\u5206\u652F: ${options.branch}`);
+  const worktrees = getProjectWorktrees();
+  const worktree = await resolveTargetWorktree(worktrees, VALIDATE_RESOLVE_MESSAGES, options.branch);
+  const branchName = worktree.branch;
+  logger.info(`validate --clean \u6267\u884C\uFF0C\u5206\u652F: ${branchName}`);
   if (getConfigValue("confirmDestructiveOps")) {
     const confirmed = await confirmDestructiveAction(
       "git reset --hard + git clean -fd",
-      `\u91CD\u7F6E\u4E3B worktree \u5E76\u5220\u9664\u5206\u652F ${options.branch} \u7684 validate \u5FEB\u7167`
+      `\u91CD\u7F6E\u4E3B worktree \u5E76\u5220\u9664\u5206\u652F ${branchName} \u7684 validate \u5FEB\u7167`
     );
     if (!confirmed) {
       printInfo(MESSAGES.DESTRUCTIVE_OP_CANCELLED);
@@ -1180,8 +1243,8 @@ async function handleValidateClean(options) {
     gitResetHard(mainWorktreePath);
     gitCleanForce(mainWorktreePath);
   }
-  removeSnapshot(projectName, options.branch);
-  printSuccess(MESSAGES.VALIDATE_CLEANED(options.branch));
+  removeSnapshot(projectName, branchName);
+  printSuccess(MESSAGES.VALIDATE_CLEANED(branchName));
 }
 function handleFirstValidate(targetWorktreePath, mainWorktreePath, projectName, branchName, hasUncommitted) {
   migrateChangesViaPatch(targetWorktreePath, mainWorktreePath, branchName, hasUncommitted);
@@ -1189,7 +1252,7 @@ function handleFirstValidate(targetWorktreePath, mainWorktreePath, projectName,
   printSuccess(MESSAGES.VALIDATE_SUCCESS(branchName));
 }
 function handleIncrementalValidate(targetWorktreePath, mainWorktreePath, projectName, branchName, hasUncommitted) {
-  const oldTreeHash = readSnapshotTreeHash(projectName, branchName);
+  const { treeHash: oldTreeHash, headCommitHash: oldHeadCommitHash } = readSnapshot(projectName, branchName);
   if (!isWorkingDirClean(mainWorktreePath)) {
     gitResetHard(mainWorktreePath);
     gitCleanForce(mainWorktreePath);
@@ -1197,7 +1260,21 @@ function handleIncrementalValidate(targetWorktreePath, mainWorktreePath, project
   migrateChangesViaPatch(targetWorktreePath, mainWorktreePath, branchName, hasUncommitted);
   saveCurrentSnapshotTree(mainWorktreePath, projectName, branchName);
   try {
-    gitReadTree(oldTreeHash, mainWorktreePath);
+    const currentHeadCommitHash = getHeadCommitHash(mainWorktreePath);
+    if (oldHeadCommitHash && oldHeadCommitHash !== currentHeadCommitHash) {
+      const oldHeadTreeHash = getCommitTreeHash(oldHeadCommitHash, mainWorktreePath);
+      const oldChangePatch = gitDiffTree(oldHeadTreeHash, oldTreeHash, mainWorktreePath);
+      if (oldChangePatch.length > 0 && gitApplyCachedCheck(oldChangePatch, mainWorktreePath)) {
+        gitApplyCachedFromStdin(oldChangePatch, mainWorktreePath);
+      } else if (oldChangePatch.length > 0) {
+        logger.warn("\u65E7\u53D8\u66F4 patch \u4E0E\u5F53\u524D HEAD \u51B2\u7A81\uFF0C\u964D\u7EA7\u4E3A\u5168\u91CF\u6A21\u5F0F");
+        printWarning(MESSAGES.INCREMENTAL_VALIDATE_FALLBACK);
+        printSuccess(MESSAGES.VALIDATE_SUCCESS(branchName));
+        return;
+      }
+    } else {
+      gitReadTree(oldTreeHash, mainWorktreePath);
+    }
   } catch (error) {
     logger.warn(`\u589E\u91CF read-tree \u5931\u8D25: ${error}`);
     printWarning(MESSAGES.INCREMENTAL_VALIDATE_FALLBACK);
@@ -1214,35 +1291,34 @@ async function handleValidate(options) {
   validateMainWorktree();
   const projectName = getProjectName();
   const mainWorktreePath = getGitTopLevel();
-  const projectDir = getProjectWorktreeDir();
-  const targetWorktreePath = join4(projectDir, options.branch);
-  logger.info(`validate \u547D\u4EE4\u6267\u884C\uFF0C\u5206\u652F: ${options.branch}`);
-  if (!existsSync6(targetWorktreePath)) {
-    throw new ClawtError(MESSAGES.WORKTREE_NOT_FOUND(options.branch));
-  }
+  const worktrees = getProjectWorktrees();
+  const worktree = await resolveTargetWorktree(worktrees, VALIDATE_RESOLVE_MESSAGES, options.branch);
+  const branchName = worktree.branch;
+  const targetWorktreePath = worktree.path;
+  logger.info(`validate \u547D\u4EE4\u6267\u884C\uFF0C\u5206\u652F: ${branchName}`);
   const hasUncommitted = !isWorkingDirClean(targetWorktreePath);
-  const hasCommitted = hasLocalCommits(options.branch, mainWorktreePath);
+  const hasCommitted = hasLocalCommits(branchName, mainWorktreePath);
   if (!hasUncommitted && !hasCommitted) {
     printInfo(MESSAGES.TARGET_WORKTREE_CLEAN);
     return;
   }
-  const isIncremental = hasSnapshot(projectName, options.branch);
+  const isIncremental = hasSnapshot(projectName, branchName);
   if (isIncremental) {
     if (!isWorkingDirClean(mainWorktreePath)) {
       await handleDirtyMainWorktree(mainWorktreePath);
     }
-    handleIncrementalValidate(targetWorktreePath, mainWorktreePath, projectName, options.branch, hasUncommitted);
+    handleIncrementalValidate(targetWorktreePath, mainWorktreePath, projectName, branchName, hasUncommitted);
   } else {
     if (!isWorkingDirClean(mainWorktreePath)) {
       await handleDirtyMainWorktree(mainWorktreePath);
     }
-    handleFirstValidate(targetWorktreePath, mainWorktreePath, projectName, options.branch, hasUncommitted);
+    handleFirstValidate(targetWorktreePath, mainWorktreePath, projectName, branchName, hasUncommitted);
   }
 }
 
 // src/commands/merge.ts
-import { join as join5 } from "path";
-import { existsSync as existsSync7 } from "fs";
+import { join as join4 } from "path";
+import { existsSync as existsSync6 } from "fs";
 function registerMergeCommand(program2) {
   program2.command("merge").description("\u5408\u5E76\u67D0\u4E2A\u5DF2\u9A8C\u8BC1\u7684 worktree \u5206\u652F\u5230\u4E3B worktree").requiredOption("-b, --branch <branchName>", "\u8981\u5408\u5E76\u7684\u5206\u652F\u540D").option("-m, --message <message>", "\u63D0\u4EA4\u4FE1\u606F\uFF08\u5DE5\u4F5C\u533A\u6709\u4FEE\u6539\u65F6\u5FC5\u586B\uFF09").action(async (options) => {
     await handleMerge(options);
@@ -1284,9 +1360,9 @@ async function handleMerge(options) {
   validateMainWorktree();
   const mainWorktreePath = getGitTopLevel();
   const projectDir = getProjectWorktreeDir();
-  const targetWorktreePath = join5(projectDir, options.branch);
+  const targetWorktreePath = join4(projectDir, options.branch);
   logger.info(`merge \u547D\u4EE4\u6267\u884C\uFF0C\u5206\u652F: ${options.branch}\uFF0C\u63D0\u4EA4\u4FE1\u606F: ${options.message ?? "(\u672A\u63D0\u4F9B)"}`);
-  if (!existsSync7(targetWorktreePath)) {
+  if (!existsSync6(targetWorktreePath)) {
     throw new ClawtError(MESSAGES.WORKTREE_NOT_FOUND(options.branch));
   }
   const projectName = getProjectName();
@@ -1379,8 +1455,8 @@ function formatConfigValue(value) {
 }
 
 // src/commands/sync.ts
-import { existsSync as existsSync8 } from "fs";
-import { join as join6 } from "path";
+import { existsSync as existsSync7 } from "fs";
+import { join as join5 } from "path";
 function registerSyncCommand(program2) {
   program2.command("sync").description("\u5C06\u4E3B\u5206\u652F\u6700\u65B0\u4EE3\u7801\u540C\u6B65\u5230\u76EE\u6807 worktree").requiredOption("-b, --branch <branchName>", "\u8981\u540C\u6B65\u7684\u5206\u652F\u540D").action(async (options) => {
     await handleSync(options);
@@ -1408,8 +1484,8 @@ async function handleSync(options) {
   const { branch } = options;
   logger.info(`sync \u547D\u4EE4\u6267\u884C\uFF0C\u5206\u652F: ${branch}`);
   const projectWorktreeDir = getProjectWorktreeDir();
-  const targetWorktreePath = join6(projectWorktreeDir, branch);
-  if (!existsSync8(targetWorktreePath)) {
+  const targetWorktreePath = join5(projectWorktreeDir, branch);
+  if (!existsSync7(targetWorktreePath)) {
     throw new ClawtError(MESSAGES.WORKTREE_NOT_FOUND(branch));
   }
   const mainWorktreePath = getGitTopLevel();