@ricsam/r5d-worker 0.0.78 → 0.0.80

package/dist/cjs/project-worktrees.cjs

@@ -29,18 +29,26 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var project_worktrees_exports = {};
 __export(project_worktrees_exports, {
   PROJECT_WORKTREE_SNAPSHOT_PREFIX: () => PROJECT_WORKTREE_SNAPSHOT_PREFIX,
-  cleanupStaleProjectWorktreeSnapshots: () => cleanupStaleProjectWorktreeSnapshots,
+  ProjectBranchCreationRollbackIncompleteError: () => ProjectBranchCreationRollbackIncompleteError,
+  applyObservedProjectMirrorHeads: () => applyObservedProjectMirrorHeads,
+  assertProjectMirrorHeadsPushed: () => assertProjectMirrorHeadsPushed,
   createLinkedProjectBranch: () => createLinkedProjectBranch,
+  createOrRetryLinkedProjectBranch: () => createOrRetryLinkedProjectBranch,
   deleteLinkedProjectBranch: () => deleteLinkedProjectBranch,
   deleteProjectMirrorBranch: () => deleteProjectMirrorBranch,
   ensureProjectWorktrees: () => ensureProjectWorktrees,
   fastForwardProjectHeadsFromMirror: () => fastForwardProjectHeadsFromMirror,
   hasLinkedProjectWorktreeLayout: () => hasLinkedProjectWorktreeLayout,
+  observeProjectMirrorHeads: () => observeProjectMirrorHeads,
+  projectBranchMayExistAfterCreateFailure: () => projectBranchMayExistAfterCreateFailure,
+  projectOriginBranchName: () => projectOriginBranchName,
   projectWorktreeConfigurationFingerprint: () => projectWorktreeConfigurationFingerprint,
   projectWorktreeOperationInProgress: () => projectWorktreeOperationInProgress,
   projectWorktreesTestHarness: () => projectWorktreesTestHarness,
   pushProjectMirrorHeads: () => pushProjectMirrorHeads,
-  removeProjectWorktrees: () => removeProjectWorktrees
+  recoverStaleProjectWorktreeSnapshots: () => recoverStaleProjectWorktreeSnapshots,
+  removeProjectWorktrees: () => removeProjectWorktrees,
+  reseedProjectHeadsFromMirror: () => reseedProjectHeadsFromMirror
 });
 module.exports = __toCommonJS(project_worktrees_exports);
 var import_node_crypto = require("node:crypto");
