clay-server 4.1.0-beta.16 → 4.1.0-beta.18

package/lib/yoke/adapters/claude.js

@@ -67,10 +67,28 @@ function applySystemPromptSnapshot(systemPrompt, enabled) {
   return systemPrompt;
 }
 
-function getSharedSkillPlugins(homeDir, existingPlugins) {
+function getSharedSkillPlugins(homeDir, existingPlugins, cwd, env) {
   var plugins = Array.isArray(existingPlugins) ? existingPlugins.slice() : [];
-  var bridgePath = skillDiscovery.ensureClaudeCodexPlugin(homeDir ? { homeDir: homeDir } : null);
+  // undefined means normal in-process Claude and may use the configured
+  // daemon home; null means a failed mapped-user resolution and must fail
+  // closed without constructing any personal bridges.
+  if (homeDir === null) return plugins;
+  var effectiveHome = homeDir === undefined ? require("../../config").REAL_HOME || os.homedir() : homeDir;
+  var rootOptions = { homeDir: effectiveHome, env: env, scopedHome: !!homeDir };
+  var roots = skillDiscovery.getSkillRoots(cwd, rootOptions);
+  var codexRoot = roots.filter(function (root) { return root.source === "codex-user"; })[0];
+  var codexOpts = codexRoot ? { homeDir: effectiveHome, source: codexRoot.path, name: "codex" } : null;
+  if (codexRoot && codexRoot.path !== path.join(effectiveHome, ".codex", "skills")) {
+    codexOpts.name = "codex-" + crypto.createHash("sha256").update(codexRoot.path).digest("hex").slice(0, 12);
+  }
+  var bridgePath = skillDiscovery.ensureClaudeCodexPlugin(codexOpts);
   if (bridgePath) plugins.push({ type: "local", path: bridgePath, skipMcpDiscovery: true });
+  for (var i = 0; i < roots.length; i++) {
+    if (roots[i].source === "codex-user" || roots[i].source === "claude-user" || roots[i].source === "claude-project") continue;
+    var rootId = crypto.createHash("sha256").update(roots[i].source + "\0" + path.resolve(roots[i].path)).digest("hex").slice(0, 12);
+    var sharedPath = skillDiscovery.ensureClaudeCodexPlugin({ homeDir: effectiveHome, source: roots[i].path, name: "shared-" + roots[i].source + "-" + rootId });
+    if (sharedPath) plugins.push({ type: "local", path: sharedPath, skipMcpDiscovery: true });
+  }
   return plugins;
 }
 
@@ -99,7 +117,7 @@ function buildWorkerQueryOptions(queryOpts, claudeOpts, workerCwd) {
       queryOpts.systemPromptSnapshot
     );
   }
-  queryOptions.plugins = queryOpts.skipSkills ? (claudeOpts.plugins || []) : getSharedSkillPlugins(claudeOpts.originalHome, claudeOpts.plugins);
+  queryOptions.plugins = queryOpts.skipSkills ? (claudeOpts.plugins || []) : getSharedSkillPlugins(claudeOpts.originalHome, claudeOpts.plugins, workerCwd, queryOpts.env);
   if (queryOpts.toolServerDescriptors) queryOptions.mcpServerDescriptors = queryOpts.toolServerDescriptors;
   if (queryOpts.onUserDialog) queryOptions.supportedDialogKinds = SUPPORTED_DIALOG_KINDS;
   queryOptions.perTaskStopAffordance = PER_TASK_STOP_AFFORDANCE;
@@ -1423,7 +1441,7 @@ function createClaudeAdapter(opts) {
         abortController: ac,
         settings: { disableAllHooks: true },
       };
