@oar-sh/oar 0.9.12 → 0.9.14

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 {
@@ -45,6 +46,8 @@ import { normalizeBackgroundTaskDigest } from '../../shared/worker-runtime/backg
 import {
   DEFAULT_TASK_STALL_MINUTES,
   TASK_OUTPUT_LIMITS,
+  cleanTaskText,
+  normalizeTaskCommand,
   normalizeTaskOutputKind,
   normalizeTaskOutputPath,
 } from '../../shared/task-output-text.mjs';
@@ -61,13 +64,14 @@ import {
   sanitizeRunHeaderPatch,
   TIMELINE_READ_DEFAULT_LIMIT,
 } from '../services/subagent-timeline-service.mjs';
-import { normalizeSubagentRunStatus } from '../../shared/subagent-timeline.mjs';
+import { SUBAGENT_TASK_TYPES, isTerminalSubagentRunStatus, normalizeSubagentRunStatus } from '../../shared/subagent-timeline.mjs';
 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 { TASK_OUTPUT_NONE_MESSAGES } from '../public/app/task-console-render.mjs';
 import {
   admitRemoteRelayRequest,
   readRemoteRelayRequest,
@@ -244,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 || '');
@@ -1419,6 +1431,9 @@ function isOpenAIImageAttachment(raw) {
 export function resolveOpenAIImageEditAttachment(rawAttachments, {
   maxImageBytes = 20 * 1024 * 1024,
   allowedRootPath = '',
+  // Folders of earlier versions that uploads are still read from: only a
+  // sha256-named blob directly inside one counts.
+  allowedBlobRootPaths = [],
   allowedGeneratedImagesRootPath = '',
 } = {}) {
   const attachments = Array.isArray(rawAttachments) ? rawAttachments : [];
@@ -1439,8 +1454,11 @@ export function resolveOpenAIImageEditAttachment(rawAttachments, {
     const filePath = String(firstImage.path || '').trim();
     if (!filePath) throw new Error('Image attachment is missing file path or data URL');
     const allowedRoot = String(allowedRootPath || '').trim();
+    const blobRoots = (Array.isArray(allowedBlobRootPaths) ? allowedBlobRootPaths : [])
+      .map((root) => String(root || '').trim())
+      .filter(Boolean);
     const generatedImagesRoot = String(allowedGeneratedImagesRootPath || '').trim();
-    if (allowedRoot || generatedImagesRoot) {
+    if (allowedRoot || blobRoots.length || generatedImagesRoot) {
       const resolvedPath = path.resolve(filePath);
       const isWithinRoot = (rootPath) => {
         if (!rootPath) return false;
@@ -1455,7 +1473,11 @@ export function resolveOpenAIImageEditAttachment(rawAttachments, {
           && relativeParts[0] !== '..'
           && relativeParts[1] === 'generated-images';
       })();
-      if (!isWithinRoot(allowedRoot) && !isGeneratedImagePath) {
+      const isOldUploadBlob = blobRoots.some((root) => (
+        path.dirname(resolvedPath) === path.resolve(root)
+        && /^[a-f0-9]{64}$/.test(path.basename(resolvedPath))
+      ));
+      if (!isWithinRoot(allowedRoot) && !isOldUploadBlob && !isGeneratedImagePath) {
         throw new Error('Image attachment path is outside the upload directory');
       }
     }
@@ -1735,6 +1757,7 @@ export function registerMessagesRoutes(app, deps) {
     MAX_UPLOAD_BYTES,
     MAX_UPLOAD_ATTACHMENTS,
     uploadsDir,
+    uploadReadDirs = [uploadsDir],
     MAX_REPO_TREE_NODES,
     MAX_REQUEUE_RETRIES,
     MAX_IMAGE_DATA_URL_LENGTH,
@@ -1792,6 +1815,9 @@ export function registerMessagesRoutes(app, deps) {
     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,
@@ -1881,6 +1907,21 @@ export function registerMessagesRoutes(app, deps) {
     return tasks.find((task) => (task?.toolUseId && task.toolUseId === runId) || (taskId && task?.taskId === taskId)) || null;
   }
 
+  // A conversation's sub-agent run by its task id. A Claude agent resumed by
+  // a new message keeps its task id, and the CLI names the call that resumed
+  // it (SendMessage) as the task's tool use, an id no run row carries: its
+  // run is the one the task id leads to.
+  function subagentRunOfTask(conversationId, taskId) {
+    const conversation = String(conversationId || '').trim();
+    const task = String(taskId || '').trim().slice(0, 200);
+    if (!conversation || !task) return null;
+    try {
+      return stmts.getSubagentRunByTaskId?.get?.(conversation, task) || null;
+    } catch {
+      return null;
+    }
+  }
+
   // Stop is offered while a run is running: a background run through its
   // task, a foreground run through the sub-agent cancel route.
   function isSubagentRunStoppable(run) {
@@ -2727,10 +2768,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);
@@ -2767,6 +2810,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({
@@ -2792,6 +2836,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) {
@@ -4429,7 +4475,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(
@@ -4761,9 +4817,9 @@ export function registerMessagesRoutes(app, deps) {
       ? (pinnedGrokModel || String(configuredGrok?.model || '').trim())
       : '';
     // Claude Cloud conversations resolve models against the cloud provider's
-    // own list (plain ids, no "[1m]" tier). The model is part of the cloud
-    // session's configuration: it can still change before the first message
-    // creates that session, and is locked afterwards.
+    // own list (plain ids, no "[1m]" tier). The first message creates the
+    // cloud session with the conversation's model; a later change is applied
+    // by the worker before the next message (see below).
     const configuredClaudeCloud = runtimeUsesClaudeCloud ? getClaudeCloudProviderSettings() : null;
     const pinnedClaudeCloudModel = runtimeUsesClaudeCloud
       ? stripModelTierSuffix(existingRuntimeSession?.provider_model)
@@ -4786,6 +4842,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,
@@ -4826,7 +4910,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;
@@ -4851,6 +4935,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.
@@ -4859,6 +4952,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 };
     };
@@ -4874,8 +4969,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 };
     };
@@ -4884,11 +4982,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
@@ -4902,15 +5005,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) {
@@ -4920,6 +5029,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';
@@ -4964,6 +5076,7 @@ export function registerMessagesRoutes(app, deps) {
       return res.json({
         ok: true,
         duplicate: true,
+        queued: false,
         alreadyResent: true,
         duplicateOfMessageId: resend.alreadyResentAs,
         conversationId,
@@ -4994,6 +5107,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,
@@ -5175,15 +5290,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,
@@ -5527,6 +5652,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,
@@ -6570,7 +6698,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 });
   });
 
@@ -6859,6 +6997,7 @@ export function registerMessagesRoutes(app, deps) {
         editAttachment = resolveOpenAIImageEditAttachment(requestBody.attachments, {
           maxImageBytes: MAX_UPLOAD_BYTES,
           allowedRootPath: uploadsDir,
+          allowedBlobRootPaths: uploadReadDirs.slice(1),
           allowedGeneratedImagesRootPath: resolveSessionStateRoot?.() || '',
         });
       } catch (error) {
@@ -7694,7 +7833,8 @@ export function registerMessagesRoutes(app, deps) {
     // 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);
+    // 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.
@@ -7706,6 +7846,7 @@ export function registerMessagesRoutes(app, deps) {
       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;
@@ -7716,8 +7857,10 @@ export function registerMessagesRoutes(app, deps) {
     sessionActivityTracker?.noteTaskSettled?.(conversationId, {
       taskId,
       toolUseId: sanitizeSubagentRunId(req.body?.toolUseId) || null,
+      // Which run ended (a resumed agent runs again under the same task id).
+      ...(req.body?.taskRunId ? { taskRunId: String(req.body.taskRunId).trim().slice(0, 200) } : {}),
       status: String(req.body?.status || '').trim().slice(0, 40) || 'completed',
-      summary: String(req.body?.summary || '').trim().slice(0, 500) || 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
@@ -7747,11 +7890,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,
@@ -7765,6 +7915,9 @@ 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,
+        // Which run of the task this is (the SDK's run id): a resumed agent
+        // keeps its task id and runs again under a new one.
+        taskRunId: String(task?.taskRunId || '').trim().slice(0, 200) || 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),
@@ -7773,6 +7926,15 @@ export function registerMessagesRoutes(app, deps) {
         exitCode: wholeNumber(task?.exitCode),
       }))
       .filter((task) => task.taskId);
+    // A resumed agent's row names the call that resumed it, which no run
+    // carries: it opens the run of its task instead (a worker that remembers
+    // the spawn sends that already).
+    const runConversationId = resolveTaskConversationId(conversationId);
+    for (const task of tasks) {
+      if (!task.toolUseId || !SUBAGENT_TASK_TYPES.has(task.taskType) || stmts.getSubagentRun?.get?.(task.toolUseId)) continue;
+      const run = subagentRunOfTask(runConversationId, task.taskId);
+      if (run) task.toolUseId = String(run.id);
+    }
     // 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) {
@@ -7870,9 +8032,11 @@ export function registerMessagesRoutes(app, deps) {
   // 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.';
+  const SUBAGENT_OUTPUT_MESSAGE = TASK_OUTPUT_NONE_MESSAGES.subagent;
 
-  // Why a task has no output to show, for the console's `none` answer.
+  // 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 = '';
@@ -7880,9 +8044,9 @@ export function registerMessagesRoutes(app, deps) {
       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 TASK_OUTPUT_NONE_MESSAGES.noOutputFile;
     }
-    return 'Output is not available for this provider.';
+    return TASK_OUTPUT_NONE_MESSAGES.provider;
   }
 
   // A task the session's task list shows that the task store does not hold:
@@ -7949,13 +8113,17 @@ export function registerMessagesRoutes(app, deps) {
       });
     }
     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 : 'running',
+      status: ended ? task.status : (held ? 'held' : 'running'),
+      ...(held ? { held: true } : {}),
       exitCode: ended ? (task.exitCode ?? null) : null,
       health: task.health || null,
       taskStallMinutes: taskStallMinutes(),
@@ -7963,9 +8131,10 @@ export function registerMessagesRoutes(app, deps) {
         taskId,
         taskType: task.taskType || null,
         description: task.description || '',
+        ...(task.command ? { command: task.command } : {}),
         startedAt: task.startedAt || null,
         endedAt: task.endedAt || null,
-        stoppable: !ended && task.stoppable !== false,
+        stoppable: !ended && !held && task.stoppable !== false,
       },
     };
     if (kind === 'none') {
@@ -7982,7 +8151,7 @@ export function registerMessagesRoutes(app, deps) {
       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.' });
+    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 !== ''
@@ -8435,12 +8604,14 @@ export function registerMessagesRoutes(app, deps) {
   // Fenced by the run row, not by an open turn: a background agent keeps
   // writing after its turn ended, and its entries belong to that turn. A run
   // the relay does not know yet but whose parent it does (an agent spawned
-  // inside another) is created under the parent's turn; anything else is a
-  // 404 the worker retries once the spawn has landed.
+  // inside another) is created under the parent's turn; a run of a task the
+  // relay knows by its task id (a resumed agent: same task, new tool use) is
+  // that task's run; anything else is a 404 the worker retries once the spawn
+  // has landed.
   app.post('/api/subagent-timeline', auth, (req, res) => {
     touchCli();
     const conversationId = String(req.body?.conversationId || '').trim();
-    const runId = sanitizeSubagentRunId(req.body?.subagentRunId);
+    let runId = sanitizeSubagentRunId(req.body?.subagentRunId);
     if (!conversationId || !runId) {
       return res.status(400).json({ error: 'Missing conversationId or subagentRunId' });
     }
@@ -8449,6 +8620,17 @@ export function registerMessagesRoutes(app, deps) {
     }
     const rawHeader = req.body?.header && typeof req.body.header === 'object' ? req.body.header : {};
     let run = stmts.getSubagentRun?.get?.(runId) || null;
+    // A finished run that a later run of its task (posted under another id)
+    // sets running again: the relay marks where it resumed, once per id.
+    let resumedNote = null;
+    if (!run) {
+      run = subagentRunOfTask(conversationId, req.body?.taskId || rawHeader.taskId);
+      if (run && isTerminalSubagentRunStatus(normalizeSubagentRunStatus(run.status))
+        && rawHeader.status && normalizeSubagentRunStatus(rawHeader.status) === 'running') {
+        resumedNote = { key: `relay:resumed:${runId}`, kind: 'note', text: 'Resumed with a new message', metadata: { resumed: true } };
+      }
+      if (run) runId = String(run.id);
+    }
     let created = false;
     if (!run) {
       const parentId = sanitizeSubagentRunId(rawHeader.parentSubagentId);
@@ -8471,7 +8653,8 @@ export function registerMessagesRoutes(app, deps) {
     if (patch) run = subagentTimeline.applyHeader(runId, patch) || run;
     let stored;
     try {
-      stored = subagentTimeline.applyEntries(run, req.body?.entries);
+      const entries = Array.isArray(req.body?.entries) ? req.body.entries : [];
+      stored = subagentTimeline.applyEntries(run, resumedNote ? [resumedNote, ...entries] : entries);
     } catch (error) {
       return res.status(500).json({ error: error?.message || 'Failed to store the timeline' });
     }