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

package/lib/yoke/muse-runtime.js

@@ -0,0 +1,211 @@
+var queryAbort = require("./query-abort");
+
+var initializeTimeoutMs = require("./interface").INITIALIZE_TIMEOUT_MS;
+
+function isAuthError(error) {
+  var kind = error && (error.kind || error.data && error.data.kind);
+  return kind === "authRequired" || /authentication|not authenticated|sign[ -]?in|log[ -]?in|credential|unauthorized|forbidden|api.?key|401/i.test(String(error && error.message || error || ""));
+}
+
+function closeResource(resource) {
+  if (!resource || typeof resource.close !== "function") return Promise.resolve();
+  return Promise.resolve().then(function() {
+    return resource.close();
+  });
+}
+// Own the process before initialize starts, including callers still opening a session.
+
+function createRuntime(adapter, sdk, options) {
+  var scope = queryAbort.createAbortScope();
+  var handshake = sdk.spawnMspConnection(Object.assign({}, options, {
+    shutdownTimeoutMs: adapter.shutdownTimeoutMs
+  }));
+  var closing = null;
+  var runtime = {
+    handshake: handshake,
+    spawned: null,
+    connection: null,
+    session: null,
+    held: [],
+    opening: true,
+    dead: false,
+    wait: scope.wait,
+    check: scope.check,
+    waitRequest: async function(promise, timeoutMs) {
+      var timer;
+      try {
+        return await scope.wait(Promise.race([ promise, new Promise(function(resolve, reject) {
+          timer = setTimeout(function() {
+            reject(new Error("Muse Code request timed out"));
+          }, timeoutMs || adapter.requestTimeoutMs);
+        }) ]));
+      } finally {
+        clearTimeout(timer);
+      }
+    },
+    fail: function(error) {},
+    onFrame: function(frame) {},
+    apply: function(frame) {
+      if (!runtime.session || scope.stopped()) return;
+      var named = frame.params && frame.params.sessionId;
+      if (named !== runtime.session.sessionId) return;
+      if (frame.method === "view/gap") {
+        runtime.fail(new Error("Muse view stream has a gap; Stop retired this attempt. Resume explicitly to reconcile the session."));
+        return;
+      }
+      try {
+        var applied = runtime.session.apply(frame);
+        if (applied.fold.kind !== "item" || applied.fold.outcome.kind !== "ignoredStaleRevision") runtime.onFrame(frame);
+      } catch (error) {
+        runtime.fail(error);
+      }
+    },
+    close: function() {
+      if (closing) return closing;
+      scope.stop();
+      if (runtime.session) runtime.session.hostExited({
+        kind: "transportEof"
+      });
+      closing = closeResource(handshake).finally(function() {
+        adapter.clients.delete(runtime);
+      });
+      return closing;
+    },
+    initialize: async function() {
+      try {
+        runtime.spawned = await runtime.waitRequest(handshake.initialize({
+          clientInfo: {
+            name: "clay",
+            title: "Clay",
+            version: "1.0.0"
+          },
+          capabilities: {
+            requestedCapabilities: [ "sessionMcp" ],
+            userInputDialogs: options.userInputDialogs === true
+          }
+        }), initializeTimeoutMs);
+        runtime.connection = runtime.spawned.connection;
+        runtime.connection.onProtocolError(function(error) {
+          runtime.fail(error);
+        });
+        runtime.connection.closed.then(function() {
+          if (scope.stopped()) return;
+          runtime.dead = true;
+          if (runtime.session) runtime.session.hostExited({
+            kind: "transportEof"
+          });
+          runtime.fail(new Error("Muse Code transport closed unexpectedly"));
+        });
+        return runtime.spawned;
+      } catch (error) {
+        await runtime.close();
+        throw error;
+      }
+    }
+  };
+  function route(frame) {
+    if (scope.stopped()) return;
+    if (frame.method === "usage/changed") { runtime.onFrame(frame); return; }
+    if (runtime.opening) runtime.held.push(frame); else runtime.apply(frame);
+  }
+  handshake.onServerRequest(async function(request) {
+    if (request.method === "approval/request") {
+      route({
+        method: "approval/requested",
+        params: request.params
+      });
+      return {};
+    }
+    if (request.method === "userInput/request" && typeof runtime.onUserInput === "function") {
+      route({ method: "userInput/requested", params: request.params });
+      return {};
+    }
+    var error = new Error("Muse host requested an unsupported client dialog: " + request.method);
+    runtime.fail(error);
+    throw error;
+  });
+  adapter.clients.add(runtime);
+  handshake.onNotification(route);
+  if (typeof handshake.onProtocolError === "function") handshake.onProtocolError(function(error) {
+    runtime.fail(error);
+  });
+  if (handshake.child && handshake.child.exit) handshake.child.exit.then(function(exit) {
+    runtime.dead = true;
+    if (runtime.session) runtime.session.hostExited(exit);
+    if (!scope.stopped()) runtime.fail(new Error("Muse Code host exited: " + exit.kind));
+  }, function(error) {
+    if (!scope.stopped()) runtime.fail(error);
+  });
+  return runtime;
+}
+
+function normalizeCatalog(result) {
+  return (result.models || []).map(function(model) {
+    return {
+      value: model.modelId,
+      displayName: model.displayLabel || model.modelId,
+      description: model.description || "",
+      supportedEffortLevels: Array.isArray(model.variants) ? model.variants.filter(function(tier) {
+        return ["none", "minimal", "low", "medium", "high", "xhigh", "max", "ultra"].includes(tier);
+      }) : [],
+      providerId: model.providerId || result.providerId,
+      profileId: model.profileId == null ? result.profileId : model.profileId,
+      defaultReasoningEffort: model.defaultReasoningEffort,
+      isDefault: model.isDefault === true,
+      effortUnknown: !Array.isArray(model.variants),
+      catalogSource: result.source
+    };
+  });
+}
+
+function modelSelection(catalog, model) {
+  for (var i = 0; i < catalog.length; i++) {
+    if (catalog[i].value !== model) continue;
+    var selection = {
+      modelId: model,
+      displayLabel: catalog[i].displayName
+    };
+    if (catalog[i].providerId) selection.providerId = catalog[i].providerId;
+    if (catalog[i].profileId != null) selection.profileId = catalog[i].profileId;
+    return selection;
+  }
+  throw new Error("Muse model is not in the live model catalog: " + model);
+}
+// SDK 1.4.7 retains opening metadata but does not ingest its history. Seed once,
+// before the buffered live suffix; pending pointers await the host's full reissue.
+
+function seedHistory(session, opening, onFrame) {
+  if (opening.verb !== "session/resume") return;
+  var history = opening.result.history || {};
+  var snapshot = history.snapshot;
+  if (snapshot && snapshot.schemaVersion !== 1) throw new Error("Unsupported Muse snapshot schema version");
+  var items = history.items || snapshot && snapshot.state.items || [];
+  for (var i = 0; i < items.length; i++) {
+    var frame = {
+      method: "item/updated",
+      params: {
+        sessionId: session.sessionId,
+        item: items[i],
+        viewCursor: opening.result.viewCursor
+      }
+    };
+    session.apply(frame);
+    if (onFrame) onFrame(frame);
+  }
+  var active = snapshot && snapshot.state.activeTurn;
+  if (active) session.apply({
+    method: "turn/started",
+    params: Object.assign({}, active, {
+      sessionId: session.sessionId,
+      viewCursor: snapshot.viewCursor
+    })
+  });
+}
+
+module.exports = {
+  isAuthError: isAuthError,
+  createRuntime: createRuntime,
+  normalizeCatalog: normalizeCatalog,
+  modelSelection: modelSelection,
+  seedHistory: seedHistory
+};

