@ricsam/r5d-worker 0.0.92 → 0.0.94

package/dist/cjs/main.cjs

@@ -4067,7 +4067,7 @@ async function startWorker(options) {
     }
     return heads;
   };
-  const pushChangedProjectHeads = async (activeMountIds, publishedHead, publicationHeads, suppressedMountIds = /* @__PURE__ */ new Set()) => {
+  const pushChangedProjectHeads = async (activeMountIds, publishedHead, publicationHeads, expectedMirrorHeads, suppressedMountIds = /* @__PURE__ */ new Set()) => {
     const active = new Set(activeMountIds);
     for (const project of projectConfigById.values()) {
       if (!readyProjectIds.has(project.projectId) || !(0, import_repository_transition_policy.repositoryMirrorWritesAllowed)(project)) continue;
@@ -4082,6 +4082,12 @@ async function startWorker(options) {
         }
       }
       if (changed.size === 0) continue;
+      const branchLeases = /* @__PURE__ */ new Map();
+      for (const branchName of changed.keys()) {
+        const mountId = projectMountId(project.projectId, branchName);
+        if (!expectedMirrorHeads.has(mountId)) throw new Error(`Missing observed hidden-mirror lease for active project mount ${mountId}`);
+        branchLeases.set(branchName, expectedMirrorHeads.get(mountId) ?? null);
+      }
       const connection = projectConnection(project);
       const results = await (0, import_project_worktrees.pushProjectMirrorHeads)({
         projectRoot: configuredProjectRoot(projectsRoot, project),
@@ -4090,7 +4096,9 @@ async function startWorker(options) {
         credentialHelper: connection.credentialHelper,
         credentialUsername: connection.mirrorCredentialUsername,
         onlyBranches: new Set(changed.keys()),
-        publicationHeads: changed
+        publicationHeads: changed,
+        expectedMirrorHeads: branchLeases,
+        branchIds: new Map(project.branches.map(({ branchId, branchName }) => [branchName, branchId]))
       });
       (0, import_project_worktrees.assertProjectMirrorHeadsPushed)(results);
       for (const result of results) {
@@ -4154,7 +4162,8 @@ async function startWorker(options) {
             mirrorUrl: connection.mirrorUrl,
             credentialHelper: connection.credentialHelper,
             credentialUsername: connection.mirrorCredentialUsername,
-            allowNonFastForward: input.allowNonFastForward
+            allowNonFastForward: input.allowNonFastForward,
+            branchIds: new Map(project.branches.map(({ branchId, branchName }) => [branchName, branchId]))
           })
         });
       } catch (error) {
@@ -4167,7 +4176,7 @@ async function startWorker(options) {
     }
     return bundles;
   };
