@oar-sh/oar 0.9.12 → 0.9.13

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

@@ -60,6 +60,7 @@ import {
 import { createUsageLimitTracker } from '../../shared/claude-usage-limit.mjs';
 import {
   discoverTaskOutputPaths,
+  shellCommandsOf,
   exitCodeFromSummary,
   isShellTaskType,
   outputDirOf,
@@ -1783,8 +1784,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 +1849,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
@@ -2321,6 +2361,7 @@ export function createClaudeSessionRunner({
   function observeProcessLevel(sdkMessage) {
     const type = String(sdkMessage?.type || '');
     if (type === 'assistant') {
+      recordShellCommands(sdkMessage);
       recordSubagentSpawns(sdkMessage);
       recordSubagentActivity(sdkMessage);
       return;
@@ -2596,6 +2637,7 @@ export function createClaudeSessionRunner({
       }
       syncWorkflowPoller(proc);
       publishBackgroundTasks();
+      prunePinnedCommands(proc);
       evaluateLifecycle();
       return;
     }
@@ -2655,6 +2697,8 @@ 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
@@ -2673,6 +2717,7 @@ export function createClaudeSessionRunner({
             startedAt: published.startedAt || null,
           } : {}),
           ...(outputPath ? { outputPath } : {}),
+          ...(command ? { command } : {}),
           ...(exitCode !== null ? { exitCode } : {}),
           ...(steps !== null ? { steps } : {}),
         });
@@ -3517,6 +3562,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(),

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

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

@@ -1567,6 +1567,7 @@ export function createCopilotSdkSessionRunner({
       taskId: shell.shellId,
       taskType: 'local_bash',
       description: shell.description || 'Detached shell',
+      ...(shell.command ? { command: shell.command } : {}),
       startedAt: shell.startedAt || null,
       stoppable: false,
     }));
@@ -1587,6 +1588,7 @@ export function createCopilotSdkSessionRunner({
           taskId: task.id,
           taskType: 'local_bash',
           description: task.description || task.command || 'Background shell',
+          ...shellCommandField(task),
           startedAt,
           stoppable: true,
           ...(task.progressSummary ? { summary: task.progressSummary } : {}),
@@ -1616,6 +1618,12 @@ export function createCopilotSdkSessionRunner({
     return cards;
   }
 
+  /** A registry shell's command line, bounded (the relay scrubs, then cuts it to 2,000). */
+  function shellCommandField(task) {
+    const command = typeof task?.command === 'string' ? task.command.trim().slice(0, 8000) : '';
+    return command ? { command } : {};
+  }
+
   /** 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();
@@ -1869,6 +1877,7 @@ export function createCopilotSdkSessionRunner({
       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'),
+        ...(shell ? shellCommandField(task) : {}),
         taskType: shell ? 'local_bash' : 'local_agent',
         startedAt: Date.parse(String(task.startedAt || '')) || null,
         ...(task.toolCallId ? { toolUseId: String(task.toolCallId) } : {}),
@@ -2135,6 +2144,7 @@ export function createCopilotSdkSessionRunner({
         postTaskSettle(shell.shellId, {
           ...settleForTask({ type: 'shell', status: '' }, { exitCode: shellExitCodes.get(shell.shellId) ?? null }),
           description: shell.description || 'Detached shell',
+          ...(shell.command ? { command: shell.command } : {}),
           taskType: 'local_bash',
           startedAt: shell.startedAt || null,
         });

package/server/db-schema.mjs

@@ -23,6 +23,7 @@ import { migrateConversationGroups } from './migrations/0014-conversation-groups
 import { migrateConversationGroupPosition } from './migrations/0015-conversation-group-position.mjs';
 import { migrateShareAccessLog } from './migrations/0016-share-access-log.mjs';
 import { migrateConversationHistoryIndexes } from './migrations/0017-conversation-history-indexes.mjs';
+import { migrateBackgroundTaskRows } from './migrations/0018-background-task-rows.mjs';
 import { migrateImageConversationSchema } from './repositories/image-conversation-repository.mjs';
 
 // Mirrors DEFAULT_RELAY_MODE in server-runtime.mjs; used only by the one-time
@@ -845,6 +846,15 @@ try {
   console.warn(`[history] migration 0017 failed; retrying on next boot: ${error?.message || error}`);
 }
 
+// The task console's rows across a restart: one new table. The task store
+// checks for it and keeps its rows in memory only without it, so a failure is
+// logged and retried next boot like 0017.
+try {
+  migrateBackgroundTaskRows(db);
+} catch (error) {
+  console.warn(`[background-tasks] migration 0018 failed; retrying on next boot: ${error?.message || error}`);
+}
+
 const runtimeSessionColumns = db.prepare(`PRAGMA table_info(runtime_sessions)`).all().map((c) => c.name);
 if (runtimeSessionColumns.length) {
   if (!runtimeSessionColumns.includes('strategy')) {

package/server/grok-worker/acp-host-services.mjs

@@ -37,6 +37,9 @@ export function createAcpHostServices({
   platform = process.platform,
   spawnImpl = spawn,
   spawnSyncImpl = spawnSync,
+  // Full path of a program Windows ships (taskkill, Windows PowerShell), or
+  // its bare name when it is not where Windows keeps it.
+  systemToolPath = windowsSystemToolPath,
   fsImpl = fs,
   // Told about every terminal's life (grok-background-tasks.mjs publishes
   // them as background tasks): `started`, `output`, `killed`, `released`,
@@ -65,9 +68,9 @@ export function createAcpHostServices({
         timeout: 10_000,
         stdio: 'ignore',
       });
-      cachedWindowsShell = probe && probe.status === 0 ? 'pwsh' : windowsSystemToolPath('powershell');
+      cachedWindowsShell = probe && probe.status === 0 ? 'pwsh' : systemToolPath('powershell');
     } catch {
-      cachedWindowsShell = windowsSystemToolPath('powershell');
+      cachedWindowsShell = systemToolPath('powershell');
     }
     return cachedWindowsShell;
   }
@@ -210,7 +213,7 @@ export function createAcpHostServices({
     if (platform === 'win32' && entry.proc.pid) {
       // proc.kill() only reaches the shell; shells leave grandchildren behind.
       try {
-        spawnImpl(windowsSystemToolPath('taskkill'), ['/pid', String(entry.proc.pid), '/t', '/f'], {
+        spawnImpl(systemToolPath('taskkill'), ['/pid', String(entry.proc.pid), '/t', '/f'], {
           stdio: 'ignore',
           windowsHide: true,
         });

package/server/grok-worker/grok-background-tasks.mjs

@@ -15,6 +15,8 @@ import { createKeptPosts } from '../../shared/worker-runtime/kept-posts.mjs';
 import { createTaskOutputSpool } from '../../shared/worker-runtime/task-output-spool.mjs';
 
 const MAX_DESCRIPTION_CHARS = 500;
+// A bound on the post: the relay scrubs the command, then cuts it to 2,000.
+const MAX_COMMAND_CHARS = 8000;
 const SPOOL_SWEEP_INTERVAL_MS = 60 * 60 * 1000;
 // Ended terminals remembered for a late exit after their release.
 const MAX_TRACKED_TERMINALS = 200;
@@ -68,6 +70,7 @@ export function createGrokTaskPublisher({
       taskId: entry.taskId,
       taskType: 'local_bash',
       description: entry.description,
+      ...(entry.command ? { command: entry.command } : {}),
       startedAt: entry.startedAt,
       stoppable: true,
       ...(outputPath ? { outputPath, outputKind: 'spool' } : {}),
@@ -117,6 +120,9 @@ export function createGrokTaskPublisher({
     const entry = {
       taskId,
       description: String(command || '').trim().slice(0, MAX_DESCRIPTION_CHARS) || 'Terminal',
+      // The whole command line (the description is cut shorter), for the
+      // console's `| tail` marker.
+      command: String(command || '').trim().slice(0, MAX_COMMAND_CHARS),
       startedAt,
       kill,
       live: false,
@@ -196,6 +202,7 @@ export function createGrokTaskPublisher({
       status,
       summary: exitCode !== null ? `exit code ${exitCode}` : (signal ? `killed by ${signal}` : null),
       description: entry.description,
+      ...(entry.command ? { command: entry.command } : {}),
       taskType: 'local_bash',
       startedAt: entry.startedAt,
       // Absent rather than null: a killed process has no exit code.

package/server/migrations/0018-background-task-rows.mjs

@@ -0,0 +1,101 @@
+'use strict';
+
+/**
+ * Migration: the task console's rows outlive a relay restart.
+ *
+ * `background_task_rows` holds what the relay keeps of a background task
+ * that has a console (a shell or Monitor task naming its output file), per
+ * store key (the id the worker posts under, its SDK session id) and task:
+ *
+ * - `state` 'live': a task of the worker's last set. After a restart it is
+ *   held back until the worker reports again: the worker's set decides which
+ *   are still running, and those of a worker that does not report are marked
+ *   ended, never shown as running again.
+ * - `state` 'ended': the dimmed row the panel keeps for an hour after the end,
+ *   with its status and exit code. `ended_at` (epoch ms) is what the hour
+ *   counts from.
+ * - `row_json` the task row as the store holds it, without the health
+ *   reading (the poller reads the file again).
+ *
+ * Rows go when the hour is up, when the conversation is deleted, and live
+ * rows when the worker's set no longer names them.
+ *
+ * Additive and idempotent. Safe to run on every boot. An older build never
+ * reads the table; its consoles start empty after a restart as before.
+ *
+ * Usage: node server/migrations/0018-background-task-rows.mjs [path/to/copilot.db]
+ */
+
+import { fileURLToPath } from 'url';
+import path from 'path';
+import process from 'process';
+import Database from 'better-sqlite3';
+
+export const BACKGROUND_TASK_ROWS_COLUMNS = Object.freeze(['store_key', 'task_id', 'state', 'row_json', 'ended_at', 'updated_at']);
+
+function tableExists(db, name) {
+  return !!db
+    .prepare(`SELECT name FROM sqlite_master WHERE type = 'table' AND name = ?`)
+    .get(name);
+}
+
+/** Why the table cannot be used (a table of that name with other columns), or ''. */
+export function backgroundTaskRowsTableProblem(db) {
+  if (!tableExists(db, 'background_task_rows')) return 'no background_task_rows table';
+  const present = new Set(db.prepare(`PRAGMA table_info(background_task_rows)`).all().map((column) => column.name));
+  const missing = BACKGROUND_TASK_ROWS_COLUMNS.filter((name) => !present.has(name));
+  return missing.length ? `background_task_rows lacks ${missing.join(', ')}` : '';
+}
+
+export function migrateBackgroundTaskRows(db) {
+  let tablesAdded = 0;
+  if (!tableExists(db, 'background_task_rows')) {
+    db.exec(`
+      CREATE TABLE background_task_rows (
+        store_key  TEXT NOT NULL,
+        task_id    TEXT NOT NULL,
+        state      TEXT NOT NULL CHECK (state IN ('live', 'ended')),
+        row_json   TEXT NOT NULL,
+        ended_at   INTEGER,
+        updated_at INTEGER NOT NULL,
+        PRIMARY KEY (store_key, task_id)
+      )
+    `);
+    tablesAdded += 1;
+  }
+  db.exec(`
+    CREATE INDEX IF NOT EXISTS idx_background_task_rows_ended
+    ON background_task_rows(state, ended_at)
+  `);
+  return { applied: tablesAdded > 0, tablesAdded };
+}
+
+function defaultDbPath() {
+  const here = path.dirname(fileURLToPath(import.meta.url));
+  return path.resolve(here, '..', 'data', 'copilot.db');
+}
+
+export function migrate(dbPath, options = {}) {
+  const db = new Database(dbPath, options);
+  try {
+    return migrateBackgroundTaskRows(db);
+  } finally {
+    db.close();
+  }
+}
+
+const isMain = process.argv[1] && path.resolve(process.argv[1]) === fileURLToPath(import.meta.url);
+if (isMain) {
+  const dbPath = process.argv[2] ? path.resolve(process.argv[2]) : defaultDbPath();
+  try {
+    const result = migrate(dbPath);
+    console.log(`Migration 0018 on ${dbPath}`);
+    console.log(result.applied
+      ? `  background task rows: tables added ${result.tablesAdded}`
+      : '  skipped: nothing to change');
+    process.exit(0);
+  } catch (err) {
+    console.error(`Migration 0018 failed: ${err?.message || err}`);
+    process.exit(1);
+  }
+}

package/server/public/app/action-confirmations.js

@@ -20,6 +20,7 @@ import {
 } from './api-client.js';
 import { isSuspendHostActionVisible } from './settings-modal.js';
 import { describeRelayRestartError } from './relay-restart-error.mjs';
+import { initRelayRestartUi, openRestartRelayConfirmation } from './relay-restart-ui.js';
 import {
   applyHostSuspendState,
   describeHostSuspendBlocker,
@@ -106,21 +107,10 @@ export async function confirmKillCurrentSession() {
   }
 }
 
-export function openRestartRelayConfirmation() {
-  openSummaryModal({
-    title: 'Restart web relay',
-    subtitle: 'Queues restart via /api/relay/shutdown',
-    kind: 'restart-relay',
-    bodyHtml: `
-      <p>Queue a manual relay restart now?</p>
-      <p>The restart waits until the current turn is idle, so it does not interrupt an in-flight turn immediately.</p>
-      <div class="summary-modal-actions">
-        <button class="chat-title-action-btn" type="button" onclick="confirmRestartWebRelay()">🌄 Restart web relay</button>
-        <button class="chat-title-action-btn" type="button" onclick="closeSummaryModal()">Cancel</button>
-      </div>
-    `,
-  });
-}
+// ⋯ → Restart web relay first shows what the restart would wait for and
+// leave running (relay-restart-ui.js); its buttons land in
+// confirmRestartWebRelay below or in confirmRestartRelayNow.
+export { openRestartRelayConfirmation };
 
 export function openEmptyQueueConfirmation() {
   menuDeps.lockChatActionsMenuShield(350);
@@ -375,6 +365,10 @@ export async function confirmRestartWebRelay() {
       showTransientRelayNotice('Relay is already shutting down/restarting.', 7000);
       return;
     }
+    if (result.status === 'shutting_down') {
+      showTransientRelayNotice('Nothing was running: the relay is restarting now.', 7000);
+      return;
+    }
     const queue = result.queue || {};
     showTransientRelayNotice(
       `Relay restart queued (pending=${Number(queue.pendingCount || 0)}, processing=${Number(queue.processingCount || 0)}).`,
@@ -399,6 +393,9 @@ export function initActionConfirmations({
     syncQueueStatusMenuEntry: typeof syncQueueStatusMenuEntry === 'function' ? syncQueueStatusMenuEntry : menuDeps.syncQueueStatusMenuEntry,
     refreshSessionWorkerStatus: typeof refreshSessionWorkerStatus === 'function' ? refreshSessionWorkerStatus : menuDeps.refreshSessionWorkerStatus,
   };
+  // The restart confirmations' and banner's inline handlers live on window
+  // either way (bootstrap exposes this module's own).
+  initRelayRestartUi();
   if (!exposeOnWindow) return;
   window.openKillSessionConfirmation = openKillSessionConfirmation;
   window.openRestartRelayConfirmation = openRestartRelayConfirmation;

package/server/public/app/api-client.js

@@ -45,7 +45,7 @@ export function areNetworkRequestsEnabled() {
   return networkRequestsEnabled;
 }
 
-export async function apiFetch(url, opts = {}) {
+export async function apiFetch(url, { onErrorResponse, ...opts } = {}) {
   // A keepalive request is a page's last word; it goes out even when the
   // page's regular network work is already suspended.
   if (!networkRequestsEnabled && !opts.keepalive) return null;
@@ -61,6 +61,9 @@ export async function apiFetch(url, opts = {}) {
     });
     if (!response.ok) {
       console.error('API error', response.status, url);
+      // A caller that shows why a request failed reads the answer here; the
+      // result is still null.
+      if (typeof onErrorResponse === 'function') await onErrorResponse(response);
       return null;
     }
     noteFetchSuccess();
@@ -585,6 +588,18 @@ export async function updateTaskStallMinutesSetting(minutes) {
   });
 }
 
+// "After a relay restart, tell interrupted sessions to carry on" (off by default).
+export async function loadRestartResumeSetting() {
+  return apiFetch('/api/settings/restart-resume');
+}
+
+export async function updateRestartResumeSetting(enabled) {
+  return apiFetch('/api/settings/restart-resume', {
+    method: 'POST',
+    body: JSON.stringify({ enabled: enabled === true }),
+  });
+}
+
 export async function loadPwaAppNameSetting() {
   return apiFetch('/api/settings/pwa-app-name');
 }
@@ -1425,6 +1440,31 @@ export async function cancelRelayRestart(body = {}) {
   });
 }
 
+// The queued restart's state, and the picture for a restart asked now: the
+// sessions it would wait for, the messages it would hold, the background
+// tasks and whether they survive (routes/relay-restart-routes.mjs).
+export async function loadRelayRestartPreview(action = 'restart') {
+  return apiFetchOrThrow(`/api/relay/shutdown?action=${encodeURIComponent(action)}`);
+}
+
+export async function keepWaitingForRelayRestart(body = {}) {
+  return apiFetchOrThrow('/api/relay/shutdown/keep-waiting', {
+    method: 'POST',
+    body: JSON.stringify({ requestedBy: 'localhost-api', ...(body || {}) }),
+  });
+}
+
+export async function loadRelayRestartMaxWaitSetting() {
+  return apiFetch('/api/settings/relay-restart-max-wait');
+}
+
+export async function updateRelayRestartMaxWaitSetting(maxWaitMinutes) {
+  return apiFetchOrThrow('/api/settings/relay-restart-max-wait', {
+    method: 'POST',
+    body: JSON.stringify({ maxWaitMinutes: Number(maxWaitMinutes) }),
+  });
+}
+
 export async function requestQueueEmpty(body = {}) {
   return apiFetchOrThrow('/api/queue/empty', {
     method: 'POST',
@@ -1436,8 +1476,22 @@ export async function requestQueueEmpty(body = {}) {
   });
 }
 
-export async function sendMessage(body) {
-  return apiFetch('/api/message', { method: 'POST', body: JSON.stringify(body) });
+// Null on any failure, like apiFetch. A send the relay refused for a reason
+// the user can act on (a 409 such as "this conversation's model is no longer
+// available") hands that reason to onRefused first, so the composer can say
+// it instead of "could not be sent". A replayed send that already landed
+// (DUPLICATE_MESSAGE_ID) is not a refusal.
+export async function sendMessage(body, { onRefused } = {}) {
+  return apiFetch('/api/message', {
+    method: 'POST',
+    body: JSON.stringify(body),
+    onErrorResponse: async (response) => {
+      if (response.status !== 409 || typeof onRefused !== 'function') return;
+      const payload = await response.json().catch(() => null);
+      const reason = readableServerError(payload?.error);
+      if (reason && payload?.code !== 'DUPLICATE_MESSAGE_ID') onRefused(reason, payload);
+    },
+  });
 }
 
 // Raw fetch instead of apiFetch: a rejected bootstrap (bad CWD, unavailable