@ricsam/r5d-worker 0.0.86 → 0.0.88

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

@@ -63,6 +63,71 @@ function revParse(workspacePath, revision) {
   const result = gitResult(workspacePath, ["rev-parse", "--verify", revision]);
   return result.exitCode === 0 ? result.stdout : null;
 }
+async function gitResultAsync(cwd, args) {
+  const subprocess = Bun.spawn(gitCommandArgs(args), {
+    cwd,
+    stdin: "ignore",
+    stdout: "pipe",
+    stderr: "pipe",
+    env: workerGitProcessEnvironment()
+  });
+  const [stdout, stderr, exitCode] = await Promise.all([
+    new Response(subprocess.stdout).text(),
+    new Response(subprocess.stderr).text(),
+    subprocess.exited
+  ]);
+  return { exitCode, stdout: stdout.trim(), stderr: stderr.trim() };
+}
+async function gitAsync(cwd, args, action) {
+  const result = await gitResultAsync(cwd, args);
+  if (result.exitCode !== 0) throw new Error(`${action}: ${result.stderr || result.stdout || `git exited ${result.exitCode}`}`);
+  return result.stdout;
+}
+async function tryGitAsync(cwd, args) {
+  return (await gitResultAsync(cwd, args)).exitCode === 0;
+}
+async function revParseAsync(workspacePath, revision) {
+  const result = await gitResultAsync(workspacePath, ["rev-parse", "--verify", revision]);
+  return result.exitCode === 0 ? result.stdout : null;
+}
+function yieldToWorkerEventLoop() {
+  return new Promise((resolve) => setImmediate(resolve));
+}
+function workspaceCommitsExist(workspacePath, heads) {
+  const uniqueHeads = [...new Set(heads)];
+  if (uniqueHeads.length === 0) return true;
+  const batch = Bun.spawnSync(gitCommandArgs(["cat-file", "--batch-check"]), {
+    cwd: workspacePath,
+    stdin: Buffer.from(uniqueHeads.map((head) => `${head}^{commit}
+`).join("")),
+    stdout: "pipe",
+    stderr: "pipe",
+    env: workerGitProcessEnvironment()
+  });
+  if (batch.exitCode !== 0) return false;
+  const lines = batch.stdout.toString().split("\n").filter(Boolean);
+  return lines.length === uniqueHeads.length && lines.every((line) => !line.endsWith(" missing"));
+}
+async function workspaceCommitsExistAsync(workspacePath, heads) {
+  const uniqueHeads = [...new Set(heads)];
+  if (uniqueHeads.length === 0) return true;
+  const subprocess = Bun.spawn(gitCommandArgs(["cat-file", "--batch-check"]), {
+    cwd: workspacePath,
+    stdin: Buffer.from(uniqueHeads.map((head) => `${head}^{commit}
+`).join("")),
+    stdout: "pipe",
+    stderr: "pipe",
+    env: workerGitProcessEnvironment()
+  });
+  const [stdout, , exitCode] = await Promise.all([
+    new Response(subprocess.stdout).text(),
+    new Response(subprocess.stderr).text(),
+    subprocess.exited
+  ]);
+  if (exitCode !== 0) return false;
+  const lines = stdout.split("\n").filter(Boolean);
+  return lines.length === uniqueHeads.length && lines.every((line) => !line.endsWith(" missing"));
+}
 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) {
@@ -86,8 +151,8 @@ function assertWorkspaceRemediationAncestry(input) {
     );
   }
 }
-function updateIntegratedWorkspaceHead(workspacePath, head) {
-  git(workspacePath, ["update-ref", WORKSPACE_GIT_INTEGRATED_REF, head], "record integrated workspace head");
+async function updateIntegratedWorkspaceHead(workspacePath, head) {
+  await gitAsync(workspacePath, ["update-ref", WORKSPACE_GIT_INTEGRATED_REF, head], "record integrated workspace head");
 }
 function fsyncDirectory(directoryPath) {
   const descriptor = fs.openSync(directoryPath, fs.constants.O_RDONLY);
@@ -191,16 +256,13 @@ function configuredWorkspaceHydrationBasisMounts(workspacePath, mounts, deferMou
     return fs.existsSync(mount.sourcePath) || fs.existsSync(outerPath) || mount.sourceMode === "all";
   });
 }
-function parseWorkspaceHydrationReceiptContent(workspacePath, receiptPath, content) {
+function parseWorkspaceHydrationReceiptContentUnverified(receiptPath, content) {
   const legacyHead = content.endsWith("\n") ? content.slice(0, -1) : "";
   if (/^(?:[0-9a-f]{40}|[0-9a-f]{64})$/.test(legacyHead) && content === `${legacyHead}
 `) {
-    if (!tryGit(workspacePath, ["cat-file", "-e", `${legacyHead}^{commit}`])) {
-      throw new Error(`Workspace hydration receipt does not resolve to a local commit: ${receiptPath}`);
-    }
     const receipt2 = { version: 3, mounts: [] };
     Object.defineProperty(receipt2, "legacyHead", { value: legacyHead, enumerable: false });
-    return receipt2;
+    return { receipt: receipt2, headsToVerify: [legacyHead] };
   }
   let parsed;
   try {
@@ -268,14 +330,16 @@ function parseWorkspaceHydrationReceiptContent(workspacePath, receiptPath, conte
   }
   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, headsToVerify: [...receiptHeads] };
+}
+function parseWorkspaceHydrationReceiptContent(workspacePath, receiptPath, content) {
+  const { receipt, headsToVerify } = parseWorkspaceHydrationReceiptContentUnverified(receiptPath, content);
+  if (!workspaceCommitsExist(workspacePath, headsToVerify)) {
+    throw new Error(`Workspace hydration receipt does not resolve to a local commit: ${receiptPath}`);
   }
   return receipt;
 }
-function readHydratedWorkspaceReceipt(workspacePath) {
+function readHydratedWorkspaceReceiptUnverified(workspacePath) {
   const receiptPath = hydratedWorkspaceReceiptPath(workspacePath);
   const status = lstatIfExists(receiptPath);
   if (!status) return null;
@@ -283,7 +347,23 @@ function readHydratedWorkspaceReceipt(workspacePath) {
     throw new Error(`Workspace hydration receipt is not a regular file: ${receiptPath}`);
   }
   const content = fs.readFileSync(receiptPath, "utf8");
-  return parseWorkspaceHydrationReceiptContent(workspacePath, receiptPath, content);
+  return { ...parseWorkspaceHydrationReceiptContentUnverified(receiptPath, content), receiptPath };
+}
+function readHydratedWorkspaceReceipt(workspacePath) {
+  const unverified = readHydratedWorkspaceReceiptUnverified(workspacePath);
+  if (!unverified) return null;
+  if (!workspaceCommitsExist(workspacePath, unverified.headsToVerify)) {
+    throw new Error(`Workspace hydration receipt does not resolve to a local commit: ${unverified.receiptPath}`);
+  }
+  return unverified.receipt;
+}
+async function readHydratedWorkspaceReceiptAsync(workspacePath) {
+  const unverified = readHydratedWorkspaceReceiptUnverified(workspacePath);
+  if (!unverified) return null;
+  if (!await workspaceCommitsExistAsync(workspacePath, unverified.headsToVerify)) {
+    throw new Error(`Workspace hydration receipt does not resolve to a local commit: ${unverified.receiptPath}`);
+  }
+  return unverified.receipt;
 }
 function hydratedWorkspaceReceiptFileIsV3(workspacePath) {
   const receiptPath = hydratedWorkspaceReceiptPath(workspacePath);
@@ -330,49 +410,142 @@ function desiredWorkspaceBasisRefs(receipt) {
 }
 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));
+  const actual = git(
+    workspacePath,
+    ["for-each-ref", "--format=%(refname) %(objectname)", WORKSPACE_GIT_BASIS_REF_PREFIX],
+    `list ${WORKSPACE_GIT_BASIS_REF_PREFIX} refs`
+  ).split("\n").filter(Boolean);
+  if (actual.length !== desired.size) return false;
+  return actual.every((line) => {
+    const separator = line.lastIndexOf(" ");
+    if (separator <= 0) return false;
+    return desired.get(line.slice(0, separator)) === line.slice(separator + 1);
+  });
 }
 function workspaceBasisRefsAreCurrent(workspacePath, receipt) {
   return workspaceBasisRefsMatch(workspacePath, receipt) && listWorkspaceRefs(workspacePath, WORKSPACE_GIT_BASIS_STAGING_REF_PREFIX).length === 0;
 }
