clawt 2.14.1 → 2.15.0

package/src/types/command.ts

@@ -16,6 +16,8 @@ export interface RunOptions {
   concurrency?: string;
   /** 任务文件路径（与 --tasks 互斥） */
   file?: string;
+  /** 预览模式，仅展示任务计划不实际执行 */
+  dryRun?: boolean;
 }
 
 /** validate 命令选项 */

package/src/utils/config.ts

@@ -1,5 +1,6 @@
 import { existsSync, readFileSync, writeFileSync } from 'node:fs';
 import { CONFIG_PATH, CLAWT_HOME, LOGS_DIR, WORKTREES_DIR, DEFAULT_CONFIG, MESSAGES } from '../constants/index.js';
+import { ClawtError } from '../errors/index.js';
 import { ensureDir } from './fs.js';
 import { logger } from '../logger/index.js';
 import type { ClawtConfig } from '../types/index.js';
@@ -65,3 +66,22 @@ export function ensureClawtDirs(): void {
   ensureDir(LOGS_DIR);
   ensureDir(WORKTREES_DIR);
 }
+
+/**
+ * 解析并发数参数
+ * 优先级：命令行参数 > 全局配置 > 默认值 0
+ * @param {string | undefined} optionValue - 命令行传入的并发数字符串
+ * @param {number} configValue - 全局配置中的默认并发数
+ * @returns {number} 解析后的并发数，0 表示不限制
+ */
+export function parseConcurrency(optionValue: string | undefined, configValue: number): number {
+  if (optionValue === undefined) {
+    return configValue;
+  }
+
+  const parsed = parseInt(optionValue, 10);
+  if (Number.isNaN(parsed) || parsed < 0) {
+    throw new ClawtError(MESSAGES.CONCURRENCY_INVALID);
+  }
+  return parsed;
+}

package/src/utils/dry-run.ts

@@ -0,0 +1,89 @@
+import chalk from 'chalk';
+import { join } from 'node:path';
+import { MESSAGES } from '../constants/index.js';
+import { checkBranchExists } from './git.js';
+import { getProjectWorktreeDir } from './worktree.js';
+import { printInfo, printDoubleSeparator, printSeparator } from './formatter.js';
+
+/** dry-run 模式下任务描述的最大显示长度 */
+const DRY_RUN_TASK_DESC_MAX_LENGTH = 70;
+
+/**
+ * 截取任务描述，超出最大长度时末尾加省略号
+ * 多行内容会被合并为单行显示
+ * @param {string} task - 原始任务描述
+ * @returns {string} 截取后的任务描述
+ */
+export function truncateTaskDesc(task: string): string {
+  // 将换行替换为空格，保证单行显示
+  const oneLine = task.replace(/\n/g, ' ').trim();
+  if (oneLine.length <= DRY_RUN_TASK_DESC_MAX_LENGTH) {
+    return oneLine;
+  }
+  return oneLine.slice(0, DRY_RUN_TASK_DESC_MAX_LENGTH) + '...';
+}
+
+/**
+ * 输出 dry-run 预览信息，展示将要创建的 worktree 列表和任务摘要
+ * @param {string[]} branchNames - 分支名列表
+ * @param {string[]} tasks - 任务描述列表（与 branchNames 等长，交互式模式可为空数组）
+ * @param {number} concurrency - 并发数
+ */
+export function printDryRunPreview(branchNames: string[], tasks: string[], concurrency: number): void {
+  const projectDir = getProjectWorktreeDir();
+  const isInteractive = tasks.length === 0;
+
+  // 标题区
+  printDoubleSeparator();
+  printInfo(`  ${chalk.bold(MESSAGES.DRY_RUN_TITLE)}`);
+  printDoubleSeparator();
+
+  // 摘要行：合并为一行，用 │ 分隔
+  const summaryParts = [
+    MESSAGES.DRY_RUN_TASK_COUNT(branchNames.length),
+    MESSAGES.DRY_RUN_CONCURRENCY(concurrency),
+    MESSAGES.DRY_RUN_WORKTREE_DIR(projectDir),
+  ];
+  if (isInteractive) {
+    summaryParts.push(MESSAGES.DRY_RUN_INTERACTIVE_MODE);
+  }
+  printInfo(summaryParts.join(chalk.gray(' │ ')));
+
+  printSeparator();
+
+  // 逐个展示 worktree 信息
+  let hasConflict = false;
+  for (let i = 0; i < branchNames.length; i++) {
+    const branch = branchNames[i];
+    const worktreePath = join(projectDir, branch);
+    const exists = checkBranchExists(branch);
+
+    if (exists) hasConflict = true;
+
+    // 序号行：正常用绿色 ✓，冲突用黄色 ⚠ + 警告文本
+    const indexLabel = `[${i + 1}/${branchNames.length}]`;
+    if (exists) {
+      printInfo(`${chalk.yellow('⚠')} ${indexLabel} ${chalk.yellow(branch)} ${chalk.gray('—')} ${chalk.yellow(MESSAGES.DRY_RUN_BRANCH_EXISTS_WARNING(branch))}`);
+    } else {
+      printInfo(`${chalk.green('✓')} ${indexLabel} ${chalk.cyan(branch)}`);
+    }
+
+    // 路径行（2空格缩进）
+    printInfo(`  ${chalk.gray('路径:')} ${worktreePath}`);
+
+    // 任务描述行（2空格缩进，非交互式模式）
+    if (!isInteractive) {
+      printInfo(`  ${chalk.gray('任务:')} ${truncateTaskDesc(tasks[i])}`);
+    }
+
+    printInfo('');
+  }
+
+  // 结尾
+  printDoubleSeparator();
+  if (hasConflict) {
+    printInfo(chalk.yellow(`⚠ ${MESSAGES.DRY_RUN_HAS_CONFLICT}`));
+  } else {
+    printInfo(chalk.green(`✓ ${MESSAGES.DRY_RUN_READY}`));
+  }
+}

