@oar-sh/oar 0.9.4 → 0.9.5

package/server/public/app/steered-turn-merge.mjs

@@ -10,6 +10,10 @@
 // - stopped: the steer was pushed into a turn the user then stopped, so it
 //   went unanswered (kind='stopped', a marker with Resend).
 // The steered user message of a fold or stop is still classed as steered.
+// A fourth marker is not a steer's: kind='answered-elsewhere' closes a message
+// whose answer was published on a background-continuation row. It gets the
+// markers' muted look and nothing else — its message was not steered, and the
+// reply next to it is an ordinary one.
 //
 // One idempotent DOM pass, same contract as syncTranscriptSeparators: every
 // insertion path (full render, live append, prepended history page) re-runs it,
@@ -23,11 +27,16 @@ export const STEERED_MSG_CLASS = 'msg-steered';
 export const STEERED_CONTINUATION_CLASS = 'msg-steered-continuation';
 export const FOLDED_MSG_CLASS = 'msg-folded';
 export const STEER_STOPPED_MSG_CLASS = 'msg-steer-stopped';
+export const ANSWERED_ELSEWHERE_MSG_CLASS = 'msg-answered-elsewhere';
 
-/** The assistant row kinds that are settle markers of a steer, not replies. */
+/**
+ * The assistant row kinds that are settle markers, not replies. The first two
+ * are a steer's (see isSteerMarker); the last only shares their styling.
+ */
 export const STEER_MARKER_CLASS_BY_KIND = Object.freeze({
   folded: FOLDED_MSG_CLASS,
   stopped: STEER_STOPPED_MSG_CLASS,
+  'answered-elsewhere': ANSWERED_ELSEWHERE_MSG_CLASS,
 });
 
 function isSteerMarker(node) {

package/server/public/index.html

@@ -2812,10 +2812,13 @@
      kind='absorbed' and the steered message carries the continuing reply. A
      steer cut off by Stop settles as kind='stopped' with a Resend button.
      Markers are notes, not answers, so they render muted and compact.
-     steered-turn-merge.mjs adds the adjacency classes. */
+     steered-turn-merge.mjs adds the adjacency classes.
+     kind='answered-elsewhere' is no steer's marker but looks like one: it
+     closes a message whose answer is on a background-continuation row. */
   .msg.assistant.msg-absorbed .msg-bubble,
   .msg.assistant.msg-folded .msg-bubble,
-  .msg.assistant.msg-steer-stopped .msg-bubble {
+  .msg.assistant.msg-steer-stopped .msg-bubble,
+  .msg.assistant.msg-answered-elsewhere .msg-bubble {
     font-size: var(--fs-meta-md); color: var(--muted); font-style: italic;
     padding: 6px 12px; opacity: 0.85;
   }
@@ -2824,7 +2827,8 @@
   .msg.assistant.msg-folded,
   .msg.assistant.msg-steer-stopped { margin-top: -8px; }
   .msg.assistant.msg-folded .msg-label,
-  .msg.assistant.msg-steer-stopped .msg-label { display: none; }
+  .msg.assistant.msg-steer-stopped .msg-label,
+  .msg.assistant.msg-answered-elsewhere .msg-label { display: none; }
   .msg.assistant.msg-steer-stopped .msg-bubble-actions { font-style: normal; }
   .msg.user.msg-steered .msg-bubble { border-style: dashed; }
   .msg.user.msg-steered .msg-label::after { content: ' · steered mid-turn'; }

package/server/routes/messages-routes.mjs

@@ -37,7 +37,7 @@ 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';
@@ -6488,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) => {
@@ -7013,7 +7017,8 @@ 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,

package/server/routes/sessions-routes.mjs

@@ -1772,8 +1772,10 @@ 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)

package/server/services/remote-relay-caller-context.mjs

@@ -155,10 +155,12 @@ export function createRemoteRelayCallerContext({
   questionTimeoutMs = DEFAULT_QUESTION_TIMEOUT_MS,
 } = {}) {
   const questionStatements = questions || createQuestionRepository(db);
-  const getConversation = db.prepare(`SELECT id, title, preferred_relay_mode, preferred_model FROM conversations WHERE id = ?`);
+  const getConversation = db.prepare(`
+    SELECT id, title, preferred_relay_mode, preferred_model, preferred_reasoning_effort FROM conversations WHERE id = ?
+  `);
   const getRuntimeSession = db.prepare(`SELECT provider_type, provider_model, model FROM runtime_sessions WHERE conversation_id = ?`);
   const listProcessingRows = db.prepare(`
-    SELECT id, kind, relay_mode, model, attempt_id, owner_sdk_session_id, timestamp, processing_at
+    SELECT id, kind, relay_mode, model, reasoning_effort, attempt_id, owner_sdk_session_id, timestamp, processing_at
     FROM queue
     WHERE conversation_id = ? AND status = 'processing'
     ORDER BY COALESCE(processing_at, timestamp) ASC
@@ -217,8 +219,10 @@ export function createRemoteRelayCallerContext({
   }
 
   /**
-   * `{ conversationId, title, provider, model, mode, processingRowId,
+   * `{ conversationId, title, provider, model, effort, mode, processingRowId,
    * attemptId, userMessageId, hops }` for the conversation making the call.
+   * `effort` is the reasoning effort of the live turn, else the one the
+   * conversation prefers ('' when neither is known).
    * `hops` is how many relays the current turn's prompt already crossed: 0
    * for a human's message. A steered message folded into the live turn is
    * part of what the agent is acting on, so the highest count among the
@@ -240,6 +244,7 @@ export function createRemoteRelayCallerContext({
       title: toText(conversation?.title),
       provider: toText(runtime?.provider_type).toLowerCase() || 'github',
       model: toText(live?.model) || toText(runtime?.provider_model) || toText(runtime?.model) || toText(conversation?.preferred_model) || '',
+      effort: (toText(live?.reasoning_effort) || toText(conversation?.preferred_reasoning_effort)).toLowerCase(),
       mode: normalizeMode(live?.relay_mode || conversation?.preferred_relay_mode),
       processingRowId: live?.id || null,
       attemptId: toText(live?.attempt_id) || null,

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

@@ -4,6 +4,7 @@ import { randomUUID as nodeRandomUUID } from 'crypto';
 
 import {
   REMOTE_RELAY_APPROVAL_MODES,
+  REMOTE_RELAY_EFFORT_PATTERN,
   REMOTE_RELAY_ERROR_CODES,
   REMOTE_RELAY_LIMITS,
   REMOTE_RELAY_PROVIDERS,
@@ -19,6 +20,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
@@ -93,8 +95,20 @@ const FAILURE_TEXT_PATTERNS = Object.freeze([
   /^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();
@@ -214,6 +228,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 +414,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 +427,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 +482,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.' };
   }
@@ -638,7 +744,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 +872,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 +1171,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 +1180,7 @@ export function createRemoteRelayDispatcher({
       origin,
       ...(model ? { model } : {}),
       ...(mode ? { relayMode: mode } : {}),
+      ...(effort ? { reasoningEffort: effort } : {}),
     };
     let sent;
     try {
@@ -1090,11 +1207,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),
+    };
+  }
+
+  /**
+   * 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 = {} }) {
+  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 +1306,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 +1350,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 +1431,7 @@ export function createRemoteRelayDispatcher({
         title,
         ...(toText(bootstrap?.workspaceRootWarning) ? { cwdWarning: toText(bootstrap.workspaceRootWarning) } : {}),
         ...(note ? { modelNote: note } : {}),
+        ...effortResult(choice),
       },
     });
   }
@@ -1332,10 +1572,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);

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) {

package/shared/remote-relay-contract.mjs

@@ -60,6 +60,10 @@ export const REMOTE_RELAY_SESSION_SCOPES = Object.freeze(['active', 'recent', 'a
 export const REMOTE_RELAY_PROVIDERS = Object.freeze(['github', 'openai', 'claude', 'cursor', 'grok']);
 export const REMOTE_RELAY_MODES = Object.freeze(['plan', 'ask', 'agent', 'autopilot']);
 export const REMOTE_RELAY_IF_BUSY = Object.freeze(['queue', 'fail']);
+// Reasoning efforts differ per provider and model (none, low, medium, high,
+// xhigh, max, ultracode, ...), so the contract only checks the shape of the
+// value: the remote relay decides whether its model takes it.
+export const REMOTE_RELAY_EFFORT_PATTERN = /^[a-z0-9][a-z0-9-]{0,31}$/;
 
 export const REMOTE_RELAY_RESULT_STATUSES = Object.freeze([
   'queued',
@@ -203,6 +207,12 @@ export const REMOTE_RELAY_TOOL_INPUT_SCHEMA = Object.freeze({
       enum: [...REMOTE_RELAY_MODES],
       description: 'send / create_session: relay mode for the remote turn (default: this session\'s mode).',
     },
+    effort: {
+      type: 'string',
+      description: 'send / create_session: reasoning effort for the remote turn, e.g. low, medium, high (relay_info lists '
+        + 'what each model takes). create_session default: this session\'s effort when the remote model supports it, '
+        + 'else the remote\'s default. send default: the remote session keeps its own.',
+    },
     title: { type: 'string', description: 'create_session: session title (default: from the prompt).' },
     question_id: { type: 'string', description: 'answer_question: id from pendingQuestions.' },
     answer: { type: 'string', description: 'answer_question: free-text answer.' },
@@ -312,6 +322,13 @@ export function validateRemoteRelayToolInput(input = {}) {
     optionalText('model', 200);
     const modeCheck = optionalEnum('mode', REMOTE_RELAY_MODES);
     if (!modeCheck.ok) return modeCheck;
+    const effort = toText(input?.effort).toLowerCase();
+    if (effort) {
+      if (!REMOTE_RELAY_EFFORT_PATTERN.test(effort)) {
+        return invalid('effort must be a short word such as low, medium or high (letters, digits and dashes, at most 32 characters)');
+      }
+      args.effort = effort;
+    }
     if (action === 'send') {
       const busyCheck = optionalEnum('if_busy', REMOTE_RELAY_IF_BUSY);
       if (!busyCheck.ok) return busyCheck;

package/shared/steer-settle-failure.mjs

@@ -41,6 +41,12 @@ const VARIANTS = Object.freeze({
     message: `This message was sent to ${label} just before you stopped the turn, so it was not answered.`,
     guidance: 'Resend it if you still want an answer.',
   }),
+  // Not a steer: delivered between turns and answered on a background
+  // continuation row (ANSWERED_ELSEWHERE_KIND in steer-settle-markers.mjs).
+  answeredElsewhere: (label) => ({
+    message: `${sentenceCase(label)} answered this message in a reply marked “background continuation” — check the replies next to it.`,
+    guidance: 'Resend it only if it went unanswered.',
+  }),
   // Pulled back out of the runtime's queue by the user (un-steer) — the
   // prompt never ran — but the relay could not be told in time.
   cancelled: (label) => ({