clay-server 5.0.0-beta.2 → 5.0.0-beta.3

package/lib/session-folders.js

@@ -0,0 +1,414 @@
+// Pure model for per-user, per-project session folders. No I/O and no
+// dependency on live sessions: callers inject the checks that need them, so
+// every invariant here is enforced the same way for any transport.
+//
+// Shape of one state:
+//   folders:     [{ id, name }]            custom folders, array order = display order
+//   assignments: { sessionKey: folderId }  folderId is a custom id; absent = Unfiled (exclusive placement)
+//   favorites:   [sessionKey]              independent Favorites tag in curated manual order; a favorite
+//                                          also keeps its folder (or Unfiled) assignment
+//   orders:      { containerKey: [keys] }  manual order per container ("unfiled", custom id, "all")
+//   collapsed:   { containerKey: true }
+//   view:        { group, sort, direction }
+// sessionKey is the session's opaque, durable sessionOriginId.
+
+var crypto = require("crypto");
+
+var FAVORITES_ID = "favorites";
+var UNFILED_ID = "unfiled";
+var ALL_ID = "all";
+var MAX_FOLDERS = 50;
+var MAX_NAME_LENGTH = 60;
+var MAX_KEYS = 5000;
+var MAX_KEY_LENGTH = 128;
+
+// Folders are the only layout. Older clients and stored preferences may still
+// name "dates" or "none"; those are accepted and canonicalized to "folders".
+var LEGACY_GROUPS = ["folders", "dates", "none"];
+var SORTS = ["activity", "created", "title", "manual"];
+var DIRECTIONS = ["desc", "asc"];
+
+function defaultState() {
+  return {
+    folders: [],
+    assignments: {},
+    favorites: [],
+    orders: {},
+    collapsed: {},
+    view: { group: "folders", sort: "activity", direction: "desc" },
+    legacyFavoritesMigrated: false,
+  };
+}
+
+function isPlainObject(value) {
+  return !!value && typeof value === "object" && !Array.isArray(value);
+}
+
+function has(object, key) {
+  return Object.prototype.hasOwnProperty.call(object, key);
+}
+
+// Dictionary keys come from storage and clients, so names that exist on
+// Object.prototype must never be treated as present, and __proto__ is refused.
+function validKey(value) {
+  return typeof value === "string" && value.length > 0 && value.length <= MAX_KEY_LENGTH && !/[\x00-\x1f]/.test(value) && value !== "__proto__";
+}
+
+function validFolderId(value) {
+  return typeof value === "string" && /^f_[a-z0-9]{6,32}$/.test(value);
+}
+
+function cleanName(raw) {
+  if (typeof raw !== "string") return { error: "Folder name must be text" };
+  var name = raw.replace(/[\x00-\x1f\x7f]/g, " ").replace(/\s+/g, " ").trim();
+  if (!name) return { error: "Folder name is required" };
+  if (name.length > MAX_NAME_LENGTH) return { error: "Folder name must be " + MAX_NAME_LENGTH + " characters or fewer" };
+  var lower = name.toLowerCase();
+  if (lower === "favorites" || lower === "unfiled") return { error: "That name is reserved for a built-in folder" };
+  return { name: name };
+}
+
+function nameTaken(state, name, exceptId) {
+  var lower = name.toLowerCase();
+  for (var i = 0; i < state.folders.length; i++) {
+    if (state.folders[i].id !== exceptId && state.folders[i].name.toLowerCase() === lower) return true;
+  }
+  return false;
+}
+
+// A real destination: a custom folder. Favorites is a tag, never a destination.
+function knownContainer(state, id) {
+  if (typeof id !== "string") return false;
+  for (var i = 0; i < state.folders.length; i++) if (state.folders[i].id === id) return true;
+  return false;
+}
+
+function uniqueKeys(list) {
+  var seen = Object.create(null);
+  var out = [];
+  if (!Array.isArray(list)) return out;
+  for (var i = 0; i < list.length && out.length < MAX_KEYS; i++) {
+    if (!validKey(list[i]) || seen[list[i]]) continue;
+    seen[list[i]] = true;
+    out.push(list[i]);
+  }
+  return out;
+}
+
+// Accepts anything stored on disk and returns a state that satisfies every
+// invariant; unknown fields and dangling references are dropped.
+function normalizeState(raw) {
+  var source = isPlainObject(raw) ? raw : {};
+  var state = defaultState();
+  var seenIds = Object.create(null);
+  var seenNames = Object.create(null);
+  var folders = Array.isArray(source.folders) ? source.folders : [];
+  for (var i = 0; i < folders.length && state.folders.length < MAX_FOLDERS; i++) {
+    var f = folders[i];
+    if (!isPlainObject(f) || !validFolderId(f.id) || seenIds[f.id]) continue;
+    var cleaned = cleanName(f.name);
+    if (cleaned.error || seenNames[cleaned.name.toLowerCase()]) continue;
+    seenIds[f.id] = true;
+    seenNames[cleaned.name.toLowerCase()] = true;
+    state.folders.push({ id: f.id, name: cleaned.name });
+  }
+  var assignments = isPlainObject(source.assignments) ? source.assignments : {};
+  var keys = Object.keys(assignments);
+  var legacyTagged = [];
+  for (var a = 0; a < keys.length && a < MAX_KEYS; a++) {
+    if (!validKey(keys[a]) || !has(assignments, keys[a])) continue;
+    // Migration: when Favorites was an exclusive folder, the assignment IS the
+    // tag. The session's previous folder was never recorded, so it lands in
+    // Unfiled; nothing is invented.
+    if (assignments[keys[a]] === FAVORITES_ID) legacyTagged.push(keys[a]);
+    else if (knownContainer(state, assignments[keys[a]])) state.assignments[keys[a]] = assignments[keys[a]];
+  }
+  var orders = isPlainObject(source.orders) ? source.orders : {};
+  var containers = Object.keys(orders);
+  for (var o = 0; o < containers.length; o++) {
+    var cid = containers[o];
+    if (cid === FAVORITES_ID || (cid !== UNFILED_ID && cid !== ALL_ID && !knownContainer(state, cid))) continue;
+    state.orders[cid] = uniqueKeys(orders[cid]);
+  }
+  reconcileOrders(state);
+  // Favorites tags: the new list first, then migrated ones in their previous
+  // curated order (legacy orders.favorites), then any remaining in key order.
+  var tagged = uniqueKeys(source.favorites);
+  var legacyOrder = uniqueKeys(has(orders, FAVORITES_ID) ? orders[FAVORITES_ID] : []).filter(function (k) { return legacyTagged.indexOf(k) !== -1; });
+  legacyTagged.forEach(function (k) { if (legacyOrder.indexOf(k) === -1) legacyOrder.push(k); });
+  tagged = uniqueKeys(tagged.concat(legacyOrder));
+  state.favorites = tagged;
+  var collapsed = isPlainObject(source.collapsed) ? source.collapsed : {};
+  var collapsedKeys = Object.keys(collapsed);
+  for (var c = 0; c < collapsedKeys.length; c++) {
+    var ck = collapsedKeys[c];
+    if (has(collapsed, ck) && collapsed[ck] === true && (ck === FAVORITES_ID || ck === UNFILED_ID || knownContainer(state, ck))) state.collapsed[ck] = true;
+  }
+  var view = isPlainObject(source.view) ? source.view : {};
+  if (SORTS.indexOf(view.sort) !== -1) state.view.sort = view.sort;
+  if (DIRECTIONS.indexOf(view.direction) !== -1) state.view.direction = view.direction;
+  state.legacyFavoritesMigrated = source.legacyFavoritesMigrated === true;
+  return state;
+}
+
+// A container's manual order may only list sessions that currently belong to
+// it. Moves, folder deletion and legacy data can leave stale members behind;
+// dropping them here keeps every order consistent with the assignments.
+// "all" spans every ordinary session and is not membership-checked.
+function reconcileOrders(state) {
+  var containers = Object.keys(state.orders);
+  for (var c = 0; c < containers.length; c++) {
+    var cid = containers[c];
+    if (cid === ALL_ID) continue;
+    var members = state.orders[cid].filter(function (key) {
+      var assigned = has(state.assignments, key) ? state.assignments[key] : UNFILED_ID;
+      return assigned === cid;
+    });
+    if (members.length) state.orders[cid] = members;
+    else delete state.orders[cid];
+  }
+  return state;
+}
+
+// One-time seed from the legacy session-level favorites. Favorites are now an
+// independent tag, so an existing custom-folder assignment is kept while the
+// tag is added. The legacy flags themselves are left untouched.
+function seedLegacyFavorites(state, legacyKeys) {
+  var next = normalizeState(state);
+  if (next.legacyFavoritesMigrated) return next;
+  for (var i = 0; i < legacyKeys.length; i++) {
+    var key = legacyKeys[i];
+    if (!validKey(key) || next.favorites.indexOf(key) !== -1) continue;
+    next.favorites.push(key);
+  }
+  next.legacyFavoritesMigrated = true;
+  return next;
+}
+
+function newFolderId() {
+  return "f_" + crypto.randomBytes(6).toString("hex");
+}
+
+function pruneKeys(state, exists) {
+  var keys = Object.keys(state.assignments);
+  for (var i = 0; i < keys.length; i++) if (!exists(keys[i])) delete state.assignments[keys[i]];
+  state.favorites = state.favorites.filter(exists);
+  var containers = Object.keys(state.orders);
+  for (var c = 0; c < containers.length; c++) {
+    state.orders[containers[c]] = state.orders[containers[c]].filter(exists);
+  }
+}
+
+function containerOf(state, key) {
+  return has(state.assignments, key) ? state.assignments[key] : UNFILED_ID;
+}
+
+// env.canOrganize(key): the key names a session this user may see and that is
+// a movable unit (a Driver root or standalone session, never a Worker).
+// env.exists(key): the session still exists in the project (for pruning).
+function applyOperation(input, op, env) {
+  var result = applyRaw(input, op, env);
+  if (result.state) {
+    pruneKeys(result.state, env.exists);
+    reconcileOrders(result.state);
+  }
+  return result;
+}
+
+function applyRaw(input, op, env) {
+  var state = normalizeState(input);
+  if (!isPlainObject(op) || typeof op.op !== "string") return { error: "Invalid folder request" };
+  var kind = op.op;
+  var i;
+
+  if (kind === "create_folder") {
+    if (state.folders.length >= MAX_FOLDERS) return { error: "You can have at most " + MAX_FOLDERS + " folders" };
+    var created = cleanName(op.name);
+    if (created.error) return created;
+    if (nameTaken(state, created.name, null)) return { error: "A folder with that name already exists" };
+    var folder = { id: newFolderId(), name: created.name };
+    state.folders.push(folder);
+    return { state: state, folderId: folder.id };
+  }
+
+  if (kind === "rename_folder") {
+    if (!validFolderId(op.folderId) || !knownContainer(state, op.folderId)) return { error: "Folder not found" };
+    var renamed = cleanName(op.name);
+    if (renamed.error) return renamed;
+    if (nameTaken(state, renamed.name, op.folderId)) return { error: "A folder with that name already exists" };
+    for (i = 0; i < state.folders.length; i++) if (state.folders[i].id === op.folderId) state.folders[i].name = renamed.name;
+    return { state: state };
+  }
+
+  if (kind === "delete_folder") {
+    if (!validFolderId(op.folderId) || !knownContainer(state, op.folderId)) return { error: "Folder not found" };
+    // Contents either go to Unfiled (the default, and what older clients get) or
+    // to another folder. Deleting the sessions themselves is a separate,
+    // server-authorized request and never reaches this pure model.
+    var mode = op.mode === undefined ? "unfiled" : op.mode;
+    if (mode !== "unfiled" && mode !== "move") return { error: "Unsupported folder deletion" };
+    var members = Object.keys(state.assignments).filter(function (k) { return state.assignments[k] === op.folderId; });
+    if (mode === "move") {
+      var dest = op.destinationId;
+      if (typeof dest !== "string" || dest === op.folderId || dest === UNFILED_ID || dest === FAVORITES_ID || !knownContainer(state, dest)) return { error: "Choose another folder for these sessions" };
+      var listed = (state.orders[op.folderId] || []).filter(function (k) { return members.indexOf(k) !== -1; });
+      var moved = listed.concat(members.filter(function (k) { return listed.indexOf(k) === -1; }));
+      for (i = 0; i < moved.length; i++) state.assignments[moved[i]] = dest;
+      if (moved.length && state.orders[dest]) {
+        state.orders[dest] = (state.orders[dest] || []).concat(moved);
+      }
+    } else {
+      for (i = 0; i < members.length; i++) delete state.assignments[members[i]];
+    }
+    state.folders = state.folders.filter(function (f) { return f.id !== op.folderId; });
+    delete state.orders[op.folderId];
+    delete state.collapsed[op.folderId];
+    return { state: state };
+  }
+
+  if (kind === "reorder_folder") {
+    if (!validFolderId(op.folderId) || !knownContainer(state, op.folderId)) return { error: "Folder not found" };
+    if (!validFolderId(op.targetId) || !knownContainer(state, op.targetId)) return { error: "Target folder not found" };
+    if (op.folderId === op.targetId) return { state: state };
+    var moving = null;
+    var rest = [];
+    for (i = 0; i < state.folders.length; i++) {
+      if (state.folders[i].id === op.folderId) moving = state.folders[i];
+      else rest.push(state.folders[i]);
+    }
+    var at = -1;
+    for (i = 0; i < rest.length; i++) if (rest[i].id === op.targetId) at = i;
+    rest.splice(op.insertBefore === false ? at + 1 : at, 0, moving);
+    state.folders = rest;
+    return { state: state };
+  }
+
+  if (kind === "place_session") {
+    if (!validKey(op.sessionKey) || !env.canOrganize(op.sessionKey)) return { error: "Session not found" };
+    // Older clients ask to place a session "in Favorites": that is the tag, and
+    // the session keeps its folder.
+    if (op.folderId === FAVORITES_ID) return tagFavorite(state, op, env, true);
+    var folderId = op.folderId === null || op.folderId === undefined || op.folderId === UNFILED_ID ? UNFILED_ID : op.folderId;
+    if (folderId !== UNFILED_ID && !knownContainer(state, folderId)) return { error: "Folder not found" };
+    if (folderId === UNFILED_ID) delete state.assignments[op.sessionKey];
+    else state.assignments[op.sessionKey] = folderId;
+    pruneKeys(state, env.exists);
+    if (op.order !== undefined) {
+      var placed = setOrder(state, op.order, op.sessionKey, folderId, env);
+      if (placed.error) return placed;
+    }
+    return { state: state };
+  }
+
+  if (kind === "set_favorite") {
+    if (!validKey(op.sessionKey) || !env.canOrganize(op.sessionKey)) return { error: "Session not found" };
+    return tagFavorite(state, op, env, op.favorite === true);
+  }
+
+  if (kind === "set_order") {
+    var target = op.containerKey;
+    if (target !== FAVORITES_ID && target !== UNFILED_ID && target !== ALL_ID && !knownContainer(state, target)) return { error: "Folder not found" };
+    var result = target === FAVORITES_ID ? setFavoritesOrder(state, op.order, env) : setOrder(state, op.order, null, target, env);
+    if (result.error) return result;
+    return { state: state };
+  }
+
+  if (kind === "set_collapsed") {
+    var key = op.containerKey;
+    if (key !== FAVORITES_ID && key !== UNFILED_ID && !knownContainer(state, key)) return { error: "Folder not found" };
+    if (op.collapsed === true) state.collapsed[key] = true;
+    else delete state.collapsed[key];
+    return { state: state };
+  }
+
+  if (kind === "set_view") {
+    if (op.group !== undefined) {
+      if (LEGACY_GROUPS.indexOf(op.group) === -1) return { error: "Invalid grouping" };
+      state.view.group = "folders";
+    }
+    if (op.sort !== undefined) {
+      if (SORTS.indexOf(op.sort) === -1) return { error: "Invalid sort" };
+      state.view.sort = op.sort;
+    }
+    if (op.direction !== undefined) {
+      if (DIRECTIONS.indexOf(op.direction) === -1) return { error: "Invalid direction" };
+      state.view.direction = op.direction;
+    }
+    return { state: state };
+  }
+
+  return { error: "Unknown folder request" };
+}
+
+// Adds or removes the Favorites tag. The session's folder is never touched. An
+// optional order places the tagged session in the curated list.
+function tagFavorite(state, op, env, favorite) {
+  var key = op.sessionKey;
+  var at = state.favorites.indexOf(key);
+  if (!favorite) {
+    if (at !== -1) state.favorites.splice(at, 1);
+    return { state: state };
+  }
+  if (at === -1) {
+    if (state.favorites.length >= MAX_KEYS) return { error: "Too many favorites" };
+    state.favorites.push(key);
+  }
+  if (op.order !== undefined) {
+    var placed = setFavoritesOrder(state, op.order, env, key);
+    if (placed.error) return placed;
+  }
+  return { state: state };
+}
+
+// The listed tags first, in the given order; any other favorite follows in its
+// existing order. Every listed key must already be a favorite.
+function setFavoritesOrder(state, order, env, requiredKey) {
+  if (!Array.isArray(order) || order.length > MAX_KEYS) return { error: "Invalid order" };
+  var listed = [];
+  var seen = Object.create(null);
+  for (var i = 0; i < order.length; i++) {
+    var key = order[i];
+    if (!validKey(key) || seen[key]) return { error: "Invalid order" };
+    if (!env.canOrganize(key)) return { error: "Session not found" };
+    if (state.favorites.indexOf(key) === -1) return { error: "Order does not match the favorites" };
+    seen[key] = true;
+    listed.push(key);
+  }
+  if (requiredKey && !seen[requiredKey]) return { error: "Order must include the favorite" };
+  state.favorites = listed.concat(state.favorites.filter(function (k) { return !seen[k]; }));
+  return { ok: true };
+}
+
+// Replaces one container's manual order. Every key must name an organizable
+// session; keys that belong to another folder are rejected so a crafted list
+// cannot smuggle sessions across containers.
+function setOrder(state, order, requiredKey, containerKey, env) {
+  if (!Array.isArray(order) || order.length > MAX_KEYS) return { error: "Invalid order" };
+  var keys = [];
+  var seen = {};
+  for (var i = 0; i < order.length; i++) {
+    var key = order[i];
+    if (!validKey(key) || seen[key]) return { error: "Invalid order" };
+    if (!env.canOrganize(key)) return { error: "Session not found" };
+    if (containerKey !== ALL_ID && containerOf(state, key) !== containerKey) return { error: "Order does not match the folder contents" };
+    seen[key] = true;
+    keys.push(key);
+  }
+  if (requiredKey && !seen[requiredKey]) return { error: "Order must include the moved session" };
+  state.orders[containerKey] = keys;
+  return { ok: true };
+}
+
+module.exports = {
+  FAVORITES_ID: FAVORITES_ID,
+  UNFILED_ID: UNFILED_ID,
+  ALL_ID: ALL_ID,
+  MAX_FOLDERS: MAX_FOLDERS,
+  LEGACY_GROUPS: LEGACY_GROUPS,
+  SORTS: SORTS,
+  DIRECTIONS: DIRECTIONS,
+  defaultState: defaultState,
+  normalizeState: normalizeState,
+  seedLegacyFavorites: seedLegacyFavorites,
+  applyOperation: applyOperation,
+};

