sync-worktrees 2.0.0 → 2.1.0

package/dist/index.js

@@ -4,6 +4,96 @@
 import * as path8 from "path";
 import { confirm as confirm2 } from "@inquirer/prompts";
 import * as cron2 from "node-cron";
+import pLimit2 from "p-limit";
+
+// src/constants.ts
+var GIT_CONSTANTS = {
+  REMOTE_PREFIX: "origin/",
+  REMOTE_NAME: "origin",
+  HEAD_REF: "/HEAD",
+  DEFAULT_BRANCH: "main",
+  COMMON_DEFAULT_BRANCHES: ["main", "master", "develop", "trunk"],
+  BARE_DIR_NAME: ".bare",
+  DIVERGED_DIR_NAME: ".diverged",
+  LFS_HEADER: "version https://git-lfs.github.com/spec/",
+  SUBMODULE_STATUS_ADDED: "+",
+  SUBMODULE_STATUS_REMOVED: "-",
+  GITDIR_PREFIX: "gitdir:",
+  GIT_CHECK_IGNORE_NO_MATCH: "exit code: 1",
+  REFS: {
+    HEADS: "refs/heads/",
+    REMOTES: "refs/remotes/origin",
+    REMOTES_ORIGIN: "refs/remotes/origin/*"
+  },
+  FETCH_CONFIG: "+refs/heads/*:refs/remotes/origin/*"
+};
+var GIT_OPERATIONS = {
+  MERGE_HEAD: "MERGE_HEAD",
+  CHERRY_PICK_HEAD: "CHERRY_PICK_HEAD",
+  REVERT_HEAD: "REVERT_HEAD",
+  BISECT_LOG: "BISECT_LOG",
+  REBASE_MERGE: "rebase-merge",
+  REBASE_APPLY: "rebase-apply"
+};
+var DEFAULT_CONFIG = {
+  CRON_SCHEDULE: "0 * * * *",
+  RETRY: {
+    MAX_ATTEMPTS: 3,
+    MAX_LFS_RETRIES: 2,
+    INITIAL_DELAY_MS: 1e3,
+    MAX_DELAY_MS: 3e4,
+    BACKOFF_MULTIPLIER: 2,
+    JITTER_MS: 500
+  },
+  PARALLELISM: {
+    MAX_REPOSITORIES: 2,
+    MAX_WORKTREE_CREATION: 1,
+    MAX_WORKTREE_UPDATES: 3,
+    MAX_WORKTREE_REMOVAL: 3,
+    MAX_STATUS_CHECKS: 20,
+    MAX_SAFE_TOTAL_CONCURRENT_OPS: 100
+  },
+  UPDATE_EXISTING_WORKTREES: true
+};
+var ERROR_MESSAGES = {
+  GIT_NOT_INITIALIZED: "Git service not initialized. Call initialize() first.",
+  ALREADY_EXISTS: "already exists",
+  ALREADY_REGISTERED: "already registered worktree",
+  FAST_FORWARD_FAILED: [
+    "Not possible to fast-forward",
+    "fatal: Not possible to fast-forward, aborting",
+    "cannot fast-forward"
+  ],
+  NO_UPSTREAM: [
+    "fatal: no upstream configured",
+    "no upstream configured for branch",
+    "fatal: ambiguous argument",
+    "unknown revision or path"
+  ],
+  LFS_ERROR: ["smudge filter lfs failed", "git-lfs", "LFS"],
+  EXDEV: "EXDEV"
+};
+var ENV_CONSTANTS = {
+  GIT_LFS_SKIP_SMUDGE: "GIT_LFS_SKIP_SMUDGE",
+  NODE_ENV_TEST: "test"
+};
+var PATH_CONSTANTS = {
+  GIT_DIR: ".git",
+  README: "README"
+};
+var CONFIG_CONSTANTS = {
+  WILDCARD_PATTERN: ".*"
+};
+var METADATA_CONSTANTS = {
+  MAX_HISTORY_ENTRIES: 10,
+  METADATA_FILENAME: "sync-metadata.json",
+  WORKTREE_METADATA_PATH: ".git/worktrees",
+  DIVERGED_INFO_FILE: ".diverged-info.json",
+  DIVERGED_REASON: "diverged-history-with-changes",
+  ACTION_CREATED: "created",
+  ACTION_UPDATED: "updated",
+  ACTION_FETCHED: "fetched"
+};
 
 // src/services/config-loader.service.ts
 import * as fs from "fs/promises";
@@ -114,13 +204,66 @@ var ConfigLoaderService = class {
         throw new Error("Invalid 'backoffMultiplier' in retry config");
       }
     }