+async function workspaceBasisRefsAreCurrentAsync(workspacePath, receipt) {
+  const desired = desiredWorkspaceBasisRefs(receipt);
+  const listing = await gitAsync(
+    workspacePath,
+    ["for-each-ref", "--format=%(refname) %(objectname)", WORKSPACE_GIT_BASIS_REF_PREFIX, WORKSPACE_GIT_BASIS_STAGING_REF_PREFIX],
+    "list workspace hydration basis refs"
+  );
+  const stable = /* @__PURE__ */ new Map();
+  for (const line of listing.split("\n").filter(Boolean)) {
+    const separator = line.lastIndexOf(" ");
+    if (separator <= 0) return false;
+    const ref = line.slice(0, separator);
+    if (ref.startsWith(WORKSPACE_GIT_BASIS_STAGING_REF_PREFIX)) return false;
+    stable.set(ref, line.slice(separator + 1));
+  }
+  if (stable.size !== desired.size) return false;
+  return [...stable].every(([ref, head]) => desired.get(ref) === head);
+}
 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", "");
+function runWorkspaceRefUpdateBatch(workspacePath, instructions, action) {
+  if (instructions.length === 0) return;
   const updated = Bun.spawnSync(gitCommandArgs(["update-ref", "--stdin"]), {
     cwd: workspacePath,
-    stdin: Buffer.from(transaction.join("\n")),
+    stdin: Buffer.from([...instructions, ""].join("\n")),
     stdout: "pipe",
     stderr: "pipe",
     env: workerGitProcessEnvironment()
   });
   if (updated.exitCode !== 0) {
-    throw new Error(`Synchronize workspace hydration basis refs: ${updated.stderr.toString().trim() || `git exited ${updated.exitCode}`}`);
+    throw new Error(`${action}: ${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");
+}
+async function runWorkspaceRefUpdateBatchAsync(workspacePath, instructions, action) {
+  if (instructions.length === 0) return;
+  const subprocess = Bun.spawn(gitCommandArgs(["update-ref", "--stdin"]), {
+    cwd: workspacePath,
+    stdin: Buffer.from([...instructions, ""].join("\n")),
+    stdout: "pipe",
+    stderr: "pipe",
+    env: workerGitProcessEnvironment()
+  });
+  const [, stderr, exitCode] = await Promise.all([
+    new Response(subprocess.stdout).text(),
+    new Response(subprocess.stderr).text(),
+    subprocess.exited
+  ]);
+  if (exitCode !== 0) {
+    throw new Error(`${action}: ${stderr.trim() || `git exited ${exitCode}`}`);
   }
 }
-function updateHydratedWorkspaceReceipt(workspacePath, receipt) {
+function workspaceBasisRefTransaction(receipt, stableRefs) {
+  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 stableRefs) {
+    if (!desired.has(ref)) transaction.push(`delete ${ref}`);
+  }
+  transaction.push("prepare", "commit");
+  return transaction;
+}
+function updateWorkspaceBasisRefs(workspacePath, receipt) {
+  runWorkspaceRefUpdateBatch(
+    workspacePath,
+    workspaceBasisRefTransaction(receipt, listWorkspaceRefs(workspacePath, WORKSPACE_GIT_BASIS_REF_PREFIX)),
+    "Synchronize workspace hydration basis refs"
+  );
+  runWorkspaceRefUpdateBatch(
+    workspacePath,
+    listWorkspaceRefs(workspacePath, WORKSPACE_GIT_BASIS_STAGING_REF_PREFIX).map((ref) => `delete ${ref}`),
+    "remove staged workspace hydration basis refs"
+  );
+}
+async function updateWorkspaceBasisRefsAsync(workspacePath, receipt) {
+  const stableRefs = (await gitAsync(workspacePath, ["for-each-ref", "--format=%(refname)", WORKSPACE_GIT_BASIS_REF_PREFIX], "list workspace basis refs")).split("\n").filter(Boolean).sort();
+  await runWorkspaceRefUpdateBatchAsync(
+    workspacePath,
+    workspaceBasisRefTransaction(receipt, stableRefs),
+    "Synchronize workspace hydration basis refs"
+  );
+  const stagedRefs = (await gitAsync(
+    workspacePath,
+    ["for-each-ref", "--format=%(refname)", WORKSPACE_GIT_BASIS_STAGING_REF_PREFIX],
+    "list staged workspace basis refs"
+  )).split("\n").filter(Boolean).sort();
+  await runWorkspaceRefUpdateBatchAsync(
+    workspacePath,
+    stagedRefs.map((ref) => `delete ${ref}`),
+    "remove staged workspace hydration basis refs"
+  );
+}
+function assertCanonicalHydrationReceiptHeads(receipt) {
   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}`);
-    }
+  }
+}
+function throwMissingHydrationReceiptCommit(workspacePath, receipt) {
+  const missing = receipt.mounts.find(({ head }) => !tryGit(workspacePath, ["cat-file", "-e", `${head}^{commit}`]));
+  throw new Error(`Cannot record workspace hydration receipt for a missing commit: ${missing?.head ?? "unknown"}`);
+}
+function updateHydratedWorkspaceReceipt(workspacePath, receipt) {
+  assertCanonicalHydrationReceiptHeads(receipt);
+  if (!workspaceCommitsExist(workspacePath, receipt.mounts.map(({ head }) => head))) {
+    throwMissingHydrationReceiptCommit(workspacePath, receipt);
   }
   readHydratedWorkspaceReceipt(workspacePath);
+  writeHydratedWorkspaceReceiptCore(workspacePath, receipt);
+}
+async function updateHydratedWorkspaceReceiptAsync(workspacePath, receipt) {
+  assertCanonicalHydrationReceiptHeads(receipt);
+  if (!await workspaceCommitsExistAsync(workspacePath, receipt.mounts.map(({ head }) => head))) {
+    throwMissingHydrationReceiptCommit(workspacePath, receipt);
+  }
+  await readHydratedWorkspaceReceiptAsync(workspacePath);
+  await writeHydratedWorkspaceReceiptCoreAsync(workspacePath, receipt);
+}
+function prepareHydratedWorkspaceReceiptWrite(workspacePath) {
   const gitDirectory = path.join(workspacePath, ".git");
   const gitDirectoryStatus = fs.lstatSync(gitDirectory);
   if (!gitDirectoryStatus.isDirectory() || gitDirectoryStatus.isSymbolicLink()) {
@@ -389,13 +562,16 @@ function updateHydratedWorkspaceReceipt(workspacePath, receipt) {
   if (!receiptDirectoryStatus.isDirectory() || receiptDirectoryStatus.isSymbolicLink()) {
     throw new Error(`Workspace hydration receipt directory is not a regular directory: ${receiptDirectory}`);
   }
-  const temporaryPath = path.join(receiptDirectory, `.workspace-hydrated-head.${process.pid}.${crypto.randomUUID()}.tmp`);
-  const stagingPrefix = `${WORKSPACE_GIT_BASIS_STAGING_REF_PREFIX}${crypto.randomUUID()}/`;
+  return { receiptPath, receiptDirectory };
+}
+function stagedWorkspaceBasisRefInstructions(receipt, stagingPrefix) {
   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");
-  }
+  return receipt.mounts.map(
+    (mount) => `update ${stagingPrefix}${workspaceBasisRefName(mount.id).slice(WORKSPACE_GIT_BASIS_REF_PREFIX.length)} ${mount.head}`
+  );
+}
+function publishHydratedWorkspaceReceiptFile(workspacePath, receipt, paths) {
+  const temporaryPath = path.join(paths.receiptDirectory, `.workspace-hydrated-head.${process.pid}.${crypto.randomUUID()}.tmp`);
   let descriptor;
   try {
     descriptor = fs.openSync(temporaryPath, fs.constants.O_WRONLY | fs.constants.O_CREAT | fs.constants.O_EXCL, 384);
@@ -404,15 +580,36 @@ function updateHydratedWorkspaceReceipt(workspacePath, receipt) {
     fs.fsyncSync(descriptor);
     fs.closeSync(descriptor);
     descriptor = void 0;
-    fs.renameSync(temporaryPath, receiptPath);
-    fsyncDirectory(receiptDirectory);
-    updateWorkspaceBasisRefs(workspacePath, receipt);
+    fs.renameSync(temporaryPath, paths.receiptPath);
+    fsyncDirectory(paths.receiptDirectory);
   } catch (error) {
     if (descriptor !== void 0) fs.closeSync(descriptor);
     fs.rmSync(temporaryPath, { force: true });
     throw error;
   }
 }
+function writeHydratedWorkspaceReceiptCore(workspacePath, receipt) {
+  const paths = prepareHydratedWorkspaceReceiptWrite(workspacePath);
+  const stagingPrefix = `${WORKSPACE_GIT_BASIS_STAGING_REF_PREFIX}${crypto.randomUUID()}/`;
+  runWorkspaceRefUpdateBatch(
+    workspacePath,
+    stagedWorkspaceBasisRefInstructions(receipt, stagingPrefix),
+    "stage workspace hydration basis refs"
+  );
+  publishHydratedWorkspaceReceiptFile(workspacePath, receipt, paths);
+  updateWorkspaceBasisRefs(workspacePath, receipt);
+}
+async function writeHydratedWorkspaceReceiptCoreAsync(workspacePath, receipt) {
+  const paths = prepareHydratedWorkspaceReceiptWrite(workspacePath);
+  const stagingPrefix = `${WORKSPACE_GIT_BASIS_STAGING_REF_PREFIX}${crypto.randomUUID()}/`;
+  await runWorkspaceRefUpdateBatchAsync(
+    workspacePath,
+    stagedWorkspaceBasisRefInstructions(receipt, stagingPrefix),
+    "stage workspace hydration basis refs"
+  );
+  publishHydratedWorkspaceReceiptFile(workspacePath, receipt, paths);
+  await updateWorkspaceBasisRefsAsync(workspacePath, receipt);
+}
 function hydrationTransactionPath(workspacePath) {
   return path.join(workspacePath, ".git", ...WORKSPACE_GIT_HYDRATION_TRANSACTION.split("/"));
 }
@@ -464,7 +661,7 @@ function fsyncTree(rootPath) {
   };
   syncEntry(rootPath);
 }
-function parseWorkspaceCheckoutDurabilityRecord(workspacePath, recordPath, content) {
+function parseWorkspaceCheckoutDurabilityRecordUnverified(recordPath, content) {
   let parsed;
   try {
     parsed = JSON.parse(content);
@@ -487,25 +684,34 @@ function parseWorkspaceCheckoutDurabilityRecord(workspacePath, recordPath, conte
 `) {
     throw new Error(`Workspace checkout durability record is noncanonical: ${recordPath}`);
   }
-  if (record.head && !tryGit(workspacePath, ["cat-file", "-e", `${record.head}^{commit}`])) {
-    throw new Error(`Workspace checkout durability record names a missing commit: ${recordPath}`);
-  }
   return record;
 }
-function readWorkspaceCheckoutDurabilityRecord(workspacePath) {
+function readWorkspaceCheckoutDurabilityRecordUnverified(workspacePath) {
   const recordPath = workspaceCheckoutDurabilityPath(workspacePath);
   const status = lstatIfExists(recordPath);
   if (!status) return null;
   if (!status.isFile() || status.isSymbolicLink()) {
     throw new Error(`Workspace checkout durability record is not a regular file: ${recordPath}`);
   }
-  return parseWorkspaceCheckoutDurabilityRecord(workspacePath, recordPath, fs.readFileSync(recordPath, "utf8"));
+  return { record: parseWorkspaceCheckoutDurabilityRecordUnverified(recordPath, fs.readFileSync(recordPath, "utf8")), recordPath };
 }
-function updateWorkspaceCheckoutDurabilityRecord(workspacePath, record) {
-  if (record.head && !tryGit(workspacePath, ["cat-file", "-e", `${record.head}^{commit}`])) {
-    throw new Error(`Cannot record workspace checkout durability for a missing commit: ${record.head}`);
+function readWorkspaceCheckoutDurabilityRecord(workspacePath) {
+  const unverified = readWorkspaceCheckoutDurabilityRecordUnverified(workspacePath);
+  if (!unverified) return null;
+  if (unverified.record.head && !tryGit(workspacePath, ["cat-file", "-e", `${unverified.record.head}^{commit}`])) {
+    throw new Error(`Workspace checkout durability record names a missing commit: ${unverified.recordPath}`);
   }
-  readWorkspaceCheckoutDurabilityRecord(workspacePath);
+  return unverified.record;
+}
+async function readWorkspaceCheckoutDurabilityRecordAsync(workspacePath) {
+  const unverified = readWorkspaceCheckoutDurabilityRecordUnverified(workspacePath);
+  if (!unverified) return null;
+  if (unverified.record.head && !await tryGitAsync(workspacePath, ["cat-file", "-e", `${unverified.record.head}^{commit}`])) {
+    throw new Error(`Workspace checkout durability record names a missing commit: ${unverified.recordPath}`);
+  }
+  return unverified.record;
+}
+function writeWorkspaceCheckoutDurabilityRecordFile(workspacePath, record) {
   const stateDirectory = workspacePrivateStateDirectory(workspacePath);
   const recordPath = workspaceCheckoutDurabilityPath(workspacePath);
   const temporaryPath = path.join(stateDirectory, `.workspace-checkout-durability.${process.pid}.${crypto.randomUUID()}.tmp`);
@@ -519,6 +725,20 @@ function updateWorkspaceCheckoutDurabilityRecord(workspacePath, record) {
     throw error;
   }
 }
+function updateWorkspaceCheckoutDurabilityRecord(workspacePath, record) {
+  if (record.head && !tryGit(workspacePath, ["cat-file", "-e", `${record.head}^{commit}`])) {
+    throw new Error(`Cannot record workspace checkout durability for a missing commit: ${record.head}`);
+  }
+  readWorkspaceCheckoutDurabilityRecord(workspacePath);
+  writeWorkspaceCheckoutDurabilityRecordFile(workspacePath, record);
+}
+async function updateWorkspaceCheckoutDurabilityRecordAsync(workspacePath, record) {
+  if (record.head && !await tryGitAsync(workspacePath, ["cat-file", "-e", `${record.head}^{commit}`])) {
+    throw new Error(`Cannot record workspace checkout durability for a missing commit: ${record.head}`);
+  }
+  await readWorkspaceCheckoutDurabilityRecordAsync(workspacePath);
+  writeWorkspaceCheckoutDurabilityRecordFile(workspacePath, record);
+}
 function fsyncWorkspaceCheckoutTree(workspacePath) {
   const status = fs.lstatSync(workspacePath);
   if (!status.isDirectory() || status.isSymbolicLink()) {
@@ -530,6 +750,40 @@ function fsyncWorkspaceCheckoutTree(workspacePath) {
   }
   fsyncDirectory(workspacePath);
 }
+const WORKSPACE_FSYNC_YIELD_INTERVAL = 64;
+async function fsyncWorkspaceCheckoutTreeYielding(workspacePath) {
+  const status = fs.lstatSync(workspacePath);
+  if (!status.isDirectory() || status.isSymbolicLink()) {
+    throw new Error(`Workspace clone root is not a regular directory: ${workspacePath}`);
+  }
+  let entriesSinceYield = 0;
+  const syncEntry = async (entryPath) => {
+    const entryStatus = fs.lstatSync(entryPath);
+    if (entryStatus.isSymbolicLink()) return;
+    if (entryStatus.isDirectory()) {
+      for (const name of fs.readdirSync(entryPath)) await syncEntry(path.join(entryPath, name));
+      fsyncDirectory(entryPath);
+      return;
+    }
+    if (!entryStatus.isFile()) return;
+    const descriptor = fs.openSync(entryPath, fs.constants.O_RDONLY | fs.constants.O_NOFOLLOW);
+    try {
+      fs.fsyncSync(descriptor);
+    } finally {
+      fs.closeSync(descriptor);
+    }
+    entriesSinceYield += 1;
+    if (entriesSinceYield >= WORKSPACE_FSYNC_YIELD_INTERVAL) {
+      entriesSinceYield = 0;
+      await yieldToWorkerEventLoop();
+    }
+  };
+  for (const name of fs.readdirSync(workspacePath)) {
+    if (name === ".git") continue;
+    await syncEntry(path.join(workspacePath, name));
+  }
+  fsyncDirectory(workspacePath);
+}
 function workspaceRebaseInProgress(workspacePath) {
   const gitDirectory = path.join(workspacePath, ".git");
   return fs.existsSync(path.join(gitDirectory, "rebase-merge")) || fs.existsSync(path.join(gitDirectory, "rebase-apply"));
@@ -537,8 +791,8 @@ function workspaceRebaseInProgress(workspacePath) {
 function workspaceResolutionInProgress(workspacePath) {
   return workspaceRebaseInProgress(workspacePath) || fs.existsSync(path.join(workspacePath, ".git", "MERGE_HEAD"));
 }
-function workspaceHasUnmergedEntries(workspacePath) {
-  const result = gitResult(workspacePath, ["ls-files", "-u", "-z"]);
+async function workspaceHasUnmergedEntries(workspacePath) {
+  const result = await gitResultAsync(workspacePath, ["ls-files", "-u", "-z"]);
   if (result.exitCode !== 0) {
     throw new Error(`Inspect unfinished workspace merge: ${result.stderr || result.stdout || `git exited ${result.exitCode}`}`);
   }
@@ -594,17 +848,21 @@ function workspaceCheckoutDurabilityIsCurrent(workspacePath) {
   const record = readWorkspaceCheckoutDurabilityRecord(workspacePath);
   return Boolean(record?.state === "durable" && record.head === revParse(workspacePath, "HEAD"));
 }
+async function workspaceCheckoutDurabilityIsCurrentAsync(workspacePath) {
+  const record = await readWorkspaceCheckoutDurabilityRecordAsync(workspacePath);
+  return Boolean(record?.state === "durable" && record.head === await revParseAsync(workspacePath, "HEAD"));
+}
 function beginWorkspaceCheckoutTransition(workspacePath) {
   recoverWorkspaceCheckoutDurability(workspacePath);
   const head = revParse(workspacePath, "HEAD");
   updateWorkspaceCheckoutDurabilityRecord(workspacePath, { version: 1, state: "transition", head });
 }
-function completeWorkspaceCheckoutTransition(workspacePath) {
-  fsyncWorkspaceCheckoutTree(workspacePath);
-  updateWorkspaceCheckoutDurabilityRecord(workspacePath, {
+async function completeWorkspaceCheckoutTransition(workspacePath) {
+  await fsyncWorkspaceCheckoutTreeYielding(workspacePath);
+  await updateWorkspaceCheckoutDurabilityRecordAsync(workspacePath, {
     version: 1,
     state: "durable",
-    head: revParse(workspacePath, "HEAD")
+    head: await revParseAsync(workspacePath, "HEAD")
   });
 }
 function throwAfterWorkspaceCheckoutRecovery(workspacePath, error) {
@@ -618,11 +876,11 @@ function throwAfterWorkspaceCheckoutRecovery(workspacePath, error) {
   }
   throw error;
 }
-function runWorkspaceCheckoutTransition(workspacePath, mutate) {
+async function runWorkspaceCheckoutTransition(workspacePath, mutate) {
   beginWorkspaceCheckoutTransition(workspacePath);
   try {
-    mutate();
-    completeWorkspaceCheckoutTransition(workspacePath);
+    await mutate();
+    await completeWorkspaceCheckoutTransition(workspacePath);
   } catch (error) {
     throwAfterWorkspaceCheckoutRecovery(workspacePath, error);
   }
@@ -920,24 +1178,24 @@ function validateMounts(workspacePath, mounts) {
     if (overlap) throw new Error(`Workspace mounts overlap: ${current} and ${overlap}`);
   }
 }
-function configureWorkspaceRepository(input) {
-  if (tryGit(input.workspacePath, ["remote", "get-url", "origin"])) {
-    git(input.workspacePath, ["remote", "set-url", "origin", input.remoteUrl], "configure workspace origin");
+async function configureWorkspaceRepository(input) {
+  if (await tryGitAsync(input.workspacePath, ["remote", "get-url", "origin"])) {
+    await gitAsync(input.workspacePath, ["remote", "set-url", "origin", input.remoteUrl], "configure workspace origin");
   } else {
-    git(input.workspacePath, ["remote", "add", "origin", input.remoteUrl], "configure workspace origin");
+    await gitAsync(input.workspacePath, ["remote", "add", "origin", input.remoteUrl], "configure workspace origin");
   }
-  tryGit(input.workspacePath, ["config", "--local", "--unset-all", "remote.origin.pushurl"]);
-  git(input.workspacePath, ["config", "--local", "--replace-all", "credential.helper", ""], "reset workspace credential helpers");
-  git(input.workspacePath, ["config", "--local", "credential.useHttpPath", "false"], "configure workspace credential path matching");
+  await tryGitAsync(input.workspacePath, ["config", "--local", "--unset-all", "remote.origin.pushurl"]);
+  await gitAsync(input.workspacePath, ["config", "--local", "--replace-all", "credential.helper", ""], "reset workspace credential helpers");
+  await gitAsync(input.workspacePath, ["config", "--local", "credential.useHttpPath", "false"], "configure workspace credential path matching");
   if (input.credentialUsername) {
-    git(
+    await gitAsync(
       input.workspacePath,
       ["config", "--local", "--replace-all", gitCredentialUsernameConfigKey(input.remoteUrl), input.credentialUsername],
       "configure workspace credential username"
     );
   }
   if (input.credentialHelper) {
-    git(
+    await gitAsync(
       input.workspacePath,
       ["config", "--local", "--add", "credential.helper", input.credentialHelper],
       "configure workspace credential helper"
@@ -946,26 +1204,26 @@ function configureWorkspaceRepository(input) {
   const name = input.gitIdentity.name.trim();
   const email = input.gitIdentity.email.trim();
   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(
+  await gitAsync(input.workspacePath, ["config", "--local", "user.name", name], "configure workspace Git user name");
+  await gitAsync(input.workspacePath, ["config", "--local", "user.email", email], "configure workspace Git user email");
+  await gitAsync(
     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");
+  await gitAsync(input.workspacePath, ["config", "--local", "core.fsyncMethod", "fsync"], "configure workspace fsync method");
 }
-function configureExistingWorkspaceGitForRemediation(input) {
+async function configureExistingWorkspaceGitForRemediation(input) {
   const workspacePath = path.resolve(input.workspacePath);
   const workspaceStatus = lstatIfExists(workspacePath);
   const gitStatus = lstatIfExists(path.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 });
+  await configureWorkspaceRepository({ ...input, workspacePath });
 }
-function fetchWorkspaceHead(workspacePath, remoteUrl, credentialHelper, credentialUsername) {
-  const result = gitResult(workspacePath, [
+async function fetchWorkspaceHead(workspacePath, remoteUrl, credentialHelper, credentialUsername) {
+  const result = await gitResultAsync(workspacePath, [
     ...gitTransportSecurityArgs(remoteUrl, credentialHelper, credentialUsername),
     "fetch",
     "--no-recurse-submodules",
@@ -984,7 +1242,7 @@ ${result.stdout}`;
   }
   return revParse(workspacePath, `refs/remotes/origin/${WORKSPACE_GIT_BRANCH}`);
 }
-function ensureWorkspaceGitClone(input) {
+async function ensureWorkspaceGitClone(input) {
   const workspacePath = path.resolve(input.workspacePath);
   const workspaceParent = path.dirname(workspacePath);
   const parentStatus = fs.lstatSync(workspaceParent);
@@ -1024,18 +1282,18 @@ function ensureWorkspaceGitClone(input) {
       git(workspacePath, ["init", `--initial-branch=${WORKSPACE_GIT_BRANCH}`], "initialize workspace clone");
     }
   }
-  configureWorkspaceRepository({ ...input, workspacePath });
+  await configureWorkspaceRepository({ ...input, 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])) {
-    updateIntegratedWorkspaceHead(workspacePath, previousRemoteHead);
+  const previousRemoteHead = await revParseAsync(workspacePath, `refs/remotes/origin/${WORKSPACE_GIT_BRANCH}`);
+  const localHeadBeforeFetch = await revParseAsync(workspacePath, "HEAD");
+  if (!await revParseAsync(workspacePath, WORKSPACE_GIT_INTEGRATED_REF) && previousRemoteHead && localHeadBeforeFetch && await tryGitAsync(workspacePath, ["merge-base", "--is-ancestor", previousRemoteHead, localHeadBeforeFetch])) {
+    await updateIntegratedWorkspaceHead(workspacePath, previousRemoteHead);
   }
-  const remoteHead = fetchWorkspaceHead(workspacePath, input.remoteUrl, input.credentialHelper, input.credentialUsername);
-  let localHead = revParse(workspacePath, "HEAD");
+  const remoteHead = await fetchWorkspaceHead(workspacePath, input.remoteUrl, input.credentialHelper, input.credentialUsername);
+  let localHead = await revParseAsync(workspacePath, "HEAD");
   if (!localHead && remoteHead) {
-    runWorkspaceCheckoutTransition(workspacePath, () => {
-      git(
+    await runWorkspaceCheckoutTransition(workspacePath, async () => {
+      await gitAsync(
         workspacePath,
         ["checkout", "--no-recurse-submodules", "-B", WORKSPACE_GIT_BRANCH, `refs/remotes/origin/${WORKSPACE_GIT_BRANCH}`],
         "check out workspace main"
@@ -1044,12 +1302,12 @@ function ensureWorkspaceGitClone(input) {
     localHead = remoteHead;
   }
   if (localHead && remoteHead && localHead === remoteHead) {
-    updateIntegratedWorkspaceHead(workspacePath, remoteHead);
+    await updateIntegratedWorkspaceHead(workspacePath, remoteHead);
   } else if (localHead && remoteHead && workspaceIsShallow(workspacePath) && !tryGit(workspacePath, ["merge-base", localHead, remoteHead]) && revParse(workspacePath, WORKSPACE_GIT_INTEGRATED_REF) === localHead && workspaceIsClean(workspacePath)) {
-    runWorkspaceCheckoutTransition(workspacePath, () => {
-      git(workspacePath, ["reset", "--hard", remoteHead], "advance workspace across retained history boundary");
+    await runWorkspaceCheckoutTransition(workspacePath, async () => {
+      await gitAsync(workspacePath, ["reset", "--hard", remoteHead], "advance workspace across retained history boundary");
     });
-    updateIntegratedWorkspaceHead(workspacePath, remoteHead);
+    await updateIntegratedWorkspaceHead(workspacePath, remoteHead);
     localHead = remoteHead;
   }
   return { localHead, remoteHead };
@@ -1173,7 +1431,7 @@ function hydrateWorkspaceGitMountsRaw(workspacePath, mounts, options = {}) {
   }
   return { hydratedMountIds: hydratedMountIds.sort(), skippedMountIds: skippedMountIds.sort() };
 }
-function hydrateWorkspaceGitMountsTransactionally(input) {
+async function hydrateWorkspaceGitMountsTransactionally(input) {
   const workspacePath = path.resolve(input.workspacePath);
   const durabilityMounts = input.durabilityMounts ?? input.mounts;
   const receiptMounts = input.receiptMounts ?? durabilityMounts;
@@ -1181,19 +1439,34 @@ function hydrateWorkspaceGitMountsTransactionally(input) {
   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)) {
+  if (input.recordCurrentHead && !await workspaceCheckoutDurabilityIsCurrentAsync(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 ? receiptWithMountsAtHead(readHydratedWorkspaceReceipt(workspacePath), targetHead, advancedDurabilityMounts, receiptMounts) : null;
+  const targetHead = input.recordCurrentHead ? await revParseAsync(workspacePath, "HEAD") : null;
+  const receiptBeforeTransaction = targetHead ? await readHydratedWorkspaceReceiptAsync(workspacePath) : null;
+  const computeSelection = () => {
+    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 hydrationMounts2 = input.mounts.filter(({ id }) => !busyMountIds.has(id));
+    const advancedDurabilityMounts2 = 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);
+    return {
+      busyMountIds,
+      hydrationMounts: hydrationMounts2,
+      advancedDurabilityMounts: advancedDurabilityMounts2,
+      skippedMountIds: [.../* @__PURE__ */ new Set([...busyMountIds, ...unavailableRequiredIds])].sort(),
+      targetReceipt: targetHead ? receiptWithMountsAtHead(receiptBeforeTransaction, targetHead, advancedDurabilityMounts2, receiptMounts) : null
+    };
+  };
+  const noopCandidate = computeSelection();
+  if (noopCandidate.hydrationMounts.length === 0 && noopCandidate.advancedDurabilityMounts.length === 0 && noopCandidate.targetReceipt && lstatIfExists(hydrationTransactionPath(workspacePath)) === null && workspaceHydrationReceiptsEqual(receiptBeforeTransaction, noopCandidate.targetReceipt) && hydratedWorkspaceReceiptFileIsV3(workspacePath) && await workspaceBasisRefsAreCurrentAsync(workspacePath, noopCandidate.targetReceipt)) {
+    return { hydratedMountIds: [], skippedMountIds: noopCandidate.skippedMountIds };
+  }
+  const selection = computeSelection();
+  const { hydrationMounts, advancedDurabilityMounts, targetReceipt } = selection;
   const manifest = beginHydrationTransaction(workspacePath, hydrationMounts, targetReceipt);
   try {
     const hydration = hydrateWorkspaceGitMountsRaw(workspacePath, hydrationMounts, { ignoreBusy: true });
@@ -1207,7 +1480,7 @@ function hydrateWorkspaceGitMountsTransactionally(input) {
     removeHydrationTransaction(workspacePath);
     return {
       hydratedMountIds: hydration.hydratedMountIds,
-      skippedMountIds: [.../* @__PURE__ */ new Set([...busyMountIds, ...unavailableRequiredIds])].sort()
+      skippedMountIds: selection.skippedMountIds
     };
   } catch (error) {
     const transactionPath = hydrationTransactionPath(workspacePath);
@@ -1226,7 +1499,7 @@ function hydrateWorkspaceGitMountsTransactionally(input) {
     throw error;
   }
 }
-function hydrateWorkspaceGitMounts(workspacePath, mounts, options = {}) {
+async function hydrateWorkspaceGitMounts(workspacePath, mounts, options = {}) {
   const gitDirectory = path.join(path.resolve(workspacePath), ".git");
   if (!fs.existsSync(gitDirectory)) {
     return hydrateWorkspaceGitMountsRaw(workspacePath, mounts, options);
@@ -1238,16 +1511,18 @@ function hydrateWorkspaceGitMounts(workspacePath, mounts, options = {}) {
     ignoreBusy: options.ignoreBusy
   });
 }
-function recoverWorkspaceGitHydration(workspacePath, mounts, options = {}) {
+async function recoverWorkspaceGitHydration(workspacePath, mounts, options = {}) {
   workspacePath = path.resolve(workspacePath);
   validateMounts(workspacePath, mounts);
   recoverWorkspaceCheckoutDurability(workspacePath, options.preserveResolutionInProgress);
   recoverPendingHydrationTransaction(workspacePath);
-  const currentHead = revParse(workspacePath, "HEAD");
-  const currentReceipt = readHydratedWorkspaceReceipt(workspacePath);
-  repairWorkspaceBasisRefs(workspacePath, currentReceipt);
+  const currentHead = await revParseAsync(workspacePath, "HEAD");
+  const currentReceipt = await readHydratedWorkspaceReceiptAsync(workspacePath);
+  if (!await workspaceBasisRefsAreCurrentAsync(workspacePath, currentReceipt ?? { version: 3, mounts: [] })) {
+    repairWorkspaceBasisRefs(workspacePath, currentReceipt);
+  }
   if (!currentHead) return;
-  const outerHeadContainsMount = (mount) => tryGit(workspacePath, ["cat-file", "-e", `HEAD:${normalizedWorkspaceMountPath(mount.workspaceRelativePath)}`]);
+  const outerHeadContainsMount = (mount) => tryGitAsync(workspacePath, ["cat-file", "-e", `HEAD:${normalizedWorkspaceMountPath(mount.workspaceRelativePath)}`]);
   const configuredBasisMounts = configuredWorkspaceHydrationBasisMounts(workspacePath, mounts, options.deferMountIds);
   const uncoveredBasisMounts = configuredBasisMounts.filter(
     (mount) => !workspaceHydrationReceiptCoversMount(currentReceipt, currentHead, mount)
@@ -1258,10 +1533,15 @@ function recoverWorkspaceGitHydration(workspacePath, mounts, options = {}) {
     (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({
+  const hydrationTargets = [];
+  for (const mount of idleBasislessMounts) {
+    if (mount.deleteWhenSourceMissing) continue;
+    if (mount.preserveLocalOnHydrationBasisChange === true && currentReceipt?.mounts.find(({ id }) => id === mount.id)?.head === currentHead) {
+      continue;
+    }
+    if (await outerHeadContainsMount(mount) || mount.preserveLocalOnInitialOuterAbsence !== true) hydrationTargets.push(mount);
+  }
+  const hydration = await hydrateWorkspaceGitMountsTransactionally({
     workspacePath,
     mounts: hydrationTargets,
     durabilityMounts: idleBasislessMounts,
@@ -1272,27 +1552,31 @@ function recoverWorkspaceGitHydration(workspacePath, mounts, options = {}) {
   });
   void hydration;
 }
-function resetWorkspaceGit(input) {
+async function resetWorkspaceGit(input) {
   const workspacePath = path.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 });
+  const initial = await ensureWorkspaceGitClone({ ...input, workspacePath });
   recoverPendingHydrationTransaction(workspacePath);
   const status = gitResult(workspacePath, ["status", "--porcelain=v1", "-z"]);
   const discardedPaths = status.exitCode === 0 ? status.stdout.split("\0").filter(Boolean).map((entry) => entry.slice(3)).sort() : [];
-  const remoteHead = fetchWorkspaceHead(workspacePath, input.remoteUrl, input.credentialHelper, input.credentialUsername);
+  const remoteHead = await fetchWorkspaceHead(workspacePath, input.remoteUrl, input.credentialHelper, input.credentialUsername);
   if (remoteHead) {
-    runWorkspaceCheckoutTransition(workspacePath, () => {
-      git(workspacePath, ["checkout", "--no-recurse-submodules", "-B", WORKSPACE_GIT_BRANCH, remoteHead], "reset workspace main");
-      git(workspacePath, ["clean", "-fd", "--", "."], "remove untracked workspace changes");
+    await runWorkspaceCheckoutTransition(workspacePath, async () => {
+      await gitAsync(workspacePath, ["checkout", "--no-recurse-submodules", "-B", WORKSPACE_GIT_BRANCH, remoteHead], "reset workspace main");
+      await gitAsync(workspacePath, ["clean", "-fd", "--", "."], "remove untracked workspace changes");
     });
   } else if (revParse(workspacePath, "HEAD")) {
-    runWorkspaceCheckoutTransition(workspacePath, () => {
-      git(workspacePath, ["rm", "-rf", "--ignore-unmatch", "--", "."], "clear unborn workspace tree");
-      git(workspacePath, ["commit", "--allow-empty", "-m", JSON.stringify({ type: "workspace_reset" })], "record empty workspace reset");
+    await runWorkspaceCheckoutTransition(workspacePath, async () => {
+      await gitAsync(workspacePath, ["rm", "-rf", "--ignore-unmatch", "--", "."], "clear unborn workspace tree");
+      await gitAsync(
+        workspacePath,
+        ["commit", "--allow-empty", "-m", JSON.stringify({ type: "workspace_reset" })],
+        "record empty workspace reset"
+      );
     });
   }
   const selected = activeMounts(input.mounts);
@@ -1309,7 +1593,7 @@ function resetWorkspaceGit(input) {
   const requiredLiveMounts = [
     ...new Map([...requiredLiveMountsBeforeHydration, ...bootstrapMounts].map((mount) => [mount.id, mount])).values()
   ];
-  const hydration = hydrateWorkspaceGitMountsTransactionally({
+  const hydration = await hydrateWorkspaceGitMountsTransactionally({
     workspacePath,
     mounts: hydrationMounts,
     durabilityMounts: [...requiredLiveMounts, ...selected.tombstones, ...durablyAbsentMounts],
@@ -1331,8 +1615,8 @@ function resetWorkspaceGit(input) {
     skippedMountIds: [.../* @__PURE__ */ new Set([...uncoveredSkippedMounts.map(({ id }) => id), ...hydration.skippedMountIds])].sort()
   };
 }
-function stagedPaths(workspacePath) {
-  return git(workspacePath, ["diff", "--cached", "--name-only", "--no-renames", "-z"], "inspect staged workspace paths").split("\0").filter(Boolean).sort();
+async function stagedPaths(workspacePath) {
+  return (await gitAsync(workspacePath, ["diff", "--cached", "--name-only", "--no-renames", "-z"], "inspect staged workspace paths")).split("\0").filter(Boolean).sort();
 }
 function emptyTreeHash(workspacePath) {
   const result = Bun.spawnSync(["git", ...NON_RECURSIVE_GIT_CONFIG, "hash-object", "-t", "tree", "--stdin"], {
@@ -1346,9 +1630,9 @@ function emptyTreeHash(workspacePath) {
     throw new Error(`Create empty workspace tree: ${result.stderr.toString().trim() || `git exited ${result.exitCode}`}`);
   return result.stdout.toString().trim();
 }
-function changedPaths(workspacePath, baseRevision, headRevision) {
+async function changedPaths(workspacePath, baseRevision, headRevision) {
   const base = baseRevision ?? emptyTreeHash(workspacePath);
-  return git(workspacePath, ["diff", "--name-only", "--no-renames", "-z", base, headRevision], "inspect workspace commit paths").split("\0").filter(Boolean).sort();
+  return (await gitAsync(workspacePath, ["diff", "--name-only", "--no-renames", "-z", base, headRevision], "inspect workspace commit paths")).split("\0").filter(Boolean).sort();
 }
 async function diffSizeBytes(workspacePath, baseRevision, headRevision, limit) {
   const base = baseRevision ?? emptyTreeHash(workspacePath);
@@ -1391,15 +1675,15 @@ function snapshotConflict(input) {
   git(input.workspacePath, ["update-ref", refs.remote, input.remoteHead], "snapshot remote workspace conflict head");
   return refs;
 }
-function rebaseWorkspace(input) {
+async function rebaseWorkspace(input) {
   const remoteRevision = `refs/remotes/origin/${WORKSPACE_GIT_BRANCH}`;
   beginWorkspaceCheckoutTransition(input.workspacePath);
-  const rebase = gitResult(
+  const rebase = await gitResultAsync(
     input.workspacePath,
     input.truncatedHistoryBase ? ["rebase", "--onto", remoteRevision, input.truncatedHistoryBase] : ["rebase", remoteRevision]
   );
   if (rebase.exitCode === 0) {
-    completeWorkspaceCheckoutTransition(input.workspacePath);
+    await completeWorkspaceCheckoutTransition(input.workspacePath);
     return { ok: true };
   }
   const conflicts = conflictPaths(input.workspacePath);
@@ -1408,7 +1692,7 @@ function rebaseWorkspace(input) {
   if (abort.exitCode !== 0) {
     throw new Error(`Abort workspace rebase: ${abort.stderr || abort.stdout || `git exited ${abort.exitCode}`}`);
   }
-  completeWorkspaceCheckoutTransition(input.workspacePath);
+  await completeWorkspaceCheckoutTransition(input.workspacePath);
   return {
     ok: false,
     conflictPaths: conflicts,
@@ -1416,13 +1700,13 @@ function rebaseWorkspace(input) {
     error: rebase.stderr || rebase.stdout || `Workspace rebase onto ${input.remoteHead} conflicted`
   };
 }
-function synchronizeWithFetchedHead(input) {
-  const localHead = revParse(input.workspacePath, "HEAD");
+async function synchronizeWithFetchedHead(input) {
+  const localHead = await revParseAsync(input.workspacePath, "HEAD");
   const remoteHead = input.remoteHead;
   if (!remoteHead) return { kind: "ready", updated: false, rebased: false };
   if (!localHead) {
-    runWorkspaceCheckoutTransition(input.workspacePath, () => {
-      git(
+    await runWorkspaceCheckoutTransition(input.workspacePath, async () => {
+      await gitAsync(
         input.workspacePath,
         ["checkout", "--no-recurse-submodules", "-B", WORKSPACE_GIT_BRANCH, `refs/remotes/origin/${WORKSPACE_GIT_BRANCH}`],
         "check out fetched workspace main"
@@ -1431,35 +1715,35 @@ function synchronizeWithFetchedHead(input) {
     return { kind: "ready", updated: true, rebased: false };
   }
   if (localHead === remoteHead) {
-    updateIntegratedWorkspaceHead(input.workspacePath, remoteHead);
+    await updateIntegratedWorkspaceHead(input.workspacePath, remoteHead);
     return { kind: "ready", updated: false, rebased: false };
   }
-  if (tryGit(input.workspacePath, ["merge-base", "--is-ancestor", localHead, remoteHead])) {
-    runWorkspaceCheckoutTransition(input.workspacePath, () => {
-      git(input.workspacePath, ["reset", "--hard", remoteHead], "fast-forward workspace main");
+  if (await tryGitAsync(input.workspacePath, ["merge-base", "--is-ancestor", localHead, remoteHead])) {
+    await runWorkspaceCheckoutTransition(input.workspacePath, async () => {
+      await gitAsync(input.workspacePath, ["reset", "--hard", remoteHead], "fast-forward workspace main");
     });
-    updateIntegratedWorkspaceHead(input.workspacePath, remoteHead);
+    await updateIntegratedWorkspaceHead(input.workspacePath, remoteHead);
     return { kind: "ready", updated: true, rebased: false };
   }
-  if (tryGit(input.workspacePath, ["merge-base", "--is-ancestor", remoteHead, localHead])) {
-    updateIntegratedWorkspaceHead(input.workspacePath, remoteHead);
+  if (await tryGitAsync(input.workspacePath, ["merge-base", "--is-ancestor", remoteHead, localHead])) {
+    await updateIntegratedWorkspaceHead(input.workspacePath, remoteHead);
     return { kind: "ready", updated: false, rebased: false };
   }
-  const integratedHead = revParse(input.workspacePath, WORKSPACE_GIT_INTEGRATED_REF);
+  const integratedHead = await revParseAsync(input.workspacePath, WORKSPACE_GIT_INTEGRATED_REF);
   const truncatedHistoryBase = workspaceIsShallow(input.workspacePath) && integratedHead && tryGit(input.workspacePath, ["merge-base", "--is-ancestor", integratedHead, localHead]) ? integratedHead : void 0;
   if (workspaceIsShallow(input.workspacePath) && !truncatedHistoryBase) {
     throw new Error(
       "Workspace history was truncated before this clone's integrated base could be identified; reset the workspace clone before retrying"
     );
   }
-  const rebased = rebaseWorkspace({
+  const rebased = await rebaseWorkspace({
     workspacePath: input.workspacePath,
     localHead,
     remoteHead,
     attemptId: input.attemptId,
     truncatedHistoryBase
   });
-  if (rebased.ok) updateIntegratedWorkspaceHead(input.workspacePath, remoteHead);
+  if (rebased.ok) await updateIntegratedWorkspaceHead(input.workspacePath, remoteHead);
   return rebased.ok ? { kind: "ready", updated: false, rebased: true } : { kind: "conflict", conflictPaths: rebased.conflictPaths, refs: rebased.refs, error: rebased.error };
 }
 async function synchronizeWorkspaceGit(input) {
@@ -1470,7 +1754,7 @@ async function synchronizeWorkspaceGit(input) {
   validateMounts(workspacePath, input.mounts);
   const requiredAncestorHeads = requiredWorkspaceAncestorHeads(input.requiredAncestorHeads);
   const preserveResolutionInProgress = input.skipMountMirror === true;
-  const initial = ensureWorkspaceGitClone({ ...input, workspacePath, preserveResolutionInProgress });
+  const initial = await ensureWorkspaceGitClone({ ...input, workspacePath, preserveResolutionInProgress });
   assertWorkspaceRemediationAncestry({
     workspacePath,
     currentHead: initial.localHead,
@@ -1479,7 +1763,7 @@ async function synchronizeWorkspaceGit(input) {
   });
   const verifiedAncestorHeads = requiredAncestorHeads.length > 0 ? requiredAncestorHeads : void 0;
   const startingHead = initial.localHead;
-  const receiptBeforeInitialHydration = readHydratedWorkspaceReceipt(workspacePath);
+  const receiptBeforeInitialHydration = await readHydratedWorkspaceReceiptAsync(workspacePath);
   const deferredMountIds = /* @__PURE__ */ new Set();
   if (initial.localHead && initial.remoteHead && initial.remoteHead !== initial.localHead) {
     for (const mount of input.mounts) {
@@ -1488,7 +1772,7 @@ async function synchronizeWorkspaceGit(input) {
       }
     }
   }
-  recoverWorkspaceGitHydration(workspacePath, input.mounts, {
+  await recoverWorkspaceGitHydration(workspacePath, input.mounts, {
     ...deferredMountIds.size > 0 ? { deferMountIds: deferredMountIds } : {},
     preserveResolutionInProgress,
     preserveStaleBases: true
@@ -1499,8 +1783,8 @@ async function synchronizeWorkspaceGit(input) {
   );
   const cycleSkippedMountIds = new Set(selected.skipped.map(({ id }) => id));
   const receiptRequiredLiveMounts = selected.active;
-  const projectionBasisHead = revParse(workspacePath, "HEAD");
-  const projectionBasisReceipt = readHydratedWorkspaceReceipt(workspacePath);
+  const projectionBasisHead = await revParseAsync(workspacePath, "HEAD");
+  const projectionBasisReceipt = await readHydratedWorkspaceReceiptAsync(workspacePath);
   const allProjectionReceiptMounts = configuredWorkspaceHydrationBasisMounts(workspacePath, input.mounts);
   const fastProjectionMounts = [];
   const mergedProjectionTrees = /* @__PURE__ */ new Map();
@@ -1541,6 +1825,10 @@ async function synchronizeWorkspaceGit(input) {
         projectionWarning = mergeSupport.error ?? "Git 2.40 or newer is required for stale workspace mount projection";
         continue;
       }
+      if (cycleSkippedMountIds.has(mount.id) || mount.busy?.()) {
+        cycleSkippedMountIds.add(mount.id);
+        continue;
+      }
       const merged = mergeWorkspaceProjectionMount({
         workspacePath,
         mount: {
@@ -1575,14 +1863,15 @@ async function synchronizeWorkspaceGit(input) {
       }
       mergedProjectionTrees.set(mount.id, merged.resultTree);
       mergedProjectionMounts.push(mount);
+      await yieldToWorkerEventLoop();
     }
   }
   if (projectionWarning) process.stderr.write(`[r5d-worker] ${projectionWarning}
 `);
-  const completedMountSelection = (requireCurrentHeadReceipt = false) => {
-    const currentHeadBeforeHydration = revParse(workspacePath, "HEAD");
+  const completedMountSelection = async (requireCurrentHeadReceipt = false) => {
+    const currentHeadBeforeHydration = await revParseAsync(workspacePath, "HEAD");
     const completionReceiptMounts = configuredWorkspaceHydrationBasisMounts(workspacePath, input.mounts);
-    const currentReceiptBeforeHydration = readHydratedWorkspaceReceipt(workspacePath);
+    const currentReceiptBeforeHydration = await readHydratedWorkspaceReceiptAsync(workspacePath);
     refreshCycleSkippedMounts(completionReceiptMounts);
     const mountIsAlreadyCovered = (mount) => Boolean(
       currentHeadBeforeHydration && workspaceHydrationReceiptCoversMount(currentReceiptBeforeHydration, currentHeadBeforeHydration, mount)
@@ -1599,7 +1888,7 @@ async function synchronizeWorkspaceGit(input) {
     const uncoveredCompletionBasisMounts = completionReceiptMounts.filter(
       (mount) => !cycleSkippedMountIds.has(mount.id) && !projectionSkippedIds.has(mount.id) && !mountIsAlreadyCovered(mount)
     );
-    const hydration = hydrateWorkspaceGitMountsTransactionally({
+    const hydration = await hydrateWorkspaceGitMountsTransactionally({
       workspacePath,
       mounts: uncoveredCompletionMounts,
       durabilityMounts: uncoveredCompletionBasisMounts,
@@ -1610,8 +1899,8 @@ async function synchronizeWorkspaceGit(input) {
     for (const id of hydration.skippedMountIds) cycleSkippedMountIds.add(id);
     refreshCycleSkippedMounts(completionReceiptMounts);
     if (requireCurrentHeadReceipt) {
-      const currentHead = revParse(workspacePath, "HEAD");
-      const receipt = readHydratedWorkspaceReceipt(workspacePath);
+      const currentHead = await revParseAsync(workspacePath, "HEAD");
+      const receipt = await readHydratedWorkspaceReceiptAsync(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)
@@ -1623,17 +1912,17 @@ async function synchronizeWorkspaceGit(input) {
     return classifyMounts([...selected.active, ...selected.tombstones], hydration.skippedMountIds);
   };
   let newlyStagedPaths = [];
-  const stageAndCommitWorkspace = () => {
-    if (workspaceResolutionInProgress(workspacePath) || workspaceHasUnmergedEntries(workspacePath)) {
+  const stageAndCommitWorkspace = async () => {
+    if (workspaceResolutionInProgress(workspacePath) || await 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);
+    await gitAsync(workspacePath, ["add", "-A", "--", "."], "stage workspace working trees");
+    newlyStagedPaths = await stagedPaths(workspacePath);
     if (newlyStagedPaths.length > 0) {
-      if (workspaceResolutionInProgress(workspacePath) || workspaceHasUnmergedEntries(workspacePath)) {
+      if (workspaceResolutionInProgress(workspacePath) || await workspaceHasUnmergedEntries(workspacePath)) {
         throw new Error("Outer workspace clone has an unfinished merge/rebase; finish or abort it before synchronizing");
       }
-      git(
+      await gitAsync(
         workspacePath,
         [
           "commit",
@@ -1644,64 +1933,77 @@ async function synchronizeWorkspaceGit(input) {
       );
     }
   };
+  const projectedFastMounts = [];
   if (!input.skipMountMirror) {
     beginWorkspaceCheckoutTransition(workspacePath);
     try {
       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);
+      for (const mount of fastActiveMounts) {
+        if (cycleSkippedMountIds.has(mount.id) || mount.busy?.()) {
+          cycleSkippedMountIds.add(mount.id);
+          continue;
+        }
+        mirrorMountsToWorkspace(workspacePath, [mount]);
+        projectedFastMounts.push(mount);
+        await yieldToWorkerEventLoop();
+      }
       removeWorkspaceMounts(workspacePath, fastTombstones);
+      projectedFastMounts.push(...fastTombstones);
       for (const mount of mergedProjectionMounts) {
         materializeWorkspaceProjectionTree({
           workspacePath,
           workspaceRelativePath: normalizedWorkspaceMountPath(mount.workspaceRelativePath),
           resultTree: mergedProjectionTrees.get(mount.id)
         });
+        await yieldToWorkerEventLoop();
       }
-      const restoreFromHeadIds = /* @__PURE__ */ new Set([...deferredMountIds, ...selected.skipped.map(({ id }) => id)]);
       restoreDeferredWorkspaceMountsFromHead(
         workspacePath,
-        input.mounts.filter(({ id }) => restoreFromHeadIds.has(id))
+        input.mounts.filter(({ id }) => deferredMountIds.has(id))
       );
-      stageAndCommitWorkspace();
-      fsyncWorkspaceCheckoutTree(workspacePath);
+      await stageAndCommitWorkspace();
+      await fsyncWorkspaceCheckoutTreeYielding(workspacePath);
     } catch (error) {
       throwAfterWorkspaceCheckoutRecovery(workspacePath, error);
     }
   } else {
-    stageAndCommitWorkspace();
-    if (newlyStagedPaths.length > 0) completeWorkspaceCheckoutTransition(workspacePath);
+    await stageAndCommitWorkspace();
+    if (newlyStagedPaths.length > 0) await completeWorkspaceCheckoutTransition(workspacePath);
   }
   if (!input.skipMountMirror) {
-    const projectedHead = revParse(workspacePath, "HEAD");
+    const projectedHead = await revParseAsync(workspacePath, "HEAD");
     if (!projectedHead) throw new Error("Workspace projection did not retain a local HEAD");
     const targetProjectionReceipt = receiptWithMountsAtHead(
       projectionBasisReceipt,
       projectedHead,
-      fastProjectionMounts,
+      projectedFastMounts,
       allProjectionReceiptMounts
     );
-    const currentProjectionReceipt = readHydratedWorkspaceReceipt(workspacePath);
-    if (!workspaceHydrationReceiptsEqual(currentProjectionReceipt, targetProjectionReceipt) || !hydratedWorkspaceReceiptFileIsV3(workspacePath) || !workspaceBasisRefsAreCurrent(workspacePath, targetProjectionReceipt)) {
-      fsyncHydratedWorkspaceMounts(fastProjectionMounts);
-      updateHydratedWorkspaceReceipt(workspacePath, targetProjectionReceipt);
+    const currentProjectionReceipt = await readHydratedWorkspaceReceiptAsync(workspacePath);
+    if (!workspaceHydrationReceiptsEqual(currentProjectionReceipt, targetProjectionReceipt) || !hydratedWorkspaceReceiptFileIsV3(workspacePath) || !await workspaceBasisRefsAreCurrentAsync(workspacePath, targetProjectionReceipt)) {
+      for (const mount of projectedFastMounts) {
+        fsyncHydratedWorkspaceMount(mount);
+        await yieldToWorkerEventLoop();
+      }
+      await updateHydratedWorkspaceReceiptAsync(workspacePath, targetProjectionReceipt);
     }
-    completeWorkspaceCheckoutTransition(workspacePath);
+    await completeWorkspaceCheckoutTransition(workspacePath);
   }
-  let remoteHead = fetchWorkspaceHead(workspacePath, input.remoteUrl, input.credentialHelper, input.credentialUsername);
+  let remoteHead = await fetchWorkspaceHead(workspacePath, input.remoteUrl, input.credentialHelper, input.credentialUsername);
   let rebaseCount = 0;
   let updated = false;
   for (let pushAttempt = 0; pushAttempt < maxPushAttempts; pushAttempt += 1) {
     assertWorkspaceRemediationAncestry({
       workspacePath,
-      currentHead: revParse(workspacePath, "HEAD"),
+      currentHead: await revParseAsync(workspacePath, "HEAD"),
       remoteHead,
       requiredAncestorHeads
     });
-    const reconciled = synchronizeWithFetchedHead({ workspacePath, remoteHead, attemptId });
+    const reconciled = await synchronizeWithFetchedHead({ workspacePath, remoteHead, attemptId });
     if (reconciled.kind === "conflict") {
-      const localHead2 = revParse(workspacePath, "HEAD");
+      const localHead2 = await revParseAsync(workspacePath, "HEAD");
       const classifiedMounts = classifyMounts([...fastProjectionMounts, ...mergedProjectionMounts], deferredMountIds);
       return {
         outcome: "conflict_blocked",
@@ -1722,8 +2024,8 @@ async function synchronizeWorkspaceGit(input) {
     }
     updated ||= reconciled.updated;
     if (reconciled.rebased) rebaseCount += 1;
-    if (reconciled.updated || reconciled.rebased) completedMountSelection(true);
-    const localHead = revParse(workspacePath, "HEAD");
+    if (reconciled.updated || reconciled.rebased) await completedMountSelection(true);
+    const localHead = await revParseAsync(workspacePath, "HEAD");
     if (!localHead) {
       const classifiedMounts = classifyMounts([...selected.active, ...selected.tombstones], deferredMountIds);
       return {
@@ -1740,7 +2042,7 @@ async function synchronizeWorkspaceGit(input) {
         ...projectionWarning ? { error: projectionWarning } : {}
       };
     }
-    const paths = changedPaths(workspacePath, remoteHead, localHead);
+    const paths = await changedPaths(workspacePath, remoteHead, localHead);
     const size = paths.length > 0 ? await (input.measureDiffSize ?? diffSizeBytes)(workspacePath, remoteHead, localHead, maxDiffBytes) : 0;
     input.assertStillAdmitted?.();
     if (paths.length > 0 && size > maxDiffBytes && !input.allowLargeDiff) {
@@ -1761,7 +2063,7 @@ async function synchronizeWorkspaceGit(input) {
     }
     if (localHead === remoteHead) {
       assertWorkspaceRemediationAncestry({ workspacePath, currentHead: localHead, remoteHead, requiredAncestorHeads });
-      const completedMounts = completedMountSelection(Boolean(input.skipMountMirror));
+      const completedMounts = await completedMountSelection(Boolean(input.skipMountMirror));
       await input.afterWorkspacePublished?.({
         publishedHead: localHead,
         activeMountIds: completedMounts.activeMountIds
@@ -1789,11 +2091,11 @@ async function synchronizeWorkspaceGit(input) {
     ];
     if (input.allowLargeDiff) pushArgs.push(`--push-option=${WORKSPACE_GIT_CONFIRMED_LARGE_DIFF_PUSH_OPTION}`);
     pushArgs.push("origin", `HEAD:refs/heads/${WORKSPACE_GIT_BRANCH}`);
-    const push = gitResult(workspacePath, pushArgs);
+    const push = await gitResultAsync(workspacePath, pushArgs);
     if (push.exitCode === 0) {
       assertWorkspaceRemediationAncestry({ workspacePath, currentHead: localHead, remoteHead, requiredAncestorHeads });
-      updateIntegratedWorkspaceHead(workspacePath, localHead);
-      const completedMounts = completedMountSelection(Boolean(input.skipMountMirror));
+      await updateIntegratedWorkspaceHead(workspacePath, localHead);
+      const completedMounts = await completedMountSelection(Boolean(input.skipMountMirror));
       await input.afterWorkspacePublished?.({
         publishedHead: localHead,
         activeMountIds: completedMounts.activeMountIds
@@ -1817,7 +2119,7 @@ async function synchronizeWorkspaceGit(input) {
 ${push.stdout}`)) {
       throw new Error(`Push workspace main: ${push.stderr || push.stdout || `git exited ${push.exitCode}`}`);
     }
-    remoteHead = fetchWorkspaceHead(workspacePath, input.remoteUrl, input.credentialHelper, input.credentialUsername);
+    remoteHead = await fetchWorkspaceHead(workspacePath, input.remoteUrl, input.credentialHelper, input.credentialUsername);
   }
   throw new Error(`Workspace push did not converge after ${maxPushAttempts} attempts`);
 }