@oar-sh/oar 0.9.12 → 0.9.14

package/server/claude-cloud-worker/claude-cloud-session-process.mjs

@@ -4,6 +4,7 @@ import fs from 'node:fs';
 import { createAskUserBridge } from '../../shared/ask-user-bridge.mjs';
 import { createRelayQuestion } from '../../shared/question-wait.mjs';
 import { DEFAULT_QUESTION_TIMEOUT_MS } from '../../shared/question-timeout.mjs';
+import { readApprovalAnswer } from '../../shared/question-answer-rule.mjs';
 import { EMPTY_TURN_COMPLETION_NOTE } from '../../shared/empty-turn-completion.mjs';
 import { stripModelTierSuffix } from '../../shared/claude-cloud/repo-url.mjs';
 import { resolveDeliveredAttribution, sameClaudeAttribution } from '../../shared/claude-attribution.mjs';
@@ -27,6 +28,7 @@ const PERMISSION_ALLOW = 'Allow';
 const PERMISSION_DENY = 'Deny';
 const QUESTION_UNANSWERED_MESSAGE = 'The user did not answer. Continue without this, or end the turn and say what you need.';
 const PERMISSION_DENIED_MESSAGE = 'The user denied this tool use.';
+const PERMISSION_UNREADABLE_MESSAGE = 'The permission card was answered with neither Allow nor Deny, so the tool use is not allowed.';
 // A catch-up after a worker restart reads the events of one unfinished turn;
 // the cap only stops a cursor that never advances.
 const MAX_CATCH_UP_PAGES = 200;
