@ricsam/r5d-worker 0.0.101 → 0.0.104

package/dist/cjs/package.json

@@ -1,5 +1,5 @@
 {
   "name": "@ricsam/r5d-worker",
-  "version": "0.0.101",
+  "version": "0.0.104",
   "type": "commonjs"
 }

package/dist/cjs/project-mirror-fetch-policy.cjs

@@ -18,24 +18,65 @@ var __copyProps = (to, from, except, desc) => {
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var project_mirror_fetch_policy_exports = {};
 __export(project_mirror_fetch_policy_exports, {
-  PROJECT_MIRROR_FETCH_BACKSTOP_MS: () => PROJECT_MIRROR_FETCH_BACKSTOP_MS,
+  parseProjectMirrorRefsTokensMessage: () => parseProjectMirrorRefsTokensMessage,
+  planProjectMirrorObservationFetch: () => planProjectMirrorObservationFetch,
   projectMirrorFetchDecision: () => projectMirrorFetchDecision
 });
 module.exports = __toCommonJS(project_mirror_fetch_policy_exports);
-const PROJECT_MIRROR_FETCH_BACKSTOP_MS = 10 * 6e4;
 function projectMirrorFetchDecision(input) {
   if (!input.skippingEnabled) return { fetch: true, reason: "skipping_disabled" };
   if (input.advertisedToken === void 0) return { fetch: true, reason: "no_advertised_token" };
   if (input.fetchedToken === void 0) return { fetch: true, reason: "never_fetched" };
   if (input.advertisedToken !== input.fetchedToken) return { fetch: true, reason: "token_changed" };
-  const backstopMs = input.backstopMs ?? PROJECT_MIRROR_FETCH_BACKSTOP_MS;
-  if (input.lastFetchAtMs === void 0 || input.nowMs - input.lastFetchAtMs >= backstopMs) {
-    return { fetch: true, reason: "backstop_elapsed" };
-  }
   return { fetch: false, reason: "token_match" };
 }
+function planProjectMirrorObservationFetch(input) {
+  if (!input.skippingEnabled) return { scope: "project", reason: "skipping_disabled" };
+  if (input.advertisedMountTokens === void 0) {
+    const decision = projectMirrorFetchDecision({
+      advertisedToken: input.advertisedProjectToken,
+      fetchedToken: input.fetchedProjectToken,
+      skippingEnabled: true
+    });
+    return decision.fetch ? { scope: "project", reason: decision.reason } : { scope: "none" };
+  }
+  const mounts = [];
+  for (const branchName of [...input.branchNames].sort()) {
+    const decision = projectMirrorFetchDecision({
+      advertisedToken: input.advertisedMountTokens.get(branchName),
+      fetchedToken: input.fetchedMountTokens.get(branchName),
+      skippingEnabled: true
+    });
+    if (decision.fetch) mounts.push({ branchName, reason: decision.reason });
+  }
+  return mounts.length === 0 ? { scope: "none" } : { scope: "mounts", mounts };
+}
+const TOKEN_RE = /^[0-9a-f]{64}$/;
+const GIT_OBJECT_NAME_RE = /^(?:[0-9a-f]{40}|[0-9a-f]{64})$/;
+function parseProjectMirrorRefsTokensMessage(message) {
+  const projectTokens = /* @__PURE__ */ new Map();
+  if (message.tokens && typeof message.tokens === "object") {
+    for (const [projectId, token] of Object.entries(message.tokens)) {
+      if (typeof token === "string" && TOKEN_RE.test(token)) projectTokens.set(projectId, token);
+    }
+  }
+  const mountTokens = /* @__PURE__ */ new Map();
+  if (message.mountTokens && typeof message.mountTokens === "object") {
+    for (const [projectId, tokensByBranch] of Object.entries(message.mountTokens)) {
+      if (!tokensByBranch || typeof tokensByBranch !== "object") continue;
+      const perMount = /* @__PURE__ */ new Map();
+      for (const [branchName, token] of Object.entries(tokensByBranch)) {
+        if (typeof token === "string" && TOKEN_RE.test(token)) perMount.set(branchName, token);
+      }
+      mountTokens.set(projectId, perMount);
+    }
+  }
+  const workspaceHead = typeof message.workspaceHead === "string" && GIT_OBJECT_NAME_RE.test(message.workspaceHead) ? message.workspaceHead : void 0;
+  return { projectTokens, mountTokens, workspaceHead };
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  PROJECT_MIRROR_FETCH_BACKSTOP_MS,
+  parseProjectMirrorRefsTokensMessage,
+  planProjectMirrorObservationFetch,
   projectMirrorFetchDecision
 });

