@oar-sh/oar 0.9.10 → 0.9.12

package/server/routes/messages-routes.mjs

@@ -41,6 +41,15 @@ import { openAIReasoningEffortsForModel } from '../../shared/openai-reasoning.mj
 import { DEFAULT_CLAUDE_REASONING_EFFORTS } from '../services/provider-reasoning-effort.mjs';
 import { claudeBaseModelId, claudeLongContextModelId } from '../../shared/model-id.mjs';
 import { sanitizeSubagentRunId } from '../../shared/subagent-run-id.mjs';
+import { normalizeBackgroundTaskDigest } from '../../shared/worker-runtime/background-task-digest.mjs';
+import {
+  DEFAULT_TASK_STALL_MINUTES,
+  TASK_OUTPUT_LIMITS,
+  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';
@@ -57,9 +66,11 @@ import { RELAY_EVENT_MESSAGE_KIND } from '../../shared/relay-events.mjs';
 import { isRelayShutdownQueued, relayShutdownGateReply } from '../services/relay-shutdown-gate.mjs';
 import { createStaleAttemptLogLimiter } from '../services/stale-attempt-log-limiter.mjs';
 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 {
   admitRemoteRelayRequest,
+  readRemoteRelayRequest,
   findMentionedRemoteRelays,
   findOriginRemoteRelay,
   formatRemoteRelayOriginHint,
@@ -1775,6 +1786,13 @@ export function registerMessagesRoutes(app, deps) {
     getModelCatalogState,
     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,
+    getTaskStallMinutes = () => DEFAULT_TASK_STALL_MINUTES,
     sendWorkerControl,
     ensureSessionId,
     touchCli,
@@ -1811,6 +1829,10 @@ export function registerMessagesRoutes(app, deps) {
     relayRestartOrchestrator,
     requestRelayShutdown,
     cancelRelayShutdown = null,
+    // Truly local = loopback peer, no tunnel marker, no forwarding header
+    // (services/request-boundary.mjs). The runtime passes the check built
+    // with the configured marker headers.
+    isTrulyLocalRequest = createLocalRequestCheck().isTrulyLocal,
     featureFlags,
     sessionWorkerRegistry,
     sessionWorkerSupervisor,
@@ -1833,6 +1855,9 @@ export function registerMessagesRoutes(app, deps) {
     // agent-sent messages, the inbound switch, and mention unlocks. Absent in
     // older wiring and most tests, where every remote-relay step is a no-op.
     remoteRelayInbound = null,
+    // Session groups (repositories/conversation-group-repository.mjs): the
+    // group stop route. Absent in older wiring and most tests.
+    conversationGroups = null,
     // Relay event subscriptions (services/relay-event-service.mjs) and the
     // per-session activity they read (services/session-activity-tracker.mjs).
     // Absent in older wiring and most tests: every hook is then a no-op.
@@ -1936,21 +1961,6 @@ export function registerMessagesRoutes(app, deps) {
       || event.includes('blocked');
   }
 
-  function isLoopbackAddress(value) {
-    const text = String(value || '').trim().toLowerCase();
-    if (!text) return false;
-    return text === '127.0.0.1'
-      || text === '::1'
-      || text === '::ffff:127.0.0.1'
-      || text === '::ffff:7f00:1';
-  }
-
-  function isLoopbackRequest(req) {
-    const socketAddress = req?.socket?.remoteAddress;
-    const ipAddress = req?.ip;
-    return isLoopbackAddress(socketAddress) || isLoopbackAddress(ipAddress);
-  }
-
   function readBridgeIdentity(req) {
     return relayBridgeOwnerService?.normalizeIdentity?.({
       pid: req.headers['x-relay-process-pid'],
@@ -2966,36 +2976,54 @@ export function registerMessagesRoutes(app, deps) {
     if (!admitRemoteRelayRequest(req, res, remoteRelayInbound)) return;
     const conversationId = String(req.params.conversationId || '').trim();
     const requestedMessageId = String(req.body?.messageId || req.body?.queueMessageId || '').trim();
+    const outcome = requestTurnStop(conversationId, {
+      requestedMessageId,
+      clientId: String(req.body?.clientId || '').trim() || null,
+    });
+    if (!outcome.ok) return rejectSessionBinding(res, outcome.status, outcome.error);
+    return res.json(outcome.body);
+  });
+
+  /**
+   * The work of POST /api/conversation/:id/cancel-turn: an `abort_turn`
+   * control for the live turn. `{ ok: true, body }` with the route's answer,
+   * or `{ ok: false, status, error }` when the conversation is unknown.
+   */
+  function requestTurnStop(conversationId, { requestedMessageId = '', clientId = null } = {}) {
     const sessionState = getConversationSessionState(conversationId);
-    if (!sessionState.ok) {
-      return rejectSessionBinding(res, sessionState.status, sessionState.error);
-    }
+    if (!sessionState.ok) return { ok: false, status: sessionState.status, error: sessionState.error };
 
     // The live turn, not merely the newest processing row: a steered message
     // folded into the running turn is also `processing`, and Stop must target
     // the turn actually executing (which the worker interrupts as a whole).
     const queueRow = resolveLiveTurnQueueRow(conversationId) || null;
     if (!queueRow) {
-      return res.json({
+      return {
         ok: true,
-        queued: false,
-        acknowledgement: 'no-active-turn',
-        requestedMessageId: requestedMessageId || null,
-        activeMessageId: null,
-      });
+        body: {
+          ok: true,
+          queued: false,
+          acknowledgement: 'no-active-turn',
+          requestedMessageId: requestedMessageId || null,
+          activeMessageId: null,
+        },
+      };
     }
 
     const activeMessageId = String(queueRow.id || '').trim();
     if (requestedMessageId && activeMessageId && requestedMessageId !== activeMessageId) {
       const requestedRow = stmts.findQById.get(requestedMessageId) || null;
       const requestedStatus = String(requestedRow?.status || '').trim().toLowerCase();
-      return res.json({
+      return {
         ok: true,
-        queued: false,
-        acknowledgement: requestedStatus === 'processing' ? 'message-mismatch' : 'already-finished',
-        requestedMessageId,
-        activeMessageId,
-      });
+        body: {
+          ok: true,
+          queued: false,
+          acknowledgement: requestedStatus === 'processing' ? 'message-mismatch' : 'already-finished',
+          requestedMessageId,
+          activeMessageId,
+        },
+      };
     }
 
     const sdkSessionId = normalizeSessionWorkerId(
@@ -3004,33 +3032,39 @@ export function registerMessagesRoutes(app, deps) {
       || sessionState.conversationSdkSessionId,
     );
     if (!sdkSessionId) {
-      return res.json({
+      return {
         ok: true,
-        queued: false,
-        acknowledgement: 'active-turn-unbound',
-        requestedMessageId: activeMessageId || requestedMessageId || null,
-        activeMessageId,
-      });
+        body: {
+          ok: true,
+          queued: false,
+          acknowledgement: 'active-turn-unbound',
+          requestedMessageId: activeMessageId || requestedMessageId || null,
+          activeMessageId,
+        },
+      };
     }
 
     const existing = findActiveRelayControlByQueueMessage.get(activeMessageId, 'abort_turn') || null;
     if (existing) {
-      return res.json({
+      return {
         ok: true,
-        queued: true,
-        duplicate: true,
-        acknowledgement: 'already-requested',
-        requestedMessageId: activeMessageId || requestedMessageId || null,
-        activeMessageId,
-        control: formatRelayControlResponse(existing),
-      });
+        body: {
+          ok: true,
+          queued: true,
+          duplicate: true,
+          acknowledgement: 'already-requested',
+          requestedMessageId: activeMessageId || requestedMessageId || null,
+          activeMessageId,
+          control: formatRelayControlResponse(existing),
+        },
+      };
     }
 
     const now = new Date().toISOString();
     const controlId = uuidv4();
     const requestPayload = JSON.stringify({
       source: 'relay-ui',
-      requestedByClientId: String(req.body?.clientId || '').trim() || null,
+      requestedByClientId: clientId || null,
     });
     insertRelayControlRequest.run(
       controlId,
@@ -3043,14 +3077,59 @@ export function registerMessagesRoutes(app, deps) {
       now,
     );
     const control = getRelayControlRequestById.get(controlId) || null;
-    return res.json({
+    return {
       ok: true,
-      queued: true,
-      acknowledgement: 'stop-queued',
-      requestedMessageId: activeMessageId || requestedMessageId || null,
-      activeMessageId,
-      control: formatRelayControlResponse(control),
-    });
+      body: {
+        ok: true,
+        queued: true,
+        acknowledgement: 'stop-queued',
+        requestedMessageId: activeMessageId || requestedMessageId || null,
+        activeMessageId,
+        control: formatRelayControlResponse(control),
+      },
+    };
+  }
+
+  // POST /api/conversation-groups/:id/stop — "Stop all running" on a session
+  // group's head row: a stop for every member's live turn, and a stop for
+  // every stoppable background task. Tasks the panel shows no Stop button
+  // for are listed as `unstoppable`. The owner's action only: a paired
+  // relay's agent is refused.
+  app.post('/api/conversation-groups/:id/stop', auth, (req, res) => {
+    if (readRemoteRelayRequest(req, remoteRelayInbound).remote) {
+      return res.status(403).json({ error: 'Session groups are managed by this relay\'s owner only.' });
+    }
+    const groupId = String(req.params.id || '').trim();
+    const group = groupId ? conversationGroups?.getGroup?.(groupId) : null;
+    if (!group) return res.status(404).json({ ok: false, error: 'Group not found' });
+    const clientId = String(req.body?.clientId || '').trim() || null;
+    const turns = [];
+    const tasks = [];
+    const unstoppable = [];
+    for (const member of conversationGroups.membersOf(groupId)) {
+      if (member.archived) continue;
+      const outcome = requestTurnStop(member.id, { clientId });
+      if (outcome.ok && outcome.body.queued === true) turns.push({ id: member.id, messageId: outcome.body.activeMessageId });
+      const conversation = stmts.getConvAnyStatus?.get?.(member.id) || null;
+      const sessionId = String(conversation?.sdk_session_id || member.id);
+      const liveTasks = [...new Set([member.id, sessionId])].flatMap((key) => backgroundTaskStore?.get?.(key) || []);
+      for (const task of liveTasks) {
+        // The store holds what the publish route keeps: `taskId`.
+        const taskId = String(task?.taskId || '').trim();
+        if (!taskId) continue;
+        if (task?.stoppable === false) {
+          unstoppable.push({ id: member.id, taskId, reason: 'no-stop' });
+          continue;
+        }
+        const sent = sendWorkerControl?.(sessionId, { type: 'stop_background_task', taskId });
+        if (sent) tasks.push({ id: member.id, taskId });
+        else unstoppable.push({ id: member.id, taskId, reason: 'worker-not-connected' });
+      }
+    }
+    if (turns.length || tasks.length) {
+      console.log(`[${ts()}] GROUP STOP ${groupId.slice(0, 12)} turns=${turns.length} tasks=${tasks.length}`);
+    }
+    return res.json({ ok: true, turns, tasks, unstoppable });
   });
 
   app.post('/api/conversation/:conversationId/subagent/:subagentRunId/cancel', auth, (req, res) => {
@@ -5313,6 +5392,7 @@ export function registerMessagesRoutes(app, deps) {
     const requesterSessionId = normalizeSessionWorkerId(requester?.sessionId);
     const settleFailedHandled = [];
     const settleFailedSkipped = [];
+    let resyncBackgroundTasks = false;
     const activeQueueMessageId = String(req.body?.activeQueueMessageId || '').trim();
     // A persistent-process worker can hold several live rows at once (the
     // running turn plus a delivered message queued behind it plus a
@@ -5379,6 +5459,33 @@ export function registerMessagesRoutes(app, deps) {
         }
       }
       sessionWorkerSupervisor?.noteSessionHeartbeat?.(requesterSessionId);
+      // The worker's digest of its live background-task ids against the set
+      // held for it (keyed as the worker posts, by its session id). They
+      // differ after a relay restart, which starts with no sets, and after a
+      // lost post either way round: the answer then asks for the full set
+      // again. A worker that sends no digest has no opinion and is never
+      // asked; a relay that holds a set while the worker reports none asks
+      // too, and the empty answer ends those tasks.
+      // The process this beat comes from holds the session: a set post of
+      // another process is a late one (see the task route).
+      backgroundTaskStore?.noteHolder?.(requesterSessionId, normalizedRequesterPid);
+      const taskDigest = normalizeBackgroundTaskDigest(req.body?.backgroundTasks);
+      if (taskDigest && typeof backgroundTaskStore?.matches === 'function') {
+        resyncBackgroundTasks = !backgroundTaskStore.matches(taskDigest, requesterSessionId, requesterConversationId);
+      }
+      // The placeholder for background work this runtime was never told the
+      // details of (a worker that cannot resync yet): the pages hear when it
+      // appears and when it goes without a set having replaced it.
+      if (!resyncBackgroundTasks && backgroundWorkView) {
+        const unreported = backgroundWorkView.hasUnreportedWork(requesterSessionId) === true;
+        if (backgroundTaskStore?.announce?.(requesterSessionId, unreported)) {
+          io.emit('background_tasks', {
+            conversationId: requesterSessionId,
+            tasks: backgroundWorkView.panelTasks(requesterSessionId, requesterConversationId),
+            endedTasks: backgroundTaskStore?.ended?.(requesterSessionId) || [],
+          });
+        }
+      }
       // Consumed steers whose settle the worker could not save within its
       // retry budget (e.g. its writes keep failing): the relay fails them
       // itself with the worker's terminal error, never requeueing them.
@@ -5438,6 +5545,7 @@ export function registerMessagesRoutes(app, deps) {
       pendingCount,
       ...(settleFailedHandled.length ? { settleFailedHandled } : {}),
       ...(settleFailedSkipped.length ? { settleFailedSkipped } : {}),
+      ...(resyncBackgroundTasks ? { resyncBackgroundTasks: true } : {}),
     });
   });
 
@@ -6421,10 +6529,10 @@ export function registerMessagesRoutes(app, deps) {
     return res.json({ ok: true, recovered: rows.length, maxAgeMs });
   });
 
+  // Emptying the queue, restarting the relay and withdrawing a restart are
+  // the user's own maintenance actions: the browser app calls them from a
+  // phone, over the tunnel and over the LAN. The token is the boundary.
   app.post('/api/queue/empty', auth, (req, res) => {
-    if (!isLoopbackRequest(req)) {
-      return res.status(403).json({ error: 'Queue empty endpoint is localhost-only' });
-    }
     const rows = stmts.listQueueForPauseDrop.all();
     const droppedCount = rows.length;
     if (!droppedCount) {
@@ -6452,9 +6560,6 @@ export function registerMessagesRoutes(app, deps) {
   });
 
   app.post('/api/relay/shutdown', auth, (req, res) => {
-    if (!isLoopbackRequest(req)) {
-      return res.status(403).json({ error: 'Relay shutdown endpoint is localhost-only' });
-    }
     if (typeof requestRelayShutdown !== 'function') {
       return res.status(501).json({ error: 'Relay shutdown orchestration is unavailable' });
     }
@@ -6472,9 +6577,6 @@ export function registerMessagesRoutes(app, deps) {
   // Withdraw a queued (not yet started) shutdown/restart. Same trust boundary
   // as queueing one.
   app.post('/api/relay/shutdown/cancel', auth, (req, res) => {
-    if (!isLoopbackRequest(req)) {
-      return res.status(403).json({ error: 'Relay shutdown endpoint is localhost-only' });
-    }
     if (typeof cancelRelayShutdown !== 'function') {
       return res.status(501).json({ error: 'Relay shutdown orchestration is unavailable' });
     }
@@ -6483,9 +6585,11 @@ export function registerMessagesRoutes(app, deps) {
     return res.json({ ok: true, ...result });
   });
 
+  // Called by the relay's own worker on this machine; nothing that came in
+  // through a proxy or the tunnel may start a provider image request.
   app.post('/api/image-operations/:operationId/execute', auth, async (req, res) => {
-    if (!isLoopbackRequest(req)) {
-      return res.status(403).json({ error: 'Image operation execution is localhost-only' });
+    if (!isTrulyLocalRequest(req)) {
+      return res.status(403).json({ error: 'Image operation execution is reachable from this machine only' });
     }
     if (featureFlags?.IMAGE_CONVERSATION_CONTINUITY_ENABLED !== true) {
       return res.status(404).json({ error: 'Image continuity is not enabled' });
@@ -7540,6 +7644,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 '';
@@ -7559,13 +7691,42 @@ 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);
+    // 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);
+    const settledDescription = String(req.body?.description || '').trim().slice(0, 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,
+      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,
+      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.
+      ...(settledDescription ? {
+        description: settledDescription,
+        taskType: String(req.body?.taskType || '').trim().slice(0, 80),
+        startedAt: Number(req.body?.startedAt) || null,
+      } : {}),
     });
     relayEventService?.afterStateChange?.(conversationId);
     res.json({ ok: true });
@@ -7574,6 +7735,10 @@ export function registerMessagesRoutes(app, deps) {
   // POST /api/background-tasks — a session worker publishes its live
   // background-task set (REPLACE semantics, mirroring the SDK's
   // background_tasks_changed signal) so the composer panel tracks it live.
+  // `resync: true` marks the set as the answer to a heartbeat that asked for
+  // it again (`resyncBackgroundTasks`): the same replace, and the pages get
+  // the set again, but a task the relay had forgotten is not a new start.
+  // `order` lets the relay drop a set that a newer one overtook.
   app.post('/api/background-tasks', auth, (req, res) => {
     touchCli();
     const conversationId = String(req.body?.conversationId || '').trim();
@@ -7600,15 +7765,53 @@ 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
+    // (`order: { epoch, seq }`), and one older than the newest applied is
+    // dropped, or a task of the newer set would read as ended. A worker
+    // that numbers none is taken as it comes.
+    // A drop is never silent: it is logged, and the answer says `stale`,
+    // on which the worker asks for a heartbeat (which makes it the holder
+    // of the session if it was not yet, and has the relay ask for the set).
+    const setOrder = backgroundTaskStore?.acceptOrder?.(conversationId, req.body?.order, {
+      pid: readBridgeIdentity(req)?.pid,
+    });
+    if (setOrder && setOrder.accepted === false) {
+      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);
-    io.emit('background_tasks', { conversationId, tasks });
+    backgroundTaskStore?.announce?.(conversationId, false);
+    if (endedWithConsole) pokeTaskHealth?.();
+    emitBackgroundTasks(conversationId, tasks);
     // The store is keyed as the worker posts (its SDK session id); the
     // tracker by the conversation.
     try {
       const trackedConversationId = resolveTaskConversationId(conversationId);
-      sessionActivityTracker?.noteTaskSet?.(trackedConversationId, tasks);
+      sessionActivityTracker?.noteTaskSet?.(trackedConversationId, tasks, { resync });
       relayEventService?.afterStateChange?.(trackedConversationId);
     } catch {}
     // The panel's copy of a task lives in memory and goes when the task
@@ -7631,7 +7834,7 @@ export function registerMessagesRoutes(app, deps) {
         .some((column) => before[column] !== after[column]);
       if (changed) emitSubagentStatus(after);
     }
-    res.json({ ok: true, count: tasks.length });
+    res.json({ ok: true, count: tasks.length, ...(resync ? { resync: true } : {}) });
   });
 
   // POST /api/conversation/:conversationId/background-task/:taskId/stop —
@@ -7650,6 +7853,168 @@ 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 = 'Sub-agents have no shell output; open the sub-agent view.';
+
+  // Why a task has no output to show, for the console's `none` answer.
+  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 'This session did not report an output file for this task. Sessions started before the task console need a restart to show output.';
+    }
+    return 'Output is not available for this 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;
+    const { kind, path } = taskOutputSource(task);
+    const head = {
+      ok: true,
+      taskId,
+      kind,
+      ended,
+      status: ended ? task.status : 'running',
+      exitCode: ended ? (task.exitCode ?? null) : null,
+      health: task.health || null,
+      taskStallMinutes: taskStallMinutes(),
+      task: {
+        taskId,
+        taskType: task.taskType || null,
+        description: task.description || '',
+        startedAt: task.startedAt || null,
+        endedAt: task.endedAt || null,
+        stoppable: !ended && 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: 'Output is not available for this task.' });
+    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