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

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-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,
@@ -238,30 +266,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 +295,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) {

package/lib/project.js

@@ -27,6 +27,7 @@ var { attachImage } = require("./project-image");
 var { attachKnowledge } = require("./project-knowledge");
 var { attachFilesystem } = require("./project-filesystem");
 var { attachSessions } = require("./project-sessions");
+var { attachModels } = require("./project-models");
 var { attachUserMessage } = require("./project-user-message");
 var { attachShellCommand } = require("./project-shell-command");
 var { attachConnection } = require("./project-connection");
@@ -35,6 +36,7 @@ var { createLocalMcp } = require("./mcp-local");
 var { attachEmail: attachEmailModule } = require("./project-email");
 var { attachSessionSpawn } = require("./project-session-spawn");
 var { attachSessionPair } = require("./project-session-pair");
+var { attachSessionHandoff } = require("./project-session-handoff");
 var { attachSessionNotes, composeSystemPrompts } = require("./project-session-notes");
 var { attachSessionDocument } = require("./project-session-document");
 var { attachSplitGroups } = require("./session-split-groups");
@@ -163,7 +165,7 @@ function createProjectContext(opts) {
   var updateChannel = opts.updateChannel || "stable";
   var osUsers = opts.osUsers || false;
   var projectOwnerId = opts.projectOwnerId || null;
-  var worktreeMeta = opts.worktreeMeta || null; // { parentSlug, branch, accessible }
+  var worktreeMeta = opts.worktreeMeta || null; // { parentSlug, branch, external }
   var isMate = opts.isMate || false;
   var onCreateWorktree = opts.onCreateWorktree || null;
   var serverPort = opts.port || 2633;
@@ -470,10 +472,9 @@ function createProjectContext(opts) {
 
   var _projModel = typeof opts.onGetProjectDefaultModel === "function" ? opts.onGetProjectDefaultModel(slug) : null;
   var _srvModel = typeof opts.onGetServerDefaultModel === "function" ? opts.onGetServerDefaultModel() : null;
-  sm._savedDefaultModel = (_projModel && _projModel.model) || (_srvModel && _srvModel.model) || null;
-  // Immediately apply the saved default so config_state on connect reflects it
-  // before the SDK has warmed up and fired system/init.
-  if (sm._savedDefaultModel) sm.currentModel = sm._savedDefaultModel;
+  var savedDefaultModel = (_projModel && _projModel.model) || (_srvModel && _srvModel.model) || null;
+  sm.defaultModelByVendor = sm.defaultModelByVendor || {};
+  if (savedDefaultModel) sm.defaultModelByVendor[sm.defaultVendor || "claude"] = savedDefaultModel;
 
   // --- Local MCP (direct process management for localhost clients) ---
   var _localMcp = createLocalMcp();
@@ -569,6 +570,18 @@ function createProjectContext(opts) {
     getLinuxUserForSession: getLinuxUserForSession,
     getPairToolDefs: function (boundSession) { return _sessionPair.getToolDefs(boundSession); },
   });
+  var _sessionHandoff = attachSessionHandoff({
+    cwd: cwd,
+    sm: sm,
+    isMate: isMate,
+    splitStore: _splitGroups.store,
+    getSdk: function () { return sdk; },
+    sendTo: sendTo,
+    usersModule: usersModule,
+    adapters: adapters,
+    getLinuxUserForSession: getLinuxUserForSession,
+    onProcessingChanged: onProcessingChanged,
+  });
   var _debate = null;
   var _debateProposal = attachDebateProposal({
     cwd: cwd,
@@ -835,6 +848,7 @@ function createProjectContext(opts) {
     getNotificationsModule: function () { return _notifications; },
     mateDisplayName: opts.mateDisplayName || "",
     isMate: isMate,
+    osUsers: osUsers,
     dangerouslySkipPermissions: dangerouslySkipPermissions,
     mcpServers: getLocalMcpServers,
     getRemoteMcpServers: function () { return _mcp.getMcpServers(); },
@@ -1052,78 +1066,6 @@ function createProjectContext(opts) {
       return;
     }
 
-    // --- Vendor model switching ---
-    if (msg.type === "get_vendor_models") {
-      (async function() {
-        if (msg.vendor) {
-          try {
-            var modelLinuxUser = getLinuxUserForWs(ws);
-            var vendorAdapter = adapters[msg.vendor] || null;
-            if (!vendorAdapter) {
-              vendorAdapter = await yoke.lazyCreateAdapter(adapters, msg.vendor, {
-                cwd: cwd,
-                linuxUser: modelLinuxUser || undefined,
-                clayPort: serverPort,
-                clayTls: serverTls,
-                clayAuthToken: serverAuthToken,
-                slug: slug,
-              });
-            }
-            var needsReadyMetadata = !sm.capabilitiesByVendor || !sm.capabilitiesByVendor[msg.vendor]
-              || !sm.modelsByVendor || !sm.modelsByVendor[msg.vendor];
-            if (vendorAdapter && needsReadyMetadata && typeof vendorAdapter.init === "function") {
-              // Init warms the adapter, but a slow/failed init must not block
-              // model listing (e.g. Codex models are a fixed list). Keep going
-              // to supportedModels() even if init throws.
-              try {
-                var readyResult = await vendorAdapter.init({
-                  cwd: cwd,
-                  clayPort: serverPort,
-                  clayTls: serverTls,
-                  clayAuthToken: serverAuthToken,
-                  slug: slug,
-                });
-                sm.capabilitiesByVendor = sm.capabilitiesByVendor || {};
-                sm.capabilitiesByVendor[msg.vendor] = readyResult.capabilities || {};
-                sm.modelsByVendor = sm.modelsByVendor || {};
-                if (Array.isArray(readyResult.models)) sm.modelsByVendor[msg.vendor] = readyResult.models;
-              } catch (e) {
-                console.error("[project] " + msg.vendor + " init failed (continuing to model list):", e.message || e);
-              }
-            }
-            if (vendorAdapter) {
-              sm.availableVendors = Object.keys(adapters);
-              sm.modelsByVendor = sm.modelsByVendor || {};
-              if (!sm.modelsByVendor[msg.vendor] && typeof vendorAdapter.supportedModels === "function") {
-                sm.modelsByVendor[msg.vendor] = await vendorAdapter.supportedModels();
-              }
-            }
-          } catch (e) {
-            console.error("[project] get_vendor_models lazy init failed for " + msg.vendor + ":", e.message || e);
-          }
-        }
-        var vendorModels = (sm.modelsByVendor && sm.modelsByVendor[msg.vendor]) || [];
-        var firstModel = vendorModels[0] || "";
-        // model value can be string or {value, displayName} object
-        var defaultModel = typeof firstModel === "string" ? firstModel : (firstModel.value || "");
-        // Preserve the user's current model selection if it belongs to this
-        // vendor, rather than always snapping back to the vendor's default.
-        var modelToSend = defaultModel;
-        if (sm.currentModel) {
-          for (var mi = 0; mi < vendorModels.length; mi++) {
-            var mv = typeof vendorModels[mi] === "string" ? vendorModels[mi] : (vendorModels[mi].value || "");
-            if (mv === sm.currentModel) {
-              modelToSend = sm.currentModel;
-              break;
-            }
-          }
-        }
-        var vendorCapabilities = (sm.capabilitiesByVendor && sm.capabilitiesByVendor[msg.vendor]) || {};
-        sendTo(ws, { type: "model_info", model: modelToSend, models: vendorModels, vendor: msg.vendor, capabilities: vendorCapabilities, availableVendors: sm.availableVendors || [], installedVendors: sm.installedVendors || [] });
-      })();
-      return;
-    }
-
     // --- Debate ---
     if (msg.type === "debate_start") {
       handleDebateStart(ws, msg);
@@ -1171,7 +1113,9 @@ function createProjectContext(opts) {
 
     // --- Sessions, config, project mgmt (delegated to project-sessions.js) ---
     if (_sessionPair.handleMessage(ws, msg)) return;
+    if (_sessionHandoff.handleMessage(ws, msg)) return;
     if (_splitGroups.handleMessage(ws, msg)) return;
+    if (_models.handleMessage(ws, msg)) return;
     if (_sessions.handleSessionsMessage(ws, msg)) return;
 
     // --- Filesystem, settings, env (delegated to project-filesystem.js) ---
@@ -1384,6 +1328,20 @@ function createProjectContext(opts) {
     _notifications: _notifications,
   });
 
+  var _models = attachModels({
+    cwd: cwd,
+    slug: slug,
+    sm: sm,
+    sdk: sdk,
+    adapters: adapters,
+    sendTo: sendTo,
+    getSessionForWs: getSessionForWs,
+    getLinuxUserForWs: getLinuxUserForWs,
+    serverPort: serverPort,
+    serverTls: serverTls,
+    serverAuthToken: serverAuthToken,
+  });
+
   // --- User message handler (delegated to project-user-message.js) ---
   var _userMessage = attachUserMessage({
     cwd: cwd,
@@ -1686,8 +1644,8 @@ function createProjectContext(opts) {
     getProject: function () { return project; },
     // Exposed so the first websocket connection can lazily warm up the
     // adapters for this project (see project-connection handleConnection).
-    warmup: function () {
-      sdk.warmup();
+    warmup: function (linuxUser) {
+      sdk.warmup(osUsers ? linuxUser : null);
       sdk.startIdleReaper();
       if (!osUsers && !sessionTitleMigrationScheduled) {
         sessionTitleMigrationScheduled = true;
@@ -1813,7 +1771,7 @@ function createProjectContext(opts) {
       status.isWorktree = true;
       status.parentSlug = worktreeMeta.parentSlug;
       status.branch = worktreeMeta.branch;
-      status.worktreeAccessible = worktreeMeta.accessible;
+      status.worktreeExternal = worktreeMeta.external === true;
     }
     if (usersModule.isMultiUser()) {
       var seen = {};