@oar-sh/oar 0.9.2 → 0.9.3

package/server/services/live-turn-picker.mjs

@@ -0,0 +1,47 @@
+// Which of a conversation's processing queue rows is the LIVE turn.
+//
+// Mid-turn steering means a conversation can have more than one row in
+// `processing` at once: the running turn plus a message the user steered in,
+// which the CLI folds into that turn and which produces no stream or activity
+// of its own — or, after a replay handoff, the row that just took the turn
+// over while the handed-off row is still settling. The live turn is the row
+// that produced output MOST RECENTLY; with no output to separate them, the
+// oldest processing row (the turn a steered message joins). Kept pure so the
+// tie-break rules are testable without a DB.
+//
+// Recency, not volume: relay_stream_events.seq is only unique within one
+// queue_message_id, so comparing it across rows picked "the row with the most
+// events" — a long handed-off turn kept the live bubble (and Stop) from the
+// row that had actually taken over.
+
+/**
+ * @param {Array<{id:string, lastOutputAtMs?:number, streamDone?:boolean, processingAtMs?:number}>} rows
+ *   Processing rows for one conversation. `lastOutputAtMs` is when the row
+ *   last wrote a stream snapshot or activity line (0 = never); `streamDone`
+ *   marks a row whose main stream snapshot is final — a handed-off row
+ *   settling, whose closing snapshot re-stamps it as the newest write — and
+ *   ranks it below every row still open; `processingAtMs` is when it entered
+ *   processing (final tie-break; smaller = older = wins).
+ * @returns {string} the live turn's row id, or '' when there are no rows.
+ */
+export function pickLiveTurnRowId(rows = []) {
+  const list = Array.isArray(rows) ? rows.filter((row) => row && row.id) : [];
+  if (!list.length) return '';
+  if (list.length === 1) return String(list[0].id);
+  const finite = (value) => (Number.isFinite(Number(value)) ? Number(value) : 0);
+  let best = null;
+  for (const row of list) {
+    if (!best) { best = row; continue; }
+    if (Boolean(row.streamDone) !== Boolean(best.streamDone)) {
+      if (!row.streamDone) best = row;
+      continue;
+    }
+    const output = finite(row.lastOutputAtMs);
+    const bestOutput = finite(best.lastOutputAtMs);
+    if (output > bestOutput
+      || (output === bestOutput && finite(row.processingAtMs) < finite(best.processingAtMs))) {
+      best = row;
+    }
+  }
+  return String(best.id);
+}

package/server/services/relay-prompt-sanitizer.mjs

@@ -135,6 +135,21 @@ const MEDIA_EMBED_BLOCK_PATTERN = new RegExp(
   'gi',
 );
 
+// A steered message's hidden note (shared/steer-note.mjs) leads the prompt the
+// runtime stored, right after any mode marker. Matched by its stable opening
+// words, because the browser copy of this module cannot import shared/.
+const STEER_NOTE_PATTERN = /^\s*\[Sent while you were still working on my previous message\.[^\]\n]*\]\s*/;
+
+// The Claude worker's slash-command guard (shared/slash-command-guard.mjs): a
+// zero-width space in front of a "/x" it delivers as text. trim() keeps it, so
+// it is matched on its own, and only where it guards a "/".
+const SLASH_COMMAND_GUARD_PATTERN = /^\u200B(?=\s*\/)/;
+
+function stripLeadingRelayNotes(text) {
+  const stripped = String(text || '').replace(STEER_NOTE_PATTERN, '').replace(SLASH_COMMAND_GUARD_PATTERN, '');
+  return stripped.trim() ? stripped.trim() : String(text || '').trim();
+}
+
 export function stripRelayPromptContext(text, relayMode = '', attachments = []) {
   const value = stripAttachmentPromptArtifacts(text)
     .replace(MEDIA_EMBED_BLOCK_PATTERN, '')
@@ -143,7 +158,7 @@ export function stripRelayPromptContext(text, relayMode = '', attachments = [])
   const patterns = buildPromptPrefixPatterns(relayMode);
   for (const pattern of patterns) {
     const stripped = value.replace(pattern, '').trim();
-    if (stripped && stripped !== value) return stripped;
+    if (stripped && stripped !== value) return stripLeadingRelayNotes(stripped);
   }
-  return value;
+  return stripLeadingRelayNotes(value);
 }

