clay-server 3.4.0-beta.2 → 3.4.0-beta.21

package/lib/project-session-handoff.js

@@ -0,0 +1,162 @@
+var yoke = require("./yoke");
+var contextBuilder = require("./session-handoff-context");
+
+function hasUserContext(session) {
+  var history = (session && session.history) || [];
+  for (var i = 0; i < history.length; i++) {
+    if (history[i] && history[i].type === "user_message" && history[i].text) return true;
+    if (history[i] && history[i].type === "handoff_context" && history[i].request) return true;
+  }
+  return false;
+}
+
+function attachSessionHandoff(ctx) {
+  var sm = ctx.sm;
+
+  function sendResult(ws, ok, details) {
+    ctx.sendTo(ws, Object.assign({ type: "session_handoff_result", ok: ok }, details || {}));
+  }
+
+  function validate(ws, source, targetVendor) {
+    if (ctx.isMate) throw new Error("Session handoff is only available in projects.");
+    if (!source) throw new Error("No active session was found.");
+    if (ctx.splitStore && ctx.splitStore.groupForMember(source.localId)) {
+      throw new Error("Open the session by itself before continuing it in another agent.");
+    }
+    if (source.isProcessing || source._queryStarting) {
+      throw new Error("Wait for the current response to finish before continuing in another agent.");
+    }
+    if (!hasUserContext(source)) throw new Error("This session does not have any conversation to continue.");
+    if (!targetVendor) throw new Error("Choose an agent for the handoff.");
+    if (!ctx.adapters[targetVendor] || (sm.installedVendors || []).indexOf(targetVendor) === -1) {
+      throw new Error("The selected coding agent is not installed.");
+    }
+    var linuxUser = ctx.getLinuxUserForSession(source);
+    var vendorInfo = yoke.getVendorInfo(targetVendor);
+    if (linuxUser && vendorInfo && vendorInfo.osUserIsolation === false) {
+      throw new Error((vendorInfo.displayName || targetVendor) + " is not available for OS-isolated users.");
+    }
+    var ownerId = ws._clayUser && ctx.usersModule.isMultiUser() ? ws._clayUser.id : null;
+    if ((source.ownerId || null) !== ownerId) throw new Error("Session access denied.");
+    return linuxUser;
+  }
+
+  function quietRecord(session, entry) {
+    session.history.push(entry);
+    sm.appendToSessionFile(session, entry);
+  }
+
+  function handoff(ws, msg) {
+    var source = sm.sessions.get(ws._clayActiveSession) || null;
+    var targetVendor = typeof msg.targetVendor === "string" ? msg.targetVendor.trim() : "";
+    var targetModel = typeof msg.model === "string" ? msg.model.trim() : "";
+    var linuxUser;
+    try {
+      linuxUser = validate(ws, source, targetVendor);
+    } catch (err) {
+      sendResult(ws, false, { error: err.message || String(err) });
+      return;
+    }
+
+    var targetEffort = yoke.clampEffort(
+      targetVendor,
+      msg.effort || (sm.currentEffortByVendor && sm.currentEffortByVendor[targetVendor]) || sm.currentEffort || "medium"
+    ) || null;
+    var target = sm.createSessionRaw({
+      ownerId: source.ownerId || null,
+      sessionVisibility: source.sessionVisibility || "shared",
+      vendor: targetVendor,
+      model: targetModel || null,
+      effort: targetEffort,
+    });
+    var targetName = (yoke.getVendorInfo(targetVendor) || {}).displayName || targetVendor;
+    target.title = (source.title || "Continued session") + " · " + targetName;
+    target.handoff = {
+      sourceSessionId: source.localId,
+      sourceVendor: source.vendor || sm.defaultVendor || "claude",
+      createdAt: Date.now(),
+      mode: "context",
+      sourceHistoryIndex: source.history.length,
+    };
+
+    var sourceEntry = {
+      type: "handoff_created",
+      targetSessionId: target.localId,
+      targetVendor: targetVendor,
+      targetTitle: target.title,
+      _ts: Date.now(),
+    };
+    var targetEntry = {
+      type: "handoff_context",
+      sourceSessionId: source.localId,
+      sourceVendor: target.handoff.sourceVendor,
+      sourceTitle: source.title || "Untitled session",
+      targetVendor: targetVendor,
+      request: contextBuilder.latestUserRequest(source.history),
+      _ts: Date.now(),
+    };
+    quietRecord(source, sourceEntry);
+    quietRecord(target, targetEntry);
+
+    var prompt = contextBuilder.buildHandoffContext({
+      cwd: ctx.cwd,
+      source: source,
+      targetVendor: targetVendor,
+    });
+    target.isProcessing = true;
+    target.lastActivity = Date.now();
+    target.sentToolResults = {};
+    sm.switchSession(target.localId, ws);
+    if (typeof ctx.onProcessingChanged === "function") ctx.onProcessingChanged();
+    sendResult(ws, true, {
+      sourceSessionId: source.localId,
+      targetSessionId: target.localId,
+      targetVendor: targetVendor,
+    });
+
+    var sdk = ctx.getSdk();
+    function failStart(err) {
+      target.isProcessing = false;
+      sm.sendAndRecord(target, { type: "error", text: "Could not start the handoff session: " + (err.message || String(err)) });
+      if (typeof ctx.onProcessingChanged === "function") ctx.onProcessingChanged();
+      sm.broadcastSessionList();
+    }
+    if (!sdk || typeof sdk.startQuery !== "function") {
+      failStart(new Error("SDK bridge is not ready."));
+      return;
+    }
+    target._queryStartTs = Date.now();
+    var startPromise;
+    try {
+      startPromise = sdk.startQuery(target, prompt, undefined, linuxUser);
+    } catch (err) {
+      failStart(err);
+      return;
+    }
+    Promise.resolve(startPromise).catch(failStart);
+  }
+
+  function handleMessage(ws, msg) {
+    if (msg.type === "handoff_session_options") {
+      ctx.sendTo(ws, {
+        type: "handoff_session_options",
+        installedVendors: sm.installedVendors || [],
+        modelsByVendor: sm.modelsByVendor || {},
+        capabilitiesByVendor: sm.capabilitiesByVendor || {},
+      });
+      return true;
+    }
+    if (msg.type === "handoff_session") {
+      handoff(ws, msg);
+      return true;
+    }
+    return false;
+  }
+
+  return { handleMessage: handleMessage };
+}
+
+module.exports = {
+  attachSessionHandoff: attachSessionHandoff,
+  hasUserContext: hasUserContext,
+};

