clay-server 3.8.1 → 4.0.0-beta.1

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

@@ -0,0 +1,84 @@
+function hasEntries(value) {
+  return !!(value && Object.keys(value).length > 0);
+}
+
+function unsafeReason(session, isPaired) {
+  if (!session || session.hidden) return "Target session is unavailable.";
+  if (!session.cliSessionId) return "Target session must have a durable session reference.";
+  if (session.sessionVisibility !== "private") return "Target session must be private.";
+  if (session.isProcessing || session._queryStarting || session._awaitingTurnResult) return "Target session must be idle.";
+  if (hasEntries(session.pendingPermissions) || hasEntries(session.pendingAskUser) || hasEntries(session.pendingElicitations) || hasEntries(session.pendingUserDialogs)) return "Target session is waiting for user input.";
+  if ((session.mode && session.mode !== "gui") || (session.runtimeMode && session.runtimeMode !== "gui") || session.terminalId != null || session.runtimeTerminalId != null || session.tuiSuspended) return "Terminal sessions cannot receive project follow-ups.";
+  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.";
+  return "";
+}
+
+function attachDelegatedFollowUp(ctx) {
+  var sm = ctx.sm;
+
+  function inspect(principal, targetSessionRef) {
+    if (!principal || typeof targetSessionRef !== "string" || targetSessionRef.indexOf("session:") !== 0) {
+      throw new Error("A durable opaque targetSessionRef is required.");
+    }
+    var session = null;
+    sm.sessions.forEach(function (candidate) {
+      if (!session && ctx.sessionRef(candidate) === targetSessionRef) session = candidate;
+    });
+    if (!session) throw new Error("Target session was not found in this project.");
+    if (ctx.isMultiUser()) {
+      if (!principal.userId || session.ownerId !== principal.userId) throw new Error("Target session access denied.");
+    } else if (session.ownerId) {
+      throw new Error("Target session access denied.");
+    }
+    var paired = !!(ctx.isPairedSession && ctx.isPairedSession(session));
+    var reason = unsafeReason(session, paired);
+    if (reason) throw new Error(reason);
+    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" };
+  }
+
+  async function dispatch(principal, targetSessionRef, task, metadata, onReady) {
+    var resolved = inspect(principal, targetSessionRef);
+    var session = resolved.session;
+    var sdk = ctx.getSdk();
+    if (!sdk || typeof sdk.pushMessage !== "function" || typeof sdk.startQuery !== "function") {
+      throw new Error("Target project runtime is unavailable.");
+    }
+    if (typeof onReady === "function") onReady(session);
+    sm.sendAndRecord(session, {
+      type: "delegated_follow_up",
+      text: task,
+      assignmentId: metadata.assignmentId,
+      sourceMateId: metadata.sourceMateId,
+      sourceProjectSlug: metadata.sourceProjectSlug,
+      sourceSessionRef: metadata.sourceSessionRef,
+    });
+    session.isProcessing = true;
+    session.lastActivity = Date.now();
+    session.sentToolResults = {};
+    if (ctx.onProcessingChanged) ctx.onProcessingChanged();
+    sm.broadcastSessionList();
+    try {
+      var delivered = sdk.pushMessage(session, task);
+      if (!delivered) await sdk.startQuery(session, task, undefined, ctx.getLinuxUserForSession(session));
+    } catch (error) {
+      session.isProcessing = false;
+      sm.sendAndRecord(session, {
+        type: "error",
+        text: "Delegated follow-up could not start: " + (error.message || String(error)),
+        assignmentId: metadata.assignmentId,
+      });
+      if (ctx.onProcessingChanged) ctx.onProcessingChanged();
+      sm.broadcastSessionList();
+      throw error;
+    }
+    return session;
+  }
+
+  return { inspectDelegatedFollowUp: inspect, dispatchDelegatedFollowUp: dispatch };
+}
+
+module.exports = { attachDelegatedFollowUp: attachDelegatedFollowUp, unsafeReason: unsafeReason };

