clawt 2.11.1 → 2.12.1

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

@@ -8,7 +8,7 @@
 - run 命令对应 `5.2 批量创建 Worktree + 执行 Claude Code 任务`，流程按步骤编号描述
 - merge 命令对应 `5.6 合并验证过的分支`，-b 可选，支持模糊匹配（与 resume/validate 共享匹配逻辑），流程按步骤编号描述
 - config 命令对应 `5.10 查看和管理全局配置`，包含查看配置和 config reset 子命令两部分（使用 `####` 子标题区分）
-- resume 命令对应 `5.11 在已有 Worktree 中恢复会话`，支持模糊匹配和交互式分支选择（-b 可选）
+- resume 命令对应 `5.11 在已有 Worktree 中恢复会话`，统一使用多选交互（resolveTargetWorktrees），选 1 个当前终端恢复，选多个在独立终端 Tab 批量恢复（-b 可选）
 - validate 命令对应 `5.4 在主 Worktree 验证其他分支`，-b 可选，支持模糊匹配（与 resume 共享匹配逻辑）
 - sync 命令对应 `5.12 将主分支代码同步到目标 Worktree`，-b 可选，支持模糊匹配（与 resume/validate/merge 共享匹配逻辑）
 - status 命令对应 `5.14 项目全局状态总览`，支持 `--json` 格式输出，展示主 worktree 状态、各 worktree 详细状态、未清理快照
@@ -35,7 +35,11 @@
 - remove 批量操作时收集错误继续处理，最后汇总报告
 - 文档中文风格，技术术语保留英文（worktree, merge, branch, SIGINT 等）
 - cleanupWorktrees 是 merge 和 run 共用的公共清理函数（在 src/utils/worktree.ts）
-- `launchInteractiveClaude` 是 run（交互式模式）和 resume 共用的公共函数（在 src/utils/claude.ts），启动前自动检测会话历史并追加 `--continue`
+- `launchInteractiveClaude` 是 run（交互式模式）和 resume（单选模式）共用的公共函数（在 src/utils/claude.ts），启动前自动检测会话历史并追加 `--continue`
+- `launchInteractiveClaudeInNewTerminal` 是 resume 批量模式使用的函数（在 src/utils/claude.ts），通过 AppleScript 在新终端 Tab 中启动
+- `buildClaudeCommand` 构建完整 shell 命令字符串（在 src/utils/claude.ts），被 `launchInteractiveClaudeInNewTerminal` 调用
+- `openCommandInNewTerminalTab` 终端 Tab 管理函数（在 src/utils/terminal.ts），支持 iTerm2 和 Terminal.app
+- `detectTerminalApp` 终端类型检测函数（在 src/utils/terminal.ts），读取 `terminalApp` 配置项
 - `hasClaudeSessionHistory` 检测 `~/.claude/projects/<encoded-path>/` 下是否有 `.jsonl` 文件（在 src/utils/claude.ts）
 - `CLAUDE_PROJECTS_DIR` 常量（`~/.claude/projects/`）定义在 `src/constants/paths.ts`
 - killAllChildProcesses 是 run 专用的子进程终止函数（在 src/utils/shell.ts）
@@ -76,14 +80,17 @@ Notes:
 - resume 和 run（交互式模式）共用 `launchInteractiveClaude()`，该函数从 run.ts 提取到 src/utils/claude.ts
 - `claudeCodeCommand` 配置项同时影响 run 交互式模式和 resume 命令
 - reset 命令与 validate --clean 的区别：reset 不删除快照文件，validate --clean 会删除快照
-- `resolveTargetWorktree()` 是 resume、validate、merge 和 sync 共用的单选分支匹配函数（在 src/utils/worktree-matcher.ts）
-- `resolveTargetWorktrees()` 是多选分支匹配函数（在 src/utils/worktree-matcher.ts），目前被 remove 命令使用
+- `resolveTargetWorktree()` 是 validate、merge 和 sync 共用的单选分支匹配函数（在 src/utils/worktree-matcher.ts）
+- `resolveTargetWorktrees()` 是多选分支匹配函数（在 src/utils/worktree-matcher.ts），被 remove 和 resume 命令使用
 - `WorktreeResolveMessages` 接口用于单选命令的消息解耦，`WorktreeMultiResolveMessages` 接口用于多选命令的消息解耦
 - `promptSelectBranch()`（Enquirer.Select）用于单选交互，`promptMultiSelectBranches()`（Enquirer.MultiSelect）用于多选交互
-- resume 的消息常量在 `MESSAGES.RESUME_*`，validate 的消息常量在 `MESSAGES.VALIDATE_*`，merge 的消息常量在 `MESSAGES.MERGE_*`，sync 的消息常量在 `MESSAGES.SYNC_*`，status 的消息常量在 `MESSAGES.STATUS_*`，remove 的 fuzzy search 消息在 `MESSAGES.REMOVE_*`
-- resume、validate、merge 和 sync 的 `-b` 参数均为可选，匹配策略一致：精确→模糊（子串，大小写不敏感）→交互单选
+- resume 的消息常量在 `MESSAGES.RESUME_*`（含 RESUME_ALL_CONFIRM / RESUME_ALL_SUCCESS 等批量恢复消息），validate 的消息常量在 `MESSAGES.VALIDATE_*`，merge 的消息常量在 `MESSAGES.MERGE_*`，sync 的消息常量在 `MESSAGES.SYNC_*`，status 的消息常量在 `MESSAGES.STATUS_*`，remove 的 fuzzy search 消息在 `MESSAGES.REMOVE_*`
+- resume 使用多选匹配策略：精确→模糊→交互多选（与 remove 一致），validate、merge 和 sync 使用单选匹配策略：精确→模糊→交互单选
 - remove 的 `-b` 参数可选，匹配策略：精确→模糊→交互多选；不传 `-b` 时列出所有分支供多选
-- validate 的交互式选择和 resume 使用同一个 `promptSelectBranch()`（Enquirer.Select）；remove 使用 `promptMultiSelectBranches()`（Enquirer.MultiSelect）
+- validate 的交互式选择使用 `promptSelectBranch()`（Enquirer.Select）；resume 和 remove 使用 `promptMultiSelectBranches()`（Enquirer.MultiSelect）
+- `promptMultiSelectBranches` 支持「全选」选项（顶部 [select-all]），通过扩展 MultiSelect 覆写 space() 实现全选 toggle
+- `SELECT_ALL_NAME` 和 `SELECT_ALL_LABEL` 常量定义在 `src/constants/prompt.ts`
+- `VALID_TERMINAL_APPS` 和 `ITERM2_APP_PATH` 常量定义在 `src/constants/terminal.ts`
 
 ## validate 快照机制
 

package/README.md

@@ -19,22 +19,19 @@ npm i -g clawt
 ```bash
 # 1. 在项目根目录（包含 .git 的目录）下执行
 # 2. 并行执行 3 个任务，每个任务在独立的 worktree 中运行
-clawt run -b feature-auth \
-  --tasks "实现用户登录功能" \
-  --tasks "实现用户注册功能" \
-  --tasks "实现密码重置功能"
+clawt run -b <branch-1>
+clawt run -b <branch-2>
+clawt run -b <branch-3>
 
 # 3. 查看所有 worktree 状态
 clawt status
 
 # 4. 验证某个分支的变更（在主 worktree 中测试）
-clawt validate -b feature-auth-1
+clawt validate -b branch-1
 
 # 5. 确认无误后合并到主分支
-clawt merge -b feature-auth-1 -m "feat: 实现用户登录功能"
+clawt merge -b branch-1 -m "feat: 实现xxx功能"
 
-# 6. 清理不需要的 worktree
-clawt remove -b feature-auth
 ```
 
 ## 命令一览
@@ -80,11 +77,15 @@ clawt run -f tasks.md -b feat
 
 ```bash
 clawt resume -b <branch>   # 指定分支
-clawt resume                # 交互式选择
+clawt resume                # 交互式多选
 ```
 
+支持多选：选 1 个在当前终端恢复，选多个自动在独立终端 Tab 中批量恢复（仅 macOS）。
+
 如果目标 worktree 存在历史会话，会自动继续上次对话（`--continue`）。
 
