clay-server 2.47.0-beta.6 → 3.0.0-beta.2

package/lib/public/style.css

@@ -1,6 +1,7 @@
 @import url("css/base.css");
 @import url("css/icon-strip.css");
 @import url("css/title-bar.css");
+@import url("css/pane.css");
 @import url("css/sidebar.css");
 @import url("css/overlays.css");
 @import url("css/menus.css");

package/lib/sdk-bridge.js

@@ -596,7 +596,8 @@ function createSDKBridge(opts) {
   function handleCanUseTool(session, toolName, input, opts) {
     // Full-auto mode: auto-approve everything except AskUserQuestion
     // (which still needs to go through the user interaction flow).
-    if (sm.currentPermissionMode === "bypassPermissions" && toolName !== "AskUserQuestion") {
+    var clayPermissionMode = session.permissionMode || sm.currentPermissionMode;
+    if (clayPermissionMode === "bypassPermissions" && toolName !== "AskUserQuestion") {
       return Promise.resolve({ behavior: "allow", updatedInput: input });
     }
 
@@ -780,17 +781,21 @@ function createSDKBridge(opts) {
               sendToSession(session, { type: "context_usage", data: metaData.data });
               break;
             case "model_changed":
+              session.model = metaData.model;
+              sm.saveSessionFile(session);
               sm.currentModel = metaData.model;
               sendModelInfoForVendor(session.vendor || (adapter && adapter.vendor) || "claude", metaData.model);
-              send({ type: "config_state", model: sm.currentModel, mode: sm.currentPermissionMode || "default", effort: sm.currentEffort || "medium", betas: sm.currentBetas || [] });
+              sendToSession(session, { type: "config_state", model: session.model || sm.currentModel, mode: session.permissionMode || sm.currentPermissionMode || "default", effort: session.effort || sm.currentEffort || "medium", betas: sm.currentBetas || [] });
               break;
             case "effort_changed":
+              session.effort = metaData.effort;
+              sm.saveSessionFile(session);
               sm.currentEffort = metaData.effort;
-              send({ type: "config_state", model: sm.currentModel || "", mode: sm.currentPermissionMode || "default", effort: sm.currentEffort, betas: sm.currentBetas || [] });
+              sendToSession(session, { type: "config_state", model: session.model || sm.currentModel || "", mode: session.permissionMode || sm.currentPermissionMode || "default", effort: session.effort, betas: sm.currentBetas || [] });
               break;
             case "permission_mode_changed":
               sm.currentPermissionMode = metaData.mode;
-              send({ type: "config_state", model: sm.currentModel || "", mode: sm.currentPermissionMode, effort: sm.currentEffort || "medium", betas: sm.currentBetas || [] });
+              sendToSession(session, { type: "config_state", model: session.model || sm.currentModel || "", mode: session.permissionMode || sm.currentPermissionMode, effort: session.effort || sm.currentEffort || "medium", betas: sm.currentBetas || [] });
               break;
             case "worker_error":
               send({ type: "error", text: metaData.error });
@@ -1076,7 +1081,24 @@ function createSDKBridge(opts) {
     return { sessionId: result.sessionId, useLocalHistory: false };
   }
 
+  // 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) {
+    session._queryStarting = true;
+    try {
+      return await startQueryInner(session, text, images, linuxUser);
+    } 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 = [];
+      }
+    }
+  }
+
+  async function startQueryInner(session, text, images, linuxUser) {
     async function ensureVendorReady(vendor) {
       if (!vendor) return null;
       if (linuxUser && !supportsOsUserIsolation(vendor)) return null;
@@ -1260,6 +1282,13 @@ function createSDKBridge(opts) {
     } else if (thinkingMode === "budget") {
       var budgetTokens = ls.thinkingBudget || sm.currentThinkingBudget;
       if (budgetTokens) claudeOpts.thinking = { type: "enabled", budgetTokens: budgetTokens };
+    } else {
+      // Adaptive (the default). Request summarized display explicitly:
+      // current models default thinking.display to "omitted", which streams
+      // thinking blocks whose text is an EMPTY string -- the UI's thinking
+      // section stays blank even though thinking happens and is billed.
+      // (SDK ThinkingAdaptive: { type: "adaptive", display?: "summarized" | "omitted" })
+      claudeOpts.thinking = { type: "adaptive", display: "summarized" };
     }
 
     if (ls.permissionMode) {
@@ -1271,13 +1300,16 @@ function createSDKBridge(opts) {
       claudeOpts.settings = Object.assign({}, claudeOpts.settings || {}, { disableAllHooks: ls.disableAllHooks });
     }
 
-    if (dangerouslySkipPermissions) {
+    if (dangerouslySkipPermissions || (session.mode === "tui" && session.dangerouslySkipPermissions)) {
       claudeOpts.allowDangerouslySkipPermissions = true;
       claudeOpts.permissionMode = "bypassPermissions";
     } else {
-      var globalMode = sm.currentPermissionMode || "default";
+      var globalMode = session.permissionMode || sm.currentPermissionMode || "default";
       var effectiveDefault;
-      if (globalMode === "bypassPermissions") effectiveDefault = "bypassPermissions";
+      // GUI full access stays inside Clay's canUseTool callback. Passing the
+      // SDK bypass mode would require its process-level dangerous escape hatch
+      // and would skip Clay's permission policy entirely.
+      if (globalMode === "bypassPermissions") effectiveDefault = "default";
       else if (session.acceptEditsAfterStart) effectiveDefault = "acceptEdits";
       else effectiveDefault = globalMode;
       var modeToApply = session._loopPermissionMode || effectiveDefault;
@@ -1315,7 +1347,7 @@ function createSDKBridge(opts) {
     // Claude would reject the unknown model. We validate against the
     // session vendor's model list regardless of which vendor happens to be
     // the project's default adapter.
-    var queryModel = (ls.model && ls.model !== "default" ? ls.model : null) || sm.currentModel || undefined;
+    var queryModel = (ls.model && ls.model !== "default" ? ls.model : null) || session.model || sm.currentModel || undefined;
     var sessionVendor = session.vendor || (adapter && adapter.vendor) || null;
     if (sessionVendor) {
       var vendorModels = (sm.modelsByVendor && sm.modelsByVendor[sessionVendor]) || [];
@@ -1330,6 +1362,14 @@ function createSDKBridge(opts) {
       queryModel = modelEntryValue(queryModel) || undefined;
     }
 
+    // Bind the resolved model to the session so it survives a daemon
+    // restart. Without this, a session started under sm.currentModel (an
+    // in-memory value) came back after restart on the adapter default.
+    if (queryModel && session.model !== queryModel) {
+      session.model = queryModel;
+      sm.saveSessionFile(session);
+    }
+
     var codexConfig = getCodexConfig(sm);
     var kiroConfig = getKiroConfig(sm);
     var mergedMcpServers = mergeMcpServers(getMcpServers(session), getRemoteMcpServers) || undefined;
@@ -1356,8 +1396,23 @@ function createSDKBridge(opts) {
 
     var queryOpts = {
       cwd: cwd,
+      // appendSystemPrompt, NOT systemPrompt: a plain-string systemPrompt
+      // REPLACES the entire Claude Code system prompt (sdk.d.ts:2096), which
+      // would strip the driver session down to the two-sentence pair preset.
+      // Adapters map this to their additive mechanism (claude: preset+append,
+      // codex/kiro: prepend to the first message).
+      appendSystemPrompt: typeof opts.getSessionSystemPrompt === "function" ? (opts.getSessionSystemPrompt(session) || undefined) : undefined,
       model: queryModel,
-      effort: ls.effort || sm.currentEffort || undefined,
+      // Effort is remembered per vendor and clamped to the session vendor's
+      // supported levels: a global value would leak codex "minimal" into
+      // Claude queries (and Claude "max" into codex) after vendor switches.
+      effort: yoke.clampEffort(
+        session.vendor || sm.defaultVendor || "claude",
+        ls.effort
+          || session.effort
+          || (sm.currentEffortByVendor && sm.currentEffortByVendor[session.vendor || sm.defaultVendor || "claude"])
+          || sm.currentEffort
+      ) || undefined,
       title: initialTitle || undefined,
       toolServers: mergedMcpServers,
       toolServerDescriptors: extractMcpDescriptors(mergedMcpServers) || undefined,
@@ -1455,6 +1510,18 @@ function createSDKBridge(opts) {
     handle.pushMessage(text, images);
     console.log("[sdk-bridge] pushMessage done, starting processQueryStream...");
 
+    // Flush messages that arrived while createQuery was still awaiting
+    // (pushMessage buffers them during the boot window). Synchronous with
+    // the handle assignment above, so ordering vs new pushes is safe.
+    if (session.pendingPush && session.pendingPush.length) {
+      var backlog = session.pendingPush;
+      session.pendingPush = [];
+      console.log("[sdk-bridge] flushing " + backlog.length + " buffered message(s) into new query");
+      for (var bi = 0; bi < backlog.length; bi++) {
+        handle.pushMessage(backlog[bi].text, backlog[bi].images);
+      }
+    }
+
     // For single-turn sessions (Ralph Loop), end the message queue so the SDK
     // query finishes after processing the one message. Without this, the query
     // stream stays open forever waiting for more messages, and onQueryComplete
@@ -1468,12 +1535,25 @@ function createSDKBridge(opts) {
     });
   }
 
+  // Returns true when the message has a consumer (delivered to a live
+  // handle, or buffered for the query currently booting). Returns false
+  // when there is nothing to deliver to -- callers must fall back to
+  // startQuery instead of assuming delivery. The old void version silently
+  // 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) {
     session.lastActivityAt = Date.now();
     // Route through QueryHandle (works for both in-process and worker paths)
     if (session.queryInstance && typeof session.queryInstance.pushMessage === "function") {
       session.queryInstance.pushMessage(text, images);
+      return true;
+    }
+    if (session._queryStarting) {
+      session.pendingPush = session.pendingPush || [];
+      session.pendingPush.push({ text: text, images: images || null });
+      return true;
     }
+    return false;
   }
 
   function permissionPushTitle(toolName, input) {
@@ -1652,51 +1732,62 @@ function createSDKBridge(opts) {
     }
     if (!session.queryInstance) {
       // No active query — just store the model for next startQuery
+      session.model = model;
+      sm.saveSessionFile(session);
       sm.currentModel = model;
       // Don't send vendor here: session vendor not yet bound, let client keep its selection
       sendModelInfoForVendor(null, model);
-      send({ type: "config_state", model: sm.currentModel, mode: sm.currentPermissionMode || "default", effort: sm.currentEffort || "medium", betas: sm.currentBetas || [] });
+      sendToSession(session, { type: "config_state", model: sm.currentModel, mode: session.permissionMode || sm.currentPermissionMode || "default", effort: session.effort || sm.currentEffort || "medium", betas: sm.currentBetas || [] });
       return;
     }
     try {
       await session.queryInstance.setModel(model);
+      session.model = model;
+      sm.saveSessionFile(session);
       sm.currentModel = model;
       var sessionVendor = session.vendor || (adapter && adapter.vendor) || "claude";
       sendModelInfoForVendor(sessionVendor, model);
-      send({ type: "config_state", model: sm.currentModel, mode: sm.currentPermissionMode || "default", effort: sm.currentEffort || "medium", betas: sm.currentBetas || [] });
+      sendToSession(session, { type: "config_state", model: sm.currentModel, mode: session.permissionMode || sm.currentPermissionMode || "default", effort: session.effort || sm.currentEffort || "medium", betas: sm.currentBetas || [] });
     } catch (e) {
       send({ type: "error", text: "Failed to switch model: " + (e.message || e) });
     }
   }
 
   async function setEffort(session, effort) {
+    // 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.
+    var effortVendor = session.vendor || sm.defaultVendor || "claude";
+    var clamped = yoke.clampEffort(effortVendor, effort) || effort;
+    sm.currentEffortByVendor = sm.currentEffortByVendor || {};
+    sm.currentEffortByVendor[effortVendor] = clamped;
+    session.effort = clamped;
+    sm.saveSessionFile(session);
+    sm.currentEffort = clamped;
     if (!session.queryInstance) {
-      sm.currentEffort = effort;
-      send({ type: "config_state", model: sm.currentModel || "", mode: sm.currentPermissionMode || "default", effort: sm.currentEffort, betas: sm.currentBetas || [] });
-      return;
+      return clamped;
     }
     // Route through QueryHandle (works for both in-process and worker paths)
     if (typeof session.queryInstance.setEffort === "function") {
-      await session.queryInstance.setEffort(effort);
+      await session.queryInstance.setEffort(clamped);
     }
-    sm.currentEffort = effort;
-    send({ type: "config_state", model: sm.currentModel || "", mode: sm.currentPermissionMode || "default", effort: sm.currentEffort, betas: sm.currentBetas || [] });
+    return clamped;
   }
 
   async function setPermissionMode(session, mode) {
     if (!session.queryInstance) {
       // No active query — just store the mode for next startQuery
       sm.currentPermissionMode = mode;
-      send({ type: "config_state", model: sm.currentModel || "", mode: sm.currentPermissionMode, effort: sm.currentEffort || "medium", betas: sm.currentBetas || [] });
+      sendToSession(session, { type: "config_state", model: session.model || sm.currentModel || "", mode: sm.currentPermissionMode, effort: session.effort || sm.currentEffort || "medium", betas: sm.currentBetas || [] });
       return;
     }
     try {
       // Route through QueryHandle (works for both in-process and worker paths)
       await session.queryInstance.setPermissionMode(mode);
       sm.currentPermissionMode = mode;
-      send({ type: "config_state", model: sm.currentModel || "", mode: sm.currentPermissionMode, effort: sm.currentEffort || "medium", betas: sm.currentBetas || [] });
+      sendToSession(session, { type: "config_state", model: session.model || sm.currentModel || "", mode: sm.currentPermissionMode, effort: session.effort || sm.currentEffort || "medium", betas: sm.currentBetas || [] });
     } catch (e) {
-      send({ type: "error", text: "Failed to set permission mode: " + (e.message || e) });
+      sendToSession(session, { type: "error", text: "Failed to set permission mode: " + (e.message || e) });
     }
   }
 

package/lib/sdk-message-processor.js

@@ -498,7 +498,7 @@ function attachMessageProcessor(ctx) {
       if (_donePreviewText.length > 140) _donePreviewText = _donePreviewText.substring(0, 140) + "...";
       var _doneTitle = mateDisplayName ? (mateDisplayName + " responded") : (session.title || "Claude");
 
-      if (pushModule) {
+      if (pushModule && !session._delegatedBy) {
         pushModule.sendPush({
           type: "done",
           slug: slug,
@@ -509,7 +509,7 @@ function attachMessageProcessor(ctx) {
       }
 
       var _nm = getNotificationsModule();
-      if (_nm && !session.loop) {
+      if (_nm && !session.loop && !session._delegatedBy) {
         _nm.notify("response_done", {
           title: _doneTitle,
           preview: _donePreviewText,

package/lib/server.js

@@ -19,6 +19,7 @@ var serverSettings = require("./server-settings");
 var serverPalette = require("./server-palette");
 var serverEmail = require("./server-email");
 var serverGlobalWs = require("./server-global-ws");
+var { parseWsRequestUrl } = require("./ws-request");
 
 var { CONFIG_DIR } = require("./config");
 var { provisionLinuxUser } = require("./os-users");
@@ -350,8 +351,11 @@ function createServer(opts) {
   // --- Security headers ---
   var securityHeaders = {
     "X-Content-Type-Options": "nosniff",
-    "X-Frame-Options": "DENY",
-    "Content-Security-Policy": "default-src 'self'; script-src 'self' 'unsafe-inline' https://cdn.jsdelivr.net https://esm.sh; style-src 'self' 'unsafe-inline' https://fonts.googleapis.com https://cdn.jsdelivr.net; img-src * data: blob:; connect-src 'self' ws: wss: https://cdn.jsdelivr.net https://esm.sh https://api.dicebear.com https://api.open-meteo.com https://ipapi.co; font-src 'self' data: https://fonts.gstatic.com https://cdn.jsdelivr.net;",
+    // SAMEORIGIN (not DENY): split-view panes frame the app from the same
+    // origin. External sites still cannot frame Clay; frame-ancestors below
+    // is the modern equivalent for browsers that honor CSP.
+    "X-Frame-Options": "SAMEORIGIN",
+    "Content-Security-Policy": "default-src 'self'; frame-ancestors 'self'; script-src 'self' 'unsafe-inline' https://cdn.jsdelivr.net https://esm.sh; style-src 'self' 'unsafe-inline' https://fonts.googleapis.com https://cdn.jsdelivr.net; img-src * data: blob:; connect-src 'self' ws: wss: https://cdn.jsdelivr.net https://esm.sh https://api.dicebear.com https://api.open-meteo.com https://ipapi.co; font-src 'self' data: https://fonts.gstatic.com https://cdn.jsdelivr.net;",
   };
   if (tlsOptions) {
     securityHeaders["Strict-Transport-Security"] = "max-age=31536000; includeSubDomains";
@@ -439,6 +443,11 @@ function createServer(opts) {
           pctx.sm.sessions.forEach(function (s) {
             if (matchedCtx) return;
             if (s.cliSessionId !== cliSid) return;
+            // Adopted external CLI sessions never had a Clay PTY: the user is
+            // sitting in that terminal already, so hook-driven attention
+            // banners are noise. They start mattering once Clay attaches a
+            // PTY (resume in Clay sets runtimeTerminalId).
+            if (s.adopted && typeof s.terminalId !== "number" && typeof s.runtimeTerminalId !== "number") return;
             if (s.mode === "tui" || s.runtimeMode === "tui") {
               matchedCtx = pctx;
               matchedLocalId = s.localId;
@@ -894,6 +903,8 @@ function createServer(opts) {
   });
 
   server.on("upgrade", function (req, socket, head) {
+    var wsRequest = parseWsRequestUrl(req.url);
+    var wsPathname = wsRequest.path;
     // Origin validation (CSRF prevention)
     var origin = req.headers.origin;
     if (origin) {
@@ -930,23 +941,30 @@ function createServer(opts) {
     }
 
     // Extract slug from WS URL: /p/{slug}/ws
-    var wsSlug = extractSlug(req.url);
+    var wsSlug = extractSlug(wsPathname);
     if (!wsSlug) {
       // Slug-less /ws: bootstrap channel for a client that hasn't entered
       // any project yet (no projects exist, or none accessible to this user
       // but they can still create one). Anything other than exactly /ws is
       // rejected.
-      if (req.url !== "/ws") {
+      if (wsPathname !== "/ws") {
         socket.destroy();
         return;
       }
       var globalUser = users.isMultiUser() ? getMultiUserFromReq(req) : null;
       wss.handleUpgrade(req, socket, head, function (ws) {
+        ws._clayPane = wsRequest.pane;
+        ws._clayPaneSession = wsRequest.paneSession;
         globalWs.handleConnection(ws, globalUser);
       });
       return;
     }
 
+    if (stripPrefix(wsPathname, wsSlug) !== "/ws") {
+      socket.destroy();
+      return;
+    }
+
     var ctx = projects.get(wsSlug);
     if (!ctx) {
       if (debug) console.log("[server] WS rejected: project not found for slug", wsSlug);
@@ -1000,6 +1018,8 @@ function createServer(opts) {
         return origEmit.apply(ws, arguments);
       };
       ws._clayUser = wsUser; // attach user context
+      ws._clayPane = wsRequest.pane;
+      ws._clayPaneSession = wsRequest.paneSession;
       var remoteAddr = req.socket.remoteAddress || "";
       ws._clayLocal = (remoteAddr === "127.0.0.1" || remoteAddr === "::1" || remoteAddr === "::ffff:127.0.0.1");
       // Clear cross-project unread for this project when client connects

package/lib/session-hygiene.js

@@ -0,0 +1,100 @@
+// Blank-session hygiene: decides which sessions are safe to reuse for a
+// "New session" request and which abandoned blanks are safe to sweep.
+// Pure decision logic only -- deletion/switching stays in sessions.js.
+
+var BLANK_SESSION_MAX_AGE_MS = 24 * 60 * 60 * 1000;
+var CLAUDE_INTERRUPTED_TEXT = "[Request interrupted by user]";
+
+// A session is "blank" when nothing has ever happened in it and nothing is
+// attached to it. Adopted external sessions are never blank (their transcript
+// lives outside Clay), TUI sessions reap themselves via their PTY onExit, and
+// spawn/loop children are managed by their own lifecycles.
+function isBlankSession(s) {
+  return !!s
+    && (s.turnCount || 0) === 0
+    && (!s.history || s.history.length === 0)
+    && !s.isProcessing
+    && !s.queryInstance
+    && !s.adopted
+    && !s.bookmarked
+    && !s.spawn
+    && !s.loop
+    && (s.mode || "gui") !== "tui"
+    && s.terminalId == null;
+}
+
+// Newest blank owned by the same user. An exact vendor match wins; a
+// vendor-less blank (default adapter, nothing decided yet) is an acceptable
+// fallback -- the caller stamps the requested vendor onto it before use.
+function findReusableBlankSession(sessions, opts) {
+  var vendor = (opts && opts.vendor) || null;
+  var ownerId = (opts && opts.ownerId) || null;
+  var exact = null;
+  var vendorless = null;
+  sessions.forEach(function (s) {
+    if (!isBlankSession(s)) return;
+    if ((s.ownerId || null) !== ownerId) return;
+    var v = s.vendor || null;
+    if (v === vendor) {
+      if (!exact || (s.createdAt || 0) > (exact.createdAt || 0)) exact = s;
+    } else if (v === null) {
+      if (!vendorless || (s.createdAt || 0) > (vendorless.createdAt || 0)) vendorless = s;
+    }
+  });
+  return exact || vendorless;
+}
+
+// Blanks untouched for more than the grace period, excluding whatever a
+// client is currently looking at.
+function collectStaleBlankSessions(sessions, activeSessionId, now) {
+  var cutoff = now - BLANK_SESSION_MAX_AGE_MS;
+  var stale = [];
+  sessions.forEach(function (s) {
+    if (!isBlankSession(s)) return;
+    if (s.localId === activeSessionId) return;
+    if (Math.max(s.createdAt || 0, s.lastActivity || 0) >= cutoff) return;
+    stale.push(s.localId);
+  });
+  return stale;
+}
+
+function extractClaudeUserText(event) {
+  var content = event && event.message && event.message.content;
+  if (typeof content === "string") return content;
+  if (!Array.isArray(content)) return "";
+  var parts = [];
+  for (var i = 0; i < content.length; i++) {
+    if (content[i] && content[i].type === "text" && typeof content[i].text === "string") {
+      parts.push(content[i].text);
+    }
+  }
+  return parts.join("");
+}
+
+// SDK capability probes create a real Claude transcript with a single "hi"
+// prompt. Newer Claude Code versions append an interruption record when Clay
+// aborts the probe, so that bookkeeping record must not make the transcript
+// look like a real two-turn conversation.
+function isClaudeWarmupTranscript(events) {
+  var promptCount = 0;
+  for (var i = 0; i < events.length; i++) {
+    var event = events[i];
+    if (!event || typeof event !== "object") continue;
+    if (event.type === "assistant") return false;
+    if (event.type !== "user" || !event.message || event.message.role !== "user") continue;
+    var text = extractClaudeUserText(event);
+    if (text === CLAUDE_INTERRUPTED_TEXT) continue;
+    if (text !== "hi") return false;
+    promptCount++;
+  }
+  return promptCount === 1;
+}
+
+module.exports = {
+  isBlankSession: isBlankSession,
+  findReusableBlankSession: findReusableBlankSession,
+  collectStaleBlankSessions: collectStaleBlankSessions,
+  extractClaudeUserText: extractClaudeUserText,
+  isClaudeWarmupTranscript: isClaudeWarmupTranscript,
+  BLANK_SESSION_MAX_AGE_MS: BLANK_SESSION_MAX_AGE_MS,
+};

package/lib/session-pair-mcp-server.js

@@ -0,0 +1,28 @@
+// Partner-control tools for sessions that belong to a split group.
+
+var buildShape = require("./session-spawn-mcp-server").buildShape;
+
+function getToolDefs(handlers) {
+  return [
+    {
+      name: "send_to_partner",
+      description: "Delegate one concrete task to the other session in this split. The partner works visibly in its own pane. A delegated turn cannot delegate back, so keep orchestration one hop deep.",
+      inputSchema: buildShape({
+        message: { type: "string", description: "The complete task or question for the partner." },
+        wait: { type: "boolean", description: "Wait for the partner's turn to finish. Defaults to true." },
+        timeoutSeconds: { type: "number", description: "Maximum wait in seconds, from 1 to 900. Defaults to 300." },
+      }, ["message"]),
+      handler: function (args) { return handlers.send(args || {}); },
+    },
+    {
+      name: "read_partner",
+      description: "Read the partner's current status and recent conversation turns. Use this after a non-waiting delegation or timeout.",
+      inputSchema: buildShape({
+        lastTurns: { type: "number", description: "Number of recent user-message-delimited turns, from 1 to 5. Defaults to 1." },
+      }),
+      handler: function (args) { return handlers.read(args || {}); },
+    },
+  ];
+}
+
+module.exports = { getToolDefs: getToolDefs };