@oar-sh/oar 0.9.4 → 0.9.6

package/server/services/remote-relay-dispatcher.mjs

@@ -2,12 +2,15 @@
 
 import { randomUUID as nodeRandomUUID } from 'crypto';
 
+import { isFailureNoteText } from '../../shared/failure-note-text.mjs';
 import {
   REMOTE_RELAY_APPROVAL_MODES,
+  REMOTE_RELAY_EFFORT_PATTERN,
   REMOTE_RELAY_ERROR_CODES,
   REMOTE_RELAY_LIMITS,
   REMOTE_RELAY_PROVIDERS,
   isRemoteRelayApprovalQuestion,
+  isRemoteRelayPromptAction,
   isRemoteRelayWriteAction,
   normalizeRemoteRelayOrigin,
   remoteConversationUrl,
@@ -19,6 +22,7 @@ import {
   withRemotePromptHeader,
 } from '../../shared/remote-relay-contract.mjs';
 import { schemaFields } from '../../shared/question-schema.mjs';
+import { ANSWERED_ELSEWHERE_KIND } from '../../shared/steer-settle-markers.mjs';
 
 // The one place a `remote_relay` tool call is decided and carried out (plan
 // §5.6). Every provider adapter ends up at POST /api/remote-relays/tool, whose
@@ -88,13 +92,24 @@ const WORKING_WORKER_STATUSES = new Set(['starting', 'processing']);
 // marker counts only there: a normal reply that quotes a relay error further
 // down is a reply, not a failure.
 const FAILURE_TEXT_PATTERNS = Object.freeze([
-  /^(?:(?!\n[ \t]*\r?\n)[\s\S]){0,600}?\berror code:\s*relay\.[a-z0-9-]+\.(?=\s|$)/i,
   /^relay recovery limit reached after \d+ attempts/i,
   /^relay timeout after \d+ attempts/i,
 ]);
 const CLAUDE_LONG_CONTEXT_SUFFIX = /\[1m\]$/i;
-// Assistant rows that are markers, not replies of their own.
-const STUB_KINDS = new Set(['folded', 'stopped']);
+// POST /api/conversation/bootstrap refuses an effort its model does not take
+// with this code (400); POST /api/message sends the same 400 without a code,
+// but with the list below.
+const EFFORT_UNSUPPORTED_CODE = 'REASONING_EFFORT_UNSUPPORTED';
+const EFFORT_SUPPORTED_FIELD = 'supportedReasoningEfforts';
+const EFFORT_SOURCES = Object.freeze({
+  requested: 'requested',
+  caller: 'same as this session',
+  remote: 'remote default',
+});
+// relay_info: efforts per provider, as groups of models that take the same ones.
+const EFFORT_LEVELS_MAX = 12;
+const EFFORT_GROUPS_MAX = 8;
+const EFFORT_GROUP_MODELS_MAX = 40;
 
 function toText(value) {
   return String(value ?? '').trim();
@@ -170,7 +185,7 @@ function compactQuery(query = {}) {
 
 function looksLikeFailureText(text) {
   const value = toText(text);
-  return FAILURE_TEXT_PATTERNS.some((pattern) => pattern.test(value));
+  return isFailureNoteText(value) || FAILURE_TEXT_PATTERNS.some((pattern) => pattern.test(value));
 }
 
 function normalizeProvider(value) {
@@ -214,6 +229,73 @@ function matchOfferedModel(candidate, offered = []) {
   return offered.find((model) => model.toLowerCase().replace(CLAUDE_LONG_CONTEXT_SUFFIX, '') === wantedBase) || '';
 }
 
+/** A reasoning effort as the relays write it, or '' when the value is not one. */
+function normalizeEffort(value) {
+  const effort = toText(value).toLowerCase();
+  return REMOTE_RELAY_EFFORT_PATTERN.test(effort) ? effort : '';
+}
+
+function effortLevels(values) {
+  return uniqueTexts((Array.isArray(values) ? values : []).map(normalizeEffort)).slice(0, EFFORT_LEVELS_MAX);
+}
+
+/**
+ * The efforts /api/models lists for a provider's model, or null when the
+ * remote does not say. `reasoningByProvider` is the provider's own view;
+ * `reasoningByModel` is keyed by model id alone, which providers share, so it
+ * only decides where the provider has no entry of its own.
+ */
+function catalogEffortsFor(models, provider, model) {
+  const key = toText(model).toLowerCase();
+  if (!key || !isPlainObject(models)) return null;
+  const keys = uniqueTexts([key, key.replace(CLAUDE_LONG_CONTEXT_SUFFIX, '')]);
+  const maps = [
+    isPlainObject(models.reasoningByProvider) ? models.reasoningByProvider[provider] : null,
+    models.reasoningByModel,
+  ];
+  for (const map of maps) {
+    if (!isPlainObject(map)) continue;
+    for (const candidate of keys) {
+      const levels = effortLevels(map[candidate]);
+      if (levels.length) return levels;
+    }
+  }
+  return null;
+}
+
+/** `[{ efforts, models }]`: the models of a provider grouped by the efforts they take. */
+function groupEffortsByModel(models, provider, offered = []) {
+  const groups = new Map();
+  for (const model of offered) {
+    const levels = catalogEffortsFor(models, provider, model);
+    if (!levels) continue;
+    const id = levels.join(' ');
+    if (!groups.has(id)) groups.set(id, { efforts: levels, models: [] });
+    groups.get(id).models.push(model);
+  }
+  return [...groups.values()]
+    .sort((a, b) => b.models.length - a.models.length)
+    .slice(0, EFFORT_GROUPS_MAX)
+    .map((group) => (group.models.length > EFFORT_GROUP_MODELS_MAX
+      ? { efforts: group.efforts, models: group.models.slice(0, EFFORT_GROUP_MODELS_MAX), more: group.models.length - EFFORT_GROUP_MODELS_MAX }
+      : group));
+}
+
+/** True when the remote answered 400 because its model does not take the effort we sent. */
+function isEffortRejection(error) {
+  const body = isPlainObject(error?.remoteBody) ? error.remoteBody : null;
+  if (!body || Number(error?.status) !== 400) return false;
+  return toText(body.code) === EFFORT_UNSUPPORTED_CODE || Array.isArray(body[EFFORT_SUPPORTED_FIELD]);
+}
+
+function supportedEffortsOf(error) {
+  return effortLevels(error?.remoteBody?.[EFFORT_SUPPORTED_FIELD]);
+}
+
+function supportedEffortsText(levels) {
+  return levels.length ? ` (it takes: ${levels.join(', ')})` : '';
+}
+
 function isRemoteRelayError(error) {
   return error?.name === 'RemoteRelayError' || /^REMOTE_/.test(toText(error?.code));
 }
@@ -333,7 +415,7 @@ const FINISHED_TASK_STATUSES = new Set(['completed', 'complete', 'done', 'failed
  * read they came with. A later user message ends the follow-up: from there
  * the session is working for someone else.
  */
-export function remoteFollowUpState(rows, replyMessageId, page, { sawBackgroundWork = false } = {}) {
+export function remoteFollowUpState(rows, replyMessageId, page, { sawBackgroundWork = false, sentMessageId = '' } = {}) {
   const list = Array.isArray(rows) ? rows : [];
   const start = list.findIndex((row) => toText(row?.id) === replyMessageId);
   const afterReply = start === -1 ? [] : list.slice(start + 1);
@@ -346,7 +428,13 @@ export function remoteFollowUpState(rows, replyMessageId, page, { sawBackgroundW
   // A queued follow-up turn shows only as activeTurn (between a task's end and
   // the follow-up turn starting); on its own, activeTurn is too weak a sign, so
   // it counts once background work or a follow-up was seen for this message.
-  const backgroundSeen = sawBackgroundWork || tasks.length > 0 || followUps.length > 0;
+  // A turn in flight that belongs to no user message (not the sent one, and no
+  // later one exists) is a turn the agent opened itself: a follow-up that is
+  // running right now, whether or not a background task was ever published
+  // (subagents the agent waits for are not).
+  const turnInFlight = isPlainObject(page?.inFlight) ? toText(page.inFlight.messageId) : '';
+  const ownTurnInFlight = !!turnInFlight && !handedOver && !!sentMessageId && turnInFlight !== sentMessageId;
+  const backgroundSeen = sawBackgroundWork || tasks.length > 0 || followUps.length > 0 || ownTurnInFlight;
   const working = !handedOver && (
     tasks.length > 0
     || (isPlainObject(page?.inFlight) && backgroundSeen)
@@ -395,6 +483,25 @@ export function settleRemoteReply(messages, messageId) {
     if (looksLikeFailureText(answer.text)) return { status: 'failed', reply: replyOf(answer, { folded: true }), note };
     return { status: 'done', reply: replyOf(answer, { folded: true }), note };
   }
+  if (kind === ANSWERED_ELSEWHERE_KIND) {
+    // The marker only points at the answer, which the remote published as a
+    // background turn BEFORE it closed the message: the nearest continuation
+    // reply above the marker. The marker's own text is never the reply — it
+    // tells a human to resend, and a calling agent would run the prompt twice.
+    const answer = rows.slice(0, rows.indexOf(own)).reverse().find((row) => row?.role === 'assistant'
+      && toText(row.kind).toLowerCase() === 'continuation');
+    if (!answer) {
+      return {
+        status: 'done',
+        note: 'The remote agent answered this message in a background turn, but that reply was not found after the message; use read_session to see it. Do not send the message again.',
+      };
+    }
+    const note = 'The remote relay published the answer to this message as a background turn; this is that turn\'s reply.';
+    if (looksLikeFailureText(answer.text)) {
+      return { status: 'failed', reply: replyOf(answer, { answeredElsewhere: true }), note };
+    }
+    return { status: 'done', reply: replyOf(answer, { answeredElsewhere: true }), note };
+  }
   if (looksLikeFailureText(own.text)) {
     return { status: 'failed', reply: replyOf(own), note: 'The remote turn failed; the reply is the relay\'s failure text.' };
   }
@@ -428,6 +535,10 @@ export function createRemoteRelayDispatcher({
   const inflightByConversation = new Map();
   const callTimesByConversation = new Map();
   const writeTimesByConversation = new Map();
+  // The loop guard: prompts sent to other relays' agents per conversation,
+  // counted from the user's latest own message. Kept in memory: a restart
+  // ends a loop of agents by itself.
+  const agentPromptsByConversation = new Map();
 
   // ─── Bookkeeping ───────────────────────────────────────────────────────────
 
@@ -450,6 +561,31 @@ export function createRemoteRelayDispatcher({
     }
   }
 
+  /**
+   * Why a relay is open to a conversation: 'user' (the user mentioned it),
+   * 'contact' (an agent on that relay wrote to the conversation, so it may be
+   * answered), or null (locked).
+   */
+  function relayAccess(conversationId, relay) {
+    if (isUnlocked(conversationId, relay?.id)) return 'user';
+    try {
+      if (toText(relay?.relayId) && repository?.hasContactFrom?.(conversationId, relay.relayId)) return 'contact';
+    } catch {}
+    return null;
+  }
+
+  function agentPrompts(conversationId) {
+    let since = null;
+    try {
+      since = repository?.latestHumanMessageId?.(conversationId) || null;
+    } catch {}
+    const kept = agentPromptsByConversation.get(conversationId);
+    if (kept && kept.since === since) return kept;
+    const fresh = { since, count: 0 };
+    agentPromptsByConversation.set(conversationId, fresh);
+    return fresh;
+  }
+
   function adjustInflight(conversationId, delta) {
     const next = inflight(conversationId) + delta;
     if (next > 0) inflightByConversation.set(conversationId, next);
@@ -638,7 +774,7 @@ export function createRemoteRelayDispatcher({
       const settled = settleRemoteReply(after.rows, messageId);
       if (settled && !settled.foldedWithoutReply) {
         if (settled.status !== 'done' || !settled.reply?.messageId) return { ...base, ...settled };
-        const follow = remoteFollowUpState(after.rows, settled.reply.messageId, page, { sawBackgroundWork: seen.background === true });
+        const follow = remoteFollowUpState(after.rows, settled.reply.messageId, page, { sawBackgroundWork: seen.background === true, sentMessageId: messageId });
         if (follow.backgroundSeen) seen.background = true;
         const latestReply = follow.latest ? replyOf(follow.latest, { followUp: true }) : settled.reply;
         if (!follow.working) {
@@ -766,8 +902,18 @@ export function createRemoteRelayDispatcher({
     };
   }
 
-  /** `[{ provider, configured, defaultModel, models }]` in contract order. */
+  /**
+   * `[{ provider, configured, defaultModel, models }]` in contract order, with
+   * `efforts` where the remote lists the reasoning efforts of those models.
+   */
   function buildProviders(catalog) {
+    return listProviders(catalog).map((entry) => {
+      const efforts = groupEffortsByModel(catalog.models, entry.provider, entry.models);
+      return efforts.length ? { ...entry, efforts } : entry;
+    });
+  }
+
+  function listProviders(catalog) {
     const models = catalog.models || {};
     const providersByModel = isPlainObject(models.providersByModel) ? models.providersByModel : {};
     const catalogModels = Array.isArray(models.models) ? models.models.map(toText).filter(Boolean) : [];
@@ -1055,7 +1201,7 @@ export function createRemoteRelayDispatcher({
    * When the replay fails too, nobody knows; the error carries the session
    * and message id so the agent checks with wait instead of sending again.
    */
-  async function postPrompt(ctx, { session, text, origin, model, mode }) {
+  async function postPrompt(ctx, { session, text, origin, model, mode, effort }) {
     const messageId = String(randomUUID());
     const body = {
       conversationId: session,
@@ -1064,6 +1210,7 @@ export function createRemoteRelayDispatcher({
       origin,
       ...(model ? { model } : {}),
       ...(mode ? { relayMode: mode } : {}),
+      ...(effort ? { reasoningEffort: effort } : {}),
     };
     let sent;
     try {
@@ -1090,11 +1237,72 @@ export function createRemoteRelayDispatcher({
         messageId: toText(sent.duplicateOfMessageId) || null,
       };
     }
-    return { duplicate: false, messageId: toText(sent?.messageId) || messageId };
+    return {
+      duplicate: false,
+      messageId: toText(sent?.messageId) || messageId,
+      effort: normalizeEffort(sent?.selectedReasoningEffort),
+    };
   }
 
-  async function deliverAndWait(action, ctx, { session, sent, waitSeconds, extra = {} }) {
+  /**
+   * What the remote made of the effort: `reported` is the one it bound (the
+   * bootstrap's preferredReasoningEffort, the message's
+   * selectedReasoningEffort). Most providers do not refuse an effort their
+   * model lacks, they fall back to their default, so the result names the
+   * effort the turn runs with and says when that is not the one asked for.
+   */
+  function settleEffort(ctx, choice, reported) {
+    const bound = normalizeEffort(reported);
+    if (!bound || bound === choice.effort) return choice;
+    if (!choice.effort) return { ...choice, effort: bound, source: EFFORT_SOURCES.remote };
+    return {
+      effort: bound,
+      source: EFFORT_SOURCES.remote,
+      note: choice.note
+        || `Relay "${ctx.relay.name}" does not offer effort "${choice.effort}" for this model; the turn runs with "${bound}".`,
+    };
+  }
+
+  /**
+   * Queues the prompt with the chosen effort. An effort the agent did not ask
+   * for (this session's, the remote session's own) that the remote refuses is
+   * dropped and the prompt sent once more without it; one the agent asked for
+   * is the remote's to refuse, so that error goes back as it is.
+   */
+  async function postPromptWithEffort(ctx, prompt, choice) {
+    try {
+      const sent = await postPrompt(ctx, { ...prompt, effort: choice.effort });
+      return { sent, choice: settleEffort(ctx, choice, sent.effort) };
+    } catch (error) {
+      if (!choice.effort || choice.source === EFFORT_SOURCES.requested || !isEffortRejection(error)) throw error;
+      const dropped = {
+        effort: '',
+        source: EFFORT_SOURCES.remote,
+        note: `Relay "${ctx.relay.name}" refused effort "${choice.effort}"${supportedEffortsText(supportedEffortsOf(error))}; sent again without it, so the turn runs with the remote's default.`,
+      };
+      const sent = await postPrompt(ctx, { ...prompt, effort: '' });
+      return { sent, choice: settleEffort(ctx, dropped, sent.effort) };
+    }
+  }
+
+  /** The `effort` / `effortSource` fields of a result, and the note that goes with them. */
+  function effortResult(choice) {
+    return {
+      ...(choice.source ? { effort: choice.effort || null, effortSource: choice.source } : {}),
+      ...(choice.note ? { note: choice.note } : {}),
+    };
+  }
+
+  async function deliverAndWait(action, ctx, { session, sent, waitSeconds, extra: given = {} }) {
     const openUrl = remoteConversationUrl(ctx.relay.url, session);
+    // `extra.note` (how the effort was settled) goes in front of the outcome's own.
+    const { note: extraNote, ...extra } = given;
+    const result = await deliverOutcome(action, ctx, { session, sent, waitSeconds, extra, openUrl });
+    const note = [extraNote, result.note].map(toText).filter(Boolean).join(' ');
+    return note ? { ...result, note } : result;
+  }
+
+  async function deliverOutcome(action, ctx, { session, sent, waitSeconds, extra, openUrl }) {
     if (sent.duplicate) {
       const outcome = {
         status: 'duplicate',
@@ -1128,9 +1336,18 @@ export function createRemoteRelayDispatcher({
     const model = args.model
       || (provider === 'grok' ? '' : (toText(conversation?.preferredModel) || toText(runtime.providerModel) || toText(runtime.model)));
     const mode = args.mode || ctx.caller.mode || toText(conversation?.preferredRelayMode) || '';
+    // The remote runs a prompt that names no effort with its provider's
+    // default, not with the one the session is set to: pass that one on, so
+    // the session keeps its own. This session's effort is never mirrored here.
+    const requested = normalizeEffort(args.effort);
+    const own = requested ? '' : normalizeEffort(conversation?.preferredReasoningEffort);
     const origin = await buildOrigin(ctx);
-    const sent = await postPrompt(ctx, { session, text: args.text, origin, model, mode });
-    return deliverAndWait('send', ctx, { session, sent, waitSeconds: args.wait_seconds });
+    const { sent, choice } = await postPromptWithEffort(ctx, { session, text: args.text, origin, model, mode }, {
+      effort: requested || own,
+      source: requested ? EFFORT_SOURCES.requested : (own ? EFFORT_SOURCES.remote : ''),
+      note: null,
+    });
+    return deliverAndWait('send', ctx, { session, sent, waitSeconds: args.wait_seconds, extra: effortResult(choice) });
   }
 
   async function createSession(ctx, args) {
@@ -1163,23 +1380,75 @@ export function createRemoteRelayDispatcher({
     const title = args.title || firstLine(args.text, TITLE_MAX) || 'Remote session';
     const origin = await buildOrigin(ctx);
 
-    const bootstrap = await call(ctx, 'POST', '/api/conversation/bootstrap', {
+    // The effort mirrors the caller like the model does: this session's when
+    // the remote lists it for the model (or lists nothing), else the remote's.
+    let choice = { effort: normalizeEffort(args.effort), source: EFFORT_SOURCES.requested, note: null };
+    if (!choice.effort) {
+      const callerEffort = normalizeEffort(ctx.caller.effort);
+      const offered = catalogEffortsFor(catalog.models, provider, model);
+      if (callerEffort && (!offered || offered.includes(callerEffort))) {
+        choice = { effort: callerEffort, source: EFFORT_SOURCES.caller, note: null };
+      } else {
+        choice = {
+          effort: '',
+          source: EFFORT_SOURCES.remote,
+          note: callerEffort
+            ? `${model || provider} on relay "${ctx.relay.name}" does not offer this session's effort "${callerEffort}"${supportedEffortsText(offered || [])}; the session uses the remote's default.`
+            : null,
+        };
+      }
+    }
+
+    const bootstrapWith = (effort) => call(ctx, 'POST', '/api/conversation/bootstrap', {
       body: {
         providerType: provider,
         ...(model ? { model } : {}),
         ...(mode ? { relayMode: mode } : {}),
+        ...(effort ? { reasoningEffort: effort } : {}),
         title,
         ...(args.cwd ? { cwd: args.cwd } : {}),
         origin,
       },
     });
+    let bootstrap;
+    try {
+      bootstrap = await bootstrapWith(choice.effort);
+    } catch (error) {
+      // Only an effort the agent did not ask for is dropped; a refused
+      // bootstrap created nothing, so asking again is safe.
+      if (!choice.effort || choice.source === EFFORT_SOURCES.requested || !isEffortRejection(error)) throw error;
+      choice = {
+        effort: '',
+        source: EFFORT_SOURCES.remote,
+        note: `Relay "${ctx.relay.name}" refused this session's effort "${choice.effort}"${supportedEffortsText(supportedEffortsOf(error))}; the session was started without it and uses the remote's default.`,
+      };
+      bootstrap = await bootstrapWith('');
+    }
+    choice = settleEffort(ctx, choice, bootstrap?.preferredReasoningEffort);
     const session = toText(bootstrap?.conversationId);
     if (!session) {
       throw new DispatchFailure(502, `${REMOTE_RELAY_ERROR_CODES.httpPrefix}502`,
         `Relay "${ctx.relay.name}" did not return the new session's id.`);
     }
     const boundModel = toText(bootstrap?.selectedModel) || model;
-    const sent = await postPrompt(ctx, { session, text: args.text, origin, model: boundModel, mode });
+    let sent;
+    try {
+      ({ sent, choice } = await postPromptWithEffort(ctx, { session, text: args.text, origin, model: boundModel, mode }, choice));
+    } catch (error) {
+      if (!choice.effort || !isEffortRejection(error)) throw error;
+      // The session exists by now: say so, or the agent starts a second one.
+      const supported = supportedEffortsOf(error);
+      const remoteCode = toText(error.remoteBody?.code);
+      throw new DispatchFailure(400, toText(error.code) || `${REMOTE_RELAY_ERROR_CODES.httpPrefix}400`,
+        `${toText(error.message) || `Relay "${ctx.relay.name}" refused effort "${choice.effort}"`}. The session was created, but the prompt was not queued.`,
+        {
+          session,
+          ...(remoteCode ? { remoteCode } : {}),
+          ...(supported.length ? { supportedEfforts: supported } : {}),
+          openUrl: remoteConversationUrl(ctx.relay.url, session),
+          note: 'Use send with this session and an effort it takes (or none); do not create another session.',
+        });
+    }
     return deliverAndWait('create_session', ctx, {
       session,
       sent,
@@ -1192,6 +1461,7 @@ export function createRemoteRelayDispatcher({
         title,
         ...(toText(bootstrap?.workspaceRootWarning) ? { cwdWarning: toText(bootstrap.workspaceRootWarning) } : {}),
         ...(note ? { modelNote: note } : {}),
+        ...effortResult(choice),
       },
     });
   }
@@ -1332,10 +1602,13 @@ export function createRemoteRelayDispatcher({
     }
     const remoteCode = toText(remoteBody?.code) || null;
     const supportedModels = Array.isArray(remoteBody?.supportedModels) ? remoteBody.supportedModels.slice(0, 50) : null;
+    // A refused effort: the ones the remote's model takes, so the agent can pick one.
+    const supportedEfforts = isEffortRejection(error) ? supportedEffortsOf(error) : [];
     const details = {
       ...extra,
       ...(remoteCode ? { remoteCode } : {}),
       ...(supportedModels ? { supportedModels } : {}),
+      ...(supportedEfforts.length ? { supportedEfforts } : {}),
     };
     if (code.startsWith(C.httpPrefix) && status >= 400 && status < 500) return failure(status, code, message, details);
     return failure(502, code || `${C.httpPrefix}502`, message, details);
@@ -1351,7 +1624,7 @@ export function createRemoteRelayDispatcher({
       online: toText(relay.lastStatus).toLowerCase() === 'online',
       version: relay.version || null,
       permission: relay.permission,
-      unlocked: isUnlocked(conversationId, relay.id),
+      unlocked: relayAccess(conversationId, relay) !== null,
     }));
     const unlocked = listed.filter((relay) => relay.unlocked).length;
     return {
@@ -1361,7 +1634,7 @@ export function createRemoteRelayDispatcher({
         summary: `list_relays: ${listed.length} relay${listed.length === 1 ? '' : 's'}, ${unlocked} unlocked`,
         self: { name: (await registry.selfName?.()) || null },
         relays: listed,
-        hint: 'Mention @name in the chat to unlock a relay.',
+        hint: 'The user unlocks a relay by mentioning @name in the chat; a relay whose agent wrote to this conversation is open as well.',
       },
     };
   }
@@ -1392,7 +1665,8 @@ export function createRemoteRelayDispatcher({
       return result;
     };
 
-    if (!isUnlocked(conversationId, relay.id)) {
+    const access = relayAccess(conversationId, relay);
+    if (!access) {
       return finish(failure(403, REMOTE_RELAY_ERROR_CODES.locked,
         `Relay "${relay.name}" is locked in this conversation. Ask the user to mention @${relay.name} (or its name) in a message to allow work there.`,
         { relay: relay.name }));
@@ -1406,9 +1680,16 @@ export function createRemoteRelayDispatcher({
     const caller = { conversationId, ...((await getCallerContext(conversationId, req)) || {}) };
     caller.mode = toText(caller.mode).toLowerCase();
     const hops = nonNegativeInt(caller.hops) + 1;
-    if (hops > REMOTE_RELAY_LIMITS.hopLimit) {
+    // The hop limit stops a prompt from travelling on to a third relay. A
+    // relay the user unlocked here stays in reach whatever prompts arrive,
+    // the relay the prompts came from may always be answered, and reading
+    // carries nothing on.
+    const origins = Array.isArray(caller.originRelayIds) ? caller.originRelayIds.map(toText) : [];
+    const answering = !!toText(relay.relayId) && origins.length > 0
+      && origins.every((id) => id === toText(relay.relayId));
+    if (write && access !== 'user' && !answering && hops > REMOTE_RELAY_LIMITS.hopLimit) {
       return finish(failure(403, REMOTE_RELAY_ERROR_CODES.hopLimit,
-        `This turn was started by another relay's agent (hop ${hops - 1}); forwarding it again would pass the limit of ${REMOTE_RELAY_LIMITS.hopLimit} hops.`,
+        `This turn acts on a prompt from another relay's agent (hop ${hops - 1}); passing it on to relay "${relay.name}" would pass the limit of ${REMOTE_RELAY_LIMITS.hopLimit} hops. The user can allow it by mentioning @${relay.name} in this conversation.`,
         { relay: relay.name }));
     }
 
@@ -1421,7 +1702,32 @@ export function createRemoteRelayDispatcher({
 
     adjustInflight(conversationId, 1);
     try {
-      if (write && REMOTE_RELAY_APPROVAL_MODES.includes(caller.mode)) {
+      const prompting = isRemoteRelayPromptAction(action);
+      let asked = false;
+      if (prompting && agentPrompts(conversationId).count >= REMOTE_RELAY_LIMITS.agentPromptsBeforeAsking) {
+        // Agents that prompt each other can go on without the user for good:
+        // from time to time the user is asked, in any relay mode.
+        const decision = await requestApproval({
+          conversationId,
+          callerContext: caller,
+          relay: relayTarget(relay),
+          action,
+          args,
+          summary: summarizeRemoteRelayCall({ action, ...args, relay: relay.name }),
+          signal,
+          agentPrompts: agentPrompts(conversationId).count,
+        });
+        const approved = decision === true || decision?.approved === true;
+        if (!approved) {
+          const code = toText(decision?.code) || REMOTE_RELAY_ERROR_CODES.approvalDenied;
+          const error = toText(decision?.error)
+            || `The agent has sent ${agentPrompts(conversationId).count} prompts to other relays' agents since the user last wrote, and the user did not allow more for now.`;
+          return finish(failure(403, code, error, { relay: relay.name }));
+        }
+        agentPrompts(conversationId).count = 0;
+        asked = true;
+      }
+      if (!asked && write && REMOTE_RELAY_APPROVAL_MODES.includes(caller.mode)) {
         const decision = await requestApproval({
           conversationId,
           callerContext: caller,
@@ -1442,6 +1748,7 @@ export function createRemoteRelayDispatcher({
 
       const ctx = { relay, caller, hops, conversationId, signal };
       const body = await ACTIONS[action](ctx, args);
+      if (prompting) agentPrompts(conversationId).count += 1;
       const { summary, ...rest } = body;
       return finish({
         status: 200,

package/server/services/remote-relay-inbound.mjs

@@ -161,6 +161,41 @@ export function formatRemoteRelayMentionHint(relays = []) {
   return `<system_reminder>The user mentioned ${subject}. The ${REMOTE_RELAY_TOOL_NAME} tool can list, read, prompt and create sessions there.</system_reminder>`;
 }
 
+/**
+ * The paired relay a remote prompt came from: `{ relayId, name }` (`relayId`
+ * is the local registry id), or null when the sender is not paired here or
+ * names no relay id.
+ */
+export function findOriginRemoteRelay(inbound, origin) {
+  const instance = String(origin?.relayId || '').trim();
+  if (!inbound || typeof inbound.listRelays !== 'function' || !instance) return null;
+  try {
+    const listed = inbound.listRelays();
+    const relay = (Array.isArray(listed) ? listed : [])
+      .find((entry) => String(entry?.relayId || '').trim() === instance);
+    return relay ? { relayId: String(relay.id || ''), name: String(relay.name || relay.id || '') } : null;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * The reminder the agent gets with a prompt another relay's agent sent: that
+ * relay is open to this conversation, and where the sender's session is. ''
+ * when the sender is not a paired relay. Like the mention hint, it rides in
+ * the queued prompt only.
+ */
+export function formatRemoteRelayOriginHint(relay, origin) {
+  const name = hintText(relay?.name);
+  if (!name) return '';
+  const session = hintText(origin?.conversationId, 80);
+  const where = session ? `relay "${name}", session "${session}"` : `relay "${name}"`;
+  return `<system_reminder>This prompt came from an agent on the paired OAR relay "${name}". `
+    + 'Your reply to it is handed back to that agent by itself. '
+    + `For more than the reply (reading its session, a question, a later report) the ${REMOTE_RELAY_TOOL_NAME} tool is open for that relay in this conversation: ${where}. `
+    + 'A prompt you send there while its turn is still running is steered into that turn.</system_reminder>';
+}
+
 /** The queued prompt with the mention hint after the user's text. */
 export function withRemoteRelayMentionHint(promptText, hint) {
   const text = String(promptText ?? '');

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

@@ -13,6 +13,7 @@ import {
   buildOarMcpServerLaunch,
   isOarMcpServerDisabled,
 } from '../mcp/oar-mcp-server.mjs';
+import { WORKER_LOG_FILE_ENV } from '../../shared/worker-runtime/worker-log-file.mjs';
 
 export { isOarMcpServerDisabled };
 
@@ -507,7 +508,8 @@ export function createWorkerSecretEnvFile(env = {}, {
  * their output discarded (`stdio: 'ignore'` / bare tmux exec), so a crash
  * left zero forensic trail — the failure mode that made the 2026-08-11
  * incident undiagnosable. Best-effort by design: a log problem must never
- * block a worker spawn. Naive rotation: >10 MB rolls to `<file>.1`.
+ * block a worker spawn. Naive rotation: >10 MB rolls to `<file>.1`, checked
+ * at each launch on every platform.
  */
 function resolveWorkerLogDir(launchEnv = {}, { pathImpl = path } = {}) {
   const explicitDir = normalizeText(launchEnv?.COPILOT_WEB_RELAY_LOG_DIR);
@@ -683,6 +685,9 @@ export async function launchSessionCli({
   // Extension engine: writes the session's OAR MCP config, returns its path
   // (or null to launch without it).
   prepareOarMcpConfigImpl = prepareOarMcpConfigFile,
+  // Windows console launch: resolves (and rotates) the worker log the worker
+  // then writes itself; returns its path or null.
+  prepareWorkerLogFileImpl = prepareWorkerLogFile,
 } = {}) {
   const target = String(targetSessionId || '').trim();
   if (!target) throw new Error('missing-target-session-id');
@@ -719,6 +724,9 @@ export async function launchSessionCli({
     ...launchEnv,
     SESSION_ID: target,
   };
+  // Set per launch below, never inherited: a relay started from inside a
+  // worker session would otherwise hand its workers that session's log.
+  delete launchSessionEnv[WORKER_LOG_FILE_ENV];
   // The extension engine gets the OAR MCP server (remote_relay + preview) the
   // node workers carry in-process; every launch path appends the same args.
   const extensionCliArgs = resolveNodeWorkerDescriptor(launchSessionEnv)
@@ -842,8 +850,15 @@ export async function launchSessionCli({
       : ['--allow-all', '--session-id', target, ...extensionCliArgs]);
   // POSIX node workers tee stdout/stderr into the worker log (a crash must
   // leave a trail). On win32 the `start` intermediary opens its own console,
-  // so fd inheritance cannot reach the worker — its window shows the output.
+  // so fd inheritance cannot reach the worker, and a shell redirect would
+  // leave its window empty: the worker is told the file and copies its own
+  // output into it (shared/worker-runtime/worker-log-file.mjs). Only the path
+  // travels; nothing of the environment or command line is written to the log.
   let detachedStdio = 'ignore';
+  if (platform === 'win32' && nodeWorker) {
+    const workerLogPath = prepareWorkerLogFileImpl(target, launchSessionEnv);
+    if (workerLogPath) launchSessionEnv[WORKER_LOG_FILE_ENV] = workerLogPath;
+  }
   if (platform !== 'win32' && nodeWorker) {
     const workerLogPath = prepareWorkerLogFile(target, launchSessionEnv);
     if (workerLogPath) {