clay-server 4.1.0-beta.6 → 4.1.0-beta.7

package/lib/project-filesystem.js

@@ -43,11 +43,11 @@ function attachFilesystem(ctx) {
     // Unsubscription must remain available after permission revocation.
     if (/^fs_/.test(msg.type) && msg.type !== "fs_unwatch") {
       if (!access.canUseFiles(ws)) {
-        sendTo(ws, { type: msg.type + "_result", error: "File browser access is not permitted" });
+        sendTo(ws, { type: msg.type + "_result", path: msg.path, requestId: msg.requestId, projectSlug: msg.projectSlug, sessionId: msg.sessionId, accountId: msg.accountId, error: "File browser access is not permitted" });
         return true;
       }
       try { access.osIdentity(ws); } catch (e) {
-        sendTo(ws, { type: msg.type + "_result", error: e.message });
+        sendTo(ws, { type: msg.type + "_result", path: msg.path, requestId: msg.requestId, projectSlug: msg.projectSlug, sessionId: msg.sessionId, accountId: msg.accountId, error: e.message });
         return true;
       }
     }
@@ -152,7 +152,7 @@ function attachFilesystem(ctx) {
         fsFile = safeAbsPath(msg.path);
       }
       if (!fsFile) {
-        sendTo(ws, { type: "fs_read_result", path: msg.path, error: "Access denied" });
+        sendTo(ws, { type: "fs_read_result", path: msg.path, requestId: msg.requestId, projectSlug: msg.projectSlug, sessionId: msg.sessionId, accountId: msg.accountId, error: "Access denied" });
         return true;
       }
       try {
@@ -162,34 +162,34 @@ function attachFilesystem(ctx) {
           // Run stat and read as target OS user
           var statResult = fsAsUser("stat", { file: fsFile }, fsReadUserInfo);
           if (statResult.size > FS_MAX_SIZE) {
-            sendTo(ws, { type: "fs_read_result", path: msg.path, binary: true, size: statResult.size, error: "File too large (" + (statResult.size / 1024 / 1024).toFixed(1) + " MB)" });
+            sendTo(ws, { type: "fs_read_result", path: msg.path, requestId: msg.requestId, projectSlug: msg.projectSlug, sessionId: msg.sessionId, accountId: msg.accountId, binary: true, size: statResult.size, error: "File too large (" + (statResult.size / 1024 / 1024).toFixed(1) + " MB)" });
             return true;
           }
           if (BINARY_EXTS.has(ext)) {
-            var result = { type: "fs_read_result", path: msg.path, binary: true, size: statResult.size };
+            var result = { type: "fs_read_result", path: msg.path, requestId: msg.requestId, projectSlug: msg.projectSlug, sessionId: msg.sessionId, accountId: msg.accountId, binary: true, size: statResult.size };
             if (IMAGE_EXTS.has(ext)) result.imageUrl = "api/file?path=" + encodeURIComponent(msg.path);
             sendTo(ws, result);
             return true;
           }
           var readResult = fsAsUser("read", { file: fsFile, readContent: true }, fsReadUserInfo);
-          sendTo(ws, { type: "fs_read_result", path: msg.path, content: readResult.content, size: statResult.size });
+          sendTo(ws, { type: "fs_read_result", path: msg.path, requestId: msg.requestId, projectSlug: msg.projectSlug, sessionId: msg.sessionId, accountId: msg.accountId, content: readResult.content, size: statResult.size });
         } else {
           var stat = fs.statSync(fsFile);
           if (stat.size > FS_MAX_SIZE) {
-            sendTo(ws, { type: "fs_read_result", path: msg.path, binary: true, size: stat.size, error: "File too large (" + (stat.size / 1024 / 1024).toFixed(1) + " MB)" });
+            sendTo(ws, { type: "fs_read_result", path: msg.path, requestId: msg.requestId, projectSlug: msg.projectSlug, sessionId: msg.sessionId, accountId: msg.accountId, binary: true, size: stat.size, error: "File too large (" + (stat.size / 1024 / 1024).toFixed(1) + " MB)" });
             return true;
           }
           if (BINARY_EXTS.has(ext)) {
-            var result = { type: "fs_read_result", path: msg.path, binary: true, size: stat.size };
+            var result = { type: "fs_read_result", path: msg.path, requestId: msg.requestId, projectSlug: msg.projectSlug, sessionId: msg.sessionId, accountId: msg.accountId, binary: true, size: stat.size };
             if (IMAGE_EXTS.has(ext)) result.imageUrl = "api/file?path=" + encodeURIComponent(msg.path);
             sendTo(ws, result);
             return true;
           }
           var content = fs.readFileSync(fsFile, "utf8");
-          sendTo(ws, { type: "fs_read_result", path: msg.path, content: content, size: stat.size });
+          sendTo(ws, { type: "fs_read_result", path: msg.path, requestId: msg.requestId, projectSlug: msg.projectSlug, sessionId: msg.sessionId, accountId: msg.accountId, content: content, size: stat.size });
         }
       } catch (e) {
-        sendTo(ws, { type: "fs_read_result", path: msg.path, error: e.message });
+        sendTo(ws, { type: "fs_read_result", path: msg.path, requestId: msg.requestId, projectSlug: msg.projectSlug, sessionId: msg.sessionId, accountId: msg.accountId, error: e.message });
       }
       return true;
     }