-      warmupOptions.plugins = getSharedSkillPlugins(initOpts && initOpts.originalHome);
+      warmupOptions.plugins = getSharedSkillPlugins(initOpts && initOpts.originalHome, null, initOpts && initOpts.cwd, initOpts && initOpts.env);
       if (_claudeBinaryPath) warmupOptions.pathToClaudeCodeExecutable = _claudeBinaryPath;
 
       if (initOpts && initOpts.dangerouslySkipPermissions) {
@@ -1637,7 +1655,7 @@ function createClaudeAdapter(opts) {
       if (co.allowDangerouslySkipPermissions) sdkOptions.allowDangerouslySkipPermissions = true;
       if (co.resumeSessionAt) sdkOptions.resumeSessionAt = co.resumeSessionAt;
       if (co.settings) sdkOptions.settings = co.settings;
-      sdkOptions.plugins = queryOpts.skipSkills ? (co.plugins || []) : getSharedSkillPlugins(co.originalHome, co.plugins);
+      sdkOptions.plugins = queryOpts.skipSkills ? (co.plugins || []) : getSharedSkillPlugins(co.originalHome, co.plugins, queryOpts.cwd || _cwd, queryOpts.env);
 
       claudeModelSwitch.attach(sdkOptions, queryOpts.onModelSwitch);
       var rawQuery = sdk.query({ prompt: mq, options: sdkOptions });
@@ -1897,7 +1915,7 @@ function createClaudeAdapter(opts) {
         abortController: ac,
         settings: { disableAllHooks: true },
       };
-      warmupOptions.plugins = getSharedSkillPlugins(initOpts && initOpts.originalHome);
+      warmupOptions.plugins = getSharedSkillPlugins(initOpts && initOpts.originalHome, null, initOpts && initOpts.cwd, initOpts && initOpts.env);
       if (_claudeBinaryPath) warmupOptions.pathToClaudeCodeExecutable = _claudeBinaryPath;
 
       if (initOpts && initOpts.dangerouslySkipPermissions) {
@@ -1979,7 +1997,7 @@ function createClaudeAdapter(opts) {
     }
 
     var warmupOptions = { cwd: workerCwd, settingSources: ["user", "project", "local"], settings: { disableAllHooks: true } };
-    warmupOptions.plugins = getSharedSkillPlugins(initOpts && initOpts.originalHome);
+    warmupOptions.plugins = getSharedSkillPlugins(initOpts && initOpts.originalHome, null, initOpts && initOpts.cwd, initOpts && initOpts.env);
     if (_claudeBinaryPath) warmupOptions.pathToClaudeCodeExecutable = _claudeBinaryPath;
     if (initOpts && initOpts.dangerouslySkipPermissions) {
       warmupOptions.permissionMode = "bypassPermissions";

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,
@@ -1163,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);
       }
@@ -1213,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++) {
@@ -1427,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 || {});
@@ -1498,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,
@@ -1530,6 +1642,7 @@ function createCodexAdapter(opts) {
   function clearRuntimeState() {
     _appServer = null;
     _initPromise = null;
+    _initializing = false;
     _cachedModels = [];
     _refCount = 0;
     _activeQueries = [];
@@ -1584,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; }),
@@ -1649,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);
@@ -1671,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();
@@ -1711,6 +1825,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,
@@ -1749,7 +1874,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);
@@ -1778,7 +1904,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);
           }
