clawt 2.11.0 → 2.12.0

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 交互式界面
-  launchInteractiveClaude(worktree);
+  // 统一走多选解析（精确匹配 / 模糊匹配 / 交互多选）
+  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

@@ -1,8 +1,8 @@
-export { CLAWT_HOME, CONFIG_PATH, LOGS_DIR, WORKTREES_DIR, VALIDATE_SNAPSHOTS_DIR } from './paths.js';
+export { CLAWT_HOME, CONFIG_PATH, LOGS_DIR, WORKTREES_DIR, VALIDATE_SNAPSHOTS_DIR, CLAUDE_PROJECTS_DIR } from './paths.js';
 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/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/paths.ts

@@ -15,3 +15,6 @@ export const WORKTREES_DIR = join(CLAWT_HOME, 'worktrees');
 
 /** validate 快照目录 ~/.clawt/validate-snapshots/ */
 export const VALIDATE_SNAPSHOTS_DIR = join(CLAWT_HOME, 'validate-snapshots');
+
+/** Claude Code 项目会话目录 ~/.claude/projects/ */
+export const CLAUDE_PROJECTS_DIR = join(homedir(), '.claude', 'projects');

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

@@ -1,16 +1,56 @@
 import { spawnSync } from 'node:child_process';
+import { existsSync, readdirSync } from 'node:fs';
+import { join } from 'node:path';
 import { ClawtError } from '../errors/index.js';
-import { APPEND_SYSTEM_PROMPT } from '../constants/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';
 
+/**
+ * 将路径编码为 Claude Code 项目目录名
+ * 规则：将所有非字母数字字符替换为 -（与 Claude Code 源码中的编码逻辑一致）
+ * @param {string} absolutePath - 绝对路径
+ * @returns {string} 编码后的目录名
+ */
+function encodeClaudeProjectPath(absolutePath: string): string {
+  return absolutePath.replace(/[^a-zA-Z0-9]/g, '-');
+}
+
+/**
+ * 检测指定 worktree 路径是否存在 Claude Code 会话历史
+ * 通过检查 ~/.claude/projects/<encoded-path>/ 下是否有 .jsonl 文件来判断
+ * @param {string} worktreePath - worktree 的绝对路径
+ * @returns {boolean} 是否存在会话历史
+ */
+export function hasClaudeSessionHistory(worktreePath: string): boolean {
+  const encodedName = encodeClaudeProjectPath(worktreePath);
+  const projectDir = join(CLAUDE_PROJECTS_DIR, encodedName);
+
+  if (!existsSync(projectDir)) {
+    return false;
+  }
+
+  const entries = readdirSync(projectDir);
+  return entries.some((entry) => entry.endsWith('.jsonl'));
+}
+
 /**
  * 在指定 worktree 中启动 Claude Code CLI 交互式界面
  * 使用 spawnSync + inherit stdio，让用户直接与 Claude Code 交互
  * @param {WorktreeInfo} worktree - worktree 信息
  */
-export function launchInteractiveClaude(worktree: WorktreeInfo): void {
+/**
+ * @typedef {Object} LaunchClaudeOptions
+ * @property {boolean} [autoContinue] - 是否自动检测历史会话并续接
+ */
+interface LaunchClaudeOptions {
+  /** 是否自动检测历史会话并追加 --continue 参数 */
+  autoContinue?: boolean;
+}
+
+export function launchInteractiveClaude(worktree: WorktreeInfo, options: LaunchClaudeOptions = {}): void {
   const commandStr = getConfigValue('claudeCodeCommand');
   const parts = commandStr.split(/\s+/).filter(Boolean);
   const cmd = parts[0];
@@ -20,10 +60,19 @@ export function launchInteractiveClaude(worktree: WorktreeInfo): void {
     APPEND_SYSTEM_PROMPT,
   ];
 
+  // 仅在启用 autoContinue 时检测历史会话并追加 --continue
+  const hasPreviousSession = options.autoContinue === true && hasClaudeSessionHistory(worktree.path);
+  if (hasPreviousSession) {
+    args.push('--continue');
+  }
+
   printInfo(`正在 worktree 中启动 Claude Code 交互式界面...`);
   printInfo(`  分支: ${worktree.branch}`);
   printInfo(`  路径: ${worktree.path}`);
   printInfo(`  指令: ${commandStr}`);
+  if (options.autoContinue) {
+    printInfo(`  模式: ${hasPreviousSession ? '继续上次对话' : '新对话'}`);
+  }
   printInfo('');
 
   const result = spawnSync(cmd, args, {
@@ -39,3 +88,44 @@ export function launchInteractiveClaude(worktree: WorktreeInfo): void {
     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 } 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/resume.test.ts

@@ -68,7 +68,7 @@ describe('handleResume', () => {
     expect(mockedValidateMainWorktree).toHaveBeenCalled();
     expect(mockedValidateClaudeCodeInstalled).toHaveBeenCalled();
     expect(mockedResolveTargetWorktree).toHaveBeenCalled();
-    expect(mockedLaunchInteractiveClaude).toHaveBeenCalledWith(worktree);
+    expect(mockedLaunchInteractiveClaude).toHaveBeenCalledWith(worktree, { autoContinue: true });
   });
 
   it('不传 -b 时也能调用 resolveTargetWorktree', async () => {