sync-worktrees 3.6.2 → 4.0.0

package/dist/index.js

@@ -1,9 +1,9 @@
 #!/usr/bin/env node
 
 // src/index.ts
-import * as path13 from "path";
-import { confirm as confirm2 } from "@inquirer/prompts";
-import * as cron3 from "node-cron";
+import { realpathSync as realpathSync2 } from "fs";
+import * as path17 from "path";
+import { fileURLToPath } from "url";
 import pLimit3 from "p-limit";
 
 // src/constants.ts
@@ -87,7 +87,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",
@@ -127,8 +128,68 @@ var HOOK_CONSTANTS = {
   }
 };
 
+// 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(path18, reasons) {
+    super(`Worktree at '${path18}' is not clean: ${reasons.join(", ")}`, "NOT_CLEAN");
+    this.path = path18;
+    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;
+  }
+};
+var ConfigFileExistsError = class extends ConfigError {
+  constructor(configPath) {
+    super(`Config file already exists: ${configPath}`, "FILE_EXISTS");
+    this.configPath = configPath;
+  }
+};
+
 // 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";
@@ -153,6 +214,17 @@ function filterBranchesByName(branches, include, exclude) {
   return result;
 }
 
+// src/utils/file-exists.ts
+import * as fs from "fs/promises";
+async function fileExists(path18) {
+  try {
+    await fs.access(path18);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
 // src/utils/git-url.ts
 function extractRepoNameFromUrl(gitUrl) {
   const url = gitUrl.trim();
@@ -178,6 +250,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";
@@ -190,54 +272,17 @@ function normalizePathForCompare(p, platform = process.platform) {
   return isCaseInsensitiveFs(platform) ? resolved.toLowerCase() : resolved;
 }
 
-// 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(path14, reasons) {
-    super(`Worktree at '${path14}' is not clean: ${reasons.join(", ")}`, "NOT_CLEAN");
-    this.path = path14;
-    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;
@@ -261,6 +306,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);
@@ -268,10 +320,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;
@@ -282,10 +332,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);
@@ -298,7 +346,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}`);
@@ -351,6 +399,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}'`);
       }
@@ -360,6 +414,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) {
@@ -376,9 +432,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");
       }
@@ -388,39 +450,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");
     }
@@ -431,6 +471,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`);
@@ -531,6 +612,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`);
@@ -551,29 +676,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;
@@ -591,9 +734,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));
@@ -610,8 +750,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;
   }
@@ -662,19 +805,13 @@ 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 };
   }
 };
 
 // src/services/InteractiveUIService.tsx
 import React8 from "react";
-import * as path10 from "path";
+import * as path14 from "path";
 import { render } from "ink";
 import * as cron2 from "node-cron";
 import pLimit2 from "p-limit";
@@ -1309,6 +1446,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/components/WorktreeStatusView.tsx
 var getStatusFlags = (status) => {
@@ -1772,7 +1917,7 @@ var App = ({
   const [diskSpaceUsed, setDiskSpaceUsed] = useState6(null);
   const [logs, setLogs] = useState6([]);
   const [repoCount, setRepoCount] = useState6(repositoryCount);
-  const [schedule3, setSchedule] = useState6(cronSchedule);
+  const [schedule2, setSchedule] = useState6(cronSchedule);
   const { stdout } = useStdout();
   const addLog = useCallback4((message, level = "info") => {
     setLogs((prev) => {
@@ -1941,67 +2086,13 @@ var App = ({
       status,
       repositoryCount: repoCount,
       lastSyncTime,
-      cronSchedule: schedule3,
+      cronSchedule: schedule2,
       diskSpaceUsed: diskSpaceUsed ?? void 0
     }
   ));
 };
 var App_default = App;
 
-// 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/retry.ts
 var DEFAULT_OPTIONS = {
   maxAttempts: "unlimited",
@@ -2072,7 +2163,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((resolve12) => setTimeout(resolve12, delay));
       attempt++;
     }
   }
@@ -2143,7 +2234,7 @@ var PhaseTimer = class {
     return results;
   }
 };
-function formatDuration2(ms) {
+function formatDuration(ms) {
   if (ms < 1e3) {
     return `${ms}ms`;
   }
@@ -2165,7 +2256,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;
@@ -2173,34 +2264,888 @@ 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 = {};
+  };
+}
+
+// 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, path18) {
+    this.add({ kind: "created", branch, path: path18 });
+  }
+  recordRemoved(branch, path18) {
+    this.add({ kind: "removed", branch, path: path18 });
+  }
+  recordUpdated(branch, path18, reason) {
+    this.add({ kind: "updated", branch, path: path18, 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, path18, preservedPath) {
+    this.add({ kind: "preserved-diverged", branch, path: path18, 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 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 ")) {
@@ -2324,8 +3269,8 @@ function defaultConsoleOutput(msg, level) {
 }
 
 // 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;
@@ -2333,7 +3278,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;
@@ -2384,11 +3329,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;
@@ -2445,7 +3404,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) {
@@ -2472,9 +3431,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) {
@@ -2486,7 +3445,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("\\")) {
@@ -2494,7 +3453,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,
@@ -2507,31 +3466,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;
@@ -2540,7 +3499,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`);
@@ -2554,7 +3513,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;
@@ -2564,7 +3523,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;
@@ -2598,7 +3557,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;
@@ -2699,9 +3658,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" },
@@ -2732,9 +3691,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,
@@ -2904,7 +3861,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
         )
@@ -3025,14 +3982,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 stat3 = await fs3.stat(gitPath);
+      const stat3 = await fs5.stat(gitPath);
       if (stat3.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}`);
       }
@@ -3046,10 +4003,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;
@@ -3069,7 +4026,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);
@@ -3097,36 +4054,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);
@@ -3134,11 +4075,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.");
@@ -3156,17 +4097,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;
@@ -3202,7 +4143,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) {
@@ -3228,6 +4169,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...");
@@ -3274,7 +4254,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);
@@ -3285,7 +4265,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;
@@ -3313,9 +4293,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);
@@ -3340,7 +4320,7 @@ var GitService = class {
         }
         retries++;
         if (retries < maxRetries) {
-          await new Promise((resolve9) => setTimeout(resolve9, retryDelay));
+          await new Promise((resolve12) => setTimeout(resolve12, retryDelay));
         }
       }
       this.logger.warn(
@@ -3402,18 +4382,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 {
     }
@@ -3452,7 +4432,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;
@@ -3460,7 +4440,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;
@@ -3496,15 +4476,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 {
       }
@@ -3528,7 +4508,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;
@@ -3751,6 +4731,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 {
@@ -3840,7 +4854,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) {
@@ -3861,35 +4875,238 @@ var GitService = class {
   }
 };
 
+// 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;
     }
@@ -3899,7 +5116,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);
@@ -3907,7 +5124,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);
@@ -3919,174 +5136,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 pathResolution = 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 = pathResolution.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...");
@@ -4094,32 +5247,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
+            });
           }
         })
       )
@@ -4128,7 +5293,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) {
@@ -4173,7 +5338,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;
@@ -4192,45 +5357,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;
@@ -4241,8 +5399,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;
           }
         })
@@ -4251,23 +5415,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 };
@@ -4290,6 +5452,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) {
@@ -4305,12 +5471,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;
               }
             })
