sync-worktrees 3.6.2 → 4.0.0

package/dist/mcp-server.js

@@ -4,9 +4,10 @@
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 
 // src/mcp/context.ts
-import * as fs7 from "fs/promises";
-import * as path9 from "path";
-import simpleGit5 from "simple-git";
+import * as fs10 from "fs/promises";
+import * as path14 from "path";
+import pLimit2 from "p-limit";
+import simpleGit6 from "simple-git";
 
 // src/constants.ts
 var GIT_CONSTANTS = {
@@ -89,7 +90,8 @@ var ENV_CONSTANTS = {
 };
 var PATH_CONSTANTS = {
   GIT_DIR: ".git",
-  README: "README"
+  README: "README",
+  CLONE_INIT_MARKER: ".sync-worktrees-clone-init"
 };
 var CONFIG_FILE_NAMES = [
   "sync-worktrees.config.js",
@@ -108,11 +110,65 @@ var METADATA_CONSTANTS = {
 };
 
 // src/services/config-loader.service.ts
-import * as fs from "fs/promises";
 import * as path2 from "path";
 import { pathToFileURL } from "url";
 import * as cron from "node-cron";
 
+// 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(path16, reasons) {
+    super(`Worktree at '${path16}' is not clean: ${reasons.join(", ")}`, "NOT_CLEAN");
+    this.path = path16;
+    this.reasons = reasons;
+  }
+};
+var ConfigError = class extends SyncWorktreesError {
+  constructor(message, code, cause) {
+    super(message, `CONFIG_${code}`, cause);
+  }
+};
+var ConfigValidationError = class extends ConfigError {
+  constructor(field, reason) {
+    super(`Invalid configuration for '${field}': ${reason}`, "VALIDATION_FAILED");
+    this.field = field;
+    this.reason = reason;
+  }
+};
+var ConfigFileNotFoundError = class extends ConfigError {
+  constructor(configPath) {
+    super(`Config file not found: ${configPath}`, "FILE_NOT_FOUND");
+    this.configPath = configPath;
+  }
+};
+
 // src/utils/branch-filter.ts
 function matchesPattern(name, pattern) {
   if (pattern.includes("*")) {
@@ -133,6 +189,17 @@ function filterBranchesByName(branches, include, exclude) {
   return result;
 }
 
+// src/utils/file-exists.ts
+import * as fs from "fs/promises";
+async function fileExists(path16) {
+  try {
+    await fs.access(path16);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
 // src/utils/git-url.ts
 function extractRepoNameFromUrl(gitUrl) {
   const url = gitUrl.trim();
@@ -158,6 +225,16 @@ function getDefaultBareRepoDir(repoUrl, baseDir = ".bare") {
   const repoName = extractRepoNameFromUrl(repoUrl);
   return `${baseDir}/${repoName}`;
 }
+function normalizeRepoUrlForComparison(url) {
+  let normalized = url.trim();
+  const isForgeUrl = /^(https?|ssh|git):\/\//i.test(normalized) || /^[\w.-]+@[^/]+:/.test(normalized);
+  normalized = normalized.replace(/^[a-zA-Z][a-zA-Z0-9+.-]*:\/\/[^/]+/, (prefix) => prefix.toLowerCase());
+  normalized = normalized.replace(/\/+$/, "");
+  if (isForgeUrl) {
+    normalized = normalized.replace(/\.git$/, "");
+  }
+  return normalized;
+}
 
 // src/utils/path-compare.ts
 import * as path from "path";
@@ -173,54 +250,17 @@ function pathsEqual(a, b, platform = process.platform) {
   return normalizePathForCompare(a, platform) === normalizePathForCompare(b, platform);
 }
 
-// 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(path11, reasons) {
-    super(`Worktree at '${path11}' is not clean: ${reasons.join(", ")}`, "NOT_CLEAN");
-    this.path = path11;
-    this.reasons = reasons;
-  }
-};
-var ConfigError = class extends SyncWorktreesError {
-  constructor(message, code, cause) {
-    super(message, `CONFIG_${code}`, cause);
-  }
-};
-var ConfigValidationError = class extends ConfigError {
-  constructor(field, reason) {
-    super(`Invalid configuration for '${field}': ${reason}`, "VALIDATION_FAILED");
-    this.field = field;
-    this.reason = reason;
-  }
+// src/utils/repo-mode.ts
+var REPOSITORY_MODES = {
+  CLONE: "clone",
+  WORKTREE: "worktree"
 };
+function isRepositoryMode(value) {
+  return value === REPOSITORY_MODES.CLONE || value === REPOSITORY_MODES.WORKTREE;
+}
+function resolveMode(cfg) {
+  return cfg.mode ?? REPOSITORY_MODES.WORKTREE;
+}
 
 // src/utils/sanitize-name.ts
 var WINDOWS_RESERVED = /^(con|prn|aux|nul|com[1-9]|lpt[1-9])$/i;
@@ -244,6 +284,13 @@ function sanitizeNameForPath(name, fieldContext = "name") {
 }
 
 // src/services/config-loader.service.ts
+var CLONE_MODE_CONFLICTING_FIELDS = [
+  "branchInclude",
+  "branchExclude",
+  "branchMaxAge",
+  "updateExistingWorktrees",
+  "bareRepoDir"
+];
 var ConfigLoaderService = class {
   async findConfigUpward(startDir) {
     let current = path2.resolve(startDir);
@@ -251,10 +298,8 @@ var ConfigLoaderService = class {
     while (true) {
       for (const name of CONFIG_FILE_NAMES) {
         const candidate = path2.join(current, name);
-        try {
-          await fs.access(candidate);
+        if (await fileExists(candidate)) {
           return candidate;
-        } catch {
         }
       }
       if (current === root) return null;
@@ -265,10 +310,8 @@ var ConfigLoaderService = class {
   }
   async loadConfigFile(configPath) {
     const absolutePath = path2.resolve(configPath);
-    try {
-      await fs.access(absolutePath);
-    } catch {
-      throw new Error(`Config file not found: ${absolutePath}`);
+    if (!await fileExists(absolutePath)) {
+      throw new ConfigFileNotFoundError(absolutePath);
     }
     try {
       const fileUrl = pathToFileURL(absolutePath);
@@ -281,7 +324,7 @@ var ConfigLoaderService = class {
       this.validateConfigFile(config);
       return config;
     } catch (error) {
-      if (error instanceof Error && error.message.includes("Config file not found")) {
+      if (error instanceof SyncWorktreesError) {
         throw error;
       }
       throw new Error(`Failed to load config file: ${error.message}`);
@@ -334,6 +377,12 @@ var ConfigLoaderService = class {
       if (repoObj.runOnce !== void 0 && typeof repoObj.runOnce !== "boolean") {
         throw new Error(`Repository '${repoObj.name}' has invalid 'runOnce' property`);
       }
+      if (repoObj.debug !== void 0 && typeof repoObj.debug !== "boolean") {
+        throw new Error(`Repository '${repoObj.name}' has invalid 'debug' property`);
+      }
+      if (repoObj.retry !== void 0) {
+        this.validateRetryConfig(repoObj.retry, `Repository '${repoObj.name}' retry config`);
+      }
       if (repoObj.filesToCopyOnBranchCreate !== void 0) {
         this.validateFilesToCopyConfig(repoObj.filesToCopyOnBranchCreate, `Repository '${repoObj.name}'`);
       }
@@ -343,6 +392,8 @@ var ConfigLoaderService = class {
       if (repoObj.sparseCheckout !== void 0) {
         this.validateSparseCheckoutConfig(repoObj.sparseCheckout, `Repository '${repoObj.name}'`);
       }
+      this.validateDepth(repoObj.depth, `Repository '${repoObj.name}' depth`);
+      this.validateRepositoryMode(repoObj, configObj.defaults);
     });
     this.warnOnDuplicateRepoUrls(configObj.repositories);
     if (configObj.defaults) {
@@ -359,9 +410,15 @@ var ConfigLoaderService = class {
       if (defaults.runOnce !== void 0 && typeof defaults.runOnce !== "boolean") {
         throw new Error("Invalid 'runOnce' in defaults");
       }
+      if (defaults.debug !== void 0 && typeof defaults.debug !== "boolean") {
+        throw new Error("Invalid 'debug' in defaults");
+      }
       if (defaults.retry !== void 0 && typeof defaults.retry !== "object") {
         throw new Error("Invalid 'retry' in defaults");
       }
+      if (defaults.retry !== void 0) {
+        this.validateRetryConfig(defaults.retry, "defaults retry config");
+      }
       if (defaults.filesToCopyOnBranchCreate !== void 0) {
         this.validateFilesToCopyConfig(defaults.filesToCopyOnBranchCreate, "defaults");
       }
@@ -371,39 +428,17 @@ var ConfigLoaderService = class {
       if (defaults.sparseCheckout !== void 0) {
         this.validateSparseCheckoutConfig(defaults.sparseCheckout, "defaults");
       }
-    }
-    if (configObj.retry !== void 0) {
-      if (typeof configObj.retry !== "object") {
-        throw new Error("'retry' must be an object");
-      }
-      const retry2 = configObj.retry;
-      if (retry2.maxAttempts !== void 0) {
-        if (retry2.maxAttempts !== "unlimited" && (typeof retry2.maxAttempts !== "number" || retry2.maxAttempts < 1)) {
-          throw new Error("Invalid 'maxAttempts' in retry config. Must be 'unlimited' or a positive number");
-        }
-      }
-      if (retry2.maxLfsRetries !== void 0) {
-        if (typeof retry2.maxLfsRetries !== "number" || retry2.maxLfsRetries < 0) {
-          throw new Error("Invalid 'maxLfsRetries' in retry config. Must be a non-negative number");
-        }
-      }
-      if (retry2.initialDelayMs !== void 0 && (typeof retry2.initialDelayMs !== "number" || retry2.initialDelayMs < 0)) {
-        throw new Error("Invalid 'initialDelayMs' in retry config");
-      }
-      if (retry2.maxDelayMs !== void 0 && (typeof retry2.maxDelayMs !== "number" || retry2.maxDelayMs < 0)) {
-        throw new Error("Invalid 'maxDelayMs' in retry config");
+      this.validateDepth(defaults.depth, "defaults.depth");
+      if (defaults.mode !== void 0 && !isRepositoryMode(defaults.mode)) {
+        throw new ConfigValidationError("defaults.mode", "must be 'clone' or 'worktree'");
       }
-      if (retry2.backoffMultiplier !== void 0 && (typeof retry2.backoffMultiplier !== "number" || retry2.backoffMultiplier < 1)) {
-        throw new Error("Invalid 'backoffMultiplier' in retry config");
-      }
-      const initialDelay = retry2.initialDelayMs ?? DEFAULT_CONFIG.RETRY.INITIAL_DELAY_MS;
-      const maxDelay = retry2.maxDelayMs ?? DEFAULT_CONFIG.RETRY.MAX_DELAY_MS;
-      if (initialDelay > maxDelay) {
-        throw new Error(
-          `Invalid retry config: 'initialDelayMs' (${initialDelay}) must not exceed 'maxDelayMs' (${maxDelay})`
-        );
+      if (defaults.branch !== void 0 && (typeof defaults.branch !== "string" || defaults.branch.trim() === "")) {
+        throw new ConfigValidationError("defaults.branch", "must be a non-empty string");
       }
     }
+    if (configObj.retry !== void 0) {
+      this.validateRetryConfig(configObj.retry, "retry config");
+    }
     if (configObj.parallelism !== void 0) {
       this.validateParallelismConfig(configObj.parallelism, "global");
     }
@@ -414,6 +449,47 @@ var ConfigLoaderService = class {
       }
     }
   }
+  validateDepth(value, field) {
+    if (value === void 0) return;
+    if (typeof value !== "number" || !Number.isSafeInteger(value) || value <= 0) {
+      throw new ConfigValidationError(field, "must be a positive safe integer");
+    }
+  }
+  validateRetryConfig(value, context) {
+    if (typeof value !== "object" || value === null) {
+      throw new Error(context === "retry config" ? "'retry' must be an object" : `Invalid 'retry' in ${context}`);
+    }
+    const retry2 = value;
+    if (retry2.maxAttempts !== void 0) {
+      if (retry2.maxAttempts !== "unlimited" && (typeof retry2.maxAttempts !== "number" || retry2.maxAttempts < 1)) {
+        throw new Error("Invalid 'maxAttempts' in retry config. Must be 'unlimited' or a positive number");
+      }
+    }
+    if (retry2.maxLfsRetries !== void 0) {
+      if (typeof retry2.maxLfsRetries !== "number" || retry2.maxLfsRetries < 0) {
+        throw new Error("Invalid 'maxLfsRetries' in retry config. Must be a non-negative number");
+      }
+    }
+    if (retry2.initialDelayMs !== void 0 && (typeof retry2.initialDelayMs !== "number" || retry2.initialDelayMs < 0)) {
+      throw new Error("Invalid 'initialDelayMs' in retry config");
+    }
+    if (retry2.maxDelayMs !== void 0 && (typeof retry2.maxDelayMs !== "number" || retry2.maxDelayMs < 0)) {
+      throw new Error("Invalid 'maxDelayMs' in retry config");
+    }
+    if (retry2.backoffMultiplier !== void 0 && (typeof retry2.backoffMultiplier !== "number" || retry2.backoffMultiplier < 1)) {
+      throw new Error("Invalid 'backoffMultiplier' in retry config");
+    }
+    if (retry2.jitterMs !== void 0 && (typeof retry2.jitterMs !== "number" || retry2.jitterMs < 0)) {
+      throw new Error("Invalid 'jitterMs' in retry config");
+    }
+    const initialDelay = retry2.initialDelayMs ?? DEFAULT_CONFIG.RETRY.INITIAL_DELAY_MS;
+    const maxDelay = retry2.maxDelayMs ?? DEFAULT_CONFIG.RETRY.MAX_DELAY_MS;
+    if (initialDelay > maxDelay) {
+      throw new Error(
+        `Invalid retry config: 'initialDelayMs' (${initialDelay}) must not exceed 'maxDelayMs' (${maxDelay})`
+      );
+    }
+  }
   validateParallelismConfig(parallelism, context) {
     if (typeof parallelism !== "object" || parallelism === null) {
       throw new Error(`'parallelism' in ${context} must be an object`);
@@ -514,6 +590,50 @@ var ConfigLoaderService = class {
       }
     }
   }
+  validateRepositoryMode(repoObj, defaults) {
+    const repoName = repoObj.name;
+    const repoMode = repoObj.mode;
+    if (repoMode !== void 0 && !isRepositoryMode(repoMode)) {
+      throw new ConfigValidationError(`Repository '${repoName}' mode`, "must be 'clone' or 'worktree'");
+    }
+    if (repoObj.branch !== void 0 && (typeof repoObj.branch !== "string" || repoObj.branch.trim() === "")) {
+      throw new ConfigValidationError(`Repository '${repoName}' branch`, "must be a non-empty string");
+    }
+    const effectiveMode = repoMode ?? defaults?.mode;
+    if (effectiveMode !== REPOSITORY_MODES.CLONE) {
+      const depthFromRepo = repoObj.depth;
+      const depthFromDefaults = defaults?.depth;
+      if (depthFromRepo !== void 0 || depthFromDefaults !== void 0) {
+        const source = depthFromRepo !== void 0 ? "repository" : "defaults";
+        throw new ConfigValidationError(
+          `Repository '${repoName}' depth`,
+          `only supported when mode is 'clone' (set on ${source})`
+        );
+      }
+      const branchFromRepo = repoObj.branch;
+      const branchFromDefaults = defaults?.branch;
+      if (branchFromRepo !== void 0 || branchFromDefaults !== void 0) {
+        const source = branchFromRepo !== void 0 ? "repository" : "defaults";
+        throw new ConfigValidationError(
+          `Repository '${repoName}' branch`,
+          `only supported when mode is 'clone' (set on ${source})`
+        );
+      }
+      return;
+    }
+    for (const field of CLONE_MODE_CONFLICTING_FIELDS) {
+      const fromRepo = repoObj[field];
+      const fromDefaults = defaults?.[field];
+      const present = fromRepo !== void 0 || fromDefaults !== void 0;
+      if (present) {
+        const source = fromRepo !== void 0 ? "repository" : "defaults";
+        throw new ConfigValidationError(
+          `Repository '${repoName}' ${field}`,
+          `not supported when mode is 'clone' (set on ${source})`
+        );
+      }
+    }
+  }
   validateHooksConfig(hooks, context) {
     if (typeof hooks !== "object" || hooks === null) {
       throw new Error(`'hooks' in ${context} must be an object`);
@@ -534,29 +654,47 @@ var ConfigLoaderService = class {
     }
   }
   resolveRepositoryConfig(repo, defaults, configDir, globalRetry, allRepositories) {
+    const mode = repo.mode ?? defaults?.mode ?? REPOSITORY_MODES.WORKTREE;
     const resolved = {
       name: repo.name,
       repoUrl: repo.repoUrl,
       worktreeDir: this.resolvePath(repo.worktreeDir, configDir),
       cronSchedule: repo.cronSchedule ?? defaults?.cronSchedule ?? DEFAULT_CONFIG.CRON_SCHEDULE,
-      runOnce: repo.runOnce ?? defaults?.runOnce ?? false
+      runOnce: repo.runOnce ?? defaults?.runOnce ?? false,
+      debug: repo.debug ?? defaults?.debug,
+      mode
     };
-    if (repo.bareRepoDir) {
-      resolved.bareRepoDir = this.resolvePath(repo.bareRepoDir, configDir);
-    } else if (allRepositories && this.isDuplicateRepoUrl(repo, allRepositories)) {
-      const sanitized = sanitizeNameForPath(repo.name, `Repository '${repo.name}' name`);
-      resolved.bareRepoDir = this.resolvePath(`.bare/${sanitized}`, configDir);
-    } else {
-      resolved.bareRepoDir = this.resolvePath(getDefaultBareRepoDir(repo.repoUrl), configDir);
+    if (configDir) {
+      resolved.__configFileDir = configDir;
     }
-    if (repo.branchMaxAge || defaults?.branchMaxAge) {
-      resolved.branchMaxAge = repo.branchMaxAge ?? defaults?.branchMaxAge;
-    }
-    if (repo.branchInclude || defaults?.branchInclude) {
-      resolved.branchInclude = repo.branchInclude ?? defaults?.branchInclude;
-    }
-    if (repo.branchExclude || defaults?.branchExclude) {
-      resolved.branchExclude = repo.branchExclude ?? defaults?.branchExclude;
+    if (mode === REPOSITORY_MODES.CLONE) {
+      if (repo.branch ?? defaults?.branch) {
+        resolved.branch = repo.branch ?? defaults?.branch;
+      }
+      if (repo.depth !== void 0 || defaults?.depth !== void 0) {
+        resolved.depth = repo.depth ?? defaults?.depth;
+      }
+    } else {
+      if (repo.bareRepoDir) {
+        resolved.bareRepoDir = this.resolvePath(repo.bareRepoDir, configDir);
+      } else if (allRepositories && this.isDuplicateRepoUrl(repo, allRepositories, defaults)) {
+        const sanitized = sanitizeNameForPath(repo.name, `Repository '${repo.name}' name`);
+        resolved.bareRepoDir = this.resolvePath(`.bare/${sanitized}`, configDir);
+      } else {
+        resolved.bareRepoDir = this.resolvePath(getDefaultBareRepoDir(repo.repoUrl), configDir);
+      }
+      if (repo.branchMaxAge || defaults?.branchMaxAge) {
+        resolved.branchMaxAge = repo.branchMaxAge ?? defaults?.branchMaxAge;
+      }
+      if (repo.branchInclude || defaults?.branchInclude) {
+        resolved.branchInclude = repo.branchInclude ?? defaults?.branchInclude;
+      }
+      if (repo.branchExclude || defaults?.branchExclude) {
+        resolved.branchExclude = repo.branchExclude ?? defaults?.branchExclude;
+      }
+      if (repo.updateExistingWorktrees !== void 0 || defaults?.updateExistingWorktrees !== void 0) {
+        resolved.updateExistingWorktrees = repo.updateExistingWorktrees ?? defaults?.updateExistingWorktrees ?? true;
+      }
     }
     if (repo.skipLfs !== void 0 || defaults?.skipLfs !== void 0) {
       resolved.skipLfs = repo.skipLfs ?? defaults?.skipLfs ?? false;
@@ -574,9 +712,6 @@ var ConfigLoaderService = class {
         ...repo.parallelism || {}
       };
     }
-    if (repo.updateExistingWorktrees !== void 0 || defaults?.updateExistingWorktrees !== void 0) {
-      resolved.updateExistingWorktrees = repo.updateExistingWorktrees ?? defaults?.updateExistingWorktrees ?? true;
-    }
     if (repo.filesToCopyOnBranchCreate || defaults?.filesToCopyOnBranchCreate) {
       const files = repo.filesToCopyOnBranchCreate ?? defaults?.filesToCopyOnBranchCreate;
       resolved.filesToCopyOnBranchCreate = files?.map((f) => this.resolvePath(f, configDir));
@@ -593,8 +728,11 @@ var ConfigLoaderService = class {
     }
     return resolved;
   }
-  isDuplicateRepoUrl(repo, all) {
-    const firstIndex = all.findIndex((r) => r.repoUrl === repo.repoUrl);
+  isDuplicateRepoUrl(repo, all, defaults) {
+    const firstIndex = all.findIndex((r) => {
+      const mode = r.mode ?? defaults?.mode ?? REPOSITORY_MODES.WORKTREE;
+      return r.repoUrl === repo.repoUrl && mode === REPOSITORY_MODES.WORKTREE;
+    });
     const myIndex = all.indexOf(repo);
     return firstIndex !== -1 && myIndex !== -1 && myIndex !== firstIndex;
   }
@@ -645,12 +783,6 @@ var ConfigLoaderService = class {
     if (overrides?.filter) {
       repositories = this.filterRepositories(repositories, overrides.filter);
     }
-    if (overrides?.noUpdateExisting) {
-      repositories = repositories.map((repo) => ({ ...repo, updateExistingWorktrees: false }));
-    }
-    if (overrides?.debug) {
-      repositories = repositories.map((repo) => ({ ...repo, debug: true }));
-    }
     return { repositories, configFile, configDir };
   }
 };
@@ -754,60 +886,6 @@ function defaultConsoleOutput(msg, level) {
   else console.log(msg);
 }
 
-// src/services/worktree-sync.service.ts
-import * as fs6 from "fs/promises";
-import * as path8 from "path";
-import pLimit from "p-limit";
-import * as lockfile from "proper-lockfile";
-
-// src/utils/date-filter.ts
-function parseDuration(durationStr) {
-  const match = durationStr.match(/^(\d+)([hdwmy])$/);
-  if (!match) {
-    return null;
-  }
-  const value = parseInt(match[1], 10);
-  const unit = match[2];
-  const multipliers = {
-    h: 60 * 60 * 1e3,
-    // hours
-    d: 24 * 60 * 60 * 1e3,
-    // days
-    w: 7 * 24 * 60 * 60 * 1e3,
-    // weeks
-    m: 30 * 24 * 60 * 60 * 1e3,
-    // months (approximate)
-    y: 365 * 24 * 60 * 60 * 1e3
-    // years (approximate)
-  };
-  return value * multipliers[unit];
-}
-function filterBranchesByAge(branches, maxAge) {
-  const maxAgeMs = parseDuration(maxAge);
-  if (maxAgeMs === null) {
-    console.warn(`Invalid duration format: ${maxAge}. Using all branches.`);
-    return branches;
-  }
-  const cutoffDate = new Date(Date.now() - maxAgeMs);
-  return branches.filter(({ lastActivity }) => lastActivity >= cutoffDate);
-}
-function formatDuration(durationStr) {
-  const match = durationStr.match(/^(\d+)([hdwmy])$/);
-  if (!match) {
-    return durationStr;
-  }
-  const value = parseInt(match[1], 10);
-  const unit = match[2];
-  const unitNames = {
-    h: value === 1 ? "hour" : "hours",
-    d: value === 1 ? "day" : "days",
-    w: value === 1 ? "week" : "weeks",
-    m: value === 1 ? "month" : "months",
-    y: value === 1 ? "year" : "years"
-  };
-  return `${value} ${unitNames[unit]}`;
-}
-
 // src/utils/lfs-error.ts
 function getErrorMessage(error) {
   if (error instanceof Error) {
@@ -829,6 +907,14 @@ function isLfsError(errorMessage) {
 function isLfsErrorFromError(error) {
   return isLfsError(getErrorMessage(error));
 }
+var MISSING_REMOTE_REF_PATTERNS = Object.freeze([
+  "couldn't find remote ref",
+  "Couldn't find remote ref",
+  "not our ref"
+]);
+function isMissingRemoteRefError(errorMessage) {
+  return MISSING_REMOTE_REF_PATTERNS.some((pattern) => errorMessage.includes(pattern));
+}
 
 // src/utils/retry.ts
 var DEFAULT_OPTIONS = {
@@ -900,7 +986,7 @@ async function retry(fn, options = {}) {
       const jitter = opts.jitterMs > 0 ? Math.random() * opts.jitterMs : 0;
       const delay = baseDelay + jitter;
       opts.onRetry(error, attempt, lfsContext);
-      await new Promise((resolve9) => setTimeout(resolve9, delay));
+      await new Promise((resolve11) => setTimeout(resolve11, delay));
       attempt++;
     }
   }
@@ -971,7 +1057,7 @@ var PhaseTimer = class {
     return results;
   }
 };
-function formatDuration2(ms) {
+function formatDuration(ms) {
   if (ms < 1e3) {
     return `${ms}ms`;
   }
@@ -993,7 +1079,7 @@ function formatTimingTable(totalDuration, phaseResults, repoName) {
     }
   });
   table.push([{ colSpan: 3, content: header, hAlign: "center" }]);
-  table.push(["Total Sync", formatDuration2(totalDuration), ""]);
+  table.push(["Total Sync", formatDuration(totalDuration), ""]);
   for (let i = 0; i < phaseResults.length; i++) {
     const result = phaseResults[i];
     const isLast = i === phaseResults.length - 1;
@@ -1001,37 +1087,901 @@ function formatTimingTable(totalDuration, phaseResults, repoName) {
     const prefix = isLast ? "\u2514\u2500" : "\u251C\u2500";
     const name = `  ${prefix} ${result.name}${countStr}`;
     const efficiency = result.efficiency ? `${result.efficiency}%` : "";
-    table.push([name, formatDuration2(result.duration), efficiency]);
+    table.push([name, formatDuration(result.duration), efficiency]);
   }
   return table.toString();
 }
 
-// src/services/git.service.ts
-import * as fs4 from "fs/promises";
-import * as path6 from "path";
-import simpleGit4 from "simple-git";
+// src/services/clone-sync.service.ts
+import * as fs3 from "fs/promises";
+import * as path4 from "path";
+import simpleGit from "simple-git";
 
-// src/utils/worktree-list-parser.ts
-function parseWorktreeListPorcelain(output) {
-  const worktrees = [];
-  let current = {};
-  const flush = () => {
-    if (!current.path) {
-      current = {};
-      return;
-    }
-    worktrees.push({
-      path: current.path,
-      branch: current.branch ?? null,
-      head: current.head ?? null,
-      detached: current.detached ?? false,
-      prunable: current.prunable ?? false,
-      locked: current.locked ?? false
+// src/utils/git-progress.ts
+function makeGitProgressHandler(logger, emitProgress) {
+  const lastBucket = /* @__PURE__ */ new Map();
+  return (event) => {
+    if (event.method !== "fetch" && event.method !== "clone" && event.method !== "pull") return;
+    const key = `${event.method}:${event.stage}`;
+    const bucket = Math.floor(event.progress / GIT_CONSTANTS.PROGRESS_BUCKET_PERCENT);
+    let last = lastBucket.get(key) ?? -1;
+    if (bucket < last) last = -1;
+    if (bucket <= last && event.progress < 100) return;
+    lastBucket.set(key, bucket);
+    const total = event.total > 0 ? `${event.processed}/${event.total}` : `${event.processed}`;
+    const message = `${event.method} ${event.stage}: ${event.progress}% (${total})`;
+    logger.info(`  \u21B3 ${message}`);
+    emitProgress?.({
+      phase: event.method,
+      message,
+      progress: event.progress,
+      processed: event.processed,
+      total: event.total
     });
-    current = {};
   };
-  for (const line of output.split("\n")) {
-    if (line.startsWith("worktree ")) {
+}
+
+// src/services/file-copy.service.ts
+import * as fs2 from "fs/promises";
+import * as path3 from "path";
+import { glob } from "glob";
+var DEFAULT_IGNORE_PATTERNS = [
+  "**/node_modules/**",
+  "**/.git/**",
+  "**/dist/**",
+  "**/build/**",
+  "**/.next/**",
+  "**/coverage/**"
+];
+var FileCopyService = class {
+  /**
+   * Copy files matching patterns from source to destination directory.
+   * Skips files that already exist at destination.
+   * Preserves directory structure relative to source.
+   */
+  async copyFiles(sourceDir, destDir, patterns) {
+    const result = {
+      copied: [],
+      skipped: [],
+      errors: []
+    };
+    if (!patterns || patterns.length === 0) {
+      return result;
+    }
+    const filesToCopy = await this.expandPatterns(sourceDir, patterns);
+    for (const relativePath of filesToCopy) {
+      const sourcePath = path3.join(sourceDir, relativePath);
+      const destPath = path3.join(destDir, relativePath);
+      try {
+        const copied = await this.copyFile(sourcePath, destPath);
+        if (copied) {
+          result.copied.push(relativePath);
+        } else {
+          result.skipped.push(relativePath);
+        }
+      } catch (error) {
+        result.errors.push({
+          file: relativePath,
+          error: error instanceof Error ? error.message : String(error)
+        });
+      }
+    }
+    return result;
+  }
+  async expandPatterns(sourceDir, patterns) {
+    const allFiles = /* @__PURE__ */ new Set();
+    for (const pattern of patterns) {
+      try {
+        const matches = await glob(pattern, {
+          cwd: sourceDir,
+          nodir: true,
+          dot: true,
+          ignore: DEFAULT_IGNORE_PATTERNS
+        });
+        for (const match of matches) {
+          allFiles.add(match);
+        }
+      } catch {
+      }
+    }
+    return Array.from(allFiles);
+  }
+  async copyFile(sourcePath, destPath) {
+    if (await fileExists(destPath)) {
+      return false;
+    }
+    const destDir = path3.dirname(destPath);
+    await fs2.mkdir(destDir, { recursive: true });
+    await fs2.copyFile(sourcePath, destPath);
+    return true;
+  }
+};
+
+// src/services/branch-created-actions.service.ts
+var BranchCreatedActionsService = class {
+  fileCopyService;
+  constructor(fileCopyService) {
+    this.fileCopyService = fileCopyService ?? new FileCopyService();
+  }
+  async copyFiles(params) {
+    const { config, sourceDir, worktreePath, branchName, logger } = params;
+    const patterns = config.filesToCopyOnBranchCreate;
+    if (!patterns?.length) return;
+    try {
+      const result = await this.fileCopyService.copyFiles(sourceDir, worktreePath, patterns);
+      if (result.copied.length > 0) {
+        logger.info(`\u{1F4CB} Copied ${result.copied.length} file(s) to '${branchName}': ${result.copied.join(", ")}`);
+      }
+      if (result.errors.length > 0) {
+        logger.warn(`\u26A0\uFE0F Failed to copy ${result.errors.length} file(s) to '${branchName}':`);
+        for (const err of result.errors) {
+          logger.warn(`  - ${err.file}: ${err.error}`);
+        }
+      }
+    } catch (error) {
+      logger.error(`Failed to copy files to '${branchName}': ${error}`);
+    }
+  }
+  runHooks(params) {
+    const { config, branchName, worktreePath, repoName, baseBranch, logger, hookExecutionService } = params;
+    if (!config.hooks?.onBranchCreated?.length) return;
+    const context = {
+      branchName,
+      worktreePath,
+      repoName,
+      baseBranch,
+      repoUrl: config.repoUrl
+    };
+    logger.info(`Running ${config.hooks.onBranchCreated.length} hook(s) for branch '${branchName}'...`);
+    hookExecutionService.executeOnBranchCreated(config.hooks, context, {
+      onStdout: (data) => logger.info(`[hook] ${data}`),
+      onStderr: (data) => logger.warn(`[hook] ${data}`),
+      onError: (command, error) => logger.error(`[hook] Failed to execute '${command}': ${error.message}`),
+      onComplete: (command, exitCode) => {
+        if (exitCode === 0) {
+          logger.info(`[hook] Command completed successfully`);
+        } else if (exitCode !== null) {
+          logger.warn(`[hook] Command exited with code ${exitCode}`);
+        }
+      }
+    });
+  }
+};
+
+// src/utils/clone-skip-format.ts
+function formatCloneSkipReason(reason) {
+  switch (reason.kind) {
+    case "branch_mismatch":
+      return reason.phase === "init" ? `clone is on '${reason.currentBranch}', expected '${reason.expectedBranch}' (since process start)` : `clone is on '${reason.currentBranch}', expected '${reason.expectedBranch}'`;
+    case "head_unreadable":
+      return `could not read HEAD: ${reason.error}`;
+    case "dirty_tree":
+      return `working tree has local changes`;
+    case "diverged":
+      return `diverged from origin/${reason.branch}`;
+    case "ahead_unpushed":
+      return `unpushed commits ahead of origin/${reason.branch}`;
+    case "missing_remote_ref":
+      return reason.source === "fetch_error" ? `origin/${reason.branch} missing on remote (fetch error)` : `origin/${reason.branch} pruned after fetch`;
+    case "indeterminate_shallow":
+      return reason.deepenedTo === null ? `unable to classify origin/${reason.branch} (no deepening attempted \u2014 configured depth already at or above all deepen targets) \u2014 remove 'depth' to unshallow` : `unable to classify origin/${reason.branch} after deepening shallow history to ${reason.deepenedTo} commits \u2014 remove or raise 'depth' to unshallow`;
+    case "origin_mismatch":
+      return `clone origin is '${reason.actual}', expected '${reason.expected}'`;
+    default: {
+      const _exhaustive = reason;
+      return _exhaustive;
+    }
+  }
+}
+
+// src/services/sync-outcome.ts
+var EMPTY_COUNTS = {
+  created: 0,
+  removed: 0,
+  updated: 0,
+  skipped: 0,
+  preserved: 0,
+  failed: 0,
+  noop: 0
+};
+function cloneCounts(counts) {
+  return { ...counts };
+}
+function cloneAction(action) {
+  return { ...action };
+}
+function countKeyFor(action) {
+  switch (action.kind) {
+    case "created":
+      return "created";
+    case "removed":
+      return "removed";
+    case "updated":
+      return "updated";
+    case "skipped":
+      return "skipped";
+    case "preserved-diverged":
+      return "preserved";
+    case "failed":
+      return "failed";
+    case "noop":
+      return "noop";
+    default: {
+      const _exhaustive = action;
+      return _exhaustive;
+    }
+  }
+}
+var SyncOutcomeAccumulator = class {
+  constructor(options) {
+    this.options = options;
+  }
+  counts = cloneCounts(EMPTY_COUNTS);
+  actions = [];
+  add(action) {
+    this.actions.push(action);
+    this.counts[countKeyFor(action)]++;
+  }
+  recordCreated(branch, path16) {
+    this.add({ kind: "created", branch, path: path16 });
+  }
+  recordRemoved(branch, path16) {
+    this.add({ kind: "removed", branch, path: path16 });
+  }
+  recordUpdated(branch, path16, reason) {
+    this.add({ kind: "updated", branch, path: path16, reason });
+  }
+  recordNoop(scope, reason, details) {
+    this.add({ kind: "noop", scope, reason, ...details });
+  }
+  recordSkipped(scope, reason, details) {
+    this.add({ kind: "skipped", scope, reason, ...details });
+  }
+  recordPreservedDiverged(branch, path16, preservedPath) {
+    this.add({ kind: "preserved-diverged", branch, path: path16, preservedPath });
+  }
+  recordFailed(scope, error, details = {}) {
+    this.add({ kind: "failed", scope, error, ...details });
+  }
+  getCounts() {
+    return cloneCounts(this.counts);
+  }
+  snapshot() {
+    return {
+      counts: cloneCounts(this.counts),
+      actions: this.actions.map(cloneAction)
+    };
+  }
+  restore(snapshot) {
+    this.counts = cloneCounts(snapshot.counts);
+    this.actions = snapshot.actions.map(cloneAction);
+  }
+  toOutcome(durationMs) {
+    return {
+      repoName: this.options.repoName,
+      mode: this.options.mode,
+      started: true,
+      counts: cloneCounts(this.counts),
+      actions: this.actions.map(cloneAction),
+      durationMs
+    };
+  }
+};
+function createEmptySyncOutcome(mode, repoName, durationMs) {
+  return {
+    repoName,
+    mode,
+    started: true,
+    counts: cloneCounts(EMPTY_COUNTS),
+    actions: [],
+    durationMs
+  };
+}
+function cloneSkipToOutcomeAction(reason, details = {}) {
+  const message = formatCloneSkipReason(reason);
+  const branch = "branch" in reason ? reason.branch : reason.kind === "branch_mismatch" ? reason.expectedBranch : details.branch;
+  return {
+    kind: "skipped",
+    scope: "repo",
+    reason: `clone_${reason.kind}`,
+    branch,
+    path: details.path,
+    message
+  };
+}
+
+// src/services/clone-sync.service.ts
+var ALL_REMOTE_BRANCHES_REFSPEC = "+refs/heads/*:refs/remotes/origin/*";
+var SHALLOW_RELATION_DEEPEN_TARGETS = [50, 200, 1e3];
+var CloneSyncService = class {
+  constructor(config, gitService, logger, options = {}) {
+    this.config = config;
+    this.gitService = gitService;
+    this.logger = logger;
+    this.branchCreatedActions = options.branchCreatedActions ?? new BranchCreatedActionsService();
+    this.progressEmitter = options.progressEmitter;
+    this.onSkip = options.onSkip;
+  }
+  initialized = false;
+  resolvedBranch = null;
+  branchCreatedActions;
+  progressEmitter;
+  onSkip;
+  outcomeAccumulator;
+  // One-shot suppression token. When init records a wrong-branch / unreadable-HEAD
+  // skip for an existing clone, it sets this so the immediately following
+  // runSyncAttempt (same sync operation) does not record the identical skip again.
+  pendingInitSkip = null;
+  updateLogger(logger) {
+    this.logger = logger;
+  }
+  isInitialized() {
+    return this.initialized;
+  }
+  clearPendingInitSkip() {
+    this.pendingInitSkip = null;
+  }
+  async getWorktrees() {
+    const worktreeDir = path4.resolve(this.config.worktreeDir);
+    if (!await fileExists(path4.join(worktreeDir, PATH_CONSTANTS.GIT_DIR))) {
+      return [];
+    }
+    const git = this.clientFor(worktreeDir, this.getFetchTimeoutMs());
+    let branch = (await git.raw(["rev-parse", "--abbrev-ref", "HEAD"])).trim();
+    if (!branch || branch === "HEAD") {
+      const head = (await git.raw(["rev-parse", "--short", "HEAD"])).trim();
+      branch = head ? `(detached ${head})` : "(detached)";
+    }
+    return [{ path: worktreeDir, branch }];
+  }
+  get repoName() {
+    return this.config.name ?? this.config.repoUrl;
+  }
+  getCloneTimeoutMs() {
+    if (process.env.NODE_ENV === ENV_CONSTANTS.NODE_ENV_TEST) return 0;
+    return this.config.cloneTimeoutMs ?? DEFAULT_CONFIG.CLONE_TIMEOUT_MS;
+  }
+  getFetchTimeoutMs() {
+    if (process.env.NODE_ENV === ENV_CONSTANTS.NODE_ENV_TEST) return 0;
+    return this.config.fetchTimeoutMs ?? DEFAULT_CONFIG.FETCH_TIMEOUT_MS;
+  }
+  isLfsSkipEnabled() {
+    return this.config.skipLfs === true;
+  }
+  buildGitOptions(blockMs) {
+    const options = {
+      progress: makeGitProgressHandler(this.logger, (event) => this.emitProgress(event))
+    };
+    if (blockMs > 0) options.timeout = { block: blockMs };
+    return options;
+  }
+  emitProgress(event) {
+    try {
+      this.progressEmitter?.(event);
+    } catch {
+    }
+  }
+  async withOutcome(outcome, operation) {
+    const previousOutcome = this.outcomeAccumulator;
+    if (outcome) {
+      this.outcomeAccumulator = outcome;
+    }
+    try {
+      return await operation();
+    } finally {
+      if (outcome) {
+        this.outcomeAccumulator = previousOutcome;
+      }
+    }
+  }
+  recordSkip(reason, logMessage, progressMessage, logLevel = "warn") {
+    if (logLevel === "warn") {
+      this.logger.warn(logMessage);
+    } else {
+      this.logger.info(logMessage);
+    }
+    this.emitProgress({ phase: "skip", message: progressMessage ?? logMessage });
+    try {
+      this.onSkip?.(reason);
+    } catch {
+    }
+    this.outcomeAccumulator?.add(
+      cloneSkipToOutcomeAction(reason, {
+        branch: this.resolvedBranch ?? this.config.branch,
+        path: this.config.worktreeDir
+      })
+    );
+  }
+  clientFor(dir, blockMs) {
+    return simpleGit(dir, this.buildGitOptions(blockMs)).env(this.buildGitEnv());
+  }
+  // Force a stable C locale so git's stderr is deterministic English. The
+  // missing-remote-ref and LFS error classification matches on those strings
+  // and would otherwise misfire under a non-English LANG/LC_ALL. simple-git's
+  // .env() merges this object with process.env (PATH etc. preserved).
+  buildGitEnv(opts = {}) {
+    const env = { LC_ALL: "C", LANG: "C" };
+    if (opts.forceLfsSkip || this.isLfsSkipEnabled()) {
+      env[ENV_CONSTANTS.GIT_LFS_SKIP_SMUDGE] = "1";
+    }
+    return env;
+  }
+  buildCloneArgs(branch) {
+    const args = ["--branch", branch, "--progress"];
+    if (this.config.depth !== void 0) {
+      args.push("--depth", String(this.config.depth), "--no-single-branch");
+    }
+    return args;
+  }
+  async buildFetchArgs(git) {
+    const args = ["origin", "--prune", "--progress"];
+    if (this.config.depth !== void 0 && await this.isShallowRepository(git)) {
+      args.push("--depth", String(this.config.depth));
+    }
+    return args;
+  }
+  async ensureAllRemoteBranchesRefspec(git) {
+    let fetchRefspecs = [];
+    try {
+      const output = await git.raw(["config", "--get-all", "remote.origin.fetch"]);
+      fetchRefspecs = output.split(/\r?\n/).map((line) => line.trim()).filter(Boolean);
+    } catch {
+      fetchRefspecs = [];
+    }
+    if (fetchRefspecs.includes(ALL_REMOTE_BRANCHES_REFSPEC)) return;
+    const customRefspecs = fetchRefspecs.filter((refspec) => !this.isOriginRemoteBranchTrackingRefspec(refspec));
+    this.logger.info(`Configuring '${this.repoName}' to fetch all remote branches from origin.`);
+    await git.raw(["remote", "set-branches", "origin", "*"]);
+    for (const refspec of customRefspecs) {
+      await git.raw(["config", "--add", "remote.origin.fetch", refspec]);
+    }
+  }
+  isOriginRemoteBranchTrackingRefspec(refspec) {
+    const withoutForce = refspec.startsWith("+") ? refspec.slice(1) : refspec;
+    if (withoutForce.startsWith("^")) return false;
+    const [source, destination] = withoutForce.split(":");
+    return source.startsWith("refs/heads/") && destination?.startsWith("refs/remotes/origin/") === true;
+  }
+  recordMissingRemoteRefSkip(branch) {
+    this.recordSkip(
+      { kind: "missing_remote_ref", branch, source: "fetch_error" },
+      `Tracked branch '${branch}' is missing on remote for '${this.repoName}'. Skipping sync.`,
+      `Skipping '${this.repoName}': origin/${branch} is missing`
+    );
+  }
+  async fetchWithRecovery(git, fetchArgs, worktreeDir, branch) {
+    try {
+      await git.fetch(fetchArgs);
+      return { skipped: false };
+    } catch (fetchError) {
+      const message = getErrorMessage(fetchError);
+      if (isLfsError(message)) {
+        this.logger.info(`\u26A0\uFE0F  LFS error during fetch for '${this.repoName}'; retrying with LFS disabled.`);
+        this.emitProgress({ phase: "fetch", message: `Retrying fetch for '${this.repoName}' with LFS disabled` });
+        const lfsSkipGit = simpleGit(worktreeDir, this.buildGitOptions(this.getFetchTimeoutMs())).env(
+          this.buildGitEnv({ forceLfsSkip: true })
+        );
+        try {
+          await lfsSkipGit.fetch(fetchArgs);
+          return { skipped: false };
+        } catch (retryError) {
+          if (isMissingRemoteRefError(getErrorMessage(retryError))) {
+            this.recordMissingRemoteRefSkip(branch);
+            return { skipped: true };
+          }
+          throw retryError;
+        }
+      }
+      if (isMissingRemoteRefError(message)) {
+        this.recordMissingRemoteRefSkip(branch);
+        return { skipped: true };
+      }
+      throw fetchError;
+    }
+  }
+  async hasRemoteBranch(git, branch) {
+    try {
+      await git.raw(["show-ref", "--verify", `refs/remotes/origin/${branch}`]);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  async isShallowRepository(git) {
+    try {
+      const output = await git.raw(["rev-parse", "--is-shallow-repository"]);
+      return output.trim() === "true";
+    } catch {
+      return false;
+    }
+  }
+  async unshallowIfDepthRemoved(git) {
+    if (this.config.depth !== void 0) return;
+    if (!await this.isShallowRepository(git)) return;
+    this.logger.info(
+      `[deepen] Existing shallow clone for '${this.repoName}' has no configured depth; fetching full history...`
+    );
+    await git.fetch(["--unshallow"]);
+  }
+  getDeepenTargets() {
+    const configuredDepth = this.config.depth;
+    if (configuredDepth === void 0) return [];
+    return SHALLOW_RELATION_DEEPEN_TARGETS.filter((target) => target > configuredDepth);
+  }
+  async deepenShallowHistoryToDepth(git, branch, targetDepth) {
+    this.logger.info(
+      `[deepen] Shallow clone for '${this.repoName}' lacks enough history to classify origin/${branch}; refetching to depth ${targetDepth} before deciding.`
+    );
+    this.emitProgress({
+      phase: "fetch",
+      message: `Deepening '${this.repoName}' to depth ${targetDepth} before classifying origin/${branch}`
+    });
+    await git.fetch([
+      "origin",
+      "--depth",
+      String(targetDepth),
+      "--prune",
+      "--progress",
+      `+refs/heads/${branch}:refs/remotes/origin/${branch}`
+    ]);
+  }
+  async resolveBranch() {
+    if (this.resolvedBranch) return this.resolvedBranch;
+    if (this.config.branch) {
+      this.resolvedBranch = this.config.branch;
+      this.emitProgress({ phase: "branch", message: `Using configured branch '${this.resolvedBranch}'` });
+      return this.resolvedBranch;
+    }
+    this.logger.info(`No branch configured for '${this.repoName}', detecting remote default branch...`);
+    this.emitProgress({ phase: "branch", message: `Resolving remote default branch for '${this.repoName}'` });
+    this.resolvedBranch = await this.gitService.getRemoteDefaultBranch(this.config.repoUrl);
+    this.logger.info(`  \u21B3 resolved default branch: ${this.resolvedBranch}`);
+    this.emitProgress({ phase: "branch", message: `Resolved default branch '${this.resolvedBranch}'` });
+    return this.resolvedBranch;
+  }
+  async initialize(outcome) {
+    return this.withOutcome(outcome, () => this.initializeInternal());
+  }
+  async initializeInternal() {
+    this.pendingInitSkip = null;
+    const branch = await this.resolveBranch();
+    const worktreeDir = this.config.worktreeDir;
+    let entries = null;
+    try {
+      entries = await fs3.readdir(worktreeDir);
+    } catch {
+      entries = null;
+    }
+    if (entries?.includes(PATH_CONSTANTS.GIT_DIR)) {
+      this.emitProgress({ phase: "clone", message: `Validating existing clone for '${this.repoName}'` });
+      const result = await this.validateExistingClone(branch);
+      if (!result.valid) {
+        this.recordSkip(result.skip, result.warnMessage, `Skipping '${this.repoName}': ${result.progressDetail}`);
+        this.pendingInitSkip = result.skip;
+        this.initialized = true;
+        return;
+      }
+      const git = this.clientFor(worktreeDir, this.getFetchTimeoutMs());
+      await this.ensureAllRemoteBranchesRefspec(git);
+      this.initialized = true;
+      this.emitProgress({ phase: "clone", message: `Existing clone validated for '${this.repoName}'` });
+      return;
+    }
+    if (entries && entries.length > 0) {
+      throw new ConfigError(
+        `Cannot clone into '${worktreeDir}': directory exists and is not empty. Remove existing contents or point worktreeDir at an empty path.`,
+        "CLONE_DESTINATION_NOT_EMPTY"
+      );
+    }
+    const cloneCreatedDir = entries === null;
+    await fs3.mkdir(worktreeDir, { recursive: true });
+    this.logger.info(`Cloning '${this.config.repoUrl}' (${branch}) into '${worktreeDir}'...`);
+    this.emitProgress({ phase: "clone", message: `Cloning '${this.repoName}' (${branch})` });
+    const cloneClient = simpleGit(this.buildGitOptions(this.getCloneTimeoutMs())).env(this.buildGitEnv());
+    try {
+      await cloneClient.clone(this.config.repoUrl, worktreeDir, this.buildCloneArgs(branch));
+    } catch (error) {
+      await this.maybeCleanupPartialClone(worktreeDir, cloneCreatedDir);
+      this.outcomeAccumulator?.recordFailed("repo", getErrorMessage(error), {
+        reason: "clone_failed",
+        branch,
+        path: worktreeDir
+      });
+      throw error;
+    }
+    const worktreeGit = this.clientFor(worktreeDir, this.getFetchTimeoutMs());
+    await this.ensureAllRemoteBranchesRefspec(worktreeGit);
+    this.logger.info(`\u2705 Clone successful.`);
+    this.emitProgress({ phase: "clone", message: `Clone successful for '${this.repoName}'` });
+    if (this.config.sparseCheckout) {
+      this.logger.info(`Applying sparse-checkout patterns to '${worktreeDir}'...`);
+      this.emitProgress({ phase: "sparse_checkout", message: `Applying sparse-checkout for '${this.repoName}'` });
+      const sparseService = this.gitService.getSparseCheckoutService();
+      await sparseService.applyToWorktree(worktreeDir, this.config.sparseCheckout);
+      await worktreeGit.raw(["checkout", "HEAD"]);
+      this.emitProgress({ phase: "sparse_checkout", message: `Sparse-checkout applied for '${this.repoName}'` });
+    }
+    this.emitProgress({ phase: "lfs", message: `Verifying LFS for '${this.repoName}'` });
+    await this.gitService.verifyLfs(worktreeDir, branch);
+    this.emitProgress({ phase: "lfs", message: `LFS verified for '${this.repoName}'` });
+    await this.runInitialFileCopy(worktreeDir, branch);
+    this.outcomeAccumulator?.recordCreated(branch, worktreeDir);
+    this.initialized = true;
+  }
+  // Detects an on-disk clone whose `origin` no longer matches the configured
+  // repoUrl (e.g. repoUrl was repointed in config). Returns a skip descriptor so
+  // we never fetch/ff-merge from the wrong remote; null when origin matches or
+  // can't be read. Comparison is normalized so https/.git/trailing-slash
+  // variants don't false-positive; the raw URLs are kept in the message.
+  async evaluateOriginMatch(git, worktreeDir) {
+    let originUrl;
+    try {
+      originUrl = (await git.raw(["remote", "get-url", "origin"])).trim();
+    } catch {
+      this.logger.warn(`Could not read 'origin' remote URL from existing clone at '${worktreeDir}'.`);
+      return null;
+    }
+    if (!originUrl || normalizeRepoUrlForComparison(originUrl) === normalizeRepoUrlForComparison(this.config.repoUrl)) {
+      return null;
+    }
+    return {
+      skip: { kind: "origin_mismatch", actual: originUrl, expected: this.config.repoUrl },
+      warnMessage: `Existing clone at '${worktreeDir}' has origin '${originUrl}', expected '${this.config.repoUrl}'. Update the remote ('git remote set-url origin <url>') or point worktreeDir at a fresh path.`,
+      progressDetail: `origin '${originUrl}' is not '${this.config.repoUrl}'`
+    };
+  }
+  async validateExistingClone(expectedBranch) {
+    const worktreeDir = this.config.worktreeDir;
+    const git = this.clientFor(worktreeDir, this.getFetchTimeoutMs());
+    const originMismatch = await this.evaluateOriginMatch(git, worktreeDir);
+    if (originMismatch) {
+      return { valid: false, ...originMismatch };
+    }
+    let currentBranch;
+    try {
+      currentBranch = (await git.raw(["rev-parse", "--abbrev-ref", "HEAD"])).trim();
+    } catch (error) {
+      const errorMessage = getErrorMessage(error);
+      return {
+        valid: false,
+        skip: { kind: "head_unreadable", phase: "init", error: errorMessage },
+        warnMessage: `Existing clone at '${worktreeDir}' has a .git folder but reading HEAD failed: ${errorMessage}`,
+        progressDetail: `could not read HEAD (${errorMessage})`
+      };
+    }
+    if (currentBranch !== expectedBranch) {
+      return {
+        valid: false,
+        skip: {
+          kind: "branch_mismatch",
+          phase: "init",
+          currentBranch,
+          expectedBranch
+        },
+        warnMessage: `Existing clone at '${worktreeDir}' is on branch '${currentBranch}', expected '${expectedBranch}'. Switch the working tree to '${expectedBranch}' or update the config.`,
+        progressDetail: `current branch '${currentBranch}' is not '${expectedBranch}'`
+      };
+    }
+    return { valid: true };
+  }
+  async maybeCleanupPartialClone(worktreeDir, cloneCreatedDir) {
+    if (!cloneCreatedDir) {
+      this.logger.warn(
+        `Clone failed; leaving '${worktreeDir}' for manual inspection (directory existed before clone attempt).`
+      );
+      return;
+    }
+    let entries;
+    try {
+      entries = await fs3.readdir(worktreeDir);
+    } catch {
+      return;
+    }
+    const looksIncomplete = entries.every((e) => e.startsWith("."));
+    const hasUsableGit = entries.includes(PATH_CONSTANTS.GIT_DIR) && await fileExists(path4.join(worktreeDir, PATH_CONSTANTS.GIT_DIR, "HEAD"));
+    if (looksIncomplete && !hasUsableGit) {
+      try {
+        await fs3.rm(worktreeDir, { recursive: true, force: true });
+        this.logger.info(`Cleaned up incomplete clone at '${worktreeDir}'.`);
+      } catch (rmError) {
+        this.logger.warn(`Failed to clean up incomplete clone at '${worktreeDir}': ${getErrorMessage(rmError)}`);
+      }
+    } else {
+      this.logger.warn(
+        `Clone failed; leaving '${worktreeDir}' for manual inspection (post-failure contents do not look like an empty incomplete clone).`
+      );
+    }
+  }
+  getInitMarkerPath(worktreeDir) {
+    return path4.join(worktreeDir, PATH_CONSTANTS.GIT_DIR, PATH_CONSTANTS.CLONE_INIT_MARKER);
+  }
+  async runInitialFileCopy(worktreeDir, branch) {
+    const marker = this.getInitMarkerPath(worktreeDir);
+    if (await fileExists(marker)) {
+      return;
+    }
+    const sourceDir = this.config.__configFileDir ?? worktreeDir;
+    await this.branchCreatedActions.copyFiles({
+      config: this.config,
+      branchName: branch,
+      worktreePath: worktreeDir,
+      sourceDir,
+      logger: this.logger
+    });
+    try {
+      await fs3.writeFile(marker, (/* @__PURE__ */ new Date()).toISOString());
+    } catch (error) {
+      this.logger.warn(`Could not write clone-init marker: ${getErrorMessage(error)}`);
+    }
+  }
+  async runSyncAttempt(outcome) {
+    return this.withOutcome(outcome, () => this.runSyncAttemptInternal());
+  }
+  async runSyncAttemptInternal() {
+    if (!this.initialized) {
+      await this.initialize();
+      this.pendingInitSkip = null;
+      return;
+    }
+    if (this.pendingInitSkip) {
+      this.pendingInitSkip = null;
+      return;
+    }
+    const branch = await this.resolveBranch();
+    const worktreeDir = this.config.worktreeDir;
+    const git = this.clientFor(worktreeDir, this.getFetchTimeoutMs());
+    let currentBranch;
+    try {
+      currentBranch = (await git.raw(["rev-parse", "--abbrev-ref", "HEAD"])).trim();
+    } catch (error) {
+      const errorMessage = getErrorMessage(error);
+      this.recordSkip(
+        { kind: "head_unreadable", phase: "sync", error: errorMessage },
+        `Could not read current branch from '${worktreeDir}': ${errorMessage}`,
+        `Skipping '${this.repoName}': could not read current branch`
+      );
+      return;
+    }
+    if (currentBranch !== branch) {
+      this.recordSkip(
+        { kind: "branch_mismatch", phase: "sync", currentBranch, expectedBranch: branch },
+        `Clone at '${worktreeDir}' is on '${currentBranch}', expected '${branch}'. Skipping fetch+merge.`,
+        `Skipping '${this.repoName}': current branch '${currentBranch}' is not '${branch}'`
+      );
+      return;
+    }
+    const originMismatch = await this.evaluateOriginMatch(git, worktreeDir);
+    if (originMismatch) {
+      this.recordSkip(
+        originMismatch.skip,
+        originMismatch.warnMessage,
+        `Skipping '${this.repoName}': ${originMismatch.progressDetail}`
+      );
+      return;
+    }
+    await this.unshallowIfDepthRemoved(git);
+    await this.ensureAllRemoteBranchesRefspec(git);
+    const fetchArgs = await this.buildFetchArgs(git);
+    this.emitProgress({ phase: "fetch", message: `Fetching origin branches for '${this.repoName}'` });
+    if ((await this.fetchWithRecovery(git, fetchArgs, worktreeDir, branch)).skipped) {
+      return;
+    }
+    this.emitProgress({ phase: "fetch", message: `Fetched origin branches for '${this.repoName}'` });
+    if (!await this.hasRemoteBranch(git, branch)) {
+      this.recordSkip(
+        { kind: "missing_remote_ref", branch, source: "post_fetch_verify" },
+        `Tracked branch '${branch}' is missing on remote for '${this.repoName}'. Skipping sync.`,
+        `Skipping '${this.repoName}': origin/${branch} is missing`
+      );
+      return;
+    }
+    if (this.config.sparseCheckout) {
+      const sparseService = this.gitService.getSparseCheckoutService();
+      try {
+        if (await sparseService.needsUpdate(worktreeDir, this.config.sparseCheckout)) {
+          this.emitProgress({ phase: "sparse_checkout", message: `Updating sparse-checkout for '${this.repoName}'` });
+          await sparseService.applyToWorktree(worktreeDir, this.config.sparseCheckout);
+          this.emitProgress({ phase: "sparse_checkout", message: `Sparse-checkout updated for '${this.repoName}'` });
+        }
+      } catch (error) {
+        this.logger.warn(`Failed to reapply sparse-checkout for '${this.repoName}': ${getErrorMessage(error)}`);
+      }
+    }
+    const isClean = await this.gitService.checkWorktreeStatus(worktreeDir);
+    if (!isClean) {
+      this.recordSkip(
+        { kind: "dirty_tree" },
+        `\u23ED\uFE0F  Skipping ff-merge for '${this.repoName}' \u2014 working tree has local changes.`,
+        `Skipping merge for '${this.repoName}': working tree has local changes`,
+        "info"
+      );
+      return;
+    }
+    let relationship = await this.gitService.classifyRemoteRelationship(worktreeDir, branch);
+    let lastDeepenedTo = null;
+    if (relationship === "indeterminate_shallow") {
+      for (const target of this.getDeepenTargets()) {
+        await this.deepenShallowHistoryToDepth(git, branch, target);
+        lastDeepenedTo = target;
+        relationship = await this.gitService.classifyRemoteRelationship(worktreeDir, branch);
+        if (relationship !== "indeterminate_shallow") break;
+      }
+    }
+    if (relationship === "up_to_date") {
+      this.logger.info(`'${this.repoName}' already up to date with origin/${branch}.`);
+      this.emitProgress({
+        phase: "skip",
+        message: `'${this.repoName}' already up to date with origin/${branch}`
+      });
+      this.outcomeAccumulator?.recordNoop("repo", "already_up_to_date", {
+        branch,
+        path: worktreeDir,
+        message: `Already up to date with origin/${branch}`
+      });
+      return;
+    }
+    if (relationship !== "fast_forward") {
+      if (relationship === "local_ahead") {
+        this.recordSkip(
+          { kind: "ahead_unpushed", branch },
+          `\u23ED\uFE0F  '${this.repoName}' has unpushed commits ahead of origin/${branch}. Skipping merge.`,
+          `Skipping merge for '${this.repoName}': unpushed commits ahead of origin/${branch}`,
+          "info"
+        );
+      } else if (relationship === "indeterminate_shallow") {
+        const detail = lastDeepenedTo === null ? `no deepening attempted (configured depth already at or above all deepen targets)` : `deepening to ${lastDeepenedTo} commits`;
+        const progressDetail = lastDeepenedTo === null ? `no deepening attempted (configured depth at/above limits)` : `shallow depth budget exhausted at ${lastDeepenedTo}`;
+        this.recordSkip(
+          { kind: "indeterminate_shallow", branch, deepenedTo: lastDeepenedTo },
+          `\u23ED\uFE0F  '${this.repoName}' could not classify origin/${branch} after ${detail}. Skipping merge \u2014 consider removing or raising 'depth' to unshallow.`,
+          `Skipping merge for '${this.repoName}': ${progressDetail}`,
+          "info"
+        );
+      } else {
+        this.recordSkip(
+          { kind: "diverged", branch },
+          `\u23ED\uFE0F  '${this.repoName}' has diverged from origin/${branch}. Skipping merge (no auto-reset).`,
+          `Skipping merge for '${this.repoName}': diverged from origin/${branch}`,
+          "info"
+        );
+      }
+      return;
+    }
+    this.logger.info(`Fast-forwarding '${this.repoName}' to origin/${branch}...`);
+    this.emitProgress({ phase: "merge", message: `Fast-forwarding '${this.repoName}' to origin/${branch}` });
+    await git.merge([`origin/${branch}`, "--ff-only"]);
+    this.logger.info(`\u2705 Updated '${this.repoName}' to origin/${branch}.`);
+    this.emitProgress({ phase: "merge", message: `Updated '${this.repoName}' to origin/${branch}` });
+    this.outcomeAccumulator?.recordUpdated(branch, worktreeDir, "fast_forward");
+  }
+};
+
+// src/services/git.service.ts
+import * as fs6 from "fs/promises";
+import * as path8 from "path";
+import simpleGit5 from "simple-git";
+
+// src/utils/worktree-list-parser.ts
+function parseWorktreeListPorcelain(output) {
+  const worktrees = [];
+  let current = {};
+  const flush = () => {
+    if (!current.path) {
+      current = {};
+      return;
+    }
+    worktrees.push({
+      path: current.path,
+      branch: current.branch ?? null,
+      head: current.head ?? null,
+      detached: current.detached ?? false,
+      prunable: current.prunable ?? false,
+      locked: current.locked ?? false
+    });
+    current = {};
+  };
+  for (const line of output.split("\n")) {
+    if (line.startsWith("worktree ")) {
       flush();
       current.path = line.substring("worktree ".length);
     } else if (line.startsWith("branch ")) {
@@ -1053,8 +2003,8 @@ function parseWorktreeListPorcelain(output) {
 }
 
 // src/services/sparse-checkout.service.ts
-import * as path3 from "path";
-import simpleGit from "simple-git";
+import * as path5 from "path";
+import simpleGit2 from "simple-git";
 var SparseCheckoutService = class {
   logger;
   gitFactory;
@@ -1062,7 +2012,7 @@ var SparseCheckoutService = class {
   matcherCache = /* @__PURE__ */ new WeakMap();
   constructor(logger, gitFactory) {
     this.logger = logger ?? Logger.createDefault();
-    this.gitFactory = gitFactory ?? ((p) => simpleGit(p));
+    this.gitFactory = gitFactory ?? ((p) => simpleGit2(p));
   }
   updateLogger(logger) {
     this.logger = logger;
@@ -1113,11 +2063,25 @@ var SparseCheckoutService = class {
       return null;
     }
   }
+  async readCurrentMode(worktreePath) {
+    const git = this.gitFactory(worktreePath);
+    try {
+      const out = await git.raw(["config", "--bool", "--get", "core.sparseCheckoutCone"]);
+      const value = out.trim().toLowerCase();
+      if (value === "true") return "cone";
+      if (value === "false") return "no-cone";
+      return null;
+    } catch {
+      return null;
+    }
+  }
   async needsUpdate(worktreePath, cfg) {
+    const desiredMode = this.resolveMode(cfg);
+    const currentMode = await this.readCurrentMode(worktreePath);
+    if (currentMode !== desiredMode) return true;
     const current = await this.readCurrent(worktreePath);
-    const desired = this.buildPatterns(cfg);
     if (current === null) return true;
-    return !this.patternsEqual(current, desired);
+    return !this.patternsEqual(current, this.buildPatternsForMode(cfg, desiredMode));
   }
   isNarrowing(currentPatterns, nextPatterns) {
     if (!currentPatterns || currentPatterns.length === 0) return false;
@@ -1174,7 +2138,7 @@ var SparseCheckoutService = class {
       for (const pat of matcher.patterns) {
         if (p === pat || p.startsWith(pat + "/")) return true;
       }
-      return matcher.ancestorDirs.has(path3.posix.dirname(p));
+      return matcher.ancestorDirs.has(path5.posix.dirname(p));
     });
   }
   getMatcher(cfg) {
@@ -1201,9 +2165,9 @@ var SparseCheckoutService = class {
 };
 
 // src/services/worktree-metadata.service.ts
-import * as fs2 from "fs/promises";
-import * as path4 from "path";
-import simpleGit2 from "simple-git";
+import * as fs4 from "fs/promises";
+import * as path6 from "path";
+import simpleGit3 from "simple-git";
 var WorktreeMetadataService = class {
   logger;
   constructor(logger) {
@@ -1215,7 +2179,7 @@ var WorktreeMetadataService = class {
    * For example: /worktrees/fix/test-branch -> test-branch (not fix/test-branch)
    */
   getWorktreeDirectoryName(worktreePath) {
-    return path4.basename(worktreePath);
+    return path6.basename(worktreePath);
   }
   async getMetadataPath(bareRepoPath, worktreeName) {
     if (worktreeName.includes("/") || worktreeName.includes("\\")) {
@@ -1223,7 +2187,7 @@ var WorktreeMetadataService = class {
         `getMetadataPath requires a filesystem-safe worktree directory name, got '${worktreeName}'. Use getMetadataPathFromWorktreePath when starting from a raw branch name.`
       );
     }
-    return path4.join(
+    return path6.join(
       bareRepoPath,
       METADATA_CONSTANTS.WORKTREE_METADATA_PATH,
       worktreeName,
@@ -1236,31 +2200,31 @@ var WorktreeMetadataService = class {
   }
   async saveMetadata(bareRepoPath, worktreeName, metadata) {
     const metadataPath = await this.getMetadataPath(bareRepoPath, worktreeName);
-    await fs2.mkdir(path4.dirname(metadataPath), { recursive: true });
+    await fs4.mkdir(path6.dirname(metadataPath), { recursive: true });
     const tmpPath = `${metadataPath}.${process.pid}.${Date.now()}.tmp`;
     let renamed = false;
     try {
-      await fs2.writeFile(tmpPath, JSON.stringify(metadata, null, 2), "utf-8");
+      await fs4.writeFile(tmpPath, JSON.stringify(metadata, null, 2), "utf-8");
       try {
-        await fs2.rename(tmpPath, metadataPath);
+        await fs4.rename(tmpPath, metadataPath);
         renamed = true;
       } catch (err) {
         if (err.code === ERROR_MESSAGES.EXDEV) {
-          await fs2.copyFile(tmpPath, metadataPath);
+          await fs4.copyFile(tmpPath, metadataPath);
         } else {
           throw err;
         }
       }
     } finally {
       if (!renamed) {
-        await fs2.unlink(tmpPath).catch(() => void 0);
+        await fs4.unlink(tmpPath).catch(() => void 0);
       }
     }
   }
   async loadMetadata(bareRepoPath, worktreeName) {
     const metadataPath = await this.getMetadataPath(bareRepoPath, worktreeName);
     try {
-      const content = await fs2.readFile(metadataPath, "utf-8");
+      const content = await fs4.readFile(metadataPath, "utf-8");
       return JSON.parse(content);
     } catch {
       return null;
@@ -1269,7 +2233,7 @@ var WorktreeMetadataService = class {
   async loadMetadataFromPath(bareRepoPath, worktreePath) {
     const metadataPath = await this.getMetadataPathFromWorktreePath(bareRepoPath, worktreePath);
     try {
-      const content = await fs2.readFile(metadataPath, "utf-8");
+      const content = await fs4.readFile(metadataPath, "utf-8");
       const metadata = JSON.parse(content);
       if (!await this.validateMetadata(metadata)) {
         this.logger.warn(`Corrupted metadata for ${worktreePath}, treating as missing`);
@@ -1283,7 +2247,7 @@ var WorktreeMetadataService = class {
   async deleteMetadata(bareRepoPath, worktreeName) {
     const metadataPath = await this.getMetadataPath(bareRepoPath, worktreeName);
     try {
-      await fs2.unlink(metadataPath);
+      await fs4.unlink(metadataPath);
     } catch (error) {
       if (error.code !== "ENOENT") {
         throw error;
@@ -1293,7 +2257,7 @@ var WorktreeMetadataService = class {
   async deleteMetadataFromPath(bareRepoPath, worktreePath) {
     const metadataPath = await this.getMetadataPathFromWorktreePath(bareRepoPath, worktreePath);
     try {
-      await fs2.unlink(metadataPath);
+      await fs4.unlink(metadataPath);
     } catch (error) {
       if (error.code !== "ENOENT") {
         throw error;
@@ -1327,7 +2291,7 @@ var WorktreeMetadataService = class {
       this.logger.warn(`No metadata found for worktree ${worktreeDirName}`);
       this.logger.info(`  Attempting to create initial metadata...`);
       try {
-        const worktreeGit = simpleGit2(worktreePath);
+        const worktreeGit = simpleGit3(worktreePath);
         const currentCommit = await worktreeGit.revparse(["HEAD"]);
         const branchSummary = await worktreeGit.branch();
         const actualBranchName = branchSummary.current;
@@ -1428,9 +2392,9 @@ var WorktreeMetadataService = class {
 };
 
 // src/services/worktree-status.service.ts
-import * as fs3 from "fs/promises";
-import * as path5 from "path";
-import simpleGit3 from "simple-git";
+import * as fs5 from "fs/promises";
+import * as path7 from "path";
+import simpleGit4 from "simple-git";
 var OPERATION_FILES = [
   { file: GIT_OPERATIONS.MERGE_HEAD, type: "merge" },
   { file: GIT_OPERATIONS.CHERRY_PICK_HEAD, type: "cherry-pick" },
@@ -1461,9 +2425,7 @@ var WorktreeStatusService = class {
     return true;
   }
   async getFullWorktreeStatus(worktreePath, includeDetails = false, lastSyncCommit) {
-    try {
-      await fs3.access(worktreePath);
-    } catch {
+    if (!await fileExists(worktreePath)) {
       return {
         isClean: true,
         hasUnpushedCommits: false,
@@ -1633,7 +2595,7 @@ var WorktreeStatusService = class {
   async detectOperationFile(gitDir) {
     const results = await Promise.all(
       OPERATION_FILES.map(
-        ({ file }) => fs3.access(path5.join(gitDir, file)).then(
+        ({ file }) => fs5.access(path7.join(gitDir, file)).then(
           () => true,
           () => false
         )
@@ -1754,14 +2716,14 @@ var WorktreeStatusService = class {
     }
   }
   async resolveGitDir(worktreePath) {
-    const gitPath = path5.join(worktreePath, PATH_CONSTANTS.GIT_DIR);
+    const gitPath = path7.join(worktreePath, PATH_CONSTANTS.GIT_DIR);
     try {
-      const stat4 = await fs3.stat(gitPath);
+      const stat4 = await fs5.stat(gitPath);
       if (stat4.isFile()) {
-        const content = await fs3.readFile(gitPath, "utf-8");
+        const content = await fs5.readFile(gitPath, "utf-8");
         const gitdirMatch = content.match(new RegExp(`^${GIT_CONSTANTS.GITDIR_PREFIX}\\s*(.+)$`, "m"));
         if (gitdirMatch) {
-          return path5.resolve(worktreePath, gitdirMatch[1].trim());
+          return path7.resolve(worktreePath, gitdirMatch[1].trim());
         }
         throw new GitOperationError("resolve-git-dir", `Failed to parse gitdir from .git file at ${gitPath}`);
       }
@@ -1775,10 +2737,10 @@ var WorktreeStatusService = class {
     }
   }
   createGitInstance(worktreePath) {
-    const key = `${path5.resolve(worktreePath)}::${this.config.skipLfs ? "1" : "0"}`;
+    const key = `${path7.resolve(worktreePath)}::${this.config.skipLfs ? "1" : "0"}`;
     let git = this.gitInstances.get(key);
     if (!git) {
-      git = this.config.skipLfs ? simpleGit3(worktreePath).env({ [ENV_CONSTANTS.GIT_LFS_SKIP_SMUDGE]: "1" }) : simpleGit3(worktreePath);
+      git = this.config.skipLfs ? simpleGit4(worktreePath).env({ [ENV_CONSTANTS.GIT_LFS_SKIP_SMUDGE]: "1" }) : simpleGit4(worktreePath);
       this.gitInstances.set(key, git);
     }
     return git;
@@ -1798,7 +2760,7 @@ var GitService = class {
     this.config = config;
     this.logger = logger ?? Logger.createDefault(void 0, config.debug);
     this.bareRepoPath = this.config.bareRepoDir || getDefaultBareRepoDir(this.config.repoUrl);
-    this.mainWorktreePath = path6.join(this.config.worktreeDir, GIT_CONSTANTS.DEFAULT_BRANCH);
+    this.mainWorktreePath = path8.join(this.config.worktreeDir, GIT_CONSTANTS.DEFAULT_BRANCH);
     this.metadataService = new WorktreeMetadataService(this.logger);
     this.statusService = new WorktreeStatusService({ skipLfs: this.config.skipLfs }, this.logger);
     this.sparseCheckoutService = new SparseCheckoutService(this.logger);
@@ -1826,36 +2788,20 @@ var GitService = class {
     return this.config.cloneTimeoutMs ?? DEFAULT_CONFIG.CLONE_TIMEOUT_MS;
   }
   getCachedGit(dirPath, useLfsSkip = false) {
-    const key = `${path6.resolve(dirPath)}::${useLfsSkip ? "1" : "0"}`;
+    const key = `${path8.resolve(dirPath)}::${useLfsSkip ? "1" : "0"}`;
     let git = this.gitInstances.get(key);
     if (!git) {
-      const base = simpleGit4(dirPath, this.buildSimpleGitOptions(this.getFetchTimeoutMs()));
+      const base = simpleGit5(dirPath, this.buildSimpleGitOptions(this.getFetchTimeoutMs()));
       git = useLfsSkip ? base.env({ [ENV_CONSTANTS.GIT_LFS_SKIP_SMUDGE]: "1" }) : base;
       this.gitInstances.set(key, git);
     }
     return git;
   }
   buildSimpleGitOptions(blockMs) {
-    const options = { progress: this.makeProgressHandler() };
+    const options = { progress: makeGitProgressHandler(this.logger) };
     if (blockMs > 0) options.timeout = { block: blockMs };
     return options;
   }
-  makeProgressHandler() {
-    const lastBucket = /* @__PURE__ */ new Map();
-    return (event) => {
-      if (event.method !== "fetch" && event.method !== "clone" && event.method !== "pull") return;
-      const key = `${event.method}:${event.stage}`;
-      const bucket = Math.floor(event.progress / GIT_CONSTANTS.PROGRESS_BUCKET_PERCENT);
-      let last = lastBucket.get(key) ?? -1;
-      if (bucket < last) {
-        last = -1;
-      }
-      if (bucket <= last && event.progress < 100) return;
-      lastBucket.set(key, bucket);
-      const total = event.total > 0 ? `${event.processed}/${event.total}` : `${event.processed}`;
-      this.logger.info(`  \u21B3 ${event.method} ${event.stage}: ${event.progress}% (${total})`);
-    };
-  }
   updateLogger(logger) {
     this.logger = logger;
     this.sparseCheckoutService.updateLogger(logger);
@@ -1863,11 +2809,11 @@ var GitService = class {
   async initialize() {
     const { repoUrl } = this.config;
     try {
-      await fs4.access(path6.join(this.bareRepoPath, "HEAD"));
+      await fs6.access(path8.join(this.bareRepoPath, "HEAD"));
     } catch {
       this.logger.info(`Cloning from "${repoUrl}" as bare repository into "${this.bareRepoPath}"...`);
-      await fs4.mkdir(path6.dirname(this.bareRepoPath), { recursive: true });
-      const cloneBase = simpleGit4(this.buildSimpleGitOptions(this.getCloneTimeoutMs()));
+      await fs6.mkdir(path8.dirname(this.bareRepoPath), { recursive: true });
+      const cloneBase = simpleGit5(this.buildSimpleGitOptions(this.getCloneTimeoutMs()));
       const cloneGit = this.isLfsSkipEnabled() ? cloneBase.env({ [ENV_CONSTANTS.GIT_LFS_SKIP_SMUDGE]: "1" }) : cloneBase;
       await cloneGit.clone(repoUrl, this.bareRepoPath, ["--bare", "--progress"]);
       this.logger.info("\u2705 Clone successful.");
@@ -1885,17 +2831,17 @@ var GitService = class {
     this.logger.info("Fetching remote branches...");
     await bareGit.fetch(["--all", "--progress"]);
     this.defaultBranch = await this.detectDefaultBranch(bareGit);
-    this.mainWorktreePath = path6.join(this.config.worktreeDir, this.defaultBranch);
+    this.mainWorktreePath = path8.join(this.config.worktreeDir, this.defaultBranch);
     let needsMainWorktree = true;
     try {
       const worktrees = await this.getWorktreesFromBare(bareGit);
-      needsMainWorktree = !worktrees.some((w) => path6.resolve(w.path) === path6.resolve(this.mainWorktreePath));
+      needsMainWorktree = !worktrees.some((w) => path8.resolve(w.path) === path8.resolve(this.mainWorktreePath));
     } catch {
     }
     if (needsMainWorktree) {
       this.logger.info(`Creating ${this.defaultBranch} worktree at "${this.mainWorktreePath}"...`);
-      await fs4.mkdir(this.config.worktreeDir, { recursive: true });
-      const absoluteWorktreePath = path6.resolve(this.mainWorktreePath);
+      await fs6.mkdir(this.config.worktreeDir, { recursive: true });
+      const absoluteWorktreePath = path8.resolve(this.mainWorktreePath);
       const branches = await bareGit.branch();
       const defaultBranchExists = branches.all.includes(this.defaultBranch);
       const useNoCheckoutMain = !!this.config.sparseCheckout;
@@ -1931,7 +2877,7 @@ var GitService = class {
       }
       const updatedWorktrees = await this.getWorktreesFromBare(bareGit);
       const mainWorktreeRegistered = updatedWorktrees.some(
-        (w) => path6.resolve(w.path) === path6.resolve(this.mainWorktreePath)
+        (w) => path8.resolve(w.path) === path8.resolve(this.mainWorktreePath)
       );
       if (!mainWorktreeRegistered) {
         if (process.env.NODE_ENV !== ENV_CONSTANTS.NODE_ENV_TEST) {
@@ -1957,6 +2903,45 @@ var GitService = class {
   getBareRepoPath() {
     return this.bareRepoPath;
   }
+  async getRemoteDefaultBranch(repoUrl) {
+    const git = simpleGit5(this.buildSimpleGitOptions(this.getFetchTimeoutMs()));
+    try {
+      const out = await git.raw(["ls-remote", "--symref", repoUrl, "HEAD"]);
+      const match = out.match(/^ref: refs\/heads\/(\S+)\s+HEAD/m);
+      if (match && match[1]) {
+        return match[1];
+      }
+    } catch {
+    }
+    const existing = [];
+    for (const candidate of GIT_CONSTANTS.COMMON_DEFAULT_BRANCHES) {
+      try {
+        const out = await git.raw(["ls-remote", "--exit-code", repoUrl, `refs/heads/${candidate}`]);
+        if (out.trim().length > 0) {
+          existing.push(candidate);
+        }
+      } catch {
+      }
+    }
+    if (existing.length === 1) {
+      this.logger.warn(
+        `Could not read symref HEAD for '${repoUrl}'; using the only common branch found ('${existing[0]}') as the default.`
+      );
+      return existing[0];
+    }
+    if (existing.length > 1) {
+      throw new Error(
+        `Unable to detect default branch for '${repoUrl}': symref HEAD is unavailable and multiple common branches exist (${existing.join(", ")}). Set 'branch' explicitly in the repository config.`
+      );
+    }
+    throw new Error(
+      `Unable to detect default branch for '${repoUrl}'. Set 'branch' explicitly in the repository config or ensure the remote is reachable.`
+    );
+  }
+  async verifyLfs(worktreePath, label) {
+    if (this.isLfsSkipEnabled()) return;
+    await this.verifyLfsFilesDownloaded(worktreePath, label);
+  }
   async fetchAll() {
     this.assertInitialized();
     this.logger.info("Fetching latest data from remote...");
@@ -2003,7 +2988,7 @@ var GitService = class {
     return branches;
   }
   async verifyLfsFilesDownloaded(worktreePath, branchName) {
-    const worktreeGit = this.config.sparseCheckout ? simpleGit4(worktreePath).env({ ...sanitizeGitEnv(process.env), [ENV_CONSTANTS.GIT_ATTR_SOURCE]: "HEAD" }) : this.getCachedGit(worktreePath);
+    const worktreeGit = this.config.sparseCheckout ? simpleGit5(worktreePath).env({ ...sanitizeGitEnv(process.env), [ENV_CONSTANTS.GIT_ATTR_SOURCE]: "HEAD" }) : this.getCachedGit(worktreePath);
     try {
       const lfsFiles = await worktreeGit.raw(["lfs", "ls-files", "--name-only"]);
       let lfsFileList = lfsFiles.trim().split("\n").filter((f) => f.length > 0);
@@ -2014,7 +2999,7 @@ var GitService = class {
         const existence = await Promise.all(
           lfsFileList.map(async (f) => {
             try {
-              await fs4.access(path6.join(worktreePath, f));
+              await fs6.access(path8.join(worktreePath, f));
               return f;
             } catch {
               return null;
@@ -2042,9 +3027,9 @@ var GitService = class {
         let allDownloaded = true;
         const notDownloaded = [];
         for (const file of samplesToCheck) {
-          const filePath = path6.join(worktreePath, file);
+          const filePath = path8.join(worktreePath, file);
           try {
-            const handle = await fs4.open(filePath, "r");
+            const handle = await fs6.open(filePath, "r");
             try {
               const buffer = Buffer.alloc(200);
               const { bytesRead } = await handle.read(buffer, 0, buffer.length, 0);
@@ -2069,7 +3054,7 @@ var GitService = class {
         }
         retries++;
         if (retries < maxRetries) {
-          await new Promise((resolve9) => setTimeout(resolve9, retryDelay));
+          await new Promise((resolve11) => setTimeout(resolve11, retryDelay));
         }
       }
       this.logger.warn(
@@ -2131,18 +3116,18 @@ var GitService = class {
   }
   async addWorktree(branchName, worktreePath) {
     const bareGit = this.getCachedGit(this.bareRepoPath, this.isLfsSkipEnabled());
-    const absoluteWorktreePath = path6.resolve(worktreePath);
-    await fs4.mkdir(path6.dirname(absoluteWorktreePath), { recursive: true });
+    const absoluteWorktreePath = path8.resolve(worktreePath);
+    await fs6.mkdir(path8.dirname(absoluteWorktreePath), { recursive: true });
     try {
-      await fs4.access(absoluteWorktreePath);
+      await fs6.access(absoluteWorktreePath);
       const worktrees = await this.getWorktreesFromBare(bareGit);
-      const isValidWorktree = worktrees.some((w) => path6.resolve(w.path) === absoluteWorktreePath);
+      const isValidWorktree = worktrees.some((w) => path8.resolve(w.path) === absoluteWorktreePath);
       if (isValidWorktree) {
         this.logger.info(`  - Worktree for '${branchName}' already exists at '${absoluteWorktreePath}'`);
         return;
       } else {
         this.logger.info(`  - Cleaning up orphaned directory at '${absoluteWorktreePath}'`);
-        await fs4.rm(absoluteWorktreePath, { recursive: true, force: true });
+        await fs6.rm(absoluteWorktreePath, { recursive: true, force: true });
       }
     } catch {
     }
@@ -2181,7 +3166,7 @@ var GitService = class {
       }
       if (errorMessage.includes("already registered worktree")) {
         const worktrees = await this.getWorktreesFromBare(bareGit);
-        const existingWorktree = worktrees.find((w) => path6.resolve(w.path) === absoluteWorktreePath);
+        const existingWorktree = worktrees.find((w) => path8.resolve(w.path) === absoluteWorktreePath);
         if (existingWorktree && !existingWorktree.isPrunable) {
           this.logger.info(`  - Worktree for '${branchName}' was created by concurrent operation`);
           return;
@@ -2189,7 +3174,7 @@ var GitService = class {
         this.logger.warn(`  - Worktree already registered but missing. Pruning and retrying...`);
         await bareGit.raw(["worktree", "prune"]);
         try {
-          await fs4.rm(absoluteWorktreePath, { recursive: true, force: true });
+          await fs6.rm(absoluteWorktreePath, { recursive: true, force: true });
         } catch {
         }
         let retryCreatedNewBranch = false;
@@ -2225,15 +3210,15 @@ var GitService = class {
       }
       this.logger.warn(`  - Failed to create worktree with tracking, falling back to simple add: ${error}`);
       try {
-        await fs4.access(absoluteWorktreePath);
+        await fs6.access(absoluteWorktreePath);
         const worktrees = await this.getWorktreesFromBare(bareGit);
-        const isValidWorktree = worktrees.some((w) => path6.resolve(w.path) === absoluteWorktreePath);
+        const isValidWorktree = worktrees.some((w) => path8.resolve(w.path) === absoluteWorktreePath);
         if (isValidWorktree) {
           this.logger.info(`  - Worktree for '${branchName}' already exists at '${absoluteWorktreePath}'`);
           return;
         } else {
           this.logger.info(`  - Cleaning up orphaned directory at '${absoluteWorktreePath}' before fallback attempt`);
-          await fs4.rm(absoluteWorktreePath, { recursive: true, force: true });
+          await fs6.rm(absoluteWorktreePath, { recursive: true, force: true });
         }
       } catch {
       }
@@ -2257,7 +3242,7 @@ var GitService = class {
         const fallbackErrorMessage = getErrorMessage(fallbackError);
         if (fallbackErrorMessage.includes("already registered worktree")) {
           const worktrees = await this.getWorktreesFromBare(bareGit);
-          const existingWorktree = worktrees.find((w) => path6.resolve(w.path) === absoluteWorktreePath);
+          const existingWorktree = worktrees.find((w) => path8.resolve(w.path) === absoluteWorktreePath);
           if (existingWorktree && !existingWorktree.isPrunable) {
             this.logger.info(`  - Worktree for '${branchName}' was created by concurrent operation during fallback`);
             return;
@@ -2480,6 +3465,40 @@ var GitService = class {
       return false;
     }
   }
+  async classifyRemoteRelationship(worktreePath, branch) {
+    const worktreeGit = this.getCachedGit(worktreePath);
+    let headSha;
+    let remoteSha;
+    try {
+      headSha = (await worktreeGit.revparse(["HEAD"])).trim();
+      remoteSha = (await worktreeGit.revparse([`refs/remotes/origin/${branch}`])).trim();
+    } catch {
+      return "diverged";
+    }
+    if (headSha === remoteSha) return "up_to_date";
+    let mergeBase = "";
+    let mergeBaseFailed = false;
+    try {
+      mergeBase = (await worktreeGit.raw(["merge-base", "HEAD", `origin/${branch}`])).trim();
+    } catch {
+      mergeBaseFailed = true;
+    }
+    if (mergeBaseFailed || !mergeBase) {
+      if (await this.isShallowRepository(worktreeGit)) return "indeterminate_shallow";
+      return "diverged";
+    }
+    if (mergeBase === headSha) return "fast_forward";
+    if (mergeBase === remoteSha) return "local_ahead";
+    return "diverged";
+  }
+  async isShallowRepository(git) {
+    try {
+      const output = await git.raw(["rev-parse", "--is-shallow-repository"]);
+      return output.trim() === "true";
+    } catch {
+      return false;
+    }
+  }
   async getChangedPathsInRange(worktreePath, fromRef, toRef) {
     const worktreeGit = this.getCachedGit(worktreePath);
     try {
@@ -2569,7 +3588,7 @@ var GitService = class {
   async createBranch(branchName, baseBranch) {
     const bareGit = this.getCachedGit(this.bareRepoPath);
     const baseRef = await this.resolveCreateBranchBaseRef(bareGit, baseBranch);
-    await bareGit.raw(["branch", branchName, baseRef]);
+    await bareGit.raw(["branch", "--no-track", branchName, baseRef]);
     this.logger.info(`Created branch '${branchName}' from '${baseRef}'`);
   }
   async pushBranch(branchName) {
@@ -2588,37 +3607,240 @@ var GitService = class {
       isPrunable: w.prunable
     }));
   }
-};
+};
+
+// src/services/progress-emitter.ts
+var ProgressEmitter = class {
+  listeners = /* @__PURE__ */ new Set();
+  onProgress(listener) {
+    this.listeners.add(listener);
+    return () => this.listeners.delete(listener);
+  }
+  emit(event) {
+    for (const listener of [...this.listeners]) {
+      try {
+        listener(event);
+      } catch {
+      }
+    }
+  }
+};
+
+// src/services/repo-operation-lock.ts
+import * as fs7 from "fs/promises";
+import * as path10 from "path";
+import * as lockfile from "proper-lockfile";
+
+// src/utils/lock-path.ts
+import { createHash } from "crypto";
+import * as os from "os";
+import * as path9 from "path";
+function getCloneModeLockTarget(config) {
+  const name = config.name;
+  const configDir = config.__configFileDir;
+  const hash = createHash("sha256").update(path9.resolve(config.worktreeDir)).digest("hex").slice(0, 16);
+  if (configDir) {
+    return {
+      dir: path9.join(configDir, ".sync-worktrees-state"),
+      file: `${sanitizeNameForPath(name ?? "repo", "clone-mode lock name")}-${hash}.lock`
+    };
+  }
+  const stateBase = process.env.XDG_STATE_HOME && process.env.XDG_STATE_HOME.length > 0 ? process.env.XDG_STATE_HOME : path9.join(os.homedir(), ".cache");
+  const dir = path9.join(stateBase, "sync-worktrees", "locks");
+  return { dir, file: `${hash}.lock` };
+}
+
+// src/services/repo-operation-lock.ts
+var RepoOperationLock = class {
+  constructor(config, gitService, logger = Logger.createDefault()) {
+    this.config = config;
+    this.gitService = gitService;
+    this.logger = logger;
+  }
+  updateLogger(logger) {
+    this.logger = logger;
+  }
+  async acquire() {
+    if (process.env.NODE_ENV === ENV_CONSTANTS.NODE_ENV_TEST) {
+      return async () => {
+      };
+    }
+    if (resolveMode(this.config) === REPOSITORY_MODES.CLONE) {
+      return this.acquireCloneModeLock();
+    }
+    return this.acquireWorktreeModeLock();
+  }
+  async acquireCloneModeLock() {
+    const target = getCloneModeLockTarget(this.config);
+    const lockTarget = path10.join(target.dir, target.file);
+    try {
+      await fs7.mkdir(target.dir, { recursive: true });
+      await fs7.writeFile(lockTarget, "", { flag: "a" });
+    } catch {
+      return null;
+    }
+    return this.lockPath(lockTarget);
+  }
+  async acquireWorktreeModeLock() {
+    const barePath = this.gitService.getBareRepoPath();
+    try {
+      await fs7.mkdir(barePath, { recursive: true });
+    } catch {
+      return null;
+    }
+    return this.lockPath(barePath);
+  }
+  async lockPath(lockTarget) {
+    try {
+      return await lockfile.lock(lockTarget, {
+        stale: DEFAULT_CONFIG.LOCK_STALE_MS,
+        update: DEFAULT_CONFIG.LOCK_UPDATE_MS,
+        retries: 0,
+        realpath: false
+      });
+    } catch (error) {
+      const code = error.code;
+      if (code === "ELOCKED") {
+        return null;
+      }
+      this.logger.warn(
+        `Could not acquire repo lock at '${lockTarget}' (${code ?? "unknown"}: ${getErrorMessage(error)}); skipping.`
+      );
+      return null;
+    }
+  }
+};
+
+// src/services/sync-retry-policy.ts
+var SyncRetryPolicy = class {
+  constructor(config, gitService, logger) {
+    this.config = config;
+    this.gitService = gitService;
+    this.logger = logger;
+  }
+  updateLogger(logger) {
+    this.logger = logger;
+  }
+  createContext() {
+    return { lfsSkipEnabled: false };
+  }
+  createOptions(syncContext) {
+    return {
+      maxAttempts: this.config.retry?.maxAttempts ?? 3,
+      maxLfsRetries: this.config.retry?.maxLfsRetries ?? 2,
+      initialDelayMs: this.config.retry?.initialDelayMs ?? 1e3,
+      maxDelayMs: this.config.retry?.maxDelayMs ?? 3e4,
+      backoffMultiplier: this.config.retry?.backoffMultiplier ?? 2,
+      jitterMs: this.config.retry?.jitterMs ?? 0,
+      onRetry: (error, attempt, context) => {
+        const errorMessage = getErrorMessage(error);
+        this.logger.info(`
+\u26A0\uFE0F  Sync attempt ${attempt} failed: ${errorMessage}`);
+        if (context?.isLfsError && !this.config.skipLfs) {
+          this.logger.info(`\u{1F504} LFS error detected. Will retry with LFS skipped...`);
+        } else {
+          this.logger.info(`\u{1F504} Retrying synchronization...
+`);
+        }
+      },
+      lfsRetryHandler: () => {
+        if (!this.config.skipLfs && !syncContext.lfsSkipEnabled) {
+          this.logger.info("\u26A0\uFE0F  Temporarily disabling LFS downloads for this sync...");
+          this.gitService.setLfsSkipEnabled(true);
+          syncContext.lfsSkipEnabled = true;
+        }
+      }
+    };
+  }
+  resetLfsSkipIfNeeded(syncContext) {
+    if (syncContext.lfsSkipEnabled && !this.config.skipLfs) {
+      this.gitService.setLfsSkipEnabled(false);
+    }
+  }
+};
+
+// src/services/worktree-mode-sync-runner.ts
+import * as fs9 from "fs/promises";
+import * as path13 from "path";
+import pLimit from "p-limit";
+
+// src/utils/date-filter.ts
+function parseDuration(durationStr) {
+  const match = durationStr.match(/^(\d+)([hdwmy])$/);
+  if (!match) {
+    return null;
+  }
+  const value = parseInt(match[1], 10);
+  const unit = match[2];
+  const multipliers = {
+    h: 60 * 60 * 1e3,
+    // hours
+    d: 24 * 60 * 60 * 1e3,
+    // days
+    w: 7 * 24 * 60 * 60 * 1e3,
+    // weeks
+    m: 30 * 24 * 60 * 60 * 1e3,
+    // months (approximate)
+    y: 365 * 24 * 60 * 60 * 1e3
+    // years (approximate)
+  };
+  return value * multipliers[unit];
+}
+function filterBranchesByAge(branches, maxAge) {
+  const maxAgeMs = parseDuration(maxAge);
+  if (maxAgeMs === null) {
+    console.warn(`Invalid duration format: ${maxAge}. Using all branches.`);
+    return branches;
+  }
+  const cutoffDate = new Date(Date.now() - maxAgeMs);
+  return branches.filter(({ lastActivity }) => lastActivity >= cutoffDate);
+}
+function formatDuration2(durationStr) {
+  const match = durationStr.match(/^(\d+)([hdwmy])$/);
+  if (!match) {
+    return durationStr;
+  }
+  const value = parseInt(match[1], 10);
+  const unit = match[2];
+  const unitNames = {
+    h: value === 1 ? "hour" : "hours",
+    d: value === 1 ? "day" : "days",
+    w: value === 1 ? "week" : "weeks",
+    m: value === 1 ? "month" : "months",
+    y: value === 1 ? "year" : "years"
+  };
+  return `${value} ${unitNames[unit]}`;
+}
 
 // src/services/path-resolution.service.ts
-import { createHash } from "crypto";
-import * as fs5 from "fs";
-import * as path7 from "path";
+import { createHash as createHash2 } from "crypto";
+import * as fs8 from "fs";
+import * as path11 from "path";
 var BRANCH_STEM_MAX = 80;
 var BRANCH_HASH_LEN = 8;
 var PathResolutionService = class {
   sanitizeBranchName(branchName) {
     const stem = branchName.replace(/\//g, "-").replace(/[^a-zA-Z0-9_-]/g, "_").slice(0, BRANCH_STEM_MAX);
-    const hash = createHash("sha256").update(branchName).digest("hex").slice(0, BRANCH_HASH_LEN);
+    const hash = createHash2("sha256").update(branchName).digest("hex").slice(0, BRANCH_HASH_LEN);
     return `${stem}-${hash}`;
   }
   getBranchWorktreePath(worktreeDir, branchName) {
-    return path7.join(worktreeDir, this.sanitizeBranchName(branchName));
+    return path11.join(worktreeDir, this.sanitizeBranchName(branchName));
   }
   resolveRealPath(inputPath) {
-    const absolute = path7.resolve(inputPath);
+    const absolute = path11.resolve(inputPath);
     const missing = [];
     let current = absolute;
-    while (!fs5.existsSync(current)) {
-      const parent = path7.dirname(current);
+    while (!fs8.existsSync(current)) {
+      const parent = path11.dirname(current);
       if (parent === current) {
         return absolute;
       }
-      missing.unshift(path7.basename(current));
+      missing.unshift(path11.basename(current));
       current = parent;
     }
     try {
-      return path7.join(fs5.realpathSync(current), ...missing);
+      return path11.join(fs8.realpathSync(current), ...missing);
     } catch {
       return absolute;
     }
@@ -2628,7 +3850,7 @@ var PathResolutionService = class {
     const a = fold(resolved);
     const b = fold(resolvedBase);
     if (a === b) return true;
-    return a.length > b.length && a.charAt(b.length) === path7.sep && a.startsWith(b);
+    return a.length > b.length && a.charAt(b.length) === path11.sep && a.startsWith(b);
   }
   normalizeWorktreePath(worktreePath, worktreeBaseDir) {
     const resolved = this.resolveRealPath(worktreePath);
@@ -2636,7 +3858,7 @@ var PathResolutionService = class {
     if (!this.isResolvedPathInsideBase(resolved, resolvedBase)) {
       throw new Error(`Worktree path '${worktreePath}' is outside base directory '${worktreeBaseDir}'`);
     }
-    return path7.relative(resolvedBase, resolved);
+    return path11.relative(resolvedBase, resolved);
   }
   isPathInsideBaseDir(targetPath, baseDir) {
     const resolved = this.resolveRealPath(targetPath);
@@ -2648,174 +3870,110 @@ var PathResolutionService = class {
   }
 };
 
-// src/services/worktree-sync.service.ts
-var WorktreeSyncService = class {
-  constructor(config) {
+// src/services/worktree-sync-planner.ts
+import * as path12 from "path";
+function createWorktreeSyncPlan(inventory, options = {}) {
+  return {
+    create: planCreateActions(inventory, options),
+    prune: planPruneActions(inventory),
+    update: options.updateExistingWorktrees === false ? [] : planUpdateActions(inventory),
+    sparse: planSparseActions(inventory, options.sparseCheckout),
+    warnings: []
+  };
+}
+function planCreateActions(inventory, options = {}) {
+  const pathResolution2 = options.pathResolution ?? new PathResolutionService();
+  const existingBranches = new Set(inventory.existingWorktrees.map((w) => w.branch));
+  const newBranches = inventory.remoteBranches.filter(
+    (branch) => !existingBranches.has(branch) && branch !== inventory.defaultBranch
+  );
+  const reservedPaths = /* @__PURE__ */ new Map();
+  for (const worktree of inventory.existingWorktrees) {
+    reservedPaths.set(path12.resolve(worktree.path), worktree.branch);
+  }
+  const actions = [];
+  for (const branch of newBranches) {
+    const worktreePath = pathResolution2.getBranchWorktreePath(inventory.worktreeDir, branch);
+    const resolved = path12.resolve(worktreePath);
+    const conflictingBranch = reservedPaths.get(resolved);
+    if (conflictingBranch && conflictingBranch !== branch) {
+      actions.push({
+        kind: "skip-create",
+        branch,
+        path: worktreePath,
+        reason: "path-collision",
+        conflictingBranch
+      });
+      continue;
+    }
+    reservedPaths.set(resolved, branch);
+    actions.push({ kind: "create", branch, path: worktreePath });
+  }
+  return actions;
+}
+function planPruneActions(inventory) {
+  const remoteBranches = new Set(inventory.remoteBranches);
+  return inventory.existingWorktrees.filter((worktree) => !remoteBranches.has(worktree.branch)).map((worktree) => ({ kind: "check-prune", branch: worktree.branch, path: worktree.path }));
+}
+function planUpdateActions(inventory) {
+  const remoteBranches = new Set(inventory.remoteBranches);
+  return inventory.existingWorktrees.filter((worktree) => remoteBranches.has(worktree.branch)).map((worktree) => ({ kind: "update-candidate", branch: worktree.branch, path: worktree.path }));
+}
+function planSparseActions(inventory, sparseCheckout) {
+  if (!sparseCheckout) {
+    return [];
+  }
+  return inventory.existingWorktrees.map((worktree) => ({
+    kind: "check-sparse",
+    branch: worktree.branch,
+    path: worktree.path
+  }));
+}
+
+// src/services/worktree-mode-sync-runner.ts
+var WorktreeModeSyncRunner = class {
+  constructor(config, gitService, logger, progressEmitter) {
     this.config = config;
-    this.logger = config.logger ?? Logger.createDefault(void 0, config.debug);
-    this.gitService = new GitService(config, this.logger);
+    this.gitService = gitService;
+    this.logger = logger;
+    this.progressEmitter = progressEmitter;
   }
-  gitService;
-  logger;
-  syncInProgress = false;
   pathResolution = new PathResolutionService();
-  progressListeners = /* @__PURE__ */ new Set();
-  async initialize() {
-    this.emitProgress({ phase: "initialize", message: "Initializing repository" });
-    await this.gitService.initialize();
-    this.emitProgress({ phase: "initialize", message: "Repository initialized" });
-  }
-  isInitialized() {
-    return this.gitService.isInitialized();
-  }
-  isSyncInProgress() {
-    return this.syncInProgress;
-  }
-  getGitService() {
-    return this.gitService;
-  }
   updateLogger(logger) {
     this.logger = logger;
-    this.gitService.updateLogger(logger);
-  }
-  onProgress(listener) {
-    this.progressListeners.add(listener);
-    return () => this.progressListeners.delete(listener);
-  }
-  async runExclusiveRepoOperation(operation) {
-    if (this.syncInProgress) {
-      this.logger.warn("\u26A0\uFE0F  Another repository operation is already in progress, skipping...");
-      return { started: false, reason: "in_progress" };
-    }
-    const release = await this.acquireBareLock();
-    if (release === null) {
-      this.logger.warn("\u26A0\uFE0F  Another process holds the sync lock for this repo, skipping...");
-      return { started: false, reason: "locked" };
-    }
-    this.syncInProgress = true;
-    try {
-      return { started: true, value: await operation() };
-    } finally {
-      this.syncInProgress = false;
-      try {
-        await release();
-      } catch (releaseError) {
-        this.logger.warn(`Failed to release sync lock: ${getErrorMessage(releaseError)}`);
-      }
-    }
-  }
-  emitProgress(event) {
-    for (const listener of this.progressListeners) {
-      try {
-        listener(event);
-      } catch {
-      }
-    }
-  }
-  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) {
-      return async () => {
-      };
-    }
-    if (typeof this.gitService.getBareRepoPath !== "function") {
-      return async () => {
-      };
-    }
-    const barePath = this.gitService.getBareRepoPath();
-    await fs6.mkdir(barePath, { recursive: true });
-    try {
-      const release = await lockfile.lock(barePath, {
-        stale: DEFAULT_CONFIG.LOCK_STALE_MS,
-        update: DEFAULT_CONFIG.LOCK_UPDATE_MS,
-        retries: 0,
-        realpath: false
-      });
-      return release;
-    } catch (error) {
-      const code = error.code;
-      if (code === "ELOCKED") {
-        return null;
-      }
-      throw error;
-    }
-  }
-  createRetryOptions(syncContext) {
-    return {
-      maxAttempts: this.config.retry?.maxAttempts ?? 3,
-      maxLfsRetries: this.config.retry?.maxLfsRetries ?? 2,
-      initialDelayMs: this.config.retry?.initialDelayMs ?? 1e3,
-      maxDelayMs: this.config.retry?.maxDelayMs ?? 3e4,
-      backoffMultiplier: this.config.retry?.backoffMultiplier ?? 2,
-      onRetry: (error, attempt, context) => {
-        const errorMessage = getErrorMessage(error);
-        this.logger.info(`
-\u26A0\uFE0F  Sync attempt ${attempt} failed: ${errorMessage}`);
-        if (context?.isLfsError && !this.config.skipLfs) {
-          this.logger.info(`\u{1F504} LFS error detected. Will retry with LFS skipped...`);
-        } else {
-          this.logger.info(`\u{1F504} Retrying synchronization...
-`);
-        }
-      },
-      lfsRetryHandler: () => {
-        if (!this.config.skipLfs && !syncContext.lfsSkipEnabled) {
-          this.logger.info("\u26A0\uFE0F  Temporarily disabling LFS downloads for this sync...");
-          this.gitService.setLfsSkipEnabled(true);
-          syncContext.lfsSkipEnabled = true;
-        }
-      }
-    };
   }
-  async runSyncAttempt(phaseTimer, syncContext) {
+  async runSyncAttempt(phaseTimer, syncContext, outcome) {
     await this.gitService.pruneWorktrees();
     await this.fetchLatestRemoteData(phaseTimer, syncContext);
     const { remoteBranches, defaultBranch } = await this.resolveSyncBranches();
-    await fs6.mkdir(this.config.worktreeDir, { recursive: true });
+    await fs9.mkdir(this.config.worktreeDir, { recursive: true });
     const worktrees = await this.gitService.getWorktrees();
     this.logger.info(`Found ${worktrees.length} existing Git worktrees.`);
     await this.cleanupOrphanedDirectories(worktrees);
-    await this.createNewWorktreesWithTiming(remoteBranches, worktrees, defaultBranch, phaseTimer);
-    await this.pruneOldWorktreesWithTiming(remoteBranches, worktrees, phaseTimer);
+    const syncPlan = createWorktreeSyncPlan(
+      {
+        remoteBranches,
+        defaultBranch,
+        existingWorktrees: worktrees,
+        worktreeDir: this.config.worktreeDir
+      },
+      {
+        pathResolution: this.pathResolution,
+        updateExistingWorktrees: this.config.updateExistingWorktrees !== false,
+        sparseCheckout: this.config.sparseCheckout
+      }
+    );
+    await this.createNewWorktreesWithTiming(syncPlan, phaseTimer, outcome);
+    await this.pruneOldWorktreesWithTiming(syncPlan.prune, phaseTimer, outcome);
     if (this.config.updateExistingWorktrees !== false) {
-      await this.updateExistingWorktreesWithTiming(worktrees, remoteBranches, phaseTimer);
+      await this.updateExistingWorktreesWithTiming(syncPlan.update, phaseTimer, outcome);
     }
     if (this.config.sparseCheckout) {
-      await this.reapplySparseCheckout(worktrees);
+      await this.reapplySparseCheckout(syncPlan.sparse, outcome);
     }
     await this.finalizeSyncAttempt(phaseTimer);
   }
-  async reapplySparseCheckout(worktrees) {
+  async reapplySparseCheckout(actions, outcome) {
     const sparseConfig = this.config.sparseCheckout;
     if (!sparseConfig) return;
     this.logger.info("Step 5: Reconciling sparse-checkout patterns on existing worktrees...");
@@ -2823,32 +3981,44 @@ var WorktreeSyncService = class {
     const desired = sparseService.buildPatterns(sparseConfig);
     const limit = pLimit(this.config.parallelism?.maxStatusChecks ?? DEFAULT_CONFIG.PARALLELISM.MAX_STATUS_CHECKS);
     await Promise.all(
-      worktrees.map(
-        (worktree) => limit(async () => {
+      actions.map(
+        (action) => limit(async () => {
+          if (action.kind !== "check-sparse") return;
           try {
             try {
-              await fs6.access(worktree.path);
+              await fs9.access(action.path);
             } catch {
               return;
             }
-            const current = await sparseService.readCurrent(worktree.path);
+            const current = await sparseService.readCurrent(action.path);
             if (current !== null && sparseService.patternsEqual(current, desired)) return;
             if (sparseService.isNarrowing(current, desired)) {
-              const status = await this.gitService.getFullWorktreeStatus(worktree.path, false);
+              const status = await this.gitService.getFullWorktreeStatus(action.path, false);
               if (!status.canRemove) {
                 this.logger.warn(
-                  `  - Skipping sparse-checkout narrowing for '${worktree.branch}': ${status.reasons.join(", ")}.`
+                  `  - Skipping sparse-checkout narrowing for '${action.branch}': ${status.reasons.join(", ")}.`
                 );
+                outcome.recordSkipped("sparse-checkout", "sparse_narrowing_unsafe", {
+                  branch: action.branch,
+                  path: action.path,
+                  message: status.reasons.join(", ")
+                });
                 return;
               }
             }
-            await sparseService.applyToWorktree(worktree.path, sparseConfig);
-            await this.gitService.checkoutHead(worktree.path);
-            this.logger.info(`  - \u2705 Sparse-checkout updated for '${worktree.branch}'`);
+            await sparseService.applyToWorktree(action.path, sparseConfig);
+            await this.gitService.checkoutHead(action.path);
+            this.logger.info(`  - \u2705 Sparse-checkout updated for '${action.branch}'`);
+            outcome.recordUpdated(action.branch, action.path, "sparse_checkout");
           } catch (error) {
             this.logger.warn(
-              `  - \u26A0\uFE0F Failed to update sparse-checkout for '${worktree.branch}': ${getErrorMessage(error)}`
+              `  - \u26A0\uFE0F Failed to update sparse-checkout for '${action.branch}': ${getErrorMessage(error)}`
             );
+            outcome.recordFailed("sparse-checkout", getErrorMessage(error), {
+              reason: "sparse_checkout_failed",
+              branch: action.branch,
+              path: action.path
+            });
           }
         })
       )
@@ -2857,7 +4027,7 @@ var WorktreeSyncService = class {
   async fetchLatestRemoteData(phaseTimer, syncContext) {
     this.logger.info("Step 1: Fetching latest data from remote...");
     phaseTimer.startPhase("Phase 1: Fetch");
-    this.emitProgress({ phase: "fetch", message: "Fetching latest data from remote" });
+    this.progressEmitter.emit({ phase: "fetch", message: "Fetching latest data from remote" });
     try {
       await this.gitService.fetchAll();
     } catch (fetchError) {
@@ -2902,7 +4072,7 @@ var WorktreeSyncService = class {
     const filteredBranches = filterBranchesByAge(filteredByName, this.config.branchMaxAge);
     const remoteBranches = filteredBranches.map((b) => b.branch);
     this.logger.info(
-      `After filtering by age (${formatDuration(this.config.branchMaxAge)}): ${remoteBranches.length} branches.`
+      `After filtering by age (${formatDuration2(this.config.branchMaxAge)}): ${remoteBranches.length} branches.`
     );
     if (filteredByName.length > remoteBranches.length) {
       const excludedCount = filteredByName.length - remoteBranches.length;
@@ -2921,45 +4091,38 @@ var WorktreeSyncService = class {
   }
   async finalizeSyncAttempt(phaseTimer) {
     phaseTimer.startPhase("Phase 5: Cleanup");
-    this.emitProgress({ phase: "cleanup", message: "Pruning worktree metadata" });
+    this.progressEmitter.emit({ phase: "cleanup", message: "Pruning worktree metadata" });
     await this.gitService.pruneWorktrees();
     this.logger.info("Step 5: Pruned worktree metadata.");
     phaseTimer.endPhase();
   }
-  async createNewWorktreesWithTiming(remoteBranches, worktrees, defaultBranch, phaseTimer) {
+  async createNewWorktreesWithTiming(syncPlan, phaseTimer, outcome) {
     const maxConcurrent = this.config.parallelism?.maxWorktreeCreation ?? DEFAULT_CONFIG.PARALLELISM.MAX_WORKTREE_CREATION;
     phaseTimer.startPhase("Phase 2: Create", maxConcurrent);
-    this.emitProgress({ phase: "create", message: "Creating worktrees for new branches" });
-    await this.createNewWorktrees(remoteBranches, worktrees, defaultBranch);
-    const existingBranches = new Set(worktrees.map((w) => w.branch));
-    const newBranches = remoteBranches.filter((b) => !existingBranches.has(b) && b !== defaultBranch);
-    phaseTimer.setPhaseCount("Phase 2: Create", newBranches.length);
+    this.progressEmitter.emit({ phase: "create", message: "Creating worktrees for new branches" });
+    await this.createNewWorktrees(syncPlan.create, outcome);
+    phaseTimer.setPhaseCount("Phase 2: Create", syncPlan.create.length);
     phaseTimer.endPhase();
   }
-  async createNewWorktrees(remoteBranches, worktrees, defaultBranch) {
-    const existingBranches = new Set(worktrees.map((w) => w.branch));
-    const newBranches = remoteBranches.filter((b) => !existingBranches.has(b) && b !== defaultBranch);
-    if (newBranches.length === 0) {
+  async createNewWorktrees(actions, outcome) {
+    if (actions.length === 0) {
       this.logger.info("Step 2: No new branches to create worktrees for.");
       return;
     }
-    const reservedPaths = /* @__PURE__ */ new Map();
-    for (const w of worktrees) {
-      reservedPaths.set(path8.resolve(w.path), w.branch);
-    }
     const plan = [];
-    for (const branchName of newBranches) {
-      const worktreePath = this.pathResolution.getBranchWorktreePath(this.config.worktreeDir, branchName);
-      const resolved = path8.resolve(worktreePath);
-      const conflict = reservedPaths.get(resolved);
-      if (conflict && conflict !== branchName) {
+    for (const action of actions) {
+      if (action.kind === "skip-create") {
         this.logger.error(
-          `  \u274C Skipping '${branchName}': sanitized worktree path '${worktreePath}' collides with existing branch '${conflict}'.`
+          `  \u274C Skipping '${action.branch}': sanitized worktree path '${action.path}' collides with existing branch '${action.conflictingBranch}'.`
         );
+        outcome.recordSkipped("branch", "path_collision", {
+          branch: action.branch,
+          path: action.path,
+          message: `Path collides with existing branch '${action.conflictingBranch}'`
+        });
         continue;
       }
-      reservedPaths.set(resolved, branchName);
-      plan.push({ branchName, worktreePath });
+      plan.push({ branchName: action.branch, worktreePath: action.path });
     }
     this.logger.info(`Step 2: Creating ${plan.length} new worktrees...`);
     const maxConcurrent = this.config.parallelism?.maxWorktreeCreation ?? DEFAULT_CONFIG.PARALLELISM.MAX_WORKTREE_CREATION;
@@ -2970,8 +4133,14 @@ var WorktreeSyncService = class {
           try {
             await this.gitService.addWorktree(branchName, worktreePath);
             this.logger.info(`  \u2705 Created worktree for '${branchName}'`);
+            outcome.recordCreated(branchName, worktreePath);
           } catch (error) {
             this.logger.error(`  \u274C Failed to create worktree for '${branchName}':`, getErrorMessage(error));
+            outcome.recordFailed("worktree", getErrorMessage(error), {
+              reason: "create_failed",
+              branch: branchName,
+              path: worktreePath
+            });
             throw error;
           }
         })
@@ -2980,23 +4149,21 @@ var WorktreeSyncService = class {
     const successCount = results.filter((r) => r.status === "fulfilled").length;
     this.logger.info(`  Created ${successCount}/${plan.length} worktrees successfully`);
   }
-  async pruneOldWorktreesWithTiming(remoteBranches, worktrees, phaseTimer) {
+  async pruneOldWorktreesWithTiming(actions, phaseTimer, outcome) {
     const maxConcurrent = this.config.parallelism?.maxStatusChecks ?? DEFAULT_CONFIG.PARALLELISM.MAX_STATUS_CHECKS;
     phaseTimer.startPhase("Phase 3: Prune", maxConcurrent);
-    this.emitProgress({ phase: "prune", message: "Pruning stale worktrees" });
-    await this.pruneOldWorktrees(remoteBranches, worktrees);
-    const deletedWorktrees = worktrees.filter((w) => !remoteBranches.includes(w.branch));
-    phaseTimer.setPhaseCount("Phase 3: Prune", deletedWorktrees.length);
+    this.progressEmitter.emit({ phase: "prune", message: "Pruning stale worktrees" });
+    await this.pruneOldWorktrees(actions, outcome);
+    phaseTimer.setPhaseCount("Phase 3: Prune", actions.length);
     phaseTimer.endPhase();
   }
-  async pruneOldWorktrees(remoteBranches, worktrees) {
-    const deletedWorktrees = worktrees.filter((w) => !remoteBranches.includes(w.branch));
-    if (deletedWorktrees.length > 0) {
-      this.logger.info(`Step 3: Checking ${deletedWorktrees.length} stale worktrees to prune...`);
+  async pruneOldWorktrees(actions, outcome) {
+    if (actions.length > 0) {
+      this.logger.info(`Step 3: Checking ${actions.length} stale worktrees to prune...`);
       const maxConcurrent = this.config.parallelism?.maxStatusChecks ?? DEFAULT_CONFIG.PARALLELISM.MAX_STATUS_CHECKS;
       const limit = pLimit(maxConcurrent);
       const statusResults = await Promise.allSettled(
-        deletedWorktrees.map(
+        actions.map(
           ({ branch: branchName, path: worktreePath }) => limit(async () => {
             const status = await this.gitService.getFullWorktreeStatus(worktreePath, this.config.debug);
             return { branchName, worktreePath, status };
@@ -3019,6 +4186,10 @@ var WorktreeSyncService = class {
           const branchName = result.reason?.branchName ?? "unknown";
           this.logger.error(`  - Error checking worktree '${branchName}':`, result.reason);
           this.logger.warn(`  - \u26A0\uFE0F Skipping removal of '${branchName}' due to status check failure (conservative)`);
+          outcome.recordSkipped("worktree", "prune_status_check_failed", {
+            branch: branchName,
+            message: getErrorMessage(result.reason)
+          });
         }
       }
       if (toRemove.length > 0) {
@@ -3034,12 +4205,23 @@ var WorktreeSyncService = class {
                   this.logger.warn(
                     `  \u26A0\uFE0F Skipping removal of '${branchName}' - status changed since initial check: ${recheck.reasons.join(", ")}`
                   );
+                  outcome.recordSkipped("worktree", "prune_status_changed", {
+                    branch: branchName,
+                    path: worktreePath,
+                    message: recheck.reasons.join(", ")
+                  });
                   return;
                 }
                 await this.gitService.removeWorktree(worktreePath);
                 this.logger.info(`  \u2705 Removed worktree for '${branchName}'`);
+                outcome.recordRemoved(branchName, worktreePath);
               } catch (error) {
                 this.logger.error(`  \u274C Failed to remove worktree for '${branchName}':`, getErrorMessage(error));
+                outcome.recordFailed("worktree", getErrorMessage(error), {
+                  reason: "remove_failed",
+                  branch: branchName,
+                  path: worktreePath
+                });
                 throw error;
               }
             })
@@ -3052,6 +4234,11 @@ var WorktreeSyncService = class {
         this.logger.info(`  Skipped ${toSkip.length} worktree(s) with local changes or unpushed commits`);
       }
       for (const { branchName, worktreePath, status } of toSkip) {
+        outcome.recordSkipped("worktree", "unsafe_to_remove", {
+          branch: branchName,
+          path: worktreePath,
+          message: status.reasons.join(", ")
+        });
         if (status.upstreamGone && status.hasUnpushedCommits) {
           this.logger.warn(`  - \u26A0\uFE0F Cannot automatically remove '${branchName}' - upstream branch was deleted.`);
           this.logger.info(`     Please review manually: cd ${worktreePath} && git log`);
@@ -3144,53 +4331,52 @@ var WorktreeSyncService = class {
       this.logger.info(`   These branches will be skipped: ${failedBranches.join(", ")}`);
     }
   }
-  async updateExistingWorktreesWithTiming(worktrees, remoteBranches, phaseTimer) {
+  async updateExistingWorktreesWithTiming(actions, phaseTimer, outcome) {
     const maxConcurrent = this.config.parallelism?.maxWorktreeUpdates ?? DEFAULT_CONFIG.PARALLELISM.MAX_WORKTREE_UPDATES;
     phaseTimer.startPhase("Phase 4: Update", maxConcurrent);
-    this.emitProgress({ phase: "update", message: "Updating existing worktrees" });
-    await this.updateExistingWorktrees(worktrees, remoteBranches);
-    const activeWorktrees = worktrees.filter((w) => remoteBranches.includes(w.branch));
-    phaseTimer.setPhaseCount("Phase 4: Update", activeWorktrees.length);
+    this.progressEmitter.emit({ phase: "update", message: "Updating existing worktrees" });
+    await this.updateExistingWorktrees(actions, outcome);
+    phaseTimer.setPhaseCount("Phase 4: Update", actions.length);
     phaseTimer.endPhase();
   }
-  async updateExistingWorktrees(worktrees, remoteBranches) {
+  async updateExistingWorktrees(actions, outcome) {
     this.logger.info("Step 4: Checking for worktrees that need updates...");
-    const divergedDir = path8.join(this.config.worktreeDir, GIT_CONSTANTS.DIVERGED_DIR_NAME);
+    const divergedDir = path13.join(this.config.worktreeDir, GIT_CONSTANTS.DIVERGED_DIR_NAME);
     try {
-      const diverged = await fs6.readdir(divergedDir);
+      const diverged = await fs9.readdir(divergedDir);
       if (diverged.length > 0) {
         this.logger.info(
-          `\u{1F4E6} Note: ${diverged.length} diverged worktree(s) in ${path8.relative(process.cwd(), divergedDir)}`
+          `\u{1F4E6} Note: ${diverged.length} diverged worktree(s) in ${path13.relative(process.cwd(), divergedDir)}`
         );
       }
     } catch {
     }
-    const activeWorktrees = worktrees.filter((w) => remoteBranches.includes(w.branch));
     const maxConcurrent = this.config.parallelism?.maxStatusChecks ?? DEFAULT_CONFIG.PARALLELISM.MAX_STATUS_CHECKS;
     const limit = pLimit(maxConcurrent);
     const checkResults = await Promise.allSettled(
-      activeWorktrees.map(
-        (worktree) => limit(async () => {
+      actions.map(
+        (action) => limit(async () => {
+          const worktree = { path: action.path, branch: action.branch };
           try {
-            await fs6.access(worktree.path);
+            await fs9.access(worktree.path);
           } catch {
-            return null;
+            return { action: "skip", worktree, reason: "missing_worktree_path" };
           }
           const hasOp = await this.gitService.hasOperationInProgress(worktree.path);
-          if (hasOp) return null;
+          if (hasOp) return { action: "skip", worktree, reason: "operation_in_progress" };
           const isClean = await this.gitService.checkWorktreeStatus(worktree.path);
-          if (!isClean) return null;
+          if (!isClean) return { action: "skip", worktree, reason: "dirty_worktree" };
           const canFastForward = await this.gitService.canFastForward(worktree.path, worktree.branch);
           if (!canFastForward) {
             const isAhead = await this.gitService.isLocalAheadOfRemote(worktree.path, worktree.branch);
             if (isAhead) {
               this.logger.info(`\u23ED\uFE0F  Skipping '${worktree.branch}' - has unpushed commits`);
-              return null;
+              return { action: "skip", worktree, reason: "local_ahead" };
             }
             return { action: "diverged", worktree };
           }
           const isBehind = await this.gitService.isWorktreeBehind(worktree.path);
-          if (!isBehind) return null;
+          if (!isBehind) return { action: "noop", worktree, reason: "already_up_to_date" };
           const sparseCfg = this.config.sparseCheckout;
           if (sparseCfg && sparseCfg.skipUpdateWhenOutsideSparse !== false) {
             const sparseService = this.gitService.getSparseCheckoutService();
@@ -3202,7 +4388,7 @@ var WorktreeSyncService = class {
               );
               if (diff !== null && !sparseService.pathsTouchSparse(diff, sparseCfg)) {
                 this.logger.info(`\u23ED\uFE0F  Skipping '${worktree.branch}' - upstream changes outside sparse paths`);
-                return null;
+                return { action: "skip", worktree, reason: "outside_sparse_checkout" };
               }
             }
           }
@@ -3214,13 +4400,25 @@ var WorktreeSyncService = class {
     const divergedWorktrees = [];
     for (const result of checkResults) {
       if (result.status === "fulfilled" && result.value) {
-        if (result.value.action === "update") {
-          worktreesToUpdate.push(result.value.worktree);
-        } else {
-          divergedWorktrees.push(result.value.worktree);
+        switch (result.value.action) {
+          case "update":
+            worktreesToUpdate.push(result.value.worktree);
+            break;
+          case "diverged":
+            divergedWorktrees.push(result.value.worktree);
+            break;
+          case "noop":
+            outcome.recordNoop("worktree", result.value.reason, result.value.worktree);
+            break;
+          case "skip":
+            outcome.recordSkipped("worktree", result.value.reason, result.value.worktree);
+            break;
         }
       } else if (result.status === "rejected") {
         this.logger.error(`  - Error checking worktree:`, result.reason);
+        outcome.recordSkipped("worktree", "update_check_failed", {
+          message: getErrorMessage(result.reason)
+        });
       }
     }
     const updateLimit = pLimit(
@@ -3234,6 +4432,7 @@ var WorktreeSyncService = class {
             this.logger.info(`  - Updating worktree '${worktree.branch}'...`);
             await this.gitService.updateWorktree(worktree.path);
             this.logger.info(`    \u2705 Successfully updated '${worktree.branch}'.`);
+            outcome.recordUpdated(worktree.branch, worktree.path, "fast_forward");
           } catch (error) {
             const errorMessage = getErrorMessage(error);
             if (ERROR_MESSAGES.FAST_FORWARD_FAILED.some((msg) => errorMessage.includes(msg))) {
@@ -3241,13 +4440,23 @@ var WorktreeSyncService = class {
                 `    \u26A0\uFE0F Branch '${worktree.branch}' cannot be fast-forwarded. Checking for divergence...`
               );
               try {
-                await this.handleDivergedBranch(worktree);
+                await this.handleDivergedBranch(worktree, outcome);
               } catch (divergedError) {
                 this.logger.error(`    \u274C Failed to handle diverged branch '${worktree.branch}':`, divergedError);
+                outcome.recordFailed("worktree", getErrorMessage(divergedError), {
+                  reason: "diverged_recovery_failed",
+                  branch: worktree.branch,
+                  path: worktree.path
+                });
                 throw divergedError;
               }
             } else {
               this.logger.error(`    \u274C Failed to update '${worktree.branch}':`, error);
+              outcome.recordFailed("worktree", errorMessage, {
+                reason: "update_failed",
+                branch: worktree.branch,
+                path: worktree.path
+              });
               throw error;
             }
           }
@@ -3259,9 +4468,14 @@ var WorktreeSyncService = class {
       mutationTasks.push(
         updateLimit(async () => {
           try {
-            await this.handleDivergedBranch(worktree);
+            await this.handleDivergedBranch(worktree, outcome);
           } catch (error) {
             this.logger.error(`    \u274C Failed to handle diverged branch '${worktree.branch}':`, error);
+            outcome.recordFailed("worktree", getErrorMessage(error), {
+              reason: "diverged_recovery_failed",
+              branch: worktree.branch,
+              path: worktree.path
+            });
             throw error;
           }
           return { type: "diverged", branch: worktree.branch };
@@ -3284,13 +4498,13 @@ var WorktreeSyncService = class {
   }
   async cleanupOrphanedDirectories(worktrees) {
     try {
-      const worktreeRelativePaths = worktrees.map((w) => path8.relative(this.config.worktreeDir, w.path));
-      const allDirs = await fs6.readdir(this.config.worktreeDir);
+      const worktreeRelativePaths = worktrees.map((w) => path13.relative(this.config.worktreeDir, w.path));
+      const allDirs = await fs9.readdir(this.config.worktreeDir);
       const regularDirs = allDirs.filter((dir) => !dir.startsWith("."));
       const orphanedDirs = [];
       for (const dir of regularDirs) {
         const isPartOfWorktree = worktreeRelativePaths.some((worktreePath) => {
-          return worktreePath === dir || worktreePath.startsWith(dir + path8.sep);
+          return worktreePath === dir || worktreePath.startsWith(dir + path13.sep);
         });
         if (!isPartOfWorktree) {
           orphanedDirs.push(dir);
@@ -3299,11 +4513,11 @@ var WorktreeSyncService = class {
       if (orphanedDirs.length > 0) {
         this.logger.info(`Found ${orphanedDirs.length} orphaned directories: ${orphanedDirs.join(", ")}`);
         for (const dir of orphanedDirs) {
-          const dirPath = path8.join(this.config.worktreeDir, dir);
+          const dirPath = path13.join(this.config.worktreeDir, dir);
           try {
-            const stat4 = await fs6.stat(dirPath);
+            const stat4 = await fs9.stat(dirPath);
             if (stat4.isDirectory()) {
-              await fs6.rm(dirPath, { recursive: true, force: true });
+              await fs9.rm(dirPath, { recursive: true, force: true });
               this.logger.info(`  - Removed orphaned directory: ${dir}`);
             }
           } catch (error) {
@@ -3315,13 +4529,14 @@ var WorktreeSyncService = class {
       this.logger.error("Error during orphaned directory cleanup:", error);
     }
   }
-  async handleDivergedBranch(worktree) {
+  async handleDivergedBranch(worktree, outcome) {
     this.logger.info(`\u26A0\uFE0F  Branch '${worktree.branch}' has diverged from upstream. Analyzing...`);
     const treesIdentical = await this.gitService.compareTreeContent(worktree.path, worktree.branch);
     if (treesIdentical) {
       this.logger.info(`\u2705 Branch '${worktree.branch}' was rebased but files are identical. Resetting to upstream...`);
       await this.gitService.resetToUpstream(worktree.path, worktree.branch);
       this.logger.info(`   Successfully updated '${worktree.branch}' to match upstream.`);
+      outcome.recordUpdated(worktree.branch, worktree.path, "reset_identical_tree");
     } else {
       const hasLocalChanges = await this.hasLocalChangesSinceLastSync(worktree.path);
       if (!hasLocalChanges) {
@@ -3330,10 +4545,12 @@ var WorktreeSyncService = class {
         );
         await this.gitService.resetToUpstream(worktree.path, worktree.branch);
         this.logger.info(`   Successfully updated '${worktree.branch}' to match upstream.`);
+        outcome.recordUpdated(worktree.branch, worktree.path, "reset_no_local_changes");
       } else {
         this.logger.info(`\u{1F512} Branch '${worktree.branch}' has diverged with local changes. Moving to diverged...`);
         const divergedPath = await this.divergeWorktree(worktree.path, worktree.branch);
-        const relativePath = path8.relative(process.cwd(), divergedPath);
+        const relativePath = path13.relative(process.cwd(), divergedPath);
+        outcome.recordPreservedDiverged(worktree.branch, worktree.path, divergedPath);
         this.logger.info(`   Moved to: ${relativePath}`);
         this.logger.info(`   Your local changes are preserved. To review:`);
         this.logger.info(`     cd ${relativePath}`);
@@ -3344,55 +4561,238 @@ var WorktreeSyncService = class {
       }
     }
   }
-  async hasLocalChangesSinceLastSync(worktreePath) {
+  async hasLocalChangesSinceLastSync(worktreePath) {
+    try {
+      const metadata = await this.gitService.getWorktreeMetadata(worktreePath);
+      if (!metadata || !metadata.lastSyncCommit) {
+        return true;
+      }
+      const currentCommit = await this.gitService.getCurrentCommit(worktreePath);
+      return currentCommit !== metadata.lastSyncCommit;
+    } catch {
+      return true;
+    }
+  }
+  async divergeWorktree(worktreePath, branchName) {
+    const divergedBaseDir = path13.join(this.config.worktreeDir, GIT_CONSTANTS.DIVERGED_DIR_NAME);
+    const timestamp = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
+    const uniqueSuffix = Date.now().toString(36) + Math.random().toString(36).substring(2, 7);
+    const safeBranchName = this.pathResolution.sanitizeBranchName(branchName);
+    const divergedName = `${timestamp}-${safeBranchName}-${uniqueSuffix}`;
+    const divergedPath = path13.join(divergedBaseDir, divergedName);
+    await fs9.mkdir(divergedBaseDir, { recursive: true });
+    try {
+      await fs9.rename(worktreePath, divergedPath);
+    } catch (err) {
+      if (err.code === ERROR_MESSAGES.EXDEV) {
+        await fs9.cp(worktreePath, divergedPath, { recursive: true });
+        await fs9.rm(worktreePath, { recursive: true, force: true });
+      } else {
+        throw err;
+      }
+    }
+    const metadata = {
+      originalBranch: branchName,
+      divergedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      reason: METADATA_CONSTANTS.DIVERGED_REASON,
+      originalPath: worktreePath,
+      localCommit: await this.gitService.getCurrentCommit(divergedPath),
+      remoteCommit: await this.gitService.getRemoteCommit(`origin/${branchName}`),
+      instruction: `To preserve your changes:
+  1. Review: git diff origin/${branchName}
+  2. Keep changes: git push --force-with-lease origin ${branchName}
+  3. Discard changes: rm -rf this directory
+
+  Original worktree location: ${worktreePath}`
+    };
+    await fs9.writeFile(
+      path13.join(divergedPath, METADATA_CONSTANTS.DIVERGED_INFO_FILE),
+      JSON.stringify(metadata, null, 2)
+    );
+    return divergedPath;
+  }
+};
+
+// src/services/worktree-sync.service.ts
+var WorktreeSyncService = class {
+  constructor(config) {
+    this.config = config;
+    this.logger = config.logger ?? Logger.createDefault(void 0, config.debug);
+    this.gitService = new GitService(config, this.logger);
+    this.repoOperationLock = new RepoOperationLock(config, this.gitService, this.logger);
+    this.retryPolicy = new SyncRetryPolicy(config, this.gitService, this.logger);
+    this.worktreeModeSyncRunner = new WorktreeModeSyncRunner(
+      config,
+      this.gitService,
+      this.logger,
+      this.progressEmitter
+    );
+    if (resolveMode(config) === REPOSITORY_MODES.CLONE) {
+      this.cloneSyncService = new CloneSyncService(config, this.gitService, this.logger, {
+        progressEmitter: (event) => this.emitProgress(event),
+        onSkip: (reason) => {
+          this.skipsAccumulator.push(reason);
+        }
+      });
+    }
+  }
+  gitService;
+  cloneSyncService = null;
+  logger;
+  syncInProgress = false;
+  progressEmitter = new ProgressEmitter();
+  repoOperationLock;
+  retryPolicy;
+  worktreeModeSyncRunner;
+  skipsAccumulator = [];
+  lastOutcome = null;
+  getRecordedSkips() {
+    return [...this.skipsAccumulator];
+  }
+  clearRecordedSkips() {
+    this.skipsAccumulator = [];
+  }
+  clearPendingInitSkip() {
+    this.cloneSyncService?.clearPendingInitSkip();
+  }
+  getLastOutcome() {
+    return this.lastOutcome;
+  }
+  isCloneMode() {
+    return this.cloneSyncService !== null;
+  }
+  async getWorktrees() {
+    if (this.cloneSyncService) {
+      return this.cloneSyncService.getWorktrees();
+    }
+    return this.gitService.getWorktrees();
+  }
+  async initialize() {
+    if (this.isInitialized()) return;
+    const result = await this.runExclusiveRepoOperation(() => this.initializeUnlocked());
+    if (!result.started) {
+      const reason = result.reason === "in_progress" ? "operation in progress" : "another process holds the lock";
+      this.logger.warn(`\u26A0\uFE0F  Initialize skipped: ${reason}`);
+    }
+  }
+  async initializeUnlocked(outcome) {
+    this.emitProgress({ phase: "initialize", message: "Initializing repository" });
+    if (this.cloneSyncService) {
+      await this.cloneSyncService.initialize(outcome);
+    } else {
+      await this.gitService.initialize();
+    }
+    this.emitProgress({ phase: "initialize", message: "Repository initialized" });
+  }
+  isInitialized() {
+    if (this.cloneSyncService) {
+      return this.cloneSyncService.isInitialized();
+    }
+    return this.gitService.isInitialized();
+  }
+  isSyncInProgress() {
+    return this.syncInProgress;
+  }
+  getGitService() {
+    return this.gitService;
+  }
+  updateLogger(logger) {
+    this.logger = logger;
+    this.gitService.updateLogger(logger);
+    this.cloneSyncService?.updateLogger(logger);
+    this.retryPolicy.updateLogger(logger);
+    this.worktreeModeSyncRunner.updateLogger(logger);
+    this.repoOperationLock.updateLogger(logger);
+  }
+  onProgress(listener) {
+    return this.progressEmitter.onProgress(listener);
+  }
+  async runExclusiveRepoOperation(operation) {
+    if (this.syncInProgress) {
+      this.logger.warn("\u26A0\uFE0F  Another repository operation is already in progress, skipping...");
+      return { started: false, reason: "in_progress" };
+    }
+    this.syncInProgress = true;
+    let release;
     try {
-      const metadata = await this.gitService.getWorktreeMetadata(worktreePath);
-      if (!metadata || !metadata.lastSyncCommit) {
-        return true;
-      }
-      const currentCommit = await this.gitService.getCurrentCommit(worktreePath);
-      return currentCommit !== metadata.lastSyncCommit;
-    } catch {
-      return true;
+      release = await this.repoOperationLock.acquire();
+    } catch (error) {
+      this.syncInProgress = false;
+      throw error;
+    }
+    if (release === null) {
+      this.syncInProgress = false;
+      this.logger.warn("\u26A0\uFE0F  Another process holds the sync lock for this repo, skipping...");
+      return { started: false, reason: "locked" };
     }
-  }
-  async divergeWorktree(worktreePath, branchName) {
-    const divergedBaseDir = path8.join(this.config.worktreeDir, GIT_CONSTANTS.DIVERGED_DIR_NAME);
-    const timestamp = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
-    const uniqueSuffix = Date.now().toString(36) + Math.random().toString(36).substring(2, 7);
-    const safeBranchName = this.pathResolution.sanitizeBranchName(branchName);
-    const divergedName = `${timestamp}-${safeBranchName}-${uniqueSuffix}`;
-    const divergedPath = path8.join(divergedBaseDir, divergedName);
-    await fs6.mkdir(divergedBaseDir, { recursive: true });
     try {
-      await fs6.rename(worktreePath, divergedPath);
-    } catch (err) {
-      if (err.code === ERROR_MESSAGES.EXDEV) {
-        await fs6.cp(worktreePath, divergedPath, { recursive: true });
-        await fs6.rm(worktreePath, { recursive: true, force: true });
-      } else {
-        throw err;
+      return { started: true, value: await operation() };
+    } finally {
+      try {
+        await release();
+      } catch (releaseError) {
+        this.logger.warn(`Failed to release sync lock: ${getErrorMessage(releaseError)}`);
       }
+      this.syncInProgress = false;
     }
-    const metadata = {
-      originalBranch: branchName,
-      divergedAt: (/* @__PURE__ */ new Date()).toISOString(),
-      reason: METADATA_CONSTANTS.DIVERGED_REASON,
-      originalPath: worktreePath,
-      localCommit: await this.gitService.getCurrentCommit(divergedPath),
-      remoteCommit: await this.gitService.getRemoteCommit(`origin/${branchName}`),
-      instruction: `To preserve your changes:
-  1. Review: git diff origin/${branchName}
-  2. Keep changes: git push --force-with-lease origin ${branchName}
-  3. Discard changes: rm -rf this directory
-
-  Original worktree location: ${worktreePath}`
-    };
-    await fs6.writeFile(
-      path8.join(divergedPath, METADATA_CONSTANTS.DIVERGED_INFO_FILE),
-      JSON.stringify(metadata, null, 2)
-    );
-    return divergedPath;
+  }
+  emitProgress(event) {
+    this.progressEmitter.emit(event);
+  }
+  async sync() {
+    const result = await this.runExclusiveRepoOperation(async () => {
+      const totalTimer = new Timer();
+      const phaseTimer = new PhaseTimer();
+      const outcome = new SyncOutcomeAccumulator({
+        mode: this.cloneSyncService ? "clone" : "worktree",
+        repoName: this.config.name
+      });
+      const syncContext = this.retryPolicy.createContext();
+      const retryOptions = this.retryPolicy.createOptions(syncContext);
+      let durationMs;
+      try {
+        if (!this.isInitialized()) {
+          await this.initializeUnlocked(outcome);
+        }
+        this.logger.info(`[${(/* @__PURE__ */ new Date()).toISOString()}] Starting worktree synchronization...`);
+        const retryOutcomeBaseline = outcome.snapshot();
+        const retryOptionsWithOutcomeReset = {
+          ...retryOptions,
+          onRetry: (error, attempt, context) => {
+            outcome.restore(retryOutcomeBaseline);
+            retryOptions.onRetry?.(error, attempt, context);
+          }
+        };
+        const cloneSync = this.cloneSyncService;
+        if (cloneSync) {
+          await retry(() => cloneSync.runSyncAttempt(outcome), retryOptionsWithOutcomeReset);
+        } else {
+          await retry(
+            () => this.worktreeModeSyncRunner.runSyncAttempt(phaseTimer, syncContext, outcome),
+            retryOptionsWithOutcomeReset
+          );
+        }
+      } catch (error) {
+        if (outcome.getCounts().failed === 0) {
+          outcome.recordFailed("repo", getErrorMessage(error), { reason: "sync_failed" });
+        }
+        this.logger.error("\n\u274C Error during worktree synchronization after all retry attempts:", error);
+        throw error;
+      } finally {
+        this.retryPolicy.resetLfsSkipIfNeeded(syncContext);
+        this.logger.info(`[${(/* @__PURE__ */ new Date()).toISOString()}] Synchronization finished.
+`);
+        durationMs = totalTimer.stop();
+        this.lastOutcome = outcome.toOutcome(durationMs);
+        if (this.config.debug) {
+          const phaseResults = phaseTimer.getResults();
+          const repoName = this.config.name;
+          this.logger.table(formatTimingTable(durationMs, phaseResults, repoName));
+        }
+      }
+      return this.lastOutcome ?? outcome.toOutcome(durationMs);
+    });
+    return result.started ? { started: true, outcome: result.value } : result;
   }
 };
 
@@ -3442,11 +4842,18 @@ var RepositoryContext = class {
   configPath = null;
   configLoader = new ConfigLoaderService();
   discoveryCache = /* @__PURE__ */ new Map();
+  launchCwd;
+  constructor(options = {}) {
+    this.launchCwd = path14.resolve(options.launchCwd ?? process.cwd());
+  }
+  getLaunchCwd() {
+    return this.launchCwd;
+  }
   async loadConfig(configPath, options = {}) {
     const setDefaultCurrent = options.setDefaultCurrent ?? true;
-    const absolutePath = path9.resolve(configPath);
+    const absolutePath = path14.resolve(configPath);
     const configFile = await this.configLoader.loadConfigFile(absolutePath);
-    const configDir = path9.dirname(absolutePath);
+    const configDir = path14.dirname(absolutePath);
     const globalDefaults = configFile.defaults;
     const resolvedAll = [];
     for (const repo of configFile.repositories) {
@@ -3483,7 +4890,7 @@ var RepositoryContext = class {
     return configFile.repositories;
   }
   async detectFromPath(dirPath) {
-    const absolutePath = path9.resolve(dirPath);
+    const absolutePath = path14.resolve(dirPath);
     const cached = this.discoveryCache.get(absolutePath);
     if (cached && await this.isCacheFresh(cached)) {
       return cached.result;
@@ -3502,8 +4909,8 @@ var RepositoryContext = class {
     const { result, adminDir } = await this.detectFromPathUncached(absolutePath);
     if (result.isWorktree && result.bareRepoPath && adminDir) {
       const [worktreeHeadMtimeMs, worktreesDirMtimeMs] = await Promise.all([
-        safeMtimeMs(path9.join(adminDir, "HEAD")),
-        safeMtimeMs(path9.join(result.bareRepoPath, "worktrees"))
+        safeMtimeMs(path14.join(adminDir, "HEAD")),
+        safeMtimeMs(path14.join(result.bareRepoPath, "worktrees"))
       ]);
       this.discoveryCache.set(absolutePath, {
         result,
@@ -3534,44 +4941,65 @@ var RepositoryContext = class {
   __discoveryCacheSizeForTest() {
     return this.discoveryCache.size;
   }
+  /** @internal Test-only helper — exposes the internal selection state. */
+  __getRepositorySelectionStateForTest() {
+    return this.getRepositorySelectionState();
+  }
   async discoverSiblingRepositories(currentBareRepoPath) {
-    const repoDir = path9.dirname(currentBareRepoPath);
-    const workspaceRoot = path9.dirname(repoDir);
-    if (workspaceRoot === repoDir) return [];
+    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 = path14.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: path14.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 = path14.dirname(currentBareRepoPath);
+    const workspaceRoot = path14.dirname(repoDir);
+    if (workspaceRoot === repoDir) {
+      return Array.from(results.values()).sort(byName);
+    }
     let entries;
     try {
-      entries = await fs7.readdir(workspaceRoot);
+      entries = await fs10.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;
-        }
-        const resolvedBare = path9.resolve(bareCandidate);
-        const matchedName = configBares.get(normalizePathForCompare(resolvedBare));
-        results.push({
+        const candidate = path14.join(workspaceRoot, entry);
+        const bareCandidate = path14.join(candidate, GIT_CONSTANTS.BARE_DIR_NAME);
+        if (!await isDirectory(bareCandidate)) return;
+        const resolvedBare = path14.resolve(bareCandidate);
+        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;
@@ -3583,8 +5011,8 @@ var RepositoryContext = class {
     if (Date.now() - cached.cachedAt >= DISCOVERY_CACHE_TTL_MS) return false;
     if (!cached.worktreeAdminDir || !cached.result.bareRepoPath) return true;
     const [currentHeadMtime, currentWorktreesDirMtime] = await Promise.all([
-      safeMtimeMs(path9.join(cached.worktreeAdminDir, "HEAD")),
-      safeMtimeMs(path9.join(cached.result.bareRepoPath, "worktrees"))
+      safeMtimeMs(path14.join(cached.worktreeAdminDir, "HEAD")),
+      safeMtimeMs(path14.join(cached.result.bareRepoPath, "worktrees"))
     ]);
     return currentHeadMtime === cached.worktreeHeadMtimeMs && currentWorktreesDirMtime === cached.worktreesDirMtimeMs;
   }
@@ -3617,6 +5045,13 @@ var RepositoryContext = class {
       return unsupported("No .git file found in path or any parent directory");
     }
     if (located.kind === "regular-git-dir") {
+      const cloneEntry = this.findConfiguredCloneEntry(worktreeRoot);
+      if (cloneEntry) {
+        return {
+          result: await this.buildCloneModeContext(cloneEntry, worktreeRoot, notes),
+          adminDir: null
+        };
+      }
       return unsupported("Directory has .git folder (regular repo, not a sync-worktrees worktree)");
     }
     const gitFileContent = located.gitFileContent;
@@ -3625,18 +5060,18 @@ var RepositoryContext = class {
       return unsupported("Invalid .git file format (missing gitdir line)");
     }
     const gitdir = gitdirMatch[1].trim();
-    const resolvedGitdir = path9.isAbsolute(gitdir) ? gitdir : path9.resolve(worktreeRoot, gitdir);
+    const resolvedGitdir = path14.isAbsolute(gitdir) ? gitdir : path14.resolve(worktreeRoot, gitdir);
     const worktreesMatch = resolvedGitdir.match(/^(.+?)[/\\]worktrees[/\\][^/\\]+$/);
     if (!worktreesMatch) {
       return unsupported("gitdir does not follow worktree structure (missing /worktrees/<name>)");
     }
-    const bareRepoPath = path9.resolve(worktreesMatch[1]);
-    const adminDir = path9.resolve(resolvedGitdir);
+    const bareRepoPath = path14.resolve(worktreesMatch[1]);
+    const adminDir = path14.resolve(resolvedGitdir);
     let repoUrl = null;
     let worktrees = [];
     let currentBranch = null;
     try {
-      const bareGit = simpleGit5(bareRepoPath);
+      const bareGit = simpleGit6(bareRepoPath);
       try {
         const remoteResult = await bareGit.remote(["get-url", "origin"]);
         const urlStr = typeof remoteResult === "string" ? remoteResult.trim() : "";
@@ -3672,7 +5107,7 @@ var RepositoryContext = class {
         adminDir
       };
     }
-    const worktreeDir = path9.dirname(worktreeRoot);
+    const worktreeDir = path14.dirname(worktreeRoot);
     const noUrlReason = "no remote origin URL detected";
     const capabilities = {
       listWorktrees: { available: true },
@@ -3708,7 +5143,7 @@ var RepositoryContext = class {
         cronSchedule: DEFAULT_CONFIG.CRON_SCHEDULE,
         runOnce: true
       };
-      const detectedKey = `${AUTO_DETECT_PREFIX}${path9.basename(bareRepoPath)}@${bareRepoPath}`;
+      const detectedKey = `${AUTO_DETECT_PREFIX}${path14.basename(bareRepoPath)}@${bareRepoPath}`;
       if (!this.repos.has(detectedKey)) {
         this.repos.set(detectedKey, {
           name: detectedKey,
@@ -3749,13 +5184,19 @@ var RepositoryContext = class {
     return { result: discovered, adminDir };
   }
   async getService(repoName) {
+    if (repoName) {
+      const explicit = this.selectExplicitRepository(repoName);
+      if (explicit.kind !== "selected") {
+        throw new Error(this.buildRepoNotFoundError(repoName));
+      }
+    }
     const name = repoName ?? this.currentRepo;
     if (!name) {
-      throw new Error("No repository specified and no current repository set");
+      throw new Error(this.buildNoRepoSelectedError());
     }
     const entry = this.repos.get(name);
     if (!entry) {
-      throw new Error(`Repository '${name}' not found. Load a config or run detect_context first.`);
+      throw new Error(this.buildRepoNotFoundError(name));
     }
     if (!entry.service) {
       const logger = createStderrLogger(entry.name);
@@ -3766,6 +5207,93 @@ var RepositoryContext = class {
     }
     return entry.service;
   }
+  getRepositorySelectionState() {
+    const configured = this.getConfiguredRepositoryNames();
+    const detected = this.getDetectedRepositoryNames();
+    return {
+      currentRepo: this.currentRepo,
+      configured,
+      detected,
+      defaultDecision: this.selectDefaultRepository(configured, detected)
+    };
+  }
+  selectExplicitRepository(repoName) {
+    if (this.repos.has(repoName)) {
+      return { kind: "selected", repoName, source: "explicit" };
+    }
+    return {
+      kind: "missing",
+      configured: this.getConfiguredRepositoryNames(),
+      detected: this.getDetectedRepositoryNames(),
+      reason: `Repository '${repoName}' not found`
+    };
+  }
+  selectDefaultRepository(configured = this.getConfiguredRepositoryNames(), detected = this.getDetectedRepositoryNames()) {
+    if (this.currentRepo !== null) {
+      return { kind: "selected", repoName: this.currentRepo, source: "current" };
+    }
+    if (this.canAutoSelectSingleConfig(configured, detected)) {
+      return { kind: "selected", repoName: configured[0], source: "single-config" };
+    }
+    if (configured.length === 0 && detected.length === 0) {
+      return {
+        kind: "missing",
+        configured,
+        detected,
+        reason: "no configured or detected repositories are registered"
+      };
+    }
+    return {
+      kind: "ambiguous",
+      configured,
+      detected,
+      reason: "repository selection is ambiguous without currentRepo or explicit repoName"
+    };
+  }
+  canAutoSelectSingleConfig(configured = this.getConfiguredRepositoryNames(), detected = this.getDetectedRepositoryNames()) {
+    return this.currentRepo === null && configured.length === 1 && detected.length === 0;
+  }
+  getDetectedRepositoryNames() {
+    return Array.from(this.repos.values()).filter((entry) => entry.source === "detected").map((entry) => entry.name);
+  }
+  formatDetectedRepositoryNames() {
+    return Array.from(this.repos.values()).filter((e) => e.source === "detected").map((e) => {
+      const location = e.discovered?.currentWorktreePath ?? e.config.bareRepoDir ?? e.config.worktreeDir;
+      return location ? `${e.name} (${location})` : e.name;
+    });
+  }
+  formatKnownRepositoryNames(names) {
+    return names.length === 0 ? "[]" : `[${names.join(", ")}]`;
+  }
+  buildNoRepoSelectedError() {
+    const selection = this.getRepositorySelectionState();
+    const detected = this.formatDetectedRepositoryNames();
+    const parts = [
+      "No repository specified and no current repository set.",
+      `launchCwd=${this.launchCwd}`,
+      `configPath=${this.configPath ?? "none"}`,
+      `loadedRepos=${this.repos.size} (config: ${selection.configured.length}, detected: ${selection.detected.length})`
+    ];
+    if (detected.length > 0) {
+      parts.push(`Detected repos: ${this.formatKnownRepositoryNames(detected)}.`);
+    }
+    if (selection.configured.length > 0) {
+      parts.push(`Configured repos: ${this.formatKnownRepositoryNames(selection.configured)}.`);
+    }
+    if (selection.configured.length > 0 || detected.length > 0) {
+      parts.push("Recovery: call set_current_repository with one of the repo names above or pass repoName explicitly.");
+    } else {
+      parts.push(
+        "Recovery: call detect_context {path: <workspace>}, load_config {configPath: <file>}, set SYNC_WORKTREES_CONFIG env var, or pass repoName explicitly."
+      );
+    }
+    return parts.join(" ");
+  }
+  buildRepoNotFoundError(name) {
+    const known = Array.from(this.repos.keys());
+    const knownStr = this.formatKnownRepositoryNames(known);
+    return `Repository '${name}' not found. Known repos: ${knownStr}. Run load_config or detect_context to register it.`;
+  }
   getEntry(repoName) {
     const name = repoName ?? this.currentRepo;
     if (!name) return null;
@@ -3792,40 +5320,229 @@ var RepositoryContext = class {
       source: e.source
     }));
   }
+  getConfiguredRepositoryNames() {
+    return Array.from(this.repos.values()).filter((entry) => entry.source === "config").map((entry) => entry.name);
+  }
+  async getConfiguredRepositorySummaries(options = {}) {
+    const entries = Array.from(this.repos.values()).filter((entry) => entry.source === "config");
+    const currentRepo = this.currentRepo;
+    const buildLean = (entry) => {
+      const mode = resolveMode(entry.config);
+      const isCurrent = entry.name === currentRepo;
+      if (mode === REPOSITORY_MODES.CLONE) {
+        return { name: entry.name, mode: "clone", checkoutPath: path14.resolve(entry.config.worktreeDir), isCurrent };
+      }
+      return { name: entry.name, mode: "worktree", worktreeDir: path14.resolve(entry.config.worktreeDir), isCurrent };
+    };
+    if (!options.detailed) {
+      return entries.map(buildLean);
+    }
+    const limit = pLimit2(DEFAULT_CONFIG.PARALLELISM.MAX_STATUS_CHECKS);
+    return Promise.all(
+      entries.map(
+        (entry) => limit(async () => {
+          const summary = buildLean(entry);
+          summary.repoUrl = entry.config.repoUrl;
+          if (entry.config.branch) summary.branch = entry.config.branch;
+          if (entry.config.sparseCheckout) {
+            const sc = entry.config.sparseCheckout;
+            summary.sparseCheckout = {
+              ...sc,
+              include: [...sc.include],
+              ...sc.exclude ? { exclude: [...sc.exclude] } : {}
+            };
+          }
+          if (summary.mode === "clone") {
+            summary.localReady = await isGitCheckout(summary.checkoutPath);
+            return summary;
+          }
+          if (entry.config.bareRepoDir) {
+            summary.bareRepoDir = path14.resolve(entry.config.bareRepoDir);
+            summary.localReady = await isDirectory(summary.bareRepoDir);
+          } else {
+            summary.localReady = false;
+          }
+          return summary;
+        })
+      )
+    );
+  }
+  autoSelectCurrentRepoIfSingleConfig() {
+    const decision = this.selectDefaultRepository();
+    if (decision.kind !== "selected") return null;
+    if (decision.source === "single-config") {
+      this.currentRepo = decision.repoName;
+    }
+    return this.currentRepo;
+  }
+  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" && resolveMode(entry.config) === REPOSITORY_MODES.CLONE) {
+      return this.readConfiguredCloneWorktree(entry, currentWorktreePath);
+    }
+    if (entry.source !== "config" || !entry.config.bareRepoDir) return { worktrees: [] };
+    const bareRepoPath = path14.resolve(entry.config.bareRepoDir);
+    if (!await isDirectory(bareRepoPath)) return { worktrees: [] };
+    try {
+      const output = await simpleGit6(bareRepoPath).raw(["worktree", "list", "--porcelain"]);
+      return { worktrees: parseWorktreeList(output, currentWorktreePath) };
+    } catch (err) {
+      return { worktrees: [], error: err instanceof Error ? err.message : String(err) };
+    }
+  }
+  findConfiguredCloneEntry(worktreeRoot) {
+    const foldedRoot = normalizePathForCompare(path14.resolve(worktreeRoot));
+    for (const entry of this.repos.values()) {
+      if (entry.source !== "config" || resolveMode(entry.config) !== REPOSITORY_MODES.CLONE) continue;
+      if (normalizePathForCompare(path14.resolve(entry.config.worktreeDir)) === foldedRoot) {
+        return entry;
+      }
+    }
+    return null;
+  }
+  async buildCloneModeContext(entry, worktreeRoot, notes) {
+    const resolvedRoot = path14.resolve(worktreeRoot);
+    let currentBranch = null;
+    try {
+      currentBranch = await readCurrentBranch(resolvedRoot);
+    } catch (err) {
+      notes.push(`Could not read clone-mode branch: ${err instanceof Error ? err.message : String(err)}`);
+    }
+    const branch = currentBranch ?? "unknown";
+    const cloneModeReason = "clone-mode repositories have a single checkout; use sync for clone-mode updates";
+    const capabilities = {
+      listWorktrees: { available: true },
+      getStatus: { available: true },
+      createWorktree: { available: false, reason: cloneModeReason },
+      removeWorktree: { available: false, reason: cloneModeReason },
+      updateWorktree: { available: false, reason: cloneModeReason },
+      sync: { available: true },
+      initialize: { available: true }
+    };
+    const discovered = {
+      isWorktree: true,
+      kind: "managed",
+      currentBranch,
+      currentWorktreePath: resolvedRoot,
+      bareRepoPath: null,
+      repoUrl: entry.config.repoUrl,
+      worktreeDir: resolvedRoot,
+      allWorktrees: [{ path: resolvedRoot, branch, isCurrent: true }],
+      siblingRepositories: [],
+      configPath: this.configPath,
+      repoName: entry.name,
+      capabilities,
+      notes
+    };
+    entry.discovered = discovered;
+    this.bootstrapCurrentRepo(entry.name, true);
+    return discovered;
+  }
+  async readConfiguredCloneWorktree(entry, currentWorktreePath) {
+    const worktreePath = path14.resolve(entry.config.worktreeDir);
+    if (!await isDirectory(worktreePath) || !await hasGitMetadata(worktreePath)) {
+      return { worktrees: [] };
+    }
+    try {
+      const branch = await readCurrentBranch(worktreePath);
+      return {
+        worktrees: [
+          {
+            path: worktreePath,
+            branch,
+            isCurrent: currentWorktreePath !== null && normalizePathForCompare(worktreePath) === normalizePathForCompare(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);
+    const resolved = path14.resolve(wt.path);
     const branch = wt.branch ?? (wt.detached ? `(detached ${(wt.head ?? "").slice(0, 7)})` : null);
     if (!branch) continue;
     results.push({
       path: resolved,
       branch,
-      isCurrent: normalizePathForCompare(resolved) === foldedCurrent
+      isCurrent: foldedCurrent !== null && normalizePathForCompare(resolved) === foldedCurrent
     });
   }
   return results;
 }
 async function safeMtimeMs(filePath) {
   try {
-    const stat4 = await fs7.stat(filePath);
+    const stat4 = await fs10.stat(filePath);
     return stat4.mtimeMs;
   } catch {
     return null;
   }
 }
+async function isDirectory(filePath) {
+  try {
+    const stat4 = await fs10.stat(filePath);
+    return stat4.isDirectory();
+  } catch {
+    return false;
+  }
+}
+async function hasGitMetadata(worktreePath) {
+  try {
+    await fs10.stat(path14.join(worktreePath, ".git"));
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function isGitCheckout(checkoutPath) {
+  if (!await isDirectory(checkoutPath)) return false;
+  try {
+    const inside = (await simpleGit6(checkoutPath).raw(["rev-parse", "--is-inside-work-tree"])).trim();
+    return inside === "true";
+  } catch {
+    return false;
+  }
+}
+async function readCurrentBranch(worktreePath) {
+  const git = simpleGit6(worktreePath);
+  const branch = (await git.raw(["rev-parse", "--abbrev-ref", "HEAD"])).trim();
+  if (branch && branch !== "HEAD") {
+    return branch;
+  }
+  const head = (await git.raw(["rev-parse", "--short", "HEAD"])).trim();
+  return head ? `(detached ${head})` : "(detached)";
+}
 async function findWorktreeRoot(startPath) {
-  let current = path9.resolve(startPath);
-  const root = path9.parse(current).root;
+  let current = path14.resolve(startPath);
+  const root = path14.parse(current).root;
   while (true) {
-    const gitPath = path9.join(current, ".git");
+    const gitPath = path14.join(current, ".git");
     try {
-      const content = await fs7.readFile(gitPath, "utf-8");
+      const content = await fs10.readFile(gitPath, "utf-8");
       return { kind: "worktree-file", worktreeRoot: current, gitFileContent: content };
     } catch (err) {
       const code = err.code;
@@ -3837,7 +5554,7 @@ async function findWorktreeRoot(startPath) {
       }
     }
     if (current === root) return null;
-    const parent = path9.dirname(current);
+    const parent = path14.dirname(current);
     if (parent === current) return null;
     current = parent;
   }
@@ -3848,13 +5565,13 @@ import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { z } from "zod";
 
 // src/mcp/handlers.ts
-import * as path10 from "path";
-import pLimit2 from "p-limit";
+import * as path15 from "path";
+import pLimit3 from "p-limit";
 
 // src/utils/disk-space.ts
 import fastFolderSize from "fast-folder-size";
 async function calculateDirectorySize(dirPath) {
-  return new Promise((resolve9, reject) => {
+  return new Promise((resolve11, reject) => {
     fastFolderSize(dirPath, (err, bytes) => {
       if (err) {
         reject(err);
@@ -3864,7 +5581,7 @@ async function calculateDirectorySize(dirPath) {
         reject(new Error(`fast-folder-size returned no bytes for ${dirPath}`));
         return;
       }
-      resolve9(bytes);
+      resolve11(bytes);
     });
   });
 }
@@ -3924,7 +5641,7 @@ function formatToolResponse(data) {
     content: [
       {
         type: "text",
-        text: JSON.stringify(data, null, 2)
+        text: JSON.stringify(data)
       }
     ]
   };
@@ -3951,7 +5668,7 @@ function formatErrorResponse(error) {
     content: [
       {
         type: "text",
-        text: JSON.stringify(body, null, 2)
+        text: JSON.stringify(body)
       }
     ],
     isError: true
@@ -3978,7 +5695,7 @@ function wrapHandler(fn) {
 }
 
 // src/mcp/worktree-summary.ts
-import simpleGit6 from "simple-git";
+import simpleGit7 from "simple-git";
 function deriveLabel(status, isCurrent) {
   if (isCurrent) return "current";
   if (!status.isClean || status.hasUnpushedCommits || status.hasStashedChanges) return "dirty";
@@ -3999,7 +5716,7 @@ function deriveSafeToRemove(status) {
 }
 async function getDivergence(worktreePath) {
   try {
-    const git = simpleGit6(worktreePath);
+    const git = simpleGit7(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) };
@@ -4010,6 +5727,7 @@ async function getDivergence(worktreePath) {
 
 // src/mcp/handlers.ts
 var pathResolution = new PathResolutionService();
+var CLONE_MODE_WORKTREE_MUTATION_REASON = "clone-mode repositories have a single checkout; use sync for clone-mode updates";
 function ensureCapability(discovered, key, toolName) {
   if (!discovered) return;
   const cap = discovered.capabilities[key];
@@ -4019,6 +5737,9 @@ function ensureCapability(discovered, key, toolName) {
   }
 }
 async function getReadyService(ctx, repoName, options = {}) {
+  if (!repoName) {
+    ctx.autoSelectCurrentRepoIfSingleConfig();
+  }
   const discovered = ctx.getDiscoveredContext(repoName);
   if (options.capability && options.toolName) {
     ensureCapability(discovered, options.capability, options.toolName);
@@ -4041,33 +5762,75 @@ async function runExclusiveRepoOperation(ctx, repoName, service, operation) {
   }
   return result.value;
 }
-async function ensureRepoWorktreePath(ctx, params, git) {
-  await ensurePathBelongsToRepo(ctx, params.path, params.repoName, git);
-  return path10.resolve(params.path);
+async function ensureRepoWorktreePath(ctx, params, service, git) {
+  await ensurePathBelongsToRepo(ctx, params.path, params.repoName, service, git);
+  return path15.resolve(params.path);
 }
-async function ensurePathBelongsToRepo(ctx, targetPath, repoName, git) {
+async function ensurePathBelongsToRepo(ctx, targetPath, repoName, service, git) {
   const discovered = ctx.getDiscoveredContext(repoName);
   if (discovered?.allWorktrees.length) {
     const match = discovered.allWorktrees.some((w) => pathsEqual(w.path, targetPath));
     if (match) return;
   }
   try {
-    const worktrees = await git.getWorktrees();
+    const worktrees = await getWorktreesFromService(service, git);
     if (worktrees.some((w) => pathsEqual(w.path, targetPath))) return;
   } catch {
   }
   throw new Error(`Path '${targetPath}' is not a registered worktree of the current repository`);
 }
+function isCloneModeService(service) {
+  const candidate = service;
+  return typeof candidate.isCloneMode === "function" && candidate.isCloneMode();
+}
+function ensureWorktreeModeService(service, toolName) {
+  if (isCloneModeService(service)) {
+    throw new CapabilityUnavailableError(toolName, [CLONE_MODE_WORKTREE_MUTATION_REASON]);
+  }
+}
+async function getWorktreesFromService(service, git) {
+  const candidate = service;
+  if (typeof candidate.getWorktrees === "function") {
+    return candidate.getWorktrees();
+  }
+  return git.getWorktrees();
+}
 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);
+  const configuredRepositories = await ctx.getConfiguredRepositorySummaries({ detailed: params.detailed ?? false });
+  let response = { ...discovered, configuredRepositories };
+  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 = pLimit3(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),
@@ -4082,16 +5845,47 @@ 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 = pLimit3(DEFAULT_CONFIG.PARALLELISM.MAX_REPOSITORIES);
+    const statusLimit = pLimit3(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 = pLimit3(DEFAULT_CONFIG.PARALLELISM.MAX_STATUS_CHECKS)) {
+  const { discovered, service, git } = await getReadyService(ctx, repoName, {
     capability: "listWorktrees",
     toolName: "list_worktrees"
   });
   let worktrees;
   try {
-    worktrees = await git.getWorktrees();
+    worktrees = await getWorktreesFromService(service, git);
   } catch {
     if (discovered) {
       worktrees = discovered.allWorktrees.map((w) => ({ path: w.path, branch: w.branch }));
@@ -4100,17 +5894,16 @@ 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 () => {
-        const resolvedPath = path10.resolve(wt.path);
+        const resolvedPath = path15.resolve(wt.path);
         const isCurrent = currentPath !== null && pathsEqual(wt.path, currentPath);
         const [status, divergence, metadata, sizeBytes] = await Promise.all([
           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,
@@ -4126,14 +5919,14 @@ 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, {
+  const { service, git } = await getReadyService(ctx, params.repoName, {
     capability: "getStatus",
     toolName: "get_worktree_status"
   });
-  const resolvedPath = await ensureRepoWorktreePath(ctx, params, git);
+  const resolvedPath = await ensureRepoWorktreePath(ctx, params, service, git);
   const [status, divergence] = await Promise.all([
     git.getFullWorktreeStatus(params.path, params.includeDetails ?? false),
     getDivergence(params.path)
@@ -4145,7 +5938,8 @@ 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}`);
@@ -4154,9 +5948,10 @@ async function handleCreateWorktree(ctx, params, _extra) {
     capability: "createWorktree",
     toolName: "create_worktree"
   });
+  ensureWorktreeModeService(service, "create_worktree");
   return runExclusiveRepoOperation(ctx, params.repoName, service, async () => {
     if (!service.isInitialized()) {
-      await service.initialize();
+      await service.initializeUnlocked();
     }
     const existence = await git.branchExists(branchName);
     let created = false;
@@ -4186,7 +5981,7 @@ async function handleCreateWorktree(ctx, params, _extra) {
     return formatToolResponse({
       success: true,
       branchName,
-      worktreePath: path10.resolve(worktreePath),
+      worktreePath: path15.resolve(worktreePath),
       created,
       pushed
     });
@@ -4197,11 +5992,12 @@ async function handleRemoveWorktree(ctx, params, _extra) {
     capability: "removeWorktree",
     toolName: "remove_worktree"
   });
+  ensureWorktreeModeService(service, "remove_worktree");
   return runExclusiveRepoOperation(ctx, params.repoName, service, async () => {
     if (!service.isInitialized()) {
-      await service.initialize();
+      await service.initializeUnlocked();
     }
-    const removedPath = await ensureRepoWorktreePath(ctx, params, git);
+    const removedPath = await ensureRepoWorktreePath(ctx, params, service, git);
     if (!params.force) {
       const status = await git.getFullWorktreeStatus(params.path, false);
       if (!status.canRemove) {
@@ -4224,13 +6020,31 @@ async function handleSync(ctx, params, extra) {
   const dispose = attachProgressReporter(service, extra);
   try {
     const start = Date.now();
+    service.clearRecordedSkips();
     const result = await service.sync();
     if (!result.started) {
       throw new SyncInProgressError(ctx.getEntry(params.repoName)?.name ?? params.repoName ?? "unknown");
     }
     const duration = Date.now() - start;
     ctx.invalidateDiscovered();
-    return formatToolResponse({ success: true, duration });
+    const outcome = result.outcome ?? createEmptySyncOutcome(
+      isCloneModeService(service) ? "clone" : "worktree",
+      ctx.getEntry(params.repoName)?.name ?? params.repoName,
+      duration
+    );
+    const skips = service.getRecordedSkips().map((reason) => ({
+      ...reason,
+      message: formatCloneSkipReason(reason)
+    }));
+    return formatToolResponse({
+      success: true,
+      duration,
+      outcome: {
+        ...outcome,
+        durationMs: outcome.durationMs ?? duration
+      },
+      skips
+    });
   } finally {
     dispose();
   }
@@ -4240,11 +6054,12 @@ async function handleUpdateWorktree(ctx, params, _extra) {
     capability: "updateWorktree",
     toolName: "update_worktree"
   });
+  ensureWorktreeModeService(service, "update_worktree");
   return runExclusiveRepoOperation(ctx, params.repoName, service, async () => {
     if (!service.isInitialized()) {
-      await service.initialize();
+      await service.initializeUnlocked();
     }
-    const worktreePath = await ensureRepoWorktreePath(ctx, params, git);
+    const worktreePath = await ensureRepoWorktreePath(ctx, params, service, git);
     await git.updateWorktree(params.path);
     ctx.invalidateDiscovered();
     return formatToolResponse({
@@ -4261,7 +6076,8 @@ async function handleInitialize(ctx, params, extra) {
   const dispose = attachProgressReporter(service, extra);
   try {
     return await runExclusiveRepoOperation(ctx, params.repoName, service, async () => {
-      await service.initialize();
+      await service.initializeUnlocked();
+      service.clearPendingInitSkip();
       const git = service.getGitService();
       ctx.invalidateDiscovered();
       return formatToolResponse({
@@ -4281,7 +6097,7 @@ async function handleLoadConfig(ctx, params, _extra) {
   }
   await ctx.loadConfig(configPath);
   return formatToolResponse({
-    configPath: path10.resolve(configPath),
+    configPath: path15.resolve(configPath),
     currentRepository: ctx.getCurrentRepo(),
     repositories: ctx.getRepositoryList()
   });
@@ -4316,20 +6132,23 @@ 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 REPO_NAME_DESCRIBE = "Repo name from loaded config. Omit to use current (set via set_current_repository) or the only loaded repo.";
+var PATH_DESCRIBE_SUFFIX = "Absolute preferred; relative resolves from server CWD.";
+var SERVER_INSTRUCTIONS = "Call `detect_context` for the project map and live worktree state; `configuredRepositories` in its response is the server-wide loaded-config inventory. Use `set_current_repository` to switch repos. Auto-loads sync-worktrees.config.{js,mjs,cjs,ts} via walk-up.";
 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")}`;
+  if (!d || !d.isWorktree || d.kind !== "managed") {
+    return SERVER_INSTRUCTIONS;
+  }
+  const fields = [];
+  if (d.repoName) fields.push(`workspace=${d.repoName}`);
+  if (d.currentWorktreePath) fields.push(`path=${d.currentWorktreePath}`);
+  if (d.configPath) fields.push(`config=${d.configPath}`);
+  if (typeof snapshot?.configuredRepoCount === "number") {
+    fields.push(`configuredRepos=${snapshot.configuredRepoCount}`);
+  }
+  fields.push(`worktrees=${d.allWorktrees.length}`);
+  return `${SERVER_INSTRUCTIONS} Connect-time: ${fields.join(" ")}.`;
 }
 function createServer(context, snapshot) {
   const server = new McpServer(
@@ -4346,22 +6165,24 @@ function createServer(context, snapshot) {
     "sync-worktrees://workspace",
     {
       title: "Workspace context",
-      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.",
+      description: "Workspace context: isWorktree, kind, currentWorktreePath, currentBranch, allWorktrees, siblingRepositories, configPath, capabilities {available,reason}, configuredRepositories (server-wide loaded-config inventory). {isWorktree:false} when outside any workspace.",
       mimeType: "application/json"
     },
     async (uri) => {
-      let discovered;
+      let payload;
       try {
-        discovered = await context.detectFromPath(process.cwd());
+        const discovered = await context.detectFromPath(process.cwd());
+        const configuredRepositories = await context.getConfiguredRepositorySummaries();
+        payload = { ...discovered, configuredRepositories };
       } catch (err) {
-        discovered = buildUnsupportedContext(process.cwd(), err instanceof Error ? err.message : String(err));
+        payload = buildUnsupportedContext(process.cwd(), err instanceof Error ? err.message : String(err));
       }
       return {
         contents: [
           {
             uri: uri.href,
             mimeType: "application/json",
-            text: JSON.stringify(discovered, null, 2)
+            text: JSON.stringify(payload)
           }
         ]
       };
@@ -4370,11 +6191,13 @@ 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 path (default: CWD). Reads .git, resolves bare repo, walks up to auto-load sync-worktrees.config.{js,mjs,cjs,ts}. Returns: configuredRepositories (server-wide loaded-config inventory; independent of params.path), bareRepoPath, allWorktrees, siblingRepositories, currentWorktreePath, configPath, capabilities {available,reason}, notes. Lean configuredRepositories entries are mode-discriminated: clone \u2192 {name, mode:'clone', checkoutPath, isCurrent}; worktree \u2192 {name, mode:'worktree', worktreeDir, isCurrent}. detailed=true adds repoUrl, branch?, sparseCheckout?, localReady, plus bareRepoDir for worktree mode. Use at session start or to bootstrap from unknown checkout.",
       inputSchema: {
-        path: z.string().optional().describe("Directory path to inspect. Defaults to the server's CWD."),
+        path: z.string().optional().describe("Directory to inspect. Default: server CWD."),
+        detailed: z.boolean().optional().default(false).describe("Expand configuredRepositories with repoUrl, branch, sparseCheckout, localReady, bareRepoDir."),
+        includeAllWorktrees: z.boolean().optional().describe("Include allWorktreesByRepo + allWorktreeErrorsByRepo for each configured repo. 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)."
+          "Enrich entries with label, divergence, staleHint. Adds 1 git status + rev-list per worktree. Default: false."
         )
       },
       annotations: {
@@ -4389,11 +6212,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 status. No repoName + config loaded = all configured repos grouped by repoName. With repoName = single repo. Entries: {path, branch, isCurrent, label (clean|dirty|stale|current|unknown), status, divergence, safeToRemove, lastSyncAt, sizeBytes}.",
       inputSchema: {
-        repoName: z.string().optional().describe(REPO_NAME_DESCRIBE),
+        repoName: z.string().optional().describe("Repo name. Omit + config loaded = list 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)."
+          "Compute on-disk size per worktree (bytes). Slow on large worktrees. Default: false (sizeBytes=null)."
         )
       },
       annotations: {
@@ -4408,11 +6231,11 @@ function createServer(context, snapshot) {
   server.registerTool(
     "get_worktree_status",
     {
-      description: "Get detailed status for one worktree (dirty files, unpushed commits, stashes, upstream gone, operations in progress). Returns: full status object plus divergence { ahead, behind } and resolved absolute path.",
+      description: "Detailed status for one worktree: dirty files, unpushed commits, stashes, upstream gone, ops in progress. Returns: status + divergence {ahead,behind} + resolved path.",
       inputSchema: {
         path: z.string().describe(`Worktree path. ${PATH_DESCRIBE_SUFFIX}`),
         repoName: z.string().optional().describe(REPO_NAME_DESCRIBE),
-        includeDetails: z.boolean().optional().describe("If true, includes file-level lists (modified, untracked, staged). Default: false (counts only).")
+        includeDetails: z.boolean().optional().describe("Include file-level lists (modified, untracked, staged). Default: false (counts only).")
       },
       annotations: {
         title: "Get worktree status",
@@ -4426,13 +6249,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 worktree for a branch. Existing branch (local/remote) = checkout. New branch = create from baseBranch + push to origin (default). baseBranch required only for new branches \u2014 pass defensively if unsure. push=false opts out. Preconditions: repo initialized (auto-runs). Returns: {success, branchName, worktreePath, created, pushed}.",
       inputSchema: {
-        branchName: z.string().describe("Branch name. Slashes and special chars are sanitized for the worktree directory name."),
+        branchName: z.string().describe("Branch name. Slashes/special chars sanitized for dir name."),
         baseBranch: z.string().optional().describe(
-          "Base branch for creating a new branch. Required if branchName does not exist locally or remotely; ignored otherwise."
+          "Base for new branch. Required if branchName doesn't 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 new branch to origin. Default: true. Ignored if branch existed."),
         repoName: z.string().optional().describe(REPO_NAME_DESCRIBE)
       },
       annotations: {
@@ -4448,12 +6271,10 @@ function createServer(context, snapshot) {
   server.registerTool(
     "remove_worktree",
     {
-      description: "Remove a worktree. Runs safety checks first: rejects if worktree is dirty, has unpushed commits, has stashes, or has an in-progress git operation (merge/rebase/cherry-pick/revert/bisect). force=true: runs `git worktree remove --force`, which DELETES uncommitted and untracked files in the worktree directory. Branch ref, stashes, and remote state are preserved. Returns: { success, removedPath }.",
+      description: "Remove worktree. Safety checks reject if dirty, unpushed commits, stashes, or op in progress (merge/rebase/cherry-pick/revert/bisect). force=true: `git worktree remove --force` DELETES uncommitted/untracked files in dir; branch ref + stashes + remote preserved. Returns: {success, removedPath}.",
       inputSchema: {
         path: z.string().describe(`Worktree path to remove. ${PATH_DESCRIBE_SUFFIX}`),
-        force: z.boolean().optional().describe(
-          "Skip safety checks and delete uncommitted/untracked files in the worktree directory. Branch ref is preserved. Default: false."
-        ),
+        force: z.boolean().optional().describe("Skip safety checks; deletes uncommitted/untracked files. Branch ref preserved. Default: false."),
         repoName: z.string().optional().describe(REPO_NAME_DESCRIBE)
       },
       annotations: {
@@ -4469,7 +6290,7 @@ function createServer(context, snapshot) {
   server.registerTool(
     "sync",
     {
-      description: "Full repo-wide synchronization: fetch all, create worktrees for new remote branches, remove worktrees for pruned remote branches (clean only), fast-forward existing worktrees. Emits progress notifications. Do not use when: you only need to update one worktree \u2014 use update_worktree. Only need to create one \u2014 use create_worktree. Preconditions: config must be loaded (load_config) and the repository initialized (auto-runs on first call). Returns: { success, duration } after sync completes.",
+      description: "Repo-wide sync: fetch, create worktrees for new remote branches, remove pruned (clean only), fast-forward existing. Emits progress. Single worktree? Use update_worktree. Single create? Use create_worktree. Preconditions: config loaded + repo initialized (auto-runs). Returns: {success, duration, skips}.",
       inputSchema: {
         repoName: z.string().optional().describe(REPO_NAME_DESCRIBE)
       },
@@ -4486,7 +6307,7 @@ function createServer(context, snapshot) {
   server.registerTool(
     "update_worktree",
     {
-      description: "Fast-forward one worktree to match its upstream. No merge commits, no rebasing, aborts if not fast-forwardable. Do not use when: you want to update every worktree in the repo \u2014 use sync.",
+      description: "Fast-forward one worktree to upstream. No merge, no rebase, aborts if not fast-forwardable. Whole repo? Use sync.",
       inputSchema: {
         path: z.string().describe(`Worktree path to fast-forward. ${PATH_DESCRIBE_SUFFIX}`),
         repoName: z.string().optional().describe(REPO_NAME_DESCRIBE)
@@ -4504,7 +6325,7 @@ function createServer(context, snapshot) {
   server.registerTool(
     "initialize",
     {
-      description: "Initialize a repository: clone as bare repo if missing, create main worktree. Safe to call on already-initialized repos (no-op-ish). Emits progress notifications. Preconditions: config must be loaded (load_config) so the repo's URL and paths are known. Returns: { success, defaultBranch, worktreeDir }.",
+      description: "Initialize repo: clone as bare if missing, create main worktree. Idempotent. Emits progress. Preconditions: config loaded. Returns: {success, defaultBranch, worktreeDir}.",
       inputSchema: {
         repoName: z.string().optional().describe(REPO_NAME_DESCRIBE)
       },
@@ -4521,11 +6342,9 @@ 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, repoUrl, worktreeDir, source }] }.",
+      description: "Load/reload sync-worktrees JS config into session. Replaces previously loaded repos. Call before sync/initialize/create_worktree in 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."
-        )
+        configPath: z.string().optional().describe("Config file path. Falls back to SYNC_WORKTREES_CONFIG env var. Errors if neither set.")
       },
       annotations: {
         title: "Load sync-worktrees config",
@@ -4540,9 +6359,9 @@ function createServer(context, snapshot) {
   server.registerTool(
     "set_current_repository",
     {
-      description: "Set the current repository for subsequent tool calls that omit repoName. Session-scoped; not persisted across server restarts. Preconditions: load_config must have been called so the name is known.",
+      description: "Set current repo for tool calls that omit repoName. Session-scoped. Preconditions: load_config called.",
       inputSchema: {
-        repoName: z.string().describe("Repository name as listed in the loaded config's `repositories[].name`.")
+        repoName: z.string().describe("Repo name from loaded config repositories[].name.")
       },
       annotations: {
         title: "Set current repository",
@@ -4584,7 +6403,10 @@ async function main() {
     process.stderr.write(`[sync-worktrees-mcp] Auto-detect failed: ${err.message}
 `);
   }
-  const server = createServer(context, { discovered });
+  const server = createServer(context, {
+    discovered,
+    configuredRepoCount: context.getConfiguredRepositoryNames().length
+  });
   const transport = new StdioServerTransport();
   await server.connect(transport);
 }