clay-server 5.5.0-beta.6 → 5.5.0-beta.8

package/lib/sdk-bridge.js

@@ -1787,6 +1787,11 @@ function createSDKBridge(opts) {
     if (structuredInputSession) requestedUserInputMode = "fallback";
     if (requestedUserInputMode === "auto" && queryContract.defaultUserInputMode) requestedUserInputMode = queryContract.defaultUserInputMode;
     var selectedUserInputMode = yoke.userInput.selectMode(sessionAdapter, requestedUserInputMode);
+    // In fallback mode the adapter denies every native AskUserQuestion call,
+    // so its tool_use block must not become an interactive card: such a card
+    // has no pendingAskUser entry and silently swallows the user's answer.
+    // The fallback dispatch path records the real, answerable card itself.
+    session._askUserNativeDispatch = selectedUserInputMode !== "fallback";
     var recoverQuestionTools = needsCatalogRecovery("questions", 1) && queryContextAvailable();
     function structuredInputContextAvailable() {
       if (!queryContextAvailable()) return false;
@@ -1972,6 +1977,18 @@ function createSDKBridge(opts) {
           ? 'Tool recovery is waiting for this conversation’s runtime to become safely available. Your message is retained; Stop cancels the wait.'
           : 'Tool recovery is ready. Continuing your retained message.' });
       },
+      onRecoveryRepair: function(info) {
+        if (!queryContextAvailable()) return;
+        var commands = (info && Array.isArray(info.commands) ? info.commands : []).map(function(command) {
+          command = String(command).replace(/\s+/g, ' ').trim();
+          return command.length > 80 ? command.slice(0, 77) + '...' : command;
+        }).filter(Boolean);
+        var count = Number(info && info.terminatedBackgroundTerminals) || commands.length || 0;
+        if (!count) return;
+        sendAndRecord(session, { type: 'informational', level: 'info', content: 'Tool recovery stopped '
+          + count + ' background terminal' + (count === 1 ? '' : 's') + ' this conversation left running'
+          + (commands.length ? ' (' + commands.join('; ') + ')' : '') + ' so your message can continue.' });
+      },
       callDynamicTool: function (toolName, args) {
         if (queryRetired() || !queryContextAvailable()) return Promise.reject(new Error("This session tool query is no longer available."));
         var toolDef = findSessionToolDef(toolName);

package/lib/sdk-message-processor.js

@@ -435,7 +435,12 @@ function attachMessageProcessor(ctx) {
             }
           }
         }
