@oar-sh/oar 0.9.11 → 0.9.13

package/server/routes/messages-routes.mjs

@@ -16,6 +16,7 @@ import {
 import {
   persistConversationModelPreference as persistConversationModelPreferenceTx,
 } from '../services/conversation-preferences-service.mjs';
+import { fallbackReasoningEffort, inheritedConversationModel } from '../services/conversation-model-fallback.mjs';
 import { killTmuxSession } from '../services/session-worker-launch-service.mjs';
 import { normalizeWorkerSteeringSnapshot } from '../services/session-worker-registry-service.mjs';
 import {
@@ -42,6 +43,16 @@ import { DEFAULT_CLAUDE_REASONING_EFFORTS } from '../services/provider-reasoning
 import { claudeBaseModelId, claudeLongContextModelId } from '../../shared/model-id.mjs';
 import { sanitizeSubagentRunId } from '../../shared/subagent-run-id.mjs';
 import { normalizeBackgroundTaskDigest } from '../../shared/worker-runtime/background-task-digest.mjs';
+import {
+  DEFAULT_TASK_STALL_MINUTES,
+  TASK_OUTPUT_LIMITS,
+  cleanTaskText,
+  normalizeTaskCommand,
+  normalizeTaskOutputKind,
+  normalizeTaskOutputPath,
+} from '../../shared/task-output-text.mjs';
+import { readBefore, readTail, shapeSnapshot, taskOutputSource } from '../services/task-output-service.mjs';
+import { taskKindOf } from '../services/session-activity-tracker.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';
@@ -60,6 +71,7 @@ import { createStaleAttemptLogLimiter } from '../services/stale-attempt-log-limi
 import { createSubagentTimelinePublisher } from '../services/subagent-viewer-rooms.mjs';
 import { createLocalRequestCheck } from '../services/request-boundary.mjs';
 import { buildClaudeCloudDelivery, isClaudeCloudProviderType } from '../services/claude-cloud-session-service.mjs';
+import { TASK_OUTPUT_NONE_MESSAGES } from '../public/app/task-console-render.mjs';
 import {
   admitRemoteRelayRequest,
   readRemoteRelayRequest,
@@ -236,9 +248,17 @@ function findRecentDuplicateUserMessage({
   const exempt = new Set((Array.isArray(exemptMessageIds) ? exemptMessageIds : [])
     .map((id) => String(id || '').trim()).filter(Boolean));
   const isExempt = (row) => exempt.has(String(row?.id || '').trim());
+  // A message whose turn failed never ran, so sending it again is a retry,
+  // not a double submit. Only failed rows: a cancelled or finished turn stays
+  // a duplicate, as before.
+  const failedTurnIds = new Set((Array.isArray(recentQueueRows) ? recentQueueRows : [])
+    .filter((row) => String(row?.status || '').trim().toLowerCase() === 'failed')
+    .map((row) => String(row?.id || '').trim())
+    .filter(Boolean));
 
   for (const row of Array.isArray(recentUserMessages) ? recentUserMessages : []) {
     if (isExempt(row)) continue;
+    if (failedTurnIds.has(String(row?.id || '').trim())) continue;
     const rowText = normalizeDuplicateMessageText(row?.text || '');
     if (!rowText || rowText !== fingerprint) continue;
     const rowTime = Date.parse(row?.timestamp || '');
@@ -1779,6 +1799,15 @@ export function registerMessagesRoutes(app, deps) {
     buildRelayReadyBannerData,
     backgroundTaskStore,
     backgroundWorkView = null,
+    // The 8 KiB a worker posts for a task without an output file
+    // (services/task-output-service.mjs createTaskOutputSnapshots).
+    taskOutputSnapshots = null,
+    // Has the health poller read soon (a task with a console ended).
+    pokeTaskHealth = null,
+    // What a recovery did with a turn that was running when the relay
+    // started (services/restart-resume-service.mjs noteOutcome).
+    noteRestartTurnOutcome = () => {},
+    getTaskStallMinutes = () => DEFAULT_TASK_STALL_MINUTES,
     sendWorkerControl,
     ensureSessionId,
     touchCli,
@@ -2713,10 +2742,12 @@ export function registerMessagesRoutes(app, deps) {
         // quietly.
         stmts.dropStaleContinuation?.run?.(row.id);
         io.emit('message_status', { messageId: row.id, conversationId: row.conversation_id, status: 'failed' });
+        noteRestartTurnOutcome(row, 'cut');
         continue;
       }
       if (row.consumed_at) {
         failConsumedQueueRow(row, { reason });
+        noteRestartTurnOutcome(row, 'cut');
         continue;
       }
       const relayActivityRows = stmts.listActivityByQueueMessage?.all?.(row.id);
@@ -2753,6 +2784,7 @@ export function registerMessagesRoutes(app, deps) {
         error: reason,
       });
       io.emit('message_status', { messageId: row.id, conversationId: row.conversation_id, status: 'pending' });
+      noteRestartTurnOutcome(row, 'requeued');
     }
     for (const row of rowsToFail) {
       const failureRecord = buildHeartbeatIdleReplayFailure({
@@ -2778,6 +2810,8 @@ export function registerMessagesRoutes(app, deps) {
           ok: false,
           error: failureRecord.code,
         });
+        // Started, so not replayed: a turn the agent never heard the end of.
+        noteRestartTurnOutcome(row, 'cut');
       }
     }
     if (rowsToRecover.length || rowsToFail.length) {
@@ -4415,7 +4449,17 @@ export function registerMessagesRoutes(app, deps) {
     const requesterSessionId = normalizeSessionWorkerId(requesterIdentity?.sessionId);
     const sessionWorkerRoutingEnabled = isSessionWorkerRoutingEnabled(featureFlags);
     let conversationSdkSessionId = null;
-    const requestedRelayMode = normalizeRelayMode(relayMode || mode);
+    // The conversation's saved choices, for a send that leaves one out: a
+    // send to an existing conversation that names no mode runs in the mode
+    // the conversation is in, not the relay default.
+    const existingConversation = (!newConversation && conversationId)
+      ? (stmts.getConvAnyStatus?.get?.(conversationId) || null)
+      : null;
+    const explicitRelayModeGiven = !!String(relayMode || mode || '').trim();
+    const savedRelayMode = !explicitRelayModeGiven && existingConversation?.preferred_relay_mode
+      ? normalizeRelayMode(existingConversation.preferred_relay_mode)
+      : null;
+    const requestedRelayMode = savedRelayMode || normalizeRelayMode(relayMode || mode);
     const trimmedText = stripRelayPromptContext(text, requestedRelayMode || relayMode || mode);
     const normalizedAttachments = normalizeAttachments(rawAttachments);
     const requestedAttachmentCount = Math.min(
@@ -4772,6 +4816,34 @@ export function registerMessagesRoutes(app, deps) {
     // sends set_model before the message), so a changed model is taken as
     // for a local Claude chat.
     const claudeCloudModel = claudeCloudModelSelection ? claudeCloudModelSelection.model : '';
+    // What the request itself chose. Only these are saved as the
+    // conversation's preference; a value filled in below never is.
+    const explicitModelGiven = !!requestedOpenAIModel;
+    const conversationReasoningEffort = String(existingConversation?.preferred_reasoning_effort || '').trim().toLowerCase();
+    // A Copilot conversation sent no model keeps its own: the saved
+    // preference, the runtime session's model, the latest user message's,
+    // and the catalog default only when it has none of these. A model the
+    // catalog no longer lists is refused rather than swapped for another.
+    const usesGitHubCatalog = !useOpenAIProvider && !runtimeBoundToExplicitProvider;
+    const inheritedModel = usesGitHubCatalog && !shouldCreateConversation && !explicitModelGiven
+      ? inheritedConversationModel({
+          conversation: existingConversation,
+          runtimeSession: existingRuntimeSession,
+          latestUserMessageModel: stmts.getLatestUserMessageModel?.get?.(conversationId)?.model || '',
+        })
+      : null;
+    const githubModelResolution = usesGitHubCatalog
+      ? resolveRequestedModel(inheritedModel ? inheritedModel.model : model)
+      : null;
+    if (inheritedModel && !githubModelResolution?.ok) {
+      return res.status(409).json({
+        error: `This conversation's model "${inheritedModel.model}" is no longer available. Choose a model and send again.`,
+        code: 'CONVERSATION_MODEL_UNAVAILABLE',
+        conversationId,
+        model: inheritedModel.model,
+        supportedModels: githubModelResolution?.available || [],
+      });
+    }
     const modelResolution = useOpenAIProvider
       ? {
           ok: !!openAIModel,
@@ -4812,7 +4884,7 @@ export function registerMessagesRoutes(app, deps) {
                   reasoningEffort: null,
                   error: claudeCloudModel ? null : 'Claude Cloud model is not configured',
                 }
-              : resolveRequestedModel(model)))));
+              : githubModelResolution))));
     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;
@@ -4837,6 +4909,15 @@ export function registerMessagesRoutes(app, deps) {
         code: 'IMAGE_TARGET_REQUIRES_IMAGE_MODEL',
       });
     }
