clay-server 5.1.0-beta.2 → 5.1.0

package/lib/sdk-message-processor.js

@@ -6,11 +6,13 @@ var yoke = require("./yoke");
 var backgroundTaskTiming = require("./background-task-timing");
 var sessionTitlePolicy = require("./session-title-policy");
 var askUserIdentity = require("./ask-user-request-identity");
+var quotaSnapshots = require("./sdk-quota-snapshot");
 
 var OVERLOAD_RETRY_LIMIT = 3;
 
 function attachMessageProcessor(ctx) {
   var sm = ctx.sm;
+  quotaSnapshots.attachQuotaSnapshots(sm);
   var send = ctx.send;
   var slug = ctx.slug;
   var isMate = ctx.isMate;
@@ -653,11 +655,13 @@ function attachMessageProcessor(ctx) {
         session._queuedTurnCount = 0;
         onProcessingChanged();
       }
-      // Detect "Not logged in" scenario early for the check below
+      // Recognize only short, zero-cost CLI login responses, not ordinary prose.
       var previewTrimmed = (session.responsePreview || "").trim();
       var isZeroCost = !parsed.cost || parsed.cost === 0;
       var isLoginPrompt = isZeroCost && previewTrimmed.length < 100
-        && /not logged in/i.test(previewTrimmed) && /\/login/i.test(previewTrimmed);
+        && ((/not logged in/i.test(previewTrimmed) && /\/login/i.test(previewTrimmed))
+          || ((session.vendor || "claude") === "claude"
+            && /^Failed to authenticate: OAuth session expired and could not be refreshed\.?$/i.test(previewTrimmed)));
       // Fetch rich context usage breakdown (fire-and-forget, non-blocking)
       if (session.queryInstance && typeof session.queryInstance.getContextUsage === "function") {
         var contextQuery = session.queryInstance;
@@ -692,7 +696,7 @@ function attachMessageProcessor(ctx) {
       if (parsed.fastModeState) {
         sendAndRecord(session, { type: "fast_mode_state", state: parsed.fastModeState });
       }
-      // Detect "Not logged in / Please run /login" from SDK.
+      // Recover both missing login and expired OAuth sessions from the SDK.
       // This is a short canned response with zero cost, not actual AI output.
       if (isLoginPrompt) {
         emitAuthRequired(session);
@@ -853,6 +857,10 @@ function attachMessageProcessor(ctx) {
 
     } else if (parsed.yokeType === "rate_limit") {
       var info = parsed.rateLimitInfo;
+      if (info.source === "account_snapshot") {
+        quotaSnapshots.recordQuotaSnapshot(session, info, sendAndRecord);
+        return;
+      }
       console.log("[sdk-bridge] rate_limit_event for session " + session.localId + ": status=" + info.status + " resetsAt=" + info.resetsAt + " isUsingOverage=" + info.isUsingOverage + " isProcessing=" + session.isProcessing);
 
       // Persist the scoped reset snapshot so reconnect/history restore can reproject it.
@@ -877,7 +885,11 @@ function attachMessageProcessor(ctx) {
           resetsAt: info.resetsAt ? info.resetsAt * 1000 : null,
           rateLimitType: info.rateLimitType || null,
           utilization: info.utilization || null,
-          isUsingOverage: info.isUsingOverage || false,
+          isUsingOverage: info.isUsingOverage === true || info.overageInUse === true,
+          overageEnabled: typeof info.overageEnabled === "boolean" ? info.overageEnabled : null,
+          overageStatus: info.overageStatus || null,
+          overageResetsAt: info.overageResetsAt ? info.overageResetsAt * 1000 : null,
+          overageDisabledReason: info.overageDisabledReason || null,
         });
         // Track rejection for auto-continue / scheduled message support
         if (info.status === "rejected" && info.resetsAt) {

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-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-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

@@ -1,6 +1,6 @@
+var resolveMateIdentityFile = require('./mate-identity-file').resolveMateIdentityFile;
 // 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'); }
@@ -11,7 +11,7 @@ function handleMateInstructions(mates, ws, msg, userId) {
     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');
+    var file = resolveMateIdentityFile(directory);
     if (!fs.lstatSync(file).isFile()) throw new Error('Mate instructions are unavailable.');
     var content = fs.readFileSync(file, 'utf8');
     var identity = mates.extractIdentity(content);

package/lib/server-mates.js

@@ -1,3 +1,4 @@
+var resolveMateIdentityFile = require('./mate-identity-file').resolveMateIdentityFile;
 var fs = require("fs");
 var path = require("path");
 var handleMateInstructions = require('./server-mate-instructions').handleMateInstructions;
@@ -32,7 +33,7 @@ function attachMates(ctx) {
       });
       for (var ri = 0; ri < allMates.length; ri++) {
         var mDir = mates.getMateDir(mateCtx, allMates[ri].id);
-        var claudePath = path.join(mDir, "CLAUDE.md");
+        var claudePath = resolveMateIdentityFile(mDir);
         try {
           mates.enforceAllSections(claudePath, { ctx: mateCtx, mateId: allMates[ri].id, projects: projList });
         } catch (e) {}

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-settings.js

@@ -12,9 +12,13 @@ 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") {

package/lib/server-storage.js

@@ -0,0 +1,57 @@
+var scanStorage = require('./storage-usage').scanStorage;
+
+function attachStorage(ctx) {
+  var pending = null;
+  var cached = null;
+  var progress = null;
+  var expires = 0;
+  var failed = false;
+  function reply(res, status, data) {
+    res.writeHead(status, { 'Content-Type': 'application/json', 'Cache-Control': 'no-store' });
+    res.end(JSON.stringify(data));
+  }
+  function authorized(req, res) {
+    if (!ctx.isRequestAuthed(req)) { reply(res, 401, { error: 'Authentication required.' }); return false; }
+    var user = ctx.getMultiUserFromReq(req);
+    if (ctx.users.isMultiUser() && (!user || user.role !== 'admin')) {
+      reply(res, 403, { error: 'Only server administrators can view disk usage.' }); return false;
+    }
+    return true;
+  }
+  function handleRequest(req, res, url) {
+    if (url.split('?')[0] !== '/api/server/storage') return false;
+    var refresh = new URL(url, 'http://localhost').searchParams.get('refresh') === '1';
+    if (!authorized(req, res)) return true;
+    if (req.method !== 'GET') { reply(res, 405, { error: 'Method not allowed.' }); return true; }
+    if (failed && Date.now() < expires) { reply(res, 500, { error: 'Disk usage could not be measured. Try again in a few seconds.' }); return true; }
+    if (!pending && !refresh && cached && Date.now() < expires) { reply(res, 200, cached); return true; }
+    if (!pending) {
+      progress = null; failed = false;
+      var users = ctx.users.getAllUsers();
+      var projects = ctx.getProjects ? ctx.getProjects() : [];
+      if (!ctx.users.isMultiUser() && users.length <= 1) {
+        if (!users.length) users = [{ id: 'local', username: 'Local user' }];
+        projects = projects.map(function (project) { return Object.assign({}, project, { projectOwnerId: project.projectOwnerId || users[0].id }); });
+      }
+      pending = (ctx.scanStorage || scanStorage)({ configDir: ctx.configDir, platform: process.platform,
+        attribution: ctx.osUsers && ctx.users.isMultiUser() && process.platform === 'linux' ? 'filesystem' : 'project',
+        users: users, projects: projects, onProgress: function (data) { progress = data; },
+        projectPaths: ctx.getProjectPaths ? ctx.getProjectPaths() : [] }).then(function (result) {
+        cached = result; expires = Date.now() + 300000; return result;
+      }).catch(function (error) { failed = true; expires = Date.now() + 5000; throw error; }).finally(function () { pending = null; });
+    }
+    var timer;
+    Promise.race([pending, new Promise(function (resolve) {
+      timer = setTimeout(function () { resolve(progress || { scanning: true }); }, 750);
+    })]).then(function (result) {
+      clearTimeout(timer);
+      if (!res.destroyed && authorized(req, res)) reply(res, result.scanning ? 202 : 200, result);
+    }).catch(function () {
+      clearTimeout(timer);
+      if (!res.destroyed) reply(res, 500, { error: 'Disk usage could not be measured. Try refreshing.' });
+    });
+    return true;
+  }
+  return { handleRequest: handleRequest };
+}
+module.exports = { attachStorage: attachStorage };

package/lib/server.js

@@ -188,7 +188,6 @@ function createServer(opts) {
   var onGetDaemonConfig = opts.onGetDaemonConfig || null;
   var onSetPin = opts.onSetPin || null;
   var onSetKeepAwake = opts.onSetKeepAwake || null;
-  var onSetInheritGroups = opts.onSetInheritGroups || null;
   var onSetImageRetention = opts.onSetImageRetention || null;
   var onShutdown = opts.onShutdown || null;
   var onRestart = opts.onRestart || null;
@@ -473,9 +472,14 @@ function createServer(opts) {
     users: users, getMultiUserFromReq: getMultiUserFromReq,
     isRequestAuthed: isRequestAuthed, opts: opts, getConfiguredOrigins: getConfiguredOrigins,
   });
+  var storageSettings = require('./server-storage').attachStorage({
+    users: users, getMultiUserFromReq: getMultiUserFromReq, isRequestAuthed: isRequestAuthed,
+    configDir: CONFIG_DIR, osUsers: osUsers, getProjects: getProjects,
+  });
   var logRejectedOrigin = createOriginRejectionLogger({ log: opts.onOriginRejectedLog });
 
   var settings = serverSettings.attachSettings({
+    isRequestAuthed: isRequestAuthed,
     users: users,
     mates: mates,
     getMultiUserFromReq: getMultiUserFromReq,
@@ -815,6 +819,7 @@ function createServer(opts) {
     if (linear.handleRequest(req, res, fullUrl)) return;
     if (speech.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;
 
     // --- Admin API endpoints (multi-user mode only) ---
@@ -1516,10 +1521,13 @@ function createServer(opts) {
       },
       onGetProjectMcpServers: onGetProjectMcpServers,
       onSetProjectMcpServers: onSetProjectMcpServers,
+      onGetSharedEnv: opts.onGetSharedEnv,
+      onSetSharedEnv: opts.onSetSharedEnv,
+      onGetProjectEnv: opts.onGetProjectEnv,
+      onSetProjectEnv: opts.onSetProjectEnv,
       onGetDaemonConfig: onGetDaemonConfig,
       onSetPin: onSetPin,
       onSetKeepAwake: onSetKeepAwake,
-      onSetInheritGroups: onSetInheritGroups,
       onSetImageRetention: onSetImageRetention,
       onSetUpdateChannel: onSetUpdateChannel,
       updateChannel: onGetDaemonConfig ? (onGetDaemonConfig().updateChannel || "stable") : "stable",

package/lib/sessions.js

@@ -444,9 +444,8 @@ function createSessionManager(opts) {
   // Adopt orphaned CLI sessions from ~/.claude/projects/<encoded-cwd>/ as
   // Clay session records. After this runs the sidebar shows a single
   // unified list of sessions regardless of whether they were born inside
-  // Clay or via the `claude` CLI directly. The user's claudeOpenMode pref
-  // decides how each click renders (TUI respawn vs GUI hydration) - both
-  // paths already exist for born-TUI sessions.
+  // Clay or via the `claude` CLI directly. Idle CLI sessions hydrate into
+  // Clay chat; already-running terminal runtimes keep their presentation.
   //
   // Adopted records are saved with mode='tui' because they originated in
   // the CLI, not via the SDK. The cross-mode click logic in
@@ -1410,7 +1409,7 @@ function createSessionManager(opts) {
           console.log("[session] Migrated " + migrated + " session title(s) to SDK format");
         }
         if (failed > 0) {
-          console.log("[session] Skipped " + failed + " session(s) (CLI session not found for current user)");
+          console.log("[session] Could not sync " + failed + " session title(s) to the provider; local titles and history are unchanged");
         }
       }).catch(function(e) {
         console.error("[session] Migration chain failed:", e.message || e);

package/lib/startup-projects.js

@@ -0,0 +1,40 @@
+// Saved project records are authoritative; filesystem availability only controls
+// runtime registration. Recent-project entries must never restore access grants.
+function buildStartupProjects(config, recent, options) {
+  var projects = [];
+  var paths = new Set();
+  var slugs = [];
+  var removed = new Set((config && config.removedProjects || []).map(function (p) { return p.path; }));
+  (config && config.projects || []).forEach(function (p) {
+    if (paths.has(p.path)) return;
+    projects.push(Object.assign({}, p));
+    paths.add(p.path);
+    slugs.push(p.slug);
+  });
+
+  function add(project) {
+    if (paths.has(project.path) || removed.has(project.path)) return;
+    if (!options.existsSync(project.path)) return;
+    var slug = options.generateSlug(project.path, slugs);
+    projects.push({
+      path: project.path,
+      slug: slug,
+      title: project.title || undefined,
+      icon: project.icon || undefined,
+      addedAt: project.addedAt || Date.now(),
+    });
+    paths.add(project.path);
+    slugs.push(slug);
+  }
+
+  if (options.addCwd) {
+    var cwdRecent = (recent || []).find(function (p) { return p.path === options.cwd; });
+    add(cwdRecent || { path: options.cwd });
+  }
+  (recent || []).forEach(function (p) {
+    if (p.path !== options.cwd) add(p);
+  });
+  return projects;
+}
+
+module.exports = { buildStartupProjects: buildStartupProjects };

package/lib/storage-native-walk.js

@@ -0,0 +1,85 @@
+var spawn = require('node:child_process').spawn;
+var execFile = require('node:child_process').execFile;
+var availability = null;
+var command = process.platform === 'linux' ? 'find' : 'gfind';
+
+function available() {
+  if (process.platform !== 'linux' && process.platform !== 'darwin') return Promise.resolve(false);
+  if (!availability) availability = new Promise(function (resolve) {
+    execFile(command, ['--version'], { timeout: 3000, maxBuffer: 4096 }, function (error, output) {
+      resolve(!error && output.indexOf('GNU findutils') !== -1);
+    });
+  });
+  return availability;
+}
+
+function literalPattern(value) {
+  return value.replace(/[\\*?\[\]]/g, '\\$&');
+}
+
+// NUL-delimited records keep tabs/newlines in filenames out of metadata parsing.
+function parseRecord(record) {
+  var fields = [];
+  var start = 0;
+  for (var i = 0; i < 6; i++) {
+    var end = record.indexOf('\t', start);
+    if (end < 0) throw new Error('Invalid native storage metadata');
+    fields.push(record.slice(start, end));
+    start = end + 1;
+  }
+  if (!fields.slice(0, 5).every(function (value) { return /^\d+$/.test(value); }) || !/^[a-z?]$/.test(fields[5])) {
+    throw new Error('Invalid native storage metadata');
+  }
+  return { path: record.slice(start), stat: {
+    dev: Number(fields[0]), ino: Number(fields[1]), uid: Number(fields[2]), blocks: Number(fields[3]), nlink: Number(fields[4]),
+    isDirectory: function () { return fields[5] === 'd'; },
+    isFile: function () { return fields[5] === 'f'; },
+    isSymbolicLink: function () { return fields[5] === 'l'; }
+  } };
+}
+
+function walk(root, excluded, onEntry, maxMs) {
+  return new Promise(function (resolve) {
+    var args = ['-P', root, '-xdev'];
+    if (excluded.length) {
+      args.push('(');
+      excluded.forEach(function (entry, index) {
+        if (index) args.push('-o');
+        args.push('-path', literalPattern(entry));
+      });
+      args.push(')', '-prune', '-o');
+    }
+    args.push('-printf', '%D\t%i\t%U\t%b\t%n\t%y\t%p\\0');
+    var child = spawn(command, args, { stdio: ['ignore', 'pipe', 'pipe'], env: Object.assign({}, process.env, { LC_ALL: 'C' }) });
+    var buffer = '';
+    var stopped = false;
+    var errors = 0;
+    var timer = null;
+    function stop() { stopped = true; child.kill('SIGKILL'); }
+    if (Number.isFinite(maxMs)) timer = setTimeout(stop, Math.max(1, maxMs));
+    child.stdout.setEncoding('utf8');
+    child.stdout.on('data', function (chunk) {
+      if (stopped) return;
+      buffer += chunk;
+      var end;
+      while (!stopped && (end = buffer.indexOf('\0')) !== -1) {
+        var record = buffer.slice(0, end);
+        buffer = buffer.slice(end + 1);
+        try {
+          var entry = parseRecord(record);
+          if (onEntry(entry.path, entry.stat) === false) stop();
+        } catch (error) { errors++; stop(); }
+      }
+      if (buffer.length > 1024 * 1024) { errors++; stop(); }
+    });
+    child.stderr.on('data', function () { errors = Math.max(1, errors); });
+    child.on('error', function () { errors++; });
+    child.on('close', function (code) {
+      clearTimeout(timer);
+      if (!stopped && (code !== 0 || buffer.length)) errors++;
+      resolve({ errors: errors, stopped: stopped });
+    });
+  });
+}
+
+module.exports = { available: available, walk: walk, parseRecord: parseRecord };