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

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 };

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

@@ -0,0 +1,97 @@
+var fs = require("fs");
+var path = require("path");
+var execFileSync = require("child_process").execFileSync;
+  function prepareIsolation(linuxUser, session, cwd) {
+    try {
+      var configMod = require("../../config");
+      var osUsersMod = require("../../os-users");
+      var originalHome = configMod.REAL_HOME || require("os").homedir();
+      var linuxUserHome = osUsersMod.getLinuxUserHome(linuxUser);
+      var uid = osUsersMod.getLinuxUserUid(linuxUser);
+      if (originalHome !== linuxUserHome && uid != null) {
+        var projectSlug = (cwd || "").replace(/\//g, "-");
+        var dstDir = path.join(linuxUserHome, ".claude", "projects", projectSlug);
+        // Create and chown the project directory once
+        if (!fs.existsSync(dstDir)) {
+          fs.mkdirSync(dstDir, { recursive: true });
+          try { execFileSync("chown", ["-R", String(uid), path.join(linuxUserHome, ".claude")]); } catch (e2) {}
+        } else {
+          try {
+            var dirStat = fs.statSync(dstDir);
+            if (dirStat.uid !== uid) {
+              execFileSync("chown", [String(uid), dstDir]);
+            }
+          } catch (e2) {}
+        }
+        // Pre-copy CLI session file so the worker can resume the conversation
+        if (session.cliSessionId) {
+          var sessionFileName = session.cliSessionId + ".jsonl";
+          var srcFile = path.join(originalHome, ".claude", "projects", projectSlug, sessionFileName);
+          var dstFile = path.join(dstDir, sessionFileName);
+          if (fs.existsSync(srcFile) && !fs.existsSync(dstFile)) {
+            fs.copyFileSync(srcFile, dstFile);
+            try { execFileSync("chown", [String(uid), dstFile]); } catch (e2) {}
+            console.log("[sdk-bridge] Pre-copied CLI session " + session.cliSessionId + " to " + linuxUser);
+          }
+        }
+      }
+    } catch (copyErr) {
+      console.log("[sdk-bridge] Dir setup / session pre-copy skipped:", copyErr.message);
+    }
+  }
+  function findConflicts(cwd) {
+    try {
+      var output = execFileSync("ps", ["ax", "-o", "pid,command"], { encoding: "utf8", timeout: 5000, stdio: ["pipe", "pipe", "pipe"] });
+      var lines = output.trim().split("\n");
+      var candidates = [];
+      for (var i = 1; i < lines.length; i++) { // skip header
+        var line = lines[i].trim();
+        var m = line.match(/^(\d+)\s+(.+)/);
+        if (!m) continue;
+        var pid = parseInt(m[1], 10);
+        var cmd = m[2];
+        // Skip our own process
+        if (pid === process.pid) continue;
+        // Skip node processes (our daemon, dev watchers, etc.)
+        if (/\bnode\b/.test(cmd.split(/\s/)[0])) continue;
+        // Match actual claude binary (e.g. /Users/x/.claude/local/claude, /usr/local/bin/claude)
+        if (/\/claude(\s|$)/.test(cmd) || /^claude(\s|$)/.test(cmd)) {
+          candidates.push({ pid: pid, command: cmd.substring(0, 200) });
+        }
+      }
+
+      // Filter to only processes whose cwd matches our project
+      var results = [];
+      for (var j = 0; j < candidates.length; j++) {
+        var c = candidates[j];
+        try {
+          // Use /proc/<pid>/cwd symlink (always available on Linux, no lsof dependency)
+          var procCwd = fs.readlinkSync("/proc/" + c.pid + "/cwd");
+          if (procCwd === cwd) {
+            results.push(c);
+          }
+        } catch (e) {
+          // /proc read failed — include as candidate anyway (conservative)
+          results.push(c);
+        }
+      }
+      return results;
+    } catch (e) {
+      return [];
+    }
+  }
+
+  /**
+   * Verify that a PID is actually a claude binary process (not arbitrary).
+   */
+  function verifyProcess(pid) {
+    try {
+      var output = execFileSync("ps", ["-p", String(pid), "-o", "command="], { encoding: "utf8", timeout: 3000, stdio: ["pipe", "pipe", "pipe"] }).trim();
+      return /\/claude(\s|$)/.test(output) || /^claude(\s|$)/.test(output);
+    } catch (e) {
+      return false;
+    }
+  }
+
+function shouldInspect(error) { return error.exitCode === 1 || error.message && error.message.indexOf("exited with code 1") >= 0; }
+module.exports = { shouldInspect: shouldInspect, prepareIsolation: prepareIsolation, findConflicts: findConflicts, verifyProcess: verifyProcess };

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

@@ -0,0 +1,75 @@
+var fs = require("fs"), path = require("path");
+var execFileSync = require("child_process").execFileSync;
+function attachProvisioning(ctx) {
+  var isSafeLinuxUsername = ctx.isSafeLinuxUsername;
+  var resolveOsUserInfo = ctx.resolveOsUserInfo;
+function claudeAvailableForUser(linuxName) {
+  if (!isSafeLinuxUsername(linuxName)) return false;
+  try {
+    var out = execFileSync("su", ["-", linuxName, "-c", "command -v claude"], {
+      encoding: "utf8",
+      timeout: 10000,
+      stdio: "pipe",
+    }).trim();
+    return out.length > 0;
+  } catch (e) {
+    return false;
+  }
+}
+
+/**
+ * Install Claude CLI for a Linux user account.
+ * Downloads and runs the install script, then ensures PATH is configured.
+ * Non-fatal: logs errors but does not throw.
+ * Skips entirely when claude is already resolvable for the user, or when
+ * CLAY_SKIP_CLAUDE_INSTALL is set (bring-your-own-claude).
+ */
+function installClaudeCli(linuxName) {
+  if (process.env.CLAY_SKIP_CLAUDE_INSTALL) {
+    console.log("[os-users] CLAY_SKIP_CLAUDE_INSTALL set, skipping Claude CLI install for " + linuxName);
+    return;
+  }
+  if (claudeAvailableForUser(linuxName)) {
+    console.log("[os-users] Claude CLI already available for " + linuxName + ", skipping install");
+    return;
+  }
+  try {
+    if (!isSafeLinuxUsername(linuxName)) throw new Error("Invalid Linux username");
+    // Download and run the Claude CLI install script as the target user
+    execFileSync("su", ["-", linuxName, "-c", "curl -fsSL https://claude.ai/install.sh | bash"], {
+      encoding: "utf8",
+      timeout: 60000,
+      stdio: "pipe",
+    });
+    console.log("[os-users] Claude CLI installed for " + linuxName);
+  } catch (e) {
+    var msg = (e.stderr || e.message || "").trim();
+    console.error("[os-users] Failed to install Claude CLI for " + linuxName + ": " + msg);
+    return;
+  }
+
+  // Append PATH export to the user's shell config if not already present
+  try {
+    var userInfo = resolveOsUserInfo(linuxName);
+    var home = userInfo.home || ("/home/" + linuxName);
+    var rcPath = fs.existsSync(path.join(home, ".zshrc")) ? path.join(home, ".zshrc") : path.join(home, ".bashrc");
+    var exportLine = 'export PATH="$HOME/.local/bin:$PATH"';
+    var existing = "";
+    try { existing = fs.readFileSync(rcPath, "utf8"); } catch (e2) {}
+    if (existing.indexOf(exportLine) === -1) {
+      var prefix = existing && !/\n$/.test(existing) ? "\n" : "";
+      fs.appendFileSync(rcPath, prefix + exportLine + "\n", "utf8");
+      try { fs.chownSync(rcPath, userInfo.uid, userInfo.gid); } catch (e3) {}
+      console.log("[os-users] PATH export appended to " + rcPath + " for " + linuxName);
+    } else {
+      console.log("[os-users] PATH already configured in " + rcPath + " for " + linuxName);
+    }
+  } catch (e) {
+    var rcMsg = (e.stderr || e.message || "").trim();
+    console.error("[os-users] Failed to configure PATH for " + linuxName + ": " + rcMsg);
+  }
+}
+
+return { available: claudeAvailableForUser, install: installClaudeCli };
+}
+module.exports = { attachProvisioning: attachProvisioning };

package/lib/yoke/providers/codex-errors.js

@@ -0,0 +1,8 @@
+function classify(text) {
+  if (/thread-store conflict|already has an active writer/i.test(String(text))) return {
+    kind: 'session_writer_conflict',
+    text: 'This Codex session is already open in another Clay or Codex process. Stop the other server or close the other session, then try again.',
+  };
+  return null;
+}
+module.exports = { classify: classify };

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

@@ -0,0 +1,17 @@
+// Discovery and startup share this resolver; an invalid override never falls back.
+var path = require("path");
+var discovery = require("../discovery");
+var onPath = discovery.pathResolver("muse");
+function resolve(options) {
+  options = options || {};
+  if (options.user || options.linuxUser || options.osUsers) return null;
+  var env = options.env || process.env;
+  var explicit = discovery.explicitEntry(env, "MUSE_CODE_PATH", false);
+  if (explicit !== undefined) return explicit;
+  var found = onPath(options);
+  if (found) return found;
+  var home = options.home || require("../../config").REAL_HOME || require("os").homedir();
+  var local = path.join(home, ".local", "bin", process.platform === "win32" ? "muse.exe" : "muse");
+  return discovery.validEntry(local, false) ? local : null;
+}
+module.exports = { resolve: resolve };

package/lib/yoke/provisioning.js

@@ -0,0 +1,6 @@
+function forProvider(provider, context) {
+  var service = require("./provider-contract").resolve(provider).provisionUser;
+  if (typeof service !== "function") throw new Error("Provider account provisioning is unavailable.");
+  return service(context);
+}
+module.exports = { forProvider: forProvider };