package/lib/yoke/muse-services.js

@@ -0,0 +1,79 @@
+// Typed MSP operations; no arbitrary command forwarding or automatic effect replay.
+var runtimeTools = require("./muse-runtime");
+function attach(adapter) {
+  async function withRuntime(options, operation) {
+    options = options || {};
+    if (options.linuxUser || options.osUsers) throw new Error("Muse Code does not support OS-owner isolation");
+    if (adapter.shuttingDown) throw new Error("Muse Code adapter is shutting down");
+    if (!adapter.binaryPath) await adapter.init(options);
+    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: options.dir || adapter.cwd,
+      env: Object.assign({}, process.env),
+    });
+    runtime.fail = function() { runtime.close().catch(function(error) { adapter.lastCloseError = error; }); };
+    try {
+      var spawned = await runtime.initialize();
+      return await operation(runtime, spawned);
+    } finally { await runtime.close(); }
+  }
+  adapter.listSessionPage = function(options) {
+    options = options || {};
+    return withRuntime(options, async function(runtime, spawned) {
+      var params = { workspaceRoot: options.dir || adapter.cwd, limit: options.limit || 50 };
+      if (options.cursor != null) params.cursor = options.cursor;
+      var page = await runtime.waitRequest(spawned.connection.request("session/list", params));
+      if (!Array.isArray(page.sessions)) throw new Error("Invalid Muse session list");
+      return page;
+    });
+  };
+  adapter.listSessions = async function(options) {
+    var page = await adapter.listSessionPage(options);
+    page.sessions.nextCursor = page.nextCursor;
+    return page.sessions;
+  };
+  adapter.readSession = function(sessionId, options) {
+    if (typeof sessionId !== "string" || !sessionId) return Promise.reject(new Error("Muse read requires an exact session id"));
+    return withRuntime(options, function(runtime, spawned) {
+      return runtime.waitRequest(spawned.connection.request("session/read", { sessionId: sessionId, excludeItems: !(options && options.includeItems) }));
+    });
+  };
+  adapter.renameSession = function(sessionId, name, options) {
+    if (typeof sessionId !== "string" || !sessionId || typeof name !== "string" || !name.trim()) return Promise.reject(new Error("Muse rename requires an exact session and name"));
+    return withRuntime(options, async function(runtime, spawned) {
+      if (sdkDurability(spawned) !== "durable") throw new Error("Muse rename is unsupported by an ephemeral host");
+      await runtime.waitRequest(spawned.connection.command("session/resume", { sessionId: sessionId, excludeItems: true }));
+      return runtime.waitRequest(spawned.connection.command("session/rename", { sessionId: sessionId, name: name }));
+    });
+  };
+  adapter.forkSession = function(sessionId, options) {
+    options = options || {};
+    return withRuntime(options, async function(runtime, spawned) {
+      var params = { sessionId: sessionId, excludeItems: true };
+      if (options.upToMessageId) params.cutPoint = { lastTurnId: options.upToMessageId };
+      var result = await runtime.waitRequest(spawned.connection.command("session/fork", params));
+      if (!result.session || !result.session.sessionId) throw new Error("Muse fork returned no session id; inspect before retrying");
+      return { sessionId: result.session.sessionId, useLocalHistory: true };
+    });
+  };
+  adapter.readUsage = function(options) {
+    return withRuntime(options, async function(runtime, spawned) {
+      var result = await runtime.waitRequest(spawned.connection.request("usage/read", {}));
+      return result.usage || null;
+    });
+  };
+}
+function sdkDurability(spawned) { return spawned.initializeResult.sessionDurability; }
+function quotaEvent(usage) {
+  if (!usage || !Number.isFinite(usage.observedAtMs)) return null;
+  var windows = [];
+  ["window", "weekly"].forEach(function(key) {
+    var value = usage[key];
+    if (!value || !Number.isFinite(value.usedPercent) || value.usedPercent < 0 || !Number.isFinite(value.resetsAtMs)) return;
+    windows.push({ key: key, usedPercent: value.usedPercent, resetsAt: value.resetsAtMs / 1000,
+      windowDurationMins: key === "weekly" ? 10080 : value.windowDurationMins || null });
+  });
+  return { yokeType: "rate_limit", rateLimitInfo: { source: "account_snapshot", limitId: "muse", observedAtMs: usage.observedAtMs, windows: windows } };
+}
+module.exports = { attach: attach, quotaEvent: quotaEvent };

