@ricsam/r5d-worker 0.0.59 → 0.0.60

package/dist/mjs/main.mjs

@@ -13,27 +13,19 @@ import {
 } from "./heartbeat.mjs";
 import { terminateProcessTree } from "./process-tree.mjs";
 import { openWorkerPortForwardRelay } from "./port-forward-client.mjs";
-import {
-  applyWorkspaceIncidentUpdate,
-  releasePendingWorkspaceHead,
-  WorkspaceIncidentOrderingFence
-} from "./workspace-incident-state.mjs";
+import { applyWorkspaceIncidentUpdate, releasePendingWorkspaceHead, WorkspaceIncidentOrderingFence } from "./workspace-incident-state.mjs";
 import { acquireWorkspaceCommandMutation, runWorkspaceCommand } from "./workspace-command-sync-policy.mjs";
 import {
-  WORKSPACE_CHECKPOINT_QUIET_MS,
+  WORKSPACE_PUBLICATION_QUIET_MS,
   WORKSPACE_IDLE_SAFETY_SCAN_MS,
-  ExplicitWorkspaceCheckpointQueue,
+  ExplicitWorkspacePublicationQueue,
   WorkspaceManifestRevisionFence,
   processWorkspaceConvergenceState,
-  processWorkspaceFilesystemWriterGate,
-  waitForWorkspaceCheckpointOnShutdown,
-  workspaceCheckpointIncidentAction,
-  workspaceCheckpointTelemetry
+  waitForWorkspacePublicationOnShutdown,
+  workspacePublicationIncidentAction,
+  workspacePublicationTelemetry
 } from "./workspace-convergence.mjs";