package/lib/project-issue-launch.js

@@ -0,0 +1,154 @@
+// Creates one visible Driver session for an exact Issue revision.
+
+var yoke = require("./yoke");
+var provenance = require("./session-provenance");
+
+function attachIssueLaunch(ctx) {
+  var requests = new Map();
+  var operations = new Map();
+
+  function osUsersEnabled() {
+    return typeof ctx.osUsers === "function" ? ctx.osUsers() === true : ctx.osUsers === true;
+  }
+
+  function requestFingerprint(args) {
+    return JSON.stringify({ ref: args.ref, expectedRevision: args.expectedRevision });
+  }
+
+  function trimRequests() {
+    if (requests.size <= 200) return;
+    for (var pair of requests) {
+      if (pair[1].settled) { requests.delete(pair[0]); return; }
+    }
+  }
+
+  function record(session, event) {
+    if (ctx.sm && typeof ctx.sm.sendAndRecord === "function") ctx.sm.sendAndRecord(session, event);
+    else {
+      session.history = session.history || [];
+      session.history.push(event);
+      if (ctx.sm && typeof ctx.sm.appendToSessionFile === "function") ctx.sm.appendToSessionFile(session, event);
+    }
+  }
+
+  function sendStatus(session, status) {
+    if (ctx.sm && typeof ctx.sm.sendToSession === "function") ctx.sm.sendToSession(session, { type: "status", status: status });
+  }
+
+  function lastLaunchError(session, fromIndex) {
+    var history = session.history || [];
+    for (var i = history.length - 1; i >= fromIndex; i--) {
+      if (history[i] && history[i].type === "error" && history[i].text) return String(history[i].text);
+    }
+    return "The Driver session could not start its agent runtime.";
+  }
+
+  function failLaunch(session, fromIndex, error) {
+    var message = error && error.message ? error.message : lastLaunchError(session, fromIndex);
+    if (lastLaunchError(session, fromIndex) === "The Driver session could not start its agent runtime.") {
+      record(session, { type: "error", text: "Could not start issue work: " + message, issueRef: session.issueOrigin && session.issueOrigin.ref });
+    }
+    session.isProcessing = false;
+    if (typeof ctx.onProcessingChanged === "function") ctx.onProcessingChanged();
+    sendStatus(session, "idle");
+    var launchError = new Error(message || "The Driver session could not start its agent runtime.");
+    launchError.sessionId = session.localId;
+    return launchError;
+  }
+
+  async function run(ws, actor, actorId, args, bound) {
+    var entry = bound.readIssue({ ref: args.ref });
+    if (entry.revision !== args.expectedRevision) throw new Error("Issue revision conflict. Reload before starting work.");
+    if (entry.status === "resolved" || entry.status === "closed") throw new Error("Reopen this issue before starting work.");
+    if ((entry.linkedWorkSessions || []).length >= 40) throw new Error("This issue has reached its work-session limit.");
+
+    var expectedLinuxUser = typeof ctx.getLinuxUserForSession === "function" ? ctx.getLinuxUserForSession({ ownerId: actorId }) : null;
+    if (osUsersEnabled() && !expectedLinuxUser) throw new Error("An OS identity is required to start work.");
+    var runtime = await ctx.resolveDefaultAi(ws);
+    if (ws.readyState !== 1 || ws._clayUser !== actor || actorId !== (ws._clayUser && ws._clayUser.id || null)) {
+      throw new Error("The requesting connection changed.");
+    }
+    if (typeof ctx.canStartWork === "function" && ctx.canStartWork(ws, actor) !== true) throw new Error("Issue work is no longer allowed from this connection.");
+    entry = bound.readIssue({ ref: args.ref });
+    if (entry.revision !== args.expectedRevision) throw new Error("Issue revision conflict. Reload before starting work.");
+    if (entry.status === "resolved" || entry.status === "closed") throw new Error("Reopen this issue before starting work.");
+    if (!runtime || !runtime.ready || !ctx.sm || (ctx.sm.installedVendors || []).indexOf(runtime.vendor) < 0) {
+      throw new Error(runtime && runtime.error || "Default AI is unavailable.");
+    }
+    if (yoke.sessionTools.capability(runtime.vendor).kind === "none") throw new Error("The selected provider does not support Issues tools.");
+    var liveLinuxUser = typeof ctx.getLinuxUserForSession === "function" ? ctx.getLinuxUserForSession({ ownerId: actorId }) : null;
+    if (osUsersEnabled() && liveLinuxUser !== expectedLinuxUser) throw new Error("The OS identity changed while issue work was being prepared.");
+
+    var session = ctx.sm.createSessionRaw({ vendor: runtime.vendor, model: runtime.model, effort: runtime.effort || null,
+      mode: "gui", ownerId: actor && actor.id || null, sessionVisibility: "private" });
+    provenance.ensureOrigin(session);
+    if (session.hidden === true || session.delegated === true || provenance.isWorker(session)) {
+      ctx.sm.deleteSession(session.localId);
+      throw new Error("A visible Driver session is required to start issue work.");
+    }
+    var linuxUser = typeof ctx.ensureProjectAccessForSession === "function"
+      ? ctx.ensureProjectAccessForSession(session) : expectedLinuxUser;
+    if (osUsersEnabled() && (!linuxUser || linuxUser !== expectedLinuxUser)) {
+      ctx.sm.deleteSession(session.localId);
+      throw new Error("The OS identity changed before issue work could start.");
+    }
+    session.issueOrigin = { ref: entry.ref, revision: args.expectedRevision, requestId: args.requestId, sessionOriginId: session.sessionOriginId };
+    try { bound.linkWorkSession(args, session); }
+    catch (error) { ctx.sm.deleteSession(session.localId); throw error; }
+
+    session.title = "Issue · " + entry.title;
+    session.titleManuallySet = true;
+    ctx.sm.saveSessionFile(session);
+    var prompt = "Work on project issue " + entry.ref + ". Read it with read_issue, inspect the repository, implement the requested outcome and verify it. Update this same issue as work progresses. Do not commit, publish, or create a PR unless explicitly authorized. If implementation is verified but no commit is authorized, keep it in_progress and record that state. Resolve only with verified commit evidence. Session completion never resolves the issue automatically.\n\nRequested issue:\n" + JSON.stringify({ title: entry.title, summary: entry.summary, body: entry.body });
+    ctx.sm.switchSession(session.localId, ws);
+    ws._clayActiveSession = session.localId;
+    record(session, { type: "user_message", text: prompt, issueRef: entry.ref, issueRevision: args.expectedRevision });
+    session.isProcessing = true;
+    sendStatus(session, "processing");
+    if (typeof ctx.onProcessingChanged === "function") ctx.onProcessingChanged();
+    ctx.sm.broadcastSessionList();
+    var historyStart = (session.history || []).length;
+    var sdk = ctx.getSdk && ctx.getSdk();
+    if (!sdk || typeof sdk.startQuery !== "function") throw failLaunch(session, historyStart, new Error("The SDK bridge is not ready."));
+    try { await sdk.startQuery(session, prompt, undefined, linuxUser); }
+    catch (error) { throw failLaunch(session, historyStart, error); }
+    if (ctx.sm.sessions.get(session.localId) !== session || !session.queryInstance) {
+      throw failLaunch(session, historyStart, null);
+    }
+    return { sessionId: session.localId, sessionOriginId: session.sessionOriginId, ref: entry.ref };
+  }
+
+  return function startWork(ws, msg, bound) {
+    var args = Object.assign({}, msg && msg.args || {}, { requestId: msg && msg.requestId });
+    var actor = ws && ws._clayUser || null;
+    var actorId = actor && actor.id || null;
+    if (!msg || typeof msg.requestId !== "string" || !msg.requestId || msg.requestId.length > 200) {
+      return Promise.reject(new Error("A work request identifier is required."));
+    }
+    if (!bound || typeof args.ref !== "string" || !Number.isInteger(args.expectedRevision)) {
+      return Promise.reject(new Error("An exact issue reference and expectedRevision are required."));
+    }
+    var fingerprint = requestFingerprint(args);
+    var requestKey = JSON.stringify([bound.scopeId, actorId, msg.requestId]);
+    var prior = requests.get(requestKey);
+    if (prior) {
+      if (prior.ws !== ws || prior.fingerprint !== fingerprint) return Promise.reject(new Error("Work request identifier was already used with different arguments."));
+      return prior.task;
+    }
+    var operationKey = JSON.stringify([bound.scopeId, actorId, args.ref, args.expectedRevision]);
+    var operation = operations.get(operationKey);
+    var task = operation ? operation.task : run(ws, actor, actorId, args, bound);
+    if (!operation) {
+      operations.set(operationKey, { task: task });
+      task.then(function () { if (operations.get(operationKey).task === task) operations.delete(operationKey); },
+        function () { if (operations.get(operationKey).task === task) operations.delete(operationKey); });
+    }
+    var request = { ws: ws, fingerprint: fingerprint, task: task, settled: false };
+    requests.set(requestKey, request);
+    task.then(function () { request.settled = true; trimRequests(); }, function () { request.settled = true; trimRequests(); });
+    trimRequests();
+    return task;
+  };
+}
+
+module.exports = { attachIssueLaunch: attachIssueLaunch };

