@oar-sh/oar 0.9.3 → 0.9.5

package/server/copilot-worker/copilot-remote-relay-tool.mjs

@@ -0,0 +1,59 @@
+// The relay's `remote_relay` tool for Copilot SDK sessions: a plain SDK
+// `Tool` (`{ name, description, parameters, skipPermission, handler }`) built
+// from the shared contract and forwarded through the shared tool core. The
+// module never imports the SDK; the session process hands the definition to
+// `SessionConfig.tools`.
+//
+// `skipPermission`: the relay does the approving. A write action in ask or
+// plan mode raises its own question card server-side, so a runtime permission
+// prompt on top would ask the user twice for one action.
+
+import {
+  REMOTE_RELAY_CALL_FAILED,
+  REMOTE_RELAY_TOOL_DESCRIPTION,
+  REMOTE_RELAY_TOOL_NAME,
+  cloneRemoteRelayToolInputSchema,
+  executeRemoteRelayTool,
+  formatRemoteRelayToolResult,
+} from '../../shared/remote-relay-tool-core.mjs';
+
+/**
+ * `runCall(fn)` wraps every execution — the session process uses it to hold
+ * its stall watchdog and idle shutdown while the relay waits on a remote turn.
+ * The handler never throws: a failure answers in-band as JSON the model can
+ * read, which is what the runtime passes back to it anyway.
+ *
+ * `getSignal(invocation)` is the call's cancellation. By default the SDK's
+ * own `invocation.signal`, which aborts when the runtime completes the
+ * request or the session disconnects; the session process adds the turn's
+ * Stop to it.
+ */
+export function buildCopilotRemoteRelayTool({
+  api,
+  getConversationId = () => '',
+  runCall = (fn) => fn(),
+  getSignal = (invocation) => invocation?.signal || null,
+  dbg = () => {},
+} = {}) {
+  return {
+    name: REMOTE_RELAY_TOOL_NAME,
+    description: REMOTE_RELAY_TOOL_DESCRIPTION,
+    parameters: cloneRemoteRelayToolInputSchema(),
+    skipPermission: true,
+    handler: async (args, invocation) => {
+      let result;
+      try {
+        result = await runCall(() => executeRemoteRelayTool(args, {
+          api,
+          conversationId: String(getConversationId() || ''),
+          signal: getSignal(invocation) || null,
+        }));
+      } catch (error) {
+        const message = error?.message || String(error);
+        dbg('remote_relay tool failed', message);
+        result = { ok: false, code: REMOTE_RELAY_CALL_FAILED, error: message };
+      }
+      return formatRemoteRelayToolResult(result);
+    },
+  };
+}

package/server/copilot-worker/copilot-sdk-event-normalizer.mjs

@@ -22,6 +22,11 @@
 import { sanitizeSubagentRunId } from '../../shared/subagent-run-id.mjs';
 import { capThought } from '../../shared/thought-cap.mjs';
 import { shouldEmitStreamUpdate } from '../../shared/stream-emit-gating.mjs';
+import {
+  REMOTE_RELAY_TOOL_NAME,
+  isRemoteRelayToolName,
+  remoteRelayActivitySummary,
+} from '../../shared/remote-relay-tool-core.mjs';
 
 const MAX_TOOL_DETAIL_LENGTH = 140;
 
@@ -78,8 +83,13 @@ export function summarizeToolInput(input) {
 }
 
 export function formatToolActivityText(toolName, input) {
-  const name = String(toolName || '').trim() || 'tool';
-  const summary = summarizeToolInput(input);
+  const rawName = String(toolName || '').trim() || 'tool';
+  // `remote_relay` (bare, or namespaced by an MCP server) reads as what it
+  // does on which relay (`send → linux-test session 01234567: “…”`); its
+  // arguments may arrive as a JSON string.
+  const isRemoteRelay = isRemoteRelayToolName(rawName);
+  const name = isRemoteRelay ? REMOTE_RELAY_TOOL_NAME : rawName;
+  const summary = (isRemoteRelay && remoteRelayActivitySummary(input)) || summarizeToolInput(input);
   return truncate(summary ? `Tool (${name}): ${summary}` : `Tool (${name})`);
 }
 