-        if (!alreadyRecordedAsk) {
+        // A fallback-mode query denies every native AskUserQuestion, so its
+        // block must not render an answerable card: it has no pendingAskUser
+        // entry and would silently swallow the user's answer. The fallback
+        // dispatch (project-ask-user) records the real card itself.
+        var ghostAskCard = block.name === "AskUserQuestion" && session._askUserNativeDispatch === false && !alreadyRecordedAsk;
+        if (!alreadyRecordedAsk && !ghostAskCard) {
           sendAndRecord(session, { type: "tool_executing", id: block.id, name: block.name, input: input });
         }
 
@@ -445,7 +450,7 @@ function attachMessageProcessor(ctx) {
           session.activeTaskToolIds[block.id] = true;
         }
 
-        if (pushModule && block.name === "AskUserQuestion" && input.questions) {
+        if (pushModule && block.name === "AskUserQuestion" && input.questions && !ghostAskCard) {
           var q = input.questions[0];
           pushModule.sendPush({
             sessionId: session.localId,

package/lib/yoke/adapters/codex.js

@@ -1899,8 +1899,8 @@ function createCodexAdapter(opts) {
       return null;
     },
 
-    retireIdleForRecovery: function(checkCurrent) {
-      return idleRecovery.retireIdleQueries(_activeQueries.slice(), _appServer, checkCurrent);
+    retireIdleForRecovery: function(checkCurrent, repair) {
+      return idleRecovery.retireIdleQueries(_activeQueries.slice(), _appServer, checkCurrent, repair);
     },
 
     createQuery: async function(queryOpts) {

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

@@ -10,15 +10,24 @@ function checkAbort(queryOpts) {
   }
 }
 
-function terminalsAreIdle(result) {
-  if (!result || result.nextCursor) return false;
+function listedTerminals(result) {
+  if (!result || result.nextCursor) return null;
   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);
-  });
+  return Array.isArray(terminals) ? terminals : null;
+}
+
+// Current Codex lists only live processes without a status field; legacy
+// builds reported finished states, so an explicit finished status still counts.
+function terminalFinished(terminal) {
+  var status = String(terminal && (terminal.status || terminal.state) || "").toLowerCase();
+  return /^(exited|terminated|completed|failed)$/.test(status);
+}
+
+function terminalsAreIdle(result) {
+  var terminals = listedTerminals(result);
+  if (!terminals) return false;
+  return terminals.every(terminalFinished);
 }
 
 function observe(checkCurrent, reason, method, rpcCode, threadId) {
@@ -46,7 +55,55 @@ function probeFailure(error, method) {
   return false;
 }
 
-async function retireIdleQueries(entries, server, checkCurrent) {
+// Owner-approved unblock for the conversation being resumed: its own live
+// background terminals would be orphaned in the retired process anyway, so
+// terminate them instead of retaining the conversation blocked forever.
+// Only the recovery target's thread is ever touched; sibling conversations
+// keep their background work. Requires the provider to report the thread
+// idle first so an active turn's terminals are never stopped.
+async function terminateTargetTerminals(server, threadId, checkCurrent, onTerminated) {
+  var method = 'thread/read';
+  var live;
+  try {
+    var status = await probe(server, method, { threadId: threadId, includeTurns: false }, 5000, checkCurrent);
+    checkCurrent();
+    if (!status || !status.thread || status.thread.id !== threadId
+        || !status.thread.status || status.thread.status.type !== 'idle') return false;
+    method = 'thread/backgroundTerminals/list';
+    var terminals = listedTerminals(await probe(server, method, { threadId: threadId }, 5000, checkCurrent));
+    checkCurrent();
+    if (!terminals) return false;
+    live = terminals.filter(function(terminal) { return !terminalFinished(terminal); });
+  } catch (error) { checkCurrent(); if (!server.started) throw error; return probeFailure(error, method); }
+  if (!live.length) return false;
+  var commands = [];
+  for (var i = 0; i < live.length; i++) {
+    var processId = live[i] && (live[i].processId !== undefined && live[i].processId !== null ? live[i].processId : live[i].id);
+    if (processId === undefined || processId === null || processId === '') return false;
+    var outcome;
+    try {
+      outcome = await probe(server, 'thread/backgroundTerminals/terminate', { threadId: threadId, processId: String(processId) }, 5000, checkCurrent);
+    } catch (error) {
+      checkCurrent();
+      if (!server.started) throw error;
+      // An unsupported or failed terminate leaves the conversation retained,
+      // exactly like before this repair existed. Never escalate it.
+      return false;
+    }
+    checkCurrent();
+    observe(checkCurrent, outcome && outcome.terminated === true
+      ? 'background_terminal_terminated' : 'background_terminal_terminate_unconfirmed',
+      'thread/backgroundTerminals/terminate', null, threadId);
+    if (!outcome || outcome.terminated !== true) return false;
+    if (typeof live[i].command === 'string' && live[i].command) commands.push(live[i].command);
+  }
+  if (typeof onTerminated === 'function') {
+    try { onTerminated(commands, live.length); } catch (error) {}
+  }
+  return true;
+}
+
+async function retireIdleQueries(entries, server, checkCurrent, repair) {
   checkCurrent();
   var candidates = [];
   for (var i = 0; i < entries.length; i++) {
@@ -63,7 +120,13 @@ async function retireIdleQueries(entries, server, checkCurrent) {
   checkCurrent();
   for (var ci = 0; ci < candidates.length; ci++) {
     var current = candidates[ci].handle.getIdleRecoverySnapshot();
-    if (!safe[ci]) { observe(checkCurrent, 'background_state_not_proven_idle', null, null, candidates[ci].snapshot.threadId); return false; }
+    if (!safe[ci]) {
+      observe(checkCurrent, 'background_state_not_proven_idle', null, null, candidates[ci].snapshot.threadId);
+      if (repair && repair.threadId && repair.threadId === candidates[ci].snapshot.threadId) {
+        await terminateTargetTerminals(server, repair.threadId, checkCurrent, repair.onTerminated);
+      }
+      return false;
+    }
     if (!current || current.revision !== candidates[ci].snapshot.revision) { observe(checkCurrent, 'input_changed_during_probe', null, null, candidates[ci].snapshot.threadId); return false; }
   }
   // No awaits between validation and closing every input. A new send either
@@ -144,19 +207,24 @@ async function threadIsIdle(server, threadId, checkCurrent) {
   } catch (error) { checkCurrent(); if (!server.started) throw error; return probeFailure(error, method); }
 }
 
-async function releaseThread(entries, server, threadId, checkCurrent) {
+async function releaseThread(entries, server, threadId, checkCurrent, repair) {
   if (!server || !server.started) throw new Error('Codex disconnected while checking recovery admission');
   var matching = entries.filter(function(entry) {
     return entry.handle && entry.handle.getRecoveryThreadId() === threadId;
   });
   if (!matching.length && await threadIsAbsent(server, threadId, checkCurrent)) return true;
   if (matching.length) {
-    if (!await retireIdleQueries(matching, server, checkCurrent)) return false;
+    if (!await retireIdleQueries(matching, server, checkCurrent, repair)) return false;
     checkCurrent();
   } else {
     // A closed SDK handle can leave a loaded provider thread behind. Only an
     // explicitly idle provider thread with verified terminal state may unload.
-    if (!await threadIsIdle(server, threadId, checkCurrent)) return false;
+    if (!await threadIsIdle(server, threadId, checkCurrent)) {
+      if (repair && repair.threadId === threadId) {
+        await terminateTargetTerminals(server, threadId, checkCurrent, repair.onTerminated);
+      }
+      return false;
+    }
   }
   try {
     var result = await probe(server, 'thread/unsubscribe', { threadId: threadId }, 5000, checkCurrent);

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

@@ -71,20 +71,33 @@ function attachRecoveryAdmission(ctx) {
     }
   }
 
-  async function releaseTarget(threadId, checkCurrent) {
+  // The owner's new message to this conversation authorizes stopping the
+  // conversation's OWN leftover background terminals: they would be orphaned
+  // by the runtime handoff anyway. Sibling conversations are never repaired.
+  function repairOptions(queryOpts) {
+    return {
+      threadId: queryOpts.resumeSessionId,
+      onTerminated: function(commands, count) {
+        if (typeof queryOpts.onRecoveryRepair !== 'function') return;
+        try { queryOpts.onRecoveryRepair({ terminatedBackgroundTerminals: count, commands: commands }); } catch (error) {}
+      },
+    };
+  }
+
+  async function releaseTarget(threadId, checkCurrent, repair) {
     checkCurrent.phase('isolated_target');
     var prior = targets.get(threadId);
     if (!prior) return true;
     checkCurrent.observe('isolated_target_reserved');
     if (cleanupFailures.has(prior)) throw cleanupFailures.get(prior);
-    await prior.retireIdleForRecovery(checkCurrent);
+    await prior.retireIdleForRecovery(checkCurrent, repair);
     await cleanup;
     checkCurrent();
     if (cleanupFailures.has(prior)) throw cleanupFailures.get(prior);
     return !targets.has(threadId);
   }
 
-  async function prepareShared(threadId, checkCurrent) {
+  async function prepareShared(threadId, checkCurrent, repair) {
     checkCurrent.phase('shared_target');
     var state = ctx.state();
     if (state.initializing) { checkCurrent.observe('shared_runtime_initializing'); return false; }
@@ -94,14 +107,14 @@ function attachRecoveryAdmission(ctx) {
     if (state.server && state.entries.some(function(entry) {
       return !entry.handle || entry.handle.getRecoveryThreadId() !== threadId;
     })) {
-      if (await idleRecovery.releaseThread(state.entries, state.server, threadId, checkCurrent)) return true;
+      if (await idleRecovery.releaseThread(state.entries, state.server, threadId, checkCurrent, repair)) return true;
       checkCurrent();
     }
     checkCurrent.phase('shared_idle_retirement');
     var retiredThreads = [];
     if (state.refCount > 0) {
       var snapshots = state.entries.map(function(entry) { return entry.handle && entry.handle.getIdleRecoverySnapshot(); });
-      if (await idleRecovery.retireIdleQueries(state.entries, state.server, checkCurrent)) {
+      if (await idleRecovery.retireIdleQueries(state.entries, state.server, checkCurrent, repair)) {
         retiredThreads = snapshots.filter(Boolean).map(function(snapshot) { return snapshot.threadId; });
       }
     }
@@ -115,7 +128,7 @@ function attachRecoveryAdmission(ctx) {
       return stopped;
     }
     checkCurrent.phase('shared_target');
-    return idleRecovery.releaseThread(state.entries, state.server, threadId, checkCurrent);
+    return idleRecovery.releaseThread(state.entries, state.server, threadId, checkCurrent, repair);
   }
 
   async function waitUntilAvailable(queryOpts, action) {
@@ -179,9 +192,10 @@ function attachRecoveryAdmission(ctx) {
   }
 
   function createQuery(queryOpts) {
+    var repair = repairOptions(queryOpts);
     return waitUntilAvailable(queryOpts, async function(checkCurrent) {
-      if (!await releaseTarget(queryOpts.resumeSessionId, checkCurrent)) return false;
-      if (!await prepareShared(queryOpts.resumeSessionId, checkCurrent)) return false;
+      if (!await releaseTarget(queryOpts.resumeSessionId, checkCurrent, repair)) return false;
+      if (!await prepareShared(queryOpts.resumeSessionId, checkCurrent, repair)) return false;
       // Once ownership is reserved, normal startup/cleanup owns cancellation.
       // A deadline must not discard a handle being created after admission.
       checkCurrent.admit();
@@ -206,8 +220,9 @@ function attachRecoveryAdmission(ctx) {
     checkSharedExit: checkSharedExit,
     hasTarget: function(threadId) { return targets.has(threadId); },
     waitForTarget: function(queryOpts) {
+      var repair = repairOptions(queryOpts);
       return waitUntilAvailable(queryOpts, async function(checkCurrent) {
-        var released = await releaseTarget(queryOpts.resumeSessionId, checkCurrent);
+        var released = await releaseTarget(queryOpts.resumeSessionId, checkCurrent, repair);
         if (released) checkCurrent.admit();
         return released;
       });

package/package.json

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