clawt 2.16.0 → 2.16.2

package/README.md

@@ -123,11 +123,18 @@ clawt validate -b <branch>                    # 将变更迁移到主 worktree
 clawt validate -b <branch> --clean             # 清理 validate 状态
 clawt validate -b <branch> -r "npm test"       # validate 成功后自动运行测试
 clawt validate -b <branch> -r "npm run build"  # validate 成功后自动构建
+clawt validate -b <branch> -r "pnpm test & pnpm build"  # 并行执行多个命令
 ```
 
 支持增量模式：再次 validate 同一分支时，可通过 `git diff` 查看两次之间的增量差异。
 
-`-r, --run` 选项可在 validate 成功后自动在主 worktree 中执行指定命令（如测试、构建等），命令执行失败不影响 validate 结果。
+`-r, --run` 选项可在 validate 成功后自动在主 worktree 中执行指定命令（如测试、构建等），命令执行失败不影响 validate 结果。支持用 `&` 分隔多个命令并行执行：
+
+| 用法 | 行为 |
+| ---- | ---- |
+| `-r "npm test"` | 单命令，同步执行 |
+| `-r "npm lint && npm test"` | `&&` 不拆分，同步执行 |
+| `-r "pnpm test & pnpm build"` | 并行执行，等全部完成后汇总结果 |
 
 ### `clawt sync` — 同步主分支代码到目标 worktree
 

package/dist/index.js

@@ -197,7 +197,21 @@ ${branches.map((b) => `    - ${b}`).join("\n")}`,
   /** --run 命令执行失败（退出码非 0） */
   VALIDATE_RUN_FAILED: (command, exitCode) => `\u2717 \u547D\u4EE4\u6267\u884C\u5B8C\u6210: ${command}\uFF0C\u9000\u51FA\u7801: ${exitCode}`,
   /** --run 命令执行异常（进程启动失败等） */
-  VALIDATE_RUN_ERROR: (command, errorMessage) => `\u2717 \u547D\u4EE4\u6267\u884C\u51FA\u9519: ${errorMessage}`
+  VALIDATE_RUN_ERROR: (command, errorMessage) => `\u2717 \u547D\u4EE4\u6267\u884C\u51FA\u9519: ${errorMessage}`,
+  /** 并行命令开始执行提示 */
+  VALIDATE_PARALLEL_RUN_START: (count) => `\u6B63\u5728\u5E76\u884C\u6267\u884C ${count} \u4E2A\u547D\u4EE4...`,
+  /** 并行执行中单个命令开始提示（带序号） */
+  VALIDATE_PARALLEL_CMD_START: (index, total, command) => `[${index}/${total}] ${command}`,
+  /** 并行执行全部成功汇总提示 */
+  VALIDATE_PARALLEL_RUN_ALL_SUCCESS: (count) => `\u2713 \u5168\u90E8 ${count} \u4E2A\u547D\u4EE4\u6267\u884C\u6210\u529F`,
+  /** 并行执行部分失败汇总提示 */
+  VALIDATE_PARALLEL_RUN_SUMMARY: (successCount, failedCount) => `\u5171 ${successCount + failedCount} \u4E2A\u547D\u4EE4\uFF0C${successCount} \u4E2A\u6210\u529F\uFF0C${failedCount} \u4E2A\u5931\u8D25`,
+  /** 并行执行中单个命令成功 */
+  VALIDATE_PARALLEL_CMD_SUCCESS: (command) => `  \u2713 ${command}`,
+  /** 并行执行中单个命令失败 */
+  VALIDATE_PARALLEL_CMD_FAILED: (command, exitCode) => `  \u2717 ${command}\uFF08\u9000\u51FA\u7801: ${exitCode}\uFF09`,
+  /** 并行执行中单个命令启动失败 */
+  VALIDATE_PARALLEL_CMD_ERROR: (command, errorMessage) => `  \u2717 ${command}\uFF08\u9519\u8BEF: ${errorMessage}\uFF09`
 };
 
 // src/constants/messages/sync.ts
@@ -261,7 +275,9 @@ var REMOVE_MESSAGES = {
 ${branches.map((b) => `    - ${b}`).join("\n")}`,
   /** 批量移除部分失败 */
   REMOVE_PARTIAL_FAILURE: (failures) => `\u4EE5\u4E0B worktree \u79FB\u9664\u5931\u8D25\uFF1A
-${failures.map((f) => `  \u2717 ${f.path}: ${f.error}`).join("\n")}`
+${failures.map((f) => `  \u2717 ${f.path}: ${f.error}`).join("\n")}`,
+  /** 用户选择保留本地分支 */
+  REMOVE_BRANCHES_KEPT: "\u5DF2\u4FDD\u7559\u672C\u5730\u5206\u652F\uFF0C\u53EF\u7A0D\u540E\u4F7F\u7528 git branch -D <\u5206\u652F\u540D> \u624B\u52A8\u5220\u9664"
 };
 
 // src/constants/messages/reset.ts
@@ -571,6 +587,31 @@ function runCommandInherited(command, options) {
     shell: true
   });
 }
