clawt 3.5.3 → 3.6.0

package/dist/index.js

@@ -311,7 +311,17 @@ ${branches.map((b) => `    - ${b}`).join("\n")}`,
   /** 批量 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`
+  RESUME_ALL_NO_MATCH: (keyword) => `\u672A\u627E\u5230\u4E0E "${keyword}" \u5339\u914D\u7684\u5206\u652F`,
+  /** --prompt 必须配合 -b 指定目标分支 */
+  RESUME_PROMPT_REQUIRES_BRANCH: "--prompt \u5FC5\u987B\u914D\u5408 -b \u6307\u5B9A\u76EE\u6807\u5206\u652F",
+  /** --prompt 和 -f 不能同时使用 */
+  RESUME_PROMPT_FILE_CONFLICT: "--prompt \u548C -f \u4E0D\u80FD\u540C\u65F6\u4F7F\u7528",
+  /** 未找到对应 worktree */
+  RESUME_WORKTREE_NOT_FOUND: (branch, available) => `\u672A\u627E\u5230\u5206\u652F "${branch}" \u5BF9\u5E94\u7684 worktree
+  \u53EF\u7528\u5206\u652F\uFF1A
+${available.map((b) => `    - ${b}`).join("\n")}`,
+  /** 追问文件加载完成 */
+  RESUME_FOLLOW_UP_FILE_LOADED: (count, path2) => `\u4ECE ${path2} \u52A0\u8F7D\u4E86 ${count} \u4E2A\u8FFD\u95EE\u4EFB\u52A1`
 };
 
 // src/constants/messages/remove.ts
@@ -2762,10 +2772,14 @@ function parseStreamEvent(event) {
 }
 
 // src/utils/task-executor.ts
