@ricsam/r5d-worker 0.0.136 → 0.0.138

package/dist/cjs/project-worktrees.cjs

@@ -1,1713 +0,0 @@
-"use strict";
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var project_worktrees_exports = {};
-__export(project_worktrees_exports, {
-  PROJECT_REMOVED_CHECKOUTS_DIRECTORY: () => PROJECT_REMOVED_CHECKOUTS_DIRECTORY,
-  PROJECT_WORKTREE_SNAPSHOT_OWNER_SESSION_ID: () => PROJECT_WORKTREE_SNAPSHOT_OWNER_SESSION_ID,
-  PROJECT_WORKTREE_SNAPSHOT_PREFIX: () => PROJECT_WORKTREE_SNAPSHOT_PREFIX,
-  ProjectBranchCreationRollbackIncompleteError: () => ProjectBranchCreationRollbackIncompleteError,
-  applyObservedProjectMirrorHeads: () => applyObservedProjectMirrorHeads,
-  assertProjectMirrorHeadsPushed: () => assertProjectMirrorHeadsPushed,
-  classifyProjectCheckout: () => classifyProjectCheckout,
-  computeLocalProjectMirrorRefsTokens: () => computeLocalProjectMirrorRefsTokens,
-  createLinkedProjectBranch: () => createLinkedProjectBranch,
-  createOrRetryLinkedProjectBranch: () => createOrRetryLinkedProjectBranch,
-  deleteLinkedProjectBranch: () => deleteLinkedProjectBranch,
-  deleteProjectMirrorBranch: () => deleteProjectMirrorBranch,
-  ensureProjectWorktrees: () => ensureProjectWorktrees,
-  fastForwardProjectHeadsFromMirror: () => fastForwardProjectHeadsFromMirror,
-  hasLinkedProjectWorktreeLayout: () => hasLinkedProjectWorktreeLayout,
-  inventoryProjectCheckouts: () => inventoryProjectCheckouts,
-  observeProjectMirrorHeads: () => observeProjectMirrorHeads,
-  projectBranchMayExistAfterCreateFailure: () => projectBranchMayExistAfterCreateFailure,
-  projectOriginBranchName: () => projectOriginBranchName,
-  projectWorktreeConfigurationFingerprint: () => projectWorktreeConfigurationFingerprint,
-  projectWorktreeOperationInProgress: () => projectWorktreeOperationInProgress,
-  projectWorktreesTestHarness: () => projectWorktreesTestHarness,
-  pushProjectMirrorHeads: () => pushProjectMirrorHeads,
-  recoverStaleProjectWorktreeSnapshots: () => recoverStaleProjectWorktreeSnapshots,
-  removeProjectWorktrees: () => removeProjectWorktrees,
-  reseedProjectHeadsFromMirror: () => reseedProjectHeadsFromMirror,
-  runProjectSnapshotApplyJob: () => runProjectSnapshotApplyJob,
-  runProjectSnapshotCreateJob: () => runProjectSnapshotCreateJob,
-  runProjectSnapshotPersistJob: () => runProjectSnapshotPersistJob,
-  runProjectSnapshotRollbackJob: () => runProjectSnapshotRollbackJob
-});
-module.exports = __toCommonJS(project_worktrees_exports);
-var import_node_crypto = require("node:crypto");
-var import_node_fs = __toESM(require("node:fs"), 1);
-var import_node_os = __toESM(require("node:os"), 1);
-var import_node_path = __toESM(require("node:path"), 1);
-var import_git_process_environment = require("./git-process-environment.cjs");
-var import_managed_paths = require("./managed-paths.cjs");
-var import_project_checkout_garbage = require("./project-checkout-garbage.cjs");
-var import_project_mirror_refs_token = require("./project-mirror-refs-token.cjs");
-var import_working_tree_mirror = require("./working-tree-mirror.cjs");
-var import_workspace_filesystem_executor = require("./workspace-filesystem-executor.cjs");
-const PROJECT_WORKTREE_SNAPSHOT_PREFIX = "r5d-project-worktrees-";
-const PROJECT_WORKTREE_SNAPSHOT_MANIFEST = "transaction.json";
-const PROJECT_WORKTREE_SNAPSHOT_MANIFEST_VERSION = 1;
-const MAX_PROJECT_WORKTREE_SNAPSHOT_MANIFEST_BYTES = 64 * 1024;
-const PROJECT_WORKTREE_SNAPSHOT_OWNER_SESSION_ID = (0, import_node_crypto.randomUUID)();
-const UUID_PATTERN = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
-const PROJECT_GIT_TRANSPORT_TIMEOUT_MS = 3e4;
-const PROJECT_WORKTREE_SNAPSHOT_NAME = new RegExp(
-  `^${PROJECT_WORKTREE_SNAPSHOT_PREFIX.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}([1-9]\\d*)-([A-Za-z0-9]{6})$`
-);
-class ProjectBranchCreationRollbackIncompleteError extends Error {
-  branchMayExist = true;
-  cleanupFailures;
-  constructor(branchName, cleanupFailures, cause) {
-    super(`Project branch ${branchName} may still exist after incomplete rollback: ${cleanupFailures.join("; ")}`, { cause });
-    this.name = "ProjectBranchCreationRollbackIncompleteError";
-    this.cleanupFailures = [...cleanupFailures];
-  }
-}
-function projectBranchMayExistAfterCreateFailure(error) {
-  return error instanceof ProjectBranchCreationRollbackIncompleteError || typeof error === "object" && error !== null && "branchMayExist" in error && error.branchMayExist === true;
-}
-function projectWorktreeConfigurationFingerprint(input) {
-  return (0, import_node_crypto.createHash)("sha256").update(
-    JSON.stringify({
-      checkoutPathSegments: input.checkoutPathSegments,
-      projectPath: input.projectPath,
-      repoHttpUrl: input.repoHttpUrl,
-      repoAuthHeader: input.repoAuthHeader,
-      defaultBranch: input.defaultBranch,
-      repositoryTransitionId: input.repositoryTransitionId ?? null,
-      executionDisabled: input.executionDisabled ?? false,
-      mirrorWritesDisabled: input.mirrorWritesDisabled ?? false,
-      preserveOnlyBranches: [...input.preserveOnlyBranches ?? []].sort((left, right) => left.branchName.localeCompare(right.branchName)).map(({ branchId, branchName }) => ({ branchId: branchId ?? null, branchName })),
-      branches: [...input.branches].sort((left, right) => left.branchName.localeCompare(right.branchName)).map(({ branchId, branchName, sourceBranchName, baseCommitHash }) => ({
-        branchId: branchId ?? null,
-        branchName,
-        sourceBranchName: sourceBranchName ?? null,
-        baseCommitHash
-      })),
-      gitIdentity: input.gitIdentity
-    })
-  ).digest("hex");
-}
-const NON_RECURSIVE_GIT_CONFIG = [
-  "-c",
-  "submodule.recurse=false",
-  "-c",
-  "fetch.recurseSubmodules=false",
-  "-c",
-  "push.recurseSubmodules=false"
-];
-function gitCommandArgs(args) {
-  return ["git", ...NON_RECURSIVE_GIT_CONFIG, ...args];
-}
-function gitResult(cwd, args) {
-  const result = Bun.spawnSync(gitCommandArgs(args), {
-    cwd,
-    stdout: "pipe",
-    stderr: "pipe",
-    env: (0, import_git_process_environment.workerGitProcessEnvironment)()
-  });
-  return {
-    exitCode: result.exitCode,
-    stdout: result.stdout.toString().trim(),
-    stderr: result.stderr.toString().trim()
-  };
-}
-function git(cwd, args, action) {
-  const result = gitResult(cwd, args);
-  if (result.exitCode !== 0) throw new Error(`${action}: ${result.stderr || result.stdout || `git exited ${result.exitCode}`}`);
-  return result.stdout;
-}
-function tryGit(cwd, args) {
-  return gitResult(cwd, args).exitCode === 0;
-}
-async function gitResultAsync(cwd, args, timeoutMs) {
-  const subprocess = Bun.spawn(gitCommandArgs(args), {
-    cwd,
-    stdin: "ignore",
-    stdout: "pipe",
-    stderr: "pipe",
-    env: (0, import_git_process_environment.workerGitProcessEnvironment)()
-  });
-  let timedOut = false;
-  const timeout = timeoutMs ? setTimeout(() => {
-    timedOut = true;
-    subprocess.kill("SIGKILL");
-  }, timeoutMs) : void 0;
-  try {
-    const [stdout, stderr, exitCode] = await Promise.all([
-      new Response(subprocess.stdout).text(),
-      new Response(subprocess.stderr).text(),
-      subprocess.exited
-    ]);
-    if (timedOut) throw new Error(`Git transport timed out after ${timeoutMs}ms`);
-    return { exitCode, stdout: stdout.trim(), stderr: stderr.trim() };
-  } finally {
-    if (timeout) clearTimeout(timeout);
-  }
-}
-async function gitAsync(cwd, args, action) {
-  const result = await gitResultAsync(cwd, args);
-  if (result.exitCode !== 0) throw new Error(`${action}: ${result.stderr || result.stdout || `git exited ${result.exitCode}`}`);
-  return result.stdout;
-}
-async function tryGitAsync(cwd, args) {
-  return (await gitResultAsync(cwd, args)).exitCode === 0;
-}
-function branchPath(projectRoot, branchName) {
-  (0, import_managed_paths.validateManagedBranchName)(branchName);
-  const result = import_node_path.default.join(projectRoot, ...branchName.split("/"));
-  const relative = import_node_path.default.relative(import_node_path.default.resolve(projectRoot), import_node_path.default.resolve(result));
-  if (relative === ".." || relative.startsWith(`..${import_node_path.default.sep}`) || import_node_path.default.isAbsolute(relative)) {
-    throw new Error(`Branch path escapes its project root: ${branchName}`);
-  }
-  return result;
-}
-function assertNoSymlinkBranchPathComponents(projectRoot, branchPath2) {
-  const resolvedRoot = import_node_path.default.resolve(projectRoot);
-  const resolvedBranchPath = import_node_path.default.resolve(branchPath2);
-  const relative = import_node_path.default.relative(resolvedRoot, resolvedBranchPath);
-  if (relative === ".." || relative.startsWith(`..${import_node_path.default.sep}`) || import_node_path.default.isAbsolute(relative)) {
-    throw new Error(`Branch path escapes its project root: ${branchPath2}`);
-  }
-  let current = resolvedRoot;
-  for (const component of ["", ...relative.split(import_node_path.default.sep).filter(Boolean)]) {
-    if (component) current = import_node_path.default.join(current, component);
-    try {
-      if (import_node_fs.default.lstatSync(current).isSymbolicLink()) {
-        throw new Error(`Project branch path contains a symbolic link: ${current}`);
-      }
-    } catch (error) {
-      const code = error.code;
-      if (code === "ENOENT" || code === "ENOTDIR") return;
-      throw error;
-    }
-  }
-}
-function assertNonOverlappingBranches(branches) {
-  const names = branches.map(({ branchName }) => branchName).sort();
-  if (new Set(names).size !== names.length) throw new Error("Project worktree branch names must be unique");
-  for (let index = 0; index < names.length; index += 1) {
-    const name = names[index];
-    (0, import_managed_paths.validateManagedBranchName)(name);
-    const baseCommitHash = branches.find(({ branchName }) => branchName === name)?.baseCommitHash;
-    if (!baseCommitHash || !/^[0-9a-f]{40}(?:[0-9a-f]{24})?$/.test(baseCommitHash)) {
-      throw new Error(`Invalid base commit hash for project branch ${name}`);
-    }
-    const overlapping = names.slice(index + 1).find((candidate) => candidate.startsWith(`${name}/`));
-    if (overlapping) throw new Error(`Branch folders overlap: ${name} and ${overlapping}`);
-  }
-}
-function gitDirectoryKind(checkoutPath) {
-  const gitPath = import_node_path.default.join(checkoutPath, ".git");
-  try {
-    const stat = import_node_fs.default.lstatSync(gitPath);
-    if (stat.isDirectory()) return "directory";
-    if (stat.isFile()) return "file";
-    return null;
-  } catch {
-    return null;
-  }
-}
-function commonGitDirectory(checkoutPath) {
-  const result = gitResult(checkoutPath, ["rev-parse", "--path-format=absolute", "--git-common-dir"]);
-  return result.exitCode === 0 ? import_node_path.default.resolve(result.stdout) : null;
-}
-async function commonGitDirectoryAsync(checkoutPath) {
-  const result = await gitResultAsync(checkoutPath, ["rev-parse", "--path-format=absolute", "--git-common-dir"]);
-  return result.exitCode === 0 ? import_node_path.default.resolve(result.stdout) : null;
-}
-function hasLinkedProjectWorktreeLayout(input) {
-  const primaryPath = branchPath(input.projectRoot, input.primaryBranchName);
-  if (gitDirectoryKind(primaryPath) !== "directory") return false;
-  const primaryCommonDir = commonGitDirectory(primaryPath);
-  if (!primaryCommonDir) return false;
-  return input.branches.every(({ branchName }) => {
-    const checkoutPath = branchPath(input.projectRoot, branchName);
-    if (branchName === input.primaryBranchName) return commonGitDirectory(checkoutPath) === primaryCommonDir;
-    return gitDirectoryKind(checkoutPath) === "file" && commonGitDirectory(checkoutPath) === primaryCommonDir;
-  });
-}
-async function hasCompatibleLinkedProjectWorktreeLayout(input) {
-  const primaryPath = branchPath(input.projectRoot, input.primaryBranchName);
-  if (gitDirectoryKind(primaryPath) !== "directory") return false;
-  const primaryCommonDir = await commonGitDirectoryAsync(primaryPath);
-  if (!primaryCommonDir) return false;
-  for (const { branchName } of input.branches) {
-    if (branchName === input.primaryBranchName) continue;
-    const checkoutPath = branchPath(input.projectRoot, branchName);
-    const kind = gitDirectoryKind(checkoutPath);
-    if (kind === null) continue;
-    if (kind !== "file" || await commonGitDirectoryAsync(checkoutPath) !== primaryCommonDir) return false;
-  }
-  return true;
-}
-function fsyncDirectory(directory) {
-  const descriptor = import_node_fs.default.openSync(directory, "r");
-  try {
-    import_node_fs.default.fsyncSync(descriptor);
-  } finally {
-    import_node_fs.default.closeSync(descriptor);
-  }
-}
-function fsyncTree(targetPath) {
-  const stat = import_node_fs.default.lstatSync(targetPath);
-  if (stat.isSymbolicLink()) return;
-  if (stat.isDirectory()) {
-    for (const entry of import_node_fs.default.readdirSync(targetPath).sort()) fsyncTree(import_node_path.default.join(targetPath, entry));
-    fsyncDirectory(targetPath);
-    return;
-  }
-  if (!stat.isFile()) return;
-  const descriptor = import_node_fs.default.openSync(targetPath, "r");
-  try {
-    import_node_fs.default.fsyncSync(descriptor);
-  } finally {
-    import_node_fs.default.closeSync(descriptor);
-  }
-}
-function fsyncDirectoryChain(directory, root) {
-  const resolvedDirectory = import_node_path.default.resolve(directory);
-  const resolvedRoot = import_node_path.default.resolve(root);
-  const relative = import_node_path.default.relative(resolvedRoot, resolvedDirectory);
-  if (relative === ".." || relative.startsWith(`..${import_node_path.default.sep}`) || import_node_path.default.isAbsolute(relative)) {
-    throw new Error(`Directory is outside its durability root: ${resolvedDirectory}`);
-  }
-  let current = resolvedDirectory;
-  while (true) {
-    assertRealDirectory(current, "Durability path");
-    fsyncDirectory(current);
-    if (current === resolvedRoot) break;
-    current = import_node_path.default.dirname(current);
-  }
-}
-function removeSnapshotStorage(snapshotRoot) {
-  const storageRoot = import_node_path.default.dirname(import_node_path.default.resolve(snapshotRoot));
-  import_node_fs.default.rmSync(snapshotRoot, { recursive: true, force: true });
-  fsyncDirectory(storageRoot);
-}
-function fsyncManagedProjectRootEntry(projectRoot) {
-  fsyncDirectoryChain(projectRoot, import_node_path.default.dirname(import_node_path.default.dirname(projectRoot)));
-}
-function createProjectWorktreeSnapshotRoot(temporaryRoot = import_node_os.default.tmpdir()) {
-  const resolvedTemporaryRoot = import_node_path.default.resolve(temporaryRoot);
-  const storageRootExisted = import_node_fs.default.existsSync(resolvedTemporaryRoot);
-  import_node_fs.default.mkdirSync(resolvedTemporaryRoot, { recursive: true, mode: 448 });
-  assertRealDirectory(resolvedTemporaryRoot, "Project worktree snapshot storage root");
-  if (!storageRootExisted) fsyncDirectory(import_node_path.default.dirname(resolvedTemporaryRoot));
-  fsyncDirectory(resolvedTemporaryRoot);
-  const snapshotRoot = import_node_fs.default.mkdtempSync(import_node_path.default.join(resolvedTemporaryRoot, `${PROJECT_WORKTREE_SNAPSHOT_PREFIX}${process.pid}-`));
-  fsyncDirectory(snapshotRoot);
-  fsyncDirectory(resolvedTemporaryRoot);
-  return snapshotRoot;
-}
-function snapshotManifestPath(snapshotRoot) {
-  return import_node_path.default.join(snapshotRoot, PROJECT_WORKTREE_SNAPSHOT_MANIFEST);
-}
-function assertRealDirectory(directory, label) {
-  const stat = import_node_fs.default.lstatSync(directory);
-  if (!stat.isDirectory() || stat.isSymbolicLink()) throw new Error(`${label} must be a real directory`);
-}
-function normalizeSnapshotManifest(value) {
-  if (typeof value !== "object" || value === null || Array.isArray(value)) {
-    throw new Error("Project worktree snapshot manifest must be an object");
-  }
-  const record = value;
-  if (record.version !== PROJECT_WORKTREE_SNAPSHOT_MANIFEST_VERSION) {
-    throw new Error("Unsupported project worktree snapshot manifest version");
-  }
-  if (record.state !== "building" && record.state !== "prepared" && record.state !== "restoring" && record.state !== "consumed") {
-    throw new Error("Project worktree snapshot manifest has an invalid state");
-  }
-  const scope = record.scope === void 0 ? "project" : record.scope;
-  if (scope !== "project" && scope !== "branches") throw new Error("Project worktree snapshot manifest has an invalid scope");
-  if (!Number.isSafeInteger(record.ownerProcessId) || record.ownerProcessId <= 0) {
-    throw new Error("Project worktree snapshot manifest has an invalid owner process");
-  }
-  if (typeof record.ownerSessionId !== "string" || !UUID_PATTERN.test(record.ownerSessionId)) {
-    throw new Error("Project worktree snapshot manifest has an invalid owner session");
-  }
-  if (typeof record.projectRoot !== "string" || !import_node_path.default.isAbsolute(record.projectRoot) || import_node_path.default.resolve(record.projectRoot) !== record.projectRoot) {
-    throw new Error("Project worktree snapshot manifest has an invalid project root");
-  }
-  if (typeof record.createdAt !== "string" || !Number.isFinite(Date.parse(record.createdAt))) {
-    throw new Error("Project worktree snapshot manifest has an invalid creation time");
-  }
-  if (!Array.isArray(record.branches)) throw new Error("Project worktree snapshot manifest has invalid branches");
-  const branches = record.branches.map((value2) => {
-    if (typeof value2 !== "object" || value2 === null || Array.isArray(value2)) {
-      throw new Error("Project worktree snapshot manifest has an invalid branch");
-    }
-    const branch = value2;
-    if (typeof branch.branchName !== "string" || typeof branch.snapshotPresent !== "boolean") {
-      throw new Error("Project worktree snapshot manifest has an invalid branch");
-    }
-    (0, import_managed_paths.validateManagedBranchName)(branch.branchName);
-    return { branchName: branch.branchName, snapshotPresent: branch.snapshotPresent };
-  });
-  const names = branches.map(({ branchName }) => branchName).sort();
-  if (new Set(names).size !== names.length) throw new Error("Project worktree snapshot branch names must be unique");
-  for (let index = 0; index < names.length; index += 1) {
-    const name = names[index];
-    if (names.slice(index + 1).some((candidate) => candidate.startsWith(`${name}/`))) {
-      throw new Error("Project worktree snapshot branch paths overlap");
-    }
-  }
-  return {
-    version: PROJECT_WORKTREE_SNAPSHOT_MANIFEST_VERSION,
-    state: record.state,
-    scope,
-    ownerProcessId: record.ownerProcessId,
-    ownerSessionId: record.ownerSessionId,
-    projectRoot: record.projectRoot,
-    branches,
-    createdAt: record.createdAt
-  };
-}
-function readSnapshotManifest(snapshotRoot) {
-  assertRealDirectory(snapshotRoot, "Project worktree snapshot root");
-  const manifestPath = snapshotManifestPath(snapshotRoot);
-  const stat = import_node_fs.default.lstatSync(manifestPath);
-  if (!stat.isFile() || stat.isSymbolicLink()) throw new Error("Project worktree snapshot manifest must be a regular file");
-  if (stat.size > MAX_PROJECT_WORKTREE_SNAPSHOT_MANIFEST_BYTES) throw new Error("Project worktree snapshot manifest is too large");
-  return normalizeSnapshotManifest(JSON.parse(import_node_fs.default.readFileSync(manifestPath, "utf8")));
-}
-function writeSnapshotManifest(snapshotRoot, manifest) {
-  assertRealDirectory(snapshotRoot, "Project worktree snapshot root");
-  const normalized = normalizeSnapshotManifest(manifest);
-  const temporaryPath = import_node_path.default.join(snapshotRoot, `.${PROJECT_WORKTREE_SNAPSHOT_MANIFEST}.${process.pid}.${(0, import_node_crypto.randomUUID)()}.tmp`);
-  let descriptor;
-  try {
-    descriptor = import_node_fs.default.openSync(temporaryPath, "wx", 384);
-    import_node_fs.default.writeFileSync(descriptor, `${JSON.stringify(normalized, null, 2)}
-`, "utf8");
-    import_node_fs.default.fsyncSync(descriptor);
-    import_node_fs.default.closeSync(descriptor);
-    descriptor = void 0;
-    import_node_fs.default.renameSync(temporaryPath, snapshotManifestPath(snapshotRoot));
-    fsyncDirectory(snapshotRoot);
-  } finally {
-    if (descriptor !== void 0) import_node_fs.default.closeSync(descriptor);
-    import_node_fs.default.rmSync(temporaryPath, { force: true });
-  }
-  return readSnapshotManifest(snapshotRoot);
-}
-function assertSameSnapshotIdentity(expected, actual) {
-  if (expected.scope !== actual.scope || expected.ownerProcessId !== actual.ownerProcessId || expected.ownerSessionId !== actual.ownerSessionId || expected.projectRoot !== actual.projectRoot || expected.createdAt !== actual.createdAt || JSON.stringify(expected.branches) !== JSON.stringify(actual.branches)) {
-    throw new Error("Project worktree snapshot identity changed");
-  }
-}
-function advanceSnapshotState(snapshotRoot, expected, state) {
-  const current = readSnapshotManifest(snapshotRoot);
-  assertSameSnapshotIdentity(expected, current);
-  const allowed = current.state === "building" && state === "prepared" || current.state === "prepared" && state === "restoring" || current.state === "prepared" && state === "consumed" || current.state === "restoring" && state === "consumed" || current.state === state;
-  if (!allowed) throw new Error(`Project worktree snapshot cannot advance from ${current.state} to ${state}`);
-  return current.state === state ? current : writeSnapshotManifest(snapshotRoot, { ...current, state });
-}
-function fullSnapshotPath(snapshotRoot, branchName) {
-  (0, import_managed_paths.validateManagedBranchName)(branchName);
-  return import_node_path.default.join(snapshotRoot, "trees", ...branchName.split("/"));
-}
-function copyCheckoutTree(sourceRoot, targetRoot) {
-  const sourceStat = import_node_fs.default.lstatSync(sourceRoot);
-  if (!sourceStat.isDirectory() || sourceStat.isSymbolicLink()) {
-    throw new Error(`Project checkout snapshot source must be a real directory: ${sourceRoot}`);
-  }
-  import_node_fs.default.mkdirSync(import_node_path.default.dirname(targetRoot), { recursive: true });
-  import_node_fs.default.cpSync(sourceRoot, targetRoot, {
-    recursive: true,
-    dereference: false,
-    errorOnExist: true,
-    force: false,
-    mode: import_node_fs.default.constants.COPYFILE_FICLONE,
-    preserveTimestamps: true,
-    verbatimSymlinks: true
-  });
-}
-function measureCheckoutTree(root) {
-  const stat = import_node_fs.default.lstatSync(root);
-  if (stat.isSymbolicLink()) return 0;
-  if (stat.isFile()) return stat.size;
-  if (!stat.isDirectory()) return 0;
-  let bytes = 0;
-  for (const entry of import_node_fs.default.readdirSync(root).sort()) bytes += measureCheckoutTree(import_node_path.default.join(root, entry));
-  return bytes;
-}
-function snapshotBranchMeasurements(branches, sourcePath) {
-  return new Map(
-    branches.map(({ branchName, snapshotPresent }) => [branchName, snapshotPresent ? measureCheckoutTree(sourcePath(branchName)) : 0])
-  );
-}
-function assertNoOutstandingSnapshotForProject(temporaryRoot, projectRoot) {
-  let entries;
-  try {
-    assertRealDirectory(temporaryRoot, "Project worktree snapshot storage root");
-    entries = import_node_fs.default.readdirSync(temporaryRoot, { withFileTypes: true });
-  } catch (error) {
-    if (error.code === "ENOENT") return;
-    throw error;
-  }
-  for (const entry of entries) {
-    if (!entry.isDirectory() || entry.isSymbolicLink() || !PROJECT_WORKTREE_SNAPSHOT_NAME.test(entry.name)) continue;
-    let manifest;
-    try {
-      manifest = readSnapshotManifest(import_node_path.default.join(temporaryRoot, entry.name));
-    } catch (error) {
-      throw new Error(`Project checkout snapshot state is unreadable at ${import_node_path.default.join(temporaryRoot, entry.name)}`, { cause: error });
-    }
-    if (manifest.projectRoot === projectRoot && manifest.state !== "consumed") {
-      throw new Error(`Project checkout has an unfinished recovery snapshot at ${import_node_path.default.join(temporaryRoot, entry.name)}`);
-    }
-  }
-}
-function snapshotBranchTrees(projectRoot, branches, temporaryRoot, onProgress, scope, ownerSessionId) {
-  const resolvedProjectRoot = import_node_path.default.resolve(projectRoot);
-  const resolvedTemporaryRoot = import_node_path.default.resolve(temporaryRoot ?? import_node_os.default.tmpdir());
-  assertNoOutstandingSnapshotForProject(resolvedTemporaryRoot, resolvedProjectRoot);
-  const root = createProjectWorktreeSnapshotRoot(resolvedTemporaryRoot);
-  const paths = /* @__PURE__ */ new Map();
-  try {
-    const branchSnapshots = branches.map(({ branchName }) => {
-      const checkoutPath = branchPath(resolvedProjectRoot, branchName);
-      let snapshotPresent = false;
-      try {
-        import_node_fs.default.lstatSync(checkoutPath);
-        snapshotPresent = true;
-      } catch (error) {
-        if (error.code !== "ENOENT") throw error;
-      }
-      return { branchName, snapshotPresent };
-    });
-    let manifest = writeSnapshotManifest(root, {
-      version: PROJECT_WORKTREE_SNAPSHOT_MANIFEST_VERSION,
-      state: "building",
-      scope,
-      ownerProcessId: process.pid,
-      ownerSessionId,
-      projectRoot: resolvedProjectRoot,
-      branches: branchSnapshots,
-      createdAt: (/* @__PURE__ */ new Date()).toISOString()
-    });
-    onProgress?.({
-      operation: "snapshot",
-      phase: "scanning",
-      projectRoot: resolvedProjectRoot,
-      completedBranches: 0,
-      totalBranches: branchSnapshots.length,
-      completedBytes: 0
-    });
-    const branchBytes = snapshotBranchMeasurements(branchSnapshots, (branchName) => branchPath(resolvedProjectRoot, branchName));
-    const totalBytes = [...branchBytes.values()].reduce((total, bytes) => total + bytes, 0);
-    let completedBytes = 0;
-    let completedBranches = 0;
-    for (const { branchName, snapshotPresent } of branchSnapshots) {
-      onProgress?.({
-        operation: "snapshot",
-        phase: "copying",
-        projectRoot: resolvedProjectRoot,
-        branchName,
-        completedBranches,
-        totalBranches: branchSnapshots.length,
-        completedBytes,
-        totalBytes
-      });
-      if (snapshotPresent) {
-        const snapshotPath = fullSnapshotPath(root, branchName);
-        copyCheckoutTree(branchPath(resolvedProjectRoot, branchName), snapshotPath);
-        paths.set(branchName, snapshotPath);
-      }
-      completedBytes += branchBytes.get(branchName) ?? 0;
-      completedBranches += 1;
-      onProgress?.({
-        operation: "snapshot",
-        phase: "copying",
-        projectRoot: resolvedProjectRoot,
-        branchName,
-        completedBranches,
-        totalBranches: branchSnapshots.length,
-        completedBytes,
-        totalBytes
-      });
-    }
-    const treesRoot = import_node_path.default.join(root, "trees");
-    onProgress?.({
-      operation: "snapshot",
-      phase: "syncing",
-      projectRoot: resolvedProjectRoot,
-      completedBranches,
-      totalBranches: branchSnapshots.length,
-      completedBytes,
-      totalBytes
-    });
-    if (import_node_fs.default.existsSync(treesRoot)) fsyncTree(treesRoot);
-    manifest = advanceSnapshotState(root, manifest, "prepared");
-    return { root, manifest, paths };
-  } catch (error) {
-    removeSnapshotStorage(root);
-    throw error;
-  }
-}
-function restoreProjectWorktreeSnapshot(snapshotRoot, manifest, onProgress) {
-  let current = readSnapshotManifest(snapshotRoot);
-  assertSameSnapshotIdentity(manifest, current);
-  if (current.state !== "prepared" && current.state !== "restoring") {
-    throw new Error(`Project worktree snapshot is ${current.state}, not prepared or restoring`);
-  }
-  const treesRoot = import_node_path.default.join(snapshotRoot, "trees");
-  const treesRootPresent = import_node_fs.default.existsSync(treesRoot);
-  const treesRootStat = treesRootPresent ? import_node_fs.default.lstatSync(treesRoot) : null;
-  if (treesRootStat && (!treesRootStat.isDirectory() || treesRootStat.isSymbolicLink())) {
-    throw new Error("Project worktree snapshot trees root must be a real directory");
-  }
-  const branchSourceRoot = current.state === "restoring" && !treesRootPresent ? current.projectRoot : treesRoot;
-  for (const { branchName, snapshotPresent } of current.branches) {
-    const targetPath = branchPath(current.projectRoot, branchName);
-    assertNoSymlinkBranchPathComponents(current.projectRoot, targetPath);
-    const sourcePath = import_node_path.default.join(branchSourceRoot, ...branchName.split("/"));
-    if (!snapshotPresent) {
-      if (current.state === "restoring" && !treesRootPresent && import_node_fs.default.existsSync(sourcePath)) {
-        throw new Error(`Restored project branch unexpectedly exists: ${branchName}`);
-      }
-      continue;
-    }
-    const stat = import_node_fs.default.lstatSync(sourcePath);
-    if (!stat.isDirectory() || stat.isSymbolicLink()) {
-      throw new Error(`Project worktree snapshot branch must be a real directory: ${branchName}`);
-    }
-  }
-  onProgress?.({
-    operation: "restore",
-    phase: "scanning",
-    projectRoot: current.projectRoot,
-    completedBranches: 0,
-    totalBranches: current.branches.length,
-    completedBytes: 0
-  });
-  const branchBytes = snapshotBranchMeasurements(current.branches, (branchName) => import_node_path.default.join(branchSourceRoot, ...branchName.split("/")));
-  const totalBytes = [...branchBytes.values()].reduce((total, bytes) => total + bytes, 0);
-  const presentBranches = current.branches.filter(({ snapshotPresent }) => snapshotPresent);
-  const destinationParent = import_node_path.default.dirname(current.projectRoot);
-  import_node_fs.default.mkdirSync(destinationParent, { recursive: true });
-  const canMoveWholeSnapshot = current.scope === "project" && presentBranches.length > 0 && (current.state === "restoring" || treesRootStat !== null && treesRootStat.dev === import_node_fs.default.lstatSync(destinationParent).dev);
-  if (canMoveWholeSnapshot) {
-    if (current.state === "prepared") current = advanceSnapshotState(snapshotRoot, current, "restoring");
-    onProgress?.({
-      operation: "restore",
-      phase: "moving",
-      projectRoot: current.projectRoot,
-      completedBranches: treesRootPresent ? 0 : current.branches.length,
-      totalBranches: current.branches.length,
-      completedBytes: treesRootPresent ? 0 : totalBytes,
-      totalBytes
-    });
-    if (treesRootPresent) {
-      import_node_fs.default.rmSync(current.projectRoot, { recursive: true, force: true });
-      fsyncDirectoryChain(destinationParent, import_node_path.default.dirname(destinationParent));
-      import_node_fs.default.renameSync(treesRoot, current.projectRoot);
-      fsyncDirectory(snapshotRoot);
-    }
-    fsyncManagedProjectRootEntry(current.projectRoot);
-    onProgress?.({
-      operation: "restore",
-      phase: "moving",
-      projectRoot: current.projectRoot,
-      completedBranches: current.branches.length,
-      totalBranches: current.branches.length,
-      completedBytes: totalBytes,
-      totalBytes
-    });
-    return;
-  }
-  if (current.state === "restoring") {
-    throw new Error("Project worktree snapshot entered atomic restore state without a movable snapshot tree");
-  }
-  for (const { branchName } of [...current.branches].sort((left, right) => right.branchName.length - left.branchName.length)) {
-    const targetPath = branchPath(current.projectRoot, branchName);
-    const targetParent = import_node_path.default.dirname(targetPath);
-    import_node_fs.default.rmSync(targetPath, { recursive: true, force: true });
-    if (import_node_fs.default.existsSync(targetParent)) fsyncDirectoryChain(targetParent, current.projectRoot);
-  }
-  let completedBytes = 0;
-  let completedBranches = 0;
-  for (const { branchName, snapshotPresent } of current.branches) {
-    onProgress?.({
-      operation: "restore",
-      phase: "copying",
-      projectRoot: current.projectRoot,
-      branchName,
-      completedBranches,
-      totalBranches: current.branches.length,
-      completedBytes,
-      totalBytes
-    });
-    if (snapshotPresent) {
-      const targetPath = branchPath(current.projectRoot, branchName);
-      copyCheckoutTree(fullSnapshotPath(snapshotRoot, branchName), targetPath);
-      fsyncTree(targetPath);
-      fsyncDirectoryChain(import_node_path.default.dirname(targetPath), current.projectRoot);
-    }
-    completedBytes += branchBytes.get(branchName) ?? 0;
-    completedBranches += 1;
-    onProgress?.({
-      operation: "restore",
-      phase: "copying",
-      projectRoot: current.projectRoot,
-      branchName,
-      completedBranches,
-      totalBranches: current.branches.length,
-      completedBytes,
-      totalBytes
-    });
-  }
-  onProgress?.({
-    operation: "restore",
-    phase: "syncing",
-    projectRoot: current.projectRoot,
-    completedBranches,
-    totalBranches: current.branches.length,
-    completedBytes,
-    totalBytes
-  });
-  import_node_fs.default.mkdirSync(current.projectRoot, { recursive: true });
-  fsyncManagedProjectRootEntry(current.projectRoot);
-}
-function consumeAndRemoveProjectWorktreeSnapshot(snapshotRoot, manifest) {
-  const consumed = advanceSnapshotState(snapshotRoot, manifest, "consumed");
-  try {
-    assertSameSnapshotIdentity(manifest, consumed);
-    removeSnapshotStorage(snapshotRoot);
-  } catch {
-  }
-}
-function persistReconciledProjectAndConsumeSnapshot(snapshot, afterProjectTreeFsync, durabilityPaths) {
-  if (durabilityPaths) {
-    for (const durabilityPath of durabilityPaths) if (import_node_fs.default.existsSync(durabilityPath)) fsyncTree(durabilityPath);
-  } else {
-    fsyncTree(snapshot.manifest.projectRoot);
-  }
-  fsyncManagedProjectRootEntry(snapshot.manifest.projectRoot);
-  afterProjectTreeFsync?.();
-  consumeAndRemoveProjectWorktreeSnapshot(snapshot.root, snapshot.manifest);
-}
-function rollbackProjectWorktreeSnapshot(snapshot) {
-  const current = readSnapshotManifest(snapshot.root);
-  assertSameSnapshotIdentity(snapshot.manifest, current);
-  if (current.state === "prepared" || current.state === "restoring") {
-    restoreProjectWorktreeSnapshot(snapshot.root, current);
-    consumeAndRemoveProjectWorktreeSnapshot(snapshot.root, current);
-    return;
-  }
-  if (current.state === "consumed") {
-    try {
-      removeSnapshotStorage(snapshot.root);
-    } catch {
-    }
-    return;
-  }
-  throw new Error(`Project worktree snapshot is unexpectedly ${current.state}`);
-}
-function isProcessAlive(processId) {
-  try {
-    process.kill(processId, 0);
-    return true;
-  } catch (error) {
-    return error.code !== "ESRCH";
-  }
-}
-function isPathInside(root, candidate) {
-  const relative = import_node_path.default.relative(import_node_path.default.resolve(root), import_node_path.default.resolve(candidate));
-  return relative !== "" && relative !== ".." && !relative.startsWith(`..${import_node_path.default.sep}`) && !import_node_path.default.isAbsolute(relative);
-}
-function assertNoSymlinkPathComponents(root, candidate) {
-  const resolvedRoot = import_node_path.default.resolve(root);
-  const resolvedCandidate = import_node_path.default.resolve(candidate);
-  if (!isPathInside(resolvedRoot, resolvedCandidate)) throw new Error("Project worktree snapshot target escapes the projects root");
-  let current = resolvedRoot;
-  for (const component of ["", ...import_node_path.default.relative(resolvedRoot, resolvedCandidate).split(import_node_path.default.sep).filter(Boolean)]) {
-    if (component) current = import_node_path.default.join(current, component);
-    try {
-      if (import_node_fs.default.lstatSync(current).isSymbolicLink()) {
-        throw new Error(`Project worktree snapshot target contains a symbolic link: ${current}`);
-      }
-    } catch (error) {
-      const code = error.code;
-      if (code === "ENOENT" || code === "ENOTDIR") return;
-      throw error;
-    }
-  }
-}
-function recoverStaleProjectWorktreeSnapshots(input) {
-  const temporaryRoot = import_node_path.default.resolve(input.temporaryRoot ?? import_node_os.default.tmpdir());
-  const projectsRoot = import_node_path.default.resolve(input.projectsRoot);
-  const processAlive = input.processAlive ?? isProcessAlive;
-  const currentProcessId = input.currentProcessId ?? process.pid;
-  const currentOwnerSessionId = input.currentOwnerSessionId ?? PROJECT_WORKTREE_SNAPSHOT_OWNER_SESSION_ID;
-  if (!Number.isSafeInteger(currentProcessId) || currentProcessId <= 0) throw new Error("Current snapshot recovery process ID is invalid");
-  if (!UUID_PATTERN.test(currentOwnerSessionId)) throw new Error("Current snapshot recovery owner session is invalid");
-  const restored = [];
-  const removed = [];
-  const failed = [];
-  let entries;
-  try {
-    assertRealDirectory(temporaryRoot, "Project worktree snapshot storage root");
-    entries = import_node_fs.default.readdirSync(temporaryRoot, { withFileTypes: true });
-  } catch (error) {
-    if (error.code === "ENOENT") return { restored, removed, failed };
-    return { restored, removed, failed: [{ path: temporaryRoot, error: error instanceof Error ? error.message : String(error) }] };
-  }
-  for (const entry of entries.sort((left, right) => left.name.localeCompare(right.name))) {
-    const match = PROJECT_WORKTREE_SNAPSHOT_NAME.exec(entry.name);
-    if (!match) continue;
-    const ownerProcessId = Number(match[1]);
-    if (!Number.isSafeInteger(ownerProcessId)) continue;
-    const candidate = import_node_path.default.join(temporaryRoot, entry.name);
-    try {
-      const stat = import_node_fs.default.lstatSync(candidate);
-      if (!stat.isDirectory() || stat.isSymbolicLink()) continue;
-      const manifest = readSnapshotManifest(candidate);
-      if (manifest.ownerProcessId !== ownerProcessId) {
-        throw new Error("Project worktree snapshot owner does not match its directory name");
-      }
-      if (!isPathInside(projectsRoot, manifest.projectRoot)) {
-        throw new Error("Project worktree snapshot target is outside the configured projects root");
-      }
-      assertNoSymlinkPathComponents(projectsRoot, manifest.projectRoot);
-      const ownedByThisProcessSession = manifest.ownerProcessId === currentProcessId && manifest.ownerSessionId === currentOwnerSessionId;
-      if (ownedByThisProcessSession || ownerProcessId !== currentProcessId && processAlive(ownerProcessId)) continue;
-      if (manifest.state === "prepared" || manifest.state === "restoring") {
-        restoreProjectWorktreeSnapshot(candidate, manifest, input.onProgress);
-        const consumed = advanceSnapshotState(candidate, manifest, "consumed");
-        removeSnapshotStorage(candidate);
-        assertSameSnapshotIdentity(manifest, consumed);
-        restored.push(candidate);
-      } else {
-        removeSnapshotStorage(candidate);
-        removed.push(candidate);
-      }
-    } catch (error) {
-      if (ownerProcessId !== currentProcessId && processAlive(ownerProcessId)) continue;
-      if (error.code === "ENOENT") {
-        try {
-          import_node_fs.default.lstatSync(candidate);
-        } catch (candidateError) {
-          if (candidateError.code === "ENOENT") continue;
-        }
-      }
-      failed.push({ path: candidate, error: error instanceof Error ? error.message : String(error) });
-    }
-  }
-  return { restored, removed, failed };
-}
-function projectOriginBranchName(input) {
-  (0, import_managed_paths.validateManagedBranchName)(input.branchName);
-  (0, import_managed_paths.validateManagedBranchName)(input.primaryBranchName);
-  (0, import_managed_paths.validateManagedBranchName)(input.defaultBranch);
-  return input.branchName === input.primaryBranchName ? input.defaultBranch : input.branchName;
-}
-function configureProjectBranchTracking(checkoutPath, branchName, originBranchName) {
-  (0, import_managed_paths.validateManagedBranchName)(branchName);
-  (0, import_managed_paths.validateManagedBranchName)(originBranchName);
-  git(checkoutPath, ["config", "--local", `branch.${branchName}.remote`, "origin"], `configure origin for ${branchName}`);
-  git(
-    checkoutPath,
-    ["config", "--local", `branch.${branchName}.merge`, `refs/heads/${originBranchName}`],
-    `configure upstream branch for ${branchName}`
-  );
-}
-async function configureProjectBranchTrackingAsync(checkoutPath, branchName, originBranchName) {
-  (0, import_managed_paths.validateManagedBranchName)(branchName);
-  (0, import_managed_paths.validateManagedBranchName)(originBranchName);
-  await gitAsync(checkoutPath, ["config", "--local", `branch.${branchName}.remote`, "origin"], `configure origin for ${branchName}`);
-  await gitAsync(
-    checkoutPath,
-    ["config", "--local", `branch.${branchName}.merge`, `refs/heads/${originBranchName}`],
-    `configure upstream branch for ${branchName}`
-  );
-}
-async function configureRepository(input) {
-  if (await tryGitAsync(input.primaryPath, ["remote", "get-url", "origin"])) {
-    await gitAsync(input.primaryPath, ["remote", "set-url", "origin", input.originUrl], "configure project origin");
-  } else {
-    await gitAsync(input.primaryPath, ["remote", "add", "origin", input.originUrl], "configure project origin");
-  }
-  await tryGitAsync(input.primaryPath, ["config", "--local", "--unset-all", "remote.origin.pushurl"]);
-  await gitAsync(input.primaryPath, ["config", "--local", "--replace-all", "credential.helper", ""], "reset project credential helpers");
-  await gitAsync(input.primaryPath, ["config", "--local", "credential.useHttpPath", "false"], "configure project credential path matching");
-  if (input.originCredentialUsername) {
-    await gitAsync(
-      input.primaryPath,
-      ["config", "--local", "--replace-all", (0, import_git_process_environment.gitCredentialUsernameConfigKey)(input.originUrl), input.originCredentialUsername],
-      "configure project credential username"
-    );
-  }
-  if (input.credentialHelper) {
-    await gitAsync(
-      input.primaryPath,
-      ["config", "--local", "--add", "credential.helper", input.credentialHelper],
-      "configure project credential helper"
-    );
-  }
-  if (input.gitIdentity) {
-    const name = input.gitIdentity.name.trim();
-    const email = input.gitIdentity.email.trim();
-    if (!name || !email) throw new Error("Git identity must include name and email");
-    await gitAsync(input.primaryPath, ["config", "--local", "user.name", name], "configure project Git user name");
-    await gitAsync(input.primaryPath, ["config", "--local", "user.email", email], "configure project Git user email");
-  }
-  if (input.primaryBranchName && input.defaultBranch && input.branches) {
-    await gitAsync(input.primaryPath, ["config", "--local", "push.default", "upstream"], "configure project push mapping");
-    for (const { branchName } of input.branches) {
-      const originBranchName = projectOriginBranchName({
-        branchName,
-        primaryBranchName: input.primaryBranchName,
-        defaultBranch: input.defaultBranch
-      });
-      await configureProjectBranchTrackingAsync(input.primaryPath, branchName, originBranchName);
-    }
-  }
-}
-async function fetchProjectHeads(input) {
-  const originFetch = await gitResultAsync(
-    input.primaryPath,
-    [
-      ...(0, import_git_process_environment.gitTransportSecurityArgs)(input.originUrl, input.credentialHelper, input.originCredentialUsername),
-      "fetch",
-      "--no-recurse-submodules",
-      "--prune",
-      "origin",
-      "+refs/heads/*:refs/remotes/origin/*"
-    ],
-    PROJECT_GIT_TRANSPORT_TIMEOUT_MS
-  );
-  if (originFetch.exitCode !== 0) {
-    throw new Error(`Fetch project origin: ${originFetch.stderr || originFetch.stdout || `git exited ${originFetch.exitCode}`}`);
-  }
-  const mirrorFetch = await gitResultAsync(
-    input.primaryPath,
-    [
-      ...(0, import_git_process_environment.gitTransportSecurityArgs)(input.mirrorUrl, input.credentialHelper, input.mirrorCredentialUsername),
-      "fetch",
-      "--no-recurse-submodules",
-      "--prune",
-      input.mirrorUrl,
-      "+refs/heads/*:refs/r5d/mirror/*"
-    ],
-    PROJECT_GIT_TRANSPORT_TIMEOUT_MS
-  );
-  if (mirrorFetch.exitCode !== 0 && !/(couldn't find remote ref|does not have any commits|remote repository is empty|no such ref)/i.test(
-    `${mirrorFetch.stderr}
-${mirrorFetch.stdout}`
-  )) {
-    throw new Error(`Fetch project head mirror: ${mirrorFetch.stderr || mirrorFetch.stdout || `git exited ${mirrorFetch.exitCode}`}`);
-  }
-}
-async function ensureCommitAvailable(input) {
-  if (await tryGitAsync(input.primaryPath, ["cat-file", "-e", `${input.commitHash}^{commit}`])) return;
-  for (const [url, username] of [
-    [input.mirrorUrl, input.mirrorCredentialUsername],
-    [input.originUrl, input.originCredentialUsername]
-  ]) {
-    if (await tryGitAsync(input.primaryPath, [
-      ...(0, import_git_process_environment.gitTransportSecurityArgs)(url, input.credentialHelper, username),
-      "fetch",
-      "--no-recurse-submodules",
-      "--no-tags",
-      url,
-      input.commitHash
-    ]))
-      return;
-  }
-  throw new Error(`Project base commit ${input.commitHash} is unavailable from origin and the canonical mirror`);
-}
-async function seedForBranch(input) {
-  const mirrorRef = `refs/r5d/mirror/${input.branch.branchName}`;
-  const mirrorHead = await tryGitAsync(input.primaryPath, ["show-ref", "--verify", "--quiet", mirrorRef]) ? await gitAsync(input.primaryPath, ["rev-parse", mirrorRef], "resolve project mirror head") : null;
-  if (input.requireMirrorHead && !mirrorHead) {
-    throw new Error(`Exact hidden project mirror head is missing for ${input.branch.branchName}`);
-  }
-  const seed = mirrorHead ?? input.branch.baseCommitHash;
-  await ensureCommitAvailable({ ...input, commitHash: seed });
-  return { seed, mirrorHead };
-}
-async function preserveHead(checkoutPath) {
-  if (!await tryGitAsync(checkoutPath, ["rev-parse", "--verify", "HEAD"])) return;
-  const head = await gitAsync(checkoutPath, ["rev-parse", "HEAD"], "read pre-reconciliation project head");
-  await gitAsync(checkoutPath, ["update-ref", `refs/r5d/pre-connect/${head}`, head], "preserve pre-reconciliation project head");
-}
-async function initializeLinkedLayout(input) {
-  for (const { branchName } of [...input.branches].sort((left, right) => right.branchName.length - left.branchName.length)) {
-    import_node_fs.default.rmSync(branchPath(input.projectRoot, branchName), { recursive: true, force: true });
-  }
-  const primaryPath = branchPath(input.projectRoot, input.primaryBranchName);
-  import_node_fs.default.mkdirSync(import_node_path.default.dirname(primaryPath), { recursive: true });
-  await gitAsync(void 0, ["init", `--initial-branch=${input.primaryBranchName}`, primaryPath], "initialize primary project clone");
-  await configureRepository({ ...input, primaryPath });
-  await fetchProjectHeads({ ...input, primaryPath });
-  const seeds = /* @__PURE__ */ new Map();
-  const mirrorHeads = /* @__PURE__ */ new Map();
-  for (const branch of input.branches) {
-    const resolved = await seedForBranch({
-      ...input,
-      primaryPath,
-      branch,
-      requireMirrorHead: input.exactMirrorBranches?.has(branch.branchName)
-    });
-    seeds.set(branch.branchName, resolved.seed);
-    mirrorHeads.set(branch.branchName, resolved.mirrorHead);
-  }
-  await gitAsync(
-    primaryPath,
-    ["checkout", "--no-recurse-submodules", "-B", input.primaryBranchName, seeds.get(input.primaryBranchName)],
-    "anchor primary project worktree"
-  );
-  for (const branch of input.branches) {
-    if (branch.branchName === input.primaryBranchName) continue;
-    await gitAsync(
-      primaryPath,
-      ["branch", "-f", branch.branchName, seeds.get(branch.branchName)],
-      `anchor project branch ${branch.branchName}`
-    );
-    const checkoutPath = branchPath(input.projectRoot, branch.branchName);
-    import_node_fs.default.mkdirSync(import_node_path.default.dirname(checkoutPath), { recursive: true });
-    await gitAsync(
-      primaryPath,
-      ["worktree", "add", "--force", checkoutPath, branch.branchName],
-      `create linked worktree ${branch.branchName}`
-    );
-  }
-  return mirrorHeads;
-}
-async function reconcileLinkedLayout(input) {
-  const primaryPath = branchPath(input.projectRoot, input.primaryBranchName);
-  await configureRepository({ ...input, primaryPath });
-  await tryGitAsync(primaryPath, ["worktree", "prune"]);
-  await fetchProjectHeads({ ...input, primaryPath });
-  const primaryCommonDir = await commonGitDirectoryAsync(primaryPath);
-  if (!primaryCommonDir) throw new Error("Primary project checkout is unavailable");
-  const mirrorHeads = /* @__PURE__ */ new Map();
-  const plan = [];
-  for (const branch of input.branches) {
-    const checkoutPath = branchPath(input.projectRoot, branch.branchName);
-    const exactMirror = input.exactMirrorBranches?.has(branch.branchName) === true;
-    const resolved = await seedForBranch({
-      ...input,
-      primaryPath,
-      branch,
-      requireMirrorHead: exactMirror
-    });
-    mirrorHeads.set(branch.branchName, resolved.mirrorHead);
-    const linked = branch.branchName === input.primaryBranchName || gitDirectoryKind(checkoutPath) !== null && await commonGitDirectoryAsync(checkoutPath) === primaryCommonDir;
-    if (!linked) {
-      plan.push({ branchName: branch.branchName, checkoutPath, seed: resolved.seed, action: "recreate" });
-      continue;
-    }
-    const currentHead = await gitAsync(checkoutPath, ["rev-parse", "HEAD"], `resolve linked worktree head ${branch.branchName}`);
-    const keep = currentHead === resolved.seed || !exactMirror && await tryGitAsync(checkoutPath, ["merge-base", "--is-ancestor", resolved.seed, currentHead]);
-    plan.push({ branchName: branch.branchName, checkoutPath, seed: resolved.seed, action: keep ? "keep" : "reset" });
-  }
-  const mutatedBranches = new Set(plan.filter(({ action }) => action !== "keep").map(({ branchName }) => branchName));
-  if (mutatedBranches.size > 0) await input.beforeDestructiveMutation(mutatedBranches);
-  for (const entry of plan) {
-    if (entry.action === "keep") continue;
-    if (entry.action === "reset") {
-      await preserveHead(entry.checkoutPath);
-      await gitAsync(entry.checkoutPath, ["reset", "--hard", entry.seed], `anchor linked worktree ${entry.branchName}`);
-      continue;
-    }
-    import_node_fs.default.rmSync(entry.checkoutPath, { recursive: true, force: true });
-    await gitAsync(primaryPath, ["branch", "-f", entry.branchName, entry.seed], `anchor project branch ${entry.branchName}`);
-    import_node_fs.default.mkdirSync(import_node_path.default.dirname(entry.checkoutPath), { recursive: true });
-    await gitAsync(
-      primaryPath,
-      ["worktree", "add", "--force", entry.checkoutPath, entry.branchName],
-      `create linked worktree ${entry.branchName}`
-    );
-  }
-  return { mirrorHeads, mutatedBranches };
-}
-async function aheadBehind(checkoutPath, branchName, primaryBranchName, defaultBranch) {
-  const originBranchName = projectOriginBranchName({ branchName, primaryBranchName, defaultBranch });
-  const originRef = `refs/remotes/origin/${originBranchName}`;
-  if (!await tryGitAsync(checkoutPath, ["show-ref", "--verify", "--quiet", originRef])) return { ahead: null, behind: null };
-  const output = await gitAsync(
-    checkoutPath,
-    ["rev-list", "--left-right", "--count", `${originRef}...HEAD`],
-    "measure project origin divergence"
-  );
-  const [behind, ahead] = output.split(/\s+/).map(Number);
-  return Number.isFinite(ahead) && Number.isFinite(behind) ? { ahead, behind } : { ahead: null, behind: null };
-}
-async function ensureProjectWorktrees(input) {
-  const projectRoot = import_node_path.default.resolve(input.projectRoot);
-  const defaultBranch = input.defaultBranch ?? input.primaryBranchName;
-  assertNonOverlappingBranches(input.branches);
-  if (!input.branches.some(({ branchName }) => branchName === input.primaryBranchName)) {
-    throw new Error(`Primary project branch ${input.primaryBranchName} is missing from the workspace configuration`);
-  }
-  const snapshotStorageRoot = import_node_path.default.resolve(input.snapshotRoot ?? import_node_os.default.tmpdir());
-  assertNoOutstandingSnapshotForProject(snapshotStorageRoot, projectRoot);
-  let snapshot;
-  const ensureSnapshot = async (branchNames) => {
-    snapshot ??= await (0, import_workspace_filesystem_executor.workspaceFilesystemExecutor)().run(
-      "project_snapshot_create",
-      {
-        projectRoot,
-        branches: (branchNames ? input.branches.filter(({ branchName }) => branchNames.has(branchName)) : input.branches).map((branch) => ({
-          ...branch
-        })),
-        temporaryRoot: snapshotStorageRoot,
-        scope: branchNames ? "branches" : "project",
-        ownerSessionId: PROJECT_WORKTREE_SNAPSHOT_OWNER_SESSION_ID
-      },
-      { onProgress: input.onSnapshotProgress }
-    );
-    return snapshot;
-  };
-  try {
-    import_node_fs.default.mkdirSync(projectRoot, { recursive: true });
-    const linked = await hasCompatibleLinkedProjectWorktreeLayout({
-      projectRoot,
-      primaryBranchName: input.primaryBranchName,
-      branches: input.branches
-    });
-    let mirrorHeads;
-    let mutatedBranches;
-    if (linked) {
-      ({ mirrorHeads, mutatedBranches } = await reconcileLinkedLayout({
-        ...input,
-        projectRoot,
-        defaultBranch,
-        beforeDestructiveMutation: async (branchNames) => {
-          await ensureSnapshot(branchNames);
-        }
-      }));
-    } else {
-      await ensureSnapshot();
-      mirrorHeads = await initializeLinkedLayout({ ...input, projectRoot, defaultBranch });
-      mutatedBranches = new Set(input.branches.map(({ branchName }) => branchName));
-    }
-    const preparedSnapshot = snapshot;
-    if (mutatedBranches.size > 0 && !preparedSnapshot) {
-      throw new Error("Project worktree mutation started without a prepared recovery snapshot");
-    }
-    const snapshotMirrors = input.branches.flatMap((branch) => {
-      if (!mutatedBranches.has(branch.branchName)) return [];
-      const snapshotPath = preparedSnapshot?.paths.get(branch.branchName);
-      return snapshotPath ? [{ snapshotPath, targetPath: branchPath(projectRoot, branch.branchName) }] : [];
-    });
-    if (snapshotMirrors.length > 0) await (0, import_workspace_filesystem_executor.workspaceFilesystemExecutor)().run("project_snapshot_apply", { mirrors: snapshotMirrors });
-    const states = [];
-    for (const branch of input.branches) {
-      const checkoutPath = branchPath(projectRoot, branch.branchName);
-      const divergence = await aheadBehind(checkoutPath, branch.branchName, input.primaryBranchName, defaultBranch);
-      states.push({
-        branchName: branch.branchName,
-        branchPath: checkoutPath,
-        head: await gitAsync(checkoutPath, ["rev-parse", "HEAD"], `resolve project head ${branch.branchName}`),
-        mirrorHead: mirrorHeads.get(branch.branchName) ?? null,
-        ...divergence
-      });
-    }
-    states.sort((left, right) => left.branchName.localeCompare(right.branchName));
-    if (snapshot) {
-      const primaryGitDirectory = import_node_path.default.join(branchPath(projectRoot, input.primaryBranchName), ".git");
-      await (0, import_workspace_filesystem_executor.workspaceFilesystemExecutor)().run("project_snapshot_persist", {
-        snapshot,
-        durabilityPaths: snapshot.manifest.scope === "branches" ? [
-          ...snapshot.manifest.branches.map(({ branchName }) => branchPath(projectRoot, branchName)),
-          // Branch refs and worktree registrations moved in the shared
-          // administrative directory; objects are fsynced by git itself.
-          import_node_path.default.join(primaryGitDirectory, "refs"),
-          import_node_path.default.join(primaryGitDirectory, "packed-refs"),
-          import_node_path.default.join(primaryGitDirectory, "worktrees")
-        ] : null
-      });
-    }
-    return states;
-  } catch (error) {
-    if (!snapshot) throw error;
-    try {
-      await (0, import_workspace_filesystem_executor.workspaceFilesystemExecutor)().run("project_snapshot_rollback", { snapshot });
-    } catch (recoveryError) {
-      throw new Error(
-        `Project worktree reconciliation failed and its snapshot could not be fully restored; recovery state is retained at ${snapshot.root}`,
-        { cause: new AggregateError([error, recoveryError]) }
-      );
-    }
-    throw error;
-  }
-}
-const WORKTREE_OPERATION_STATE_PATHS = ["MERGE_HEAD", "CHERRY_PICK_HEAD", "REVERT_HEAD", "rebase-merge", "rebase-apply", "sequencer"];
-function perWorktreeGitDirectory(checkoutPath) {
-  const gitPath = import_node_path.default.join(checkoutPath, ".git");
-  let stat;
-  try {
-    stat = import_node_fs.default.lstatSync(gitPath);
-  } catch {
-    return null;
-  }
-  if (stat.isDirectory()) return gitPath;
-  if (!stat.isFile()) return null;
-  let pointer;
-  try {
-    pointer = import_node_fs.default.readFileSync(gitPath, "utf8");
-  } catch {
-    return null;
-  }
-  const match = /^gitdir:[ \t]*(.+?)[ \t\r\n]*$/m.exec(pointer);
-  if (!match?.[1]) return null;
-  return import_node_path.default.resolve(checkoutPath, match[1]);
-}
-function projectWorktreeOperationInProgress(checkoutPath) {
-  const gitDirectory = perWorktreeGitDirectory(checkoutPath);
-  if (!gitDirectory) return false;
-  return WORKTREE_OPERATION_STATE_PATHS.some((statePath) => import_node_fs.default.existsSync(import_node_path.default.join(gitDirectory, statePath)));
-}
-function createLinkedProjectBranch(input) {
-  (0, import_managed_paths.validateManagedBranchName)(input.sourceBranchName);
-  (0, import_managed_paths.validateManagedBranchName)(input.branchName);
-  if (input.sourceBranchName === input.branchName) throw new Error("Source and target branch names must differ");
-  const sourcePath = branchPath(input.projectRoot, input.sourceBranchName);
-  const targetPath = branchPath(input.projectRoot, input.branchName);
-  assertNoSymlinkBranchPathComponents(input.projectRoot, sourcePath);
-  assertNoSymlinkBranchPathComponents(input.projectRoot, targetPath);
-  if (!commonGitDirectory(sourcePath)) throw new Error(`Source worktree ${input.sourceBranchName} is unavailable`);
-  if (projectWorktreeOperationInProgress(sourcePath)) {
-    throw new Error(`Source worktree ${input.sourceBranchName} has an in-progress Git operation`);
-  }
-  if (import_node_fs.default.existsSync(targetPath) || tryGit(sourcePath, ["show-ref", "--verify", "--quiet", `refs/heads/${input.branchName}`])) {
-    throw new Error(`Project branch ${input.branchName} already exists`);
-  }
-  const registeredWorktrees = git(sourcePath, ["worktree", "list", "--porcelain"], "inspect linked project worktrees").split(/\r?\n/).flatMap((line) => line.startsWith("worktree ") ? [import_node_path.default.resolve(line.slice("worktree ".length))] : []);
-  const overlappingWorktree = registeredWorktrees.find((worktreePath) => {
-    const targetRelative = import_node_path.default.relative(worktreePath, targetPath);
-    const worktreeRelative = import_node_path.default.relative(targetPath, worktreePath);
-    return targetRelative === "" || targetRelative !== ".." && !targetRelative.startsWith(`..${import_node_path.default.sep}`) && !import_node_path.default.isAbsolute(targetRelative) || worktreeRelative !== ".." && !worktreeRelative.startsWith(`..${import_node_path.default.sep}`) && !import_node_path.default.isAbsolute(worktreeRelative);
-  });
-  if (overlappingWorktree) throw new Error(`Project branch folder overlaps linked worktree ${overlappingWorktree}`);
-  const sourceHead = git(sourcePath, ["rev-parse", "HEAD"], "resolve source branch head");
-  let branchCreated = false;
-  try {
-    git(sourcePath, ["branch", input.branchName, sourceHead], `create project branch ${input.branchName}`);
-    branchCreated = true;
-    import_node_fs.default.mkdirSync(import_node_path.default.dirname(targetPath), { recursive: true });
-    assertNoSymlinkBranchPathComponents(input.projectRoot, targetPath);
-    git(
-      sourcePath,
-      ["worktree", "add", "--force", "--no-checkout", targetPath, input.branchName],
-      `create linked worktree ${input.branchName}`
-    );
-    configureProjectBranchTracking(targetPath, input.branchName, input.branchName);
-    assertNoSymlinkBranchPathComponents(input.projectRoot, targetPath);
-    if (input.workingTree === "carry") {
-      git(targetPath, ["read-tree", sourceHead], `initialize linked worktree index ${input.branchName}`);
-      (0, import_working_tree_mirror.mirrorWorkingTree)({ sourceRoot: sourcePath, targetRoot: targetPath, sourceMode: "git", deletionMode: "git" });
-    } else {
-      git(targetPath, ["reset", "--hard", sourceHead], `check out linked worktree ${input.branchName}`);
-    }
-    return { branchPath: targetPath, baseCommitHash: sourceHead };
-  } catch (error) {
-    if (branchCreated) {
-      let removeError;
-      try {
-        import_node_fs.default.rmSync(targetPath, { recursive: true, force: true });
-      } catch (cleanupError) {
-        removeError = cleanupError;
-      }
-      const prune = gitResult(sourcePath, ["worktree", "prune"]);
-      const deleteBranch = gitResult(sourcePath, ["branch", "-D", input.branchName]);
-      const cleanupFailures = [];
-      try {
-        import_node_fs.default.lstatSync(targetPath);
-        cleanupFailures.push(`target path remains at ${targetPath}`);
-      } catch (verificationError) {
-        const code = verificationError.code;
-        if (code !== "ENOENT" && code !== "ENOTDIR") {
-          cleanupFailures.push(
-            `could not verify target removal${removeError ? ` after ${removeError instanceof Error ? removeError.message : String(removeError)}` : ""}: ${verificationError instanceof Error ? verificationError.message : String(verificationError)}`
-          );
-        }
-      }
-      const worktrees = gitResult(sourcePath, ["worktree", "list", "--porcelain"]);
-      if (worktrees.exitCode !== 0) {
-        cleanupFailures.push(
-          `could not verify linked-worktree removal: ${worktrees.stderr || worktrees.stdout || `git exited ${worktrees.exitCode}`}`
-        );
-      } else {
-        const targetRegistered = worktrees.stdout.split(/\r?\n/).some((line) => line.startsWith("worktree ") && import_node_path.default.resolve(line.slice("worktree ".length)) === import_node_path.default.resolve(targetPath));
-        if (targetRegistered) {
-          cleanupFailures.push(
-            `linked worktree remains registered at ${targetPath}${prune.exitCode === 0 ? "" : ` (${prune.stderr || prune.stdout || `git exited ${prune.exitCode}`})`}`
-          );
-        }
-      }
-      const branchRef = gitResult(sourcePath, ["show-ref", "--verify", "--quiet", `refs/heads/${input.branchName}`]);
-      if (branchRef.exitCode === 0) {
-        cleanupFailures.push(
-          `branch ref remains${deleteBranch.exitCode === 0 ? "" : ` (${deleteBranch.stderr || deleteBranch.stdout || `git exited ${deleteBranch.exitCode}`})`}`
-        );
-      } else if (branchRef.exitCode !== 1) {
-        cleanupFailures.push(
-          `could not verify branch ref removal: ${branchRef.stderr || branchRef.stdout || `git exited ${branchRef.exitCode}`}`
-        );
-      }
-      if (cleanupFailures.length > 0) {
-        throw new ProjectBranchCreationRollbackIncompleteError(input.branchName, cleanupFailures, error);
-      }
-    }
-    throw error;
-  }
-}
-async function createOrRetryLinkedProjectBranch(input) {
-  if (input.pendingRetry) {
-    deleteLinkedProjectBranch({
-      projectRoot: input.projectRoot,
-      primaryBranchName: input.primaryBranchName,
-      branchName: input.branchName
-    });
-  }
-  return await (0, import_workspace_filesystem_executor.workspaceFilesystemExecutor)().run("project_branch_create", {
-    projectRoot: input.projectRoot,
-    sourceBranchName: input.sourceBranchName,
-    branchName: input.branchName,
-    workingTree: input.workingTree
-  });
-}
-function classifyProjectCheckout(input) {
-  const checkoutPath = branchPath(input.projectRoot, input.branchName);
-  let stat;
-  try {
-    stat = import_node_fs.default.lstatSync(checkoutPath);
-  } catch {
-    return "missing";
-  }
-  if (!stat.isDirectory()) return "not_a_worktree";
-  if (input.branchName === input.primaryBranchName) return gitDirectoryKind(checkoutPath) === "directory" ? "linked" : "not_a_worktree";
-  if (gitDirectoryKind(checkoutPath) !== "file") return "not_a_worktree";
-  const gitDirectory = perWorktreeGitDirectory(checkoutPath);
-  if (!gitDirectory) return "not_a_worktree";
-  let registry;
-  let registered;
-  try {
-    registry = import_node_fs.default.realpathSync(import_node_path.default.join(branchPath(input.projectRoot, input.primaryBranchName), ".git", "worktrees"));
-    registered = import_node_fs.default.realpathSync(gitDirectory);
-  } catch {
-    return "not_a_worktree";
-  }
-  const relative = import_node_path.default.relative(registry, registered);
-  if (!relative || relative === ".." || relative.startsWith(`..${import_node_path.default.sep}`) || import_node_path.default.isAbsolute(relative)) return "not_a_worktree";
-  return "linked";
-}
-function inventoryProjectCheckouts(input) {
-  const states = input.branchNames.map((branchName) => ({
-    branchName,
-    checkoutPath: branchPath(input.projectRoot, branchName),
-    state: classifyProjectCheckout({ ...input, branchName })
-  }));
-  const primaryLinked = states.some(({ branchName, state }) => branchName === input.primaryBranchName && state === "linked");
-  const inventory = { linkedBranchNames: [], missingCheckouts: [] };
-  for (const { branchName, checkoutPath, state } of states) {
-    if (primaryLinked && state === "linked") inventory.linkedBranchNames.push(branchName);
-    else inventory.missingCheckouts.push({ branchName, checkoutPath, reason: state === "linked" ? "not_a_worktree" : state });
-  }
-  return inventory;
-}
-const PROJECT_REMOVED_CHECKOUTS_DIRECTORY = ".r5d-removed";
-function moveProjectCheckoutAside(projectRoot, branchName, checkoutPath) {
-  const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
-  const target = import_node_path.default.join(projectRoot, PROJECT_REMOVED_CHECKOUTS_DIRECTORY, ...`${branchName}-${timestamp}`.split("/"));
-  import_node_fs.default.mkdirSync(import_node_path.default.dirname(target), { recursive: true });
-  import_node_fs.default.renameSync(checkoutPath, target);
-  return target;
-}
-function deleteLinkedProjectBranch(input) {
-  (0, import_managed_paths.validateManagedBranchName)(input.primaryBranchName);
-  (0, import_managed_paths.validateManagedBranchName)(input.branchName);
-  if (input.branchName === input.primaryBranchName) throw new Error(`Cannot delete the primary project branch ${input.primaryBranchName}`);
-  const primaryPath = branchPath(input.projectRoot, input.primaryBranchName);
-  const checkoutPath = branchPath(input.projectRoot, input.branchName);
-  const primaryCommonDir = commonGitDirectory(primaryPath);
-  if (!primaryCommonDir) throw new Error("Primary project checkout is unavailable");
-  let movedAsidePath;
-  let stagedForCollectionPath;
-  if (import_node_fs.default.existsSync(checkoutPath)) {
-    const checkoutCommonDir = import_node_fs.default.lstatSync(checkoutPath).isDirectory() ? commonGitDirectory(checkoutPath) : null;
-    if (checkoutCommonDir !== primaryCommonDir) {
-      movedAsidePath = moveProjectCheckoutAside(input.projectRoot, input.branchName, checkoutPath);
-      tryGit(primaryPath, ["worktree", "prune"]);
-    } else {
-      if (projectWorktreeOperationInProgress(checkoutPath)) {
-        throw new Error(`Project branch ${input.branchName} has an in-progress Git operation`);
-      }
-      stagedForCollectionPath = (0, import_project_checkout_garbage.stageProjectCheckoutForDeletion)(input.projectRoot, input.branchName, checkoutPath);
-      git(primaryPath, ["worktree", "prune"], `prune linked worktree ${input.branchName}`);
-    }
-  } else {
-    tryGit(primaryPath, ["worktree", "prune"]);
-  }
-  const branchRef = `refs/heads/${input.branchName}`;
-  if (tryGit(primaryPath, ["show-ref", "--verify", "--quiet", branchRef])) {
-    git(primaryPath, ["branch", "-D", input.branchName], `delete project branch ${input.branchName}`);
-  }
-  return {
-    branchName: input.branchName,
-    ...movedAsidePath ? { movedAsidePath } : {},
-    ...stagedForCollectionPath ? { stagedForCollectionPath } : {}
-  };
-}
-function removeProjectWorktrees(input) {
-  const projectRoot = import_node_path.default.resolve(input.projectRoot);
-  if (input.branchNames.length === 0) throw new Error("Cannot remove a project with no configured branches");
-  for (const branchName of input.branchNames) {
-    (0, import_managed_paths.validateManagedBranchName)(branchName);
-    const checkoutPath = branchPath(projectRoot, branchName);
-    if (import_node_fs.default.existsSync(checkoutPath) && projectWorktreeOperationInProgress(checkoutPath)) {
-      throw new Error(`Project branch ${branchName} has an in-progress Git operation`);
-    }
-  }
-  if (!import_node_fs.default.existsSync(projectRoot)) return {};
-  return { stagedForCollectionPath: (0, import_project_checkout_garbage.stageProjectForDeletion)(input.projectsRoot, projectRoot) };
-}
-async function deleteProjectMirrorBranch(input) {
-  (0, import_managed_paths.validateManagedBranchName)(input.branchName);
-  const deleted = await gitResultAsync(
-    input.gitDirectory,
-    [
-      ...(0, import_git_process_environment.gitTransportSecurityArgs)(input.mirrorUrl, input.credentialHelper, input.credentialUsername),
-      "push",
-      "--no-recurse-submodules",
-      input.mirrorUrl,
-      `:refs/heads/${input.branchName}`
-    ],
-    PROJECT_GIT_TRANSPORT_TIMEOUT_MS
-  );
-  if (deleted.exitCode !== 0 && !/(remote ref does not exist|unable to delete|no such ref)/i.test(`${deleted.stderr}
-${deleted.stdout}`)) {
-    throw new Error(
-      `Delete hidden project mirror for ${input.branchName}: ${deleted.stderr || deleted.stdout || `git exited ${deleted.exitCode}`}`
-    );
-  }
-  await gitResultAsync(input.gitDirectory, ["update-ref", "-d", `refs/r5d/mirror/${input.branchName}`]);
-}
-async function pushProjectMirrorHeads(input) {
-  const results = [];
-  for (const branchName of [...input.branchNames].sort()) {
-    if (input.onlyBranches && !input.onlyBranches.has(branchName)) continue;
-    const checkoutPath = branchPath(input.projectRoot, branchName);
-    const head = input.publicationHeads ? input.publicationHeads.get(branchName) : await gitAsync(checkoutPath, ["rev-parse", "HEAD"], `resolve mirror head for ${branchName}`);
-    if (!head || !/^[0-9a-f]{40}(?:[0-9a-f]{24})?$/.test(head)) {
-      throw new Error(`Missing exact publication head for project branch ${branchName}`);
-    }
-    if (!await tryGitAsync(checkoutPath, ["cat-file", "-e", `${head}^{commit}`])) {
-      throw new Error(`Exact publication head ${head} is unavailable for project branch ${branchName}`);
-    }
-    if (!input.expectedMirrorHeads.has(branchName)) {
-      throw new Error(`Missing hidden-mirror lease for project branch ${branchName}`);
-    }
-    const expectedMirrorHead = input.expectedMirrorHeads.get(branchName) ?? null;
-    if (expectedMirrorHead !== null && !/^[0-9a-f]{40}(?:[0-9a-f]{24})?$/.test(expectedMirrorHead)) {
-      throw new Error(`Invalid hidden-mirror lease for project branch ${branchName}`);
-    }
-    const branchId = input.branchIds.get(branchName);
-    if (!branchId || !/^[A-Za-z0-9][A-Za-z0-9_-]{0,127}$/.test(branchId)) {
-      throw new Error(`Missing valid branch incarnation for project branch ${branchName}`);
-    }
-    if (expectedMirrorHead) {
-      const handoffPrefix = `refs/r5d/server-synced/${branchId}/`;
-      const markedCommits = (await gitAsync(
-        checkoutPath,
-        ["for-each-ref", "--format=%(objectname)", handoffPrefix],
-        `inspect synchronized server commits before publishing ${branchName}`
-      )).split(/\r?\n/).filter((value) => /^[0-9a-f]{40}(?:[0-9a-f]{24})?$/.test(value));
-      for (const markedCommit of markedCommits) {
-        const markerIsInLease = await tryGitAsync(checkoutPath, ["merge-base", "--is-ancestor", markedCommit, expectedMirrorHead]);
-        if (markerIsInLease && !await tryGitAsync(checkoutPath, ["merge-base", "--is-ancestor", markedCommit, head])) {
-          throw new Error(`Refusing to overwrite synchronized server commit history for project branch ${branchName}`);
-        }
-      }
-    }
-    if (projectWorktreeOperationInProgress(checkoutPath)) {
-      results.push({ branchName, head, pushed: false, reason: "git_operation_in_progress" });
-      continue;
-    }
-    const pushed = await gitResultAsync(
-      checkoutPath,
-      [
-        ...(0, import_git_process_environment.gitTransportSecurityArgs)(input.mirrorUrl, input.credentialHelper, input.credentialUsername),
-        "push",
-        "--no-recurse-submodules",
-        `--force-with-lease=refs/heads/${branchName}:${expectedMirrorHead ?? ""}`,
-        input.mirrorUrl,
-        `${head}:refs/heads/${branchName}`
-      ],
-      PROJECT_GIT_TRANSPORT_TIMEOUT_MS
-    );
-    if (pushed.exitCode !== 0) {
-      throw new Error(`Push hidden project mirror for ${branchName}: ${pushed.stderr || pushed.stdout || `git exited ${pushed.exitCode}`}`);
-    }
-    await gitAsync(checkoutPath, ["update-ref", `refs/r5d/mirror/${branchName}`, head], `record pushed mirror tip ${branchName}`);
-    results.push({ branchName, head, pushed: true });
-  }
-  return results;
-}
-function assertProjectMirrorHeadsPushed(results) {
-  const skipped = results.find((result) => !result.pushed);
-  if (skipped) {
-    throw new Error(`Hidden project mirror publication skipped ${skipped.branchName}${skipped.reason ? ` (${skipped.reason})` : ""}`);
-  }
-}
-const PROJECT_MIRROR_FETCH_REFSPECS = ["+refs/heads/*:refs/r5d/mirror/*", "+refs/r5d/server-synced/*:refs/r5d/server-synced/*"];
-function projectMirrorMountFetchRefspecs(branchName, branchId) {
-  (0, import_managed_paths.validateManagedBranchName)(branchName);
-  if (branchId !== void 0 && !/^[A-Za-z0-9][A-Za-z0-9_-]{0,127}$/.test(branchId)) throw new Error(`Invalid branch id for ${branchName}`);
-  return [
-    `+refs/heads/${branchName}:refs/r5d/mirror/${branchName}`,
-    branchId === void 0 ? "+refs/r5d/server-synced/*:refs/r5d/server-synced/*" : `+refs/r5d/server-synced/${branchId}/*:refs/r5d/server-synced/${branchId}/*`
-  ];
-}
-async function fetchProjectMirrorRefs(input) {
-  const fetch = (refspecs) => gitResultAsync(
-    input.primaryPath,
-    [
-      ...(0, import_git_process_environment.gitTransportSecurityArgs)(input.mirrorUrl, input.credentialHelper, input.credentialUsername),
-      "fetch",
-      "--no-recurse-submodules",
-      "--prune",
-      input.mirrorUrl,
-      ...refspecs
-    ],
-    PROJECT_GIT_TRANSPORT_TIMEOUT_MS
-  );
-  if (input.fetchOnlyBranches && input.fetchOnlyBranches.size > 0) {
-    const refspecs = [...input.fetchOnlyBranches].sort().flatMap((branchName) => projectMirrorMountFetchRefspecs(branchName, input.branchIds?.get(branchName)));
-    const scoped = await fetch(refspecs);
-    if (scoped.exitCode === 0) return;
-    if (!/(couldn't find remote ref|no such ref)/i.test(`${scoped.stderr}
-${scoped.stdout}`)) {
-      throw new Error(`Refresh project head mirror: ${scoped.stderr || scoped.stdout || `git exited ${scoped.exitCode}`}`);
-    }
-  }
-  const whole = await fetch(PROJECT_MIRROR_FETCH_REFSPECS);
-  if (whole.exitCode !== 0) {
-    throw new Error(`Refresh project head mirror: ${whole.stderr || whole.stdout || `git exited ${whole.exitCode}`}`);
-  }
-}
-async function observeProjectMirrorHeads(input) {
-  const primaryPath = branchPath(input.projectRoot, input.primaryBranchName);
-  if (input.refreshRemote !== false && !(input.fetchOnlyBranches && input.fetchOnlyBranches.size === 0)) {
-    await fetchProjectMirrorRefs({ ...input, primaryPath });
-  }
-  const observations = [];
-  for (const branchName of [...input.branchNames].sort()) {
-    const checkoutPath = branchPath(input.projectRoot, branchName);
-    const previousHead = await gitAsync(checkoutPath, ["rev-parse", "HEAD"], `resolve local project head ${branchName}`);
-    const mirrorRef = `refs/r5d/mirror/${branchName}`;
-    const mirrorHead = await tryGitAsync(primaryPath, ["show-ref", "--verify", "--quiet", mirrorRef]) ? await gitAsync(primaryPath, ["rev-parse", mirrorRef], `resolve refreshed mirror head ${branchName}`) : null;
-    const branchId = input.branchIds?.get(branchName);
-    if (branchId && !/^[A-Za-z0-9][A-Za-z0-9_-]{0,127}$/.test(branchId)) throw new Error(`Invalid branch id for ${branchName}`);
-    const handoffPrefix = branchId ? `refs/r5d/server-synced/${branchId}/` : null;
-    const handoffRows = handoffPrefix ? await gitAsync(
-      primaryPath,
-      ["for-each-ref", "--format=%(objectname) %(refname)", handoffPrefix],
-      `inspect synchronized server commits for ${branchName}`
-    ) : "";
-    const serverSyncedWorkspaceHeads = (await Promise.all(
-      handoffRows.split(/\r?\n/).map(async (row) => {
-        const separator = row.indexOf(" ");
-        if (separator < 0 || !mirrorHead) return null;
-        const markedCommit = row.slice(0, separator);
-        const ref = row.slice(separator + 1);
-        if (!/^[0-9a-f]{40}(?:[0-9a-f]{24})?$/.test(markedCommit) || !handoffPrefix || !ref.startsWith(handoffPrefix)) {
-          return null;
-        }
-        const markerIsIntegrated = markedCommit === mirrorHead || await tryGitAsync(primaryPath, ["merge-base", "--is-ancestor", markedCommit, mirrorHead]);
-        if (!markerIsIntegrated) return null;
-        const workspaceHead = ref.slice(handoffPrefix.length);
-        return /^[0-9a-f]{40}(?:[0-9a-f]{24})?$/.test(workspaceHead) ? workspaceHead : null;
-      })
-    )).filter((workspaceHead) => workspaceHead !== null).sort();
-    const fastForward = Boolean(
-      mirrorHead && mirrorHead !== previousHead && await tryGitAsync(checkoutPath, ["merge-base", "--is-ancestor", previousHead, mirrorHead])
-    );
-    const serverSynced = Boolean(mirrorHead && mirrorHead !== previousHead && serverSyncedWorkspaceHeads.length > 0);
-    const shouldMove = Boolean(mirrorHead && mirrorHead !== previousHead && (input.allowNonFastForward || fastForward || serverSynced));
-    observations.push({
-      branchName,
-      previousHead,
-      mirrorHead,
-      mode: input.allowNonFastForward ? "reseed" : serverSynced && !fastForward ? "server_synced" : "fast_forward",
-      serverSyncedWorkspaceHeads,
-      shouldMove
-    });
-  }
-  return observations;
-}
-async function computeLocalProjectMirrorRefsTokens(input) {
-  const primaryPath = branchPath(input.projectRoot, input.primaryBranchName);
-  const rows = await gitAsync(
-    primaryPath,
-    ["for-each-ref", import_project_mirror_refs_token.PROJECT_MIRROR_REF_LISTING_FORMAT, import_project_mirror_refs_token.PROJECT_MIRROR_REF_PREFIX, import_project_mirror_refs_token.PROJECT_SERVER_SYNCED_REF_PREFIX],
-    "list cached project mirror refs"
-  );
-  return (0, import_project_mirror_refs_token.projectMirrorRefsTokens)((0, import_project_mirror_refs_token.canonicalizeLocalProjectMirrorRefs)((0, import_project_mirror_refs_token.parseProjectMirrorRefListing)(rows)), input.mounts);
-}
-async function applyObservedProjectMirrorHeads(input) {
-  const results = [];
-  for (const observation of [...input.observations].sort((left, right) => left.branchName.localeCompare(right.branchName))) {
-    const { branchName, mirrorHead } = observation;
-    const checkoutPath = branchPath(input.projectRoot, branchName);
-    const currentHead = await gitAsync(checkoutPath, ["rev-parse", "HEAD"], `resolve local project head ${branchName}`);
-    const serverSyncedCovered = observation.mode !== "server_synced" || (input.serverSyncedWorkspaceCovered ? await input.serverSyncedWorkspaceCovered(observation) : false);
-    if (!observation.shouldMove || !serverSyncedCovered || !mirrorHead || currentHead === mirrorHead || currentHead !== observation.previousHead) {
-      results.push({ branchName, previousHead: currentHead, mirrorHead, moved: false });
-      continue;
-    }
-    if (!await tryGitAsync(checkoutPath, ["cat-file", "-e", `${mirrorHead}^{commit}`])) {
-      throw new Error(`Observed hidden mirror head is no longer available for ${branchName}: ${mirrorHead}`);
-    }
-    const mutationAllowed = () => !projectWorktreeOperationInProgress(checkoutPath) && input.branchMutationAllowed?.(branchName, checkoutPath) !== false;
-    if (!mutationAllowed()) {
-      results.push({ branchName, previousHead: currentHead, mirrorHead, moved: false });
-      continue;
-    }
-    if (observation.mode === "reseed" || observation.mode === "server_synced") {
-      await preserveHead(checkoutPath);
-      if (!mutationAllowed()) {
-        results.push({ branchName, previousHead: currentHead, mirrorHead, moved: false });
-        continue;
-      }
-    }
-    const action = observation.mode === "reseed" ? "reseed" : observation.mode === "server_synced" ? "adopt server commit" : "fast-forward";
-    await gitAsync(checkoutPath, ["read-tree", "--reset", mirrorHead], `${action} project index ${branchName}`);
-    await gitAsync(
-      checkoutPath,
-      ["update-ref", `refs/heads/${branchName}`, mirrorHead, currentHead],
-      `${action} project branch ${branchName}`
-    );
-    results.push({ branchName, previousHead: currentHead, mirrorHead, moved: true });
-  }
-  return results;
-}
-async function updateProjectHeadsFromMirror(input) {
-  const observations = await observeProjectMirrorHeads(input);
-  return applyObservedProjectMirrorHeads({
-    projectRoot: input.projectRoot,
-    primaryBranchName: input.primaryBranchName,
-    observations,
-    branchMutationAllowed: input.branchMutationAllowed
-  });
-}
-async function fastForwardProjectHeadsFromMirror(input) {
-  return (await updateProjectHeadsFromMirror({ ...input, allowNonFastForward: false })).map(({ moved, ...state }) => ({
-    ...state,
-    fastForwarded: moved
-  }));
-}
-async function reseedProjectHeadsFromMirror(input) {
-  return (await updateProjectHeadsFromMirror({ ...input, allowNonFastForward: true })).map(({ moved, ...state }) => ({
-    ...state,
-    reseeded: moved
-  }));
-}
-function runProjectSnapshotCreateJob(input, context) {
-  return snapshotBranchTrees(input.projectRoot, input.branches, input.temporaryRoot, context.progress, input.scope, input.ownerSessionId);
-}
-function runProjectSnapshotApplyJob(input) {
-  for (const { snapshotPath, targetPath } of input.mirrors) {
-    (0, import_working_tree_mirror.mirrorWorkingTree)({ sourceRoot: snapshotPath, targetRoot: targetPath, sourceMode: "all", deletionMode: "git" });
-  }
-  return null;
-}
-function runProjectSnapshotPersistJob(input) {
-  persistReconciledProjectAndConsumeSnapshot(input.snapshot, void 0, input.durabilityPaths ?? void 0);
-  return null;
-}
-function runProjectSnapshotRollbackJob(input) {
-  rollbackProjectWorktreeSnapshot(input.snapshot);
-  return null;
-}
-const projectWorktreesTestHarness = {
-  commandArgs: gitCommandArgs,
-  configureRepository,
-  createPreparedSnapshot(input) {
-    return {
-      root: snapshotBranchTrees(
-        input.projectRoot,
-        input.branches,
-        input.temporaryRoot,
-        void 0,
-        input.scope ?? "project",
-        PROJECT_WORKTREE_SNAPSHOT_OWNER_SESSION_ID
-      ).root
-    };
-  },
-  consumeSnapshot(snapshotRoot) {
-    const manifest = readSnapshotManifest(snapshotRoot);
-    advanceSnapshotState(snapshotRoot, manifest, "consumed");
-  },
-  persistProjectAndConsumeSnapshot(snapshotRoot, afterProjectTreeFsync) {
-    const manifest = readSnapshotManifest(snapshotRoot);
-    persistReconciledProjectAndConsumeSnapshot({ root: snapshotRoot, manifest, paths: /* @__PURE__ */ new Map() }, afterProjectTreeFsync);
-  },
-  snapshotState(snapshotRoot) {
-    return readSnapshotManifest(snapshotRoot).state;
-  }
-};
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  PROJECT_REMOVED_CHECKOUTS_DIRECTORY,
-  PROJECT_WORKTREE_SNAPSHOT_OWNER_SESSION_ID,
-  PROJECT_WORKTREE_SNAPSHOT_PREFIX,
-  ProjectBranchCreationRollbackIncompleteError,
-  applyObservedProjectMirrorHeads,
-  assertProjectMirrorHeadsPushed,
-  classifyProjectCheckout,
-  computeLocalProjectMirrorRefsTokens,
-  createLinkedProjectBranch,
-  createOrRetryLinkedProjectBranch,
-  deleteLinkedProjectBranch,
-  deleteProjectMirrorBranch,
-  ensureProjectWorktrees,
-  fastForwardProjectHeadsFromMirror,
-  hasLinkedProjectWorktreeLayout,
-  inventoryProjectCheckouts,
-  observeProjectMirrorHeads,
-  projectBranchMayExistAfterCreateFailure,
-  projectOriginBranchName,
-  projectWorktreeConfigurationFingerprint,
-  projectWorktreeOperationInProgress,
-  projectWorktreesTestHarness,
-  pushProjectMirrorHeads,
-  recoverStaleProjectWorktreeSnapshots,
-  removeProjectWorktrees,
-  reseedProjectHeadsFromMirror,
-  runProjectSnapshotApplyJob,
-  runProjectSnapshotCreateJob,
-  runProjectSnapshotPersistJob,
-  runProjectSnapshotRollbackJob
-});