@oar-sh/oar 0.9.2 → 0.9.3

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

@@ -4,8 +4,7 @@
 // control polling, activity channels) but executes turns through the Copilot
 // SDK's headless runtime instead of the `copilot` TUI under a PTY.
 //
-// Dormant until phase 3 registers a worker kind for it. Run it by hand against
-// a live relay with:
+// Run it by hand against a live relay with:
 //
 //   COPILOT_WEB_RELAY_CONFIG=server/config.json \
 //   COPILOT_WORKSPACE_ROOT=/path/to/workspace \
@@ -21,6 +20,10 @@ import {
 import { createApiClient } from '../../shared/worker-runtime/api-client.mjs';
 import { createWorkerWebSocketLink } from '../../shared/worker-runtime/worker-websocket-link.mjs';
 import { createHeartbeatController } from '../../shared/worker-runtime/heartbeat.mjs';
+import {
+  createRunnerLinkBridge,
+  failSettlingRowsOnShutdown,
+} from '../../shared/worker-runtime/runner-link-wiring.mjs';
 import { createControlPoller } from '../../shared/control-poller.mjs';
 import { installWorkerCrashGuard } from '../../shared/worker-crash-guard.mjs';
 import {
@@ -69,8 +72,29 @@ async function main() {
     api,
     sdkSessionId,
     abortAckNote: 'copilot session aborted',
+    // A subagent lane's Stop. Lanes are keyed on the envelope agentId, which
+    // is also the runtime's task id, so `rpc.tasks.cancel` is tried; the
+    // runtime refuses ids it does not track (then the control answers "not
+    // supported" and the whole-turn Stop remains). Background agents have no
+    // lane — their Stop is the task panel's. (Late-bound: controls only poll
+    // while a turn is live.)
+    onAbortSubagent: (subagentRunId) => turnRunner.stopBackgroundTask(subagentRunId),
     dbg,
   });
+  // The relay's *Background task timeout* slider (0 = unlimited) rides every
+  // delivery payload, exactly as for the Claude worker: background agents and
+  // shells now have cards and a Stop, so the slider governs them too and a cap
+  // expiry CANCELS them rather than forgetting them. The env var is an
+  // emergency override only.
+  const backgroundTaskTimeoutOverrideMs = readOptionalMs('COPILOT_SDK_RELAY_BACKGROUND_TASK_TIMEOUT_MS');
+  let backgroundTaskTimeoutMs = backgroundTaskTimeoutOverrideMs ?? 0;
+  // The runner reports every flip of its delivery gate; the bridge turns them
+  // into the link's worker.unready / worker.ready frames, so a message queued
+  // while a question card is open is held in the relay queue and steers into
+  // the resumed turn one round trip after the answer.
+  const linkBridge = createRunnerLinkBridge();
+  // Late-bound: the heartbeat controller is built after the runner.
+  let heartbeat = null;
   const turnRunner = createCopilotSdkSessionRunner({
     api,
     sdkSessionId,
@@ -82,23 +106,22 @@ async function main() {
     // How long a deferred model switch may wait for its drain before the
     // explicit selection fails the row (default 10s).
     modelSwitchTimeoutMs: readOptionalMs('COPILOT_SDK_RELAY_MODEL_SWITCH_TIMEOUT_MS'),
-    // How long live detached shells alone may hold the runtime open (0 = no
-    // limit). Deliberately NOT the relay's `background_task_timeout_minutes`
-    // slider that rides every delivery payload: that slider defaults to
-    // 0/unlimited and governs Claude's background tasks, which the composer
-    // lists and can stop. A Copilot detached shell has neither, so consuming it
-    // would make "a forgotten shell pins a runtime forever" the default with
-    // nothing in the UI to reveal it. The runner's own 30-minute cap applies
-    // unless this says otherwise.
-    ...(() => {
-      const override = readOptionalMs('COPILOT_SDK_RELAY_BACKGROUND_TASK_TIMEOUT_MS');
-      return override === undefined ? {} : { getBackgroundTaskTimeoutMs: () => override };
-    })(),
+    getBackgroundTaskTimeoutMs: () => backgroundTaskTimeoutMs,
+    // A readiness flip is a hold starting or ending (question card, approval,
+    // compaction): the composer's steering snapshot changed with it.
+    onDeliveryReadinessChange: (ready) => {
+      linkBridge.onDeliveryReadinessChange(ready);
+      heartbeat?.requestPulse();
+    },
+    // A message became (or stopped being) cancellable: report it now rather
+    // than on the next 10 s heartbeat (coalesced by the controller).
+    onCancellableChange: () => heartbeat?.requestPulse(),
+    canHandBackHeldDelivery: () => linkBridge.canHandBackHeldDelivery(),
     dbg,
   });
 
   let heartbeatTimer = null;
-  const heartbeat = createHeartbeatController({
+  heartbeat = createHeartbeatController({
     api,
     pollMs: HEARTBEAT_MS,
     getSessionReady: () => true,
@@ -110,6 +133,12 @@ async function main() {
     // the crash guard below takes the entries whole so its requeues stay
     // fenced to this attempt.
     getActiveQueueMessageIds: () => turnRunner.getActiveQueueMessageIds().map((entry) => entry.id),
+    // The composer's steering snapshot (Steer / Queue + the hold reason, the
+    // un-steerable rows) and the consumed steers whose settle the runner gave
+    // up on — the relay fails those itself, never re-running them.
+    getSteeringState: () => turnRunner.steeringState(),
+    getSettleFailed: () => turnRunner.getSettleFailed(),
+    onSettleFailedHandled: (ids) => turnRunner.acknowledgeSettleFailed(ids),
   });
 
   const wsLink = createWorkerWebSocketLink({
@@ -119,8 +148,22 @@ async function main() {
     getSessionReady: () => true,
     getSessionId: () => sdkSessionId,
     getPid: () => process.pid,
+    // Mid-turn steering opt-in: the link keeps signalling readiness while a
+    // delivery is in flight as long as the runner can absorb another message
+    // into the live turn, and withdraws it while the runner holds.
+    getSteeringReady: () => turnRunner.canAcceptSteering(),
+    getDeliveryHeld: () => turnRunner.isDeliveryHeld(),
+    // A relay that just (re)started knows nothing of this worker until it
+    // heartbeats; the composer's steering snapshot rides that beat.
+    onServerHello: () => heartbeat.requestPulse(),
     onDeliver: async (pending, reason) => {
       dbg('queue.deliver received', `reason=${reason}`, `msgId=${pending?.message?.id || 'none'}`);
+      // Slider changes reach a running worker on its next delivery; an
+      // explicit env override pins the value regardless.
+      const deliveredTimeout = Number(pending?.settings?.backgroundTaskTimeoutMs);
+      if (backgroundTaskTimeoutOverrideMs === undefined && Number.isFinite(deliveredTimeout) && deliveredTimeout >= 0) {
+        backgroundTaskTimeoutMs = deliveredTimeout;
+      }
       try {
         return await turnRunner.handlePendingPayload(pending);
       } catch (error) {
@@ -129,19 +172,38 @@ async function main() {
       }
     },
     onControl: (control) => {
-      // Background-task controls have no Copilot SDK equivalent yet: the
-      // runtime's `session.background_tasks_changed` carries an empty payload
-      // (23 of them fire during a single bash call), so there is no task id to
-      // stop. Logged rather than silently dropped.
-      dbg('worker control ignored (unsupported by the SDK worker)', String(control?.type || '(none)'));
+      const type = String(control?.type || '').trim();
+      if (type === 'cancel_pushed_message') {
+        // Un-steer: pull a pushed-but-unconsumed message back out of the
+        // runtime's queue and cancel its row.
+        void turnRunner.cancelPushedMessage(control?.messageId).catch((error) => {
+          dbg('un-steer failed', error?.message || String(error));
+        });
+        return;
+      }
+      if (type === 'stop_background_task') {
+        // The task panel's per-card Stop → rpc.tasks.cancel.
+        const taskId = String(control?.taskId || '').trim();
+        dbg('stop background task control', taskId);
+        void turnRunner.stopBackgroundTask(taskId).catch((error) => {
+          dbg('stop background task failed', error?.message || String(error));
+        });
+        return;
+      }
+      dbg('worker control ignored (unsupported by the SDK worker)', type || '(none)');
     },
   });
+  linkBridge.attach(wsLink);
 
   const shutdown = async (signal) => {
     dbg(`shutting down (${signal})`);
     try { wsLink.stop(); } catch {}
     try { heartbeat.stopHeartbeat(); } catch {}
     try { controlPoller.stop(); } catch {}
+    // Rows whose prompt the runtime consumed and whose settle marker has not
+    // landed are failed terminally, never left for dead-worker recovery to
+    // requeue (that would run the prompt twice). Bounded.
+    try { await failSettlingRowsOnShutdown({ api, runner: turnRunner }); } catch {}
     // Bounded, like the Cursor worker: stopping the runtime is an RPC, and a
     // hung stop must never make the process ignore the supervisor's SIGTERM.
     try {

package/server/db-schema.mjs

@@ -9,6 +9,7 @@
 // final schema either way.
 import { rebuildRecentWorkspaceRootsTable } from './migrations/0002-recent-workspace-roots-path-key.mjs';
 import { ensurePushSubscriptionsTable } from './migrations/0003-push-subscriptions.mjs';
+import { migrateSteerSettleMarkers } from './migrations/0004-steer-settle-markers.mjs';
 import { migrateImageConversationSchema } from './repositories/image-conversation-repository.mjs';
 
 // Mirrors DEFAULT_RELAY_MODE in server-runtime.mjs; used only by the one-time
@@ -637,6 +638,13 @@ if (!queueColumns.includes('parked_at')) {
 if (!queueColumns.includes('parked_target_session_id')) {
   db.exec(`ALTER TABLE queue ADD COLUMN parked_target_session_id TEXT`);
 }
+if (!queueColumns.includes('consumed_at')) {
+  // Set when the Claude CLI has provably taken a row's prompt (a steer still
+  // pending when the turn it was pushed into finished). A consumed row is
+  // at-most-once: every recovery path fails it terminally instead of
+  // requeueing it, because a re-delivery would run the prompt a second time.
+  db.exec(`ALTER TABLE queue ADD COLUMN consumed_at TEXT`);
+}
 if (!queueColumns.includes('kind')) {
   // 'continuation' rows are synthetic turns for the Claude worker's
   // background-task continuations: born 'processing', never deliverable, and
@@ -682,6 +690,18 @@ db.exec(`CREATE INDEX IF NOT EXISTS idx_queue_owner_pending ON queue(status, own
 db.exec(`CREATE INDEX IF NOT EXISTS idx_queue_parked_release ON queue(status, parked_transaction_id, parked_target_session_id, parked_at, timestamp)`);
 db.exec(`CREATE UNIQUE INDEX IF NOT EXISTS idx_queue_continuation_op ON queue(continuation_op_id) WHERE continuation_op_id IS NOT NULL`);
 migrateImageConversationSchema(db);
+// After the queue's response_message_id exists: the source-link backfill
+// reads it. Not boot-critical — every reader of its columns tolerates their
+// absence — so a failure (e.g. SQLITE_BUSY) is logged and retried next boot
+// instead of keeping the relay down.
+try {
+  const steerSettleMarkersMigration = migrateSteerSettleMarkers(db);
+  if (steerSettleMarkersMigration.foldStubsRekinded) {
+    console.log(`[steering] re-kinded ${steerSettleMarkersMigration.foldStubsRekinded} fold stub(s) as 'folded'`);
+  }
+} catch (error) {
+  console.warn(`[steering] migration 0004 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) {

package/server/migrations/0004-steer-settle-markers.mjs

@@ -0,0 +1,119 @@
+'use strict';
+
+/**
+ * Migration: give steering settle stubs a durable shape the transcript can
+ * render on reload.
+ *
+ * 1. `messages.source_message_id` — the user message an assistant row answers.
+ *    The link used to live only in `queue.response_message_id`, and the queue
+ *    keeps just the newest 200 finished rows, so older assistant rows lost
+ *    their anchor and fell back to response-time ordering: an absorbed
+ *    (handed-off) reply then sorted below the steered message it hands off to,
+ *    and the merge never applied. Backfilled from whatever queue rows remain.
+ * 2. `messages.resend_of_message_id` — on a user message sent with Resend,
+ *    the stopped steer it re-sends. Durable, so "Resent" survives reloads and
+ *    other devices, and the relay can refuse a second Resend of one original.
+ * 3. Fold stubs saved as kind='absorbed' become kind='folded'. 'absorbed'
+ *    tells the client the reply continues through the NEXT user message, so
+ *    the next ordinary message after a fold was styled as steered.
+ *
+ * Idempotent: the column is added once, the backfill only fills NULLs, and the
+ * kind rewrite matches nothing once applied. Safe to run on every boot.
+ *
+ * Usage: node server/migrations/0004-steer-settle-markers.mjs [path/to/copilot.db]
+ */
+
+import { fileURLToPath } from 'url';
+import path from 'path';
+import process from 'process';
+import Database from 'better-sqlite3';
+
+import { STEER_FOLDED_TEXT } from '../../shared/steer-settle-markers.mjs';
+
+function tableExists(db, name) {
+  return !!db
+    .prepare(`SELECT name FROM sqlite_master WHERE type = 'table' AND name = ?`)
+    .get(name);
+}
+
+function columnNames(db, table) {
+  return new Set(db.prepare(`PRAGMA table_info(${table})`).all().map((column) => String(column.name)));
+}
+
+export function migrateSteerSettleMarkers(db) {
+  if (!tableExists(db, 'messages')) {
+    return { applied: false, reason: 'messages table not found', sourceLinksBackfilled: 0, foldStubsRekinded: 0 };
+  }
+  let columns = columnNames(db, 'messages');
+  let columnAdded = false;
+  if (!columns.has('source_message_id')) {
+    db.exec(`ALTER TABLE messages ADD COLUMN source_message_id TEXT`);
+    columnAdded = true;
+  }
+  if (!columns.has('resend_of_message_id')) {
+    db.exec(`ALTER TABLE messages ADD COLUMN resend_of_message_id TEXT`);
+    columnAdded = true;
+  }
+  if (columnAdded) columns = columnNames(db, 'messages');
+  let sourceLinksBackfilled = 0;
+  let foldStubsRekinded = 0;
+  db.transaction(() => {
+    // Walk the (small, pruned) queue rather than correlating every message
+    // against it.
+    if (tableExists(db, 'queue') && columnNames(db, 'queue').has('response_message_id')) {
+      const link = db.prepare(`
+        UPDATE messages SET source_message_id = ?
+        WHERE id = ? AND role = 'assistant' AND source_message_id IS NULL
+      `);
+      const rows = db.prepare(`
+        SELECT id, response_message_id FROM queue
+        WHERE response_message_id IS NOT NULL AND response_message_id != ''
+      `).all();
+      for (const row of rows) {
+        sourceLinksBackfilled += link.run(String(row.id), String(row.response_message_id)).changes;
+      }
+    }
+    if (columns.has('kind')) {
+      foldStubsRekinded = db.prepare(`
+        UPDATE messages SET kind = 'folded'
+        WHERE role = 'assistant' AND kind = 'absorbed' AND TRIM(text) = ?
+      `).run(STEER_FOLDED_TEXT).changes;
+    }
+  })();
+  return {
+    applied: columnAdded || sourceLinksBackfilled > 0 || foldStubsRekinded > 0,
+    columnAdded,
+    sourceLinksBackfilled,
+    foldStubsRekinded,
+  };
+}
+
+export function migrate(dbPath) {
+  const db = new Database(dbPath);
+  try {
+    return migrateSteerSettleMarkers(db);
+  } finally {
+    db.close();
+  }
+}
+
+function defaultDbPath() {
+  const here = path.dirname(fileURLToPath(import.meta.url));
+  return path.resolve(here, '..', 'data', 'copilot.db');
+}
+
+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 0004 on ${dbPath}`);
+    console.log(result.applied
+      ? `  column added: ${result.columnAdded}; source links backfilled: ${result.sourceLinksBackfilled}; fold stubs re-kinded: ${result.foldStubsRekinded}`
+      : `  skipped: ${result.reason || 'nothing to change'}`);
+    process.exit(0);
+  } catch (err) {
+    console.error(`Migration 0004 failed: ${err?.message || err}`);
+    process.exit(1);
+  }
+}

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

@@ -655,10 +655,30 @@ export async function searchMessages(options = {}) {
   return apiFetch(`/api/search/messages?${params.toString()}`);
 }
 
+// Raw fetch instead of apiFetch: a refused delete (the conversation is still
+// working, or its session would not stop) must surface the server's reason.
+// The long timeout covers stopping the session and deleting its CLI session.
 export async function deleteConversation(id) {
   const convId = String(id || '').trim();
-  if (!convId) return null;
-  return apiFetch(`/api/conversation/${convId}`, { method: 'DELETE' });
+  if (!convId || !areNetworkRequestsEnabled()) return null;
+  const url = `/api/conversation/${encodeURIComponent(convId)}`;
+  try {
+    const response = await fetch(`${BASE}${url}`, {
+      signal: requestTimeoutSignal(LONG_REQUEST_TIMEOUT_MS),
+      method: 'DELETE',
+      headers: {
+        'Content-Type': 'application/json',
+        ...authHeaders(),
+      },
+    });
+    const payload = await response.json().catch(() => null);
+    if (!response.ok) return { ...(payload || {}), ok: false, status: response.status };
+    noteFetchSuccess();
+    return payload || { ok: true };
+  } catch (error) {
+    noteFetchFailure(url, error);
+    return null;
+  }
 }
 
 export async function updateMessageShareVisibility(conversationId, messageId, hiddenFromShares) {

package/server/public/app/ask-user-view.js

@@ -10,11 +10,23 @@ import { loadRelayQuestions as loadRelayQuestionsApi, answerRelayQuestion, answe
 import { enqueueOutboxRequest, registerOutboxSync } from './sync-outbox.mjs';
 import { renderLinkedPlainText } from './router.js';
 import { schemaFieldsFromQuestion } from './question-schema-view.mjs';
+import { composeMultiSelectAnswer, isMultiSelectQuestion, offersMultiSelectToggle } from './question-multi-select.mjs';
 import { isChatInteractionHeld } from './selection-guard.mjs';
+import { questionCardHeadLabel } from './conversation-provider-indicator.mjs';
 
 let relayQuestionRenderHash = '';
 let renderedRelayQuestionIds = new Set();
 const relayQuestionStructuredDrafts = new Map();
+// Ticked choices of a multi-select card (question id → Set of labels), kept
+// across re-renders until the card is answered.
+const relayQuestionMultiDrafts = new Map();
+// The "Select several" switch position per card (question id → boolean) on
+// cards that offer it (Copilot); absent = the provider's flag decides.
+const relayQuestionMultiMode = new Map();
+
+function multiModeFor(question) {
+  return question ? relayQuestionMultiMode.get(question.id) : undefined;
+}
 const RELAY_QUESTION_AUTO_SCROLL_THRESHOLD_PX = 80;
 
 function distanceFromBottom(el) {
@@ -75,6 +87,8 @@ export function upsertRelayQuestion(question) {
   relayQuestions.set(question.id, question);
   updatePendingQuestionBanner();
   window.renderConvList?.();
+  // A question opening or settling flips the composer's steering hold.
+  window.syncComposerButtonState?.();
   renderRelayQuestions();
 }
 
@@ -98,10 +112,19 @@ export async function loadRelayQuestions(conversationId) {
       relayQuestionStructuredDrafts.delete(questionId);
     }
   }
+  // Multi-select ticks and the "Select several" switch position die with the
+  // card, whoever settled it (this device, another one, a timeout).
+  for (const draftMap of [relayQuestionMultiDrafts, relayQuestionMultiMode]) {
+    for (const questionId of draftMap.keys()) {
+      const question = next.get(questionId);
+      if (!question || question.status !== 'pending') draftMap.delete(questionId);
+    }
+  }
   relayQuestions.clear();
   for (const [id, q] of next.entries()) relayQuestions.set(id, q);
   updatePendingQuestionBanner();
   window.renderConvList?.();
+  window.syncComposerButtonState?.();
 
   if (!conversationId && pending.length) {
     const latest = pending
@@ -212,6 +235,7 @@ export function renderRelayQuestions() {
       answeredAt: q.answeredAt || '',
       createdAt: q.createdAt || '',
       choices: Array.isArray(q.choices) ? q.choices : [],
+      multiSelect: isMultiSelectQuestion(q, multiModeFor(q)),
       schema: q.requestSchema || null,
     }))
   );
@@ -249,24 +273,41 @@ export function renderRelayQuestions() {
       interactiveHtml = renderMultiFieldForm(question);
     } else {
       const choices = Array.isArray(question.choices) ? question.choices : [];
-      const choiceHtml = choices.length
-        ? (question.status === 'pending'
-            ? `<div class="relay-question-choices">${
-                choices.map((choice) => `<button class="relay-question-choice" data-choice="${escHtml(choice)}" data-relay-focus-key="choice-${escHtml(choice)}" onclick="submitRelayQuestionChoice('${question.id}', this.dataset.choice)">${escHtml(choice)}</button>`).join('')
-              }</div>`
-            : `<div class="relay-question-choices">${
-                choices.map((choice) => `<button class="relay-question-choice" disabled>${escHtml(choice)}</button>`).join('')
-              }</div>`)
+      // A multi-select card (the provider said several may be picked) offers
+      // checkmarks and ONE Reply; ticking never answers by itself.
+      const multiSelect = isMultiSelectQuestion(question, multiModeFor(question));
+      const ticked = relayQuestionMultiDrafts.get(question.id) || new Set();
+      // Copilot cards: a switch between one-click answers and checkmarks,
+      // pre-set from the model's flag or the question's wording.
+      const toggleHtml = question.status === 'pending' && offersMultiSelectToggle(question)
+        ? `<label class="relay-question-multi-toggle"><input type="checkbox" data-relay-focus-key="multi-toggle"${multiSelect ? ' checked' : ''} onchange="setRelayQuestionMultiMode('${question.id}', this.checked)"> Select several</label>`
         : '';
+      let choiceHtml = '';
+      if (choices.length && question.status === 'pending' && multiSelect) {
+        choiceHtml = `<div class="relay-question-choices relay-question-multi" id="relay-question-multi-${question.id}">${
+          choices.map((choice) => `<label class="relay-question-choice relay-question-choice-check"><input type="checkbox" data-choice-value="${escHtml(choice)}" data-relay-focus-key="multi-${escHtml(choice)}"${ticked.has(choice) ? ' checked' : ''} onchange="onRelayQuestionMultiSelectChange('${question.id}', this.dataset.choiceValue, this.checked)"> ${escHtml(choice)}</label>`).join('')
+        }</div>`;
+      } else if (choices.length && question.status === 'pending') {
+        choiceHtml = `<div class="relay-question-choices">${
+          choices.map((choice) => `<button class="relay-question-choice" data-choice="${escHtml(choice)}" data-relay-focus-key="choice-${escHtml(choice)}" onclick="submitRelayQuestionChoice('${question.id}', this.dataset.choice)">${escHtml(choice)}</button>`).join('')
+        }</div>`;
+      } else if (choices.length) {
+        choiceHtml = `<div class="relay-question-choices">${
+          choices.map((choice) => `<button class="relay-question-choice" disabled>${escHtml(choice)}</button>`).join('')
+        }</div>`;
+      }
       const showReplyControls = question.status === 'pending';
       const draftText = String(relayQuestionDrafts.get(question.id) || '');
+      const replyPlaceholder = multiSelect
+        ? 'Add another answer or a note (optional)… (Ctrl/Cmd+Enter to send)'
+        : 'Type a reply… (Ctrl/Cmd+Enter to send)';
       const replyHtml = showReplyControls
         ? `<div class="relay-question-reply">
-            <textarea id="relay-question-input-${question.id}" placeholder="Type a reply… (Ctrl/Cmd+Enter to send)" onkeydown="handleRelayQuestionKey(event, '${question.id}')" oninput="onRelayQuestionDraftInput('${question.id}', this.value)">${escHtml(draftText)}</textarea>
-            <button class="relay-question-submit" onclick="submitRelayQuestionAnswer('${question.id}')">Reply</button>
+            <textarea id="relay-question-input-${question.id}" placeholder="${replyPlaceholder}" onkeydown="handleRelayQuestionKey(event, '${question.id}')" oninput="onRelayQuestionDraftInput('${question.id}', this.value)">${escHtml(draftText)}</textarea>
+            <button class="relay-question-submit" onclick="${multiSelect ? 'submitRelayQuestionMultiSelect' : 'submitRelayQuestionAnswer'}('${question.id}')">${multiSelect ? 'Reply with selection' : 'Reply'}</button>
           </div>`
         : '';
-      interactiveHtml = `${choiceHtml}${replyHtml}`;
+      interactiveHtml = `${choiceHtml}${toggleHtml}${replyHtml}`;
     }
 
     const answeredHtml = question.status === 'answered' && question.answer
@@ -278,7 +319,7 @@ export function renderRelayQuestions() {
 
     wrapper.innerHTML = `
       <div class="relay-question-card${question.status === 'timed_out' ? ' relay-question-timed-out' : ''}">
-        <div class="relay-question-head">Copilot question${modeTag} · ${fmtDate(question.createdAt)}</div>
+        <div class="relay-question-head">${questionCardHeadLabel(conversations[question.conversationId])}${modeTag} · ${fmtDate(question.createdAt)}</div>
         <div class="relay-question-body">${renderLinkedPlainText(question.prompt || '')}</div>
         ${contextHtml}
         ${answeredHtml}
@@ -467,6 +508,7 @@ export async function submitRelayStructuredAnswer(questionId) {
     if (r.question) relayQuestions.set(questionId, r.question);
     updatePendingQuestionBanner();
     window.renderConvList?.();
+    window.syncComposerButtonState?.();
     renderRelayQuestions();
     window.showTransientRelayNotice?.(`✅ Answer received · Agent continuing…`, 7000);
   } catch (e) {
@@ -480,6 +522,44 @@ export async function submitRelayQuestionChoice(questionId, choice) {
   await submitRelayQuestionAnswer(questionId, choice);
 }
 
+/** Ticked labels of a multi-select card, in the card's own order. */
+function tickedMultiSelectLabels(questionId) {
+  const container = document.getElementById(`relay-question-multi-${questionId}`);
+  if (!container) return [...(relayQuestionMultiDrafts.get(questionId) || [])];
+  return Array.from(container.querySelectorAll('input[type="checkbox"]:checked'))
+    .map((el) => String(el.getAttribute('data-choice-value') || ''));
+}
+
+/**
+ * The "Select several" switch: flip the card between one-click answers and
+ * checkmarks. Ticks made so far are kept, and the card re-renders in place.
+ */
+export function setRelayQuestionMultiMode(questionId, enabled) {
+  const id = String(questionId || '');
+  if (!id) return;
+  relayQuestionMultiMode.set(id, enabled === true);
+  renderRelayQuestions();
+}
+
+export function onRelayQuestionMultiSelectChange(questionId, label, checked) {
+  const id = String(questionId || '');
+  const set = relayQuestionMultiDrafts.get(id) || new Set();
+  if (checked) set.add(String(label || ''));
+  else set.delete(String(label || ''));
+  relayQuestionMultiDrafts.set(id, set);
+}
+
+/**
+ * Answer a multi-select card: every ticked choice, plus whatever was typed as
+ * an extra answer, joined the way the provider's own UI would ("A, C").
+ */
+export async function submitRelayQuestionMultiSelect(questionId) {
+  const input = document.getElementById(`relay-question-input-${questionId}`);
+  const answer = composeMultiSelectAnswer(tickedMultiSelectLabels(questionId), input?.value || '');
+  if (!answer) return;
+  await submitRelayQuestionAnswer(questionId, answer);
+}
+
 // Offline fallback: park the answer in the durable outbox so Background Sync
 // (or the next page load) delivers it. A replay against an already-answered
 // or expired question gets a 4xx and is dropped, so this cannot double-answer.
@@ -499,7 +579,13 @@ async function enqueueRelayAnswerForSync(questionId, body) {
 
 export async function submitRelayQuestionAnswer(questionId, presetAnswer = null) {
   const input = document.getElementById(`relay-question-input-${questionId}`);
-  const answer = String(presetAnswer != null ? presetAnswer : (input?.value || '')).trim();
+  // Ctrl/Cmd+Enter in a multi-select card's text field sends the ticked
+  // choices along with the typed text, exactly like its Reply button.
+  const pendingQuestion = relayQuestions.get(questionId) || null;
+  const composed = presetAnswer == null && isMultiSelectQuestion(pendingQuestion, multiModeFor(pendingQuestion))
+    ? composeMultiSelectAnswer(tickedMultiSelectLabels(questionId), input?.value || '')
+    : null;
+  const answer = String(presetAnswer != null ? presetAnswer : (composed ?? (input?.value || ''))).trim();
   if (!answer) return;
 
   const card = document.querySelector(`.relay-question-container[data-question-id="${questionId}"]`);
@@ -522,9 +608,12 @@ export async function submitRelayQuestionAnswer(questionId, presetAnswer = null)
     }
     relayQuestionDrafts.delete(questionId);
     relayQuestionStructuredDrafts.delete(questionId);
+    relayQuestionMultiDrafts.delete(questionId);
+    relayQuestionMultiMode.delete(questionId);
     relayQuestions.set(questionId, r.question);
     updatePendingQuestionBanner();
     window.renderConvList?.();
+    window.syncComposerButtonState?.();
     renderRelayQuestions();
     window.showTransientRelayNotice?.(`✅ Answer received: ${answer} · Agent continuing…`, 7000);
   } catch (e) {

package/server/public/app/attachments-view.js

@@ -221,7 +221,7 @@ export function renderAttachmentPreview() {
   if (!selectedAttachments.length) {
     el.innerHTML = '';
     el.classList.remove('visible');
-    window.syncComposerControlState?.();
+    window.syncComposerButtonState?.();
     syncComposerAttachmentWarning();
     return;
   }
@@ -251,7 +251,7 @@ export function renderAttachmentPreview() {
   `;
   }).join('');
   el.classList.add('visible');
-  window.syncComposerControlState?.();
+  window.syncComposerButtonState?.();
   syncComposerAttachmentWarning();
 }
 
@@ -293,6 +293,41 @@ export function clearAttachments() {
   renderAttachmentPreview();
 }
 
+function composerAttachmentSha(attachment) {
+  return String(attachment?.sha256 || attachment?.uploaded?.sha256 || '').trim().toLowerCase();
+}
+
+/**
+ * Removes the composer entries a send took with it and keeps anything added
+ * after that snapshot, uploading or not. Matches by identity first, then by
+ * content hash — switching away and back mid-send rebuilds the composer from
+ * the draft cache as new objects — and removes one entry per sent attachment,
+ * so a genuine second copy survives. Persisting what remains is the caller's
+ * job.
+ */
+export function removeComposerAttachments(sent = []) {
+  const pending = (Array.isArray(sent) ? sent : []).filter(Boolean);
+  if (!pending.length) return;
+  const removed = new Set();
+  const unmatched = [];
+  for (const att of pending) {
+    if (selectedAttachments.includes(att) && !removed.has(att)) removed.add(att);
+    else unmatched.push(att);
+  }
+  for (const att of unmatched) {
+    const sha = composerAttachmentSha(att);
+    if (!sha) continue;
+    const match = selectedAttachments.find((candidate) => !removed.has(candidate) && composerAttachmentSha(candidate) === sha);
+    if (match) removed.add(match);
+  }
+  if (!removed.size) return;
+  const kept = selectedAttachments.filter((att) => !removed.has(att));
+  for (const att of removed) releaseAttachmentPreviewUrl(att);
+  selectedAttachments.length = 0;
+  selectedAttachments.push(...kept);
+  renderAttachmentPreview();
+}
+
 /**
  * Replaces composer attachments wholesale, used when hydrating a conversation's
  * cached draft attachments. Object URLs from the outgoing set are released.

package/server/public/app/background-task-timeout-options.mjs

@@ -0,0 +1,9 @@
+// Mirrors shared/background-task-timeout.mjs, which the browser cannot import
+// (only server/public is served). shared/background-task-timeout.test.mjs
+// asserts the two stay identical.
+//
+// The settings slider shows this until the relay's own value loads, and keeps
+// showing it if that request fails, so it must be the default the relay
+// enforces: 4 hours. 0 means no limit only when chosen explicitly.
+
+export const DEFAULT_BACKGROUND_TASK_TIMEOUT_MINUTES = 240;