+    if (configObj.parallelism !== void 0) {
+      this.validateParallelismConfig(configObj.parallelism, "global");
+    }
+    if (configObj.defaults && typeof configObj.defaults === "object") {
+      const defaults = configObj.defaults;
+      if (defaults.parallelism !== void 0) {
+        this.validateParallelismConfig(defaults.parallelism, "defaults");
+      }
+    }
+  }
+  validateParallelismConfig(parallelism, context) {
+    if (typeof parallelism !== "object" || parallelism === null) {
+      throw new Error(`'parallelism' in ${context} must be an object`);
+    }
+    const config = parallelism;
+    if (config.maxRepositories !== void 0) {
+      if (typeof config.maxRepositories !== "number" || config.maxRepositories < 1) {
+        throw new Error(`Invalid 'maxRepositories' in ${context} parallelism config. Must be a positive number`);
+      }
+    }
+    if (config.maxWorktreeCreation !== void 0) {
+      if (typeof config.maxWorktreeCreation !== "number" || config.maxWorktreeCreation < 1) {
+        throw new Error(`Invalid 'maxWorktreeCreation' in ${context} parallelism config. Must be a positive number`);
+      }
+    }
+    if (config.maxWorktreeUpdates !== void 0) {
+      if (typeof config.maxWorktreeUpdates !== "number" || config.maxWorktreeUpdates < 1) {
+        throw new Error(`Invalid 'maxWorktreeUpdates' in ${context} parallelism config. Must be a positive number`);
+      }
+    }
+    if (config.maxWorktreeRemoval !== void 0) {
+      if (typeof config.maxWorktreeRemoval !== "number" || config.maxWorktreeRemoval < 1) {
+        throw new Error(`Invalid 'maxWorktreeRemoval' in ${context} parallelism config. Must be a positive number`);
+      }
+    }
+    if (config.maxStatusChecks !== void 0) {
+      if (typeof config.maxStatusChecks !== "number" || config.maxStatusChecks < 1) {
+        throw new Error(`Invalid 'maxStatusChecks' in ${context} parallelism config. Must be a positive number`);
+      }
+    }
+    const maxRepos = config.maxRepositories ?? DEFAULT_CONFIG.PARALLELISM.MAX_REPOSITORIES;
+    const maxCreation = config.maxWorktreeCreation ?? DEFAULT_CONFIG.PARALLELISM.MAX_WORKTREE_CREATION;
+    const maxUpdates = config.maxWorktreeUpdates ?? DEFAULT_CONFIG.PARALLELISM.MAX_WORKTREE_UPDATES;
+    const maxRemoval = config.maxWorktreeRemoval ?? DEFAULT_CONFIG.PARALLELISM.MAX_WORKTREE_REMOVAL;
+    const maxStatus = config.maxStatusChecks ?? DEFAULT_CONFIG.PARALLELISM.MAX_STATUS_CHECKS;
+    const maxPerRepoOps = maxCreation + maxUpdates + maxRemoval + maxStatus;
+    const totalMaxConcurrent = maxRepos * maxPerRepoOps;
+    if (totalMaxConcurrent > DEFAULT_CONFIG.PARALLELISM.MAX_SAFE_TOTAL_CONCURRENT_OPS) {
+      const safeMaxRepos = Math.floor(DEFAULT_CONFIG.PARALLELISM.MAX_SAFE_TOTAL_CONCURRENT_OPS / maxPerRepoOps);
+      throw new Error(
+        `Total concurrent operations (${totalMaxConcurrent}) exceeds safe limit (${DEFAULT_CONFIG.PARALLELISM.MAX_SAFE_TOTAL_CONCURRENT_OPS}). With current per-repository limits (creation: ${maxCreation}, updates: ${maxUpdates}, removal: ${maxRemoval}, status: ${maxStatus}), maximum safe maxRepositories is ${safeMaxRepos}. Consider reducing maxRepositories or lowering per-operation limits.`
+      );
+    }
   }
   resolveRepositoryConfig(repo, defaults, configDir, globalRetry) {
     const resolved = {
       name: repo.name,
       repoUrl: repo.repoUrl,
       worktreeDir: this.resolvePath(repo.worktreeDir, configDir),
-      cronSchedule: repo.cronSchedule ?? defaults?.cronSchedule ?? "0 * * * *",
+      cronSchedule: repo.cronSchedule ?? defaults?.cronSchedule ?? DEFAULT_CONFIG.CRON_SCHEDULE,
       runOnce: repo.runOnce ?? defaults?.runOnce ?? false
     };
     if (repo.bareRepoDir) {
@@ -139,6 +282,12 @@ var ConfigLoaderService = class {
         ...repo.retry || {}
       };
     }
+    if (repo.parallelism || defaults?.parallelism) {
+      resolved.parallelism = {
+        ...defaults?.parallelism || {},
+        ...repo.parallelism || {}
+      };
+    }
     if (repo.updateExistingWorktrees !== void 0 || defaults?.updateExistingWorktrees !== void 0) {
       resolved.updateExistingWorktrees = repo.updateExistingWorktrees ?? defaults?.updateExistingWorktrees ?? true;
     }
@@ -158,7 +307,7 @@ var ConfigLoaderService = class {
     return repositories.filter((repo) => {
       return patterns.some((pattern) => {
         if (pattern.includes("*")) {
-          const regex = new RegExp("^" + pattern.replace(/\*/g, ".*") + "$");
+          const regex = new RegExp("^" + pattern.replace(/\*/g, CONFIG_CONSTANTS.WILDCARD_PATTERN) + "$");
           return regex.test(repo.name);
         }
         return repo.name === pattern;
@@ -294,6 +443,7 @@ var App_default = App;
 // src/services/worktree-sync.service.ts
 import * as fs5 from "fs/promises";
 import * as path5 from "path";
+import pLimit from "p-limit";
 
 // src/utils/date-filter.ts
 function parseDuration(durationStr) {
@@ -373,6 +523,7 @@ var DEFAULT_OPTIONS = {
   maxDelayMs: 6e5,
   // 10 minutes
   backoffMultiplier: 2,
+  jitterMs: 0,
   shouldRetry: (error, context) => {
     const err = error;
     if (isLfsErrorFromError(error)) {
@@ -430,7 +581,9 @@ async function retry(fn, options = {}) {
       if (lfsContext.isLfsError && opts.lfsRetryHandler) {
         opts.lfsRetryHandler(lfsContext);
       }
-      const delay = Math.min(opts.initialDelayMs * Math.pow(opts.backoffMultiplier, attempt - 1), opts.maxDelayMs);
+      const baseDelay = Math.min(opts.initialDelayMs * Math.pow(opts.backoffMultiplier, attempt - 1), opts.maxDelayMs);
+      const jitter = opts.jitterMs > 0 ? Math.random() * opts.jitterMs : 0;
+      const delay = baseDelay + jitter;
       opts.onRetry(error, attempt, lfsContext);
       await new Promise((resolve6) => setTimeout(resolve6, delay));
       attempt++;
@@ -438,6 +591,106 @@ async function retry(fn, options = {}) {
   }
 }
 
+// src/utils/timing.ts
+import Table from "cli-table3";
+var Timer = class {
+  startTime;
+  endTime;
+  constructor() {
+    this.startTime = Date.now();
+  }
+  stop() {
+    this.endTime = Date.now();
+    return this.getDuration();
+  }
+  getDuration() {
+    const end = this.endTime ?? Date.now();
+    return end - this.startTime;
+  }
+};
+var PhaseTimer = class {
+  phases = /* @__PURE__ */ new Map();
+  currentPhase;
+  startPhase(name, parallelism) {
+    if (this.currentPhase) {
+      this.endPhase();
+    }
+    this.currentPhase = name;
+    this.phases.set(name, { timer: new Timer(), parallelism });
+  }
+  endPhase() {
+    if (this.currentPhase) {
+      const phase = this.phases.get(this.currentPhase);
+      if (phase) {
+        phase.timer.stop();
+      }
+      this.currentPhase = void 0;
+    }
+  }
+  setPhaseCount(name, count) {
+    const phase = this.phases.get(name);
+    if (phase) {
+      phase.count = count;
+    }
+  }
+  getResults() {
+    if (this.currentPhase) {
+      this.endPhase();
+    }
+    const results = [];
+    for (const [name, { timer, count, parallelism }] of this.phases.entries()) {
+      const duration = timer.getDuration();
+      const result = {
+        name,
+        duration,
+        count
+      };
+      if (count && count > 0 && parallelism && parallelism > 1) {
+        const batches = Math.ceil(count / parallelism);
+        const avgTimePerBatch = duration / batches;
+        const theoreticalSequentialTime = count * avgTimePerBatch;
+        result.efficiency = theoreticalSequentialTime > 0 ? Math.round(theoreticalSequentialTime / duration * 100) : 100;
+      }
+      results.push(result);
+    }
+    return results;
+  }
+};
+function formatDuration2(ms) {
+  if (ms < 1e3) {
+    return `${ms}ms`;
+  }
+  if (ms < 6e4) {
+    return `${(ms / 1e3).toFixed(1)}s`;
+  }
+  const minutes = Math.floor(ms / 6e4);
+  const seconds = Math.floor(ms % 6e4 / 1e3);
+  return `${minutes}m ${seconds}s`;
+}
+function formatTimingTable(totalDuration, phaseResults, repoName) {
+  const header = repoName ? `Performance Summary - [${repoName}]` : "Performance Summary";
+  const table = new Table({
+    head: ["Operation", "Duration", "Efficiency"],
+    colWidths: [35, 12, 12],
+    style: {
+      head: ["cyan", "bold"],
+      border: ["gray"]
+    }
+  });
+  table.push([{ colSpan: 3, content: header, hAlign: "center" }]);
+  table.push(["Total Sync", formatDuration2(totalDuration), ""]);
+  for (let i = 0; i < phaseResults.length; i++) {
+    const result = phaseResults[i];
+    const isLast = i === phaseResults.length - 1;
+    const countStr = result.count ? ` (${result.count})` : "";
+    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]);
+  }
+  return table.toString();
+}
+
 // src/services/git.service.ts
 import * as fs4 from "fs/promises";
 import * as path4 from "path";
@@ -469,29 +722,54 @@ function getDefaultBareRepoDir(repoUrl, baseDir = ".bare") {
   return `${baseDir}/${repoName}`;
 }
 
+// src/services/logger.service.ts
+var Logger = class _Logger {
+  repoName;
+  debugEnabled;
+  constructor(options = {}) {
+    this.repoName = options.repoName;
+    this.debugEnabled = options.debug ?? false;
+  }
+  prefix() {
+    return this.repoName ? `[${this.repoName}] ` : "";
+  }
+  debug(message, ...args) {
+    if (!this.debugEnabled) return;
+    console.log(this.prefix() + this.formatMessage(message, args));
+  }
+  info(message, ...args) {
+    console.log(this.prefix() + this.formatMessage(message, args));
+  }
+  warn(message, ...args) {
+    console.warn(this.prefix() + this.formatMessage(message, args));
+  }
+  error(message, error) {
+    if (error instanceof Error) {
+      console.error(this.prefix() + message, error);
+    } else if (error) {
+      console.error(this.prefix() + message, error);
+    } else {
+      console.error(this.prefix() + message);
+    }
+  }
+  table(content) {
+    console.log("\n" + content + "\n");
+  }
+  formatMessage(message, args) {
+    if (args.length === 0) {
+      return message;
+    }
+    return args.reduce((msg, arg) => msg.replace("%s", String(arg)), message);
+  }
+  static createDefault(repoName, debug) {
+    return new _Logger({ repoName, debug });
+  }
+};
+
 // src/services/worktree-metadata.service.ts
 import * as fs2 from "fs/promises";
 import * as path2 from "path";
 import simpleGit from "simple-git";
-
-// src/constants.ts
-var GIT_OPERATIONS = {
-  MERGE_HEAD: "MERGE_HEAD",
-  CHERRY_PICK_HEAD: "CHERRY_PICK_HEAD",
-  REVERT_HEAD: "REVERT_HEAD",
-  BISECT_LOG: "BISECT_LOG",
-  REBASE_MERGE: "rebase-merge",
-  REBASE_APPLY: "rebase-apply"
-};
-var PATH_CONSTANTS = {
-  GIT_DIR: ".git",
-  README: "README"
-};
-var METADATA_CONSTANTS = {
-  MAX_HISTORY_ENTRIES: 10
-};
-
-// src/services/worktree-metadata.service.ts
 var WorktreeMetadataService = class {
   /**
    * Gets the internal worktree directory name from a worktree path.
@@ -502,7 +780,12 @@ var WorktreeMetadataService = class {
     return path2.basename(worktreePath);
   }
   async getMetadataPath(bareRepoPath, worktreeName) {
-    return path2.join(bareRepoPath, ".git", "worktrees", worktreeName, "sync-metadata.json");
+    return path2.join(
+      bareRepoPath,
+      METADATA_CONSTANTS.WORKTREE_METADATA_PATH,
+      worktreeName,
+      METADATA_CONSTANTS.METADATA_FILENAME
+    );
   }
   async getMetadataPathFromWorktreePath(bareRepoPath, worktreePath) {
     const worktreeDirName = this.getWorktreeDirectoryName(worktreePath);
@@ -537,7 +820,12 @@ var WorktreeMetadataService = class {
         const branchName = path2.basename(worktreePath);
         const parentDir = path2.dirname(worktreePath);
         const possibleBranchWithSlash = path2.join(path2.basename(parentDir), branchName);
-        const oldPath = path2.join(bareRepoPath, ".git", "worktrees", possibleBranchWithSlash, "sync-metadata.json");
+        const oldPath = path2.join(
+          bareRepoPath,
+          METADATA_CONSTANTS.WORKTREE_METADATA_PATH,
+          possibleBranchWithSlash,
+          METADATA_CONSTANTS.METADATA_FILENAME
+        );
         const content = await fs2.readFile(oldPath, "utf-8");
         const metadata = JSON.parse(content);
         if (!await this.validateMetadata(metadata)) {
@@ -620,7 +908,7 @@ var WorktreeMetadataService = class {
           }
         } catch {
         }
-        const parentBranch = defaultBranch || "main";
+        const parentBranch = defaultBranch || GIT_CONSTANTS.DEFAULT_BRANCH;
         await this.createInitialMetadataFromPath(
           bareRepoPath,
           worktreePath,
@@ -853,7 +1141,7 @@ var WorktreeStatusService = class {
       const lines = result.split("\n").filter((line) => line.trim());
       for (const line of lines) {
         const firstChar = line.charAt(0);
-        if (firstChar === "+" || firstChar === "-") {
+        if (firstChar === GIT_CONSTANTS.SUBMODULE_STATUS_ADDED || firstChar === GIT_CONSTANTS.SUBMODULE_STATUS_REMOVED) {
           return true;
         }
       }
@@ -951,7 +1239,7 @@ var WorktreeStatusService = class {
       const modifiedSubmodules = [];
       for (const line of lines) {
         const firstChar = line.charAt(0);
-        if (firstChar === "+" || firstChar === "-") {
+        if (firstChar === GIT_CONSTANTS.SUBMODULE_STATUS_ADDED || firstChar === GIT_CONSTANTS.SUBMODULE_STATUS_REMOVED) {
           const match = line.match(/^[+-]\s*(\S+)/);
           if (match) {
             modifiedSubmodules.push(match[1]);
@@ -1000,7 +1288,7 @@ var WorktreeStatusService = class {
       return files.filter((f) => !ignoredFiles.has(f));
     } catch (error) {
       const errorMessage = getErrorMessage(error);
-      if (errorMessage.includes("exit code: 1")) {
+      if (errorMessage.includes(GIT_CONSTANTS.GIT_CHECK_IGNORE_NO_MATCH)) {
         return files;
       }
       console.warn(`Warning: Could not check gitignore status for files in ${worktreePath}: ${errorMessage}`);
@@ -1021,7 +1309,7 @@ var WorktreeStatusService = class {
       const stat4 = await fs3.stat(gitPath);
       if (stat4.isFile()) {
         const content = await fs3.readFile(gitPath, "utf-8");
-        const gitdirMatch = content.match(/^gitdir:\s*(.+)$/m);
+        const gitdirMatch = content.match(new RegExp(`^${GIT_CONSTANTS.GITDIR_PREFIX}\\s*(.+)$`, "m"));
         if (gitdirMatch) {
           return path3.resolve(worktreePath, gitdirMatch[1].trim());
         }
@@ -1043,31 +1331,33 @@ var WorktreeStatusService = class {
 
 // src/services/git.service.ts
 var GitService = class {
-  constructor(config) {
+  constructor(config, logger) {
     this.config = config;
+    this.logger = logger ?? Logger.createDefault(void 0, config.debug);
     this.bareRepoPath = this.config.bareRepoDir || getDefaultBareRepoDir(this.config.repoUrl);
-    this.mainWorktreePath = path4.join(this.config.worktreeDir, "main");
+    this.mainWorktreePath = path4.join(this.config.worktreeDir, GIT_CONSTANTS.DEFAULT_BRANCH);
     this.metadataService = new WorktreeMetadataService();
     this.statusService = new WorktreeStatusService({ skipLfs: this.config.skipLfs });
   }
   git = null;
   bareRepoPath;
   mainWorktreePath;
-  defaultBranch = "main";
+  defaultBranch = GIT_CONSTANTS.DEFAULT_BRANCH;
   // Will be updated after detection
   metadataService;
   statusService;
+  logger;
   async initialize() {
     const { repoUrl } = this.config;
     try {
       await fs4.access(path4.join(this.bareRepoPath, "HEAD"));
-      console.log(`Bare repository at "${this.bareRepoPath}" already exists. Using it.`);
+      this.logger.info(`Bare repository at "${this.bareRepoPath}" already exists. Using it.`);
     } catch {
-      console.log(`Cloning from "${repoUrl}" as bare repository into "${this.bareRepoPath}"...`);
+      this.logger.info(`Cloning from "${repoUrl}" as bare repository into "${this.bareRepoPath}"...`);
       await fs4.mkdir(path4.dirname(this.bareRepoPath), { recursive: true });
-      const cloneGit = this.isLfsSkipEnabled() ? simpleGit3().env({ GIT_LFS_SKIP_SMUDGE: "1" }) : simpleGit3();
+      const cloneGit = this.isLfsSkipEnabled() ? simpleGit3().env({ [ENV_CONSTANTS.GIT_LFS_SKIP_SMUDGE]: "1" }) : simpleGit3();
       await cloneGit.clone(repoUrl, this.bareRepoPath, ["--bare"]);
-      console.log("\u2705 Clone successful.");
+      this.logger.info("\u2705 Clone successful.");
     }
     const bareGit = simpleGit3(this.bareRepoPath);
     try {
@@ -1079,11 +1369,11 @@ var GitService = class {
     } catch {
       await bareGit.addConfig("remote.origin.fetch", "+refs/heads/*:refs/remotes/origin/*");
     }
-    console.log("Fetching remote branches...");
+    this.logger.info("Fetching remote branches...");
     await bareGit.fetch(["--all"]);
     this.defaultBranch = await this.detectDefaultBranch(bareGit);
     this.mainWorktreePath = path4.join(this.config.worktreeDir, this.defaultBranch);
-    console.log(`Detected default branch: ${this.defaultBranch}`);
+    this.logger.info(`Detected default branch: ${this.defaultBranch}`);
     let needsMainWorktree = true;
     try {
       const worktrees = await this.getWorktreesFromBare(bareGit);
@@ -1091,7 +1381,7 @@ var GitService = class {
     } catch {
     }
     if (needsMainWorktree) {
-      console.log(`Creating ${this.defaultBranch} worktree at "${this.mainWorktreePath}"...`);
+      this.logger.info(`Creating ${this.defaultBranch} worktree at "${this.mainWorktreePath}"...`);
       await fs4.mkdir(this.config.worktreeDir, { recursive: true });
       const absoluteWorktreePath = path4.resolve(this.mainWorktreePath);
       try {
@@ -1099,7 +1389,7 @@ var GitService = class {
         const defaultBranchExists = branches.all.includes(this.defaultBranch);
         if (defaultBranchExists) {
           await bareGit.raw(["worktree", "add", absoluteWorktreePath, this.defaultBranch]);
-          const worktreeGit = this.isLfsSkipEnabled() ? simpleGit3(absoluteWorktreePath).env({ GIT_LFS_SKIP_SMUDGE: "1" }) : simpleGit3(absoluteWorktreePath);
+          const worktreeGit = this.isLfsSkipEnabled() ? simpleGit3(absoluteWorktreePath).env({ [ENV_CONSTANTS.GIT_LFS_SKIP_SMUDGE]: "1" }) : simpleGit3(absoluteWorktreePath);
           await worktreeGit.branch(["--set-upstream-to", `origin/${this.defaultBranch}`, this.defaultBranch]);
         } else {
           await bareGit.raw([
@@ -1115,17 +1405,17 @@ var GitService = class {
       } catch (error) {
         const errorMessage = getErrorMessage(error);
         if (errorMessage.includes("already exists")) {
-          console.log(
+          this.logger.info(
             `${this.defaultBranch} worktree directory already exists at '${absoluteWorktreePath}', skipping creation.`
           );
         } else {
-          console.warn(`Failed to create ${this.defaultBranch} worktree with tracking, using simple add: ${error}`);
+          this.logger.warn(`Failed to create ${this.defaultBranch} worktree with tracking, using simple add: ${error}`);
           try {
             await bareGit.raw(["worktree", "add", absoluteWorktreePath, this.defaultBranch]);
           } catch (fallbackError) {
             const fallbackErrorMessage = getErrorMessage(fallbackError);
             if (fallbackErrorMessage.includes("already exists")) {
-              console.log(
+              this.logger.info(
                 `${this.defaultBranch} worktree directory already exists at '${absoluteWorktreePath}', skipping creation.`
               );
             } else {
@@ -1139,8 +1429,8 @@ var GitService = class {
         (w) => path4.resolve(w.path) === path4.resolve(this.mainWorktreePath)
       );
       if (!mainWorktreeRegistered) {
-        if (process.env.NODE_ENV !== "test") {
-          console.warn(`Main worktree was created but not found in worktree list. This may cause issues.`);
+        if (process.env.NODE_ENV !== ENV_CONSTANTS.NODE_ENV_TEST) {
+          this.logger.warn(`Main worktree was created but not found in worktree list. This may cause issues.`);
         }
       }
     }
@@ -1158,9 +1448,9 @@ var GitService = class {
   }
   async fetchAll() {
     const git = this.getGit();
-    console.log("Fetching latest data from remote...");
+    this.logger.info("Fetching latest data from remote...");
     if (this.isLfsSkipEnabled()) {
-      await git.env({ GIT_LFS_SKIP_SMUDGE: "1" }).fetch(["--all", "--prune"]);
+      await git.env({ [ENV_CONSTANTS.GIT_LFS_SKIP_SMUDGE]: "1" }).fetch(["--all", "--prune"]);
     } else {
       await git.fetch(["--all", "--prune"]);
     }
@@ -1168,7 +1458,7 @@ var GitService = class {
   async fetchBranch(branchName) {
     const git = this.getGit();
     if (this.isLfsSkipEnabled()) {
-      await git.env({ GIT_LFS_SKIP_SMUDGE: "1" }).fetch(["origin", branchName, "--prune"]);
+      await git.env({ [ENV_CONSTANTS.GIT_LFS_SKIP_SMUDGE]: "1" }).fetch(["origin", branchName, "--prune"]);
     } else {
       await git.fetch(["origin", branchName, "--prune"]);
     }
@@ -1211,7 +1501,7 @@ var GitService = class {
         return;
       }
       if (this.config.debug) {
-        console.log(`  - Verifying ${lfsFileList.length} LFS files are downloaded...`);
+        this.logger.info(`  - Verifying ${lfsFileList.length} LFS files are downloaded...`);
       }
       const sampleSize = Math.min(5, lfsFileList.length);
       const samplesToCheck = [];
@@ -1233,7 +1523,7 @@ var GitService = class {
               const buffer = Buffer.alloc(200);
               const { bytesRead } = await handle.read(buffer, 0, buffer.length, 0);
               const header = buffer.subarray(0, bytesRead).toString("utf8");
-              if (header.startsWith("version https://git-lfs.github.com/spec/")) {
+              if (header.startsWith(GIT_CONSTANTS.LFS_HEADER)) {
                 allDownloaded = false;
                 notDownloaded.push(file);
               }
@@ -1247,7 +1537,7 @@ var GitService = class {
         }
         if (allDownloaded) {
           if (this.config.debug) {
-            console.log(`  - \u2705 LFS files verified (${samplesToCheck.length} samples checked)`);
+            this.logger.info(`  - \u2705 LFS files verified (${samplesToCheck.length} samples checked)`);
           }
           return;
         }
@@ -1256,16 +1546,16 @@ var GitService = class {
           await new Promise((resolve6) => setTimeout(resolve6, retryDelay));
         }
       }
-      console.warn(
+      this.logger.warn(
         `  - \u26A0\uFE0F Warning: Some LFS files may not be fully downloaded after ${maxRetries} seconds. This might cause issues if tools access the worktree immediately.`
       );
     } catch (error) {
-      console.warn(`  - \u26A0\uFE0F Warning: Could not verify LFS files for '${branchName}': ${error}`);
+      this.logger.warn(`  - \u26A0\uFE0F Warning: Could not verify LFS files for '${branchName}': ${error}`);
     }
   }
   async createWorktreeMetadata(bareGit, worktreePath, branchName) {
     try {
-      const worktreeGit = this.isLfsSkipEnabled() ? simpleGit3(worktreePath).env({ GIT_LFS_SKIP_SMUDGE: "1" }) : simpleGit3(worktreePath);
+      const worktreeGit = this.isLfsSkipEnabled() ? simpleGit3(worktreePath).env({ [ENV_CONSTANTS.GIT_LFS_SKIP_SMUDGE]: "1" }) : simpleGit3(worktreePath);
       const currentCommit = await worktreeGit.revparse(["HEAD"]);
       const parentCommit = await bareGit.revparse([this.defaultBranch]);
       await this.metadataService.createInitialMetadataFromPath(
@@ -1277,12 +1567,12 @@ var GitService = class {
         parentCommit.trim()
       );
     } catch (metadataError) {
-      console.error(`  - \u274C Failed to create metadata for '${branchName}': ${metadataError}`);
+      this.logger.error(`  - \u274C Failed to create metadata for '${branchName}': ${metadataError}`);
       throw new Error(`Metadata creation failed for ${branchName}. This worktree cannot be auto-managed.`);
     }
   }
   async addWorktree(branchName, worktreePath) {
-    const bareGit = this.isLfsSkipEnabled() ? simpleGit3(this.bareRepoPath).env({ GIT_LFS_SKIP_SMUDGE: "1" }) : simpleGit3(this.bareRepoPath);
+    const bareGit = this.isLfsSkipEnabled() ? simpleGit3(this.bareRepoPath).env({ [ENV_CONSTANTS.GIT_LFS_SKIP_SMUDGE]: "1" }) : simpleGit3(this.bareRepoPath);
     const absoluteWorktreePath = path4.resolve(worktreePath);
     await fs4.mkdir(path4.dirname(absoluteWorktreePath), { recursive: true });
     try {
@@ -1290,10 +1580,10 @@ var GitService = class {
       const worktrees = await this.getWorktreesFromBare(bareGit);
       const isValidWorktree = worktrees.some((w) => path4.resolve(w.path) === absoluteWorktreePath);
       if (isValidWorktree) {
-        console.log(`  - Worktree for '${branchName}' already exists at '${absoluteWorktreePath}'`);
+        this.logger.info(`  - Worktree for '${branchName}' already exists at '${absoluteWorktreePath}'`);
         return;
       } else {
-        console.log(`  - Cleaning up orphaned directory at '${absoluteWorktreePath}'`);
+        this.logger.info(`  - Cleaning up orphaned directory at '${absoluteWorktreePath}'`);
         await fs4.rm(absoluteWorktreePath, { recursive: true, force: true });
       }
     } catch {
@@ -1303,7 +1593,7 @@ var GitService = class {
       const localBranchExists = branches.all.includes(branchName);
       if (localBranchExists || branchName.includes("/")) {
         await bareGit.raw(["worktree", "add", absoluteWorktreePath, branchName]);
-        const worktreeGit = this.isLfsSkipEnabled() ? simpleGit3(absoluteWorktreePath).env({ GIT_LFS_SKIP_SMUDGE: "1" }) : simpleGit3(absoluteWorktreePath);
+        const worktreeGit = this.isLfsSkipEnabled() ? simpleGit3(absoluteWorktreePath).env({ [ENV_CONSTANTS.GIT_LFS_SKIP_SMUDGE]: "1" }) : simpleGit3(absoluteWorktreePath);
         await worktreeGit.branch(["--set-upstream-to", `origin/${branchName}`, branchName]);
       } else {
         await bareGit.raw([
@@ -1316,7 +1606,7 @@ var GitService = class {
           `origin/${branchName}`
         ]);
       }
-      console.log(`  - Created worktree for '${branchName}' with tracking to origin/${branchName}`);
+      this.logger.info(`  - Created worktree for '${branchName}' with tracking to origin/${branchName}`);
       if (!this.isLfsSkipEnabled()) {
         await this.verifyLfsFilesDownloaded(absoluteWorktreePath, branchName);
       }
@@ -1327,7 +1617,13 @@ var GitService = class {
         throw error;
       }
       if (errorMessage.includes("already registered worktree")) {
-        console.warn(`  - Worktree already registered but missing. Pruning and retrying...`);
+        const worktrees = await this.getWorktreesFromBare(bareGit);
+        const existingWorktree = worktrees.find((w) => path4.resolve(w.path) === absoluteWorktreePath);
+        if (existingWorktree && !existingWorktree.isPrunable) {
+          this.logger.info(`  - Worktree for '${branchName}' was created by concurrent operation`);
+          return;
+        }
+        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 });
@@ -1343,53 +1639,66 @@ var GitService = class {
             absoluteWorktreePath,
             `origin/${branchName}`
           ]);
-          console.log(`  - Created worktree for '${branchName}' after pruning`);
+          this.logger.info(`  - Created worktree for '${branchName}' after pruning`);
           if (!this.isLfsSkipEnabled()) {
             await this.verifyLfsFilesDownloaded(absoluteWorktreePath, branchName);
           }
           await this.createWorktreeMetadata(bareGit, absoluteWorktreePath, branchName);
           return;
         } catch (retryError) {
-          console.error(`  - Failed to create worktree after pruning: ${retryError}`);
+          this.logger.error(`  - Failed to create worktree after pruning: ${retryError}`);
           throw retryError;
         }
       }
-      console.warn(`  - Failed to create worktree with tracking, falling back to simple add: ${error}`);
+      this.logger.warn(`  - Failed to create worktree with tracking, falling back to simple add: ${error}`);
       try {
         await fs4.access(absoluteWorktreePath);
         const worktrees = await this.getWorktreesFromBare(bareGit);
         const isValidWorktree = worktrees.some((w) => path4.resolve(w.path) === absoluteWorktreePath);
         if (isValidWorktree) {
-          console.log(`  - Worktree for '${branchName}' already exists at '${absoluteWorktreePath}'`);
+          this.logger.info(`  - Worktree for '${branchName}' already exists at '${absoluteWorktreePath}'`);
           return;
         } else {
-          console.log(`  - Cleaning up orphaned directory at '${absoluteWorktreePath}' before fallback attempt`);
+          this.logger.info(`  - Cleaning up orphaned directory at '${absoluteWorktreePath}' before fallback attempt`);
           await fs4.rm(absoluteWorktreePath, { recursive: true, force: true });
         }
       } catch {
       }
-      await bareGit.raw(["worktree", "add", absoluteWorktreePath, branchName]);
-      console.log(`  - Created worktree for '${branchName}' (without tracking)`);
-      if (!this.isLfsSkipEnabled()) {
-        await this.verifyLfsFilesDownloaded(absoluteWorktreePath, branchName);
+      try {
+        await bareGit.raw(["worktree", "add", absoluteWorktreePath, branchName]);
+        this.logger.info(`  - Created worktree for '${branchName}' (without tracking)`);
+        if (!this.isLfsSkipEnabled()) {
+          await this.verifyLfsFilesDownloaded(absoluteWorktreePath, branchName);
+        }
+        await this.createWorktreeMetadata(bareGit, absoluteWorktreePath, branchName);
+      } catch (fallbackError) {
+        const fallbackErrorMessage = getErrorMessage(fallbackError);
+        if (fallbackErrorMessage.includes("already registered worktree")) {
+          const worktrees = await this.getWorktreesFromBare(bareGit);
+          const existingWorktree = worktrees.find((w) => path4.resolve(w.path) === absoluteWorktreePath);
+          if (existingWorktree && !existingWorktree.isPrunable) {
+            this.logger.info(`  - Worktree for '${branchName}' was created by concurrent operation during fallback`);
+            return;
+          }
+        }
+        throw fallbackError;
       }
-      await this.createWorktreeMetadata(bareGit, absoluteWorktreePath, branchName);
     }
   }
   async removeWorktree(worktreePath) {
     const bareGit = simpleGit3(this.bareRepoPath);
     await bareGit.raw(["worktree", "remove", worktreePath, "--force"]);
-    console.log(`  - \u2705 Safely removed stale worktree at '${worktreePath}'.`);
+    this.logger.info(`  - \u2705 Safely removed stale worktree at '${worktreePath}'.`);
     try {
       await this.metadataService.deleteMetadataFromPath(this.bareRepoPath, worktreePath);
     } catch (metadataError) {
-      console.warn(`Failed to delete metadata for worktree: ${metadataError}`);
+      this.logger.warn(`Failed to delete metadata for worktree: ${metadataError}`);
     }
   }
   async pruneWorktrees() {
     const bareGit = simpleGit3(this.bareRepoPath);
     await bareGit.raw(["worktree", "prune"]);
-    console.log("Pruned worktree metadata.");
+    this.logger.info("Pruned worktree metadata.");
   }
   async checkWorktreeStatus(worktreePath) {
     const worktreeGit = simpleGit3(worktreePath);
@@ -1428,7 +1737,7 @@ var GitService = class {
       const unpushedCount = parseInt(result.trim(), 10);
       return unpushedCount > 0;
     } catch (error) {
-      console.error(`Error checking unpushed commits: ${error}`);
+      this.logger.error(`Error checking unpushed commits: ${error}`);
       return false;
     }
   }
@@ -1466,7 +1775,7 @@ var GitService = class {
         }
         return false;
       }
-      console.error(
+      this.logger.error(
         `Unexpected error checking upstream status for ${worktreePath}. This might indicate a real issue rather than a missing upstream. Error: ${errorMessage}`
       );
       return false;
@@ -1478,7 +1787,7 @@ var GitService = class {
       const stashList = await worktreeGit.stashList();
       return stashList.total > 0;
     } catch (error) {
-      console.error(`Error checking stash: ${error}`);
+      this.logger.error(`Error checking stash: ${error}`);
       return true;
     }
   }
@@ -1544,7 +1853,7 @@ var GitService = class {
       } catch {
         try {
           const remoteBranches = await bareGit.branch(["-r"]);
-          const commonDefaults = ["main", "master", "develop", "trunk"];
+          const commonDefaults = GIT_CONSTANTS.COMMON_DEFAULT_BRANCHES;
           for (const defaultName of commonDefaults) {
             if (remoteBranches.all.some((branch) => branch === `origin/${defaultName}`)) {
               return defaultName;
@@ -1554,10 +1863,10 @@ var GitService = class {
         }
       }
     }
-    return "main";
+    return GIT_CONSTANTS.DEFAULT_BRANCH;
   }
   isLfsSkipEnabled() {
-    return this.config.skipLfs || process.env.GIT_LFS_SKIP_SMUDGE === "1";
+    return this.config.skipLfs || process.env[ENV_CONSTANTS.GIT_LFS_SKIP_SMUDGE] === "1";
   }
   async getWorktrees() {
     const bareGit = simpleGit3(this.bareRepoPath);
@@ -1579,7 +1888,7 @@ var GitService = class {
     }
   }
   async updateWorktree(worktreePath) {
-    const worktreeGit = this.isLfsSkipEnabled() ? simpleGit3(worktreePath).env({ GIT_LFS_SKIP_SMUDGE: "1" }) : simpleGit3(worktreePath);
+    const worktreeGit = this.isLfsSkipEnabled() ? simpleGit3(worktreePath).env({ [ENV_CONSTANTS.GIT_LFS_SKIP_SMUDGE]: "1" }) : simpleGit3(worktreePath);
     const branchSummary = await worktreeGit.branch();
     const currentBranch = branchSummary.current;
     await worktreeGit.merge([`origin/${currentBranch}`, "--ff-only"]);
@@ -1597,14 +1906,14 @@ var GitService = class {
         this.defaultBranch
       );
     } catch (metadataError) {
-      console.warn(`Failed to update metadata for worktree: ${metadataError}`);
+      this.logger.warn(`Failed to update metadata for worktree: ${metadataError}`);
     }
   }
   async hasDivergedHistory(worktreePath, expectedBranch) {
     const worktreeGit = simpleGit3(worktreePath);
     const branchInfo = await worktreeGit.branch();
     if (branchInfo.current !== expectedBranch) {
-      console.warn(`Branch mismatch in hasDivergedHistory: expected ${expectedBranch}, got ${branchInfo.current}`);
+      this.logger.warn(`Branch mismatch in hasDivergedHistory: expected ${expectedBranch}, got ${branchInfo.current}`);
       return false;
     }
     try {
@@ -1633,12 +1942,12 @@ var GitService = class {
       const remoteTree = await worktreeGit.raw(["rev-parse", `origin/${branch}^{tree}`]);
       return localTree.trim() === remoteTree.trim();
     } catch (error) {
-      console.error(`Error comparing tree content: ${error}`);
+      this.logger.error(`Error comparing tree content: ${error}`);
       return false;
     }
   }
   async resetToUpstream(worktreePath, branch) {
-    const worktreeGit = this.isLfsSkipEnabled() ? simpleGit3(worktreePath).env({ GIT_LFS_SKIP_SMUDGE: "1" }) : simpleGit3(worktreePath);
+    const worktreeGit = this.isLfsSkipEnabled() ? simpleGit3(worktreePath).env({ [ENV_CONSTANTS.GIT_LFS_SKIP_SMUDGE]: "1" }) : simpleGit3(worktreePath);
     await worktreeGit.reset(["--hard", `origin/${branch}`]);
     try {
       const currentCommit = await worktreeGit.revparse(["HEAD"]);
@@ -1650,7 +1959,7 @@ var GitService = class {
         this.defaultBranch
       );
     } catch (metadataError) {
-      console.warn(`Failed to update metadata after reset: ${metadataError}`);
+      this.logger.warn(`Failed to update metadata after reset: ${metadataError}`);
     }
   }
   async getCurrentCommit(worktreePath) {
@@ -1678,17 +1987,27 @@ var GitService = class {
         currentWorktree.branch = line.substring(7).replace("refs/heads/", "");
       } else if (line === "detached") {
         currentWorktree.detached = true;
+      } else if (line === "prunable") {
+        currentWorktree.prunable = true;
       } else if (line.trim() === "") {
         if (currentWorktree.path) {
           if (currentWorktree.branch && !currentWorktree.detached) {
-            worktrees.push({ path: currentWorktree.path, branch: currentWorktree.branch });
+            worktrees.push({
+              path: currentWorktree.path,
+              branch: currentWorktree.branch,
+              isPrunable: currentWorktree.prunable || false
+            });
           }
         }
         currentWorktree = {};
       }
     }
     if (currentWorktree.path && currentWorktree.branch && !currentWorktree.detached) {
-      worktrees.push({ path: currentWorktree.path, branch: currentWorktree.branch });
+      worktrees.push({
+        path: currentWorktree.path,
+        branch: currentWorktree.branch,
+        isPrunable: currentWorktree.prunable || false
+      });
     }
     return worktrees;
   }
@@ -1698,9 +2017,11 @@ var GitService = class {
 var WorktreeSyncService = class {
   constructor(config) {
     this.config = config;
-    this.gitService = new GitService(config);
+    this.logger = config.logger ?? Logger.createDefault(void 0, config.debug);
+    this.gitService = new GitService(config, this.logger);
   }
   gitService;
+  logger;
   syncInProgress = false;
   async initialize() {
     await this.gitService.initialize();
@@ -1710,11 +2031,13 @@ var WorktreeSyncService = class {
   }
   async sync() {
     if (this.syncInProgress) {
-      console.warn("\u26A0\uFE0F  Sync already in progress, skipping...");
+      this.logger.warn("\u26A0\uFE0F  Sync already in progress, skipping...");
       return;
     }
     this.syncInProgress = true;
-    console.log(`[${(/* @__PURE__ */ new Date()).toISOString()}] Starting worktree synchronization...`);
+    this.logger.info(`[${(/* @__PURE__ */ new Date()).toISOString()}] Starting worktree synchronization...`);
+    const totalTimer = new Timer();
+    const phaseTimer = new PhaseTimer();
     let lfsSkipEnabled = false;
     const retryOptions = {
       maxAttempts: this.config.retry?.maxAttempts ?? 3,
@@ -1724,18 +2047,18 @@ var WorktreeSyncService = class {
       backoffMultiplier: this.config.retry?.backoffMultiplier ?? 2,
       onRetry: (error, attempt, context) => {
         const errorMessage = getErrorMessage(error);
-        console.log(`
+        this.logger.info(`
 \u26A0\uFE0F  Sync attempt ${attempt} failed: ${errorMessage}`);
         if (context?.isLfsError && !this.config.skipLfs) {
-          console.log(`\u{1F504} LFS error detected. Will retry with LFS skipped...`);
+          this.logger.info(`\u{1F504} LFS error detected. Will retry with LFS skipped...`);
         } else {
-          console.log(`\u{1F504} Retrying synchronization...
+          this.logger.info(`\u{1F504} Retrying synchronization...
 `);
         }
       },
       lfsRetryHandler: () => {
         if (!this.config.skipLfs && !lfsSkipEnabled) {
-          console.log("\u26A0\uFE0F  Temporarily disabling LFS downloads for this sync...");
+          this.logger.info("\u26A0\uFE0F  Temporarily disabling LFS downloads for this sync...");
           process.env.GIT_LFS_SKIP_SMUDGE = "1";
           lfsSkipEnabled = true;
         }
@@ -1744,14 +2067,15 @@ var WorktreeSyncService = class {
     try {
       await retry(async () => {
         await this.gitService.pruneWorktrees();
-        console.log("Step 1: Fetching latest data from remote...");
+        this.logger.info("Step 1: Fetching latest data from remote...");
+        phaseTimer.startPhase("Phase 1: Fetch");
         try {
           await this.gitService.fetchAll();
         } catch (fetchError) {
           const errorMessage = getErrorMessage(fetchError);
           if (isLfsError(errorMessage) && !lfsSkipEnabled && !this.config.skipLfs) {
-            console.log("\u26A0\uFE0F  Fetch all failed due to LFS error. Attempting branch-by-branch fetch...");
-            console.log("\u26A0\uFE0F  Temporarily disabling LFS downloads for branch-by-branch fetch...");
+            this.logger.info("\u26A0\uFE0F  Fetch all failed due to LFS error. Attempting branch-by-branch fetch...");
+            this.logger.info("\u26A0\uFE0F  Temporarily disabling LFS downloads for branch-by-branch fetch...");
             process.env.GIT_LFS_SKIP_SMUDGE = "1";
             lfsSkipEnabled = true;
             await this.fetchBranchByBranch();
@@ -1759,143 +2083,221 @@ var WorktreeSyncService = class {
             throw fetchError;
           }
         }
+        phaseTimer.endPhase();
         let remoteBranches;
         if (this.config.branchMaxAge) {
           const branchesWithActivity = await this.gitService.getRemoteBranchesWithActivity();
           const filteredBranches = filterBranchesByAge(branchesWithActivity, this.config.branchMaxAge);
           remoteBranches = filteredBranches.map((b) => b.branch);
-          console.log(`Found ${branchesWithActivity.length} remote branches.`);
-          console.log(
+          this.logger.info(`Found ${branchesWithActivity.length} remote branches.`);
+          this.logger.info(
             `After filtering by age (${formatDuration(this.config.branchMaxAge)}): ${remoteBranches.length} branches.`
           );
           if (branchesWithActivity.length > remoteBranches.length) {
             const excludedCount = branchesWithActivity.length - remoteBranches.length;
-            console.log(`  - Excluded ${excludedCount} stale branches.`);
+            this.logger.info(`  - Excluded ${excludedCount} stale branches.`);
           }
         } else {
           remoteBranches = await this.gitService.getRemoteBranches();
-          console.log(`Found ${remoteBranches.length} remote branches.`);
+          this.logger.info(`Found ${remoteBranches.length} remote branches.`);
         }
         const defaultBranch = this.gitService.getDefaultBranch();
         if (!remoteBranches.includes(defaultBranch)) {
           remoteBranches.push(defaultBranch);
-          console.log(`Ensuring default branch '${defaultBranch}' is retained.`);
+          this.logger.info(`Ensuring default branch '${defaultBranch}' is retained.`);
         }
         await fs5.mkdir(this.config.worktreeDir, { recursive: true });
         const worktrees = await this.gitService.getWorktrees();
         const worktreeBranches = worktrees.map((w) => w.branch);
-        console.log(`Found ${worktrees.length} existing Git worktrees.`);
+        this.logger.info(`Found ${worktrees.length} existing Git worktrees.`);
         await this.cleanupOrphanedDirectories(worktrees);
-        await this.createNewWorktrees(remoteBranches, worktreeBranches, defaultBranch);
-        await this.pruneOldWorktrees(remoteBranches, worktreeBranches);
+        await this.createNewWorktreesWithTiming(remoteBranches, worktreeBranches, defaultBranch, phaseTimer);
+        await this.pruneOldWorktreesWithTiming(remoteBranches, worktreeBranches, phaseTimer);
         if (this.config.updateExistingWorktrees !== false) {
-          await this.updateExistingWorktrees(worktrees, remoteBranches);
+          await this.updateExistingWorktreesWithTiming(worktrees, remoteBranches, phaseTimer);
         }
+        phaseTimer.startPhase("Phase 5: Cleanup");
         await this.gitService.pruneWorktrees();
-        console.log("Step 5: Pruned worktree metadata.");
+        this.logger.info("Step 5: Pruned worktree metadata.");
+        phaseTimer.endPhase();
       }, retryOptions);
     } catch (error) {
-      console.error("\n\u274C Error during worktree synchronization after all retry attempts:", error);
+      this.logger.error("\n\u274C Error during worktree synchronization after all retry attempts:", error);
       throw error;
     } finally {
       if (lfsSkipEnabled && !this.config.skipLfs) {
         delete process.env.GIT_LFS_SKIP_SMUDGE;
       }
       this.syncInProgress = false;
-      console.log(`[${(/* @__PURE__ */ new Date()).toISOString()}] Synchronization finished.
+      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));
+      }
     }
   }
+  async createNewWorktreesWithTiming(remoteBranches, existingWorktreeBranches, defaultBranch, phaseTimer) {
+    const maxConcurrent = this.config.parallelism?.maxWorktreeCreation ?? DEFAULT_CONFIG.PARALLELISM.MAX_WORKTREE_CREATION;
+    phaseTimer.startPhase("Phase 2: Create", maxConcurrent);
+    await this.createNewWorktrees(remoteBranches, existingWorktreeBranches, defaultBranch);
+    const newBranches = remoteBranches.filter((b) => !existingWorktreeBranches.includes(b)).filter((b) => b !== defaultBranch);
+    phaseTimer.setPhaseCount("Phase 2: Create", newBranches.length);
+    phaseTimer.endPhase();
+  }
   async createNewWorktrees(remoteBranches, existingWorktreeBranches, defaultBranch) {
     const newBranches = remoteBranches.filter((b) => !existingWorktreeBranches.includes(b)).filter((b) => b !== defaultBranch);
     if (newBranches.length > 0) {
-      console.log(`Step 2: Creating new worktrees for: ${newBranches.join(", ")}`);
-      for (const branchName of newBranches) {
-        const worktreePath = path5.join(this.config.worktreeDir, branchName);
-        await this.gitService.addWorktree(branchName, worktreePath);
-      }
+      this.logger.info(`Step 2: Creating ${newBranches.length} new worktrees...`);
+      const maxConcurrent = this.config.parallelism?.maxWorktreeCreation ?? DEFAULT_CONFIG.PARALLELISM.MAX_WORKTREE_CREATION;
+      const limit = pLimit(maxConcurrent);
+      const results = await Promise.allSettled(
+        newBranches.map(
+          (branchName) => limit(async () => {
+            const worktreePath = path5.join(this.config.worktreeDir, branchName);
+            try {
+              await this.gitService.addWorktree(branchName, worktreePath);
+              this.logger.info(`  \u2705 Created worktree for '${branchName}'`);
+            } catch (error) {
+              this.logger.error(`  \u274C Failed to create worktree for '${branchName}':`, getErrorMessage(error));
+              throw error;
+            }
+          })
+        )
+      );
+      const successCount = results.filter((r) => r.status === "fulfilled").length;
+      this.logger.info(`  Created ${successCount}/${newBranches.length} worktrees successfully`);
     } else {
-      console.log("Step 2: No new branches to create worktrees for.");
+      this.logger.info("Step 2: No new branches to create worktrees for.");
     }
   }
+  async pruneOldWorktreesWithTiming(remoteBranches, existingWorktreeBranches, phaseTimer) {
+    const maxConcurrent = this.config.parallelism?.maxStatusChecks ?? DEFAULT_CONFIG.PARALLELISM.MAX_STATUS_CHECKS;
+    phaseTimer.startPhase("Phase 3: Prune", maxConcurrent);
+    await this.pruneOldWorktrees(remoteBranches, existingWorktreeBranches);
+    const deletedBranches = existingWorktreeBranches.filter((branch) => !remoteBranches.includes(branch));
+    phaseTimer.setPhaseCount("Phase 3: Prune", deletedBranches.length);
+    phaseTimer.endPhase();
+  }
   async pruneOldWorktrees(remoteBranches, existingWorktreeBranches) {
     const deletedBranches = existingWorktreeBranches.filter((branch) => !remoteBranches.includes(branch));
     if (deletedBranches.length > 0) {
-      console.log(`Step 3: Checking for stale worktrees to prune: ${deletedBranches.join(", ")}`);
-      for (const branchName of deletedBranches) {
-        const worktreePath = path5.join(this.config.worktreeDir, branchName);
-        try {
-          const status = await this.gitService.getFullWorktreeStatus(worktreePath, this.config.debug);
+      this.logger.info(`Step 3: Checking ${deletedBranches.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(
+        deletedBranches.map(
+          (branchName) => limit(async () => {
+            const worktreePath = path5.join(this.config.worktreeDir, branchName);
+            const status = await this.gitService.getFullWorktreeStatus(worktreePath, this.config.debug);
+            return { branchName, worktreePath, status };
+          })
+        )
+      );
+      const toRemove = [];
+      const toSkip = [];
+      for (const result of statusResults) {
+        if (result.status === "fulfilled") {
+          const { branchName, worktreePath, status } = result.value;
           if (status.canRemove) {
-            await this.gitService.removeWorktree(worktreePath);
+            toRemove.push({ branchName, worktreePath });
           } else {
-            if (status.upstreamGone && status.hasUnpushedCommits) {
-              console.warn(`  - \u26A0\uFE0F Cannot automatically remove '${branchName}' - upstream branch was deleted.`);
-              console.log(`     Please review manually: cd ${worktreePath} && git log`);
-              console.log(
-                `     If changes were squash-merged, you can safely remove with: git worktree remove ${worktreePath}`
-              );
-            } else {
-              console.log(`  - \u26A0\uFE0F Skipping removal of '${branchName}' due to: ${status.reasons.join(", ")}.`);
-            }
-            if (this.config.debug && status.details) {
-              this.logDebugDetails(branchName, status.details);
-            }
+            toSkip.push({ branchName, status });
           }
-        } catch (error) {
-          console.error(`  - Error checking worktree '${branchName}':`, error);
+        } else {
+          this.logger.error(`  - Error checking worktree:`, result.reason);
+        }
+      }
+      if (toRemove.length > 0) {
+        const removeLimit = pLimit(
+          this.config.parallelism?.maxWorktreeRemoval ?? DEFAULT_CONFIG.PARALLELISM.MAX_WORKTREE_REMOVAL
+        );
+        const removeResults = await Promise.allSettled(
+          toRemove.map(
+            ({ branchName, worktreePath }) => removeLimit(async () => {
+              try {
+                await this.gitService.removeWorktree(worktreePath);
+                this.logger.info(`  \u2705 Removed worktree for '${branchName}'`);
+              } catch (error) {
+                this.logger.error(`  \u274C Failed to remove worktree for '${branchName}':`, getErrorMessage(error));
+                throw error;
+              }
+            })
+          )
+        );
+        const removedCount = removeResults.filter((r) => r.status === "fulfilled").length;
+        this.logger.info(`  Removed ${removedCount}/${toRemove.length} worktrees successfully`);
+      }
+      if (toSkip.length > 0) {
+        this.logger.info(`  Skipped ${toSkip.length} worktree(s) with local changes or unpushed commits`);
+      }
+      for (const { branchName, status } of toSkip) {
+        if (status.upstreamGone && status.hasUnpushedCommits) {
+          const worktreePath = path5.join(this.config.worktreeDir, branchName);
+          this.logger.warn(`  - \u26A0\uFE0F Cannot automatically remove '${branchName}' - upstream branch was deleted.`);
+          this.logger.info(`     Please review manually: cd ${worktreePath} && git log`);
+          this.logger.info(
+            `     If changes were squash-merged, you can safely remove with: git worktree remove ${worktreePath}`
+          );
+        } else {
+          this.logger.info(`  - \u26A0\uFE0F Skipping removal of '${branchName}' due to: ${status.reasons.join(", ")}.`);
+        }
+        if (this.config.debug && status.details) {
+          this.logDebugDetails(branchName, status.details);
         }
       }
     } else {
-      console.log("Step 3: No stale worktrees to prune.");
+      this.logger.info("Step 3: No stale worktrees to prune.");
     }
   }
   logDebugDetails(branchName, details) {
-    console.log(`
+    this.logger.info(`
      \u{1F50D} Debug details for '${branchName}':`);
     if (details.modifiedFiles > 0 && details.modifiedFilesList) {
-      console.log(`        - Modified files (${details.modifiedFiles}):`);
-      details.modifiedFilesList.forEach((file) => console.log(`          \u2022 ${file}`));
+      this.logger.info(`        - Modified files (${details.modifiedFiles}):`);
+      details.modifiedFilesList.forEach((file) => this.logger.info(`          \u2022 ${file}`));
     }
     if (details.deletedFiles > 0 && details.deletedFilesList) {
-      console.log(`        - Deleted files (${details.deletedFiles}):`);
-      details.deletedFilesList.forEach((file) => console.log(`          \u2022 ${file}`));
+      this.logger.info(`        - Deleted files (${details.deletedFiles}):`);
+      details.deletedFilesList.forEach((file) => this.logger.info(`          \u2022 ${file}`));
     }
     if (details.renamedFiles > 0 && details.renamedFilesList) {
-      console.log(`        - Renamed files (${details.renamedFiles}):`);
-      details.renamedFilesList.forEach((file) => console.log(`          \u2022 ${file.from} \u2192 ${file.to}`));
+      this.logger.info(`        - Renamed files (${details.renamedFiles}):`);
+      details.renamedFilesList.forEach((file) => this.logger.info(`          \u2022 ${file.from} \u2192 ${file.to}`));
     }
     if (details.createdFiles > 0 && details.createdFilesList) {
-      console.log(`        - Created files (${details.createdFiles}):`);
-      details.createdFilesList.forEach((file) => console.log(`          \u2022 ${file}`));
+      this.logger.info(`        - Created files (${details.createdFiles}):`);
+      details.createdFilesList.forEach((file) => this.logger.info(`          \u2022 ${file}`));
     }
     if (details.conflictedFiles > 0 && details.conflictedFilesList) {
-      console.log(`        - Conflicted files (${details.conflictedFiles}):`);
-      details.conflictedFilesList.forEach((file) => console.log(`          \u2022 ${file}`));
+      this.logger.info(`        - Conflicted files (${details.conflictedFiles}):`);
+      details.conflictedFilesList.forEach((file) => this.logger.info(`          \u2022 ${file}`));
     }
     if (details.untrackedFiles > 0 && details.untrackedFilesList) {
-      console.log(`        - Untracked files (not ignored) (${details.untrackedFiles}):`);
-      details.untrackedFilesList.forEach((file) => console.log(`          \u2022 ${file}`));
+      this.logger.info(`        - Untracked files (not ignored) (${details.untrackedFiles}):`);
+      details.untrackedFilesList.forEach((file) => this.logger.info(`          \u2022 ${file}`));
     }
     if (details.unpushedCommitCount !== void 0 && details.unpushedCommitCount > 0) {
-      console.log(`        - Unpushed commits: ${details.unpushedCommitCount}`);
+      this.logger.info(`        - Unpushed commits: ${details.unpushedCommitCount}`);
     }
     if (details.stashCount !== void 0 && details.stashCount > 0) {
-      console.log(`        - Stashed changes: ${details.stashCount}`);
+      this.logger.info(`        - Stashed changes: ${details.stashCount}`);
     }
     if (details.operationType) {
-      console.log(`        - Operation in progress: ${details.operationType}`);
+      this.logger.info(`        - Operation in progress: ${details.operationType}`);
     }
     if (details.modifiedSubmodules && details.modifiedSubmodules.length > 0) {
-      console.log(`        - Modified submodules (${details.modifiedSubmodules.length}):`);
-      details.modifiedSubmodules.forEach((submodule) => console.log(`          \u2022 ${submodule}`));
+      this.logger.info(`        - Modified submodules (${details.modifiedSubmodules.length}):`);
+      details.modifiedSubmodules.forEach((submodule) => this.logger.info(`          \u2022 ${submodule}`));
     }
-    console.log("");
+    this.logger.info("");
   }
   async fetchBranchByBranch() {
-    console.log("Fetching branches individually to isolate LFS errors...");
+    this.logger.info("Fetching branches individually to isolate LFS errors...");
     const remoteBranches = await this.gitService.getRemoteBranches();
-    console.log(`Found ${remoteBranches.length} remote branches to fetch.`);
+    this.logger.info(`Found ${remoteBranches.length} remote branches to fetch.`);
     const failedBranches = [];
     let successCount = 0;
     for (const branch of remoteBranches) {
@@ -1904,79 +2306,104 @@ var WorktreeSyncService = class {
         successCount++;
       } catch (error) {
         const errorMessage = getErrorMessage(error);
-        console.log(`  \u26A0\uFE0F  Failed to fetch branch '${branch}': ${errorMessage}`);
+        this.logger.info(`  \u26A0\uFE0F  Failed to fetch branch '${branch}': ${errorMessage}`);
         failedBranches.push(branch);
       }
     }
-    console.log(`Branch-by-branch fetch completed: ${successCount}/${remoteBranches.length} successful`);
+    this.logger.info(`Branch-by-branch fetch completed: ${successCount}/${remoteBranches.length} successful`);
     if (failedBranches.length > 0) {
-      console.log(`\u26A0\uFE0F  Failed to fetch ${failedBranches.length} branches due to errors.`);
-      console.log(`   These branches will be skipped: ${failedBranches.join(", ")}`);
+      this.logger.info(`\u26A0\uFE0F  Failed to fetch ${failedBranches.length} branches due to errors.`);
+      this.logger.info(`   These branches will be skipped: ${failedBranches.join(", ")}`);
     }
   }
+  async updateExistingWorktreesWithTiming(worktrees, remoteBranches, phaseTimer) {
+    const maxConcurrent = this.config.parallelism?.maxWorktreeUpdates ?? DEFAULT_CONFIG.PARALLELISM.MAX_WORKTREE_UPDATES;
+    phaseTimer.startPhase("Phase 4: Update", maxConcurrent);
+    await this.updateExistingWorktrees(worktrees, remoteBranches);
+    const activeWorktrees = worktrees.filter((w) => remoteBranches.includes(w.branch));
+    phaseTimer.setPhaseCount("Phase 4: Update", activeWorktrees.length);
+    phaseTimer.endPhase();
+  }
   async updateExistingWorktrees(worktrees, remoteBranches) {
-    const worktreesToUpdate = [];
-    console.log("Step 4: Checking for worktrees that need updates...");
-    const divergedDir = path5.join(this.config.worktreeDir, ".diverged");
+    this.logger.info("Step 4: Checking for worktrees that need updates...");
+    const divergedDir = path5.join(this.config.worktreeDir, GIT_CONSTANTS.DIVERGED_DIR_NAME);
     try {
       const diverged = await fs5.readdir(divergedDir);
       if (diverged.length > 0) {
-        console.log(`\u{1F4E6} Note: ${diverged.length} diverged worktree(s) in ${path5.relative(process.cwd(), divergedDir)}`);
+        this.logger.info(
+          `\u{1F4E6} Note: ${diverged.length} diverged worktree(s) in ${path5.relative(process.cwd(), divergedDir)}`
+        );
       }
     } catch {
     }
     const activeWorktrees = worktrees.filter((w) => remoteBranches.includes(w.branch));
-    for (const worktree of activeWorktrees) {
-      try {
-        try {
-          await fs5.access(worktree.path);
-        } catch {
-          continue;
-        }
-        const hasOp = await this.gitService.hasOperationInProgress(worktree.path);
-        if (hasOp) {
-          continue;
-        }
-        const isClean = await this.gitService.checkWorktreeStatus(worktree.path);
-        if (!isClean) {
-          continue;
-        }
-        const canFastForward = await this.gitService.canFastForward(worktree.path, worktree.branch);
-        if (!canFastForward) {
-          await this.handleDivergedBranch(worktree);
-          continue;
-        }
-        const isBehind = await this.gitService.isWorktreeBehind(worktree.path);
-        if (isBehind) {
-          worktreesToUpdate.push(worktree);
-        }
-      } catch (error) {
-        console.error(`  - Error checking worktree '${worktree.branch}':`, error);
+    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 () => {
+          try {
+            await fs5.access(worktree.path);
+          } catch {
+            return null;
+          }
+          const hasOp = await this.gitService.hasOperationInProgress(worktree.path);
+          if (hasOp) return null;
+          const isClean = await this.gitService.checkWorktreeStatus(worktree.path);
+          if (!isClean) return null;
+          const canFastForward = await this.gitService.canFastForward(worktree.path, worktree.branch);
+          if (!canFastForward) {
+            await this.handleDivergedBranch(worktree);
+            return null;
+          }
+          const isBehind = await this.gitService.isWorktreeBehind(worktree.path);
+          return isBehind ? worktree : null;
+        })
+      )
+    );
+    const worktreesToUpdate = [];
+    for (const result of checkResults) {
+      if (result.status === "fulfilled" && result.value) {
+        worktreesToUpdate.push(result.value);
+      } else if (result.status === "rejected") {
+        this.logger.error(`  - Error checking worktree:`, result.reason);
       }
     }
     if (worktreesToUpdate.length > 0) {
-      console.log(`  - Found ${worktreesToUpdate.length} worktrees behind their upstream branches.`);
-      for (const worktree of worktreesToUpdate) {
-        try {
-          console.log(`  - Updating worktree '${worktree.branch}'...`);
-          await this.gitService.updateWorktree(worktree.path);
-          console.log(`    \u2705 Successfully updated '${worktree.branch}'.`);
-        } catch (error) {
-          const errorMessage = getErrorMessage(error);
-          if (errorMessage.includes("Not possible to fast-forward") || errorMessage.includes("fatal: Not possible to fast-forward, aborting") || errorMessage.includes("cannot fast-forward")) {
-            console.log(`    \u26A0\uFE0F Branch '${worktree.branch}' cannot be fast-forwarded. Checking for divergence...`);
+      this.logger.info(`  - Found ${worktreesToUpdate.length} worktrees behind their upstream branches.`);
+      const updateLimit = pLimit(
+        this.config.parallelism?.maxWorktreeUpdates ?? DEFAULT_CONFIG.PARALLELISM.MAX_WORKTREE_UPDATES
+      );
+      const updateResults = await Promise.allSettled(
+        worktreesToUpdate.map(
+          (worktree) => updateLimit(async () => {
             try {
-              await this.handleDivergedBranch(worktree);
-            } catch (divergedError) {
-              console.error(`    \u274C Failed to handle diverged branch '${worktree.branch}':`, divergedError);
+              this.logger.info(`  - Updating worktree '${worktree.branch}'...`);
+              await this.gitService.updateWorktree(worktree.path);
+              this.logger.info(`    \u2705 Successfully updated '${worktree.branch}'.`);
+            } catch (error) {
+              const errorMessage = getErrorMessage(error);
+              if (ERROR_MESSAGES.FAST_FORWARD_FAILED.some((msg) => errorMessage.includes(msg))) {
+                this.logger.info(
+                  `    \u26A0\uFE0F Branch '${worktree.branch}' cannot be fast-forwarded. Checking for divergence...`
+                );
+                try {
+                  await this.handleDivergedBranch(worktree);
+                } catch (divergedError) {
+                  this.logger.error(`    \u274C Failed to handle diverged branch '${worktree.branch}':`, divergedError);
+                }
+              } else {
+                this.logger.error(`    \u274C Failed to update '${worktree.branch}':`, error);
+              }
+              throw error;
             }
-          } else {
-            console.error(`    \u274C Failed to update '${worktree.branch}':`, error);
-          }
-        }
-      }
+          })
+        )
+      );
+      const successCount = updateResults.filter((r) => r.status === "fulfilled").length;
+      this.logger.info(`  Updated ${successCount}/${worktreesToUpdate.length} worktrees successfully`);
     } else {
-      console.log("  - All worktrees are up to date.");
+      this.logger.info("  - All worktrees are up to date.");
     }
   }
   async cleanupOrphanedDirectories(worktrees) {
@@ -1994,50 +2421,50 @@ var WorktreeSyncService = class {
         }
       }
       if (orphanedDirs.length > 0) {
-        console.log(`Found ${orphanedDirs.length} orphaned directories: ${orphanedDirs.join(", ")}`);
+        this.logger.info(`Found ${orphanedDirs.length} orphaned directories: ${orphanedDirs.join(", ")}`);
         for (const dir of orphanedDirs) {
           const dirPath = path5.join(this.config.worktreeDir, dir);
           try {
             const stat4 = await fs5.stat(dirPath);
             if (stat4.isDirectory()) {
               await fs5.rm(dirPath, { recursive: true, force: true });
-              console.log(`  - Removed orphaned directory: ${dir}`);
+              this.logger.info(`  - Removed orphaned directory: ${dir}`);
             }
           } catch (error) {
-            console.error(`  - Failed to remove orphaned directory ${dir}:`, error);
+            this.logger.error(`  - Failed to remove orphaned directory ${dir}:`, error);
           }
         }
       }
     } catch (error) {
-      console.error("Error during orphaned directory cleanup:", error);
+      this.logger.error("Error during orphaned directory cleanup:", error);
     }
   }
   async handleDivergedBranch(worktree) {
-    console.log(`\u26A0\uFE0F  Branch '${worktree.branch}' has diverged from upstream. Analyzing...`);
+    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) {
-      console.log(`\u2705 Branch '${worktree.branch}' was rebased but files are identical. Resetting to upstream...`);
+      this.logger.info(`\u2705 Branch '${worktree.branch}' was rebased but files are identical. Resetting to upstream...`);
       await this.gitService.resetToUpstream(worktree.path, worktree.branch);
-      console.log(`   Successfully updated '${worktree.branch}' to match upstream.`);
+      this.logger.info(`   Successfully updated '${worktree.branch}' to match upstream.`);
     } else {
       const hasLocalChanges = await this.hasLocalChangesSinceLastSync(worktree.path);
       if (!hasLocalChanges) {
-        console.log(
+        this.logger.info(
           `\u2705 Branch '${worktree.branch}' has diverged but you made no local changes. Resetting to upstream...`
         );
         await this.gitService.resetToUpstream(worktree.path, worktree.branch);
-        console.log(`   Successfully updated '${worktree.branch}' to match upstream.`);
+        this.logger.info(`   Successfully updated '${worktree.branch}' to match upstream.`);
       } else {
-        console.log(`\u{1F512} Branch '${worktree.branch}' has diverged with local changes. Moving to diverged...`);
+        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 = path5.relative(process.cwd(), divergedPath);
-        console.log(`   Moved to: ${relativePath}`);
-        console.log(`   Your local changes are preserved. To review:`);
-        console.log(`     cd ${relativePath}`);
-        console.log(`     git diff origin/${worktree.branch}`);
+        this.logger.info(`   Moved to: ${relativePath}`);
+        this.logger.info(`   Your local changes are preserved. To review:`);
+        this.logger.info(`     cd ${relativePath}`);
+        this.logger.info(`     git diff origin/${worktree.branch}`);
         await this.gitService.removeWorktree(worktree.path);
         await this.gitService.addWorktree(worktree.branch, worktree.path);
-        console.log(`   Created fresh worktree from upstream at: ${worktree.path}`);
+        this.logger.info(`   Created fresh worktree from upstream at: ${worktree.path}`);
       }
     }
   }
@@ -2054,9 +2481,9 @@ var WorktreeSyncService = class {
     }
   }
   async divergeWorktree(worktreePath, branchName) {
-    const divergedBaseDir = path5.join(this.config.worktreeDir, ".diverged");
+    const divergedBaseDir = path5.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).substr(2, 5);
+    const uniqueSuffix = Date.now().toString(36) + Math.random().toString(36).substring(2, 7);
     const safeBranchName = branchName.replace(/\//g, "-");
     const divergedName = `${timestamp}-${safeBranchName}-${uniqueSuffix}`;
     const divergedPath = path5.join(divergedBaseDir, divergedName);
@@ -2075,7 +2502,7 @@ var WorktreeSyncService = class {
     const metadata = {
       originalBranch: branchName,
       divergedAt: (/* @__PURE__ */ new Date()).toISOString(),
-      reason: "diverged-history-with-changes",
+      reason: METADATA_CONSTANTS.DIVERGED_REASON,
       originalPath: worktreePath,
       localCommit: await this.gitService.getCurrentCommit(divergedPath),
       remoteCommit: await this.gitService.getRemoteCommit(`origin/${branchName}`),
@@ -2086,7 +2513,10 @@ var WorktreeSyncService = class {
 
   Original worktree location: ${worktreePath}`
     };
-    await fs5.writeFile(path5.join(divergedPath, ".diverged-info.json"), JSON.stringify(metadata, null, 2));
+    await fs5.writeFile(
+      path5.join(divergedPath, METADATA_CONSTANTS.DIVERGED_INFO_FILE),
+      JSON.stringify(metadata, null, 2)
+    );
     return divergedPath;
   }
 };
@@ -2685,14 +3115,18 @@ async function promptForConfig(partialConfig) {
 
 // src/index.ts
 async function runSingleRepository(config) {
-  console.log("\n\u{1F4CB} CLI Command (for future reference):");
-  console.log(`   ${reconstructCliCommand(config)}`);
-  console.log("");
+  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) {
-      console.log("Running the sync process once as requested by --runOnce flag.");
+      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);
@@ -2706,37 +3140,66 @@ async function runSingleRepository(config) {
           uiService.updateLastSyncTime();
           void uiService.calculateAndUpdateDiskSpace();
         } catch (error) {
-          console.error(`Error during scheduled sync: ${error.message}`);
+          logger.error(`Error during scheduled sync: ${error.message}`, error);
           uiService.setStatus("idle");
         }
       });
     }
   } catch (error) {
-    console.error("\u274C Fatal Error during initialization:", error.message);
+    logger.error("\u274C Fatal Error during initialization:", error);
     process.exit(1);
   }
 }
-async function runMultipleRepositories(repositories, runOnce, configPath) {
+async function runMultipleRepositories(repositories, runOnce, configPath, maxParallel) {
   const services = /* @__PURE__ */ new Map();
-  console.log(`
+  const globalLogger = Logger.createDefault();
+  globalLogger.info(`
 \u{1F504} Syncing ${repositories.length} repositories...`);
-  for (const repoConfig of repositories) {
-    console.log(`
+  const limit = pLimit2(maxParallel ?? DEFAULT_CONFIG.PARALLELISM.MAX_REPOSITORIES);
+  const initResults = await Promise.allSettled(
+    repositories.map(
+      (repoConfig) => limit(async () => {
+        const repoLogger = Logger.createDefault(repoConfig.name, repoConfig.debug);
+        repoLogger.info(`
 \u{1F4E6} Repository: ${repoConfig.name}`);
-    console.log(`   URL: ${repoConfig.repoUrl}`);
-    console.log(`   Worktrees: ${repoConfig.worktreeDir}`);
-    if (repoConfig.bareRepoDir) {
-      console.log(`   Bare repo: ${repoConfig.bareRepoDir}`);
-    }
-    const syncService = new WorktreeSyncService(repoConfig);
-    services.set(repoConfig.name, syncService);
-    try {
-      await syncService.initialize();
-      await syncService.sync();
-    } catch (error) {
-      console.error(`\u274C Error syncing repository '${repoConfig.name}':`, error.message);
+        repoLogger.info(`   URL: ${repoConfig.repoUrl}`);
+        repoLogger.info(`   Worktrees: ${repoConfig.worktreeDir}`);
+        if (repoConfig.bareRepoDir) {
+          repoLogger.info(`   Bare repo: ${repoConfig.bareRepoDir}`);
+        }
+        if (!repoConfig.logger) {
+          repoConfig.logger = repoLogger;
+        }
+        const syncService = new WorktreeSyncService(repoConfig);
+        await syncService.initialize();
+        return { name: repoConfig.name, service: syncService };
+      })
+    )
+  );
+  const servicesToSync = [];
+  for (const result of initResults) {
+    if (result.status === "fulfilled") {
+      services.set(result.value.name, result.value.service);
+      servicesToSync.push(result.value);
+    } else {
+      globalLogger.error(`\u274C Failed to initialize repository:`, result.reason);
     }
   }
+  const syncResults = await Promise.allSettled(
+    servicesToSync.map(
+      ({ name, service }) => limit(async () => {
+        try {
+          await service.sync();
+        } catch (error) {
+          globalLogger.error(`\u274C Error syncing repository '${name}':`, error);
+          throw error;
+        }
+      })
+    )
+  );
+  const successCount = syncResults.filter((r) => r.status === "fulfilled").length;
+  globalLogger.info(`
+\u2705 Successfully synced ${successCount}/${servicesToSync.length} repositories`);
   if (!runOnce) {
     const uniqueSchedules = [...new Set(repositories.map((r) => r.cronSchedule))];
     const displaySchedule = uniqueSchedules.length === 1 ? uniqueSchedules[0] : void 0;
@@ -2753,25 +3216,29 @@ async function runMultipleRepositories(repositories, runOnce, configPath) {
         cron2.schedule(repoConfig.cronSchedule, async () => {
           const reposToSync = repositories.filter((r) => r.cronSchedule === repoConfig.cronSchedule);
           uiService.setStatus("syncing");
-          for (const repo of reposToSync) {
-            const service = services.get(repo.name);
-            if (!service) continue;
-            console.log(`Running scheduled sync for: ${repo.name}`);
-            try {
-              await service.sync();
-            } catch (error) {
-              console.error(`Error syncing '${repo.name}': ${error.message}`);
-            }
-          }
+          await Promise.allSettled(
+            reposToSync.map(
+              (repo) => limit(async () => {
+                const service = services.get(repo.name);
+                if (!service) return;
+                globalLogger.info(`Running scheduled sync for: ${repo.name}`);
+                try {
+                  await service.sync();
+                } catch (error) {
+                  globalLogger.error(`Error syncing '${repo.name}':`, error);
+                }
+              })
+            )
+          );
           uiService.updateLastSyncTime();
           void uiService.calculateAndUpdateDiskSpace();
         });
       }
     }
-    console.log(`All ${repositories.length} repositories scheduled`);
+    globalLogger.info(`All ${repositories.length} repositories scheduled`);
     for (const [schedule3] of cronJobs) {
       const repoCount = repositories.filter((r) => r.cronSchedule === schedule3).length;
-      console.log(`${schedule3}: ${repoCount} repository(ies)`);
+      globalLogger.info(`${schedule3}: ${repoCount} repository(ies)`);
     }
   }
 }
@@ -2844,7 +3311,8 @@ async function main() {
           debug: true
         }));
       }
-      await runMultipleRepositories(repositories, globalRunOnce, options.config);
+      const maxParallel = configFile.parallelism?.maxRepositories ?? configFile.defaults?.parallelism?.maxRepositories ?? DEFAULT_CONFIG.PARALLELISM.MAX_REPOSITORIES;
+      await runMultipleRepositories(repositories, globalRunOnce, options.config, maxParallel);
     } catch (error) {
       if (error instanceof Error && error.message.includes("Config file not found")) {
         console.error(`