@oar-sh/oar 0.9.12 → 0.9.14

package/server/services/restart-resume-service.mjs

@@ -0,0 +1,303 @@
+'use strict';
+
+/**
+ * "After a relay restart, tell interrupted sessions to carry on" (opt-in,
+ * per relay, off by default).
+ *
+ * Session workers outlive the relay's runtime, and a turn whose worker lived
+ * through the restart simply goes on. A turn whose worker did not (it died
+ * with the relay, or came back without the turn) is dealt with by the
+ * recovery paths, and most of them requeue it: the row runs again by itself,
+ * and nothing more is needed. A few cannot run again, because the prompt
+ * already reached the agent and a second delivery would run it twice:
+ *
+ *  - a background continuation (a turn the agent opened itself), torn down;
+ *  - a steer the CLI had already taken (`consumed_at`), failed;
+ *  - a turn that had started (activity, a stream) when its live worker no
+ *    longer claimed it, failed instead of replayed (`turn-replay-blocked`).
+ *
+ * The agent never hears that its turn stopped. With the setting on, such a
+ * session gets ONE note of the relay's in the conversation once its rows are
+ * settled: the relay restarted, the turn was interrupted, check what you
+ * were doing and carry on. The user's message is never sent again.
+ *
+ * Which turns count: the rows that were `processing` when this runtime
+ * started (`captureBoot`), followed through the recovery paths
+ * (`noteOutcome`). A row its worker claims after the start (a heartbeat
+ * that lists it: the worker lived through the restart and has the turn) is
+ * the restart's no more: whatever ends it later is not put down to it.
+ * A conversation gets a note when one of its rows was cut off and none was
+ * requeued (that one runs again: a note would double the work), claimed by
+ * a worker that lived through the restart, or failed for another reason.
+ * Nothing for idle sessions, nothing when
+ * the setting is off when the note would be sent, nothing for an archived or
+ * deleted conversation, nothing while a usage-limit follow-up is held (it
+ * carries the turn on itself), at most one note per conversation and
+ * runtime. The note is an ordinary pending row, queued behind whatever the
+ * user has queued already, so it never jumps ahead of a user message; its
+ * delivery starts the session's worker as for any message.
+ */
+
+import { randomUUID } from 'node:crypto';
+
+export const RESTART_RESUME_SETTING_KEY = 'restart_resume_notes';
+export const RESTART_RESUME_KIND = 'relay-restart-resume';
+export const RESTART_RESUME_LEAD = 'Automatic message from OAR, not from the user:';
+
+// How long after the start a cut-off turn is still put down to the restart.
+const DEFAULT_WINDOW_MS = 30 * 60_000;
+
+/** The stored value as on or off; off unless it was switched on. */
+export function readRestartResumeSetting(raw) {
+  return ['1', 'true', 'on'].includes(String(raw ?? '').trim().toLowerCase());
+}
+
+export function parseRestartResumeUpdate(value) {
+  if (typeof value !== 'boolean') return { ok: false, error: 'enabled must be true or false' };
+  return { ok: true, enabled: value };
+}
+
+function defaultFormatTime(ms) {
+  const at = new Date(Number(ms));
+  if (!Number.isFinite(at.getTime())) return 'just now';
+  return `${at.toISOString().slice(0, 16).replace('T', ' ')} UTC`;
+}
+
+/** The note's text. */
+export function buildRestartResumeNoteText({ restartedAt, formatTime = defaultFormatTime } = {}) {
+  return `${RESTART_RESUME_LEAD} the relay restarted at ${formatTime(restartedAt)}, and the turn you were working on was interrupted before it finished. `
+    + 'Check where you were (the files you changed, the commands and background tasks you started) and carry on from there. '
+    + 'Do not repeat steps that already completed; if the work was already done, say so briefly.';
+}
+
+const OUTCOMES = new Set(['cut', 'requeued', 'failed', 'claimed']);
+
+function text(value) {
+  return String(value ?? '').trim();
+}
+
+export function createRestartResumeService({
+  db,
+  stmts,
+  isEnabled = () => false,
+  emit = () => {},
+  wake = () => {},
+  now = () => Date.now(),
+  bootAt = now(),
+  windowMs = DEFAULT_WINDOW_MS,
+  formatTime = defaultFormatTime,
+  logger = console,
+} = {}) {
+  if (!db || !stmts) throw new Error('createRestartResumeService requires db and stmts');
+  const listProcessing = db.prepare(`
+    SELECT id, conversation_id, model, model_variant_id, reasoning_effort, context_tier, relay_mode,
+           owner_sdk_session_id, runtime_session_id
+    FROM queue WHERE status = 'processing'
+  `);
+  const statusOf = db.prepare(`SELECT status FROM queue WHERE id = ?`);
+  let heldPause = null;
+  try {
+    // A held usage-limit follow-up (usage-limit-pause-service.mjs).
+    heldPause = db.prepare(`
+      SELECT 1 FROM queue
+      WHERE conversation_id = ? AND status = 'pending' AND usage_limit_pause IS NOT NULL
+      LIMIT 1
+    `);
+  } catch {}
+
+  // queue id → conversation id, for the rows processing at the start.
+  const watched = new Map();
+  // conversation id → { rows: Map(queue id → { row, outcome }) }
+  const conversations = new Map();
+  // Conversations that had their note in this runtime.
+  const noted = new Set();
+
+  function log(line) {
+    try { logger?.log?.(`[restart-resume] ${line}`); } catch {}
+  }
+
+  function expired() {
+    return now() - bootAt > windowMs;
+  }
+
+  /** The rows processing when this runtime started; returns how many. */
+  function captureBoot() {
+    let rows = [];
+    try { rows = listProcessing.all(); } catch {}
+    for (const row of rows) {
+      const conversationId = text(row.conversation_id);
+      const id = text(row.id);
+      if (!conversationId || !id) continue;
+      watched.set(id, conversationId);
+      let entry = conversations.get(conversationId);
+      if (!entry) conversations.set(conversationId, entry = { rows: new Map() });
+      entry.rows.set(id, { row, outcome: null });
+    }
+    if (rows.length) log(`${rows.length} turn(s) were running when the relay started; following them`);
+    return rows.length;
+  }
+
+  /**
+   * What a recovery path did with a row: `cut` (it cannot run again),
+   * `requeued` (it runs again by itself) or `failed` (ended for another
+   * reason); or `claimed`: its worker, alive after the restart, holds it.
+   * Only the rows of the start count, and only their first outcome.
+   */
+  function noteOutcome(row, outcome) {
+    const id = text(row?.id ?? row);
+    const conversationId = watched.get(id);
+    if (!conversationId || !OUTCOMES.has(outcome)) return false;
+    watched.delete(id);
+    const entry = conversations.get(conversationId)?.rows.get(id);
+    if (entry && !entry.outcome) entry.outcome = outcome;
+    settle(conversationId);
+    return true;
+  }
+
+  // Decides a conversation once none of its rows of the start is processing.
+  function settle(conversationId) {
+    const entry = conversations.get(conversationId);
+    if (!entry) return;
+    for (const [id, item] of entry.rows) {
+      if (item.outcome) continue;
+      let status = '';
+      try { status = text(statusOf.get(id)?.status).toLowerCase(); } catch {}
+      if (status === 'processing') return;
+      // Back in the queue by a path that did not say so: it runs again.
+      item.outcome = status === 'pending' || status === 'parked' ? 'requeued' : 'settled';
+      watched.delete(id);
+    }
+    conversations.delete(conversationId);
+    const outcomes = [...entry.rows.values()].map((item) => item.outcome);
+    if (!outcomes.includes('cut')) return;
+    if (outcomes.includes('requeued')) {
+      log(`conv=${conversationId.slice(0, 8)} no note: the interrupted turn runs again by itself`);
+      return;
+    }
+    if (outcomes.includes('claimed')) {
+      log(`conv=${conversationId.slice(0, 8)} no note: its worker lived through the restart and has its turn`);
+      return;
+    }
+    if (outcomes.includes('failed')) {
+      log(`conv=${conversationId.slice(0, 8)} no note: the turn failed, the failure says what to do`);
+      return;
+    }
+    const cut = [...entry.rows.values()].find((item) => item.outcome === 'cut')?.row || null;
+    sendNote(conversationId, cut);
+  }
+
+  function skip(conversationId, why) {
+    log(`conv=${conversationId.slice(0, 8)} no note: ${why}`);
+    return null;
+  }
+
+  function sendNote(conversationId, cutRow) {
+    if (noted.has(conversationId)) return skip(conversationId, 'it had one after this restart');
+    let enabled = false;
+    try { enabled = isEnabled() === true; } catch {}
+    if (!enabled) return skip(conversationId, 'the setting is off');
+    const conversation = stmts.getConvAnyStatus?.get?.(conversationId) || null;
+    if (!conversation || text(conversation.status) === 'deleted') return skip(conversationId, 'the conversation is gone');
+    if (Number(conversation.archived) === 1) return skip(conversationId, 'the conversation is archived');
+    try {
+      if (heldPause?.get(conversationId)) return skip(conversationId, 'a usage-limit follow-up carries the turn on');
+    } catch {}
+    noted.add(conversationId);
+
+    const at = new Date(now()).toISOString();
+    const messageId = randomUUID();
+    const noteText = buildRestartResumeNoteText({ restartedAt: bootAt, formatTime });
+    const runtimeSession = stmts.getRuntimeSessionByConversation?.get?.(conversationId) || null;
+    const latestModel = stmts.getLatestConversationModel?.get?.(conversationId)?.model || null;
+    // The model and mode the interrupted turn ran with.
+    const model = text(cutRow?.model) || text(latestModel) || text(runtimeSession?.provider_model) || text(runtimeSession?.model) || null;
+    const modelVariant = text(cutRow?.model_variant_id) || model;
+    const relayMode = text(cutRow?.relay_mode) || 'agent';
+    const owner = text(cutRow?.owner_sdk_session_id) || text(runtimeSession?.sdk_session_id) || null;
+    const write = db.transaction(() => {
+      stmts.insertMsg.run(
+        messageId,
+        conversationId,
+        'user',
+        noteText,
+        modelVariant || null,
+        relayMode,
+        null,
+        at,
+        modelVariant || null,
+        null,
+        text(modelVariant).toLowerCase() === 'auto' ? 'auto' : 'manual',
+      );
+      stmts.setMessageKind?.run?.(RESTART_RESUME_KIND, messageId);
+      stmts.updateConvTime?.run?.(at, conversationId);
+      const queueArgs = [
+        messageId,
+        conversationId,
+        text(cutRow?.runtime_session_id) || runtimeSession?.id || null,
+        0,
+        model,
+        modelVariant || null,
+        text(cutRow?.reasoning_effort) || null,
+        text(cutRow?.context_tier) || null,
+        relayMode,
+        noteText,
+        null,
+        at,
+        owner,
+        owner ? at : null,
+        null,
+        null,
+      ];
+      if (stmts.queueHasImageOperationId || stmts.insertQ?.source?.includes?.('image_operation_id')) queueArgs.push(null);
+      stmts.insertQ.run(...queueArgs);
+    });
+    try {
+      write();
+    } catch (error) {
+      noted.delete(conversationId);
+      try { logger?.warn?.(`[restart-resume] conv=${conversationId.slice(0, 8)} note not queued: ${error?.message || error}`); } catch {}
+      return null;
+    }
+    try {
+      emit('user_message', {
+        conversationId,
+        messageId,
+        senderClientId: null,
+        message: {
+          role: 'user',
+          text: noteText,
+          model: modelVariant || null,
+          mode: relayMode,
+          attachments: [],
+          timestamp: at,
+          kind: RESTART_RESUME_KIND,
+        },
+      });
+    } catch {}
+    try { emit('message_status', { messageId, conversationId, status: 'pending' }); } catch {}
+    try { wake({ conversationId, ownerSessionId: owner, messageId }); } catch {}
+    log(`conv=${conversationId.slice(0, 8)} note queued: its turn was cut off by the restart`);
+    return messageId;
+  }
+
+  /** Decides the conversations whose rows settled on their own; ends the watch after the window. */
+  function tick() {
+    if (!conversations.size) return;
+    if (expired()) {
+      watched.clear();
+      conversations.clear();
+      return;
+    }
+    for (const conversationId of [...conversations.keys()]) settle(conversationId);
+  }
+
+  return {
+    captureBoot,
+    noteOutcome,
+    tick,
+    /** What is still followed, for tests and diagnostics. */
+    pending() {
+      return [...conversations.keys()];
+    },
+  };
+}