package/lib/yoke/muse-skills.js

@@ -0,0 +1,79 @@
+var discovery = require("./skill-discovery");
+function create(queryOpts, getRuntime, push, assertLive) {
+  var options = queryOpts.skillOptions;
+  var delivered = false;
+  var lastCatalog = "";
+  var lastIndex = "";
+  function available() {
+    assertLive();
+    var readOnly = queryOpts.adapterOptions && queryOpts.adapterOptions.MUSE && queryOpts.adapterOptions.MUSE.readOnly;
+    var allowed = !queryOpts.skipSkills && !readOnly && options && !options.disable && typeof options.isAvailable === "function" && options.isAvailable() === true;
+    if (!allowed && delivered) throw new Error("The skill query scope is no longer available");
+    return !!allowed;
+  }
+  function check() {
+    if (!available()) throw new Error("Skills require an authorized Clay query scope");
+  }
+  async function listNative() {
+    check();
+    var runtime = getRuntime();
+    if (!runtime || !runtime.session) throw new Error("Muse skills require an opened session");
+    var result = await runtime.waitRequest(runtime.connection.request("skill/list", { sessionId: runtime.session.sessionId }));
+    check();
+    if (!result || !Array.isArray(result.skills)) throw new Error("Muse returned an invalid native skill catalog");
+    return { skills: result.skills.filter(function(skill) {
+      // Clay-only names are delivered from private roots, never native installs.
+      return skill && typeof skill.selector === "string" && !/(?:^|:)clay-/.test(skill.selector);
+    }) };
+  }
+  function scopedOptions() {
+    var fs = require("fs");
+    return Object.assign({}, options, {
+      readDir: function(dir) { check(); return options.readDir ? options.readDir(dir) : fs.readdirSync(dir, { withFileTypes: true }); },
+      readFile: function(file) { check(); var content = options.readFile ? options.readFile(file) : fs.readFileSync(file, "utf8"); check(); return content; },
+      realpath: function(file) { check(); return options.realpath ? options.realpath(file) : fs.realpathSync(file); },
+    });
+  }
+  async function prepare(text, selected) {
+    if (!available()) {
+      if (selected) throw new Error("Skills require an authorized Clay query scope");
+      return { text: text, skill: null, scoped: false };
+    }
+    var native = await listNative();
+    var readOpts = scopedOptions();
+    var shared = discovery.discoverSkills(queryOpts.cwd, readOpts).filter(function(skill) {
+      return !/^clay-/.test(skill.name) || /^clay-/.test(skill.source);
+    });
+    check();
+    var slash = typeof text === "string" && /^\/([^\s/]+)(?:[ \t]([\s\S]*))?$/.exec(text);
+    var explicit = selected;
+    var referenceText = text;
+    if (slash) {
+      if (native.skills.some(function(skill) { return skill.selector === slash[1]; })) {
+        explicit = { selector: slash[1], arguments: slash[2] || "" };
+        text = "";
+      } else if (shared.some(function(skill) { return skill.name === slash[1]; })) {
+        referenceText = "$" + slash[1] + (slash[2] ? " " + slash[2] : "");
+        text = referenceText;
+      } else throw new Error("Skill is not in the current Muse or shared catalog: " + slash[1]);
+    }
+    if (explicit && !native.skills.some(function(skill) { return skill.selector === explicit.selector; })) throw new Error("Muse skill is not in the live session catalog");
+    var index = discovery.buildSkillIndex(shared);
+    var content = discovery.readReferencedSkills(referenceText, shared, 32768, readOpts);
+    if (discovery.findSkillReferences(referenceText, shared).length && !content) throw new Error("Shared skill instructions are unavailable");
+    check();
+    var commands = native.skills.map(function(skill) { return skill.selector; });
+    var names = shared.map(function(skill) { return skill.name; });
+    var catalog = JSON.stringify([commands, names]);
+    if (catalog !== lastCatalog) {
+      push({ yokeType: "commands_changed", commandNames: commands, skills: names });
+      lastCatalog = catalog;
+    }
+    var guidance = index && index !== lastIndex ? index + "\nNative /selector commands invoke Muse skills; $name references load shared instructions. If names collide, /name is native and $name is shared." : "";
+    lastIndex = index;
+    delivered = true;
+    return { text: [text, guidance, content].filter(Boolean).join("\n\n"), skill: explicit || null, scoped: true };
+  }
+  return { prepare: prepare, listNative: listNative, check: check };
+}
+module.exports = { create: create };