+    // A send that names no effort runs with the conversation's own, clamped
+    // to the nearest level the model has. Null when there is nothing to keep
+    // or it neither matches nor clamps (an ultracode on a model without it):
+    // the provider's own default applies then.
+    const conversationEffortFor = (supported) => (
+      !explicitReasoningEffort && conversationReasoningEffort
+        ? (fallbackReasoningEffort([conversationReasoningEffort], supported, { fallback: '' }) || null)
+        : null
+    );
     // Claude conversations validate effort against the Claude provider's
     // per-model levels ('none' = SDK default). Effort is per-turn: each Claude
     // turn is a fresh query(), so it can change between messages.
@@ -4845,6 +4926,8 @@ export function registerMessagesRoutes(app, deps) {
       const supported = Array.isArray(configuredClaude?.effortsByModel?.[String(requestedModel || '').trim().toLowerCase()])
         ? configuredClaude.effortsByModel[String(requestedModel || '').trim().toLowerCase()]
         : [...DEFAULT_CLAUDE_REASONING_EFFORTS];
+      const kept = conversationEffortFor(supported);
+      if (kept) return { ok: true, effort: kept, supported };
       const effort = supported.includes(requestedEffort) ? requestedEffort : 'none';
       return { ok: true, effort: effort === 'none' ? 'none' : effort, supported };
     };
