clay-server 5.3.0-beta.4 → 5.3.0-beta.6

package/lib/public/style.css

@@ -79,6 +79,7 @@
 @import url("css/skills-workbench.css");
 
 @import url("css/right-workbench.css?v=20261020-workbench-overlay");
+@import url("css/tool-pane.css");
 
 @import url("css/mate-conversation.css");
 

package/lib/server-workbench-layout-settings.js

@@ -32,7 +32,7 @@ function attachWorkbenchLayoutSettings(ctx) {
     req.on('data', function (chunk) {
       if (finished) return;
       body += chunk;
-      if (Buffer.byteLength(body) > 1024) { finished = true; body = ''; reply(res, 413, { error: 'Request too large.' }); }
+      if (Buffer.byteLength(body) > 65536) { finished = true; body = ''; reply(res, 413, { error: 'Request too large.' }); }
     });
     req.on('aborted', function () { finished = true; });
     req.on('error', function () { finished = true; });
@@ -41,11 +41,11 @@ function attachWorkbenchLayoutSettings(ctx) {
       if (identity(req) !== accountId) { reply(res, 401, { error: 'Account changed. Sign in again.' }); return; }
       var input;
       try { input = JSON.parse(body); } catch (error) { reply(res, 400, { error: 'Invalid JSON.' }); return; }
-      if (!input || Array.isArray(input) || Object.keys(input).length !== 2 || !Object.prototype.hasOwnProperty.call(input, 'mode') || !Object.prototype.hasOwnProperty.call(input, 'revision')) {
+      if (!input || Array.isArray(input) || Object.keys(input).some(function (key) { return ['mode', 'revision', 'layout'].indexOf(key) < 0; }) || !Object.prototype.hasOwnProperty.call(input, 'mode') || !Object.prototype.hasOwnProperty.call(input, 'revision')) {
         reply(res, 400, { error: 'Invalid workbench preference.' }); return;
       }
       try {
-        var result = ctx.users.setWorkbenchLayoutPreference(accountId, input.mode, input.revision);
+        var result = ctx.users.setWorkbenchLayoutPreference(accountId, input.mode, input.revision, input.layout);
         reply(res, result.error ? result.status || 400 : 200, result);
       } catch (error) { reply(res, 500, { error: 'Workbench layout could not be saved. Your previous layout is retained.' }); }
     });

package/lib/server.js

@@ -317,6 +317,7 @@ function createServer(opts) {
 
   // --- Project registry ---
   var assignmentService = attachWorkspaceAssignmentService({
+    resolveMate: function (owner, id) { return mates.getMate(mates.buildMateCtx(users.isMultiUser() ? owner : null), id); },
     getPresentation: function (principal) {
       var project = projects.get(principal.sourceProjectSlug), manager = project && project.getSessionManager(), status = project && project.getStatus();
       var session = manager && manager.sessions.get(principal.sourceSessionId);

package/lib/split-view-layout.js

@@ -12,7 +12,7 @@ function validateTree(tree, expectedOrigins) {
   var invalid = null;
   function walk(node, depth) {
     if (invalid) return;
-    if (!node || typeof node !== "object" || depth > MAX_SESSIONS) { invalid = "Layout tree is malformed"; return; }
+    if (!node || typeof node !== "object" || Array.isArray(node) || depth > MAX_SESSIONS) { invalid = "Layout tree is malformed"; return; }
     if (Object.prototype.hasOwnProperty.call(node, "id")) {
       if (Object.keys(node).length !== 1 || !validOrigin(node.id) || origins.indexOf(node.id) !== -1) {
         invalid = "Layout leaves must have unique valid session origins"; return;
@@ -28,11 +28,11 @@ function validateTree(tree, expectedOrigins) {
     }
     walk(node.left, depth + 1); walk(node.right, depth + 1);
   }
-  walk(tree, 0);
+  if (tree !== null) walk(tree, 0);
   if (invalid) return { ok: false, error: invalid, origins: origins };
-  if (origins.length < 2 || origins.length > MAX_SESSIONS) return { ok: false, error: "A Split view requires two to eight sessions", origins: origins };
+  if (origins.length > MAX_SESSIONS) return { ok: false, error: "A View supports zero to eight sessions", origins: origins };
   if (expectedOrigins) {
-    if (!Array.isArray(expectedOrigins) || expectedOrigins.length !== origins.length ||
+    if (!Array.isArray(expectedOrigins) || expectedOrigins.length !== origins.length || new Set(expectedOrigins).size !== expectedOrigins.length ||
         expectedOrigins.some(function (id) { return !validOrigin(id) || origins.indexOf(id) === -1; })) {
       return { ok: false, error: "Layout leaves must exactly match the selected sessions", origins: origins };
     }
@@ -100,9 +100,9 @@ function validateViewShape(view) {
   var name = validateName(view.name);
   if (!name.ok) return name;
   if (view.nameMode != null && ["automatic", "custom"].indexOf(view.nameMode) === -1) return { ok: false, error: "Split view name mode is invalid" };
-  if (!Number.isInteger(view.revision) || view.revision < 1 || !validatePreset(view.layout)) return { ok: false, error: "Split view revision or layout is invalid" };
+  if (!Number.isSafeInteger(view.revision) || view.revision < 1 || !validatePreset(view.layout)) return { ok: false, error: "Split view revision or layout is invalid" };
   var refs = view.sessionRefs;
-  if (!Array.isArray(refs) || refs.length < 2 || refs.length > MAX_SESSIONS) return { ok: false, error: "A Split view requires two to eight sessions" };
+  if (!Array.isArray(refs) || refs.length > MAX_SESSIONS) return { ok: false, error: "A View supports zero to eight sessions" };
   var ids = [];
   for (var i = 0; i < refs.length; i++) {
     var ref = refs[i];
@@ -113,7 +113,11 @@ function validateViewShape(view) {
   }
   var tree = validateTree(view.tree, ids);
   if (!tree.ok) return tree;
-  if (typeof view.activeSessionOriginId !== "string" || ids.indexOf(view.activeSessionOriginId) === -1) return { ok: false, error: "Active session must belong to the Split view" };
+  if (ids.length ? typeof view.activeSessionOriginId !== "string" || ids.indexOf(view.activeSessionOriginId) === -1 : view.activeSessionOriginId !== null) return { ok: false, error: "Active session must belong to the Split view" };
+  if (view.workspace !== undefined) {
+    var checked = require("./project-view-workspace").validate(view.workspace, view);
+    if (!checked.ok) return checked;
+  }
   return { ok: true, name: name.name, origins: ids };
 }
 

package/lib/users-workbench-layout-preferences.js

@@ -1,3 +1,4 @@
+var windowLayouts = require('./workbench-window-layout');
 // Account UI preferences are excluded from canonical Clay controls.
 function validMode(mode) { return mode === 'overlay' || mode === 'docked'; }
 function attachWorkbenchLayoutPreferences(deps) {
@@ -12,16 +13,25 @@ function attachWorkbenchLayoutPreferences(deps) {
   function value(accountId, saved) {
     if (saved === undefined) return { accountId: accountId, mode: 'overlay', revision: 0 };
     if (!saved || !validMode(saved.mode) || !Number.isSafeInteger(saved.revision) || saved.revision < 1) throw new Error('Invalid stored preference.');
-    return { accountId: accountId, mode: saved.mode, revision: saved.revision };
+    if (saved.layouts && !windowLayouts.validLayouts(saved.layouts)) throw new Error('Invalid stored window layout.');
+    return Object.assign({ accountId: accountId, mode: saved.mode, revision: saved.revision }, saved.layouts ? { layouts: saved.layouts } : {});
   }
   function get(accountId) { return value(accountId, context(accountId).saved); }
-  function set(accountId, mode, revision) {
+  function set(accountId, mode, revision, layout) {
+    if (layout !== undefined && !windowLayouts.validLayout(layout)) return { status: 400, error: 'Invalid window layout.' };
     if (!validMode(mode) || !Number.isSafeInteger(revision) || revision < 0) return { status: 400, error: 'Invalid workbench layout.' };
     var current = context(accountId), prior = value(accountId, current.saved);
     if (prior.revision !== revision) return { status: 409, error: 'Workbench layout changed elsewhere. Reload the preference and try again.' };
-    if (prior.mode === mode) return prior;
+    var layouts = Object.assign({}, prior.layouts || {});
+    var changed = layout && JSON.stringify(layouts[layout.key]) !== JSON.stringify({ base: layout.base, tree: layout.tree });
+    if (prior.mode === mode && !changed) return prior;
+    if (layout) {
+      delete layouts[layout.key];
+      if (Object.keys(layouts).length >= 32) delete layouts[Object.keys(layouts)[0]];
+      layouts[layout.key] = { base: layout.base, tree: layout.tree };
+    }
     if (revision === Number.MAX_SAFE_INTEGER) throw new Error('Preference revision exhausted.');
-    var saved = { mode: mode, revision: revision + 1 };
+    var saved = Object.assign({ mode: mode, revision: revision + 1 }, Object.keys(layouts).length ? { layouts: layouts } : {});
     if (current.settings) config.saveConfig(Object.assign({}, current.settings, { workbenchLayoutPreference: saved }));
     else deps.saveUsers(Object.assign({}, current.data, { users: current.data.users.map(function (entry) {
       return entry === current.user ? Object.assign({}, entry, { workbenchLayoutPreference: saved }) : entry;

package/lib/workbench-window-layout.js

@@ -0,0 +1,30 @@
+// Display preferences only: these records never open sessions or run tools.
+var tools = ['tool-terminal', 'tool-browser', 'tool-file-viewer'];
+function validTree(tree, allowTools) {
+  var ids = [], nodes = 0;
+  function walk(node, depth) {
+    if (!node || typeof node !== 'object' || Array.isArray(node) || ++nodes > 21 || depth > 10) return false;
+    if (Object.prototype.hasOwnProperty.call(node, 'id')) {
+      if (Object.keys(node).length !== 1 || typeof node.id !== 'string' || !/^[A-Za-z0-9_-]{1,128}$/.test(node.id)) return false;
+      if (node.id.indexOf('tool-') === 0 && (!allowTools || tools.indexOf(node.id) < 0)) return false;
+      ids.push(node.id); return true;
+    }
+    return Object.keys(node).sort().join(',') === 'axis,left,ratio,right' && ['horizontal', 'vertical'].indexOf(node.axis) >= 0 &&
+      Number.isFinite(node.ratio) && node.ratio >= .05 && node.ratio <= .95 && walk(node.left, depth + 1) && walk(node.right, depth + 1);
+  }
+  return walk(tree, 0) && ids.length > 0 && ids.length <= (allowTools ? 11 : 8) && new Set(ids).size === ids.length;
+}
+function validLayout(input) {
+  return !!input && typeof input === 'object' && !Array.isArray(input) && Object.keys(input).sort().join(',') === 'base,key,tree' &&
+    typeof input.key === 'string' && input.key.length > 0 && input.key.length <= 512 && input.key !== '__proto__' &&
+    validTree(input.base, false) && validTree(input.tree, true) && sameSessions(input.base, input.tree);
+}
+function sameSessions(base, tree) {
+  function ids(node) { return node.id ? (tools.indexOf(node.id) >= 0 ? [] : [node.id]) : ids(node.left).concat(ids(node.right)); }
+  return JSON.stringify(ids(base).sort()) === JSON.stringify(ids(tree).sort());
+}
+function validLayouts(layouts) {
+  return !!layouts && typeof layouts === 'object' && !Array.isArray(layouts) && Object.keys(layouts).length <= 32 &&
+    Object.keys(layouts).every(function (key) { var item = layouts[key]; return item && validLayout({ key: key, base: item.base, tree: item.tree }); });
+}
+module.exports = { validLayout: validLayout, validLayouts: validLayouts };

package/lib/workspace-assignment-service.js

@@ -2,7 +2,7 @@ var fs = require("fs");
 var path = require("path");
 var crypto = require("crypto");
 
-var ACTIVE = { proposed: true, starting: true, running: true };
+var ACTIVE = { proposed: true, queued: true, starting: true, running: true };
 var MAX_RUNNING = 3;
 
 function clean(value, max) {
@@ -21,6 +21,8 @@ function attachWorkspaceAssignmentService(ctx) {
   var pendingRestartReplay = {};
   var presentations = new WeakMap();
   var presentationTargets = new WeakMap();
+  var followUps = require('./workspace-follow-up-queue').createFollowUpQueue({ records: records,
+    exactSource: exactSource, exactTarget: exactTarget, settle: settle, approve: approve });
 
   function recordFile(userId) {
     return storageDir ? path.join(storageDir, userStorageKey(userId)) : null;
@@ -44,12 +46,13 @@ function attachWorkspaceAssignmentService(ctx) {
       if (!files[i].endsWith(".json") || files[i].indexOf(".tmp.") !== -1) continue;
       try {
         var loaded = JSON.parse(fs.readFileSync(path.join(storageDir, files[i]), "utf8"));
-        if (Array.isArray(loaded)) records = records.concat(loaded);
+        if (Array.isArray(loaded)) records.push.apply(records, loaded);
       } catch (e) {}
     }
     var changedUsers = {};
     for (var j = 0; j < records.length; j++) {
-      if (records[j].status !== "starting" && records[j].status !== "running") continue;
+      if (records[j].status !== "queued" && records[j].status !== "starting" && records[j].status !== "running") continue;
+      records[j].deliveryState = records[j].status === "queued" ? "not_sent" : "unknown";
       records[j].status = "interrupted";
       records[j].error = "Clay restarted before this assignment completed.";
       records[j].updatedAt = Date.now();
@@ -90,6 +93,8 @@ function attachWorkspaceAssignmentService(ctx) {
       title: record.title,
       task: record.task,
       status: record.status,
+      deliveryState: record.deliveryState || null,
+      parentAssignmentId: record.parentAssignmentId || null,
       sourceProjectSlug: record.sourceProjectSlug,
       sourceSessionRef: record.sourceSessionRef,
       targetSessionRef: record.targetSessionRef || null,
@@ -119,6 +124,8 @@ function attachWorkspaceAssignmentService(ctx) {
     var status = project.getStatus();
     if (!status || status.isMate !== true || status.mateId !== record.sourceMateId) return null;
     if (ctx.isMultiUser() && status.projectOwnerId !== record.userId) return null;
+    var mate = ctx.resolveMate && ctx.resolveMate(status.projectOwnerId || null, record.sourceMateId);
+    if (ctx.resolveMate && (!mate || mate.id !== record.sourceMateId || ctx.isMultiUser() && mate.createdBy !== record.userId)) return null;
     var manager = project.getSessionManager();
     var session = null;
     if (manager && manager.sessions) {
@@ -129,7 +136,7 @@ function attachWorkspaceAssignmentService(ctx) {
     if (!session) return null;
     if (ctx.isMultiUser() && session.ownerId !== record.userId) return null;
     if (!ctx.isMultiUser() && session.ownerId && session.ownerId !== record.singleUserOwnerId) return null;
-    return { project: project, manager: manager, session: session };
+    return { project: project, manager: manager, session: session, mate: mate || null };
   }
 
   function present(record, principal) {
@@ -149,7 +156,7 @@ function attachWorkspaceAssignmentService(ctx) {
   function emit(record, eventType) {
     var observer = presentations.get(record);
     if (observer) {
-      if (record.status === 'starting') observer.phase('queued');
+      if (record.status === 'starting' || record.status === 'queued') observer.phase('queued');
       else if (record.status === 'running') observer.phase('running');
       else if (record.status !== 'proposed') { observer.finish({ status: record.status === 'interrupted' ? 'failed' : record.status, outcome: record.status === 'interrupted' ? 'uncertain' : undefined }); presentations.delete(record); }
     }
@@ -232,12 +239,16 @@ function attachWorkspaceAssignmentService(ctx) {
     var idempotency = crypto.createHash("sha256").update(key + "\u0000follow_up\u0000" + projectSlug + "\u0000" + targetSessionRef + "\u0000" + title + "\u0000" + task).digest("hex");
     for (var i = 0; i < records.length; i++) {
       if (records[i].idempotencyKey === idempotency) return publicRecord(records[i]);
-      if (records[i].sourceKey === key && ACTIVE[records[i].status]) throw new Error("This conversation already has an active assignment.");
+      if (records[i].sourceKey === key && ACTIVE[records[i].status] &&
+          (records[i].targetProjectSlug !== projectSlug || records[i].targetSessionRef !== targetSessionRef)) throw new Error("An active assignment already exists. Send this update to that exact Driver session.");
     }
     var candidate = { userId: principal.userId || null, singleUserOwnerId: principal.singleUserOwnerId || null, targetProjectSlug: projectSlug };
     var target = exactTarget(candidate);
     if (!target || typeof target.inspectDelegatedFollowUp !== "function") throw new Error("Target project is unavailable for follow-ups.");
-    var inspected = target.inspectDelegatedFollowUp({ userId: principal.userId }, targetSessionRef);
+    if (records.filter(function (item) { return item.sourceKey === key && item.delivery === 'follow_up' && ACTIVE[item.status]; }).length >= 16) throw new Error('There are already 16 pending follow-ups. Wait for or cancel a review.');
+    var candidateInput = { userId: principal.userId || null, sourceKey: key, targetProjectSlug: projectSlug, targetSessionRef: targetSessionRef,
+      sourceMateId: principal.mateId, sourceProjectSlug: principal.sourceProjectSlug, sourceSessionRef: principal.sourceSessionRef };
+    var inspected = followUps.inspect(candidateInput, target);
     var now = Date.now();
     var targetStatus = target.getStatus();
     var record = {
@@ -250,6 +261,7 @@ function attachWorkspaceAssignmentService(ctx) {
       title: title, task: task, delivery: "follow_up", status: "proposed", createdAt: now, updatedAt: now,
     };
     if (!exactSource(record)) throw new Error("Source conversation is no longer available.");
+    followUps.remember(record, target, inspected);
     records.push(record);
     saveUser(record.userId);
     present(record, principal);
@@ -279,7 +291,9 @@ function attachWorkspaceAssignmentService(ctx) {
 
   function settle(record, status, session, error) {
     if (!ACTIVE[record.status]) return publicRecord(record);
+    if (record.delivery === "follow_up" && record.deliveryState !== "accepted") record.deliveryState = record.status === "starting" ? "unknown" : "not_sent";
     record.status = status;
+    followUps.cleanup(record);
     record.resultSummary = status === "completed" ? summarize(session) : "";
     record.error = clean(error || "", 800);
     record.updatedAt = Date.now();
@@ -287,12 +301,19 @@ function attachWorkspaceAssignmentService(ctx) {
     delete unsubscribers[record.assignmentId];
     saveUser(record.userId);
     emit(record);
+    followUps.wake(record);
     return publicRecord(record);
   }
 
   function watch(record, manager, session) {
     var view = presentationTargets.get(record); if (view) { view.session = session; view.origin = session.sessionOriginId; var observer = presentations.get(record); if (observer && observer.target) observer.target({ kind: 'session', projectSlug: record.targetProjectSlug, sessionId: session.localId, sessionOriginId: session.sessionOriginId }); }
+    if (unsubscribers[record.assignmentId]) unsubscribers[record.assignmentId]();
     var unsubscribe = manager.subscribeSession(session.localId, function (event) {
+      if (record.status === 'queued') {
+        if (event.type === 'error') settle(record, 'failed', session, event.text || 'Driver failed before follow-up delivery.');
+        else if (event.type === 'done' || event.type === 'result') followUps.schedule(record);
+        return;
+      }
       if (event.type === "session_id") {
         record.targetSessionRef = ctx.sessionRef(record.targetProjectSlug, session);
         record.updatedAt = Date.now();
@@ -301,6 +322,7 @@ function attachWorkspaceAssignmentService(ctx) {
       } else if (event.type === "error") {
         settle(record, "failed", session, event.text || "Assignment failed.");
       } else if (event.type === "done" || event.type === "result") {
+        if (record.delivery === "follow_up") record.deliveryState = "accepted";
         settle(record, session._lastTurnInterrupted ? "interrupted" : "completed", session, "");
       }
     });
@@ -308,17 +330,32 @@ function attachWorkspaceAssignmentService(ctx) {
   }
 
   async function approve(record) {
-    if (record.status !== "proposed") return publicRecord(record);
+    if (record.status !== "proposed" && record.status !== "queued") return publicRecord(record);
     var running = records.filter(function (item) {
       return item.userId === record.userId && (item.status === "starting" || item.status === "running");
     }).length;
-    if (running >= MAX_RUNNING) throw new Error("Too many assignments are already running.");
     if (!exactSource(record)) throw new Error("Source conversation is no longer available.");
     var target = exactTarget(record);
     var followUp = record.delivery === "follow_up";
     if (!target || (followUp ? typeof target.dispatchDelegatedFollowUp !== "function" : typeof target.createDelegatedSession !== "function")) throw new Error("Target project is no longer available.");
+    if (followUp) {
+      var inspected;
+      try { inspected = followUps.validate(record, target, followUps.inspect(record, target)); }
+      catch (error) { return settle(record, 'failed', null, error.message); }
+      if (followUps.busy(inspected.session) || (followUps.first(record) && followUps.first(record) !== record)) {
+        var beforeQueue = Object.assign({}, record, { decision: record.decision, deliveryState: record.deliveryState, queueOrder: record.queueOrder });
+        if (record.status === 'proposed') record.queueOrder = records.reduce(function (max, item) { return Math.max(max, item.queueOrder || 0); }, 0) + 1;
+        record.decision = 'approve'; record.status = 'queued'; record.deliveryState = 'queued'; record.updatedAt = Date.now();
+        try { saveUser(record.userId); } catch (error) { Object.assign(record, beforeQueue); throw error; }
+        watch(record, target.getSessionManager(), inspected.session); followUps.track(record); emit(record); followUps.schedule(record);
+        return publicRecord(record);
+      }
+    }
+    if (running >= MAX_RUNNING) throw new Error("Too many assignments are already running.");
+    followUps.cleanup(record);
     record.decision = "approve";
     record.status = "starting";
+    if (followUp) record.deliveryState = "dispatching";
     record.updatedAt = Date.now();
     saveUser(record.userId);
     emit(record);
@@ -329,10 +366,11 @@ function attachWorkspaceAssignmentService(ctx) {
         sourceMateId: record.sourceMateId,
         sourceProjectSlug: record.sourceProjectSlug,
         sourceSessionRef: record.sourceSessionRef,
+        parentAssignmentId: record.parentAssignmentId || null,
       };
       var session;
       if (followUp) {
-        session = await target.dispatchDelegatedFollowUp({ userId: record.userId }, record.targetSessionRef, record.task, metadata, function (existing) { watch(record, target.getSessionManager(), existing); });
+        session = await target.dispatchDelegatedFollowUp({ userId: record.userId, sourceMateId: record.sourceMateId, sourceProjectSlug: record.sourceProjectSlug, sourceSessionRef: record.sourceSessionRef }, record.targetSessionRef, record.task, metadata, function (existing) { followUps.validate(record, exactTarget(record), followUps.inspect(record, target)); watch(record, target.getSessionManager(), existing); });
       } else {
         session = await target.createDelegatedSession({ userId: record.userId }, record.task, metadata, function (created) { watch(record, target.getSessionManager(), created); });
       }
@@ -340,6 +378,7 @@ function attachWorkspaceAssignmentService(ctx) {
       record.targetSessionRef = ctx.sessionRef(record.targetProjectSlug, session);
       record.targetSessionId = session.localId;
       record.status = "running";
+      if (followUp) record.deliveryState = "accepted";
       record.updatedAt = Date.now();
       saveUser(record.userId);
       emit(record);
@@ -350,12 +389,17 @@ function attachWorkspaceAssignmentService(ctx) {
   }
 
   function cancel(record) {
-    if (record.status !== "proposed") return publicRecord(record);
+    if (record.status !== "proposed" && record.status !== "queued") return publicRecord(record);
+    followUps.cleanup(record);
+    if (unsubscribers[record.assignmentId]) unsubscribers[record.assignmentId]();
+    delete unsubscribers[record.assignmentId];
+    record.deliveryState = 'not_sent';
     record.decision = "cancel";
     record.status = "cancelled";
     record.updatedAt = Date.now();
     saveUser(record.userId);
     emit(record);
+    followUps.wake(record);
     return publicRecord(record);
   }
 
@@ -396,6 +440,7 @@ function attachWorkspaceAssignmentService(ctx) {
     validateResponseSource(ws, msg, record, routedProjectSlug);
     var action = msg.action === "approve" ? "approve" : (msg.action === "cancel" ? "cancel" : "");
     if (!action) throw new Error("Choose approve or cancel.");
+    if (record.status === "queued" && action === "cancel") return cancel(record);
     if (record.status !== "proposed") {
       if (record.decision === action) return publicRecord(record);
       throw new Error("Assignment proposal has already been resolved.");

package/lib/workspace-follow-up-queue.js

@@ -0,0 +1,92 @@
+// Reviewed assignment updates share the existing follow-up dispatch service.
+function createFollowUpQueue(ctx) {
+  var snapshots = new WeakMap(), scheduled = new WeakSet(), sourceWatches = new WeakMap();
+  function source(record) {
+    var current = ctx.exactSource(record);
+    if (!current || current.session.taskStopRequested || current.session._pendingMessageDrainPaused || current.session._lastTurnInterrupted || current.session.abortController && current.session.abortController.signal.aborted || current.session._mentionInProgress || current.session.spawn) throw new Error('Source conversation stopped or changed. Request a new review.');
+    return current;
+  }
+  function inspect(record, project) {
+    var parent = ctx.records.find(function (item) {
+      return item.sourceKey === record.sourceKey && item.delivery !== 'follow_up' && item.targetProjectSlug === record.targetProjectSlug &&
+        item.targetSessionRef === record.targetSessionRef && (!record.parentAssignmentId || item.assignmentId === record.parentAssignmentId);
+    });
+    return project.inspectDelegatedFollowUp({ userId: record.userId, sourceMateId: record.sourceMateId,
+      sourceProjectSlug: record.sourceProjectSlug, sourceSessionRef: record.sourceSessionRef }, record.targetSessionRef,
+      { allowBusy: true, parentAssignmentId: parent && parent.assignmentId || null });
+  }
+  function remember(record, project, inspected) {
+    var current = source(record);
+    snapshots.set(record, { project: project, session: inspected.session, origin: inspected.session.sessionOriginId,
+      linuxUser: inspected.linuxUser || null, source: current.session, sourceProject: current.project });
+    record.targetSessionOriginId = inspected.session.sessionOriginId || null;
+    record.targetLinuxUser = inspected.linuxUser || null;
+    record.targetDirectory = project.getStatus().path || null;
+    record.sourceDirectory = current.project.getStatus().path || null;
+    record.sourceVisibility = current.session.sessionVisibility || null;
+    record.sourceBuiltinKey = current.mate && current.mate.builtinKey || null;
+    record.sourceSessionOriginId = current.session.sessionOriginId || null;
+    record.sourceQueryGeneration = current.session._sdkQueryGeneration || null;
+    var parent = ctx.records.find(function (item) { return item.sourceKey === record.sourceKey && item.delivery !== 'follow_up' &&
+      item.targetProjectSlug === record.targetProjectSlug && item.targetSessionRef === record.targetSessionRef; });
+    record.parentAssignmentId = parent && parent.assignmentId || null;
+  }
+  function validate(record, project, inspected) {
+    var current = source(record), saved = snapshots.get(record);
+    if (saved && (saved.project !== project || saved.session !== inspected.session || saved.origin !== inspected.session.sessionOriginId ||
+        saved.linuxUser !== (inspected.linuxUser || null) || saved.source !== current.session || saved.sourceProject !== current.project) ||
+        record.targetSessionOriginId && record.targetSessionOriginId !== inspected.session.sessionOriginId ||
+        record.sourceSessionOriginId && record.sourceSessionOriginId !== current.session.sessionOriginId ||
+        record.parentAssignmentId && (!inspected.session.assignment || inspected.session.assignment.assignmentId !== record.parentAssignmentId) ||
+        record.sourceVisibility !== (current.session.sessionVisibility || null) ||
+        record.targetDirectory !== (project.getStatus().path || null) || record.sourceDirectory !== (current.project.getStatus().path || null) ||
+        record.sourceBuiltinKey !== (current.mate && current.mate.builtinKey || null) ||
+        (record.targetLinuxUser || null) !== (inspected.linuxUser || null) ||
+        (record.sourceQueryGeneration || null) !== (current.session._sdkQueryGeneration || null)) throw new Error('Follow-up identity or OS mapping changed. Request a new review.');
+    return inspected;
+  }
+  function busy(session) { return !!(session.isProcessing || session._queryStarting || session._awaitingTurnResult); }
+  function cleanup(record) {
+    var unsubscribe = sourceWatches.get(record);
+    if (unsubscribe) unsubscribe();
+    sourceWatches.delete(record);
+  }
+  function track(record) {
+    if (sourceWatches.has(record)) return;
+    var current = source(record);
+    if (typeof current.manager.subscribeSession !== 'function') return;
+    var unsubscribe = current.manager.subscribeSession(current.session.localId, function () {
+      if (record.status !== 'queued') return;
+      try { validate(record, ctx.exactTarget(record), inspect(record, ctx.exactTarget(record))); } catch (error) { stop(record, 'interrupted', error); }
+    });
+    if (unsubscribe) sourceWatches.set(record, unsubscribe);
+  }
+  function first(record) {
+    return ctx.records.filter(function (item) { return item.status === 'queued' && item.userId === record.userId &&
+      item.targetProjectSlug === record.targetProjectSlug && item.targetSessionRef === record.targetSessionRef; })
+      .sort(function (a, b) { return a.queueOrder - b.queueOrder; })[0];
+  }
+  function wake(record) { var next = first(record); if (next) schedule(next); }
+  function stop(record, status, error) {
+    try { ctx.settle(record, status, null, error.message); }
+    catch (failure) { console.error('Follow-up status could not be persisted:', failure.message); }
+  }
+  function schedule(record) {
+    if (record.status !== 'queued' || scheduled.has(record)) return;
+    scheduled.add(record);
+    setImmediate(function () {
+      scheduled.delete(record);
+      if (record.status !== 'queued') return;
+      try {
+        var project = ctx.exactTarget(record);
+        if (!project) throw new Error('Target project access changed.');
+        var inspected = validate(record, project, inspect(record, project));
+        if (inspected.session._lastTurnInterrupted) throw new Error('Driver was stopped; explicit owner resumption is required.');
+        if (first(record) !== record || busy(inspected.session)) return;
+        Promise.resolve(ctx.approve(record)).catch(function (error) { stop(record, 'failed', error); });
+      } catch (error) { stop(record, 'interrupted', error); }
+    });
+  }
+  return { inspect: inspect, remember: remember, validate: validate, busy: busy, track: track, schedule: schedule, first: first, wake: wake, cleanup: cleanup };
+}
+module.exports = { createFollowUpQueue: createFollowUpQueue };

package/lib/workspace-query-mcp-server.js

@@ -90,7 +90,7 @@ function commonTools(bound) {
     },
     {
       name: "propose_project_follow_up",
-      description: "Propose a bounded follow-up in an existing durable private session. This posts a user-visible approval card and performs no target work until explicit approval.",
+      description: "Propose reviewed instructions for an exact existing private Driver session, including an update to your active assignment. Busy Drivers queue approved instructions for their next turn; stopped sessions require explicit owner resumption. No target work occurs before human approval.",
       inputSchema: shape({
         projectSlug: field("string", "Exact owned target project slug."),
         targetSessionRef: field("string", "Durable opaque session reference returned by list_project_sessions."),

package/package.json

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

package/lib/public/pane-assets/chunk-6D4DPE5X.js

@@ -1 +0,0 @@
-import{l as a,m as b,n as c,o as d}from"./chunk-IZ2ZANEY.js";import"./chunk-7H36SUZA.js";import"./chunk-DGOFGEUK.js";export{a as closeLinear,c as handleLinearResult,d as initLinearPanel,b as openLinear};

package/lib/public/pane-assets/chunk-6SM2WQJX.js

@@ -1 +0,0 @@
-import{K as a,L as b,M as c,N as d,O as e,P as f}from"./chunk-7H36SUZA.js";import"./chunk-DGOFGEUK.js";export{e as handleSharedBrowserMessage,d as hideSharedBrowser,f as initSharedBrowser,c as openSharedBrowser,b as openSharedBrowserAt,a as sendBrowserInput};