package/lib/yoke/muse-turns.js

@@ -0,0 +1,71 @@
+// Foreground completion is a non-terminal SDK fact. Continue following every
+// turn to its real outcome while releasing only the next submission boundary.
+function create(options) {
+  var state = options.state;
+  var turns = new Map();
+  function started(entry) {
+    if (entry.started || !entry.turn.observedStart) return;
+    entry.started = true;
+    options.push({ yokeType: 'turn_start', uuid: entry.turn.turnId, messageType: 'user', turnId: entry.turn.turnId });
+    options.push({ yokeType: 'turn_activity', phase: 'running', turnId: entry.turn.turnId });
+  }
+  function foreground(entry, params) {
+    if (entry.yielded || !params || !Array.isArray(params.blockingAgents) || !params.blockingAgents.length) return;
+    entry.yielded = true;
+    entry.release({ kind: 'foreground' });
+  }
+  function onFrame(frame) {
+    if (frame.method !== 'turn/foregroundCompleted' && frame.method !== 'turn/started') return;
+    var entry = turns.get(frame.params.turnId);
+    if (entry && frame.method === 'turn/started') { started(entry); return; }
+    var folded = state.session.fold.turn(frame.params.turnId);
+    if (entry && folded && folded.state === 'running') foreground(entry, folded.foregroundCompleted);
+  }
+  function follow(turn, report, sequence) {
+    var entry = { turn: turn, yielded: false };
+    var boundary = new Promise(function (resolve) { entry.release = resolve; });
+    turns.set(turn.turnId, entry);
+    state.liveTurnIds.add(turn.turnId);
+    started(entry);
+    var admission = state.session.pending.list().find(function (pending) { return pending.ack && pending.ack.turnId === turn.turnId; });
+    var existing = state.session.fold.turn(turn.turnId);
+    if (!entry.started && (!existing || existing.state === 'running')) options.push({
+      yokeType: 'turn_activity', phase: 'waiting', turnId: turn.turnId,
+      disposition: admission && admission.ack.disposition
+    });
+    options.ready();
+    var terminal = (async function () {
+      try {
+        for await (var item of turn.items()) {
+          if (state.stopped) return { kind: 'stopped' };
+          if (!options.renderer.hasItem(item.itemId)) options.renderer.emitItem(item);
+          await options.emitArtifact(item);
+        }
+        var outcome = await options.runtime().wait(turn.completed);
+        if (state.stopped) return { kind: 'stopped' };
+        options.renderer.closeBlocks(turn.turnId);
+        var event = options.outcomeEvent(outcome);
+        // A retired foreground turn cannot settle a newer turn's reviews or
+        // user-work completion callbacks when its reminder checks finish late.
+        if (event.yokeType === 'result' && entry.yielded && sequence < state.messageSequence) event.backgroundOnly = true;
+        if (report || event.yokeType !== 'result') options.push(event);
+        if (event.yokeType !== 'result') await options.close();
+        return { kind: 'terminal', outcome: outcome, event: event };
+      } catch (error) {
+        options.fail(error);
+        return { kind: 'failed' };
+      } finally {
+        turns.delete(turn.turnId);
+        state.liveTurnIds.delete(turn.turnId);
+        if (!state.stopped && !state.active && state.inputEnded && !turns.size) options.close().catch(options.fail);
+      }
+    })();
+    // Session.apply can receive this event before turn/start's acknowledgement.
+    var folded = state.session.fold.turn(turn.turnId);
+    if (folded && folded.state === 'running') foreground(entry, folded.foregroundCompleted);
+    return Promise.race([terminal, boundary]);
+  }
+  return { follow: follow, onFrame: onFrame, pending: function () { return turns.size > 0; },
+    background: function () { return Array.from(turns.values()).some(function (entry) { return entry.yielded; }); } };
+}
+module.exports = { create: create };

