@ricsam/r5d-worker 0.0.81 → 0.0.83

package/dist/cjs/workspace-git-sync.cjs

@@ -34,6 +34,8 @@ __export(workspace_git_sync_exports, {
   WORKSPACE_GIT_CONFIRMED_LARGE_DIFF_PUSH_OPTION: () => WORKSPACE_GIT_CONFIRMED_LARGE_DIFF_PUSH_OPTION,
   WORKSPACE_GIT_HYDRATED_RECEIPT: () => WORKSPACE_GIT_HYDRATED_RECEIPT,
   WORKSPACE_GIT_HYDRATION_TRANSACTION: () => WORKSPACE_GIT_HYDRATION_TRANSACTION,
+  WorkspaceRemediationAncestryError: () => WorkspaceRemediationAncestryError,
+  configureExistingWorkspaceGitForRemediation: () => configureExistingWorkspaceGitForRemediation,
   ensureWorkspaceGitClone: () => ensureWorkspaceGitClone,
   hydrateWorkspaceGitMounts: () => hydrateWorkspaceGitMounts,
   recoverWorkspaceGitHydration: () => recoverWorkspaceGitHydration,
@@ -46,6 +48,7 @@ module.exports = __toCommonJS(workspace_git_sync_exports);
 var import_node_fs = __toESM(require("node:fs"), 1);
 var import_node_path = __toESM(require("node:path"), 1);
 var import_git_process_environment = require("./git-process-environment.cjs");
+var import_workspace_merge_projection = require("./workspace-merge-projection.cjs");
 var import_working_tree_mirror = require("./working-tree-mirror.cjs");
 var import_workspace_mount_boundary = require("./workspace-mount-boundary.cjs");
 const WORKSPACE_GIT_BRANCH = "main";
@@ -55,6 +58,12 @@ const WORKSPACE_GIT_INTEGRATED_REF = "refs/r5d/workspace-local/integrated";
 const WORKSPACE_GIT_HYDRATED_RECEIPT = "r5d/workspace-hydrated-head";
 const WORKSPACE_GIT_HYDRATION_TRANSACTION = "r5d/workspace-hydration-transaction";
 const WORKSPACE_GIT_CHECKOUT_DURABILITY = "r5d/workspace-checkout-durability";
+class WorkspaceRemediationAncestryError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "WorkspaceRemediationAncestryError";
+  }
+}
 const NON_RECURSIVE_GIT_CONFIG = [
   "-c",
   "submodule.recurse=false",
@@ -94,6 +103,29 @@ function revParse(workspacePath, revision) {
   const result = gitResult(workspacePath, ["rev-parse", "--verify", revision]);
   return result.exitCode === 0 ? result.stdout : null;
 }
+function requiredWorkspaceAncestorHeads(value) {
+  if (value === void 0) return [];
+  if (!Array.isArray(value) || value.length === 0 || value.some((head) => typeof head !== "string" || !/^(?:[0-9a-f]{40}|[0-9a-f]{64})$/.test(head)) || new Set(value).size !== value.length) {
+    throw new WorkspaceRemediationAncestryError("Workspace remediation ancestor requirements are invalid");
+  }
+  return [...value];
+}
+function assertWorkspaceRemediationAncestry(input) {
+  if (input.requiredAncestorHeads.length === 0) return;
+  if (!input.currentHead) throw new WorkspaceRemediationAncestryError("Workspace remediation has no resolved HEAD to verify");
+  for (const requiredHead of input.requiredAncestorHeads) {
+    if (!tryGit(input.workspacePath, ["cat-file", "-e", `${requiredHead}^{commit}`]) || !tryGit(input.workspacePath, ["merge-base", "--is-ancestor", requiredHead, input.currentHead])) {
+      throw new WorkspaceRemediationAncestryError(
+        `Workspace remediation HEAD does not descend from required conflict commit ${requiredHead}`
+      );
+    }
+  }
+  if (!input.remoteHead || !tryGit(input.workspacePath, ["cat-file", "-e", `${input.remoteHead}^{commit}`]) || !tryGit(input.workspacePath, ["merge-base", "--is-ancestor", input.remoteHead, input.currentHead])) {
+    throw new WorkspaceRemediationAncestryError(
+      "Fetched workspace head is not an ancestor of the resolved remediation HEAD; merge it explicitly before synchronizing"
+    );
+  }
+}
 function updateIntegratedWorkspaceHead(workspacePath, head) {
   git(workspacePath, ["update-ref", WORKSPACE_GIT_INTEGRATED_REF, head], "record integrated workspace head");
 }
@@ -140,22 +172,52 @@ function compareWorkspaceHydrationMountBasis(left, right) {
   return left.id.localeCompare(right.id);
 }
 function workspaceHydrationReceipt(head, mounts) {
-  const bases = mounts.map(workspaceHydrationMountBasis).sort(compareWorkspaceHydrationMountBasis);
+  const bases = mounts.map((mount) => ({ ...workspaceHydrationMountBasis(mount), head })).sort(compareWorkspaceHydrationMountBasis);
   const ids = /* @__PURE__ */ new Set();
   for (const basis of bases) {
     if (ids.has(basis.id)) throw new Error(`Workspace hydration receipt mount id must be unique: ${basis.id}`);
     ids.add(basis.id);
   }
-  return { version: 2, head, mounts: bases };
+  return { version: 3, mounts: bases };
+}
+function receiptWithMountsAtHead(previous, head, mounts, allConfiguredMounts) {
+  const advanceIds = new Set(mounts.map(({ id }) => id));
+  const previousById = new Map(previous?.mounts.map((entry) => [entry.id, entry]) ?? []);
+  const entries = allConfiguredMounts.flatMap((mount) => {
+    const basis = workspaceHydrationMountBasis(mount);
+    if (advanceIds.has(mount.id)) return [{ ...basis, head }];
+    const carried = previousById.get(mount.id);
+    if (!carried) return [];
+    return [carried];
+  });
+  entries.sort(compareWorkspaceHydrationMountBasis);
+  const ids = /* @__PURE__ */ new Set();
+  for (const entry of entries) {
+    if (ids.has(entry.id)) throw new Error(`Workspace hydration receipt mount id must be unique: ${entry.id}`);
+    ids.add(entry.id);
+  }
+  return { version: 3, mounts: entries };
 }
 function workspaceHydrationReceiptsEqual(left, right) {
-  return JSON.stringify(left) === JSON.stringify(right);
+  if (JSON.stringify(left) !== JSON.stringify(right)) return false;
+  const effectiveLegacyHead = (receipt) => receipt?.mounts.length === 0 ? receipt.legacyHead ?? null : null;
+  return effectiveLegacyHead(left) === effectiveLegacyHead(right);
 }
 function workspaceHydrationReceiptCoversMount(receipt, head, mount) {
-  if (!receipt || receipt.head !== head) return false;
+  if (!receipt) return false;
+  const expected = workspaceHydrationMountBasis(mount);
+  const actual = receipt.mounts.find(({ id }) => id === expected.id);
+  if (!actual || actual.head !== head) return false;
+  const { head: _head, ...actualBasis } = actual;
+  return JSON.stringify(actualBasis) === JSON.stringify(expected);
+}
+function workspaceHydrationReceiptMountBasisHead(receipt, mount) {
+  if (!receipt) return null;
   const expected = workspaceHydrationMountBasis(mount);
   const actual = receipt.mounts.find(({ id }) => id === expected.id);
-  return Boolean(actual && JSON.stringify(actual) === JSON.stringify(expected));
+  if (!actual) return null;
+  const { head, ...actualBasis } = actual;
+  return JSON.stringify(actualBasis) === JSON.stringify(expected) ? head : null;
 }
 function workspaceHydrationReceiptMatchesMounts(receipt, head, mounts) {
   return workspaceHydrationReceiptsEqual(receipt, workspaceHydrationReceipt(head, mounts));
@@ -176,7 +238,9 @@ function parseWorkspaceHydrationReceiptContent(workspacePath, receiptPath, conte
     if (!tryGit(workspacePath, ["cat-file", "-e", `${legacyHead}^{commit}`])) {
       throw new Error(`Workspace hydration receipt does not resolve to a local commit: ${receiptPath}`);
     }
-    return { version: 2, head: legacyHead, mounts: [] };
+    const receipt2 = { version: 3, mounts: [] };
+    Object.defineProperty(receipt2, "legacyHead", { value: legacyHead, enumerable: false });
+    return receipt2;
   }
   let parsed;
   try {
@@ -188,7 +252,8 @@ function parseWorkspaceHydrationReceiptContent(workspacePath, receiptPath, conte
     throw new Error(`Workspace hydration receipt contains an invalid object id or mount basis: ${receiptPath}`);
   }
   const candidate = parsed;
-  if (candidate.version !== 2 || typeof candidate.head !== "string" || !/^(?:[0-9a-f]{40}|[0-9a-f]{64})$/.test(candidate.head)) {
+  const liftedV2Head = candidate.version === 2 && typeof candidate.head === "string" && /^(?:[0-9a-f]{40}|[0-9a-f]{64})$/.test(candidate.head) ? candidate.head : null;
+  if (candidate.version !== 3 && liftedV2Head === null) {
     throw new Error(`Workspace hydration receipt contains an invalid object id or mount basis: ${receiptPath}`);
   }
   if (!Array.isArray(candidate.mounts)) {
@@ -202,23 +267,51 @@ function parseWorkspaceHydrationReceiptContent(workspacePath, receiptPath, conte
     const mount = rawMount;
     const normalizedRelativePath = typeof mount.workspaceRelativePath === "string" ? normalizedWorkspaceMountPath(mount.workspaceRelativePath) : "";
     const durabilityRelative = typeof mount.sourcePath === "string" && typeof mount.durabilityRootPath === "string" ? import_node_path.default.relative(mount.durabilityRootPath, mount.sourcePath) : "..";
-    if (typeof mount.id !== "string" || !mount.id || seenIds.has(mount.id) || typeof mount.incarnationKey !== "string" || !mount.incarnationKey || mount.incarnationKey.includes("\0") || typeof mount.sourcePath !== "string" || import_node_path.default.resolve(mount.sourcePath) !== mount.sourcePath || typeof mount.durabilityRootPath !== "string" || import_node_path.default.resolve(mount.durabilityRootPath) !== mount.durabilityRootPath || !durabilityRelative || durabilityRelative === ".." || durabilityRelative.startsWith(`..${import_node_path.default.sep}`) || import_node_path.default.isAbsolute(durabilityRelative) || typeof mount.workspaceRelativePath !== "string" || mount.workspaceRelativePath !== normalizedRelativePath || !normalizedRelativePath || normalizedRelativePath === "." || normalizedRelativePath.split("/").some((segment) => segment === ".." || segment === ".git") || mount.sourceMode !== "all" && mount.sourceMode !== "git" || mount.hydrateDeletionMode !== "all" && mount.hydrateDeletionMode !== "git" || typeof mount.preserveLocalOnInitialOuterAbsence !== "boolean" || typeof mount.preserveLocalOnHydrationBasisChange !== "boolean" || typeof mount.deleteWhenSourceMissing !== "boolean") {
+    if (typeof mount.id !== "string" || !mount.id || seenIds.has(mount.id) || typeof mount.incarnationKey !== "string" || !mount.incarnationKey || mount.incarnationKey.includes("\0") || typeof mount.sourcePath !== "string" || import_node_path.default.resolve(mount.sourcePath) !== mount.sourcePath || typeof mount.durabilityRootPath !== "string" || import_node_path.default.resolve(mount.durabilityRootPath) !== mount.durabilityRootPath || !durabilityRelative || durabilityRelative === ".." || durabilityRelative.startsWith(`..${import_node_path.default.sep}`) || import_node_path.default.isAbsolute(durabilityRelative) || typeof mount.workspaceRelativePath !== "string" || mount.workspaceRelativePath !== normalizedRelativePath || !normalizedRelativePath || normalizedRelativePath === "." || normalizedRelativePath.split("/").some((segment) => segment === ".." || segment === ".git") || mount.sourceMode !== "all" && mount.sourceMode !== "git" || mount.hydrateDeletionMode !== "all" && mount.hydrateDeletionMode !== "git" || typeof mount.preserveLocalOnInitialOuterAbsence !== "boolean" || typeof mount.preserveLocalOnHydrationBasisChange !== "boolean" || typeof mount.deleteWhenSourceMissing !== "boolean" || candidate.version === 3 && (typeof mount.head !== "string" || !/^(?:[0-9a-f]{40}|[0-9a-f]{64})$/.test(mount.head))) {
       throw new Error(`Workspace hydration receipt contains an invalid mount basis: ${receiptPath}`);
     }
     seenIds.add(mount.id);
-    return mount;
+    return {
+      id: mount.id,
+      incarnationKey: mount.incarnationKey,
+      sourcePath: mount.sourcePath,
+      durabilityRootPath: mount.durabilityRootPath,
+      workspaceRelativePath: mount.workspaceRelativePath,
+      sourceMode: mount.sourceMode,
+      hydrateDeletionMode: mount.hydrateDeletionMode,
+      preserveLocalOnInitialOuterAbsence: mount.preserveLocalOnInitialOuterAbsence,
+      preserveLocalOnHydrationBasisChange: mount.preserveLocalOnHydrationBasisChange,
+      deleteWhenSourceMissing: mount.deleteWhenSourceMissing,
+      head: candidate.version === 3 ? mount.head : liftedV2Head
+    };
   });
+  const sortedMounts = mounts.sort(compareWorkspaceHydrationMountBasis);
+  if (liftedV2Head) {
+    const legacyReceipt = {
+      version: 2,
+      head: liftedV2Head,
+      mounts: sortedMounts.map(({ head: _head, ...basis }) => basis)
+    };
+    if (content !== `${JSON.stringify(legacyReceipt)}
+`) {
+      throw new Error(`Workspace hydration receipt contains a noncanonical mount basis: ${receiptPath}`);
+    }
+  }
   const receipt = {
-    version: 2,
-    head: candidate.head,
-    mounts: mounts.sort(compareWorkspaceHydrationMountBasis)
+    version: 3,
+    mounts: sortedMounts
   };
-  if (content !== `${JSON.stringify(receipt)}
+  if (liftedV2Head) Object.defineProperty(receipt, "legacyHead", { value: liftedV2Head, enumerable: false });
+  if (candidate.version === 3 && content !== `${JSON.stringify(receipt)}
 `) {
     throw new Error(`Workspace hydration receipt contains a noncanonical mount basis: ${receiptPath}`);
   }
-  if (!tryGit(workspacePath, ["cat-file", "-e", `${receipt.head}^{commit}`])) {
-    throw new Error(`Workspace hydration receipt does not resolve to a local commit: ${receiptPath}`);
+  const receiptHeads = new Set(receipt.mounts.map((mount) => mount.head));
+  if (liftedV2Head) receiptHeads.add(liftedV2Head);
+  for (const head of receiptHeads) {
+    if (!tryGit(workspacePath, ["cat-file", "-e", `${head}^{commit}`])) {
+      throw new Error(`Workspace hydration receipt does not resolve to a local commit: ${receiptPath}`);
+    }
   }
   return receipt;
 }
@@ -232,22 +325,92 @@ function readHydratedWorkspaceReceipt(workspacePath) {
   const content = import_node_fs.default.readFileSync(receiptPath, "utf8");
   return parseWorkspaceHydrationReceiptContent(workspacePath, receiptPath, content);
 }
+function hydratedWorkspaceReceiptFileIsV3(workspacePath) {
+  const receiptPath = hydratedWorkspaceReceiptPath(workspacePath);
+  const status = lstatIfExists(receiptPath);
+  if (!status?.isFile() || status.isSymbolicLink()) return false;
+  try {
+    return JSON.parse(import_node_fs.default.readFileSync(receiptPath, "utf8")).version === 3;
+  } catch {
+    return false;
+  }
+}
 function workspaceGitHydrationIsCurrent(workspacePath, mounts) {
   const resolvedWorkspacePath = import_node_path.default.resolve(workspacePath);
   if (!import_node_fs.default.existsSync(import_node_path.default.join(resolvedWorkspacePath, ".git"))) return true;
   if (mounts) validateMounts(resolvedWorkspacePath, mounts);
   const head = revParse(resolvedWorkspacePath, "HEAD");
   if (!workspaceCheckoutDurabilityIsCurrent(resolvedWorkspacePath)) return false;
-  if (head === null) return true;
   const receipt = readHydratedWorkspaceReceipt(resolvedWorkspacePath);
-  return mounts ? workspaceHydrationReceiptMatchesMounts(receipt, head, configuredWorkspaceHydrationBasisMounts(resolvedWorkspacePath, mounts)) : receipt?.head === head;
+  if (!workspaceBasisRefsAreCurrent(resolvedWorkspacePath, receipt ?? { version: 3, mounts: [] })) return false;
+  if (head === null) return true;
+  if (!receipt) return false;
+  return mounts ? configuredWorkspaceHydrationBasisMounts(resolvedWorkspacePath, mounts).every(
+    (mount) => workspaceHydrationReceiptCoversMount(receipt, head, mount) || Boolean(mount.busy?.() && workspaceHydrationReceiptMountBasisHead(receipt, mount))
+  ) : Boolean(receipt && receipt.mounts.every((mount) => mount.head === head));
+}
+const WORKSPACE_GIT_BASIS_REF_PREFIX = "refs/r5d/workspace-basis/";
+const WORKSPACE_GIT_BASIS_STAGING_REF_PREFIX = "refs/r5d/workspace-basis-staging/";
+function workspaceBasisRefName(mountId) {
+  const sanitized = Buffer.from(mountId, "utf8").toString("base64url");
+  if (!sanitized) throw new Error(`Cannot derive a workspace basis ref for mount id: ${mountId}`);
+  return `${WORKSPACE_GIT_BASIS_REF_PREFIX}${sanitized}`;
+}
+function listWorkspaceRefs(workspacePath, prefix) {
+  return git(workspacePath, ["for-each-ref", "--format=%(refname)", prefix], `list ${prefix} refs`).split("\n").filter(Boolean).sort();
+}
+function desiredWorkspaceBasisRefs(receipt) {
+  const desired = /* @__PURE__ */ new Map();
+  for (const mount of receipt.mounts) {
+    const ref = workspaceBasisRefName(mount.id);
+    if (desired.has(ref)) throw new Error(`Workspace hydration mount ids collide at basis ref ${ref}`);
+    desired.set(ref, mount.head);
+  }
+  return desired;
+}
+function workspaceBasisRefsMatch(workspacePath, receipt) {
+  const desired = desiredWorkspaceBasisRefs(receipt);
+  const actualRefs = listWorkspaceRefs(workspacePath, WORKSPACE_GIT_BASIS_REF_PREFIX);
+  if (actualRefs.length !== desired.size) return false;
+  return actualRefs.every((ref) => desired.get(ref) === revParse(workspacePath, ref));
+}
+function workspaceBasisRefsAreCurrent(workspacePath, receipt) {
+  return workspaceBasisRefsMatch(workspacePath, receipt) && listWorkspaceRefs(workspacePath, WORKSPACE_GIT_BASIS_STAGING_REF_PREFIX).length === 0;
+}
+function repairWorkspaceBasisRefs(workspacePath, receipt) {
+  const effectiveReceipt = receipt ?? { version: 3, mounts: [] };
+  if (!workspaceBasisRefsAreCurrent(workspacePath, effectiveReceipt)) updateWorkspaceBasisRefs(workspacePath, effectiveReceipt);
+}
+function updateWorkspaceBasisRefs(workspacePath, receipt) {
+  const desired = desiredWorkspaceBasisRefs(receipt);
+  const transaction = ["start"];
+  for (const [ref, head] of [...desired].sort(([left], [right]) => left.localeCompare(right))) transaction.push(`update ${ref} ${head}`);
+  for (const ref of listWorkspaceRefs(workspacePath, WORKSPACE_GIT_BASIS_REF_PREFIX)) {
+    if (!desired.has(ref)) transaction.push(`delete ${ref}`);
+  }
+  transaction.push("prepare", "commit", "");
+  const updated = Bun.spawnSync(gitCommandArgs(["update-ref", "--stdin"]), {
+    cwd: workspacePath,
+    stdin: Buffer.from(transaction.join("\n")),
+    stdout: "pipe",
+    stderr: "pipe",
+    env: (0, import_git_process_environment.workerGitProcessEnvironment)()
+  });
+  if (updated.exitCode !== 0) {
+    throw new Error(`Synchronize workspace hydration basis refs: ${updated.stderr.toString().trim() || `git exited ${updated.exitCode}`}`);
+  }
+  for (const ref of listWorkspaceRefs(workspacePath, WORKSPACE_GIT_BASIS_STAGING_REF_PREFIX)) {
+    git(workspacePath, ["update-ref", "-d", ref], "remove staged workspace hydration basis ref");
+  }
 }
 function updateHydratedWorkspaceReceipt(workspacePath, receipt) {
-  if (!/^(?:[0-9a-f]{40}|[0-9a-f]{64})$/.test(receipt.head)) {
-    throw new Error(`Cannot record invalid fully hydrated workspace object id: ${receipt.head}`);
-  }
-  if (!tryGit(workspacePath, ["cat-file", "-e", `${receipt.head}^{commit}`])) {
-    throw new Error(`Cannot record workspace hydration receipt for a missing commit: ${receipt.head}`);
+  for (const mount of receipt.mounts) {
+    if (!/^(?:[0-9a-f]{40}|[0-9a-f]{64})$/.test(mount.head)) {
+      throw new Error(`Cannot record invalid workspace hydration object id: ${mount.head}`);
+    }
+    if (!tryGit(workspacePath, ["cat-file", "-e", `${mount.head}^{commit}`])) {
+      throw new Error(`Cannot record workspace hydration receipt for a missing commit: ${mount.head}`);
+    }
   }
   readHydratedWorkspaceReceipt(workspacePath);
   const gitDirectory = import_node_path.default.join(workspacePath, ".git");
@@ -267,6 +430,12 @@ function updateHydratedWorkspaceReceipt(workspacePath, receipt) {
     throw new Error(`Workspace hydration receipt directory is not a regular directory: ${receiptDirectory}`);
   }
   const temporaryPath = import_node_path.default.join(receiptDirectory, `.workspace-hydrated-head.${process.pid}.${crypto.randomUUID()}.tmp`);
+  const stagingPrefix = `${WORKSPACE_GIT_BASIS_STAGING_REF_PREFIX}${crypto.randomUUID()}/`;
+  desiredWorkspaceBasisRefs(receipt);
+  for (const mount of receipt.mounts) {
+    const stagedRef = `${stagingPrefix}${workspaceBasisRefName(mount.id).slice(WORKSPACE_GIT_BASIS_REF_PREFIX.length)}`;
+    git(workspacePath, ["update-ref", stagedRef, mount.head], "stage workspace hydration basis ref");
+  }
   let descriptor;
   try {
     descriptor = import_node_fs.default.openSync(temporaryPath, import_node_fs.default.constants.O_WRONLY | import_node_fs.default.constants.O_CREAT | import_node_fs.default.constants.O_EXCL, 384);
@@ -277,6 +446,7 @@ function updateHydratedWorkspaceReceipt(workspacePath, receipt) {
     descriptor = void 0;
     import_node_fs.default.renameSync(temporaryPath, receiptPath);
     fsyncDirectory(receiptDirectory);
+    updateWorkspaceBasisRefs(workspacePath, receipt);
   } catch (error) {
     if (descriptor !== void 0) import_node_fs.default.closeSync(descriptor);
     import_node_fs.default.rmSync(temporaryPath, { force: true });
@@ -404,6 +574,16 @@ function workspaceRebaseInProgress(workspacePath) {
   const gitDirectory = import_node_path.default.join(workspacePath, ".git");
   return import_node_fs.default.existsSync(import_node_path.default.join(gitDirectory, "rebase-merge")) || import_node_fs.default.existsSync(import_node_path.default.join(gitDirectory, "rebase-apply"));
 }
+function workspaceResolutionInProgress(workspacePath) {
+  return workspaceRebaseInProgress(workspacePath) || import_node_fs.default.existsSync(import_node_path.default.join(workspacePath, ".git", "MERGE_HEAD"));
+}
+function workspaceHasUnmergedEntries(workspacePath) {
+  const result = gitResult(workspacePath, ["ls-files", "-u", "-z"]);
+  if (result.exitCode !== 0) {
+    throw new Error(`Inspect unfinished workspace merge: ${result.stderr || result.stdout || `git exited ${result.exitCode}`}`);
+  }
+  return result.stdout.length > 0;
+}
 function clearWorkspaceCheckoutTree(workspacePath) {
   for (const name of import_node_fs.default.readdirSync(workspacePath)) {
     if (name === ".git") continue;
@@ -411,15 +591,18 @@ function clearWorkspaceCheckoutTree(workspacePath) {
   }
   fsyncDirectory(workspacePath);
 }
-function recoverWorkspaceCheckoutDurability(workspacePath) {
+function recoverWorkspaceCheckoutDurability(workspacePath, preserveResolutionInProgress = false) {
   workspacePath = import_node_path.default.resolve(workspacePath);
   const record = readWorkspaceCheckoutDurabilityRecord(workspacePath);
   const observedHead = revParse(workspacePath, "HEAD");
   if (record?.state === "durable" && record.head === observedHead) return;
+  if (preserveResolutionInProgress && workspaceResolutionInProgress(workspacePath)) {
+    throw new Error("Workspace resolution is in progress; finish or abort it before synchronizing");
+  }
   let targetHead = record?.state === "transition" ? record.head : observedHead;
   if (record?.state === "transition" && observedHead && observedHead !== record.head) {
     const hydrationReceipt = readHydratedWorkspaceReceipt(workspacePath);
-    if (hydrationReceipt?.head === observedHead) {
+    if (hydrationReceipt?.legacyHead === observedHead || hydrationReceipt?.mounts.some((mount) => mount.head === observedHead)) {
       targetHead = observedHead;
     }
   }
@@ -501,7 +684,7 @@ function parseHydrationTransactionManifest(transactionPath) {
     throw new Error(`Workspace hydration transaction manifest is invalid: ${manifestPath}`);
   }
   const candidate = parsed;
-  if (candidate.version !== 2 || !Array.isArray(candidate.mounts)) {
+  if (candidate.version !== 2 && candidate.version !== 3 || !Array.isArray(candidate.mounts)) {
     throw new Error(`Workspace hydration transaction manifest is invalid: ${manifestPath}`);
   }
   const parseReceipt = (rawReceipt) => {
@@ -533,7 +716,7 @@ function parseHydrationTransactionManifest(transactionPath) {
     return mount;
   });
   return {
-    version: 2,
+    version: 3,
     targetReceipt,
     receiptBefore,
     mounts
@@ -626,7 +809,7 @@ function beginHydrationTransaction(workspacePath, mounts, targetReceipt) {
     const snapshotRoot = import_node_path.default.join(stagingPath, "mounts");
     import_node_fs.default.mkdirSync(snapshotRoot, { mode: 448 });
     const manifest = {
-      version: 2,
+      version: 3,
       targetReceipt,
       receiptBefore: readHydratedWorkspaceReceipt(workspacePath),
       mounts: mounts.map((mount, index) => {
@@ -805,9 +988,22 @@ function configureWorkspaceRepository(input) {
   if (!name || !email) throw new Error("Workspace Git identity must include name and email");
   git(input.workspacePath, ["config", "--local", "user.name", name], "configure workspace Git user name");
   git(input.workspacePath, ["config", "--local", "user.email", email], "configure workspace Git user email");
-  git(input.workspacePath, ["config", "--local", "core.fsync", "committed"], "configure durable workspace commits");
+  git(
+    input.workspacePath,
+    ["config", "--local", "core.fsync", "committed,reference"],
+    "configure durable workspace commits and references"
+  );
   git(input.workspacePath, ["config", "--local", "core.fsyncMethod", "fsync"], "configure workspace fsync method");
 }
+function configureExistingWorkspaceGitForRemediation(input) {
+  const workspacePath = import_node_path.default.resolve(input.workspacePath);
+  const workspaceStatus = lstatIfExists(workspacePath);
+  const gitStatus = lstatIfExists(import_node_path.default.join(workspacePath, ".git"));
+  if (!workspaceStatus?.isDirectory() || workspaceStatus.isSymbolicLink() || !gitStatus?.isDirectory() || gitStatus.isSymbolicLink()) {
+    throw new Error("Active workspace remediation requires a regular existing canonical synchronization checkout");
+  }
+  configureWorkspaceRepository({ ...input, workspacePath });
+}
 function fetchWorkspaceHead(workspacePath, remoteUrl, credentialHelper, credentialUsername) {
   const result = gitResult(workspacePath, [
     ...(0, import_git_process_environment.gitTransportSecurityArgs)(remoteUrl, credentialHelper, credentialUsername),
@@ -869,7 +1065,7 @@ function ensureWorkspaceGitClone(input) {
     }
   }
   configureWorkspaceRepository({ ...input, workspacePath });
-  recoverWorkspaceCheckoutDurability(workspacePath);
+  recoverWorkspaceCheckoutDurability(workspacePath, input.preserveResolutionInProgress);
   const previousRemoteHead = revParse(workspacePath, `refs/remotes/origin/${WORKSPACE_GIT_BRANCH}`);
   const localHeadBeforeFetch = revParse(workspacePath, "HEAD");
   if (!revParse(workspacePath, WORKSPACE_GIT_INTEGRATED_REF) && previousRemoteHead && localHeadBeforeFetch && tryGit(workspacePath, ["merge-base", "--is-ancestor", previousRemoteHead, localHeadBeforeFetch])) {
@@ -1019,31 +1215,40 @@ function hydrateWorkspaceGitMountsRaw(workspacePath, mounts, options = {}) {
 }
 function hydrateWorkspaceGitMountsTransactionally(input) {
   const workspacePath = import_node_path.default.resolve(input.workspacePath);
-  const mountIds = input.mounts.map(({ id }) => id).sort();
-  const requiredIds = (input.requiredMounts ?? input.mounts).map(({ id }) => id).sort();
-  if (mountIds.length !== requiredIds.length || mountIds.some((id, index) => id !== requiredIds[index])) {
-    return { hydratedMountIds: [], skippedMountIds: requiredIds };
-  }
-  const busyMountIds = input.ignoreBusy ? [] : (input.durabilityMounts ?? input.mounts).filter((mount) => mount.busy?.()).map(({ id }) => id).sort();
-  if (busyMountIds.length > 0) {
-    return { hydratedMountIds: [], skippedMountIds: busyMountIds };
-  }
+  const durabilityMounts = input.durabilityMounts ?? input.mounts;
+  const receiptMounts = input.receiptMounts ?? durabilityMounts;
+  const requiredMounts = input.requiredMounts ?? input.mounts;
+  const candidateMounts = [
+    ...new Map([...input.mounts, ...durabilityMounts, ...requiredMounts].map((mount) => [mount.id, mount])).values()
+  ];
+  const busyMountIds = new Set(input.ignoreBusy ? [] : candidateMounts.filter((mount) => mount.busy?.()).map(({ id }) => id));
+  const requestedIds = new Set(input.mounts.map(({ id }) => id));
+  const requiredIds = new Set(requiredMounts.map(({ id }) => id));
+  const hydrationMounts = input.mounts.filter(({ id }) => !busyMountIds.has(id));
+  const advancedDurabilityMounts = durabilityMounts.filter(
+    ({ id }) => !busyMountIds.has(id) && (requestedIds.has(id) || !requiredIds.has(id))
+  );
+  const unavailableRequiredIds = requiredMounts.filter(({ id }) => busyMountIds.has(id) || !requestedIds.has(id)).map(({ id }) => id);
   if (input.recordCurrentHead && !workspaceCheckoutDurabilityIsCurrent(workspacePath)) {
     throw new Error("Workspace checkout is not durably materialized at its current HEAD");
   }
   const targetHead = input.recordCurrentHead ? revParse(workspacePath, "HEAD") : null;
-  const targetReceipt = targetHead ? workspaceHydrationReceipt(targetHead, input.receiptMounts ?? input.durabilityMounts ?? input.mounts) : null;
-  const manifest = beginHydrationTransaction(workspacePath, input.mounts, targetReceipt);
+  const targetReceipt = targetHead ? receiptWithMountsAtHead(readHydratedWorkspaceReceipt(workspacePath), targetHead, advancedDurabilityMounts, receiptMounts) : null;
+  const manifest = beginHydrationTransaction(workspacePath, hydrationMounts, targetReceipt);
   try {
-    const hydration = hydrateWorkspaceGitMountsRaw(workspacePath, input.mounts, { ignoreBusy: true });
-    if (hydration.skippedMountIds.length > 0 || hydration.hydratedMountIds.length !== requiredIds.length || hydration.hydratedMountIds.some((id, index) => id !== requiredIds[index])) {
+    const hydration = hydrateWorkspaceGitMountsRaw(workspacePath, hydrationMounts, { ignoreBusy: true });
+    const expectedHydratedIds = hydrationMounts.map(({ id }) => id).sort();
+    if (hydration.skippedMountIds.length > 0 || hydration.hydratedMountIds.length !== expectedHydratedIds.length || hydration.hydratedMountIds.some((id, index) => id !== expectedHydratedIds[index])) {
       throw new Error("Workspace hydration did not include every required mount");
     }
-    fsyncHydratedWorkspaceMounts(input.durabilityMounts ?? input.mounts);
+    fsyncHydratedWorkspaceMounts(advancedDurabilityMounts);
     markHydrationTransactionDurable(workspacePath);
     if (targetReceipt) updateHydratedWorkspaceReceipt(workspacePath, targetReceipt);
     removeHydrationTransaction(workspacePath);
-    return hydration;
+    return {
+      hydratedMountIds: hydration.hydratedMountIds,
+      skippedMountIds: [.../* @__PURE__ */ new Set([...busyMountIds, ...unavailableRequiredIds])].sort()
+    };
   } catch (error) {
     const transactionPath = hydrationTransactionPath(workspacePath);
     if (lstatIfExists(transactionPath) && hydrationTransactionCommitted(transactionPath)) {
@@ -1076,44 +1281,44 @@ function hydrateWorkspaceGitMounts(workspacePath, mounts, options = {}) {
 function recoverWorkspaceGitHydration(workspacePath, mounts, options = {}) {
   workspacePath = import_node_path.default.resolve(workspacePath);
   validateMounts(workspacePath, mounts);
-  recoverWorkspaceCheckoutDurability(workspacePath);
+  recoverWorkspaceCheckoutDurability(workspacePath, options.preserveResolutionInProgress);
   recoverPendingHydrationTransaction(workspacePath);
   const currentHead = revParse(workspacePath, "HEAD");
-  if (!currentHead) return;
   const currentReceipt = readHydratedWorkspaceReceipt(workspacePath);
+  repairWorkspaceBasisRefs(workspacePath, currentReceipt);
+  if (!currentHead) return;
   const outerHeadContainsMount = (mount) => tryGit(workspacePath, ["cat-file", "-e", `HEAD:${normalizedWorkspaceMountPath(mount.workspaceRelativePath)}`]);
   const configuredBasisMounts = configuredWorkspaceHydrationBasisMounts(workspacePath, mounts, options.deferMountIds);
   const uncoveredBasisMounts = configuredBasisMounts.filter(
     (mount) => !workspaceHydrationReceiptCoversMount(currentReceipt, currentHead, mount)
   );
   if (workspaceHydrationReceiptMatchesMounts(currentReceipt, currentHead, configuredBasisMounts)) return;
-  const busyMountIds = options.ignoreBusy ? [] : uncoveredBasisMounts.filter((mount) => mount.busy?.()).map(({ id }) => id);
-  if (busyMountIds.length > 0) {
-    throw new Error(
-      `Workspace HEAD ${currentHead} has not been fully hydrated; busy mounts must finish before projection: ${busyMountIds.join(", ")}`
-    );
-  }
-  const hydrationTargets = uncoveredBasisMounts.filter(
-    (mount) => !mount.deleteWhenSourceMissing && !(mount.preserveLocalOnHydrationBasisChange === true && currentReceipt?.head === currentHead) && (outerHeadContainsMount(mount) || mount.preserveLocalOnInitialOuterAbsence !== true)
+  const busyMountIds = new Set(options.ignoreBusy ? [] : uncoveredBasisMounts.filter((mount) => mount.busy?.()).map(({ id }) => id));
+  const recoveryMounts = uncoveredBasisMounts.filter(
+    (mount) => workspaceHydrationReceiptMountBasisHead(currentReceipt, mount) === null || !options.preserveStaleBases && !busyMountIds.has(mount.id)
+  );
+  const idleBasislessMounts = recoveryMounts.filter((mount) => !busyMountIds.has(mount.id));
+  const hydrationTargets = idleBasislessMounts.filter(
+    (mount) => !mount.deleteWhenSourceMissing && !(mount.preserveLocalOnHydrationBasisChange === true && currentReceipt?.mounts.find(({ id }) => id === mount.id)?.head === currentHead) && (outerHeadContainsMount(mount) || mount.preserveLocalOnInitialOuterAbsence !== true)
   );
   const hydration = hydrateWorkspaceGitMountsTransactionally({
     workspacePath,
     mounts: hydrationTargets,
-    durabilityMounts: uncoveredBasisMounts,
+    durabilityMounts: idleBasislessMounts,
     receiptMounts: configuredBasisMounts,
     requiredMounts: hydrationTargets,
     ignoreBusy: options.ignoreBusy,
     recordCurrentHead: true
   });
-  if (hydration.skippedMountIds.length > 0) {
-    throw new Error(
-      `Workspace HEAD ${currentHead} has not been fully hydrated; busy mounts must finish before projection: ${hydration.skippedMountIds.join(", ")}`
-    );
-  }
+  void hydration;
 }
 function resetWorkspaceGit(input) {
   const workspacePath = import_node_path.default.resolve(input.workspacePath);
   validateMounts(workspacePath, input.mounts);
+  const busyResetMountIds = input.mounts.filter((mount) => mount.busy?.()).map(({ id }) => id);
+  if (busyResetMountIds.length > 0) {
+    throw new Error(`Workspace reset cannot run while mounts are busy: ${busyResetMountIds.sort().join(", ")}`);
+  }
   const initial = ensureWorkspaceGitClone({ ...input, workspacePath });
   recoverPendingHydrationTransaction(workspacePath);
   const status = gitResult(workspacePath, ["status", "--porcelain=v1", "-z"]);
@@ -1300,69 +1505,137 @@ async function synchronizeWorkspaceGit(input) {
   const maxDiffBytes = input.maxDiffBytes ?? MAX_WORKSPACE_GIT_DIFF_BYTES;
   const maxPushAttempts = Math.max(1, input.maxPushAttempts ?? 4);
   validateMounts(workspacePath, input.mounts);
-  const busyLiveMountIds = input.skipMountMirror ? [] : input.mounts.filter((mount) => !(mount.deleteWhenSourceMissing && !import_node_fs.default.existsSync(mount.sourcePath)) && mount.busy?.()).map(({ id }) => id).sort();
-  if (busyLiveMountIds.length > 0) {
-    const cloneExists = import_node_fs.default.existsSync(import_node_path.default.join(workspacePath, ".git"));
-    const localHead = cloneExists ? revParse(workspacePath, "HEAD") : null;
-    const remoteHead2 = cloneExists ? revParse(workspacePath, `refs/remotes/origin/${WORKSPACE_GIT_BRANCH}`) : null;
-    return {
-      outcome: "no_change",
-      startingHead: localHead,
-      localHead,
-      remoteHead: remoteHead2,
-      publishedHead: remoteHead2,
-      rebaseCount: 0,
-      diffSizeBytes: 0,
-      affectedPaths: [],
-      activeMountIds: [],
-      skippedMountIds: input.mounts.map(({ id }) => id).sort()
-    };
-  }
-  const initial = ensureWorkspaceGitClone({ ...input, workspacePath });
+  const requiredAncestorHeads = requiredWorkspaceAncestorHeads(input.requiredAncestorHeads);
+  const preserveResolutionInProgress = input.skipMountMirror === true;
+  const initial = ensureWorkspaceGitClone({ ...input, workspacePath, preserveResolutionInProgress });
+  assertWorkspaceRemediationAncestry({
+    workspacePath,
+    currentHead: initial.localHead,
+    remoteHead: initial.remoteHead,
+    requiredAncestorHeads
+  });
+  const verifiedAncestorHeads = requiredAncestorHeads.length > 0 ? requiredAncestorHeads : void 0;
   const startingHead = initial.localHead;
   const receiptBeforeInitialHydration = readHydratedWorkspaceReceipt(workspacePath);
   const deferredMountIds = /* @__PURE__ */ new Set();
-  if (initial.localHead && initial.remoteHead && initial.remoteHead !== initial.localHead && receiptBeforeInitialHydration?.head === initial.localHead) {
+  if (initial.localHead && initial.remoteHead && initial.remoteHead !== initial.localHead) {
     for (const mount of input.mounts) {
-      if (!mount.deleteWhenSourceMissing && mount.preserveLocalOnInitialOuterAbsence !== true && mount.preserveLocalOnHydrationBasisChange !== true && !workspaceHydrationReceiptCoversMount(receiptBeforeInitialHydration, initial.localHead, mount)) {
+      if (!mount.deleteWhenSourceMissing && mount.preserveLocalOnInitialOuterAbsence !== true && mount.preserveLocalOnHydrationBasisChange !== true && workspaceHydrationReceiptMountBasisHead(receiptBeforeInitialHydration, mount) === null) {
         deferredMountIds.add(mount.id);
       }
     }
   }
   recoverWorkspaceGitHydration(workspacePath, input.mounts, {
-    ...deferredMountIds.size > 0 ? { deferMountIds: deferredMountIds } : {}
+    ...deferredMountIds.size > 0 ? { deferMountIds: deferredMountIds } : {},
+    preserveResolutionInProgress,
+    preserveStaleBases: true
   });
-  const receiptRequiredLiveMounts = input.mounts.filter(({ sourcePath }) => import_node_fs.default.existsSync(sourcePath));
   const selected = activeMounts(input.mounts);
-  const projectedActiveMounts = selected.active.filter(({ id }) => !deferredMountIds.has(id));
-  const projectedTombstones = selected.tombstones.filter(({ id }) => !deferredMountIds.has(id));
+  const projectionMutationTokens = new Map(
+    input.mounts.flatMap((mount) => mount.mutationToken ? [[mount.id, mount.mutationToken()]] : [])
+  );
+  const cycleSkippedMountIds = new Set(selected.skipped.map(({ id }) => id));
+  const receiptRequiredLiveMounts = selected.active;
   const projectionBasisHead = revParse(workspacePath, "HEAD");
   const projectionBasisReceipt = readHydratedWorkspaceReceipt(workspacePath);
-  const projectionReceiptMounts = configuredWorkspaceHydrationBasisMounts(workspacePath, input.mounts).filter(
-    (mount) => !deferredMountIds.has(mount.id) && Boolean(projectionBasisHead && workspaceHydrationReceiptCoversMount(projectionBasisReceipt, projectionBasisHead, mount))
-  );
+  const allProjectionReceiptMounts = configuredWorkspaceHydrationBasisMounts(workspacePath, input.mounts);
+  const fastProjectionMounts = [];
+  const mergedProjectionTrees = /* @__PURE__ */ new Map();
+  const mergedProjectionMounts = [];
+  const projectionSkippedIds = /* @__PURE__ */ new Set();
+  let projectionWarning;
+  const refreshCycleSkippedMounts = (mounts = input.mounts) => {
+    for (const mount of mounts) {
+      const projectionToken = projectionMutationTokens.get(mount.id);
+      if (projectionToken !== void 0 && mount.mutationToken?.() !== projectionToken) cycleSkippedMountIds.add(mount.id);
+      if (mount.busy?.()) cycleSkippedMountIds.add(mount.id);
+    }
+  };
+  const classifyMounts = (activeCandidates, additionalSkippedIds = []) => {
+    refreshCycleSkippedMounts();
+    const skippedIds = /* @__PURE__ */ new Set([...cycleSkippedMountIds, ...projectionSkippedIds, ...additionalSkippedIds]);
+    return {
+      activeMountIds: [...new Set(activeCandidates.filter(({ id }) => !skippedIds.has(id)).map(({ id }) => id))].sort(),
+      skippedMountIds: [...skippedIds].sort()
+    };
+  };
+  if (!input.skipMountMirror) {
+    const mergeProjectionEnabled = process.env.R5D_WORKSPACE_MERGE_PROJECTION !== "0";
+    const mergeSupport = mergeProjectionEnabled ? (0, import_workspace_merge_projection.workspaceMergeProjectionSupport)() : { supported: false, error: "Workspace merge projection is disabled by R5D_WORKSPACE_MERGE_PROJECTION=0" };
+    for (const mount of [...selected.active, ...selected.tombstones]) {
+      if (deferredMountIds.has(mount.id)) continue;
+      const basisHead = workspaceHydrationReceiptMountBasisHead(projectionBasisReceipt, mount);
+      if (projectionBasisHead === null || basisHead === projectionBasisHead) {
+        fastProjectionMounts.push(mount);
+        continue;
+      }
+      if (basisHead === null) {
+        deferredMountIds.add(mount.id);
+        continue;
+      }
+      if (!mergeSupport.supported) {
+        projectionSkippedIds.add(mount.id);
+        projectionWarning = mergeSupport.error ?? "Git 2.40 or newer is required for stale workspace mount projection";
+        continue;
+      }
+      const merged = (0, import_workspace_merge_projection.mergeWorkspaceProjectionMount)({
+        workspacePath,
+        mount: {
+          id: mount.id,
+          sourcePath: mount.sourcePath,
+          workspaceRelativePath: normalizedWorkspaceMountPath(mount.workspaceRelativePath),
+          sourceMode: mount.sourceMode
+        },
+        basisHead,
+        currentHead: projectionBasisHead,
+        attemptId
+      });
+      if (merged.kind === "conflict") {
+        const refs = snapshotConflict({ workspacePath, attemptId, localHead: merged.oursCommit, remoteHead: projectionBasisHead });
+        return {
+          outcome: "conflict_blocked",
+          startingHead,
+          localHead: merged.oursCommit,
+          remoteHead: initial.remoteHead,
+          publishedHead: initial.remoteHead,
+          rebaseCount: 0,
+          diffSizeBytes: 0,
+          affectedPaths: merged.conflictPaths,
+          activeMountIds: [],
+          skippedMountIds: input.mounts.map(({ id }) => id).sort(),
+          conflictPaths: merged.conflictPaths,
+          conflictSnapshotRefs: refs,
+          conflictKind: "projection_merge",
+          ...verifiedAncestorHeads ? { verifiedAncestorHeads } : {},
+          error: merged.error
+        };
+      }
+      mergedProjectionTrees.set(mount.id, merged.resultTree);
+      mergedProjectionMounts.push(mount);
+    }
+  }
+  if (projectionWarning) process.stderr.write(`[r5d-worker] ${projectionWarning}
+`);
   const completedMountSelection = (requireCurrentHeadReceipt = false) => {
     const currentHeadBeforeHydration = revParse(workspacePath, "HEAD");
     const completionReceiptMounts = configuredWorkspaceHydrationBasisMounts(workspacePath, input.mounts);
-    if (currentHeadBeforeHydration && workspaceHydrationReceiptMatchesMounts(
-      readHydratedWorkspaceReceipt(workspacePath),
-      currentHeadBeforeHydration,
-      completionReceiptMounts
-    )) {
-      const lateBusyIds = selected.active.filter((mount) => mount.busy?.()).map(({ id }) => id);
-      const lateBusy = new Set(lateBusyIds);
-      return {
-        activeMountIds: [...selected.active.filter(({ id }) => !lateBusy.has(id)), ...selected.tombstones].map(({ id }) => id).sort(),
-        skippedMountIds: [.../* @__PURE__ */ new Set([...selected.skipped.map(({ id }) => id), ...lateBusyIds])].sort()
-      };
-    }
     const currentReceiptBeforeHydration = readHydratedWorkspaceReceipt(workspacePath);
+    refreshCycleSkippedMounts(completionReceiptMounts);
     const mountIsAlreadyCovered = (mount) => Boolean(
       currentHeadBeforeHydration && workspaceHydrationReceiptCoversMount(currentReceiptBeforeHydration, currentHeadBeforeHydration, mount)
     );
-    const uncoveredCompletionMounts = selected.active.filter((mount) => !mountIsAlreadyCovered(mount));
-    const uncoveredRequiredLiveMounts = receiptRequiredLiveMounts.filter((mount) => !mountIsAlreadyCovered(mount));
-    const uncoveredCompletionBasisMounts = completionReceiptMounts.filter((mount) => !mountIsAlreadyCovered(mount));
+    if (currentHeadBeforeHydration && completionReceiptMounts.every((mount) => cycleSkippedMountIds.has(mount.id) || mountIsAlreadyCovered(mount))) {
+      return classifyMounts([...selected.active, ...selected.tombstones]);
+    }
+    const uncoveredCompletionMounts = selected.active.filter(
+      (mount) => !cycleSkippedMountIds.has(mount.id) && !projectionSkippedIds.has(mount.id) && !mountIsAlreadyCovered(mount)
+    );
+    const uncoveredRequiredLiveMounts = receiptRequiredLiveMounts.filter(
+      (mount) => !cycleSkippedMountIds.has(mount.id) && !projectionSkippedIds.has(mount.id) && !mountIsAlreadyCovered(mount)
+    );
+    const uncoveredCompletionBasisMounts = completionReceiptMounts.filter(
+      (mount) => !cycleSkippedMountIds.has(mount.id) && !projectionSkippedIds.has(mount.id) && !mountIsAlreadyCovered(mount)
+    );
     const hydration = hydrateWorkspaceGitMountsTransactionally({
       workspacePath,
       mounts: uncoveredCompletionMounts,
@@ -1371,22 +1644,32 @@ async function synchronizeWorkspaceGit(input) {
       requiredMounts: uncoveredRequiredLiveMounts,
       recordCurrentHead: true
     });
+    for (const id of hydration.skippedMountIds) cycleSkippedMountIds.add(id);
+    refreshCycleSkippedMounts(completionReceiptMounts);
     if (requireCurrentHeadReceipt) {
       const currentHead = revParse(workspacePath, "HEAD");
-      if (currentHead && !workspaceHydrationReceiptMatchesMounts(readHydratedWorkspaceReceipt(workspacePath), currentHead, completionReceiptMounts)) {
+      const receipt = readHydratedWorkspaceReceipt(workspacePath);
+      const transactionSkippedMountIds = new Set(hydration.skippedMountIds);
+      const idleMounts = completionReceiptMounts.filter(
+        (mount) => !cycleSkippedMountIds.has(mount.id) && !transactionSkippedMountIds.has(mount.id) && !mount.busy?.() && !projectionSkippedIds.has(mount.id)
+      );
+      if (currentHead && !idleMounts.every((mount) => workspaceHydrationReceiptCoversMount(receipt, currentHead, mount))) {
         throw new Error(`Workspace inbound integration ${currentHead} could not be fully hydrated before publication continued`);
       }
     }
-    return {
-      activeMountIds: [...selected.active, ...selected.tombstones].map(({ id }) => id).sort(),
-      skippedMountIds: [.../* @__PURE__ */ new Set([...selected.skipped.map(({ id }) => id), ...hydration.skippedMountIds])].sort()
-    };
+    return classifyMounts([...selected.active, ...selected.tombstones], hydration.skippedMountIds);
   };
   let newlyStagedPaths = [];
   const stageAndCommitWorkspace = () => {
+    if (workspaceResolutionInProgress(workspacePath) || workspaceHasUnmergedEntries(workspacePath)) {
+      throw new Error("Outer workspace clone has an unfinished merge/rebase; finish or abort it before synchronizing");
+    }
     git(workspacePath, ["add", "-A", "--", "."], "stage workspace working trees");
     newlyStagedPaths = stagedPaths(workspacePath);
     if (newlyStagedPaths.length > 0) {
+      if (workspaceResolutionInProgress(workspacePath) || workspaceHasUnmergedEntries(workspacePath)) {
+        throw new Error("Outer workspace clone has an unfinished merge/rebase; finish or abort it before synchronizing");
+      }
       git(
         workspacePath,
         [
@@ -1401,11 +1684,22 @@ async function synchronizeWorkspaceGit(input) {
   if (!input.skipMountMirror) {
     beginWorkspaceCheckoutTransition(workspacePath);
     try {
-      mirrorMountsToWorkspace(workspacePath, projectedActiveMounts);
-      removeWorkspaceMounts(workspacePath, projectedTombstones);
+      const selectedActiveIds = new Set(selected.active.map(({ id }) => id));
+      const fastActiveMounts = fastProjectionMounts.filter(({ id }) => selectedActiveIds.has(id));
+      const fastTombstones = fastProjectionMounts.filter(({ id }) => !selectedActiveIds.has(id));
+      mirrorMountsToWorkspace(workspacePath, fastActiveMounts);
+      removeWorkspaceMounts(workspacePath, fastTombstones);
+      for (const mount of mergedProjectionMounts) {
+        (0, import_workspace_merge_projection.materializeWorkspaceProjectionTree)({
+          workspacePath,
+          workspaceRelativePath: normalizedWorkspaceMountPath(mount.workspaceRelativePath),
+          resultTree: mergedProjectionTrees.get(mount.id)
+        });
+      }
+      const restoreFromHeadIds = /* @__PURE__ */ new Set([...deferredMountIds, ...selected.skipped.map(({ id }) => id)]);
       restoreDeferredWorkspaceMountsFromHead(
         workspacePath,
-        input.mounts.filter(({ id }) => deferredMountIds.has(id))
+        input.mounts.filter(({ id }) => restoreFromHeadIds.has(id))
       );
       stageAndCommitWorkspace();
       fsyncWorkspaceCheckoutTree(workspacePath);
@@ -1419,9 +1713,15 @@ async function synchronizeWorkspaceGit(input) {
   if (!input.skipMountMirror) {
     const projectedHead = revParse(workspacePath, "HEAD");
     if (!projectedHead) throw new Error("Workspace projection did not retain a local HEAD");
-    const targetProjectionReceipt = workspaceHydrationReceipt(projectedHead, projectionReceiptMounts);
-    if (!workspaceHydrationReceiptsEqual(readHydratedWorkspaceReceipt(workspacePath), targetProjectionReceipt)) {
-      fsyncHydratedWorkspaceMounts([...projectedActiveMounts, ...projectedTombstones]);
+    const targetProjectionReceipt = receiptWithMountsAtHead(
+      projectionBasisReceipt,
+      projectedHead,
+      fastProjectionMounts,
+      allProjectionReceiptMounts
+    );
+    const currentProjectionReceipt = readHydratedWorkspaceReceipt(workspacePath);
+    if (!workspaceHydrationReceiptsEqual(currentProjectionReceipt, targetProjectionReceipt) || !hydratedWorkspaceReceiptFileIsV3(workspacePath) || !workspaceBasisRefsAreCurrent(workspacePath, targetProjectionReceipt)) {
+      fsyncHydratedWorkspaceMounts(fastProjectionMounts);
       updateHydratedWorkspaceReceipt(workspacePath, targetProjectionReceipt);
     }
     completeWorkspaceCheckoutTransition(workspacePath);
@@ -1430,9 +1730,16 @@ async function synchronizeWorkspaceGit(input) {
   let rebaseCount = 0;
   let updated = false;
   for (let pushAttempt = 0; pushAttempt < maxPushAttempts; pushAttempt += 1) {
+    assertWorkspaceRemediationAncestry({
+      workspacePath,
+      currentHead: revParse(workspacePath, "HEAD"),
+      remoteHead,
+      requiredAncestorHeads
+    });
     const reconciled = synchronizeWithFetchedHead({ workspacePath, remoteHead, attemptId });
     if (reconciled.kind === "conflict") {
       const localHead2 = revParse(workspacePath, "HEAD");
+      const classifiedMounts = classifyMounts([...fastProjectionMounts, ...mergedProjectionMounts], deferredMountIds);
       return {
         outcome: "conflict_blocked",
         startingHead,
@@ -1442,10 +1749,11 @@ async function synchronizeWorkspaceGit(input) {
         rebaseCount: rebaseCount + 1,
         diffSizeBytes: 0,
         affectedPaths: [.../* @__PURE__ */ new Set([...newlyStagedPaths, ...reconciled.conflictPaths])].sort(),
-        activeMountIds: [...projectedActiveMounts, ...projectedTombstones].map(({ id }) => id).sort(),
-        skippedMountIds: [.../* @__PURE__ */ new Set([...selected.skipped.map(({ id }) => id), ...deferredMountIds])].sort(),
+        ...classifiedMounts,
         conflictPaths: reconciled.conflictPaths,
         conflictSnapshotRefs: reconciled.refs,
+        conflictKind: "integration_rebase",
+        ...verifiedAncestorHeads ? { verifiedAncestorHeads } : {},
         error: reconciled.error
       };
     }
@@ -1454,6 +1762,7 @@ async function synchronizeWorkspaceGit(input) {
     if (reconciled.updated || reconciled.rebased) completedMountSelection(true);
     const localHead = revParse(workspacePath, "HEAD");
     if (!localHead) {
+      const classifiedMounts = classifyMounts([...selected.active, ...selected.tombstones], deferredMountIds);
       return {
         outcome: "no_change",
         startingHead,
@@ -1463,13 +1772,16 @@ async function synchronizeWorkspaceGit(input) {
         rebaseCount,
         diffSizeBytes: 0,
         affectedPaths: [],
-        activeMountIds: [...selected.active, ...selected.tombstones].map(({ id }) => id).sort(),
-        skippedMountIds: selected.skipped.map(({ id }) => id).sort()
+        ...classifiedMounts,
+        ...verifiedAncestorHeads ? { verifiedAncestorHeads } : {},
+        ...projectionWarning ? { error: projectionWarning } : {}
       };
     }
     const paths = changedPaths(workspacePath, remoteHead, localHead);
-    const size = paths.length > 0 ? await diffSizeBytes(workspacePath, remoteHead, localHead, maxDiffBytes) : 0;
+    const size = paths.length > 0 ? await (input.measureDiffSize ?? diffSizeBytes)(workspacePath, remoteHead, localHead, maxDiffBytes) : 0;
+    input.assertStillAdmitted?.();
     if (paths.length > 0 && size > maxDiffBytes && !input.allowLargeDiff) {
+      const classifiedMounts = classifyMounts([...selected.active, ...selected.tombstones]);
       return {
         outcome: "large_diff_blocked",
         startingHead,
@@ -1479,17 +1791,19 @@ async function synchronizeWorkspaceGit(input) {
         rebaseCount,
         diffSizeBytes: size,
         affectedPaths: paths,
-        activeMountIds: [...selected.active, ...selected.tombstones].map(({ id }) => id).sort(),
-        skippedMountIds: selected.skipped.map(({ id }) => id).sort(),
+        ...classifiedMounts,
+        ...verifiedAncestorHeads ? { verifiedAncestorHeads } : {},
         error: `Workspace diff exceeds the ${maxDiffBytes}-byte automatic publication limit`
       };
     }
     if (localHead === remoteHead) {
+      assertWorkspaceRemediationAncestry({ workspacePath, currentHead: localHead, remoteHead, requiredAncestorHeads });
       const completedMounts = completedMountSelection(Boolean(input.skipMountMirror));
       await input.afterWorkspacePublished?.({
         publishedHead: localHead,
         activeMountIds: completedMounts.activeMountIds
       });
+      input.assertStillAdmitted?.();
       return {
         outcome: updated ? "updated" : "no_change",
         startingHead,
@@ -1499,9 +1813,12 @@ async function synchronizeWorkspaceGit(input) {
         rebaseCount,
         diffSizeBytes: size,
         affectedPaths: paths,
-        ...completedMounts
+        ...completedMounts,
+        ...verifiedAncestorHeads ? { verifiedAncestorHeads } : {},
+        ...projectionWarning ? { error: projectionWarning } : {}
       };
     }
+    assertWorkspaceRemediationAncestry({ workspacePath, currentHead: localHead, remoteHead, requiredAncestorHeads });
     const pushArgs = [
       ...(0, import_git_process_environment.gitTransportSecurityArgs)(input.remoteUrl, input.credentialHelper, input.credentialUsername),
       "push",
@@ -1511,12 +1828,14 @@ async function synchronizeWorkspaceGit(input) {
     pushArgs.push("origin", `HEAD:refs/heads/${WORKSPACE_GIT_BRANCH}`);
     const push = gitResult(workspacePath, pushArgs);
     if (push.exitCode === 0) {
+      assertWorkspaceRemediationAncestry({ workspacePath, currentHead: localHead, remoteHead, requiredAncestorHeads });
       updateIntegratedWorkspaceHead(workspacePath, localHead);
       const completedMounts = completedMountSelection(Boolean(input.skipMountMirror));
       await input.afterWorkspacePublished?.({
         publishedHead: localHead,
         activeMountIds: completedMounts.activeMountIds
       });
+      input.assertStillAdmitted?.();
       return {
         outcome: "pushed",
         startingHead,
@@ -1526,7 +1845,9 @@ async function synchronizeWorkspaceGit(input) {
         rebaseCount,
         diffSizeBytes: size,
         affectedPaths: paths,
-        ...completedMounts
+        ...completedMounts,
+        ...verifiedAncestorHeads ? { verifiedAncestorHeads } : {},
+        ...projectionWarning ? { error: projectionWarning } : {}
       };
     }
     if (!/(non-fast-forward|fetch first|rejected|failed to push some refs)/i.test(`${push.stderr}
@@ -1552,6 +1873,8 @@ const workspaceGitSyncTestHarness = {
   WORKSPACE_GIT_CONFIRMED_LARGE_DIFF_PUSH_OPTION,
   WORKSPACE_GIT_HYDRATED_RECEIPT,
   WORKSPACE_GIT_HYDRATION_TRANSACTION,
+  WorkspaceRemediationAncestryError,
+  configureExistingWorkspaceGitForRemediation,
   ensureWorkspaceGitClone,
   hydrateWorkspaceGitMounts,
   recoverWorkspaceGitHydration,