clay-server 2.47.0-beta.6 → 3.0.0-beta.2

package/lib/session-split-groups.js

@@ -0,0 +1,298 @@
+var crypto = require("crypto");
+var fs = require("fs");
+var path = require("path");
+
+function truncateTitle(title) {
+  var value = String(title || "New Session");
+  return value.length > 20 ? value.slice(0, 19) + "…" : value;
+}
+
+function autoGroupName(leftTitle, rightTitle) {
+  return truncateTitle(leftTitle) + " | " + truncateTitle(rightTitle);
+}
+
+function createSplitGroupStore(opts) {
+  var sessions = opts.sessions;
+  var groupsFile = path.join(opts.sessionsDir, "split-groups.json");
+  var usersModule = opts.usersModule;
+  var broadcast = opts.broadcast || function () {};
+  var groups = [];
+
+  // localIds are reassigned on every daemon restart (loadSessions renumbers
+  // by createdAt), so persisted member localIds go stale as soon as the
+  // session set changes. cliSessionIds are the durable anchor: keep them on
+  // every record and remap members from them at load.
+  function currentCliIds(group) {
+    var left = sessions.get(group.members[0]);
+    var right = sessions.get(group.members[1]);
+    var prev = Array.isArray(group.memberCliIds) ? group.memberCliIds : [null, null];
+    return [
+      (left && left.cliSessionId) || prev[0] || null,
+      (right && right.cliSessionId) || prev[1] || null,
+    ];
+  }
+
+  function refreshPairAnchors(group) {
+    if (!group.pair) return;
+    var driver = sessions.get(group.pair.driverId);
+    var worker = sessions.get(group.pair.workerId);
+    group.pairCliIds = [
+      (driver && driver.cliSessionId) || (group.pairCliIds && group.pairCliIds[0]) || null,
+      (worker && worker.cliSessionId) || (group.pairCliIds && group.pairCliIds[1]) || null,
+    ];
+  }
+
+  function sessionByCliId(cliId) {
+    if (!cliId) return null;
+    var found = null;
+    sessions.forEach(function (s) {
+      if (s.cliSessionId === cliId) found = s;
+    });
+    return found;
+  }
+
+  function save() {
+    for (var gi = 0; gi < groups.length; gi++) {
+      groups[gi].memberCliIds = currentCliIds(groups[gi]);
+      refreshPairAnchors(groups[gi]);
+    }
+    var tmp = groupsFile + ".tmp." + process.pid;
+    fs.mkdirSync(opts.sessionsDir, { recursive: true });
+    fs.writeFileSync(tmp, JSON.stringify(groups, null, 2) + "\n");
+    if (process.platform !== "win32") {
+      try { fs.chmodSync(tmp, 0o600); } catch (e) {}
+    }
+    fs.renameSync(tmp, groupsFile);
+  }
+
+  function validRecord(group) {
+    return group && typeof group.id === "string" && Array.isArray(group.members) &&
+      group.members.length === 2 && group.members[0] !== group.members[1] &&
+      Number.isInteger(group.members[0]) && Number.isInteger(group.members[1]) &&
+      sessions.has(group.members[0]) && sessions.has(group.members[1]);
+  }
+
+  function load() {
+    var loaded = [];
+    var shouldRewrite = false;
+    try {
+      loaded = JSON.parse(fs.readFileSync(groupsFile, "utf8"));
+      if (!Array.isArray(loaded)) loaded = [];
+    } catch (e) {
+      if (e.code !== "ENOENT") shouldRewrite = true;
+    }
+    var claimed = {};
+    groups = loaded.filter(function (group) {
+      // Remap members from the durable cliSessionIds; the stored localIds
+      // are only trusted for legacy records that predate memberCliIds.
+      if (group && Array.isArray(group.memberCliIds)) {
+        var left = sessionByCliId(group.memberCliIds[0]);
+        var right = sessionByCliId(group.memberCliIds[1]);
+        if (!left || !right || left === right) return false;
+        if (group.members[0] !== left.localId || group.members[1] !== right.localId) {
+          group.members = [left.localId, right.localId];
+          shouldRewrite = true;
+        }
+      }
+      if (group && group.pair && Array.isArray(group.pairCliIds)) {
+        var driver = sessionByCliId(group.pairCliIds[0]);
+        var worker = sessionByCliId(group.pairCliIds[1]);
+        if (driver && worker) {
+          group.pair.driverId = driver.localId;
+          group.pair.workerId = worker.localId;
+        }
+      }
+      if (group && group.pair) {
+        var pairValid = Array.isArray(group.members) && group.pair.driverId !== group.pair.workerId &&
+          group.members.indexOf(group.pair.driverId) !== -1 &&
+          group.members.indexOf(group.pair.workerId) !== -1;
+        if (!pairValid) return false;
+      }
+      if (!validRecord(group) || claimed[group.members[0]] || claimed[group.members[1]]) return false;
+      claimed[group.members[0]] = true;
+      claimed[group.members[1]] = true;
+      return true;
+    });
+    if (groups.length !== loaded.length) shouldRewrite = true;
+    if (shouldRewrite) save();
+  }
+
+  function isMultiUser() {
+    return !!(usersModule && usersModule.isMultiUser && usersModule.isMultiUser());
+  }
+
+  function listFor(ws) {
+    if (!isMultiUser()) return groups.slice();
+    if (!ws || !ws._clayUser) return [];
+    return groups.filter(function (group) { return group.ownerId === ws._clayUser.id; });
+  }
+
+  function groupForMember(localId) {
+    for (var i = 0; i < groups.length; i++) {
+      if (groups[i].members.indexOf(localId) !== -1) return groups[i];
+    }
+    return null;
+  }
+
+  function canAccess(ws, session) {
+    if (!isMultiUser()) return true;
+    return !!(ws && ws._clayUser && usersModule.canAccessSession(
+      ws._clayUser.id, session, { visibility: "public" }
+    ));
+  }
+
+  function canOwn(ws, group) {
+    return !isMultiUser() || !!(ws && ws._clayUser && group.ownerId === ws._clayUser.id);
+  }
+
+  function create(ws, msg) {
+    var members = msg && msg.members;
+    if (!Array.isArray(members) || members.length !== 2) return { ok: false, error: "A split group requires exactly two sessions" };
+    if (!Number.isInteger(members[0]) || !Number.isInteger(members[1]) || members[0] === members[1]) {
+      return { ok: false, error: "Split group members must be two distinct session ids" };
+    }
+    var left = sessions.get(members[0]);
+    var right = sessions.get(members[1]);
+    if (!left || !right) return { ok: false, error: "Session not found" };
+    if (!canAccess(ws, left) || !canAccess(ws, right)) return { ok: false, error: "Session access denied" };
+    if (groupForMember(members[0]) || groupForMember(members[1])) return { ok: false, error: "A session can belong to only one split group" };
+    var requestedName = typeof msg.name === "string" ? msg.name.trim().slice(0, 80) : "";
+    var group = {
+      id: "sg_" + Date.now().toString(36) + "_" + crypto.randomBytes(3).toString("hex"),
+      name: requestedName || autoGroupName(left.title, right.title),
+      nameCustomized: !!requestedName,
+      ownerId: isMultiUser() && ws && ws._clayUser ? ws._clayUser.id : null,
+      members: members.slice(),
+      createdAt: Date.now(),
+    };
+    if (msg.pair) {
+      if (msg.pair.driverId === msg.pair.workerId || members.indexOf(msg.pair.driverId) === -1 || members.indexOf(msg.pair.workerId) === -1) {
+        return { ok: false, error: "Pair roles must reference both split group members" };
+      }
+      group.pair = { driverId: msg.pair.driverId, workerId: msg.pair.workerId };
+    }
+    groups.push(group);
+    save();
+    broadcast();
+    return { ok: true, group: group };
+  }
+
+  function rename(ws, msg) {
+    var group = groups.find(function (item) { return item.id === (msg && msg.id); });
+    if (!group) return { ok: false, error: "Split group not found" };
+    if (!canOwn(ws, group)) return { ok: false, error: "Only the group owner can rename it" };
+    var name = typeof msg.name === "string" ? msg.name.trim().slice(0, 80) : "";
+    if (!name) return { ok: false, error: "Group name is required" };
+    group.name = name;
+    group.nameCustomized = true;
+    save();
+    broadcast();
+    return { ok: true, group: group };
+  }
+
+  // Assign or clear Driver/Worker roles on an existing group. driverId null
+  // clears the pair (back to ad-hoc: both members get the partner tools).
+  // Role changes apply to tool mounting on the next query start; the runtime
+  // guard in project-session-pair enforces them immediately for live queries.
+  function setPair(ws, msg) {
+    var group = groups.find(function (item) { return item.id === (msg && msg.id); });
+    if (!group) return { ok: false, error: "Split group not found" };
+    if (!canOwn(ws, group)) return { ok: false, error: "Only the group owner can change pair roles" };
+    if (msg.driverId == null) {
+      delete group.pair;
+      delete group.pairCliIds;
+      save();
+      broadcast();
+      return { ok: true, group: group };
+    }
+    if (!Number.isInteger(msg.driverId) || group.members.indexOf(msg.driverId) === -1) {
+      return { ok: false, error: "Driver must be a member of the split group" };
+    }
+    var workerId = group.members[0] === msg.driverId ? group.members[1] : group.members[0];
+    group.pair = { driverId: msg.driverId, workerId: workerId };
+    save();
+    broadcast();
+    return { ok: true, group: group };
+  }
+
+  function dissolve(ws, msg) {
+    var index = groups.findIndex(function (item) { return item.id === (msg && msg.id); });
+    if (index === -1) return { ok: false, error: "Split group not found" };
+    if (!canOwn(ws, groups[index])) return { ok: false, error: "Only the group owner can separate it" };
+    var removed = groups.splice(index, 1)[0];
+    save();
+    broadcast();
+    return { ok: true, group: removed };
+  }
+
+  function dissolveBySession(localId) {
+    var before = groups.length;
+    groups = groups.filter(function (group) { return group.members.indexOf(localId) === -1; });
+    if (groups.length === before) return false;
+    save();
+    broadcast();
+    return true;
+  }
+
+  function refreshAutoName(localId) {
+    var group = groupForMember(localId);
+    if (!group) return false;
+    if (group.nameCustomized) {
+      // Auto-title fires on a member's first message, which is also when a
+      // blank member gains its cliSessionId. Re-save so the durable anchor
+      // is captured even when the name itself stays untouched.
+      var fresh = currentCliIds(group);
+      var prev = Array.isArray(group.memberCliIds) ? group.memberCliIds : [null, null];
+      if (fresh[0] !== prev[0] || fresh[1] !== prev[1]) save();
+      return false;
+    }
+    group.name = autoGroupName(sessions.get(group.members[0]).title, sessions.get(group.members[1]).title);
+    save();
+    broadcast();
+    return true;
+  }
+
+  load();
+  return { create: create, rename: rename, setPair: setPair, dissolve: dissolve, dissolveBySession: dissolveBySession,
+    refreshAutoName: refreshAutoName,
+    listFor: listFor, groupForMember: groupForMember, get groups() { return groups; } };
+}
+
+function attachSplitGroups(ctx) {
+  var store = createSplitGroupStore({
+    sessions: ctx.sm.sessions,
+    sessionsDir: ctx.sm.sessionsDir,
+    usersModule: ctx.usersModule,
+    broadcast: broadcast,
+  });
+
+  function sendState(ws) {
+    if (!ws || ws._clayPane) return;
+    ctx.sendTo(ws, { type: "split_groups", groups: store.listFor(ws) });
+  }
+
+  function broadcast() {
+    for (var ws of ctx.clients) {
+      if (ws.readyState === 1) sendState(ws);
+    }
+  }
+
+  function handleMessage(ws, msg) {
+    var action = null;
+    var result = null;
+    if (msg.type === "split_group_create") { action = "create"; result = store.create(ws, msg); }
+    else if (msg.type === "split_group_rename") { action = "rename"; result = store.rename(ws, msg); }
+    else if (msg.type === "split_group_dissolve") { action = "dissolve"; result = store.dissolve(ws, msg); }
+    else if (msg.type === "split_group_set_pair") { action = "set_pair"; result = store.setPair(ws, msg); }
+    else return false;
+    ctx.sendTo(ws, { type: "split_group_result", action: action, ok: result.ok, error: result.error || null, group: result.group || null });
+    return true;
+  }
+
+  ctx.sm.setOnSessionDeleted(store.dissolveBySession);
+  ctx.sm.setOnSessionRenamed(store.refreshAutoName);
+  return { handleMessage: handleMessage, sendConnectionState: sendState, store: store };
+}
+
+module.exports = { attachSplitGroups: attachSplitGroups, createSplitGroupStore: createSplitGroupStore,
+  autoGroupName: autoGroupName };