package/lib/yoke/options/acp.js

@@ -0,0 +1,2 @@
+function map(intent) { return { ACP: { mcpServers: intent.sessionBridge } }; }
+module.exports = { map: map };

package/lib/yoke/options/antigravity.js

@@ -0,0 +1,2 @@
+function map(intent) { return { ANTIGRAVITY: { dangerouslySkipPermissions: !intent.readOnly && (intent.nativeBypass || intent.permissionMode === "bypassPermissions") } }; }
+module.exports = { map: map };

package/lib/yoke/options/claude.js

@@ -0,0 +1,21 @@
+function map(intent) {
+  var options = { settingSources: intent.instructionSources || ["user", "project", "local"], includePartialMessages: true,
+    enableFileCheckpointing: true, extraArgs: { "replay-user-messages": null }, promptSuggestions: true, agentProgressSummaries: true };
+  if (intent.betas && intent.betas.length) options.betas = intent.betas;
+  var thinking = intent.thinking || {};
+  if (thinking.mode === "disabled") options.thinking = { type: "disabled" };
+  else if (thinking.mode === "budget" && thinking.budget) options.thinking = { type: "enabled", budgetTokens: thinking.budget };
+  else options.thinking = { type: "adaptive", display: "summarized" };
+  if (intent.disableHooks !== undefined) options.settings = { disableAllHooks: intent.disableHooks };
+  options.permissionMode = intent.nativePermissionMode || "default";
+  if (intent.nativeBypass && !intent.readOnly) { options.permissionMode = "bypassPermissions"; options.allowDangerouslySkipPermissions = true; }
+  if (intent.readOnly) { options.permissionMode = "default"; options.allowDangerouslySkipPermissions = false; }
+  if (intent.resumeAt) options.resumeSessionAt = intent.resumeAt;
+  if (intent.isolation && intent.isolation.user) {
+    var isolation = intent.isolation;
+    Object.assign(options, { linuxUser: isolation.user, originalHome: isolation.home, singleTurn: intent.singleTurn,
+      projectPath: isolation.projectPath, _perfT0: intent.startedAt, _workerState: isolation.workerState });
+  }
+  return { CLAUDE: options };
+}
+module.exports = { map: map };

