@oar-sh/oar 0.9.11 → 0.9.12

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,126 @@
+// 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;
+
+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]));
+}
+
+/**
+ * Every task output file a `user` SDK message announces: the tool_result
+ * blocks of backgrounded Bash (and Monitor) calls. 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);
+  }
+  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-sdk-session-process.mjs

@@ -120,6 +120,10 @@ import {
   probeRuntime,
   resolveTurnStallWindows,
 } from '../../shared/worker-runtime/turn-liveness.mjs';
+import { createTaskOutputSpool } from '../../shared/worker-runtime/task-output-spool.mjs';
+import { createShellOutputMirror } from './copilot-shell-output-mirror.mjs';
+import { isTransientProgressText, settleForTask, shellExitFromEvent } from './copilot-task-settle.mjs';
+import { createKeptPosts } from '../../shared/worker-runtime/kept-posts.mjs';
 
 // How long the runtime may sit with no session activity before the worker
 // closes it. The worker process itself stays up and reconnects lazily on the
@@ -235,6 +239,8 @@ const STOPPED_ROW_PUBLISH_WAIT_MS = 5_000;
  * (which carries no payload and fires ~20 times per shell call).
  */
 const DEFAULT_TASK_REFRESH_MS = 250;
+/** How often the task output spool drops files of tasks that ended over an hour ago. */
+const SPOOL_SWEEP_INTERVAL_MS = 60 * 60 * 1000;
 /** Trailing throttle for enrichment-only card updates (a live tool call, tokens). */
 const DEFAULT_TASK_PUBLISH_THROTTLE_MS = 2_000;
 /**
@@ -465,6 +471,9 @@ export function createCopilotSdkSessionRunner({
   // worker asks for a heartbeat, on which the relay learns which process
   // holds the session and asks for the set again.
   onBackgroundTaskSetStale = () => {},
+  // Where attached shells' output is mirrored for the task console
+  // (shared/worker-runtime/task-output-spool.mjs). Tests pass their own.
+  taskOutputSpool = null,
   dbg = () => {},
 } = {}) {
   let client = null;
@@ -619,6 +628,24 @@ export function createCopilotSdkSessionRunner({
   // cards; the registry alone decides liveness (the lifecycle pin).
   let backgroundTasks = new Map();
   const agentDetails = new Map();
+  // A detached shell names its own log (`TaskShellInfo.logPath`); an attached
+  // one has only the runtime's recent-output window, mirrored into a spool
+  // file here so the task console can read it like any other log.
+  const spool = taskOutputSpool || (() => {
+    try { return createTaskOutputSpool({ sessionId: sdkSessionId }); } catch (error) {
+      dbg('task output spool unavailable', error?.message || String(error));
+      return null;
+    }
+  })();
+  const shellOutputMirror = createShellOutputMirror({ spool, dbg });
+  // Ended tasks' files are kept about an hour for the relay; swept at start
+  // and hourly.
+  const sweepSpool = () => {
+    try { spool?.sweep(); } catch (error) { dbg('task output spool sweep failed', error?.message || String(error)); }
+  };
+  sweepSpool();
+  const spoolSweepTimer = setInterval(sweepSpool, SPOOL_SWEEP_INTERVAL_MS);
+  spoolSweepTimer.unref?.();
   let taskRefreshTimer = null;
   let taskRefreshChain = Promise.resolve();
   // Reads of the registry that failed in a row. While there are some, "no
@@ -678,6 +705,16 @@ export function createCopilotSdkSessionRunner({
   // The detached shells this session has running. The lifecycle's pin, and the
   // reason a settled one is worth waiting for.
   const backgroundShells = createBackgroundShellTracker();
+  // How a background task ended, told to the relay (its live set only says
+  // the task is gone). A failed post is kept and sent again after the next
+  // heartbeat answer.
+  const keptTaskSettles = createKeptPosts({ api, dbg: (...args) => dbg('background task settle:', ...args) });
+  // shellId → the exit code the events reported (a `shell_completed`
+  // notification, a `read_bash` result), and the ends already noted
+  // (taskId → { body, exitCode, registryStatus }): a detached shell's code
+  // usually comes with the `read_bash` after its end, and is posted then.
+  const shellExitCodes = new Map();
+  const postedSettles = new Map();
   // When a shell settled and the continuation it should trigger has not opened
   // yet. Holds the runtime for `continuationGraceMs`; cleared by the
   // continuation opening, or by the grace expiring on a runtime that decided it
@@ -1553,6 +1590,7 @@ export function createCopilotSdkSessionRunner({
           startedAt,
           stoppable: true,
           ...(task.progressSummary ? { summary: task.progressSummary } : {}),
+          ...shellOutputFields(task),
         });
         continue;
       }
@@ -1572,11 +1610,22 @@ export function createCopilotSdkSessionRunner({
         ...(detail.lastToolCall ? { lastToolCall: detail.lastToolCall } : {}),
         ...(Number.isFinite(detail.totalTokens) && detail.totalTokens > 0 ? { totalTokens: detail.totalTokens } : {}),
         ...(task.progressSummary ? { summary: task.progressSummary } : {}),
+        ...(Number.isInteger(detail.steps) ? { steps: detail.steps } : {}),
       });
     }
     return cards;
   }
 
+  /** Where the task console reads a shell's output: its own log, or the spool mirror. */
+  function shellOutputFields(task) {
+    const logPath = String(task.logPath || '').trim();
+    if (logPath) return { outputPath: logPath, outputKind: 'file' };
+    if (spool && shellOutputMirror.has(task.id)) {
+      try { return { outputPath: spool.pathFor(task.id), outputKind: 'spool' }; } catch {}
+    }
+    return {};
+  }
+
   /**
    * Mirror the live background work into the relay's task panel (REPLACE
    * semantics, the same route the Claude worker publishes on). Set changes
@@ -1682,6 +1731,8 @@ export function createCopilotSdkSessionRunner({
         model: String(data.model || '').trim(),
         lastToolCall: '',
         totalTokens: 0,
+        // Tool calls so far: the panel row's step count.
+        steps: 0,
         startedAt: Date.now(),
       });
       scheduleTaskRefresh();
@@ -1706,6 +1757,7 @@ export function createCopilotSdkSessionRunner({
       const detail = agentDetails.get(agentId);
       if (type === 'tool.execution_start') {
         detail.lastToolCall = formatToolActivityText(data.toolName, data.arguments);
+        detail.steps += 1;
         publishBackgroundTasks();
       } else if (type === 'assistant.usage') {
         const used = (Number(data.inputTokens) || 0) + (Number(data.outputTokens) || 0);
@@ -1716,6 +1768,9 @@ export function createCopilotSdkSessionRunner({
       } else if (type === 'subagent.completed' || type === 'subagent.failed') {
         const total = Number(data.totalTokens);
         if (Number.isFinite(total) && total > 0) detail.totalTokens = total;
+        // The runtime's own count wins over the events this worker saw.
+        const toolCalls = Number(data.totalToolCalls);
+        if (Number.isFinite(toolCalls) && toolCalls >= 0) detail.steps = Math.floor(toolCalls);
         scheduleTaskRefresh();
       }
     }
@@ -1758,6 +1813,8 @@ export function createCopilotSdkSessionRunner({
     }
     if (session !== target) return;
     taskRefreshFailures = 0;
+    const listedById = new Map((Array.isArray(listed?.tasks) ? listed.tasks : [])
+      .map((task) => [String(task?.id || '').trim(), task]));
     const next = new Map();
     for (const task of Array.isArray(listed?.tasks) ? listed.tasks : []) {
       const id = String(task?.id || '').trim();
@@ -1773,6 +1830,10 @@ export function createCopilotSdkSessionRunner({
         next.set(id, { ...task, id, status, progressSummary: backgroundTasks.get(id)?.progressSummary || '' });
       }
     }
+    // Tasks that left the live set, with where a shell's output is (before
+    // its mirror ends below).
+    const departed = [...backgroundTasks.values()].filter((task) => !next.has(task.id));
+    const departedOutput = new Map(departed.map((task) => [task.id, task.type === 'shell' ? shellOutputFields(task) : {}]));
     // Progress lines for the live set: the agent's latest intent / last
     // activity, a shell's last output line. One RPC per live task per refresh
     // (refreshes are debounced), best effort.
@@ -1781,26 +1842,68 @@ export function createCopilotSdkSessionRunner({
         try {
           const progress = (await askRuntime('tasks.getProgress', () => target.rpc.tasks.getProgress({ id: task.id })))?.progress || null;
           task.progressSummary = summarizeTaskProgress(progress);
+          mirrorShellProgress(task, progress);
         } catch { /* a card without a progress line */ }
       }
