clawt 2.20.0 → 3.1.0

package/dist/index.js

@@ -16,9 +16,11 @@ var WORKTREES_DIR = join(CLAWT_HOME, "worktrees");
 var VALIDATE_SNAPSHOTS_DIR = join(CLAWT_HOME, "validate-snapshots");
 var CLAUDE_PROJECTS_DIR = join(homedir(), ".claude", "projects");
 var UPDATE_CHECK_PATH = join(CLAWT_HOME, "update-check.json");
+var PROJECTS_CONFIG_DIR = join(CLAWT_HOME, "projects");
 
 // src/constants/branch.ts
 var INVALID_BRANCH_CHARS = /[\/\\.\s~:*?[\]^]+/g;
+var VALIDATE_BRANCH_PREFIX = "clawt-validate-";
 
 // src/constants/messages/common.ts
 var COMMON_MESSAGES = {
@@ -121,7 +123,9 @@ var RUN_MESSAGES = {
 // src/constants/messages/create.ts
 var CREATE_MESSAGES = {
   /** 创建数量参数无效 */
-  INVALID_COUNT: (value) => `\u65E0\u6548\u7684\u521B\u5EFA\u6570\u91CF: "${value}"\uFF0C\u8BF7\u8F93\u5165\u6B63\u6574\u6570`
+  INVALID_COUNT: (value) => `\u65E0\u6548\u7684\u521B\u5EFA\u6570\u91CF: "${value}"\uFF0C\u8BF7\u8F93\u5165\u6B63\u6574\u6570`,
+  /** 当前不在主工作分支上的警告 */
+  CREATE_WARN_NOT_ON_MAIN_BRANCH: (mainBranch, currentBranch) => `\u5F53\u524D\u4E0D\u5728\u4E3B\u5DE5\u4F5C\u5206\u652F ${mainBranch} \u4E0A\uFF08\u5F53\u524D: ${currentBranch}\uFF09`
 };
 
 // src/constants/messages/merge.ts
@@ -218,7 +222,12 @@ ${branches.map((b) => `    - ${b}`).join("\n")}`,
   /** 自动 sync 开始提示 */
   VALIDATE_AUTO_SYNC_START: (branch) => `\u6B63\u5728\u81EA\u52A8\u540C\u6B65\u4E3B\u5206\u652F\u5230 ${branch} ...`,
   /** 用户拒绝自动 sync */
-  VALIDATE_AUTO_SYNC_DECLINED: (branch) => `\u8BF7\u624B\u52A8\u6267\u884C clawt sync -b ${branch} \u540C\u6B65\u4E3B\u5206\u652F\u540E\u91CD\u8BD5`
+  VALIDATE_AUTO_SYNC_DECLINED: (branch) => `\u8BF7\u624B\u52A8\u6267\u884C clawt sync -b ${branch} \u540C\u6B65\u4E3B\u5206\u652F\u540E\u91CD\u8BD5`,
+  /** 验证分支不存在 */
+  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`
 };
 
 // src/constants/messages/sync.ts
@@ -243,7 +252,9 @@ ${branches.map((b) => `    - ${b}`).join("\n")}`,
   /** sync 交互选择提示 */
   SYNC_SELECT_BRANCH: "\u8BF7\u9009\u62E9\u8981\u540C\u6B65\u7684\u5206\u652F",
   /** sync 模糊匹配到多个结果提示 */
-  SYNC_MULTIPLE_MATCHES: (name) => `"${name}" \u5339\u914D\u5230\u591A\u4E2A\u5206\u652F\uFF0C\u8BF7\u9009\u62E9\uFF1A`
+  SYNC_MULTIPLE_MATCHES: (name) => `"${name}" \u5339\u914D\u5230\u591A\u4E2A\u5206\u652F\uFF0C\u8BF7\u9009\u62E9\uFF1A`,
+  /** sync 后验证分支已重建提示 */
+  SYNC_VALIDATE_BRANCH_REBUILT: (validateBranch) => `\u9A8C\u8BC1\u5206\u652F ${validateBranch} \u5DF2\u91CD\u5EFA`
 };
 
 // src/constants/messages/resume.ts
@@ -284,7 +295,9 @@ ${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")}`,
   /** 用户选择保留本地分支 */
-  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"
+  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",
+  /** 确认删除本地分支和验证分支 */
+  REMOVE_CONFIRM_DELETE_BRANCHES: "\u662F\u5426\u540C\u65F6\u5220\u9664\u5BF9\u5E94\u7684\u672C\u5730\u5206\u652F\u548C\u9A8C\u8BC1\u5206\u652F\uFF1F"
 };
 
 // src/constants/messages/reset.ts
