clawt 2.10.1 → 2.11.0

package/src/utils/index.ts

@@ -47,12 +47,16 @@ export {
 } from './git.js';
 export { sanitizeBranchName, generateBranchNames, validateBranchesNotExist } from './branch.js';
 export { validateMainWorktree, validateGitInstalled, validateClaudeCodeInstalled } from './validation.js';
-export { createWorktrees, getProjectWorktrees, getProjectWorktreeDir, cleanupWorktrees, getWorktreeStatus } from './worktree.js';
+export { createWorktrees, getProjectWorktrees, getProjectWorktreeDir, cleanupWorktrees, getWorktreeStatus, createWorktreesByBranches } from './worktree.js';
 export { loadConfig, writeDefaultConfig, getConfigValue, ensureClawtDirs } from './config.js';
-export { printSuccess, printError, printWarning, printInfo, printSeparator, printDoubleSeparator, confirmAction, confirmDestructiveAction, formatWorktreeStatus, isWorktreeIdle } from './formatter.js';
+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 { 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';
+

package/src/utils/progress-render.ts

@@ -0,0 +1,90 @@
+import chalk from 'chalk';
+import { TASK_STATUS_ICONS, TASK_STATUS_LABELS } from '../constants/index.js';
+import { formatDuration } from './formatter.js';
+
+/** 单个任务的进度状态 */
+export interface TaskProgress {
+  /** 任务序号（从 1 开始） */
+  index: number;
+  /** 分支名（用于显示） */
+  branch: string;
+  /** worktree 路径（完成/失败后显示，终端可点击跳转） */
+  path: string;
+  /** 任务状态 */
+  status: 'pending' | 'running' | 'done' | 'failed';
+  /** 任务启动时间戳 */
+  startedAt: number;
+  /** 任务完成时间戳 */
+  finishedAt: number | null;
+  /** 最后活动时间戳（stderr 有输出时更新） */
+  lastActiveAt: number;
+  /** 耗时（毫秒），完成后由 ClaudeCodeResult 填入 */
+  durationMs: number | null;
+  /** 费用（美元），完成后由 ClaudeCodeResult 填入 */
+  costUsd: number | null;
+}
+
+/**
+ * 计算分支名的最大显示宽度，用于对齐
+ * @param {TaskProgress[]} tasks - 任务列表
+ * @returns {number} 最大分支名长度
+ */
+export function getMaxBranchWidth(tasks: TaskProgress[]): number {
+  return Math.max(...tasks.map((t) => t.branch.length));
+}
+
+/**
+ * 渲染单个任务行（TTY 模式）
+ * 格式: [1/3] feat-1  ⠹ 运行中 1m23s
+ * 完成/失败后追加 worktree 路径，终端可点击跳转
+ * @param {TaskProgress} task - 任务进度
+ * @param {number} total - 总任务数
+ * @param {number} maxBranchWidth - 分支名最大宽度（用于对齐）
+ * @param {string} spinnerChar - 当前 spinner 帧字符
+ * @returns {string} 渲染后的单行字符串（含 chalk 颜色）
+ */
+export function renderTaskLine(task: TaskProgress, total: number, maxBranchWidth: number, spinnerChar: string): string {
+  const indexStr = `[${task.index}/${total}]`;
+  const branchStr = task.branch.padEnd(maxBranchWidth);
+
+  switch (task.status) {
+    case 'pending': {
+      return `${indexStr} ${branchStr}  ${chalk.gray(TASK_STATUS_ICONS.PENDING)} ${chalk.gray(TASK_STATUS_LABELS.PENDING)}  ${chalk.dim(task.path)}`;
+    }
+    case 'running': {
+      const elapsed = formatDuration(Date.now() - task.startedAt);
+      return `${indexStr} ${branchStr}  ${chalk.cyan(spinnerChar)} ${chalk.cyan(TASK_STATUS_LABELS.RUNNING)} ${chalk.gray(elapsed)}  ${chalk.dim(task.path)}`;
+    }
+    case 'done': {
+      const duration = task.durationMs != null ? formatDuration(task.durationMs) : 'N/A';
+      const cost = task.costUsd != null ? `$${task.costUsd.toFixed(2)}` : '';
+      return `${indexStr} ${branchStr}  ${chalk.green(TASK_STATUS_ICONS.DONE)} ${chalk.green(TASK_STATUS_LABELS.DONE)}   ${chalk.gray(duration)}  ${chalk.yellow(cost)}  ${chalk.dim(task.path)}`;
+    }
+    case 'failed': {
+      const duration = task.durationMs != null ? formatDuration(task.durationMs) : 'N/A';
+      return `${indexStr} ${branchStr}  ${chalk.red(TASK_STATUS_ICONS.FAILED)} ${chalk.red(TASK_STATUS_LABELS.FAILED)}   ${chalk.gray(duration)}  ${chalk.dim(task.path)}`;
+    }
+  }
+}
+
+/**
+ * 渲染汇总行，统计各状态的任务数
+ * 格式: [2/8 运行中, 3/8 已完成, 3/8 排队中]
+ * @param {TaskProgress[]} tasks - 任务列表
+ * @param {number} total - 总任务数
+ * @returns {string} 汇总行字符串
+ */
+export function renderSummaryLine(tasks: TaskProgress[], total: number): string {
+  const running = tasks.filter((t) => t.status === 'running').length;
+  const done = tasks.filter((t) => t.status === 'done').length;
+  const failed = tasks.filter((t) => t.status === 'failed').length;
+  const pending = tasks.filter((t) => t.status === 'pending').length;
+
+  const parts: string[] = [];
+  if (running > 0) parts.push(chalk.cyan(`${running}/${total} ${TASK_STATUS_LABELS.RUNNING}`));
+  if (done > 0) parts.push(chalk.green(`${done}/${total} ${TASK_STATUS_LABELS.DONE}`));
+  if (failed > 0) parts.push(chalk.red(`${failed}/${total} ${TASK_STATUS_LABELS.FAILED}`));
+  if (pending > 0) parts.push(chalk.gray(`${pending}/${total} ${TASK_STATUS_LABELS.PENDING}`));
+
+  return `[${parts.join(', ')}]`;
+}

package/src/utils/progress.ts

@@ -0,0 +1,213 @@
+import {
+  SPINNER_FRAMES,
+  SPINNER_INTERVAL_MS,
+  CURSOR_UP,
+  CLEAR_LINE,
+  CURSOR_HIDE,
+  CURSOR_SHOW,
+  MESSAGES,
+} from '../constants/index.js';
+import { formatDuration } from './formatter.js';
+import type { TaskProgress } from './progress-render.js';
+import { getMaxBranchWidth, renderTaskLine, renderSummaryLine } from './progress-render.js';
+
+/**
+ * 任务进度面板渲染器
+ *
+ * 职责：协调任务状态管理与终端渲染
+ * - TTY 模式：使用 ANSI 转义码实现原地多行刷新
+ * - 非 TTY 模式：降级为逐行输出，不使用 ANSI 转义
+ */
+export class ProgressRenderer {
+  /** 所有任务的进度状态 */
+  private tasks: TaskProgress[];
+  /** 总任务数 */
+  private total: number;
+  /** 当前 spinner 帧索引 */
+  private frameIndex: number;
+  /** 定时器引用 */
+  private timer: ReturnType<typeof setInterval> | null;
+  /** 是否为 TTY 环境 */
+  private isTTY: boolean;
+  /** 已渲染的行数（用于回退光标） */
+  private renderedLineCount: number;
+  /** 是否已停止 */
+  private stopped: boolean;
+  /** 是否存在排队任务（启用汇总行渲染） */
+  private hasPendingTasks: boolean;
+
+  /**
+   * 创建进度面板渲染器
+   * @param {string[]} branches - 分支名列表，顺序对应任务列表
+   * @param {string[]} paths - worktree 路径列表，完成/失败后显示
+   * @param {boolean} [allRunning=true] - 是否将所有任务初始化为 running 状态，false 时初始化为 pending
+   */
+  constructor(branches: string[], paths: string[], allRunning: boolean = true) {
+    const now = Date.now();
+    this.total = branches.length;
+    this.frameIndex = 0;
+    this.timer = null;
+    this.isTTY = !!process.stdout.isTTY;
+    this.renderedLineCount = 0;
+    this.stopped = false;
+    this.hasPendingTasks = !allRunning;
+
+    this.tasks = branches.map((branch, i) => ({
+      index: i + 1,
+      branch,
+      path: paths[i],
+      status: allRunning ? 'running' : 'pending',
+      startedAt: allRunning ? now : 0,
+      finishedAt: null,
+      lastActiveAt: allRunning ? now : 0,
+      durationMs: null,
+      costUsd: null,
+    }));
+  }
+
+  /**
+   * 启动定时渲染循环
+   * TTY 模式下每 SPINNER_INTERVAL_MS 毫秒刷新一次面板
+   * 非 TTY 模式下输出状态为 running 的任务的启动信息
+   */
+  start(): void {
+    if (this.stopped) return;
+
+    if (!this.isTTY) {
+      // 非 TTY 降级：仅输出已为 running 的任务的启动信息
+      for (const task of this.tasks) {
+        if (task.status === 'running') {
+          console.log(MESSAGES.PROGRESS_TASK_STARTED(task.index, this.total, task.branch, task.path));
+        }
+      }
+      return;
+    }
+
+    // TTY 模式：隐藏光标，启动定时刷新
+    process.stdout.write(CURSOR_HIDE);
+    this.render();
+    this.timer = setInterval(() => {
+      this.frameIndex = (this.frameIndex + 1) % SPINNER_FRAMES.length;
+      this.render();
+    }, SPINNER_INTERVAL_MS);
+
+    // 确保定时器不阻止进程退出
+    if (this.timer.unref) {
+      this.timer.unref();
+    }
+  }
+
+  /**
+   * 更新指定任务的最后活动时间戳
+   * 当 child.stderr 有输出时调用，表示任务仍然活跃
+   * @param {number} index - 任务索引（从 0 开始）
+   */
+  updateActivity(index: number): void {
+    this.tasks[index].lastActiveAt = Date.now();
+  }
+
+  /**
+   * 标记指定任务为运行中状态
+   * 将 pending 任务标记为 running 并设置启动时间戳
+   * @param {number} index - 任务索引（从 0 开始）
+   */
+  markRunning(index: number): void {
+    const task = this.tasks[index];
+    const now = Date.now();
+    task.status = 'running';
+    task.startedAt = now;
+    task.lastActiveAt = now;
+
+    if (!this.isTTY) {
+      // 非 TTY 降级：输出启动信息
+      console.log(MESSAGES.PROGRESS_TASK_STARTED(task.index, this.total, task.branch, task.path));
+    }
+  }
+
+  /**
+   * 标记指定任务为完成状态
+   * @param {number} index - 任务索引（从 0 开始）
+   * @param {number} durationMs - 耗时（毫秒）
+   * @param {number} costUsd - 费用（美元）
+   */
+  markDone(index: number, durationMs: number, costUsd: number): void {
+    const task = this.tasks[index];
+    task.status = 'done';
+    task.finishedAt = Date.now();
+    task.durationMs = durationMs;
+    task.costUsd = costUsd;
+
+    if (!this.isTTY) {
+      // 非 TTY 降级：直接输出完成信息
+      const duration = formatDuration(durationMs);
+      const cost = `$${costUsd.toFixed(2)}`;
+      console.log(MESSAGES.PROGRESS_TASK_DONE(task.index, this.total, task.branch, duration, cost, task.path));
+    }
+  }
+
+  /**
+   * 标记指定任务为失败状态
+   * @param {number} index - 任务索引（从 0 开始）
+   * @param {number} durationMs - 耗时（毫秒）
+   */
+  markFailed(index: number, durationMs: number): void {
+    const task = this.tasks[index];
+    task.status = 'failed';
+    task.finishedAt = Date.now();
+    task.durationMs = durationMs;
+
+    if (!this.isTTY) {
+      // 非 TTY 降级：直接输出失败信息
+      const duration = formatDuration(durationMs);
+      console.log(MESSAGES.PROGRESS_TASK_FAILED(task.index, this.total, task.branch, duration, task.path));
+    }
+  }
+
+  /**
+   * 停止渲染循环并恢复光标
+   * 在所有任务完成或 SIGINT 中断时调用
+   */
+  stop(): void {
+    if (this.stopped) return;
+    this.stopped = true;
+
+    if (this.timer) {
+      clearInterval(this.timer);
+      this.timer = null;
+    }
+
+    if (this.isTTY) {
+      // 最后渲染一次，确保最终状态显示正确
+      this.render();
+      // 恢复光标显示
+      process.stdout.write(CURSOR_SHOW);
+    }
+  }
+
+  /**
+   * 执行一次完整的面板渲染
+   * 先回退光标到面板起始位置，再逐行输出
+   */
+  private render(): void {
+    const maxBranchWidth = getMaxBranchWidth(this.tasks);
+    const spinnerChar = SPINNER_FRAMES[this.frameIndex];
+    const lines = this.tasks.map((task) => renderTaskLine(task, this.total, maxBranchWidth, spinnerChar));
+
+    // 存在排队任务时追加汇总行
+    if (this.hasPendingTasks) {
+      lines.push(renderSummaryLine(this.tasks, this.total));
+    }
+
+    // 回退光标到面板起始位置
+    if (this.renderedLineCount > 0) {
+      process.stdout.write(CURSOR_UP(this.renderedLineCount));
+    }
+
+    // 逐行输出，每行末尾清除残留字符
+    for (const line of lines) {
+      process.stdout.write(`${line}${CLEAR_LINE}\n`);
+    }
+
+    this.renderedLineCount = lines.length;
+  }
+}

package/src/utils/task-executor.ts

@@ -0,0 +1,365 @@
+import type { ChildProcess } from 'node:child_process';
+import { logger } from '../logger/index.js';
+import { MESSAGES } from '../constants/index.js';
+import type { ClaudeCodeResult, TaskResult, TaskSummary, WorktreeInfo } from '../types/index.js';
+import { spawnProcess, killAllChildProcesses } from './shell.js';
+import { cleanupWorktrees } from './worktree.js';
+import { getConfigValue } from './config.js';
+import { printSuccess, printWarning, printInfo, printDoubleSeparator, confirmAction } from './formatter.js';
+import { ProgressRenderer } from './progress.js';
+
+/** executeClaudeTask 的返回结构，包含子进程引用和结果 Promise */
+interface ClaudeTaskHandle {
+  /** 子进程实例，用于在中断时终止 */
+  child: ChildProcess;
+  /** 任务结果 Promise */
+  promise: Promise<TaskResult>;
+}
+
+/**
+ * 在指定 worktree 中执行 Claude Code 任务，由于是--output-format json形式，所以这里固定claude code cli的启动命令
+ * @param {WorktreeInfo} worktree - worktree 信息
+ * @param {string} task - 任务描述
+ * @returns {ClaudeTaskHandle} 包含子进程引用和结果 Promise
+ */
+function executeClaudeTask(worktree: WorktreeInfo, task: string): ClaudeTaskHandle {
+  const child = spawnProcess(
+    'claude',
+    ['-p', task, '--output-format', 'json', '--permission-mode', 'bypassPermissions'],
+    {
+      cwd: worktree.path,
+      // stdin 必须设置为 'ignore'，不能用 'pipe'
+      // 原因：claude -p 是非交互模式，不需要 stdin 输入。如果 stdin 为 'pipe'，
+      // 父进程会创建一个可写流连接到子进程但从不写入也不关闭，
+      // claude 检测到 stdin 是管道后会尝试读取输入，导致进程永远卡住
+      stdio: ['ignore', 'pipe', 'pipe'],
+    },
+  );
+
+  const promise = new Promise<TaskResult>((resolve) => {
+    let stdout = '';
+    let stderr = '';
+
+    child.stdout?.on('data', (data: Buffer) => {
+      stdout += data.toString();
+    });
+
+    child.stderr?.on('data', (data: Buffer) => {
+      stderr += data.toString();
+    });
+
+    child.on('close', (code) => {
+      let result: ClaudeCodeResult | null = null;
+      let success = code === 0;
+
+      try {
+        if (stdout.trim()) {
+          result = JSON.parse(stdout.trim()) as ClaudeCodeResult;
+          success = !result.is_error;
+        }
+      } catch {
+        logger.warn(`解析 Claude Code 输出失败: ${stdout.substring(0, 200)}`);
+      }
+
+      resolve({
+        task,
+        branch: worktree.branch,
+        worktreePath: worktree.path,
+        success,
+        result,
+        error: success ? undefined : stderr || '任务执行失败',
+      });
+    });
+
+    child.on('error', (err) => {
+      resolve({
+        task,
+        branch: worktree.branch,
+        worktreePath: worktree.path,
+        success: false,
+        result: null,
+        error: err.message,
+      });
+    });
+  });
+
+  return { child, promise };
+}
+
+/**
+ * 输出所有任务的汇总信息
+ * @param {TaskSummary} summary - 汇总信息
+ */
+function printTaskSummary(summary: TaskSummary): void {
+  printDoubleSeparator();
+  printInfo(`全部任务已完成 (${summary.total}/${summary.total})`);
+  printInfo(`  成功: ${summary.succeeded}`);
+  printInfo(`  失败: ${summary.failed}`);
+  printInfo(`  总耗时: ${(summary.totalDurationMs / 1000).toFixed(1)}s`);
+  printInfo(`  总花费: $${summary.totalCostUsd.toFixed(2)}`);
+  printDoubleSeparator();
+}
+
+/**
+ * 处理用户中断（Ctrl+C）后的清理流程
+ * 根据全局配置决定自动清理或交互式确认
+ * @param {WorktreeInfo[]} worktrees - 本次创建的 worktree 列表
+ */
+async function handleInterruptCleanup(worktrees: WorktreeInfo[]): Promise<void> {
+  const autoDelete = getConfigValue('autoDeleteBranch');
+
+  if (autoDelete) {
+    // 全局配置了自动删除，直接清理
+    cleanupWorktrees(worktrees);
+    printSuccess(MESSAGES.INTERRUPT_AUTO_CLEANED(worktrees.length));
+    return;
+  }
+
+  // 交互式确认是否清理
+  const shouldClean = await confirmAction(MESSAGES.INTERRUPT_CONFIRM_CLEANUP);
+
+  if (shouldClean) {
+    cleanupWorktrees(worktrees);
+    printSuccess(MESSAGES.INTERRUPT_CLEANED(worktrees.length));
+  } else {
+    printInfo(MESSAGES.INTERRUPT_KEPT);
+  }
+}
+
+/**
+ * 更新进度面板中指定任务的完成/失败状态
+ * @param {ProgressRenderer} renderer - 进度面板渲染器
+ * @param {number} index - 任务索引（从 0 开始）
+ * @param {TaskResult} result - 任务执行结果
+ * @param {number} startTime - 任务批次启动时间戳
+ */
+function updateRendererStatus(renderer: ProgressRenderer, index: number, result: TaskResult, startTime: number): void {
+  if (result.success) {
+    renderer.markDone(
+      index,
+      result.result?.duration_ms ?? (Date.now() - startTime),
+      result.result?.total_cost_usd ?? 0,
+    );
+  } else {
+    renderer.markFailed(
+      index,
+      result.result?.duration_ms ?? (Date.now() - startTime),
+    );
+  }
+}
+
+/**
+ * 以并发限制模式执行任务队列
+ * 维护活跃任务池，某个任务完成后立即启动队列中下一个
+ * @param {WorktreeInfo[]} worktrees - worktree 列表
+ * @param {string[]} tasks - 任务描述列表
+ * @param {number} concurrency - 最大并发数
+ * @param {ProgressRenderer} renderer - 进度面板渲染器
+ * @param {number} startTime - 任务批次启动时间戳
+ * @param {() => boolean} isInterrupted - 检查是否已中断的函数
+ * @param {ChildProcess[]} childProcesses - 共享子进程数组，执行过程中动态追加
+ * @returns {Promise<TaskResult[]>} 所有任务结果
+ */
+async function executeWithConcurrency(
+  worktrees: WorktreeInfo[],
+  tasks: string[],
+  concurrency: number,
+  renderer: ProgressRenderer,
+  startTime: number,
+  isInterrupted: () => boolean,
+  childProcesses: ChildProcess[],
+): Promise<TaskResult[]> {
+  const total = tasks.length;
+  const results: TaskResult[] = new Array(total);
+  let nextIndex = 0;
+  let completedCount = 0;
+
+  return new Promise((resolve) => {
+    /**
+     * 启动下一个排队中的任务
+     * 从队列中取出任务并启动执行，完成时递归调用自身
+     */
+    function launchNext(): void {
+      if (nextIndex >= total || isInterrupted()) return;
+
+      const index = nextIndex;
+      nextIndex++;
+
+      const wt = worktrees[index];
+      const task = tasks[index];
+      logger.info(`启动任务 ${index + 1}: ${task} (worktree: ${wt.path})`);
+
+      // 标记为运行中
+      renderer.markRunning(index);
+
+      const handle = executeClaudeTask(wt, task);
+      childProcesses.push(handle.child);
+
+      // 监听 stderr 输出，更新任务活动时间戳
+      handle.child.stderr?.on('data', () => {
+        renderer.updateActivity(index);
+      });
+
+      handle.promise.then((result) => {
+        results[index] = result;
+        completedCount++;
+
+        // 被中断时不再更新面板
+        if (!isInterrupted()) {
+          updateRendererStatus(renderer, index, result, startTime);
+        }
+
+        // 启动下一个排队任务
+        launchNext();
+
+        // 所有任务完成时 resolve
+        if (completedCount === total) {
+          resolve(results);
+        }
+      });
+    }
+
+    // 初始启动 concurrency 个任务
+    const initialBatch = Math.min(concurrency, total);
+    for (let i = 0; i < initialBatch; i++) {
+      launchNext();
+    }
+  });
+}
+
+/**
+ * 以全量并行模式执行所有任务
+ * @param {WorktreeInfo[]} worktrees - worktree 列表
+ * @param {string[]} tasks - 任务描述列表
+ * @param {ProgressRenderer} renderer - 进度面板渲染器
+ * @param {number} startTime - 任务批次启动时间戳
+ * @param {() => boolean} isInterrupted - 检查是否已中断的函数
+ * @param {ChildProcess[]} childProcesses - 共享子进程数组，启动时追加
+ * @returns {Promise<TaskResult[]>} 所有任务结果
+ */
+async function executeAllParallel(
+  worktrees: WorktreeInfo[],
+  tasks: string[],
+  renderer: ProgressRenderer,
+  startTime: number,
+  isInterrupted: () => boolean,
+  childProcesses: ChildProcess[],
+): Promise<TaskResult[]> {
+  const handles = worktrees.map((wt, index) => {
+    const task = tasks[index];
+    logger.info(`启动任务 ${index + 1}: ${task} (worktree: ${wt.path})`);
+    const handle = executeClaudeTask(wt, task);
+    childProcesses.push(handle.child);
+
+    // 监听 stderr 输出，更新任务活动时间戳
+    handle.child.stderr?.on('data', () => {
+      renderer.updateActivity(index);
+    });
+
+    return handle;
+  });
+
+  const results = await Promise.all(
+    handles.map((handle, index) =>
+      handle.promise.then((result) => {
+        // 被中断时不再更新面板
+        if (!isInterrupted()) {
+          updateRendererStatus(renderer, index, result, startTime);
+        }
+        return result;
+      }),
+    ),
+  );
+
+  return results;
+}
+
+/**
+ * 批量任务执行的公共逻辑
+ * 负责进度面板、SIGINT 处理、并发控制、汇总输出
+ * @param {WorktreeInfo[]} worktrees - worktree 列表
+ * @param {string[]} tasks - 任务描述列表
+ * @param {number} concurrency - 最大并发数，0 表示不限制
+ */
+export async function executeBatchTasks(
+  worktrees: WorktreeInfo[],
+  tasks: string[],
+  concurrency: number,
+): Promise<void> {
+  const count = tasks.length;
+
+  // 有并发限制时输出提示
+  if (concurrency > 0) {
+    printInfo(MESSAGES.CONCURRENCY_INFO(concurrency, count));
+    printInfo('');
+  }
+
+  // 实例化进度面板渲染器
+  const startTime = Date.now();
+  const branches = worktrees.map((wt) => wt.branch);
+  const paths = worktrees.map((wt) => wt.path);
+  // 有并发限制时任务初始化为 pending 状态，否则初始化为 running
+  const allRunning = concurrency === 0;
+  const renderer = new ProgressRenderer(branches, paths, allRunning);
+
+  // 启动进度面板渲染
+  renderer.start();
+
+  // 共享中断状态标志和子进程引用数组
+  let interrupted = false;
+  const isInterrupted = () => interrupted;
+  const childProcesses: ChildProcess[] = [];
+
+  // 监听 SIGINT（Ctrl+C），终止所有子进程并触发清理流程
+  const sigintHandler = async () => {
+    if (interrupted) return;
+    interrupted = true;
+
+    // 停止进度面板渲染
+    renderer.stop();
+
+    printInfo('');
+    printWarning(MESSAGES.INTERRUPTED);
+    killAllChildProcesses(childProcesses);
+
+    // 等待所有已启动的子进程退出后再执行清理
+    await Promise.allSettled(childProcesses.map((cp) =>
+      new Promise<void>((resolve) => {
+        if (cp.exitCode !== null) {
+          resolve();
+        } else {
+          cp.on('close', () => resolve());
+        }
+      }),
+    ));
+
+    await handleInterruptCleanup(worktrees);
+    process.exit(1);
+  };
+  process.on('SIGINT', sigintHandler);
+
+  // 根据并发限制选择执行模式
+  const results = concurrency > 0
+    ? await executeWithConcurrency(worktrees, tasks, concurrency, renderer, startTime, isInterrupted, childProcesses)
+    : await executeAllParallel(worktrees, tasks, renderer, startTime, isInterrupted, childProcesses);
+
+  // 正常完成，停止进度面板并移除 SIGINT 监听器
+  renderer.stop();
+  process.removeListener('SIGINT', sigintHandler);
+
+  // 被中断时不输出汇总（已在 sigintHandler 中处理退出）
+  if (interrupted) return;
+
+  const totalDurationMs = Date.now() - startTime;
+
+  // 汇总
+  const summary: TaskSummary = {
+    total: results.length,
+    succeeded: results.filter((r) => r.success).length,
+    failed: results.filter((r) => !r.success).length,
+    totalDurationMs,
+    totalCostUsd: results.reduce((sum, r) => sum + (r.result?.total_cost_usd ?? 0), 0),
+  };
+
+  printTaskSummary(summary);
+}