package/lib/yoke/options/codex-defaults.js

@@ -0,0 +1,29 @@
+var CODEX_DEFAULTS = {
+  approval: "on-request",
+  sandbox: "danger-full-access",
+  webSearch: "live",
+};
+
+var CODEX_APPROVAL_POLICIES = ["untrusted", "on-request", "granular", "never"];
+
+function normalizeCodexApproval(value) {
+  if (value === "on-failure") return CODEX_DEFAULTS.approval;
+  if (CODEX_APPROVAL_POLICIES.indexOf(value) === -1) return CODEX_DEFAULTS.approval;
+  return value;
+}
+
+function getCodexConfig(sm) {
+  sm = sm || {};
+  return {
+    approval: normalizeCodexApproval(sm && sm.codexApproval),
+    sandbox: (sm && sm.codexSandbox) === undefined ? CODEX_DEFAULTS.sandbox : ["read-only", "workspace-write", "danger-full-access"].indexOf(sm.codexSandbox) >= 0 ? sm.codexSandbox : "read-only",
+    webSearch: (sm && sm.codexWebSearch) === undefined ? CODEX_DEFAULTS.webSearch : ["disabled", "cached", "live"].indexOf(sm.codexWebSearch) >= 0 ? sm.codexWebSearch : "disabled",
+  };
+}
+
+module.exports = {
+  CODEX_DEFAULTS: CODEX_DEFAULTS,
+  CODEX_APPROVAL_POLICIES: CODEX_APPROVAL_POLICIES,
+  normalizeCodexApproval: normalizeCodexApproval,
+  getCodexConfig: getCodexConfig,
+};