package/server/copilot-worker/copilot-sdk-session-process.mjs

@@ -84,6 +84,8 @@ import {
   isToolOverrideRejection,
   parseAskUserToolArguments,
 } from './copilot-ask-user-tool.mjs';
+import { buildCopilotRemoteRelayTool } from './copilot-remote-relay-tool.mjs';
+import { createRemoteRelayToolGate } from '../../shared/remote-relay-tool-core.mjs';
 import {
   EXIT_PLAN_BOARD_POSTED_FEEDBACK,
   EXIT_PLAN_NO_BOARD_FEEDBACK,
@@ -351,6 +353,9 @@ export function createCopilotSdkSessionRunner({
   // runtime's built-in one. A runtime that refuses the override falls back
   // to the built-in for the rest of this worker's life.
   relayAskUserTool = true,
+  // Whether sessions carry the relay's `remote_relay` tool
+  // (shared/remote-relay-tool-core.mjs). Default: ask the relay.
+  remoteRelayToolGate = null,
   taskRefreshMs = DEFAULT_TASK_REFRESH_MS,
   taskPublishThrottleMs = DEFAULT_TASK_PUBLISH_THROTTLE_MS,
   // Called with `true`/`false` whenever the runner flips between accepting
@@ -518,6 +523,17 @@ export function createCopilotSdkSessionRunner({
   // the human's eventual answer to a runtime whose row is already settled.
   // Same guard the Cursor worker's `hasPendingClientWork` provides.
   let pendingHumanRequests = 0;
+  // Running `remote_relay` calls. The runtime is just as silent while one
+  // runs (the relay may wait up to 600 s for a remote turn, plus an approval
+  // card), so they hold the stall watchdog and the idle shutdown too — but
+  // not steering: nobody is answering a card here.
+  let pendingRelayToolCalls = 0;
+  // `remote_relay` is registered only while this relay has paired remotes.
+  // Asked once when the worker starts; a session build waits for that first
+  // answer (it is async anyway), and every runtime stop asks again so the
+  // next session picks up a remote paired in the meantime.
+  const remoteRelayGate = remoteRelayToolGate || createRemoteRelayToolGate({ api });
+  void remoteRelayGate.refresh();
   // The `SessionConfig.provider` block this session was BUILT with, or null for
   // a hosted (`github`) session. Set by `buildSessionConfig` rather than by a
   // second throwaway resolve here, so "is this BYOK?" and "what did the runtime
@@ -1787,6 +1803,32 @@ export function createCopilotSdkSessionRunner({
     };
   }
 
+  /**
+   * The relay's `remote_relay` tool (copilot-remote-relay-tool.mjs). Every call
+   * is counted while it runs: the stall watchdog re-arms instead of failing the
+   * row, and the lifecycle keeps the runtime up. The clock restarts from the
+   * answer, like after a card. A call is cancelled by the runtime (its
+   * invocation signal) or by a Stop of the turn it started under.
+   */
+  function buildRemoteRelayTool() {
+    return buildCopilotRemoteRelayTool({
+      api,
+      getConversationId: () => activeTurn?.message?.conversationId || sdkSessionId || '',
+      getSignal: (invocation) => combineSignals(activeTurn?.remoteRelayStop?.signal, invocation?.signal),
+      runCall: async (fn) => {
+        pendingRelayToolCalls += 1;
+        try {
+          return await fn();
+        } finally {
+          pendingRelayToolCalls -= 1;
+          touch();
+          activeTurn?.armStall?.();
+        }
+      },
+      dbg,
+    });
+  }
+
   /** One signal that aborts when any of the given ones does (nulls ignored). */
   function combineSignals(...signals) {
     const live = signals.filter((signal) => signal && typeof signal.aborted === 'boolean');
@@ -1804,20 +1846,35 @@ export function createCopilotSdkSessionRunner({
    * Open a session, retrying once without the relay's `ask_user` when the
    * runtime refuses the override (an older runtime). The refusal is
    * remembered until the runtime is stopped — the next runtime (possibly
-   * auto-updated under the relay) gets another try.
+   * auto-updated under the relay) gets another try. Only the override goes:
+   * the relay's other tools (`remote_relay`) override nothing and stay.
    */
   async function openSession(open, config) {
     try {
       return await open(config);
     } catch (error) {
-      if (!config?.tools?.length || !isToolOverrideRejection(error) || isSessionNotFoundError(error)) throw error;
+      const tools = Array.isArray(config?.tools) ? config.tools : [];
+      const isAskUserOverride = (tool) => tool?.name === RELAY_ASK_USER_TOOL_NAME && tool?.overridesBuiltInTool === true;
+      if (!tools.some(isAskUserOverride) || !isToolOverrideRejection(error) || isSessionNotFoundError(error)) throw error;
       dbg('the runtime refused the relay ask_user override; using its built-in ask_user', error?.message || String(error));
       askUserOverrideRejected = true;
       const { tools: _tools, ...withoutTools } = config;
-      return open(withoutTools);
+      const kept = tools.filter((tool) => !isAskUserOverride(tool));
+      return open(kept.length ? { ...withoutTools, tools: kept } : withoutTools);
     }
   }
 
+  /** The relay's own session tools; each is added only when it applies. */
+  function relaySessionTools() {
+    return [
+      // The relay's `ask_user` (see copilot-ask-user-tool.mjs): the built-in's
+      // fields plus `multi_select`, so a model can declare a multi-select
+      // question instead of the relay guessing from its wording.
+      ...(relayAskUserTool && !askUserOverrideRejected ? [buildRelayAskUserTool()] : []),
+      ...(remoteRelayGate.isEnabled() ? [buildRemoteRelayTool()] : []),
+    ];
+  }
+
   function buildSessionConfig(model, reasoningEffort = null) {
     // Built once per session, not per request. Reads the mode off the LIVE turn
     // rather than closing over the one the session was built with, because one
@@ -1857,6 +1914,7 @@ export function createCopilotSdkSessionRunner({
     const provider = resolveProviderConfigImpl({ env, model: model || defaultModel, dbg });
     byokProvider = provider;
     const effort = normalizeRelayEffort(reasoningEffort);
+    const tools = relaySessionTools();
     return {
       // The relay session id IS the SDK session id, so the runtime's own state
       // under ~/.copilot/session-state/<id> is addressable by conversation and
@@ -1879,10 +1937,8 @@ export function createCopilotSdkSessionRunner({
       // The runtime's own defaults, pinned. See DEFAULT_INFINITE_SESSION_CONFIG.
       ...(infiniteSessionConfig ? { infiniteSessions: { ...infiniteSessionConfig } } : {}),
       onEvent: routeEvent,
-      // The relay's `ask_user` (see copilot-ask-user-tool.mjs): the built-in's
-      // fields plus `multi_select`, so a model can declare a multi-select
-      // question instead of the relay guessing from its wording.
-      ...(relayAskUserTool && !askUserOverrideRejected ? { tools: [buildRelayAskUserTool()] } : {}),
+      // The relay's own tools (`relaySessionTools`); omitted when there are none.
+      ...(tools.length ? { tools } : {}),
       // Permission policy follows the conversation's relay mode: agent and
       // autopilot auto-approve, plan denies non-read tools with feedback, and
       // ask asks the human through a relay question card. The handler reads the
@@ -2119,6 +2175,9 @@ export function createCopilotSdkSessionRunner({
   async function ensureSession(model, effort) {
     await ensureClient();
     if (!session) {
+      // The tool list is part of the session: wait for the worker's first
+      // registration answer (bounded, and it fails closed).
+      await remoteRelayGate.ready();
       const config = buildSessionConfig(model, effort);
       // Resume first, always. On a brand-new conversation this costs one
       // failed RPC; on every other path (worker restart, idle shutdown,
@@ -2185,6 +2244,8 @@ export function createCopilotSdkSessionRunner({
 
   async function stopRuntime(reason) {
     stopLifecycleTimer();
+    // The next session is built from a fresh registration answer.
+    void remoteRelayGate.refresh();
     try { detachRuntimeExit(); } catch { /* the observer is best-effort */ }
     detachRuntimeExit = () => {};
     const closingSession = session;
@@ -2320,7 +2381,9 @@ export function createCopilotSdkSessionRunner({
     // A pending question card means a human is mid-answer; tearing the runtime
     // down under them would discard the session the answer belongs to. A turn
     // that is still publishing counts too: it settled, but its rows are live.
-    if (disposed || activeTurn || publishingTurns.size > 0 || pendingHumanRequests > 0 || !client) return;
+    if (
+      disposed || activeTurn || publishingTurns.size > 0 || pendingHumanRequests > 0 || pendingRelayToolCalls > 0 || !client
+    ) return;
     if (!(idleShutdownMs > 0)) return;
     // Evaluated before the idle clock so the caps still expire on a runtime
     // that has been quiet far longer than the idle window.
@@ -2441,6 +2504,10 @@ export function createCopilotSdkSessionRunner({
       // Cancels any relay question card this turn is blocked on, so an aborted
       // turn does not leave a human answering into the void.
       abortController: new AbortController(),
+      // Cancels the `remote_relay` calls that started under this turn — on the
+      // user's Stop only. Not `abortController`: that one also fires when the
+      // turn settles normally, and a background agent's call must outlive that.
+      remoteRelayStop: new AbortController(),
       // Cards (questions, ask-mode approvals, elicitations) open on this
       // turn's row; `humansIdle` resolves when the last one is done. A turn
       // that settles with one still open publishes only after it (driveTurn).
@@ -2546,7 +2613,9 @@ export function createCopilotSdkSessionRunner({
         // A human staring at a question card is not a stalled runtime. Re-arm
         // rather than fail: the card has its own (much longer) timeout, and
         // failing the row here would settle it while the answer is still coming.
-        if (pendingHumanRequests > 0) {
+        // A remote_relay call waiting on another relay is the same kind of
+        // silence; the relay bounds that wait itself.
+        if (pendingHumanRequests > 0 || pendingRelayToolCalls > 0) {
           turn.armStall();
           return;
         }
@@ -3010,6 +3079,10 @@ export function createCopilotSdkSessionRunner({
     }
     turn.aborted = true;
     turn.abortedRowId = rowId;
+    // A pending `remote_relay` call ends now rather than when the runtime gets
+    // round to it: the relay drops the request, withdraws its approval card
+    // and stops waiting on the remote, and the watchdog hold is released.
+    turn.remoteRelayStop?.abort();
     // While `ensureSession` is still connecting there is no session to abort
     // and this would be a silent no-op; `runTurn` re-checks `turn.aborted`
     // once the session exists and settles there instead.
@@ -3937,6 +4010,7 @@ export function createCopilotSdkSessionRunner({
       continuationDueSince,
       compacting: isCompacting(),
       pendingHumanRequests,
+      pendingRelayToolCalls,
       sessionRpc: { ...sessionRpc },
       activeEntries: activeTurn
         ? activeTurn.entries.map((entry) => ({

package/server/copilot-worker/copilot-sdk-session-worker.mjs

@@ -20,6 +20,7 @@ import {
 import { createApiClient } from '../../shared/worker-runtime/api-client.mjs';
 import { createWorkerWebSocketLink } from '../../shared/worker-runtime/worker-websocket-link.mjs';
 import { createHeartbeatController } from '../../shared/worker-runtime/heartbeat.mjs';
+import { installWorkerLogFile } from '../../shared/worker-runtime/worker-log-file.mjs';
 import {
   createRunnerLinkBridge,
   failSettlingRowsOnShutdown,
@@ -33,6 +34,10 @@ import {
 } from '../../shared/worker-bootstrap.mjs';
 import { createCopilotSdkSessionRunner } from './copilot-sdk-session-process.mjs';
 
+// Windows console launch: the launcher names the worker log, this copies
+// stdout/stderr into it. A no-op wherever the launcher redirects instead.
+installWorkerLogFile();
+
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 const HEARTBEAT_MS = 10_000;
 

package/server/cursor-worker/cursor-remote-relay-tool.mjs

@@ -0,0 +1,65 @@
+/**
+ * The relay's `remote_relay` custom tool for the Cursor worker. SDK-free: the
+ * turn runner passes the returned `{ description, inputSchema, execute }` into
+ * `customTools.remote_relay`, and every call goes through the shared tool core
+ * to the local relay endpoint.
+ *
+ * A call can legitimately run for many minutes (a remote turn plus an approval
+ * card), during which the SDK emits nothing. `onCallStart`/`onCallEnd` bracket
+ * every execution — errors included — so the runner can count it as pending
+ * client work and hold its stall watchdog, exactly as it does for ask_user.
+ *
+ * The SDK hands `execute` no cancellation of its own (the context is only
+ * `{ toolCallId }`), so `getAbortSignal` supplies the running turn's: a Stop
+ * aborts it, which cancels the pending relay request and ends the hold.
+ */
+
+import {
+  REMOTE_RELAY_CALL_FAILED,
+  REMOTE_RELAY_TOOL_DESCRIPTION,
+  REMOTE_RELAY_TOOL_NAME,
+  cloneRemoteRelayToolInputSchema,
+  executeRemoteRelayTool,
+  formatRemoteRelayToolResult,
+} from '../../shared/remote-relay-tool-core.mjs';
+
+export function createRemoteRelayTool({
+  api,
+  getConversationId = () => '',
+  onCallStart = () => {},
+  onCallEnd = () => {},
+  getAbortSignal = () => null,
+  dbg = () => {},
+} = {}) {
+  async function execute(args) {
+    onCallStart();
+    try {
+      const result = await executeRemoteRelayTool(args, {
+        api,
+        conversationId: String(getConversationId() || ''),
+        signal: getAbortSignal?.() || null,
+      });
+      return {
+        structuredContent: result,
+        content: [{ type: 'text', text: formatRemoteRelayToolResult(result) }],
+      };
+    } catch (error) {
+      // A tool exception must never kill the run.
+      const message = error?.message || String(error);
+      dbg('remote_relay tool failed', message);
+      const result = { ok: false, code: REMOTE_RELAY_CALL_FAILED, error: message };
+      return {
+        structuredContent: result,
+        content: [{ type: 'text', text: formatRemoteRelayToolResult(result) }],
+      };
+    } finally {
+      onCallEnd();
+    }
+  }
+  return {
+    name: REMOTE_RELAY_TOOL_NAME,
+    description: REMOTE_RELAY_TOOL_DESCRIPTION,
+    inputSchema: cloneRemoteRelayToolInputSchema(),
+    execute,
+  };
+}

package/server/cursor-worker/cursor-session-worker.mjs

@@ -13,10 +13,15 @@ import {
 import { createApiClient } from '../../shared/worker-runtime/api-client.mjs';
 import { createWorkerWebSocketLink } from '../../shared/worker-runtime/worker-websocket-link.mjs';
 import { createHeartbeatController } from '../../shared/worker-runtime/heartbeat.mjs';
+import { installWorkerLogFile } from '../../shared/worker-runtime/worker-log-file.mjs';
 import { createControlPoller } from '../../shared/control-poller.mjs';
 import { installWorkerCrashGuard } from '../../shared/worker-crash-guard.mjs';
 import { createCursorTurnRunner } from './cursor-turn-runner.mjs';
 
+// Windows console launch: the launcher names the worker log, this copies
+// stdout/stderr into it. A no-op wherever the launcher redirects instead.
+installWorkerLogFile();
+
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 const HEARTBEAT_MS = 10_000;
 

package/server/cursor-worker/cursor-turn-runner.mjs

@@ -12,6 +12,8 @@ import {
 } from './cursor-sdk-adapter.mjs';
 import { createAskUserTool } from './cursor-ask-user-tool.mjs';
 import { createPreviewTool } from './cursor-preview-tool.mjs';
+import { createRemoteRelayTool } from './cursor-remote-relay-tool.mjs';
+import { createRemoteRelayToolGate } from '../../shared/remote-relay-tool-core.mjs';
 import {
   buildCursorSubagentAgents,
   cursorSubagentRosterFingerprint,
@@ -120,6 +122,9 @@ export function createCursorTurnRunner({
   resolveModelParamsImpl = resolveCursorReasoningParams,
   createNormalizerImpl = createSdkMessageNormalizer,
   buildUserMessageImpl = buildCursorUserMessage,
+  // Whether agent handles carry the relay's `remote_relay` tool
+  // (shared/remote-relay-tool-core.mjs). Default: ask the relay.
+  remoteRelayToolGate = null,
   dbg = () => {},
 } = {}) {
   // Unlike the Claude worker, the agent handle (and the custom tools bound
@@ -140,6 +145,9 @@ export function createCursorTurnRunner({
   // Open ask_user round-trips: the merged-stream stall watchdog defers while
   // a human is thinking about a question card.
   let pendingAskUserCalls = 0;
+  // Running remote_relay calls, same family: the relay may be waiting up to
+  // 600 s for a remote turn (plus an approval card) with no SDK traffic.
+  let pendingRemoteRelayCalls = 0;
   // Mirrors the Copilot extension's lastPromptedRelayMode: full mode
   // instructions ride on the first message of a mode and on mode changes only.
   let lastNudgedRelayMode = '';
@@ -188,6 +196,39 @@ export function createCursorTurnRunner({
       execute: previewTool.execute,
     },
   };
+  // `remote_relay` joins the set only while this relay has paired remotes.
+  // Asked once when the worker starts; the first handle waits for the answer
+  // (it is created asynchronously anyway), and every handle creation refreshes
+  // it so a later rebuild picks up a remote paired in the meantime.
+  const remoteRelayGate = remoteRelayToolGate || createRemoteRelayToolGate({ api });
+  void remoteRelayGate.refresh();
+  const remoteRelayTool = createRemoteRelayTool({
+    api,
+    getConversationId: () => activeMessage?.conversationId || sdkSessionId || '',
+    onCallStart: () => { pendingRemoteRelayCalls += 1; },
+    onCallEnd: () => { pendingRemoteRelayCalls -= 1; },
+    // The running turn's signal, read when the call starts: a Stop (or the
+    // auth retry burning a dead attempt) cancels the pending relay request.
+    // Between turns there is none — the last turn's may be aborted already.
+    getAbortSignal: () => (waitingForTurn ? currentAbortController?.signal || null : null),
+    dbg,
+  });
+
+  function customToolsForHandle() {
+    if (!remoteRelayGate.isEnabled()) return customTools;
+    return {
+      ...customTools,
+      [remoteRelayTool.name]: {
+        description: remoteRelayTool.description,
+        inputSchema: remoteRelayTool.inputSchema,
+        execute: remoteRelayTool.execute,
+      },
+    };
+  }
+
+  function hasPendingClientWork() {
+    return pendingAskUserCalls > 0 || pendingRemoteRelayCalls > 0;
+  }
 
   function getActiveQueueMessageId() {
     return waitingForTurn ? String(activeMessage?.id || '') : '';
@@ -262,7 +303,9 @@ export function createCursorTurnRunner({
     if (!agentHandle) {
       const durableId = String(message.cursorAgentId || '').trim() || cursorAgentId;
       const agents = buildCursorSubagentAgents(rosterModels);
-      const options = { apiKey, model, cwd, storeDir, sdkSessionId, customTools, agents, dbg };
+      await remoteRelayGate.ready();
+      const options = { apiKey, model, cwd, storeDir, sdkSessionId, customTools: customToolsForHandle(), agents, dbg };
+      void remoteRelayGate.refresh();
       try {
         agentHandle = await createAgentHandleImpl({ ...options, agentId: durableId });
       } catch (error) {
@@ -565,7 +608,7 @@ export function createCursorTurnRunner({
             // The SDK's documented recovery for a wedged persisted run —
             // armed by the second busy retry below.
             sendLocal: forceNextSend ? { force: true } : null,
-            hasPendingClientWork: () => pendingAskUserCalls > 0,
+            hasPendingClientWork,
             dbg,
           });
           forceNextSend = false;

package/server/cursor-worker/sdk-message-normalizer.mjs

@@ -1,6 +1,11 @@
 import { sanitizeSubagentRunId } from '../../shared/subagent-run-id.mjs';
 import { capThought } from '../../shared/thought-cap.mjs';
 import { shouldEmitStreamUpdate } from '../../shared/stream-emit-gating.mjs';
+import {
+  REMOTE_RELAY_TOOL_NAME,
+  isRemoteRelayToolName,
+  remoteRelayActivitySummary,
+} from '../../shared/remote-relay-tool-core.mjs';
 
 const MAX_TOOL_DETAIL_LENGTH = 140;
 const SUBAGENT_TOOL_NAMES = new Set(['task', 'agent']);
@@ -39,7 +44,27 @@ export function summarizeToolInput(toolName, input) {
   }
 }
 
+/**
+ * The relay's custom tools reach the stream as the SDK's generic MCP call
+ * (`name: 'mcp'`, args `{ providerIdentifier: 'custom-user-tools', toolName,
+ * args }`). `remote_relay` is shown as itself with the contract's one-line
+ * summary, so the transcript reads `Tool (remote_relay): send → …` like every
+ * other provider's; null for any other tool.
+ */
+function remoteRelayCallArgs(toolName, input) {
+  if (isRemoteRelayToolName(toolName)) return input || {};
+  if (String(toolName || '').trim().toLowerCase() !== 'mcp' || !input || typeof input !== 'object') return null;
+  return isRemoteRelayToolName(input.toolName) ? (input.args || {}) : null;
+}
+
 export function formatToolActivityText(toolName, input) {
+  const remoteArgs = remoteRelayCallArgs(toolName, input);
+  if (remoteArgs) {
+    const remoteSummary = remoteRelayActivitySummary(remoteArgs);
+    return truncate(remoteSummary
+      ? `Tool (${REMOTE_RELAY_TOOL_NAME}): ${remoteSummary}`
+      : `Tool (${REMOTE_RELAY_TOOL_NAME})`);
+  }
   const summary = summarizeToolInput(toolName, input);
   return truncate(summary ? `Tool (${toolName}): ${summary}` : `Tool (${toolName})`);
 }

package/server/db-schema.mjs

@@ -10,6 +10,7 @@
 import { rebuildRecentWorkspaceRootsTable } from './migrations/0002-recent-workspace-roots-path-key.mjs';
 import { ensurePushSubscriptionsTable } from './migrations/0003-push-subscriptions.mjs';
 import { migrateSteerSettleMarkers } from './migrations/0004-steer-settle-markers.mjs';
+import { migrateRemoteRelays } from './migrations/0005-remote-relays.mjs';
 import { migrateImageConversationSchema } from './repositories/image-conversation-repository.mjs';
 
 // Mirrors DEFAULT_RELAY_MODE in server-runtime.mjs; used only by the one-time
@@ -702,6 +703,13 @@ try {
 } catch (error) {
   console.warn(`[steering] migration 0004 failed; retrying on next boot: ${error?.message || error}`);
 }
+// Remote relays: additive columns and the unlock table. Readers tolerate their
+// absence, so a failure is logged and retried next boot like 0004.
+try {
+  migrateRemoteRelays(db);
+} catch (error) {
+  console.warn(`[remote-relays] migration 0005 failed; retrying on next boot: ${error?.message || error}`);
+}
 
 const runtimeSessionColumns = db.prepare(`PRAGMA table_info(runtime_sessions)`).all().map((c) => c.name);
 if (runtimeSessionColumns.length) {