@@ -4323,6 +5500,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`);
@@ -4415,53 +5597,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();
@@ -4473,7 +5654,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" };
               }
             }
           }
@@ -4485,13 +5666,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(
@@ -4505,6 +5698,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))) {
@@ -4512,13 +5706,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;
             }
           }
@@ -4530,9 +5734,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 };
@@ -4555,13 +5764,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);
@@ -4570,11 +5779,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 stat3 = await fs6.stat(dirPath);
+            const stat3 = await fs9.stat(dirPath);
             if (stat3.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) {
@@ -4586,13 +5795,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) {
@@ -4601,10 +5811,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}`);
@@ -4628,19 +5840,19 @@ var WorktreeSyncService = class {
     }
   }
   async divergeWorktree(worktreePath, branchName) {
-    const divergedBaseDir = path8.join(this.config.worktreeDir, GIT_CONSTANTS.DIVERGED_DIR_NAME);
+    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 = path8.join(divergedBaseDir, divergedName);
-    await fs6.mkdir(divergedBaseDir, { recursive: true });
+    const divergedPath = path13.join(divergedBaseDir, divergedName);
+    await fs9.mkdir(divergedBaseDir, { recursive: true });
     try {
-      await fs6.rename(worktreePath, divergedPath);
+      await fs9.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 });
+        await fs9.cp(worktreePath, divergedPath, { recursive: true });
+        await fs9.rm(worktreePath, { recursive: true, force: true });
       } else {
         throw err;
       }