package/lib/project-delegated-session.js

@@ -0,0 +1,53 @@
+function attachDelegatedSession(ctx) {
+  var sm = ctx.sm;
+
+  async function createDelegatedSession(principal, task, metadata, onCreated) {
+    if (!principal || !task) throw new Error("A bound owner and task are required.");
+    var selection = await ctx.resolveModel(principal);
+    if (!selection || selection.status !== "ready" || !selection.vendor || !selection.model) {
+      throw new Error(selection && selection.error ? selection.error : "No configured model is available in the target project.");
+    }
+    var sdk = ctx.getSdk();
+    if (!sdk || typeof sdk.startQuery !== "function") throw new Error("Target project runtime is unavailable.");
+    var create = typeof sm.createSessionRaw === "function" ? sm.createSessionRaw : sm.createSession;
+    var session = create.call(sm, {
+      ownerId: principal.userId || null,
+      sessionVisibility: "private",
+      vendor: selection.vendor,
+      model: selection.model,
+    });
+    session.title = metadata.title;
+    session.assignment = {
+      assignmentId: metadata.assignmentId,
+      sourceMateId: metadata.sourceMateId,
+      sourceProjectSlug: metadata.sourceProjectSlug,
+      sourceSessionRef: metadata.sourceSessionRef,
+      delegated: true,
+    };
+    session.singleTurn = true;
+    if (typeof onCreated === "function") onCreated(session);
+    sm.sendAndRecord(session, {
+      type: "delegated_work",
+      text: task,
+      assignmentId: metadata.assignmentId,
+      sourceMateId: metadata.sourceMateId,
+      sourceProjectSlug: metadata.sourceProjectSlug,
+      sourceSessionRef: metadata.sourceSessionRef,
+    });
+    session.isProcessing = true;
+    session.lastActivity = Date.now();
+    session.sentToolResults = {};
+    sm.broadcastSessionList();
+    try {
+      await Promise.resolve(sdk.startQuery(session, task, undefined, ctx.getLinuxUserForSession(session)));
+    } catch (error) {
+      session.isProcessing = false;
+      sm.sendAndRecord(session, { type: "error", text: error.message || String(error) });
+    }
+    return session;
+  }
+
+  return { createDelegatedSession: createDelegatedSession };
+}
+
+module.exports = { attachDelegatedSession: attachDelegatedSession };

package/lib/project-filesystem.js

@@ -13,7 +13,7 @@ var execFileSync = require("child_process").execFileSync;
  *   getOsUserInfoForWs (function)
  *   startFileWatch, stopFileWatch, startDirWatch (from _fileWatch)
  *   usersModule, fsAsUser
- *   validateEnvString (function)
+ *   validateEnvString, onEnvironmentChanged (functions)
  *   opts (for onGetProjectEnv, onSetProjectEnv, onGetSharedEnv, onSetSharedEnv callbacks)
  *   IGNORED_DIRS, BINARY_EXTS, IMAGE_EXTS, FS_MAX_SIZE (constants)
  */
