clawt 3.5.0 → 3.5.2

package/src/types/command.ts

@@ -36,6 +36,8 @@ export interface MergeOptions {
   branch?: string;
   /** 提交信息（目标 worktree 工作区有修改时必填） */
   message?: string;
+  /** 遇到冲突直接调用 AI 解决，不再询问 */
+  auto?: boolean;
 }
 
 /** remove 命令选项 */

package/src/types/config.ts

@@ -18,6 +18,10 @@ export interface ClawtConfig {
   aliases: Record<string, string>;
   /** 是否启用自动更新检查 */
   autoUpdate: boolean;
+  /** merge 冲突时的解决模式：ask（询问）、auto（自动 AI 解决）、manual（手动解决） */
+  conflictResolveMode: 'ask' | 'auto' | 'manual';
+  /** Claude Code 冲突解决超时时间（毫秒），默认 300000（5 分钟） */
+  conflictResolveTimeoutMs: number;
 }
 
 /** 单个配置项的完整定义（默认值 + 描述） */

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/conflict-resolver.ts

@@ -0,0 +1,170 @@
+import { execFileSync } from 'node:child_process';
+import { logger } from '../logger/index.js';
+import { ClawtError } from '../errors/index.js';
+import { getConfigValue } from './config.js';
+import { getConflictFiles, gitAddFiles, gitMergeContinue } from './git.js';
+import { printInfo, printSuccess, printWarning } from './formatter.js';
+import { confirmAction } from './formatter.js';
+import { MESSAGES } from '../constants/index.js';
+import { CONFLICT_RESOLVE_PROMPT } from '../constants/ai-prompts.js';
+
+/** 默认 Claude Code 冲突解决超时时间（毫秒） */
+const DEFAULT_CONFLICT_RESOLVE_TIMEOUT_MS = 300000;
+
+/**
+ * 构建发送给 Claude Code 的冲突解决 prompt
+ * Claude Code 会自动读取当前工作目录下的冲突文件，无需手动传入
+ * @returns {string} 纯指令性 AI prompt
+ */
+export function buildConflictResolvePrompt(): string {
+  return CONFLICT_RESOLVE_PROMPT;
+}
+
+/**
+ * 获取冲突解决超时时间（毫秒）
+ * 优先使用配置项，未配置时使用默认值
+ * @returns {number} 超时时间（毫秒）
+ */
+function getConflictResolveTimeout(): number {
+  const configValue = getConfigValue('conflictResolveTimeoutMs');
+  if (typeof configValue === 'number' && configValue > 0) {
+    return configValue;
+  }
+  return DEFAULT_CONFLICT_RESOLVE_TIMEOUT_MS;
+}
+
+/**
+ * 调用 Claude Code CLI 以非交互模式解决冲突
+ * 使用 execFileSync 数组参数形式避免 shell 注入
+ * @param {string} prompt - AI prompt
+ * @param {string} cwd - 工作目录
+ * @returns {string} Claude Code 的输出
+ */
+export function invokeClaudeForConflictResolve(prompt: string, cwd: string): string {
+  const args = ['-p', prompt, '--permission-mode', 'bypassPermissions'];
+
+  logger.info(`调用 Claude Code 解决冲突，命令: claude -p "..." --permission-mode bypassPermissions`);
+
+  try {
+    const output = execFileSync('claude', args, {
+      cwd,
+      encoding: 'utf-8',
+      stdio: ['pipe', 'pipe', 'pipe'],
+      timeout: getConflictResolveTimeout(),
+    });
+    return output;
+  } catch (error: unknown) {
+    const errMsg = error instanceof Error ? error.message : String(error);
+    logger.error(`Claude Code 冲突解决失败: ${errMsg}`);
+    throw new ClawtError(MESSAGES.MERGE_CONFLICT_AI_FAILED(errMsg));
+  }
+}
+
+/**
+ * 执行 AI 辅助冲突解决的完整流程
+ * 1. 获取冲突文件列表
+ * 2. 构建 AI prompt
+ * 3. 调用 Claude Code 解决冲突
+ * 4. 检查冲突是否解决
+ * 5. git add 已解决的文件并 merge --continue
+ * @param {string} currentBranch - 当前分支名
+ * @param {string} incomingBranch - 传入分支名
+ * @param {string} cwd - 工作目录
+ * @returns {boolean} 是否所有冲突都已解决
+ */
+export function resolveConflictsWithAI(
+  currentBranch: string,
+  incomingBranch: string,
+  cwd: string,
+): boolean {
+  const conflictFiles = getConflictFiles(cwd);
+  if (conflictFiles.length === 0) {
+    return true;
+  }
+
+  printInfo(MESSAGES.MERGE_CONFLICT_AI_START(conflictFiles.length));
+
+  // 构建 prompt 并调用 Claude Code，捕获异常提供恢复提示
+  const prompt = buildConflictResolvePrompt();
+  try {
+    invokeClaudeForConflictResolve(prompt, cwd);
+  } catch (error) {
+    // AI 调用失败时输出友好提示，告知用户可手动解决或重试
+    const errMsg = error instanceof ClawtError ? error.message : String(error);
+    printWarning(errMsg);
+    return false;
+  }
+
+  // 检查冲突是否已解决
+  const remainingConflicts = getConflictFiles(cwd);
+
+  if (remainingConflicts.length === 0) {
+    // 所有冲突已解决，git add 所有原冲突文件并完成 merge
+    gitAddFiles(conflictFiles, cwd);
+    gitMergeContinue(cwd);
+    printSuccess(MESSAGES.MERGE_CONFLICT_AI_SUCCESS);
+    return true;
+  }
+
+  // 部分冲突已解决，git add 已解决的文件
+  const resolvedFiles = conflictFiles.filter((f) => !remainingConflicts.includes(f));
+  if (resolvedFiles.length > 0) {
+    gitAddFiles(resolvedFiles, cwd);
+  }
+
+  printWarning(MESSAGES.MERGE_CONFLICT_AI_PARTIAL(remainingConflicts.length));
+  return false;
+}
+
+/**
+ * 根据配置和命令选项判断冲突解决模式
+ * @param {boolean} [autoFlag] - --auto 命令行参数
+ * @returns {'ask' | 'auto' | 'manual'} 冲突解决模式
+ */
+export function determineConflictResolveMode(autoFlag?: boolean): 'ask' | 'auto' | 'manual' {
+  // --auto 命令行参数优先级最高
+  if (autoFlag === true) {
+    return 'auto';
+  }
+
+  const configMode = getConfigValue('conflictResolveMode');
+  if (configMode === 'auto' || configMode === 'manual') {
+    return configMode;
+  }
+
+  return 'ask';
+}
+
+/**
+ * 处理合并冲突的入口函数
+ * 根据冲突解决模式决定处理方式：auto 直接 AI 解决，ask 询问用户，manual 抛出错误
+ * @param {string} currentBranch - 当前分支名
+ * @param {string} incomingBranch - 传入分支名
+ * @param {string} cwd - 工作目录
+ * @param {boolean} [autoFlag] - --auto 命令行参数
+ * @returns {Promise<boolean>} 是否成功解决了所有冲突
+ */
+export async function handleMergeConflict(
+  currentBranch: string,
+  incomingBranch: string,
+  cwd: string,
+  autoFlag?: boolean,
+): Promise<boolean> {
+  const mode = determineConflictResolveMode(autoFlag);
+
+  if (mode === 'manual') {
+    throw new ClawtError(MESSAGES.MERGE_CONFLICT_MANUAL);
+  }
+
+  if (mode === 'auto') {
+    return resolveConflictsWithAI(currentBranch, incomingBranch, cwd);
+  }
+
+  // mode === 'ask'
+  const shouldUseAI = await confirmAction(MESSAGES.MERGE_CONFLICT_ASK_AI);
+  if (!shouldUseAI) {
+    throw new ClawtError(MESSAGES.MERGE_CONFLICT_MANUAL);
+  }
+
+  return resolveConflictsWithAI(currentBranch, incomingBranch, cwd);
+}

