@oar-sh/oar 0.9.0

package/shared/question-schema.mjs

@@ -0,0 +1,315 @@
+'use strict';
+
+/**
+ * Shared helpers for working with `ask_user` / elicitation `requestedSchema`
+ * forms. Used by the relay server, the web UI (via a browser copy of the same
+ * logic), and the extension bridge so single- and multi-field structured forms
+ * are handled consistently.
+ *
+ * A requestedSchema follows a restricted subset of JSON Schema:
+ *   {
+ *     "type": "object",
+ *     "properties": {
+ *       "<field>": {
+ *         "type": "string" | "boolean" | "number" | "integer" | "array",
+ *         "title": "...", "description": "...", "default": ...,
+ *         "enum": [...],                       // string choices
+ *         "oneOf": [{ "const": v, "title": l }],// labelled choices
+ *         "format": "email" | "uri" | ...,
+ *         "items": { ... }                      // for arrays (enum / anyOf)
+ *       }
+ *     },
+ *     "required": ["field1", ...]
+ *   }
+ */
+
+function isPlainObject(value) {
+  return !!value && typeof value === 'object' && !Array.isArray(value);
+}
+
+function parseMaybeJson(value) {
+  if (typeof value !== 'string') return value;
+  const text = value.trim();
+  if (!text || (text[0] !== '{' && text[0] !== '[')) return value;
+  try {
+    return JSON.parse(text);
+  } catch {
+    return value;
+  }
+}
+
+/**
+ * Return true when a request carries a requestedSchema, even when the schema
+ * is invalid. Callers use this to avoid treating a failed structured request
+ * as a legacy text prompt while the SDK validates or retries it.
+ */
+export function containsRequestedSchema(source) {
+  if (!source) return false;
+  const seen = new Set();
+  const queue = [source];
+  let depth = 0;
+  while (queue.length && depth < 5000) {
+    depth += 1;
+    const current = parseMaybeJson(queue.shift());
+    if (!isPlainObject(current)) continue;
+    if (seen.has(current)) continue;
+    seen.add(current);
+    if (current.requestedSchema !== undefined) return true;
+    for (const key of [
+      'toolArgs', 'arguments', 'args', 'input', 'payload', 'body', 'request',
+      'toolInput', 'toolCall', 'data',
+    ]) {
+      if (current[key] !== undefined) queue.push(current[key]);
+    }
+  }
+  return false;
+}
+
+/**
+ * Locate a `requestedSchema` object inside an arbitrary request/toolArgs shape.
+ * Returns the normalized schema object or null.
+ */
+export function extractRequestedSchema(source) {
+  if (!source) return null;
+  const seen = new Set();
+  const queue = [source];
+  let depth = 0;
+  while (queue.length && depth < 5000) {
+    depth += 1;
+    const current = parseMaybeJson(queue.shift());
+    if (!isPlainObject(current)) continue;
+    if (seen.has(current)) continue;
+    seen.add(current);
+    const candidate = parseMaybeJson(current.requestedSchema);
+    if (isPlainObject(candidate) && isPlainObject(candidate.properties)) {
+      return normalizeSchema(candidate);
+    }
+    for (const key of [
+      'toolArgs', 'arguments', 'args', 'input', 'payload', 'body', 'request',
+      'toolInput', 'toolCall', 'data',
+    ]) {
+      if (current[key] !== undefined) queue.push(current[key]);
+    }
+  }
+  return null;
+}
+
+/** Normalize a raw schema (parsing JSON strings, ensuring shape). */
+export function normalizeSchema(raw) {
+  const schema = parseMaybeJson(raw);
+  if (!isPlainObject(schema) || !isPlainObject(schema.properties)) return null;
+  const required = Array.isArray(schema.required)
+    ? schema.required.map((name) => String(name)).filter(Boolean)
+    : [];
+  return {
+    type: 'object',
+    properties: schema.properties,
+    required,
+  };
+}
+
+function normalizeChoice(entry) {
+  if (typeof entry === 'string') {
+    const value = entry.trim();
+    return value ? { value, label: value } : null;
+  }
+  if (isPlainObject(entry)) {
+    const value = entry.const !== undefined ? entry.const : (entry.value !== undefined ? entry.value : entry.title);
+    if (value === undefined || value === null) return null;
+    const label = String(entry.title || entry.label || entry.description || value).trim();
+    return { value, label: label || String(value) };
+  }
+  return null;
+}
+
+function fieldChoices(prop) {
+  const out = [];
+  if (Array.isArray(prop?.enum)) {
+    for (const e of prop.enum) {
+      const c = normalizeChoice(e);
+      if (c) out.push(c);
+    }
+  }
+  if (Array.isArray(prop?.oneOf)) {
+    for (const e of prop.oneOf) {
+      const c = normalizeChoice(e);
+      if (c) out.push(c);
+    }
+  }
+  // Array item choices (multi-select)
+  const items = prop?.items;
+  if (isPlainObject(items)) {
+    if (Array.isArray(items.enum)) {
+      for (const e of items.enum) {
+        const c = normalizeChoice(e);
+        if (c) out.push(c);
+      }
+    }
+    if (Array.isArray(items.anyOf)) {
+      for (const e of items.anyOf) {
+        const c = normalizeChoice(e);
+        if (c) out.push(c);
+      }
+    }
+  }
+  // Deduplicate by value
+  const seen = new Set();
+  return out.filter((c) => {
+    const key = String(c.value);
+    if (seen.has(key)) return false;
+    seen.add(key);
+    return true;
+  });
+}
+
+/**
+ * Return an ordered list of normalized field descriptors for a schema.
+ */
+export function schemaFields(schema) {
+  const normalized = normalizeSchema(schema);
+  if (!normalized) return [];
+  const requiredSet = new Set(normalized.required);
+  const fields = [];
+  for (const [name, rawProp] of Object.entries(normalized.properties)) {
+    const prop = parseMaybeJson(rawProp);
+    if (!isPlainObject(prop)) continue;
+    const type = String(prop.type || 'string').toLowerCase();
+    const choices = fieldChoices(prop);
+    fields.push({
+      name,
+      type,
+      title: String(prop.title || name).trim() || name,
+      description: String(prop.description || '').trim(),
+      required: requiredSet.has(name),
+      hasDefault: Object.prototype.hasOwnProperty.call(prop, 'default'),
+      default: prop.default,
+      choices,
+      isMultiSelect: type === 'array',
+      format: String(prop.format || '').trim() || null,
+    });
+  }
+  return fields;
+}
+
+/** True when the schema describes more than one field. */
+export function isMultiFieldSchema(schema) {
+  return schemaFields(schema).length > 1;
+}
+
+function coerceValue(field, rawValue) {
+  if (rawValue === undefined || rawValue === null || rawValue === '') {
+    return { present: false, value: undefined };
+  }
+  switch (field.type) {
+    case 'boolean': {
+      if (typeof rawValue === 'boolean') return { present: true, value: rawValue };
+      const text = String(rawValue).trim().toLowerCase();
+      if (['true', 'yes', '1', 'on'].includes(text)) return { present: true, value: true };
+      if (['false', 'no', '0', 'off'].includes(text)) return { present: true, value: false };
+      return { present: true, value: undefined, error: 'expected boolean' };
+    }
+    case 'number':
+    case 'integer': {
+      const num = Number(rawValue);
+      if (!Number.isFinite(num)) return { present: true, value: undefined, error: 'expected number' };
+      if (field.type === 'integer' && !Number.isInteger(num)) {
+        return { present: true, value: Math.trunc(num) };
+      }
+      return { present: true, value: num };
+    }
+    case 'array': {
+      let arr = rawValue;
+      if (typeof rawValue === 'string') {
+        arr = rawValue.split(',').map((s) => s.trim()).filter(Boolean);
+      }
+      if (!Array.isArray(arr)) return { present: true, value: undefined, error: 'expected array' };
+      return { present: true, value: arr.map((v) => (typeof v === 'string' ? v.trim() : v)) };
+    }
+    default: {
+      return { present: true, value: String(rawValue) };
+    }
+  }
+}
+
+function choiceMatches(field, value) {
+  if (!field.choices.length) return true;
+  const allowed = field.choices.map((c) => String(c.value));
+  if (field.type === 'array') {
+    const list = Array.isArray(value) ? value : [value];
+    return list.every((v) => allowed.includes(String(v)));
+  }
+  return allowed.includes(String(value));
+}
+
+/**
+ * Validate and coerce a structured answer object against the schema.
+ * Returns { ok, errors: [{field, message}], value: {field: coerced} }.
+ */
+export function validateStructuredAnswer(schema, answer) {
+  const fields = schemaFields(schema);
+  const errors = [];
+  const value = {};
+  const source = isPlainObject(answer) ? answer : {};
+
+  for (const field of fields) {
+    let raw = source[field.name];
+    const coerced = coerceValue(field, raw);
+
+    if (!coerced.present) {
+      if (field.hasDefault) {
+        value[field.name] = field.default;
+        continue;
+      }
+      if (field.required) {
+        errors.push({ field: field.name, message: `${field.title} is required` });
+      }
+      continue;
+    }
+
+    if (coerced.error) {
+      errors.push({ field: field.name, message: `${field.title}: ${coerced.error}` });
+      continue;
+    }
+
+    if (!choiceMatches(field, coerced.value)) {
+      errors.push({ field: field.name, message: `${field.title}: value not allowed` });
+      continue;
+    }
+
+    value[field.name] = coerced.value;
+  }
+
+  return { ok: errors.length === 0, errors, value };
+}
+
+/** Render a structured answer object as a short human-readable string. */
+export function summarizeStructuredAnswer(schema, answer) {
+  const fields = schemaFields(schema);
+  const source = isPlainObject(answer) ? answer : {};
+  const parts = [];
+  const ordered = fields.length ? fields.map((f) => f.name) : Object.keys(source);
+  for (const name of ordered) {
+    if (!(name in source)) continue;
+    const field = fields.find((f) => f.name === name);
+    const label = field ? field.title : name;
+    let val = source[name];
+    if (Array.isArray(val)) val = val.join(', ');
+    parts.push(`${label}: ${val}`);
+  }
+  return parts.join(' · ');
+}
+
+/**
+ * Build a structured content object from a single flat string answer.
+ * Used for backward compatibility / single-field schemas where the relay only
+ * captured one string. Maps the answer onto the schema's single field.
+ */
+export function flatAnswerToStructured(schema, flatAnswer) {
+  const fields = schemaFields(schema);
+  if (fields.length !== 1) return null;
+  const field = fields[0];
+  const coerced = coerceValue(field, flatAnswer);
+  if (!coerced.present || coerced.error) return null;
+  if (!choiceMatches(field, coerced.value)) return null;
+  return { [field.name]: coerced.value };
+}

