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

package/lib/yoke/query-options.js

@@ -0,0 +1,10 @@
+// Translate common execution intent at the provider implementation boundary.
+function map(provider, intent) {
+  var info = provider && Object.prototype.hasOwnProperty.call(provider, "mapQueryOptions") ? provider : require("./provider-contract").resolve(provider);
+  if (info.mapQueryOptions === undefined) return {};
+  if (typeof info.mapQueryOptions !== "function") throw new Error("Provider option mapping is unavailable.");
+  var options = info.mapQueryOptions(intent || {});
+  if (!options || typeof options !== "object" || Array.isArray(options)) throw new Error("Invalid provider option mapping.");
+  return options;
+}
+module.exports = { map: map };

package/lib/yoke/response-recovery.js

@@ -0,0 +1,41 @@
+// Explicit provider implementation, with a live binding to the implementation
+// selected for this session. Stop always reaches the originally bound service.
+function attachResponseRecovery(ctx) {
+  var managers = new Map(), bindings = new WeakMap();
+  function policy(session) {
+    return require('./provider-contract').resolve(ctx.getProvider ? ctx.getProvider(session) : session.vendor || 'claude');
+  }
+  function manager(session, create) {
+    if (!create) return bindings.get(session) || null;
+    var factory = policy(session).recoveryFactory;
+    var previous = bindings.get(session);
+    if (factory === undefined) {
+      if (previous) previous.cancel(session);
+      bindings.delete(session);
+      return null;
+    }
+    if (typeof factory !== 'function') throw new Error('Provider recovery implementation is unavailable.');
+    if (!managers.has(factory)) {
+      var context = Object.assign({}, ctx, { isCurrentProvider: function(target) { return policy(target).recoveryFactory === factory; } });
+      var service = factory(context);
+      ['begin', 'enqueue', 'event', 'progress', 'cancel', 'current', 'valid', 'stopping', 'dispose'].forEach(function(name) {
+        if (!service || typeof service[name] !== 'function') throw new Error('Provider recovery implementation is missing ' + name + '.');
+      });
+      managers.set(factory, service);
+    }
+    var selected = managers.get(factory);
+    if (previous && previous !== selected) previous.cancel(session);
+    bindings.set(session, selected);
+    return selected;
+  }
+  var api = {};
+  ['begin', 'enqueue', 'event', 'progress', 'cancel', 'current', 'valid', 'stopping'].forEach(function(name) {
+    api[name] = function(session) {
+      var service = manager(session, name === 'begin' || name === 'enqueue');
+      return service ? service[name].apply(service, arguments) : name === 'stopping' || name === 'valid' ? false : null;
+    };
+  });
+  api.dispose = function() { managers.forEach(function(service) { service.dispose(); }); managers.clear(); bindings = new WeakMap(); };
+  return api;
+}
+module.exports = { attachResponseRecovery: attachResponseRecovery };

package/lib/yoke/sdk-mcp-descriptors.js

@@ -0,0 +1,37 @@
+// Extract serializable tool descriptors from MCP server instances.
+// Used for IPC to worker processes (McpSdkServerConfigWithInstance is not serializable).
+function extractMcpDescriptors(mcpServers) {
+  if (!mcpServers) return null;
+  // Claude's adapter uses Zod v3 for JSON Schema tools; other servers use v4.
+  // Use the MCP SDK's version-aware converter for both kinds of registered tool.
+  var toJSONSchema = require("@modelcontextprotocol/sdk/server/zod-json-schema-compat.js").toJsonSchemaCompat;
+  var descriptors = [];
+  var names = Object.keys(mcpServers);
+  for (var i = 0; i < names.length; i++) {
+    var serverName = names[i];
+    var server = mcpServers[serverName];
+    if (!server || !server.instance || !server.instance._registeredTools) continue;
+    var tools = [];
+    var toolNames = Object.keys(server.instance._registeredTools);
+    for (var j = 0; j < toolNames.length; j++) {
+      var toolName = toolNames[j];
+      var toolDef = server.instance._registeredTools[toolName];
+      var inputSchema = { type: "object", properties: {} };
+      try {
+        if (toolDef._clayInputSchema) inputSchema = toolDef._clayInputSchema;
+        else if (toolDef.inputSchema) inputSchema = toJSONSchema(toolDef.inputSchema);
+      } catch (e) {
+        throw new Error("Cannot serialize MCP tool schema " + serverName + "/" + toolName + ": " + e.message);
+      }
+      tools.push({
+        name: toolName,
+        description: toolDef.description || toolName,
+        inputSchema: inputSchema,
+      });
+    }
+    if (tools.length > 0) descriptors.push({ serverName: serverName, tools: tools });
+  }
+  return descriptors.length > 0 ? descriptors : null;
+}
+
+module.exports = { extractMcpDescriptors: extractMcpDescriptors };

