clay-server 4.1.0-beta.9 → 4.1.0

package/lib/yoke/adapters/codex.js

@@ -29,7 +29,7 @@ var CODEX_REASONING_DEFAULTS = {
   model_supports_reasoning_summaries: true,
 };
 var DEFAULT_CODEX_MODEL = "gpt-6-astra";
-var CODEX_QUERY_BOUND_TOOL_CAPABILITY = { mode: "dynamic", resume: "persisted-catalog-only" };
+var CODEX_QUERY_BOUND_TOOL_CAPABILITY = { mode: "dynamic", resume: "session-mcp-recovery" };
 var CODEX_NOTE_TOOLS = {
   list_notes: true,
   write_note: true,
@@ -181,6 +181,11 @@ function flattenEvent(notification, state) {
 
   if (method === "turn/started") {
     state.turnStarted = true;
+    state.currentTurnId = params.turnId || params.turn_id || (params.turn && params.turn.id) || null;
+    state.lastInputTokens = null;
+    state.lastCachedTokens = null;
+    state.lastOutputTokens = null;
+    state.currentContextUsage = null;
     var userUuid = generateUuid();
     events.push({ yokeType: "turn_start", uuid: userUuid, messageType: "user" });
     return events;
@@ -194,16 +199,38 @@ function flattenEvent(notification, state) {
     if (turnStatus === "interrupted" || state.aborted) {
       events.push({ yokeType: "interrupted" });
     }
-    var inputTokens = state.lastInputTokens !== null && state.lastInputTokens !== undefined
-      ? state.lastInputTokens : (usage ? (usage.input_tokens || 0) : 0);
-    var outputTokens = (usage ? (usage.output_tokens || 0) : 0) || state.lastOutputTokens || 0;
-    var cachedTokens = (usage ? (usage.cached_input_tokens || 0) : 0) || state.lastCachedTokens || 0;
+    // Generic usage reporting is independent from current context occupancy.
+    // The latter is supplied only by a valid thread/tokenUsage snapshot.
+    // Some normal protocol completions omit usage even though the preceding
+    // token snapshot carried useful per-turn accounting. Keep that fallback
+    // for the generic usage panel, but never use it as context occupancy.
+    var inputTokens = usage && typeof usage.input_tokens === "number"
+      ? usage.input_tokens : (typeof state.lastInputTokens === "number" ? state.lastInputTokens : 0);
+    var outputTokens = usage && typeof usage.output_tokens === "number"
+      ? usage.output_tokens : (typeof state.lastOutputTokens === "number" ? state.lastOutputTokens : 0);
+    var cachedTokens = usage && typeof usage.cached_input_tokens === "number"
+      ? usage.cached_input_tokens : (typeof state.lastCachedTokens === "number" ? state.lastCachedTokens : 0);
     var hasTokenData = inputTokens > 0 || outputTokens > 0;
     var resultModelUsage = {};
     // Codex reports the real window in thread/tokenUsage/updated. Dropping it
     // made the client fall back to its model-name table, which has no entry
     // for codex model ids and defaulted to Claude's 200k denominator.
-    resultModelUsage[state.model] = { contextWindow: state.modelContextWindow || null };
+    var contextSnapshot = { valid: false };
+    if (state.currentContextUsage
+        && typeof state.currentContextUsage.input_tokens === "number"
+        && typeof state.currentContextUsage.contextWindow === "number"
+        && state.currentContextUsage.contextWindow > 0) {
+      contextSnapshot = {
+        valid: true,
+        inputTokens: state.currentContextUsage.input_tokens,
+        contextWindow: state.currentContextUsage.contextWindow,
+      };
+      if (state.currentContextUsage.turnId) contextSnapshot.turnId = state.currentContextUsage.turnId;
+    }
+    resultModelUsage[state.model] = {
+      contextWindow: state.modelContextWindow || null,
+      contextSnapshot: contextSnapshot,
+    };
     var assistantUuid = generateUuid();
     events.push({
       yokeType: "result",
@@ -683,24 +710,36 @@ function flattenEvent(notification, state) {
   if (method === "thread/tokenUsage/updated") {
     var tu = params.tokenUsage;
     if (tu) {
+      var tokenTurnId = params.turnId || params.turn_id || tu.turnId || null;
+      if (tokenTurnId && state.currentTurnId && tokenTurnId !== state.currentTurnId) {
+        state.lastInputTokens = null;
+        state.lastCachedTokens = null;
+        state.lastOutputTokens = null;
+        state.currentContextUsage = null;
+        return events;
+      }
+      var currentWindow = null;
       var turnUsage = tu.lastTurn;
       if (turnUsage) {
         var candidateInput = typeof turnUsage.inputTokens === "number" ? turnUsage.inputTokens : null;
-        var currentWindow = typeof tu.modelContextWindow === "number" ? tu.modelContextWindow : null;
-        state.lastInputTokens = candidateInput !== null && (currentWindow === null || candidateInput <= currentWindow) ? candidateInput : null;
+        currentWindow = typeof tu.modelContextWindow === "number" && isFinite(tu.modelContextWindow) && tu.modelContextWindow > 0
+          ? tu.modelContextWindow : null;
+        state.lastInputTokens = candidateInput !== null && isFinite(candidateInput) && candidateInput >= 0 && currentWindow !== null && candidateInput <= currentWindow ? candidateInput : null;
         state.lastCachedTokens = turnUsage.cachedInputTokens || 0;
         state.lastOutputTokens = turnUsage.outputTokens || 0;
-        state.currentContextUsage = state.lastInputTokens !== null &&
-          (currentWindow === null || state.lastInputTokens <= currentWindow)
-          ? { input_tokens: state.lastInputTokens, contextWindow: currentWindow }
-          : { input_tokens: null, contextWindow: currentWindow };
+        if (state.lastInputTokens !== null && currentWindow !== null) {
+          state.currentContextUsage = { input_tokens: state.lastInputTokens, contextWindow: currentWindow };
+          if (tokenTurnId || state.currentTurnId) state.currentContextUsage.turnId = tokenTurnId || state.currentTurnId;
+        } else {
+          state.currentContextUsage = null;
+        }
       } else {
         state.lastInputTokens = null;
         state.lastCachedTokens = null;
         state.lastOutputTokens = null;
         state.currentContextUsage = null;
       }
-      if (tu.modelContextWindow) state.modelContextWindow = tu.modelContextWindow;
+      if (currentWindow !== null) state.modelContextWindow = currentWindow;
     }
     return events;
   }
@@ -750,6 +789,7 @@ function createEventState(model) {
     lastCachedTokens: null,
     lastOutputTokens: null,
     currentContextUsage: null,
+    currentTurnId: null,
     modelContextWindow: null,
     done: false,
     aborted: false,
@@ -1123,16 +1163,25 @@ function createCodexQueryHandle(appServer, queryOpts) {
 
       var threadResult;
       if (queryOpts.resumeSessionId) {
-        // ThreadResumeParams in the installed app-server schema has no
-        // dynamicTools field. New tools therefore require a new Driver/Worker
-        // thread; resumed threads can only refresh handlers for persisted tools.
-        threadResult = await appServer.send("thread/resume", {
+        // ThreadResumeParams has no dynamicTools field, but its supported
+        // config override can start an exact-query MCP bridge without making
+        // a replacement thread or changing the saved conversation history.
+        var resumeParams = {
           threadId: queryOpts.resumeSessionId,
           model: threadParams.model,
           sandbox: threadParams.sandbox,
           approvalPolicy: threadParams.approvalPolicy,
           cwd: threadParams.cwd,
-        }, 60000);
+        };
+        if (queryOpts.sessionMcpServer && !queryOpts.isolatedRecovery) {
+          resumeParams.config = { mcp_servers: {} };
+          resumeParams.config.mcp_servers[queryOpts.sessionMcpServer.name] = {
+            command: queryOpts.sessionMcpServer.command,
+            args: queryOpts.sessionMcpServer.args || [],
+            env: queryOpts.sessionMcpServer.env || {},
+          };
+        }
+        threadResult = await appServer.send("thread/resume", resumeParams, 60000);
       } else {
         threadResult = await appServer.send("thread/start", threadParams, 60000);
       }
@@ -1173,7 +1222,7 @@ function createCodexQueryHandle(appServer, queryOpts) {
 
         // Explicit references use Codex's native skill input item regardless of
         // which vendor owns the SKILL.md file.
-        var availableSkills = queryOpts.skipSkills ? [] : skillDiscovery.discoverSkills(queryOpts.cwd);
+        var availableSkills = queryOpts.skipSkills ? [] : skillDiscovery.discoverSkills(queryOpts.cwd, queryOpts.skillOptions || { env: queryOpts.env });
         var skillItemsToInject = [];
         var injected = {};
         for (var ii = 0; ii < input.length; ii++) {
@@ -1288,7 +1337,10 @@ function createCodexQueryHandle(appServer, queryOpts) {
     },
 
     getContextUsage: function() {
-      return Promise.resolve(state.currentContextUsage);
+      return Promise.resolve(state.currentContextUsage || {
+        unavailable: true,
+        reason: "current_context_unavailable",
+      });
     },
 
     abort: function() {
@@ -1384,11 +1436,25 @@ function createCodexAdapter(opts) {
     for (var i = 0; i < listeners.length; i++) listeners[i]();
   }
   var _initPromise = null;
+  var _initializing = false;
   var _shutdownPromise = null;
   var _refCount = 0;
   var _lastActiveAt = Date.now();
   var _shuttingDown = false;
   var _activeQueries = [];
+  var _recoveryHandoff = null;
+  var _recoveryRuntimes = [];
+  var _recoveryCleanup = Promise.resolve();
+  var _recoveryCleanupTasks = [];
+
+  function scopedSkillOptions(env) {
+    if (!_runtimeLinuxUser) return { env: env };
+    try {
+      return Object.assign(skillDiscovery.optionsForOsUser(_resolveOsUserInfo(_runtimeLinuxUser)), { env: env });
+    } catch (e) {
+      return { disable: true };
+    }
+  }
 
   function withoutLinuxUser(callOpts) {
     var cleaned = Object.assign({}, callOpts || {});
@@ -1455,6 +1521,95 @@ function createCodexAdapter(opts) {
     updateLastActiveAt();
   }
 
+  function waitForRecoveryHandoff() {
+    return _recoveryHandoff || Promise.resolve();
+  }
+
+  function retainRecoveryRuntime(runtime) {
+    _recoveryRuntimes.push(runtime);
+  }
+
+  function removeRecoveryRuntime(runtime) {
+    var next = [];
+    for (var i = 0; i < _recoveryRuntimes.length; i++) {
+      if (_recoveryRuntimes[i] !== runtime) next.push(_recoveryRuntimes[i]);
+    }
+    _recoveryRuntimes = next;
+  }
+
+  function cleanupRecoveryRuntime(runtime) {
+    for (var i = 0; i < _recoveryCleanupTasks.length; i++) {
+      if (_recoveryCleanupTasks[i].runtime === runtime) return _recoveryCleanupTasks[i].promise;
+    }
+    var task = { runtime: runtime, promise: null };
+    _recoveryCleanupTasks.push(task);
+    var priorCleanup = _recoveryCleanup;
+    task.promise = Promise.resolve(priorCleanup).catch(function() {
+      return null;
+    }).then(function() {
+      return runtime.shutdown();
+    }).catch(function(error) {
+      console.error("[yoke/codex] Isolated recovery runtime shutdown failed:", error.message || error);
+    }).then(function() {
+      removeRecoveryRuntime(runtime);
+      var remainingTasks = [];
+      for (var ti = 0; ti < _recoveryCleanupTasks.length; ti++) {
+        if (_recoveryCleanupTasks[ti] !== task) remainingTasks.push(_recoveryCleanupTasks[ti]);
+      }
+      _recoveryCleanupTasks = remainingTasks;
+    });
+    _recoveryCleanup = task.promise;
+    return task.promise;
+  }
+
+  function shutdownRecoveryRuntimes() {
+    var runtimes = _recoveryRuntimes.slice();
+    if (!runtimes.length) return _recoveryCleanup;
+    return Promise.all(runtimes.map(function(runtime) {
+      return cleanupRecoveryRuntime(runtime);
+    })).then(function() {
+      _recoveryRuntimes = [];
+    });
+  }
+
+  async function createIsolatedRecoveryQuery(queryOpts) {
+    var releaseHandoff;
+    var priorHandoff = _recoveryHandoff;
+    var myHandoff = new Promise(function(resolve) { releaseHandoff = resolve; });
+    _recoveryHandoff = myHandoff;
+    await (priorHandoff || Promise.resolve());
+    try {
+      await _recoveryCleanup;
+      if (_refCount > 0 || _initializing) {
+        throw new Error("Codex resumed-tool recovery is waiting for an active shared runtime; retry after its current queries finish.");
+      }
+      if (_appServer) {
+        var stopped = await adapter.shutdownIfIdle(0);
+        if (!stopped) throw new Error("Codex resumed-tool recovery could not safely release the shared runtime; retry after its current queries finish.");
+      }
+      var recoveryRuntime = createCodexAdapter(Object.assign({}, _defaultInitOpts, {
+        recoveryRuntime: true,
+        recoverySessionMcpServer: queryOpts.sessionMcpServer,
+      }));
+      retainRecoveryRuntime(recoveryRuntime);
+      var recoveryOpts = Object.assign({}, queryOpts, {
+        isolatedRecovery: true,
+        onRuntimeFinished: function() {
+          return cleanupRecoveryRuntime(recoveryRuntime);
+        },
+      });
+      try {
+        return await recoveryRuntime.createQuery(recoveryOpts);
+      } catch (error) {
+        await cleanupRecoveryRuntime(recoveryRuntime);
+        throw error;
+      }
+    } finally {
+      releaseHandoff();
+      if (_recoveryHandoff === myHandoff) _recoveryHandoff = null;
+    }
+  }
+
   function buildReadyResponse(skillNames) {
     return {
       models: _cachedModels,
@@ -1487,6 +1642,7 @@ function createCodexAdapter(opts) {
   function clearRuntimeState() {
     _appServer = null;
     _initPromise = null;
+    _initializing = false;
     _cachedModels = [];
     _refCount = 0;
     _activeQueries = [];
@@ -1541,7 +1697,7 @@ function createCodexAdapter(opts) {
       var deadline = Date.now() + 5000;
       var shouldAbort = !!force;
 
-      if (_initPromise) {
+      if (_initializing && _initPromise) {
         try {
           await Promise.race([
             _initPromise.catch(function() { return null; }),
@@ -1606,9 +1762,10 @@ function createCodexAdapter(opts) {
       }
 
       // Deduplicate concurrent init calls
-      if (_initPromise) return _initPromise;
+      if (_initializing && _initPromise) return _initPromise;
 
-      _initPromise = (async function() {
+      _initializing = true;
+      var initPromise = (async function() {
         var serverOpts = { cwd: _cwd, env: effectiveInitOpts.env || null };
         if (_runtimeLinuxUser) {
           serverOpts.osUserInfo = _resolveOsUserInfo(_runtimeLinuxUser);
@@ -1628,7 +1785,7 @@ function createCodexAdapter(opts) {
 
         // Track 1: Read local MCP server definitions from ~/.clay/mcp.json
         // and inject into Codex config so Codex manages them natively.
-        var mcpServerConfig = {};
+        var mcpServerConfig = Object.assign({}, serverOpts.config.mcp_servers || {});
         try {
           var mcpLocal = require("../../mcp-local");
           var localMcpServers = mcpLocal.readMergedServers();
@@ -1651,6 +1808,7 @@ function createCodexAdapter(opts) {
         var clayPort = effectiveInitOpts.clayPort || process.env.CLAY_PORT || 2633;
         var clayTls = effectiveInitOpts.clayTls || false;
         var clayAuthToken = effectiveInitOpts.clayAuthToken || "";
+        var clayBridgeToken = effectiveInitOpts.clayBridgeToken || "";
         var claySlug = effectiveInitOpts.slug || _slug || "";
         try {
           if (require("fs").existsSync(bridgePath)) {
@@ -1658,6 +1816,7 @@ function createCodexAdapter(opts) {
             if (clayTls) bridgeArgs.push("--tls");
             var bridgeEnv = {};
             if (clayAuthToken) bridgeEnv.CLAY_AUTH_TOKEN = clayAuthToken;
+            if (clayBridgeToken) bridgeEnv.CLAY_BRIDGE_TOKEN = clayBridgeToken;
             mcpServerConfig["clay-tools"] = {
               command: process.execPath,
               args: bridgeArgs,
@@ -1668,6 +1827,17 @@ function createCodexAdapter(opts) {
           console.error("[codex] Failed to configure clay-tools bridge:", e.message);
         }
 
+        // Recovery uses a dedicated app-server so the query-local bridge can
+        // coexist with every server already configured for this runtime.
+        var recoveryMcpServer = effectiveInitOpts.recoverySessionMcpServer;
+        if (recoveryMcpServer && recoveryMcpServer.name && recoveryMcpServer.command) {
+          mcpServerConfig[recoveryMcpServer.name] = {
+            command: recoveryMcpServer.command,
+            args: recoveryMcpServer.args || [],
+            env: recoveryMcpServer.env || {},
+          };
+        }
+
         if (Object.keys(mcpServerConfig).length > 0) {
           serverOpts.config = Object.assign({}, serverOpts.config || {}, {
             mcp_servers: mcpServerConfig,
@@ -1706,7 +1876,8 @@ function createCodexAdapter(opts) {
         // triggering and skills/list use the same merged inventory.
         var skillNames = [];
         try {
-          var roots = skillDiscovery.getSkillRoots(_cwd);
+          var skillOptions = scopedSkillOptions(effectiveInitOpts.env);
+          var roots = skillOptions.disable ? [] : skillDiscovery.getSkillRoots(_cwd, skillOptions);
           var extraRootPaths = [];
           for (var ri = 0; ri < roots.length; ri++) {
             if (roots[ri].source !== "codex-user" && path.isAbsolute(roots[ri].path)) extraRootPaths.push(roots[ri].path);
@@ -1735,7 +1906,7 @@ function createCodexAdapter(opts) {
           }
           // Direct discovery remains the fallback for older Codex app-server
           // versions and keeps the GUI inventory vendor-neutral.
-          var sharedSkills = skillDiscovery.discoverSkills(_cwd);
+          var sharedSkills = skillDiscovery.discoverSkills(_cwd, skillOptions);
           for (var csn = 0; csn < sharedSkills.length; csn++) {
             if (skillNames.indexOf(sharedSkills[csn].name) === -1) skillNames.push(sharedSkills[csn].name);
           }
@@ -1749,13 +1920,20 @@ function createCodexAdapter(opts) {
           throw createShutdownError();
         }
 
-        _initPromise = null;
         updateLastActiveAt();
 
         return buildReadyResponse(skillNames);
       })();
 
-      return _initPromise;
+      _initPromise = initPromise;
+      initPromise.then(function() {
+        _initializing = false;
+        if (_initPromise === initPromise) _initPromise = null;
+      }, function() {
+        _initializing = false;
+        if (_initPromise === initPromise) _initPromise = null;
+      });
+      return initPromise;
     },
 
     supportedModels: function() {
@@ -1784,6 +1962,10 @@ function createCodexAdapter(opts) {
       if (_shuttingDown) {
         throw createShutdownError();
       }
+      if (queryOpts && queryOpts.sessionMcpServer && queryOpts.resumeSessionId && !queryOpts.isolatedRecovery) {
+        return createIsolatedRecoveryQuery(queryOpts);
+      }
+      await waitForRecoveryHandoff();
 
       if (!_appServer || !_appServer.started) {
         await adapter.init(queryOpts || {});
@@ -1822,8 +2004,11 @@ function createCodexAdapter(opts) {
         onElicitation: queryOpts.userInputMode === "fallback" ? null : (queryOpts.onElicitation || null),
         onUserInputRequest: queryOpts.userInputMode === "fallback" ? null : (queryOpts.onUserInputRequest || null),
         resumeSessionId: queryOpts.resumeSessionId || null,
+        sessionMcpServer: queryOpts.sessionMcpServer || null,
+        isolatedRecovery: queryOpts.isolatedRecovery === true,
         registerBackgroundTaskReset: registerBackgroundTaskReset,
         ephemeral: queryOpts.ephemeral === true,
+        skillOptions: scopedSkillOptions(queryOpts.env),
       };
 
       // Reasoning effort
@@ -1856,6 +2041,7 @@ function createCodexAdapter(opts) {
         handleOpts.onFinished = function() {
           removeActiveQuery(activeEntry);
           decrementRefCount();
+          if (typeof queryOpts.onRuntimeFinished === "function") queryOpts.onRuntimeFinished();
         };
         handle = createCodexQueryHandle(_appServer, handleOpts);
       } catch (e) {
@@ -1970,6 +2156,7 @@ function createCodexAdapter(opts) {
       return Promise.all([
         beginShutdown(true),
         shutdownUserRuntimes("shutdown"),
+        shutdownRecoveryRuntimes(),
       ]).then(function() { return true; });
     },
 
@@ -1997,7 +2184,7 @@ function createCodexAdapter(opts) {
         });
       }
       if (_shuttingDown || _shutdownPromise) return Promise.resolve(false);
-      if (_initPromise) return Promise.resolve(false);
+      if (_initializing) return Promise.resolve(false);
       if (!_appServer) return Promise.resolve(false);
       if (_refCount > 0) return Promise.resolve(false);
       if (Date.now() - _lastActiveAt < (idleMs || 0)) return Promise.resolve(false);

package/lib/yoke/adapters/kiro.js

@@ -18,7 +18,7 @@ var INITIALIZE_TIMEOUT_MS = require("../interface").INITIALIZE_TIMEOUT_MS;
 var skillDiscovery = require("../skill-discovery");
 var { KIRO_DEFAULTS } = require("../../kiro-defaults");
 
-function injectSharedSkillContent(message, skills) {
+function injectSharedSkillContent(message, skills, readOpts) {
   var text = "";
   if (typeof message === "string") text = message;
   else if (Array.isArray(message)) {
@@ -26,7 +26,7 @@ function injectSharedSkillContent(message, skills) {
       if (message[i] && message[i].type === "text") text += "\n" + (message[i].text || "");
     }
   }
-  var content = skillDiscovery.readReferencedSkills(text, skills, 32768);
+  var content = skillDiscovery.readReferencedSkills(text, skills, 32768, readOpts);
   if (!content) return message;
   var appendix = "\n\nUse the following shared skill instructions for this turn:\n" + content;
   if (typeof message === "string") return message + appendix;
@@ -682,7 +682,7 @@ function createKiroQueryHandle(acp, queryOpts) {
       while (!isCancelled()) {
         resetTurnState();
 
-        var messageWithSkills = injectSharedSkillContent(currentMessage, queryOpts.skills || []);
+        var messageWithSkills = injectSharedSkillContent(currentMessage, queryOpts.skills || [], queryOpts.skillOptions);
         var input = typeof messageWithSkills === "string"
           ? [{ type: "text", text: messageWithSkills }]
           : messageWithSkills;
@@ -1012,7 +1012,7 @@ function createKiroAdapter(opts) {
           _defaultModel = "auto";
         }
 
-        var skillNames = skillDiscovery.discoverSkills(_cwd).map(function(skill) { return skill.name; });
+        var skillNames = skillDiscovery.discoverSkills(_cwd, { env: (initOpts && initOpts.env) || null }).map(function(skill) { return skill.name; });
         console.log("[yoke/kiro] ACP initialized, models: " + _cachedModels.length + ", skills: " + skillNames.length);
 
         updateLastActiveAt();
@@ -1065,7 +1065,7 @@ function createKiroAdapter(opts) {
       var model = queryOpts.model || _defaultModel || "auto";
       var ac = queryOpts.abortController || new AbortController();
       var kiroOpts = (queryOpts.adapterOptions && queryOpts.adapterOptions.KIRO) || {};
-      var sharedSkills = queryOpts.skipSkills ? [] : skillDiscovery.discoverSkills(queryOpts.cwd || _cwd);
+      var sharedSkills = queryOpts.skipSkills ? [] : skillDiscovery.discoverSkills(queryOpts.cwd || _cwd, queryOpts.skillOptions || { env: queryOpts.env || null });
       var skillIndex = skillDiscovery.buildSkillIndex(sharedSkills);
 
       var activeEntry = { abort: function() { try { ac.abort(); } catch (e) {} } };
@@ -1079,6 +1079,7 @@ function createKiroAdapter(opts) {
         systemPrompt: queryOpts.systemPrompt || "",
         appendSystemPrompt: [queryOpts.appendSystemPrompt, skillIndex].filter(function (part) { return !!part; }).join("\n\n"),
         skills: sharedSkills,
+        skillOptions: queryOpts.skillOptions || { env: queryOpts.env || null },
         abortController: ac,
         canUseTool: queryOpts.canUseTool || null,
         resumeSessionId: queryOpts.resumeSessionId || null,

package/lib/yoke/claude-context-usage.js

@@ -0,0 +1,57 @@
+var crypto = require("crypto");
+
+function options(value) {
+  return { detail: value && value.detail === "full" ? "full" : "summary" };
+}
+
+function createRequests(worker) {
+  var pending = new Map();
+  return {
+    request: function(value) {
+      return new Promise(function(resolve, reject) {
+        var id = crypto.randomUUID();
+        var timer = setTimeout(function() {
+          pending.delete(id);
+          reject(new Error("Context usage request timed out"));
+        }, 30000);
+        pending.set(id, { resolve: resolve, reject: reject, timer: timer });
+        var accepted = false;
+        try { accepted = worker.send({ type: "get_context_usage", requestId: id, options: options(value) }); }
+        catch (error) {
+          clearTimeout(timer);
+          pending.delete(id);
+          reject(error);
+          return;
+        }
+        if (!accepted) {
+          clearTimeout(timer);
+          pending.delete(id);
+          resolve(null);
+        }
+      });
+    },
+    receive: function(message) {
+      var entry = pending.get(message.requestId);
+      if (!entry) return;
+      pending.delete(message.requestId);
+      clearTimeout(entry.timer);
+      if (message.error) entry.reject(new Error(message.error));
+      else entry.resolve(message.data || null);
+    },
+    close: function() {
+      pending.forEach(function(entry) { clearTimeout(entry.timer); entry.resolve(null); });
+      pending.clear();
+    },
+  };
+}
+
+async function respond(query, message, send) {
+  try {
+    var data = query && typeof query.getContextUsage === "function" ? await query.getContextUsage(options(message.options)) : null;
+    send({ type: "context_usage_response", requestId: message.requestId, data: data });
+  } catch (error) {
+    send({ type: "context_usage_response", requestId: message.requestId, error: error.message });
+  }
+}
+
+module.exports = { options: options, createRequests: createRequests, respond: respond };

package/lib/yoke/claude-message-correlation.js

@@ -0,0 +1,31 @@
+// Match merged Claude replies to the messages admitted by this query.
+var crypto = require("crypto");
+
+function createCorrelation() {
+  var pending = new Set();
+  var submitted = 0;
+  return {
+    message: function(content) {
+      return { type: "user", uuid: crypto.randomUUID(), message: { role: "user", content: content } };
+    },
+    accepted: function(message) { pending.add(message.uuid); submitted++; },
+    submitted: function() { return submitted; },
+    result: function(raw, event) {
+      if (raw.type !== "result") return event;
+      event.submittedMessageCount = submitted;
+      var ids = Array.isArray(raw.user_message_uuids) ? raw.user_message_uuids : [];
+      if (raw.user_message_uuid) ids = ids.concat(raw.user_message_uuid);
+      var matched = 0;
+      ids.forEach(function(id) {
+        if (pending.delete(id)) matched++;
+      });
+      // Only count UUIDs admitted by this query, once each. Older providers
+      // without correlation fields retain the bridge's legacy accounting.
+      if (matched) event.answeredUserMessageCount = matched;
+      else if (!ids.length && pending.size) pending.delete(pending.values().next().value);
+      return event;
+    },
+  };
+}
+
+module.exports = { createCorrelation: createCorrelation };

package/lib/yoke/claude-model-switch.js

@@ -0,0 +1,15 @@
+function attach(options, notify) {
+  if (typeof notify !== "function") return;
+  var hooks = Object.assign({}, options.hooks || {});
+  hooks.PostModelSwitch = (hooks.PostModelSwitch || []).concat([{
+    hooks: [async function(input) {
+      if (input.from_model && input.to_model && input.from_model !== input.to_model) {
+        notify({ fromModel: input.from_model, toModel: input.to_model, source: input.source || "unknown" });
+      }
+      return {};
+    }],
+  }]);
+  options.hooks = hooks;
+}
+
+module.exports = { attach: attach };

package/lib/yoke/index.js

@@ -379,7 +379,11 @@ function createAdapters(opts) {
 
   if (installed.codex && supportsConfiguredIsolation("codex")) {
     try {
-      adapters.codex = createAdapter({ vendor: "codex", cwd: opts.cwd, slug: opts.slug, osUsers: !!opts.osUsers });
+      adapters.codex = createAdapter({
+        vendor: "codex", cwd: opts.cwd, slug: opts.slug, osUsers: !!opts.osUsers,
+        clayPort: opts.clayPort, clayTls: opts.clayTls,
+        clayAuthToken: opts.clayAuthToken, clayBridgeToken: opts.clayBridgeToken,
+      });
       auth.codex = true;
     } catch (e) {
       console.error("[yoke] Failed to create adapter for codex:", e.message);