@oar-sh/oar 0.9.3 → 0.9.5

package/server/routes/messages-routes.mjs

@@ -37,9 +37,17 @@ import { openAIReasoningEffortsForModel } from '../../shared/openai-reasoning.mj
 import { DEFAULT_CLAUDE_REASONING_EFFORTS } from '../services/provider-reasoning-effort.mjs';
 import { claudeBaseModelId, claudeLongContextModelId } from '../../shared/model-id.mjs';
 import { sanitizeSubagentRunId } from '../../shared/subagent-run-id.mjs';
-import { STEER_FOLDED_TEXT } from '../../shared/steer-settle-markers.mjs';
+import { ANSWERED_ELSEWHERE_KIND, STEER_FOLDED_TEXT } from '../../shared/steer-settle-markers.mjs';
 import { isLiveResend } from '../services/steer-resend.mjs';
 import { resolveProviderModelSelection } from '../services/provider-model-selection.mjs';
+import { stripRemotePromptHeader } from '../../shared/remote-relay-contract.mjs';
+import {
+  admitRemoteRelayRequest,
+  findMentionedRemoteRelays,
+  formatRemoteRelayMentionHint,
+  recordRemoteRelayUnlocks,
+  withRemoteRelayMentionHint,
+} from '../services/remote-relay-inbound.mjs';
 
 export const SESSION_WORKER_OWNER_LEASE_MS = 120_000;
 export const SESSION_WORKER_TRANSIENT_DEQUEUE_RETRIES = 2;
@@ -1784,6 +1792,7 @@ export function registerMessagesRoutes(app, deps) {
     relayBridgeOwnerService,
     relayRestartOrchestrator,
     requestRelayShutdown,
+    cancelRelayShutdown = null,
     featureFlags,
     sessionWorkerRegistry,
     sessionWorkerSupervisor,
@@ -1801,6 +1810,10 @@ export function registerMessagesRoutes(app, deps) {
     opaqueResponseRecoveryPollMs = OPAQUE_RESPONSE_RECOVERY_POLL_MS,
     relayQuestionFinalizationHoldMs = RELAY_QUESTION_FINALIZATION_HOLD_MS,
     imageOperationService = null,
+    // Remote relays (server/services/remote-relay-inbound.mjs): origin on
+    // agent-sent messages, the inbound switch, and mention unlocks. Absent in
+    // older wiring and most tests, where every remote-relay step is a no-op.
+    remoteRelayInbound = null,
   } = deps;
 
   const ttyConsoleActive = runtimeState?.ttyConsoleActive === true;
@@ -1952,6 +1965,16 @@ export function registerMessagesRoutes(app, deps) {
     };
   }
 
+  // The stored preferences, for a send that must leave them alone.
+  function readConversationModelPreference(conversationId, fallbackRelayMode = DEFAULT_RELAY_MODE) {
+    const row = stmts.getConvAnyStatus?.get?.(String(conversationId || '').trim()) || null;
+    return {
+      preferredRelayMode: normalizeRelayMode(row?.preferred_relay_mode) || fallbackRelayMode || DEFAULT_RELAY_MODE,
+      preferredModel: String(row?.preferred_model || '').trim(),
+      preferredReasoningEffort: String(row?.preferred_reasoning_effort || '').trim(),
+    };
+  }
+
   function getConversationSessionState(conversationId) {
     const normalizedConversationId = String(conversationId || '').trim();
     if (!normalizedConversationId) {
@@ -2081,7 +2104,7 @@ export function registerMessagesRoutes(app, deps) {
       },
     });
     io.emit('message_status', { messageId, conversationId, status: 'failed' });
-    void pushDispatchService?.notifyTurnFailed?.({ conversationId, messageId: responseId, text: responseText });
+    void pushDispatchService?.notifyTurnFailed?.({ conversationId, messageId: responseId, sourceMessageId: messageId, text: responseText });
     cancelPendingRelayQuestionsForMessage(messageId);
     const ownerSessionId = isSessionWorkerRoutingEnabled(featureFlags)
       ? normalizeSessionWorkerId(queueRow?.owner_sdk_session_id)
