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

package/lib/daemon.js

@@ -1352,13 +1352,15 @@ var ipc = createIPCServer(socketPath(), function (msg) {
 //      skill_listing / deferred_tools attachments which can run into the
 //      tens of KB on its own)
 //   2. mtime older than 60 seconds        (avoid racing an in-flight warmup)
-//   3. exactly one user message, content text equals literal "hi"
+//   3. exactly one real user prompt equal to literal "hi" (the automatic
+//      interruption record written when the probe is aborted is ignored)
 //   4. zero assistant messages            (real users virtually always get a reply)
 //
 // Multi-user OS-isolated installs have per-user ~/.claude trees that the
 // daemon process can't traverse; the inline cleanup in claude-worker.js
 // covers those.
 function cleanupSdkWarmupSessions() {
+  var sessionHygiene = require("./session-hygiene");
   var projectsRoot = path.join(REAL_HOME, ".claude", "projects");
   var projectDirs;
   try { projectDirs = fs.readdirSync(projectsRoot, { withFileTypes: true }); }
@@ -1388,9 +1390,7 @@ function cleanupSdkWarmupSessions() {
       var raw;
       try { raw = fs.readFileSync(fp, "utf8"); } catch (e) { continue; }
       var lines = raw.split("\n");
-      var userCount = 0;
-      var assistantCount = 0;
-      var userText = null;
+      var events = [];
       var parseOk = true;
       for (var li = 0; li < lines.length; li++) {
         var line = lines[li];
@@ -1398,31 +1398,10 @@ function cleanupSdkWarmupSessions() {
         var ev;
         try { ev = JSON.parse(line); } catch (e) { parseOk = false; break; }
         if (!ev || typeof ev !== "object") continue;
-        if (ev.type === "user") {
-          userCount++;
-          if (userCount > 1) break;
-          var msg = ev.message;
-          var content = msg && msg.content;
-          if (typeof content === "string") {
-            userText = content;
-          } else if (Array.isArray(content)) {
-            var parts = [];
-            for (var ci = 0; ci < content.length; ci++) {
-              if (content[ci] && content[ci].type === "text" && typeof content[ci].text === "string") {
-                parts.push(content[ci].text);
-              }
-            }
-            userText = parts.join("");
-          }
-        } else if (ev.type === "assistant") {
-          assistantCount++;
-          if (assistantCount > 0) break;
-        }
+        events.push(ev);
       }
       if (!parseOk) continue;
-      if (userCount !== 1) continue;
-      if (assistantCount !== 0) continue;
-      if (userText !== "hi") continue;
+      if (!sessionHygiene.isClaudeWarmupTranscript(events)) continue;
 
       try { fs.unlinkSync(fp); deleted++; } catch (e) {}
     }

package/lib/project-connection.js

@@ -39,6 +39,7 @@ function attachConnection(ctx) {
   var _loop = ctx._loop;
   var _mcp = ctx._mcp;
   var _notifications = ctx._notifications;
+  var _splitGroups = ctx._splitGroups;
   var hydrateImageRefs = ctx.hydrateImageRefs;
   var resolveSessionForView = ctx.resolveSessionForView;
   var broadcastClientCount = ctx.broadcastClientCount;
@@ -128,9 +129,19 @@ function attachConnection(ctx) {
     } else if (!usersModule.isMultiUser()) {
       allSessions = allSessions.filter(function (s) { return !s.ownerId; });
     }
-    var restoredState = findRestoredActiveSession(ws, wsUser, allSessions);
+    var restoredState = ws._clayPane
+      ? { active: null, storedPresence: null }
+      : findRestoredActiveSession(ws, wsUser, allSessions);
     var restoredActive = restoredState.active;
     var initialVendor = (restoredActive && restoredActive.vendor) || sm.defaultVendor || "claude";
+    var initialEffort = (restoredActive && restoredActive.effort) || yoke.clampEffort(
+      initialVendor,
+      (sm.currentEffortByVendor && sm.currentEffortByVendor[initialVendor]) || sm.currentEffort || "medium"
+    ) || null;
+    if (restoredActive && !restoredActive.effort && initialEffort) {
+      restoredActive.effort = initialEffort;
+      sm.saveSessionFile(restoredActive);
+    }
     var initialModels = (sm.modelsByVendor && sm.modelsByVendor[initialVendor]) || sm.availableModels || [];
     sendTo(ws, { type: "info", cwd: cwd, slug: slug, project: title || project, version: currentVersion, debug: !!debug, dangerouslySkipPermissions: dangerouslySkipPermissions, osUsers: osUsers, lanHost: lanHost, projectCount: _filteredProjects.length, projects: _filteredProjects, projectOwnerId: projectOwnerId, ownerLocked: ownerLocked, vendors: yoke.VENDOR_REGISTRY });
     // Update notifications are pushed on a scheduled interval (see
@@ -139,10 +150,11 @@ function attachConnection(ctx) {
     if (sm.slashCommands) {
       sendTo(ws, { type: "slash_commands", commands: sm.slashCommands });
     }
-    if (sm.currentModel) {
-      sendTo(ws, { type: "model_info", model: sm.currentModel, models: initialModels, vendor: initialVendor, availableVendors: sm.availableVendors || [], installedVendors: sm.installedVendors || [] });
+    var initialModel = (restoredActive && restoredActive.model) || sm.currentModel || "";
+    if (initialModel) {
+      sendTo(ws, { type: "model_info", model: initialModel, models: initialModels, vendor: initialVendor, availableVendors: sm.availableVendors || [], installedVendors: sm.installedVendors || [] });
     }
-    sendTo(ws, { 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 });
+    sendTo(ws, { type: "config_state", model: initialModel, mode: sm.currentPermissionMode || "default", effort: initialEffort || "medium", betas: sm.currentBetas || [], thinking: sm.currentThinking || "adaptive", thinkingBudget: sm.currentThinkingBudget || 10000 });
     sendTo(ws, { type: "last_vendor", vendor: sm.lastVendor || "" });
     sendTo(ws, Object.assign({ type: "codex_config" }, getCodexConfig(sm)));
     sendTo(ws, { type: "term_list", terminals: tm.list() });
@@ -186,13 +198,14 @@ function attachConnection(ctx) {
       type: "session_list",
       sessions: allSessions.map(function (s) { return sm.mapSessionForClient(s); }),
     });
+    if (_splitGroups) _splitGroups.sendConnectionState(ws);
 
     // Restore active session for this client from server-side presence
     var active = restoredState.active;
     var presenceKey = wsUser ? wsUser.id : "_default";
     var storedPresence = restoredState.storedPresence;
     var autoCreated = false;
-    if (!active) {
+    if (!active && !ws._clayPane) {
       var autoOpts = {};
       if (wsUser && usersModule.isMultiUser()) autoOpts.ownerId = wsUser.id;
       active = sm.createSession(autoOpts, ws);
@@ -212,7 +225,7 @@ function attachConnection(ctx) {
         try { resolveSessionForView(active, ws); } catch (e) {}
       }
       var _vendorCaps = (sm.capabilitiesByVendor && sm.capabilitiesByVendor[active.vendor || sm.defaultVendor || "claude"]) || {};
-      sendTo(ws, { type: "session_switched", id: active.localId, cliSessionId: active.cliSessionId || null, loop: active.loop || null, vendor: active.vendor || null, hasHistory: (active.history && active.history.length > 0), capabilities: _vendorCaps, mode: active.mode || "gui", terminalId: typeof active.terminalId === "number" ? active.terminalId : null, runtimeMode: active.runtimeMode || null, runtimeTerminalId: typeof active.runtimeTerminalId === "number" ? active.runtimeTerminalId : null, tuiSuspended: !!active.tuiSuspended });
+      sendTo(ws, { type: "session_switched", id: active.localId, cliSessionId: active.cliSessionId || null, loop: active.loop || null, vendor: active.vendor || null, model: active.model || null, effort: active.effort || initialEffort || null, hasHistory: (active.history && active.history.length > 0), capabilities: _vendorCaps, mode: active.mode || "gui", terminalId: typeof active.terminalId === "number" ? active.terminalId : null, runtimeMode: active.runtimeMode || null, runtimeTerminalId: typeof active.runtimeTerminalId === "number" ? active.runtimeTerminalId : null, tuiSuspended: !!active.tuiSuspended });
       // Send per-session context sources
       var sessionSources = loadContextSources(slug, active.localId);
       sendTo(ws, { type: "context_sources_state", active: sessionSources });
@@ -257,7 +270,7 @@ function attachConnection(ctx) {
       }
     }
 
-    if (active) {
+    if (active && !ws._clayPane) {
       userPresence.setPresence(slug, presenceKey, active.localId, storedPresence ? storedPresence.mateDm : null);
       // For auto-created sessions, apply project email defaults
       if (autoCreated) {
@@ -296,7 +309,7 @@ function attachConnection(ctx) {
   }
 
   function handleDisconnection(ws) {
-    if (ws._clayActiveSession) {
+    if (ws._clayActiveSession && !ws._clayPane) {
       var dcPresKey = ws._clayUser ? ws._clayUser.id : "_default";
       var dcExisting = userPresence.getPresence(slug, dcPresKey);
       userPresence.setPresence(slug, dcPresKey, ws._clayActiveSession, dcExisting ? dcExisting.mateDm : null);

package/lib/project-session-pair.js

@@ -0,0 +1,312 @@
+var pairMcp = require("./session-pair-mcp-server");
+var yoke = require("./yoke");
+
+var MAX_RESPONSE_CHARS = 30000;
+
+function toolResult(value) {
+  return Promise.resolve({ content: [{ type: "text", text: JSON.stringify(value) }] });
+}
+
+function toolError(err) {
+  return Promise.resolve({
+    content: [{ type: "text", text: "Error: " + (err.message || err) }],
+    isError: true,
+  });
+}
+
+function responseText(history, fromIndex) {
+  var text = "";
+  for (var i = Math.max(0, fromIndex || 0); i < history.length; i++) {
+    if (history[i] && history[i].type === "delta" && history[i].text) text += history[i].text;
+  }
+  if (text.length > MAX_RESPONSE_CHARS) text = text.slice(-MAX_RESPONSE_CHARS);
+  return text;
+}
+
+function errorSince(history, fromIndex) {
+  for (var i = history.length - 1; i >= Math.max(0, fromIndex || 0); i--) {
+    if (history[i] && history[i].type === "error") return history[i].text || "partner turn failed";
+  }
+  return null;
+}
+
+function recentTurns(session, count) {
+  var history = session.history || [];
+  var starts = [];
+  for (var i = 0; i < history.length; i++) {
+    if (history[i] && history[i].type === "user_message") starts.push(i);
+  }
+  var from = starts.length > 0 ? starts[Math.max(0, starts.length - count)] : 0;
+  var turns = [];
+  var current = null;
+  for (var j = from; j < history.length; j++) {
+    var item = history[j];
+    if (!item) continue;
+    if (item.type === "user_message") {
+      current = { user: item.text || "", delegated: !!item.delegated, response: "" };
+      turns.push(current);
+    } else if (item.type === "delta" && item.text) {
+      if (!current) { current = { user: "", delegated: false, response: "" }; turns.push(current); }
+      current.response += item.text;
+      if (current.response.length > MAX_RESPONSE_CHARS) current.response = current.response.slice(-MAX_RESPONSE_CHARS);
+    }
+  }
+  return turns;
+}
+
+function attachSessionPair(ctx) {
+  var sm = ctx.sm;
+  var store = ctx.splitStore;
+
+  function groupAndPartner(caller) {
+    if (!caller) throw new Error("partner tools require a session-bound tool server");
+    var group = store.groupForMember(caller.localId);
+    if (!group) throw new Error("this session is not in a split group");
+    if (group.pair && group.pair.driverId !== caller.localId) {
+      throw new Error("only the configured Driver can direct this pair");
+    }
+    var partnerId = group.members[0] === caller.localId ? group.members[1] : group.members[0];
+    var partner = sm.sessions.get(partnerId);
+    if (!partner) throw new Error("split partner session was not found");
+    if (caller.ownerId !== partner.ownerId) throw new Error("split partner access denied");
+    return { group: group, partner: partner };
+  }
+
+  function broadcastDelegation(group, caller, partner, active) {
+    var message = {
+      type: "split_delegation",
+      groupId: group.id,
+      from: caller.localId,
+      to: partner.localId,
+      active: !!active,
+    };
+    if (typeof ctx.broadcastDelegation === "function") ctx.broadcastDelegation(group, message);
+    else ctx.send(message);
+  }
+
+  function finishDelegation(group, caller, partner, token) {
+    if (partner._pairDelegation !== token) return;
+    delete partner._pairDelegation;
+    delete partner._delegatedBy;
+    broadcastDelegation(group, caller, partner, false);
+  }
+
+  function waitForPartner(group, caller, partner, token, timeoutSeconds) {
+    return new Promise(function (resolve, reject) {
+      var deadline = Date.now() + timeoutSeconds * 1000;
+      var timer = setInterval(function () {
+        var currentGroup = store.groupForMember(caller.localId);
+        if (!currentGroup || currentGroup.id !== group.id || currentGroup.members.indexOf(partner.localId) === -1) {
+          clearInterval(timer);
+          finishDelegation(group, caller, partner, token);
+          reject(new Error("the split group was dissolved while waiting for the partner"));
+          return;
+        }
+        if (!partner.isProcessing && !partner._queryStarting) {
+          clearInterval(timer);
+          finishDelegation(group, caller, partner, token);
+          var failure = errorSince(partner.history || [], token.startIndex);
+          resolve({
+            status: failure ? "error" : "complete",
+            response: responseText(partner.history || [], token.startIndex),
+            error: failure || undefined,
+          });
+          return;
+        }
+        if (Date.now() >= deadline) {
+          clearInterval(timer);
+          monitorPartner(group, caller, partner, token);
+          resolve({ status: "running", response: responseText(partner.history || [], token.startIndex), hint: "Use read_partner to check again." });
+        }
+      }, 500);
+    });
+  }
+
+  function monitorPartner(group, caller, partner, token) {
+    var timer = setInterval(function () {
+      var currentGroup = store.groupForMember(caller.localId);
+      if (!currentGroup || currentGroup.id !== group.id || (!partner.isProcessing && !partner._queryStarting)) {
+        clearInterval(timer);
+        finishDelegation(group, caller, partner, token);
+      }
+    }, 500);
+  }
+
+  async function sendToPartner(args, caller) {
+    try {
+      if (caller && caller._delegatedBy) throw new Error("delegated turns cannot delegate to another session");
+      var resolved = groupAndPartner(caller);
+      var message = typeof args.message === "string" ? args.message.trim() : "";
+      if (!message) throw new Error("message is required");
+      var wait = args.wait !== false;
+      var timeout = Number.isFinite(args.timeoutSeconds) ? Math.floor(args.timeoutSeconds) : 300;
+      timeout = Math.max(1, Math.min(900, timeout));
+      var partner = resolved.partner;
+      if (partner._pairDelegation) throw new Error("the partner is already handling a delegated task");
+      var token = { from: caller.localId, groupId: resolved.group.id, startIndex: partner.history.length };
+      partner._pairDelegation = token;
+      partner._delegatedBy = caller.localId;
+      sm.sendAndRecord(partner, {
+        type: "user_message",
+        text: message,
+        delegated: true,
+        delegatedBy: caller.localId,
+        delegatedByTitle: caller.title || "Driver",
+        delegatedByVendor: caller.vendor || "claude",
+      });
+      partner.lastActivity = Date.now();
+      partner.sentToolResults = {};
+      broadcastDelegation(resolved.group, caller, partner, true);
+      var sdk = ctx.getSdk();
+      if (!sdk) throw new Error("SDK bridge is not ready");
+      if (!partner.isProcessing) {
+        partner.isProcessing = true;
+        ctx.onProcessingChanged();
+        sm.sendToSession(partner, { type: "status", status: "processing" });
+      }
+      if (!sdk.pushMessage(partner, message)) {
+        partner._queryStartTs = Date.now();
+        Promise.resolve(sdk.startQuery(partner, message, undefined, ctx.getLinuxUserForSession(partner))).catch(function (err) {
+          partner.isProcessing = false;
+          sm.sendAndRecord(partner, { type: "error", text: err.message || String(err) });
+        });
+      }
+      sm.broadcastSessionList();
+      if (!wait) {
+        monitorPartner(resolved.group, caller, partner, token);
+        return toolResult({ status: "running", partnerId: partner.localId, hint: "Use read_partner to check progress." });
+      }
+      return toolResult(await waitForPartner(resolved.group, caller, partner, token, timeout));
+    } catch (e) {
+      if (caller) {
+        var group = store.groupForMember(caller.localId);
+        if (group) {
+          var partnerId = group.members[0] === caller.localId ? group.members[1] : group.members[0];
+          var partner = sm.sessions.get(partnerId);
+          if (partner && partner._pairDelegation && partner._pairDelegation.from === caller.localId && !partner.isProcessing) {
+            finishDelegation(group, caller, partner, partner._pairDelegation);
+          }
+        }
+      }
+      return toolError(e);
+    }
+  }
+
+  function readPartner(args, caller) {
+    try {
+      var resolved = groupAndPartner(caller);
+      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",
+        partnerId: resolved.partner.localId,
+        title: resolved.partner.title || "New Session",
+        turns: recentTurns(resolved.partner, count),
+      });
+    } catch (e) {
+      return toolError(e);
+    }
+  }
+
+  function getToolDefs(boundSession) {
+    if (!boundSession) return pairMcp.getToolDefs({
+      send: function () { return toolError(new Error("send_to_partner requires a session-bound tool server")); },
+      read: function () { return toolError(new Error("read_partner requires a session-bound tool server")); },
+    });
+    // Mount whenever we have a bound session: MCP servers are fixed for the
+    // lifetime of a query, and Claude queries live across turns, so gating on
+    // group membership HERE would permanently hide the tools from a session
+    // whose split is created mid-conversation (the ad-hoc flow). Handlers
+    // re-resolve the group on every call, so an ungrouped session gets a
+    // clear error, and a session that gains a partner later just works.
+    // The one structural exclusion: a session that is ALREADY a configured
+    // pair worker at query start never sees the tools.
+    var group = store.groupForMember(boundSession.localId);
+    if (group && group.pair && group.pair.driverId !== boundSession.localId) return [];
+    return pairMcp.getToolDefs({
+      send: function (args) { return sendToPartner(args, boundSession); },
+      read: function (args) { return readPartner(args, boundSession); },
+    });
+  }
+
+  function validateVendor(vendor) {
+    var installed = sm.installedVendors || [];
+    if (!vendor || installed.indexOf(vendor) === -1) throw new Error("vendor is not installed: " + (vendor || "unknown"));
+    return vendor;
+  }
+
+  function createPair(ws, msg) {
+    try {
+      if (ctx.isMate) throw new Error("Pair sessions are only available in projects");
+      var driverSpec = msg.driver || {};
+      var workerSpec = msg.worker || {};
+      var workerVendor = validateVendor(workerSpec.vendor || sm.lastVendor || "codex");
+      var ownerId = ws._clayUser && ctx.usersModule.isMultiUser() ? ws._clayUser.id : null;
+      var driver;
+      var groupName;
+      if (Number.isInteger(driverSpec.sessionId)) {
+        // "Add Worker" on an existing session: the current session becomes
+        // the Driver with its full conversation context intact.
+        driver = sm.sessions.get(driverSpec.sessionId);
+        if (!driver) throw new Error("driver session not found");
+        if ((driver.ownerId || null) !== ownerId) throw new Error("driver session access denied");
+        if (store.groupForMember(driver.localId)) throw new Error("this session is already in a split group");
+        groupName = undefined; // auto name from member titles
+      } else {
+        var driverVendor = validateVendor(driverSpec.vendor || "claude");
+        var driverEffort = yoke.clampEffort(driverVendor, driverSpec.effort || (sm.currentEffortByVendor && sm.currentEffortByVendor[driverVendor]) || sm.currentEffort || "medium") || null;
+        driver = sm.createSessionRaw({ ownerId: ownerId, vendor: driverVendor, model: driverSpec.model || null, effort: driverEffort });
+        driver.title = "Driver · " + ((yoke.getVendorInfo(driverVendor) || {}).displayName || driverVendor);
+        if (driverSpec.effort) driver.loopSettings = { effort: driverSpec.effort };
+        groupName = "Agent pair";
+      }
+      var workerEffort = yoke.clampEffort(workerVendor, workerSpec.effort || (sm.currentEffortByVendor && sm.currentEffortByVendor[workerVendor]) || sm.currentEffort || "medium") || null;
+      var worker = sm.createSessionRaw({ ownerId: ownerId, vendor: workerVendor, model: workerSpec.model || null, effort: workerEffort });
+      worker.title = "Worker · " + ((yoke.getVendorInfo(workerVendor) || {}).displayName || workerVendor);
+      if (workerSpec.effort) worker.loopSettings = { effort: workerSpec.effort };
+      var result = store.create(ws, {
+        members: [driver.localId, worker.localId],
+        pair: { driverId: driver.localId, workerId: worker.localId },
+        name: groupName,
+      });
+      if (!result.ok) throw new Error(result.error);
+      sm.broadcastSessionList();
+      ctx.sendTo(ws, { type: "pair_session_created", ok: true, group: result.group });
+    } catch (e) {
+      ctx.sendTo(ws, { type: "pair_session_created", ok: false, error: e.message || String(e) });
+    }
+  }
+
+  function handleMessage(ws, msg) {
+    if (msg.type === "pair_session_options") {
+      if (ctx.isMate) return false;
+      ctx.sendTo(ws, {
+        type: "pair_session_options",
+        installedVendors: sm.installedVendors || [],
+        modelsByVendor: sm.modelsByVendor || {},
+        capabilitiesByVendor: sm.capabilitiesByVendor || {},
+        lastVendor: sm.lastVendor || null,
+      });
+      return true;
+    }
+    if (msg.type === "pair_session_create") {
+      createPair(ws, msg);
+      return true;
+    }
+    return false;
+  }
+
+  function getSystemPrompt(session) {
+    var group = store.groupForMember(session.localId);
+    if (!group || !group.pair || group.pair.driverId !== session.localId) return "";
+    return "You are the Driver in a two-agent pair. Plan the work, delegate concrete bounded tasks with send_to_partner, inspect results with read_partner, then integrate and verify the final outcome. Do not delegate work that must be performed sequentially in this same session.";
+  }
+
+  return { getToolDefs: getToolDefs, handleMessage: handleMessage, getSystemPrompt: getSystemPrompt };
+}
+
+module.exports = {
+  attachSessionPair: attachSessionPair,
+  responseText: responseText,
+  recentTurns: recentTurns,
+};

package/lib/project-session-spawn.js

@@ -336,13 +336,17 @@ function attachSessionSpawn(ctx) {
   // its handlers fail closed if anything ever routes a call to them.
   function createMcpServer(adapter, boundSession) {
     if (ctx.isMate || !adapter || typeof adapter.createToolServer !== "function") return null;
+    var tools = sessionSpawnMcp.getToolDefs({
+      spawn: function (args) { return spawn(args, boundSession || null); },
+      check: function (args) { return check(args, boundSession || null); },
+    });
+    if (typeof ctx.getPairToolDefs === "function") {
+      tools = tools.concat(ctx.getPairToolDefs(boundSession || null) || []);
+    }
     return adapter.createToolServer({
       name: "clay-sessions",
       version: "1.0.0",
-      tools: sessionSpawnMcp.getToolDefs({
-        spawn: function (args) { return spawn(args, boundSession || null); },
-        check: function (args) { return check(args, boundSession || null); },
-      }),
+      tools: tools,
     });
   }