@@ -402,7 +415,7 @@ var PROJECTS_MESSAGES = {
 // src/constants/messages/completion.ts
 var COMPLETION_MESSAGES = {
   /** completion 命令的主描述 */
-  COMPLETION_COMMAND_DESC: "\u751F\u6210\u548C\u5B89\u88C5 shell \u81EA\u52A8\u8865\u5168\u811A\u672C",
+  COMPLETION_COMMAND_DESC: "\u4E3A\u7EC8\u7AEF\u63D0\u4F9B shell \u81EA\u52A8\u8865\u5168\u529F\u80FD\uFF08bash/zsh\uFF09",
   /** bash 子命令描述 */
   COMPLETION_BASH_DESC: "\u8F93\u51FA bash \u81EA\u52A8\u8865\u5168\u811A\u672C",
   /** zsh 子命令描述 */
@@ -434,6 +447,78 @@ var UPDATE_MESSAGES = {
   UPDATE_HINT: (command) => `\u6267\u884C ${command} \u8FDB\u884C\u66F4\u65B0`
 };
 
+// src/constants/messages/init.ts
+var INIT_MESSAGES = {
+  /** init 成功 */
+  INIT_SUCCESS: (branch) => `\u2713 \u9879\u76EE\u521D\u59CB\u5316\u6210\u529F\uFF0C\u4E3B\u5DE5\u4F5C\u5206\u652F\u8BBE\u7F6E\u4E3A: ${branch}`,
+  /** init 更新 */
+  INIT_UPDATED: (oldBranch, newBranch) => `\u2713 \u5DF2\u5C06\u4E3B\u5DE5\u4F5C\u5206\u652F\u4ECE ${oldBranch} \u66F4\u65B0\u4E3A ${newBranch}`,
+  /** init show 查看当前项目完整配置（JSON 格式） */
+  INIT_SHOW: (configJson) => `${configJson}`,
+  /** init 未初始化 */
+  INIT_NOT_INITIALIZED: "\u9879\u76EE\u5C1A\u672A\u521D\u59CB\u5316\uFF0C\u8BF7\u5148\u6267\u884C clawt init \u8BBE\u7F6E\u4E3B\u5DE5\u4F5C\u5206\u652F",
+  /** 项目未初始化（requireProjectConfig 使用） */
+  PROJECT_NOT_INITIALIZED: "\u9879\u76EE\u5C1A\u672A\u521D\u59CB\u5316\uFF0C\u8BF7\u5148\u6267\u884C clawt init \u8BBE\u7F6E\u4E3B\u5DE5\u4F5C\u5206\u652F",
+  /** 项目配置缺少 clawtMainWorkBranch 字段 */
+  PROJECT_CONFIG_MISSING_BRANCH: "\u9879\u76EE\u914D\u7F6E\u7F3A\u5C11\u4E3B\u5DE5\u4F5C\u5206\u652F\u4FE1\u606F\uFF0C\u8BF7\u91CD\u65B0\u6267\u884C clawt init \u8BBE\u7F6E\u4E3B\u5DE5\u4F5C\u5206\u652F"
+};
+
+// src/constants/messages/interactive-panel.ts
+import chalk from "chalk";
+
+// src/constants/interactive-panel.ts
+var PANEL_REFRESH_INTERVAL_MS = 5e3;
+var PANEL_COUNTDOWN_INTERVAL_MS = 1e3;
+var SELECTED_INDICATOR = "\u25B6";
+var UNSELECTED_INDICATOR = " ";
+var KEY_ARROW_UP = "\x1B[A";
+var KEY_ARROW_DOWN = "\x1B[B";
+var KEY_CTRL_C = 3;
+var PANEL_SHORTCUT_KEYS = {
+  /** 验证 */
+  VALIDATE: "v",
+  /** 合并 */
+  MERGE: "m",
+  /** 删除 */
+  DELETE: "d",
+  /** 恢复 */
+  RESUME: "r",
+  /** 同步 */
+  SYNC: "s",
+  /** 手动刷新 */
+  REFRESH: "f",
+  /** 退出 */
+  QUIT: "q"
+};
+var PANEL_DATE_SEPARATOR_PREFIX = "\u2550\u2550\u2550\u2550";
+var PANEL_FIXED_ROWS = 4;
+
+// src/constants/messages/interactive-panel.ts
+var SHORTCUT_LABELS = {
+  VALIDATE: "\u9A8C\u8BC1",
+  MERGE: "\u5408\u5E76",
+  DELETE: "\u5220\u9664",
+  RESUME: "\u6062\u590D",
+  SYNC: "\u540C\u6B65",
+  REFRESH: "\u5237\u65B0",
+  QUIT: "\u9000\u51FA"
+};
+var PANEL_FOOTER_SHORTCUTS = Object.entries(SHORTCUT_LABELS).map(([key, label]) => `[${chalk.cyan(PANEL_SHORTCUT_KEYS[key])}]${label}`).join("  ");
+var PANEL_FOOTER_COUNTDOWN = (seconds) => chalk.gray(`(${seconds}s \u540E\u5237\u65B0)`);
+var PANEL_OVERFLOW_DOWN_HINT = chalk.gray("\u2193 \u66F4\u591A worktree...");
+var PANEL_OVERFLOW_UP_HINT = chalk.gray("\u2191 \u66F4\u591A worktree...");
+var PANEL_SNAPSHOT_SUMMARY = (total, orphaned) => {
+  const base = `\u5FEB\u7167: ${total} \u4E2A`;
+  if (orphaned > 0) {
+    return `${base}\uFF08${chalk.yellow(`${orphaned} \u4E2A\u5B64\u7ACB`)}\uFF09`;
+  }
+  return base;
+};
+var PANEL_NO_WORKTREES = "(\u65E0\u6D3B\u8DC3 worktree)";
+var PANEL_PRESS_ENTER_TO_RETURN = chalk.gray("\n\u6309 Enter \u8FD4\u56DE\u9762\u677F...");
+var PANEL_NOT_TTY = "\u4EA4\u4E92\u5F0F\u9762\u677F\u9700\u8981 TTY \u7EC8\u7AEF\u73AF\u5883\uFF0C\u8BF7\u76F4\u63A5\u5728\u7EC8\u7AEF\u4E2D\u8FD0\u884C clawt status -i";
+var PANEL_TITLE = (projectName) => chalk.bold.cyan(`\u9879\u76EE\u72B6\u6001\u603B\u89C8: ${projectName}`);
+
 // src/constants/messages/index.ts
 var MESSAGES = {
   ...COMMON_MESSAGES,
@@ -449,7 +534,8 @@ var MESSAGES = {
   ...STATUS_MESSAGES,
   ...ALIAS_MESSAGES,
   ...PROJECTS_MESSAGES,
-  ...COMPLETION_MESSAGES
+  ...COMPLETION_MESSAGES,
+  ...INIT_MESSAGES
 };
 
 // src/constants/exitCodes.ts
@@ -567,14 +653,14 @@ var CLEAR_SCREEN = "\x1B[2J";
 var CURSOR_HOME = "\x1B[H";
 
 // src/constants/prompt.ts
-import chalk from "chalk";
+import chalk2 from "chalk";
 var SELECT_ALL_NAME = "__select_all__";
 var SELECT_ALL_LABEL = "[select-all]";
 var GROUP_SELECT_ALL_PREFIX = "__group_select_all_";
 var GROUP_SELECT_ALL_LABEL = (dateLabel) => `[select-all: ${dateLabel}]`;
-var GROUP_SEPARATOR_LABEL = (dateLabel, relativeTime) => `\u2550\u2550\u2550\u2550 ${chalk.bold.hex("#FF8C00")(dateLabel)}\uFF08${chalk.hex("#FF8C00")(relativeTime)}\uFF09 \u2550\u2550\u2550\u2550`;
+var GROUP_SEPARATOR_LABEL = (dateLabel, relativeTime) => `\u2550\u2550\u2550\u2550 ${chalk2.bold.hex("#FF8C00")(dateLabel)}\uFF08${chalk2.hex("#FF8C00")(relativeTime)}\uFF09 \u2550\u2550\u2550\u2550`;
 var UNKNOWN_DATE_GROUP = "\u672A\u77E5\u65E5\u671F";
-var UNKNOWN_DATE_SEPARATOR_LABEL = `\u2550\u2550\u2550\u2550 ${chalk.bold.hex("#FF8C00")("\u672A\u77E5\u65E5\u671F")} \u2550\u2550\u2550\u2550`;
+var UNKNOWN_DATE_SEPARATOR_LABEL = `\u2550\u2550\u2550\u2550 ${chalk2.bold.hex("#FF8C00")("\u672A\u77E5\u65E5\u671F")} \u2550\u2550\u2550\u2550`;
 
 // src/errors/index.ts
 var ClawtError = class extends Error {
@@ -594,7 +680,7 @@ var ClawtError = class extends Error {
 // src/logger/index.ts
 import winston from "winston";
 import DailyRotateFile from "winston-daily-rotate-file";
-import chalk2 from "chalk";
+import chalk3 from "chalk";
 import { existsSync, mkdirSync } from "fs";
 if (!existsSync(LOGS_DIR)) {
   mkdirSync(LOGS_DIR, { recursive: true });
@@ -619,13 +705,13 @@ var logger = winston.createLogger({
   transports: [dailyRotateTransport]
 });
 var LEVEL_COLORS = {
-  error: chalk2.red,
-  warn: chalk2.yellow,
-  info: chalk2.cyan,
-  debug: chalk2.gray
+  error: chalk3.red,
+  warn: chalk3.yellow,
+  info: chalk3.cyan,
+  debug: chalk3.gray
 };
 function colorizeLevel(level) {
-  const colorFn = LEVEL_COLORS[level] || chalk2.white;
+  const colorFn = LEVEL_COLORS[level] || chalk3.white;
   return colorFn(level.toUpperCase().padEnd(5));
 }
 function enableConsoleTransport() {
@@ -636,7 +722,7 @@ function enableConsoleTransport() {
     return;
   }
   const consoleFormat = winston.format.printf(({ level, message, timestamp }) => {
-    return `${chalk2.gray(timestamp)} ${colorizeLevel(level)} ${message}`;
+    return `${chalk3.gray(timestamp)} ${colorizeLevel(level)} ${message}`;
   });
   const consoleTransport = new winston.transports.Console({
     level: "debug",
@@ -902,24 +988,30 @@ function getBranchCreatedAt(branchName, cwd) {
     return null;
   }
 }
+function gitCheckout(branchName, cwd) {
+  execCommand(`git checkout ${branchName}`, { cwd });
+}
+function createBranch(branchName, cwd) {
+  execCommand(`git branch ${branchName}`, { cwd });
+}
 
 // src/utils/formatter.ts
-import chalk3 from "chalk";
+import chalk4 from "chalk";
 import { createInterface } from "readline";
 function printSuccess(message) {
-  console.log(chalk3.green(message));
+  console.log(chalk4.green(message));
 }
 function printError(message) {
-  console.error(chalk3.red(`\u2717 ${message}`));
+  console.error(chalk4.red(`\u2717 ${message}`));
 }
 function printWarning(message) {
-  console.log(chalk3.yellow(`\u26A0 ${message}`));
+  console.log(chalk4.yellow(`\u26A0 ${message}`));
 }
 function printInfo(message) {
   console.log(message);
 }
 function printHint(message) {
-  console.log(chalk3.hex("#FF8C00")(message));
+  console.log(chalk4.hex("#FF8C00")(message));
 }
 function printSeparator() {
   console.log(MESSAGES.SEPARATOR);
@@ -940,7 +1032,7 @@ function confirmAction(question) {
   });
 }
 function confirmDestructiveAction(dangerousCommand, description) {
-  printWarning(`\u5373\u5C06\u6267\u884C ${chalk3.red.bold(dangerousCommand)}\uFF0C${description}`);
+  printWarning(`\u5373\u5C06\u6267\u884C ${chalk4.red.bold(dangerousCommand)}\uFF0C${description}`);
   return confirmAction("\u662F\u5426\u7EE7\u7EED\uFF1F");
 }
 function isWorktreeIdle(status) {
@@ -948,17 +1040,17 @@ function isWorktreeIdle(status) {
 }
 function formatWorktreeStatus(status) {
   const parts = [];
-  parts.push(chalk3.yellow(`${status.commitCount} \u4E2A\u63D0\u4EA4`));
+  parts.push(chalk4.yellow(`${status.commitCount} \u4E2A\u63D0\u4EA4`));
   if (status.insertions === 0 && status.deletions === 0) {
     parts.push("\u65E0\u53D8\u66F4");
   } else {
     const diffParts = [];
-    diffParts.push(chalk3.green(`+${status.insertions}`));
-    diffParts.push(chalk3.red(`-${status.deletions}`));
+    diffParts.push(chalk4.green(`+${status.insertions}`));
+    diffParts.push(chalk4.red(`-${status.deletions}`));
     parts.push(diffParts.join(" "));
   }
   if (status.hasDirtyFiles) {
-    parts.push(chalk3.gray("(\u672A\u63D0\u4EA4\u4FEE\u6539)"));
+    parts.push(chalk4.gray("(\u672A\u63D0\u4EA4\u4FEE\u6539)"));
   }
   return parts.join("   ");
 }
@@ -1076,8 +1168,8 @@ function validateClaudeCodeInstalled() {
 }
 
 // src/utils/worktree.ts
-import { join as join3 } from "path";
-import { existsSync as existsSync3, readdirSync as readdirSync2 } from "fs";
+import { join as join4 } from "path";
+import { existsSync as existsSync4, readdirSync as readdirSync2 } from "fs";
 
 // src/utils/fs.ts
 import { existsSync as existsSync2, mkdirSync as mkdirSync2, readdirSync, rmdirSync, statSync } from "fs";
@@ -1118,10 +1210,152 @@ function calculateDirSize(dirPath) {
   return totalSize;
 }
 
+// src/utils/validate-branch.ts
+import Enquirer from "enquirer";
+
+// src/utils/project-config.ts
+import { existsSync as existsSync3, readFileSync, writeFileSync } from "fs";
+import { join as join3 } from "path";
+function getProjectConfigPath(projectName) {
+  return join3(PROJECTS_CONFIG_DIR, projectName, "config.json");
+}
+function loadProjectConfig() {
+  const projectName = getProjectName();
+  const configPath = getProjectConfigPath(projectName);
+  if (!existsSync3(configPath)) {
+    return null;
+  }
+  try {
+    const raw = readFileSync(configPath, "utf-8");
+    return JSON.parse(raw);
+  } catch (error) {
+    logger.warn(`\u9879\u76EE\u914D\u7F6E\u6587\u4EF6\u89E3\u6790\u5931\u8D25: ${error}`);
+    return null;
+  }
+}
+function saveProjectConfig(config2) {
+  const projectName = getProjectName();
+  const configPath = getProjectConfigPath(projectName);
+  const projectDir = join3(PROJECTS_CONFIG_DIR, projectName);
+  ensureDir(projectDir);
+  writeFileSync(configPath, JSON.stringify(config2, null, 2), "utf-8");
+  logger.info(`\u9879\u76EE\u914D\u7F6E\u5DF2\u4FDD\u5B58: ${configPath}`);
+}
+function requireProjectConfig() {
+  const config2 = loadProjectConfig();
+  if (!config2) {
+    throw new ClawtError(MESSAGES.PROJECT_NOT_INITIALIZED);
+  }
+  if (!config2.clawtMainWorkBranch) {
+    throw new ClawtError(MESSAGES.PROJECT_CONFIG_MISSING_BRANCH);
+  }
+  return config2;
+}
+function getMainWorkBranch() {
+  const config2 = requireProjectConfig();
+  return config2.clawtMainWorkBranch;
+}
+
+// src/utils/validate-branch.ts
+function getValidateBranchName(branchName) {
+  return `${VALIDATE_BRANCH_PREFIX}${branchName}`;
+}
+function createValidateBranch(branchName, cwd) {
+  const validateBranchName = getValidateBranchName(branchName);
+  if (checkBranchExists(validateBranchName, cwd)) {
+    logger.info(`\u9A8C\u8BC1\u5206\u652F\u5DF2\u5B58\u5728\uFF0C\u8DF3\u8FC7\u521B\u5EFA: ${validateBranchName}`);
+    return;
+  }
+  createBranch(validateBranchName, cwd);
+  logger.info(`\u9A8C\u8BC1\u5206\u652F\u5DF2\u521B\u5EFA: ${validateBranchName}`);
+}
+function deleteValidateBranch(branchName, cwd) {
+  const validateBranchName = getValidateBranchName(branchName);
+  if (!checkBranchExists(validateBranchName, cwd)) {
+    logger.info(`\u9A8C\u8BC1\u5206\u652F\u4E0D\u5B58\u5728\uFF0C\u8DF3\u8FC7\u5220\u9664: ${validateBranchName}`);
+    return;
+  }
+  deleteBranch(validateBranchName, cwd);
+  logger.info(`\u9A8C\u8BC1\u5206\u652F\u5DF2\u5220\u9664: ${validateBranchName}`);
+}
+async function rebuildValidateBranch(branchName, cwd) {
+  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(`\u9A8C\u8BC1\u5206\u652F\u5DF2\u91CD\u5EFA: ${getValidateBranchName(branchName)}`);
+}
+async function handleDirtyWorkingDir(cwd) {
+  printWarning("\u5F53\u524D\u5206\u652F\u6709\u672A\u63D0\u4EA4\u7684\u66F4\u6539\uFF0C\u8BF7\u9009\u62E9\u5904\u7406\u65B9\u5F0F\uFF1A\n");
+  const choice = await new Enquirer.Select({
+    message: "\u9009\u62E9\u5904\u7406\u65B9\u5F0F",
+    choices: [
+      {
+        name: "reset",
+        message: "reset        - \u4E22\u5F03\u6240\u6709\u66F4\u6539 (git reset --hard HEAD && git clean -fd)"
+      },
+      {
+        name: "stash",
+        message: "stash        - \u6682\u5B58\u66F4\u6539 (git add . && git stash)"
+      },
+      {
+        name: "exit",
+        message: "exit         - \u9000\u51FA\uFF0C\u624B\u52A8\u5904\u7406"
+      }
+    ],
+    initial: 0
+  }).run();
+  if (choice === "exit") {
+    throw new ClawtError("\u7528\u6237\u9009\u62E9\u9000\u51FA\uFF0C\u8BF7\u624B\u52A8\u5904\u7406\u5DE5\u4F5C\u533A\u66F4\u6539\u540E\u91CD\u8BD5");
+  }
+  if (choice === "reset") {
+    gitResetHard(cwd);
+    gitCleanForce(cwd);
+  } else if (choice === "stash") {
+    gitAddAll(cwd);
+    gitStashPush("clawt:auto-stash", cwd);
+  }
+  if (!isWorkingDirClean(cwd)) {
+    throw new ClawtError("\u5DE5\u4F5C\u533A\u4ECD\u7136\u4E0D\u5E72\u51C0\uFF0C\u8BF7\u624B\u52A8\u5904\u7406");
+  }
+}
+async function ensureOnMainWorkBranch(cwd) {
+  const mainBranch = getMainWorkBranch();
+  const currentBranch = getCurrentBranch(cwd);
+  if (currentBranch === mainBranch) {
+    return;
+  }
+  if (currentBranch.startsWith(VALIDATE_BRANCH_PREFIX)) {
+    logger.info(`\u5F53\u524D\u5728\u9A8C\u8BC1\u5206\u652F ${currentBranch} \u4E0A\uFF0C\u81EA\u52A8\u5207\u56DE\u4E3B\u5DE5\u4F5C\u5206\u652F ${mainBranch}`);
+    if (!isWorkingDirClean(cwd)) {
+      gitResetHard(cwd);
+      gitCleanForce(cwd);
+    }
+    gitCheckout(mainBranch, cwd);
+    return;
+  }
+  logger.info(`\u5F53\u524D\u5728\u5206\u652F ${currentBranch} \u4E0A\uFF0C\u9700\u5207\u6362\u5230\u4E3B\u5DE5\u4F5C\u5206\u652F ${mainBranch}`);
+  if (!isWorkingDirClean(cwd)) {
+    await handleDirtyWorkingDir(cwd);
+  }
+  gitCheckout(mainBranch, cwd);
+}
+
 // src/utils/worktree.ts
 function getProjectWorktreeDir() {
   const projectName = getProjectName();
-  return join3(WORKTREES_DIR, projectName);
+  return join4(WORKTREES_DIR, projectName);
 }
 function createWorktrees(branchName, count) {
   const sanitized = sanitizeBranchName(branchName);
@@ -1131,8 +1365,9 @@ function createWorktrees(branchName, count) {
   ensureDir(projectDir);
   const results = [];
   for (const name of branchNames) {
-    const worktreePath = join3(projectDir, name);
+    const worktreePath = join4(projectDir, name);
     createWorktree(name, worktreePath);
+    createValidateBranch(name);
     results.push({ path: worktreePath, branch: name });
     logger.info(`worktree \u521B\u5EFA\u5B8C\u6210: ${worktreePath} (\u5206\u652F: ${name})`);
   }
@@ -1144,8 +1379,9 @@ function createWorktreesByBranches(branchNames) {
   ensureDir(projectDir);
   const results = [];
   for (const name of branchNames) {
-    const worktreePath = join3(projectDir, name);
+    const worktreePath = join4(projectDir, name);
     createWorktree(name, worktreePath);
+    createValidateBranch(name);
     results.push({ path: worktreePath, branch: name });
     logger.info(`worktree \u521B\u5EFA\u5B8C\u6210: ${worktreePath} (\u5206\u652F: ${name})`);
   }
@@ -1153,7 +1389,7 @@ function createWorktreesByBranches(branchNames) {
 }
 function getProjectWorktrees() {
   const projectDir = getProjectWorktreeDir();
-  if (!existsSync3(projectDir)) {
+  if (!existsSync4(projectDir)) {
     return [];
   }
   const worktreeListOutput = gitWorktreeList();
@@ -1166,7 +1402,7 @@ function getProjectWorktrees() {
     if (!entry.isDirectory()) {
       continue;
     }
-    const fullPath = join3(projectDir, entry.name);
+    const fullPath = join4(projectDir, entry.name);
     if (registeredPaths.has(fullPath)) {
       worktrees.push({
         path: fullPath,
@@ -1181,6 +1417,7 @@ function cleanupWorktrees(worktrees) {
     try {
       removeWorktreeByPath(wt.path);
       deleteBranch(wt.branch);
+      deleteValidateBranch(wt.branch);
       logger.info(`\u5DF2\u6E05\u7406 worktree \u548C\u5206\u652F: ${wt.branch}`);
     } catch (error) {
       logger.error(`\u6E05\u7406 worktree \u5931\u8D25: ${wt.path} - ${error}`);
@@ -1203,13 +1440,13 @@ function getWorktreeStatus(worktree) {
 }
 
 // src/utils/config.ts
-import { existsSync as existsSync4, readFileSync, writeFileSync } from "fs";
+import { existsSync as existsSync5, readFileSync as readFileSync2, writeFileSync as writeFileSync2 } from "fs";
 function loadConfig() {
-  if (!existsSync4(CONFIG_PATH)) {
+  if (!existsSync5(CONFIG_PATH)) {
     return { ...DEFAULT_CONFIG };
   }
   try {
-    const raw = readFileSync(CONFIG_PATH, "utf-8");
+    const raw = readFileSync2(CONFIG_PATH, "utf-8");
     return { ...DEFAULT_CONFIG, ...JSON.parse(raw) };
   } catch {
     logger.warn(MESSAGES.CONFIG_CORRUPTED);
@@ -1218,13 +1455,13 @@ function loadConfig() {
   }
 }
 function writeConfig(config2) {
-  writeFileSync(CONFIG_PATH, JSON.stringify(config2, null, 2), "utf-8");
+  writeFileSync2(CONFIG_PATH, JSON.stringify(config2, null, 2), "utf-8");
 }
 function writeDefaultConfig() {
   writeConfig(DEFAULT_CONFIG);
 }
 function saveConfig(config2) {
-  writeFileSync(CONFIG_PATH, JSON.stringify(config2, null, 2), "utf-8");
+  writeFileSync2(CONFIG_PATH, JSON.stringify(config2, null, 2), "utf-8");
 }
 function getConfigValue(key) {
   const config2 = loadConfig();
@@ -1234,6 +1471,7 @@ function ensureClawtDirs() {
   ensureDir(CLAWT_HOME);
   ensureDir(LOGS_DIR);
   ensureDir(WORKTREES_DIR);
+  ensureDir(PROJECTS_CONFIG_DIR);
 }
 function parseConcurrency(optionValue, configValue) {
   if (optionValue === void 0) {
@@ -1247,18 +1485,18 @@ function parseConcurrency(optionValue, configValue) {
 }
 
 // src/utils/prompt.ts
-import Enquirer from "enquirer";
+import Enquirer2 from "enquirer";
 
 // src/utils/claude.ts
 import { spawnSync as spawnSync2 } from "child_process";
-import { existsSync as existsSync6, readdirSync as readdirSync3 } from "fs";
-import { join as join4 } from "path";
+import { existsSync as existsSync7, readdirSync as readdirSync3 } from "fs";
+import { join as join5 } from "path";
 
 // src/utils/terminal.ts
 import { execFileSync as execFileSync2 } from "child_process";
-import { existsSync as existsSync5 } from "fs";
+import { existsSync as existsSync6 } from "fs";
 function isITerm2Installed() {
-  return existsSync5(ITERM2_APP_PATH);
+  return existsSync6(ITERM2_APP_PATH);
 }
 function detectTerminalApp() {
   const configured = getConfigValue("terminalApp");
@@ -1331,8 +1569,8 @@ function encodeClaudeProjectPath(absolutePath) {
 }
 function hasClaudeSessionHistory(worktreePath) {
   const encodedName = encodeClaudeProjectPath(worktreePath);
-  const projectDir = join4(CLAUDE_PROJECTS_DIR, encodedName);
-  if (!existsSync6(projectDir)) {
+  const projectDir = join5(CLAUDE_PROJECTS_DIR, encodedName);
+  if (!existsSync7(projectDir)) {
     return false;
   }
   const entries = readdirSync3(projectDir);
@@ -1388,20 +1626,20 @@ function launchInteractiveClaudeInNewTerminal(worktree, hasPreviousSession) {
 }
 
 // src/utils/validate-snapshot.ts
-import { join as join5 } from "path";
-import { existsSync as existsSync7, readFileSync as readFileSync2, writeFileSync as writeFileSync2, unlinkSync, readdirSync as readdirSync4, rmdirSync as rmdirSync2, statSync as statSync2 } from "fs";
+import { join as join6 } from "path";
+import { existsSync as existsSync8, readFileSync as readFileSync3, writeFileSync as writeFileSync3, unlinkSync, readdirSync as readdirSync4, rmdirSync as rmdirSync2, statSync as statSync2 } from "fs";
 function getSnapshotPath(projectName, branchName) {
-  return join5(VALIDATE_SNAPSHOTS_DIR, projectName, `${branchName}.tree`);
+  return join6(VALIDATE_SNAPSHOTS_DIR, projectName, `${branchName}.tree`);
 }
 function getSnapshotHeadPath(projectName, branchName) {
-  return join5(VALIDATE_SNAPSHOTS_DIR, projectName, `${branchName}.head`);
+  return join6(VALIDATE_SNAPSHOTS_DIR, projectName, `${branchName}.head`);
 }
 function hasSnapshot(projectName, branchName) {
-  return existsSync7(getSnapshotPath(projectName, branchName));
+  return existsSync8(getSnapshotPath(projectName, branchName));
 }
 function getSnapshotModifiedTime(projectName, branchName) {
   const snapshotPath = getSnapshotPath(projectName, branchName);
-  if (!existsSync7(snapshotPath)) return null;
+  if (!existsSync8(snapshotPath)) return null;
   const stat = statSync2(snapshotPath);
   return stat.mtime.toISOString();
 }
@@ -1409,47 +1647,47 @@ function readSnapshot(projectName, branchName) {
   const snapshotPath = getSnapshotPath(projectName, branchName);
   const headPath = getSnapshotHeadPath(projectName, branchName);
   logger.debug(`\u8BFB\u53D6 validate \u5FEB\u7167: ${snapshotPath}`);
-  const treeHash = existsSync7(snapshotPath) ? readFileSync2(snapshotPath, "utf-8").trim() : "";
-  const headCommitHash = existsSync7(headPath) ? readFileSync2(headPath, "utf-8").trim() : "";
+  const treeHash = existsSync8(snapshotPath) ? readFileSync3(snapshotPath, "utf-8").trim() : "";
+  const headCommitHash = existsSync8(headPath) ? readFileSync3(headPath, "utf-8").trim() : "";
   return { treeHash, headCommitHash };
 }
 function writeSnapshot(projectName, branchName, treeHash, headCommitHash) {
   const snapshotPath = getSnapshotPath(projectName, branchName);
   const headPath = getSnapshotHeadPath(projectName, branchName);
-  const snapshotDir = join5(VALIDATE_SNAPSHOTS_DIR, projectName);
+  const snapshotDir = join6(VALIDATE_SNAPSHOTS_DIR, projectName);
   ensureDir(snapshotDir);
-  writeFileSync2(snapshotPath, treeHash, "utf-8");
-  writeFileSync2(headPath, headCommitHash, "utf-8");
+  writeFileSync3(snapshotPath, treeHash, "utf-8");
+  writeFileSync3(headPath, headCommitHash, "utf-8");
   logger.info(`\u5DF2\u4FDD\u5B58 validate \u5FEB\u7167: ${snapshotPath}, ${headPath}`);
 }
 function removeSnapshot(projectName, branchName) {
   const snapshotPath = getSnapshotPath(projectName, branchName);
   const headPath = getSnapshotHeadPath(projectName, branchName);
-  if (existsSync7(snapshotPath)) {
+  if (existsSync8(snapshotPath)) {
     unlinkSync(snapshotPath);
     logger.info(`\u5DF2\u5220\u9664 validate \u5FEB\u7167: ${snapshotPath}`);
   }
-  if (existsSync7(headPath)) {
+  if (existsSync8(headPath)) {
     unlinkSync(headPath);
     logger.info(`\u5DF2\u5220\u9664 validate \u5FEB\u7167: ${headPath}`);
   }
 }
 function getProjectSnapshotBranches(projectName) {
-  const projectDir = join5(VALIDATE_SNAPSHOTS_DIR, projectName);
-  if (!existsSync7(projectDir)) {
+  const projectDir = join6(VALIDATE_SNAPSHOTS_DIR, projectName);
+  if (!existsSync8(projectDir)) {
     return [];
   }
   const files = readdirSync4(projectDir);
   return files.filter((f) => f.endsWith(".tree")).map((f) => f.replace(/\.tree$/, ""));
 }
 function removeProjectSnapshots(projectName) {
-  const projectDir = join5(VALIDATE_SNAPSHOTS_DIR, projectName);
-  if (!existsSync7(projectDir)) {
+  const projectDir = join6(VALIDATE_SNAPSHOTS_DIR, projectName);
+  if (!existsSync8(projectDir)) {
     return;
   }
   const files = readdirSync4(projectDir);
   for (const file of files) {
-    unlinkSync(join5(projectDir, file));
+    unlinkSync(join6(projectDir, file));
   }
   try {
     rmdirSync2(projectDir);
@@ -1459,7 +1697,7 @@ function removeProjectSnapshots(projectName) {
 }
 
 // src/utils/worktree-matcher.ts
-import Enquirer2 from "enquirer";
+import Enquirer3 from "enquirer";
 import { statSync as statSync3 } from "fs";
 function findExactMatch(worktrees, branchName) {
   return worktrees.find((wt) => wt.branch === branchName);
@@ -1469,7 +1707,7 @@ function findFuzzyMatches(worktrees, keyword) {
   return worktrees.filter((wt) => wt.branch.toLowerCase().includes(lowerKeyword));
 }
 async function promptSelectBranch(worktrees, message) {
-  const selectedBranch = await new Enquirer2.Select({
+  const selectedBranch = await new Enquirer3.Select({
     message,
     choices: worktrees.map((wt) => ({
       name: wt.branch,
@@ -1487,7 +1725,7 @@ async function promptMultiSelectBranches(worktrees, message) {
     { name: SELECT_ALL_NAME, message: SELECT_ALL_LABEL },
     ...branchChoices
   ];
-  const MultiSelect = Enquirer2.MultiSelect;
+  const MultiSelect = Enquirer3.MultiSelect;
   class MultiSelectWithSelectAll extends MultiSelect {
     space() {
       if (!this.focused) return;
@@ -1642,7 +1880,7 @@ async function promptGroupedMultiSelectBranches(worktrees, message) {
   const groupMembershipMap = buildGroupMembershipMap(groups);
   const groupSelectAllNames = new Set(groupMembershipMap.keys());
   const allBranchNames = new Set(worktrees.map((wt) => wt.branch));
-  const MultiSelect = Enquirer2.MultiSelect;
+  const MultiSelect = Enquirer3.MultiSelect;
   class MultiSelectWithGroupSelectAll extends MultiSelect {
     space() {
       if (!this.focused) return;
@@ -1700,7 +1938,7 @@ async function promptGroupedMultiSelectBranches(worktrees, message) {
 }
 
 // src/utils/progress-render.ts
-import chalk4 from "chalk";
+import chalk5 from "chalk";
 import stringWidth from "string-width";
 var ANSI_RESET = "\x1B[0m";
 function truncateToTerminalWidth(text, maxWidth) {
@@ -1737,23 +1975,23 @@ function renderTaskLine(task, total, maxPathWidth, spinnerChar) {
   const pathStr = task.path.padEnd(maxPathWidth);
   switch (task.status) {
     case "pending": {
-      return `${indexStr} ${pathStr}  ${chalk4.gray(TASK_STATUS_ICONS.PENDING)} ${chalk4.gray(TASK_STATUS_LABELS.PENDING)}`;
+      return `${indexStr} ${pathStr}  ${chalk5.gray(TASK_STATUS_ICONS.PENDING)} ${chalk5.gray(TASK_STATUS_LABELS.PENDING)}`;
     }
     case "running": {
       const elapsed = formatDuration(Date.now() - task.startedAt);
-      const detail = task.activity ? `  ${chalk4.dim(task.activity)}` : "";
-      return `${indexStr} ${pathStr}  ${chalk4.cyan(spinnerChar)} ${chalk4.cyan(TASK_STATUS_LABELS.RUNNING)} ${chalk4.gray(elapsed)}${detail}`;
+      const detail = task.activity ? `  ${chalk5.dim(task.activity)}` : "";
+      return `${indexStr} ${pathStr}  ${chalk5.cyan(spinnerChar)} ${chalk5.cyan(TASK_STATUS_LABELS.RUNNING)} ${chalk5.gray(elapsed)}${detail}`;
     }
     case "done": {
       const duration = task.durationMs != null ? formatDuration(task.durationMs) : "N/A";
       const cost = task.costUsd != null ? `$${task.costUsd.toFixed(2)}` : "";
-      const preview = task.resultPreview ? `  ${chalk4.dim(task.resultPreview)}` : "";
-      return `${indexStr} ${pathStr}  ${chalk4.green(TASK_STATUS_ICONS.DONE)} ${chalk4.green(TASK_STATUS_LABELS.DONE)}   ${chalk4.gray(duration)}  ${chalk4.yellow(cost)}${preview}`;
+      const preview = task.resultPreview ? `  ${chalk5.dim(task.resultPreview)}` : "";
+      return `${indexStr} ${pathStr}  ${chalk5.green(TASK_STATUS_ICONS.DONE)} ${chalk5.green(TASK_STATUS_LABELS.DONE)}   ${chalk5.gray(duration)}  ${chalk5.yellow(cost)}${preview}`;
     }
     case "failed": {
       const duration = task.durationMs != null ? formatDuration(task.durationMs) : "N/A";
-      const preview = task.resultPreview ? `  ${chalk4.dim(task.resultPreview)}` : "";
-      return `${indexStr} ${pathStr}  ${chalk4.red(TASK_STATUS_ICONS.FAILED)} ${chalk4.red(TASK_STATUS_LABELS.FAILED)}   ${chalk4.gray(duration)}${preview}`;
+      const preview = task.resultPreview ? `  ${chalk5.dim(task.resultPreview)}` : "";
+      return `${indexStr} ${pathStr}  ${chalk5.red(TASK_STATUS_ICONS.FAILED)} ${chalk5.red(TASK_STATUS_LABELS.FAILED)}   ${chalk5.gray(duration)}${preview}`;
     }
   }
 }
@@ -1763,10 +2001,10 @@ function renderSummaryLine(tasks, total) {
   const failed = tasks.filter((t) => t.status === "failed").length;
   const pending = tasks.filter((t) => t.status === "pending").length;
   const parts = [];
-  if (running > 0) parts.push(chalk4.cyan(`${running}/${total} ${TASK_STATUS_LABELS.RUNNING}`));
-  if (done > 0) parts.push(chalk4.green(`${done}/${total} ${TASK_STATUS_LABELS.DONE}`));
-  if (failed > 0) parts.push(chalk4.red(`${failed}/${total} ${TASK_STATUS_LABELS.FAILED}`));
-  if (pending > 0) parts.push(chalk4.gray(`${pending}/${total} ${TASK_STATUS_LABELS.PENDING}`));
+  if (running > 0) parts.push(chalk5.cyan(`${running}/${total} ${TASK_STATUS_LABELS.RUNNING}`));
+  if (done > 0) parts.push(chalk5.green(`${done}/${total} ${TASK_STATUS_LABELS.DONE}`));
+  if (failed > 0) parts.push(chalk5.red(`${failed}/${total} ${TASK_STATUS_LABELS.FAILED}`));
+  if (pending > 0) parts.push(chalk5.gray(`${pending}/${total} ${TASK_STATUS_LABELS.PENDING}`));
   return `[${parts.join(", ")}]`;
 }
 
@@ -1998,7 +2236,7 @@ var ProgressRenderer = class {
 
 // src/utils/task-file.ts
 import { resolve } from "path";
-import { existsSync as existsSync8, readFileSync as readFileSync3 } from "fs";
+import { existsSync as existsSync9, readFileSync as readFileSync4 } from "fs";
 var TASK_BLOCK_REGEX = /<!-- CLAWT-TASKS:START -->([\s\S]*?)<!-- CLAWT-TASKS:END -->/g;
 var BRANCH_LINE_REGEX = /^#\s*branch:\s*(.+)$/;
 var EMPTY_TASKS_MESSAGE = "\u4EFB\u52A1\u5217\u8868\u4E0D\u80FD\u4E3A\u7A7A";
@@ -2044,10 +2282,10 @@ function parseTaskFile(content, options) {
 }
 function loadTaskFile(filePath, options) {
   const absolutePath = resolve(filePath);
-  if (!existsSync8(absolutePath)) {
+  if (!existsSync9(absolutePath)) {
     throw new ClawtError(MESSAGES.TASK_FILE_NOT_FOUND(absolutePath));
   }
-  const content = readFileSync3(absolutePath, "utf-8");
+  const content = readFileSync4(absolutePath, "utf-8");
   const entries = parseTaskFile(content, options);
   if (entries.length === 0) {
     throw new ClawtError(MESSAGES.TASK_FILE_EMPTY);
@@ -2381,8 +2619,8 @@ async function executeBatchTasks(worktrees, tasks, concurrency) {
 }
 
 // src/utils/dry-run.ts
-import chalk5 from "chalk";
-import { join as join6 } from "path";
+import chalk6 from "chalk";
+import { join as join7 } from "path";
 var DRY_RUN_TASK_DESC_MAX_LENGTH = 80;
 function truncateTaskDesc(task) {
   const oneLine = task.replace(/\n/g, " ").trim();
@@ -2395,7 +2633,7 @@ function printDryRunPreview(branchNames, tasks, concurrency) {
   const projectDir = getProjectWorktreeDir();
   const isInteractive = tasks.length === 0;
   printDoubleSeparator();
-  printInfo(`  ${chalk5.bold(MESSAGES.DRY_RUN_TITLE)}`);
+  printInfo(`  ${chalk6.bold(MESSAGES.DRY_RUN_TITLE)}`);
   printDoubleSeparator();
   const summaryParts = [
     MESSAGES.DRY_RUN_TASK_COUNT(branchNames.length),
@@ -2405,31 +2643,31 @@ function printDryRunPreview(branchNames, tasks, concurrency) {
   if (isInteractive) {
     summaryParts.push(MESSAGES.DRY_RUN_INTERACTIVE_MODE);
   }
-  printInfo(summaryParts.join(chalk5.gray(" \u2502 ")));
+  printInfo(summaryParts.join(chalk6.gray(" \u2502 ")));
   printSeparator();
   let hasConflict = false;
   for (let i = 0; i < branchNames.length; i++) {
     const branch = branchNames[i];
-    const worktreePath = join6(projectDir, branch);
+    const worktreePath = join7(projectDir, branch);
     const exists = checkBranchExists(branch);
     if (exists) hasConflict = true;
     const indexLabel = `[${i + 1}/${branchNames.length}]`;
     if (exists) {
-      printInfo(`${chalk5.yellow("\u26A0")} ${indexLabel} ${chalk5.yellow(branch)} ${chalk5.gray("\u2014")} ${chalk5.yellow(MESSAGES.DRY_RUN_BRANCH_EXISTS_WARNING(branch))}`);
+      printInfo(`${chalk6.yellow("\u26A0")} ${indexLabel} ${chalk6.yellow(branch)} ${chalk6.gray("\u2014")} ${chalk6.yellow(MESSAGES.DRY_RUN_BRANCH_EXISTS_WARNING(branch))}`);
     } else {
-      printInfo(`${chalk5.green("\u2713")} ${indexLabel} ${chalk5.cyan(branch)}`);
+      printInfo(`${chalk6.green("\u2713")} ${indexLabel} ${chalk6.cyan(branch)}`);
     }
-    printInfo(`  ${chalk5.gray("\u8DEF\u5F84:")} ${worktreePath}`);
+    printInfo(`  ${chalk6.gray("\u8DEF\u5F84:")} ${worktreePath}`);
     if (!isInteractive) {
-      printInfo(`  ${chalk5.gray("\u4EFB\u52A1:")} ${truncateTaskDesc(tasks[i])}`);
+      printInfo(`  ${chalk6.gray("\u4EFB\u52A1:")} ${truncateTaskDesc(tasks[i])}`);
     }
     printInfo("");
   }
   printDoubleSeparator();
   if (hasConflict) {
-    printInfo(chalk5.yellow(`\u26A0 ${MESSAGES.DRY_RUN_HAS_CONFLICT}`));
+    printInfo(chalk6.yellow(`\u26A0 ${MESSAGES.DRY_RUN_HAS_CONFLICT}`));
   } else {
-    printInfo(chalk5.green(`\u2713 ${MESSAGES.DRY_RUN_READY}`));
+    printInfo(chalk6.green(`\u2713 ${MESSAGES.DRY_RUN_READY}`));
   }
 }
 
@@ -2447,8 +2685,8 @@ function applyAliases(program2, aliases) {
 }
 
 // src/utils/config-strategy.ts
-import chalk6 from "chalk";
-import Enquirer3 from "enquirer";
+import chalk7 from "chalk";
+import Enquirer4 from "enquirer";
 function isValidConfigKey(key) {
   return key in DEFAULT_CONFIG;
 }
@@ -2491,16 +2729,16 @@ async function promptConfigValue(key, currentValue) {
 }
 function formatConfigValue(value) {
   if (typeof value === "boolean") {
-    return value ? chalk6.green("true") : chalk6.yellow("false");
+    return value ? chalk7.green("true") : chalk7.yellow("false");
   }
-  return chalk6.cyan(String(value));
+  return chalk7.cyan(String(value));
 }
 async function promptBooleanValue(key, currentValue) {
   const choices = [
     { name: "true", message: "true" },
     { name: "false", message: "false" }
   ];
-  const selected = await new Enquirer3.Select({
+  const selected = await new Enquirer4.Select({
     message: MESSAGES.CONFIG_INPUT_PROMPT(key),
     choices,
     initial: currentValue ? 0 : 1
@@ -2508,7 +2746,7 @@ async function promptBooleanValue(key, currentValue) {
   return selected === "true";
 }
 async function promptNumberValue(key, currentValue) {
-  const input = await new Enquirer3.Input({
+  const input = await new Enquirer4.Input({
     message: MESSAGES.CONFIG_INPUT_PROMPT(key),
     initial: String(currentValue),
     validate: (val) => {
@@ -2523,28 +2761,28 @@ async function promptEnumValue(key, currentValue, allowedValues) {
     name: v,
     message: v
   }));
-  return await new Enquirer3.Select({
+  return await new Enquirer4.Select({
     message: MESSAGES.CONFIG_INPUT_PROMPT(key),
     choices,
     initial: allowedValues.indexOf(currentValue)
   }).run();
 }
 async function promptStringValue(key, currentValue) {
-  return await new Enquirer3.Input({
+  return await new Enquirer4.Input({
     message: MESSAGES.CONFIG_INPUT_PROMPT(key),
     initial: currentValue
   }).run();
 }
 
 // src/utils/update-checker.ts
-import { readFileSync as readFileSync4, writeFileSync as writeFileSync3 } from "fs";
+import { readFileSync as readFileSync5, writeFileSync as writeFileSync4 } from "fs";
 import { execSync as execSync3 } from "child_process";
 import { request } from "https";
-import chalk7 from "chalk";
+import chalk8 from "chalk";
 import stringWidth2 from "string-width";
 function readUpdateCache() {
   try {
-    const raw = readFileSync4(UPDATE_CHECK_PATH, "utf-8");
+    const raw = readFileSync5(UPDATE_CHECK_PATH, "utf-8");
     return JSON.parse(raw);
   } catch {
     return null;
@@ -2552,7 +2790,7 @@ function readUpdateCache() {
 }
 function writeUpdateCache(cache) {
   try {
-    writeFileSync3(UPDATE_CHECK_PATH, JSON.stringify(cache, null, 2), "utf-8");
+    writeFileSync4(UPDATE_CHECK_PATH, JSON.stringify(cache, null, 2), "utf-8");
   } catch {
   }
 }
@@ -2615,12 +2853,12 @@ function detectPackageManager() {
 }
 function printUpdateNotification(currentVersion, latestVersion) {
   const updateText = UPDATE_MESSAGES.UPDATE_AVAILABLE(
-    chalk7.red(currentVersion),
-    chalk7.green(latestVersion)
+    chalk8.red(currentVersion),
+    chalk8.green(latestVersion)
   );
   const pm = detectPackageManager();
   const updateCommand = UPDATE_COMMANDS[pm] || UPDATE_COMMANDS.npm;
-  const commandText = UPDATE_MESSAGES.UPDATE_HINT(chalk7.cyan(updateCommand));
+  const commandText = UPDATE_MESSAGES.UPDATE_HINT(chalk8.cyan(updateCommand));
   const updateTextWidth = stringWidth2(updateText);
   const commandTextWidth = stringWidth2(commandText);
   const innerWidth = Math.max(updateTextWidth, commandTextWidth) + 4;
@@ -2667,10 +2905,642 @@ async function checkForUpdates(currentVersion) {
   }
 }
 
+// src/utils/json.ts
+function primitiveToString(value) {
+  if (value === void 0) {
+    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);
+}
+function safeStringify(value, indent = 2) {
+  if (value === null || typeof value !== "object") {
+    return primitiveToString(value);
+  }
+  try {
+    const seen = /* @__PURE__ */ new WeakSet();
+    return JSON.stringify(
+      value,
+      (_key, val) => {
+        if (typeof val === "bigint") {
+          return val.toString();
+        }
+        if (typeof val === "undefined" || typeof val === "function" || typeof val === "symbol") {
+          return primitiveToString(val);
+        }
+        if (typeof val === "object" && val !== null) {
+          if (seen.has(val)) {
+            return "[Circular]";
+          }
+          seen.add(val);
+        }
+        return val;
+      },
+      indent
+    );
+  } catch {
+    try {
+      return JSON.stringify(String(value), null, indent);
+    } catch {
+      return "[Unserializable]";
+    }
+  }
+}
+
+// src/utils/interactive-panel.ts
+import { createInterface as createInterface2 } from "readline";
+
+// src/utils/interactive-panel-render.ts
+import chalk9 from "chalk";
+import stringWidth3 from "string-width";
+function buildSeparatorWithHint(cols, hint) {
+  const maxWidth = Math.min(cols, 60);
+  if (!hint) {
+    return chalk9.gray("\u2500".repeat(maxWidth));
+  }
+  const hintWidth = stringWidth3(hint);
+  const remaining = Math.max(maxWidth - 2 - hintWidth, 0);
+  const leftLen = Math.floor(remaining / 2);
+  const rightLen = remaining - leftLen;
+  return `${chalk9.gray("\u2500".repeat(leftLen))} ${hint} ${chalk9.gray("\u2500".repeat(rightLen))}`;
+}
+function buildPanelFrame(statusResult, selectedIndex, scrollOffset, rows, cols, countdown) {
+  const lines = [];
+  lines.push(PANEL_TITLE(statusResult.main.projectName));
+  lines.push(renderSnapshotSummary(statusResult.snapshots.total, statusResult.snapshots.orphaned));
+  const visibleRows = calculateVisibleRows(rows);
+  if (statusResult.worktrees.length === 0) {
+    lines.push(buildSeparatorWithHint(cols, ""));
+    lines.push(PANEL_NO_WORKTREES);
+    lines.push(buildSeparatorWithHint(cols, ""));
+  } else {
+    const panelLines = buildGroupedWorktreeLines(statusResult.worktrees, selectedIndex);
+    const hasOverflowUp = scrollOffset > 0;
+    const hasOverflowDown = scrollOffset + visibleRows < panelLines.length;
+    lines.push(buildSeparatorWithHint(cols, hasOverflowUp ? PANEL_OVERFLOW_UP_HINT : ""));
+    const visibleLines = panelLines.slice(scrollOffset, scrollOffset + visibleRows);
+    for (const pl of visibleLines) {
+      lines.push(pl.text);
+    }
+    lines.push(buildSeparatorWithHint(cols, hasOverflowDown ? PANEL_OVERFLOW_DOWN_HINT : ""));
+  }
+  lines.push(renderFooter(countdown));
+  return lines;
+}
+function buildDisplayOrder(worktrees) {
+  const worktreeInfos = worktrees.map((wt) => ({ path: wt.path, branch: wt.branch }));
+  const groups = groupWorktreesByDate(worktreeInfos);
+  const branchIndexMap = /* @__PURE__ */ new Map();
+  for (let i = 0; i < worktrees.length; i++) {
+    branchIndexMap.set(worktrees[i].branch, i);
+  }
+  const displayOrder = [];
+  for (const [, groupWorktrees] of groups) {
+    for (const gwt of groupWorktrees) {
+      displayOrder.push(branchIndexMap.get(gwt.branch));
+    }
+  }
+  return displayOrder;
+}
+function buildGroupedWorktreeLines(worktrees, selectedIndex) {
+  const panelLines = [];
+  const worktreeInfos = worktrees.map((wt) => ({ path: wt.path, branch: wt.branch }));
+  const groups = groupWorktreesByDate(worktreeInfos);
+  const branchIndexMap = /* @__PURE__ */ new Map();
+  for (let i = 0; i < worktrees.length; i++) {
+    branchIndexMap.set(worktrees[i].branch, i);
+  }
+  for (const [dateKey, groupWorktrees] of groups) {
+    panelLines.push({
+      type: "separator",
+      text: renderDateSeparator(dateKey)
+    });
+    panelLines.push({
+      type: "separator",
+      text: ""
+    });
+    for (const gwt of groupWorktrees) {
+      const wtIndex = branchIndexMap.get(gwt.branch);
+      const wt = worktrees[wtIndex];
+      const isSelected = wtIndex === selectedIndex;
+      const blockLines = renderWorktreeBlock(wt, isSelected);
+      for (const line of blockLines) {
+        panelLines.push({
+          type: "worktree-content",
+          text: line,
+          worktreeIndex: wtIndex
+        });
+      }
+    }
+  }
+  return panelLines;
+}
+function renderDateSeparator(dateKey) {
+  const leftPad = "  ";
+  if (dateKey === UNKNOWN_DATE_GROUP) {
+    return `${leftPad}${chalk9.gray(PANEL_DATE_SEPARATOR_PREFIX)} ${chalk9.bold.hex("#FF8C00")("\u672A\u77E5\u65E5\u671F")} ${chalk9.gray(PANEL_DATE_SEPARATOR_PREFIX)}`;
+  }
+  const relativeDate = formatRelativeDate(dateKey);
+  return `${leftPad}${chalk9.gray(PANEL_DATE_SEPARATOR_PREFIX)} ${chalk9.bold.hex("#FF8C00")(dateKey)}${chalk9.hex("#FF8C00")(`\uFF08${relativeDate}\uFF09`)} ${chalk9.gray(PANEL_DATE_SEPARATOR_PREFIX)}`;
+}
+function renderWorktreeBlock(wt, isSelected) {
+  const lines = [];
+  const indicator = isSelected ? chalk9.cyan(SELECTED_INDICATOR) : UNSELECTED_INDICATOR;
+  const branchStyle = isSelected ? chalk9.bold.cyan : chalk9.bold;
+  const statusLabel = formatChangeStatusLabel(wt.changeStatus);
+  lines.push(`${indicator} ${branchStyle(wt.branch)}   [${statusLabel}]`);
+  const indent = "    ";
+  if (wt.insertions > 0 || wt.deletions > 0) {
+    lines.push(`${indent}${chalk9.green(`+${wt.insertions}`)} ${chalk9.red(`-${wt.deletions}`)}`);
+  }
+  if (wt.commitsAhead > 0) {
+    lines.push(`${indent}${chalk9.yellow(`${wt.commitsAhead} \u4E2A\u672C\u5730\u63D0\u4EA4`)}`);
+  }
+  if (wt.commitsBehind > 0) {
+    lines.push(`${indent}${chalk9.yellow(`\u843D\u540E\u4E3B\u5206\u652F ${wt.commitsBehind} \u4E2A\u63D0\u4EA4`)}`);
+  } else {
+    lines.push(`${indent}${chalk9.green("\u4E0E\u4E3B\u5206\u652F\u540C\u6B65")}`);
+  }
+  if (wt.createdAt) {
+    const relativeTime = formatRelativeTime(wt.createdAt);
+    if (relativeTime) {
+      lines.push(`${indent}${chalk9.gray(MESSAGES.STATUS_CREATED_AT(relativeTime))}`);
+    }
+  }
+  if (wt.snapshotTime) {
+    const relativeTime = formatRelativeTime(wt.snapshotTime);
+    if (relativeTime) {
+      lines.push(`${indent}${chalk9.green(MESSAGES.STATUS_LAST_VALIDATED(relativeTime))}`);
+    }
+  } else {
+    lines.push(`${indent}${chalk9.red(MESSAGES.STATUS_NOT_VALIDATED)}`);
+  }
+  lines.push("");
+  return lines;
+}
+function formatChangeStatusLabel(status) {
+  switch (status) {
+    case "committed":
+      return chalk9.green(MESSAGES.STATUS_CHANGE_COMMITTED);
+    case "uncommitted":
+      return chalk9.yellow(MESSAGES.STATUS_CHANGE_UNCOMMITTED);
+    case "conflict":
+      return chalk9.red(MESSAGES.STATUS_CHANGE_CONFLICT);
+    case "clean":
+      return chalk9.gray(MESSAGES.STATUS_CHANGE_CLEAN);
+  }
+}
+function renderSnapshotSummary(total, orphaned) {
+  return PANEL_SNAPSHOT_SUMMARY(total, orphaned);
+}
+function renderFooter(countdown) {
+  return `${PANEL_FOOTER_SHORTCUTS}  ${PANEL_FOOTER_COUNTDOWN(countdown)}`;
+}
+function calculateVisibleRows(terminalRows) {
+  const fixedRows = PANEL_FIXED_ROWS + 1;
+  return Math.max(terminalRows - fixedRows, 3);
+}
+
+// src/utils/interactive-panel.ts
+var InteractivePanel = class {
+  /** 当前状态数据 */
+  statusResult;
+  /** 当前选中的显示位置索引（对应 displayOrder 数组的下标） */
+  selectedDisplayIndex;
+  /** 显示顺序到原始索引的映射（按日期分组后的排列顺序） */
+  displayOrder;
+  /** 滚动偏移（基于行数） */
+  scrollOffset;
+  /** 数据刷新定时器引用 */
+  refreshTimer;
+  /** 倒计时定时器引用 */
+  countdownTimer;
+  /** 刷新倒计时剩余秒数 */
+  refreshCountdown;
+  /** 是否已停止 */
+  stopped;
+  /** 是否为 TTY 环境 */
+  isTTY;
+  /** resize 事件处理器引用 */
+  resizeHandler;
+  /** exit 兜底处理器 */
+  exitHandler;
+  /** stdin 数据处理器引用（用于清理） */
+  stdinDataHandler;
+  /** 操作锁（防止操作期间响应按键） */
+  isOperating;
+  /** Promise resolve 函数（stop 时调用以完成 start 返回的 Promise） */
+  resolveStart;
+  /** 数据收集函数引用 */
+  collectStatusFn;
+  /**
+   * 创建交互式面板
+   * @param {() => StatusResult} collectStatusFn - 数据收集函数
+   */
+  constructor(collectStatusFn) {
+    this.statusResult = null;
+    this.selectedDisplayIndex = 0;
+    this.displayOrder = [];
+    this.scrollOffset = 0;
+    this.refreshTimer = null;
+    this.countdownTimer = null;
+    this.refreshCountdown = PANEL_REFRESH_INTERVAL_MS / 1e3;
+    this.stopped = false;
+    this.isTTY = !!process.stdout.isTTY;
+    this.resizeHandler = null;
+    this.exitHandler = null;
+    this.stdinDataHandler = null;
+    this.isOperating = false;
+    this.resolveStart = null;
+    this.collectStatusFn = collectStatusFn;
+  }
+  /**
+   * 启动交互式面板
+   * 非 TTY 时打印提示并退出
+   * @returns {Promise<void>} 面板关闭时 resolve
+   */
+  start() {
+    if (!this.isTTY) {
+      console.log(PANEL_NOT_TTY);
+      return Promise.resolve();
+    }
+    return new Promise((resolve3) => {
+      this.resolveStart = resolve3;
+      this.statusResult = this.collectStatusFn();
+      this.displayOrder = buildDisplayOrder(this.statusResult.worktrees);
+      this.initTerminal();
+      this.startKeyboardListener();
+      this.startAutoRefresh();
+      this.render();
+    });
+  }
+  /**
+   * 停止面板，恢复终端状态
+   */
+  stop() {
+    if (this.stopped) return;
+    this.stopped = true;
+    this.clearTimers();
+    this.stopKeyboardListener();
+    this.restoreTerminal();
+    if (this.resizeHandler) {
+      process.stdout.removeListener("resize", this.resizeHandler);
+      this.resizeHandler = null;
+    }
+    if (this.exitHandler) {
+      process.removeListener("exit", this.exitHandler);
+      this.exitHandler = null;
+    }
+    if (this.resolveStart) {
+      this.resolveStart();
+      this.resolveStart = null;
+    }
+  }
+  /**
+   * 初始化终端：进入备选屏幕、隐藏光标、禁用行换行
+   */
+  initTerminal() {
+    process.stdout.write(ALT_SCREEN_ENTER);
+    process.stdout.write(CURSOR_HIDE);
+    process.stdout.write(LINE_WRAP_DISABLE);
+    this.resizeHandler = () => {
+      if (!this.stopped && !this.isOperating) {
+        this.render();
+      }
+    };
+    process.stdout.on("resize", this.resizeHandler);
+    this.exitHandler = () => {
+      process.stdout.write(LINE_WRAP_ENABLE);
+      process.stdout.write(CURSOR_SHOW);
+      process.stdout.write(ALT_SCREEN_LEAVE);
+    };
+    process.on("exit", this.exitHandler);
+  }
+  /**
+   * 恢复终端：启用行换行、显示光标、退出备选屏幕
+   */
+  restoreTerminal() {
+    process.stdout.write(LINE_WRAP_ENABLE);
+    process.stdout.write(CURSOR_SHOW);
+    process.stdout.write(ALT_SCREEN_LEAVE);
+  }
+  /**
+   * 启动键盘监听
+   * 将 stdin 设为 raw 模式以捕获每个按键
+   */
+  startKeyboardListener() {
+    if (process.stdin.isTTY) {
+      process.stdin.setRawMode(true);
+    }
+    process.stdin.resume();
+    this.stdinDataHandler = (data) => {
+      this.handleKeypress(data);
+    };
+    process.stdin.on("data", this.stdinDataHandler);
+  }
+  /**
+   * 停止键盘监听，恢复 stdin 状态
+   */
+  stopKeyboardListener() {
+    if (this.stdinDataHandler) {
+      process.stdin.removeListener("data", this.stdinDataHandler);
+      this.stdinDataHandler = null;
+    }
+    if (process.stdin.isTTY) {
+      process.stdin.setRawMode(false);
+    }
+    process.stdin.pause();
+  }
+  /**
+   * 处理键盘输入
+   * @param {Buffer} data - 按键数据
+   */
+  handleKeypress(data) {
+    if (this.isOperating) return;
+    const str = data.toString();
+    if (data[0] === KEY_CTRL_C) {
+      this.stop();
+      return;
+    }
+    if (str === KEY_ARROW_UP) {
+      this.navigateUp();
+      return;
+    }
+    if (str === KEY_ARROW_DOWN) {
+      this.navigateDown();
+      return;
+    }
+    const key = str.toLowerCase();
+    if (key === PANEL_SHORTCUT_KEYS.QUIT) {
+      this.stop();
+      return;
+    }
+    if (key === PANEL_SHORTCUT_KEYS.REFRESH) {
+      this.refreshData();
+      return;
+    }
+    if (key === PANEL_SHORTCUT_KEYS.VALIDATE) {
+      this.executeOperation(() => this.handleValidate());
+      return;
+    }
+    if (key === PANEL_SHORTCUT_KEYS.MERGE) {
+      this.executeOperation(() => this.handleMerge());
+      return;
+    }
+    if (key === PANEL_SHORTCUT_KEYS.DELETE) {
+      this.executeOperation(() => this.handleDelete());
+      return;
+    }
+    if (key === PANEL_SHORTCUT_KEYS.RESUME) {
+      this.executeOperation(() => this.handleResume());
+      return;
+    }
+    if (key === PANEL_SHORTCUT_KEYS.SYNC) {
+      this.executeOperation(() => this.handleSync());
+      return;
+    }
+  }
+  /**
+   * 向上导航，选中显示顺序中的上一个 worktree
+   */
+  navigateUp() {
+    if (!this.statusResult || this.displayOrder.length === 0) return;
+    if (this.selectedDisplayIndex > 0) {
+      this.selectedDisplayIndex--;
+      this.adjustScrollForSelection();
+      this.render();
+    }
+  }
+  /**
+   * 向下导航，选中显示顺序中的下一个 worktree
+   */
+  navigateDown() {
+    if (!this.statusResult || this.displayOrder.length === 0) return;
+    if (this.selectedDisplayIndex < this.displayOrder.length - 1) {
+      this.selectedDisplayIndex++;
+      this.adjustScrollForSelection();
+      this.render();
+    }
+  }
+  /**
+   * 获取当前选中的原始 worktree 索引
+   * @returns {number} 原始 worktrees 数组中的索引
+   */
+  getSelectedOriginalIndex() {
+    return this.displayOrder[this.selectedDisplayIndex];
+  }
+  /**
+   * 调整滚动偏移以确保选中项在可见区域内
+   */
+  adjustScrollForSelection() {
+    if (!this.statusResult || this.displayOrder.length === 0) return;
+    const originalIndex = this.getSelectedOriginalIndex();
+    const rows = process.stdout.rows || 24;
+    const visibleRows = calculateVisibleRows(rows);
+    const panelLines = buildGroupedWorktreeLines(this.statusResult.worktrees, originalIndex);
+    let firstLine = -1;
+    let lastLine = -1;
+    for (let i = 0; i < panelLines.length; i++) {
+      if (panelLines[i].worktreeIndex === originalIndex) {
+        if (firstLine === -1) firstLine = i;
+        lastLine = i;
+      }
+    }
+    if (firstLine === -1) return;
+    let groupStart = firstLine;
+    while (groupStart > 0 && panelLines[groupStart - 1].type === "separator") {
+      groupStart--;
+    }
+    if (groupStart < this.scrollOffset) {
+      this.scrollOffset = groupStart;
+    }
+    if (lastLine >= this.scrollOffset + visibleRows) {
+      this.scrollOffset = lastLine - visibleRows + 1;
+    }
+    if (this.scrollOffset > groupStart) {
+      this.scrollOffset = groupStart;
+    }
+  }
+  /**
+   * 启动自动刷新：数据刷新定时器 + 倒计时定时器
+   */
+  startAutoRefresh() {
+    this.refreshCountdown = PANEL_REFRESH_INTERVAL_MS / 1e3;
+    this.refreshTimer = setInterval(() => {
+      this.refreshData();
+    }, PANEL_REFRESH_INTERVAL_MS);
+    this.countdownTimer = setInterval(() => {
+      if (this.refreshCountdown > 0) {
+        this.refreshCountdown--;
+      }
+      this.render();
+    }, PANEL_COUNTDOWN_INTERVAL_MS);
+    if (this.refreshTimer.unref) this.refreshTimer.unref();
+    if (this.countdownTimer.unref) this.countdownTimer.unref();
+  }
+  /**
+   * 清除所有定时器
+   */
+  clearTimers() {
+    if (this.refreshTimer) {
+      clearInterval(this.refreshTimer);
+      this.refreshTimer = null;
+    }
+    if (this.countdownTimer) {
+      clearInterval(this.countdownTimer);
+      this.countdownTimer = null;
+    }
+  }
+  /**
+   * 刷新数据：记录当前选中分支 → 重新收集 → 恢复选中位置 → 重置倒计时 → 重绘
+   */
+  refreshData() {
+    if (this.stopped || this.isOperating) return;
+    const originalIndex = this.displayOrder[this.selectedDisplayIndex];
+    const previousBranch = this.statusResult?.worktrees[originalIndex]?.branch;
+    this.statusResult = this.collectStatusFn();
+    this.displayOrder = buildDisplayOrder(this.statusResult.worktrees);
+    this.restoreSelection(previousBranch);
+    this.refreshCountdown = PANEL_REFRESH_INTERVAL_MS / 1e3;
+    this.render();
+  }
+  /**
+   * 按分支名恢复选中位置（基于显示顺序）
+   * @param {string | undefined} previousBranch - 之前选中的分支名
+   */
+  restoreSelection(previousBranch) {
+    if (!this.statusResult || !previousBranch || this.displayOrder.length === 0) {
+      this.selectedDisplayIndex = 0;
+      return;
+    }
+    const newDisplayIndex = this.displayOrder.findIndex(
+      (origIdx) => this.statusResult.worktrees[origIdx]?.branch === previousBranch
+    );
+    if (newDisplayIndex >= 0) {
+      this.selectedDisplayIndex = newDisplayIndex;
+    } else {
+      this.selectedDisplayIndex = Math.min(this.selectedDisplayIndex, Math.max(0, this.displayOrder.length - 1));
+    }
+    this.adjustScrollForSelection();
+  }
+  /**
+   * 渲染一帧面板内容
+   * 使用同步输出防止闪烁
+   */
+  render() {
+    if (this.stopped || this.isOperating || !this.statusResult) return;
+    const cols = process.stdout.columns || DEFAULT_TERMINAL_COLUMNS;
+    const rows = process.stdout.rows || 24;
+    const frameLines = buildPanelFrame(
+      this.statusResult,
+      this.getSelectedOriginalIndex(),
+      this.scrollOffset,
+      rows,
+      cols,
+      this.refreshCountdown
+    );
+    process.stdout.write(SYNC_OUTPUT_START);
+    process.stdout.write(CLEAR_SCREEN);
+    process.stdout.write(CURSOR_HOME);
+    for (let i = 0; i < frameLines.length; i++) {
+      const suffix = i < frameLines.length - 1 ? "\n" : "";
+      process.stdout.write(`${truncateToTerminalWidth(frameLines[i], cols)}${suffix}`);
+    }
+    process.stdout.write(SYNC_OUTPUT_END);
+  }
+  /**
+   * 执行操作：暂停面板 → 恢复终端 → 执行命令 → 等待回车 → 恢复面板
+   * @param {() => void} action - 要执行的操作
+   */
+  async executeOperation(action) {
+    if (!this.statusResult || this.displayOrder.length === 0) return;
+    this.isOperating = true;
+    this.clearTimers();
+    this.restoreTerminal();
+    this.stopKeyboardListener();
+    action();
+    console.log(PANEL_PRESS_ENTER_TO_RETURN);
+    await this.waitForEnter();
+    this.initTerminal();
+    this.startKeyboardListener();
+    this.isOperating = false;
+    this.refreshData();
+    this.startAutoRefresh();
+    this.render();
+  }
+  /**
+   * 获取当前选中的分支名
+   * @returns {string} 当前选中的分支名
+   */
+  getSelectedBranch() {
+    const originalIndex = this.getSelectedOriginalIndex();
+    return this.statusResult.worktrees[originalIndex].branch;
+  }
+  /**
+   * 执行验证操作
+   */
+  handleValidate() {
+    const branch = this.getSelectedBranch();
+    runCommandInherited(`clawt validate -b ${branch}`);
+  }
+  /**
+   * 执行合并操作
+   */
+  handleMerge() {
+    const branch = this.getSelectedBranch();
+    runCommandInherited(`clawt merge -b ${branch}`);
+  }
+  /**
+   * 执行删除操作
+   */
+  handleDelete() {
+    const branch = this.getSelectedBranch();
+    runCommandInherited(`clawt remove -b ${branch}`);
+  }
+  /**
+   * 执行恢复操作
+   */
+  handleResume() {
+    const branch = this.getSelectedBranch();
+    runCommandInherited(`clawt resume -b ${branch}`);
+  }
+  /**
+   * 执行同步操作
+   */
+  handleSync() {
+    const branch = this.getSelectedBranch();
+    runCommandInherited(`clawt sync -b ${branch}`);
+  }
+  /**
+   * 等待用户按回车键
+   * @returns {Promise<void>} 用户按回车时 resolve
+   */
+  waitForEnter() {
+    return new Promise((resolve3) => {
+      const rl = createInterface2({
+        input: process.stdin,
+        output: process.stdout
+      });
+      rl.once("line", () => {
+        rl.close();
+        resolve3();
+      });
+    });
+  }
+};
+
 // src/commands/list.ts
-import chalk8 from "chalk";
+import chalk10 from "chalk";
 function registerListCommand(program2) {
-  program2.command("list").description("\u5217\u51FA\u5F53\u524D\u9879\u76EE\u6240\u6709 worktree").option("--json", "\u4EE5 JSON \u683C\u5F0F\u8F93\u51FA").action((options) => {
+  program2.command("list").description("\u5217\u51FA\u5F53\u524D\u9879\u76EE\u6240\u6709 worktree\uFF08\u652F\u6301 --json \u683C\u5F0F\u8F93\u51FA\uFF09").option("--json", "\u4EE5 JSON \u683C\u5F0F\u8F93\u51FA").action((options) => {
     handleList(options);
   });
 }
@@ -2705,12 +3575,12 @@ function printListAsText(projectName, worktrees) {
     for (const wt of worktrees) {
       const status = getWorktreeStatus(wt);
       const isIdle = status ? isWorktreeIdle(status) : false;
-      const pathDisplay = isIdle ? chalk8.hex("#FF8C00")(wt.path) : wt.path;
+      const pathDisplay = isIdle ? chalk10.hex("#FF8C00")(wt.path) : wt.path;
       printInfo(`  ${pathDisplay}   [${wt.branch}]`);
       if (status) {
         printInfo(`    ${formatWorktreeStatus(status)}`);
       } else {
-        printInfo(`    ${chalk8.yellow(MESSAGES.WORKTREE_STATUS_UNAVAILABLE)}`);
+        printInfo(`    ${chalk10.yellow(MESSAGES.WORKTREE_STATUS_UNAVAILABLE)}`);
       }
       printInfo("");
     }
@@ -2720,12 +3590,13 @@ function printListAsText(projectName, worktrees) {
 
 // src/commands/create.ts
 function registerCreateCommand(program2) {
-  program2.command("create").description("\u6279\u91CF\u521B\u5EFA worktree \u53CA\u5BF9\u5E94\u5206\u652F").requiredOption("-b, --branch <branchName>", "\u5206\u652F\u540D").option("-n, --number <count>", "\u521B\u5EFA\u6570\u91CF", "1").action((options) => {
-    handleCreate(options);
+  program2.command("create").description("\u6279\u91CF\u521B\u5EFA worktree \u53CA\u5BF9\u5E94\u5206\u652F\uFF08\u542B\u9A8C\u8BC1\u5206\u652F\uFF09").requiredOption("-b, --branch <branchName>", "\u5206\u652F\u540D").option("-n, --number <count>", "\u521B\u5EFA\u6570\u91CF", "1").action(async (options) => {
+    await handleCreate(options);
   });
 }
-function handleCreate(options) {
+async function handleCreate(options) {
   validateMainWorktree();
+  await ensureOnMainWorkBranch();
   const count = Number(options.number);
   if (!Number.isInteger(count) || count <= 0) {
     throw new ClawtError(
@@ -2741,6 +3612,7 @@ function handleCreate(options) {
     printInfo(`\u76EE\u5F55\u8DEF\u5F84${index + 1}\uFF1A`);
     printInfo(`  ${wt.path}`);
     printInfo(`  \u5206\u652F\u540D: ${wt.branch}`);
+    printInfo(`  \u9A8C\u8BC1\u5206\u652F: ${getValidateBranchName(wt.branch)}`);
     printSeparator();
   });
 }
@@ -2753,7 +3625,7 @@ var REMOVE_RESOLVE_MESSAGES = {
   noMatch: MESSAGES.REMOVE_NO_MATCH
 };
 function registerRemoveCommand(program2) {
-  program2.command("remove").description("\u79FB\u9664 worktree\uFF08\u652F\u6301\u5355\u4E2A/\u6279\u91CF/\u5168\u90E8\uFF09").option("--all", "\u79FB\u9664\u5F53\u524D\u9879\u76EE\u4E0B\u6240\u6709 worktree").option("-b, --branch <branchName>", "\u6307\u5B9A\u5206\u652F\u540D\uFF08\u652F\u6301\u6A21\u7CCA\u5339\u914D\uFF0C\u4E0D\u4F20\u5219\u5217\u51FA\u6240\u6709\u5206\u652F\uFF09").action(async (options) => {
+  program2.command("remove").description("\u79FB\u9664 worktree\uFF08\u652F\u6301\u6A21\u7CCA\u5339\u914D/\u591A\u9009/\u5168\u90E8\uFF09").option("--all", "\u79FB\u9664\u5F53\u524D\u9879\u76EE\u4E0B\u6240\u6709 worktree").option("-b, --branch <branchName>", "\u6307\u5B9A\u5206\u652F\u540D\uFF08\u652F\u6301\u6A21\u7CCA\u5339\u914D\uFF0C\u4E0D\u4F20\u5219\u5217\u51FA\u6240\u6709\u5206\u652F\uFF09").action(async (options) => {
     await handleRemove(options);
   });
 }
@@ -2774,13 +3646,13 @@ async function handleRemove(options) {
   }
   printInfo("\u5373\u5C06\u79FB\u9664\u4EE5\u4E0B worktree \u53CA\u672C\u5730\u5206\u652F\uFF1A\n");
   worktreesToRemove.forEach((wt, index) => {
-    printInfo(`  ${index + 1}. ${wt.path}  \u2192  \u5206\u652F: ${wt.branch}`);
+    printInfo(`  ${index + 1}. ${wt.path}  \u2192  \u5206\u652F: ${wt.branch}  \u9A8C\u8BC1\u5206\u652F: ${getValidateBranchName(wt.branch)}`);
   });
   printInfo("");
   const autoDelete = getConfigValue("autoDeleteBranch");
   let shouldDeleteBranch = autoDelete;
   if (!autoDelete) {
-    shouldDeleteBranch = await confirmAction("\u662F\u5426\u540C\u65F6\u5220\u9664\u5BF9\u5E94\u7684\u672C\u5730\u5206\u652F\uFF1F");
+    shouldDeleteBranch = await confirmAction(MESSAGES.REMOVE_CONFIRM_DELETE_BRANCHES);
     if (!shouldDeleteBranch) {
       printHint(MESSAGES.REMOVE_BRANCHES_KEPT);
     }
@@ -2788,10 +3660,12 @@ async function handleRemove(options) {
   const failures = [];
   for (const wt of worktreesToRemove) {
     try {
+      await ensureOnMainWorkBranch();
       removeWorktreeByPath(wt.path);
       if (shouldDeleteBranch) {
         deleteBranch(wt.branch);
       }
+      deleteValidateBranch(wt.branch);
       removeSnapshot(projectName, wt.branch);
       printSuccess(MESSAGES.WORKTREE_REMOVED(wt.path));
     } catch (error) {
@@ -2816,7 +3690,7 @@ async function handleRemove(options) {
 
 // src/commands/run.ts
 function registerRunCommand(program2) {
-  program2.command("run").description("\u6279\u91CF\u521B\u5EFA worktree \u5E76\u542F\u52A8 Claude Code \u6267\u884C\u4EFB\u52A1").option("-b, --branch <branchName>", "\u5206\u652F\u540D").option("--tasks <task...>", "\u4EFB\u52A1\u5217\u8868\uFF08\u53EF\u591A\u6B21\u6307\u5B9A\uFF09\uFF0C\u4E0D\u4F20\u5219\u5728 worktree \u4E2D\u6253\u5F00 Claude Code \u4EA4\u4E92\u5F0F\u754C\u9762").option("-c, --concurrency <n>", "\u6700\u5927\u5E76\u53D1\u6570\uFF0C0 \u8868\u793A\u4E0D\u9650\u5236").option("-f, --file <path>", "\u4ECE\u4EFB\u52A1\u6587\u4EF6\u8BFB\u53D6\u4EFB\u52A1\u5217\u8868\uFF08\u4E0E --tasks \u4E92\u65A5\uFF09").option("-d, --dry-run", "\u9884\u89C8\u6A21\u5F0F\uFF0C\u4EC5\u5C55\u793A\u4EFB\u52A1\u8BA1\u5212\u4E0D\u5B9E\u9645\u6267\u884C").action(async (options) => {
+  program2.command("run").description("\u6279\u91CF\u521B\u5EFA worktree + \u542F\u52A8 Claude Code \u6267\u884C\u4EFB\u52A1\uFF08\u652F\u6301\u4EFB\u52A1\u6587\u4EF6\uFF09").option("-b, --branch <branchName>", "\u5206\u652F\u540D").option("--tasks <task...>", "\u4EFB\u52A1\u5217\u8868\uFF08\u53EF\u591A\u6B21\u6307\u5B9A\uFF09\uFF0C\u4E0D\u4F20\u5219\u5728 worktree \u4E2D\u6253\u5F00 Claude Code \u4EA4\u4E92\u5F0F\u754C\u9762").option("-c, --concurrency <n>", "\u6700\u5927\u5E76\u53D1\u6570\uFF0C0 \u8868\u793A\u4E0D\u9650\u5236").option("-f, --file <path>", "\u4ECE\u4EFB\u52A1\u6587\u4EF6\u8BFB\u53D6\u4EFB\u52A1\u5217\u8868\uFF08\u4E0E --tasks \u4E92\u65A5\uFF09").option("--dry-run", "\u9884\u89C8\u6A21\u5F0F\uFF0C\u4EC5\u5C55\u793A\u4EFB\u52A1\u8BA1\u5212\u4E0D\u5B9E\u9645\u6267\u884C").action(async (options) => {
     await handleRun(options);
   });
 }
@@ -2854,6 +3728,9 @@ function handleDryRunFromFile(options) {
 }
 async function handleRun(options) {
   validateMainWorktree();
+  if (!options.dryRun) {
+    await ensureOnMainWorkBranch();
+  }
   if (options.file && options.tasks) {
     throw new ClawtError(MESSAGES.FILE_AND_TASKS_CONFLICT);
   }
@@ -2909,7 +3786,7 @@ var RESUME_RESOLVE_MESSAGES = {
   noMatch: MESSAGES.RESUME_NO_MATCH
 };
 function registerResumeCommand(program2) {
-  program2.command("resume").description("\u5728\u5DF2\u6709 worktree \u4E2D\u6062\u590D Claude Code \u4EA4\u4E92\u5F0F\u4F1A\u8BDD").option("-b, --branch <branchName>", "\u8981\u6062\u590D\u7684\u5206\u652F\u540D\uFF08\u652F\u6301\u6A21\u7CCA\u5339\u914D\uFF0C\u4E0D\u4F20\u5219\u5217\u51FA\u6240\u6709\u5206\u652F\uFF09").action(async (options) => {
+  program2.command("resume").description("\u5728\u5DF2\u6709 worktree \u4E2D\u6062\u590D Claude Code \u4F1A\u8BDD\uFF08\u652F\u6301\u591A\u9009\u6279\u91CF\u6062\u590D\uFF09").option("-b, --branch <branchName>", "\u8981\u6062\u590D\u7684\u5206\u652F\u540D\uFF08\u652F\u6301\u6A21\u7CCA\u5339\u914D\uFF0C\u4E0D\u4F20\u5219\u5217\u51FA\u6240\u6709\u5206\u652F\uFF09").action(async (options) => {
     await handleResume(options);
   });
 }
@@ -2961,9 +3838,6 @@ async function handleBatchResume(worktrees) {
   printSuccess(MESSAGES.RESUME_ALL_SUCCESS(worktrees.length));
 }
 
-// src/commands/validate.ts
-import Enquirer4 from "enquirer";
-
 // src/commands/sync.ts
 function registerSyncCommand(program2) {
   program2.command("sync").description("\u5C06\u4E3B\u5206\u652F\u6700\u65B0\u4EE3\u7801\u540C\u6B65\u5230\u76EE\u6807 worktree").option("-b, --branch <branchName>", "\u8981\u540C\u6B65\u7684\u5206\u652F\u540D\uFF08\u652F\u6301\u6A21\u7CCA\u5339\u914D\uFF0C\u4E0D\u4F20\u5219\u5217\u51FA\u6240\u6709\u5206\u652F\uFF09").action(async (options) => {
@@ -2993,9 +3867,9 @@ function mergeMainBranch(worktreePath, mainBranch) {
     throw new ClawtError(`\u5408\u5E76 ${mainBranch} \u5931\u8D25`);
   }
 }
-function executeSyncForBranch(targetWorktreePath, branch) {
+async function executeSyncForBranch(targetWorktreePath, branch) {
   const mainWorktreePath = getGitTopLevel();
-  const mainBranch = getCurrentBranch(mainWorktreePath);
+  const mainBranch = getMainWorkBranch();
   if (!isWorkingDirClean(targetWorktreePath)) {
     autoSaveChanges(targetWorktreePath, branch);
   }
@@ -3011,15 +3885,20 @@ function executeSyncForBranch(targetWorktreePath, branch) {
     logger.info(`\u5DF2\u6E05\u9664\u5206\u652F ${branch} \u7684 validate \u5FEB\u7167`);
   }
   printSuccess(MESSAGES.SYNC_SUCCESS(branch, mainBranch));
+  await rebuildValidateBranch(branch, mainWorktreePath);
+  const validateBranchName = getValidateBranchName(branch);
+  printInfo(MESSAGES.SYNC_VALIDATE_BRANCH_REBUILT(validateBranchName));
   return { success: true, hasConflict: false };
 }
 async function handleSync(options) {
   validateMainWorktree();
+  requireProjectConfig();
+  await ensureOnMainWorkBranch();
   logger.info(`sync \u547D\u4EE4\u6267\u884C\uFF0C\u5206\u652F: ${options.branch ?? "(\u672A\u6307\u5B9A)"}`);
   const worktrees = getProjectWorktrees();
   const worktree = await resolveTargetWorktree(worktrees, SYNC_RESOLVE_MESSAGES, options.branch);
   const { path: targetWorktreePath, branch } = worktree;
-  executeSyncForBranch(targetWorktreePath, branch);
+  await executeSyncForBranch(targetWorktreePath, branch);
 }
 
 // src/commands/validate.ts
@@ -3030,43 +3909,12 @@ var VALIDATE_RESOLVE_MESSAGES = {
   noMatch: MESSAGES.VALIDATE_NO_MATCH
 };
 function registerValidateCommand(program2) {
-  program2.command("validate").description("\u5728\u4E3B worktree \u9A8C\u8BC1\u67D0\u4E2A worktree \u5206\u652F\u7684\u53D8\u66F4").option("-b, --branch <branchName>", "\u8981\u9A8C\u8BC1\u7684\u5206\u652F\u540D\uFF08\u652F\u6301\u6A21\u7CCA\u5339\u914D\uFF0C\u4E0D\u4F20\u5219\u5217\u51FA\u6240\u6709\u5206\u652F\uFF09").option("--clean", "\u6E05\u7406 validate \u72B6\u6001\uFF08\u91CD\u7F6E\u4E3B worktree \u5E76\u5220\u9664\u5FEB\u7167\uFF09").option("-r, --run <command>", "validate \u6210\u529F\u540E\u5728\u4E3B worktree \u4E2D\u6267\u884C\u7684\u547D\u4EE4").action(async (options) => {
+  program2.command("validate").description("\u5728\u4E3B worktree \u9A8C\u8BC1\u67D0\u4E2A worktree \u5206\u652F\u7684\u53D8\u66F4\uFF08\u901A\u8FC7\u9A8C\u8BC1\u5206\u652F\uFF09").option("-b, --branch <branchName>", "\u8981\u9A8C\u8BC1\u7684\u5206\u652F\u540D\uFF08\u652F\u6301\u6A21\u7CCA\u5339\u914D\uFF0C\u4E0D\u4F20\u5219\u5217\u51FA\u6240\u6709\u5206\u652F\uFF09").option("--clean", "\u6E05\u7406 validate \u72B6\u6001\uFF08\u91CD\u7F6E\u4E3B worktree \u5E76\u5220\u9664\u5FEB\u7167\uFF09").option("-r, --run <command>", "validate \u6210\u529F\u540E\u5728\u4E3B worktree \u4E2D\u6267\u884C\u7684\u547D\u4EE4").action(async (options) => {
     await handleValidate(options);
   });
 }
 async function handleDirtyMainWorktree(mainWorktreePath) {
-  printWarning("\u4E3B worktree \u5F53\u524D\u5206\u652F\u6709\u672A\u63D0\u4EA4\u7684\u66F4\u6539\uFF0C\u8BF7\u9009\u62E9\u5904\u7406\u65B9\u5F0F\uFF1A\n");
-  const choice = await new Enquirer4.Select({
-    message: "\u9009\u62E9\u5904\u7406\u65B9\u5F0F",
-    choices: [
-      {
-        name: "reset",
-        message: "reset (\u63A8\u8350) - \u4E22\u5F03\u6240\u6709\u66F4\u6539 (git reset --hard HEAD && git clean -fd)"
-      },
-      {
-        name: "stash",
-        message: "stash        - \u6682\u5B58\u66F4\u6539 (git add . && git stash)"
-      },
-      {
-        name: "exit",
-        message: "exit         - \u9000\u51FA\uFF0C\u624B\u52A8\u5904\u7406"
-      }
-    ],
-    initial: 0
-  }).run();
-  if (choice === "exit") {
-    throw new ClawtError("\u7528\u6237\u9009\u62E9\u9000\u51FA");
-  }
-  if (choice === "reset") {
-    gitResetHard(mainWorktreePath);
-    gitCleanForce(mainWorktreePath);
-  } else if (choice === "stash") {
-    gitAddAll(mainWorktreePath);
-    gitStashPush("clawt:auto-stash", mainWorktreePath);
-  }
-  if (!isWorkingDirClean(mainWorktreePath)) {
-    throw new ClawtError("\u5DE5\u4F5C\u533A\u4ECD\u7136\u4E0D\u5E72\u51C0\uFF0C\u8BF7\u624B\u52A8\u5904\u7406");
-  }
+  await handleDirtyWorkingDir(mainWorktreePath);
 }
 function migrateChangesViaPatch(targetWorktreePath, mainWorktreePath, branchName, hasUncommitted) {
   let didTempCommit = false;
@@ -3109,7 +3957,7 @@ async function handlePatchApplyFailure(targetWorktreePath, branchName) {
     return;
   }
   printInfo(MESSAGES.VALIDATE_AUTO_SYNC_START(branchName));
-  const syncResult = executeSyncForBranch(targetWorktreePath, branchName);
+  const syncResult = await executeSyncForBranch(targetWorktreePath, branchName);
 }
 function saveCurrentSnapshotTree(mainWorktreePath, projectName, branchName) {
   gitAddAll(mainWorktreePath);
@@ -3121,6 +3969,7 @@ function saveCurrentSnapshotTree(mainWorktreePath, projectName, branchName) {
 }
 async function handleValidateClean(options) {
   validateMainWorktree();
+  requireProjectConfig();
   const projectName = getProjectName();
   const mainWorktreePath = getGitTopLevel();
   const worktrees = getProjectWorktrees();
@@ -3141,17 +3990,24 @@ async function handleValidateClean(options) {
     gitResetHard(mainWorktreePath);
     gitCleanForce(mainWorktreePath);
   }
+  await ensureOnMainWorkBranch(mainWorktreePath);
   removeSnapshot(projectName, branchName);
   printSuccess(MESSAGES.VALIDATE_CLEANED(branchName));
 }
 async function handleFirstValidate(targetWorktreePath, mainWorktreePath, projectName, branchName, hasUncommitted) {
+  const validateBranchName = getValidateBranchName(branchName);
+  if (!checkBranchExists(validateBranchName)) {
+    throw new ClawtError(MESSAGES.VALIDATE_BRANCH_NOT_FOUND(validateBranchName, branchName));
+  }
+  gitCheckout(validateBranchName, mainWorktreePath);
   const result = migrateChangesViaPatch(targetWorktreePath, mainWorktreePath, branchName, hasUncommitted);
   if (!result.success) {
+    await ensureOnMainWorkBranch(mainWorktreePath);
     await handlePatchApplyFailure(targetWorktreePath, branchName);
     return;
   }
   saveCurrentSnapshotTree(mainWorktreePath, projectName, branchName);
-  printSuccess(MESSAGES.VALIDATE_SUCCESS(branchName));
+  printSuccess(MESSAGES.VALIDATE_SUCCESS_WITH_BRANCH(branchName, validateBranchName));
 }
 async function handleIncrementalValidate(targetWorktreePath, mainWorktreePath, projectName, branchName, hasUncommitted) {
   const { treeHash: oldTreeHash, headCommitHash: oldHeadCommitHash } = readSnapshot(projectName, branchName);
@@ -3159,8 +4015,17 @@ async function handleIncrementalValidate(targetWorktreePath, mainWorktreePath, p
     gitResetHard(mainWorktreePath);
     gitCleanForce(mainWorktreePath);
   }
+  const validateBranchName = getValidateBranchName(branchName);
+  if (!checkBranchExists(validateBranchName)) {
+    throw new ClawtError(MESSAGES.VALIDATE_BRANCH_NOT_FOUND(validateBranchName, branchName));
+  }
+  const currentBranch = getCurrentBranch(mainWorktreePath);
+  if (currentBranch !== validateBranchName) {
+    gitCheckout(validateBranchName, mainWorktreePath);
+  }
   const result = migrateChangesViaPatch(targetWorktreePath, mainWorktreePath, branchName, hasUncommitted);
   if (!result.success) {
+    await ensureOnMainWorkBranch(mainWorktreePath);
     await handlePatchApplyFailure(targetWorktreePath, branchName);
     return;
   }
@@ -3175,7 +4040,7 @@ async function handleIncrementalValidate(targetWorktreePath, mainWorktreePath, p
       } else if (oldChangePatch.length > 0) {
         logger.warn("\u65E7\u53D8\u66F4 patch \u4E0E\u5F53\u524D HEAD \u51B2\u7A81\uFF0C\u964D\u7EA7\u4E3A\u5168\u91CF\u6A21\u5F0F");
         printWarning(MESSAGES.INCREMENTAL_VALIDATE_FALLBACK);
-        printSuccess(MESSAGES.VALIDATE_SUCCESS(branchName));
+        printSuccess(MESSAGES.VALIDATE_SUCCESS_WITH_BRANCH(branchName, validateBranchName));
         return;
       }
     } else {
@@ -3184,7 +4049,7 @@ async function handleIncrementalValidate(targetWorktreePath, mainWorktreePath, p
   } catch (error) {
     logger.warn(`\u589E\u91CF read-tree \u5931\u8D25: ${error}`);
     printWarning(MESSAGES.INCREMENTAL_VALIDATE_FALLBACK);
-    printSuccess(MESSAGES.VALIDATE_SUCCESS(branchName));
+    printSuccess(MESSAGES.VALIDATE_SUCCESS_WITH_BRANCH(branchName, validateBranchName));
     return;
   }
   printSuccess(MESSAGES.INCREMENTAL_VALIDATE_SUCCESS(branchName));
@@ -3248,6 +4113,7 @@ async function handleValidate(options) {
     return;
   }
   validateMainWorktree();
+  requireProjectConfig();
   const projectName = getProjectName();
   const mainWorktreePath = getGitTopLevel();
   const worktrees = getProjectWorktrees();
@@ -3280,7 +4146,7 @@ async function handleValidate(options) {
 
 // src/commands/merge.ts
 function registerMergeCommand(program2) {
-  program2.command("merge").description("\u5408\u5E76\u67D0\u4E2A\u5DF2\u9A8C\u8BC1\u7684 worktree \u5206\u652F\u5230\u4E3B worktree").option("-b, --branch <branchName>", "\u8981\u5408\u5E76\u7684\u5206\u652F\u540D\uFF08\u652F\u6301\u6A21\u7CCA\u5339\u914D\uFF0C\u4E0D\u4F20\u5219\u5217\u51FA\u6240\u6709\u5206\u652F\uFF09").option("-m, --message <message>", "\u63D0\u4EA4\u4FE1\u606F\uFF08\u5DE5\u4F5C\u533A\u6709\u4FEE\u6539\u65F6\u5FC5\u586B\uFF09").action(async (options) => {
+  program2.command("merge").description("\u5408\u5E76\u67D0\u4E2A\u5DF2\u9A8C\u8BC1\u7684 worktree \u5206\u652F\u5230\u4E3B worktree").option("-b, --branch <branchName>", "\u8981\u5408\u5E76\u7684\u5206\u652F\u540D\uFF08\u652F\u6301\u6A21\u7CCA\u5339\u914D\uFF0C\u4E0D\u4F20\u5219\u5217\u51FA\u6240\u6709\u5206\u652F\u4F9B\u9009\u62E9\uFF09").option("-m, --message <commitMessage>", "\u63D0\u4EA4\u4FE1\u606F\uFF08\u76EE\u6807 worktree \u5DE5\u4F5C\u533A\u6709\u4FEE\u6539\u65F6\u5FC5\u586B\uFF09").action(async (options) => {
     await handleMerge(options);
   });
 }
@@ -3298,7 +4164,7 @@ async function handleSquashIfNeeded(targetWorktreePath, mainWorktreePath, branch
   if (!shouldSquash) {
     return false;
   }
-  const mainBranch = getCurrentBranch(mainWorktreePath);
+  const mainBranch = getMainWorkBranch();
   const mergeBase = gitMergeBase(mainBranch, branchName, mainWorktreePath);
   logger.info(`squash: merge-base = ${mergeBase}, \u5206\u652F = ${branchName}`);
   gitResetSoftTo(mergeBase, targetWorktreePath);
@@ -3325,6 +4191,7 @@ function cleanupWorktreeAndBranch(worktreePath, branchName) {
 async function handleMerge(options) {
   validateMainWorktree();
   const mainWorktreePath = getGitTopLevel();
+  await ensureOnMainWorkBranch(mainWorktreePath);
   logger.info(`merge \u547D\u4EE4\u6267\u884C\uFF0C\u5206\u652F: ${options.branch ?? "(\u672A\u6307\u5B9A)"}\uFF0C\u63D0\u4EA4\u4FE1\u606F: ${options.message ?? "(\u672A\u63D0\u4F9B)"}`);
   const worktrees = getProjectWorktrees();
   const worktree = await resolveTargetWorktree(worktrees, MERGE_RESOLVE_MESSAGES, options.branch);
@@ -3398,7 +4265,7 @@ async function handleMerge(options) {
 }
 
 // src/commands/config.ts
-import chalk9 from "chalk";
+import chalk11 from "chalk";
 import Enquirer5 from "enquirer";
 function registerConfigCommand(program2) {
   const configCmd = program2.command("config").description("\u4EA4\u4E92\u5F0F\u67E5\u770B\u548C\u4FEE\u6539\u5168\u5C40\u914D\u7F6E").action(async () => {
@@ -3459,7 +4326,7 @@ async function handleInteractiveConfigSet() {
     const isObject = typeof DEFAULT_CONFIG[k] === "object";
     return {
       name: k,
-      message: `${k}: ${isObject ? chalk9.dim(JSON.stringify(config2[k])) : formatConfigValue(config2[k])}  ${chalk9.dim(`\u2014 ${CONFIG_DESCRIPTIONS[k]}`)}`,
+      message: `${k}: ${isObject ? chalk11.dim(JSON.stringify(config2[k])) : formatConfigValue(config2[k])}  ${chalk11.dim(`\u2014 ${CONFIG_DESCRIPTIONS[k]}`)}`,
       ...isObject && { disabled: CONFIG_ALIAS_DISABLED_HINT }
     };
   });
@@ -3492,6 +4359,7 @@ function registerResetCommand(program2) {
 }
 async function handleReset() {
   validateMainWorktree();
+  requireProjectConfig();
   const mainWorktreePath = getGitTopLevel();
   logger.info("reset \u547D\u4EE4\u6267\u884C");
   if (!isWorkingDirClean(mainWorktreePath)) {
@@ -3514,14 +4382,19 @@ async function handleReset() {
 }
 
 // src/commands/status.ts
-import chalk10 from "chalk";
+import chalk12 from "chalk";
 function registerStatusCommand(program2) {
-  program2.command("status").description("\u663E\u793A\u9879\u76EE\u5168\u5C40\u72B6\u6001\u603B\u89C8").option("--json", "\u4EE5 JSON \u683C\u5F0F\u8F93\u51FA").action((options) => {
-    handleStatus(options);
+  program2.command("status").description("\u663E\u793A\u9879\u76EE\u5168\u5C40\u72B6\u6001\u603B\u89C8\uFF08\u652F\u6301 --json \u683C\u5F0F\u8F93\u51FA\uFF09").option("--json", "\u4EE5 JSON \u683C\u5F0F\u8F93\u51FA").option("-i, --interactive", "\u4EA4\u4E92\u5F0F\u9762\u677F\u6A21\u5F0F").action(async (options) => {
+    await handleStatus(options);
   });
 }
-function handleStatus(options) {
+async function handleStatus(options) {
   validateMainWorktree();
+  if (options.interactive) {
+    const panel = new InteractivePanel(collectStatus);
+    await panel.start();
+    return;
+  }
   const statusResult = collectStatus();
   logger.info(`status \u547D\u4EE4\u6267\u884C\uFF0C\u9879\u76EE: ${statusResult.main.projectName}\uFF0C\u5171 ${statusResult.totalWorktrees} \u4E2A worktree`);
   if (options.json) {
@@ -3627,7 +4500,7 @@ function printStatusAsJson(result) {
 }
 function printStatusAsText(result) {
   printDoubleSeparator();
-  printInfo(`  ${chalk10.bold.cyan(MESSAGES.STATUS_TITLE(result.main.projectName))}`);
+  printInfo(`  ${chalk12.bold.cyan(MESSAGES.STATUS_TITLE(result.main.projectName))}`);
   printDoubleSeparator();
   printInfo("");
   printMainSection(result.main);
@@ -3640,17 +4513,17 @@ function printStatusAsText(result) {
   printDoubleSeparator();
 }
 function printMainSection(main2) {
-  printInfo(`  ${chalk10.bold("\u25C6")} ${chalk10.bold(MESSAGES.STATUS_MAIN_SECTION)}`);
-  printInfo(`    \u5206\u652F: ${chalk10.bold(main2.branch)}`);
+  printInfo(`  ${chalk12.bold("\u25C6")} ${chalk12.bold(MESSAGES.STATUS_MAIN_SECTION)}`);
+  printInfo(`    \u5206\u652F: ${chalk12.bold(main2.branch)}`);
   if (main2.isClean) {
-    printInfo(`    \u72B6\u6001: ${chalk10.green("\u2713 \u5E72\u51C0")}`);
+    printInfo(`    \u72B6\u6001: ${chalk12.green("\u2713 \u5E72\u51C0")}`);
   } else {
-    printInfo(`    \u72B6\u6001: ${chalk10.yellow("\u2717 \u6709\u672A\u63D0\u4EA4\u4FEE\u6539")}`);
+    printInfo(`    \u72B6\u6001: ${chalk12.yellow("\u2717 \u6709\u672A\u63D0\u4EA4\u4FEE\u6539")}`);
   }
   printInfo("");
 }
 function printWorktreesSection(worktrees, total) {
-  printInfo(`  ${chalk10.bold("\u25C6")} ${chalk10.bold(MESSAGES.STATUS_WORKTREES_SECTION)} (${total} \u4E2A)`);
+  printInfo(`  ${chalk12.bold("\u25C6")} ${chalk12.bold(MESSAGES.STATUS_WORKTREES_SECTION)} (${total} \u4E2A)`);
   printInfo("");
   if (worktrees.length === 0) {
     printInfo(`    ${MESSAGES.STATUS_NO_WORKTREES}`);
@@ -3661,57 +4534,57 @@ function printWorktreesSection(worktrees, total) {
   }
 }
 function printWorktreeItem(wt) {
-  const statusLabel = formatChangeStatusLabel(wt.changeStatus);
-  printInfo(`  ${chalk10.bold("\u25CF")} ${chalk10.bold(wt.branch)}   [${statusLabel}]`);
+  const statusLabel = formatChangeStatusLabel2(wt.changeStatus);
+  printInfo(`  ${chalk12.bold("\u25CF")} ${chalk12.bold(wt.branch)}   [${statusLabel}]`);
   if (wt.insertions > 0 || wt.deletions > 0) {
-    printInfo(`    ${chalk10.green(`+${wt.insertions}`)} ${chalk10.red(`-${wt.deletions}`)}`);
+    printInfo(`    ${chalk12.green(`+${wt.insertions}`)} ${chalk12.red(`-${wt.deletions}`)}`);
   }
   if (wt.commitsAhead > 0) {
-    printInfo(`    ${chalk10.yellow(`${wt.commitsAhead} \u4E2A\u672C\u5730\u63D0\u4EA4`)}`);
+    printInfo(`    ${chalk12.yellow(`${wt.commitsAhead} \u4E2A\u672C\u5730\u63D0\u4EA4`)}`);
   }
   if (wt.commitsBehind > 0) {
-    printInfo(`    ${chalk10.yellow(`\u843D\u540E\u4E3B\u5206\u652F ${wt.commitsBehind} \u4E2A\u63D0\u4EA4`)}`);
+    printInfo(`    ${chalk12.yellow(`\u843D\u540E\u4E3B\u5206\u652F ${wt.commitsBehind} \u4E2A\u63D0\u4EA4`)}`);
   } else {
-    printInfo(`    ${chalk10.green("\u4E0E\u4E3B\u5206\u652F\u540C\u6B65")}`);
+    printInfo(`    ${chalk12.green("\u4E0E\u4E3B\u5206\u652F\u540C\u6B65")}`);
   }
   if (wt.createdAt) {
     const relativeTime = formatRelativeTime(wt.createdAt);
     if (relativeTime) {
-      printInfo(`    ${chalk10.gray(MESSAGES.STATUS_CREATED_AT(relativeTime))}`);
+      printInfo(`    ${chalk12.gray(MESSAGES.STATUS_CREATED_AT(relativeTime))}`);
     }
   }
   if (wt.snapshotTime) {
     const relativeTime = formatRelativeTime(wt.snapshotTime);
     if (relativeTime) {
-      printInfo(`    ${chalk10.green(MESSAGES.STATUS_LAST_VALIDATED(relativeTime))}`);
+      printInfo(`    ${chalk12.green(MESSAGES.STATUS_LAST_VALIDATED(relativeTime))}`);
     }
   } else {
-    printInfo(`    ${chalk10.red(MESSAGES.STATUS_NOT_VALIDATED)}`);
+    printInfo(`    ${chalk12.red(MESSAGES.STATUS_NOT_VALIDATED)}`);
   }
   printInfo("");
 }
-function formatChangeStatusLabel(status) {
+function formatChangeStatusLabel2(status) {
   switch (status) {
     case "committed":
-      return chalk10.green(MESSAGES.STATUS_CHANGE_COMMITTED);
+      return chalk12.green(MESSAGES.STATUS_CHANGE_COMMITTED);
     case "uncommitted":
-      return chalk10.yellow(MESSAGES.STATUS_CHANGE_UNCOMMITTED);
+      return chalk12.yellow(MESSAGES.STATUS_CHANGE_UNCOMMITTED);
     case "conflict":
-      return chalk10.red(MESSAGES.STATUS_CHANGE_CONFLICT);
+      return chalk12.red(MESSAGES.STATUS_CHANGE_CONFLICT);
     case "clean":
-      return chalk10.gray(MESSAGES.STATUS_CHANGE_CLEAN);
+      return chalk12.gray(MESSAGES.STATUS_CHANGE_CLEAN);
   }
 }
 function printSnapshotsSection(snapshots) {
-  printInfo(`  ${chalk10.bold("\u25C6")} ${chalk10.bold(MESSAGES.STATUS_SNAPSHOTS_SECTION)} (${snapshots.total} \u4E2A)`);
+  printInfo(`  ${chalk12.bold("\u25C6")} ${chalk12.bold(MESSAGES.STATUS_SNAPSHOTS_SECTION)} (${snapshots.total} \u4E2A)`);
   if (snapshots.orphaned > 0) {
-    printInfo(`    ${chalk10.yellow(MESSAGES.STATUS_SNAPSHOT_ORPHANED(snapshots.orphaned))}`);
+    printInfo(`    ${chalk12.yellow(MESSAGES.STATUS_SNAPSHOT_ORPHANED(snapshots.orphaned))}`);
   }
   printInfo("");
 }
 
 // src/commands/alias.ts
-import chalk11 from "chalk";
+import chalk13 from "chalk";
 function getRegisteredCommandNames(program2) {
   return program2.commands.map((cmd) => cmd.name());
 }
@@ -3732,7 +4605,7 @@ ${MESSAGES.ALIAS_LIST_TITLE}
 `);
   printSeparator();
   for (const [alias, command] of entries) {
-    printInfo(`  ${chalk11.bold(alias)} \u2192 ${chalk11.cyan(command)}`);
+    printInfo(`  ${chalk13.bold(alias)} \u2192 ${chalk13.cyan(command)}`);
   }
   printInfo("");
   printSeparator();
@@ -3764,7 +4637,7 @@ function handleAliasRemove(alias) {
   printSuccess(MESSAGES.ALIAS_REMOVE_SUCCESS(alias));
 }
 function registerAliasCommand(program2) {
-  const aliasCmd = program2.command("alias").description("\u7BA1\u7406\u547D\u4EE4\u522B\u540D").action(() => {
+  const aliasCmd = program2.command("alias").description("\u7BA1\u7406\u547D\u4EE4\u522B\u540D\uFF08\u5217\u51FA / \u8BBE\u7F6E / \u79FB\u9664\uFF09").action(() => {
     handleAliasList();
   });
   aliasCmd.command("list").description("\u5217\u51FA\u6240\u6709\u522B\u540D").action(() => {
@@ -3779,9 +4652,9 @@ function registerAliasCommand(program2) {
 }
 
 // src/commands/projects.ts
-import { existsSync as existsSync9, readdirSync as readdirSync5, statSync as statSync4 } from "fs";
-import { join as join7 } from "path";
-import chalk12 from "chalk";
+import { existsSync as existsSync10, readdirSync as readdirSync5, statSync as statSync4 } from "fs";
+import { join as join8 } from "path";
+import chalk14 from "chalk";
 function registerProjectsCommand(program2) {
   program2.command("projects [name]").description("\u5C55\u793A\u6240\u6709\u9879\u76EE\u7684 worktree \u6982\u89C8\uFF0C\u6216\u67E5\u770B\u6307\u5B9A\u9879\u76EE\u7684 worktree \u8BE6\u60C5").option("--json", "\u4EE5 JSON \u683C\u5F0F\u8F93\u51FA").action((name, options) => {
     handleProjects({ name, json: options.json });
@@ -3804,8 +4677,8 @@ function handleProjectsOverview(json) {
   printProjectsOverviewAsText(result);
 }
 function handleProjectDetail(name, json) {
-  const projectDir = join7(WORKTREES_DIR, name);
-  if (!existsSync9(projectDir)) {
+  const projectDir = join8(WORKTREES_DIR, name);
+  if (!existsSync10(projectDir)) {
     printError(MESSAGES.PROJECTS_NOT_FOUND(name));
     process.exit(1);
   }
@@ -3818,7 +4691,7 @@ function handleProjectDetail(name, json) {
   printProjectDetailAsText(result);
 }
 function collectProjectsOverview() {
-  if (!existsSync9(WORKTREES_DIR)) {
+  if (!existsSync10(WORKTREES_DIR)) {
     return { projects: [], totalProjects: 0, totalDiskUsage: 0 };
   }
   const entries = readdirSync5(WORKTREES_DIR, { withFileTypes: true });
@@ -3827,7 +4700,7 @@ function collectProjectsOverview() {
     if (!entry.isDirectory()) {
       continue;
     }
-    const projectDir = join7(WORKTREES_DIR, entry.name);
+    const projectDir = join8(WORKTREES_DIR, entry.name);
     const overview = collectSingleProjectOverview(entry.name, projectDir);
     projects.push(overview);
   }
@@ -3844,7 +4717,7 @@ function collectSingleProjectOverview(name, projectDir) {
   const worktreeDirs = subEntries.filter((e) => e.isDirectory());
   const worktreeCount = worktreeDirs.length;
   const diskUsage = calculateDirSize(projectDir);
-  const lastActiveTime = resolveProjectLastActiveTime(projectDir, worktreeDirs.map((e) => join7(projectDir, e.name)));
+  const lastActiveTime = resolveProjectLastActiveTime(projectDir, worktreeDirs.map((e) => join8(projectDir, e.name)));
   return {
     name,
     worktreeCount,
@@ -3859,7 +4732,7 @@ function collectProjectDetail(name, projectDir) {
     if (!entry.isDirectory()) {
       continue;
     }
-    const wtPath = join7(projectDir, entry.name);
+    const wtPath = join8(projectDir, entry.name);
     const detail = collectSingleWorktreeDetail(entry.name, wtPath);
     worktrees.push(detail);
   }
@@ -3900,7 +4773,7 @@ function sortByLastActiveTimeDesc(projects) {
 }
 function printProjectsOverviewAsText(result) {
   printDoubleSeparator();
-  printInfo(`  ${chalk12.bold.cyan(MESSAGES.PROJECTS_OVERVIEW_TITLE)}`);
+  printInfo(`  ${chalk14.bold.cyan(MESSAGES.PROJECTS_OVERVIEW_TITLE)}`);
   printDoubleSeparator();
   printInfo("");
   if (result.projects.length === 0) {
@@ -3914,7 +4787,7 @@ function printProjectsOverviewAsText(result) {
   }
   printSeparator();
   printInfo("");
-  printInfo(`  \u5171 ${chalk12.bold(String(result.totalProjects))} \u4E2A\u9879\u76EE   ${chalk12.gray(MESSAGES.PROJECTS_TOTAL_DISK_USAGE(formatDiskSize(result.totalDiskUsage)))}`);
+  printInfo(`  \u5171 ${chalk14.bold(String(result.totalProjects))} \u4E2A\u9879\u76EE   ${chalk14.gray(MESSAGES.PROJECTS_TOTAL_DISK_USAGE(formatDiskSize(result.totalDiskUsage)))}`);
   printInfo("");
   printDoubleSeparator();
 }
@@ -3922,16 +4795,16 @@ function printProjectOverviewItem(project) {
   const relativeTime = formatRelativeTime(project.lastActiveTime);
   const activeLabel = relativeTime ? MESSAGES.PROJECTS_LAST_ACTIVE(relativeTime) : "";
   const diskLabel = MESSAGES.PROJECTS_DISK_USAGE(formatDiskSize(project.diskUsage));
-  printInfo(`  ${chalk12.bold("\u25CF")} ${chalk12.bold(project.name)}`);
-  printInfo(`    ${MESSAGES.PROJECTS_WORKTREE_COUNT(project.worktreeCount)}   ${chalk12.gray(activeLabel)}   ${chalk12.gray(diskLabel)}`);
+  printInfo(`  ${chalk14.bold("\u25CF")} ${chalk14.bold(project.name)}`);
+  printInfo(`    ${MESSAGES.PROJECTS_WORKTREE_COUNT(project.worktreeCount)}   ${chalk14.gray(activeLabel)}   ${chalk14.gray(diskLabel)}`);
   printInfo("");
 }
 function printProjectDetailAsText(result) {
   printDoubleSeparator();
-  printInfo(`  ${chalk12.bold.cyan(MESSAGES.PROJECTS_DETAIL_TITLE(result.name))}`);
+  printInfo(`  ${chalk14.bold.cyan(MESSAGES.PROJECTS_DETAIL_TITLE(result.name))}`);
   printDoubleSeparator();
   printInfo("");
-  printInfo(`  ${chalk12.bold("\u25C6")} ${chalk12.bold(MESSAGES.PROJECTS_PATH(result.projectDir))}`);
+  printInfo(`  ${chalk14.bold("\u25C6")} ${chalk14.bold(MESSAGES.PROJECTS_PATH(result.projectDir))}`);
   printInfo(`    ${MESSAGES.PROJECTS_TOTAL_DISK_USAGE(formatDiskSize(result.totalDiskUsage))}`);
   printInfo("");
   printSeparator();
@@ -3951,14 +4824,14 @@ function printWorktreeDetailItem(wt) {
   const relativeTime = formatRelativeTime(wt.lastModifiedTime);
   const modifiedLabel = relativeTime ? MESSAGES.PROJECTS_LAST_MODIFIED(relativeTime) : "";
   const diskLabel = MESSAGES.PROJECTS_DISK_USAGE(formatDiskSize(wt.diskUsage));
-  printInfo(`  ${chalk12.bold("\u25CF")} ${chalk12.bold(wt.branch)}`);
+  printInfo(`  ${chalk14.bold("\u25CF")} ${chalk14.bold(wt.branch)}`);
   printInfo(`    ${wt.path}`);
-  printInfo(`    ${chalk12.gray(modifiedLabel)}   ${chalk12.gray(diskLabel)}`);
+  printInfo(`    ${chalk14.gray(modifiedLabel)}   ${chalk14.gray(diskLabel)}`);
   printInfo("");
 }
 
 // src/commands/completion.ts
-import { readFileSync as readFileSync5, writeFileSync as writeFileSync4, existsSync as existsSync11 } from "fs";
+import { readFileSync as readFileSync6, writeFileSync as writeFileSync5, existsSync as existsSync12 } from "fs";
 import { resolve as resolve2 } from "path";
 import { homedir as homedir2 } from "os";
 
@@ -4009,14 +4882,14 @@ compdef _clawt_completion clawt
 }
 
 // src/utils/completion-engine.ts
-import { existsSync as existsSync10, readdirSync as readdirSync6, statSync as statSync5 } from "fs";
-import { join as join8, dirname, basename as basename2 } from "path";
+import { existsSync as existsSync11, readdirSync as readdirSync6, statSync as statSync5 } from "fs";
+import { join as join9, dirname, basename as basename2 } from "path";
 function completeFilePath(partial) {
   const cwd = process.cwd();
   const hasDir = partial.includes("/");
-  const searchDir = hasDir ? join8(cwd, dirname(partial)) : cwd;
+  const searchDir = hasDir ? join9(cwd, dirname(partial)) : cwd;
   const prefix = hasDir ? basename2(partial) : partial;
-  if (!existsSync10(searchDir)) {
+  if (!existsSync11(searchDir)) {
     return [];
   }
   const entries = readdirSync6(searchDir);
@@ -4025,7 +4898,7 @@ function completeFilePath(partial) {
   for (const entry of entries) {
     if (!entry.startsWith(prefix)) continue;
     if (entry.startsWith(".")) continue;
-    const fullPath = join8(searchDir, entry);
+    const fullPath = join9(searchDir, entry);
     try {
       const stat = statSync5(fullPath);
       if (stat.isDirectory()) {
@@ -4114,15 +4987,15 @@ function generateCompletions(program2, args) {
 
 // src/commands/completion.ts
 function appendToFile(filePath, content) {
-  if (existsSync11(filePath)) {
-    const current = readFileSync5(filePath, "utf-8");
+  if (existsSync12(filePath)) {
+    const current = readFileSync6(filePath, "utf-8");
     if (current.includes("clawt completion")) {
       printInfo(MESSAGES.COMPLETION_INSTALL_EXISTS + ": " + filePath);
       return;
     }
     content = current + content;
   }
-  writeFileSync4(filePath, content, "utf-8");
+  writeFileSync5(filePath, content, "utf-8");
   printSuccess(MESSAGES.COMPLETION_INSTALL_SUCCESS + ": " + filePath);
   printInfo(MESSAGES.COMPLETION_INSTALL_RESTART(filePath));
 }
@@ -4169,6 +5042,37 @@ function registerCompletionCommand(program2) {
   });
 }
 
+// src/commands/init.ts
+import { Command as Cmd } from "commander";
+function registerInitCommand(program2) {
+  const initCmd = program2.command("init").description("\u521D\u59CB\u5316\u9879\u76EE\u7EA7\u914D\u7F6E\uFF0C\u8BBE\u7F6E\u4E3B\u5DE5\u4F5C\u5206\u652F").option("-b, --branch <branchName>", "\u6307\u5B9A\u4E3B\u5DE5\u4F5C\u5206\u652F\u540D\uFF08\u9ED8\u8BA4\u4F7F\u7528\u5F53\u524D\u5206\u652F\uFF09").action(async (options) => {
+    await handleInit(options);
+  });
+  initCmd.addCommand(
+    new Cmd("show").description("\u5C55\u793A\u5F53\u524D\u9879\u76EE\u7684 init \u914D\u7F6E").action(() => {
+      handleInitShow();
+    })
+  );
+}
+function handleInitShow() {
+  validateMainWorktree();
+  const config2 = requireProjectConfig();
+  const configJson = safeStringify(config2);
+  printInfo(MESSAGES.INIT_SHOW(configJson));
+}
+async function handleInit(options) {
+  validateMainWorktree();
+  const existingConfig = loadProjectConfig();
+  const branchName = options.branch || getCurrentBranch();
+  logger.info(`init \u547D\u4EE4\u6267\u884C\uFF0C\u4E3B\u5DE5\u4F5C\u5206\u652F: ${branchName}`);
+  saveProjectConfig({ clawtMainWorkBranch: branchName });
+  if (existingConfig) {
+    printSuccess(MESSAGES.INIT_UPDATED(existingConfig.clawtMainWorkBranch, branchName));
+  } else {
+    printSuccess(MESSAGES.INIT_SUCCESS(branchName));
+  }
+}
+
 // src/index.ts
 var require2 = createRequire(import.meta.url);
 var { version } = require2("../package.json");
@@ -4194,6 +5098,7 @@ registerStatusCommand(program);
 registerAliasCommand(program);
 registerProjectsCommand(program);
 registerCompletionCommand(program);
+registerInitCommand(program);
 var config = loadConfig();
 applyAliases(program, config.aliases);
 process.on("uncaughtException", (error) => {