package/src/utils/git-core.ts

@@ -1,5 +1,5 @@
 import { basename } from 'node:path';
-import { execSync } from 'node:child_process';
+import { execSync, execFileSync } from 'node:child_process';
 import { execCommand, execCommandWithInput } from './shell.js';
 import { logger } from '../logger/index.js';
 
@@ -367,3 +367,51 @@ export function gitApplyCachedCheck(patchContent: Buffer, cwd?: string): boolean
     return false;
   }
 }
+
+/**
+ * 获取冲突文件列表
+ * 通过 git status --porcelain 解析 UU/AA/DD 等冲突标记
+ * @param {string} [cwd] - 工作目录
+ * @returns {string[]} 冲突文件路径列表
+ */
+export function getConflictFiles(cwd?: string): string[] {
+  const status = getStatusPorcelain(cwd);
+  if (!status) return [];
+  return status
+    .split('\n')
+    .filter((line) => /^(UU|AA|DD|DU|UD|AU|UA)/.test(line))
+    .map((line) => line.slice(3));
+}
+
+/**
+ * git add 指定文件
+ * 使用 execFileSync 数组参数形式避免文件名中特殊字符导致的注入风险
+ * @param {string[]} files - 文件路径列表
+ * @param {string} [cwd] - 工作目录
+ */
+export function gitAddFiles(files: string[], cwd?: string): void {
+  if (files.length === 0) return;
+  const args = ['add', '--', ...files];
+  logger.debug(`执行命令: git ${args.join(' ')}${cwd ? ` (cwd: ${cwd})` : ''}`);
+  execFileSync('git', args, {
+    cwd,
+    encoding: 'utf-8',
+    stdio: ['pipe', 'pipe', 'pipe'],
+  });
+}
+
+/**
+ * git merge --continue（非交互式）
+ * @param {string} [cwd] - 工作目录
+ */
+export function gitMergeContinue(cwd?: string): void {
+  execCommand('GIT_EDITOR=true git merge --continue', { cwd });
+}
+
+/**
+ * git merge --abort
+ * @param {string} [cwd] - 工作目录
+ */
+export function gitMergeAbort(cwd?: string): void {
+  execCommand('git merge --abort', { cwd });
+}

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,
@@ -48,6 +49,10 @@ export {
   getBranchCreatedAt,
   gitCheckout,
   createBranch,
+  getConflictFiles,
+  gitAddFiles,
+  gitMergeContinue,
+  gitMergeAbort,
 } from './git.js';
 export { sanitizeBranchName, generateBranchNames, validateBranchesNotExist } from './branch.js';
 export { validateMainWorktree, validateGitInstalled, validateClaudeCodeInstalled, validateHeadExists, validateWorkingDirClean, runPreChecks } from './validation.js';
