@ricsam/r5d-worker 0.0.83 → 0.0.87

package/dist/mjs/package.json

@@ -1,5 +1,5 @@
 {
   "name": "@ricsam/r5d-worker",
-  "version": "0.0.83",
+  "version": "0.0.87",
   "type": "module"
 }

package/dist/mjs/project-worktrees.mjs

@@ -80,6 +80,29 @@ function git(cwd, args, action) {
 function tryGit(cwd, args) {
   return gitResult(cwd, args).exitCode === 0;
 }
+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;
+}
 function branchPath(projectRoot, branchName) {
   validateManagedBranchName(branchName);
   const result = path.join(projectRoot, ...branchName.split("/"));
@@ -139,6 +162,10 @@ function commonGitDirectory(checkoutPath) {
   const result = gitResult(checkoutPath, ["rev-parse", "--path-format=absolute", "--git-common-dir"]);
   return result.exitCode === 0 ? path.resolve(result.stdout) : null;
 }
+async function commonGitDirectoryAsync(checkoutPath) {
+  const result = await gitResultAsync(checkoutPath, ["rev-parse", "--path-format=absolute", "--git-common-dir"]);
+  return result.exitCode === 0 ? path.resolve(result.stdout) : null;
+}
 function hasLinkedProjectWorktreeLayout(input) {
   const primaryPath = branchPath(input.projectRoot, input.primaryBranchName);
   if (gitDirectoryKind(primaryPath) !== "directory") return false;
@@ -150,17 +177,19 @@ function hasLinkedProjectWorktreeLayout(input) {
     return gitDirectoryKind(checkoutPath) === "file" && commonGitDirectory(checkoutPath) === primaryCommonDir;
   });
 }
