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

package/lib/vendor-usage-service.js

@@ -0,0 +1,281 @@
+// Shared acquisition service for vendor account usage.
+//
+// One place decides whether a direct read is allowed, runs it with a bounded
+// timeout (cancelling the underlying work), shares an in-flight read between
+// callers, caches results and backs off after failures. Provider-specific
+// parsing lives in the reader modules; the capability table says which vendors
+// have a reader at all.
+//
+// Identity: a direct read is allowed only when the credential provably belongs
+// to the requester. In account mode, vendors that run as the server's own user
+// (Muse, Kimi, Grok, Kiro) and Codex without a mapped OS user are refused with a
+// clear status instead of showing the server user's account to every owner.
+// Cache entries are keyed by owner + OS user + vendor. Where a cheap credential
+// fingerprint exists (Kimi, Grok) it is re-read before cached figures are
+// returned (including while a read is in flight) and again when a read
+// completes; rotation or deletion discards the figures. Figures from a source
+// whose account cannot be verified (Muse, Kiro, Claude, Codex) are shown for at
+// most one TTL (60 s) from the reading: after that, in peek and read alike,
+// they are replaced by an explicit "expired" state with no numbers, and a failed
+// refresh never extends them. Verified-identity figures may be kept, marked
+// stale, across a transient failure for at most `staleMaxMs`. A Claude reading
+// is bound to the exact live session and query that produced it and is dropped
+// when that source is replaced. Sign-in failures and account changes always drop
+// figures. A result is used only if the caller is still current when the work
+// starts, while it waits, and when it settles.
+
+var capabilities = require("./vendor-usage-capabilities");
+var metrics = require("./vendor-usage-metrics");
+var nativeReaders = require("./vendor-usage-native-readers");
+var httpReaders = require("./vendor-usage-http-readers");
+var acpReaders = require("./vendor-usage-acp-readers");
+
+var DEFAULTS = { ttlMs: 60 * 1000, minForceMs: 10 * 1000, timeoutMs: 15 * 1000, backoffBaseMs: 30 * 1000, backoffMaxMs: 10 * 60 * 1000, noAuthRetryMs: 5 * 60 * 1000, staleMaxMs: 10 * 60 * 1000 };
+
+// Failures that mean the credential or account is not (or no longer) the one
+// the cached figures described, so those figures must not be shown again.
+var DROPS_FIGURES = ["no_auth", "expired_auth", "unauthorized", "untrusted_origin", "account_changed", "source_changed"];
+
+var MESSAGES = {
+  identity_unprovable: "Clay cannot prove which account this vendor uses for you, so it will not read one.",
+  account_changed: "The saved sign-in changed while usage was being read; figures from the previous account were discarded.",
+  source_changed: "The session that reported this usage was replaced; its figures were discarded.",
+  expired: "The last reading is too old and its account cannot be verified, so it is not shown. Read again.",
+};
+
+function defaultFetchJson(timeoutMs) {
+  return async function (url, headers) {
+    var response = await fetch(url, { headers: headers, signal: AbortSignal.timeout(timeoutMs), redirect: "error" });
+    var body = null;
+    try { body = await response.json(); } catch (e) { body = null; }
+    return { status: response.status, body: body };
+  };
+}
+
+function createUsageService(options) {
+  options = options || {};
+  var now = typeof options.now === "function" ? options.now : Date.now;
+  var timing = Object.assign({}, DEFAULTS, options.timing || {});
+  var fs = require("fs");
+  var os = require("os");
+  var httpDeps = Object.assign({
+    readText: function (file) { return fs.promises.readFile(file, "utf8"); },
+    readTextSync: function (file) { return fs.readFileSync(file, "utf8"); },
+    fetchJson: defaultFetchJson(timing.timeoutMs),
+    env: process.env, homedir: os.homedir,
+  }, options.http || {});
+  httpDeps.now = now;
+  var acpDeps = Object.assign({
+    binary: function () { try { return require("./yoke/kiro-acp-server").findKiroPath(); } catch (e) { return null; } },
+    spawn: function (command, args, spawnOptions) { return require("child_process").spawn(command, args, spawnOptions); },
+    tmpdir: os.tmpdir, env: process.env,
+  }, options.acp || {});
+  var readers = Object.assign({
+    claude: nativeReaders.claude,
+    codex: nativeReaders.codex,
+    muse: nativeReaders.muse,
+    kimi: function () { return httpReaders.kimi(httpDeps); },
+    grok: function () { return httpReaders.grok(httpDeps); },
+    kiro: function (context) { return acpReaders.kiro(context, acpDeps); },
+  }, options.readers || {});
+  var identities = Object.assign({
+    kimi: function () { return httpReaders.identities.kimi(httpDeps); },
+    grok: function () { return httpReaders.identities.grok(httpDeps); },
+  }, options.identities || {});
+  var multiUser = typeof options.multiUser === "function" ? options.multiUser : function () { return false; };
+  var osUsersEnabled = typeof options.osUsersEnabled === "function" ? options.osUsersEnabled : function () { return false; };
+  var sourceLive = typeof options.sourceLive === "function" ? options.sourceLive : function () { return true; };
+  var getAdapter = typeof options.getAdapter === "function" ? options.getAdapter : function () { return null; };
+  var entries = Object.create(null);
+  var generations = Object.create(null);
+
+  function keyOf(owner, linuxUser, vendor) { return owner + "\u0000" + (linuxUser || "") + "\u0000" + vendor; }
+
+  function identityOf(vendor) {
+    try { return identities[vendor] ? identities[vendor]() : null; } catch (e) { return null; }
+  }
+
+  function refusal(vendor, linuxUser, hasSession) {
+    var cap = capabilities.capabilityFor(vendor);
+    if (cap.mode !== "query") return { status: "unintegrated", failureKind: "unintegrated", message: cap.reason || "No usage source is integrated." };
+    if (cap.identity === "owner-session") return hasSession === false ? { status: "idle", failureKind: null, message: null } : null;
+    if (!multiUser()) return null;
+    if (cap.identity === "owner-os-user" && osUsersEnabled() && linuxUser) return null;
+    return { status: "refused", failureKind: "identity_unprovable", message: MESSAGES.identity_unprovable };
+  }
+
+  function blank(status, failureKind, message) {
+    return { status: status, metrics: [], fetchedAtMs: null, stale: false, failureKind: failureKind || null, message: message || null, retryAtMs: null, planType: null, accountId: null, fetching: false };
+  }
+
+  function bindingOf(session) {
+    return session ? { session: session, query: session.queryInstance } : null;
+  }
+
+  function bindingLive(binding) {
+    return !binding || (binding.session.queryInstance === binding.query && sourceLive(binding.session) !== false);
+  }
+
+  function sameBinding(a, b) {
+    return (!a && !b) || (!!a && !!b && a.session === b.session && a.query === b.query);
+  }
+
+  // Figures whose account cannot be verified live only for one TTL; verified
+  // ones may stay (stale) a bounded while. Past that the numbers are removed.
+  function expire(entry) {
+    var a = entry.account;
+    if (!a.metrics.length) return;
+    var age = a.fetchedAtMs === null ? Infinity : now() - a.fetchedAtMs;
+    var limit = entry.identity ? timing.staleMaxMs : timing.ttlMs;
+    if (age < limit) return;
+    entry.account = { status: "idle", metrics: [], fetchedAtMs: null, stale: false, failureKind: "expired", message: MESSAGES.expired, planType: null, accountId: null };
+    entry.identity = null;
+  }
+
+  function snapshotOf(entry) {
+    expire(entry);
+    var a = entry.account;
+    return {
+      status: a.status, metrics: a.metrics.slice(), fetchedAtMs: a.fetchedAtMs, stale: a.stale === true,
+      failureKind: a.failureKind || null, message: a.message || null, retryAtMs: entry.retryAtMs || null,
+      planType: a.planType || null, accountId: a.accountId || null, sourceSessionId: a.sourceSessionId === undefined ? null : a.sourceSessionId,
+      fetching: !!entry.inflight,
+    };
+  }
+
+  function emptyEntry() {
+    return { account: { status: "idle", metrics: [], fetchedAtMs: null }, identity: null, binding: null, failures: 0, retryAtMs: 0, inflight: null, token: 0 };
+  }
+
+  function drop(key) {
+    var entry = entries[key];
+    if (!entry) return;
+    entry.token++;
+    delete entries[key];
+  }
+
+  // True when the cached projection no longer describes the live source: the
+  // credential fingerprint differs (rotation or deletion, even mid-read) or the
+  // session/query that produced it was replaced.
+  function sourceChanged(entry, vendor) {
+    if (entry.identity && identityOf(vendor) !== entry.identity) return true;
+    return !bindingLive(entry.binding);
+  }
+
+  // The current known state, without starting a read.
+  function peek(owner, linuxUser, vendor) {
+    var refused = refusal(vendor, linuxUser, null);
+    if (refused && refused.status !== "idle") return blank(refused.status, refused.failureKind, refused.message);
+    var key = keyOf(owner, linuxUser, vendor);
+    var entry = entries[key];
+    if (!entry) return blank("idle");
+    if (sourceChanged(entry, vendor)) { drop(key); return blank("idle"); }
+    return snapshotOf(entry);
+  }
+
+  function failureDelay(entry, kind) {
+    if (kind === "no_auth") return timing.noAuthRetryMs;
+    return Math.min(timing.backoffMaxMs, timing.backoffBaseMs * Math.pow(2, Math.max(0, entry.failures - 1)));
+  }
+
+  function settleFailure(entry, error) {
+    var kind = error && error.failureKind ? error.failureKind : "error";
+    entry.failures += 1;
+    entry.retryAtMs = now() + failureDelay(entry, kind);
+    var prior = entry.account;
+    // Only a transient failure keeps the last good figures (marked stale);
+    // a sign-in problem or account change must not leave a former account's numbers.
+    // Figures survive only when their account is verifiable (a fingerprint) and
+    // they are still inside the bounded stale window.
+    var keep = DROPS_FIGURES.indexOf(kind) === -1 && !!entry.identity && prior.metrics.length > 0 && (prior.status === "ok" || prior.stale === true) && prior.fetchedAtMs !== null && now() - prior.fetchedAtMs < timing.staleMaxMs;
+    entry.account = {
+      status: kind === "no_auth" ? "no_auth" : kind === "expired_auth" ? "expired_auth" : "error",
+      metrics: keep ? prior.metrics : [], fetchedAtMs: keep ? prior.fetchedAtMs : null, stale: keep,
+      failureKind: kind, message: error && error.failureKind ? error.message : "Usage could not be read.",
+      planType: keep ? prior.planType || null : null, accountId: keep ? prior.accountId || null : null,
+      sourceSessionId: keep ? prior.sourceSessionId : null,
+    };
+    if (!keep) { entry.identity = null; entry.binding = null; }
+  }
+
+  function withTimeout(promise, controller) {
+    var timer;
+    var limit = new Promise(function (resolve, reject) {
+      timer = setTimeout(function () {
+        controller.abort();
+        reject(nativeReaders.failure("timeout", "The usage read timed out."));
+      }, timing.timeoutMs);
+    });
+    return Promise.race([promise, limit]).then(function (v) { clearTimeout(timer); return v; }, function (e) { clearTimeout(timer); throw e; });
+  }
+
+  // Resolves to a snapshot, or null when the result must not be used because
+  // the caller or the account changed. Nothing is started for a caller that is
+  // already stale.
+  async function read(request) {
+    var owner = request.owner, linuxUser = request.linuxUser || null, vendor = request.vendor;
+    var isCurrent = typeof request.isCurrent === "function" ? request.isCurrent : function () { return true; };
+    if (!isCurrent()) return null;
+    var refused = refusal(vendor, linuxUser, !!request.session);
+    if (refused) return refused.status === "idle" ? peek(owner, linuxUser, vendor) : blank(refused.status, refused.failureKind, refused.message);
+    var key = keyOf(owner, linuxUser, vendor);
+    var entry = entries[key] || (entries[key] = emptyEntry());
+    var startedGeneration = generations[owner] || 0;
+    var before = identityOf(vendor);
+    var binding = bindingOf(request.session);
+    if ((entry.identity && before !== entry.identity) || !bindingLive(entry.binding) || (entry.binding && !sameBinding(entry.binding, binding))) {
+      drop(key);
+      entry = entries[key] = emptyEntry();
+    }
+    expire(entry);
+    var current = now();
+    var age = entry.account.fetchedAtMs === null ? Infinity : current - entry.account.fetchedAtMs;
+    var coolingDown = entry.retryAtMs > current;
+    var fresh = entry.account.status === "ok" && age < (request.force ? timing.minForceMs : timing.ttlMs);
+    if (!entry.inflight && (fresh || coolingDown)) return isCurrent() ? snapshotOf(entry) : null;
+    if (!entry.inflight) {
+      var token = ++entry.token;
+      var controller = new AbortController();
+      var context = { adapter: getAdapter(vendor), linuxUser: linuxUser, session: request.session || null, signal: controller.signal };
+      entry.binding = binding;
+      var run = Promise.resolve().then(function () { return withTimeout(readers[vendor](context), controller); });
+      entry.inflight = run.then(function (result) {
+        if (entry.token !== token || (generations[owner] || 0) !== startedGeneration) return;
+        var list = (result && Array.isArray(result.metrics) ? result.metrics : []).filter(metrics.valid);
+        if (list.length === 0) throw nativeReaders.failure("unavailable", "The vendor reported no usage figures for this account.");
+        if (!bindingLive(binding)) throw nativeReaders.failure("source_changed", MESSAGES.source_changed);
+        // The credential is re-read AFTER the response. For a fingerprinted
+        // source it must equal the one the reader used (or, failing that, the
+        // one seen before the call); rotation, deletion or first appearance
+        // mid-read means neither account's figures can be attributed.
+        var expected = result.identity || before;
+        if (identities[vendor]) {
+          var fresh = identityOf(vendor);
+          if (fresh !== expected) throw nativeReaders.failure("account_changed", MESSAGES.account_changed);
+        }
+        entry.failures = 0; entry.retryAtMs = 0;
+        entry.identity = identities[vendor] ? expected || null : null;
+        entry.account = { status: "ok", metrics: list, fetchedAtMs: Number.isFinite(result.observedAtMs) ? result.observedAtMs : now(), stale: false, planType: result.planType || null, accountId: result.accountId || null, sourceSessionId: result.sourceSessionId === undefined ? null : result.sourceSessionId };
+      }).catch(function (error) {
+        if (entry.token !== token || (generations[owner] || 0) !== startedGeneration) return;
+        settleFailure(entry, error);
+      }).then(function () { if (entry.token === token) entry.inflight = null; });
+    }
+    await entry.inflight;
+    if (!isCurrent() || (generations[owner] || 0) !== startedGeneration || entries[key] !== entry) return null;
+    return snapshotOf(entry);
+  }
+
+  // Forget everything for an owner (account switch, logout, access change);
+  // reads still in flight can no longer store or return a result.
+  function invalidate(owner) {
+    generations[owner] = (generations[owner] || 0) + 1;
+    Object.keys(entries).forEach(function (key) {
+      if (key.indexOf(owner + "\u0000") === 0) drop(key);
+    });
+  }
+
+  return { read: read, peek: peek, invalidate: invalidate, refusal: refusal };
+}
+
+module.exports = { createUsageService: createUsageService, DEFAULTS: DEFAULTS };

