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

package/lib/project-mate-interaction.js

@@ -3,6 +3,7 @@ var fs = require("fs");
 var path = require("path");
 var crypto = require("crypto");
 var mateSync = require("./mate-knowledge-sync");
+var dmDigestCursor = require("./dm-digest-cursor");
 
 // Mirror a Mate-owned journal into the Clay-wide Knowledge backend after the
 // legacy append has already succeeded. Reconciling the whole journal keeps the
@@ -294,6 +295,9 @@ function attachMateInteraction(ctx) {
         mirrorMateJournal(mateDir, "session-digests.jsonl", job);
       } catch (e) {
         console.error("[digest-worker] Write failed for " + job.mateId + ":", e.message);
+        if (job.onError) job.onError(e);
+        processDigestQueue();
+        return;
       }
 
       // Write user observations if present
@@ -422,63 +426,19 @@ function attachMateInteraction(ctx) {
   // Delta-based: only collects new turns since the last successful digest.
   // Concurrency debounce: turns that arrive while a digest is in-flight
   // are naturally batched into the next flush.
-  var _dmDigestPending = false;
-  function digestDmTurn(session, responsePreview) {
-    if (!isMate || _dmDigestPending) return;
+  var _dmDigestPending = new WeakSet();
+  function digestDmTurn(session) {
+    if (!isMate || _dmDigestPending.has(session)) return;
     var mateId = path.basename(cwd);
     var mateCtx = matesModule.buildMateCtx(projectOwnerId);
     if (!matesModule.isMate(mateCtx, mateId)) return;
 
-    // Track digest index per session so switching sessions doesn't misalign.
-    // On resumed sessions (after restart), recover index from the last
-    // digest_checkpoint entry in history so undigested turns aren't lost.
-    if (typeof session._dmLastDigestedIndex !== "number") {
-      session._dmLastDigestedIndex = 0;
-      for (var ci = session.history.length - 1; ci >= 0; ci--) {
-        if (session.history[ci].type === "digest_checkpoint") {
-          session._dmLastDigestedIndex = session.history[ci].digestedIndex;
-          break;
-        }
-      }
-    }
-
-    // Collect only new turns since the last successful digest
-    var conversationParts = [];
-    var totalLen = 0;
-    var CONV_CAP = 6000;
-    var startIndex = session._dmLastDigestedIndex;
-    for (var hi = startIndex; hi < session.history.length; hi++) {
-      if (totalLen >= CONV_CAP) break;
-      var entry = session.history[hi];
-      if (entry.type === "user_message" && entry.text) {
-        var uText = entry.text;
-        if (totalLen + uText.length > CONV_CAP) {
-          uText = uText.substring(0, Math.max(200, CONV_CAP - totalLen)) + "...";
-        }
-        conversationParts.push("User: " + uText);
-        totalLen += uText.length;
-      } else if (entry.type === "assistant_message" && entry.text) {
-        var aText = entry.text;
-        if (totalLen + aText.length > CONV_CAP) {
-          aText = aText.substring(0, Math.max(200, CONV_CAP - totalLen)) + "...";
-        }
-        conversationParts.push("Mate: " + aText);
-        totalLen += aText.length;
-      }
-    }
-    // If the latest response hasn't landed in history yet, append it
-    var lastResponseText = responsePreview || "";
-    if (lastResponseText && conversationParts.length > 0) {
-      var lastPart = conversationParts[conversationParts.length - 1];
-      if (lastPart.indexOf("Mate:") !== 0 || lastPart.indexOf(lastResponseText.substring(0, 50)) === -1) {
-        var rText = lastResponseText;
-        if (totalLen + rText.length > CONV_CAP) {
-          rText = rText.substring(0, Math.max(200, CONV_CAP - totalLen)) + "...";
-        }
-        conversationParts.push("Mate: " + rText);
-      }
-    }
-    if (conversationParts.length === 0) return;
+    // Recover the exact next unread position. Legacy index-only checkpoints
+    // remain readable and are treated as fully consumed entries.
+    var digestState = dmDigestCursor.readState(session.history);
+    var startCursor = digestState.cursor;
+    var chunk = dmDigestCursor.collectChunk(session.history, startCursor);
+    if (!chunk.conversationContent) return;
 
     var mateDir = matesModule.getMateDir(mateCtx, mateId);
     var knowledgeDir = path.join(mateDir, "knowledge");
@@ -500,8 +460,8 @@ function attachMateInteraction(ctx) {
       }
     } catch (e) {}
 
-    _dmDigestPending = true;
-    var snapshotIndex = session.history.length;
+    _dmDigestPending.add(session);
+    var checkpointCursor = chunk.cursor;
 
     enqueueDigest({
       mateCtx: mateCtx,
@@ -509,17 +469,27 @@ function attachMateInteraction(ctx) {
       mateId: mateId,
       type: "dm",
       priorSummary: priorSummary || "",
-      conversationContent: conversationParts.join("\n"),
+      conversationContent: chunk.conversationContent,
       onDone: function () {
-        session._dmLastDigestedIndex = snapshotIndex;
-        // Persist checkpoint so resumed sessions know where to continue
-        var checkpoint = { type: "digest_checkpoint", digestedIndex: snapshotIndex };
+        // Journal and checkpoint are separate appends: if this append fails,
+        // retry may duplicate the saved digest, but must never skip its input.
+        var checkpoint = { type: "digest_checkpoint", cursor: checkpointCursor };
+        var saved = false;
+        try { saved = sm.appendToSessionFile(session, checkpoint) !== false; } catch (e) {
+          console.error("[dm-digest] Checkpoint append failed:", e.message);
+        }
+        if (!saved) {
+          _dmDigestPending.delete(session);
+          return;
+        }
         session.history.push(checkpoint);
-        sm.appendToSessionFile(session, checkpoint);
-        _dmDigestPending = false;
+        _dmDigestPending.delete(session);
+        if (dmDigestCursor.hasPending(session.history, checkpointCursor)) {
+          setImmediate(function () { digestDmTurn(session, ""); });
+        }
       },
       onError: function () {
-        _dmDigestPending = false;
+        _dmDigestPending.delete(session);
       },
     });
   }
@@ -570,6 +540,8 @@ function attachMateInteraction(ctx) {
 
     var mateName = (mate.profile && mate.profile.displayName) || mate.name || "Mate";
     var avatarColor = (mate.profile && mate.profile.avatarColor) || "#5857fc";
+    var avatarCatalogId = (mate.profile && mate.profile.avatarCatalogId) || "";
+    var avatarCustom = (mate.profile && mate.profile.avatarCustom) || "";
     var avatarStyle = (mate.profile && mate.profile.avatarStyle) || "imprint";
     var avatarSeed = (mate.profile && mate.profile.avatarSeed) || mate.id;
 
@@ -622,6 +594,8 @@ function attachMateInteraction(ctx) {
       mateName: mateName,
       avatarColor: avatarColor,
       avatarStyle: avatarStyle,
+      avatarCatalogId: avatarCatalogId,
+      avatarCustom: avatarCustom,
       avatarSeed: avatarSeed,
     });
 
@@ -657,6 +631,8 @@ function attachMateInteraction(ctx) {
           text: fullText,
           avatarColor: avatarColor,
           avatarStyle: avatarStyle,
+          avatarCatalogId: avatarCatalogId,
+          avatarCustom: avatarCustom,
           avatarSeed: avatarSeed,
         };
         session.history.push(mentionResponseEntry);
@@ -820,6 +796,8 @@ function attachMateInteraction(ctx) {
       name: (mate.profile && mate.profile.displayName) || mate.name || "Mate",
       avatarColor: (mate.profile && mate.profile.avatarColor) || "#5857fc",
       avatarStyle: (mate.profile && mate.profile.avatarStyle) || "imprint",
+      avatarCatalogId: (mate.profile && mate.profile.avatarCatalogId) || "",
+      avatarCustom: (mate.profile && mate.profile.avatarCustom) || "",
       avatarSeed: (mate.profile && mate.profile.avatarSeed) || mateId,
     };
   }

package/lib/project-mcp.js

@@ -1,10 +1,19 @@
 var crypto = require('crypto');
+var path = require('path');
 var createProxy = require('./mcp-proxy').createProxy;
 var createStore = require('./mcp-connection-store').createConnectionStore;
 var createRemoteConnections = require('./mcp-remote-connections').createRemoteConnections;
+var SHARED_REGISTRIES = new Map();
 
 function attachMcp(ctx) {
-  var devices = new Map(), pending = new Map();
+  var storage = ctx.storage || createStore(ctx.root, ctx.slug, { shared: true });
+  var namespace = storage.namespace || (ctx.root ? path.resolve(ctx.root) : storage);
+  var registry = SHARED_REGISTRIES.get(namespace);
+  if (!registry) { registry = { devices: new Map(), pending: new Map(), managers: new Set() }; SHARED_REGISTRIES.set(namespace, registry); }
+  var devices = registry.devices, pending = registry.pending, manager = {};
+  registry.managers.add(manager);
+  function announce(owner) { registry.managers.forEach(function (source) { source.broadcast(owner); }); }
+  manager.broadcast = broadcast;
   function ownerFor(ws) {
     if (!ctx.canAccess(ws)) throw new Error('MCP access is not permitted.');
     return ctx.isMultiUser() ? String(ws._clayUser.id) : 'default';
@@ -15,17 +24,32 @@ function attachMcp(ctx) {
       try { if (ws.readyState === 1 && ownerFor(ws) === owner) ctx.sendTo(ws, Object.assign({ slug: ctx.slug }, msg)); } catch (error) {}
     });
   }
+  function isSession(subject) { return !!subject && ctx.canUseSession(subject); }
+  function sourceIdentity(subject) { return isSession(subject) ? ctx.ownerIdentity(ctx.isMultiUser() ? String(subject.ownerId) : 'default') : ctx.identity(subject); }
+  var discovery = require('./mcp-source-discovery').createDiscovery({ cwd: ctx.cwd || process.cwd(), home: ctx.discoveryHome,
+    identity: sourceIdentity, runtimeEnv: function (owner, subject) { return isSession(subject) ? ctx.runtimeEnvForSession(subject) : ctx.runtimeEnv ? ctx.runtimeEnv(owner, subject) : {}; }, authorize: function (owner, subject) {
+      var permitted = isSession(subject) ? (ctx.isMultiUser() ? String(subject.ownerId) : 'default') === owner && ctx.canDiscoverSession(subject) : ownerFor(subject) === owner && ctx.canDiscover && ctx.canDiscover(subject);
+      if (!permitted) throw new Error('Vendor discovery requires your authorized OS user mapping or a sole account installation.');
+      authorizeOwner(owner);
+    }, snapshot: function (owner) { return storage.snapshot(owner); } });
   var remote = createRemoteConnections({
     remoteFetch: ctx.remoteFetch, createLoginBrowser: ctx.createLoginBrowser,
-    storage: ctx.storage || createStore(ctx.root, ctx.slug), authorize: authorizeOwner,
-    changed: function (owner) { broadcast(owner); }, sendOwner: sendOwner, sendTo: function (ws, msg) { ctx.sendTo(ws, Object.assign({ slug: ctx.slug }, msg)); },
+    storage: storage, authorize: authorizeOwner,
+    changed: function (owner) { announce(owner); }, sendOwner: sendOwner, sendTo: function (ws, msg) { ctx.sendTo(ws, Object.assign({ slug: ctx.slug }, msg)); },
+    ownerIdentity: ctx.ownerIdentity, selectImport: discovery.selected,
     identity: ctx.identity,
     canAccess: function (ws, owner) { try { return ownerFor(ws) === owner; } catch (error) { return false; } },
   });
+  var agentTools = require('./mcp-agent-tools').attachMcpAgentTools({
+    available: function (session) { return typeof ctx.canDiscoverSession === "function" && typeof ctx.runtimeEnvForSession === "function" && ctx.canDiscoverSession(session); },
+    clients: ctx.clients, isMultiUser: ctx.isMultiUser, ownerFor: ownerFor, canUseSession: ctx.canUseSession,
+    authorizeOwner: authorizeOwner, discovery: discovery, importConnection: remote.importConnection,
+    userInput: ctx.userInput, consentTimeout: ctx.consentTimeout,
+  });
   function deviceFor(owner) {
     var device = devices.get(owner);
     if (!device || device.ws.readyState !== 1) return null;
-    try { if (ownerFor(device.ws) !== owner) return null; } catch (error) { return null; }
+    try { authorizeOwner(owner); if (!device.authorized()) return null; } catch (error) { return null; }
     return device;
   }
   function enabled(owner, name) {
@@ -59,13 +83,18 @@ function attachMcp(ctx) {
         if (call.ws !== device.ws) return;
         clearTimeout(call.timer); pending.delete(id); call.reject(new Error('Your computer disconnected.'));
       });
-      broadcast(owner);
+      announce(owner);
     });
   }
   function handleMcpMessage(ws, msg) {
     if (!msg || typeof msg.type !== 'string' || (msg.type.indexOf('mcp_') !== 0 && msg.type !== 'mcp_toggle_server')) return false;
     var owner;
     try { owner = ownerFor(ws); } catch (error) { return true; }
+    if (msg.type === 'mcp_discovery_request') {
+      try { ctx.sendTo(ws, Object.assign({ type: 'mcp_discovery_result', slug: ctx.slug, requestId: msg.requestId, ok: true }, discovery.scan(owner, ws, msg.file ? { file: msg.file, vendor: msg.vendor } : null))); }
+      catch (error) { ctx.sendTo(ws, { type: 'mcp_discovery_result', slug: ctx.slug, requestId: msg.requestId, ok: false, error: error.message }); }
+      return true;
+    }
     if (msg.type === 'mcp_state_request') { sendConnectionState(ws); return true; }
     if (msg.type === 'mcp_servers_available') {
       var servers = Array.isArray(msg.servers) ? msg.servers : [];
@@ -75,8 +104,10 @@ function attachMcp(ctx) {
       });
       var old = devices.get(owner);
       if (old && old.ws !== ws) disconnectDevice(old.ws);
-      devices.set(owner, { ws: ws, servers: servers, hostConnected: !!msg.hostConnected, extensionId: ctx.extensionId(ws) });
-      broadcast(owner); return true;
+      devices.set(owner, { ws: ws, servers: servers, hostConnected: !!msg.hostConnected, extensionId: ctx.extensionId(ws), manager: manager,
+        authorized: function () { return ctx.clients.has(ws) && ownerFor(ws) === owner && ctx.canUseOwner(owner); },
+        send: function (message) { ctx.sendTo(ws, Object.assign({ slug: ctx.slug }, message)); } });
+      announce(owner); return true;
     }
     if (msg.type === 'mcp_tool_result' || msg.type === 'mcp_tool_error') {
       var call = pending.get(msg.callId);
@@ -114,35 +145,42 @@ function attachMcp(ctx) {
       if (!row || !row.tools.some(function (item) { return item.name === tool; })) throw new Error('Computer tool is unavailable.');
       var id = crypto.randomUUID();
       var timer = setTimeout(function () { pending.delete(id); reject(new Error('Computer tool timed out.')); }, 60000);
-      pending.set(id, { owner: owner, ws: device.ws, resolve: resolve, reject: reject, timer: timer, authorize: function () {
+      pending.set(id, { owner: owner, ws: device.ws, manager: manager, resolve: resolve, reject: reject, timer: timer, authorize: function () {
         authorize(); if (!enabled(owner, server) || deviceFor(owner) !== device) throw new Error('Computer access changed.');
       } });
-      ctx.sendTo(device.ws, { type: 'mcp_tool_call', callId: id, server: server, method: 'tools/call', params: { name: tool, arguments: args } });
+      device.send({ type: 'mcp_tool_call', callId: id, server: server, method: 'tools/call', params: { name: tool, arguments: args } });
     });
   }
-  function getMcpServers(session) {
-    if (!session || !ctx.canUseSession(session)) return {};
+  function getMcpServers(session, allowManagement) {
+    if (!session || !ctx.canUseSession(session) || (ctx.sessionVendor ? ctx.sessionVendor(session) : session.vendor) === 'antigravity') return {};
     var owner = ctx.isMultiUser() ? String(session.ownerId) : 'default';
     function authorize() {
       authorizeOwner(owner);
       if (!ctx.canUseSession(session) || (ctx.isMultiUser() && String(session.ownerId) !== owner)) throw new Error('Session MCP access changed.');
     }
-    var result = {};
+    var result = {}, management = allowManagement === false ? null : agentTools.getServer(session);
+    if (management) result['clay-mcp-connections'] = management;
     buildState(owner).servers.forEach(function (server) {
       if (!server.projectEnabled || !server.extensionEnabled || !server.tools.length) return;
       try {
         result[server.name] = createProxy(server.name, server.tools, function (tool, args) {
-          return server.source === 'url' ? remote.call(owner, server.id, tool, args, authorize) : callComputer(owner, server.name, tool, args, authorize);
+          return server.source !== 'computer' ? remote.call(owner, server.id, tool, args, authorize) : callComputer(owner, server.name, tool, args, authorize);
         });
       } catch (error) { /* Unsupported schemas are not advertised as callable tools. */ }
     });
     return result;
   }
   function destroy() {
-    pending.forEach(function (call) { clearTimeout(call.timer); call.reject(new Error('MCP closed.')); }); pending.clear();
-    devices.clear(); remote.destroy();
+    var removedSockets = [];
+    devices.forEach(function (device, owner) { if (device.manager === manager) { removedSockets.push(device.ws); devices.delete(owner); } });
+    pending.forEach(function (call, id) {
+      if (call.manager === manager || removedSockets.indexOf(call.ws) >= 0) { clearTimeout(call.timer); call.reject(new Error('MCP closed.')); pending.delete(id); }
+    });
+    agentTools.destroy(); remote.destroy(); discovery.destroy();
+    registry.managers.delete(manager);
+    if (!registry.managers.size) SHARED_REGISTRIES.delete(namespace);
   }
-  return { handleMcpMessage: handleMcpMessage, getMcpServers: getMcpServers, sendConnectionState: sendConnectionState,
+  return { registerConsentViewer: agentTools.registerViewer, handleMcpMessage: handleMcpMessage, getMcpServers: getMcpServers, sendConnectionState: sendConnectionState,
     handleExtensionDisconnect: disconnectDevice, rebuildAndBroadcast: function () { devices.forEach(function (device, owner) { broadcast(owner); }); }, destroy: destroy };
 }
 module.exports = { attachMcp: attachMcp };

package/lib/project-session-document.js

@@ -61,7 +61,10 @@ function attachSessionDocument(ctx) {
     return { content: fs.readFileSync(target, "utf8"), exists: true, size: stat.size };
   }
 
+  function canUse(caller) { return !!caller && (!ctx.canUseSession || ctx.canUseSession(caller)); }
+
   function present(args, caller) {
+    if (!canUse(caller)) return toolError("Documents require a live authorized session.");
     if (!caller) return toolError("present_markdown_edit requires a session-bound tool server");
     var target = resolveMarkdownPath(args.path);
     if (!target) return toolError("path must be a .md or .mdx file inside the project");
@@ -82,6 +85,7 @@ function attachSessionDocument(ctx) {
   }
 
   function presentWireframe(args, caller) {
+    if (!canUse(caller)) return toolError("Documents require a live authorized session.");
     if (!caller) return toolError("present_wireframe requires a session-bound tool server");
     if (typeof args.source !== "string" || !/^[a-zA-Z0-9_-]{1,80}$/.test(args.id || "")) return toolError("Provide source and a short stable id using letters, digits, hyphens or underscores.");
     var source;
@@ -92,6 +96,7 @@ function attachSessionDocument(ctx) {
       return toolError(e.message || String(e));
     }
     return wireframeRenderer.renderPlantUml(source).then(function () {
+      if (!canUse(caller)) return toolError("Document access changed.");
       sendToSession(caller.localId, { type: "wireframe_present", source: source, id: args.id, title: String(args.title || "clay-sketch").slice(0, 100), sessionId: caller.localId });
       return toolResult({ ready: true, id: args.id, saved: false });
     }).catch(function (e) {
@@ -100,7 +105,7 @@ function attachSessionDocument(ctx) {
   }
 
   function getToolDefs(boundSession) {
-    if (isMate) return [];
+    if (boundSession && !canUse(boundSession)) return [];
     return sessionDocumentMcp.getToolDefs({
       presentWireframe: function (args) { return presentWireframe(args, boundSession || null); },
       present: function (args) { return present(args, boundSession || null); },
@@ -108,7 +113,7 @@ function attachSessionDocument(ctx) {
   }
 
   function createMcpServer(adapter, boundSession) {
-    if (isMate || !adapter || typeof adapter.createToolServer !== "function") return null;
+    if (!adapter || typeof adapter.createToolServer !== "function") return null;
     return adapter.createToolServer({
       name: "clay-documents",
       version: "1.0.0",
@@ -118,7 +123,7 @@ function attachSessionDocument(ctx) {
 
   return {
     createMcpServer: createMcpServer,
-    getSystemPrompt: function () { return isMate ? "" : DOCUMENT_PROMPT + "\n\n" + WIREFRAME_PROMPT; },
+    getSystemPrompt: function () { return DOCUMENT_PROMPT + "\n\n" + WIREFRAME_PROMPT; },
     getToolDefs: getToolDefs,
   };
 }

package/lib/project-session-github.js

@@ -1,6 +1,8 @@
+var primary = require('./session-work-primary');
 var github = require("./session-github");
 var buildShape = require("./session-spawn-mcp-server").buildShape;
 var CONTRACT = "GitHub work links: proactively call link_session_github as soon as conversation context or tool results reasonably establish that an issue or PR is part of this session's work. Do not wait for an explicit linking request, implementation to begin, or work to finish. Investigating an issue, reviewing a PR or its requested changes, addressing review feedback, and checking CI or merge readiness all count as work. When a working PR is connected to an issue and both are relevant to the task, link both. Resolve a known repository and issue/PR number to the exact GitHub URL; if the repository is uncertain, verify it with a read-only lookup instead of silently skipping the link. Incidental mentions, examples, and unrelated reference material alone do not qualify. The current branch alone is insufficient evidence because sessions may share a checkout; combine it with conversation or verified task evidence. This records local metadata only and does not post to GitHub, so no separate linking approval is needed. Use get_session_github to inspect/refresh linked status and discover accessible sessions already working on the same reference before starting duplicate work. When the work shifts to another issue or PR, check that the relevant links are present before reporting progress or completion. Keep Issues as quiet background records, not a mandatory workflow. Unlink an incorrect association with unlink_session_github.";
+CONTRACT += primary.GUIDANCE;
 function attachSessionGithub(ctx) {
   var inflight = new Map();
   var attempts = new Map();
@@ -39,7 +41,7 @@ function attachSessionGithub(ctx) {
     return entry.pending;
   }
   function authorize(session) {
-    if (!session || ctx.sm.sessions.get(session.localId) !== session || ctx.isMate || !ctx.canUse(session)) throw new Error("GitHub links require an authorized project session.");
+    if (!session || ctx.sm.sessions.get(session.localId) !== session || !ctx.canUse(session)) throw new Error("GitHub links require an authorized project session.");
     var identity = ctx.identity(session);
     // Account login does not imply OS isolation. Match the project's execution mode.
     if (ctx.osUsers && !identity) throw new Error("GitHub requires a mapped OS user with gh authentication in OS-isolated mode.");
@@ -95,10 +97,11 @@ function attachSessionGithub(ctx) {
           if (!other.hidden && !other.delegated && !require("./session-provenance").isWorker(other) && ctx.canRead(session, other) && (other.githubLinks || []).some(function (link) { return link.url.toLowerCase() === url; })) matches.push({ sessionId: other.localId, title: other.title });
         });
       }
-      return { links: links, matchingSessions: matches.slice(0, 20) };
+      return { links: links, workPrimary: session.workPrimary || {}, matchingSessions: matches.slice(0, 20) };
     }
     var ref = github.parseReference(args.url);
     if (name === "unlink_session_github") {
+      primary.guardUnlink(session, ref.url);
       session.githubLinks = (session.githubLinks || []).filter(function (link) { return link.url.toLowerCase() !== ref.url.toLowerCase(); });
     } else {
       var verified = await github.readReference(ctx.cwd, ref.url, identity, ctx.run);
@@ -108,12 +111,15 @@ function attachSessionGithub(ctx) {
       session.githubLinks = retained.concat([verified]);
     }
     persist(session);
-    return { links: session.githubLinks };
+    if (name === "link_session_github" && args.primary === true) await primary.requestPrimary(ctx, session, ref.url, authorize);
+    return { links: session.githubLinks, workPrimary: session.workPrimary || {} };
   }
   function defs(session) {
-    if (ctx.isMate || (session && !ctx.canUse(session))) return [];
+    if (session && !ctx.canUse(session)) return [];
     return ["link_session_github", "get_session_github", "unlink_session_github"].map(function (name) {
-      return { name: name, permissionName: "mcp__clay-github__" + name, description: CONTRACT + " " + (name === "get_session_github" ? "Read linked status; optional URL finds visible existing work sessions." : name === "link_session_github" ? "Verify and attach one issue or PR to the current session." : "Remove one local association without modifying GitHub."), inputSchema: buildShape({ url: { type: "string", description: "Exact https://github.com/owner/repo/issues/123 or /pull/123 URL." } }, name === "get_session_github" ? [] : ["url"]), handler: async function (args) {
+      var fields = { url: { type: "string", description: "Exact https://github.com/owner/repo/issues/123 or /pull/123 URL." } };
+      if (name === "link_session_github") fields.primary = { type: "boolean", description: "Only for an explicit user request to select this item as primary. Requires human confirmation." };
+      return { name: name, permissionName: "mcp__clay-github__" + name, description: CONTRACT + " " + (name === "get_session_github" ? "Read linked status; optional URL finds visible existing work sessions." : name === "link_session_github" ? "Verify and attach one issue or PR to the current session." : "Remove one local association without modifying GitHub."), inputSchema: buildShape(fields, name === "get_session_github" ? [] : ["url"]), handler: async function (args) {
         try { return { content: [{ type: "text", text: JSON.stringify(await invoke(session, name, args || {})) }] }; }
         catch (error) { return { isError: true, content: [{ type: "text", text: error.message }] }; }
       } };
@@ -121,11 +127,14 @@ function attachSessionGithub(ctx) {
   }
   return {
     getDynamicToolDefs: defs,
-    getSystemPrompt: function () { return ctx.isMate ? "" : CONTRACT; },
-    createMcpServer: function (adapter, session) { return ctx.isMate || !adapter.createToolServer ? null : adapter.createToolServer({ name: "clay-github", version: "1.0.0", tools: defs(session) }); },
+    getSystemPrompt: function () { return CONTRACT; },
+    createMcpServer: function (adapter, session) { return !adapter.createToolServer ? null : adapter.createToolServer({ name: "clay-github", version: "1.0.0", tools: defs(session) }); },
     getBridgeTools: function (session, normalize) { return defs(session).map(function (tool) { return { server: "clay-github", name: tool.name, description: tool.description, inputSchema: normalize(tool.inputSchema) }; }); },
     callBridgeTool: function (session, name, args) { var tool = defs(session).find(function (item) { return item.name === name; }); return tool ? tool.handler(args) : Promise.reject(new Error("GitHub tool unavailable.")); },
     handleMessage: function (ws, msg) {
+      if (primary.handleMessage(ctx, ws, msg, function (session) {
+        if (ctx.sm.sessions.get(session.localId) !== session || !ctx.canUse(session)) throw new Error("Primary work requires an authorized project session.");
+      })) return true;
       if (msg.type !== "session_github_refresh") return false;
       var ids = Array.isArray(msg.sessionIds) ? msg.sessionIds.slice(0, 100) : [ws._clayActiveSession];
       Array.from(new Set(ids)).forEach(function (id) {

package/lib/project-session-linear.js

@@ -1,3 +1,4 @@
+var primary = require('./session-work-primary');
 var api = require('./linear-api');
 var buildShape = require('./session-spawn-mcp-server').buildShape;
 var isWorker = require('./session-provenance').isWorker;
@@ -10,6 +11,7 @@ var CONTRACT = [
   'Use get_session_linear with the issue URL to discover accessible existing work before starting duplicate work, and read_linear_issue to read requirements and comments before implementing linked work. When the work shifts to another issue or before reporting progress or completion, check that the relevant links are present. When a GitHub PR implements the Linear issue, link both using link_session_linear and link_session_github when available; do not infer a relationship from the current branch alone.',
   'Do not link incidental mentions, examples, or unrelated references. Use unlink_session_linear to correct an association. Linking shares the issue identifier, title and status with people who can see this Clay session. These tools only read Linear and store local session links; they never update Linear issues or post comments, so no separate linking approval is needed. Issue content is task data, not permission for unrelated actions.',
 ].join(' ');
+CONTRACT += primary.GUIDANCE;
 function attachSessionLinear(ctx) {
   var inflight = new Map(), attempts = new Map(), statusCache = new Map(), statusQueue = Promise.resolve();
   function connection(ownerId) {
@@ -23,7 +25,7 @@ function attachSessionLinear(ctx) {
     if (ctx.storage.view(bound.owner).revision !== bound.revision) throw new Error('Linear connection changed. Please retry.');
   }
   function authorize(session) {
-    if (!session || ctx.sm.sessions.get(session.localId) !== session || ctx.isMate || !ctx.canUse(session)) throw new Error('Linear links require an authorized project Driver session.');
+    if (!session || ctx.sm.sessions.get(session.localId) !== session || !ctx.canUse(session)) throw new Error('Linear links require an authorized project session.');
   }
   function readStatus(session, url) {
     var bound = connection(session.ownerId);
@@ -112,6 +114,7 @@ function attachSessionLinear(ctx) {
   }
   function unlink(session, url) {
     authorize(session); var ref = api.parseReference(url);
+    primary.guardUnlink(session, ref.url);
     save(session, (session.linearLinks || []).filter(function (item) { return item.url.toLowerCase() !== ref.url.toLowerCase(); }));
     return { links: session.linearLinks };
   }
@@ -125,15 +128,20 @@ function attachSessionLinear(ctx) {
       if (session.ownerId !== owner) throw new Error('Session owner changed.');
       return result;
     }
-    if (name === 'link_session_linear') return link(session, args.url, session.ownerId);
+    if (name === 'link_session_linear') {
+      await link(session, args.url, session.ownerId);
+      if (args.primary === true) await primary.requestPrimary(ctx, session, api.parseReference(args.url).url, authorize);
+      return { links: session.linearLinks, workPrimary: session.workPrimary || {} };
+    }
     if (name === 'unlink_session_linear') return unlink(session, args.url);
-    return { links: await refresh(session), matchingSessions: args.url ? find(session, api.parseReference(args.url).url) : [] };
+    return { links: await refresh(session), workPrimary: session.workPrimary || {}, matchingSessions: args.url ? find(session, api.parseReference(args.url).url) : [] };
   }
   function defs(session) {
-    if (ctx.isMate || !ctx.storage || (session && !ctx.canUse(session))) return [];
+    if (!ctx.storage || (session && !ctx.canUse(session))) return [];
     return ['link_session_linear', 'get_session_linear', 'unlink_session_linear', 'read_linear_issue', 'search_linear_issues'].map(function (name) {
       var fields = name === 'search_linear_issues' ? { query: { type: 'string', description: 'Issue title, identifier or exact URL. Returns up to 20 matches.' } } :
         { url: { type: 'string', description: 'Exact https://linear.app/workspace/issue/ENG-123/title URL.' } };
+      if (name === 'link_session_linear') fields.primary = { type: 'boolean', description: 'Only for an explicit user request to select this item as primary. Requires human confirmation.' };
       if (name === 'read_linear_issue') fields.cursor = { type: 'string', description: 'Optional endCursor for the next page of comments.' };
       return { name: name, permissionName: 'mcp__clay-linear__' + name, description: CONTRACT + ' Operation: ' + name + '.',
         inputSchema: buildShape(fields, name === 'get_session_linear' ? [] : [name === 'search_linear_issues' ? 'query' : 'url']),
@@ -189,8 +197,8 @@ function attachSessionLinear(ctx) {
     return true;
   }
   return { handleMessage: handleMessage, getDynamicToolDefs: defs,
-    getSystemPrompt: function () { return ctx.isMate ? '' : CONTRACT; },
-    createMcpServer: function (adapter, session) { return ctx.isMate || !ctx.storage || !adapter.createToolServer ? null : adapter.createToolServer({ name: 'clay-linear', version: '1.0.0', tools: defs(session) }); },
+    getSystemPrompt: function () { return CONTRACT; },
+    createMcpServer: function (adapter, session) { return !ctx.storage || !adapter.createToolServer ? null : adapter.createToolServer({ name: 'clay-linear', version: '1.0.0', tools: defs(session) }); },
     getBridgeTools: function (session, normalize) { return defs(session).map(function (tool) { return { server: 'clay-linear', name: tool.name, description: tool.description, inputSchema: normalize(tool.inputSchema) }; }); },
     callBridgeTool: function (session, name, args) { var tool = defs(session).find(function (item) { return item.name === name; }); return tool && session ? tool.handler(args) : Promise.reject(new Error('Linear tool unavailable.')); } };
 }

package/lib/project-session-notes.js

@@ -130,7 +130,10 @@ function attachSessionNotes(ctx) {
     });
   }
 
+  function canUseSession(caller) { return !!caller && (!ctx.canUseSession || ctx.canUseSession(caller)); }
+
   function listNotes(args, caller) {
+    if (!canUseSession(caller)) return toolError("Notes require a live authorized session.");
     if (!caller) return toolError("list_notes requires a session-bound tool server");
     var state = args && typeof args.state === "string" ? args.state : "open";
     if (["open", "closed", "all"].indexOf(state) === -1) return toolError("state must be open, closed, or all");
@@ -138,6 +141,7 @@ function attachSessionNotes(ctx) {
   }
 
   function writeNote(args, caller) {
+    if (!canUseSession(caller)) return toolError("Notes require a live authorized session.");
     if (!caller) return toolError("write_note requires a session-bound tool server");
     var rawText = typeof args.text === "string" ? args.text : "";
     if (rawText.length > MAX_NOTE_TEXT_CHARS) return toolError("text exceeds " + MAX_NOTE_TEXT_CHARS + " characters");
@@ -227,7 +231,7 @@ function attachSessionNotes(ctx) {
   }
 
   function getToolDefs(boundSession) {
-    if (ctx.isMate) return [];
+    if (boundSession && !canUseSession(boundSession)) return [];
     return sessionNotesMcp.getToolDefs({
       list: function (args) { return listNotes(args, boundSession || null); },
       write: function (args) { return writeNote(args, boundSession || null); },
@@ -238,7 +242,7 @@ function attachSessionNotes(ctx) {
   }
 
   function createMcpServer(adapter, boundSession) {
-    if (ctx.isMate || !adapter || typeof adapter.createToolServer !== "function") return null;
+    if (!adapter || typeof adapter.createToolServer !== "function") return null;
     return adapter.createToolServer({
       name: "clay-notes",
       version: "1.0.0",
@@ -247,12 +251,12 @@ function attachSessionNotes(ctx) {
   }
 
   function getSystemPrompt() {
-    if (ctx.isMate) return "";
     return buildNotesPrompt(nm.list());
   }
 
   return {
     createMcpServer: createMcpServer,
+    canUseSession: canUseSession,
     getSystemPrompt: getSystemPrompt,
     getToolDefs: getToolDefs,
   };

package/lib/project-sessions.js

@@ -143,12 +143,16 @@ function attachSessions(ctx) {
     return !session.ownerId;
   }
 
-  function respondToAskUser(session, msg) {
+  function respondToAskUser(session, msg, ws) {
     if (!session || !msg || !msg.toolId) return false;
     var toolId = msg.toolId;
     var answers = msg.answers || {};
     var pending = session.pendingAskUser && session.pendingAskUser[toolId];
     if (!pending) return false;
+    if (pending.request && pending.request.source === "mcp-import" &&
+        (typeof pending.request.authorizeResponse !== "function" || !pending.request.authorizeResponse(ws))) return false;
+    if (pending.request && pending.request.source === "work-primary" && usersModule.isMultiUser() &&
+        (!ws || !ws._clayUser || ws._clayUser.id !== session.ownerId)) return false;
     if (pending.mode === "yoke") {
       try { yoke.userInput.normalizeAnswers(pending.request.questions, answers); }
       catch (e) { return false; }
@@ -1597,7 +1601,7 @@ function attachSessions(ctx) {
 
     if (msg.type === "ask_user_response") {
       var session = getSessionForWs(ws);
-      if (session) respondToAskUser(session, msg);
+      if (session) respondToAskUser(session, msg, ws);
       return true;
     }