package/shared/question-timeout.mjs

@@ -0,0 +1,18 @@
+export const DEFAULT_QUESTION_TIMEOUT_MS = 8 * 60 * 60_000;
+export const QUESTION_TIMEOUT_CONTINUATION_TEXT = "[No user response before timeout — continue according to the current relay mode.]";
+
+/**
+ * Absolute expiry for a relay question. Only an actual finite number is
+ * honored (including 0); anything else — absent, `null`, strings, junk —
+ * falls back to the default. The strictness is deliberate: coercing here is
+ * how `Number(null) === 0` silently produced questions that expired the
+ * moment they were created (the pre-2026-09 relay-question-ui e2e flake),
+ * and for a timeout the safe failure direction is "lives 8h", never
+ * "expires now".
+ */
+export function questionExpiresAt(createdAt, timeoutMs = DEFAULT_QUESTION_TIMEOUT_MS) {
+  const normalizedTimeoutMs = Number.isFinite(timeoutMs)
+    ? Math.max(0, Math.trunc(timeoutMs))
+    : DEFAULT_QUESTION_TIMEOUT_MS;
+  return new Date(new Date(createdAt).getTime() + normalizedTimeoutMs).toISOString();
+}

package/shared/stream-emit-gating.mjs

@@ -0,0 +1,28 @@
+// The single emit-gating rule every worker's stream channel uses.
+//
+// Mirrors the gating the Copilot extension's stream publisher applies, so
+// `relay_stream` traffic stays comparable across providers and engines: a
+// conversation run on Claude, Cursor, Grok or Copilot produces the same shape
+// of incremental updates for the same prose. It was copied byte-for-byte into
+// four normalizers before it lived here; keep it in one place so a change to
+// the flood control lands everywhere at once.
+//
+// Returns true when `nextText` is worth publishing given the last text that
+// was published:
+//   - never publish empty text;
+//   - always publish the first text;
+//   - never re-publish identical text;
+//   - publish once 24+ new characters accumulated, or on a sentence/line
+//     boundary, or whenever the text shrank or was rewritten.
+export function shouldEmitStreamUpdate(nextText, previousText) {
+  const next = String(nextText || '');
+  const prev = String(previousText || '');
+  if (!next) return false;
+  if (!prev) return true;
+  if (next === prev) return false;
+  const delta = next.length - prev.length;
+  if (delta >= 24) return true;
+  if (delta > 0 && /[\n.!?:)]$/.test(next)) return true;
+  if (delta <= 0) return true;
+  return false;
+}

