@oar-sh/oar 0.9.4 → 0.9.6

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,19 +32,22 @@ 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';
 import { DEFAULT_CLAUDE_REASONING_EFFORTS } from '../services/provider-reasoning-effort.mjs';
 import { claudeBaseModelId, claudeLongContextModelId } from '../../shared/model-id.mjs';
 import { sanitizeSubagentRunId } from '../../shared/subagent-run-id.mjs';
-import { STEER_FOLDED_TEXT } from '../../shared/steer-settle-markers.mjs';
+import { ANSWERED_ELSEWHERE_KIND, STEER_FOLDED_TEXT } from '../../shared/steer-settle-markers.mjs';
 import { isLiveResend } from '../services/steer-resend.mjs';
 import { resolveProviderModelSelection } from '../services/provider-model-selection.mjs';
 import { stripRemotePromptHeader } from '../../shared/remote-relay-contract.mjs';
 import {
   admitRemoteRelayRequest,
   findMentionedRemoteRelays,
+  findOriginRemoteRelay,
+  formatRemoteRelayOriginHint,
   formatRemoteRelayMentionHint,
   recordRemoteRelayUnlocks,
   withRemoteRelayMentionHint,
@@ -450,15 +454,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 +486,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 +494,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,
@@ -628,8 +636,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),
@@ -1804,6 +1817,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,
@@ -4685,13 +4699,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;
@@ -5346,6 +5366,26 @@ export function registerMessagesRoutes(app, deps) {
     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).
+    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') {
+        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.
   //
@@ -6488,7 +6528,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) => {
@@ -6531,8 +6575,8 @@ 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 });
     // 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