@@ -253,8 +255,8 @@ export function createClaudeCloudSessionRunner({
     const requested = String(message?.model || '').trim();
     const perTurn = requested && requested.toLowerCase() !== 'auto' ? requested : '';
     // The delivered message names the conversation's current model; the launch
-    // model is what it was when the worker started, and the model may still be
-    // changed until the first message creates the cloud session.
+    // model is what it was when the worker started. A change after the first
+    // message is applied before the next one (applyModel).
     return stripModelTierSuffix(String(message?.providerModel || '').trim() || perTurn || defaultModel);
   }
 
@@ -723,8 +725,12 @@ export function createClaudeCloudSessionRunner({
     });
     const result = await askUserBridge.waitForRelayQuestionAnswer(questionId, { signal });
     if (result.timedOut || signal.aborted) return { behavior: 'deny', message: QUESTION_UNANSWERED_MESSAGE };
-    if (result.answer === PERMISSION_ALLOW) return { behavior: 'allow', updatedInput: request.input };
-    return { behavior: 'deny', message: PERMISSION_DENIED_MESSAGE };
+    const decision = readApprovalAnswer(result.answer, { approve: PERMISSION_ALLOW, deny: PERMISSION_DENY });
+    if (decision === 'approve') return { behavior: 'allow', updatedInput: request.input };
+    if (decision === 'deny') return { behavior: 'deny', message: PERMISSION_DENIED_MESSAGE };
+    // The relay takes only the choices on this card; anything else is no
+    // decision of the user's, and the agent is told so.
+    return { behavior: 'deny', message: PERMISSION_UNREADABLE_MESSAGE };
   }
 
   async function askUser(t, request, signal) {

package/server/claude-worker/claude-session-process.mjs

@@ -39,11 +39,13 @@ import {
   isStaleAttemptError,
 } from './claude-turn-publisher.mjs';
 import { createSubagentTimelineRecorder } from './subagent-timeline-recorder.mjs';
+import { SUBAGENT_TASK_TYPES } from '../../shared/subagent-timeline.mjs';
 import { createAskUserBridge } from '../../shared/ask-user-bridge.mjs';
 import { createRemoteRelayToolGate } from '../../shared/remote-relay-tool-core.mjs';
 import { buildRelayStopFailure } from '../../shared/relay-stop-failure.mjs';
 import { createTurnLiveness, resolveTurnStallWindows } from '../../shared/worker-runtime/turn-liveness.mjs';
 import { createKeptPosts } from '../../shared/worker-runtime/kept-posts.mjs';
+import { explainLaunchFailure, missingWorkingDirectoryError } from '../../shared/worker-runtime/working-directory.mjs';
 import {
   ANSWERED_ELSEWHERE_KIND,
   DELIVERY_ANSWERED_ELSEWHERE_TEXT,
@@ -60,6 +62,7 @@ import {
 import { createUsageLimitTracker } from '../../shared/claude-usage-limit.mjs';
 import {
   discoverTaskOutputPaths,
+  shellCommandsOf,
   exitCodeFromSummary,
   isShellTaskType,
   outputDirOf,
@@ -81,8 +84,6 @@ function modeAppendClass(relayMode) {
 
 export { STEER_FOLDED_TEXT, STEER_STOPPED_TEXT };
 
-/** Task types that run a model of their own (vs. bash/monitor/workflow). */
-const AGENT_TASK_TYPES = new Set(['local_agent', 'agent', 'subagent']);
 const MAX_TASK_TOOL_CALL_CHARS = 300;
 /** Output paths remembered per process (one per backgrounded shell). */
 const MAX_TASK_OUTPUT_PATHS = 200;
@@ -458,6 +459,9 @@ export function createClaudeSessionRunner({
   readContextUsageImpl = readContextUsage,
   readPlanUsageImpl = readPlanUsage,
   relocateTranscriptImpl = relocateClaudeTranscriptForCwd,
+  // The error a spawn in `cwd` fails with up front, or null
+  // (shared/worker-runtime/working-directory.mjs).
+  checkWorkingDirectoryImpl = missingWorkingDirectoryError,
   idleShutdownMs = 10 * 60_000,
   getBackgroundTaskTimeoutMs = () => 0,
   // The per-conversation auto-compact window (token count, null = Auto). Read
@@ -1762,7 +1766,7 @@ export function createClaudeSessionRunner({
         // agent-like task runs on the session model. Resolved at publish
         // time so the spawn block landing after task_started still heals on
         // the next publish. Bash & co. get no model at all.
-        const agentLike = AGENT_TASK_TYPES.has(String(task.taskType || ''));
+        const agentLike = SUBAGENT_TASK_TYPES.has(String(task.taskType || ''));
         const pinnedModel = (task.toolUseId && processRef.subagentSpawns.get(task.toolUseId)) || '';
         const activity = (task.toolUseId && processRef.subagentActivity.get(task.toolUseId)) || {};
         const model = agentLike ? (activity.model || pinnedModel || processRef.initModel || null) : null;
@@ -1776,6 +1780,7 @@ export function createClaudeSessionRunner({
           lastToolCall: (agentLike && activity.lastToolCall) || null,
           totalTokens: task.totalTokens ?? null,
           toolUseId: task.toolUseId || null,
+          ...(task.taskRunId ? { taskRunId: task.taskRunId } : {}),
           subagentType: task.subagentType || null,
           model,
           modelInherited: Boolean(model && !pinnedModel && !activity.model),
@@ -1783,8 +1788,10 @@ export function createClaudeSessionRunner({
           // sanitizer whitelists and re-clamps it before storing.
           ...(task.workflowProgress ? { workflowProgress: task.workflowProgress } : {}),
           ...(agentLike && Number.isInteger(task.steps) ? { steps: task.steps } : {}),
-          // Where the relay reads the task's console from.
+          // Where the relay reads the task's console from, and the command
+          // line the console reads a `| tail` off.
           ...(isShellTaskType(task.taskType) ? taskOutputFields(processRef, taskId) : {}),
+          ...(isShellTaskType(task.taskType) && taskCommand(processRef, taskId, task) ? { command: taskCommand(processRef, taskId, task) } : {}),
         };
       });
       return postTaskSet({ tasks, ...(resync ? { resync: true } : {}) }).catch((error) => {
@@ -1846,12 +1853,49 @@ export function createClaudeSessionRunner({
   /** A backgrounded Bash/Monitor result: note its file, and show it on the live row. */
   function recordTaskOutputPaths(sdkMessage) {
     let liveChanged = false;
-    for (const { taskId, outputPath } of discoverTaskOutputPaths(sdkMessage)) {
+    for (const { taskId, outputPath, toolUseId } of discoverTaskOutputPaths(sdkMessage)) {
+      if (toolUseId && !proc.taskToolUses.has(taskId)) {
+        proc.taskToolUses.set(taskId, toolUseId);
+        capMap(proc.taskToolUses, MAX_TASK_OUTPUT_PATHS);
+        if (proc.liveTasks.has(taskId) && proc.shellCommands.has(toolUseId)) liveChanged = true;
+      }
       if (rememberTaskOutputPath(proc, taskId, outputPath) && proc.liveTasks.has(taskId)) liveChanged = true;
     }
     if (liveChanged) publishBackgroundTasks();
   }
 
+  function capMap(map, max) {
+    while (map.size > max) map.delete(map.keys().next().value);
+  }
+
+  // The command line of each Bash or Monitor call, by its tool_use id: a
+  // shell task's row names it (task_started's tool_use_id, or the call whose
+  // result announced the task's file).
+  function recordShellCommands(sdkMessage) {
+    for (const { toolUseId, command } of shellCommandsOf(sdkMessage)) {
+      proc.shellCommands.set(toolUseId, command);
+      capMap(proc.shellCommands, MAX_TASK_OUTPUT_PATHS);
+    }
+  }
+
+  // A task's command, pinned to its id once found: the 200 newest calls
+  // the map by tool_use id keeps may move past a long-running task's call.
+  function taskCommand(processRef, taskId, task) {
+    const pinned = processRef.taskCommands.get(taskId);
+    if (pinned) return pinned;
+    const toolUseId = task?.toolUseId || processRef.taskToolUses.get(taskId) || '';
+    const command = (toolUseId && processRef.shellCommands.get(toolUseId)) || '';
+    if (command && (processRef.liveTasks.has(taskId) || processRef.departedTasks.has(taskId))) processRef.taskCommands.set(taskId, command);
+    return command;
+  }
+
+  // Pinned commands go with their task: live or departed until its settle.
+  function prunePinnedCommands(processRef) {
+    for (const taskId of [...processRef.taskCommands.keys()]) {
+      if (!processRef.liveTasks.has(taskId) && !processRef.departedTasks.has(taskId)) processRef.taskCommands.delete(taskId);
+    }
+  }
+
   /**
    * The relay's fallback for a shell task with no file: the CLI's last 8 KiB
    * (`Query.getTaskOutput`, implemented in sdk.mjs though sdk.d.ts does not
@@ -2175,7 +2219,7 @@ export function createClaudeSessionRunner({
   // alias like "opus") and the full input of the tool it is calling now.
   // Single-lined and capped: the panel crops it to its width.
   function recordSubagentActivity(sdkMessage) {
-    const parentId = String(sdkMessage?.parent_tool_use_id || '').trim();
+    const parentId = timelineRecorder.runIdFor(sdkMessage?.parent_tool_use_id);
     if (!parentId) return;
     const entry = proc.subagentActivity.get(parentId) || {};
     const before = `${entry.model || ''}\n${entry.lastToolCall || ''}`;
@@ -2321,6 +2365,7 @@ export function createClaudeSessionRunner({
   function observeProcessLevel(sdkMessage) {
     const type = String(sdkMessage?.type || '');
     if (type === 'assistant') {
+      recordShellCommands(sdkMessage);
       recordSubagentSpawns(sdkMessage);
       recordSubagentActivity(sdkMessage);
       return;
@@ -2550,11 +2595,15 @@ export function createClaudeSessionRunner({
         .filter((task) => String(task?.task_id || '').trim())
         .map((task) => {
           const taskId = String(task.task_id).trim();
-          const known = previous.get(taskId) || {};
+          const runId = String(task?.run_id || '').trim();
+          // Another run of a task still listed (resumed at once): its own row.
+          const listed = previous.get(taskId) || {};
+          const known = runId && listed.taskRunId && listed.taskRunId !== runId ? {} : listed;
           return [taskId, {
             ...known,
             taskType: String(task?.task_type || '').trim() || known.taskType || '',
             description: String(task?.description || '').trim() || known.description || '',
+            taskRunId: runId || known.taskRunId || '',
             startedAt: known.startedAt || Date.now(),
           }];
         }));
@@ -2596,6 +2645,7 @@ export function createClaudeSessionRunner({
       }
       syncWorkflowPoller(proc);
       publishBackgroundTasks();
+      prunePinnedCommands(proc);
       evaluateLifecycle();
       return;
     }
@@ -2609,8 +2659,14 @@ export function createClaudeSessionRunner({
         known.subagentType = String(sdkMessage.subagent_type || '').trim() || known.subagentType || '';
         // The task's spawning tool_use id is the same identity the subagent
         // bubbles key on — recorded so the panel and the bubbles can be
-        // correlated (and a targeted stop can find its task).
-        known.toolUseId = String(sdkMessage.tool_use_id || '').trim() || known.toolUseId || '';
+        // correlated (and a targeted stop can find its task). A resumed agent
+        // names the call that resumed it (SendMessage); the recorder leads
+        // that back to the agent's run.
+        const toolUseId = String(sdkMessage.tool_use_id || '').trim();
+        known.toolUseId = timelineRecorder.runIdFor(toolUseId) || known.toolUseId || '';
+        // Which run of the task this is: the SDK's run id, else (an older
+        // CLI) the tool use that started it, which differs per run too.
+        known.taskRunId = String(sdkMessage.run_id || '').trim() || known.taskRunId || toolUseId;
         // task_started can be the first event carrying the task_type; a
         // workflow revealed here must start its poller too.
         syncWorkflowPoller(proc);
@@ -2625,7 +2681,7 @@ export function createClaudeSessionRunner({
         known.summary = String(sdkMessage.summary || '').trim() || known.summary;
         known.lastToolName = String(sdkMessage.last_tool_name || '').trim() || known.lastToolName;
         known.subagentType = String(sdkMessage.subagent_type || '').trim() || known.subagentType || '';
-        known.toolUseId = String(sdkMessage.tool_use_id || '').trim() || known.toolUseId || '';
+        known.toolUseId = timelineRecorder.runIdFor(sdkMessage.tool_use_id) || known.toolUseId || '';
         const totalTokens = Number(sdkMessage.usage?.total_tokens);
         if (Number.isFinite(totalTokens)) known.totalTokens = totalTokens;
         // The sub-agent's tool calls so far: the panel row's step count.
@@ -2655,15 +2711,19 @@ export function createClaudeSessionRunner({
         rememberTaskOutputPath(proc, taskId, sdkMessage.output_file);
         const shellLike = isShellTaskType(published?.taskType);
         const outputPath = shellLike ? (proc.taskOutputPaths.get(taskId) || '') : '';
+        const command = shellLike ? taskCommand(proc, taskId, { toolUseId: String(sdkMessage.tool_use_id || published?.toolUseId || '').trim() }) : '';
+        proc.taskCommands.delete(taskId);
         const exitCode = shellLike ? exitCodeFromSummary(sdkMessage.summary) : null;
         const toolUses = Number(sdkMessage.usage?.tool_uses);
-        const steps = AGENT_TASK_TYPES.has(String(published?.taskType || '')) && Number.isFinite(toolUses) && toolUses >= 0
+        const steps = SUBAGENT_TASK_TYPES.has(String(published?.taskType || '')) && Number.isFinite(toolUses) && toolUses >= 0
           ? Math.floor(toolUses)
           : null;
+        const settledRunId = String(sdkMessage.run_id || published?.taskRunId || '').trim();
         void keptTaskSettles.post('/api/background-task-settled', {
           conversationId: sdkSessionId,
           taskId,
-          toolUseId: String(sdkMessage.tool_use_id || published?.toolUseId || '').trim() || null,
+          toolUseId: timelineRecorder.runIdFor(sdkMessage.tool_use_id) || published?.toolUseId || null,
+          ...(settledRunId ? { taskRunId: settledRunId } : {}),
           status: String(sdkMessage.status || '').trim() || 'completed',
           summary: String(sdkMessage.summary || '').trim().slice(0, 500) || null,
           ...(sdkMessage.reason ? { reason: String(sdkMessage.reason).slice(0, 40) } : {}),
@@ -2673,6 +2733,7 @@ export function createClaudeSessionRunner({
             startedAt: published.startedAt || null,
           } : {}),
           ...(outputPath ? { outputPath } : {}),
+          ...(command ? { command } : {}),
           ...(exitCode !== null ? { exitCode } : {}),
           ...(steps !== null ? { steps } : {}),
         });
@@ -3456,6 +3517,7 @@ export function createClaudeSessionRunner({
             message: ctx.message,
             errorText: String(streamError?.message || streamError || 'unknown error'),
             usageLimit: usageLimit.classifyException(streamError),
+            error: streamError,
           }).catch(() => {});
         }
         continue;
@@ -3477,6 +3539,11 @@ export function createClaudeSessionRunner({
   // Spawn / adapt
 
   function spawnProcess(message, { resume: resumeOverride = '' } = {}) {
+    // A spawn in a folder that is gone fails with ENOENT, which the SDK
+    // reports as a native binary that does not match the libc. Thrown here,
+    // the delivery fails with the folder's name instead (handlePendingPayload).
+    const missingFolder = checkWorkingDirectoryImpl(cwd);
+    if (missingFolder) throw missingFolder;
     const relayMode = message.relayMode || 'agent';
     const model = resolvePerTurnModel(message);
     const effort = normalizeClaudeEffort(message.reasoningEffort);
@@ -3517,6 +3584,12 @@ export function createClaudeSessionRunner({
       // next to it.
       taskOutputPaths: new Map(),
       taskOutputDir: '',
+      // tool_use id → the command line of a Bash or Monitor call, and taskId
+      // → the call whose result announced the task: a shell row's command.
+      shellCommands: new Map(),
+      taskToolUses: new Map(),
+      // taskId → its command, pinned while the task is live or departed.
+      taskCommands: new Map(),
       // taskId → { runId, labels, digestJson } for live local_workflow tasks;
       // pruned by syncWorkflowPoller when a task leaves the live set.
       workflowStates: new Map(),
@@ -3691,7 +3764,11 @@ export function createClaudeSessionRunner({
           syncDeliveryReadiness();
         }
       } catch (error) {
-        if (!processRef.aborted && !abortController.signal.aborted) streamError = error;
+        // A launch that failed because the folder went away after the check
+        // above is told as that, too.
+        if (!processRef.aborted && !abortController.signal.aborted) {
+          streamError = explainLaunchFailure(error, cwd, { check: checkWorkingDirectoryImpl });
+        }
       } finally {
         try {
           processRef.turn.endInput?.();
@@ -4170,7 +4247,7 @@ export function createClaudeSessionRunner({
       settingsWindowOpen = false;
       const errorText = String(error?.message || error || 'unknown error');
       dbg('claude turn failed', message.id, errorText);
-      await publisher.publishTurnException({ message, errorText, usageLimit: usageLimit.classifyException(error) });
+      await publisher.publishTurnException({ message, errorText, usageLimit: usageLimit.classifyException(error), error });
       return true;
     } finally {
       endAdmission();
@@ -4211,7 +4288,7 @@ export function createClaudeSessionRunner({
    * subagents have no task id and remain full-turn-Stop only.
    */
   async function stopBackgroundTaskByToolUseId(toolUseId) {
-    const normalized = String(toolUseId || '').trim();
+    const normalized = timelineRecorder.runIdFor(toolUseId);
     if (!normalized || !proc) return false;
     for (const [taskId, task] of proc.liveTasks.entries()) {
       if (String(task?.toolUseId || '').trim() === normalized) {

package/server/claude-worker/claude-turn-publisher.mjs

@@ -4,6 +4,7 @@ import { countPlanLikeLines } from '../../shared/plan-lines.mjs';
 import { EMPTY_TURN_COMPLETION_NOTE } from '../../shared/empty-turn-completion.mjs';
 import { buildSteerSettleFailure, steerSettleFailureText } from '../../shared/steer-settle-failure.mjs';
 import { buildUsageLimitFailure } from '../../shared/claude-usage-limit.mjs';
+import { WORKING_DIRECTORY_MISSING_CODE, isWorkingDirectoryMissingError } from '../../shared/worker-runtime/working-directory.mjs';
 
 const PLAN_BOARD_ACTIONS = [
   { id: 'autopilot', label: 'Implement in autopilot', mode: 'autopilot' },
@@ -390,7 +391,7 @@ export function createClaudeTurnPublisher({ api, dbg = () => {}, takeWorkflowRun
     });
   }
 
-  async function publishTurnException({ message, errorText, usageLimit = null }) {
+  async function publishTurnException({ message, errorText, usageLimit = null, error = null }) {
     if (usageLimit) {
       await publishResponse(message, {
         text: usageLimit.text || errorText,
@@ -399,6 +400,24 @@ export function createClaudeTurnPublisher({ api, dbg = () => {}, takeWorkflowRun
       });
       return;
     }
+    // The conversation's folder is gone: the error names it and says what to
+    // do, which neither a retry nor a sign-in changes.
+    if (isWorkingDirectoryMissingError(error)) {
+      await publishResponse(message, {
+        text: `System note: ${error.message} ${error.guidance}`,
+        model: null,
+        terminalError: {
+          kind: 'claude-turn-failed',
+          code: WORKING_DIRECTORY_MISSING_CODE,
+          stableCode: `claude.${WORKING_DIRECTORY_MISSING_CODE}`,
+          message: error.message,
+          guidance: error.guidance,
+          failedAt: new Date().toISOString(),
+          queueMessageId: String(message.id || '') || null,
+        },
+      });
+      return;
+    }
     const isAuthError = /authentication|logged in|login|credential|api key/i.test(errorText);
     await publishResponse(message, {
       text: isAuthError

package/server/claude-worker/subagent-timeline-recorder.mjs

@@ -1,6 +1,7 @@
 import crypto from 'node:crypto';
 import { displayToolName, isBackgroundLaunch, isSubagentToolName } from './sdk-message-normalizer.mjs';
 import {
+  SUBAGENT_TASK_TYPES,
   SUBAGENT_TIMELINE_ENTRY_MAX_CHARS,
   SUBAGENT_TIMELINE_MAX_ENTRIES,
   cutSubagentTimelineText,
@@ -8,6 +9,8 @@ import {
 } from '../../shared/subagent-timeline.mjs';
 
 const MAX_TRACKED_RUNS = 200;
+// Task ids and resume ids remembered to find a resumed agent's run.
+const MAX_TRACKED_TASKS = 500;
 
 export function toolResultText(content) {
   if (typeof content === 'string') return content;
@@ -53,6 +56,16 @@ function capText(text) {
  *
  * It also answers which turn owns a run's live lanes (`ownsRun`): only the
  * turn that spawned an agent shows its frames in its in-turn lanes.
+ *
+ * A finished background agent that the session sends a new message
+ * (SendMessage) runs again as the same task: task_started names its task id
+ * again, with the SendMessage call as its tool_use_id. That id leads to the
+ * run of the task's first start (`runIdFor`), so the record goes on under the
+ * agent's run, running again, with a note where it resumed. A start the
+ * recorder already saw (same run id) adds nothing, and an event of an
+ * earlier run (a lower run id) is late and left out. Every post names
+ * the run's task id too: a relay that knows the run by the task alone (this
+ * recorder did not see the first start) places it there.
  */
 export function createSubagentTimelineRecorder({
   api,
@@ -66,6 +79,9 @@ export function createSubagentTimelineRecorder({
   writerId = crypto.randomBytes(4).toString('hex'),
 } = {}) {
   const runs = new Map(); // runId -> run state, in registration order
+  const taskRuns = new Map(); // taskId -> the run its first start named
+  const resumeRuns = new Map(); // tool_use_id of a later start -> that run
+  const latestRuns = new Map(); // taskId -> the SDK run id of its latest start
   let flushTimer = null;
   let flushing = null;
   let localCounter = 0;
@@ -75,6 +91,26 @@ export function createSubagentTimelineRecorder({
     return `${writerId}:${localCounter}`;
   }
 
+  /** The run an id belongs to: a resumed agent's later tool use leads to its first run. */
+  function runIdFor(id) {
+    const key = String(id || '').trim();
+    return resumeRuns.get(key) || key;
+  }
+
+  // An event of an earlier run of a task than its latest start: late (the
+  // run ids of one task sort in the order the runs opened). Without run ids,
+  // every event counts.
+  function isEarlierRun(taskId, sdkRunId) {
+    const latest = taskId ? latestRuns.get(taskId) : '';
+    return !!sdkRunId && !!latest && sdkRunId < latest;
+  }
+
+  function remember(map, key, value) {
+    map.delete(key);
+    map.set(key, value);
+    while (map.size > MAX_TRACKED_TASKS) map.delete(map.keys().next().value);
+  }
+
   function ensureRun(runId, { parentId = null, displayName = '', subagentType = '' } = {}) {
     const id = String(runId || '').trim();
     if (!id) return null;
@@ -221,7 +257,7 @@ export function createSubagentTimelineRecorder({
   }
 
   function observeAssistant(sdkMessage) {
-    const parentId = String(sdkMessage?.parent_tool_use_id || '').trim();
+    const parentId = runIdFor(sdkMessage?.parent_tool_use_id);
     const content = Array.isArray(sdkMessage?.message?.content) ? sdkMessage.message.content : [];
     if (!parentId) {
       // The main thread: only the agents it spawns matter here.
@@ -261,7 +297,7 @@ export function createSubagentTimelineRecorder({
   }
 
   function observeStreamEvent(sdkMessage) {
-    const parentId = String(sdkMessage?.parent_tool_use_id || '').trim();
+    const parentId = runIdFor(sdkMessage?.parent_tool_use_id);
     if (!parentId) return;
     const run = ensureRun(parentId);
     const event = sdkMessage?.event || {};
@@ -309,7 +345,7 @@ export function createSubagentTimelineRecorder({
   }
 
   function observeUser(sdkMessage) {
-    const parentId = String(sdkMessage?.parent_tool_use_id || '').trim();
+    const parentId = runIdFor(sdkMessage?.parent_tool_use_id);
     const content = Array.isArray(sdkMessage?.message?.content) ? sdkMessage.message.content : [];
     for (const block of content) {
       if (block?.type !== 'tool_result') continue;
@@ -346,17 +382,46 @@ export function createSubagentTimelineRecorder({
     const subtype = String(sdkMessage?.subtype || '');
     const toolUseId = String(sdkMessage?.tool_use_id || '').trim();
     if (!toolUseId) return;
+    const taskId = String(sdkMessage?.task_id || '').trim();
+    const sdkRunId = String(sdkMessage?.run_id || '').trim();
     if (subtype === 'task_started') {
-      const run = ensureRun(toolUseId, { subagentType: String(sdkMessage.subagent_type || '').trim() });
+      // Only sub-agents are resumed; shells and the rest are not remembered.
+      const taskType = String(sdkMessage.task_type || '').trim();
+      const agent = !!taskId && (!taskType || SUBAGENT_TASK_TYPES.has(taskType));
+      if (agent && sdkRunId) {
+        // The same start again, or an earlier run's start arriving late.
+        const latest = latestRuns.get(taskId);
+        if (latest && sdkRunId <= latest) return;
+        remember(latestRuns, taskId, sdkRunId);
+      }
+      const firstRun = agent ? taskRuns.get(taskId) : '';
+      if (firstRun && firstRun !== toolUseId) remember(resumeRuns, toolUseId, firstRun);
+      else if (agent && !firstRun) remember(taskRuns, taskId, toolUseId);
+      const run = ensureRun(runIdFor(toolUseId), { subagentType: String(sdkMessage.subagent_type || '').trim() });
+      // The same task started again (under another tool use, or after it
+      // ended): resumed.
+      const resumed = !!firstRun && (firstRun !== toolUseId || run.settled);
+      run.settled = false;
       if (sdkMessage.is_backgrounded === true) run.background = true;
+      if (resumed) {
+        const prompt = String(sdkMessage.prompt || '').trim();
+        addEntry(run, {
+          kind: 'note',
+          text: capText(prompt ? `Resumed with a new message: ${prompt}` : 'Resumed with a new message'),
+          metadata: { resumed: true },
+        });
+      }
+      // Running: a start, and for a resumed agent its return from the end.
       patchHeader(run, {
-        taskId: String(sdkMessage.task_id || '').trim() || null,
+        status: 'running',
+        taskId: taskId || null,
         subagentType: String(sdkMessage.subagent_type || '').trim() || null,
         background: sdkMessage.is_backgrounded === true ? true : null,
       });
       return;
     }
-    const run = runs.get(toolUseId);
+    if (isEarlierRun(taskId, sdkRunId)) return;
+    const run = runs.get(runIdFor(toolUseId));
     if (!run) return;
     if (subtype === 'task_updated') {
       if (sdkMessage?.patch?.is_backgrounded === true) {
@@ -413,7 +478,7 @@ export function createSubagentTimelineRecorder({
   }
 
   function ownsRun(runId, owner) {
-    const run = runs.get(String(runId || '').trim());
+    const run = runs.get(runIdFor(runId));
     if (!run || !owner) return false;
     if (!run.owner && run.parentId) run.owner = runs.get(run.parentId)?.owner || null;
     return run.owner === owner;
@@ -426,7 +491,7 @@ export function createSubagentTimelineRecorder({
    * carries it now; an unknown run keeps the old behaviour.
    */
   function isForeignRun(runId, owner) {
-    let run = runs.get(String(runId || '').trim());
+    let run = runs.get(runIdFor(runId));
     if (!run) return false;
     const spawnOwner = run.owner || null;
     let background = false;
@@ -469,6 +534,7 @@ export function createSubagentTimelineRecorder({
       await api('POST', '/api/subagent-timeline', {
         conversationId,
         subagentRunId: run.id,
+        ...(run.header.taskId ? { taskId: run.header.taskId } : {}),
         entries,
         ...(header ? { header } : {}),
       });
@@ -566,6 +632,7 @@ export function createSubagentTimelineRecorder({
     flush,
     processEnded,
     hasPending,
+    runIdFor,
     // For tests and diagnostics.
     runState: (runId) => runs.get(String(runId || '').trim()) || null,
   };

package/server/claude-worker/task-output-discovery.mjs

@@ -13,6 +13,13 @@ import nodePath from 'node:path';
 /** Task types whose output is a shell's stdout/stderr (getTaskOutput serves these too). */
 export const SHELL_TASK_TYPES = new Set(['local_bash', 'monitor', 'monitor_mcp', 'monitor_ws']);
 export const MAX_OUTPUT_PATH_CHARS = 1024;
+// The command line a shell row carries. The relay scrubs it, then cuts it
+// to 2,000 characters: a cut here first could split a credential it would
+// no longer recognise, so this one is only a bound on the post.
+export const MAX_TASK_COMMAND_CHARS = 8000;
+// The tools whose call starts a shell task: their input's `command` is the
+// task's command line (the console marks a `| tail` from it).
+const SHELL_TOOL_NAMES = new Set(['Bash', 'Monitor']);
 
 const OUTPUT_MARKER = 'Output is being written to';
 // The CLI's own file name: a path with spaces (a Windows profile dir) still
@@ -89,9 +96,28 @@ function isBackgroundNote(text) {
   return Boolean(mcp && taskIdFromOutputFile(mcp[1]));
 }
 
+/**
+ * `{ toolUseId, command }` of each Bash or Monitor call in an `assistant` SDK
+ * message: the command line of the task such a call starts in the
+ * background, cut at 8,000 characters (the relay cuts after scrubbing).
+ */
+export function shellCommandsOf(sdkMessage) {
+  if (String(sdkMessage?.type || '') !== 'assistant') return [];
+  const blocks = Array.isArray(sdkMessage?.message?.content) ? sdkMessage.message.content : [];
+  const found = [];
+  for (const block of blocks) {
+    if (block?.type !== 'tool_use' || !SHELL_TOOL_NAMES.has(String(block.name || ''))) continue;
+    const toolUseId = String(block.id || '').trim();
+    const command = typeof block.input?.command === 'string' ? block.input.command.trim().slice(0, MAX_TASK_COMMAND_CHARS) : '';
+    if (toolUseId && command) found.push({ toolUseId, command });
+  }
+  return found;
+}
+
 /**
  * Every task output file a `user` SDK message announces: the tool_result
- * blocks of backgrounded Bash (and Monitor) calls. The structured result's
+ * blocks of backgrounded Bash (and Monitor) calls, with the id of the call
+ * (`toolUseId`, '' when the block names none). The structured result's
  * `backgroundTaskId` names the task when the message answers a single call.
  */
 export function discoverTaskOutputPaths(sdkMessage) {
@@ -108,7 +134,7 @@ export function discoverTaskOutputPaths(sdkMessage) {
     const text = toolResultText(block);
     if (!structuredTaskId && !isBackgroundNote(text)) continue;
     const announced = parseOutputAnnouncement(text, structuredTaskId);
-    if (announced) found.push(announced);
+    if (announced) found.push({ ...announced, toolUseId: String(block.tool_use_id || '').trim() });
   }
   return found;
 }

package/server/copilot-worker/copilot-ask-user-tool.mjs

@@ -40,7 +40,7 @@ export const RELAY_ASK_USER_TOOL_PARAMETERS = Object.freeze({
     choices: {
       type: 'array',
       items: { type: 'string' },
-      description: 'Optional list of choices for a multiple choice question. Prefer providing choices when possible.',
+      description: 'Optional list of choices for a multiple choice question. Prefer providing choices when possible. The relay keeps the first 8 choices and drops the rest.',
     },
     multi_select: {
       type: 'boolean',

package/server/copilot-worker/copilot-continuation-signals.mjs

@@ -249,9 +249,13 @@ export function createReplayGate() {
  * `observe(event)` returns what the event changed, so the caller can pin the
  * runtime's lifecycle and note that a continuation is due without re-parsing.
  */
+// A shell row's command line: a bound on the post. The relay scrubs it, then
+// cuts it to 2,000 characters.
+const SHELL_COMMAND_CHARS_MAX = 8000;
+
 export function createBackgroundShellTracker({ now = () => Date.now() } = {}) {
-  const shells = new Map(); // shellId -> { shellId, description, startedAt }
-  const toolCalls = new Map(); // toolCallId -> { toolName, shellId, description }
+  const shells = new Map(); // shellId -> { shellId, description, command, startedAt }
+  const toolCalls = new Map(); // toolCallId -> { toolName, shellId, description, command }
 
   function rememberToolCall(toolCallId, entry) {
     if (!toolCallId) return;
@@ -264,10 +268,10 @@ export function createBackgroundShellTracker({ now = () => Date.now() } = {}) {
     }
   }
 
-  function open(shellId, description) {
+  function open(shellId, description, command = '') {
     const id = normalizeShellId(shellId);
     if (!id || shells.has(id)) return null;
-    const shell = { shellId: id, description: String(description || '').trim(), startedAt: now() };
+    const shell = { shellId: id, description: String(description || '').trim(), command: String(command || '').trim(), startedAt: now() };
     shells.set(id, shell);
     return shell;
   }
@@ -308,6 +312,8 @@ export function createBackgroundShellTracker({ now = () => Date.now() } = {}) {
         toolName,
         shellId: normalizeShellId(args.shellId),
         description: String(args.description || '').trim(),
+        // The shell tool's command line, for the row.
+        command: typeof args.command === 'string' ? args.command.trim().slice(0, SHELL_COMMAND_CHARS_MAX) : '',
       });
       return { opened, settled, heralded };
     }
@@ -337,7 +343,7 @@ export function createBackgroundShellTracker({ now = () => Date.now() } = {}) {
 
       const started = SHELL_OPENED_RE.exec(text);
       if (started && data.success !== false) {
-        const shell = open(started[1], call?.description);
+        const shell = open(started[1], call?.description, call?.command);
         if (shell) opened.push(shell);
         return { opened, settled, heralded };
       }