package/shared/subagent-run-id.mjs

@@ -0,0 +1,17 @@
+/**
+ * Sanitize a provider-reported subagent call id before it becomes a database
+ * row id. Malformed ids have been seen live (an embedded newline; two
+ * concatenated tool ids): they round-trip into URLs and DOM lookups, and while
+ * the client escapes them, a control character inside a primary key helps
+ * nobody. Non-printable runs collapse to a single dash and the id is capped.
+ */
+export function sanitizeSubagentRunId(raw) {
+  const trimmed = String(raw || '').trim();
+  if (!trimmed) return null;
+  const cleaned = trimmed
+    .replace(/[^\x21-\x7E]+/g, '-')
+    .replace(/-{2,}/g, '-')
+    .replace(/^-+|-+$/g, '');
+  if (!cleaned) return null;
+  return cleaned.slice(0, 128);
+}

package/shared/thought-cap.mjs

@@ -0,0 +1,13 @@
+// The per-thought character cap shared by every worker's reasoning channel.
+//
+// A single reasoning block can run to hundreds of kilobytes; the relay stores
+// and re-broadcasts every thought update, so an uncapped thought turns one
+// verbose turn into a transport problem. 16 KiB is the cap the Copilot
+// extension's reasoning-stream bridge has used since it shipped, and the
+// worker normalizers copied it verbatim — this is that one definition.
+export const MAX_THOUGHT_CHARS = 16 * 1024;
+
+export function capThought(text) {
+  const value = String(text || '');
+  return value.length <= MAX_THOUGHT_CHARS ? value : value.slice(0, MAX_THOUGHT_CHARS);
+}

