clay-server 4.7.1-beta.3 → 4.7.1-beta.5

package/lib/project-connection.js

@@ -260,7 +260,7 @@ function attachConnection(ctx) {
       }
       var _vendorCaps = (sm.capabilitiesByVendor && sm.capabilitiesByVendor[active.vendor || sm.defaultVendor || "claude"]) || {};
       var activePermissionState = permissionModes.clientState(active, sm.currentPermissionMode, sm.defaultVendor);
-      sendTo(ws, { type: "session_switched", id: active.localId, sessionOriginId: active.sessionOriginId || null, cliSessionId: active.cliSessionId || null, loop: active.loop || null, vendor: active.vendor || null, model: active.model || null, effort: active.effort || initialEffort || null, hasHistory: (active.history && active.history.length > 0), capabilities: _vendorCaps, mode: active.mode || "gui", terminalId: typeof active.terminalId === "number" ? active.terminalId : null, runtimeMode: active.runtimeMode || null, runtimeTerminalId: typeof active.runtimeTerminalId === "number" ? active.runtimeTerminalId : null, tuiSuspended: !!active.tuiSuspended, permissionMode: activePermissionState.requestedPermissionMode, effectivePermissionMode: activePermissionState.effectivePermissionMode, permissionCapabilities: activePermissionState.permissionCapabilities, mcpPermissionModeOverrides: activePermissionState.mcpPermissionModeOverrides });
+      sendTo(ws, { type: "session_switched", id: active.localId, sessionOriginId: active.sessionOriginId || null, cliSessionId: active.cliSessionId || null, loop: active.loop || null, vendor: active.vendor || null, model: active.model || null, effort: active.effort || initialEffort || null, hasHistory: (active.history && active.history.length > 0), capabilities: _vendorCaps, isProcessing: !!active.isProcessing, mode: active.mode || "gui", terminalId: typeof active.terminalId === "number" ? active.terminalId : null, runtimeMode: active.runtimeMode || null, runtimeTerminalId: typeof active.runtimeTerminalId === "number" ? active.runtimeTerminalId : null, tuiSuspended: !!active.tuiSuspended, permissionMode: activePermissionState.requestedPermissionMode, effectivePermissionMode: activePermissionState.effectivePermissionMode, permissionCapabilities: activePermissionState.permissionCapabilities, mcpPermissionModeOverrides: activePermissionState.mcpPermissionModeOverrides });
       if (ctx.autonomousRun) sendTo(ws, { type: "autonomous_run_state", sessionId: active.localId, run: ctx.autonomousRun.project(active.autonomousRun) });
       // Send per-session context sources
       var sessionSources = loadContextSources(slug, active.localId);

package/lib/project-sessions.js

