clay-server 5.2.0-beta.4 → 5.2.0-beta.6

package/lib/yoke/adapters/claude.js

@@ -4,6 +4,7 @@
 // This is the ONLY file (besides claude-worker.js) that imports the SDK.
 // Also manages worker processes for OS-level user isolation.
 
+var attachWorkerStartup = require("../claude-worker-startup").attachWorkerStartup;
 var bindQueryAbort = require("../query-abort").bindAbort;
 var path = require("path");
 var fs = require("fs");
@@ -527,7 +528,7 @@ function flattenEvent(raw) {
   // --- rate_limit_event ---
   if (raw.type === "rate_limit_event" && raw.rate_limit_info) {
     base.yokeType = "rate_limit";
-    base.rateLimitInfo = raw.rate_limit_info;
+    base.rateLimitInfo = Object.assign({}, raw.rate_limit_info, { isUsingOverage: raw.rate_limit_info.isUsingOverage === true || raw.rate_limit_info.overageInUse === true });
     return base;
   }
 
@@ -600,6 +601,8 @@ function createQueryHandle(rawQuery, messageQueue, abortController) {
   var correlation = claudeCorrelation.createCorrelation();
   var closed = false;
   var removeAbort = function () {};
+  var resolveStopped;
+  var stopped = new Promise(function(resolve) { resolveStopped = resolve; });
   var handle = {
     // Opaque adapter state (null for in-process queries)
     _adapterState: null,
@@ -610,12 +613,13 @@ function createQueryHandle(rawQuery, messageQueue, abortController) {
       return {
         next: function() {
           return rawIter.next().then(function(result) {
-            if (result.done) { closed = true; removeAbort(); }
+            if (result.done) { closed = true; removeAbort(); resolveStopped(); }
             if (result.done) return result;
             return { value: correlation.result(result.value, flattenEvent(result.value)), done: false };
           }, function(err) {
             closed = true;
             removeAbort();
+            resolveStopped();
             throw err;
           });
         },
@@ -715,6 +719,11 @@ function createQueryHandle(rawQuery, messageQueue, abortController) {
       }
     },
 
+    stopAndWait: function() {
+      handle.abort();
+      return stopped;
+    },
+
     close: function() {
       closed = true;
       removeAbort();
@@ -818,9 +827,7 @@ function spawnWorker(linuxUser, workerScriptPath, cwd) {
     buffer: "",
   };
 
-  worker.readyPromise = new Promise(function(resolve) {
-    worker._readyResolve = resolve;
-  });
+  attachWorkerStartup(worker);
 
   // Resolves when the worker process actually exits.
   // Used to prevent spawning a new worker before the old one finishes
@@ -860,7 +867,15 @@ function spawnWorker(linuxUser, workerScriptPath, cwd) {
     });
     connection.on("error", function(err) {
       console.error("[yoke/claude] Worker connection error:", err.message);
+      if (worker._readyReject) worker._readyReject(err);
     });
+    connection.on("close", function() {
+      if (worker._readyReject) worker._readyReject(new Error("Claude worker connection closed before ready."));
+    });
+  });
+  worker.server.on("error", function(error) {
+    if (worker._readyReject) worker._readyReject(error);
+    cleanupWorker(worker);
   });
 
   worker.server.listen(socketPath, function() {
@@ -892,6 +907,14 @@ function spawnWorker(linuxUser, workerScriptPath, cwd) {
     });
     worker.process = spawn(workerSpawn.command, workerSpawn.args, workerSpawn.options);
 
+    worker.process.on("error", function(error) {
+      if (worker._readyReject) worker._readyReject(error);
+      worker.messageHandlers.forEach(function(handler) { handler({ type: "query_error", error: error.message, _fallback: true }); });
+      cleanupWorker(worker);
+      // Only a spawn failure proves that no child execution exists. Other
+      // ChildProcess errors (for example a failed signal) are not exit evidence.
+      if (!worker.process.pid && worker._exitResolve) { worker._exitResolve(); worker._exitResolve = null; }
+    });
     worker.process.stdout.on("data", function(data) {
       console.log("[sdk-worker:" + linuxUser + "] " + data.toString().trim());
     });
@@ -905,9 +928,8 @@ function spawnWorker(linuxUser, workerScriptPath, cwd) {
     worker.process.on("exit", function(code, signal) {
       console.log("[yoke/claude] Worker for " + linuxUser + " exited (code=" + code + ", signal=" + signal + ")" + (worker._stderrBuf ? " stderr: " + worker._stderrBuf.trim() : ""));
       // Reject readyPromise if worker dies before becoming ready
-      if (!worker.ready && worker._readyResolve) {
-        worker._readyResolve = null;
-        // Let the readyPromise hang; the query_error handler will clean up
+      if (!worker.ready && worker._readyReject) {
+        worker._readyReject(new Error("Claude worker exited before ready (code=" + code + ")."));
       }
       // Notify message handlers about unexpected exit so sessions don't hang.
       // Always dispatch a fallback query_error. The handler is idempotent:
@@ -1082,6 +1104,9 @@ function createWorkerQueryHandle(worker, canUseTool, onElicitation, callMcpTool,
   var iterWaiting = null;
   var iterEnded = false;
   var iterError = null;
+  var resolveStopped;
+  var stopped = new Promise(function(resolve) { resolveStopped = resolve; });
+  if (worker.exitPromise) worker.exitPromise.then(resolveStopped);
 
   // Pending request/response correlation for handle methods that need a
   // result from the worker (e.g. rewindFiles). Each entry is keyed by a
@@ -1299,6 +1324,8 @@ function createWorkerQueryHandle(worker, canUseTool, onElicitation, callMcpTool,
       }
 
       case "query_done":
+        if (worker._abortTimeout) { clearTimeout(worker._abortTimeout); worker._abortTimeout = null; }
+        resolveStopped();
         rejectPendingPermissionModes(new Error("Worker query ended while changing permission mode"));
         console.log("[yoke/claude] IPC query_done received, pid=" + (worker.process ? worker.process.pid : "?"));
         worker._queryEnded = true;
@@ -1306,6 +1333,10 @@ function createWorkerQueryHandle(worker, canUseTool, onElicitation, callMcpTool,
         break;
 
       case "query_error": {
+        if (!msg._fallback) {
+          if (worker._abortTimeout) { clearTimeout(worker._abortTimeout); worker._abortTimeout = null; }
+          resolveStopped();
+        }
         rejectPendingPermissionModes(new Error(msg.error || "Worker exited while changing permission mode"));
         console.log("[yoke/claude] IPC query_error received, pid=" + (worker.process ? worker.process.pid : "?") + " _fallback=" + !!msg._fallback + " _queryEnded=" + worker._queryEnded + " error=" + (msg.error || "").substring(0, 100));
         // Skip fallback errors from exit handler if we already handled the real one
@@ -1472,6 +1503,11 @@ function createWorkerQueryHandle(worker, canUseTool, onElicitation, callMcpTool,
       }, 5000);
     },
 
+    stopAndWait: function() {
+      handle.abort();
+      return stopped;
+    },
+
     close: function() {
       rejectPendingPermissionModes(new Error("Worker query closed while changing permission mode"));
       // End the iterator
@@ -1507,43 +1543,7 @@ function createWorkerQueryHandle(worker, canUseTool, onElicitation, callMcpTool,
 
 // --- Adapter factory ---
 
-function resolveClaudeBinaryPath() {
-  // 1. Explicit env var override
-  if (process.env.CLAUDE_CODE_PATH && fs.existsSync(process.env.CLAUDE_CODE_PATH)) {
-    return process.env.CLAUDE_CODE_PATH;
-  }
-
-  // 2. `which claude` in the daemon's PATH
-  try {
-    var result = require("child_process").execSync("which claude", { encoding: "utf8", timeout: 5000 }).trim();
-    if (result && fs.existsSync(result)) return result;
-  } catch (e) {}
-
-  // 3. Common per-user and system locations (best-effort fallback for the daemon user)
-  var home = process.env.HOME || "";
-  var candidates = [];
-  if (home) {
-    candidates.push(home + "/.npm-global/bin/claude");
-    candidates.push(home + "/.local/bin/claude");
-    candidates.push(home + "/.volta/bin/claude");
-    candidates.push(home + "/.bun/bin/claude");
-    candidates.push(home + "/bin/claude");
-  }
-  candidates.push("/usr/local/bin/claude");
-  candidates.push("/usr/bin/claude");
-  candidates.push("/opt/homebrew/bin/claude");
-  for (var i = 0; i < candidates.length; i++) {
-    try { if (fs.existsSync(candidates[i])) return candidates[i]; } catch (e) {}
-  }
-
-  // 4. Bundled CLI entry from the SDK's peer
-  try {
-    var resolved = require.resolve("@anthropic-ai/claude-code/cli.js");
-    if (resolved && fs.existsSync(resolved)) return resolved;
-  } catch (e) {}
-
-  return null;
-}
+var resolveClaudeBinaryPath = require("../providers/claude-executable").resolve;
 
 function createClaudeAdapter(opts) {
   var _cwd = (opts && opts.cwd) || process.cwd();
@@ -1556,6 +1556,7 @@ function createClaudeAdapter(opts) {
 
   var adapter = {
     vendor: "claude",
+    queryContract: require("./claude-query-contract"),
     userInputCapability: { mode: "native", native: true, transport: "AskUserQuestion/onElicitation" },
 
     // Path to worker script (sdk-bridge uses this to spawn worker processes)
@@ -1642,7 +1643,7 @@ function createClaudeAdapter(opts) {
 
             try {
               var models = await stream.supportedModels();
-              result.models = models || [];
+              result.models = require("../providers/claude-model-descriptions").list(models);
               _cachedModels = result.models;
             } catch (e) {
               // supportedModels may fail, models list will be empty
@@ -1909,7 +1910,10 @@ function createClaudeAdapter(opts) {
 
     // Wait for worker to be ready before sending query_start
     if (!reusingWorker) {
-      await worker.readyPromise;
+      try { await worker.readyPromise; } catch (error) {
+        worker.kill();
+        throw error;
+      }
     }
 
     // Build serializable query options (no callbacks, no AbortController).
@@ -1954,7 +1958,7 @@ function createClaudeAdapter(opts) {
           warmupDone = true;
           var r = msg.result || {};
           resolve({
-            models: r.models || [],
+            models: require("../providers/claude-model-descriptions").list(r.models),
             defaultModel: r.model || "",
             skills: r.skills || [],
             slashCommands: r.slashCommands || [],
@@ -2071,7 +2075,7 @@ function createClaudeAdapter(opts) {
 
             try {
               var models = await stream.supportedModels();
-              result.models = models || [];
+              result.models = require("../providers/claude-model-descriptions").list(models);
               _cachedModels = result.models;
             } catch (e) {
               // supportedModels may fail, models list will be empty
@@ -2122,7 +2126,7 @@ function createClaudeAdapter(opts) {
           warmupDone = true;
           var r = msg.result || {};
           resolve({
-            models: r.models || [],
+            models: require("../providers/claude-model-descriptions").list(r.models),
             defaultModel: r.model || "",
             skills: r.skills || [],
             slashCommands: r.slashCommands || [],

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

@@ -0,0 +1,24 @@
+// Codex restores dynamic definitions from the original thread catalog.
+// Keep persisted legacy field names here so old conversations remain readable.
+var fields = {
+  schedules: "codexDynamicToolCatalogVersion",
+  questions: "codexUserInputToolCatalogVersion",
+  browser: "codexSharedBrowserToolCatalogVersion",
+  issues: "codexIssuesToolCatalogVersion",
+  knowledge: "codexYouToolCatalogVersion",
+  linear: "codexLinearToolCatalogVersion",
+};
+module.exports = {
+  toolTransport: "dynamic",
+  catalogLifetime: "conversation",
+  externalToolTransport: "dynamic",
+  defaultUserInputMode: "fallback",
+  questionGuidance: require("../user-input-guidance").codexQuestionGuidance,
+  catalogVersion: function (session, family) { return Number(session[fields[family]] || 0); },
+  recordCatalog: function (session, versions) {
+    Object.keys(versions).forEach(function (family) {
+      if (fields[family]) session[fields[family]] = versions[family];
+    });
+  },
+  staleCatalogReason: "This Codex conversation predates Clay's scheduled-task tool catalog. Start a new conversation to use the assisted interview; manual task creation remains available here.",
+};

package/lib/yoke/adapters/codex.js

@@ -1343,6 +1343,8 @@ function createCodexQueryHandle(appServer, queryOpts) {
       return { threadId: state.threadId, revision: inputRevision };
     },
 
+    getRecoveryThreadId: function() { return state.threadId || queryOpts.resumeSessionId || null; },
+
     retireIdleForRecovery: function() {
       handle.endInput();
       return loopFinished;
@@ -1461,11 +1463,23 @@ function createCodexAdapter(opts) {
   var _refCount = 0;
   var _lastActiveAt = Date.now();
   var _shuttingDown = false;
+  var _recoveryIdleShutdown = null;
   var _activeQueries = [];
-  var _recoveryHandoff = null;
-  var _recoveryRuntimes = [];
-  var _recoveryCleanup = Promise.resolve();
-  var _recoveryCleanupTasks = [];
+  var recoveryAdmission = require("../codex-recovery-admission").attachRecoveryAdmission({
+    state: function() { return { epoch: _shutdownEpoch, shuttingDown: _shuttingDown, retiring: _recoveryIdleShutdown === _shutdownEpoch,
+      initializing: _initializing, refCount: _refCount, server: _appServer, entries: _activeQueries.slice() }; },
+    shutdownError: createShutdownError,
+    stopIdle: async function() {
+      _recoveryIdleShutdown = _shutdownEpoch;
+      try { return await adapter.shutdownIfIdle(0); }
+      finally { _recoveryIdleShutdown = null; }
+    },
+    createRuntime: function(queryOpts) {
+      return createCodexAdapter(Object.assign({}, _defaultInitOpts, {
+        recoveryRuntime: true, recoverySessionMcpServer: queryOpts.sessionMcpServer,
+      }));
+    },
+  });
 
   function scopedSkillOptions(env) {
     if (!_runtimeLinuxUser) return { env: env };
@@ -1541,102 +1555,6 @@ function createCodexAdapter(opts) {
     updateLastActiveAt();
   }
 
-  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 shutdownEpoch = _shutdownEpoch;
-    function checkCurrent() {
-      idleRecovery.checkAbort(queryOpts);
-      if (_shuttingDown || shutdownEpoch !== _shutdownEpoch) throw createShutdownError();
-    }
-    var releaseHandoff;
-    var priorHandoff = _recoveryHandoff;
-    var myHandoff = new Promise(function(resolve) { releaseHandoff = resolve; });
-    _recoveryHandoff = myHandoff;
-    await (priorHandoff || Promise.resolve());
-    try {
-      await _recoveryCleanup;
-      checkCurrent();
-      if (!_initializing && _refCount > 0) {
-        await idleRecovery.retireIdleQueries(_activeQueries.slice(), _appServer, checkCurrent);
-      }
-      checkCurrent();
-      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.");
-      }
-      checkCurrent();
-      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,
@@ -1764,6 +1682,7 @@ function createCodexAdapter(opts) {
   var adapter = {
     vendor: "codex",
     queryBoundToolCapability: CODEX_QUERY_BOUND_TOOL_CAPABILITY,
+    queryContract: require("./codex-query-contract"),
     userInputCapability: { mode: "native", native: true, transport: "item/tool/requestUserInput" },
 
     init: function(initOpts) {
@@ -1777,12 +1696,14 @@ function createCodexAdapter(opts) {
       if (_runtimeLinuxUser && requestedLinuxUser && requestedLinuxUser !== _runtimeLinuxUser) {
         return Promise.reject(new Error("Codex runtime user mismatch"));
       }
-      if (_shuttingDown) {
+      if (_shuttingDown && _recoveryIdleShutdown !== _shutdownEpoch) {
         return Promise.reject(createShutdownError());
       }
-      if (_recoveryHandoff) {
+      try { recoveryAdmission.checkSharedExit(); }
+      catch (error) { return Promise.reject(error); }
+      if (recoveryAdmission.pending()) {
         var initEpoch = _shutdownEpoch;
-        return _recoveryHandoff.then(function() {
+        return recoveryAdmission.pending().then(function() {
           if (initEpoch !== _shutdownEpoch) throw createShutdownError();
           return adapter.init(initOpts);
         });
@@ -1963,6 +1884,10 @@ function createCodexAdapter(opts) {
       return null;
     },
 
+    retireIdleForRecovery: function(checkCurrent) {
+      return idleRecovery.retireIdleQueries(_activeQueries.slice(), _appServer, checkCurrent);
+    },
+
     createQuery: async function(queryOpts) {
       var requestedLinuxUser = queryOpts && queryOpts.linuxUser;
       if (!_runtimeLinuxUser && requestedLinuxUser) {
@@ -1974,28 +1899,37 @@ function createCodexAdapter(opts) {
       if (_runtimeLinuxUser && requestedLinuxUser && requestedLinuxUser !== _runtimeLinuxUser) {
         throw new Error("Codex runtime user mismatch");
       }
-      if (_shuttingDown) {
+      if (_shuttingDown && _recoveryIdleShutdown !== _shutdownEpoch) {
         throw createShutdownError();
       }
       if (queryOpts && queryOpts.sessionMcpServer && queryOpts.resumeSessionId && !queryOpts.isolatedRecovery) {
-        return createIsolatedRecoveryQuery(queryOpts);
+        return recoveryAdmission.createQuery(queryOpts);
       }
       var queryEpoch = _shutdownEpoch;
+      function checkAdmission() {
+        idleRecovery.checkAbort(queryOpts || {});
+        if ((_shuttingDown && _recoveryIdleShutdown !== _shutdownEpoch) || queryEpoch !== _shutdownEpoch) throw createShutdownError();
+      }
       // Recheck after every await: recovery may replace the runtime while an
       // ordinary start is waiting for initialization or an earlier handoff.
       while (true) {
         idleRecovery.checkAbort(queryOpts || {});
-        if (_shuttingDown || queryEpoch !== _shutdownEpoch) throw createShutdownError();
-        if (_recoveryHandoff) {
-          await _recoveryHandoff;
+        if ((_shuttingDown && _recoveryIdleShutdown !== _shutdownEpoch) || queryEpoch !== _shutdownEpoch) throw createShutdownError();
+        recoveryAdmission.checkSharedExit();
+        if (recoveryAdmission.pending()) {
+          await idleRecovery.wait(recoveryAdmission.pending(), checkAdmission);
+          continue;
+        }
+        if (queryOpts.resumeSessionId && recoveryAdmission.hasTarget(queryOpts.resumeSessionId)) {
+          await recoveryAdmission.waitForTarget(queryOpts);
           continue;
         }
         if (_initializing && _initPromise) {
-          await _initPromise;
+          await idleRecovery.wait(_initPromise, checkAdmission);
           continue;
         }
         if (!_appServer || !_appServer.started) {
-          await adapter.init(queryOpts || {});
+          await idleRecovery.wait(adapter.init(queryOpts || {}), checkAdmission);
           continue;
         }
         break;
@@ -2174,12 +2108,20 @@ function createCodexAdapter(opts) {
     },
 
     // Shutdown the app-server process
+    shutdownForRecovery: async function() {
+      var proc = _appServer && _appServer.proc;
+      await adapter.shutdown();
+      if (proc && proc.exitCode === null && proc.signalCode === null) {
+        throw new Error('Codex recovery runtime exit could not be confirmed; its thread remains reserved.');
+      }
+    },
+
     shutdown: function() {
       _shutdownEpoch++;
       return Promise.all([
         beginShutdown(true),
         shutdownUserRuntimes("shutdown"),
-        shutdownRecoveryRuntimes(),
+        recoveryAdmission.shutdown(),
       ]).then(function() { return true; });
     },
 

package/lib/yoke/adapters/kiro.js

@@ -279,7 +279,7 @@ function flattenUpdate(update, state) {
 
   // Token usage
   if (type === "usage_update") {
-    if (typeof update.used === "number") state.lastInputTokens = update.used;
+    if (typeof update.used === "number") { state.lastInputTokens = update.used; state.contextMeasurement = "observed"; }
     if (typeof update.size === "number") state.contextWindow = update.size;
     return events;
   }
@@ -294,6 +294,7 @@ function flattenUpdate(update, state) {
       if (typeof percentage !== "number") percentage = kiroMeta.usagePercentage;
       if (typeof percentage === "number" && state.contextWindow) {
         state.lastInputTokens = Math.round(state.contextWindow * percentage / 100);
+        state.contextMeasurement = "estimated";
       }
     }
     return events;
@@ -782,6 +783,7 @@ function createKiroQueryHandle(acp, queryOpts) {
     getContextUsage: function() {
       return Promise.resolve(state.lastInputTokens != null ? {
         input_tokens: state.lastInputTokens,
+        measurement: state.contextMeasurement || "observed",
         contextWindow: state.contextWindow || null,
       } : null);
     },

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

@@ -0,0 +1,7 @@
+// Muse's sessionMcp configuration is supplied on both start and resume.
+module.exports = {
+  toolTransport: "stdio-mcp",
+  catalogLifetime: "query",
+  permissionModes: ["auto"],
+  interruptionMessage: "Interrupted · What should Muse do instead?",
+};

package/lib/yoke/adapters/muse.js

@@ -0,0 +1,122 @@
+var museQuery = require("../muse-query");
+var runtimeTools = require("../muse-runtime");
+var findMusePath = require("../providers/muse-executable").resolve;
+
+function createMuseAdapter(opts) {
+  opts = opts || {};
+  var adapter = {
+    vendor: "muse",
+    userInputCapability: { mode: "native", native: true },
+    providerContract: require("../vendor-registry").getVendorInfo("muse"),
+    queryContract: require("./muse-query-contract"),
+    cwd: opts.cwd || process.cwd(),
+    binaryPath: opts._binaryPath || null,
+    sdkPromise: null,
+    catalog: [],
+    clients: new Set(),
+    handles: new Set(),
+    shuttingDown: false,
+    requestTimeoutMs: opts._requestTimeoutMs || 9e4,
+    titleTimeoutMs: opts._titleTimeoutMs || 15e3,
+    shutdownTimeoutMs: opts._shutdownTimeoutMs == null ? 1e3 : opts._shutdownTimeoutMs
+  };
+  adapter.loadSdk = function() {
+    if (opts._sdk) return Promise.resolve(opts._sdk);
+    if (!adapter.sdkPromise) adapter.sdkPromise = import("@muse-code/sdk");
+    return adapter.sdkPromise;
+  };
+  adapter.init = async function(initOpts) {
+    if (opts.osUsers || opts.linuxUser || initOpts && (initOpts.linuxUser || initOpts.osUsers)) throw new Error("Muse Code does not support OS-owner isolation");
+    if (!adapter.binaryPath) adapter.binaryPath = findMusePath();
+    if (!adapter.binaryPath) throw new Error("Muse Code binary not found: muse. Install Muse Code or set MUSE_CODE_PATH.");
+    await adapter.loadSdk();
+    return {
+      models: [],
+      defaultModel: null,
+      skills: [],
+      slashCommands: [],
+      fastModeState: null,
+      capabilities: {
+        effort: true,
+        midSessionModelSwitch: true,
+        fork: true,
+        rollback: false,
+        sessionListing: true,
+        sessionRename: true,
+        thinking: true,
+        betas: false,
+        rewind: false,
+        sessionResume: true,
+        promptSuggestions: false,
+        elicitation: false,
+        fileCheckpointing: false,
+        contextCompacting: true,
+        queryBoundTools: {
+          mode: "stdio-mcp",
+          source: "@muse-code/sdk SessionConfig.mcpServers"
+        },
+        skillSharing: true,
+        toolPolicy: [ "ask", "allow-all" ]
+      }
+    };
+  };
+  adapter.supportedModels = async function() {
+    if (adapter.shuttingDown) throw new Error("Muse Code adapter is shutting down");
+    if (!adapter.binaryPath) await adapter.init();
+    var sdk = await adapter.loadSdk();
+    if (adapter.shuttingDown) throw new Error("Muse Code adapter is shutting down");
+    var runtime = runtimeTools.createRuntime(adapter, sdk, {
+      command: adapter.binaryPath,
+      args: [ "serve" ],
+      cwd: adapter.cwd,
+      env: Object.assign({}, process.env)
+    });
+    runtime.fail = function(error) {
+      runtime.close().catch(function(closeError) {
+        adapter.lastCloseError = closeError;
+      });
+    };
+    try {
+      var spawned = await runtime.initialize();
+      adapter.catalog = runtimeTools.normalizeCatalog(await runtime.waitRequest(spawned.connection.request("model/list", {})));
+      return adapter.catalog.slice();
+    } finally {
+      await runtime.close();
+    }
+  };
+  adapter.createToolServer = function() {
+    return null;
+  };
+  adapter.createQuery = async function(queryOpts) {
+    if (opts.osUsers || opts.linuxUser || queryOpts && queryOpts.linuxUser) throw new Error("Muse Code does not support OS-owner isolation");
+    if (!adapter.binaryPath) await adapter.init(queryOpts || {});
+    if (adapter.shuttingDown) throw new Error("Muse Code adapter is shutting down");
+    return museQuery.createMuseQueryHandle(adapter, queryOpts || {});
+  };
+  adapter.generateTitle = function(messages, titleOpts) {
+    return require("../title-query").generateTitle(adapter, messages, Object.assign({}, titleOpts, { timeoutMs: adapter.titleTimeoutMs }),
+      { skipProjectInstructions: true, skipSkills: true, adapterOptions: { MUSE: { readOnly: true, mcpServers: [] } } });
+  };
+  adapter.shutdown = async function() {
+    adapter.shuttingDown = true;
+    var results = await Promise.allSettled(Array.from(adapter.handles).map(function(handle) {
+      return handle.close();
+    }).concat(Array.from(adapter.clients).map(function(runtime) {
+      return runtime.close();
+    })));
+    var failed = results.find(function(result) {
+      return result.status === "rejected";
+    });
+    if (failed) throw failed.reason;
+    return true;
+  };
+  require("../muse-services").attach(adapter);
+  return adapter;
+}
+
+module.exports = {
+  createMuseAdapter: createMuseAdapter,
+  findMusePath: findMusePath,
+  isAuthError: runtimeTools.isAuthError,
+  chooseApprovalDecision: require("../muse-policy").chooseApprovalDecision
+};