@ricsam/r5d-worker 0.0.53 → 0.0.55

package/dist/cjs/heartbeat.cjs

@@ -20,7 +20,9 @@ var heartbeat_exports = {};
 __export(heartbeat_exports, {
   WORKER_HEARTBEAT_INTERVAL_MS: () => WORKER_HEARTBEAT_INTERVAL_MS,
   WORKER_HEARTBEAT_TIMEOUT_MS: () => WORKER_HEARTBEAT_TIMEOUT_MS,
-  hasWorkerHeartbeatTimedOut: () => hasWorkerHeartbeatTimedOut
+  grantWorkerHeartbeatBusyGrace: () => grantWorkerHeartbeatBusyGrace,
+  hasWorkerHeartbeatTimedOut: () => hasWorkerHeartbeatTimedOut,
+  hasWorkerHeartbeatTimedOutWithBusyGrace: () => hasWorkerHeartbeatTimedOutWithBusyGrace
 });
 module.exports = __toCommonJS(heartbeat_exports);
 const WORKER_HEARTBEAT_INTERVAL_MS = 15e3;
@@ -28,9 +30,20 @@ const WORKER_HEARTBEAT_TIMEOUT_MS = 45e3;
 function hasWorkerHeartbeatTimedOut(lastHeartbeatAt, now = Date.now(), timeoutMs = WORKER_HEARTBEAT_TIMEOUT_MS) {
   return lastHeartbeatAt !== null && now - lastHeartbeatAt >= timeoutMs;
 }
+function grantWorkerHeartbeatBusyGrace(lastHeartbeatAt, currentGrace, now = Date.now(), timeoutMs = WORKER_HEARTBEAT_TIMEOUT_MS, graceMs = WORKER_HEARTBEAT_INTERVAL_MS) {
+  if (!hasWorkerHeartbeatTimedOut(lastHeartbeatAt, now, timeoutMs)) return currentGrace;
+  if (currentGrace?.heartbeatAt === lastHeartbeatAt) return currentGrace;
+  return { heartbeatAt: lastHeartbeatAt, expiresAt: now + graceMs };
+}
+function hasWorkerHeartbeatTimedOutWithBusyGrace(lastHeartbeatAt, busyGrace, now = Date.now(), timeoutMs = WORKER_HEARTBEAT_TIMEOUT_MS) {
+  if (lastHeartbeatAt !== null && busyGrace?.heartbeatAt === lastHeartbeatAt && now < busyGrace.expiresAt) return false;
+  return hasWorkerHeartbeatTimedOut(lastHeartbeatAt, now, timeoutMs);
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   WORKER_HEARTBEAT_INTERVAL_MS,
   WORKER_HEARTBEAT_TIMEOUT_MS,
-  hasWorkerHeartbeatTimedOut
+  grantWorkerHeartbeatBusyGrace,
+  hasWorkerHeartbeatTimedOut,
+  hasWorkerHeartbeatTimedOutWithBusyGrace
 });

package/dist/cjs/main.cjs

@@ -63,6 +63,7 @@ var import_git_identity = require("./git-identity.cjs");
 var import_heartbeat = require("./heartbeat.cjs");
 var import_process_tree = require("./process-tree.cjs");
 var import_port_forward_client = require("./port-forward-client.cjs");
+var import_workspace_incident_state = require("./workspace-incident-state.cjs");
 var import_supervisor = require("./supervisor.cjs");
 var import_managed_paths = require("./managed-paths.cjs");
 var import_workspace_sync = require("./workspace-sync.cjs");
@@ -81,6 +82,7 @@ const pendingProcessTerminals = /* @__PURE__ */ new Map();
 const cancelledProcessRuns = /* @__PURE__ */ new Set();
 const activePtys = /* @__PURE__ */ new Map();
 let currentWorkerSocket = null;
