clay-server 3.8.1 → 4.0.0-beta.10

package/lib/tools-registry.js

@@ -0,0 +1,286 @@
+var fs = require("fs");
+var path = require("path");
+var config = require("./config");
+var toolUiSpec = require("./tool-ui-spec");
+var toolCapsuleSource = require("./tool-capsule-source");
+
+var CAPSULES_ROOT = path.join(__dirname, "capsules");
+var SEED_MARKER = ".capsules-v7";
+var REMOVED_BUILTIN_IDS = ["board", "translator", "scratchpad"];
+var UI_NODE_TYPES = toolUiSpec.UI_NODE_TYPES;
+var DISCOVERY_FIELD_MAX_LENGTH = 240;
+
+function resolveToolsRoot(ctx) {
+  if (ctx && ctx.linuxUser) return path.join("/home", ctx.linuxUser, ".clay", "tools");
+  if (ctx && ctx.multiUser && ctx.userId) return path.join(config.CONFIG_DIR, "tools", ctx.userId);
+  return path.join(config.CONFIG_DIR, "tools");
+}
+
+function validateToolId(id) {
+  if (typeof id !== "string" || !/^[a-z0-9]+(?:-[a-z0-9]+)*$/.test(id)) {
+    throw new Error("Tool ID must be a lowercase slug.");
+  }
+}
+
+function isTrustedServerRuntime(manifest) {
+  if (!manifest || manifest.runtime !== "server") return false;
+  var sourceManifest = path.join(CAPSULES_ROOT, manifest.id || "", "manifest.json");
+  try {
+    var shipped = JSON.parse(fs.readFileSync(sourceManifest, "utf8"));
+    return shipped.id === manifest.id && shipped.runtime === "server";
+  } catch (e) {
+    return false;
+  }
+}
+
+function filesMatch(first, second) {
+  try {
+    return fs.readFileSync(first).equals(fs.readFileSync(second));
+  } catch (e) {
+    return false;
+  }
+}
+
+function manifestWithoutHydratedMetadata(manifest) {
+  var result = Object.assign({}, manifest);
+  delete result.modelAlias;
+  delete result.description;
+  delete result.useWhen;
+  return result;
+}
+
+function hydrateShippedManifestMetadata(directory, manifest) {
+  if (!manifest) return manifest;
+  var shippedDirectory = path.join(CAPSULES_ROOT, manifest.id || "");
+  var shippedManifestPath = path.join(shippedDirectory, "manifest.json");
+  try {
+    var shipped = JSON.parse(fs.readFileSync(shippedManifestPath, "utf8"));
+    if (shipped.id !== manifest.id) return manifest;
+    if (JSON.stringify(manifestWithoutHydratedMetadata(manifest)) !== JSON.stringify(manifestWithoutHydratedMetadata(shipped))) return manifest;
+    if (!filesMatch(path.join(directory, "ui.json"), path.join(shippedDirectory, "ui.json"))) return manifest;
+    if ((manifest.runtime || "worker") === "worker" && !filesMatch(path.join(directory, "logic.js"), path.join(shippedDirectory, "logic.js"))) return manifest;
+    var hydrated = Object.assign({}, manifest);
+    var fields = ["modelAlias", "description", "useWhen"];
+    for (var i = 0; i < fields.length; i++) {
+      if (hydrated[fields[i]] === undefined && shipped[fields[i]] !== undefined) hydrated[fields[i]] = shipped[fields[i]];
+    }
+    return hydrated;
+  } catch (e) {
+    return manifest;
+  }
+}
+
+function validateDiscoveryField(manifest, field, label) {
+  if (manifest[field] === undefined) return;
+  if (typeof manifest[field] !== "string" || !manifest[field].trim()) {
+    throw new Error("Tool " + label + " must be non-empty text.");
+  }
+  if (manifest[field] !== manifest[field].trim() || /[\u0000-\u001f\u007f]/.test(manifest[field])) {
+    throw new Error("Tool " + label + " must be a single trimmed line.");
+  }
+  if (manifest[field].length > DISCOVERY_FIELD_MAX_LENGTH) {
+    throw new Error("Tool " + label + " must be " + DISCOVERY_FIELD_MAX_LENGTH + " characters or fewer.");
+  }
+}
+
+function validateManifest(manifest, opts) {
+  opts = opts || {};
+  if (!manifest || typeof manifest !== "object" || Array.isArray(manifest)) {
+    throw new Error("Tool manifest is required.");
+  }
+  validateToolId(manifest.id);
+  if (typeof manifest.name !== "string" || !manifest.name.trim()) {
+    throw new Error("Tool name is required.");
+  }
+  if (manifest.lucideIcon !== undefined && (typeof manifest.lucideIcon !== "string" || !/^[a-z0-9-]+$/.test(manifest.lucideIcon))) {
+    throw new Error("Tool icon must be a lowercase Lucide icon name.");
+  }
+  if (manifest.skills !== undefined && typeof manifest.skills !== "string") {
+    throw new Error("Tool skills must be markdown text.");
+  }
+  validateDiscoveryField(manifest, "description", "description");
+  validateDiscoveryField(manifest, "useWhen", "useWhen");
+  if (manifest.permissions !== undefined) {
+    if (!Array.isArray(manifest.permissions)) throw new Error("Tool permissions must be an array.");
+    for (var pi = 0; pi < manifest.permissions.length; pi++) {
+      if (manifest.permissions[pi] !== "llm") throw new Error("Unknown tool permission '" + manifest.permissions[pi] + "'.");
+    }
+  }
+  if (manifest.modelAlias !== undefined && ["fast", "standard", "deep"].indexOf(manifest.modelAlias) === -1) {
+    throw new Error("Tool modelAlias must be fast, standard, or deep.");
+  }
+  var runtime = manifest.runtime || "worker";
+  if (runtime !== "worker" && runtime !== "server") {
+    throw new Error("Tool runtime must be 'worker' or 'server'.");
+  }
+  if (runtime === "server" && !opts.allowServerRuntime) {
+    throw new Error("Server-runtime capsules cannot be installed over WebSocket.");
+  }
+  if (runtime === "server" && !isTrustedServerRuntime(manifest)) {
+    throw new Error("Server runtime is reserved for shipped built-in capsules.");
+  }
+}
+
+var validateUiNode = toolUiSpec.validateUiNode;
+var validateUiTreeForManifest = toolUiSpec.validateUiTreeForManifest;
+
+function toolDirectory(ctx, id) {
+  validateToolId(id);
+  return path.join(resolveToolsRoot(ctx), id);
+}
+
+function seedBuiltInCapsules(ctx) {
+  var root = resolveToolsRoot(ctx);
+  var marker = path.join(root, SEED_MARKER);
+  if (fs.existsSync(marker)) return;
+  fs.mkdirSync(root, { recursive: true });
+  for (var ri = 0; ri < REMOVED_BUILTIN_IDS.length; ri++) {
+    fs.rmSync(path.join(root, REMOVED_BUILTIN_IDS[ri]), { recursive: true, force: true });
+  }
+  // Clay ships no built-in Capsules any more, so lib/capsules/ is absent from a
+  // fresh checkout and from the npm tarball (neither git nor npm carries an
+  // empty directory). Seeding still owns the removed-built-in migration above
+  // and the marker below, so an absent root means "nothing to copy" rather than
+  // a failure. Anything other than a missing root is still a real error.
+  var entries = [];
+  try {
+    entries = fs.readdirSync(CAPSULES_ROOT, { withFileTypes: true });
+  } catch (e) {
+    if (e.code !== "ENOENT") throw e;
+  }
+  var seeded = [];
+  for (var i = 0; i < entries.length; i++) {
+    if (!entries[i].isDirectory()) continue;
+    var destination = path.join(root, entries[i].name);
+    if (!fs.existsSync(destination)) {
+      fs.cpSync(path.join(CAPSULES_ROOT, entries[i].name), destination, { recursive: true });
+      seeded.push(entries[i].name);
+    } else {
+      var sourceFiles = fs.readdirSync(path.join(CAPSULES_ROOT, entries[i].name));
+      for (var fi = 0; fi < sourceFiles.length; fi++) {
+        var sourceFile = path.join(CAPSULES_ROOT, entries[i].name, sourceFiles[fi]);
+        var destinationFile = path.join(destination, sourceFiles[fi]);
+        if (!fs.existsSync(destinationFile)) fs.copyFileSync(sourceFile, destinationFile);
+      }
+    }
+  }
+  fs.writeFileSync(marker, seeded.join("\n") + "\n", "utf8");
+}
+
+function getTool(ctx, id) {
+  var directory = toolDirectory(ctx, id);
+  var manifestPath = path.join(directory, "manifest.json");
+  var logicPath = path.join(directory, "logic.js");
+  var uiPath = path.join(directory, "ui.json");
+  if (!fs.existsSync(manifestPath) || !fs.existsSync(uiPath)) return null;
+  var manifest = JSON.parse(fs.readFileSync(manifestPath, "utf8"));
+  var uiTree = JSON.parse(fs.readFileSync(uiPath, "utf8"));
+  validateManifest(manifest, { allowServerRuntime: true });
+  if (manifest.id !== id) throw new Error("Capsule folder name must match manifest ID.");
+  validateUiTreeForManifest(uiTree, manifest);
+  var runtime = manifest.runtime || "worker";
+  if (runtime === "worker" && !fs.existsSync(logicPath)) throw new Error("Worker capsule logic.js is required.");
+  manifest = hydrateShippedManifestMetadata(directory, manifest);
+  return {
+    manifest: Object.assign({}, manifest, { runtime: runtime }),
+    logicSource: runtime === "worker" ? fs.readFileSync(logicPath, "utf8") : null,
+    uiTree: uiTree,
+    metadata: toolCapsuleSource.sanitizedMetadata(resolveToolsRoot(ctx), id),
+  };
+}
+
+function listTools(ctx) {
+  seedBuiltInCapsules(ctx);
+  var root = resolveToolsRoot(ctx);
+  var entries = fs.readdirSync(root, { withFileTypes: true });
+  var manifests = [];
+  for (var i = 0; i < entries.length; i++) {
+    if (!entries[i].isDirectory()) continue;
+    if (entries[i].name.charAt(0) === ".") continue;
+    try {
+      var tool = getTool(ctx, entries[i].name);
+      if (tool) manifests.push(tool.manifest);
+      else manifests.push({ id: entries[i].name, error: "Capsule requires manifest.json and ui.json." });
+    } catch (e) {
+      manifests.push({ id: entries[i].name, error: e.message });
+    }
+  }
+  manifests.sort(function (a, b) { return (a.name || a.id).localeCompare(b.name || b.id); });
+  return manifests;
+}
+
+function installTool(ctx, input) {
+  if (!input || typeof input !== "object") throw new Error("Tool installation payload is required.");
+  validateManifest(input.manifest, { allowServerRuntime: false });
+  if (typeof input.logicSource !== "string" || !input.logicSource.trim()) {
+    throw new Error("Tool logic source is required.");
+  }
+  validateUiTreeForManifest(input.uiTree, input.manifest);
+  var manifest = Object.assign({}, input.manifest, { name: input.manifest.name.trim(), runtime: "worker" });
+  var directory = toolDirectory(ctx, manifest.id);
+  if (fs.existsSync(directory)) throw new Error("A Capsule with this ID already exists. Read its source and use the update tool instead.");
+  fs.mkdirSync(resolveToolsRoot(ctx), { recursive: true });
+  fs.mkdirSync(directory);
+  try {
+    fs.writeFileSync(path.join(directory, "manifest.json"), JSON.stringify(manifest, null, 2) + "\n", "utf8");
+    fs.writeFileSync(path.join(directory, "logic.js"), input.logicSource, "utf8");
+    fs.writeFileSync(path.join(directory, "ui.json"), JSON.stringify(input.uiTree, null, 2) + "\n", "utf8");
+  } catch (error) {
+    fs.rmSync(directory, { recursive: true, force: true });
+    throw error;
+  }
+  return getTool(ctx, manifest.id);
+}
+
+function getToolSource(ctx, id) {
+  var tool = getTool(ctx, id);
+  if (!tool) throw new Error("Tool not found.");
+  return toolCapsuleSource.readSource(toolDirectory(ctx, id));
+}
+
+function getToolMetadata(ctx, id) {
+  if (!getTool(ctx, id)) throw new Error("Tool not found.");
+  return toolCapsuleSource.sanitizedMetadata(resolveToolsRoot(ctx), id);
+}
+
+function setMateEditingAllowed(ctx, id, allowed) {
+  if (!getTool(ctx, id)) throw new Error("Tool not found.");
+  return toolCapsuleSource.setMateEditingAllowed(resolveToolsRoot(ctx), id, allowed);
+}
+
+function updateTool(ctx, id, input) {
+  var tool = getTool(ctx, id);
+  if (!tool) throw new Error("Tool not found.");
+  toolCapsuleSource.updateSource(toolDirectory(ctx, id), input, {
+    validateManifest: validateManifest,
+    validateUiNode: function (uiTree) { return validateUiTreeForManifest(uiTree, input.manifest); },
+  });
+  return getTool(ctx, id);
+}
+
+function removeTool(ctx, id) {
+  var directory = toolDirectory(ctx, id);
+  if (!fs.existsSync(directory)) return false;
+  fs.rmSync(directory, { recursive: true, force: true });
+  toolCapsuleSource.removeMetadata(resolveToolsRoot(ctx), id);
+  return true;
+}
+
+module.exports = {
+  CAPSULES_ROOT: CAPSULES_ROOT,
+  UI_NODE_TYPES: UI_NODE_TYPES,
+  resolveToolsRoot: resolveToolsRoot,
+  validateToolId: validateToolId,
+  validateManifest: validateManifest,
+  validateUiNode: validateUiNode,
+  validateUiTreeForManifest: validateUiTreeForManifest,
+  seedBuiltInCapsules: seedBuiltInCapsules,
+  listTools: listTools,
+  getTool: getTool,
+  installTool: installTool,
+  getToolSource: getToolSource,
+  getToolMetadata: getToolMetadata,
+  setMateEditingAllowed: setMateEditingAllowed,
+  updateTool: updateTool,
+  removeTool: removeTool,
+};