-function hasCompatibleLinkedProjectWorktreeLayout(input) {
+async function hasCompatibleLinkedProjectWorktreeLayout(input) {
   const primaryPath = branchPath(input.projectRoot, input.primaryBranchName);
   if (gitDirectoryKind(primaryPath) !== "directory") return false;
-  const primaryCommonDir = commonGitDirectory(primaryPath);
+  const primaryCommonDir = await commonGitDirectoryAsync(primaryPath);
   if (!primaryCommonDir) return false;
-  return input.branches.every(({ branchName }) => {
-    if (branchName === input.primaryBranchName) return true;
+  for (const { branchName } of input.branches) {
+    if (branchName === input.primaryBranchName) continue;
     const checkoutPath = branchPath(input.projectRoot, branchName);
     const kind = gitDirectoryKind(checkoutPath);
-    return kind === null || kind === "file" && commonGitDirectory(checkoutPath) === primaryCommonDir;
-  });
+    if (kind === null) continue;
+    if (kind !== "file" || await commonGitDirectoryAsync(checkoutPath) !== primaryCommonDir) return false;
+  }
+  return true;
 }
 function fsyncDirectory(directory) {
   const descriptor = fs.openSync(directory, "r");
@@ -574,24 +603,34 @@ function configureProjectBranchTracking(checkoutPath, branchName, originBranchNa
     `configure upstream branch for ${branchName}`
   );
 }
-function configureRepository(input) {
-  if (tryGit(input.primaryPath, ["remote", "get-url", "origin"])) {
-    git(input.primaryPath, ["remote", "set-url", "origin", input.originUrl], "configure project origin");
+async function configureProjectBranchTrackingAsync(checkoutPath, branchName, originBranchName) {
+  validateManagedBranchName(branchName);
+  validateManagedBranchName(originBranchName);
+  await gitAsync(checkoutPath, ["config", "--local", `branch.${branchName}.remote`, "origin"], `configure origin for ${branchName}`);
+  await gitAsync(
+    checkoutPath,
+    ["config", "--local", `branch.${branchName}.merge`, `refs/heads/${originBranchName}`],
+    `configure upstream branch for ${branchName}`
+  );
+}
+async function configureRepository(input) {
+  if (await tryGitAsync(input.primaryPath, ["remote", "get-url", "origin"])) {
+    await gitAsync(input.primaryPath, ["remote", "set-url", "origin", input.originUrl], "configure project origin");
   } else {
-    git(input.primaryPath, ["remote", "add", "origin", input.originUrl], "configure project origin");
+    await gitAsync(input.primaryPath, ["remote", "add", "origin", input.originUrl], "configure project origin");
   }
-  tryGit(input.primaryPath, ["config", "--local", "--unset-all", "remote.origin.pushurl"]);
-  git(input.primaryPath, ["config", "--local", "--replace-all", "credential.helper", ""], "reset project credential helpers");
-  git(input.primaryPath, ["config", "--local", "credential.useHttpPath", "false"], "configure project credential path matching");
+  await tryGitAsync(input.primaryPath, ["config", "--local", "--unset-all", "remote.origin.pushurl"]);
+  await gitAsync(input.primaryPath, ["config", "--local", "--replace-all", "credential.helper", ""], "reset project credential helpers");
+  await gitAsync(input.primaryPath, ["config", "--local", "credential.useHttpPath", "false"], "configure project credential path matching");
   if (input.originCredentialUsername) {
-    git(
+    await gitAsync(
       input.primaryPath,
       ["config", "--local", "--replace-all", gitCredentialUsernameConfigKey(input.originUrl), input.originCredentialUsername],
       "configure project credential username"
     );
   }
   if (input.credentialHelper) {
-    git(
+    await gitAsync(
       input.primaryPath,
       ["config", "--local", "--add", "credential.helper", input.credentialHelper],
       "configure project credential helper"
@@ -601,23 +640,23 @@ function configureRepository(input) {
     const name = input.gitIdentity.name.trim();
     const email = input.gitIdentity.email.trim();
     if (!name || !email) throw new Error("Git identity must include name and email");
-    git(input.primaryPath, ["config", "--local", "user.name", name], "configure project Git user name");
-    git(input.primaryPath, ["config", "--local", "user.email", email], "configure project Git user email");
+    await gitAsync(input.primaryPath, ["config", "--local", "user.name", name], "configure project Git user name");
+    await gitAsync(input.primaryPath, ["config", "--local", "user.email", email], "configure project Git user email");
   }
   if (input.primaryBranchName && input.defaultBranch && input.branches) {
-    git(input.primaryPath, ["config", "--local", "push.default", "upstream"], "configure project push mapping");
+    await gitAsync(input.primaryPath, ["config", "--local", "push.default", "upstream"], "configure project push mapping");
     for (const { branchName } of input.branches) {
       const originBranchName = projectOriginBranchName({
         branchName,
         primaryBranchName: input.primaryBranchName,
         defaultBranch: input.defaultBranch
       });
-      configureProjectBranchTracking(input.primaryPath, branchName, originBranchName);
+      await configureProjectBranchTrackingAsync(input.primaryPath, branchName, originBranchName);
     }
   }
 }
-function fetchProjectHeads(input) {
-  const originFetch = gitResult(input.primaryPath, [
+async function fetchProjectHeads(input) {
+  const originFetch = await gitResultAsync(input.primaryPath, [
     ...gitTransportSecurityArgs(input.originUrl, input.credentialHelper, input.originCredentialUsername),
     "fetch",
     "--no-recurse-submodules",
@@ -628,7 +667,7 @@ function fetchProjectHeads(input) {
   if (originFetch.exitCode !== 0) {
     throw new Error(`Fetch project origin: ${originFetch.stderr || originFetch.stdout || `git exited ${originFetch.exitCode}`}`);
   }
-  const mirrorFetch = gitResult(input.primaryPath, [
+  const mirrorFetch = await gitResultAsync(input.primaryPath, [
     ...gitTransportSecurityArgs(input.mirrorUrl, input.credentialHelper, input.mirrorCredentialUsername),
     "fetch",
     "--no-recurse-submodules",
@@ -643,13 +682,13 @@ ${mirrorFetch.stdout}`
     throw new Error(`Fetch project head mirror: ${mirrorFetch.stderr || mirrorFetch.stdout || `git exited ${mirrorFetch.exitCode}`}`);
   }
 }
-function ensureCommitAvailable(input) {
-  if (tryGit(input.primaryPath, ["cat-file", "-e", `${input.commitHash}^{commit}`])) return;
+async function ensureCommitAvailable(input) {
+  if (await tryGitAsync(input.primaryPath, ["cat-file", "-e", `${input.commitHash}^{commit}`])) return;
   for (const [url, username] of [
     [input.mirrorUrl, input.mirrorCredentialUsername],
     [input.originUrl, input.originCredentialUsername]
   ]) {
-    if (tryGit(input.primaryPath, [
+    if (await tryGitAsync(input.primaryPath, [
       ...gitTransportSecurityArgs(url, input.credentialHelper, username),
       "fetch",
       "--no-recurse-submodules",
@@ -661,34 +700,34 @@ function ensureCommitAvailable(input) {
   }
   throw new Error(`Project base commit ${input.commitHash} is unavailable from origin and the canonical mirror`);
 }
-function seedForBranch(input) {
+async function seedForBranch(input) {
   const mirrorRef = `refs/r5d/mirror/${input.branch.branchName}`;
-  const mirrorHead = tryGit(input.primaryPath, ["show-ref", "--verify", "--quiet", mirrorRef]) ? git(input.primaryPath, ["rev-parse", mirrorRef], "resolve project mirror head") : null;
+  const mirrorHead = await tryGitAsync(input.primaryPath, ["show-ref", "--verify", "--quiet", mirrorRef]) ? await gitAsync(input.primaryPath, ["rev-parse", mirrorRef], "resolve project mirror head") : null;
   if (input.requireMirrorHead && !mirrorHead) {
     throw new Error(`Exact hidden project mirror head is missing for ${input.branch.branchName}`);
   }
   const seed = mirrorHead ?? input.branch.baseCommitHash;
-  ensureCommitAvailable({ ...input, commitHash: seed });
+  await ensureCommitAvailable({ ...input, commitHash: seed });
   return { seed, mirrorHead };
 }
-function preserveHead(checkoutPath) {
-  if (!tryGit(checkoutPath, ["rev-parse", "--verify", "HEAD"])) return;
-  const head = git(checkoutPath, ["rev-parse", "HEAD"], "read pre-reconciliation project head");
-  git(checkoutPath, ["update-ref", `refs/r5d/pre-connect/${head}`, head], "preserve pre-reconciliation project head");
+async function preserveHead(checkoutPath) {
+  if (!await tryGitAsync(checkoutPath, ["rev-parse", "--verify", "HEAD"])) return;
+  const head = await gitAsync(checkoutPath, ["rev-parse", "HEAD"], "read pre-reconciliation project head");
+  await gitAsync(checkoutPath, ["update-ref", `refs/r5d/pre-connect/${head}`, head], "preserve pre-reconciliation project head");
 }
-function initializeLinkedLayout(input) {
+async function initializeLinkedLayout(input) {
   for (const { branchName } of [...input.branches].sort((left, right) => right.branchName.length - left.branchName.length)) {
     fs.rmSync(branchPath(input.projectRoot, branchName), { recursive: true, force: true });
   }
   const primaryPath = branchPath(input.projectRoot, input.primaryBranchName);
   fs.mkdirSync(path.dirname(primaryPath), { recursive: true });
-  git(void 0, ["init", `--initial-branch=${input.primaryBranchName}`, primaryPath], "initialize primary project clone");
-  configureRepository({ ...input, primaryPath });
-  fetchProjectHeads({ ...input, primaryPath });
+  await gitAsync(void 0, ["init", `--initial-branch=${input.primaryBranchName}`, primaryPath], "initialize primary project clone");
+  await configureRepository({ ...input, primaryPath });
+  await fetchProjectHeads({ ...input, primaryPath });
   const seeds = /* @__PURE__ */ new Map();
   const mirrorHeads = /* @__PURE__ */ new Map();
   for (const branch of input.branches) {
-    const resolved = seedForBranch({
+    const resolved = await seedForBranch({
       ...input,
       primaryPath,
       branch,
@@ -697,63 +736,71 @@ function initializeLinkedLayout(input) {
     seeds.set(branch.branchName, resolved.seed);
     mirrorHeads.set(branch.branchName, resolved.mirrorHead);
   }
-  git(
+  await gitAsync(
     primaryPath,
     ["checkout", "--no-recurse-submodules", "-B", input.primaryBranchName, seeds.get(input.primaryBranchName)],
     "anchor primary project worktree"
   );
   for (const branch of input.branches) {
     if (branch.branchName === input.primaryBranchName) continue;
-    git(primaryPath, ["branch", "-f", branch.branchName, seeds.get(branch.branchName)], `anchor project branch ${branch.branchName}`);
+    await gitAsync(
+      primaryPath,
+      ["branch", "-f", branch.branchName, seeds.get(branch.branchName)],
+      `anchor project branch ${branch.branchName}`
+    );
     const checkoutPath = branchPath(input.projectRoot, branch.branchName);
     fs.mkdirSync(path.dirname(checkoutPath), { recursive: true });
-    git(primaryPath, ["worktree", "add", "--force", checkoutPath, branch.branchName], `create linked worktree ${branch.branchName}`);
+    await gitAsync(primaryPath, ["worktree", "add", "--force", checkoutPath, branch.branchName], `create linked worktree ${branch.branchName}`);
   }
   return mirrorHeads;
 }
-function reconcileLinkedLayout(input) {
+async function reconcileLinkedLayout(input) {
   const primaryPath = branchPath(input.projectRoot, input.primaryBranchName);
-  configureRepository({ ...input, primaryPath });
-  tryGit(primaryPath, ["worktree", "prune"]);
-  fetchProjectHeads({ ...input, primaryPath });
+  await configureRepository({ ...input, primaryPath });
+  await tryGitAsync(primaryPath, ["worktree", "prune"]);
+  await fetchProjectHeads({ ...input, primaryPath });
   const mirrorHeads = /* @__PURE__ */ new Map();
   const mutatedBranches = /* @__PURE__ */ new Set();
   for (const branch of input.branches) {
     const checkoutPath = branchPath(input.projectRoot, branch.branchName);
-    const resolved = seedForBranch({
+    const resolved = await seedForBranch({
       ...input,
       primaryPath,
       branch,
       requireMirrorHead: input.exactMirrorBranches?.has(branch.branchName)
     });
     mirrorHeads.set(branch.branchName, resolved.mirrorHead);
-    if (branch.branchName === input.primaryBranchName || commonGitDirectory(checkoutPath) === commonGitDirectory(primaryPath)) {
-      const currentHead = git(checkoutPath, ["rev-parse", "HEAD"], `resolve linked worktree head ${branch.branchName}`);
+    if (branch.branchName === input.primaryBranchName || await commonGitDirectoryAsync(checkoutPath) === await commonGitDirectoryAsync(primaryPath)) {
+      const currentHead = await gitAsync(checkoutPath, ["rev-parse", "HEAD"], `resolve linked worktree head ${branch.branchName}`);
       if (currentHead === resolved.seed) continue;
       input.beforeDestructiveMutation();
       mutatedBranches.add(branch.branchName);
-      preserveHead(checkoutPath);
-      git(checkoutPath, ["reset", "--hard", resolved.seed], `anchor linked worktree ${branch.branchName}`);
+      await preserveHead(checkoutPath);
+      await gitAsync(checkoutPath, ["reset", "--hard", resolved.seed], `anchor linked worktree ${branch.branchName}`);
       continue;
     }
     input.beforeDestructiveMutation();
     mutatedBranches.add(branch.branchName);
     fs.rmSync(checkoutPath, { recursive: true, force: true });
-    git(primaryPath, ["branch", "-f", branch.branchName, resolved.seed], `anchor project branch ${branch.branchName}`);
+    await gitAsync(primaryPath, ["branch", "-f", branch.branchName, resolved.seed], `anchor project branch ${branch.branchName}`);
     fs.mkdirSync(path.dirname(checkoutPath), { recursive: true });
-    git(primaryPath, ["worktree", "add", "--force", checkoutPath, branch.branchName], `create linked worktree ${branch.branchName}`);
+    await gitAsync(primaryPath, ["worktree", "add", "--force", checkoutPath, branch.branchName], `create linked worktree ${branch.branchName}`);
   }
   return { mirrorHeads, mutatedBranches };
 }
-function aheadBehind(checkoutPath, branchName, primaryBranchName, defaultBranch) {
+async function aheadBehind(checkoutPath, branchName, primaryBranchName, defaultBranch) {
   const originBranchName = projectOriginBranchName({ branchName, primaryBranchName, defaultBranch });
   const originRef = `refs/remotes/origin/${originBranchName}`;
-  if (!tryGit(checkoutPath, ["show-ref", "--verify", "--quiet", originRef])) return { ahead: null, behind: null };
-  const output = git(checkoutPath, ["rev-list", "--left-right", "--count", `${originRef}...HEAD`], "measure project origin divergence");
+  if (!await tryGitAsync(checkoutPath, ["show-ref", "--verify", "--quiet", originRef])) return { ahead: null, behind: null };
+  const output = await gitAsync(
+    checkoutPath,
+    ["rev-list", "--left-right", "--count", `${originRef}...HEAD`],
+    "measure project origin divergence"
+  );
   const [behind, ahead] = output.split(/\s+/).map(Number);
   return Number.isFinite(ahead) && Number.isFinite(behind) ? { ahead, behind } : { ahead: null, behind: null };
 }
-function ensureProjectWorktrees(input) {
+async function ensureProjectWorktrees(input) {
   const projectRoot = path.resolve(input.projectRoot);
   const defaultBranch = input.defaultBranch ?? input.primaryBranchName;
   assertNonOverlappingBranches(input.branches);
@@ -769,7 +816,7 @@ function ensureProjectWorktrees(input) {
   };
   try {
     fs.mkdirSync(projectRoot, { recursive: true });
-    const linked = hasCompatibleLinkedProjectWorktreeLayout({
+    const linked = await hasCompatibleLinkedProjectWorktreeLayout({
       projectRoot,
       primaryBranchName: input.primaryBranchName,
       branches: input.branches
@@ -777,7 +824,7 @@ function ensureProjectWorktrees(input) {
     let mirrorHeads;
     let mutatedBranches;
     if (linked) {
-      ({ mirrorHeads, mutatedBranches } = reconcileLinkedLayout({
+      ({ mirrorHeads, mutatedBranches } = await reconcileLinkedLayout({
         ...input,
         projectRoot,
         defaultBranch,
@@ -785,7 +832,7 @@ function ensureProjectWorktrees(input) {
       }));
     } else {
       ensureSnapshot();
-      mirrorHeads = initializeLinkedLayout({ ...input, projectRoot, defaultBranch });
+      mirrorHeads = await initializeLinkedLayout({ ...input, projectRoot, defaultBranch });
       mutatedBranches = new Set(input.branches.map(({ branchName }) => branchName));
     }
     const preparedSnapshot = snapshot;
@@ -803,17 +850,19 @@ function ensureProjectWorktrees(input) {
         deletionMode: "git"
       });
     }
-    const states = input.branches.map((branch) => {
+    const states = [];
+    for (const branch of input.branches) {
       const checkoutPath = branchPath(projectRoot, branch.branchName);
-      const divergence = aheadBehind(checkoutPath, branch.branchName, input.primaryBranchName, defaultBranch);
-      return {
+      const divergence = await aheadBehind(checkoutPath, branch.branchName, input.primaryBranchName, defaultBranch);
+      states.push({
         branchName: branch.branchName,
         branchPath: checkoutPath,
-        head: git(checkoutPath, ["rev-parse", "HEAD"], `resolve project head ${branch.branchName}`),
+        head: await gitAsync(checkoutPath, ["rev-parse", "HEAD"], `resolve project head ${branch.branchName}`),
         mirrorHead: mirrorHeads.get(branch.branchName) ?? null,
         ...divergence
-      };
-    }).sort((left, right) => left.branchName.localeCompare(right.branchName));
+      });
+    }
+    states.sort((left, right) => left.branchName.localeCompare(right.branchName));
     if (snapshot) persistReconciledProjectAndConsumeSnapshot(snapshot);
     return states;
   } catch (error) {
@@ -829,14 +878,31 @@ function ensureProjectWorktrees(input) {
     throw error;
   }
 }
+const WORKTREE_OPERATION_STATE_PATHS = ["MERGE_HEAD", "CHERRY_PICK_HEAD", "REVERT_HEAD", "rebase-merge", "rebase-apply", "sequencer"];
+function perWorktreeGitDirectory(checkoutPath) {
+  const gitPath = path.join(checkoutPath, ".git");
+  let stat;
+  try {
+    stat = fs.lstatSync(gitPath);
+  } catch {
+    return null;
+  }
+  if (stat.isDirectory()) return gitPath;
+  if (!stat.isFile()) return null;
+  let pointer;
+  try {
+    pointer = fs.readFileSync(gitPath, "utf8");
+  } catch {
+    return null;
+  }
+  const match = /^gitdir:[ \t]*(.+?)[ \t\r\n]*$/m.exec(pointer);
+  if (!match?.[1]) return null;
+  return path.resolve(checkoutPath, match[1]);
+}
 function projectWorktreeOperationInProgress(checkoutPath) {
-  const gitPaths = ["MERGE_HEAD", "CHERRY_PICK_HEAD", "REVERT_HEAD", "rebase-merge", "rebase-apply", "sequencer"];
-  return gitPaths.some((gitPath) => {
-    const result = gitResult(checkoutPath, ["rev-parse", "--git-path", gitPath]);
-    if (result.exitCode !== 0) return false;
-    const resolved = path.isAbsolute(result.stdout) ? result.stdout : path.resolve(checkoutPath, result.stdout);
-    return fs.existsSync(resolved);
-  });
+  const gitDirectory = perWorktreeGitDirectory(checkoutPath);
+  if (!gitDirectory) return false;
+  return WORKTREE_OPERATION_STATE_PATHS.some((statePath) => fs.existsSync(path.join(gitDirectory, statePath)));
 }
 function createLinkedProjectBranch(input) {
   validateManagedBranchName(input.sourceBranchName);
@@ -977,9 +1043,9 @@ function removeProjectWorktrees(input) {
   }
   fs.rmSync(projectRoot, { recursive: true, force: true });
 }
-function deleteProjectMirrorBranch(input) {
+async function deleteProjectMirrorBranch(input) {
   validateManagedBranchName(input.branchName);
-  const deleted = gitResult(input.gitDirectory, [
+  const deleted = await gitResultAsync(input.gitDirectory, [
     ...gitTransportSecurityArgs(input.mirrorUrl, input.credentialHelper, input.credentialUsername),
     "push",
     "--no-recurse-submodules",
@@ -993,23 +1059,23 @@ ${deleted.stdout}`)) {
     );
   }
 }
-function pushProjectMirrorHeads(input) {
+async function pushProjectMirrorHeads(input) {
   const results = [];
   for (const branchName of [...input.branchNames].sort()) {
     if (input.onlyBranches && !input.onlyBranches.has(branchName)) continue;
     const checkoutPath = branchPath(input.projectRoot, branchName);
-    const head = input.publicationHeads ? input.publicationHeads.get(branchName) : git(checkoutPath, ["rev-parse", "HEAD"], `resolve mirror head for ${branchName}`);
+    const head = input.publicationHeads ? input.publicationHeads.get(branchName) : await gitAsync(checkoutPath, ["rev-parse", "HEAD"], `resolve mirror head for ${branchName}`);
     if (!head || !/^[0-9a-f]{40}(?:[0-9a-f]{24})?$/.test(head)) {
       throw new Error(`Missing exact publication head for project branch ${branchName}`);
     }
-    if (!tryGit(checkoutPath, ["cat-file", "-e", `${head}^{commit}`])) {
+    if (!await tryGitAsync(checkoutPath, ["cat-file", "-e", `${head}^{commit}`])) {
       throw new Error(`Exact publication head ${head} is unavailable for project branch ${branchName}`);
     }
     if (projectWorktreeOperationInProgress(checkoutPath)) {
       results.push({ branchName, head, pushed: false, reason: "git_operation_in_progress" });
       continue;
     }
-    git(
+    await gitAsync(
       checkoutPath,
       [
         ...gitTransportSecurityArgs(input.mirrorUrl, input.credentialHelper, input.credentialUsername),
@@ -1030,9 +1096,9 @@ function assertProjectMirrorHeadsPushed(results) {
     throw new Error(`Hidden project mirror publication skipped ${skipped.branchName}${skipped.reason ? ` (${skipped.reason})` : ""}`);
   }
 }
-function observeProjectMirrorHeads(input) {
+async function observeProjectMirrorHeads(input) {
   const primaryPath = branchPath(input.projectRoot, input.primaryBranchName);
-  const fetch = gitResult(primaryPath, [
+  const fetch = await gitResultAsync(primaryPath, [
     ...gitTransportSecurityArgs(input.mirrorUrl, input.credentialHelper, input.credentialUsername),
     "fetch",
     "--no-recurse-submodules",
@@ -1042,50 +1108,63 @@ function observeProjectMirrorHeads(input) {
   ]);
   if (fetch.exitCode !== 0)
     throw new Error(`Refresh project head mirror: ${fetch.stderr || fetch.stdout || `git exited ${fetch.exitCode}`}`);
-  return [...input.branchNames].sort().map((branchName) => {
+  const observations = [];
+  for (const branchName of [...input.branchNames].sort()) {
     const checkoutPath = branchPath(input.projectRoot, branchName);
-    const previousHead = git(checkoutPath, ["rev-parse", "HEAD"], `resolve local project head ${branchName}`);
+    const previousHead = await gitAsync(checkoutPath, ["rev-parse", "HEAD"], `resolve local project head ${branchName}`);
     const mirrorRef = `refs/r5d/mirror/${branchName}`;
-    const mirrorHead = tryGit(primaryPath, ["show-ref", "--verify", "--quiet", mirrorRef]) ? git(primaryPath, ["rev-parse", mirrorRef], `resolve refreshed mirror head ${branchName}`) : null;
+    const mirrorHead = await tryGitAsync(primaryPath, ["show-ref", "--verify", "--quiet", mirrorRef]) ? await gitAsync(primaryPath, ["rev-parse", mirrorRef], `resolve refreshed mirror head ${branchName}`) : null;
     const shouldMove = Boolean(
-      mirrorHead && mirrorHead !== previousHead && (input.allowNonFastForward || tryGit(checkoutPath, ["merge-base", "--is-ancestor", previousHead, mirrorHead]))
+      mirrorHead && mirrorHead !== previousHead && (input.allowNonFastForward || await tryGitAsync(checkoutPath, ["merge-base", "--is-ancestor", previousHead, mirrorHead]))
     );
-    return {
+    observations.push({
       branchName,
       previousHead,
       mirrorHead,
       mode: input.allowNonFastForward ? "reseed" : "fast_forward",
       shouldMove
-    };
-  });
+    });
+  }
+  return observations;
 }
-function applyObservedProjectMirrorHeads(input) {
-  return [...input.observations].sort((left, right) => left.branchName.localeCompare(right.branchName)).map((observation) => {
+async function applyObservedProjectMirrorHeads(input) {
+  const results = [];
+  for (const observation of [...input.observations].sort((left, right) => left.branchName.localeCompare(right.branchName))) {
     const { branchName, mirrorHead } = observation;
     const checkoutPath = branchPath(input.projectRoot, branchName);
-    const currentHead = git(checkoutPath, ["rev-parse", "HEAD"], `resolve local project head ${branchName}`);
+    const currentHead = await gitAsync(checkoutPath, ["rev-parse", "HEAD"], `resolve local project head ${branchName}`);
     if (!observation.shouldMove || !mirrorHead || currentHead === mirrorHead || currentHead !== observation.previousHead) {
-      return { branchName, previousHead: currentHead, mirrorHead, moved: false };
+      results.push({ branchName, previousHead: currentHead, mirrorHead, moved: false });
+      continue;
     }
-    if (!tryGit(checkoutPath, ["cat-file", "-e", `${mirrorHead}^{commit}`])) {
+    if (!await tryGitAsync(checkoutPath, ["cat-file", "-e", `${mirrorHead}^{commit}`])) {
       throw new Error(`Observed hidden mirror head is no longer available for ${branchName}: ${mirrorHead}`);
     }
     const mutationAllowed = () => !projectWorktreeOperationInProgress(checkoutPath) && input.branchMutationAllowed?.(branchName, checkoutPath) !== false;
     if (!mutationAllowed()) {
-      return { branchName, previousHead: currentHead, mirrorHead, moved: false };
+      results.push({ branchName, previousHead: currentHead, mirrorHead, moved: false });
+      continue;
     }
     if (observation.mode === "reseed") {
-      preserveHead(checkoutPath);
-      if (!mutationAllowed()) return { branchName, previousHead: currentHead, mirrorHead, moved: false };
+      await preserveHead(checkoutPath);
+      if (!mutationAllowed()) {
+        results.push({ branchName, previousHead: currentHead, mirrorHead, moved: false });
+        continue;
+      }
     }
     const action = observation.mode === "reseed" ? "reseed" : "fast-forward";
-    git(checkoutPath, ["read-tree", "--reset", mirrorHead], `${action} project index ${branchName}`);
-    git(checkoutPath, ["update-ref", `refs/heads/${branchName}`, mirrorHead, currentHead], `${action} project branch ${branchName}`);
-    return { branchName, previousHead: currentHead, mirrorHead, moved: true };
-  });
+    await gitAsync(checkoutPath, ["read-tree", "--reset", mirrorHead], `${action} project index ${branchName}`);
+    await gitAsync(
+      checkoutPath,
+      ["update-ref", `refs/heads/${branchName}`, mirrorHead, currentHead],
+      `${action} project branch ${branchName}`
+    );
+    results.push({ branchName, previousHead: currentHead, mirrorHead, moved: true });
+  }
+  return results;
 }
-function updateProjectHeadsFromMirror(input) {
-  const observations = observeProjectMirrorHeads(input);
+async function updateProjectHeadsFromMirror(input) {
+  const observations = await observeProjectMirrorHeads(input);
   return applyObservedProjectMirrorHeads({
     projectRoot: input.projectRoot,
     primaryBranchName: input.primaryBranchName,
@@ -1093,14 +1172,14 @@ function updateProjectHeadsFromMirror(input) {
     branchMutationAllowed: input.branchMutationAllowed
   });
 }
-function fastForwardProjectHeadsFromMirror(input) {
-  return updateProjectHeadsFromMirror({ ...input, allowNonFastForward: false }).map(({ moved, ...state }) => ({
+async function fastForwardProjectHeadsFromMirror(input) {
+  return (await updateProjectHeadsFromMirror({ ...input, allowNonFastForward: false })).map(({ moved, ...state }) => ({
     ...state,
     fastForwarded: moved
   }));
 }
-function reseedProjectHeadsFromMirror(input) {
-  return updateProjectHeadsFromMirror({ ...input, allowNonFastForward: true }).map(({ moved, ...state }) => ({
+async function reseedProjectHeadsFromMirror(input) {
+  return (await updateProjectHeadsFromMirror({ ...input, allowNonFastForward: true })).map(({ moved, ...state }) => ({
     ...state,
     reseeded: moved
   }));

package/dist/mjs/workspace-automatic-sync-policy.mjs

@@ -15,6 +15,12 @@ function projectBranchHasActiveWorkspaceTarget(projectId, branchName, activeTarg
   }
   return false;
 }
+function projectBranchMountBusyDuringExclusiveSync(input) {
+  return input.executionDisabled || input.worktreeOperationInProgress || input.retainedCanonicalProcessGroup || projectBranchHasActiveWorkspaceTarget(input.projectId, input.branchName, input.activeTargets);
+}
+function workspacePlansMountBusyDuringExclusiveSync(activeTargets, retainedCanonicalProcessGroup = false) {
+  return retainedCanonicalProcessGroup || hasActiveVisibleProjectsWorkspaceTarget(activeTargets);
+}
 function shouldDeferAutomaticWorkspaceSyncForPendingBranch(pendingCreatedBranches, activeTargets) {
   if (pendingCreatedBranches.length === 0) return false;
   const targets = [...activeTargets];
@@ -36,5 +42,7 @@ export {
   pendingCreatedBranchAutomaticSyncDeferral,
   pendingCreatedBranchKey,
   projectBranchHasActiveWorkspaceTarget,
-  shouldDeferAutomaticWorkspaceSyncForPendingBranch
+  projectBranchMountBusyDuringExclusiveSync,
+  shouldDeferAutomaticWorkspaceSyncForPendingBranch,
+  workspacePlansMountBusyDuringExclusiveSync
 };

package/dist/mjs/workspace-command-sync-policy.mjs

@@ -20,12 +20,32 @@ function shouldSerializeWorkspaceCommand(target) {
 function runWorkspaceCommand(target, coordinator, operation) {
   return shouldSerializeWorkspaceCommand(target) ? coordinator.runMutation(operation) : Promise.resolve().then(operation);
 }
+async function runReservedWorkspaceCommand(target, coordinator, operation, releaseReservation) {
+  let released = false;
+  const releaseOnce = () => {
+    if (released) return;
+    released = true;
+    releaseReservation();
+  };
+  try {
+    return await runWorkspaceCommand(target, coordinator, async () => {
+      try {
+        return await operation();
+      } finally {
+        releaseOnce();
+      }
+    });
+  } finally {
+    releaseOnce();
+  }
+}
 function acquireWorkspaceCommandMutation(target, coordinator) {
   return shouldSerializeWorkspaceCommand(target) ? coordinator.acquireMutation() : Promise.resolve(void 0);
 }
 export {
   acquireWorkspaceCommandMutation,
   reserveWorkspaceCommandAfterCurrentSync,
+  runReservedWorkspaceCommand,
   runWorkspaceCommand,
   shouldSerializeWorkspaceCommand
 };