+> **注意：** 使用 Terminal.app 批量恢复时，需要在「系统设置 → 隐私与安全性 → 辅助功能」中授权终端应用。iTerm2 无需额外授权。终端类型可通过配置项 `terminalApp` 指定。
+
 ### `clawt create` — 仅创建 worktree（不执行任务）
 
 ```bash
@@ -159,6 +160,8 @@ clawt config reset    # 恢复默认配置
 | `claudeCodeCommand` | `"claude"` | Claude Code CLI 启动命令 |
 | `autoPullPush` | `false` | merge 后自动 pull/push |
 | `confirmDestructiveOps` | `true` | 破坏性操作前确认 |
+| `maxConcurrency` | `0` | run 命令最大并发数，`0` 为不限制 |
+| `terminalApp` | `"auto"` | 批量 resume 使用的终端：`auto` / `iterm2` / `terminal` |
 
 ## 全局选项
 

package/dist/index.js

@@ -119,7 +119,7 @@ var MERGE_MESSAGES = {
   /** merge 后清理 worktree 和分支成功 */
   WORKTREE_CLEANED: (branch) => `\u2713 \u5DF2\u6E05\u7406 worktree \u548C\u5206\u652F: ${branch}`,
   /** 目标 worktree 有未提交修改但未指定 -m */
-  TARGET_WORKTREE_DIRTY_NO_MESSAGE: "\u76EE\u6807 worktree \u6709\u672A\u63D0\u4EA4\u7684\u4FEE\u6539\uFF0C\u8BF7\u901A\u8FC7 -m \u53C2\u6570\u63D0\u4F9B\u63D0\u4EA4\u4FE1\u606F",
+  TARGET_WORKTREE_DIRTY_NO_MESSAGE: (worktreePath) => `${worktreePath} \u6709\u672A\u63D0\u4EA4\u7684\u4FEE\u6539\uFF0C\u8BF7\u901A\u8FC7 -m \u53C2\u6570\u63D0\u4F9B\u63D0\u4EA4\u4FE1\u606F`,
   /** 目标 worktree 既干净又无本地提交 */
   TARGET_WORKTREE_NO_CHANGES: "\u76EE\u6807 worktree \u6CA1\u6709\u4EFB\u4F55\u53EF\u5408\u5E76\u7684\u53D8\u66F4\uFF08\u5DE5\u4F5C\u533A\u5E72\u51C0\u4E14\u65E0\u672C\u5730\u63D0\u4EA4\uFF09",
   /** merge 命令检测到 validate 状态的提示 */
@@ -209,10 +209,18 @@ var RESUME_MESSAGES = {
   RESUME_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")}`,
-  /** 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 多选交互提示 */
+  RESUME_SELECT_BRANCH: "\u8BF7\u9009\u62E9\u8981\u6062\u590D\u7684\u5206\u652F\uFF08\u7A7A\u683C\u9009\u62E9\uFF0C\u56DE\u8F66\u786E\u8BA4\uFF09",
+  /** resume 模糊匹配到多个结果的多选提示 */
+  RESUME_MULTIPLE_MATCHES: (keyword) => `"${keyword}" \u5339\u914D\u5230\u591A\u4E2A\u5206\u652F\uFF0C\u8BF7\u9009\u62E9\u8981\u6062\u590D\u7684\uFF1A`,
+  /** 批量 resume 确认提示 */
+  RESUME_ALL_CONFIRM: (count) => `\u5373\u5C06\u5728 ${count} \u4E2A\u72EC\u7ACB\u7EC8\u7AEF Tab \u4E2D\u6062\u590D Claude Code \u4F1A\u8BDD\uFF0C\u662F\u5426\u7EE7\u7EED\uFF1F`,
+  /** 批量 resume 完成提示 */
+  RESUME_ALL_SUCCESS: (count) => `\u5DF2\u5728 ${count} \u4E2A\u7EC8\u7AEF Tab \u4E2D\u542F\u52A8 Claude Code \u4F1A\u8BDD`,
+  /** 批量 resume 非 macOS 平台提示 */
+  RESUME_ALL_PLATFORM_UNSUPPORTED: "\u6279\u91CF resume \u76EE\u524D\u4EC5\u652F\u6301 macOS \u5E73\u53F0\uFF08\u901A\u8FC7 AppleScript \u6253\u5F00\u7EC8\u7AEF Tab\uFF09",
+  /** 批量 resume 无匹配分支提示 */
+  RESUME_ALL_NO_MATCH: (keyword) => `\u672A\u627E\u5230\u4E0E "${keyword}" \u5339\u914D\u7684\u5206\u652F`
 };
 
 // src/constants/messages/remove.ts
@@ -297,6 +305,10 @@ var EXIT_CODES = {
   ARGUMENT_ERROR: 2
 };
 
