clawt 3.10.4 → 3.10.6

package/dist/index.js

@@ -819,6 +819,33 @@ var VALIDATE_MESSAGES_I18N = {
     "zh-CN": (branch) => `\u53D8\u66F4\u8FC1\u79FB\u5931\u8D25\uFF1A\u76EE\u6807\u5206\u652F\u4E0E\u4E3B\u5206\u652F\u5DEE\u5F02\u8FC7\u5927
   \u8BF7\u5148\u6267\u884C clawt sync -b ${branch} \u540C\u6B65\u4E3B\u5206\u652F\u540E\u91CD\u8BD5`
   },
+  /** validate 检测到被 .gitignore 忽略的残留文件冲突 */
+  VALIDATE_IGNORED_FILES_CONFLICT: {
+    en: (files, cleanCommands) => {
+      const maxDisplay = 10;
+      const displayed = files.slice(0, maxDisplay).map((f) => `  - ${f}`).join("\n");
+      const more = files.length > maxDisplay ? `
+  ...(${files.length} files total)` : "";
+      const cmds = cleanCommands.map((c) => `  ${c}`).join("\n");
+      return `Ignored files left in main worktree are blocking patch apply:
+${displayed}${more}
+
+Please clean up manually and retry:
+${cmds}`;
+    },
+    "zh-CN": (files, cleanCommands) => {
+      const maxDisplay = 10;
+      const displayed = files.slice(0, maxDisplay).map((f) => `  - ${f}`).join("\n");
+      const more = files.length > maxDisplay ? `
+  ...\uFF08\u5171 ${files.length} \u4E2A\u6587\u4EF6\uFF09` : "";
+      const cmds = cleanCommands.map((c) => `  ${c}`).join("\n");
+      return `\u68C0\u6D4B\u5230\u88AB .gitignore \u5FFD\u7565\u7684\u6587\u4EF6\u6B8B\u7559\u5728\u4E3B worktree \u4E2D\uFF0C\u5BFC\u81F4\u53D8\u66F4\u65E0\u6CD5\u5E94\u7528\uFF1A
+${displayed}${more}
+
+\u8BF7\u624B\u52A8\u6E05\u7406\u540E\u91CD\u8BD5\uFF1A
+${cmds}`;
+    }
+  },
   /** validate 无可用 worktree */
   VALIDATE_NO_WORKTREES: {
     en: "No worktrees available, please create one with clawt run or clawt create first",
@@ -2817,6 +2844,19 @@ function gitMergeContinue(cwd) {
 function buildAutoSaveCommitMessage(mainBranch, branch) {
   return `${AUTO_SAVE_COMMIT_MESSAGE_PREFIX} ${mainBranch} into ${branch}`;
 }
+function gitCheckIgnored(paths, cwd) {
+  if (paths.length === 0) return [];
+  try {
+    const output = execFileSync2("git", ["check-ignore", "--", ...paths], {
+      cwd,
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    return output.trim().split("\n").filter(Boolean);
+  } catch {
+    return [];
+  }
+}
 
 // src/utils/git-branch.ts
 function checkBranchExists(branchName, cwd) {
@@ -3027,6 +3067,16 @@ function formatLocalISOString(date) {
   const minutes = String(absMinutes % 60).padStart(2, "0");
   return `${iso}${sign}${hours}:${minutes}`;
 }
+function formatBaseBranchLine(baseBranch) {
+  const lang = getCurrentLanguage();
+  const label = lang === "en" ? "Base branch" : "\u6765\u6E90\u5206\u652F";
+  const fallback = lang === "en" ? "Not recorded" : "\u672A\u8BB0\u5F55";
+  return `${label}: ${baseBranch ?? fallback}`;
+}
+function formatBaseBranchInline(baseBranch) {
+  const fallback = getCurrentLanguage() === "en" ? "Not recorded" : "\u672A\u8BB0\u5F55";
+  return `<- ${baseBranch ?? fallback}`;
+}
 function generateTaskFilename(prefix) {
   const now = /* @__PURE__ */ new Date();
   const pad = (n) => String(n).padStart(2, "0");
@@ -3355,45 +3405,100 @@ async function runPreChecks(options) {
 }
 
 // src/utils/worktree.ts
-import { join as join5 } from "path";
-import { existsSync as existsSync5, readdirSync as readdirSync2 } from "fs";
+import { join as join6 } from "path";
+import { existsSync as existsSync6, readdirSync as readdirSync2 } from "fs";
+
+// src/utils/worktree-metadata.ts
+import { existsSync as existsSync5, readFileSync as readFileSync3, rmSync, writeFileSync as writeFileSync3 } from "fs";
+import { dirname, join as join5 } from "path";
+function getWorktreeMetadataPath(projectName, branchName) {
+  return join5(PROJECTS_CONFIG_DIR, projectName, "worktrees", `${branchName}.json`);
+}
+function saveWorktreeMetadata(projectName, metadata) {
+  const metadataPath = getWorktreeMetadataPath(projectName, metadata.branch);
+  const metadataDir = dirname(metadataPath);
+  try {
+    ensureDir(metadataDir);
+    writeFileSync3(metadataPath, safeStringify(metadata), "utf-8");
+  } catch (error) {
+    logger.error(`\u4FDD\u5B58 worktree \u5143\u6570\u636E\u5931\u8D25: ${metadataPath}`, error);
+    throw error;
+  }
+}
+function loadWorktreeMetadata(projectName, branchName) {
+  const metadataPath = getWorktreeMetadataPath(projectName, branchName);
+  if (!existsSync5(metadataPath)) {
+    return null;
+  }
+  try {
+    const content = readFileSync3(metadataPath, "utf-8");
+    const parsed = JSON.parse(content);
+    if (!parsed || typeof parsed !== "object" || !parsed.branch || !parsed.baseBranch) {
+      logger.warn(`worktree \u5143\u6570\u636E\u683C\u5F0F\u65E0\u6548: ${metadataPath}`);
+      return null;
+    }
+    return parsed;
+  } catch (error) {
+    logger.warn(`\u89E3\u6790 worktree \u5143\u6570\u636E\u5931\u8D25: ${metadataPath}`, error);
+    return null;
+  }
+}
+function removeWorktreeMetadata(projectName, branchName) {
+  const metadataPath = getWorktreeMetadataPath(projectName, branchName);
+  try {
+    if (existsSync5(metadataPath)) {
+      rmSync(metadataPath);
+    }
+  } catch (error) {
+    logger.error(`\u5220\u9664 worktree \u5143\u6570\u636E\u5931\u8D25: ${metadataPath}`, error);
+  }
+}
+
+// src/utils/worktree.ts
 function getProjectWorktreeDir() {
   const projectName = getProjectName();
-  return join5(WORKTREES_DIR, projectName);
+  return join6(WORKTREES_DIR, projectName);
 }
 function createWorktrees(branchName, count) {
   const sanitized = sanitizeBranchName(branchName);
   const branchNames = generateBranchNames(sanitized, count);
   validateBranchesNotExist(branchNames);
-  const projectDir = getProjectWorktreeDir();
+  const projectName = getProjectName();
+  const projectDir = join6(WORKTREES_DIR, projectName);
   ensureDir(projectDir);
+  const baseBranch = getCurrentBranch();
   const results = [];
   for (const name of branchNames) {
-    const worktreePath = join5(projectDir, name);
+    const worktreePath = join6(projectDir, name);
     createWorktree(name, worktreePath);
     createValidateBranch(name);
-    results.push({ path: worktreePath, branch: name });
+    saveWorktreeMetadata(projectName, { branch: name, baseBranch, createdAt: (/* @__PURE__ */ new Date()).toISOString() });
+    results.push({ path: worktreePath, branch: name, baseBranch });
     logger.info(`worktree \u521B\u5EFA\u5B8C\u6210: ${worktreePath} (\u5206\u652F: ${name})`);
   }
   return results;
 }
 function createWorktreesByBranches(branchNames) {
   validateBranchesNotExist(branchNames);
-  const projectDir = getProjectWorktreeDir();
+  const projectName = getProjectName();
+  const projectDir = join6(WORKTREES_DIR, projectName);
   ensureDir(projectDir);
+  const baseBranch = getCurrentBranch();
   const results = [];
   for (const name of branchNames) {
-    const worktreePath = join5(projectDir, name);
+    const worktreePath = join6(projectDir, name);
     createWorktree(name, worktreePath);
     createValidateBranch(name);
-    results.push({ path: worktreePath, branch: name });
+    saveWorktreeMetadata(projectName, { branch: name, baseBranch, createdAt: (/* @__PURE__ */ new Date()).toISOString() });
+    results.push({ path: worktreePath, branch: name, baseBranch });
     logger.info(`worktree \u521B\u5EFA\u5B8C\u6210: ${worktreePath} (\u5206\u652F: ${name})`);
   }
   return results;
 }
 function getProjectWorktrees() {
-  const projectDir = getProjectWorktreeDir();
-  if (!existsSync5(projectDir)) {
+  const projectName = getProjectName();
+  const projectDir = join6(WORKTREES_DIR, projectName);
+  if (!existsSync6(projectDir)) {
     return [];
   }
   const worktreeListOutput = gitWorktreeList();
@@ -3406,29 +3511,33 @@ function getProjectWorktrees() {
     if (!entry.isDirectory()) {
       continue;
     }
-    const fullPath = join5(projectDir, entry.name);
+    const fullPath = join6(projectDir, entry.name);
     if (registeredPaths.has(fullPath)) {
+      const metadata = loadWorktreeMetadata(projectName, entry.name);
       worktrees.push({
         path: fullPath,
-        branch: entry.name
+        branch: entry.name,
+        baseBranch: metadata?.baseBranch ?? null
       });
     }
   }
   return worktrees;
 }
 function cleanupWorktrees(worktrees) {
+  const projectName = getProjectName();
   for (const wt of worktrees) {
     try {
       removeWorktreeByPath(wt.path);
       deleteBranch(wt.branch);
       deleteValidateBranch(wt.branch);
+      removeWorktreeMetadata(projectName, 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}`);
     }
   }
   gitWorktreePrune();
-  const projectDir = getProjectWorktreeDir();
+  const projectDir = join6(WORKTREES_DIR, projectName);
   removeEmptyDir(projectDir);
 }
 function getWorktreeStatus(worktree) {
@@ -3445,7 +3554,7 @@ function getWorktreeStatus(worktree) {
 
 // src/utils/symlink-guard.ts
 import { readdirSync as readdirSync3, lstatSync, unlinkSync, readlinkSync } from "fs";
-import { join as join6, relative, isAbsolute as isAbsolute2, resolve } from "path";
+import { join as join7, relative, isAbsolute as isAbsolute2, resolve } from "path";
 function isExternalSymlink(linkPath, worktreeRoot) {
   try {
     const target = readlinkSync(linkPath);
@@ -3462,7 +3571,7 @@ function removeExternalSymlinks(dir) {
     const entries = readdirSync3(dir, { withFileTypes: true });
     for (const entry of entries) {
       if (!entry.isSymbolicLink()) continue;
-      const fullPath = join6(dir, entry.name);
+      const fullPath = join7(dir, entry.name);
       if (!isExternalSymlink(fullPath, dir)) continue;
       try {
         const stat = lstatSync(fullPath);
@@ -3497,14 +3606,14 @@ async function promptCommitMessage(promptMessage, nonInteractiveErrorMessage) {
 
 // src/utils/claude.ts
 import { spawnSync as spawnSync3 } from "child_process";
-import { existsSync as existsSync7, readdirSync as readdirSync4 } from "fs";
-import { join as join7 } from "path";
+import { existsSync as existsSync8, readdirSync as readdirSync4 } from "fs";
+import { join as join8 } from "path";
 
 // src/utils/terminal.ts
 import { execFileSync as execFileSync3 } from "child_process";
-import { existsSync as existsSync6 } from "fs";
+import { existsSync as existsSync7 } from "fs";
 function isITerm2Installed() {
-  return existsSync6(ITERM2_APP_PATH);
+  return existsSync7(ITERM2_APP_PATH);
 }
 function isCmuxEnvironment() {
   return !!process.env.CMUX_WORKSPACE_ID;
@@ -3642,8 +3751,8 @@ function encodeClaudeProjectPath(absolutePath) {
 }
 function hasClaudeSessionHistory(worktreePath) {
   const encodedName = encodeClaudeProjectPath(worktreePath);
-  const projectDir = join7(CLAUDE_PROJECTS_DIR, encodedName);
-  if (!existsSync7(projectDir)) {
+  const projectDir = join8(CLAUDE_PROJECTS_DIR, encodedName);
+  if (!existsSync8(projectDir)) {
     return false;
   }
   const entries = readdirSync4(projectDir);
@@ -3696,23 +3805,23 @@ function launchInteractiveClaudeInNewTerminal(worktree, hasPreviousSession) {
 }
 
 // src/utils/validate-snapshot.ts
-import { join as join8 } from "path";
-import { existsSync as existsSync8, readFileSync as readFileSync3, writeFileSync as writeFileSync3, unlinkSync as unlinkSync2, readdirSync as readdirSync5, rmdirSync as rmdirSync2, statSync as statSync2 } from "fs";
+import { join as join9 } from "path";
+import { existsSync as existsSync9, readFileSync as readFileSync4, writeFileSync as writeFileSync4, unlinkSync as unlinkSync2, readdirSync as readdirSync5, rmdirSync as rmdirSync2, statSync as statSync2 } from "fs";
 function getSnapshotPath(projectName, branchName) {
-  return join8(VALIDATE_SNAPSHOTS_DIR, projectName, `${branchName}.tree`);
+  return join9(VALIDATE_SNAPSHOTS_DIR, projectName, `${branchName}.tree`);
 }
 function getSnapshotHeadPath(projectName, branchName) {
-  return join8(VALIDATE_SNAPSHOTS_DIR, projectName, `${branchName}.head`);
+  return join9(VALIDATE_SNAPSHOTS_DIR, projectName, `${branchName}.head`);
 }
 function getSnapshotStagedPath(projectName, branchName) {
-  return join8(VALIDATE_SNAPSHOTS_DIR, projectName, `${branchName}.staged`);
+  return join9(VALIDATE_SNAPSHOTS_DIR, projectName, `${branchName}.staged`);
 }
 function hasSnapshot(projectName, branchName) {
-  return existsSync8(getSnapshotPath(projectName, branchName));
+  return existsSync9(getSnapshotPath(projectName, branchName));
 }
 function getSnapshotModifiedTime(projectName, branchName) {
   const snapshotPath = getSnapshotPath(projectName, branchName);
-  if (!existsSync8(snapshotPath)) return null;
+  if (!existsSync9(snapshotPath)) return null;
   const stat = statSync2(snapshotPath);
   return stat.mtime.toISOString();
 }
@@ -3721,22 +3830,22 @@ function readSnapshot(projectName, branchName) {
   const headPath = getSnapshotHeadPath(projectName, branchName);
   const stagedPath = getSnapshotStagedPath(projectName, branchName);
   logger.debug(`\u8BFB\u53D6 validate \u5FEB\u7167: ${snapshotPath}`);
-  const treeHash = existsSync8(snapshotPath) ? readFileSync3(snapshotPath, "utf-8").trim() : "";
-  const headCommitHash = existsSync8(headPath) ? readFileSync3(headPath, "utf-8").trim() : "";
-  const stagedTreeHash = existsSync8(stagedPath) ? readFileSync3(stagedPath, "utf-8").trim() : "";
+  const treeHash = existsSync9(snapshotPath) ? readFileSync4(snapshotPath, "utf-8").trim() : "";
+  const headCommitHash = existsSync9(headPath) ? readFileSync4(headPath, "utf-8").trim() : "";
+  const stagedTreeHash = existsSync9(stagedPath) ? readFileSync4(stagedPath, "utf-8").trim() : "";
   return { treeHash, headCommitHash, stagedTreeHash };
 }
 function writeSnapshot(projectName, branchName, treeHash, headCommitHash, stagedTreeHash) {
-  const snapshotDir = join8(VALIDATE_SNAPSHOTS_DIR, projectName);
+  const snapshotDir = join9(VALIDATE_SNAPSHOTS_DIR, projectName);
   ensureDir(snapshotDir);
   if (treeHash !== void 0) {
-    writeFileSync3(getSnapshotPath(projectName, branchName), treeHash, "utf-8");
+    writeFileSync4(getSnapshotPath(projectName, branchName), treeHash, "utf-8");
   }
   if (headCommitHash !== void 0) {
-    writeFileSync3(getSnapshotHeadPath(projectName, branchName), headCommitHash, "utf-8");
+    writeFileSync4(getSnapshotHeadPath(projectName, branchName), headCommitHash, "utf-8");
   }
   if (stagedTreeHash !== void 0) {
-    writeFileSync3(getSnapshotStagedPath(projectName, branchName), stagedTreeHash, "utf-8");
+    writeFileSync4(getSnapshotStagedPath(projectName, branchName), stagedTreeHash, "utf-8");
   }
   logger.info(`\u5DF2\u5199\u5165 validate \u5FEB\u7167 (project=${projectName}, branch=${branchName})`);
 }
@@ -3744,35 +3853,35 @@ function removeSnapshot(projectName, branchName) {
   const snapshotPath = getSnapshotPath(projectName, branchName);
   const headPath = getSnapshotHeadPath(projectName, branchName);
   const stagedPath = getSnapshotStagedPath(projectName, branchName);
-  if (existsSync8(snapshotPath)) {
+  if (existsSync9(snapshotPath)) {
     unlinkSync2(snapshotPath);
     logger.info(`\u5DF2\u5220\u9664 validate \u5FEB\u7167: ${snapshotPath}`);
   }
-  if (existsSync8(headPath)) {
+  if (existsSync9(headPath)) {
     unlinkSync2(headPath);
     logger.info(`\u5DF2\u5220\u9664 validate \u5FEB\u7167: ${headPath}`);
   }
-  if (existsSync8(stagedPath)) {
+  if (existsSync9(stagedPath)) {
     unlinkSync2(stagedPath);
     logger.info(`\u5DF2\u5220\u9664 validate \u5FEB\u7167: ${stagedPath}`);
   }
 }
 function getProjectSnapshotBranches(projectName) {
-  const projectDir = join8(VALIDATE_SNAPSHOTS_DIR, projectName);
-  if (!existsSync8(projectDir)) {
+  const projectDir = join9(VALIDATE_SNAPSHOTS_DIR, projectName);
+  if (!existsSync9(projectDir)) {
     return [];
   }
   const files = readdirSync5(projectDir);
   return files.filter((f) => f.endsWith(".tree")).map((f) => f.replace(/\.tree$/, ""));
 }
 function removeProjectSnapshots(projectName) {
-  const projectDir = join8(VALIDATE_SNAPSHOTS_DIR, projectName);
-  if (!existsSync8(projectDir)) {
+  const projectDir = join9(VALIDATE_SNAPSHOTS_DIR, projectName);
+  if (!existsSync9(projectDir)) {
     return;
   }
   const files = readdirSync5(projectDir);
   for (const file of files) {
-    unlinkSync2(join8(projectDir, file));
+    unlinkSync2(join9(projectDir, file));
   }
   try {
     rmdirSync2(projectDir);
@@ -4303,7 +4412,7 @@ var ProgressRenderer = class {
 
 // src/utils/task-file.ts
 import { resolve as resolve2 } from "path";
-import { existsSync as existsSync9, readFileSync as readFileSync4 } from "fs";
+import { existsSync as existsSync10, readFileSync as readFileSync5 } 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 = getCurrentLanguage() === "en" ? "Task list cannot be empty" : "\u4EFB\u52A1\u5217\u8868\u4E0D\u80FD\u4E3A\u7A7A";
@@ -4349,10 +4458,10 @@ function parseTaskFile(content, options) {
 }
 function loadTaskFile(filePath, options) {
   const absolutePath = resolve2(filePath);
-  if (!existsSync9(absolutePath)) {
+  if (!existsSync10(absolutePath)) {
     throw new ClawtError(MESSAGES.TASK_FILE_NOT_FOUND(absolutePath));
   }
-  const content = readFileSync4(absolutePath, "utf-8");
+  const content = readFileSync5(absolutePath, "utf-8");
   const entries = parseTaskFile(content, options);
   if (entries.length === 0) {
     throw new ClawtError(MESSAGES.TASK_FILE_EMPTY);
@@ -4697,7 +4806,7 @@ async function executeBatchTasks(worktrees, tasks, concurrency, continueFlags) {
 
 // src/utils/dry-run.ts
 import chalk6 from "chalk";
-import { join as join9 } from "path";
+import { join as join10 } from "path";
 var DRY_RUN_TASK_DESC_MAX_LENGTH = 80;
 function truncateTaskDesc(task) {
   const oneLine = task.replace(/\n/g, " ").trim();
@@ -4725,7 +4834,7 @@ function printDryRunPreview(branchNames, tasks, concurrency) {
   let hasConflict = false;
   for (let i = 0; i < branchNames.length; i++) {
     const branch = branchNames[i];
-    const worktreePath = join9(projectDir, branch);
+    const worktreePath = join10(projectDir, branch);
     const exists = checkBranchExists(branch);
     if (exists) hasConflict = true;
     const indexLabel = `[${i + 1}/${branchNames.length}]`;
@@ -4880,14 +4989,14 @@ async function promptStringValue(key, currentValue) {
 }
 
 // src/utils/update-checker.ts
-import { readFileSync as readFileSync5, writeFileSync as writeFileSync4 } from "fs";
+import { readFileSync as readFileSync6, writeFileSync as writeFileSync5 } from "fs";
 import { execSync as execSync4 } from "child_process";
 import { request } from "https";
 import chalk8 from "chalk";
 import stringWidth2 from "string-width";
 function readUpdateCache() {
   try {
-    const raw = readFileSync5(UPDATE_CHECK_PATH, "utf-8");
+    const raw = readFileSync6(UPDATE_CHECK_PATH, "utf-8");
     return JSON.parse(raw);
   } catch {
     return null;
@@ -4895,7 +5004,7 @@ function readUpdateCache() {
 }
 function writeUpdateCache(cache) {
   try {
-    writeFileSync4(UPDATE_CHECK_PATH, JSON.stringify(cache, null, 2), "utf-8");
+    writeFileSync5(UPDATE_CHECK_PATH, JSON.stringify(cache, null, 2), "utf-8");
   } catch {
   }
 }
@@ -5093,6 +5202,17 @@ async function executeRunCommand(command, mainWorktreePath) {
 }
 
 // src/utils/validate-core.ts
+import { existsSync as existsSync11 } from "fs";
+import { join as join11 } from "path";
+function buildCleanCommands(files) {
+  const dirs = /* @__PURE__ */ new Set();
+  for (const file of files) {
+    const lastSlash = file.lastIndexOf("/");
+    const dir = lastSlash > 0 ? file.substring(0, lastSlash) : ".";
+    dirs.add(dir);
+  }
+  return Array.from(dirs).map((dir) => `git clean -fdx ${dir}/`);
+}
 function migrateChangesViaPatch(targetWorktreePath, mainWorktreePath, branchName, hasUncommitted) {
   let didTempCommit = false;
   try {
@@ -5101,6 +5221,13 @@ function migrateChangesViaPatch(targetWorktreePath, mainWorktreePath, branchName
       gitCommit("clawt:temp-commit-for-validate", targetWorktreePath);
       didTempCommit = true;
     }
+    const ignoredFiles = detectIgnoredFilesInPatch(branchName, mainWorktreePath);
+    if (ignoredFiles.length > 0) {
+      const cleanCommands = buildCleanCommands(ignoredFiles);
+      logger.warn(`\u68C0\u6D4B\u5230 ${ignoredFiles.length} \u4E2A\u88AB\u5FFD\u7565\u7684\u6B8B\u7559\u6587\u4EF6\u51B2\u7A81`);
+      printWarning(MESSAGES.VALIDATE_IGNORED_FILES_CONFLICT(ignoredFiles, cleanCommands));
+      return { success: false };
+    }
     const patch = gitDiffBinaryAgainstBranch(branchName, mainWorktreePath);
     if (patch.length > 0) {
       try {
@@ -5175,6 +5302,16 @@ function switchToValidateBranch(branchName, mainWorktreePath) {
   }
   return validateBranchName;
 }
+function detectIgnoredFilesInPatch(branchName, mainWorktreePath) {
+  try {
+    const output = execCommand(`git diff --name-only HEAD...${branchName}`, { cwd: mainWorktreePath });
+    const patchFiles = output.split("\n").filter(Boolean);
+    if (patchFiles.length === 0) return [];
+    return gitCheckIgnored(patchFiles, mainWorktreePath).filter((file) => existsSync11(join11(mainWorktreePath, file)));
+  } catch {
+    return [];
+  }
+}
 
 // src/utils/interactive-panel.ts
 import { createInterface as createInterface2 } from "readline";
@@ -5218,7 +5355,7 @@ function buildPanelFrame(statusResult, selectedIndex, scrollOffset, rows, cols,
   return lines;
 }
 function buildDisplayOrder(worktrees) {
-  const worktreeInfos = worktrees.map((wt) => ({ path: wt.path, branch: wt.branch }));
+  const worktreeInfos = worktrees.map((wt) => ({ path: wt.path, branch: wt.branch, baseBranch: wt.baseBranch }));
   const groups = groupWorktreesByDate(worktreeInfos);
   const branchIndexMap = /* @__PURE__ */ new Map();
   for (let i = 0; i < worktrees.length; i++) {
@@ -5234,7 +5371,7 @@ function buildDisplayOrder(worktrees) {
 }
 function buildGroupedWorktreeLines(worktrees, selectedIndex) {
   const panelLines = [];
-  const worktreeInfos = worktrees.map((wt) => ({ path: wt.path, branch: wt.branch }));
+  const worktreeInfos = worktrees.map((wt) => ({ path: wt.path, branch: wt.branch, baseBranch: wt.baseBranch }));
   const groups = groupWorktreesByDate(worktreeInfos);
   const branchIndexMap = /* @__PURE__ */ new Map();
   for (let i = 0; i < worktrees.length; i++) {
@@ -5292,6 +5429,7 @@ function renderWorktreeBlock(wt, isSelected) {
   } else {
     lines.push(`${indent}${chalk9.green(PANEL_SYNCED_WITH_MAIN)}`);
   }
+  lines.push(`${indent}${chalk9.gray(formatBaseBranchLine(wt.baseBranch))}`);
   if (wt.createdAt) {
     const relativeTime = formatRelativeTime(wt.createdAt);
     if (relativeTime) {
@@ -5967,9 +6105,9 @@ async function handleMergeConflict(currentBranch, incomingBranch, cwd, autoFlag)
 }
 
 // src/hooks/post-create.ts
-import { existsSync as existsSync10, accessSync, chmodSync, constants as fsConstants } from "fs";
+import { existsSync as existsSync12, accessSync, chmodSync, constants as fsConstants } from "fs";
 import { spawn as spawn2 } from "child_process";
-import { join as join10 } from "path";
+import { join as join12 } from "path";
 var POST_CREATE_SCRIPT_RELATIVE_PATH = ".clawt/postCreate.sh";
 function isExecutable(filePath) {
   try {
@@ -6001,8 +6139,8 @@ function resolvePostCreateHook() {
     }
   }
   const mainWorktreePath = getMainWorktreePath();
-  const scriptPath = join10(mainWorktreePath, POST_CREATE_SCRIPT_RELATIVE_PATH);
-  if (existsSync10(scriptPath)) {
+  const scriptPath = join12(mainWorktreePath, POST_CREATE_SCRIPT_RELATIVE_PATH);
+  if (existsSync12(scriptPath)) {
     if (!isExecutable(scriptPath)) {
       autoFixExecutablePermission(scriptPath);
     }
@@ -6101,7 +6239,8 @@ function printListAsJson(projectName, worktrees) {
     total: worktrees.length,
     worktrees: worktrees.map((wt) => ({
       path: wt.path,
-      branch: wt.branch
+      branch: wt.branch,
+      baseBranch: wt.baseBranch
     }))
   };
   console.log(JSON.stringify(result, null, 2));
@@ -6117,7 +6256,7 @@ function printListAsText(projectName, worktrees) {
       const status = getWorktreeStatus(wt);
       const isIdle = status ? isWorktreeIdle(status) : false;
       const pathDisplay = isIdle ? chalk10.hex("#FF8C00")(wt.path) : wt.path;
-      printInfo(`  ${pathDisplay}   [${wt.branch}]`);
+      printInfo(`  ${pathDisplay}   [${wt.branch}]   ${formatBaseBranchInline(wt.baseBranch)}`);
       if (status) {
         printInfo(`    ${formatWorktreeStatus(status)}`);
       } else {
@@ -6217,6 +6356,7 @@ async function handleRemove(options) {
       }
       deleteValidateBranch(wt.branch);
       removeSnapshot(projectName, wt.branch);
+      removeWorktreeMetadata(projectName, wt.branch);
       printSuccess(MESSAGES.WORKTREE_REMOVED(wt.path));
     } catch (error) {
       const errorMessage = error instanceof Error ? error.message : String(error);
@@ -6757,7 +6897,7 @@ async function shouldCleanupAfterMerge(branchName) {
   return confirmAction(MESSAGES.CONFIRM_DELETE_WORKTREE_BRANCH(branchName), true);
 }
 function cleanupWorktreeAndBranch(worktreePath, branchName) {
-  cleanupWorktrees([{ path: worktreePath, branch: branchName }]);
+  cleanupWorktrees([{ path: worktreePath, branch: branchName, baseBranch: null }]);
   printSuccess(MESSAGES.WORKTREE_CLEANED(branchName));
 }
 async function handleMerge(options) {
@@ -7032,7 +7172,8 @@ async function collectWorktreeDetailedStatusAsync(worktree, projectName) {
     snapshotTime: resolveSnapshotTime(projectName, worktree.branch),
     insertions: diffStat.insertions,
     deletions: diffStat.deletions,
-    createdAt
+    createdAt,
+    baseBranch: worktree.baseBranch
   };
 }
 function detectChangeStatusFromPorcelain(porcelain, commitsAhead) {
@@ -7157,6 +7298,7 @@ function printWorktreeItem(wt) {
   } else {
     printInfo(`    ${chalk11.green(lang === "en" ? "In sync with main" : "\u4E0E\u4E3B\u5206\u652F\u540C\u6B65")}`);
   }
+  printInfo(`    ${chalk11.gray(formatBaseBranchLine(wt.baseBranch))}`);
   if (wt.createdAt) {
     const relativeTime = formatRelativeTime(wt.createdAt);
     if (relativeTime) {
@@ -7263,8 +7405,8 @@ function registerAliasCommand(program2) {
 }
 
 // src/commands/projects.ts
-import { existsSync as existsSync11, readdirSync as readdirSync6, statSync as statSync4 } from "fs";
-import { join as join11 } from "path";
+import { existsSync as existsSync13, readdirSync as readdirSync6, statSync as statSync4 } from "fs";
+import { join as join13 } from "path";
 import chalk13 from "chalk";
 function registerProjectsCommand(program2) {
   program2.command("projects [name]").description(getCurrentLanguage() === "en" ? "Show worktree overview across projects, or view details for a specific project" : "\u5C55\u793A\u6240\u6709\u9879\u76EE\u7684 worktree \u6982\u89C8\uFF0C\u6216\u67E5\u770B\u6307\u5B9A\u9879\u76EE\u7684 worktree \u8BE6\u60C5").option("--json", getCurrentLanguage() === "en" ? "Output in JSON format" : "\u4EE5 JSON \u683C\u5F0F\u8F93\u51FA").action((name, options) => {
@@ -7288,8 +7430,8 @@ function handleProjectsOverview(json) {
   printProjectsOverviewAsText(result);
 }
 function handleProjectDetail(name, json) {
-  const projectDir = join11(WORKTREES_DIR, name);
-  if (!existsSync11(projectDir)) {
+  const projectDir = join13(WORKTREES_DIR, name);
+  if (!existsSync13(projectDir)) {
     printError(MESSAGES.PROJECTS_NOT_FOUND(name));
     process.exit(1);
   }
@@ -7302,7 +7444,7 @@ function handleProjectDetail(name, json) {
   printProjectDetailAsText(result);
 }
 function collectProjectsOverview() {
-  if (!existsSync11(WORKTREES_DIR)) {
+  if (!existsSync13(WORKTREES_DIR)) {
     return { projects: [], totalProjects: 0, totalDiskUsage: 0 };
   }
   const entries = readdirSync6(WORKTREES_DIR, { withFileTypes: true });
@@ -7311,7 +7453,7 @@ function collectProjectsOverview() {
     if (!entry.isDirectory()) {
       continue;
     }
-    const projectDir = join11(WORKTREES_DIR, entry.name);
+    const projectDir = join13(WORKTREES_DIR, entry.name);
     const overview = collectSingleProjectOverview(entry.name, projectDir);
     projects.push(overview);
   }
@@ -7328,7 +7470,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) => join11(projectDir, e.name)));
+  const lastActiveTime = resolveProjectLastActiveTime(projectDir, worktreeDirs.map((e) => join13(projectDir, e.name)));
   return {
     name,
     worktreeCount,
@@ -7343,7 +7485,7 @@ function collectProjectDetail(name, projectDir) {
     if (!entry.isDirectory()) {
       continue;
     }
-    const wtPath = join11(projectDir, entry.name);
+    const wtPath = join13(projectDir, entry.name);
     const detail = collectSingleWorktreeDetail(entry.name, wtPath);
     worktrees.push(detail);
   }
@@ -7443,7 +7585,7 @@ function printWorktreeDetailItem(wt) {
 }
 
 // src/commands/completion.ts
-import { readFileSync as readFileSync6, writeFileSync as writeFileSync5, existsSync as existsSync13 } from "fs";
+import { readFileSync as readFileSync7, writeFileSync as writeFileSync6, existsSync as existsSync15 } from "fs";
 import { resolve as resolve3 } from "path";
 import { homedir as homedir2 } from "os";
 
@@ -7494,23 +7636,23 @@ compdef _clawt_completion clawt
 }
 
 // src/utils/completion-engine.ts
-import { existsSync as existsSync12, readdirSync as readdirSync7, statSync as statSync5 } from "fs";
-import { join as join12, dirname, basename as basename2 } from "path";
+import { existsSync as existsSync14, readdirSync as readdirSync7, statSync as statSync5 } from "fs";
+import { join as join14, dirname as dirname2, basename as basename2 } from "path";
 function completeFilePath(partial) {
   const cwd = process.cwd();
   const hasDir = partial.includes("/");
-  const searchDir = hasDir ? join12(cwd, dirname(partial)) : cwd;
+  const searchDir = hasDir ? join14(cwd, dirname2(partial)) : cwd;
   const prefix = hasDir ? basename2(partial) : partial;
-  if (!existsSync12(searchDir)) {
+  if (!existsSync14(searchDir)) {
     return [];
   }
   const entries = readdirSync7(searchDir);
   const results = [];
-  const dirPrefix = hasDir ? dirname(partial) + "/" : "";
+  const dirPrefix = hasDir ? dirname2(partial) + "/" : "";
   for (const entry of entries) {
     if (!entry.startsWith(prefix)) continue;
     if (entry.startsWith(".")) continue;
-    const fullPath = join12(searchDir, entry);
+    const fullPath = join14(searchDir, entry);
     try {
       const stat = statSync5(fullPath);
       if (stat.isDirectory()) {
@@ -7599,15 +7741,15 @@ function generateCompletions(program2, args) {
 
 // src/commands/completion.ts
 function appendToFile(filePath, content) {
-  if (existsSync13(filePath)) {
-    const current = readFileSync6(filePath, "utf-8");
+  if (existsSync15(filePath)) {
+    const current = readFileSync7(filePath, "utf-8");
     if (current.includes("clawt completion")) {
       printInfo(MESSAGES.COMPLETION_INSTALL_EXISTS + ": " + filePath);
       return;
     }
     content = current + content;
   }
-  writeFileSync5(filePath, content, "utf-8");
+  writeFileSync6(filePath, content, "utf-8");
   printSuccess(MESSAGES.COMPLETION_INSTALL_SUCCESS + ": " + filePath);
   printInfo(MESSAGES.COMPLETION_INSTALL_RESTART(filePath));
 }
@@ -7739,23 +7881,23 @@ async function handleHome() {
 }
 
 // src/commands/tasks.ts
-import { resolve as resolve4, dirname as dirname2, join as join13 } from "path";
-import { existsSync as existsSync14, writeFileSync as writeFileSync6 } from "fs";
+import { resolve as resolve4, dirname as dirname3, join as join15 } from "path";
+import { existsSync as existsSync16, writeFileSync as writeFileSync7 } from "fs";
 function registerTasksCommand(program2) {
   const taskCmd = program2.command("tasks").description(getCurrentLanguage() === "en" ? "Task file management" : "\u4EFB\u52A1\u6587\u4EF6\u7BA1\u7406");
   taskCmd.command("init").description(getCurrentLanguage() === "en" ? "Generate task template file" : "\u751F\u6210\u4EFB\u52A1\u6A21\u677F\u6587\u4EF6").argument("[path]", getCurrentLanguage() === "en" ? "Output file path" : "\u8F93\u51FA\u6587\u4EF6\u8DEF\u5F84").action(async (path2) => {
-    const filePath = path2 ?? join13(TASK_TEMPLATE_OUTPUT_DIR, generateTaskFilename(TASK_TEMPLATE_FILENAME_PREFIX));
+    const filePath = path2 ?? join15(TASK_TEMPLATE_OUTPUT_DIR, generateTaskFilename(TASK_TEMPLATE_FILENAME_PREFIX));
     await handleTasksInit(filePath);
   });
 }
 async function handleTasksInit(filePath) {
   const absolutePath = resolve4(filePath);
   logger.info(`tasks init \u547D\u4EE4\u6267\u884C\uFF0C\u76EE\u6807\u6587\u4EF6: ${absolutePath}`);
-  if (existsSync14(absolutePath)) {
+  if (existsSync16(absolutePath)) {
     throw new ClawtError(MESSAGES.TASK_INIT_FILE_EXISTS(filePath));
   }
-  ensureDir(dirname2(absolutePath));
-  writeFileSync6(absolutePath, getTaskTemplateContent(), "utf-8");
+  ensureDir(dirname3(absolutePath));
+  writeFileSync7(absolutePath, getTaskTemplateContent(), "utf-8");
   printSuccess(MESSAGES.TASK_INIT_SUCCESS(filePath));
   printHint(MESSAGES.TASK_INIT_HINT(filePath));
 }