-import {
-  acquireWorkspaceManifestVisibleLease,
-  inspectWorkspaceManifestAdmission
-} from "./workspace-manifest-admission.mjs";
+import { inspectWorkspaceManifestFilesystem } from "./workspace-manifest-admission.mjs";
 import {
   isRetryableWorkerServerStatus,
   superviseWorkerRuntime,
@@ -64,7 +56,6 @@ const cancelledProcessRuns = /* @__PURE__ */ new Set();
 const activePtys = /* @__PURE__ */ new Map();
 let currentWorkerSocket = null;
 const workspaceSyncSingleFlight = new WorkspaceSyncSingleFlight();
-const workspaceFilesystemWriters = processWorkspaceFilesystemWriterGate();
 let githubCredential = null;
 let visibleGitIdentity = null;
 function defaultConfigPath() {
@@ -786,25 +777,13 @@ function fallbackInternalRemoteUrl(baseUrl, projectId) {
 }
 function visibleCheckoutRemoteFor(input) {
   const canonicalCheckout = input.manifest?.canonicalCheckouts?.find((checkout) => checkout.branchName === input.branchName);
-  const isCanonicalManifestBranch = Boolean(canonicalCheckout);
-  const usesCanonicalRemote = isCanonicalManifestBranch || !input.manifest?.repoHttpUrl;
-  if (usesCanonicalRemote) {
-    return {
-      remoteUrl: fallbackInternalRemoteUrl(input.baseUrl, input.projectId),
-      authHeader: `Authorization: Bearer ${input.token}`,
-      persistAuth: false,
-      reconcileExistingOrigin: isCanonicalManifestBranch,
-      requireRemoteBranch: isCanonicalManifestBranch,
-      requiredBaseCommit: canonicalCheckout?.scaffoldCommitHash ?? null
-    };
-  }
   return {
-    remoteUrl: input.manifest?.repoHttpUrl ?? fallbackInternalRemoteUrl(input.baseUrl, input.projectId),
-    authHeader: input.manifest?.repoAuthHeader ?? null,
-    persistAuth: true,
-    reconcileExistingOrigin: Boolean(input.manifest?.repoHttpUrl),
-    requireRemoteBranch: false,
-    requiredBaseCommit: null
+    remoteUrl: fallbackInternalRemoteUrl(input.baseUrl, input.projectId),
+    authHeader: `Authorization: Bearer ${input.token}`,
+    persistAuth: false,
+    reconcileExistingOrigin: true,
+    requireRemoteBranch: true,
+    requiredBaseCommit: canonicalCheckout?.scaffoldCommitHash ?? null
   };
 }
 function gitExtraHeaderUrlForRemote(remoteUrl) {
@@ -1025,9 +1004,11 @@ function checkoutVisibleBranch(input) {
 }
 function migrateExistingCheckoutToRequiredRemote(input) {
   if (originRemoteUrl(input.branchPath) === input.remoteUrl) return;
-  if (hasWorktreeChanges(input.branchPath)) {
+  const dirtyWorkingTree = hasWorktreeChanges(input.branchPath);
+  if (dirtyWorkingTree && input.requiredBaseCommit) {
     throw new Error(`Cannot migrate dirty checkout for ${input.branchName} to its canonical remote`);
   }
+  const preserveWorkingTree = dirtyWorkingTree;
   runGit(
     visibleCheckoutFetchArgs("--no-tags", input.remoteUrl, `+refs/heads/${input.branchName}:refs/remotes/origin/${input.branchName}`),
     {
@@ -1042,11 +1023,12 @@ function migrateExistingCheckoutToRequiredRemote(input) {
   if (input.requiredBaseCommit && (!tryGit(["cat-file", "-e", `${input.requiredBaseCommit}^{commit}`], { cwd: input.branchPath }) || !tryGit(["merge-base", "--is-ancestor", input.requiredBaseCommit, canonicalRemoteRef], { cwd: input.branchPath }))) {
     throw new Error(`Canonical branch ${input.branchName} is not derived from required scaffold ${input.requiredBaseCommit}`);
   }
+  ensureOriginRemote(input.branchPath, input.remoteUrl);
+  if (preserveWorkingTree) return;
   if (tryGit(["rev-parse", "--verify", "HEAD"], { cwd: input.branchPath })) {
     const previousHead = runGit(["rev-parse", "HEAD"], { cwd: input.branchPath });
     runGit(["update-ref", `refs/r5d/pre-canonical-checkout/${previousHead}`, previousHead], { cwd: input.branchPath });
   }
-  ensureOriginRemote(input.branchPath, input.remoteUrl);
   runGit(["checkout", "--no-recurse-submodules", "-B", input.branchName, `origin/${input.branchName}`], {
     cwd: input.branchPath
   });
@@ -1139,7 +1121,7 @@ function ensureVisibleGitCheckout(input) {
   configureVisibleGitIdentity(branchPath, visibleGitIdentity, runGit);
   return branchPath;
 }
-function ensureBranchWorkspace(input) {
+function ensureBranchWorktree(input) {
   const defaultBranch = input.manifest?.defaultBranch || "main";
   const remote = visibleCheckoutRemoteFor(input);
   return {
@@ -1172,7 +1154,7 @@ function resolveWorkerSessionTarget(input) {
   }
   const manifest = input.manifestByProjectId.get(input.target.projectId);
   const projectRoot = projectRootFor(input.projectsRoot, input.target.projectId, input.manifestByProjectId);
-  const workspace = ensureBranchWorkspace({
+  const worktree = ensureBranchWorktree({
     projectId: input.target.projectId,
     baseUrl: input.baseUrl,
     token: input.token,
@@ -1181,7 +1163,7 @@ function resolveWorkerSessionTarget(input) {
     branchName: input.target.branchName,
     manifest
   });
-  return { target: input.target, rootPath: workspace.branchPath, manifest };
+  return { target: input.target, rootPath: worktree.branchPath, manifest };
 }
 function workspaceSyncCheckoutTargets(input) {
   const selected = /* @__PURE__ */ new Map();
@@ -2386,15 +2368,15 @@ async function startWorker(options) {
   const workspaceConvergence = processWorkspaceConvergenceState(path.join(syncRoot, "workspace-convergence.json"));
   const workspaceManifestRevision = new WorkspaceManifestRevisionFence();
   let workspaceReady = false;
-  let workspaceCheckpointTimer;
+  let workspacePublicationTimer;
   let workspaceSafetyScan;
   let workspaceManifestHydrationTimer;
   let workspaceManifestHydrationInFlight = false;
   let workspaceSafetyScanInFlight = false;
   let workspaceHeadConvergenceInFlight = false;
   let pendingWorkspaceHead;
-  let pendingCheckpoint;
-  const explicitWorkspaceCheckpoints = new ExplicitWorkspaceCheckpointQueue();
+  let pendingPublication;
+  const explicitWorkspacePublications = new ExplicitWorkspacePublicationQueue();
   let terminalReplayTimer;
   let workspaceSyncRequestsInFlight = 0;
   let sessionArtifactSyncRequestsInFlight = 0;
@@ -2441,121 +2423,110 @@ async function startWorker(options) {
         })
       );
     } catch (error) {
-      process.stderr.write(
-        `[r5d-worker] failed to send workspace readiness: ${error instanceof Error ? error.message : String(error)}
-`
-      );
+      process.stderr.write(`[r5d-worker] failed to send workspace readiness: ${error instanceof Error ? error.message : String(error)}
+`);
     }
   };
-  const workerHasActiveWriter = () => activeProcesses.size > 0 || activePtys.size > 0 || cliUpdateInProgress;
   const targetMayMutateVisibleWorkspace = (target) => target.type === "project" || target.rootProfile === "visible_projects";
-  const armWorkspaceCheckpoint = (trigger, options2 = { delayMs: WORKSPACE_CHECKPOINT_QUIET_MS }) => {
+  const armWorkspacePublication = (trigger, options2 = { delayMs: WORKSPACE_PUBLICATION_QUIET_MS }) => {
     workspaceConvergence.schedule();
     if (currentWorkerSocket !== ws || ws.readyState !== WebSocket.OPEN) return;
     sendWorkspaceReady();
-    if (options2.requestId && !explicitWorkspaceCheckpoints.schedule({ requestId: options2.requestId, trigger }, pendingCheckpoint?.requestId)) {
+    if (options2.requestId && !explicitWorkspacePublications.schedule({ requestId: options2.requestId, trigger }, pendingPublication?.requestId)) {
       return;
     }
-    if (!options2.requestId && explicitWorkspaceCheckpoints.hasScheduled()) return;
-    if (workspaceCheckpointTimer) clearTimeout(workspaceCheckpointTimer);
-    workspaceCheckpointTimer = setTimeout(() => {
-      workspaceCheckpointTimer = void 0;
-      if (options2.requestId) explicitWorkspaceCheckpoints.consumeScheduled(options2.requestId);
-      if (currentWorkerSocket !== ws || ws.readyState !== WebSocket.OPEN) return;
-      if (!workspaceReady || !workspaceRemoteUrl) {
-        armWorkspaceCheckpoint(trigger, { delayMs: 1e3, ...options2.requestId ? { requestId: options2.requestId } : {} });
-        return;
-      }
-      if (activeWorkspaceIncidentId) {
-        workspaceConvergence.block();
-        sendWorkspaceReady();
-        if (workspaceCheckpointIncidentAction(options2.requestId) === "defer_automatic") return;
-        if (pendingCheckpoint) {
-          explicitWorkspaceCheckpoints.enqueue({ requestId: options2.requestId, trigger }, pendingCheckpoint.requestId);
+    if (!options2.requestId && explicitWorkspacePublications.hasScheduled()) return;
+    if (workspacePublicationTimer) clearTimeout(workspacePublicationTimer);
+    workspacePublicationTimer = setTimeout(
+      () => {
+        workspacePublicationTimer = void 0;
+        if (options2.requestId) explicitWorkspacePublications.consumeScheduled(options2.requestId);
+        if (currentWorkerSocket !== ws || ws.readyState !== WebSocket.OPEN) return;
+        if (!workspaceReady || !workspaceRemoteUrl) {
+          armWorkspacePublication(trigger, { delayMs: 1e3, ...options2.requestId ? { requestId: options2.requestId } : {} });
+          return;
+        }
+        if (activeWorkspaceIncidentId) {
+          workspaceConvergence.block();
+          sendWorkspaceReady();
+          if (workspacePublicationIncidentAction(options2.requestId) === "defer_automatic") return;
+          if (pendingPublication) {
+            explicitWorkspacePublications.enqueue({ requestId: options2.requestId, trigger }, pendingPublication.requestId);
+            return;
+          }
+          const snapshot2 = workspaceConvergence.snapshot();
+          pendingPublication = {
+            requestId: options2.requestId,
+            trigger,
+            dirtyGeneration: snapshot2.dirtyGeneration,
+            explicit: true,
+            workInFlight: false,
+            requestedAt: Date.now()
+          };
+          try {
+            ws.send(
+              JSON.stringify({
+                type: "workspace_publication_request",
+                requestId: options2.requestId,
+                trigger,
+                dirtyGeneration: snapshot2.dirtyGeneration,
+                localHead: snapshot2.localHead,
+                desiredCanonicalHead: snapshot2.desiredCanonicalHead
+              })
+            );
+          } catch (error) {
+            pendingPublication = void 0;
+            workspaceConvergence.defer();
+            process.stderr.write(
+              `[r5d-worker] failed to request blocked workspace publication authority: ${error instanceof Error ? error.message : String(error)}
+`
+            );
+            armWorkspacePublication(trigger, { delayMs: 1e3, requestId: options2.requestId });
+          }
           return;
         }
-        const snapshot2 = workspaceConvergence.snapshot();
-        pendingCheckpoint = {
-          requestId: options2.requestId,
+        if (pendingPublication) {
+          armWorkspacePublication(trigger, { delayMs: 1e3, ...options2.requestId ? { requestId: options2.requestId } : {} });
+          return;
+        }
+        const snapshot = workspaceConvergence.snapshot();
+        const requestId = options2.requestId ?? crypto.randomUUID();
+        pendingPublication = {
+          requestId,
           trigger,
-          dirtyGeneration: snapshot2.dirtyGeneration,
-          explicit: true,
-          admissionHeld: false,
+          dirtyGeneration: snapshot.dirtyGeneration,
+          explicit: options2.requestId !== void 0,
           workInFlight: false,
-          requestedAt: Date.now(),
-          releaseCheckpointAdmission: () => {
-          }
+          requestedAt: Date.now()
         };
         try {
           ws.send(
             JSON.stringify({
-              type: "workspace_checkpoint_request",
-              requestId: options2.requestId,
+              type: "workspace_publication_request",
+              requestId,
               trigger,
-              dirtyGeneration: snapshot2.dirtyGeneration,
-              localHead: snapshot2.localHead,
-              desiredCanonicalHead: snapshot2.desiredCanonicalHead
+              dirtyGeneration: snapshot.dirtyGeneration,
+              localHead: snapshot.localHead,
+              desiredCanonicalHead: snapshot.desiredCanonicalHead
             })
           );
         } catch (error) {
-          pendingCheckpoint = void 0;
+          pendingPublication = void 0;
           workspaceConvergence.defer();
           process.stderr.write(
-            `[r5d-worker] failed to request blocked workspace checkpoint authority: ${error instanceof Error ? error.message : String(error)}
+            `[r5d-worker] failed to request workspace publication: ${error instanceof Error ? error.message : String(error)}
 `
           );
-          armWorkspaceCheckpoint(trigger, { delayMs: 1e3, requestId: options2.requestId });
+          armWorkspacePublication(trigger, { delayMs: 1e3, ...options2.requestId ? { requestId: options2.requestId } : {} });
         }
-        return;
-      }
-      if (pendingCheckpoint || workerHasActiveWriter()) {
-        armWorkspaceCheckpoint(trigger, { delayMs: 1e3, ...options2.requestId ? { requestId: options2.requestId } : {} });
-        return;
-      }
-      const releaseCheckpointAdmission = workspaceFilesystemWriters.tryAcquireCheckpoint();
-      if (!releaseCheckpointAdmission) {
-        armWorkspaceCheckpoint(trigger, { delayMs: 1e3, ...options2.requestId ? { requestId: options2.requestId } : {} });
-        return;
-      }
-      const snapshot = workspaceConvergence.snapshot();
-      const requestId = options2.requestId ?? crypto.randomUUID();
-      pendingCheckpoint = {
-        requestId,
-        trigger,
-        dirtyGeneration: snapshot.dirtyGeneration,
-        explicit: options2.requestId !== void 0,
-        admissionHeld: true,
-        workInFlight: false,
-        requestedAt: Date.now(),
-        releaseCheckpointAdmission
-      };
-      try {
-        ws.send(
-          JSON.stringify({
-            type: "workspace_checkpoint_request",
-            requestId,
-            trigger,
-            dirtyGeneration: snapshot.dirtyGeneration,
-            localHead: snapshot.localHead,
-            desiredCanonicalHead: snapshot.desiredCanonicalHead
-          })
-        );
-      } catch (error) {
-        releaseCheckpointAdmission();
-        pendingCheckpoint = void 0;
-        workspaceConvergence.defer();
-        process.stderr.write(
-          `[r5d-worker] failed to request workspace checkpoint: ${error instanceof Error ? error.message : String(error)}
-`
-        );
-        armWorkspaceCheckpoint(trigger, { delayMs: 1e3, ...options2.requestId ? { requestId: options2.requestId } : {} });
-      }
-    }, Math.max(0, options2.delayMs));
-    workspaceCheckpointTimer.unref();
+      },
+      Math.max(0, options2.delayMs)
+    );
+    workspacePublicationTimer.unref();
   };
   const markWorkspaceDirty = (trigger, force = false) => {
     workspaceConvergence.markDirty();
-    armWorkspaceCheckpoint(trigger, { delayMs: force ? 0 : WORKSPACE_CHECKPOINT_QUIET_MS });
+    armWorkspacePublication(trigger, { delayMs: force ? 0 : WORKSPACE_PUBLICATION_QUIET_MS });
   };
   const convergeAvailableWorkspaceHead = async () => {
     if (pendingWorkspaceHead === void 0 || !workspaceReady || !workspaceRemoteUrl || activeWorkspaceIncidentId || workspaceHeadConvergenceInFlight) {
@@ -2565,12 +2536,9 @@ async function startWorker(options) {
     pendingWorkspaceHead = void 0;
     workspaceConvergence.observeCanonicalHead(advertisedHead);
     workspaceHeadConvergenceInFlight = true;
-    let releaseVisibleHydration = null;
     try {
       const snapshot = workspaceConvergence.snapshot();
-      const mayHydrateVisible = !workerHasActiveWriter() && !pendingCheckpoint && snapshot.dirtyGeneration === snapshot.publishedGeneration;
-      releaseVisibleHydration = mayHydrateVisible ? workspaceFilesystemWriters.tryAcquireCheckpoint() : null;
-      const hydrateVisible = releaseVisibleHydration !== null;
+      const hydrateVisible = !pendingPublication && snapshot.dirtyGeneration === snapshot.publishedGeneration;
       const converged = await workspaceSyncSingleFlight.runExclusive(
         () => convergeWorkspaceHead(workspaceSyncInput({ type: "inbound_head", detail: advertisedHead ?? "unborn" }), {
           hydrateVisible
@@ -2579,7 +2547,7 @@ async function startWorker(options) {
       workspaceConvergence.observeCanonicalHead(converged.canonicalHead);
       if (converged.hydrated) workspaceConvergence.setLocalHead(converged.localHead);
       if (hydrateVisible && converged.localChanges) {
-        markWorkspaceDirty({ type: "periodic", detail: "inbound overlap retained for next checkpoint" });
+        markWorkspaceDirty({ type: "periodic", detail: "inbound overlap retained for next publication" });
       }
       sendWorkspaceReady();
     } catch (error) {
@@ -2589,7 +2557,6 @@ async function startWorker(options) {
 `
       );
     } finally {
-      releaseVisibleHydration?.();
       workspaceHeadConvergenceInFlight = false;
       heartbeatBusyGrace = grantWorkerHeartbeatBusyGrace(lastServerHeartbeatAt, heartbeatBusyGrace);
       if (pendingWorkspaceHead !== void 0) {
@@ -2610,7 +2577,7 @@ async function startWorker(options) {
     workspaceShadowRoot,
     manifestByProjectId
   });
-  const ensureVisibleWorkspaceCheckouts = (targets, options2 = {}) => {
+  const ensureVisibleWorktrees = (targets, options2 = {}) => {
     const created = [];
     for (const target of targets) {
       const manifest = manifestByProjectId.get(target.projectId);
@@ -2639,7 +2606,7 @@ async function startWorker(options) {
         reconcileExistingOrigin: remote.reconcileExistingOrigin,
         requireRemoteBranch: remote.requireRemoteBranch,
         requiredBaseCommit: remote.requiredBaseCommit,
-        allowRequiredRemoteMigration: !(options2.strictCanonicalRevalidation && remote.requireRemoteBranch),
+        allowRequiredRemoteMigration: !(options2.strictCanonicalRevalidation && remote.requiredBaseCommit),
         clearPersistentAuth: !remote.persistAuth
       });
       if (!existed) created.push(target);
@@ -2650,46 +2617,43 @@ async function startWorker(options) {
     if (workspaceManifestHydrationTimer || workspaceManifestHydrationInFlight || pendingManifestCheckouts.size === 0 || currentWorkerSocket !== ws || ws.readyState !== WebSocket.OPEN) {
       return;
     }
-    workspaceManifestHydrationTimer = setTimeout(() => {
-      workspaceManifestHydrationTimer = void 0;
-      if (!workspaceReady || !workspaceRemoteUrl || activeWorkspaceIncidentId || pendingCheckpoint || pendingManifestCheckouts.size === 0 || currentWorkerSocket !== ws || ws.readyState !== WebSocket.OPEN) {
-        if (pendingManifestCheckouts.size > 0 && currentWorkerSocket === ws && ws.readyState === WebSocket.OPEN) {
-          schedulePendingManifestCheckoutHydration(1e3);
-        }
-        return;
-      }
-      const releaseHydration = workspaceFilesystemWriters.tryAcquireCheckpoint();
-      if (!releaseHydration) {
-        schedulePendingManifestCheckoutHydration(1e3);
-        return;
-      }
-      workspaceManifestHydrationInFlight = true;
-      void workspaceSyncSingleFlight.runExclusive(async () => {
-        if (!workspaceReady || activeWorkspaceIncidentId || currentWorkerSocket !== ws || ws.readyState !== WebSocket.OPEN) {
+    workspaceManifestHydrationTimer = setTimeout(
+      () => {
+        workspaceManifestHydrationTimer = void 0;
+        if (!workspaceReady || !workspaceRemoteUrl || activeWorkspaceIncidentId || pendingPublication || pendingManifestCheckouts.size === 0 || currentWorkerSocket !== ws || ws.readyState !== WebSocket.OPEN) {
+          if (pendingManifestCheckouts.size > 0 && currentWorkerSocket === ws && ws.readyState === WebSocket.OPEN) {
+            schedulePendingManifestCheckoutHydration(1e3);
+          }
           return;
         }
-        const targets = [...pendingManifestCheckouts.values()];
-        ensureVisibleWorkspaceCheckouts(targets, { strictCanonicalRevalidation: true });
-        for (const target of targets) {
-          const manifest = manifestByProjectId.get(target.projectId);
-          if (!manifest || !manifest.branches.includes(target.branchName)) continue;
-          const branchPath = path.join(projectRootFor(projectsRoot, target.projectId, manifestByProjectId), target.branchName);
-          if (hasNormalVisibleGitDir(branchPath)) {
-            pendingManifestCheckouts.delete(manifestCheckoutKey(target.projectId, target.branchName));
+        workspaceManifestHydrationInFlight = true;
+        void workspaceSyncSingleFlight.runExclusive(async () => {
+          if (!workspaceReady || activeWorkspaceIncidentId || currentWorkerSocket !== ws || ws.readyState !== WebSocket.OPEN) {
+            return;
           }
-        }
-      }).then(() => sendWorkspaceReady()).catch((error) => {
-        process.stderr.write(
-          `[r5d-worker] pending manifest checkout hydration failed: ${error instanceof Error ? error.message : String(error)}
+          const targets = [...pendingManifestCheckouts.values()];
+          ensureVisibleWorktrees(targets, { strictCanonicalRevalidation: true });
+          for (const target of targets) {
+            const manifest = manifestByProjectId.get(target.projectId);
+            if (!manifest || !manifest.branches.includes(target.branchName)) continue;
+            const branchPath = path.join(projectRootFor(projectsRoot, target.projectId, manifestByProjectId), target.branchName);
+            if (hasNormalVisibleGitDir(branchPath)) {
+              pendingManifestCheckouts.delete(manifestCheckoutKey(target.projectId, target.branchName));
+            }
+          }
+        }).then(() => sendWorkspaceReady()).catch((error) => {
+          process.stderr.write(
+            `[r5d-worker] pending manifest checkout hydration failed: ${error instanceof Error ? error.message : String(error)}
 `
-        );
-      }).finally(() => {
-        releaseHydration();
-        workspaceManifestHydrationInFlight = false;
-        heartbeatBusyGrace = grantWorkerHeartbeatBusyGrace(lastServerHeartbeatAt, heartbeatBusyGrace);
-        if (pendingManifestCheckouts.size > 0) schedulePendingManifestCheckoutHydration(1e3);
-      });
-    }, Math.max(0, delayMs));
+          );
+        }).finally(() => {
+          workspaceManifestHydrationInFlight = false;
+          heartbeatBusyGrace = grantWorkerHeartbeatBusyGrace(lastServerHeartbeatAt, heartbeatBusyGrace);
+          if (pendingManifestCheckouts.size > 0) schedulePendingManifestCheckoutHydration(1e3);
+        });
+      },
+      Math.max(0, delayMs)
+    );
     workspaceManifestHydrationTimer.unref();
   };
   const runRequestedWorkspaceSync = async (authority, trigger, overrides = {}) => {
@@ -2723,7 +2687,7 @@ async function startWorker(options) {
           });
         }
         pendingTargets = shouldEnsureCheckouts ? scopedPendingTargets : [];
-        const createdCheckouts = ensureVisibleWorkspaceCheckouts(checkoutTargets, {
+        const createdCheckouts = ensureVisibleWorktrees(checkoutTargets, {
           strictCanonicalRevalidation: true
         });
         const newVisibleCheckoutByKey = /* @__PURE__ */ new Map();
@@ -2805,11 +2769,11 @@ async function startWorker(options) {
   const handleGracefulShutdown = () => {
     if (shutdownAfterClose) return;
     shutdownAfterClose = true;
-    void waitForWorkspaceCheckpointOnShutdown({
+    void waitForWorkspacePublicationOnShutdown({
       snapshot: () => workspaceConvergence.snapshot(),
-      forceCheckpoint: () => armWorkspaceCheckpoint({ type: "manual", detail: "graceful worker shutdown" }, { delayMs: 0 })
+      forcePublication: () => armWorkspacePublication({ type: "manual", detail: "graceful worker shutdown" }, { delayMs: 0 })
     }).then((outcome) => {
-      process.stdout.write(`[r5d-worker] graceful workspace checkpoint ${outcome}
+      process.stdout.write(`[r5d-worker] graceful workspace publication ${outcome}
 `);
       if (ws.readyState === WebSocket.OPEN || ws.readyState === WebSocket.CONNECTING) {
         ws.close(1e3, "Worker shutting down");
@@ -2880,105 +2844,84 @@ async function startWorker(options) {
       if (message.type === "workspace_manifest") {
         const revisionToken = workspaceManifestRevision.begin(message.revision);
         workspaceReady = false;
-        const manifestAdmission = inspectWorkspaceManifestAdmission({
+        const manifestFilesystem = inspectWorkspaceManifestFilesystem({
           projectsRoot,
           workspaceShadowRoot,
           projects: message.projects
         });
-        const releaseManifestHydration = await acquireWorkspaceManifestVisibleLease(
-          workspaceFilesystemWriters,
-          manifestAdmission
-        );
-        let completed = false;
-        try {
-          completed = await workspaceSyncSingleFlight.runExclusive(async () => {
-            if (!workspaceManifestRevision.isCurrent(revisionToken)) return false;
-            const firstBootstrap = manifestAdmission.firstBootstrap;
-            configureGitHubAuth(message.githubCredential);
-            visibleGitIdentity = message.gitIdentity;
-            workspaceRemoteUrl = message.workspaceRemoteUrl;
-            const migratedProjectIds = releaseManifestHydration ? migrateLegacyProjectRoots(projectsRoot, message.projects) : [];
-            manifestByProjectId.clear();
-            for (const project of message.projects) manifestByProjectId.set(project.projectId, project);
-            const currentCheckouts = allManifestCheckouts();
-            const currentCheckoutKeys = new Set(
-              currentCheckouts.map(({ projectId, branchName }) => manifestCheckoutKey(projectId, branchName))
-            );
-            for (const key of pendingManifestCheckouts.keys()) {
-              if (!currentCheckoutKeys.has(key)) pendingManifestCheckouts.delete(key);
-            }
-            for (const checkout of currentCheckouts) {
-              const key = manifestCheckoutKey(checkout.projectId, checkout.branchName);
-              const branchPath = path.join(
-                projectRootFor(projectsRoot, checkout.projectId, manifestByProjectId),
-                checkout.branchName
-              );
-              if (!hasNormalVisibleGitDir(branchPath)) pendingManifestCheckouts.set(key, checkout);
-            }
-            if (!workspaceManifestRevision.isCurrent(revisionToken)) return false;
-            const created = releaseManifestHydration ? ensureVisibleWorkspaceCheckouts(currentCheckouts, { strictCanonicalRevalidation: true }) : [];
-            if (!workspaceManifestRevision.isCurrent(revisionToken)) return false;
-            const bootstrapped = await convergeWorkspaceHead(
-              workspaceSyncInput({ type: "connect" }, { newVisibleCheckouts: created }),
-              {
-                // An existing checkout becomes routable after a fetch. Its
-                // visible tree converges asynchronously; first bootstrap alone
-                // must materialize the canonical snapshot before readiness.
-                // Re-check the incident immediately before convergence so a
-                // concurrently delivered fence forces fetch-only behavior.
-                hydrateVisible: firstBootstrap && !activeWorkspaceIncidentId
-              }
-            );
-            if (!workspaceManifestRevision.isCurrent(revisionToken)) return false;
-            workspaceConvergence.setLocalHead(bootstrapped.localHead);
-            workspaceConvergence.observeCanonicalHead(bootstrapped.canonicalHead);
-            for (const checkout of currentCheckouts) {
-              const manifest = manifestByProjectId.get(checkout.projectId);
-              if (!manifest) continue;
-              const branchPath = path.join(projectRootFor(projectsRoot, checkout.projectId, manifestByProjectId), checkout.branchName);
-              if (hasNormalVisibleGitDir(branchPath)) {
-                pendingManifestCheckouts.delete(manifestCheckoutKey(checkout.projectId, checkout.branchName));
-              }
+        const completed = await workspaceSyncSingleFlight.runExclusive(async () => {
+          if (!workspaceManifestRevision.isCurrent(revisionToken)) return false;
+          const firstBootstrap = manifestFilesystem.firstBootstrap;
+          configureGitHubAuth(message.githubCredential);
+          visibleGitIdentity = message.gitIdentity;
+          workspaceRemoteUrl = message.workspaceRemoteUrl;
+          const migratedProjectIds = migrateLegacyProjectRoots(projectsRoot, message.projects);
+          manifestByProjectId.clear();
+          for (const project of message.projects) manifestByProjectId.set(project.projectId, project);
+          const currentCheckouts = allManifestCheckouts();
+          const currentCheckoutKeys = new Set(
+            currentCheckouts.map(({ projectId, branchName }) => manifestCheckoutKey(projectId, branchName))
+          );
+          for (const key of pendingManifestCheckouts.keys()) {
+            if (!currentCheckoutKeys.has(key)) pendingManifestCheckouts.delete(key);
+          }
+          for (const checkout of currentCheckouts) {
+            const key = manifestCheckoutKey(checkout.projectId, checkout.branchName);
+            const branchPath = path.join(projectRootFor(projectsRoot, checkout.projectId, manifestByProjectId), checkout.branchName);
+            if (!hasNormalVisibleGitDir(branchPath)) pendingManifestCheckouts.set(key, checkout);
+          }
+          if (!workspaceManifestRevision.isCurrent(revisionToken)) return false;
+          const created = firstBootstrap || migratedProjectIds.length > 0 ? ensureVisibleWorktrees(currentCheckouts, { strictCanonicalRevalidation: true }) : [];
+          if (!workspaceManifestRevision.isCurrent(revisionToken)) return false;
+          const bootstrapped = await convergeWorkspaceHead(workspaceSyncInput({ type: "connect" }, { newVisibleCheckouts: created }), {
+            // An existing checkout becomes routable after a fetch. Its
+            // visible tree converges asynchronously; first bootstrap alone
+            // must materialize the canonical snapshot before readiness.
+            // Re-check the incident immediately before convergence so a
+            // concurrently delivered fence forces fetch-only behavior.
+            hydrateVisible: firstBootstrap && !activeWorkspaceIncidentId
+          });
+          if (!workspaceManifestRevision.isCurrent(revisionToken)) return false;
+          workspaceConvergence.setLocalHead(bootstrapped.localHead);
+          workspaceConvergence.observeCanonicalHead(bootstrapped.canonicalHead);
+          for (const checkout of currentCheckouts) {
+            const manifest = manifestByProjectId.get(checkout.projectId);
+            if (!manifest) continue;
+            const branchPath = path.join(projectRootFor(projectsRoot, checkout.projectId, manifestByProjectId), checkout.branchName);
+            if (hasNormalVisibleGitDir(branchPath)) {
+              pendingManifestCheckouts.delete(manifestCheckoutKey(checkout.projectId, checkout.branchName));
             }
-            process.stdout.write(
-              `[r5d-worker] workspace manifest: ${message.projects.length} projects${migratedProjectIds.length > 0 ? `; migrated ${migratedProjectIds.length} project checkout root(s)` : ""}
+          }
+          process.stdout.write(
+            `[r5d-worker] workspace manifest: ${message.projects.length} projects${migratedProjectIds.length > 0 ? `; migrated ${migratedProjectIds.length} project checkout root(s)` : ""}
 `
-            );
-            return true;
-          });
-        } finally {
-          releaseManifestHydration?.();
-        }
+          );
+          return true;
+        });
         if (!completed || !workspaceManifestRevision.complete(revisionToken)) return;
         workspaceReady = true;
         sendWorkspaceReady();
         schedulePendingManifestCheckoutHydration();
         if (!workspaceSafetyScan) {
           workspaceSafetyScan = setInterval(() => {
-            if (!workspaceReady || !workspaceRemoteUrl || activeWorkspaceIncidentId || pendingCheckpoint || workspaceSafetyScanInFlight) {
+            if (!workspaceReady || !workspaceRemoteUrl || activeWorkspaceIncidentId || pendingPublication || workspaceSafetyScanInFlight) {
               return;
             }
             workspaceSafetyScanInFlight = true;
             void (async () => {
               const before = workspaceConvergence.snapshot();
-              const mayHydrateVisible = !workerHasActiveWriter() && before.dirtyGeneration === before.publishedGeneration;
-              const releaseVisibleHydration = mayHydrateVisible ? workspaceFilesystemWriters.tryAcquireCheckpoint() : null;
-              const hydrateVisible = releaseVisibleHydration !== null;
-              try {
-                const converged = await workspaceSyncSingleFlight.runExclusive(
-                  () => convergeWorkspaceHead(workspaceSyncInput({ type: "periodic", detail: "idle convergence scan" }), {
-                    hydrateVisible
-                  })
-                );
-                workspaceConvergence.observeCanonicalHead(converged.canonicalHead);
-                if (converged.hydrated) workspaceConvergence.setLocalHead(converged.localHead);
-                if (converged.localChanges && hydrateVisible) {
-                  markWorkspaceDirty({ type: "periodic", detail: "idle safety scan" });
-                }
-                sendWorkspaceReady();
-              } finally {
-                releaseVisibleHydration?.();
+              const hydrateVisible = before.dirtyGeneration === before.publishedGeneration;
+              const converged = await workspaceSyncSingleFlight.runExclusive(
+                () => convergeWorkspaceHead(workspaceSyncInput({ type: "periodic", detail: "idle convergence scan" }), {
+                  hydrateVisible
+                })
+              );
+              workspaceConvergence.observeCanonicalHead(converged.canonicalHead);
+              if (converged.hydrated) workspaceConvergence.setLocalHead(converged.localHead);
+              if (converged.localChanges && hydrateVisible) {
+                markWorkspaceDirty({ type: "periodic", detail: "idle safety scan" });
               }
+              sendWorkspaceReady();
             })().catch((error) => {
               process.stderr.write(
                 `[r5d-worker] idle workspace safety scan failed: ${error instanceof Error ? error.message : String(error)}
@@ -2994,7 +2937,7 @@ async function startWorker(options) {
         pendingWorkspaceHead = workspaceConvergence.snapshot().desiredCanonicalHead;
         void convergeAvailableWorkspaceHead();
         if (workspaceConvergence.snapshot().dirtyGeneration > workspaceConvergence.snapshot().publishedGeneration) {
-          armWorkspaceCheckpoint({ type: "periodic", detail: "resume dirty generation after reconnect" }, { delayMs: 0 });
+          armWorkspacePublication({ type: "periodic", detail: "resume dirty generation after reconnect" }, { delayMs: 0 });
         }
         return;
       }
@@ -3025,59 +2968,52 @@ async function startWorker(options) {
         void convergeAvailableWorkspaceHead();
         return;
       }
-      if (message.type === "workspace_checkpoint_now") {
-        armWorkspaceCheckpoint(message.trigger, { delayMs: 0, requestId: message.requestId });
+      if (message.type === "workspace_publication_now") {
+        armWorkspacePublication(message.trigger, { delayMs: 0, requestId: message.requestId });
         return;
       }
-      if (message.type === "workspace_checkpoint_authority") {
-        const checkpoint = pendingCheckpoint;
-        if (!checkpoint || checkpoint.requestId !== message.requestId) {
-          process.stderr.write(`[r5d-worker] ignoring checkpoint authority for unknown request ${message.requestId}
+      if (message.type === "workspace_publication_authority") {
+        const publication = pendingPublication;
+        if (!publication || publication.requestId !== message.requestId) {
+          process.stderr.write(`[r5d-worker] ignoring publication authority for unknown request ${message.requestId}
 `);
           return;
         }
         if (message.status !== "granted") {
-          checkpoint.releaseCheckpointAdmission();
-          pendingCheckpoint = void 0;
+          pendingPublication = void 0;
           workspaceConvergence.observeCanonicalHead(message.canonicalHead);
           const applyBlockedResponse = message.status === "blocked" && workspaceIncidentOrdering.permitsBlockedResponse(message.incidentId);
           if (applyBlockedResponse) {
             workspaceConvergence.block();
             if (message.incidentId) activeWorkspaceIncidentId = message.incidentId;
           } else {
-            workspaceConvergence.resetTransientCheckpointState();
+            workspaceConvergence.resetTransientPublicationState();
             workspaceConvergence.observeIncidentState(Boolean(activeWorkspaceIncidentId));
             if (message.status === "busy") {
-              armWorkspaceCheckpoint(checkpoint.trigger, {
+              armWorkspacePublication(publication.trigger, {
                 delayMs: message.retryAfterMs ?? 1e3,
-                requestId: checkpoint.requestId
+                requestId: publication.requestId
               });
             } else if (!activeWorkspaceIncidentId) {
-              const explicit = explicitWorkspaceCheckpoints.next();
+              const explicit = explicitWorkspacePublications.next();
               if (explicit) {
-                armWorkspaceCheckpoint(explicit.trigger, { delayMs: 0, requestId: explicit.requestId });
+                armWorkspacePublication(explicit.trigger, { delayMs: 0, requestId: explicit.requestId });
               } else if (workspaceConvergence.snapshot().dirtyGeneration > workspaceConvergence.snapshot().publishedGeneration) {
-                armWorkspaceCheckpoint(checkpoint.trigger, { delayMs: 0 });
+                armWorkspacePublication(publication.trigger, { delayMs: 0 });
               }
             }
           }
           sendWorkspaceReady();
           return;
         }
-        checkpoint.attemptId = message.attemptId;
-        checkpoint.authorityToken = message.authorityToken;
-        checkpoint.workInFlight = true;
-        pendingCheckpoint = checkpoint;
-        if (!checkpoint.admissionHeld) {
-          const releaseCheckpointAdmission = await workspaceFilesystemWriters.acquireCheckpoint();
-          if (currentWorkerSocket !== ws || pendingCheckpoint?.requestId !== checkpoint.requestId || pendingCheckpoint.attemptId !== message.attemptId) {
-            releaseCheckpointAdmission();
-            checkpoint.workInFlight = false;
-            workspaceConvergence.resetTransientCheckpointState();
-            return;
-          }
-          checkpoint.admissionHeld = true;
-          checkpoint.releaseCheckpointAdmission = releaseCheckpointAdmission;
+        publication.attemptId = message.attemptId;
+        publication.authorityToken = message.authorityToken;
+        publication.workInFlight = true;
+        pendingPublication = publication;
+        if (currentWorkerSocket !== ws) {
+          publication.workInFlight = false;
+          workspaceConvergence.resetTransientPublicationState();
+          return;
         }
         workspaceConvergence.beginPreparing();
         sendWorkspaceReady();
@@ -3089,11 +3025,11 @@ async function startWorker(options) {
           result = await workspaceSyncSingleFlight.runExclusive(async () => {
             prepareStartedAt = Date.now();
             const pendingTargets = [...pendingManifestCheckouts.values()];
-            const createdCheckouts = ensureVisibleWorkspaceCheckouts(pendingTargets, { strictCanonicalRevalidation: true });
+            const createdCheckouts = ensureVisibleWorktrees(pendingTargets, { strictCanonicalRevalidation: true });
             synchronizeStartedAt = Date.now();
             synchronizeStarted = true;
             const prepared = await synchronizeWorkspace(
-              workspaceSyncInput(checkpoint.trigger, {
+              workspaceSyncInput(publication.trigger, {
                 attemptId: message.attemptId,
                 quarantineRef: message.quarantineRef,
                 expectedCanonicalHead: message.expectedHead,
@@ -3111,7 +3047,7 @@ async function startWorker(options) {
             type: "workspace_sync",
             attemptId: message.attemptId,
             workerLabel: label,
-            trigger: checkpoint.trigger,
+            trigger: publication.trigger,
             outcome: "failed",
             startingHead: message.expectedHead,
             expectedHead: message.expectedHead,
@@ -3128,9 +3064,9 @@ async function startWorker(options) {
         const finishedAt = Date.now();
         result = {
           ...result,
-          dirtyGeneration: checkpoint.dirtyGeneration,
-          telemetry: workspaceCheckpointTelemetry({
-            requestedAt: checkpoint.requestedAt,
+          dirtyGeneration: publication.dirtyGeneration,
+          telemetry: workspacePublicationTelemetry({
+            requestedAt: publication.requestedAt,
             prepareStartedAt,
             synchronizeStartedAt,
             finishedAt
@@ -3141,36 +3077,35 @@ async function startWorker(options) {
         try {
           ws.send(
             JSON.stringify({
-              type: "workspace_checkpoint_result",
-              requestId: checkpoint.requestId,
+              type: "workspace_publication_result",
+              requestId: publication.requestId,
               attemptId: message.attemptId,
               authorityToken: message.authorityToken,
-              dirtyGeneration: checkpoint.dirtyGeneration,
+              dirtyGeneration: publication.dirtyGeneration,
               result
             })
           );
         } catch (error) {
-          workspaceConvergence.resetTransientCheckpointState();
+          workspaceConvergence.resetTransientPublicationState();
           throw error;
         } finally {
-          checkpoint.workInFlight = false;
-          checkpoint.releaseCheckpointAdmission();
-          if (currentWorkerSocket !== ws) workspaceConvergence.resetTransientCheckpointState();
+          publication.workInFlight = false;
+          if (currentWorkerSocket !== ws) workspaceConvergence.resetTransientPublicationState();
         }
         return;
       }
-      if (message.type === "workspace_checkpoint_completed") {
-        const checkpoint = pendingCheckpoint;
-        if (!checkpoint || checkpoint.requestId !== message.requestId || checkpoint.attemptId !== message.attemptId) {
-          process.stderr.write(`[r5d-worker] ignoring completion for unknown checkpoint ${message.requestId}
+      if (message.type === "workspace_publication_completed") {
+        const publication = pendingPublication;
+        if (!publication || publication.requestId !== message.requestId || publication.attemptId !== message.attemptId) {
+          process.stderr.write(`[r5d-worker] ignoring completion for unknown publication ${message.requestId}
 `);
           return;
         }
-        pendingCheckpoint = void 0;
+        pendingPublication = void 0;
         workspaceConvergence.observeCanonicalHead(message.canonicalHead);
         if (message.status === "published" || message.status === "no_change") {
           workspaceConvergence.complete({
-            generation: Math.min(message.publishedGeneration ?? checkpoint.dirtyGeneration, checkpoint.dirtyGeneration),
+            generation: Math.min(message.publishedGeneration ?? publication.dirtyGeneration, publication.dirtyGeneration),
             canonicalHead: message.canonicalHead,
             published: true
           });
@@ -3178,18 +3113,18 @@ async function startWorker(options) {
           workspaceConvergence.block();
           if (message.incidentId) activeWorkspaceIncidentId = message.incidentId;
         } else {
-          workspaceConvergence.resetTransientCheckpointState();
+          workspaceConvergence.resetTransientPublicationState();
           workspaceConvergence.observeIncidentState(Boolean(activeWorkspaceIncidentId));
         }
         sendWorkspaceReady();
-        const explicit = message.status === "retry" && checkpoint.explicit ? { requestId: checkpoint.requestId, trigger: checkpoint.trigger } : explicitWorkspaceCheckpoints.next();
+        const explicit = message.status === "retry" && publication.explicit ? { requestId: publication.requestId, trigger: publication.trigger } : explicitWorkspacePublications.next();
         if (explicit) {
-          armWorkspaceCheckpoint(explicit.trigger, {
+          armWorkspacePublication(explicit.trigger, {
             delayMs: message.retryAfterMs ?? 0,
             requestId: explicit.requestId
           });
         } else if (message.status === "retry" || message.status === "failed" || workspaceConvergence.snapshot().dirtyGeneration > workspaceConvergence.snapshot().publishedGeneration) {
-          armWorkspaceCheckpoint(checkpoint.trigger, { delayMs: message.retryAfterMs ?? 1e3 });
+          armWorkspacePublication(publication.trigger, { delayMs: message.retryAfterMs ?? 1e3 });
         }
         if (message.canonicalHead !== workspaceConvergence.snapshot().localHead) {
           pendingWorkspaceHead = message.canonicalHead;
@@ -3237,11 +3172,11 @@ async function startWorker(options) {
           pendingWorkspaceHead = workspaceConvergence.snapshot().desiredCanonicalHead;
           void convergeAvailableWorkspaceHead();
         }
-        const explicit = !activeWorkspaceIncidentId ? explicitWorkspaceCheckpoints.next() : void 0;
+        const explicit = !activeWorkspaceIncidentId ? explicitWorkspacePublications.next() : void 0;
         if (explicit) {
-          armWorkspaceCheckpoint(explicit.trigger, { delayMs: 0, requestId: explicit.requestId });
+          armWorkspacePublication(explicit.trigger, { delayMs: 0, requestId: explicit.requestId });
         } else if (!activeWorkspaceIncidentId && workspaceConvergence.snapshot().dirtyGeneration > workspaceConvergence.snapshot().publishedGeneration) {
-          armWorkspaceCheckpoint({ type: "periodic", detail: "resume after workspace incident" }, { delayMs: 0 });
+          armWorkspacePublication({ type: "periodic", detail: "resume after workspace incident" }, { delayMs: 0 });
         }
         if (!activeWorkspaceIncidentId) schedulePendingManifestCheckoutHydration();
         sendWorkspaceReady();
@@ -3342,10 +3277,8 @@ async function startWorker(options) {
           });
           return;
         }
-        const releaseWorkspaceWriter = targetMayMutateVisibleWorkspace(message.target) ? await workspaceFilesystemWriters.acquireWriter() : void 0;
         const releaseWorkspaceMutation = await acquireWorkspaceCommandMutation(message.target, workspaceSyncSingleFlight);
         let mutationLeaseTransferred = false;
-        let writerLeaseTransferred = false;
         try {
           const resolvedTarget = resolveMessageTarget(message.target);
           process.stdout.write(`[r5d-worker] pty ${message.ptyId}: ${describeWorkerSessionTarget(message.target)}
@@ -3358,16 +3291,11 @@ async function startWorker(options) {
             ...releaseWorkspaceMutation ? { releaseWorkspaceMutation } : {},
             ...targetMayMutateVisibleWorkspace(message.target) ? {
               onTerminal: () => {
-                markWorkspaceDirty(
-                  { type: "process_terminal", detail: `pty ${message.ptyId} completed` },
-                  true
-                );
-                releaseWorkspaceWriter?.();
+                markWorkspaceDirty({ type: "process_terminal", detail: `pty ${message.ptyId} completed` }, true);
               }
             } : {}
           });
           mutationLeaseTransferred = releaseWorkspaceMutation !== void 0;
-          writerLeaseTransferred = releaseWorkspaceWriter !== void 0;
         } catch (error) {
           sendWorkerMessage(ws, {
             type: "pty_error",
@@ -3377,7 +3305,6 @@ async function startWorker(options) {
           });
         } finally {
           if (!mutationLeaseTransferred) releaseWorkspaceMutation?.();
-          if (!writerLeaseTransferred) releaseWorkspaceWriter?.();
         }
         return;
       }
@@ -3397,7 +3324,7 @@ async function startWorker(options) {
         const activePty = activePtys.get(message.ptyId);
         closePty(message);
         if (activePty && targetMayMutateVisibleWorkspace(activePty.target)) {
-          armWorkspaceCheckpoint({ type: "process_terminal", detail: `pty ${message.ptyId} closed` }, { delayMs: 0 });
+          armWorkspacePublication({ type: "process_terminal", detail: `pty ${message.ptyId} closed` }, { delayMs: 0 });
         }
         return;
       }
@@ -3412,36 +3339,31 @@ async function startWorker(options) {
           });
           return;
         }
-        const releaseWorkspaceWriter = targetMayMutateVisibleWorkspace(message.target) ? await workspaceFilesystemWriters.acquireWriter() : void 0;
+        let result;
         try {
-          let result;
-          try {
-            const runCommand = async () => {
-              const resolvedTarget = resolveMessageTarget(message.target);
-              process.stdout.write(`[r5d-worker] exec ${message.runId}: ${message.argv.join(" ")}
+          const runCommand = async () => {
+            const resolvedTarget = resolveMessageTarget(message.target);
+            process.stdout.write(`[r5d-worker] exec ${message.runId}: ${message.argv.join(" ")}
 `);
-              return await executeCommand({ message, resolvedTarget, baseUrl, token, artifactRoot, planRoot });
-            };
-            result = await runWorkspaceCommand(message.target, workspaceSyncSingleFlight, runCommand);
-          } catch (error) {
-            result = {
-              type: "exec_result",
-              requestId: message.requestId,
-              stdout: "",
-              stderr: "",
-              exitCode: 1,
-              error: error instanceof Error ? error.message : String(error)
-            };
-          }
-          ws.send(JSON.stringify(result));
-          if (targetMayMutateVisibleWorkspace(message.target)) {
-            markWorkspaceDirty(
-              { type: "shell_inline", sessionId: message.sessionId, processRunId: message.runId, detail: "foreground command completed" },
-              true
-            );
-          }
-        } finally {
-          releaseWorkspaceWriter?.();
+            return await executeCommand({ message, resolvedTarget, baseUrl, token, artifactRoot, planRoot });
+          };
+          result = await runWorkspaceCommand(message.target, workspaceSyncSingleFlight, runCommand);
+        } catch (error) {
+          result = {
+            type: "exec_result",
+            requestId: message.requestId,
+            stdout: "",
+            stderr: "",
+            exitCode: 1,
+            error: error instanceof Error ? error.message : String(error)
+          };
+        }
+        ws.send(JSON.stringify(result));
+        if (targetMayMutateVisibleWorkspace(message.target)) {
+          markWorkspaceDirty(
+            { type: "shell_inline", sessionId: message.sessionId, processRunId: message.runId, detail: "foreground command completed" },
+            true
+          );
         }
         return;
       }
@@ -3461,7 +3383,6 @@ async function startWorker(options) {
           runId: message.runId
         });
         const runCommand = async () => {
-          const releaseWorkspaceWriter = targetMayMutateVisibleWorkspace(message.target) ? await workspaceFilesystemWriters.acquireWriter() : void 0;
           try {
             const resolvedTarget = resolveMessageTarget(message.target);
             process.stdout.write(`[r5d-worker] exec_start ${message.runId}: ${message.argv.join(" ")}
@@ -3487,7 +3408,6 @@ async function startWorker(options) {
                 true
               );
             }
-            releaseWorkspaceWriter?.();
           }
         };
         const execution = runWorkspaceCommand(message.target, workspaceSyncSingleFlight, runCommand);
@@ -3502,46 +3422,41 @@ async function startWorker(options) {
         return;
       }
       if (message.type === "read" || message.type === "write" || message.type === "edit" || message.type === "grep" || message.type === "find" || message.type === "ls" || message.type === "view_file_bytes") {
-        const releaseWorkspaceWriter = (message.type === "write" || message.type === "edit") && targetMayMutateVisibleWorkspace(message.target) ? await workspaceFilesystemWriters.acquireWriter() : void 0;
         try {
-          try {
-            const result = await workspaceSyncSingleFlight.runMutation(async () => {
-              const resolvedTarget = resolveMessageTarget(message.target);
-              return await executeOperation({
-                message,
-                resolvedTarget,
-                baseUrl,
-                token,
-                artifactRoot,
-                planRoot
-              });
+          const result = await runWorkspaceCommand(message.target, workspaceSyncSingleFlight, async () => {
+            const resolvedTarget = resolveMessageTarget(message.target);
+            return await executeOperation({
+              message,
+              resolvedTarget,
+              baseUrl,
+              token,
+              artifactRoot,
+              planRoot
+            });
+          });
+          ws.send(
+            JSON.stringify({
+              type: "operation_result",
+              requestId: message.requestId,
+              result
+            })
+          );
+          if ((message.type === "write" || message.type === "edit") && targetMayMutateVisibleWorkspace(message.target)) {
+            markWorkspaceDirty({
+              type: message.type,
+              sessionId: message.sessionId,
+              toolCallId: message.requestId,
+              ...message.target.type === "project" ? { projectId: message.target.projectId, branchName: message.target.branchName } : {}
             });
-            ws.send(
-              JSON.stringify({
-                type: "operation_result",
-                requestId: message.requestId,
-                result
-              })
-            );
-            if ((message.type === "write" || message.type === "edit") && targetMayMutateVisibleWorkspace(message.target)) {
-              markWorkspaceDirty({
-                type: message.type,
-                sessionId: message.sessionId,
-                toolCallId: message.requestId,
-                ...message.target.type === "project" ? { projectId: message.target.projectId, branchName: message.target.branchName } : {}
-              });
-            }
-          } catch (error) {
-            ws.send(
-              JSON.stringify({
-                type: "operation_result",
-                requestId: message.requestId,
-                error: error instanceof Error ? error.message : String(error)
-              })
-            );
           }
-        } finally {
-          releaseWorkspaceWriter?.();
+        } catch (error) {
+          ws.send(
+            JSON.stringify({
+              type: "operation_result",
+              requestId: message.requestId,
+              error: error instanceof Error ? error.message : String(error)
+            })
+          );
         }
         return;
       }
@@ -3566,13 +3481,12 @@ async function startWorker(options) {
     process.off("SIGTERM", handleGracefulShutdown);
     process.off("SIGINT", handleGracefulShutdown);
     stopHeartbeatWatchdog();
-    if (workspaceCheckpointTimer) {
-      clearTimeout(workspaceCheckpointTimer);
-      workspaceCheckpointTimer = void 0;
+    if (workspacePublicationTimer) {
+      clearTimeout(workspacePublicationTimer);
+      workspacePublicationTimer = void 0;
     }
-    if (!pendingCheckpoint?.workInFlight) {
-      pendingCheckpoint?.releaseCheckpointAdmission();
-      workspaceConvergence.resetTransientCheckpointState();
+    if (!pendingPublication?.workInFlight) {
+      workspaceConvergence.resetTransientPublicationState();
     }
     if (workspaceSafetyScan) {
       clearInterval(workspaceSafetyScan);