@@ -1792,13 +1918,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() {
@@ -1827,6 +1960,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 || {});
@@ -1865,8 +2002,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
@@ -1899,6 +2039,7 @@ function createCodexAdapter(opts) {
         handleOpts.onFinished = function() {
           removeActiveQuery(activeEntry);
           decrementRefCount();
+          if (typeof queryOpts.onRuntimeFinished === "function") queryOpts.onRuntimeFinished();
         };
         handle = createCodexQueryHandle(_appServer, handleOpts);
       } catch (e) {
@@ -2013,6 +2154,7 @@ function createCodexAdapter(opts) {
       return Promise.all([
         beginShutdown(true),
         shutdownUserRuntimes("shutdown"),
+        shutdownRecoveryRuntimes(),
       ]).then(function() { return true; });
     },
 
@@ -2040,7 +2182,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/session-skill-catalog.js

@@ -0,0 +1,45 @@
+// Session-owned shared skill catalog.
+// ----------------------------------
+// Keeps personal skill names out of project-wide session-manager state while
+// retaining vendor commands separately for hydration and session switching.
+
+var skillDiscovery = require("./skill-discovery");
+
+function createSessionSkillCatalog(opts) {
+  opts = opts || {};
+  var cwd = opts.cwd;
+  var osUsers = !!opts.osUsers;
+  var getLinuxUser = opts.getLinuxUser || function () { return null; };
+  var resolveUser = opts.resolveUser || require("../os-users").resolveOsUserInfo;
+
+  function optionsFor(session) {
+    if (!osUsers) return opts.homeDir ? { homeDir: opts.homeDir, env: opts.env } : {};
+    var linuxUser = getLinuxUser(session);
+    if (!linuxUser) return { disable: true };
+    try {
+      return skillDiscovery.optionsForOsUser(resolveUser(linuxUser));
+    } catch (e) {
+      return { disable: true };
+    }
+  }
+
+  function hydrate(session) {
+    if (!session) return [];
+    var discovered = skillDiscovery.discoverSkills(cwd, optionsFor(session));
+    var names = discovered.map(function (skill) { return skill.name; });
+    session.skillNames = names;
+    var vendorCommands = Array.isArray(session.vendorSlashCommands) ? session.vendorSlashCommands : [];
+    var combined = vendorCommands.slice();
+    for (var i = 0; i < names.length; i++) {
+      if (combined.indexOf(names[i]) === -1) combined.push(names[i]);
+    }
+    session.slashCommands = combined;
+    session.slashCommandsByVendor = session.slashCommandsByVendor || {};
+    session.slashCommandsByVendor[session.vendor || "claude"] = combined;
+    return combined;
+  }
+
+  return { hydrate: hydrate, optionsFor: optionsFor };
+}
+
+module.exports = { createSessionSkillCatalog: createSessionSkillCatalog };

package/lib/yoke/skill-discovery.js

@@ -11,6 +11,18 @@ function defaultHomeDir() {
   try { return require("../config").REAL_HOME; } catch (e) { return os.homedir(); }
 }
 
+function optionsForOsUser(userInfo, fsAsUser) {
+  if (!userInfo || typeof userInfo.home !== "string" || !userInfo.home) return { disable: true };
+  fsAsUser = fsAsUser || require("../os-users").fsAsUser;
+  return {
+    homeDir: userInfo.home,
+    scopedHome: true,
+    readDir: function (dir) { return fsAsUser("list", { dir: dir }, userInfo).map(function (entry) { return { name: entry.name, isDir: entry.isDir }; }); },
+    readFile: function (file) { return fsAsUser("read", { file: file, readContent: true }, userInfo).content; },
+    realpath: function (file) { return fsAsUser("realpath", { file: file }, userInfo).path; },
+  };
+}
+
 function unquote(value) {
   var text = String(value || "").trim();
   if ((text[0] === '"' && text[text.length - 1] === '"') ||
@@ -20,61 +32,83 @@ function unquote(value) {
   return text;
 }
 
-function readMetadata(skillPath, fallbackName) {
+function readMetadata(skillPath, fallbackName, opts) {
   var content;
-  try { content = fs.readFileSync(skillPath, "utf8"); } catch (e) { return null; }
+  try { content = opts && opts.readFile ? opts.readFile(skillPath) : fs.readFileSync(skillPath, "utf8"); } catch (e) { return null; }
   var name = fallbackName;
   var description = "";
+  var version = "";
   var frontmatter = content.match(/^---\s*\r?\n([\s\S]*?)\r?\n---(?:\s*\r?\n|$)/);
   if (frontmatter) {
     var nameMatch = frontmatter[1].match(/^name:\s*(.+)$/m);
     var descriptionMatch = frontmatter[1].match(/^description:\s*(.+)$/m);
     if (nameMatch) name = unquote(nameMatch[1]) || fallbackName;
     if (descriptionMatch) description = unquote(descriptionMatch[1]);
+    var versionMatch = frontmatter[1].match(/^version:\s*(.+)$/m);
+    if (versionMatch) version = unquote(versionMatch[1]);
   }
   if (!description) {
     var heading = content.match(/^#\s+(.+)$/m);
     if (heading) description = heading[1].trim();
   }
-  return { name: name, description: description };
+  return { name: name, description: description, version: version };
 }
 
-function scanRoot(root, source, merged) {
+function scanRoot(root, source, merged, opts) {
   var entries;
-  try { entries = fs.readdirSync(root, { withFileTypes: true }); } catch (e) { return; }
+  try { entries = opts && opts.readDir ? opts.readDir(root) : fs.readdirSync(root, { withFileTypes: true }); } catch (e) { return; }
   entries.sort(function(a, b) { return a.name.localeCompare(b.name); });
   for (var i = 0; i < entries.length; i++) {
     var entry = entries[i];
-    if (!entry.isDirectory() && !entry.isSymbolicLink()) continue;
+    if ((!opts || !opts.readDir) && (entry.isDir === false || (typeof entry.isDirectory === "function" && !entry.isDirectory() && !entry.isSymbolicLink()))) continue;
     var skillPath = path.join(root, entry.name, "SKILL.md");
-    var metadata = readMetadata(skillPath, entry.name);
+    var realSkillPath;
+    try { realSkillPath = opts && opts.realpath ? opts.realpath(skillPath) : fs.realpathSync(skillPath); } catch (e) { continue; }
+    var metadata = readMetadata(realSkillPath, entry.name, opts);
     if (!metadata) continue;
-    merged[metadata.name] = {
+    var key = opts && opts.includeDuplicates ? source + "\0" + metadata.name : metadata.name;
+    merged[key] = {
       name: metadata.name,
-      path: skillPath,
+      path: realSkillPath,
       description: metadata.description,
+      version: metadata.version,
       source: source,
     };
   }
 }
 
 function getSkillRoots(cwd, opts) {
-  var homeDir = (opts && opts.homeDir) || defaultHomeDir();
+  opts = opts || {};
+  var env = opts.env || (opts.homeDir ? {} : process.env);
+  if (opts.scopedHome) {
+    env = Object.assign({}, env);
+    delete env.CODEX_HOME;
+    delete env.CLAUDE_CONFIG_DIR;
+  }
+  var homeDir = opts.homeDir || env.HOME || defaultHomeDir();
+  var codexHome = env.CODEX_HOME ? path.resolve(homeDir, env.CODEX_HOME) : path.join(homeDir, ".codex");
+  var claudeConfigDir = env.CLAUDE_CONFIG_DIR ? path.resolve(homeDir, env.CLAUDE_CONFIG_DIR) : path.join(homeDir, ".claude");
   var roots = [
-    { path: path.join(homeDir, ".codex", "skills"), source: "codex-user" },
-    { path: path.join(homeDir, ".claude", "skills"), source: "claude-user" },
+    { path: path.join(homeDir, ".agents", "skills"), source: "agents-user" },
+    { path: path.join(codexHome, "skills"), source: "codex-user" },
+    { path: path.join(codexHome, "skills", ".system"), source: "codex-system-user" },
+    { path: path.join(claudeConfigDir, "skills"), source: "claude-user" },
   ];
   if (cwd) {
     roots.push({ path: path.join(cwd, "skills"), source: "project" });
+    roots.push({ path: path.join(cwd, ".agents", "skills"), source: "agents-project" });
+    roots.push({ path: path.join(cwd, ".codex", "skills"), source: "codex-project" });
+    roots.push({ path: path.join(cwd, ".codex", "skills", ".system"), source: "codex-system-project" });
     roots.push({ path: path.join(cwd, ".claude", "skills"), source: "claude-project" });
   }
   return roots;
 }
 
 function discoverSkills(cwd, opts) {
+  if (opts && opts.disable) return [];
   var merged = {};
   var roots = getSkillRoots(cwd, opts);
-  for (var i = 0; i < roots.length; i++) scanRoot(roots[i].path, roots[i].source, merged);
+  for (var i = 0; i < roots.length; i++) scanRoot(roots[i].path, roots[i].source, merged, opts);
   return Object.keys(merged).sort().map(function(name) { return merged[name]; });
 }
 
@@ -112,13 +146,13 @@ function buildSkillIndex(skills) {
   return lines.join("\n");
 }
 
-function readReferencedSkills(text, skills, maxChars) {
+function readReferencedSkills(text, skills, maxChars, readOpts) {
   var references = findSkillReferences(text, skills);
   var remaining = maxChars || 32768;
   var blocks = [];
   for (var i = 0; i < references.length && remaining > 0; i++) {
     var content;
-    try { content = fs.readFileSync(references[i].path, "utf8"); } catch (e) { continue; }
+    try { content = readOpts && readOpts.readFile ? readOpts.readFile(references[i].path) : fs.readFileSync(references[i].path, "utf8"); } catch (e) { continue; }
     var header = "<shared-skill name=\"" + references[i].name + "\" source=\"" + references[i].source + "\">\n";
     var footer = "\n</shared-skill>";
     var available = Math.max(0, remaining - header.length - footer.length);
@@ -142,18 +176,20 @@ function lstatOrNull(target) {
 }
 
 function ensureClaudeCodexPlugin(opts) {
-  var homeDir = (opts && opts.homeDir) || defaultHomeDir();
-  var source = path.join(homeDir, ".codex", "skills");
+  opts = opts || {};
+  var homeDir = opts.homeDir || defaultHomeDir();
+  var source = opts.source || path.join(homeDir, ".codex", "skills");
+  var bridgeName = opts.name || "codex";
   try {
     if (!fs.statSync(source).isDirectory()) return null;
   } catch (e) { return null; }
 
-  var pluginDir = path.join(homeDir, ".clay", "skill-bridge", "codex");
+  var pluginDir = path.join(homeDir, ".clay", "skill-bridge", bridgeName);
   var bridgeRoot = path.dirname(pluginDir);
   var manifestDir = path.join(pluginDir, ".claude-plugin");
   var manifestPath = path.join(manifestDir, "plugin.json");
   var skillsLink = path.join(pluginDir, "skills");
-  var manifest = JSON.stringify({ name: "codex", version: "1.0.0", description: "Codex skills shared by Clay" }, null, 2) + "\n";
+  var manifest = JSON.stringify({ name: bridgeName, version: "1.0.0", description: "Shared skills provided by Clay" }, null, 2) + "\n";
 
   try {
     fs.mkdirSync(path.join(homeDir, ".clay"), { recursive: true });
@@ -168,7 +204,10 @@ function ensureClaudeCodexPlugin(opts) {
     if (!manifestDirStat) fs.mkdirSync(manifestDir);
     var manifestStat = lstatOrNull(manifestPath);
     if (manifestStat) {
-      if (!manifestStat.isFile() || fs.readFileSync(manifestPath, "utf8") !== manifest) return null;
+      if (!manifestStat.isFile()) return null;
+      var existingManifest = fs.readFileSync(manifestPath, "utf8");
+      var legacyManifest = JSON.stringify({ name: "codex", version: "1.0.0", description: "Codex skills shared by Clay" }, null, 2) + "\n";
+      if (existingManifest !== manifest && existingManifest !== legacyManifest) return null;
     } else {
       fs.writeFileSync(manifestPath, manifest, { mode: 0o600, flag: "wx" });
     }
@@ -192,5 +231,6 @@ module.exports = {
   findSkillReferences: findSkillReferences,
   getSkillRoots: getSkillRoots,
   indexSkills: indexSkills,
+  optionsForOsUser: optionsForOsUser,
   readReferencedSkills: readReferencedSkills,
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "clay-server",
-  "version": "4.1.0-beta.16",
+  "version": "4.1.0-beta.18",
   "description": "Self-hosted team workspace for Claude Code and Codex. Multi-user, browser-based, with persistent AI mates.",
   "bin": {
     "clay-server": "./bin/cli.js"