+      // A mirrored shell that just left the live set: its last window, once
+      // (the runtime still tracks a finished task), then the mirror ends.
+      for (const id of shellOutputMirror.ids()) {
+        if (next.has(id)) continue;
+        try {
+          const progress = (await askRuntime('tasks.getProgress', () => target.rpc.tasks.getProgress({ id })))?.progress || null;
+          if (progress?.type === 'shell') shellOutputMirror.mirror(id, progress.recentOutput);
+        } catch { /* the file keeps what it had */ }
+        shellOutputMirror.forget(id);
+      }
     }
     if (session !== target) return;
     const setChanged = next.size !== backgroundTasks.size
       || [...next.keys()].some((id) => !backgroundTasks.has(id));
     backgroundTasks = next;
+    // How they ended: the registry's finished entry (its status, an agent's
+    // result) and a shell's exit code.
+    for (const task of departed) {
+      if (task.type !== 'shell' && task.type !== 'agent') continue;
+      const finished = listedById.get(task.id) || task;
+      const shell = task.type === 'shell';
+      postTaskSettle(task.id, {
+        ...settleForTask(finished, { exitCode: shell ? (shellExitCodes.get(task.id) ?? null) : null }),
+        description: task.description || task.displayName || task.command || (shell ? 'Background shell' : 'Background agent'),
+        taskType: shell ? 'local_bash' : 'local_agent',
+        startedAt: Date.parse(String(task.startedAt || '')) || null,
+        ...(task.toolCallId ? { toolUseId: String(task.toolCallId) } : {}),
+        ...(departedOutput.get(task.id) || {}),
+      }, { registryStatus: String(finished.status || '') });
+    }
     publishBackgroundTasks({ immediate: setChanged });
     // The lifecycle poll (every `lifecyclePollMs`) picks the new set up; a
     // re-evaluation here would re-schedule a refresh and spin.
   }
 