@@ -33,6 +33,7 @@ function attachFilesystem(ctx) {
   var usersModule = ctx.usersModule;
   var fsAsUser = ctx.fsAsUser;
   var validateEnvString = ctx.validateEnvString;
+  var onEnvironmentChanged = ctx.onEnvironmentChanged || function () {};
   var opts = ctx.opts;
   var IGNORED_DIRS = ctx.IGNORED_DIRS;
   var BINARY_EXTS = ctx.BINARY_EXTS;
@@ -234,16 +235,11 @@ function attachFilesystem(ctx) {
     // --- Project environment variables ---
     if (msg.type === "get_project_env") {
       var envrc = "";
-      var hasEnvrc = false;
       if (typeof opts.onGetProjectEnv === "function") {
         var envResult = opts.onGetProjectEnv(msg.slug);
         envrc = envResult.envrc || "";
       }
-      try {
-        var envrcPath = path.join(cwd, ".envrc");
-        hasEnvrc = fs.existsSync(envrcPath);
-      } catch (e) {}
-      sendTo(ws, { type: "project_env_result", slug: msg.slug, envrc: envrc, hasEnvrc: hasEnvrc });
+      sendTo(ws, { type: "project_env_result", slug: msg.slug, envrc: envrc });
       return true;
     }
 
@@ -255,7 +251,8 @@ function attachFilesystem(ctx) {
           return true;
         }
         var setResult = opts.onSetProjectEnv(msg.slug, msg.envrc || "");
-        sendTo(ws, { type: "set_project_env_result", ok: setResult.ok, slug: msg.slug, error: setResult.error });
+        if (setResult.ok) onEnvironmentChanged();
+        sendTo(ws, { type: "set_project_env_result", ok: setResult.ok, slug: msg.slug, error: setResult.error, timing: setResult.ok ? "Applies to newly created coding-agent processes. Active processes keep their current environment." : undefined });
       } else {
         sendTo(ws, { type: "set_project_env_result", ok: false, error: "Not supported" });
       }
@@ -308,7 +305,8 @@ function attachFilesystem(ctx) {
           return true;
         }
         var sharedSetResult = opts.onSetSharedEnv(msg.envrc || "");
-        sendTo(ws, { type: "set_shared_env_result", ok: sharedSetResult.ok, error: sharedSetResult.error });
+        if (sharedSetResult.ok) onEnvironmentChanged();
+        sendTo(ws, { type: "set_shared_env_result", ok: sharedSetResult.ok, error: sharedSetResult.error, timing: sharedSetResult.ok ? "Applies to newly created coding-agent processes. Active processes keep their current environment." : undefined });
       } else {
         sendTo(ws, { type: "set_shared_env_result", ok: false, error: "Not supported" });
       }

package/lib/project-knowledge.js

@@ -155,6 +155,7 @@ function attachKnowledge(ctx) {
 
   return {
     handleKnowledgeMessage: handleKnowledgeMessage,
+    listKnowledgeFiles: listKnowledgeFiles,
   };
 }
 

package/lib/project-mate-creation-proposal.js

