clay-server 5.2.0-beta.4 → 5.2.0-beta.5

package/lib/sdk-bridge.js

@@ -323,6 +323,7 @@ function createSDKBridge(opts) {
   }
 
   function stopIdleReaper() {
+    responseRecovery.dispose();
     if (_idleReaperTimer) {
       clearInterval(_idleReaperTimer);
       _idleReaperTimer = null;
@@ -389,6 +390,17 @@ function createSDKBridge(opts) {
   var sendAndRecord = msgProcessor.sendAndRecord;
   var sendToSession = msgProcessor.sendToSession;
 
+  var responseRecovery = require("./sdk-response-recovery").attachResponseRecovery(Object.assign({
+    sessions: sm.sessions,
+    changed: onProcessingChanged,
+    record: sendAndRecord,
+    send: sendToSession,
+    broadcast: function() { if (sm.broadcastSessionList) sm.broadcastSessionList(); },
+    restart: function(session, payload, state) {
+      return startQuery(session, payload.text, payload.images, payload.linuxUser, payload.beforePush, null, state);
+    },
+  }, opts.responseRecovery || {}));
+
   // --- MCP elicitation ---
 
   function handleElicitation(session, request, opts) {
@@ -417,6 +429,7 @@ function createSDKBridge(opts) {
 
       if (pushModule) {
         pushModule.sendPush({
+          sessionId: session.localId,
           type: "elicitation",
           slug: slug,
           title: (request.serverName || "MCP Server") + " needs input",
@@ -467,6 +480,7 @@ function createSDKBridge(opts) {
 
       if (pushModule) {
         pushModule.sendPush({
+          sessionId: session.localId,
           type: "user_dialog",
           slug: slug,
           title: "Claude needs a decision",
@@ -745,6 +759,34 @@ function createSDKBridge(opts) {
     // Workspace inspection and proposal posting are session-bound. Keep this
     // list exact so a future execution/mutation tool cannot inherit approval.
     var safeWorkspaceTools = {
+      "mcp__clay-workspace__read_owner_screen": true,
+      "mcp__clay-workspace__inspect_owner_screen_change": true,
+      "mcp__clay-workspace__control_owner_screen": true,
+      "mcp__clay-workspace__discover_product_controls": true,
+      "mcp__clay-workspace__list_owned_mates": true,
+      "mcp__clay-workspace__begin_schedule_control_interview": true,
+      "mcp__clay-workspace__read_schedule_controls": true,
+      "mcp__clay-workspace__inspect_schedule_change": true,
+      "mcp__clay-workspace__control_schedules": true,
+      "mcp__clay-workspace__read_mate_chat_control": true,
+      "mcp__clay-workspace__inspect_mate_chat_change": true,
+      "mcp__clay-workspace__control_mate_chat": true,
+      "mcp__clay-workspace__read_project_workspace": true,
+      "mcp__clay-workspace__read_workspace_receipt": true,
+      "mcp__clay-workspace__inspect_workspace_change": true,
+      "mcp__clay-workspace__control_project_workspace": true,
+      "mcp__clay-workspace__read_project_records": true,
+      "mcp__clay-workspace__inspect_project_record_change": true,
+      "mcp__clay-workspace__control_project_records": true,
+      "mcp__clay-workspace__read_mate_knowledge_control": true,
+      "mcp__clay-workspace__inspect_mate_knowledge_change": true,
+      "mcp__clay-workspace__control_mate_knowledge": true,
+      "mcp__clay-workspace__inspect_mate_control": true,
+      "mcp__clay-workspace__control_mate_lifecycle": true,
+      "mcp__clay-workspace__inspect_project_control": true,
+      "mcp__clay-workspace__control_project_lifecycle": true,
+      "mcp__clay-workspace__inspect_session_control": true,
+      "mcp__clay-workspace__control_project_session": true,
       "mcp__clay-workspace__list_projects": true,
       "mcp__clay-workspace__list_project_sessions": true,
       "mcp__clay-workspace__search_project_history": true,
@@ -902,6 +944,7 @@ function createSDKBridge(opts) {
 
       if (pushModule) {
         pushModule.sendPush({
+          sessionId: session.localId,
           type: "permission_request",
           slug: slug,
           requestId: requestId,
@@ -1006,6 +1049,7 @@ function createSDKBridge(opts) {
   function recordRuntimeEffectivePermissionMode(session, queryInstance, queryGeneration, message) {
     if (!message || (message.yokeType !== "init" && message.yokeType !== "status") || !message.permissionMode) return false;
     if (!ownsQueryRuntime(session, queryInstance, queryGeneration)) return false;
+    session._permissionObservationRevision = Number(session._permissionObservationRevision || 0) + 1;
     session.effectivePermissionMode = message.permissionMode;
     session.permissionModeFallbackReason = null;
     sm.saveSessionFile(session);
@@ -1047,7 +1091,7 @@ function createSDKBridge(opts) {
     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 (!ownsQueryRuntime(session, myQueryInstance, myQueryGeneration) || responseRecovery.stopping(session)) 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") {
@@ -1091,6 +1135,7 @@ function createSDKBridge(opts) {
         if (continuationIdentity && !ownsQueryRuntime(session, myQueryInstance, myQueryGeneration)) {
           continue;
         }
+        responseRecovery.event(session, msg);
         processSDKMessage(session, msg);
         if (continuationIdentity) {
           settleContinuationStartup(session, myQueryInstance, myQueryGeneration, true, null);
@@ -1120,7 +1165,7 @@ function createSDKBridge(opts) {
       // Stream ended normally after a task stop — no "result" message was sent,
       // so the session is still marked as processing. Send interrupted feedback.
       console.log("[sdk-bridge] processQueryStream ended: isProcessing=" + session.isProcessing + " taskStopRequested=" + session.taskStopRequested);
-      var stillOwnsRuntime = session.queryInstance === myQueryInstance;
+      var stillOwnsRuntime = session.queryInstance === myQueryInstance && !responseRecovery.stopping(session);
       settleContinuationStartup(session, myQueryInstance, myQueryGeneration, false, "The successor query ended before initialization.");
       if (session.isProcessing && session.taskStopRequested && stillOwnsRuntime) {
         session._lastTurnInterrupted = true;
@@ -1158,7 +1203,7 @@ function createSDKBridge(opts) {
       }
     } catch (err) {
       settleContinuationStartup(session, myQueryInstance, myQueryGeneration, false, err.message || "The successor query failed before initialization.");
-      if (session.isProcessing && session.queryInstance === myQueryInstance) {
+      if (session.isProcessing && session.queryInstance === myQueryInstance && !responseRecovery.stopping(session)) {
         session.isProcessing = false;
         session._awaitingTurnResult = false;
         session._queuedTurnCount = 0;
@@ -1272,7 +1317,8 @@ function createSDKBridge(opts) {
       }
       if (session.messageQueue === myMessageQueue) session.messageQueue = null;
       if (session.abortController === myAbortController) session.abortController = null;
-      if (ownsRuntime) {
+      if (ownsRuntime && !responseRecovery.stopping(session)) {
+        responseRecovery.cancel(session);
         session.taskStopRequested = false;
         session.pendingPermissions = {};
         // Preserve only restored legacy MCP entries. Canonical Yoke requests
@@ -1321,7 +1367,7 @@ function createSDKBridge(opts) {
           }
         }
       }
-      if (!session.isProcessing && typeof opts.onSessionAvailable === "function") opts.onSessionAvailable(session);
+      if (!responseRecovery.stopping(session) && !session.isProcessing && typeof opts.onSessionAvailable === "function") opts.onSessionAvailable(session);
     }
   }
 
@@ -1442,22 +1488,70 @@ function createSDKBridge(opts) {
 
   // Wrapper: marks the boot window so pushMessage can buffer instead of
   // dropping messages that arrive while createQuery is still awaiting.
-  async function startQuery(session, text, images, linuxUser, beforePush, onAccepted) {
+  async function startQuery(session, text, images, linuxUser, beforePush, onAccepted, retryState) {
+    if (opts.isLifecycleExecutionPaused && opts.isLifecycleExecutionPaused()) {
+      sendAndRecord(session, { type: "error", text: "Project execution is paused for lifecycle recovery. Reconcile the saved operation, or send a new owner message after restoring the registration." });
+      session.isProcessing = false; onProcessingChanged(); sendAndRecord(session, { type: "done", code: 1 }); return false;
+    }
+    if (session._responseRecoveryStopPending && !retryState) {
+      session.isProcessing = false;
+      onProcessingChanged();
+      sendAndRecord(session, { type: "error", text: "The previous Claude attempt has not confirmed stopped. Check the connection before sending this message again." });
+      sendAndRecord(session, { type: "done", code: 1 });
+      return false;
+    }
+    if (responseRecovery.stopping(session) && !retryState) return false;
     delete session._lastTurnInterrupted;
+    var claude = (session.vendor || adapter.vendor) === "claude";
+    var payload = { text: text, images: images, linuxUser: linuxUser, beforePush: beforePush };
+    var recoveryState = claude ? responseRecovery.begin(session, payload, retryState) : null;
+    if (recoveryState) recoveryState.handle = null;
+    var guardedPush = function() {
+      return !session.destroying && !session.taskStopRequested
+        && (!recoveryState || responseRecovery.valid(session, recoveryState) && !recoveryState.stopping)
+        && (typeof beforePush !== "function" || beforePush() === true);
+    };
+    guardedPush.exactProductDelivery = !!(beforePush && beforePush.exactProductDelivery);
     session._queryGeneration = (session._queryGeneration || 0) + 1;
     session._queryStarting = true;
+    var starting = startQueryInner(session, text, images, linuxUser, guardedPush, onAccepted, recoveryState);
+    if (recoveryState) recoveryState.starting = starting;
     try {
-      return await startQueryInner(session, text, images, linuxUser, beforePush, onAccepted);
+      var accepted = await starting;
+      if (accepted === false && (!recoveryState || !recoveryState.stopping)) {
+        responseRecovery.cancel(session);
+        session.isProcessing = false;
+        onProcessingChanged();
+      }
+      return accepted;
+    } catch (error) {
+      // Includes synchronous input queue failures, before stream consumption.
+      var failedHandle = session.queryInstance;
+      if (failedHandle) {
+        try { if (typeof failedHandle.abort === "function") failedHandle.abort(); } catch (e) {}
+        try { if (typeof failedHandle.close === "function") failedHandle.close(); } catch (e) {}
+      }
+      session.queryInstance = null;
+      session.abortController = null;
+      session.messageQueue = null;
+      session.isProcessing = false;
+      session._awaitingTurnResult = false;
+      session._queuedTurnCount = 0;
+      taskLifecycle.clearAll(session);
+      if (!recoveryState || !recoveryState.stopping) {
+        responseRecovery.cancel(session);
+        sendAndRecord(session, { type: "error", text: "The agent connection failed while delivering your message. Please retry or check the connection." });
+        sendAndRecord(session, { type: "done", code: 1 });
+        onProcessingChanged();
+        sm.broadcastSessionList();
+      }
+      return false;
     } finally {
       session._queryStarting = false;
-      if (!session.queryInstance && session.pendingPush && session.pendingPush.length) {
-        // The query never came up (auth/adapter failure already reported to
-        // the user). Drop the backlog rather than leaking it into a future
-        // unrelated query.
-        session.pendingPush = [];
-      }
-      if (!session.queryInstance && !session.isProcessing) session.taskStopRequested = false;
-      if (!session.isProcessing && typeof opts.onSessionAvailable === "function") opts.onSessionAvailable(session);
+      delete session._codexRecoveryWaiting;
+      if (!session.queryInstance && session.pendingPush && session.pendingPush.length) session.pendingPush = [];
+      if (!session.queryInstance && !session.isProcessing && !session._pendingMessageDrainPaused && !responseRecovery.stopping(session)) session.taskStopRequested = false;
+      if (!responseRecovery.stopping(session) && !session.isProcessing && typeof opts.onSessionAvailable === "function") opts.onSessionAvailable(session);
     }
   }
 
@@ -1501,7 +1595,7 @@ function createSDKBridge(opts) {
     };
   }
 
-  async function startQueryInner(session, text, images, linuxUser, beforePush, onAccepted) {
+  async function startQueryInner(session, text, images, linuxUser, beforePush, onAccepted, recoveryState) {
     var sessionRuntimeEnv = getRuntimeEnv(session);
     var resumedAtQueryStart = !!session.cliSessionId;
     async function ensureVendorReady(vendor) {
@@ -1822,13 +1916,15 @@ function createSDKBridge(opts) {
       if (sm && sm.sessions && typeof sm.sessions.get === "function" && sm.sessions.get(session.localId) !== session) return false;
       return canUseSessionTools(session) === true;
     }
+    var hasMateScheduleTool = sessionToolDefs.some(function (tool) { return yoke.sessionTools.MATE_SCHEDULE_TOOLS.indexOf(tool.name) !== -1; });
+    var recoverCodexMateSchedules = sessionAdapter.vendor === "codex" && !!session.cliSessionId && hasMateScheduleTool && queryContextAvailable();
     var hasScheduleTool = false;
     var hasScheduleInterviewTool = false;
     var scheduleInterviewActive = null;
     var scheduleQuestionLimit = null;
     for (var sessionToolIndex = 0; sessionToolIndex < sessionToolDefs.length; sessionToolIndex++) {
       if (yoke.sessionTools.SCHEDULE_TOOLS.indexOf(sessionToolDefs[sessionToolIndex].name) !== -1) hasScheduleTool = true;
-      if (sessionToolDefs[sessionToolIndex].name === "begin_scheduled_task_interview") {
+      if (["begin_scheduled_task_interview", "begin_mate_schedule_interview", "begin_schedule_control_interview"].indexOf(sessionToolDefs[sessionToolIndex].name) >= 0) {
         hasScheduleInterviewTool = true;
         scheduleInterviewActive = sessionToolDefs[sessionToolIndex].scheduleInterviewActive || null;
         scheduleQuestionLimit = sessionToolDefs[sessionToolIndex].structuredQuestionLimit || null;
@@ -1860,9 +1956,10 @@ function createSDKBridge(opts) {
       return "Ask exactly one question at a time, wait for the answer, then ask the next question.";
     }
     var sessionUserInputHandler = function(request, respond) {
-      if (!structuredInputContextAvailable()) {
+      if (queryRetired() || !structuredInputContextAvailable()) {
         return respond.cancel("This structured-input request belongs to an unavailable or older query.");
       }
+      responseRecovery.progress(session);
       var questionError = scheduleQuestionError(request);
       if (questionError) return respond.cancel(questionError);
       if (request.presentation === "elicitation" && request.diagnostics && request.diagnostics.elicitation) {
@@ -1895,6 +1992,11 @@ function createSDKBridge(opts) {
         }
       }
     }
+    if (sessionAdapter.vendor === "claude" && hasMateScheduleTool && typeof sessionAdapter.createToolServer === "function") {
+      localMcpServers = Object.assign({}, localMcpServers || {});
+      localMcpServers["clay-mate-schedules"] = sessionAdapter.createToolServer({ name: "clay-mate-schedules", version: "1.0.0",
+        tools: sessionToolDefs.filter(function (tool) { return yoke.sessionTools.MATE_SCHEDULE_TOOLS.indexOf(tool.name) !== -1; }) });
+    }
     if (selectedUserInputMode === "fallback") {
       var userInputServer = yoke.userInput.createFallbackServer(sessionAdapter, sessionUserInputHandler, { force: true, maxQuestions: scheduleQuestionLimit });
       if (userInputServer) {
@@ -1951,6 +2053,11 @@ function createSDKBridge(opts) {
     }
 
     var modelSwitchGeneration = session._queryGeneration;
+    function queryRetired() {
+      if (sessionAdapter.vendor !== "claude") return false;
+      return Number(session._sdkQueryGeneration || 0) !== queryGeneration || session.taskStopRequested
+        || session.destroying || responseRecovery.stopping(session) || (handle && session.queryInstance !== handle);
+    }
     var queryOpts = {
       onModelSwitch: function(change) {
         if (session._queryGeneration !== modelSwitchGeneration || session.taskStopRequested) return;
@@ -1992,7 +2099,18 @@ 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 || recoverCodexQuestionTools || recoverCodexBrowserTools || recoverCodexLinearTools || recoverCodexYouTools || recoverCodexExternalTools) ? getCodexSessionMcpServer(session, queryGeneration) : undefined,
+      sessionMcpServer: (recoverCodexMateSchedules || recoverCodexIssueTools || recoverCodexQuestionTools || recoverCodexBrowserTools || recoverCodexLinearTools || recoverCodexYouTools || recoverCodexExternalTools) ? getCodexSessionMcpServer(session, queryGeneration) : undefined,
+      onRecoveryAdmission: function(waiting) {
+        if (!queryContextAvailable()) return;
+        if (waiting) session._codexRecoveryWaiting = queryGeneration;
+        else delete session._codexRecoveryWaiting;
+      },
+      onRecoveryWaiting: function(waiting) {
+        if (!queryContextAvailable()) return;
+        sendAndRecord(session, { type: 'informational', level: 'info', content: waiting
+          ? 'Codex recovery is waiting for this conversation’s runtime to become safely available. Your message is retained; Stop cancels the wait.'
+          : 'Codex recovery is ready. Continuing your retained message.' });
+      },
       callDynamicTool: function (toolName, args) {
         var toolDef = findSessionToolDef(toolName);
         if (toolDef && typeof toolDef.handler === "function") {
@@ -2003,6 +2121,8 @@ function createSDKBridge(opts) {
       resumeSessionId: session.cliSessionId || undefined,
       abortController: linuxUser ? undefined : session.abortController,
       canUseTool: function(toolName, input, toolOpts) {
+        if (queryRetired()) return { behavior: "deny", message: "This attempt has stopped." };
+        responseRecovery.progress(session);
         var nativeQuestionError = toolName === "AskUserQuestion" ? scheduleQuestionError(input) : null;
         if (nativeQuestionError) return { behavior: "deny", message: nativeQuestionError };
         var permissionName = toolName;
@@ -2011,6 +2131,8 @@ function createSDKBridge(opts) {
         return handleCanUseTool(session, permissionName, input, toolOpts);
       },
       preToolUsePolicy: function(toolName, input) {
+        if (queryRetired()) return Promise.resolve({ behavior: "deny", message: "This attempt has stopped." });
+        responseRecovery.progress(session);
         var nativeQuestionError = toolName === "AskUserQuestion" ? scheduleQuestionError(input) : null;
         if (nativeQuestionError) return Promise.resolve({ behavior: "deny", message: nativeQuestionError });
         var permissionName = toolName;
@@ -2024,12 +2146,18 @@ function createSDKBridge(opts) {
       validateUserInputRequest: scheduleQuestionError,
       userInputMode: selectedUserInputMode,
       onElicitation: function(request, elicitOpts) {
+        if (queryRetired()) return Promise.resolve({ action: "cancel" });
+        responseRecovery.progress(session);
         return handleElicitation(session, request, elicitOpts);
       },
       onUserDialog: function(dialogRequest, dialogOpts) {
+        if (queryRetired()) return Promise.resolve({ behavior: "cancelled" });
+        responseRecovery.progress(session);
         return handleUserDialog(session, dialogRequest, dialogOpts);
       },
       callMcpTool: function(serverName, toolName, args) {
+        if (queryRetired()) return Promise.reject(new Error("This attempt has stopped."));
+        responseRecovery.progress(session);
         return callMcpToolHandler(mergedMcpServers, serverName, toolName, args);
       },
       adapterOptions: {
@@ -2061,10 +2189,28 @@ function createSDKBridge(opts) {
       },
     };
 
+    if (recoveryState) {
+      if (!recoveryState.context) recoveryState.context = { appendSystemPrompt: queryOpts.appendSystemPrompt, model: queryOpts.model, effort: queryOpts.effort };
+      Object.assign(queryOpts, recoveryState.context);
+    }
     var handle;
+    var startupHandle = session.queryInstance;
     console.log("[sdk-bridge] calling adapter.createQuery... vendor=" + sessionAdapter.vendor);
     try {
       handle = await sessionAdapter.createQuery(queryOpts);
+      // A guarded delivery must still own the exact startup after provider
+      // creation. Never replace a newer handle or publish to a deleted target.
+      if (beforePush && beforePush.exactProductDelivery) {
+        var startupCurrent = false;
+        try { startupCurrent = sm.sessions.get(session.localId) === session && session.queryInstance === startupHandle && Number(session._sdkQueryGeneration || 0) === queryGeneration && beforePush() === true; } catch (guardError) {}
+        if (!startupCurrent) {
+          try { if (handle.abort) handle.abort(); } catch (abortError) {}
+          try { if (handle.close) handle.close(); } catch (closeError) {}
+          if (session.queryInstance === startupHandle) session.isProcessing = false;
+          return false;
+        }
+      }
+      if (recoveryState) recoveryState.handle = handle;
       console.log("[sdk-bridge] createQuery returned handle, vendor=" + sessionAdapter.vendor);
       // SDK accepted the explicit title. Provisional labels remain eligible
       // for semantic generation after the first Home exchange (or the normal
@@ -2084,6 +2230,7 @@ function createSDKBridge(opts) {
       console.error("[sdk-bridge] Failed to create query for session " + session.localId + ":", e.message || e);
       console.error("[sdk-bridge] cliSessionId:", session.cliSessionId, "resume:", !!session.cliSessionId);
       console.error("[sdk-bridge] Stack:", e.stack || "(no stack)");
+      if (beforePush && beforePush.exactProductDelivery && (sm.sessions.get(session.localId) !== session || session.queryInstance !== startupHandle || Number(session._sdkQueryGeneration || 0) !== queryGeneration)) return false;
       session.isProcessing = false;
       session._awaitingTurnResult = false;
       session._queuedTurnCount = 0;
@@ -2138,6 +2285,7 @@ function createSDKBridge(opts) {
     }
 
     if (typeof beforePush === "function" && beforePush() !== true) {
+      try { if (typeof handle.abort === "function") handle.abort(); } catch (e) {}
       try { handle.close(); } catch (e) {}
       if (session.queryInstance === handle) session.queryInstance = null;
       session.messageQueue = null;
@@ -2147,6 +2295,13 @@ function createSDKBridge(opts) {
       session._queuedTurnCount = 0;
       taskLifecycle.clearAll(session);
       onProcessingChanged();
+      if (recoveryState && !responseRecovery.stopping(session)) {
+        sendAndRecord(session, { type: "thinking_stop" });
+        sendAndRecord(session, { type: session.taskStopRequested ? "info" : "error", text: session.taskStopRequested
+          ? "Stopped before sending your message."
+          : "This request is no longer eligible for delivery. Please review it and send it again." });
+        sendAndRecord(session, { type: "done", code: session.taskStopRequested ? 0 : 1 });
+      }
       sm.broadcastSessionList();
       return false;
     }
@@ -2235,6 +2390,19 @@ function createSDKBridge(opts) {
   // dropped messages in both gap windows, which is what made a session show
   // the processing indicator without ever answering until a second send.
   function pushMessage(session, text, images, deliveryMeta) {
+    if (session._responseRecoveryStopPending && !responseRecovery.stopping(session)) return false;
+    function trackDelivery() {
+      if ((session.vendor || adapter.vendor) === "claude") responseRecovery.enqueue(session, {
+        text: text, images: images, linuxUser: session.lastLinuxUser || null,
+      });
+    }
+    if (responseRecovery.stopping(session)) {
+      // Keep admission serialized while the old execution is terminating.
+      session.pendingPush = session.pendingPush || [];
+      session.pendingPush.push(Object.assign({ text: text, images: images || null }, deliveryMeta || {}));
+      trackDelivery();
+      return true;
+    }
     session.lastActivityAt = Date.now();
     if (session._runtimeRefreshRequested && !session._queryStarting) {
       session._runtimeRefreshRequested = false;
@@ -2261,6 +2429,7 @@ function createSDKBridge(opts) {
         console.error("[sdk-bridge] QueryHandle rejected message for session " + session.localId + ":", e.message || e);
       }
       if (delivered) {
+        trackDelivery();
         delete session._lastTurnInterrupted;
         if (session._awaitingTurnResult) {
           session._queuedTurnCount = (session._queuedTurnCount || 0) + 1;
@@ -2285,6 +2454,7 @@ function createSDKBridge(opts) {
     if (session._queryStarting) {
       session.pendingPush = session.pendingPush || [];
       session.pendingPush.push(Object.assign({ text: text, images: images || null }, deliveryMeta || {}));
+      trackDelivery();
       return true;
     }
     return false;
@@ -2495,7 +2665,20 @@ function createSDKBridge(opts) {
     sendModelInfoForVendor(null, defaultVendor, defaultModelForVendor(defaultVendor));
   }
 
-  async function setModel(session, model) {
+  async function setModel(session, model, options) {
+    if (options && typeof options.revalidate === "function") {
+      var vendor = session.vendor || sm.defaultVendor || "claude";
+      return require("./session-config-transition").applySessionConfig({
+        sm: sm, session: session, revalidate: options.revalidate, method: "setModel", nativeValue: model, changes: { model: model },
+        publish: function () {
+          sm.defaultModelByVendor = sm.defaultModelByVendor || {};
+          sm.defaultModelByVendor[vendor] = model;
+          sm.broadcastSessionList();
+          sendModelInfoForVendor(session, vendor, model);
+          sendToSession(session, { type: "config_state", sessionId: session.localId, vendor: vendor, model: model, effort: session.effort || sm.currentEffort || "medium", mode: session.permissionMode || sm.currentPermissionMode || "default", betas: sm.currentBetas || [] });
+        },
+      });
+    }
     // Normalize to string id in case a { value, displayName } object slips in
     if (model && typeof model !== "string") {
       model = modelEntryValue(model);
@@ -2531,7 +2714,22 @@ function createSDKBridge(opts) {
     }
   }
 
-  async function setEffort(session, effort) {
+  async function setEffort(session, effort, options) {
+    if (options && typeof options.revalidate === "function") {
+      var vendor = session.vendor || sm.defaultVendor || "claude";
+      var value = yoke.clampEffort(vendor, effort);
+      if (!value || value !== effort) throw new Error("Unsupported reasoning effort.");
+      return require("./session-config-transition").applySessionConfig({
+        sm: sm, session: session, revalidate: options.revalidate, method: "setEffort", nativeValue: value, changes: { effort: value },
+        publish: function () {
+          sm.currentEffortByVendor = sm.currentEffortByVendor || {};
+          sm.currentEffortByVendor[vendor] = value;
+          sm.currentEffort = value;
+          sm.broadcastSessionList();
+          sendToSession(session, { type: "config_state", sessionId: session.localId, vendor: vendor, effort: value, model: session.model || "", mode: session.permissionMode || sm.currentPermissionMode || "default", betas: sm.currentBetas || [] });
+        },
+      });
+    }
     // Remember the pick per vendor (clamped) so vendor switches don't leak
     // unsupported levels across sessions; sm.currentEffort stays as the
     // display value for the session the user just configured.
@@ -2800,6 +2998,7 @@ function createSDKBridge(opts) {
     startQuery: startQuery,
     startQueryWithAcceptance: startQueryWithAcceptance,
     pushMessage: pushMessage,
+    cancelResponseRecovery: responseRecovery.cancel,
     refreshSessionRuntime: refreshSessionRuntime,
     refreshEnvironmentRuntime: refreshEnvironmentRuntime,
     setModel: setModel,

package/lib/sdk-message-processor.js

@@ -430,6 +430,7 @@ function attachMessageProcessor(ctx) {
         if (pushModule && block.name === "AskUserQuestion" && input.questions) {
           var q = input.questions[0];
           pushModule.sendPush({
+            sessionId: session.localId,
             type: "ask_user",
             slug: slug,
             title: (mateDisplayName || "Claude") + " has a question",
@@ -715,6 +716,7 @@ function attachMessageProcessor(ctx) {
 
       if (pushModule && !session._delegatedBy && !_suppressResponseNotification) {
         pushModule.sendPush({
+          sessionId: session.localId,
           type: "done",
           slug: slug,
           title: _doneTitle,

package/lib/sdk-response-recovery.js

@@ -0,0 +1,155 @@
+// Claude delivery watchdog. Only an unanswered foreground turn is replayable.
+function attachResponseRecovery(ctx) {
+  var states = new Map();
+  var schedule = ctx.setTimeout || setTimeout;
+  var unschedule = ctx.clearTimeout || clearTimeout;
+  var waitMs = ctx.waitMs || 180000;
+  var stopMs = ctx.stopMs || 10000;
+
+  function live(session, state) {
+    return states.get(session) === state && !session.destroying && !session.taskStopRequested
+      && state.ownerId === session.ownerId && state.vendor === session.vendor
+      && (!ctx.sessions || ctx.sessions.get(session.localId) === session);
+  }
+  function clearTimer(state) {
+    if (state.timer) unschedule(state.timer);
+    state.timer = null;
+  }
+  function cancel(session, expected) {
+    var state = states.get(session);
+    if (expected && state !== expected) return;
+    if (state) clearTimer(state);
+    states.delete(session);
+  }
+  function protectedWait(session) {
+    return [session.pendingPermissions, session.pendingAskUser, session.pendingElicitations,
+      session.pendingUserDialogs, session.activeTaskToolIds].some(function(map) {
+      return map && Object.keys(map).length > 0;
+    }) || (session.activeBackgroundTasks && session.activeBackgroundTasks.length > 0);
+  }
+  function arm(session, state) {
+    clearTimer(state);
+    if (!state.turns.length || state.turns[0].progress || state.stopping) return;
+    state.timer = schedule(function() { expire(session, state); }, waitMs);
+    if (state.timer && state.timer.unref) state.timer.unref();
+  }
+  function snapshot(payload) {
+    return Object.assign({}, payload, { images: payload.images ? JSON.parse(JSON.stringify(payload.images)) : payload.images });
+  }
+  function begin(session, payload, retryState) {
+    if (retryState) return retryState;
+    cancel(session);
+    var state = { turns: [snapshot(payload)], timer: null, stopping: false, retried: false, ownerId: session.ownerId, vendor: session.vendor };
+    states.set(session, state);
+    arm(session, state);
+    return state;
+  }
+  function enqueue(session, payload) {
+    var state = states.get(session);
+    if (!state) return begin(session, payload);
+    state.turns.push(snapshot(payload));
+    return state;
+  }
+  function progress(session) {
+    var state = states.get(session);
+    if (!state || state.stopping || !state.turns.length) return;
+    state.turns[0].progress = true;
+    clearTimer(state);
+  }
+  function event(session, msg) {
+    var state = states.get(session);
+    if (!state || state.stopping || !msg) return;
+    var type = msg.yokeType;
+    if (type === 'error' || type === 'interrupted') { cancel(session); return; }
+    if (type === 'result') {
+      if (msg.subtype === 'success' && !msg.is_error && msg.numTurns === 0
+          && msg.origin && msg.origin.kind === 'task-notification'
+          && !msg.localCommand && msg.resultText === '') return;
+      var remaining = require('./sdk-turn-queue').pendingSends(session, msg);
+      state.turns = remaining ? state.turns.slice(-remaining) : [];
+      state.retried = false;
+      arm(session, state);
+      if (!state.turns.length) cancel(session);
+    } else if ((type === 'text_delta' || type === 'thinking_delta') && (msg.text || msg.delta)
+        || type === 'tool_start' || type === 'tool_input_delta' || type === 'tool_progress'
+        || type === 'task_started' || type === 'task_progress' || type === 'subagent_message'
+        || type === 'message' && msg.messageRole === 'assistant' && msg.content && msg.content.length) {
+      progress(session);
+    }
+  }
+  function finish(session, state, text) {
+    if (!live(session, state)) { cancel(session, state); return; }
+    cancel(session);
+    // Fence late output when a transport cannot confirm termination.
+    session._sdkQueryGeneration = Number(session._sdkQueryGeneration || 0) + 1;
+    session.isProcessing = false;
+    session._awaitingTurnResult = false;
+    session._queuedTurnCount = 0;
+    ctx.changed();
+    ctx.record(session, { type: 'thinking_stop' });
+    ctx.record(session, { type: 'error', text: text });
+    ctx.record(session, { type: 'done', code: 1 });
+    ctx.broadcast();
+  }
+  async function expire(session, state) {
+    clearTimer(state);
+    if (!live(session, state)) { cancel(session, state); return; }
+    // Never stop a known tool or a human decision because prose is absent.
+    if (protectedWait(session)) { progress(session); return; }
+    state.stopping = true;
+    ctx.record(session, { type: 'info', text: 'Claude has not responded for three minutes. Stopping this attempt safely before retrying.' });
+    var timeout;
+    var stopped = false;
+    try {
+      var stopAttempt = (async function() {
+        var handle = session.queryInstance || state.handle;
+        if (!handle && session.abortController) session.abortController.abort();
+        if (!handle && state.starting) await state.starting;
+        handle = handle || session.queryInstance || state.handle;
+        if (handle) {
+          if (typeof handle.stopAndWait !== 'function') return false;
+          await handle.stopAndWait();
+          if (session.streamPromise) await session.streamPromise;
+        }
+        return true;
+      })();
+      session._responseRecoveryStopPending = stopAttempt;
+      stopAttempt.then(function(confirmed) {
+        if (confirmed && session._responseRecoveryStopPending === stopAttempt) session._responseRecoveryStopPending = null;
+      }, function() {});
+      stopped = await Promise.race([
+        stopAttempt,
+        new Promise(function(resolve) { timeout = schedule(function() { resolve(false); }, stopMs); }),
+      ]);
+    } catch (e) { stopped = false; }
+    if (timeout) unschedule(timeout);
+    if (!live(session, state)) { cancel(session, state); return; }
+    if (!stopped) {
+      finish(session, state, 'Claude could not be confirmed stopped. Automatic retry was cancelled to avoid running your request twice. Check your Claude connection before trying again.');
+      return;
+    }
+    if (state.retried || state.turns.length !== 1) {
+      finish(session, state, state.retried
+        ? 'Claude still has not responded after one automatic retry. Please send your message again or check your Claude connection.'
+        : 'Claude did not respond. Several messages were queued, so automatic replay was cancelled to avoid duplicating work. Please send the unanswered messages again.');
+      return;
+    }
+    state.retried = true;
+    state.stopping = false;
+    session.isProcessing = true;
+    ctx.changed();
+    ctx.record(session, { type: 'info', text: 'The previous attempt has stopped. Retrying your original message once.' });
+    ctx.send(session, { type: 'status', status: 'processing' });
+    arm(session, state);
+    var payload = state.turns[0];
+    await ctx.restart(session, payload, state);
+  }
+  return {
+    begin: begin, enqueue: enqueue, event: event, progress: progress, cancel: cancel,
+    current: function(session) { return states.get(session); },
+    valid: live,
+    stopping: function(session) { var state = states.get(session); return !!(state && state.stopping); },
+    dispose: function() { states.forEach(function(state) { clearTimer(state); }); states.clear(); },
+  };
+}
+module.exports = { attachResponseRecovery: attachResponseRecovery };