+  /**
+   * An attached shell's recent-output window into the spool (a detached one
+   * writes its own log). The refresh cadence is the registry's, unchanged:
+   * the window only stops being thrown away.
+   */
+  function mirrorShellProgress(task, progress) {
+    if (task.type !== 'shell' || progress?.type !== 'shell') return;
+    if (String(task.logPath || '').trim()) return;
+    shellOutputMirror.mirror(task.id, progress.recentOutput);
+  }
+
   function summarizeTaskProgress(progress) {
     if (!progress || typeof progress !== 'object') return '';
     if (progress.type === 'agent') {
+      // A spinner or status line ("⟳ Thinking…") says nothing the row does
+      // not; the newest line with content does, else none.
       const intent = String(progress.latestIntent || '').trim();
-      if (intent) return intent.slice(0, 300);
+      if (intent && !isTransientProgressText(intent)) return intent.slice(0, 300);
       const lines = Array.isArray(progress.recentActivity) ? progress.recentActivity : [];
-      const last = lines.length ? String(lines[lines.length - 1]?.message || '').trim() : '';
-      return last.slice(0, 300);
+      for (let index = lines.length - 1; index >= 0; index -= 1) {
+        const line = String(lines[index]?.message || '').trim();
+        if (line && !isTransientProgressText(line)) return line.slice(0, 300);
+      }
+      return '';
     }
     if (progress.type === 'shell') {
       const output = String(progress.recentOutput || '').trim();
@@ -1972,7 +2075,46 @@ export function createCopilotSdkSessionRunner({
     dbg(`copilot session rpc surfaces: queue=${sessionRpc.queue} interruptMainTurn=${sessionRpc.interruptMainTurn} tasks=${sessionRpc.tasks}`);
   }
 
+  /** A shell's exit code from an event; a settle already posted without it goes again. */
+  function noteShellExit(event) {
+    let exit = null;
+    try { exit = shellExitFromEvent(event); } catch {}
+    if (!exit) return;
+    shellExitCodes.set(exit.shellId, exit.exitCode);
+    while (shellExitCodes.size > 200) shellExitCodes.delete(shellExitCodes.keys().next().value);
+    const posted = postedSettles.get(exit.shellId);
+    if (!posted || posted.exitCode !== null || posted.body.taskType !== 'local_bash') return;
+    postTaskSettle(exit.shellId, {
+      ...posted.body,
+      ...settleForTask({ type: 'shell', status: posted.registryStatus || '' }, { exitCode: exit.exitCode }),
+    }, { registryStatus: posted.registryStatus });
+  }
+
+  /**
+   * Tell the relay how a background task ended (advisory, kept on failure).
+   * An end nothing has told yet (`unknown`) is only noted: the relay already
+   * calls a task that left its set without a word unknown, and an exit code
+   * that comes later is posted then.
+   */
+  function postTaskSettle(taskId, { status, exitCode, summary, ...rest }, { registryStatus } = {}) {
+    const id = String(taskId || '').trim();
+    if (!id) return;
+    const body = {
+      conversationId: sdkSessionId,
+      taskId: id,
+      status,
+      summary: summary || null,
+      ...rest,
+      ...(Number.isInteger(exitCode) ? { exitCode } : {}),
+    };
+    postedSettles.set(id, { body, exitCode: Number.isInteger(exitCode) ? exitCode : null, registryStatus: registryStatus || '' });
+    while (postedSettles.size > 200) postedSettles.delete(postedSettles.keys().next().value);
+    if (status === 'unknown') return;
+    void keptTaskSettles.post('/api/background-task-settled', body);
+  }
+
   function observeBackgroundShells(event) {
+    noteShellExit(event);
     let changed;
     try {
       changed = backgroundShells.observe(event);
@@ -1986,6 +2128,17 @@ export function createCopilotSdkSessionRunner({
     }
     for (const shell of changed.settled) {
       dbg('detached shell settled', shell.shellId);
+      // Without the task registry the tracker's set is the panel's: the end
+      // of a shell it listed is told here (an id it never saw open, as a
+      // foreground shell's result names one, was never a task).
+      if (!sessionRpc.tasks && shell.startedAt) {
+        postTaskSettle(shell.shellId, {
+          ...settleForTask({ type: 'shell', status: '' }, { exitCode: shellExitCodes.get(shell.shellId) ?? null }),
+          description: shell.description || 'Detached shell',
+          taskType: 'local_bash',
+          startedAt: shell.startedAt || null,
+        });
+      }
       const note = describeSettledShell(shell);
       // Only carried when there is no turn to publish into: inside a turn the
       // normalizer already narrates the `read_bash` that reads the output. A
@@ -4741,6 +4894,7 @@ export function createCopilotSdkSessionRunner({
   async function dispose() {
     disposed = true;
     stopLifecycleTimer();
+    clearInterval(spoolSweepTimer);
     if (queueLaneTimer) {
       clearTimeout(queueLaneTimer);
       queueLaneTimer = null;
@@ -4764,6 +4918,8 @@ export function createCopilotSdkSessionRunner({
     acknowledgeSettleFailed,
     backgroundTaskIds,
     resyncBackgroundTasks,
+    // The relay answered a heartbeat: settle notices kept for it go out.
+    flushKeptTaskSettles: () => keptTaskSettles.flush(),
     cancelPushedMessage,
     // The task panel's per-card Stop (`rpc.tasks.cancel`); also what a
     // subagent lane's Stop tries — the runtime tracks sync agents in the same

package/server/copilot-worker/copilot-sdk-session-worker.mjs

@@ -150,6 +150,8 @@ async function main() {
     // restarted, a post was lost) asks for the set again.
     getBackgroundTaskIds: () => turnRunner.backgroundTaskIds(),
     onResyncBackgroundTasks: () => turnRunner.resyncBackgroundTasks(),
+    // The relay answered: settle notices it missed go out.
+    onAnswered: () => turnRunner.flushKeptTaskSettles?.(),
   });
 
   const wsLink = createWorkerWebSocketLink({

package/server/copilot-worker/copilot-shell-output-mirror.mjs

@@ -0,0 +1,94 @@
+// An attached Copilot shell keeps its output in the runtime only: the worker
+// sees it as `tasks.getProgress().recentOutput`, a sliding window of the last
+// lines, on every registry refresh. The task console needs a file, so each
+// window's new part is appended to the session's spool
+// (shared/worker-runtime/task-output-spool.mjs).
+//
+// Consecutive windows overlap: the new part is what follows the longest
+// suffix of the previous window that is also a prefix of the new one. With no
+// overlap at all (more output between two refreshes than the window holds)
+// the lines in between are lost; the new window is appended whole after a
+// line break, and the modal says the output is mirrored from a window.
+
+/** The runtime's placeholder for a shell that has printed nothing yet. */
+const NO_OUTPUT_PLACEHOLDER = '(no output yet)';
+
+/**
+ * Length of the longest suffix of `previous` that is a prefix of `next`
+ * (prefix function over `next + sep + previous`, linear time: windows are
+ * kilobytes and are compared on every refresh).
+ */
+export function overlapLength(previous, next) {
+  const a = String(next || '');
+  const b = String(previous || '');
+  if (!a || !b) return 0;
+  const n = a.length;
+  const fail = new Int32Array(n);
+  for (let i = 1, k = 0; i < n; i += 1) {
+    while (k > 0 && a[i] !== a[k]) k = fail[k - 1];
+    if (a[i] === a[k]) k += 1;
+    fail[i] = k;
+  }
+  let k = 0;
+  for (let i = 0; i < b.length; i += 1) {
+    while (k > 0 && (k === n || b[i] !== a[k])) k = fail[k - 1];
+    if (b[i] === a[k]) k += 1;
+  }
+  return k;
+}
+
+/**
+ * What to append when the window moves from `previous` to `next`:
+ * `{ text, gap }`, `gap` true when the windows share nothing.
+ */
+export function newOutputSuffix(previous, next) {
+  const before = String(previous || '');
+  const after = String(next || '');
+  if (!after || after === before) return { text: '', gap: false };
+  if (!before) return { text: after, gap: false };
+  if (after.startsWith(before)) return { text: after.slice(before.length), gap: false };
+  const overlap = overlapLength(before, after);
+  if (overlap > 0) return { text: after.slice(overlap), gap: false };
+  return { text: after, gap: true };
+}
+
+export function createShellOutputMirror({ spool, dbg = () => {} } = {}) {
+  // taskId → { window, endsWithNewline }
+  const mirrors = new Map();
+
+  /** Feed one `recentOutput` window; returns the text appended. */
+  function mirror(taskId, recentOutput) {
+    const id = String(taskId || '').trim();
+    if (!id || !spool) return '';
+    const state = mirrors.get(id) || { window: '', endsWithNewline: true };
+    mirrors.set(id, state);
+    const window = typeof recentOutput === 'string' ? recentOutput : '';
+    if (!window || window.trim() === NO_OUTPUT_PLACEHOLDER) return '';
+    const { text, gap } = newOutputSuffix(state.window, window);
+    state.window = window;
+    if (!text) return '';
+    const written = gap && !state.endsWithNewline ? `\n${text}` : text;
+    const result = spool.append(id, written);
+    if (result && result.ok === false) dbg('task output spool append failed', id);
+    state.endsWithNewline = written.endsWith('\n');
+    return written;
+  }
+
+  /** Whether a window of this task was ever fed (its spool file is named). */
+  function has(taskId) {
+    return mirrors.has(String(taskId || '').trim());
+  }
+
+  /** The task ended: no more windows; the file stays for the relay. */
+  function forget(taskId) {
+    const id = String(taskId || '').trim();
+    if (!mirrors.delete(id)) return;
+    try { spool?.end?.(id); } catch {}
+  }
+
+  function ids() {
+    return [...mirrors.keys()];
+  }
+
+  return { mirror, has, forget, ids };
+}