-  const applyObservedProjectHeadsAfterInboundWorkspace = async (bundles, activeMountIds, requireObservedHeads) => {
+  const applyObservedProjectHeadsAfterInboundWorkspace = async (bundles, activeMountIds, requireObservedHeads, integratedWorkspaceHead) => {
     const active = new Set(activeMountIds);
     for (const bundle of bundles) {
       const project = projectConfigById.get(bundle.projectId);
@@ -4179,7 +4188,16 @@ async function startWorker(options) {
           projectRoot: bundle.projectRoot,
           primaryBranchName: bundle.primaryBranchName,
           observations,
-          branchMutationAllowed: (branchName, checkoutPath) => !projectBranchMountBusy(project.projectId, branchName, checkoutPath)
+          branchMutationAllowed: (branchName, checkoutPath) => !projectBranchMountBusy(project.projectId, branchName, checkoutPath),
+          serverSyncedWorkspaceCovered: async (observation) => {
+            if (!integratedWorkspaceHead) return false;
+            for (const workspaceHead of observation.serverSyncedWorkspaceHeads) {
+              if (await tryGitAsync(["merge-base", "--is-ancestor", workspaceHead, integratedWorkspaceHead], { cwd: workspaceShadowRoot })) {
+                return true;
+              }
+            }
+            return false;
+          }
         });
         if (requireObservedHeads) {
           for (const observation of observations) {
@@ -4304,6 +4322,12 @@ async function startWorker(options) {
     const outerRemediation = input.trigger.type === "remediation" || input.trigger.type === "remediation_confirm";
     const mounts = outerRemediation ? (0, import_workspace_git_sync.workspaceGitMountsForRemediation)(configuredMounts) : configuredMounts;
     const observedProjectHeads = outerRemediation ? [] : await observeProjectHeadsBeforeOuterWorkspace({ allowNonFastForward: false, failClosed: false });
+    const expectedMirrorHeads = /* @__PURE__ */ new Map();
+    for (const bundle of observedProjectHeads) {
+      for (const observation of bundle.observations) {
+        expectedMirrorHeads.set(projectMountId(bundle.projectId, observation.branchName), observation.mirrorHead);
+      }
+    }
     const inboundMoveMountIds = new Set(
       observedProjectHeads.flatMap(
         ({ projectId, observations }) => observations.filter(({ shouldMove }) => shouldMove).map(({ branchName }) => projectMountId(projectId, branchName))
@@ -4325,12 +4349,17 @@ async function startWorker(options) {
       requiredAncestorHeads: input.requiredAncestorHeads,
       assertStillAdmitted: input.assertStillAdmitted,
       afterWorkspacePublished: outerRemediation ? void 0 : async ({ activeMountIds, publishedHead }) => {
-        await pushChangedProjectHeads(activeMountIds, publishedHead, publicationHeads, inboundMoveMountIds);
+        await pushChangedProjectHeads(activeMountIds, publishedHead, publicationHeads, expectedMirrorHeads, inboundMoveMountIds);
       }
     });
     input.assertStillAdmitted?.();
     if (["no_change", "updated", "pushed"].includes(result.outcome) && !outerRemediation) {
-      await applyObservedProjectHeadsAfterInboundWorkspace(observedProjectHeads, result.activeMountIds, false);
+      await applyObservedProjectHeadsAfterInboundWorkspace(
+        observedProjectHeads,
+        result.activeMountIds,
+        false,
+        result.localHead ?? result.remoteHead
+      );
     }
     return mapWorkspaceGitResult(input.attemptId, input.trigger, result);
   };
@@ -4425,11 +4454,12 @@ async function startWorker(options) {
         }
         try {
           assertStillAdmitted();
+          const hasDurableBranchDeletion = projectWorkspaceState.tombstones.some((tombstone) => tombstone.kind === "branch");
           return await performWorkspaceSync({
             attemptId,
             trigger: input.trigger,
-            confirmedLargeDiff: input.confirmedLargeDiff,
-            confirmationReason: input.confirmationReason,
+            confirmedLargeDiff: input.confirmedLargeDiff === true || hasDurableBranchDeletion,
+            confirmationReason: input.confirmationReason ?? (hasDurableBranchDeletion ? "durable project branch deletion" : void 0),
             resetToCanonical: input.resetToCanonical,
             requiredAncestorHeads: input.requiredAncestorHeads,
             assertStillAdmitted
@@ -4966,9 +4996,12 @@ async function startWorker(options) {
             );
           }
         };
+        const hasDurableBranchDeletion = projectWorkspaceState.tombstones.some((tombstone) => tombstone.kind === "branch");
         const result = await performWorkspaceSync({
           attemptId: crypto.randomUUID(),
           trigger: { type: "connect" },
+          confirmedLargeDiff: hasDurableBranchDeletion,
+          confirmationReason: hasDurableBranchDeletion ? "durable project branch deletion" : void 0,
           resetToCanonical: workspaceConfigurationResetToCanonicalIsAllowed(message.resetToCanonical, incidentDeferral.incidentId),
           assertStillAdmitted: assertConfigurationSyncStillAdmitted
         });
@@ -5210,7 +5243,9 @@ async function startWorker(options) {
           ptyEnvFilesV1: true,
           workspaceRemediationAncestorGuardV1: true,
           workspaceIncidentConfigDeferralV1: true,
-          workspaceConfigResetToCanonicalV1: true
+          workspaceConfigResetToCanonicalV1: true,
+          projectBranchDeletionFastAckV1: true,
+          projectMirrorLeaseV1: true
         },
         projectRoot: projectsRoot,
         artifactRoot,
@@ -5464,23 +5499,15 @@ async function startWorker(options) {
             return true;
           });
           if (deletionNeedsSync) {
-            const result = await runWorkspaceSync({
-              trigger: {
+            scheduleAutomaticWorkspaceSync(
+              {
                 type: "manual",
                 projectId: message.projectId,
                 branchName: message.branchName,
                 detail: "deleted project branch"
               },
-              confirmedLargeDiff: true,
-              confirmationReason: "explicit project branch deletion",
-              sendResult: false
-            });
-            if (result.outcome === "failed" || result.outcome === "conflict_blocked" || result.outcome === "large_diff_blocked") {
-              throw new Error(result.error ?? `Project branch deletion workspace sync ended with ${result.outcome}`);
-            }
-            if (pendingMirrorDeletes.has(deletionKey)) {
-              throw new Error("Project branch deletion did not remove the hidden mirror ref");
-            }
+              0
+            );
           }
           sendWorkerMessage(ws, {
             type: "operation_result",

package/dist/cjs/package.json

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

package/dist/cjs/project-worktrees.cjs

@@ -64,6 +64,7 @@ const PROJECT_WORKTREE_SNAPSHOT_MANIFEST_VERSION = 1;
 const MAX_PROJECT_WORKTREE_SNAPSHOT_MANIFEST_BYTES = 64 * 1024;
 const PROJECT_WORKTREE_SNAPSHOT_OWNER_SESSION_ID = (0, import_node_crypto.randomUUID)();
 const UUID_PATTERN = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
+const PROJECT_GIT_TRANSPORT_TIMEOUT_MS = 3e4;
 const PROJECT_WORKTREE_SNAPSHOT_NAME = new RegExp(
   `^${PROJECT_WORKTREE_SNAPSHOT_PREFIX.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}([1-9]\\d*)-([A-Za-z0-9]{6})$`
 );
@@ -133,7 +134,7 @@ function git(cwd, args, action) {
 function tryGit(cwd, args) {
   return gitResult(cwd, args).exitCode === 0;
 }
-async function gitResultAsync(cwd, args) {
+async function gitResultAsync(cwd, args, timeoutMs) {
   const subprocess = Bun.spawn(gitCommandArgs(args), {
     cwd,
     stdin: "ignore",
@@ -141,12 +142,22 @@ async function gitResultAsync(cwd, args) {
     stderr: "pipe",
     env: (0, import_git_process_environment.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() };
+  let timedOut = false;
+  const timeout = timeoutMs ? setTimeout(() => {
+    timedOut = true;
+    subprocess.kill("SIGKILL");
+  }, timeoutMs) : void 0;
+  try {
+    const [stdout, stderr, exitCode] = await Promise.all([
+      new Response(subprocess.stdout).text(),
+      new Response(subprocess.stderr).text(),
+      subprocess.exited
+    ]);
+    if (timedOut) throw new Error(`Git transport timed out after ${timeoutMs}ms`);
+    return { exitCode, stdout: stdout.trim(), stderr: stderr.trim() };
+  } finally {
+    if (timeout) clearTimeout(timeout);
+  }
 }
 async function gitAsync(cwd, args, action) {
   const result = await gitResultAsync(cwd, args);
@@ -861,25 +872,33 @@ async function configureRepository(input) {
   }
 }
 async function fetchProjectHeads(input) {
-  const originFetch = await gitResultAsync(input.primaryPath, [
-    ...(0, import_git_process_environment.gitTransportSecurityArgs)(input.originUrl, input.credentialHelper, input.originCredentialUsername),
-    "fetch",
-    "--no-recurse-submodules",
-    "--prune",
-    "origin",
-    "+refs/heads/*:refs/remotes/origin/*"
-  ]);
+  const originFetch = await gitResultAsync(
+    input.primaryPath,
+    [
+      ...(0, import_git_process_environment.gitTransportSecurityArgs)(input.originUrl, input.credentialHelper, input.originCredentialUsername),
+      "fetch",
+      "--no-recurse-submodules",
+      "--prune",
+      "origin",
+      "+refs/heads/*:refs/remotes/origin/*"
+    ],
+    PROJECT_GIT_TRANSPORT_TIMEOUT_MS
+  );
   if (originFetch.exitCode !== 0) {
     throw new Error(`Fetch project origin: ${originFetch.stderr || originFetch.stdout || `git exited ${originFetch.exitCode}`}`);
   }
-  const mirrorFetch = await gitResultAsync(input.primaryPath, [
-    ...(0, import_git_process_environment.gitTransportSecurityArgs)(input.mirrorUrl, input.credentialHelper, input.mirrorCredentialUsername),
-    "fetch",
-    "--no-recurse-submodules",
-    "--prune",
-    input.mirrorUrl,
-    "+refs/heads/*:refs/r5d/mirror/*"
-  ]);
+  const mirrorFetch = await gitResultAsync(
+    input.primaryPath,
+    [
+      ...(0, import_git_process_environment.gitTransportSecurityArgs)(input.mirrorUrl, input.credentialHelper, input.mirrorCredentialUsername),
+      "fetch",
+      "--no-recurse-submodules",
+      "--prune",
+      input.mirrorUrl,
+      "+refs/heads/*:refs/r5d/mirror/*"
+    ],
+    PROJECT_GIT_TRANSPORT_TIMEOUT_MS
+  );
   if (mirrorFetch.exitCode !== 0 && !/(couldn't find remote ref|does not have any commits|remote repository is empty|no such ref)/i.test(
     `${mirrorFetch.stderr}
 ${mirrorFetch.stdout}`
@@ -1258,13 +1277,17 @@ function removeProjectWorktrees(input) {
 }
 async function deleteProjectMirrorBranch(input) {
   (0, import_managed_paths.validateManagedBranchName)(input.branchName);
-  const deleted = await gitResultAsync(input.gitDirectory, [
-    ...(0, import_git_process_environment.gitTransportSecurityArgs)(input.mirrorUrl, input.credentialHelper, input.credentialUsername),
-    "push",
-    "--no-recurse-submodules",
-    input.mirrorUrl,
-    `:refs/heads/${input.branchName}`
-  ]);
+  const deleted = await gitResultAsync(
+    input.gitDirectory,
+    [
+      ...(0, import_git_process_environment.gitTransportSecurityArgs)(input.mirrorUrl, input.credentialHelper, input.credentialUsername),
+      "push",
+      "--no-recurse-submodules",
+      input.mirrorUrl,
+      `:refs/heads/${input.branchName}`
+    ],
+    PROJECT_GIT_TRANSPORT_TIMEOUT_MS
+  );
   if (deleted.exitCode !== 0 && !/(remote ref does not exist|unable to delete|no such ref)/i.test(`${deleted.stderr}
 ${deleted.stdout}`)) {
     throw new Error(
@@ -1284,21 +1307,50 @@ async function pushProjectMirrorHeads(input) {
     if (!await tryGitAsync(checkoutPath, ["cat-file", "-e", `${head}^{commit}`])) {
       throw new Error(`Exact publication head ${head} is unavailable for project branch ${branchName}`);
     }
+    if (!input.expectedMirrorHeads.has(branchName)) {
+      throw new Error(`Missing hidden-mirror lease for project branch ${branchName}`);
+    }
+    const expectedMirrorHead = input.expectedMirrorHeads.get(branchName) ?? null;
+    if (expectedMirrorHead !== null && !/^[0-9a-f]{40}(?:[0-9a-f]{24})?$/.test(expectedMirrorHead)) {
+      throw new Error(`Invalid hidden-mirror lease for project branch ${branchName}`);
+    }
+    const branchId = input.branchIds.get(branchName);
+    if (!branchId || !/^[A-Za-z0-9][A-Za-z0-9_-]{0,127}$/.test(branchId)) {
+      throw new Error(`Missing valid branch incarnation for project branch ${branchName}`);
+    }
+    if (expectedMirrorHead) {
+      const handoffPrefix = `refs/r5d/server-synced/${branchId}/`;
+      const markedCommits = (await gitAsync(
+        checkoutPath,
+        ["for-each-ref", "--format=%(objectname)", handoffPrefix],
+        `inspect synchronized server commits before publishing ${branchName}`
+      )).split(/\r?\n/).filter((value) => /^[0-9a-f]{40}(?:[0-9a-f]{24})?$/.test(value));
+      for (const markedCommit of markedCommits) {
+        const markerIsInLease = await tryGitAsync(checkoutPath, ["merge-base", "--is-ancestor", markedCommit, expectedMirrorHead]);
+        if (markerIsInLease && !await tryGitAsync(checkoutPath, ["merge-base", "--is-ancestor", markedCommit, head])) {
+          throw new Error(`Refusing to overwrite synchronized server commit history for project branch ${branchName}`);
+        }
+      }
+    }
     if (projectWorktreeOperationInProgress(checkoutPath)) {
       results.push({ branchName, head, pushed: false, reason: "git_operation_in_progress" });
       continue;
     }
-    await gitAsync(
+    const pushed = await gitResultAsync(
       checkoutPath,
       [
         ...(0, import_git_process_environment.gitTransportSecurityArgs)(input.mirrorUrl, input.credentialHelper, input.credentialUsername),
         "push",
         "--no-recurse-submodules",
+        `--force-with-lease=refs/heads/${branchName}:${expectedMirrorHead ?? ""}`,
         input.mirrorUrl,
-        `+${head}:refs/heads/${branchName}`
+        `${head}:refs/heads/${branchName}`
       ],
-      `push hidden project mirror for ${branchName}`
+      PROJECT_GIT_TRANSPORT_TIMEOUT_MS
     );
+    if (pushed.exitCode !== 0) {
+      throw new Error(`Push hidden project mirror for ${branchName}: ${pushed.stderr || pushed.stdout || `git exited ${pushed.exitCode}`}`);
+    }
     results.push({ branchName, head, pushed: true });
   }
   return results;
@@ -1311,14 +1363,19 @@ function assertProjectMirrorHeadsPushed(results) {
 }
 async function observeProjectMirrorHeads(input) {
   const primaryPath = branchPath(input.projectRoot, input.primaryBranchName);
-  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/*"
-  ]);
+  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}`}`);
   const observations = [];
@@ -1327,14 +1384,40 @@ async function observeProjectMirrorHeads(input) {
     const previousHead = await gitAsync(checkoutPath, ["rev-parse", "HEAD"], `resolve local project head ${branchName}`);
     const mirrorRef = `refs/r5d/mirror/${branchName}`;
     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 || await tryGitAsync(checkoutPath, ["merge-base", "--is-ancestor", previousHead, mirrorHead]))
+    const branchId = input.branchIds?.get(branchName);
+    if (branchId && !/^[A-Za-z0-9][A-Za-z0-9_-]{0,127}$/.test(branchId)) throw new Error(`Invalid branch id for ${branchName}`);
+    const handoffPrefix = branchId ? `refs/r5d/server-synced/${branchId}/` : null;
+    const handoffRows = handoffPrefix ? await gitAsync(
+      primaryPath,
+      ["for-each-ref", "--format=%(objectname) %(refname)", handoffPrefix],
+      `inspect synchronized server commits for ${branchName}`
+    ) : "";
+    const serverSyncedWorkspaceHeads = (await Promise.all(
+      handoffRows.split(/\r?\n/).map(async (row) => {
+        const separator = row.indexOf(" ");
+        if (separator < 0 || !mirrorHead) return null;
+        const markedCommit = row.slice(0, separator);
+        const ref = row.slice(separator + 1);
+        if (!/^[0-9a-f]{40}(?:[0-9a-f]{24})?$/.test(markedCommit) || !handoffPrefix || !ref.startsWith(handoffPrefix)) {
+          return null;
+        }
+        const markerIsIntegrated = markedCommit === mirrorHead || await tryGitAsync(primaryPath, ["merge-base", "--is-ancestor", markedCommit, mirrorHead]);
+        if (!markerIsIntegrated) return null;
+        const workspaceHead = ref.slice(handoffPrefix.length);
+        return /^[0-9a-f]{40}(?:[0-9a-f]{24})?$/.test(workspaceHead) ? workspaceHead : null;
+      })
+    )).filter((workspaceHead) => workspaceHead !== null).sort();
+    const fastForward = Boolean(
+      mirrorHead && mirrorHead !== previousHead && await tryGitAsync(checkoutPath, ["merge-base", "--is-ancestor", previousHead, mirrorHead])
     );
+    const serverSynced = Boolean(mirrorHead && mirrorHead !== previousHead && serverSyncedWorkspaceHeads.length > 0);
+    const shouldMove = Boolean(mirrorHead && mirrorHead !== previousHead && (input.allowNonFastForward || fastForward || serverSynced));
     observations.push({
       branchName,
       previousHead,
       mirrorHead,
-      mode: input.allowNonFastForward ? "reseed" : "fast_forward",
+      mode: input.allowNonFastForward ? "reseed" : serverSynced && !fastForward ? "server_synced" : "fast_forward",
+      serverSyncedWorkspaceHeads,
       shouldMove
     });
   }
@@ -1346,7 +1429,8 @@ async function applyObservedProjectMirrorHeads(input) {
     const { branchName, mirrorHead } = observation;
     const checkoutPath = branchPath(input.projectRoot, branchName);
     const currentHead = await gitAsync(checkoutPath, ["rev-parse", "HEAD"], `resolve local project head ${branchName}`);
-    if (!observation.shouldMove || !mirrorHead || currentHead === mirrorHead || currentHead !== observation.previousHead) {
+    const serverSyncedCovered = observation.mode !== "server_synced" || (input.serverSyncedWorkspaceCovered ? await input.serverSyncedWorkspaceCovered(observation) : false);
+    if (!observation.shouldMove || !serverSyncedCovered || !mirrorHead || currentHead === mirrorHead || currentHead !== observation.previousHead) {
       results.push({ branchName, previousHead: currentHead, mirrorHead, moved: false });
       continue;
     }
@@ -1358,14 +1442,14 @@ async function applyObservedProjectMirrorHeads(input) {
       results.push({ branchName, previousHead: currentHead, mirrorHead, moved: false });
       continue;
     }
-    if (observation.mode === "reseed") {
+    if (observation.mode === "reseed" || observation.mode === "server_synced") {
       await preserveHead(checkoutPath);
       if (!mutationAllowed()) {
         results.push({ branchName, previousHead: currentHead, mirrorHead, moved: false });
         continue;
       }
     }
-    const action = observation.mode === "reseed" ? "reseed" : "fast-forward";
+    const action = observation.mode === "reseed" ? "reseed" : observation.mode === "server_synced" ? "adopt server commit" : "fast-forward";
     await gitAsync(checkoutPath, ["read-tree", "--reset", mirrorHead], `${action} project index ${branchName}`);
     await gitAsync(
       checkoutPath,

package/dist/mjs/main.mjs

@@ -4073,7 +4073,7 @@ async function startWorker(options) {
     }
     return heads;
   };
-  const pushChangedProjectHeads = async (activeMountIds, publishedHead, publicationHeads, suppressedMountIds = /* @__PURE__ */ new Set()) => {
+  const pushChangedProjectHeads = async (activeMountIds, publishedHead, publicationHeads, expectedMirrorHeads, suppressedMountIds = /* @__PURE__ */ new Set()) => {
     const active = new Set(activeMountIds);
     for (const project of projectConfigById.values()) {
       if (!readyProjectIds.has(project.projectId) || !repositoryMirrorWritesAllowed(project)) continue;
@@ -4088,6 +4088,12 @@ async function startWorker(options) {
         }
       }
       if (changed.size === 0) continue;
+      const branchLeases = /* @__PURE__ */ new Map();
+      for (const branchName of changed.keys()) {
+        const mountId = projectMountId(project.projectId, branchName);
+        if (!expectedMirrorHeads.has(mountId)) throw new Error(`Missing observed hidden-mirror lease for active project mount ${mountId}`);
+        branchLeases.set(branchName, expectedMirrorHeads.get(mountId) ?? null);
+      }
       const connection = projectConnection(project);
       const results = await pushProjectMirrorHeads({
         projectRoot: configuredProjectRoot(projectsRoot, project),
@@ -4096,7 +4102,9 @@ async function startWorker(options) {
         credentialHelper: connection.credentialHelper,
         credentialUsername: connection.mirrorCredentialUsername,
         onlyBranches: new Set(changed.keys()),
-        publicationHeads: changed
+        publicationHeads: changed,
+        expectedMirrorHeads: branchLeases,
+        branchIds: new Map(project.branches.map(({ branchId, branchName }) => [branchName, branchId]))
       });
       assertProjectMirrorHeadsPushed(results);
       for (const result of results) {
@@ -4160,7 +4168,8 @@ async function startWorker(options) {
             mirrorUrl: connection.mirrorUrl,
             credentialHelper: connection.credentialHelper,
             credentialUsername: connection.mirrorCredentialUsername,
-            allowNonFastForward: input.allowNonFastForward
+            allowNonFastForward: input.allowNonFastForward,
+            branchIds: new Map(project.branches.map(({ branchId, branchName }) => [branchName, branchId]))
           })
         });
       } catch (error) {
@@ -4173,7 +4182,7 @@ async function startWorker(options) {
     }
     return bundles;
   };
-  const applyObservedProjectHeadsAfterInboundWorkspace = async (bundles, activeMountIds, requireObservedHeads) => {
+  const applyObservedProjectHeadsAfterInboundWorkspace = async (bundles, activeMountIds, requireObservedHeads, integratedWorkspaceHead) => {
     const active = new Set(activeMountIds);
     for (const bundle of bundles) {
       const project = projectConfigById.get(bundle.projectId);
@@ -4185,7 +4194,16 @@ async function startWorker(options) {
           projectRoot: bundle.projectRoot,
           primaryBranchName: bundle.primaryBranchName,
           observations,
-          branchMutationAllowed: (branchName, checkoutPath) => !projectBranchMountBusy(project.projectId, branchName, checkoutPath)
+          branchMutationAllowed: (branchName, checkoutPath) => !projectBranchMountBusy(project.projectId, branchName, checkoutPath),
+          serverSyncedWorkspaceCovered: async (observation) => {
+            if (!integratedWorkspaceHead) return false;
+            for (const workspaceHead of observation.serverSyncedWorkspaceHeads) {
+              if (await tryGitAsync(["merge-base", "--is-ancestor", workspaceHead, integratedWorkspaceHead], { cwd: workspaceShadowRoot })) {
+                return true;
+              }
+            }
+            return false;
+          }
         });
         if (requireObservedHeads) {
           for (const observation of observations) {
@@ -4310,6 +4328,12 @@ async function startWorker(options) {
     const outerRemediation = input.trigger.type === "remediation" || input.trigger.type === "remediation_confirm";
     const mounts = outerRemediation ? workspaceGitMountsForRemediation(configuredMounts) : configuredMounts;
     const observedProjectHeads = outerRemediation ? [] : await observeProjectHeadsBeforeOuterWorkspace({ allowNonFastForward: false, failClosed: false });
+    const expectedMirrorHeads = /* @__PURE__ */ new Map();
+    for (const bundle of observedProjectHeads) {
+      for (const observation of bundle.observations) {
+        expectedMirrorHeads.set(projectMountId(bundle.projectId, observation.branchName), observation.mirrorHead);
+      }
+    }
     const inboundMoveMountIds = new Set(
       observedProjectHeads.flatMap(
         ({ projectId, observations }) => observations.filter(({ shouldMove }) => shouldMove).map(({ branchName }) => projectMountId(projectId, branchName))
@@ -4331,12 +4355,17 @@ async function startWorker(options) {
       requiredAncestorHeads: input.requiredAncestorHeads,
       assertStillAdmitted: input.assertStillAdmitted,
       afterWorkspacePublished: outerRemediation ? void 0 : async ({ activeMountIds, publishedHead }) => {
-        await pushChangedProjectHeads(activeMountIds, publishedHead, publicationHeads, inboundMoveMountIds);
+        await pushChangedProjectHeads(activeMountIds, publishedHead, publicationHeads, expectedMirrorHeads, inboundMoveMountIds);
       }
     });
     input.assertStillAdmitted?.();
     if (["no_change", "updated", "pushed"].includes(result.outcome) && !outerRemediation) {
-      await applyObservedProjectHeadsAfterInboundWorkspace(observedProjectHeads, result.activeMountIds, false);
+      await applyObservedProjectHeadsAfterInboundWorkspace(
+        observedProjectHeads,
+        result.activeMountIds,
+        false,
+        result.localHead ?? result.remoteHead
+      );
     }
     return mapWorkspaceGitResult(input.attemptId, input.trigger, result);
   };
@@ -4431,11 +4460,12 @@ async function startWorker(options) {
         }
         try {
           assertStillAdmitted();
+          const hasDurableBranchDeletion = projectWorkspaceState.tombstones.some((tombstone) => tombstone.kind === "branch");
           return await performWorkspaceSync({
             attemptId,
             trigger: input.trigger,
-            confirmedLargeDiff: input.confirmedLargeDiff,
-            confirmationReason: input.confirmationReason,
+            confirmedLargeDiff: input.confirmedLargeDiff === true || hasDurableBranchDeletion,
+            confirmationReason: input.confirmationReason ?? (hasDurableBranchDeletion ? "durable project branch deletion" : void 0),
             resetToCanonical: input.resetToCanonical,
             requiredAncestorHeads: input.requiredAncestorHeads,
             assertStillAdmitted
@@ -4972,9 +5002,12 @@ async function startWorker(options) {
             );
           }
         };
+        const hasDurableBranchDeletion = projectWorkspaceState.tombstones.some((tombstone) => tombstone.kind === "branch");
         const result = await performWorkspaceSync({
           attemptId: crypto.randomUUID(),
           trigger: { type: "connect" },
+          confirmedLargeDiff: hasDurableBranchDeletion,
+          confirmationReason: hasDurableBranchDeletion ? "durable project branch deletion" : void 0,
           resetToCanonical: workspaceConfigurationResetToCanonicalIsAllowed(message.resetToCanonical, incidentDeferral.incidentId),
           assertStillAdmitted: assertConfigurationSyncStillAdmitted
         });
@@ -5216,7 +5249,9 @@ async function startWorker(options) {
           ptyEnvFilesV1: true,
           workspaceRemediationAncestorGuardV1: true,
           workspaceIncidentConfigDeferralV1: true,
-          workspaceConfigResetToCanonicalV1: true
+          workspaceConfigResetToCanonicalV1: true,
+          projectBranchDeletionFastAckV1: true,
+          projectMirrorLeaseV1: true
         },
         projectRoot: projectsRoot,
         artifactRoot,
@@ -5470,23 +5505,15 @@ async function startWorker(options) {
             return true;
           });
           if (deletionNeedsSync) {
-            const result = await runWorkspaceSync({
-              trigger: {
+            scheduleAutomaticWorkspaceSync(
+              {
                 type: "manual",
                 projectId: message.projectId,
                 branchName: message.branchName,
                 detail: "deleted project branch"
               },
-              confirmedLargeDiff: true,
-              confirmationReason: "explicit project branch deletion",
-              sendResult: false
-            });
-            if (result.outcome === "failed" || result.outcome === "conflict_blocked" || result.outcome === "large_diff_blocked") {
-              throw new Error(result.error ?? `Project branch deletion workspace sync ended with ${result.outcome}`);
-            }
-            if (pendingMirrorDeletes.has(deletionKey)) {
-              throw new Error("Project branch deletion did not remove the hidden mirror ref");
-            }
+              0
+            );
           }
           sendWorkerMessage(ws, {
             type: "operation_result",

package/dist/mjs/package.json

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

package/dist/mjs/project-worktrees.mjs

@@ -11,6 +11,7 @@ const PROJECT_WORKTREE_SNAPSHOT_MANIFEST_VERSION = 1;
 const MAX_PROJECT_WORKTREE_SNAPSHOT_MANIFEST_BYTES = 64 * 1024;
 const PROJECT_WORKTREE_SNAPSHOT_OWNER_SESSION_ID = randomUUID();
 const UUID_PATTERN = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
+const PROJECT_GIT_TRANSPORT_TIMEOUT_MS = 3e4;
 const PROJECT_WORKTREE_SNAPSHOT_NAME = new RegExp(
   `^${PROJECT_WORKTREE_SNAPSHOT_PREFIX.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}([1-9]\\d*)-([A-Za-z0-9]{6})$`
 );
@@ -80,7 +81,7 @@ function git(cwd, args, action) {
 function tryGit(cwd, args) {
   return gitResult(cwd, args).exitCode === 0;
 }
-async function gitResultAsync(cwd, args) {
+async function gitResultAsync(cwd, args, timeoutMs) {
   const subprocess = Bun.spawn(gitCommandArgs(args), {
     cwd,
     stdin: "ignore",
@@ -88,12 +89,22 @@ async function gitResultAsync(cwd, args) {
     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() };
+  let timedOut = false;
+  const timeout = timeoutMs ? setTimeout(() => {
+    timedOut = true;
+    subprocess.kill("SIGKILL");
+  }, timeoutMs) : void 0;
+  try {
+    const [stdout, stderr, exitCode] = await Promise.all([
+      new Response(subprocess.stdout).text(),
+      new Response(subprocess.stderr).text(),
+      subprocess.exited
+    ]);
+    if (timedOut) throw new Error(`Git transport timed out after ${timeoutMs}ms`);
+    return { exitCode, stdout: stdout.trim(), stderr: stderr.trim() };
+  } finally {
+    if (timeout) clearTimeout(timeout);
+  }
 }
 async function gitAsync(cwd, args, action) {
   const result = await gitResultAsync(cwd, args);
@@ -808,25 +819,33 @@ async function configureRepository(input) {
   }
 }
 async function fetchProjectHeads(input) {
-  const originFetch = await gitResultAsync(input.primaryPath, [
-    ...gitTransportSecurityArgs(input.originUrl, input.credentialHelper, input.originCredentialUsername),
-    "fetch",
-    "--no-recurse-submodules",
-    "--prune",
-    "origin",
-    "+refs/heads/*:refs/remotes/origin/*"
-  ]);
+  const originFetch = await gitResultAsync(
+    input.primaryPath,
+    [
+      ...gitTransportSecurityArgs(input.originUrl, input.credentialHelper, input.originCredentialUsername),
+      "fetch",
+      "--no-recurse-submodules",
+      "--prune",
+      "origin",
+      "+refs/heads/*:refs/remotes/origin/*"
+    ],
+    PROJECT_GIT_TRANSPORT_TIMEOUT_MS
+  );
   if (originFetch.exitCode !== 0) {
     throw new Error(`Fetch project origin: ${originFetch.stderr || originFetch.stdout || `git exited ${originFetch.exitCode}`}`);
   }
-  const mirrorFetch = await gitResultAsync(input.primaryPath, [
-    ...gitTransportSecurityArgs(input.mirrorUrl, input.credentialHelper, input.mirrorCredentialUsername),
-    "fetch",
-    "--no-recurse-submodules",
-    "--prune",
-    input.mirrorUrl,
-    "+refs/heads/*:refs/r5d/mirror/*"
-  ]);
+  const mirrorFetch = await gitResultAsync(
+    input.primaryPath,
+    [
+      ...gitTransportSecurityArgs(input.mirrorUrl, input.credentialHelper, input.mirrorCredentialUsername),
+      "fetch",
+      "--no-recurse-submodules",
+      "--prune",
+      input.mirrorUrl,
+      "+refs/heads/*:refs/r5d/mirror/*"
+    ],
+    PROJECT_GIT_TRANSPORT_TIMEOUT_MS
+  );
   if (mirrorFetch.exitCode !== 0 && !/(couldn't find remote ref|does not have any commits|remote repository is empty|no such ref)/i.test(
     `${mirrorFetch.stderr}
 ${mirrorFetch.stdout}`
@@ -1205,13 +1224,17 @@ function removeProjectWorktrees(input) {
 }
 async function deleteProjectMirrorBranch(input) {
   validateManagedBranchName(input.branchName);
-  const deleted = await gitResultAsync(input.gitDirectory, [
-    ...gitTransportSecurityArgs(input.mirrorUrl, input.credentialHelper, input.credentialUsername),
-    "push",
-    "--no-recurse-submodules",
-    input.mirrorUrl,
-    `:refs/heads/${input.branchName}`
-  ]);
+  const deleted = await gitResultAsync(
+    input.gitDirectory,
+    [
+      ...gitTransportSecurityArgs(input.mirrorUrl, input.credentialHelper, input.credentialUsername),
+      "push",
+      "--no-recurse-submodules",
+      input.mirrorUrl,
+      `:refs/heads/${input.branchName}`
+    ],
+    PROJECT_GIT_TRANSPORT_TIMEOUT_MS
+  );
   if (deleted.exitCode !== 0 && !/(remote ref does not exist|unable to delete|no such ref)/i.test(`${deleted.stderr}
 ${deleted.stdout}`)) {
     throw new Error(
@@ -1231,21 +1254,50 @@ async function pushProjectMirrorHeads(input) {
     if (!await tryGitAsync(checkoutPath, ["cat-file", "-e", `${head}^{commit}`])) {
       throw new Error(`Exact publication head ${head} is unavailable for project branch ${branchName}`);
     }
+    if (!input.expectedMirrorHeads.has(branchName)) {
+      throw new Error(`Missing hidden-mirror lease for project branch ${branchName}`);
+    }
+    const expectedMirrorHead = input.expectedMirrorHeads.get(branchName) ?? null;
+    if (expectedMirrorHead !== null && !/^[0-9a-f]{40}(?:[0-9a-f]{24})?$/.test(expectedMirrorHead)) {
+      throw new Error(`Invalid hidden-mirror lease for project branch ${branchName}`);
+    }
+    const branchId = input.branchIds.get(branchName);
+    if (!branchId || !/^[A-Za-z0-9][A-Za-z0-9_-]{0,127}$/.test(branchId)) {
+      throw new Error(`Missing valid branch incarnation for project branch ${branchName}`);
+    }
+    if (expectedMirrorHead) {
+      const handoffPrefix = `refs/r5d/server-synced/${branchId}/`;
+      const markedCommits = (await gitAsync(
+        checkoutPath,
+        ["for-each-ref", "--format=%(objectname)", handoffPrefix],
+        `inspect synchronized server commits before publishing ${branchName}`
+      )).split(/\r?\n/).filter((value) => /^[0-9a-f]{40}(?:[0-9a-f]{24})?$/.test(value));
+      for (const markedCommit of markedCommits) {
+        const markerIsInLease = await tryGitAsync(checkoutPath, ["merge-base", "--is-ancestor", markedCommit, expectedMirrorHead]);
+        if (markerIsInLease && !await tryGitAsync(checkoutPath, ["merge-base", "--is-ancestor", markedCommit, head])) {
+          throw new Error(`Refusing to overwrite synchronized server commit history for project branch ${branchName}`);
+        }
+      }
+    }
     if (projectWorktreeOperationInProgress(checkoutPath)) {
       results.push({ branchName, head, pushed: false, reason: "git_operation_in_progress" });
       continue;
     }
-    await gitAsync(
+    const pushed = await gitResultAsync(
       checkoutPath,
       [
         ...gitTransportSecurityArgs(input.mirrorUrl, input.credentialHelper, input.credentialUsername),
         "push",
         "--no-recurse-submodules",
+        `--force-with-lease=refs/heads/${branchName}:${expectedMirrorHead ?? ""}`,
         input.mirrorUrl,
-        `+${head}:refs/heads/${branchName}`
+        `${head}:refs/heads/${branchName}`
       ],
-      `push hidden project mirror for ${branchName}`
+      PROJECT_GIT_TRANSPORT_TIMEOUT_MS
     );
+    if (pushed.exitCode !== 0) {
+      throw new Error(`Push hidden project mirror for ${branchName}: ${pushed.stderr || pushed.stdout || `git exited ${pushed.exitCode}`}`);
+    }
     results.push({ branchName, head, pushed: true });
   }
   return results;
@@ -1258,14 +1310,19 @@ function assertProjectMirrorHeadsPushed(results) {
 }
 async function observeProjectMirrorHeads(input) {
   const primaryPath = branchPath(input.projectRoot, input.primaryBranchName);
-  const fetch = await gitResultAsync(primaryPath, [
-    ...gitTransportSecurityArgs(input.mirrorUrl, input.credentialHelper, input.credentialUsername),
-    "fetch",
-    "--no-recurse-submodules",
-    "--prune",
-    input.mirrorUrl,
-    "+refs/heads/*:refs/r5d/mirror/*"
-  ]);
+  const fetch = await gitResultAsync(
+    primaryPath,
+    [
+      ...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}`}`);
   const observations = [];
@@ -1274,14 +1331,40 @@ async function observeProjectMirrorHeads(input) {
     const previousHead = await gitAsync(checkoutPath, ["rev-parse", "HEAD"], `resolve local project head ${branchName}`);
     const mirrorRef = `refs/r5d/mirror/${branchName}`;
     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 || await tryGitAsync(checkoutPath, ["merge-base", "--is-ancestor", previousHead, mirrorHead]))
+    const branchId = input.branchIds?.get(branchName);
+    if (branchId && !/^[A-Za-z0-9][A-Za-z0-9_-]{0,127}$/.test(branchId)) throw new Error(`Invalid branch id for ${branchName}`);
+    const handoffPrefix = branchId ? `refs/r5d/server-synced/${branchId}/` : null;
+    const handoffRows = handoffPrefix ? await gitAsync(
+      primaryPath,
+      ["for-each-ref", "--format=%(objectname) %(refname)", handoffPrefix],
+      `inspect synchronized server commits for ${branchName}`
+    ) : "";
+    const serverSyncedWorkspaceHeads = (await Promise.all(
+      handoffRows.split(/\r?\n/).map(async (row) => {
+        const separator = row.indexOf(" ");
+        if (separator < 0 || !mirrorHead) return null;
+        const markedCommit = row.slice(0, separator);
+        const ref = row.slice(separator + 1);
+        if (!/^[0-9a-f]{40}(?:[0-9a-f]{24})?$/.test(markedCommit) || !handoffPrefix || !ref.startsWith(handoffPrefix)) {
+          return null;
+        }
+        const markerIsIntegrated = markedCommit === mirrorHead || await tryGitAsync(primaryPath, ["merge-base", "--is-ancestor", markedCommit, mirrorHead]);
+        if (!markerIsIntegrated) return null;
+        const workspaceHead = ref.slice(handoffPrefix.length);
+        return /^[0-9a-f]{40}(?:[0-9a-f]{24})?$/.test(workspaceHead) ? workspaceHead : null;
+      })
+    )).filter((workspaceHead) => workspaceHead !== null).sort();
+    const fastForward = Boolean(
+      mirrorHead && mirrorHead !== previousHead && await tryGitAsync(checkoutPath, ["merge-base", "--is-ancestor", previousHead, mirrorHead])
     );
+    const serverSynced = Boolean(mirrorHead && mirrorHead !== previousHead && serverSyncedWorkspaceHeads.length > 0);
+    const shouldMove = Boolean(mirrorHead && mirrorHead !== previousHead && (input.allowNonFastForward || fastForward || serverSynced));
     observations.push({
       branchName,
       previousHead,
       mirrorHead,
-      mode: input.allowNonFastForward ? "reseed" : "fast_forward",
+      mode: input.allowNonFastForward ? "reseed" : serverSynced && !fastForward ? "server_synced" : "fast_forward",
+      serverSyncedWorkspaceHeads,
       shouldMove
     });
   }
@@ -1293,7 +1376,8 @@ async function applyObservedProjectMirrorHeads(input) {
     const { branchName, mirrorHead } = observation;
     const checkoutPath = branchPath(input.projectRoot, branchName);
     const currentHead = await gitAsync(checkoutPath, ["rev-parse", "HEAD"], `resolve local project head ${branchName}`);
-    if (!observation.shouldMove || !mirrorHead || currentHead === mirrorHead || currentHead !== observation.previousHead) {
+    const serverSyncedCovered = observation.mode !== "server_synced" || (input.serverSyncedWorkspaceCovered ? await input.serverSyncedWorkspaceCovered(observation) : false);
+    if (!observation.shouldMove || !serverSyncedCovered || !mirrorHead || currentHead === mirrorHead || currentHead !== observation.previousHead) {
       results.push({ branchName, previousHead: currentHead, mirrorHead, moved: false });
       continue;
     }
@@ -1305,14 +1389,14 @@ async function applyObservedProjectMirrorHeads(input) {
       results.push({ branchName, previousHead: currentHead, mirrorHead, moved: false });
       continue;
     }
-    if (observation.mode === "reseed") {
+    if (observation.mode === "reseed" || observation.mode === "server_synced") {
       await preserveHead(checkoutPath);
       if (!mutationAllowed()) {
         results.push({ branchName, previousHead: currentHead, mirrorHead, moved: false });
         continue;
       }
     }
-    const action = observation.mode === "reseed" ? "reseed" : "fast-forward";
+    const action = observation.mode === "reseed" ? "reseed" : observation.mode === "server_synced" ? "adopt server commit" : "fast-forward";
     await gitAsync(checkoutPath, ["read-tree", "--reset", mirrorHead], `${action} project index ${branchName}`);
     await gitAsync(
       checkoutPath,

package/dist/types/project-worktrees.d.ts

@@ -175,6 +175,10 @@ export declare function pushProjectMirrorHeads(input: {
     onlyBranches?: ReadonlySet<string>;
     /** Exact pre-projection commits to publish after the outer tree is reachable. */
     publicationHeads?: ReadonlyMap<string, string>;
+    /** Hidden-mirror tips observed before the corresponding outer projection. */
+    expectedMirrorHeads: ReadonlyMap<string, string | null>;
+    /** Durable branch incarnations used to scope server-authored handoff refs. */
+    branchIds: ReadonlyMap<string, string>;
 }): Promise<Array<{
     branchName: string;
     head: string;
@@ -200,7 +204,8 @@ export type ProjectMirrorHeadObservation = {
     branchName: string;
     previousHead: string;
     mirrorHead: string | null;
-    mode: "fast_forward" | "reseed";
+    mode: "fast_forward" | "reseed" | "server_synced";
+    serverSyncedWorkspaceHeads: string[];
     shouldMove: boolean;
 };
 /**
@@ -210,6 +215,7 @@ export type ProjectMirrorHeadObservation = {
  */
 export declare function observeProjectMirrorHeads(input: Omit<ProjectMirrorHeadUpdateInput, "branchMutationAllowed"> & {
     allowNonFastForward: boolean;
+    branchIds?: ReadonlyMap<string, string>;
 }): Promise<ProjectMirrorHeadObservation[]>;
 /** Apply only previously observed object ids; this function never refetches. */
 export declare function applyObservedProjectMirrorHeads(input: {
@@ -218,6 +224,8 @@ export declare function applyObservedProjectMirrorHeads(input: {
     observations: readonly ProjectMirrorHeadObservation[];
     /** Rechecked immediately before refs or the index move. */
     branchMutationAllowed?: (branchName: string, checkoutPath: string) => boolean;
+    /** Proves the visible outer workspace has hydrated the server commit's exact source generation. */
+    serverSyncedWorkspaceCovered?: (observation: ProjectMirrorHeadObservation) => Promise<boolean>;
 }): Promise<Array<{
     branchName: string;
     previousHead: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ricsam/r5d-worker",
-  "version": "0.0.92",
+  "version": "0.0.94",
   "type": "module",
   "main": "./dist/cjs/main.cjs",
   "module": "./dist/mjs/main.mjs",