clay-server 3.8.1 → 4.0.0-beta.2

package/lib/server-tools.js

@@ -0,0 +1,377 @@
+var toolsRegistry = require("./tools-registry");
+var toolStorage = require("./tool-storage");
+var crypto = require("crypto");
+var toolLlm = require("./tool-llm");
+
+function attachTools(deps) {
+  var users = deps.users;
+  var projects = deps.projects;
+  var serverLogic = Object.create(null);
+  var controlTimeoutMs = deps.controlTimeoutMs || 15000;
+  var llmControlTimeoutMs = deps.llmControlTimeoutMs || 90000;
+  var pendingControl = Object.create(null);
+
+  function contextFor(userId) {
+    var multiUser = users.isMultiUser();
+    var linuxUser = null;
+    if (multiUser) {
+      var user = users.findUserById(userId);
+      if (user && user.linuxUser) linuxUser = user.linuxUser;
+    }
+    return { userId: userId, multiUser: multiUser, linuxUser: linuxUser };
+  }
+
+  function send(ws, payload) {
+    if (ws.readyState !== undefined && ws.readyState !== 1) return;
+    ws.send(JSON.stringify(payload));
+  }
+
+  function broadcastToUser(userId, payload) {
+    var sent = new Set();
+    projects.forEach(function (projectContext) {
+      projectContext.forEachClient(function (otherWs) {
+        if (sent.has(otherWs)) return;
+        if (users.isMultiUser() && (!otherWs._clayUser || otherWs._clayUser.id !== userId)) return;
+        sent.add(otherWs);
+        send(otherWs, payload);
+      });
+    });
+  }
+
+  function sendError(ws, msg, error) {
+    send(ws, {
+      type: "tools_error",
+      requestType: msg.type,
+      toolId: msg.toolId || (msg.manifest && msg.manifest.id) || null,
+      seq: msg.seq,
+      requestId: msg.requestId,
+      message: error && error.message ? error.message : "Tool operation failed.",
+    });
+  }
+
+  function run(ws, msg, operation) {
+    Promise.resolve().then(operation).catch(function (error) { sendError(ws, msg, error); });
+  }
+
+  function fullToolList(ctx) {
+    var manifests = toolsRegistry.listTools(ctx);
+    var tools = [];
+    for (var i = 0; i < manifests.length; i++) {
+      if (manifests[i].error) {
+        tools.push(manifests[i]);
+        continue;
+      }
+      var tool = toolsRegistry.getTool(ctx, manifests[i].id);
+      if (tool) tools.push(tool);
+    }
+    return tools;
+  }
+
+  function installedManifests(userId) {
+    var ctx = contextFor(userId);
+    return toolsRegistry.listTools(ctx).filter(function (manifest) { return !manifest.error; });
+  }
+
+  function refreshMateCatalogs(userId) {
+    projects.forEach(function (projectContext) {
+      try {
+        if (!projectContext || typeof projectContext.getStatus !== "function" || typeof projectContext.refreshCapsuleCatalog !== "function") return;
+        var status = projectContext.getStatus();
+        if (!status || status.isMate !== true) return;
+        if (users.isMultiUser() && status.projectOwnerId !== userId) return;
+        projectContext.refreshCapsuleCatalog();
+      } catch (error) {
+        console.error("[tools] Could not refresh a Mate Capsule catalog:", error && error.message ? error.message : error);
+      }
+    });
+  }
+
+  function socketUserId(ws) {
+    if (!users.isMultiUser()) return "default";
+    return ws._clayUser ? ws._clayUser.id : null;
+  }
+
+  function latestHomeSocket(userId) {
+    var found = null;
+    var foundAt = -1;
+    var seen = new Set();
+    projects.forEach(function (projectContext) {
+      projectContext.forEachClient(function (ws) {
+        if (seen.has(ws) || socketUserId(ws) !== userId || !ws._homeChatTap) return;
+        seen.add(ws);
+        if (ws.readyState !== undefined && ws.readyState !== 1) return;
+        var openedAt = ws._homeChatTap.openedAt || 0;
+        if (!found || openedAt >= foundAt) {
+          found = ws;
+          foundAt = openedAt;
+        }
+      });
+    });
+    return found;
+  }
+
+  function requestBrowserControl(userId, mateId, toolId, kind, payload, timeoutMs) {
+    var ws = latestHomeSocket(userId);
+    if (!ws) return Promise.reject(new Error("The user's home screen is not open."));
+    var requestId = "toolctl_" + crypto.randomUUID();
+    return new Promise(function (resolve, reject) {
+      var timer = setTimeout(function () {
+        delete pendingControl[requestId];
+        reject(new Error("The tool control request timed out because the home screen did not respond."));
+      }, timeoutMs || controlTimeoutMs);
+      pendingControl[requestId] = {
+        ws: ws,
+        userId: userId,
+        resolve: resolve,
+        reject: reject,
+        timer: timer,
+      };
+      send(ws, {
+        type: "tool_control_request",
+        requestId: requestId,
+        toolId: toolId,
+        kind: kind,
+        payload: payload || {},
+        callerId: mateId,
+      });
+    });
+  }
+
+  function controlForMate(userId, mateId, toolId, kind, payload) {
+    payload = payload || {};
+    var ctx = contextFor(userId);
+    toolsRegistry.listTools(ctx);
+    var installed = toolsRegistry.getTool(ctx, toolId);
+    if (!installed) return Promise.reject(new Error("Tool is not installed."));
+    if (installed.manifest.runtime === "server") {
+      var adapter = serverLogic[toolId];
+      if (!adapter) return Promise.reject(new Error("No trusted server runtime is registered for this capsule."));
+      var context = { userId: userId, callerId: mateId };
+      if (kind === "snapshot") return Promise.resolve(adapter.snapshot(context));
+      if (kind === "act") return Promise.resolve(adapter.act(context, payload.actionId, payload.args || {}));
+      if (kind === "set" && adapter.set) return Promise.resolve(adapter.set(context, payload.controlId, payload.value));
+      return Promise.reject(new Error("The server-runtime capsule does not support '" + kind + "'."));
+    }
+    var permissions = installed.manifest.permissions || [];
+    var timeoutMs = kind === "act" && permissions.indexOf("llm") !== -1 ? llmControlTimeoutMs : controlTimeoutMs;
+    return requestBrowserControl(userId, mateId, toolId, kind, payload || {}, timeoutMs);
+  }
+
+  function handleControlResponse(ws, msg, userId) {
+    var pending = pendingControl[msg.requestId];
+    if (!pending || pending.ws !== ws || pending.userId !== userId) return;
+    clearTimeout(pending.timer);
+    delete pendingControl[msg.requestId];
+    if (msg.error) pending.reject(new Error(msg.error));
+    else pending.resolve(msg.data || {});
+  }
+
+  function storageOperation(ctx, msg) {
+    if (!toolsRegistry.getTool(ctx, msg.toolId)) throw new Error("Tool is not installed.");
+    var storage = toolStorage.createToolStorage(ctx, msg.toolId);
+    var args = msg.args || {};
+    if (msg.op === "list") return storage.list();
+    if (msg.op === "get") return storage.get(args.id);
+    if (msg.op === "put") return storage.put(args.doc);
+    if (msg.op === "delete") return storage.delete(args.id);
+    if (msg.op === "query") return storage.query(args.query || {});
+    throw new Error("Unknown storage operation '" + msg.op + "'.");
+  }
+
+  function projectForSocket(ws) {
+    var found = null;
+    projects.forEach(function (projectContext) {
+      if (!found && projectContext.clients && projectContext.clients.has(ws)) found = projectContext;
+    });
+    return found;
+  }
+
+  async function llmOperation(ws, ctx, userId, msg) {
+    var tool = toolsRegistry.getTool(ctx, msg.toolId);
+    if (!tool) throw new Error("Tool is not installed.");
+    var permissions = tool.manifest.permissions || [];
+    if (permissions.indexOf("llm") === -1) throw new Error("This capsule does not have the llm permission.");
+    var args = toolLlm.validateArgs(msg.args);
+    var projectContext = projectForSocket(ws);
+    if (!projectContext || typeof projectContext.completeToolLlm !== "function") throw new Error("No project LLM runtime is available.");
+    console.debug("[tool-llm] toolId=" + msg.toolId + " callerId=" + (msg.callerId || "user"));
+    return projectContext.completeToolLlm(ws, args);
+  }
+
+  async function llmConfiguration(ws, alias) {
+    var projectContext = projectForSocket(ws);
+    if (!projectContext || typeof projectContext.getToolLlmConfig !== "function") {
+      return { status: "error", vendor: "", vendorName: "", model: "", modelName: "", error: "No project model configuration is available." };
+    }
+    try {
+      return await projectContext.getToolLlmConfig(ws, alias);
+    } catch (error) {
+      return { status: "error", vendor: "", vendorName: "", model: "", modelName: "", error: error && error.message ? error.message : "Could not load the model configuration." };
+    }
+  }
+
+  function installForMate(userId, input) {
+    var installed = toolsRegistry.installTool(contextFor(userId), input);
+    refreshMateCatalogs(userId);
+    broadcastToUser(userId, { type: "tool_installed", tool: installed });
+    return installed;
+  }
+
+  function sourceForMate(userId, toolId) {
+    var ctx = contextFor(userId);
+    var installed = toolsRegistry.getTool(ctx, toolId);
+    if (!installed) throw new Error("Tool not found.");
+    if (installed.manifest.runtime !== "worker") throw new Error("Server-managed Capsule source is not available to Mates.");
+    if (!installed.metadata || installed.metadata.mateEditingAllowed !== true) {
+      throw new Error("The user has not allowed Mate source access for this Capsule.");
+    }
+    return toolsRegistry.getToolSource(ctx, toolId);
+  }
+
+  function updateForMate(userId, toolId, input) {
+    var ctx = contextFor(userId);
+    var installed = toolsRegistry.getTool(ctx, toolId);
+    if (!installed) throw new Error("Tool not found.");
+    if (!installed.metadata || installed.metadata.mateEditingAllowed !== true) {
+      throw new Error("The user has not allowed Mate editing for this Capsule.");
+    }
+    var updated = toolsRegistry.updateTool(ctx, toolId, input);
+    refreshMateCatalogs(userId);
+    broadcastToUser(userId, { type: "tool_installed", tool: updated });
+    var source = toolsRegistry.getToolSource(ctx, toolId);
+    return Object.assign({}, updated, { revision: source.revision });
+  }
+
+  function setMateAccess(userId, toolId, allowed, requestId) {
+    var ctx = contextFor(userId);
+    var tool = toolsRegistry.getTool(ctx, toolId);
+    if (!tool) throw new Error("Tool not found.");
+    if (tool.manifest.runtime !== "worker" && allowed === true) {
+      throw new Error("Server-managed Capsules cannot be edited by Mates.");
+    }
+    var metadata = toolsRegistry.setMateEditingAllowed(ctx, toolId, allowed);
+    broadcastToUser(userId, { type: "tool_mate_access_state", toolId: toolId, requestId: requestId || null, ok: true, metadata: metadata });
+    return metadata;
+  }
+
+  function removeForMate(userId, toolId) {
+    var removed = toolsRegistry.removeTool(contextFor(userId), toolId);
+    if (!removed) throw new Error("Tool not found.");
+    refreshMateCatalogs(userId);
+    broadcastToUser(userId, { type: "tool_removed", toolId: toolId });
+    return { removed: true, toolId: toolId };
+  }
+
+  function handleMessage(ws, msg) {
+    var messageTypes = ["tools_list", "tool_get", "tool_install", "tool_remove", "tool_storage_op", "tool_llm_op", "tool_llm_config_get", "tool_control_response", "tool_source_get", "tool_mate_access_set"];
+    if (!msg || messageTypes.indexOf(msg.type) === -1) return false;
+    var userId;
+    if (users.isMultiUser()) {
+      if (!ws._clayUser) return false;
+      userId = ws._clayUser.id;
+    } else {
+      userId = "default";
+    }
+    var ctx = contextFor(userId);
+
+    if (msg.type === "tool_control_response") {
+      handleControlResponse(ws, msg, userId);
+      return true;
+    }
+
+    if (msg.type === "tools_list") {
+      run(ws, msg, function () {
+        send(ws, { type: "tools_state", tools: fullToolList(ctx) });
+      });
+      return true;
+    }
+    if (msg.type === "tool_get") {
+      run(ws, msg, function () {
+        var tool = toolsRegistry.getTool(ctx, msg.toolId);
+        if (!tool) throw new Error("Tool not found.");
+        send(ws, { type: "tools_state", tools: [tool], requestedToolId: msg.toolId });
+      });
+      return true;
+    }
+    if (msg.type === "tool_source_get") {
+      Promise.resolve().then(function () {
+        return toolsRegistry.getToolSource(ctx, msg.toolId);
+      }).then(function (source) {
+        send(ws, Object.assign({ type: "tool_source_state", toolId: msg.toolId, requestId: msg.requestId, ok: true }, source));
+      }).catch(function (error) {
+        send(ws, { type: "tool_source_state", toolId: msg.toolId, requestId: msg.requestId, ok: false, error: error && error.message ? error.message : "Could not read Capsule source." });
+      });
+      return true;
+    }
+    if (msg.type === "tool_mate_access_set") {
+      Promise.resolve().then(function () {
+        if (typeof msg.allowed !== "boolean") throw new Error("Mate editing permission must be true or false.");
+        return setMateAccess(userId, msg.toolId, msg.allowed, msg.requestId);
+      }).catch(function (error) {
+        send(ws, { type: "tool_mate_access_state", toolId: msg.toolId, requestId: msg.requestId, ok: false, error: error && error.message ? error.message : "Could not update Mate editing permission." });
+      });
+      return true;
+    }
+    if (msg.type === "tool_install") {
+      run(ws, msg, function () {
+        installForMate(userId, {
+          manifest: msg.manifest,
+          logicSource: msg.logicSource,
+          uiTree: msg.uiTree,
+        });
+      });
+      return true;
+    }
+    if (msg.type === "tool_remove") {
+      run(ws, msg, function () {
+        removeForMate(userId, msg.toolId);
+      });
+      return true;
+    }
+    if (msg.type === "tool_storage_op") {
+      Promise.resolve().then(function () {
+        return storageOperation(ctx, msg);
+      }).then(function (data) {
+        send(ws, { type: "tool_storage_result", toolId: msg.toolId, op: msg.op, seq: msg.seq, data: data });
+      }).catch(function (error) {
+        send(ws, {
+          type: "tool_storage_result",
+          toolId: msg.toolId,
+          op: msg.op,
+          seq: msg.seq,
+          error: error && error.message ? error.message : "Tool storage operation failed.",
+        });
+      });
+      return true;
+    }
+    if (msg.type === "tool_llm_op") {
+      run(ws, msg, async function () {
+        var data = await llmOperation(ws, ctx, userId, msg);
+        send(ws, { type: "tool_llm_result", toolId: msg.toolId, requestId: msg.requestId, data: data });
+      });
+      return true;
+    }
+    if (msg.type === "tool_llm_config_get") {
+      run(ws, msg, async function () {
+        var alias = toolLlm.MODEL_ALIASES.indexOf(msg.alias) !== -1 ? msg.alias : "standard";
+        var state = await llmConfiguration(ws, alias);
+        send(ws, Object.assign({ type: "tool_llm_config_state", requestId: msg.requestId || null, alias: alias }, state));
+      });
+      return true;
+    }
+    return false;
+  }
+
+  return {
+    handleMessage: handleMessage,
+    installedManifests: installedManifests,
+    controlForMate: controlForMate,
+    installForMate: installForMate,
+    sourceForMate: sourceForMate,
+    updateForMate: updateForMate,
+    setMateAccess: setMateAccess,
+    removeForMate: removeForMate,
+  };
+}
+
+module.exports = { attachTools: attachTools };

