sync-worktrees 3.6.1 → 3.6.3

package/dist/mcp-server.js

@@ -2538,7 +2538,7 @@ var GitService = class {
     const bareGit = this.getCachedGit(this.bareRepoPath);
     const checkRef = async (ref) => {
       try {
-        await bareGit.raw(["show-ref", "--verify", "--quiet", ref]);
+        await bareGit.raw(["show-ref", "--verify", ref]);
         return true;
       } catch {
         return false;
@@ -2555,10 +2555,22 @@ var GitService = class {
     const branches = await bareGit.branch();
     return branches.all;
   }
+  async resolveCreateBranchBaseRef(bareGit, baseBranch) {
+    const candidates = baseBranch.startsWith(GIT_CONSTANTS.REMOTE_PREFIX) || baseBranch.startsWith("refs/") ? [baseBranch] : [`${GIT_CONSTANTS.REMOTE_PREFIX}${baseBranch}`, baseBranch];
+    for (const candidate of candidates) {
+      try {
+        await bareGit.revparse(["--verify", candidate]);
+        return candidate;
+      } catch {
+      }
+    }
+    return candidates[0];
+  }
   async createBranch(branchName, baseBranch) {
     const bareGit = this.getCachedGit(this.bareRepoPath);
-    await bareGit.raw(["branch", branchName, `origin/${baseBranch}`]);
-    this.logger.info(`Created branch '${branchName}' from '${baseBranch}'`);
+    const baseRef = await this.resolveCreateBranchBaseRef(bareGit, baseBranch);
+    await bareGit.raw(["branch", "--no-track", branchName, baseRef]);
+    this.logger.info(`Created branch '${branchName}' from '${baseRef}'`);
   }
   async pushBranch(branchName) {
     const bareGit = this.getCachedGit(this.bareRepoPath);
@@ -2670,17 +2682,9 @@ var WorktreeSyncService = class {
     this.progressListeners.add(listener);
     return () => this.progressListeners.delete(listener);
   }
-  emitProgress(event) {
-    for (const listener of this.progressListeners) {
-      try {
-        listener(event);
-      } catch {
-      }
-    }
-  }
-  async sync() {
+  async runExclusiveRepoOperation(operation) {
     if (this.syncInProgress) {
-      this.logger.warn("\u26A0\uFE0F  Sync already in progress, skipping...");
+      this.logger.warn("\u26A0\uFE0F  Another repository operation is already in progress, skipping...");
       return { started: false, reason: "in_progress" };
     }
     const release = await this.acquireBareLock();
@@ -2689,36 +2693,55 @@ var WorktreeSyncService = class {
       return { started: false, reason: "locked" };
     }
     this.syncInProgress = true;
-    this.logger.info(`[${(/* @__PURE__ */ new Date()).toISOString()}] Starting worktree synchronization...`);
-    const totalTimer = new Timer();
-    const phaseTimer = new PhaseTimer();
-    const syncContext = { lfsSkipEnabled: false };
-    const retryOptions = this.createRetryOptions(syncContext);
     try {
-      await retry(() => this.runSyncAttempt(phaseTimer, syncContext), retryOptions);
-    } catch (error) {
-      this.logger.error("\n\u274C Error during worktree synchronization after all retry attempts:", error);
-      throw error;
+      return { started: true, value: await operation() };
     } finally {
-      if (syncContext.lfsSkipEnabled && !this.config.skipLfs) {
-        this.gitService.setLfsSkipEnabled(false);
-      }
       this.syncInProgress = false;
       try {
         await release();
       } catch (releaseError) {
         this.logger.warn(`Failed to release sync lock: ${getErrorMessage(releaseError)}`);
       }
-      this.logger.info(`[${(/* @__PURE__ */ new Date()).toISOString()}] Synchronization finished.
-`);
-      if (this.config.debug) {
-        const totalDuration = totalTimer.stop();
-        const phaseResults = phaseTimer.getResults();
-        const repoName = this.config.name;
-        this.logger.table(formatTimingTable(totalDuration, phaseResults, repoName));
+    }
+  }
+  emitProgress(event) {
+    for (const listener of this.progressListeners) {
+      try {
+        listener(event);
+      } catch {
       }
     }
-    return { started: true };
+  }
+  async sync() {
+    const result = await this.runExclusiveRepoOperation(async () => {
+      if (!this.isInitialized()) {
+        await this.initialize();
+      }
+      this.logger.info(`[${(/* @__PURE__ */ new Date()).toISOString()}] Starting worktree synchronization...`);
+      const totalTimer = new Timer();
+      const phaseTimer = new PhaseTimer();
+      const syncContext = { lfsSkipEnabled: false };
+      const retryOptions = this.createRetryOptions(syncContext);
+      try {
+        await retry(() => this.runSyncAttempt(phaseTimer, syncContext), retryOptions);
+      } catch (error) {
+        this.logger.error("\n\u274C Error during worktree synchronization after all retry attempts:", error);
+        throw error;
+      } finally {
+        if (syncContext.lfsSkipEnabled && !this.config.skipLfs) {
+          this.gitService.setLfsSkipEnabled(false);
+        }
+        this.logger.info(`[${(/* @__PURE__ */ new Date()).toISOString()}] Synchronization finished.
+`);
+        if (this.config.debug) {
+          const totalDuration = totalTimer.stop();
+          const phaseResults = phaseTimer.getResults();
+          const repoName = this.config.name;
+          this.logger.table(formatTimingTable(totalDuration, phaseResults, repoName));
+        }
+      }
+    });
+    return result.started ? { started: true } : result;
   }
   async acquireBareLock() {
     if (process.env.NODE_ENV === ENV_CONSTANTS.NODE_ENV_TEST) {
@@ -2730,15 +2753,9 @@ var WorktreeSyncService = class {
       };
     }
     const barePath = this.gitService.getBareRepoPath();
-    const lockTarget = path8.join(barePath, "HEAD");
+    await fs6.mkdir(barePath, { recursive: true });
     try {
-      await fs6.access(lockTarget);
-    } catch {
-      return async () => {
-      };
-    }
-    try {
-      const release = await lockfile.lock(lockTarget, {
+      const release = await lockfile.lock(barePath, {
         stale: DEFAULT_CONFIG.LOCK_STALE_MS,
         update: DEFAULT_CONFIG.LOCK_UPDATE_MS,
         retries: 0,
@@ -3518,43 +3535,60 @@ var RepositoryContext = class {
     return this.discoveryCache.size;
   }
   async discoverSiblingRepositories(currentBareRepoPath) {
+    const currentBare = normalizePathForCompare(currentBareRepoPath);
+    const results = /* @__PURE__ */ new Map();
+    const byName = (a, b) => a.name.localeCompare(b.name);
+    const configCandidates = Array.from(this.repos.values()).filter((entry) => entry.source === "config" && !!entry.config.bareRepoDir).map((entry) => {
+      const bareRepoPath = path9.resolve(entry.config.bareRepoDir);
+      return { entry, bareRepoPath, foldedBare: normalizePathForCompare(bareRepoPath) };
+    }).filter((c) => c.foldedBare !== currentBare);
+    const configPresence = await Promise.all(configCandidates.map((c) => isDirectory(c.bareRepoPath)));
+    configCandidates.forEach(({ entry, bareRepoPath, foldedBare }, i) => {
+      const sibling = {
+        name: entry.name,
+        bareRepoPath,
+        worktreeDir: path9.resolve(entry.config.worktreeDir),
+        repoUrl: entry.config.repoUrl,
+        present: configPresence[i],
+        configMatched: true
+      };
+      if (entry.config.sparseCheckout) {
+        sibling.sparseCheckout = entry.config.sparseCheckout;
+      }
+      results.set(foldedBare, sibling);
+    });
     const repoDir = path9.dirname(currentBareRepoPath);
     const workspaceRoot = path9.dirname(repoDir);
-    if (workspaceRoot === repoDir) return [];
+    if (workspaceRoot === repoDir) {
+      return Array.from(results.values()).sort(byName);
+    }
     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);
-      }
+      return Array.from(results.values()).sort(byName);
     }
-    const results = [];
+    const configBares = new Map(configCandidates.map((c) => [c.foldedBare, c.entry.name]));
     await Promise.all(
       entries.map(async (entry) => {
         const candidate = path9.join(workspaceRoot, entry);
         const bareCandidate = path9.join(candidate, GIT_CONSTANTS.BARE_DIR_NAME);
-        try {
-          const stat4 = await fs7.stat(bareCandidate);
-          if (!stat4.isDirectory()) return;
-        } catch {
-          return;
-        }
+        if (!await isDirectory(bareCandidate)) return;
         const resolvedBare = path9.resolve(bareCandidate);
-        const matchedName = configBares.get(normalizePathForCompare(resolvedBare));
-        results.push({
+        const foldedBare = normalizePathForCompare(resolvedBare);
+        if (foldedBare === currentBare || results.has(foldedBare)) return;
+        const matchedName = configBares.get(foldedBare);
+        results.set(foldedBare, {
           name: matchedName ?? entry,
           bareRepoPath: resolvedBare,
+          worktreeDir: null,
+          repoUrl: null,
+          present: true,
           configMatched: matchedName !== void 0
         });
       })
     );
-    results.sort((a, b) => a.name.localeCompare(b.name));
-    return results;
+    return Array.from(results.values()).sort(byName);
   }
   bootstrapCurrentRepo(candidate, force = false) {
     if (this.currentRepo !== null) return;
@@ -3775,12 +3809,44 @@ var RepositoryContext = class {
       source: e.source
     }));
   }
+  getConfiguredRepositoryNames() {
+    return Array.from(this.repos.values()).filter((entry) => entry.source === "config").map((entry) => entry.name);
+  }
+  async getAllConfiguredWorktreeDetails(currentWorktreePath = null) {
+    const entries = Array.from(this.repos.values()).filter((entry) => entry.source === "config");
+    const results = await Promise.all(
+      entries.map(async (entry) => ({
+        name: entry.name,
+        result: await this.readConfiguredWorktrees(entry, currentWorktreePath)
+      }))
+    );
+    const worktreesByRepo = {};
+    const errorsByRepo = {};
+    for (const entry of results) {
+      worktreesByRepo[entry.name] = entry.result.worktrees;
+      if (entry.result.error) {
+        errorsByRepo[entry.name] = entry.result.error;
+      }
+    }
+    return { worktreesByRepo, errorsByRepo };
+  }
   getConfigPath() {
     return this.configPath;
   }
+  async readConfiguredWorktrees(entry, currentWorktreePath) {
+    if (entry.source !== "config" || !entry.config.bareRepoDir) return { worktrees: [] };
+    const bareRepoPath = path9.resolve(entry.config.bareRepoDir);
+    if (!await isDirectory(bareRepoPath)) return { worktrees: [] };
+    try {
+      const output = await simpleGit5(bareRepoPath).raw(["worktree", "list", "--porcelain"]);
+      return { worktrees: parseWorktreeList(output, currentWorktreePath) };
+    } catch (err) {
+      return { worktrees: [], error: err instanceof Error ? err.message : String(err) };
+    }
+  }
 };
 function parseWorktreeList(output, currentPath) {
-  const foldedCurrent = normalizePathForCompare(currentPath);
+  const foldedCurrent = currentPath ? normalizePathForCompare(currentPath) : null;
   const results = [];
   for (const wt of parseWorktreeListPorcelain(output)) {
     const resolved = path9.resolve(wt.path);
@@ -3789,7 +3855,7 @@ function parseWorktreeList(output, currentPath) {
     results.push({
       path: resolved,
       branch,
-      isCurrent: normalizePathForCompare(resolved) === foldedCurrent
+      isCurrent: foldedCurrent !== null && normalizePathForCompare(resolved) === foldedCurrent
     });
   }
   return results;
@@ -3802,6 +3868,14 @@ async function safeMtimeMs(filePath) {
     return null;
   }
 }
+async function isDirectory(filePath) {
+  try {
+    const stat4 = await fs7.stat(filePath);
+    return stat4.isDirectory();
+  } catch {
+    return false;
+  }
+}
 async function findWorktreeRoot(startPath) {
   let current = path9.resolve(startPath);
   const root = path9.parse(current).root;
@@ -4001,21 +4075,11 @@ function ensureCapability(discovered, key, toolName) {
     throw new CapabilityUnavailableError(toolName, reasons);
   }
 }
-async function ensureNotSyncing(ctx, repoName) {
-  const entry = ctx.getEntry(repoName);
-  if (!entry?.service) return;
-  if (entry.service.isSyncInProgress()) {
-    throw new SyncInProgressError(entry.name);
-  }
-}
 async function getReadyService(ctx, repoName, options = {}) {
   const discovered = ctx.getDiscoveredContext(repoName);
   if (options.capability && options.toolName) {
     ensureCapability(discovered, options.capability, options.toolName);
   }
-  if (options.ensureNotSyncing) {
-    await ensureNotSyncing(ctx, repoName);
-  }
   const service = await ctx.getService(repoName);
   if (options.ensureInitialized && !service.isInitialized()) {
     await service.initialize();
@@ -4026,6 +4090,14 @@ async function getReadyService(ctx, repoName, options = {}) {
     git: service.getGitService()
   };
 }
+async function runExclusiveRepoOperation(ctx, repoName, service, operation) {
+  const result = await service.runExclusiveRepoOperation(operation);
+  if (!result.started) {
+    const name = ctx.getEntry(repoName)?.name ?? repoName ?? "unknown";
+    throw new SyncInProgressError(name);
+  }
+  return result.value;
+}
 async function ensureRepoWorktreePath(ctx, params, git) {
   await ensurePathBelongsToRepo(ctx, params.path, params.repoName, git);
   return path10.resolve(params.path);
@@ -4046,13 +4118,38 @@ async function ensurePathBelongsToRepo(ctx, targetPath, repoName, git) {
 async function handleDetectContext(ctx, params, _extra) {
   const target = params.path ?? process.cwd();
   const discovered = await ctx.detectFromPath(target);
-  if (!params.includeStatus || discovered.allWorktrees.length === 0) {
-    return formatToolResponse(discovered);
+  let response = discovered;
+  if (params.includeAllWorktrees) {
+    const details = await ctx.getAllConfiguredWorktreeDetails(discovered.currentWorktreePath);
+    const errorsByRepo = Object.keys(details.errorsByRepo).length > 0 ? details.errorsByRepo : void 0;
+    response = {
+      ...response,
+      allWorktreesByRepo: details.worktreesByRepo,
+      allWorktreeErrorsByRepo: errorsByRepo
+    };
+  }
+  if (!params.includeStatus) {
+    return formatToolResponse(response);
   }
   const statusService = new WorktreeStatusService();
-  const limit = pLimit2(DEFAULT_CONFIG.PARALLELISM.MAX_STATUS_CHECKS);
-  const enriched = await Promise.all(
-    discovered.allWorktrees.map(
+  const statusLimit = pLimit2(DEFAULT_CONFIG.PARALLELISM.MAX_STATUS_CHECKS);
+  const enriched = await enrichDetectedWorktrees(response.allWorktrees, statusService, statusLimit);
+  let allWorktreesByRepo = response.allWorktreesByRepo;
+  if (allWorktreesByRepo) {
+    const entries = await Promise.all(
+      Object.entries(allWorktreesByRepo).map(async ([repoName, worktrees]) => [
+        repoName,
+        await enrichDetectedWorktrees(worktrees, statusService, statusLimit)
+      ])
+    );
+    allWorktreesByRepo = Object.fromEntries(entries);
+  }
+  return formatToolResponse({ ...response, allWorktrees: enriched, allWorktreesByRepo });
+}
+async function enrichDetectedWorktrees(worktrees, statusService, limit) {
+  if (worktrees.length === 0) return worktrees;
+  return Promise.all(
+    worktrees.map(
       (wt) => limit(async () => {
         const [status, divergence] = await Promise.all([
           statusService.getFullWorktreeStatus(wt.path, false).catch(() => null),
@@ -4067,10 +4164,41 @@ async function handleDetectContext(ctx, params, _extra) {
       })
     )
   );
-  return formatToolResponse({ ...discovered, allWorktrees: enriched });
 }
 async function handleListWorktrees(ctx, params, _extra) {
-  const { discovered, git } = await getReadyService(ctx, params.repoName, {
+  const configuredRepoNames = params.repoName ? [] : ctx.getConfiguredRepositoryNames();
+  if (configuredRepoNames.length > 0) {
+    const limit = pLimit2(DEFAULT_CONFIG.PARALLELISM.MAX_REPOSITORIES);
+    const statusLimit = pLimit2(DEFAULT_CONFIG.PARALLELISM.MAX_STATUS_CHECKS);
+    const repositories = await Promise.all(
+      configuredRepoNames.map(
+        (repoName) => limit(async () => {
+          try {
+            return [
+              repoName,
+              {
+                worktrees: await listWorktreesForRepo(ctx, repoName, params.includeSize, statusLimit)
+              }
+            ];
+          } catch (err) {
+            return [
+              repoName,
+              {
+                worktrees: [],
+                error: err instanceof Error ? err.message : String(err)
+              }
+            ];
+          }
+        })
+      )
+    );
+    return formatToolResponse({ repositories: Object.fromEntries(repositories) });
+  }
+  const results = await listWorktreesForRepo(ctx, params.repoName, params.includeSize);
+  return formatToolResponse({ worktrees: results });
+}
+async function listWorktreesForRepo(ctx, repoName, includeSize, limit = pLimit2(DEFAULT_CONFIG.PARALLELISM.MAX_STATUS_CHECKS)) {
+  const { discovered, git } = await getReadyService(ctx, repoName, {
     capability: "listWorktrees",
     toolName: "list_worktrees"
   });
@@ -4085,7 +4213,6 @@ async function handleListWorktrees(ctx, params, _extra) {
     }
   }
   const currentPath = discovered?.currentWorktreePath ?? null;
-  const limit = pLimit2(DEFAULT_CONFIG.PARALLELISM.MAX_STATUS_CHECKS);
   const results = await Promise.all(
     worktrees.map(
       (wt) => limit(async () => {
@@ -4095,7 +4222,7 @@ async function handleListWorktrees(ctx, params, _extra) {
           git.getFullWorktreeStatus(wt.path, false).catch(() => null),
           getDivergence(wt.path),
           git.getWorktreeMetadata(wt.path).catch(() => null),
-          params.includeSize ? calculateDirectorySize(wt.path).catch(() => null) : Promise.resolve(null)
+          includeSize ? calculateDirectorySize(wt.path).catch(() => null) : Promise.resolve(null)
         ]);
         return {
           path: resolvedPath,
@@ -4111,7 +4238,7 @@ async function handleListWorktrees(ctx, params, _extra) {
       })
     )
   );
-  return formatToolResponse({ worktrees: results });
+  return results;
 }
 async function handleGetWorktreeStatus(ctx, params, _extra) {
   const { git } = await getReadyService(ctx, params.repoName, {
@@ -4130,76 +4257,82 @@ async function handleGetWorktreeStatus(ctx, params, _extra) {
   });
 }
 async function handleCreateWorktree(ctx, params, _extra) {
-  const { branchName, baseBranch, push } = params;
+  const { branchName, baseBranch } = params;
+  const push = params.push ?? true;
   const validation = isValidGitBranchName(branchName);
   if (!validation.valid) {
     throw new Error(`Invalid branch name '${branchName}': ${validation.error}`);
   }
   const { service, git } = await getReadyService(ctx, params.repoName, {
     capability: "createWorktree",
-    toolName: "create_worktree",
-    ensureInitialized: true,
-    ensureNotSyncing: true
+    toolName: "create_worktree"
   });
-  const existence = await git.branchExists(branchName);
-  let created = false;
-  let pushed = false;
-  if (!existence.local && !existence.remote) {
-    if (!baseBranch) {
-      throw new Error(`Branch '${branchName}' does not exist. Provide 'baseBranch' to create it.`);
-    }
-    await git.createBranch(branchName, baseBranch);
-    created = true;
-  }
-  const worktreeDir = service.config.worktreeDir;
-  const worktreePath = pathResolution.getBranchWorktreePath(worktreeDir, branchName);
-  const existing = await git.getWorktrees();
-  const collision = existing.find((w) => pathsEqual(w.path, worktreePath) && w.branch !== branchName);
-  if (collision) {
-    throw new Error(
-      `Sanitized worktree path '${worktreePath}' collides with existing branch '${collision.branch}'. Rename or remove the conflicting branch first.`
-    );
-  }
-  await git.addWorktree(branchName, worktreePath);
-  ctx.invalidateDiscovered();
-  if (created && push) {
-    await git.pushBranch(branchName);
-    pushed = true;
-  }
-  return formatToolResponse({
-    success: true,
-    branchName,
-    worktreePath: path10.resolve(worktreePath),
-    created,
-    pushed
+  return runExclusiveRepoOperation(ctx, params.repoName, service, async () => {
+    if (!service.isInitialized()) {
+      await service.initialize();
+    }
+    const existence = await git.branchExists(branchName);
+    let created = false;
+    let pushed = false;
+    if (!existence.local && !existence.remote) {
+      if (!baseBranch) {
+        throw new Error(`Branch '${branchName}' does not exist. Provide 'baseBranch' to create it.`);
+      }
+      await git.createBranch(branchName, baseBranch);
+      created = true;
+    }
+    const worktreeDir = service.config.worktreeDir;
+    const worktreePath = pathResolution.getBranchWorktreePath(worktreeDir, branchName);
+    const existing = await git.getWorktrees();
+    const collision = existing.find((w) => pathsEqual(w.path, worktreePath) && w.branch !== branchName);
+    if (collision) {
+      throw new Error(
+        `Sanitized worktree path '${worktreePath}' collides with existing branch '${collision.branch}'. Rename or remove the conflicting branch first.`
+      );
+    }
+    await git.addWorktree(branchName, worktreePath);
+    ctx.invalidateDiscovered();
+    if (created && push) {
+      await git.pushBranch(branchName);
+      pushed = true;
+    }
+    return formatToolResponse({
+      success: true,
+      branchName,
+      worktreePath: path10.resolve(worktreePath),
+      created,
+      pushed
+    });
   });
 }
 async function handleRemoveWorktree(ctx, params, _extra) {
-  const { git } = await getReadyService(ctx, params.repoName, {
+  const { service, git } = await getReadyService(ctx, params.repoName, {
     capability: "removeWorktree",
-    toolName: "remove_worktree",
-    ensureInitialized: true,
-    ensureNotSyncing: true
+    toolName: "remove_worktree"
   });
-  const removedPath = await ensureRepoWorktreePath(ctx, params, git);
-  if (!params.force) {
-    const status = await git.getFullWorktreeStatus(params.path, false);
-    if (!status.canRemove) {
-      throw new Error(`Cannot remove worktree: ${status.reasons.join(", ")}. Use force=true to override.`);
+  return runExclusiveRepoOperation(ctx, params.repoName, service, async () => {
+    if (!service.isInitialized()) {
+      await service.initialize();
     }
-  }
-  await git.removeWorktree(params.path);
-  ctx.invalidateDiscovered();
-  return formatToolResponse({
-    success: true,
-    removedPath
+    const removedPath = await ensureRepoWorktreePath(ctx, params, git);
+    if (!params.force) {
+      const status = await git.getFullWorktreeStatus(params.path, false);
+      if (!status.canRemove) {
+        throw new Error(`Cannot remove worktree: ${status.reasons.join(", ")}. Use force=true to override.`);
+      }
+    }
+    await git.removeWorktree(params.path);
+    ctx.invalidateDiscovered();
+    return formatToolResponse({
+      success: true,
+      removedPath
+    });
   });
 }
 async function handleSync(ctx, params, extra) {
   const { service } = await getReadyService(ctx, params.repoName, {
     capability: "sync",
-    toolName: "sync",
-    ensureInitialized: true
+    toolName: "sync"
   });
   const dispose = attachProgressReporter(service, extra);
   try {
@@ -4216,35 +4349,39 @@ async function handleSync(ctx, params, extra) {
   }
 }
 async function handleUpdateWorktree(ctx, params, _extra) {
-  const { git } = await getReadyService(ctx, params.repoName, {
+  const { service, git } = await getReadyService(ctx, params.repoName, {
     capability: "updateWorktree",
-    toolName: "update_worktree",
-    ensureInitialized: true,
-    ensureNotSyncing: true
+    toolName: "update_worktree"
   });
-  const worktreePath = await ensureRepoWorktreePath(ctx, params, git);
-  await git.updateWorktree(params.path);
-  ctx.invalidateDiscovered();
-  return formatToolResponse({
-    success: true,
-    worktreePath
+  return runExclusiveRepoOperation(ctx, params.repoName, service, async () => {
+    if (!service.isInitialized()) {
+      await service.initialize();
+    }
+    const worktreePath = await ensureRepoWorktreePath(ctx, params, git);
+    await git.updateWorktree(params.path);
+    ctx.invalidateDiscovered();
+    return formatToolResponse({
+      success: true,
+      worktreePath
+    });
   });
 }
 async function handleInitialize(ctx, params, extra) {
   const { service } = await getReadyService(ctx, params.repoName, {
     capability: "initialize",
-    toolName: "initialize",
-    ensureNotSyncing: true
+    toolName: "initialize"
   });
   const dispose = attachProgressReporter(service, extra);
   try {
-    await service.initialize();
-    const git = service.getGitService();
-    ctx.invalidateDiscovered();
-    return formatToolResponse({
-      success: true,
-      defaultBranch: git.getDefaultBranch(),
-      worktreeDir: service.config.worktreeDir
+    return await runExclusiveRepoOperation(ctx, params.repoName, service, async () => {
+      await service.initialize();
+      const git = service.getGitService();
+      ctx.invalidateDiscovered();
+      return formatToolResponse({
+        success: true,
+        defaultBranch: git.getDefaultBranch(),
+        worktreeDir: service.config.worktreeDir
+      });
     });
   } finally {
     dispose();
@@ -4294,7 +4431,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, 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.";
+var SERVER_INSTRUCTIONS = "Before running git worktree operations, call `detect_context` with `includeAllWorktrees: true` at session start to learn every configured repository and worktree, plus the current repo, current branch, sibling repositories, and available capabilities. It walks up to auto-discover sync-worktrees.config.{js,mjs,cjs,ts}, reports config-driven sibling repositories, 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;
@@ -4346,11 +4483,14 @@ function createServer(context, snapshot) {
   server.registerTool(
     "detect_context",
     {
-      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[].",
+      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 configured sibling repositories. 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."),
+        includeAllWorktrees: z.boolean().optional().describe(
+          "If true, includes allWorktreesByRepo with worktrees for every configured repository, keyed by repoName, and allWorktreeErrorsByRepo for repos that could not be enumerated. Default: false."
+        ),
         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)."
+          "If true, enriches worktree entries with label, divergence, and staleHint. Adds one git status + rev-list per worktree. Default: false (cheap path)."
         )
       },
       annotations: {
@@ -4365,9 +4505,11 @@ function createServer(context, snapshot) {
   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: { safe, reason }, lastSyncAt, sizeBytes }.",
+      description: "List worktrees with enriched status. Without repoName and with a loaded config, returns all configured repositories grouped by repoName. With repoName, returns that single repository. Returns worktree entries as { 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(
+          "Repository name from loaded config. If omitted and a config is loaded, lists all configured repos."
+        ),
         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)."
         )
@@ -4402,13 +4544,13 @@ function createServer(context, snapshot) {
   server.registerTool(
     "create_worktree",
     {
-      description: "Create a worktree for a branch. If the branch exists (local or remote), checks it out; otherwise creates it from baseBranch. Optionally pushes the new branch to origin. Key params: baseBranch is required only when the branch does not yet exist \u2014 pass it defensively if unsure. push=true only affects newly created branches. Preconditions: repository must be initialized (auto-runs on first call). Returns: { success, branchName, worktreePath, created, pushed }.",
+      description: "Create a worktree for a branch. If the branch exists (local or remote), checks it out; otherwise creates it from baseBranch and pushes the new branch to origin by default. Key params: baseBranch is required only when the branch does not yet exist \u2014 pass it defensively if unsure. push=false opts out for newly created branches. Preconditions: repository must be initialized (auto-runs on first call). Returns: { success, branchName, worktreePath, created, pushed }.",
       inputSchema: {
         branchName: z.string().describe("Branch name. Slashes and special chars are sanitized for the worktree directory name."),
         baseBranch: z.string().optional().describe(
           "Base branch for creating a new branch. Required if branchName does not exist locally or remotely; ignored otherwise."
         ),
-        push: z.boolean().optional().describe("Push the newly created branch to origin. Ignored if the branch already existed."),
+        push: z.boolean().optional().describe("Push the newly created branch to origin. Default: true. Ignored if the branch already existed."),
         repoName: z.string().optional().describe(REPO_NAME_DESCRIBE)
       },
       annotations: {
@@ -4497,7 +4639,7 @@ function createServer(context, snapshot) {
   server.registerTool(
     "load_config",
     {
-      description: "Load or reload a sync-worktrees JavaScript config file into the server's session. Replaces any previously loaded repositories. Call this before sync/initialize/create_worktree when using a config-driven workflow. Returns: { configPath, currentRepository, repositories: [{ name, repoPath, worktreeDir, ... }] }.",
+      description: "Load or reload a sync-worktrees JavaScript config file into the server's session. Replaces any previously loaded repositories. Call this before sync/initialize/create_worktree when using a config-driven workflow. Returns: { configPath, currentRepository, repositories: [{ name, repoUrl, worktreeDir, source }] }.",
       inputSchema: {
         configPath: z.string().optional().describe(
           "Path to the config file. If omitted, falls back to the SYNC_WORKTREES_CONFIG env var. Errors if neither is set."