@@ -1760,7 +1760,7 @@ function attachSessions(ctx) {
         // Send feedback as next user message if there's text
         if (feedback) {
           setTimeout(function () {
-            var userMsg = { type: "user_message", text: feedback };
+            var userMsg = { type: "user_message", text: feedback, planFeedback: true };
             session.history.push(userMsg);
             sm.appendToSessionFile(session, userMsg);
             sendToSession(session.localId, userMsg);

package/lib/public/app.js

@@ -284,6 +284,7 @@ import { initDebate, handleDebatePreparing, handleDebateStarted, handleDebateRes
     loadingMore: false,
     historyTotal: 0,
     replayingHistory: false,
+    historyReplayBatch: null,
     projectName: projectName,
     cwd: "",
     currentSlug: currentSlug,

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

@@ -24,6 +24,7 @@ import { clearPermissionModePending } from './permission-control.js';
 import { clearMcpPermissionModePending } from './mcp-ui.js';
 import { createWebSocketLifecycle } from './websocket-lifecycle.js';
 import { createWebSocketWatchdog } from './websocket-watchdog.js';
+import { resetHistoryReplayBatch } from './history-replay-batch.js';
 
 var connectOverlay = null;
 var hasConnectedOnce = false;
@@ -324,6 +325,7 @@ function onConnected() {
 
 export function connect() {
   if (lifecycle.isOffline()) return;
+  resetHistoryReplayBatch();
   var attemptEpoch = lifecycle.beginAttempt();
   attemptStartedAt = Date.now();
   var ws = getWs();

package/lib/public/modules/app-message-router.js

@@ -14,6 +14,7 @@ import { handleClaySessionTarget } from './command-palette.js';
 import { handleDefaultAiMessage } from './default-ai.js';
 import { handleCursorSharingMessage } from './cursor-sharing-preference.js';
 import { handlePendingMessageQueueMessage } from './pending-message-queue.js';
+import { receiveHistoryReplay } from './history-replay-batch.js';
 
 export function handleHomeProtocolMessage(msg) {
   if (handleIssueReference(msg)) return true;
@@ -82,6 +83,10 @@ export function handleHomeProtocolMessage(msg) {
 }
 
 export function processMessage(msg) {
+  receiveHistoryReplay(msg, dispatchMessage);
+}
+
+function dispatchMessage(msg) {
   if (handlePendingMessageQueueMessage(msg)) return;
   if (handleDefaultAiMessage(msg)) return;
   if (handleCursorSharingMessage(msg)) return;

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

@@ -67,7 +67,7 @@ import { renderGeneratedImage, renderImageGenerationProgress, clearImageGenerati
 import { clearPairResultStatus, handlePairResultStatus } from './pair-result-status.js';
 
 // --- App module imports ---
-import { scrollToBottom, addToMessages, addUserMessage, addSystemMessage, removeMatePreThinking, resetStreamBuffer, appendDelta, finalizeAssistantBlock, addConflictMessage, addContextOverflowMessage, showSuggestionChips, armStickyBottom, VENDOR_AVATARS, VENDOR_NAMES } from './app-rendering.js';
+import { scrollToBottom, addToMessages, addUserMessage, addSystemMessage, removeMatePreThinking, resetStreamBuffer, appendDelta, flushStreamBuffer, finalizeAssistantBlock, addConflictMessage, addContextOverflowMessage, showSuggestionChips, armStickyBottom, VENDOR_AVATARS, VENDOR_NAMES } from './app-rendering.js';
 import { setActivity, startUrgentBlink, stopUrgentBlink, blinkSessionDot, updateCrossProjectBlink } from './app-favicon.js';
 import { setStatus } from './app-connection.js';
 import { resolvePaneSession, resolveSwitchedVendor } from './pane-session.js';
@@ -251,16 +251,14 @@ export function processMessage(msg) {
         }
         updateContextPanel();
         updateUsagePanel();
-        // Render + finalize any incomplete turn from the replayed history
-        var _hs = store.snap();
-        if (_hs.currentMsgEl && _hs.currentFullText) {
-          var replayContentEl = _hs.currentMsgEl.querySelector(".md-content");
-          if (replayContentEl) {
-            replayContentEl.innerHTML = renderMarkdown(_hs.currentFullText);
-          }
+        // Keep the active answer and tools attached so live deltas continue
+        // the restored turn instead of starting a second answer bubble.
+        if (store.get('sessionIsProcessing')) {
+          flushStreamBuffer();
+        } else {
+          markAllToolsDone();
+          finalizeAssistantBlock();
         }
-        markAllToolsDone();
-        finalizeAssistantBlock();
         stopUrgentBlink();
         // Clean up debate UI if debate is not active after replay
         if (!isDebateActive()) {
@@ -975,6 +973,12 @@ export function processMessage(msg) {
         if (msg.sessionId != null && String(msg.sessionId) !== String(store.get('activeSessionId'))) break;
         if (msg.clientMessageId && messagesEl.querySelector('[data-client-message-id="' + msg.clientMessageId + '"]')) break;
         if (!store.get('replayingHistory')) beginMarkdownTurn();
+        // A recorded user turn closes the previous one. Tools left open by an
+        // interrupted earlier turn must not keep spinning in a restored
+        // running session, where history_done keeps current tools active.
+        // Question answers, plan feedback and Driver delegations are injected
+        // mid-turn, so tools before them may still be running.
+        else if (!msg.askUserAnswer && !msg.planFeedback && !msg.delegated) markAllToolsDone();
         resetThinkingGroup();
         if (msg.planContent) {
           setPlanContent(msg.planContent);

package/lib/public/modules/chat-render-runtime.js

@@ -168,7 +168,7 @@ export function keepActiveThinkingAtTail() {
 }
 
 export function scrollToBottom() {
-  if (prependAnchor) return;
+  if (prependAnchor || store.get('replayingHistory')) return;
   var messagesEl = getMessagesEl();
   if (!messagesEl) return;
   var distFromBottom = messagesEl.scrollHeight - messagesEl.scrollTop - messagesEl.clientHeight;
@@ -192,7 +192,7 @@ export function scrollToBottom() {
 }
 
 export function forceScrollToBottom() {
-  if (prependAnchor) return;
+  if (prependAnchor || store.get('replayingHistory')) return;
   armStickyBottom(750);
 }
 

package/lib/public/modules/history-replay-batch.js

@@ -0,0 +1,113 @@
+import { store } from './store.js';
+
+// Recovery bounds for a replay whose history_done never arrives. Either limit
+// restores everything received so far and lets later messages through, so a
+// lost terminator cannot capture live output indefinitely.
+export var HISTORY_REPLAY_TIMEOUT_MS = 20000;
+export var HISTORY_REPLAY_MAX_EVENTS = 200000;
+export var HISTORY_REPLAY_MAX_TEXT = 16 * 1024 * 1024;
+var MAX_LOGGED_FAILURES = 5;
+
+function cancelTimer(batch) {
+  if (batch && batch.timer) {
+    clearTimeout(batch.timer);
+    batch.timer = null;
+  }
+}
+
+export function resetHistoryReplayBatch() {
+  cancelTimer(store.get('historyReplayBatch'));
+  store.set({ historyReplayBatch: null, replayingHistory: false });
+}
+
+function canCombine(previous, message) {
+  if (!previous || previous.type !== message.type || typeof previous.text !== 'string' || typeof message.text !== 'string') return false;
+  if (message.type !== 'delta' && message.type !== 'thinking_delta') return false;
+  // Keep identity/metadata boundaries intact. Timestamps on individual tokens
+  // can differ; the first token still supplies the message's display time.
+  var keys = Object.keys(previous).concat(Object.keys(message));
+  return keys.every(function (key) {
+    return key === 'text' || key === '_ts' || previous[key] === message[key];
+  });
+}
+
+function finishText(batch) {
+  if (!batch.textParts) return;
+  batch.items[batch.items.length - 1].text = batch.textParts.join('');
+  batch.textParts = null;
+}
+
+// Diagnostics name the entry type and error class only. Error messages and
+// stacks can quote transcript content, so they are never logged.
+function describeFailure(msg, err) {
+  var type = msg && typeof msg.type === 'string' && /^[A-Za-z0-9_]{1,64}$/.test(msg.type) ? msg.type : 'unknown';
+  var name = err && typeof err.name === 'string' && /^[A-Za-z]{1,64}$/.test(err.name) ? err.name : 'Error';
+  return type + ' entry failed with ' + name;
+}
+
+function deliver(batch, done, dispatch) {
+  cancelTimer(batch);
+  finishText(batch);
+  if (store.get('historyReplayBatch') === batch) store.set({ historyReplayBatch: null });
+  var entries = batch.items.concat([done]);
+  var failures = 0;
+  try {
+    // Each entry is isolated like a separate socket message: one bad record
+    // must not discard the rest of the transcript or history_done cleanup.
+    for (var i = 0; i < entries.length; i++) {
+      try {
+        dispatch(entries[i]);
+      } catch (err) {
+        failures++;
+        if (failures <= MAX_LOGGED_FAILURES) {
+          console.error('[history-replay] Restored history ' + (i + 1) + '/' + entries.length + ': ' + describeFailure(entries[i], err));
+        }
+      }
+    }
+    if (failures > MAX_LOGGED_FAILURES) {
+      console.error('[history-replay] ' + (failures - MAX_LOGGED_FAILURES) + ' more restored history failures were not logged.');
+    }
+  } finally {
+    store.set({ replayingHistory: false });
+  }
+}
+
+function recover(batch, reason, dispatch) {
+  if (store.get('historyReplayBatch') !== batch) return;
+  console.warn('[history-replay] history_done missing after ' + batch.received + ' events (' + reason + '); restoring received history.');
+  deliver(batch, { type: 'history_done', replayRecovered: true }, dispatch);
+}
+
+// WebSocket history arrives across many browser tasks. Collect it before
+// calling the normal handlers so the browser cannot paint intermediate tools,
+// Thinking segments or old answers between those tasks.
+export function receiveHistoryReplay(msg, dispatch) {
+  if (msg.type === 'session_switched' || msg.type === 'project_info') resetHistoryReplayBatch();
+  if (msg.type === 'history_meta') {
+    cancelTimer(store.get('historyReplayBatch'));
+    var started = { items: [msg], textParts: null, received: 1, text: 0, timer: null };
+    started.timer = setTimeout(function () { recover(started, 'timeout', dispatch); }, HISTORY_REPLAY_TIMEOUT_MS);
+    store.set({ historyReplayBatch: started });
+    return;
+  }
+  var batch = store.get('historyReplayBatch');
+  if (!batch) {
+    dispatch(msg);
+    return;
+  }
+  if (msg.type === 'history_done') {
+    deliver(batch, msg, dispatch);
+    return;
+  }
+  batch.received++;
+  if (typeof msg.text === 'string') batch.text += msg.text.length;
+  var previous = batch.items[batch.items.length - 1];
+  if (canCombine(previous, msg)) {
+    if (!batch.textParts) batch.textParts = [previous.text];
+    batch.textParts.push(msg.text);
+  } else {
+    finishText(batch);
+    batch.items.push(Object.assign({}, msg));
+  }
+  if (batch.received >= HISTORY_REPLAY_MAX_EVENTS || batch.text >= HISTORY_REPLAY_MAX_TEXT) recover(batch, 'size', dispatch);
+}

package/lib/yoke/adapters/codex.js

@@ -14,6 +14,7 @@ var { resolveOsUserInfo } = require("../../os-users");
 var backgroundTasks = require("../codex-background-tasks");
 var codexUserInput = require("../codex-user-input");
 var createTurnStop = require("../codex-turn-stop").createTurnStop;
+var idleRecovery = require("../codex-idle-recovery");
 
 // --- Reasoning defaults ---
 // Reasoning summaries are the only readable thinking channel Codex offers:
@@ -895,6 +896,9 @@ function createCodexQueryHandle(appServer, queryOpts) {
   var messageWaiting = null;
   var messageQueueEnded = false;
   var handlerEntry = null;
+  var inputRevision = 0;
+  var resolveLoopFinished;
+  var loopFinished = new Promise(function(resolve) { resolveLoopFinished = resolve; });
 
   function pushMessageToQueue(msg) {
     if (messageQueueEnded) return false;
@@ -1314,6 +1318,7 @@ function createCodexQueryHandle(appServer, queryOpts) {
 
     state.done = true;
     endIterator();
+    resolveLoopFinished();
   }
 
   var handle = {
@@ -1333,6 +1338,7 @@ function createCodexQueryHandle(appServer, queryOpts) {
 
     pushMessage: function(text, images) {
       if (iteratorDone || state.done || messageQueueEnded) return false;
+      inputRevision++;
       var input;
       if (images && images.length > 0) {
         input = [];
@@ -1354,6 +1360,16 @@ function createCodexQueryHandle(appServer, queryOpts) {
       }
     },
 
+    getIdleRecoverySnapshot: function() {
+      if (!state.threadId || !messageWaiting || messageQueue.length || messageQueueEnded || iteratorDone || isCancelled()) return null;
+      return { threadId: state.threadId, revision: inputRevision };
+    },
+
+    retireIdleForRecovery: function() {
+      handle.endInput();
+      return loopFinished;
+    },
+
     setModel: function(model) {
       state.model = model || DEFAULT_CODEX_MODEL;
       return Promise.resolve();
@@ -1477,6 +1493,7 @@ function createCodexAdapter(opts) {
   var _initPromise = null;
   var _initializing = false;
   var _shutdownPromise = null;
+  var _shutdownEpoch = 0;
   var _refCount = 0;
   var _lastActiveAt = Date.now();
   var _shuttingDown = false;
@@ -1560,10 +1577,6 @@ function createCodexAdapter(opts) {
     updateLastActiveAt();
   }
 
-  function waitForRecoveryHandoff() {
-    return _recoveryHandoff || Promise.resolve();
-  }
-
   function retainRecoveryRuntime(runtime) {
     _recoveryRuntimes.push(runtime);
   }
@@ -1612,6 +1625,11 @@ function createCodexAdapter(opts) {
   }
 
   async function createIsolatedRecoveryQuery(queryOpts) {
+    var shutdownEpoch = _shutdownEpoch;
+    function checkCurrent() {
+      idleRecovery.checkAbort(queryOpts);
+      if (_shuttingDown || shutdownEpoch !== _shutdownEpoch) throw createShutdownError();
+    }
     var releaseHandoff;
     var priorHandoff = _recoveryHandoff;
     var myHandoff = new Promise(function(resolve) { releaseHandoff = resolve; });
@@ -1619,6 +1637,11 @@ function createCodexAdapter(opts) {
     await (priorHandoff || Promise.resolve());
     try {
       await _recoveryCleanup;
+      checkCurrent();
+      if (!_initializing && _refCount > 0) {
+        await idleRecovery.retireIdleQueries(_activeQueries.slice(), _appServer, checkCurrent);
+      }
+      checkCurrent();
       if (_refCount > 0 || _initializing) {
         throw new Error("Codex resumed-tool recovery is waiting for an active shared runtime; retry after its current queries finish.");
       }
@@ -1626,6 +1649,7 @@ function createCodexAdapter(opts) {
         var stopped = await adapter.shutdownIfIdle(0);
         if (!stopped) throw new Error("Codex resumed-tool recovery could not safely release the shared runtime; retry after its current queries finish.");
       }
+      checkCurrent();
       var recoveryRuntime = createCodexAdapter(Object.assign({}, _defaultInitOpts, {
         recoveryRuntime: true,
         recoverySessionMcpServer: queryOpts.sessionMcpServer,
@@ -1792,6 +1816,13 @@ function createCodexAdapter(opts) {
       if (_shuttingDown) {
         return Promise.reject(createShutdownError());
       }
+      if (_recoveryHandoff) {
+        var initEpoch = _shutdownEpoch;
+        return _recoveryHandoff.then(function() {
+          if (initEpoch !== _shutdownEpoch) throw createShutdownError();
+          return adapter.init(initOpts);
+        });
+      }
 
       var effectiveInitOpts = Object.assign({}, _defaultInitOpts, initOpts || {});
 
@@ -2004,10 +2035,25 @@ function createCodexAdapter(opts) {
       if (queryOpts && queryOpts.sessionMcpServer && queryOpts.resumeSessionId && !queryOpts.isolatedRecovery) {
         return createIsolatedRecoveryQuery(queryOpts);
       }
-      await waitForRecoveryHandoff();
-
-      if (!_appServer || !_appServer.started) {
-        await adapter.init(queryOpts || {});
+      var queryEpoch = _shutdownEpoch;
+      // Recheck after every await: recovery may replace the runtime while an
+      // ordinary start is waiting for initialization or an earlier handoff.
+      while (true) {
+        idleRecovery.checkAbort(queryOpts || {});
+        if (_shuttingDown || queryEpoch !== _shutdownEpoch) throw createShutdownError();
+        if (_recoveryHandoff) {
+          await _recoveryHandoff;
+          continue;
+        }
+        if (_initializing && _initPromise) {
+          await _initPromise;
+          continue;
+        }
+        if (!_appServer || !_appServer.started) {
+          await adapter.init(queryOpts || {});
+          continue;
+        }
+        break;
       }
 
       if (_shuttingDown) {
@@ -2186,6 +2232,7 @@ function createCodexAdapter(opts) {
 
     // Shutdown the app-server process
     shutdown: function() {
+      _shutdownEpoch++;
       return Promise.all([
         beginShutdown(true),
         shutdownUserRuntimes("shutdown"),

package/lib/yoke/codex-idle-recovery.js

@@ -0,0 +1,52 @@
+// Retire retained inputs only after every query is verified idle. The adapter
+// holds admission closed while this runs; existing handles may still receive
+// messages, so their input revisions must be checked again after each probe.
+function checkAbort(queryOpts) {
+  var signal = queryOpts.abortController && queryOpts.abortController.signal;
+  if (signal && signal.aborted) {
+    var error = new Error("Query cancelled");
+    error.name = "AbortError";
+    throw error;
+  }
+}
+
+function terminalsAreIdle(result) {
+  if (!result || result.nextCursor) return false;
+  var terminals = Array.isArray(result) ? result
+    : result.data || result.terminals || result.backgroundTerminals || result.items;
+  if (!Array.isArray(terminals)) return false;
+  return terminals.every(function(terminal) {
+    var status = String(terminal && (terminal.status || terminal.state) || "").toLowerCase();
+    return /^(exited|terminated|completed|failed)$/.test(status);
+  });
+}
+
+async function retireIdleQueries(entries, server, checkCurrent) {
+  checkCurrent();
+  var candidates = [];
+  for (var i = 0; i < entries.length; i++) {
+    var handle = entries[i].handle;
+    var snapshot = handle && handle.getIdleRecoverySnapshot && handle.getIdleRecoverySnapshot();
+    if (!snapshot) return false;
+    candidates.push({ handle: handle, snapshot: snapshot });
+  }
+  var safe = await Promise.all(candidates.map(function(candidate) {
+    return server.send("thread/backgroundTerminals/list", {
+      threadId: candidate.snapshot.threadId,
+    }, 5000).then(terminalsAreIdle, function() { return false; });
+  }));
+  checkCurrent();
+  for (var ci = 0; ci < candidates.length; ci++) {
+    var current = candidates[ci].handle.getIdleRecoverySnapshot();
+    if (!safe[ci] || !current || current.revision !== candidates[ci].snapshot.revision) return false;
+  }
+  // No awaits between validation and closing every input. A new send either
+  // already invalidated its snapshot or sees a closed input and resumes anew.
+  var finished = candidates.map(function(candidate) {
+    return candidate.handle.retireIdleForRecovery();
+  });
+  await Promise.all(finished);
+  return true;
+}
+
+module.exports = { retireIdleQueries: retireIdleQueries, checkAbort: checkAbort };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "clay-server",
-  "version": "4.7.1-beta.3",
+  "version": "4.7.1-beta.5",
   "description": "Self-hosted team workspace for Claude Code and Codex. Multi-user, browser-based, with persistent AI mates.",
   "bin": {
     "clay-server": "./bin/cli.js"