@@ -4860,8 +4943,11 @@ export function registerMessagesRoutes(app, deps) {
         // the worker validates it against the resolved model's live params
         // and falls back to the model default on any mismatch. Clamping to
         // 'none' here would actively disable thinking on the resolved model.
-        return { ok: true, effort: requestedEffort, supported: [] };
+        // The conversation's own effort goes through the same way.
+        return { ok: true, effort: requestedEffort || conversationReasoningEffort, supported: [] };
       }
+      const kept = conversationEffortFor(discovered);
+      if (kept) return { ok: true, effort: kept, supported: discovered };
       const effort = discovered.includes(requestedEffort) ? requestedEffort : 'none';
       return { ok: true, effort, supported: discovered };
     };
@@ -4870,11 +4956,16 @@ export function registerMessagesRoutes(app, deps) {
       const supported = Array.isArray(configuredGrok?.effortsByModel?.[String(requestedModel || '').trim().toLowerCase()])
         ? configuredGrok.effortsByModel[String(requestedModel || '').trim().toLowerCase()]
         : ['none', 'low', 'medium', 'high'];
+      const kept = conversationEffortFor(supported);
+      if (kept) return { ok: true, effort: kept, supported };
       const effort = supported.includes(requestedEffort) ? requestedEffort : 'none';
       return { ok: true, effort, supported };
     };
     let reasoningResolution = useOpenAIProvider
-      ? resolveOpenAIReasoningEffort(explicitReasoningEffort, openAIModel)
+      ? resolveOpenAIReasoningEffort(
+          explicitReasoningEffort || conversationEffortFor(openAIReasoningEffortsForModel(openAIModel)) || '',
+          openAIModel,
+        )
       : (runtimeUsesClaude
         ? resolveClaudeReasoningEffort()
         : (runtimeUsesCursor
@@ -4888,15 +4979,21 @@ export function registerMessagesRoutes(app, deps) {
                   requestedModel,
                   explicitReasoningEffort || modelResolution.reasoningEffort || null,
                 )))));
+    // No effort sent (or the model's variant carried one it lacks): the
+    // conversation's own effort, clamped to the model's levels, else its
+    // lowest level that is not 'none'. Some models list 'none' and the API
+    // still refuses it, so it is taken only when the conversation chose it or
+    // the model has nothing else.
     if (!reasoningResolution?.ok && !explicitReasoningEffort) {
       const supportedEfforts = Array.isArray(reasoningResolution?.supported)
         ? reasoningResolution.supported.map((value) => String(value || '').trim().toLowerCase()).filter(Boolean)
         : [];
-      const fallbackReasoningEffort = supportedEfforts.includes('none')
-        ? 'none'
-        : (supportedEfforts[0] || null);
-      if (fallbackReasoningEffort) {
-        reasoningResolution = resolveRequestedReasoningEffort(requestedModel, fallbackReasoningEffort);
+      const fallbackEffort = fallbackReasoningEffort(
+        [modelResolution.reasoningEffort, conversationReasoningEffort],
+        supportedEfforts,
+      );
+      if (fallbackEffort) {
+        reasoningResolution = resolveRequestedReasoningEffort(requestedModel, fallbackEffort);
       }
     }
     if (!reasoningResolution?.ok) {
@@ -4906,6 +5003,9 @@ export function registerMessagesRoutes(app, deps) {
       });
     }
     const requestedReasoningEffort = reasoningResolution.effort || null;