package/lib/yoke/sdk-server-factory.js

@@ -0,0 +1,7 @@
+// Shared SDK server envelope; transport projection remains inside YOKE.
+function load() {
+  var sdk = require("@anthropic-ai/claude-agent-sdk");
+  if (typeof sdk.createSdkMcpServer !== "function" || typeof sdk.tool !== "function") throw new Error("SDK tool server implementation is unavailable.");
+  return { createSdkMcpServer: sdk.createSdkMcpServer, tool: sdk.tool };
+}
+module.exports = { load: load };

package/lib/yoke/session-history.js

@@ -0,0 +1,8 @@
+// A provider fork may return local history or require a provider-owned reader.
+// Absence is an unsupported operation, never an empty successful transcript.
+function read(provider, home, cwd, sessionId) {
+  var reader = require("./provider-contract").resolve(provider).readSessionHistory;
+  if (typeof reader !== "function") throw new Error("Provider session history reading is unavailable.");
+  return reader(home, cwd, sessionId);
+}
+module.exports = { read: read };

package/lib/yoke/session-tool-transport.js

@@ -1,23 +1,39 @@
 // Shared production transport facts for query-bound Clay tools.
 
 var vendorRegistry = require("./vendor-registry");
-var CODEX_CATALOG_VERSION = 5;
+var SCHEDULE_CATALOG_VERSION = 5;
+var MATE_SCHEDULE_TOOLS = ["begin_mate_schedule_interview", "propose_mate_schedule", "list_mate_schedules", "read_mate_schedule", "update_mate_schedule", "cancel_mate_schedule"];
 var SCHEDULE_TOOLS = ["begin_scheduled_task_interview", "propose_scheduled_task", "list_scheduled_tasks", "read_scheduled_task", "update_scheduled_task", "report_scheduled_task_outcome"];
 