package/src/utils/index.ts

@@ -48,7 +48,7 @@ export {
 export { sanitizeBranchName, generateBranchNames, validateBranchesNotExist } from './branch.js';
 export { validateMainWorktree, validateGitInstalled, validateClaudeCodeInstalled } from './validation.js';
 export { createWorktrees, getProjectWorktrees, getProjectWorktreeDir, cleanupWorktrees, getWorktreeStatus, createWorktreesByBranches } from './worktree.js';
-export { loadConfig, writeDefaultConfig, writeConfig, saveConfig, getConfigValue, ensureClawtDirs } from './config.js';
+export { loadConfig, writeDefaultConfig, writeConfig, saveConfig, getConfigValue, ensureClawtDirs, parseConcurrency } from './config.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';
@@ -57,9 +57,10 @@ export { getSnapshotPath, hasSnapshot, readSnapshotTreeHash, readSnapshot, write
 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 { parseTaskFile, loadTaskFile, parseTasksFromOptions } from './task-file.js';
 export { executeBatchTasks } from './task-executor.js';
 export { detectTerminalApp, openCommandInNewTerminalTab } from './terminal.js';
+export { truncateTaskDesc, printDryRunPreview } from './dry-run.js';
 export { applyAliases } from './alias.js';
 export { isValidConfigKey, getValidConfigKeys, parseConfigValue, promptConfigValue, formatConfigValue } from './config-strategy.js';
 

package/src/utils/task-file.ts

@@ -10,6 +10,24 @@ const TASK_BLOCK_REGEX = /<!-- CLAWT-TASKS:START -->([\s\S]*?)<!-- CLAWT-TASKS:E
 /** 匹配分支名行的正则：# branch: <name> */
 const BRANCH_LINE_REGEX = /^#\s*branch:\s*(.+)$/;
 
+/** 任务列表为空时的错误提示 */
+const EMPTY_TASKS_MESSAGE = '任务列表不能为空';
+
+/**
+ * 从命令行 --tasks 选项中解析出有效的任务列表
+ * 去除首尾空白并过滤空字符串，结果为空时抛出错误
+ * @param {string[]} rawTasks - 原始任务字符串数组
+ * @returns {string[]} 过滤后的有效任务列表
+ * @throws {ClawtError} 任务列表为空时抛出
+ */
+export function parseTasksFromOptions(rawTasks: string[]): string[] {
+  const tasks = rawTasks.map((t) => t.trim()).filter(Boolean);
+  if (tasks.length === 0) {
+    throw new ClawtError(EMPTY_TASKS_MESSAGE);
+  }
+  return tasks;
+}
+
 /**
  * 解析任务文件内容，提取所有任务块
  * 每个块内 `# branch: <name>` 为分支名，其余行为任务描述

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

@@ -19,7 +19,7 @@ vi.mock('../../../src/utils/index.js', () => ({
   validateClaudeCodeInstalled: vi.fn(),
   getProjectWorktrees: vi.fn(),
   launchInteractiveClaude: vi.fn(),
-  resolveTargetWorktree: vi.fn(),
+  resolveTargetWorktrees: vi.fn(),
 }));
 
 import { registerResumeCommand } from '../../../src/commands/resume.js';
@@ -28,21 +28,21 @@ import {
   validateClaudeCodeInstalled,
   getProjectWorktrees,
   launchInteractiveClaude,
-  resolveTargetWorktree,
+  resolveTargetWorktrees,
 } from '../../../src/utils/index.js';
 
 const mockedValidateMainWorktree = vi.mocked(validateMainWorktree);
 const mockedValidateClaudeCodeInstalled = vi.mocked(validateClaudeCodeInstalled);
 const mockedGetProjectWorktrees = vi.mocked(getProjectWorktrees);
 const mockedLaunchInteractiveClaude = vi.mocked(launchInteractiveClaude);
-const mockedResolveTargetWorktree = vi.mocked(resolveTargetWorktree);
+const mockedResolveTargetWorktrees = vi.mocked(resolveTargetWorktrees);
 
 beforeEach(() => {
   mockedValidateMainWorktree.mockReset();
   mockedValidateClaudeCodeInstalled.mockReset();
   mockedGetProjectWorktrees.mockReset();
   mockedLaunchInteractiveClaude.mockReset();
-  mockedResolveTargetWorktree.mockReset();
+  mockedResolveTargetWorktrees.mockReset();
 });
 
 describe('registerResumeCommand', () => {
@@ -58,7 +58,7 @@ describe('handleResume', () => {
   it('成功恢复 Claude Code 会话', async () => {
     const worktree = { path: '/path/feature', branch: 'feature' };
     mockedGetProjectWorktrees.mockReturnValue([worktree]);
-    mockedResolveTargetWorktree.mockResolvedValue(worktree);
+    mockedResolveTargetWorktrees.mockResolvedValue([worktree]);
 
     const program = new Command();
     program.exitOverride();
@@ -67,14 +67,14 @@ describe('handleResume', () => {
 
     expect(mockedValidateMainWorktree).toHaveBeenCalled();
     expect(mockedValidateClaudeCodeInstalled).toHaveBeenCalled();
-    expect(mockedResolveTargetWorktree).toHaveBeenCalled();
+    expect(mockedResolveTargetWorktrees).toHaveBeenCalled();
     expect(mockedLaunchInteractiveClaude).toHaveBeenCalledWith(worktree, { autoContinue: true });
   });
 
-  it('不传 -b 时也能调用 resolveTargetWorktree', async () => {
+  it('不传 -b 时也能调用 resolveTargetWorktrees', async () => {
     const worktree = { path: '/path/feature', branch: 'feature' };
     mockedGetProjectWorktrees.mockReturnValue([worktree]);
-    mockedResolveTargetWorktree.mockResolvedValue(worktree);
+    mockedResolveTargetWorktrees.mockResolvedValue([worktree]);
 
     const program = new Command();
     program.exitOverride();
@@ -82,7 +82,7 @@ describe('handleResume', () => {
     await program.parseAsync(['resume'], { from: 'user' });
 
     // branchName 参数为 undefined
-    expect(mockedResolveTargetWorktree).toHaveBeenCalledWith(
+    expect(mockedResolveTargetWorktrees).toHaveBeenCalledWith(
       expect.any(Array),
       expect.any(Object),
       undefined,

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

@@ -31,6 +31,14 @@ vi.mock('../../../src/constants/index.js', () => ({
     BRANCH_OR_FILE_REQUIRED: '请指定 -b 或 -f',
     TASK_FILE_LOADED: (count: number, path: string) => `✓ 从 ${path} 加载了 ${count} 个任务`,
     TASK_FILE_MISSING_TASK_BY_INDEX: (blockIndex: number) => `第 ${blockIndex} 个任务块缺少任务描述`,
+    DRY_RUN_TITLE: 'Dry Run 预览',
+    DRY_RUN_TASK_COUNT: (count: number) => `任务数: ${count}`,
+    DRY_RUN_CONCURRENCY: (concurrency: number) => `并发数: ${concurrency === 0 ? '不限制' : concurrency}`,
+    DRY_RUN_WORKTREE_DIR: (dir: string) => `Worktree 目录: ${dir}`,
+    DRY_RUN_BRANCH_EXISTS_WARNING: (name: string) => `分支 ${name} 已存在`,
+    DRY_RUN_INTERACTIVE_MODE: '模式: 交互式（无预设任务）',
+    DRY_RUN_READY: '预览完成，无冲突。移除 --dry-run 即可正式执行。',
+    DRY_RUN_HAS_CONFLICT: '存在分支冲突，实际执行时将会报错。请先处理冲突的分支。',
   },
 }));
 
@@ -46,8 +54,11 @@ vi.mock('../../../src/utils/index.js', async (importOriginal) => {
     validateClaudeCodeInstalled: vi.fn(),
     createWorktrees: vi.fn(),
     sanitizeBranchName: vi.fn(),
+    generateBranchNames: vi.fn(),
     checkBranchExists: vi.fn(),
     getConfigValue: vi.fn().mockReturnValue(0),
+    parseConcurrency: vi.fn().mockReturnValue(0),
+    getProjectWorktreeDir: vi.fn().mockReturnValue('/mock/.clawt/worktrees/test-project'),
     printSuccess: vi.fn(),
     printError: vi.fn(),
     printWarning: vi.fn(),
@@ -57,7 +68,9 @@ vi.mock('../../../src/utils/index.js', async (importOriginal) => {
     confirmAction: vi.fn(),
     launchInteractiveClaude: vi.fn(),
     loadTaskFile: vi.fn(),
+    parseTasksFromOptions: vi.fn(),
     createWorktreesByBranches: vi.fn(),
+    printDryRunPreview: vi.fn(),
   };
 });
 
@@ -80,6 +93,7 @@ vi.mock('../../../src/utils/worktree.js', () => ({
 
 vi.mock('../../../src/utils/config.js', () => ({
   getConfigValue: vi.fn().mockReturnValue(0),
+  parseConcurrency: vi.fn().mockReturnValue(0),
   loadConfig: vi.fn(),
   writeDefaultConfig: vi.fn(),
   ensureClawtDirs: vi.fn(),
@@ -110,30 +124,45 @@ vi.mock('../../../src/utils/progress.js', () => ({
   },
 }));
 
+vi.mock('../../../src/utils/dry-run.js', () => ({
+  truncateTaskDesc: vi.fn(),
+  printDryRunPreview: vi.fn(),
+}));
+
 import { registerRunCommand } from '../../../src/commands/run.js';
 import {
   createWorktrees,
   createWorktreesByBranches,
   sanitizeBranchName,
+  generateBranchNames,
   checkBranchExists,
+  parseConcurrency,
   printSuccess,
+  printDryRunPreview,
   launchInteractiveClaude,
   getConfigValue,
   loadTaskFile,
+  parseTasksFromOptions,
+  validateClaudeCodeInstalled,
 } from '../../../src/utils/index.js';
 import { spawnProcess } from '../../../src/utils/shell.js';
-import { printInfo } from '../../../src/utils/formatter.js';
+import { printInfo as formatterPrintInfo } from '../../../src/utils/formatter.js';
 
 const mockedCreateWorktrees = vi.mocked(createWorktrees);
 const mockedCreateWorktreesByBranches = vi.mocked(createWorktreesByBranches);
 const mockedSanitizeBranchName = vi.mocked(sanitizeBranchName);
+const mockedGenerateBranchNames = vi.mocked(generateBranchNames);
 const mockedCheckBranchExists = vi.mocked(checkBranchExists);
+const mockedParseConcurrency = vi.mocked(parseConcurrency);
 const mockedSpawnProcess = vi.mocked(spawnProcess);
 const mockedPrintSuccess = vi.mocked(printSuccess);
-const mockedPrintInfo = vi.mocked(printInfo);
+const mockedPrintDryRunPreview = vi.mocked(printDryRunPreview);
+const mockedFormatterPrintInfo = vi.mocked(formatterPrintInfo);
 const mockedLaunchInteractiveClaude = vi.mocked(launchInteractiveClaude);
 const mockedGetConfigValue = vi.mocked(getConfigValue);
 const mockedLoadTaskFile = vi.mocked(loadTaskFile);
+const mockedParseTasksFromOptions = vi.mocked(parseTasksFromOptions);
+const mockedValidateClaudeCodeInstalled = vi.mocked(validateClaudeCodeInstalled);
 
 /**
  * 创建模拟子进程
@@ -166,16 +195,33 @@ beforeEach(() => {
   mockedCreateWorktrees.mockReset();
   mockedCreateWorktreesByBranches.mockReset();
   mockedSanitizeBranchName.mockReset();
+  mockedGenerateBranchNames.mockReset();
   mockedCheckBranchExists.mockReset();
+  mockedParseConcurrency.mockReset();
+  mockedParseConcurrency.mockReturnValue(0);
   mockedSpawnProcess.mockReset();
   mockedPrintSuccess.mockReset();
-  mockedPrintInfo.mockReset();
+  mockedPrintDryRunPreview.mockReset();
+  mockedFormatterPrintInfo.mockReset();
   mockedLaunchInteractiveClaude.mockReset();
   mockedGetConfigValue.mockReset();
   mockedGetConfigValue.mockReturnValue(0 as any);
   mockedLoadTaskFile.mockReset();
+  mockedParseTasksFromOptions.mockReset();
+  mockedValidateClaudeCodeInstalled.mockReset();
   // sanitizeBranchName 默认返回输入值
   mockedSanitizeBranchName.mockImplementation((name: string) => name);
+  // generateBranchNames 默认使用真实逻辑
+  mockedGenerateBranchNames.mockImplementation((name: string, count: number) => {
+    if (count === 1) return [name];
+    return Array.from({ length: count }, (_, i) => `${name}-${i + 1}`);
+  });
+  // parseTasksFromOptions 默认使用真实逻辑
+  mockedParseTasksFromOptions.mockImplementation((rawTasks: string[]) => {
+    const tasks = rawTasks.map((t) => t.trim()).filter(Boolean);
+    if (tasks.length === 0) throw new Error('任务列表不能为空');
+    return tasks;
+  });
 });
 
 describe('registerRunCommand', () => {
@@ -285,6 +331,7 @@ describe('handleRun', () => {
   });
 
   it('传 --concurrency 限制并发数', async () => {
+    mockedParseConcurrency.mockReturnValue(1);
     const worktrees = [
       { path: '/path/feat-1', branch: 'feat-1' },
       { path: '/path/feat-2', branch: 'feat-2' },
@@ -311,7 +358,7 @@ describe('handleRun', () => {
     // 所有任务都应执行完毕
     expect(mockedSpawnProcess).toHaveBeenCalledTimes(3);
     // 应输出并发限制提示
-    expect(mockedPrintInfo).toHaveBeenCalledWith(expect.stringContaining('并发限制'));
+    expect(mockedFormatterPrintInfo).toHaveBeenCalledWith(expect.stringContaining('并发限制'));
   });
 
   it('--concurrency 为 0 时不限制并发', async () => {
@@ -336,12 +383,13 @@ describe('handleRun', () => {
     await program.parseAsync(['run', '-b', 'feat', '--tasks', 'task1', 'task2', '-c', '0'], { from: 'user' });
 
     // 不限制并发时不输出并发限制提示
-    expect(mockedPrintInfo).not.toHaveBeenCalledWith(expect.stringContaining('并发限制'));
+    expect(mockedFormatterPrintInfo).not.toHaveBeenCalledWith(expect.stringContaining('并发限制'));
     expect(mockedSpawnProcess).toHaveBeenCalledTimes(2);
   });
 
   it('未传 -c 时使用全局配置的 maxConcurrency', async () => {
     mockedGetConfigValue.mockReturnValue(2 as any);
+    mockedParseConcurrency.mockReturnValue(2);
 
     const worktrees = [
       { path: '/path/feat-1', branch: 'feat-1' },
@@ -366,7 +414,7 @@ describe('handleRun', () => {
     await program.parseAsync(['run', '-b', 'feat', '--tasks', 'task1', 'task2', 'task3'], { from: 'user' });
 
     // 应输出并发限制提示（使用配置值 2）
-    expect(mockedPrintInfo).toHaveBeenCalledWith(expect.stringContaining('并发限制'));
+    expect(mockedFormatterPrintInfo).toHaveBeenCalledWith(expect.stringContaining('并发限制'));
     expect(mockedSpawnProcess).toHaveBeenCalledTimes(3);
   });
 
@@ -454,3 +502,109 @@ describe('handleRun', () => {
     ).rejects.toThrow();
   });
 });
+
+describe('handleRun --dry-run', () => {
+  it('--dry-run + --tasks 展示任务预览，不创建 worktree 也不启动 Claude Code', async () => {
+    const program = new Command();
+    program.exitOverride();
+    registerRunCommand(program);
+    await program.parseAsync(['run', '-b', 'feat', '--tasks', '实现登录功能', '修复首页bug', '--dry-run'], { from: 'user' });
+
+    // 不创建 worktree
+    expect(mockedCreateWorktrees).not.toHaveBeenCalled();
+    expect(mockedCreateWorktreesByBranches).not.toHaveBeenCalled();
+    // 不启动 Claude Code
+    expect(mockedLaunchInteractiveClaude).not.toHaveBeenCalled();
+    expect(mockedSpawnProcess).not.toHaveBeenCalled();
+    // 应调用 generateBranchNames 生成分支名
+    expect(mockedGenerateBranchNames).toHaveBeenCalledWith('feat', 2);
+    // 应调用 printDryRunPreview 输出预览
+    expect(mockedPrintDryRunPreview).toHaveBeenCalledWith(['feat-1', 'feat-2'], ['实现登录功能', '修复首页bug'], 0);
+  });
+
+  it('--dry-run 不调用 validateClaudeCodeInstalled', async () => {
+    const program = new Command();
+    program.exitOverride();
+    registerRunCommand(program);
+    await program.parseAsync(['run', '-b', 'feat', '--tasks', 'task1', '--dry-run'], { from: 'user' });
+
+    expect(mockedValidateClaudeCodeInstalled).not.toHaveBeenCalled();
+  });
+
+  it('--dry-run 交互式模式展示单个 worktree 信息', async () => {
+    const program = new Command();
+    program.exitOverride();
+    registerRunCommand(program);
+    await program.parseAsync(['run', '-b', 'feat', '--dry-run'], { from: 'user' });
+
+    // 不创建 worktree
+    expect(mockedCreateWorktrees).not.toHaveBeenCalled();
+    // 不启动 Claude Code
+    expect(mockedLaunchInteractiveClaude).not.toHaveBeenCalled();
+    // 交互式模式：分支名列表为单个，任务为空数组
+    expect(mockedPrintDryRunPreview).toHaveBeenCalledWith(['feat'], [], 0);
+  });
+
+  it('--dry-run + -f 从任务文件展示预览', async () => {
+    mockedLoadTaskFile.mockReturnValue([
+      { branch: 'feat-login', task: '实现登录功能' },
+      { branch: 'fix-bug', task: '修复问题' },
+    ]);
+
+    const program = new Command();
+    program.exitOverride();
+    registerRunCommand(program);
+    await program.parseAsync(['run', '-f', 'tasks.md', '--dry-run'], { from: 'user' });
+
+    // 应加载任务文件
+    expect(mockedLoadTaskFile).toHaveBeenCalledWith('tasks.md', { branchRequired: true });
+    // 不创建 worktree
+    expect(mockedCreateWorktrees).not.toHaveBeenCalled();
+    expect(mockedCreateWorktreesByBranches).not.toHaveBeenCalled();
+    // 不启动 Claude Code
+    expect(mockedSpawnProcess).not.toHaveBeenCalled();
+    // 应调用 printDryRunPreview
+    expect(mockedPrintDryRunPreview).toHaveBeenCalledWith(
+      ['feat-login', 'fix-bug'],
+      ['实现登录功能', '修复问题'],
+      0,
+    );
+  });
+
+  it('--dry-run + -f + -b 模式使用 -b 自动编号', async () => {
+    mockedLoadTaskFile.mockReturnValue([
+      { task: '任务1' },
+      { task: '任务2' },
+    ]);
+
+    const program = new Command();
+    program.exitOverride();
+    registerRunCommand(program);
+    await program.parseAsync(['run', '-b', 'feat', '-f', 'tasks.md', '--dry-run'], { from: 'user' });
+
+    // 应使用 generateBranchNames 自动编号
+    expect(mockedGenerateBranchNames).toHaveBeenCalledWith('feat', 2);
+    // 不实际创建 worktree
+    expect(mockedCreateWorktrees).not.toHaveBeenCalled();
+    // 应调用 printDryRunPreview
+    expect(mockedPrintDryRunPreview).toHaveBeenCalled();
+  });
+
+  it('--dry-run 传递并发配置给 printDryRunPreview', async () => {
+    mockedParseConcurrency.mockReturnValue(3);
+
+    const program = new Command();
+    program.exitOverride();
+    registerRunCommand(program);
+    await program.parseAsync(['run', '-b', 'feat', '--tasks', 'task1', 'task2', '-c', '3', '--dry-run'], { from: 'user' });
+
+    // 不创建 worktree
+    expect(mockedCreateWorktrees).not.toHaveBeenCalled();
+    // 应将并发数传递给 printDryRunPreview
+    expect(mockedPrintDryRunPreview).toHaveBeenCalledWith(
+      expect.any(Array),
+      expect.any(Array),
+      3,
+    );
+  });
+});

package/tests/unit/constants/messages.test.ts

@@ -12,7 +12,6 @@ describe('MESSAGES', () => {
       'TARGET_WORKTREE_CLEAN',
       'MERGE_CONFLICT',
       'COMMIT_MESSAGE_REQUIRED',
-      'TARGET_WORKTREE_DIRTY_NO_MESSAGE',
       'TARGET_WORKTREE_NO_CHANGES',
       'INTERRUPTED',
       'INTERRUPT_CONFIRM_CLEANUP',
@@ -49,6 +48,11 @@ describe('MESSAGES', () => {
   });
 
   describe('模板函数消息', () => {
+    it('TARGET_WORKTREE_DIRTY_NO_MESSAGE 包含 worktree 路径', () => {
+      const result = MESSAGES.TARGET_WORKTREE_DIRTY_NO_MESSAGE('/path/to/wt');
+      expect(result).toContain('/path/to/wt');
+    });
+
     it('BRANCH_EXISTS 包含分支名', () => {
       const result = MESSAGES.BRANCH_EXISTS('feature-a');
       expect(result).toContain('feature-a');

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

@@ -18,7 +18,7 @@ vi.mock('../../../src/utils/fs.js', () => ({
 }));
 
 import { existsSync, readFileSync, writeFileSync } from 'node:fs';
-import { loadConfig, getConfigValue, writeDefaultConfig, writeConfig, saveConfig, ensureClawtDirs } from '../../../src/utils/config.js';
+import { loadConfig, getConfigValue, writeDefaultConfig, writeConfig, saveConfig, ensureClawtDirs, parseConcurrency } from '../../../src/utils/config.js';
 import { DEFAULT_CONFIG } from '../../../src/constants/index.js';
 import { ensureDir } from '../../../src/utils/fs.js';
 
@@ -96,6 +96,28 @@ describe('ensureClawtDirs', () => {
   });
 });
 
+describe('parseConcurrency', () => {
+  it('命令行参数 undefined 时返回配置值', () => {
+    expect(parseConcurrency(undefined, 5)).toBe(5);
+  });
+
+  it('命令行参数为有效正整数时返回解析值', () => {
+    expect(parseConcurrency('3', 0)).toBe(3);
+  });
+
+  it('命令行参数为 0 时返回 0（不限制）', () => {
+    expect(parseConcurrency('0', 5)).toBe(0);
+  });
+
+  it('命令行参数为负数时抛出错误', () => {
+    expect(() => parseConcurrency('-1', 0)).toThrow();
+  });
+
+  it('命令行参数为非数字时抛出错误', () => {
+    expect(() => parseConcurrency('abc', 0)).toThrow();
+  });
+});
+
 describe('saveConfig', () => {
   it('将配置对象写入配置文件', () => {
     const customConfig = { ...DEFAULT_CONFIG, autoDeleteBranch: true };