clay-server 4.1.0-beta.6 → 4.1.0-beta.7

package/lib/project-pending-message-queue.js

@@ -0,0 +1,264 @@
+var fs = require("fs");
+var path = require("path");
+var crypto = require("crypto");
+var config = require("./config");
+var sessionProvenance = require("./session-provenance");
+
+var MAX_TEXT = 100000;
+var MAX_PASTES = 20;
+var MAX_PASTE_LENGTH = 500000;
+var MAX_IMAGES = 20;
+var MAX_IMAGE_DATA = 25 * 1024 * 1024;
+var MAX_TOTAL_BYTES = 32 * 1024 * 1024;
+var MAX_ACTIVE_ITEMS = 100;
+var IMAGE_TYPE_RE = /^image\/[a-z0-9.+-]{1,64}$/i;
+var CLIENT_MESSAGE_ID_RE = /^[A-Za-z0-9._:-]{1,128}$/;
+
+function defaultFilePath(opts) {
+  var identity = String(opts.slug || "") + "\n" + path.resolve(opts.cwd || process.cwd());
+  return path.join(config.CONFIG_DIR, "pending-message-queues", crypto.createHash("sha256").update(identity).digest("hex") + ".json");
+}
+
+function createPendingMessageQueue(opts) {
+  var filePath = opts.filePath || defaultFilePath(opts);
+  var broadcast = opts.broadcast || opts.send || function () {};
+  var authorize = opts.authorize || function () { return true; };
+  var canMutate = opts.canMutate || authorize;
+  var loaded = load();
+  var data = loaded.data;
+  var loadError = loaded.error;
+
+  function emptyData() { return { version: 1, revision: 0, nextId: 1, items: [], paused: {} }; }
+  function validStored(parsed) {
+    if (!parsed || parsed.version !== 1 || !Number.isInteger(parsed.revision) || parsed.revision < 0 || !Number.isInteger(parsed.nextId) || parsed.nextId < 1 || !Array.isArray(parsed.items)) return false;
+    if (parsed.paused !== undefined && (!parsed.paused || typeof parsed.paused !== "object" || Array.isArray(parsed.paused))) return false;
+    var pausedKeys = Object.keys(parsed.paused || {});
+    for (var pausedIndex = 0; pausedIndex < pausedKeys.length; pausedIndex++) if (pausedKeys[pausedIndex].length > 300 || parsed.paused[pausedKeys[pausedIndex]] !== true) return false;
+    for (var i = 0; i < parsed.items.length; i++) {
+      var item = parsed.items[i];
+      if (!item || typeof item.id !== "string" || typeof item.sessionKey !== "string" || typeof item.projectSlug !== "string" || typeof item.actorId !== "string" || !item.message || ["pending", "claimed", "consumed", "cancelled", "failed"].indexOf(item.state) < 0) return false;
+    }
+    return true;
+  }
+  function load() {
+    if (!fs.existsSync(filePath)) return { data: emptyData(), error: null };
+    try {
+      var parsed = JSON.parse(fs.readFileSync(filePath, "utf8"));
+      if (!validStored(parsed)) return { data: emptyData(), error: "Queue storage is malformed" };
+      if (!parsed.paused) parsed.paused = {};
+      return { data: parsed, error: null };
+    } catch (e) {
+      return { data: emptyData(), error: "Queue storage is unreadable" };
+    }
+  }
+  function save() {
+    fs.mkdirSync(path.dirname(filePath), { recursive: true });
+    var tmp = filePath + ".tmp." + process.pid + "." + crypto.randomBytes(6).toString("hex");
+    fs.writeFileSync(tmp, JSON.stringify(data, null, 2) + "\n", { mode: 0o600 });
+    fs.renameSync(tmp, filePath);
+  }
+  var persist = opts.persist || save;
+  function key(session) {
+    var hadOrigin = !!(session && session.sessionOriginId);
+    var origin = sessionProvenance.ensureOrigin(session);
+    if (!hadOrigin && origin && typeof opts.ensureSessionIdentity === "function") opts.ensureSessionIdentity(session);
+    return String(origin);
+  }
+  function actorId(actor) { return actor && actor.id ? String(actor.id) : "default"; }
+  function copy(value) { return JSON.parse(JSON.stringify(value)); }
+  function restore(snapshot) { data.version = snapshot.version; data.revision = snapshot.revision; data.nextId = snapshot.nextId; data.items = snapshot.items; data.paused = snapshot.paused || {}; }
+  function targetKey(session) { return String(opts.slug) + ":" + key(session); }
+  function isPaused(session) { return !!(session && data.paused[targetKey(session)]); }
+  function sameTarget(item, session) { return !!(item && session && item.sessionKey === key(session) && item.projectSlug === opts.slug); }
+  function scoped(item, session, actor) { return sameTarget(item, session) && item.actorId === actorId(actor); }
+  function visible(session, actor) {
+    if (loadError || !session || !authorize(session, actor)) return [];
+    var out = [];
+    for (var i = 0; i < data.items.length; i++) if (sameTarget(data.items[i], session)) out.push(copy(data.items[i]));
+    return out;
+  }
+  function result(ok, error, session, actor) {
+    return { ok: ok, error: error || null, revision: data.revision, sessionId: session ? session.localId : null, projectSlug: opts.slug, paused: session ? isPaused(session) : false, items: session ? visible(session, actor) : [] };
+  }
+  function validateMessage(message) {
+    if (!message || typeof message !== "object" || Array.isArray(message)) return "Invalid message";
+    var text = message.text == null ? "" : message.text;
+    if (typeof text !== "string" || text.length > MAX_TEXT) return "Message text is invalid or too long";
+    var pastes = message.pastes == null ? [] : message.pastes;
+    if (!Array.isArray(pastes) || pastes.length > MAX_PASTES) return "Too many paste attachments";
+    for (var i = 0; i < pastes.length; i++) if (typeof pastes[i] !== "string" || pastes[i].length > MAX_PASTE_LENGTH) return "Invalid paste attachment";
+    var images = message.images == null ? [] : message.images;
+    if (!Array.isArray(images) || images.length > MAX_IMAGES) return "Too many image attachments";
+    for (var j = 0; j < images.length; j++) {
+      var image = images[j];
+      if (!image || typeof image !== "object" || !IMAGE_TYPE_RE.test(image.mediaType || "") || typeof image.data !== "string" || image.data.length > MAX_IMAGE_DATA) return "Invalid image attachment";
+    }
+    if (!text.trim() && !pastes.length && !images.length) return "Message must contain text or an attachment";
+    if (message.clientMessageId != null && (typeof message.clientMessageId !== "string" || !CLIENT_MESSAGE_ID_RE.test(message.clientMessageId))) return "Invalid client message identifier";
+    try { if (Buffer.byteLength(JSON.stringify(message), "utf8") > MAX_TOTAL_BYTES) return "Message payload is too large"; }
+    catch (e) { return "Invalid message payload"; }
+    return null;
+  }
+  function sanitizeImages(images) {
+    if (!Array.isArray(images)) return images;
+    return images.map(function (image) { return { mediaType: image.mediaType, data: image.data }; });
+  }
+  function inspect(session, actor, clientMessageId) {
+    if (loadError || !clientMessageId) return null;
+    for (var i = 0; i < data.items.length; i++) if (data.items[i].clientMessageId === clientMessageId && scoped(data.items[i], session, actor)) return copy(data.items[i]);
+    return null;
+  }
+  function hasActive(session) {
+    if (loadError || !session) return false;
+    for (var i = 0; i < data.items.length; i++) if (sameTarget(data.items[i], session) && (data.items[i].state === "pending" || data.items[i].state === "claimed")) return true;
+    return false;
+  }
+  function admit(session, message, actor) {
+    if (loadError) return result(false, loadError, session, actor);
+    if (!session || !canMutate(session, actor, null)) return result(false, "Not authorized", session, actor);
+    var validationError = validateMessage(message);
+    if (validationError) return result(false, validationError, session, actor);
+    var activeCount = 0;
+    for (var activeIndex = 0; activeIndex < data.items.length; activeIndex++) {
+      if (sameTarget(data.items[activeIndex], session) && (data.items[activeIndex].state === "pending" || data.items[activeIndex].state === "claimed")) activeCount++;
+    }
+    if (activeCount >= MAX_ACTIVE_ITEMS) return result(false, "Pending message queue is full", session, actor);
+    var clientId = message.clientMessageId ? String(message.clientMessageId) : null;
+    var duplicate = inspect(session, actor, clientId);
+    if (duplicate) return result(duplicate.state !== "cancelled" && duplicate.state !== "failed", duplicate.state === "cancelled" ? "Message was cancelled" : duplicate.state === "failed" ? "Message delivery failed" : null, session, actor);
+    var before = copy(data);
+    var storedMessage = copy(message);
+    if (Object.prototype.hasOwnProperty.call(storedMessage, "images")) storedMessage.images = sanitizeImages(storedMessage.images);
+    var item = { id: "pm_" + data.nextId++, sessionKey: key(session), sessionLocalId: session.localId, projectSlug: opts.slug, actorId: actorId(actor), actorName: actor && (actor.displayName || actor.username || actor.name) ? String(actor.displayName || actor.username || actor.name).slice(0, 120) : null, clientMessageId: clientId, message: storedMessage, createdAt: Date.now(), state: "pending" };
+    delete item.message._pendingConsumed;
+    data.items.push(item);
+    data.revision++;
+    try { persist(); } catch (e) { restore(before); return result(false, "Queue storage failed", session, actor); }
+    broadcast(session, { type: "pending_message_queued", sessionId: session.localId, projectSlug: opts.slug, paused: isPaused(session), item: copy(item), revision: data.revision });
+    return result(true, null, session, actor);
+  }
+  function mutate(session, actor, id, expectedRevision, expectedSessionId, operation, allowedStates) {
+    if (loadError) return result(false, loadError, session, actor);
+    if (!session || session.localId !== expectedSessionId || !authorize(session, actor)) return result(false, "Session changed", session, actor);
+    if (expectedRevision !== data.revision) return result(false, "Stale queue revision", session, actor);
+    var index = -1;
+    for (var i = 0; i < data.items.length; i++) if (data.items[i].id === id && sameTarget(data.items[i], session)) index = i;
+    var mutableStates = allowedStates || ["pending"];
+    if (index < 0 || mutableStates.indexOf(data.items[index].state) < 0 || !canMutate(session, actor, data.items[index])) return result(false, "Pending message not found", session, actor);
+    var before = copy(data);
+    operation(data.items, index);
+    data.revision++;
+    try { persist(); } catch (e) { restore(before); return result(false, "Queue storage failed", session, actor); }
+    if (data.items[index].state === "cancelled" && session._pendingMessageClaimId === data.items[index].id) delete session._pendingMessageClaimId;
+    broadcast(session, { type: "pending_message_state", sessionId: session.localId, projectSlug: opts.slug, paused: isPaused(session), revision: data.revision, items: visible(session, actor) });
+    return result(true, null, session, actor);
+  }
+  function edit(session, actor, id, revision, expectedSessionId, message) {
+    var current = null;
+    for (var i = 0; i < data.items.length; i++) if (data.items[i].id === id && sameTarget(data.items[i], session)) current = data.items[i];
+    var text = message && message.text;
+    if (typeof text !== "string" || text.length > MAX_TEXT) return result(false, "Edited text is invalid or too long", session, actor);
+    var proposed = current ? Object.assign({}, current.message, { text: text }) : null;
+    if (message && Object.prototype.hasOwnProperty.call(message, "images")) {
+      proposed = Object.assign({}, proposed, { images: message.images });
+    }
+    if (current) {
+      var validationError = validateMessage(proposed);
+      if (validationError) return result(false, validationError, session, actor);
+    }
+    return mutate(session, actor, id, revision, expectedSessionId, function (items, index) {
+      var nextMessage = Object.assign({}, items[index].message, { text: text });
+      if (message && Object.prototype.hasOwnProperty.call(message, "images")) nextMessage.images = sanitizeImages(message.images);
+      items[index].message = nextMessage;
+    });
+  }
+  function cancel(session, actor, id, revision, expectedSessionId) {
+    return mutate(session, actor, id, revision, expectedSessionId, function (items, index) { items[index].state = "cancelled"; }, ["pending", "claimed"]);
+  }
+  function reorder(session, actor, ids, revision, expectedSessionId) {
+    if (loadError) return result(false, loadError, session, actor);
+    var positions = [];
+    var pending = [];
+    for (var i = 0; i < data.items.length; i++) if (scoped(data.items[i], session, actor) && data.items[i].state === "pending") { positions.push(i); pending.push(data.items[i].id); }
+    if (!Array.isArray(ids) || ids.length !== pending.length) return result(false, "Reorder must include every owned pending message", session, actor);
+    var seen = {};
+    for (var j = 0; j < ids.length; j++) {
+      if (seen[ids[j]] || pending.indexOf(ids[j]) < 0) return result(false, "Reorder contains a duplicate, foreign, or nonpending message", session, actor);
+      seen[ids[j]] = true;
+    }
+    if (!ids.length) return result(true, null, session, actor);
+    return mutate(session, actor, ids[0], revision, expectedSessionId, function (items) {
+      var byId = {};
+      for (var k = 0; k < positions.length; k++) byId[items[positions[k]].id] = items[positions[k]];
+      for (var n = 0; n < positions.length; n++) items[positions[n]] = byId[ids[n]];
+    });
+  }
+  function pause(session, actor) {
+    if (loadError || !session || !authorize(session, actor)) return false;
+    if (!hasActive(session)) return true;
+    if (isPaused(session)) return true;
+    var before = copy(data);
+    data.paused[targetKey(session)] = true;
+    data.revision++;
+    try { persist(); } catch (e) { restore(before); return false; }
+    broadcast(session, { type: "pending_message_state", sessionId: session.localId, projectSlug: opts.slug, paused: true, revision: data.revision, items: visible(session, actor) });
+    return true;
+  }
+  function resume(session, actor, expectedRevision, expectedSessionId) {
+    if (loadError) return result(false, loadError, session, actor);
+    if (!session || session.localId !== expectedSessionId || !authorize(session, actor)) return result(false, "Session changed", session, actor);
+    if (expectedRevision !== data.revision) return result(false, "Stale queue revision", session, actor);
+    if (!isPaused(session)) return result(true, null, session, actor);
+    var before = copy(data);
+    delete data.paused[targetKey(session)];
+    data.revision++;
+    try { persist(); } catch (e) { restore(before); return result(false, "Queue storage failed", session, actor); }
+    broadcast(session, { type: "pending_message_state", sessionId: session.localId, projectSlug: opts.slug, paused: false, revision: data.revision, items: visible(session, actor) });
+    return result(true, null, session, actor);
+  }
+  function finishClaim(session, id, ok, error) {
+    var index = -1;
+    for (var i = 0; i < data.items.length; i++) if (data.items[i].id === id && sameTarget(data.items[i], session) && data.items[i].state === "claimed") index = i;
+    if (index < 0) return false;
+    var before = copy(data);
+    data.items[index].state = ok === "release" ? "pending" : ok ? "consumed" : "failed";
+    if (ok === "release") delete data.items[index].claimedAt;
+    else data.items[index][ok ? "consumedAt" : "failedAt"] = Date.now();
+    if (!ok) data.items[index].failure = error || "Pending message dispatch was rejected";
+    data.revision++;
+    try { persist(); } catch (e) { restore(before); return false; }
+    if (session._pendingMessageClaimId === id) delete session._pendingMessageClaimId;
+    broadcast(session, { type: ok === "release" ? "pending_message_state" : "pending_message_consumed", sessionId: session.localId, projectSlug: opts.slug, paused: isPaused(session), id: id, state: data.items[index].state, items: ok === "release" ? visible(session, { id: data.items[index].actorId }) : undefined, revision: data.revision });
+    return true;
+  }
+  function consumeOne(session, dispatch) {
+    if (loadError || !session || session._pendingMessageClaimId || isPaused(session) || session._pendingMessageDrainPaused || session.taskStopRequested || session._queryStarting || session._awaitingTurnResult || session.isProcessing) return null;
+    if (session.rateLimitResetsAt && session.rateLimitResetsAt > Date.now()) return null;
+    for (var i = 0; i < data.items.length; i++) {
+      var item = data.items[i];
+      if (!sameTarget(item, session) || item.state !== "pending") continue;
+      if (!canMutate(session, { id: item.actorId }, item)) continue;
+      var before = copy(data);
+      item.state = "claimed";
+      item.claimedAt = Date.now();
+      data.revision++;
+      try { persist(); } catch (e) { restore(before); return null; }
+      session._pendingMessageClaimId = item.id;
+      broadcast(session, { type: "pending_message_claimed", sessionId: session.localId, projectSlug: opts.slug, paused: isPaused(session), id: item.id, revision: data.revision });
+      var completed = false;
+      function complete(ok, error) { if (completed) return false; completed = true; return finishClaim(session, item.id, ok, error); }
+      try { if (dispatch(copy(item), complete) === false) complete(false, "Pending message dispatch was rejected"); }
+      catch (e) { complete(false, e.message || String(e)); }
+      return copy(item);
+    }
+    return null;
+  }
+  function hydrate(session, actor) { return result(!loadError, loadError, session, actor); }
+  function isClaimed(session, id) {
+    for (var i = 0; i < data.items.length; i++) if (data.items[i].id === id && sameTarget(data.items[i], session) && data.items[i].state === "claimed") return true;
+    return false;
+  }
+  return { admit: admit, edit: edit, cancel: cancel, reorder: reorder, pause: pause, resume: resume, consumeOne: consumeOne, hydrate: hydrate, inspect: inspect, hasActive: hasActive, isClaimed: isClaimed, isPaused: isPaused, list: visible, getRevision: function () { return data.revision; }, getLoadError: function () { return loadError; }, filePath: filePath };
+}
+
+module.exports = { createPendingMessageQueue: createPendingMessageQueue };