package/server/services/session-activity-tracker.mjs

@@ -25,7 +25,9 @@
  *  - `noteTaskSet` — every POST /api/background-tasks (REPLACE semantics):
  *    a new task id is a start, a task gone from the set has ended, a changed
  *    task (tool call, summary, tokens) is activity. A task that started
- *    before this runtime did was announced by the runtime before it.
+ *    before this runtime did was announced by the runtime before it. A task
+ *    that ended and is listed under another run (`taskRunId`: a resumed
+ *    Claude sub-agent keeps its task id) is a start again.
  *  - `noteTaskSettled` — how a task ended, where the worker says so (the
  *    Claude worker's task_notification). A task this runtime never knew
  *    still gets its end event when the worker describes it.
@@ -168,6 +170,11 @@ export function createSessionActivityTracker({
   const sessions = new Map();
   // Edges already reported for an end, by `${conversationId}:${key}`.
   const endedKeys = new Map();
+  // `${conversationId}:${taskId}` → the run of the task that ended (the
+  // SDK's run id, `taskRunId`), where the worker names one. A resumed Claude
+  // sub-agent keeps its task id and runs again under a new run id: a set
+  // that lists it with another run is a new start, not a late set.
+  const endedRuns = new Map();
   // `${conversationId}:${taskId}` of the ends nobody reported: the task was
   // only missing from a set for the grace. A later set that lists it again
   // says it never ended.
@@ -216,16 +223,25 @@ export function createSessionActivityTracker({
     for (const key of [task.taskId, task.toolUseId ? `run:${task.toolUseId}` : '']) {
       if (key) endedKeys.set(`${conversationId}:${key}`, at);
     }
+    if (task.taskRunId) endedRuns.set(`${conversationId}:${task.taskId}`, task.taskRunId);
+    else endedRuns.delete(`${conversationId}:${task.taskId}`);
     if (endedKeys.size > 2000) {
       for (const [key, when] of endedKeys) {
         if (at - when > RECENT_TASK_TTL_MS) {
           endedKeys.delete(key);
           endedByAbsence.delete(key);
+          endedRuns.delete(key);
         }
       }
     }
   }
 
+  /** The set lists an ended task under another run: it was resumed. */
+  function isNewRun(conversationId, taskId, taskRunId) {
+    const ended = endedRuns.get(`${conversationId}:${taskId}`);
+    return !!taskRunId && !!ended && ended !== taskRunId;
+  }
+
   function wasEnded(conversationId, task) {
     return [task.taskId, task.toolUseId ? `run:${task.toolUseId}` : '']
       .some((key) => key && endedKeys.has(`${conversationId}:${key}`));
@@ -308,6 +324,7 @@ export function createSessionActivityTracker({
   /** Takes back an end that was only an absence; the task's old row goes from the recent ones. */
   function unEnd(conversationId, entry, taskId, toolUseId) {
     endedByAbsence.delete(`${conversationId}:${taskId}`);
+    endedRuns.delete(`${conversationId}:${taskId}`);
     const index = entry.recent.findIndex((task) => task.taskId === taskId);
     const [old] = index >= 0 ? entry.recent.splice(index, 1) : [null];
     for (const key of [taskId, toolUseId ? `run:${toolUseId}` : '', old?.toolUseId ? `run:${old.toolUseId}` : '']) {
@@ -332,6 +349,7 @@ export function createSessionActivityTracker({
       seen.add(taskId);
       const signature = taskSignature(raw);
       const known = entry.live.get(taskId);
+      const taskRunId = toText(raw.taskRunId);
       if (known && !known.leftAtMs) {
         if (known.signature !== signature) {
           known.signature = signature;
@@ -340,32 +358,45 @@ export function createSessionActivityTracker({
         }
         known.description = toText(raw.description) || known.description;
         known.toolUseId = toText(raw.toolUseId) || known.toolUseId;
+        known.taskRunId = taskRunId || known.taskRunId;
         known.summary = toText(raw.summary) || known.summary;
         known.model = toText(raw.model) || known.model;
         continue;
       }
       if (known?.leftAtMs) {
-        // Back in the set after it left: it did not end after all.
-        if (known.graceTimer) clearTimer(known.graceTimer);
-        known.graceTimer = null;
-        known.leftAtMs = 0;
-        continue;
+        if (!taskRunId || !known.taskRunId || known.taskRunId === taskRunId) {
+          // Back in the set after it left: it did not end after all.
+          if (known.graceTimer) clearTimer(known.graceTimer);
+          known.graceTimer = null;
+          known.leftAtMs = 0;
+          continue;
+        }
+        // Back under another run (resumed within the grace): the run that
+        // left ended, how is not known; the new one starts below.
+        finishTask(id, known, { status: 'completed', reported: false });
       }
       let revived = null;
       if (wasEnded(id, { taskId, toolUseId: toText(raw.toolUseId) })) {
-        // Settled already (its notice came before the set dropped it).
-        if (!endedByAbsence.has(`${id}:${taskId}`)) continue;
-        // Ended only because a set did not list it (a set that arrived out
-        // of turn, a worker that left it out for a moment) and listed
-        // again: it never ended. It comes back as the task it was, with no
-        // second start. The end that was reported for it stays reported;
-        // its real end will be another.
-        revived = unEnd(id, entry, taskId, toText(raw.toolUseId)) || {};
+        if (isNewRun(id, taskId, taskRunId)) {
+          // Resumed: the same task, a new run. Its first run's end stays
+          // reported; this run starts (and will end) on its own.
+          unEnd(id, entry, taskId, toText(raw.toolUseId));
+        } else {
+          // Settled already (its notice came before the set dropped it).
+          if (!endedByAbsence.has(`${id}:${taskId}`)) continue;
+          // Ended only because a set did not list it (a set that arrived out
+          // of turn, a worker that left it out for a moment) and listed
+          // again: it never ended. It comes back as the task it was, with no
+          // second start. The end that was reported for it stays reported;
+          // its real end will be another.
+          revived = unEnd(id, entry, taskId, toText(raw.toolUseId)) || {};
+        }
       }
       const taskStartedAtMs = msOf(raw.startedAt);
       const task = {
         taskId,
         toolUseId: toText(raw.toolUseId) || null,
+        taskRunId: taskRunId || null,
         taskType: toText(raw.taskType),
         kind: taskKindOf(raw.taskType),
         description: toText(raw.description).slice(0, 500),
@@ -395,16 +426,21 @@ export function createSessionActivityTracker({
   }
 
   function noteTaskSettled(conversationId, {
-    taskId, toolUseId, status, summary, exitCode, description, taskType, startedAt,
+    taskId, toolUseId, taskRunId, status, summary, exitCode, description, taskType, startedAt,
   } = {}) {
     const id = toText(conversationId);
     if (!id) return;
     const entry = session(id);
     const key = toText(taskId);
     const run = toText(toolUseId);
+    const settledRun = toText(taskRunId);
     const task = (key && entry.live.get(key))
       || [...entry.live.values()].find((candidate) => run && candidate.toolUseId === run)
       || null;
+    // The end of an earlier run of a task that was resumed since (a notice
+    // the worker sent again late): the run that is live now goes on.
+    if (task && settledRun && task.taskRunId && task.taskRunId !== settledRun) return;
+    if (task && settledRun) task.taskRunId = settledRun;
     const settled = {
       status: normalizeTaskStatus(status || 'completed'),
       summary: toText(summary) || null,
@@ -439,6 +475,7 @@ export function createSessionActivityTracker({
       const unknown = {
         taskId: key,
         toolUseId: runId || null,
+        taskRunId: settledRun || null,
         taskType: toText(taskType),
         kind: taskKindOf(taskType),
         description: toText(description).slice(0, 500),

package/server/services/session-worker-launch-service.mjs

@@ -14,6 +14,7 @@ import {
   isOarMcpServerDisabled,
 } from '../mcp/oar-mcp-server.mjs';
 import { WORKER_LOG_FILE_ENV } from '../../shared/worker-runtime/worker-log-file.mjs';
+import { missingWorkingDirectoryError } from '../../shared/worker-runtime/working-directory.mjs';
 import {
   describeSpawnEnvironment,
   envPathKey,
@@ -213,6 +214,9 @@ export function applyCursorProviderEnvironment(env = {}, {
   enabled = false,
   model = '',
   apiKey = '',
+  // The relay's resolved, absolute data dir: the worker keeps its agent stores
+  // there, and must not resolve a relative one or the config's own again.
+  dataDir = '',
 } = {}) {
   const next = { ...env };
   if (resolveWorkerKind(next) === 'cursor') delete next.COPILOT_WEB_RELAY_WORKER_KIND;
@@ -225,6 +229,8 @@ export function applyCursorProviderEnvironment(env = {}, {
   next.CURSOR_API_KEY = normalizedApiKey;
   const normalizedModel = normalizeText(model);
   if (normalizedModel) next.CURSOR_RELAY_MODEL = normalizedModel;
+  const normalizedDataDir = normalizeText(dataDir);
+  if (normalizedDataDir) next.COPILOT_WEB_RELAY_DATA_DIR = path.resolve(normalizedDataDir);
   return next;
 }
 
@@ -717,6 +723,9 @@ export function buildTmuxWorkerShellCommand(targetSessionId, env = {}, {
     'COPILOT_WEB_RELAY_CONFIG',
     'COPILOT_WEB_RELAY_TOOLS',
     'COPILOT_WEB_RELAY_LOG_DIR',
+    // The Cursor worker keeps its agent stores in the relay's data dir
+    // (applyCursorProviderEnvironment).
+    'COPILOT_WEB_RELAY_DATA_DIR',
     'COPILOT_WEB_RELAY_CLI_EXECUTABLE',
     'COPILOT_WEB_RELAY_EXTENSION_BOOTSTRAP_PATH',
     'COPILOT_SDK_PATH',
@@ -847,6 +856,19 @@ export function describeWindowsStartFailure(state, { spawnCommand = 'cmd.exe', p
   return null;
 }
 
+/**
+ * A spawn whose folder is gone fails with ENOENT (or ENOTDIR), which reads as
+ * a missing program (`node`, `cmd.exe`). Asked only after a spawn failed: the folder
+ * is named instead, or null when it is there. Exported for the tests.
+ * (A tmux launch never gets here: `new-session -c` falls back to the home
+ * folder, and the worker reports the folder on the turn.)
+ */
+export function describeLaunchFolderFailure(state, folder, { check = missingWorkingDirectoryError } = {}) {
+  if (state?.error?.code !== 'ENOENT' && state?.error?.code !== 'ENOTDIR') return null;
+  const missing = check(folder);
+  return missing ? `worker-spawn-failed: ${missing.message}` : null;
+}
+
 function buildWorkerLaunchEnv({ processCwd, workspaceRoot, env = process.env } = {}) {
   const launchProcessCwd = String(processCwd || '').trim();
   const launchWorkspaceRoot = String(workspaceRoot || '').trim() || launchProcessCwd;
@@ -900,6 +922,8 @@ export async function launchSessionCli({
   // Where a launch that went wrong explains itself (one line per call).
   log = null,
   locateExecutableImpl = locateExecutable,
+  // Asked after a failed spawn whether its folder is gone (the error, or null).
+  checkWorkingDirectoryImpl = missingWorkingDirectoryError,
 } = {}) {
   const target = String(targetSessionId || '').trim();
   if (!target) throw new Error('missing-target-session-id');
@@ -1154,7 +1178,8 @@ export async function launchSessionCli({
     // `cmd /c start` returns at once when the program started. Still running,
     // or ended with an error, means it did not: name the program, and log the
     // command and the PATH it was looked up on.
-    const failure = describeWindowsStartFailure(childState, { spawnCommand, program: startedProgram });
+    const failure = describeLaunchFolderFailure(childState, launchProcessCwd, { check: checkWorkingDirectoryImpl })
+      || describeWindowsStartFailure(childState, { spawnCommand, program: startedProgram });
     if (failure) {
       if (childState.tracked && !childState.exited) {
         try { child.kill?.(); } catch {}
@@ -1176,6 +1201,11 @@ export async function launchSessionCli({
     // A failed spawn reports its error on the next tick.
     await new Promise((resolve) => setImmediate(resolve));
     const reason = childState.error?.code || childState.error?.message || '';
+    const folderFailure = describeLaunchFolderFailure(childState, launchProcessCwd, { check: checkWorkingDirectoryImpl });
+    if (folderFailure) {
+      explain(`could not start ${spawnCommand}: ${folderFailure}`);
+      throw new Error(folderFailure);
+    }
     explain(`could not start ${spawnCommand}${reason ? ` (${reason})` : ''}; ${spawnEnvironmentText()}`);
     throw new Error(`worker-spawn-unhealthy:missing-pid${reason ? ` (${spawnCommand}: ${reason})` : ''}`);
   }

package/server/services/session-worker-process-service.mjs

@@ -296,6 +296,8 @@ export function createSessionWorkerProcessInspector({
   platform = process.platform,
   execFileSyncImpl = execFileSync,
   execFileImpl = execFile,
+  // Where Windows keeps PowerShell (the bare name when it is not there).
+  systemToolPath = windowsSystemToolPath,
   now = () => Date.now(),
   snapshotCacheMs = SNAPSHOT_CACHE_MS,
   slowReadMs = SLOW_READ_MS,
@@ -320,7 +322,7 @@ export function createSessionWorkerProcessInspector({
 
   function getWindowsProcessSnapshot() {
     if (platform !== 'win32') return [];
-    const output = execFileSyncImpl(windowsSystemToolPath('powershell.exe'), ['-NoProfile', '-Command', WINDOWS_PROCESS_SNAPSHOT_SCRIPT], {
+    const output = execFileSyncImpl(systemToolPath('powershell.exe'), ['-NoProfile', '-Command', WINDOWS_PROCESS_SNAPSHOT_SCRIPT], {
       // stderr is kept (not shown): a failed read reports it.
       stdio: ['ignore', 'pipe', 'pipe'],
       windowsHide: true,
@@ -376,7 +378,7 @@ export function createSessionWorkerProcessInspector({
     if (platform !== 'win32') return Promise.resolve([]);
     return new Promise((resolve, reject) => {
       execFileImpl(
-        windowsSystemToolPath('powershell.exe'),
+        systemToolPath('powershell.exe'),
         ['-NoProfile', '-Command', WINDOWS_PROCESS_SNAPSHOT_SCRIPT],
         { windowsHide: true, timeout: WINDOWS_PROCESS_SNAPSHOT_TIMEOUT_MS, maxBuffer: WINDOWS_PROCESS_SNAPSHOT_MAX_BUFFER },
         (error, stdout, stderr) => {
@@ -545,7 +547,7 @@ export function createSessionWorkerProcessInspector({
   function stopWindowsPids(pids) {
     const ids = uniquePids(pids);
     if (!ids.length) return [];
-    execFileSyncImpl(windowsSystemToolPath('powershell.exe'), ['-NoProfile', '-Command', buildStopWindowsPidsScript(ids)], {
+    execFileSyncImpl(systemToolPath('powershell.exe'), ['-NoProfile', '-Command', buildStopWindowsPidsScript(ids)], {
       stdio: ['ignore', 'ignore', 'ignore'],
     });
     return ids;
@@ -557,7 +559,7 @@ export function createSessionWorkerProcessInspector({
     if (!ids.length) return Promise.resolve([]);
     return new Promise((resolve, reject) => {
       execFileImpl(
-        windowsSystemToolPath('powershell.exe'),
+        systemToolPath('powershell.exe'),
         ['-NoProfile', '-Command', buildStopWindowsPidsScript(ids)],
         { windowsHide: true, timeout: WINDOWS_STOP_TIMEOUT_MS, maxBuffer: WINDOWS_PROCESS_SNAPSHOT_MAX_BUFFER },
         (error) => {