clay-server 4.7.0-beta.1 → 4.7.0-beta.3

package/lib/yoke/adapters/antigravity.js

@@ -1,3 +1,4 @@
+var bindAbort = require("../query-abort").bindAbort;
 var childProcess = require("child_process");
 var readline = require("readline");
 var skillDiscovery = require("../skill-discovery");
@@ -75,6 +76,9 @@ function toolName(name) {
 
 function createAntigravityQueryHandle(binaryPath, queryOpts, onFinished) {
   var processHandle = null;
+  var removeAbort = function () {};
+  var killTimer = null;
+  var processExited = false;
   var outputReader = null;
   var events = [];
   var eventWaiter = null;
@@ -115,6 +119,7 @@ function createAntigravityQueryHandle(binaryPath, queryOpts, onFinished) {
   function endEvents() {
     if (ended) return;
     ended = true;
+    removeAbort();
     if (eventWaiter) {
       var resolve = eventWaiter;
       eventWaiter = null;
@@ -252,6 +257,8 @@ function createAntigravityQueryHandle(binaryPath, queryOpts, onFinished) {
       endEvents();
     });
     processHandle.on("exit", function(code, signal) {
+      processExited = true;
+      if (killTimer) clearTimeout(killTimer);
       if (!ended && activeTurn) {
         var message = stderr.trim() || "Antigravity CLI exited before completing the turn";
         pushEvent(isAuthError(message)
@@ -309,8 +316,24 @@ function createAntigravityQueryHandle(binaryPath, queryOpts, onFinished) {
     },
     abort: function() {
       if (ended) return;
+      inputEnded = true;
+      messages = [];
       pushEvent({ yokeType: "interrupted" });
-      if (processHandle) processHandle.kill("SIGINT");
+      if (processHandle && !processExited) {
+        try { processHandle.kill("SIGINT"); } catch (error) {
+          pushEvent({ yokeType: "error", text: "Could not interrupt Antigravity: " + error.message });
+        }
+        if (!processExited) {
+          killTimer = setTimeout(function () {
+            if (!processExited) {
+              try { processHandle.kill("SIGKILL"); } catch (error) {
+                console.error("[yoke/antigravity] Could not terminate stopped query:", error.message);
+              }
+            }
+          }, 5000);
+          killTimer.unref();
+        }
+      }
       endEvents();
     },
     close: function() {
@@ -319,6 +342,7 @@ function createAntigravityQueryHandle(binaryPath, queryOpts, onFinished) {
       endEvents();
     },
   };
+  removeAbort = bindAbort(queryOpts.abortController, function () { handle.abort(); });
   return handle;
 }
 

package/lib/yoke/adapters/claude.js

@@ -4,6 +4,7 @@
 // This is the ONLY file (besides claude-worker.js) that imports the SDK.
 // Also manages worker processes for OS-level user isolation.
 
+var bindQueryAbort = require("../query-abort").bindAbort;
 var path = require("path");
 var fs = require("fs");
 var os = require("os");
@@ -576,6 +577,7 @@ function normalizeBackgroundTasks(tasks) {
 function createQueryHandle(rawQuery, messageQueue, abortController) {
   var correlation = claudeCorrelation.createCorrelation();
   var closed = false;
+  var removeAbort = function () {};
   var handle = {
     // Opaque adapter state (null for in-process queries)
     _adapterState: null,
@@ -586,11 +588,12 @@ function createQueryHandle(rawQuery, messageQueue, abortController) {
       return {
         next: function() {
           return rawIter.next().then(function(result) {
-            if (result.done) closed = true;
+            if (result.done) { closed = true; removeAbort(); }
             if (result.done) return result;
             return { value: correlation.result(result.value, flattenEvent(result.value)), done: false };
           }, function(err) {
             closed = true;
+            removeAbort();
             throw err;
           });
         },
@@ -684,6 +687,7 @@ function createQueryHandle(rawQuery, messageQueue, abortController) {
 
     abort: function() {
       closed = true;
+      try { messageQueue.end(); } catch (e) {}
       if (abortController) {
         try { abortController.abort(); } catch (e) {}
       }
@@ -691,6 +695,7 @@ function createQueryHandle(rawQuery, messageQueue, abortController) {
 
     close: function() {
       closed = true;
+      removeAbort();
       try { messageQueue.end(); } catch (e) {}
       if (rawQuery && typeof rawQuery.close === "function") {
         try { rawQuery.close(); } catch (e) {}
@@ -712,6 +717,10 @@ function createQueryHandle(rawQuery, messageQueue, abortController) {
     },
   };
 
+  removeAbort = bindQueryAbort(abortController, function () {
+    closed = true;
+    try { messageQueue.end(); } catch (e) {}
+  });
   return handle;
 }
 
@@ -1043,6 +1052,7 @@ function serializeWorkerValue(value, seen) {
 // query identically to an in-process query.
 
 function createWorkerQueryHandle(worker, canUseTool, onElicitation, callMcpTool, onUserDialog, onUserInputRequest, onModelSwitch, preToolUsePolicy) {
+  var interactionAbort = new AbortController();
   var contextRequests = claudeContextUsage.createRequests(worker);
   var correlation = claudeCorrelation.createCorrelation();
   // Async iterable state
@@ -1085,6 +1095,7 @@ function createWorkerQueryHandle(worker, canUseTool, onElicitation, callMcpTool,
   }
 
   function endIter() {
+    interactionAbort.abort();
     contextRequests.close();
     if (iterEnded) return;
     iterEnded = true;
@@ -1096,6 +1107,7 @@ function createWorkerQueryHandle(worker, canUseTool, onElicitation, callMcpTool,
   }
 
   function errorIter(err) {
+    interactionAbort.abort();
     contextRequests.close();
     if (iterEnded) return;
     iterEnded = true;
@@ -1122,8 +1134,9 @@ function createWorkerQueryHandle(worker, canUseTool, onElicitation, callMcpTool,
             decisionReason: msg.decisionReason,
             defaultToNo: msg.defaultToNo === true,
             suppressAlwaysAllowRule: msg.suppressAlwaysAllowRule === true,
-            signal: { addEventListener: function() {} },
+            signal: interactionAbort.signal,
           }).then(function(result) {
+            if (interactionAbort.signal.aborted) result = { behavior: "deny", message: "Query cancelled" };
             worker.send({ type: "permission_response", requestId: msg.requestId, result: result });
           }).catch(function(e) {
             console.error("[yoke/claude] permission_response send failed:", e.message || e);
@@ -1149,8 +1162,9 @@ function createWorkerQueryHandle(worker, canUseTool, onElicitation, callMcpTool,
         if (onUserInputRequest) {
           claudeUserInput.ask(onUserInputRequest, msg.input, {
             toolUseID: msg.toolUseId,
-            signal: { addEventListener: function() {} },
+            signal: interactionAbort.signal,
           }).then(function(result) {
+            if (interactionAbort.signal.aborted) return;
             worker.send({ type: "ask_user_response", toolUseId: msg.toolUseId, result: result });
           }).catch(function(e) {
             console.error("[yoke/claude] ask_user_response send failed:", e.message || e);
@@ -1171,12 +1185,13 @@ function createWorkerQueryHandle(worker, canUseTool, onElicitation, callMcpTool,
           var workerElicitation = onUserInputRequest
             ? claudeUserInput.elicitation(onUserInputRequest, workerElicitationRequest, {
               requestId: msg.requestId,
-              signal: { addEventListener: function() {} },
+              signal: interactionAbort.signal,
             })
             : onElicitation(workerElicitationRequest, {
-            signal: { addEventListener: function() {} },
+            signal: interactionAbort.signal,
           });
           workerElicitation.then(function(result) {
+            if (interactionAbort.signal.aborted) return;
             worker.send({ type: "elicitation_response", requestId: msg.requestId, result: result });
           }).catch(function(e) {
             console.error("[yoke/claude] elicitation_response send failed:", e.message || e);
@@ -1191,8 +1206,9 @@ function createWorkerQueryHandle(worker, canUseTool, onElicitation, callMcpTool,
             payload: msg.payload || {},
             toolUseID: msg.toolUseId || undefined,
           }, {
-            signal: { addEventListener: function() {} },
+            signal: interactionAbort.signal,
           }).then(function(result) {
+            if (interactionAbort.signal.aborted) return;
             worker.send({ type: "user_dialog_response", requestId: msg.requestId, result: result });
           }).catch(function(e) {
             console.error("[yoke/claude] user_dialog_response send failed:", e.message || e);
@@ -1327,7 +1343,7 @@ function createWorkerQueryHandle(worker, canUseTool, onElicitation, callMcpTool,
     getSubmittedMessageCount: correlation.submitted,
 
     pushMessage: function(text, images) {
-      if (iterEnded || (worker.process && (worker.process.killed || worker.process.exitCode != null))) return false;
+      if (iterEnded || worker._abortSent || (worker.process && (worker.process.killed || worker.process.exitCode != null))) return false;
       var content = [];
       if (images && images.length > 0) {
         for (var i = 0; i < images.length; i++) {
@@ -1417,8 +1433,10 @@ function createWorkerQueryHandle(worker, canUseTool, onElicitation, callMcpTool,
     },
 
     abort: function() {
+      if (iterEnded || worker._abortSent) return;
       console.log("[yoke/claude] ABORT sent to worker pid=" + (worker.process ? worker.process.pid : "?"));
       worker._abortSent = true;
+      interactionAbort.abort();
       try { worker.send({ type: "abort" }); } catch (e) {}
       // If the worker doesn't finish within 5s (e.g. subagent stuck), force-kill it.
       // The worker exit handler will dispatch a fallback query_error and send done.

package/lib/yoke/adapters/codex.js

@@ -3,6 +3,8 @@
 // Implements the YOKE interface using codex app-server protocol.
 // Bidirectional JSON-RPC over stdin/stdout enables interactive approval flows.
 
+var createTurnEvents = require("../codex-turn-events").createTurnEvents;
+var bindQueryAbort = require("../query-abort").bindAbort;
 var path = require("path");
 var fs = require("fs");
 var { CodexAppServer } = require("../codex-app-server");
@@ -11,6 +13,7 @@ var skillDiscovery = require("../skill-discovery");
 var { resolveOsUserInfo } = require("../../os-users");
 var backgroundTasks = require("../codex-background-tasks");
 var codexUserInput = require("../codex-user-input");
+var createTurnStop = require("../codex-turn-stop").createTurnStop;
 
 // --- Reasoning defaults ---
 // Reasoning summaries are the only readable thinking channel Codex offers:
@@ -812,6 +815,7 @@ function createEventState(model) {
 
 function createCodexQueryHandle(appServer, queryOpts) {
   var abortController = queryOpts.abortController;
+  var removeAbort = function () {};
   var promptParts = [queryOpts.systemPrompt, queryOpts.appendSystemPrompt].filter(function (part) { return !!part; });
   var systemPrompt = promptParts.join("\n\n");
   var canUseTool = queryOpts.canUseTool || null;
@@ -826,6 +830,11 @@ function createCodexQueryHandle(appServer, queryOpts) {
   }
 
   var state = createEventState(queryOpts.model);
+  var turnEvents = createTurnEvents(handleServerEvent);
+  var turnStop = createTurnStop(appServer, function (error) {
+    console.error("[yoke/codex] turn interrupt failed:", error.message || error);
+    pushEvent({ yokeType: "error", text: "Codex cancellation could not be confirmed. The remote turn may still be running." });
+  });
 
   // Internal event buffer for async iterator
   var eventBuffer = [];
@@ -864,6 +873,7 @@ function createCodexQueryHandle(appServer, queryOpts) {
   }
 
   function endIterator() {
+    removeAbort();
     iteratorDone = true;
     if (eventWaiting) {
       var resolve = eventWaiting;
@@ -912,6 +922,13 @@ function createCodexQueryHandle(appServer, queryOpts) {
     // Ignore events from other threads (app-server is shared across sessions)
     if (params.threadId && state.threadId && params.threadId !== state.threadId) return;
 
+    if (!turnEvents.accept(msg)) return;
+
+    // Capture cancellation identity even if Stop arrived before turn/start replied.
+    var eventTurnId = params.turnId || params.turn_id || (params.turn && params.turn.id);
+    if (method === "turn/started") turnStop.started(eventTurnId);
+    if (method === "turn/completed" || method === "turn/failed") turnStop.completed(eventTurnId);
+
     // After abort, only let turn-ending events through
     if (isCancelled() && method !== "turn/completed" && method !== "turn/failed" && method !== "serverRequest/resolved" && method !== "thread/status/changed") return;
 
@@ -1089,6 +1106,7 @@ function createCodexQueryHandle(appServer, queryOpts) {
 
     // Resolve turn promise when turn ends
     if (method === "turn/completed" || method === "turn/failed") {
+      turnEvents.finish();
       if (turnResolve) {
         var resolve = turnResolve;
         turnResolve = null;
@@ -1204,6 +1222,7 @@ function createCodexQueryHandle(appServer, queryOpts) {
       while (!isCancelled()) {
         // Reset per-turn state
         state.turnStarted = false;
+        state.currentTurnId = null;
         state.textBlocks = {};
         state.textLengths = {};
         state.thinkingBlocks = {};
@@ -1243,11 +1262,22 @@ function createCodexQueryHandle(appServer, queryOpts) {
           input = input.concat(skillItemsToInject);
         }
 
-        await appServer.send("turn/start", {
-          threadId: state.threadId,
-          input: input,
-          model: state.model,
-        }, 60000);
+        turnStop.begin(state.threadId);
+        turnEvents.begin();
+        try {
+          var turnResult = await appServer.send("turn/start", {
+            threadId: state.threadId,
+            input: input,
+            model: state.model,
+          }, 60000);
+          var startedTurnId = turnResult && turnResult.turn && turnResult.turn.id;
+          turnStop.startSettled(startedTurnId);
+          turnEvents.ready(startedTurnId);
+        } catch (startError) {
+          turnEvents.finish();
+          turnStop.startSettled(null);
+          throw startError;
+        }
 
         // Wait for turn to complete
         await turnPromise;
@@ -1348,19 +1378,23 @@ function createCodexQueryHandle(appServer, queryOpts) {
     abort: function() {
       console.log("[yoke/codex] handle.abort() called, threadId=" + state.threadId + " already aborted=" + state.aborted);
       state.aborted = true;
-      // Send turn/interrupt to stop the server-side turn
-      if (state.threadId && appServer.started) {
-        appServer.send("turn/interrupt", { threadId: state.threadId }, 5000).catch(function() {});
-      }
-      // End iterator immediately. sdk-bridge's post-loop code checks
-      // session.taskStopRequested and sends the interrupted message + done.
-      // This matches Claude's abort pattern.
-      if (turnResolve) {
-        var resolve = turnResolve;
-        turnResolve = null;
-        resolve();
-      }
-      endIterator();
+      messageQueueEnded = true;
+      messageQueue = [];
+      if (messageWaiting) {
+        var releaseMessage = messageWaiting;
+        messageWaiting = null;
+        releaseMessage(null);
+      }
+      // Keep the iterator alive until the exact interrupt settles so failures
+      // reach the transcript instead of being silently reported as a stop.
+      return turnStop.abort().then(function () {
+        if (turnResolve) {
+          var resolve = turnResolve;
+          turnResolve = null;
+          resolve();
+        }
+        endIterator();
+      });
     },
 
     close: function() {
@@ -1383,12 +1417,9 @@ function createCodexQueryHandle(appServer, queryOpts) {
     },
   };
 
-  // Listen for external abort (sdk-bridge's stopTask calls session.abortController.abort())
-  if (abortController && abortController.signal) {
-    abortController.signal.addEventListener("abort", function() {
-      if (!state.aborted) handle.abort();
-    }, { once: true });
-  }
+  removeAbort = bindQueryAbort(abortController, function () {
+    if (!state.aborted) handle.abort();
+  });
 
   return handle;
 }

package/lib/yoke/adapters/kiro.js

@@ -12,6 +12,7 @@
 //        session/request_permission requests for tool approvals.
 //   session/cancel (notif) -> interrupt the active turn
 
+var queryAbort = require("../query-abort");
 var { execFile } = require("child_process");
 var { KiroAcpServer, findKiroPath } = require("../kiro-acp-server");
 var INITIALIZE_TIMEOUT_MS = require("../interface").INITIALIZE_TIMEOUT_MS;
@@ -398,6 +399,12 @@ function createEventState(opts) {
 
 function createKiroQueryHandle(acp, queryOpts) {
   var abortController = queryOpts.abortController;
+  var cancellation = queryAbort.createAbortScope();
+  var removeAbort = function () {};
+  function send(method, params, timeout) {
+    cancellation.check();
+    return cancellation.wait(acp.send(method, params, timeout, cancellation.signal));
+  }
   var promptParts = [queryOpts.systemPrompt, queryOpts.appendSystemPrompt].filter(function (part) { return !!part; });
   var systemPrompt = promptParts.join("\n\n");
   var canUseTool = queryOpts.canUseTool || null;
@@ -436,6 +443,7 @@ function createKiroQueryHandle(acp, queryOpts) {
 
   function endIterator() {
     iteratorDone = true;
+    removeAbort();
     if (eventWaiting) {
       var resolve = eventWaiting;
       eventWaiting = null;
@@ -506,9 +514,10 @@ function createKiroQueryHandle(acp, queryOpts) {
         var meta = (tc.toolCallId && state.toolMeta[tc.toolCallId]) || {};
         var toolName = toolNameForKind(tc.kind || meta.kind, tc.title || meta.title);
         var toolInput = tc.rawInput || meta.rawInput || { title: tc.title || meta.title };
-        canUseTool(toolName, toolInput, {}).then(function(decision) {
-          acp.respond(msg.id, { outcome: { outcome: "selected", optionId: isApproved(decision) ? allowId : rejectId } });
+        cancellation.wait(Promise.resolve().then(function () { cancellation.check(); return canUseTool(toolName, toolInput, { signal: cancellation.signal }); })).then(function(decision) {
+          acp.respond(msg.id, isCancelled() ? { outcome: { outcome: "cancelled" } } : { outcome: { outcome: "selected", optionId: isApproved(decision) ? allowId : rejectId } });
         }).catch(function(err) {
+          if (isCancelled()) { acp.respond(msg.id, { outcome: { outcome: "cancelled" } }); return; }
           console.error("[yoke/kiro] canUseTool error:", err.message);
           acp.respond(msg.id, { outcome: { outcome: "selected", optionId: rejectId } });
         });
@@ -592,13 +601,13 @@ function createKiroQueryHandle(acp, queryOpts) {
   function setSessionModel(model) {
     if (!state.sessionId || !acp.started) return Promise.resolve();
     if (state.engine === "v3") {
-      return acp.send("session/set_config_option", {
+      return send("session/set_config_option", {
         sessionId: state.sessionId,
         configId: "model",
         value: model,
       }, 15000);
     }
-    return acp.send("session/set_model", { sessionId: state.sessionId, modelId: model }, 15000);
+    return send("session/set_model", { sessionId: state.sessionId, modelId: model }, 15000);
   }
 
   // --- Main query loop ---
@@ -638,12 +647,13 @@ function createKiroQueryHandle(acp, queryOpts) {
         handlerEntry.sessionId = state.sessionId;
         state.loadingSession = true;
         try {
-          await acp.send("session/load", {
+          await send("session/load", {
             sessionId: state.sessionId,
             cwd: queryOpts.cwd,
             mcpServers: queryOpts.mcpServers || [],
           }, 60000);
         } catch (e) {
+          if (isCancelled()) throw e;
           // If load fails (unknown session), fall back to a fresh session.
           console.warn("[yoke/kiro] session/load failed, starting fresh:", e.message);
           state.sessionId = null;
@@ -653,7 +663,7 @@ function createKiroQueryHandle(acp, queryOpts) {
         }
       }
       if (!state.sessionId) {
-        var newResult = await acp.send("session/new", {
+        var newResult = await send("session/new", {
           cwd: queryOpts.cwd,
           mcpServers: queryOpts.mcpServers || [],
         }, 60000);
@@ -664,7 +674,7 @@ function createKiroQueryHandle(acp, queryOpts) {
       // Kiro v3 defaults to autopilot, which bypasses permission requests.
       // Supervised mode is mandatory so every tool call reaches canUseTool.
       if (state.engine === "v3") {
-        await acp.send("session/set_config_option", {
+        await send("session/set_config_option", {
           sessionId: state.sessionId,
           configId: "autopilot",
           value: "off",
@@ -676,7 +686,7 @@ function createKiroQueryHandle(acp, queryOpts) {
         await setSessionModel(queryOpts.model).catch(function() {});
       }
       if (queryOpts.mode) {
-        await acp.send("session/set_mode", { sessionId: state.sessionId, modeId: queryOpts.mode }, 15000).catch(function() {});
+        await send("session/set_mode", { sessionId: state.sessionId, modeId: queryOpts.mode }, 15000).catch(function() {});
       }
 
       while (!isCancelled()) {
@@ -690,7 +700,7 @@ function createKiroQueryHandle(acp, queryOpts) {
         // Emit turn_start so the UI records a user turn boundary.
         pushEvent({ yokeType: "turn_start", uuid: generateUuid(), messageType: "user" });
 
-        var promptResult = await acp.send("session/prompt", {
+        var promptResult = await send("session/prompt", {
           sessionId: state.sessionId,
           prompt: input,
         }, 30 * 60 * 1000);
@@ -779,11 +789,17 @@ function createKiroQueryHandle(acp, queryOpts) {
 
     abort: function() {
       console.log("[yoke/kiro] handle.abort() sessionId=" + state.sessionId + " already=" + state.aborted);
+      if (state.aborted || iteratorDone) return;
       state.aborted = true;
-      if (state.sessionId && acp.started) {
-        // ACP cancellation is a notification; the in-flight session/prompt will
-        // resolve with stopReason "cancelled".
-        acp.notify("session/cancel", { sessionId: state.sessionId });
+      cancellation.stop();
+      handle.endInput();
+      messageQueue = [];
+      try {
+        if (state.sessionId && (!acp.started || acp.notify("session/cancel", { sessionId: state.sessionId }) === false)) {
+          throw new Error("ACP transport is disconnected");
+        }
+      } catch (error) {
+        pushEvent({ yokeType: "error", text: "Kiro cancellation could not be delivered: " + error.message });
       }
       endIterator();
     },
@@ -808,12 +824,7 @@ function createKiroQueryHandle(acp, queryOpts) {
     },
   };
 
-  if (abortController && abortController.signal) {
-    abortController.signal.addEventListener("abort", function() {
-      if (!state.aborted) handle.abort();
-    }, { once: true });
-  }
-
+  removeAbort = queryAbort.bindAbort(abortController, function () { handle.abort(); });
   return handle;
 }
 

package/lib/yoke/codex-turn-events.js

@@ -0,0 +1,32 @@
+// A resumed thread can still deliver notifications from its previous turn.
+// Only turn/start's response authorizes tagged output for this query's turn.
+function createTurnEvents(deliver) {
+  var active = false;
+  var starting = false;
+  var turnId = null;
+  var pending = [];
+  function idOf(message) {
+    var params = message.params || {};
+    return params.turnId || params.turn_id || (params.turn && params.turn.id) || null;
+  }
+  return {
+    begin: function () { active = true; starting = true; turnId = null; pending = []; },
+    accept: function (message) {
+      var id = idOf(message);
+      var scoped = id || /^(turn\/|item\/)/.test(message.method || '');
+      if (!scoped) return true;
+      if (!active) return false;
+      if (starting && id) { pending.push(message); return false; }
+      return !id || !turnId || id === turnId;
+    },
+    ready: function (id) {
+      turnId = id;
+      starting = false;
+      var buffered = pending;
+      pending = [];
+      buffered.forEach(function (message) { deliver(message); });
+    },
+    finish: function () { active = false; starting = false; pending = []; },
+  };
+}
+module.exports = { createTurnEvents: createTurnEvents };

package/lib/yoke/codex-turn-stop.js

@@ -0,0 +1,59 @@
+// Stop only the turn owned by this query, including an in-flight turn/start.
+function createTurnStop(server, onError) {
+  var turnId = null;
+  var threadId = null;
+  var starting = false;
+  var completed = false;
+  var stopped = false;
+  var sent = false;
+  var resolveStop = null;
+  var stopPromise = null;
+
+  function settle() {
+    if (resolveStop) { var resolve = resolveStop; resolveStop = null; resolve(); }
+  }
+
+  function interrupt() {
+    if (!stopped || sent) return;
+    if (!turnId) { if (!starting) settle(); return; }
+    sent = true;
+    var target = { threadId: threadId, turnId: turnId };
+    Promise.resolve().then(function () {
+      if (!server.started) throw new Error('Codex is disconnected; cancellation could not be confirmed.');
+      return server.send('turn/interrupt', target, 5000);
+    }).catch(function (error) {
+      onError(error);
+    }).finally(settle);
+  }
+
+  return {
+    begin: function (id) { threadId = id; turnId = null; starting = true; completed = false; sent = false; },
+    started: function (id) {
+      if (!id || turnId || completed) return;
+      turnId = id;
+      starting = false;
+      interrupt();
+    },
+    startSettled: function (id) {
+      starting = false;
+      if (id && !turnId && !completed) turnId = id;
+      interrupt();
+    },
+    completed: function (id) {
+      if (id && turnId && id !== turnId) return;
+      turnId = null;
+      completed = true;
+      starting = false;
+      if (!sent) settle();
+    },
+    abort: function () {
+      if (stopPromise) return stopPromise;
+      stopped = true;
+      stopPromise = new Promise(function (resolve) { resolveStop = resolve; });
+      interrupt();
+      return stopPromise;
+    },
+  };
+}
+
+module.exports = { createTurnStop: createTurnStop };

package/lib/yoke/query-abort.js

@@ -0,0 +1,40 @@
+// Query-local cancellation. Never terminates a shared provider process.
+function bindAbort(controller, abort) {
+  var signal = controller && controller.signal;
+  if (!signal) return function () {};
+  if (signal.aborted) { abort(); return function () {}; }
+  signal.addEventListener('abort', abort, { once: true });
+  return function () { signal.removeEventListener('abort', abort); };
+}
+
+function createAbortScope() {
+  var stopped = false;
+  var controller = new AbortController();
+  var waiting = new Set();
+  function error() { var err = new Error('Query cancelled'); err.name = 'AbortError'; return err; }
+  return {
+    signal: controller.signal,
+    stopped: function () { return stopped; },
+    wait: function (promise) {
+      return new Promise(function (resolve, reject) {
+        function cancel() { reject(error()); }
+        if (stopped) cancel();
+        else waiting.add(cancel);
+        Promise.resolve(promise).then(function (value) {
+          waiting.delete(cancel);
+          if (stopped) cancel(); else resolve(value);
+        }, function (err) { waiting.delete(cancel); reject(err); });
+      });
+    },
+    stop: function () {
+      if (stopped) return;
+      stopped = true;
+      controller.abort();
+      waiting.forEach(function (cancel) { cancel(); });
+      waiting.clear();
+    },
+    check: function () { if (stopped) throw error(); },
+  };
+}
+
+module.exports = { bindAbort: bindAbort, createAbortScope: createAbortScope };

package/lib/yoke/user-input-guidance.js

@@ -0,0 +1,11 @@
+// Required decisions use Clay's blocking question lifecycle in every Codex mode.
+function codexQuestionGuidance() {
+  return [
+    "When clarification materially changes task scope, targets, or intended behavior, use Clay's ask_user_questions tool (or its available MCP-qualified equivalent).",
+    "Present the question as a structured input card, not a question followed by bullet choices in ordinary chat. Await the tool result before work that depends on the answer.",
+    "Call the blocking question tool by itself; do not batch dependent actions alongside it or detach it into background work. request_user_input may be unavailable outside Plan mode, so use ask_user_questions in that case.",
+    "A cancelled, skipped, empty, or failed question is not an answer or approval. Do not infer a choice; leave dependent work pending and explain what answer is needed.",
+    "Do not ask again when the user has already answered or authorized the work. This question tool does not replace tool-permission enforcement."
+  ].join(" ");
+}
+module.exports = { codexQuestionGuidance: codexQuestionGuidance };

package/lib/yoke/user-input.js

@@ -219,7 +219,7 @@ function fallbackToolDefs(handler, options) {
     queryBound: true,
     description: initialLimit === 1
       ? "Ask the user exactly one structured question, wait for the answer, then call again if another question is needed. Use zero options for freeform or 2-6 options for choices; never one option."
-      : "Ask the user 1-3 structured questions. Use zero options for freeform or 2-6 options for choices; never one option.",
+      : "Ask the user 1-3 structured questions and wait for their answers before continuing dependent work. Use this for scope or target decisions; do not substitute prose questions or asynchronous notifications. A cancelled or skipped question is not an answer. Use zero options for freeform or 2-6 options for choices; never one option.",
     inputSchema: buildQuestionShape(initialLimit),
     handler: function (input) {
       if (questionLimit(options) === 1 && input && Array.isArray(input.questions) && input.questions.length !== 1) {

package/package.json

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