package/lib/users-home-dock-preferences.js

@@ -0,0 +1,77 @@
+// Per-user persistence for the home tool dock.
+
+function attachHomeDockPreferences(deps) {
+  var loadUsers = deps.loadUsers;
+  var saveUsers = deps.saveUsers;
+
+  function defaults() {
+    return { dockOpen: false, dockFocus: false, dockWidth: null, activeToolId: null };
+  }
+
+  function normalize(value) {
+    var source = value && typeof value === "object" ? value : {};
+    var width = typeof source.dockWidth === "number" && Number.isFinite(source.dockWidth)
+      ? Math.max(420, Math.min(1600, Math.round(source.dockWidth)))
+      : null;
+    var toolId = typeof source.activeToolId === "string" && /^[a-z0-9][a-z0-9_-]{0,63}$/.test(source.activeToolId)
+      ? source.activeToolId
+      : null;
+    return {
+      dockOpen: source.dockOpen === true,
+      dockFocus: source.dockOpen === true && source.dockFocus === true,
+      dockWidth: width,
+      activeToolId: toolId,
+    };
+  }
+
+  function loadSingleUserPreference() {
+    try {
+      var config = require("./config");
+      var current = config.loadConfig() || {};
+      return normalize(current.homeDockPreference);
+    } catch (e) {
+      return defaults();
+    }
+  }
+
+  function saveSingleUserPreference(preference) {
+    try {
+      var config = require("./config");
+      var current = config.loadConfig() || {};
+      config.saveConfig(Object.assign({}, current, { homeDockPreference: preference }));
+      return { ok: true, preference: preference };
+    } catch (e) {
+      return { error: "Unable to save home dock preference" };
+    }
+  }
+
+  function getHomeDockPreference(userId) {
+    var data = loadUsers();
+    for (var i = 0; i < data.users.length; i++) {
+      if (data.users[i].id === userId) return normalize(data.users[i].homeDockPreference);
+    }
+    if (userId === "default") return loadSingleUserPreference();
+    return defaults();
+  }
+
+  function setHomeDockPreference(userId, patch) {
+    var current = getHomeDockPreference(userId);
+    var next = normalize(Object.assign({}, current, patch || {}));
+    var data = loadUsers();
+    for (var i = 0; i < data.users.length; i++) {
+      if (data.users[i].id !== userId) continue;
+      data.users[i].homeDockPreference = next;
+      saveUsers(data);
+      return { ok: true, preference: next };
+    }
+    if (userId === "default") return saveSingleUserPreference(next);
+    return { error: "User not found" };
+  }
+
+  return {
+    getHomeDockPreference: getHomeDockPreference,
+    setHomeDockPreference: setHomeDockPreference,
+  };
+}
+
+module.exports = { attachHomeDockPreferences: attachHomeDockPreferences };