@@ -2824,6 +2847,7 @@ export function registerMessagesRoutes(app, deps) {
   });
 
   app.post('/api/conversation/:conversationId/cancel-turn', auth, (req, res) => {
+    if (!admitRemoteRelayRequest(req, res, remoteRelayInbound)) return;
     const conversationId = String(req.params.conversationId || '').trim();
     const requestedMessageId = String(req.body?.messageId || req.body?.queueMessageId || '').trim();
     const sessionState = getConversationSessionState(conversationId);
@@ -3072,6 +3096,7 @@ export function registerMessagesRoutes(app, deps) {
   }
 
   app.post('/api/conversation/:conversationId/cancel-queued-turn', auth, (req, res) => {
+    if (!admitRemoteRelayRequest(req, res, remoteRelayInbound)) return;
     const conversationId = String(req.params.conversationId || '').trim();
     const requestedMessageId = String(req.body?.messageId || '').trim();
     if (!conversationId) {
@@ -4053,6 +4078,12 @@ export function registerMessagesRoutes(app, deps) {
       attachments: rawAttachments,
       imageTarget: rawImageTarget,
     } = req.body;
+    // A prompt from another relay's agent (body `origin` or the
+    // X-OAR-Remote-Origin header) is refused while the inbound switch is off.
+    // Otherwise its provenance is stored with the message, and it never
+    // unlocks relays or touches the composer draft and preferences.
+    const remoteRequest = admitRemoteRelayRequest(req, res, remoteRelayInbound);
+    if (!remoteRequest) return;
     const sessionId = clientId || ensureSessionId(req, res);
     const requesterIdentity = readBridgeIdentity(req);
     const requesterSessionId = normalizeSessionWorkerId(requesterIdentity?.sessionId);
@@ -4547,7 +4578,12 @@ export function registerMessagesRoutes(app, deps) {
       });
     }
     const resendOriginId = resend?.originId || null;
-    if (!shouldCreateConversation) {
+    // Another relay's agent sends every prompt with a fresh messageId, and a
+    // retry of the same send hits the messageId check at insert. The text
+    // window below would instead swallow a deliberate repeat ("run the tests
+    // again"), which the agent cannot tell from a lost send.
+    const exemptFromTextDuplicateCheck = remoteRequest.remote && !!clientMessageId;
+    if (!shouldCreateConversation && !exemptFromTextDuplicateCheck) {
       const recentUserMessages = stmts.getRecentMessagesDesc.all(conversationId, 20);
       const recentQueueRows = db.prepare(`
         SELECT id, text, status, timestamp
@@ -4577,7 +4613,10 @@ export function registerMessagesRoutes(app, deps) {
 
     const convId = shouldCreateConversation ? uuidv4() : conversationId;
     if (shouldCreateConversation) {
-      getOrCreateConversation(convId, trimmedText || attachmentSummary(attachments) || 'Image');
+      // An agent's prompt opens with the sending relay's header line, which
+      // says who is talking, not what the conversation is about.
+      const titleText = remoteRequest.remote ? stripRemotePromptHeader(trimmedText).trim() : trimmedText;
+      getOrCreateConversation(convId, titleText || attachmentSummary(attachments) || 'Image');
     }
     let conversationWorkspaceRootState = null;
     if (workspaceRootUpdate.changed && workspaceRootUpdate.resolvedPath) {
@@ -4637,7 +4676,7 @@ export function registerMessagesRoutes(app, deps) {
       isNewConversation: shouldCreateConversation,
     });
     const msgId = clientMessageId || uuidv4();
-    const queueText = shouldApplySeed
+    const promptText = shouldApplySeed
       ? [
           '[Carry-over context from previous compacted conversation]',
           String(convSeed.summary_seed).trim(),
@@ -4646,6 +4685,16 @@ export function registerMessagesRoutes(app, deps) {
           trimmedText || '(User sent image attachments only.)',
         ].join('\n')
       : trimmedText;
+    // Only what a human typed unlocks a remote relay (decision 19). The hint
+    // rides in the queued prompt only, so the stored message and the user's
+    // bubble stay exactly what was typed.
+    const mentionedRemoteRelays = remoteRequest.remote
+      ? []
+      : findMentionedRemoteRelays(remoteRelayInbound, trimmedText);
+    const queueText = withRemoteRelayMentionHint(promptText, formatRemoteRelayMentionHint(mentionedRemoteRelays));
+    // A Resend never came from the composer, and neither did another relay's
+    // agent: whatever the user is typing there stays their draft.
+    const keepsComposerDraft = !!resendOriginId || remoteRequest.remote;
 
     const requestedModelOrigin = deriveModelOrigin(requestedModelVariantId || requestedModel);
     let conversationPreferences;
@@ -4664,12 +4713,11 @@ export function registerMessagesRoutes(app, deps) {
         null,
         requestedModelOrigin,
       );
+      if (remoteRequest.origin) remoteRelayInbound?.repository?.setMessageOrigin?.(msgId, remoteRequest.origin);
       linkUploadReferences(convId, msgId, attachments);
       stmts.updateConvTime.run(now, convId);
       if (resendOriginId) stmts.setMessageResendOf?.run(resendOriginId, msgId);
-      // A Resend never came from the composer: whatever the user is typing
-      // there stays their draft.
-      if (!resendOriginId) {
+      if (!keepsComposerDraft) {
         if (typeof stmts.updateConvDraft?.run === 'function') {
           stmts.updateConvDraft.run(null, now, sessionId || null, convId);
         } else {
@@ -4716,13 +4764,17 @@ export function registerMessagesRoutes(app, deps) {
       ) {
         stmts.updateRuntimeSessionProvider.run('claude', claudeModel, claudeModel, now, runtimeSession.id);
       }
-      conversationPreferences = persistConversationModelPreference(
-        convId,
-        requestedRelayMode,
-        requestedModel,
-        requestedReasoningEffort,
-        now,
-      );
+      // Another relay's agent picks the model and mode of its own turn; the
+      // composer keeps restoring the user's choice for this conversation.
+      conversationPreferences = remoteRequest.remote && !shouldCreateConversation
+        ? readConversationModelPreference(convId, requestedRelayMode)
+        : persistConversationModelPreference(
+          convId,
+          requestedRelayMode,
+          requestedModel,
+          requestedReasoningEffort,
+          now,
+        );
       stmts.insertQ.run(
         msgId,
         convId,
@@ -4781,7 +4833,12 @@ export function registerMessagesRoutes(app, deps) {
       }
       throw error;
     }
-    if (!resendOriginId) {
+    recordRemoteRelayUnlocks(remoteRelayInbound, {
+      conversationId: convId,
+      messageId: msgId,
+      relays: mentionedRemoteRelays,
+    });
+    if (!keepsComposerDraft) {
       io.emit('conversation_draft_updated', {
         conversationId: convId,
         draftText: '',
@@ -4851,7 +4908,7 @@ export function registerMessagesRoutes(app, deps) {
       stmts.clearConvSeed.run(now, convId);
     }
 
-    console.log(`[${ts()}] QUEUED    ${msgId.slice(0,8)} conv=${convId.slice(0,8)} rs=${String(runtimeSession?.id || 'none').slice(0,8)} owner=${String(ownerSessionId || 'none').slice(0,8)} new=${!conversationId || !!newConversation} model=${requestedModel} variant=${requestedModelVariantId}${requestedReasoningEffort ? ` effort=${requestedReasoningEffort}` : ''} mode=${requestedRelayMode} text="${trimmedText.slice(0,60)}"${shouldApplySeed ? ' seeded=1' : ''}${attachments.length ? ` attachments=${attachments.length}` : ''}`);
+    console.log(`[${ts()}] QUEUED    ${msgId.slice(0,8)} conv=${convId.slice(0,8)} rs=${String(runtimeSession?.id || 'none').slice(0,8)} owner=${String(ownerSessionId || 'none').slice(0,8)} new=${!conversationId || !!newConversation} model=${requestedModel} variant=${requestedModelVariantId}${requestedReasoningEffort ? ` effort=${requestedReasoningEffort}` : ''} mode=${requestedRelayMode} text="${trimmedText.slice(0,60)}"${shouldApplySeed ? ' seeded=1' : ''}${attachments.length ? ` attachments=${attachments.length}` : ''}${remoteRequest.remote ? ` remote=${remoteRequest.origin?.relayName || remoteRequest.origin?.relayId || 'unknown'} hops=${remoteRequest.origin?.hops ?? '?'}` : ''}${mentionedRemoteRelays.length ? ` mentions=${mentionedRemoteRelays.length}` : ''}`);
 
     emitToClientsExceptSessionId(
       'user_message',
@@ -4867,6 +4924,7 @@ export function registerMessagesRoutes(app, deps) {
           mode: requestedRelayMode,
           timestamp: now,
           attachments,
+          ...(remoteRequest.origin ? { origin: remoteRequest.origin } : {}),
         },
       },
       sessionId,
@@ -6047,6 +6105,20 @@ export function registerMessagesRoutes(app, deps) {
     return res.json({ ok: true, ...result });
   });
 
+  // Withdraw a queued (not yet started) shutdown/restart. Same trust boundary
+  // as queueing one.
+  app.post('/api/relay/shutdown/cancel', auth, (req, res) => {
+    if (!isLoopbackRequest(req)) {
+      return res.status(403).json({ error: 'Relay shutdown endpoint is localhost-only' });
+    }
+    if (typeof cancelRelayShutdown !== 'function') {
+      return res.status(501).json({ error: 'Relay shutdown orchestration is unavailable' });
+    }
+    const requestedBy = String(req.body?.requestedBy || 'localhost-api').trim().slice(0, 80) || 'localhost-api';
+    const result = cancelRelayShutdown({ requestedBy });
+    return res.json({ ok: true, ...result });
+  });
+
   app.post('/api/image-operations/:operationId/execute', auth, async (req, res) => {
     if (!isLoopbackRequest(req)) {
       return res.status(403).json({ error: 'Image operation execution is localhost-only' });
@@ -6416,7 +6488,11 @@ export function registerMessagesRoutes(app, deps) {
     });
   });
 
-  const SETTLED_STEER_KINDS = new Set(['folded', 'stopped']);
+  // Responses that are settle markers, not replies: stamped with their kind,
+  // and no "turn completed" push. The last one is not a steer's: it closes a
+  // message whose answer was published on a continuation row, and that reply
+  // already sent the push.
+  const SETTLED_STEER_KINDS = new Set(['folded', 'stopped', ANSWERED_ELSEWHERE_KIND]);
 
   // POST /api/response — CLI submits response
   app.post('/api/response', auth, async (req, res) => {
@@ -6941,11 +7017,14 @@ export function registerMessagesRoutes(app, deps) {
     io.emit('message_status', { messageId, conversationId: targetConversationId, status: 'done' });
     // An absorbed row is not a finished turn — the reply continues on the
     // steered message's row, whose own completion sends the one notification.
-    // A stopped steer has no reply at all.
+    // A stopped steer has no reply at all, and a message answered on a
+    // continuation row was notified by that row.
     if (!settledKind) {
       void pushDispatchService?.notifyTurnComplete?.({
         conversationId: targetConversationId,
         messageId: responseId,
+        // The push service skips turns another relay's agent started.
+        sourceMessageId: messageId,
         text: resolvedText,
       });
     }

package/server/routes/remote-relay-routes.mjs

@@ -0,0 +1,133 @@
+'use strict';
+
+// Remote relays API (plan §5.1, §5.4, §5.6): this relay's identity, the list
+// of paired relays, adding/pairing, self settings and the single endpoint all
+// agent tool calls converge on. Everything is behind `auth` — including the
+// inbound pairing call, which another relay makes with a token that works here.
+//
+// No response carries a stored token: the registry's public views drop it, and
+// the pairing service's answers never contain one.
+
+function sendResult(res, result, fallbackStatus = 400) {
+  const { status, ...payload } = result || {};
+  const code = Number.isInteger(status) ? status : (payload.ok === false ? fallbackStatus : 200);
+  return res.status(code).json(payload);
+}
+
+function internalError(res, error, what) {
+  return res.status(500).json({ error: `${what} failed: ${String(error?.message || error)}` });
+}
+
+export function registerRemoteRelayRoutes(app, deps) {
+  const {
+    auth,
+    registry,
+    pairing,
+    // WP2's dispatcher: `{ dispatch({ conversationId, action, args, req }) →
+    // Promise<{ status, body }>, inflight(conversationId) → number }`.
+    dispatcher = null,
+  } = deps;
+
+  // Static paths first: Express would otherwise hand them to /:id.
+
+  // GET /api/relay/identity — who this relay is, for other relays' probes.
+  app.get('/api/relay/identity', auth, (_req, res) => {
+    res.json(registry.selfIdentity());
+  });
+
+  app.get('/api/remote-relays', auth, (_req, res) => {
+    res.json({
+      relays: registry.listPublic(),
+      self: { ...registry.selfIdentity(), ...registry.getSelfSettings() },
+    });
+  });
+
+  // Workers ask at start whether to register the remote_relay tool at all.
+  app.get('/api/remote-relays/summary', auth, (_req, res) => {
+    const relays = registry.listPublic();
+    res.json({
+      count: relays.length,
+      online: relays.filter((relay) => relay.lastStatus === 'online').length,
+    });
+  });
+
+  // The Grok inactivity hold asks whether a tool call is still running.
+  app.get('/api/remote-relays/inflight', auth, (req, res) => {
+    const conversationId = String(req.query?.conversationId || '').trim();
+    let inflight = 0;
+    try {
+      inflight = Number(dispatcher?.inflight?.(conversationId)) || 0;
+    } catch {}
+    res.json({ inflight });
+  });
+
+  // POST /api/remote-relays — add a relay from a pasted link (and pair back).
+  app.post('/api/remote-relays', auth, async (req, res) => {
+    try {
+      sendResult(res, await pairing.addFromLink(req.body || {}));
+    } catch (error) {
+      internalError(res, error, 'Adding the remote relay');
+    }
+  });
+
+  // POST /api/remote-relays/pair — another relay introduces itself.
+  app.post('/api/remote-relays/pair', auth, async (req, res) => {
+    try {
+      sendResult(res, await pairing.acceptPairing(req.body || {}));
+    } catch (error) {
+      internalError(res, error, 'Pairing');
+    }
+  });
+
+  // POST /api/remote-relays/tool — every provider adapter's remote_relay call.
+  app.post('/api/remote-relays/tool', auth, async (req, res) => {
+    if (!dispatcher) return res.status(503).json({ error: 'Remote relay dispatcher unavailable' });
+    // A worker that gives up on the call (turn stopped, worker gone) closes
+    // the request: withdraw its approval card and stop waiting for the reply.
+    const controller = new AbortController();
+    res.on('close', () => {
+      if (!res.writableFinished) controller.abort();
+    });
+    try {
+      const result = await dispatcher.dispatch({
+        conversationId: req.body?.conversationId,
+        action: req.body?.action,
+        args: req.body?.args || {},
+        req,
+        signal: controller.signal,
+      });
+      if (controller.signal.aborted) return;
+      res.status(Number.isInteger(result?.status) ? result.status : 200).json(result?.body ?? {});
+    } catch (error) {
+      internalError(res, error, 'The remote relay call');
+    }
+  });
+
+  app.get('/api/settings/remote-relays', auth, (_req, res) => {
+    res.json(registry.getSelfSettings());
+  });
+
+  app.post('/api/settings/remote-relays', auth, (req, res) => {
+    sendResult(res, registry.setSelfSettings(req.body || {}));
+  });
+
+  // PATCH /api/remote-relays/:id — { permission, url, token, tokenMode }.
+  app.patch('/api/remote-relays/:id', auth, (req, res) => {
+    sendResult(res, registry.update(req.params?.id, req.body || {}));
+  });
+
+  // DELETE /api/remote-relays/:id — local only; the other side keeps its entry.
+  app.delete('/api/remote-relays/:id', auth, (req, res) => {
+    sendResult(res, registry.remove(req.params?.id), 404);
+  });
+
+  app.post('/api/remote-relays/:id/check', auth, async (req, res) => {
+    try {
+      const relay = await registry.check(req.params?.id);
+      if (!relay) return res.status(404).json({ error: 'Unknown remote relay' });
+      res.json({ ok: true, relay });
+    } catch (error) {
+      internalError(res, error, 'The check');
+    }
+  });
+}

package/server/routes/sessions-routes.mjs

@@ -6,7 +6,6 @@ import fs from 'fs';
 import path from 'path';
 import { fileURLToPath } from 'url';
 import { randomUUID } from 'crypto';
-import { spawn } from 'child_process';
 import { createSdkSessionSyncService } from '../services/sdk-session-sync-service.mjs';
 import { applySafeServedContentHeaders } from '../services/safe-served-content.mjs';
 import { stripRelayPromptContext } from '../services/relay-prompt-sanitizer.mjs';
@@ -36,6 +35,8 @@ import {
 import { workspaceRootDisplayName } from '../workspace-root.mjs';
 import { createKeyedMutex } from '../services/keyed-mutex-service.mjs';
 import { createFixedWindowRateLimiter } from '../services/rate-limit-service.mjs';
+import { parseRemoteRelayOriginJson } from '../repositories/remote-relay-repository.mjs';
+import { admitRemoteRelayRequest, publicRemoteRelayOrigin } from '../services/remote-relay-inbound.mjs';
 import {
   RELAUNCH_COALESCE_WINDOW_MS,
   buildRelaunchRequestKey,
@@ -686,26 +687,6 @@ function isOpenAIImageModelId(model = '') {
   return normalized.startsWith('gpt-image-') || normalized.startsWith('dall-e-');
 }
 
-function runHostSuspendToRam() {
-  if (process.platform !== 'win32') {
-    return { ok: false, statusCode: 501, error: 'Host suspend is only supported on Windows' };
-  }
-  try {
-    const child = spawn('rundll32.exe', ['powrprof.dll,SetSuspendState', '0,0,0'], {
-      detached: true,
-      stdio: 'ignore',
-      windowsHide: true,
-    });
-    child.unref?.();
-    return {
-      ok: true,
-      command: 'rundll32.exe powrprof.dll,SetSuspendState 0,0,0',
-    };
-  } catch (error) {
-    return { ok: false, statusCode: 500, error: error?.message || 'Failed to launch host suspend command' };
-  }
-}
-
 function isPidAlive(pidValue) {
   const pid = Number(pidValue);
   if (!Number.isInteger(pid) || pid <= 0) return false;
@@ -1766,6 +1747,8 @@ export function buildConversationMessages({
         const queueRow = sourceMessageId
           ? queueRowsById.get(sourceMessageId)
           : (message?.role === 'user' ? queueRowsById.get(id) : null);
+        // Provenance of a prompt another relay's agent sent: the bubble's badge.
+        const origin = message?.role === 'user' ? parseRemoteRelayOriginJson(message?.origin_json) : null;
         return {
           activities: message?.role === 'assistant' ? (relayActivitiesByMessageId.get(id) || []) : [],
           thoughts: message?.role === 'assistant' ? (relayThoughtsByMessageId.get(id) || []) : [],
@@ -1789,13 +1772,16 @@ export function buildConversationMessages({
           executedProvider: message?.executed_provider || message?.executedProvider || undefined,
           // 'continuation' badges a self-started turn; 'absorbed' marks a
           // reply that continues through the next (steered) user message;
-          // 'folded'/'stopped' are a steer's settle markers. Without this the
-          // live-appended badge/merge/marker vanished on reload.
+          // 'folded'/'stopped' are a steer's settle markers, and
+          // 'answered-elsewhere' marks a message whose answer is on a
+          // continuation row. Without this the live-appended
+          // badge/merge/marker vanished on reload.
           kind: message?.kind || undefined,
           resendOfMessageId: message?.role === 'user' ? (message?.resend_of_message_id || undefined) : undefined,
           resentAs: (message?.role === 'assistant' && message?.kind === 'stopped' && sourceMessageId)
             ? (liveResends.get(sourceMessageId) || undefined)
             : undefined,
+          ...(origin ? { origin } : {}),
         };
       })
     : [];
@@ -2105,6 +2091,13 @@ export function registerSessionsRoutes(app, deps) {
     windowsBootAutostartService,
     isSha256,
     uploadPathForSha,
+    hostSuspendService = null,
+    collectHostActivity = null,
+    hostSuspendPlatform = process.platform,
+    // Remote relays (server/services/remote-relay-inbound.mjs): origin on
+    // conversations another relay's agent created, and the inbound switch.
+    // Absent in older wiring and most tests, where both are no-ops.
+    remoteRelayInbound = null,
   } = deps;
   const sdkSessionSyncService = createSdkSessionSyncService(db);
   // Generic synchronous transaction runner for the session-sync route: binding
@@ -2633,7 +2626,11 @@ export function registerSessionsRoutes(app, deps) {
     });
     messages = messages.map((message) => {
       const sourceMessageId = responseMessageToSourceId.get(String(message.id || '').trim()) || message.sourceMessageId || undefined;
-      const nextMessage = sourceMessageId ? { ...message, sourceMessageId } : message;
+      const withSource = sourceMessageId ? { ...message, sourceMessageId } : message;
+      // A public share never shows another relay's address or ids.
+      const nextMessage = withSource.origin
+        ? { ...withSource, origin: publicRemoteRelayOrigin(withSource.origin) }
+        : withSource;
       const attachments = Array.isArray(nextMessage?.attachments)
         ? nextMessage.attachments.map((attachment) => rewriteSharedGeneratedImageAttachmentContentUrl(rewriteSharedAttachmentContentUrl(attachment, shareToken), shareToken))
         : nextMessage?.attachments;
@@ -2782,6 +2779,8 @@ export function registerSessionsRoutes(app, deps) {
         draftAttachments: parseDraftAttachmentsColumn(r.draft_attachments),
         draftUpdatedAt: r.draft_updated_at || null,
         draftUpdatedByClientId: r.draft_updated_by_client_id || null,
+        // Set on conversations another relay's agent created ("via <relay>").
+        origin: parseRemoteRelayOriginJson(r.origin_json),
       };
     });
 
@@ -3423,6 +3422,7 @@ export function registerSessionsRoutes(app, deps) {
       draftAttachments: parseDraftAttachmentsColumn(conv.draft_attachments),
       draftUpdatedAt: conv.draft_updated_at || null,
       draftUpdatedByClientId: conv.draft_updated_by_client_id || null,
+      origin: parseRemoteRelayOriginJson(conv.origin_json),
       messages: history.messages,
       pageInfo: history.pageInfo,
       refreshed: true,
@@ -3818,6 +3818,10 @@ export function registerSessionsRoutes(app, deps) {
       updatedAt: conv.updated_at,
       sessionUsageSummary,
       inFlight,
+      // A queued (pending/parked) row counts too: inFlight covers only the
+      // processing one. Another relay's agent tells "still queued" from
+      // "cancelled" with it.
+      activeTurn: Number(stmts.getConversationActiveQueueCount?.get?.(resolvedConversationId)?.count || 0) > 0,
       backgroundTasks: backgroundTaskStore?.get?.(resolvedConversationId) || [],
       previews: listConversationPreviews?.(resolvedConversationId) || [],
       preferredRelayMode: preferences.preferredRelayMode,
@@ -3827,6 +3831,8 @@ export function registerSessionsRoutes(app, deps) {
       draftAttachments: parseDraftAttachmentsColumn(conv.draft_attachments),
       draftUpdatedAt: conv.draft_updated_at || null,
       draftUpdatedByClientId: conv.draft_updated_by_client_id || null,
+      // Set on conversations another relay's agent created ("via <relay>").
+      origin: parseRemoteRelayOriginJson(conv.origin_json),
       messages: history.messages,
       pageInfo: history.pageInfo,
     });
@@ -4548,6 +4554,7 @@ export function registerSessionsRoutes(app, deps) {
     });
     const orphanedUploads = collectOrphanedUploadsFromConversation(id);
     hardDeleteConversationRows(id);
+    remoteRelayInbound?.repository?.forgetConversation?.(id);
     deleteOrphanedUploads(orphanedUploads);
     if (sdkSessionId && !cliSession.queued) stmts.deleteSdkDeleteRequest?.run?.(sdkSessionId);
     io.emit('conversation_deleted', { conversationId: id });
@@ -4556,6 +4563,7 @@ export function registerSessionsRoutes(app, deps) {
 
   // POST /api/conversation/:id/archive — archive conversation
   app.post('/api/conversation/:id/archive', auth, async (req, res) => {
+    if (!admitRemoteRelayRequest(req, res, remoteRelayInbound)) return;
     const id = String(req.params.id || '').trim();
     if (!id) return res.status(400).json({ error: 'Missing conversation id' });
     try {
@@ -4573,6 +4581,10 @@ export function registerSessionsRoutes(app, deps) {
   });
 
   app.post('/api/conversation/bootstrap', auth, async (req, res) => {
+    // Another relay's agent starting a session: refused while the inbound
+    // switch is off, otherwise the conversation keeps its provenance.
+    const remoteRequest = admitRemoteRelayRequest(req, res, remoteRelayInbound);
+    if (!remoteRequest) return;
     const clientSessionId = String(ensureSessionId(req, res) || '').trim();
     const now = new Date().toISOString();
     let conversationId = '';
@@ -4868,6 +4880,7 @@ export function registerSessionsRoutes(app, deps) {
       // single canonical tuple.
       const commitBootstrapState = db.transaction(() => {
         stmts.insertConv.run(conversationId, title, now, now);
+        if (remoteRequest.origin) remoteRelayInbound?.repository?.setConversationOrigin?.(conversationId, remoteRequest.origin);
         const boundRuntimeSession = ensureRuntimeSessionBinding(
           conversationId,
           selectedModel,
@@ -4987,6 +5000,7 @@ export function registerSessionsRoutes(app, deps) {
         ok: true,
         conversationId,
         conversation,
+        origin: parseRemoteRelayOriginJson(conversation?.origin_json),
         runtimeSessionId: runtimeSession?.id || null,
         ownerSessionId,
         worker: ownerWorker,
@@ -5088,6 +5102,7 @@ export function registerSessionsRoutes(app, deps) {
       activeBridgeOwner: runtimeState.activeBridgeOwner || null,
       restartOrchestrator: relayRestartOrchestrator?.getState?.() || null,
       relayShutdown: runtimeState.relayShutdown || null,
+      hostSuspend: runtimeState.hostSuspend || null,
       platform: process.platform,
       features: featureFlags || {},
       sessionWorker: sessionWorkerStatus,
@@ -6182,21 +6197,59 @@ export function registerSessionsRoutes(app, deps) {
     });
   });
 
+  // Deferred host suspend: the request is queued and fulfilled by the
+  // host-suspend service once nothing runs any more (see
+  // docs/plans/2026-09-27-deferred-host-suspend.md).
+  app.get('/api/host/suspend', auth, (req, res) => {
+    if (!hostSuspendService) {
+      return res.status(501).json({ ok: false, error: 'Host suspend is unavailable' });
+    }
+    const state = hostSuspendService.refresh();
+    let activity = null;
+    if (!state.pending && typeof collectHostActivity === 'function') {
+      try {
+        activity = collectHostActivity({ request: null });
+      } catch (error) {
+        activity = { blockers: [], error: String(error?.message || error) };
+      }
+    }
+    return res.json({
+      ok: true,
+      supported: hostSuspendPlatform === 'win32',
+      state,
+      blockers: state.pending ? state.blockers : (activity?.blockers || []),
+      activity,
+    });
+  });
+
   app.post('/api/host/suspend', auth, (req, res) => {
-    const result = runHostSuspendToRam();
-    if (!result?.ok) {
-      return res.status(result?.statusCode || 500).json({
-        ok: false,
-        error: result?.error || 'Failed to suspend host',
-      });
+    if (!hostSuspendService) {
+      return res.status(501).json({ ok: false, error: 'Host suspend is unavailable' });
+    }
+    if (hostSuspendPlatform !== 'win32') {
+      return res.status(501).json({ ok: false, error: 'Host suspend is only supported on Windows' });
     }
+    const reason = String(req.body?.reason || 'manual-suspend').trim().slice(0, 140) || 'manual-suspend';
+    const requestedBy = String(req.body?.requestedBy || 'localhost-api').trim().slice(0, 80) || 'localhost-api';
+    const result = hostSuspendService.request({ reason, requestedBy });
     return res.status(202).json({
       ok: true,
       queued: true,
-      command: result.command,
+      accepted: result.accepted !== false,
+      alreadyPending: !!result.alreadyPending,
+      state: result.state,
     });
   });
 
+  app.post('/api/host/suspend/cancel', auth, (req, res) => {
+    if (!hostSuspendService) {
+      return res.status(501).json({ ok: false, error: 'Host suspend is unavailable' });
+    }
+    const requestedBy = String(req.body?.requestedBy || 'localhost-api').trim().slice(0, 80) || 'localhost-api';
+    const result = hostSuspendService.cancel({ requestedBy });
+    return res.json({ ok: true, cancelled: !!result.cancelled, state: result.state });
+  });
+
   app.get('/api/restart-orchestrator', auth, (req, res) => {
     ensureSessionId(req, res);
     return res.json({ orchestrator: relayRestartOrchestrator?.getState?.() || null });