package/lib/sessions.js

@@ -4,6 +4,7 @@ var config = require("./config");
 var utils = require("./utils");
 var users = require("./users");
 var { CODEX_DEFAULTS } = require("./codex-defaults");
+var hygiene = require("./session-hygiene");
 
 function createSessionManager(opts) {
   var cwd = opts.cwd;
@@ -12,6 +13,8 @@ function createSessionManager(opts) {
   var sendEach = opts.sendEach || null; // function(fn) - call fn(ws) for each connected client
   var sendAndRecord = null;      // set after init via setSendAndRecord
   var onSessionDone = opts.onSessionDone || function () {};
+  var onSessionDeleted = opts.onSessionDeleted || function () {};
+  var onSessionRenamed = opts.onSessionRenamed || function () {};
 
   // --- Multi-session state ---
   var nextLocalId = 1;
@@ -29,10 +32,62 @@ function createSessionManager(opts) {
   var codexWebSearch = CODEX_DEFAULTS.webSearch;
 
   // --- Session persistence (centralized in ~/.clay/sessions/{encoded-cwd}/) ---
-  var sessionsBase = path.join(config.CONFIG_DIR, "sessions");
+  var sessionsBase = opts.sessionsBase || path.join(config.CONFIG_DIR, "sessions");
   var encodedCwd = utils.resolveEncodedDir(sessionsBase, cwd);
   var sessionsDir = path.join(sessionsBase, encodedCwd);
   fs.mkdirSync(sessionsDir, { recursive: true });
+  var cliSessionsDir = opts.cliSessionsDir || path.join(config.REAL_HOME, ".claude", "projects", utils.encodeCwd(cwd));
+  var deletedCliSessionsPath = path.join(sessionsDir, "deleted-cli-sessions.json");
+  var deletedCliSessionIds = new Set();
+  try {
+    var deletedCliData = JSON.parse(fs.readFileSync(deletedCliSessionsPath, "utf8"));
+    var deletedCliIds = Array.isArray(deletedCliData) ? deletedCliData : deletedCliData.sessionIds;
+    if (Array.isArray(deletedCliIds)) {
+      for (var dci = 0; dci < deletedCliIds.length; dci++) {
+        if (typeof deletedCliIds[dci] === "string") deletedCliSessionIds.add(deletedCliIds[dci]);
+      }
+    }
+  } catch (e) {}
+
+  function rememberDeletedCliSession(cliSessionId) {
+    if (!cliSessionId || deletedCliSessionIds.has(cliSessionId)) return;
+    deletedCliSessionIds.add(cliSessionId);
+    try {
+      var data = JSON.stringify({ version: 1, sessionIds: Array.from(deletedCliSessionIds) }, null, 2) + "\n";
+      var tmpPath = deletedCliSessionsPath + ".tmp." + process.pid;
+      fs.writeFileSync(tmpPath, data);
+      if (process.platform !== "win32") {
+        try { fs.chmodSync(tmpPath, 0o600); } catch (chmodErr) {}
+      }
+      fs.renameSync(tmpPath, deletedCliSessionsPath);
+    } catch (e) {
+      console.error("[session] Failed to remember deleted CLI session:", e.message);
+    }
+  }
+
+  function readCliTranscriptHead(filePath) {
+    var MAX_READ = 64 * 1024;
+    try {
+      var stat = fs.statSync(filePath);
+      var fd = fs.openSync(filePath, "r");
+      var bytesToRead = Math.min(stat.size, MAX_READ);
+      var buf = Buffer.alloc(bytesToRead);
+      fs.readSync(fd, buf, 0, bytesToRead, 0);
+      fs.closeSync(fd);
+      var lines = buf.toString("utf8").split("\n");
+      var events = [];
+      for (var i = 0; i < lines.length; i++) {
+        if (!lines[i]) continue;
+        try {
+          var event = JSON.parse(lines[i]);
+          if (event && typeof event === "object") events.push(event);
+        } catch (e) {}
+      }
+      return events;
+    } catch (e) {
+      return null;
+    }
+  }
 
   // Auto-migrate sessions from legacy locations:
   //   v1: {cwd}/.claude-relay/sessions/
@@ -94,15 +149,20 @@ function createSessionManager(opts) {
       };
       if (session.ownerId) metaObj.ownerId = session.ownerId;
       if (session.vendor) metaObj.vendor = session.vendor;
+      if (session.model) metaObj.model = session.model;
+      if (session.effort) metaObj.effort = session.effort;
       // Persist the session's "born" mode so TUI sessions reappear after a
       // daemon restart. terminalId/runtimeMode/runtimeTerminalId are
       // transient (PTY ids don't survive restart), so they aren't stored;
       // the click handler will respawn the PTY via `claude --resume` when
       // the user reopens the session.
       if (session.mode === "tui") metaObj.mode = "tui";
+      if (session.adopted) metaObj.adopted = true;
       // Born-TUI sessions launched in bypass-permissions mode persist the flag
       // so lazy-resume (`claude --resume`) re-spawns with the same flag.
       if (session.dangerouslySkipPermissions) metaObj.dangerouslySkipPermissions = true;
+      if (session.permissionMode) metaObj.permissionMode = session.permissionMode;
+      if (session.permissionModeBeforeFullAccess) metaObj.permissionModeBeforeFullAccess = session.permissionModeBeforeFullAccess;
       if (session.sessionVisibility) metaObj.sessionVisibility = session.sessionVisibility;
       if (session.bookmarked) metaObj.bookmarked = true;
       if (typeof session.favoriteOrder === "number") metaObj.favoriteOrder = session.favoriteOrder;
@@ -144,6 +204,16 @@ function createSessionManager(opts) {
     }
   }
 
+  function deriveSessionModel(history) {
+    for (var i = history.length - 1; i >= 0; i--) {
+      var modelUsage = history[i] && history[i].modelUsage;
+      if (!modelUsage || typeof modelUsage !== "object") continue;
+      var models = Object.keys(modelUsage);
+      if (models.length > 0) return models[0];
+    }
+    return null;
+  }
+
   function loadSessions() {
     var files;
     try { files = fs.readdirSync(sessionsDir); } catch { return; }
@@ -207,6 +277,8 @@ function createSessionManager(opts) {
         lastRewindUuid: m.lastRewindUuid || null,
       };
       if (m.vendor) session.vendor = m.vendor;
+      session.model = m.model || deriveSessionModel(loaded[i].history);
+      session.effort = m.effort || null;
       if (m.loop) session.loop = m.loop;
       if (m.spawn) session.spawn = m.spawn;
       if (m.debateState) session.debateState = m.debateState;
@@ -217,7 +289,13 @@ function createSessionManager(opts) {
       // here so it shows up in the sidebar with the right icon; the
       // switch_session handler respawns the PTY on click.
       session.mode = (m.mode === "tui") ? "tui" : "gui";
-      session.dangerouslySkipPermissions = !!m.dangerouslySkipPermissions;
+      if (m.adopted) session.adopted = true;
+      // The dangerous CLI flag belongs to born-TUI sessions only. Migrate any
+      // GUI metadata written by the short-lived full-access implementation to
+      // Clay's own per-session permission mode.
+      session.dangerouslySkipPermissions = session.mode === "tui" && !!m.dangerouslySkipPermissions;
+      session.permissionMode = m.permissionMode || (session.mode === "gui" && m.dangerouslySkipPermissions ? "bypassPermissions" : null);
+      session.permissionModeBeforeFullAccess = m.permissionModeBeforeFullAccess || null;
       session.terminalId = null;
       session.runtimeMode = null;
       session.runtimeTerminalId = null;
@@ -243,13 +321,11 @@ function createSessionManager(opts) {
   // Strict skip rules:
   //   - cliSessionId already known to Clay  (avoids duplicate records)
   //   - File has zero user messages         (incomplete / corrupted file)
-  //   - Warmup shape: 1 user message that is literal "hi", 0 assistant
-  //     messages (covered by daemon cleanup but defensive here too)
+  //   - Warmup shape: 1 real "hi" prompt, optional automatic interruption,
+  //     and 0 assistant messages (covered by daemon cleanup but defensive)
   function adoptOrphanedCliSessions() {
-    var encodedCwd = utils.encodeCwd(cwd);
-    var cliDir = path.join(config.REAL_HOME, ".claude", "projects", encodedCwd);
     var files;
-    try { files = fs.readdirSync(cliDir); } catch (e) { return; }
+    try { files = fs.readdirSync(cliSessionsDir); } catch (e) { return; }
 
     // Build set of cliSessionIds Clay already tracks
     var knownCliIds = new Set();
@@ -257,37 +333,22 @@ function createSessionManager(opts) {
       if (s.cliSessionId) knownCliIds.add(s.cliSessionId);
     });
 
-    var MAX_READ = 64 * 1024;  // first 64KB is enough for first user message
     var adopted = 0;
 
     for (var i = 0; i < files.length; i++) {
       if (!files[i].endsWith(".jsonl")) continue;
       var cliSid = files[i].slice(0, -".jsonl".length);
       if (knownCliIds.has(cliSid)) continue;
+      if (deletedCliSessionIds.has(cliSid)) continue;
 
-      var fp = path.join(cliDir, files[i]);
-      var raw;
-      try {
-        var stat = fs.statSync(fp);
-        var fd = fs.openSync(fp, "r");
-        var bytesToRead = Math.min(stat.size, MAX_READ);
-        var buf = Buffer.alloc(bytesToRead);
-        fs.readSync(fd, buf, 0, bytesToRead, 0);
-        fs.closeSync(fd);
-        raw = buf.toString("utf8");
-      } catch (e) { continue; }
-
-      var lines = raw.split("\n");
+      var fp = path.join(cliSessionsDir, files[i]);
+      var events = readCliTranscriptHead(fp);
+      if (!events) continue;
       var userCount = 0;
-      var assistantCount = 0;
       var firstUserText = null;
       var createdAtIso = null;
-      for (var li = 0; li < lines.length; li++) {
-        var line = lines[li];
-        if (!line) continue;
-        var ev;
-        try { ev = JSON.parse(line); } catch (e) { continue; }
-        if (!ev || typeof ev !== "object") continue;
+      for (var li = 0; li < events.length; li++) {
+        var ev = events[li];
         if (ev.type === "user" && ev.message && ev.message.role === "user") {
           userCount++;
           if (firstUserText == null) {
@@ -303,14 +364,12 @@ function createSessionManager(opts) {
             }
             if (ev.timestamp && !createdAtIso) createdAtIso = ev.timestamp;
           }
-        } else if (ev.type === "assistant") {
-          assistantCount++;
         }
       }
 
       if (userCount === 0) continue;
       // Defensive warmup skip (daemon also cleans these)
-      if (userCount === 1 && assistantCount === 0 && firstUserText === "hi") continue;
+      if (hygiene.isClaudeWarmupTranscript(events)) continue;
 
       // Title: first user message trimmed/truncated. Fall back to a
       // neutral label so the sidebar entry is identifiable.
@@ -345,6 +404,10 @@ function createSessionManager(opts) {
         lastRewindUuid: null,
         vendor: "claude",
         mode: "tui",
+        // Adopted from an external `claude` run in this cwd, not started by
+        // Clay. Notification emitters must stay silent for these until the
+        // user actually opens them in Clay (a PTY gets attached).
+        adopted: true,
         terminalId: null,
         runtimeMode: null,
         runtimeTerminalId: null,
@@ -363,9 +426,45 @@ function createSessionManager(opts) {
     }
   }
 
+  // Remove rows created by older Clay versions that misclassified an SDK
+  // warmup transcript as a real external session. Deletion is tombstoned, so
+  // the preserved Claude file cannot be adopted again on the next restart.
+  function sweepAdoptedWarmupSessions() {
+    var stale = [];
+    sessions.forEach(function (session) {
+      if (!session.adopted || !session.cliSessionId) return;
+      var transcriptPath = path.join(cliSessionsDir, session.cliSessionId + ".jsonl");
+      var events = readCliTranscriptHead(transcriptPath);
+      var missingEmptySource = !fs.existsSync(transcriptPath) && (!session.history || session.history.length === 0);
+      if (missingEmptySource || (events && hygiene.isClaudeWarmupTranscript(events))) stale.push(session.localId);
+    });
+    for (var i = 0; i < stale.length; i++) deleteSessionQuiet(stale[i]);
+    if (stale.length > 0) {
+      console.log("[sessions] Removed " + stale.length + " adopted SDK warmup session(s) for " + cwd);
+    }
+  }
+
+  // Delete blank sessions (never used, nothing attached) that have sat
+  // untouched past the grace period. Runs at startup and on new_session.
+  function sweepBlankSessions() {
+    var stale = hygiene.collectStaleBlankSessions(sessions, activeSessionId, Date.now());
+    for (var i = 0; i < stale.length; i++) deleteSessionQuiet(stale[i]);
+    if (stale.length > 0) {
+      console.log("[sessions] Swept " + stale.length + " stale blank session(s) for " + cwd);
+      broadcastSessionList();
+    }
+    return stale.length;
+  }
+
+  function findReusableBlankSession(opts) {
+    return hygiene.findReusableBlankSession(sessions, opts);
+  }
+
   // Load persisted sessions from disk, then adopt any orphan CLI sessions
   loadSessions();
+  sweepAdoptedWarmupSessions();
   adoptOrphanedCliSessions();
+  sweepBlankSessions();
 
   function getActiveSession() {
     return sessions.get(activeSessionId) || null;
@@ -403,10 +502,14 @@ function createSessionManager(opts) {
       favoriteOrder: typeof s.favoriteOrder === "number" ? s.favoriteOrder : null,
       unread: unreadMap[s.localId] || 0,
       vendor: s.vendor || null,
+      model: s.model || null,
+      effort: s.effort || null,
       mode: s.mode || "gui",
       terminalId: typeof s.terminalId === "number" ? s.terminalId : null,
       runtimeMode: s.runtimeMode || null,
       runtimeTerminalId: typeof s.runtimeTerminalId === "number" ? s.runtimeTerminalId : null,
+      dangerouslySkipPermissions: !!s.dangerouslySkipPermissions,
+      permissionMode: s.permissionMode || null,
     };
   }
 
@@ -469,7 +572,12 @@ function createSessionManager(opts) {
       bookmarked: false,
       favoriteOrder: null,
       vendor: (sessionOpts && sessionOpts.vendor) || null,
+      model: (sessionOpts && sessionOpts.model) || null,
+      effort: (sessionOpts && sessionOpts.effort) || null,
       mode: (sessionOpts && sessionOpts.mode === "tui") ? "tui" : "gui",
+      dangerouslySkipPermissions: !!(sessionOpts && sessionOpts.mode === "tui" && sessionOpts.dangerouslySkipPermissions),
+      permissionMode: (sessionOpts && sessionOpts.permissionMode) || null,
+      permissionModeBeforeFullAccess: null,
       terminalId: null,
     };
     sessions.set(localId, session);
@@ -503,8 +611,12 @@ function createSessionManager(opts) {
       bookmarked: false,
       favoriteOrder: null,
       vendor: (sessionOpts && sessionOpts.vendor) || null,
+      model: (sessionOpts && sessionOpts.model) || null,
+      effort: (sessionOpts && sessionOpts.effort) || null,
       mode: (sessionOpts && sessionOpts.mode === "tui") ? "tui" : "gui",
-      dangerouslySkipPermissions: !!(sessionOpts && sessionOpts.dangerouslySkipPermissions),
+      dangerouslySkipPermissions: !!(sessionOpts && sessionOpts.mode === "tui" && sessionOpts.dangerouslySkipPermissions),
+      permissionMode: (sessionOpts && sessionOpts.permissionMode) || null,
+      permissionModeBeforeFullAccess: null,
       terminalId: null,
     };
     sessions.set(localId, session);
@@ -569,7 +681,11 @@ function createSessionManager(opts) {
     var session = sessions.get(localId);
     if (!session) return;
 
-    activeSessionId = localId;
+    // Pane sockets (split-view iframes) pin their session via switch_session
+    // but must not move the project-global active pointer: reloads and
+    // session_list "active" flags would otherwise follow whichever pane
+    // pinned last instead of what the user is actually looking at.
+    if (!(targetWs && targetWs._clayPane)) activeSessionId = localId;
     if (targetWs) {
       targetWs._clayActiveSession = localId;
       // Clear unread for this session (multi-user)
@@ -589,7 +705,7 @@ function createSessionManager(opts) {
     var _capsByVendor = capabilitiesByVendor || {};
     var _sessionVendor = session.vendor || defaultVendor || "claude";
     var _vendorCaps = _capsByVendor[_sessionVendor] || {};
-    _send({ type: "session_switched", id: localId, cliSessionId: session.cliSessionId || null, loop: session.loop || null, vendor: session.vendor || null, hasHistory: (session.history && session.history.length > 0), capabilities: _vendorCaps, isProcessing: !!session.isProcessing, mode: session.mode || "gui", terminalId: typeof session.terminalId === "number" ? session.terminalId : null, runtimeMode: session.runtimeMode || null, runtimeTerminalId: typeof session.runtimeTerminalId === "number" ? session.runtimeTerminalId : null, tuiSuspended: !!session.tuiSuspended });
+    _send({ type: "session_switched", id: localId, cliSessionId: session.cliSessionId || null, loop: session.loop || null, vendor: session.vendor || null, model: session.model || null, effort: session.effort || null, hasHistory: (session.history && session.history.length > 0), capabilities: _vendorCaps, isProcessing: !!session.isProcessing, mode: session.mode || "gui", terminalId: typeof session.terminalId === "number" ? session.terminalId : null, runtimeMode: session.runtimeMode || null, runtimeTerminalId: typeof session.runtimeTerminalId === "number" ? session.runtimeTerminalId : null, tuiSuspended: !!session.tuiSuspended, dangerouslySkipPermissions: !!session.dangerouslySkipPermissions, permissionMode: session.permissionMode || null });
     // Send vendor-specific slash commands
     var _vendorCmds = slashCommandsByVendor[_sessionVendor] || slashCommands || [];
     _send({ type: "slash_commands", commands: _vendorCmds, vendor: _sessionVendor });
@@ -656,10 +772,14 @@ function createSessionManager(opts) {
     }
 
     if (session.cliSessionId) {
+      rememberDeletedCliSession(session.cliSessionId);
       try { fs.unlinkSync(sessionFilePath(session.cliSessionId)); } catch(e) {}
     }
 
     sessions.delete(localId);
+    try { onSessionDeleted(localId); } catch (e) {
+      console.error("[session] Session deletion hook failed:", e.message || e);
+    }
 
     if (activeSessionId === localId) {
       var remaining = [...sessions.keys()];
@@ -694,9 +814,13 @@ function createSessionManager(opts) {
       session.worker = null;
     }
     if (session.cliSessionId) {
+      rememberDeletedCliSession(session.cliSessionId);
       try { fs.unlinkSync(sessionFilePath(session.cliSessionId)); } catch(e) {}
     }
     sessions.delete(localId);
+    try { onSessionDeleted(localId); } catch (e) {
+      console.error("[session] Session deletion hook failed:", e.message || e);
+    }
   }
 
   function deleteSessionsBulk(localIds, targetWs) {
@@ -1054,6 +1178,9 @@ function createSessionManager(opts) {
     set codexWebSearch(v) { codexWebSearch = v; },
     sessions: sessions,
     sessionsDir: sessionsDir,
+    setOnSessionDeleted: function (fn) { onSessionDeleted = fn || function () {}; },
+    setOnSessionRenamed: function (fn) { onSessionRenamed = fn || function () {}; },
+    notifySessionRenamed: function (localId) { onSessionRenamed(localId); },
     HISTORY_PAGE_SIZE: HISTORY_PAGE_SIZE,
     getActiveSession: getActiveSession,
     createSession: createSession,
@@ -1062,6 +1189,8 @@ function createSessionManager(opts) {
     deleteSession: deleteSession,
     deleteSessionQuiet: deleteSessionQuiet,
     deleteSessionsBulk: deleteSessionsBulk,
+    sweepBlankSessions: sweepBlankSessions,
+    findReusableBlankSession: findReusableBlankSession,
     resumeSession: resumeSession,
     broadcastSessionList: broadcastSessionList,
     getTotalUnread: function (ws) {