clawt 2.10.1 → 2.11.1

package/dist/index.js

@@ -14,6 +14,7 @@ var CONFIG_PATH = join(CLAWT_HOME, "config.json");
 var LOGS_DIR = join(CLAWT_HOME, "logs");
 var WORKTREES_DIR = join(CLAWT_HOME, "worktrees");
 var VALIDATE_SNAPSHOTS_DIR = join(CLAWT_HOME, "validate-snapshots");
+var CLAUDE_PROJECTS_DIR = join(homedir(), ".claude", "projects");
 
 // src/constants/branch.ts
 var INVALID_BRANCH_CHARS = /[\/\\.\s~:*?[\]^]+/g;
@@ -71,7 +72,33 @@ var RUN_MESSAGES = {
   /** 中断后清理完成 */
   INTERRUPT_CLEANED: (count) => `\u2713 \u5DF2\u6E05\u7406 ${count} \u4E2A worktree \u548C\u5BF9\u5E94\u5206\u652F`,
   /** 中断后保留 worktree */
-  INTERRUPT_KEPT: "\u5DF2\u4FDD\u7559 worktree\uFF0C\u53EF\u7A0D\u540E\u4F7F\u7528 clawt remove \u624B\u52A8\u6E05\u7406"
+  INTERRUPT_KEPT: "\u5DF2\u4FDD\u7559 worktree\uFF0C\u53EF\u7A0D\u540E\u4F7F\u7528 clawt remove \u624B\u52A8\u6E05\u7406",
+  /** 非 TTY 环境降级输出：任务启动 */
+  PROGRESS_TASK_STARTED: (index, total, branch, path) => `[${index}/${total}] ${branch} \u542F\u52A8  ${path}`,
+  /** 非 TTY 环境降级输出：任务完成 */
+  PROGRESS_TASK_DONE: (index, total, branch, duration, cost, path) => `[${index}/${total}] ${branch} \u2713 \u5B8C\u6210 ${duration} ${cost}  ${path}`,
+  /** 非 TTY 环境降级输出：任务失败 */
+  PROGRESS_TASK_FAILED: (index, total, branch, duration, path) => `[${index}/${total}] ${branch} \u2717 \u5931\u8D25 ${duration}  ${path}`,
+  /** 并发限制提示 */
+  CONCURRENCY_INFO: (concurrency, total) => `\u5E76\u53D1\u9650\u5236: ${concurrency}\uFF0C\u5171 ${total} \u4E2A\u4EFB\u52A1`,
+  /** 并发数无效提示 */
+  CONCURRENCY_INVALID: "\u5E76\u53D1\u6570\u5FC5\u987B\u4E3A\u6B63\u6574\u6570",
+  /** 任务文件不存在 */
+  TASK_FILE_NOT_FOUND: (path) => `\u4EFB\u52A1\u6587\u4EF6\u4E0D\u5B58\u5728: ${path}`,
+  /** 任务文件中没有解析到有效任务 */
+  TASK_FILE_EMPTY: "\u4EFB\u52A1\u6587\u4EF6\u4E2D\u6CA1\u6709\u89E3\u6790\u5230\u6709\u6548\u4EFB\u52A1",
+  /** 任务文件中某个任务块缺少分支名 */
+  TASK_FILE_MISSING_BRANCH: (blockIndex) => `\u4EFB\u52A1\u6587\u4EF6\u7B2C ${blockIndex} \u4E2A\u4EFB\u52A1\u5757\u7F3A\u5C11\u5206\u652F\u540D\uFF08# branch: ...\uFF09`,
+  /** 任务文件中某个任务块缺少任务描述 */
+  TASK_FILE_MISSING_TASK: (branch) => `\u4EFB\u52A1\u6587\u4EF6\u4E2D\u5206\u652F ${branch} \u7F3A\u5C11\u4EFB\u52A1\u63CF\u8FF0`,
+  /** 任务文件中某个任务块缺少任务描述（无分支名时按索引定位） */
+  TASK_FILE_MISSING_TASK_BY_INDEX: (blockIndex) => `\u4EFB\u52A1\u6587\u4EF6\u7B2C ${blockIndex} \u4E2A\u4EFB\u52A1\u5757\u7F3A\u5C11\u4EFB\u52A1\u63CF\u8FF0`,
+  /** --file 和 --tasks 不能同时使用 */
+  FILE_AND_TASKS_CONFLICT: "--file \u548C --tasks \u4E0D\u80FD\u540C\u65F6\u4F7F\u7528",
+  /** 任务文件加载成功 */
+  TASK_FILE_LOADED: (count, path) => `\u2713 \u4ECE ${path} \u52A0\u8F7D\u4E86 ${count} \u4E2A\u4EFB\u52A1`,
+  /** 未指定 -b 或 -f */
+  BRANCH_OR_FILE_REQUIRED: "\u8BF7\u6307\u5B9A -b \u5206\u652F\u540D\u6216 -f \u4EFB\u52A1\u6587\u4EF6"
 };
 
 // src/constants/messages/create.ts