package/dist/cjs/project-mirror-refs-token.cjs

@@ -18,19 +18,38 @@ var __copyProps = (to, from, except, desc) => {
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var project_mirror_refs_token_exports = {};
 __export(project_mirror_refs_token_exports, {
+  PROJECT_MIRROR_REFS_TOKEN_NAMESPACES: () => PROJECT_MIRROR_REFS_TOKEN_NAMESPACES,
+  PROJECT_MIRROR_REF_LISTING_FORMAT: () => PROJECT_MIRROR_REF_LISTING_FORMAT,
   PROJECT_MIRROR_REF_PREFIX: () => PROJECT_MIRROR_REF_PREFIX,
   PROJECT_SERVER_SYNCED_REF_PREFIX: () => PROJECT_SERVER_SYNCED_REF_PREFIX,
   canonicalizeLocalProjectMirrorRefs: () => canonicalizeLocalProjectMirrorRefs,
-  hashProjectMirrorRefs: () => hashProjectMirrorRefs
+  hashProjectMirrorRefs: () => hashProjectMirrorRefs,
+  parseProjectMirrorRefListing: () => parseProjectMirrorRefListing,
+  projectMirrorMountRefs: () => projectMirrorMountRefs,
+  projectMirrorRefsTokens: () => projectMirrorRefsTokens
 });
 module.exports = __toCommonJS(project_mirror_refs_token_exports);
 var import_node_crypto = require("node:crypto");
+const PROJECT_MIRROR_REFS_TOKEN_NAMESPACES = ["refs/heads/", "refs/r5d/server-synced/"];
 const PROJECT_MIRROR_REF_PREFIX = "refs/r5d/mirror/";
 const PROJECT_SERVER_SYNCED_REF_PREFIX = "refs/r5d/server-synced/";
+const PROJECT_MIRROR_REF_LISTING_FORMAT = "--format=%(objectname) %(refname)";
+const GIT_OBJECT_NAME_RE = /^(?:[0-9a-f]{40}|[0-9a-f]{64})$/;
 function hashProjectMirrorRefs(refs) {
   const lines = refs.map(({ objectName, refname }) => `${objectName} ${refname}`).sort((left, right) => left < right ? -1 : left > right ? 1 : 0);
   return (0, import_node_crypto.createHash)("sha256").update(lines.join("\n")).digest("hex");
 }
+function parseProjectMirrorRefListing(output, options = {}) {
+  return output.split(/\r?\n/).filter(Boolean).map((row) => {
+    const separator = row.indexOf(" ");
+    const objectName = separator < 0 ? "" : row.slice(0, separator);
+    const refname = separator < 0 ? "" : row.slice(separator + 1);
+    if (!GIT_OBJECT_NAME_RE.test(objectName) || refname.length === 0 || options.namespaces !== void 0 && !options.namespaces.some((prefix) => refname.startsWith(prefix))) {
+      throw new Error(`Invalid ref listing row: ${row}`);
+    }
+    return { refname, objectName };
+  });
+}
 function canonicalizeLocalProjectMirrorRefs(refs) {
   const canonical = [];
   for (const { refname, objectName } of refs) {
@@ -42,10 +61,25 @@ function canonicalizeLocalProjectMirrorRefs(refs) {
   }
   return canonical;
 }
+function projectMirrorMountRefs(refs, mount) {
+  const headRef = `refs/heads/${mount.branchName}`;
+  const handoffPrefix = `${PROJECT_SERVER_SYNCED_REF_PREFIX}${mount.branchId}/`;
+  return refs.filter(({ refname }) => refname === headRef || refname.startsWith(handoffPrefix));
+}
+function projectMirrorRefsTokens(refs, mounts) {
+  const mountTokens = /* @__PURE__ */ new Map();
+  for (const mount of mounts) mountTokens.set(mount.branchName, hashProjectMirrorRefs(projectMirrorMountRefs(refs, mount)));
+  return { project: hashProjectMirrorRefs(refs), mounts: mountTokens };
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  PROJECT_MIRROR_REFS_TOKEN_NAMESPACES,
+  PROJECT_MIRROR_REF_LISTING_FORMAT,
   PROJECT_MIRROR_REF_PREFIX,
   PROJECT_SERVER_SYNCED_REF_PREFIX,
   canonicalizeLocalProjectMirrorRefs,
-  hashProjectMirrorRefs
+  hashProjectMirrorRefs,
+  parseProjectMirrorRefListing,
+  projectMirrorMountRefs,
+  projectMirrorRefsTokens
 });

package/dist/cjs/project-worktrees.cjs

@@ -28,11 +28,13 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var project_worktrees_exports = {};
 __export(project_worktrees_exports, {
+  PROJECT_REMOVED_CHECKOUTS_DIRECTORY: () => PROJECT_REMOVED_CHECKOUTS_DIRECTORY,
   PROJECT_WORKTREE_SNAPSHOT_PREFIX: () => PROJECT_WORKTREE_SNAPSHOT_PREFIX,
   ProjectBranchCreationRollbackIncompleteError: () => ProjectBranchCreationRollbackIncompleteError,
   applyObservedProjectMirrorHeads: () => applyObservedProjectMirrorHeads,
   assertProjectMirrorHeadsPushed: () => assertProjectMirrorHeadsPushed,
-  computeLocalProjectMirrorRefsToken: () => computeLocalProjectMirrorRefsToken,
+  classifyProjectCheckout: () => classifyProjectCheckout,
+  computeLocalProjectMirrorRefsTokens: () => computeLocalProjectMirrorRefsTokens,
   createLinkedProjectBranch: () => createLinkedProjectBranch,
   createOrRetryLinkedProjectBranch: () => createOrRetryLinkedProjectBranch,
   deleteLinkedProjectBranch: () => deleteLinkedProjectBranch,
@@ -40,6 +42,7 @@ __export(project_worktrees_exports, {
   ensureProjectWorktrees: () => ensureProjectWorktrees,
   fastForwardProjectHeadsFromMirror: () => fastForwardProjectHeadsFromMirror,
   hasLinkedProjectWorktreeLayout: () => hasLinkedProjectWorktreeLayout,
+  inventoryProjectCheckouts: () => inventoryProjectCheckouts,
   observeProjectMirrorHeads: () => observeProjectMirrorHeads,
   projectBranchMayExistAfterCreateFailure: () => projectBranchMayExistAfterCreateFailure,
   projectOriginBranchName: () => projectOriginBranchName,
@@ -334,6 +337,8 @@ function normalizeSnapshotManifest(value) {
   if (record.state !== "building" && record.state !== "prepared" && record.state !== "restoring" && record.state !== "consumed") {
     throw new Error("Project worktree snapshot manifest has an invalid state");
   }
+  const scope = record.scope === void 0 ? "project" : record.scope;
+  if (scope !== "project" && scope !== "branches") throw new Error("Project worktree snapshot manifest has an invalid scope");
   if (!Number.isSafeInteger(record.ownerProcessId) || record.ownerProcessId <= 0) {
     throw new Error("Project worktree snapshot manifest has an invalid owner process");
   }
@@ -369,6 +374,7 @@ function normalizeSnapshotManifest(value) {
   return {
     version: PROJECT_WORKTREE_SNAPSHOT_MANIFEST_VERSION,
     state: record.state,
+    scope,
     ownerProcessId: record.ownerProcessId,
     ownerSessionId: record.ownerSessionId,
     projectRoot: record.projectRoot,
@@ -405,7 +411,7 @@ function writeSnapshotManifest(snapshotRoot, manifest) {
   return readSnapshotManifest(snapshotRoot);
 }
 function assertSameSnapshotIdentity(expected, actual) {
-  if (expected.ownerProcessId !== actual.ownerProcessId || expected.ownerSessionId !== actual.ownerSessionId || expected.projectRoot !== actual.projectRoot || expected.createdAt !== actual.createdAt || JSON.stringify(expected.branches) !== JSON.stringify(actual.branches)) {
+  if (expected.scope !== actual.scope || expected.ownerProcessId !== actual.ownerProcessId || expected.ownerSessionId !== actual.ownerSessionId || expected.projectRoot !== actual.projectRoot || expected.createdAt !== actual.createdAt || JSON.stringify(expected.branches) !== JSON.stringify(actual.branches)) {
     throw new Error("Project worktree snapshot identity changed");
   }
 }
@@ -472,7 +478,7 @@ function assertNoOutstandingSnapshotForProject(temporaryRoot, projectRoot) {
     }
   }
 }
-function snapshotBranchTrees(projectRoot, branches, temporaryRoot, onProgress) {
+function snapshotBranchTrees(projectRoot, branches, temporaryRoot, onProgress, scope = "project") {
   const resolvedProjectRoot = import_node_path.default.resolve(projectRoot);
   const resolvedTemporaryRoot = import_node_path.default.resolve(temporaryRoot ?? import_node_os.default.tmpdir());
   assertNoOutstandingSnapshotForProject(resolvedTemporaryRoot, resolvedProjectRoot);
@@ -493,6 +499,7 @@ function snapshotBranchTrees(projectRoot, branches, temporaryRoot, onProgress) {
     let manifest = writeSnapshotManifest(root, {
       version: PROJECT_WORKTREE_SNAPSHOT_MANIFEST_VERSION,
       state: "building",
+      scope,
       ownerProcessId: process.pid,
       ownerSessionId: PROJECT_WORKTREE_SNAPSHOT_OWNER_SESSION_ID,
       projectRoot: resolvedProjectRoot,
@@ -599,7 +606,7 @@ function restoreProjectWorktreeSnapshot(snapshotRoot, manifest, onProgress) {
   const presentBranches = current.branches.filter(({ snapshotPresent }) => snapshotPresent);
   const destinationParent = import_node_path.default.dirname(current.projectRoot);
   import_node_fs.default.mkdirSync(destinationParent, { recursive: true });
-  const canMoveWholeSnapshot = presentBranches.length > 0 && (current.state === "restoring" || treesRootStat !== null && treesRootStat.dev === import_node_fs.default.lstatSync(destinationParent).dev);
+  const canMoveWholeSnapshot = current.scope === "project" && presentBranches.length > 0 && (current.state === "restoring" || treesRootStat !== null && treesRootStat.dev === import_node_fs.default.lstatSync(destinationParent).dev);
   if (canMoveWholeSnapshot) {
     if (current.state === "prepared") current = advanceSnapshotState(snapshotRoot, current, "restoring");
     onProgress?.({
@@ -690,8 +697,12 @@ function consumeAndRemoveProjectWorktreeSnapshot(snapshotRoot, manifest) {
   } catch {
   }
 }
-function persistReconciledProjectAndConsumeSnapshot(snapshot, afterProjectTreeFsync) {
-  fsyncTree(snapshot.manifest.projectRoot);
+function persistReconciledProjectAndConsumeSnapshot(snapshot, afterProjectTreeFsync, durabilityPaths) {
+  if (durabilityPaths) {
+    for (const durabilityPath of durabilityPaths) if (import_node_fs.default.existsSync(durabilityPath)) fsyncTree(durabilityPath);
+  } else {
+    fsyncTree(snapshot.manifest.projectRoot);
+  }
   fsyncManagedProjectRootEntry(snapshot.manifest.projectRoot);
   afterProjectTreeFsync?.();
   consumeAndRemoveProjectWorktreeSnapshot(snapshot.root, snapshot.manifest);
@@ -989,8 +1000,10 @@ async function reconcileLinkedLayout(input) {
   await configureRepository({ ...input, primaryPath });
   await tryGitAsync(primaryPath, ["worktree", "prune"]);
   await fetchProjectHeads({ ...input, primaryPath });
+  const primaryCommonDir = await commonGitDirectoryAsync(primaryPath);
+  if (!primaryCommonDir) throw new Error("Primary project checkout is unavailable");
   const mirrorHeads = /* @__PURE__ */ new Map();
-  const mutatedBranches = /* @__PURE__ */ new Set();
+  const plan = [];
   for (const branch of input.branches) {
     const checkoutPath = branchPath(input.projectRoot, branch.branchName);
     const resolved = await seedForBranch({
@@ -1000,24 +1013,30 @@ async function reconcileLinkedLayout(input) {
       requireMirrorHead: input.exactMirrorBranches?.has(branch.branchName)
     });
     mirrorHeads.set(branch.branchName, resolved.mirrorHead);
-    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);
-      await preserveHead(checkoutPath);
-      await gitAsync(checkoutPath, ["reset", "--hard", resolved.seed], `anchor linked worktree ${branch.branchName}`);
+    const linked = branch.branchName === input.primaryBranchName || gitDirectoryKind(checkoutPath) !== null && await commonGitDirectoryAsync(checkoutPath) === primaryCommonDir;
+    if (!linked) {
+      plan.push({ branchName: branch.branchName, checkoutPath, seed: resolved.seed, action: "recreate" });
       continue;
     }
-    input.beforeDestructiveMutation();
-    mutatedBranches.add(branch.branchName);
-    import_node_fs.default.rmSync(checkoutPath, { recursive: true, force: true });
-    await gitAsync(primaryPath, ["branch", "-f", branch.branchName, resolved.seed], `anchor project branch ${branch.branchName}`);
-    import_node_fs.default.mkdirSync(import_node_path.default.dirname(checkoutPath), { recursive: true });
+    const currentHead = await gitAsync(checkoutPath, ["rev-parse", "HEAD"], `resolve linked worktree head ${branch.branchName}`);
+    plan.push({ branchName: branch.branchName, checkoutPath, seed: resolved.seed, action: currentHead === resolved.seed ? "keep" : "reset" });
+  }
+  const mutatedBranches = new Set(plan.filter(({ action }) => action !== "keep").map(({ branchName }) => branchName));
+  if (mutatedBranches.size > 0) input.beforeDestructiveMutation(mutatedBranches);
+  for (const entry of plan) {
+    if (entry.action === "keep") continue;
+    if (entry.action === "reset") {
+      await preserveHead(entry.checkoutPath);
+      await gitAsync(entry.checkoutPath, ["reset", "--hard", entry.seed], `anchor linked worktree ${entry.branchName}`);
+      continue;
+    }
+    import_node_fs.default.rmSync(entry.checkoutPath, { recursive: true, force: true });
+    await gitAsync(primaryPath, ["branch", "-f", entry.branchName, entry.seed], `anchor project branch ${entry.branchName}`);
+    import_node_fs.default.mkdirSync(import_node_path.default.dirname(entry.checkoutPath), { recursive: true });
     await gitAsync(
       primaryPath,
-      ["worktree", "add", "--force", checkoutPath, branch.branchName],
-      `create linked worktree ${branch.branchName}`
+      ["worktree", "add", "--force", entry.checkoutPath, entry.branchName],
+      `create linked worktree ${entry.branchName}`
     );
   }
   return { mirrorHeads, mutatedBranches };
@@ -1044,8 +1063,14 @@ async function ensureProjectWorktrees(input) {
   const snapshotStorageRoot = import_node_path.default.resolve(input.snapshotRoot ?? import_node_os.default.tmpdir());
   assertNoOutstandingSnapshotForProject(snapshotStorageRoot, projectRoot);
   let snapshot;
-  const ensureSnapshot = () => {
-    snapshot ??= snapshotBranchTrees(projectRoot, input.branches, snapshotStorageRoot, input.onSnapshotProgress);
+  const ensureSnapshot = (branchNames) => {
+    snapshot ??= snapshotBranchTrees(
+      projectRoot,
+      branchNames ? input.branches.filter(({ branchName }) => branchNames.has(branchName)) : input.branches,
+      snapshotStorageRoot,
+      input.onSnapshotProgress,
+      branchNames ? "branches" : "project"
+    );
     return snapshot;
   };
   try {
@@ -1097,7 +1122,21 @@ async function ensureProjectWorktrees(input) {
       });
     }
     states.sort((left, right) => left.branchName.localeCompare(right.branchName));
-    if (snapshot) persistReconciledProjectAndConsumeSnapshot(snapshot);
+    if (snapshot) {
+      const primaryGitDirectory = import_node_path.default.join(branchPath(projectRoot, input.primaryBranchName), ".git");
+      persistReconciledProjectAndConsumeSnapshot(
+        snapshot,
+        void 0,
+        snapshot.manifest.scope === "branches" ? [
+          ...snapshot.manifest.branches.map(({ branchName }) => branchPath(projectRoot, branchName)),
+          // Branch refs and worktree registrations moved in the shared
+          // administrative directory; objects are fsynced by git itself.
+          import_node_path.default.join(primaryGitDirectory, "refs"),
+          import_node_path.default.join(primaryGitDirectory, "packed-refs"),
+          import_node_path.default.join(primaryGitDirectory, "worktrees")
+        ] : void 0
+      );
+    }
     return states;
   } catch (error) {
     if (!snapshot) throw error;
@@ -1174,8 +1213,12 @@ function createLinkedProjectBranch(input) {
     );
     configureProjectBranchTracking(targetPath, input.branchName, input.branchName);
     assertNoSymlinkBranchPathComponents(input.projectRoot, targetPath);
-    git(targetPath, ["read-tree", sourceHead], `initialize linked worktree index ${input.branchName}`);
-    (0, import_working_tree_mirror.mirrorWorkingTree)({ sourceRoot: sourcePath, targetRoot: targetPath, sourceMode: "git", deletionMode: "git" });
+    if (input.workingTree === "carry") {
+      git(targetPath, ["read-tree", sourceHead], `initialize linked worktree index ${input.branchName}`);
+      (0, import_working_tree_mirror.mirrorWorkingTree)({ sourceRoot: sourcePath, targetRoot: targetPath, sourceMode: "git", deletionMode: "git" });
+    } else {
+      git(targetPath, ["reset", "--hard", sourceHead], `check out linked worktree ${input.branchName}`);
+    }
     return { branchPath: targetPath, baseCommitHash: sourceHead };
   } catch (error) {
     if (branchCreated) {
@@ -1239,6 +1282,53 @@ function createOrRetryLinkedProjectBranch(input) {
   }
   return createLinkedProjectBranch(input);
 }
+function classifyProjectCheckout(input) {
+  const checkoutPath = branchPath(input.projectRoot, input.branchName);
+  let stat;
+  try {
+    stat = import_node_fs.default.lstatSync(checkoutPath);
+  } catch {
+    return "missing";
+  }
+  if (!stat.isDirectory()) return "not_a_worktree";
+  if (input.branchName === input.primaryBranchName) return gitDirectoryKind(checkoutPath) === "directory" ? "linked" : "not_a_worktree";
+  if (gitDirectoryKind(checkoutPath) !== "file") return "not_a_worktree";
+  const gitDirectory = perWorktreeGitDirectory(checkoutPath);
+  if (!gitDirectory) return "not_a_worktree";
+  let registry;
+  let registered;
+  try {
+    registry = import_node_fs.default.realpathSync(import_node_path.default.join(branchPath(input.projectRoot, input.primaryBranchName), ".git", "worktrees"));
+    registered = import_node_fs.default.realpathSync(gitDirectory);
+  } catch {
+    return "not_a_worktree";
+  }
+  const relative = import_node_path.default.relative(registry, registered);
+  if (!relative || relative === ".." || relative.startsWith(`..${import_node_path.default.sep}`) || import_node_path.default.isAbsolute(relative)) return "not_a_worktree";
+  return "linked";
+}
+function inventoryProjectCheckouts(input) {
+  const states = input.branchNames.map((branchName) => ({
+    branchName,
+    checkoutPath: branchPath(input.projectRoot, branchName),
+    state: classifyProjectCheckout({ ...input, branchName })
+  }));
+  const primaryLinked = states.some(({ branchName, state }) => branchName === input.primaryBranchName && state === "linked");
+  const inventory = { linkedBranchNames: [], missingCheckouts: [] };
+  for (const { branchName, checkoutPath, state } of states) {
+    if (primaryLinked && state === "linked") inventory.linkedBranchNames.push(branchName);
+    else inventory.missingCheckouts.push({ branchName, checkoutPath, reason: state === "linked" ? "not_a_worktree" : state });
+  }
+  return inventory;
+}
+const PROJECT_REMOVED_CHECKOUTS_DIRECTORY = ".r5d-removed";
+function moveProjectCheckoutAside(projectRoot, branchName, checkoutPath) {
+  const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
+  const target = import_node_path.default.join(projectRoot, PROJECT_REMOVED_CHECKOUTS_DIRECTORY, ...`${branchName}-${timestamp}`.split("/"));
+  import_node_fs.default.mkdirSync(import_node_path.default.dirname(target), { recursive: true });
+  import_node_fs.default.renameSync(checkoutPath, target);
+  return target;
+}
 function deleteLinkedProjectBranch(input) {
   (0, import_managed_paths.validateManagedBranchName)(input.primaryBranchName);
   (0, import_managed_paths.validateManagedBranchName)(input.branchName);
@@ -1247,15 +1337,18 @@ function deleteLinkedProjectBranch(input) {
   const checkoutPath = branchPath(input.projectRoot, input.branchName);
   const primaryCommonDir = commonGitDirectory(primaryPath);
   if (!primaryCommonDir) throw new Error("Primary project checkout is unavailable");
+  let movedAsidePath;
   if (import_node_fs.default.existsSync(checkoutPath)) {
-    const checkoutCommonDir = commonGitDirectory(checkoutPath);
+    const checkoutCommonDir = import_node_fs.default.lstatSync(checkoutPath).isDirectory() ? commonGitDirectory(checkoutPath) : null;
     if (checkoutCommonDir !== primaryCommonDir) {
-      throw new Error(`Project branch path ${input.branchName} is not a linked worktree of the configured project`);
-    }
-    if (projectWorktreeOperationInProgress(checkoutPath)) {
-      throw new Error(`Project branch ${input.branchName} has an in-progress Git operation`);
+      movedAsidePath = moveProjectCheckoutAside(input.projectRoot, input.branchName, checkoutPath);
+      tryGit(primaryPath, ["worktree", "prune"]);
+    } else {
+      if (projectWorktreeOperationInProgress(checkoutPath)) {
+        throw new Error(`Project branch ${input.branchName} has an in-progress Git operation`);
+      }
+      git(primaryPath, ["worktree", "remove", "--force", checkoutPath], `remove linked worktree ${input.branchName}`);
     }
-    git(primaryPath, ["worktree", "remove", "--force", checkoutPath], `remove linked worktree ${input.branchName}`);
   } else {
     tryGit(primaryPath, ["worktree", "prune"]);
   }
@@ -1263,7 +1356,7 @@ function deleteLinkedProjectBranch(input) {
   if (tryGit(primaryPath, ["show-ref", "--verify", "--quiet", branchRef])) {
     git(primaryPath, ["branch", "-D", input.branchName], `delete project branch ${input.branchName}`);
   }
-  return { branchName: input.branchName };
+  return { branchName: input.branchName, ...movedAsidePath ? { movedAsidePath } : {} };
 }
 function removeProjectWorktrees(input) {
   const projectRoot = import_node_path.default.resolve(input.projectRoot);
@@ -1365,24 +1458,46 @@ function assertProjectMirrorHeadsPushed(results) {
     throw new Error(`Hidden project mirror publication skipped ${skipped.branchName}${skipped.reason ? ` (${skipped.reason})` : ""}`);
   }
 }
+const PROJECT_MIRROR_FETCH_REFSPECS = ["+refs/heads/*:refs/r5d/mirror/*", "+refs/r5d/server-synced/*:refs/r5d/server-synced/*"];
+function projectMirrorMountFetchRefspecs(branchName, branchId) {
+  (0, import_managed_paths.validateManagedBranchName)(branchName);
+  if (branchId !== void 0 && !/^[A-Za-z0-9][A-Za-z0-9_-]{0,127}$/.test(branchId)) throw new Error(`Invalid branch id for ${branchName}`);
+  return [
+    `+refs/heads/${branchName}:refs/r5d/mirror/${branchName}`,
+    branchId === void 0 ? "+refs/r5d/server-synced/*:refs/r5d/server-synced/*" : `+refs/r5d/server-synced/${branchId}/*:refs/r5d/server-synced/${branchId}/*`
+  ];
+}
+async function fetchProjectMirrorRefs(input) {
+  const fetch = (refspecs) => gitResultAsync(
+    input.primaryPath,
+    [
+      ...(0, import_git_process_environment.gitTransportSecurityArgs)(input.mirrorUrl, input.credentialHelper, input.credentialUsername),
+      "fetch",
+      "--no-recurse-submodules",
+      "--prune",
+      input.mirrorUrl,
+      ...refspecs
+    ],
+    PROJECT_GIT_TRANSPORT_TIMEOUT_MS
+  );
+  if (input.fetchOnlyBranches && input.fetchOnlyBranches.size > 0) {
+    const refspecs = [...input.fetchOnlyBranches].sort().flatMap((branchName) => projectMirrorMountFetchRefspecs(branchName, input.branchIds?.get(branchName)));
+    const scoped = await fetch(refspecs);
+    if (scoped.exitCode === 0) return;
+    if (!/(couldn't find remote ref|no such ref)/i.test(`${scoped.stderr}
+${scoped.stdout}`)) {
+      throw new Error(`Refresh project head mirror: ${scoped.stderr || scoped.stdout || `git exited ${scoped.exitCode}`}`);
+    }
+  }
+  const whole = await fetch(PROJECT_MIRROR_FETCH_REFSPECS);
+  if (whole.exitCode !== 0) {
+    throw new Error(`Refresh project head mirror: ${whole.stderr || whole.stdout || `git exited ${whole.exitCode}`}`);
+  }
+}
 async function observeProjectMirrorHeads(input) {
   const primaryPath = branchPath(input.projectRoot, input.primaryBranchName);
-  if (input.refreshRemote !== false) {
-    const fetch = await gitResultAsync(
-      primaryPath,
-      [
-        ...(0, import_git_process_environment.gitTransportSecurityArgs)(input.mirrorUrl, input.credentialHelper, input.credentialUsername),
-        "fetch",
-        "--no-recurse-submodules",
-        "--prune",
-        input.mirrorUrl,
-        "+refs/heads/*:refs/r5d/mirror/*",
-        "+refs/r5d/server-synced/*:refs/r5d/server-synced/*"
-      ],
-      PROJECT_GIT_TRANSPORT_TIMEOUT_MS
-    );
-    if (fetch.exitCode !== 0)
-      throw new Error(`Refresh project head mirror: ${fetch.stderr || fetch.stdout || `git exited ${fetch.exitCode}`}`);
+  if (input.refreshRemote !== false && !(input.fetchOnlyBranches && input.fetchOnlyBranches.size === 0)) {
+    await fetchProjectMirrorRefs({ ...input, primaryPath });
   }
   const observations = [];
   for (const branchName of [...input.branchNames].sort()) {
@@ -1429,23 +1544,14 @@ async function observeProjectMirrorHeads(input) {
   }
   return observations;
 }
-async function computeLocalProjectMirrorRefsToken(input) {
+async function computeLocalProjectMirrorRefsTokens(input) {
   const primaryPath = branchPath(input.projectRoot, input.primaryBranchName);
   const rows = await gitAsync(
     primaryPath,
-    ["for-each-ref", "--format=%(objectname) %(refname)", import_project_mirror_refs_token.PROJECT_MIRROR_REF_PREFIX, import_project_mirror_refs_token.PROJECT_SERVER_SYNCED_REF_PREFIX],
+    ["for-each-ref", import_project_mirror_refs_token.PROJECT_MIRROR_REF_LISTING_FORMAT, import_project_mirror_refs_token.PROJECT_MIRROR_REF_PREFIX, import_project_mirror_refs_token.PROJECT_SERVER_SYNCED_REF_PREFIX],
     "list cached project mirror refs"
   );
-  const refs = rows.split(/\r?\n/).filter(Boolean).map((row) => {
-    const separator = row.indexOf(" ");
-    const objectName = separator < 0 ? "" : row.slice(0, separator);
-    const refname = separator < 0 ? "" : row.slice(separator + 1);
-    if (!/^[0-9a-f]{40,64}$/.test(objectName) || refname.length === 0) {
-      throw new Error(`Invalid cached mirror ref listing row: ${row}`);
-    }
-    return { refname, objectName };
-  });
-  return (0, import_project_mirror_refs_token.hashProjectMirrorRefs)((0, import_project_mirror_refs_token.canonicalizeLocalProjectMirrorRefs)(refs));
+  return (0, import_project_mirror_refs_token.projectMirrorRefsTokens)((0, import_project_mirror_refs_token.canonicalizeLocalProjectMirrorRefs)((0, import_project_mirror_refs_token.parseProjectMirrorRefListing)(rows)), input.mounts);
 }
 async function applyObservedProjectMirrorHeads(input) {
   const results = [];
@@ -1509,7 +1615,7 @@ const projectWorktreesTestHarness = {
   commandArgs: gitCommandArgs,
   configureRepository,
   createPreparedSnapshot(input) {
-    return { root: snapshotBranchTrees(input.projectRoot, input.branches, input.temporaryRoot).root };
+    return { root: snapshotBranchTrees(input.projectRoot, input.branches, input.temporaryRoot, void 0, input.scope).root };
   },
   consumeSnapshot(snapshotRoot) {
     const manifest = readSnapshotManifest(snapshotRoot);
@@ -1525,11 +1631,13 @@ const projectWorktreesTestHarness = {
 };
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  PROJECT_REMOVED_CHECKOUTS_DIRECTORY,
   PROJECT_WORKTREE_SNAPSHOT_PREFIX,
   ProjectBranchCreationRollbackIncompleteError,
   applyObservedProjectMirrorHeads,
   assertProjectMirrorHeadsPushed,
-  computeLocalProjectMirrorRefsToken,
+  classifyProjectCheckout,
+  computeLocalProjectMirrorRefsTokens,
   createLinkedProjectBranch,
   createOrRetryLinkedProjectBranch,
   deleteLinkedProjectBranch,
@@ -1537,6 +1645,7 @@ const projectWorktreesTestHarness = {
   ensureProjectWorktrees,
   fastForwardProjectHeadsFromMirror,
   hasLinkedProjectWorktreeLayout,
+  inventoryProjectCheckouts,
   observeProjectMirrorHeads,
   projectBranchMayExistAfterCreateFailure,
   projectOriginBranchName,