package/lib/project-session-pair.js

@@ -98,10 +98,15 @@ function attachSessionPair(ctx) {
     token.delivered = true;
     var failure = token.failure || null;
     var response = token.response || "";
-    var text = "A Worker task delegated through send_to_partner has finished.\n\n" +
-      "Original task:\n" + token.message + "\n\n" +
-      (failure ? "Worker error:\n" + failure : "Worker result:\n" + (response || "(No text response was recorded.)")) +
-      "\n\nReview the result, verify it as needed, and continue the task.";
+    var text;
+    if (token.interrupted) {
+      text = "[Worker execution interrupted] The user interrupted the Worker mid-turn. Its work is PARTIAL and unverified — do not treat it as finished. Review what was done and decide next steps with the user.";
+    } else {
+      text = "A Worker task delegated through send_to_partner has finished.\n\n" +
+        "Original task:\n" + token.message + "\n\n" +
+        (failure ? "Worker error:\n" + failure : "Worker result:\n" + (response || "(No text response was recorded.)")) +
+        "\n\nReview the result, verify it as needed, and continue the task.";
+    }
     sm.sendAndRecord(caller, {
       type: "user_message",
       text: text,
@@ -146,6 +151,7 @@ function attachSessionPair(ctx) {
     }
     token.response = responseText(partner.history || [], token.startIndex);
     token.failure = errorSince(partner.history || [], token.startIndex);
+    token.interrupted = !token.failure && !!partner._lastTurnInterrupted;
     finishDelegation(group, caller, partner, token);
     return resumeDriverWithResult(caller, partner, token);
   }
@@ -165,8 +171,9 @@ function attachSessionPair(ctx) {
           clearInterval(timer);
           finishDelegation(group, caller, partner, token);
           var failure = errorSince(partner.history || [], token.startIndex);
+          var interrupted = !failure && !!partner._lastTurnInterrupted;
           resolve({
-            status: failure ? "error" : "complete",
+            status: failure ? "error" : (interrupted ? "interrupted" : "complete"),
             response: responseText(partner.history || [], token.startIndex),
             error: failure || undefined,
           });
@@ -260,7 +267,7 @@ function attachSessionPair(ctx) {
       var count = Number.isFinite(args.lastTurns) ? Math.floor(args.lastTurns) : 1;
       count = Math.max(1, Math.min(5, count));
       return toolResult({
-        status: resolved.partner.isProcessing ? "running" : "idle",
+        status: resolved.partner.isProcessing ? "running" : (resolved.partner._lastTurnInterrupted ? "interrupted" : "idle"),
         partnerId: resolved.partner.localId,
         title: resolved.partner.title || "New Session",
         turns: recentTurns(resolved.partner, count),
@@ -383,7 +390,7 @@ function attachSessionPair(ctx) {
     var group = store.groupForMember(session.localId);
     var pairPrompt = "";
     if (group && group.pair && group.pair.driverId === session.localId) {
-      pairPrompt = "You are the Driver in a two-agent pair. The tools send_to_partner and read_partner are provided directly to you. Use send_to_partner to delegate concrete bounded work to the Worker. A completed Worker turn leaves the Worker session available for more work. If review or user feedback requires corrections to the Worker's implementation, delegate a follow-up turn to that Worker instead of editing the Worker-owned files yourself. If send_to_partner reports that the Worker is no longer available, create a replacement with spawn_sessions and delegate the remaining implementation rather than taking it over. If a non-waiting delegation finishes later, Clay pushes the result back and resumes you automatically; use read_partner only when you need an interim status check. Integrate and verify the final outcome. Do not search the project for implementations of these tools, and do not delegate work that must be performed sequentially in this same session.";
+      pairPrompt = "You are the Driver in a two-agent pair. The tools send_to_partner and read_partner are provided directly to you. Use send_to_partner to delegate concrete bounded work to the Worker. A completed Worker turn leaves the Worker session available for more work. If a Worker turn is interrupted, its work is partial and unverified; review it and decide next steps with the user. If review or user feedback requires corrections to the Worker's implementation, delegate a follow-up turn to that Worker instead of editing the Worker-owned files yourself. If send_to_partner reports that the Worker is no longer available, create a replacement with spawn_sessions and delegate the remaining implementation rather than taking it over. If a non-waiting delegation finishes later, Clay pushes the result back and resumes you automatically; use read_partner only when you need an interim status check. Integrate and verify the final outcome. Do not search the project for implementations of these tools, and do not delegate work that must be performed sequentially in this same session.";
     }
     return [pairPrompt, workerProposal.getSystemPrompt(session)].filter(Boolean).join("\n\n");
   }

package/lib/project-session-spawn.js

@@ -319,7 +319,7 @@ function attachSessionSpawn(ctx) {
         statuses.push({
           localId: session.localId,
           title: session.title || "New Session",
-          status: session.isProcessing ? "running" : (hasSessionError(session) ? "error" : "done"),
+          status: session.isProcessing ? "running" : (session._lastTurnInterrupted ? "interrupted" : (hasSessionError(session) ? "error" : "done")),
           turnCount: session.turnCount || 0,
           lastActivity: session.lastActivity || session.createdAt || 0,
         });

package/lib/project-sessions.js

@@ -658,10 +658,6 @@ function attachSessions(ctx) {
           // (resume_tui_session), and born-GUI never auto-converts to a terminal.
           resolveSessionForView(xmTarget, ws);
         }
-        // If the target session's vendor doesn't own the currently cached
-        // model, clear sm.currentModel so the UI and next query don't leak
-        // the previous session's vendor-specific model into this one. A
-        // session-specific model always wins and survives daemon restarts.
         var switchTargetSess = sm.sessions.get(msg.id);
         var switchTargetVendor = switchTargetSess && (switchTargetSess.vendor || sm.defaultVendor || "claude");
         if (switchTargetSess && !switchTargetSess.effort) {
@@ -671,22 +667,6 @@ function attachSessions(ctx) {
           ) || null;
           sm.saveSessionFile(switchTargetSess);
         }
-        if (switchTargetSess && switchTargetSess.model) {
-          sm.currentModel = switchTargetSess.model;
-        } else if (switchTargetSess && sm.currentModel) {
-          var targetVendor = switchTargetSess.vendor || sm.defaultVendor || null;
-          var tvModels = (targetVendor && sm.modelsByVendor && sm.modelsByVendor[targetVendor]) || [];
-          var found = false;
-          var _curLc = sm.currentModel.toLowerCase();
-          for (var tvi = 0; tvi < tvModels.length; tvi++) {
-            var tvEntry = tvModels[tvi];
-            var tvVal = typeof tvEntry === "string" ? tvEntry : (tvEntry && (tvEntry.value || tvEntry.id)) || "";
-            if (tvVal === sm.currentModel || (tvVal && (tvVal.toLowerCase().indexOf(_curLc) !== -1 || _curLc.indexOf(tvVal.toLowerCase()) !== -1))) { found = true; break; }
-          }
-          if (tvModels.length > 0 && !found) {
-            sm.currentModel = "";
-          }
-        }
         // Check access in multi-user mode
         if (usersModule.isMultiUser() && ws._clayUser) {
           var switchTarget = sm.sessions.get(msg.id);
@@ -958,14 +938,6 @@ function attachSessions(ctx) {
       return true;
     }
 
-    if (msg.type === "set_model" && msg.model) {
-      var session = getSessionForWs(ws);
-      if (session) {
-        sdk.setModel(session, msg.model);
-      }
-      return true;
-    }
-
     if (msg.type === "reload_skills") {
       var session = getSessionForWs(ws);
       if (session && sdk.reloadSkills) {
@@ -997,11 +969,7 @@ function attachSessions(ctx) {
             " is bound to '" + vendorSession.vendor + "', refused rebind to '" + msg.vendor + "'");
         } else {
           vendorSession.vendor = msg.vendor;
-          // Clear the shared model so the next query uses the vendor's default
-          // instead of leaking the previous vendor's model into a fresh session.
-          if (sm.currentModel) {
-            sm.currentModel = "";
-          }
+          if (vendorSession.vendor !== msg.vendor) vendorSession.model = "";
           sm.saveSessionFile(vendorSession);
           sm.broadcastSessionList();
         }
@@ -1012,11 +980,11 @@ function attachSessions(ctx) {
           type: "model_info",
           model: "",
           models: vendorModels,
-          vendor: msg.vendor,
+          vendor: msg.vendor, sessionId: vendorSession ? vendorSession.localId : null,
           availableVendors: sm.availableVendors || [],
           installedVendors: sm.installedVendors || [],
         });
-        send({ type: "config_state", model: sm.currentModel || "", mode: sm.currentPermissionMode || "default", effort: sm.currentEffort || "medium", betas: sm.currentBetas || [], thinking: sm.currentThinking || "adaptive", thinkingBudget: sm.currentThinkingBudget || 10000 });
+        send({ type: "config_state", vendor: null, sessionId: null, mode: sm.currentPermissionMode || "default", effort: sm.currentEffort || "medium", betas: sm.currentBetas || [], thinking: sm.currentThinking || "adaptive", thinkingBudget: sm.currentThinkingBudget || 10000 });
       }
       return true;
     }
@@ -1052,7 +1020,7 @@ function attachSessions(ctx) {
         sm.broadcastSessionList();
         sdk.setPermissionMode(session, msg.mode);
       }
-      send({ type: "config_state", model: sm.currentModel || "", mode: sm.currentPermissionMode, effort: sm.currentEffort || "medium", betas: sm.currentBetas || [], thinking: sm.currentThinking || "adaptive", thinkingBudget: sm.currentThinkingBudget || 10000 });
+      send({ type: "config_state", vendor: null, sessionId: null, mode: sm.currentPermissionMode, effort: sm.currentEffort || "medium", betas: sm.currentBetas || [], thinking: sm.currentThinking || "adaptive", thinkingBudget: sm.currentThinkingBudget || 10000 });
       return true;
     }
 
@@ -1113,7 +1081,7 @@ function attachSessions(ctx) {
       if (session) {
         sdk.setPermissionMode(session, msg.mode);
       }
-      send({ type: "config_state", model: sm.currentModel || "", mode: sm.currentPermissionMode, effort: sm.currentEffort || "medium", betas: sm.currentBetas || [], thinking: sm.currentThinking || "adaptive", thinkingBudget: sm.currentThinkingBudget || 10000 });
+      send({ type: "config_state", vendor: null, sessionId: null, mode: sm.currentPermissionMode, effort: sm.currentEffort || "medium", betas: sm.currentBetas || [], thinking: sm.currentThinking || "adaptive", thinkingBudget: sm.currentThinkingBudget || 10000 });
       return true;
     }
 
@@ -1126,7 +1094,7 @@ function attachSessions(ctx) {
       if (session) {
         sdk.setPermissionMode(session, msg.mode);
       }
-      send({ type: "config_state", model: sm.currentModel || "", mode: sm.currentPermissionMode, effort: sm.currentEffort || "medium", betas: sm.currentBetas || [], thinking: sm.currentThinking || "adaptive", thinkingBudget: sm.currentThinkingBudget || 10000 });
+      send({ type: "config_state", vendor: null, sessionId: null, mode: sm.currentPermissionMode, effort: sm.currentEffort || "medium", betas: sm.currentBetas || [], thinking: sm.currentThinking || "adaptive", thinkingBudget: sm.currentThinkingBudget || 10000 });
       return true;
     }
 
@@ -1142,7 +1110,7 @@ function attachSessions(ctx) {
         sdk.setEffort(session, sessionEffort).catch(function (e) {
           sendTo(ws, { type: "error", text: "Failed to change reasoning effort: " + (e.message || e) });
         });
-        sm.sendToSession(session, { type: "config_state", model: session.model || sm.currentModel || "", mode: session.permissionMode || sm.currentPermissionMode || "default", effort: sessionEffort, betas: sm.currentBetas || [], thinking: sm.currentThinking || "adaptive", thinkingBudget: sm.currentThinkingBudget || 10000 });
+        sm.sendToSession(session, { type: "config_state", model: session.model || ((sm.defaultModelByVendor || {})[effortVendor]) || "", vendor: effortVendor, sessionId: session.localId, mode: session.permissionMode || sm.currentPermissionMode || "default", effort: sessionEffort, betas: sm.currentBetas || [], thinking: sm.currentThinking || "adaptive", thinkingBudget: sm.currentThinkingBudget || 10000 });
       }
       return true;
     }
@@ -1152,7 +1120,7 @@ function attachSessions(ctx) {
         opts.onSetServerDefaultEffort(msg.effort);
       }
       sm.currentEffort = msg.effort;
-      send({ type: "config_state", model: sm.currentModel || "", mode: sm.currentPermissionMode || "default", effort: sm.currentEffort, betas: sm.currentBetas || [], thinking: sm.currentThinking || "adaptive", thinkingBudget: sm.currentThinkingBudget || 10000 });
+      send({ type: "config_state", vendor: null, sessionId: null, mode: sm.currentPermissionMode || "default", effort: sm.currentEffort, betas: sm.currentBetas || [], thinking: sm.currentThinking || "adaptive", thinkingBudget: sm.currentThinkingBudget || 10000 });
       return true;
     }
 
@@ -1161,20 +1129,20 @@ function attachSessions(ctx) {
         opts.onSetProjectDefaultEffort(slug, msg.effort);
       }
       sm.currentEffort = msg.effort;
-      send({ type: "config_state", model: sm.currentModel || "", mode: sm.currentPermissionMode || "default", effort: sm.currentEffort, betas: sm.currentBetas || [], thinking: sm.currentThinking || "adaptive", thinkingBudget: sm.currentThinkingBudget || 10000 });
+      send({ type: "config_state", vendor: null, sessionId: null, mode: sm.currentPermissionMode || "default", effort: sm.currentEffort, betas: sm.currentBetas || [], thinking: sm.currentThinking || "adaptive", thinkingBudget: sm.currentThinkingBudget || 10000 });
       return true;
     }
 
     if (msg.type === "set_betas") {
       sm.currentBetas = msg.betas || [];
-      send({ type: "config_state", model: sm.currentModel || "", mode: sm.currentPermissionMode || "default", effort: sm.currentEffort || "medium", betas: sm.currentBetas, thinking: sm.currentThinking || "adaptive", thinkingBudget: sm.currentThinkingBudget || 10000 });
+      send({ type: "config_state", vendor: null, sessionId: null, mode: sm.currentPermissionMode || "default", effort: sm.currentEffort || "medium", betas: sm.currentBetas, thinking: sm.currentThinking || "adaptive", thinkingBudget: sm.currentThinkingBudget || 10000 });
       return true;
     }
 
     if (msg.type === "set_thinking") {
       sm.currentThinking = msg.thinking || "adaptive";
       if (msg.budgetTokens) sm.currentThinkingBudget = msg.budgetTokens;
-      send({ type: "config_state", model: sm.currentModel || "", mode: sm.currentPermissionMode || "default", effort: sm.currentEffort || "medium", betas: sm.currentBetas || [], thinking: sm.currentThinking || "adaptive", thinkingBudget: sm.currentThinkingBudget || 10000 });
+      send({ type: "config_state", vendor: null, sessionId: null, mode: sm.currentPermissionMode || "default", effort: sm.currentEffort || "medium", betas: sm.currentBetas || [], thinking: sm.currentThinking || "adaptive", thinkingBudget: sm.currentThinkingBudget || 10000 });
       return true;
     }
 
@@ -1456,7 +1424,7 @@ function attachSessions(ctx) {
       if (decision === "allow_accept_edits") {
         sdk.setPermissionMode(session, "acceptEdits");
         sm.currentPermissionMode = "acceptEdits";
-        send({ type: "config_state", model: sm.currentModel || "", mode: sm.currentPermissionMode, effort: sm.currentEffort || "medium", betas: sm.currentBetas || [], thinking: sm.currentThinking || "adaptive", thinkingBudget: sm.currentThinkingBudget || 10000 });
+        send({ type: "config_state", vendor: null, sessionId: null, mode: sm.currentPermissionMode, effort: sm.currentEffort || "medium", betas: sm.currentBetas || [], thinking: sm.currentThinking || "adaptive", thinkingBudget: sm.currentThinkingBudget || 10000 });
         pending.resolve({ behavior: "allow", updatedInput: pending.toolInput });
         sm.sendAndRecord(session, { type: "permission_resolved", requestId: requestId, decision: decision });
         return true;
@@ -1485,7 +1453,7 @@ function attachSessions(ctx) {
 
         // Update permission mode for the new session
         sm.currentPermissionMode = "acceptEdits";
-        send({ type: "config_state", model: sm.currentModel || "", mode: sm.currentPermissionMode, effort: sm.currentEffort || "medium", betas: sm.currentBetas || [], thinking: sm.currentThinking || "adaptive", thinkingBudget: sm.currentThinkingBudget || 10000 });
+        send({ type: "config_state", vendor: null, sessionId: null, mode: sm.currentPermissionMode, effort: sm.currentEffort || "medium", betas: sm.currentBetas || [], thinking: sm.currentThinking || "adaptive", thinkingBudget: sm.currentThinkingBudget || 10000 });
 
         // Build prompt from plan content (sent from client) or plan file path
         var clientPlanContent = msg.planContent || "";

package/lib/project-worker-proposal.js

@@ -40,7 +40,7 @@ function attachWorkerProposal(ctx) {
   function isEligible(session) {
     if (ctx.isMate || !session || session.mode === "tui") return false;
     if (store.groupForMember(session.localId)) return false;
-    return isFableSession(session, sm.modelsByVendor, sm.currentModel);
+    return isFableSession(session, sm.modelsByVendor, (sm.defaultModelByVendor || {})[session.vendor || "claude"]);
   }
 
   function safeModelsByVendor(installed) {
@@ -112,7 +112,7 @@ function attachWorkerProposal(ctx) {
     }
     var models = options.modelsByVendor[vendor] || [];
     var model = modelIsAvailable(options, vendor, args.recommendedModel) ? (args.recommendedModel || "") : "";
-    var currentModel = session.model || sm.currentModel || "";
+    var currentModel = session.model || (sm.defaultModelByVendor || {})[session.vendor || "claude"] || "";
     if (vendor === session.vendor && model === currentModel) model = "";
     if (!model && models.length > 0) {
       for (var j = 0; j < models.length; j++) {
@@ -154,6 +154,18 @@ function attachWorkerProposal(ctx) {
     }, patch));
   }
 
+  function skipPermissionsEnabled(session) {
+    return !!session && (session.permissionMode === "bypassPermissions" || session.dangerouslySkipPermissions === true);
+  }
+
+  function autoApprovalWs(session) {
+    return {
+      _clayActiveSession: session.localId,
+      _clayUser: session.ownerId ? { id: session.ownerId } : null,
+      _autoApproval: true,
+    };
+  }
+
   async function propose(args, session) {
     if (!isEligible(session)) return toolResult({ error: "Worker suggestions are only available in an unpaired Fable session." });
     if (hasPendingProposal(session)) return toolResult({ error: "A Worker suggestion is already awaiting a decision." });
@@ -166,6 +178,7 @@ function attachWorkerProposal(ctx) {
     var options = proposalOptions();
     if (options.installedVendors.length === 0) return toolResult({ error: "No coding agent is installed for a Worker session." });
     var recommendation = chooseRecommendation(args, session, options);
+    var autoApprove = skipPermissionsEnabled(session);
     var proposal = {
       type: "worker_proposal",
       proposalId: "worker_" + crypto.randomUUID(),
@@ -178,7 +191,22 @@ function attachWorkerProposal(ctx) {
       recommendedEffort: recommendation.effort,
       options: options,
     };
+    if (autoApprove) proposal.autoApproved = true;
     sm.sendAndRecord(session, proposal);
+    if (autoApprove) {
+      var accepted = await acceptProposal(session, proposal, {
+        vendor: recommendation.vendor,
+        model: recommendation.model,
+        effort: recommendation.effort,
+        autoApproved: true,
+      }, autoApprovalWs(session));
+      if (!accepted.ok) return toolResult({ error: accepted.error || "Could not start the Worker." });
+      return toolResult({
+        status: "running",
+        proposalId: proposal.proposalId,
+        instruction: "The Worker was auto-approved and started because skip permissions is enabled. Its result will return for review.",
+      });
+    }
     return toolResult({
       status: "posted",
       proposalId: proposal.proposalId,
@@ -220,6 +248,8 @@ function attachWorkerProposal(ctx) {
     var followup;
     if (result.status === "complete") {
       followup = "[Worker execution completed]\nReview and verify the Worker's result. The Worker session remains available: if the implementation needs corrections or additional edits, send a follow-up with send_to_partner instead of taking over the Worker-owned files yourself. If that Worker is no longer available, create a replacement with spawn_sessions for the remaining implementation.\n\n" + (result.response || "The Worker completed without a text summary.");
+    } else if (result.status === "interrupted") {
+      followup = "[Worker execution interrupted]\nThe user interrupted the Worker mid-turn. Its work is PARTIAL and unverified — do not treat it as finished. Review what was done and decide next steps with the user.";
     } else if (result.status === "running") {
       followup = "[Worker execution is still running]\nUse read_partner to inspect progress before completing the task.";
     } else {
@@ -238,30 +268,24 @@ function attachWorkerProposal(ctx) {
     return session;
   }
 
-  async function respondToProposal(ws, msg) {
-    var session = sessionForResponse(ws);
-    var proposal = findProposal(session, msg.proposalId);
-    if (!proposal) throw new Error("Worker suggestion not found");
-    if (proposal.status !== "pending") throw new Error("Worker suggestion has already been resolved");
-    if (!msg.accepted) {
-      updateProposal(session, proposal, { status: "declined" });
-      await resumeDriver(session, "[Worker suggestion declined]\nContinue this task in the current session using the plan you already prepared.");
-      return { ok: true, status: "declined" };
-    }
+  async function acceptProposal(session, proposal, msg, ws) {
     var options = proposal.options || proposalOptions();
     var vendor = msg.vendor || proposal.recommendedVendor;
     var model = msg.model || "";
     if (options.installedVendors.indexOf(vendor) === -1) throw new Error("Selected Worker vendor is not installed");
     if (!modelIsAvailable(options, vendor, model)) throw new Error("Selected Worker model is unavailable");
     var effort = yoke.clampEffort(vendor, msg.effort || proposal.recommendedEffort || "medium") || "";
-    updateProposal(session, proposal, { status: "starting", selectedVendor: vendor, selectedModel: model, selectedEffort: effort });
+    var startingPatch = { status: "starting", selectedVendor: vendor, selectedModel: model, selectedEffort: effort };
+    if (msg.autoApproved) startingPatch.autoApproved = true;
+    updateProposal(session, proposal, startingPatch);
     try {
       var created = ctx.createPairRecord(ws, {
         driver: { sessionId: session.localId },
         worker: { vendor: vendor, model: model, effort: effort },
       });
       updateProposal(session, proposal, { status: "running", groupId: created.group.id, workerId: created.worker.localId });
-      ctx.sendTo(ws, { type: "pair_session_created", ok: true, group: created.group });
+      if (ws._autoApproval) sm.sendToSession(session, { type: "pair_session_created", ok: true, group: created.group });
+      else ctx.sendTo(ws, { type: "pair_session_created", ok: true, group: created.group });
       runWorker(session, proposal).catch(function (err) {
         updateProposal(session, proposal, { status: "error", error: err.message || String(err) });
         resumeDriver(session, "[Worker execution failed]\n" + (err.message || String(err))).catch(function () {});
@@ -273,6 +297,19 @@ function attachWorkerProposal(ctx) {
     }
   }
 
+  async function respondToProposal(ws, msg) {
+    var session = sessionForResponse(ws);
+    var proposal = findProposal(session, msg.proposalId);
+    if (!proposal) throw new Error("Worker suggestion not found");
+    if (proposal.status !== "pending") throw new Error("Worker suggestion has already been resolved");
+    if (!msg.accepted) {
+      updateProposal(session, proposal, { status: "declined" });
+      await resumeDriver(session, "[Worker suggestion declined]\nContinue this task in the current session using the plan you already prepared.");
+      return { ok: true, status: "declined" };
+    }
+    return acceptProposal(session, proposal, msg, ws);
+  }
+
   function handleMessage(ws, msg) {
     if (msg.type !== "worker_proposal_response") return false;
     respondToProposal(ws, msg).catch(function (err) {