@@ -4659,89 +5871,194 @@ var WorktreeSyncService = class {
 
   Original worktree location: ${worktreePath}`
     };
-    await fs6.writeFile(
-      path8.join(divergedPath, METADATA_CONSTANTS.DIVERGED_INFO_FILE),
+    await fs9.writeFile(
+      path13.join(divergedPath, METADATA_CONSTANTS.DIVERGED_INFO_FILE),
       JSON.stringify(metadata, null, 2)
     );
     return divergedPath;
   }
 };
 
-// src/services/file-copy.service.ts
-import * as fs7 from "fs/promises";
-import * as path9 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;
+// 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 {
+      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" };
+    }
+    try {
+      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 filesToCopy = await this.expandPatterns(sourceDir, patterns);
-    for (const relativePath of filesToCopy) {
-      const sourcePath = path9.join(sourceDir, relativePath);
-      const destPath = path9.join(destDir, relativePath);
+  }
+  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 {
-        const copied = await this.copyFile(sourcePath, destPath);
-        if (copied) {
-          result.copied.push(relativePath);
+        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 {
-          result.skipped.push(relativePath);
+          await retry(
+            () => this.worktreeModeSyncRunner.runSyncAttempt(phaseTimer, syncContext, outcome),
+            retryOptionsWithOutcomeReset
+          );
         }
       } 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);
+        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));
         }
-      } catch {
       }
-    }
-    return Array.from(allFiles);
-  }
-  async copyFile(sourcePath, destPath) {
-    try {
-      await fs7.access(destPath);
-      return false;
-    } catch {
-    }
-    const destDir = path9.dirname(destPath);
-    await fs7.mkdir(destDir, { recursive: true });
-    await fs7.copyFile(sourcePath, destPath);
-    return true;
+      return this.lastOutcome ?? outcome.toOutcome(durationMs);
+    });
+    return result.started ? { started: true, outcome: result.value } : result;
   }
 };
 
@@ -4874,7 +6191,7 @@ var HookExecutionService = class {
 // src/utils/disk-space.ts
 import fastFolderSize from "fast-folder-size";
 async function calculateDirectorySize(dirPath) {
-  return new Promise((resolve9, reject) => {
+  return new Promise((resolve12, reject) => {
     fastFolderSize(dirPath, (err, bytes) => {
       if (err) {
         reject(err);
@@ -4884,7 +6201,7 @@ async function calculateDirectorySize(dirPath) {
         reject(new Error(`fast-folder-size returned no bytes for ${dirPath}`));
         return;
       }
-      resolve9(bytes);
+      resolve12(bytes);
     });
   });
 }
@@ -4955,7 +6272,7 @@ var AppEventEmitter = class {
 };
 
 // src/services/InteractiveUIService.tsx
-import * as fs8 from "fs/promises";
+import * as fs10 from "fs/promises";
 var WAIT_SYNC_FAST_TIMEOUT_MS = 2e3;
 var WAIT_SYNC_DEFAULT_TIMEOUT_MS = 3e4;
 var InteractiveUIService = class {
@@ -4968,15 +6285,15 @@ var InteractiveUIService = class {
   logBuffer = [];
   uiReady = false;
   hookExecutionService = new HookExecutionService();
+  branchCreatedActions = new BranchCreatedActionsService();
   pathResolution = new PathResolutionService();
   limit;
   reloadInProgress = false;
   isDestroyed = false;
-  reloadOptions;
   events;
   ownsEvents;
   unsubscribeCallbacks = [];
-  constructor(syncServices, configPath, cronSchedule, maxParallel, reloadOptions, events) {
+  constructor(syncServices, configPath, cronSchedule, maxParallel, events) {
     this.ownsEvents = events === void 0;
     this.events = events ?? new AppEventEmitter();
     if (syncServices.length === 0) {
@@ -4987,7 +6304,6 @@ var InteractiveUIService = class {
     this.cronSchedule = cronSchedule;
     this.repositoryCount = syncServices.length;
     this.limit = pLimit2(maxParallel ?? DEFAULT_CONFIG.PARALLELISM.MAX_REPOSITORIES);
-    this.reloadOptions = reloadOptions ?? {};
     this.startBufferFlushCheck();
     this.renderUI();
     this.injectLoggersIntoServices();
@@ -5045,15 +6361,15 @@ var InteractiveUIService = class {
     const scheduleGroups = /* @__PURE__ */ new Map();
     for (const service of this.syncServices) {
       if (service.config.runOnce) continue;
-      const schedule3 = service.config.cronSchedule || this.cronSchedule;
-      if (!schedule3) continue;
-      if (!scheduleGroups.has(schedule3)) {
-        scheduleGroups.set(schedule3, []);
+      const schedule2 = service.config.cronSchedule || this.cronSchedule;
+      if (!schedule2) continue;
+      if (!scheduleGroups.has(schedule2)) {
+        scheduleGroups.set(schedule2, []);
       }
-      scheduleGroups.get(schedule3).push(service);
+      scheduleGroups.get(schedule2).push(service);
     }
-    for (const [schedule3, services] of scheduleGroups) {
-      const task = cron2.schedule(schedule3, async () => {
+    for (const [schedule2, services] of scheduleGroups) {
+      const task = cron2.schedule(schedule2, async () => {
         await this.runSyncCycle(services, { logErrors: false });
       });
       this.cronJobs.push(task);
@@ -5091,8 +6407,8 @@ var InteractiveUIService = class {
           getWorktreeStatusForRepo: (index) => this.getWorktreeStatusForRepo(index),
           getDivergedDirectoriesForRepo: (index) => this.getDivergedDirectoriesForRepo(index),
           deleteDivergedDirectory: (repoIndex, name) => this.deleteDivergedDirectory(repoIndex, name),
-          openEditorInWorktree: (path14) => this.openEditorInWorktree(path14),
-          openTerminalInWorktree: (repoIndex, path14, branchName) => this.openTerminalInWorktree(repoIndex, path14, branchName),
+          openEditorInWorktree: (path18) => this.openEditorInWorktree(path18),
+          openTerminalInWorktree: (repoIndex, path18, branchName) => this.openTerminalInWorktree(repoIndex, path18, branchName),
           copyBranchFiles: (repoIndex, baseBranch, targetBranch) => this.copyBranchFiles(repoIndex, baseBranch, targetBranch),
           createWorktreeForBranch: (repoIndex, branchName) => this.createWorktreeForBranch(repoIndex, branchName),
           executeOnBranchCreatedHooks: (repoIndex, context) => this.executeOnBranchCreatedHooks(repoIndex, context)
@@ -5121,24 +6437,28 @@ var InteractiveUIService = class {
       this.addLog("Reloading configuration...");
       this.setStatus("syncing");
       const configLoader = new ConfigLoaderService();
-      const { repositories } = await configLoader.buildRepositories(this.configPath, {
-        filter: this.reloadOptions.filter,
-        noUpdateExisting: this.reloadOptions.noUpdateExisting,
-        debug: this.reloadOptions.debug
-      });
+      const { repositories } = await configLoader.buildRepositories(this.configPath);
       const initResults = await Promise.allSettled(
         repositories.map(
           (repoConfig) => this.limit(async () => {
             const service = new WorktreeSyncService(repoConfig);
             await service.initialize();
-            return service;
+            return {
+              service,
+              clonePhaseSkips: service.getRecordedSkips().map((reason) => ({
+                repo: repoConfig.name || repoConfig.repoUrl,
+                reason: formatCloneSkipReason(reason)
+              }))
+            };
           })
         )
       );
       const newServices = [];
+      const initClonePhaseSkips = [];
       for (const result of initResults) {
         if (result.status === "fulfilled") {
-          newServices.push(result.value);
+          newServices.push(result.value.service);
+          initClonePhaseSkips.push(...result.value.clonePhaseSkips);
         } else {
           this.addLog(`Failed to initialize repository: ${result.reason}`, "error");
         }
@@ -5156,12 +6476,24 @@ var InteractiveUIService = class {
       this.setupCronJobs();
       this.events.emit("updateRepositoryCount", this.repositoryCount);
       this.events.emit("updateCronSchedule", this.cronSchedule);
-      const { failures, skipped, attempted } = await this.runSyncServices(this.syncServices);
+      const {
+        failures,
+        skipped,
+        clonePhaseSkips: syncClonePhaseSkips,
+        attempted
+      } = await this.runSyncServices(this.syncServices);
+      const clonePhaseSkips = [...initClonePhaseSkips, ...syncClonePhaseSkips];
       await this.recordSyncOutcome({ failures, skipped, attempted });
       this.setStatus("idle");
       for (const skip of skipped) {
         this.addLog(`Sync skipped for '${skip.repo}': ${skip.reason}`, "warn");
       }
+      for (const skip of clonePhaseSkips) {
+        this.addLog(`Clone-mode skip for '${skip.repo}': ${skip.reason}`, "warn");
+      }
+      if (clonePhaseSkips.length > 0) {
+        this.addLog(`\u26A0\uFE0F  ${clonePhaseSkips.length} clone-mode skip(s) during reload`, "warn");
+      }
       if (failures.length > 0) {
         for (const failure of failures) {
           this.addLog(`Failed to sync repository '${failure.repo}': ${failure.error}`, "error");
@@ -5195,14 +6527,14 @@ var InteractiveUIService = class {
         if (Date.now() - startTime > timeoutMs) {
           throw new Error("Timeout waiting for sync operations to complete");
         }
-        await new Promise((resolve9) => setTimeout(resolve9, checkInterval));
+        await new Promise((resolve12) => setTimeout(resolve12, checkInterval));
       }
     });
     try {
       await Promise.all(syncChecks);
     } catch {
       this.addLog(
-        `Warning: Timeout waiting for sync operations to complete after ${formatDuration2(timeoutMs)}. Proceeding with potential data loss risk.`,
+        `Warning: Timeout waiting for sync operations to complete after ${formatDuration(timeoutMs)}. Proceeding with potential data loss risk.`,
         "warn"
       );
     }
@@ -5304,8 +6636,7 @@ var InteractiveUIService = class {
       throw new Error(`Invalid repository index: ${repoIndex}`);
     }
     const service = this.syncServices[repoIndex];
-    const gitService = service.getGitService();
-    return gitService.getWorktrees();
+    return this.getWorktreesFromService(service);
   }
   async getWorktreeStatusForRepo(repoIndex) {
     if (repoIndex < 0 || repoIndex >= this.syncServices.length) {
@@ -5313,7 +6644,7 @@ var InteractiveUIService = class {
     }
     const service = this.syncServices[repoIndex];
     const gitService = service.getGitService();
-    const worktrees = await gitService.getWorktrees();
+    const worktrees = await this.getWorktreesFromService(service);
     const results = await Promise.allSettled(
       worktrees.map(async (wt) => {
         const status = await gitService.getFullWorktreeStatus(wt.path, true);
@@ -5322,28 +6653,35 @@ var InteractiveUIService = class {
     );
     return results.filter((r) => r.status === "fulfilled").map((r) => r.value);
   }
+  async getWorktreesFromService(service) {
+    const worktreeProvider = service;
+    if (typeof worktreeProvider.getWorktrees === "function") {
+      return worktreeProvider.getWorktrees();
+    }
+    return service.getGitService().getWorktrees();
+  }
   async getDivergedDirectoriesForRepo(repoIndex) {
     if (repoIndex < 0 || repoIndex >= this.syncServices.length) {
       return [];
     }
     const service = this.syncServices[repoIndex];
     const worktreeDir = service.config.worktreeDir;
-    const divergedDir = path10.join(worktreeDir, GIT_CONSTANTS.DIVERGED_DIR_NAME);
+    const divergedDir = path14.join(worktreeDir, GIT_CONSTANTS.DIVERGED_DIR_NAME);
     let dirEntries;
     try {
-      dirEntries = await fs8.readdir(divergedDir, { withFileTypes: true, encoding: "utf-8" });
+      dirEntries = await fs10.readdir(divergedDir, { withFileTypes: true, encoding: "utf-8" });
     } catch {
       return [];
     }
     const subdirs = dirEntries.filter((e) => e.isDirectory());
     const results = await Promise.allSettled(
       subdirs.map(async (entry) => {
-        const fullPath = path10.join(divergedDir, entry.name);
-        const infoFilePath = path10.join(fullPath, METADATA_CONSTANTS.DIVERGED_INFO_FILE);
+        const fullPath = path14.join(divergedDir, entry.name);
+        const infoFilePath = path14.join(fullPath, METADATA_CONSTANTS.DIVERGED_INFO_FILE);
         let originalBranch = entry.name;
         let divergedAt = "";
         try {
-          const infoContent = await fs8.readFile(infoFilePath, "utf-8");
+          const infoContent = await fs10.readFile(infoFilePath, "utf-8");
           const info = JSON.parse(infoContent);
           if (typeof info.originalBranch === "string") originalBranch = info.originalBranch;
           if (typeof info.divergedAt === "string") divergedAt = info.divergedAt;
@@ -5374,15 +6712,15 @@ var InteractiveUIService = class {
     }
     const service = this.syncServices[repoIndex];
     const worktreeDir = service.config.worktreeDir;
-    const divergedBase = path10.resolve(worktreeDir, GIT_CONSTANTS.DIVERGED_DIR_NAME);
+    const divergedBase = path14.resolve(worktreeDir, GIT_CONSTANTS.DIVERGED_DIR_NAME);
     if (!name || name === "." || name === ".." || name.includes("/") || name.includes("\\")) {
       throw new Error(`Invalid diverged directory name: "${name}"`);
     }
-    const targetPath = path10.join(divergedBase, name);
+    const targetPath = path14.join(divergedBase, name);
     if (!this.pathResolution.isPathInsideBaseDir(targetPath, divergedBase)) {
       throw new Error(`Path traversal rejected: "${name}" resolves outside the diverged directory`);
     }
-    await fs8.rm(targetPath, { recursive: true, force: true });
+    await fs10.rm(targetPath, { recursive: true, force: true });
     this.addLog(`\u{1F5D1}\uFE0F Deleted diverged directory: ${name}`, "info");
   }
   async createWorktreeForBranch(repoIndex, branchName) {
@@ -5500,7 +6838,7 @@ var InteractiveUIService = class {
   async runSyncCycle(services, options) {
     this.setStatus("syncing");
     try {
-      const { failures, skipped, attempted } = await this.runSyncServices(services);
+      const { failures, skipped, partialSkips, clonePhaseSkips, attempted } = await this.runSyncServices(services);
       if (options.logErrors) {
         for (const failure of failures) {
           this.addLog(`Failed to sync repository '${failure.repo}': ${failure.error}`, "error");
@@ -5509,6 +6847,15 @@ var InteractiveUIService = class {
       for (const skip of skipped) {
         this.addLog(`Sync skipped for '${skip.repo}': ${skip.reason}`, "warn");
       }
+      for (const skip of clonePhaseSkips) {
+        this.addLog(`Clone-mode skip for '${skip.repo}': ${skip.reason}`, "warn");
+      }
+      if (clonePhaseSkips.length > 0) {
+        this.addLog(`\u26A0\uFE0F  ${clonePhaseSkips.length} clone-mode skip(s) this cycle`, "warn");
+      }
+      for (const partial of partialSkips) {
+        this.addLog(`${partial.repo}: ${partial.reason}`, "info");
+      }
       await this.recordSyncOutcome({ failures, skipped, attempted });
       return failures;
     } finally {
@@ -5525,6 +6872,7 @@ var InteractiveUIService = class {
     const syncResults = await Promise.allSettled(
       services.map(
         (service) => this.limit(async () => {
+          service.clearRecordedSkips();
           if (!service.isInitialized()) {
             await service.initialize();
           }
@@ -5538,18 +6886,39 @@ var InteractiveUIService = class {
     );
     const failures = [];
     const skipped = [];
+    const partialSkips = [];
+    const clonePhaseSkips = [];
     for (let i = 0; i < syncResults.length; i++) {
       const result = syncResults[i];
+      const repoName = services[i].config.name || services[i].config.repoUrl;
       if (result.status === "rejected") {
-        const repoName = result.reason?.repoName ?? "unknown";
+        const fallbackName = result.reason?.repoName ?? repoName;
         const errorMessage = result.reason instanceof Error ? result.reason.message : String(result.reason);
-        failures.push({ repo: repoName, error: errorMessage });
+        failures.push({ repo: fallbackName, error: errorMessage });
       } else if (result.value.result && result.value.result.started === false) {
-        const repoName = services[i].config.name || services[i].config.repoUrl;
         skipped.push({ repo: repoName, reason: `sync skipped: ${result.value.result.reason}` });
+      } else if (result.status === "fulfilled" && result.value.result?.started === true) {
+        const outcome = result.value.result.outcome;
+        if (outcome?.counts.failed) {
+          failures.push({ repo: repoName, error: `${outcome.counts.failed} sync action(s) failed` });
+        }
+        if (outcome?.mode === "worktree" && outcome.counts.skipped > 0) {
+          partialSkips.push({ repo: repoName, reason: `${outcome.counts.skipped} sync action(s) skipped` });
+        }
+      }
+      for (const reason of services[i].getRecordedSkips()) {
+        clonePhaseSkips.push({ repo: repoName, reason: formatCloneSkipReason(reason) });
       }
     }
-    return { failures, skipped, attempted: services.length };
+    return { failures, skipped, partialSkips, clonePhaseSkips, attempted: services.length };
+  }
+  buildUiLogger() {
+    return new Logger({
+      outputFn: (msg, level) => {
+        const uiLevel = level === "warn" ? "warn" : level === "error" ? "error" : "info";
+        this.addLog(msg, uiLevel);
+      }
+    });
   }
   executeOnBranchCreatedHooks(repoIndex, context) {
     if (repoIndex < 0 || repoIndex >= this.syncServices.length) {
@@ -5557,27 +6926,15 @@ var InteractiveUIService = class {
     }
     const service = this.syncServices[repoIndex];
     const config = service.config;
-    if (!config.hooks?.onBranchCreated?.length) {
-      return;
-    }
-    this.addLog(`Running ${config.hooks.onBranchCreated.length} hook(s) for branch '${context.branchName}'...`, "info");
-    this.hookExecutionService.executeOnBranchCreated(config.hooks, context, {
-      onStdout: (data) => {
-        this.addLog(`[hook] ${data}`, "info");
-      },
-      onStderr: (data) => {
-        this.addLog(`[hook] ${data}`, "warn");
-      },
-      onError: (command, error) => {
-        this.addLog(`[hook] Failed to execute '${command}': ${error.message}`, "error");
-      },
-      onComplete: (command, exitCode) => {
-        if (exitCode === 0) {
-          this.addLog(`[hook] Command completed successfully`, "info");
-        } else if (exitCode !== null) {
-          this.addLog(`[hook] Command exited with code ${exitCode}`, "warn");
-        }
-      }
+    const repoName = config.name || config.repoUrl;
+    this.branchCreatedActions.runHooks({
+      config,
+      repoName,
+      branchName: context.branchName,
+      worktreePath: context.worktreePath,
+      baseBranch: context.baseBranch,
+      logger: this.buildUiLogger(),
+      hookExecutionService: this.hookExecutionService
     });
   }
   async copyBranchFiles(repoIndex, baseBranch, targetBranch) {
@@ -5589,33 +6946,20 @@ var InteractiveUIService = class {
     if (!config.filesToCopyOnBranchCreate?.length) {
       return;
     }
-    const gitService = service.getGitService();
-    const worktrees = await gitService.getWorktrees();
+    const worktrees = await this.getWorktreesFromService(service);
     const sourceWorktree = worktrees.find((w) => w.branch === baseBranch);
     const targetWorktree = worktrees.find((w) => w.branch === targetBranch);
     if (!sourceWorktree || !targetWorktree) {
       this.addLog(`Could not find worktrees for file copy: source=${baseBranch}, target=${targetBranch}`, "warn");
       return;
     }
-    const fileCopyService = new FileCopyService();
-    try {
-      const result = await fileCopyService.copyFiles(
-        sourceWorktree.path,
-        targetWorktree.path,
-        config.filesToCopyOnBranchCreate
-      );
-      if (result.copied.length > 0) {
-        this.addLog(`\u{1F4CB} Copied ${result.copied.length} file(s) to new branch: ${result.copied.join(", ")}`, "info");
-      }
-      if (result.errors.length > 0) {
-        this.addLog(`\u26A0\uFE0F Failed to copy ${result.errors.length} file(s):`, "warn");
-        for (const err of result.errors) {
-          this.addLog(`  - ${err.file}: ${err.error}`, "warn");
-        }
-      }
-    } catch (error) {
-      this.addLog(`Failed to copy files to new branch: ${error}`, "error");
-    }
+    await this.branchCreatedActions.copyFiles({
+      config,
+      branchName: targetBranch,
+      worktreePath: targetWorktree.path,
+      sourceDir: sourceWorktree.path,
+      logger: this.buildUiLogger()
+    });
   }
   async destroy(fast = false) {
     this.isDestroyed = true;
@@ -5644,135 +6988,85 @@ var InteractiveUIService = class {
 // src/utils/cli.ts
 import yargs from "yargs";
 import { hideBin } from "yargs/helpers";
-function parseArguments() {
-  const argv = yargs(hideBin(process.argv)).option("config", {
-    alias: "c",
-    type: "string",
-    description: "Path to JavaScript config file"
-  }).option("filter", {
-    alias: "f",
-    type: "string",
-    description: "Filter repositories by name (supports wildcards and comma-separated values)"
-  }).option("list", {
-    alias: "l",
-    type: "boolean",
-    description: "List configured repositories and exit",
-    default: false
-  }).option("bareRepoDir", {
-    alias: "b",
-    type: "string",
-    description: "Directory for storing bare repositories (default: .bare/<repo-name>)."
-  }).option("repoUrl", {
-    alias: "u",
-    type: "string",
-    description: "Git repository URL (e.g., SSH or HTTPS)."
-  }).option("worktreeDir", {
-    alias: "w",
-    type: "string",
-    description: "Absolute path to the directory for storing worktrees."
-  }).option("cronSchedule", {
-    alias: "s",
-    type: "string",
-    description: "Cron schedule for how often to run the sync.",
-    default: "0 * * * *"
-  }).option("runOnce", {
-    type: "boolean",
-    description: "Run the sync process once and then exit, without scheduling.",
-    default: false
-  }).option("branchMaxAge", {
-    alias: "a",
-    type: "string",
-    description: "Maximum age of branches to sync (e.g., '30d', '6m', '1y')."
-  }).option("branchInclude", {
-    type: "string",
-    description: "Only sync branches matching these patterns (comma-separated, supports wildcards)."
-  }).option("branchExclude", {
-    type: "string",
-    description: "Exclude branches matching these patterns (comma-separated, supports wildcards)."
-  }).option("skipLfs", {
-    type: "boolean",
-    description: "Skip Git LFS downloads when fetching and creating worktrees.",
-    default: false
-  }).option("no-update-existing", {
-    type: "boolean",
-    description: "Disable automatic updates of existing worktrees.",
-    default: false
-  }).option("debug", {
-    alias: "d",
-    type: "boolean",
-    description: "Enable debug mode to show detailed reasons why worktrees are not cleaned up.",
-    default: false
-  }).option("sync-on-start", {
-    type: "boolean",
-    description: "Run sync immediately when starting the interactive UI (config mode only).",
-    default: false
-  }).help().alias("help", "h").parseSync();
-  return {
-    config: argv.config,
-    filter: argv.filter,
-    list: argv.list,
-    repoUrl: argv.repoUrl,
-    worktreeDir: argv.worktreeDir,
-    cronSchedule: argv.cronSchedule,
-    runOnce: argv.runOnce,
-    bareRepoDir: argv.bareRepoDir,
-    branchMaxAge: argv.branchMaxAge,
-    branchInclude: argv.branchInclude ? argv.branchInclude.split(",").map((p) => p.trim()) : void 0,
-    branchExclude: argv.branchExclude ? argv.branchExclude.split(",").map((p) => p.trim()) : void 0,
-    skipLfs: argv.skipLfs,
-    noUpdateExisting: argv["no-update-existing"],
-    debug: argv.debug,
-    syncOnStart: argv["sync-on-start"]
-  };
-}
-function isInteractiveMode(config) {
-  return !config.repoUrl || !config.worktreeDir;
-}
-function reconstructCliCommand(config) {
-  const executable = process.argv[1].includes("ts-node") ? "ts-node src/index.ts" : "sync-worktrees";
-  const args = [];
-  args.push(`--repoUrl "${config.repoUrl}"`);
-  if (config.worktreeDir) {
-    args.push(`--worktreeDir "${config.worktreeDir}"`);
-  }
-  if (config.bareRepoDir) {
-    args.push(`--bareRepoDir "${config.bareRepoDir}"`);
-  }
-  if (config.cronSchedule && config.cronSchedule !== "0 * * * *") {
-    args.push(`--cronSchedule "${config.cronSchedule}"`);
-  }
-  if (config.runOnce) {
-    args.push("--runOnce");
-  }
-  if (config.branchMaxAge) {
-    args.push(`--branchMaxAge "${config.branchMaxAge}"`);
-  }
-  if (config.branchInclude?.length) {
-    args.push(`--branchInclude "${config.branchInclude.join(",")}"`);
-  }
-  if (config.branchExclude?.length) {
-    args.push(`--branchExclude "${config.branchExclude.join(",")}"`);
-  }
-  if (config.skipLfs) {
-    args.push("--skip-lfs");
-  }
-  if (config.updateExistingWorktrees === false) {
-    args.push("--no-update-existing");
-  }
-  if (config.debug) {
-    args.push("--debug");
+var CLI_COMMANDS = {
+  RUN: "run",
+  INIT: "init",
+  LIST: "list"
+};
+function parseArguments(argv = hideBin(process.argv)) {
+  let parsed;
+  yargs(argv).scriptName("sync-worktrees").parserConfiguration({ "camel-case-expansion": false }).strict().command(
+    "$0",
+    "Sync git worktrees against a config file",
+    (y) => y.option("config", {
+      alias: "c",
+      type: "string",
+      description: "Path to JavaScript config file (auto-detected in CWD when omitted)."
+    }).option("runOnce", {
+      type: "boolean",
+      description: "Run a sync once and exit, overriding config runOnce settings for this invocation.",
+      default: false
+    }),
+    (args) => {
+      parsed = {
+        command: CLI_COMMANDS.RUN,
+        config: args.config,
+        runOnce: args.runOnce
+      };
+    }
+  ).command(
+    CLI_COMMANDS.INIT,
+    "Create a new config file interactively",
+    (y) => y.option("config", {
+      alias: "c",
+      type: "string",
+      description: "Target path for the generated config file (default: ./sync-worktrees.config.js)."
+    }).option("force", {
+      type: "boolean",
+      description: "Overwrite the target file if it already exists.",
+      default: false
+    }),
+    (args) => {
+      parsed = {
+        command: CLI_COMMANDS.INIT,
+        config: args.config,
+        force: args.force
+      };
+    }
+  ).command(
+    CLI_COMMANDS.LIST,
+    "List repositories configured in a config file and exit",
+    (y) => y.option("config", {
+      alias: "c",
+      type: "string",
+      description: "Path to JavaScript config file (auto-detected in CWD when omitted)."
+    }).option("filter", {
+      alias: "f",
+      type: "string",
+      description: "Filter repositories by name (wildcards, comma-separated)."
+    }),
+    (args) => {
+      parsed = {
+        command: CLI_COMMANDS.LIST,
+        config: args.config,
+        filter: args.filter
+      };
+    }
+  ).demandCommand(0, 0).help().alias("help", "h").version().parseSync();
+  if (!parsed) {
+    throw new Error("Failed to parse CLI arguments");
   }
-  return `${executable} ${args.join(" ")}`;
+  return parsed;
 }
 
 // src/utils/config-generator.ts
-import * as fs9 from "fs/promises";
-import * as path11 from "path";
+import * as fs11 from "fs/promises";
+import * as path15 from "path";
 function serializeToESM(obj, indent = 0) {
   const spaces = " ".repeat(indent);
   const innerSpaces = " ".repeat(indent + 2);
   if (typeof obj === "string") {
-    return `"${obj}"`;
+    return JSON.stringify(obj);
   }
   if (typeof obj === "number" || typeof obj === "boolean") {
     return String(obj);
@@ -5796,99 +7090,102 @@ ${spaces}}`;
   }
   return String(obj);
 }