-function executeClaudeTask(worktree, task, onActivity) {
+function executeClaudeTask(worktree, task, onActivity, continueSession) {
+  const args = ["-p", task, "--output-format", "stream-json", "--verbose", "--permission-mode", "bypassPermissions"];
+  if (continueSession) {
+    args.push("--continue");
+  }
   const child = spawnProcess(
     "claude",
-    ["-p", task, "--output-format", "stream-json", "--verbose", "--permission-mode", "bypassPermissions"],
+    args,
     {
       cwd: worktree.path,
       // stdin 必须设置为 'ignore'，不能用 'pipe'
@@ -2875,7 +2889,7 @@ function updateRendererStatus(renderer, index, result, startTime) {
     );
   }
 }
-async function executeWithConcurrency(worktrees, tasks, concurrency, renderer, startTime, isInterrupted, childProcesses) {
+async function executeWithConcurrency(worktrees, tasks, concurrency, renderer, startTime, isInterrupted, childProcesses, continueFlags) {
   const total = tasks.length;
   const results = new Array(total);
   let nextIndex = 0;
@@ -2891,7 +2905,7 @@ async function executeWithConcurrency(worktrees, tasks, concurrency, renderer, s
       renderer.markRunning(index);
       const handle = executeClaudeTask(wt, task, (activityText) => {
         renderer.updateActivityText(index, activityText);
-      });
+      }, continueFlags?.[index]);
       childProcesses.push(handle.child);
       handle.promise.then((result) => {
         results[index] = result;
@@ -2911,13 +2925,13 @@ async function executeWithConcurrency(worktrees, tasks, concurrency, renderer, s
     }
   });
 }
-async function executeAllParallel(worktrees, tasks, renderer, startTime, isInterrupted, childProcesses) {
+async function executeAllParallel(worktrees, tasks, renderer, startTime, isInterrupted, childProcesses, continueFlags) {
   const handles = worktrees.map((wt, index) => {
     const task = tasks[index];
     logger.info(`\u542F\u52A8\u4EFB\u52A1 ${index + 1}: ${task} (worktree: ${wt.path})`);
     const handle = executeClaudeTask(wt, task, (activityText) => {
       renderer.updateActivityText(index, activityText);
-    });
+    }, continueFlags?.[index]);
     childProcesses.push(handle.child);
     return handle;
   });
@@ -2933,8 +2947,13 @@ async function executeAllParallel(worktrees, tasks, renderer, startTime, isInter
   );
   return results;
 }
-async function executeBatchTasks(worktrees, tasks, concurrency) {
+async function executeBatchTasks(worktrees, tasks, concurrency, continueFlags) {
   const count = tasks.length;
+  if (continueFlags && continueFlags.length !== count) {
+    throw new ClawtError(
+      `continueFlags \u957F\u5EA6 (${continueFlags.length}) \u4E0E\u4EFB\u52A1\u6570 (${count}) \u4E0D\u4E00\u81F4`
+    );
+  }
   if (concurrency > 0) {
     printInfo(MESSAGES.CONCURRENCY_INFO(concurrency, count));
     printInfo("");
@@ -2968,10 +2987,10 @@ async function executeBatchTasks(worktrees, tasks, concurrency) {
     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);
+  const results = concurrency > 0 ? await executeWithConcurrency(worktrees, tasks, concurrency, renderer, startTime, isInterrupted, childProcesses, continueFlags) : await executeAllParallel(worktrees, tasks, renderer, startTime, isInterrupted, childProcesses, continueFlags);
   renderer.stop();
   process.removeListener("SIGINT", sigintHandler);
-  if (interrupted) return;
+  if (interrupted) return [];
   const totalDurationMs = Date.now() - startTime;
   const summary = {
     total: results.length,
@@ -2981,6 +3000,7 @@ async function executeBatchTasks(worktrees, tasks, concurrency) {
     totalCostUsd: results.reduce((sum, r) => sum + (r.result?.total_cost_usd ?? 0), 0)
   };
   printTaskSummary(summary);
+  return results;
 }
 
 // src/utils/dry-run.ts
@@ -4439,12 +4459,26 @@ var RESUME_RESOLVE_MESSAGES = {
   noMatch: MESSAGES.RESUME_NO_MATCH
 };
 function registerResumeCommand(program2) {
-  program2.command("resume").description("\u5728\u5DF2\u6709 worktree \u4E2D\u6062\u590D Claude Code \u4F1A\u8BDD\uFF08\u652F\u6301\u591A\u9009\u6279\u91CF\u6062\u590D\uFF09").option("-b, --branch <branchName>", "\u8981\u6062\u590D\u7684\u5206\u652F\u540D\uFF08\u652F\u6301\u6A21\u7CCA\u5339\u914D\uFF0C\u4E0D\u4F20\u5219\u5217\u51FA\u6240\u6709\u5206\u652F\uFF09").action(async (options) => {
+  program2.command("resume").description("\u5728\u5DF2\u6709 worktree \u4E2D\u6062\u590D Claude Code \u4F1A\u8BDD\uFF08\u652F\u6301\u591A\u9009\u6279\u91CF\u6062\u590D\uFF09").option("-b, --branch <branchName>", "\u8981\u6062\u590D\u7684\u5206\u652F\u540D\uFF08\u652F\u6301\u6A21\u7CCA\u5339\u914D\uFF0C\u4E0D\u4F20\u5219\u5217\u51FA\u6240\u6709\u5206\u652F\uFF09").option("--prompt <content>", "\u975E\u4EA4\u4E92\u5F0F\u8FFD\u95EE\uFF08\u9700\u914D\u5408 -b \u6307\u5B9A\u5206\u652F\uFF09").option("-f, --file <path>", "\u4ECE\u4EFB\u52A1\u6587\u4EF6\u6279\u91CF\u8FFD\u95EE\uFF08\u901A\u8FC7 branch \u540D\u5339\u914D\u5DF2\u6709 worktree\uFF09").option("-c, --concurrency <n>", "\u6279\u91CF\u8FFD\u95EE\u6700\u5927\u5E76\u53D1\u6570\uFF0C0 \u8868\u793A\u4E0D\u9650\u5236").action(async (options) => {
     await handleResume(options);
   });
 }
 async function handleResume(options) {
   await runPreChecks(PRE_CHECK_RESUME);
+  if (options.prompt && options.file) {
+    throw new ClawtError(MESSAGES.RESUME_PROMPT_FILE_CONFLICT);
+  }
+  if (options.prompt) {
+    if (!options.branch) {
+      throw new ClawtError(MESSAGES.RESUME_PROMPT_REQUIRES_BRANCH);
+    }
+    const worktrees2 = getProjectWorktrees();
+    const worktree = resolveWorktreeByBranch(options.branch, worktrees2);
+    return handleNonInteractiveSingleResume(worktree, options.prompt);
+  }
+  if (options.file) {
+    return handleNonInteractiveBatchResume(options.file, options);
+  }
   logger.info(`resume \u547D\u4EE4\u6267\u884C\uFF0C\u5206\u652F\u8FC7\u6EE4: ${options.branch ?? "(\u65E0)"}`);
   const worktrees = getProjectWorktrees();
   let targetWorktrees;
@@ -4468,6 +4502,35 @@ async function handleResume(options) {
     await handleBatchResume(targetWorktrees);
   }
 }
+function resolveWorktreeByBranch(branch, worktrees) {
+  const match = findExactMatch(worktrees, branch);
+  if (!match) {
+    const available = worktrees.map((wt) => wt.branch);
+    throw new ClawtError(MESSAGES.RESUME_WORKTREE_NOT_FOUND(branch, available));
+  }
+  return match;
+}
+async function handleNonInteractiveSingleResume(worktree, prompt) {
+  const hasPrevious = hasClaudeSessionHistory(worktree.path);
+  await executeBatchTasks([worktree], [prompt], 0, [hasPrevious]);
+}
+async function handleNonInteractiveBatchResume(filePath, options) {
+  const entries = loadTaskFile(filePath, { branchRequired: true });
+  printSuccess(MESSAGES.RESUME_FOLLOW_UP_FILE_LOADED(entries.length, filePath));
+  const allWorktrees = getProjectWorktrees();
+  const worktrees = [];
+  const tasks = [];
+  const continueFlags = [];
+  for (const entry of entries) {
+    const worktree = resolveWorktreeByBranch(entry.branch, allWorktrees);
+    worktrees.push(worktree);
+    tasks.push(entry.task);
+    continueFlags.push(hasClaudeSessionHistory(worktree.path));
+  }
+  const concurrency = parseConcurrency(options.concurrency, getConfigValue("maxConcurrency"));
+  logger.info(`resume \u547D\u4EE4\uFF08\u6279\u91CF\u8FFD\u95EE\u6A21\u5F0F\uFF09\u6267\u884C\uFF0C\u4EFB\u52A1\u6570: ${entries.length}\uFF0C\u5E76\u53D1\u6570: ${concurrency || "\u4E0D\u9650\u5236"}`);
+  await executeBatchTasks(worktrees, tasks, concurrency, continueFlags);
+}
 function printBatchResumePreview(worktrees, sessionMap) {
   printInfo("\u5373\u5C06\u6062\u590D\u7684\u5206\u652F\uFF1A");
   for (const wt of worktrees) {

package/dist/postinstall.js

@@ -302,7 +302,17 @@ ${branches.map((b) => `    - ${b}`).join("\n")}`,
   /** 批量 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`
+  RESUME_ALL_NO_MATCH: (keyword) => `\u672A\u627E\u5230\u4E0E "${keyword}" \u5339\u914D\u7684\u5206\u652F`,
+  /** --prompt 必须配合 -b 指定目标分支 */
+  RESUME_PROMPT_REQUIRES_BRANCH: "--prompt \u5FC5\u987B\u914D\u5408 -b \u6307\u5B9A\u76EE\u6807\u5206\u652F",
+  /** --prompt 和 -f 不能同时使用 */
+  RESUME_PROMPT_FILE_CONFLICT: "--prompt \u548C -f \u4E0D\u80FD\u540C\u65F6\u4F7F\u7528",
+  /** 未找到对应 worktree */
+  RESUME_WORKTREE_NOT_FOUND: (branch, available) => `\u672A\u627E\u5230\u5206\u652F "${branch}" \u5BF9\u5E94\u7684 worktree
+  \u53EF\u7528\u5206\u652F\uFF1A
+${available.map((b) => `    - ${b}`).join("\n")}`,
+  /** 追问文件加载完成 */
+  RESUME_FOLLOW_UP_FILE_LOADED: (count, path) => `\u4ECE ${path} \u52A0\u8F7D\u4E86 ${count} \u4E2A\u8FFD\u95EE\u4EFB\u52A1`
 };
 
 // src/constants/messages/remove.ts

package/package.json

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

package/src/commands/resume.ts

@@ -1,5 +1,6 @@
 import type { Command } from 'commander';
 import { logger } from '../logger/index.js';
+import { ClawtError } from '../errors/index.js';
 import { MESSAGES } from '../constants/index.js';
 import type { ResumeOptions } from '../types/index.js';
 import type { WorktreeInfo } from '../types/index.js';
@@ -12,10 +13,14 @@ import {
   hasClaudeSessionHistory,
   resolveTargetWorktrees,
   promptGroupedMultiSelectBranches,
+  findExactMatch,
   printInfo,
   printSuccess,
   confirmAction,
   getConfigValue,
+  parseConcurrency,
+  loadTaskFile,
+  executeBatchTasks,
 } from '../utils/index.js';
 import type { WorktreeMultiResolveMessages } from '../utils/index.js';
 
@@ -36,6 +41,9 @@ export function registerResumeCommand(program: Command): void {
     .command('resume')
     .description('在已有 worktree 中恢复 Claude Code 会话（支持多选批量恢复）')
     .option('-b, --branch <branchName>', '要恢复的分支名（支持模糊匹配，不传则列出所有分支）')
+    .option('--prompt <content>', '非交互式追问（需配合 -b 指定分支）')
+    .option('-f, --file <path>', '从任务文件批量追问（通过 branch 名匹配已有 worktree）')
+    .option('-c, --concurrency <n>', '批量追问最大并发数，0 表示不限制')
     .action(async (options: ResumeOptions) => {
       await handleResume(options);
     });
@@ -49,6 +57,25 @@ export function registerResumeCommand(program: Command): void {
 async function handleResume(options: ResumeOptions): Promise<void> {
   await runPreChecks(PRE_CHECK_RESUME);
 
+  // 非交互式追问逻辑分支
+  if (options.prompt && options.file) {
+    throw new ClawtError(MESSAGES.RESUME_PROMPT_FILE_CONFLICT);
+  }
+
+  if (options.prompt) {
+    if (!options.branch) {
+      throw new ClawtError(MESSAGES.RESUME_PROMPT_REQUIRES_BRANCH);
+    }
+    const worktrees = getProjectWorktrees();
+    const worktree = resolveWorktreeByBranch(options.branch, worktrees);
+    return handleNonInteractiveSingleResume(worktree, options.prompt);
+  }
+
+  if (options.file) {
+    return handleNonInteractiveBatchResume(options.file, options);
+  }
+
+  // 原有交互式逻辑
   logger.info(`resume 命令执行，分支过滤: ${options.branch ?? '(无)'}`);
   const worktrees = getProjectWorktrees();
 
@@ -82,6 +109,70 @@ async function handleResume(options: ResumeOptions): Promise<void> {
   }
 }
 
+/**
+ * 精确匹配分支对应的 worktree
+ * 找不到时抛出包含可用分支列表的错误
+ * @param {string} branch - 目标分支名
+ * @param {WorktreeInfo[]} worktrees - 可用的 worktree 列表
+ * @returns {WorktreeInfo} 匹配的 worktree
+ * @throws {ClawtError} 未找到匹配分支时抛出
+ */
+function resolveWorktreeByBranch(branch: string, worktrees: WorktreeInfo[]): WorktreeInfo {
+  const match = findExactMatch(worktrees, branch);
+  if (!match) {
+    const available = worktrees.map((wt) => wt.branch);
+    throw new ClawtError(MESSAGES.RESUME_WORKTREE_NOT_FOUND(branch, available));
+  }
+  return match;
+}
+
+/**
+ * 非交互式单分支追问
+ * 检查 worktree 是否有历史会话，有则通过 --continue 继续最新会话
+ * @param {WorktreeInfo} worktree - 目标 worktree
+ * @param {string} prompt - 追问内容
+ */
+async function handleNonInteractiveSingleResume(worktree: WorktreeInfo, prompt: string): Promise<void> {
+  // 检查是否有历史会话，有则追加 --continue
+  const hasPrevious = hasClaudeSessionHistory(worktree.path);
+  await executeBatchTasks([worktree], [prompt], 0, [hasPrevious]);
+}
+
+/**
+ * 非交互式批量追问
+ * 从任务文件解析追问内容，按 branch 名精确匹配已有 worktree，批量执行
+ * @param {string} filePath - 追问任务文件路径
+ * @param {ResumeOptions} options - 命令选项（含并发数配置）
+ */
+async function handleNonInteractiveBatchResume(filePath: string, options: ResumeOptions): Promise<void> {
+  // 解析追问文件，branch 为必填字段
+  const entries = loadTaskFile(filePath, { branchRequired: true });
+  printSuccess(MESSAGES.RESUME_FOLLOW_UP_FILE_LOADED(entries.length, filePath));
+
+  // 获取所有已有 worktree
+  const allWorktrees = getProjectWorktrees();
+
+  // 按 branch 名精确匹配 worktree，构建执行参数
+  const worktrees: WorktreeInfo[] = [];
+  const tasks: string[] = [];
+  const continueFlags: boolean[] = [];
+
+  for (const entry of entries) {
+    const worktree = resolveWorktreeByBranch(entry.branch!, allWorktrees);
+    worktrees.push(worktree);
+    tasks.push(entry.task);
+    // 按 worktree 独立检查是否有历史会话
+    continueFlags.push(hasClaudeSessionHistory(worktree.path));
+  }
+
+  // 解析并发数
+  const concurrency = parseConcurrency(options.concurrency, getConfigValue('maxConcurrency'));
+
+  logger.info(`resume 命令（批量追问模式）执行，任务数: ${entries.length}，并发数: ${concurrency || '不限制'}`);
+
+  await executeBatchTasks(worktrees, tasks, concurrency, continueFlags);
+}
+
 /**
  * 输出即将恢复的分支列表（含会话状态：继续/新对话）
  * @param {WorktreeInfo[]} worktrees - 待恢复的 worktree 列表

package/src/constants/messages/resume.ts

@@ -18,4 +18,14 @@ export const RESUME_MESSAGES = {
   RESUME_ALL_PLATFORM_UNSUPPORTED: '批量 resume 目前仅支持 macOS 平台（通过 AppleScript 打开终端 Tab）',
   /** 批量 resume 无匹配分支提示 */
   RESUME_ALL_NO_MATCH: (keyword: string) => `未找到与 "${keyword}" 匹配的分支`,
+
+  /** --prompt 必须配合 -b 指定目标分支 */
+  RESUME_PROMPT_REQUIRES_BRANCH: '--prompt 必须配合 -b 指定目标分支',
+  /** --prompt 和 -f 不能同时使用 */
+  RESUME_PROMPT_FILE_CONFLICT: '--prompt 和 -f 不能同时使用',
+  /** 未找到对应 worktree */
+  RESUME_WORKTREE_NOT_FOUND: (branch: string, available: string[]) =>
+    `未找到分支 "${branch}" 对应的 worktree\n  可用分支：\n${available.map((b) => `    - ${b}`).join('\n')}`,
+  /** 追问文件加载完成 */
+  RESUME_FOLLOW_UP_FILE_LOADED: (count: number, path: string) => `从 ${path} 加载了 ${count} 个追问任务`,
 } as const;

package/src/types/command.ts

@@ -52,6 +52,12 @@ export interface RemoveOptions {
 export interface ResumeOptions {
   /** 要恢复的分支名（可选，不传则列出所有分支供选择） */
   branch?: string;
+  /** 非交互式追问内容（需配合 -b 指定分支） */
+  prompt?: string;
+  /** 从任务文件批量追问（通过 branch 名匹配已有 worktree） */
+  file?: string;
+  /** 批量追问最大并发数，0 表示不限制（Commander 传入为字符串） */
+  concurrency?: string;
 }
 
 /** sync 命令选项 */

package/src/utils/task-executor.ts

@@ -9,6 +9,7 @@ import { printSuccess, printWarning, printInfo, printDoubleSeparator, confirmAct
 import { ProgressRenderer } from './progress.js';
 import { createLineBuffer, parseStreamLine, parseStreamEvent, truncateText } from './stream-parser.js';
 import { RESULT_PREVIEW_MAX_LENGTH } from '../constants/index.js';
+import { ClawtError } from '../errors/index.js';
 
 /** executeClaudeTask 的返回结构，包含子进程引用和结果 Promise */
 interface ClaudeTaskHandle {
@@ -29,13 +30,21 @@ type ActivityCallback = (activityText: string) => void;
  * @param {WorktreeInfo} worktree - worktree 信息
  * @param {string} task - 任务描述
  * @param {ActivityCallback} [onActivity] - 活动更新回调（可选）
+ * @param {boolean} [continueSession] - 是否继续该 worktree 目录下最新的会话
  * @returns {ClaudeTaskHandle} 包含子进程引用和结果 Promise
  */
-function executeClaudeTask(worktree: WorktreeInfo, task: string, onActivity?: ActivityCallback): ClaudeTaskHandle {
+function executeClaudeTask(worktree: WorktreeInfo, task: string, onActivity?: ActivityCallback, continueSession?: boolean): ClaudeTaskHandle {
   // 旧版使用 --output-format json，现改为 stream-json --verbose 以支持实时活动信息
+  const args = ['-p', task, '--output-format', 'stream-json', '--verbose', '--permission-mode', 'bypassPermissions'];
+
+  // 追问模式：追加 --continue 继续该目录下最新会话
+  if (continueSession) {
+    args.push('--continue');
+  }
+
   const child = spawnProcess(
     'claude',
-    ['-p', task, '--output-format', 'stream-json', '--verbose', '--permission-mode', 'bypassPermissions'],
+    args,
     {
       cwd: worktree.path,
       // stdin 必须设置为 'ignore'，不能用 'pipe'
@@ -198,6 +207,7 @@ function updateRendererStatus(renderer: ProgressRenderer, index: number, result:
  * @param {number} startTime - 任务批次启动时间戳
  * @param {() => boolean} isInterrupted - 检查是否已中断的函数
  * @param {ChildProcess[]} childProcesses - 共享子进程数组，执行过程中动态追加
+ * @param {boolean[]} [continueFlags] - 按索引对应每个任务是否继续已有会话（追问模式，追加 --continue）
  * @returns {Promise<TaskResult[]>} 所有任务结果
  */
 async function executeWithConcurrency(
@@ -208,6 +218,7 @@ async function executeWithConcurrency(
   startTime: number,
   isInterrupted: () => boolean,
   childProcesses: ChildProcess[],
+  continueFlags?: boolean[],
 ): Promise<TaskResult[]> {
   const total = tasks.length;
   const results: TaskResult[] = new Array(total);
@@ -234,7 +245,7 @@ async function executeWithConcurrency(
 
       const handle = executeClaudeTask(wt, task, (activityText) => {
         renderer.updateActivityText(index, activityText);
-      });
+      }, continueFlags?.[index]);
       childProcesses.push(handle.child);
 
       handle.promise.then((result) => {
@@ -272,6 +283,7 @@ async function executeWithConcurrency(
  * @param {number} startTime - 任务批次启动时间戳
  * @param {() => boolean} isInterrupted - 检查是否已中断的函数
  * @param {ChildProcess[]} childProcesses - 共享子进程数组，启动时追加
+ * @param {boolean[]} [continueFlags] - 按索引对应每个任务是否继续已有会话（追问模式，追加 --continue）
  * @returns {Promise<TaskResult[]>} 所有任务结果
  */
 async function executeAllParallel(
@@ -281,13 +293,14 @@ async function executeAllParallel(
   startTime: number,
   isInterrupted: () => boolean,
   childProcesses: ChildProcess[],
+  continueFlags?: boolean[],
 ): 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, (activityText) => {
       renderer.updateActivityText(index, activityText);
-    });
+    }, continueFlags?.[index]);
     childProcesses.push(handle.child);
 
     return handle;
@@ -314,14 +327,25 @@ async function executeAllParallel(
  * @param {WorktreeInfo[]} worktrees - worktree 列表
  * @param {string[]} tasks - 任务描述列表
  * @param {number} concurrency - 最大并发数，0 表示不限制
+ * @param {boolean[]} [continueFlags] - 按索引对应每个任务是否继续已有会话（追问模式，追加 --continue）
+ * @returns {Promise<TaskResult[]>} 所有任务的执行结果
+ * @throws {ClawtError} continueFlags 长度与任务数不一致时抛出
  */
 export async function executeBatchTasks(
   worktrees: WorktreeInfo[],
   tasks: string[],
   concurrency: number,
-): Promise<void> {
+  continueFlags?: boolean[],
+): Promise<TaskResult[]> {
   const count = tasks.length;
 
+  // 校验 continueFlags 长度与 worktrees 一致，防止调用方传入不匹配的数组
+  if (continueFlags && continueFlags.length !== count) {
+    throw new ClawtError(
+      `continueFlags 长度 (${continueFlags.length}) 与任务数 (${count}) 不一致`,
+    );
+  }
+
   // 有并发限制时输出提示
   if (concurrency > 0) {
     printInfo(MESSAGES.CONCURRENCY_INFO(concurrency, count));
@@ -374,15 +398,15 @@ export async function executeBatchTasks(
 
   // 根据并发限制选择执行模式
   const results = concurrency > 0
-    ? await executeWithConcurrency(worktrees, tasks, concurrency, renderer, startTime, isInterrupted, childProcesses)
-    : await executeAllParallel(worktrees, tasks, renderer, startTime, isInterrupted, childProcesses);
+    ? await executeWithConcurrency(worktrees, tasks, concurrency, renderer, startTime, isInterrupted, childProcesses, continueFlags)
+    : await executeAllParallel(worktrees, tasks, renderer, startTime, isInterrupted, childProcesses, continueFlags);
 
   // 正常完成，停止进度面板并移除 SIGINT 监听器
   renderer.stop();
   process.removeListener('SIGINT', sigintHandler);
 
   // 被中断时不输出汇总（已在 sigintHandler 中处理退出）
-  if (interrupted) return;
+  if (interrupted) return [];
 
   const totalDurationMs = Date.now() - startTime;
 
@@ -396,4 +420,6 @@ export async function executeBatchTasks(
   };
 
   printTaskSummary(summary);
+
+  return results;
 }

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

@@ -5,6 +5,16 @@ vi.mock('../../../src/logger/index.js', () => ({
   logger: { debug: vi.fn(), info: vi.fn(), warn: vi.fn(), error: vi.fn() },
 }));
 
+vi.mock('../../../src/errors/index.js', () => ({
+  ClawtError: class ClawtError extends Error {
+    exitCode: number;
+    constructor(message: string, exitCode = 1) {
+      super(message);
+      this.exitCode = exitCode;
+    }
+  },
+}));
+
 vi.mock('../../../src/constants/index.js', async (importOriginal) => {
   const actual = await importOriginal<typeof import('../../../src/constants/index.js')>();
   return {
@@ -16,6 +26,11 @@ vi.mock('../../../src/constants/index.js', async (importOriginal) => {
       RESUME_NO_MATCH: (keyword: string, branches: string[]) => `未找到匹配 "${keyword}" 的分支`,
       RESUME_ALL_CONFIRM: (count: number) => `确认恢复 ${count} 个分支？`,
       RESUME_ALL_SUCCESS: (count: number) => `已恢复 ${count} 个分支`,
+      RESUME_PROMPT_REQUIRES_BRANCH: '--prompt 必须配合 -b 指定目标分支',
+      RESUME_PROMPT_FILE_CONFLICT: '--prompt 和 -f 不能同时使用',
+      RESUME_WORKTREE_NOT_FOUND: (branch: string, available: string[]) => `未找到分支 "${branch}" 对应的 worktree`,
+      RESUME_FOLLOW_UP_FILE_LOADED: (count: number, path: string) => `从 ${path} 加载了 ${count} 个追问任务`,
+      CONCURRENCY_INFO: (concurrency: number, total: number) => `并发限制: ${concurrency}，共 ${total} 个任务`,
     },
   };
 });
@@ -29,48 +44,64 @@ vi.mock('../../../src/utils/index.js', () => ({
   hasClaudeSessionHistory: vi.fn(),
   resolveTargetWorktrees: vi.fn(),
   promptGroupedMultiSelectBranches: vi.fn(),
+  findExactMatch: vi.fn(),
   printInfo: vi.fn(),
   printSuccess: vi.fn(),
+  printWarning: vi.fn(),
   confirmAction: vi.fn(),
   getConfigValue: vi.fn(),
+  parseConcurrency: vi.fn().mockReturnValue(0),
+  loadTaskFile: vi.fn(),
+  executeBatchTasks: vi.fn().mockResolvedValue([]),
 }));
 
 import { registerResumeCommand } from '../../../src/commands/resume.js';
 import {
   runPreChecks,
-  validateClaudeCodeInstalled,
   getProjectWorktrees,
   launchInteractiveClaude,
   launchInteractiveClaudeInNewTerminal,
   hasClaudeSessionHistory,
   resolveTargetWorktrees,
   promptGroupedMultiSelectBranches,
+  findExactMatch,
   confirmAction,
   getConfigValue,
+  parseConcurrency,
+  loadTaskFile,
+  executeBatchTasks,
 } from '../../../src/utils/index.js';
 
 const mockedRunPreChecks = vi.mocked(runPreChecks);
-const mockedValidateClaudeCodeInstalled = vi.mocked(validateClaudeCodeInstalled);
 const mockedGetProjectWorktrees = vi.mocked(getProjectWorktrees);
 const mockedLaunchInteractiveClaude = vi.mocked(launchInteractiveClaude);
 const mockedLaunchInteractiveClaudeInNewTerminal = vi.mocked(launchInteractiveClaudeInNewTerminal);
 const mockedHasClaudeSessionHistory = vi.mocked(hasClaudeSessionHistory);
 const mockedResolveTargetWorktrees = vi.mocked(resolveTargetWorktrees);
 const mockedPromptGroupedMultiSelectBranches = vi.mocked(promptGroupedMultiSelectBranches);
+const mockedFindExactMatch = vi.mocked(findExactMatch);
 const mockedConfirmAction = vi.mocked(confirmAction);
 const mockedGetConfigValue = vi.mocked(getConfigValue);
+const mockedParseConcurrency = vi.mocked(parseConcurrency);
+const mockedLoadTaskFile = vi.mocked(loadTaskFile);
+const mockedExecuteBatchTasks = vi.mocked(executeBatchTasks);
 
 beforeEach(() => {
   mockedRunPreChecks.mockReset();
-  mockedValidateClaudeCodeInstalled.mockReset();
   mockedGetProjectWorktrees.mockReset();
   mockedLaunchInteractiveClaude.mockReset();
   mockedLaunchInteractiveClaudeInNewTerminal.mockReset();
   mockedHasClaudeSessionHistory.mockReset();
   mockedResolveTargetWorktrees.mockReset();
   mockedPromptGroupedMultiSelectBranches.mockReset();
+  mockedFindExactMatch.mockReset();
   mockedConfirmAction.mockReset();
   mockedGetConfigValue.mockReset();
+  mockedParseConcurrency.mockReset();
+  mockedParseConcurrency.mockReturnValue(0);
+  mockedLoadTaskFile.mockReset();
+  mockedExecuteBatchTasks.mockReset();
+  mockedExecuteBatchTasks.mockResolvedValue([]);
 });
 
 describe('registerResumeCommand', () => {
@@ -80,6 +111,16 @@ describe('registerResumeCommand', () => {
     const cmd = program.commands.find((c) => c.name() === 'resume');
     expect(cmd).toBeDefined();
   });
+
+  it('注册 --prompt、-f、-c 选项', () => {
+    const program = new Command();
+    registerResumeCommand(program);
+    const cmd = program.commands.find((c) => c.name() === 'resume');
+    const options = cmd!.options.map((o) => o.long);
+    expect(options).toContain('--prompt');
+    expect(options).toContain('--file');
+    expect(options).toContain('--concurrency');
+  });
 });
 
 describe('handleResume', () => {
@@ -226,3 +267,200 @@ describe('handleResume — resumeInPlace 配置', () => {
     expect(mockedGetConfigValue).not.toHaveBeenCalled();
   });
 });
+
+describe('handleResume — 非交互式追问', () => {
+  it('--prompt + -b 有历史会话时传 [true]', async () => {
+    const worktree = { path: '/path/feature', branch: 'feature' };
+    mockedGetProjectWorktrees.mockReturnValue([worktree]);
+    mockedFindExactMatch.mockReturnValue(worktree);
+    mockedHasClaudeSessionHistory.mockReturnValue(true);
+    mockedExecuteBatchTasks.mockResolvedValue([]);
+
+    const program = new Command();
+    program.exitOverride();
+    registerResumeCommand(program);
+    await program.parseAsync(['resume', '-b', 'feature', '--prompt', '加上单元测试'], { from: 'user' });
+
+    expect(mockedFindExactMatch).toHaveBeenCalled();
+    expect(mockedHasClaudeSessionHistory).toHaveBeenCalledWith(worktree.path);
+    // 有历史会话时使用 --continue 模式
+    expect(mockedExecuteBatchTasks).toHaveBeenCalledWith(
+      [worktree],
+      ['加上单元测试'],
+      0,
+      [true],
+    );
+    // 不应走交互式流程
+    expect(mockedResolveTargetWorktrees).not.toHaveBeenCalled();
+    expect(mockedLaunchInteractiveClaude).not.toHaveBeenCalled();
+  });
+
+  it('--prompt + -b 无历史会话时传 [false]', async () => {
+    const worktree = { path: '/path/feature', branch: 'feature' };
+    mockedGetProjectWorktrees.mockReturnValue([worktree]);
+    mockedFindExactMatch.mockReturnValue(worktree);
+    mockedHasClaudeSessionHistory.mockReturnValue(false);
+    mockedExecuteBatchTasks.mockResolvedValue([]);
+
+    const program = new Command();
+    program.exitOverride();
+    registerResumeCommand(program);
+    await program.parseAsync(['resume', '-b', 'feature', '--prompt', '加上单元测试'], { from: 'user' });
+
+    expect(mockedHasClaudeSessionHistory).toHaveBeenCalledWith(worktree.path);
+    // 无历史会话时不传 --continue
+    expect(mockedExecuteBatchTasks).toHaveBeenCalledWith(
+      [worktree],
+      ['加上单元测试'],
+      0,
+      [false],
+    );
+  });
+
+  it('--prompt 无 -b 时报错', async () => {
+    const program = new Command();
+    program.exitOverride();
+    registerResumeCommand(program);
+
+    await expect(
+      program.parseAsync(['resume', '--prompt', '加上单元测试'], { from: 'user' }),
+    ).rejects.toThrow('--prompt 必须配合 -b 指定目标分支');
+  });
+
+  it('--prompt 和 -f 同时使用时报错', async () => {
+    const program = new Command();
+    program.exitOverride();
+    registerResumeCommand(program);
+
+    await expect(
+      program.parseAsync(['resume', '-b', 'feature', '--prompt', '追问', '-f', 'tasks.md'], { from: 'user' }),
+    ).rejects.toThrow('--prompt 和 -f 不能同时使用');
+  });
+
+  it('--prompt 指定的分支不存在时报错', async () => {
+    mockedGetProjectWorktrees.mockReturnValue([
+      { path: '/path/other', branch: 'other' },
+    ]);
+    mockedFindExactMatch.mockReturnValue(undefined);
+
+    const program = new Command();
+    program.exitOverride();
+    registerResumeCommand(program);
+
+    await expect(
+      program.parseAsync(['resume', '-b', 'nonexistent', '--prompt', '追问'], { from: 'user' }),
+    ).rejects.toThrow('未找到分支');
+  });
+
+  it('-f 批量追问模式', async () => {
+    const worktrees = [
+      { path: '/path/feat-a', branch: 'feat-a' },
+      { path: '/path/feat-b', branch: 'feat-b' },
+    ];
+    mockedLoadTaskFile.mockReturnValue([
+      { branch: 'feat-a', task: '追问任务A' },
+      { branch: 'feat-b', task: '追问任务B' },
+    ]);
+    mockedGetProjectWorktrees.mockReturnValue(worktrees);
+    mockedFindExactMatch
+      .mockReturnValueOnce(worktrees[0])
+      .mockReturnValueOnce(worktrees[1]);
+    mockedHasClaudeSessionHistory.mockReturnValue(true);
+    mockedExecuteBatchTasks.mockResolvedValue([]);
+
+    const program = new Command();
+    program.exitOverride();
+    registerResumeCommand(program);
+    await program.parseAsync(['resume', '-f', 'follow-up.md'], { from: 'user' });
+
+    expect(mockedLoadTaskFile).toHaveBeenCalledWith('follow-up.md', { branchRequired: true });
+    // 按 worktree 独立检查会话历史
+    expect(mockedHasClaudeSessionHistory).toHaveBeenCalledWith('/path/feat-a');
+    expect(mockedHasClaudeSessionHistory).toHaveBeenCalledWith('/path/feat-b');
+    expect(mockedExecuteBatchTasks).toHaveBeenCalledWith(
+      worktrees,
+      ['追问任务A', '追问任务B'],
+      0,
+      [true, true],
+    );
+  });
+
+  it('-f 批量追问分支不存在时报错', async () => {
+    mockedLoadTaskFile.mockReturnValue([
+      { branch: 'nonexistent', task: '追问任务' },
+    ]);
+    mockedGetProjectWorktrees.mockReturnValue([
+      { path: '/path/feat-a', branch: 'feat-a' },
+    ]);
+    mockedFindExactMatch.mockReturnValue(undefined);
+
+    const program = new Command();
+    program.exitOverride();
+    registerResumeCommand(program);
+
+    await expect(
+      program.parseAsync(['resume', '-f', 'follow-up.md'], { from: 'user' }),
+    ).rejects.toThrow('未找到分支');
+  });
+
+  it('-f + -c 传递并发数', async () => {
+    const worktree = { path: '/path/feat-a', branch: 'feat-a' };
+    mockedLoadTaskFile.mockReturnValue([
+      { branch: 'feat-a', task: '追问' },
+    ]);
+    mockedGetProjectWorktrees.mockReturnValue([worktree]);
+    mockedFindExactMatch.mockReturnValue(worktree);
+    mockedHasClaudeSessionHistory.mockReturnValue(true);
+    mockedParseConcurrency.mockReturnValue(2);
+    mockedExecuteBatchTasks.mockResolvedValue([]);
+
+    const program = new Command();
+    program.exitOverride();
+    registerResumeCommand(program);
+    await program.parseAsync(['resume', '-f', 'follow-up.md', '-c', '2'], { from: 'user' });
+
+    expect(mockedExecuteBatchTasks).toHaveBeenCalledWith(
+      [worktree],
+      ['追问'],
+      2,
+      [true],
+    );
+  });
+
+  it('-f 批量追问按 worktree 独立检查会话历史', async () => {
+    const worktrees = [
+      { path: '/path/feat-a', branch: 'feat-a' },
+      { path: '/path/feat-b', branch: 'feat-b' },
+      { path: '/path/feat-c', branch: 'feat-c' },
+    ];
+    mockedLoadTaskFile.mockReturnValue([
+      { branch: 'feat-a', task: '任务A' },
+      { branch: 'feat-b', task: '任务B' },
+      { branch: 'feat-c', task: '任务C' },
+    ]);
+    mockedGetProjectWorktrees.mockReturnValue(worktrees);
+    mockedFindExactMatch
+      .mockReturnValueOnce(worktrees[0])
+      .mockReturnValueOnce(worktrees[1])
+      .mockReturnValueOnce(worktrees[2]);
+    // feat-a 有历史会话，feat-b 无，feat-c 有
+    mockedHasClaudeSessionHistory
+      .mockReturnValueOnce(true)
+      .mockReturnValueOnce(false)
+      .mockReturnValueOnce(true);
+    mockedExecuteBatchTasks.mockResolvedValue([]);
+
+    const program = new Command();
+    program.exitOverride();
+    registerResumeCommand(program);
+    await program.parseAsync(['resume', '-f', 'follow-up.md'], { from: 'user' });
+
+    // continueFlags 应按 worktree 独立反映各自的会话历史状态
+    expect(mockedExecuteBatchTasks).toHaveBeenCalledWith(
+      worktrees,
+      ['任务A', '任务B', '任务C'],
+      0,
+      [true, false, true],
+    );
+  });
+});