@oar-sh/oar 0.9.11 → 0.9.13

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

@@ -58,6 +58,14 @@ import {
   withSlashCommandGuardContent,
 } from '../../shared/slash-command-guard.mjs';
 import { createUsageLimitTracker } from '../../shared/claude-usage-limit.mjs';
+import {
+  discoverTaskOutputPaths,
+  shellCommandsOf,
+  exitCodeFromSummary,
+  isShellTaskType,
+  outputDirOf,
+  usableOutputPath,
+} from './task-output-discovery.mjs';
 
 /**
  * Which system-prompt append a relay mode gets (claude-sdk-adapter's
@@ -77,6 +85,8 @@ 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;
 
 // ---------------------------------------------------------------------------
 // Workflow progress sources (CLI 2.1.226 on-disk formats)
@@ -460,6 +470,10 @@ export function createClaudeSessionRunner({
   // leaves the CLI's own attribution. Piggybacked on deliveries like the
   // window above.
   getAttribution = () => null,
+  // How long a backgrounded Bash command may run without its own timeout
+  // (ms; the relay's Claude setting). Read at spawn only: the CLI takes it
+  // from its environment, so a change applies to the next process.
+  getBackgroundCommandLimitMs = () => null,
   // The per-conversation thinking state ({enabled, display}); read per turn
   // like the window, so a settings change reaches a running process on its
   // next delivery.
@@ -1769,6 +1783,11 @@ export function createClaudeSessionRunner({
           // The workflow digest (poller below) rides the same row; the relay
           // 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, 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) => {
@@ -1788,6 +1807,126 @@ export function createClaudeSessionRunner({
     return Promise.resolve();
   }
 
+  // ---------------------------------------------------------------------------
+  // Task output files
+  //
+  // The relay reads a shell task's console straight from the file the CLI
+  // writes (`<tasks dir>/<taskId>.output`); the worker only names it. Bash
+  // results announce the path (task-output-discovery.mjs); a Monitor result
+  // does not, but its file follows the same scheme next to any known one, and
+  // is named only once it exists. Without a path the relay falls back to the
+  // CLI's `getTaskOutput` snapshot (task_output_snapshot control).
+
+  function rememberTaskOutputPath(processRef, taskId, outputPath) {
+    const id = String(taskId || '').trim();
+    const usable = usableOutputPath(outputPath);
+    if (!id || !usable) return false;
+    const dir = outputDirOf(usable);
+    if (dir) processRef.taskOutputDir = dir;
+    // The first path a task names wins, here as on the relay.
+    if (processRef.taskOutputPaths.has(id)) return false;
+    processRef.taskOutputPaths.set(id, usable);
+    while (processRef.taskOutputPaths.size > MAX_TASK_OUTPUT_PATHS) {
+      processRef.taskOutputPaths.delete(processRef.taskOutputPaths.keys().next().value);
+    }
+    return true;
+  }
+
+  function taskOutputFields(processRef, taskId) {
+    const known = processRef.taskOutputPaths.get(taskId);
+    if (known) return { outputPath: known, outputKind: 'file' };
+    if (processRef.taskOutputDir) {
+      const candidate = nodePath.join(processRef.taskOutputDir, `${taskId}.output`);
+      let exists = false;
+      try { exists = nodeFs.existsSync(candidate); } catch {}
+      if (exists && rememberTaskOutputPath(processRef, taskId, candidate)) {
+        return { outputPath: candidate, outputKind: 'file' };
+      }
+    }
+    return { outputKind: 'snapshot' };
+  }
+
+  /** 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, 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
+   * declare it), posted for the relay to serve. Asked once per viewer open.
+   */
+  async function snapshotTaskOutput(taskId) {
+    const id = String(taskId || '').trim();
+    const processRef = proc;
+    if (!id || typeof processRef?.turn?.getTaskOutput !== 'function') {
+      dbg('task output snapshot unavailable', id || '(no task)');
+      return false;
+    }
+    let answer;
+    try {
+      answer = await processRef.turn.getTaskOutput(id);
+    } catch (error) {
+      dbg('getTaskOutput failed', id, error?.message || String(error));
+      return false;
+    }
+    const output = typeof answer?.output === 'string' ? answer.output : '';
+    const totalBytes = Number(answer?.total_bytes);
+    try {
+      await api('POST', `/api/background-tasks/${encodeURIComponent(id)}/output-snapshot`, {
+        conversationId: sdkSessionId,
+        output,
+        totalBytes: Number.isFinite(totalBytes) && totalBytes >= 0 ? totalBytes : Buffer.byteLength(output),
+        truncated: answer?.truncated === true,
+      });
+      return true;
+    } catch (error) {
+      dbg('task output snapshot post failed', id, error?.message || String(error));
+      return false;
+    }
+  }
+
   // ---------------------------------------------------------------------------
   // Workflow progress poller
   //
