clawt 3.5.1 → 3.5.2

package/dist/index.js

@@ -250,7 +250,19 @@ ${branches.map((b) => `    - ${b}`).join("\n")}`,
   VALIDATE_BRANCH_NOT_FOUND: (validateBranch, branch) => `\u9A8C\u8BC1\u5206\u652F ${validateBranch} \u4E0D\u5B58\u5728\uFF0C\u8BF7\u5148\u6267\u884C clawt create \u6216 clawt run \u521B\u5EFA\u5206\u652F ${branch}`,
   /** validate 成功（含验证分支信息） */
   VALIDATE_SUCCESS_WITH_BRANCH: (branch, validateBranch) => `\u2713 \u5DF2\u5207\u6362\u5230\u9A8C\u8BC1\u5206\u652F ${validateBranch} \u5E76\u5E94\u7528\u5206\u652F ${branch} \u7684\u53D8\u66F4
-  \u53EF\u4EE5\u5F00\u59CB\u9A8C\u8BC1\u4E86`
+  \u53EF\u4EE5\u5F00\u59CB\u9A8C\u8BC1\u4E86`,
+  /** 错误信息已复制到剪贴板提示 */
+  VALIDATE_RUN_ERROR_COPIED: "\u2702 \u9519\u8BEF\u4FE1\u606F\u5DF2\u590D\u5236\u5230\u526A\u8D34\u677F",
+  /** 剪贴板复制失败提示 */
+  VALIDATE_RUN_ERROR_COPY_FAILED: "\u26A0 \u9519\u8BEF\u4FE1\u606F\u590D\u5236\u5230\u526A\u8D34\u677F\u5931\u8D25",
+  /** 单命令（含 && 链）剪贴板错误格式 */
+  VALIDATE_CLIPBOARD_SINGLE_ERROR: (command, stderr) => `${command} \u6307\u4EE4\u6267\u884C\u51FA\u9519\uFF0C\u9519\u8BEF\u4FE1\u606F\uFF1A
+${stderr}`,
+  /** 并行命令中单个命令的剪贴板错误格式 */
+  VALIDATE_CLIPBOARD_PARALLEL_ERROR: (command, stderr) => `${command} \u6307\u4EE4\u6267\u884C\u51FA\u9519\uFF0C\u9519\u8BEF\u4FE1\u606F\uFF1A
+${stderr}`,
+  /** 多个错误之间的分隔符 */
+  VALIDATE_CLIPBOARD_SEPARATOR: "\n\n---\n\n"
 };
 
 // src/constants/messages/sync.ts