-function capability(vendor) {
-  if (vendor === "claude") return { supported: true, kind: "sdk-mcp" };
-  if (vendor === "codex") return { supported: true, kind: "dynamic" };
-  var info = vendorRegistry.getVendorInfo(vendor);
-  if (info && info.sessionBoundTools === true) return { supported: true, kind: "stdio-mcp" };
-  return { supported: false, kind: "none" };
+// Accept an adapter as well as a registry key. Live adapters can implement the
+// same semantics independently of their name; unknown providers fail closed.
+function contract(provider) {
+  if (provider && typeof provider === "object" && provider.queryContract) return provider.queryContract;
+  var info = vendorRegistry.getVendorInfo(typeof provider === "string" ? provider : provider && provider.vendor);
+  if (info && info.queryContract) return info.queryContract;
+  return info && info.sessionBoundTools === true ? { toolTransport: "stdio-mcp", catalogLifetime: "query" } : {};
+}
+
+function capability(provider) {
+  var kind = contract(provider).toolTransport || "none";
+  if (["sdk-mcp", "dynamic", "stdio-mcp"].indexOf(kind) === -1) kind = "none";
+  return { supported: kind !== "none", kind: kind };
+}
+
+function needsRecovery(provider, session, family, version) {
+  var policy = contract(provider);
+  if (!session.cliSessionId || policy.catalogLifetime !== "conversation") return false;
+  if (!family) return true;
+  if (typeof policy.catalogVersion !== "function") return true;
+  var recorded = policy.catalogVersion(session, family);
+  return !Number.isFinite(recorded) || recorded < version;
 }
 
 function availableForSession(session) {
-  var vendor = session && (session.vendor || "claude");
-  var transport = capability(vendor);
-  if (!transport.supported) return { available: false, reason: "This provider's current Clay adapter does not deliver custom session tools." };
-  if (vendor === "codex" && session.cliSessionId && Number(session.codexDynamicToolCatalogVersion || 0) < CODEX_CATALOG_VERSION) {
-    return { available: false, reason: "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." };
+  var provider = session && (session.vendor || "claude");
+  if (!capability(provider).supported) return { available: false, reason: "This provider's current Clay adapter does not deliver custom session tools." };
+  if (needsRecovery(provider, session, "schedules", SCHEDULE_CATALOG_VERSION)) {
+    return { available: false, reason: contract(provider).staleCatalogReason || "This conversation's persisted tool catalog is outdated. Start a new conversation to use the assisted interview." };
   }
   return { available: true, reason: null };
 }
@@ -38,16 +54,21 @@ function questionToolName(vendor) {
 
 function bridgeServerForTool(name) {
   if (name === "ask_user_questions") return "yoke-user-input";
+  if (MATE_SCHEDULE_TOOLS.indexOf(name) !== -1) return "clay-mate-schedules";
   if (SCHEDULE_TOOLS.indexOf(name) !== -1) return "clay-scheduled-tasks";
   return null;
 }
 
 module.exports = {
+  contract: contract,
+  needsRecovery: needsRecovery,
   capability: capability,
   availableForSession: availableForSession,
-  CODEX_CATALOG_VERSION: CODEX_CATALOG_VERSION,
+  SCHEDULE_CATALOG_VERSION: SCHEDULE_CATALOG_VERSION,
+  CODEX_CATALOG_VERSION: SCHEDULE_CATALOG_VERSION, // Legacy export for existing consumers.
   scheduleToolName: scheduleToolName,
   questionToolName: questionToolName,
   bridgeServerForTool: bridgeServerForTool,
   SCHEDULE_TOOLS: SCHEDULE_TOOLS,
+  MATE_SCHEDULE_TOOLS: MATE_SCHEDULE_TOOLS,
 };

package/lib/yoke/settings.js

@@ -0,0 +1,23 @@
+function implementations(provider) {
+  if (provider) { var policy = require("./provider-contract").resolve(provider); return policy.settings ? [policy.settings] : []; }
+  var registry = require("./vendor-registry").VENDOR_REGISTRY;
+  return Array.from(new Set(Object.keys(registry).map(function(vendor) { return registry[vendor].settings; }).filter(Boolean)));
+}
+function defaults() {
+  var result = {};
+  implementations().forEach(function(service) { Object.assign(result, service.defaults()); });
+  return result;
+}
+function messages(settings) {
+  return implementations().flatMap(function(service) { return service.messages(settings); });
+}
+function change(message, settings, provider) {
+  var services = implementations(provider);
+  for (var i = 0; i < services.length; i++) {
+    if (typeof services[i].change !== "function") throw new Error("Provider settings implementation is unavailable.");
+    var result = services[i].change(message, settings);
+    if (result) return result;
+  }
+  return null;
+}
+module.exports = { defaults: defaults, messages: messages, change: change };

package/lib/yoke/source-locations.js

@@ -0,0 +1,4 @@
+var path = require("path");
+// Legacy imported skill format; Clay-only skills use their own private root.
+function legacySkillRoot(base) { return path.join(base, ".claude", "skills"); }
+module.exports = { legacySkillRoot: legacySkillRoot };

package/lib/yoke/title-query.js

@@ -25,12 +25,14 @@ async function generateTitle(adapter, messages, opts, queryOptions) {
   opts = opts || {};
   var controller = new AbortController();
   var handle;
-  var closed = false;
+  var closing;
   function close() {
-    if (handle && !closed) {
-      closed = true;
-      try { handle.close(); } catch (error) { controller.abort(); }
+    if (handle && !closing) {
+      try { closing = Promise.resolve(handle.close()); }
+      catch (error) { closing = Promise.reject(error); }
+      closing.catch(function () { controller.abort(); });
     }
+    return closing;
   }
   var rejectAbort;
   var cancelled = new Promise(function (resolve, reject) { rejectAbort = reject; });
@@ -39,7 +41,7 @@ async function generateTitle(adapter, messages, opts, queryOptions) {
     rejectAbort(new Error("Title request aborted or timed out"));
     close();
   }
-  var timer = setTimeout(abort, 30000);
+  var timer = setTimeout(abort, opts.timeoutMs || 30000);
   if (opts.signal) opts.signal.addEventListener("abort", abort, { once: true });
   var request = Promise.resolve().then(async function () {
     if (opts.signal && opts.signal.aborted) { abort(); throw new Error("Title request aborted"); }
@@ -69,12 +71,21 @@ async function generateTitle(adapter, messages, opts, queryOptions) {
     }
     throw new Error("Title request ended without a successful result");
   });
+  var title;
+  var failure;
   try {
-    return await Promise.race([request, cancelled]);
+    try { title = await Promise.race([request, cancelled]); }
+    catch (error) { failure = error; }
+    // Keep the overall deadline armed while cleanup is pending. A late handle
+    // still initiates close through the request continuation, with rejection
+    // observed by close(), even after this caller has been released.
+    try { await Promise.race([close(), cancelled]); }
+    catch (error) { if (!failure) failure = error; }
+    if (failure) throw failure;
+    return title;
   } finally {
     clearTimeout(timer);
     if (opts.signal) opts.signal.removeEventListener("abort", abort);
-    close();
   }
 }
 

package/lib/yoke/tui-transcript-index.js

@@ -0,0 +1,132 @@
+// tui-transcript-index.js
+//
+// Build a per-session index of assistant text messages from a Claude Code
+// TUI transcript (~/.claude/projects/{encoded-cwd}/{cliSessionId}.jsonl).
+//
+// The TUI message-grab feature uses this index on the client to map a
+// hovered xterm region back to its original markdown source. We only
+// extract assistant text blocks. Tool calls and tool results render in
+// the terminal in a shape that's quite different from their JSONL form,
+// so matching them would be noisy and not particularly useful.
+//
+// Codex sessions don't write transcripts at all; callers should skip
+// indexing for non-claude vendors.
+
+var fs = require("fs");
+var path = require("path");
+var utils = require("../utils");
+var { REAL_HOME } = require("../config");
+
+var encodeCwd = utils.encodeCwd;
+
+// Min length of a normalized assistant message to bother indexing.
+// Anything shorter ("ok", "sure", "yes") would generate too many false
+// positives when matched against a hovered terminal block.
+var MIN_MATCH_LEN = 20;
+
+// Claude Code writes its JSONL under the *running user's* home, which
+// is not the daemon's home in OS-isolation mode (where each Clay user
+// gets a real Linux account like /home/clay-name). Callers from the
+// project context resolve the session owner's home and pass it in;
+// when no home is provided we fall back to REAL_HOME for single-user
+// installs.
+function transcriptFilePath(home, cwd, cliSessionId) {
+  if (!cwd || !cliSessionId) return null;
+  var base = home || REAL_HOME;
+  return path.join(base, ".claude", "projects", encodeCwd(cwd), cliSessionId + ".jsonl");
+}
+
+// matchKey is just whitespace-normalized raw markdown. We intentionally
+// do NOT strip markdown decoration here.
+//
+// Reasoning: TUI rendering drops markdown markers (**bold** -> bold,
+// `code` -> code, [text](url) -> text, etc.) and the visible text is
+// therefore always a substring of the JSONL source's character stream.
+// If we strip server-side we risk getting the rules wrong on corner
+// cases (double-backtick code spans, list-bullet rendering quirks,
+// nested formatting) and the resulting matchKey diverges from both
+// sides at once. Leaving the source alone and letting the client do a
+// multi-offset substring probe against block text is more robust and
+// much less code.
+function normalizeForMatch(s) {
+  if (!s) return "";
+  return s.replace(/\s+/g, " ").trim();
+}
+
+// Stable per-message id. Claude's JSONL usually carries one of these but
+// fall back to the parsed line index so the client always has a handle.
+function messageId(obj, index) {
+  if (obj && obj.uuid) return String(obj.uuid);
+  if (obj && obj.message && obj.message.id) return String(obj.message.id);
+  return "msg-" + index;
+}
+
+// Parse a single JSONL line into one assistant-text record, or null
+// when the line isn't one we index (user prompts, tool_use blocks,
+// tool_result records, etc.). Text-only assistant blocks get joined
+// in order so a multi-block response surfaces as a single grabbable
+// message.
+function parseAssistantTextLine(line, index) {
+  var obj;
+  try { obj = JSON.parse(line); } catch (e) { return null; }
+  if (!obj || !obj.message) return null;
+  if (obj.message.role !== "assistant") return null;
+  if (!Array.isArray(obj.message.content)) return null;
+
+  var text = "";
+  for (var i = 0; i < obj.message.content.length; i++) {
+    var block = obj.message.content[i];
+    if (block && block.type === "text" && typeof block.text === "string") {
+      text += block.text;
+    }
+  }
+  text = text.trim();
+  if (!text) return null;
+
+  var normalized = normalizeForMatch(text);
+  if (normalized.length < MIN_MATCH_LEN) return null;
+
+  return {
+    id: messageId(obj, index),
+    text: text,
+    matchKey: normalized,
+  };
+}
+
+// Read the whole transcript and return the assistant text index. The
+// transcripts are small enough (KB to a few MB) that a sync read on
+// session open or on a watcher-driven update is fine. We also return
+// the mtime/size so callers can short-circuit re-reads when nothing
+// changed.
+function readAssistantIndex(home, cwd, cliSessionId) {
+  var file = transcriptFilePath(home, cwd, cliSessionId);
+  if (!file) return { messages: [], mtimeMs: 0, byteLength: 0 };
+  var raw;
+  var stat;
+  try {
+    raw = fs.readFileSync(file, "utf8");
+    stat = fs.statSync(file);
+  } catch (e) {
+    return { messages: [], mtimeMs: 0, byteLength: 0 };
+  }
+  var lines = raw.split("\n");
+  var messages = [];
+  for (var i = 0; i < lines.length; i++) {
+    if (!lines[i]) continue;
+    var entry = parseAssistantTextLine(lines[i], i);
+    if (entry) messages.push(entry);
+  }
+  return {
+    messages: messages,
+    mtimeMs: stat.mtimeMs || 0,
+    byteLength: stat.size || raw.length,
+  };
+}
+
+module.exports = {
+  MIN_MATCH_LEN: MIN_MATCH_LEN,
+  transcriptFilePath: transcriptFilePath,
+  readAssistantIndex: readAssistantIndex,
+  parseAssistantTextLine: parseAssistantTextLine,
+  normalizeForMatch: normalizeForMatch,
+};

package/lib/yoke/usage.js

@@ -0,0 +1,48 @@
+function number() {
+  for (var i = 0; i < arguments.length; i++) if (typeof arguments[i] === 'number' && Number.isFinite(arguments[i]) && arguments[i] >= 0) return arguments[i];
+  return null;
+}
+function accounting(value) {
+  if (!value) return null;
+  return Object.assign({}, value, { inputTokens: number(value.inputTokens, value.input_tokens), outputTokens: number(value.outputTokens, value.output_tokens),
+    cacheReadInputTokens: number(value.cacheReadInputTokens, value.cache_read_input_tokens), cacheCreationInputTokens: number(value.cacheCreationInputTokens, value.cache_creation_input_tokens) });
+}
+function validateProjection(value) {
+  value = value || {};
+  var used = number(value.usedTokens), window = number(value.windowTokens);
+  var measurement = ['observed', 'estimated', 'unavailable'].indexOf(value.measurement) >= 0 ? value.measurement : 'unavailable';
+  var inflated = used !== null && window !== null && used > window;
+  if (inflated || used === null || measurement === 'unavailable') { used = null; measurement = 'unavailable'; }
+  return { usedTokens: used, windowTokens: window, measurement: measurement, source: inflated || measurement === 'unavailable' && window === null ? 'unavailable' : typeof value.source === 'string' ? value.source : 'unavailable' };
+}
+function context(value, provider) {
+  if (!value) return null;
+  if (value.context && value.context.measurement) return Object.assign({}, value, { context: validateProjection(value.context) });
+  var policy = require('./provider-contract').resolve(provider);
+  var projection = typeof policy.normalizeContext === 'function' ? policy.normalizeContext(value) : { usedTokens: null, windowTokens: null, measurement: 'unavailable', source: 'unavailable' };
+  return Object.assign({}, value, { context: validateProjection(projection) });
+}
+function sdkContext(value) { return { usedTokens: number(value.totalTokens), windowTokens: number(value.maxTokens), measurement: value.unavailable ? 'unavailable' : value.measurement === 'estimated' ? 'estimated' : 'observed', source: 'claude_sdk_context_usage' }; }
+function tokenContext(value) { return { usedTokens: number(value.input_tokens), windowTokens: number(value.contextWindow), measurement: value.unavailable ? 'unavailable' : value.measurement === 'estimated' ? 'estimated' : 'observed', source: 'adapter_context_usage' }; }
+function turnContext(event) {
+  var models = event.modelUsage || {}, entries = Object.keys(models);
+  var result = { usedTokens: null, windowTokens: null, measurement: 'unavailable', source: 'unavailable' };
+  for (var i = 0; i < entries.length; i++) {
+    var value = models[entries[i]], snapshot = value.contextSnapshot;
+    if (snapshot) return { usedTokens: snapshot.valid === true ? number(snapshot.inputTokens) : null, windowTokens: number(snapshot.contextWindow, value.contextWindow), measurement: snapshot.valid === true ? 'observed' : 'unavailable', source: 'last_turn' };
+    result.windowTokens = number(value.contextWindow, result.windowTokens);
+  }
+  // Per-query accounting can contain many API calls. Never use its sum as
+  // current occupancy. Only an actual last-call measurement is a valid estimate.
+  result.usedTokens = number(event.lastStreamInputTokens);
+  if (result.usedTokens !== null) { result.measurement = 'estimated'; result.source = 'last_call'; }
+  return result;
+}
+function clientEvent(event, provider) {
+  if (!event) return event;
+  var info = require('./provider-contract').resolve(provider);
+  if ((event.type === 'rate_limit' || event.type === 'rate_limit_usage') && !event.source && info.requiresQuotaSource) return Object.assign({}, event, { ignored: true });
+  if (event.type !== 'result') return event;
+  return Object.assign({}, event, { usage: accounting(event.usage), context: validateProjection(event.context || turnContext(event)) });
+}
+module.exports = { number: number, accounting: accounting, context: context, sdkContext: sdkContext, tokenContext: tokenContext, turnContext: turnContext, clientEvent: clientEvent };

package/lib/yoke/user-input.js

@@ -246,6 +246,7 @@ function capability(adapter) {
 }
 
 function selectMode(adapter, requestedMode) {
+  if (requestedMode !== undefined && ["auto", "native", "fallback"].indexOf(requestedMode) < 0) throw new Error("Unsupported structured input mode.");
   if (requestedMode === "fallback") return "fallback";
   if (requestedMode === "native" && capability(adapter).mode !== "native") {
     throw new Error("This provider does not support native structured user input.");
@@ -260,7 +261,19 @@ function createFallbackServer(adapter, handler) {
   return adapter.createToolServer({ name: "yoke-user-input", version: "1.0.0", tools: fallbackToolDefs(handler, opts) });
 }
 
+// AskUserQuestion is also the normalized legacy question-tool identity in
+// stored Clay transcripts. Adapters may translate another native shape.
+function toolQuestions(adapter, name, input) {
+  var contract = require("./session-tool-transport").contract(adapter);
+  if (typeof contract.questionInput === "function") {
+    var nativeInput = contract.questionInput(name, input);
+    if (nativeInput) return nativeInput;
+  }
+  return name === "AskUserQuestion" || name === TOOL_NAME ? input : null;
+}
+
 module.exports = {
+  toolQuestions: toolQuestions,
   TOOL_NAME: TOOL_NAME,
   normalizeQuestions: normalizeQuestions,
   questionsFromElicitation: questionsFromElicitation,

package/lib/yoke/vendor-registry.js

@@ -1,6 +1,6 @@
 // Static, init-free facts about each vendor YOKE supports. Host code that
 // needs metadata before adapter initialization should read it from here.
-// Do not import adapters into this module.
+// Only init-free contract data may be imported here; never runtime adapters.
 
 // Canonical effort ordering used to clamp a level onto a vendor that does
 // not support it (e.g. codex "minimal" -> claude "low", claude "max" ->
@@ -10,6 +10,26 @@ var EFFORT_ORDER = ["minimal", "low", "medium", "high", "xhigh", "max"];
 // sessionBoundTools gates whether per-session MCP tool mounting reaches a vendor's process.
 var VENDOR_REGISTRY = {
   claude: {
+    readSessionHistory: require("./cli-sessions").readCliSessionHistory,
+    terminalResumeCommand: "claude --resume",
+    planPathSegments: [".claude/plans/"],
+    notificationHooks: require("./claude-hook-installer"),
+    maintenance: require("./claude-maintenance"),
+    credentialDirectories: [".claude"],
+    preferredModelFamilies: ["opus", "sonnet", "haiku"],
+    provisionUser: require("./providers/claude-provision").attachProvisioning,
+    configuration: require("./configuration").claude,
+    normalizeContext: require("./usage").sdkContext, authenticationReply: require("./auth-events").authenticationReply,
+    rateLimitScheduling: true, acceptsUnstampedQuota: true,
+    terminalLoginCommand: "claude auth login", browserLoginCommand: "claude auth login",
+    oauthHosts: ["claude.ai", "claude.com", "console.anthropic.com", "platform.claude.com"],
+    resolveExecutable: require("./discovery").bundledResolver(function() { return require("./providers/claude-executable").resolve(); }, "claude"),
+    processControl: require("./providers/claude-process"),
+    prepareIsolation: require("./providers/claude-process").prepareIsolation,
+    recoveryFactory: require("./claude-response-recovery").attachResponseRecovery,
+    supportsLegacyGuiResume: function(session) { return !!session.cliSessionId; },
+    mapQueryOptions: require("./options/claude").map,
+    queryContract: require("./adapters/claude-query-contract"),
     displayName: "Claude Code",
     loginCommand: "claude login",
     binaryName: "claude",
@@ -27,6 +47,16 @@ var VENDOR_REGISTRY = {
     rateLimitTracking: true,
   },
   codex: {
+    credentialDirectories: [".codex"],
+    preferredModelFamilies: ["astra", "sol", "gpt", "o"],
+    classifyError: require("./providers/codex-errors").classify,
+    settings: require("./options/codex-settings"),
+    configuration: require("./configuration").codex,
+    normalizeContext: require("./usage").tokenContext, requiresQuotaSource: true,
+    browserLoginCommand: "codex login", oauthHosts: ["auth.openai.com"],
+    resolveExecutable: require("./discovery").bundledResolver(function() { return require("./codex-app-server").findCodexPath(); }, "codex"),
+    mapQueryOptions: require("./options/codex").map,
+    queryContract: require("./adapters/codex-query-contract"),
     displayName: "Codex",
     loginCommand: "codex login --device-auth",
     binaryName: "codex",
@@ -43,7 +73,27 @@ var VENDOR_REGISTRY = {
     },
     rateLimitTracking: true,
   },
+  muse: {
+    displayName: "Muse Code",
+    loginCommand: "muse",
+    binaryName: "muse",
+    avatar: "/muse-avatar.svg",
+    sessionModes: ["gui"],
+    effortLevels: ["none", "minimal", "low", "medium", "high", "xhigh", "max", "ultra"],
+    osUserIsolation: false,
+    sessionBoundTools: true,
+    usageDashboard: null,
+    rateLimitTracking: false,
+    forkHistoryBoundary: "completed-turn-inclusive",
+    resolveExecutable: require("./providers/muse-executable").resolve,
+    mapQueryOptions: require("./options/muse").map,
+    queryContract: require("./adapters/muse-query-contract"),
+    normalizeContext: require("./usage").tokenContext,
+    configuration: { auto: true, permissionModes: [{ value: "default", label: "Ask" }] },
+  },
   antigravity: {
+    resolveExecutable: require("./providers/antigravity-executable").resolve,
+    mapQueryOptions: require("./options/antigravity").map,
     displayName: "Antigravity CLI",
     loginCommand: "agy",
     binaryName: "agy",
@@ -56,6 +106,8 @@ var VENDOR_REGISTRY = {
     rateLimitTracking: false,
   },
   opencode: {
+    resolveExecutable: require("./discovery").acpResolver("opencode"),
+    mapQueryOptions: require("./options/acp").map,
     displayName: "OpenCode",
     loginCommand: "opencode auth login",
     binaryName: "opencode",
@@ -68,6 +120,8 @@ var VENDOR_REGISTRY = {
     rateLimitTracking: false,
   },
   kimi: {
+    resolveExecutable: require("./discovery").acpResolver("kimi"),
+    mapQueryOptions: require("./options/acp").map,
     displayName: "Kimi Code",
     loginCommand: "kimi login",
     binaryName: "kimi",
@@ -80,6 +134,8 @@ var VENDOR_REGISTRY = {
     rateLimitTracking: false,
   },
   grok: {
+    resolveExecutable: require("./discovery").acpResolver("grok"),
+    mapQueryOptions: require("./options/acp").map,
     displayName: "Grok Build",
     loginCommand: "grok login --device-auth",
     binaryName: "grok",
@@ -92,6 +148,8 @@ var VENDOR_REGISTRY = {
     rateLimitTracking: false,
   },
   copilot: {
+    resolveExecutable: require("./discovery").acpResolver("copilot"),
+    mapQueryOptions: require("./options/acp").map,
     displayName: "GitHub Copilot CLI",
     loginCommand: "copilot login",
     binaryName: "copilot",
@@ -104,6 +162,8 @@ var VENDOR_REGISTRY = {
     rateLimitTracking: false,
   },
   qwen: {
+    resolveExecutable: require("./discovery").acpResolver("qwen"),
+    mapQueryOptions: require("./options/acp").map,
     displayName: "Qwen Code",
     loginCommand: "qwen",
     binaryName: "qwen",
@@ -116,6 +176,8 @@ var VENDOR_REGISTRY = {
     rateLimitTracking: false,
   },
   junie: {
+    resolveExecutable: require("./discovery").acpResolver("junie"),
+    mapQueryOptions: require("./options/acp").map,
     displayName: "Junie CLI",
     loginCommand: "junie",
     binaryName: "junie",
@@ -128,6 +190,9 @@ var VENDOR_REGISTRY = {
     rateLimitTracking: false,
   },
   kiro: {
+    normalizeContext: require("./usage").tokenContext,
+    resolveExecutable: require("./discovery").bundledResolver(function() { return require("./kiro-acp-server").findKiroPath(); }, "kiro-cli"),
+    mapQueryOptions: require("./options/kiro").map,
     displayName: "Kiro CLI",
     loginCommand: "kiro-cli login",
     binaryName: "kiro-cli",
@@ -169,7 +234,22 @@ function clampEffort(vendor, effort) {
   return nearest;
 }
 
+// Publish only serializable product descriptions, never backend services.
+function publicInfo() {
+  var result = {};
+  Object.keys(VENDOR_REGISTRY).forEach(function(vendor) {
+    var info = VENDOR_REGISTRY[vendor], entry = {};
+    ["displayName", "terminalResumeCommand", "planPathSegments", "loginCommand", "binaryName", "avatar", "sessionModes", "effortLevels", "osUserIsolation", "sessionBoundTools", "usageDashboard", "rateLimitTracking", "rateLimitScheduling", "acceptsUnstampedQuota", "configuration"].forEach(function(key) {
+      if (info[key] !== undefined) entry[key] = info[key];
+    });
+    entry.browserLoginSupported = typeof info.browserLoginCommand === "string" && Array.isArray(info.oauthHosts) && info.oauthHosts.length > 0;
+    result[vendor] = entry;
+  });
+  return result;
+}
+
 module.exports = {
+  publicInfo: publicInfo,
   VENDOR_REGISTRY: VENDOR_REGISTRY,
   getVendorInfo: getVendorInfo,
   clampEffort: clampEffort,