clay-server 5.2.0-beta.8 → 5.2.0

package/lib/sdk-message-processor.js

@@ -46,6 +46,10 @@ function attachMessageProcessor(ctx) {
     sm.sendAndRecord(session, obj, clientObj);
   }
 
+  function observeQuota(session, message, observedAtMs) {
+    if (typeof sm.notifyQuotaObserved === "function") sm.notifyQuotaObserved(session, message, observedAtMs);
+  }
+
   function recordTurnActivity(session, activity) {
     // An authoritative input card owns progress until its request settles.
     var awaitingInput = ["pendingPermissions", "pendingAskUser", "pendingElicitations", "pendingUserDialogs"].some(function (key) {
@@ -892,7 +896,7 @@ function attachMessageProcessor(ctx) {
     } else if (parsed.yokeType === "rate_limit") {
       var info = parsed.rateLimitInfo;
       if (info.source === "account_snapshot") {
-        quotaSnapshots.recordQuotaSnapshot(session, info, sendAndRecord);
+        quotaSnapshots.recordQuotaSnapshot(session, info, sendAndRecord, observeQuota);
         return;
       }
       console.log("[sdk-bridge] rate_limit_event for session " + session.localId + ": status=" + info.status + " resetsAt=" + info.resetsAt + " isUsingOverage=" + info.isUsingOverage + " isProcessing=" + session.isProcessing);
@@ -907,6 +911,7 @@ function attachMessageProcessor(ctx) {
           resetsAt: info.resetsAt * 1000,
           status: info.status,
         });
+        observeQuota(session, { type: "rate_limit_usage", vendor: session.vendor || "claude", rateLimitType: info.rateLimitType, resetsAt: info.resetsAt * 1000, status: info.status }, Date.now());
       }
 
       // Warning/rejection handling (existing behavior)
@@ -925,6 +930,9 @@ function attachMessageProcessor(ctx) {
           overageResetsAt: info.overageResetsAt ? info.overageResetsAt * 1000 : null,
           overageDisabledReason: info.overageDisabledReason || null,
         });
+        if (info.rateLimitType && info.utilization) {
+          observeQuota(session, { type: "rate_limit", vendor: session.vendor || "claude", rateLimitType: info.rateLimitType, utilization: info.utilization }, Date.now());
+        }
         // Track rejection for auto-continue / scheduled message support
         if (info.status === "rejected" && info.resetsAt) {
           session.rateLimitResetsAt = info.resetsAt * 1000;

package/lib/sdk-quota-snapshot.js

@@ -1,4 +1,4 @@
-function recordQuotaSnapshot(session, info, sendAndRecord) {
+function recordQuotaSnapshot(session, info, sendAndRecord, observe) {
   var message = {
     type: "rate_limit_usage",
     sessionId: session.localId,
@@ -10,6 +10,9 @@ function recordQuotaSnapshot(session, info, sendAndRecord) {
     }),
   };
   if (Number.isFinite(info.observedAtMs)) message.observedAtMs = info.observedAtMs;
+  // The overview records every live observation, including an unchanged one:
+  // deduplication below only avoids re-recording identical history.
+  if (typeof observe === "function") observe(session, message, Number.isFinite(info.observedAtMs) ? info.observedAtMs : Date.now());
   var snapshots = session._quotaSnapshots || (session._quotaSnapshots = Object.create(null));
   var key = JSON.stringify([session.ownerId, session.vendor, info.limitId]);
   var serialized = JSON.stringify(message);
@@ -18,7 +21,22 @@ function recordQuotaSnapshot(session, info, sendAndRecord) {
   sendAndRecord(session, message);
 }
 
+// Observation listeners feed the owner-scoped vendor overview. They never
+// influence rejection handling or scheduling.
+function attachQuotaObservers(sm) {
+  // Idempotent: the processor and the overview may attach in either order.
+  if (typeof sm.addOnQuotaObserved === "function") return;
+  var listeners = [];
+  sm.addOnQuotaObserved = function (fn) { if (typeof fn === "function") listeners.push(fn); };
+  sm.notifyQuotaObserved = function (session, message, observedAtMs) {
+    for (var i = 0; i < listeners.length; i++) {
+      try { listeners[i](session, message, observedAtMs); } catch (e) { /* the overview is optional */ }
+    }
+  };
+}
+
 function attachQuotaSnapshots(sm) {
+  attachQuotaObservers(sm);
   if (typeof sm.addOnSessionViewed !== "function") return;
   sm.addOnSessionViewed(function (session, ws, send) {
     var seen = Object.create(null);
@@ -34,4 +52,4 @@ function attachQuotaSnapshots(sm) {
   });
 }
 
-module.exports = { recordQuotaSnapshot: recordQuotaSnapshot, attachQuotaSnapshots: attachQuotaSnapshots };
+module.exports = { recordQuotaSnapshot: recordQuotaSnapshot, attachQuotaSnapshots: attachQuotaSnapshots, attachQuotaObservers: attachQuotaObservers };

package/lib/server-github-stars.js

@@ -0,0 +1,39 @@
+// server-github-stars.js - GET /api/github-stars for the top-bar Star link.
+//
+// Read-only. Returns the cached public star count of the fixed Clay
+// repository (null when not yet known). No request input reaches GitHub, and
+// nothing about the caller is sent or stored.
+
+var githubStarCount = require("./github-star-count");
+
+function attachGithubStars(ctx) {
+  var cache = ctx.cache || githubStarCount.createGithubStarCount();
+
+  function json(res, status, body) {
+    res.writeHead(status, { "Content-Type": "application/json", "Cache-Control": "no-store" });
+    res.end(JSON.stringify(body));
+  }
+
+  function handleRequest(req, res, url) {
+    if (url !== "/api/github-stars") return false;
+    if (req.method !== "GET") {
+      res.writeHead(405, { "Content-Type": "application/json", "Allow": "GET" });
+      res.end(JSON.stringify({ error: "Method not allowed." }));
+      return true;
+    }
+    if (!ctx.isRequestAuthed(req)) {
+      json(res, 401, { error: "Sign in to continue." });
+      return true;
+    }
+    cache.get().then(function (snapshot) {
+      json(res, 200, snapshot);
+    }, function () {
+      json(res, 200, { repo: githubStarCount.REPO, stars: null, fetchedAt: null });
+    });
+    return true;
+  }
+
+  return { handleRequest: handleRequest };
+}
+
+module.exports = { attachGithubStars: attachGithubStars };

package/lib/server-global-ws.js

@@ -19,6 +19,9 @@
 var fs = require("fs");
 var path = require("path");
 var config = require("./config");
+var startProtocol = require("./project-start-protocol");
+var startReply = startProtocol.withRequestId;
+var browseMeta = startProtocol.browseMeta;
 
 // Mirrored from lib/project.js — keep in sync if entries change there.
 var IGNORED_DIRS = new Set([
@@ -79,8 +82,9 @@ function attachGlobalWs(opts) {
         parentDir = path.dirname(absTarget);
         prefix = path.basename(absTarget).toLowerCase();
       }
-      if (opts.canUsePath && !opts.canUsePath(ws._clayUser && ws._clayUser.id, parentDir)) {
-        sendTo(ws, { type: "browse_dir_result", entries: [], error: "Directory access is not permitted" });
+      var canList = function (candidate) { return !opts.canUsePath || opts.canUsePath(ws._clayUser && ws._clayUser.id, candidate); };
+      if (!canList(parentDir)) {
+        sendTo(ws, startReply(msg, { type: "browse_dir_result", path: msg.path, entries: [], error: "Directory access is not permitted" }));
         return;
       }
       try {
@@ -96,9 +100,9 @@ function attachGlobalWs(opts) {
           dirEntries.push({ name: d.name, path: path.join(parentDir, d.name) });
         }
         dirEntries.sort(function (a, b) { return a.name.localeCompare(b.name); });
-        sendTo(ws, { type: "browse_dir_result", path: msg.path, entries: dirEntries });
+        sendTo(ws, Object.assign(browseMeta(msg, parentDir, prefix, canList), { type: "browse_dir_result", path: msg.path, entries: dirEntries }));
       } catch (e) {
-        sendTo(ws, { type: "browse_dir_result", path: msg.path, entries: [], error: e.message });
+        sendTo(ws, startReply(msg, { type: "browse_dir_result", path: msg.path, entries: [], error: e.message }));
       }
       return;
     }
@@ -108,24 +112,24 @@ function attachGlobalWs(opts) {
       var addPath = (msg.path || "").replace(/^~/, config.REAL_HOME);
       var addAbs = path.resolve(addPath);
       if (opts.canUsePath && !opts.canUsePath(ws._clayUser && ws._clayUser.id, addAbs)) {
-        sendTo(ws, { type: "add_project_result", ok: false, error: "Directory access is not permitted" });
+        sendTo(ws, startReply(msg, { type: "add_project_result", ok: false, error: "Directory access is not permitted" }));
         return;
       }
       try {
         var addStat = fs.statSync(addAbs);
         if (!addStat.isDirectory()) {
-          sendTo(ws, { type: "add_project_result", ok: false, error: "Not a directory" });
+          sendTo(ws, startReply(msg, { type: "add_project_result", ok: false, error: "Not a directory" }));
           return;
         }
       } catch (e) {
-        sendTo(ws, { type: "add_project_result", ok: false, error: "Directory not found" });
+        sendTo(ws, startReply(msg, { type: "add_project_result", ok: false, error: "Directory not found" }));
         return;
       }
       if (typeof onAddProject === "function") {
         var result = onAddProject(addAbs, ws._clayUser);
-        sendTo(ws, Object.assign({}, result, { type: "add_project_result" }));
+        sendTo(ws, startReply(msg, Object.assign({}, result, { type: "add_project_result" })));
       } else {
-        sendTo(ws, { type: "add_project_result", ok: false, error: "Not supported" });
+        sendTo(ws, startReply(msg, { type: "add_project_result", ok: false, error: "Not supported" }));
       }
       return;
     }
@@ -135,7 +139,7 @@ function attachGlobalWs(opts) {
       if (ws._clayUser && usersModule) {
         var cpPerms = usersModule.getEffectivePermissions(ws._clayUser, osUsers);
         if (!cpPerms.createProject) {
-          sendTo(ws, { type: "add_project_result", ok: false, error: "You do not have permission to create projects" });
+          sendTo(ws, startReply(msg, { type: "add_project_result", ok: false, error: "You do not have permission to create projects" }));
           return;
         }
       }
@@ -144,14 +148,14 @@ function attachGlobalWs(opts) {
     if (msg.type === "create_project") {
       var createName = (msg.name || "").trim();
       if (!createName || !/^[a-zA-Z0-9_-]+$/.test(createName)) {
-        sendTo(ws, { type: "add_project_result", ok: false, error: "Invalid name. Use only letters, numbers, dashes, and underscores." });
+        sendTo(ws, startReply(msg, { type: "add_project_result", ok: false, error: "Invalid name. Use only letters, numbers, dashes, and underscores." }));
         return;
       }
       if (typeof onCreateProject === "function") {
         var createResult = onCreateProject(createName, ws._clayUser);
-        sendTo(ws, Object.assign({}, createResult, { type: "add_project_result" }));
+        sendTo(ws, startReply(msg, Object.assign({}, createResult, { type: "add_project_result" })));
       } else {
-        sendTo(ws, { type: "add_project_result", ok: false, error: "Not supported" });
+        sendTo(ws, startReply(msg, { type: "add_project_result", ok: false, error: "Not supported" }));
       }
       return;
     }
@@ -159,16 +163,16 @@ function attachGlobalWs(opts) {
     if (msg.type === "clone_project") {
       var cloneUrl = (msg.url || "").trim();
       if (!cloneUrl || (!/^https?:\/\//.test(cloneUrl) && !/^git@/.test(cloneUrl))) {
-        sendTo(ws, { type: "add_project_result", ok: false, error: "Invalid URL. Use https:// or git@ format." });
+        sendTo(ws, startReply(msg, { type: "add_project_result", ok: false, error: "Invalid URL. Use https:// or git@ format." }));
         return;
       }
-      sendTo(ws, { type: "clone_project_progress", status: "cloning" });
+      sendTo(ws, startReply(msg, { type: "clone_project_progress", status: "cloning" }));
       if (typeof onCloneProject === "function") {
         onCloneProject(cloneUrl, ws._clayUser, function (cloneResult) {
-          sendTo(ws, { type: "add_project_result", ok: cloneResult.ok, slug: cloneResult.slug, error: cloneResult.error });
+          sendTo(ws, startReply(msg, { type: "add_project_result", ok: cloneResult.ok, slug: cloneResult.slug, error: cloneResult.error }));
         });
       } else {
-        sendTo(ws, { type: "add_project_result", ok: false, error: "Not supported" });
+        sendTo(ws, startReply(msg, { type: "add_project_result", ok: false, error: "Not supported" }));
       }
       return;
     }

package/lib/server.js

@@ -507,6 +507,8 @@ function createServer(opts) {
   var linear = require('./server-linear').attachLinear({ users: users, getMultiUserFromReq: getMultiUserFromReq,
     isRequestAuthed: isRequestAuthed, CONFIG_DIR: CONFIG_DIR });
 
+  var githubStars = require('./server-github-stars').attachGithubStars({ isRequestAuthed: isRequestAuthed });
+
   var speech = serverSpeech.attachSpeech({ users: users, getMultiUserFromReq: getMultiUserFromReq,
     isRequestAuthed: isRequestAuthed, CONFIG_DIR: CONFIG_DIR, getAllowedOrigins: getAllowedOrigins });
 
@@ -925,6 +927,7 @@ function createServer(opts) {
 
     if (linear.handleRequest(req, res, fullUrl)) return;
     if (speech.handleRequest(req, res, fullUrl)) return;
+    if (githubStars.handleRequest(req, res, fullUrl)) return;
     if (networkSettings.handleRequest(req, res, fullUrl)) return;
     if (storageSettings.handleRequest(req, res, fullUrl)) return;
     if (settings.handleRequest(req, res, fullUrl)) return;
@@ -967,6 +970,13 @@ function createServer(opts) {
         res.end(auth.getAuthPage());
         return;
       }
+      // The standalone project list was removed. A legacy /projects link resolves
+      // through the same server-backed workspace selection as the root path.
+      if (fullUrl !== "/") {
+        res.writeHead(302, { "Location": "/", "Cache-Control": "no-store" });
+        res.end();
+        return;
+      }
       if (projects.size > 0) {
         var targetSlug = null;
         var reqUser = users.isMultiUser() ? getMultiUserFromReq(req) : null;
@@ -1590,6 +1600,7 @@ function createServer(opts) {
         return ctx.getSchedules().length;
       },
       canAccessProjectSlug: canUserAccessSlug,
+      onGetProjectAccess: onGetProjectAccess,
       canUsePath: canUsePath,
       onPresenceChange: broadcastPresenceChange,
       onProcessingChanged: broadcastProcessingChange,

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

@@ -1,6 +1,8 @@
 // Sticky-note memory tools for project sessions.
 
 var buildShape = require("./session-spawn-mcp-server").buildShape;
+var z;
+try { z = require("zod"); } catch (e) { z = null; }
 
 var MEMORY_CONTRACT =
   "The sticky-note board persists across sessions and is a user-facing artifact shared with people and Clay agents, not private agent scratch space. " +
@@ -8,15 +10,28 @@ var MEMORY_CONTRACT =
   "Use Sticky Notes for preferences, reminders, undeveloped ideas, or an explicit request to remember something; confirmed Issues also get short link notes as described below. For concrete actionable bugs, improvements, or deferred implementation, an authorized Project Driver should use Project Issues. If you lack Issues authority, route the work through an eligible Project Driver. Check active notes first when a duplicate is plausible. " +
   require("./issues-filing-guidance").NOTE_GUIDANCE +
   "Never create a note merely because work is important, lengthy, spans agents or restarts, or might help another agent. Do not record completed work, implementation details, test results, investigation logs, transient blockers, conversation summaries, or announcements of your own activity. When uncertain, do not write. " +
+  "One exception: when the user explicitly asks for a working checklist, keep that one native checklist note and check its items off as they are done; never start a checklist the user did not ask for. " +
   "Updates are visible too: update only when durable state materially changes. " +
   "A note is an attention item, so finishing it means closing it, never erasing it: call close_note once the thing it is asking for is done, and the note leaves the active board while the record stays and can be reopened. Do not turn a note into a completion log instead of closing it. " +
   "Put a concise plain-text title on the first line, stay focused on one topic, and include only the context needed for future action.";
 
+var CHECKLIST_USAGE =
+  " Native checklists: pass checklist: true to create one. The first line is the title and every later non-empty, non-heading line is an item; write items as '- [ ] task' and '- [x] task' for items already done. " +
+  "To check or uncheck items, call list_notes, then pass id, that note's current version and checks with the exact item keys it returned. " +
+  "Any change to a checklist note, switching checklist mode, or changing checks needs the current version; a stale version or unknown item is refused, so list again and retry. " +
+  "Text, saved checks and colour you do not change are kept, and switching mode never erases content. Change text and checks in separate calls. " +
+  "When rewriting a checklist's text, start from checklist.effectiveText so each line's - [x] marker carries its real completion; droppedSavedChecks lists saved checks whose exact line no longer exists.";
+
+var CHECK_ENTRY = z ? z.object({
+  item: z.string().describe("Exact item key from list_notes checklist.items[].item."),
+  checked: z.boolean().describe("true marks the item done; false marks it not done."),
+}) : null;
+
 function getToolDefs(handlers) {
   return [
     {
       name: "list_notes",
-      description: MEMORY_CONTRACT + " List the notes before writing when you need to avoid duplicates or inspect full memory beyond the injected summary. Lists open notes by default; pass state to see closed ones.",
+      description: MEMORY_CONTRACT + " List the notes before writing when you need to avoid duplicates or inspect full memory beyond the injected summary. Lists open notes by default; pass state to see closed ones. Each note includes its version and checklistMode; checklist notes also include checklist.items with exact item keys, each item's effective checked value (a saved check overrides the Markdown marker), its saved value, and completed/total counts.",
       inputSchema: buildShape({
         state: { type: "string", enum: ["open", "closed", "all"], description: "Which notes to list. Defaults to open, the notes still asking for action." },
       }),
@@ -24,12 +39,16 @@ function getToolDefs(handlers) {
     },
     {
       name: "write_note",
-      description: MEMORY_CONTRACT + " Create a new note, or update an existing note by id. For notes other than confirmed Issue link notes, apply this test: would the user likely choose to keep this visible on their board next week? If the answer is unclear, do not call this tool. The 20000-character limit is an abuse guard, not a target.",
+      description: MEMORY_CONTRACT + " Create a new note, or update an existing note by id. For notes other than confirmed Issue link notes and a working checklist the user explicitly asked for, apply this test: would the user likely choose to keep this visible on their board next week? If the answer is unclear, do not call this tool. The 20000-character limit is an abuse guard, not a target." + CHECKLIST_USAGE,
       inputSchema: buildShape({
         id: { type: "string", description: "Existing note id to update. Omit to create a note." },
-        text: { type: "string", description: "User-facing sticky-note text with a concise title on the first line and only durable, action-relevant context below it." },
+        text: { type: "string", description: "User-facing sticky-note text with a concise title on the first line and only durable, action-relevant context below it. Required when creating; omit on update to keep the current text." },
         color: { type: "string", enum: ["yellow", "blue", "green", "pink", "orange", "purple"], description: "Optional sticky-note color." },
-      }, ["text"]),
+        checklist: { type: "boolean", description: "true creates or switches to a native checklist, false switches back to an ordinary note. Switching keeps the text and saved checks." },
+        version: { type: "number", description: "The note's current version from list_notes. Required for any change to a checklist note, a checklist mode switch, or checks." },
+        // buildShape returns no fields when zod is unavailable.
+        checks: { schema: CHECK_ENTRY && z.array(CHECK_ENTRY).min(1).max(1000), description: "Checklist items to check or uncheck on an existing checklist note, using exact item keys from list_notes." },
+      }),
       handler: function (args) { return handlers.write(args || {}); },
     },
     {
@@ -60,6 +79,9 @@ function getToolDefs(handlers) {
 }
 
 module.exports = {
+  // 2: native checklist fields. Conversation-scoped catalogs older than this
+  // receive the current schema through exact-query recovery.
+  CATALOG_VERSION: 2,
   MEMORY_CONTRACT: MEMORY_CONTRACT,
   getToolDefs: getToolDefs,
 };

package/lib/session-notes-writes.js

@@ -0,0 +1,88 @@
+// Pure planning for agent sticky-note updates, including native checklists.
+// Every checklist-affecting write must name the note's current version and
+// exact item keys, so a stale view can never overwrite newer content or marks.
+
+var checklist = require("./notes-checklist");
+
+var MAX_CHECKS = 1000;
+
+function validateArgs(args) {
+  if (args.checklist !== undefined && typeof args.checklist !== "boolean") return "checklist must be true or false";
+  if (args.version !== undefined && !Number.isFinite(args.version)) return "version must be the number returned by list_notes";
+  if (args.checks === undefined) return null;
+  if (!Array.isArray(args.checks) || args.checks.length === 0 || args.checks.length > MAX_CHECKS) {
+    return "checks must be a non-empty array of at most " + MAX_CHECKS + " { item, checked } entries";
+  }
+  for (var i = 0; i < args.checks.length; i++) {
+    var entry = args.checks[i];
+    if (!entry || typeof entry !== "object" || typeof entry.item !== "string" || typeof entry.checked !== "boolean") {
+      return "each checks entry needs an item key from list_notes and checked true or false";
+    }
+  }
+  return null;
+}
+
+function staleError(note) {
+  return "note " + note.id + " has changed or the version is missing; call list_notes, review its current text and items, and retry with that version";
+}
+
+// Saved marks whose exact item line no longer exists after a text change.
+function droppedChecks(note, nextText) {
+  var kept = checklist.normalizeState(note.checklistState, nextText);
+  return checklist.describe(note).filter(function (entry) {
+    return entry.saved !== null && kept[decodeURIComponent(entry.item)] === undefined;
+  }).map(function (entry) {
+    return { text: entry.text, checked: entry.saved };
+  });
+}
+
+function planUpdate(note, args, text, color) {
+  var isChecklist = note.checklistMode === true;
+  var modeChange = typeof args.checklist === "boolean" && args.checklist !== isChecklist;
+  var hasText = typeof args.text === "string";
+  var hasChecks = Array.isArray(args.checks);
+  var needsVersion = isChecklist || modeChange || hasChecks;
+  if ((needsVersion || args.version !== undefined) && args.version !== note.updatedAt) return { error: staleError(note) };
+  if (hasText && !text) return { error: "text must not be empty; close the note instead of erasing it" };
+  if (hasText && hasChecks) return { error: "change text and checks in separate calls so item keys refer to one exact version" };
+
+  var changes = {};
+  var dropped = [];
+  if (hasText && text !== note.text) {
+    changes.text = text;
+    dropped = droppedChecks(note, text);
+    if (isChecklist && !modeChange) {
+      // Storage repeats the same exact-source and version guard atomically.
+      changes.checklistEdit = true;
+      changes.checklistSource = note.text;
+      changes.checklistVersion = note.updatedAt;
+    }
+  }
+  if (color && color !== note.color) changes.color = color;
+  if (modeChange) changes.checklistMode = args.checklist;
+
+  if (hasChecks) {
+    var resultMode = modeChange ? args.checklist : isChecklist;
+    if (!resultMode) return { error: "checks apply only to checklist notes; pass checklist: true to switch this note to a checklist without changing its text" };
+    var state = checklist.normalizeState(note.checklistState, note.text);
+    var requested = Object.create(null);
+    for (var i = 0; i < args.checks.length; i++) {
+      var found = checklist.findItem(note, args.checks[i].item);
+      if (!found) return { error: "checklist item not found in note " + note.id + "; call list_notes and use its current item keys" };
+      if (requested[found.key] !== undefined && requested[found.key] !== args.checks[i].checked) {
+        return { error: "checks names the same item more than once with different values" };
+      }
+      requested[found.key] = args.checks[i].checked;
+      state[found.key] = args.checks[i].checked;
+    }
+    changes.checklistState = state;
+  }
+
+  if (!hasText && !hasChecks && !color && args.checklist === undefined) {
+    return { error: "nothing to change; pass text, color, checklist, or checks" };
+  }
+  // An identical request is acknowledged without bumping the version.
+  return { changes: Object.keys(changes).length ? changes : null, droppedSavedChecks: dropped };
+}
+
+module.exports = { validateArgs: validateArgs, planUpdate: planUpdate, MAX_CHECKS: MAX_CHECKS };

package/lib/session-visibility.js

@@ -36,16 +36,29 @@ function handleDefaultChange(ctx, ws, msg) {
     defaultChangeResult(ctx, ws, msg || {}, { ok: false, error: "Session visibility default must be private or shared." });
     return true;
   }
-  if (msg.slug && msg.slug !== ctx.slug) {
-    defaultChangeResult(ctx, ws, msg, { ok: false, error: "Project settings access is not permitted" });
-    return true;
+  var denied = { ok: false, error: "Project settings access is not permitted" };
+  // The target is named by the client, so it is authorised here, never trusted:
+  // another project must be accessible to this account and its own access
+  // record (owner, worktree, Mate) is the one checked below.
+  var target = msg.slug && typeof msg.slug === "string" ? msg.slug : ctx.slug;
+  var access;
+  if (target === ctx.slug) {
+    if (ctx.isMate === true) { defaultChangeResult(ctx, ws, msg, { ok: false, error: "Not supported" }); return true; }
+    access = ctx.getProjectAccess ? ctx.getProjectAccess() : null;
+  } else {
+    if (/^mate-/.test(target) || typeof ctx.getTargetAccess !== "function" ||
+        typeof ctx.canAccessProjectSlug !== "function" || ctx.canAccessProjectSlug(ws, target) !== true) {
+      defaultChangeResult(ctx, ws, msg, denied);
+      return true;
+    }
+    access = ctx.getTargetAccess(target);
+    if (!access || access.error || access.isMate === true) { defaultChangeResult(ctx, ws, msg, denied); return true; }
   }
-  if (ctx.isMate === true || !ctx.usersModule || !ctx.usersModule.isMultiUser || !ctx.usersModule.isMultiUser()) {
+  if (!ctx.usersModule || !ctx.usersModule.isMultiUser || !ctx.usersModule.isMultiUser()) {
     defaultChangeResult(ctx, ws, msg, { ok: false, error: "Not supported" });
     return true;
   }
   var user = ws && ws._clayUser && ctx.usersModule.findUserById(ws._clayUser.id);
-  var access = ctx.getProjectAccess ? ctx.getProjectAccess() : null;
   if (access && access.isWorktree === true) {
     defaultChangeResult(ctx, ws, msg, { ok: false, error: "Worktrees inherit this setting from their parent project." });
     return true;
@@ -53,16 +66,15 @@ function handleDefaultChange(ctx, ws, msg) {
   var permissions = user && ctx.usersModule.getEffectivePermissions
     ? ctx.usersModule.getEffectivePermissions(user, ctx.osUsers) : {};
   var isOwner = !!(user && access && access.ownerId && access.ownerId === user.id);
-  var isAdmin = !!(user && user.role === "admin");
   if (!user || !permissions.projectSettings || !isOwner) {
-    defaultChangeResult(ctx, ws, msg, { ok: false, error: "Project settings access is not permitted" });
+    defaultChangeResult(ctx, ws, msg, denied);
     return true;
   }
   if (typeof ctx.opts.onSetProjectSessionVisibilityDefault !== "function") {
     defaultChangeResult(ctx, ws, msg, { ok: false, error: "Not supported" });
     return true;
   }
-  var result = ctx.opts.onSetProjectSessionVisibilityDefault(ctx.slug, msg.visibility);
+  var result = ctx.opts.onSetProjectSessionVisibilityDefault(target, msg.visibility);
   defaultChangeResult(ctx, ws, msg, { ok: !!(result && result.ok), visibility: result && result.visibility, error: result && result.error });
   return true;
 }

package/lib/sessions.js

@@ -166,6 +166,7 @@ function createSessionManager(opts) {
       if (session.codexLinearToolCatalogVersion) metaObj.codexLinearToolCatalogVersion = session.codexLinearToolCatalogVersion;
       if (session.codexSharedBrowserToolCatalogVersion) metaObj.codexSharedBrowserToolCatalogVersion = session.codexSharedBrowserToolCatalogVersion;
       if (session.codexIssuesToolCatalogVersion) metaObj.codexIssuesToolCatalogVersion = session.codexIssuesToolCatalogVersion;
+      if (session.codexNotesToolCatalogVersion) metaObj.codexNotesToolCatalogVersion = session.codexNotesToolCatalogVersion;
       if (session.model) metaObj.model = session.model;
       if (session.effort) metaObj.effort = session.effort;
       // Persist the session's "born" mode so TUI sessions reappear after a
@@ -358,6 +359,7 @@ function createSessionManager(opts) {
       session.codexLinearToolCatalogVersion = Number(m.codexLinearToolCatalogVersion || 0);
       session.codexSharedBrowserToolCatalogVersion = Number(m.codexSharedBrowserToolCatalogVersion || 0);
       session.codexIssuesToolCatalogVersion = Number(m.codexIssuesToolCatalogVersion || 0);
+      session.codexNotesToolCatalogVersion = Number(m.codexNotesToolCatalogVersion || 0);
       session.model = m.model || deriveSessionModel(loaded[i].history);
       session.effort = m.effort || null;
       if (m.loop) session.loop = m.loop;
@@ -789,8 +791,9 @@ function createSessionManager(opts) {
     return 0;
   }
 
-  function replayHistory(session, fromIndex, targetWs, transform) {
-    var _send = (targetWs && sendTo) ? function (obj) { sendTo(targetWs, obj); } : send;
+  function replayHistory(session, fromIndex, targetWs, transform, snapshotSend) {
+    var _send = snapshotSend || ((targetWs && sendTo) ? function (obj) { sendTo(targetWs, obj); } : send);
+    var sendHistory = snapshotSend && snapshotSend.history || _send;
     var total = session.history.length;
     if (typeof fromIndex !== "number") {
       if (total <= INITIAL_HISTORY_SIZE) {
@@ -800,7 +803,7 @@ function createSessionManager(opts) {
       }
     }
 
-    _send({ type: "history_meta", total: total, from: fromIndex });
+    sendHistory({ type: "history_meta", total: total, from: fromIndex });
 
     for (var i = fromIndex; i < total; i++) {
       var _item = session.history[i];
@@ -812,7 +815,7 @@ function createSessionManager(opts) {
       var normalizedItem = require("./yoke/usage").clientEvent(_item, session.vendor || "claude");
       var replayItem = transform ? transform(normalizedItem) : normalizedItem;
       if (replayItem && typeof replayItem === "object") replayItem = Object.assign({}, replayItem, { _historyIndex: i });
-      _send(replayItem);
+      sendHistory(replayItem);
     }
 
     // Find the last result message in the full history for accurate context data
@@ -833,16 +836,17 @@ function createSessionManager(opts) {
       }
     }
 
-    _send({ type: "history_done", controlHistoryRevision: require("./clay-control-target-projection").digest(session.history || []), sessionId: session.localId, sessionOriginId: session.sessionOriginId || null, lastUsage: lastUsage, lastModelUsage: lastModelUsage, lastCost: lastCost, lastStreamInputTokens: lastStreamInputTokens, context: lastContext, contextUsage: require("./yoke/usage").context(session.lastContextUsage, session.vendor || "claude") });
+    sendHistory({ type: "history_done", controlHistoryRevision: require("./clay-control-target-projection").digest(session.history || []), sessionId: session.localId, sessionOriginId: session.sessionOriginId || null, lastUsage: lastUsage, lastModelUsage: lastModelUsage, lastCost: lastCost, lastStreamInputTokens: lastStreamInputTokens, context: lastContext, contextUsage: require("./yoke/usage").context(session.lastContextUsage, session.vendor || "claude") });
     for (var vi = 0; vi < sessionViewedListeners.length; vi++) {
       try { sessionViewedListeners[vi](session, targetWs, _send); } catch (e) {}
     }
   }
 
-  function switchSession(localId, targetWs, transform) {
+  function switchSession(localId, targetWs, transform, snapshotSend, snapshotGuard) {
     var session = sessions.get(localId);
     if (!session) return;
     if (typeof onSessionHydrate === "function") onSessionHydrate(session);
+    if (snapshotGuard && !snapshotGuard()) return;
 
     // Pane sockets (split-view iframes) pin their session via switch_session
     // but must not move the project-global active pointer: reloads and
@@ -863,7 +867,7 @@ function createSessionManager(opts) {
     singleUserUnread[localId] = 0;
 
     // In multi-user mode with a specific client, only send to that client
-    var _send = (targetWs && sendTo) ? function (obj) { sendTo(targetWs, obj); } : send;
+    var _send = snapshotSend || ((targetWs && sendTo) ? function (obj) { sendTo(targetWs, obj); } : send);
 
     var _capsByVendor = capabilitiesByVendor || {};
     var _sessionVendor = session.vendor || defaultVendor || "claude";
@@ -876,7 +880,7 @@ function createSessionManager(opts) {
       || [];
     _send({ type: "slash_commands", commands: _vendorCmds, vendor: _sessionVendor });
     broadcastSessionList();
-    replayHistory(session, undefined, targetWs, transform);
+    replayHistory(session, undefined, targetWs, transform, snapshotSend);
 
     if (session.isProcessing) {
       _send({ type: "status", status: "processing" });
@@ -894,10 +898,15 @@ function createSessionManager(opts) {
         toolInput: p.toolInput,
         toolUseId: p.toolUseId,
         decisionReason: p.decisionReason,
+        defaultToNo: p.defaultToNo,
+        suppressAlwaysAllowRule: p.suppressAlwaysAllowRule,
+        mateId: p.mateId || undefined,
+        vendor: p.vendor || session.vendor || undefined,
       });
     }
 
     // Re-send active mention indicator so returning clients restore the mate avatar state
+    if (snapshotSend) require('./pane-pending-interactions').send(session, _send);
     if (session._mentionInProgress && session._mentionActiveMateId) {
       _send({ type: "mention_processing", mateId: session._mentionActiveMateId, active: true });
     }
@@ -1030,6 +1039,14 @@ function createSessionManager(opts) {
     }
   }
 
+  // An activated pane socket only accepts frames carrying its exact binding;
+  // the transport adds it, or withholds the frame if the binding is stale.
+  function sendLiveToSocket(ws, session, obj, data) {
+    if (!ws._clayPaneActivation) { ws.send(data); return; }
+    var panePayload = require("./pane-session-transport").outbound(ws, obj, session.localId);
+    if (panePayload) ws.send(JSON.stringify(panePayload));
+  }
+
   function doSendToSession(session, obj) {
     // Send to active clients without recording to history/disk (ephemeral data)
     if (sendEach) {
@@ -1038,7 +1055,7 @@ function createSessionManager(opts) {
         if (filterFn && !filterFn(session)) return;
         if (session.homeDebatePlanning === true) return;
         if (ws._clayActiveSession === session.localId && ws.readyState === 1) {
-          ws.send(data);
+          sendLiveToSocket(ws, session, obj, data);
         }
       });
     } else if (session.localId === activeSessionId) {
@@ -1070,7 +1087,7 @@ function createSessionManager(opts) {
         if (filterFn && !filterFn(session)) return;
         if (session.homeDebatePlanning === true) return;
         if (ws._clayActiveSession === session.localId) {
-          if (ws.readyState === 1) ws.send(data);
+          if (ws.readyState === 1) sendLiveToSocket(ws, session, outgoingObj, data);
         } else if (session.isProcessing && !session._ioThrottle) {
           if (!ioData) ioData = JSON.stringify({ type: "session_io", id: session.localId });
           if (ws.readyState === 1) ws.send(ioData);