package/lib/project-issues.js

@@ -0,0 +1,58 @@
+var mcp = require("./issues-mcp-server");
+var resolveIssueWorkSession = require("./issue-work-session").resolveIssueWorkSession;
+function attachProjectIssues(ctx) {
+  function user(ws) {
+    return !ctx.isMate && ctx.service && ctx.service.bindUser({ projectSlug: ctx.projectSlug, userId: ws._clayUser && ws._clayUser.id });
+  }
+  function notify(entry, type) {
+    for (var ws of ctx.getClients()) {
+      if (!ws || ws.readyState !== 1 || ws._clayPane) continue;
+      try { var bound = user(ws); if (bound) { if (entry.deleted) bound.readIssueTombstone({ ref: entry.ref }); else bound.readIssue({ ref: entry.ref }); ctx.sendTo(ws, Object.assign({ type: type || "issue_updated", projectSlug: ctx.projectSlug, ref: entry.ref, status: entry.status, title: entry.title, revision: entry.revision }, type === "issue_deleted" ? { deleted: true } : {})); } } catch (error) { /* Access may have changed. */ }
+    }
+    return entry;
+  }
+  function sessionBound(session) {
+    var bound = !ctx.isMate && ctx.service && session && ctx.service.bindProjectSession({ projectSlug: ctx.projectSlug, session: session });
+    if (!bound) return null;
+    ["createIssue", "updateIssue", "reviewIssueComment"].forEach(function (method) {
+      var original = bound[method];
+      bound[method] = async function (args) { var result = await original(args); if (method === "reviewIssueComment") return notify(result, "issue_commented"); return notify(result); };
+    });
+    return bound;
+  }
+  function defs(session) { return ctx.isMate || !ctx.service || (session && !sessionBound(session)) ? [] : mcp.getToolDefs(sessionBound(session)); }
+  function handleMessage(ws, msg) {
+    var methods = { issues_list: "listIssues", issue_read: "readIssue", issue_create: "createIssue", issue_update: "updateIssue", issue_history: "issueHistory", issue_revision: "readIssueRevision", issue_comment: "commentIssue", issue_delete: "removeIssue" };
+    if (!methods[msg.type] && msg.type !== "issue_start_work" && msg.type !== "issue_open_work") return false;
+    Promise.resolve().then(async function () {
+      var bound = user(ws);
+      if (!bound) throw new Error("Issues are unavailable for this project.");
+      var result;
+      if (msg.type === "issue_open_work") {
+        var session = resolveIssueWorkSession(bound, msg.args || {});
+        ctx.sm.switchSession(session.localId, ws); ws._clayActiveSession = session.localId;
+        result = { sessionId: session.localId };
+      } else if (msg.type === "issue_start_work") { result = await ctx.startWork(ws, msg, bound); notify(bound.readIssue({ ref: msg.args.ref })); }
+      else {
+        result = await bound[methods[msg.type]](msg.args || {});
+        if (msg.type === "issue_create" || msg.type === "issue_update") notify(result);
+        else if (msg.type === "issue_comment") notify(result, "issue_commented");
+        else if (msg.type === "issue_delete") notify(result, "issue_deleted");
+      }
+      ctx.sendTo(ws, { type: "issues_result", requestId: msg.requestId, action: msg.type, result: result, canDelete: bound.canDelete === true });
+    }).catch(function (error) {
+      var result = error && error.sessionId ? { sessionId: error.sessionId } : undefined;
+      ctx.sendTo(ws, { type: "issues_result", requestId: msg.requestId, action: msg.type, error: error.message, result: result });
+    });
+    return true;
+  }
+  return {
+    handleMessage: handleMessage, notify: notify,
+    getDynamicToolDefs: function (session) { return defs(session).map(function (tool) { tool.permissionName = "mcp__clay-issues__" + tool.name; return tool; }); },
+    createMcpServer: function (adapter, session) { return ctx.isMate || !ctx.service || !adapter.createToolServer ? null : adapter.createToolServer({ name: "clay-issues", version: "1.0.0", tools: defs(session) }); },
+    getBridgeTools: function (session, normalize) { return defs(session).map(function (tool) { return { server: "clay-issues", name: tool.name, description: tool.description, inputSchema: normalize(tool.inputSchema) }; }); },
+    callBridgeTool: function (session, name, args) { var tool = defs(session).find(function (item) { return item.name === name; }); if (!tool || !session) return Promise.reject(new Error("Issue tool unavailable.")); return tool.handler(args); },
+    getSystemPrompt: function (session) { return sessionBound(session) ? "--- Project Issues ---\n" + mcp.CONTRACT : ""; },
+  };
+}
+module.exports = { attachProjectIssues: attachProjectIssues };