@@ -6586,6 +6630,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.
@@ -6611,14 +6671,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',
@@ -7011,9 +7079,17 @@ 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.
+    // 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/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/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)
@@ -2091,6 +2093,7 @@ export function registerSessionsRoutes(app, deps) {
     uploadPathForSha,
     hostSuspendService = null,
     collectHostActivity = null,
+    usageLimitPauseService = null,
     hostSuspendPlatform = process.platform,
     // Remote relays (server/services/remote-relay-inbound.mjs): origin on
     // conversations another relay's agent created, and the inbound switch.
@@ -3821,6 +3824,7 @@ export function registerSessionsRoutes(app, deps) {
       // "cancelled" with it.
       activeTurn: Number(stmts.getConversationActiveQueueCount?.get?.(resolvedConversationId)?.count || 0) > 0,
       backgroundTasks: backgroundTaskStore?.get?.(resolvedConversationId) || [],
+      usageLimitPause: usageLimitPauseService?.getPause?.(resolvedConversationId) || null,
       previews: listConversationPreviews?.(resolvedConversationId) || [],
       preferredRelayMode: preferences.preferredRelayMode,
       preferredModel: preferences.preferredModel,
@@ -5101,6 +5105,7 @@ export function registerSessionsRoutes(app, deps) {
       restartOrchestrator: relayRestartOrchestrator?.getState?.() || null,
       relayShutdown: runtimeState.relayShutdown || null,
       hostSuspend: runtimeState.hostSuspend || null,
+      usageLimit: runtimeState.usageLimit || null,
       platform: process.platform,
       features: featureFlags || {},
       sessionWorker: sessionWorkerStatus,
@@ -6248,6 +6253,39 @@ export function registerSessionsRoutes(app, deps) {
     return res.json({ ok: true, cancelled: !!result.cancelled, state: result.state });
   });
 
+  // Turns paused at the Claude usage limit (usage-limit-pause-service): the
+  // held follow-up can be sent before the reset, or dropped.
+  app.get('/api/usage-limit', auth, (req, res) => {
+    if (!usageLimitPauseService) {
+      return res.status(501).json({ ok: false, error: 'Usage limit handling is unavailable' });
+    }
+    return res.json({
+      ok: true,
+      account: usageLimitPauseService.getAccountState(),
+      pauses: usageLimitPauseService.listPauses(),
+    });
+  });
+
+  app.post('/api/usage-limit/resume', auth, (req, res) => {
+    if (!usageLimitPauseService) {
+      return res.status(501).json({ ok: false, error: 'Usage limit handling is unavailable' });
+    }
+    const conversationId = String(req.body?.conversationId || '').trim();
+    if (!conversationId) return res.status(400).json({ ok: false, error: 'Missing conversationId' });
+    const result = usageLimitPauseService.resumeNow({ conversationId });
+    return res.json({ ok: true, resumed: !!result.resumed, messageId: result.messageId || null, pause: result.state });
+  });
+
+  app.post('/api/usage-limit/cancel', auth, (req, res) => {
+    if (!usageLimitPauseService) {
+      return res.status(501).json({ ok: false, error: 'Usage limit handling is unavailable' });
+    }
+    const conversationId = String(req.body?.conversationId || '').trim();
+    if (!conversationId) return res.status(400).json({ ok: false, error: 'Missing conversationId' });
+    const result = usageLimitPauseService.cancel({ conversationId });
+    return res.json({ ok: true, cancelled: !!result.cancelled, messageId: result.messageId || null, pause: result.state });
+  });
+
   app.get('/api/restart-orchestrator', auth, (req, res) => {
     ensureSessionId(req, res);
     return res.json({ orchestrator: relayRestartOrchestrator?.getState?.() || null });

package/server/server-runtime.mjs

@@ -56,6 +56,7 @@ import { sweepUnreferencedUploads, UNREFERENCED_UPLOADS_QUERY } from './services
 import webpush from 'web-push';
 import { createPushDispatchService, ensurePushVapidKeys } from './services/push-dispatch-service.mjs';
 import { createHostSuspendService } from './services/host-suspend-service.mjs';
+import { USAGE_LIMIT_ACCOUNT_SOCKET_EVENT, createUsageLimitPauseService } from './services/usage-limit-pause-service.mjs';
 import { createGitHubCiActivityService } from './services/github-ci-activity-service.mjs';
 import { runHostSuspendToRam } from './services/host-suspend-command.mjs';
 import { createActiveDeviceTracker } from './services/push-active-device-service.mjs';
@@ -113,6 +114,7 @@ import {
   resolveLaunchWorkspaceRootPath,
 } from './services/workspace-root-defaults-service.mjs';
 import { maybeStartTtyConsole } from './tty-console-bootstrap.mjs';
+import { installRelayConsoleLog, resolveRelayConsoleLogPath } from './services/relay-console-log.mjs';
 import {
   computeFeatureFlagState,
   FEATURE_REGISTRY,
@@ -186,11 +188,18 @@ const PWA_SW_PATH = path.join(PUBLIC_DIR, 'sw.js');
 const SOCKET_IO_CLIENT_JS_PATH = path.join(__dirname, '..', 'node_modules', 'socket.io', 'client-dist', 'socket.io.js');
 const APP_CONFIG_PLACEHOLDER = /window\.__COPILOT_APP_CONFIG = \{ basePath: '[^']*' \};/;
 const PWA_VERSION_PLACEHOLDER = /const __PWA_VERSION = '[^']*';/;
+// The console goes to a terminal, a tmux pane or nowhere: keep a copy to read
+// after a restart or an incident.
+const relayConsoleLog = installRelayConsoleLog({
+  logPath: resolveRelayConsoleLogPath({ env: process.env, serverDir: __dirname }),
+});
 const ttyConsoleRuntime = await maybeStartTtyConsole({
   serverDir: __dirname,
   logsDir: path.join(__dirname, 'logs'),
   logger: console,
 });
+// The terminal console takes the console's methods over when it starts.
+relayConsoleLog?.rewrap();
 
 // ─── Config ────────────────────────────────────────────────────────────────────
 const CONFIG_PATH    = process.env.COPILOT_WEB_RELAY_CONFIG
@@ -1599,6 +1608,7 @@ const CURATED_MODEL_IDS = [
 ];
 
 let config = { ...DEFAULT_CONFIG };
+relayConsoleLog?.setSecrets(() => [config.authToken]);
 if (fs.existsSync(CONFIG_PATH)) {
   try { config = { ...config, ...JSON.parse(fs.readFileSync(CONFIG_PATH, 'utf8')) }; }
   catch (e) { console.error('Failed to read config.json, using defaults.'); }
@@ -4964,12 +4974,19 @@ function collectHostActivity({ request = null } = {}) {
     if (!conversationId) continue;
     hostSuspendWatchedConversationIds.add(conversationId);
     const count = Number(row.cnt || 0);
+    // A turn paused at the Claude usage limit is work still owed: the host
+    // stays up for one that resumes by itself, not for one that waits for
+    // the user.
+    const pause = count === 1 ? usageLimitPauseService.getPause(conversationId) : null;
+    if (pause && !pause.auto) continue;
     blockers.push({
       kind: 'turn',
       conversationId,
       title: hostActivityTitle(conversationId, row.title),
       count,
-      detail: count > 1 ? `${count} turns running` : 'turn running',
+      detail: pause
+        ? `turn paused at the Claude ${pause.label} until ${pause.resumeAt}`
+        : (count > 1 ? `${count} turns running` : 'turn running'),
     });
   }
   for (const [key, entry] of backgroundTaskStore.sets) {
@@ -5017,6 +5034,15 @@ const hostSuspendService = createHostSuspendService({
   },
 });
 
+const usageLimitPauseService = createUsageLimitPauseService({
+  db,
+  stmts,
+  emit: (event, payload) => io.emit(event, payload),
+  // A follow-up resumed by hand is due at once: wake its worker.
+  onQueueChanged: (reason) => { void primePendingSessionWorkers(reason); },
+  logger: console,
+});
+
 // The live turn among a conversation's processing rows. Mid-turn steering can
 // leave several processing at once — the running turn, steered messages the
 // CLI folded into it (no output of their own), a handed-off row still settling
@@ -6182,6 +6208,9 @@ const runtimeState = {
   get ttyConsoleActive() { return Boolean(ttyConsoleRuntime?.tty); },
   get relayShutdown() { return getRelayShutdownState(); },
   get hostSuspend() { return hostSuspendService.getState(); },
+  get usageLimit() {
+    return { account: usageLimitPauseService.getAccountState(), pauses: usageLimitPauseService.listPauses() };
+  },
   get activeBridgeOwner() { return relayBridgeOwnerService.getOwner(); },
   get workerWebSocketStatus() { return sessionWorkerWebSocketService.status(); },
   get tmuxInspectorStatus() { return tmuxInspectorSocketService.status(); },
@@ -6238,7 +6267,7 @@ const remoteRelayPairing = createRemoteRelayPairing({
 });
 // What the inbound routes need: no tokens, only ids, names and state.
 const remoteRelayInbound = {
-  listRelays: () => remoteRelayRegistry.list().map(({ id, name, url, lastStatus, version }) => ({ id, name, url, lastStatus, version })),
+  listRelays: () => remoteRelayRegistry.list().map(({ id, relayId, name, url, lastStatus, version }) => ({ id, relayId, name, url, lastStatus, version })),
   selfNames: () => [remoteRelayRegistry.selfName()],
   inboundEnabled: () => remoteRelayRegistry.getSelfSettings().inboundEnabled,
   recordUnlock: (conversationId, relayId, messageId) => remoteRelayRepository?.recordUnlock(conversationId, relayId, messageId) ?? false,
@@ -6461,6 +6490,7 @@ const sharedRouteDeps = {
   relayShutdownStatePayload,
   hostSuspendService,
   collectHostActivity,
+  usageLimitPauseService,
   markSharedViewerPresence,
   getSharedWatcherCount,
   statusEventService,
@@ -6851,6 +6881,7 @@ io.on('connection', (socket) => {
   // Pending host suspend / relay restart banners must survive a reconnect.
   try { socket.emit('host_suspend_state', hostSuspendService.getState()); } catch {}
   try { socket.emit('relay_shutdown_state', relayShutdownStatePayload()); } catch {}
+  try { socket.emit(USAGE_LIMIT_ACCOUNT_SOCKET_EVENT, usageLimitPauseService.getAccountState()); } catch {}
   // Visibility heartbeats for push suppression; also clears a stale
   // deviceVisible flag restored by connectionStateRecovery.
   activeDeviceTracker.registerSocket(socket);

package/server/services/preview-proxy-server.mjs

@@ -239,6 +239,11 @@ function guardConnectTimeout(upstreamReq, timeoutMs, onTimeout) {
   });
 }
 
+// Requests the lane sends a second time when the connection it kept to the
+// dev server turns out to be closed, and what such a connection fails with.
+const REPEATABLE_METHODS = new Set(['GET', 'HEAD', 'OPTIONS']);
+const STALE_CONNECTION_CODES = new Set(['ECONNRESET', 'EPIPE']);
+
 export function createPreviewProxyServer({
   registry,
   logger = console,
@@ -327,46 +332,69 @@ export function createPreviewProxyServer({
       bearerTokens: relayBearerTokens,
     });
 
-    const upstreamReq = httpImpl.request({
-      host: entry.targetHost,
-      port: entry.targetPort,
-      method: req.method,
-      path: upstreamPath,
-      headers,
-      agent,
-    });
-
-    let timedOut = false;
-    guardConnectTimeout(upstreamReq, connectTimeoutMs, () => { timedOut = true; });
+    // A request without a body can be sent a second time.
+    const repeatable = REPEATABLE_METHODS.has(String(req.method || '').toUpperCase())
+      && !(Number(req.headers['content-length']) > 0)
+      && !req.headers['transfer-encoding'];
+    let upstreamReq = null;
+
+    const forward = ({ again = false } = {}) => {
+      const current = httpImpl.request({
+        host: entry.targetHost,
+        port: entry.targetPort,
+        method: req.method,
+        path: upstreamPath,
+        headers,
+        agent,
+      });
+      upstreamReq = current;
+
+      let timedOut = false;
+      guardConnectTimeout(current, connectTimeoutMs, () => { timedOut = true; });
+
+      current.on('response', (upstreamRes) => {
+        const outHeaders = sanitizeResponseHeaders(upstreamRes.headers, {
+          basePath: entry.basePath,
+          targetHost: entry.targetHost,
+          targetPort: entry.targetPort,
+        });
+        res.writeHead(upstreamRes.statusCode || 502, outHeaders);
+        // 204/304 and HEAD carry no body; piping one would desync the connection.
+        if (req.method === 'HEAD' || upstreamRes.statusCode === 204 || upstreamRes.statusCode === 304) {
+          upstreamRes.resume();
+          res.end();
+          return;
+        }
+        upstreamRes.pipe(res);
+        upstreamRes.on('error', () => { try { res.destroy(); } catch {} });
+      });
 
-    upstreamReq.on('response', (upstreamRes) => {
-      const outHeaders = sanitizeResponseHeaders(upstreamRes.headers, {
-        basePath: entry.basePath,
-        targetHost: entry.targetHost,
-        targetPort: entry.targetPort,
+      current.on('error', (error) => {
+        if (upstreamReq !== current) return;
+        // The connection was kept from an earlier request, and the dev server
+        // has closed it since (it exited, or was restarted): that says nothing
+        // about the server now. One more try on a connection of its own either
+        // reaches the restarted server or says that nothing is listening.
+        if (!again && repeatable && current.reusedSocket && !res.headersSent && !res.destroyed
+          && STALE_CONNECTION_CODES.has(String(error?.code || ''))) {
+          forward({ again: true });
+          return;
+        }
+        const refused = String(error?.code || '') === 'ECONNREFUSED';
+        const detail = refused || timedOut
+          ? `Nothing is listening on <code>${escapeHtml(entry.targetHost)}:${entry.targetPort}</code>. The dev server behind this preview has probably exited — restart it on the same port and reload; this link stays valid.`
+          : `The upstream connection failed: <code>${escapeHtml(error?.code || error?.message || 'unknown error')}</code>.`;
+        sendErrorPage(res, 502, { title: 'Preview upstream unreachable', detail });
       });
-      res.writeHead(upstreamRes.statusCode || 502, outHeaders);
-      // 204/304 and HEAD carry no body; piping one would desync the connection.
-      if (req.method === 'HEAD' || upstreamRes.statusCode === 204 || upstreamRes.statusCode === 304) {
-        upstreamRes.resume();
-        res.end();
-        return;
-      }
-      upstreamRes.pipe(res);
-      upstreamRes.on('error', () => { try { res.destroy(); } catch {} });
-    });
 
-    upstreamReq.on('error', (error) => {
-      const refused = String(error?.code || '') === 'ECONNREFUSED';
-      const detail = refused || timedOut
-        ? `Nothing is listening on <code>${escapeHtml(entry.targetHost)}:${entry.targetPort}</code>. The dev server behind this preview has probably exited — restart it on the same port and reload; this link stays valid.`
-        : `The upstream connection failed: <code>${escapeHtml(error?.code || error?.message || 'unknown error')}</code>.`;
-      sendErrorPage(res, 502, { title: 'Preview upstream unreachable', detail });
-    });
+      // The second try has nothing left to read from the request.
+      if (again) current.end();
+      else req.pipe(current);
+    };
 
-    req.on('aborted', () => { try { upstreamReq.destroy(); } catch {} });
-    res.on('close', () => { try { upstreamReq.destroy(); } catch {} });
-    req.pipe(upstreamReq);
+    req.on('aborted', () => { try { upstreamReq?.destroy(); } catch {} });
+    res.on('close', () => { try { upstreamReq?.destroy(); } catch {} });
+    forward();
   }
 
   // WebSocket upgrades (Vite HMR, an app's own socket) ride the same prefix.