sync-worktrees 2.1.0 → 3.0.1

package/dist/mcp-server.js

@@ -0,0 +1,3852 @@
+#!/usr/bin/env node
+
+// src/mcp/index.ts
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+
+// src/mcp/context.ts
+import * as fs7 from "fs/promises";
+import * as path8 from "path";
+import simpleGit4 from "simple-git";
+
+// 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_BRANCH_FETCHES: 3,
+    MAX_SAFE_TOTAL_CONCURRENT_OPS: 100
+  },
+  UPDATE_EXISTING_WORKTREES: true,
+  HOOK_TIMEOUT_MS: 6e4
+};
+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 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";
+import * as path from "path";
+import { pathToFileURL } from "url";
+import * as cron from "node-cron";
+
+// src/utils/branch-filter.ts
+function matchesPattern(name, pattern) {
+  if (pattern.includes("*")) {
+    const escapedPattern = pattern.replace(/[.+?^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*");
+    const regex = new RegExp("^" + escapedPattern + "$");
+    return regex.test(name);
+  }
+  return name === pattern;
+}
+function filterBranchesByName(branches, include, exclude) {
+  let result = branches;
+  if (include && include.length > 0) {
+    result = result.filter((branch) => include.some((pattern) => matchesPattern(branch, pattern)));
+  }
+  if (exclude && exclude.length > 0) {
+    result = result.filter((branch) => !exclude.some((pattern) => matchesPattern(branch, pattern)));
+  }
+  return result;
+}
+
+// src/services/config-loader.service.ts
+var ConfigLoaderService = class {
+  async loadConfigFile(configPath) {
+    const absolutePath = path.resolve(configPath);
+    try {
+      await fs.access(absolutePath);
+    } catch {
+      throw new Error(`Config file not found: ${absolutePath}`);
+    }
+    try {
+      const fileUrl = pathToFileURL(absolutePath);
+      fileUrl.searchParams.set("t", Date.now().toString());
+      const configModule = await import(fileUrl.href);
+      const config = configModule.default;
+      if (!config) {
+        throw new Error("Config file must use 'export default' syntax");
+      }
+      this.validateConfigFile(config);
+      return config;
+    } catch (error) {
+      if (error instanceof Error && error.message.includes("Config file not found")) {
+        throw error;
+      }
+      throw new Error(`Failed to load config file: ${error.message}`);
+    }
+  }
+  validateConfigFile(config) {
+    if (!config || typeof config !== "object") {
+      throw new Error("Config file must export an object");
+    }
+    const configObj = config;
+    if (!Array.isArray(configObj.repositories)) {
+      throw new Error("Config file must have a 'repositories' array");
+    }
+    if (configObj.repositories.length === 0) {
+      throw new Error("Config file must have at least one repository");
+    }
+    const seenNames = /* @__PURE__ */ new Set();
+    configObj.repositories.forEach((repo, index) => {
+      if (!repo || typeof repo !== "object") {
+        throw new Error(`Repository at index ${index} must be an object`);
+      }
+      const repoObj = repo;
+      if (!repoObj.name || typeof repoObj.name !== "string") {
+        throw new Error(`Repository at index ${index} must have a 'name' property`);
+      }
+      if (seenNames.has(repoObj.name)) {
+        throw new Error(`Duplicate repository name: ${repoObj.name}`);
+      }
+      seenNames.add(repoObj.name);
+      if (!repoObj.repoUrl || typeof repoObj.repoUrl !== "string") {
+        throw new Error(`Repository '${repoObj.name}' must have a 'repoUrl' property`);
+      }
+      if (!this.isValidGitUrl(repoObj.repoUrl)) {
+        throw new Error(
+          `Repository '${repoObj.name}' has invalid 'repoUrl': '${repoObj.repoUrl}'. Expected an HTTP(S), SSH, Git protocol URL, or a local/file path (file://, absolute filesystem path)`
+        );
+      }
+      if (!repoObj.worktreeDir || typeof repoObj.worktreeDir !== "string") {
+        throw new Error(`Repository '${repoObj.name}' must have a 'worktreeDir' property`);
+      }
+      if (repoObj.bareRepoDir !== void 0 && typeof repoObj.bareRepoDir !== "string") {
+        throw new Error(`Repository '${repoObj.name}' has invalid 'bareRepoDir' property`);
+      }
+      if (repoObj.cronSchedule !== void 0 && typeof repoObj.cronSchedule !== "string") {
+        throw new Error(`Repository '${repoObj.name}' has invalid 'cronSchedule' property`);
+      }
+      if (typeof repoObj.cronSchedule === "string" && !cron.validate(repoObj.cronSchedule)) {
+        throw new Error(`Repository '${repoObj.name}' has invalid cron expression: '${repoObj.cronSchedule}'`);
+      }
+      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 (repoObj.hooks !== void 0) {
+        this.validateHooksConfig(repoObj.hooks, `Repository '${repoObj.name}'`);
+      }
+    });
+    if (configObj.defaults) {
+      if (typeof configObj.defaults !== "object") {
+        throw new Error("'defaults' must be an object");
+      }
+      const defaults = configObj.defaults;
+      if (defaults.cronSchedule !== void 0 && typeof defaults.cronSchedule !== "string") {
+        throw new Error("Invalid 'cronSchedule' in defaults");
+      }
+      if (typeof defaults.cronSchedule === "string" && !cron.validate(defaults.cronSchedule)) {
+        throw new Error(`Invalid cron expression in defaults: '${defaults.cronSchedule}'`);
+      }
+      if (defaults.runOnce !== void 0 && typeof defaults.runOnce !== "boolean") {
+        throw new Error("Invalid 'runOnce' in defaults");
+      }
+      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 (defaults.hooks !== void 0) {
+        this.validateHooksConfig(defaults.hooks, "defaults");
+      }
+    }
+    if (configObj.retry !== void 0) {
+      if (typeof configObj.retry !== "object") {
+        throw new Error("'retry' must be an object");
+      }
+      const retry2 = configObj.retry;
+      if (retry2.maxAttempts !== void 0) {
+        if (retry2.maxAttempts !== "unlimited" && (typeof retry2.maxAttempts !== "number" || retry2.maxAttempts < 1)) {
+          throw new Error("Invalid 'maxAttempts' in retry config. Must be 'unlimited' or a positive number");
+        }
+      }
+      if (retry2.maxLfsRetries !== void 0) {
+        if (typeof retry2.maxLfsRetries !== "number" || retry2.maxLfsRetries < 0) {
+          throw new Error("Invalid 'maxLfsRetries' in retry config. Must be a non-negative number");
+        }
+      }
+      if (retry2.initialDelayMs !== void 0 && (typeof retry2.initialDelayMs !== "number" || retry2.initialDelayMs < 0)) {
+        throw new Error("Invalid 'initialDelayMs' in retry config");
+      }
+      if (retry2.maxDelayMs !== void 0 && (typeof retry2.maxDelayMs !== "number" || retry2.maxDelayMs < 0)) {
+        throw new Error("Invalid 'maxDelayMs' in retry config");
+      }
+      if (retry2.backoffMultiplier !== void 0 && (typeof retry2.backoffMultiplier !== "number" || retry2.backoffMultiplier < 1)) {
+        throw new Error("Invalid 'backoffMultiplier' in retry config");
+      }
+      const initialDelay = retry2.initialDelayMs ?? DEFAULT_CONFIG.RETRY.INITIAL_DELAY_MS;
+      const maxDelay = retry2.maxDelayMs ?? DEFAULT_CONFIG.RETRY.MAX_DELAY_MS;
+      if (initialDelay > maxDelay) {
+        throw new Error(
+          `Invalid retry config: 'initialDelayMs' (${initialDelay}) must not exceed 'maxDelayMs' (${maxDelay})`
+        );
+      }
+    }
+    if (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;
+    const positiveIntFields = [
+      "maxRepositories",
+      "maxWorktreeCreation",
+      "maxWorktreeUpdates",
+      "maxWorktreeRemoval",
+      "maxStatusChecks",
+      "maxBranchFetches"
+    ];
+    for (const field of positiveIntFields) {
+      const value = config[field];
+      if (value !== void 0 && (typeof value !== "number" || value < 1)) {
+        throw new Error(`Invalid '${field}' 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})`
+        );
+      }
+    }
+  }
+  validateHooksConfig(hooks, context) {
+    if (typeof hooks !== "object" || hooks === null) {
+      throw new Error(`'hooks' in ${context} must be an object`);
+    }
+    const hooksObj = hooks;
+    if (hooksObj.onBranchCreated !== void 0) {
+      if (!Array.isArray(hooksObj.onBranchCreated)) {
+        throw new Error(`'hooks.onBranchCreated' in ${context} must be an array`);
+      }
+      for (let i = 0; i < hooksObj.onBranchCreated.length; i++) {
+        const command = hooksObj.onBranchCreated[i];
+        if (typeof command !== "string" || command.trim() === "") {
+          throw new Error(
+            `'hooks.onBranchCreated' 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 ?? DEFAULT_CONFIG.CRON_SCHEDULE,
+      runOnce: repo.runOnce ?? defaults?.runOnce ?? false
+    };
+    if (repo.bareRepoDir) {
+      resolved.bareRepoDir = this.resolvePath(repo.bareRepoDir, configDir);
+    }
+    if (repo.branchMaxAge || defaults?.branchMaxAge) {
+      resolved.branchMaxAge = repo.branchMaxAge ?? defaults?.branchMaxAge;
+    }
+    if (repo.branchInclude || defaults?.branchInclude) {
+      resolved.branchInclude = repo.branchInclude ?? defaults?.branchInclude;
+    }
+    if (repo.branchExclude || defaults?.branchExclude) {
+      resolved.branchExclude = repo.branchExclude ?? defaults?.branchExclude;
+    }
+    if (repo.skipLfs !== void 0 || defaults?.skipLfs !== void 0) {
+      resolved.skipLfs = repo.skipLfs ?? defaults?.skipLfs ?? false;
+    }
+    if (repo.retry || defaults?.retry || globalRetry) {
+      resolved.retry = {
+        ...globalRetry || {},
+        ...defaults?.retry || {},
+        ...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) {
+      const files = repo.filesToCopyOnBranchCreate ?? defaults?.filesToCopyOnBranchCreate;
+      resolved.filesToCopyOnBranchCreate = files?.map((f) => this.resolvePath(f, configDir));
+    }
+    if (repo.hooks || defaults?.hooks) {
+      resolved.hooks = {
+        ...defaults?.hooks || {},
+        ...repo.hooks || {}
+      };
+    }
+    return resolved;
+  }
+  isValidGitUrl(url) {
+    if (/^https?:\/\/.+/.test(url)) return true;
+    if (/^(ssh:\/\/|git@).+/.test(url)) return true;
+    if (/^git:\/\/.+/.test(url)) return true;
+    if (/^(file:\/\/|\/|[A-Za-z]:\\)/.test(url)) return true;
+    return false;
+  }
+  resolvePath(inputPath, baseDir) {
+    if (path.isAbsolute(inputPath)) {
+      return inputPath;
+    }
+    return path.resolve(baseDir || process.cwd(), inputPath);
+  }
+  filterRepositories(repositories, filter) {
+    if (!filter) {
+      return repositories;
+    }
+    const patterns = filter.split(",").map((p) => p.trim());
+    return repositories.filter((repo) => {
+      return patterns.some((pattern) => matchesPattern(repo.name, pattern));
+    });
+  }
+  async buildRepositories(configPath, overrides) {
+    const configFile = await this.loadConfigFile(configPath);
+    const configDir = path.dirname(path.resolve(configPath));
+    let repositories = configFile.repositories.map(
+      (repo) => this.resolveRepositoryConfig(repo, configFile.defaults, configDir, configFile.retry)
+    );
+    if (overrides?.filter) {
+      repositories = this.filterRepositories(repositories, overrides.filter);
+    }
+    if (overrides?.noUpdateExisting) {
+      repositories = repositories.map((repo) => ({ ...repo, updateExistingWorktrees: false }));
+    }
+    if (overrides?.debug) {
+      repositories = repositories.map((repo) => ({ ...repo, debug: true }));
+    }
+    return { repositories, configFile, configDir };
+  }
+};
+
+// src/services/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 });
+  }
+  withPassthrough(passthrough) {
+    const upstream = this.outputFn;
+    return new _Logger({
+      repoName: this.repoName,
+      debug: this.debugEnabled,
+      outputFn: (msg, level) => {
+        if (upstream) {
+          upstream(msg, level);
+        } else {
+          defaultConsoleOutput(msg, level);
+        }
+        try {
+          passthrough(msg, level);
+        } catch {
+        }
+      }
+    });
+  }
+};
+function defaultConsoleOutput(msg, level) {
+  if (level === "warn") console.warn(msg);
+  else if (level === "error") console.error(msg);
+  else console.log(msg);
+}
+
+// src/services/worktree-sync.service.ts
+import * as fs6 from "fs/promises";
+import * as path7 from "path";
+import pLimit from "p-limit";
+
+// src/utils/date-filter.ts
+function parseDuration(durationStr) {
+  const match = durationStr.match(/^(\d+)([hdwmy])$/);
+  if (!match) {
+    return null;
+  }
+  const value = parseInt(match[1], 10);
+  const unit = match[2];
+  const multipliers = {
+    h: 60 * 60 * 1e3,
+    // hours
+    d: 24 * 60 * 60 * 1e3,
+    // days
+    w: 7 * 24 * 60 * 60 * 1e3,
+    // weeks
+    m: 30 * 24 * 60 * 60 * 1e3,
+    // months (approximate)
+    y: 365 * 24 * 60 * 60 * 1e3
+    // years (approximate)
+  };
+  return value * multipliers[unit];
+}
+function filterBranchesByAge(branches, maxAge) {
+  const maxAgeMs = parseDuration(maxAge);
+  if (maxAgeMs === null) {
+    console.warn(`Invalid duration format: ${maxAge}. Using all branches.`);
+    return branches;
+  }
+  const cutoffDate = new Date(Date.now() - maxAgeMs);
+  return branches.filter(({ lastActivity }) => lastActivity >= cutoffDate);
+}
+function formatDuration(durationStr) {
+  const match = durationStr.match(/^(\d+)([hdwmy])$/);
+  if (!match) {
+    return durationStr;
+  }
+  const value = parseInt(match[1], 10);
+  const unit = match[2];
+  const unitNames = {
+    h: value === 1 ? "hour" : "hours",
+    d: value === 1 ? "day" : "days",
+    w: value === 1 ? "week" : "weeks",
+    m: value === 1 ? "month" : "months",
+    y: value === 1 ? "year" : "years"
+  };
+  return `${value} ${unitNames[unit]}`;
+}
+
+// src/utils/lfs-error.ts
+function getErrorMessage(error) {
+  if (error instanceof Error) {
+    return error.message;
+  }
+  if (error && typeof error === "object" && "message" in error) {
+    return String(error.message);
+  }
+  return String(error);
+}
+var LFS_ERROR_PATTERNS = Object.freeze([
+  "smudge filter lfs failed",
+  "Object does not exist on the server",
+  "external filter 'git-lfs filter-process' failed"
+]);
+function isLfsError(errorMessage) {
+  return LFS_ERROR_PATTERNS.some((pattern) => errorMessage.includes(pattern));
+}
+function isLfsErrorFromError(error) {
+  return isLfsError(getErrorMessage(error));
+}
+
+// src/utils/retry.ts
+var DEFAULT_OPTIONS = {
+  maxAttempts: "unlimited",
+  maxLfsRetries: 2,
+  initialDelayMs: 1e3,
+  maxDelayMs: 6e5,
+  // 10 minutes
+  backoffMultiplier: 2,
+  jitterMs: 0,
+  shouldRetry: (error, context) => {
+    const err = error;
+    if (isLfsErrorFromError(error)) {
+      if (context) {
+        context.isLfsError = true;
+      }
+      return true;
+    }
+    if (err.code === "ENOTFOUND" || err.code === "ECONNREFUSED" || err.code === "ETIMEDOUT") {
+      return true;
+    }
+    if (err.code === "EBUSY" || err.code === "ENOENT" || err.code === "EACCES") {
+      return true;
+    }
+    if (err.message?.includes("Could not read from remote repository")) {
+      return true;
+    }
+    if (err.message?.includes("fatal: unable to access")) {
+      return true;
+    }
+    return false;
+  },
+  onRetry: () => {
+  },
+  lfsRetryHandler: (_context) => {
+  }
+};
+async function retry(fn, options = {}) {
+  const opts = { ...DEFAULT_OPTIONS, ...options };
+  let attempt = 1;
+  let lfsAttempt = 0;
+  const lfsContext = { isLfsError: false };
+  while (true) {
+    try {
+      return await fn();
+    } catch (error) {
+      lfsContext.isLfsError = false;
+      if (!opts.shouldRetry(error, lfsContext)) {
+        throw error;
+      }
+      if (lfsContext.isLfsError) {
+        lfsAttempt++;
+        if (lfsAttempt > opts.maxLfsRetries) {
+          const err = error;
+          throw new Error(
+            `LFS error retry limit exceeded (${opts.maxLfsRetries} attempts). Consider using --skip-lfs option to bypass LFS downloads.`,
+            { cause: err }
+          );
+        }
+      }
+      const isLastAttempt = opts.maxAttempts !== "unlimited" && attempt >= opts.maxAttempts;
+      if (isLastAttempt) {
+        throw error;
+      }
+      if (lfsContext.isLfsError && opts.lfsRetryHandler) {
+        opts.lfsRetryHandler(lfsContext);
+      }
+      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((resolve9) => setTimeout(resolve9, delay));
+      attempt++;
+    }
+  }
+}
+
+// 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";
+import simpleGit3 from "simple-git";
+
+// src/utils/git-url.ts
+function extractRepoNameFromUrl(gitUrl) {
+  const url = gitUrl.trim();
+  const sshMatch = url.match(/^git@[^:]+:(?:.+\/)?([^/]+?)(?:\.git)?$/);
+  if (sshMatch) {
+    return sshMatch[1];
+  }
+  const sshUrlMatch = url.match(/^ssh:\/\/[^/]+\/(?:.+\/)?([^/]+?)(?:\.git)?$/);
+  if (sshUrlMatch) {
+    return sshUrlMatch[1];
+  }
+  const httpsMatch = url.match(/^https?:\/\/[^/]+\/(?:.+\/)?([^/]+?)(?:\.git)?$/);
+  if (httpsMatch) {
+    return httpsMatch[1];
+  }
+  const fileMatch = url.match(/^file:\/\/(?:.+\/)?([^/]+?)(?:\.git)?$/);
+  if (fileMatch) {
+    return fileMatch[1];
+  }
+  throw new Error(`Invalid Git URL format: ${gitUrl}`);
+}
+function getDefaultBareRepoDir(repoUrl, baseDir = ".bare") {
+  const repoName = extractRepoNameFromUrl(repoUrl);
+  return `${baseDir}/${repoName}`;
+}
+
+// src/utils/worktree-list-parser.ts
+function parseWorktreeListPorcelain(output) {
+  const worktrees = [];
+  let current = {};
+  const flush = () => {
+    if (!current.path) {
+      current = {};
+      return;
+    }
+    worktrees.push({
+      path: current.path,
+      branch: current.branch ?? null,
+      head: current.head ?? null,
+      detached: current.detached ?? false,
+      prunable: current.prunable ?? false,
+      locked: current.locked ?? false
+    });
+    current = {};
+  };
+  for (const line of output.split("\n")) {
+    if (line.startsWith("worktree ")) {
+      flush();
+      current.path = line.substring("worktree ".length);
+    } else if (line.startsWith("branch ")) {
+      current.branch = line.substring("branch ".length).replace("refs/heads/", "");
+    } else if (line.startsWith("HEAD ")) {
+      current.head = line.substring("HEAD ".length);
+    } else if (line === "detached") {
+      current.detached = true;
+    } else if (line === "prunable" || line.startsWith("prunable ")) {
+      current.prunable = true;
+    } else if (line === "locked" || line.startsWith("locked ")) {
+      current.locked = true;
+    } else if (line.trim() === "") {
+      flush();
+    }
+  }
+  flush();
+  return worktrees;
+}
+
+// src/services/worktree-metadata.service.ts
+import * as fs2 from "fs/promises";
+import * as path2 from "path";
+import simpleGit from "simple-git";
+var WorktreeMetadataService = class {
+  logger;
+  constructor(logger) {
+    this.logger = logger ?? Logger.createDefault();
+  }
+  /**
+   * Gets the internal worktree directory name from a worktree path.
+   * Git uses the basename of the worktree path as the internal directory name.
+   * For example: /worktrees/fix/test-branch -> test-branch (not fix/test-branch)
+   */
+  getWorktreeDirectoryName(worktreePath) {
+    return path2.basename(worktreePath);
+  }
+  async getMetadataPath(bareRepoPath, worktreeName) {
+    if (worktreeName.includes("/") || worktreeName.includes("\\")) {
+      throw new Error(
+        `getMetadataPath requires a filesystem-safe worktree directory name, got '${worktreeName}'. Use getMetadataPathFromWorktreePath when starting from a raw branch name.`
+      );
+    }
+    return path2.join(
+      bareRepoPath,
+      METADATA_CONSTANTS.WORKTREE_METADATA_PATH,
+      worktreeName,
+      METADATA_CONSTANTS.METADATA_FILENAME
+    );
+  }
+  async getMetadataPathFromWorktreePath(bareRepoPath, worktreePath) {
+    const worktreeDirName = this.getWorktreeDirectoryName(worktreePath);
+    return this.getMetadataPath(bareRepoPath, worktreeDirName);
+  }
+  async saveMetadata(bareRepoPath, worktreeName, metadata) {
+    const metadataPath = await this.getMetadataPath(bareRepoPath, worktreeName);
+    await fs2.mkdir(path2.dirname(metadataPath), { recursive: true });
+    const tmpPath = `${metadataPath}.${process.pid}.${Date.now()}.tmp`;
+    let renamed = false;
+    try {
+      await fs2.writeFile(tmpPath, JSON.stringify(metadata, null, 2), "utf-8");
+      try {
+        await fs2.rename(tmpPath, metadataPath);
+        renamed = true;
+      } catch (err) {
+        if (err.code === ERROR_MESSAGES.EXDEV) {
+          await fs2.copyFile(tmpPath, metadataPath);
+        } else {
+          throw err;
+        }
+      }
+    } finally {
+      if (!renamed) {
+        await fs2.unlink(tmpPath).catch(() => void 0);
+      }
+    }
+  }
+  async loadMetadata(bareRepoPath, worktreeName) {
+    const metadataPath = await this.getMetadataPath(bareRepoPath, worktreeName);
+    try {
+      const content = await fs2.readFile(metadataPath, "utf-8");
+      return JSON.parse(content);
+    } catch {
+      return null;
+    }
+  }
+  async loadMetadataFromPath(bareRepoPath, worktreePath) {
+    const metadataPath = await this.getMetadataPathFromWorktreePath(bareRepoPath, worktreePath);
+    try {
+      const content = await fs2.readFile(metadataPath, "utf-8");
+      const metadata = JSON.parse(content);
+      if (!await this.validateMetadata(metadata)) {
+        this.logger.warn(`Corrupted metadata for ${worktreePath}, treating as missing`);
+        return null;
+      }
+      return metadata;
+    } catch {
+      return null;
+    }
+  }
+  async deleteMetadata(bareRepoPath, worktreeName) {
+    const metadataPath = await this.getMetadataPath(bareRepoPath, worktreeName);
+    try {
+      await fs2.unlink(metadataPath);
+    } catch (error) {
+      if (error.code !== "ENOENT") {
+        throw error;
+      }
+    }
+  }
+  async deleteMetadataFromPath(bareRepoPath, worktreePath) {
+    const metadataPath = await this.getMetadataPathFromWorktreePath(bareRepoPath, worktreePath);
+    try {
+      await fs2.unlink(metadataPath);
+    } catch (error) {
+      if (error.code !== "ENOENT") {
+        throw error;
+      }
+    }
+  }
+  async updateLastSync(bareRepoPath, worktreeName, commit, action = "updated") {
+    const existing = await this.loadMetadata(bareRepoPath, worktreeName);
+    if (!existing) {
+      this.logger.warn(
+        `No metadata found for worktree ${worktreeName}; skipping update because upstream/parent context is unavailable`
+      );
+      return;
+    }
+    existing.lastSyncCommit = commit;
+    existing.lastSyncDate = (/* @__PURE__ */ new Date()).toISOString();
+    existing.syncHistory.push({
+      date: existing.lastSyncDate,
+      commit,
+      action
+    });
+    if (existing.syncHistory.length > METADATA_CONSTANTS.MAX_HISTORY_ENTRIES) {
+      existing.syncHistory = existing.syncHistory.slice(-METADATA_CONSTANTS.MAX_HISTORY_ENTRIES);
+    }
+    await this.saveMetadata(bareRepoPath, worktreeName, existing);
+  }
+  async updateLastSyncFromPath(bareRepoPath, worktreePath, commit, action = "updated", defaultBranch) {
+    const worktreeDirName = this.getWorktreeDirectoryName(worktreePath);
+    const existing = await this.loadMetadataFromPath(bareRepoPath, worktreePath);
+    if (!existing) {
+      this.logger.warn(`No metadata found for worktree ${worktreeDirName}`);
+      this.logger.info(`  Attempting to create initial metadata...`);
+      try {
+        const worktreeGit = simpleGit(worktreePath);
+        const currentCommit = await worktreeGit.revparse(["HEAD"]);
+        const branchSummary = await worktreeGit.branch();
+        const actualBranchName = branchSummary.current;
+        if (!actualBranchName) {
+          throw new Error("Could not determine current branch name");
+        }
+        let upstreamBranch = `origin/${actualBranchName}`;
+        try {
+          const configuredUpstream = await worktreeGit.raw([
+            "rev-parse",
+            "--abbrev-ref",
+            `${actualBranchName}@{upstream}`
+          ]);
+          if (configuredUpstream.trim()) {
+            upstreamBranch = configuredUpstream.trim();
+          }
+        } catch {
+        }
+        const parentBranch = defaultBranch || GIT_CONSTANTS.DEFAULT_BRANCH;
+        await this.createInitialMetadataFromPath(
+          bareRepoPath,
+          worktreePath,
+          currentCommit.trim(),
+          upstreamBranch,
+          parentBranch,
+          currentCommit.trim()
+        );
+        this.logger.info(`  \u2705 Created metadata for ${worktreeDirName}`);
+        return;
+      } catch (error) {
+        this.logger.error(`  \u274C Failed to create metadata`, error);
+        throw error;
+      }
+    }
+    existing.lastSyncCommit = commit;
+    existing.lastSyncDate = (/* @__PURE__ */ new Date()).toISOString();
+    existing.syncHistory.push({
+      date: existing.lastSyncDate,
+      commit,
+      action
+    });
+    if (existing.syncHistory.length > METADATA_CONSTANTS.MAX_HISTORY_ENTRIES) {
+      existing.syncHistory = existing.syncHistory.slice(-METADATA_CONSTANTS.MAX_HISTORY_ENTRIES);
+    }
+    await this.saveMetadata(bareRepoPath, worktreeDirName, existing);
+  }
+  async createInitialMetadata(bareRepoPath, worktreeName, commit, upstreamBranch, parentBranch, parentCommit) {
+    const metadata = {
+      lastSyncCommit: commit,
+      lastSyncDate: (/* @__PURE__ */ new Date()).toISOString(),
+      upstreamBranch,
+      createdFrom: {
+        branch: parentBranch,
+        commit: parentCommit
+      },
+      syncHistory: [
+        {
+          date: (/* @__PURE__ */ new Date()).toISOString(),
+          commit,
+          action: "created"
+        }
+      ]
+    };
+    await this.saveMetadata(bareRepoPath, worktreeName, metadata);
+  }
+  async createInitialMetadataFromPath(bareRepoPath, worktreePath, commit, upstreamBranch, parentBranch, parentCommit) {
+    const worktreeDirName = this.getWorktreeDirectoryName(worktreePath);
+    const metadata = {
+      lastSyncCommit: commit,
+      lastSyncDate: (/* @__PURE__ */ new Date()).toISOString(),
+      upstreamBranch,
+      createdFrom: {
+        branch: parentBranch,
+        commit: parentCommit
+      },
+      syncHistory: [
+        {
+          date: (/* @__PURE__ */ new Date()).toISOString(),
+          commit,
+          action: "created"
+        }
+      ]
+    };
+    await this.saveMetadata(bareRepoPath, worktreeDirName, metadata);
+  }
+  async validateMetadata(metadata) {
+    if (!metadata.lastSyncCommit || !metadata.lastSyncDate || !metadata.upstreamBranch) {
+      return false;
+    }
+    if (!/^[0-9a-f]+$/i.test(metadata.lastSyncCommit)) {
+      return false;
+    }
+    if (Number.isNaN(new Date(metadata.lastSyncDate).getTime())) {
+      return false;
+    }
+    return true;
+  }
+};
+
+// src/services/worktree-status.service.ts
+import * as fs3 from "fs/promises";
+import * as path3 from "path";
+import simpleGit2 from "simple-git";
+
+// src/errors/index.ts
+var SyncWorktreesError = class extends Error {
+  constructor(message, code, cause) {
+    super(message);
+    this.code = code;
+    this.cause = cause;
+    this.name = this.constructor.name;
+    Object.setPrototypeOf(this, new.target.prototype);
+    if (cause && cause.stack) {
+      this.stack = `${this.stack}
+Caused by: ${cause.stack}`;
+    }
+  }
+};
+var GitError = class extends SyncWorktreesError {
+  constructor(message, code, cause) {
+    super(message, `GIT_${code}`, cause);
+  }
+};
+var GitOperationError = class extends GitError {
+  constructor(operation, details, cause) {
+    super(`Git operation '${operation}' failed: ${details}`, "OPERATION_FAILED", cause);
+  }
+};
+var WorktreeError = class extends SyncWorktreesError {
+  constructor(message, code, cause) {
+    super(message, `WORKTREE_${code}`, cause);
+  }
+};
+var WorktreeNotCleanError = class extends WorktreeError {
+  constructor(path10, reasons) {
+    super(`Worktree at '${path10}' is not clean: ${reasons.join(", ")}`, "NOT_CLEAN");
+    this.path = path10;
+    this.reasons = reasons;
+  }
+};
+
+// src/services/worktree-status.service.ts
+var OPERATION_FILES = [
+  { file: GIT_OPERATIONS.MERGE_HEAD, type: "merge" },
+  { file: GIT_OPERATIONS.CHERRY_PICK_HEAD, type: "cherry-pick" },
+  { file: GIT_OPERATIONS.REVERT_HEAD, type: "revert" },
+  { file: GIT_OPERATIONS.BISECT_LOG, type: "bisect" },
+  { file: GIT_OPERATIONS.REBASE_MERGE, type: "rebase" },
+  { file: GIT_OPERATIONS.REBASE_APPLY, type: "rebase (apply)" }
+];
+var WorktreeStatusService = class {
+  constructor(config = {}, logger) {
+    this.config = config;
+    this.logger = logger ?? Logger.createDefault();
+  }
+  gitInstances = /* @__PURE__ */ new Map();
+  logger;
+  async checkWorktreeStatus(worktreePath) {
+    const worktreeGit = this.createGitInstance(worktreePath);
+    const status = await worktreeGit.status();
+    const hasTrackedChanges = status.modified.length > 0 || status.deleted.length > 0 || status.renamed.length > 0 || status.created.length > 0 || status.conflicted.length > 0;
+    if (hasTrackedChanges) {
+      return false;
+    }
+    if (status.not_added.length > 0) {
+      const untrackedFiles = status.not_added;
+      const notIgnoredFiles = await this.filterUntrackedFiles(worktreePath, untrackedFiles);
+      return notIgnoredFiles.length === 0;
+    }
+    return true;
+  }
+  async getFullWorktreeStatus(worktreePath, includeDetails = false, lastSyncCommit) {
+    try {
+      await fs3.access(worktreePath);
+    } catch {
+      return {
+        isClean: true,
+        hasUnpushedCommits: false,
+        hasStashedChanges: false,
+        hasOperationInProgress: false,
+        hasModifiedSubmodules: false,
+        upstreamGone: false,
+        canRemove: true,
+        reasons: []
+      };
+    }
+    const snap = await this.collectSnapshot(worktreePath, lastSyncCommit);
+    const isClean = this.deriveIsClean(snap);
+    const hasUnpushedCommits = !snap.detached && (snap.unpushedCount ?? 1) > 0;
+    const hasStashedChanges = snap.stashTotal === null ? true : snap.stashTotal > 0;
+    const hasOperationInProgress = snap.gitDir === null ? true : snap.operationFile !== null;
+    const hasModifiedSubmodules = this.deriveModifiedSubmodules(snap).length > 0 || snap.submoduleStatus === null;
+    const upstreamGone = !snap.detached && snap.upstream !== null && snap.remoteBranches.length > 0 ? !snap.remoteBranches.includes(snap.upstream) : false;
+    const reasons = [];
+    if (!isClean) reasons.push("uncommitted changes");
+    if (hasUnpushedCommits) reasons.push("unpushed commits");
+    if (hasOperationInProgress) reasons.push("operation in progress");
+    if (hasModifiedSubmodules) reasons.push("modified submodules");
+    const canRemove = isClean && !hasUnpushedCommits && !hasOperationInProgress && !hasModifiedSubmodules;
+    const details = includeDetails ? this.buildStatusDetails(snap) : void 0;
+    return {
+      isClean,
+      hasUnpushedCommits,
+      hasStashedChanges,
+      hasOperationInProgress,
+      hasModifiedSubmodules,
+      upstreamGone,
+      canRemove,
+      reasons,
+      details
+    };
+  }
+  async collectSnapshot(worktreePath, lastSyncCommit) {
+    const git = this.createGitInstance(worktreePath);
+    const [status, branchResult, remoteBranchesResult, stashResult, submoduleResult, gitDirResult] = await Promise.all([
+      git.status().catch((e) => {
+        this.logger.error(`Error reading status for ${worktreePath}`, e);
+        return null;
+      }),
+      git.branch().catch(() => null),
+      git.branch(["-r"]).catch(() => null),
+      git.stashList().catch((e) => {
+        this.logger.error(`Error checking stash`, e);
+        return null;
+      }),
+      git.raw(["submodule", "status"]).catch((e) => {
+        this.logger.error(`Error checking submodule status`, e);
+        return null;
+      }),
+      this.resolveGitDir(worktreePath).catch((e) => {
+        this.logger.error(`Error checking operation in progress for ${worktreePath}`, e);
+        return null;
+      })
+    ]);
+    const currentBranch = branchResult?.current ?? null;
+    const detached = !branchResult?.current || Boolean(branchResult?.detached);
+    let upstream = null;
+    let unpushedCount = null;
+    if (!detached && currentBranch) {
+      const revListArgs = lastSyncCommit ? ["rev-list", "--count", `${lastSyncCommit}..HEAD`] : ["rev-list", "--count", currentBranch, "--not", "--remotes"];
+      const [upstreamResult, unpushedResult] = await Promise.all([
+        git.raw(["rev-parse", "--abbrev-ref", `${currentBranch}@{upstream}`]).then(
+          (raw) => ({ ok: true, value: raw }),
+          (error) => ({ ok: false, error })
+        ),
+        git.raw(revListArgs).then(
+          (raw) => ({ ok: true, value: raw }),
+          (error) => ({ ok: false, error })
+        )
+      ]);
+      if (upstreamResult.ok) {
+        upstream = upstreamResult.value.trim() || null;
+      } else {
+        const errorMessage = getErrorMessage(upstreamResult.error);
+        if (!errorMessage.includes("fatal: no upstream configured") && !errorMessage.includes("no upstream configured for branch") && !errorMessage.includes("fatal: ambiguous argument") && !errorMessage.includes("unknown revision or path")) {
+          this.logger.error(`Unexpected error checking upstream status for ${worktreePath}: ${errorMessage}`);
+        }
+      }
+      if (unpushedResult.ok) {
+        unpushedCount = parseInt(unpushedResult.value.trim(), 10);
+      } else {
+        this.logger.error(`Error checking unpushed commits`, unpushedResult.error);
+      }
+    }
+    const operationFile = gitDirResult ? await this.detectOperationFile(gitDirResult) : null;
+    let untrackedNotIgnored = [];
+    if (status && status.not_added.length > 0) {
+      try {
+        untrackedNotIgnored = await this.filterUntrackedFiles(worktreePath, status.not_added);
+      } catch {
+        untrackedNotIgnored = status.not_added;
+      }
+    }
+    return {
+      exists: true,
+      status,
+      currentBranch,
+      detached,
+      remoteBranches: remoteBranchesResult?.all ?? [],
+      upstream,
+      unpushedCount,
+      stashTotal: stashResult?.total ?? null,
+      submoduleStatus: submoduleResult,
+      operationFile,
+      gitDir: gitDirResult,
+      untrackedNotIgnored
+    };
+  }
+  deriveIsClean(snap) {
+    const status = snap.status;
+    if (!status) return false;
+    const hasTracked = status.modified.length > 0 || status.deleted.length > 0 || status.renamed.length > 0 || status.created.length > 0 || status.conflicted.length > 0;
+    if (hasTracked) return false;
+    return snap.untrackedNotIgnored.length === 0;
+  }
+  deriveModifiedSubmodules(snap) {
+    if (!snap.submoduleStatus) return [];
+    const modified = [];
+    for (const line of snap.submoduleStatus.split("\n").filter((l) => l.trim())) {
+      const firstChar = line.charAt(0);
+      if (firstChar === GIT_CONSTANTS.SUBMODULE_STATUS_ADDED || firstChar === GIT_CONSTANTS.SUBMODULE_STATUS_REMOVED) {
+        const match = line.match(/^[+-]\s*(\S+)/);
+        if (match) modified.push(match[1]);
+      }
+    }
+    return modified;
+  }
+  buildStatusDetails(snap) {
+    const status = snap.status;
+    const details = {
+      modifiedFiles: status?.modified.length ?? 0,
+      deletedFiles: status?.deleted.length ?? 0,
+      renamedFiles: status?.renamed.length ?? 0,
+      createdFiles: status?.created.length ?? 0,
+      conflictedFiles: status?.conflicted.length ?? 0,
+      untrackedFiles: snap.untrackedNotIgnored.length
+    };
+    if (status) {
+      if (status.modified.length > 0) details.modifiedFilesList = status.modified;
+      if (status.deleted.length > 0) details.deletedFilesList = status.deleted;
+      if (status.renamed.length > 0) {
+        details.renamedFilesList = status.renamed.map((r) => ({ from: r.from, to: r.to }));
+      }
+      if (status.created.length > 0) details.createdFilesList = status.created;
+      if (status.conflicted.length > 0) details.conflictedFilesList = status.conflicted;
+    }
+    if (snap.untrackedNotIgnored.length > 0) details.untrackedFilesList = snap.untrackedNotIgnored;
+    if (!snap.detached && snap.unpushedCount !== null) details.unpushedCommitCount = snap.unpushedCount;
+    if (snap.stashTotal !== null) details.stashCount = snap.stashTotal;
+    const opType = this.operationTypeFromFile(snap.operationFile);
+    if (opType) details.operationType = opType;
+    const modSubs = this.deriveModifiedSubmodules(snap);
+    if (modSubs.length > 0) details.modifiedSubmodules = modSubs;
+    return details;
+  }
+  operationTypeFromFile(file) {
+    if (!file) return void 0;
+    return OPERATION_FILES.find((op) => op.file === file)?.type;
+  }
+  async detectOperationFile(gitDir) {
+    const results = await Promise.all(
+      OPERATION_FILES.map(
+        ({ file }) => fs3.access(path3.join(gitDir, file)).then(
+          () => true,
+          () => false
+        )
+      )
+    );
+    const idx = results.findIndex(Boolean);
+    return idx >= 0 ? OPERATION_FILES[idx].file : null;
+  }
+  async hasUnpushedCommits(worktreePath, lastSyncCommit) {
+    const worktreeGit = this.createGitInstance(worktreePath);
+    try {
+      if (await this.isDetachedHead(worktreeGit)) {
+        return false;
+      }
+      const branchSummary = await worktreeGit.branch();
+      const currentBranch = branchSummary.current;
+      if (lastSyncCommit) {
+        try {
+          const newCommitsResult = await worktreeGit.raw(["rev-list", "--count", `${lastSyncCommit}..HEAD`]);
+          const newCommitsCount = parseInt(newCommitsResult.trim(), 10);
+          return newCommitsCount > 0;
+        } catch {
+        }
+      }
+      const result = await worktreeGit.raw(["rev-list", "--count", currentBranch, "--not", "--remotes"]);
+      const unpushedCount = parseInt(result.trim(), 10);
+      return unpushedCount > 0;
+    } catch (error) {
+      this.logger.error(`Error checking unpushed commits`, error);
+      return true;
+    }
+  }
+  async hasUpstreamGone(worktreePath) {
+    const worktreeGit = this.createGitInstance(worktreePath);
+    try {
+      if (await this.isDetachedHead(worktreeGit)) {
+        return false;
+      }
+      const branchSummary = await worktreeGit.branch();
+      const currentBranch = branchSummary.current;
+      const upstream = await worktreeGit.raw(["rev-parse", "--abbrev-ref", `${currentBranch}@{upstream}`]);
+      const remoteBranches = await worktreeGit.branch(["-r"]);
+      return !remoteBranches.all.includes(upstream.trim());
+    } catch (error) {
+      const errorMessage = getErrorMessage(error);
+      if (errorMessage.includes("fatal: no upstream configured") || errorMessage.includes("no upstream configured for branch") || errorMessage.includes("fatal: ambiguous argument") || errorMessage.includes("unknown revision or path")) {
+        return false;
+      }
+      this.logger.error(`Unexpected error checking upstream status for ${worktreePath}: ${errorMessage}`);
+      return true;
+    }
+  }
+  async hasStashedChanges(worktreePath) {
+    const worktreeGit = this.createGitInstance(worktreePath);
+    try {
+      const stashList = await worktreeGit.stashList();
+      return stashList.total > 0;
+    } catch (error) {
+      this.logger.error(`Error checking stash`, error);
+      return true;
+    }
+  }
+  async hasModifiedSubmodules(worktreePath) {
+    const worktreeGit = this.createGitInstance(worktreePath);
+    try {
+      const result = await worktreeGit.raw(["submodule", "status"]);
+      const lines = result.split("\n").filter((line) => line.trim());
+      for (const line of lines) {
+        const firstChar = line.charAt(0);
+        if (firstChar === GIT_CONSTANTS.SUBMODULE_STATUS_ADDED || firstChar === GIT_CONSTANTS.SUBMODULE_STATUS_REMOVED) {
+          return true;
+        }
+      }
+      return false;
+    } catch (error) {
+      this.logger.error(`Error checking submodule status`, error);
+      return true;
+    }
+  }
+  async hasOperationInProgress(worktreePath) {
+    try {
+      const gitDir = await this.resolveGitDir(worktreePath);
+      return await this.detectOperationFile(gitDir) !== null;
+    } catch (error) {
+      this.logger.error(`Error checking operation in progress for ${worktreePath}`, error);
+      return true;
+    }
+  }
+  async validateWorktreeForRemoval(worktreePath, lastSyncCommit) {
+    const status = await this.getFullWorktreeStatus(worktreePath, false, lastSyncCommit);
+    if (!status.canRemove) {
+      throw new WorktreeNotCleanError(worktreePath, status.reasons);
+    }
+  }
+  async filterUntrackedFiles(worktreePath, files) {
+    if (files.length === 0) return [];
+    const worktreeGit = this.createGitInstance(worktreePath);
+    try {
+      const result = await worktreeGit.raw(["check-ignore", "--", ...files]);
+      const ignoredFiles = new Set(
+        result.trim().split("\n").filter((f) => f)
+      );
+      return files.filter((f) => !ignoredFiles.has(f));
+    } catch (error) {
+      const errorMessage = getErrorMessage(error);
+      if (errorMessage.includes(GIT_CONSTANTS.GIT_CHECK_IGNORE_NO_MATCH)) {
+        return files;
+      }
+      throw error;
+    }
+  }
+  async isDetachedHead(worktreeGit) {
+    try {
+      const branchSummary = await worktreeGit.branch();
+      return !branchSummary.current || branchSummary.detached;
+    } catch {
+      return true;
+    }
+  }
+  async resolveGitDir(worktreePath) {
+    const gitPath = path3.join(worktreePath, PATH_CONSTANTS.GIT_DIR);
+    try {
+      const stat4 = await fs3.stat(gitPath);
+      if (stat4.isFile()) {
+        const content = await fs3.readFile(gitPath, "utf-8");
+        const gitdirMatch = content.match(new RegExp(`^${GIT_CONSTANTS.GITDIR_PREFIX}\\s*(.+)$`, "m"));
+        if (gitdirMatch) {
+          return path3.resolve(worktreePath, gitdirMatch[1].trim());
+        }
+        throw new GitOperationError("resolve-git-dir", `Failed to parse gitdir from .git file at ${gitPath}`);
+      }
+      return gitPath;
+    } catch (error) {
+      throw new GitOperationError(
+        "resolve-git-dir",
+        `Failed to resolve .git directory for ${worktreePath}`,
+        error instanceof Error ? error : void 0
+      );
+    }
+  }
+  createGitInstance(worktreePath) {
+    const key = `${path3.resolve(worktreePath)}::${this.config.skipLfs ? "1" : "0"}`;
+    let git = this.gitInstances.get(key);
+    if (!git) {
+      git = this.config.skipLfs ? simpleGit2(worktreePath).env({ [ENV_CONSTANTS.GIT_LFS_SKIP_SMUDGE]: "1" }) : simpleGit2(worktreePath);
+      this.gitInstances.set(key, git);
+    }
+    return git;
+  }
+};
+
+// src/services/git.service.ts
+var GitService = class {
+  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, GIT_CONSTANTS.DEFAULT_BRANCH);
+    this.metadataService = new WorktreeMetadataService(this.logger);
+    this.statusService = new WorktreeStatusService({ skipLfs: this.config.skipLfs }, this.logger);
+  }
+  git = null;
+  bareRepoPath;
+  mainWorktreePath;
+  defaultBranch = GIT_CONSTANTS.DEFAULT_BRANCH;
+  // Will be updated after detection
+  metadataService;
+  statusService;
+  logger;
+  lfsSkipOverride = false;
+  gitInstances = /* @__PURE__ */ new Map();
+  getCachedGit(dirPath, useLfsSkip = false) {
+    const key = `${path4.resolve(dirPath)}::${useLfsSkip ? "1" : "0"}`;
+    let git = this.gitInstances.get(key);
+    if (!git) {
+      git = useLfsSkip ? simpleGit3(dirPath).env({ [ENV_CONSTANTS.GIT_LFS_SKIP_SMUDGE]: "1" }) : simpleGit3(dirPath);
+      this.gitInstances.set(key, git);
+    }
+    return git;
+  }
+  updateLogger(logger) {
+    this.logger = logger;
+  }
+  async initialize() {
+    const { repoUrl } = this.config;
+    try {
+      await fs4.access(path4.join(this.bareRepoPath, "HEAD"));
+    } catch {
+      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({ [ENV_CONSTANTS.GIT_LFS_SKIP_SMUDGE]: "1" }) : simpleGit3();
+      await cloneGit.clone(repoUrl, this.bareRepoPath, ["--bare"]);
+      this.logger.info("\u2705 Clone successful.");
+    }
+    const bareGit = this.getCachedGit(this.bareRepoPath);
+    try {
+      const existingConfig = await bareGit.raw(["config", "--get-all", "remote.origin.fetch"]);
+      const targetConfig = "+refs/heads/*:refs/remotes/origin/*";
+      if (!existingConfig.includes(targetConfig)) {
+        await bareGit.addConfig("remote.origin.fetch", targetConfig);
+      }
+    } catch {
+      await bareGit.addConfig("remote.origin.fetch", "+refs/heads/*:refs/remotes/origin/*");
+    }
+    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);
+    let needsMainWorktree = true;
+    try {
+      const worktrees = await this.getWorktreesFromBare(bareGit);
+      needsMainWorktree = !worktrees.some((w) => path4.resolve(w.path) === path4.resolve(this.mainWorktreePath));
+    } catch {
+    }
+    if (needsMainWorktree) {
+      this.logger.info(`Creating ${this.defaultBranch} worktree at "${this.mainWorktreePath}"...`);
+      await fs4.mkdir(this.config.worktreeDir, { recursive: true });
+      const absoluteWorktreePath = path4.resolve(this.mainWorktreePath);
+      const branches = await bareGit.branch();
+      const defaultBranchExists = branches.all.includes(this.defaultBranch);
+      try {
+        if (defaultBranchExists) {
+          await bareGit.raw(["worktree", "add", absoluteWorktreePath, this.defaultBranch]);
+          const worktreeGit = this.getCachedGit(absoluteWorktreePath, this.isLfsSkipEnabled());
+          await worktreeGit.branch(["--set-upstream-to", `origin/${this.defaultBranch}`, this.defaultBranch]);
+        } else {
+          await bareGit.raw([
+            "worktree",
+            "add",
+            "--track",
+            "-b",
+            this.defaultBranch,
+            absoluteWorktreePath,
+            `origin/${this.defaultBranch}`
+          ]);
+        }
+      } catch (error) {
+        const errorMessage = getErrorMessage(error);
+        if (errorMessage.includes("already exists")) {
+          this.logger.info(
+            `${this.defaultBranch} worktree directory already exists at '${absoluteWorktreePath}', skipping creation.`
+          );
+        } else {
+          throw error;
+        }
+      }
+      const updatedWorktrees = await this.getWorktreesFromBare(bareGit);
+      const mainWorktreeRegistered = updatedWorktrees.some(
+        (w) => path4.resolve(w.path) === path4.resolve(this.mainWorktreePath)
+      );
+      if (!mainWorktreeRegistered) {
+        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.`);
+        }
+      }
+    }
+    this.git = this.getCachedGit(this.mainWorktreePath);
+    return this.git;
+  }
+  getGit() {
+    if (!this.git) {
+      throw new Error("Git service not initialized. Call initialize() first.");
+    }
+    return this.git;
+  }
+  isInitialized() {
+    return this.git !== null;
+  }
+  getDefaultBranch() {
+    return this.defaultBranch;
+  }
+  async fetchAll() {
+    this.assertInitialized();
+    this.logger.info("Fetching latest data from remote...");
+    const git = this.getCachedGit(this.mainWorktreePath, this.isLfsSkipEnabled());
+    await git.fetch(["--all", "--prune"]);
+  }
+  async fetchBranch(branchName) {
+    this.assertInitialized();
+    const git = this.getCachedGit(this.mainWorktreePath, this.isLfsSkipEnabled());
+    await git.fetch(["origin", branchName, "--prune"]);
+  }
+  assertInitialized() {
+    if (!this.git) {
+      throw new Error("Git service not initialized. Call initialize() first.");
+    }
+  }
+  async getRemoteBranches() {
+    const git = this.getGit();
+    const branches = await git.branch(["-r"]);
+    return branches.all.filter((b) => b.startsWith("origin/") && !b.endsWith("/HEAD")).map((b) => b.replace("origin/", "")).filter((b) => b !== "origin" && b.length > 0);
+  }
+  async getRemoteBranchesWithActivity() {
+    const git = this.getGit();
+    const result = await git.raw([
+      "for-each-ref",
+      "--format=%(refname:short)|%(committerdate:iso8601)",
+      "refs/remotes/origin"
+    ]);
+    const branches = [];
+    const lines = result.trim().split("\n").filter((line) => line);
+    for (const line of lines) {
+      const [ref, dateStr] = line.split("|", 2);
+      if (ref && dateStr && !ref.endsWith("/HEAD")) {
+        const branch = ref.replace("origin/", "");
+        if (branch === "origin" || branch.length === 0) {
+          continue;
+        }
+        const lastActivity = new Date(dateStr);
+        if (!isNaN(lastActivity.getTime())) {
+          branches.push({ branch, lastActivity });
+        }
+      }
+    }
+    return branches;
+  }
+  async verifyLfsFilesDownloaded(worktreePath, branchName) {
+    const worktreeGit = this.getCachedGit(worktreePath);
+    try {
+      const lfsFiles = await worktreeGit.raw(["lfs", "ls-files", "--name-only"]);
+      const lfsFileList = lfsFiles.trim().split("\n").filter((f) => f.length > 0);
+      if (lfsFileList.length === 0) {
+        return;
+      }
+      if (this.config.debug) {
+        this.logger.info(`  - Verifying ${lfsFileList.length} LFS files are downloaded...`);
+      }
+      const sampleSize = Math.min(5, lfsFileList.length);
+      const samplesToCheck = [];
+      for (let i = 0; i < sampleSize; i++) {
+        const randomIndex = Math.floor(Math.random() * lfsFileList.length);
+        samplesToCheck.push(lfsFileList[randomIndex]);
+      }
+      let retries = 0;
+      const maxRetries = 30;
+      const retryDelay = 1e3;
+      while (retries < maxRetries) {
+        let allDownloaded = true;
+        const notDownloaded = [];
+        for (const file of samplesToCheck) {
+          const filePath = path4.join(worktreePath, file);
+          try {
+            const handle = await fs4.open(filePath, "r");
+            try {
+              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(GIT_CONSTANTS.LFS_HEADER)) {
+                allDownloaded = false;
+                notDownloaded.push(file);
+              }
+            } finally {
+              await handle.close();
+            }
+          } catch {
+            allDownloaded = false;
+            notDownloaded.push(file);
+          }
+        }
+        if (allDownloaded) {
+          if (this.config.debug) {
+            this.logger.info(`  - \u2705 LFS files verified (${samplesToCheck.length} samples checked)`);
+          }
+          return;
+        }
+        retries++;
+        if (retries < maxRetries) {
+          await new Promise((resolve9) => setTimeout(resolve9, retryDelay));
+        }
+      }
+      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) {
+      this.logger.warn(`  - \u26A0\uFE0F Warning: Could not verify LFS files for '${branchName}': ${error}`);
+    }
+  }
+  async createWorktreeMetadata(bareGit, worktreePath, branchName) {
+    try {
+      const worktreeGit = this.getCachedGit(worktreePath, this.isLfsSkipEnabled());
+      const currentCommit = await worktreeGit.revparse(["HEAD"]);
+      const parentCommit = await bareGit.revparse([this.defaultBranch]);
+      await this.metadataService.createInitialMetadataFromPath(
+        this.bareRepoPath,
+        worktreePath,
+        currentCommit.trim(),
+        `origin/${branchName}`,
+        this.defaultBranch,
+        parentCommit.trim()
+      );
+    } catch (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.getCachedGit(this.bareRepoPath, this.isLfsSkipEnabled());
+    const absoluteWorktreePath = path4.resolve(worktreePath);
+    await fs4.mkdir(path4.dirname(absoluteWorktreePath), { recursive: true });
+    try {
+      await fs4.access(absoluteWorktreePath);
+      const worktrees = await this.getWorktreesFromBare(bareGit);
+      const isValidWorktree = worktrees.some((w) => path4.resolve(w.path) === absoluteWorktreePath);
+      if (isValidWorktree) {
+        this.logger.info(`  - Worktree for '${branchName}' already exists at '${absoluteWorktreePath}'`);
+        return;
+      } else {
+        this.logger.info(`  - Cleaning up orphaned directory at '${absoluteWorktreePath}'`);
+        await fs4.rm(absoluteWorktreePath, { recursive: true, force: true });
+      }
+    } catch {
+    }
+    try {
+      const branches = await bareGit.branch();
+      const localBranchExists = branches.all.includes(branchName);
+      if (localBranchExists || branchName.includes("/")) {
+        await bareGit.raw(["worktree", "add", absoluteWorktreePath, branchName]);
+        const worktreeGit = this.getCachedGit(absoluteWorktreePath, this.isLfsSkipEnabled());
+        await worktreeGit.branch(["--set-upstream-to", `origin/${branchName}`, branchName]);
+      } else {
+        await bareGit.raw([
+          "worktree",
+          "add",
+          "--track",
+          "-b",
+          branchName,
+          absoluteWorktreePath,
+          `origin/${branchName}`
+        ]);
+      }
+      this.logger.info(`  - Created worktree for '${branchName}' with tracking to origin/${branchName}`);
+      if (!this.isLfsSkipEnabled()) {
+        await this.verifyLfsFilesDownloaded(absoluteWorktreePath, branchName);
+      }
+      try {
+        await this.createWorktreeMetadata(bareGit, absoluteWorktreePath, branchName);
+      } catch (metadataError) {
+        this.logger.warn(`  - Metadata creation failed for '${branchName}', removing worktree to prevent orphan`);
+        try {
+          await bareGit.raw(["worktree", "remove", "--force", absoluteWorktreePath]);
+        } catch {
+        }
+        throw new Error(`Metadata creation failed for '${branchName}': ${getErrorMessage(metadataError)}`);
+      }
+    } catch (error) {
+      const errorMessage = getErrorMessage(error);
+      if (errorMessage.includes("Metadata creation failed")) {
+        throw error;
+      }
+      if (errorMessage.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`);
+          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 });
+        } catch {
+        }
+        try {
+          await bareGit.raw([
+            "worktree",
+            "add",
+            "--track",
+            "-b",
+            branchName,
+            absoluteWorktreePath,
+            `origin/${branchName}`
+          ]);
+          this.logger.info(`  - Created worktree for '${branchName}' after pruning`);
+          if (!this.isLfsSkipEnabled()) {
+            await this.verifyLfsFilesDownloaded(absoluteWorktreePath, branchName);
+          }
+          try {
+            await this.createWorktreeMetadata(bareGit, absoluteWorktreePath, branchName);
+          } catch (metadataError) {
+            this.logger.warn(`  - Metadata creation failed for '${branchName}', removing worktree to prevent orphan`);
+            try {
+              await bareGit.raw(["worktree", "remove", "--force", absoluteWorktreePath]);
+            } catch {
+            }
+            throw new Error(`Metadata creation failed for '${branchName}': ${getErrorMessage(metadataError)}`);
+          }
+          return;
+        } catch (retryError) {
+          this.logger.error(`  - Failed to create worktree after pruning: ${retryError}`);
+          throw retryError;
+        }
+      }
+      const isTrackingError = errorMessage.includes("not a valid object name") || errorMessage.includes("not a commit") || errorMessage.includes("cannot set up tracking") || errorMessage.includes("does not track") || errorMessage.includes("remote tracking branch") || errorMessage.includes("no such remote ref");
+      if (!isTrackingError) {
+        throw 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) {
+          this.logger.info(`  - Worktree for '${branchName}' already exists at '${absoluteWorktreePath}'`);
+          return;
+        } else {
+          this.logger.info(`  - Cleaning up orphaned directory at '${absoluteWorktreePath}' before fallback attempt`);
+          await fs4.rm(absoluteWorktreePath, { recursive: true, force: true });
+        }
+      } catch {
+      }
+      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);
+        }
+        try {
+          await this.createWorktreeMetadata(bareGit, absoluteWorktreePath, branchName);
+        } catch (metadataError) {
+          this.logger.warn(`  - Metadata creation failed for '${branchName}', removing worktree to prevent orphan`);
+          try {
+            await bareGit.raw(["worktree", "remove", "--force", absoluteWorktreePath]);
+          } catch {
+          }
+          throw new Error(`Metadata creation failed for '${branchName}': ${getErrorMessage(metadataError)}`);
+        }
+      } 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;
+      }
+    }
+  }
+  async removeWorktree(worktreePath) {
+    const bareGit = this.getCachedGit(this.bareRepoPath);
+    await bareGit.raw(["worktree", "remove", worktreePath, "--force"]);
+    this.logger.info(`  - \u2705 Safely removed stale worktree at '${worktreePath}'.`);
+    try {
+      await this.metadataService.deleteMetadataFromPath(this.bareRepoPath, worktreePath);
+    } catch (metadataError) {
+      this.logger.warn(`Failed to delete metadata for worktree: ${metadataError}`);
+    }
+  }
+  async pruneWorktrees() {
+    const bareGit = this.getCachedGit(this.bareRepoPath);
+    await bareGit.raw(["worktree", "prune"]);
+    this.logger.info("Pruned worktree metadata.");
+  }
+  async checkWorktreeStatus(worktreePath) {
+    return this.statusService.checkWorktreeStatus(worktreePath);
+  }
+  async hasUnpushedCommits(worktreePath) {
+    const metadata = await this.metadataService.loadMetadataFromPath(this.bareRepoPath, worktreePath);
+    return this.statusService.hasUnpushedCommits(worktreePath, metadata?.lastSyncCommit);
+  }
+  async hasUpstreamGone(worktreePath) {
+    return this.statusService.hasUpstreamGone(worktreePath);
+  }
+  async hasStashedChanges(worktreePath) {
+    return this.statusService.hasStashedChanges(worktreePath);
+  }
+  async getFullWorktreeStatus(worktreePath, includeDetails = false) {
+    const metadata = await this.metadataService.loadMetadataFromPath(this.bareRepoPath, worktreePath);
+    return this.statusService.getFullWorktreeStatus(worktreePath, includeDetails, metadata?.lastSyncCommit);
+  }
+  async hasModifiedSubmodules(worktreePath) {
+    return this.statusService.hasModifiedSubmodules(worktreePath);
+  }
+  async hasOperationInProgress(worktreePath) {
+    return this.statusService.hasOperationInProgress(worktreePath);
+  }
+  async getCurrentBranch() {
+    const git = this.getGit();
+    const branchSummary = await git.branch();
+    return branchSummary.current;
+  }
+  async detectDefaultBranch(bareGit) {
+    try {
+      const headRef = await bareGit.raw(["symbolic-ref", "refs/remotes/origin/HEAD"]);
+      const branch = headRef.trim().split("/").pop();
+      if (branch) {
+        return branch;
+      }
+    } catch {
+      try {
+        await bareGit.raw(["remote", "set-head", "origin", "-a"]);
+        const headRef = await bareGit.raw(["symbolic-ref", "refs/remotes/origin/HEAD"]);
+        const branch = headRef.trim().split("/").pop();
+        if (branch) {
+          return branch;
+        }
+      } catch {
+        try {
+          const remoteBranches = await bareGit.branch(["-r"]);
+          const commonDefaults = GIT_CONSTANTS.COMMON_DEFAULT_BRANCHES;
+          for (const defaultName of commonDefaults) {
+            if (remoteBranches.all.some((branch) => branch === `origin/${defaultName}`)) {
+              return defaultName;
+            }
+          }
+        } catch {
+        }
+      }
+    }
+    return GIT_CONSTANTS.DEFAULT_BRANCH;
+  }
+  setLfsSkipEnabled(value) {
+    this.lfsSkipOverride = value;
+  }
+  isLfsSkipEnabled() {
+    return this.config.skipLfs || this.lfsSkipOverride;
+  }
+  async getWorktrees() {
+    const bareGit = this.getCachedGit(this.bareRepoPath);
+    return this.getWorktreesFromBare(bareGit);
+  }
+  async isWorktreeBehind(worktreePath) {
+    const worktreeGit = this.getCachedGit(worktreePath);
+    try {
+      const branchSummary = await worktreeGit.branch();
+      const currentBranch = branchSummary.current;
+      const upstreamInfo = await worktreeGit.raw(["rev-parse", "--abbrev-ref", `${currentBranch}@{upstream}`]);
+      if (!upstreamInfo.trim()) {
+        return false;
+      }
+      const behindCount = await worktreeGit.raw(["rev-list", "--count", `HEAD..${upstreamInfo.trim()}`]);
+      return parseInt(behindCount.trim(), 10) > 0;
+    } catch {
+      return false;
+    }
+  }
+  async updateWorktree(worktreePath) {
+    const worktreeGit = this.getCachedGit(worktreePath, this.isLfsSkipEnabled());
+    const branchSummary = await worktreeGit.branch();
+    const currentBranch = branchSummary.current;
+    await worktreeGit.merge([`origin/${currentBranch}`, "--ff-only"]);
+    try {
+      const currentCommit = await worktreeGit.revparse(["HEAD"]);
+      await this.metadataService.updateLastSyncFromPath(
+        this.bareRepoPath,
+        worktreePath,
+        currentCommit.trim(),
+        "updated",
+        this.defaultBranch
+      );
+    } catch (metadataError) {
+      this.logger.warn(`Failed to update metadata for worktree: ${metadataError}`);
+    }
+  }
+  async hasDivergedHistory(worktreePath, expectedBranch) {
+    const worktreeGit = this.getCachedGit(worktreePath);
+    const branchInfo = await worktreeGit.branch();
+    if (branchInfo.current !== expectedBranch) {
+      this.logger.warn(`Branch mismatch in hasDivergedHistory: expected ${expectedBranch}, got ${branchInfo.current}`);
+      return false;
+    }
+    try {
+      await worktreeGit.raw(["merge-base", "--is-ancestor", "HEAD", `origin/${expectedBranch}`]);
+      return false;
+    } catch {
+      return true;
+    }
+  }
+  async canFastForward(worktreePath, branch) {
+    const worktreeGit = this.getCachedGit(worktreePath);
+    try {
+      const mergeBase = await worktreeGit.raw(["merge-base", "HEAD", `origin/${branch}`]);
+      const mergeBaseSha = mergeBase.trim();
+      const headSha = await worktreeGit.revparse(["HEAD"]);
+      const headShaTrimmed = headSha.trim();
+      return mergeBaseSha === headShaTrimmed;
+    } catch {
+      return false;
+    }
+  }
+  async isLocalAheadOfRemote(worktreePath, branch) {
+    const worktreeGit = this.getCachedGit(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 = this.getCachedGit(worktreePath);
+    try {
+      const localTree = await worktreeGit.raw(["rev-parse", "HEAD^{tree}"]);
+      const remoteTree = await worktreeGit.raw(["rev-parse", `origin/${branch}^{tree}`]);
+      return localTree.trim() === remoteTree.trim();
+    } catch (error) {
+      this.logger.error(`Error comparing tree content: ${error}`);
+      return false;
+    }
+  }
+  async resetToUpstream(worktreePath, branch) {
+    const worktreeGit = this.getCachedGit(worktreePath, this.isLfsSkipEnabled());
+    await worktreeGit.reset(["--hard", `origin/${branch}`]);
+    try {
+      const currentCommit = await worktreeGit.revparse(["HEAD"]);
+      await this.metadataService.updateLastSyncFromPath(
+        this.bareRepoPath,
+        worktreePath,
+        currentCommit.trim(),
+        "updated",
+        this.defaultBranch
+      );
+    } catch (metadataError) {
+      this.logger.warn(`Failed to update metadata after reset: ${metadataError}`);
+    }
+  }
+  async getCurrentCommit(worktreePath) {
+    const worktreeGit = this.getCachedGit(worktreePath);
+    const commit = await worktreeGit.revparse(["HEAD"]);
+    return commit.trim();
+  }
+  async getRemoteCommit(ref) {
+    const git = this.getCachedGit(this.bareRepoPath);
+    const commit = await git.revparse([ref]);
+    return commit.trim();
+  }
+  async branchExists(branchName) {
+    const bareGit = this.getCachedGit(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 = this.getCachedGit(this.bareRepoPath);
+    const branches = await bareGit.branch();
+    return branches.all;
+  }
+  async createBranch(branchName, baseBranch) {
+    const bareGit = this.getCachedGit(this.bareRepoPath);
+    await bareGit.raw(["branch", branchName, `origin/${baseBranch}`]);
+    this.logger.info(`Created branch '${branchName}' from '${baseBranch}'`);
+  }
+  async pushBranch(branchName) {
+    const bareGit = this.getCachedGit(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);
+  }
+  async getWorktreesFromBare(bareGit) {
+    const result = await bareGit.raw(["worktree", "list", "--porcelain"]);
+    return parseWorktreeListPorcelain(result).filter((w) => !w.detached && w.branch !== null).map((w) => ({
+      path: w.path,
+      branch: w.branch,
+      isPrunable: w.prunable
+    }));
+  }
+};
+
+// src/services/path-resolution.service.ts
+import { createHash } from "crypto";
+import * as fs5 from "fs";
+import * as path6 from "path";
+
+// src/utils/path-compare.ts
+import * as path5 from "path";
+var CASE_INSENSITIVE_PLATFORMS = /* @__PURE__ */ new Set(["darwin"]);
+function isCaseInsensitiveFs(platform = process.platform) {
+  return CASE_INSENSITIVE_PLATFORMS.has(platform);
+}
+function normalizePathForCompare(p, platform = process.platform) {
+  const resolved = path5.resolve(p);
+  return isCaseInsensitiveFs(platform) ? resolved.toLowerCase() : resolved;
+}
+function pathsEqual(a, b, platform = process.platform) {
+  return normalizePathForCompare(a, platform) === normalizePathForCompare(b, platform);
+}
+
+// src/services/path-resolution.service.ts
+var BRANCH_STEM_MAX = 80;
+var BRANCH_HASH_LEN = 8;
+var PathResolutionService = class {
+  sanitizeBranchName(branchName) {
+    const stem = branchName.replace(/\//g, "-").replace(/[^a-zA-Z0-9_-]/g, "_").slice(0, BRANCH_STEM_MAX);
+    const hash = createHash("sha256").update(branchName).digest("hex").slice(0, BRANCH_HASH_LEN);
+    return `${stem}-${hash}`;
+  }
+  getBranchWorktreePath(worktreeDir, branchName) {
+    return path6.join(worktreeDir, this.sanitizeBranchName(branchName));
+  }
+  resolveRealPath(inputPath) {
+    const absolute = path6.resolve(inputPath);
+    const missing = [];
+    let current = absolute;
+    while (!fs5.existsSync(current)) {
+      const parent = path6.dirname(current);
+      if (parent === current) {
+        return absolute;
+      }
+      missing.unshift(path6.basename(current));
+      current = parent;
+    }
+    try {
+      return path6.join(fs5.realpathSync(current), ...missing);
+    } catch {
+      return absolute;
+    }
+  }
+  isResolvedPathInsideBase(resolved, resolvedBase) {
+    const fold = (p) => isCaseInsensitiveFs() ? p.toLowerCase() : p;
+    const a = fold(resolved);
+    const b = fold(resolvedBase);
+    if (a === b) return true;
+    return a.length > b.length && a.charAt(b.length) === path6.sep && a.startsWith(b);
+  }
+  normalizeWorktreePath(worktreePath, worktreeBaseDir) {
+    const resolved = this.resolveRealPath(worktreePath);
+    const resolvedBase = this.resolveRealPath(worktreeBaseDir);
+    if (!this.isResolvedPathInsideBase(resolved, resolvedBase)) {
+      throw new Error(`Worktree path '${worktreePath}' is outside base directory '${worktreeBaseDir}'`);
+    }
+    return path6.relative(resolvedBase, resolved);
+  }
+  isPathInsideBaseDir(targetPath, baseDir) {
+    const resolved = this.resolveRealPath(targetPath);
+    const resolvedBase = this.resolveRealPath(baseDir);
+    return this.isResolvedPathInsideBase(resolved, resolvedBase);
+  }
+  extractBranchFromWorktreePath(worktreePath, worktreeBaseDir) {
+    return this.normalizeWorktreePath(worktreePath, worktreeBaseDir);
+  }
+};
+
+// src/services/worktree-sync.service.ts
+var WorktreeSyncService = class {
+  constructor(config) {
+    this.config = config;
+    this.logger = config.logger ?? Logger.createDefault(void 0, config.debug);
+    this.gitService = new GitService(config, this.logger);
+  }
+  gitService;
+  logger;
+  syncInProgress = false;
+  pathResolution = new PathResolutionService();
+  progressListeners = /* @__PURE__ */ new Set();
+  async initialize() {
+    this.emitProgress({ phase: "initialize", message: "Initializing repository" });
+    await this.gitService.initialize();
+    this.emitProgress({ phase: "initialize", message: "Repository initialized" });
+  }
+  isInitialized() {
+    return this.gitService.isInitialized();
+  }
+  isSyncInProgress() {
+    return this.syncInProgress;
+  }
+  getGitService() {
+    return this.gitService;
+  }
+  updateLogger(logger) {
+    this.logger = logger;
+    this.gitService.updateLogger(logger);
+  }
+  onProgress(listener) {
+    this.progressListeners.add(listener);
+    return () => this.progressListeners.delete(listener);
+  }
+  emitProgress(event) {
+    for (const listener of this.progressListeners) {
+      try {
+        listener(event);
+      } catch {
+      }
+    }
+  }
+  async sync() {
+    if (this.syncInProgress) {
+      this.logger.warn("\u26A0\uFE0F  Sync already in progress, skipping...");
+      return { started: false, reason: "in_progress" };
+    }
+    this.syncInProgress = true;
+    this.logger.info(`[${(/* @__PURE__ */ new Date()).toISOString()}] Starting worktree synchronization...`);
+    const totalTimer = new Timer();
+    const phaseTimer = new PhaseTimer();
+    const syncContext = { lfsSkipEnabled: false };
+    const retryOptions = this.createRetryOptions(syncContext);
+    try {
+      await retry(() => this.runSyncAttempt(phaseTimer, syncContext), retryOptions);
+    } catch (error) {
+      this.logger.error("\n\u274C Error during worktree synchronization after all retry attempts:", error);
+      throw error;
+    } finally {
+      if (syncContext.lfsSkipEnabled && !this.config.skipLfs) {
+        this.gitService.setLfsSkipEnabled(false);
+      }
+      this.syncInProgress = false;
+      this.logger.info(`[${(/* @__PURE__ */ new Date()).toISOString()}] Synchronization finished.
+`);
+      if (this.config.debug) {
+        const totalDuration = totalTimer.stop();
+        const phaseResults = phaseTimer.getResults();
+        const repoName = this.config.name;
+        this.logger.table(formatTimingTable(totalDuration, phaseResults, repoName));
+      }
+    }
+    return { started: true };
+  }
+  createRetryOptions(syncContext) {
+    return {
+      maxAttempts: this.config.retry?.maxAttempts ?? 3,
+      maxLfsRetries: this.config.retry?.maxLfsRetries ?? 2,
+      initialDelayMs: this.config.retry?.initialDelayMs ?? 1e3,
+      maxDelayMs: this.config.retry?.maxDelayMs ?? 3e4,
+      backoffMultiplier: this.config.retry?.backoffMultiplier ?? 2,
+      onRetry: (error, attempt, context) => {
+        const errorMessage = getErrorMessage(error);
+        this.logger.info(`
+\u26A0\uFE0F  Sync attempt ${attempt} failed: ${errorMessage}`);
+        if (context?.isLfsError && !this.config.skipLfs) {
+          this.logger.info(`\u{1F504} LFS error detected. Will retry with LFS skipped...`);
+        } else {
+          this.logger.info(`\u{1F504} Retrying synchronization...
+`);
+        }
+      },
+      lfsRetryHandler: () => {
+        if (!this.config.skipLfs && !syncContext.lfsSkipEnabled) {
+          this.logger.info("\u26A0\uFE0F  Temporarily disabling LFS downloads for this sync...");
+          this.gitService.setLfsSkipEnabled(true);
+          syncContext.lfsSkipEnabled = true;
+        }
+      }
+    };
+  }
+  async runSyncAttempt(phaseTimer, syncContext) {
+    await this.gitService.pruneWorktrees();
+    await this.fetchLatestRemoteData(phaseTimer, syncContext);
+    const { remoteBranches, defaultBranch } = await this.resolveSyncBranches();
+    await fs6.mkdir(this.config.worktreeDir, { recursive: true });
+    const worktrees = await this.gitService.getWorktrees();
+    this.logger.info(`Found ${worktrees.length} existing Git worktrees.`);
+    await this.cleanupOrphanedDirectories(worktrees);
+    await this.createNewWorktreesWithTiming(remoteBranches, worktrees, defaultBranch, phaseTimer);
+    await this.pruneOldWorktreesWithTiming(remoteBranches, worktrees, phaseTimer);
+    if (this.config.updateExistingWorktrees !== false) {
+      await this.updateExistingWorktreesWithTiming(worktrees, remoteBranches, phaseTimer);
+    }
+    await this.finalizeSyncAttempt(phaseTimer);
+  }
+  async fetchLatestRemoteData(phaseTimer, syncContext) {
+    this.logger.info("Step 1: Fetching latest data from remote...");
+    phaseTimer.startPhase("Phase 1: Fetch");
+    this.emitProgress({ phase: "fetch", message: "Fetching latest data from remote" });
+    try {
+      await this.gitService.fetchAll();
+    } catch (fetchError) {
+      const errorMessage = getErrorMessage(fetchError);
+      if (isLfsError(errorMessage) && !syncContext.lfsSkipEnabled && !this.config.skipLfs) {
+        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...");
+        this.gitService.setLfsSkipEnabled(true);
+        syncContext.lfsSkipEnabled = true;
+        await this.fetchBranchByBranch();
+      } else {
+        throw fetchError;
+      }
+    } finally {
+      phaseTimer.endPhase();
+    }
+  }
+  async resolveSyncBranches() {
+    const remoteBranches = this.config.branchMaxAge ? await this.getRemoteBranchesFilteredByActivity() : await this.getRemoteBranchesFilteredByName();
+    const defaultBranch = this.gitService.getDefaultBranch();
+    if (!remoteBranches.includes(defaultBranch)) {
+      remoteBranches.push(defaultBranch);
+      this.logger.info(`Ensuring default branch '${defaultBranch}' is retained.`);
+    }
+    return { remoteBranches, defaultBranch };
+  }
+  async getRemoteBranchesFilteredByActivity() {
+    const branchesWithActivity = await this.gitService.getRemoteBranchesWithActivity();
+    this.logger.info(`Found ${branchesWithActivity.length} remote branches.`);
+    const branchNames = filterBranchesByName(
+      branchesWithActivity.map((b) => b.branch),
+      this.config.branchInclude,
+      this.config.branchExclude
+    );
+    if (branchNames.length < branchesWithActivity.length) {
+      this.logger.info(
+        `After branch name filtering: ${branchNames.length} of ${branchesWithActivity.length} branches.`
+      );
+    }
+    const branchNameSet = new Set(branchNames);
+    const filteredByName = branchesWithActivity.filter((b) => branchNameSet.has(b.branch));
+    const filteredBranches = filterBranchesByAge(filteredByName, this.config.branchMaxAge);
+    const remoteBranches = filteredBranches.map((b) => b.branch);
+    this.logger.info(
+      `After filtering by age (${formatDuration(this.config.branchMaxAge)}): ${remoteBranches.length} branches.`
+    );
+    if (filteredByName.length > remoteBranches.length) {
+      const excludedCount = filteredByName.length - remoteBranches.length;
+      this.logger.info(`  - Excluded ${excludedCount} stale branches.`);
+    }
+    return remoteBranches;
+  }
+  async getRemoteBranchesFilteredByName() {
+    const allBranches = await this.gitService.getRemoteBranches();
+    this.logger.info(`Found ${allBranches.length} remote branches.`);
+    const remoteBranches = filterBranchesByName(allBranches, this.config.branchInclude, this.config.branchExclude);
+    if (remoteBranches.length < allBranches.length) {
+      this.logger.info(`After branch name filtering: ${remoteBranches.length} of ${allBranches.length} branches.`);
+    }
+    return remoteBranches;
+  }
+  async finalizeSyncAttempt(phaseTimer) {
+    phaseTimer.startPhase("Phase 5: Cleanup");
+    this.emitProgress({ phase: "cleanup", message: "Pruning worktree metadata" });
+    await this.gitService.pruneWorktrees();
+    this.logger.info("Step 5: Pruned worktree metadata.");
+    phaseTimer.endPhase();
+  }
+  async createNewWorktreesWithTiming(remoteBranches, worktrees, defaultBranch, phaseTimer) {
+    const maxConcurrent = this.config.parallelism?.maxWorktreeCreation ?? DEFAULT_CONFIG.PARALLELISM.MAX_WORKTREE_CREATION;
+    phaseTimer.startPhase("Phase 2: Create", maxConcurrent);
+    this.emitProgress({ phase: "create", message: "Creating worktrees for new branches" });
+    await this.createNewWorktrees(remoteBranches, worktrees, defaultBranch);
+    const existingBranches = new Set(worktrees.map((w) => w.branch));
+    const newBranches = remoteBranches.filter((b) => !existingBranches.has(b) && b !== defaultBranch);
+    phaseTimer.setPhaseCount("Phase 2: Create", newBranches.length);
+    phaseTimer.endPhase();
+  }
+  async createNewWorktrees(remoteBranches, worktrees, defaultBranch) {
+    const existingBranches = new Set(worktrees.map((w) => w.branch));
+    const newBranches = remoteBranches.filter((b) => !existingBranches.has(b) && b !== defaultBranch);
+    if (newBranches.length === 0) {
+      this.logger.info("Step 2: No new branches to create worktrees for.");
+      return;
+    }
+    const reservedPaths = /* @__PURE__ */ new Map();
+    for (const w of worktrees) {
+      reservedPaths.set(path7.resolve(w.path), w.branch);
+    }
+    const plan = [];
+    for (const branchName of newBranches) {
+      const worktreePath = this.pathResolution.getBranchWorktreePath(this.config.worktreeDir, branchName);
+      const resolved = path7.resolve(worktreePath);
+      const conflict = reservedPaths.get(resolved);
+      if (conflict && conflict !== branchName) {
+        this.logger.error(
+          `  \u274C Skipping '${branchName}': sanitized worktree path '${worktreePath}' collides with existing branch '${conflict}'.`
+        );
+        continue;
+      }
+      reservedPaths.set(resolved, branchName);
+      plan.push({ branchName, worktreePath });
+    }
+    this.logger.info(`Step 2: Creating ${plan.length} new worktrees...`);
+    const maxConcurrent = this.config.parallelism?.maxWorktreeCreation ?? DEFAULT_CONFIG.PARALLELISM.MAX_WORKTREE_CREATION;
+    const limit = pLimit(maxConcurrent);
+    const results = await Promise.allSettled(
+      plan.map(
+        ({ branchName, worktreePath }) => limit(async () => {
+          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}/${plan.length} worktrees successfully`);
+  }
+  async pruneOldWorktreesWithTiming(remoteBranches, worktrees, phaseTimer) {
+    const maxConcurrent = this.config.parallelism?.maxStatusChecks ?? DEFAULT_CONFIG.PARALLELISM.MAX_STATUS_CHECKS;
+    phaseTimer.startPhase("Phase 3: Prune", maxConcurrent);
+    this.emitProgress({ phase: "prune", message: "Pruning stale worktrees" });
+    await this.pruneOldWorktrees(remoteBranches, worktrees);
+    const deletedWorktrees = worktrees.filter((w) => !remoteBranches.includes(w.branch));
+    phaseTimer.setPhaseCount("Phase 3: Prune", deletedWorktrees.length);
+    phaseTimer.endPhase();
+  }
+  async pruneOldWorktrees(remoteBranches, worktrees) {
+    const deletedWorktrees = worktrees.filter((w) => !remoteBranches.includes(w.branch));
+    if (deletedWorktrees.length > 0) {
+      this.logger.info(`Step 3: Checking ${deletedWorktrees.length} stale worktrees to prune...`);
+      const maxConcurrent = this.config.parallelism?.maxStatusChecks ?? DEFAULT_CONFIG.PARALLELISM.MAX_STATUS_CHECKS;
+      const limit = pLimit(maxConcurrent);
+      const statusResults = await Promise.allSettled(
+        deletedWorktrees.map(
+          ({ branch: branchName, path: worktreePath }) => limit(async () => {
+            const status = await this.gitService.getFullWorktreeStatus(worktreePath, this.config.debug);
+            return { branchName, worktreePath, status };
+          }).catch((error) => {
+            throw Object.assign(error instanceof Error ? error : new Error(String(error)), { branchName });
+          })
+        )
+      );
+      const toRemove = [];
+      const toSkip = [];
+      for (const result of statusResults) {
+        if (result.status === "fulfilled") {
+          const { branchName, worktreePath, status } = result.value;
+          if (status.canRemove) {
+            toRemove.push({ branchName, worktreePath });
+          } else {
+            toSkip.push({ branchName, worktreePath, status });
+          }
+        } else {
+          const branchName = result.reason?.branchName ?? "unknown";
+          this.logger.error(`  - Error checking worktree '${branchName}':`, result.reason);
+          this.logger.warn(`  - \u26A0\uFE0F Skipping removal of '${branchName}' due to status check failure (conservative)`);
+        }
+      }
+      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 {
+                const recheck = await this.gitService.getFullWorktreeStatus(worktreePath, false);
+                if (!recheck.canRemove) {
+                  this.logger.warn(
+                    `  \u26A0\uFE0F Skipping removal of '${branchName}' - status changed since initial check: ${recheck.reasons.join(", ")}`
+                  );
+                  return;
+                }
+                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, worktreePath, status } of toSkip) {
+        if (status.upstreamGone && status.hasUnpushedCommits) {
+          this.logger.warn(`  - \u26A0\uFE0F Cannot automatically remove '${branchName}' - upstream branch was deleted.`);
+          this.logger.info(`     Please review manually: cd ${worktreePath} && git log`);
+          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 {
+      this.logger.info("Step 3: No stale worktrees to prune.");
+    }
+  }
+  logDebugDetails(branchName, details) {
+    this.logger.info(`
+     \u{1F50D} Debug details for '${branchName}':`);
+    if (details.modifiedFiles > 0 && details.modifiedFilesList) {
+      this.logger.info(`        - Modified files (${details.modifiedFiles}):`);
+      details.modifiedFilesList.forEach((file) => this.logger.info(`          \u2022 ${file}`));
+    }
+    if (details.deletedFiles > 0 && details.deletedFilesList) {
+      this.logger.info(`        - Deleted files (${details.deletedFiles}):`);
+      details.deletedFilesList.forEach((file) => this.logger.info(`          \u2022 ${file}`));
+    }
+    if (details.renamedFiles > 0 && details.renamedFilesList) {
+      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) {
+      this.logger.info(`        - Created files (${details.createdFiles}):`);
+      details.createdFilesList.forEach((file) => this.logger.info(`          \u2022 ${file}`));
+    }
+    if (details.conflictedFiles > 0 && details.conflictedFilesList) {
+      this.logger.info(`        - Conflicted files (${details.conflictedFiles}):`);
+      details.conflictedFilesList.forEach((file) => this.logger.info(`          \u2022 ${file}`));
+    }
+    if (details.untrackedFiles > 0 && details.untrackedFilesList) {
+      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) {
+      this.logger.info(`        - Unpushed commits: ${details.unpushedCommitCount}`);
+    }
+    if (details.stashCount !== void 0 && details.stashCount > 0) {
+      this.logger.info(`        - Stashed changes: ${details.stashCount}`);
+    }
+    if (details.operationType) {
+      this.logger.info(`        - Operation in progress: ${details.operationType}`);
+    }
+    if (details.modifiedSubmodules && details.modifiedSubmodules.length > 0) {
+      this.logger.info(`        - Modified submodules (${details.modifiedSubmodules.length}):`);
+      details.modifiedSubmodules.forEach((submodule) => this.logger.info(`          \u2022 ${submodule}`));
+    }
+    this.logger.info("");
+  }
+  async fetchBranchByBranch() {
+    this.logger.info("Fetching branches individually to isolate LFS errors...");
+    const remoteBranches = await this.gitService.getRemoteBranches();
+    this.logger.info(`Found ${remoteBranches.length} remote branches to fetch.`);
+    const fetchLimit = pLimit(
+      this.config.parallelism?.maxBranchFetches ?? DEFAULT_CONFIG.PARALLELISM.MAX_BRANCH_FETCHES
+    );
+    const failedBranches = [];
+    let successCount = 0;
+    const results = await Promise.allSettled(
+      remoteBranches.map(
+        (branch) => fetchLimit(async () => {
+          await this.gitService.fetchBranch(branch);
+          return branch;
+        })
+      )
+    );
+    for (let i = 0; i < results.length; i++) {
+      const result = results[i];
+      if (result.status === "fulfilled") {
+        successCount++;
+      } else {
+        const errorMessage = getErrorMessage(result.reason);
+        this.logger.info(`  \u26A0\uFE0F  Failed to fetch branch '${remoteBranches[i]}': ${errorMessage}`);
+        failedBranches.push(remoteBranches[i]);
+      }
+    }
+    this.logger.info(`Branch-by-branch fetch completed: ${successCount}/${remoteBranches.length} successful`);
+    if (failedBranches.length > 0) {
+      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);
+    this.emitProgress({ phase: "update", message: "Updating existing worktrees" });
+    await this.updateExistingWorktrees(worktrees, remoteBranches);
+    const activeWorktrees = worktrees.filter((w) => remoteBranches.includes(w.branch));
+    phaseTimer.setPhaseCount("Phase 4: Update", activeWorktrees.length);
+    phaseTimer.endPhase();
+  }
+  async updateExistingWorktrees(worktrees, remoteBranches) {
+    this.logger.info("Step 4: Checking for worktrees that need updates...");
+    const divergedDir = path7.join(this.config.worktreeDir, GIT_CONSTANTS.DIVERGED_DIR_NAME);
+    try {
+      const diverged = await fs6.readdir(divergedDir);
+      if (diverged.length > 0) {
+        this.logger.info(
+          `\u{1F4E6} Note: ${diverged.length} diverged worktree(s) in ${path7.relative(process.cwd(), divergedDir)}`
+        );
+      }
+    } catch {
+    }
+    const activeWorktrees = worktrees.filter((w) => remoteBranches.includes(w.branch));
+    const maxConcurrent = this.config.parallelism?.maxStatusChecks ?? DEFAULT_CONFIG.PARALLELISM.MAX_STATUS_CHECKS;
+    const limit = pLimit(maxConcurrent);
+    const checkResults = await Promise.allSettled(
+      activeWorktrees.map(
+        (worktree) => limit(async () => {
+          try {
+            await fs6.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;
+            }
+            return { action: "diverged", worktree };
+          }
+          const isBehind = await this.gitService.isWorktreeBehind(worktree.path);
+          return isBehind ? { action: "update", worktree } : null;
+        })
+      )
+    );
+    const worktreesToUpdate = [];
+    const divergedWorktrees = [];
+    for (const result of checkResults) {
+      if (result.status === "fulfilled" && result.value) {
+        if (result.value.action === "update") {
+          worktreesToUpdate.push(result.value.worktree);
+        } else {
+          divergedWorktrees.push(result.value.worktree);
+        }
+      } else if (result.status === "rejected") {
+        this.logger.error(`  - Error checking worktree:`, result.reason);
+      }
+    }
+    const updateLimit = pLimit(
+      this.config.parallelism?.maxWorktreeUpdates ?? DEFAULT_CONFIG.PARALLELISM.MAX_WORKTREE_UPDATES
+    );
+    const mutationTasks = [];
+    for (const worktree of worktreesToUpdate) {
+      mutationTasks.push(
+        updateLimit(async () => {
+          try {
+            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);
+                throw divergedError;
+              }
+            } else {
+              this.logger.error(`    \u274C Failed to update '${worktree.branch}':`, error);
+              throw error;
+            }
+          }
+          return { type: "update", branch: worktree.branch };
+        })
+      );
+    }
+    for (const worktree of divergedWorktrees) {
+      mutationTasks.push(
+        updateLimit(async () => {
+          try {
+            await this.handleDivergedBranch(worktree);
+          } catch (error) {
+            this.logger.error(`    \u274C Failed to handle diverged branch '${worktree.branch}':`, error);
+            throw error;
+          }
+          return { type: "diverged", branch: worktree.branch };
+        })
+      );
+    }
+    if (mutationTasks.length > 0) {
+      if (worktreesToUpdate.length > 0) {
+        this.logger.info(`  - Found ${worktreesToUpdate.length} worktrees behind their upstream branches.`);
+      }
+      if (divergedWorktrees.length > 0) {
+        this.logger.info(`  - Found ${divergedWorktrees.length} diverged worktrees to handle.`);
+      }
+      const mutationResults = await Promise.allSettled(mutationTasks);
+      const successCount = mutationResults.filter((r) => r.status === "fulfilled").length;
+      this.logger.info(`  Processed ${successCount}/${mutationTasks.length} worktrees successfully`);
+    } else {
+      this.logger.info("  - All worktrees are up to date.");
+    }
+  }
+  async cleanupOrphanedDirectories(worktrees) {
+    try {
+      const worktreeRelativePaths = worktrees.map((w) => path7.relative(this.config.worktreeDir, w.path));
+      const allDirs = await fs6.readdir(this.config.worktreeDir);
+      const regularDirs = allDirs.filter((dir) => !dir.startsWith("."));
+      const orphanedDirs = [];
+      for (const dir of regularDirs) {
+        const isPartOfWorktree = worktreeRelativePaths.some((worktreePath) => {
+          return worktreePath === dir || worktreePath.startsWith(dir + path7.sep);
+        });
+        if (!isPartOfWorktree) {
+          orphanedDirs.push(dir);
+        }
+      }
+      if (orphanedDirs.length > 0) {
+        this.logger.info(`Found ${orphanedDirs.length} orphaned directories: ${orphanedDirs.join(", ")}`);
+        for (const dir of orphanedDirs) {
+          const dirPath = path7.join(this.config.worktreeDir, dir);
+          try {
+            const stat4 = await fs6.stat(dirPath);
+            if (stat4.isDirectory()) {
+              await fs6.rm(dirPath, { recursive: true, force: true });
+              this.logger.info(`  - Removed orphaned directory: ${dir}`);
+            }
+          } catch (error) {
+            this.logger.error(`  - Failed to remove orphaned directory ${dir}:`, error);
+          }
+        }
+      }
+    } catch (error) {
+      this.logger.error("Error during orphaned directory cleanup:", error);
+    }
+  }
+  async handleDivergedBranch(worktree) {
+    this.logger.info(`\u26A0\uFE0F  Branch '${worktree.branch}' has diverged from upstream. Analyzing...`);
+    const treesIdentical = await this.gitService.compareTreeContent(worktree.path, worktree.branch);
+    if (treesIdentical) {
+      this.logger.info(`\u2705 Branch '${worktree.branch}' was rebased but files are identical. Resetting to upstream...`);
+      await this.gitService.resetToUpstream(worktree.path, worktree.branch);
+      this.logger.info(`   Successfully updated '${worktree.branch}' to match upstream.`);
+    } else {
+      const hasLocalChanges = await this.hasLocalChangesSinceLastSync(worktree.path);
+      if (!hasLocalChanges) {
+        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);
+        this.logger.info(`   Successfully updated '${worktree.branch}' to match upstream.`);
+      } else {
+        this.logger.info(`\u{1F512} Branch '${worktree.branch}' has diverged with local changes. Moving to diverged...`);
+        const divergedPath = await this.divergeWorktree(worktree.path, worktree.branch);
+        const relativePath = path7.relative(process.cwd(), divergedPath);
+        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);
+        this.logger.info(`   Created fresh worktree from upstream at: ${worktree.path}`);
+      }
+    }
+  }
+  async hasLocalChangesSinceLastSync(worktreePath) {
+    try {
+      const metadata = await this.gitService.getWorktreeMetadata(worktreePath);
+      if (!metadata || !metadata.lastSyncCommit) {
+        return true;
+      }
+      const currentCommit = await this.gitService.getCurrentCommit(worktreePath);
+      return currentCommit !== metadata.lastSyncCommit;
+    } catch {
+      return true;
+    }
+  }
+  async divergeWorktree(worktreePath, branchName) {
+    const divergedBaseDir = path7.join(this.config.worktreeDir, GIT_CONSTANTS.DIVERGED_DIR_NAME);
+    const timestamp = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
+    const uniqueSuffix = Date.now().toString(36) + Math.random().toString(36).substring(2, 7);
+    const safeBranchName = this.pathResolution.sanitizeBranchName(branchName);
+    const divergedName = `${timestamp}-${safeBranchName}-${uniqueSuffix}`;
+    const divergedPath = path7.join(divergedBaseDir, divergedName);
+    await fs6.mkdir(divergedBaseDir, { recursive: true });
+    try {
+      await fs6.rename(worktreePath, divergedPath);
+    } catch (err) {
+      if (err.code === ERROR_MESSAGES.EXDEV) {
+        await fs6.cp(worktreePath, divergedPath, { recursive: true });
+        await fs6.rm(worktreePath, { recursive: true, force: true });
+      } else {
+        throw err;
+      }
+    }
+    const metadata = {
+      originalBranch: branchName,
+      divergedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      reason: METADATA_CONSTANTS.DIVERGED_REASON,
+      originalPath: worktreePath,
+      localCommit: await this.gitService.getCurrentCommit(divergedPath),
+      remoteCommit: await this.gitService.getRemoteCommit(`origin/${branchName}`),
+      instruction: `To preserve your changes:
+  1. Review: git diff origin/${branchName}
+  2. Keep changes: git push --force-with-lease origin ${branchName}
+  3. Discard changes: rm -rf this directory
+
+  Original worktree location: ${worktreePath}`
+    };
+    await fs6.writeFile(
+      path7.join(divergedPath, METADATA_CONSTANTS.DIVERGED_INFO_FILE),
+      JSON.stringify(metadata, null, 2)
+    );
+    return divergedPath;
+  }
+};
+
+// src/mcp/context.ts
+var AUTO_DETECT_PREFIX = "__auto_detected__:";
+var DISCOVERY_CACHE_TTL_MS = 5e3;
+var EMPTY_CAPABILITIES = {
+  canListWorktrees: false,
+  canGetStatus: false,
+  canCreateWorktree: false,
+  canRemoveWorktree: false,
+  canUpdateWorktree: false,
+  canSync: false,
+  canInitialize: false
+};
+function buildUnsupportedContext(currentPath, reason) {
+  return {
+    isWorktree: false,
+    kind: "unsupported",
+    currentBranch: null,
+    currentWorktreePath: currentPath,
+    bareRepoPath: null,
+    repoUrl: null,
+    worktreeDir: null,
+    allWorktrees: [],
+    configLoaded: false,
+    repoName: null,
+    capabilities: EMPTY_CAPABILITIES,
+    reasons: [reason]
+  };
+}
+function createStderrLogger(repoName) {
+  return new Logger({
+    repoName,
+    outputFn: (msg) => {
+      process.stderr.write(msg + "\n");
+    }
+  });
+}
+var RepositoryContext = class {
+  repos = /* @__PURE__ */ new Map();
+  currentRepo = null;
+  configPath = null;
+  configLoader = new ConfigLoaderService();
+  discoveryCache = /* @__PURE__ */ new Map();
+  async loadConfig(configPath) {
+    const absolutePath = path8.resolve(configPath);
+    const configFile = await this.configLoader.loadConfigFile(absolutePath);
+    for (const [name, entry] of this.repos) {
+      if (entry.source === "config") {
+        this.repos.delete(name);
+      }
+    }
+    this.configPath = absolutePath;
+    const configDir = path8.dirname(absolutePath);
+    const globalDefaults = configFile.defaults;
+    for (const repo of configFile.repositories) {
+      const resolved = this.configLoader.resolveRepositoryConfig(repo, globalDefaults, configDir, configFile.retry);
+      this.repos.set(resolved.name, {
+        name: resolved.name,
+        config: resolved,
+        source: "config"
+      });
+    }
+    if (this.currentRepo && !this.repos.has(this.currentRepo)) {
+      this.currentRepo = null;
+    }
+    if (!this.currentRepo && configFile.repositories.length > 0) {
+      this.currentRepo = configFile.repositories[0].name;
+    }
+    return configFile.repositories;
+  }
+  async detectFromPath(dirPath) {
+    const absolutePath = path8.resolve(dirPath);
+    const cached = this.discoveryCache.get(absolutePath);
+    if (cached && await this.isCacheFresh(cached)) {
+      return cached.result;
+    }
+    const { result, adminDir } = await this.detectFromPathUncached(absolutePath);
+    if (result.isWorktree && result.bareRepoPath && adminDir) {
+      const [worktreeHeadMtimeMs, worktreesDirMtimeMs] = await Promise.all([
+        safeMtimeMs(path8.join(adminDir, "HEAD")),
+        safeMtimeMs(path8.join(result.bareRepoPath, "worktrees"))
+      ]);
+      this.discoveryCache.set(absolutePath, {
+        result,
+        cachedAt: Date.now(),
+        worktreeAdminDir: adminDir,
+        worktreeHeadMtimeMs,
+        worktreesDirMtimeMs
+      });
+    }
+    return result;
+  }
+  invalidateDiscovered() {
+    this.discoveryCache.clear();
+  }
+  /** @internal Test-only helper — registers a repo entry without going through config loading. */
+  __registerForTest(name, entry) {
+    this.repos.set(name, { ...entry, name });
+  }
+  /** @internal Test-only helper — sets the current repo pointer. */
+  __setCurrentRepoForTest(name) {
+    this.currentRepo = name;
+  }
+  /** @internal Test-only helper — returns the size of the internal repo map. */
+  __repoCountForTest() {
+    return this.repos.size;
+  }
+  /** @internal Test-only helper — returns the size of the discovery cache. */
+  __discoveryCacheSizeForTest() {
+    return this.discoveryCache.size;
+  }
+  bootstrapCurrentRepo(candidate) {
+    if (this.currentRepo !== null) return;
+    if (!this.repos.has(candidate)) return;
+    if (this.repos.size !== 1) return;
+    this.currentRepo = candidate;
+  }
+  async isCacheFresh(cached) {
+    if (Date.now() - cached.cachedAt >= DISCOVERY_CACHE_TTL_MS) return false;
+    if (!cached.worktreeAdminDir || !cached.result.bareRepoPath) return true;
+    const [currentHeadMtime, currentWorktreesDirMtime] = await Promise.all([
+      safeMtimeMs(path8.join(cached.worktreeAdminDir, "HEAD")),
+      safeMtimeMs(path8.join(cached.result.bareRepoPath, "worktrees"))
+    ]);
+    return currentHeadMtime === cached.worktreeHeadMtimeMs && currentWorktreesDirMtime === cached.worktreesDirMtimeMs;
+  }
+  async detectFromPathUncached(absolutePath) {
+    const reasons = [];
+    const located = await findWorktreeRoot(absolutePath);
+    const worktreeRoot = located?.worktreeRoot ?? absolutePath;
+    const unsupported = (reason, isWorktree = false) => {
+      reasons.push(reason);
+      return {
+        result: {
+          isWorktree,
+          kind: "unsupported",
+          currentBranch: null,
+          currentWorktreePath: worktreeRoot,
+          bareRepoPath: null,
+          repoUrl: null,
+          worktreeDir: null,
+          allWorktrees: [],
+          configLoaded: this.configPath !== null,
+          repoName: null,
+          capabilities: EMPTY_CAPABILITIES,
+          reasons
+        },
+        adminDir: null
+      };
+    };
+    if (!located) {
+      return unsupported("No .git file found in path or any parent directory");
+    }
+    if (located.kind === "regular-git-dir") {
+      return unsupported("Directory has .git folder (regular repo, not a sync-worktrees worktree)");
+    }
+    const gitFileContent = located.gitFileContent;
+    const gitdirMatch = gitFileContent.match(/^gitdir:\s*(.+)$/m);
+    if (!gitdirMatch) {
+      return unsupported("Invalid .git file format (missing gitdir line)");
+    }
+    const gitdir = gitdirMatch[1].trim();
+    const resolvedGitdir = path8.isAbsolute(gitdir) ? gitdir : path8.resolve(worktreeRoot, gitdir);
+    const worktreesMatch = resolvedGitdir.match(/^(.+?)[/\\]worktrees[/\\][^/\\]+$/);
+    if (!worktreesMatch) {
+      return unsupported("gitdir does not follow worktree structure (missing /worktrees/<name>)");
+    }
+    const bareRepoPath = path8.resolve(worktreesMatch[1]);
+    const adminDir = path8.resolve(resolvedGitdir);
+    let repoUrl = null;
+    let worktrees = [];
+    let currentBranch = null;
+    try {
+      const bareGit = simpleGit4(bareRepoPath);
+      try {
+        const remoteResult = await bareGit.remote(["get-url", "origin"]);
+        const urlStr = typeof remoteResult === "string" ? remoteResult.trim() : "";
+        repoUrl = urlStr || null;
+      } catch {
+        reasons.push("Could not read remote origin URL");
+      }
+      const listOutput = await bareGit.raw(["worktree", "list", "--porcelain"]);
+      worktrees = parseWorktreeList(listOutput, worktreeRoot);
+      const current = worktrees.find((w) => w.isCurrent);
+      if (current) {
+        currentBranch = current.branch;
+      }
+    } catch (err) {
+      reasons.push(`Failed to read bare repo at ${bareRepoPath}: ${err.message}`);
+      return {
+        result: {
+          isWorktree: true,
+          kind: "unsupported",
+          currentBranch: null,
+          currentWorktreePath: worktreeRoot,
+          bareRepoPath,
+          repoUrl: null,
+          worktreeDir: null,
+          allWorktrees: [],
+          configLoaded: this.configPath !== null,
+          repoName: null,
+          capabilities: EMPTY_CAPABILITIES,
+          reasons
+        },
+        adminDir
+      };
+    }
+    const worktreeDir = path8.dirname(worktreeRoot);
+    const capabilities = {
+      canListWorktrees: true,
+      canGetStatus: true,
+      canCreateWorktree: repoUrl !== null,
+      canRemoveWorktree: true,
+      canUpdateWorktree: true,
+      canSync: false,
+      canInitialize: false
+    };
+    if (!repoUrl) {
+      reasons.push("create_worktree unavailable: no remote origin URL detected");
+    }
+    const foldPath = (p) => isCaseInsensitiveFs() ? p.toLowerCase() : p;
+    const foldedBare = foldPath(bareRepoPath);
+    let matchedConfig = null;
+    for (const entry of this.repos.values()) {
+      if (entry.source === "config") {
+        const entryBare = entry.config.bareRepoDir ? path8.resolve(entry.config.bareRepoDir) : null;
+        if (entryBare && foldPath(entryBare) === foldedBare) {
+          matchedConfig = entry;
+          break;
+        }
+      }
+    }
+    let repoName = null;
+    let kind = "unmanaged";
+    if (matchedConfig) {
+      repoName = matchedConfig.name;
+      kind = "managed";
+      capabilities.canSync = true;
+      capabilities.canInitialize = true;
+    } else if (repoUrl) {
+      const syntheticConfig = {
+        repoUrl,
+        worktreeDir,
+        bareRepoDir: bareRepoPath,
+        cronSchedule: DEFAULT_CONFIG.CRON_SCHEDULE,
+        runOnce: true
+      };
+      const detectedKey = `${AUTO_DETECT_PREFIX}${path8.basename(bareRepoPath)}@${bareRepoPath}`;
+      if (!this.repos.has(detectedKey)) {
+        this.repos.set(detectedKey, {
+          name: detectedKey,
+          config: syntheticConfig,
+          source: "detected"
+        });
+      }
+      repoName = detectedKey;
+      reasons.push("sync/initialize unavailable: no config file loaded (running in auto-detect mode)");
+    } else {
+      reasons.push("sync/initialize unavailable: no config file and no remote URL");
+    }
+    if (repoName) {
+      this.bootstrapCurrentRepo(repoName);
+    }
+    const discovered = {
+      isWorktree: true,
+      kind,
+      currentBranch,
+      currentWorktreePath: worktreeRoot,
+      bareRepoPath,
+      repoUrl,
+      worktreeDir,
+      allWorktrees: worktrees,
+      configLoaded: this.configPath !== null,
+      repoName,
+      capabilities,
+      reasons
+    };
+    if (repoName) {
+      const entry = this.repos.get(repoName);
+      if (entry) {
+        entry.discovered = discovered;
+      }
+    }
+    return { result: discovered, adminDir };
+  }
+  async getService(repoName) {
+    const name = repoName ?? this.currentRepo;
+    if (!name) {
+      throw new Error("No repository specified and no current repository set");
+    }
+    const entry = this.repos.get(name);
+    if (!entry) {
+      throw new Error(`Repository '${name}' not found. Load a config or run detect_context first.`);
+    }
+    if (!entry.service) {
+      const logger = createStderrLogger(entry.name);
+      entry.service = new WorktreeSyncService({
+        ...entry.config,
+        logger
+      });
+    }
+    return entry.service;
+  }
+  getEntry(repoName) {
+    const name = repoName ?? this.currentRepo;
+    if (!name) return null;
+    return this.repos.get(name) ?? null;
+  }
+  getDiscoveredContext(repoName) {
+    const entry = this.getEntry(repoName);
+    return entry?.discovered ?? null;
+  }
+  getCurrentRepo() {
+    return this.currentRepo;
+  }
+  setCurrentRepo(repoName) {
+    if (!this.repos.has(repoName)) {
+      throw new Error(`Repository '${repoName}' not found`);
+    }
+    this.currentRepo = repoName;
+  }
+  getRepositoryList() {
+    return Array.from(this.repos.values()).map((e) => ({
+      name: e.name,
+      repoUrl: e.config.repoUrl,
+      worktreeDir: e.config.worktreeDir,
+      source: e.source
+    }));
+  }
+  getConfigPath() {
+    return this.configPath;
+  }
+};
+function parseWorktreeList(output, currentPath) {
+  const resolvedCurrent = path8.resolve(currentPath);
+  const fold = (p) => isCaseInsensitiveFs() ? p.toLowerCase() : p;
+  const foldedCurrent = fold(resolvedCurrent);
+  const results = [];
+  for (const wt of parseWorktreeListPorcelain(output)) {
+    const resolved = path8.resolve(wt.path);
+    const branch = wt.branch ?? (wt.detached ? `(detached ${(wt.head ?? "").slice(0, 7)})` : null);
+    if (!branch) continue;
+    results.push({
+      path: resolved,
+      branch,
+      isCurrent: fold(resolved) === foldedCurrent
+    });
+  }
+  return results;
+}
+async function safeMtimeMs(filePath) {
+  try {
+    const stat4 = await fs7.stat(filePath);
+    return stat4.mtimeMs;
+  } catch {
+    return null;
+  }
+}
+async function findWorktreeRoot(startPath) {
+  let current = path8.resolve(startPath);
+  const root = path8.parse(current).root;
+  while (true) {
+    const gitPath = path8.join(current, ".git");
+    try {
+      const content = await fs7.readFile(gitPath, "utf-8");
+      return { kind: "worktree-file", worktreeRoot: current, gitFileContent: content };
+    } catch (err) {
+      const code = err.code;
+      if (code === "EISDIR") {
+        return { kind: "regular-git-dir", worktreeRoot: current };
+      }
+      if (code !== "ENOENT") {
+        return null;
+      }
+    }
+    if (current === root) return null;
+    const parent = path8.dirname(current);
+    if (parent === current) return null;
+    current = parent;
+  }
+}
+
+// src/mcp/server.ts
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { z } from "zod";
+
+// src/mcp/handlers.ts
+import * as path9 from "path";
+import pLimit2 from "p-limit";
+import simpleGit5 from "simple-git";
+
+// src/utils/git-validation.ts
+function isValidGitBranchName(name) {
+  if (!name.trim()) {
+    return { valid: false, error: "Branch name cannot be empty" };
+  }
+  if (name === "@") {
+    return { valid: false, error: "Branch name cannot be '@'" };
+  }
+  if (name.startsWith("-")) {
+    return { valid: false, error: "Branch name cannot start with '-'" };
+  }
+  if (name.startsWith("/") || name.endsWith("/")) {
+    return { valid: false, error: "Branch name cannot start or end 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.includes("/.") || name.includes("./")) {
+    return { valid: false, error: "Branch name cannot contain '/.' or './'" };
+  }
+  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" };
+  }
+  for (const component of name.split("/")) {
+    if (component === "") {
+      return { valid: false, error: "Branch name cannot contain empty path components" };
+    }
+    if (component.startsWith(".") || component.endsWith(".")) {
+      return { valid: false, error: "Branch name path components cannot start or end with '.'" };
+    }
+    if (component.endsWith(".lock")) {
+      return { valid: false, error: "Branch name path components cannot end with '.lock'" };
+    }
+  }
+  if (/[\x00-\x20\x7f~^:?*[\\]/.test(name)) {
+    return { valid: false, error: "Branch name contains invalid characters" };
+  }
+  return { valid: true };
+}
+
+// src/mcp/utils.ts
+function formatToolResponse(data) {
+  return {
+    content: [
+      {
+        type: "text",
+        text: JSON.stringify(data, null, 2)
+      }
+    ]
+  };
+}
+function formatErrorResponse(error) {
+  let code = "UNKNOWN_ERROR";
+  let message = String(error);
+  if (error instanceof SyncWorktreesError) {
+    code = error.code;
+    message = error.message;
+  } else if (error instanceof Error) {
+    code = "INTERNAL_ERROR";
+    message = error.message;
+  }
+  const body = {
+    error: true,
+    code,
+    message
+  };
+  if (process.env.DEBUG && error instanceof Error && error.stack) {
+    body.stack = error.stack;
+  }
+  return {
+    content: [
+      {
+        type: "text",
+        text: JSON.stringify(body, null, 2)
+      }
+    ],
+    isError: true
+  };
+}
+var CapabilityUnavailableError = class extends SyncWorktreesError {
+  constructor(capability, reasons) {
+    super(`Capability '${capability}' unavailable: ${reasons.join(", ")}`, "CAPABILITY_UNAVAILABLE");
+  }
+};
+var SyncInProgressError = class extends SyncWorktreesError {
+  constructor(repoName) {
+    super(`Sync already in progress for '${repoName}'`, "SYNC_IN_PROGRESS");
+  }
+};
+function wrapHandler(fn) {
+  return async (params, extra) => {
+    try {
+      return await fn(params, extra);
+    } catch (error) {
+      return formatErrorResponse(error);
+    }
+  };
+}
+
+// src/mcp/handlers.ts
+var pathResolution = new PathResolutionService();
+function ensureCapability(discovered, key, toolName) {
+  if (!discovered) return;
+  if (!discovered.capabilities[key]) {
+    throw new CapabilityUnavailableError(toolName, discovered.reasons);
+  }
+}
+async function ensureNotSyncing(ctx, repoName) {
+  const entry = ctx.getEntry(repoName);
+  if (!entry?.service) return;
+  if (entry.service.isSyncInProgress()) {
+    throw new SyncInProgressError(entry.name);
+  }
+}
+async function getReadyService(ctx, repoName, options = {}) {
+  const discovered = ctx.getDiscoveredContext(repoName);
+  if (options.capability && options.toolName) {
+    ensureCapability(discovered, options.capability, options.toolName);
+  }
+  if (options.ensureNotSyncing) {
+    await ensureNotSyncing(ctx, repoName);
+  }
+  const service = await ctx.getService(repoName);
+  if (options.ensureInitialized && !service.isInitialized()) {
+    await service.initialize();
+  }
+  return {
+    discovered,
+    service,
+    git: service.getGitService()
+  };
+}
+async function ensureRepoWorktreePath(ctx, params, git) {
+  await ensurePathBelongsToRepo(ctx, params.path, params.repoName, git);
+  return path9.resolve(params.path);
+}
+async function ensurePathBelongsToRepo(ctx, targetPath, repoName, git) {
+  const discovered = ctx.getDiscoveredContext(repoName);
+  if (discovered?.allWorktrees.length) {
+    const match = discovered.allWorktrees.some((w) => pathsEqual(w.path, targetPath));
+    if (match) return;
+  }
+  try {
+    const worktrees = await git.getWorktrees();
+    if (worktrees.some((w) => pathsEqual(w.path, targetPath))) return;
+  } catch {
+  }
+  throw new Error(`Path '${targetPath}' is not a registered worktree of the current repository`);
+}
+function deriveLabel(status, isCurrent) {
+  if (isCurrent) return "current";
+  if (!status.isClean || status.hasUnpushedCommits || status.hasStashedChanges) return "dirty";
+  if (status.upstreamGone) return "stale";
+  return "clean";
+}
+async function getDivergence(worktreePath) {
+  try {
+    const git = simpleGit5(worktreePath);
+    const output = await git.raw(["rev-list", "--left-right", "--count", "HEAD...@{upstream}"]);
+    const [aheadStr, behindStr] = output.trim().split(/\s+/);
+    return { ahead: parseInt(aheadStr, 10), behind: parseInt(behindStr, 10) };
+  } catch {
+    return null;
+  }
+}
+async function handleDetectContext(ctx, params, _extra) {
+  const target = params.path ?? process.cwd();
+  const discovered = await ctx.detectFromPath(target);
+  return formatToolResponse(discovered);
+}
+async function handleListWorktrees(ctx, params, _extra) {
+  const { discovered, git } = await getReadyService(ctx, params.repoName, {
+    capability: "canListWorktrees",
+    toolName: "list_worktrees"
+  });
+  let worktrees;
+  try {
+    worktrees = await git.getWorktrees();
+  } catch {
+    if (discovered) {
+      worktrees = discovered.allWorktrees.map((w) => ({ path: w.path, branch: w.branch }));
+    } else {
+      throw new Error("Cannot list worktrees - service not initialized and no detected context");
+    }
+  }
+  const currentPath = discovered?.currentWorktreePath ?? null;
+  const limit = pLimit2(DEFAULT_CONFIG.PARALLELISM.MAX_STATUS_CHECKS);
+  const results = await Promise.all(
+    worktrees.map(
+      (wt) => limit(async () => {
+        const resolvedPath = path9.resolve(wt.path);
+        const isCurrent = currentPath !== null && pathsEqual(wt.path, currentPath);
+        const [status, divergence, metadata] = await Promise.all([
+          git.getFullWorktreeStatus(wt.path, false).catch(() => null),
+          getDivergence(wt.path),
+          git.getWorktreeMetadata(wt.path).catch(() => null)
+        ]);
+        return {
+          path: resolvedPath,
+          branch: wt.branch,
+          isCurrent,
+          label: status ? deriveLabel(status, isCurrent) : "unknown",
+          status,
+          divergence,
+          safeToRemove: status ? status.canRemove && !status.upstreamGone : false,
+          lastSyncAt: metadata?.lastSyncDate ?? null
+        };
+      })
+    )
+  );
+  return formatToolResponse({ worktrees: results });
+}
+async function handleGetWorktreeStatus(ctx, params, _extra) {
+  const { git } = await getReadyService(ctx, params.repoName, {
+    capability: "canGetStatus",
+    toolName: "get_worktree_status"
+  });
+  const resolvedPath = await ensureRepoWorktreePath(ctx, params, git);
+  const [status, divergence] = await Promise.all([
+    git.getFullWorktreeStatus(params.path, params.includeDetails ?? false),
+    getDivergence(params.path)
+  ]);
+  return formatToolResponse({
+    path: resolvedPath,
+    ...status,
+    divergence
+  });
+}
+async function handleCreateWorktree(ctx, params, _extra) {
+  const { branchName, baseBranch, push } = params;
+  const validation = isValidGitBranchName(branchName);
+  if (!validation.valid) {
+    throw new Error(`Invalid branch name '${branchName}': ${validation.error}`);
+  }
+  const { service, git } = await getReadyService(ctx, params.repoName, {
+    capability: "canCreateWorktree",
+    toolName: "create_worktree",
+    ensureInitialized: true,
+    ensureNotSyncing: true
+  });
+  const existence = await git.branchExists(branchName);
+  let created = false;
+  let pushed = false;
+  if (!existence.local && !existence.remote) {
+    if (!baseBranch) {
+      throw new Error(`Branch '${branchName}' does not exist. Provide 'baseBranch' to create it.`);
+    }
+    await git.createBranch(branchName, baseBranch);
+    created = true;
+  }
+  const worktreeDir = service.config.worktreeDir;
+  const worktreePath = pathResolution.getBranchWorktreePath(worktreeDir, branchName);
+  const existing = await git.getWorktrees();
+  const collision = existing.find((w) => pathsEqual(w.path, worktreePath) && w.branch !== branchName);
+  if (collision) {
+    throw new Error(
+      `Sanitized worktree path '${worktreePath}' collides with existing branch '${collision.branch}'. Rename or remove the conflicting branch first.`
+    );
+  }
+  await git.addWorktree(branchName, worktreePath);
+  ctx.invalidateDiscovered();
+  if (created && push) {
+    await git.pushBranch(branchName);
+    pushed = true;
+  }
+  return formatToolResponse({
+    success: true,
+    branchName,
+    worktreePath: path9.resolve(worktreePath),
+    created,
+    pushed
+  });
+}
+async function handleRemoveWorktree(ctx, params, _extra) {
+  const { git } = await getReadyService(ctx, params.repoName, {
+    capability: "canRemoveWorktree",
+    toolName: "remove_worktree",
+    ensureInitialized: true,
+    ensureNotSyncing: true
+  });
+  const removedPath = await ensureRepoWorktreePath(ctx, params, git);
+  if (!params.force) {
+    const status = await git.getFullWorktreeStatus(params.path, false);
+    if (!status.canRemove) {
+      throw new Error(`Cannot remove worktree: ${status.reasons.join(", ")}. Use force=true to override.`);
+    }
+  }
+  await git.removeWorktree(params.path);
+  ctx.invalidateDiscovered();
+  return formatToolResponse({
+    success: true,
+    removedPath
+  });
+}
+async function handleSync(ctx, params, extra) {
+  const { service } = await getReadyService(ctx, params.repoName, {
+    capability: "canSync",
+    toolName: "sync",
+    ensureInitialized: true
+  });
+  const dispose = attachProgressReporter(service, extra);
+  try {
+    const start = Date.now();
+    const result = await service.sync();
+    if (!result.started) {
+      throw new SyncInProgressError(ctx.getEntry(params.repoName)?.name ?? params.repoName ?? "unknown");
+    }
+    const duration = Date.now() - start;
+    ctx.invalidateDiscovered();
+    return formatToolResponse({ success: true, duration });
+  } finally {
+    dispose();
+  }
+}
+async function handleUpdateWorktree(ctx, params, _extra) {
+  const { git } = await getReadyService(ctx, params.repoName, {
+    capability: "canUpdateWorktree",
+    toolName: "update_worktree",
+    ensureInitialized: true,
+    ensureNotSyncing: true
+  });
+  const worktreePath = await ensureRepoWorktreePath(ctx, params, git);
+  await git.updateWorktree(params.path);
+  ctx.invalidateDiscovered();
+  return formatToolResponse({
+    success: true,
+    worktreePath
+  });
+}
+async function handleInitialize(ctx, params, extra) {
+  const { service } = await getReadyService(ctx, params.repoName, {
+    capability: "canInitialize",
+    toolName: "initialize",
+    ensureNotSyncing: true
+  });
+  const dispose = attachProgressReporter(service, extra);
+  try {
+    await service.initialize();
+    const git = service.getGitService();
+    ctx.invalidateDiscovered();
+    return formatToolResponse({
+      success: true,
+      defaultBranch: git.getDefaultBranch(),
+      worktreeDir: service.config.worktreeDir
+    });
+  } finally {
+    dispose();
+  }
+}
+async function handleLoadConfig(ctx, params, _extra) {
+  const configPath = params.configPath ?? process.env.SYNC_WORKTREES_CONFIG;
+  if (!configPath) {
+    throw new Error("configPath required (or set SYNC_WORKTREES_CONFIG env var)");
+  }
+  await ctx.loadConfig(configPath);
+  return formatToolResponse({
+    configPath: path9.resolve(configPath),
+    currentRepository: ctx.getCurrentRepo(),
+    repositories: ctx.getRepositoryList()
+  });
+}
+async function handleSetCurrentRepository(ctx, params, _extra) {
+  ctx.setCurrentRepo(params.repoName);
+  return formatToolResponse({
+    currentRepository: ctx.getCurrentRepo(),
+    repositories: ctx.getRepositoryList()
+  });
+}
+function attachProgressReporter(service, extra) {
+  const token = extra?._meta?.progressToken;
+  if (token === void 0 || !extra) return () => {
+  };
+  if (!service.onProgress) return () => {
+  };
+  let progressCounter = 0;
+  const unsubscribe = service.onProgress((event) => {
+    progressCounter++;
+    void extra.sendNotification({
+      method: "notifications/progress",
+      params: {
+        progressToken: token,
+        progress: progressCounter,
+        message: `[${event.phase}] ${event.message}`
+      }
+    }).catch(() => {
+    });
+  });
+  return unsubscribe;
+}
+
+// src/mcp/server.ts
+var REPO_NAME_DESCRIBE = "Repository name from loaded config. If omitted, uses the current repository set via set_current_repository or the only loaded repo.";
+var PATH_DESCRIBE_SUFFIX = "Absolute path preferred; relative paths resolve from the server's CWD.";
+var SERVER_INSTRUCTIONS = "Before running git worktree operations, call `detect_context` to learn the current repo, current branch, and which capabilities are available. It reports whether the working directory is inside a sync-worktrees-managed workspace, lists sibling worktrees, and explains why any capability is disabled.";
+function createServer(context) {
+  const server = new McpServer(
+    {
+      name: "sync-worktrees",
+      version: "1.0.0"
+    },
+    {
+      instructions: SERVER_INSTRUCTIONS
+    }
+  );
+  server.registerResource(
+    "workspace",
+    "sync-worktrees://workspace",
+    {
+      title: "Workspace context",
+      description: "Current sync-worktrees workspace context: whether CWD is inside a managed worktree, the current branch, sibling worktrees, and available capabilities. Returns { isWorktree: false } when CWD is outside any workspace.",
+      mimeType: "application/json"
+    },
+    async (uri) => {
+      let discovered;
+      try {
+        discovered = await context.detectFromPath(process.cwd());
+      } catch (err) {
+        discovered = buildUnsupportedContext(process.cwd(), err instanceof Error ? err.message : String(err));
+      }
+      return {
+        contents: [
+          {
+            uri: uri.href,
+            mimeType: "application/json",
+            text: JSON.stringify(discovered, null, 2)
+          }
+        ]
+      };
+    }
+  );
+  server.registerTool(
+    "detect_context",
+    {
+      description: "Detect sync-worktrees structure from a filesystem path. Reads .git file, resolves bare repo, discovers sibling worktrees. Defaults to CWD. Use when: bootstrapping from an unknown checkout with no config loaded. Returns: discovered repo root, bare repo path, all sibling worktrees, current worktree path, capabilities.",
+      inputSchema: {
+        path: z.string().optional().describe("Directory path to inspect. Defaults to the server's CWD.")
+      },
+      annotations: {
+        title: "Detect sync-worktrees context",
+        readOnlyHint: true,
+        idempotentHint: true,
+        openWorldHint: false
+      }
+    },
+    wrapHandler((params, extra) => handleDetectContext(context, params, extra))
+  );
+  server.registerTool(
+    "list_worktrees",
+    {
+      description: "List all worktrees of a repository with enriched status. Returns: array of { path, branch, isCurrent, label (clean|dirty|stale|current|unknown), status, divergence (ahead/behind), safeToRemove, lastSyncAt }.",
+      inputSchema: {
+        repoName: z.string().optional().describe(REPO_NAME_DESCRIBE)
+      },
+      annotations: {
+        title: "List worktrees with status",
+        readOnlyHint: true,
+        idempotentHint: true,
+        openWorldHint: false
+      }
+    },
+    wrapHandler((params, extra) => handleListWorktrees(context, params, extra))
+  );
+  server.registerTool(
+    "get_worktree_status",
+    {
+      description: "Get detailed status for one worktree (dirty files, unpushed commits, stashes, upstream gone, operations in progress). Returns: full status object plus divergence { ahead, behind } and resolved absolute path.",
+      inputSchema: {
+        path: z.string().describe(`Worktree path. ${PATH_DESCRIBE_SUFFIX}`),
+        repoName: z.string().optional().describe(REPO_NAME_DESCRIBE),
+        includeDetails: z.boolean().optional().describe("If true, includes file-level lists (modified, untracked, staged). Default: false (counts only).")
+      },
+      annotations: {
+        title: "Get worktree status",
+        readOnlyHint: true,
+        idempotentHint: true,
+        openWorldHint: false
+      }
+    },
+    wrapHandler((params, extra) => handleGetWorktreeStatus(context, params, extra))
+  );
+  server.registerTool(
+    "create_worktree",
+    {
+      description: "Create a worktree for a branch. If the branch exists (local or remote), checks it out; otherwise creates it from baseBranch. Optionally pushes the new branch to origin. Key params: baseBranch is required only when the branch does not yet exist \u2014 pass it defensively if unsure. push=true only affects newly created branches. Preconditions: repository must be initialized (auto-runs on first call). Returns: { success, branchName, worktreePath, created, pushed }.",
+      inputSchema: {
+        branchName: z.string().describe("Branch name. Slashes and special chars are sanitized for the worktree directory name."),
+        baseBranch: z.string().optional().describe(
+          "Base branch for creating a new branch. Required if branchName does not exist locally or remotely; ignored otherwise."
+        ),
+        push: z.boolean().optional().describe("Push the newly created branch to origin. Ignored if the branch already existed."),
+        repoName: z.string().optional().describe(REPO_NAME_DESCRIBE)
+      },
+      annotations: {
+        title: "Create worktree",
+        readOnlyHint: false,
+        destructiveHint: false,
+        idempotentHint: false,
+        openWorldHint: true
+      }
+    },
+    wrapHandler((params, extra) => handleCreateWorktree(context, params, extra))
+  );
+  server.registerTool(
+    "remove_worktree",
+    {
+      description: "Remove a worktree. Runs safety checks first: rejects if worktree is dirty, has unpushed commits, has stashes, or has an in-progress git operation (merge/rebase/cherry-pick/revert/bisect). force=true: runs `git worktree remove --force`, which DELETES uncommitted and untracked files in the worktree directory. Branch ref, stashes, and remote state are preserved. Returns: { success, removedPath }.",
+      inputSchema: {
+        path: z.string().describe(`Worktree path to remove. ${PATH_DESCRIBE_SUFFIX}`),
+        force: z.boolean().optional().describe(
+          "Skip safety checks and delete uncommitted/untracked files in the worktree directory. Branch ref is preserved. Default: false."
+        ),
+        repoName: z.string().optional().describe(REPO_NAME_DESCRIBE)
+      },
+      annotations: {
+        title: "Remove worktree",
+        readOnlyHint: false,
+        destructiveHint: true,
+        idempotentHint: false,
+        openWorldHint: false
+      }
+    },
+    wrapHandler((params, extra) => handleRemoveWorktree(context, params, extra))
+  );
+  server.registerTool(
+    "sync",
+    {
+      description: "Full repo-wide synchronization: fetch all, create worktrees for new remote branches, remove worktrees for pruned remote branches (clean only), fast-forward existing worktrees. Emits progress notifications. Do not use when: you only need to update one worktree \u2014 use update_worktree. Only need to create one \u2014 use create_worktree. Preconditions: config must be loaded (load_config) and the repository initialized (auto-runs on first call). Returns: { success, duration } after sync completes.",
+      inputSchema: {
+        repoName: z.string().optional().describe(REPO_NAME_DESCRIBE)
+      },
+      annotations: {
+        title: "Sync repository worktrees",
+        readOnlyHint: false,
+        destructiveHint: true,
+        idempotentHint: false,
+        openWorldHint: true
+      }
+    },
+    wrapHandler((params, extra) => handleSync(context, params, extra))
+  );
+  server.registerTool(
+    "update_worktree",
+    {
+      description: "Fast-forward one worktree to match its upstream. No merge commits, no rebasing, aborts if not fast-forwardable. Do not use when: you want to update every worktree in the repo \u2014 use sync.",
+      inputSchema: {
+        path: z.string().describe(`Worktree path to fast-forward. ${PATH_DESCRIBE_SUFFIX}`),
+        repoName: z.string().optional().describe(REPO_NAME_DESCRIBE)
+      },
+      annotations: {
+        title: "Fast-forward one worktree",
+        readOnlyHint: false,
+        destructiveHint: false,
+        idempotentHint: true,
+        openWorldHint: true
+      }
+    },
+    wrapHandler((params, extra) => handleUpdateWorktree(context, params, extra))
+  );
+  server.registerTool(
+    "initialize",
+    {
+      description: "Initialize a repository: clone as bare repo if missing, create main worktree. Safe to call on already-initialized repos (no-op-ish). Emits progress notifications. Preconditions: config must be loaded (load_config) so the repo's URL and paths are known. Returns: { success, defaultBranch, worktreeDir }.",
+      inputSchema: {
+        repoName: z.string().optional().describe(REPO_NAME_DESCRIBE)
+      },
+      annotations: {
+        title: "Initialize repository",
+        readOnlyHint: false,
+        destructiveHint: false,
+        idempotentHint: true,
+        openWorldHint: true
+      }
+    },
+    wrapHandler((params, extra) => handleInitialize(context, params, extra))
+  );
+  server.registerTool(
+    "load_config",
+    {
+      description: "Load or reload a sync-worktrees JavaScript config file into the server's session. Replaces any previously loaded repositories. Call this before sync/initialize/create_worktree when using a config-driven workflow. Returns: { configPath, currentRepository, repositories: [{ name, repoPath, worktreeDir, ... }] }.",
+      inputSchema: {
+        configPath: z.string().optional().describe(
+          "Path to the config file. If omitted, falls back to the SYNC_WORKTREES_CONFIG env var. Errors if neither is set."
+        )
+      },
+      annotations: {
+        title: "Load sync-worktrees config",
+        readOnlyHint: false,
+        destructiveHint: false,
+        idempotentHint: true,
+        openWorldHint: false
+      }
+    },
+    wrapHandler((params, extra) => handleLoadConfig(context, params, extra))
+  );
+  server.registerTool(
+    "set_current_repository",
+    {
+      description: "Set the current repository for subsequent tool calls that omit repoName. Session-scoped; not persisted across server restarts. Preconditions: load_config must have been called so the name is known.",
+      inputSchema: {
+        repoName: z.string().describe("Repository name as listed in the loaded config's `repositories[].name`.")
+      },
+      annotations: {
+        title: "Set current repository",
+        readOnlyHint: false,
+        destructiveHint: false,
+        idempotentHint: true,
+        openWorldHint: false
+      }
+    },
+    wrapHandler((params, extra) => handleSetCurrentRepository(context, params, extra))
+  );
+  return server;
+}
+
+// src/mcp/index.ts
+async function main() {
+  const context = new RepositoryContext();
+  const configPath = process.env.SYNC_WORKTREES_CONFIG;
+  if (configPath) {
+    try {
+      await context.loadConfig(configPath);
+      process.stderr.write(`[sync-worktrees-mcp] Loaded config: ${configPath}
+`);
+    } catch (err) {
+      process.stderr.write(`[sync-worktrees-mcp] Failed to load SYNC_WORKTREES_CONFIG: ${err.message}
+`);
+    }
+  }
+  try {
+    const discovered = await context.detectFromPath(process.cwd());
+    if (discovered.isWorktree) {
+      process.stderr.write(
+        `[sync-worktrees-mcp] Auto-detected ${discovered.kind} worktree at ${discovered.currentWorktreePath} (branch: ${discovered.currentBranch})
+`
+      );
+    }
+  } catch (err) {
+    process.stderr.write(`[sync-worktrees-mcp] Auto-detect failed: ${err.message}
+`);
+  }
+  const server = createServer(context);
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+}
+main().catch((err) => {
+  process.stderr.write(`[sync-worktrees-mcp] Fatal error: ${err.message}
+`);
+  process.exit(1);
+});
+//# sourceMappingURL=mcp-server.js.map