clawt 2.10.0 → 2.10.1

package/docs/spec.md

@@ -171,7 +171,7 @@ git show-ref --verify refs/heads/<branchName> 2>/dev/null
 | `clawt run`           | 批量创建 worktree + 启动 Claude Code 执行任务    | 5.2      |
 | `clawt validate`      | 在主 worktree 验证某个 worktree 分支的变更        | 5.4      |
 | `clawt merge`         | 合并某个已验证的 worktree 分支到主 worktree       | 5.6      |
-| `clawt remove`        | 移除 worktree（支持单个/批量/全部）               | 5.5      |
+| `clawt remove`        | 移除 worktree（支持模糊匹配/多选/全部）             | 5.5      |
 | `clawt list`          | 列出当前项目所有 worktree（支持 `--json` 格式输出） | 5.8      |
 | `clawt config`        | 查看全局配置                                     | 5.10     |
 | `clawt config reset`  | 将配置恢复为默认值                                | 5.10     |
@@ -574,29 +574,42 @@ git apply --cached < patch
 **命令：**
 
 ```bash
-clawt remove [options]
+# 移除当前项目所有 worktree
+clawt remove --all
+
+# 指定分支名（支持模糊匹配）
+clawt remove -b <branchName>
+
+# 不指定参数（列出所有分支供多选）
+clawt remove
 ```
 
 **参数：**
 
-| 参数      | 说明                                                       |
-| --------- | ---------------------------------------------------------- |
-| `--all`   | 移除当前项目 (`~/.clawt/worktrees/<project>/`) 下所有 worktree |
-| `-b <branchName>` | 移除匹配 branchName 或 branchName-* 的 worktree      |
-
-**三种移除粒度：**
+| 参数      | 必填 | 说明                                                                   |
+| --------- | ---- | ---------------------------------------------------------------------- |
+| `--all`   | 否   | 移除当前项目 (`~/.clawt/worktrees/<project>/`) 下所有 worktree           |
+| `-b`      | 否   | 指定分支名（支持模糊匹配，不传则列出所有分支供多选）                       |
 
-| 粒度 | 命令示例                                 | 移除范围                                                      |
-| ---- | ---------------------------------------- | ------------------------------------------------------------- |
-| 全部 | `clawt remove --all`                     | `~/.clawt/worktrees/<project>/` 下所有 worktree                |
-| 分支 | `clawt remove -b feature-scheme`         | `~/.clawt/worktrees/<project>/feature-scheme-*` 的所有 worktree |
-| 单个 | `clawt remove -b feature-scheme-2`       | 仅移除 `feature-scheme-2` 对应的 worktree（完整分支名精确匹配）    |
+> **提示：** 不传 `--all` 也不传 `-b` 时，会列出当前项目所有 worktree 供交互式多选。
 
 **运行流程：**
 
 1. **主 worktree 校验** (2.1)
 2. **获取项目名** (2.2)
