clay-server 5.2.0-beta.3 → 5.2.0-beta.5

package/lib/project-shared-browser.js

@@ -5,12 +5,14 @@ var browserTools = require("./shared-browser-tools");
 var createRuntime = require("./shared-browser-runtime").createRuntime;
 
 function attachSharedBrowser(ctx) {
+  var storageStore = ctx.storageStore || require("./shared-browser-storage").attachStorageStore(require("./config").CONFIG_DIR);
   var records = new Map();
   var viewers = new Map();
   var destroyed = false;
   function allowed(session, ws) {
     try {
-      if (ctx.isMate || !session || ctx.sm.sessions.get(session.localId) !== session) return false;
+      if (!session || ctx.sm.sessions.get(session.localId) !== session) return false;
+      if (ctx.isMate && ctx.usersModule.isMultiUser() && (!ctx.ownerId || session.ownerId !== ctx.ownerId)) return false;
       if (ctx.usersModule.isMultiUser()) {
         var user = ctx.usersModule.findUserById(session.ownerId);
         if (!user || (ws && (!ws._clayUser || String(ws._clayUser.id) !== String(user.id)))) return false;
@@ -35,7 +37,7 @@ function attachSharedBrowser(ctx) {
   function projection(record) {
     if (!record) return null;
     return { id: record.id, phase: record.phase, control: record.control, epoch: record.epoch, handoff: !!record.handoff,
-      url: record.url, width: record.width, height: record.height, activity: record.activity || null, activityHistory: record.activityHistory || [], pointer: record.pointer || null, error: record.error || "" };
+      browserLink: record.url ? "browser:" + record.url : null, incognito: record.incognito, personalCookiesAvailable: !!ctx.isMate, url: record.url, width: record.width, height: record.height, activity: record.activity || null, activityHistory: record.activityHistory || [], pointer: record.pointer || null, error: record.error || "" };
   }
   function sessionRecords(session) {
     return Array.from(records.values()).filter(function (record) { return record.session === session && recordAllowed(record); });
@@ -93,6 +95,13 @@ function attachSharedBrowser(ctx) {
     if ((record.activity || record.pointer) && record.activityGeneration !== Number(record.session._sdkQueryGeneration || 0)) {
       activityHistory.interruptActivity(record); record.pointer = null; broadcast(record);
     }
+    if (message.type === "navigation") {
+      try { record.navigationUrl = policy.browserUrl(message.navigationUrl || message.url); } catch (error) { record.navigationUrl = null; }
+    }
+    if (message.type === "navigation" && !record.incognito) {
+      try { storageStore.visit(record.cookieOwner, message.url); }
+      catch (error) { end(record, "Could not save personal browsing history"); return; }
+    }
     if (message.type === "ready") { record.phase = "live"; record.resolveReady(); }
     if (message.type === "error") { end(record, message.error); return; }
     if (message.url !== undefined) record.url = policy.visibleUrl(message.url);
@@ -108,10 +117,12 @@ function attachSharedBrowser(ctx) {
   }
   // Every new tab starts shared. Exclusive human mode is explicit, per tab, and only the human clears it,
   // so an agent open never reuses (or bypasses) an exclusive tab.
-  function create(session, actor, newTab) {
+  function create(session, actor, newTab, incognito) {
     requireAccess(session);
+    if (incognito !== undefined && typeof incognito !== "boolean") throw new Error("Invalid incognito mode");
+    var temporary = !ctx.isMate || incognito === true;
     var tabs = sessionRecords(session);
-    var previous = !newTab && tabs.find(function (record) { return record.runtime && (actor === "user" || record.control === "agent"); });
+    var previous = !newTab && tabs.find(function (record) { return record.runtime && (incognito === undefined || record.incognito === temporary) && (actor === "user" || record.control === "agent"); });
     if (previous) return previous;
     if (tabs.length >= 12) {
       var expired = tabs.find(function (record) { return !record.runtime; });
@@ -122,12 +133,15 @@ function attachSharedBrowser(ctx) {
     records.forEach(function (record) { if (record.runtime && record.ownerId === session.ownerId) active++; });
     if (active >= 4) throw new Error("End another browser before opening more than four active tabs");
     var record = { session: session, ownerId: session.ownerId, identity: identityKey(session), id: crypto.randomUUID(), phase: "starting", control: "agent", epoch: 0,
-      url: "", width: 1280, height: 800, touched: Date.now(), runtime: null, frame: null };
+      cookieOwner: ctx.isMate ? (ctx.ownerId || session.ownerId || "default") : null, incognito: temporary, url: "", width: 1280, height: 800, touched: Date.now(), runtime: null, frame: null };
     record.ready = new Promise(function (resolve, reject) { record.resolveReady = resolve; record.rejectReady = reject; });
     record.ready.catch(function () {});
     records.set(record.id, record);
     try {
-      record.runtime = (ctx.createRuntime || createRuntime)({ identity: ctx.getIdentity(session), onEvent: function (message) { receive(record, message); } });
+      record.runtime = (ctx.createRuntime || createRuntime)({ identity: ctx.getIdentity(session), storage: temporary ? null : {
+        read: function () { if (!recordAllowed(record)) throw new Error("Browser access was revoked"); return storageStore.read(record.cookieOwner); },
+        exchange: function (previous, current) { if (!recordAllowed(record)) throw new Error("Browser access was revoked"); return storageStore.exchange(record.cookieOwner, previous, current); },
+      }, onEvent: function (message) { receive(record, message); } });
     } catch (e) { end(record, e.message); }
     broadcast(record, true);
     return record;
@@ -186,6 +200,7 @@ function attachSharedBrowser(ctx) {
     requireAccess(session);
     if (actor === "agent" && Number(session._sdkQueryGeneration || 0) !== generation) throw new Error("Browser result belongs to an older query");
     if (!recordAllowed(record) || records.get(record.id) !== record || record.epoch !== epoch) throw new Error("Browser control changed during the action");
+    if (result && result.url !== undefined) record.url = policy.visibleUrl(result.url);
     return result;
   }
   async function tool(session, args) {
@@ -196,8 +211,10 @@ function attachSharedBrowser(ctx) {
       var value;
       if (args.action === "status") value = { browsers: sessionRecords(session).map(projection) };
       else if (args.action === "open") {
+        if (args.incognito !== undefined && typeof args.incognito !== "boolean") throw new Error("Invalid incognito mode");
         var url = args.url ? policy.browserUrl(args.url) : null;
-        record = args.browserId ? selectRecord(session, args.browserId) : create(session, "agent", args.newTab === true);
+        record = args.browserId ? selectRecord(session, args.browserId) : create(session, "agent", args.newTab === true, args.incognito);
+        if (args.incognito !== undefined && record.incognito !== (!ctx.isMate || args.incognito)) throw new Error("This tab has a different cookie mode. Open a new tab with the requested mode.");
         if (url) await run(session, record, "agent", "action", { kind: "navigate", url: url }, args.intent);
         value = projection(record);
       } else if (args.action === "finish") {
@@ -206,14 +223,27 @@ function attachSharedBrowser(ctx) {
       } else if (args.action === "inspect") {
         value = await run(session, record, "agent", "inspect", null, args.intent);
         value.browserId = record.id;
+        value.browserLink = record.url ? "browser:" + record.url : null;
         var image = value.image; delete value.image;
         return { content: [{ type: "text", text: JSON.stringify(value) }, { type: "image", mimeType: "image/jpeg", data: image }] };
       } else {
         value = await run(session, record, "agent", "action", policy.validateAction(Object.assign({}, args, { kind: args.action })), args.intent);
       }
+      if (value && value.url) value.browserLink = "browser:" + policy.visibleUrl(value.url);
       return { content: [{ type: "text", text: JSON.stringify(value) }] };
     } catch (e) { return { isError: true, content: [{ type: "text", text: e.message }] }; }
   }
+  async function openLinkedPage(session, url, incognito) {
+    var record = sessionRecords(session).find(function (tab) {
+      return tab.runtime && ((tab.phase === "live" && (tab.navigationUrl || tab.url) === url) || (tab.linkOpening && tab.linkOpening.url === url));
+    });
+    if (record) { if (record.linkOpening) await record.linkOpening.promise; return record; }
+    record = create(session, "user", true, incognito);
+    record.navigationUrl = url;
+    record.linkOpening = { url: url, promise: run(session, record, "user", "action", { kind: "navigate", url: url }) };
+    try { await record.linkOpening.promise; } finally { record.linkOpening = null; }
+    return record;
+  }
   function handleMessage(ws, msg) {
     if (!msg.type || msg.type.indexOf("shared_browser_") !== 0) return false;
     var session = ctx.getSessionForWs(ws);
@@ -221,8 +251,22 @@ function attachSharedBrowser(ctx) {
       requireAccess(session, ws);
       if (String(msg.sessionId) !== String(session.localId)) throw new Error("Browser session changed");
       var record;
+      if (msg.type === "shared_browser_settings") {
+        if (!ctx.isMate) throw new Error("Personal browser settings are available only in Mates");
+        if (typeof msg.requestId !== "string" || msg.requestId.length > 100) throw new Error("Invalid browser settings request");
+        var owner = ctx.ownerId || session.ownerId || "default";
+        var settings = storageStore.manage(owner, msg.operation, msg.target);
+        requireAccess(session, ws);
+        ctx.sendTo(ws, { type: "shared_browser_settings", sessionId: session.localId, requestId: msg.requestId, settings: settings });
+        return;
+      }
       if (msg.type === "shared_browser_state_request") { sendState(ws, session, sessionRecords(session)[0]); return; }
-      if (msg.type === "shared_browser_open") { record = create(session, "user", msg.newTab === true); sendState(ws, session, record, true, true); return; }
+      if (msg.type === "shared_browser_open") {
+        var targetUrl = msg.url === undefined ? null : policy.browserUrl(msg.url);
+        if (targetUrl) record = await openLinkedPage(session, targetUrl, msg.incognito);
+        else record = create(session, "user", msg.newTab === true, msg.incognito);
+        sendState(ws, session, record, true, true); return;
+      }
       record = selectRecord(session, msg.browserId);
       if (!record || !recordAllowed(record, ws) || msg.browserId !== record.id) throw new Error("Browser session expired");
       if (msg.type === "shared_browser_view") {
@@ -242,7 +286,7 @@ function attachSharedBrowser(ctx) {
         await run(session, record, "user", "action", policy.validateAction(msg.event));
       }
     }).catch(function (e) {
-      if (ws.readyState === 1) ctx.sendTo(ws, { type: "shared_browser_error", sessionId: msg.sessionId, error: e.message });
+      if (ws.readyState === 1) ctx.sendTo(ws, { type: "shared_browser_error", sessionId: msg.sessionId, error: e.message, requestId: msg.requestId });
     });
     return true;
   }
@@ -257,7 +301,7 @@ function attachSharedBrowser(ctx) {
   sweep.unref();
   function getToolDefs(session) {
     var generation = Number(session && session._sdkQueryGeneration || 0);
-    return ctx.isMate ? [] : browserTools.getToolDefs(function (args) {
+    return browserTools.getToolDefs(function (args) {
       if (session && Number(session._sdkQueryGeneration || 0) !== generation) {
         return Promise.resolve({ isError: true, content: [{ type: "text", text: "This browser tool belongs to an older query" }] });
       }
@@ -267,8 +311,8 @@ function attachSharedBrowser(ctx) {
   return {
     handleMessage: handleMessage,
     getToolDefs: getToolDefs,
-    getSystemPrompt: function () { return ctx.isMate ? "" : browserTools.PROMPT; },
-    createMcpServer: function (adapter, session) { return ctx.isMate || !adapter || typeof adapter.createToolServer !== "function" ? null : adapter.createToolServer({ name: "clay-shared-browser", version: "1.0.0", tools: getToolDefs(session) }); },
+    getSystemPrompt: function () { return browserTools.PROMPT; },
+    createMcpServer: function (adapter, session) { return !adapter || typeof adapter.createToolServer !== "function" ? null : adapter.createToolServer({ name: "clay-shared-browser", version: "1.0.0", tools: getToolDefs(session) }); },
     destroy: function () { destroyed = true; clearInterval(sweep); records.forEach(function (record) { end(record); }); records.clear(); viewers.clear(); },
   };
 }

package/lib/project-user-message.js

@@ -118,6 +118,12 @@ function attachUserMessage(ctx) {
       requestId: msg.requestId || null, ok: !!ok, error: error || null });
   }
 
+  function noteUpdateResult(ws, msg, ok, note, error) {
+    if (!msg.requestId) return;
+    sendTo(ws, { type: "note_update_result", projectSlug: slug, noteId: msg.id || null,
+      requestId: msg.requestId, ok: !!ok, note: note || null, error: error || null });
+  }
+
   // --------------- Main handler ---------------
 
   function handleUserMessage(ws, msg, forcedSession, internal) {
@@ -155,7 +161,10 @@ function attachUserMessage(ctx) {
     }
 
     if (msg.type === "note_update") {
-      if (!msg.id) return true;
+      if (!msg.id) {
+        noteUpdateResult(ws, msg, false, null, "Note id is required");
+        return true;
+      }
       // A legacy `hidden` update is a lifecycle transition, so the actor is
       // derived from the bound socket rather than taken from the message.
       var noteChanges = msg;
@@ -166,10 +175,24 @@ function attachUserMessage(ctx) {
       if (updated) {
         send({ type: "note_updated", note: updated });
         if (msg.text !== undefined || msg.hidden !== undefined) syncNotesKnowledge();
+        noteUpdateResult(ws, msg, true, updated, null);
+      } else {
+        noteUpdateResult(ws, msg, false, null, "Note update could not be saved");
       }
       return true;
     }
 
+    if (msg.type === "note_close" && msg.humanClose === true) {
+      if (!canHumanManageNotes(ws)) { noteUpdateResult(ws, msg, false, null, "You are not authorized to close notes in this project."); return true; }
+      var result = nm.closeHuman(msg.id, msg, notesLifecycle.userActor(ws && ws._clayUser));
+      if (!result) { noteUpdateResult(ws, msg, false, null, "The note changed or could not be saved. Review it and retry."); return true; }
+      if (result.removed) send({ type: "note_deleted", id: result.removed.id });
+      else send({ type: "note_updated", note: result.note });
+      noteUpdateResult(ws, msg, true, result.note || null, null);
+      syncNotesKnowledge();
+      return true;
+    }
+
     // Completing a note closes it. `note_delete` is the retired spelling and is
     // deliberately routed to the same non-destructive close, so an older client
     // still on the wire cannot erase a record.
@@ -443,6 +466,10 @@ function attachUserMessage(ctx) {
       finishPendingEarly(false, "Pending messages cannot be delivered to a Driver-operated Split Worker");
       return true;
     }
+    if (!pendingInternal && ctx.resumeLifecycleProject) {
+      try { ctx.resumeLifecycleProject(ws); }
+      catch (error) { sendTo(ws, { type: "error", text: error.message }); return true; }
+    }
     if (!pendingInternal && session._driverContinuationLease && pendingMessageQueue) {
       var continuationQueued = pendingMessageQueue.admit(session, msg, ws && ws._clayUser);
       if (continuationQueued.ok) {
@@ -719,6 +746,7 @@ function attachUserMessage(ctx) {
 
     function pendingBlockReason() {
       if (!pendingInternal) return null;
+      if (ctx.isLifecycleExecutionPaused && ctx.isLifecycleExecutionPaused()) return "Pending message dispatch paused";
       if (!pendingMessageQueue.isClaimed(session, pendingInternal.item.id)) return "Pending message was cancelled";
       if (pendingMessageQueue.isPaused(session) || session._pendingMessageDrainPaused || session.taskStopRequested) return "Pending message dispatch paused";
       if (typeof ctx.authorizePendingDispatch !== "function" || !ctx.authorizePendingDispatch(session, ws && ws._clayUser, pendingInternal.item)) return "Pending message authorization changed";
@@ -941,6 +969,7 @@ function attachUserMessage(ctx) {
   }
 
   function consumePendingMessage(session) {
+    if (ctx.isLifecycleExecutionPaused && ctx.isLifecycleExecutionPaused()) return false;
     if (!pendingMessageQueue) return false;
     var consumed = pendingMessageQueue.consumeOne(session, function (item, complete) {
       var actor = item.actorId && usersModule.findUserById(item.actorId);

package/lib/project-workspace-operations.js

@@ -0,0 +1,126 @@
+var fs = require('fs'), path = require('path'), crypto = require('crypto');
+var git = require('./git-cli');
+function digest(value) { return crypto.createHash('sha256').update(typeof value === 'string' || Buffer.isBuffer(value) ? value : JSON.stringify(value)).digest('hex'); }
+function inode(file) { var s = fs.statSync(file); return [s.dev, s.ino, s.mode, s.uid, s.gid]; }
+function attachWorkspaceOperations(ctx) {
+  var busy = false;
+  function authorize(principal, domain) {
+    var record = ctx.getAccess(), user = principal.userId && ctx.users.findUserById(principal.userId);
+    if (ctx.isMate || !record || record.lifecycleExecutionPaused || ctx.users.isMultiUser() && (!user || record.ownerId !== user.id || !ctx.users.canAccessProject(user.id, record))) throw new Error('Live selected-project ownership or access is unavailable.');
+    if (!ctx.users.isMultiUser() && record.ownerId && record.ownerId !== principal.singleUserOwnerId) throw new Error('Selected-project ownership changed.');
+    if (user && ctx.users.getEffectivePermissions(user, ctx.osUsers)[domain === 'terminal' ? 'terminal' : 'fileBrowser'] !== true) throw new Error('The account does not have permission for this product operation.');
+    var identity = null;
+    if (ctx.osUsers) {
+      if (!user || !user.linuxUser) throw new Error('A live mapped OS identity is required.');
+      identity = require('./os-users').resolveOsUserInfo(user.linuxUser);
+      if (!identity || !Number.isInteger(identity.uid) || identity.uid < 0 || !Number.isInteger(identity.gid) || identity.gid < 0 || identity.user !== user.linuxUser) throw new Error('The mapped OS identity is unavailable.');
+    }
+    return { identity: identity, projectBound: true, ownerId: user ? user.id : null };
+  }
+  function rootIdentity(principal, domain) {
+    var scope = authorize(principal, domain), root = fs.realpathSync(ctx.cwd);
+    return digest([root, inode(root), scope.ownerId, scope.identity && [scope.identity.user, scope.identity.uid, scope.identity.gid, scope.identity.home]]);
+  }
+  function bounded(requested, missing) {
+    if (typeof requested !== 'string' || !requested || path.isAbsolute(requested) || /[\u0000-\u001f\u007f]/.test(requested) || requested.split(/[\\/]/).some(function (part) { return part === '..' || ['.git', '.clay', '.claude', '.codex', '.envrc'].indexOf(part) >= 0; })) throw new Error('Use an in-project relative path outside managed settings and Git metadata.');
+    var root = fs.realpathSync(ctx.cwd), resolved = root;
+    var parts = requested.split('/').filter(function (part) { return part && part !== '.'; });
+    for (var i = 0; i < parts.length; i++) {
+      resolved = path.join(resolved, parts[i]);
+      var stat;
+      try { stat = fs.lstatSync(resolved); } catch (error) { if (missing && error.code === 'ENOENT' && i === parts.length - 1) return resolved; throw error; }
+      if (stat.isSymbolicLink() || stat.isFile() && stat.nlink !== 1) throw new Error('Symlinks and multiply linked files are unavailable in canonical project controls.');
+    }
+    if (path.relative(root, resolved).split(path.sep).indexOf('..') >= 0) throw new Error('The canonical project boundary changed.');
+    return resolved;
+  }
+  function repository(scope) {
+    var marker = fs.lstatSync(path.join(ctx.cwd, '.git'));
+    if (!marker.isDirectory() || marker.isSymbolicLink()) throw new Error('Canonical Git controls require a direct local .git directory; linked metadata and submodules are unavailable.');
+    var status = git.getStatus(ctx.cwd, scope.identity);
+    if (!status.isRepository || fs.realpathSync(status.root) !== fs.realpathSync(ctx.cwd)) throw new Error('Select the exact registered repository root, rather than a repository subdirectory.');
+    if (fs.realpathSync(status.gitDir) !== fs.realpathSync(path.join(ctx.cwd, '.git'))) throw new Error('The Git metadata directory escaped the selected project.');
+    return status;
+  }
+  function gitProjection(status) { return { isRepository: true, branch: status.branch, oid: status.oid, upstream: status.upstream, ahead: status.ahead, behind: status.behind, detached: status.detached, files: status.files.slice(0, 200), truncated: status.files.length > 200, dirty: status.dirty }; }
+  function terminal(scope, id) {
+    var item = ctx.tm.inspect(id);
+    var identity = scope.identity ? JSON.stringify([scope.identity.user, scope.identity.uid, scope.identity.gid, scope.identity.home]) : null;
+    if (!item || item.kind !== 'shell' || item.ownerId !== scope.ownerId || item.osIdentity !== identity) throw new Error('Select an exact same-owner shell terminal. Coding-agent, login and foreign terminals are excluded.');
+    return item;
+  }
+  function read(principal, op) {
+    var scope = authorize(principal, op.domain), before = rootIdentity(principal, op.domain), result;
+    if (op.domain === 'files') {
+      bounded(op.path || '.');
+      if (op.action === 'list') { var entries = ctx.files().list(scope, op.path || '.'); result = { entries: entries.slice(0, 200), truncated: entries.length > 200 }; }
+      else { result = ctx.files().read(scope, op.path); if (result.content && result.content.length > 65536) result = { error: 'Canonical text reads are limited to 64 KB.', size: result.size }; }
+    } else if (op.domain === 'git') {
+      var status = repository(scope);
+      if (op.action === 'status') result = gitProjection(status);
+      else { var working = bounded(op.path, true); if (fs.existsSync(working)) ctx.files().read(scope, op.path); result = git.getFileDiff(ctx.cwd, op.path, scope.identity); if ((result.oldContent.length + result.newContent.length) > 65536) throw new Error('Canonical diff reads are limited to 64 KB.'); }
+    } else if (op.action === 'list') result = { terminals: ctx.tm.list().filter(function (item) { try { terminal(scope, item.id); return true; } catch (error) { return false; } }).map(function (item) { return ctx.tm.inspect(item.id); }) };
+    else { var item = terminal(scope, op.id); result = Object.assign({}, item, ctx.tm.getScrollback(item.id)); }
+    if (rootIdentity(principal, op.domain) !== before) throw new Error('Project or OS identity changed during the read.');
+    return result;
+  }
+  function snapshot(principal, op) {
+    var scope = authorize(principal, op.domain);
+    if (op.domain === 'files') { bounded(op.path); return ctx.files().snapshot(scope, op.path); }
+    if (op.domain === 'git') {
+      var status = repository(scope);
+      if (!op.paths.length || !op.paths.every(function (name) { return status.files.some(function (item) { return item.path === name; }); })) throw new Error('Select exact currently changed Git paths.');
+      var entries = op.paths.map(function (name) {
+        var working = bounded(name, true);
+        if (fs.existsSync(working) && !fs.lstatSync(working).isFile()) throw new Error('Canonical staging requires individual regular file paths; recursive directory staging is unavailable.');
+        if (fs.existsSync(working)) ctx.files().read(scope, name);
+        var item = status.files.find(function (file) { return file.path === name; });
+        if (item.originalPath) bounded(item.originalPath, true);
+        var diff = git.getFileDiff(ctx.cwd, name, scope.identity);
+        if (diff.binary) throw new Error('Canonical staging of binary files is unavailable.');
+        return digest(diff);
+      });
+      var index = path.join(status.gitDir, 'index');
+      return { status: gitProjection(status), gitDirectory: [fs.realpathSync(status.gitDir), inode(status.gitDir)], index: fs.existsSync(index) ? digest(fs.readFileSync(index)) : null, files: entries,
+        configuration: digest(git.runGitSync(ctx.cwd, ['config', '--null', '--list', '--show-origin'], null, scope.identity)),
+        attributes: digest(git.runGitSync(ctx.cwd, ['check-attr', '-z', '--all', '--'].concat(op.paths), null, scope.identity)) };
+    }
+    return op.action === 'create' ? ctx.tm.list().map(function (item) { return ctx.tm.inspect(item.id); }) : terminal(scope, op.id);
+  }
+  async function apply(principal, op, expected, revalidate) {
+    if (busy) throw new Error('Another project file, Git or terminal change is applying. Inspect again after it settles.');
+    busy = true;
+    var attempted = false, result;
+    try {
+      var scope = authorize(principal, op.domain);
+      revalidate();
+      if (digest(snapshot(principal, op)) !== digest(expected)) throw new Error('The exact product revision changed.');
+      if (op.domain === 'files') return ctx.files().write(scope, op.path, op.content, { expected: expected, revalidate: function () { revalidate(); bounded(op.path); } });
+      attempted = true;
+      if (op.domain === 'git') {
+        await git.runAction(ctx.cwd, { action: op.action, paths: op.paths }, scope.identity);
+        result = { status: 'completed', runtimeEffect: 'index_updated', persisted: true };
+      } else if (op.action === 'create') {
+        var created = ctx.tm.create(op.cols, op.rows, scope.identity, null, { kind: 'shell', ownerId: scope.ownerId });
+        if (!created) throw new Error('The terminal transport is unavailable or its limit was reached.');
+        result = { status: 'completed', runtimeEffect: 'shell_created', terminalId: created.id, terminalIdentity: created.identity, commandSent: false, persisted: false };
+      } else if (op.action === 'rename') {
+        ctx.tm.rename(op.id, op.title); result = { status: 'completed', runtimeEffect: 'renamed', terminalId: op.id, terminalIdentity: expected.identity, persisted: false };
+      } else if (op.action === 'resize') {
+        ctx.tm.resizeExact(op.id, op.cols, op.rows, expected.identity, revalidate);
+        result = { status: 'completed', runtimeEffect: 'resized', terminalId: op.id, terminalIdentity: expected.identity, persisted: false };
+      } else {
+        await ctx.tm.closeAndWait(op.id, { identity: expected.identity, revalidate: function () { revalidate(); var live = terminal(authorize(principal, 'terminal'), op.id); if (live.identity !== expected.identity) throw new Error('Terminal identity changed during closure.'); } });
+        result = { status: 'completed', runtimeEffect: 'closed', terminalId: op.id, terminalIdentity: expected.identity, exitAcknowledged: true, persisted: false };
+      }
+      revalidate();
+      if (op.domain === 'terminal') ctx.publishTerminals();
+      return result;
+    } catch (error) {
+      error.productControlResult = Object.assign({ persisted: attempted ? 'unknown' : false, runtimeEffect: attempted ? 'unknown' : 'none', retrySafe: false }, result, error.productControlResult || {}, { status: 'failed', error: error.message });
+      throw error;
+    } finally { busy = false; }
+  }
+  return { rootIdentity: rootIdentity, read: read, snapshot: snapshot, apply: apply };
+}
+module.exports = { attachWorkspaceOperations: attachWorkspaceOperations };

package/lib/project-workspace-query.js

@@ -1,4 +1,5 @@
 var workspaceMcp = require("./workspace-query-mcp-server");
+var productTools = require("./clay-product-control-tools");
 var clayHistoryMcp = require("./clay-history-mcp-server");
 
 function attachProjectWorkspaceQuery(ctx) {
@@ -25,7 +26,12 @@ function attachProjectWorkspaceQuery(ctx) {
   function getToolDefs(session) {
     var bound = session ? binding(session) : null;
     if (session && !bound) return [];
-    return workspaceMcp.getToolDefs(bound, !!(bound && bound.isClay));
+    var tools = workspaceMcp.getToolDefs(bound, !!(bound && bound.isClay));
+    if (bound && bound.isClay && ctx.controlService) {
+      var controls = ctx.controlService.bind({ projectSlug: projectSlug, projectOwnerId: getProjectOwnerId(), isMate: true, mateId: mateId, session: session });
+      if (controls) tools = tools.concat(productTools.getToolDefs(controls));
+    }
+    return tools;
   }
 
   function createMcpServer(adapter, session) {
@@ -34,7 +40,8 @@ function attachProjectWorkspaceQuery(ctx) {
     if (session && !bound) return null;
     var projectBound = binding(null);
     if (!projectBound) return null;
-    return workspaceMcp.createMcpServer(adapter, bound, projectBound.isClay);
+    if (!adapter || typeof adapter.createToolServer !== "function") return null;
+    return adapter.createToolServer({ name: "clay-workspace", version: "2.0.0", tools: session ? getToolDefs(session) : workspaceMcp.getToolDefs(null, projectBound.isClay) });
   }
 
   function createHistoryMcpServer(adapter, session) {