-async function generateConfigFile(config, configPath) {
-  const configDir = path11.dirname(configPath);
-  await fs9.mkdir(configDir, { recursive: true });
-  const worktreeDirRelative = path11.relative(configDir, config.worktreeDir);
+async function generateConfigFile(input2, configPath, options = {}) {
+  const configDir = path15.dirname(configPath);
+  await fs11.mkdir(configDir, { recursive: true });
+  const worktreeDirRelative = path15.relative(configDir, input2.worktreeDir);
   const useRelativeWorktree = !worktreeDirRelative.startsWith("../../../");
-  const repoName = extractRepoNameFromUrl(config.repoUrl);
+  const repoName = extractRepoNameFromUrl(input2.repoUrl);
   const repository = {
     name: repoName,
-    repoUrl: config.repoUrl,
-    worktreeDir: useRelativeWorktree ? `./${worktreeDirRelative}` : config.worktreeDir
+    repoUrl: input2.repoUrl,
+    worktreeDir: useRelativeWorktree ? `./${worktreeDirRelative}` : input2.worktreeDir
   };
-  if (config.bareRepoDir) {
-    const bareRepoDirRelative = path11.relative(configDir, config.bareRepoDir);
+  if (input2.bareRepoDir) {
+    const bareRepoDirRelative = path15.relative(configDir, input2.bareRepoDir);
     const useRelativeBare = !bareRepoDirRelative.startsWith("../../../");
-    repository.bareRepoDir = useRelativeBare ? `./${bareRepoDirRelative}` : config.bareRepoDir;
+    repository.bareRepoDir = useRelativeBare ? `./${bareRepoDirRelative}` : input2.bareRepoDir;
   }
   const configObject = {
     defaults: {
-      cronSchedule: config.cronSchedule,
-      runOnce: config.runOnce
+      cronSchedule: input2.cronSchedule,
+      runOnce: input2.runOnce
     },
     repositories: [repository]
   };
-  const configContent = `/**
+  const configContent = `// @ts-check
+
+/**
  * Sync-worktrees configuration file
  * Generated on ${(/* @__PURE__ */ new Date()).toISOString()}
  */
 
-export default ${serializeToESM(configObject)};
+/** @satisfies {import("sync-worktrees").SyncWorktreesConfig} */
+const config = ${serializeToESM(configObject)};
+
+export default config;
 `;
-  await fs9.writeFile(configPath, configContent, "utf-8");
+  try {
+    await fs11.writeFile(configPath, configContent, {
+      encoding: "utf-8",
+      flag: options.overwrite ? "w" : "wx"
+    });
+  } catch (error) {
+    if (error.code === "EEXIST") {
+      throw new ConfigFileExistsError(configPath);
+    }
+    throw error;
+  }
 }
 function getDefaultConfigPath() {
-  return path11.join(process.cwd(), "sync-worktrees.config.js");
+  return path15.join(process.cwd(), "sync-worktrees.config.js");
 }
 async function findConfigInCwd(cwd = process.cwd()) {
   for (const name of CONFIG_FILE_NAMES) {
-    const full = path11.join(cwd, name);
-    try {
-      await fs9.access(full);
+    const full = path15.join(cwd, name);
+    if (await fileExists(full)) {
       return full;
-    } catch {
     }
   }
   return null;
 }
 
 // src/utils/interactive.ts
-import * as path12 from "path";
+import * as path16 from "path";
 import { confirm, input, select } from "@inquirer/prompts";
-async function promptForConfig(partialConfig) {
+async function promptForInitConfig() {
   console.log("\u{1F527} Welcome to sync-worktrees interactive setup!\n");
-  let repoUrl = partialConfig.repoUrl;
-  if (!repoUrl) {
-    repoUrl = await input({
-      message: "Enter the Git repository URL (e.g., https://github.com/user/repo.git):",
-      validate: (value) => {
-        if (!value.trim()) {
-          return "Repository URL is required";
-        }
-        try {
-          if (!value.match(/^(https?:\/\/|ssh:\/\/|git@|file:\/\/).*$/)) {
-            return "Please enter a valid Git URL (https://, ssh://, git@, or file://)";
-          }
-          return true;
-        } catch {
-          return "Please enter a valid URL";
-        }
+  const repoUrl = await input({
+    message: "Enter the Git repository URL (e.g., https://github.com/user/repo.git):",
+    validate: (value) => {
+      if (!value.trim()) {
+        return "Repository URL is required";
       }
-    });
-  }
-  let worktreeDir = partialConfig.worktreeDir;
-  if (!worktreeDir) {
-    const repoName = repoUrl ? extractRepoNameFromUrl(repoUrl) : "";
-    const defaultWorktreeDir = repoName ? `./${repoName}` : "";
-    worktreeDir = await input({
-      message: "Enter the directory for storing worktrees:",
-      default: defaultWorktreeDir,
-      validate: (value) => {
-        if (!value.trim() && !defaultWorktreeDir) {
-          return "Worktree directory is required";
-        }
-        return true;
+      if (!value.match(/^(https?:\/\/|ssh:\/\/|git@|file:\/\/).*$/)) {
+        return "Please enter a valid Git URL (https://, ssh://, git@, or file://)";
       }
-    });
-    if (!worktreeDir.trim() && defaultWorktreeDir) {
-      worktreeDir = defaultWorktreeDir;
+      return true;
     }
-    if (!path12.isAbsolute(worktreeDir)) {
-      worktreeDir = path12.resolve(worktreeDir);
+  });
+  const repoName = extractRepoNameFromUrl(repoUrl);
+  const defaultWorktreeDir = repoName ? `./${repoName}` : "";
+  let worktreeDir = await input({
+    message: "Enter the directory for storing worktrees:",
+    default: defaultWorktreeDir,
+    validate: (value) => {
+      if (!value.trim() && !defaultWorktreeDir) {
+        return "Worktree directory is required";
+      }
+      return true;
     }
+  });
+  if (!worktreeDir.trim() && defaultWorktreeDir) {
+    worktreeDir = defaultWorktreeDir;
   }
-  let bareRepoDir = partialConfig.bareRepoDir;
+  if (!path16.isAbsolute(worktreeDir)) {
+    worktreeDir = path16.resolve(worktreeDir);
+  }
+  let bareRepoDir;
   const askForBareDir = await confirm({
     message: "Would you like to specify a custom location for the bare repository?",
     default: false
@@ -5904,96 +7201,42 @@ async function promptForConfig(partialConfig) {
         return true;
       }
     });
-    if (!path12.isAbsolute(bareRepoDir)) {
-      bareRepoDir = path12.resolve(bareRepoDir);
-    }
-  }
-  let runOnce = partialConfig.runOnce;
-  let cronSchedule = partialConfig.cronSchedule || "0 * * * *";
-  if (runOnce === void 0) {
-    const runMode = await select({
-      message: "How would you like to run the sync?",
-      choices: [
-        { name: "Run once", value: "once" },
-        { name: "Schedule with cron", value: "scheduled" }
-      ]
-    });
-    runOnce = runMode === "once";
-    if (!runOnce && !partialConfig.cronSchedule) {
-      cronSchedule = await input({
-        message: "Enter the cron schedule (or press enter for default):",
-        default: "0 * * * *",
-        validate: (value) => {
-          if (!value.trim()) {
-            return "Cron schedule is required";
-          }
-          const parts = value.trim().split(" ");
-          if (parts.length < 5) {
-            return "Invalid cron pattern. Expected format: '* * * * *'";
-          }
-          return true;
-        }
-      });
+    if (!path16.isAbsolute(bareRepoDir)) {
+      bareRepoDir = path16.resolve(bareRepoDir);
     }
   }
-  const finalConfig = {
-    repoUrl,
-    worktreeDir,
-    cronSchedule,
-    runOnce: runOnce || false,
-    bareRepoDir
-  };
-  console.log("\n\u{1F4CB} Configuration summary:");
-  console.log(`   Repository URL: ${finalConfig.repoUrl}`);
-  console.log(`   Worktrees:      ${finalConfig.worktreeDir}`);
-  if (finalConfig.bareRepoDir) {
-    console.log(`   Bare repo:      ${finalConfig.bareRepoDir}`);
-  } else {
-    console.log(`   Bare repo:      .bare/<repo-name> (default)`);
-  }
-  if (finalConfig.runOnce) {
-    console.log(`   Mode:           Run once`);
-  } else {
-    console.log(`   Mode:           Scheduled (${finalConfig.cronSchedule})`);
-  }
-  console.log("");
-  const saveConfig = await confirm({
-    message: "Would you like to save this configuration to a file for future use?",
-    default: true
+  const runMode = await select({
+    message: "How would you like to run the sync?",
+    choices: [
+      { name: "Run once", value: "once" },
+      { name: "Schedule with cron", value: "scheduled" }
+    ]
   });
-  let savedConfigPath;
-  if (saveConfig) {
-    const defaultConfigPath = getDefaultConfigPath();
-    let configPath = await input({
-      message: "Enter the path for the config file:",
-      default: defaultConfigPath,
+  const runOnce = runMode === "once";
+  let cronSchedule = "0 * * * *";
+  if (!runOnce) {
+    cronSchedule = await input({
+      message: "Enter the cron schedule (or press enter for default):",
+      default: "0 * * * *",
       validate: (value) => {
         if (!value.trim()) {
-          return "Config file path is required";
+          return "Cron schedule is required";
         }
-        if (!value.endsWith(".js")) {
-          return "Config file must have a .js extension";
+        const parts = value.trim().split(" ");
+        if (parts.length < 5) {
+          return "Invalid cron pattern. Expected format: '* * * * *'";
         }
         return true;
       }
     });
-    if (!path12.isAbsolute(configPath)) {
-      configPath = path12.resolve(configPath);
-    }
-    try {
-      await generateConfigFile(finalConfig, configPath);
-      savedConfigPath = configPath;
-      console.log(`
-\u2705 Configuration saved to: ${configPath}`);
-      console.log(`
-\u{1F4A1} Next time run \`sync-worktrees\` from this directory \u2014 the config will be auto-loaded.`);
-      console.log("");
-    } catch (error) {
-      console.error(`
-\u274C Failed to save config file: ${error.message}`);
-    }
   }
