sync-worktrees 2.0.0 → 2.2.0

package/dist/index.js

@@ -1,9 +1,99 @@
 #!/usr/bin/env node
 
 // src/index.ts
-import * as path8 from "path";
+import * as path10 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";
@@ -73,6 +163,9 @@ var ConfigLoaderService = class {
       if (repoObj.runOnce !== void 0 && typeof repoObj.runOnce !== "boolean") {
         throw new Error(`Repository '${repoObj.name}' has invalid 'runOnce' property`);
       }
+      if (repoObj.filesToCopyOnBranchCreate !== void 0) {
+        this.validateFilesToCopyConfig(repoObj.filesToCopyOnBranchCreate, `Repository '${repoObj.name}'`);
+      }
     });
     if (configObj.defaults) {
       if (typeof configObj.defaults !== "object") {
@@ -88,6 +181,9 @@ var ConfigLoaderService = class {
       if (defaults.retry !== void 0 && typeof defaults.retry !== "object") {
         throw new Error("Invalid 'retry' in defaults");
       }
+      if (defaults.filesToCopyOnBranchCreate !== void 0) {
+        this.validateFilesToCopyConfig(defaults.filesToCopyOnBranchCreate, "defaults");
+      }
     }
     if (configObj.retry !== void 0) {
       if (typeof configObj.retry !== "object") {
@@ -114,13 +210,79 @@ 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.`
+      );
+    }
+  }
+  validateFilesToCopyConfig(filesToCopy, context) {
+    if (!Array.isArray(filesToCopy)) {
+      throw new Error(`'filesToCopyOnBranchCreate' in ${context} must be an array`);
+    }
+    for (let i = 0; i < filesToCopy.length; i++) {
+      const pattern = filesToCopy[i];
+      if (typeof pattern !== "string" || pattern.trim() === "") {
+        throw new Error(
+          `'filesToCopyOnBranchCreate' in ${context} must contain only non-empty strings (invalid at index ${i})`
+        );
+      }
+    }
   }
   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,9 +301,18 @@ 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;
     }
+    if (repo.filesToCopyOnBranchCreate || defaults?.filesToCopyOnBranchCreate) {
+      resolved.filesToCopyOnBranchCreate = repo.filesToCopyOnBranchCreate ?? defaults?.filesToCopyOnBranchCreate;
+    }
     return resolved;
   }
   resolvePath(inputPath, baseDir) {
@@ -158,7 +329,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;
@@ -168,13 +339,15 @@ var ConfigLoaderService = class {
 };
 
 // src/services/InteractiveUIService.tsx
-import React4 from "react";
+import React7 from "react";
+import * as path7 from "path";
 import { render } from "ink";
 import * as cron from "node-cron";
+import { spawn } from "child_process";
 
 // src/components/App.tsx
-import React3, { useState as useState2, useEffect as useEffect2, useCallback } from "react";
-import { Box as Box3, useInput as useInput2 } from "ink";
+import React6, { useState as useState5, useEffect as useEffect5, useCallback as useCallback3, useRef as useRef3 } from "react";
+import { Box as Box6, useInput as useInput5, useStdout } from "ink";
 
 // src/components/StatusBar.tsx
 import React, { useState, useEffect } from "react";
@@ -210,7 +383,7 @@ var StatusBar = ({ status, repositoryCount, lastSyncTime, cronSchedule, diskSpac
   const getStatusIcon = () => {
     return status === "syncing" ? "\u27F3" : "\u2713";
   };
-  return /* @__PURE__ */ React.createElement(Box, { borderStyle: "single", paddingX: 1 }, /* @__PURE__ */ React.createElement(Box, { flexDirection: "column", width: "100%" }, /* @__PURE__ */ React.createElement(Box, { justifyContent: "space-between" }, /* @__PURE__ */ React.createElement(Text, { bold: true }, getStatusIcon(), " Status:", " ", /* @__PURE__ */ React.createElement(Text, { color: getStatusColor() }, status === "syncing" ? "Syncing..." : "Running")), /* @__PURE__ */ React.createElement(Text, null, "Repositories: ", /* @__PURE__ */ React.createElement(Text, { bold: true, color: "cyan" }, repositoryCount))), /* @__PURE__ */ React.createElement(Box, { justifyContent: "space-between" }, /* @__PURE__ */ React.createElement(Text, null, "Last Sync: ", /* @__PURE__ */ React.createElement(Text, { color: "gray" }, formatTime(lastSyncTime))), cronSchedule && /* @__PURE__ */ React.createElement(Text, null, "Next Sync: ", /* @__PURE__ */ React.createElement(Text, { color: "gray" }, formatTime(nextSyncTime)))), /* @__PURE__ */ React.createElement(Box, { justifyContent: "space-between" }, /* @__PURE__ */ React.createElement(Text, null, "Disk Space: ", /* @__PURE__ */ React.createElement(Text, { color: "magenta" }, diskSpaceUsed || "Calculating...")))));
+  return /* @__PURE__ */ React.createElement(Box, { borderStyle: "single", paddingX: 1 }, /* @__PURE__ */ React.createElement(Box, { flexDirection: "column", width: "100%" }, /* @__PURE__ */ React.createElement(Box, { justifyContent: "space-between" }, /* @__PURE__ */ React.createElement(Text, { bold: true }, getStatusIcon(), " Status:", " ", /* @__PURE__ */ React.createElement(Text, { color: getStatusColor() }, status === "syncing" ? "Syncing..." : "Running")), /* @__PURE__ */ React.createElement(Text, null, "Repositories: ", /* @__PURE__ */ React.createElement(Text, { bold: true, color: "cyan" }, repositoryCount))), /* @__PURE__ */ React.createElement(Box, { justifyContent: "space-between" }, /* @__PURE__ */ React.createElement(Text, null, "Last Sync: ", /* @__PURE__ */ React.createElement(Text, { color: "gray" }, formatTime(lastSyncTime))), cronSchedule && /* @__PURE__ */ React.createElement(Text, null, "Next Sync: ", /* @__PURE__ */ React.createElement(Text, { color: "gray" }, formatTime(nextSyncTime)))), /* @__PURE__ */ React.createElement(Box, { justifyContent: "space-between" }, /* @__PURE__ */ React.createElement(Text, null, "Disk Space: ", /* @__PURE__ */ React.createElement(Text, { color: "magenta" }, diskSpaceUsed || "Calculating...")), /* @__PURE__ */ React.createElement(Text, { dimColor: true }, /* @__PURE__ */ React.createElement(Text, { color: "yellow" }, "s"), "ync", " ", /* @__PURE__ */ React.createElement(Text, { color: "yellow" }, "c"), "reate", " ", /* @__PURE__ */ React.createElement(Text, { color: "yellow" }, "o"), "pen", " ", /* @__PURE__ */ React.createElement(Text, { color: "yellow" }, "r"), "eload", " ", /* @__PURE__ */ React.createElement(Text, { color: "yellow" }, "?"), "help", " ", /* @__PURE__ */ React.createElement(Text, { color: "yellow" }, "q"), "uit"))));
 };
 var StatusBar_default = StatusBar;
 
@@ -221,27 +394,632 @@ var HelpModal = ({ onClose }) => {
   useInput(() => {
     onClose();
   });
-  return /* @__PURE__ */ React2.createElement(Box2, { justifyContent: "center", alignItems: "center", flexDirection: "column", marginTop: 2, marginBottom: 2 }, /* @__PURE__ */ React2.createElement(Box2, { borderStyle: "double", borderColor: "cyan", paddingX: 2, paddingY: 1, flexDirection: "column", width: 60 }, /* @__PURE__ */ React2.createElement(Box2, { justifyContent: "center", marginBottom: 1 }, /* @__PURE__ */ React2.createElement(Text2, { bold: true, color: "cyan" }, "\u{1F333} sync-worktrees - Keyboard Shortcuts")), /* @__PURE__ */ React2.createElement(Box2, { flexDirection: "column", gap: 0 }, /* @__PURE__ */ React2.createElement(Box2, null, /* @__PURE__ */ React2.createElement(Box2, { width: 15 }, /* @__PURE__ */ React2.createElement(Text2, { bold: true, color: "yellow" }, "?"), /* @__PURE__ */ React2.createElement(Text2, null, " or "), /* @__PURE__ */ React2.createElement(Text2, { bold: true, color: "yellow" }, "h")), /* @__PURE__ */ React2.createElement(Text2, null, "Toggle this help screen")), /* @__PURE__ */ React2.createElement(Box2, null, /* @__PURE__ */ React2.createElement(Box2, { width: 15 }, /* @__PURE__ */ React2.createElement(Text2, { bold: true, color: "yellow" }, "s")), /* @__PURE__ */ React2.createElement(Text2, null, "Manually trigger sync for all repositories")), /* @__PURE__ */ React2.createElement(Box2, null, /* @__PURE__ */ React2.createElement(Box2, { width: 15 }, /* @__PURE__ */ React2.createElement(Text2, { bold: true, color: "yellow" }, "r")), /* @__PURE__ */ React2.createElement(Text2, null, "Reload configuration and re-sync all repos")), /* @__PURE__ */ React2.createElement(Box2, null, /* @__PURE__ */ React2.createElement(Box2, { width: 15 }, /* @__PURE__ */ React2.createElement(Text2, { bold: true, color: "yellow" }, "q"), /* @__PURE__ */ React2.createElement(Text2, null, " or "), /* @__PURE__ */ React2.createElement(Text2, { bold: true, color: "yellow" }, "Esc")), /* @__PURE__ */ React2.createElement(Text2, null, "Gracefully quit"))), /* @__PURE__ */ React2.createElement(Box2, { justifyContent: "center", marginTop: 1 }, /* @__PURE__ */ React2.createElement(Text2, { dimColor: true }, "Press any key to close"))));
+  return /* @__PURE__ */ React2.createElement(Box2, { justifyContent: "center", alignItems: "center", flexDirection: "column", marginTop: 2, marginBottom: 2 }, /* @__PURE__ */ React2.createElement(Box2, { borderStyle: "double", borderColor: "cyan", paddingX: 2, paddingY: 1, flexDirection: "column", width: 60 }, /* @__PURE__ */ React2.createElement(Box2, { justifyContent: "center", marginBottom: 1 }, /* @__PURE__ */ React2.createElement(Text2, { bold: true, color: "cyan" }, "\u{1F333} sync-worktrees - Keyboard Shortcuts")), /* @__PURE__ */ React2.createElement(Box2, { flexDirection: "column", gap: 0 }, /* @__PURE__ */ React2.createElement(Text2, { bold: true, color: "green", dimColor: true }, "Navigation"), /* @__PURE__ */ React2.createElement(Box2, null, /* @__PURE__ */ React2.createElement(Box2, { width: 15 }, /* @__PURE__ */ React2.createElement(Text2, { bold: true, color: "yellow" }, "j"), /* @__PURE__ */ React2.createElement(Text2, null, " / "), /* @__PURE__ */ React2.createElement(Text2, { bold: true, color: "yellow" }, "\u2193")), /* @__PURE__ */ React2.createElement(Text2, null, "Scroll down one line")), /* @__PURE__ */ React2.createElement(Box2, null, /* @__PURE__ */ React2.createElement(Box2, { width: 15 }, /* @__PURE__ */ React2.createElement(Text2, { bold: true, color: "yellow" }, "k"), /* @__PURE__ */ React2.createElement(Text2, null, " / "), /* @__PURE__ */ React2.createElement(Text2, { bold: true, color: "yellow" }, "\u2191")), /* @__PURE__ */ React2.createElement(Text2, null, "Scroll up one line")), /* @__PURE__ */ React2.createElement(Box2, null, /* @__PURE__ */ React2.createElement(Box2, { width: 15 }, /* @__PURE__ */ React2.createElement(Text2, { bold: true, color: "yellow" }, "gg")), /* @__PURE__ */ React2.createElement(Text2, null, "Jump to top")), /* @__PURE__ */ React2.createElement(Box2, null, /* @__PURE__ */ React2.createElement(Box2, { width: 15 }, /* @__PURE__ */ React2.createElement(Text2, { bold: true, color: "yellow" }, "G")), /* @__PURE__ */ React2.createElement(Text2, null, "Jump to bottom (re-enables auto-scroll)")), /* @__PURE__ */ React2.createElement(Box2, { marginTop: 1 }, /* @__PURE__ */ React2.createElement(Text2, { bold: true, color: "green", dimColor: true }, "Actions")), /* @__PURE__ */ React2.createElement(Box2, null, /* @__PURE__ */ React2.createElement(Box2, { width: 15 }, /* @__PURE__ */ React2.createElement(Text2, { bold: true, color: "yellow" }, "s")), /* @__PURE__ */ React2.createElement(Text2, null, "Manually trigger sync for all repositories")), /* @__PURE__ */ React2.createElement(Box2, null, /* @__PURE__ */ React2.createElement(Box2, { width: 15 }, /* @__PURE__ */ React2.createElement(Text2, { bold: true, color: "yellow" }, "c")), /* @__PURE__ */ React2.createElement(Text2, null, "Create a new branch")), /* @__PURE__ */ React2.createElement(Box2, null, /* @__PURE__ */ React2.createElement(Box2, { width: 15 }, /* @__PURE__ */ React2.createElement(Text2, { bold: true, color: "yellow" }, "o")), /* @__PURE__ */ React2.createElement(Text2, null, "Open editor in worktree")), /* @__PURE__ */ React2.createElement(Box2, null, /* @__PURE__ */ React2.createElement(Box2, { width: 15 }, /* @__PURE__ */ React2.createElement(Text2, { bold: true, color: "yellow" }, "r")), /* @__PURE__ */ React2.createElement(Text2, null, "Reload configuration and re-sync all repos")), /* @__PURE__ */ React2.createElement(Box2, null, /* @__PURE__ */ React2.createElement(Box2, { width: 15 }, /* @__PURE__ */ React2.createElement(Text2, { bold: true, color: "yellow" }, "?"), /* @__PURE__ */ React2.createElement(Text2, null, " / "), /* @__PURE__ */ React2.createElement(Text2, { bold: true, color: "yellow" }, "h")), /* @__PURE__ */ React2.createElement(Text2, null, "Toggle this help screen")), /* @__PURE__ */ React2.createElement(Box2, null, /* @__PURE__ */ React2.createElement(Box2, { width: 15 }, /* @__PURE__ */ React2.createElement(Text2, { bold: true, color: "yellow" }, "q"), /* @__PURE__ */ React2.createElement(Text2, null, " / "), /* @__PURE__ */ React2.createElement(Text2, { bold: true, color: "yellow" }, "Esc")), /* @__PURE__ */ React2.createElement(Text2, null, "Gracefully quit"))), /* @__PURE__ */ React2.createElement(Box2, { justifyContent: "center", marginTop: 1 }, /* @__PURE__ */ React2.createElement(Text2, { dimColor: true }, "Press any key to close"))));
 };
 var HelpModal_default = HelpModal;
 
-// src/components/App.tsx
-var App = ({ repositoryCount, cronSchedule, onManualSync, onReload, onQuit }) => {
-  const [showHelp, setShowHelp] = useState2(false);
-  const [status, setStatus] = useState2("idle");
-  const [lastSyncTime, setLastSyncTime] = useState2(null);
-  const [diskSpaceUsed, setDiskSpaceUsed] = useState2(null);
+// src/components/BranchCreationWizard.tsx
+import React3, { useState as useState2, useEffect as useEffect2, useCallback } from "react";
+import { Box as Box3, Text as Text3, useInput as useInput2 } from "ink";
+var isValidGitBranchName = (name) => {
+  if (!name.trim()) {
+    return { valid: false, error: "Branch name cannot be empty" };
+  }
+  if (name.startsWith("-")) {
+    return { valid: false, error: "Branch name cannot start with '-'" };
+  }
+  if (name.endsWith(".lock")) {
+    return { valid: false, error: "Branch name cannot end with '.lock'" };
+  }
+  if (name.includes("..")) {
+    return { valid: false, error: "Branch name cannot contain '..'" };
+  }
+  if (name.includes("@{")) {
+    return { valid: false, error: "Branch name cannot contain '@{'" };
+  }
+  if (name.startsWith(".") || name.endsWith(".")) {
+    return { valid: false, error: "Branch name cannot start or end with '.'" };
+  }
+  if (name.includes("//")) {
+    return { valid: false, error: "Branch name cannot contain consecutive slashes" };
+  }
+  if (/[\x00-\x1f\x7f~^:?*\[\\]/.test(name)) {
+    return { valid: false, error: "Branch name contains invalid characters" };
+  }
+  return { valid: true };
+};
+var BranchCreationWizard = ({
+  repositories,
+  getBranchesForRepo,
+  getDefaultBranchForRepo,
+  createAndPushBranch,
+  onClose,
+  onComplete
+}) => {
+  const [step, setStep] = useState2(repositories.length > 1 ? "SELECT_PROJECT" : "SELECT_BRANCH");
+  const [selectedProjectIndex, setSelectedProjectIndex] = useState2(repositories.length === 1 ? 0 : 0);
+  const [branches, setBranches] = useState2([]);
+  const [defaultBranch, setDefaultBranch] = useState2("");
+  const [selectedBranchIndex, setSelectedBranchIndex] = useState2(0);
+  const [branchName, setBranchName] = useState2("");
+  const [existingSuffix, setExistingSuffix] = useState2(null);
+  const [validationError, setValidationError] = useState2(null);
+  const [result, setResult] = useState2(null);
+  const [loading, setLoading] = useState2(false);
+  const loadBranches = useCallback(
+    async (repoIndex) => {
+      setLoading(true);
+      try {
+        const branchList = await getBranchesForRepo(repoIndex);
+        const defaultBr = getDefaultBranchForRepo(repoIndex);
+        setBranches(branchList);
+        setDefaultBranch(defaultBr);
+        const defaultIndex = branchList.indexOf(defaultBr);
+        setSelectedBranchIndex(defaultIndex >= 0 ? defaultIndex : 0);
+      } catch {
+        setBranches([]);
+      }
+      setLoading(false);
+    },
+    [getBranchesForRepo, getDefaultBranchForRepo]
+  );
+  const checkBranchExists = useCallback(
+    (name) => {
+      if (!name.trim()) {
+        setExistingSuffix(null);
+        setValidationError(null);
+        return;
+      }
+      const validation = isValidGitBranchName(name);
+      if (!validation.valid) {
+        setValidationError(validation.error ?? null);
+        setExistingSuffix(null);
+        return;
+      }
+      setValidationError(null);
+      let suffix = 0;
+      let testName = name;
+      while (branches.includes(testName)) {
+        suffix++;
+        testName = `${name}-${suffix}`;
+      }
+      setExistingSuffix(suffix > 0 ? suffix : null);
+    },
+    [branches]
+  );
+  useEffect2(() => {
+    if (step === "SELECT_BRANCH" && branches.length === 0 && !loading) {
+      loadBranches(selectedProjectIndex);
+    }
+  }, [step, selectedProjectIndex, branches.length, loading, loadBranches]);
+  useEffect2(() => {
+    if (step === "ENTER_NAME") {
+      checkBranchExists(branchName);
+    }
+  }, [branchName, step, checkBranchExists]);
+  const handleCreateBranch = async () => {
+    const trimmedName = branchName.trim();
+    if (!trimmedName) return;
+    const validation = isValidGitBranchName(trimmedName);
+    if (!validation.valid) {
+      setValidationError(validation.error ?? null);
+      return;
+    }
+    setStep("CREATING");
+    const baseBranch = branches[selectedBranchIndex];
+    const createResult = await createAndPushBranch(selectedProjectIndex, baseBranch, trimmedName);
+    setResult(createResult);
+    setStep("RESULT");
+  };
   useInput2((input2, key) => {
+    if (step === "CREATING") return;
+    if (key.escape) {
+      if (step === "SELECT_PROJECT") {
+        onClose();
+      } else if (step === "SELECT_BRANCH") {
+        if (repositories.length > 1) {
+          setBranches([]);
+          setStep("SELECT_PROJECT");
+        } else {
+          onClose();
+        }
+      } else if (step === "ENTER_NAME") {
+        setBranchName("");
+        setExistingSuffix(null);
+        setStep("SELECT_BRANCH");
+      } else if (step === "RESULT") {
+        const context = result?.success ? {
+          repoIndex: selectedProjectIndex,
+          baseBranch: branches[selectedBranchIndex],
+          newBranch: result.finalName
+        } : void 0;
+        onComplete(result?.success ?? false, context);
+      }
+      return;
+    }
+    if (step === "SELECT_PROJECT") {
+      if (key.upArrow) {
+        setSelectedProjectIndex((prev) => Math.max(0, prev - 1));
+      } else if (key.downArrow) {
+        setSelectedProjectIndex((prev) => Math.min(repositories.length - 1, prev + 1));
+      } else if (key.return) {
+        loadBranches(selectedProjectIndex);
+        setStep("SELECT_BRANCH");
+      }
+    } else if (step === "SELECT_BRANCH") {
+      if (key.upArrow) {
+        setSelectedBranchIndex((prev) => Math.max(0, prev - 1));
+      } else if (key.downArrow) {
+        setSelectedBranchIndex((prev) => Math.min(branches.length - 1, prev + 1));
+      } else if (key.return && branches.length > 0) {
+        setStep("ENTER_NAME");
+      }
+    } else if (step === "ENTER_NAME") {
+      if (key.return && branchName.trim()) {
+        void handleCreateBranch();
+      } else if (key.backspace || key.delete) {
+        setBranchName((prev) => prev.slice(0, -1));
+      } else if (input2 && !key.ctrl && !key.meta) {
+        const validChar = /^[a-zA-Z0-9/_-]$/.test(input2);
+        if (validChar) {
+          setBranchName((prev) => prev + input2);
+        }
+      }
+    } else if (step === "RESULT") {
+      const context = result?.success ? {
+        repoIndex: selectedProjectIndex,
+        baseBranch: branches[selectedBranchIndex],
+        newBranch: result.finalName
+      } : void 0;
+      onComplete(result?.success ?? false, context);
+    }
+  });
+  const getStepNumber = () => {
+    if (repositories.length === 1) {
+      if (step === "SELECT_BRANCH") return 1;
+      if (step === "ENTER_NAME") return 2;
+      return 2;
+    }
+    if (step === "SELECT_PROJECT") return 1;
+    if (step === "SELECT_BRANCH") return 2;
+    if (step === "ENTER_NAME") return 3;
+    return 3;
+  };
+  const getTotalSteps = () => repositories.length === 1 ? 2 : 3;
+  const renderProjectSelection = () => /* @__PURE__ */ React3.createElement(Box3, { flexDirection: "column", gap: 1 }, /* @__PURE__ */ React3.createElement(Text3, null, "Select repository:"), /* @__PURE__ */ React3.createElement(Box3, { flexDirection: "column" }, repositories.map((repo, idx) => /* @__PURE__ */ React3.createElement(Box3, { key: repo.index }, /* @__PURE__ */ React3.createElement(Text3, { color: idx === selectedProjectIndex ? "cyan" : void 0 }, idx === selectedProjectIndex ? "> " : "  ", repo.name)))));
+  const renderBranchSelection = () => {
+    if (loading) {
+      return /* @__PURE__ */ React3.createElement(Text3, { color: "yellow" }, "Loading branches...");
+    }
+    if (branches.length === 0) {
+      return /* @__PURE__ */ React3.createElement(Text3, { color: "red" }, "No branches found");
+    }
+    const visibleCount = 8;
+    const halfVisible = Math.floor(visibleCount / 2);
+    let startIdx = Math.max(0, selectedBranchIndex - halfVisible);
+    const endIdx = Math.min(branches.length, startIdx + visibleCount);
+    if (endIdx - startIdx < visibleCount) {
+      startIdx = Math.max(0, endIdx - visibleCount);
+    }
+    const visibleBranches = branches.slice(startIdx, endIdx);
+    return /* @__PURE__ */ React3.createElement(Box3, { flexDirection: "column", gap: 1 }, /* @__PURE__ */ React3.createElement(Text3, null, "Select base branch:"), /* @__PURE__ */ React3.createElement(Box3, { flexDirection: "column" }, startIdx > 0 && /* @__PURE__ */ React3.createElement(Text3, { dimColor: true }, "  ..."), visibleBranches.map((branch, idx) => {
+      const actualIdx = startIdx + idx;
+      const isSelected = actualIdx === selectedBranchIndex;
+      const isDefault = branch === defaultBranch;
+      return /* @__PURE__ */ React3.createElement(Box3, { key: branch }, /* @__PURE__ */ React3.createElement(Text3, { color: isSelected ? "cyan" : void 0 }, isSelected ? "> " : "  ", branch, isDefault && /* @__PURE__ */ React3.createElement(Text3, { color: "green" }, " (default)")));
+    }), endIdx < branches.length && /* @__PURE__ */ React3.createElement(Text3, { dimColor: true }, "  ...")));
+  };
+  const renderNameInput = () => {
+    const baseBranch = branches[selectedBranchIndex] || "";
+    const finalName = existingSuffix !== null ? `${branchName}-${existingSuffix}` : branchName;
+    const endsWithSlash = branchName.endsWith("/");
+    return /* @__PURE__ */ React3.createElement(Box3, { flexDirection: "column", gap: 1 }, /* @__PURE__ */ React3.createElement(Text3, null, "Base branch: ", /* @__PURE__ */ React3.createElement(Text3, { color: "cyan" }, baseBranch)), /* @__PURE__ */ React3.createElement(Text3, null, "Enter new branch name:"), /* @__PURE__ */ React3.createElement(Box3, null, /* @__PURE__ */ React3.createElement(Text3, { color: "cyan" }, "> "), /* @__PURE__ */ React3.createElement(Text3, null, branchName), /* @__PURE__ */ React3.createElement(Text3, { color: "gray" }, "|")), validationError && /* @__PURE__ */ React3.createElement(Text3, { color: "red" }, validationError), !validationError && endsWithSlash && /* @__PURE__ */ React3.createElement(Text3, { color: "yellow", dimColor: true }, "Hint: consecutive slashes (//) are not allowed"), !validationError && !endsWithSlash && existingSuffix !== null && branchName && /* @__PURE__ */ React3.createElement(Text3, { color: "yellow" }, "Name exists, will create: ", /* @__PURE__ */ React3.createElement(Text3, { color: "cyan" }, finalName)));
+  };
+  const renderCreating = () => /* @__PURE__ */ React3.createElement(Box3, { flexDirection: "column", gap: 1 }, /* @__PURE__ */ React3.createElement(Text3, { color: "yellow" }, "Creating branch..."), /* @__PURE__ */ React3.createElement(Text3, { dimColor: true }, "Please wait while the branch is created and pushed to remote."));
+  const renderResult = () => {
+    if (!result) return null;
+    if (result.success) {
+      return /* @__PURE__ */ React3.createElement(Box3, { flexDirection: "column", gap: 1 }, /* @__PURE__ */ React3.createElement(Text3, { color: "green" }, "Branch created successfully!"), /* @__PURE__ */ React3.createElement(Text3, null, "Created: ", /* @__PURE__ */ React3.createElement(Text3, { color: "cyan" }, result.finalName)), /* @__PURE__ */ React3.createElement(Text3, null, "From: ", /* @__PURE__ */ React3.createElement(Text3, { color: "cyan" }, branches[selectedBranchIndex])), /* @__PURE__ */ React3.createElement(Text3, { dimColor: true }, "Syncing now to create the worktree..."));
+    }
+    return /* @__PURE__ */ React3.createElement(Box3, { flexDirection: "column", gap: 1 }, /* @__PURE__ */ React3.createElement(Text3, { color: "red" }, "Failed to create branch"), /* @__PURE__ */ React3.createElement(Text3, { color: "red" }, result.error));
+  };
+  const renderContent = () => {
+    switch (step) {
+      case "SELECT_PROJECT":
+        return renderProjectSelection();
+      case "SELECT_BRANCH":
+        return renderBranchSelection();
+      case "ENTER_NAME":
+        return renderNameInput();
+      case "CREATING":
+        return renderCreating();
+      case "RESULT":
+        return renderResult();
+    }
+  };
+  const renderFooter = () => {
+    if (step === "CREATING") return null;
+    if (step === "RESULT") {
+      return /* @__PURE__ */ React3.createElement(Text3, { dimColor: true }, "Press any key to continue");
+    }
+    if (step === "ENTER_NAME") {
+      return /* @__PURE__ */ React3.createElement(Text3, { dimColor: true }, "Enter to create \u2022 ESC to go back");
+    }
+    return /* @__PURE__ */ React3.createElement(Text3, { dimColor: true }, "\u2191/\u2193 to navigate \u2022 Enter to select \u2022 ESC to cancel");
+  };
+  return /* @__PURE__ */ React3.createElement(Box3, { flexDirection: "column", marginTop: 1, marginBottom: 1 }, /* @__PURE__ */ React3.createElement(Box3, { borderStyle: "round", borderColor: "green", paddingX: 2, paddingY: 1, flexDirection: "column", width: 60 }, /* @__PURE__ */ React3.createElement(Box3, { marginBottom: 1 }, /* @__PURE__ */ React3.createElement(Text3, { bold: true, color: "green" }, "\u{1F33F} Create New Branch", " ", step !== "CREATING" && step !== "RESULT" && /* @__PURE__ */ React3.createElement(Text3, { dimColor: true }, "(Step ", getStepNumber(), "/", getTotalSteps(), ")"))), repositories.length > 1 && step !== "SELECT_PROJECT" && step !== "CREATING" && step !== "RESULT" && /* @__PURE__ */ React3.createElement(Box3, { marginBottom: 1 }, /* @__PURE__ */ React3.createElement(Text3, null, "Repository: ", /* @__PURE__ */ React3.createElement(Text3, { color: "cyan" }, repositories[selectedProjectIndex].name))), renderContent(), /* @__PURE__ */ React3.createElement(Box3, { marginTop: 1 }, renderFooter())));
+};
+var BranchCreationWizard_default = BranchCreationWizard;
+
+// src/components/OpenEditorWizard.tsx
+import React4, { useState as useState3, useEffect as useEffect3, useMemo, useCallback as useCallback2, useRef } from "react";
+import { Box as Box4, Text as Text4, useInput as useInput3 } from "ink";
+var OpenEditorWizard = ({
+  repositories,
+  getWorktreesForRepo,
+  openEditorInWorktree,
+  onClose
+}) => {
+  const [step, setStep] = useState3(repositories.length > 1 ? "SELECT_PROJECT" : "SELECT_WORKTREE");
+  const [selectedProjectIndex, setSelectedProjectIndex] = useState3(0);
+  const [projectFilter, setProjectFilter] = useState3("");
+  const selectedRepoIndexRef = useRef(repositories.length === 1 ? 0 : -1);
+  const [worktrees, setWorktrees] = useState3([]);
+  const [selectedWorktreeIndex, setSelectedWorktreeIndex] = useState3(0);
+  const [worktreeFilter, setWorktreeFilter] = useState3("");
+  const [loading, setLoading] = useState3(false);
+  const [error, setError] = useState3(null);
+  const filteredProjects = useMemo(() => {
+    if (!projectFilter) return repositories;
+    const lowerFilter = projectFilter.toLowerCase();
+    return repositories.filter((repo) => repo.name.toLowerCase().includes(lowerFilter));
+  }, [repositories, projectFilter]);
+  const filteredWorktrees = useMemo(() => {
+    if (!worktreeFilter) return worktrees;
+    const lowerFilter = worktreeFilter.toLowerCase();
+    return worktrees.filter((wt) => wt.branch.toLowerCase().includes(lowerFilter));
+  }, [worktrees, worktreeFilter]);
+  const loadWorktrees = useCallback2(
+    async (repoIndex) => {
+      setLoading(true);
+      try {
+        const wts = await getWorktreesForRepo(repoIndex);
+        setWorktrees(wts);
+        setSelectedWorktreeIndex(0);
+      } catch (err) {
+        setError(`Failed to load worktrees: ${err}`);
+        setStep("ERROR");
+      }
+      setLoading(false);
+    },
+    [getWorktreesForRepo]
+  );
+  useEffect3(() => {
+    if (step === "SELECT_WORKTREE" && worktrees.length === 0 && !loading && selectedRepoIndexRef.current >= 0) {
+      loadWorktrees(selectedRepoIndexRef.current);
+    }
+  }, [step, worktrees.length, loading, loadWorktrees]);
+  const handleOpenEditor = () => {
+    const worktree = filteredWorktrees[selectedWorktreeIndex];
+    if (!worktree) return;
+    setStep("OPENING");
+    const result = openEditorInWorktree(worktree.path);
+    if (result.success) {
+      onClose();
+    } else {
+      setError(result.error || "Failed to open editor");
+      setStep("ERROR");
+    }
+  };
+  useInput3((input2, key) => {
+    if (step === "OPENING") return;
+    if (key.escape) {
+      if (step === "SELECT_PROJECT") {
+        onClose();
+      } else if (step === "SELECT_WORKTREE") {
+        if (repositories.length > 1) {
+          setWorktrees([]);
+          setWorktreeFilter("");
+          selectedRepoIndexRef.current = -1;
+          setStep("SELECT_PROJECT");
+        } else {
+          onClose();
+        }
+      } else if (step === "ERROR") {
+        onClose();
+      }
+      return;
+    }
+    if (step === "SELECT_PROJECT") {
+      if (key.upArrow) {
+        setSelectedProjectIndex((prev) => Math.max(0, prev - 1));
+      } else if (key.downArrow) {
+        setSelectedProjectIndex((prev) => Math.min(filteredProjects.length - 1, prev + 1));
+      } else if (key.return && filteredProjects.length > 0) {
+        const selectedRepo = filteredProjects[selectedProjectIndex];
+        if (selectedRepo) {
+          selectedRepoIndexRef.current = selectedRepo.index;
+          setStep("SELECT_WORKTREE");
+          loadWorktrees(selectedRepo.index);
+        }
+      } else if (key.backspace || key.delete) {
+        setProjectFilter((prev) => prev.slice(0, -1));
+        setSelectedProjectIndex(0);
+      } else if (input2 && !key.ctrl && !key.meta) {
+        setProjectFilter((prev) => prev + input2);
+        setSelectedProjectIndex(0);
+      }
+    } else if (step === "SELECT_WORKTREE") {
+      if (key.upArrow) {
+        setSelectedWorktreeIndex((prev) => Math.max(0, prev - 1));
+      } else if (key.downArrow) {
+        setSelectedWorktreeIndex((prev) => Math.min(filteredWorktrees.length - 1, prev + 1));
+      } else if (key.return && filteredWorktrees.length > 0) {
+        handleOpenEditor();
+      } else if (key.backspace || key.delete) {
+        setWorktreeFilter((prev) => prev.slice(0, -1));
+        setSelectedWorktreeIndex(0);
+      } else if (input2 && !key.ctrl && !key.meta) {
+        setWorktreeFilter((prev) => prev + input2);
+        setSelectedWorktreeIndex(0);
+      }
+    } else if (step === "ERROR") {
+      onClose();
+    }
+  });
+  const getStepNumber = () => {
+    if (repositories.length === 1) {
+      return 1;
+    }
+    return step === "SELECT_PROJECT" ? 1 : 2;
+  };
+  const getTotalSteps = () => repositories.length === 1 ? 1 : 2;
+  const renderProjectSelection = () => {
+    const visibleCount = 8;
+    const halfVisible = Math.floor(visibleCount / 2);
+    let startIdx = Math.max(0, selectedProjectIndex - halfVisible);
+    const endIdx = Math.min(filteredProjects.length, startIdx + visibleCount);
+    if (endIdx - startIdx < visibleCount) {
+      startIdx = Math.max(0, endIdx - visibleCount);
+    }
+    const visibleProjects = filteredProjects.slice(startIdx, endIdx);
+    return /* @__PURE__ */ React4.createElement(Box4, { flexDirection: "column", gap: 1 }, /* @__PURE__ */ React4.createElement(Text4, null, "Select repository:"), /* @__PURE__ */ React4.createElement(Box4, null, /* @__PURE__ */ React4.createElement(Text4, null, "Filter: "), /* @__PURE__ */ React4.createElement(Text4, { color: "cyan" }, projectFilter || "_"), /* @__PURE__ */ React4.createElement(Text4, { dimColor: true }, " ", "(", filteredProjects.length, "/", repositories.length, " matches)")), /* @__PURE__ */ React4.createElement(Box4, { flexDirection: "column" }, filteredProjects.length === 0 ? /* @__PURE__ */ React4.createElement(Text4, { color: "yellow" }, "No matches") : /* @__PURE__ */ React4.createElement(React4.Fragment, null, startIdx > 0 && /* @__PURE__ */ React4.createElement(Text4, { dimColor: true }, " ..."), visibleProjects.map((repo, idx) => {
+      const actualIdx = startIdx + idx;
+      const isSelected = actualIdx === selectedProjectIndex;
+      return /* @__PURE__ */ React4.createElement(Box4, { key: repo.index }, /* @__PURE__ */ React4.createElement(Text4, { color: isSelected ? "cyan" : void 0 }, isSelected ? "> " : "  ", repo.name));
+    }), endIdx < filteredProjects.length && /* @__PURE__ */ React4.createElement(Text4, { dimColor: true }, " ..."))));
+  };
+  const renderWorktreeSelection = () => {
+    if (loading) {
+      return /* @__PURE__ */ React4.createElement(Text4, { color: "yellow" }, "Loading worktrees...");
+    }
+    if (worktrees.length === 0) {
+      return /* @__PURE__ */ React4.createElement(Text4, { color: "red" }, "No worktrees found");
+    }
+    const visibleCount = 8;
+    const halfVisible = Math.floor(visibleCount / 2);
+    let startIdx = Math.max(0, selectedWorktreeIndex - halfVisible);
+    const endIdx = Math.min(filteredWorktrees.length, startIdx + visibleCount);
+    if (endIdx - startIdx < visibleCount) {
+      startIdx = Math.max(0, endIdx - visibleCount);
+    }
+    const visibleWorktrees = filteredWorktrees.slice(startIdx, endIdx);
+    return /* @__PURE__ */ React4.createElement(Box4, { flexDirection: "column", gap: 1 }, /* @__PURE__ */ React4.createElement(Text4, null, "Select worktree:"), /* @__PURE__ */ React4.createElement(Box4, null, /* @__PURE__ */ React4.createElement(Text4, null, "Filter: "), /* @__PURE__ */ React4.createElement(Text4, { color: "cyan" }, worktreeFilter || "_"), /* @__PURE__ */ React4.createElement(Text4, { dimColor: true }, " ", "(", filteredWorktrees.length, "/", worktrees.length, " matches)")), /* @__PURE__ */ React4.createElement(Box4, { flexDirection: "column" }, filteredWorktrees.length === 0 ? /* @__PURE__ */ React4.createElement(Text4, { color: "yellow" }, "No matches") : /* @__PURE__ */ React4.createElement(React4.Fragment, null, startIdx > 0 && /* @__PURE__ */ React4.createElement(Text4, { dimColor: true }, " ..."), visibleWorktrees.map((wt, idx) => {
+      const actualIdx = startIdx + idx;
+      const isSelected = actualIdx === selectedWorktreeIndex;
+      return /* @__PURE__ */ React4.createElement(Box4, { key: wt.path }, /* @__PURE__ */ React4.createElement(Text4, { color: isSelected ? "cyan" : void 0 }, isSelected ? "> " : "  ", wt.branch));
+    }), endIdx < filteredWorktrees.length && /* @__PURE__ */ React4.createElement(Text4, { dimColor: true }, " ..."))));
+  };
+  const renderOpening = () => /* @__PURE__ */ React4.createElement(Box4, { flexDirection: "column", gap: 1 }, /* @__PURE__ */ React4.createElement(Text4, { color: "yellow" }, "Opening editor..."));
+  const renderError = () => /* @__PURE__ */ React4.createElement(Box4, { flexDirection: "column", gap: 1 }, /* @__PURE__ */ React4.createElement(Text4, { color: "red" }, "Error: ", error), /* @__PURE__ */ React4.createElement(Text4, { dimColor: true }, "Press any key to close"));
+  const renderContent = () => {
+    switch (step) {
+      case "SELECT_PROJECT":
+        return renderProjectSelection();
+      case "SELECT_WORKTREE":
+        return renderWorktreeSelection();
+      case "OPENING":
+        return renderOpening();
+      case "ERROR":
+        return renderError();
+    }
+  };
+  const renderFooter = () => {
+    if (step === "OPENING") return null;
+    if (step === "ERROR") return null;
+    return /* @__PURE__ */ React4.createElement(Text4, { dimColor: true }, "\u2191/\u2193 navigate \u2022 Type to filter \u2022 Enter to select \u2022 ESC to cancel");
+  };
+  return /* @__PURE__ */ React4.createElement(Box4, { flexDirection: "column", marginTop: 1, marginBottom: 1 }, /* @__PURE__ */ React4.createElement(Box4, { borderStyle: "round", borderColor: "blue", paddingX: 2, paddingY: 1, flexDirection: "column", width: 60 }, /* @__PURE__ */ React4.createElement(Box4, { marginBottom: 1 }, /* @__PURE__ */ React4.createElement(Text4, { bold: true, color: "blue" }, "\u{1F4C2} Open in Editor", " ", step !== "OPENING" && step !== "ERROR" && /* @__PURE__ */ React4.createElement(Text4, { dimColor: true }, "(Step ", getStepNumber(), "/", getTotalSteps(), ")"))), repositories.length > 1 && step === "SELECT_WORKTREE" && !loading && selectedRepoIndexRef.current >= 0 && /* @__PURE__ */ React4.createElement(Box4, { marginBottom: 1 }, /* @__PURE__ */ React4.createElement(Text4, null, "Repository: ", /* @__PURE__ */ React4.createElement(Text4, { color: "cyan" }, repositories.find((r) => r.index === selectedRepoIndexRef.current)?.name))), renderContent(), /* @__PURE__ */ React4.createElement(Box4, { marginTop: 1 }, renderFooter())));
+};
+var OpenEditorWizard_default = OpenEditorWizard;
+
+// src/components/LogPanel.tsx
+import React5, { useState as useState4, useEffect as useEffect4, useRef as useRef2 } from "react";
+import { Box as Box5, Text as Text5, useInput as useInput4 } from "ink";
+var LogPanel = ({ logs, height, isActive }) => {
+  const [scrollOffset, setScrollOffset] = useState4(0);
+  const [autoScroll, setAutoScroll] = useState4(true);
+  const [pendingG, setPendingG] = useState4(false);
+  const gTimeoutRef = useRef2(null);
+  const borderLines = 2;
+  const headerLine = 1;
+  const visibleLines = Math.max(1, height - borderLines - headerLine);
+  const maxOffset = Math.max(0, logs.length - visibleLines);
+  useEffect4(() => {
+    if (autoScroll) {
+      setScrollOffset(maxOffset);
+    }
+  }, [logs.length, maxOffset, autoScroll]);
+  useEffect4(() => {
+    return () => {
+      if (gTimeoutRef.current) {
+        clearTimeout(gTimeoutRef.current);
+      }
+    };
+  }, []);
+  useInput4(
+    (input2, key) => {
+      if (!isActive) return;
+      if (key.upArrow || input2 === "k") {
+        setScrollOffset((prev) => Math.max(0, prev - 1));
+        setAutoScroll(false);
+        setPendingG(false);
+      } else if (key.downArrow || input2 === "j") {
+        setScrollOffset((prev) => {
+          const newOffset = Math.min(maxOffset, prev + 1);
+          if (newOffset >= maxOffset) {
+            setAutoScroll(true);
+          }
+          return newOffset;
+        });
+        setPendingG(false);
+      } else if (key.pageUp) {
+        setScrollOffset((prev) => Math.max(0, prev - visibleLines));
+        setAutoScroll(false);
+        setPendingG(false);
+      } else if (key.pageDown) {
+        setScrollOffset((prev) => {
+          const newOffset = Math.min(maxOffset, prev + visibleLines);
+          if (newOffset >= maxOffset) {
+            setAutoScroll(true);
+          }
+          return newOffset;
+        });
+        setPendingG(false);
+      } else if (input2 === "g") {
+        if (pendingG) {
+          setScrollOffset(0);
+          setAutoScroll(false);
+          setPendingG(false);
+          if (gTimeoutRef.current) {
+            clearTimeout(gTimeoutRef.current);
+            gTimeoutRef.current = null;
+          }
+        } else {
+          setPendingG(true);
+          gTimeoutRef.current = setTimeout(() => {
+            setPendingG(false);
+          }, 500);
+        }
+      } else if (input2 === "G") {
+        setScrollOffset(maxOffset);
+        setAutoScroll(true);
+        setPendingG(false);
+      }
+    },
+    { isActive }
+  );
+  const getLogColor = (level) => {
+    switch (level) {
+      case "error":
+        return "red";
+      case "warn":
+        return "yellow";
+      default:
+        return void 0;
+    }
+  };
+  const visibleLogs = logs.slice(scrollOffset, scrollOffset + visibleLines);
+  const hasMoreAbove = scrollOffset > 0;
+  const hasMoreBelow = scrollOffset + visibleLines < logs.length;
+  const aboveCount = scrollOffset;
+  const belowCount = logs.length - scrollOffset - visibleLines;
+  const emptyLines = Math.max(0, visibleLines - visibleLogs.length);
+  return /* @__PURE__ */ React5.createElement(Box5, { borderStyle: "single", flexDirection: "column", flexGrow: 1, paddingX: 1 }, /* @__PURE__ */ React5.createElement(Box5, { justifyContent: "space-between" }, /* @__PURE__ */ React5.createElement(Text5, { bold: true }, "\u{1F4CB} Logs ", logs.length > 0 && /* @__PURE__ */ React5.createElement(Text5, { dimColor: true }, "(", logs.length, " entries)")), isActive && /* @__PURE__ */ React5.createElement(Text5, { dimColor: true }, hasMoreAbove || hasMoreBelow ? "\u2191/\u2193 scroll" : "", " ", autoScroll ? "(auto)" : "")), hasMoreAbove && /* @__PURE__ */ React5.createElement(Text5, { dimColor: true }, "\u2191 ", aboveCount, " more above"), visibleLogs.map((log) => /* @__PURE__ */ React5.createElement(Text5, { key: log.id, color: getLogColor(log.level), wrap: "truncate" }, log.message)), Array.from({ length: emptyLines }).map((_, i) => /* @__PURE__ */ React5.createElement(Text5, { key: `empty-${i}` }, " ")), hasMoreBelow && /* @__PURE__ */ React5.createElement(Text5, { dimColor: true }, "\u2193 ", belowCount, " more below"));
+};
+var LogPanel_default = LogPanel;
+
+// src/utils/app-events.ts
+var AppEventEmitter = class {
+  listeners = /* @__PURE__ */ new Map();
+  on(event, callback) {
+    if (!this.listeners.has(event)) {
+      this.listeners.set(event, /* @__PURE__ */ new Set());
+    }
+    this.listeners.get(event).add(callback);
+    return () => {
+      this.listeners.get(event)?.delete(callback);
+    };
+  }
+  emit(event, ...args) {
+    const callbacks = this.listeners.get(event);
+    if (callbacks) {
+      for (const callback of callbacks) {
+        try {
+          callback(args[0]);
+        } catch {
+        }
+      }
+    }
+  }
+  removeAllListeners() {
+    this.listeners.clear();
+  }
+};
+var appEvents = new AppEventEmitter();
+
+// src/components/App.tsx
+var MAX_LOG_ENTRIES = 5e3;
+var App = ({
+  repositoryCount,
+  cronSchedule,
+  onManualSync,
+  onReload,
+  onQuit,
+  getRepositoryList,
+  getBranchesForRepo,
+  getDefaultBranchForRepo,
+  createAndPushBranch,
+  getWorktreesForRepo,
+  openEditorInWorktree,
+  copyBranchFiles,
+  createWorktreeForBranch
+}) => {
+  const [showHelp, setShowHelp] = useState5(false);
+  const [showBranchWizard, setShowBranchWizard] = useState5(false);
+  const [showOpenEditorWizard, setShowOpenEditorWizard] = useState5(false);
+  const [status, setStatus] = useState5("idle");
+  const [lastSyncTime, setLastSyncTime] = useState5(null);
+  const [diskSpaceUsed, setDiskSpaceUsed] = useState5(null);
+  const [logs, setLogs] = useState5([]);
+  const { stdout } = useStdout();
+  const addLog = useCallback3((message, level = "info") => {
+    setLogs((prev) => {
+      const newLogs = [
+        ...prev,
+        {
+          id: `${Date.now()}-${Math.random().toString(36).slice(2, 9)}`,
+          message,
+          level,
+          timestamp: /* @__PURE__ */ new Date()
+        }
+      ];
+      if (newLogs.length > MAX_LOG_ENTRIES) {
+        return newLogs.slice(-MAX_LOG_ENTRIES);
+      }
+      return newLogs;
+    });
+  }, []);
+  const addLogRef = useRef3(addLog);
+  addLogRef.current = addLog;
+  useInput5((input2) => {
     if (showHelp) {
       if (input2 === "?" || input2 === "h") {
         setShowHelp(false);
       }
       return;
     }
-    if (key.escape || input2 === "q") {
+    if (showBranchWizard || showOpenEditorWizard) {
+      return;
+    }
+    if (input2 === "q") {
       void onQuit();
     } else if (input2 === "?" || input2 === "h") {
       setShowHelp(true);
+    } else if (input2 === "c" && status === "idle") {
+      setShowBranchWizard(true);
+    } else if (input2 === "o" && status === "idle") {
+      setShowOpenEditorWizard(true);
     } else if (input2 === "s" && status !== "syncing") {
       setStatus("syncing");
       void (async () => {
@@ -264,21 +1042,71 @@ var App = ({ repositoryCount, cronSchedule, onManualSync, onReload, onQuit }) =>
       })();
     }
   });
-  const updateLastSyncTime = useCallback(() => {
+  const updateLastSyncTime = useCallback3(() => {
     setLastSyncTime(/* @__PURE__ */ new Date());
     setStatus("idle");
   }, []);
-  useEffect2(() => {
-    globalThis.__inkAppMethods = {
-      updateLastSyncTime,
-      setStatus,
-      setDiskSpace: setDiskSpaceUsed
-    };
+  useEffect5(() => {
+    const unsubscribers = [
+      appEvents.on("updateLastSyncTime", () => {
+        setLastSyncTime(/* @__PURE__ */ new Date());
+        setStatus("idle");
+      }),
+      appEvents.on("setStatus", (newStatus) => {
+        setStatus(newStatus);
+      }),
+      appEvents.on("setDiskSpace", (diskSpace) => {
+        setDiskSpaceUsed(diskSpace);
+      }),
+      appEvents.on("addLog", ({ message, level }) => {
+        addLogRef.current(message, level);
+      })
+    ];
+    appEvents.emit("uiReady");
     return () => {
-      delete globalThis.__inkAppMethods;
+      unsubscribers.forEach((unsub) => unsub());
     };
-  }, [updateLastSyncTime, setStatus]);
-  return /* @__PURE__ */ React3.createElement(Box3, { flexDirection: "column" }, /* @__PURE__ */ React3.createElement(
+  }, []);
+  const statusBarHeight = 5;
+  const terminalRows = stdout.rows ?? 24;
+  const logPanelHeight = Math.max(5, terminalRows - statusBarHeight);
+  const showModal = showHelp || showBranchWizard || showOpenEditorWizard;
+  return /* @__PURE__ */ React6.createElement(Box6, { flexDirection: "column", minHeight: terminalRows }, !showModal && /* @__PURE__ */ React6.createElement(LogPanel_default, { logs, height: logPanelHeight, isActive: !showModal }), showHelp && /* @__PURE__ */ React6.createElement(HelpModal_default, { onClose: () => setShowHelp(false) }), showBranchWizard && /* @__PURE__ */ React6.createElement(
+    BranchCreationWizard_default,
+    {
+      repositories: getRepositoryList(),
+      getBranchesForRepo,
+      getDefaultBranchForRepo,
+      createAndPushBranch,
+      onClose: () => setShowBranchWizard(false),
+      onComplete: (success, context) => {
+        setShowBranchWizard(false);
+        if (success && context) {
+          setStatus("syncing");
+          void (async () => {
+            try {
+              await createWorktreeForBranch(context.repoIndex, context.newBranch);
+              if (copyBranchFiles) {
+                await copyBranchFiles(context.repoIndex, context.baseBranch, context.newBranch);
+              }
+            } catch (error) {
+              console.error("Failed to create worktree:", error);
+            } finally {
+              setStatus("idle");
+            }
+          })();
+        }
+      }
+    }
+  ), showOpenEditorWizard && /* @__PURE__ */ React6.createElement(
+    OpenEditorWizard_default,
+    {
+      repositories: getRepositoryList(),
+      getWorktreesForRepo,
+      openEditorInWorktree,
+      onClose: () => setShowOpenEditorWizard(false)
+    }
+  ), /* @__PURE__ */ React6.createElement(
     StatusBar_default,
     {
       status,
@@ -287,13 +1115,14 @@ var App = ({ repositoryCount, cronSchedule, onManualSync, onReload, onQuit }) =>
       cronSchedule,
       diskSpaceUsed: diskSpaceUsed ?? void 0
     }
-  ), showHelp && /* @__PURE__ */ React3.createElement(HelpModal_default, { onClose: () => setShowHelp(false) }));
+  ));
 };
 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 +1202,7 @@ var DEFAULT_OPTIONS = {
   maxDelayMs: 6e5,
   // 10 minutes
   backoffMultiplier: 2,
+  jitterMs: 0,
   shouldRetry: (error, context) => {
     const err = error;
     if (isLfsErrorFromError(error)) {
@@ -430,7 +1260,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 +1270,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 +1401,86 @@ function getDefaultBareRepoDir(repoUrl, baseDir = ".bare") {
   return `${baseDir}/${repoName}`;
 }
 
+// src/services/logger.service.ts
+var Logger = class _Logger {
+  repoName;
+  debugEnabled;
+  outputFn;
+  constructor(options = {}) {
+    this.repoName = options.repoName;
+    this.debugEnabled = options.debug ?? false;
+    this.outputFn = options.outputFn;
+  }
+  prefix() {
+    return this.repoName ? `[${this.repoName}] ` : "";
+  }
+  debug(message, ...args) {
+    if (!this.debugEnabled) return;
+    const formattedMessage = this.prefix() + this.formatMessage(message, args);
+    if (this.outputFn) {
+      this.outputFn(formattedMessage, "debug");
+    } else {
+      console.log(formattedMessage);
+    }
+  }
+  info(message, ...args) {
+    const formattedMessage = this.prefix() + this.formatMessage(message, args);
+    if (this.outputFn) {
+      this.outputFn(formattedMessage, "info");
+    } else {
+      console.log(formattedMessage);
+    }
+  }
+  warn(message, ...args) {
+    const formattedMessage = this.prefix() + this.formatMessage(message, args);
+    if (this.outputFn) {
+      this.outputFn(formattedMessage, "warn");
+    } else {
+      console.warn(formattedMessage);
+    }
+  }
+  error(message, error) {
+    let formattedMessage = this.prefix() + message;
+    if (error instanceof Error) {
+      formattedMessage += ` ${error.message}`;
+    } else if (error) {
+      formattedMessage += ` ${String(error)}`;
+    }
+    if (this.outputFn) {
+      this.outputFn(formattedMessage, "error");
+    } else {
+      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) {
+    const formattedMessage = "\n" + content + "\n";
+    if (this.outputFn) {
+      this.outputFn(formattedMessage, "info");
+    } else {
+      console.log(formattedMessage);
+    }
+  }
+  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 +1491,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 +1531,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 +1619,7 @@ var WorktreeMetadataService = class {
           }
         } catch {
         }
-        const parentBranch = defaultBranch || "main";
+        const parentBranch = defaultBranch || GIT_CONSTANTS.DEFAULT_BRANCH;
         await this.createInitialMetadataFromPath(
           bareRepoPath,
           worktreePath,
@@ -736,9 +1735,9 @@ var WorktreeError = class extends SyncWorktreesError {
   }
 };
 var WorktreeNotCleanError = class extends WorktreeError {
-  constructor(path9, reasons) {
-    super(`Worktree at '${path9}' is not clean: ${reasons.join(", ")}`, "NOT_CLEAN");
-    this.path = path9;
+  constructor(path11, reasons) {
+    super(`Worktree at '${path11}' is not clean: ${reasons.join(", ")}`, "NOT_CLEAN");
+    this.path = path11;
     this.reasons = reasons;
   }
 };
@@ -853,7 +1852,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 +1950,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 +1999,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 +2020,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 +2042,37 @@ 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;
+  updateLogger(logger) {
+    this.logger = logger;
+  }
   async initialize() {
     const { repoUrl } = this.config;
+    let needsClone = false;
     try {
       await fs4.access(path4.join(this.bareRepoPath, "HEAD"));
-      console.log(`Bare repository at "${this.bareRepoPath}" already exists. Using it.`);
     } catch {
-      console.log(`Cloning from "${repoUrl}" as bare repository into "${this.bareRepoPath}"...`);
+      needsClone = true;
+      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 +2084,12 @@ var GitService = class {
     } catch {
       await bareGit.addConfig("remote.origin.fetch", "+refs/heads/*:refs/remotes/origin/*");
     }
-    console.log("Fetching remote branches...");
-    await bareGit.fetch(["--all"]);
+    if (needsClone) {
+      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}`);
     let needsMainWorktree = true;
     try {
       const worktrees = await this.getWorktreesFromBare(bareGit);
@@ -1091,7 +2097,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 +2105,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 +2121,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 +2145,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.`);
         }
       }
     }
@@ -1153,14 +2159,17 @@ var GitService = class {
     }
     return this.git;
   }
+  isInitialized() {
+    return this.git !== null;
+  }
   getDefaultBranch() {
     return this.defaultBranch;
   }
   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 +2177,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 +2220,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 +2242,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 +2256,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 +2265,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 +2286,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 +2299,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 +2312,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 +2325,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 +2336,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 +2358,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 +2456,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 +2494,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 +2506,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 +2572,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 +2582,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 +2607,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 +2625,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 {
@@ -1626,6 +2654,18 @@ var GitService = class {
       return false;
     }
   }
+  async isLocalAheadOfRemote(worktreePath, branch) {
+    const worktreeGit = simpleGit3(worktreePath);
+    try {
+      const mergeBase = await worktreeGit.raw(["merge-base", "HEAD", `origin/${branch}`]);
+      const mergeBaseSha = mergeBase.trim();
+      const remoteSha = await worktreeGit.revparse([`origin/${branch}`]);
+      const remoteShaTrimmed = remoteSha.trim();
+      return mergeBaseSha === remoteShaTrimmed;
+    } catch {
+      return false;
+    }
+  }
   async compareTreeContent(worktreePath, branch) {
     const worktreeGit = simpleGit3(worktreePath);
     try {
@@ -1633,12 +2673,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 +2690,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) {
@@ -1663,6 +2703,29 @@ var GitService = class {
     const commit = await git.revparse([ref]);
     return commit.trim();
   }
+  async branchExists(branchName) {
+    const bareGit = simpleGit3(this.bareRepoPath);
+    const localBranches = await bareGit.branch();
+    const local = localBranches.all.includes(branchName);
+    const remoteBranches = await bareGit.branch(["-r"]);
+    const remote = remoteBranches.all.includes(`origin/${branchName}`);
+    return { local, remote };
+  }
+  async getLocalBranches() {
+    const bareGit = simpleGit3(this.bareRepoPath);
+    const branches = await bareGit.branch();
+    return branches.all;
+  }
+  async createBranch(branchName, baseBranch) {
+    const bareGit = simpleGit3(this.bareRepoPath);
+    await bareGit.raw(["branch", branchName, `origin/${baseBranch}`]);
+    this.logger.info(`Created branch '${branchName}' from '${baseBranch}'`);
+  }
+  async pushBranch(branchName) {
+    const bareGit = simpleGit3(this.bareRepoPath);
+    await bareGit.push(["origin", `${branchName}:${branchName}`, "-u"]);
+    this.logger.info(`Pushed branch '${branchName}' to remote`);
+  }
   async getWorktreeMetadata(worktreePath) {
     return this.metadataService.loadMetadataFromPath(this.bareRepoPath, worktreePath);
   }
@@ -1678,17 +2741,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,23 +2771,37 @@ 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();
   }
+  isInitialized() {
+    return this.gitService.isInitialized();
+  }
   isSyncInProgress() {
     return this.syncInProgress;
   }
+  getGitService() {
+    return this.gitService;
+  }
+  updateLogger(logger) {
+    this.logger = logger;
+    this.gitService.updateLogger(logger);
+  }
   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 +2811,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 +2831,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 +2847,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 +3070,109 @@ 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) {
+            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;
+            }
+            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 +3190,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 +3250,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 +3271,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,11 +3282,92 @@ 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;
   }
 };
 
+// src/services/file-copy.service.ts
+import * as fs6 from "fs/promises";
+import * as path6 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 = path6.join(sourceDir, relativePath);
+      const destPath = path6.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) {
+    try {
+      await fs6.access(destPath);
+      return false;
+    } catch {
+    }
+    const destDir = path6.dirname(destPath);
+    await fs6.mkdir(destDir, { recursive: true });
+    await fs6.copyFile(sourcePath, destPath);
+    return true;
+  }
+};
+
 // src/utils/disk-space.ts
 import fastFolderSize from "fast-folder-size";
 async function calculateDirectorySize(dirPath) {
@@ -2139,9 +3416,8 @@ var InteractiveUIService = class {
   cronSchedule;
   cronJobs = [];
   repositoryCount;
-  originalConsoleLog;
-  originalConsoleWarn;
-  originalConsoleError;
+  logBuffer = [];
+  uiReady = false;
   constructor(syncServices, configPath, cronSchedule) {
     if (syncServices.length === 0) {
       throw new Error("InteractiveUIService requires at least one WorktreeSyncService");
@@ -2150,31 +3426,52 @@ var InteractiveUIService = class {
     this.configPath = configPath;
     this.cronSchedule = cronSchedule;
     this.repositoryCount = syncServices.length;
-    this.originalConsoleLog = console.log.bind(console);
-    this.originalConsoleWarn = console.warn.bind(console);
-    this.originalConsoleError = console.error.bind(console);
-    this.redirectConsole();
     this.setupCronJobs();
+    this.startBufferFlushCheck();
     this.renderUI();
+    this.injectLoggersIntoServices();
+    setTimeout(() => {
+      this.addLog("\u{1F680} sync-worktrees UI initialized", "info");
+    }, 100);
+  }
+  startBufferFlushCheck() {
+    const unsubscribe = appEvents.on("uiReady", () => {
+      this.uiReady = true;
+      this.flushLogBuffer();
+      unsubscribe();
+    });
   }
-  redirectConsole() {
-    console.log = (...args) => {
-      const message = args.map((arg) => typeof arg === "string" ? arg : JSON.stringify(arg, null, 2)).join(" ");
-      this.originalConsoleLog(message);
-    };
-    console.warn = (...args) => {
-      const message = args.map((arg) => typeof arg === "string" ? arg : JSON.stringify(arg, null, 2)).join(" ");
-      this.originalConsoleWarn(message);
-    };
-    console.error = (...args) => {
-      const message = args.map((arg) => typeof arg === "string" ? arg : JSON.stringify(arg, null, 2)).join(" ");
-      this.originalConsoleError(message);
+  createOutputFn() {
+    return (message, level) => {
+      const uiLevel = level === "debug" ? "info" : level;
+      this.addLog(message, uiLevel);
     };
   }
-  restoreConsole() {
-    console.log = this.originalConsoleLog;
-    console.warn = this.originalConsoleWarn;
-    console.error = this.originalConsoleError;
+  injectLoggersIntoServices() {
+    const outputFn = this.createOutputFn();
+    for (const service of this.syncServices) {
+      const config = service.config;
+      service.updateLogger(
+        new Logger({
+          repoName: config.name,
+          debug: config.debug,
+          outputFn
+        })
+      );
+    }
+  }
+  addLog(message, level = "info") {
+    if (this.uiReady) {
+      appEvents.emit("addLog", { message, level });
+    } else {
+      this.logBuffer.push({ message, level });
+    }
+  }
+  flushLogBuffer() {
+    for (const log of this.logBuffer) {
+      appEvents.emit("addLog", { message: log.message, level: log.level });
+    }
+    this.logBuffer = [];
   }
   setupCronJobs() {
     if (!this.cronSchedule) {
@@ -2188,6 +3485,9 @@ var InteractiveUIService = class {
       const task = cron.schedule(schedule3, async () => {
         this.setStatus("syncing");
         try {
+          if (!service.isInitialized()) {
+            await service.initialize();
+          }
           await service.sync();
         } catch (error) {
           console.error(`Error syncing: ${error.message}`);
@@ -2211,28 +3511,42 @@ var InteractiveUIService = class {
       this.app.unmount();
     }
     this.app = render(
-      /* @__PURE__ */ React4.createElement(
+      /* @__PURE__ */ React7.createElement(
         App_default,
         {
           repositoryCount: this.repositoryCount,
           cronSchedule: this.cronSchedule,
           onManualSync: () => this.handleManualSync(),
           onReload: () => this.handleReload(),
-          onQuit: () => this.handleQuit()
+          onQuit: () => this.handleQuit(),
+          getRepositoryList: () => this.getRepositoryList(),
+          getBranchesForRepo: (index) => this.getBranchesForRepo(index),
+          getDefaultBranchForRepo: (index) => this.getDefaultBranchForRepo(index),
+          createAndPushBranch: (repoIndex, baseBranch, branchName) => this.createAndPushBranch(repoIndex, baseBranch, branchName),
+          getWorktreesForRepo: (index) => this.getWorktreesForRepo(index),
+          openEditorInWorktree: (path11) => this.openEditorInWorktree(path11),
+          copyBranchFiles: (repoIndex, baseBranch, targetBranch) => this.copyBranchFiles(repoIndex, baseBranch, targetBranch),
+          createWorktreeForBranch: (repoIndex, branchName) => this.createWorktreeForBranch(repoIndex, branchName)
         }
       )
     );
   }
   async handleManualSync() {
+    await this.triggerInitialSync();
+  }
+  async triggerInitialSync() {
     this.setStatus("syncing");
     try {
       for (const service of this.syncServices) {
+        if (!service.isInitialized()) {
+          await service.initialize();
+        }
         await service.sync();
       }
       this.updateLastSyncTime();
       await this.calculateAndUpdateDiskSpace();
     } catch (error) {
-      console.error("Manual sync failed:", error);
+      console.error("Sync failed:", error);
     } finally {
       this.setStatus("idle");
     }
@@ -2316,22 +3630,13 @@ var InteractiveUIService = class {
     }
   }
   updateLastSyncTime() {
-    const methods = globalThis.__inkAppMethods;
-    if (methods && methods.updateLastSyncTime) {
-      methods.updateLastSyncTime();
-    }
+    appEvents.emit("updateLastSyncTime");
   }
   setStatus(status) {
-    const methods = globalThis.__inkAppMethods;
-    if (methods && methods.setStatus) {
-      methods.setStatus(status);
-    }
+    appEvents.emit("setStatus", status);
   }
   setDiskSpace(diskSpace) {
-    const methods = globalThis.__inkAppMethods;
-    if (methods && methods.setDiskSpace) {
-      methods.setDiskSpace(diskSpace);
-    }
+    appEvents.emit("setDiskSpace", diskSpace);
   }
   async calculateAndUpdateDiskSpace() {
     try {
@@ -2346,14 +3651,137 @@ var InteractiveUIService = class {
       this.setDiskSpace("N/A");
     }
   }
+  getRepositoryList() {
+    return this.syncServices.map((service, index) => ({
+      index,
+      name: service.config.name || `repo-${index}`,
+      repoUrl: service.config.repoUrl
+    }));
+  }
+  async getBranchesForRepo(repoIndex) {
+    if (repoIndex < 0 || repoIndex >= this.syncServices.length) {
+      throw new Error(`Invalid repository index: ${repoIndex}`);
+    }
+    const service = this.syncServices[repoIndex];
+    const gitService = service.getGitService();
+    return gitService.getRemoteBranches();
+  }
+  getDefaultBranchForRepo(repoIndex) {
+    if (repoIndex < 0 || repoIndex >= this.syncServices.length) {
+      throw new Error(`Invalid repository index: ${repoIndex}`);
+    }
+    const service = this.syncServices[repoIndex];
+    const gitService = service.getGitService();
+    return gitService.getDefaultBranch();
+  }
+  async createAndPushBranch(repoIndex, baseBranch, branchName) {
+    if (repoIndex < 0 || repoIndex >= this.syncServices.length) {
+      return { success: false, finalName: branchName, error: `Invalid repository index: ${repoIndex}` };
+    }
+    const service = this.syncServices[repoIndex];
+    const gitService = service.getGitService();
+    try {
+      let finalName = branchName;
+      let suffix = 0;
+      while (true) {
+        const exists = await gitService.branchExists(finalName);
+        if (!exists.local && !exists.remote) {
+          break;
+        }
+        suffix++;
+        finalName = `${branchName}-${suffix}`;
+      }
+      await gitService.createBranch(finalName, baseBranch);
+      await gitService.pushBranch(finalName);
+      return { success: true, finalName };
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      return { success: false, finalName: branchName, error: errorMessage };
+    }
+  }
+  async getWorktreesForRepo(repoIndex) {
+    if (repoIndex < 0 || repoIndex >= this.syncServices.length) {
+      throw new Error(`Invalid repository index: ${repoIndex}`);
+    }
+    const service = this.syncServices[repoIndex];
+    const gitService = service.getGitService();
+    return gitService.getWorktrees();
+  }
+  async createWorktreeForBranch(repoIndex, branchName) {
+    if (repoIndex < 0 || repoIndex >= this.syncServices.length) {
+      throw new Error(`Invalid repository index: ${repoIndex}`);
+    }
+    const service = this.syncServices[repoIndex];
+    const gitService = service.getGitService();
+    const worktreeDir = service.config.worktreeDir;
+    const worktreePath = path7.join(worktreeDir, branchName);
+    await gitService.addWorktree(branchName, worktreePath);
+  }
+  openEditorInWorktree(worktreePath) {
+    const editor = process.env.EDITOR || process.env.VISUAL || "code";
+    try {
+      const child = spawn(editor, [worktreePath], {
+        detached: true,
+        stdio: "ignore"
+      });
+      child.on("error", (err) => {
+        this.addLog(`Failed to open editor '${editor}': ${err.message}`, "error");
+        this.addLog("Set EDITOR or VISUAL environment variable to your preferred editor", "warn");
+      });
+      child.unref();
+      return { success: true };
+    } catch (err) {
+      const errorMessage = err instanceof Error ? err.message : String(err);
+      this.addLog(`Failed to open editor '${editor}': ${errorMessage}`, "error");
+      return { success: false, error: errorMessage };
+    }
+  }
+  async copyBranchFiles(repoIndex, baseBranch, targetBranch) {
+    if (repoIndex < 0 || repoIndex >= this.syncServices.length) {
+      return;
+    }
+    const service = this.syncServices[repoIndex];
+    const config = service.config;
+    if (!config.filesToCopyOnBranchCreate?.length) {
+      return;
+    }
+    const gitService = service.getGitService();
+    const worktrees = await gitService.getWorktrees();
+    const sourceWorktree = worktrees.find((w) => w.branch === baseBranch);
+    const targetWorktree = worktrees.find((w) => w.branch === targetBranch);
+    if (!sourceWorktree || !targetWorktree) {
+      console.warn(`Could not find worktrees for file copy: source=${baseBranch}, target=${targetBranch}`);
+      return;
+    }
+    const fileCopyService = new FileCopyService();
+    try {
+      const result = await fileCopyService.copyFiles(
+        sourceWorktree.path,
+        targetWorktree.path,
+        config.filesToCopyOnBranchCreate
+      );
+      if (result.copied.length > 0) {
+        console.log(`\u{1F4CB} Copied ${result.copied.length} file(s) to new branch: ${result.copied.join(", ")}`);
+      }
+      if (result.errors.length > 0) {
+        console.warn(`\u26A0\uFE0F Failed to copy ${result.errors.length} file(s):`);
+        for (const err of result.errors) {
+          console.warn(`  - ${err.file}: ${err.error}`);
+        }
+      }
+    } catch (error) {
+      console.error(`Failed to copy files to new branch: ${error}`);
+    }
+  }
   destroy() {
     this.cancelCronJobs();
-    this.restoreConsole();
     if (this.app) {
       this.app.unmount();
       this.app = null;
     }
-    delete globalThis.__inkAppMethods;
+    appEvents.removeAllListeners();
+    this.uiReady = false;
+    this.logBuffer = [];
   }
 };
 
@@ -2412,6 +3840,10 @@ function parseArguments() {
     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,
@@ -2425,7 +3857,8 @@ function parseArguments() {
     branchMaxAge: argv.branchMaxAge,
     skipLfs: argv.skipLfs,
     noUpdateExisting: argv["no-update-existing"],
-    debug: argv.debug
+    debug: argv.debug,
+    syncOnStart: argv["sync-on-start"]
   };
 }
 function isInteractiveMode(config) {
@@ -2463,12 +3896,12 @@ function reconstructCliCommand(config) {
 }
 
 // src/utils/interactive.ts
-import * as path7 from "path";
+import * as path9 from "path";
 import { confirm, input, select } from "@inquirer/prompts";
 
 // src/utils/config-generator.ts
-import * as fs6 from "fs/promises";
-import * as path6 from "path";
+import * as fs7 from "fs/promises";
+import * as path8 from "path";
 function serializeToESM(obj, indent = 0) {
   const spaces = " ".repeat(indent);
   const innerSpaces = " ".repeat(indent + 2);
@@ -2498,9 +3931,9 @@ ${spaces}}`;
   return String(obj);
 }
 async function generateConfigFile(config, configPath) {
-  const configDir = path6.dirname(configPath);
-  await fs6.mkdir(configDir, { recursive: true });
-  const worktreeDirRelative = path6.relative(configDir, config.worktreeDir);
+  const configDir = path8.dirname(configPath);
+  await fs7.mkdir(configDir, { recursive: true });
+  const worktreeDirRelative = path8.relative(configDir, config.worktreeDir);
   const useRelativeWorktree = !worktreeDirRelative.startsWith("../../../");
   const repoName = extractRepoNameFromUrl(config.repoUrl);
   const repository = {
@@ -2509,7 +3942,7 @@ async function generateConfigFile(config, configPath) {
     worktreeDir: useRelativeWorktree ? `./${worktreeDirRelative}` : config.worktreeDir
   };
   if (config.bareRepoDir) {
-    const bareRepoDirRelative = path6.relative(configDir, config.bareRepoDir);
+    const bareRepoDirRelative = path8.relative(configDir, config.bareRepoDir);
     const useRelativeBare = !bareRepoDirRelative.startsWith("../../../");
     repository.bareRepoDir = useRelativeBare ? `./${bareRepoDirRelative}` : config.bareRepoDir;
   }
@@ -2527,10 +3960,10 @@ async function generateConfigFile(config, configPath) {
 
 export default ${serializeToESM(configObject)};
 `;
-  await fs6.writeFile(configPath, configContent, "utf-8");
+  await fs7.writeFile(configPath, configContent, "utf-8");
 }
 function getDefaultConfigPath() {
-  return path6.join(process.cwd(), "sync-worktrees.config.js");
+  return path8.join(process.cwd(), "sync-worktrees.config.js");
 }
 
 // src/utils/interactive.ts
@@ -2572,8 +4005,8 @@ async function promptForConfig(partialConfig) {
     if (!worktreeDir.trim() && defaultWorktreeDir) {
       worktreeDir = defaultWorktreeDir;
     }
-    if (!path7.isAbsolute(worktreeDir)) {
-      worktreeDir = path7.resolve(worktreeDir);
+    if (!path9.isAbsolute(worktreeDir)) {
+      worktreeDir = path9.resolve(worktreeDir);
     }
   }
   let bareRepoDir = partialConfig.bareRepoDir;
@@ -2592,8 +4025,8 @@ async function promptForConfig(partialConfig) {
         return true;
       }
     });
-    if (!path7.isAbsolute(bareRepoDir)) {
-      bareRepoDir = path7.resolve(bareRepoDir);
+    if (!path9.isAbsolute(bareRepoDir)) {
+      bareRepoDir = path9.resolve(bareRepoDir);
     }
   }
   let runOnce = partialConfig.runOnce;
@@ -2664,8 +4097,8 @@ async function promptForConfig(partialConfig) {
         return true;
       }
     });
-    if (!path7.isAbsolute(configPath)) {
-      configPath = path7.resolve(configPath);
+    if (!path9.isAbsolute(configPath)) {
+      configPath = path9.resolve(configPath);
     }
     try {
       await generateConfigFile(finalConfig, configPath);
@@ -2673,7 +4106,7 @@ async function promptForConfig(partialConfig) {
 \u2705 Configuration saved to: ${configPath}`);
       console.log(`
 \u{1F4A1} You can now use this config file with:`);
-      console.log(`   sync-worktrees --config ${path7.relative(process.cwd(), configPath)}`);
+      console.log(`   sync-worktrees --config ${path9.relative(process.cwd(), configPath)}`);
       console.log("");
     } catch (error) {
       console.error(`
@@ -2685,14 +4118,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,43 +4143,76 @@ 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, syncOnStart) {
   const services = /* @__PURE__ */ new Map();
-  console.log(`
+  const globalLogger = Logger.createDefault();
+  const limit = pLimit2(maxParallel ?? DEFAULT_CONFIG.PARALLELISM.MAX_REPOSITORIES);
+  if (runOnce) {
+    globalLogger.info(`
 \u{1F504} Syncing ${repositories.length} repositories...`);
-  for (const repoConfig of repositories) {
-    console.log(`
+    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}`);
+          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 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);
+    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`);
+  } else {
+    for (const repoConfig of repositories) {
+      const syncService = new WorktreeSyncService(repoConfig);
+      services.set(repoConfig.name, syncService);
     }
-  }
-  if (!runOnce) {
     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);
-    uiService.updateLastSyncTime();
     void uiService.calculateAndUpdateDiskSpace();
     const cronJobs = /* @__PURE__ */ new Map();
     for (const repoConfig of repositories) {
@@ -2753,25 +4223,35 @@ 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;
+                uiService.addLog(`Running scheduled sync for: ${repo.name}`);
+                try {
+                  if (!service.isInitialized()) {
+                    await service.initialize();
+                  }
+                  await service.sync();
+                } catch (error) {
+                  uiService.addLog(`Error syncing '${repo.name}': ${error}`, "error");
+                }
+              })
+            )
+          );
           uiService.updateLastSyncTime();
           void uiService.calculateAndUpdateDiskSpace();
         });
       }
     }
-    console.log(`All ${repositories.length} repositories scheduled`);
+    uiService.addLog(`\u{1F4CB} ${repositories.length} repositories configured`);
     for (const [schedule3] of cronJobs) {
       const repoCount = repositories.filter((r) => r.cronSchedule === schedule3).length;
-      console.log(`${schedule3}: ${repoCount} repository(ies)`);
+      uiService.addLog(`\u23F0 ${schedule3}: ${repoCount} repository(ies)`);
+    }
+    if (syncOnStart) {
+      await uiService.triggerInitialSync();
     }
   }
 }
@@ -2779,7 +4259,7 @@ async function listRepositories(configPath, filter) {
   const configLoader = new ConfigLoaderService();
   try {
     const configFile = await configLoader.loadConfigFile(configPath);
-    const configDir = path8.dirname(path8.resolve(configPath));
+    const configDir = path10.dirname(path10.resolve(configPath));
     let repositories = configFile.repositories.map(
       (repo) => configLoader.resolveRepositoryConfig(repo, configFile.defaults, configDir, configFile.retry)
     );
@@ -2820,7 +4300,7 @@ async function main() {
     }
     try {
       const configFile = await configLoader.loadConfigFile(options.config);
-      const configDir = path8.dirname(path8.resolve(options.config));
+      const configDir = path10.dirname(path10.resolve(options.config));
       let repositories = configFile.repositories.map(
         (repo) => configLoader.resolveRepositoryConfig(repo, configFile.defaults, configDir, configFile.retry)
       );
@@ -2844,7 +4324,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, options.syncOnStart);
     } catch (error) {
       if (error instanceof Error && error.message.includes("Config file not found")) {
         console.error(`