+function parseParallelCommands(commandString) {
+  const placeholder = "\0AND\0";
+  const escaped = commandString.replace(/&&/g, placeholder);
+  const parts = escaped.split("&");
+  return parts.map((part) => part.replace(new RegExp(placeholder, "g"), "&&").trim()).filter((part) => part.length > 0);
+}
+function runParallelCommands(commands, options) {
+  const promises = commands.map((command) => {
+    return new Promise((resolve2) => {
+      logger.debug(`\u5E76\u884C\u542F\u52A8\u547D\u4EE4: ${command}${options?.cwd ? ` (cwd: ${options.cwd})` : ""}`);
+      const child = spawn(command, {
+        cwd: options?.cwd,
+        stdio: "inherit",
+        shell: true
+      });
+      child.on("error", (err) => {
+        resolve2({ command, exitCode: 1, error: err.message });
+      });
+      child.on("close", (code) => {
+        resolve2({ command, exitCode: code ?? 1 });
+      });
+    });
+  });
+  return Promise.all(promises);
+}
 
 // src/utils/git.ts
 import { basename } from "path";
@@ -762,6 +803,9 @@ function printWarning(message) {
 function printInfo(message) {
   console.log(message);
 }
+function printHint(message) {
+  console.log(chalk2.hex("#FF8C00")(message));
+}
 function printSeparator() {
   console.log(MESSAGES.SEPARATOR);
 }
@@ -2062,6 +2106,9 @@ async function handleRemove(options) {
   let shouldDeleteBranch = autoDelete;
   if (!autoDelete) {
     shouldDeleteBranch = await confirmAction("\u662F\u5426\u540C\u65F6\u5220\u9664\u5BF9\u5E94\u7684\u672C\u5730\u5206\u652F\uFF1F");
+    if (!shouldDeleteBranch) {
+      printHint(MESSAGES.REMOVE_BRANCHES_KEPT);
+    }
   }
   const failures = [];
   for (const wt of worktreesToRemove) {
@@ -2384,8 +2431,7 @@ function handleIncrementalValidate(targetWorktreePath, mainWorktreePath, project
   }
   printSuccess(MESSAGES.INCREMENTAL_VALIDATE_SUCCESS(branchName));
 }
-function executeRunCommand(command, mainWorktreePath) {
-  printInfo("");
+function executeSingleCommand(command, mainWorktreePath) {
   printInfo(MESSAGES.VALIDATE_RUN_START(command));
   printSeparator();
   const result = runCommandInherited(command, { cwd: mainWorktreePath });
@@ -2401,6 +2447,43 @@ function executeRunCommand(command, mainWorktreePath) {
     printError(MESSAGES.VALIDATE_RUN_FAILED(command, exitCode));
   }
 }
+function reportParallelResults(results) {
+  printSeparator();
+  const successCount = results.filter((r) => r.exitCode === 0 && !r.error).length;
+  const failedCount = results.length - successCount;
+  for (const result of results) {
+    if (result.error) {
+      printError(MESSAGES.VALIDATE_PARALLEL_CMD_ERROR(result.command, result.error));
+    } else if (result.exitCode === 0) {
+      printSuccess(MESSAGES.VALIDATE_PARALLEL_CMD_SUCCESS(result.command));
+    } else {
+      printError(MESSAGES.VALIDATE_PARALLEL_CMD_FAILED(result.command, result.exitCode));
+    }
+  }
+  if (failedCount === 0) {
+    printSuccess(MESSAGES.VALIDATE_PARALLEL_RUN_ALL_SUCCESS(results.length));
+  } else {
+    printError(MESSAGES.VALIDATE_PARALLEL_RUN_SUMMARY(successCount, failedCount));
+  }
+}
+async function executeParallelCommands(commands, mainWorktreePath) {
+  printInfo(MESSAGES.VALIDATE_PARALLEL_RUN_START(commands.length));
+  for (let i = 0; i < commands.length; i++) {
+    printInfo(MESSAGES.VALIDATE_PARALLEL_CMD_START(i + 1, commands.length, commands[i]));
+  }
+  printSeparator();
+  const results = await runParallelCommands(commands, { cwd: mainWorktreePath });
+  reportParallelResults(results);
+}
+async function executeRunCommand(command, mainWorktreePath) {
+  printInfo("");
+  const commands = parseParallelCommands(command);
+  if (commands.length <= 1) {
+    executeSingleCommand(commands[0] || command, mainWorktreePath);
+  } else {
+    await executeParallelCommands(commands, mainWorktreePath);
+  }
+}
 async function handleValidate(options) {
   if (options.clean) {
     await handleValidateClean(options);
@@ -2433,7 +2516,7 @@ async function handleValidate(options) {
     handleFirstValidate(targetWorktreePath, mainWorktreePath, projectName, branchName, hasUncommitted);
   }
   if (options.run) {
-    executeRunCommand(options.run, mainWorktreePath);
+    await executeRunCommand(options.run, mainWorktreePath);
   }
 }
 

package/dist/postinstall.js

@@ -189,7 +189,21 @@ ${branches.map((b) => `    - ${b}`).join("\n")}`,
   /** --run 命令执行失败（退出码非 0） */
   VALIDATE_RUN_FAILED: (command, exitCode) => `\u2717 \u547D\u4EE4\u6267\u884C\u5B8C\u6210: ${command}\uFF0C\u9000\u51FA\u7801: ${exitCode}`,
   /** --run 命令执行异常（进程启动失败等） */
-  VALIDATE_RUN_ERROR: (command, errorMessage) => `\u2717 \u547D\u4EE4\u6267\u884C\u51FA\u9519: ${errorMessage}`
+  VALIDATE_RUN_ERROR: (command, errorMessage) => `\u2717 \u547D\u4EE4\u6267\u884C\u51FA\u9519: ${errorMessage}`,
+  /** 并行命令开始执行提示 */
+  VALIDATE_PARALLEL_RUN_START: (count) => `\u6B63\u5728\u5E76\u884C\u6267\u884C ${count} \u4E2A\u547D\u4EE4...`,
+  /** 并行执行中单个命令开始提示（带序号） */
+  VALIDATE_PARALLEL_CMD_START: (index, total, command) => `[${index}/${total}] ${command}`,
+  /** 并行执行全部成功汇总提示 */
+  VALIDATE_PARALLEL_RUN_ALL_SUCCESS: (count) => `\u2713 \u5168\u90E8 ${count} \u4E2A\u547D\u4EE4\u6267\u884C\u6210\u529F`,
+  /** 并行执行部分失败汇总提示 */
+  VALIDATE_PARALLEL_RUN_SUMMARY: (successCount, failedCount) => `\u5171 ${successCount + failedCount} \u4E2A\u547D\u4EE4\uFF0C${successCount} \u4E2A\u6210\u529F\uFF0C${failedCount} \u4E2A\u5931\u8D25`,
+  /** 并行执行中单个命令成功 */
+  VALIDATE_PARALLEL_CMD_SUCCESS: (command) => `  \u2713 ${command}`,
+  /** 并行执行中单个命令失败 */
+  VALIDATE_PARALLEL_CMD_FAILED: (command, exitCode) => `  \u2717 ${command}\uFF08\u9000\u51FA\u7801: ${exitCode}\uFF09`,
+  /** 并行执行中单个命令启动失败 */
+  VALIDATE_PARALLEL_CMD_ERROR: (command, errorMessage) => `  \u2717 ${command}\uFF08\u9519\u8BEF: ${errorMessage}\uFF09`
 };
 
 // src/constants/messages/sync.ts
@@ -253,7 +267,9 @@ var REMOVE_MESSAGES = {
 ${branches.map((b) => `    - ${b}`).join("\n")}`,
   /** 批量移除部分失败 */
   REMOVE_PARTIAL_FAILURE: (failures) => `\u4EE5\u4E0B worktree \u79FB\u9664\u5931\u8D25\uFF1A
-${failures.map((f) => `  \u2717 ${f.path}: ${f.error}`).join("\n")}`
+${failures.map((f) => `  \u2717 ${f.path}: ${f.error}`).join("\n")}`,
+  /** 用户选择保留本地分支 */
+  REMOVE_BRANCHES_KEPT: "\u5DF2\u4FDD\u7559\u672C\u5730\u5206\u652F\uFF0C\u53EF\u7A0D\u540E\u4F7F\u7528 git branch -D <\u5206\u652F\u540D> \u624B\u52A8\u5220\u9664"
 };
 
 // src/constants/messages/reset.ts

package/docs/spec.md

@@ -603,40 +603,104 @@ git restore --staged .
 如果用户传入了 `-r, --run` 选项，在 validate 成功后自动在主 worktree 中执行指定命令：
 
 ```bash
-# 示例
+# 示例：单命令
 clawt validate -b feature-scheme-1 -r "npm test"
+
+# 示例：并行执行多个命令（& 为并行分隔符）
+clawt validate -b feature-scheme-1 -r "pnpm test & pnpm build"
 ```
 
 **执行说明：**
 
-- 命令通过 `spawnSync` + `inherit` stdio 模式在主 worktree 中执行，输出实时显示在终端
 - 命令执行失败（退出码非 0 或进程启动失败）**不影响** validate 本身的结果，仅输出提示信息
 - `--clean` 模式下传入 `--run` 会被忽略（只执行 clean 逻辑）
 
+**命令解析规则：**
+
+`-r` 选项支持通过 `&` 将多个命令并行执行。解析由 `parseParallelCommands()`（`src/utils/shell.ts`）负责：
+
+1. 先将命令字符串中的 `&&` 临时替换为占位符，避免被误拆
+2. 按单个 `&` 分割为多个独立命令
+3. 还原占位符为 `&&`，去除首尾空白，过滤空串
+
+| 输入示例 | 解析结果 | 执行方式 |
+| -------- | -------- | -------- |
+| `"npm test"` | `["npm test"]` | 单命令，同步执行（`spawnSync` + `inherit`） |
+| `"npm lint && npm test"` | `["npm lint && npm test"]` | 单命令（`&&` 不拆分），同步执行 |
+| `"npm test & npm build"` | `["npm test", "npm build"]` | 并行执行（`spawn` + `Promise.all`） |
+| `"npm lint && npm test & npm build"` | `["npm lint && npm test", "npm build"]` | 并行执行 2 个命令 |
+
+**单命令执行：**
+
+当解析后只有 1 个命令时，通过 `spawnSync` + `inherit` stdio 模式同步执行，输出实时显示在终端。
+
+**并行命令执行：**
+
+当解析后有多个命令时，通过 `runParallelCommands()`（`src/utils/shell.ts`）执行：
+
+- 每个命令通过 Node.js `spawn` 以 shell 模式启动，`stdio: 'inherit'`
+- 使用 `Promise.all` 等待全部命令完成
+- 完成后汇总输出各命令的执行结果
+
+**向后兼容性：**
+
+- `-r "npm test"` — 单命令，走原有同步路径，行为无变化
+- `-r "npm lint && npm test"` — `&&` 不拆分，走原有同步路径，行为无变化
+- `-r "npm test & npm build"` — **新行为**：并行执行，等全部完成后汇总
+
 **输出格式：**
 
 ```
-# 命令执行成功
+# 单命令执行成功
 正在主 worktree 中执行命令: npm test
 ────────────────────────────────────────
 ... 命令的实时输出 ...
 ────────────────────────────────────────
 ✓ 命令执行完成: npm test，退出码: 0
 
-# 命令执行失败（退出码非 0）
+# 单命令执行失败（退出码非 0）
 正在主 worktree 中执行命令: npm test
 ────────────────────────────────────────
 ... 命令的实时输出 ...
 ────────────────────────────────────────
 ✗ 命令执行完成: npm test，退出码: 1
 
-# 命令执行出错（进程启动失败）
+# 单命令执行出错（进程启动失败）
 正在主 worktree 中执行命令: nonexistent
 ────────────────────────────────────────
 ────────────────────────────────────────
 ✗ 命令执行出错: spawn ENOENT
+
+# 并行命令执行（全部成功）
+正在并行执行 2 个命令...
+[1/2] pnpm test
+[2/2] pnpm build
+────────────────────────────────────────
+... 各命令的实时输出（交错显示） ...
+────────────────────────────────────────
+  ✓ pnpm test
+  ✓ pnpm build
+✓ 全部 2 个命令执行成功
+
+# 并行命令执行（部分失败）
+正在并行执行 2 个命令...
+[1/2] pnpm test
+[2/2] pnpm build
+────────────────────────────────────────
+... 各命令的实时输出（交错显示） ...
+────────────────────────────────────────
+  ✗ pnpm test（退出码: 1）
+  ✓ pnpm build
+共 2 个命令，1 个成功，1 个失败
 ```
 
+**实现要点：**
+
+- 命令解析：`parseParallelCommands()`（`src/utils/shell.ts`）
+- 并行执行：`runParallelCommands()`（`src/utils/shell.ts`），返回 `ParallelCommandResult[]`
+- 结果汇总：`reportParallelResults()`（`src/commands/validate.ts`）
+- 消息常量：`MESSAGES.VALIDATE_PARALLEL_*` 系列（`src/constants/messages/validate.ts`）
+
 #### 增量 validate（存在历史快照）
 
 当 `~/.clawt/validate-snapshots/<project>/<branchName>.tree` 存在时，自动进入增量模式：

package/package.json

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

package/src/commands/remove.ts

@@ -16,6 +16,7 @@ import {
   printInfo,
   printSuccess,
   printError,
+  printHint,
   confirmAction,
   removeSnapshot,
   removeProjectSnapshots,
@@ -85,6 +86,9 @@ async function handleRemove(options: RemoveOptions): Promise<void> {
 
   if (!autoDelete) {
     shouldDeleteBranch = await confirmAction('是否同时删除对应的本地分支？');
+    if (!shouldDeleteBranch) {
+      printHint(MESSAGES.REMOVE_BRANCHES_KEPT);
+    }
   }
 
   // 执行移除，收集失败项

package/src/commands/validate.ts

@@ -40,8 +40,10 @@ import {
   printSeparator,
   resolveTargetWorktree,
   runCommandInherited,
+  parseParallelCommands,
+  runParallelCommands,
 } from '../utils/index.js';
-import type { WorktreeResolveMessages } from '../utils/index.js';
+import type { WorktreeResolveMessages, ParallelCommandResult } from '../utils/index.js';
 
 /** validate 命令的分支解析消息配置 */
 const VALIDATE_RESOLVE_MESSAGES: WorktreeResolveMessages = {
@@ -305,13 +307,11 @@ function handleIncrementalValidate(targetWorktreePath: string, mainWorktreePath:
 }
 
 /**
- * 在主 worktree 中执行用户指定的命令
- * 命令执行失败不影响 validate 本身的结果，仅输出提示
+ * 执行单个命令（同步方式，保持原有行为不变）
  * @param {string} command - 要执行的命令字符串
  * @param {string} mainWorktreePath - 主 worktree 路径
  */
-function executeRunCommand(command: string, mainWorktreePath: string): void {
-  printInfo('');
+function executeSingleCommand(command: string, mainWorktreePath: string): void {
   printInfo(MESSAGES.VALIDATE_RUN_START(command));
   printSeparator();
 
@@ -333,6 +333,73 @@ function executeRunCommand(command: string, mainWorktreePath: string): void {
   }
 }
 
+/**
+ * 汇总输出并行命令的执行结果
+ * @param {ParallelCommandResult[]} results - 各命令的执行结果数组
+ */
+function reportParallelResults(results: ParallelCommandResult[]): void {
+  printSeparator();
+
+  const successCount = results.filter((r) => r.exitCode === 0 && !r.error).length;
+  const failedCount = results.length - successCount;
+
+  for (const result of results) {
+    if (result.error) {
+      printError(MESSAGES.VALIDATE_PARALLEL_CMD_ERROR(result.command, result.error));
+    } else if (result.exitCode === 0) {
+      printSuccess(MESSAGES.VALIDATE_PARALLEL_CMD_SUCCESS(result.command));
+    } else {
+      printError(MESSAGES.VALIDATE_PARALLEL_CMD_FAILED(result.command, result.exitCode));
+    }
+  }
+
+  if (failedCount === 0) {
+    printSuccess(MESSAGES.VALIDATE_PARALLEL_RUN_ALL_SUCCESS(results.length));
+  } else {
+    printError(MESSAGES.VALIDATE_PARALLEL_RUN_SUMMARY(successCount, failedCount));
+  }
+}
+
+/**
+ * 并行执行多个命令并汇总结果
+ * @param {string[]} commands - 要并行执行的命令数组
+ * @param {string} mainWorktreePath - 主 worktree 路径
+ */
+async function executeParallelCommands(commands: string[], mainWorktreePath: string): Promise<void> {
+  printInfo(MESSAGES.VALIDATE_PARALLEL_RUN_START(commands.length));
+
+  for (let i = 0; i < commands.length; i++) {
+    printInfo(MESSAGES.VALIDATE_PARALLEL_CMD_START(i + 1, commands.length, commands[i]));
+  }
+
+  printSeparator();
+
+  const results = await runParallelCommands(commands, { cwd: mainWorktreePath });
+
+  reportParallelResults(results);
+}
+
+/**
+ * 在主 worktree 中执行用户指定的命令
+ * 根据命令字符串中的 & 分隔符决定是单命令执行还是并行执行
+ * 命令执行失败不影响 validate 本身的结果，仅输出提示
+ * @param {string} command - 要执行的命令字符串
+ * @param {string} mainWorktreePath - 主 worktree 路径
+ */
+async function executeRunCommand(command: string, mainWorktreePath: string): Promise<void> {
+  printInfo('');
+
+  const commands = parseParallelCommands(command);
+
+  if (commands.length <= 1) {
+    // 单命令（包括含 && 的串行命令），走原有同步路径
+    executeSingleCommand(commands[0] || command, mainWorktreePath);
+  } else {
+    // 多命令，并行执行
+    await executeParallelCommands(commands, mainWorktreePath);
+  }
+}
+
 /**
  * 执行 validate 命令的核心逻辑
  * @param {ValidateOptions} options - 命令选项
@@ -386,6 +453,6 @@ async function handleValidate(options: ValidateOptions): Promise<void> {
 
   // validate 成功后执行用户指定的命令
   if (options.run) {
-    executeRunCommand(options.run, mainWorktreePath);
+    await executeRunCommand(options.run, mainWorktreePath);
   }
 }

package/src/constants/messages/remove.ts

@@ -12,4 +12,6 @@ export const REMOVE_MESSAGES = {
   /** 批量移除部分失败 */
   REMOVE_PARTIAL_FAILURE: (failures: Array<{ path: string; error: string }>) =>
     `以下 worktree 移除失败：\n${failures.map((f) => `  ✗ ${f.path}: ${f.error}`).join('\n')}`,
+  /** 用户选择保留本地分支 */
+  REMOVE_BRANCHES_KEPT: '已保留本地分支，可稍后使用 git branch -D <分支名> 手动删除',
 } as const;

package/src/constants/messages/validate.ts

@@ -32,4 +32,25 @@ export const VALIDATE_MESSAGES = {
   /** --run 命令执行异常（进程启动失败等） */
   VALIDATE_RUN_ERROR: (command: string, errorMessage: string) =>
     `✗ 命令执行出错: ${errorMessage}`,
+  /** 并行命令开始执行提示 */
+  VALIDATE_PARALLEL_RUN_START: (count: number) =>
+    `正在并行执行 ${count} 个命令...`,
+  /** 并行执行中单个命令开始提示（带序号） */
+  VALIDATE_PARALLEL_CMD_START: (index: number, total: number, command: string) =>
+    `[${index}/${total}] ${command}`,
+  /** 并行执行全部成功汇总提示 */
+  VALIDATE_PARALLEL_RUN_ALL_SUCCESS: (count: number) =>
+    `✓ 全部 ${count} 个命令执行成功`,
+  /** 并行执行部分失败汇总提示 */
+  VALIDATE_PARALLEL_RUN_SUMMARY: (successCount: number, failedCount: number) =>
+    `共 ${successCount + failedCount} 个命令，${successCount} 个成功，${failedCount} 个失败`,
+  /** 并行执行中单个命令成功 */
+  VALIDATE_PARALLEL_CMD_SUCCESS: (command: string) =>
+    `  ✓ ${command}`,
+  /** 并行执行中单个命令失败 */
+  VALIDATE_PARALLEL_CMD_FAILED: (command: string, exitCode: number) =>
+    `  ✗ ${command}（退出码: ${exitCode}）`,
+  /** 并行执行中单个命令启动失败 */
+  VALIDATE_PARALLEL_CMD_ERROR: (command: string, errorMessage: string) =>
+    `  ✗ ${command}（错误: ${errorMessage}）`,
 } as const;

package/src/utils/formatter.ts

@@ -35,6 +35,14 @@ export function printInfo(message: string): void {
   console.log(message);
 }
 
+/**
+ * 输出提示信息（橙色）
+ * @param {string} message - 消息内容
+ */
+export function printHint(message: string): void {
+  console.log(chalk.hex('#FF8C00')(message));
+}
+
 /**
  * 输出分隔线
  */

package/src/utils/index.ts

@@ -1,4 +1,5 @@
-export { execCommand, spawnProcess, killAllChildProcesses, execCommandWithInput, runCommandInherited } from './shell.js';
+export { execCommand, spawnProcess, killAllChildProcesses, execCommandWithInput, runCommandInherited, parseParallelCommands, runParallelCommands } from './shell.js';
+export type { ParallelCommandResult } from './shell.js';
 export {
   getGitCommonDir,
   getGitTopLevel,
@@ -49,7 +50,7 @@ export { sanitizeBranchName, generateBranchNames, validateBranchesNotExist } fro
 export { validateMainWorktree, validateGitInstalled, validateClaudeCodeInstalled } from './validation.js';
 export { createWorktrees, getProjectWorktrees, getProjectWorktreeDir, cleanupWorktrees, getWorktreeStatus, createWorktreesByBranches } from './worktree.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 { printSuccess, printError, printWarning, printInfo, printHint, printSeparator, printDoubleSeparator, confirmAction, confirmDestructiveAction, formatWorktreeStatus, isWorktreeIdle, formatDuration } from './formatter.js';
 export { ensureDir, removeEmptyDir } from './fs.js';
 export { multilineInput } from './prompt.js';
 export { launchInteractiveClaude, hasClaudeSessionHistory, launchInteractiveClaudeInNewTerminal } from './claude.js';

package/src/utils/shell.ts

@@ -1,6 +1,16 @@
 import { execSync, execFileSync, spawn, spawnSync, type ChildProcess, type SpawnSyncReturns, type StdioOptions } from 'node:child_process';
 import { logger } from '../logger/index.js';
 
+/** 并行命令执行的单个结果 */
+export interface ParallelCommandResult {
+  /** 执行的命令字符串 */
+  command: string;
+  /** 进程退出码 */
+  exitCode: number;
+  /** 进程启动失败时的错误信息 */
+  error?: string;
+}
+
 /**
  * 同步执行 shell 命令并返回 stdout
  * @param {string} command - 要执行的命令
@@ -92,3 +102,58 @@ export function runCommandInherited(
     shell: true,
   });
 }
+
+/**
+ * 解析命令字符串中的并行分隔符 `&`，将其拆分为多个独立命令
+ * `&&` 不会被拆分（属于 shell 的串行逻辑与操作符）
+ * @param {string} commandString - 命令字符串
+ * @returns {string[]} 拆分后的命令数组
+ */
+export function parseParallelCommands(commandString: string): string[] {
+  // 将 && 临时替换为占位符，避免被 & 分割逻辑误拆
+  const placeholder = '\x00AND\x00';
+  const escaped = commandString.replace(/&&/g, placeholder);
+
+  // 按单个 & 分割
+  const parts = escaped.split('&');
+
+  // 还原占位符为 &&，并去除首尾空白
+  return parts
+    .map((part) => part.replace(new RegExp(placeholder, 'g'), '&&').trim())
+    .filter((part) => part.length > 0);
+}
+
+/**
+ * 并行执行多个命令，等待全部完成后返回结果
+ * 每个命令通过 spawn 以 shell 模式启动，stdio 继承父进程（实时输出到终端）
+ * @param {string[]} commands - 要并行执行的命令数组
+ * @param {object} options - 可选配置
+ * @param {string} options.cwd - 工作目录
+ * @returns {Promise<ParallelCommandResult[]>} 各命令的执行结果
+ */
+export function runParallelCommands(
+  commands: string[],
+  options?: { cwd?: string },
+): Promise<ParallelCommandResult[]> {
+  const promises = commands.map((command) => {
+    return new Promise<ParallelCommandResult>((resolve) => {
+      logger.debug(`并行启动命令: ${command}${options?.cwd ? ` (cwd: ${options.cwd})` : ''}`);
+
+      const child = spawn(command, {
+        cwd: options?.cwd,
+        stdio: 'inherit',
+        shell: true,
+      });
+
+      child.on('error', (err) => {
+        resolve({ command, exitCode: 1, error: err.message });
+      });
+
+      child.on('close', (code) => {
+        resolve({ command, exitCode: code ?? 1 });
+      });
+    });
+  });
+
+  return Promise.all(promises);
+}

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

@@ -24,6 +24,7 @@ vi.mock('../../../src/constants/index.js', () => ({
     REMOVE_SELECT_BRANCH: '请选择要移除的分支（空格选择，回车确认）',
     REMOVE_MULTIPLE_MATCHES: (name: string) => `"${name}" 匹配到多个分支`,
     REMOVE_NO_MATCH: (name: string, branches: string[]) => `未找到与 "${name}" 匹配的分支，可用：${branches.join(', ')}`,
+    REMOVE_BRANCHES_KEPT: '已保留本地分支，可稍后使用 git branch -D <分支名> 手动删除',
   },
 }));
 
@@ -40,6 +41,7 @@ vi.mock('../../../src/utils/index.js', () => ({
   printInfo: vi.fn(),
   printSuccess: vi.fn(),
   printError: vi.fn(),
+  printHint: vi.fn(),
   confirmAction: vi.fn(),
   removeSnapshot: vi.fn(),
   removeProjectSnapshots: vi.fn(),
@@ -59,6 +61,7 @@ import {
   removeProjectSnapshots,
   printSuccess,
   printError,
+  printHint,
   resolveTargetWorktrees,
 } from '../../../src/utils/index.js';
 
@@ -72,6 +75,7 @@ const mockedRemoveSnapshot = vi.mocked(removeSnapshot);
 const mockedRemoveProjectSnapshots = vi.mocked(removeProjectSnapshots);
 const mockedPrintSuccess = vi.mocked(printSuccess);
 const mockedPrintError = vi.mocked(printError);
+const mockedPrintHint = vi.mocked(printHint);
 const mockedResolveTargetWorktrees = vi.mocked(resolveTargetWorktrees);
 
 beforeEach(() => {
@@ -86,6 +90,7 @@ beforeEach(() => {
   mockedRemoveProjectSnapshots.mockReset();
   mockedPrintSuccess.mockReset();
   mockedPrintError.mockReset();
+  mockedPrintHint.mockReset();
   mockedResolveTargetWorktrees.mockReset();
 });
 
@@ -199,6 +204,8 @@ describe('handleRemove', () => {
     expect(mockedConfirmAction).toHaveBeenCalled();
     // 用户拒绝删除分支
     expect(mockedDeleteBranch).not.toHaveBeenCalled();
+    // 应提示用户分支已保留
+    expect(mockedPrintHint).toHaveBeenCalledWith('已保留本地分支，可稍后使用 git branch -D <分支名> 手动删除');
   });
 
   it('-b 指定不存在的分支时 resolveTargetWorktrees 抛出错误', async () => {

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

@@ -32,6 +32,13 @@ vi.mock('../../../src/constants/index.js', () => ({
     VALIDATE_RUN_SUCCESS: (cmd: string) => `✓ 命令执行完成: ${cmd}`,
     VALIDATE_RUN_FAILED: (cmd: string, code: number) => `✗ 命令失败: ${cmd}，退出码: ${code}`,
     VALIDATE_RUN_ERROR: (cmd: string, msg: string) => `✗ 命令出错: ${msg}`,
+    VALIDATE_PARALLEL_RUN_START: (count: number) => `正在并行执行 ${count} 个命令...`,
+    VALIDATE_PARALLEL_CMD_START: (index: number, total: number, cmd: string) => `[${index}/${total}] ${cmd}`,
+    VALIDATE_PARALLEL_RUN_ALL_SUCCESS: (count: number) => `✓ 全部 ${count} 个命令执行成功`,
+    VALIDATE_PARALLEL_RUN_SUMMARY: (s: number, f: number) => `共 ${s + f} 个命令，${s} 个成功，${f} 个失败`,
+    VALIDATE_PARALLEL_CMD_SUCCESS: (cmd: string) => `  ✓ ${cmd}`,
+    VALIDATE_PARALLEL_CMD_FAILED: (cmd: string, code: number) => `  ✗ ${cmd}（退出码: ${code}）`,
+    VALIDATE_PARALLEL_CMD_ERROR: (cmd: string, msg: string) => `  ✗ ${cmd}（错误: ${msg}）`,
     SEPARATOR: '────',
   },
 }));
@@ -79,6 +86,8 @@ vi.mock('../../../src/utils/index.js', () => ({
   runCommandInherited: vi.fn(),
   printError: vi.fn(),
   printSeparator: vi.fn(),
+  parseParallelCommands: vi.fn(),
+  runParallelCommands: vi.fn(),
 }));
 
 import { registerValidateCommand } from '../../../src/commands/validate.js';
@@ -116,6 +125,8 @@ import {
   runCommandInherited,
   printError,
   printSeparator,
+  parseParallelCommands,
+  runParallelCommands,
 } from '../../../src/utils/index.js';
 
 const mockedGetProjectName = vi.mocked(getProjectName);
@@ -151,6 +162,8 @@ const mockedPrintWarning = vi.mocked(printWarning);
 const mockedRunCommandInherited = vi.mocked(runCommandInherited);
 const mockedPrintError = vi.mocked(printError);
 const mockedPrintSeparator = vi.mocked(printSeparator);
+const mockedParseParallelCommands = vi.mocked(parseParallelCommands);
+const mockedRunParallelCommands = vi.mocked(runParallelCommands);
 
 const worktree = { path: '/path/feature', branch: 'feature' };
 
@@ -188,6 +201,10 @@ beforeEach(() => {
   mockedRunCommandInherited.mockReset();
   mockedPrintError.mockReset();
   mockedPrintSeparator.mockReset();
+  mockedParseParallelCommands.mockReset();
+  mockedRunParallelCommands.mockReset();
+  // 默认让 parseParallelCommands 返回单命令数组，保持旧测试兼容
+  mockedParseParallelCommands.mockImplementation((cmd: string) => [cmd]);
 });
 
 describe('registerValidateCommand', () => {
@@ -516,3 +533,89 @@ describe('--run 选项', () => {
     expect(mockedRunCommandInherited).not.toHaveBeenCalled();
   });
 });
+
+describe('--run 并行命令', () => {
+  /** 设置首次 validate 成功的公共 mock */
+  function setupSuccessfulFirstValidate(): void {
+    mockedIsWorkingDirClean.mockReturnValue(true);
+    mockedHasLocalCommits.mockReturnValue(true);
+    mockedHasSnapshot.mockReturnValue(false);
+    mockedGitDiffBinaryAgainstBranch.mockReturnValue(Buffer.from('diff'));
+    mockedGitWriteTree.mockReturnValue('treehash');
+    mockedGetHeadCommitHash.mockReturnValue('headhash');
+  }
+
+  it('& 分隔的命令触发并行执行', async () => {
+    setupSuccessfulFirstValidate();
+    mockedParseParallelCommands.mockReturnValue(['pnpm test', 'pnpm build']);
+    mockedRunParallelCommands.mockResolvedValue([
+      { command: 'pnpm test', exitCode: 0 },
+      { command: 'pnpm build', exitCode: 0 },
+    ]);
+
+    const program = new Command();
+    program.exitOverride();
+    registerValidateCommand(program);
+    await program.parseAsync(['validate', '-b', 'feature', '-r', 'pnpm test & pnpm build'], { from: 'user' });
+
+    // 应该调用并行执行而非同步执行
+    expect(mockedRunParallelCommands).toHaveBeenCalledWith(['pnpm test', 'pnpm build'], { cwd: '/repo' });
+    expect(mockedRunCommandInherited).not.toHaveBeenCalled();
+    // 全部成功，printSuccess 被调用（validate 成功 + 各命令成功 + 汇总成功）
+    expect(mockedPrintSuccess).toHaveBeenCalled();
+  });
+
+  it('并行执行部分失败时输出错误汇总', async () => {
+    setupSuccessfulFirstValidate();
+    mockedParseParallelCommands.mockReturnValue(['pnpm test', 'pnpm build']);
+    mockedRunParallelCommands.mockResolvedValue([
+      { command: 'pnpm test', exitCode: 1 },
+      { command: 'pnpm build', exitCode: 0 },
+    ]);
+
+    const program = new Command();
+    program.exitOverride();
+    registerValidateCommand(program);
+    await program.parseAsync(['validate', '-b', 'feature', '-r', 'pnpm test & pnpm build'], { from: 'user' });
+
+    expect(mockedRunParallelCommands).toHaveBeenCalled();
+    // 部分失败，应有错误输出
+    expect(mockedPrintError).toHaveBeenCalled();
+  });
+
+  it('单命令走原有同步路径不触发并行', async () => {
+    setupSuccessfulFirstValidate();
+    mockedParseParallelCommands.mockReturnValue(['npm test']);
+    mockedRunCommandInherited.mockReturnValue({
+      pid: 0, output: [], stdout: Buffer.alloc(0), stderr: Buffer.alloc(0),
+      status: 0, signal: null, error: undefined,
+    });
+
+    const program = new Command();
+    program.exitOverride();
+    registerValidateCommand(program);
+    await program.parseAsync(['validate', '-b', 'feature', '-r', 'npm test'], { from: 'user' });
+
+    // 单命令应该走同步路径
+    expect(mockedRunCommandInherited).toHaveBeenCalledWith('npm test', { cwd: '/repo' });
+    expect(mockedRunParallelCommands).not.toHaveBeenCalled();
+  });
+
+  it('&& 命令不触发并行执行', async () => {
+    setupSuccessfulFirstValidate();
+    mockedParseParallelCommands.mockReturnValue(['pnpm lint && pnpm test']);
+    mockedRunCommandInherited.mockReturnValue({
+      pid: 0, output: [], stdout: Buffer.alloc(0), stderr: Buffer.alloc(0),
+      status: 0, signal: null, error: undefined,
+    });
+
+    const program = new Command();
+    program.exitOverride();
+    registerValidateCommand(program);
+    await program.parseAsync(['validate', '-b', 'feature', '-r', 'pnpm lint && pnpm test'], { from: 'user' });
+
+    // && 不拆分，走同步路径
+    expect(mockedRunCommandInherited).toHaveBeenCalledWith('pnpm lint && pnpm test', { cwd: '/repo' });
+    expect(mockedRunParallelCommands).not.toHaveBeenCalled();
+  });
+});

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

@@ -13,7 +13,7 @@ vi.mock('../../../src/logger/index.js', () => ({
 }));
 
 import { execSync, execFileSync, spawn } from 'node:child_process';
-import { execCommand, execCommandWithInput, spawnProcess, killAllChildProcesses } from '../../../src/utils/shell.js';
+import { execCommand, execCommandWithInput, spawnProcess, killAllChildProcesses, parseParallelCommands } from '../../../src/utils/shell.js';
 
 const mockedExecSync = vi.mocked(execSync);
 const mockedExecFileSync = vi.mocked(execFileSync);
@@ -106,3 +106,44 @@ describe('killAllChildProcesses', () => {
     expect(() => killAllChildProcesses([])).not.toThrow();
   });
 });
+
+describe('parseParallelCommands', () => {
+  it('单个命令返回包含该命令的数组', () => {
+    expect(parseParallelCommands('pnpm test')).toEqual(['pnpm test']);
+  });
+
+  it('使用 & 分隔的多个命令被正确拆分', () => {
+    expect(parseParallelCommands('pnpm test & pnpm build')).toEqual(['pnpm test', 'pnpm build']);
+  });
+
+  it('&& 不会被拆分，保持为单条命令', () => {
+    expect(parseParallelCommands('pnpm lint && pnpm test')).toEqual(['pnpm lint && pnpm test']);
+  });
+
+  it('混合场景：&& 和 & 同时存在', () => {
+    expect(parseParallelCommands('pnpm lint && pnpm test & pnpm build')).toEqual([
+      'pnpm lint && pnpm test',
+      'pnpm build',
+    ]);
+  });
+
+  it('多个 & 分隔的命令', () => {
+    expect(parseParallelCommands('cmd1 & cmd2 & cmd3')).toEqual(['cmd1', 'cmd2', 'cmd3']);
+  });
+
+  it('空字符串返回空数组', () => {
+    expect(parseParallelCommands('')).toEqual([]);
+  });
+
+  it('去除命令首尾空白', () => {
+    expect(parseParallelCommands('  pnpm test  &  pnpm build  ')).toEqual(['pnpm test', 'pnpm build']);
+  });
+
+  it('多个 && 不拆分', () => {
+    expect(parseParallelCommands('cmd1 && cmd2 && cmd3')).toEqual(['cmd1 && cmd2 && cmd3']);
+  });
+
+  it('尾部 & 后无内容时过滤空字符串', () => {
+    expect(parseParallelCommands('pnpm test & ')).toEqual(['pnpm test']);
+  });
+});