package/shared/tool-activity.mjs

@@ -0,0 +1,98 @@
+const DEFAULT_MAX_LENGTH = 140;
+
+export function parseToolPayload(value) {
+  if (typeof value !== 'string') return value;
+  const text = value.trim();
+  if (!text || (!text.startsWith('{') && !text.startsWith('['))) return value;
+  try {
+    return JSON.parse(text);
+  } catch {
+    return value;
+  }
+}
+
+export function normalizeToolActivityText(value, maxLength = DEFAULT_MAX_LENGTH) {
+  const text = String(value || '').replace(/\s+/g, ' ').trim();
+  if (!text) return '';
+  return text.slice(0, Math.max(1, Number(maxLength) || DEFAULT_MAX_LENGTH));
+}
+
+function formatToolFieldValue(value) {
+  if (value === null || value === undefined) return '';
+  if (typeof value === 'string') return value;
+  if (Array.isArray(value)) return value.join(', ');
+  if (typeof value === 'object') {
+    try {
+      return JSON.stringify(value);
+    } catch {
+      return '';
+    }
+  }
+  return String(value);
+}
+
+export function formatStoreMemoryActivity(toolName, args) {
+  const parsedArgs = parseToolPayload(args);
+  if (!parsedArgs || typeof parsedArgs !== 'object' || Array.isArray(parsedArgs)) return '';
+  const fields = ['subject', 'fact', 'citations', 'reason', 'scope']
+    .map((key) => {
+      const value = formatToolFieldValue(parsedArgs[key]).replace(/\s+/g, ' ').trim();
+      return value ? `${key}="${value.replace(/"/g, "'")}"` : '';
+    })
+    .filter(Boolean);
+  if (!fields.length) return `Tool (${String(toolName || 'store_memory').trim() || 'store_memory'})`;
+  return `Tool (${String(toolName || 'store_memory').trim() || 'store_memory'}):\n${fields.join('\n')}`;
+}
+
+export function formatVoteMemoryActivity(toolName, args) {
+  const parsedArgs = parseToolPayload(args);
+  if (!parsedArgs || typeof parsedArgs !== 'object' || Array.isArray(parsedArgs)) return '';
+  const fields = ['fact', 'direction', 'reason', 'scope']
+    .map((key) => {
+      const value = formatToolFieldValue(parsedArgs[key]).replace(/\s+/g, ' ').trim();
+      return value ? `${key}="${value.replace(/"/g, "'")}"` : '';
+    })
+    .filter(Boolean);
+  if (!fields.length) return `Tool (${String(toolName || 'vote_memory').trim() || 'vote_memory'})`;
+  return `Tool (${String(toolName || 'vote_memory').trim() || 'vote_memory'}):\n${fields.join('\n')}`;
+}
+
+export function extractToolResultText(value, maxLength = DEFAULT_MAX_LENGTH) {
+  const seen = new WeakSet();
+  const candidates = [];
+  function collect(input) {
+    const parsed = parseToolPayload(input);
+    if (parsed === null || parsed === undefined) return;
+    if (typeof parsed === 'string') {
+      const text = normalizeToolActivityText(parsed, maxLength);
+      if (text) candidates.push(text);
+      return;
+    }
+    if (typeof parsed !== 'object') return;
+    if (seen.has(parsed)) return;
+    seen.add(parsed);
+    for (const key of ['value', 'text', 'content', 'output_text', 'outputText', 'summary', 'title', 'url']) {
+      if (parsed[key] !== undefined) collect(parsed[key]);
+    }
+    if (Array.isArray(parsed)) {
+      for (const item of parsed) collect(item);
+    }
+  }
+  collect(value);
+  return candidates.find(Boolean) || '';
+}
+
+export function formatToolResultActivity(toolName, result, maxLength = DEFAULT_MAX_LENGTH) {
+  const name = String(toolName || '').trim();
+  if (!name) return '';
+  const lower = name.toLowerCase();
+  const text = extractToolResultText(result, maxLength);
+  if (!text) return '';
+  if (lower.includes('web_search') || lower.includes('web search')) {
+    return `Tool (${name}): output="${text.replace(/"/g, "'")}"`;
+  }
+  if (lower.includes('web_fetch') || lower.includes('web fetch')) {
+    return `Tool (${name}): output="${text.replace(/"/g, "'")}"`;
+  }
+  return '';
+}