@@ -0,0 +1,120 @@
+var mateCreationMcp = require("./mate-creation-mcp-server");
+var selectCatalogModel = require("./project-models").selectCatalogModel;
+
+function attachMateCreationProposal(ctx) {
+  var pending = {};
+
+  function clean(value, maxLength) {
+    if (typeof value !== "string") return "";
+    return value.replace(/\u0000/g, "").trim().slice(0, maxLength);
+  }
+
+  function publicProposal(source) {
+    return {
+      proposalId: source.proposalId,
+      name: clean(source.name, 80),
+      bio: clean(source.bio, 280),
+      relationship: clean(source.relationship, 120),
+      activities: Array.isArray(source.activities) ? source.activities.slice(0, 12) : [],
+      communicationStyle: Array.isArray(source.communicationStyle) ? source.communicationStyle.slice(0, 12) : [],
+      autonomy: clean(source.autonomy, 500),
+      identityMarkdown: clean(source.identityMarkdown, 30000),
+    };
+  }
+
+  function record(session, event) {
+    if (typeof ctx.recordSessionEvent === "function") ctx.recordSessionEvent(session, event);
+  }
+
+  function validateBoundSession(session) {
+    var projectOwnerId = typeof ctx.getProjectOwnerId === "function" ? ctx.getProjectOwnerId() : null;
+    var ownerValid = typeof ctx.isMultiUser === "function" && ctx.isMultiUser() ? !!(session && session.ownerId && (!projectOwnerId || session.ownerId === projectOwnerId)) : !!(session && !session.ownerId);
+    return !!(session && ctx.isMate === true && ctx.isHostAgent === true && session.mateCreationMode === true
+      && ownerValid);
+  }
+
+  function hasInterviewAnswer(session) {
+    var history = session && Array.isArray(session.history) ? session.history : [];
+    for (var i = history.length - 1; i >= 0; i--) if (history[i] && history[i].type === "ask_user_answered") return true;
+    return false;
+  }
+
+  function getToolDefs(boundSession) {
+    if (!boundSession || boundSession.mateCreationMode !== true) return [];
+    return mateCreationMcp.getToolDefs(function (definition) {
+      if (!validateBoundSession(boundSession)) return Promise.resolve({ action: "error", error: "Mate proposals require an owned Clay creation interview." });
+      if (!hasInterviewAnswer(boundSession)) return Promise.resolve({ action: "error", error: "Interview the user before proposing a Mate." });
+      return new Promise(function (resolve) {
+        var proposalId = "mp_" + Date.now() + "_" + Math.random().toString(36).slice(2, 8);
+        definition.proposalId = proposalId;
+        pending[proposalId] = { resolve: resolve, definition: definition, session: boundSession };
+        record(boundSession, { type: "mate_creation_proposal", proposal: publicProposal(definition) });
+      });
+    });
+  }
+
+  function createMcpServer(adapter, boundSession) {
+    return adapter.createToolServer({ name: "clay-mate-creation", version: "1.0.0", tools: getToolDefs(boundSession) });
+  }
+
+  function getBridgeTools(boundSession, normalizeSchema) {
+    if (!boundSession) return [];
+    return getToolDefs(boundSession).map(function (tool) {
+      return { server: "clay-mate-creation", name: tool.name, description: tool.description || tool.name, inputSchema: normalizeSchema(tool.inputSchema) };
+    });
+  }
+
+  function callBridgeTool(boundSession, toolName, args) {
+    var tools = getToolDefs(boundSession);
+    for (var i = 0; i < tools.length; i++) if (tools[i].name === toolName) return Promise.resolve(tools[i].handler(args || {}));
+    return Promise.reject(new Error("Session tool not found: clay-mate-creation/" + toolName));
+  }
+
+  function handleHomeMessage(ws, msg, session) {
+    var entry = msg && msg.proposalId ? pending[msg.proposalId] : null;
+    if (!entry || entry.session !== session || !validateBoundSession(session)) return false;
+    delete pending[msg.proposalId];
+    if (msg.action !== "create") {
+      record(session, { type: "mate_creation_proposal_resolved", proposalId: msg.proposalId, action: "cancel" });
+      entry.resolve({ action: "cancel" });
+      return true;
+    }
+    if (typeof ctx.createReadyMate !== "function") {
+      var unavailable = "Mate creation is unavailable.";
+      record(session, { type: "mate_creation_proposal_resolved", proposalId: msg.proposalId, action: "error", error: unavailable });
+      entry.resolve({ action: "error", error: unavailable });
+      return true;
+    }
+    var vendor = session.vendor || "claude";
+    if (typeof ctx.getVendorModelCatalog !== "function") {
+      var catalogUnavailable = "The Mate model catalog is unavailable.";
+      record(session, { type: "mate_creation_proposal_resolved", proposalId: msg.proposalId, action: "error", error: catalogUnavailable });
+      entry.resolve({ action: "error", error: catalogUnavailable });
+      return true;
+    }
+    Promise.resolve(ctx.getVendorModelCatalog(ws, vendor)).then(function (catalog) {
+      var selected = catalog && catalog.status === "ready" ? selectCatalogModel(catalog.models || [], catalog.defaultModel, "deep") : null;
+      if (!selected) throw new Error((catalog && catalog.error) || "No high-capability Mate model is available for " + vendor + ".");
+      return ctx.createReadyMate(ws, session.ownerId || null, Object.assign({}, entry.definition, { vendor: vendor, model: selected.value }));
+    }).then(function (mate) {
+      session.homeMateCreationPhase = "created";
+      record(session, { type: "mate_creation_proposal_resolved", proposalId: msg.proposalId, action: "create", mateId: mate.id, mateName: (mate.profile && mate.profile.displayName) || mate.name || "Mate" });
+      entry.resolve({ action: "create", mateId: mate.id });
+    }).catch(function (error) {
+      var text = error && error.message ? error.message : "The Mate could not be created.";
+      record(session, { type: "mate_creation_proposal_resolved", proposalId: msg.proposalId, action: "error", error: text });
+      entry.resolve({ action: "error", error: text });
+    });
+    return true;
+  }
+
+  return {
+    createMcpServer: createMcpServer,
+    getToolDefs: getToolDefs,
+    getBridgeTools: getBridgeTools,
+    callBridgeTool: callBridgeTool,
+    handleHomeMessage: handleHomeMessage,
+  };
+}
+
+module.exports = { attachMateCreationProposal: attachMateCreationProposal };