package/lib/yoke/options/codex-settings.js

@@ -0,0 +1,21 @@
+// Provider setting validation and legacy wire projection. The host owns
+// permission checks, the actual settings store and publication.
+var config = require('./codex-defaults');
+var actions = {
+  set_codex_approval: { key: 'codexApproval', input: 'approval', choices: config.CODEX_APPROVAL_POLICIES, fallback: config.CODEX_DEFAULTS.approval },
+  set_codex_sandbox: { key: 'codexSandbox', input: 'sandbox', choices: ['read-only', 'workspace-write', 'danger-full-access'], fallback: config.CODEX_DEFAULTS.sandbox },
+  set_codex_websearch: { key: 'codexWebSearch', input: 'webSearch', choices: ['disabled', 'cached', 'live'], fallback: config.CODEX_DEFAULTS.webSearch },
+};
+function defaults() { return { codexApproval: config.CODEX_DEFAULTS.approval, codexSandbox: config.CODEX_DEFAULTS.sandbox, codexWebSearch: config.CODEX_DEFAULTS.webSearch }; }
+function messages(settings) { return [Object.assign({ type: 'codex_config' }, config.getCodexConfig(settings))]; }
+function change(message, settings) {
+  var action = actions[message.type];
+  if (!action) return null;
+  var value = message[action.input];
+  if (value == null || value === '') value = action.fallback;
+  if (action.key === 'codexApproval' && value === 'on-failure') value = action.fallback;
+  if (action.choices.indexOf(value) < 0) throw new Error('Unsupported provider setting value.');
+  var patch = {}; patch[action.key] = value;
+  return { patch: patch, messages: messages(Object.assign({}, settings, patch)) };
+}
+module.exports = { defaults: defaults, messages: messages, change: change };

package/lib/yoke/options/codex.js

@@ -0,0 +1,6 @@
+function map(intent) {
+  var config = require("./codex-defaults").getCodexConfig(intent.settings);
+  return { CODEX: { approvalPolicy: "never", sandboxMode: intent.readOnly ? "read-only" : config.sandbox,
+    webSearchMode: intent.readOnly ? "disabled" : config.webSearch } };
+}
+module.exports = { map: map };

package/lib/yoke/options/kiro-defaults.js

@@ -0,0 +1,22 @@
+// Kiro-specific default values. Single source of truth — do not duplicate
+// elsewhere. Consumed by the server-side vendor plumbing and sent to clients
+// via the config state so the UI renders the right controls.
+
+var KIRO_DEFAULTS = {
+  // Kiro CLI 2.18.1 exposes the next-generation agent as the v3 engine. Its
+  // general-purpose mode id is "vibe" (displayed as "Default").
+  engine: "v3",
+  mode: "vibe",
+};
+
+function getKiroConfig(sm) {
+  return {
+    engine: (sm && sm.kiroEngine) || KIRO_DEFAULTS.engine,
+    mode: (sm && sm.kiroMode) || KIRO_DEFAULTS.mode,
+  };
+}
+
+module.exports = {
+  KIRO_DEFAULTS: KIRO_DEFAULTS,
+  getKiroConfig: getKiroConfig,
+};

