clay-server 5.1.0-beta.1 → 6.0.0-beta.1

package/lib/sdk-quota-snapshot.js

@@ -0,0 +1,37 @@
+function recordQuotaSnapshot(session, info, sendAndRecord) {
+  var message = {
+    type: "rate_limit_usage",
+    sessionId: session.localId,
+    vendor: session.vendor,
+    source: "account_snapshot",
+    limitId: info.limitId,
+    quotaWindows: info.windows.map(function (window) {
+      return Object.assign({}, window, { resetsAt: window.resetsAt ? window.resetsAt * 1000 : null });
+    }),
+  };
+  var snapshots = session._quotaSnapshots || (session._quotaSnapshots = Object.create(null));
+  var key = JSON.stringify([session.ownerId, session.vendor, info.limitId]);
+  var serialized = JSON.stringify(message);
+  if (snapshots[key] === serialized) return;
+  snapshots[key] = serialized;
+  sendAndRecord(session, message);
+}
+
+function attachQuotaSnapshots(sm) {
+  if (typeof sm.addOnSessionViewed !== "function") return;
+  sm.addOnSessionViewed(function (session, ws, send) {
+    if (session.vendor !== "codex") return;
+    var seen = Object.create(null);
+    var history = session.history || [];
+    // A deduplicated snapshot may precede the initial page of chat history.
+    for (var i = history.length - 1; i >= 0; i--) {
+      var entry = history[i];
+      if (entry.type !== "rate_limit_usage" || entry.source !== "account_snapshot" || entry.vendor !== session.vendor) continue;
+      if (seen[entry.limitId]) continue;
+      seen[entry.limitId] = true;
+      send(Object.assign({}, entry, { sessionId: session.localId }));
+    }
+  });
+}
+
+module.exports = { recordQuotaSnapshot: recordQuotaSnapshot, attachQuotaSnapshots: attachQuotaSnapshots };

package/lib/server-admin.js

