clawt 2.10.0 → 2.11.0

package/src/commands/run.ts

@@ -1,27 +1,20 @@
 import type { Command } from 'commander';
-import type { ChildProcess } from 'node:child_process';
 import { logger } from '../logger/index.js';
 import { ClawtError } from '../errors/index.js';
 import { MESSAGES } from '../constants/index.js';
-import type { RunOptions, ClaudeCodeResult, TaskResult, TaskSummary, WorktreeInfo } from '../types/index.js';
+import type { RunOptions, WorktreeInfo } from '../types/index.js';
 import {
   validateMainWorktree,
   validateClaudeCodeInstalled,
   createWorktrees,
+  createWorktreesByBranches,
   sanitizeBranchName,
   checkBranchExists,
-  spawnProcess,
-  killAllChildProcesses,
-  cleanupWorktrees,
   getConfigValue,
   printSuccess,
-  printError,
-  printWarning,
-  printInfo,
-  printSeparator,
-  printDoubleSeparator,
-  confirmAction,
   launchInteractiveClaude,
+  loadTaskFile,
+  executeBatchTasks,
 } from '../utils/index.js';
 
 /**
@@ -32,165 +25,93 @@ export function registerRunCommand(program: Command): void {
   program
     .command('run')
     .description('批量创建 worktree 并启动 Claude Code 执行任务')
-    .requiredOption('-b, --branch <branchName>', '分支名')
+    .option('-b, --branch <branchName>', '分支名')
     .option('--tasks <task...>', '任务列表（可多次指定），不传则在 worktree 中打开 Claude Code 交互式界面')
+    .option('-c, --concurrency <n>', '最大并发数，0 表示不限制')
+    .option('-f, --file <path>', '从任务文件读取任务列表（与 --tasks 互斥）')
     .action(async (options: RunOptions) => {
       await handleRun(options);
     });
 }
 
-/** 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
+ * 解析并发数参数
+ * 优先级：命令行参数 > 全局配置 > 默认值 0
+ * @param {string | undefined} optionValue - 命令行传入的并发数字符串
+ * @param {number} configValue - 全局配置中的默认并发数
+ * @returns {number} 解析后的并发数，0 表示不限制
  */
