sync-worktrees 3.0.1 → 3.2.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 {
@@ -780,6 +803,43 @@ import * as fs4 from "fs/promises";
 import * as path4 from "path";
 import simpleGit3 from "simple-git";
 
+// src/errors/index.ts
+var SyncWorktreesError = class extends Error {
+  constructor(message, code, cause) {
+    super(message);
+    this.code = code;
+    this.cause = cause;
+    this.name = this.constructor.name;
+    Object.setPrototypeOf(this, new.target.prototype);
+    if (cause && cause.stack) {
+      this.stack = `${this.stack}
+Caused by: ${cause.stack}`;
+    }
+  }
+};
+var GitError = class extends SyncWorktreesError {
+  constructor(message, code, cause) {
+    super(message, `GIT_${code}`, cause);
+  }
+};
+var GitOperationError = class extends GitError {
+  constructor(operation, details, cause) {
+    super(`Git operation '${operation}' failed: ${details}`, "OPERATION_FAILED", cause);
+  }
+};
+var WorktreeError = class extends SyncWorktreesError {
+  constructor(message, code, cause) {
+    super(message, `WORKTREE_${code}`, cause);
+  }
+};
+var WorktreeNotCleanError = class extends WorktreeError {
+  constructor(path10, reasons) {
+    super(`Worktree at '${path10}' is not clean: ${reasons.join(", ")}`, "NOT_CLEAN");
+    this.path = path10;
+    this.reasons = reasons;
+  }
+};
+
 // src/utils/git-url.ts
 function extractRepoNameFromUrl(gitUrl) {
   const url = gitUrl.trim();
@@ -1078,45 +1138,6 @@ var WorktreeMetadataService = class {
 import * as fs3 from "fs/promises";
 import * as path3 from "path";
 import simpleGit2 from "simple-git";
-
-// src/errors/index.ts
-var SyncWorktreesError = class extends Error {
-  constructor(message, code, cause) {
-    super(message);
-    this.code = code;
-    this.cause = cause;
-    this.name = this.constructor.name;
-    Object.setPrototypeOf(this, new.target.prototype);
-    if (cause && cause.stack) {
-      this.stack = `${this.stack}
-Caused by: ${cause.stack}`;
-    }
-  }
-};
-var GitError = class extends SyncWorktreesError {
-  constructor(message, code, cause) {
-    super(message, `GIT_${code}`, cause);
-  }
-};
-var GitOperationError = class extends GitError {
-  constructor(operation, details, cause) {
-    super(`Git operation '${operation}' failed: ${details}`, "OPERATION_FAILED", cause);
-  }
-};
-var WorktreeError = class extends SyncWorktreesError {
-  constructor(message, code, cause) {
-    super(message, `WORKTREE_${code}`, cause);
-  }
-};
-var WorktreeNotCleanError = class extends WorktreeError {
-  constructor(path10, reasons) {
-    super(`Worktree at '${path10}' is not clean: ${reasons.join(", ")}`, "NOT_CLEAN");
-    this.path = path10;
-    this.reasons = reasons;
-  }
-};
-
-// src/services/worktree-status.service.ts
 var OPERATION_FILES = [
   { file: GIT_OPERATIONS.MERGE_HEAD, type: "merge" },
   { file: GIT_OPERATIONS.CHERRY_PICK_HEAD, type: "cherry-pick" },
@@ -1173,6 +1194,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 {
@@ -1731,24 +1753,19 @@ var GitService = class {
     } catch {
     }
     try {
-      const branches = await bareGit.branch();
-      const localBranchExists = branches.all.includes(branchName);
-      if (localBranchExists || branchName.includes("/")) {
-        await bareGit.raw(["worktree", "add", absoluteWorktreePath, branchName]);
-        const worktreeGit = this.getCachedGit(absoluteWorktreePath, this.isLfsSkipEnabled());
-        await worktreeGit.branch(["--set-upstream-to", `origin/${branchName}`, branchName]);
+      const { local: localBranchExists, remote: remoteBranchExists } = await this.branchExists(branchName);
+      await this.runWorktreeAddByMatrix(
+        bareGit,
+        branchName,
+        absoluteWorktreePath,
+        localBranchExists,
+        remoteBranchExists
+      );
+      if (localBranchExists && !remoteBranchExists) {
+        this.logger.info(`  - Created worktree for '${branchName}' (no remote yet \u2014 push to set upstream)`);
       } else {
-        await bareGit.raw([
-          "worktree",
-          "add",
-          "--track",
-          "-b",
-          branchName,
-          absoluteWorktreePath,
-          `origin/${branchName}`
-        ]);
+        this.logger.info(`  - Created worktree for '${branchName}' with tracking to origin/${branchName}`);
       }
-      this.logger.info(`  - Created worktree for '${branchName}' with tracking to origin/${branchName}`);
       if (!this.isLfsSkipEnabled()) {
         await this.verifyLfsFilesDownloaded(absoluteWorktreePath, branchName);
       }
@@ -1764,6 +1781,9 @@ var GitService = class {
       }
     } catch (error) {
       const errorMessage = getErrorMessage(error);
+      if (error?.isUpstreamSetupFailure) {
+        throw error;
+      }
       if (errorMessage.includes("Metadata creation failed")) {
         throw error;
       }
@@ -1781,15 +1801,14 @@ var GitService = class {
         } catch {
         }
         try {
-          await bareGit.raw([
-            "worktree",
-            "add",
-            "--track",
-            "-b",
+          const { local: localBranchExists, remote: remoteBranchExists } = await this.branchExists(branchName);
+          await this.runWorktreeAddByMatrix(
+            bareGit,
             branchName,
             absoluteWorktreePath,
-            `origin/${branchName}`
-          ]);
+            localBranchExists,
+            remoteBranchExists
+          );
           this.logger.info(`  - Created worktree for '${branchName}' after pruning`);
           if (!this.isLfsSkipEnabled()) {
             await this.verifyLfsFilesDownloaded(absoluteWorktreePath, branchName);
@@ -1858,6 +1877,43 @@ var GitService = class {
       }
     }
   }
+  async runWorktreeAddByMatrix(bareGit, branchName, absoluteWorktreePath, localExists, remoteExists) {
+    if (localExists && remoteExists) {
+      await bareGit.raw(["worktree", "add", absoluteWorktreePath, branchName]);
+      try {
+        const worktreeGit = this.getCachedGit(absoluteWorktreePath, this.isLfsSkipEnabled());
+        await worktreeGit.branch(["--set-upstream-to", `origin/${branchName}`, branchName]);
+      } catch (error) {
+        let rollbackFailed = false;
+        try {
+          await bareGit.raw(["worktree", "remove", "--force", absoluteWorktreePath]);
+        } catch (rollbackError) {
+          rollbackFailed = true;
+          this.logger.warn(
+            `  - Rollback failed for '${branchName}' at '${absoluteWorktreePath}' after upstream setup error: ${getErrorMessage(rollbackError)}`
+          );
+        }
+        const detail = getErrorMessage(error);
+        const suffix = rollbackFailed ? " (rollback failed; partial worktree may remain)" : "";
+        const wrapped = new Error(`Failed to set upstream for '${branchName}': ${detail}${suffix}`);
+        wrapped.isUpstreamSetupFailure = true;
+        throw wrapped;
+      }
+      return;
+    }
+    if (localExists) {
+      await bareGit.raw(["worktree", "add", absoluteWorktreePath, branchName]);
+      return;
+    }
+    if (remoteExists) {
+      await bareGit.raw(["worktree", "add", "--track", "-b", branchName, absoluteWorktreePath, `origin/${branchName}`]);
+      return;
+    }
+    throw new WorktreeError(
+      `Branch '${branchName}' does not exist locally or on origin; create it first`,
+      "BRANCH_NOT_FOUND"
+    );
+  }
   async removeWorktree(worktreePath) {
     const bareGit = this.getCachedGit(this.bareRepoPath);
     await bareGit.raw(["worktree", "remove", worktreePath, "--force"]);
@@ -2051,10 +2107,18 @@ var GitService = class {
   }
   async branchExists(branchName) {
     const bareGit = this.getCachedGit(this.bareRepoPath);
-    const localBranches = await bareGit.branch();
-    const local = localBranches.all.includes(branchName);
-    const remoteBranches = await bareGit.branch(["-r"]);
-    const remote = remoteBranches.all.includes(`origin/${branchName}`);
+    const checkRef = async (ref) => {
+      try {
+        await bareGit.raw(["show-ref", "--verify", "--quiet", ref]);
+        return true;
+      } catch {
+        return false;
+      }
+    };
+    const [local, remote] = await Promise.all([
+      checkRef(`${GIT_CONSTANTS.REFS.HEADS}${branchName}`),
+      checkRef(`${GIT_CONSTANTS.REFS.REMOTES}/${branchName}`)
+    ]);
     return { local, remote };
   }
   async getLocalBranches() {
@@ -2804,15 +2868,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 +2890,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 +2911,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 +2934,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 +2946,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 +2992,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 +3047,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 +3062,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 +3100,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 +3109,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 +3121,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 +3156,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 +3175,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 +3192,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 +3255,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 +3264,7 @@ function parseWorktreeList(output, currentPath) {
     results.push({
       path: resolved,
       branch,
-      isCurrent: fold(resolved) === foldedCurrent
+      isCurrent: normalizePathForCompare(resolved) === foldedCurrent
     });
   }
   return results;
@@ -3189,7 +3308,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 +3435,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 +3518,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 +3566,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 +3590,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 +3611,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 +3651,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 +3672,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 +3692,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 +3707,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,15 +3769,27 @@ 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.";
-function createServer(context) {
+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 buildInstructions(snapshot) {
+  const d = snapshot?.discovered;
+  if (!d || !d.isWorktree || d.kind !== "managed") return SERVER_INSTRUCTIONS;
+  const lines = ["Connect-time context (call `detect_context` for live state):"];
+  if (d.kind) lines.push(`- kind: ${d.kind}`);
+  if (d.currentWorktreePath) lines.push(`- currentWorktreePath: ${d.currentWorktreePath}`);
+  if (d.currentBranch) lines.push(`- currentBranch: ${d.currentBranch}`);
+  if (d.configPath) lines.push(`- configPath: ${d.configPath}`);
+  return `${SERVER_INSTRUCTIONS}
+
+${lines.join("\n")}`;
+}
+function createServer(context, snapshot) {
   const server = new McpServer(
     {
       name: "sync-worktrees",
       version: "1.0.0"
     },
     {
-      instructions: SERVER_INSTRUCTIONS
+      instructions: buildInstructions(snapshot)
     }
   );
   server.registerResource(
@@ -3609,7 +3797,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 +3821,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 +3840,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",
@@ -3828,8 +4022,9 @@ async function main() {
 `);
     }
   }
+  let discovered = null;
   try {
-    const discovered = await context.detectFromPath(process.cwd());
+    discovered = await context.detectFromPath(process.cwd());
     if (discovered.isWorktree) {
       process.stderr.write(
         `[sync-worktrees-mcp] Auto-detected ${discovered.kind} worktree at ${discovered.currentWorktreePath} (branch: ${discovered.currentBranch})
@@ -3840,7 +4035,7 @@ async function main() {
     process.stderr.write(`[sync-worktrees-mcp] Auto-detect failed: ${err.message}
 `);
   }
-  const server = createServer(context);
+  const server = createServer(context, { discovered });
   const transport = new StdioServerTransport();
   await server.connect(transport);
 }