package/server/services/relay-question-context.mjs

@@ -0,0 +1,46 @@
+// The `context` block a relay question card carries: who asked, why, for which
+// queue row, and the few presentation hints the card renders from. Workers
+// send it on POST /api/relay-question; it is stored inside the question's
+// request envelope and served back to the client. Anything not listed here is
+// dropped, so a new hint the client reads must be added here too (the
+// multi-select flag was once silently stripped this way).
+
+/**
+ * @param {unknown} rawContext
+ * @param {{ normalizeRelayMode?: (mode: string) => string | null, defaultRelayMode?: string }} [options]
+ */
+export function sanitizeRelayQuestionContext(rawContext, {
+  normalizeRelayMode = (mode) => String(mode || '').trim().toLowerCase() || null,
+  defaultRelayMode = 'agent',
+} = {}) {
+  if (!rawContext || typeof rawContext !== 'object' || Array.isArray(rawContext)) return null;
+  const context = {};
+  if (typeof rawContext.source === 'string' && rawContext.source.trim()) {
+    context.source = rawContext.source.trim().slice(0, 64);
+  }
+  if (typeof rawContext.rationale === 'string' && rawContext.rationale.trim()) {
+    context.rationale = rawContext.rationale.trim().slice(0, 240);
+  }
+  if (typeof rawContext.queueMessageId === 'string' && rawContext.queueMessageId.trim()) {
+    context.queueMessageId = rawContext.queueMessageId.trim();
+  }
+  if (typeof rawContext.conversationId === 'string' && rawContext.conversationId.trim()) {
+    context.conversationId = rawContext.conversationId.trim();
+  }
+  if (typeof rawContext.relayMode === 'string' && rawContext.relayMode.trim()) {
+    context.relayMode = normalizeRelayMode(rawContext.relayMode) || defaultRelayMode;
+  }
+  // The card renders checkmarks instead of one-shot buttons when several
+  // answers are allowed (Claude's AskUserQuestion `multiSelect`, or the
+  // Copilot worker's wording heuristic). Only an explicit `true` is kept.
+  if (rawContext.multiSelect === true) context.multiSelect = true;
+  // Providers whose ask tool cannot always say so (Copilot) mark their choice
+  // cards with this: the card then offers a "Select several" switch, so the
+  // user can pick several answers even when the model did not flag it.
+  if (rawContext.allowMultiSelect === true) context.allowMultiSelect = true;
+  // Claude's short question label ("Workers", "Visibility").
+  if (typeof rawContext.header === 'string' && rawContext.header.trim()) {
+    context.header = rawContext.header.trim().slice(0, 120);
+  }
+  return Object.keys(context).length ? context : null;
+}

package/server/services/sdk-session-import-service.mjs