-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 {TaskResult} taskResult - 任务结果
- */
-function printTaskNotification(taskResult: TaskResult): void {
-  const { success, worktreePath, branch, result } = taskResult;
-  const status = success ? '完成' : '失败';
-  const icon = success ? '✓' : '✗';
-  const durationStr = result ? `${(result.duration_ms / 1000).toFixed(1)}s` : 'N/A';
-  const costStr = result ? `$${result.total_cost_usd.toFixed(2)}` : 'N/A';
-  const resultStr = success ? 'success' : 'failed';
-
-  if (success) {
-    printSuccess(`${icon} [${status}] worktree: ${worktreePath}`);
-  } else {
-    printError(`${icon} [${status}] worktree: ${worktreePath}`);
+function parseConcurrency(optionValue: string | undefined, configValue: number): number {
+  if (optionValue === undefined) {
+    return configValue;
   }
-  printInfo(`  分支: ${branch}`);
-  printInfo(`  耗时: ${durationStr}`);
-  printInfo(`  花费: ${costStr}`);
-  printInfo(`  结果: ${resultStr}`);
-  printSeparator();
-}
 
-/**
- * 输出所有任务的汇总信息
- * @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();
+  const parsed = parseInt(optionValue, 10);
+  if (Number.isNaN(parsed) || parsed < 0) {
+    throw new ClawtError(MESSAGES.CONCURRENCY_INVALID);
+  }
+  return parsed;
 }
 
 /**
- * 处理用户中断（Ctrl+C）后的清理流程
- * 根据全局配置决定自动清理或交互式确认
- * @param {WorktreeInfo[]} worktrees - 本次创建的 worktree 列表
+ * 处理从任务文件执行的逻辑
+ * @param {RunOptions} options - 命令选项（包含 file 字段）
  */
-async function handleInterruptCleanup(worktrees: WorktreeInfo[]): Promise<void> {
-  const autoDelete = getConfigValue('autoDeleteBranch');
+async function handleRunFromFile(options: RunOptions): Promise<void> {
+  // 有 -b 参数时，文件中的分支名为可选
+  const branchRequired = !options.branch;
+  // 加载并解析任务文件
+  const entries = loadTaskFile(options.file!, { branchRequired });
+  printSuccess(MESSAGES.TASK_FILE_LOADED(entries.length, options.file!));
 
-  if (autoDelete) {
-    // 全局配置了自动删除，直接清理
-    cleanupWorktrees(worktrees);
-    printSuccess(MESSAGES.INTERRUPT_AUTO_CLEANED(worktrees.length));
-    return;
-  }
+  const tasks = entries.map((e) => e.task);
 
-  // 交互式确认是否清理
-  const shouldClean = await confirmAction(MESSAGES.INTERRUPT_CONFIRM_CLEANUP);
+  let worktrees: WorktreeInfo[];
 
-  if (shouldClean) {
-    cleanupWorktrees(worktrees);
-    printSuccess(MESSAGES.INTERRUPT_CLEANED(worktrees.length));
+  if (options.branch) {
+    // 有 -b 参数：忽略文件中的分支名，用 -b 自动编号
+    worktrees = createWorktrees(options.branch, entries.length);
   } else {
-    printInfo(MESSAGES.INTERRUPT_KEPT);
+    // 无 -b 参数：使用文件中每个任务的独立分支名
+    const branches = entries.map((e) => sanitizeBranchName(e.branch!));
+    worktrees = createWorktreesByBranches(branches);
   }
+
+  // 解析并发数
+  const concurrency = parseConcurrency(options.concurrency, getConfigValue('maxConcurrency'));
+
+  logger.info(`run 命令（文件模式）执行，任务数: ${entries.length}，并发数: ${concurrency || '不限制'}`);
+
+  await executeBatchTasks(worktrees, tasks, concurrency);
 }
 
 /**
  * 执行 run 命令的核心逻辑
- * 不传 --tasks 时创建单个 worktree 并打开 Claude Code 交互式界面
- * 传 --tasks 时批量创建 worktree 并并行执行任务
+ * 支持三种模式：
+ * 1. -f 任务文件模式
+ * 2. --tasks 命令行任务模式
+ * 3. 无任务参数时打开交互式界面
  * @param {RunOptions} options - 命令选项
  */
 async function handleRun(options: RunOptions): Promise<void> {
   validateMainWorktree();
   validateClaudeCodeInstalled();
 
+  // 互斥校验：--file 和 --tasks 不能同时使用
+  if (options.file && options.tasks) {
+    throw new ClawtError(MESSAGES.FILE_AND_TASKS_CONFLICT);
+  }
+
+  // --file 模式
+  if (options.file) {
+    return handleRunFromFile(options);
+  }
+
+  // 非 --file 模式必须指定 -b
+  if (!options.branch) {
+    throw new ClawtError(MESSAGES.BRANCH_OR_FILE_REQUIRED);
+  }
+
   // 未传 --tasks 时，创建单个 worktree 并打开 Claude Code 交互式界面
   if (!options.tasks || options.tasks.length === 0) {
     // 分支已存在时，提示用户使用 resume 恢复会话
@@ -214,73 +135,14 @@ async function handleRun(options: RunOptions): Promise<void> {
   }
 
   const count = tasks.length;
-  logger.info(`run 命令执行，分支: ${options.branch}，任务数: ${count}`);
 
-  // 创建 worktree
-  const worktrees = createWorktrees(options.branch, count);
-  printSuccess(MESSAGES.WORKTREE_CREATED(worktrees.length));
-  for (const wt of worktrees) {
-    printInfo(`  分支: ${wt.branch}  路径: ${wt.path}`);
-  }
-  printInfo('');
+  // 解析并发数：命令行参数 > 全局配置 > 默认值 0
+  const concurrency = parseConcurrency(options.concurrency, getConfigValue('maxConcurrency'));
 
-  // 并行执行 Claude Code 任务，每个完成时实时通知
-  const startTime = Date.now();
-  const handles = worktrees.map((wt, index) => {
-    const task = tasks[index];
-    logger.info(`启动任务 ${index + 1}: ${task} (worktree: ${wt.path})`);
-    return executeClaudeTask(wt, task);
-  });
+  logger.info(`run 命令执行，分支: ${options.branch}，任务数: ${count}，并发数: ${concurrency || '不限制'}`);
 
-  // 收集所有子进程引用，用于中断时终止
-  const childProcesses = handles.map((h) => h.child);
-
-  // 监听 SIGINT（Ctrl+C），终止所有子进程并触发清理流程
-  let interrupted = false;
-  const sigintHandler = async () => {
-    if (interrupted) return;
-    interrupted = true;
-
-    printInfo('');
-    printWarning(MESSAGES.INTERRUPTED);
-    killAllChildProcesses(childProcesses);
-
-    // 等待所有子进程退出后再执行清理
-    await Promise.allSettled(handles.map((h) => h.promise));
-
-    await handleInterruptCleanup(worktrees);
-    process.exit(1);
-  };
-  process.on('SIGINT', sigintHandler);
-
-  const taskPromises = handles.map((handle) =>
-    handle.promise.then((result) => {
-      // 被中断时不再输出通知
-      if (!interrupted) {
-        printTaskNotification(result);
-      }
-      return result;
-    }),
-  );
-
-  const results = await Promise.all(taskPromises);
-
-  // 正常完成，移除 SIGINT 监听器
-  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),
-  };
+  // 创建 worktree
+  const worktrees = createWorktrees(options.branch, count);
 
-  printTaskSummary(summary);
+  await executeBatchTasks(worktrees, tasks, concurrency);
 }

package/src/constants/config.ts

@@ -25,6 +25,10 @@ export const CONFIG_DEFINITIONS: ConfigDefinitions = {
     defaultValue: true,
     description: '执行破坏性操作（reset、validate --clean）前是否提示确认',
   },
+  maxConcurrency: {
+    defaultValue: 0,
+    description: 'run 命令默认最大并发数，0 表示不限制',
+  },
 };
 
 /**

package/src/constants/index.ts

@@ -1,8 +1,18 @@
 export { CLAWT_HOME, CONFIG_PATH, LOGS_DIR, WORKTREES_DIR, VALIDATE_SNAPSHOTS_DIR } from './paths.js';
 export { INVALID_BRANCH_CHARS } from './branch.js';
-export { MESSAGES } from './messages.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 { 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';
+export {
+  SPINNER_FRAMES,
+  SPINNER_INTERVAL_MS,
+  CURSOR_UP,
+  CLEAR_LINE,
+  CURSOR_HIDE,
+  CURSOR_SHOW,
+  TASK_STATUS_ICONS,
+  TASK_STATUS_LABELS,
+} from './progress.js';

package/src/constants/messages/common.ts

@@ -0,0 +1,41 @@
+/** 通用/共享提示消息 */
+export const COMMON_MESSAGES = {
+  /** 不在主 worktree 根目录 */
+  NOT_MAIN_WORKTREE: '请在主 worktree 的根目录下执行 clawt',
+  /** Git 未安装 */
+  GIT_NOT_INSTALLED: 'Git 未安装或不在 PATH 中，请先安装 Git',
+  /** Claude Code CLI 未安装 */
+  CLAUDE_NOT_INSTALLED: 'Claude Code CLI 未安装，请先安装：npm install -g @anthropic-ai/claude-code',
+  /** 分支已存在 */
+  BRANCH_EXISTS: (name: string) => `分支 ${name} 已存在，无法创建`,
+  /** 分支名清理后为空 */
+  BRANCH_NAME_EMPTY: (original: string) =>
+    `分支名 "${original}" 中不包含合法字符，无法创建分支`,
+  /** 分支名被转换 */
+  BRANCH_SANITIZED: (original: string, sanitized: string) =>
+    `分支名已转换: ${original} → ${sanitized}`,
+  /** worktree 创建成功 */
+  WORKTREE_CREATED: (count: number) => `✓ 已创建 ${count} 个 worktree`,
+  /** worktree 移除成功 */
+  WORKTREE_REMOVED: (path: string) => `✓ 已移除 worktree: ${path}`,
+  /** 没有 worktree */
+  NO_WORKTREES: '(无 worktree)',
+  /** 目标 worktree 不存在 */
+  WORKTREE_NOT_FOUND: (name: string) => `worktree ${name} 不存在`,
+  /** 主 worktree 有未提交更改 */
+  MAIN_WORKTREE_DIRTY: '主 worktree 有未提交的更改，请先处理',
+  /** 目标 worktree 无更改 */
+  TARGET_WORKTREE_CLEAN: '该 worktree 的分支上没有任何更改，无需验证',
+  /** 用户取消破坏性操作 */
+  DESTRUCTIVE_OP_CANCELLED: '已取消操作',
+  /** 请提供提交信息 */
+  COMMIT_MESSAGE_REQUIRED: '请提供提交信息（-m 参数）',
+  /** 配置文件损坏，已重新生成默认配置 */
+  CONFIG_CORRUPTED: '配置文件损坏或无法解析，已重新生成默认配置',
+  /** worktree 状态获取失败 */
+  WORKTREE_STATUS_UNAVAILABLE: '(状态不可用)',
+  /** 分隔线 */
+  SEPARATOR: '────────────────────────────────────────',
+  /** 粗分隔线 */
+  DOUBLE_SEPARATOR: '════════════════════════════════════════',
+} as const;

package/src/constants/messages/config.ts

@@ -0,0 +1,5 @@
+/** config 命令专属提示消息 */
+export const CONFIG_CMD_MESSAGES = {
+  /** 配置已恢复为默认值 */
+  CONFIG_RESET_SUCCESS: '✓ 配置已恢复为默认值',
+} as const;

package/src/constants/messages/create.ts

@@ -0,0 +1,5 @@
+/** create 命令专属提示消息 */
+export const CREATE_MESSAGES = {
+  /** 创建数量参数无效 */
+  INVALID_COUNT: (value: string) => `无效的创建数量: "${value}"，请输入正整数`,
+} as const;

package/src/constants/messages/index.ts

@@ -0,0 +1,29 @@
+import { COMMON_MESSAGES } from './common.js';
+import { RUN_MESSAGES } from './run.js';
+import { CREATE_MESSAGES } from './create.js';
+import { MERGE_MESSAGES } from './merge.js';
+import { VALIDATE_MESSAGES } from './validate.js';
+import { SYNC_MESSAGES } from './sync.js';
+import { RESUME_MESSAGES } from './resume.js';
+import { REMOVE_MESSAGES } from './remove.js';
+import { RESET_MESSAGES } from './reset.js';
+import { CONFIG_CMD_MESSAGES } from './config.js';
+import { STATUS_MESSAGES } from './status.js';
+
+/**
+ * 提示消息模板
+ * 合并所有子模块的消息，保持扁平结构以兼容现有的 MESSAGES.XXX 访问方式
+ */
+export const MESSAGES = {
+  ...COMMON_MESSAGES,
+  ...RUN_MESSAGES,
+  ...CREATE_MESSAGES,
+  ...MERGE_MESSAGES,
+  ...VALIDATE_MESSAGES,
+  ...SYNC_MESSAGES,
+  ...RESUME_MESSAGES,
+  ...REMOVE_MESSAGES,
+  ...RESET_MESSAGES,
+  ...CONFIG_CMD_MESSAGES,
+  ...STATUS_MESSAGES,
+} as const;

package/src/constants/messages/merge.ts

@@ -0,0 +1,42 @@
+/** merge 命令专属提示消息 */
+export const MERGE_MESSAGES = {
+  /** merge 成功 */
+  MERGE_SUCCESS: (branch: string, message: string, pushed: boolean) =>
+    `✓ 分支 ${branch} 已成功合并到当前分支\n  提交信息: ${message}${pushed ? '\n  已推送到远程仓库' : ''}`,
+  /** merge 成功（无提交信息，目标 worktree 已提交过） */
+  MERGE_SUCCESS_NO_MESSAGE: (branch: string, pushed: boolean) =>
+    `✓ 分支 ${branch} 已成功合并到当前分支${pushed ? '\n  已推送到远程仓库' : ''}`,
+  /** merge 冲突 */
+  MERGE_CONFLICT: '合并存在冲突，请手动处理：\n  解决冲突后执行 git add . && git merge --continue',
+  /** merge 后清理 worktree 和分支成功 */
+  WORKTREE_CLEANED: (branch: string) => `✓ 已清理 worktree 和分支: ${branch}`,
+  /** 目标 worktree 有未提交修改但未指定 -m */
+  TARGET_WORKTREE_DIRTY_NO_MESSAGE: '目标 worktree 有未提交的修改，请通过 -m 参数提供提交信息',
+  /** 目标 worktree 既干净又无本地提交 */
+  TARGET_WORKTREE_NO_CHANGES: '目标 worktree 没有任何可合并的变更（工作区干净且无本地提交）',
+  /** merge 命令检测到 validate 状态的提示 */
+  MERGE_VALIDATE_STATE_HINT: (branch: string) =>
+    `主 worktree 可能存在 validate 残留状态，可先执行 clawt validate -b ${branch} --clean 清理`,
+  /** merge 检测到 auto-save 提交，提示用户是否压缩 */
+  MERGE_SQUASH_PROMPT: '检测到 sync 产生的临时提交，是否将所有提交压缩为一个？\n  压缩后变更将保留在目标worktree的暂存区，需要重新提交（可使用 Claude Code Cli或其他工具生成提交信息）',
+  /** squash 完成且通过 -m 直接提交后的提示 */
+  MERGE_SQUASH_COMMITTED: (branch: string) =>
+    `✓ 已将分支 ${branch} 的所有提交压缩为一个`,
+  /** squash 完成但未提供 -m，提示用户自行提交 */
+  MERGE_SQUASH_PENDING: (worktreePath: string, branch: string) =>
+    `✓ 已将所有提交压缩到暂存区\n  请在目标 worktree 中提交后重新执行 merge：\n  cd ${worktreePath}\n  提交完成后执行：clawt merge -b ${branch}`,
+  /** merge 后 pull 冲突 */
+  PULL_CONFLICT:
+    '自动 pull 时发生冲突，merge 已完成但远程同步失败\n  请手动解决冲突：\n  解决冲突后执行 git add . && git commit\n  然后执行 git push 推送到远程',
+  /** push 失败 */
+  PUSH_FAILED: '自动 push 失败，merge 和 pull 已完成\n  请手动执行 git push',
+  /** merge 无可用 worktree */
+  MERGE_NO_WORKTREES: '当前项目没有可用的 worktree，请先通过 clawt run 或 clawt create 创建',
+  /** merge 模糊匹配无结果，列出可用分支 */
+  MERGE_NO_MATCH: (name: string, branches: string[]) =>
+    `未找到与 "${name}" 匹配的分支\n  可用分支：\n${branches.map((b) => `    - ${b}`).join('\n')}`,
+  /** merge 交互选择提示 */
+  MERGE_SELECT_BRANCH: '请选择要合并的分支',
+  /** merge 模糊匹配到多个结果提示 */
+  MERGE_MULTIPLE_MATCHES: (name: string) => `"${name}" 匹配到多个分支，请选择：`,
+} as const;

package/src/constants/messages/remove.ts

@@ -0,0 +1,15 @@
+/** remove 命令专属提示消息 */
+export const REMOVE_MESSAGES = {
+  /** remove 无可用 worktree */
+  REMOVE_NO_WORKTREES: '当前项目没有可用的 worktree，无需移除',
+  /** remove 多选交互提示 */
+  REMOVE_SELECT_BRANCH: '请选择要移除的分支（空格选择，回车确认）',
+  /** remove 模糊匹配到多个结果提示 */
+  REMOVE_MULTIPLE_MATCHES: (name: string) => `"${name}" 匹配到多个分支，请选择要移除的（空格选择，回车确认）：`,
+  /** remove 模糊匹配无结果，列出可用分支 */
+  REMOVE_NO_MATCH: (name: string, branches: string[]) =>
+    `未找到与 "${name}" 匹配的分支\n  可用分支：\n${branches.map((b) => `    - ${b}`).join('\n')}`,
+  /** 批量移除部分失败 */
+  REMOVE_PARTIAL_FAILURE: (failures: Array<{ path: string; error: string }>) =>
+    `以下 worktree 移除失败：\n${failures.map((f) => `  ✗ ${f.path}: ${f.error}`).join('\n')}`,
+} as const;

package/src/constants/messages/reset.ts

@@ -0,0 +1,7 @@
+/** reset 命令专属提示消息 */
+export const RESET_MESSAGES = {
+  /** reset 成功 */
+  RESET_SUCCESS: '✓ 主 worktree 工作区和暂存区已重置',
+  /** reset 时工作区和暂存区已干净 */
+  RESET_ALREADY_CLEAN: '主 worktree 工作区和暂存区已是干净状态，无需重置',
+} as const;

package/src/constants/messages/resume.ts

@@ -0,0 +1,12 @@
+/** resume 命令专属提示消息 */
+export const RESUME_MESSAGES = {
+  /** resume 无可用 worktree */
+  RESUME_NO_WORKTREES: '当前项目没有可用的 worktree，请先通过 clawt run 或 clawt create 创建',
+  /** 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}" 匹配到多个分支，请选择：`,
+} as const;

package/src/constants/messages/run.ts

@@ -0,0 +1,46 @@
+/** run 命令专属提示消息 */
+export const RUN_MESSAGES = {
+  /** 分支已存在时提示使用 resume */
+  BRANCH_EXISTS_USE_RESUME: (name: string) =>
+    `分支 ${name} 已存在，请使用 clawt resume -b ${name} 恢复会话`,
+  /** 检测到用户中断 */
+  INTERRUPTED: '检测到退出指令，已停止 Claude Code 任务',
+  /** 中断后自动清理完成 */
+  INTERRUPT_AUTO_CLEANED: (count: number) => `✓ 已自动清理 ${count} 个 worktree 和对应分支`,
+  /** 中断后手动确认清理 */
+  INTERRUPT_CONFIRM_CLEANUP: '是否移除刚刚创建的 worktree 和对应分支？',
+  /** 中断后清理完成 */
+  INTERRUPT_CLEANED: (count: number) => `✓ 已清理 ${count} 个 worktree 和对应分支`,
+  /** 中断后保留 worktree */
+  INTERRUPT_KEPT: '已保留 worktree，可稍后使用 clawt remove 手动清理',
+  /** 非 TTY 环境降级输出：任务启动 */
+  PROGRESS_TASK_STARTED: (index: number, total: number, branch: string, path: string) =>
+    `[${index}/${total}] ${branch} 启动  ${path}`,
+  /** 非 TTY 环境降级输出：任务完成 */
+  PROGRESS_TASK_DONE: (index: number, total: number, branch: string, duration: string, cost: string, path: string) =>
+    `[${index}/${total}] ${branch} ✓ 完成 ${duration} ${cost}  ${path}`,
+  /** 非 TTY 环境降级输出：任务失败 */
+  PROGRESS_TASK_FAILED: (index: number, total: number, branch: string, duration: string, path: string) =>
+    `[${index}/${total}] ${branch} ✗ 失败 ${duration}  ${path}`,
+  /** 并发限制提示 */
+  CONCURRENCY_INFO: (concurrency: number, total: number) =>
+    `并发限制: ${concurrency}，共 ${total} 个任务`,
+  /** 并发数无效提示 */
+  CONCURRENCY_INVALID: '并发数必须为正整数',
+  /** 任务文件不存在 */
+  TASK_FILE_NOT_FOUND: (path: string) => `任务文件不存在: ${path}`,
+  /** 任务文件中没有解析到有效任务 */
+  TASK_FILE_EMPTY: '任务文件中没有解析到有效任务',
+  /** 任务文件中某个任务块缺少分支名 */
+  TASK_FILE_MISSING_BRANCH: (blockIndex: number) => `任务文件第 ${blockIndex} 个任务块缺少分支名（# branch: ...）`,
+  /** 任务文件中某个任务块缺少任务描述 */
+  TASK_FILE_MISSING_TASK: (branch: string) => `任务文件中分支 ${branch} 缺少任务描述`,
+  /** 任务文件中某个任务块缺少任务描述（无分支名时按索引定位） */
+  TASK_FILE_MISSING_TASK_BY_INDEX: (blockIndex: number) => `任务文件第 ${blockIndex} 个任务块缺少任务描述`,
+  /** --file 和 --tasks 不能同时使用 */
+  FILE_AND_TASKS_CONFLICT: '--file 和 --tasks 不能同时使用',
+  /** 任务文件加载成功 */
+  TASK_FILE_LOADED: (count: number, path: string) => `✓ 从 ${path} 加载了 ${count} 个任务`,
+  /** 未指定 -b 或 -f */
+  BRANCH_OR_FILE_REQUIRED: '请指定 -b 分支名或 -f 任务文件',
+} as const;

package/src/constants/messages/status.ts

@@ -0,0 +1,25 @@
+/** status 命令专属提示消息 */
+export const STATUS_MESSAGES = {
+  /** status 命令标题 */
+  STATUS_TITLE: (projectName: string) => `项目状态总览: ${projectName}`,
+  /** status 主 worktree 区块标题 */
+  STATUS_MAIN_SECTION: '主 Worktree',
+  /** status worktrees 区块标题 */
+  STATUS_WORKTREES_SECTION: 'Worktree 列表',
+  /** status 快照区块标题 */
+  STATUS_SNAPSHOTS_SECTION: '未清理的 Validate 快照',
+  /** status 无 worktree */
+  STATUS_NO_WORKTREES: '(无活跃 worktree)',
+  /** status 无未清理快照 */
+  STATUS_NO_SNAPSHOTS: '(无未清理的快照)',
+  /** status 变更状态：已提交 */
+  STATUS_CHANGE_COMMITTED: '已提交',
+  /** status 变更状态：未提交修改 */
+  STATUS_CHANGE_UNCOMMITTED: '未提交修改',
+  /** status 变更状态：合并冲突 */
+  STATUS_CHANGE_CONFLICT: '合并冲突',
+  /** status 变更状态：无变更 */
+  STATUS_CHANGE_CLEAN: '无变更',
+  /** status 快照对应 worktree 已不存在 */
+  STATUS_SNAPSHOT_ORPHANED: '(对应 worktree 已不存在)',
+} as const;

package/src/constants/messages/sync.ts

@@ -0,0 +1,24 @@
+/** sync 命令专属提示消息 */
+export const SYNC_MESSAGES = {
+  /** sync 自动保存未提交变更 */
+  SYNC_AUTO_COMMITTED: (branch: string) =>
+    `已自动保存 ${branch} 分支的未提交变更`,
+  /** sync 开始合并 */
+  SYNC_MERGING: (targetBranch: string, mainBranch: string) =>
+    `正在将 ${mainBranch} 合并到 ${targetBranch} ...`,
+  /** sync 成功 */
+  SYNC_SUCCESS: (targetBranch: string, mainBranch: string) =>
+    `✓ 已将 ${mainBranch} 的最新代码同步到 ${targetBranch}`,
+  /** sync 冲突 */
+  SYNC_CONFLICT: (worktreePath: string) =>
+    `合并存在冲突，请进入目标 worktree 手动解决：\n  cd ${worktreePath}\n  解决冲突后执行 git add . && git merge --continue\n  clawt validate -b <branch> 验证变更`,
+  /** sync 无可用 worktree */
+  SYNC_NO_WORKTREES: '当前项目没有可用的 worktree，请先通过 clawt run 或 clawt create 创建',
+  /** sync 模糊匹配无结果，列出可用分支 */
+  SYNC_NO_MATCH: (name: string, branches: string[]) =>
+    `未找到与 "${name}" 匹配的分支\n  可用分支：\n${branches.map((b) => `    - ${b}`).join('\n')}`,
+  /** sync 交互选择提示 */
+  SYNC_SELECT_BRANCH: '请选择要同步的分支',
+  /** sync 模糊匹配到多个结果提示 */
+  SYNC_MULTIPLE_MATCHES: (name: string) => `"${name}" 匹配到多个分支，请选择：`,
+} as const;

package/src/constants/messages/validate.ts

@@ -0,0 +1,25 @@
+/** validate 命令专属提示消息 */
+export const VALIDATE_MESSAGES = {
+  /** validate 成功 */
+  VALIDATE_SUCCESS: (branch: string) =>
+    `✓ 已将分支 ${branch} 的变更应用到主 worktree\n  可以开始验证了`,
+  /** 增量 validate 成功提示 */
+  INCREMENTAL_VALIDATE_SUCCESS: (branch: string) =>
+    `✓ 已将分支 ${branch} 的最新变更应用到主 worktree（增量模式）\n  暂存区 = 上次快照，工作目录 = 最新变更`,
+  /** 增量 validate 降级为全量模式提示 */
+  INCREMENTAL_VALIDATE_FALLBACK: '增量对比失败，已降级为全量模式',
+  /** validate 状态已清理 */
+  VALIDATE_CLEANED: (branch: string) => `✓ 分支 ${branch} 的 validate 状态已清理`,
+  /** validate patch apply 失败，提示用户同步主分支 */
+  VALIDATE_PATCH_APPLY_FAILED: (branch: string) =>
+    `变更迁移失败：目标分支与主分支差异过大\n  请先执行 clawt sync -b ${branch} 同步主分支后重试`,
+  /** validate 无可用 worktree */
+  VALIDATE_NO_WORKTREES: '当前项目没有可用的 worktree，请先通过 clawt run 或 clawt create 创建',
+  /** validate 模糊匹配无结果，列出可用分支 */
+  VALIDATE_NO_MATCH: (name: string, branches: string[]) =>
+    `未找到与 "${name}" 匹配的分支\n  可用分支：\n${branches.map((b) => `    - ${b}`).join('\n')}`,
+  /** validate 交互选择提示 */
+  VALIDATE_SELECT_BRANCH: '请选择要验证的分支',
+  /** validate 模糊匹配到多个结果提示 */
+  VALIDATE_MULTIPLE_MATCHES: (name: string) => `"${name}" 匹配到多个分支，请选择：`,
+} as const;