@@ -288,6 +315,10 @@ var CONFIG_DEFINITIONS = {
   confirmDestructiveOps: {
     defaultValue: true,
     description: "\u6267\u884C\u7834\u574F\u6027\u64CD\u4F5C\uFF08reset\u3001validate --clean\uFF09\u524D\u662F\u5426\u63D0\u793A\u786E\u8BA4"
+  },
+  maxConcurrency: {
+    defaultValue: 0,
+    description: "run \u547D\u4EE4\u9ED8\u8BA4\u6700\u5927\u5E76\u53D1\u6570\uFF0C0 \u8868\u793A\u4E0D\u9650\u5236"
   }
 };
 function deriveDefaultConfig(definitions) {
@@ -311,6 +342,32 @@ var AUTO_SAVE_COMMIT_MESSAGE = "chore: auto-save before sync";
 // src/constants/logger.ts
 var DEBUG_TIMESTAMP_FORMAT = "HH:mm:ss.SSS";
 
+// src/constants/progress.ts
+var SPINNER_FRAMES = ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"];
+var SPINNER_INTERVAL_MS = 100;
+var CURSOR_UP = (n) => `\x1B[${n}A`;
+var CLEAR_LINE = "\x1B[0K";
+var CURSOR_HIDE = "\x1B[?25l";
+var CURSOR_SHOW = "\x1B[?25h";
+var TASK_STATUS_ICONS = {
+  /** 排队中 */
+  PENDING: "\u25E6",
+  /** 完成 */
+  DONE: "\u2713",
+  /** 失败 */
+  FAILED: "\u2717"
+};
+var TASK_STATUS_LABELS = {
+  /** 排队中 */
+  PENDING: "\u6392\u961F\u4E2D",
+  /** 运行中 */
+  RUNNING: "\u8FD0\u884C\u4E2D",
+  /** 完成 */
+  DONE: "\u5B8C\u6210",
+  /** 失败 */
+  FAILED: "\u5931\u8D25"
+};
+
 // src/errors/index.ts
 var ClawtError = class extends Error {
   /** 退出码 */
@@ -616,14 +673,14 @@ function printDoubleSeparator() {
   console.log(MESSAGES.DOUBLE_SEPARATOR);
 }
 function confirmAction(question) {
-  return new Promise((resolve) => {
+  return new Promise((resolve2) => {
     const rl = createInterface({
       input: process.stdin,
       output: process.stdout
     });
     rl.question(`${question} (y/N) `, (answer) => {
       rl.close();
-      resolve(answer.toLowerCase() === "y");
+      resolve2(answer.toLowerCase() === "y");
     });
   });
 }
@@ -650,6 +707,15 @@ function formatWorktreeStatus(status) {
   }
   return parts.join("   ");
 }
+function formatDuration(ms) {
+  const totalSeconds = ms / 1e3;
+  if (totalSeconds < 60) {
+    return `${totalSeconds.toFixed(1)}s`;
+  }
+  const minutes = Math.floor(totalSeconds / 60);
+  const seconds = Math.floor(totalSeconds % 60);
+  return `${minutes}m${String(seconds).padStart(2, "0")}s`;
+}
 
 // src/utils/branch.ts
 function sanitizeBranchName(branchName) {
@@ -742,6 +808,19 @@ function createWorktrees(branchName, count) {
   }
   return results;
 }
+function createWorktreesByBranches(branchNames) {
+  validateBranchesNotExist(branchNames);
+  const projectDir = getProjectWorktreeDir();
+  ensureDir(projectDir);
+  const results = [];
+  for (const name of branchNames) {
+    const worktreePath = join2(projectDir, name);
+    createWorktree(name, worktreePath);
+    results.push({ path: worktreePath, branch: name });
+    logger.info(`worktree \u521B\u5EFA\u5B8C\u6210: ${worktreePath} (\u5206\u652F: ${name})`);
+  }
+  return results;
+}
 function getProjectWorktrees() {
   const projectDir = getProjectWorktreeDir();
   if (!existsSync3(projectDir)) {
@@ -826,7 +905,21 @@ import Enquirer from "enquirer";
 
 // src/utils/claude.ts
 import { spawnSync } from "child_process";
-function launchInteractiveClaude(worktree) {
+import { existsSync as existsSync5, readdirSync as readdirSync3 } from "fs";
+import { join as join3 } from "path";
+function encodeClaudeProjectPath(absolutePath) {
+  return absolutePath.replace(/[^a-zA-Z0-9]/g, "-");
+}
+function hasClaudeSessionHistory(worktreePath) {
+  const encodedName = encodeClaudeProjectPath(worktreePath);
+  const projectDir = join3(CLAUDE_PROJECTS_DIR, encodedName);
+  if (!existsSync5(projectDir)) {
+    return false;
+  }
+  const entries = readdirSync3(projectDir);
+  return entries.some((entry) => entry.endsWith(".jsonl"));
+}
+function launchInteractiveClaude(worktree, options = {}) {
   const commandStr = getConfigValue("claudeCodeCommand");
   const parts = commandStr.split(/\s+/).filter(Boolean);
   const cmd = parts[0];
@@ -835,10 +928,17 @@ function launchInteractiveClaude(worktree) {
     "--append-system-prompt",
     APPEND_SYSTEM_PROMPT
   ];
+  const hasPreviousSession = options.autoContinue === true && hasClaudeSessionHistory(worktree.path);
+  if (hasPreviousSession) {
+    args.push("--continue");
+  }
   printInfo(`\u6B63\u5728 worktree \u4E2D\u542F\u52A8 Claude Code \u4EA4\u4E92\u5F0F\u754C\u9762...`);
   printInfo(`  \u5206\u652F: ${worktree.branch}`);
   printInfo(`  \u8DEF\u5F84: ${worktree.path}`);
   printInfo(`  \u6307\u4EE4: ${commandStr}`);
+  if (options.autoContinue) {
+    printInfo(`  \u6A21\u5F0F: ${hasPreviousSession ? "\u7EE7\u7EED\u4E0A\u6B21\u5BF9\u8BDD" : "\u65B0\u5BF9\u8BDD"}`);
+  }
   printInfo("");
   const result = spawnSync(cmd, args, {
     cwd: worktree.path,
@@ -853,29 +953,29 @@ function launchInteractiveClaude(worktree) {
 }
 
 // src/utils/validate-snapshot.ts
-import { join as join3 } from "path";
-import { existsSync as existsSync5, readFileSync as readFileSync2, writeFileSync as writeFileSync2, unlinkSync, readdirSync as readdirSync3, rmdirSync as rmdirSync2 } from "fs";
+import { join as join4 } from "path";
+import { existsSync as existsSync6, readFileSync as readFileSync2, writeFileSync as writeFileSync2, unlinkSync, readdirSync as readdirSync4, rmdirSync as rmdirSync2 } from "fs";
 function getSnapshotPath(projectName, branchName) {
-  return join3(VALIDATE_SNAPSHOTS_DIR, projectName, `${branchName}.tree`);
+  return join4(VALIDATE_SNAPSHOTS_DIR, projectName, `${branchName}.tree`);
 }
 function getSnapshotHeadPath(projectName, branchName) {
-  return join3(VALIDATE_SNAPSHOTS_DIR, projectName, `${branchName}.head`);
+  return join4(VALIDATE_SNAPSHOTS_DIR, projectName, `${branchName}.head`);
 }
 function hasSnapshot(projectName, branchName) {
-  return existsSync5(getSnapshotPath(projectName, branchName));
+  return existsSync6(getSnapshotPath(projectName, branchName));
 }
 function readSnapshot(projectName, branchName) {
   const snapshotPath = getSnapshotPath(projectName, branchName);
   const headPath = getSnapshotHeadPath(projectName, branchName);
   logger.debug(`\u8BFB\u53D6 validate \u5FEB\u7167: ${snapshotPath}`);
-  const treeHash = existsSync5(snapshotPath) ? readFileSync2(snapshotPath, "utf-8").trim() : "";
-  const headCommitHash = existsSync5(headPath) ? readFileSync2(headPath, "utf-8").trim() : "";
+  const treeHash = existsSync6(snapshotPath) ? readFileSync2(snapshotPath, "utf-8").trim() : "";
+  const headCommitHash = existsSync6(headPath) ? readFileSync2(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 = join3(VALIDATE_SNAPSHOTS_DIR, projectName);
+  const snapshotDir = join4(VALIDATE_SNAPSHOTS_DIR, projectName);
   ensureDir(snapshotDir);
   writeFileSync2(snapshotPath, treeHash, "utf-8");
   writeFileSync2(headPath, headCommitHash, "utf-8");
@@ -884,31 +984,31 @@ function writeSnapshot(projectName, branchName, treeHash, headCommitHash) {
 function removeSnapshot(projectName, branchName) {
   const snapshotPath = getSnapshotPath(projectName, branchName);
   const headPath = getSnapshotHeadPath(projectName, branchName);
-  if (existsSync5(snapshotPath)) {
+  if (existsSync6(snapshotPath)) {
     unlinkSync(snapshotPath);
     logger.info(`\u5DF2\u5220\u9664 validate \u5FEB\u7167: ${snapshotPath}`);
   }
-  if (existsSync5(headPath)) {
+  if (existsSync6(headPath)) {
     unlinkSync(headPath);
     logger.info(`\u5DF2\u5220\u9664 validate \u5FEB\u7167: ${headPath}`);
   }
 }
 function getProjectSnapshotBranches(projectName) {
-  const projectDir = join3(VALIDATE_SNAPSHOTS_DIR, projectName);
-  if (!existsSync5(projectDir)) {
+  const projectDir = join4(VALIDATE_SNAPSHOTS_DIR, projectName);
+  if (!existsSync6(projectDir)) {
     return [];
   }
-  const files = readdirSync3(projectDir);
+  const files = readdirSync4(projectDir);
   return files.filter((f) => f.endsWith(".tree")).map((f) => f.replace(/\.tree$/, ""));
 }
 function removeProjectSnapshots(projectName) {
-  const projectDir = join3(VALIDATE_SNAPSHOTS_DIR, projectName);
-  if (!existsSync5(projectDir)) {
+  const projectDir = join4(VALIDATE_SNAPSHOTS_DIR, projectName);
+  if (!existsSync6(projectDir)) {
     return;
   }
-  const files = readdirSync3(projectDir);
+  const files = readdirSync4(projectDir);
   for (const file of files) {
-    unlinkSync(join3(projectDir, file));
+    unlinkSync(join4(projectDir, file));
   }
   try {
     rmdirSync2(projectDir);
@@ -999,8 +1099,467 @@ async function resolveTargetWorktree(worktrees, messages, branchName) {
   throw new ClawtError(messages.noMatch(branchName, allBranches));
 }
 
-// src/commands/list.ts
+// src/utils/progress-render.ts
 import chalk3 from "chalk";
+function getMaxBranchWidth(tasks) {
+  return Math.max(...tasks.map((t) => t.branch.length));
+}
+function renderTaskLine(task, total, maxBranchWidth, spinnerChar) {
+  const indexStr = `[${task.index}/${total}]`;
+  const branchStr = task.branch.padEnd(maxBranchWidth);
+  switch (task.status) {
+    case "pending": {
+      return `${indexStr} ${branchStr}  ${chalk3.gray(TASK_STATUS_ICONS.PENDING)} ${chalk3.gray(TASK_STATUS_LABELS.PENDING)}  ${chalk3.dim(task.path)}`;
+    }
+    case "running": {
+      const elapsed = formatDuration(Date.now() - task.startedAt);
+      return `${indexStr} ${branchStr}  ${chalk3.cyan(spinnerChar)} ${chalk3.cyan(TASK_STATUS_LABELS.RUNNING)} ${chalk3.gray(elapsed)}  ${chalk3.dim(task.path)}`;
+    }
+    case "done": {
+      const duration = task.durationMs != null ? formatDuration(task.durationMs) : "N/A";
+      const cost = task.costUsd != null ? `$${task.costUsd.toFixed(2)}` : "";
+      return `${indexStr} ${branchStr}  ${chalk3.green(TASK_STATUS_ICONS.DONE)} ${chalk3.green(TASK_STATUS_LABELS.DONE)}   ${chalk3.gray(duration)}  ${chalk3.yellow(cost)}  ${chalk3.dim(task.path)}`;
+    }
+    case "failed": {
+      const duration = task.durationMs != null ? formatDuration(task.durationMs) : "N/A";
+      return `${indexStr} ${branchStr}  ${chalk3.red(TASK_STATUS_ICONS.FAILED)} ${chalk3.red(TASK_STATUS_LABELS.FAILED)}   ${chalk3.gray(duration)}  ${chalk3.dim(task.path)}`;
+    }
+  }
+}
+function renderSummaryLine(tasks, total) {
+  const running = tasks.filter((t) => t.status === "running").length;
+  const done = tasks.filter((t) => t.status === "done").length;
+  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(chalk3.cyan(`${running}/${total} ${TASK_STATUS_LABELS.RUNNING}`));
+  if (done > 0) parts.push(chalk3.green(`${done}/${total} ${TASK_STATUS_LABELS.DONE}`));
+  if (failed > 0) parts.push(chalk3.red(`${failed}/${total} ${TASK_STATUS_LABELS.FAILED}`));
+  if (pending > 0) parts.push(chalk3.gray(`${pending}/${total} ${TASK_STATUS_LABELS.PENDING}`));
+  return `[${parts.join(", ")}]`;
+}
+
+// src/utils/progress.ts
+var ProgressRenderer = class {
+  /** 所有任务的进度状态 */
+  tasks;
+  /** 总任务数 */
+  total;
+  /** 当前 spinner 帧索引 */
+  frameIndex;
+  /** 定时器引用 */
+  timer;
+  /** 是否为 TTY 环境 */
+  isTTY;
+  /** 已渲染的行数（用于回退光标） */
+  renderedLineCount;
+  /** 是否已停止 */
+  stopped;
+  /** 是否存在排队任务（启用汇总行渲染） */
+  hasPendingTasks;
+  /**
+   * 创建进度面板渲染器
+   * @param {string[]} branches - 分支名列表，顺序对应任务列表
+   * @param {string[]} paths - worktree 路径列表，完成/失败后显示
+   * @param {boolean} [allRunning=true] - 是否将所有任务初始化为 running 状态，false 时初始化为 pending
+   */
+  constructor(branches, paths, allRunning = true) {
+    const now = Date.now();
+    this.total = branches.length;
+    this.frameIndex = 0;
+    this.timer = null;
+    this.isTTY = !!process.stdout.isTTY;
+    this.renderedLineCount = 0;
+    this.stopped = false;
+    this.hasPendingTasks = !allRunning;
+    this.tasks = branches.map((branch, i) => ({
+      index: i + 1,
+      branch,
+      path: paths[i],
+      status: allRunning ? "running" : "pending",
+      startedAt: allRunning ? now : 0,
+      finishedAt: null,
+      lastActiveAt: allRunning ? now : 0,
+      durationMs: null,
+      costUsd: null
+    }));
+  }
+  /**
+   * 启动定时渲染循环
+   * TTY 模式下每 SPINNER_INTERVAL_MS 毫秒刷新一次面板
+   * 非 TTY 模式下输出状态为 running 的任务的启动信息
+   */
+  start() {
+    if (this.stopped) return;
+    if (!this.isTTY) {
+      for (const task of this.tasks) {
+        if (task.status === "running") {
+          console.log(MESSAGES.PROGRESS_TASK_STARTED(task.index, this.total, task.branch, task.path));
+        }
+      }
+      return;
+    }
+    process.stdout.write(CURSOR_HIDE);
+    this.render();
+    this.timer = setInterval(() => {
+      this.frameIndex = (this.frameIndex + 1) % SPINNER_FRAMES.length;
+      this.render();
+    }, SPINNER_INTERVAL_MS);
+    if (this.timer.unref) {
+      this.timer.unref();
+    }
+  }
+  /**
+   * 更新指定任务的最后活动时间戳
+   * 当 child.stderr 有输出时调用，表示任务仍然活跃
+   * @param {number} index - 任务索引（从 0 开始）
+   */
+  updateActivity(index) {
+    this.tasks[index].lastActiveAt = Date.now();
+  }
+  /**
+   * 标记指定任务为运行中状态
+   * 将 pending 任务标记为 running 并设置启动时间戳
+   * @param {number} index - 任务索引（从 0 开始）
+   */
+  markRunning(index) {
+    const task = this.tasks[index];
+    const now = Date.now();
+    task.status = "running";
+    task.startedAt = now;
+    task.lastActiveAt = now;
+    if (!this.isTTY) {
+      console.log(MESSAGES.PROGRESS_TASK_STARTED(task.index, this.total, task.branch, task.path));
+    }
+  }
+  /**
+   * 标记指定任务为完成状态
+   * @param {number} index - 任务索引（从 0 开始）
+   * @param {number} durationMs - 耗时（毫秒）
+   * @param {number} costUsd - 费用（美元）
+   */
+  markDone(index, durationMs, costUsd) {
+    const task = this.tasks[index];
+    task.status = "done";
+    task.finishedAt = Date.now();
+    task.durationMs = durationMs;
+    task.costUsd = costUsd;
+    if (!this.isTTY) {
+      const duration = formatDuration(durationMs);
+      const cost = `$${costUsd.toFixed(2)}`;
+      console.log(MESSAGES.PROGRESS_TASK_DONE(task.index, this.total, task.branch, duration, cost, task.path));
+    }
+  }
+  /**
+   * 标记指定任务为失败状态
+   * @param {number} index - 任务索引（从 0 开始）
+   * @param {number} durationMs - 耗时（毫秒）
+   */
+  markFailed(index, durationMs) {
+    const task = this.tasks[index];
+    task.status = "failed";
+    task.finishedAt = Date.now();
+    task.durationMs = durationMs;
+    if (!this.isTTY) {
+      const duration = formatDuration(durationMs);
+      console.log(MESSAGES.PROGRESS_TASK_FAILED(task.index, this.total, task.branch, duration, task.path));
+    }
+  }
+  /**
+   * 停止渲染循环并恢复光标
+   * 在所有任务完成或 SIGINT 中断时调用
+   */
+  stop() {
+    if (this.stopped) return;
+    this.stopped = true;
+    if (this.timer) {
+      clearInterval(this.timer);
+      this.timer = null;
+    }
+    if (this.isTTY) {
+      this.render();
+      process.stdout.write(CURSOR_SHOW);
+    }
+  }
+  /**
+   * 执行一次完整的面板渲染
+   * 先回退光标到面板起始位置，再逐行输出
+   */
+  render() {
+    const maxBranchWidth = getMaxBranchWidth(this.tasks);
+    const spinnerChar = SPINNER_FRAMES[this.frameIndex];
+    const lines = this.tasks.map((task) => renderTaskLine(task, this.total, maxBranchWidth, spinnerChar));
+    if (this.hasPendingTasks) {
+      lines.push(renderSummaryLine(this.tasks, this.total));
+    }
+    if (this.renderedLineCount > 0) {
+      process.stdout.write(CURSOR_UP(this.renderedLineCount));
+    }
+    for (const line of lines) {
+      process.stdout.write(`${line}${CLEAR_LINE}
+`);
+    }
+    this.renderedLineCount = lines.length;
+  }
+};
+
+// src/utils/task-file.ts
+import { resolve } from "path";
+import { existsSync as existsSync7, readFileSync as readFileSync3 } from "fs";
+var TASK_BLOCK_REGEX = /<!-- CLAWT-TASKS:START -->([\s\S]*?)<!-- CLAWT-TASKS:END -->/g;
+var BRANCH_LINE_REGEX = /^#\s*branch:\s*(.+)$/;
+function parseTaskFile(content, options) {
+  const branchRequired = options?.branchRequired ?? true;
+  const entries = [];
+  let match;
+  let blockIndex = 0;
+  TASK_BLOCK_REGEX.lastIndex = 0;
+  while ((match = TASK_BLOCK_REGEX.exec(content)) !== null) {
+    blockIndex++;
+    const blockContent = match[1].trim();
+    const lines = blockContent.split("\n");
+    let branch;
+    const taskLines = [];
+    for (const line of lines) {
+      const branchMatch = line.trim().match(BRANCH_LINE_REGEX);
+      if (branchMatch) {
+        branch = branchMatch[1].trim();
+      } else {
+        taskLines.push(line);
+      }
+    }
+    if (branchRequired && !branch) {
+      throw new ClawtError(MESSAGES.TASK_FILE_MISSING_BRANCH(blockIndex));
+    }
+    const task = taskLines.join("\n").trim();
+    if (!task) {
+      throw new ClawtError(
+        branch ? MESSAGES.TASK_FILE_MISSING_TASK(branch) : MESSAGES.TASK_FILE_MISSING_TASK_BY_INDEX(blockIndex)
+      );
+    }
+    entries.push({ branch, task });
+  }
+  return entries;
+}
+function loadTaskFile(filePath, options) {
+  const absolutePath = resolve(filePath);
+  if (!existsSync7(absolutePath)) {
+    throw new ClawtError(MESSAGES.TASK_FILE_NOT_FOUND(absolutePath));
+  }
+  const content = readFileSync3(absolutePath, "utf-8");
+  const entries = parseTaskFile(content, options);
+  if (entries.length === 0) {
+    throw new ClawtError(MESSAGES.TASK_FILE_EMPTY);
+  }
+  return entries;
+}
+
+// src/utils/task-executor.ts
+function executeClaudeTask(worktree, task) {
+  const child = spawnProcess(
+    "claude",
+    ["-p", task, "--output-format", "json", "--permission-mode", "bypassPermissions"],
+    {
+      cwd: worktree.path,
+      // stdin 必须设置为 'ignore'，不能用 'pipe'
+      // 原因：claude -p 是非交互模式，不需要 stdin 输入。如果 stdin 为 'pipe'，
+      // 父进程会创建一个可写流连接到子进程但从不写入也不关闭，
+      // claude 检测到 stdin 是管道后会尝试读取输入，导致进程永远卡住
+      stdio: ["ignore", "pipe", "pipe"]
+    }
+  );
+  const promise = new Promise((resolve2) => {
+    let stdout = "";
+    let stderr = "";
+    child.stdout?.on("data", (data) => {
+      stdout += data.toString();
+    });
+    child.stderr?.on("data", (data) => {
+      stderr += data.toString();
+    });
+    child.on("close", (code) => {
+      let result = null;
+      let success = code === 0;
+      try {
+        if (stdout.trim()) {
+          result = JSON.parse(stdout.trim());
+          success = !result.is_error;
+        }
+      } catch {
+        logger.warn(`\u89E3\u6790 Claude Code \u8F93\u51FA\u5931\u8D25: ${stdout.substring(0, 200)}`);
+      }
+      resolve2({
+        task,
+        branch: worktree.branch,
+        worktreePath: worktree.path,
+        success,
+        result,
+        error: success ? void 0 : stderr || "\u4EFB\u52A1\u6267\u884C\u5931\u8D25"
+      });
+    });
+    child.on("error", (err) => {
+      resolve2({
+        task,
+        branch: worktree.branch,
+        worktreePath: worktree.path,
+        success: false,
+        result: null,
+        error: err.message
+      });
+    });
+  });
+  return { child, promise };
+}
+function printTaskSummary(summary) {
+  printDoubleSeparator();
+  printInfo(`\u5168\u90E8\u4EFB\u52A1\u5DF2\u5B8C\u6210 (${summary.total}/${summary.total})`);
+  printInfo(`  \u6210\u529F: ${summary.succeeded}`);
+  printInfo(`  \u5931\u8D25: ${summary.failed}`);
+  printInfo(`  \u603B\u8017\u65F6: ${(summary.totalDurationMs / 1e3).toFixed(1)}s`);
+  printInfo(`  \u603B\u82B1\u8D39: $${summary.totalCostUsd.toFixed(2)}`);
+  printDoubleSeparator();
+}
+async function handleInterruptCleanup(worktrees) {
+  const autoDelete = getConfigValue("autoDeleteBranch");
+  if (autoDelete) {
+    cleanupWorktrees(worktrees);
+    printSuccess(MESSAGES.INTERRUPT_AUTO_CLEANED(worktrees.length));
+    return;
+  }
+  const shouldClean = await confirmAction(MESSAGES.INTERRUPT_CONFIRM_CLEANUP);
+  if (shouldClean) {
+    cleanupWorktrees(worktrees);
+    printSuccess(MESSAGES.INTERRUPT_CLEANED(worktrees.length));
+  } else {
+    printInfo(MESSAGES.INTERRUPT_KEPT);
+  }
+}
+function updateRendererStatus(renderer, index, result, startTime) {
+  if (result.success) {
+    renderer.markDone(
+      index,
+      result.result?.duration_ms ?? Date.now() - startTime,
+      result.result?.total_cost_usd ?? 0
+    );
+  } else {
+    renderer.markFailed(
+      index,
+      result.result?.duration_ms ?? Date.now() - startTime
+    );
+  }
+}
+async function executeWithConcurrency(worktrees, tasks, concurrency, renderer, startTime, isInterrupted, childProcesses) {
+  const total = tasks.length;
+  const results = new Array(total);
+  let nextIndex = 0;
+  let completedCount = 0;
+  return new Promise((resolve2) => {
+    function launchNext() {
+      if (nextIndex >= total || isInterrupted()) return;
+      const index = nextIndex;
+      nextIndex++;
+      const wt = worktrees[index];
+      const task = tasks[index];
+      logger.info(`\u542F\u52A8\u4EFB\u52A1 ${index + 1}: ${task} (worktree: ${wt.path})`);
+      renderer.markRunning(index);
+      const handle = executeClaudeTask(wt, task);
+      childProcesses.push(handle.child);
+      handle.child.stderr?.on("data", () => {
+        renderer.updateActivity(index);
+      });
+      handle.promise.then((result) => {
+        results[index] = result;
+        completedCount++;
+        if (!isInterrupted()) {
+          updateRendererStatus(renderer, index, result, startTime);
+        }
+        launchNext();
+        if (completedCount === total) {
+          resolve2(results);
+        }
+      });
+    }
+    const initialBatch = Math.min(concurrency, total);
+    for (let i = 0; i < initialBatch; i++) {
+      launchNext();
+    }
+  });
+}
+async function executeAllParallel(worktrees, tasks, renderer, startTime, isInterrupted, childProcesses) {
+  const handles = worktrees.map((wt, index) => {
+    const task = tasks[index];
+    logger.info(`\u542F\u52A8\u4EFB\u52A1 ${index + 1}: ${task} (worktree: ${wt.path})`);
+    const handle = executeClaudeTask(wt, task);
+    childProcesses.push(handle.child);
+    handle.child.stderr?.on("data", () => {
+      renderer.updateActivity(index);
+    });
+    return handle;
+  });
+  const results = await Promise.all(
+    handles.map(
+      (handle, index) => handle.promise.then((result) => {
+        if (!isInterrupted()) {
+          updateRendererStatus(renderer, index, result, startTime);
+        }
+        return result;
+      })
+    )
+  );
+  return results;
+}
+async function executeBatchTasks(worktrees, tasks, concurrency) {
+  const count = tasks.length;
+  if (concurrency > 0) {
+    printInfo(MESSAGES.CONCURRENCY_INFO(concurrency, count));
+    printInfo("");
+  }
+  const startTime = Date.now();
+  const branches = worktrees.map((wt) => wt.branch);
+  const paths = worktrees.map((wt) => wt.path);
+  const allRunning = concurrency === 0;
+  const renderer = new ProgressRenderer(branches, paths, allRunning);
+  renderer.start();
+  let interrupted = false;
+  const isInterrupted = () => interrupted;
+  const childProcesses = [];
+  const sigintHandler = async () => {
+    if (interrupted) return;
+    interrupted = true;
+    renderer.stop();
+    printInfo("");
+    printWarning(MESSAGES.INTERRUPTED);
+    killAllChildProcesses(childProcesses);
+    await Promise.allSettled(childProcesses.map(
+      (cp) => new Promise((resolve2) => {
+        if (cp.exitCode !== null) {
+          resolve2();
+        } else {
+          cp.on("close", () => resolve2());
+        }
+      })
+    ));
+    await handleInterruptCleanup(worktrees);
+    process.exit(1);
+  };
+  process.on("SIGINT", sigintHandler);
+  const results = concurrency > 0 ? await executeWithConcurrency(worktrees, tasks, concurrency, renderer, startTime, isInterrupted, childProcesses) : await executeAllParallel(worktrees, tasks, renderer, startTime, isInterrupted, childProcesses);
+  renderer.stop();
+  process.removeListener("SIGINT", sigintHandler);
+  if (interrupted) return;
+  const totalDurationMs = Date.now() - startTime;
+  const summary = {
+    total: results.length,
+    succeeded: results.filter((r) => r.success).length,
+    failed: results.filter((r) => !r.success).length,
+    totalDurationMs,
+    totalCostUsd: results.reduce((sum, r) => sum + (r.result?.total_cost_usd ?? 0), 0)
+  };
+  printTaskSummary(summary);
+}
+
+// src/commands/list.ts
+import chalk4 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) => {
     handleList(options);
@@ -1037,12 +1596,12 @@ function printListAsText(projectName, worktrees) {
     for (const wt of worktrees) {
       const status = getWorktreeStatus(wt);
       const isIdle = status ? isWorktreeIdle(status) : false;
-      const pathDisplay = isIdle ? chalk3.hex("#FF8C00")(wt.path) : wt.path;
+      const pathDisplay = isIdle ? chalk4.hex("#FF8C00")(wt.path) : wt.path;
       printInfo(`  ${pathDisplay}   [${wt.branch}]`);
       if (status) {
         printInfo(`    ${formatWorktreeStatus(status)}`);
       } else {
-        printInfo(`    ${chalk3.yellow(MESSAGES.WORKTREE_STATUS_UNAVAILABLE)}`);
+        printInfo(`    ${chalk4.yellow(MESSAGES.WORKTREE_STATUS_UNAVAILABLE)}`);
       }
       printInfo("");
     }
@@ -1145,110 +1704,48 @@ 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").requiredOption("-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").action(async (options) => {
+  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").action(async (options) => {
     await handleRun(options);
   });
 }
-function executeClaudeTask(worktree, task) {
-  const child = spawnProcess(
-    "claude",
-    ["-p", task, "--output-format", "json", "--permission-mode", "bypassPermissions"],
-    {
-      cwd: worktree.path,
-      // stdin 必须设置为 'ignore'，不能用 'pipe'
-      // 原因：claude -p 是非交互模式，不需要 stdin 输入。如果 stdin 为 'pipe'，
-      // 父进程会创建一个可写流连接到子进程但从不写入也不关闭，
-      // claude 检测到 stdin 是管道后会尝试读取输入，导致进程永远卡住
-      stdio: ["ignore", "pipe", "pipe"]
-    }
-  );
-  const promise = new Promise((resolve) => {
-    let stdout = "";
-    let stderr = "";
-    child.stdout?.on("data", (data) => {
-      stdout += data.toString();
-    });
-    child.stderr?.on("data", (data) => {
-      stderr += data.toString();
-    });
-    child.on("close", (code) => {
-      let result = null;
-      let success = code === 0;
-      try {
-        if (stdout.trim()) {
-          result = JSON.parse(stdout.trim());
-          success = !result.is_error;
-        }
-      } catch {
-        logger.warn(`\u89E3\u6790 Claude Code \u8F93\u51FA\u5931\u8D25: ${stdout.substring(0, 200)}`);
-      }
-      resolve({
-        task,
-        branch: worktree.branch,
-        worktreePath: worktree.path,
-        success,
-        result,
-        error: success ? void 0 : stderr || "\u4EFB\u52A1\u6267\u884C\u5931\u8D25"
-      });
-    });
-    child.on("error", (err) => {
-      resolve({
-        task,
-        branch: worktree.branch,
-        worktreePath: worktree.path,
-        success: false,
-        result: null,
-        error: err.message
-      });
-    });
-  });
-  return { child, promise };
-}
-function printTaskNotification(taskResult) {
-  const { success, worktreePath, branch, result } = taskResult;
-  const status = success ? "\u5B8C\u6210" : "\u5931\u8D25";
-  const icon = success ? "\u2713" : "\u2717";
-  const durationStr = result ? `${(result.duration_ms / 1e3).toFixed(1)}s` : "N/A";
-  const costStr = result ? `$${result.total_cost_usd.toFixed(2)}` : "N/A";
-  const resultStr = success ? "success" : "failed";
-  if (success) {
-    printSuccess(`${icon} [${status}] worktree: ${worktreePath}`);
-  } else {
-    printError(`${icon} [${status}] worktree: ${worktreePath}`);
+function parseConcurrency(optionValue, configValue) {
+  if (optionValue === void 0) {
+    return configValue;
   }
-  printInfo(`  \u5206\u652F: ${branch}`);
-  printInfo(`  \u8017\u65F6: ${durationStr}`);
-  printInfo(`  \u82B1\u8D39: ${costStr}`);
-  printInfo(`  \u7ED3\u679C: ${resultStr}`);
-  printSeparator();
-}
-function printTaskSummary(summary) {
-  printDoubleSeparator();
-  printInfo(`\u5168\u90E8\u4EFB\u52A1\u5DF2\u5B8C\u6210 (${summary.total}/${summary.total})`);
-  printInfo(`  \u6210\u529F: ${summary.succeeded}`);
-  printInfo(`  \u5931\u8D25: ${summary.failed}`);
-  printInfo(`  \u603B\u8017\u65F6: ${(summary.totalDurationMs / 1e3).toFixed(1)}s`);
-  printInfo(`  \u603B\u82B1\u8D39: $${summary.totalCostUsd.toFixed(2)}`);
-  printDoubleSeparator();
-}
-async function handleInterruptCleanup(worktrees) {
-  const autoDelete = getConfigValue("autoDeleteBranch");
-  if (autoDelete) {
-    cleanupWorktrees(worktrees);
-    printSuccess(MESSAGES.INTERRUPT_AUTO_CLEANED(worktrees.length));
-    return;
+  const parsed = parseInt(optionValue, 10);
+  if (Number.isNaN(parsed) || parsed < 0) {
+    throw new ClawtError(MESSAGES.CONCURRENCY_INVALID);
   }
-  const shouldClean = await confirmAction(MESSAGES.INTERRUPT_CONFIRM_CLEANUP);
-  if (shouldClean) {
-    cleanupWorktrees(worktrees);
-    printSuccess(MESSAGES.INTERRUPT_CLEANED(worktrees.length));
+  return parsed;
+}
+async function handleRunFromFile(options) {
+  const branchRequired = !options.branch;
+  const entries = loadTaskFile(options.file, { branchRequired });
+  printSuccess(MESSAGES.TASK_FILE_LOADED(entries.length, options.file));
+  const tasks = entries.map((e) => e.task);
+  let worktrees;
+  if (options.branch) {
+    worktrees = createWorktrees(options.branch, entries.length);
   } else {
-    printInfo(MESSAGES.INTERRUPT_KEPT);
+    const branches = entries.map((e) => sanitizeBranchName(e.branch));
+    worktrees = createWorktreesByBranches(branches);
   }
+  const concurrency = parseConcurrency(options.concurrency, getConfigValue("maxConcurrency"));
+  logger.info(`run \u547D\u4EE4\uFF08\u6587\u4EF6\u6A21\u5F0F\uFF09\u6267\u884C\uFF0C\u4EFB\u52A1\u6570: ${entries.length}\uFF0C\u5E76\u53D1\u6570: ${concurrency || "\u4E0D\u9650\u5236"}`);
+  await executeBatchTasks(worktrees, tasks, concurrency);
 }
 async function handleRun(options) {
   validateMainWorktree();
   validateClaudeCodeInstalled();
+  if (options.file && options.tasks) {
+    throw new ClawtError(MESSAGES.FILE_AND_TASKS_CONFLICT);
+  }
+  if (options.file) {
+    return handleRunFromFile(options);
+  }
+  if (!options.branch) {
+    throw new ClawtError(MESSAGES.BRANCH_OR_FILE_REQUIRED);
+  }
   if (!options.tasks || options.tasks.length === 0) {
     const sanitized = sanitizeBranchName(options.branch);
     if (checkBranchExists(sanitized)) {
@@ -1265,52 +1762,10 @@ async function handleRun(options) {
     throw new ClawtError("\u4EFB\u52A1\u5217\u8868\u4E0D\u80FD\u4E3A\u7A7A");
   }
   const count = tasks.length;
-  logger.info(`run \u547D\u4EE4\u6267\u884C\uFF0C\u5206\u652F: ${options.branch}\uFF0C\u4EFB\u52A1\u6570: ${count}`);
+  const concurrency = parseConcurrency(options.concurrency, getConfigValue("maxConcurrency"));
+  logger.info(`run \u547D\u4EE4\u6267\u884C\uFF0C\u5206\u652F: ${options.branch}\uFF0C\u4EFB\u52A1\u6570: ${count}\uFF0C\u5E76\u53D1\u6570: ${concurrency || "\u4E0D\u9650\u5236"}`);
   const worktrees = createWorktrees(options.branch, count);
-  printSuccess(MESSAGES.WORKTREE_CREATED(worktrees.length));
-  for (const wt of worktrees) {
-    printInfo(`  \u5206\u652F: ${wt.branch}  \u8DEF\u5F84: ${wt.path}`);
-  }
-  printInfo("");
-  const startTime = Date.now();
-  const handles = worktrees.map((wt, index) => {
-    const task = tasks[index];
-    logger.info(`\u542F\u52A8\u4EFB\u52A1 ${index + 1}: ${task} (worktree: ${wt.path})`);
-    return executeClaudeTask(wt, task);
-  });
-  const childProcesses = handles.map((h) => h.child);
-  let interrupted = false;
-  const sigintHandler = async () => {
-    if (interrupted) return;
-    interrupted = true;
-    printInfo("");
-    printWarning(MESSAGES.INTERRUPTED);
-    killAllChildProcesses(childProcesses);
-    await Promise.allSettled(handles.map((h) => h.promise));
-    await handleInterruptCleanup(worktrees);
-    process.exit(1);
-  };
-  process.on("SIGINT", sigintHandler);
-  const taskPromises = handles.map(
-    (handle) => handle.promise.then((result) => {
-      if (!interrupted) {
-        printTaskNotification(result);
-      }
-      return result;
-    })
-  );
-  const results = await Promise.all(taskPromises);
-  process.removeListener("SIGINT", sigintHandler);
-  if (interrupted) return;
-  const totalDurationMs = Date.now() - startTime;
-  const summary = {
-    total: results.length,
-    succeeded: results.filter((r) => r.success).length,
-    failed: results.filter((r) => !r.success).length,
-    totalDurationMs,
-    totalCostUsd: results.reduce((sum, r) => sum + (r.result?.total_cost_usd ?? 0), 0)
-  };
-  printTaskSummary(summary);
+  await executeBatchTasks(worktrees, tasks, concurrency);
 }
 
 // src/commands/resume.ts
@@ -1331,7 +1786,7 @@ async function handleResume(options) {
   logger.info(`resume \u547D\u4EE4\u6267\u884C\uFF0C\u5206\u652F: ${options.branch ?? "(\u672A\u6307\u5B9A)"}`);
   const worktrees = getProjectWorktrees();
   const worktree = await resolveTargetWorktree(worktrees, RESUME_RESOLVE_MESSAGES, options.branch);
-  launchInteractiveClaude(worktree);
+  launchInteractiveClaude(worktree, { autoContinue: true });
 }
 
 // src/commands/validate.ts
@@ -1637,7 +2092,7 @@ async function handleMerge(options) {
 }
 
 // src/commands/config.ts
-import chalk4 from "chalk";
+import chalk5 from "chalk";
 function registerConfigCommand(program2) {
   const configCmd = program2.command("config").description("\u67E5\u770B\u548C\u7BA1\u7406\u5168\u5C40\u914D\u7F6E").action(() => {
     handleConfig();
@@ -1650,7 +2105,7 @@ function handleConfig() {
   const config = loadConfig();
   logger.info("config \u547D\u4EE4\u6267\u884C\uFF0C\u5C55\u793A\u5168\u5C40\u914D\u7F6E");
   printInfo(`
-${chalk4.dim("\u914D\u7F6E\u6587\u4EF6\u8DEF\u5F84:")} ${CONFIG_PATH}
+${chalk5.dim("\u914D\u7F6E\u6587\u4EF6\u8DEF\u5F84:")} ${CONFIG_PATH}
 `);
   printSeparator();
   const keys = Object.keys(DEFAULT_CONFIG);
@@ -1660,8 +2115,8 @@ ${chalk4.dim("\u914D\u7F6E\u6587\u4EF6\u8DEF\u5F84:")} ${CONFIG_PATH}
     const description = CONFIG_DESCRIPTIONS[key];
     const formattedValue = formatConfigValue(value);
     if (i === 0) printInfo("");
-    printInfo(`  ${chalk4.bold(key)}: ${formattedValue}`);
-    printInfo(`  ${chalk4.dim(description)}`);
+    printInfo(`  ${chalk5.bold(key)}: ${formattedValue}`);
+    printInfo(`  ${chalk5.dim(description)}`);
     printInfo("");
   }
   printSeparator();
@@ -1681,9 +2136,9 @@ async function handleConfigReset() {
 }
 function formatConfigValue(value) {
   if (typeof value === "boolean") {
-    return value ? chalk4.green("true") : chalk4.yellow("false");
+    return value ? chalk5.green("true") : chalk5.yellow("false");
   }
-  return chalk4.cyan(String(value));
+  return chalk5.cyan(String(value));
 }
 
 // src/commands/sync.ts
@@ -1770,7 +2225,7 @@ async function handleReset() {
 }
 
 // src/commands/status.ts
-import chalk5 from "chalk";
+import chalk6 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);
@@ -1866,7 +2321,7 @@ function printStatusAsJson(result) {
 }
 function printStatusAsText(result) {
   printDoubleSeparator();
-  printInfo(`  ${chalk5.bold.cyan(MESSAGES.STATUS_TITLE(result.main.projectName))}`);
+  printInfo(`  ${chalk6.bold.cyan(MESSAGES.STATUS_TITLE(result.main.projectName))}`);
   printDoubleSeparator();
   printInfo("");
   printMainSection(result.main);
@@ -1879,17 +2334,17 @@ function printStatusAsText(result) {
   printDoubleSeparator();
 }
 function printMainSection(main) {
-  printInfo(`  ${chalk5.bold("\u25C6")} ${chalk5.bold(MESSAGES.STATUS_MAIN_SECTION)}`);
-  printInfo(`    \u5206\u652F: ${chalk5.bold(main.branch)}`);
+  printInfo(`  ${chalk6.bold("\u25C6")} ${chalk6.bold(MESSAGES.STATUS_MAIN_SECTION)}`);
+  printInfo(`    \u5206\u652F: ${chalk6.bold(main.branch)}`);
   if (main.isClean) {
-    printInfo(`    \u72B6\u6001: ${chalk5.green("\u2713 \u5E72\u51C0")}`);
+    printInfo(`    \u72B6\u6001: ${chalk6.green("\u2713 \u5E72\u51C0")}`);
   } else {
-    printInfo(`    \u72B6\u6001: ${chalk5.yellow("\u2717 \u6709\u672A\u63D0\u4EA4\u4FEE\u6539")}`);
+    printInfo(`    \u72B6\u6001: ${chalk6.yellow("\u2717 \u6709\u672A\u63D0\u4EA4\u4FEE\u6539")}`);
   }
   printInfo("");
 }
 function printWorktreesSection(worktrees, total) {
-  printInfo(`  ${chalk5.bold("\u25C6")} ${chalk5.bold(MESSAGES.STATUS_WORKTREES_SECTION)} (${total} \u4E2A)`);
+  printInfo(`  ${chalk6.bold("\u25C6")} ${chalk6.bold(MESSAGES.STATUS_WORKTREES_SECTION)} (${total} \u4E2A)`);
   printInfo("");
   if (worktrees.length === 0) {
     printInfo(`    ${MESSAGES.STATUS_NO_WORKTREES}`);
@@ -1901,39 +2356,39 @@ function printWorktreesSection(worktrees, total) {
 }
 function printWorktreeItem(wt) {
   const statusLabel = formatChangeStatusLabel(wt.changeStatus);
-  printInfo(`  ${chalk5.bold("\u25CF")} ${chalk5.bold(wt.branch)}   [${statusLabel}]`);
+  printInfo(`  ${chalk6.bold("\u25CF")} ${chalk6.bold(wt.branch)}   [${statusLabel}]`);
   const parts = [];
   if (wt.insertions > 0 || wt.deletions > 0) {
-    parts.push(`${chalk5.green(`+${wt.insertions}`)} ${chalk5.red(`-${wt.deletions}`)}`);
+    parts.push(`${chalk6.green(`+${wt.insertions}`)} ${chalk6.red(`-${wt.deletions}`)}`);
   }
   if (wt.commitsAhead > 0) {
-    parts.push(chalk5.yellow(`${wt.commitsAhead} \u4E2A\u672C\u5730\u63D0\u4EA4`));
+    parts.push(chalk6.yellow(`${wt.commitsAhead} \u4E2A\u672C\u5730\u63D0\u4EA4`));
   }
   if (wt.commitsBehind > 0) {
-    parts.push(chalk5.yellow(`\u843D\u540E\u4E3B\u5206\u652F ${wt.commitsBehind} \u4E2A\u63D0\u4EA4`));
+    parts.push(chalk6.yellow(`\u843D\u540E\u4E3B\u5206\u652F ${wt.commitsBehind} \u4E2A\u63D0\u4EA4`));
   } else {
-    parts.push(chalk5.green("\u4E0E\u4E3B\u5206\u652F\u540C\u6B65"));
+    parts.push(chalk6.green("\u4E0E\u4E3B\u5206\u652F\u540C\u6B65"));
   }
   printInfo(`    ${parts.join("   ")}`);
   if (wt.hasSnapshot) {
-    printInfo(`    ${chalk5.blue("\u6709 validate \u5FEB\u7167")}`);
+    printInfo(`    ${chalk6.blue("\u6709 validate \u5FEB\u7167")}`);
   }
   printInfo("");
 }
 function formatChangeStatusLabel(status) {
   switch (status) {
     case "committed":
-      return chalk5.green(MESSAGES.STATUS_CHANGE_COMMITTED);
+      return chalk6.green(MESSAGES.STATUS_CHANGE_COMMITTED);
     case "uncommitted":
-      return chalk5.yellow(MESSAGES.STATUS_CHANGE_UNCOMMITTED);
+      return chalk6.yellow(MESSAGES.STATUS_CHANGE_UNCOMMITTED);
     case "conflict":
-      return chalk5.red(MESSAGES.STATUS_CHANGE_CONFLICT);
+      return chalk6.red(MESSAGES.STATUS_CHANGE_CONFLICT);
     case "clean":
-      return chalk5.gray(MESSAGES.STATUS_CHANGE_CLEAN);
+      return chalk6.gray(MESSAGES.STATUS_CHANGE_CLEAN);
   }
 }
 function printSnapshotsSection(snapshots) {
-  printInfo(`  ${chalk5.bold("\u25C6")} ${chalk5.bold(MESSAGES.STATUS_SNAPSHOTS_SECTION)} (${snapshots.length} \u4E2A)`);
+  printInfo(`  ${chalk6.bold("\u25C6")} ${chalk6.bold(MESSAGES.STATUS_SNAPSHOTS_SECTION)} (${snapshots.length} \u4E2A)`);
   printInfo("");
   if (snapshots.length === 0) {
     printInfo(`    ${MESSAGES.STATUS_NO_SNAPSHOTS}`);
@@ -1941,8 +2396,8 @@ function printSnapshotsSection(snapshots) {
     return;
   }
   for (const snap of snapshots) {
-    const orphanLabel = snap.worktreeExists ? "" : `  ${chalk5.yellow(MESSAGES.STATUS_SNAPSHOT_ORPHANED)}`;
-    const icon = snap.worktreeExists ? chalk5.blue("\u25CF") : chalk5.yellow("\u26A0");
+    const orphanLabel = snap.worktreeExists ? "" : `  ${chalk6.yellow(MESSAGES.STATUS_SNAPSHOT_ORPHANED)}`;
+    const icon = snap.worktreeExists ? chalk6.blue("\u25CF") : chalk6.yellow("\u26A0");
     printInfo(`  ${icon} ${snap.branch}${orphanLabel}`);
   }
   printInfo("");