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

package/lib/public/app.js

@@ -1,3 +1,4 @@
+import { initGenerationStop } from './modules/generation-stop.js';
 import { initIssueLinks } from './modules/clay-issue-links.js';
 import { initIssues, closeIssues } from './modules/issues.js';
 import { initIssuesContext } from './modules/issues-context.js';
@@ -821,6 +822,7 @@ import { initDebate, handleDebatePreparing, handleDebateStarted, handleDebateRes
 
   // --- Notifications module ---
   initAppNotifications();
+  initGenerationStop();
 
   // --- Panels module ---
   initPanels();

package/lib/public/css/input.css

@@ -1717,3 +1717,30 @@ body.tui-composer-active #config-chip-wrap {
   font-weight: 600;
   color: inherit;
 }
+
+/* Stop remains available when Send is occupied by a draft or Worker lock. */
+#generation-stop-row {
+  max-width: var(--content-width);
+  margin: 6px auto 0;
+  display: flex;
+  justify-content: flex-end;
+}
+#generation-stop-row.hidden { display: none; }
+body:not(.worker-pane-locked) #input-area:has(#send-btn.stop:not(:disabled)) #generation-stop-row { display: none; }
+#generation-stop {
+  display: inline-flex;
+  align-items: center;
+  gap: 6px;
+  min-height: 36px;
+  padding: 6px 12px;
+  border: 1px solid var(--border);
+  border-radius: 18px;
+  background: var(--sidebar-bg);
+  color: var(--text-secondary);
+  font: inherit;
+  font-size: 12px;
+  cursor: pointer;
+}
+#generation-stop:hover:not(:disabled) { color: var(--text); background: var(--code-bg); }
+#generation-stop:disabled { opacity: 0.5; cursor: default; }
+#generation-stop .lucide { width: 12px; height: 12px; }

package/lib/public/index.html

@@ -635,6 +635,9 @@
           </div>
         </div>
       </div>
+      <div id="generation-stop-row" class="hidden">
+        <button id="generation-stop" type="button" aria-label="Stop generating"><i data-lucide="square"></i><span>Stop</span></button>
+      </div>
     </div>
   </div>
   <!-- Mobile input-more bottom sheet: attach / image + context sources -->

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

@@ -151,7 +151,19 @@ function suspendSocketWatchdogs() {
   watchdog.suspend();
 }
 
