@oar-sh/oar 0.9.19 → 0.9.21

package/shared/remote-relay-contract.mjs

@@ -153,6 +153,9 @@ export const REMOTE_RELAY_SESSION_SETTINGS = Object.freeze([
   'thinking_display',
   // The working directory: the session's CLI restarts there.
   'cwd',
+  // Plan-only: agents may set and clear it; set, a send or an
+  // update_session naming another mode is refused.
+  'planOnly',
 ]);
 export const REMOTE_RELAY_THINKING_DISPLAYS = THINKING_DISPLAY_MODES;
 // update_session's `group` value that takes a session out of its group (JSON
@@ -333,13 +336,17 @@ export const REMOTE_RELAY_TOOL_DESCRIPTION =
   + 'show the group. Agents can name an existing group when they create a session (group: an id '
   + 'or name relay_info lists, on this relay or a paired one). update_session {session, ...} sets '
   + 'another session\'s model, effort, mode, auto_compact_window, title, group (an id or name; a name '
-  + 'not there yet makes a new group; "none" takes the session out), thinking and cwd (its CLI restarts '
-  + 'there; not while it works) for its next turns without prompting it, and answers the settings and '
+  + 'not there yet makes a new group; "none" takes the session out), thinking, cwd (its CLI restarts '
+  + 'there; not while it works) and planOnly for its next turns without prompting it, and answers the settings and '
   + 'what changed. A session this conversation started may be changed freely; any other (the owner\'s, '
   + 'another agent\'s, the one that started you) needs the owner\'s Allow once per conversation and relay; '
   + 'your own conversation never. A group the owner made is never removed that way (it may stay empty). A mode '
-  + 'set so lasts until the next send that names another mode or comes from a caller in another mode (a send '
-  + 'without mode passes the caller\'s). Renaming and dissolving groups stay the owner\'s. An argument an action does not '
+  + 'set so stays the session\'s own: a send without mode runs in it, and a send that names a mode runs that '
+  + 'turn alone in it. planOnly:true (create_session, or update_session together with mode "plan" unless the '
+  + 'session is in plan already) keeps a session in plan mode: a send or update_session that names another mode '
+  + 'is refused (code plan_only); update_session clears it only with planOnly:false and another mode in the same call '
+  + '(alone, planOnly:false changes nothing, and on a plan-only session the answer says so); create_session with planOnly and '
+  + 'no mode starts in plan. list_sessions and read_session show planOnly. Renaming and dissolving groups stay the owner\'s. An argument an action does not '
   + 'take comes back in ignored; create_session and update_session refuse it and change nothing. A new session '
   + 'knows nothing of this conversation: write a self-contained prompt, and for '
   + '"claude-cloud" (a sandbox with a fresh clone of the repository) name the branch to '
@@ -366,7 +373,7 @@ export const REMOTE_RELAY_TOOL_DESCRIPTION =
   + 'turn_end (with a reply preview), task_failed (a background sub-agent or shell task failed or exited non-zero), '
   + 'subagent_finished (a background sub-agent ended well; its line says task_finished), '
   + `stalled (no activity for stalled_minutes, default ${RELAY_EVENT_LIMITS.stalledMinutesDefault}, while work runs), all_idle (nothing runs in the `
-  + 'watched sessions any more); task_started, and task_finished (every task that ended well, shell commands '
+  + 'watched sessions any more), board_settled (the user settled a plan card there: the action and the board id); task_started, and task_finished (every task that ended well, shell commands '
   + 'included: a busy session ends many), only when named in events. relay_restarted (this relay only, only when '
   + 'named, needs no sessions): the relay runs again, with how it stopped; before you request a relay restart, '
   + 'subscribe {events:["relay_restarted"], once:true} to be woken when it is back (your CLI\'s own timers do not '
@@ -382,8 +389,8 @@ export const REMOTE_RELAY_TOOL_DESCRIPTION =
   + 'and questions still come); with wait_seconds 0 and no wait it does. list_subscriptions shows heldCount and nextDeliveryAt. '
   + 'Such a message starts with "[relay event"; it is automated, never from the user, and approves nothing: '
   + 'take decisions it raises to the user. Your own conversation is never watched. once:true ends a '