package/lib/project-logs-mcp-server.js

@@ -52,21 +52,17 @@ var LEARNING_CONTRACT =
 // history or loses the history when the board is cleared.
 //
 // This is guidance for the Driver, not an automatic mirror: notes are also
-// written by people and by Mates that hold no Logs authority, so nothing here
-// makes creating a note mutate the ledger on its own.
+// written by people and by Mates that hold no Issues or Logs authority, so
+// nothing here makes creating a note mutate either canonical record.
 var ATTENTION_CONTRACT =
   "Sticky Notes and Project Logs are two different layers and must not be confused. " +
   "A Sticky Note is the transient attention layer: an unresolved, actionable commitment or defect that stays on the active board only while it still needs action, and is closed once it no longer does. Closing is reversible and never deletes the note. " +
-  "A Project Log is the durable project-scoped ledger: discovery, evidence, impact, decision, remediation, and outcome stay permanently, versioned, long after the note has been closed. " +
-  "When you discover a concrete defect in this project that will remain unresolved past the current work, and you therefore write a Sticky Note about it, also record it in the ledger. The note is the alert; the log entry is the record. " +
-  "Do both in this order when practical: create or update the log entry first, then write the note and include the entry's opaque log: reference in the note text, so the alert points at the durable record. " +
-  "A log entry may mention that an attention note exists, but must never depend on a note id for its identity, because the note is a transient alert and the ledger must stand on its own. " +
-  "If the ledger already has an entry for this defect, revise that entry instead of creating a second one. " +
-  "Categorise it as defect, security, or incident, or another category this project already uses when one fits better, and set priority separately from category. " +
-  "When the defect is fixed, revise that same entry with the remediation, how it was verified, and the outcome as a new canonical revision, and only then close the Sticky Note. Close it, never delete it: the note leaves the active board and the entry stays permanent. " +
-  "If you find and fully fix a defect inside the current task, do not open a Sticky Note for it at all, and write a log entry only when the discovery itself has durable value for the project. " +
-  "This pairing applies to concrete unresolved defects, not to everything on the board. Never mirror speculation, general cleanup ideas, transient blockers, proposals, or ordinary notes into the ledger. " +
-  "Notes written by people or by other sessions are not yours to mirror; judge only what you discovered yourself.";
+  "Project Issues are the primary record for concrete defects. For a Project Driver session with Issues authority, search, reuse, or create the Issue first, recording observable evidence, affected component, impact, and next action there. Then write only a concise Sticky Note title, one-line actionable cue, and the actual opaque issue: reference; never duplicate the full defect details in the note. " +
+  "If you lack Issues authority, route the defect through an eligible Project Driver. Never invent an issue reference, drop the alert, mirror storage automatically, or expand privileges. " +
+  "Project Logs remain required for concise work continuity, decisions, and results. Reference the issue in the Log instead of duplicating its full defect report. Logs are durable and versioned; the issue keeps the defect lifecycle and the note remains the transient alert. " +
+  "If the Issue already exists, revise that Issue instead of creating a second one. When the defect is fixed, update the Issue with remediation and verification while respecting its real commit-evidence and status rules; only then close a Sticky Note created by this same session. Close it, never delete it. " +
+  "If you find and fully fix a defect inside the current task, do not open a Sticky Note for it at all, and keep the required concise Log only when the work instruction or result belongs in the project record. " +
+  "This Issue-plus-note flow applies to concrete unresolved defects, not to ordinary notes or proposals. Notes written by people or by other sessions are not yours to mirror; judge authority and evidence rather than mutating records automatically.";
 
 var REVIEW_CONTRACT =
   "People cannot edit the ledger, so a comment is a proposal or a piece of evidence and never an automatic change. Judge each one against the project itself. " +

