clay-server 4.2.0 → 4.3.0-beta.10

package/lib/public/css/sidebar.css

@@ -1262,26 +1262,81 @@
   opacity: 1;
 }
 
-/* Split button: main action + chevron sharing one grid cell. */
+.session-top-action:focus-visible {
+  outline: 2px solid var(--accent);
+  outline-offset: 2px;
+}
+
+/* Primary creation action with an adjacent icon-only provider selector. */
 .session-top-action-split {
   display: flex;
+  flex-wrap: nowrap;
   align-items: stretch;
-  gap: 2px;
+  gap: 0;
   min-width: 0;
 }
 
 .session-top-action-split .split-main {
   flex: 1 1 auto;
   width: auto;
+  min-width: 0;
+  padding: 0 9px;
+  gap: 6px;
+  font-size: 12px;
+  line-height: 1.2;
+  border: 1px solid var(--border-subtle);
+  background: color-mix(in srgb, var(--sidebar-hover) 46%, transparent);
+  color: var(--text);
+  font-weight: 500;
+  white-space: normal;
+  text-align: left;
+  border-radius: 9px 0 0 9px;
 }
 
-.session-top-action-split .split-chevron {
-  flex: 0 0 auto;
-  width: 28px;
-  min-width: 28px;
+.session-top-action-split .split-main:hover {
+  border-color: var(--border);
+  background: var(--sidebar-hover);
+}
+
+.session-top-action-split .split-provider {
+  flex: 0 0 26px;
+  width: 26px;
+  min-width: 26px;
   padding: 0;
+  border: 1px solid var(--border-subtle);
+  border-left-color: var(--border);
+  background: color-mix(in srgb, var(--sidebar-hover) 46%, transparent);
+  border-radius: 0 9px 9px 0;
+  display: inline-flex;
+  align-items: center;
+  gap: 2px;
   justify-content: center;
-  gap: 0;
+}
+
+.session-top-action-split .split-provider:hover {
+  background: var(--sidebar-hover);
+}
+
+.session-create-provider-icon {
+  width: 16px;
+  height: 16px;
+  margin-right: 0;
+  border-radius: 4px;
+  object-fit: cover;
+}
+
+.session-create-provider-chevron {
+  display: inline-flex;
+}
+
+.session-create-provider-chevron .lucide,
+.session-create-provider-chevron svg {
+  width: 14px;
+  height: 14px;
+}
+
+.session-create-provider[aria-expanded="true"] {
+  background: var(--sidebar-hover);
 }
 
 .session-favorites-section {

package/lib/public/index.html

@@ -410,9 +410,9 @@
           <button id="header-info-btn" type="button" title="Session info"><i data-lucide="info"></i></button>
           <div id="header-full-access-btn" class="session-permission-control hidden" role="group" aria-label="Session permission mode">
             <div class="session-permission-segmented">
-              <button type="button" data-permission-mode="default">Ask</button>
-              <button type="button" data-permission-mode="auto">Auto</button>
-              <button type="button" data-permission-mode="bypassPermissions" aria-label="Skip permissions"><span class="permission-label-long">Skip permissions</span><span class="permission-label-short" aria-hidden="true">Skip</span></button>
+              <button type="button" data-permission-mode="default" aria-label="Ask permissions" title="Ask permissions"><span class="permission-label">Ask</span><span class="permission-spinner" aria-hidden="true"></span></button>
+              <button type="button" data-permission-mode="auto" aria-label="Auto permissions" title="Auto permissions"><span class="permission-label">Auto</span><span class="permission-spinner" aria-hidden="true"></span></button>
+              <button type="button" data-permission-mode="bypassPermissions" aria-label="Skip permissions" title="Skip permissions"><span class="permission-label">Skip</span><span class="permission-spinner" aria-hidden="true"></span></button>
             </div>
             <span class="session-permission-status hidden" aria-live="polite"></span>
           </div>

package/lib/public/modules/app-connection.js

@@ -22,10 +22,9 @@ import { beginDefaultVendorConnection, requestDefaultVendor } from './default-ve
 import { clearProjectSplitState } from './split-session-boundary.js';
 import { clearPermissionModePending } from './permission-control.js';
 import { clearMcpPermissionModePending } from './mcp-ui.js';
+import { createWebSocketLifecycle } from './websocket-lifecycle.js';
+import { createWebSocketWatchdog } from './websocket-watchdog.js';
 
-var reconnectTimer = null;
-var reconnectDelay = 1000;
-var connectTimeoutId = null;
 var connectOverlay = null;
 var hasConnectedOnce = false;
 
@@ -44,9 +43,32 @@ var overlayGraceTimer = null;
 // server-global-ws.js. Well under the common 60s proxy read timeout, and one
 // timer per live socket.
 var HEARTBEAT_MS = 25000;
-var heartbeatTimer = null;
-var heartbeatDeadlineTimer = null;
 var disconnectedAt = 0;
+var attemptStartedAt = 0;
+var attemptSocket = null;
+var lifecycle = createWebSocketLifecycle({
+  handshakeTimeoutMs: 12000,
+  onHandshakeTimeout: function (epoch) {
+    if (lifecycle.current(epoch) && attemptSocket) {
+      forceReplaceSocket("handshake_timeout", 0, epoch);
+    }
+  }
+});
+var watchdog = createWebSocketWatchdog({
+  heartbeatIntervalMs: HEARTBEAT_MS,
+  heartbeatDeadlineMs: 10000,
+  probeTimeoutMs: 4000,
+  now: function () { return Date.now(); },
+  isCurrent: function (socket, epoch) {
+    return getWs() === socket && socket.readyState === 1 && lifecycle.current(epoch);
+  },
+  sendPing: function (socket) {
+    socket.send(JSON.stringify({ type: "ping" }));
+  },
+  onFailure: function (reason, epoch, latency) {
+    forceReplaceSocket(reason, 0, epoch, latency);
+  }
+});
 
 function clearOverlayGrace() {
   if (overlayGraceTimer) {
@@ -64,15 +86,54 @@ function showOverlayNow() {
   connectOverlay.classList.remove("hidden");
 }
 
-export function stopHeartbeat() {
-  if (heartbeatTimer) {
-    clearInterval(heartbeatTimer);
-    heartbeatTimer = null;
+function recordConnectionDiagnostic(reason, code, latency) {
+  var safeReasons = { close: true, error: true, handshake_timeout: true, heartbeat_timeout: true, heartbeat_error: true, probe_error: true, probe_timeout: true, auth_timeout: true, "ack-timeout": true, online: true, visible: true };
+  if (!safeReasons[reason]) reason = "unknown";
+  console.warn("[clay] WebSocket diagnostic", {
+    reason: reason,
+    code: typeof code === "number" ? code : 0,
+    retry: lifecycle.getRetryAttempt(),
+    latencyMs: typeof latency === "number" ? Math.max(0, Math.min(latency, 600000)) : null
+  });
+}
+
+function forceReplaceSocket(reason, code, epoch, latency) {
+  if (!lifecycle.current(epoch)) return;
+  var socket = getWs();
+  watchdog.clearProbe();
+  stopHeartbeat();
+  if (socket) {
+    socket.onopen = null;
+    socket.onmessage = null;
+    socket.onerror = null;
+    socket.onclose = null;
+    try { socket.close(); } catch (e) {}
   }
-  if (heartbeatDeadlineTimer) {
-    clearTimeout(heartbeatDeadlineTimer);
-    heartbeatDeadlineTimer = null;
+  setWs(null);
+  recordConnectionDiagnostic(reason, code, latency);
+  setStatus("disconnected");
+  lifecycle.invalidate(epoch);
+  scheduleReconnect(reason);
+}
+
+export function stopHeartbeat() {
+  watchdog.stopHeartbeat();
+}
+
+function suspendSocketForOffline() {
+  watchdog.clearProbe();
+  stopHeartbeat();
+  var socket = getWs();
+  attemptSocket = null;
+  if (socket) {
+    socket.onopen = null;
+    socket.onmessage = null;
+    socket.onerror = null;
+    socket.onclose = null;
+    try { socket.close(); } catch (e) {}
   }
+  setWs(null);
+  if (socket || store.get('connected')) setStatus("disconnected");
 }
 
 // Started once per live socket. The socket it was started for is captured, so
@@ -80,28 +141,51 @@ export function stopHeartbeat() {
 // connection. The pong the server sends back keeps a proxy's upstream read
 // timeout from expiring. A missing pong also identifies a half-open socket,
 // which browsers can otherwise leave OPEN while silently losing sends.
-export function startHeartbeat(socket) {
-  stopHeartbeat();
-  if (!socket) return;
-  heartbeatTimer = setInterval(function () {
-    if (!socket || socket.readyState !== 1 || getWs() !== socket) {
-      stopHeartbeat();
-      return;
-    }
-    try { socket.send(JSON.stringify({ type: "ping" })); } catch (e) {}
-    if (heartbeatDeadlineTimer) clearTimeout(heartbeatDeadlineTimer);
-    heartbeatDeadlineTimer = setTimeout(function () {
-      heartbeatDeadlineTimer = null;
-      if (getWs() === socket && socket.readyState === 1) connect();
-    }, 10000);
-  }, HEARTBEAT_MS);
+export function startHeartbeat(socket, attemptEpoch) {
+  watchdog.startHeartbeat(socket, attemptEpoch);
+}
+
+function suspendSocketWatchdogs() {
+  // A frozen page cannot promise proxy keepalive. Retire its deadlines without
+  // closing the socket; resume performs a fresh bounded liveness check.
+  watchdog.suspend();
+}
+
+function resumeSocketWatchdogs(reason) {
+  var resumed = watchdog.resume();
+  var socket = getWs();
+  if (socket && socket.readyState === 1 && resumed) startHeartbeat(socket, lifecycle.getEpoch());
+  probeReconnect(reason);
 }
 
 export function initConnection() {
   connectOverlay = document.getElementById("connect-overlay");
+  if (typeof navigator !== "undefined" && navigator.onLine === false) lifecycle.setOffline(true);
+  if (document.hidden) suspendSocketWatchdogs();
   window.addEventListener("clay-message-delivery-timeout", function (event) {
     var socket = event.detail && event.detail.socket;
-    if (!socket || getWs() === socket) connect();
+    recordConnectionDiagnostic("ack-timeout", 0, null);
+    if (!socket || getWs() === socket) probeReconnect("ack-timeout");
+  });
+  window.addEventListener("offline", function () {
+    lifecycle.setOffline(true);
+    suspendSocketForOffline();
+  });
+  window.addEventListener("online", function () {
+    lifecycle.wake(function () {
+      if (document.hidden) return;
+      resumeSocketWatchdogs("online");
+    });
+  });
+  document.addEventListener("visibilitychange", function () {
+    if (document.hidden) suspendSocketWatchdogs();
+    else resumeSocketWatchdogs("visible");
+  });
+  document.addEventListener("freeze", function () {
+    suspendSocketWatchdogs();
+  });
+  document.addEventListener("resume", function () {
+    if (!document.hidden) resumeSocketWatchdogs("visible");
   });
 
   // --- Reactive UI sync for connected/processing state ---
@@ -224,6 +308,9 @@ function onConnected() {
 }
 
 export function connect() {
+  if (lifecycle.isOffline()) return;
+  var attemptEpoch = lifecycle.beginAttempt();
+  attemptStartedAt = Date.now();
   var ws = getWs();
   // Tear down the previous socket's heartbeat before a new socket exists, so
   // two sockets can never both be pinging.
@@ -236,37 +323,24 @@ export function connect() {
     ws.onclose = null;
     ws.close();
   }
-  if (connectTimeoutId) { clearTimeout(connectTimeoutId); connectTimeoutId = null; }
-
   var protocol = location.protocol === "https:" ? "wss:" : "ws:";
   var socketPath = store.get('wsPath');
   if (store.get('socketPath') && store.get('socketPath') !== socketPath) clearProjectSplitState();
   store.set({ socketPath: socketPath, activeProjectSlug: null, sessionActivatedProjectSlug: null, sessionListProjectSlug: null, splitGroupsProjectSlug: null });
   var newWs = new WebSocket(protocol + "//" + location.host + socketPath);
   setWs(newWs);
-
-  // If not connected within 3s, force retry
-  connectTimeoutId = setTimeout(function () {
-    if (getWs() !== newWs) return;
-    if (!store.get('connected')) {
-      newWs.onclose = null;
-      newWs.onerror = null;
-      newWs.close();
-      connect();
-    }
-  }, 3000);
+  attemptSocket = newWs;
 
   newWs.onopen = function () {
-    if (getWs() !== newWs) return;
-    if (connectTimeoutId) { clearTimeout(connectTimeoutId); connectTimeoutId = null; }
+    if (getWs() !== newWs || !lifecycle.current(attemptEpoch)) return;
+    if (!lifecycle.markOpen(attemptEpoch)) return;
     if (hasConnectedOnce && disconnectedAt) {
       console.log("[clay] WebSocket reconnected after " + (Date.now() - disconnectedAt) + "ms");
     }
     disconnectedAt = 0;
     setStatus("connected");
-    startHeartbeat(newWs);
-    reconnectDelay = 1000;
-    if (reconnectTimer) { clearTimeout(reconnectTimer); reconnectTimer = null; }
+    startHeartbeat(newWs, attemptEpoch);
+    lifecycle.clearRetry();
 
     // A pane pin is one-shot per WebSocket, not per page lifetime. The server
     // intentionally does not restore pane presence after a daemon restart.
@@ -292,64 +366,81 @@ export function connect() {
   };
 
   newWs.onclose = function (e) {
-    if (getWs() !== newWs) return;
-    if (connectTimeoutId) { clearTimeout(connectTimeoutId); connectTimeoutId = null; }
+    if (getWs() !== newWs || !lifecycle.current(attemptEpoch)) return;
     stopHeartbeat();
+    watchdog.clearProbe();
     disconnectedAt = Date.now();
-    // Abnormal closes are the ones worth reporting: a clean close is either a
-    // deliberate navigation or a server shutdown the user already knows about.
-    if (e && !e.wasClean) {
-      console.warn("[clay] WebSocket closed abnormally: code=" + e.code +
-        " reason=" + (e.reason || "(none)") + " wasClean=false");
-    }
+    recordConnectionDiagnostic("close", e && e.code, attemptStartedAt ? Date.now() - attemptStartedAt : null);
     closeDmUserPicker();
     store.set({ activeProjectSlug: null, sessionActivatedProjectSlug: null });
     setStatus("disconnected");
     setActivity(null);
-    scheduleReconnect();
+    lifecycle.invalidate(attemptEpoch);
+    scheduleReconnect("close");
   };
 
-  newWs.onerror = function () {};
+  newWs.onerror = function () {
+    if (getWs() !== newWs || !lifecycle.current(attemptEpoch)) return;
+    recordConnectionDiagnostic("error", 0, null);
+    forceReplaceSocket("error", 0, attemptEpoch);
+  };
 
   newWs.onmessage = function (event) {
-    if (getWs() !== newWs) return;
+    if (getWs() !== newWs || !lifecycle.current(attemptEpoch)) return;
     // Backup: if we're receiving messages, we're connected
     if (!store.get('connected')) {
       setStatus("connected");
-      reconnectDelay = 1000;
-      if (reconnectTimer) { clearTimeout(reconnectTimer); reconnectTimer = null; }
+      lifecycle.clearRetry();
     }
 
     blinkIO();
     var msg;
     try { msg = JSON.parse(event.data); } catch (e) { return; }
-    if (msg.type === "pong" && heartbeatDeadlineTimer) {
-      clearTimeout(heartbeatDeadlineTimer);
-      heartbeatDeadlineTimer = null;
-    }
+    lifecycle.markLive(attemptEpoch);
+    if (msg.type === "pong") watchdog.acceptPong(newWs, attemptEpoch);
     processMessage(msg);
   };
 }
 
 export function cancelReconnect() {
-  if (reconnectTimer) { clearTimeout(reconnectTimer); reconnectTimer = null; }
+  watchdog.clearProbe();
+  stopHeartbeat();
+  lifecycle.cancel();
+}
+
+function probeReconnect(reason) {
+  if (lifecycle.isOffline() || !lifecycle.current(lifecycle.getEpoch())) return;
+  var socket = getWs();
+  if (socket && socket.readyState === 0) return;
+  if (socket && socket.readyState === 1) {
+    watchdog.probe(socket, lifecycle.getEpoch());
+    return;
+  }
+  scheduleReconnect(reason);
 }
 
-export function scheduleReconnect() {
-  if (reconnectTimer) return;
-  reconnectTimer = setTimeout(function () {
-    reconnectTimer = null;
-    // Check if auth is still valid before reconnecting
-    fetch("/info").then(function (res) {
+export function scheduleReconnect(reason) {
+  lifecycle.schedule(reason || "unknown", function (epoch) {
+    var authEpoch = epoch;
+    var controller = typeof AbortController === "function" ? new AbortController() : null;
+    var authToken = lifecycle.beginAuth(authEpoch, function () {
+      if (controller) controller.abort();
+      scheduleReconnect("auth_timeout");
+    }, function () {
+      if (controller) controller.abort();
+    });
+    if (!authToken) return;
+    fetch("/info", controller ? { signal: controller.signal } : undefined).then(function (res) {
+      if (!lifecycle.finishAuth(authEpoch, authToken)) return;
+      if (!lifecycle.canProceed(authEpoch)) return;
       if (res.status === 401) {
         location.reload();
         return;
       }
       connect();
     }).catch(function () {
-      // Server still down, try connecting anyway
-      connect();
+      var authFinished = lifecycle.finishAuth(authEpoch, authToken);
+      if (authFinished && lifecycle.canProceed(authEpoch)) connect();
     });
-  }, reconnectDelay);
-  reconnectDelay = Math.min(reconnectDelay * 1.5, 10000);
+  });
 }

package/lib/public/modules/app-messages.js

@@ -4,7 +4,8 @@ import { handleIssuesMessageInContext as handleIssuesMessage } from './issues-co
 // All dependencies are direct imports; no context injection needed.
 
 import { store } from './store.js';
-import { acknowledgeMessage, replayPendingMessages } from './message-delivery.js';
+import { acknowledgeMessage, activateDeliverySession, refreshDeliverySessionIdentity } from './message-delivery.js';
+import { initMessageDeliveryUi } from './message-delivery-ui.js';
 import { getWs } from './ws-ref.js';
 
 // --- Leaf module imports ---
@@ -30,6 +31,7 @@ import { syncPaneTitles, maybeRestoreSplitGroup, openGroup } from './split-view.
 import { showPairDialog, handlePairCreated, handleSplitDelegation, showWorkerDelegationNotice, hideWorkerDelegationNotice } from './split-pair-ui.js';
 import { handleSessionActionMessage } from './session-actions.js';
 import { renderWorkerProposal, updateWorkerProposal } from './worker-proposal.js';
+import { renderDriverContinuation, updateDriverContinuation, renderDriverContinuationContext } from './driver-continuation.js';
 import { handleInputSync, autoResize, builtinCommands, setScheduleBtnDisabled, sendShellResultToAgent, handleAcceptedOrdinaryMessage, handleScheduleMessageResult } from './input.js';
 import { startThinking, appendThinking, stopThinking, resetThinkingGroup, createToolItem, updateToolExecuting, updateToolResult, markAllToolsDone, closeToolGroup, removeToolFromGroup, resetToolState, getTools, getPlanContent, setPlanContent, renderPlanBanner, renderPlanCard, getTodoTools, handleTodoWrite, handleTaskCreate, handleTaskUpdate, applyDeadSessionTodoCompaction, isPlanFilePath, enableMainInput, addTurnMeta, updateSubagentActivity, addSubagentToolEntry, markSubagentDone, initSubagentStop, updateSubagentProgress, updateSubagentTaskStatus, renderAskUserQuestion, markAskUserAnswered, renderPermissionRequest, markPermissionCancelled, markPermissionResolved, renderElicitationRequest, markElicitationResolved, renderUserDialogRequest, markUserDialogResolved, updateThinkingTokens } from './tools.js';
 import { finishThinkingTurn, resumeThinkingAfterReplay } from './thinking-lifecycle.js';
@@ -60,6 +62,7 @@ import { handleShellCommandResult } from './shell-command.js';
 import { handleLoopRegistryUpdated, handleScheduleRunStarted, handleScheduleRunFinished, handleLoopScheduled, isSchedulerOpen, enterCraftingMode, exitCraftingMode, handleLoopRegistryFiles } from './scheduler.js';
 import { handleScheduledTaskMessage, handleScheduledTaskSessionSwitched } from './scheduled-tasks.js';
 import { renderGeneratedImage, renderImageGenerationProgress, clearImageGenerationProgress, clearAllImageGenerationProgress } from './generated-images.js';
+import { clearPairResultStatus, handlePairResultStatus } from './pair-result-status.js';
 
 // --- App module imports ---
 import { scrollToBottom, addToMessages, addUserMessage, addSystemMessage, removeMatePreThinking, appendDelta, finalizeAssistantBlock, addConflictMessage, addContextOverflowMessage, showSuggestionChips, armStickyBottom, VENDOR_AVATARS, VENDOR_NAMES } from './app-rendering.js';
@@ -97,6 +100,7 @@ var messagesEl = document.getElementById("messages");
 var headerTitleEl = document.getElementById("header-title");
 var inputEl = document.getElementById("input");
 var connectOverlay = document.getElementById("connect-overlay");
+initMessageDeliveryUi();
 
 export function processMessage(msg) {
   if (handleIssuesMessage(msg)) return;
@@ -240,6 +244,7 @@ export function processMessage(msg) {
         // Restore cached rich context usage BEFORE updateContextPanel runs
         if (msg.contextUsage && !msg.contextUsage.unavailable) store.set({ richContextUsage: msg.contextUsage });
         else markContextUnavailable();
+
         // Restore accurate context data from the last result in full history
         if (msg.lastUsage || msg.lastModelUsage) {
           accumulateContext(msg.lastCost, msg.lastUsage, msg.lastModelUsage, msg.lastStreamInputTokens);
@@ -732,6 +737,10 @@ export function processMessage(msg) {
         if (!msg.ok && msg.error) showToast(msg.error, "error");
         break;
 
+      case "split_worker_close_result":
+        if (!msg.ok && msg.error) showToast(msg.error, "error");
+        break;
+
       case "pair_session_options":
         showPairDialog(msg);
         break;
@@ -756,6 +765,19 @@ export function processMessage(msg) {
         updateWorkerProposal(msg);
         break;
 
+      case "driver_continuation_proposal":
+        renderDriverContinuation(msg);
+        break;
+
+      case "driver_continuation_update":
+      case "driver_continuation_result":
+        updateDriverContinuation(msg);
+        break;
+
+      case "driver_continuation_context":
+        renderDriverContinuationContext(msg);
+        break;
+
       case "split_delegation":
         handleSplitDelegation(msg);
         syncPaneTitles();
@@ -788,6 +810,10 @@ export function processMessage(msg) {
         handleRemoteSelection(msg);
         break;
 
+      case "pair_result_status":
+        handlePairResultStatus(msg);
+        break;
+
       case "session_io":
         blinkSessionDot(msg.id);
         break;
@@ -807,6 +833,7 @@ export function processMessage(msg) {
         break;
 
       case "session_switched":
+        clearPairResultStatus();
         syncAutonomousRunForSession(msg.autonomousRun || null);
         closeWhatsNewArticle();
         // Save draft from outgoing session
@@ -825,10 +852,10 @@ export function processMessage(msg) {
         var _effectiveTerminalId = (typeof msg.runtimeTerminalId === "number")
           ? msg.runtimeTerminalId
           : (typeof msg.terminalId === "number" ? msg.terminalId : null);
-        store.set({ activeSessionId: msg.id, cliSessionId: msg.cliSessionId || null, currentModel: msg.model || "", currentEffort: msg.effort || store.get('currentEffort'), vendorCapabilities: msg.capabilities || {}, sessionIsProcessing: !!msg.isProcessing, activeSessionMode: _effectiveMode, activeTerminalId: _effectiveTerminalId, sessionHasHistory: !!msg.hasHistory, sessionVendorBound: !!msg.vendor || !!msg.hasHistory, sessionFullAccess: msg.permissionMode === "bypassPermissions", currentMode: msg.permissionMode || store.get('currentMode'), effectivePermissionMode: msg.effectivePermissionMode || null, permissionCapabilities: msg.permissionCapabilities || { auto: false, mcpOverride: false }, mcpPermissionModeOverrides: msg.mcpPermissionModeOverrides || {} });
+        store.set({ activeSessionId: msg.id, sessionOriginId: msg.sessionOriginId || null, cliSessionId: msg.cliSessionId || null, currentModel: msg.model || "", currentEffort: msg.effort || store.get('currentEffort'), vendorCapabilities: msg.capabilities || {}, sessionIsProcessing: !!msg.isProcessing, activeSessionMode: _effectiveMode, activeTerminalId: _effectiveTerminalId, sessionHasHistory: !!msg.hasHistory, sessionVendorBound: !!msg.vendor || !!msg.hasHistory, sessionFullAccess: msg.permissionMode === "bypassPermissions", currentMode: msg.permissionMode || store.get('currentMode'), effectivePermissionMode: msg.effectivePermissionMode || null, permissionCapabilities: msg.permissionCapabilities || { auto: false, mcpOverride: false }, mcpPermissionModeOverrides: msg.mcpPermissionModeOverrides || {} });
         handleScheduledTaskSessionSwitched(msg);
         requestLoopInterviewState();
-        replayPendingMessages(msg.id);
+        activateDeliverySession(msg.id, msg.cliSessionId || null, msg.sessionOriginId || null);
         // TUI sessions swap the chat UI for an embedded xterm running
         // `claude` inside a real PTY. Mount or tear down before the rest of
         // the chat-side bookkeeping runs so we don't waste work on hidden DOM.
@@ -922,6 +949,7 @@ export function processMessage(msg) {
 
       case "session_id":
         store.set({ cliSessionId: msg.cliSessionId });
+        refreshDeliverySessionIdentity(msg.cliSessionId, store.get('sessionOriginId') || null);
         break;
 
       case "message_uuid":

package/lib/public/modules/driver-continuation-state.js

@@ -0,0 +1,76 @@
+function clean(value) {
+  return value === undefined || value === null ? "" : String(value);
+}
+
+export function continuationKey(message) {
+  if (!message) return "";
+  var projectSlug = clean(message.projectSlug);
+  var sourceOriginId = clean(message.sourceOriginId);
+  var proposalId = clean(message.proposalId);
+  if (!projectSlug || !sourceOriginId || !proposalId) return "";
+  return projectSlug + "\n" + sourceOriginId + "\n" + proposalId;
+}
+
+export function authoritativeState(message) {
+  return {
+    key: continuationKey(message),
+    projectSlug: clean(message.projectSlug),
+    sourceOriginId: clean(message.sourceOriginId),
+    proposalId: clean(message.proposalId),
+    sourceSessionId: Number(message.sourceSessionId),
+    status: message.status || "pending",
+    requestId: "",
+    requestKind: "",
+    inflight: false,
+    error: message.error || "",
+  };
+}
+
+export function beginRequest(state, kind, requestId, connected) {
+  if (!state || !state.key || state.inflight || connected !== true) return null;
+  if (kind === "decision" && state.status !== "pending") return null;
+  var next = Object.assign({}, state, {
+    inflight: true,
+    requestId: clean(requestId),
+    requestKind: kind,
+    error: "",
+  });
+  return next.requestId ? next : null;
+}
+
+export function applyResponse(state, message) {
+  if (!state || !message || continuationKey(message) !== state.key) return null;
+  if (message.requestId && clean(message.requestId) !== state.requestId) return null;
+  var next = Object.assign({}, state, { inflight: false, requestId: "", requestKind: "" });
+  var sourceSessionId = Number(message.sourceSessionId);
+  if (Number.isInteger(sourceSessionId) && sourceSessionId > 0) next.sourceSessionId = sourceSessionId;
+  if (message.status) next.status = message.status;
+  next.error = message.error || "";
+  return next;
+}
+
+export function failRequest(state, requestId, error) {
+  if (!state || !state.inflight || clean(requestId) !== state.requestId) return null;
+  return Object.assign({}, state, {
+    inflight: false,
+    requestId: "",
+    requestKind: "",
+    error: clean(error) || "The request could not be sent. Try again.",
+  });
+}
+
+export function sendContinuationPayload(ws, payload) {
+  if (!ws || ws.readyState !== 1) return { ok: false, error: "The connection is unavailable. Try again." };
+  try {
+    if (ws.send(JSON.stringify(payload)) === false) {
+      return { ok: false, error: "The request was not accepted by the connection. Try again." };
+    }
+  } catch (error) {
+    return { ok: false, error: "The request could not be sent. Try again." };
+  }
+  return { ok: true };
+}
+
+export function continuationCanAct(state, connected) {
+  return !!state && state.status === "pending" && !state.inflight && connected === true;
+}