@@ -77,7 +77,7 @@ export function createSdkSessionImportService({
   logger = console,
 } = {}) {
   if (!db || !stmts || typeof createClient !== 'function') throw new Error('SDK session importer requires database, statements, and a client factory');
-  let runtime = null;
+  let runtimeCreation = null;
   let activeRun = null;
   let closing = false;
   const countConversationMessages = db.prepare(`
@@ -149,8 +149,18 @@ export function createSdkSessionImportService({
     // Refusing after dispose() is what stops a mid-shutdown import from
     // resurrecting a fresh SDK client the server would never tear down.
     if (closing) throw new Error('SDK session importer is shutting down');
-    if (!runtime) runtime = await createClient();
-    return runtime;
+    // Callers share the start in flight: parallel deletes, or a delete during
+    // the startup import, each started a runtime of their own, and only the
+    // last one was ever disposed. A start that fails is dropped, so the next
+    // call tries again.
+    if (!runtimeCreation) {
+      const creation = Promise.resolve().then(() => createClient());
+      runtimeCreation = creation;
+      creation.catch(() => {
+        if (runtimeCreation === creation) runtimeCreation = null;
+      });
+    }
+    return runtimeCreation;
   }
 
   function isTombstoned(sdkSessionId) {
@@ -329,6 +339,34 @@ export function createSdkSessionImportService({
     return activeRun;
   }
 
+  /**
+   * Remove a Copilot session from the runtime's own store, for a conversation
+   * deleted in the relay. Goes through the SDK rather than the session-state
+   * folder so the runtime's bookkeeping stays consistent. Throws when the
+   * runtime cannot do it; the caller decides what that means.
+   */
+  async function deleteSession(sdkSessionId) {
+    const sid = text(sdkSessionId);
+    if (!sid) throw new Error('Missing session id');
+    const client = await getRuntime();
+    if (typeof client?.client?.deleteSession !== 'function') {
+      throw new Error('deleteSession() is unavailable in this Copilot runtime');
+    }
+    await client.client.deleteSession(sid);
+  }
+
+  /**
+   * Whether the relay only imported this session and never ran it: the ledger
+   * says the importer brought it in, and no queued turn or relay worker says
+   * the relay has run it since. Continuing an imported conversation does not
+   * touch the ledger, so that evidence is checked here too, and it flips the
+   * ledger to 'relay' for good, as it does on import.
+   */
+  function isImportedOnly(sdkSessionId) {
+    const sid = text(sdkSessionId);
+    return !!sid && !relayOwnsSession(sid);
+  }
+
   async function refreshConversation(conversation) {
     const sdkSessionId = text(conversation?.sdk_session_id || conversation?.sdkSessionId || conversation?.id);
     if (!sdkSessionId || isTombstoned(sdkSessionId)) {
@@ -343,14 +381,18 @@ export function createSdkSessionImportService({
     runStartupImport,
     importSession,
     refreshConversation,
+    deleteSession,
+    isImportedOnly,
     async dispose() {
       // Flag first: getRuntime() must refuse before the client goes away, or a
-      // concurrent import observes runtime = null and creates a replacement
-      // while the server is exiting.
+      // concurrent import finds no runtime and starts a replacement while the
+      // server is exiting.
       closing = true;
       try { await activeRun; } catch {}
-      const current = runtime;
-      runtime = null;
+      // A start still in flight is waited for, so its runtime is disposed too.
+      const creation = runtimeCreation;
+      runtimeCreation = null;
+      const current = await creation?.catch(() => null);
       await current?.dispose?.();
     },
   };

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

@@ -60,6 +60,54 @@ function normalizeStatus(value) {
   return ALLOWED_STATUSES.has(mapped) ? mapped : 'new';
 }
 
+const STEERING_HOLD_REASONS = new Set(['question', 'compaction', 'adoption', 'delivery', 'other']);
+const STEERING_MESSAGE_ID_MAX_LENGTH = 64;
+const STEERING_CANCELLABLE_IDS_MAX = 50;
+
+// Queue message ids the worker still holds pushed-but-unconsumed (the Copilot
+// SDK's queued lane): trimmed strings only, deduped, capped — a worker cannot
+// grow the status payload without bound.
+function normalizeSteeringCancellableIds(raw) {
+  if (!Array.isArray(raw)) return [];
+  const seen = new Set();
+  const ids = [];
+  for (const value of raw) {
+    if (typeof value !== 'string') continue;
+    const id = value.trim();
+    if (!id || id.length > STEERING_MESSAGE_ID_MAX_LENGTH || seen.has(id)) continue;
+    seen.add(id);
+    ids.push(id);
+    if (ids.length >= STEERING_CANCELLABLE_IDS_MAX) break;
+  }
+  return ids;
+}
+
+// The worker's composer-facing steering snapshot, published on its heartbeat.
+// Callers follow the registry convention of spreading the existing entry into
+// upserts, so an update without `steering` keeps the last known snapshot.
+// Exported so the heartbeat route compares apples to apples: normalizing there
+// with different rules would make an unknown holdReason never converge and
+// re-upsert on every heartbeat.
+//
+// `supported` is the worker's opt-in to mid-turn steering and the client
+// composer's only steering gate: a worker that never sets it — the extension
+// path, or a Claude worker old enough to send the 4-field snapshot — keeps
+// "Queue". `cancellableIds` lists the pushed rows the worker can still pull
+// back out of its runtime (un-steer).
+export function normalizeWorkerSteeringSnapshot(raw) {
+  if (!raw || typeof raw !== 'object') return null;
+  const holdReason = String(raw.holdReason || '').trim().toLowerCase();
+  const messageId = String(raw.messageId || '').trim().slice(0, STEERING_MESSAGE_ID_MAX_LENGTH);
+  return {
+    turnActive: raw.turnActive === true,
+    canSteer: raw.canSteer === true,
+    holdReason: STEERING_HOLD_REASONS.has(holdReason) ? holdReason : null,
+    messageId: messageId || null,
+    supported: raw.supported === true,
+    cancellableIds: normalizeSteeringCancellableIds(raw.cancellableIds),
+  };
+}
+
 function sanitizeState(raw = null) {
   const nowIso = new Date().toISOString();
   const base = raw && typeof raw === 'object' ? raw : {};
@@ -74,11 +122,23 @@ function sanitizeState(raw = null) {
     queueDepth: toNonNegativeInt(base.queueDepth, 0),
     retryCount: toNonNegativeInt(base.retryCount, 0),
     lastError: String(base.lastError || '').trim() || null,
+    steering: normalizeWorkerSteeringSnapshot(base.steering),
     updatedAt: normalizeTimestamp(base.updatedAt, nowIso),
     createdAt,
   };
 }
 
+// Statuses that mean the process a snapshot described is gone or not yet
+// replaced by one that has reported. 'error' counts only on the way IN: a
+// live worker marked errored (a requeue retry) keeps heartbeating, and its
+// next snapshot must stick rather than be cleared on every upsert.
+const WORKER_GONE_STATUSES = new Set(['new', 'starting', 'stopped', 'error']);
+
+function isWorkerReplacedOrGone(existing, next) {
+  if (existing.pid && next.pid !== existing.pid) return true;
+  return next.status !== existing.status && WORKER_GONE_STATUSES.has(next.status);
+}
+
 function toSnapshot(entry) {
   return Object.freeze({ ...entry });
 }
@@ -163,12 +223,26 @@ export function createSessionWorkerRegistry() {
       createdAt: existing?.createdAt || state.createdAt,
       updatedAt: new Date().toISOString(),
     });
+    // A steering snapshot describes one live worker process. Callers spread
+    // the old entry into every upsert, so without this a crashed worker's
+    // hold outlived it and the composer showed it until a replacement
+    // heartbeated — indefinitely, if none ever did.
+    if (existing && isWorkerReplacedOrGone(existing, next)) next.steering = null;
     clearIndexesForSession(existing);
     bySession.set(state.sdkSessionId, next);
     updateIndexesForSession(next);
     return toSnapshot(next);
   }
 
+  /** Drop a session's steering snapshot (its worker process is known dead). */
+  function clearSteering(sdkSessionId) {
+    const sessionId = normalizeSessionId(sdkSessionId);
+    const existing = sessionId ? bySession.get(sessionId) : null;
+    if (!existing?.steering) return false;
+    bySession.set(sessionId, { ...existing, steering: null, updatedAt: new Date().toISOString() });
+    return true;
+  }
+
   function removeWorker(sdkSessionId) {
     const sessionId = normalizeSessionId(sdkSessionId);
     if (!sessionId) return false;
@@ -224,6 +298,7 @@ export function createSessionWorkerRegistry() {
     getWorkerByRuntimeSessionId,
     listWorkers,
     upsertWorker,
+    clearSteering,
     removeWorker,
     rekeyWorker,
     clearAll,

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

@@ -482,10 +482,16 @@ export function createSessionWorkerSupervisor({
     if (current && !isTransitionAllowed(current.status, requestedStatus)) {
       return current;
     }
+    // The steering snapshot is the worker's to set (its heartbeat) and the
+    // registry's to clear (process gone or replaced). Callers build nextState
+    // from an older copy of the entry — ensureWorker from the 'starting' one,
+    // taken before the new process heartbeated — so passing theirs through
+    // would overwrite the snapshot the worker sent in the meantime.
+    const { steering: _staleSteering, ...patch } = nextState;
     const next = registry.upsertWorker({
       ...(current || {}),
       sdkSessionId: sessionId,
-      ...nextState,
+      ...patch,
       status: requestedStatus,
       updatedAt: nowIso(),
     });

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

@@ -91,6 +91,13 @@ function queueSnapshotChanged(left, right) {
 // heartbeats and a retained socket no longer proves the worker is alive.
 const WORKER_SOCKET_LIVENESS_MAX_SILENCE_MS = 30_000;
 
+// Protocol features this relay understands, advertised in server.hello. A
+// worker that updated on disk before the relay restarted must not rely on
+// them otherwise: an older relay ignores worker.unready / hello ready:false
+// and treats a `steering-held` requeue as a failure (retry, backoff,
+// worker marked errored).
+export const WORKER_PROTOCOL_CAPABILITIES = Object.freeze(['worker-unready', 'steering-held']);
+
 export function createSessionWorkerWebSocketService({
   WebSocketServerImpl,
   httpServer,
@@ -378,6 +385,7 @@ export function createSessionWorkerWebSocketService({
     emitEvent(ws, {
       type: 'server.hello',
       reason: 'connected',
+      capabilities: WORKER_PROTOCOL_CAPABILITIES,
       queue: normalizeQueueSnapshot(queueCounts()),
       sessionId: identity.sessionId,
       timestamp: nowIso(),
@@ -396,12 +404,15 @@ export function createSessionWorkerWebSocketService({
       if (payload.type === 'worker.hello') {
         if (!bindSocketIdentity(ws, meta, payload)) return;
         meta.lastSeenAtMs = nowMsSafe();
-        meta.ready = true;
+        // A worker holding deliveries (open question card, compaction) binds
+        // its identity with hello but must not be handed work.
+        meta.ready = payload.ready !== false;
         meta.lastHelloAt = nowIso();
         noteHeartbeat(meta, 'worker-hello');
         emitEvent(ws, {
           type: 'server.hello',
           reason: 'ack',
+          capabilities: WORKER_PROTOCOL_CAPABILITIES,
           queue: normalizeQueueSnapshot(queueCounts()),
           sessionId: meta.sessionId,
           timestamp: nowIso(),
@@ -418,6 +429,17 @@ export function createSessionWorkerWebSocketService({
         void maybeDeliverToSocket(ws, String(payload.reason || 'worker-ready'));
         return;
       }
+      if (payload.type === 'worker.unready') {
+        // Readiness is otherwise sticky until the next delivery: a ready sent
+        // while the worker could steer would still stand after a hold began,
+        // and the delivery it drew would only be handed back.
+        if (!bindSocketIdentity(ws, meta, payload)) return;
+        meta.lastSeenAtMs = nowMsSafe();
+        meta.ready = false;
+        meta.lastUnreadyAt = nowIso();
+        noteHeartbeat(meta, String(payload.reason || 'worker-unready'));
+        return;
+      }
       if (payload.type === 'worker.ping') {
         if (!bindSocketIdentity(ws, meta, payload)) return;
         meta.lastSeenAtMs = nowMsSafe();

package/server/services/steer-resend.mjs

@@ -0,0 +1,45 @@
+// Resend of a steer a Stop cut off unanswered (kind='stopped'): shared by the
+// POST /api/message guard and the transcript payload, so "Resent" on screen
+// and the relay's refusal of a second Resend agree.
+
+/**
+ * Whether an earlier Resend still stands. A cancelled queued message loses
+ * its queue row; a failed one keeps it as 'failed'; a finished one may have
+ * been pruned from the queue, which its answer (linked by source) proves.
+ */
+export function isLiveResend({ hasQueueRow = false, queueStatus = null, answered = false } = {}) {
+  if (hasQueueRow) {
+    return !['failed', 'cancelled'].includes(String(queueStatus || '').trim().toLowerCase());
+  }
+  return !!answered;
+}
+
+/**
+ * Original message id → the id of a Resend of it that still stands, from one
+ * conversation's messages (DB rows) and queue rows ({ id, status }).
+ */
+export function liveResendsByOriginal(dbMessages = [], queueRows = []) {
+  const queueById = new Map((Array.isArray(queueRows) ? queueRows : [])
+    .map((row) => [String(row?.id || '').trim(), row]));
+  const answeredSources = new Set();
+  for (const message of Array.isArray(dbMessages) ? dbMessages : []) {
+    if (message?.role !== 'assistant') continue;
+    const source = String(message?.source_message_id || '').trim();
+    if (source) answeredSources.add(source);
+  }
+  for (const row of queueById.values()) {
+    if (row?.response_message_id) answeredSources.add(String(row.id || '').trim());
+  }
+  const result = new Map();
+  for (const message of Array.isArray(dbMessages) ? dbMessages : []) {
+    if (message?.role !== 'user') continue;
+    const original = String(message?.resend_of_message_id || '').trim();
+    if (!original || result.has(original)) continue;
+    const id = String(message?.id || '').trim();
+    const queueRow = queueById.get(id);
+    if (isLiveResend({ hasQueueRow: !!queueRow, queueStatus: queueRow?.status, answered: answeredSources.has(id) })) {
+      result.set(original, id);
+    }
+  }
+  return result;
+}

package/shared/background-task-timeout.mjs

@@ -2,14 +2,22 @@
 // persistent Claude CLI process alive, shared so the settings slider and the
 // worker enforcing it agree on bounds and formatting.
 //
-// 0 means no limit — the default: a process holding live tasks stays up until
-// the tasks finish, the user stops them from the composer panel, or the
-// worker/relay goes down. Mirrors shared/turn-ceiling.mjs.
+// The default is 4 hours: long enough for real long-running work to finish,
+// short enough that a forgotten shell or agent does not keep its runtime
+// alive indefinitely. 0 (chosen explicitly) means no limit: a process holding
+// live tasks stays up until the tasks finish, the user stops them from the
+// composer panel, or the worker/relay goes down. Mirrors
+// shared/turn-ceiling.mjs.
+//
+// The browser mirrors the default in
+// server/public/app/background-task-timeout-options.mjs (only server/public is
+// served), and the slider's static markup in server/public/index.html starts
+// at it; unit tests pin both to this module.
 
 export const BACKGROUND_TASK_TIMEOUT_MIN_MINUTES = 0;
 export const BACKGROUND_TASK_TIMEOUT_MAX_MINUTES = 600;
 export const BACKGROUND_TASK_TIMEOUT_STEP_MINUTES = 5;
-export const DEFAULT_BACKGROUND_TASK_TIMEOUT_MINUTES = 0;
+export const DEFAULT_BACKGROUND_TASK_TIMEOUT_MINUTES = 240;
 
 /** 0 disables the timeout entirely (unlimited). */
 export function normalizeBackgroundTaskTimeoutMinutes(value, fallback = DEFAULT_BACKGROUND_TASK_TIMEOUT_MINUTES) {

package/shared/control-poller.mjs

@@ -63,7 +63,10 @@ export function createControlPoller({
 
     dbg('abort_turn control received', control.id);
     try {
-      await onAbortTurn();
+      // The control names the row the user stopped. A runner that owns several
+      // rows at once (a turn plus the messages steered into it) needs it to
+      // tell the stopped row from the ones it must settle itself.
+      await onAbortTurn(control);
       await api('POST', `/api/control/${encodeURIComponent(control.id)}/result`, {
         ok: true,
         note: abortAckNote,

package/shared/question-multi-select.mjs

@@ -0,0 +1,16 @@
+// Whether a choice question reads as "pick several" — for providers whose
+// ask-user tool has no multi-select flag (Copilot's `ask_user`; Claude's
+// AskUserQuestion carries `multiSelect: true` itself). The card then offers
+// checkmarks instead of one-shot buttons and answers with the selected labels
+// joined by ", ". Conservative on purpose: an ordinary "which one?" keeps its
+// buttons, because a wrongly multi-select card costs the user a second click
+// while a wrongly single-select one forces them into the free-text field.
+export function looksLikeMultiSelectQuestion(questionText, choices = []) {
+  if (!Array.isArray(choices) || choices.length < 2) return false;
+  const text = String(questionText || '');
+  return /\ball that apply\b/i.test(text)
+    || /\bmulti-?select\b/i.test(text)
+    || /\b(select|choose|pick|check|tick|enable|turn on)\b[^.!?\n]{0,40}\b(all|multiple|several|any number|one or more|as many|more than one)\b/i.test(text)
+    || /\bmultiple (choices|options|selections|answers)\b/i.test(text)
+    || /\bone or more\b/i.test(text);
+}

package/shared/relay-stop-failure.mjs

@@ -0,0 +1,15 @@
+// The terminal outcome of a turn the user stopped — what the relay records
+// when a worker acknowledges an abort control. Shared so a worker that dies
+// before its ack lands fails the stopped row the same way instead of letting
+// it be requeued (a requeue re-runs a prompt the user explicitly stopped).
+export function buildRelayStopFailure() {
+  return {
+    kind: 'turn-aborted',
+    error: 'turn-aborted',
+    code: 'turn-aborted',
+    stableCode: 'relay.turn-aborted',
+    message: 'System note: This turn was stopped from the relay UI before completion.',
+    guidance: 'Send a new message to continue when you are ready.',
+    failedAt: new Date().toISOString(),
+  };
+}

package/shared/slash-command-guard.mjs

@@ -0,0 +1,76 @@
+// Keeps a "/x" message the relay delivers to the Claude CLI plain text.
+//
+// The relay itself runs only /compact and /preview as commands, and neither
+// reaches a worker as text: the composer (and the /api/message route, for
+// /compact) intercept them. Any other "/x" the composer sends only after its
+// warn-once guard ("press send again to send as text"), and the API accepts
+// it as-is — so it must reach the model as the text the user typed. The Claude
+// CLI, however, runs a prompt as a slash command when the string, or its LAST
+// text block trimmed, starts with "/". Between turns that ran "/help what is
+// 3 + 4?" as the CLI's /help (a `local_command` with "isn't available in this
+// environment" as its output): the model never saw the question, and the
+// relay attributed the next turn's reply to that row (live, 2026-09-26).
+//
+// The guard is a zero-width space in front of the "/". JavaScript's trim()
+// does not strip U+200B, so neither the CLI's command check nor its queue's
+// "is this a command" check fires, and the message is handled exactly like
+// any other plain-text prompt (live probe, CLI 2.1.283: no local_command, the
+// model answered the question, the transcript keeps the character). The
+// relay stores and shows the user's own text; only the CLI sees the guard.
+//
+// A steered message needs none: the steer note (shared/steer-note.mjs) already
+// leads its text, so the guard only applies where the text itself starts
+// with "/".
+//
+// Not the SDK's per-message `client_composed: true`: that suppresses the
+// dispatch too (same probe), but older CLIs ignore the field, it also turns
+// off `@path` expansion and drops part of the turn-start context for that
+// message (the probe lost the token-budget reminder), and per the CLI bundle
+// its queue still classifies the text by the leading "/" (e.g. never merges
+// it with other queued prompts) — the guard makes it plain text everywhere.
+
+export const SLASH_COMMAND_GUARD = '\u200B';
+
+function readsAsSlashCommand(text) {
+  return typeof text === 'string' && text.trim().startsWith('/');
+}
+
+/** Prefix the guard when the CLI would read the text as a slash command. */
+export function withSlashCommandGuard(text) {
+  return readsAsSlashCommand(text) ? `${SLASH_COMMAND_GUARD}${text}` : text;
+}
+
+/**
+ * The guard applied to Claude user content: a string, or every text block of a
+ * content-block array (the CLI inspects the last block; guarding each keeps
+ * that true whatever the block order). Returns the input itself when nothing
+ * needed a guard; never mutates it.
+ */
+export function withSlashCommandGuardContent(content) {
+  if (typeof content === 'string') return withSlashCommandGuard(content);
+  if (!Array.isArray(content)) return content;
+  if (!content.some((block) => block?.type === 'text' && readsAsSlashCommand(block.text))) return content;
+  return content.map((block) => (block?.type === 'text' && readsAsSlashCommand(block.text)
+    ? { ...block, text: withSlashCommandGuard(block.text) }
+    : block));
+}
+
+/**
+ * The user's own text from a guarded prompt: the leading guard is dropped only
+ * where it stands in front of a "/", so other text is returned unchanged.
+ */
+export function stripSlashCommandGuard(text) {
+  const value = String(text ?? '');
+  return value.startsWith(SLASH_COMMAND_GUARD) && readsAsSlashCommand(value.slice(SLASH_COMMAND_GUARD.length))
+    ? value.slice(SLASH_COMMAND_GUARD.length)
+    : value;
+}
+
+/** stripSlashCommandGuard over a string or each text block of a content array. */
+export function stripSlashCommandGuardContent(content) {
+  if (typeof content === 'string') return stripSlashCommandGuard(content);
+  if (!Array.isArray(content)) return content;
+  return content.map((block) => (block?.type === 'text' && typeof block.text === 'string'
+    ? { ...block, text: stripSlashCommandGuard(block.text) }
+    : block));
+}