-3. 根据参数确定要移除的 worktree 列表
+3. **确定待移除的 worktree 列表**：
+   - **指定 `--all`** → 选中当前项目所有 worktree
+   - **未指定 `--all`** → 通过 `resolveTargetWorktrees` 解析目标 worktree（多选版本），匹配策略如下：
+     - **未传 `-b` 参数**：
+       - 无可用 worktree → 报错退出
+       - 仅 1 个 worktree → 直接使用，无需选择
+       - 多个 worktree → 通过交互式多选列表（Enquirer.MultiSelect）让用户选择（空格选择，回车确认）
+     - **传了 `-b` 参数**：
+       1. **精确匹配优先**：在 worktree 列表中查找分支名完全相同的 worktree，找到则直接使用
+       2. **模糊匹配**（子串匹配，大小写不敏感）：
+          - 唯一匹配 → 直接使用
+          - 多个匹配 → 通过交互式多选列表让用户从匹配结果中选择
+       3. **无匹配** → 报错退出，并列出所有可用分支名
 4. 列出即将移除的 worktree 及对应分支：
 
 ```

package/package.json

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

package/src/commands/remove.ts

@@ -19,7 +19,17 @@ import {
   confirmAction,
   removeSnapshot,
   removeProjectSnapshots,
+  resolveTargetWorktrees,
 } from '../utils/index.js';
+import type { WorktreeMultiResolveMessages } from '../utils/index.js';
+
+/** remove 命令的分支解析消息配置 */
+const REMOVE_RESOLVE_MESSAGES: WorktreeMultiResolveMessages = {
+  noWorktrees: MESSAGES.REMOVE_NO_WORKTREES,
+  selectBranch: MESSAGES.REMOVE_SELECT_BRANCH,
+  multipleMatches: MESSAGES.REMOVE_MULTIPLE_MATCHES,
+  noMatch: MESSAGES.REMOVE_NO_MATCH,
+};
 
 /**
  * 注册 remove 命令：移除 worktree
@@ -30,38 +40,12 @@ export function registerRemoveCommand(program: Command): void {
     .command('remove')
     .description('移除 worktree（支持单个/批量/全部）')
     .option('--all', '移除当前项目下所有 worktree')
-    .option('-b, --branch <branchName>', '指定分支名（完整分支名精确匹配）')
+    .option('-b, --branch <branchName>', '指定分支名（支持模糊匹配，不传则列出所有分支）')
     .action(async (options: RemoveOptions) => {
       await handleRemove(options);
     });
 }
 
-/**
- * 根据参数确定要移除的 worktree 列表
- * @param {RemoveOptions} options - 命令选项
- * @returns {Array<{path: string, branch: string}>} 待移除的 worktree 列表
- */
-function resolveWorktreesToRemove(options: RemoveOptions): Array<{ path: string; branch: string }> {
-  const allWorktrees = getProjectWorktrees();
-
-  if (options.all) {
-    return allWorktrees;
-  }
-
-  if (!options.branch) {
-    throw new ClawtError('请指定 --all 或 -b <branchName> 参数');
-  }
-
-  // 分支级移除：匹配 branchName 或 branchName-*
-  const matched = allWorktrees.filter(
-    (wt) => wt.branch === options.branch || wt.branch.startsWith(`${options.branch}-`),
-  );
-  if (matched.length === 0) {
-    throw new ClawtError(MESSAGES.WORKTREE_NOT_FOUND(options.branch));
-  }
-  return matched;
-}
-
 /**
  * 执行 remove 命令的核心逻辑
  * @param {RemoveOptions} options - 命令选项
@@ -72,7 +56,16 @@ async function handleRemove(options: RemoveOptions): Promise<void> {
   const projectName = getProjectName();
   logger.info(`remove 命令执行，项目: ${projectName}`);
 
-  const worktreesToRemove = resolveWorktreesToRemove(options);
+  const allWorktrees = getProjectWorktrees();
+
+  // 确定待移除的 worktree 列表
+  let worktreesToRemove;
+  if (options.all) {
+    worktreesToRemove = allWorktrees;
+  } else {
+    // 通过 fuzzy search 解析目标 worktree（精确匹配 / 模糊匹配 / 交互多选）
+    worktreesToRemove = await resolveTargetWorktrees(allWorktrees, REMOVE_RESOLVE_MESSAGES, options.branch);
+  }
 
   if (worktreesToRemove.length === 0) {
     printInfo(MESSAGES.NO_WORKTREES);

package/src/constants/index.ts

@@ -1,6 +1,6 @@
 export { CLAWT_HOME, CONFIG_PATH, LOGS_DIR, WORKTREES_DIR, VALIDATE_SNAPSHOTS_DIR } from './paths.js';
 export { INVALID_BRANCH_CHARS } from './branch.js';
-export { MESSAGES } from './messages.js';
+export { MESSAGES } from './messages/index.js';
 export { EXIT_CODES } from './exitCodes.js';
 export { ENABLE_BRACKETED_PASTE, DISABLE_BRACKETED_PASTE, PASTE_THRESHOLD_MS } from './terminal.js';
 export { DEFAULT_CONFIG, CONFIG_DESCRIPTIONS, APPEND_SYSTEM_PROMPT } from './config.js';

package/src/constants/messages/common.ts

@@ -0,0 +1,41 @@
+/** 通用/共享提示消息 */
+export const COMMON_MESSAGES = {
+  /** 不在主 worktree 根目录 */
+  NOT_MAIN_WORKTREE: '请在主 worktree 的根目录下执行 clawt',
+  /** Git 未安装 */
+  GIT_NOT_INSTALLED: 'Git 未安装或不在 PATH 中，请先安装 Git',
+  /** Claude Code CLI 未安装 */
+  CLAUDE_NOT_INSTALLED: 'Claude Code CLI 未安装，请先安装：npm install -g @anthropic-ai/claude-code',
+  /** 分支已存在 */
+  BRANCH_EXISTS: (name: string) => `分支 ${name} 已存在，无法创建`,
+  /** 分支名清理后为空 */
+  BRANCH_NAME_EMPTY: (original: string) =>
+    `分支名 "${original}" 中不包含合法字符，无法创建分支`,
+  /** 分支名被转换 */
+  BRANCH_SANITIZED: (original: string, sanitized: string) =>
+    `分支名已转换: ${original} → ${sanitized}`,
+  /** worktree 创建成功 */
+  WORKTREE_CREATED: (count: number) => `✓ 已创建 ${count} 个 worktree`,
+  /** worktree 移除成功 */
+  WORKTREE_REMOVED: (path: string) => `✓ 已移除 worktree: ${path}`,
+  /** 没有 worktree */
+  NO_WORKTREES: '(无 worktree)',
+  /** 目标 worktree 不存在 */
+  WORKTREE_NOT_FOUND: (name: string) => `worktree ${name} 不存在`,
+  /** 主 worktree 有未提交更改 */
+  MAIN_WORKTREE_DIRTY: '主 worktree 有未提交的更改，请先处理',
+  /** 目标 worktree 无更改 */
+  TARGET_WORKTREE_CLEAN: '该 worktree 的分支上没有任何更改，无需验证',
+  /** 用户取消破坏性操作 */
+  DESTRUCTIVE_OP_CANCELLED: '已取消操作',
+  /** 请提供提交信息 */
+  COMMIT_MESSAGE_REQUIRED: '请提供提交信息（-m 参数）',
+  /** 配置文件损坏，已重新生成默认配置 */
+  CONFIG_CORRUPTED: '配置文件损坏或无法解析，已重新生成默认配置',
+  /** worktree 状态获取失败 */
+  WORKTREE_STATUS_UNAVAILABLE: '(状态不可用)',
+  /** 分隔线 */
+  SEPARATOR: '────────────────────────────────────────',
+  /** 粗分隔线 */
+  DOUBLE_SEPARATOR: '════════════════════════════════════════',
+} as const;

package/src/constants/messages/config.ts

@@ -0,0 +1,5 @@
+/** config 命令专属提示消息 */
+export const CONFIG_CMD_MESSAGES = {
+  /** 配置已恢复为默认值 */
+  CONFIG_RESET_SUCCESS: '✓ 配置已恢复为默认值',
+} as const;

package/src/constants/messages/create.ts

@@ -0,0 +1,5 @@
+/** create 命令专属提示消息 */
+export const CREATE_MESSAGES = {
+  /** 创建数量参数无效 */
+  INVALID_COUNT: (value: string) => `无效的创建数量: "${value}"，请输入正整数`,
+} as const;

package/src/constants/messages/index.ts

@@ -0,0 +1,29 @@
+import { COMMON_MESSAGES } from './common.js';
+import { RUN_MESSAGES } from './run.js';
+import { CREATE_MESSAGES } from './create.js';
+import { MERGE_MESSAGES } from './merge.js';
+import { VALIDATE_MESSAGES } from './validate.js';
+import { SYNC_MESSAGES } from './sync.js';
+import { RESUME_MESSAGES } from './resume.js';
+import { REMOVE_MESSAGES } from './remove.js';
+import { RESET_MESSAGES } from './reset.js';
+import { CONFIG_CMD_MESSAGES } from './config.js';
+import { STATUS_MESSAGES } from './status.js';
+
+/**
+ * 提示消息模板
+ * 合并所有子模块的消息，保持扁平结构以兼容现有的 MESSAGES.XXX 访问方式
+ */
+export const MESSAGES = {
+  ...COMMON_MESSAGES,
+  ...RUN_MESSAGES,
+  ...CREATE_MESSAGES,
+  ...MERGE_MESSAGES,
+  ...VALIDATE_MESSAGES,
+  ...SYNC_MESSAGES,
+  ...RESUME_MESSAGES,
+  ...REMOVE_MESSAGES,
+  ...RESET_MESSAGES,
+  ...CONFIG_CMD_MESSAGES,
+  ...STATUS_MESSAGES,
+} as const;

package/src/constants/messages/merge.ts

@@ -0,0 +1,42 @@
+/** merge 命令专属提示消息 */
+export const MERGE_MESSAGES = {
+  /** merge 成功 */
+  MERGE_SUCCESS: (branch: string, message: string, pushed: boolean) =>
+    `✓ 分支 ${branch} 已成功合并到当前分支\n  提交信息: ${message}${pushed ? '\n  已推送到远程仓库' : ''}`,
+  /** merge 成功（无提交信息，目标 worktree 已提交过） */
+  MERGE_SUCCESS_NO_MESSAGE: (branch: string, pushed: boolean) =>
+    `✓ 分支 ${branch} 已成功合并到当前分支${pushed ? '\n  已推送到远程仓库' : ''}`,
+  /** merge 冲突 */
+  MERGE_CONFLICT: '合并存在冲突，请手动处理：\n  解决冲突后执行 git add . && git merge --continue',
+  /** merge 后清理 worktree 和分支成功 */
+  WORKTREE_CLEANED: (branch: string) => `✓ 已清理 worktree 和分支: ${branch}`,
+  /** 目标 worktree 有未提交修改但未指定 -m */
+  TARGET_WORKTREE_DIRTY_NO_MESSAGE: '目标 worktree 有未提交的修改，请通过 -m 参数提供提交信息',
+  /** 目标 worktree 既干净又无本地提交 */
+  TARGET_WORKTREE_NO_CHANGES: '目标 worktree 没有任何可合并的变更（工作区干净且无本地提交）',
+  /** merge 命令检测到 validate 状态的提示 */
+  MERGE_VALIDATE_STATE_HINT: (branch: string) =>
+    `主 worktree 可能存在 validate 残留状态，可先执行 clawt validate -b ${branch} --clean 清理`,
+  /** merge 检测到 auto-save 提交，提示用户是否压缩 */
+  MERGE_SQUASH_PROMPT: '检测到 sync 产生的临时提交，是否将所有提交压缩为一个？\n  压缩后变更将保留在目标worktree的暂存区，需要重新提交（可使用 Claude Code Cli或其他工具生成提交信息）',
+  /** squash 完成且通过 -m 直接提交后的提示 */
+  MERGE_SQUASH_COMMITTED: (branch: string) =>
+    `✓ 已将分支 ${branch} 的所有提交压缩为一个`,
+  /** squash 完成但未提供 -m，提示用户自行提交 */
+  MERGE_SQUASH_PENDING: (worktreePath: string, branch: string) =>
+    `✓ 已将所有提交压缩到暂存区\n  请在目标 worktree 中提交后重新执行 merge：\n  cd ${worktreePath}\n  提交完成后执行：clawt merge -b ${branch}`,
+  /** merge 后 pull 冲突 */
+  PULL_CONFLICT:
+    '自动 pull 时发生冲突，merge 已完成但远程同步失败\n  请手动解决冲突：\n  解决冲突后执行 git add . && git commit\n  然后执行 git push 推送到远程',
+  /** push 失败 */
+  PUSH_FAILED: '自动 push 失败，merge 和 pull 已完成\n  请手动执行 git push',
+  /** merge 无可用 worktree */
+  MERGE_NO_WORKTREES: '当前项目没有可用的 worktree，请先通过 clawt run 或 clawt create 创建',
+  /** merge 模糊匹配无结果，列出可用分支 */
+  MERGE_NO_MATCH: (name: string, branches: string[]) =>
+    `未找到与 "${name}" 匹配的分支\n  可用分支：\n${branches.map((b) => `    - ${b}`).join('\n')}`,
+  /** merge 交互选择提示 */
+  MERGE_SELECT_BRANCH: '请选择要合并的分支',
+  /** merge 模糊匹配到多个结果提示 */
+  MERGE_MULTIPLE_MATCHES: (name: string) => `"${name}" 匹配到多个分支，请选择：`,
+} as const;

package/src/constants/messages/remove.ts

@@ -0,0 +1,15 @@
+/** remove 命令专属提示消息 */
+export const REMOVE_MESSAGES = {
+  /** remove 无可用 worktree */
+  REMOVE_NO_WORKTREES: '当前项目没有可用的 worktree，无需移除',
+  /** remove 多选交互提示 */
+  REMOVE_SELECT_BRANCH: '请选择要移除的分支（空格选择，回车确认）',
+  /** remove 模糊匹配到多个结果提示 */
+  REMOVE_MULTIPLE_MATCHES: (name: string) => `"${name}" 匹配到多个分支，请选择要移除的（空格选择，回车确认）：`,
+  /** remove 模糊匹配无结果，列出可用分支 */
+  REMOVE_NO_MATCH: (name: string, branches: string[]) =>
+    `未找到与 "${name}" 匹配的分支\n  可用分支：\n${branches.map((b) => `    - ${b}`).join('\n')}`,
+  /** 批量移除部分失败 */
+  REMOVE_PARTIAL_FAILURE: (failures: Array<{ path: string; error: string }>) =>
+    `以下 worktree 移除失败：\n${failures.map((f) => `  ✗ ${f.path}: ${f.error}`).join('\n')}`,
+} as const;

package/src/constants/messages/reset.ts

@@ -0,0 +1,7 @@
+/** reset 命令专属提示消息 */
+export const RESET_MESSAGES = {
+  /** reset 成功 */
+  RESET_SUCCESS: '✓ 主 worktree 工作区和暂存区已重置',
+  /** reset 时工作区和暂存区已干净 */
+  RESET_ALREADY_CLEAN: '主 worktree 工作区和暂存区已是干净状态，无需重置',
+} as const;

package/src/constants/messages/resume.ts

@@ -0,0 +1,12 @@
+/** resume 命令专属提示消息 */
+export const RESUME_MESSAGES = {
+  /** resume 无可用 worktree */
+  RESUME_NO_WORKTREES: '当前项目没有可用的 worktree，请先通过 clawt run 或 clawt create 创建',
+  /** resume 模糊匹配无结果，列出可用分支 */
+  RESUME_NO_MATCH: (name: string, branches: string[]) =>
+    `未找到与 "${name}" 匹配的分支\n  可用分支：\n${branches.map((b) => `    - ${b}`).join('\n')}`,
+  /** resume 交互选择提示 */
+  RESUME_SELECT_BRANCH: '请选择要恢复的分支',
+  /** resume 模糊匹配到多个结果提示 */
+  RESUME_MULTIPLE_MATCHES: (name: string) => `"${name}" 匹配到多个分支，请选择：`,
+} as const;

package/src/constants/messages/run.ts

@@ -0,0 +1,16 @@
+/** run 命令专属提示消息 */
+export const RUN_MESSAGES = {
+  /** 分支已存在时提示使用 resume */
+  BRANCH_EXISTS_USE_RESUME: (name: string) =>
+    `分支 ${name} 已存在，请使用 clawt resume -b ${name} 恢复会话`,
+  /** 检测到用户中断 */
+  INTERRUPTED: '检测到退出指令，已停止 Claude Code 任务',
+  /** 中断后自动清理完成 */
+  INTERRUPT_AUTO_CLEANED: (count: number) => `✓ 已自动清理 ${count} 个 worktree 和对应分支`,
+  /** 中断后手动确认清理 */
+  INTERRUPT_CONFIRM_CLEANUP: '是否移除刚刚创建的 worktree 和对应分支？',
+  /** 中断后清理完成 */
+  INTERRUPT_CLEANED: (count: number) => `✓ 已清理 ${count} 个 worktree 和对应分支`,
+  /** 中断后保留 worktree */
+  INTERRUPT_KEPT: '已保留 worktree，可稍后使用 clawt remove 手动清理',
+} as const;

package/src/constants/messages/status.ts

@@ -0,0 +1,25 @@
+/** status 命令专属提示消息 */
+export const STATUS_MESSAGES = {
+  /** status 命令标题 */
+  STATUS_TITLE: (projectName: string) => `项目状态总览: ${projectName}`,
+  /** status 主 worktree 区块标题 */
+  STATUS_MAIN_SECTION: '主 Worktree',
+  /** status worktrees 区块标题 */
+  STATUS_WORKTREES_SECTION: 'Worktree 列表',
+  /** status 快照区块标题 */
+  STATUS_SNAPSHOTS_SECTION: '未清理的 Validate 快照',
+  /** status 无 worktree */
+  STATUS_NO_WORKTREES: '(无活跃 worktree)',
+  /** status 无未清理快照 */
+  STATUS_NO_SNAPSHOTS: '(无未清理的快照)',
+  /** status 变更状态：已提交 */
+  STATUS_CHANGE_COMMITTED: '已提交',
+  /** status 变更状态：未提交修改 */
+  STATUS_CHANGE_UNCOMMITTED: '未提交修改',
+  /** status 变更状态：合并冲突 */
+  STATUS_CHANGE_CONFLICT: '合并冲突',
+  /** status 变更状态：无变更 */
+  STATUS_CHANGE_CLEAN: '无变更',
+  /** status 快照对应 worktree 已不存在 */
+  STATUS_SNAPSHOT_ORPHANED: '(对应 worktree 已不存在)',
+} as const;

package/src/constants/messages/sync.ts

@@ -0,0 +1,24 @@
+/** sync 命令专属提示消息 */
+export const SYNC_MESSAGES = {
+  /** sync 自动保存未提交变更 */
+  SYNC_AUTO_COMMITTED: (branch: string) =>
+    `已自动保存 ${branch} 分支的未提交变更`,
+  /** sync 开始合并 */
+  SYNC_MERGING: (targetBranch: string, mainBranch: string) =>
+    `正在将 ${mainBranch} 合并到 ${targetBranch} ...`,
+  /** sync 成功 */
+  SYNC_SUCCESS: (targetBranch: string, mainBranch: string) =>
+    `✓ 已将 ${mainBranch} 的最新代码同步到 ${targetBranch}`,
+  /** sync 冲突 */
+  SYNC_CONFLICT: (worktreePath: string) =>
+    `合并存在冲突，请进入目标 worktree 手动解决：\n  cd ${worktreePath}\n  解决冲突后执行 git add . && git merge --continue\n  clawt validate -b <branch> 验证变更`,
+  /** sync 无可用 worktree */
+  SYNC_NO_WORKTREES: '当前项目没有可用的 worktree，请先通过 clawt run 或 clawt create 创建',
+  /** sync 模糊匹配无结果，列出可用分支 */
+  SYNC_NO_MATCH: (name: string, branches: string[]) =>
+    `未找到与 "${name}" 匹配的分支\n  可用分支：\n${branches.map((b) => `    - ${b}`).join('\n')}`,
+  /** sync 交互选择提示 */
+  SYNC_SELECT_BRANCH: '请选择要同步的分支',
+  /** sync 模糊匹配到多个结果提示 */
+  SYNC_MULTIPLE_MATCHES: (name: string) => `"${name}" 匹配到多个分支，请选择：`,
+} as const;

package/src/constants/messages/validate.ts

@@ -0,0 +1,25 @@
+/** validate 命令专属提示消息 */
+export const VALIDATE_MESSAGES = {
+  /** validate 成功 */
+  VALIDATE_SUCCESS: (branch: string) =>
+    `✓ 已将分支 ${branch} 的变更应用到主 worktree\n  可以开始验证了`,
+  /** 增量 validate 成功提示 */
+  INCREMENTAL_VALIDATE_SUCCESS: (branch: string) =>
+    `✓ 已将分支 ${branch} 的最新变更应用到主 worktree（增量模式）\n  暂存区 = 上次快照，工作目录 = 最新变更`,
+  /** 增量 validate 降级为全量模式提示 */
+  INCREMENTAL_VALIDATE_FALLBACK: '增量对比失败，已降级为全量模式',
+  /** validate 状态已清理 */
+  VALIDATE_CLEANED: (branch: string) => `✓ 分支 ${branch} 的 validate 状态已清理`,
+  /** validate patch apply 失败，提示用户同步主分支 */
+  VALIDATE_PATCH_APPLY_FAILED: (branch: string) =>
+    `变更迁移失败：目标分支与主分支差异过大\n  请先执行 clawt sync -b ${branch} 同步主分支后重试`,
+  /** validate 无可用 worktree */
+  VALIDATE_NO_WORKTREES: '当前项目没有可用的 worktree，请先通过 clawt run 或 clawt create 创建',
+  /** validate 模糊匹配无结果，列出可用分支 */
+  VALIDATE_NO_MATCH: (name: string, branches: string[]) =>
+    `未找到与 "${name}" 匹配的分支\n  可用分支：\n${branches.map((b) => `    - ${b}`).join('\n')}`,
+  /** validate 交互选择提示 */
+  VALIDATE_SELECT_BRANCH: '请选择要验证的分支',
+  /** validate 模糊匹配到多个结果提示 */
+  VALIDATE_MULTIPLE_MATCHES: (name: string) => `"${name}" 匹配到多个分支，请选择：`,
+} as const;

package/src/utils/index.ts

@@ -54,5 +54,5 @@ export { ensureDir, removeEmptyDir } from './fs.js';
 export { multilineInput } from './prompt.js';
 export { launchInteractiveClaude } from './claude.js';
 export { getSnapshotPath, hasSnapshot, readSnapshotTreeHash, readSnapshot, writeSnapshot, removeSnapshot, removeProjectSnapshots, getProjectSnapshotBranches } from './validate-snapshot.js';
-export { findExactMatch, findFuzzyMatches, promptSelectBranch, resolveTargetWorktree } from './worktree-matcher.js';
-export type { WorktreeResolveMessages } from './worktree-matcher.js';
+export { findExactMatch, findFuzzyMatches, promptSelectBranch, promptMultiSelectBranches, resolveTargetWorktree, resolveTargetWorktrees } from './worktree-matcher.js';
+export type { WorktreeResolveMessages, WorktreeMultiResolveMessages } from './worktree-matcher.js';

package/src/utils/worktree-matcher.ts

@@ -38,6 +38,21 @@ export function findFuzzyMatches(worktrees: WorktreeInfo[], keyword: string): Wo
   return worktrees.filter((wt) => wt.branch.toLowerCase().includes(lowerKeyword));
 }
 
+/**
+ * 多选场景下的分支解析消息文案配置
+ * 与 WorktreeResolveMessages 类似，但用于需要多选的命令（如 remove）
+ */
+export interface WorktreeMultiResolveMessages {
+  /** 无可用 worktree 时的错误消息 */
+  noWorktrees: string;
+  /** 未传分支名时的多选交互提示 */
+  selectBranch: string;
+  /** 模糊匹配到多个结果时的多选交互提示 */
+  multipleMatches: (keyword: string) => string;
+  /** 无匹配结果时的错误消息 */
+  noMatch: (keyword: string, branches: string[]) => string;
+}
+
 /**
  * 通过交互式列表让用户从 worktree 列表中选择一个分支
  * @param {WorktreeInfo[]} worktrees - 可供选择的 worktree 列表
@@ -57,6 +72,83 @@ export async function promptSelectBranch(worktrees: WorktreeInfo[], message: str
   return worktrees.find((wt) => wt.branch === selectedBranch)!;
 }
 
+/**
+ * 通过交互式多选列表让用户从 worktree 列表中选择多个分支
+ * 用户可通过空格键选择/取消，回车键确认
+ * @param {WorktreeInfo[]} worktrees - 可供选择的 worktree 列表
+ * @param {string} message - 选择提示信息
+ * @returns {Promise<WorktreeInfo[]>} 用户选择的 worktree 列表
+ */
+export async function promptMultiSelectBranches(worktrees: WorktreeInfo[], message: string): Promise<WorktreeInfo[]> {
+  // @ts-expect-error enquirer 类型声明未导出 MultiSelect 类，但运行时存在
+  const selectedBranches: string[] = await new Enquirer.MultiSelect({
+    message,
+    choices: worktrees.map((wt) => ({
+      name: wt.branch,
+      message: wt.branch,
+    })),
+    // 使用空心圆/实心圆作为选中指示符
+    symbols: {
+      indicator: { on: '●', off: '○' },
+    },
+  }).run();
+
+  return worktrees.filter((wt) => selectedBranches.includes(wt.branch));
+}
+
+/**
+ * 根据用户输入解析目标 worktree（多选版本）
+ * 匹配策略：精确匹配 → 模糊匹配（唯一直接使用，多个交互多选） → 无匹配报错
+ * 不传分支名时列出所有可用分支供多选
+ * @param {WorktreeInfo[]} worktrees - 可用的 worktree 列表
+ * @param {WorktreeMultiResolveMessages} messages - 命令专属的消息文案
+ * @param {string} [branchName] - 用户输入的分支名（可选）
+ * @returns {Promise<WorktreeInfo[]>} 解析后的目标 worktree 列表
+ * @throws {ClawtError} 无可用 worktree 或无匹配结果时抛出
+ */
+export async function resolveTargetWorktrees(
+  worktrees: WorktreeInfo[],
+  messages: WorktreeMultiResolveMessages,
+  branchName?: string,
+): Promise<WorktreeInfo[]> {
+  // 无可用 worktree，直接报错
+  if (worktrees.length === 0) {
+    throw new ClawtError(messages.noWorktrees);
+  }
+
+  // 未传 -b 参数：列出所有分支供多选
+  if (!branchName) {
+    // 只有一个 worktree 时直接使用，无需选择
+    if (worktrees.length === 1) {
+      return [worktrees[0]];
+    }
+    return promptMultiSelectBranches(worktrees, messages.selectBranch);
+  }
+
+  // 1. 精确匹配优先
+  const exactMatch = findExactMatch(worktrees, branchName);
+  if (exactMatch) {
+    return [exactMatch];
+  }
+
+  // 2. 模糊匹配
+  const fuzzyMatches = findFuzzyMatches(worktrees, branchName);
+
+  // 2a. 唯一匹配，直接使用
+  if (fuzzyMatches.length === 1) {
+    return [fuzzyMatches[0]];
+  }
+
+  // 2b. 多个匹配，交互多选
+  if (fuzzyMatches.length > 1) {
+    return promptMultiSelectBranches(fuzzyMatches, messages.multipleMatches(branchName));
+  }
+
+  // 3. 无匹配，抛出错误并列出所有可用分支
+  const allBranches = worktrees.map((wt) => wt.branch);
+  throw new ClawtError(messages.noMatch(branchName, allBranches));
+}
+
 /**
  * 根据用户输入解析目标 worktree
  * 匹配策略：精确匹配 → 模糊匹配（唯一直接使用，多个交互选择） → 无匹配报错

package/tests/unit/commands/config.test.ts

@@ -0,0 +1,110 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { Command } from 'commander';
+
+// mock 依赖模块
+vi.mock('../../../src/logger/index.js', () => ({
+  logger: { debug: vi.fn(), info: vi.fn(), warn: vi.fn(), error: vi.fn() },
+}));
+
+vi.mock('../../../src/utils/index.js', () => ({
+  loadConfig: vi.fn(),
+  writeDefaultConfig: vi.fn(),
+  printInfo: vi.fn(),
+  printSuccess: vi.fn(),
+  printSeparator: vi.fn(),
+  confirmDestructiveAction: vi.fn(),
+}));
+
+vi.mock('../../../src/constants/index.js', () => ({
+  CONFIG_PATH: '/mock/.clawt/config.json',
+  DEFAULT_CONFIG: {
+    claudeCodeCommand: 'claude',
+    autoDeleteBranch: false,
+    autoPullPush: false,
+    confirmDestructiveOps: true,
+  },
+  CONFIG_DESCRIPTIONS: {
+    claudeCodeCommand: 'Claude Code CLI 命令',
+    autoDeleteBranch: '自动删除分支',
+    autoPullPush: '自动 pull/push',
+    confirmDestructiveOps: '破坏性操作确认',
+  },
+  MESSAGES: {
+    CONFIG_RESET_SUCCESS: '配置已恢复为默认值',
+    DESTRUCTIVE_OP_CANCELLED: '已取消操作',
+  },
+}));
+
+import { registerConfigCommand } from '../../../src/commands/config.js';
+import { loadConfig, writeDefaultConfig, printInfo, printSuccess, confirmDestructiveAction } from '../../../src/utils/index.js';
+
+const mockedLoadConfig = vi.mocked(loadConfig);
+const mockedWriteDefaultConfig = vi.mocked(writeDefaultConfig);
+const mockedPrintInfo = vi.mocked(printInfo);
+const mockedPrintSuccess = vi.mocked(printSuccess);
+const mockedConfirmDestructiveAction = vi.mocked(confirmDestructiveAction);
+
+beforeEach(() => {
+  mockedLoadConfig.mockReset();
+  mockedWriteDefaultConfig.mockReset();
+  mockedPrintInfo.mockReset();
+  mockedPrintSuccess.mockReset();
+  mockedConfirmDestructiveAction.mockReset();
+});
+
+describe('registerConfigCommand', () => {
+  it('注册 config 命令和 config reset 子命令', () => {
+    const program = new Command();
+    registerConfigCommand(program);
+    const configCmd = program.commands.find((c) => c.name() === 'config');
+    expect(configCmd).toBeDefined();
+    const resetCmd = configCmd!.commands.find((c) => c.name() === 'reset');
+    expect(resetCmd).toBeDefined();
+  });
+});
+
+describe('handleConfig（通过 action 间接测试）', () => {
+  it('展示配置列表', () => {
+    mockedLoadConfig.mockReturnValue({
+      claudeCodeCommand: 'claude',
+      autoDeleteBranch: false,
+      autoPullPush: false,
+      confirmDestructiveOps: true,
+    });
+
+    const program = new Command();
+    program.exitOverride();
+    registerConfigCommand(program);
+    program.parse(['config'], { from: 'user' });
+
+    expect(mockedLoadConfig).toHaveBeenCalled();
+    // 应输出配置信息
+    expect(mockedPrintInfo).toHaveBeenCalled();
+  });
+});
+
+describe('handleConfigReset（通过 action 间接测试）', () => {
+  it('用户确认后恢复默认配置', async () => {
+    mockedConfirmDestructiveAction.mockResolvedValue(true);
+
+    const program = new Command();
+    program.exitOverride();
+    registerConfigCommand(program);
+    await program.parseAsync(['config', 'reset'], { from: 'user' });
+
+    expect(mockedWriteDefaultConfig).toHaveBeenCalled();
+    expect(mockedPrintSuccess).toHaveBeenCalled();
+  });
+
+  it('用户取消操作时不写入', async () => {
+    mockedConfirmDestructiveAction.mockResolvedValue(false);
+
+    const program = new Command();
+    program.exitOverride();
+    registerConfigCommand(program);
+    await program.parseAsync(['config', 'reset'], { from: 'user' });
+
+    expect(mockedWriteDefaultConfig).not.toHaveBeenCalled();
+    expect(mockedPrintInfo).toHaveBeenCalled();
+  });
+});