@ricsam/r5d-worker 0.0.111 → 0.0.112

package/dist/cjs/main.cjs

@@ -62,7 +62,8 @@ var import_plan_lint = require("./plan-lint.cjs");
 var import_node_fs = __toESM(require("node:fs"), 1);
 var import_recovery_store = require("./recovery-store.cjs");
 var import_recovery_output_window = require("./recovery-output-window.cjs");
-var import_job_resources = require("./job-resources.cjs");
+var import_command_launcher = require("./command-launcher.cjs");
+var import_inline_output = require("./inline-output.cjs");
 var import_recovery_protocol = require("./recovery-protocol.cjs");
 var import_node_path = __toESM(require("node:path"), 1);
 var import_node_crypto = require("node:crypto");
@@ -155,7 +156,7 @@ const PTY_INPUT_BUSY_GRACE_MS = 3e3;
 const PTY_FOREGROUND_POLL_MS = 1e3;
 const PTY_FOREGROUND_IDLE_ENABLED = process.env.R5D_PTY_FOREGROUND_IDLE !== "0";
 const PTY_TMP_PATH_PREFIX = "r5d-worker-tmp://";
-let workerJobResources;
+let workerCommandLauncher;
 const activeProcesses = /* @__PURE__ */ new Map();
 const credentialBearingProcessGroups = /* @__PURE__ */ new Map();
 const credentialBearingProcessGroupTargets = /* @__PURE__ */ new Map();
@@ -175,6 +176,41 @@ let workerExecutionLeaseDeadline = 0;
 let workerExecutionLeaseTimer;
 let workerLeaseExpired = false;
 const infrastructureStoppedRunIds = /* @__PURE__ */ new Set();