package/lib/users-home-surface-preferences.js

@@ -0,0 +1,99 @@
+// Per-user persistence for durable Home conversation selections.
+
+function attachHomeSurfacePreferences(deps) {
+  var loadUsers = deps.loadUsers;
+  var saveUsers = deps.saveUsers;
+
+  function defaults() {
+    return { surface: null, projectSlug: null, activeMateId: null, activeSessionByMate: {}, sidebarCollapsed: false, chatScope: "all", subSurface: "chat" };
+  }
+
+  function validId(value) {
+    return typeof value === "string" && /^[a-zA-Z0-9][a-zA-Z0-9_-]{0,127}$/.test(value);
+  }
+
+  function validSessionReference(value) {
+    return typeof value === "string" && value.length > 0 && value.length <= 256 && !/[\x00-\x1f]/.test(value);
+  }
+
+  function validProjectSlug(value) {
+    return typeof value === "string" && /^[a-z0-9][a-z0-9_-]{0,127}$/.test(value);
+  }
+
+  function normalize(value) {
+    var source = value && typeof value === "object" ? value : {};
+    var sessions = source.activeSessionByMate && typeof source.activeSessionByMate === "object" && !Array.isArray(source.activeSessionByMate)
+      ? source.activeSessionByMate
+      : {};
+    var normalizedSessions = {};
+    var mateIds = Object.keys(sessions);
+    for (var i = 0; i < mateIds.length; i++) {
+      if (!validId(mateIds[i]) || !validSessionReference(sessions[mateIds[i]])) continue;
+      normalizedSessions[mateIds[i]] = sessions[mateIds[i]];
+    }
+    return {
+      surface: source.surface === "home" || source.surface === "project" ? source.surface : null,
+      projectSlug: validProjectSlug(source.projectSlug) ? source.projectSlug : null,
+      activeMateId: validId(source.activeMateId) ? source.activeMateId : null,
+      activeSessionByMate: normalizedSessions,
+      sidebarCollapsed: source.sidebarCollapsed === true,
+      chatScope: source.chatScope === "current" ? "current" : "all",
+      subSurface: source.subSurface === "debates" ? "debates" : "chat",
+    };
+  }
+
+  function loadSingleUserPreference() {
+    try {
+      var config = require("./config");
+      var current = config.loadConfig() || {};
+      return normalize(current.homeSurfacePreference);
+    } catch (e) {
+      return defaults();
+    }
+  }
+
+  function saveSingleUserPreference(preference) {
+    try {
+      var config = require("./config");
+      var current = config.loadConfig() || {};
+      config.saveConfig(Object.assign({}, current, { homeSurfacePreference: preference }));
+      return { ok: true, preference: preference };
+    } catch (e) {
+      return { error: "Unable to save Home surface preference" };
+    }
+  }
+
+  function getHomeSurfacePreference(userId) {
+    var data = loadUsers();
+    for (var i = 0; i < data.users.length; i++) {
+      if (data.users[i].id === userId) return normalize(data.users[i].homeSurfacePreference);
+    }
+    if (userId === "default") return loadSingleUserPreference();
+    return defaults();
+  }
+
+  function setHomeSurfacePreference(userId, patch) {
+    var current = getHomeSurfacePreference(userId);
+    var merged = Object.assign({}, current, patch || {});
+    if (patch && patch.activeSessionByMate && typeof patch.activeSessionByMate === "object") {
+      merged.activeSessionByMate = Object.assign({}, current.activeSessionByMate, patch.activeSessionByMate);
+    }
+    var next = normalize(merged);
+    var data = loadUsers();
+    for (var i = 0; i < data.users.length; i++) {
+      if (data.users[i].id !== userId) continue;
+      data.users[i].homeSurfacePreference = next;
+      saveUsers(data);
+      return { ok: true, preference: next };
+    }
+    if (userId === "default") return saveSingleUserPreference(next);
+    return { error: "User not found" };
+  }
+
+  return {
+    getHomeSurfacePreference: getHomeSurfacePreference,
+    setHomeSurfacePreference: setHomeSurfacePreference,
+  };
+}
+
+module.exports = { attachHomeSurfacePreferences: attachHomeSurfacePreferences };

