clawt 3.10.5 → 3.10.6

package/AGENTS.md

@@ -0,0 +1,16 @@
+# Project Memory
+
+## 代码阅读规范（必须严格遵守的三步阅读流程）
+
+每次接到任务时，**必须**按以下顺序渐进式地理解项目，禁止跳步：
+
+1. **第一步：阅读 `docs/spec.md`** — 全面了解项目整体架构、核心概念与模块划分，建立全局认知。
+2. **第二步：根据用户问题，阅读 `docs/` 下对应模块的详细文档** — 例如用户问 merge 相关功能，则阅读 `docs/merge.md`；问 config 相关则阅读 `docs/config.md` 和 `docs/config-file.md`，以此类推。
+3. **第三步：阅读具体的源代码** — 在前两步建立充分上下文后，再深入代码实现，确保方案设计不会因阅读代码不全面而产生缺陷。
+
+>  **重要提示：文档可能滞后于代码。当文档描述与实际代码实现存在冲突时，以代码为准。**
+
+## 编码规范
+
+- JSON 序列化必须使用项目封装的 `safeStringify`（位于 `src/utils/json.ts`），禁止直接使用原生 `JSON.stringify`。`safeStringify` 已通过 `src/utils/index.js` 统一导出。
+- 构造输出对象时，使用 `{ ...obj }` 解构展开而非逐字段列举，避免源类型新增字段后遗漏。

package/dist/index.js

@@ -3067,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");
@@ -3395,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();
@@ -3446,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) {
@@ -3485,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);
@@ -3502,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);
@@ -3537,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;
@@ -3682,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);
@@ -3736,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();
 }
@@ -3761,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})`);
 }
@@ -3784,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);
@@ -4343,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";
@@ -4389,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);
@@ -4737,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();
@@ -4765,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}]`;
@@ -4920,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;
@@ -4935,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 {
   }
 }
@@ -5133,8 +5202,8 @@ async function executeRunCommand(command, mainWorktreePath) {
 }
 
 // src/utils/validate-core.ts
-import { existsSync as existsSync10 } from "fs";
-import { join as join10 } from "path";
+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) {
@@ -5238,7 +5307,7 @@ function detectIgnoredFilesInPatch(branchName, mainWorktreePath) {
     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) => existsSync10(join10(mainWorktreePath, file)));
+    return gitCheckIgnored(patchFiles, mainWorktreePath).filter((file) => existsSync11(join11(mainWorktreePath, file)));
   } catch {
     return [];
   }
@@ -5286,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++) {
@@ -5302,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++) {
@@ -5360,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) {
@@ -6035,9 +6105,9 @@ async function handleMergeConflict(currentBranch, incomingBranch, cwd, autoFlag)
 }
 
 // src/hooks/post-create.ts