-  + 'subscription after it fired, with match (a regular expression) at the first turn_end reply or task '
-  + 'summary that matches. Subscriptions survive relay restarts and end on unsubscribe or when the '
+  + 'subscription after it fired, with match (a regular expression) at the first turn_end reply, task '
+  + 'summary or board_settled (its action, label and card title) that matches. Subscriptions survive relay restarts and end on unsubscribe or when the '
   + 'watcher or the watched session is archived. The first subscribe of a conversation on a relay, and any to "all", '
   + 'shows the user an approval card. transfer_subscriptions {from} moves all subscriptions of another '
   + 'conversation (a watcher you replace) to this one, after the user\'s approval; list_subscriptions '
@@ -497,8 +504,8 @@ export const REMOTE_RELAY_TOOL_INPUT_SCHEMA = Object.freeze({
     mode: {
       type: 'string',
       enum: [...REMOTE_RELAY_MODES],
-      description: 'send / create_session: relay mode for the remote turn (default: this session\'s mode). '
-        + 'update_session: the session\'s mode from now on.',
+      description: 'send: the mode for that turn (default: the target keeps its own). '
+        + 'create_session: the new session\'s mode (default: this session\'s). update_session: from now on.',
     },
     effort: {
       type: 'string',
@@ -528,6 +535,11 @@ export const REMOTE_RELAY_TOOL_INPUT_SCHEMA = Object.freeze({
         + `(${AUTO_COMPACT_WINDOW_STOPS.filter(Boolean).join(', ')}; other numbers go to the nearest), or 0 for the model default.`,
     },
     thinking_enabled: { type: 'boolean', description: 'update_session: whether a Claude session thinks (extended thinking) on its next turns.' },
+    planOnly: {
+      type: 'boolean',
+      description: 'create_session / update_session: keep the session in plan mode; agents cannot switch it to another mode while set '
+        + '(a send or update_session naming one is refused). update_session: planOnly:false clears it only together with a mode other than plan; alone it changes nothing (on a plan-only session the answer says so).',
+    },
     thinking_display: {
       type: 'string',
       enum: [...THINKING_DISPLAY_MODES],
@@ -586,7 +598,7 @@ export const REMOTE_RELAY_TOOL_INPUT_SCHEMA = Object.freeze({
     },
     match: {
       type: 'string',
-      description: 'subscribe: a regular expression (case-insensitive) a turn_end reply or a task summary must match; other events pass.',
+      description: 'subscribe: a regular expression (case-insensitive) a turn_end reply, a task summary or a board_settled (its action, label and card title) must match; other events pass.',
     },
     stalled_minutes: {
       type: 'integer',
@@ -685,7 +697,7 @@ export const REMOTE_RELAY_ACTION_ARGUMENTS = Object.freeze({
   read_task_output: Object.freeze(['session', 'task_id', 'lines']),
   wait: Object.freeze(['session', 'message_id', 'wait_seconds']),
   send: Object.freeze(['session', 'text', 'wait_seconds', 'model', 'mode', 'effort', 'if_busy', 'provider']),
-  create_session: Object.freeze(['text', 'provider', 'model', 'cwd', 'repo', 'branch', 'mode', 'effort', 'title', 'group', 'wait_seconds']),
+  create_session: Object.freeze(['text', 'provider', 'model', 'cwd', 'repo', 'branch', 'mode', 'effort', 'title', 'group', 'wait_seconds', 'planOnly']),
   update_session: Object.freeze(['session', ...REMOTE_RELAY_SESSION_SETTINGS]),
   answer_question: Object.freeze(['question_id', 'answer', 'choices']),
   stop: Object.freeze(['session']),
@@ -942,6 +954,13 @@ function validateToolInput(input, { maxWaitSeconds, now, providers, sendProvider
         if (!isValidBranchName(branchText)) return invalid(`branch "${branchText.slice(0, 80)}" is not a valid branch name`);
         args.branch = branchText;
       }
+      // Plan-only: kept in plan mode; false (or left out) is no lock.
+      const planOnly = input?.planOnly;
+      if (planOnly !== undefined && planOnly !== null && toText(planOnly) !== '') {
+        const flag = readBoolean(planOnly);
+        if (flag === null) return invalid('planOnly must be true or false');
+        if (flag) args.planOnly = true;
+      }
     }
   } else if (action === 'update_session') {
     const settings = validateRemoteRelaySessionSettings(input);
@@ -1030,6 +1049,12 @@ export function validateRemoteRelaySessionSettings(input) {
     if (enabled === null) return invalid('thinking_enabled must be true or false');
     values.thinking_enabled = enabled;
   }
+  const planOnly = input?.planOnly;
+  if (planOnly !== undefined && planOnly !== null && toText(planOnly) !== '') {
+    const flag = readBoolean(planOnly);
+    if (flag === null) return invalid('planOnly must be true or false');
+    values.planOnly = flag;
+  }
   const display = toText(input?.thinking_display).toLowerCase();
   if (display) {
     if (!THINKING_DISPLAY_MODES.includes(display)) return invalid(`thinking_display must be one of: ${THINKING_DISPLAY_MODES.join(', ')}`);
@@ -1267,6 +1292,36 @@ export function formatSessionGroupList(groups, max = REMOTE_RELAY_GROUP_LIMITS.r
 // a dispatcher never offers one to its agent. Defined in relay-asks.mjs.
 export { REMOTE_RELAY_APPROVAL_SOURCE };
 
+// What an approval card is about: its context carries one of these
+// as `variant`, and a `summary` of at most this many characters (kind,
+// requesting session, reason; never the prompt, answer or question text). A
+// paired relay's Inbox shows them in place of the card text it never gets.
+export const REMOTE_RELAY_APPROVAL_VARIANTS = Object.freeze([
+  'create_session', 'loop_guard', 'write', 'session_settings', 'watch', 'local_sessions',
+]);
+export const REMOTE_RELAY_APPROVAL_SUMMARY_MAX = 160;
+// Each variant's kind label, without titles: the Inbox row's head, and the
+// push body of a device whose preview preference is off.
+export const REMOTE_RELAY_APPROVAL_VARIANT_LABELS = Object.freeze({
+  create_session: 'New session',
+  loop_guard: 'Loop guard',
+  write: 'Write',
+  session_settings: 'Session settings',
+  watch: 'Watch',
+  local_sessions: 'Start sessions',
+});
+
+// Who pushes a card a turn waits on (an approval, a blocking ask_user) when a
+// paired relay that can push reads this relay's Inbox (`?push=1`): `notice`
+// on each such pending item. `here`: this relay's own push reached a device;
+// `wait`: its push is not settled yet; `you`: the caller holds the claim and
+// pushes; `other`: another paired relay holds it. With `you`, `claimed` says
+// whether this request recorded the claim (`now`, the caller pushes) or the
+// caller held it already (`before`, e.g. after the caller restarted: no
+// second push).
+export const REMOTE_INBOX_NOTICES = Object.freeze({ here: 'here', wait: 'wait', you: 'you', other: 'other' });
+export const REMOTE_INBOX_CLAIMS = Object.freeze({ now: 'now', before: 'before' });
+
 /** True for such a card: a formatted question, or a stored request envelope (both carry `context`). */
 export function isRemoteRelayApprovalQuestion(question) {
   const context = question && typeof question === 'object' ? question.context : null;

package/shared/turn-token-usage.mjs

@@ -0,0 +1,144 @@
+import { claudeBaseModelId } from './model-id.mjs';
+
+// The token report a worker posts after a turn (POST /api/turn-token-usage),
+// checked and normalised. Shared by the relay (the route and
+// services/token-usage-service.mjs) and the workers that build it.
+//
+// A token field a provider did not report is null; a negative, non-finite
+// or unsafely large one is not a count either and becomes null, and a
+// fraction is cut to the integer. 0 always means the provider reported zero. `inputTokens` is fresh
+// input: without the tokens read from or written to the prompt cache.
+
+export const TURN_TOKEN_FIELDS = Object.freeze([
+  'inputTokens',
+  'outputTokens',
+  'cacheWriteTokens',
+  'cacheReadTokens',
+  'reasoningTokens',
+]);
+
+export const TURN_TOKEN_COST_SOURCES = Object.freeze(['claude-code', 'provider', 'oar-deepseek-table']);
+
+export const TURN_TOKEN_PROVIDERS = Object.freeze(['github', 'claude', 'claude-api', 'claude-cloud', 'deepseek', 'cursor', 'grok']);
+
+// One report names at most this many models; more is not a turn.
+export const TURN_TOKEN_MAX_MODELS = 32;
+const ID_MAX_LENGTH = 200;
+const BILLING_PATTERN = /^byok-[a-z0-9][a-z0-9_-]{0,39}$/;
+
+/** A provider's model id as the tables keep it: lower case, without `[1m]`. */
+export function tokenUsageModel(value) {
+  return claudeBaseModelId(String(value ?? '').trim()).toLowerCase();
+}
+
+// Past these a value is not a count or a cost but a broken report.
+const MAX_COST_USD = 1e9;
+
+/** A token count, or null when the value is not one. */
+export function tokenCount(value) {
+  if (typeof value !== 'number' || !Number.isFinite(value) || value < 0 || value > Number.MAX_SAFE_INTEGER) return null;
+  return Math.trunc(value);
+}
+
+function costValue(value) {
+  if (typeof value !== 'number' || !Number.isFinite(value) || value < 0 || value > MAX_COST_USD) return null;
+  return value;
+}
+
+/** a + b where either may be null: null only when both are. */
+export function addNullable(a, b) {
+  if (a == null) return b == null ? null : b;
+  if (b == null) return a;
+  return a + b;
+}
+
+/** '' or `byok-<provider type>`; null for anything else. */
+export function normalizeTurnTokenBilling(value) {
+  const billing = String(value || '').trim().toLowerCase();
+  if (!billing) return '';
+  return BILLING_PATTERN.test(billing) ? billing : null;
+}
+
+/**
+ * `[{ model, inputTokens, …, costUsd, costSource, costUnknown }]`, one per
+ * model: the same model named twice (also `x` and `x[1m]`) is summed.
+ */
+export function normalizeTurnTokenEntries(entries) {
+  const byModel = new Map();
+  for (const entry of Array.isArray(entries) ? entries : []) {
+    const model = tokenUsageModel(entry?.model);
+    if (!model || model.length > ID_MAX_LENGTH) continue;
+    const next = {
+      model,
+      ...Object.fromEntries(TURN_TOKEN_FIELDS.map((field) => [field, tokenCount(entry?.[field])])),
+      costUsd: costValue(entry?.costUsd),
+      costSource: TURN_TOKEN_COST_SOURCES.includes(entry?.costSource) ? entry.costSource : null,
+      costUnknown: entry?.costUnknown === true,
+    };
+    const current = byModel.get(model);
+    if (!current) {
+      byModel.set(model, next);
+      continue;
+    }
+    // The caps hold for the sum too, not only for each entry.
+    for (const field of TURN_TOKEN_FIELDS) {
+      const sum = addNullable(current[field], next[field]);
+      current[field] = sum === null ? null : tokenCount(sum);
+    }
+    const costSum = addNullable(current.costUsd, next.costUsd);
+    current.costUsd = costSum === null ? null : costValue(costSum);
+    current.costSource = current.costSource || next.costSource;
+    current.costUnknown = current.costUnknown || next.costUnknown;
+  }
+  return [...byModel.values()];
+}
+
+function idValue(value) {
+  const id = String(value ?? '').trim();
+  return id.length > ID_MAX_LENGTH ? null : id;
+}
+
+/**
+ * The report a worker posts, checked: `{ ok, report }` or `{ ok: false,
+ * error }`. `models` carries the turn's own counts; `sessionTotals` (Claude
+ * cloud) the session's running totals, of which the relay books the growth.
+ * Who the provider and billing are is the relay's to settle; the body's are
+ * only stated.
+ */
+export function normalizeTurnTokenUsageReport(body = {}) {
+  const conversationId = idValue(body?.conversationId);
+  const turnId = idValue(body?.turnId);
+  const runId = idValue(body?.runId);
+  if (!conversationId) return { ok: false, error: 'Missing conversationId' };
+  if (!turnId) return { ok: false, error: 'Missing turnId' };
+  if (runId === null) return { ok: false, error: 'Invalid runId' };
+  const provider = String(body?.provider || '').trim().toLowerCase();
+  if (provider && !TURN_TOKEN_PROVIDERS.includes(provider)) return { ok: false, error: 'Unknown provider' };
+  const billing = normalizeTurnTokenBilling(body?.billing);
+  if (billing === null) return { ok: false, error: 'Invalid billing' };
+  const at = body?.at == null || body?.at === '' ? null : String(body.at).trim();
+  if (at !== null && !Number.isFinite(Date.parse(at))) return { ok: false, error: 'Invalid at' };
+  const hasModels = Array.isArray(body?.models);
+  const hasSessionTotals = Array.isArray(body?.sessionTotals);
+  if (hasModels === hasSessionTotals) return { ok: false, error: 'Send either models or sessionTotals' };
+  const raw = hasModels ? body.models : body.sessionTotals;
+  if (raw.length > TURN_TOKEN_MAX_MODELS) return { ok: false, error: `More than ${TURN_TOKEN_MAX_MODELS} models` };
+  const entries = normalizeTurnTokenEntries(raw);
+  if (!entries.length) return { ok: false, error: 'Missing models' };
+  const nativeSessionId = idValue(body?.nativeSessionId) || null;
+  if (hasSessionTotals && !nativeSessionId) return { ok: false, error: 'Missing nativeSessionId' };
+  return {
+    ok: true,
+    report: {
+      conversationId,
+      turnId,
+      runId,
+      provider,
+      billing,
+      nativeSessionId,
+      responseMessageId: idValue(body?.responseMessageId) || null,
+      at: at === null ? null : new Date(Date.parse(at)).toISOString(),
+      ...(hasModels ? { models: entries } : { sessionTotals: entries }),
+    },
+  };
+}

package/shared/worker-runtime/heartbeat.mjs

@@ -37,6 +37,10 @@ export function createHeartbeatController({
   // relay hands a Claude chat's row only to a worker of the row's billing,
   // and knows a worker's kind from what it says here and in its hello.
   workerKind = null,
+  // Optional: the build id of the code this worker started on
+  // (shared/build-id.mjs). A worker whose websocket is down still beats, so
+  // the relay learns the build here as well as from the hello.
+  buildId = null,
   // requestPulse's window: one turn transition can flip the steering
   // snapshot several times in quick succession, and each flip only needs to
   // reach the relay once.
@@ -71,6 +75,7 @@ export function createHeartbeatController({
         ...(settleFailed.length ? { settleFailed } : {}),
         ...(Array.isArray(backgroundTaskIds) ? { backgroundTasks: backgroundTaskDigest(backgroundTaskIds) } : {}),
         ...(workerKind ? { workerKind: String(workerKind) } : {}),
+        ...(typeof buildId === "string" && buildId.trim() ? { buildId: buildId.trim() } : {}),
       };
       const response = await api("POST", "/api/heartbeat", body);
       // Failed by the relay, or skipped because this worker has no claim on

package/shared/worker-runtime/simple-steering-state.mjs

@@ -0,0 +1,38 @@
+/**
+ * The heartbeat steering snapshot of a worker that runs one delivered message
+ * at a time and never steers into a running turn: the Cursor, Grok and Claude
+ * cloud workers. They send it for the release fields, which tell the relay
+ * whether it may stop this worker and launch a fresh one now (its recycle
+ * after a deploy), the same fields the Claude and Copilot SDK workers send.
+ *
+ * `supported: false` keeps the composer as it was for these kinds: it offers
+ * mid-turn steering only to a worker that says `supported: true`, and reads
+ * neither the hold nor the cancellable ids of one that does not.
+ *
+ * - `activeAttempt`: the runner's `getActiveQueueAttempt()` (`{ id, attemptId }`
+ *   or null), the row the running turn owns.
+ * - `turnActive`: the runner's own word that a turn runs (`isTurnActive()`),
+ *   for a turn whose row has no id to show.
+ * - `backgroundTaskCount`: live background work that ends with the worker
+ *   (Grok's terminals).
+ *
+ * A turn holds the release ('turn'), then live background work ('background').
+ */
+export function buildSimpleSteeringState({ activeAttempt = null, turnActive = false, backgroundTaskCount = 0 } = {}) {
+  const messageId = String(activeAttempt?.id || '').trim() || null;
+  const turn = turnActive === true || Boolean(messageId);
+  const tasks = Number(backgroundTaskCount);
+  const liveTasks = Number.isInteger(tasks) && tasks > 0 ? tasks : 0;
+  const releaseHold = turn ? 'turn' : (liveTasks > 0 ? 'background' : null);
+  return {
+    turnActive: turn,
+    canSteer: false,
+    holdReason: null,
+    messageId,
+    supported: false,
+    cancellableIds: [],
+    releasable: !releaseHold,
+    releaseHold,
+    backgroundTaskCount: liveTasks,
+  };
+}

package/shared/worker-runtime/worker-websocket-link.mjs

@@ -1,3 +1,5 @@
+import { buildIdsDiffer } from "../build-id.mjs";
+
 function normalizeText(value) {
   const text = String(value || "").trim();
   return text || null;
@@ -70,6 +72,10 @@ export function createWorkerWebSocketLink({
   // every hello and ready: the relay hands a Claude chat's row only to a
   // worker of the row's billing.
   workerKind = null,
+  // The build id of the code this worker started on (shared/build-id.mjs),
+  // stated in every hello and ready next to the kind: the relay recycles a
+  // worker whose build differs from its own once the worker is idle.
+  buildId = null,
   minBackoffMs = 1000,
   maxBackoffMs = 8_000,
   jitterMs = 250,
@@ -121,6 +127,12 @@ export function createWorkerWebSocketLink({
   let lastPongAt = null;
   let lastQueueChangedAt = null;
   let lastDeliveryAt = null;
+  // The build id the relay named in its latest server.hello (null when it
+  // named none), and whether this connection has already logged that it
+  // differs from ours: the relay acks every worker.hello with another
+  // server.hello, and the log needs the news only once per connection.
+  let relayBuildId = null;
+  let buildMismatchLogged = false;
 
   function getNowMs() {
     const value = Number(now());
@@ -175,6 +187,7 @@ export function createWorkerWebSocketLink({
       sessionId: normalizeText(getSessionId()),
       pid: normalizePositiveInt(getPid()),
       ...(normalizeText(workerKind) ? { kind: normalizeText(workerKind) } : {}),
+      ...(normalizeText(buildId) ? { buildId: normalizeText(buildId) } : {}),
       ...(held ? { ready: false } : {}),
     });
     if (sent) lastHelloSentAt = getNowMs();
@@ -203,6 +216,7 @@ export function createWorkerWebSocketLink({
       sessionId: normalizeText(getSessionId()),
       pid: normalizePositiveInt(getPid()),
       ...(normalizeText(workerKind) ? { kind: normalizeText(workerKind) } : {}),
+      ...(normalizeText(buildId) ? { buildId: normalizeText(buildId) } : {}),
     });
     if (sent) lastReadySentAt = getNowMs();
     return sent;
@@ -393,6 +407,7 @@ export function createWorkerWebSocketLink({
         clearReadyRefreshTimer();
         // The next connection may reach a different (restarted) relay.
         serverCapabilities = new Set();
+        buildMismatchLogged = false;
       }
       if (stopped || !reconnect) return true;
       // A newer socket is already under way and owns the reconnect.
@@ -440,6 +455,13 @@ export function createWorkerWebSocketLink({
       }
       if (payload?.type === "server.hello") {
         serverCapabilities = new Set(Array.isArray(payload.capabilities) ? payload.capabilities.map(String) : []);
+        relayBuildId = normalizeText(payload.buildId);
+        // Only a line in the log: the relay decides when to replace this
+        // worker, and the worker takes no action of its own on it.
+        if (!buildMismatchLogged && buildIdsDiffer(relayBuildId, normalizeText(buildId))) {
+          buildMismatchLogged = true;
+          dbg(`relay build ${relayBuildId}, mine ${normalizeText(buildId)}: the relay will recycle this worker when idle`);
+        }
         if (!serverHelloSeen) {
           serverHelloSeen = true;
           // The handshake is complete: only now does the backoff start over.
@@ -536,6 +558,7 @@ export function createWorkerWebSocketLink({
       lastPongAt,
       lastQueueChangedAt,
       lastDeliveryAt,
+      relayBuildId,
     };
   }
 

package/shared/worker-runtime/working-directory.mjs

@@ -16,7 +16,7 @@ import fs from 'node:fs';
 export const WORKING_DIRECTORY_MISSING_CODE = 'working-directory-missing';
 
 export const WORKING_DIRECTORY_GUIDANCE =
-  'Restore the folder, or choose another working directory for this conversation (⋯ → Change CWD), '
+  'Restore the folder, or choose another working directory for this conversation (︙ → Change CWD), '
   + 'then send the message again.';
 
 // What a failed launch says, in the words of the SDKs: Node's spawn error, the