@oar-sh/oar 0.9.5 → 0.9.7

package/server/routes/messages-routes.mjs

@@ -22,6 +22,7 @@ import {
   STEER_SETTLE_FAILED_CODE,
   STEER_SETTLE_FAILED_STABLE_CODE,
 } from '../../shared/steer-settle-failure.mjs';
+import { matchFailureNote } from '../../shared/failure-note-text.mjs';
 import { buildRelayStopFailure } from '../../shared/relay-stop-failure.mjs';
 import { stopSessionWorkerProcesses } from '../services/session-worker-stop-service.mjs';
 import {
@@ -31,6 +32,7 @@ import {
   usageSnapshotFromSummary,
 } from '../services/usage-snapshot-helpers.mjs';
 import { claudePlanUsageFromResult, normalizeClaudePlanUsage } from '../services/plan-usage-claude.mjs';
+import { isUsageLimitTerminalError } from '../services/usage-limit-pause-service.mjs';
 import { normalizeCopilotWorkerUsage } from '../services/plan-usage-copilot.mjs';
 import { normalizeGrokTurnUsage } from '../services/plan-usage-grok.mjs';
 import { openAIReasoningEffortsForModel } from '../../shared/openai-reasoning.mjs';
@@ -41,9 +43,13 @@ import { ANSWERED_ELSEWHERE_KIND, STEER_FOLDED_TEXT } from '../../shared/steer-s
 import { isLiveResend } from '../services/steer-resend.mjs';
 import { resolveProviderModelSelection } from '../services/provider-model-selection.mjs';
 import { stripRemotePromptHeader } from '../../shared/remote-relay-contract.mjs';
+import { stripModelTierSuffix } from '../../shared/claude-cloud/repo-url.mjs';
+import { buildClaudeCloudDelivery, isClaudeCloudProviderType } from '../services/claude-cloud-session-service.mjs';
 import {
   admitRemoteRelayRequest,
   findMentionedRemoteRelays,
+  findOriginRemoteRelay,
+  formatRemoteRelayOriginHint,
   formatRemoteRelayMentionHint,
   recordRemoteRelayUnlocks,
   withRemoteRelayMentionHint,
@@ -110,6 +116,8 @@ function normalizeRequestedProviderType(value = '') {
   // "no provider stated" and the guards below could never fire.
   if (normalized === 'grok' || normalized === 'xai' || normalized === 'xai-grok') return 'grok';
   if (normalized === 'claude' || normalized === 'anthropic') return 'claude';
+  // Its own provider, never read as `claude`.
+  if (normalized === 'claude-cloud') return 'claude-cloud';
   return '';
 }
 
@@ -117,6 +125,7 @@ const BOOTSTRAP_ONLY_PROVIDER_LABELS = Object.freeze({
   cursor: 'Cursor',
   grok: 'Grok',
   claude: 'Claude',
+  'claude-cloud': 'Claude Cloud',
 });
 
 function deriveModelOrigin(model) {
@@ -450,15 +459,19 @@ function extractTerminalId(text, patterns = []) {
   return null;
 }
 
+/**
+ * Reads a failure a sender reported as text only, without a `terminalError`
+ * record. The text has to BE a failure note, not merely contain one
+ * (shared/failure-note-text.mjs): a reply that quoted a note was stored as a
+ * failed turn, cut off at the quoted code.
+ */
 export function parseTerminalFailureText(text) {
   const raw = String(text || '').trim();
-  if (!raw) return null;
-  const stableCodeMatch = raw.match(/error code:\s*(relay\.[a-z0-9-]+)/i);
-  if (!stableCodeMatch) return null;
-  const stableCode = String(stableCodeMatch[1] || '').trim().toLowerCase();
-  const code = normalizeTerminalErrorCode(stableCode);
+  const note = matchFailureNote(raw);
+  if (!note) return null;
+  const code = normalizeTerminalErrorCode(note.stableCode);
   if (!code) return null;
-  const message = normalizeTerminalErrorText(raw.slice(0, stableCodeMatch.index).trim().replace(/\s+$/, '.'));
+  const message = normalizeTerminalErrorText(note.lead.trim().replace(/\s+$/, '.'));
   const detailMatch = raw.match(/details:\s*(.+)$/i);
   return {
     terminal: true,
@@ -478,7 +491,7 @@ export function parseTerminalFailureText(text) {
   };
 }
 
-function buildTerminalFailureTextForChat(terminalFailure, fallbackMessage = null) {
+export function buildTerminalFailureTextForChat(terminalFailure, fallbackMessage = null) {
   const failure = terminalFailure && typeof terminalFailure === 'object' ? terminalFailure : {};
   const code = normalizeTerminalErrorCode(failure.code || failure.stableCode) || 'unknown-terminal';
   const stableCode = `relay.${code}`;
@@ -486,7 +499,7 @@ function buildTerminalFailureTextForChat(terminalFailure, fallbackMessage = null
     || normalizeTerminalErrorText(fallbackMessage)
     || 'The relay runtime hit a terminal error and could not complete this turn.';
   const guidance = normalizeTerminalErrorText(failure.guidance)
-    || 'Retry the message. If this keeps failing, restart the relay and include the error code.';
+    || 'Send the message again to retry. If this keeps failing, include the error code when you report it.';
   const detail = normalizeTerminalErrorText(failure.detail);
   const ids = [
     normalizeTerminalErrorText(failure.functionCallId) ? `functionCallId=${failure.functionCallId}` : null,
@@ -581,9 +594,17 @@ async function resolveRelayResponseText({
   }
 }
 
-export function resolveTerminalFailurePayload(payload = {}, { fallbackText = null } = {}) {
+/**
+ * `inferFromText`: whether a text shaped like a failure note counts as one
+ * when no record came with it. A session worker always sends the record
+ * (`terminalError`), so for its publishes (an `attemptId` names the attempt)
+ * the text is a reply whatever it says — a reply that names a code after
+ * fixing a failed test is a reply. Senders without an attempt (the Copilot
+ * extension, a note read from another relay) still report as text.
+ */
+export function resolveTerminalFailurePayload(payload = {}, { fallbackText = null, inferFromText = true } = {}) {
   const body = payload && typeof payload === 'object' ? payload : {};
-  const parsedTextFailure = parseTerminalFailureText(body.text);
+  const parsedTextFailure = inferFromText ? parseTerminalFailureText(body.text) : null;
   const direct = body.terminalError && typeof body.terminalError === 'object'
     ? body.terminalError
     : null;
@@ -628,8 +649,13 @@ export function resolveTerminalFailurePayload(payload = {}, { fallbackText = nul
   const code = explicitCode
     || normalizeTerminalErrorCode(parsedTextFailure?.code)
     || 'unknown-terminal';
+  // Known from the text alone: nothing but the shape of the text says that
+  // this is a failure, so the text is kept as it was sent.
+  const fromText = !!parsedTextFailure && !direct && !explicitCode
+    && body.terminal !== true && body.isTerminal !== true && body.errorKind !== 'terminal';
   return {
     terminal: true,
+    ...(fromText ? { fromText: true } : {}),
     code,
     stableCode: `relay.${code}`,
     message: explicitMessage || parsedTextFailure?.message || normalizeTerminalErrorText(fallbackText),
@@ -1108,6 +1134,7 @@ export function buildDequeuedRelayMessage({
   defaultRelayMode,
   defaultModel,
   getCursorProviderSettings = () => null,
+  getClaudeCloudProviderSettings = () => null,
 } = {}) {
   if (!msg) return null;
   const attachments = parseAttachments(msg.attachments).map(hydrateAttachment).filter(Boolean);
@@ -1137,6 +1164,17 @@ export function buildDequeuedRelayMessage({
       .map((value) => String(value || '').trim())
       .filter(Boolean);
   }
+  // A Claude Cloud worker creates its session from the first delivered
+  // message and sends into it afterwards: the repository, the branch and the
+  // binding it reported ride on every message, so a restarted worker needs
+  // nothing but the delivery. Other providers never get the field.
+  const claudeCloud = isClaudeCloudProviderType(providerType)
+    ? buildClaudeCloudDelivery({
+        conversation: stmts.getConvAnyStatus?.get?.(msg.conversation_id) || null,
+        runtimeSession,
+        fallbackEnvironmentId: getClaudeCloudProviderSettings()?.environmentId || '',
+      })
+    : null;
   return {
     id: msg.id,
     conversationId: msg.conversation_id,
@@ -1150,6 +1188,7 @@ export function buildDequeuedRelayMessage({
     cursorAgentId: String(runtimeSession?.cursor_agent_id || '').trim() || null,
     cursorSubagentModels,
     grokNativeSessionId: String(runtimeSession?.grok_native_session_id || '').trim() || null,
+    ...(isClaudeCloudProviderType(providerType) ? { claudeCloud } : {}),
     reasoningEffort: String(msg.reasoning_effort || '').trim() || null,
     contextTier: String(msg.context_tier || '').trim() || 'default',
     quality: normalizeOpenAIImageQuality(msg.reasoning_effort),
@@ -1770,6 +1809,7 @@ export function registerMessagesRoutes(app, deps) {
     getClaudeProviderSettings = () => ({ enabled: false, model: '', models: [] }),
     getCursorProviderSettings = () => ({ enabled: false, model: '', models: [] }),
     getGrokProviderSettings = () => ({ enabled: false, model: '', models: [] }),
+    getClaudeCloudProviderSettings = () => ({ enabled: false, defaultModel: '', environmentId: '', models: [] }),
     rebindUnstartedOpenAIConversationModel = null,
     normalizeRelayMode,
     DEFAULT_RELAY_MODE,
@@ -1804,6 +1844,7 @@ export function registerMessagesRoutes(app, deps) {
     resolveSessionStateRoot,
     fetchUsageSummary = null,
     planUsageService = null,
+    usageLimitPauseService = null,
     getCursorPlanAllowanceSettings = () => ({ cursorModelsUsd: null, otherModelsUsd: null, resetDay: 1 }),
     getGrokPlanAllowanceSettings = () => ({ monthlyUsd: null, resetDay: 1 }),
     opaqueResponseRecoveryWaitMs = OPAQUE_RESPONSE_RECOVERY_WAIT_MS,
@@ -4152,7 +4193,8 @@ export function registerMessagesRoutes(app, deps) {
     const runtimeBoundToExplicitProvider = runtimeProviderType === 'openai'
       || runtimeProviderType === 'claude'
       || runtimeProviderType === 'cursor'
-      || runtimeProviderType === 'grok';
+      || runtimeProviderType === 'grok'
+      || runtimeProviderType === 'claude-cloud';
     const configuredOpenAIModel = String(configuredOpenAI?.model || '').trim();
     const availableOpenAIModels = new Set(
       (Array.isArray(configuredOpenAI?.models) ? configuredOpenAI.models : [])
@@ -4276,6 +4318,17 @@ export function registerMessagesRoutes(app, deps) {
         });
       }
     }
+    // Claude Cloud conversations are bootstrap-created only as well: each
+    // carries the repository its cloud session clones. Only an explicit
+    // provider counts here — the cloud's model ids are the Claude provider's
+    // own, so an id alone never means "cloud".
+    const runtimeUsesClaudeCloud = runtimeProviderType === 'claude-cloud';
+    if (!shouldCreateConversation && !runtimeUsesClaudeCloud && requestedProviderType === 'claude-cloud') {
+      return res.status(409).json({
+        error: 'Claude Cloud requires creating a new Claude Cloud conversation',
+        code: 'CLAUDE_CLOUD_REQUIRES_NEW_CONVERSATION',
+      });
+    }
     if (
       useOpenAIProvider
       && requestedOpenAIModel
@@ -4408,6 +4461,32 @@ export function registerMessagesRoutes(app, deps) {
     const grokModel = runtimeUsesGrok
       ? (pinnedGrokModel || String(configuredGrok?.model || '').trim())
       : '';
+    // Claude Cloud conversations resolve models against the cloud provider's
+    // own list (plain ids, no "[1m]" tier). The model is part of the cloud
+    // session's configuration: it can still change before the first message
+    // creates that session, and is locked afterwards.
+    const configuredClaudeCloud = runtimeUsesClaudeCloud ? getClaudeCloudProviderSettings() : null;
+    const pinnedClaudeCloudModel = runtimeUsesClaudeCloud
+      ? stripModelTierSuffix(existingRuntimeSession?.provider_model)
+      : '';
+    const claudeCloudModelSelection = runtimeUsesClaudeCloud
+      ? resolveProviderModelSelection({
+          requestedModel: stripModelTierSuffix(model),
+          configuredModel: pinnedClaudeCloudModel || String(configuredClaudeCloud?.defaultModel || '').trim(),
+          availableModels: Array.isArray(configuredClaudeCloud?.models) ? configuredClaudeCloud.models : [],
+        })
+      : null;
+    if (claudeCloudModelSelection && !claudeCloudModelSelection.ok) {
+      return res.status(400).json({
+        error: `Claude Cloud model "${claudeCloudModelSelection.requestedModel}" is not available`,
+        code: 'CLAUDE_CLOUD_MODEL_UNAVAILABLE',
+        supportedModels: claudeCloudModelSelection.availableModels || [],
+      });
+    }
+    // A cloud session's model can be switched between turns (the worker
+    // sends set_model before the message), so a changed model is taken as
+    // for a local Claude chat.
+    const claudeCloudModel = claudeCloudModelSelection ? claudeCloudModelSelection.model : '';
     const modelResolution = useOpenAIProvider
       ? {
           ok: !!openAIModel,
@@ -4440,7 +4519,15 @@ export function registerMessagesRoutes(app, deps) {
                 reasoningEffort: null,
                 error: grokModel ? null : 'Grok model is not configured',
               }
-            : resolveRequestedModel(model))));
+            : (runtimeUsesClaudeCloud
+              ? {
+                  ok: !!claudeCloudModel,
+                  model: claudeCloudModel,
+                  modelVariantId: claudeCloudModel,
+                  reasoningEffort: null,
+                  error: claudeCloudModel ? null : 'Claude Cloud model is not configured',
+                }
+              : resolveRequestedModel(model)))));
     if (!modelResolution.ok) return res.status(400).json({ error: modelResolution.error, supportedModels: modelResolution.available || [] });
     const requestedModel = String(modelResolution.model || '').trim();
     const requestedAutoModel = requestedModel.toLowerCase() === AUTO_MODEL_SENTINEL;
@@ -4509,10 +4596,13 @@ export function registerMessagesRoutes(app, deps) {
           ? resolveCursorReasoningEffort()
           : (runtimeUsesGrok
             ? resolveGrokReasoningEffort()
-            : resolveRequestedReasoningEffort(
-                requestedModel,
-                explicitReasoningEffort || modelResolution.reasoningEffort || null,
-              ))));
+            // A cloud session takes no effort: whatever was asked, it is none.
+            : (runtimeUsesClaudeCloud
+              ? { ok: true, effort: 'none', supported: ['none'] }
+              : resolveRequestedReasoningEffort(
+                  requestedModel,
+                  explicitReasoningEffort || modelResolution.reasoningEffort || null,
+                )))));
     if (!reasoningResolution?.ok && !explicitReasoningEffort) {
       const supportedEfforts = Array.isArray(reasoningResolution?.supported)
         ? reasoningResolution.supported.map((value) => String(value || '').trim().toLowerCase()).filter(Boolean)
@@ -4539,6 +4629,9 @@ export function registerMessagesRoutes(app, deps) {
       }
     } else if (!['default', 'long_context'].includes(requestedContextTier)) {
       return res.status(400).json({ error: 'Unsupported context tier' });
+    } else if (runtimeUsesClaudeCloud) {
+      // The cloud has no long-context tier to pick.
+      normalizedContextTier = 'default';
     }
     if (!requestedRelayMode) return res.status(400).json({ error: 'Unsupported relay mode' });
     const conversationWorkspaceState = (!shouldCreateConversation && typeof resolveConversationWorkspaceState === 'function')
@@ -4685,13 +4778,19 @@ export function registerMessagesRoutes(app, deps) {
           trimmedText || '(User sent image attachments only.)',
         ].join('\n')
       : trimmedText;
-    // Only what a human typed unlocks a remote relay (decision 19). The hint
+    // Only what a human typed unlocks a remote relay by mention (decision 19);
+    // a prompt from a relay's agent opens that one relay and no other. The hint
     // rides in the queued prompt only, so the stored message and the user's
     // bubble stay exactly what was typed.
     const mentionedRemoteRelays = remoteRequest.remote
       ? []
       : findMentionedRemoteRelays(remoteRelayInbound, trimmedText);
-    const queueText = withRemoteRelayMentionHint(promptText, formatRemoteRelayMentionHint(mentionedRemoteRelays));
+    // A prompt from another relay's agent opens that relay for this
+    // conversation (it may be answered): the agent is told where it came from.
+    const remoteRelayHint = remoteRequest.remote
+      ? formatRemoteRelayOriginHint(findOriginRemoteRelay(remoteRelayInbound, remoteRequest.origin), remoteRequest.origin)
+      : formatRemoteRelayMentionHint(mentionedRemoteRelays);
+    const queueText = withRemoteRelayMentionHint(promptText, remoteRelayHint);
     // A Resend never came from the composer, and neither did another relay's
     // agent: whatever the user is typing there stays their draft.
     const keepsComposerDraft = !!resendOriginId || remoteRequest.remote;
@@ -4764,6 +4863,17 @@ export function registerMessagesRoutes(app, deps) {
       ) {
         stmts.updateRuntimeSessionProvider.run('claude', claudeModel, claudeModel, now, runtimeSession.id);
       }
+      // A cloud conversation follows the composer like a Claude one: the
+      // worker switches the sandbox's model before the message.
+      if (
+        runtimeUsesClaudeCloud
+        && claudeCloudModel
+        && runtimeSession?.id
+        && claudeCloudModel !== String(existingRuntimeSession?.provider_model || '').trim()
+        && typeof stmts.updateRuntimeSessionProvider?.run === 'function'
+      ) {
+        stmts.updateRuntimeSessionProvider.run('claude-cloud', claudeCloudModel, claudeCloudModel, now, runtimeSession.id);
+      }
       // Another relay's agent picks the model and mode of its own turn; the
       // composer keeps restoring the user's choice for this conversation.
       conversationPreferences = remoteRequest.remote && !shouldCreateConversation
@@ -5265,7 +5375,10 @@ export function registerMessagesRoutes(app, deps) {
     if (!runtimeSession) {
       return res.status(404).json({ error: 'Runtime session not found for conversation' });
     }
-    if (String(runtimeSession.provider_type || 'github').trim().toLowerCase() !== 'claude') {
+    // The Claude Cloud worker reports the same shape (the cloud session's
+    // context and token usage), so both providers are taken here.
+    const contextUsageProvider = String(runtimeSession.provider_type || 'github').trim().toLowerCase();
+    if (contextUsageProvider !== 'claude' && contextUsageProvider !== 'claude-cloud') {
       return res.status(409).json({ error: 'Conversation is not bound to the Claude provider' });
     }
     if (typeof stmts.updateRuntimeSessionContextUsage?.run !== 'function') {
@@ -5325,13 +5438,17 @@ export function registerMessagesRoutes(app, deps) {
     // Claude-bound conversation's worker may write the Claude card. The
     // snapshot itself is global, so a misrouted poster would corrupt it for
     // everyone.
+    // A Claude Cloud worker posts here too; its report is kept under its own
+    // snapshot key, so the Claude card stays what the Claude workers wrote.
     const conversationId = String(req.body?.conversationId || '').trim();
+    let snapshotProvider = 'claude';
     if (conversationId) {
       const runtimeSession = stmts.getRuntimeSessionByConversation?.get?.(conversationId) || null;
       const boundProvider = String(runtimeSession?.provider_type || 'github').trim().toLowerCase();
-      if (runtimeSession && boundProvider !== 'claude') {
+      if (runtimeSession && boundProvider !== 'claude' && boundProvider !== 'claude-cloud') {
         return res.status(409).json({ error: 'Conversation is not bound to the Claude provider' });
       }
+      if (runtimeSession && boundProvider === 'claude-cloud') snapshotProvider = 'claude-cloud';
     }
     const usage = normalizeClaudePlanUsage(req.body?.usage)
       || claudePlanUsageFromResult({
@@ -5339,13 +5456,34 @@ export function registerMessagesRoutes(app, deps) {
         totalCostUsd: req.body?.totalCostUsd,
       });
     if (!usage) return res.status(400).json({ error: 'Missing usable usage payload' });
-    planUsageService.saveSnapshot('claude', usage, {
+    planUsageService.saveSnapshot(snapshotProvider, usage, {
       source: 'worker',
       error: String(req.body?.error || '').trim() || null,
     });
     res.json({ ok: true });
   });
 
+  // POST /api/claude-usage-limit — the Claude worker forwards what the CLI
+  // reported about the subscription's usage limit (a `rate_limit_event`): the
+  // clients warn before the limit and show the reset once it is reached.
+  app.post('/api/claude-usage-limit', auth, (req, res) => {
+    touchCli();
+    if (!usageLimitPauseService) return res.status(501).json({ error: 'Usage limit handling is unavailable' });
+    // The report is the account's, so only a Claude-bound conversation's
+    // worker may write it (same validation as the plan usage card); a Claude
+    // Cloud chat runs on the same account and reports the same limit.
+    const conversationId = String(req.body?.conversationId || '').trim();
+    if (conversationId) {
+      const runtimeSession = stmts.getRuntimeSessionByConversation?.get?.(conversationId) || null;
+      const boundProvider = String(runtimeSession?.provider_type || 'github').trim().toLowerCase();
+      if (runtimeSession && boundProvider !== 'claude' && boundProvider !== 'claude-cloud') {
+        return res.status(409).json({ error: 'Conversation is not bound to the Claude provider' });
+      }
+    }
+    const state = usageLimitPauseService.recordReport({ report: req.body?.report });
+    res.json({ ok: true, state });
+  });
+
   // POST /api/copilot-plan-usage — the Copilot SDK worker reports the turn's
   // billing/token detail.
   //
@@ -5942,6 +6080,7 @@ export function registerMessagesRoutes(app, deps) {
         defaultRelayMode: DEFAULT_RELAY_MODE,
         defaultModel: DEFAULT_MODEL,
         getCursorProviderSettings,
+        getClaudeCloudProviderSettings,
       });
       
       if (out.attachments.length) {
@@ -6535,8 +6674,11 @@ export function registerMessagesRoutes(app, deps) {
         });
       }
     };
-    const trimmedText = String(text || '').trim();
-    const terminalFailure = resolveTerminalFailurePayload(req.body, { fallbackText: trimmedText });
+    let trimmedText = String(text || '').trim();
+    let terminalFailure = resolveTerminalFailurePayload(req.body, {
+      fallbackText: trimmedText,
+      inferFromText: !String(req.body?.attemptId || '').trim(),
+    });
     // Final digests of background workflows that settled during this turn —
     // the transcript's "Finished background task" cards. Same structural
     // sanitizer as the live panel rows; junk entries drop silently (this
@@ -6590,6 +6732,22 @@ export function registerMessagesRoutes(app, deps) {
     }
 
     const relayMode = normalizeRelayMode(mode || q?.relay_mode) || DEFAULT_RELAY_MODE;
+    // A Claude turn refused at the usage limit is paused, not failed: its row
+    // ends with a note like any answered one, and a follow-up is queued that
+    // is held until the reset (usage-limit-pause-service).
+    const usageLimitPause = terminalFailure && q && isUsageLimitTerminalError(req.body?.terminalError)
+      ? (usageLimitPauseService?.planPause?.({
+        terminalError: req.body.terminalError,
+        conversationId: targetConversationId,
+        providerType: stmts.getRuntimeSessionByConversation?.get(targetConversationId)?.provider_type,
+        queueRow: q,
+        partialText: req.body?.partialText,
+      }) || null)
+      : null;
+    if (usageLimitPause) {
+      trimmedText = usageLimitPause.noteText;
+      terminalFailure = null;
+    }
     if (terminalFailure) {
       // Terminal failures carry provenance too: the original hijack incident
       // presented exactly as stolen turns dying on 402 through this path.
@@ -6615,14 +6773,22 @@ export function registerMessagesRoutes(app, deps) {
       if (terminalCrossConversation.crossConversation) {
         console.warn(`[${ts()}] CONVERSATION MISMATCH ${messageId?.slice(0, 8)} conv=${targetConversationId?.slice(0, 8)} responderConv=${terminalCrossConversation.responderConversationId?.slice(0, 8)} — terminal failure posted by another conversation's worker`);
       }
-      const failureText = buildTerminalFailureTextForChat(terminalFailure, trimmedText);
+      // A failure read from the text alone keeps that text, whole: it is the
+      // note already, and should the reading be wrong, nothing of a reply is
+      // lost.
+      const failureText = terminalFailure.fromText
+        ? trimmedText
+        : buildTerminalFailureTextForChat(terminalFailure, trimmedText);
+      // What the turn had written before it failed stays readable: the note
+      // goes below it instead of replacing it.
+      const partialText = String(req.body.partialText || '').trim();
       const failed = failQueueMessage({
         queueRow: q,
         messageId,
         conversationId: targetConversationId,
         relayMode,
         model: model || q?.model || null,
-        responseText: failureText,
+        responseText: partialText ? `${partialText}\n\n${failureText}` : failureText,
         executedProvider: terminalExecutedProvider,
         failureRecord: {
           kind: 'terminal',
@@ -7015,6 +7181,13 @@ export function registerMessagesRoutes(app, deps) {
       },
     });
     io.emit('message_status', { messageId, conversationId: targetConversationId, status: 'done' });
+    if (usageLimitPause) {
+      try {
+        usageLimitPauseService.schedulePause(usageLimitPause, { queueRow: q });
+      } catch (error) {
+        console.warn(`[${ts()}] USAGE LIMIT ${messageId?.slice(0, 8)} conv=${targetConversationId?.slice(0, 8)} the follow-up could not be queued: ${error?.message || error}`);
+      }
+    }
     // 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, and a message answered on a
@@ -7035,7 +7208,10 @@ export function registerMessagesRoutes(app, deps) {
   // Providers whose workers turn runtime-initiated activity into continuation
   // rows: the Claude worker (background tasks/agents) and the Copilot SDK
   // worker (detached background shells) serving both Copilot-CLI providers.
-  const CONTINUATION_PROVIDER_TYPES = new Set(['claude', 'github', 'openai']);
+  // A Claude Cloud session can take a turn of its own too: one the agent
+  // starts when its background work reports back, or one started on
+  // claude.ai; the cloud worker follows it and registers it here.
+  const CONTINUATION_PROVIDER_TYPES = new Set(['claude', 'github', 'openai', 'claude-cloud']);
 
   // POST /api/continuation-turn — a session worker's CLI started a turn on its
   // own (a background task's notification). The synthetic queue row gives that

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

@@ -1,5 +1,7 @@
 'use strict';
 
+import { persistConversationPreferences } from '../services/conversation-preferences-service.mjs';
+
 function normalizeId(value) {
   const text = String(value || '').trim();
   return text || null;
@@ -86,6 +88,7 @@ export function registerRelayBoardRoutes(app, deps) {
   const {
     auth,
     io,
+    db,
     stmts,
     uuidv4,
     normalizeRelayMode,
@@ -96,9 +99,52 @@ export function registerRelayBoardRoutes(app, deps) {
     pushDispatchService,
   } = deps;
 
+  /**
+   * The session goes on in the mode that was chosen on the board: after
+   * "Implement in autopilot" the composer says Autopilot, and the next message
+   * carries the work on instead of planning again. The model and the effort
+   * stay as they are. Advisory: the follow-up is queued whatever happens here.
+   */
+  function followChosenMode(conversationId, relayMode, updatedAt) {
+    try {
+      const existing = stmts.getConvAnyStatus?.get?.(conversationId) || null;
+      if (!existing || String(existing.status || '').trim() === 'deleted') return;
+      if ((normalizeRelayMode(existing.preferred_relay_mode) || '') === relayMode) return;
+      const persisted = persistConversationPreferences({
+        db,
+        stmts,
+        conversationId,
+        preferredRelayMode: relayMode,
+        preferredModel: existing.preferred_model,
+        preferredReasoningEffort: existing.preferred_reasoning_effort,
+        updatedAt,
+      });
+      if (!persisted.ok) return;
+      // No sender: the page that pressed the button has to follow as well.
+      io.emit('conversation_preferences_updated', {
+        conversationId,
+        preferredRelayMode: persisted.preferredRelayMode,
+        preferredModel: persisted.preferredModel,
+        preferredReasoningEffort: persisted.preferredReasoningEffort,
+        autoCompactWindow: persisted.autoCompactWindow ?? null,
+        thinkingEnabled: persisted.thinkingEnabled ?? null,
+        thinkingDisplay: persisted.thinkingDisplay ?? null,
+        updatedAt: persisted.updatedAt,
+        senderClientId: null,
+      });
+    } catch {}
+  }
+
   app.get('/api/relay-boards', auth, (req, res) => {
     const conversationId = req.query.conversationId ? String(req.query.conversationId) : null;
     const status = String(req.query.status || 'pending').trim() || 'pending';
+    // Every board of one conversation, settled ones included: a reply goes on
+    // showing the plan it offered and what was chosen. Per conversation only.
+    if (status === 'all') {
+      if (!conversationId) return res.status(400).json({ error: 'Missing conversationId' });
+      const all = stmts.listBoardsForConversation.all(conversationId);
+      return res.json({ boards: all.map(formatRelayBoardRow).filter(Boolean) });
+    }
     const rows = stmts.listBoards.all(status, conversationId, conversationId);
     res.json({ boards: rows.map(formatRelayBoardRow).filter(Boolean) });
   });
@@ -222,7 +268,11 @@ export function registerRelayBoardRoutes(app, deps) {
           String(resolvedVariantModel || '').trim().toLowerCase() === 'auto' ? 'auto' : 'manual',
         );
         stmts.updateConvTime.run(now, convId);
-        stmts.insertQ.run(
+        // One value per placeholder of the queue insert: the context tier
+        // (none: the follow-up runs on the conversation's own) and, where the
+        // queue has the column, the image operation. Two short, the insert
+        // threw and the action answered 500 with the board already marked.
+        const queueArgs = [
           queuedMessageId,
           convId,
           runtimeSession?.id || null,
@@ -230,6 +280,7 @@ export function registerRelayBoardRoutes(app, deps) {
           resolvedBaseModel,
           resolvedVariantModel,
           resolvedReasoningEffort,
+          null,
           relayMode,
           followupPrompt,
           null,
@@ -238,7 +289,9 @@ export function registerRelayBoardRoutes(app, deps) {
           null,
           null,
           null,
-        );
+        ];
+        if (stmts.queueHasImageOperationId) queueArgs.push(null);
+        stmts.insertQ.run(...queueArgs);
         io.emit('user_message', {
           conversationId: convId,
           messageId: queuedMessageId,
@@ -253,6 +306,7 @@ export function registerRelayBoardRoutes(app, deps) {
             timestamp: now,
           },
         });
+        followChosenMode(convId, relayMode, now);
       }
     }
 

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

@@ -42,12 +42,15 @@ export function registerRemoteRelayRoutes(app, deps) {
     });
   });
 
-  // Workers ask at start whether to register the remote_relay tool at all.
+  // Workers ask at start whether to register the remote_relay tool at all:
+  // when a relay is paired (`count`), or when this relay's own sessions are
+  // open to its agents (`localEnabled`, the local target).
   app.get('/api/remote-relays/summary', auth, (_req, res) => {
     const relays = registry.listPublic();
     res.json({
       count: relays.length,
       online: relays.filter((relay) => relay.lastStatus === 'online').length,
+      localEnabled: registry.getAgentSessionsSettings?.().enabled === true,
     });
   });
 
@@ -111,6 +114,17 @@ export function registerRemoteRelayRoutes(app, deps) {
     sendResult(res, registry.setSelfSettings(req.body || {}));
   });
 
+  // Agent sessions: whether this relay's agents may start and use sessions on
+  // it, and the longest wait of one tool call. POST takes
+  // `{ enabled?, maxWaitSeconds? }` and answers the GET shape plus `ok`.
+  app.get('/api/settings/agent-sessions', auth, (_req, res) => {
+    res.json(registry.getAgentSessionsSettings());
+  });
+
+  app.post('/api/settings/agent-sessions', auth, (req, res) => {
+    sendResult(res, registry.setAgentSessionsSettings(req.body || {}));
+  });
+
   // PATCH /api/remote-relays/:id — { permission, url, token, tokenMode }.
   app.patch('/api/remote-relays/:id', auth, (req, res) => {
     sendResult(res, registry.update(req.params?.id, req.body || {}));