+    // The request's own effort: sent as such, or carried by the variant id of
+    // a model it named.
+    const explicitEffortGiven = !!explicitReasoningEffort || (explicitModelGiven && !!modelResolution.reasoningEffort);
     let normalizedContextTier = requestedContextTier;
     if (openAIImageModel) {
       normalizedContextTier = normalizeOpenAIImageSize(requestedContextTier) || 'auto';
@@ -4950,6 +5050,7 @@ export function registerMessagesRoutes(app, deps) {
       return res.json({
         ok: true,
         duplicate: true,
+        queued: false,
         alreadyResent: true,
         duplicateOfMessageId: resend.alreadyResentAs,
         conversationId,
@@ -4980,6 +5081,8 @@ export function registerMessagesRoutes(app, deps) {
         return res.json({
           ok: true,
           duplicate: true,
+          // Said outright for a caller that reads only `ok`: nothing new runs.
+          queued: false,
           duplicateWindowMs: DUPLICATE_USER_MESSAGE_WINDOW_MS,
           duplicateSource: duplicateMessage.source,
           duplicateOfMessageId: duplicateMessage.messageId,
@@ -5161,15 +5264,25 @@ export function registerMessagesRoutes(app, deps) {
       }
       // 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
-        ? readConversationModelPreference(convId, requestedRelayMode)
-        : persistConversationModelPreference(
+      // Any other send to an existing conversation saves only what it named:
+      // a model or an effort filled in from a fallback is never written back
+      // as the conversation's choice (an empty effort keeps the stored one).
+      const savedModel = String(existingConversation?.preferred_model || '').trim();
+      if (shouldCreateConversation) {
+        conversationPreferences = persistConversationModelPreference(
+          convId, requestedRelayMode, requestedModel, requestedReasoningEffort, now,
+        );
+      } else if (remoteRequest.remote || (!explicitModelGiven && !(explicitEffortGiven && savedModel))) {
+        conversationPreferences = readConversationModelPreference(convId, requestedRelayMode);
+      } else {
+        conversationPreferences = persistConversationModelPreference(
           convId,
           requestedRelayMode,
-          requestedModel,
-          requestedReasoningEffort,
+          explicitModelGiven ? requestedModel : savedModel,
+          explicitEffortGiven ? requestedReasoningEffort : '',
           now,
         );
+      }
       stmts.insertQ.run(
         msgId,
         convId,
@@ -5468,6 +5581,7 @@ export function registerMessagesRoutes(app, deps) {
           io.emit('background_tasks', {
             conversationId: requesterSessionId,
             tasks: backgroundWorkView.panelTasks(requesterSessionId, requesterConversationId),
+            endedTasks: backgroundTaskStore?.ended?.(requesterSessionId) || [],
           });
         }
       }
@@ -5512,6 +5626,9 @@ export function registerMessagesRoutes(app, deps) {
         const leaseExpiresAt = addMsToIso(now, SESSION_WORKER_OWNER_LEASE_MS);
         for (const id of activeQueueMessageIds) {
           refreshProcessingLeaseForOwnedMessage.run(leaseExpiresAt, now, id, requesterSessionId);
+          // The worker has the turn: if it was running when the relay
+          // started, the restart did not cut it off.
+          noteRestartTurnOutcome({ id }, 'claimed');
         }
         recoverOwnedProcessingRowsForSession(requesterSessionId, {
           excludeMessageIds: activeQueueMessageIds,
@@ -6555,7 +6672,17 @@ export function registerMessagesRoutes(app, deps) {
       || rawRestart === 1
       || String(rawRestart || '').trim().toLowerCase() === 'true'
       || String(rawRestart || '').trim() === '1';
-    const result = requestRelayShutdown({ reason, requestedBy, restart });
+    // `immediate` starts it now, without waiting for the running turns (the
+    // banner's "Restart now"); the answer names what it did not wait for.
+    const rawImmediate = req.body?.immediate;
+    const immediate = rawImmediate === true
+      || rawImmediate === 1
+      || String(rawImmediate || '').trim().toLowerCase() === 'true'
+      || String(rawImmediate || '').trim() === '1';
+    // The banner's "Restart now" names the queued request it saw (see
+    // services/relay-restart-queue.mjs); a stale one is refused.
+    const expectRequestedAt = String(req.body?.expectRequestedAt || '').trim().slice(0, 40) || null;
+    const result = requestRelayShutdown({ reason, requestedBy, restart, immediate, expectRequestedAt });
     return res.json({ ok: true, ...result });
   });
 
@@ -7629,6 +7756,34 @@ export function registerMessagesRoutes(app, deps) {
     res.json({ ok: true, messageId, conversationId, attemptId });
   });
 
+  // An integer from a worker's post, or undefined (dropped from the row).
+  function wholeNumber(value, { min = Number.MIN_SAFE_INTEGER } = {}) {
+    if (value === null || value === undefined || value === '' || typeof value === 'boolean') return undefined;
+    const number = Number(value);
+    return Number.isSafeInteger(number) && number >= min ? number : undefined;
+  }
+
+  // A task row's console fields as the publish route keeps them.
+  function taskOutputFields(task) {
+    const outputPath = normalizeTaskOutputPath(task?.outputPath);
+    const requestedKind = String(task?.outputKind || '').trim();
+    if (!outputPath && !requestedKind) return {};
+    const outputKind = normalizeTaskOutputKind(requestedKind, outputPath);
+    // A file kind without a readable path has nothing to show.
+    if ((outputKind === 'file' || outputKind === 'spool') && !outputPath) return { outputKind: 'none' };
+    return { ...(outputPath ? { outputPath } : {}), outputKind };
+  }
+
+  // `background_tasks` with the health readings on the live rows and the
+  // ended rows beside them, for the key the worker posts under.
+  function emitBackgroundTasks(key, tasks = backgroundTaskStore?.get?.(key) || []) {
+    io.emit('background_tasks', {
+      conversationId: key,
+      tasks: backgroundTaskStore?.withHealth ? backgroundTaskStore.withHealth(tasks, key) : tasks,
+      endedTasks: backgroundTaskStore?.ended?.(key) || [],
+    });
+  }
+
   function resolveTaskConversationId(id) {
     const key = String(id || '').trim();
     if (!key) return '';
@@ -7648,14 +7803,36 @@ export function registerMessagesRoutes(app, deps) {
     const conversationId = resolveTaskConversationId(req.body?.conversationId);
     const taskId = String(req.body?.taskId || '').trim();
     if (!conversationId || !taskId) return res.status(400).json({ error: 'Missing conversationId or taskId' });
-    const exitCode = Number(req.body?.exitCode);
-    const settledDescription = String(req.body?.description || '').trim().slice(0, 500);
+    // Only a number the worker sent: a missing or null exit code stays null
+    // (Number(null) would read as a clean exit).
+    const exitCode = wholeNumber(req.body?.exitCode);
+    // Scrubbed like the output: a description can be the command line.
+    const settledDescription = cleanTaskText(String(req.body?.description || ''), 500);
+    // The store is keyed as the worker posts. A task with a console stays
+    // viewable as an ended row; one that ended while this runtime was away
+    // becomes one when the post names its output.
+    const settledOutputPath = normalizeTaskOutputPath(req.body?.outputPath);
+    const endedRow = backgroundTaskStore?.settle?.(String(req.body?.conversationId || '').trim(), taskId, {
+      status: req.body?.status,
+      exitCode: exitCode ?? null,
+      steps: wholeNumber(req.body?.steps, { min: 0 }),
+      outputPath: settledOutputPath || undefined,
+      outputKind: settledOutputPath ? normalizeTaskOutputKind(req.body?.outputKind, settledOutputPath) : undefined,
+      description: settledDescription,
+      command: normalizeTaskCommand(req.body?.command) || undefined,
+      taskType: String(req.body?.taskType || '').trim().slice(0, 80),
+      startedAt: Number(req.body?.startedAt) || null,
+    }) || null;
+    if (endedRow) {
+      emitBackgroundTasks(String(req.body?.conversationId || '').trim());
+      pokeTaskHealth?.();
+    }
     sessionActivityTracker?.noteTaskSettled?.(conversationId, {
       taskId,
       toolUseId: sanitizeSubagentRunId(req.body?.toolUseId) || null,
       status: String(req.body?.status || '').trim().slice(0, 40) || 'completed',
-      summary: String(req.body?.summary || '').trim().slice(0, 500) || null,
-      exitCode: Number.isInteger(exitCode) ? exitCode : null,
+      summary: cleanTaskText(String(req.body?.summary || ''), 500) || null,
+      exitCode: exitCode ?? null,
       // What the task was, from a worker that sends it: the end of a task
       // this runtime never knew (it ended while the relay was away) is
       // still an event then.
@@ -7684,11 +7861,18 @@ export function registerMessagesRoutes(app, deps) {
       .map((task) => ({
         taskId: String(task?.taskId || '').trim(),
         taskType: String(task?.taskType || '').trim(),
-        description: String(task?.description || '').trim().slice(0, 500),
+        // Scrubbed like the output before anything keeps or sends them: a
+        // description can be the command line (Grok's terminals, a Copilot
+        // shell without one), a summary or tool call can quote one.
+        description: cleanTaskText(String(task?.description || ''), 500),
+        // A shell task's command line, where the worker knows it: scrubbed
+        // like the output and cut at 2,000 characters before it is kept, so
+        // every reader (the pages, read_session, the stored row) gets it so.
+        command: normalizeTaskCommand(task?.command) || undefined,
         startedAt: Number(task?.startedAt) || null,
-        summary: String(task?.summary || '').trim().slice(0, 500) || null,
+        summary: cleanTaskText(String(task?.summary || ''), 500) || null,
         lastToolName: String(task?.lastToolName || '').trim() || null,
-        lastToolCall: String(task?.lastToolCall || '').replace(/\s+/g, ' ').trim().slice(0, 300) || null,
+        lastToolCall: cleanTaskText(String(task?.lastToolCall || '').replace(/\s+/g, ' '), 300) || null,
         totalTokens: Number.isFinite(Number(task?.totalTokens)) ? Number(task.totalTokens) : null,
         subagentType: String(task?.subagentType || '').trim().slice(0, 120) || null,
         model: String(task?.model || '').trim().slice(0, 120) || null,
@@ -7702,8 +7886,23 @@ export function registerMessagesRoutes(app, deps) {
         // The spawning tool_use id: the sub-agent run this task is. The panel
         // opens the run's viewer from it.
         toolUseId: sanitizeSubagentRunId(task?.toolUseId) || undefined,
+        // The console (shell and Monitor tasks): the file holding the
+        // output, how it is obtained ('none': the provider has none to give).
+        ...taskOutputFields(task),
+        // Tool calls a sub-agent made so far.
+        steps: wholeNumber(task?.steps, { min: 0 }),
+        exitCode: wholeNumber(task?.exitCode),
       }))
       .filter((task) => task.taskId);
+    // The first path a task names wins: a later post cannot point a live
+    // task's console at another file.
+    for (const task of tasks) {
+      const held = (backgroundTaskStore?.get?.(conversationId) || []).find((entry) => entry?.taskId === task.taskId);
+      if (held?.outputPath && task.outputPath !== held.outputPath) {
+        task.outputPath = held.outputPath;
+        task.outputKind = held.outputKind;
+      }
+    }
     const resync = req.body?.resync === true;
     // Posts can overtake each other on the way (an ordinary publish and the
     // answer to a resync, two publishes): a worker numbers its sets
@@ -7720,9 +7919,15 @@ export function registerMessagesRoutes(app, deps) {
       console.log(`[${typeof ts === 'function' ? ts() : new Date().toISOString()}] BG-TASKS set dropped (${setOrder.reason}) session=${conversationId.slice(0, 8)} epoch=${Number(req.body?.order?.epoch) || 0} seq=${Number(req.body?.order?.seq) || 0} tasks=${tasks.length}`);
       return res.json({ ok: true, count: tasks.length, stale: true, reason: setOrder.reason });
     }
+    // A task with a console that leaves the set ended: its file is read once
+    // more soon (its last output often lands after the poller's last look).
+    const nextIds = new Set(tasks.map((task) => task.taskId));
+    const endedWithConsole = (backgroundTaskStore?.get?.(conversationId) || [])
+      .some((task) => task?.outputPath && !nextIds.has(task.taskId));
     backgroundTaskStore?.replace?.(conversationId, tasks);
     backgroundTaskStore?.announce?.(conversationId, false);
-    io.emit('background_tasks', { conversationId, tasks });
+    if (endedWithConsole) pokeTaskHealth?.();
+    emitBackgroundTasks(conversationId, tasks);
     // The store is keyed as the worker posts (its SDK session id); the
     // tracker by the conversation.
     try {
@@ -7769,6 +7974,175 @@ export function registerMessagesRoutes(app, deps) {
     res.json({ ok: true });
   });
 
+  // ─── Task console ──────────────────────────────────────────────────────────
+
+  // The task a conversation's console asks for: in the live or the ended set
+  // of the conversation, under its own id or its worker's session id (the
+  // key the worker posts under), as the stop route resolves it.
+  function findConversationTask(conversationId, taskId) {
+    const conversation = stmts.getConvAnyStatus?.get?.(conversationId) || null;
+    if (!conversation) return { conversation: null, found: null, sessionId: '' };
+    const sessionId = String(conversation.sdk_session_id || conversationId);
+    const found = backgroundTaskStore?.findTask?.([conversationId, sessionId], taskId) || null;
+    return { conversation, found, sessionId };
+  }
+
+  // The providers whose workers name a shell task's output (a file, a spool
+  // or a snapshot). A task of theirs without one comes from a worker that
+  // started before the console existed.
+  const TASK_OUTPUT_PROVIDERS = new Set(['claude', 'github', 'copilot', 'grok']);
+  const SUBAGENT_OUTPUT_MESSAGE = TASK_OUTPUT_NONE_MESSAGES.subagent;
+
+  // Why a task has no output to show, for the console's `none` answer. The
+  // texts are the page's own (task-console-render.mjs), so the row's hover
+  // title and the console say the same.
+  function noOutputMessage(conversationId, task) {
+    if (taskKindOf(task?.taskType) === 'subagent') return SUBAGENT_OUTPUT_MESSAGE;
+    let provider = '';
+    try {
+      provider = String(stmts.getRuntimeSessionByConversation?.get?.(conversationId)?.provider_type || '').trim().toLowerCase();
+    } catch {}
+    if (!provider || TASK_OUTPUT_PROVIDERS.has(provider)) {
+      return TASK_OUTPUT_NONE_MESSAGES.noOutputFile;
+    }
+    return TASK_OUTPUT_NONE_MESSAGES.provider;
+  }
+
+  // A task the session's task list shows that the task store does not hold:
+  // a sub-agent (live or ended, its run is its record) or a task that ended
+  // without a console. The activity tracker knows it by its task or run id.
+  function trackedTask(conversationId, taskId) {
+    let view = null;
+    try { view = sessionActivityTracker?.describe?.(conversationId) || null; } catch {}
+    const tasks = Array.isArray(view?.tasks) ? view.tasks : [];
+    const found = tasks.find((task) => !task?.placeholder && (String(task?.id || '') === taskId || String(task?.runId || '') === taskId));
+    if (found) return found;
+    const run = stmts.getSubagentRun?.get?.(taskId) || null;
+    if (run && String(run.conversation_id || '') === conversationId) {
+      return { id: taskId, kind: 'subagent', type: run.subagent_type || null, description: run.display_name || '', status: run.status || null };
+    }
+    return null;
+  }
+
+  function taskStallMinutes() {
+    try {
+      return getTaskStallMinutes();
+    } catch {
+      return DEFAULT_TASK_STALL_MINUTES;
+    }
+  }
+
+  // GET /api/conversation/:conversationId/background-task/:taskId/output —
+  // the console's read of a shell or Monitor task's output. Without
+  // `before`: the last `lines` lines (default 2,000, at most 5,000) within
+  // 256 KB; with `before` (a startOffset of an earlier answer): the lines
+  // ending there. Everything is cleaned (controls out, colours kept,
+  // credentials scrubbed) for every reader. Another relay's agent reads it
+  // too (remote_relay read_task_output, read permission): no inbound switch,
+  // nothing it reads changes anything.
+  app.get('/api/conversation/:conversationId/background-task/:taskId/output', auth, async (req, res) => {
+    const conversationId = String(req.params.conversationId || '').trim();
+    const taskId = String(req.params.taskId || '').trim();
+    if (!conversationId || !taskId) return res.status(400).json({ error: 'Missing conversationId or taskId' });
+    const { conversation, found, sessionId } = findConversationTask(conversationId, taskId);
+    if (!conversation) return res.status(404).json({ error: 'Conversation not found' });
+    if (!found) {
+      const tracked = trackedTask(conversationId, taskId);
+      if (!tracked) return res.status(404).json({ error: 'Task not found', code: 'task-not-found' });
+      const running = String(tracked.status || 'running') === 'running';
+      const subagent = tracked.kind !== 'shell';
+      return res.json({
+        ok: true,
+        taskId,
+        kind: 'none',
+        ended: !running,
+        status: running ? 'running' : String(tracked.status || 'unknown'),
+        exitCode: running ? null : (Number.isInteger(tracked.exitCode) ? tracked.exitCode : null),
+        health: null,
+        taskStallMinutes: taskStallMinutes(),
+        task: {
+          taskId,
+          taskType: tracked.type || (subagent ? 'local_agent' : 'local_bash'),
+          description: String(tracked.description || ''),
+          startedAt: Date.parse(tracked.startedAt) || null,
+          endedAt: Date.parse(tracked.endedAt) || null,
+          stoppable: false,
+        },
+        message: subagent ? SUBAGENT_OUTPUT_MESSAGE : noOutputMessage(conversationId, { taskType: 'local_bash' }),
+      });
+    }
+    const { task, ended, key } = found;
+    // Held since a relay restart: its worker has not said yet whether it
+    // still runs, so it is neither running nor stoppable.
+    const held = !ended && found.restored === true;
+    const { kind, path } = taskOutputSource(task);
+    const head = {
+      ok: true,
+      taskId,
+      kind,
+      ended,
+      status: ended ? task.status : (held ? 'held' : 'running'),
+      ...(held ? { held: true } : {}),
+      exitCode: ended ? (task.exitCode ?? null) : null,
+      health: task.health || null,
+      taskStallMinutes: taskStallMinutes(),
+      task: {
+        taskId,
+        taskType: task.taskType || null,
+        description: task.description || '',
+        ...(task.command ? { command: task.command } : {}),
+        startedAt: task.startedAt || null,
+        endedAt: task.endedAt || null,
+        stoppable: !ended && !held && task.stoppable !== false,
+      },
+    };
+    if (kind === 'none') {
+      return res.json({ ...head, message: noOutputMessage(conversationId, task) });
+    }
+    if (kind === 'snapshot') {
+      // The worker answers a request with a post of the task's last 8 KiB;
+      // the console asks again every few seconds and gets the newest copy.
+      const cached = taskOutputSnapshots?.get?.([key, sessionId, conversationId], taskId) || null;
+      if (!ended) {
+        const sent = sendWorkerControl?.(sessionId, { type: 'task_output_snapshot', taskId });
+        if (!sent && !cached) return res.status(409).json({ error: 'Session worker is not connected', code: 'worker-not-connected' });
+      }
+      if (!cached) return res.json({ ...head, pending: true, text: '', lines: [], startOffset: 0, endOffset: 0, size: 0, mtime: null, hasMoreBefore: false });
+      return res.json({ ...head, ...shapeSnapshot(cached) });
+    }
+    if (!path) return res.json({ ...head, kind: 'none', message: TASK_OUTPUT_NONE_MESSAGES.noPath });
+    const lines = req.query?.lines;
+    const before = req.query?.before;
+    const read = before !== undefined && before !== ''
+      ? await readBefore(path, { before, lines })
+      : await readTail(path, { lines });
+    if (!read.ok) {
+      // No file yet (a spool is named before its first byte) reads as no
+      // output yet; one the relay does not read (a symlink, a folder) is
+      // said so instead of failing.
+      const empty = { text: '', lines: [], startOffset: 0, endOffset: 0, size: 0, mtime: null, hasMoreBefore: false };
+      return res.json({ ...head, ...empty, ...(read.code === 'missing' ? {} : { unavailable: read.code }) });
+    }
+    return res.json({ ...head, ...read });
+  });
+
+  // POST /api/background-tasks/:taskId/output-snapshot — a worker's answer
+  // to `task_output_snapshot`: the task's latest output where it has no
+  // file (Claude's getTaskOutput, its last 8 KiB).
+  app.post('/api/background-tasks/:taskId/output-snapshot', auth, (req, res) => {
+    touchCli();
+    const key = String(req.body?.conversationId || '').trim();
+    const taskId = String(req.params.taskId || '').trim();
+    if (!key || !taskId) return res.status(400).json({ error: 'Missing conversationId or taskId' });
+    if (typeof req.body?.output !== 'string') return res.status(400).json({ error: 'output must be a string' });
+    taskOutputSnapshots?.set?.(key, taskId, {
+      output: req.body.output.slice(0, TASK_OUTPUT_LIMITS.chunkBytes),
+      totalBytes: req.body?.totalBytes,
+      truncated: req.body?.truncated === true,
+    });
+    res.json({ ok: true });
+  });
+
   // POST /api/activity — relay sends in-flight activity updates (tool/search sections)
   // Optional attempt fence for the live lanes (stream/thought/activity/
   // subagent): a writer that names its processing attempt is rejected once