@@ -979,26 +991,83 @@ function parseParallelCommands(commandString) {
   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((resolve4) => {
-      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) => {
-        resolve4({ command, exitCode: 1, error: err.message });
+function spawnWithStderrCapture(command, options) {
+  return new Promise((resolve4) => {
+    const child = spawn(command, {
+      cwd: options?.cwd,
+      stdio: ["inherit", "inherit", "pipe"],
+      shell: true
+    });
+    const stderrChunks = [];
+    child.stderr?.on("data", (chunk) => {
+      process.stderr.write(chunk);
+      stderrChunks.push(chunk);
+    });
+    child.on("error", (err) => {
+      resolve4({
+        exitCode: 1,
+        error: err.message,
+        stderr: Buffer.concat(stderrChunks).toString("utf-8")
       });
-      child.on("close", (code) => {
-        resolve4({ command, exitCode: code ?? 1 });
+    });
+    child.on("close", (code) => {
+      resolve4({
+        exitCode: code ?? 1,
+        stderr: Buffer.concat(stderrChunks).toString("utf-8")
       });
     });
   });
+}
+function runCommandWithStderrCapture(command, options) {
+  logger.debug(`\u6267\u884C\u547D\u4EE4(stderr\u6355\u83B7): ${command}${options?.cwd ? ` (cwd: ${options.cwd})` : ""}`);
+  return spawnWithStderrCapture(command, options);
+}
+function runParallelCommandsWithStderrCapture(commands, options) {
+  const promises = commands.map(async (command) => {
+    logger.debug(`\u5E76\u884C\u542F\u52A8\u547D\u4EE4(stderr\u6355\u83B7): ${command}${options?.cwd ? ` (cwd: ${options.cwd})` : ""}`);
+    const result = await spawnWithStderrCapture(command, options);
+    return { command, ...result };
+  });
   return Promise.all(promises);
 }
 
+// src/utils/clipboard.ts
+import { spawnSync as spawnSync2 } from "child_process";
+function getClipboardCommand() {
+  switch (process.platform) {
+    case "darwin":
+      return { command: "pbcopy", args: [] };
+    case "linux":
+      return { command: "xclip", args: ["-selection", "clipboard"] };
+    case "win32":
+      return { command: "clip", args: [] };
+    default:
+      return null;
+  }
+}
+function copyToClipboard(text) {
+  try {
+    const clipboardCmd = getClipboardCommand();
+    if (!clipboardCmd) {
+      logger.debug(`\u4E0D\u652F\u6301\u7684\u5E73\u53F0: ${process.platform}\uFF0C\u8DF3\u8FC7\u526A\u8D34\u677F\u590D\u5236`);
+      return false;
+    }
+    const result = spawnSync2(clipboardCmd.command, clipboardCmd.args, {
+      input: text,
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    if (result.status !== 0) {
+      logger.debug(`\u526A\u8D34\u677F\u547D\u4EE4\u6267\u884C\u5931\u8D25\uFF0C\u9000\u51FA\u7801: ${result.status}`);
+      return false;
+    }
+    return true;
+  } catch (error) {
+    logger.debug(`\u526A\u8D34\u677F\u590D\u5236\u5F02\u5E38: ${error.message}`);
+    return false;
+  }
+}
+
 // src/utils/git-core.ts
 import { basename } from "path";
 import { execSync as execSync2, execFileSync as execFileSync2 } from "child_process";
@@ -1757,7 +1826,7 @@ function parseConcurrency(optionValue, configValue) {
 import Enquirer2 from "enquirer";
 
 // src/utils/claude.ts
-import { spawnSync as spawnSync2 } from "child_process";
+import { spawnSync as spawnSync3 } from "child_process";
 import { existsSync as existsSync7, readdirSync as readdirSync3 } from "fs";
 import { join as join5 } from "path";
 
@@ -1866,7 +1935,7 @@ function launchInteractiveClaude(worktree, options = {}) {
     printInfo(`  \u6A21\u5F0F: ${hasPreviousSession ? "\u7EE7\u7EED\u4E0A\u6B21\u5BF9\u8BDD" : "\u65B0\u5BF9\u8BDD"}`);
   }
   printInfo("");
-  const result = spawnSync2(cmd, args, {
+  const result = spawnSync3(cmd, args, {
     cwd: worktree.path,
     stdio: "inherit"
   });
@@ -3227,39 +3296,66 @@ async function checkForUpdates(currentVersion) {
 }
 
 // src/utils/validate-runner.ts
-function executeSingleCommand(command, mainWorktreePath) {
+function handleErrorClipboard(clipboardContent) {
+  const success = copyToClipboard(clipboardContent);
+  if (success) {
+    printInfo(MESSAGES.VALIDATE_RUN_ERROR_COPIED);
+  } else {
+    printWarning(MESSAGES.VALIDATE_RUN_ERROR_COPY_FAILED);
+  }
+}
+function buildSingleErrorClipboard(command, stderr, exitCode) {
+  if (stderr.trim()) {
+    return MESSAGES.VALIDATE_CLIPBOARD_SINGLE_ERROR(command, stderr.trim());
+  }
+  return `${command} \u6307\u4EE4\u6267\u884C\u51FA\u9519\uFF0C\u9000\u51FA\u7801: ${exitCode}`;
+}
+async function executeSingleCommand(command, mainWorktreePath) {
   printInfo(MESSAGES.VALIDATE_RUN_START(command));
   printSeparator();
-  const result = runCommandInherited(command, { cwd: mainWorktreePath });
+  const result = await runCommandWithStderrCapture(command, { cwd: mainWorktreePath });
   printSeparator();
   if (result.error) {
-    printError(MESSAGES.VALIDATE_RUN_ERROR(command, result.error.message));
+    printError(MESSAGES.VALIDATE_RUN_ERROR(command, result.error));
+    const clipboardContent = MESSAGES.VALIDATE_CLIPBOARD_SINGLE_ERROR(command, result.error);
+    handleErrorClipboard(clipboardContent);
     return;
   }
-  const exitCode = result.status ?? 1;
-  if (exitCode === 0) {
+  if (result.exitCode === 0) {
     printSuccess(MESSAGES.VALIDATE_RUN_SUCCESS(command));
   } else {
-    printError(MESSAGES.VALIDATE_RUN_FAILED(command, exitCode));
+    printError(MESSAGES.VALIDATE_RUN_FAILED(command, result.exitCode));
+    const clipboardContent = buildSingleErrorClipboard(command, result.stderr, result.exitCode);
+    handleErrorClipboard(clipboardContent);
   }
 }
 function reportParallelResults(results) {
   printSeparator();
   const successCount = results.filter((r) => r.exitCode === 0 && !r.error).length;
   const failedCount = results.length - successCount;
+  const errorClipboardParts = [];
   for (const result of results) {
     if (result.error) {
       printError(MESSAGES.VALIDATE_PARALLEL_CMD_ERROR(result.command, result.error));
+      errorClipboardParts.push(
+        MESSAGES.VALIDATE_CLIPBOARD_PARALLEL_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));
+      const errorContent = result.stderr.trim() ? result.stderr.trim() : `\u9000\u51FA\u7801: ${result.exitCode}`;
+      errorClipboardParts.push(
+        MESSAGES.VALIDATE_CLIPBOARD_PARALLEL_ERROR(result.command, errorContent)
+      );
     }
   }
   if (failedCount === 0) {
     printSuccess(MESSAGES.VALIDATE_PARALLEL_RUN_ALL_SUCCESS(results.length));
   } else {
     printError(MESSAGES.VALIDATE_PARALLEL_RUN_SUMMARY(successCount, failedCount));
+    const clipboardContent = errorClipboardParts.join(MESSAGES.VALIDATE_CLIPBOARD_SEPARATOR);
+    handleErrorClipboard(clipboardContent);
   }
 }
 async function executeParallelCommands(commands, mainWorktreePath) {
@@ -3268,14 +3364,14 @@ async function executeParallelCommands(commands, mainWorktreePath) {
     printInfo(MESSAGES.VALIDATE_PARALLEL_CMD_START(i + 1, commands.length, commands[i]));
   }
   printSeparator();
-  const results = await runParallelCommands(commands, { cwd: mainWorktreePath });
+  const results = await runParallelCommandsWithStderrCapture(commands, { cwd: mainWorktreePath });
   reportParallelResults(results);
 }
 async function executeRunCommand(command, mainWorktreePath) {
   printInfo("");
   const commands = parseParallelCommands(command);
   if (commands.length <= 1) {
-    executeSingleCommand(commands[0] || command, mainWorktreePath);
+    await executeSingleCommand(commands[0] || command, mainWorktreePath);
   } else {
     await executeParallelCommands(commands, mainWorktreePath);
   }

package/dist/postinstall.js

@@ -241,7 +241,19 @@ ${branches.map((b) => `    - ${b}`).join("\n")}`,
   VALIDATE_BRANCH_NOT_FOUND: (validateBranch, branch) => `\u9A8C\u8BC1\u5206\u652F ${validateBranch} \u4E0D\u5B58\u5728\uFF0C\u8BF7\u5148\u6267\u884C clawt create \u6216 clawt run \u521B\u5EFA\u5206\u652F ${branch}`,
   /** validate 成功（含验证分支信息） */
   VALIDATE_SUCCESS_WITH_BRANCH: (branch, validateBranch) => `\u2713 \u5DF2\u5207\u6362\u5230\u9A8C\u8BC1\u5206\u652F ${validateBranch} \u5E76\u5E94\u7528\u5206\u652F ${branch} \u7684\u53D8\u66F4
-  \u53EF\u4EE5\u5F00\u59CB\u9A8C\u8BC1\u4E86`
+  \u53EF\u4EE5\u5F00\u59CB\u9A8C\u8BC1\u4E86`,
+  /** 错误信息已复制到剪贴板提示 */
+  VALIDATE_RUN_ERROR_COPIED: "\u2702 \u9519\u8BEF\u4FE1\u606F\u5DF2\u590D\u5236\u5230\u526A\u8D34\u677F",
+  /** 剪贴板复制失败提示 */
+  VALIDATE_RUN_ERROR_COPY_FAILED: "\u26A0 \u9519\u8BEF\u4FE1\u606F\u590D\u5236\u5230\u526A\u8D34\u677F\u5931\u8D25",
+  /** 单命令（含 && 链）剪贴板错误格式 */
+  VALIDATE_CLIPBOARD_SINGLE_ERROR: (command, stderr) => `${command} \u6307\u4EE4\u6267\u884C\u51FA\u9519\uFF0C\u9519\u8BEF\u4FE1\u606F\uFF1A
+${stderr}`,
+  /** 并行命令中单个命令的剪贴板错误格式 */
+  VALIDATE_CLIPBOARD_PARALLEL_ERROR: (command, stderr) => `${command} \u6307\u4EE4\u6267\u884C\u51FA\u9519\uFF0C\u9519\u8BEF\u4FE1\u606F\uFF1A
+${stderr}`,
+  /** 多个错误之间的分隔符 */
+  VALIDATE_CLIPBOARD_SEPARATOR: "\n\n---\n\n"
 };
 
 // src/constants/messages/sync.ts

package/package.json

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

package/src/constants/messages/validate.ts

@@ -71,4 +71,16 @@ export const VALIDATE_MESSAGES = {
   /** validate 成功（含验证分支信息） */
   VALIDATE_SUCCESS_WITH_BRANCH: (branch: string, validateBranch: string) =>
     `✓ 已切换到验证分支 ${validateBranch} 并应用分支 ${branch} 的变更\n  可以开始验证了`,
+  /** 错误信息已复制到剪贴板提示 */
+  VALIDATE_RUN_ERROR_COPIED: '✂ 错误信息已复制到剪贴板',
+  /** 剪贴板复制失败提示 */
+  VALIDATE_RUN_ERROR_COPY_FAILED: '⚠ 错误信息复制到剪贴板失败',
+  /** 单命令（含 && 链）剪贴板错误格式 */
+  VALIDATE_CLIPBOARD_SINGLE_ERROR: (command: string, stderr: string) =>
+    `${command} 指令执行出错，错误信息：\n${stderr}`,
+  /** 并行命令中单个命令的剪贴板错误格式 */
+  VALIDATE_CLIPBOARD_PARALLEL_ERROR: (command: string, stderr: string) =>
+    `${command} 指令执行出错，错误信息：\n${stderr}`,
+  /** 多个错误之间的分隔符 */
+  VALIDATE_CLIPBOARD_SEPARATOR: '\n\n---\n\n',
 } as const;

package/src/utils/clipboard.ts

@@ -0,0 +1,52 @@
+import { spawnSync } from 'node:child_process';
+import { logger } from '../logger/index.js';
+
+/**
+ * 根据当前操作系统获取剪贴板写入命令
+ * @returns {{ command: string, args: string[] } | null} 剪贴板命令配置，不支持的平台返回 null
+ */
+function getClipboardCommand(): { command: string; args: string[] } | null {
+  switch (process.platform) {
+    case 'darwin':
+      return { command: 'pbcopy', args: [] };
+    case 'linux':
+      return { command: 'xclip', args: ['-selection', 'clipboard'] };
+    case 'win32':
+      return { command: 'clip', args: [] };
+    default:
+      return null;
+  }
+}
+
+/**
+ * 将文本复制到系统剪贴板
+ * 跨平台支持：macOS (pbcopy)、Linux (xclip)、Windows (clip)
+ * 失败时静默返回 false，不影响主流程
+ * @param {string} text - 要复制到剪贴板的文本
+ * @returns {boolean} 复制是否成功
+ */
+export function copyToClipboard(text: string): boolean {
+  try {
+    const clipboardCmd = getClipboardCommand();
+    if (!clipboardCmd) {
+      logger.debug(`不支持的平台: ${process.platform}，跳过剪贴板复制`);
+      return false;
+    }
+
+    const result = spawnSync(clipboardCmd.command, clipboardCmd.args, {
+      input: text,
+      encoding: 'utf-8',
+      stdio: ['pipe', 'pipe', 'pipe'],
+    });
+
+    if (result.status !== 0) {
+      logger.debug(`剪贴板命令执行失败，退出码: ${result.status}`);
+      return false;
+    }
+
+    return true;
+  } catch (error) {
+    logger.debug(`剪贴板复制异常: ${(error as Error).message}`);
+    return false;
+  }
+}

package/src/utils/index.ts

@@ -1,5 +1,6 @@
-export { execCommand, spawnProcess, killAllChildProcesses, execCommandWithInput, runCommandInherited, parseParallelCommands, runParallelCommands } from './shell.js';
-export type { ParallelCommandResult } from './shell.js';
+export { execCommand, spawnProcess, killAllChildProcesses, execCommandWithInput, runCommandInherited, parseParallelCommands, runParallelCommands, runCommandWithStderrCapture, runParallelCommandsWithStderrCapture } from './shell.js';
+export type { ParallelCommandResult, CommandResultWithStderr, ParallelCommandResultWithStderr } from './shell.js';
+export { copyToClipboard } from './clipboard.js';
 export {
   getGitCommonDir,
   getGitTopLevel,

package/src/utils/shell.ts

@@ -11,6 +11,22 @@ export interface ParallelCommandResult {
   error?: string;
 }
 
+/** 带 stderr 捕获的命令执行结果 */
+export interface CommandResultWithStderr {
+  /** 进程退出码 */
+  exitCode: number;
+  /** 进程启动失败时的错误信息 */
+  error?: string;
+  /** 捕获的 stderr 输出内容 */
+  stderr: string;
+}
+
+/** 带 stderr 捕获的并行命令执行结果 */
+export interface ParallelCommandResultWithStderr extends ParallelCommandResult {
+  /** 捕获的 stderr 输出内容 */
+  stderr: string;
+}
+
 /**
  * 同步执行 shell 命令并返回 stdout
  * @param {string} command - 要执行的命令
@@ -157,3 +173,83 @@ export function runParallelCommands(
 
   return Promise.all(promises);
 }
+
+/**
+ * 以 shell 模式启动子进程，捕获 stderr 同时实时回显到终端
+ * stdout 直接继承父进程（实时输出），stderr 通过 pipe 捕获并同步回显
+ * @param {string} command - 要执行的命令字符串
+ * @param {object} options - 可选配置
+ * @param {string} options.cwd - 工作目录
+ * @returns {Promise<{ exitCode: number, error?: string, stderr: string }>} 退出码、错误信息和 stderr 内容
+ */
+function spawnWithStderrCapture(
+  command: string,
+  options?: { cwd?: string },
+): Promise<{ exitCode: number; error?: string; stderr: string }> {
+  return new Promise((resolve) => {
+    const child = spawn(command, {
+      cwd: options?.cwd,
+      stdio: ['inherit', 'inherit', 'pipe'],
+      shell: true,
+    });
+
+    const stderrChunks: Buffer[] = [];
+
+    child.stderr?.on('data', (chunk: Buffer) => {
+      // 实时回显到终端
+      process.stderr.write(chunk);
+      // 累积到 buffer
+      stderrChunks.push(chunk);
+    });
+
+    child.on('error', (err) => {
+      resolve({
+        exitCode: 1,
+        error: err.message,
+        stderr: Buffer.concat(stderrChunks).toString('utf-8'),
+      });
+    });
+
+    child.on('close', (code) => {
+      resolve({
+        exitCode: code ?? 1,
+        stderr: Buffer.concat(stderrChunks).toString('utf-8'),
+      });
+    });
+  });
+}
+
+/**
+ * 异步执行命令，捕获 stderr 同时实时回显到终端
+ * @param {string} command - 要执行的命令字符串
+ * @param {object} options - 可选配置
+ * @param {string} options.cwd - 工作目录
+ * @returns {Promise<CommandResultWithStderr>} 包含退出码和 stderr 内容的结果
+ */
+export function runCommandWithStderrCapture(
+  command: string,
+  options?: { cwd?: string },
+): Promise<CommandResultWithStderr> {
+  logger.debug(`执行命令(stderr捕获): ${command}${options?.cwd ? ` (cwd: ${options.cwd})` : ''}`);
+  return spawnWithStderrCapture(command, options);
+}
+
+/**
+ * 并行执行多个命令，捕获每个命令的 stderr 同时实时回显到终端
+ * @param {string[]} commands - 要并行执行的命令数组
+ * @param {object} options - 可选配置
+ * @param {string} options.cwd - 工作目录
+ * @returns {Promise<ParallelCommandResultWithStderr[]>} 各命令的执行结果（含 stderr）
+ */
+export function runParallelCommandsWithStderrCapture(
+  commands: string[],
+  options?: { cwd?: string },
+): Promise<ParallelCommandResultWithStderr[]> {
+  const promises = commands.map(async (command): Promise<ParallelCommandResultWithStderr> => {
+    logger.debug(`并行启动命令(stderr捕获): ${command}${options?.cwd ? ` (cwd: ${options.cwd})` : ''}`);
+    const result = await spawnWithStderrCapture(command, options);
+    return { command, ...result };
+  });
+
+  return Promise.all(promises);
+}

package/src/utils/validate-runner.ts

@@ -3,57 +3,101 @@ import {
   printInfo,
   printSuccess,
   printError,
+  printWarning,
   printSeparator,
-  runCommandInherited,
   parseParallelCommands,
-  runParallelCommands,
 } from './index.js';
-import type { ParallelCommandResult } from './index.js';
+import { runCommandWithStderrCapture, runParallelCommandsWithStderrCapture } from './shell.js';
+import type { ParallelCommandResultWithStderr } from './shell.js';
+import { copyToClipboard } from './clipboard.js';
 
 /**
- * 执行单个命令（同步方式，保持原有行为不变）
+ * 处理命令执行失败后的剪贴板复制逻辑
+ * 将格式化的错误信息复制到系统剪贴板，并输出操作结果提示
+ * @param {string} clipboardContent - 要复制到剪贴板的完整错误信息
+ */
+function handleErrorClipboard(clipboardContent: string): void {
+  const success = copyToClipboard(clipboardContent);
+  if (success) {
+    printInfo(MESSAGES.VALIDATE_RUN_ERROR_COPIED);
+  } else {
+    printWarning(MESSAGES.VALIDATE_RUN_ERROR_COPY_FAILED);
+  }
+}
+
+/**
+ * 构建单命令失败时的剪贴板内容
+ * @param {string} command - 失败的命令
+ * @param {string} stderr - 捕获的 stderr 内容
+ * @param {number} exitCode - 进程退出码
+ * @returns {string} 格式化后的剪贴板内容
+ */
+function buildSingleErrorClipboard(command: string, stderr: string, exitCode: number): string {
+  if (stderr.trim()) {
+    return MESSAGES.VALIDATE_CLIPBOARD_SINGLE_ERROR(command, stderr.trim());
+  }
+  return `${command} 指令执行出错，退出码: ${exitCode}`;
+}
+
+/**
+ * 执行单个命令（异步方式，捕获 stderr 并在失败时复制到剪贴板）
  * @param {string} command - 要执行的命令字符串
  * @param {string} mainWorktreePath - 主 worktree 路径
  */
-function executeSingleCommand(command: string, mainWorktreePath: string): void {
+async function executeSingleCommand(command: string, mainWorktreePath: string): Promise<void> {
   printInfo(MESSAGES.VALIDATE_RUN_START(command));
   printSeparator();
 
-  const result = runCommandInherited(command, { cwd: mainWorktreePath });
+  const result = await runCommandWithStderrCapture(command, { cwd: mainWorktreePath });
 
   printSeparator();
 
   if (result.error) {
     // 进程启动失败（如命令不存在）
-    printError(MESSAGES.VALIDATE_RUN_ERROR(command, result.error.message));
+    printError(MESSAGES.VALIDATE_RUN_ERROR(command, result.error));
+    const clipboardContent = MESSAGES.VALIDATE_CLIPBOARD_SINGLE_ERROR(command, result.error);
+    handleErrorClipboard(clipboardContent);
     return;
   }
 
-  const exitCode = result.status ?? 1;
-  if (exitCode === 0) {
+  if (result.exitCode === 0) {
     printSuccess(MESSAGES.VALIDATE_RUN_SUCCESS(command));
   } else {
-    printError(MESSAGES.VALIDATE_RUN_FAILED(command, exitCode));
+    printError(MESSAGES.VALIDATE_RUN_FAILED(command, result.exitCode));
+    const clipboardContent = buildSingleErrorClipboard(command, result.stderr, result.exitCode);
+    handleErrorClipboard(clipboardContent);
   }
 }
 
 /**
- * 汇总输出并行命令的执行结果
- * @param {ParallelCommandResult[]} results - 各命令的执行结果数组
+ * 汇总输出并行命令的执行结果，并将失败命令的错误信息复制到剪贴板
+ * @param {ParallelCommandResultWithStderr[]} results - 各命令的执行结果数组
  */
-function reportParallelResults(results: ParallelCommandResult[]): void {
+function reportParallelResults(results: ParallelCommandResultWithStderr[]): void {
   printSeparator();
 
   const successCount = results.filter((r) => r.exitCode === 0 && !r.error).length;
   const failedCount = results.length - successCount;
+  const errorClipboardParts: string[] = [];
 
   for (const result of results) {
     if (result.error) {
       printError(MESSAGES.VALIDATE_PARALLEL_CMD_ERROR(result.command, result.error));
+      // 收集错误信息用于剪贴板
+      errorClipboardParts.push(
+        MESSAGES.VALIDATE_CLIPBOARD_PARALLEL_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));
+      // 收集错误信息用于剪贴板
+      const errorContent = result.stderr.trim()
+        ? result.stderr.trim()
+        : `退出码: ${result.exitCode}`;
+      errorClipboardParts.push(
+        MESSAGES.VALIDATE_CLIPBOARD_PARALLEL_ERROR(result.command, errorContent),
+      );
     }
   }
 
@@ -61,6 +105,9 @@ function reportParallelResults(results: ParallelCommandResult[]): void {
     printSuccess(MESSAGES.VALIDATE_PARALLEL_RUN_ALL_SUCCESS(results.length));
   } else {
     printError(MESSAGES.VALIDATE_PARALLEL_RUN_SUMMARY(successCount, failedCount));
+    // 将所有失败命令的错误信息拼接后一次性复制到剪贴板
+    const clipboardContent = errorClipboardParts.join(MESSAGES.VALIDATE_CLIPBOARD_SEPARATOR);
+    handleErrorClipboard(clipboardContent);
   }
 }
 
@@ -78,7 +125,7 @@ async function executeParallelCommands(commands: string[], mainWorktreePath: str
 
   printSeparator();
 
-  const results = await runParallelCommands(commands, { cwd: mainWorktreePath });
+  const results = await runParallelCommandsWithStderrCapture(commands, { cwd: mainWorktreePath });
 
   reportParallelResults(results);
 }
@@ -96,8 +143,8 @@ export async function executeRunCommand(command: string, mainWorktreePath: strin
   const commands = parseParallelCommands(command);
 
   if (commands.length <= 1) {
-    // 单命令（包括含 && 的串行命令），走原有同步路径
-    executeSingleCommand(commands[0] || command, mainWorktreePath);
+    // 单命令（包括含 && 的串行命令），走异步路径并捕获 stderr
+    await executeSingleCommand(commands[0] || command, mainWorktreePath);
   } else {
     // 多命令，并行执行
     await executeParallelCommands(commands, mainWorktreePath);