@ricsam/r5d-worker 0.0.111 → 0.0.113

package/dist/mjs/main.mjs

@@ -6,10 +6,12 @@ import fs from "node:fs";
 import { WorkerRecoveryStore, workerOperationDigest } from "./recovery-store.mjs";
 import { WorkerOutputWindow } from "./recovery-output-window.mjs";
 import {
-  createWorkerJobResources,
-  collectWorkerInlineOutput,
-  WorkerJobCancelledError
-} from "./job-resources.mjs";
+  createWorkerCommandLauncher,
+  commandLauncherEnvironment,
+  CommandLaunchCancelledError,
+  CommandLauncherUnavailableError
+} from "./command-launcher.mjs";
+import { collectWorkerInlineOutput } from "./inline-output.mjs";
 import {
   WORKER_RESUMABLE_PROTOCOL,
   WORKER_RECOVERY_TIMEOUT_MS
@@ -173,7 +175,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();
@@ -193,6 +195,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(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
@@ -222,22 +259,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) {
@@ -1602,7 +1635,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");
@@ -2768,27 +2803,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 WorkerJobCancelledError();
+        if (cancelledProcessRuns.has(id)) throw new CommandLaunchCancelledError();
       }
     });
   } finally {
@@ -2847,7 +2883,7 @@ async function executeCommand(input) {
     settlePreparation();
     if (input.message.timeoutMs) {
       timeout = setTimeout(() => {
-        input.resources.kill();
+        cancelWorkerCommandLaunch(input.resources);
         void 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)}
@@ -2861,6 +2897,7 @@ async function executeCommand(input) {
       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,
@@ -2868,14 +2905,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 CommandLauncherUnavailableError) throw error;
+    cancelWorkerCommandLaunch(input.resources);
     return {
       type: "exec_result",
       requestId: input.message.requestId,
@@ -2895,12 +2930,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;
@@ -2912,7 +2949,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,
@@ -2975,7 +3012,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 terminateProcessTree(subprocess).catch((error) => {
           process.stderr.write(
@@ -3004,18 +3041,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,
@@ -3024,14 +3062,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 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,
@@ -3039,8 +3075,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",
@@ -3058,9 +3092,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 {
@@ -3100,6 +3139,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;
@@ -3461,6 +3501,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],
@@ -3493,38 +3556,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, {
@@ -3567,8 +3606,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;
@@ -3660,9 +3703,15 @@ async function startWorker(options, projectRuntime = {
   initializeCredentialStoreDirectoryOnce();
   const label = requireValue(options.label, "Missing required --label <label>");
   validateLabel(label);
-  if (!workerJobResources) {
-    workerJobResources = createWorkerJobResources();
-    process.stdout.write(`[r5d-worker] job resources: ${workerJobResources.isolation}; ${JSON.stringify(workerJobResources.budget)}
+  if (!workerCommandLauncher) {
+    const launcher = await createWorkerCommandLauncher({
+      configuration: process.env.R5D_WORKER_COMMAND_LAUNCHER,
+      env: commandLauncherEnvironment(),
+      onFailure: handleWorkerCommandLauncherFailure
+    });
+    workerCommandLauncher = launcher;
+    await launcher.initialize();
+    process.stdout.write(`[r5d-worker] command launcher: ${launcher.mode}
 `);
   }
   const rootDir = path.resolve(options.rootDir ?? process.env.R5D_ROOT ?? defaultRootDir());
@@ -4905,7 +4954,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
       });
@@ -5716,7 +5765,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)}
@@ -5869,14 +5918,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 terminateProcessTree(active.process);
           })
-        );
+        ]);
         sendWorkerMessage(ws, { type: "cancel_session_ack", cancellationId: message.cancellationId });
         return;
       }
@@ -6323,7 +6372,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,
@@ -6358,7 +6407,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);
         }
@@ -6470,7 +6519,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 reserveWorkspaceCommandAfterCurrentSync(message.target, workspaceSyncSingleFlight, () => {
             workspaceSyncPriorityPtyTargets.set(message.ptyId, message.target);
             if (targetMayMutateVisibleWorkspace(message.target)) recordVisibleWorkspaceMutation(message.target);
@@ -6509,8 +6558,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;
       }
@@ -6539,7 +6588,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);
         }
@@ -6573,7 +6622,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 reserveWorkspaceCommandAfterCurrentSync(message.target, workspaceSyncSingleFlight, () => {
               workspaceSyncPriorityProcessTargets.set(message.runId, message.target);
@@ -6627,7 +6676,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)) {
@@ -6701,7 +6750,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 reserveWorkspaceCommandAfterCurrentSync(message.target, workspaceSyncSingleFlight, () => {
                 workspaceSyncPriorityProcessTargets.set(message.runId, message.target);
@@ -6717,7 +6766,7 @@ async function startWorker(options, projectRuntime = {
             });
           } finally {
             if (targetReserved) workspaceSyncPriorityProcessTargets.delete(message.runId);
-            await releaseWorkerJobResources(resources);
+            await releaseWorkerCommandLaunch(resources);
             cancelledProcessRuns.delete(message.runId);
           }
         })();
@@ -6849,11 +6898,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(WORKER_RELOAD_EXIT_CODE);
-    }
-    if (shutdownAfterClose) {
-      process.exit(0);
+    if (launcherFailureInProgress) return;
+    if (reloadAfterClose || shutdownAfterClose) {
+      void exitWorkerRuntime(reloadAfterClose ? WORKER_RELOAD_EXIT_CODE : 0);
+      return;
     }
     const reconnect = () => {
       const delay = workerReconnectDelayMs(Math.random, workerReconnectAttempt++);
@@ -6911,10 +6959,10 @@ async function main() {
     try {
       await startWorker(parsed.options);
     } catch (error) {
-      if (error instanceof WorkerServerUnavailableError) {
+      if (error instanceof WorkerServerUnavailableError || error instanceof CommandLauncherUnavailableError) {
         process.stderr.write(`[r5d-worker] ${error.message}
 `);
-        process.exit(WORKER_RECONNECT_EXIT_CODE);
+        await exitWorkerRuntime(WORKER_RECONNECT_EXIT_CODE);
       }
       throw error;
     }
@@ -6932,10 +6980,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);
   });
 }
 export {

package/dist/mjs/package.json

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

package/dist/mjs/supervisor.mjs

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

package/dist/types/command-launcher.d.ts

@@ -0,0 +1,61 @@
+export type CommandLaunchRequest = {
+    id: string;
+    kind: "exec" | "exec_start" | "pty_open";
+    workspaceEffect?: "none";
+    sessionId?: string;
+    assertAdmission: () => void;
+};
+export type CommandLaunchLease = {
+    wrap(argv: string[]): string[];
+    cancel(): Promise<void>;
+    diagnose(): Promise<string | undefined>;
+    release(): Promise<void>;
+};
+export declare class CommandLauncherUnavailableError extends Error {
+    constructor(message: string, cause?: unknown);
+}
+export declare class CommandLaunchCancelledError extends Error {
+    constructor();
+}
+export declare function parseCommandLauncher(configuration: string | undefined): string[] | undefined;
+/** Launcher configuration is operator-owned; do not inherit worker or package credentials. */
+export declare function commandLauncherEnvironment(source?: NodeJS.ProcessEnv): NodeJS.ProcessEnv;
+/** Generic optional JSONL controller; policy and OS-specific launch prefixes live outside the worker. */
+export declare class WorkerCommandLauncher {
+    private readonly options;
+    readonly mode: "direct" | "external";
+    private readonly child?;
+    private readonly pending;
+    private readonly launches;
+    private readonly exited;
+    private failure?;
+    private closing;
+    private initialized;
+    private closePromise?;
+    private sequence;
+    constructor(options?: {
+        argv?: string[];
+        env?: NodeJS.ProcessEnv;
+        onFailure?: (error: Error, ids: string[]) => void;
+        onStderr?: (text: string) => void;
+        requestTimeoutMs?: number;
+        acquisitionTimeoutMs?: number;
+    });
+    initialize(): Promise<void>;
+    get activeIds(): string[];
+    acquire(request: CommandLaunchRequest): Promise<CommandLaunchLease>;
+    cancel(id: string): Promise<void>;
+    cancelSession(sessionId: string): Promise<void>;
+    cancelMatching(matches: (id: string, sessionId?: string) => boolean): Promise<void>;
+    close(): Promise<void>;
+    private waitForExit;
+    private releaseRecord;
+    private assertHealthy;
+    private rpc;
+    private receive;
+    private rejectPending;
+    private fail;
+}
+export declare function createWorkerCommandLauncher(options?: Omit<NonNullable<ConstructorParameters<typeof WorkerCommandLauncher>[0]>, "argv"> & {
+    configuration?: string;
+}): Promise<WorkerCommandLauncher>;

package/dist/types/inline-output.d.ts

@@ -0,0 +1,3 @@
+export declare const WORKER_INLINE_OUTPUT_MAX_BYTES: number;
+/** Bound inline RPC buffers in the worker regardless of child launch policy. */
+export declare function collectWorkerInlineOutput(stream: ReadableStream<Uint8Array> | null, maxBytes?: number, signal?: AbortSignal): Promise<string>;

package/dist/types/supervisor-launcher-cleanup-fixture.d.ts

@@ -0,0 +1 @@
+export {};

package/package.json

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