package/lib/server.js

@@ -13,10 +13,16 @@ var serverSkills = require("./server-skills");
 var claudeHookInstaller = require("./claude-hook-installer");
 var serverDm = require("./server-dm");
 var serverMates = require("./server-mates");
-var serverClayHome = require("./server-clay-home");
+var serverHomeChat = require("./server-home-chat");
+var shouldSuppressHomeResponse = require("./home-response-notifications").shouldSuppressHomeResponse;
+var serverHomePreferences = require("./server-home-preferences");
+var serverTools = require("./server-tools");
 var serverAdmin = require("./server-admin");
 var serverSettings = require("./server-settings");
 var serverPalette = require("./server-palette");
+var workspaceQueryModule = require("./workspace-query-service");
+var { attachWorkspaceQueryService } = workspaceQueryModule;
+var { attachWorkspaceAssignmentService } = require("./workspace-assignment-service");
 var serverEmail = require("./server-email");
 var serverGlobalWs = require("./server-global-ws");
 var { parseWsRequestUrl } = require("./ws-request");
@@ -291,6 +297,27 @@ function createServer(opts) {
 
   // --- Project registry ---
   var projects = new Map(); // slug → projectContext
+  var assignmentService = attachWorkspaceAssignmentService({
+    storageDir: path.join(CONFIG_DIR, "workspace-assignments"),
+    getProjects: function () { return projects; },
+    isMultiUser: function () { return users.isMultiUser(); },
+    sessionRef: workspaceQueryModule.sessionRef,
+  });
+  var workspaceQueryService = attachWorkspaceQueryService({
+    getProjects: function () { return projects; },
+    isMultiUser: function () { return users.isMultiUser(); },
+    canAccessProject: function (userId, status) {
+      return users.canAccessProject(userId, {
+        ownerId: status && status.projectOwnerId || null,
+        visibility: status && status.visibility || "public",
+        allowedUsers: status && status.allowedUsers || [],
+      });
+    },
+    resolveMate: function (userId, mateId) {
+      return mates.getMate(mates.buildMateCtx(users.isMultiUser() ? userId : null), mateId);
+    },
+    assignmentService: assignmentService,
+  });
 
   // --- Admin module ---
   var admin = serverAdmin.attachAdmin({
@@ -355,7 +382,7 @@ function createServer(opts) {
     // origin. External sites still cannot frame Clay; frame-ancestors below
     // is the modern equivalent for browsers that honor CSP.
     "X-Frame-Options": "SAMEORIGIN",
-    "Content-Security-Policy": "default-src 'self'; frame-ancestors 'self'; script-src 'self' 'unsafe-inline' https://cdn.jsdelivr.net https://esm.sh; style-src 'self' 'unsafe-inline' https://fonts.googleapis.com https://cdn.jsdelivr.net; img-src * data: blob:; connect-src 'self' ws: wss: https://cdn.jsdelivr.net https://esm.sh https://api.open-meteo.com https://ipapi.co; font-src 'self' data: https://fonts.gstatic.com https://cdn.jsdelivr.net;",
+    "Content-Security-Policy": "default-src 'self'; frame-ancestors 'self'; script-src 'self' 'unsafe-inline' https://cdn.jsdelivr.net https://esm.sh; worker-src 'self' blob:; style-src 'self' 'unsafe-inline' https://fonts.googleapis.com https://cdn.jsdelivr.net; img-src * data: blob:; connect-src 'self' ws: wss: https://cdn.jsdelivr.net https://esm.sh https://api.open-meteo.com https://ipapi.co; font-src 'self' data: https://fonts.gstatic.com https://cdn.jsdelivr.net;",
   };
   if (tlsOptions) {
     securityHeaders["Strict-Transport-Security"] = "max-age=31536000; includeSubDomains";
@@ -655,7 +682,7 @@ function createServer(opts) {
     // --- Skills routes (delegated to server-skills) ---
     if (skills.handleRequest(req, res, fullUrl)) return;
 
-    // Root path — redirect to first accessible project
+    // Root path — render home while keeping the last accessible project connected.
     if (fullUrl === "/" && req.method === "GET") {
       if (!isRequestAuthed(req)) {
         res.writeHead(200, { "Content-Type": "text/html; charset=utf-8" });
@@ -665,9 +692,23 @@ function createServer(opts) {
       if (projects.size > 0) {
         var targetSlug = null;
         var reqUser = users.isMultiUser() ? getMultiUserFromReq(req) : null;
+        var homePreference = typeof users.getHomeSurfacePreference === "function"
+          ? users.getHomeSurfacePreference(reqUser ? reqUser.id : "default")
+          : null;
+        var preferredContextSlug = homePreference && homePreference.projectSlug;
+        if (preferredContextSlug && projects.has(preferredContextSlug)) {
+          if (reqUser && onGetProjectAccess) {
+            var preferredAccess = onGetProjectAccess(preferredContextSlug);
+            if (preferredAccess && !preferredAccess.error && users.canAccessProject(reqUser.id, preferredAccess)) {
+              targetSlug = preferredContextSlug;
+            }
+          } else {
+            targetSlug = preferredContextSlug;
+          }
+        }
         // Check for last-visited project cookie
         var lastProject = parseCookies(req)["clay_last_project"];
-        if (lastProject && projects.has(lastProject)) {
+        if (!targetSlug && lastProject && projects.has(lastProject)) {
           if (reqUser && onGetProjectAccess) {
             var lpAccess = onGetProjectAccess(lastProject);
             if (lpAccess && !lpAccess.error && users.canAccessProject(reqUser.id, lpAccess)) {
@@ -692,8 +733,15 @@ function createServer(opts) {
           });
         }
         if (targetSlug) {
-          res.writeHead(302, { "Location": "/p/" + targetSlug + "/" });
-          res.end();
+          try {
+            var homeHtml = fs.readFileSync(path.join(publicDir, "index.html"), "utf8");
+            homeHtml = homeHtml.replace("<body>", '<body data-home-project-slug="' + targetSlug + '">');
+            res.writeHead(200, { "Content-Type": "text/html; charset=utf-8", "Cache-Control": "no-cache" });
+            res.end(homeHtml);
+          } catch (e) {
+            res.writeHead(500, { "Content-Type": "text/plain" });
+            res.end("App shell missing.");
+          }
           return;
         }
       }
@@ -1028,10 +1076,9 @@ function createServer(opts) {
         unreadMap[wsSlug] = 0;
       }
       ctx.handleConnection(ws, wsUser);
-      // Tear down the home-chat subscription (if any) on socket close so
-      // we don't leak callbacks against Clay's session manager.
+      // Tear down the embedded mate chat subscription on socket close.
       ws.on("close", function () {
-        try { clayHomeHandler.handleDisconnection(ws); } catch (e) {}
+        try { homeChatHandler.handleDisconnection(ws); } catch (e) {}
       });
     });
   });
@@ -1119,8 +1166,20 @@ function createServer(opts) {
       projectOwnerId: projectOwnerId || null,
       worktreeMeta: worktreeMeta || null,
       isMate: extra.isMate || false,
+      mateId: extra.mateId || (extra.isMate ? path.basename(cwd) : null),
       mateDisplayName: extra.mateDisplayName || "",
       isHostAgent: !!extra.isHostAgent,
+      createReadyMate: function (ws, userId, definition) {
+        if (!mateHandler || typeof mateHandler.createReadyMateFromInterview !== "function") throw new Error("Mate creation is unavailable.");
+        return mateHandler.createReadyMateFromInterview(ws, userId, definition);
+      },
+      workspaceQueryService: workspaceQueryService,
+      getProjectAccess: function () {
+        return onGetProjectAccess ? onGetProjectAccess(slug) : { visibility: "public", ownerId: projectOwnerId || null };
+      },
+      shouldSuppressResponseNotification: function (session) {
+        return shouldSuppressHomeResponse(projects, slug, session);
+      },
       pushModule: pushModule,
       debug: debug,
       dangerouslySkipPermissions: dangerouslySkipPermissions,
@@ -1143,52 +1202,6 @@ function createServer(opts) {
         });
         return list;
       },
-      getAllProjectSessions: function () {
-        var allSessions = [];
-        projects.forEach(function (pCtx, pSlug) {
-          if (pSlug === slug) return; // skip self
-          var status = pCtx.getStatus();
-          if (status.isWorktree) return;
-          var pSm = pCtx.getSessionManager();
-          if (!pSm) return;
-          var projectTitle = status.title || status.project || pSlug;
-          pSm.sessions.forEach(function (s) {
-            if (!s.hidden && s.history && s.history.length > 0) {
-              s._projectTitle = projectTitle;
-              allSessions.push(s);
-            }
-          });
-        });
-        return allSessions;
-      },
-      // Like getAllProjectSessions but returns the per-project grouped
-      // shape that session-search.searchPalette expects. Includes self
-      // (so the host agent can search its own past Clay conversations).
-      // Used by clay-history-mcp-server.
-      getAllProjectsWithSessions: function () {
-        var out = [];
-        projects.forEach(function (pCtx, pSlug) {
-          var status = pCtx.getStatus();
-          if (status.isWorktree) return;
-          var pSm = pCtx.getSessionManager();
-          if (!pSm) return;
-          var sessions = [];
-          pSm.sessions.forEach(function (s) {
-            if (s.hidden) return;
-            sessions.push(s);
-          });
-          if (sessions.length === 0) return;
-          out.push({
-            projectSlug: pSlug,
-            projectTitle: status.title || status.project || pSlug,
-            projectIcon: status.icon || null,
-            isMate: !!status.isMate,
-            mateId: status.mateId || null,
-            sessions: sessions,
-          });
-        });
-        return out;
-      },
       getHubSchedules: function () {
         var allSchedules = [];
         projects.forEach(function (ctx, s) {
@@ -1277,6 +1290,29 @@ function createServer(opts) {
       onSetProjectDefaultMode: onSetProjectDefaultMode,
       onGetProjectLastVendor: onGetProjectLastVendor,
       onSetProjectLastVendor: onSetProjectLastVendor,
+      listControllableTools: function (userId) {
+        return toolsHandler ? toolsHandler.installedManifests(userId) : [];
+      },
+      controlToolForMate: function (userId, mateId, toolId, kind, payload) {
+        if (!toolsHandler) return Promise.reject(new Error("Tool control is unavailable."));
+        return toolsHandler.controlForMate(userId, mateId, toolId, kind, payload);
+      },
+      installToolForMate: function (userId, input) {
+        if (!toolsHandler) return Promise.reject(new Error("Tool installation is unavailable."));
+        return toolsHandler.installForMate(userId, input);
+      },
+      sourceToolForMate: function (userId, toolId) {
+        if (!toolsHandler) return Promise.reject(new Error("Capsule source access is unavailable."));
+        return toolsHandler.sourceForMate(userId, toolId);
+      },
+      updateToolForMate: function (userId, toolId, input) {
+        if (!toolsHandler) return Promise.reject(new Error("Capsule source updates are unavailable."));
+        return toolsHandler.updateForMate(userId, toolId, input);
+      },
+      removeToolForMate: function (userId, toolId) {
+        if (!toolsHandler) return Promise.reject(new Error("Tool removal is unavailable."));
+        return toolsHandler.removeForMate(userId, toolId);
+      },
       onGetProjectMcpServers: onGetProjectMcpServers,
       onSetProjectMcpServers: onSetProjectMcpServers,
       onGetDaemonConfig: onGetDaemonConfig,
@@ -1295,6 +1331,7 @@ function createServer(opts) {
       isUserOnline: isUserOnline,
     });
     projects.set(slug, ctx);
+    assignmentService.reconcileProject(slug);
     // ctx.warmup() is now deferred to the first websocket connection into
     // this project (see project-connection.js handleConnection). Warming
     // every project at startup spawned a CodexAppServer and an mcp-bridge
@@ -1318,12 +1355,24 @@ function createServer(opts) {
   // --- Email account handler (per-user email account management) ---
   var emailHandler = serverEmail.attachEmail({ users: users });
 
-  // --- Clay home chat handler (host agent chat embedded in home hub) ---
-  var clayHomeHandler = serverClayHome.attachClayHome({
+  // --- Embedded mate chat handler ---
+  var homeChatHandler = serverHomeChat.attachHomeChat({
     users: users,
     mates: mates,
     projects: projects,
     addProject: addProject,
+    workspaceQueryService: workspaceQueryService,
+  });
+
+  var homePreferencesHandler = serverHomePreferences.attachHomePreferences({
+    users: users,
+    projects: projects,
+  });
+
+  // --- User-installed home tools handler ---
+  var toolsHandler = serverTools.attachTools({
+    users: users,
+    projects: projects,
   });
 
   // --- Mate handler ---
@@ -1333,11 +1382,14 @@ function createServer(opts) {
     if (mateHandler) mateHandler.scheduleRegistryRefresh();
   }
 
-  function handleDmMessage(ws, msg) {
+  function handleDmMessage(ws, msg, routedProjectSlug) {
+    if (assignmentService.handleMessage(ws, msg, routedProjectSlug)) return;
     if (dmHandler.handleMessage(ws, msg)) return;
     if (mateHandler && mateHandler.handleMessage(ws, msg)) return;
     if (emailHandler.handleMessage(ws, msg)) return;
-    if (clayHomeHandler.handleMessage(ws, msg)) return;
+    if (homeChatHandler.handleMessage(ws, msg)) return;
+    if (homePreferencesHandler.handleMessage(ws, msg)) return;
+    if (toolsHandler.handleMessage(ws, msg)) return;
   }
 
   function removeProject(slug) {