clay-server 5.5.0-beta.5 → 5.5.0-beta.7

package/lib/sdk-bridge.js

@@ -1972,6 +1972,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/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.5",
+  "version": "5.5.0-beta.7",
   "description": "Self-hosted team workspace for Claude Code and Codex. Multi-user, browser-based, with persistent AI mates.",
   "bin": {
     "clay-server": "./bin/cli.js"

package/lib/public/pane-assets/chunk-6EDR4PMU.js

@@ -1 +0,0 @@
-import{C as a,D as b,E as c}from"./chunk-W7XXER5Z.js";import"./chunk-TVKTFEST.js";import"./chunk-YHBTK56T.js";import"./chunk-OGIHAXLD.js";import"./chunk-QOL6PHMZ.js";import"./chunk-DTNAWMGQ.js";import"./chunk-R7QVVFUG.js";import"./chunk-OQBKX36J.js";import"./chunk-EGCR2MH4.js";export{a as closeLoginBrowser,c as handleLoginBrowserMessage,b as openLoginBrowser};

package/lib/public/pane-assets/chunk-AFATDM32.js

@@ -1 +0,0 @@
-import{Tc as a,Uc as b,Vc as c,Wc as d,Xc as e,Yc as f,Zc as g,_c as h}from"./chunk-W7XXER5Z.js";import"./chunk-TVKTFEST.js";import"./chunk-YHBTK56T.js";import"./chunk-OGIHAXLD.js";import"./chunk-QOL6PHMZ.js";import"./chunk-DTNAWMGQ.js";import"./chunk-R7QVVFUG.js";import"./chunk-OQBKX36J.js";import"./chunk-EGCR2MH4.js";export{f as closeNotesBrowser,b as closedNotes,c as handleNoteDeleteResult,h as initNotesBrowser,g as isNotesBrowserOpen,a as openNotes,e as openNotesBrowser,d as renderNotesBrowser};

package/lib/public/pane-assets/chunk-ET4NUBYW.js

@@ -1 +0,0 @@
-import{jc as a,kc as b,lc as c,mc as d}from"./chunk-W7XXER5Z.js";import"./chunk-TVKTFEST.js";import"./chunk-YHBTK56T.js";import"./chunk-OGIHAXLD.js";import"./chunk-QOL6PHMZ.js";import"./chunk-DTNAWMGQ.js";import"./chunk-R7QVVFUG.js";import"./chunk-OQBKX36J.js";import"./chunk-EGCR2MH4.js";export{c as closeDebatesWorkbench,a as handleDebatesWorkbenchState,d as initDebatesWorkbench,b as openDebatesWorkbench};

package/lib/public/pane-assets/chunk-EYJZ3R7Y.js

@@ -1 +0,0 @@
-import{n as a,o as b,p as c,q as d}from"./chunk-W7XXER5Z.js";import"./chunk-TVKTFEST.js";import"./chunk-YHBTK56T.js";import"./chunk-OGIHAXLD.js";import"./chunk-QOL6PHMZ.js";import"./chunk-DTNAWMGQ.js";import"./chunk-R7QVVFUG.js";import"./chunk-OQBKX36J.js";import"./chunk-EGCR2MH4.js";export{a as closeLinear,c as handleLinearResult,d as initLinearPanel,b as openLinear};

package/lib/public/pane-assets/chunk-KZ3CYS5U.js

@@ -1 +0,0 @@
-import{g as a,h as b,i as c}from"./chunk-QOL6PHMZ.js";import"./chunk-DTNAWMGQ.js";import"./chunk-R7QVVFUG.js";import"./chunk-OQBKX36J.js";import"./chunk-EGCR2MH4.js";export{a as closeWireframe,b as openWireframe,c as restoreWireframeWorkbench};

package/lib/public/pane-assets/chunk-NRP4NXVZ.js

@@ -1 +0,0 @@
-import{r as a,s as b,t as c,u as d,v as e,w as f}from"./chunk-W7XXER5Z.js";import"./chunk-TVKTFEST.js";import"./chunk-YHBTK56T.js";import"./chunk-OGIHAXLD.js";import"./chunk-QOL6PHMZ.js";import"./chunk-DTNAWMGQ.js";import"./chunk-R7QVVFUG.js";import"./chunk-OQBKX36J.js";import"./chunk-EGCR2MH4.js";export{c as closeIssues,f as handleIssuesMessage,e as initIssues,d as openIssues,b as refreshGithubIssue,a as requestIssue};

package/lib/public/pane-assets/chunk-Y77DR2RU.js

@@ -1 +0,0 @@
-import{Ta as a,Ua as b,Va as c,Wa as d,Xa as e}from"./chunk-W7XXER5Z.js";import"./chunk-TVKTFEST.js";import"./chunk-YHBTK56T.js";import"./chunk-OGIHAXLD.js";import"./chunk-QOL6PHMZ.js";import"./chunk-DTNAWMGQ.js";import"./chunk-R7QVVFUG.js";import"./chunk-OQBKX36J.js";import"./chunk-EGCR2MH4.js";export{c as closeYou,d as handleYouMessage,e as initYou,b as openYou,a as sendYou};