@@ -51,9 +59,26 @@ var import_git_process_environment = require("./git-process-environment.cjs");
 var import_managed_paths = require("./managed-paths.cjs");
 var import_working_tree_mirror = require("./working-tree-mirror.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_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({
@@ -62,7 +87,12 @@ function projectWorktreeConfigurationFingerprint(input) {
       repoHttpUrl: input.repoHttpUrl,
       repoAuthHeader: input.repoAuthHeader,
       defaultBranch: input.defaultBranch,
-      branches: [...input.branches].sort((left, right) => left.branchName.localeCompare(right.branchName)).map(({ branchName, sourceBranchName, baseCommitHash }) => ({
+      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
@@ -112,6 +142,27 @@ function branchPath(projectRoot, 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");
@@ -164,26 +215,310 @@ function hasCompatibleLinkedProjectWorktreeLayout(input) {
     return kind === null || kind === "file" && commonGitDirectory(checkoutPath) === primaryCommonDir;
   });
 }
-function createProjectWorktreeSnapshotRoot() {
-  return import_node_fs.default.mkdtempSync(import_node_path.default.join(import_node_os.default.tmpdir(), `${PROJECT_WORKTREE_SNAPSHOT_PREFIX}${process.pid}-`));
+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 !== "consumed") {
+    throw new Error("Project worktree snapshot manifest has an invalid state");
+  }
+  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,
+    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.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 === "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 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) {
-  const root = createProjectWorktreeSnapshotRoot();
+function snapshotBranchTrees(projectRoot, branches, temporaryRoot) {
+  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 {
-    for (const { branchName } of branches) {
-      const checkoutPath = branchPath(projectRoot, branchName);
-      if (!import_node_fs.default.existsSync(checkoutPath)) continue;
-      const snapshotPath = import_node_path.default.join(root, ...branchName.split("/"));
-      (0, import_working_tree_mirror.mirrorWorkingTree)({ sourceRoot: checkoutPath, targetRoot: snapshotPath, sourceMode: "all", deletionMode: "all" });
+    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",
+      ownerProcessId: process.pid,
+      ownerSessionId: PROJECT_WORKTREE_SNAPSHOT_OWNER_SESSION_ID,
+      projectRoot: resolvedProjectRoot,
+      branches: branchSnapshots,
+      createdAt: (/* @__PURE__ */ new Date()).toISOString()
+    });
+    for (const { branchName, snapshotPresent } of branchSnapshots) {
+      if (!snapshotPresent) continue;
+      const snapshotPath = fullSnapshotPath(root, branchName);
+      copyCheckoutTree(branchPath(resolvedProjectRoot, branchName), snapshotPath);
       paths.set(branchName, snapshotPath);
     }
-    return { root, paths };
+    const treesRoot = import_node_path.default.join(root, "trees");
+    if (import_node_fs.default.existsSync(treesRoot)) fsyncTree(treesRoot);
+    manifest = advanceSnapshotState(root, manifest, "prepared");
+    return { root, manifest, paths };
   } catch (error) {
-    import_node_fs.default.rmSync(root, { recursive: true, force: true });
+    removeSnapshotStorage(root);
     throw error;
   }
 }
+function restoreProjectWorktreeSnapshot(snapshotRoot, manifest) {
+  const current = readSnapshotManifest(snapshotRoot);
+  assertSameSnapshotIdentity(manifest, current);
+  if (current.state !== "prepared") throw new Error(`Project worktree snapshot is ${current.state}, not prepared`);
+  for (const { branchName, snapshotPresent } of current.branches) {
+    const targetPath = branchPath(current.projectRoot, branchName);
+    assertNoSymlinkBranchPathComponents(current.projectRoot, targetPath);
+    if (!snapshotPresent) continue;
+    const sourcePath = fullSnapshotPath(snapshotRoot, branchName);
+    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}`);
+    }
+  }
+  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);
+  }
+  for (const { branchName, snapshotPresent } of current.branches) {
+    if (!snapshotPresent) continue;
+    const targetPath = branchPath(current.projectRoot, branchName);
+    copyCheckoutTree(fullSnapshotPath(snapshotRoot, branchName), targetPath);
+    fsyncTree(targetPath);
+    fsyncDirectoryChain(import_node_path.default.dirname(targetPath), current.projectRoot);
+  }
+  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) {
+  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") {
+    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);
@@ -192,35 +527,105 @@ function isProcessAlive(processId) {
     return error.code !== "ESRCH";
   }
 }
-function cleanupStaleProjectWorktreeSnapshots(input = {}) {
+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 { removed, failed };
-    return { removed, failed: [{ path: temporaryRoot, error: error instanceof Error ? error.message : String(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) || processAlive(ownerProcessId)) continue;
+    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;
-      import_node_fs.default.rmSync(candidate, { recursive: true, force: true });
-      removed.push(candidate);
+      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") {
+        restoreProjectWorktreeSnapshot(candidate, manifest);
+        const consumed = advanceSnapshotState(candidate, manifest, "consumed");
+        removeSnapshotStorage(candidate);
+        assertSameSnapshotIdentity(manifest, consumed);
+        restored.push(candidate);
+      } else {
+        removeSnapshotStorage(candidate);
+        removed.push(candidate);
+      }
     } catch (error) {
-      if (error.code === "ENOENT") continue;
+      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 { removed, failed };
+  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}`
+  );
 }
 function configureRepository(input) {
   if (tryGit(input.primaryPath, ["remote", "get-url", "origin"])) {
@@ -252,6 +657,17 @@ function configureRepository(input) {
     git(input.primaryPath, ["config", "--local", "user.name", name], "configure project Git user name");
     git(input.primaryPath, ["config", "--local", "user.email", email], "configure project Git user email");
   }
+  if (input.primaryBranchName && input.defaultBranch && input.branches) {
+    git(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
+      });
+      configureProjectBranchTracking(input.primaryPath, branchName, originBranchName);
+    }
+  }
 }
 function fetchProjectHeads(input) {
   const originFetch = gitResult(input.primaryPath, [
@@ -301,6 +717,9 @@ function ensureCommitAvailable(input) {
 function seedForBranch(input) {
   const mirrorRef = `refs/r5d/mirror/${input.branch.branchName}`;
   const mirrorHead = tryGit(input.primaryPath, ["show-ref", "--verify", "--quiet", mirrorRef]) ? git(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;
   ensureCommitAvailable({ ...input, commitHash: seed });
   return { seed, mirrorHead };
@@ -322,7 +741,12 @@ function initializeLinkedLayout(input) {
   const seeds = /* @__PURE__ */ new Map();
   const mirrorHeads = /* @__PURE__ */ new Map();
   for (const branch of input.branches) {
-    const resolved = seedForBranch({ ...input, primaryPath, branch });
+    const resolved = seedForBranch({
+      ...input,
+      primaryPath,
+      branch,
+      requireMirrorHead: input.exactMirrorBranches?.has(branch.branchName)
+    });
     seeds.set(branch.branchName, resolved.seed);
     mirrorHeads.set(branch.branchName, resolved.mirrorHead);
   }
@@ -346,24 +770,37 @@ function reconcileLinkedLayout(input) {
   tryGit(primaryPath, ["worktree", "prune"]);
   fetchProjectHeads({ ...input, primaryPath });
   const mirrorHeads = /* @__PURE__ */ new Map();
+  const mutatedBranches = /* @__PURE__ */ new Set();
   for (const branch of input.branches) {
     const checkoutPath = branchPath(input.projectRoot, branch.branchName);
-    const resolved = seedForBranch({ ...input, primaryPath, branch });
+    const resolved = seedForBranch({
+      ...input,
+      primaryPath,
+      branch,
+      requireMirrorHead: input.exactMirrorBranches?.has(branch.branchName)
+    });
     mirrorHeads.set(branch.branchName, resolved.mirrorHead);
     if (branch.branchName === input.primaryBranchName || commonGitDirectory(checkoutPath) === commonGitDirectory(primaryPath)) {
+      const currentHead = git(checkoutPath, ["rev-parse", "HEAD"], `resolve linked worktree head ${branch.branchName}`);
+      if (currentHead === resolved.seed) continue;
+      input.beforeDestructiveMutation();
+      mutatedBranches.add(branch.branchName);
       preserveHead(checkoutPath);
       git(checkoutPath, ["reset", "--hard", resolved.seed], `anchor linked worktree ${branch.branchName}`);
       continue;
     }
+    input.beforeDestructiveMutation();
+    mutatedBranches.add(branch.branchName);
     import_node_fs.default.rmSync(checkoutPath, { recursive: true, force: true });
     git(primaryPath, ["branch", "-f", branch.branchName, resolved.seed], `anchor project branch ${branch.branchName}`);
     import_node_fs.default.mkdirSync(import_node_path.default.dirname(checkoutPath), { recursive: true });
     git(primaryPath, ["worktree", "add", "--force", checkoutPath, branch.branchName], `create linked worktree ${branch.branchName}`);
   }
-  return mirrorHeads;
+  return { mirrorHeads, mutatedBranches };
 }
-function aheadBehind(checkoutPath, branchName) {
-  const originRef = `refs/remotes/origin/${branchName}`;
+function aheadBehind(checkoutPath, branchName, primaryBranchName, defaultBranch) {
+  const originBranchName = projectOriginBranchName({ branchName, primaryBranchName, defaultBranch });
+  const originRef = `refs/remotes/origin/${originBranchName}`;
   if (!tryGit(checkoutPath, ["show-ref", "--verify", "--quiet", originRef])) return { ahead: null, behind: null };
   const output = git(checkoutPath, ["rev-list", "--left-right", "--count", `${originRef}...HEAD`], "measure project origin divergence");
   const [behind, ahead] = output.split(/\s+/).map(Number);
@@ -371,11 +808,18 @@ function aheadBehind(checkoutPath, branchName) {
 }
 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 snapshot = snapshotBranchTrees(projectRoot, input.branches);
+  const snapshotStorageRoot = import_node_path.default.resolve(input.snapshotRoot ?? import_node_os.default.tmpdir());
+  assertNoOutstandingSnapshotForProject(snapshotStorageRoot, projectRoot);
+  let snapshot;
+  const ensureSnapshot = () => {
+    snapshot ??= snapshotBranchTrees(projectRoot, input.branches, snapshotStorageRoot);
+    return snapshot;
+  };
   try {
     import_node_fs.default.mkdirSync(projectRoot, { recursive: true });
     const linked = hasCompatibleLinkedProjectWorktreeLayout({
@@ -383,9 +827,27 @@ function ensureProjectWorktrees(input) {
       primaryBranchName: input.primaryBranchName,
       branches: input.branches
     });
-    const mirrorHeads = linked ? reconcileLinkedLayout({ ...input, projectRoot }) : initializeLinkedLayout({ ...input, projectRoot });
+    let mirrorHeads;
+    let mutatedBranches;
+    if (linked) {
+      ({ mirrorHeads, mutatedBranches } = reconcileLinkedLayout({
+        ...input,
+        projectRoot,
+        defaultBranch,
+        beforeDestructiveMutation: ensureSnapshot
+      }));
+    } else {
+      ensureSnapshot();
+      mirrorHeads = 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");
+    }
     for (const branch of input.branches) {
-      const snapshotPath = snapshot.paths.get(branch.branchName);
+      if (!mutatedBranches.has(branch.branchName)) continue;
+      const snapshotPath = preparedSnapshot?.paths.get(branch.branchName);
       if (!snapshotPath) continue;
       (0, import_working_tree_mirror.mirrorWorkingTree)({
         sourceRoot: snapshotPath,
@@ -394,9 +856,9 @@ function ensureProjectWorktrees(input) {
         deletionMode: "git"
       });
     }
-    return input.branches.map((branch) => {
+    const states = input.branches.map((branch) => {
       const checkoutPath = branchPath(projectRoot, branch.branchName);
-      const divergence = aheadBehind(checkoutPath, branch.branchName);
+      const divergence = aheadBehind(checkoutPath, branch.branchName, input.primaryBranchName, defaultBranch);
       return {
         branchName: branch.branchName,
         branchPath: checkoutPath,
@@ -405,8 +867,19 @@ function ensureProjectWorktrees(input) {
         ...divergence
       };
     }).sort((left, right) => left.branchName.localeCompare(right.branchName));
-  } finally {
-    import_node_fs.default.rmSync(snapshot.root, { recursive: true, force: true });
+    if (snapshot) persistReconciledProjectAndConsumeSnapshot(snapshot);
+    return states;
+  } catch (error) {
+    if (!snapshot) throw error;
+    try {
+      rollbackProjectWorktreeSnapshot(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;
   }
 }
 function projectWorktreeOperationInProgress(checkoutPath) {
@@ -424,6 +897,8 @@ function createLinkedProjectBranch(input) {
   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`);
@@ -439,25 +914,84 @@ function createLinkedProjectBranch(input) {
   });
   if (overlappingWorktree) throw new Error(`Project branch folder overlaps linked worktree ${overlappingWorktree}`);
   const sourceHead = git(sourcePath, ["rev-parse", "HEAD"], "resolve source branch head");
-  const snapshotRoot = createProjectWorktreeSnapshotRoot();
+  let branchCreated = false;
   try {
-    (0, import_working_tree_mirror.mirrorWorkingTree)({ sourceRoot: sourcePath, targetRoot: snapshotRoot, sourceMode: "git", deletionMode: "all" });
     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 });
-    try {
-      git(sourcePath, ["worktree", "add", "--force", targetPath, input.branchName], `create linked worktree ${input.branchName}`);
-      (0, import_working_tree_mirror.mirrorWorkingTree)({ sourceRoot: snapshotRoot, targetRoot: targetPath, sourceMode: "all", deletionMode: "git" });
-    } catch (error) {
-      import_node_fs.default.rmSync(targetPath, { recursive: true, force: true });
-      tryGit(sourcePath, ["worktree", "prune"]);
-      tryGit(sourcePath, ["branch", "-D", input.branchName]);
-      throw error;
-    }
+    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);
+    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" });
     return { branchPath: targetPath, baseCommitHash: sourceHead };
-  } finally {
-    import_node_fs.default.rmSync(snapshotRoot, { recursive: true, force: true });
+  } 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;
   }
 }
+function createOrRetryLinkedProjectBranch(input) {
+  if (input.pendingRetry) {
+    deleteLinkedProjectBranch({
+      projectRoot: input.projectRoot,
+      primaryBranchName: input.primaryBranchName,
+      branchName: input.branchName
+    });
+  }
+  return createLinkedProjectBranch(input);
+}
 function deleteLinkedProjectBranch(input) {
   (0, import_managed_paths.validateManagedBranchName)(input.primaryBranchName);
   (0, import_managed_paths.validateManagedBranchName)(input.branchName);
@@ -517,7 +1051,13 @@ function pushProjectMirrorHeads(input) {
   for (const branchName of [...input.branchNames].sort()) {
     if (input.onlyBranches && !input.onlyBranches.has(branchName)) continue;
     const checkoutPath = branchPath(input.projectRoot, branchName);
-    const head = git(checkoutPath, ["rev-parse", "HEAD"], `resolve mirror head for ${branchName}`);
+    const head = input.publicationHeads ? input.publicationHeads.get(branchName) : git(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 (!tryGit(checkoutPath, ["cat-file", "-e", `${head}^{commit}`])) {
+      throw new Error(`Exact publication head ${head} is unavailable for project branch ${branchName}`);
+    }
     if (projectWorktreeOperationInProgress(checkoutPath)) {
       results.push({ branchName, head, pushed: false, reason: "git_operation_in_progress" });
       continue;
@@ -529,7 +1069,7 @@ function pushProjectMirrorHeads(input) {
         "push",
         "--no-recurse-submodules",
         input.mirrorUrl,
-        `+HEAD:refs/heads/${branchName}`
+        `+${head}:refs/heads/${branchName}`
       ],
       `push hidden project mirror for ${branchName}`
     );
@@ -537,7 +1077,13 @@ function pushProjectMirrorHeads(input) {
   }
   return results;
 }
-function fastForwardProjectHeadsFromMirror(input) {
+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})` : ""}`);
+  }
+}
+function observeProjectMirrorHeads(input) {
   const primaryPath = branchPath(input.projectRoot, input.primaryBranchName);
   const fetch = gitResult(primaryPath, [
     ...(0, import_git_process_environment.gitTransportSecurityArgs)(input.mirrorUrl, input.credentialHelper, input.credentialUsername),
@@ -554,31 +1100,103 @@ function fastForwardProjectHeadsFromMirror(input) {
     const previousHead = git(checkoutPath, ["rev-parse", "HEAD"], `resolve local project head ${branchName}`);
     const mirrorRef = `refs/r5d/mirror/${branchName}`;
     const mirrorHead = tryGit(primaryPath, ["show-ref", "--verify", "--quiet", mirrorRef]) ? git(primaryPath, ["rev-parse", mirrorRef], `resolve refreshed mirror head ${branchName}`) : null;
-    if (!mirrorHead || mirrorHead === previousHead || projectWorktreeOperationInProgress(checkoutPath) || !tryGit(checkoutPath, ["merge-base", "--is-ancestor", previousHead, mirrorHead])) {
-      return { branchName, previousHead, mirrorHead, fastForwarded: false };
+    const shouldMove = Boolean(
+      mirrorHead && mirrorHead !== previousHead && (input.allowNonFastForward || tryGit(checkoutPath, ["merge-base", "--is-ancestor", previousHead, mirrorHead]))
+    );
+    return {
+      branchName,
+      previousHead,
+      mirrorHead,
+      mode: input.allowNonFastForward ? "reseed" : "fast_forward",
+      shouldMove
+    };
+  });
+}
+function applyObservedProjectMirrorHeads(input) {
+  return [...input.observations].sort((left, right) => left.branchName.localeCompare(right.branchName)).map((observation) => {
+    const { branchName, mirrorHead } = observation;
+    const checkoutPath = branchPath(input.projectRoot, branchName);
+    const currentHead = git(checkoutPath, ["rev-parse", "HEAD"], `resolve local project head ${branchName}`);
+    if (!observation.shouldMove || !mirrorHead || currentHead === mirrorHead || currentHead !== observation.previousHead) {
+      return { branchName, previousHead: currentHead, mirrorHead, moved: false };
+    }
+    if (!tryGit(checkoutPath, ["cat-file", "-e", `${mirrorHead}^{commit}`])) {
+      throw new Error(`Observed hidden mirror head is no longer available for ${branchName}: ${mirrorHead}`);
     }
-    git(checkoutPath, ["update-ref", `refs/heads/${branchName}`, mirrorHead, previousHead], `fast-forward project branch ${branchName}`);
-    git(checkoutPath, ["reset", "--mixed", mirrorHead], `refresh project index ${branchName}`);
-    return { branchName, previousHead, mirrorHead, fastForwarded: true };
+    const mutationAllowed = () => !projectWorktreeOperationInProgress(checkoutPath) && input.branchMutationAllowed?.(branchName, checkoutPath) !== false;
+    if (!mutationAllowed()) {
+      return { branchName, previousHead: currentHead, mirrorHead, moved: false };
+    }
+    if (observation.mode === "reseed") {
+      preserveHead(checkoutPath);
+      if (!mutationAllowed()) return { branchName, previousHead: currentHead, mirrorHead, moved: false };
+    }
+    const action = observation.mode === "reseed" ? "reseed" : "fast-forward";
+    git(checkoutPath, ["read-tree", "--reset", mirrorHead], `${action} project index ${branchName}`);
+    git(checkoutPath, ["update-ref", `refs/heads/${branchName}`, mirrorHead, currentHead], `${action} project branch ${branchName}`);
+    return { branchName, previousHead: currentHead, mirrorHead, moved: true };
+  });
+}
+function updateProjectHeadsFromMirror(input) {
+  const observations = observeProjectMirrorHeads(input);
+  return applyObservedProjectMirrorHeads({
+    projectRoot: input.projectRoot,
+    primaryBranchName: input.primaryBranchName,
+    observations,
+    branchMutationAllowed: input.branchMutationAllowed
   });
 }
+function fastForwardProjectHeadsFromMirror(input) {
+  return updateProjectHeadsFromMirror({ ...input, allowNonFastForward: false }).map(({ moved, ...state }) => ({
+    ...state,
+    fastForwarded: moved
+  }));
+}
+function reseedProjectHeadsFromMirror(input) {
+  return updateProjectHeadsFromMirror({ ...input, allowNonFastForward: true }).map(({ moved, ...state }) => ({
+    ...state,
+    reseeded: moved
+  }));
+}
 const projectWorktreesTestHarness = {
   commandArgs: gitCommandArgs,
-  configureRepository
+  configureRepository,
+  createPreparedSnapshot(input) {
+    return { root: snapshotBranchTrees(input.projectRoot, input.branches, input.temporaryRoot).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_WORKTREE_SNAPSHOT_PREFIX,
-  cleanupStaleProjectWorktreeSnapshots,
+  ProjectBranchCreationRollbackIncompleteError,
+  applyObservedProjectMirrorHeads,
+  assertProjectMirrorHeadsPushed,
   createLinkedProjectBranch,
+  createOrRetryLinkedProjectBranch,
   deleteLinkedProjectBranch,
   deleteProjectMirrorBranch,
   ensureProjectWorktrees,
   fastForwardProjectHeadsFromMirror,
   hasLinkedProjectWorktreeLayout,
+  observeProjectMirrorHeads,
+  projectBranchMayExistAfterCreateFailure,
+  projectOriginBranchName,
   projectWorktreeConfigurationFingerprint,
   projectWorktreeOperationInProgress,
   projectWorktreesTestHarness,
   pushProjectMirrorHeads,
-  removeProjectWorktrees
+  recoverStaleProjectWorktreeSnapshots,
+  removeProjectWorktrees,
+  reseedProjectHeadsFromMirror
 });