-  return { config: finalConfig, savedConfigPath };
+  return {
+    repoUrl,
+    worktreeDir,
+    bareRepoDir,
+    cronSchedule,
+    runOnce
+  };
 }
 
 // src/utils/signal-handlers.ts
@@ -6045,48 +7288,12 @@ Shutdown took longer than ${forceExitMs}ms, forcing exit.`);
 
 // src/index.ts
 var signalHandle = setupSignalHandlers();
-async function runSingleRepository(config) {
-  const logger = Logger.createDefault(void 0, config.debug);
-  logger.info("\n\u{1F4CB} CLI Command (for future reference):");
-  logger.info(`   ${reconstructCliCommand(config)}`);
-  logger.info("");
-  if (!config.logger) {
-    config.logger = logger;
-  }
-  const syncService = new WorktreeSyncService(config);
-  try {
-    await syncService.initialize();
-    if (config.runOnce) {
-      logger.info("Running the sync process once as requested by --runOnce flag.");
-      await syncService.sync();
-    } else {
-      const uiService = new InteractiveUIService([syncService], void 0, config.cronSchedule);
-      signalHandle.register((fast) => uiService.destroy(fast));
-      await syncService.sync();
-      uiService.updateLastSyncTime();
-      void uiService.calculateAndUpdateDiskSpace();
-      const job = cron3.schedule(config.cronSchedule, async () => {
-        try {
-          uiService.setStatus("syncing");
-          await syncService.sync();
-          uiService.updateLastSyncTime();
-          void uiService.calculateAndUpdateDiskSpace();
-        } catch (error) {
-          logger.error(`Error during scheduled sync: ${error.message}`, error);
-          uiService.setStatus("idle");
-        }
-      });
-      uiService.registerCronJob(job);
-    }
-  } catch (error) {
-    logger.error("\u274C Fatal Error during initialization:", error);
-    process.exit(1);
-  }
-}
-async function runMultipleRepositories(repositories, runOnce, configPath, maxParallel, syncOnStart, reloadOptions) {
+async function runMultipleRepositories(configFile, repositories, configPath) {
   const services = /* @__PURE__ */ new Map();
   const globalLogger = Logger.createDefault();
-  const limit = pLimit3(maxParallel ?? DEFAULT_CONFIG.PARALLELISM.MAX_REPOSITORIES);
+  const runOnce = configFile.defaults?.runOnce ?? false;
+  const maxParallel = configFile.parallelism?.maxRepositories ?? configFile.defaults?.parallelism?.maxRepositories ?? DEFAULT_CONFIG.PARALLELISM.MAX_REPOSITORIES;
+  const limit = pLimit3(maxParallel);
   if (runOnce) {
     globalLogger.info(`
 \u{1F504} Syncing ${repositories.length} repositories...`);
@@ -6123,7 +7330,7 @@ async function runMultipleRepositories(repositories, runOnce, configPath, maxPar
       servicesToSync.map(
         ({ name, service }) => limit(async () => {
           try {
-            await service.sync();
+            return await service.sync();
           } catch (error) {
             globalLogger.error(`\u274C Error syncing repository '${name}':`, error);
             throw error;
@@ -6131,9 +7338,66 @@ async function runMultipleRepositories(repositories, runOnce, configPath, maxPar
         })
       )
     );
-    const successCount = syncResults.filter((r) => r.status === "fulfilled").length;
-    globalLogger.info(`
-\u2705 Successfully synced ${successCount}/${servicesToSync.length} repositories`);
+    const skipsByRepo = [];
+    const skippedNames = /* @__PURE__ */ new Set();
+    const outcomeFailedNames = /* @__PURE__ */ new Set();
+    const partialSkipNames = /* @__PURE__ */ new Set();
+    for (let i = 0; i < servicesToSync.length; i++) {
+      const { name, service } = servicesToSync[i];
+      const reasons = service.getRecordedSkips();
+      if (reasons.length > 0) {
+        skipsByRepo.push({ repo: name, reasons });
+        skippedNames.add(name);
+      }
+      const result = syncResults[i];
+      if (result.status === "fulfilled") {
+        if (!result.value.started) {
+          skippedNames.add(name);
+          continue;
+        }
+        const counts = result.value.outcome?.counts;
+        if (counts) {
+          if (counts.failed > 0) {
+            outcomeFailedNames.add(name);
+          }
+          if (counts.skipped > 0 && !skippedNames.has(name) && !outcomeFailedNames.has(name)) {
+            partialSkipNames.add(name);
+          }
+        }
+      }
+    }
+    if (skipsByRepo.length > 0) {
+      const skipsRepoWord = skipsByRepo.length === 1 ? "repo" : "repos";
+      globalLogger.warn(`
+\u26A0\uFE0F  Clone-mode skips (${skipsByRepo.length} ${skipsRepoWord}):`);
+      for (const { repo, reasons } of skipsByRepo) {
+        for (const reason of reasons) {
+          globalLogger.warn(`  \u2022 ${repo} \u2014 ${formatCloneSkipReason(reason)}`);
+        }
+      }
+    }
+    const initFailures = initResults.filter(
+      (result, index) => result.status === "rejected" && !skippedNames.has(repositories[index].name)
+    ).length;
+    const syncFailures = syncResults.filter(
+      (result, index) => result.status === "rejected" && !skippedNames.has(servicesToSync[index].name)
+    ).length;
+    const failedCount = initFailures + syncFailures + outcomeFailedNames.size;
+    const skippedCount = skippedNames.size;
+    const successCount = syncResults.filter((result, index) => {
+      const repoName = servicesToSync[index].name;
+      return result.status === "fulfilled" && result.value.started && !skippedNames.has(repoName) && !outcomeFailedNames.has(repoName);
+    }).length;
+    const processedRepoWord = repositories.length === 1 ? "repo" : "repos";
+    const skipSummaryLabel = skippedNames.size === skipsByRepo.length ? "with clone-mode skips" : "skipped";
+    const partialSuffix = partialSkipNames.size > 0 ? ` (${partialSkipNames.size} with partial skips)` : "";
+    globalLogger.info(
+      `
+\u{1F4CA} Processed ${repositories.length} ${processedRepoWord}: ${successCount} synced${partialSuffix}, ${skippedCount} ${skipSummaryLabel}, ${failedCount} failed`
+    );
+    if (failedCount > 0) {
+      process.exitCode = 1;
+    }
   } else {
     for (const repoConfig of repositories) {
       const syncService = new WorktreeSyncService(repoConfig);
@@ -6142,7 +7406,7 @@ async function runMultipleRepositories(repositories, runOnce, configPath, maxPar
     const uniqueSchedules = [...new Set(repositories.map((r) => r.cronSchedule))];
     const displaySchedule = uniqueSchedules.length === 1 ? uniqueSchedules[0] : void 0;
     const allServices = Array.from(services.values());
-    const uiService = new InteractiveUIService(allServices, configPath, displaySchedule, maxParallel, reloadOptions);
+    const uiService = new InteractiveUIService(allServices, configPath, displaySchedule, maxParallel);
     signalHandle.register((fast) => uiService.destroy(fast));
     void uiService.calculateAndUpdateDiskSpace();
     uiService.setupCronJobs();
@@ -6151,15 +7415,12 @@ async function runMultipleRepositories(repositories, runOnce, configPath, maxPar
     for (const repo of repositories) {
       cronSchedules.set(repo.cronSchedule, (cronSchedules.get(repo.cronSchedule) || 0) + 1);
     }
-    for (const [schedule3, count] of cronSchedules) {
-      uiService.addLog(`\u23F0 ${schedule3}: ${count} repository(ies)`);
-    }
-    if (syncOnStart) {
-      await uiService.triggerInitialSync();
+    for (const [schedule2, count] of cronSchedules) {
+      uiService.addLog(`\u23F0 ${schedule2}: ${count} repository(ies)`);
     }
   }
 }
-async function listRepositories(configPath, filter) {
+async function runList(configPath, filter) {
   const configLoader = new ConfigLoaderService();
   try {
     const { repositories } = await configLoader.buildRepositories(configPath, { filter });
@@ -6187,114 +7448,98 @@ async function listRepositories(configPath, filter) {
     process.exit(1);
   }
 }
-async function runFromConfigFile(configPath, options) {
+async function runFromConfigFile(configPath, runOnceOverride = false) {
   const configLoader = new ConfigLoaderService();
-  const { repositories, configFile } = await configLoader.buildRepositories(configPath, {
-    filter: options.filter,
-    noUpdateExisting: options.noUpdateExisting,
-    debug: options.debug
-  });
-  if (options.filter && repositories.length === 0) {
-    console.error(`\u274C No repositories match filter: ${options.filter}`);
+  const { repositories, configFile } = await configLoader.buildRepositories(configPath);
+  const effectiveConfigFile = runOnceOverride ? { ...configFile, defaults: { ...configFile.defaults ?? {}, runOnce: true } } : configFile;
+  await runMultipleRepositories(effectiveConfigFile, repositories, configPath);
+}
+async function resolveConfigOrExit(cliPath) {
+  const resolved = cliPath ? path17.resolve(cliPath) : await findConfigInCwd();
+  if (!resolved) {
+    console.error(
+      "\u274C No config file found. Pass --config <path>, run `sync-worktrees init` to create one, or place a sync-worktrees.config.{js,mjs,cjs} in this directory."
+    );
     process.exit(1);
   }
-  const globalRunOnce = options.runOnce ?? configFile.defaults?.runOnce ?? false;
-  const maxParallel = configFile.parallelism?.maxRepositories ?? configFile.defaults?.parallelism?.maxRepositories ?? DEFAULT_CONFIG.PARALLELISM.MAX_REPOSITORIES;
-  const reloadOptions = {
-    filter: options.filter,
-    noUpdateExisting: options.noUpdateExisting,
-    debug: options.debug
-  };
-  await runMultipleRepositories(
-    repositories,
-    globalRunOnce,
-    configPath,
-    maxParallel,
-    options.syncOnStart,
-    reloadOptions
-  );
+  return resolved;
 }
-async function runInteractive(partial, options) {
-  const result = await promptForConfig(partial);
-  if (result.savedConfigPath) {
-    await runFromConfigFile(result.savedConfigPath, {
-      filter: options.filter,
-      noUpdateExisting: options.noUpdateExisting,
-      debug: options.debug,
-      runOnce: options.runOnce,
-      syncOnStart: options.syncOnStart
-    });
-    return;
+function exitConfigExists(targetPath) {
+  console.error(`
+\u274C Config file already exists: ${targetPath}`);
+  console.error(`\u{1F4A1} Re-run with --force to overwrite.`);
+  process.exit(1);
+}
+async function runInit(configPath, force) {
+  const targetPath = configPath ? path17.resolve(configPath) : getDefaultConfigPath();
+  if (!force && await fileExists(targetPath)) {
+    exitConfigExists(targetPath);
   }
-  const config = result.config;
-  if (options.noUpdateExisting) {
-    config.updateExistingWorktrees = false;
-  } else if (config.updateExistingWorktrees === void 0) {
-    config.updateExistingWorktrees = true;
+  const input2 = await promptForInitConfig();
+  try {
+    await generateConfigFile(input2, targetPath, { overwrite: force });
+  } catch (error) {
+    if (error instanceof ConfigFileExistsError) {
+      exitConfigExists(error.configPath);
+    }
+    throw error;
   }
-  if (options.debug !== void 0) {
-    config.debug = options.debug;
+  const displayPath = path17.relative(process.cwd(), targetPath) || targetPath;
+  console.log(`
+\u2705 Configuration saved to: ${targetPath}`);
+  console.log(`
+\u{1F4A1} Next: sync-worktrees --config ${displayPath}`);
+}
+async function runSync(options) {
+  const configPath = await resolveConfigOrExit(options.config);
+  const displayPath = path17.relative(process.cwd(), configPath) || configPath;
+  console.log(`\u{1F4C4} Using config: ${displayPath}`);
+  try {
+    await runFromConfigFile(configPath, options.runOnce);
+  } catch (error) {
+    if (error instanceof ConfigFileNotFoundError) {
+      console.error(`
+\u274C Config file not found: ${error.configPath}`);
+      console.error(`\u{1F4A1} Run 'sync-worktrees init --config ${displayPath}' to create one.`);
+      process.exit(1);
+    }
+    console.error("\u274C Error loading config file:", error.message);
+    process.exit(1);
   }
-  await runSingleRepository(config);
 }
 async function main() {
   const options = parseArguments();
-  if (!options.config && !options.repoUrl && !options.worktreeDir) {
-    const discovered = await findConfigInCwd();
-    if (discovered) {
-      options.config = discovered;
-      console.log(`\u{1F4C4} Using config: ${path13.relative(process.cwd(), discovered)}`);
-    }
-  }
-  if (options.config) {
-    if (options.list) {
-      await listRepositories(options.config, options.filter);
-      return;
-    }
-    try {
-      await runFromConfigFile(options.config, {
-        filter: options.filter,
-        noUpdateExisting: options.noUpdateExisting,
-        debug: options.debug,
-        runOnce: options.runOnce,
-        syncOnStart: options.syncOnStart
-      });
-    } catch (error) {
-      if (error instanceof Error && error.message.includes("Config file not found")) {
-        console.error(`
-\u274C Config file not found: ${options.config}`);
-        const createConfig = await confirm2({
-          message: "Would you like to run interactive setup to create a config file?",
-          default: true
-        });
-        if (createConfig) {
-          await runInteractive({}, options);
-        } else {
-          console.log("\n\u{1F4A1} You can create a config file manually or run without --config for interactive setup.");
-          process.exit(1);
-        }
-      } else {
-        console.error("\u274C Error loading config file:", error.message);
-        process.exit(1);
-      }
+  switch (options.command) {
+    case CLI_COMMANDS.INIT:
+      return runInit(options.config, options.force);
+    case CLI_COMMANDS.LIST: {
+      const configPath = await resolveConfigOrExit(options.config);
+      return runList(configPath, options.filter);
     }
-  } else if (isInteractiveMode(options)) {
-    await runInteractive(options, options);
-  } else {
-    const config = options;
-    if (options.noUpdateExisting) {
-      config.updateExistingWorktrees = false;
-    } else if (config.updateExistingWorktrees === void 0) {
-      config.updateExistingWorktrees = true;
-    }
-    if (options.debug !== void 0) {
-      config.debug = options.debug;
+    case CLI_COMMANDS.RUN:
+      return runSync(options);
+    default: {
+      const _exhaustive = options;
+      throw new Error(`Unhandled command: ${JSON.stringify(_exhaustive)}`);
     }
-    await runSingleRepository(config);
   }
 }
-main().catch((error) => {
-  console.error("\u274C Unhandled error:", error);
-  process.exit(1);
-});
+function isMainEntrypoint() {
+  const entry = process.argv[1];
+  if (!entry) return false;
+  try {
+    return realpathSync2(entry) === fileURLToPath(import.meta.url);
+  } catch {
+    return false;
+  }
+}
+if (isMainEntrypoint()) {
+  main().catch((error) => {
+    console.error("\u274C Unhandled error:", error);
+    process.exit(1);
+  });
+}
+export {
+  runMultipleRepositories
+};
 //# sourceMappingURL=index.js.map