clay-server 5.2.0-beta.1 → 5.2.0-beta.10

package/lib/os-users.js

@@ -153,6 +153,19 @@ function fsAsUser(op, args, osUserInfo) {
     });
     var binOutput = execFileSync(binSpawn.command, binSpawn.args, binSpawn.options);
     return { buffer: Buffer.from(binOutput.trim(), "base64") };
+  } else if (op === 'write_exact') {
+    script = [
+      "var fs = require('fs'), crypto = require('crypto'), path = require('path');",
+      "var f = " + JSON.stringify(args.file) + "; var expected = " + JSON.stringify(args.expected) + ";",
+      "var root = " + JSON.stringify(args.root) + "; var relative = path.relative(root, f);",
+      "function checkPath() { if (fs.realpathSync(root) !== root || path.isAbsolute(relative) || relative.split(path.sep).indexOf('..') >= 0) throw new Error('The canonical file boundary changed.'); var at = root; relative.split(path.sep).forEach(function (part) { at = path.join(at, part); if (fs.lstatSync(at).isSymbolicLink()) throw new Error('File parent symlinks are unavailable.'); }); }",
+      "checkPath();",
+      "var fd = fs.openSync(f, fs.constants.O_RDWR | fs.constants.O_NOFOLLOW);",
+      "try { var s = fs.fstatSync(fd);",
+      "if (!s.isFile() || s.nlink !== 1 || s.dev !== expected.dev || s.ino !== expected.ino || s.mode !== expected.mode || s.uid !== expected.uid || s.gid !== expected.gid || s.size !== expected.size || s.mtimeMs !== expected.mtime || crypto.createHash('sha256').update(fs.readFileSync(fd, 'utf8')).digest('hex') !== expected.hash) throw new Error('The exact file revision changed.');",
+      "checkPath(); fs.ftruncateSync(fd, 0); var bytes = Buffer.from(" + JSON.stringify(args.content) + ", 'utf8'), offset = 0; while (offset < bytes.length) { var written = fs.writeSync(fd, bytes, offset, bytes.length - offset, offset); if (!written) throw new Error('File write made no progress.'); offset += written; } fs.fsyncSync(fd); } finally { fs.closeSync(fd); }",
+      "process.stdout.write(JSON.stringify({ ok: true }));",
+    ].join(' ');
   } else if (op === "write") {
     script = [
       "var fs = require('fs');",
@@ -267,18 +280,18 @@ function isHomeDirectory(dirPath) {
  * Uses setfacl to add recursive + default ACL entries.
  * Skips home directories to avoid slow recursive ACL on large trees.
  */
-function grantProjectAccess(projectPath, linuxUser) {
+function grantProjectAccess(projectPath, linuxUser, options) {
   if (isHomeDirectory(projectPath)) {
     console.log("[os-users] Skipping ACL for home directory: " + projectPath);
-    return;
+    return true;
   }
   if (!isSafeLinuxUsername(linuxUser)) {
     console.error("[os-users] Invalid Linux username for ACL grant: " + linuxUser);
-    return;
+    return false;
   }
   var cacheKey = aclCacheKey(projectPath, linuxUser);
-  if (_aclGrantCache[cacheKey]) {
-    return;
+  if (_aclGrantCache[cacheKey] && !(options && options.force)) {
+    return true;
   }
   try {
     // Recursive ACL for existing files
@@ -295,6 +308,7 @@ function grantProjectAccess(projectPath, linuxUser) {
     });
     _aclGrantCache[cacheKey] = true;
     console.log("[os-users] Granted ACL access for " + linuxUser + " on " + projectPath);
+    return true;
   } catch (e) {
     delete _aclGrantCache[cacheKey];
     var errMsg = (e.stderr || e.message || "").toString();
@@ -305,6 +319,7 @@ function grantProjectAccess(projectPath, linuxUser) {
     } else {
       console.error("[os-users] Failed to grant ACL access for " + linuxUser + " on " + projectPath + ": " + errMsg);
     }
+    return false;
   }
 }
 
@@ -460,72 +475,11 @@ function getLinuxUserUid(username) {
  * hardcoded ~/.local/bin/claude path.
  * Returns true if claude resolves, false otherwise.
  */
-function claudeAvailableForUser(linuxName) {
-  if (!isSafeLinuxUsername(linuxName)) return false;
-  try {
-    var out = execFileSync("su", ["-", linuxName, "-c", "command -v claude"], {
-      encoding: "utf8",
-      timeout: 10000,
-      stdio: "pipe",
-    }).trim();
-    return out.length > 0;
-  } catch (e) {
-    return false;
-  }
-}
-
-/**
- * Install Claude CLI for a Linux user account.
- * Downloads and runs the install script, then ensures PATH is configured.
- * Non-fatal: logs errors but does not throw.
- * Skips entirely when claude is already resolvable for the user, or when
- * CLAY_SKIP_CLAUDE_INSTALL is set (bring-your-own-claude).
- */
-function installClaudeCli(linuxName) {
-  if (process.env.CLAY_SKIP_CLAUDE_INSTALL) {
-    console.log("[os-users] CLAY_SKIP_CLAUDE_INSTALL set, skipping Claude CLI install for " + linuxName);
-    return;
-  }
-  if (claudeAvailableForUser(linuxName)) {
-    console.log("[os-users] Claude CLI already available for " + linuxName + ", skipping install");
-    return;
-  }
-  try {
-    if (!isSafeLinuxUsername(linuxName)) throw new Error("Invalid Linux username");
-    // Download and run the Claude CLI install script as the target user
-    execFileSync("su", ["-", linuxName, "-c", "curl -fsSL https://claude.ai/install.sh | bash"], {
-      encoding: "utf8",
-      timeout: 60000,
-      stdio: "pipe",
-    });
-    console.log("[os-users] Claude CLI installed for " + linuxName);
-  } catch (e) {
-    var msg = (e.stderr || e.message || "").trim();
-    console.error("[os-users] Failed to install Claude CLI for " + linuxName + ": " + msg);
-    return;
-  }
-
-  // Append PATH export to the user's shell config if not already present
-  try {
-    var userInfo = resolveOsUserInfo(linuxName);
-    var home = userInfo.home || ("/home/" + linuxName);
-    var rcPath = fs.existsSync(path.join(home, ".zshrc")) ? path.join(home, ".zshrc") : path.join(home, ".bashrc");
-    var exportLine = 'export PATH="$HOME/.local/bin:$PATH"';
-    var existing = "";
-    try { existing = fs.readFileSync(rcPath, "utf8"); } catch (e2) {}
-    if (existing.indexOf(exportLine) === -1) {
-      var prefix = existing && !/\n$/.test(existing) ? "\n" : "";
-      fs.appendFileSync(rcPath, prefix + exportLine + "\n", "utf8");
-      try { fs.chownSync(rcPath, userInfo.uid, userInfo.gid); } catch (e3) {}
-      console.log("[os-users] PATH export appended to " + rcPath + " for " + linuxName);
-    } else {
-      console.log("[os-users] PATH already configured in " + rcPath + " for " + linuxName);
-    }
-  } catch (e) {
-    var rcMsg = (e.stderr || e.message || "").trim();
-    console.error("[os-users] Failed to configure PATH for " + linuxName + ": " + rcMsg);
-  }
+function defaultRuntimeProvisioning() {
+  return require("./yoke/provisioning").forProvider("claude", { isSafeLinuxUsername: isSafeLinuxUsername, resolveOsUserInfo: resolveOsUserInfo });
 }
+function claudeAvailableForUser(user) { return defaultRuntimeProvisioning().available(user); }
+function installClaudeCli(user) { return defaultRuntimeProvisioning().install(user); }
 
 /**
  * Provision a Linux user account for a Clay user.

package/lib/pane-pending-interactions.js

@@ -0,0 +1,20 @@
+// Pending requests can precede the initial history window. Restate their exact
+// display payloads before snapshot completion, without resolving or replaying
+// any human decision. Client renderers deduplicate by their original IDs.
+function send(session, emit) {
+  Object.keys(session.pendingAskUser || {}).forEach(function (id) {
+    var pending = session.pendingAskUser[id];
+    var input = pending.input || { questions: pending.request && pending.request.questions || [] };
+    emit({ type: 'ask_user_pending', toolId: id, input: input });
+  });
+  Object.keys(session.pendingElicitations || {}).forEach(function (id) {
+    var request = session.pendingElicitations[id].request || {};
+    emit({ type: 'elicitation_request', requestId: id, serverName: request.serverName, message: request.message,
+      mode: request.mode || 'form', url: request.url || null, elicitationId: request.elicitationId || null, requestedSchema: request.requestedSchema || null });
+  });
+  Object.keys(session.pendingUserDialogs || {}).forEach(function (id) {
+    var request = session.pendingUserDialogs[id].request || {};
+    emit({ type: 'user_dialog_request', requestId: id, dialogKind: request.dialogKind, payload: request.payload || {}, toolUseId: request.toolUseID || null });
+  });
+}
+module.exports = { send: send };

package/lib/pane-session-activation.js

@@ -0,0 +1,114 @@
+var provenance = require('./session-provenance');
+
+// This opt-in protocol only describes an authenticated ordinary pane snapshot.
+// It grants no action authority and is never a visible-render acknowledgement.
+function begin(ctx, ws, msg) {
+  if (!Object.prototype.hasOwnProperty.call(msg, 'paneActivation')) {
+    ws._clayPaneActivation = null;
+    return null;
+  }
+  var request = msg.paneActivation;
+  var session = ctx.sm.sessions.get(msg.id);
+  var userId = ws._clayUser && ws._clayUser.id || null;
+  var worker = provenance.isWorker(session);
+  var parentSession = worker && Array.from(ctx.sm.sessions.values()).find(function (parent) { return parent.sessionOriginId === session.sessionProvenance.parentSessionOriginId && !provenance.isWorker(parent); });
+  var identity = session && {
+    requestId: request && request.requestId,
+    generation: request && request.generation,
+    projectSlug: ctx.slug,
+    viewerId: userId,
+    ownerId: session.ownerId || null,
+    sessionId: session.localId,
+    sessionOriginId: session.sessionOriginId,
+    role: worker ? 'worker' : 'driver',
+    workerGeneration: worker ? session.sessionProvenance.generation : null,
+    parentSessionOriginId: worker ? session.sessionProvenance.parentSessionOriginId : null,
+    groupStamp: groupStamp(),
+  };
+  function groupStamp() {
+    var group = ctx.splitStore && ctx.splitStore.groupForMember(msg.id);
+    return group ? JSON.stringify({ id: group.id, members: group.members, pair: group.pair || null }) : null;
+  }
+  function allowed() {
+    if (typeof ws._clayAuthCheck === 'function' && !ws._clayAuthCheck()) return false;
+    var access = ctx.getProjectAccess ? ctx.getProjectAccess() : { visibility: 'public' };
+    if (!ctx.usersModule.isMultiUser()) return !session.ownerId;
+    return !!userId &&
+      !!ctx.usersModule.findUserById(userId) &&
+      ctx.usersModule.canAccessProject(userId, access) &&
+      ctx.usersModule.canAccessSession(userId, session, access);
+  }
+  var valid = request && typeof request === 'object' &&
+    typeof request.requestId === 'string' && /^[a-zA-Z0-9_-]{1,96}$/.test(request.requestId) &&
+    Number.isSafeInteger(request.generation) && request.generation > (ws._clayPaneActivationGeneration || 0) &&
+    ws._clayPane === true && !ws._clayContextual && !ctx.isMate && ws.readyState === 1 &&
+    session && session.sessionOriginId && !session.isMate &&
+    (session.runtimeMode || session.mode || 'gui') === 'gui' && !session.tuiSuspended &&
+    request.projectSlug === identity.projectSlug && request.viewerId === identity.viewerId &&
+    request.ownerId === identity.ownerId && request.sessionOriginId === identity.sessionOriginId &&
+    request.role === identity.role && request.workerGeneration === identity.workerGeneration &&
+    (!ctx.splitStore || request.groupStamp === identity.groupStamp && request.parentSessionOriginId === identity.parentSessionOriginId) &&
+    (!worker || Number.isSafeInteger(identity.workerGeneration) && identity.workerGeneration > 0) && allowed();
+  if (!valid) {
+    // Do not disclose whether a foreign or removed session exists.
+    ctx.sendTo(ws, { type: 'pane_activation_rejected', requestId: request && typeof request.requestId === 'string' ? request.requestId.slice(0, 96) : null });
+    return false;
+  }
+  ws._clayPaneActivationGeneration = identity.generation;
+  ws._clayPaneActivation = identity;
+  function current() {
+    return ws.readyState === 1 && ws._clayPane === true && !ws._clayContextual && !ctx.isMate && !session.isMate &&
+      ws._clayPaneActivation === identity &&
+      ctx.sm.sessions.get(msg.id) === session && session.sessionOriginId === identity.sessionOriginId &&
+      (ws._clayUser && ws._clayUser.id || null) === userId &&
+      (session.ownerId || null) === identity.ownerId &&
+      (session.runtimeMode || session.mode || 'gui') === 'gui' && !session.tuiSuspended &&
+      (provenance.isWorker(session) ? 'worker' : 'driver') === identity.role &&
+      (provenance.isWorker(session) ? session.sessionProvenance.generation : null) === identity.workerGeneration &&
+      groupStamp() === identity.groupStamp &&
+      (!worker || parentSession && ctx.sm.sessions.get(parentSession.localId) === parentSession &&
+        session.sessionProvenance.parentSessionOriginId === identity.parentSessionOriginId && parentSession.sessionOriginId === identity.parentSessionOriginId &&
+        !provenance.isWorker(parentSession) && (parentSession.ownerId || null) === identity.ownerId) &&
+      allowed();
+  }
+  function send(message) {
+    if (current() && ws._clayActiveSession === session.localId) ctx.sendTo(ws, Object.assign({}, message, { paneActivation: identity }));
+  }
+  var historyItems = [], historyText = 0;
+  // Only synchronous replay uses this bounded envelope. Each actual disclosure
+  // rechecks live authorization; nothing is cached across a send or async work.
+  send.history = function (message) {
+    if (message.type === 'history_done') {
+      flushHistory();
+      send(message);
+      return;
+    }
+    historyItems.push(message);
+    historyText += typeof message.text === 'string' ? message.text.length : 0;
+    if (historyItems.length >= 100 || historyText >= 65536) flushHistory();
+  };
+  function flushHistory() {
+    if (!historyItems.length) return;
+    var items = historyItems;
+    historyItems = []; historyText = 0;
+    send({ type: 'pane_history_batch', items: items });
+  }
+  if (current()) ctx.sendTo(ws, { type: 'pane_activation_started', paneActivation: identity });
+  ws._clayPaneActivationValid = function () { return current() && ws._clayActiveSession === identity.sessionId; };
+  return {
+    validate: function () {
+      if (current()) return true;
+      ctx.sendTo(ws, { type: 'pane_activation_rejected', requestId: identity.requestId });
+      ws._clayPaneActivation = null;
+      return false;
+    },
+    send: send,
+    finish: function () {
+      // Includes history listeners, status, permissions and context sources.
+      // Consumers still need to observe their own DOM/composer readiness.
+      if (ws._clayActiveSession === session.localId) send({ type: 'pane_activation_snapshot_done' });
+    },
+  };
+}
+
+module.exports = { begin: begin };

package/lib/pane-session-transport.js

@@ -0,0 +1,26 @@
+var AsyncLocalStorage = require('node:async_hooks').AsyncLocalStorage;
+var requests = new AsyncLocalStorage();
+
+function same(a, b) {
+  return !!a && !!b && ['requestId', 'generation', 'projectSlug', 'viewerId', 'ownerId', 'sessionId', 'sessionOriginId', 'role', 'workerGeneration', 'groupStamp', 'parentSessionOriginId'].every(function (key) { return a[key] === b[key]; });
+}
+function run(ws, msg, dispatch) {
+  var binding = ws._clayPaneActivation;
+  if (!binding && msg.paneBinding || binding && msg.type === 'switch_session' && !msg.paneActivation) return;
+  if (binding && ['switch_session', 'ping', 'pong', 'clay_ui_ready'].indexOf(msg.type) < 0) {
+    if (!same(binding, msg.paneBinding) || !ws._clayPaneActivationValid || !ws._clayPaneActivationValid()) return;
+  }
+  return requests.run({ ws: ws, binding: binding || null }, function () { return dispatch(ws, msg); });
+}
+// A direct asynchronous reply retains the request's original binding. Live
+// provider events instead supply their authoritative source session explicitly.
+function outbound(ws, message, sessionId) {
+  if (!message || message.paneActivation || /^pane_activation_/.test(message.type)) return message;
+  var scope = requests.getStore();
+  var binding = sessionId === undefined ? scope && scope.ws === ws && scope.binding : ws._clayPaneActivation;
+  if (!binding) return message;
+  if (sessionId !== undefined && binding.sessionId !== sessionId) return null;
+  if (!same(binding, ws._clayPaneActivation) || !ws._clayPaneActivationValid || !ws._clayPaneActivationValid()) return null;
+  return Object.assign({}, message, { paneActivation: binding });
+}
+module.exports = { run: run, outbound: outbound, same: same };

package/lib/project-admin-overview.js

@@ -0,0 +1,51 @@
+// This projection is an allowlist. Never add runtime/session/path objects here.
+function projectMetadata(status, access, users) {
+  if (!status || status.isMate || !access || access.error) return null;
+  var owner = access.ownerId && users.findUserById(access.ownerId);
+  return {
+    slug: status.slug,
+    project: status.title || status.project || status.slug,
+    title: status.title || status.project || status.slug,
+    projectOwnerId: owner ? owner.id : null,
+    ownerName: owner ? (owner.displayName || owner.username) : "Ownership needs recovery",
+    visibility: access.visibility,
+    contentAccess: false,
+    administrativeAccess: true,
+    ownershipRecovery: access.ownershipRecovery === "required" || !owner,
+    runtimeHealth: "Registered",
+  };
+}
+
+function metadataFor(user, status, access, users) {
+  if (!user || !users.findUserById(user.id) || user.role !== "admin" || !status || status.isMate || /^mate-/.test(status.slug)) return null;
+  return projectMetadata(status, access, users);
+}
+
+function escape(value) {
+  return String(value || "").replace(/[&<>"']/g, function (character) {
+    return { "&": "&amp;", "<": "&lt;", ">": "&gt;", '"': "&quot;", "'": "&#39;" }[character];
+  });
+}
+
+function page(metadata, projects) {
+  var privacyText = metadata.ownershipRecovery
+    ? "Content remains restricted because no verified owner is available. Ask the server operator to verify the account’s OS UID and real home/project mapping, then run the documented ownership repair."
+    : "Conversations, files and terminals are private. Ask the owner to share project access.";
+  var accessText = metadata.ownershipRecovery
+    ? "Ownership needs recovery. The server operator must independently verify or repair the authoritative account-to-OS mapping before ownership repair can succeed. Ambiguous records stay restricted; administrator status cannot claim this project. See the Project ownership and administrator access guide."
+    : "Only the project owner can change ownership, visibility and sharing. Administrator status does not grant access to private content.";
+  var strip = projects.filter(function (project) { return !project.isMate; }).map(function (project) {
+    return '<a class="icon-strip-item' + (project.slug === metadata.slug ? ' active' : '') + '" href="/p/' + encodeURIComponent(project.slug) + '/" title="' + escape(project.title || project.project) + '"><span class="icon-strip-name">' + escape((project.title || project.project || project.slug).substring(0, 2)) + '</span></a>';
+  }).join("");
+  return '<!doctype html><html lang="en"><head><meta charset="utf-8"><meta name="viewport" content="width=device-width,initial-scale=1"><title>' + escape(metadata.title) + ' · Clay</title>' +
+    '<script src="/appearance-bootstrap.js"></script><link rel="stylesheet" href="/style.css"><link rel="stylesheet" href="/css/project-admin-overview.css"></head><body>' +
+    '<div id="layout"><header id="top-bar"><a href="/" class="top-bar-brand-link" aria-label="Clay home"><span class="top-bar-brand-wordmark"></span></a></header>' +
+    '<div id="layout-body"><nav id="icon-strip" aria-label="Projects"><div class="icon-strip-projects">' + strip + '</div></nav>' +
+    '<main id="main-area" class="project-admin-overview"><div class="project-admin-canvas"><h1>' + escape(metadata.title) + '</h1>' +
+    '<div role="tablist" aria-label="Project information"><button type="button" role="tab" aria-selected="true" id="overview-tab" aria-controls="overview-panel">Overview</button><button type="button" role="tab" aria-selected="false" id="access-tab" aria-controls="access-panel">Access</button></div>' +
+    '<section id="overview-panel" role="tabpanel" aria-labelledby="overview-tab"><dl><dt>Owner</dt><dd>' + escape(metadata.ownerName) + '</dd><dt>Visibility</dt><dd>' + escape(metadata.visibility) + '</dd><dt>Status</dt><dd>' + (metadata.ownershipRecovery ? 'Ownership needs recovery' : escape(metadata.runtimeHealth)) + '</dd><dt>Your access</dt><dd>Administrative metadata only</dd></dl><p>' + escape(privacyText) + '</p><p class="project-admin-secondary">Resource usage is unavailable for this project.</p></section>' +
+    '<section id="access-panel" role="tabpanel" aria-labelledby="access-tab" hidden><h2>Administrative metadata only</h2><p>' + escape(accessText) + '</p></section></div></main></div></div>' +
+    '<script type="module" src="/modules/project-admin-overview.js"></script></body></html>';
+}
+
+module.exports = { metadataFor: metadataFor, page: page };

package/lib/project-ask-user.js

@@ -25,8 +25,9 @@ function attachAskUser(ctx) {
       respond.cancel("Autonomous mode. Make your own decision.");
       return;
     }
-    var questions = planningQuestions(boundSession, request.questions);
+    var questions = ["mcp-import", "product-control"].indexOf(request.source) >= 0 ? request.questions : planningQuestions(boundSession, request.questions);
     var input = { questions: questions };
+    if (request.source === 'mcp-import') input.source = 'mcp-import';
     if (!boundSession.pendingAskUser) boundSession.pendingAskUser = {};
     var pending = {
       input: input,
@@ -38,15 +39,18 @@ function attachAskUser(ctx) {
     };
     boundSession.pendingAskUser[request.id] = pending;
     if (respond && typeof respond.onSettle === "function") {
-      respond.onSettle(function () {
+      respond.onSettle(function (result) {
+        if (request.source === 'product-control' && result.status !== 'submitted') ctx.record(boundSession, { type: 'product_control_question_expired', toolId: request.id, error: 'This exact change review expired or was cancelled. No change was authorized.' });
+        if (request.source === 'mate-schedule' && result.status !== 'submitted') ctx.record(boundSession, { type: 'mate_schedule_question_expired', toolId: request.id, error: 'This schedule review expired. Request a new review.' });
+        if (request.source === 'mcp-import' && result.status !== 'submitted') ctx.record(boundSession, { type: 'mcp_import_consent_expired', toolId: request.id, source: 'mcp-import', error: 'Import consent expired or was cancelled. No connection was imported.' });
         if (boundSession.pendingAskUser && boundSession.pendingAskUser[request.id] === pending) delete boundSession.pendingAskUser[request.id];
       });
     }
     if (!askUserIdentity.hasRecordedAskUserRequest(boundSession.history, request.id, input)) {
-      ctx.record(boundSession, { type: "tool_executing", id: request.id, name: "AskUserQuestion", input: input });
+      ctx.record(boundSession, { type: "tool_executing", id: request.id, name: "AskUserQuestion", input: input, source: request.source });
     }
     var router = ctx.getWorkerQuestionRouter && ctx.getWorkerQuestionRouter();
-    if (router) router.routeQuestion(boundSession, request, respond, function (answers, driverId) {
+    if (router && request.source !== "mcp-import" && request.source !== "mate-schedule" && request.source !== "product-control") router.routeQuestion(boundSession, request, respond, function (answers, driverId) {
       var displayAnswers = {};
       request.questions.forEach(function (question, index) { displayAnswers[index] = answers[question.id].join(", "); });
       ctx.record(boundSession, { type: "ask_user_answered", toolId: request.id, answers: displayAnswers, answeredByDriver: driverId });

package/lib/project-connection.js

@@ -3,7 +3,7 @@ var path = require("path");
 var usersModule = require("./users");
 var userPresence = require("./user-presence");
 var emailAccounts = require("./email-accounts");
-var { getCodexConfig } = require("./codex-defaults");
+var providerSettings = require("./yoke/settings");
 var yoke = require("./yoke");
 var permissionModes = require("./session-permission-mode");
 var sessionProvenance = require("./session-provenance");
@@ -143,6 +143,9 @@ function attachConnection(ctx) {
   var _warmedUp = false;
 
   function findRestoredActiveSession(ws, wsUser, allSessions) {
+    if (ws._clayContextual && ws._clayPaneSession) {
+      return { active: allSessions.find(function (session) { return session.localId === ws._clayPaneSession; }) || null, storedPresence: null };
+    }
     var active = null;
     var presenceKey = wsUser ? wsUser.id : "_default";
     var storedPresence = userPresence.getPresence(slug, presenceKey);
@@ -202,7 +205,7 @@ function attachConnection(ctx) {
     } else if (!usersModule.isMultiUser()) {
       allSessions = allSessions.filter(function (s) { return !s.ownerId; });
     }
-    var restoredState = ws._clayPane
+    var restoredState = ws._clayPane && !ws._clayContextual
       ? { active: null, storedPresence: null }
       : findRestoredActiveSession(ws, wsUser, allSessions);
     var restoredActive = restoredState.active;
@@ -217,7 +220,7 @@ function attachConnection(ctx) {
       sm.saveSessionFile(restoredActive);
     }
     var initialModels = (sm.modelsByVendor && sm.modelsByVendor[initialVendor]) || sm.availableModels || [];
-    sendTo(ws, { type: "info", cwd: cwd, slug: slug, project: title || project, version: currentVersion, debug: !!debug, dangerouslySkipPermissions: dangerouslySkipPermissions, osUsers: osUsers, lanHost: lanHost, projectCount: _filteredProjects.length, projects: _filteredProjects, projectOwnerId: projectOwnerId, ownerLocked: ownerLocked, vendors: yoke.VENDOR_REGISTRY, isMate: isMate, mateId: isMate ? mateId : null, mateDisplayName: isMate ? (mateDisplayName || title || project || "Mate") : "" });
+    sendTo(ws, { type: "info", controlRuntimeId: require("./clay-control-target-projection").runtime(sm), cwd: cwd, slug: slug, project: title || project, version: currentVersion, debug: !!debug, dangerouslySkipPermissions: dangerouslySkipPermissions, osUsers: osUsers, lanHost: lanHost, projectCount: _filteredProjects.length, projects: _filteredProjects, projectOwnerId: projectOwnerId, ownerLocked: ownerLocked, vendors: require("./yoke/vendor-registry").publicInfo(), isMate: isMate, mateId: isMate ? mateId : null, mateDisplayName: isMate ? (mateDisplayName || title || project || "Mate") : "" });
     if (typeof sendCursorSharingState === "function") sendCursorSharingState(ws);
     // Update notifications are pushed on a scheduled interval (see
     // scheduleUpdateBroadcast). We no longer push on connect to avoid
@@ -234,8 +237,8 @@ function attachConnection(ctx) {
     var initialPermissionState = permissionModes.clientState(restoredActive, sm.currentPermissionMode, sm.defaultVendor);
     sendTo(ws, { type: "config_state", model: initialModelInfo.model, vendor: initialVendor, sessionId: restoredActive ? restoredActive.localId : null, mode: initialPermissionState.requestedPermissionMode, effectivePermissionMode: initialPermissionState.effectivePermissionMode, permissionCapabilities: initialPermissionState.permissionCapabilities, mcpPermissionModeOverrides: initialPermissionState.mcpPermissionModeOverrides, effort: initialEffort || "medium", betas: sm.currentBetas || [], thinking: sm.currentThinking || "adaptive", thinkingBudget: sm.currentThinkingBudget || 10000 });
     sendTo(ws, { type: "last_vendor", vendor: sm.lastVendor || "" });
-    sendTo(ws, Object.assign({ type: "codex_config" }, getCodexConfig(sm)));
-    sendTo(ws, { type: "term_list", terminals: tm.list() });
+    providerSettings.messages(sm).forEach(function(message) { sendTo(ws, message); });
+    sendTo(ws, { type: "term_list", terminals: tm.list(true) });
     // Any login flow already running in this project, so a reconnecting client
     // re-attaches to the existing login terminal instead of starting another.
     if (_vendorLogin) _vendorLogin.sendStateTo(ws);
@@ -267,7 +270,7 @@ function attachConnection(ctx) {
     var presenceKey = wsUser ? wsUser.id : "_default";
     var storedPresence = restoredState.storedPresence;
     var autoCreated = false;
-    if (!active && !ws._clayPane) {
+    if (!active && (!ws._clayPane || (ws._clayContextual && !ws._clayPaneSession))) {
       var autoOpts = {};
       if (wsUser && usersModule.isMultiUser()) autoOpts.ownerId = wsUser.id;
       active = sm.createSession(autoOpts, ws);
@@ -301,12 +304,13 @@ function attachConnection(ctx) {
       }
       sendTo(ws, { type: "history_meta", total: total, from: fromIndex });
       for (var i = fromIndex; i < total; i++) {
-        sendTo(ws, hydrateImageRefs(active.history[i]));
+        sendTo(ws, Object.assign({}, hydrateImageRefs(require("./yoke/usage").clientEvent(active.history[i], active.vendor || "claude")), { _historyIndex: i }));
       }
-      var _lastUsage = null, _lastModelUsage = null, _lastCost = null, _lastStreamInputTokens = null;
+      var _lastContext = null, _lastUsage = null, _lastModelUsage = null, _lastCost = null, _lastStreamInputTokens = null;
       for (var _ri = total - 1; _ri >= 0; _ri--) {
         if (active.history[_ri].type === "result") {
-          var _r = active.history[_ri];
+          var _r = require("./yoke/usage").clientEvent(active.history[_ri], active.vendor || "claude");
+          _lastContext = _r.context;
           _lastUsage = _r.usage || null;
           _lastModelUsage = _r.modelUsage || null;
           _lastCost = _r.cost != null ? _r.cost : null;
@@ -314,7 +318,7 @@ function attachConnection(ctx) {
           break;
         }
       }
-      sendTo(ws, { type: "history_done", lastUsage: _lastUsage, lastModelUsage: _lastModelUsage, lastCost: _lastCost, lastStreamInputTokens: _lastStreamInputTokens, contextUsage: active.lastContextUsage || null });
+      sendTo(ws, { type: "history_done", controlHistoryRevision: require("./clay-control-target-projection").digest(active.history || []), sessionId: active.localId, sessionOriginId: active.sessionOriginId || null, lastUsage: _lastUsage, lastModelUsage: _lastModelUsage, lastCost: _lastCost, lastStreamInputTokens: _lastStreamInputTokens, context: _lastContext, contextUsage: require("./yoke/usage").context(active.lastContextUsage, active.vendor || "claude") });
       if (scheduledMessages) scheduledMessages.sendState(active, ws);
       if (pairResultRecovery) pairResultRecovery.sendState(active, ws);
 

package/lib/project-control-git-view.js

@@ -0,0 +1,12 @@
+var fs = require('fs'), path = require('path');
+var projection = require('./clay-control-target-projection');
+function project(service, principal, status, manager) {
+  var before = service.rootIdentity(principal, 'git');
+  var directory = fs.realpathSync(status.gitDir), stat = fs.statSync(directory), indexPath = path.join(directory, 'index');
+  var index = fs.existsSync(indexPath) ? require('crypto').createHash('sha256').update(fs.readFileSync(indexPath)).digest('hex') : null;
+  var view = { runtimeId: projection.runtime(manager), repository: projection.digest([directory, [stat.dev, stat.ino, stat.mode, stat.uid, stat.gid]]),
+    files: status.files.slice(0, 200).map(function (file) { return { path: file.path, revision: projection.digest([status.oid, index, file]) }; }) };
+  if (service.rootIdentity(principal, 'git') !== before) throw new Error('Workspace identity changed during projection.');
+  return view;
+}
+module.exports = { project: project };

package/lib/project-debate.js

@@ -774,6 +774,7 @@ function attachDebate(ctx) {
       var identityMate = matesModule.getMate(debate.mateCtx, msg.mateId);
       var identityProfile = identityMate && identityMate.profile ? identityMate.profile : (identityMate || {});
       if (!msg.mateName) msg.mateName = identity.name;
+      if (!msg.avatarCatalogId) msg.avatarCatalogId = identityProfile.avatarCatalogId || "";
       if (!msg.avatarStyle) msg.avatarStyle = identity.avatarStyle;
       if (!msg.avatarSeed) msg.avatarSeed = identity.avatarSeed;
       if (!msg.avatarColor) msg.avatarColor = identity.avatarColor;

package/lib/project-delegated-follow-up.js

@@ -12,7 +12,7 @@ function unsafeReason(session, isPaired) {
   if (session.homeDebatePlanning || session.homeDebatePhase || session.debateSetupMode || session.debateState || session._debate) return "Debate sessions cannot receive project follow-ups.";
   if (session.loop || session.spawn || session.handoff || session.assignment || session.singleTurn || session._pairDelegation || isPaired) return "Orchestrated sessions cannot receive project follow-ups.";
   if (session.dangerouslySkipPermissions || session.permissionMode === "bypassPermissions") return "Full-access sessions cannot receive project follow-ups.";
-  if (session.destroying || session.scheduledMessage || session.rateLimitAutoContinuePending || session.taskStopRequested || session._runtimeRefreshRequested || session.pendingPush && session.pendingPush.length) return "Target session is not safely resumable right now.";
+  if (session.destroying || session.scheduledMessage || session.rateLimitAutoContinuePending || session.taskStopRequested || session._pendingMessageDrainPaused || session._runtimeRefreshRequested || session.pendingPush && session.pendingPush.length) return "Target session is not safely resumable right now.";
   return "";
 }
 
@@ -36,6 +36,7 @@ function attachDelegatedFollowUp(ctx) {
     var paired = !!(ctx.isPairedSession && ctx.isPairedSession(session));
     var reason = unsafeReason(session, paired);
     if (reason) throw new Error(reason);
+    if (ctx.isPendingQueuePaused && ctx.isPendingQueuePaused(session)) throw new Error("The Driver queue is stopped; explicit owner resume is required.");
     if (!ctx.canResumeVendor(session.vendor)) throw new Error("Target session provider cannot safely resume this conversation.");
     return { session: session, sessionRef: targetSessionRef, title: session.title || "Existing session" };
   }

package/lib/project-directory-claim.js

@@ -0,0 +1,65 @@
+// Reserve a new project directory before running Git or changing ownership.
+// Filesystem identity checks also keep failed attempts from deleting targets
+// replaced by another actor. Hostile OS/root mutation is outside this boundary.
+var fs = require("fs");
+var path = require("path");
+
+function canonical(candidate) {
+  var current = path.resolve(candidate);
+  var missing = [];
+  while (true) {
+    try { return path.join.apply(path, [fs.realpathSync(current)].concat(missing)); }
+    catch (error) {
+      if (error.code !== "ENOENT") throw error;
+      // A dangling symlink is an existing object, not a missing directory.
+      try { fs.lstatSync(current); throw new Error("A project path contains a dangling symlink."); }
+      catch (statError) { if (statError.code !== "ENOENT") throw statError; }
+      var parent = path.dirname(current);
+      if (parent === current) throw error;
+      missing.unshift(path.basename(current));
+      current = parent;
+    }
+  }
+}
+
+function inside(root, candidate) {
+  var relative = path.relative(root, candidate);
+  return relative !== ".." && relative.indexOf(".." + path.sep) !== 0 && !path.isAbsolute(relative);
+}
+
+function rejectIntersection(target, projects, userId) {
+  (projects || []).forEach(function (project) {
+    var root = canonical(project.path);
+    if (target === root || inside(target, root) || (project.ownerId !== userId && inside(root, target))) {
+      throw new Error("The destination intersects a registered project.");
+    }
+  });
+}
+
+function claim(options) {
+  var slug = options.slug;
+  if (!slug || slug === "." || slug === ".." || path.basename(slug) !== slug) throw new Error("Invalid project directory name.");
+  var base = canonical(options.baseDir);
+  var target = path.join(base, slug);
+  rejectIntersection(target, options.projects, options.userId);
+  fs.mkdirSync(base, { recursive: true });
+  if (fs.realpathSync(options.baseDir) !== base) throw new Error("The project base directory changed.");
+  rejectIntersection(target, options.projects, options.userId);
+  // EEXIST rejects directories, files, symlinks and concurrent claims alike.
+  fs.mkdirSync(target, { mode: 0o700 });
+  var identity = fs.lstatSync(target);
+  function assertOwned() {
+    var current = fs.lstatSync(target);
+    if (!current.isDirectory() || current.isSymbolicLink() || current.dev !== identity.dev || current.ino !== identity.ino || fs.realpathSync(base) !== base) {
+      throw new Error("The claimed project directory changed.");
+    }
+  }
+  function cleanup() {
+    try { assertOwned(); } catch (error) { return false; }
+    fs.rmSync(target, { recursive: true });
+    return true;
+  }
+  return { path: target, assertOwned: assertOwned, cleanup: cleanup };
+}
+
+module.exports = { claim: claim, canonical: canonical };