@@ -2222,10 +2361,16 @@ export function createClaudeSessionRunner({
   function observeProcessLevel(sdkMessage) {
     const type = String(sdkMessage?.type || '');
     if (type === 'assistant') {
+      recordShellCommands(sdkMessage);
       recordSubagentSpawns(sdkMessage);
       recordSubagentActivity(sdkMessage);
       return;
     }
+    if (type === 'user') {
+      // Any agent's backgrounded shell, the main thread's or a subagent's.
+      recordTaskOutputPaths(sdkMessage);
+      return;
+    }
     if (type !== 'system') return;
     const subtype = String(sdkMessage.subtype || '');
     if (subtype === 'init') {
@@ -2492,6 +2637,7 @@ export function createClaudeSessionRunner({
       }
       syncWorkflowPoller(proc);
       publishBackgroundTasks();
+      prunePinnedCommands(proc);
       evaluateLifecycle();
       return;
     }
@@ -2524,6 +2670,9 @@ export function createClaudeSessionRunner({
         known.toolUseId = String(sdkMessage.tool_use_id || '').trim() || 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.
+        const toolUses = Number(sdkMessage.usage?.tool_uses);
+        if (Number.isFinite(toolUses) && toolUses >= 0) known.steps = Math.floor(toolUses);
         publishBackgroundTasks({ throttled: true });
       }
       return;
@@ -2543,6 +2692,18 @@ export function createClaudeSessionRunner({
         // tell its watchers the end. A failed post is kept and sent again.
         const published = proc.liveTasks.get(taskId) || proc.departedTasks.get(taskId) || null;
         proc.departedTasks.delete(taskId);
+        // A shell's file and exit code make the relay's ended row: its
+        // console stays readable after the task is gone.
+        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
+          ? Math.floor(toolUses)
+          : null;
         void keptTaskSettles.post('/api/background-task-settled', {
           conversationId: sdkSessionId,
           taskId,
@@ -2555,6 +2716,10 @@ export function createClaudeSessionRunner({
             taskType: String(published.taskType || ''),
             startedAt: published.startedAt || null,
           } : {}),
+          ...(outputPath ? { outputPath } : {}),
+          ...(command ? { command } : {}),
+          ...(exitCode !== null ? { exitCode } : {}),
+          ...(steps !== null ? { steps } : {}),
         });
       }
       // A settled session-level task means the CLI is about to dequeue a
@@ -3365,6 +3530,7 @@ export function createClaudeSessionRunner({
     const thinkingEnabled = parseThinkingEnabled(thinkingState.enabled);
     const thinkingDisplay = parseThinkingDisplay(thinkingState.display);
     const attribution = getAttribution() || null;
+    const backgroundCommandLimitMs = getBackgroundCommandLimitMs() ?? null;
     const abortController = new AbortController();
     const processRef = {
       turn: null,
@@ -3391,6 +3557,17 @@ export function createClaudeSessionRunner({
       // taskId → the row of a task that left the live set, until its
       // notification arrives.
       departedTasks: new Map(),
+      // taskId → the file a shell task's output goes to (first named wins),
+      // and the directory of the last one seen: a Monitor task's file sits
+      // 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(),
@@ -3538,6 +3715,7 @@ export function createClaudeSessionRunner({
       thinkingEnabled,
       thinkingDisplay,
       attribution,
+      backgroundCommandLimitMs,
       abortController,
       canUseTool,
       pathToClaudeCodeExecutable,
@@ -4121,6 +4299,7 @@ export function createClaudeSessionRunner({
     isTurnActive,
     stopBackgroundTask,
     stopBackgroundTaskByToolUseId,
+    snapshotTaskOutput,
     backgroundTaskIds,
     resyncBackgroundTasks,
     flushKeptTaskSettles,

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

@@ -18,6 +18,10 @@ import { createControlPoller } from '../../shared/control-poller.mjs';
 import { resolveDeliveredAutoCompactWindow } from '../../shared/auto-compact-window.mjs';
 import { resolveDeliveredThinking } from '../../shared/claude-thinking.mjs';
 import { resolveDeliveredAttribution } from '../../shared/claude-attribution.mjs';
+import {
+  DEFAULT_CLAUDE_BACKGROUND_COMMAND_LIMIT_MS,
+  resolveDeliveredClaudeBackgroundCommandLimitMs,
+} from '../../shared/claude-background-command-limit.mjs';
 import { installWorkerCrashGuard } from '../../shared/worker-crash-guard.mjs';
 import { createClaudeSessionRunner } from './claude-session-process.mjs';
 import { createRunnerLinkBridge, failSettlingRowsOnShutdown } from './claude-worker-link-wiring.mjs';
@@ -70,6 +74,9 @@ async function main() {
   // What this session's commits and PRs say; same piggyback. null = the
   // CLI's own attribution (vanilla).
   let attribution = null;
+  // How long a backgrounded Bash command may run without its own timeout;
+  // same piggyback, applied when the CLI process is next spawned.
+  let backgroundCommandLimitMs = DEFAULT_CLAUDE_BACKGROUND_COMMAND_LIMIT_MS;
 
   const api = createApiClient({
     serverUrl,
@@ -116,6 +123,7 @@ async function main() {
     getAutoCompactWindow: () => autoCompactWindow,
     getThinking: () => thinking,
     getAttribution: () => attribution,
+    getBackgroundCommandLimitMs: () => backgroundCommandLimitMs,
     // A readiness flip is a hold starting or ending (question card,
     // compaction, a turn-opening delivery): the steering snapshot changed
     // with it, so it goes out now rather than on the next 10 s heartbeat.
@@ -190,6 +198,7 @@ async function main() {
       // user choosing Host default.
       thinking = resolveDeliveredThinking(thinking, pending?.settings);
       attribution = resolveDeliveredAttribution(attribution, pending?.settings);
+      backgroundCommandLimitMs = resolveDeliveredClaudeBackgroundCommandLimitMs(backgroundCommandLimitMs, pending?.settings);
       try {
         return await turnRunner.handlePendingPayload(pending);
       } catch (error) {
@@ -205,6 +214,14 @@ async function main() {
         await turnRunner.stopBackgroundTask(taskId);
         return;
       }
+      if (type === 'task_output_snapshot') {
+        // A console opened on a shell task with no output file: the CLI's
+        // last 8 KiB goes to the relay, which serves it as a static tail.
+        const taskId = String(control?.taskId || '').trim();
+        dbg('task output snapshot control', taskId);
+        await turnRunner.snapshotTaskOutput(taskId);
+        return;
+      }
       dbg('unknown worker control ignored', type || '(none)');
     },
   });

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

@@ -0,0 +1,152 @@
+// Where a Claude background shell writes its output, read off the SDK stream.
+//
+// The CLI writes every Bash task (and every Monitor tool task, which is a
+// `local_bash` task of kind "monitor") to `<tasks dir>/<taskId>.output`, and
+// tells the model the path in the Bash tool's result text: "Command running in
+// background with ID: <id>. Output is being written to: <path>." (wording
+// read from the bundled CLI, SDK 0.3.292). The structured result
+// (`SDKUserMessage.tool_use_result`, a BashOutput) names the task id as
+// `backgroundTaskId` but carries no path of its own. `task_notification`
+// repeats the path as `output_file` when the task ends.
+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
+// reads whole, up to its `.output` and the sentence's full stop.
+const OUTPUT_FILE_PATTERN = /Output is being written to:?\s+([^\n;]+?\.output)(?=[.;,]?(?:\s|$))/;
+// Any other shape: one token, without the trailing punctuation.
+const OUTPUT_TOKEN_PATTERN = /Output is being written to:?\s+(\S+?)[.;,]?(?:\s|$)/;
+const TASK_ID_PATTERN = /\bID:\s*([A-Za-z0-9_-]+)/;
+// What the CLI's own background notes start with (Bash, SDK 0.3.292). A
+// foreground command that merely prints "Output is being written to: ..."
+// must never bind a path to a task, so only these, the MCP form below, or a
+// result whose structured output names the task are read.
+const CLI_BACKGROUND_PREFIXES = [
+  'Command running in background',
+  'Command was manually backgrounded',
+  'Command was moved to the background',
+  'Command did not complete within',
+];
+// The backgrounded MCP task's note: no colon, then "; use <tool> on that path".
+const MCP_BACKGROUND_PATTERN = /Output is being written to (\S[^\n;]*?\.output); use \S/;
+
+export function isShellTaskType(taskType) {
+  return SHELL_TASK_TYPES.has(String(taskType || '').trim());
+}
+
+/** An absolute path of sane length, or ''. Windows shapes count on every host. */
+export function usableOutputPath(value) {
+  const text = String(value || '').trim();
+  if (!text || text.length > MAX_OUTPUT_PATH_CHARS) return '';
+  return nodePath.posix.isAbsolute(text) || nodePath.win32.isAbsolute(text) ? text : '';
+}
+
+/** `.../tasks/b8k2m4x7q.output` → `b8k2m4x7q`. */
+function taskIdFromOutputFile(filePath) {
+  const base = String(filePath).split(/[\\/]/).pop() || '';
+  return base.endsWith('.output') ? base.slice(0, -'.output'.length) : '';
+}
+
+/** The directory part of a path, for either separator. */
+export function outputDirOf(filePath) {
+  const text = String(filePath || '');
+  const cut = Math.max(text.lastIndexOf('/'), text.lastIndexOf('\\'));
+  return cut > 0 ? text.slice(0, cut) : '';
+}
+
+function toolResultText(block) {
+  const content = block?.content;
+  if (typeof content === 'string') return content;
+  if (!Array.isArray(content)) return '';
+  return content
+    .filter((part) => part?.type === 'text' && typeof part.text === 'string')
+    .map((part) => part.text)
+    .join('\n');
+}
+
+/** `{ taskId, outputPath }` from one tool result's text, or null. */
+export function parseOutputAnnouncement(text, knownTaskId = '') {
+  const source = String(text || '');
+  if (!source.includes(OUTPUT_MARKER)) return null;
+  const match = source.match(OUTPUT_FILE_PATTERN) || source.match(OUTPUT_TOKEN_PATTERN);
+  const outputPath = usableOutputPath(match?.[1]);
+  if (!outputPath) return null;
+  const taskId = String(knownTaskId || '').trim()
+    || taskIdFromOutputFile(outputPath)
+    || (source.match(TASK_ID_PATTERN)?.[1] || '');
+  return taskId ? { taskId, outputPath } : null;
+}
+
+/** The CLI's own note about a backgrounded call, not a command's printed output. */
+function isBackgroundNote(text) {
+  const source = String(text || '').trimStart();
+  if (CLI_BACKGROUND_PREFIXES.some((prefix) => source.startsWith(prefix))) return true;
+  const mcp = source.match(MCP_BACKGROUND_PATTERN);
+  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, 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) {
+  if (String(sdkMessage?.type || '') !== 'user') return [];
+  const blocks = Array.isArray(sdkMessage?.message?.content) ? sdkMessage.message.content : [];
+  const results = blocks.filter((block) => block?.type === 'tool_result');
+  if (!results.length) return [];
+  const structured = sdkMessage.tool_use_result && typeof sdkMessage.tool_use_result === 'object'
+    ? sdkMessage.tool_use_result
+    : null;
+  const structuredTaskId = results.length === 1 ? String(structured?.backgroundTaskId || '').trim() : '';
+  const found = [];
+  for (const block of results) {
+    const text = toolResultText(block);
+    if (!structuredTaskId && !isBackgroundNote(text)) continue;
+    const announced = parseOutputAnnouncement(text, structuredTaskId);
+    if (announced) found.push({ ...announced, toolUseId: String(block.tool_use_id || '').trim() });
+  }
+  return found;
+}
+
+/**
+ * The exit code a shell task's settle summary names: `Background command
+ * "npm test" failed with exit code 2` / `... completed (exit code 0)`.
+ * The last mention wins (the command's own description may say "exit code").
+ */
+export function exitCodeFromSummary(summary) {
+  const matches = [...String(summary || '').matchAll(/exit code (-?\d+)/gi)];
+  if (!matches.length) return null;
+  const code = Number(matches[matches.length - 1][1]);
+  return Number.isInteger(code) ? code : null;
+}

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 };
       }