clawt 2.19.0 → 3.0.0

package/src/utils/json.ts

@@ -0,0 +1,67 @@
+/**
+ * 非对象类型的值直接转为字符串表示
+ * @param {unknown} value - 任意值
+ * @returns {string} 字符串表示
+ */
+function primitiveToString(value: unknown): string {
+  if (value === undefined) {
+    return 'undefined';
+  }
+  if (value === null) {
+    return 'null';
+  }
+  if (typeof value === 'symbol') {
+    return value.toString();
+  }
+  if (typeof value === 'function') {
+    return `[Function: ${value.name || 'anonymous'}]`;
+  }
+  return String(value);
+}
+
+/**
+ * 安全的 JSON 序列化，兼容非 JSON 安全类型（undefined、function、Symbol、BigInt、循环引用等）
+ * @param {unknown} value - 要序列化的值
+ * @param {number} [indent=2] - 缩进空格数
+ * @returns {string} 序列化后的 JSON 字符串，失败时返回兜底描述
+ */
+export function safeStringify(value: unknown, indent: number = 2): string {
+  // 非对象类型直接转字符串，无需走 JSON.stringify
+  if (value === null || typeof value !== 'object') {
+    return primitiveToString(value);
+  }
+
+  try {
+    // 利用 WeakSet 检测循环引用
+    const seen = new WeakSet();
+    return JSON.stringify(
+      value,
+      (_key: string, val: unknown) => {
+        // 处理 BigInt 类型（JSON.stringify 默认不支持）
+        if (typeof val === 'bigint') {
+          return val.toString();
+        }
+        // 将 undefined、function、Symbol 转为可读字符串，避免被 JSON.stringify 丢弃
+        if (typeof val === 'undefined' || typeof val === 'function' || typeof val === 'symbol') {
+          return primitiveToString(val);
+        }
+        // 检测循环引用：对象类型且非 null 时才需要检查
+        if (typeof val === 'object' && val !== null) {
+          if (seen.has(val)) {
+            return '[Circular]';
+          }
+          seen.add(val);
+        }
+        return val;
+      },
+      indent,
+    );
+  } catch {
+    // 极端情况兜底：尝试用 util.inspect 风格输出
+    try {
+      return JSON.stringify(String(value), null, indent);
+    } catch {
+      return '[Unserializable]';
+    }
+  }
+}

package/src/utils/project-config.ts