+// src/constants/terminal.ts
+var VALID_TERMINAL_APPS = ["auto", "iterm2", "terminal"];
+var ITERM2_APP_PATH = "/Applications/iTerm.app";
+
 // src/constants/config.ts
 var APPEND_SYSTEM_PROMPT = "After the code execution is completed, it is prohibited to build the project for verification.";
 var CONFIG_DEFINITIONS = {
@@ -319,6 +331,10 @@ var CONFIG_DEFINITIONS = {
   maxConcurrency: {
     defaultValue: 0,
     description: "run \u547D\u4EE4\u9ED8\u8BA4\u6700\u5927\u5E76\u53D1\u6570\uFF0C0 \u8868\u793A\u4E0D\u9650\u5236"
+  },
+  terminalApp: {
+    defaultValue: "auto",
+    description: "\u6279\u91CF resume \u4F7F\u7528\u7684\u7EC8\u7AEF\u5E94\u7528\uFF1Aauto\uFF08\u81EA\u52A8\u68C0\u6D4B\uFF09\u3001iterm2\u3001terminal\uFF08macOS\uFF09"
   }
 };
 function deriveDefaultConfig(definitions) {
@@ -368,6 +384,10 @@ var TASK_STATUS_LABELS = {
   FAILED: "\u5931\u8D25"
 };
 
+// src/constants/prompt.ts
+var SELECT_ALL_NAME = "__select_all__";
+var SELECT_ALL_LABEL = "[select-all]";
+
 // src/errors/index.ts
 var ClawtError = class extends Error {
   /** 退出码 */
@@ -905,15 +925,88 @@ import Enquirer from "enquirer";
 
 // src/utils/claude.ts
 import { spawnSync } from "child_process";
-import { existsSync as existsSync5, readdirSync as readdirSync3 } from "fs";
+import { existsSync as existsSync6, readdirSync as readdirSync3 } from "fs";
 import { join as join3 } from "path";
+
+// src/utils/terminal.ts
+import { execFileSync as execFileSync2 } from "child_process";
+import { existsSync as existsSync5 } from "fs";
+function isITerm2Installed() {
+  return existsSync5(ITERM2_APP_PATH);
+}
+function detectTerminalApp() {
+  const configured = getConfigValue("terminalApp");
+  if (configured === "iterm2" || configured === "terminal") {
+    return configured;
+  }
+  if (!VALID_TERMINAL_APPS.includes(configured)) {
+    logger.warn(`terminalApp \u914D\u7F6E\u503C "${configured}" \u65E0\u6548\uFF0C\u6709\u6548\u503C: ${VALID_TERMINAL_APPS.join(", ")}\uFF0C\u5C06\u4F7F\u7528\u81EA\u52A8\u68C0\u6D4B`);
+  }
+  if (isITerm2Installed()) {
+    return "iterm2";
+  }
+  return "terminal";
+}
+function escapeAppleScriptString(str) {
+  return str.replace(/\\/g, "\\\\").replace(/"/g, '\\"');
+}
+function buildTerminalAppleScript(command, title) {
+  const escapedCommand = escapeAppleScriptString(command);
+  const escapedTitle = escapeAppleScriptString(title);
+  return `
+tell application "Terminal"
+  activate
+  tell application "System Events" to tell process "Terminal" to keystroke "t" using command down
+  delay 0.3
+  do script "${escapedCommand}" in front window's selected tab
+  set custom title of front window's selected tab to "${escapedTitle}"
+end tell
+  `.trim();
+}
+function buildITermAppleScript(command, title) {
+  const escapedCommand = escapeAppleScriptString(command);
+  const escapedTitle = escapeAppleScriptString(title);
+  return `
+tell application "iTerm"
+  activate
+  tell current window
+    create tab with default profile
+    tell current session
+      set name to "${escapedTitle}"
+      write text "${escapedCommand}"
+    end tell
+  end tell
+end tell
+  `.trim();
+}
+function openCommandInNewTerminalTab(command, tabTitle) {
+  if (process.platform !== "darwin") {
+    throw new ClawtError("\u6279\u91CF resume \u76EE\u524D\u4EC5\u652F\u6301 macOS \u5E73\u53F0\uFF08\u901A\u8FC7 AppleScript \u6253\u5F00\u7EC8\u7AEF Tab\uFF09");
+  }
+  const terminalApp = detectTerminalApp();
+  const script = terminalApp === "iterm2" ? buildITermAppleScript(command, tabTitle) : buildTerminalAppleScript(command, tabTitle);
+  logger.debug(`\u6253\u5F00\u7EC8\u7AEF Tab [${terminalApp}]: ${tabTitle}`);
+  logger.debug(`\u6267\u884C\u547D\u4EE4: ${command}`);
+  try {
+    execFileSync2("osascript", ["-e", script], {
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    const accessibilityHint = terminalApp === "terminal" ? "\n\u63D0\u793A\uFF1ATerminal.app \u9700\u8981\u8F85\u52A9\u529F\u80FD\u6743\u9650\uFF0C\u8BF7\u5728\u300C\u7CFB\u7EDF\u8BBE\u7F6E \u2192 \u9690\u79C1\u4E0E\u5B89\u5168\u6027 \u2192 \u8F85\u52A9\u529F\u80FD\u300D\u4E2D\u6388\u6743\u7EC8\u7AEF\u5E94\u7528" : "";
+    throw new ClawtError(`\u6253\u5F00\u7EC8\u7AEF Tab \u5931\u8D25: ${message}${accessibilityHint}`);
+  }
+}
+
+// src/utils/claude.ts
 function encodeClaudeProjectPath(absolutePath) {
   return absolutePath.replace(/[^a-zA-Z0-9]/g, "-");
 }
 function hasClaudeSessionHistory(worktreePath) {
   const encodedName = encodeClaudeProjectPath(worktreePath);
   const projectDir = join3(CLAUDE_PROJECTS_DIR, encodedName);
-  if (!existsSync5(projectDir)) {
+  if (!existsSync6(projectDir)) {
     return false;
   }
   const entries = readdirSync3(projectDir);
@@ -951,10 +1044,26 @@ function launchInteractiveClaude(worktree, options = {}) {
     printWarning(`Claude Code \u9000\u51FA\u7801: ${result.status}`);
   }
 }
+function escapeShellSingleQuote(str) {
+  return str.replace(/'/g, "'\\''");
+}
+function buildClaudeCommand(worktree, hasPreviousSession) {
+  const commandStr = getConfigValue("claudeCodeCommand");
+  const escapedPath = escapeShellSingleQuote(worktree.path);
+  const escapedPrompt = escapeShellSingleQuote(APPEND_SYSTEM_PROMPT);
+  const continueFlag = hasPreviousSession ? " --continue" : "";
+  return `cd '${escapedPath}' && ${commandStr} --append-system-prompt '${escapedPrompt}'${continueFlag}`;
+}
+function launchInteractiveClaudeInNewTerminal(worktree, hasPreviousSession) {
+  const command = buildClaudeCommand(worktree, hasPreviousSession);
+  const modeLabel = hasPreviousSession ? "\u7EE7\u7EED" : "\u65B0\u5BF9\u8BDD";
+  const tabTitle = `clawt: ${worktree.branch}`;
+  openCommandInNewTerminalTab(command, tabTitle);
+}
 
 // src/utils/validate-snapshot.ts
 import { join as join4 } from "path";
-import { existsSync as existsSync6, readFileSync as readFileSync2, writeFileSync as writeFileSync2, unlinkSync, readdirSync as readdirSync4, rmdirSync as rmdirSync2 } from "fs";
+import { existsSync as existsSync7, readFileSync as readFileSync2, writeFileSync as writeFileSync2, unlinkSync, readdirSync as readdirSync4, rmdirSync as rmdirSync2 } from "fs";
 function getSnapshotPath(projectName, branchName) {
   return join4(VALIDATE_SNAPSHOTS_DIR, projectName, `${branchName}.tree`);
 }
@@ -962,14 +1071,14 @@ function getSnapshotHeadPath(projectName, branchName) {
   return join4(VALIDATE_SNAPSHOTS_DIR, projectName, `${branchName}.head`);
 }
 function hasSnapshot(projectName, branchName) {
-  return existsSync6(getSnapshotPath(projectName, branchName));
+  return existsSync7(getSnapshotPath(projectName, branchName));
 }
 function readSnapshot(projectName, branchName) {
   const snapshotPath = getSnapshotPath(projectName, branchName);
   const headPath = getSnapshotHeadPath(projectName, branchName);
   logger.debug(`\u8BFB\u53D6 validate \u5FEB\u7167: ${snapshotPath}`);
-  const treeHash = existsSync6(snapshotPath) ? readFileSync2(snapshotPath, "utf-8").trim() : "";
-  const headCommitHash = existsSync6(headPath) ? readFileSync2(headPath, "utf-8").trim() : "";
+  const treeHash = existsSync7(snapshotPath) ? readFileSync2(snapshotPath, "utf-8").trim() : "";
+  const headCommitHash = existsSync7(headPath) ? readFileSync2(headPath, "utf-8").trim() : "";
   return { treeHash, headCommitHash };
 }
 function writeSnapshot(projectName, branchName, treeHash, headCommitHash) {
@@ -984,18 +1093,18 @@ function writeSnapshot(projectName, branchName, treeHash, headCommitHash) {
 function removeSnapshot(projectName, branchName) {
   const snapshotPath = getSnapshotPath(projectName, branchName);
   const headPath = getSnapshotHeadPath(projectName, branchName);
-  if (existsSync6(snapshotPath)) {
+  if (existsSync7(snapshotPath)) {
     unlinkSync(snapshotPath);
     logger.info(`\u5DF2\u5220\u9664 validate \u5FEB\u7167: ${snapshotPath}`);
   }
-  if (existsSync6(headPath)) {
+  if (existsSync7(headPath)) {
     unlinkSync(headPath);
     logger.info(`\u5DF2\u5220\u9664 validate \u5FEB\u7167: ${headPath}`);
   }
 }
 function getProjectSnapshotBranches(projectName) {
   const projectDir = join4(VALIDATE_SNAPSHOTS_DIR, projectName);
-  if (!existsSync6(projectDir)) {
+  if (!existsSync7(projectDir)) {
     return [];
   }
   const files = readdirSync4(projectDir);
@@ -1003,7 +1112,7 @@ function getProjectSnapshotBranches(projectName) {
 }
 function removeProjectSnapshots(projectName) {
   const projectDir = join4(VALIDATE_SNAPSHOTS_DIR, projectName);
-  if (!existsSync6(projectDir)) {
+  if (!existsSync7(projectDir)) {
     return;
   }
   const files = readdirSync4(projectDir);
@@ -1037,12 +1146,37 @@ async function promptSelectBranch(worktrees, message) {
   return worktrees.find((wt) => wt.branch === selectedBranch);
 }
 async function promptMultiSelectBranches(worktrees, message) {
-  const selectedBranches = await new Enquirer2.MultiSelect({
+  const branchChoices = worktrees.map((wt) => ({
+    name: wt.branch,
+    message: wt.branch
+  }));
+  const choices = [
+    { name: SELECT_ALL_NAME, message: SELECT_ALL_LABEL },
+    ...branchChoices
+  ];
+  const MultiSelect = Enquirer2.MultiSelect;
+  class MultiSelectWithSelectAll extends MultiSelect {
+    space() {
+      if (!this.focused) return;
+      if (this.focused.name === SELECT_ALL_NAME) {
+        const willEnable = !this.focused.enabled;
+        for (const ch of this.choices) {
+          ch.enabled = willEnable;
+        }
+        return this.render();
+      }
+      this.toggle(this.focused);
+      const selectAllChoice = this.choices.find((ch) => ch.name === SELECT_ALL_NAME);
+      const branchItems = this.choices.filter((ch) => ch.name !== SELECT_ALL_NAME);
+      if (selectAllChoice) {
+        selectAllChoice.enabled = branchItems.every((ch) => ch.enabled);
+      }
+      return this.render();
+    }
+  }
+  const selectedBranches = await new MultiSelectWithSelectAll({
     message,
-    choices: worktrees.map((wt) => ({
-      name: wt.branch,
-      message: wt.branch
-    })),
+    choices,
     // 使用空心圆/实心圆作为选中指示符
     symbols: {
       indicator: { on: "\u25CF", off: "\u25CB" }
@@ -1305,7 +1439,7 @@ var ProgressRenderer = class {
 
 // src/utils/task-file.ts
 import { resolve } from "path";
-import { existsSync as existsSync7, readFileSync as readFileSync3 } from "fs";
+import { existsSync as existsSync8, readFileSync as readFileSync3 } from "fs";
 var TASK_BLOCK_REGEX = /<!-- CLAWT-TASKS:START -->([\s\S]*?)<!-- CLAWT-TASKS:END -->/g;
 var BRANCH_LINE_REGEX = /^#\s*branch:\s*(.+)$/;
 function parseTaskFile(content, options) {
@@ -1343,7 +1477,7 @@ function parseTaskFile(content, options) {
 }
 function loadTaskFile(filePath, options) {
   const absolutePath = resolve(filePath);
-  if (!existsSync7(absolutePath)) {
+  if (!existsSync8(absolutePath)) {
     throw new ClawtError(MESSAGES.TASK_FILE_NOT_FOUND(absolutePath));
   }
   const content = readFileSync3(absolutePath, "utf-8");
@@ -1783,10 +1917,44 @@ function registerResumeCommand(program2) {
 async function handleResume(options) {
   validateMainWorktree();
   validateClaudeCodeInstalled();
-  logger.info(`resume \u547D\u4EE4\u6267\u884C\uFF0C\u5206\u652F: ${options.branch ?? "(\u672A\u6307\u5B9A)"}`);
+  logger.info(`resume \u547D\u4EE4\u6267\u884C\uFF0C\u5206\u652F\u8FC7\u6EE4: ${options.branch ?? "(\u65E0)"}`);
   const worktrees = getProjectWorktrees();
-  const worktree = await resolveTargetWorktree(worktrees, RESUME_RESOLVE_MESSAGES, options.branch);
-  launchInteractiveClaude(worktree, { autoContinue: true });
+  const targetWorktrees = await resolveTargetWorktrees(worktrees, RESUME_RESOLVE_MESSAGES, options.branch);
+  if (targetWorktrees.length === 0) {
+    return;
+  }
+  if (targetWorktrees.length === 1) {
+    launchInteractiveClaude(targetWorktrees[0], { autoContinue: true });
+  } else {
+    await handleBatchResume(targetWorktrees);
+  }
+}
+function printBatchResumePreview(worktrees, sessionMap) {
+  printInfo("\u5373\u5C06\u6062\u590D\u7684\u5206\u652F\uFF1A");
+  for (const wt of worktrees) {
+    const modeLabel = sessionMap.get(wt.path) ? "\u7EE7\u7EED\u4E0A\u6B21\u5BF9\u8BDD" : "\u65B0\u5BF9\u8BDD";
+    printInfo(`  - ${wt.branch} (${modeLabel})`);
+  }
+  printInfo("");
+}
+function buildSessionMap(worktrees) {
+  const map = /* @__PURE__ */ new Map();
+  for (const wt of worktrees) {
+    map.set(wt.path, hasClaudeSessionHistory(wt.path));
+  }
+  return map;
+}
+async function handleBatchResume(worktrees) {
+  const sessionMap = buildSessionMap(worktrees);
+  printBatchResumePreview(worktrees, sessionMap);
+  const confirmed = await confirmAction(MESSAGES.RESUME_ALL_CONFIRM(worktrees.length));
+  if (!confirmed) {
+    return;
+  }
+  for (const wt of worktrees) {
+    launchInteractiveClaudeInNewTerminal(wt, sessionMap.get(wt.path) ?? false);
+  }
+  printSuccess(MESSAGES.RESUME_ALL_SUCCESS(worktrees.length));
 }
 
 // src/commands/validate.ts
@@ -2037,7 +2205,7 @@ async function handleMerge(options) {
   const targetClean = isWorkingDirClean(targetWorktreePath);
   if (!targetClean) {
     if (!options.message) {
-      throw new ClawtError(MESSAGES.TARGET_WORKTREE_DIRTY_NO_MESSAGE);
+      throw new ClawtError(MESSAGES.TARGET_WORKTREE_DIRTY_NO_MESSAGE(targetWorktreePath));
     }
     gitAddAll(targetWorktreePath);
     gitCommit(options.message, targetWorktreePath);

package/dist/postinstall.js

@@ -111,7 +111,7 @@ var MERGE_MESSAGES = {
   /** merge 后清理 worktree 和分支成功 */
   WORKTREE_CLEANED: (branch) => `\u2713 \u5DF2\u6E05\u7406 worktree \u548C\u5206\u652F: ${branch}`,
   /** 目标 worktree 有未提交修改但未指定 -m */
-  TARGET_WORKTREE_DIRTY_NO_MESSAGE: "\u76EE\u6807 worktree \u6709\u672A\u63D0\u4EA4\u7684\u4FEE\u6539\uFF0C\u8BF7\u901A\u8FC7 -m \u53C2\u6570\u63D0\u4F9B\u63D0\u4EA4\u4FE1\u606F",
+  TARGET_WORKTREE_DIRTY_NO_MESSAGE: (worktreePath) => `${worktreePath} \u6709\u672A\u63D0\u4EA4\u7684\u4FEE\u6539\uFF0C\u8BF7\u901A\u8FC7 -m \u53C2\u6570\u63D0\u4F9B\u63D0\u4EA4\u4FE1\u606F`,
   /** 目标 worktree 既干净又无本地提交 */
   TARGET_WORKTREE_NO_CHANGES: "\u76EE\u6807 worktree \u6CA1\u6709\u4EFB\u4F55\u53EF\u5408\u5E76\u7684\u53D8\u66F4\uFF08\u5DE5\u4F5C\u533A\u5E72\u51C0\u4E14\u65E0\u672C\u5730\u63D0\u4EA4\uFF09",
   /** merge 命令检测到 validate 状态的提示 */
@@ -201,10 +201,18 @@ var RESUME_MESSAGES = {
   RESUME_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")}`,
-  /** 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 多选交互提示 */
+  RESUME_SELECT_BRANCH: "\u8BF7\u9009\u62E9\u8981\u6062\u590D\u7684\u5206\u652F\uFF08\u7A7A\u683C\u9009\u62E9\uFF0C\u56DE\u8F66\u786E\u8BA4\uFF09",
+  /** resume 模糊匹配到多个结果的多选提示 */
+  RESUME_MULTIPLE_MATCHES: (keyword) => `"${keyword}" \u5339\u914D\u5230\u591A\u4E2A\u5206\u652F\uFF0C\u8BF7\u9009\u62E9\u8981\u6062\u590D\u7684\uFF1A`,
+  /** 批量 resume 确认提示 */
+  RESUME_ALL_CONFIRM: (count) => `\u5373\u5C06\u5728 ${count} \u4E2A\u72EC\u7ACB\u7EC8\u7AEF Tab \u4E2D\u6062\u590D Claude Code \u4F1A\u8BDD\uFF0C\u662F\u5426\u7EE7\u7EED\uFF1F`,
+  /** 批量 resume 完成提示 */
+  RESUME_ALL_SUCCESS: (count) => `\u5DF2\u5728 ${count} \u4E2A\u7EC8\u7AEF Tab \u4E2D\u542F\u52A8 Claude Code \u4F1A\u8BDD`,
+  /** 批量 resume 非 macOS 平台提示 */
+  RESUME_ALL_PLATFORM_UNSUPPORTED: "\u6279\u91CF resume \u76EE\u524D\u4EC5\u652F\u6301 macOS \u5E73\u53F0\uFF08\u901A\u8FC7 AppleScript \u6253\u5F00\u7EC8\u7AEF Tab\uFF09",
+  /** 批量 resume 无匹配分支提示 */
+  RESUME_ALL_NO_MATCH: (keyword) => `\u672A\u627E\u5230\u4E0E "${keyword}" \u5339\u914D\u7684\u5206\u652F`
 };
 
 // src/constants/messages/remove.ts
@@ -300,6 +308,10 @@ var CONFIG_DEFINITIONS = {
   maxConcurrency: {
     defaultValue: 0,
     description: "run \u547D\u4EE4\u9ED8\u8BA4\u6700\u5927\u5E76\u53D1\u6570\uFF0C0 \u8868\u793A\u4E0D\u9650\u5236"
+  },
+  terminalApp: {
+    defaultValue: "auto",
+    description: "\u6279\u91CF resume \u4F7F\u7528\u7684\u7EC8\u7AEF\u5E94\u7528\uFF1Aauto\uFF08\u81EA\u52A8\u68C0\u6D4B\uFF09\u3001iterm2\u3001terminal\uFF08macOS\uFF09"
   }
 };
 function deriveDefaultConfig(definitions) {

package/docs/spec.md

@@ -175,7 +175,7 @@ git show-ref --verify refs/heads/<branchName> 2>/dev/null
 | `clawt list`          | 列出当前项目所有 worktree（支持 `--json` 格式输出） | 5.8      |
 | `clawt config`        | 查看全局配置                                     | 5.10     |
 | `clawt config reset`  | 将配置恢复为默认值                                | 5.10     |
-| `clawt resume`        | 在已有 worktree 中恢复 Claude Code 交互式会话      | 5.11     |
+| `clawt resume`        | 在已有 worktree 中恢复 Claude Code 会话（支持多选批量恢复） | 5.11     |
 | `clawt sync`          | 将主分支最新代码同步到目标 worktree                  | 5.12     |
 | `clawt reset`         | 重置主 worktree 工作区和暂存区                       | 5.13     |
 | `clawt status`        | 显示项目全局状态总览（支持 `--json` 格式输出）          | 5.14     |
@@ -751,7 +751,7 @@ clawt merge [-m <commitMessage>]
 5. **根据目标 worktree 状态决定是否需要提交**
    - 检测目标 worktree 工作区是否干净（`git status --porcelain`）
    - **工作区有未提交修改**：
-     - 如果用户未提供 `-m`，提示 `目标 worktree 有未提交的修改，请通过 -m 参数提供提交信息`，退出
+     - 如果用户未提供 `-m`，提示 `<worktreePath> 有未提交的修改，请通过 -m 参数提供提交信息`（其中 `<worktreePath>` 为目标 worktree 的完整路径），退出
      - 提供了 `-m` → 执行提交：
        ```bash
        cd ~/.clawt/worktrees/<project>/<branchName>
@@ -840,7 +840,9 @@ clawt merge [-m <commitMessage>]
   "autoDeleteBranch": false,
   "claudeCodeCommand": "claude",
   "autoPullPush": false,
-  "confirmDestructiveOps": true
+  "confirmDestructiveOps": true,
+  "maxConcurrency": 0,
+  "terminalApp": "auto"
 }
 ```
 
@@ -852,6 +854,8 @@ clawt merge [-m <commitMessage>]
 | `claudeCodeCommand` | `string` | `"claude"` | Claude Code CLI 启动指令，用于 `clawt run` 不传 `--tasks` 时和 `clawt resume` 在 worktree 中打开交互式界面 |
 | `autoPullPush` | `boolean` | `false` | merge 成功后是否自动执行 git pull 和 git push |
 | `confirmDestructiveOps` | `boolean` | `true` | 执行破坏性操作（reset、validate --clean、config reset）前是否提示确认 |
+| `maxConcurrency` | `number` | `0` | run 命令默认最大并发数，`0` 表示不限制 |
+| `terminalApp` | `string` | `"auto"` | 批量 resume 使用的终端应用：`auto`（自动检测）、`iterm2`、`terminal`（macOS） |
 
 ---
 
@@ -1054,7 +1058,7 @@ clawt config reset
 # 指定分支名（支持模糊匹配）
 clawt resume -b <branchName>
 
-# 不指定分支名（列出所有分支供选择）
+# 不指定分支名（列出所有分支供多选）
 clawt resume
 ```
 
@@ -1062,29 +1066,54 @@ clawt resume
 
 | 参数 | 必填 | 说明                                                  |
 | ---- | ---- | ----------------------------------------------------- |
-| `-b` | 否   | 要恢复的分支名（支持模糊匹配，不传则列出所有分支供选择） |
+| `-b` | 否   | 要恢复的分支名（支持模糊匹配，不传则列出所有分支供多选） |
 
 **使用场景：**
 
-当用户之前通过 `clawt run` 或 `clawt create` 创建了 worktree 但会话已结束，希望在该 worktree 中重新打开 Claude Code 交互式界面继续工作。
+当用户之前通过 `clawt run` 或 `clawt create` 创建了 worktree 但会话已结束，希望在该 worktree 中重新打开 Claude Code 交互式界面继续工作。支持一次选中多个分支，自动在独立终端 Tab 中批量恢复。
 
 **运行流程：**
 
 1. **主 worktree 校验** (2.1)
 2. **Claude Code CLI 校验**：确认 `claude` CLI 可用
-3. **解析目标 worktree**：根据 `-b` 参数解析目标 worktree，匹配策略如下：
+3. **解析目标 worktree（多选模式）**：统一使用 `resolveTargetWorktrees`（多选版本）解析目标 worktree，匹配策略如下：
    - **未传 `-b` 参数**：
      - 获取当前项目所有 worktree
      - 无可用 worktree → 报错退出
      - 仅 1 个 worktree → 直接使用，无需选择
-     - 多个 worktree → 通过交互式列表（Enquirer.Select）让用户选择
+     - 多个 worktree → 通过交互式多选列表（Enquirer.MultiSelect）让用户选择（空格选择，回车确认），顶部提供「全选」选项
    - **传了 `-b` 参数**：
      1. **精确匹配优先**：在 worktree 列表中查找分支名完全相同的 worktree，找到则直接使用
      2. **模糊匹配**（子串匹配，大小写不敏感）：
         - 唯一匹配 → 直接使用
-        - 多个匹配 → 通过交互式列表让用户从匹配结果中选择
+        - 多个匹配 → 通过交互式多选列表让用户从匹配结果中选择
      3. **无匹配** → 报错退出，并列出所有可用分支名
-4. **启动 Claude Code 交互式界面**：通过 `launchInteractiveClaude()` 在目标 worktree 中启动 Claude Code CLI 交互式界面（使用 `spawnSync` + `inherit stdio`）
+4. **根据选中数量自动分发**：
+   - **用户未选择任何分支** → 直接退出
+   - **选中 1 个** → 在当前终端恢复（同原有行为），通过 `launchInteractiveClaude()` 启动（使用 `spawnSync` + `inherit stdio`）
+   - **选中多个** → 进入批量恢复流程（见下文）
+
+**批量恢复流程：**
+
+1. **计算会话状态**：一次性遍历所有选中的 worktree，通过 `hasClaudeSessionHistory()` 检测是否存在历史会话，构建 sessionMap 避免重复 I/O
+2. **输出预览**：列出即将恢复的分支及其会话状态（"继续上次对话"或"新对话"）
+3. **用户确认**：提示即将在 N 个独立终端 Tab 中恢复会话，等待用户确认
+4. **逐个在新终端 Tab 中启动**：通过 `launchInteractiveClaudeInNewTerminal()` 构建 shell 命令并通过 AppleScript 在新终端 Tab 中执行
+5. **输出完成提示**
+
+**终端 Tab 管理：**
+
+批量恢复通过 `openCommandInNewTerminalTab()`（`src/utils/terminal.ts`）在新终端 Tab 中启动 Claude Code。终端类型由配置项 `terminalApp` 控制：
+
+| 配置值     | 行为                                                         |
+| ---------- | ------------------------------------------------------------ |
+| `auto`     | 自动检测：优先检测 iTerm2 是否已安装（`/Applications/iTerm.app`），已安装则使用 iTerm2，否则降级到 Terminal.app |
+| `iterm2`   | 强制使用 iTerm2                                               |
+| `terminal` | 强制使用 Terminal.app                                         |
+
+**平台限制：** 批量恢复目前仅支持 macOS 平台（通过 AppleScript 打开终端 Tab）。非 macOS 平台会抛出错误。
+
+**权限要求：** Terminal.app 通过 System Events 模拟键盘操作（`Cmd+T`）新建 Tab，需要在「系统设置 → 隐私与安全性 → 辅助功能」中授权终端应用。iTerm2 使用原生 AppleScript 接口，无需辅助功能权限。
 
 启动命令通过配置项 `claudeCodeCommand`（默认值 `claude`）指定，与 `clawt run` 不传 `--tasks` 时的交互式界面行为一致。
 

package/package.json

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

package/src/commands/merge.ts

@@ -165,7 +165,7 @@ async function handleMerge(options: MergeOptions): Promise<void> {
   if (!targetClean) {
     // 目标 worktree 有未提交修改，必须提供 -m
     if (!options.message) {
-      throw new ClawtError(MESSAGES.TARGET_WORKTREE_DIRTY_NO_MESSAGE);
+      throw new ClawtError(MESSAGES.TARGET_WORKTREE_DIRTY_NO_MESSAGE(targetWorktreePath));
     }
     gitAddAll(targetWorktreePath);
     gitCommit(options.message, targetWorktreePath);

package/src/commands/resume.ts

@@ -2,17 +2,23 @@ import type { Command } from 'commander';
 import { logger } from '../logger/index.js';
 import { MESSAGES } from '../constants/index.js';
 import type { ResumeOptions } from '../types/index.js';
+import type { WorktreeInfo } from '../types/index.js';
 import {
   validateMainWorktree,
   validateClaudeCodeInstalled,
   getProjectWorktrees,
   launchInteractiveClaude,
-  resolveTargetWorktree,
+  launchInteractiveClaudeInNewTerminal,
+  hasClaudeSessionHistory,
+  resolveTargetWorktrees,
+  printInfo,
+  printSuccess,
+  confirmAction,
 } from '../utils/index.js';
-import type { WorktreeResolveMessages } from '../utils/index.js';
+import type { WorktreeMultiResolveMessages } from '../utils/index.js';
 
-/** resume 命令的分支解析消息配置 */
-const RESUME_RESOLVE_MESSAGES: WorktreeResolveMessages = {
+/** resume 命令的多选分支解析消息配置 */
+const RESUME_RESOLVE_MESSAGES: WorktreeMultiResolveMessages = {
   noWorktrees: MESSAGES.RESUME_NO_WORKTREES,
   selectBranch: MESSAGES.RESUME_SELECT_BRANCH,
   multipleMatches: MESSAGES.RESUME_MULTIPLE_MATCHES,
@@ -35,19 +41,83 @@ export function registerResumeCommand(program: Command): void {
 
 /**
  * 执行 resume 命令的核心逻辑
- * 解析目标 worktree 并恢复 Claude Code 会话
+ * 统一走多选交互，根据选中数量自动分发：选 1 个在当前终端恢复，选多个在独立终端 Tab 中批量恢复
  * @param {ResumeOptions} options - 命令选项
  */
 async function handleResume(options: ResumeOptions): Promise<void> {
   validateMainWorktree();
   validateClaudeCodeInstalled();
 
-  logger.info(`resume 命令执行，分支: ${options.branch ?? '(未指定)'}`);
-
-  // 解析目标 worktree（精确匹配 / 模糊匹配 / 交互选择）
+  logger.info(`resume 命令执行，分支过滤: ${options.branch ?? '(无)'}`);
   const worktrees = getProjectWorktrees();
-  const worktree = await resolveTargetWorktree(worktrees, RESUME_RESOLVE_MESSAGES, options.branch);
 
-  // 启动 Claude Code 交互式界面（resume 自动续接历史会话）
-  launchInteractiveClaude(worktree, { autoContinue: true });
+  // 统一走多选解析（精确匹配 / 模糊匹配 / 交互多选）
+  const targetWorktrees = await resolveTargetWorktrees(worktrees, RESUME_RESOLVE_MESSAGES, options.branch);
+
+  // 用户未选择任何分支时直接退出
+  if (targetWorktrees.length === 0) {
+    return;
+  }
+
+  if (targetWorktrees.length === 1) {
+    // 选中 1 个 → 当前终端恢复（resume 自动续接历史会话）
+    launchInteractiveClaude(targetWorktrees[0], { autoContinue: true });
+  } else {
+    // 选中多个 → 逐个在新终端 Tab 中启动
+    await handleBatchResume(targetWorktrees);
+  }
+}
+
+/**
+ * 输出即将恢复的分支列表（含会话状态：继续/新对话）
+ * @param {WorktreeInfo[]} worktrees - 待恢复的 worktree 列表
+ * @param {Map<string, boolean>} sessionMap - worktree 路径 → 是否存在历史会话的映射
+ */
+function printBatchResumePreview(worktrees: WorktreeInfo[], sessionMap: Map<string, boolean>): void {
+  printInfo('即将恢复的分支：');
+  for (const wt of worktrees) {
+    const modeLabel = sessionMap.get(wt.path) ? '继续上次对话' : '新对话';
+    printInfo(`  - ${wt.branch} (${modeLabel})`);
+  }
+  printInfo('');
+}
+
+/**
+ * 批量计算 worktree 的会话历史状态
+ * 一次性遍历所有 worktree，避免后续流程中重复调用 hasClaudeSessionHistory 产生多余 I/O
+ * @param {WorktreeInfo[]} worktrees - worktree 列表
+ * @returns {Map<string, boolean>} worktree 路径 → 是否存在历史会话的映射
+ */
+function buildSessionMap(worktrees: WorktreeInfo[]): Map<string, boolean> {
+  const map = new Map<string, boolean>();
+  for (const wt of worktrees) {
+    map.set(wt.path, hasClaudeSessionHistory(wt.path));
+  }
+  return map;
+}
+
+/**
+ * 批量恢复多个 worktree 的 Claude Code 会话
+ * 逐个在新终端 Tab 中启动
+ * @param {WorktreeInfo[]} worktrees - 待恢复的 worktree 列表
+ */
+async function handleBatchResume(worktrees: WorktreeInfo[]): Promise<void> {
+  // 一次性计算所有 worktree 的会话状态，后续传递使用避免重复 I/O
+  const sessionMap = buildSessionMap(worktrees);
+
+  // 输出即将恢复的分支列表
+  printBatchResumePreview(worktrees, sessionMap);
+
+  // 确认操作
+  const confirmed = await confirmAction(MESSAGES.RESUME_ALL_CONFIRM(worktrees.length));
+  if (!confirmed) {
+    return;
+  }
+
+  // 逐个在新终端 Tab 中启动 Claude Code
+  for (const wt of worktrees) {
+    launchInteractiveClaudeInNewTerminal(wt, sessionMap.get(wt.path) ?? false);
+  }
+
+  printSuccess(MESSAGES.RESUME_ALL_SUCCESS(worktrees.length));
 }

package/src/constants/config.ts

@@ -29,6 +29,10 @@ export const CONFIG_DEFINITIONS: ConfigDefinitions = {
     defaultValue: 0,
     description: 'run 命令默认最大并发数，0 表示不限制',
   },
+  terminalApp: {
+    defaultValue: 'auto',
+    description: '批量 resume 使用的终端应用：auto（自动检测）、iterm2、terminal（macOS）',
+  },
 };
 
 /**

package/src/constants/index.ts

@@ -2,7 +2,7 @@ export { CLAWT_HOME, CONFIG_PATH, LOGS_DIR, WORKTREES_DIR, VALIDATE_SNAPSHOTS_DI
 export { INVALID_BRANCH_CHARS } from './branch.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 { ENABLE_BRACKETED_PASTE, DISABLE_BRACKETED_PASTE, PASTE_THRESHOLD_MS, VALID_TERMINAL_APPS, ITERM2_APP_PATH } from './terminal.js';
 export { DEFAULT_CONFIG, CONFIG_DESCRIPTIONS, APPEND_SYSTEM_PROMPT } from './config.js';
 export { AUTO_SAVE_COMMIT_MESSAGE } from './git.js';
 export { DEBUG_LOG_PREFIX, DEBUG_TIMESTAMP_FORMAT } from './logger.js';
@@ -16,3 +16,4 @@ export {
   TASK_STATUS_ICONS,
   TASK_STATUS_LABELS,
 } from './progress.js';
+export { SELECT_ALL_NAME, SELECT_ALL_LABEL } from './prompt.js';

package/src/constants/messages/merge.ts

@@ -11,7 +11,8 @@ export const MERGE_MESSAGES = {
   /** merge 后清理 worktree 和分支成功 */
   WORKTREE_CLEANED: (branch: string) => `✓ 已清理 worktree 和分支: ${branch}`,
   /** 目标 worktree 有未提交修改但未指定 -m */
-  TARGET_WORKTREE_DIRTY_NO_MESSAGE: '目标 worktree 有未提交的修改，请通过 -m 参数提供提交信息',
+  TARGET_WORKTREE_DIRTY_NO_MESSAGE: (worktreePath: string) =>
+    `${worktreePath} 有未提交的修改，请通过 -m 参数提供提交信息`,
   /** 目标 worktree 既干净又无本地提交 */
   TARGET_WORKTREE_NO_CHANGES: '目标 worktree 没有任何可合并的变更（工作区干净且无本地提交）',
   /** merge 命令检测到 validate 状态的提示 */

package/src/constants/messages/resume.ts

@@ -5,8 +5,17 @@ export const RESUME_MESSAGES = {
   /** 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}" 匹配到多个分支，请选择：`,
+  /** resume 多选交互提示 */
+  RESUME_SELECT_BRANCH: '请选择要恢复的分支（空格选择，回车确认）',
+  /** resume 模糊匹配到多个结果的多选提示 */
+  RESUME_MULTIPLE_MATCHES: (keyword: string) => `"${keyword}" 匹配到多个分支，请选择要恢复的：`,
+
+  /** 批量 resume 确认提示 */
+  RESUME_ALL_CONFIRM: (count: number) => `即将在 ${count} 个独立终端 Tab 中恢复 Claude Code 会话，是否继续？`,
+  /** 批量 resume 完成提示 */
+  RESUME_ALL_SUCCESS: (count: number) => `已在 ${count} 个终端 Tab 中启动 Claude Code 会话`,
+  /** 批量 resume 非 macOS 平台提示 */
+  RESUME_ALL_PLATFORM_UNSUPPORTED: '批量 resume 目前仅支持 macOS 平台（通过 AppleScript 打开终端 Tab）',
+  /** 批量 resume 无匹配分支提示 */
+  RESUME_ALL_NO_MATCH: (keyword: string) => `未找到与 "${keyword}" 匹配的分支`,
 } as const;

package/src/constants/messages.ts

@@ -45,7 +45,8 @@ export const MESSAGES = {
   /** 请提供提交信息 */
   COMMIT_MESSAGE_REQUIRED: '请提供提交信息（-m 参数）',
   /** 目标 worktree 有未提交修改但未指定 -m */
-  TARGET_WORKTREE_DIRTY_NO_MESSAGE: '目标 worktree 有未提交的修改，请通过 -m 参数提供提交信息',
+  TARGET_WORKTREE_DIRTY_NO_MESSAGE: (worktreePath: string) =>
+    `${worktreePath} 有未提交的修改，请通过 -m 参数提供提交信息`,
   /** 目标 worktree 既干净又无本地提交 */
   TARGET_WORKTREE_NO_CHANGES: '目标 worktree 没有任何可合并的变更（工作区干净且无本地提交）',
   /** 检测到用户中断 */

package/src/constants/prompt.ts

@@ -0,0 +1,5 @@
+/** 多选列表中全选选项的标识名称 */
+export const SELECT_ALL_NAME = '__select_all__';
+
+/** 多选列表中全选选项的显示文本 */
+export const SELECT_ALL_LABEL = '[select-all]';

package/src/constants/terminal.ts

@@ -11,3 +11,9 @@ export const DISABLE_BRACKETED_PASTE = '\x1b[?2004l';
  * 作为 Bracketed Paste Mode 不可用时的降级方案
  */
 export const PASTE_THRESHOLD_MS = 10;
+
+/** 配置项 terminalApp 允许的有效值 */
+export const VALID_TERMINAL_APPS: readonly string[] = ['auto', 'iterm2', 'terminal'];
+
+/** iTerm2 应用路径，用于 auto 模式检测是否已安装 */
+export const ITERM2_APP_PATH = '/Applications/iTerm.app';

package/src/types/config.ts

@@ -10,6 +10,8 @@ export interface ClawtConfig {
   confirmDestructiveOps: boolean;
   /** run 命令默认最大并发数，0 表示不限制 */
   maxConcurrency: number;
+  /** 批量 resume 使用的终端应用：'auto'（自动检测）、'iterm2'、'terminal'（macOS） */
+  terminalApp: string;
 }
 
 /** 单个配置项的完整定义（默认值 + 描述） */

package/src/utils/claude.ts

@@ -5,6 +5,7 @@ import { ClawtError } from '../errors/index.js';
 import { APPEND_SYSTEM_PROMPT, CLAUDE_PROJECTS_DIR } from '../constants/index.js';
 import { getConfigValue } from './config.js';
 import { printInfo, printWarning } from './formatter.js';
+import { openCommandInNewTerminalTab } from './terminal.js';
 import type { WorktreeInfo } from '../types/index.js';
 
 /**
@@ -87,3 +88,44 @@ export function launchInteractiveClaude(worktree: WorktreeInfo, options: LaunchC
     printWarning(`Claude Code 退出码: ${result.status}`);
   }
 }
+
+/**
+ * 转义 shell 单引号
+ * 将字符串中的单引号替换为 '\'' 以安全嵌入单引号包裹的 shell 字符串
+ * @param {string} str - 原始字符串
+ * @returns {string} 转义后的字符串
+ */
+function escapeShellSingleQuote(str: string): string {
+  return str.replace(/'/g, "'\\''");
+}
+
+/**
+ * 构建在指定 worktree 中启动 Claude Code 的完整 shell 命令
+ * 生成格式：cd <path> && <claudeCommand> --append-system-prompt '...' [--continue]
+ * @param {WorktreeInfo} worktree - worktree 信息
+ * @param {boolean} hasPreviousSession - 是否存在历史会话（由调用方预计算，避免重复 I/O）
+ * @returns {string} 完整的 shell 命令字符串
+ */
+export function buildClaudeCommand(worktree: WorktreeInfo, hasPreviousSession: boolean): string {
+  const commandStr = getConfigValue('claudeCodeCommand');
+
+  const escapedPath = escapeShellSingleQuote(worktree.path);
+  const escapedPrompt = escapeShellSingleQuote(APPEND_SYSTEM_PROMPT);
+  const continueFlag = hasPreviousSession ? ' --continue' : '';
+
+  return `cd '${escapedPath}' && ${commandStr} --append-system-prompt '${escapedPrompt}'${continueFlag}`;
+}
+
+/**
+ * 在新终端 Tab 中启动 Claude Code 交互式会话
+ * 通过 AppleScript 打开独立终端 Tab，支持 Terminal.app 和 iTerm2
+ * @param {WorktreeInfo} worktree - worktree 信息
+ * @param {boolean} hasPreviousSession - 是否存在历史会话（由调用方预计算，避免重复 I/O）
+ */
+export function launchInteractiveClaudeInNewTerminal(worktree: WorktreeInfo, hasPreviousSession: boolean): void {
+  const command = buildClaudeCommand(worktree, hasPreviousSession);
+  const modeLabel = hasPreviousSession ? '继续' : '新对话';
+  const tabTitle = `clawt: ${worktree.branch}`;
+
+  openCommandInNewTerminalTab(command, tabTitle);
+}

package/src/utils/index.ts

@@ -52,11 +52,12 @@ export { loadConfig, writeDefaultConfig, getConfigValue, ensureClawtDirs } from
 export { printSuccess, printError, printWarning, printInfo, printSeparator, printDoubleSeparator, confirmAction, confirmDestructiveAction, formatWorktreeStatus, isWorktreeIdle, formatDuration } from './formatter.js';
 export { ensureDir, removeEmptyDir } from './fs.js';
 export { multilineInput } from './prompt.js';
-export { launchInteractiveClaude, hasClaudeSessionHistory } from './claude.js';
+export { launchInteractiveClaude, hasClaudeSessionHistory, launchInteractiveClaudeInNewTerminal } from './claude.js';
 export { getSnapshotPath, hasSnapshot, readSnapshotTreeHash, readSnapshot, writeSnapshot, removeSnapshot, removeProjectSnapshots, getProjectSnapshotBranches } from './validate-snapshot.js';
 export { findExactMatch, findFuzzyMatches, promptSelectBranch, promptMultiSelectBranches, resolveTargetWorktree, resolveTargetWorktrees } from './worktree-matcher.js';
 export type { WorktreeResolveMessages, WorktreeMultiResolveMessages } from './worktree-matcher.js';
 export { ProgressRenderer } from './progress.js';
 export { parseTaskFile, loadTaskFile } from './task-file.js';
 export { executeBatchTasks } from './task-executor.js';
+export { detectTerminalApp, openCommandInNewTerminalTab } from './terminal.js';
 

package/src/utils/terminal.ts

@@ -0,0 +1,134 @@
+import { execFileSync } from 'node:child_process';
+import { existsSync } from 'node:fs';
+import { ClawtError } from '../errors/index.js';
+import { logger } from '../logger/index.js';
+import { VALID_TERMINAL_APPS, ITERM2_APP_PATH } from '../constants/index.js';
+import { getConfigValue } from './config.js';
+
+/** 终端应用类型 */
+type TerminalApp = 'iterm2' | 'terminal';
+
+/**
+ * 检测系统是否安装了 iTerm2
+ * 通过检查 /Applications/iTerm.app 是否存在来判断
+ * @returns {boolean} 是否安装了 iTerm2
+ */
+function isITerm2Installed(): boolean {
+  return existsSync(ITERM2_APP_PATH);
+}
+
+/**
+ * 检测当前使用的终端应用
+ * 优先读取配置项 terminalApp；值为 'auto' 时优先检测 iTerm2 是否已安装，
+ * 已安装则使用 iTerm2，否则降级到 Terminal.app
+ * @returns {TerminalApp} 终端类型：'iterm2' 或 'terminal'
+ */
+export function detectTerminalApp(): TerminalApp {
+  const configured = getConfigValue('terminalApp');
+
+  // 配置了明确的终端类型，直接使用
+  if (configured === 'iterm2' || configured === 'terminal') {
+    return configured;
+  }
+
+  // 配置值无效时给出警告（auto 除外）
+  if (!VALID_TERMINAL_APPS.includes(configured)) {
+    logger.warn(`terminalApp 配置值 "${configured}" 无效，有效值: ${VALID_TERMINAL_APPS.join(', ')}，将使用自动检测`);
+  }
+
+  // auto 模式：优先检测 iTerm2 是否已安装
+  if (isITerm2Installed()) {
+    return 'iterm2';
+  }
+  return 'terminal';
+}
+
+/**
+ * 转义 AppleScript 字符串中的特殊字符
+ * 将反斜杠和双引号进行转义，防止注入
+ * @param {string} str - 原始字符串
+ * @returns {string} 转义后的字符串
+ */
+function escapeAppleScriptString(str: string): string {
+  return str.replace(/\\/g, '\\\\').replace(/"/g, '\\"');
+}
+
+/**
+ * 构建 Terminal.app 的 AppleScript 脚本
+ * 在当前窗口新建 Tab 并执行命令
+ * @param {string} command - 要执行的 shell 命令
+ * @param {string} title - Tab 标题
+ * @returns {string} AppleScript 脚本内容
+ */
+function buildTerminalAppleScript(command: string, title: string): string {
+  const escapedCommand = escapeAppleScriptString(command);
+  const escapedTitle = escapeAppleScriptString(title);
+  return `
+tell application "Terminal"
+  activate
+  tell application "System Events" to tell process "Terminal" to keystroke "t" using command down
+  delay 0.3
+  do script "${escapedCommand}" in front window's selected tab
+  set custom title of front window's selected tab to "${escapedTitle}"
+end tell
+  `.trim();
+}
+
+/**
+ * 构建 iTerm2 的 AppleScript 脚本
+ * 在当前窗口新建 Tab 并执行命令
+ * @param {string} command - 要执行的 shell 命令
+ * @param {string} title - Tab 标题
+ * @returns {string} AppleScript 脚本内容
+ */
+function buildITermAppleScript(command: string, title: string): string {
+  const escapedCommand = escapeAppleScriptString(command);
+  const escapedTitle = escapeAppleScriptString(title);
+  return `
+tell application "iTerm"
+  activate
+  tell current window
+    create tab with default profile
+    tell current session
+      set name to "${escapedTitle}"
+      write text "${escapedCommand}"
+    end tell
+  end tell
+end tell
+  `.trim();
+}
+
+/**
+ * 在新终端 Tab 中执行命令
+ * 自动检测终端类型（iTerm2 / Terminal.app），通过 AppleScript 打开新 Tab
+ * @param {string} command - 要执行的 shell 命令
+ * @param {string} tabTitle - Tab 标题
+ * @throws {ClawtError} 非 macOS 平台或 AppleScript 执行失败时抛出
+ */
+export function openCommandInNewTerminalTab(command: string, tabTitle: string): void {
+  if (process.platform !== 'darwin') {
+    throw new ClawtError('批量 resume 目前仅支持 macOS 平台（通过 AppleScript 打开终端 Tab）');
+  }
+
+  const terminalApp = detectTerminalApp();
+  const script = terminalApp === 'iterm2'
+    ? buildITermAppleScript(command, tabTitle)
+    : buildTerminalAppleScript(command, tabTitle);
+
+  logger.debug(`打开终端 Tab [${terminalApp}]: ${tabTitle}`);
+  logger.debug(`执行命令: ${command}`);
+
+  try {
+    execFileSync('osascript', ['-e', script], {
+      encoding: 'utf-8',
+      stdio: ['pipe', 'pipe', 'pipe'],
+    });
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    // Terminal.app 通过 System Events 模拟键盘操作需要辅助功能权限
+    const accessibilityHint = terminalApp === 'terminal'
+      ? '\n提示：Terminal.app 需要辅助功能权限，请在「系统设置 → 隐私与安全性 → 辅助功能」中授权终端应用'
+      : '';
+    throw new ClawtError(`打开终端 Tab 失败: ${message}${accessibilityHint}`);
+  }
+}

package/src/utils/worktree-matcher.ts

@@ -1,7 +1,27 @@
 import Enquirer from 'enquirer';
 import { ClawtError } from '../errors/index.js';
+import { SELECT_ALL_NAME, SELECT_ALL_LABEL } from '../constants/index.js';
 import type { WorktreeInfo } from '../types/index.js';
 
+/** enquirer MultiSelect 选项条目的运行时结构 */
+interface MultiSelectChoice {
+  name: string;
+  message: string;
+  enabled: boolean;
+}
+
+/**
+ * enquirer MultiSelect 实例的运行时接口
+ * enquirer 类型声明未导出 MultiSelect，手动声明以消除 TypeScript 类型错误
+ */
+interface MultiSelectInstance {
+  focused: MultiSelectChoice | undefined;
+  choices: MultiSelectChoice[];
+  render(): void;
+  toggle(choice: MultiSelectChoice): void;
+  run(): Promise<string[]>;
+}
+
 /**
  * 分支解析时使用的消息文案配置
  * 通过此接口实现命令间的消息解耦，不同命令可传入各自的提示文案
@@ -74,25 +94,68 @@ export async function promptSelectBranch(worktrees: WorktreeInfo[], message: str
 
 /**
  * 通过交互式多选列表让用户从 worktree 列表中选择多个分支
+ * 顶部提供「全选」选项，点击可切换全选/全不选
  * 用户可通过空格键选择/取消，回车键确认
  * @param {WorktreeInfo[]} worktrees - 可供选择的 worktree 列表
  * @param {string} message - 选择提示信息
  * @returns {Promise<WorktreeInfo[]>} 用户选择的 worktree 列表
  */
 export async function promptMultiSelectBranches(worktrees: WorktreeInfo[], message: string): Promise<WorktreeInfo[]> {
+  // 构建 choices 列表，顶部插入全选选项
+  const branchChoices = worktrees.map((wt) => ({
+    name: wt.branch,
+    message: wt.branch,
+  }));
+
+  const choices = [
+    { name: SELECT_ALL_NAME, message: SELECT_ALL_LABEL },
+    ...branchChoices,
+  ];
+
   // @ts-expect-error enquirer 类型声明未导出 MultiSelect 类，但运行时存在
-  const selectedBranches: string[] = await new Enquirer.MultiSelect({
+  const MultiSelect: new (options: Record<string, unknown>) => MultiSelectInstance = Enquirer.MultiSelect;
+
+  /**
+   * 扩展 MultiSelect，覆写 space() 方法实现全选 toggle
+   * 当焦点在「全选」选项上按空格时，切换所有分支选项的选中状态
+   */
+  class MultiSelectWithSelectAll extends MultiSelect {
+    space(this: MultiSelectInstance) {
+      if (!this.focused) return;
+
+      if (this.focused.name === SELECT_ALL_NAME) {
+        // 切换全选：如果全选项当前未选中则全选，否则全不选
+        const willEnable = !this.focused.enabled;
+        for (const ch of this.choices) {
+          ch.enabled = willEnable;
+        }
+        return this.render();
+      }
+
+      // 非全选选项：执行默认的 toggle 行为
+      this.toggle(this.focused);
+
+      // 同步全选选项状态：所有分支选项都选中时自动勾选全选，否则取消
+      const selectAllChoice = this.choices.find((ch) => ch.name === SELECT_ALL_NAME);
+      const branchItems = this.choices.filter((ch) => ch.name !== SELECT_ALL_NAME);
+      if (selectAllChoice) {
+        selectAllChoice.enabled = branchItems.every((ch) => ch.enabled);
+      }
+
+      return this.render();
+    }
+  }
+
+  const selectedBranches: string[] = await new MultiSelectWithSelectAll({
     message,
-    choices: worktrees.map((wt) => ({
-      name: wt.branch,
-      message: wt.branch,
-    })),
+    choices,
     // 使用空心圆/实心圆作为选中指示符
     symbols: {
       indicator: { on: '●', off: '○' },
     },
   }).run();
 
+  // 过滤掉全选选项，只返回实际的 worktree
   return worktrees.filter((wt) => selectedBranches.includes(wt.branch));
 }
 

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

@@ -26,7 +26,8 @@ vi.mock('../../../src/constants/index.js', () => ({
     MERGE_SQUASH_PENDING: (path: string, branch: string) => `请手动提交: ${path}`,
     MERGE_VALIDATE_STATE_HINT: (branch: string) => `分支 ${branch} 存在 validate 状态`,
     MAIN_WORKTREE_DIRTY: '主 worktree 有未提交的更改',
-    TARGET_WORKTREE_DIRTY_NO_MESSAGE: '目标 worktree 有未提交修改，请提供 -m 参数',
+    TARGET_WORKTREE_DIRTY_NO_MESSAGE: (worktreePath: string) =>
+      `${worktreePath} 有未提交修改，请提供 -m 参数`,
     TARGET_WORKTREE_NO_CHANGES: '没有可合并的变更',
     MERGE_CONFLICT: '合并冲突',
     PULL_CONFLICT: 'pull 冲突',