-import { existsSync as existsSync11, 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 join11 } from "path";
+import { join as join12 } from "path";
 var POST_CREATE_SCRIPT_RELATIVE_PATH = ".clawt/postCreate.sh";
 function isExecutable(filePath) {
   try {
@@ -6069,8 +6139,8 @@ function resolvePostCreateHook() {
     }
   }
   const mainWorktreePath = getMainWorktreePath();
-  const scriptPath = join11(mainWorktreePath, POST_CREATE_SCRIPT_RELATIVE_PATH);
-  if (existsSync11(scriptPath)) {
+  const scriptPath = join12(mainWorktreePath, POST_CREATE_SCRIPT_RELATIVE_PATH);
+  if (existsSync12(scriptPath)) {
     if (!isExecutable(scriptPath)) {
       autoFixExecutablePermission(scriptPath);
     }
@@ -6169,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));
@@ -6185,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 {
@@ -6285,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);
@@ -6825,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) {
@@ -7100,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) {
@@ -7225,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) {
@@ -7331,8 +7405,8 @@ function registerAliasCommand(program2) {
 }
 
 // src/commands/projects.ts
-import { existsSync as existsSync12, readdirSync as readdirSync6, statSync as statSync4 } from "fs";
-import { join as join12 } 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) => {
@@ -7356,8 +7430,8 @@ function handleProjectsOverview(json) {
   printProjectsOverviewAsText(result);
 }
 function handleProjectDetail(name, json) {
-  const projectDir = join12(WORKTREES_DIR, name);
-  if (!existsSync12(projectDir)) {
+  const projectDir = join13(WORKTREES_DIR, name);
+  if (!existsSync13(projectDir)) {
     printError(MESSAGES.PROJECTS_NOT_FOUND(name));
     process.exit(1);
   }
@@ -7370,7 +7444,7 @@ function handleProjectDetail(name, json) {
   printProjectDetailAsText(result);
 }
 function collectProjectsOverview() {
-  if (!existsSync12(WORKTREES_DIR)) {
+  if (!existsSync13(WORKTREES_DIR)) {
     return { projects: [], totalProjects: 0, totalDiskUsage: 0 };
   }
   const entries = readdirSync6(WORKTREES_DIR, { withFileTypes: true });
@@ -7379,7 +7453,7 @@ function collectProjectsOverview() {
     if (!entry.isDirectory()) {
       continue;
     }
-    const projectDir = join12(WORKTREES_DIR, entry.name);
+    const projectDir = join13(WORKTREES_DIR, entry.name);
     const overview = collectSingleProjectOverview(entry.name, projectDir);
     projects.push(overview);
   }
@@ -7396,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) => join12(projectDir, e.name)));
+  const lastActiveTime = resolveProjectLastActiveTime(projectDir, worktreeDirs.map((e) => join13(projectDir, e.name)));
   return {
     name,
     worktreeCount,
@@ -7411,7 +7485,7 @@ function collectProjectDetail(name, projectDir) {
     if (!entry.isDirectory()) {
       continue;
     }
-    const wtPath = join12(projectDir, entry.name);
+    const wtPath = join13(projectDir, entry.name);
     const detail = collectSingleWorktreeDetail(entry.name, wtPath);
     worktrees.push(detail);
   }
@@ -7511,7 +7585,7 @@ function printWorktreeDetailItem(wt) {
 }
 
 // src/commands/completion.ts
-import { readFileSync as readFileSync6, writeFileSync as writeFileSync5, existsSync as existsSync14 } 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";
 
@@ -7562,23 +7636,23 @@ compdef _clawt_completion clawt
 }
 
 // src/utils/completion-engine.ts
-import { existsSync as existsSync13, readdirSync as readdirSync7, statSync as statSync5 } from "fs";
-import { join as join13, 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 ? join13(cwd, dirname(partial)) : cwd;
+  const searchDir = hasDir ? join14(cwd, dirname2(partial)) : cwd;
   const prefix = hasDir ? basename2(partial) : partial;
-  if (!existsSync13(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 = join13(searchDir, entry);
+    const fullPath = join14(searchDir, entry);
     try {
       const stat = statSync5(fullPath);
       if (stat.isDirectory()) {
@@ -7667,15 +7741,15 @@ function generateCompletions(program2, args) {
 
 // src/commands/completion.ts
 function appendToFile(filePath, content) {
-  if (existsSync14(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));
 }
@@ -7807,23 +7881,23 @@ async function handleHome() {
 }
 
 // src/commands/tasks.ts
-import { resolve as resolve4, dirname as dirname2, join as join14 } from "path";
-import { existsSync as existsSync15, 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 ?? join14(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 (existsSync15(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));
 }

package/docs/create.md

@@ -50,6 +50,7 @@ clawt create -b <branchName> [-n <count>] [--no-post-create]
    - 若 `n > 1`：校验 `branchName-1` 到 `branchName-n`
    - 所有分支名在创建任何 worktree **之前**完成全部校验
 8. **批量创建 worktree + 验证分支**
+   - 创建前记录当前所在分支为来源分支（`baseBranch`），保存到 `~/.clawt/projects/<projectName>/worktrees/<branchName>.json`
    - 若 `n = 1`：
      ```bash
      git worktree add -b <branchName> ~/.clawt/worktrees/<project>/<branchName>