package/shared/turn-ceiling.mjs

@@ -0,0 +1,53 @@
+// Absolute cap on how long a single turn may stay in 'processing' before the
+// relay requeues it, shared so the settings slider and the recovery sweep agree
+// on bounds and formatting.
+//
+// This is only a backstop. Normal staleness is measured from worker heartbeats
+// (see listRecoverableProcessing), and a turn waiting on an unanswered question
+// is exempt from both — so the ceiling exists purely for a worker that is hung
+// while still heartbeating.
+
+export const TURN_CEILING_MIN_MINUTES = 0;
+export const TURN_CEILING_MAX_MINUTES = 600;
+export const TURN_CEILING_STEP_MINUTES = 5;
+export const DEFAULT_TURN_CEILING_MINUTES = 60;
+
+/** 0 disables the ceiling entirely. */
+export function normalizeTurnCeilingMinutes(value, fallback = DEFAULT_TURN_CEILING_MINUTES) {
+  // Number('') and Number(null) are both 0, which would silently read as
+  // "no limit". Absent input is absent, not a request to disable the ceiling.
+  if (value === null || value === undefined) return fallback;
+  if (typeof value === 'string' && value.trim() === '') return fallback;
+  const numeric = Number(value);
+  if (!Number.isFinite(numeric)) return fallback;
+  const rounded = Math.round(numeric);
+  if (rounded <= TURN_CEILING_MIN_MINUTES) return 0;
+  return Math.min(TURN_CEILING_MAX_MINUTES, rounded);
+}
+
+export function turnCeilingMinutesToMs(minutes) {
+  return normalizeTurnCeilingMinutes(minutes) * 60_000;
+}
+
+/** An unset setting means "never configured", which is the default — not 0. */
+export function readTurnCeilingSetting(storedValue) {
+  const text = storedValue === null || storedValue === undefined ? '' : String(storedValue).trim();
+  if (!text) return DEFAULT_TURN_CEILING_MINUTES;
+  return normalizeTurnCeilingMinutes(text);
+}
+
+export function parseTurnCeilingUpdate(value) {
+  const minutes = normalizeTurnCeilingMinutes(value, null);
+  if (minutes === null) return { ok: false, error: 'ceilingMinutes must be a number' };
+  return { ok: true, minutes };
+}
+
+export function formatTurnCeilingLabel(minutes) {
+  const normalized = normalizeTurnCeilingMinutes(minutes);
+  if (normalized === 0) return 'No limit';
+  if (normalized < 60) return `${normalized} min`;
+  const hours = Math.floor(normalized / 60);
+  const remainder = normalized % 60;
+  const hourLabel = `${hours} h`;
+  return remainder ? `${hourLabel} ${remainder} min` : hourLabel;
+}