package/lib/yoke/options/kiro.js

@@ -0,0 +1,5 @@
+function map(intent) {
+  var config = require("./kiro-defaults").getKiroConfig(intent.settings);
+  return { KIRO: { engine: config.engine, mode: config.mode, mcpServers: intent.sessionBridge } };
+}
+module.exports = { map: map };

package/lib/yoke/options/muse.js

@@ -0,0 +1,5 @@
+function map(intent) {
+  if (intent.readOnly) throw new Error("Muse SDK 1.4.7 cannot enforce the curator read-only sandbox contract");
+  return { MUSE: { mcpServers: intent.readOnly ? [] : intent.sessionBridge || [], readOnly: intent.readOnly === true } };
+}
+module.exports = { map: map };

package/lib/yoke/provider-contract.js

@@ -0,0 +1,5 @@
+function resolve(provider) {
+  if (provider && typeof provider === "object" && provider.providerContract) return provider.providerContract;
+  return require("./vendor-registry").getVendorInfo(typeof provider === "string" ? provider : provider && provider.vendor) || {};
+}
+module.exports = { resolve: resolve };

package/lib/yoke/providers/antigravity-executable.js

@@ -0,0 +1,8 @@
+// One authoritative resolver for both installation discovery and adapter init.
+var resolvePath = require("../discovery").pathResolver("agy", "ANTIGRAVITY_CLI_PATH");
+function resolve(options) {
+  options = options || {};
+  if (options.user) return null;
+  return resolvePath(options);
+}
+module.exports = { resolve: resolve };

package/lib/yoke/providers/claude-executable.js

@@ -0,0 +1,40 @@
+var fs = require("fs");
+function resolveClaudeBinaryPath() {
+  // 1. Explicit env var override
+  var discovery = require("../discovery");
+  var explicit = discovery.explicitEntry(process.env, "CLAUDE_CODE_PATH", true);
+  if (explicit !== undefined) return explicit;
+
+  // 2. `which claude` in the daemon's PATH
+  try {
+    var result = require("child_process").execSync("which claude", { encoding: "utf8", timeout: 5000 }).trim();
+    if (discovery.validEntry(result, false)) 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 (discovery.validEntry(candidates[i], false)) 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 (discovery.validEntry(resolved, true)) return resolved;
+  } catch (e) {}
+
+  return null;
+}
+
+module.exports = { resolve: resolveClaudeBinaryPath };

package/lib/yoke/providers/claude-model-descriptions.js

@@ -0,0 +1,14 @@
+// Preserve existing model descriptions and beta availability at the provider boundary.
+var DESCRIPTIONS = { default: "Automatically selects the best model for the task.", sonnet: "Fast and capable. Great balance of speed and intelligence.", haiku: "Fastest model. Best for quick tasks and simple questions.", opus: "Most powerful model. Best for complex reasoning and analysis." };
+function describe(entry) {
+  var model = typeof entry === "string" ? { value: entry, displayName: entry } : Object.assign({}, entry);
+  var name = String(model.value || "").toLowerCase();
+  if (model.supportsBetaContext === undefined) model.supportsBetaContext = name.indexOf("sonnet") !== -1;
+  if (!model.description) {
+    var family = Object.keys(DESCRIPTIONS).find(function(key) { return name.indexOf(key) !== -1; });
+    if (family) model.description = DESCRIPTIONS[family];
+  }
+  return model;
+}
+function list(models) { return (models || []).map(describe); }
+module.exports = { describe: describe, list: list };