package/lib/project-message-delivery.js

@@ -29,7 +29,7 @@ function ensureRecordedMessages(session) {
   return recorded;
 }
 
-function createProjectMessageDelivery(sendTo) {
+function createProjectMessageDelivery(sendTo, projectSlug) {
   function inspect(ws, session, msg) {
     var clientMessageId = normalizeClientMessageId(msg && msg.clientMessageId);
     if (!clientMessageId) return { clientMessageId: null, ownerId: ownerKey(ws), duplicate: false };
@@ -48,11 +48,13 @@ function createProjectMessageDelivery(sendTo) {
     ensureRecordedMessages(session).set(deliveryKey(receipt.ownerId, receipt.clientMessageId), message);
   }
 
-  function acknowledge(ws, receipt, message) {
+  function acknowledge(ws, receipt, message, session) {
     if (!receipt || !receipt.clientMessageId) return;
     sendTo(ws, {
       type: "message_ack",
       clientMessageId: receipt.clientMessageId,
+      projectSlug: projectSlug || null,
+      sessionId: session ? session.localId : null,
       message: message || receipt.recordedMessage || null,
     });
   }

package/lib/project-models.js

@@ -1,4 +1,5 @@
 var yoke = require("./yoke");
+var defaultAiRuntime = require("./default-ai-runtime");
 
 function modelEntryValue(entry) {
   if (!entry) return "";
@@ -12,6 +13,17 @@ function modelEntryMatches(entry, value) {
   return entry.value === value || entry.id === value || entry.resolvedModel === value;
 }
 
+function modelsWithEffortMetadata(models, vendorInfo) {
+  var fallback = vendorInfo && Array.isArray(vendorInfo.effortLevels) ? vendorInfo.effortLevels : [];
+  return (models || []).map(function (model) {
+    if (typeof model === "string") {
+      return { value: model, displayName: model, supportedEffortLevels: fallback.slice() };
+    }
+    if (!model || Array.isArray(model.supportedEffortLevels)) return model;
+    return Object.assign({}, model, { supportedEffortLevels: fallback.slice() });
+  });
+}
+
 function normalizeCatalogModels(models) {
   var normalized = [];
   models = models || [];
@@ -64,8 +76,12 @@ function attachModels(ctx) {
   var serverPort = ctx.serverPort;
   var serverTls = ctx.serverTls;
   var serverAuthToken = ctx.serverAuthToken;
+  var resolveDefaultAi = ctx.resolveDefaultAi;
 
-  function getVendorAvailability() {
+  function getVendorAvailability(ws) {
+    if (sm.installedVendors === undefined && sdk && typeof sdk.refreshInstalledVendors === "function") {
+      sdk.refreshInstalledVendors(getLinuxUserForWs(ws));
+    }
     var available = (sm.availableVendors || []).slice();
     var installed = (sm.installedVendors || []).slice();
     var ids = available.slice();
@@ -160,8 +176,8 @@ function attachModels(ctx) {
       console.error("[project-models] model loading failed for " + vendor + ":", e.message || e);
     }
 
-    var vendorModels = (sm.modelsByVendor && sm.modelsByVendor[vendor]) || [];
     var vendorInfo = yoke.getVendorInfo(vendor);
+    var vendorModels = modelsWithEffortMetadata((sm.modelsByVendor && sm.modelsByVendor[vendor]) || [], vendorInfo);
     var displayName = vendorInfo ? vendorInfo.displayName : vendor;
     var status = vendorModels.length > 0 ? "ready" : (loadError ? "error" : "empty");
     var defaultModel = "";
@@ -191,11 +207,62 @@ function attachModels(ctx) {
       installedVendors: sm.installedVendors || [],
       status: status,
       error: errorText,
+      effortLevels: vendorInfo && Array.isArray(vendorInfo.effortLevels) ? vendorInfo.effortLevels.slice() : [],
     };
   }
 
   async function resolveConfiguredModel(ws, alias) {
-    var availability = getVendorAvailability();
+    if (typeof resolveDefaultAi === "function") {
+      var defaultSelection = await resolveDefaultAi(ws);
+      var normalizedAlias = alias === "fast" || alias === "deep" ? alias : "standard";
+      if (!defaultSelection || !defaultSelection.ready) {
+        return {
+          status: "error",
+          vendor: defaultSelection && defaultSelection.vendor || "",
+          vendorName: defaultSelection && defaultSelection.vendor || "",
+          model: "",
+          modelName: "",
+          alias: normalizedAlias,
+          effort: "",
+          error: defaultSelection && defaultSelection.error || "Default AI is unavailable.",
+        };
+      }
+      var selectedModel = defaultSelection.model;
+      var selectedName = defaultSelection.model;
+      if (normalizedAlias !== "standard") {
+        var selectedCatalog = await getVendorCatalog(ws, defaultSelection.vendor);
+        var aliasEntry = selectCatalogModel(selectedCatalog.models || [], defaultSelection.model, normalizedAlias);
+        if (!aliasEntry || selectedCatalog.status !== "ready") {
+          return {
+            status: "error",
+            vendor: defaultSelection.vendor,
+            vendorName: defaultSelection.vendor,
+            model: "",
+            modelName: "",
+            alias: normalizedAlias,
+            effort: defaultSelection.effort || "",
+            error: selectedCatalog.error || "The selected Default AI provider has no available model.",
+          };
+        }
+        selectedModel = aliasEntry.value;
+        selectedName = aliasEntry.displayName || selectedModel;
+        var aliasEffort = defaultAiRuntime.resolveEffort({ effort: defaultSelection.effort || "" }, aliasEntry.source, selectedCatalog);
+        if (!aliasEffort.ok) aliasEffort = defaultAiRuntime.resolveEffort(null, aliasEntry.source, selectedCatalog);
+        defaultSelection = Object.assign({}, defaultSelection, { effort: aliasEffort.effort || "" });
+      }
+      var selectedInfo = yoke.getVendorInfo(defaultSelection.vendor);
+      return {
+        status: "ready",
+        vendor: defaultSelection.vendor,
+        vendorName: selectedInfo && selectedInfo.displayName ? selectedInfo.displayName : defaultSelection.vendor,
+        alias: normalizedAlias,
+        model: selectedModel,
+        modelName: selectedName,
+        effort: defaultSelection.effort || "",
+        error: "",
+      };
+    }
+    var availability = getVendorAvailability(ws);
     var candidates = [];
     var preferredVendor = sm.defaultVendor || "";
     if (preferredVendor) candidates.push(preferredVendor);
@@ -341,5 +408,6 @@ module.exports = {
   modelEntryMatches: modelEntryMatches,
   modelEntryValue: modelEntryValue,
   normalizeCatalogModels: normalizeCatalogModels,
+  modelsWithEffortMetadata: modelsWithEffortMetadata,
   selectCatalogModel: selectCatalogModel,
 };