+let launcherFailureInProgress = false;
+let runtimeExitPromise;
+function fenceWorkerRuntimeOperations() {
+  launcherFailureInProgress = true;
+  workerAdmissionGeneration += 1;
+  for (const operation of recoveryStore?.operations() ?? []) {
+    if (operation.state !== "completed") recoveryStore?.unknown(operation.requestId);
+  }
+  for (const runId of workerCommandLauncher?.activeIds ?? []) {
+    infrastructureStoppedRunIds.add(runId);
+    cancelledProcessRuns.add(runId);
+    recoveryStore?.unknownRun(runId);
+  }
+  for (const runId of activeProcesses.keys()) infrastructureStoppedRunIds.add(runId);
+}
+function exitWorkerRuntime(code) {
+  if (runtimeExitPromise) return runtimeExitPromise;
+  fenceWorkerRuntimeOperations();
+  runtimeExitPromise = (async () => {
+    await Promise.race([
+      Promise.allSettled([terminateActiveCredentialBearingChildren(), workerCommandLauncher?.close()]),
+      Bun.sleep(4e3)
+    ]);
+    process.exit(code);
+  })();
+  return runtimeExitPromise;
+}
+function handleWorkerCommandLauncherFailure(error) {
+  if (!workerCommandLauncher || launcherFailureInProgress) return;
+  fenceWorkerRuntimeOperations();
+  process.stderr.write(`[r5d-worker] ${error.message}; stopping runtime for communication recovery
+`);
+  currentWorkerSocket?.close(1012, "Command launcher recovery");
+  void exitWorkerRuntime(import_supervisor.WORKER_RECONNECT_EXIT_CODE);
+}
 function isWorkerCommunicationFailure(message) {
   return /Could not resolve host|Couldn't connect|Failed to connect|Connection reset|Connection timed out|remote end hung up|Empty reply|requested URL returned error: (?:408|429|5\d\d)|fetch failed|socket connection|ECONNRESET|ECONNREFUSED|ETIMEDOUT|Unable to connect|network connection was lost|Worker communication recovery expired|operation was aborted due to timeout|operation timed out|Failed to (?:fetch|download).*\((?:408|429|5\d\d)\)/i.test(
     message
@@ -204,22 +240,18 @@ function renewWorkerExecutionLease(leaseMs) {
     () => {
       if (Date.now() < workerExecutionLeaseDeadline) return;
       workerLeaseExpired = true;
-      try {
-        workerJobResources?.cancelMatching((id) => id.startsWith("pty:"));
-      } catch (error) {
-        process.stderr.write(`[r5d-worker] expired PTY resource termination failed: ${error}
+      void workerCommandLauncher?.cancelMatching((id) => id.startsWith("pty:")).catch((error) => {
+        process.stderr.write(`[r5d-worker] expired PTY launcher cancellation failed: ${error}
 `);
-      }
+      });
       closeAllPtys();
       for (const operation of recoveryStore?.operations() ?? []) {
         if (operation.sessionId && operation.state !== "completed") {
           recoveryStore?.cancelSession(operation.sessionId);
-          try {
-            workerJobResources?.cancelSession(operation.sessionId);
-          } catch (error) {
-            process.stderr.write(`[r5d-worker] expired command resource termination failed: ${error}
+          void workerCommandLauncher?.cancelSession(operation.sessionId).catch((error) => {
+            process.stderr.write(`[r5d-worker] expired command launcher cancellation failed: ${error}
 `);
-          }
+          });
         }
       }
       for (const [runId, active] of activeProcesses) {
@@ -1584,7 +1616,9 @@ async function fenceCredentialGenerationAtConfigureEntry(input) {
   await input.terminatePreviousGeneration();
   return true;
 }
-function requireCredentialGenerationRestart(required, fatalExit = (exitCode2) => process.exit(exitCode2), exitCode = 1) {
+function requireCredentialGenerationRestart(required, fatalExit = (exitCode2) => {
+  void exitWorkerRuntime(exitCode2);
+}, exitCode = 1) {
   if (!required) return;
   fatalExit(exitCode);
   throw new Error("Credential generation restart callback returned unexpectedly");
@@ -2750,27 +2784,28 @@ async function prepareShellEnvForTarget(input) {
     ...targetProcessEnv(input.rootDir, input.target)
   };
 }
-async function releaseWorkerJobResources(resources) {
-  if (!resources) return;
-  try {
-    await resources.release();
-  } catch (error) {
-    process.stderr.write(`[r5d-worker] job resource cleanup failed: ${error instanceof Error ? error.message : String(error)}
+async function releaseWorkerCommandLaunch(resources) {
+  await resources?.release();
+}
+function cancelWorkerCommandLaunch(resources) {
+  void resources.cancel().catch((error) => {
+    process.stderr.write(`[r5d-worker] command launcher cancellation failed: ${error instanceof Error ? error.message : String(error)}
 `);
-  }
+  });
 }
-async function acquireWorkerCommandResources(ws, message, assertAdmission) {
+async function acquireWorkerCommandLaunch(ws, message, assertAdmission) {
   const id = message.type === "pty_open" ? `pty:${message.ptyId}` : message.runId;
   const operationId = message.type === "pty_open" ? id : `exec:${id}`;
   sendWorkerMessage(ws, { type: "heartbeat_lease", operationId, active: true });
   try {
-    return await workerJobResources.acquire({
+    return await workerCommandLauncher.acquire({
       id,
-      lane: message.type === "exec" && message.workspaceEffect === "none" ? "utility" : "general",
+      kind: message.type,
+      ..."workspaceEffect" in message && message.workspaceEffect === "none" ? { workspaceEffect: "none" } : {},
       ..."sessionId" in message && message.sessionId ? { sessionId: message.sessionId } : {},
       assertAdmission: () => {
         assertAdmission();
-        if (cancelledProcessRuns.has(id)) throw new import_job_resources.WorkerJobCancelledError();
+        if (cancelledProcessRuns.has(id)) throw new import_command_launcher.CommandLaunchCancelledError();
       }
     });
   } finally {
@@ -2829,7 +2864,7 @@ async function executeCommand(input) {
     settlePreparation();
     if (input.message.timeoutMs) {
       timeout = setTimeout(() => {
-        input.resources.kill();
+        cancelWorkerCommandLaunch(input.resources);
         void (0, import_process_tree.terminateProcessTree)(subprocess).catch((error) => {
           process.stderr.write(
             `[r5d-worker] failed to terminate timed-out command ${input.message.runId}: ${error instanceof Error ? error.message : String(error)}
@@ -2839,10 +2874,11 @@ async function executeCommand(input) {
       }, input.message.timeoutMs);
     }
     outputReaders = [
-      (0, import_job_resources.collectWorkerInlineOutput)(subprocess.stdout, void 0, outputAbort.signal),
-      (0, import_job_resources.collectWorkerInlineOutput)(subprocess.stderr, void 0, outputAbort.signal)
+      (0, import_inline_output.collectWorkerInlineOutput)(subprocess.stdout, void 0, outputAbort.signal),
+      (0, import_inline_output.collectWorkerInlineOutput)(subprocess.stderr, void 0, outputAbort.signal)
     ];
     const [stdout, stderr, exitCode] = await Promise.all([outputReaders[0], outputReaders[1], subprocess.exited]);
+    const diagnostic = await input.resources.diagnose();
     return {
       type: "exec_result",
       requestId: input.message.requestId,
@@ -2850,14 +2886,12 @@ async function executeCommand(input) {
       stderr,
       exitCode,
       durationMs: Date.now() - startedAt,
-      ...input.resources.memoryLimitExceeded() ? {
-        error: `Command exceeded its worker memory limit (${input.resources.memoryBytes} bytes). Reduce parallelism or memory use and retry.`
-      } : {}
+      ...diagnostic ? { error: diagnostic } : {}
     };
   } catch (error) {
     outputAbort.abort(error);
-    if (error instanceof StaleWorkerAdmissionError) throw error;
-    input.resources.kill();
+    if (error instanceof StaleWorkerAdmissionError || error instanceof import_command_launcher.CommandLauncherUnavailableError) throw error;
+    cancelWorkerCommandLaunch(input.resources);
     return {
       type: "exec_result",
       requestId: input.message.requestId,
@@ -2877,12 +2911,14 @@ async function executeCommand(input) {
     }
     outputAbort.abort();
     await Promise.allSettled(outputReaders);
+    await releaseWorkerCommandLaunch(input.resources);
     activeProcesses.delete(input.message.runId);
   }
 }
 async function executeStreamingCommand(input) {
   const startedAt = Date.now();
   let started = false;
+  let terminal;
   let timedOut = false;
   let timeout;
   let spawnedProcess;
@@ -2894,7 +2930,7 @@ async function executeStreamingCommand(input) {
   };
   input.setPreparationHeartbeatLease(true);
   try {
-    if (cancelledProcessRuns.delete(input.message.runId)) {
+    if (cancelledProcessRuns.has(input.message.runId)) {
       sendWorkerMessage(input.ws, {
         type: "exec_start_error",
         requestId: input.message.requestId,
@@ -2957,7 +2993,7 @@ async function executeStreamingCommand(input) {
     if (input.message.timeoutMs) {
       timeout = setTimeout(() => {
         timedOut = true;
-        input.resources.kill();
+        cancelWorkerCommandLaunch(input.resources);
         closeProcessStdin(activeProcesses.get(input.message.runId));
         void (0, import_process_tree.terminateProcessTree)(subprocess).catch((error) => {
           process.stderr.write(
@@ -2986,18 +3022,19 @@ async function executeStreamingCommand(input) {
         });
       })
     ]);
-    if (input.resources.memoryLimitExceeded()) {
+    const diagnostic = await input.resources.diagnose();
+    if (diagnostic) {
       sendWorkerMessage(input.ws, {
         type: "exec_output",
         runId: input.message.runId,
         stream: "stderr",
         data: `
-[r5d-worker] Command exceeded its memory limit (${input.resources.memoryBytes} bytes). Reduce parallelism or memory use and retry.
+[r5d-worker] ${diagnostic}
 `
       });
     }
     const canonicalWorkspaceHead = canonicalSyncTerminalHead(input.resolvedTarget);
-    const terminal = {
+    terminal = {
       type: "exec_exit",
       runId: input.message.runId,
       exitCode,
@@ -3006,14 +3043,12 @@ async function executeStreamingCommand(input) {
       ...input.message.workspaceEffect === "none" ? { workspaceEffect: "none" } : {},
       ...canonicalWorkspaceHead ? { canonicalWorkspaceHead } : {}
     };
-    pendingProcessTerminals.set(input.message.runId, terminal);
-    sendWorkerMessage(input.ws, terminal);
   } catch (error) {
-    if (!started && error instanceof StaleWorkerAdmissionError) throw error;
+    if (error instanceof import_command_launcher.CommandLauncherUnavailableError || !started && error instanceof StaleWorkerAdmissionError) throw error;
     const message = error instanceof Error ? error.message : String(error);
     if (started) {
       const canonicalWorkspaceHead = canonicalSyncTerminalHead(input.resolvedTarget);
-      const terminal = {
+      terminal = {
         type: "exec_error",
         runId: input.message.runId,
         error: message,
@@ -3021,8 +3056,6 @@ async function executeStreamingCommand(input) {
         ...input.message.workspaceEffect === "none" ? { workspaceEffect: "none" } : {},
         ...canonicalWorkspaceHead ? { canonicalWorkspaceHead } : {}
       };
-      pendingProcessTerminals.set(input.message.runId, terminal);
-      sendWorkerMessage(input.ws, terminal);
     } else {
       sendWorkerMessage(input.ws, {
         type: "exec_start_error",
@@ -3040,9 +3073,14 @@ async function executeStreamingCommand(input) {
     if (spawnedProcess) {
       await reapCompletedCredentialBearingProcessGroup(input.message.runId, spawnedProcess);
     }
+    await releaseWorkerCommandLaunch(input.resources);
     activeProcesses.delete(input.message.runId);
     cancelledProcessRuns.delete(input.message.runId);
   }
+  if (terminal) {
+    pendingProcessTerminals.set(input.message.runId, terminal);
+    sendWorkerMessage(input.ws, terminal);
+  }
 }
 async function reapCompletedCredentialBearingProcessGroup(runId, subprocess) {
   try {
@@ -3082,6 +3120,7 @@ function sendReplayWorkerMessage(ws, message) {
   return message.type === "exec_output" ? workerOutputWindow.send(message, send, target.bufferedAmount) : send(message);
 }
 function sendWorkerMessage(ws, message) {
+  if (launcherFailureInProgress) return;
   if (recoveryStore && "requestId" in message && typeof message.requestId === "string" && recoveryStore.isUnknown(message.requestId))
     return;
   const transportError = "error" in message && typeof message.error === "string" ? message.error : message.type === "workspace_sync_result" && message.result.outcome === "failed" ? message.result.error : void 0;
@@ -3443,6 +3482,29 @@ async function openPty(input) {
     envFilesRemoved = true;
     removePtyEnvFiles(stagedEnvFiles.paths);
   };
+  let terminalHandled = false;
+  const finishPty = async (terminal) => {
+    if (terminalHandled) return;
+    terminalHandled = true;
+    try {
+      const diagnostic = await input.resources.diagnose();
+      if (diagnostic) outputCoalescer.push(`\r
+[r5d-worker] ${diagnostic}\r
+`);
+    } finally {
+      cleanupEnvFiles();
+      await releaseWorkerCommandLaunch(input.resources);
+      outputCoalescer.flush();
+      activePtys.delete(input.message.ptyId);
+      input.releaseWorkspaceMutation?.();
+      input.onTerminal?.();
+    }
+    sendWorkerMessage(input.ws, terminal);
+  };
+  const reportPtyCleanupFailure = (error) => {
+    process.stderr.write(`[r5d-worker] PTY launcher cleanup failed: ${error instanceof Error ? error.message : String(error)}
+`);
+  };
   try {
     const ptyProcess = createNodePtyBridge({
       file: shellArgv[0],
@@ -3475,38 +3537,14 @@ async function openPty(input) {
         outputCoalescer.push(data);
       },
       onExit: (event) => {
-        if (input.resources.memoryLimitExceeded())
-          outputCoalescer.push(
-            `\r
-[r5d-worker] Terminal exceeded its memory limit (${input.resources.memoryBytes} bytes). Reduce parallelism or memory use and retry.\r
-`
-          );
-        outputCoalescer.flush();
-        input.releaseWorkspaceMutation?.();
-        activePtys.delete(input.message.ptyId);
-        cleanupEnvFiles();
-        input.onTerminal?.();
-        void releaseWorkerJobResources(input.resources);
-        sendWorkerMessage(input.ws, {
-          type: "pty_exit",
-          ptyId: input.message.ptyId,
-          exitCode: event.exitCode,
-          signal: event.signal
-        });
+        void finishPty({ type: "pty_exit", ptyId: input.message.ptyId, exitCode: event.exitCode, signal: event.signal }).catch(
+          reportPtyCleanupFailure
+        );
       },
       onError: (error) => {
-        outputCoalescer.flush();
-        input.releaseWorkspaceMutation?.();
-        activePtys.delete(input.message.ptyId);
-        cleanupEnvFiles();
-        input.onTerminal?.();
-        void releaseWorkerJobResources(input.resources);
-        sendWorkerMessage(input.ws, {
-          type: "pty_error",
-          requestId: input.message.requestId,
-          ptyId: input.message.ptyId,
-          error: error.message
-        });
+        void finishPty({ type: "pty_error", requestId: input.message.requestId, ptyId: input.message.ptyId, error: error.message }).catch(
+          reportPtyCleanupFailure
+        );
       },
       onTerminationError: (error) => {
         sendWorkerMessage(input.ws, {
@@ -3549,8 +3587,12 @@ function resizePty(message) {
   }
   ptyProcess.resize(Math.max(1, Math.min(Math.floor(message.cols || 80), 500)), Math.max(1, Math.min(Math.floor(message.rows || 24), 500)));
 }
-function closePty(message) {
-  workerJobResources?.cancel(`pty:${message.ptyId}`);
+async function closePty(message) {
+  try {
+    await workerCommandLauncher?.cancel(`pty:${message.ptyId}`);
+  } finally {
+    activePtys.get(message.ptyId)?.kill();
+  }
   const ptyProcess = activePtys.get(message.ptyId);
   if (!ptyProcess) {
     return;
@@ -3642,9 +3684,15 @@ async function startWorker(options, projectRuntime = {
   initializeCredentialStoreDirectoryOnce();
   const label = requireValue(options.label, "Missing required --label <label>");
   validateLabel(label);
-  if (!workerJobResources) {
-    workerJobResources = (0, import_job_resources.createWorkerJobResources)();
-    process.stdout.write(`[r5d-worker] job resources: ${workerJobResources.isolation}; ${JSON.stringify(workerJobResources.budget)}
+  if (!workerCommandLauncher) {
+    const launcher = await (0, import_command_launcher.createWorkerCommandLauncher)({
+      configuration: process.env.R5D_WORKER_COMMAND_LAUNCHER,
+      env: (0, import_command_launcher.commandLauncherEnvironment)(),
+      onFailure: handleWorkerCommandLauncherFailure
+    });
+    workerCommandLauncher = launcher;
+    await launcher.initialize();
+    process.stdout.write(`[r5d-worker] command launcher: ${launcher.mode}
 `);
   }
   const rootDir = import_node_path.default.resolve(options.rootDir ?? process.env.R5D_ROOT ?? defaultRootDir());
@@ -4887,7 +4935,7 @@ async function startWorker(options, projectRuntime = {
             `[r5d-worker] workspace synchronization failed without a recoverable hydration basis; exiting for exact recovery after ${unsafeWorkspaceSyncRecoveryAttempts} in-process recovery attempt(s): ${errorMessage}
 `
           );
-          process.exit(exitCode);
+          void exitWorkerRuntime(exitCode);
         },
         exitCode: 1
       });
@@ -5698,7 +5746,7 @@ async function startWorker(options, projectRuntime = {
       if (ws.readyState === WebSocket.OPEN || ws.readyState === WebSocket.CONNECTING) {
         ws.close(1e3, "Worker shutting down");
       } else {
-        process.exit(0);
+        await exitWorkerRuntime(0);
       }
     })().catch((error) => {
       process.stderr.write(`[r5d-worker] graceful workspace sync failed: ${error instanceof Error ? error.message : String(error)}
@@ -5851,14 +5899,14 @@ async function startWorker(options, projectRuntime = {
       }
       if (message.type === "cancel_session") {
         recoveryStore.cancelSession(message.sessionId);
-        workerJobResources?.cancelSession(message.sessionId);
-        await Promise.all(
-          [...activeProcesses].filter(([, active]) => active.sessionId === message.sessionId).map(async ([runId, active]) => {
+        await Promise.all([
+          workerCommandLauncher?.cancelSession(message.sessionId),
+          ...[...activeProcesses].filter(([, active]) => active.sessionId === message.sessionId).map(async ([runId, active]) => {
             cancelledProcessRuns.add(runId);
             closeProcessStdin(active);
             await (0, import_process_tree.terminateProcessTree)(active.process);
           })
-        );
+        ]);
         sendWorkerMessage(ws, { type: "cancel_session_ack", cancellationId: message.cancellationId });
         return;
       }
@@ -6305,7 +6353,7 @@ async function startWorker(options, projectRuntime = {
           });
           return;
         }
-        if (activeProcesses.size > 0 || activePtys.size > 0 || workspaceSyncRequestsInFlight > 0 || sessionArtifactSyncRequestsInFlight > 0) {
+        if (activeProcesses.size > 0 || (workerCommandLauncher?.activeIds.length ?? 0) > 0 || activePtys.size > 0 || workspaceSyncRequestsInFlight > 0 || sessionArtifactSyncRequestsInFlight > 0) {
           sendWorkerMessage(ws, {
             type: "update_clis_result",
             requestId: message.requestId,
@@ -6340,7 +6388,7 @@ async function startWorker(options, projectRuntime = {
       if (message.type === "cancel") {
         let resourceCancellationError;
         try {
-          workerJobResources?.cancel(message.runId);
+          await workerCommandLauncher?.cancel(message.runId);
         } catch (error) {
           resourceCancellationError = error instanceof Error ? error.message : String(error);
         }
@@ -6452,7 +6500,7 @@ async function startWorker(options, projectRuntime = {
         let releaseWorkspaceMutation;
         let mutationLeaseTransferred = false;
         try {
-          resources = await acquireWorkerCommandResources(ws, message, assertMessageAdmission);
+          resources = await acquireWorkerCommandLaunch(ws, message, assertMessageAdmission);
           await (0, import_workspace_command_sync_policy.reserveWorkspaceCommandAfterCurrentSync)(message.target, workspaceSyncSingleFlight, () => {
             workspaceSyncPriorityPtyTargets.set(message.ptyId, message.target);
             if (targetMayMutateVisibleWorkspace(message.target)) recordVisibleWorkspaceMutation(message.target);
@@ -6491,8 +6539,8 @@ async function startWorker(options, projectRuntime = {
           });
         } finally {
           workspaceSyncPriorityPtyTargets.delete(message.ptyId);
+          if (!resourcesTransferred) await releaseWorkerCommandLaunch(resources);
           if (!mutationLeaseTransferred) releaseWorkspaceMutation?.();
-          if (!resourcesTransferred) await releaseWorkerJobResources(resources);
         }
         return;
       }
@@ -6521,7 +6569,7 @@ async function startWorker(options, projectRuntime = {
       }
       if (message.type === "pty_close") {
         const activePty = activePtys.get(message.ptyId);
-        closePty(message);
+        await closePty(message);
         if (activePty && targetMayMutateVisibleWorkspace(activePty.target)) {
           markWorkspaceDirty({ type: "process_terminal", detail: `pty ${message.ptyId} closed` }, true, activePty.target);
         }
@@ -6555,7 +6603,7 @@ async function startWorker(options, projectRuntime = {
         let targetReserved = false;
         const hasWorkspaceEffect = workerCommandHasWorkspaceEffect(message);
         try {
-          resources = await acquireWorkerCommandResources(ws, message, assertMessageAdmission);
+          resources = await acquireWorkerCommandLaunch(ws, message, assertMessageAdmission);
           if (hasWorkspaceEffect) {
             await (0, import_workspace_command_sync_policy.reserveWorkspaceCommandAfterCurrentSync)(message.target, workspaceSyncSingleFlight, () => {
               workspaceSyncPriorityProcessTargets.set(message.runId, message.target);
@@ -6609,7 +6657,7 @@ async function startWorker(options, projectRuntime = {
           };
         } finally {
           if (targetReserved) workspaceSyncPriorityProcessTargets.delete(message.runId);
-          await releaseWorkerJobResources(resources);
+          await releaseWorkerCommandLaunch(resources);
           cancelledProcessRuns.delete(message.runId);
         }
         if (infrastructureStoppedRunIds.has(message.runId)) {
@@ -6683,7 +6731,7 @@ async function startWorker(options, projectRuntime = {
         const execution = (async () => {
           let targetReserved = false;
           try {
-            resources = await acquireWorkerCommandResources(ws, message, assertMessageAdmission);
+            resources = await acquireWorkerCommandLaunch(ws, message, assertMessageAdmission);
             if (hasWorkspaceEffect) {
               await (0, import_workspace_command_sync_policy.reserveWorkspaceCommandAfterCurrentSync)(message.target, workspaceSyncSingleFlight, () => {
                 workspaceSyncPriorityProcessTargets.set(message.runId, message.target);
@@ -6699,7 +6747,7 @@ async function startWorker(options, projectRuntime = {
             });
           } finally {
             if (targetReserved) workspaceSyncPriorityProcessTargets.delete(message.runId);
-            await releaseWorkerJobResources(resources);
+            await releaseWorkerCommandLaunch(resources);
             cancelledProcessRuns.delete(message.runId);
           }
         })();
@@ -6831,11 +6879,10 @@ async function startWorker(options, projectRuntime = {
     const reason = event.reason ? `: ${event.reason}` : "";
     process.stderr.write(`[r5d-worker] disconnected (${event.code}${reason})
 `);
-    if (reloadAfterClose) {
-      process.exit(import_supervisor.WORKER_RELOAD_EXIT_CODE);
-    }
-    if (shutdownAfterClose) {
-      process.exit(0);
+    if (launcherFailureInProgress) return;
+    if (reloadAfterClose || shutdownAfterClose) {
+      void exitWorkerRuntime(reloadAfterClose ? import_supervisor.WORKER_RELOAD_EXIT_CODE : 0);
+      return;
     }
     const reconnect = () => {
       const delay = (0, import_supervisor.workerReconnectDelayMs)(Math.random, workerReconnectAttempt++);
@@ -6893,10 +6940,10 @@ async function main() {
     try {
       await startWorker(parsed.options);
     } catch (error) {
-      if (error instanceof WorkerServerUnavailableError) {
+      if (error instanceof WorkerServerUnavailableError || error instanceof import_command_launcher.CommandLauncherUnavailableError) {
         process.stderr.write(`[r5d-worker] ${error.message}
 `);
-        process.exit(import_supervisor.WORKER_RECONNECT_EXIT_CODE);
+        await exitWorkerRuntime(import_supervisor.WORKER_RECONNECT_EXIT_CODE);
       }
       throw error;
     }
@@ -6914,10 +6961,10 @@ function isCliEntrypoint() {
   return typeof require === "function" && typeof module !== "undefined" && require.main === module;
 }
 if (isCliEntrypoint()) {
-  main().catch((error) => {
+  main().catch(async (error) => {
     process.stderr.write(`[r5d-worker] ${error instanceof Error ? error.message : String(error)}
 `);
-    process.exit(1);
+    await exitWorkerRuntime(1);
   });
 }
 // Annotate the CommonJS export names for ESM import in node:

package/dist/cjs/package.json

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

package/dist/cjs/supervisor.cjs

@@ -54,7 +54,7 @@ function workerReconnectDelayMs(random = Math.random, attempt = 0) {
   return floor + Math.floor(sample * (ceiling - floor));
 }
 async function defaultRuntimeReaper(runtime) {
-  await (0, import_process_tree.terminateProcessTree)(runtime);
+  await (0, import_process_tree.terminateProcessTree)(runtime, { graceMs: 6e3 });
 }
 function isRetryableWorkerServerStatus(status) {
   return status === 408 || status === 429 || status >= 500;