@@ -19,6 +19,17 @@ function attachAdmin(ctx) {
   var onProjectOwnerChanged = ctx.onProjectOwnerChanged;
 
   function handleRequest(req, res, fullUrl) {
+    var mateAccessRoute = /^\/api\/admin\/projects\/([^/]+)\/(visibility|owner|users|access)$/.exec(fullUrl);
+    if (mateAccessRoute) {
+      var target = projects.get(mateAccessRoute[1]);
+      var status = target && target.getStatus();
+      if ((status && status.isMate) || mateAccessRoute[1].indexOf("mate-") === 0) {
+        res.writeHead(403, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({ error: "Clay and Mate ownership is private and cannot be shared or transferred." }));
+        return true;
+      }
+    }
+
 
     // --- Admin API endpoints (multi-user mode only) ---
 

package/lib/server-appearance-settings.js

@@ -0,0 +1,71 @@
+var fs = require('fs');
+var path = require('path');
+
+function attachAppearanceSettings(ctx) {
+  var defaultPath = path.join(ctx.CONFIG_DIR, 'appearance-preferences.json');
+  function reply(res, code, data) {
+    res.writeHead(code, { 'Content-Type': 'application/json', 'Cache-Control': 'no-store' });
+    res.end(JSON.stringify(data));
+  }
+  function identity(req) {
+    if (!ctx.isRequestAuthed(req)) return null;
+    if (!ctx.users.isMultiUser()) return { id: 'default' };
+    return ctx.getMultiUserFromReq(req);
+  }
+  function read(user) {
+    var saved;
+    if (ctx.users.isMultiUser()) saved = user.appearancePreferences;
+    else {
+      try { saved = JSON.parse(fs.readFileSync(defaultPath, 'utf8')); }
+      catch (error) { if (error.code !== 'ENOENT') throw error; }
+    }
+    return Object.assign({ theme: saved && saved.theme || null, mode: saved && saved.mode || null, configured: !!saved }, saved && saved.lightTheme ? { lightTheme: saved.lightTheme } : {}, saved && saved.darkTheme ? { darkTheme: saved.darkTheme } : {});
+  }
+  function save(user, values) {
+    if (ctx.users.isMultiUser()) {
+      var data = ctx.users.loadUsers();
+      var current = data.users.find(function (entry) { return entry.id === user.id; });
+      if (!current) throw new Error('Account no longer available.');
+      current.appearancePreferences = values;
+      ctx.users.saveUsers(data);
+    } else {
+      fs.mkdirSync(ctx.CONFIG_DIR, { recursive: true });
+      fs.writeFileSync(defaultPath + '.tmp', JSON.stringify(values), { mode: 0o600 });
+      fs.renameSync(defaultPath + '.tmp', defaultPath);
+    }
+  }
+  function handleRequest(req, res, url) {
+    if (url !== '/api/user/appearance') return false;
+    var user = identity(req);
+    if (!user) { reply(res, 401, { error: 'Sign in to manage appearance.' }); return true; }
+    if (req.method === 'GET') {
+      try { reply(res, 200, read(user)); } catch (error) { reply(res, 500, { error: 'Could not read appearance preferences.' }); }
+      return true;
+    }
+    if (req.method !== 'PUT') { reply(res, 405, { error: 'Method not allowed.' }); return true; }
+    if (req.headers['x-clay-settings'] !== '1' || (req.headers['sec-fetch-site'] && ['same-origin', 'none'].indexOf(req.headers['sec-fetch-site']) < 0)) {
+      reply(res, 403, { error: 'Save preferences from Clay.' }); return true;
+    }
+    var body = ''; var tooLarge = false;
+    req.setEncoding('utf8');
+    req.on('data', function (chunk) { body += chunk; if (body.length > 4096 && !tooLarge) { tooLarge = true; reply(res, 413, { error: 'Request too large.' }); } });
+    req.on('end', function () {
+      if (tooLarge) return;
+      user = identity(req);
+      if (!user) { reply(res, 401, { error: 'Sign in again.' }); return; }
+      var values;
+      try { values = JSON.parse(body); } catch (error) { reply(res, 400, { error: 'Invalid JSON.' }); return; }
+      if (!values || (values.theme !== null && (typeof values.theme !== 'string' || !/^[a-zA-Z0-9_-]{1,120}$/.test(values.theme))) || [null, 'light', 'dark'].indexOf(values.mode) < 0) { reply(res, 400, { error: 'Invalid appearance preference.' }); return; }
+      if (['lightTheme', 'darkTheme'].some(function (field) { return values[field] !== undefined && (typeof values[field] !== 'string' || !/^[a-zA-Z0-9_-]{1,120}$/.test(values[field])); })) { reply(res, 400, { error: 'Invalid theme pair.' }); return; }
+      var previous;
+      try { previous = read(user); } catch (error) { reply(res, 500, { error: 'Could not read appearance preferences.' }); return; }
+      values = Object.assign({}, previous.lightTheme ? { lightTheme: previous.lightTheme } : {}, previous.darkTheme ? { darkTheme: previous.darkTheme } : {}, values);
+      values = Object.assign({ theme: values.theme, mode: values.mode }, values.lightTheme ? { lightTheme: values.lightTheme } : {}, values.darkTheme ? { darkTheme: values.darkTheme } : {});
+      try { save(user, values); reply(res, 200, values); }
+      catch (error) { reply(res, 500, { error: 'Could not save appearance preferences. Your draft is retained.' }); }
+    });
+    return true;
+  }
+  return { handleRequest: handleRequest };
+}
+module.exports = { attachAppearanceSettings: attachAppearanceSettings };

package/lib/server-home-chat-events.js

@@ -297,7 +297,7 @@ function transformEvent(event, mateId, session, requestId, stableSessionId) {
   }
   if (event.type === "debate_proposal_resolved" && event.proposalId) return Object.assign({ type: "home_debate_proposal_resolved", proposalId: event.proposalId, action: event.action || "cancel", error: event.error || "" }, metadata);
   if (session && session.mateCreationMode === true && event.type === "mate_creation_proposal" && event.proposal) return Object.assign({ type: "home_mate_creation_proposal", proposal: event.proposal }, metadata);
-  if (session && session.mateCreationMode === true && event.type === "mate_creation_proposal_resolved" && event.proposalId) return Object.assign({ type: "home_mate_creation_proposal_resolved", proposalId: event.proposalId, action: event.action || "cancel", mateId: event.mateId || null, mateName: event.mateName || null, error: event.error || "" }, metadata);
+  if (session && session.mateCreationMode === true && event.type === "mate_creation_proposal_resolved" && event.proposalId) return Object.assign({ type: "home_mate_creation_proposal_resolved", proposalId: event.proposalId, action: event.action || "cancel", createdMateId: event.mateId || null, mateName: event.mateName || null, error: event.error || "" }, metadata);
   if (session && session.debateSetupMode === true && event.type === "tool_executing" && event.name === "AskUserQuestion" && event.id && event.input) {
     return Object.assign({ type: "home_debate_question", toolId: event.id, questions: homeDebateQuestions(event.input) }, metadata);
   }

package/lib/server-home-chat.js

@@ -11,6 +11,7 @@ var homeChatEvents = require("./server-home-chat-events");
 var homeCapsuleCreation = require("./server-home-capsule-creation");
 var sessionTitlePolicy = require("./session-title-policy");
 var sessionProvenance = require("./session-provenance");
+var userPresence = require("./user-presence");
 var historyToHomeChat = homeChatEvents.historyToHomeChat;
 var transformEvent = homeChatEvents.transformEvent;
 function attachHomeChat(deps) {
@@ -232,6 +233,7 @@ function attachHomeChat(deps) {
       var payload = {
         type: "home_mate_history",
         mateId: found.mate.id,
+        localId: session.localId,
         sessionId: sessionReference(session),
         requestId: requestId || null,
         model: session.model || null,
@@ -279,13 +281,18 @@ function attachHomeChat(deps) {
     sendMessage(ws, { type: "home_mate_sessions_state", mateId: found.mate.id, sessions: listHomeSessions(found, userId) });
   }
 
+  function persistActiveSession(ws, found, userId, session) {
+    if (!ws || ws._clayPane || !found || !session) return;
+    userPresence.setPresence(found.slug, userId || "_default", userPresence.sessionIdForPersistence(session), null);
+  }
+
   var homeDebate = attachHomeDebatePlanning({
     findMateProject: findMateProject, resolveHomeSession: resolveHomeSession,
     sessionReference: sessionReference, setupTap: setupTap, sendHistory: sendHistory,
     sendSessionList: sendSessionList, sendError: sendError, sendModelError: sendModelError,
-    homeModels: homeModels, isActorLive: isActorLive,
+    homeModels: homeModels, isActorLive: isActorLive, persistActiveSession: persistActiveSession,
   });
-  var homeMateCreation = attachHomeMateCreation({ findMateProject: findMateProject, resolveHomeSession: resolveHomeSession, sessionReference: sessionReference, setupTap: setupTap, sendHistory: sendHistory, sendSessionList: sendSessionList, sendError: sendError, sendModelError: sendModelError, homeModels: homeModels, isActorLive: isActorLive });
+  var homeMateCreation = attachHomeMateCreation({ findMateProject: findMateProject, resolveHomeSession: resolveHomeSession, sessionReference: sessionReference, setupTap: setupTap, sendHistory: sendHistory, sendSessionList: sendSessionList, sendError: sendError, sendModelError: sendModelError, homeModels: homeModels, isActorLive: isActorLive, persistActiveSession: persistActiveSession });
   var homeClayEntry = attachHomeClayEntry({ findMateProject: findMateProject, ownsSession: ownsSession, sessionReference: sessionReference, setupSearchTap: setupSearchTap, sendHistory: sendHistory, sendSessionList: sendSessionList, sendError: sendError, sendModelError: sendModelError, homeModels: homeModels, isActorLive: isActorLive });
 
   async function openExactSession(ws, found, userId, selected, msg) {
@@ -591,6 +598,21 @@ function attachHomeChat(deps) {
     teardownTap(ws);
     teardownTap(ws, "_searchClayTap");
   }
-  return { handleMessage: handleMessage, handleDisconnection: handleDisconnection, findMateProject: findMateProject };
+  function resolveMateSessionDefaults(ws, userId, mateId) {
+    var found = findMateProject(userId, mateId, false);
+    if (!found) return Promise.reject(new Error("Mate is no longer available."));
+    try {
+      found = assertFreshFound(ws, found, userId);
+    } catch (error) {
+      return Promise.reject(error);
+    }
+    return homeModels.resolveMateModel(ws, found, userId, { useDefault: true });
+  }
+  return {
+    handleMessage: handleMessage,
+    handleDisconnection: handleDisconnection,
+    findMateProject: findMateProject,
+    resolveMateSessionDefaults: resolveMateSessionDefaults,
+  };
 }
 module.exports = { attachHomeChat: attachHomeChat };

package/lib/server-home-debate-planning.js

@@ -91,14 +91,17 @@ function attachHomeDebatePlanning(ctx) {
     if (!liveFound || liveFound.ctx !== found.ctx || !liveFound.mate || liveFound.mate.builtinKey !== "clay") throw new Error("Clay is no longer available.");
     var liveManager = liveFound.ctx.getSessionManager();
     if (!liveManager || liveManager !== manager || !liveFound.ctx.sdk) throw new Error("Clay conversation is no longer available.");
-    var session = manager.createSession({ ownerId: userId, vendor: resolved.vendor, model: resolved.model, effort: resolved.effort || null }, null);
+    var session = manager.createSessionRaw({ ownerId: userId, vendor: resolved.vendor, model: resolved.model, effort: resolved.effort || null });
     session.title = PLANNING_TITLE;
     session.titleManuallySet = true;
     session.debateSetupMode = true;
     session.homeDebatePlanning = true;
     session.homeDebatePhase = "planning";
     session.homeDebateInitialTopic = normalizeInitialTopic(msg.topic);
+    if (typeof manager.saveSessionFile === "function" && manager.saveSessionFile(session) === false) throw new Error("The debate setup could not be saved. Try again.");
     if (requestId) ws._homeDebatePlanningRequests[requestId] = session.localId;
+    manager.switchSession(session.localId, ws);
+    if (typeof ctx.persistActiveSession === "function") ctx.persistActiveSession(ws, liveFound, userId, session);
     ctx.setupTap(ws, liveFound, session.localId, requestId);
     ctx.sendHistory(ws, liveFound, session, requestId);
     ctx.sendSessionList(ws, liveFound, userId);

package/lib/server-home-debates.js

@@ -105,6 +105,8 @@ function attachHomeDebates(deps) {
         var lastActivity = typeof session.lastActivity === "number" ? session.lastActivity : createdAt;
         debates.push({
           mateId: found.mate.id,
+          projectSlug: found.slug,
+          localId: session.localId,
           sessionId: sessionReference(session),
           title: details.topic || "Debate planning",
           topic: details.topic,

package/lib/server-home-mate-creation.js

@@ -164,14 +164,17 @@ function attachHomeMateCreation(ctx) {
     if (!liveFound || liveFound.ctx !== found.ctx || !liveFound.mate || liveFound.mate.builtinKey !== "clay") throw new Error("Clay is no longer available.");
     var liveManager = liveFound.ctx.getSessionManager();
     if (!liveManager || liveManager !== manager || !liveFound.ctx.sdk) throw new Error("Clay conversation is no longer available.");
-    var session = manager.createSession({ ownerId: userId, vendor: resolved.vendor, model: resolved.model, effort: resolved.effort || null }, null);
+    var session = manager.createSessionRaw({ ownerId: userId, vendor: resolved.vendor, model: resolved.model, effort: resolved.effort || null });
     session.title = TITLE;
     session.titleManuallySet = true;
     session.mateCreationMode = true;
     session.homeMateCreationPhase = "interview";
+    if (typeof manager.saveSessionFile === "function" && manager.saveSessionFile(session) === false) throw new Error("The Mate interview could not be saved. Try again.");
     if (requestId) ws._homeMateCreationRequests[requestId] = session.localId;
     manager.sendAndRecord(session, { type: MARKER, internal: true });
     manager.sendAndRecord(session, { type: "tool_executing", name: "AskUserQuestion", id: firstQuestionId(session), input: { questions: [FIRST_QUESTION] } });
+    manager.switchSession(session.localId, ws);
+    if (typeof ctx.persistActiveSession === "function") ctx.persistActiveSession(ws, liveFound, userId, session);
     ctx.setupTap(ws, liveFound, session.localId, requestId);
     ctx.sendHistory(ws, liveFound, session, requestId);
     ctx.sendSessionList(ws, liveFound, userId);

package/lib/server-linear.js

@@ -10,39 +10,45 @@ function attachLinear(ctx) {
   }
   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/linear/connection') return false;
+    var match = /^\/api\/linear\/connections(?:\/([a-zA-Z0-9_-]{1,64}))?$/.exec(url);
+    if (url !== '/api/linear/connection' && !match) return false;
+    var connectionId = match && match[1];
+    if (match && !connectionId && req.method !== 'GET') { json(res, 405, { error: 'Method not allowed.' }); return true; }
     var id = owner(req);
     if (!id) { json(res, 401, { error: 'Sign in to connect Linear.' }); return true; }
     var origin = req.headers.origin;
     try { if (req.headers['sec-fetch-site'] === 'cross-site' || (origin && new URL(origin).host !== req.headers.host)) throw new Error(); }
     catch (error) { json(res, 403, { error: 'Invalid request origin.' }); return true; }
     if (req.method === 'GET') {
-      try { json(res, 200, storage.view(id)); } catch (error) { json(res, 500, { error: 'Could not read Linear connection.' }); }
+      try { json(res, 200, match && !connectionId ? { connections: storage.list(id) } : storage.view(id, connectionId)); } catch (error) { json(res, 500, { error: 'Could not read Linear connection.' }); }
       return true;
     }
     if (req.method !== 'PUT' && req.method !== 'DELETE') { json(res, 405, { error: 'Method not allowed.' }); return true; }
     // A disconnect or newer save invalidates an older validation in flight.
-    var operation = {}; pending.set(id, operation);
+    var operation = {}, pendingId = id + ':' + (connectionId || 'default'); pending.set(pendingId, operation);
     var chunks = [], size = 0;
     req.on('data', function (chunk) { size += chunk.length; if (size <= 8192) chunks.push(chunk); });
     req.on('end', async function () {
       try {
         if (size > 8192) throw new Error('Request is too large.');
-        var token = null, workspace = null;
+        var token = null, workspace = null, name;
         if (req.method === 'PUT') {
           var body = JSON.parse(Buffer.concat(chunks).toString('utf8'));
+          name = body.name;
+          if (match && (typeof name !== 'string' || !name.trim() || name.trim().length > 80)) throw new Error('Invalid connection name.');
+          if (match && !body.key) body.key = storage.key(id, connectionId);
           if (typeof body.key !== 'string' || !body.key.trim() || body.key.length > 4096 || /[\r\n]/.test(body.key)) throw new Error('Enter a valid Linear API key.');
           token = body.key.trim();
           var data = await (ctx.query || api.query)(token, 'query ClayConnection { organization { id name urlKey } }');
           if (!data.organization || !data.organization.id) throw new Error('Linear workspace is unavailable.');
           workspace = { id: data.organization.id, name: data.organization.name, slug: data.organization.urlKey };
         }
-        if (pending.get(id) !== operation || owner(req) !== id || res.destroyed) throw new Error('Connection changed. Please try again.');
-        json(res, 200, storage.save(id, token, workspace));
+        if (pending.get(pendingId) !== operation || owner(req) !== id || res.destroyed) throw new Error('Connection changed. Please try again.');
+        json(res, 200, storage.save(id, token, workspace, connectionId, name));
       } catch (error) { if (!res.destroyed) json(res, 400, { error: 'Could not update Linear connection. Check your API key and try again.' }); }
-      finally { if (pending.get(id) === operation) pending.delete(id); }
+      finally { if (pending.get(pendingId) === operation) pending.delete(pendingId); }
     });
-    req.on('error', function () { if (pending.get(id) === operation) pending.delete(id); });
+    req.on('error', function () { if (pending.get(pendingId) === operation) pending.delete(pendingId); });
     return true;
   }
   return { handleRequest: handleRequest, storage: storage };

package/lib/server-mate-instructions.js

@@ -0,0 +1,44 @@
+// Owner-scoped identity editing; generated instruction sections stay intact.
+var fs = require('fs');
+var path = require('path');
+var crypto = require('crypto');
+
+function revision(content) { return crypto.createHash('sha256').update(content).digest('hex'); }
+function handleMateInstructions(mates, ws, msg, userId) {
+  if (msg.type !== 'mate_instructions_get' && msg.type !== 'mate_instructions_set') return false;
+  var reply = {type: 'mate_instructions_result', mateId: msg.mateId, requestId: msg.requestId, operation: msg.type === 'mate_instructions_set' ? 'save' : 'read', ok: false};
+  try {
+    var ctx = mates.buildMateCtx(userId);
+    if (typeof msg.mateId !== 'string' || !mates.isMateIdFormat(msg.mateId) || !mates.getMate(ctx, msg.mateId)) throw new Error('Mate not found.');
+    var directory = mates.getMateDir(ctx, msg.mateId);
+    var file = path.join(directory, 'CLAUDE.md');
+    if (!fs.lstatSync(file).isFile()) throw new Error('Mate instructions are unavailable.');
+    var content = fs.readFileSync(file, 'utf8');
+    var identity = mates.extractIdentity(content);
+    if (msg.type === 'mate_instructions_set') {
+      if (msg.revision !== revision(identity)) {
+        reply.conflict = true;
+        throw new Error('The prompt changed elsewhere. Reload the saved prompt before applying your edits.');
+      }
+      if (typeof msg.content !== 'string' || msg.content.trim().length < 50 || Buffer.byteLength(msg.content, 'utf8') > 131072) throw new Error('Use a prompt between 50 characters and 128 KB.');
+      var next = msg.content.trimEnd();
+      if (mates.extractIdentity(next) !== next) throw new Error('System-managed instruction sections cannot be included in the editable prompt.');
+      var temporary = file + '.settings-' + crypto.randomBytes(8).toString('hex');
+      try {
+        fs.writeFileSync(temporary, next + content.slice(identity.length), {encoding: 'utf8', mode: fs.statSync(file).mode & 511, flag: 'wx'});
+        fs.renameSync(temporary, file);
+      } finally { if (fs.existsSync(temporary)) fs.unlinkSync(temporary); }
+      // The canonical save succeeds independently of best-effort audit copies.
+      try { mates.backupIdentity(directory, next); mates.logIdentityChange(directory, 'user_settings', next, identity); } catch (error) {}
+      identity = next;
+    }
+    reply.ok = true;
+    reply.content = identity;
+    reply.revision = revision(identity);
+  } catch (error) {
+    reply.error = error.code === 'ENOENT' ? 'Mate instructions are unavailable.' : error.message;
+  }
+  ws.send(JSON.stringify(reply));
+  return true;
+}
+module.exports = {handleMateInstructions: handleMateInstructions};

package/lib/server-mates.js

@@ -1,5 +1,6 @@
 var fs = require("fs");
 var path = require("path");
+var handleMateInstructions = require('./server-mate-instructions').handleMateInstructions;
 var readyCreation = require("./mate-ready-creation");
 
 function attachMates(ctx) {
@@ -106,6 +107,8 @@ function attachMates(ctx) {
       userId = "default";
     }
 
+    if (handleMateInstructions(mates, ws, msg, userId)) return true;
+
     if (msg.type === "mate_create") {
       if (!msg.seedData) return true;
       try {
@@ -229,6 +232,7 @@ function attachMates(ctx) {
         projects.forEach(function (pCtx) {
           pCtx.forEachClient(function (otherWs) {
             if (otherWs === ws) return;
+            if (users.isMultiUser() && (!otherWs._clayUser || otherWs._clayUser.id !== userId)) return;
             if (otherWs.readyState !== 1) return;
             otherWs.send(JSON.stringify({ type: "mate_deleted", mateId: msg.mateId, availableBuiltins: availableBuiltins3 }));
           });
@@ -295,17 +299,22 @@ function attachMates(ctx) {
     if (msg.type === "mate_update") {
       if (!msg.mateId || !msg.updates) return true;
       if (Object.prototype.hasOwnProperty.call(msg.updates, "model")) {
-        ws.send(JSON.stringify({ type: "mate_error", error: "Use the Mate model selector to change this setting." }));
+        ws.send(JSON.stringify({ type: "mate_error", mateId: msg.mateId, error: "Use the Mate model selector to change this setting." }));
         return true;
       }
       var mateCtx7 = mates.buildMateCtx(userId);
       var updated = mates.updateMate(mateCtx7, msg.mateId, msg.updates);
+      if (updated && updated.error) {
+        ws.send(JSON.stringify({ type: "mate_error", mateId: msg.mateId, requestId: msg.requestId, error: updated.error }));
+        return true;
+      }
       if (updated) {
-        ws.send(JSON.stringify({ type: "mate_updated", mate: updated }));
+        ws.send(JSON.stringify({ type: "mate_updated", mate: updated, requestId: msg.requestId }));
         // Broadcast update
         projects.forEach(function (pCtx) {
           pCtx.forEachClient(function (otherWs) {
             if (otherWs === ws) return;
+            if (users.isMultiUser() && (!otherWs._clayUser || otherWs._clayUser.id !== userId)) return;
             if (otherWs.readyState !== 1) return;
             otherWs.send(JSON.stringify({ type: "mate_updated", mate: updated }));
           });
@@ -313,7 +322,7 @@ function attachMates(ctx) {
         // Re-enforce team sections across all mate projects so roster stays current
         refreshTeamSections(mateCtx7);
       } else {
-        ws.send(JSON.stringify({ type: "mate_error", error: "Mate not found" }));
+        ws.send(JSON.stringify({ type: "mate_error", mateId: msg.mateId, requestId: msg.requestId, error: "Mate not found" }));
       }
       return true;
     }

package/lib/server-notification-settings.js

@@ -0,0 +1,67 @@
+var fs = require('fs');
+var path = require('path');
+
+function attachNotificationSettings(ctx) {
+  var defaultPath = path.join(ctx.CONFIG_DIR, 'notification-preferences.json');
+  function reply(res, code, data) {
+    res.writeHead(code, { 'Content-Type': 'application/json', 'Cache-Control': 'no-store' });
+    res.end(JSON.stringify(data));
+  }
+  function identity(req) {
+    if (!ctx.isRequestAuthed(req)) return null;
+    if (!ctx.users.isMultiUser()) return { id: 'default' };
+    return ctx.getMultiUserFromReq(req);
+  }
+  function read(user) {
+    var saved;
+    if (ctx.users.isMultiUser()) saved = user.notificationPreferences;
+    else {
+      try { saved = JSON.parse(fs.readFileSync(defaultPath, 'utf8')); }
+      catch (error) { if (error.code !== 'ENOENT') throw error; }
+    }
+    return { alert: !saved || saved.alert !== false, sound: !saved || saved.sound !== false, configured: !!saved };
+  }
+  function save(user, values) {
+    if (ctx.users.isMultiUser()) {
+      var data = ctx.users.loadUsers();
+      var current = data.users.find(function (entry) { return entry.id === user.id; });
+      if (!current) throw new Error('Account no longer available.');
+      current.notificationPreferences = values;
+      ctx.users.saveUsers(data);
+    } else {
+      fs.mkdirSync(ctx.CONFIG_DIR, { recursive: true });
+      fs.writeFileSync(defaultPath + '.tmp', JSON.stringify(values), { mode: 0o600 });
+      fs.renameSync(defaultPath + '.tmp', defaultPath);
+    }
+  }
+  function handleRequest(req, res, url) {
+    if (url !== '/api/user/notifications') return false;
+    var user = identity(req);
+    if (!user) { reply(res, 401, { error: 'Sign in to manage notifications.' }); return true; }
+    if (req.method === 'GET') {
+      try { reply(res, 200, read(user)); } catch (error) { reply(res, 500, { error: 'Could not read notification preferences.' }); }
+      return true;
+    }
+    if (req.method !== 'PUT') { reply(res, 405, { error: 'Method not allowed.' }); return true; }
+    if (req.headers['x-clay-settings'] !== '1' || (req.headers['sec-fetch-site'] && ['same-origin', 'none'].indexOf(req.headers['sec-fetch-site']) < 0)) {
+      reply(res, 403, { error: 'Save preferences from Clay.' }); return true;
+    }
+    var body = ''; var tooLarge = false;
+    req.setEncoding('utf8');
+    req.on('data', function (chunk) { body += chunk; if (body.length > 4096 && !tooLarge) { tooLarge = true; reply(res, 413, { error: 'Request too large.' }); } });
+    req.on('end', function () {
+      if (tooLarge) return;
+      user = identity(req);
+      if (!user) { reply(res, 401, { error: 'Sign in again.' }); return; }
+      var values;
+      try { values = JSON.parse(body); } catch (error) { reply(res, 400, { error: 'Invalid JSON.' }); return; }
+      if (!values || typeof values.alert !== 'boolean' || typeof values.sound !== 'boolean') { reply(res, 400, { error: 'Alert and sound must be booleans.' }); return; }
+      values = { alert: values.alert, sound: values.sound };
+      try { save(user, values); reply(res, 200, values); }
+      catch (error) { reply(res, 500, { error: 'Could not save notification preferences. Your draft is retained.' }); }
+    });
+    return true;
+  }
+  return { handleRequest: handleRequest };
+}
+module.exports = { attachNotificationSettings: attachNotificationSettings };

package/lib/server-palette.js

@@ -11,7 +11,7 @@ function attachPalette(ctx) {
     if (!user) return { visibility: "public" };
     if (typeof canUserAccessSlug !== "function" || !canUserAccessSlug(user.id, slug)) return null;
     if (status && status.isMate) {
-      return { visibility: "private", ownerId: status.projectOwnerId || null, allowedUsers: [] };
+      return { isMate: true, visibility: "private", ownerId: status.projectOwnerId || null, allowedUsers: [] };
     }
     var access = onGetProjectAccess ? onGetProjectAccess(slug) : null;
     return access && !access.error ? access : null;

package/lib/server-settings.js

@@ -1,6 +1,7 @@
 var fs = require("fs");
 var path = require("path");
 var { attachExperimentalSettings } = require("./server-experimental-settings");
+var dicebearAvatar = require("./dicebear-avatar");
 
 function attachSettings(ctx) {
   var users = ctx.users;
@@ -11,10 +12,36 @@ function attachSettings(ctx) {
   var CONFIG_DIR = ctx.CONFIG_DIR;
 
   var profilePath = path.join(CONFIG_DIR, "profile.json");
+  var appearanceSettings = require('./server-appearance-settings').attachAppearanceSettings(ctx);
+  var notificationSettings = require('./server-notification-settings').attachNotificationSettings(ctx);
   var experimentalSettings = attachExperimentalSettings(ctx);
 
   function handleRequest(req, res, fullUrl) {
+    if (appearanceSettings.handleRequest(req, res, fullUrl)) return true;
+    if (notificationSettings.handleRequest(req, res, fullUrl)) return true;
     if (experimentalSettings.handleRequest(req, res, fullUrl)) return true;
+    // Render historical avatar styles locally so profile seeds never leave Clay.
+    if (req.method === "GET" && fullUrl === "/api/generated-avatar") {
+      var avatarParams = new URL(req.url || fullUrl, "http://localhost").searchParams;
+      var avatarStyle = avatarParams.get("style") || "";
+      if (!dicebearAvatar.isSupportedStyle(avatarStyle)) {
+        res.writeHead(404, { "Content-Type": "application/json" });
+        res.end('{"error":"Unknown avatar style"}');
+        return true;
+      }
+      dicebearAvatar.renderAvatar(avatarStyle, avatarParams.get("seed") || "", avatarParams.get("size")).then(function (svg) {
+        res.writeHead(200, {
+          "Content-Type": "image/svg+xml; charset=utf-8",
+          "Cache-Control": "private, max-age=31536000, immutable",
+          "X-Content-Type-Options": "nosniff",
+        });
+        res.end(svg);
+      }).catch(function () {
+        res.writeHead(500, { "Content-Type": "application/json" });
+        res.end('{"error":"Avatar generation failed"}');
+      });
+      return true;
+    }
     // GET /api/profile
     if (req.method === "GET" && fullUrl === "/api/profile") {
       if (users.isMultiUser()) {
@@ -31,6 +58,7 @@ function attachSettings(ctx) {
         profile.pinEnabled = !!mu.pinHash;
         profile.autoContinueOnRateLimit = !!mu.autoContinueOnRateLimit;
         profile.chatLayout = mu.chatLayout || "channel";
+        profile.projectMateFilterMode = users.getProjectMateFilterMode(mu.id);
         profile.mateOnboardingShown = !!mu.mateOnboardingShown;
         profile.matesEnabled = mu.matesEnabled === true;
         profile.capsulesEnabled = users.getCapsulesEnabled(mu.id);
@@ -55,6 +83,7 @@ function attachSettings(ctx) {
         var dc = opts.onGetDaemonConfig();
         profile.autoContinueOnRateLimit = !!dc.autoContinueOnRateLimit;
         profile.chatLayout = dc.chatLayout || "channel";
+        profile.projectMateFilterMode = users.getProjectMateFilterMode(null);
         profile.mateOnboardingShown = !!dc.mateOnboardingShown;
         profile.matesEnabled = dc.matesEnabled === true;
         profile.capsulesEnabled = dc.capsulesEnabled === true;
@@ -266,6 +295,11 @@ function attachSettings(ctx) {
           res.end('{"error":"Mate not found"}');
           return;
         }
+        if (mate.profile && mate.profile.avatarLocked) {
+          res.writeHead(403, { "Content-Type": "application/json" });
+          res.end('{"error":"This Mate avatar is managed by Clay"}');
+          return;
+        }
         var ext = ct.split("/")[1] === "jpeg" ? "jpg" : ct.split("/")[1];
         var avatarDir = path.join(CONFIG_DIR, "mate-avatars");
         fs.mkdirSync(avatarDir, { recursive: true });
@@ -297,6 +331,10 @@ function attachSettings(ctx) {
     // Serve custom mate avatar image
     if (req.method === "GET" && fullUrl.startsWith("/api/mate-avatar/")) {
       var mateAvatarId = fullUrl.split("/api/mate-avatar/")[1].split("?")[0];
+      var avatarUser = users.isMultiUser() ? getMultiUserFromReq(req) : null;
+      if ((users.isMultiUser() && !avatarUser) || !mates.getMate(mates.buildMateCtx(avatarUser ? avatarUser.id : "default"), mateAvatarId)) {
+        res.writeHead(404); res.end(); return true;
+      }
       var mateAvatarDir = path.join(CONFIG_DIR, "mate-avatars");
       try {
         var files = fs.readdirSync(mateAvatarDir);
@@ -312,7 +350,7 @@ function attachSettings(ctx) {
           var ctMap = { jpg: "image/jpeg", png: "image/png", gif: "image/gif", webp: "image/webp" };
           res.writeHead(200, {
             "Content-Type": ctMap[ext] || "application/octet-stream",
-            "Cache-Control": "public, max-age=31536000, immutable",
+            "Cache-Control": "private, no-store",
           });
           res.end(fs.readFileSync(path.join(mateAvatarDir, match)));
           return true;
@@ -528,6 +566,36 @@ function attachSettings(ctx) {
       return true;
     }
 
+    // PUT /api/user/project-mate-filter
+    if (req.method === "PUT" && fullUrl === "/api/user/project-mate-filter") {
+      var isMultiUserFilter = users.isMultiUser();
+      var muFilter = getMultiUserFromReq(req);
+      if (isMultiUserFilter && !muFilter) {
+        res.writeHead(401, { "Content-Type": "application/json" });
+        res.end('{"error":"unauthorized"}');
+        return true;
+      }
+      var bodyFilter = "";
+      req.on("data", function (chunk) { bodyFilter += chunk; });
+      req.on("end", function () {
+        try {
+          var dataFilter = JSON.parse(bodyFilter);
+          var resultFilter = users.setProjectMateFilterMode(muFilter ? muFilter.id : null, dataFilter.mode);
+          if (resultFilter.error) {
+            res.writeHead(400, { "Content-Type": "application/json" });
+            res.end(JSON.stringify({ error: resultFilter.error }));
+            return;
+          }
+          res.writeHead(200, { "Content-Type": "application/json" });
+          res.end(JSON.stringify(resultFilter));
+        } catch (e) {
+          res.writeHead(400, { "Content-Type": "application/json" });
+          res.end('{"error":"Invalid request"}');
+        }
+      });
+      return true;
+    }
+
     // PUT /api/user/terminal-font
     // Body: { family?: string, size?: number }
     // Per-user terminal font preferences shared across every xterm in