package/lib/users-preferences.js

@@ -334,14 +334,11 @@ function attachPreferences(deps) {
     return { error: "User not found" };
   }
 
-  // --- Per-user Mates UI toggle ---
+  // --- Per-user project Mate DM shortcut toggle ---
   //
-  // When disabled, the entire Mates surface (sidebar avatars, DM "Create a
-  // Mate" entry, home-hub mates strip) is hidden for this user; multi-user
-  // and the rest of the sidebar are unaffected. Default is OFF: Mates is
-  // opt-in, not opt-out. Stored as `matesEnabled`; only the literal `true`
-  // enables it, so brand-new users (no field set) get the default-off
-  // experience and must turn Mates on explicitly in settings.
+  // `matesEnabled` is retained as the persisted field for compatibility.
+  // It now controls only project-local Mate DM shortcuts. The broader Mate
+  // capability surface is always available. Default remains off.
 
   function getMatesEnabled(userId) {
     var data = loadUsers();

package/lib/users.js

@@ -6,6 +6,8 @@ var { CONFIG_DIR } = require("./config");
 var { attachAuth } = require("./users-auth");
 var { DEFAULT_PERMISSIONS, ALL_PERMISSIONS, attachPermissions } = require("./users-permissions");
 var { attachPreferences } = require("./users-preferences");
+var { attachHomeDockPreferences } = require("./users-home-dock-preferences");
+var { attachHomeSurfacePreferences } = require("./users-home-surface-preferences");
 
 var USERS_FILE = path.join(CONFIG_DIR, "users.json");
 
@@ -394,6 +396,8 @@ function removeExpiredInvites() {
 var auth = attachAuth({ loadUsers: loadUsers, saveUsers: saveUsers, findAdmin: findAdmin });
 var permissions = attachPermissions({ loadUsers: loadUsers, saveUsers: saveUsers, findUserById: findUserById });
 var preferences = attachPreferences({ loadUsers: loadUsers, saveUsers: saveUsers });
+var homeDockPreferences = attachHomeDockPreferences({ loadUsers: loadUsers, saveUsers: saveUsers });
+var homeSurfacePreferences = attachHomeSurfacePreferences({ loadUsers: loadUsers, saveUsers: saveUsers });
 
 // Alias auth functions
 var isMultiUser = auth.isMultiUser;
@@ -442,6 +446,10 @@ var markWhatsNewSeen = preferences.markWhatsNewSeen;
 var getTerminalFont = preferences.getTerminalFont;
 var setTerminalFont = preferences.setTerminalFont;
 var setMateOnboarded = preferences.setMateOnboarded;
+var getHomeDockPreference = homeDockPreferences.getHomeDockPreference;
+var setHomeDockPreference = homeDockPreferences.setHomeDockPreference;
+var getHomeSurfacePreference = homeSurfacePreferences.getHomeSurfacePreference;
+var setHomeSurfacePreference = homeSurfacePreferences.setHomeSurfacePreference;
 
 module.exports = {
   USERS_FILE: USERS_FILE,
@@ -511,6 +519,10 @@ module.exports = {
   markWhatsNewSeen: markWhatsNewSeen,
   getTerminalFont: getTerminalFont,
   setTerminalFont: setTerminalFont,
+  getHomeDockPreference: getHomeDockPreference,
+  setHomeDockPreference: setHomeDockPreference,
+  getHomeSurfacePreference: getHomeSurfacePreference,
+  setHomeSurfacePreference: setHomeSurfacePreference,
   getDeletedBuiltinKeys: getDeletedBuiltinKeys,
   addDeletedBuiltinKey: addDeletedBuiltinKey,
   removeDeletedBuiltinKey: removeDeletedBuiltinKey,

package/lib/whats-new-content.js

@@ -70,13 +70,13 @@ var ENTRIES = [
     title: "GUI is back as the default",
     publishedAt: "2026-07-01",
     image: null,
-    summary: "Anthropic reversed the June 15 billing split, so SDK usage is no longer billed separately. Clay opens Claude sessions in the GUI chat again by default. Mates is now off by default as it winds down.",
+    summary: "Anthropic reversed the June 15 billing split, so SDK usage is no longer billed separately. Clay opens Claude sessions in the GUI chat again by default. Project Mate DM shortcuts are hidden by default.",
     body: '' +
       '<p><strong>Good news: Anthropic walked back the June 15 billing change.</strong> The planned Interactive vs. Programmatic split (which would have charged Claude Agent SDK usage at full API rates) is off the table, so the reason we moved everyone to the TUI is gone.</p>' +
       '<h3>GUI is the default again</h3>' +
       '<p>New Claude sessions open in the <strong>GUI chat</strong> (SDK) by default, the way they did before. The embedded <code>claude</code> <strong>TUI</strong> is still there whenever you want it &mdash; toggle <strong>"Open Claude as terminal (TUI)"</strong> in Settings.</p>' +
-      '<h3>Mates is off by default</h3>' +
-      '<p>As announced, <strong>Mates</strong> is no longer a first-class Clay feature. It is now <strong>off by default</strong> so Clay stays focused as a developer tool. Your existing Mates and their knowledge files remain on disk &mdash; if you still use them, re-enable Mates in <strong>Settings</strong>.</p>' +
+      '<h3>Project Mate DM shortcuts are optional</h3>' +
+      '<p>Mate DM shortcuts inside project workspaces are hidden by default and can be shown in <strong>Settings</strong>. Mates themselves remain available in Clay Home, together with their conversations, memory, debates, and project collaboration.</p>' +
       '<p>Clay only gets sharper from here.</p>',
   },
 ];