@@ -59,7 +64,7 @@ export { ensureDir, removeEmptyDir, calculateDirSize } from './fs.js';
 export { multilineInput } from './prompt.js';
 export { launchInteractiveClaude, hasClaudeSessionHistory, launchInteractiveClaudeInNewTerminal } from './claude.js';
 export { getSnapshotPath, hasSnapshot, getSnapshotModifiedTime, readSnapshotTreeHash, readSnapshot, writeSnapshot, removeSnapshot, removeProjectSnapshots, getProjectSnapshotBranches } from './validate-snapshot.js';
-export { findExactMatch, findFuzzyMatches, promptSelectBranch, promptMultiSelectBranches, promptGroupedMultiSelectBranches, resolveTargetWorktree, resolveTargetWorktrees, groupWorktreesByDate, buildGroupedChoices, buildGroupMembershipMap, formatRelativeDate, getWorktreeCreatedDate, getWorktreeCreatedTime } from './worktree-matcher.js';
+export { findExactMatch, findFuzzyMatches, promptGroupedMultiSelectBranches, resolveTargetWorktree, resolveTargetWorktrees, groupWorktreesByDate, buildGroupedChoices, buildGroupMembershipMap, formatRelativeDate, getWorktreeCreatedDate, getWorktreeCreatedTime } from './worktree-matcher.js';
 export type { WorktreeResolveMessages, WorktreeMultiResolveMessages } from './worktree-matcher.js';
 export { ProgressRenderer } from './progress.js';
 export { parseTaskFile, loadTaskFile, parseTasksFromOptions } from './task-file.js';
@@ -79,4 +84,5 @@ export { migrateChangesViaPatch, computeCurrentTreeHash, saveCurrentSnapshotTree
 export { InteractivePanel } from './interactive-panel.js';
 export { buildPanelFrame, buildGroupedWorktreeLines, buildDisplayOrder, renderDateSeparator, renderWorktreeBlock, renderSnapshotSummary, renderFooter, calculateVisibleRows } from './interactive-panel-render.js';
 export type { PanelLine } from './interactive-panel-render.js';
+export { buildConflictResolvePrompt, invokeClaudeForConflictResolve, resolveConflictsWithAI, determineConflictResolveMode, handleMergeConflict } from './conflict-resolver.js';
 

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);