package/lib/sessions.js

@@ -613,6 +613,7 @@ function createSessionManager(opts) {
     return {
       id: s.localId,
       cliSessionId: s.cliSessionId || null,
+      createdAt: s.createdAt || 0,
       title: s.title || "New Session",
       githubLinks: s.githubLinks || [],
       linearLinks: s.linearLinks || [],
@@ -812,9 +813,9 @@ function createSessionManager(opts) {
     return session;
   }
 
-  // Initial replay payload size. Lowered from 200 to reduce client-side
-  // layout work on resume — older items are loaded progressively on
-  // scroll-up via the existing pagination path.
+  // History entries include tool activity and streamed output, so opening a
+  // conversation needs a wider window than each incremental scroll-up page.
+  var INITIAL_HISTORY_SIZE = 500;
   var HISTORY_PAGE_SIZE = 100;
 
   function findTurnBoundary(history, targetIndex) {
@@ -828,10 +829,10 @@ function createSessionManager(opts) {
     var _send = (targetWs && sendTo) ? function (obj) { sendTo(targetWs, obj); } : send;
     var total = session.history.length;
     if (typeof fromIndex !== "number") {
-      if (total <= HISTORY_PAGE_SIZE) {
+      if (total <= INITIAL_HISTORY_SIZE) {
         fromIndex = 0;
       } else {
-        fromIndex = findTurnBoundary(session.history, Math.max(0, total - HISTORY_PAGE_SIZE));
+        fromIndex = findTurnBoundary(session.history, Math.max(0, total - INITIAL_HISTORY_SIZE));
       }
     }
 
@@ -1442,6 +1443,7 @@ function createSessionManager(opts) {
       for (var i = 0; i < listeners.length; i++) listeners[i](localId);
     },
     HISTORY_PAGE_SIZE: HISTORY_PAGE_SIZE,
+    INITIAL_HISTORY_SIZE: INITIAL_HISTORY_SIZE,
     getActiveSession: getActiveSession,
     createSession: createSession,
     createSessionRaw: createSessionRaw,

package/lib/users-session-folder-preferences.js

@@ -0,0 +1,69 @@
+// Per-user, per-project persistence for sidebar session folders. Multi-user
+// installs store it on the user's own record; single-user installs use the
+// daemon config. A user can only ever read or write their own entry.
+
+var sessionFolders = require("./session-folders");
+
+function validSlug(slug) {
+  return typeof slug === "string" && /^[a-zA-Z0-9][a-zA-Z0-9_.-]{0,127}$/.test(slug);
+}
+
+function attachSessionFolderPreferences(deps) {
+  var loadUsers = deps.loadUsers;
+  var saveUsers = deps.saveUsers;
+
+  function loadConfigState(slug) {
+    try {
+      var cfg = require("./config").loadConfig() || {};
+      var all = cfg.sessionFolderPreferences;
+      return all && typeof all === "object" && Object.prototype.hasOwnProperty.call(all, slug) ? all[slug] : null;
+    } catch (e) {
+      return null;
+    }
+  }
+
+  function saveConfigState(slug, state) {
+    try {
+      var config = require("./config");
+      var cfg = config.loadConfig() || {};
+      var all = Object.assign({}, cfg.sessionFolderPreferences || {});
+      all[slug] = state;
+      config.saveConfig(Object.assign({}, cfg, { sessionFolderPreferences: all }));
+      return { ok: true, state: state };
+    } catch (e) {
+      return { error: "Unable to save session folders" };
+    }
+  }
+
+  function getSessionFolders(userId, slug) {
+    if (!validSlug(slug)) return sessionFolders.defaultState();
+    var data = loadUsers();
+    for (var i = 0; i < data.users.length; i++) {
+      if (data.users[i].id !== userId) continue;
+      var stored = data.users[i].sessionFolders;
+      return sessionFolders.normalizeState(stored && typeof stored === "object" && Object.prototype.hasOwnProperty.call(stored, slug) ? stored[slug] : null);
+    }
+    if (userId === "default") return sessionFolders.normalizeState(loadConfigState(slug));
+    return sessionFolders.defaultState();
+  }
+
+  function setSessionFolders(userId, slug, state) {
+    if (!validSlug(slug)) return { error: "Invalid project" };
+    var next = sessionFolders.normalizeState(state);
+    var data = loadUsers();
+    for (var i = 0; i < data.users.length; i++) {
+      if (data.users[i].id !== userId) continue;
+      var all = data.users[i].sessionFolders && typeof data.users[i].sessionFolders === "object" ? data.users[i].sessionFolders : {};
+      all[slug] = next;
+      data.users[i].sessionFolders = all;
+      saveUsers(data);
+      return { ok: true, state: next };
+    }
+    if (userId === "default") return saveConfigState(slug, next);
+    return { error: "User not found" };
+  }
+
+  return { getSessionFolders: getSessionFolders, setSessionFolders: setSessionFolders };
+}
+
+module.exports = { attachSessionFolderPreferences: attachSessionFolderPreferences };

package/lib/users.js

@@ -8,6 +8,7 @@ var { DEFAULT_PERMISSIONS, ALL_PERMISSIONS, attachPermissions } = require("./use
 var { attachPreferences } = require("./users-preferences");
 var { attachHomeDockPreferences } = require("./users-home-dock-preferences");
 var { attachHomeSurfacePreferences } = require("./users-home-surface-preferences");
+var { attachSessionFolderPreferences } = require("./users-session-folder-preferences");
 var { attachExperimentalPreferences } = require("./users-experimental-preferences");
 var { attachScheduledTaskPreferences } = require("./users-scheduled-task-preferences");
 var { attachDefaultAiPreferences } = require("./users-default-ai-preferences");
@@ -403,6 +404,7 @@ var permissions = attachPermissions({ loadUsers: loadUsers, saveUsers: saveUsers
 var preferences = attachPreferences({ loadUsers: loadUsers, saveUsers: saveUsers });
 var homeDockPreferences = attachHomeDockPreferences({ loadUsers: loadUsers, saveUsers: saveUsers });
 var homeSurfacePreferences = attachHomeSurfacePreferences({ loadUsers: loadUsers, saveUsers: saveUsers });
+var sessionFolderPreferences = attachSessionFolderPreferences({ loadUsers: loadUsers, saveUsers: saveUsers });
 var experimentalPreferences = attachExperimentalPreferences({ loadUsers: loadUsers, saveUsers: saveUsers });
 var scheduledTaskPreferences = attachScheduledTaskPreferences({ loadUsers: loadUsers, saveUsers: saveUsers });
 var defaultAiPreferences = attachDefaultAiPreferences({ loadUsers: loadUsers, saveUsers: saveUsers, isMultiUser: auth.isMultiUser });
@@ -462,6 +464,8 @@ var getHomeDockPreference = homeDockPreferences.getHomeDockPreference;
 var setHomeDockPreference = homeDockPreferences.setHomeDockPreference;
 var getHomeSurfacePreference = homeSurfacePreferences.getHomeSurfacePreference;
 var setHomeSurfacePreference = homeSurfacePreferences.setHomeSurfacePreference;
+var getSessionFolders = sessionFolderPreferences.getSessionFolders;
+var setSessionFolders = sessionFolderPreferences.setSessionFolders;
 var getScheduledTaskInterviewEngine = scheduledTaskPreferences.get;
 var setScheduledTaskInterviewEngine = scheduledTaskPreferences.set;
 var getDefaultAiPreference = defaultAiPreferences.getDefaultAiPreference;
@@ -545,6 +549,8 @@ module.exports = {
   setHomeDockPreference: setHomeDockPreference,
   getHomeSurfacePreference: getHomeSurfacePreference,
   setHomeSurfacePreference: setHomeSurfacePreference,
+  getSessionFolders: getSessionFolders,
+  setSessionFolders: setSessionFolders,
   getScheduledTaskInterviewEngine: getScheduledTaskInterviewEngine,
   setScheduledTaskInterviewEngine: setScheduledTaskInterviewEngine,
   getDefaultAiPreference: getDefaultAiPreference,

package/lib/ws-schema.js

@@ -25,6 +25,17 @@ var schema = {
   "rename_session":           { direction: "c2s", handler: "lib/project-sessions.js", description: "Rename a session" },
   "set_session_bookmark":     { direction: "c2s", handler: "lib/project-sessions.js", description: "Bookmark or unbookmark a session in the sidebar" },
   "reorder_session_bookmarks": { direction: "c2s", handler: "lib/project-sessions.js", description: "Reorder favorited sessions within the favorites area" },
+  "session_folders_get":      { direction: "c2s", handler: "lib/project-session-folders.js", description: "Request the caller's personal session folder state for this project" },
+  "session_folders_op":       { direction: "c2s", handler: "lib/project-session-folders.js", description: "Validated folder operation (create/rename/delete/reorder folder, place/reorder session, collapse, view)" },
+  "session_folders_delete_preview": { direction: "c2s", handler: "lib/project-session-folder-delete.js", description: "Ask for the authoritative session count and snapshot token before deleting a folder" },
+  "session_folders_delete":   { direction: "c2s", handler: "lib/project-session-folder-delete.js", description: "Delete a folder, moving its sessions to Unfiled or another folder, or deleting them (snapshot token required)" },
+  "session_folders_state":    { direction: "s2c", handler: "lib/public/modules/session-folders.js", description: "Authoritative per-user, per-project session folder state; sent on connect and after every change to all of that user's sockets" },
+  "new_session_options_get":  { direction: "c2s", handler: "lib/project-session-creation.js", description: "Ask for the installed providers, the project's default provider and whether the caller may set it" },
+  "new_session_default_set":  { direction: "c2s", handler: "lib/project-session-creation.js", description: "Save the project-scoped default provider the inline New session row preselects" },
+  "new_session_options":      { direction: "s2c", handler: "lib/public/modules/session-create.js", description: "Installed providers, project default provider and default-setting permission for the inline New session row" },
+  "new_session_default_result": { direction: "s2c", handler: "lib/public/modules/session-create.js", description: "Outcome of saving the project New session default" },
+  "new_session_project_default": { direction: "s2c", handler: "lib/public/modules/session-create.js", description: "The project New session default changed" },
+  "session_folders_delete_preview_result": { direction: "s2c", handler: "lib/public/modules/session-folders.js", description: "Server count and snapshot token for a pending folder deletion" },
   "bulk_delete_sessions":    { direction: "c2s", handler: "lib/project-sessions.js", description: "Delete a group of sessions at once" },
   "set_session_visibility":   { direction: "c2s", handler: "lib/project-sessions.js", description: "Show or hide a session in the sidebar" },
   "set_project_session_visibility_default": { direction: "c2s", handler: "lib/project-sessions.js", description: "Set private/shared default for new ordinary project sessions" },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "clay-server",
-  "version": "5.0.0-beta.2",
+  "version": "5.0.0-beta.3",
   "description": "Self-hosted team workspace for Claude Code and Codex. Multi-user, browser-based, with persistent AI mates.",
   "bin": {
     "clay-server": "./bin/cli.js"

package/lib/public/modules/session-creation-cta.js

@@ -1,46 +0,0 @@
-// Shared, presentation-only session creation controls for desktop and mobile.
-
-import { iconHtml } from './icons.js';
-
-var SESSION_VENDOR_LABELS = {
-  claude: "Claude",
-  codex: "Codex",
-  antigravity: "Antigravity",
-  opencode: "OpenCode",
-  kimi: "Kimi",
-  grok: "Grok",
-  copilot: "Copilot",
-  qwen: "Qwen",
-  junie: "Junie",
-  kiro: "Kiro",
-};
-
-export function renderSessionCreationCta(options) {
-  var row = document.createElement("div");
-  row.className = options.rowClass + " session-create-cta";
-
-  var createButton = document.createElement("button");
-  createButton.className = options.createClass + " session-create-primary";
-  createButton.type = "button";
-  var vendorLabel = SESSION_VENDOR_LABELS[options.vendorKey] || options.vendorName;
-  createButton.innerHTML = '<img src="' + options.vendorAvatar +
-    '" class="' + options.iconClass + ' session-create-provider-icon" alt="">' +
-    '<span>Create new ' + vendorLabel + ' session</span>';
-  createButton.title = options.createTitle;
-  createButton.setAttribute("aria-label", options.createTitle);
-  createButton.addEventListener("click", options.onCreate);
-  row.appendChild(createButton);
-
-  var providerButton = document.createElement("button");
-  providerButton.className = options.providerClass + " session-create-provider";
-  providerButton.type = "button";
-  providerButton.title = options.providerTitle;
-  providerButton.setAttribute("aria-label", "Switch AI provider (current: " + options.vendorName + ")");
-  providerButton.setAttribute("aria-expanded", "false");
-  providerButton.setAttribute("aria-controls", options.menuId);
-  providerButton.innerHTML = iconHtml("chevron-down", "session-create-provider-chevron");
-  providerButton.addEventListener("click", options.onProvider);
-  row.appendChild(providerButton);
-
-  return { element: row, createButton: createButton, providerButton: providerButton };
-}