sync-worktrees 3.0.1 → 3.1.0

package/dist/mcp-server.js

@@ -85,6 +85,11 @@ var PATH_CONSTANTS = {
   GIT_DIR: ".git",
   README: "README"
 };
+var CONFIG_FILE_NAMES = [
+  "sync-worktrees.config.js",
+  "sync-worktrees.config.mjs",
+  "sync-worktrees.config.cjs"
+];
 var METADATA_CONSTANTS = {
   MAX_HISTORY_ENTRIES: 10,
   METADATA_FILENAME: "sync-metadata.json",
@@ -124,6 +129,24 @@ function filterBranchesByName(branches, include, exclude) {
 
 // src/services/config-loader.service.ts
 var ConfigLoaderService = class {
+  async findConfigUpward(startDir) {
+    let current = path.resolve(startDir);
+    const root = path.parse(current).root;
+    while (true) {
+      for (const name of CONFIG_FILE_NAMES) {
+        const candidate = path.join(current, name);
+        try {
+          await fs.access(candidate);
+          return candidate;
+        } catch {
+        }
+      }
+      if (current === root) return null;
+      const parent = path.dirname(current);
+      if (parent === current) return null;
+      current = parent;
+    }
+  }
   async loadConfigFile(configPath) {
     const absolutePath = path.resolve(configPath);
     try {
@@ -1173,6 +1196,7 @@ var WorktreeStatusService = class {
     if (hasUnpushedCommits) reasons.push("unpushed commits");
     if (hasOperationInProgress) reasons.push("operation in progress");
     if (hasModifiedSubmodules) reasons.push("modified submodules");
+    if (upstreamGone) reasons.push("upstream gone");
     const canRemove = isClean && !hasUnpushedCommits && !hasOperationInProgress && !hasModifiedSubmodules;
     const details = includeDetails ? this.buildStatusDetails(snap) : void 0;
     return {
@@ -2804,15 +2828,18 @@ var WorktreeSyncService = class {
 // src/mcp/context.ts
 var AUTO_DETECT_PREFIX = "__auto_detected__:";
 var DISCOVERY_CACHE_TTL_MS = 5e3;
-var EMPTY_CAPABILITIES = {
-  canListWorktrees: false,
-  canGetStatus: false,
-  canCreateWorktree: false,
-  canRemoveWorktree: false,
-  canUpdateWorktree: false,
-  canSync: false,
-  canInitialize: false
-};
+function emptyCapabilities(reason) {
+  const state = reason ? { available: false, reason } : { available: false };
+  return {
+    listWorktrees: { ...state },
+    getStatus: { ...state },
+    createWorktree: { ...state },
+    removeWorktree: { ...state },
+    updateWorktree: { ...state },
+    sync: { ...state },
+    initialize: { ...state }
+  };
+}
 function buildUnsupportedContext(currentPath, reason) {
   return {
     isWorktree: false,
@@ -2823,10 +2850,11 @@ function buildUnsupportedContext(currentPath, reason) {
     repoUrl: null,
     worktreeDir: null,
     allWorktrees: [],
-    configLoaded: false,
+    siblingRepositories: [],
+    configPath: null,
     repoName: null,
-    capabilities: EMPTY_CAPABILITIES,
-    reasons: [reason]
+    capabilities: emptyCapabilities(reason),
+    notes: [reason]
   };
 }
 function createStderrLogger(repoName) {
@@ -2843,7 +2871,8 @@ var RepositoryContext = class {
   configPath = null;
   configLoader = new ConfigLoaderService();
   discoveryCache = /* @__PURE__ */ new Map();
-  async loadConfig(configPath) {
+  async loadConfig(configPath, options = {}) {
+    const setDefaultCurrent = options.setDefaultCurrent ?? true;
     const absolutePath = path8.resolve(configPath);
     const configFile = await this.configLoader.loadConfigFile(absolutePath);
     for (const [name, entry] of this.repos) {
@@ -2865,9 +2894,10 @@ var RepositoryContext = class {
     if (this.currentRepo && !this.repos.has(this.currentRepo)) {
       this.currentRepo = null;
     }
-    if (!this.currentRepo && configFile.repositories.length > 0) {
+    if (setDefaultCurrent && !this.currentRepo && configFile.repositories.length > 0) {
       this.currentRepo = configFile.repositories[0].name;
     }
+    this.discoveryCache.clear();
     return configFile.repositories;
   }
   async detectFromPath(dirPath) {
@@ -2876,6 +2906,17 @@ var RepositoryContext = class {
     if (cached && await this.isCacheFresh(cached)) {
       return cached.result;
     }
+    if (this.configPath === null) {
+      const found = await this.configLoader.findConfigUpward(absolutePath);
+      if (found) {
+        try {
+          await this.loadConfig(found, { setDefaultCurrent: false });
+        } catch (err) {
+          process.stderr.write(`[sync-worktrees] auto-loaded config failed: ${err.message}
+`);
+        }
+      }
+    }
     const { result, adminDir } = await this.detectFromPathUncached(absolutePath);
     if (result.isWorktree && result.bareRepoPath && adminDir) {
       const [worktreeHeadMtimeMs, worktreesDirMtimeMs] = await Promise.all([
@@ -2911,10 +2952,49 @@ var RepositoryContext = class {
   __discoveryCacheSizeForTest() {
     return this.discoveryCache.size;
   }
-  bootstrapCurrentRepo(candidate) {
+  async discoverSiblingRepositories(currentBareRepoPath) {
+    const repoDir = path8.dirname(currentBareRepoPath);
+    const workspaceRoot = path8.dirname(repoDir);
+    if (workspaceRoot === repoDir) return [];
+    let entries;
+    try {
+      entries = await fs7.readdir(workspaceRoot);
+    } catch {
+      return [];
+    }
+    const configBares = /* @__PURE__ */ new Map();
+    for (const entry of this.repos.values()) {
+      if (entry.source === "config" && entry.config.bareRepoDir) {
+        configBares.set(normalizePathForCompare(entry.config.bareRepoDir), entry.name);
+      }
+    }
+    const results = [];
+    await Promise.all(
+      entries.map(async (entry) => {
+        const candidate = path8.join(workspaceRoot, entry);
+        const bareCandidate = path8.join(candidate, GIT_CONSTANTS.BARE_DIR_NAME);
+        try {
+          const stat4 = await fs7.stat(bareCandidate);
+          if (!stat4.isDirectory()) return;
+        } catch {
+          return;
+        }
+        const resolvedBare = path8.resolve(bareCandidate);
+        const matchedName = configBares.get(normalizePathForCompare(resolvedBare));
+        results.push({
+          name: matchedName ?? entry,
+          bareRepoPath: resolvedBare,
+          configMatched: matchedName !== void 0
+        });
+      })
+    );
+    results.sort((a, b) => a.name.localeCompare(b.name));
+    return results;
+  }
+  bootstrapCurrentRepo(candidate, force = false) {
     if (this.currentRepo !== null) return;
     if (!this.repos.has(candidate)) return;
-    if (this.repos.size !== 1) return;
+    if (!force && this.repos.size !== 1) return;
     this.currentRepo = candidate;
   }
   async isCacheFresh(cached) {
@@ -2927,14 +3007,14 @@ var RepositoryContext = class {
     return currentHeadMtime === cached.worktreeHeadMtimeMs && currentWorktreesDirMtime === cached.worktreesDirMtimeMs;
   }
   async detectFromPathUncached(absolutePath) {
-    const reasons = [];
+    const notes = [];
     const located = await findWorktreeRoot(absolutePath);
     const worktreeRoot = located?.worktreeRoot ?? absolutePath;
-    const unsupported = (reason, isWorktree = false) => {
-      reasons.push(reason);
+    const unsupported = (reason) => {
+      notes.push(reason);
       return {
         result: {
-          isWorktree,
+          isWorktree: false,
           kind: "unsupported",
           currentBranch: null,
           currentWorktreePath: worktreeRoot,
@@ -2942,10 +3022,11 @@ var RepositoryContext = class {
           repoUrl: null,
           worktreeDir: null,
           allWorktrees: [],
-          configLoaded: this.configPath !== null,
+          siblingRepositories: [],
+          configPath: this.configPath,
           repoName: null,
-          capabilities: EMPTY_CAPABILITIES,
-          reasons
+          capabilities: emptyCapabilities(reason),
+          notes
         },
         adminDir: null
       };
@@ -2979,7 +3060,7 @@ var RepositoryContext = class {
         const urlStr = typeof remoteResult === "string" ? remoteResult.trim() : "";
         repoUrl = urlStr || null;
       } catch {
-        reasons.push("Could not read remote origin URL");
+        notes.push("Could not read remote origin URL");
       }
       const listOutput = await bareGit.raw(["worktree", "list", "--porcelain"]);
       worktrees = parseWorktreeList(listOutput, worktreeRoot);
@@ -2988,7 +3069,8 @@ var RepositoryContext = class {
         currentBranch = current.branch;
       }
     } catch (err) {
-      reasons.push(`Failed to read bare repo at ${bareRepoPath}: ${err.message}`);
+      const reason = `Failed to read bare repo at ${bareRepoPath}: ${err.message}`;
+      notes.push(reason);
       return {
         result: {
           isWorktree: true,
@@ -2999,34 +3081,31 @@ var RepositoryContext = class {
           repoUrl: null,
           worktreeDir: null,
           allWorktrees: [],
-          configLoaded: this.configPath !== null,
+          siblingRepositories: [],
+          configPath: this.configPath,
           repoName: null,
-          capabilities: EMPTY_CAPABILITIES,
-          reasons
+          capabilities: emptyCapabilities(reason),
+          notes
         },
         adminDir
       };
     }
     const worktreeDir = path8.dirname(worktreeRoot);
+    const noUrlReason = "no remote origin URL detected";
     const capabilities = {
-      canListWorktrees: true,
-      canGetStatus: true,
-      canCreateWorktree: repoUrl !== null,
-      canRemoveWorktree: true,
-      canUpdateWorktree: true,
-      canSync: false,
-      canInitialize: false
+      listWorktrees: { available: true },
+      getStatus: { available: true },
+      createWorktree: repoUrl !== null ? { available: true } : { available: false, reason: noUrlReason },
+      removeWorktree: { available: true },
+      updateWorktree: { available: true },
+      sync: { available: false, reason: "no config and no remote URL" },
+      initialize: { available: false, reason: "no config and no remote URL" }
     };
-    if (!repoUrl) {
-      reasons.push("create_worktree unavailable: no remote origin URL detected");
-    }
-    const foldPath = (p) => isCaseInsensitiveFs() ? p.toLowerCase() : p;
-    const foldedBare = foldPath(bareRepoPath);
+    const foldedBare = normalizePathForCompare(bareRepoPath);
     let matchedConfig = null;
     for (const entry of this.repos.values()) {
-      if (entry.source === "config") {
-        const entryBare = entry.config.bareRepoDir ? path8.resolve(entry.config.bareRepoDir) : null;
-        if (entryBare && foldPath(entryBare) === foldedBare) {
+      if (entry.source === "config" && entry.config.bareRepoDir) {
+        if (normalizePathForCompare(entry.config.bareRepoDir) === foldedBare) {
           matchedConfig = entry;
           break;
         }
@@ -3037,8 +3116,8 @@ var RepositoryContext = class {
     if (matchedConfig) {
       repoName = matchedConfig.name;
       kind = "managed";
-      capabilities.canSync = true;
-      capabilities.canInitialize = true;
+      capabilities.sync = { available: true };
+      capabilities.initialize = { available: true };
     } else if (repoUrl) {
       const syntheticConfig = {
         repoUrl,
@@ -3056,13 +3135,14 @@ var RepositoryContext = class {
         });
       }
       repoName = detectedKey;
-      reasons.push("sync/initialize unavailable: no config file loaded (running in auto-detect mode)");
-    } else {
-      reasons.push("sync/initialize unavailable: no config file and no remote URL");
+      const autoReason = "no config file loaded (running in auto-detect mode)";
+      capabilities.sync = { available: false, reason: autoReason };
+      capabilities.initialize = { available: false, reason: autoReason };
     }
     if (repoName) {
-      this.bootstrapCurrentRepo(repoName);
+      this.bootstrapCurrentRepo(repoName, matchedConfig !== null);
     }
+    const siblingRepositories = await this.discoverSiblingRepositories(bareRepoPath);
     const discovered = {
       isWorktree: true,
       kind,
@@ -3072,10 +3152,11 @@ var RepositoryContext = class {
       repoUrl,
       worktreeDir,
       allWorktrees: worktrees,
-      configLoaded: this.configPath !== null,
+      siblingRepositories,
+      configPath: this.configPath,
       repoName,
       capabilities,
-      reasons
+      notes
     };
     if (repoName) {
       const entry = this.repos.get(repoName);
@@ -3134,9 +3215,7 @@ var RepositoryContext = class {
   }
 };
 function parseWorktreeList(output, currentPath) {
-  const resolvedCurrent = path8.resolve(currentPath);
-  const fold = (p) => isCaseInsensitiveFs() ? p.toLowerCase() : p;
-  const foldedCurrent = fold(resolvedCurrent);
+  const foldedCurrent = normalizePathForCompare(currentPath);
   const results = [];
   for (const wt of parseWorktreeListPorcelain(output)) {
     const resolved = path8.resolve(wt.path);
@@ -3145,7 +3224,7 @@ function parseWorktreeList(output, currentPath) {
     results.push({
       path: resolved,
       branch,
-      isCurrent: fold(resolved) === foldedCurrent
+      isCurrent: normalizePathForCompare(resolved) === foldedCurrent
     });
   }
   return results;
@@ -3189,7 +3268,24 @@ import { z } from "zod";
 // src/mcp/handlers.ts
 import * as path9 from "path";
 import pLimit2 from "p-limit";
-import simpleGit5 from "simple-git";
+
+// src/utils/disk-space.ts
+import fastFolderSize from "fast-folder-size";
+async function calculateDirectorySize(dirPath) {
+  return new Promise((resolve9, reject) => {
+    fastFolderSize(dirPath, (err, bytes) => {
+      if (err) {
+        reject(err);
+        return;
+      }
+      if (bytes === void 0) {
+        reject(new Error(`fast-folder-size returned no bytes for ${dirPath}`));
+        return;
+      }
+      resolve9(bytes);
+    });
+  });
+}
 
 // src/utils/git-validation.ts
 function isValidGitBranchName(name) {
@@ -3299,12 +3395,45 @@ function wrapHandler(fn) {
   };
 }
 
+// src/mcp/worktree-summary.ts
+import simpleGit5 from "simple-git";
+function deriveLabel(status, isCurrent) {
+  if (isCurrent) return "current";
+  if (!status.isClean || status.hasUnpushedCommits || status.hasStashedChanges) return "dirty";
+  if (status.upstreamGone) return "stale";
+  return "clean";
+}
+function deriveSafeToRemove(status) {
+  if (status.canRemove && !status.upstreamGone) {
+    return { safe: true, reason: "clean tree, no unpushed commits" };
+  }
+  if (status.canRemove && status.upstreamGone) {
+    return { safe: false, reason: "branch deleted upstream \u2014 verify no work is lost before removal" };
+  }
+  if (status.reasons.length > 0) {
+    return { safe: false, reason: status.reasons.join(", ") };
+  }
+  return { safe: false, reason: "not safe to remove" };
+}
+async function getDivergence(worktreePath) {
+  try {
+    const git = simpleGit5(worktreePath);
+    const output = await git.raw(["rev-list", "--left-right", "--count", "HEAD...@{upstream}"]);
+    const [aheadStr, behindStr] = output.trim().split(/\s+/);
+    return { ahead: parseInt(aheadStr, 10), behind: parseInt(behindStr, 10) };
+  } catch {
+    return null;
+  }
+}
+
 // src/mcp/handlers.ts
 var pathResolution = new PathResolutionService();
 function ensureCapability(discovered, key, toolName) {
   if (!discovered) return;
-  if (!discovered.capabilities[key]) {
-    throw new CapabilityUnavailableError(toolName, discovered.reasons);
+  const cap = discovered.capabilities[key];
+  if (!cap.available) {
+    const reasons = cap.reason ? [cap.reason] : discovered.notes;
+    throw new CapabilityUnavailableError(toolName, reasons);
   }
 }
 async function ensureNotSyncing(ctx, repoName) {
@@ -3349,30 +3478,35 @@ async function ensurePathBelongsToRepo(ctx, targetPath, repoName, git) {
   }
   throw new Error(`Path '${targetPath}' is not a registered worktree of the current repository`);
 }
-function deriveLabel(status, isCurrent) {
-  if (isCurrent) return "current";
-  if (!status.isClean || status.hasUnpushedCommits || status.hasStashedChanges) return "dirty";
-  if (status.upstreamGone) return "stale";
-  return "clean";
-}
-async function getDivergence(worktreePath) {
-  try {
-    const git = simpleGit5(worktreePath);
-    const output = await git.raw(["rev-list", "--left-right", "--count", "HEAD...@{upstream}"]);
-    const [aheadStr, behindStr] = output.trim().split(/\s+/);
-    return { ahead: parseInt(aheadStr, 10), behind: parseInt(behindStr, 10) };
-  } catch {
-    return null;
-  }
-}
 async function handleDetectContext(ctx, params, _extra) {
   const target = params.path ?? process.cwd();
   const discovered = await ctx.detectFromPath(target);
-  return formatToolResponse(discovered);
+  if (!params.includeStatus || discovered.allWorktrees.length === 0) {
+    return formatToolResponse(discovered);
+  }
+  const statusService = new WorktreeStatusService();
+  const limit = pLimit2(DEFAULT_CONFIG.PARALLELISM.MAX_STATUS_CHECKS);
+  const enriched = await Promise.all(
+    discovered.allWorktrees.map(
+      (wt) => limit(async () => {
+        const [status, divergence] = await Promise.all([
+          statusService.getFullWorktreeStatus(wt.path, false).catch(() => null),
+          getDivergence(wt.path)
+        ]);
+        return {
+          ...wt,
+          label: status ? deriveLabel(status, wt.isCurrent) : wt.isCurrent ? "current" : "unknown",
+          divergence,
+          staleHint: status?.upstreamGone ?? false
+        };
+      })
+    )
+  );
+  return formatToolResponse({ ...discovered, allWorktrees: enriched });
 }
 async function handleListWorktrees(ctx, params, _extra) {
   const { discovered, git } = await getReadyService(ctx, params.repoName, {
-    capability: "canListWorktrees",
+    capability: "listWorktrees",
     toolName: "list_worktrees"
   });
   let worktrees;
@@ -3392,20 +3526,22 @@ async function handleListWorktrees(ctx, params, _extra) {
       (wt) => limit(async () => {
         const resolvedPath = path9.resolve(wt.path);
         const isCurrent = currentPath !== null && pathsEqual(wt.path, currentPath);
-        const [status, divergence, metadata] = await Promise.all([
+        const [status, divergence, metadata, sizeBytes] = await Promise.all([
           git.getFullWorktreeStatus(wt.path, false).catch(() => null),
           getDivergence(wt.path),
-          git.getWorktreeMetadata(wt.path).catch(() => null)
+          git.getWorktreeMetadata(wt.path).catch(() => null),
+          params.includeSize ? calculateDirectorySize(wt.path).catch(() => null) : Promise.resolve(null)
         ]);
         return {
           path: resolvedPath,
           branch: wt.branch,
           isCurrent,
-          label: status ? deriveLabel(status, isCurrent) : "unknown",
+          label: status ? deriveLabel(status, isCurrent) : isCurrent ? "current" : "unknown",
           status,
           divergence,
-          safeToRemove: status ? status.canRemove && !status.upstreamGone : false,
-          lastSyncAt: metadata?.lastSyncDate ?? null
+          safeToRemove: status ? deriveSafeToRemove(status) : { safe: false, reason: "status unavailable" },
+          lastSyncAt: metadata?.lastSyncDate ?? null,
+          sizeBytes
         };
       })
     )
@@ -3414,7 +3550,7 @@ async function handleListWorktrees(ctx, params, _extra) {
 }
 async function handleGetWorktreeStatus(ctx, params, _extra) {
   const { git } = await getReadyService(ctx, params.repoName, {
-    capability: "canGetStatus",
+    capability: "getStatus",
     toolName: "get_worktree_status"
   });
   const resolvedPath = await ensureRepoWorktreePath(ctx, params, git);
@@ -3435,7 +3571,7 @@ async function handleCreateWorktree(ctx, params, _extra) {
     throw new Error(`Invalid branch name '${branchName}': ${validation.error}`);
   }
   const { service, git } = await getReadyService(ctx, params.repoName, {
-    capability: "canCreateWorktree",
+    capability: "createWorktree",
     toolName: "create_worktree",
     ensureInitialized: true,
     ensureNotSyncing: true
@@ -3475,7 +3611,7 @@ async function handleCreateWorktree(ctx, params, _extra) {
 }
 async function handleRemoveWorktree(ctx, params, _extra) {
   const { git } = await getReadyService(ctx, params.repoName, {
-    capability: "canRemoveWorktree",
+    capability: "removeWorktree",
     toolName: "remove_worktree",
     ensureInitialized: true,
     ensureNotSyncing: true
@@ -3496,7 +3632,7 @@ async function handleRemoveWorktree(ctx, params, _extra) {
 }
 async function handleSync(ctx, params, extra) {
   const { service } = await getReadyService(ctx, params.repoName, {
-    capability: "canSync",
+    capability: "sync",
     toolName: "sync",
     ensureInitialized: true
   });
@@ -3516,7 +3652,7 @@ async function handleSync(ctx, params, extra) {
 }
 async function handleUpdateWorktree(ctx, params, _extra) {
   const { git } = await getReadyService(ctx, params.repoName, {
-    capability: "canUpdateWorktree",
+    capability: "updateWorktree",
     toolName: "update_worktree",
     ensureInitialized: true,
     ensureNotSyncing: true
@@ -3531,7 +3667,7 @@ async function handleUpdateWorktree(ctx, params, _extra) {
 }
 async function handleInitialize(ctx, params, extra) {
   const { service } = await getReadyService(ctx, params.repoName, {
-    capability: "canInitialize",
+    capability: "initialize",
     toolName: "initialize",
     ensureNotSyncing: true
   });
@@ -3593,7 +3729,7 @@ function attachProgressReporter(service, extra) {
 // src/mcp/server.ts
 var REPO_NAME_DESCRIBE = "Repository name from loaded config. If omitted, uses the current repository set via set_current_repository or the only loaded repo.";
 var PATH_DESCRIBE_SUFFIX = "Absolute path preferred; relative paths resolve from the server's CWD.";
-var SERVER_INSTRUCTIONS = "Before running git worktree operations, call `detect_context` to learn the current repo, current branch, and which capabilities are available. It reports whether the working directory is inside a sync-worktrees-managed workspace, lists sibling worktrees, and explains why any capability is disabled.";
+var SERVER_INSTRUCTIONS = "Before running git worktree operations, call `detect_context` to learn the current repo, current branch, sibling repositories under the workspace root, and which capabilities are available. It walks up to auto-discover sync-worktrees.config.{js,mjs,cjs,ts}, lists sibling worktrees, and reports per-capability {available, reason} so you can tell which tool is gated and why.";
 function createServer(context) {
   const server = new McpServer(
     {
@@ -3609,7 +3745,7 @@ function createServer(context) {
     "sync-worktrees://workspace",
     {
       title: "Workspace context",
-      description: "Current sync-worktrees workspace context: whether CWD is inside a managed worktree, the current branch, sibling worktrees, and available capabilities. Returns { isWorktree: false } when CWD is outside any workspace.",
+      description: "Current sync-worktrees workspace context: whether CWD is inside a managed worktree, the current branch, sibling worktrees, sibling repositories, auto-discovered configPath, and per-capability {available, reason}. Returns { isWorktree: false } when CWD is outside any workspace.",
       mimeType: "application/json"
     },
     async (uri) => {
@@ -3633,9 +3769,12 @@ function createServer(context) {
   server.registerTool(
     "detect_context",
     {
-      description: "Detect sync-worktrees structure from a filesystem path. Reads .git file, resolves bare repo, discovers sibling worktrees. Defaults to CWD. Use when: bootstrapping from an unknown checkout with no config loaded. Returns: discovered repo root, bare repo path, all sibling worktrees, current worktree path, capabilities.",
+      description: "Detect sync-worktrees structure from a filesystem path. Reads .git file, resolves bare repo, discovers sibling worktrees, walks up for a sync-worktrees.config.{js,mjs,cjs,ts}, and lists sibling bare repos under the workspace root. Defaults to CWD. Use when: bootstrapping from an unknown checkout. Returns: discovered repo root, bare repo path, all sibling worktrees, sibling repositories, current worktree path, configPath (auto-found), per-capability {available, reason}, notes[].",
       inputSchema: {
-        path: z.string().optional().describe("Directory path to inspect. Defaults to the server's CWD.")
+        path: z.string().optional().describe("Directory path to inspect. Defaults to the server's CWD."),
+        includeStatus: z.boolean().optional().describe(
+          "If true, enriches each entry in allWorktrees with label, divergence, and staleHint. Adds one git status + rev-list per worktree. Default: false (cheap path)."
+        )
       },
       annotations: {
         title: "Detect sync-worktrees context",
@@ -3649,9 +3788,12 @@ function createServer(context) {
   server.registerTool(
     "list_worktrees",
     {
-      description: "List all worktrees of a repository with enriched status. Returns: array of { path, branch, isCurrent, label (clean|dirty|stale|current|unknown), status, divergence (ahead/behind), safeToRemove, lastSyncAt }.",
+      description: "List all worktrees of a repository with enriched status. Returns: array of { path, branch, isCurrent, label (clean|dirty|stale|current|unknown), status, divergence (ahead/behind), safeToRemove: { safe, reason }, lastSyncAt, sizeBytes }.",
       inputSchema: {
-        repoName: z.string().optional().describe(REPO_NAME_DESCRIBE)
+        repoName: z.string().optional().describe(REPO_NAME_DESCRIBE),
+        includeSize: z.boolean().optional().describe(
+          "If true, computes the on-disk size of each worktree (in bytes). Slow on large worktrees. Default: false (sizeBytes returned as null)."
+        )
       },
       annotations: {
         title: "List worktrees with status",