package/shared/worker-bootstrap.mjs

@@ -0,0 +1,44 @@
+// The two things every session worker's entry point needs before it can do
+// anything: which relay session it was spawned for, and a debug channel that
+// timestamps and tags its own lines.
+//
+// Used by the Copilot SDK worker today. The Claude/Cursor/Grok workers still
+// carry their own copies of both; folding them in is a mechanical follow-up
+// (tracked in docs/plans/copilot-sdk-worker.md) that is deliberately not part
+// of the dormant worker's review pass — those three are live.
+
+/**
+ * The relay session id, from `--session-id <id>`, `--session-id=<id>`, or the
+ * `SESSION_ID` environment variable, in that order. Returns '' when none is
+ * present so the caller can fail with its own message.
+ */
+export function parseSessionIdArg(argv = process.argv, env = process.env) {
+  const index = argv.indexOf('--session-id');
+  if (index !== -1 && argv[index + 1]) return String(argv[index + 1]).trim();
+  const inline = argv.find((arg) => String(arg || '').startsWith('--session-id='));
+  if (inline) return String(inline.split('=')[1] || '').trim();
+  return String(env.SESSION_ID || '').trim();
+}
+
+/**
+ * A `dbg(...parts)` that prefixes every line with the worker name and an ISO
+ * timestamp, so interleaved worker logs stay attributable in a shared journal.
+ */
+export function createWorkerDebug(workerName, { log = console.log } = {}) {
+  const name = String(workerName || 'worker').trim() || 'worker';
+  return (...parts) => {
+    log(`[${name} ${new Date().toISOString()}]`, ...parts);
+  };
+}
+
+/**
+ * A numeric env override that honours 0 as a real value (the project's
+ * "0 = no limit / disabled" convention), returning undefined when unset or
+ * unparseable so an option default can take over.
+ */
+export function readOptionalMs(name, env = process.env) {
+  const raw = String(env[name] || '').trim();
+  if (!raw) return undefined;
+  const parsed = Number(raw);
+  return Number.isFinite(parsed) && parsed >= 0 ? parsed : undefined;
+}

package/shared/worker-crash-guard.mjs

@@ -0,0 +1,60 @@
+/**
+ * Last-resort crash handling for provider session workers.
+ *
+ * Without these handlers an uncaught exception (or, on modern Node, an
+ * unhandled rejection) kills the worker silently mid-turn: no requeue, no
+ * terminal response, just a 'processing' row waiting out the server's
+ * dead-worker recovery. The guard requeues every queue row the worker owes
+ * work for (continuation rows are torn down server-side by the same route),
+ * then exits non-zero so the supervisor sees a real failure.
+ *
+ * The requeue is strictly bounded: a crash handler that hangs is worse than
+ * no handler at all.
+ */
+export function installWorkerCrashGuard({
+  api,
+  workerName = 'session-worker',
+  getActiveQueueMessageIds = () => [],
+  onBeforeExit = () => {},
+  requeueTimeoutMs = 2_000,
+  exit = (code) => process.exit(code),
+  processImpl = process,
+  logError = (...args) => console.error(...args),
+} = {}) {
+  let crashing = false;
+  const handler = (kind) => (error) => {
+    if (crashing) return;
+    crashing = true;
+    logError(`${workerName} ${kind}:`, error?.stack || error?.message || error);
+    (async () => {
+      try {
+        const ids = [...new Set(
+          (getActiveQueueMessageIds() || [])
+            .map((id) => String(id || '').trim())
+            .filter(Boolean),
+        )];
+        if (ids.length && typeof api === 'function') {
+          await Promise.race([
+            Promise.allSettled(ids.map((id) => api('POST', '/api/requeue', { messageId: id }))),
+            new Promise((resolve) => {
+              const timer = setTimeout(resolve, Math.max(0, Number(requeueTimeoutMs) || 0));
+              timer.unref?.();
+            }),
+          ]);
+        }
+      } catch {}
+      try { onBeforeExit(); } catch {}
+      exit(1);
+    })();
+  };
+  const onException = handler('uncaughtException');
+  const onRejection = handler('unhandledRejection');
+  processImpl.on('uncaughtException', onException);
+  processImpl.on('unhandledRejection', onRejection);
+  return {
+    uninstall() {
+      processImpl.off('uncaughtException', onException);
+      processImpl.off('unhandledRejection', onRejection);
+    },
+  };
+}