@@ -0,0 +1,77 @@
+import { existsSync, readFileSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { PROJECTS_CONFIG_DIR, MESSAGES } from '../constants/index.js';
+import { ClawtError } from '../errors/index.js';
+import { logger } from '../logger/index.js';
+import { getProjectName } from './git.js';
+import { ensureDir } from './fs.js';
+import type { ProjectConfig } from '../types/index.js';
+
+/**
+ * 获取项目配置文件路径
+ * @param {string} projectName - 项目名
+ * @returns {string} 配置文件路径
+ */
+export function getProjectConfigPath(projectName: string): string {
+  return join(PROJECTS_CONFIG_DIR, projectName, 'config.json');
+}
+
+/**
+ * 加载当前项目的配置
+ * @returns {ProjectConfig | null} 项目配置，不存在时返回 null
+ */
+export function loadProjectConfig(): ProjectConfig | null {
+  const projectName = getProjectName();
+  const configPath = getProjectConfigPath(projectName);
+
+  if (!existsSync(configPath)) {
+    return null;
+  }
+
+  try {
+    const raw = readFileSync(configPath, 'utf-8');
+    return JSON.parse(raw) as ProjectConfig;
+  } catch (error) {
+    logger.warn(`项目配置文件解析失败: ${error}`);
+    return null;
+  }
+}
+
+/**
+ * 保存项目配置
+ * @param {ProjectConfig} config - 要保存的项目配置
+ */
+export function saveProjectConfig(config: ProjectConfig): void {
+  const projectName = getProjectName();
+  const configPath = getProjectConfigPath(projectName);
+  // 确保项目子目录存在
+  const projectDir = join(PROJECTS_CONFIG_DIR, projectName);
+  ensureDir(projectDir);
+  writeFileSync(configPath, JSON.stringify(config, null, 2), 'utf-8');
+  logger.info(`项目配置已保存: ${configPath}`);
+}
+
+/**
+ * 获取当前项目配置，不存在则抛出错误
+ * @returns {ProjectConfig} 项目配置
+ */
+export function requireProjectConfig(): ProjectConfig {
+  const config = loadProjectConfig();
+  if (!config) {
+    throw new ClawtError(MESSAGES.PROJECT_NOT_INITIALIZED);
+  }
+  // 校验配置文件中是否包含 clawtMainWorkBranch 字段
+  if (!config.clawtMainWorkBranch) {
+    throw new ClawtError(MESSAGES.PROJECT_CONFIG_MISSING_BRANCH);
+  }
+  return config;
+}
+
+/**
+ * 从项目配置中获取主工作分支名
+ * @returns {string} 主工作分支名
+ */
+export function getMainWorkBranch(): string {
+  const config = requireProjectConfig();
+  return config.clawtMainWorkBranch;
+}

package/src/utils/validate-branch.ts

@@ -0,0 +1,166 @@
+import Enquirer from 'enquirer';
+import { VALIDATE_BRANCH_PREFIX } from '../constants/index.js';
+import { logger } from '../logger/index.js';
+import { checkBranchExists, createBranch, deleteBranch, getCurrentBranch, gitCheckout, gitResetHard, gitCleanForce, isWorkingDirClean, gitAddAll, gitStashPush } from './git.js';
+import { getMainWorkBranch } from './project-config.js';
+import { printWarning } from './formatter.js';
+import { ClawtError } from '../errors/index.js';
+
+/**
+ * 生成验证分支名
+ * @param {string} branchName - 原始分支名
+ * @returns {string} 验证分支名
+ */
+export function getValidateBranchName(branchName: string): string {
+  return `${VALIDATE_BRANCH_PREFIX}${branchName}`;
+}
+
+/**
+ * 创建验证分支（如果不存在）
+ * @param {string} branchName - 原始分支名
+ * @param {string} [cwd] - 工作目录
+ */
+export function createValidateBranch(branchName: string, cwd?: string): void {
+  const validateBranchName = getValidateBranchName(branchName);
+
+  if (checkBranchExists(validateBranchName, cwd)) {
+    logger.info(`验证分支已存在，跳过创建: ${validateBranchName}`);
+    return;
+  }
+
+  createBranch(validateBranchName, cwd);
+  logger.info(`验证分支已创建: ${validateBranchName}`);
+}
+
+/**
+ * 删除验证分支（如果存在）
+ * @param {string} branchName - 原始分支名
+ * @param {string} [cwd] - 工作目录
+ */
+export function deleteValidateBranch(branchName: string, cwd?: string): void {
+  const validateBranchName = getValidateBranchName(branchName);
+
+  if (!checkBranchExists(validateBranchName, cwd)) {
+    logger.info(`验证分支不存在，跳过删除: ${validateBranchName}`);
+    return;
+  }
+
+  deleteBranch(validateBranchName, cwd);
+  logger.info(`验证分支已删除: ${validateBranchName}`);
+}
+
+/**
+ * 重建验证分支（先删除再创建）
+ * 确保在主工作分支上创建验证分支，处理三种情况：
+ * 1. 已在主工作分支上 → 直接重建
+ * 2. 在验证分支上 → 清理工作区后自动切回主工作分支
+ * 3. 在其他分支上 → 检查工作区是否干净，不干净则交互处理后切回主工作分支
+ * @param {string} branchName - 原始分支名
+ * @param {string} [cwd] - 工作目录
+ */
+export async function rebuildValidateBranch(branchName: string, cwd?: string): Promise<void> {
+  const mainBranch = getMainWorkBranch();
+  const currentBranch = getCurrentBranch(cwd);
+
+  if (currentBranch === mainBranch) {
+    // 已在主工作分支上，无需切换
+  } else if (currentBranch.startsWith(VALIDATE_BRANCH_PREFIX)) {
+    // 在验证分支上，验证分支的修改是可丢弃的，直接清理后切回
+    gitResetHard(cwd);
+    gitCleanForce(cwd);
+    gitCheckout(mainBranch, cwd);
+  } else {
+    // 在其他分支上，需确保工作区干净后切回主工作分支
+    if (!isWorkingDirClean(cwd)) {
+      await handleDirtyWorkingDir(cwd);
+    }
+    gitCheckout(mainBranch, cwd);
+  }
+
+  deleteValidateBranch(branchName, cwd);
+  createValidateBranch(branchName, cwd);
+  logger.info(`验证分支已重建: ${getValidateBranchName(branchName)}`);
+}
+
+/**
+ * 处理工作区有未提交更改的情况
+ * 提供交互式选择：reset（丢弃所有更改）、stash（暂存更改）、exit（退出让用户手动处理）
+ * @param {string} [cwd] - 工作目录
+ */
+export async function handleDirtyWorkingDir(cwd?: string): Promise<void> {
+  printWarning('当前分支有未提交的更改，请选择处理方式：\n');
+
+  // @ts-expect-error enquirer 类型声明未导出 Select 类，但运行时存在
+  const choice = await new Enquirer.Select({
+    message: '选择处理方式',
+    choices: [
+      {
+        name: 'reset',
+        message: 'reset        - 丢弃所有更改 (git reset --hard HEAD && git clean -fd)',
+      },
+      {
+        name: 'stash',
+        message: 'stash        - 暂存更改 (git add . && git stash)',
+      },
+      {
+        name: 'exit',
+        message: 'exit         - 退出，手动处理',
+      },
+    ],
+    initial: 0,
+  }).run();
+
+  if (choice === 'exit') {
+    throw new ClawtError('用户选择退出，请手动处理工作区更改后重试');
+  }
+
+  if (choice === 'reset') {
+    gitResetHard(cwd);
+    gitCleanForce(cwd);
+  } else if (choice === 'stash') {
+    gitAddAll(cwd);
+    gitStashPush('clawt:auto-stash', cwd);
+  }
+
+  // 再次检查是否干净
+  if (!isWorkingDirClean(cwd)) {
+    throw new ClawtError('工作区仍然不干净，请手动处理');
+  }
+}
+
+/**
+ * 确保当前在主工作分支上
+ * 三种情况：
+ * 1. 已在主工作分支上 → 直接返回
+ * 2. 在验证分支上 → 清理工作区后自动切回主工作分支
+ * 3. 在其他分支上 → 处理脏工作区后切换到主工作分支
+ * @param {string} [cwd] - 工作目录
+ */
+export async function ensureOnMainWorkBranch(cwd?: string): Promise<void> {
+  const mainBranch = getMainWorkBranch();
+  const currentBranch = getCurrentBranch(cwd);
+
+  // 已在主工作分支上，无需操作
+  if (currentBranch === mainBranch) {
+    return;
+  }
+
+  // 当前在验证分支上，清理工作区后自动切回
+  if (currentBranch.startsWith(VALIDATE_BRANCH_PREFIX)) {
+    logger.info(`当前在验证分支 ${currentBranch} 上，自动切回主工作分支 ${mainBranch}`);
+    // 验证分支上的修改是可丢弃的，直接清理
+    if (!isWorkingDirClean(cwd)) {
+      gitResetHard(cwd);
+      gitCleanForce(cwd);
+    }
+    gitCheckout(mainBranch, cwd);
+    return;
+  }
+
+  // 当前在其他分支上，处理脏工作区后切换
+  logger.info(`当前在分支 ${currentBranch} 上，需切换到主工作分支 ${mainBranch}`);
+  if (!isWorkingDirClean(cwd)) {
+    await handleDirtyWorkingDir(cwd);
+  }
+  gitCheckout(mainBranch, cwd);
+}

package/src/utils/worktree-matcher.ts

@@ -1,6 +1,15 @@
 import Enquirer from 'enquirer';
+import { statSync } from 'node:fs';
 import { ClawtError } from '../errors/index.js';
-import { SELECT_ALL_NAME, SELECT_ALL_LABEL } from '../constants/index.js';
+import {
+  SELECT_ALL_NAME,
+  SELECT_ALL_LABEL,
+  GROUP_SELECT_ALL_PREFIX,
+  GROUP_SELECT_ALL_LABEL,
+  GROUP_SEPARATOR_LABEL,
+  UNKNOWN_DATE_GROUP,
+  UNKNOWN_DATE_SEPARATOR_LABEL,
+} from '../constants/index.js';
 import type { WorktreeInfo } from '../types/index.js';
 
 /** enquirer MultiSelect 选项条目的运行时结构 */
@@ -264,3 +273,261 @@ export async function resolveTargetWorktree(
   const allBranches = worktrees.map((wt) => wt.branch);
   throw new ClawtError(messages.noMatch(branchName, allBranches));
 }
+
+/** enquirer MultiSelect 分隔线条目结构 */
+interface MultiSelectSeparator {
+  role: 'separator';
+  message: string;
+}
+
+/** enquirer MultiSelect choices 数组的条目类型 */
+type GroupedChoice = { name: string; message: string } | MultiSelectSeparator;
+
+/**
+ * 将 Date 对象格式化为本地时区的 YYYY-MM-DD 字符串
+ * @param {Date} date - 日期对象
+ * @returns {string} YYYY-MM-DD 格式的本地日期字符串
+ */
+function formatLocalDate(date: Date): string {
+  const year = date.getFullYear();
+  const month = String(date.getMonth() + 1).padStart(2, '0');
+  const day = String(date.getDate()).padStart(2, '0');
+  return `${year}-${month}-${day}`;
+}
+
+/**
+ * 获取 worktree 目录的创建日期（本地时区）
+ * 通过文件系统的 birthtime 获取目录实际创建时间，比 git reflog 更准确
+ * @param {string} dirPath - worktree 目录路径
+ * @returns {string | null} YYYY-MM-DD 格式的本地日期字符串，无法获取时返回 null
+ */
+function getWorktreeCreatedDate(dirPath: string): string | null {
+  try {
+    const stat = statSync(dirPath);
+    return formatLocalDate(stat.birthtime);
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * 将 YYYY-MM-DD 日期字符串格式化为中文相对日期描述
+ * 基于自然日计算，适用于日期分组场景
+ * @param {string} dateStr - YYYY-MM-DD 格式的日期字符串
+ * @returns {string} 中文相对日期描述，如"今天"、"昨天"、"3 天前"
+ */
+function formatRelativeDate(dateStr: string): string {
+  const today = formatLocalDate(new Date());
+  const todayMs = new Date(today).getTime();
+  const targetMs = new Date(dateStr).getTime();
+  const diffDays = Math.round((todayMs - targetMs) / (1000 * 60 * 60 * 24));
+
+  if (diffDays === 0) return '今天';
+  if (diffDays === 1) return '昨天';
+  if (diffDays < 30) return `${diffDays} 天前`;
+  if (diffDays < 365) {
+    const months = Math.floor(diffDays / 30);
+    return `${months} 个月前`;
+  }
+  const years = Math.floor(diffDays / 365);
+  return `${years} 年前`;
+}
+
+/**
+ * 按创建日期对 worktree 列表进行分组
+ * 通过 worktree 目录的文件系统创建时间进行分组
+ * 无法获取日期的分支归入"未知日期"组
+ * @param {WorktreeInfo[]} worktrees - worktree 列表
+ * @returns {Map<string, WorktreeInfo[]>} 日期 → worktree 列表的映射，按日期降序排列，未知日期在最后
+ */
+export function groupWorktreesByDate(worktrees: WorktreeInfo[]): Map<string, WorktreeInfo[]> {
+  const groups = new Map<string, WorktreeInfo[]>();
+
+  for (const wt of worktrees) {
+    const dateKey = getWorktreeCreatedDate(wt.path) ?? UNKNOWN_DATE_GROUP;
+
+    if (!groups.has(dateKey)) {
+      groups.set(dateKey, []);
+    }
+    groups.get(dateKey)!.push(wt);
+  }
+
+  // 按日期降序排列，未知日期放最后
+  const sortedEntries = [...groups.entries()].sort((a, b) => {
+    if (a[0] === UNKNOWN_DATE_GROUP) return 1;
+    if (b[0] === UNKNOWN_DATE_GROUP) return -1;
+    return b[0].localeCompare(a[0]);
+  });
+
+  return new Map(sortedEntries);
+}
+
+/**
+ * 根据分组数据构建 enquirer MultiSelect 的 choices 数组
+ * 包含全局全选、每组的分隔线和组全选、以及各组内的分支选项
+ * @param {Map<string, WorktreeInfo[]>} groups - 日期分组数据
+ * @returns {GroupedChoice[]} enquirer choices 数组
+ */
+export function buildGroupedChoices(groups: Map<string, WorktreeInfo[]>): GroupedChoice[] {
+  const choices: GroupedChoice[] = [];
+
+  // 顶部插入全局全选
+  choices.push({ name: SELECT_ALL_NAME, message: SELECT_ALL_LABEL });
+
+  for (const [dateKey, worktreeList] of groups) {
+    // 分隔线
+    if (dateKey === UNKNOWN_DATE_GROUP) {
+      choices.push({ role: 'separator', message: UNKNOWN_DATE_SEPARATOR_LABEL });
+    } else {
+      const relativeTime = formatRelativeDate(dateKey);
+      choices.push({ role: 'separator', message: GROUP_SEPARATOR_LABEL(dateKey, relativeTime) });
+    }
+
+    // 组级全选
+    const groupSelectAllName = `${GROUP_SELECT_ALL_PREFIX}${dateKey}`;
+    choices.push({ name: groupSelectAllName, message: GROUP_SELECT_ALL_LABEL(dateKey) });
+
+    // 该组内各分支
+    for (const wt of worktreeList) {
+      choices.push({ name: wt.branch, message: wt.branch });
+    }
+  }
+
+  return choices;
+}
+
+/**
+ * 构建组全选 name 到该组分支 name 列表的映射
+ * 用于 space() 方法中快速查找某个组全选项对应的所有分支
+ * @param {Map<string, WorktreeInfo[]>} groups - 日期分组数据
+ * @returns {Map<string, string[]>} 组全选 name → 分支 name 列表的映射
+ */
+export function buildGroupMembershipMap(groups: Map<string, WorktreeInfo[]>): Map<string, string[]> {
+  const map = new Map<string, string[]>();
+
+  for (const [dateKey, worktreeList] of groups) {
+    const groupSelectAllName = `${GROUP_SELECT_ALL_PREFIX}${dateKey}`;
+    map.set(groupSelectAllName, worktreeList.map((wt) => wt.branch));
+  }
+
+  return map;
+}
+
+/**
+ * 通过交互式多选列表（按日期分组）让用户选择多个分支
+ * 提供三级联动：全局全选、组级全选、单个分支
+ * @param {WorktreeInfo[]} worktrees - 可供选择的 worktree 列表
+ * @param {string} message - 选择提示信息
+ * @returns {Promise<WorktreeInfo[]>} 用户选择的 worktree 列表
+ */
+export async function promptGroupedMultiSelectBranches(
+  worktrees: WorktreeInfo[],
+  message: string,
+): Promise<WorktreeInfo[]> {
+  const groups = groupWorktreesByDate(worktrees);
+  const choices = buildGroupedChoices(groups);
+  const groupMembershipMap = buildGroupMembershipMap(groups);
+
+  // 收集所有组全选的 name，用于判断某个 choice 是否为组全选项
+  const groupSelectAllNames = new Set(groupMembershipMap.keys());
+
+  // 收集所有实际分支的 name
+  const allBranchNames = new Set(worktrees.map((wt) => wt.branch));
+
+  // @ts-expect-error enquirer 类型声明未导出 MultiSelect 类，但运行时存在
+  const MultiSelect: new (options: Record<string, unknown>) => MultiSelectInstance = Enquirer.MultiSelect;
+
+  /**
+   * 扩展 MultiSelect，实现三级联动的 space() 覆写
+   * - 全局全选：切换所有 choices（含组全选）
+   * - 组级全选：切换该组内所有分支，同步全局全选状态
+   * - 普通分支：toggle 该分支，同步所属组全选和全局全选状态
+   */
+  class MultiSelectWithGroupSelectAll extends MultiSelect {
+    space(this: MultiSelectInstance) {
+      if (!this.focused) return;
+
+      const focusedName = this.focused.name;
+
+      if (focusedName === SELECT_ALL_NAME) {
+        // 全局全选：切换所有 choices
+        const willEnable = !this.focused.enabled;
+        for (const ch of this.choices) {
+          ch.enabled = willEnable;
+        }
+        return this.render();
+      }
+
+      if (groupSelectAllNames.has(focusedName)) {
+        // 组级全选：切换该组内所有分支
+        const willEnable = !this.focused.enabled;
+        const memberNames = groupMembershipMap.get(focusedName)!;
+        // 切换组全选自身
+        this.focused.enabled = willEnable;
+        // 切换该组的所有分支
+        for (const ch of this.choices) {
+          if (memberNames.includes(ch.name)) {
+            ch.enabled = willEnable;
+          }
+        }
+        // 同步全局全选状态：检查所有实际分支是否全选
+        syncGlobalSelectAll(this.choices);
+        return this.render();
+      }
+
+      // 普通分支：toggle 该分支
+      this.toggle(this.focused);
+
+      // 同步所属组全选状态
+      syncGroupSelectAll(this.choices, focusedName);
+      // 同步全局全选状态
+      syncGlobalSelectAll(this.choices);
+
+      return this.render();
+    }
+  }
+
+  /**
+   * 同步全局全选状态
+   * 根据所有实际分支的选中状态更新全局全选项
+   * @param {MultiSelectChoice[]} choiceList - choices 列表
+   */
+  function syncGlobalSelectAll(choiceList: MultiSelectChoice[]): void {
+    const selectAllChoice = choiceList.find((ch) => ch.name === SELECT_ALL_NAME);
+    if (!selectAllChoice) return;
+
+    const branchItems = choiceList.filter((ch) => allBranchNames.has(ch.name));
+    selectAllChoice.enabled = branchItems.length > 0 && branchItems.every((ch) => ch.enabled);
+  }
+
+  /**
+   * 同步指定分支所属组的全选状态
+   * 根据该组内所有分支的选中状态更新组全选项
+   * @param {MultiSelectChoice[]} choiceList - choices 列表
+   * @param {string} branchName - 刚被 toggle 的分支名
+   */
+  function syncGroupSelectAll(choiceList: MultiSelectChoice[], branchName: string): void {
+    for (const [groupName, memberNames] of groupMembershipMap) {
+      if (!memberNames.includes(branchName)) continue;
+
+      const groupChoice = choiceList.find((ch) => ch.name === groupName);
+      if (!groupChoice) continue;
+
+      const memberChoices = choiceList.filter((ch) => memberNames.includes(ch.name));
+      groupChoice.enabled = memberChoices.length > 0 && memberChoices.every((ch) => ch.enabled);
+      break;
+    }
+  }
+
+  const selectedBranches: string[] = await new MultiSelectWithGroupSelectAll({
+    message,
+    choices,
+    // 使用空心圆/实心圆作为选中指示符
+    symbols: {
+      indicator: { on: '●', off: '○' },
+    },
+  }).run();
+
+  // 过滤掉全选项和组全选项，只返回实际选中的 worktree
+  return worktrees.filter((wt) => selectedBranches.includes(wt.branch));
+}

package/src/utils/worktree.ts

@@ -5,6 +5,7 @@ import { logger } from '../logger/index.js';
 import { createWorktree as gitCreateWorktree, getProjectName, gitWorktreeList, removeWorktreeByPath, deleteBranch, gitWorktreePrune, getCommitCountAhead, getDiffStat, isWorkingDirClean } from './git.js';
 import { sanitizeBranchName, generateBranchNames, validateBranchesNotExist } from './branch.js';
 import { ensureDir, removeEmptyDir } from './fs.js';
+import { createValidateBranch, deleteValidateBranch } from './validate-branch.js';
 import type { WorktreeInfo, WorktreeStatus } from '../types/index.js';
 
 /**
@@ -37,11 +38,12 @@ export function createWorktrees(branchName: string, count: number): WorktreeInfo
   const projectDir = getProjectWorktreeDir();
   ensureDir(projectDir);
 
-  // 5. 串行创建 worktree
+  // 5. 串行创建 worktree 及对应验证分支
   const results: WorktreeInfo[] = [];
   for (const name of branchNames) {
     const worktreePath = join(projectDir, name);
     gitCreateWorktree(name, worktreePath);
+    createValidateBranch(name);
     results.push({ path: worktreePath, branch: name });
     logger.info(`worktree 创建完成: ${worktreePath} (分支: ${name})`);
   }
@@ -64,11 +66,12 @@ export function createWorktreesByBranches(branchNames: string[]): WorktreeInfo[]
   const projectDir = getProjectWorktreeDir();
   ensureDir(projectDir);
 
-  // 3. 串行创建 worktree
+  // 3. 串行创建 worktree 及对应验证分支
   const results: WorktreeInfo[] = [];
   for (const name of branchNames) {
     const worktreePath = join(projectDir, name);
     gitCreateWorktree(name, worktreePath);
+    createValidateBranch(name);
     results.push({ path: worktreePath, branch: name });
     logger.info(`worktree 创建完成: ${worktreePath} (分支: ${name})`);
   }
@@ -123,6 +126,7 @@ export function cleanupWorktrees(worktrees: WorktreeInfo[]): void {
     try {
       removeWorktreeByPath(wt.path);
       deleteBranch(wt.branch);
+      deleteValidateBranch(wt.branch);
       logger.info(`已清理 worktree 和分支: ${wt.branch}`);
     } catch (error) {
       logger.error(`清理 worktree 失败: ${wt.path} - ${error}`);