clawt 2.16.1 → 2.16.3

package/package.json

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

package/src/commands/status.ts

@@ -2,7 +2,7 @@ import type { Command } from 'commander';
 import chalk from 'chalk';
 import { MESSAGES } from '../constants/index.js';
 import { logger } from '../logger/index.js';
-import type { StatusOptions, WorktreeDetailedStatus, MainWorktreeStatus, SnapshotInfo, StatusResult, WorktreeInfo } from '../types/index.js';
+import type { StatusOptions, WorktreeDetailedStatus, MainWorktreeStatus, SnapshotSummary, StatusResult, WorktreeInfo } from '../types/index.js';
 import {
   validateMainWorktree,
   getProjectName,
@@ -14,8 +14,10 @@ import {
   getDiffStat,
   hasMergeConflict,
   hasLocalCommits,
-  hasSnapshot,
+  getSnapshotModifiedTime,
   getProjectSnapshotBranches,
+  getBranchCreatedAt,
+  formatRelativeTime,
   printInfo,
   printDoubleSeparator,
   printSeparator,
@@ -96,6 +98,7 @@ function collectWorktreeDetailedStatus(worktree: WorktreeInfo, projectName: stri
   const changeStatus = detectChangeStatus(worktree);
   const { commitsAhead, commitsBehind } = countCommitDivergence(worktree.branch);
   const { insertions, deletions } = countDiffStat(worktree.path);
+  const createdAt = resolveBranchCreatedAt(worktree.branch);
 
   return {
     path: worktree.path,
@@ -103,9 +106,10 @@ function collectWorktreeDetailedStatus(worktree: WorktreeInfo, projectName: stri
     changeStatus,
     commitsAhead,
     commitsBehind,
-    hasSnapshot: hasSnapshot(projectName, worktree.branch),
+    snapshotTime: resolveSnapshotTime(projectName, worktree.branch),
     insertions,
     deletions,
+    createdAt,
   };
 }
 
@@ -162,20 +166,47 @@ function countDiffStat(worktreePath: string): { insertions: number; deletions: n
 }
 
 /**
- * 收集未清理的 validate 快照信息
- * 对比快照分支与现有 worktree 分支，标识孤立快照
+ * 获取分支的创建时间
+ * @param {string} branchName - 分支名
+ * @returns {string | null} ISO 8601 格式的创建时间，获取失败时返回 null
+ */
+function resolveBranchCreatedAt(branchName: string): string | null {
+  try {
+    return getBranchCreatedAt(branchName);
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * 获取分支的 validate 快照修改时间
+ * @param {string} projectName - 项目名
+ * @param {string} branchName - 分支名
+ * @returns {string | null} ISO 8601 格式的快照时间，无快照时返回 null
+ */
+function resolveSnapshotTime(projectName: string, branchName: string): string | null {
+  try {
+    return getSnapshotModifiedTime(projectName, branchName);
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * 收集 validate 快照摘要信息
  * @param {string} projectName - 项目名
  * @param {WorktreeInfo[]} worktrees - 当前有效的 worktree 列表
- * @returns {SnapshotInfo[]} 快照信息列表
+ * @returns {SnapshotSummary} 快照摘要
  */
-function collectSnapshots(projectName: string, worktrees: WorktreeInfo[]): SnapshotInfo[] {
+function collectSnapshots(projectName: string, worktrees: WorktreeInfo[]): SnapshotSummary {
   const snapshotBranches = getProjectSnapshotBranches(projectName);
   const worktreeBranchSet = new Set(worktrees.map((wt) => wt.branch));
+  const orphaned = snapshotBranches.filter((branch) => !worktreeBranchSet.has(branch)).length;
 
-  return snapshotBranches.map((branch) => ({
-    branch,
-    worktreeExists: worktreeBranchSet.has(branch),
-  }));
+  return {
+    total: snapshotBranches.length,
+    orphaned,
+  };
 }
 
 /**
@@ -256,31 +287,39 @@ function printWorktreeItem(wt: WorktreeDetailedStatus): void {
   const statusLabel = formatChangeStatusLabel(wt.changeStatus);
   printInfo(`  ${chalk.bold('●')} ${chalk.bold(wt.branch)}   [${statusLabel}]`);
 
-  // 差异统计行
-  const parts: string[] = [];
-
-  // 行数变更（仅在有变更时展示）
+  // 变更行数
   if (wt.insertions > 0 || wt.deletions > 0) {
-    parts.push(`${chalk.green(`+${wt.insertions}`)} ${chalk.red(`-${wt.deletions}`)}`);
+    printInfo(`    ${chalk.green(`+${wt.insertions}`)} ${chalk.red(`-${wt.deletions}`)}`);
   }
 
   // 本地提交数
   if (wt.commitsAhead > 0) {
-    parts.push(chalk.yellow(`${wt.commitsAhead} 个本地提交`));
+    printInfo(`    ${chalk.yellow(`${wt.commitsAhead} 个本地提交`)}`);
   }
 
   // 与主分支的同步状态
   if (wt.commitsBehind > 0) {
-    parts.push(chalk.yellow(`落后主分支 ${wt.commitsBehind} 个提交`));
+    printInfo(`    ${chalk.yellow(`落后主分支 ${wt.commitsBehind} 个提交`)}`);
   } else {
-    parts.push(chalk.green('与主分支同步'));
+    printInfo(`    ${chalk.green('与主分支同步')}`);
   }
 
-  printInfo(`    ${parts.join('   ')}`);
+  // 分支创建时间
+  if (wt.createdAt) {
+    const relativeTime = formatRelativeTime(wt.createdAt);
+    if (relativeTime) {
+      printInfo(`    ${chalk.gray(MESSAGES.STATUS_CREATED_AT(relativeTime))}`);
+    }
+  }
 
-  // 快照状态
-  if (wt.hasSnapshot) {
-    printInfo(`    ${chalk.blue('有 validate 快照')}`);
+  // 验证状态
+  if (wt.snapshotTime) {
+    const relativeTime = formatRelativeTime(wt.snapshotTime);
+    if (relativeTime) {
+      printInfo(`    ${chalk.green(MESSAGES.STATUS_LAST_VALIDATED(relativeTime))}`);
+    }
+  } else {
+    printInfo(`    ${chalk.red(MESSAGES.STATUS_NOT_VALIDATED)}`);
   }
 
   printInfo('');
@@ -305,23 +344,13 @@ function formatChangeStatusLabel(status: WorktreeDetailedStatus['changeStatus'])
 }
 
 /**
- * 输出未清理快照区块
- * @param {SnapshotInfo[]} snapshots - 快照信息列表
+ * 输出快照摘要区块
+ * @param {SnapshotSummary} snapshots - 快照摘要信息
  */
-function printSnapshotsSection(snapshots: SnapshotInfo[]): void {
-  printInfo(`  ${chalk.bold('◆')} ${chalk.bold(MESSAGES.STATUS_SNAPSHOTS_SECTION)} (${snapshots.length} 个)`);
-  printInfo('');
-
-  if (snapshots.length === 0) {
-    printInfo(`    ${MESSAGES.STATUS_NO_SNAPSHOTS}`);
-    printInfo('');
-    return;
-  }
-
-  for (const snap of snapshots) {
-    const orphanLabel = snap.worktreeExists ? '' : `  ${chalk.yellow(MESSAGES.STATUS_SNAPSHOT_ORPHANED)}`;
-    const icon = snap.worktreeExists ? chalk.blue('●') : chalk.yellow('⚠');
-    printInfo(`  ${icon} ${snap.branch}${orphanLabel}`);
+function printSnapshotsSection(snapshots: SnapshotSummary): void {
+  printInfo(`  ${chalk.bold('◆')} ${chalk.bold(MESSAGES.STATUS_SNAPSHOTS_SECTION)} (${snapshots.total} 个)`);
+  if (snapshots.orphaned > 0) {
+    printInfo(`    ${chalk.yellow(MESSAGES.STATUS_SNAPSHOT_ORPHANED(snapshots.orphaned))}`);
   }
   printInfo('');
 }

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/status.ts

@@ -7,7 +7,7 @@ export const STATUS_MESSAGES = {
   /** status worktrees 区块标题 */
   STATUS_WORKTREES_SECTION: 'Worktree 列表',
   /** status 快照区块标题 */
-  STATUS_SNAPSHOTS_SECTION: '未清理的 Validate 快照',
+  STATUS_SNAPSHOTS_SECTION: 'Validate 快照',
   /** status 无 worktree */
   STATUS_NO_WORKTREES: '(无活跃 worktree)',
   /** status 无未清理快照 */
@@ -21,5 +21,13 @@ export const STATUS_MESSAGES = {
   /** status 变更状态：无变更 */
   STATUS_CHANGE_CLEAN: '无变更',
   /** status 快照对应 worktree 已不存在 */
-  STATUS_SNAPSHOT_ORPHANED: '(对应 worktree 已不存在)',
+  STATUS_SNAPSHOT_ORPHANED: (count: number) => `其中 ${count} 个快照对应的 worktree 已不存在`,
+  /** status 分支创建时间标签 */
+  STATUS_CREATED_AT: (relativeTime: string) => `创建于 ${relativeTime}`,
+  /** status 分支无分叉提交时的提示 */
+  STATUS_NO_DIVERGED_COMMITS: '尚无分叉提交',
+  /** status 上次验证时间标签 */
+  STATUS_LAST_VALIDATED: (relativeTime: string) => `上次验证: ${relativeTime}`,
+  /** status 未验证警示 */
+  STATUS_NOT_VALIDATED: '✗ 未验证',
 } 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/types/index.ts

@@ -3,5 +3,5 @@ export type { CreateOptions, RunOptions, ValidateOptions, MergeOptions, RemoveOp
 export type { WorktreeInfo, WorktreeStatus } from './worktree.js';
 export type { ClaudeCodeResult } from './claudeCode.js';
 export type { TaskResult, TaskSummary } from './taskResult.js';
-export type { WorktreeDetailedStatus, MainWorktreeStatus, SnapshotInfo, StatusResult } from './status.js';
+export type { WorktreeDetailedStatus, MainWorktreeStatus, SnapshotInfo, SnapshotSummary, StatusResult } from './status.js';
 export type { TaskFileEntry, ParseTaskFileOptions } from './taskFile.js';

package/src/types/status.ts

@@ -10,12 +10,14 @@ export interface WorktreeDetailedStatus {
   commitsAhead: number;
   /** 落后于主分支的提交数 */
   commitsBehind: number;
-  /** 是否存在 validate 快照 */
-  hasSnapshot: boolean;
+  /** 上次 validate 验证时间（ISO 8601 时间字符串），无快照时为 null */
+  snapshotTime: string | null;
   /** 工作区和暂存区的新增行数 */
   insertions: number;
   /** 工作区和暂存区的删除行数 */
   deletions: number;
+  /** 分支创建时间（首次分叉提交的 ISO 8601 时间字符串），无分叉提交时为 null */
+  createdAt: string | null;
 }
 
 /** 主 worktree 状态信息 */
@@ -36,14 +38,22 @@ export interface SnapshotInfo {
   worktreeExists: boolean;
 }
 
+/** validate 快照摘要信息 */
+export interface SnapshotSummary {
+  /** 快照总数 */
+  total: number;
+  /** 孤立快照数（对应 worktree 已不存在） */
+  orphaned: number;
+}
+
 /** status 命令的完整输出结构 */
 export interface StatusResult {
   /** 主 worktree 状态 */
   main: MainWorktreeStatus;
   /** 各 worktree 的详细状态 */
   worktrees: WorktreeDetailedStatus[];
-  /** 未清理的 validate 快照列表 */
-  snapshots: SnapshotInfo[];
+  /** validate 快照摘要 */
+  snapshots: SnapshotSummary;
   /** worktree 总数 */
   totalWorktrees: number;
 }

package/src/utils/formatter.ts

@@ -142,3 +142,45 @@ export function formatDuration(ms: number): string {
   const seconds = Math.floor(totalSeconds % 60);
   return `${minutes}m${String(seconds).padStart(2, '0')}s`;
 }
+
+/**
+ * 将 ISO 8601 日期字符串格式化为中文相对时间描述
+ * 例如: "3 天前"、"2 小时前"、"刚刚"
+ * @param {string} isoDateString - ISO 8601 格式的日期字符串
+ * @returns {string | null} 中文相对时间描述，无效日期时返回 null
+ */
+export function formatRelativeTime(isoDateString: string): string | null {
+  const date = new Date(isoDateString);
+  const now = new Date();
+  const diffMs = now.getTime() - date.getTime();
+
+  // 无效日期返回 null
+  if (isNaN(diffMs)) {
+    return null;
+  }
+
+  // 未来时间或不到 1 分钟
+  if (diffMs < 0 || diffMs < 60 * 1000) {
+    return '刚刚';
+  }
+
+  const diffMinutes = Math.floor(diffMs / (1000 * 60));
+  const diffHours = Math.floor(diffMs / (1000 * 60 * 60));
+  const diffDays = Math.floor(diffMs / (1000 * 60 * 60 * 24));
+
+  if (diffHours < 1) {
+    return `${diffMinutes} 分钟前`;
+  }
+  if (diffDays < 1) {
+    return `${diffHours} 小时前`;
+  }
+  if (diffDays < 30) {
+    return `${diffDays} 天前`;
+  }
+  if (diffDays < 365) {
+    const months = Math.floor(diffDays / 30);
+    return `${months} 个月前`;
+  }
+  const years = Math.floor(diffDays / 365);
+  return `${years} 年前`;
+}

package/src/utils/git.ts

@@ -481,3 +481,23 @@ export function gitApplyCachedCheck(patchContent: Buffer, cwd?: string): boolean
     return false;
   }
 }
+
+/**
+ * 获取分支的创建时间（通过 reflog 获取分支创建时的时间戳）
+ * reflog 的最后一条记录即为分支创建时的记录
+ * @param {string} branchName - 目标分支名
+ * @param {string} [cwd] - 工作目录
+ * @returns {string | null} ISO 8601 格式的时间字符串，无法获取时返回 null
+ */
+export function getBranchCreatedAt(branchName: string, cwd?: string): string | null {
+  try {
+    const output = execCommand(`git reflog show ${branchName} --format=%cI`, { cwd });
+    if (!output.trim()) return null;
+    // 取最后一行，即分支创建时的 reflog 记录
+    const lines = output.trim().split('\n');
+    const lastLine = lines[lines.length - 1];
+    return lastLine || null;
+  } catch {
+    return null;
+  }
+}

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,
@@ -44,16 +45,17 @@ export {
   getCommitTreeHash,
   gitDiffTree,
   gitApplyCachedCheck,
+  getBranchCreatedAt,
 } from './git.js';
 export { sanitizeBranchName, generateBranchNames, validateBranchesNotExist } from './branch.js';
 export { validateMainWorktree, validateGitInstalled, validateClaudeCodeInstalled } from './validation.js';
 export { createWorktrees, getProjectWorktrees, getProjectWorktreeDir, cleanupWorktrees, getWorktreeStatus, createWorktreesByBranches } from './worktree.js';
 export { loadConfig, writeDefaultConfig, writeConfig, saveConfig, getConfigValue, ensureClawtDirs, parseConcurrency } from './config.js';
-export { printSuccess, printError, printWarning, printInfo, printHint, printSeparator, printDoubleSeparator, confirmAction, confirmDestructiveAction, formatWorktreeStatus, isWorktreeIdle, formatDuration } from './formatter.js';
+export { printSuccess, printError, printWarning, printInfo, printHint, printSeparator, printDoubleSeparator, confirmAction, confirmDestructiveAction, formatWorktreeStatus, isWorktreeIdle, formatDuration, formatRelativeTime } from './formatter.js';
 export { ensureDir, removeEmptyDir } from './fs.js';
 export { multilineInput } from './prompt.js';
 export { launchInteractiveClaude, hasClaudeSessionHistory, launchInteractiveClaudeInNewTerminal } from './claude.js';
-export { getSnapshotPath, hasSnapshot, readSnapshotTreeHash, readSnapshot, writeSnapshot, removeSnapshot, removeProjectSnapshots, getProjectSnapshotBranches } from './validate-snapshot.js';
+export { getSnapshotPath, hasSnapshot, getSnapshotModifiedTime, readSnapshotTreeHash, readSnapshot, writeSnapshot, removeSnapshot, removeProjectSnapshots, getProjectSnapshotBranches } from './validate-snapshot.js';
 export { findExactMatch, findFuzzyMatches, promptSelectBranch, promptMultiSelectBranches, resolveTargetWorktree, resolveTargetWorktrees } from './worktree-matcher.js';
 export type { WorktreeResolveMessages, WorktreeMultiResolveMessages } from './worktree-matcher.js';
 export { ProgressRenderer } from './progress.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/src/utils/validate-snapshot.ts

@@ -1,5 +1,5 @@
 import { join } from 'node:path';
-import { existsSync, readFileSync, writeFileSync, unlinkSync, readdirSync, rmdirSync } from 'node:fs';
+import { existsSync, readFileSync, writeFileSync, unlinkSync, readdirSync, rmdirSync, statSync } from 'node:fs';
 import { VALIDATE_SNAPSHOTS_DIR } from '../constants/index.js';
 import { ensureDir } from './fs.js';
 import { logger } from '../logger/index.js';
@@ -34,6 +34,19 @@ export function hasSnapshot(projectName: string, branchName: string): boolean {
   return existsSync(getSnapshotPath(projectName, branchName));
 }
 
+/**
+ * 获取指定项目和分支的 validate 快照文件修改时间
+ * @param {string} projectName - 项目名
+ * @param {string} branchName - 分支名
+ * @returns {string | null} ISO 8601 格式的修改时间，快照不存在时返回 null
+ */
+export function getSnapshotModifiedTime(projectName: string, branchName: string): string | null {
+  const snapshotPath = getSnapshotPath(projectName, branchName);
+  if (!existsSync(snapshotPath)) return null;
+  const stat = statSync(snapshotPath);
+  return stat.mtime.toISOString();
+}
+
 /**
  * 读取指定项目和分支的 validate 快照中存储的 tree hash
  * @param {string} projectName - 项目名