+const workspaceSyncSingleFlight = new import_workspace_sync.WorkspaceSyncSingleFlight();
 let githubCredential = null;
 let visibleGitIdentity = null;
 function defaultConfigPath() {
@@ -2252,75 +2254,72 @@ function resolveHostShell(command, platform = process.platform) {
   return { file, args: command === void 0 ? ["-l"] : ["-lc", command] };
 }
 async function openPty(input) {
-  try {
-    const planProcessEnv = !(input.resolvedTarget.target.type === "workspace" && input.resolvedTarget.target.rootProfile === "canonical_sync") ? preparePlanEnvForShell({
-      target: input.resolvedTarget.target,
-      planRoot: input.planRoot,
-      activePlanId: input.message.env?.R5D_ACTIVE_PLAN_ID
-    }) : {};
-    const targetProcessEnv = targetIdentityEnv(input.resolvedTarget.target);
-    const shell = resolveHostShell(input.message.command);
-    const ptyProcess = createNodePtyBridge({
-      file: shell.file,
-      args: shell.args,
-      ptyOptions: {
-        name: "xterm-256color",
-        cols: Math.max(1, Math.min(Math.floor(input.message.cols || 80), 500)),
-        rows: Math.max(1, Math.min(Math.floor(input.message.rows || 24), 500)),
-        cwd: input.resolvedTarget.rootPath,
-        env: {
-          ...process.env,
-          ...githubProcessEnv(),
-          ...input.message.env ?? {},
-          ...planProcessEnv,
-          ...targetProcessEnv
-        }
-      },
-      onOpened: () => {
-        sendWorkerMessage(input.ws, {
-          type: "pty_opened",
-          requestId: input.message.requestId,
-          ptyId: input.message.ptyId
-        });
-      },
-      onOutput: (data) => {
-        sendWorkerMessage(input.ws, {
-          type: "pty_output",
-          ptyId: input.message.ptyId,
-          data
-        });
-      },
-      onExit: (event) => {
-        activePtys.delete(input.message.ptyId);
-        sendWorkerMessage(input.ws, {
-          type: "pty_exit",
-          ptyId: input.message.ptyId,
-          exitCode: event.exitCode,
-          signal: event.signal
-        });
-      },
-      onError: (error) => {
-        activePtys.delete(input.message.ptyId);
-        sendWorkerMessage(input.ws, {
-          type: "pty_error",
-          requestId: input.message.requestId,
-          ptyId: input.message.ptyId,
-          error: error.message
-        });
-      }
-    });
-    activePtys.set(input.message.ptyId, {
-      ...ptyProcess,
-      target: input.resolvedTarget.target
-    });
-  } catch (error) {
-    sendWorkerMessage(input.ws, {
-      type: "pty_error",
-      requestId: input.message.requestId,
-      ptyId: input.message.ptyId,
-      error: error instanceof Error ? error.message : String(error)
-    });
+  if (activePtys.has(input.message.ptyId)) {
+    throw new Error(`Shell ${input.message.ptyId} is already open`);
   }
+  const planProcessEnv = !(input.resolvedTarget.target.type === "workspace" && input.resolvedTarget.target.rootProfile === "canonical_sync") ? preparePlanEnvForShell({
+    target: input.resolvedTarget.target,
+    planRoot: input.planRoot,
+    activePlanId: input.message.env?.R5D_ACTIVE_PLAN_ID
+  }) : {};
+  const targetProcessEnv = targetIdentityEnv(input.resolvedTarget.target);
+  const shell = resolveHostShell(input.message.command);
+  const ptyProcess = createNodePtyBridge({
+    file: shell.file,
+    args: shell.args,
+    ptyOptions: {
+      name: "xterm-256color",
+      cols: Math.max(1, Math.min(Math.floor(input.message.cols || 80), 500)),
+      rows: Math.max(1, Math.min(Math.floor(input.message.rows || 24), 500)),
+      cwd: input.resolvedTarget.rootPath,
+      env: {
+        ...process.env,
+        ...githubProcessEnv(),
+        ...input.message.env ?? {},
+        ...planProcessEnv,
+        ...targetProcessEnv
+      }
+    },
+    onOpened: () => {
+      sendWorkerMessage(input.ws, {
+        type: "pty_opened",
+        requestId: input.message.requestId,
+        ptyId: input.message.ptyId
+      });
+    },
+    onOutput: (data) => {
+      sendWorkerMessage(input.ws, {
+        type: "pty_output",
+        ptyId: input.message.ptyId,
+        data
+      });
+    },
+    onExit: (event) => {
+      input.releaseWorkspaceMutation();
+      activePtys.delete(input.message.ptyId);
+      sendWorkerMessage(input.ws, {
+        type: "pty_exit",
+        ptyId: input.message.ptyId,
+        exitCode: event.exitCode,
+        signal: event.signal
+      });
+    },
+    onError: (error) => {
+      input.releaseWorkspaceMutation();
+      activePtys.delete(input.message.ptyId);
+      sendWorkerMessage(input.ws, {
+        type: "pty_error",
+        requestId: input.message.requestId,
+        ptyId: input.message.ptyId,
+        error: error.message
+      });
+    }
+  });
+  activePtys.set(input.message.ptyId, {
+    ...ptyProcess,
+    target: input.resolvedTarget.target,
+    releaseWorkspaceMutation: input.releaseWorkspaceMutation
+  });
 }
 function writePty(ws, message) {
   const ptyProcess = activePtys.get(message.ptyId);
@@ -2397,7 +2396,6 @@ async function startWorker(options) {
   import_node_fs.default.mkdirSync(planRoot, { recursive: true });
   const manifestByProjectId = /* @__PURE__ */ new Map();
   const pendingManifestCheckouts = /* @__PURE__ */ new Map();
-  const workspaceSyncSingleFlight = new import_workspace_sync.WorkspaceSyncSingleFlight();
   let workspaceRemoteUrl = null;
   let activeWorkspaceIncidentId = null;
   let previousPeriodicFingerprint = null;
@@ -2423,8 +2421,32 @@ async function startWorker(options) {
       ...overrides
     };
   };
-  const sendWorkspaceSyncResult = (requestId, result) => {
-    sendWorkerMessage(ws, { type: "workspace_sync_result", requestId, result });
+  const sendWorkspaceSyncResult = (authority, result) => {
+    try {
+      ws.send(JSON.stringify({ type: "workspace_sync_result", ...authority, result }));
+    } catch (error) {
+      process.stderr.write(
+        `[r5d-worker] failed to send workspace_sync_result on its issuing connection: ${error instanceof Error ? error.message : String(error)}
+`
+      );
+    }
+  };
+  const requestWorkspaceSync = (trigger, fingerprint) => {
+    try {
+      ws.send(
+        JSON.stringify({
+          type: "workspace_sync_requested",
+          observationId: crypto.randomUUID(),
+          trigger,
+          ...fingerprint ? { fingerprint } : {}
+        })
+      );
+    } catch (error) {
+      process.stderr.write(
+        `[r5d-worker] failed to send workspace sync observation on its current connection: ${error instanceof Error ? error.message : String(error)}
+`
+      );
+    }
   };
   const manifestCheckoutKey = (projectId, branchName) => `${projectId}\0${branchName}`;
   const allManifestCheckouts = () => [...manifestByProjectId.values()].flatMap(
@@ -2475,7 +2497,7 @@ async function startWorker(options) {
     }
     return created;
   };
-  const runRequestedWorkspaceSync = async (requestId, trigger, overrides = {}) => {
+  const runRequestedWorkspaceSync = async (authority, trigger, overrides = {}) => {
     workspaceSyncRequestsInFlight += 1;
     try {
       let pendingTargets = [];
@@ -2519,7 +2541,7 @@ async function startWorker(options) {
         }
       }
       previousPeriodicFingerprint = null;
-      sendWorkspaceSyncResult(requestId, result);
+      sendWorkspaceSyncResult(authority, result);
       return result;
     } catch (error) {
       const result = {
@@ -2539,7 +2561,7 @@ async function startWorker(options) {
         error: error instanceof Error ? error.message : String(error)
       };
       previousPeriodicFingerprint = null;
-      sendWorkspaceSyncResult(requestId, result);
+      sendWorkspaceSyncResult(authority, result);
       return result;
     } finally {
       workspaceSyncRequestsInFlight -= 1;
@@ -2551,6 +2573,7 @@ async function startWorker(options) {
     }
   });
   let lastServerHeartbeatAt = null;
+  let heartbeatBusyGrace = null;
   let heartbeatTimedOut = false;
   let heartbeatWatchdog;
   const stopHeartbeatWatchdog = () => {
@@ -2562,7 +2585,7 @@ async function startWorker(options) {
   ws.addEventListener("open", () => {
     currentWorkerSocket = ws;
     heartbeatWatchdog = setInterval(() => {
-      if (heartbeatTimedOut || !(0, import_heartbeat.hasWorkerHeartbeatTimedOut)(lastServerHeartbeatAt)) {
+      if (heartbeatTimedOut || !(0, import_heartbeat.hasWorkerHeartbeatTimedOutWithBusyGrace)(lastServerHeartbeatAt, heartbeatBusyGrace)) {
         return;
       }
       heartbeatTimedOut = true;
@@ -2582,7 +2605,8 @@ async function startWorker(options) {
         capabilities: {
           updateClis: true,
           canonicalResolverCheckout: true,
-          browserPortForwarding: true
+          browserPortForwarding: true,
+          globalWorkspaceSyncLeaseV1: true
         },
         projectRoot: projectsRoot,
         artifactRoot,
@@ -2609,33 +2633,35 @@ async function startWorker(options) {
         return;
       }
       if (message.type === "workspace_manifest") {
-        configureGitHubAuth(message.githubCredential);
-        visibleGitIdentity = message.gitIdentity;
-        workspaceRemoteUrl = message.workspaceRemoteUrl;
-        const previousCheckoutKeys = new Set(
-          allManifestCheckouts().map(({ projectId, branchName }) => manifestCheckoutKey(projectId, branchName))
-        );
-        const migratedProjectIds = (0, import_managed_paths.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);
-          if (previousCheckoutKeys.has(key)) continue;
-          const branchPath = import_node_path.default.join(projectRootFor(projectsRoot, checkout.projectId, manifestByProjectId), checkout.branchName);
-          if (!hasNormalVisibleGitDir(branchPath)) pendingManifestCheckouts.set(key, checkout);
-        }
-        previousPeriodicFingerprint = null;
-        process.stdout.write(
-          `[r5d-worker] workspace manifest: ${message.projects.length} projects${migratedProjectIds.length > 0 ? `; migrated ${migratedProjectIds.length} project checkout root(s)` : ""}
+        await workspaceSyncSingleFlight.runMutation(() => {
+          configureGitHubAuth(message.githubCredential);
+          visibleGitIdentity = message.gitIdentity;
+          workspaceRemoteUrl = message.workspaceRemoteUrl;
+          const previousCheckoutKeys = new Set(
+            allManifestCheckouts().map(({ projectId, branchName }) => manifestCheckoutKey(projectId, branchName))
+          );
+          const migratedProjectIds = (0, import_managed_paths.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);
+            if (previousCheckoutKeys.has(key)) continue;
+            const branchPath = import_node_path.default.join(projectRootFor(projectsRoot, checkout.projectId, manifestByProjectId), checkout.branchName);
+            if (!hasNormalVisibleGitDir(branchPath)) pendingManifestCheckouts.set(key, checkout);
+          }
+          previousPeriodicFingerprint = null;
+          process.stdout.write(
+            `[r5d-worker] workspace manifest: ${message.projects.length} projects${migratedProjectIds.length > 0 ? `; migrated ${migratedProjectIds.length} project checkout root(s)` : ""}
 `
-        );
+          );
+        });
         if (!periodicWorkspaceScan) {
           const emptyFingerprint = (0, import_node_crypto.createHash)("sha256").update("").digest("hex");
           periodicWorkspaceScan = setInterval(() => {
@@ -2652,7 +2678,7 @@ async function startWorker(options) {
               );
               if (hasPendingGenericCheckout) {
                 previousPeriodicFingerprint = null;
-                await runRequestedWorkspaceSync(crypto.randomUUID(), {
+                requestWorkspaceSync({
                   type: "periodic",
                   detail: "workspace manifest additions"
                 });
@@ -2668,7 +2694,7 @@ async function startWorker(options) {
                 return;
               }
               previousPeriodicFingerprint = null;
-              await runRequestedWorkspaceSync(crypto.randomUUID(), { type: "periodic" });
+              requestWorkspaceSync({ type: "periodic" }, fingerprint);
             })().catch((error) => {
               process.stderr.write(
                 `[r5d-worker] periodic workspace synchronization failed: ${error instanceof Error ? error.message : String(error)}
@@ -2676,6 +2702,7 @@ async function startWorker(options) {
               );
             }).finally(() => {
               periodicWorkspaceScanInFlight = false;
+              heartbeatBusyGrace = (0, import_heartbeat.grantWorkerHeartbeatBusyGrace)(lastServerHeartbeatAt, heartbeatBusyGrace);
             });
           }, import_workspace_sync.WORKSPACE_PERIODIC_SCAN_INTERVAL_MS);
           periodicWorkspaceScan.unref();
@@ -2683,23 +2710,23 @@ async function startWorker(options) {
         return;
       }
       if (message.type === "sync_workspace") {
-        await runRequestedWorkspaceSync(message.requestId, message.trigger, {
-          attemptId: message.attemptId,
-          confirmedLargeDiff: message.confirmedLargeDiff,
-          confirmationReason: message.confirmationReason,
-          resetToCanonical: message.resetToCanonical,
-          skipVisibleMirror: message.skipVisibleMirror
-        });
-        return;
-      }
-      if (message.type === "workspace_head_updated") {
-        if (!activeWorkspaceIncidentId) {
-          await runRequestedWorkspaceSync(
-            crypto.randomUUID(),
-            { type: "inbound_head", detail: message.commitHash },
-            { skipVisibleMirror: true }
-          );
-        }
+        await runRequestedWorkspaceSync(
+          {
+            requestId: message.requestId,
+            intentId: message.intentId,
+            leaseEpoch: message.leaseEpoch,
+            leaseToken: message.leaseToken
+          },
+          message.trigger,
+          {
+            attemptId: message.attemptId,
+            quarantineRef: message.quarantineRef,
+            confirmedLargeDiff: message.confirmedLargeDiff,
+            confirmationReason: message.confirmationReason,
+            resetToCanonical: message.resetToCanonical,
+            skipVisibleMirror: message.skipVisibleMirror
+          }
+        );
         return;
       }
       if (message.type === "sync_session_artifacts") {
@@ -2729,8 +2756,17 @@ async function startWorker(options) {
         return;
       }
       if (message.type === "workspace_incident_updated") {
-        activeWorkspaceIncidentId = message.status === "remediating" || message.status === "waiting_for_worker" ? message.incidentId : null;
+        const previousIncidentId = activeWorkspaceIncidentId;
+        activeWorkspaceIncidentId = (0, import_workspace_incident_state.applyWorkspaceIncidentUpdate)(activeWorkspaceIncidentId, message);
         previousPeriodicFingerprint = null;
+        const releasedHead = (0, import_workspace_incident_state.releasePendingWorkspaceHead)(
+          previousIncidentId,
+          activeWorkspaceIncidentId,
+          message.status === "resolved" || message.status === "confirmed" || message.status === "reset" ? message.incidentId : null
+        );
+        if (releasedHead.syncHead) {
+          requestWorkspaceSync({ type: "inbound_head", detail: releasedHead.syncHead });
+        }
         return;
       }
       if (message.type === "exec_terminal_ack") {
@@ -2787,6 +2823,7 @@ async function startWorker(options) {
       }
       if (message.type === "ping") {
         lastServerHeartbeatAt = Date.now();
+        heartbeatBusyGrace = null;
         ws.send(JSON.stringify({ type: "pong" }));
         return;
       }
@@ -2827,11 +2864,14 @@ async function startWorker(options) {
           });
           return;
         }
+        const releaseWorkspaceMutation = await workspaceSyncSingleFlight.acquireMutation();
+        let leaseTransferred = false;
         try {
           const resolvedTarget = resolveMessageTarget(message.target);
           process.stdout.write(`[r5d-worker] pty ${message.ptyId}: ${describeWorkerSessionTarget(message.target)}
 `);
-          await openPty({ ws, message, resolvedTarget, planRoot });
+          await openPty({ ws, message, resolvedTarget, planRoot, releaseWorkspaceMutation });
+          leaseTransferred = true;
         } catch (error) {
           sendWorkerMessage(ws, {
             type: "pty_error",
@@ -2839,6 +2879,8 @@ async function startWorker(options) {
             ptyId: message.ptyId,
             error: error instanceof Error ? error.message : String(error)
           });
+        } finally {
+          if (!leaseTransferred) releaseWorkspaceMutation();
         }
         return;
       }
@@ -2867,10 +2909,12 @@ async function startWorker(options) {
         }
         let result;
         try {
-          const resolvedTarget = resolveMessageTarget(message.target);
-          process.stdout.write(`[r5d-worker] exec ${message.runId}: ${message.argv.join(" ")}
+          result = await workspaceSyncSingleFlight.runMutation(async () => {
+            const resolvedTarget = resolveMessageTarget(message.target);
+            process.stdout.write(`[r5d-worker] exec ${message.runId}: ${message.argv.join(" ")}
 `);
-          result = await executeCommand({ message, resolvedTarget, baseUrl, token, artifactRoot, planRoot });
+            return await executeCommand({ message, resolvedTarget, baseUrl, token, artifactRoot, planRoot });
+          });
         } catch (error) {
           result = {
             type: "exec_result",
@@ -2899,11 +2943,11 @@ async function startWorker(options) {
           requestId: message.requestId,
           runId: message.runId
         });
-        try {
+        void workspaceSyncSingleFlight.runMutation(async () => {
           const resolvedTarget = resolveMessageTarget(message.target);
           process.stdout.write(`[r5d-worker] exec_start ${message.runId}: ${message.argv.join(" ")}
 `);
-          void executeStreamingCommand({
+          await executeStreamingCommand({
             ws,
             message,
             resolvedTarget,
@@ -2911,34 +2955,29 @@ async function startWorker(options) {
             token,
             artifactRoot,
             planRoot
-          }).catch((error) => {
-            sendWorkerMessage(ws, {
-              type: "exec_start_error",
-              requestId: message.requestId,
-              runId: message.runId,
-              error: error instanceof Error ? error.message : String(error)
-            });
           });
-        } catch (error) {
+        }).catch((error) => {
           sendWorkerMessage(ws, {
             type: "exec_start_error",
             requestId: message.requestId,
             runId: message.runId,
             error: error instanceof Error ? error.message : String(error)
           });
-        }
+        });
         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") {
         try {
-          const resolvedTarget = resolveMessageTarget(message.target);
-          const result = await executeOperation({
-            message,
-            resolvedTarget,
-            baseUrl,
-            token,
-            artifactRoot,
-            planRoot
+          const result = await workspaceSyncSingleFlight.runMutation(async () => {
+            const resolvedTarget = resolveMessageTarget(message.target);
+            return await executeOperation({
+              message,
+              resolvedTarget,
+              baseUrl,
+              token,
+              artifactRoot,
+              planRoot
+            });
           });
           ws.send(
             JSON.stringify({
@@ -2971,6 +3010,8 @@ async function startWorker(options) {
     })().catch((error) => {
       process.stderr.write(`[r5d-worker] message handling failed: ${error instanceof Error ? error.message : String(error)}
 `);
+    }).finally(() => {
+      heartbeatBusyGrace = (0, import_heartbeat.grantWorkerHeartbeatBusyGrace)(lastServerHeartbeatAt, heartbeatBusyGrace);
     });
   });
   ws.addEventListener("close", (event) => {

package/dist/cjs/package.json

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

package/dist/cjs/workspace-incident-state.cjs

@@ -0,0 +1,39 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var workspace_incident_state_exports = {};
+__export(workspace_incident_state_exports, {
+  applyWorkspaceIncidentUpdate: () => applyWorkspaceIncidentUpdate,
+  releasePendingWorkspaceHead: () => releasePendingWorkspaceHead
+});
+module.exports = __toCommonJS(workspace_incident_state_exports);
+function applyWorkspaceIncidentUpdate(currentIncidentId, update) {
+  if (update.status === "remediating" || update.status === "waiting_for_worker") return update.incidentId;
+  if (currentIncidentId && update.incidentId && update.incidentId !== currentIncidentId) return currentIncidentId;
+  return null;
+}
+function releasePendingWorkspaceHead(previousIncidentId, currentIncidentId, terminalIncidentId) {
+  if (!previousIncidentId || currentIncidentId) return { syncHead: null };
+  if (terminalIncidentId === previousIncidentId) return { syncHead: "authoritative" };
+  return { syncHead: null };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  applyWorkspaceIncidentUpdate,
+  releasePendingWorkspaceHead
+});