+function refreshBackgroundPane() {
+  if (document.hidden || !store.get('paneNeedsSnapshot')) return false;
+  store.set({ paneNeedsSnapshot: false });
+  if (!store.get('paneMode') || !store.get('paneSessionId') || lifecycle.isOffline()) return false;
+  // A fresh socket discards browser-queued deltas and re-pins the exact pane.
+  // Server replay supplies current history, status and pending interactions.
+  watchdog.resume();
+  connect();
+  return true;
+}
+
 function resumeSocketWatchdogs(reason) {
+  if (refreshBackgroundPane()) return;
   var resumed = watchdog.resume();
   var socket = getWs();
   if (socket && socket.readyState === 1 && resumed) startHeartbeat(socket, lifecycle.getEpoch());
@@ -178,10 +190,13 @@ export function initConnection() {
     });
   });
   document.addEventListener("visibilitychange", function () {
-    if (document.hidden) suspendSocketWatchdogs();
-    else resumeSocketWatchdogs("visible");
+    if (document.hidden) {
+      if (store.get('paneMode') && store.get('paneSessionId')) store.set({ paneNeedsSnapshot: true });
+      suspendSocketWatchdogs();
+    } else resumeSocketWatchdogs("visible");
   });
   document.addEventListener("freeze", function () {
+    if (store.get('paneMode') && store.get('paneSessionId')) store.set({ paneNeedsSnapshot: true });
     suspendSocketWatchdogs();
   });
   document.addEventListener("resume", function () {
@@ -387,6 +402,12 @@ export function connect() {
 
   newWs.onmessage = function (event) {
     if (getWs() !== newWs || !lifecycle.current(attemptEpoch)) return;
+    // Hidden pane deltas are replaced by a current server snapshot on return.
+    if (store.get('paneMode') && store.get('paneSessionId') && document.hidden) {
+      store.set({ paneNeedsSnapshot: true });
+      return;
+    }
+    if (refreshBackgroundPane()) return;
     // Backup: if we're receiving messages, we're connected
     if (!store.get('connected')) {
       setStatus("connected");

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

@@ -83,6 +83,7 @@ export function drawFaviconAnimFrame() {
 
 export function setSendBtnMode(mode) {
   var sendBtn = getSendBtn();
+  sendBtn.setAttribute("aria-label", mode === "stop" ? "Stop generating" : "Send");
   if (mode === "stop") {
     sendBtn.disabled = false;
     sendBtn.classList.add("stop");

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

@@ -66,7 +66,7 @@ import { renderGeneratedImage, renderImageGenerationProgress, clearImageGenerati
 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';
+import { scrollToBottom, addToMessages, addUserMessage, addSystemMessage, removeMatePreThinking, resetStreamBuffer, appendDelta, 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';
@@ -834,6 +834,7 @@ export function processMessage(msg) {
 
       case "session_switched":
         clearPairResultStatus();
+        resetStreamBuffer();
         syncAutonomousRunForSession(msg.autonomousRun || null);
         // Save draft from outgoing session
         var _prevSid = store.get('activeSessionId');

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

@@ -45,6 +45,11 @@ export function addCopyHandler(msgEl, rawText) {
 export function appendDelta(text) {
   ensureAssistantBlock();
   streamBuffer += text;
+  if (store.get('replayingHistory')) {
+    store.set({ currentFullText: store.get('currentFullText') + streamBuffer });
+    streamBuffer = "";
+    return;
+  }
   if (!streamDrainTimer) {
     streamDrainTimer = requestAnimationFrame(drainStreamTick);
   }
@@ -55,16 +60,9 @@ function drainStreamTick() {
   var _s = store.snap();
   if (!_s.currentMsgEl || streamBuffer.length === 0) return;
 
-  var n;
-  var len = streamBuffer.length;
-  if (len > 200) { n = Math.ceil(len / 4); }
-  else if (len > 80) { n = 8; }
-  else if (len > 30) { n = 5; }
-  else if (len > 10) { n = 2; }
-  else { n = 1; }
-
-  var chunk = streamBuffer.slice(0, n);
-  streamBuffer = streamBuffer.slice(n);
+  // Render everything received by this frame; never replay a typing backlog.
+  var chunk = streamBuffer;
+  streamBuffer = "";
   var newText = _s.currentFullText + chunk;
   store.set({ currentFullText: newText });
 
@@ -82,6 +80,14 @@ function drainStreamTick() {
   }
 }
 
+export function resetStreamBuffer() {
+  if (streamDrainTimer) cancelAnimationFrame(streamDrainTimer);
+  if (highlightTimer) clearTimeout(highlightTimer);
+  streamDrainTimer = null;
+  highlightTimer = null;
+  streamBuffer = "";
+}
+
 export function flushStreamBuffer() {
   if (streamDrainTimer) { cancelAnimationFrame(streamDrainTimer); streamDrainTimer = null; }
   if (streamBuffer.length > 0) {

package/lib/public/modules/generation-stop.js

@@ -0,0 +1,24 @@
+import { store } from './store.js';
+import { getWs } from './ws-ref.js';
+
+// This control lives outside the composer so drafts and Worker locks cannot
+// take away the human's ability to stop the displayed session.
+export function initGenerationStop() {
+  var row = document.getElementById('generation-stop-row');
+  var button = document.getElementById('generation-stop');
+  if (!row || !button) return;
+  function sync() {
+    row.classList.toggle('hidden', !store.get('processing'));
+    button.disabled = !store.get('connected');
+    button.title = store.get('connected') ? 'Stop generating' : 'Reconnect to stop generating';
+  }
+  button.addEventListener('click', function () {
+    var ws = getWs();
+    if (!store.get('processing') || !store.get('connected') || !ws || ws.readyState !== 1) return;
+    ws.send(JSON.stringify({ type: 'stop' }));
+  });
+  store.subscribe(function (state, previous) {
+    if (state.processing !== previous.processing || state.connected !== previous.connected) sync();
+  });
+  sync();
+}

package/lib/sdk-bridge.js

@@ -1,4 +1,5 @@
 const crypto = require("crypto");
+var codexQuestionGuidance = require("./yoke/user-input-guidance").codexQuestionGuidance;
 var fs = require("fs");
 var path = require("path");
 var execSync = require("child_process").execSync;
@@ -1054,6 +1055,10 @@ function createSDKBridge(opts) {
     console.log("[sdk-bridge] processQueryStream: starting for-await loop, vendor=" + (session.vendor || adapter.vendor));
     try {
       for await (var msg of myQueryInstance) {
+        // An old iterator may drain after Stop or after a replacement query starts.
+        if (!ownsQueryRuntime(session, myQueryInstance, myQueryGeneration)) continue;
+        if ((session.taskStopRequested || (myAbortController && myAbortController.signal.aborted))
+            && msg && msg.yokeType !== "error" && msg.yokeType !== "interrupted") continue;
         if (msg && msg.yokeType !== "text_delta" && msg.yokeType !== "thinking_delta" && msg.yokeType !== "tool_input_delta") {
           console.log("[sdk-bridge] processQueryStream: received event yokeType=" + msg.yokeType);
         }
@@ -1111,6 +1116,7 @@ function createSDKBridge(opts) {
             && session.cliSessionId === msg.sessionId
             && (!sm.sessions || typeof sm.sessions.get !== "function" || sm.sessions.get(session.localId) === session)) {
           if (codexCatalogCandidate.version) session.codexDynamicToolCatalogVersion = codexCatalogCandidate.version;
+          if (codexCatalogCandidate.userInputVersion) session.codexUserInputToolCatalogVersion = codexCatalogCandidate.userInputVersion;
           if (codexCatalogCandidate.issuesVersion) session.codexIssuesToolCatalogVersion = codexCatalogCandidate.issuesVersion;
           sm.saveSessionFile(session);
           codexCatalogCandidate = null;
@@ -1804,8 +1810,10 @@ function createSDKBridge(opts) {
     var activeLoopInterview = !isDriverOperatedSession(session) && !session.loopInterviewHandoff && !activeRun && !!loopInterview.activeInterviewId(session);
     var structuredInputSession = hasScheduleInterviewTool || activeLoopInterview || (!isDriverOperatedSession(session) && session.ralphCraftingMode === true && session.loop && session.loop.role === "crafting");
     var requestedUserInputMode = session.debateSetupMode || session.mateCreationMode ? "fallback" : "auto";
-    if (structuredInputSession) requestedUserInputMode = "fallback";
+    if (structuredInputSession || sessionAdapter.vendor === "codex") requestedUserInputMode = "fallback";
     var selectedUserInputMode = yoke.userInput.selectMode(sessionAdapter, requestedUserInputMode);
+    var recoverCodexQuestionTools = sessionAdapter.vendor === "codex" && !!session.cliSessionId
+      && Number(session.codexUserInputToolCatalogVersion || 0) < 1 && queryContextAvailable();
     function structuredInputContextAvailable() {
       if (!queryContextAvailable()) return false;
       // A schedule-triggered fallback shares the schedule feature's live
@@ -1928,7 +1936,10 @@ function createSDKBridge(opts) {
       // would strip the driver session down to the two-sentence pair preset.
       // Adapters map this to their additive mechanism (claude: preset+append,
       // codex/kiro: prepend to the first message).
-      appendSystemPrompt: typeof opts.getSessionSystemPrompt === "function" ? (opts.getSessionSystemPrompt(session) || undefined) : undefined,
+      appendSystemPrompt: [
+        typeof opts.getSessionSystemPrompt === "function" ? opts.getSessionSystemPrompt(session) : "",
+        sessionAdapter.vendor === "codex" && queryContextAvailable() ? codexQuestionGuidance() : "",
+      ].filter(Boolean).join("\n\n") || undefined,
       model: queryModel,
       // Effort is remembered per vendor and clamped to the session vendor's
       // supported levels: a global value would leak codex "minimal" into
@@ -1946,7 +1957,7 @@ function createSDKBridge(opts) {
       dynamicTools: sessionToolDefs,
       // Codex persists dynamic tools with a thread. A stale authorized Driver
       // gets this exact-query bridge; its handlers still reauthorize live.
-      sessionMcpServer: recoverCodexIssueTools ? getCodexSessionMcpServer(session, queryGeneration) : undefined,
+      sessionMcpServer: (recoverCodexIssueTools || recoverCodexQuestionTools) ? getCodexSessionMcpServer(session, queryGeneration) : undefined,
       callDynamicTool: function (toolName, args) {
         var toolDef = findSessionToolDef(toolName);
         if (toolDef && typeof toolDef.handler === "function") {
@@ -2159,6 +2170,9 @@ function createSDKBridge(opts) {
       if (completeInterviewCatalog || requiredCatalogTools.report_scheduled_task_outcome) {
         codexCatalogCandidate = { generation: queryGeneration, version: yoke.sessionTools.CODEX_CATALOG_VERSION };
       }
+      if (requiredCatalogTools.ask_user_questions) {
+        codexCatalogCandidate = Object.assign({}, codexCatalogCandidate || {}, { generation: queryGeneration, userInputVersion: 1 });
+      }
       if (hasIssueCatalog) {
         codexCatalogCandidate = Object.assign({}, codexCatalogCandidate || {}, {
           generation: queryGeneration,

package/lib/sessions.js

@@ -180,6 +180,7 @@ function createSessionManager(opts) {
       if (session.ownerId) metaObj.ownerId = session.ownerId;
       if (session.vendor) metaObj.vendor = session.vendor;
       if (session.codexDynamicToolCatalogVersion) metaObj.codexDynamicToolCatalogVersion = session.codexDynamicToolCatalogVersion;
+      if (session.codexUserInputToolCatalogVersion) metaObj.codexUserInputToolCatalogVersion = session.codexUserInputToolCatalogVersion;
       if (session.codexIssuesToolCatalogVersion) metaObj.codexIssuesToolCatalogVersion = session.codexIssuesToolCatalogVersion;
       if (session.model) metaObj.model = session.model;
       if (session.effort) metaObj.effort = session.effort;
@@ -354,6 +355,7 @@ function createSessionManager(opts) {
       };
       if (m.vendor) session.vendor = m.vendor;
       session.codexDynamicToolCatalogVersion = Number(m.codexDynamicToolCatalogVersion || 0);
+      session.codexUserInputToolCatalogVersion = Number(m.codexUserInputToolCatalogVersion || 0);
       session.codexIssuesToolCatalogVersion = Number(m.codexIssuesToolCatalogVersion || 0);
       session.model = m.model || deriveSessionModel(loaded[i].history);
       session.effort = m.effort || null;

package/lib/yoke/acp-process-manager.js

@@ -188,33 +188,41 @@ AcpProcessManager.prototype.addRequestHandler = function(method, fn) {
   this.requestHandlers[method] = fn;
 };
 
-AcpProcessManager.prototype.send = function(method, params, timeoutMs) {
+AcpProcessManager.prototype.send = function(method, params, timeoutMs, signal) {
   var self = this;
   var id = this.nextId++;
   timeoutMs = timeoutMs || 30000;
-
   return new Promise(function(resolve, reject) {
-    if (!self.proc || !self.started) {
-      reject(new Error("ACP server not started"));
-      return;
-    }
-    var timer = setTimeout(function() {
+    var timer;
+    function cleanup() {
+      if (timer) clearTimeout(timer);
       delete self.pendingRequests[id];
-      reject(new Error("Request timeout: " + method + " (id=" + id + ")"));
-    }, timeoutMs);
-    self.pendingRequests[id] = { resolve: resolve, reject: reject, timer: timer };
-
+      if (signal) signal.removeEventListener("abort", cancel);
+    }
+    function fail(error) { cleanup(); reject(error); }
+    function cancel() {
+      var error = new Error("ACP request cancelled: " + method);
+      error.name = "AbortError";
+      fail(error);
+    }
+    if (signal && signal.aborted) { cancel(); return; }
+    if (!self.proc || !self.started) { fail(new Error("ACP server not started")); return; }
+    timer = setTimeout(function() { fail(new Error("Request timeout: " + method + " (id=" + id + ")")); }, timeoutMs);
+    self.pendingRequests[id] = {
+      resolve: function (value) { cleanup(); resolve(value); }, reject: fail, timer: timer,
+    };
+    if (signal) signal.addEventListener("abort", cancel, { once: true });
     var msg = { jsonrpc: "2.0", id: id, method: method };
     if (params !== undefined) msg.params = params;
-    self._write(msg);
+    if (self._write(msg) === false) fail(new Error("ACP transport is not writable"));
   });
 };
 
 AcpProcessManager.prototype.notify = function(method, params) {
-  if (!this.proc || !this.started) return;
+  if (!this.proc || !this.started) return false;
   var msg = { jsonrpc: "2.0", method: method };
   if (params !== undefined) msg.params = params;
-  this._write(msg);
+  return this._write(msg);
 };
 
 AcpProcessManager.prototype.respond = function(id, result) {
@@ -228,11 +236,13 @@ AcpProcessManager.prototype.respondError = function(id, code, message) {
 };
 
 AcpProcessManager.prototype._write = function(msg) {
-  if (!this.proc || !this.proc.stdin || this.proc.stdin.destroyed) return;
+  if (!this.proc || !this.proc.stdin || this.proc.stdin.destroyed) return false;
   try {
     this.proc.stdin.write(JSON.stringify(msg) + "\n");
+    return true;
   } catch (e) {
     this._error("Write error:", e.message);
+    return false;
   }
 };
 

package/lib/yoke/acp-query-handle.js

@@ -1,29 +1,33 @@
 // Shared ACP Query Handle
 // -----------------------
 // Implements the YOKE QueryHandle contract with standard ACP session methods.
-
 var normalizer = require("./acp-event-normalizer");
 var driverRuntime = require("./acp-driver-runtime");
-
+var queryAbort = require("./query-abort");
 var uuidCounter = 0;
 function generateUuid(vendor) {
   uuidCounter++;
   return (vendor || "acp") + "-" + Date.now().toString(36) + "-" + uuidCounter.toString(36);
 }
-
 function isAuthError(value) {
   return /not logged in|sign in|log ?in|authenticate|authentication|credentials|unauthorized|forbidden|\b401\b/i.test(String(value || ""));
 }
-
 function isApproved(decision) {
   return decision === true || (decision && decision.behavior === "allow");
 }
-
 function createAcpQueryHandle(acp, queryOpts) {
   queryOpts = queryOpts || {};
   var vendor = queryOpts.vendor || "acp";
   var driver = queryOpts.driver || null;
   var abortController = queryOpts.abortController;
+  var cancellation = queryAbort.createAbortScope();
+  var removeAbort = function () {};
+  var pendingPermissions = new Set();
+  var stopDelivery = Promise.resolve();
+  function send(method, params, timeout) {
+    cancellation.check();
+    return cancellation.wait(acp.send(method, params, timeout, cancellation.signal));
+  }
   var canUseTool = queryOpts.canUseTool || null;
   var state = normalizer.createEventState({ vendor: vendor, contextWindow: queryOpts.contextWindow });
   state.sessionId = queryOpts.resumeSessionId || null;
@@ -76,6 +80,7 @@ function createAcpQueryHandle(acp, queryOpts) {
   function endIterator() {
     if (iteratorDone) return;
     iteratorDone = true;
+    removeAbort();
     if (eventWaiting) {
       var resolve = eventWaiting;
       eventWaiting = null;
@@ -128,7 +133,19 @@ function createAcpQueryHandle(acp, queryOpts) {
       return;
     }
 
+    var answered = false;
+    function cancelPermission() {
+      if (answered) return;
+      answered = true;
+      pendingPermissions.delete(cancelPermission);
+      acp.respond(msg.id, { outcome: { outcome: "cancelled" } });
+    }
+    pendingPermissions.add(cancelPermission);
     function respond(allowed) {
+      if (answered) return;
+      if (isCancelled()) { cancelPermission(); return; }
+      answered = true;
+      pendingPermissions.delete(cancelPermission);
       var optionId = allowed ? allowId : rejectId;
       if (!optionId) {
         acp.respond(msg.id, { outcome: { outcome: "cancelled" } });
@@ -160,7 +177,7 @@ function createAcpQueryHandle(acp, queryOpts) {
       input: input,
       options: options,
     }), function() { return { toolName: toolName, input: input }; }) || { toolName: toolName, input: input };
-    Promise.resolve(canUseTool(permission.toolName || toolName, permission.input || input, {})).then(function(decision) {
+    Promise.resolve(canUseTool(permission.toolName || toolName, permission.input || input, { signal: cancellation.signal })).then(function(decision) {
       respond(isApproved(decision));
     }).catch(function(err) {
       console.error("[yoke/" + vendor + "] canUseTool error:", err.message || err);
@@ -193,7 +210,7 @@ function createAcpQueryHandle(acp, queryOpts) {
     if (!state.sessionId || !acp.started || value === undefined || value === null) return Promise.resolve();
     var option = configOptionFor(category, fallbackId);
     if (option) {
-      return acp.send("session/set_config_option", {
+      return send("session/set_config_option", {
         sessionId: state.sessionId,
         configId: option.id,
         value: value,
@@ -202,7 +219,7 @@ function createAcpQueryHandle(acp, queryOpts) {
       });
     }
     if (category === "mode") {
-      return acp.send("session/set_mode", { sessionId: state.sessionId, modeId: value }, 15000);
+      return send("session/set_mode", { sessionId: state.sessionId, modeId: value }, 15000);
     }
     return Promise.reject(new Error("ACP session does not expose configuration option: " + fallbackId));
   }
@@ -230,7 +247,7 @@ function createAcpQueryHandle(acp, queryOpts) {
       if (safeModeValue([modes.currentModeId])) return Promise.resolve();
       var safeMode = safeModeValue(modes.availableModes || []);
       if (!safeMode) return Promise.reject(new Error("ACP agent started in an unsafe permission mode and exposed no supervised mode"));
-      return acp.send("session/set_mode", { sessionId: state.sessionId, modeId: safeMode }, 15000);
+      return send("session/set_mode", { sessionId: state.sessionId, modeId: safeMode }, 15000);
     }
     if (driver && driver.permissionModeGuaranteed === true) return Promise.resolve();
     return Promise.reject(new Error("ACP agent did not expose a verifiable supervised permission mode"));
@@ -302,6 +319,7 @@ function createAcpQueryHandle(acp, queryOpts) {
   }
 
   function applySessionResult(result) {
+    cancellation.check();
     result = result || {};
     if (result.sessionId) state.sessionId = result.sessionId;
     if (Array.isArray(result.configOptions)) state.configOptions = result.configOptions;
@@ -313,7 +331,7 @@ function createAcpQueryHandle(acp, queryOpts) {
   async function openDefaultSession(handlerEntry) {
     if (state.sessionId && queryOpts.canResumeSession) {
       handlerEntry.sessionId = state.sessionId;
-      var resumed = await acp.send("session/resume", buildSessionParams("resume", {
+      var resumed = await send("session/resume", buildSessionParams("resume", {
         sessionId: state.sessionId,
         cwd: queryOpts.cwd,
         mcpServers: queryOpts.mcpServers || [],
@@ -324,7 +342,7 @@ function createAcpQueryHandle(acp, queryOpts) {
       handlerEntry.sessionId = state.sessionId;
       state.loadingSession = true;
       try {
-        var loaded = await acp.send("session/load", buildSessionParams("load", {
+        var loaded = await send("session/load", buildSessionParams("load", {
           sessionId: state.sessionId,
           cwd: queryOpts.cwd,
           mcpServers: queryOpts.mcpServers || [],
@@ -336,7 +354,7 @@ function createAcpQueryHandle(acp, queryOpts) {
     }
 
     state.sessionId = null;
-    var result = await acp.send("session/new", buildSessionParams("new", {
+    var result = await send("session/new", buildSessionParams("new", {
       cwd: queryOpts.cwd,
       mcpServers: queryOpts.mcpServers || [],
     }), 60000);
@@ -355,7 +373,7 @@ function createAcpQueryHandle(acp, queryOpts) {
         sessionId: state.sessionId,
         prompt: asPrompt(message),
       });
-      return acp.send("session/prompt", params, 30 * 60 * 1000);
+      return send("session/prompt", params, 30 * 60 * 1000);
     });
   }
 
@@ -363,17 +381,17 @@ function createAcpQueryHandle(acp, queryOpts) {
     var currentMessage = prependSystemPrompt(initialMessage);
     var handlerEntry = acp.addHandler(handleServerEvent);
     try {
-      var sessionResult = await openSession(handlerEntry);
+      var sessionResult = await cancellation.wait(openSession(handlerEntry));
       handlerEntry.sessionId = state.sessionId;
-      await driverRuntime.callAsync(driver, "afterSessionOpen", driverContext({ sessionResult: sessionResult }), function() {});
-      await ensureSafePermissionMode();
+      await cancellation.wait(driverRuntime.callAsync(driver, "afterSessionOpen", driverContext({ sessionResult: sessionResult }), function() {}));
+      await cancellation.wait(ensureSafePermissionMode());
       if (state.model && state.model !== "auto") await setModel(state.model);
       if (queryOpts.mode) await setConfig("mode", "mode", queryOpts.mode);
 
       while (!isCancelled()) {
         normalizer.resetTurnState(state);
         pushEvent({ yokeType: "turn_start", uuid: generateUuid(vendor), messageType: "user" });
-        var result = await prompt(currentMessage);
+        var result = await cancellation.wait(prompt(currentMessage));
         var closing = normalizer.closeOpenBlocks(state);
         for (var i = 0; i < closing.length; i++) pushEvent(closing[i]);
         if (isCancelled() || (result && result.stopReason === "cancelled")) {
@@ -395,6 +413,7 @@ function createAcpQueryHandle(acp, queryOpts) {
           : { yokeType: "error", text: message });
       }
     } finally {
+      await stopDelivery;
       acp.removeHandler(handlerEntry);
       state.done = true;
       endIterator();
@@ -448,36 +467,29 @@ function createAcpQueryHandle(acp, queryOpts) {
       }; });
     },
     abort: function() {
+      if (state.aborted || iteratorDone) return;
       state.aborted = true;
-      driverRuntime.call(driver, "cancel", driverContext(), function() {
-        if (state.sessionId && acp.started) acp.notify("session/cancel", { sessionId: state.sessionId });
-      });
-      endIterator();
-    },
-    close: function() {
-      messageQueueEnded = true;
-      if (messageWaiting) {
-        var resolve = messageWaiting;
-        messageWaiting = null;
-        resolve(null);
-      }
-      endIterator();
+      cancellation.stop();
+      handle.endInput();
+      messageQueue = [];
+      pendingPermissions.forEach(function (cancel) { try { cancel(); } catch (e) {} });
+      stopDelivery = driverRuntime.callAsync(driver, "cancel", driverContext(), function() {
+        if (state.sessionId && (!acp.started || acp.notify("session/cancel", { sessionId: state.sessionId }) === false)) {
+          throw new Error("ACP transport is disconnected");
+        }
+      }).catch(function (error) {
+        pushEvent({ yokeType: "error", text: "Cancellation could not be delivered: " + error.message });
+      }).finally(endIterator);
+      return stopDelivery;
     },
+    close: function() { handle.endInput(); endIterator(); },
     endInput: function() {
       messageQueueEnded = true;
-      if (messageWaiting) {
-        var resolve = messageWaiting;
-        messageWaiting = null;
-        resolve(null);
-      }
+      if (messageWaiting) { var resolve = messageWaiting; messageWaiting = null; resolve(null); }
     },
   };
 
-  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/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.2",
+  "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"