package/lib/ws-schema.js

@@ -37,6 +37,8 @@ var schema = {
   "session_folders_state":    { direction: "s2c", handler: "lib/public/modules/session-folders.js", description: "Authoritative per-user, per-project session folder state; sent on connect and after every change to all of that user's sockets" },
   "new_session_options_get":  { direction: "c2s", handler: "lib/project-session-creation.js", description: "Ask for the installed providers, the project's default provider and whether the caller may set it" },
   "new_session_default_set":  { direction: "c2s", handler: "lib/project-session-creation.js", description: "Save the project-scoped default provider the inline New session row preselects" },
+  "vendor_usage_get":         { direction: "c2s", handler: "lib/vendor-usage-overview.js", description: "Ask for the caller's observed per-vendor usage overview for this project" },
+  "vendor_usage_overview":    { direction: "s2c", handler: "lib/public/modules/vendor-usage-overview.js", description: "Owner-scoped observed vendor usage windows, reset times and observation times; unknown vendors carry no windows" },
   "new_session_options":      { direction: "s2c", handler: "lib/public/modules/session-create.js", description: "Installed providers, project default provider and default-setting permission for the inline New session row" },
   "new_session_default_result": { direction: "s2c", handler: "lib/public/modules/session-create.js", description: "Outcome of saving the project New session default" },
   "new_session_project_default": { direction: "s2c", handler: "lib/public/modules/session-create.js", description: "The project New session default changed" },
@@ -404,9 +406,9 @@ var schema = {
   // -----------------------------------------------------------------------
   // Projects
   // -----------------------------------------------------------------------
-  "browse_dir":               { direction: "c2s", handler: "lib/project-sessions.js", description: "Browse directory entries for project creation" },
+  "browse_dir":               { direction: "c2s", handler: "lib/project-sessions.js", description: "Browse directory entries for project creation (requestId echoed; reply adds canonical dir, prefix, permitted parent)" },
   "browse_dir_result":        { direction: "s2c", handler: "lib/public/modules/app-messages.js", description: "Directory listing result" },
-  "add_project":              { direction: "c2s", handler: "lib/project-sessions.js", description: "Add an existing directory as a project" },
+  "add_project":              { direction: "c2s", handler: "lib/project-sessions.js", description: "Add an existing directory as a project (optional requestId echoed on add_project_result, also for create/clone)" },
   "add_project_result":       { direction: "s2c", handler: "lib/public/modules/app-messages.js", description: "Add project result" },
   "create_project":           { direction: "c2s", handler: "lib/project-sessions.js", description: "Create a new empty project directory" },
   "clone_project":            { direction: "c2s", handler: "lib/project-sessions.js", description: "Clone a git repository as a new project" },

package/lib/yoke/adapters/claude.js

@@ -704,6 +704,15 @@ function createQueryHandle(rawQuery, messageQueue, abortController) {
       return Promise.resolve(null);
     },
 
+    // Account plan usage through the SDK's usage call, which the SDK marks
+    // experimental: guarded by capability, resolves null when absent, and the
+    // caller validates the shape. Transcript scanning is skipped.
+    getAccountUsage: function() {
+      var method = rawQuery && rawQuery.usage_EXPERIMENTAL_MAY_CHANGE_DO_NOT_RELY_ON_THIS_API_YET;
+      if (typeof method === "function") return Promise.resolve(method.call(rawQuery, { skipBehaviors: true }));
+      return Promise.resolve(null);
+    },
+
     supportedModels: function() {
       if (rawQuery && typeof rawQuery.supportedModels === "function") {
         return rawQuery.supportedModels();
@@ -1482,6 +1491,9 @@ function createWorkerQueryHandle(worker, canUseTool, onElicitation, callMcpTool,
       return iterEnded ? Promise.resolve(null) : contextRequests.request(options);
     },
 
+    // The OS-isolated worker protocol has no account usage request.
+    getAccountUsage: function() { return Promise.resolve(null); },
+
     supportedModels: function() {
       return Promise.resolve([]);
     },

package/lib/yoke/adapters/codex-query-contract.js

@@ -7,6 +7,7 @@ var fields = {
   issues: "codexIssuesToolCatalogVersion",
   knowledge: "codexYouToolCatalogVersion",
   linear: "codexLinearToolCatalogVersion",
+  notes: "codexNotesToolCatalogVersion",
 };
 module.exports = {
   toolTransport: "dynamic",

package/lib/yoke/adapters/codex.js

@@ -17,6 +17,7 @@ var createTurnStop = require("../codex-turn-stop").createTurnStop;
 var idleRecovery = require("../codex-idle-recovery");
 var modelCatalog = require("../codex-model-catalog");
 var normalizeQuotaSnapshot = require("../codex-rate-limits").normalizeSnapshot;
+var dynamicToolNames = require("../codex-dynamic-tool-names");
 
 // --- Reasoning defaults ---
 // Reasoning summaries are the only readable thinking channel Codex offers:
@@ -33,7 +34,7 @@ var normalizeQuotaSnapshot = require("../codex-rate-limits").normalizeSnapshot;
 var CODEX_REASONING_DEFAULTS = {
   model_reasoning_summary: "detailed",
 };
-var DEFAULT_CODEX_MODEL = "gpt-6-astra";
+var DEFAULT_CODEX_MODEL = modelCatalog.DEFAULT_MODEL;
 var CODEX_QUERY_BOUND_TOOL_CAPABILITY = { mode: "dynamic", resume: "session-mcp-recovery" };
 var CODEX_NOTE_TOOLS = {
   list_notes: true,
@@ -622,6 +623,8 @@ function flattenEvent(notification, state) {
     // Dynamic tools are supplied by Clay for a specific thread, such as the
     // Driver's pair-session controls.
     if (item.type === "dynamicToolCall" || item.type === "dynamic_tool_call") {
+      // Activity shows the original Clay name, not the Codex wire alias.
+      var dynamicDisplayName = state.dynamicToolCatalog ? state.dynamicToolCatalog.displayName(item.tool) : item.tool;
       if (!state.toolBlocks[item.id]) {
         state.blockCounter++;
         state.toolBlocks[item.id] = "blk_" + state.blockCounter;
@@ -630,13 +633,13 @@ function flattenEvent(notification, state) {
           yokeType: "tool_start",
           blockId: dynamicBlockId,
           toolId: item.id,
-          toolName: item.tool || "session_tool",
+          toolName: dynamicDisplayName || "session_tool",
         });
         events.push({
           yokeType: "tool_executing",
           blockId: dynamicBlockId,
           toolId: item.id,
-          toolName: item.tool || "session_tool",
+          toolName: dynamicDisplayName || "session_tool",
           input: item.arguments || {},
         });
       }
@@ -968,6 +971,15 @@ function createCodexQueryHandle(appServer, queryOpts) {
     // server request and waits for the client to execute and answer it.
     if (method === "item/tool/call") {
       var dynamicParams = msg.params || {};
+      var resolvedDynamicTool = (state.dynamicToolCatalog || dynamicToolNames.createCatalog([])).resolve(dynamicParams.tool, dynamicParams.namespace);
+      if (resolvedDynamicTool.error) {
+        appServer.respond(msg.id, {
+          contentItems: [{ type: "inputText", text: "Error: " + resolvedDynamicTool.error }],
+          success: false,
+        });
+        return;
+      }
+      var dynamicToolName = resolvedDynamicTool.name;
       if (!callDynamicTool) {
         appServer.respond(msg.id, {
           contentItems: [{ type: "inputText", text: "Session tool handler is unavailable" }],
@@ -976,7 +988,7 @@ function createCodexQueryHandle(appServer, queryOpts) {
         return;
       }
       function executeDynamicTool() {
-        return Promise.resolve(callDynamicTool(dynamicParams.tool, dynamicParams.arguments || {})).then(function (result) {
+        return Promise.resolve(callDynamicTool(dynamicToolName, dynamicParams.arguments || {})).then(function (result) {
           var content = result && Array.isArray(result.content) ? result.content : [];
           var contentItems = content.map(function (item) {
             return { type: "inputText", text: item && item.text ? item.text : JSON.stringify(item) };
@@ -987,7 +999,7 @@ function createCodexQueryHandle(appServer, queryOpts) {
           appServer.respond(msg.id, { contentItems: contentItems, success: !(result && result.isError) });
         });
       }
-      var permissionToolName = canonicalDynamicPermissionToolName(dynamicParams.tool);
+      var permissionToolName = canonicalDynamicPermissionToolName(dynamicToolName);
       var permission = canUseTool
         ? Promise.resolve(canUseTool(permissionToolName, dynamicParams.arguments || {}, {
           toolUseID: dynamicParams.callId || String(msg.id),
@@ -1158,13 +1170,15 @@ function createCodexQueryHandle(appServer, queryOpts) {
       if (queryOpts.webSearchMode) {
         threadParams.webSearchMode = queryOpts.webSearchMode;
       }
-      if (Array.isArray(queryOpts.dynamicTools) && queryOpts.dynamicTools.length > 0) {
-        threadParams.dynamicTools = queryOpts.dynamicTools.map(function (tool) {
+      // Built on resume too: the persisted catalog uses the same aliases.
+      state.dynamicToolCatalog = dynamicToolNames.createCatalog(Array.isArray(queryOpts.dynamicTools) ? queryOpts.dynamicTools : []);
+      if (state.dynamicToolCatalog.advertised.length > 0) {
+        threadParams.dynamicTools = state.dynamicToolCatalog.advertised.map(function (entry) {
           return {
             type: "function",
-            name: tool.name,
-            description: tool.description || tool.name,
-            inputSchema: dynamicInputSchema(tool.inputSchema),
+            name: entry.name,
+            description: entry.def.description || entry.def.name,
+            inputSchema: dynamicInputSchema(entry.def.inputSchema),
           };
         });
       }
@@ -1558,7 +1572,7 @@ function createCodexAdapter(opts) {
   function buildReadyResponse(skillNames) {
     return {
       models: _cachedModels,
-      defaultModel: DEFAULT_CODEX_MODEL,
+      defaultModel: modelCatalog.defaultModel(_cachedModels),
       skills: skillNames || [],
       slashCommands: skillNames || [],
       fastModeState: null,
@@ -1943,7 +1957,7 @@ function createCodexAdapter(opts) {
         throw new Error("[yoke/codex] Adapter not initialized. Call init() first.");
       }
 
-      var model = queryOpts.model || DEFAULT_CODEX_MODEL;
+      var model = queryOpts.model || modelCatalog.defaultModel(_cachedModels);
       var ac = queryOpts.abortController || new AbortController();
       var activeEntry = {
         abort: function() {
@@ -2036,6 +2050,25 @@ function createCodexAdapter(opts) {
       return { handle: handle, backendPersistence: "ephemeral" };
     },
 
+    // Reads the account's own quota through the already-running app-server;
+    // it never starts a runtime and never starts a turn. Routed to the mapped
+    // OS user's runtime exactly like the other per-owner operations.
+    readAccountRateLimits: async function(opts) {
+      var requestedLinuxUser = opts && opts.linuxUser;
+      if (requestedLinuxUser) {
+        // Throws on a runtime bound to a different OS user; never answers from another identity.
+        var userRuntime = getUserRuntime(requestedLinuxUser);
+        if (userRuntime !== adapter) return userRuntime.readAccountRateLimits(withoutLinuxUser(opts));
+      }
+      if (_requiresLinuxUser) throw new Error("Codex requires a mapped Linux user while OS-user isolation is enabled");
+      if (!_appServer || !_appServer.started) {
+        var idle = new Error("Codex has not started in this project yet; open a Codex session to read account usage.");
+        idle.failureKind = "runtime_idle";
+        throw idle;
+      }
+      return _appServer.send("account/rateLimits/read", { excludeResetCreditDetails: true }, 15000);
+    },
+
     // --- Title generation ---
     generateTitle: async function(messages, opts) {
       var requestedLinuxUser = opts && opts.linuxUser;

package/lib/yoke/claude-hook-installer.js

@@ -67,6 +67,7 @@ var CLAY_MANAGED_ALLOW = [
   "mcp__clay-workspace__read_workspace_receipt",
   "mcp__clay-workspace__inspect_workspace_change",
   "mcp__clay-workspace__control_project_workspace",
+  "mcp__clay-workspace__read_vendor_usage",
   "mcp__clay-workspace__read_project_records",
   "mcp__clay-workspace__inspect_project_record_change",
   "mcp__clay-workspace__control_project_records",

package/lib/yoke/codex-dynamic-tool-names.js

@@ -0,0 +1,80 @@
+// Reversible Codex transport names for Clay dynamic tools.
+//
+// Codex app-server (rust-v0.162.1 validate_dynamic_tools) rejects a
+// thread/start whose dynamic tool names do not match ^[a-zA-Z0-9_-]+$, exceed
+// 128 characters, repeat, or are "mcp" / start with "mcp__". Clay keeps its
+// original names (for example mcp__server__tool) for dispatch, permissions and
+// activity, and only the Codex wire uses a deterministic alias. Determinism
+// lets a resumed thread's persisted catalog resolve against a rebuilt catalog.
+
+var crypto = require("crypto");
+
+var MAX_NAME_LENGTH = 128;
+var ALIAS_PREFIX = "clay__";
+var HASH_LENGTH = 16;
+var IDENTIFIER = /^[A-Za-z0-9_-]+$/;
+
+function isReserved(name) {
+  return name === "mcp" || name.indexOf("mcp__") === 0;
+}
+
+// True when Codex accepts the name as-is and it cannot be mistaken for an alias.
+function isPlainName(name) {
+  return typeof name === "string" && name.length > 0 && name.length <= MAX_NAME_LENGTH
+    && IDENTIFIER.test(name) && !isReserved(name) && name.indexOf(ALIAS_PREFIX) !== 0;
+}
+
+function transportName(name) {
+  if (typeof name !== "string" || !name) throw new Error("Dynamic tool names must be non-empty strings.");
+  if (isPlainName(name)) return name;
+  var hash = crypto.createHash("sha256").update(name, "utf8").digest("hex").slice(0, HASH_LENGTH);
+  var readable = name.replace(/^mcp__/, "").replace(/[^A-Za-z0-9_-]/g, "_");
+  var room = MAX_NAME_LENGTH - ALIAS_PREFIX.length - 2 - HASH_LENGTH;
+  return ALIAS_PREFIX + readable.slice(0, room) + "__" + hash;
+}
+
+// Build the exact alias map for one query's catalog. Repeated identical
+// originals resolve to the same handler, so they are advertised once. Two
+// different originals sharing an alias fail closed instead of guessing.
+function createCatalog(defs) {
+  var byTransport = new Map();
+  var byOriginal = new Map();
+  var advertised = [];
+  (defs || []).forEach(function (def) {
+    var original = def && def.name;
+    var alias = transportName(original);
+    if (byOriginal.has(original)) return;
+    if (byTransport.has(alias)) {
+      throw new Error("Codex dynamic tool names collide: " + byTransport.get(alias) + " and " + original);
+    }
+    byTransport.set(alias, original);
+    byOriginal.set(original, alias);
+    advertised.push({ def: def, name: alias });
+  });
+
+  // Map a Codex call back to the original Clay name. Plain names keep the
+  // existing live-catalog lookup; aliases must belong to this catalog.
+  function resolve(tool, namespace) {
+    if (namespace !== undefined && namespace !== null && namespace !== "") {
+      return { error: "Clay does not register namespaced dynamic tools: " + namespace };
+    }
+    if (typeof tool !== "string" || !tool) return { error: "Dynamic tool call has no tool name." };
+    if (byTransport.has(tool)) return { name: byTransport.get(tool) };
+    if (isPlainName(tool)) return { name: tool };
+    return { error: "Session tool is not in this conversation's current catalog: " + tool };
+  }
+
+  function displayName(tool) {
+    return byTransport.has(tool) ? byTransport.get(tool) : tool;
+  }
+
+  return { advertised: advertised, resolve: resolve, displayName: displayName };
+}
+
+module.exports = {
+  MAX_NAME_LENGTH: MAX_NAME_LENGTH,
+  ALIAS_PREFIX: ALIAS_PREFIX,
+  isPlainName: isPlainName,
+  transportName: transportName,
+  createCatalog: createCatalog,
+};

package/lib/yoke/codex-model-catalog.js

@@ -1,5 +1,16 @@
 // Runtime catalogs are scoped to the adapter's OS user and provider configuration.
-var FALLBACK = ["gpt-6-astra", "gpt-6.1-sol", "gpt-5.6-sol", "gpt-5.6-terra", "gpt-5.6-luna", "gpt-5.5", "gpt-5.2"];
+// The runtime model/list is authoritative. This offline fallback mirrors the
+// picker-visible presets bundled with @openai/codex 0.162.1, in their priority
+// order, minus models the official Codex models page lists as retired for
+// ChatGPT sign-in or deprecated (gpt-5.5, gpt-5.2). Verified 2026-10-17:
+// https://learn.chatgpt.com/docs/models
+var FALLBACK = ["gpt-6.1-sol", "gpt-6-astra", "gpt-6-sol", "gpt-6-luna", "gpt-5.6-sol", "gpt-5.6-terra", "gpt-5.6-luna"];
+// Codex marks its highest-priority picker-visible preset as default; for the
+// bundled 0.162.1 presets that is gpt-6.1-sol. Used only without a runtime flag.
+var DEFAULT_MODEL = "gpt-6.1-sol";
+// Fast, low-cost models for title generation, newest first (gpt-5.6-luna's
+// bundled upgrade target is gpt-6-luna).
+var TITLE_MODELS = ["gpt-6-luna", "gpt-5.6-luna"];
 
 function fallback() {
   return FALLBACK.slice();
@@ -21,6 +32,8 @@ async function load(server) {
         if (!entry || entry.hidden || typeof entry.model !== "string" || !entry.model || seen.has(entry.model)) return;
         seen.add(entry.model);
         var model = { value: entry.model, displayName: entry.displayName || entry.model, description: entry.description || "" };
+        if (typeof entry.defaultReasoningEffort === "string" && entry.defaultReasoningEffort) model.defaultReasoningEffort = entry.defaultReasoningEffort;
+        if (entry.isDefault === true) model.isDefault = true;
         if (Array.isArray(entry.supportedReasoningEfforts)) {
           model.supportedEffortLevels = entry.supportedReasoningEfforts.map(function (option) { return option.reasoningEffort; }).filter(function (effort) { return typeof effort === "string" && effort.length > 0; });
         }
@@ -37,11 +50,32 @@ async function load(server) {
   return fallback();
 }
 
+// The runtime's own default wins. Without a flag, never name a model the
+// catalog does not offer: use the static default only when it is listed,
+// otherwise the first valid row. An empty catalog keeps the static default.
+function defaultModel(models) {
+  var values = [];
+  var flagged = null;
+  (models || []).forEach(function (entry) {
+    var value = typeof entry === "string" ? entry : entry && typeof entry === "object" ? entry.value : null;
+    if (typeof value !== "string" || !value.trim()) return;
+    values.push(value);
+    if (!flagged && typeof entry === "object" && entry.isDefault === true) flagged = value;
+  });
+  if (flagged) return flagged;
+  if (values.indexOf(DEFAULT_MODEL) !== -1 || values.length === 0) return DEFAULT_MODEL;
+  return values[0];
+}
+
 function selectTitleModel(models, sessionModel) {
   var entries = models.map(function (entry) {
     return typeof entry === "string" ? { value: entry } : entry;
   }).filter(function (entry) { return entry && typeof entry.value === "string" && entry.value.trim(); });
-  var selected = entries.find(function (entry) { return entry.value === "gpt-5.6-luna"; })
+  var selected = null;
+  for (var ti = 0; ti < TITLE_MODELS.length && !selected; ti++) {
+    selected = entries.find(function (entry) { return entry.value === TITLE_MODELS[ti]; }) || null;
+  }
+  selected = selected
     || entries.find(function (entry) { return entry.value === sessionModel; }) || entries[0];
   if (!selected) throw new Error("No supported Codex title model is available");
   var efforts = selected.supportedEffortLevels;
@@ -49,4 +83,4 @@ function selectTitleModel(models, sessionModel) {
   return { model: selected.value, effort: effort };
 }
 
-module.exports = { fallback: fallback, load: load, selectTitleModel: selectTitleModel };
+module.exports = { DEFAULT_MODEL: DEFAULT_MODEL, fallback: fallback, load: load, defaultModel: defaultModel, selectTitleModel: selectTitleModel };