package/lib/project-memory.js

@@ -8,7 +8,8 @@ function attachMemory(ctx) {
   var sendTo = ctx.sendTo;
   var matesModule = ctx.matesModule;
   var sessionSearch = ctx.sessionSearch;
-  var getAllProjectSessions = ctx.getAllProjectSessions;
+  var getWorkspaceMemorySessions = ctx.getWorkspaceMemorySessions || function () { return []; };
+  var getOwnedCurrentSessions = ctx.getOwnedCurrentSessions || function () { return []; };
   var projectOwnerId = ctx.projectOwnerId;
   var handleMessage = ctx.handleMessage;
 
@@ -166,7 +167,7 @@ function attachMemory(ctx) {
         var timelineEntries = [];
 
         // Own sessions
-        sm.sessions.forEach(function (s) {
+        getOwnedCurrentSessions().forEach(function (s) {
           if (s.hidden || !s.history || s.history.length === 0) return;
           timelineEntries.push({
             title: s.title || "New Session",
@@ -176,7 +177,7 @@ function attachMemory(ctx) {
         });
 
         // Cross-project sessions
-        var crossForTimeline = getAllProjectSessions();
+        var crossForTimeline = getWorkspaceMemorySessions();
         for (var cti = 0; cti < crossForTimeline.length; cti++) {
           var cs = crossForTimeline[cti];
           timelineEntries.push({
@@ -209,7 +210,7 @@ function attachMemory(ctx) {
       try {
         // Collect mate's own sessions
         var mateSessions = [];
-        sm.sessions.forEach(function (s) {
+        getOwnedCurrentSessions().forEach(function (s) {
           if (!s.hidden && s.history && s.history.length > 0) {
             mateSessions.push(s);
           }
@@ -218,7 +219,7 @@ function attachMemory(ctx) {
         // globalSearch: also collect sessions from all other projects + knowledge files
         var knowledgeFiles = [];
         if (hasGlobalSearch) {
-          var crossSessions = getAllProjectSessions();
+          var crossSessions = getWorkspaceMemorySessions();
           for (var cs = 0; cs < crossSessions.length; cs++) {
             mateSessions.push(crossSessions[cs]);
           }
@@ -595,7 +596,7 @@ function attachMemory(ctx) {
 
   // --- Message handlers for memory management UI ---
 
-  function handleMemoryList(ws) {
+  function readMemoryState() {
     var digestFile = path.join(cwd, "knowledge", "session-digests.jsonl");
     var summaryFile = path.join(cwd, "knowledge", "memory-summary.md");
     var entries = [];
@@ -620,7 +621,12 @@ function attachMemory(ctx) {
     } catch (e) {}
     // Return newest first
     entries.reverse();
-    sendTo(ws, { type: "memory_list", entries: entries, summary: summary });
+    return { entries: entries, summary: summary };
+  }
+
+  function handleMemoryList(ws) {
+    var state = readMemoryState();
+    sendTo(ws, { type: "memory_list", entries: state.entries, summary: state.summary });
   }
 
   function handleMemorySearch(ws, msg) {
@@ -671,6 +677,7 @@ function attachMemory(ctx) {
     gateMemory: gateMemory,
     updateMemorySummary: updateMemorySummary,
     initMemorySummary: initMemorySummary,
+    readMemoryState: readMemoryState,
     handleMemoryList: handleMemoryList,
     handleMemorySearch: handleMemorySearch,
     handleMemoryDelete: handleMemoryDelete,

package/lib/project-models.js

@@ -12,6 +12,46 @@ function modelEntryMatches(entry, value) {
   return entry.value === value || entry.id === value || entry.resolvedModel === value;
 }
 
+function normalizeCatalogModels(models) {
+  var normalized = [];
+  models = models || [];
+  for (var i = 0; i < models.length; i++) {
+    var value = modelEntryValue(models[i]);
+    if (!value) continue;
+    var displayName = typeof models[i] === "string" ? models[i] : (models[i].displayName || models[i].name || value);
+    var searchParts = [value, displayName];
+    if (typeof models[i] === "object") {
+      searchParts.push(models[i].id || "");
+      searchParts.push(models[i].resolvedModel || "");
+    }
+    normalized.push({ value: value, displayName: displayName, search: searchParts.join(" ").toLowerCase(), source: models[i] });
+  }
+  return normalized;
+}
+
+function selectCatalogModel(models, defaultModel, alias) {
+  var entries = normalizeCatalogModels(models);
+  if (entries.length === 0) return null;
+  var configured = null;
+  for (var i = 0; i < entries.length; i++) {
+    if (modelEntryMatches(entries[i].source, defaultModel)) {
+      configured = entries[i];
+      break;
+    }
+  }
+  alias = alias === "fast" || alias === "deep" ? alias : "standard";
+  if (alias === "standard" && configured) return configured;
+  var matcher = alias === "fast"
+    ? /haiku|mini|flash|fast|lite|small|luna/
+    : alias === "deep"
+      ? /opus|\bpro\b|max|deep|large|\bsol\b|reason/
+      : /sonnet|standard|balanced|terra/;
+  for (var mi = 0; mi < entries.length; mi++) {
+    if (matcher.test(entries[mi].search)) return entries[mi];
+  }
+  return configured || entries[0];
+}
+
 function attachModels(ctx) {
   var cwd = ctx.cwd;
   var slug = ctx.slug;
@@ -25,26 +65,36 @@ function attachModels(ctx) {
   var serverTls = ctx.serverTls;
   var serverAuthToken = ctx.serverAuthToken;
 
-  async function loadVendorModels(ws, msg) {
-    var vendor = msg.vendor || "";
-    var requestId = msg.requestId || null;
-    var loadError = null;
-    var vendorAdapter = null;
-    var session = getSessionForWs(ws);
+  function getVendorAvailability() {
+    var available = (sm.availableVendors || []).slice();
+    var installed = (sm.installedVendors || []).slice();
+    var ids = available.slice();
+    for (var i = 0; i < installed.length; i++) {
+      if (ids.indexOf(installed[i]) === -1) ids.push(installed[i]);
+    }
+    return ids.map(function (vendor) {
+      var info = yoke.getVendorInfo(vendor);
+      return {
+        id: vendor,
+        displayName: info && info.displayName ? info.displayName : vendor,
+        installed: installed.indexOf(vendor) !== -1,
+      };
+    });
+  }
 
-    if (!vendor) {
-      sendTo(ws, {
-        type: "model_info",
-        vendor: vendor,
-        requestId: requestId,
-        modelStatus: "error",
-        error: "No vendor was selected.",
-        model: "",
-        models: [],
-        sessionId: session ? session.localId : null,
-      });
-      return;
+  function modelDisplayName(models, value) {
+    for (var i = 0; i < models.length; i++) {
+      if (!modelEntryMatches(models[i], value)) continue;
+      return typeof models[i] === "string" ? models[i] : (models[i].displayName || modelEntryValue(models[i]));
     }
+    return value;
+  }
+
+  async function getVendorCatalog(ws, vendor) {
+    var loadError = null;
+    var loadedDefaultModel = "";
+    var vendorAdapter = null;
+    if (!vendor) return { vendor: "", models: [], capabilities: {}, status: "error", error: "No vendor was selected." };
 
     try {
       var modelLinuxUser = getLinuxUserForWs(ws);
@@ -75,6 +125,7 @@ function attachModels(ctx) {
           });
           sm.capabilitiesByVendor = sm.capabilitiesByVendor || {};
           sm.capabilitiesByVendor[vendor] = readyResult.capabilities || {};
+          loadedDefaultModel = readyResult.defaultModel || "";
           sm.modelsByVendor = sm.modelsByVendor || {};
           if (Array.isArray(readyResult.models) && readyResult.models.length > 0) {
             sm.modelsByVendor[vendor] = readyResult.models;
@@ -110,6 +161,84 @@ function attachModels(ctx) {
     }
 
     var vendorModels = (sm.modelsByVendor && sm.modelsByVendor[vendor]) || [];
+    var vendorInfo = yoke.getVendorInfo(vendor);
+    var displayName = vendorInfo ? vendorInfo.displayName : vendor;
+    var status = vendorModels.length > 0 ? "ready" : (loadError ? "error" : "empty");
+    var defaultModel = "";
+    var preferredModels = [
+      (sm.defaultModelByVendor && sm.defaultModelByVendor[vendor]) || "",
+      loadedDefaultModel,
+    ];
+    for (var preferredIndex = 0; preferredIndex < preferredModels.length && !defaultModel; preferredIndex++) {
+      for (var modelIndex = 0; modelIndex < vendorModels.length; modelIndex++) {
+        if (!modelEntryMatches(vendorModels[modelIndex], preferredModels[preferredIndex])) continue;
+        defaultModel = modelEntryValue(vendorModels[modelIndex]);
+        break;
+      }
+    }
+    var errorText = "";
+    if (status === "error") {
+      errorText = "Could not load " + displayName + " models: " + (loadError.message || loadError);
+    } else if (status === "empty") {
+      errorText = displayName + " returned no models. Check CLI authentication and retry.";
+    }
+    return {
+      vendor: vendor,
+      models: vendorModels,
+      defaultModel: defaultModel,
+      capabilities: (sm.capabilitiesByVendor && sm.capabilitiesByVendor[vendor]) || {},
+      availableVendors: sm.availableVendors || [],
+      installedVendors: sm.installedVendors || [],
+      status: status,
+      error: errorText,
+    };
+  }
+
+  async function resolveConfiguredModel(ws, alias) {
+    var availability = getVendorAvailability();
+    var candidates = [];
+    var preferredVendor = sm.defaultVendor || "";
+    if (preferredVendor) candidates.push(preferredVendor);
+    for (var i = 0; i < availability.length; i++) {
+      if (candidates.indexOf(availability[i].id) === -1) candidates.push(availability[i].id);
+    }
+    var errors = [];
+    for (var ci = 0; ci < candidates.length; ci++) {
+      var catalog = await getVendorCatalog(ws, candidates[ci]);
+      var models = catalog.models || [];
+      var selected = selectCatalogModel(models, catalog.defaultModel, alias);
+      if (catalog.status !== "ready" || !selected) {
+        if (catalog.error) errors.push(catalog.error);
+        continue;
+      }
+      var info = yoke.getVendorInfo(catalog.vendor);
+      return {
+        status: "ready",
+        vendor: catalog.vendor,
+        vendorName: info && info.displayName ? info.displayName : catalog.vendor,
+        alias: alias === "fast" || alias === "deep" ? alias : "standard",
+        model: selected.value,
+        modelName: selected.displayName || modelDisplayName(models, selected.value),
+        error: "",
+      };
+    }
+    return {
+      status: "error",
+      vendor: preferredVendor,
+      vendorName: preferredVendor ? ((yoke.getVendorInfo(preferredVendor) || {}).displayName || preferredVendor) : "",
+      model: "",
+      modelName: "",
+      alias: alias === "fast" || alias === "deep" ? alias : "standard",
+      error: errors[0] || "No configured model is available. Sign in to an installed model provider CLI, then retry.",
+    };
+  }
+
+  async function loadVendorModels(ws, msg) {
+    var vendor = msg.vendor || "";
+    var requestId = msg.requestId || null;
+    var session = getSessionForWs(ws);
+    var catalog = await getVendorCatalog(ws, vendor);
+    var vendorModels = catalog.models;
     var modelToSend = modelEntryValue(vendorModels[0]);
     var preferredModel = (session && session.vendor === vendor && session.model) || (sm.defaultModelByVendor && sm.defaultModelByVendor[vendor]) || "";
     if (preferredModel) {
@@ -120,27 +249,18 @@ function attachModels(ctx) {
         }
       }
     }
-    var vendorInfo = yoke.getVendorInfo(vendor);
-    var displayName = vendorInfo ? vendorInfo.displayName : vendor;
-    var status = vendorModels.length > 0 ? "ready" : (loadError ? "error" : "empty");
-    var errorText = "";
-    if (status === "error") {
-      errorText = "Could not load " + displayName + " models: " + (loadError.message || loadError);
-    } else if (status === "empty") {
-      errorText = displayName + " returned no models. Check CLI authentication and retry.";
-    }
     sendTo(ws, {
       type: "model_info",
       model: modelToSend,
       models: vendorModels,
       vendor: vendor,
       sessionId: session ? session.localId : null,
-      capabilities: (sm.capabilitiesByVendor && sm.capabilitiesByVendor[vendor]) || {},
-      availableVendors: sm.availableVendors || [],
-      installedVendors: sm.installedVendors || [],
+      capabilities: catalog.capabilities,
+      availableVendors: catalog.availableVendors,
+      installedVendors: catalog.installedVendors,
       requestId: requestId,
-      modelStatus: status,
-      error: errorText,
+      modelStatus: catalog.status,
+      error: catalog.error,
     });
   }
 
@@ -208,6 +328,9 @@ function attachModels(ctx) {
 
   return {
     handleMessage: handleMessage,
+    getVendorCatalog: getVendorCatalog,
+    getVendorAvailability: getVendorAvailability,
+    resolveConfiguredModel: resolveConfiguredModel,
     loadVendorModels: loadVendorModels,
     selectModel: selectModel,
   };
@@ -217,4 +340,6 @@ module.exports = {
   attachModels: attachModels,
   modelEntryMatches: modelEntryMatches,
   modelEntryValue: modelEntryValue,
+  normalizeCatalogModels: normalizeCatalogModels,
+  selectCatalogModel: selectCatalogModel,
 };

package/lib/project-session-notes.js

@@ -7,7 +7,7 @@ var MAX_NOTE_PROMPT_CHARS = 800;
 var NOTES_LABEL = "--- Project sticky notes (cross-session work memory; manage via clay-notes tools) ---";
 var NOTES_HINT = "- More notes are available; call list_notes for the rest.";
 var PROACTIVE_POLICY = sessionNotesMcp.MEMORY_CONTRACT + " If an injected preview is relevant or truncated, call list_notes before acting or writing so you do not create a duplicate.";
-var NOTE_COLORS = ["yellow", "blue", "green", "pink", "orange", "purple"];
+var NOTE_COLORS = ["purple", "green", "yellow", "blue", "pink", "orange"];
 
 function toolResult(value) {
   return Promise.resolve({ content: [{ type: "text", text: JSON.stringify(value) }] });
@@ -150,7 +150,7 @@ function attachSessionNotes(ctx) {
     var placement = autoPlacement(notes);
     var created = nm.create({
       text: text,
-      color: color || "yellow",
+      color: color || "purple",
       x: placement.x,
       y: placement.y,
       origin: { sessionId: caller.localId, vendor: caller.vendor || "claude" },