package/lib/project-scheduled-tasks.js

@@ -266,12 +266,10 @@ function attachScheduledTasks(ctx) {
   }
 
   async function engineState(ws, msg, session) {
-    var userId = ws && ws._clayUser ? ws._clayUser.id : "default";
-    var preference = ctx.usersModule && ctx.usersModule.getScheduledTaskInterviewEngine ? ctx.usersModule.getScheduledTaskInterviewEngine(userId) : {};
     var installed = (sm.installedVendors || []).filter(function (vendor) { return sessionToolTransport.capability(vendor).kind !== "none"; });
     var runtimeInstalled = sm.installedVendors || [];
     var requestedVendor = clean(msg && msg.vendor, 40);
-    var targetVendor = runtimeInstalled.indexOf(requestedVendor) !== -1 ? requestedVendor : (installed.indexOf(preference.vendor) !== -1 ? preference.vendor : installed[0] || "");
+    var targetVendor = runtimeInstalled.indexOf(requestedVendor) !== -1 ? requestedVendor : installed[0] || runtimeInstalled[0] || "";
     var catalogError = "";
     if (targetVendor && ctx.getEngineCatalog) {
       try {
@@ -285,7 +283,7 @@ function attachScheduledTasks(ctx) {
       models[runtimeInstalled[i]] = (sm.modelsByVendor && sm.modelsByVendor[runtimeInstalled[i]] || []).slice();
       ready[runtimeInstalled[i]] = models[runtimeInstalled[i]].length > 0;
     }
-    ctx.sendTo(ws, { type: "scheduled_task_interview_engine_state", requestId: msg.requestId || null, projectSlug: ctx.projectSlug || null, sessionId: session.localId, installedVendors: installed, runtimeInstalledVendors: runtimeInstalled.slice(), modelsByVendor: models, catalogReadyByVendor: ready, catalogVendor: targetVendor, error: catalogError, preference: preference || {} });
+    ctx.sendTo(ws, { type: "scheduled_task_interview_engine_state", requestId: msg.requestId || null, projectSlug: ctx.projectSlug || null, sessionId: session.localId, installedVendors: installed, runtimeInstalledVendors: runtimeInstalled.slice(), modelsByVendor: models, catalogReadyByVendor: ready, catalogVendor: targetVendor, error: catalogError });
   }
 
   function createTaskFiles(id, task) {

package/lib/project-sessions.js

@@ -108,8 +108,11 @@ function attachSessions(ctx) {
   var getLinuxUserForSession = ctx.getLinuxUserForSession;
   var ensureProjectAccessForSession = ctx.ensureProjectAccessForSession;
   var getOsUserInfoForWs = ctx.getOsUserInfoForWs;
-  function stopSession(session) {
-    if (!session || (!session.isProcessing && !session._queryStarting)) return false;
+  function stopSession(session, actor) {
+    if (!session) return false;
+    session._pendingMessageDrainPaused = true;
+    if (typeof ctx.onPendingQueuePause === "function") ctx.onPendingQueuePause(session, actor || null);
+    if (!session.isProcessing && !session._queryStarting) return true;
     if (typeof ctx.onHumanPairStop === "function") ctx.onHumanPairStop(session);
     session.taskStopRequested = true;
     if (session.abortController) session.abortController.abort();
@@ -506,6 +509,64 @@ function attachSessions(ctx) {
     }
   }
 
+  function scheduledRequestError(ws, msg, text) {
+    if (!msg.requestId) return;
+    sendTo(ws, { type: "new_session_result", requestId: String(msg.requestId).substring(0, 200), ok: false, error: text });
+  }
+
+  function scheduledSourceIsCurrent(ws, msg, sourceSession) {
+    if (!sourceSession || getSessionForWs(ws) !== sourceSession) return false;
+    if (typeof msg.sourceSessionId !== "number" || msg.sourceSessionId !== sourceSession.localId) return false;
+    if (msg.projectSlug !== slug || msg.mode !== "gui" || msg.forceNew !== true) return false;
+    return !!ctx.canCreateScheduledTaskInterview && ctx.canCreateScheduledTaskInterview(ws, sourceSession) === true;
+  }
+
+  async function prepareScheduledInterview(ws, msg) {
+    var sourceSession = getSessionForWs(ws);
+    var actorId = usersModule.isMultiUser() ? (ws._clayUser && ws._clayUser.id) : "default";
+    if (!actorId || !scheduledSourceIsCurrent(ws, msg, sourceSession)) throw new Error("Scheduled Tasks is unavailable in the current project session.");
+    if (typeof ctx.resolveDefaultAi !== "function") throw new Error("Default AI is unavailable for assisted scheduling.");
+    var resolved = await ctx.resolveDefaultAi(ws);
+    if (usersModule.isMultiUser()) {
+      var liveId = ws._clayUser && ws._clayUser.id;
+      if (liveId !== actorId || !usersModule.findUserById(actorId)) throw new Error("Your account is no longer available.");
+    }
+    if (!scheduledSourceIsCurrent(ws, msg, sourceSession)) throw new Error("Scheduled Tasks is no longer available in the current project session.");
+    if (!resolved || !resolved.ready) throw new Error(resolved && resolved.error || "Default AI is unavailable for assisted scheduling.");
+    var installed = sm.installedVendors || [];
+    var vendorInfo = yoke.getVendorInfo(resolved.vendor);
+    if (installed.indexOf(resolved.vendor) === -1 || !vendorInfo || yoke.sessionTools.capability(resolved.vendor).kind === "none") {
+      throw new Error("The Default AI provider cannot run the Scheduled Tasks interview tools in this project.");
+    }
+    var models = resolved.catalog && resolved.catalog.models || [];
+    if (!catalogHasModel(models, resolved.model)) throw new Error("The Default AI model is no longer available.");
+    if (!catalogSupportsEffort(models, resolved.model, resolved.effort || "", vendorInfo.effortLevels)) throw new Error("The Default AI effort is unavailable for this model.");
+    return { sourceSession: sourceSession, actorId: actorId, runtime: resolved };
+  }
+
+  function createScheduledInterview(ws, msg, prepared) {
+    if (!scheduledSourceIsCurrent(ws, msg, prepared.sourceSession)) throw new Error("Scheduled Tasks is no longer available in the current project session.");
+    if (usersModule.isMultiUser()) {
+      var liveId = ws._clayUser && ws._clayUser.id;
+      if (liveId !== prepared.actorId || !usersModule.findUserById(prepared.actorId)) throw new Error("Your account is no longer available.");
+    }
+    sm.sweepBlankSessions();
+    var sessionOpts = {
+      sessionVisibility: sessionVisibility.normalize(msg.sessionVisibility),
+      vendor: prepared.runtime.vendor,
+      model: prepared.runtime.model,
+      effort: prepared.runtime.effort || null,
+      mode: "gui",
+    };
+    if (usersModule.isMultiUser()) sessionOpts.ownerId = prepared.actorId;
+    var newSession = sm.createSession(sessionOpts, ws);
+    ws._clayActiveSession = newSession.localId;
+    if (msg.requestId) sendTo(ws, { type: "new_session_result", requestId: String(msg.requestId).substring(0, 200), ok: true, sessionId: newSession.localId });
+    var presenceKey = ws._clayUser ? ws._clayUser.id : "_default";
+    if (!ws._clayPane) userPresence.setPresence(slug, presenceKey, userPresence.sessionIdForPersistence(newSession), null);
+    if (usersModule.isMultiUser() && !ws._clayPane) broadcastPresence();
+  }
+
   function handleSessionsMessage(ws, msg) {
 
     if (msg.type === "push_subscribe") {
@@ -532,32 +593,22 @@ function attachSessions(ctx) {
 
     if (msg.type === "new_session") {
       if (msg.scheduleInterview === true) {
-        var sourceSession = getSessionForWs(ws);
-        var interviewVendor = typeof msg.vendor === "string" ? msg.vendor : "";
-        var installed = sm.installedVendors || [];
-        var knownModels = sm.modelsByVendor && sm.modelsByVendor[interviewVendor] || [];
-        var requestedModel = typeof msg.model === "string" ? msg.model : "";
-        var requestedEffort = typeof msg.effort === "string" ? msg.effort : "";
-        var vendorInfo = yoke.getVendorInfo(interviewVendor);
-        var engineError = "";
-        var sourceMatches = !!sourceSession && Number(msg.sourceSessionId) === Number(sourceSession.localId);
-        if (!sourceMatches || msg.projectSlug !== slug || !ctx.canCreateScheduledTaskInterview || !ctx.canCreateScheduledTaskInterview(ws, sourceSession)) engineError = "Scheduled Tasks is unavailable in the current project session.";
-        else if (!interviewVendor || installed.indexOf(interviewVendor) === -1 || !vendorInfo || yoke.sessionTools.capability(interviewVendor).kind === "none") engineError = "The selected interview engine is no longer available for assisted scheduling.";
-        else if (!knownModels.length) engineError = "Interview models are still loading or unavailable for this engine.";
-        else if (requestedModel && !catalogHasModel(knownModels, requestedModel)) engineError = "The selected interview model is no longer available.";
-        else if (!catalogSupportsEffort(knownModels, requestedModel, requestedEffort, vendorInfo.effortLevels)) engineError = "The selected interview effort is unavailable for this engine.";
-        if (engineError) {
-          if (msg.requestId) sendTo(ws, { type: "new_session_result", requestId: String(msg.requestId).substring(0, 200), ok: false, error: engineError });
-          return true;
-        }
-        var preferenceUserId = ws._clayUser ? ws._clayUser.id : "default";
-        var savedPreference;
-        try { savedPreference = usersModule.setScheduledTaskInterviewEngine(preferenceUserId, { vendor: interviewVendor, model: requestedModel, effort: requestedEffort }); }
-        catch (preferenceError) { savedPreference = { error: preferenceError.message || String(preferenceError) }; }
-        if (!savedPreference || !savedPreference.ok) {
-          if (msg.requestId) sendTo(ws, { type: "new_session_result", requestId: String(msg.requestId).substring(0, 200), ok: false, error: savedPreference && savedPreference.error || "The interview engine preference could not be saved." });
+        var scheduledRequestId = typeof msg.requestId === "string" ? msg.requestId.substring(0, 200) : "";
+        if (!scheduledRequestId) {
+          scheduledRequestError(ws, msg, "A request identity is required for a Scheduled Tasks interview.");
           return true;
         }
+        if (!ws._scheduledInterviewSessionRequests) ws._scheduledInterviewSessionRequests = {};
+        if (ws._scheduledInterviewSessionRequests[scheduledRequestId]) return true;
+        var pendingScheduled = prepareScheduledInterview(ws, msg).then(function (prepared) {
+          createScheduledInterview(ws, msg, prepared);
+        }).catch(function (error) {
+          scheduledRequestError(ws, msg, error.message || String(error));
+        }).finally(function () {
+          if (ws._scheduledInterviewSessionRequests[scheduledRequestId] === pendingScheduled) delete ws._scheduledInterviewSessionRequests[scheduledRequestId];
+        });
+        ws._scheduledInterviewSessionRequests[scheduledRequestId] = pendingScheduled;
+        return true;
       }
       // Opportunistic hygiene: drop blanks that sat untouched past the grace
       // period before deciding whether to reuse or create.
@@ -566,7 +617,6 @@ function attachSessions(ctx) {
       if (ws._clayUser && usersModule.isMultiUser()) sessionOpts.ownerId = ws._clayUser.id;
       sessionOpts.sessionVisibility = sessionVisibility.normalize(msg.sessionVisibility);
       if (msg.vendor) sessionOpts.vendor = msg.vendor;
-      if (msg.scheduleInterview === true && msg.model) sessionOpts.model = msg.model;
       // Mode resolution: vendors without a TUI session mode are always GUI.
       // TUI-capable sessions honor the explicit msg.mode if provided, otherwise
       // fall back to the user's claudeOpenMode preference. This is what
@@ -636,9 +686,7 @@ function attachSessions(ctx) {
         sm.switchSession(newSess.localId, ws);
       } else {
         var newSessionVendor = sessionOpts.vendor || sm.defaultVendor || "claude";
-        sessionOpts.effort = msg.scheduleInterview === true && msg.effort
-          ? msg.effort
-          : yoke.clampEffort(newSessionVendor, (sm.currentEffortByVendor && sm.currentEffortByVendor[newSessionVendor]) || sm.currentEffort || "medium") || null;
+        sessionOpts.effort = yoke.clampEffort(newSessionVendor, (sm.currentEffortByVendor && sm.currentEffortByVendor[newSessionVendor]) || sm.currentEffort || "medium") || null;
         // Reuse an existing blank GUI session instead of stacking another
         // one. A vendor-less blank is acceptable: nothing has happened in it,
         // so stamping the requested vendor is equivalent to a fresh create.
@@ -1073,7 +1121,7 @@ function attachSessions(ctx) {
     if (msg.type === "stop") {
       var session = getSessionForWs(ws);
       if (autonomousRun && session && session.autonomousRun) autonomousRun.finish(session, "stopped", "Stopped by the user.");
-      stopSession(session);
+      stopSession(session, ws && ws._clayUser);
       return true;
     }
 
@@ -1484,6 +1532,9 @@ function attachSessions(ctx) {
     if (msg.type === "cursor_move" || msg.type === "cursor_leave" || msg.type === "text_select") {
       if (!usersModule.isMultiUser() || !ws._clayUser) return true;
       var u = ws._clayUser;
+      if (typeof usersModule.getCursorSharing === "function" && !usersModule.getCursorSharing(u.id)) {
+        if (msg.type !== "cursor_leave" && !(msg.type === "text_select" && Array.isArray(msg.ranges) && msg.ranges.length === 0)) return true;
+      }
       var p = u.profile || {};
       var cursorMsg = {
         type: msg.type,

package/lib/project-tool-llm-runtime.js

@@ -0,0 +1,48 @@
+// Keeps Capsule LLM selection and execution bound to one live project actor.
+
+function attachProjectToolLlmRuntime(ctx) {
+  function currentPrincipal(ws) {
+    if (!ctx.users.isMultiUser() && !ctx.osUsers) return { userId: "default", linuxUser: null };
+    var claimedId = ws && ws._clayUser && ws._clayUser.id;
+    var user = claimedId ? ctx.users.findUserById(claimedId) : null;
+    if (!user) throw new Error("Authenticated user identity is required for this AI request.");
+    var access = ctx.getProjectAccess();
+    if (!ctx.users.canAccessProject(user.id, access)) throw new Error("Project access is no longer available for this AI request.");
+    var linuxUser = ctx.osUsers ? user.linuxUser || null : null;
+    if (ctx.osUsers && !linuxUser) throw new Error("An OS user identity is required for this AI request.");
+    return { userId: user.id, linuxUser: linuxUser };
+  }
+
+  function revalidatePrincipal(ws, expected) {
+    var current = currentPrincipal(ws);
+    if (current.userId !== expected.userId || current.linuxUser !== expected.linuxUser) {
+      throw new Error("The authenticated runtime identity changed while the AI request was loading.");
+    }
+    return current;
+  }
+
+  async function getConfiguration(ws, alias) {
+    var principal = currentPrincipal(ws);
+    var selection = await ctx.resolveModel(ws, alias);
+    revalidatePrincipal(ws, principal);
+    return selection;
+  }
+
+  async function complete(ws, args) {
+    var principal = currentPrincipal(ws);
+    var selection = await ctx.resolveModel(ws, args.model);
+    var live = revalidatePrincipal(ws, principal);
+    return ctx.complete({
+      adapters: ctx.adapters,
+      cwd: ctx.cwd,
+      linuxUser: live.linuxUser,
+      args: args,
+      selection: selection,
+      timeoutMs: 60000,
+    });
+  }
+
+  return { getConfiguration: getConfiguration, complete: complete };
+}
+
+module.exports = { attachProjectToolLlmRuntime: attachProjectToolLlmRuntime };