clay-server 3.3.2-beta.3 → 3.4.0-beta.2

package/lib/public/modules/input.js

@@ -7,6 +7,7 @@ import { mateAvatarUrl } from './avatar.js';
 import { tuiIsActive, tuiSubmitText } from './session-tui-view.js';
 import { VENDOR_AVATARS, VENDOR_NAMES } from './app-rendering.js';
 import { showToast } from './utils.js';
+import { isShellCommandMode, submitShellCommand } from './shell-command.js';
 
 var ctx;
 
@@ -75,6 +76,37 @@ export var builtinCommands = [
   { name: "status", desc: "Process status and resource usage" },
 ];
 
+function commitVendorForTurn() {
+  var committedVendor = store.get('currentVendor');
+  var vendorToggle = document.getElementById("vendor-toggle-wrap");
+  var activeIndicator = document.getElementById("active-vendor-indicator");
+  var activeIcon = document.getElementById("active-vendor-icon");
+  if (committedVendor) {
+    if (vendorToggle) {
+      vendorToggle.classList.add("hidden");
+      vendorToggle.classList.remove("locked");
+    }
+    if (activeIndicator && activeIcon) {
+      activeIcon.src = VENDOR_AVATARS[committedVendor] || VENDOR_AVATARS.claude;
+      activeIcon.alt = VENDOR_NAMES[committedVendor] || VENDOR_NAMES.claude;
+      activeIndicator.title = (VENDOR_NAMES[committedVendor] || VENDOR_NAMES.claude) + " session";
+      activeIndicator.classList.remove("hidden");
+    }
+  } else if (vendorToggle) {
+    vendorToggle.classList.remove("hidden");
+    vendorToggle.classList.add("locked");
+  }
+  store.set({ vendorSelectionLocked: false, sessionHasHistory: true });
+}
+
+function showPreThinkingForTurn() {
+  if (ctx.isMateDm && ctx.isMateDm()) {
+    ctx.showMatePreThinking();
+  } else if (ctx.showClaudePreThinking) {
+    ctx.showClaudePreThinking();
+  }
+}
+
 // --- Send ---
 export function sendMessage() {
   // Debate ended mode intercept: route to resume handler
@@ -92,6 +124,14 @@ export function sendMessage() {
     ctx.handleDebateFloorSend();
     return;
   }
+  if (isShellCommandMode()) {
+    var shellText = ctx.inputEl.value.trim();
+    if (!shellText || !submitShellCommand(shellText)) return;
+    ctx.inputEl.value = "";
+    sendInputSync();
+    autoResize();
+    return;
+  }
   // DM mode intercept: if in DM mode, route to DM handler instead
   if (ctx.isDmMode && ctx.isDmMode() && ctx.handleDmSend) {
     ctx.handleDmSend();
@@ -304,36 +344,10 @@ export function sendMessage() {
   // Bumping sessionHasHistory drives in-session lock states (e.g. the
   // Codex model picker that becomes informational once the thread is
   // bound to a model).
-  var _committedVendor = store.get('currentVendor');
-  var _vtw2 = document.getElementById("vendor-toggle-wrap");
-  var _avi = document.getElementById("active-vendor-indicator");
-  var _avIcon = document.getElementById("active-vendor-icon");
-  if (_committedVendor) {
-    if (_vtw2) {
-      _vtw2.classList.add("hidden");
-      _vtw2.classList.remove("locked");
-    }
-    if (_avi && _avIcon) {
-      _avIcon.src = VENDOR_AVATARS[_committedVendor] || VENDOR_AVATARS.claude;
-      _avIcon.alt = VENDOR_NAMES[_committedVendor] || VENDOR_NAMES.claude;
-      _avi.title = (VENDOR_NAMES[_committedVendor] || VENDOR_NAMES.claude) + " session";
-      _avi.classList.remove("hidden");
-    }
-  } else if (_vtw2) {
-    // No committed vendor (defensive — shouldn't happen because the
-    // input is otherwise gated on a vendor pick). Fall back to the
-    // locked toggle so the running vendor is still visible.
-    _vtw2.classList.remove("hidden");
-    _vtw2.classList.add("locked");
-  }
-  store.set({ vendorSelectionLocked: false, sessionHasHistory: true });
+  commitVendorForTurn();
 
   // Show pre-thinking dots before server responds
-  if (ctx.isMateDm && ctx.isMateDm()) {
-    ctx.showMatePreThinking();
-  } else if (ctx.showClaudePreThinking) {
-    ctx.showClaudePreThinking();
-  }
+  showPreThinkingForTurn();
 
   ctx.inputEl.value = "";
   sendInputSync();
@@ -354,6 +368,22 @@ export function sendTextMessage(text) {
   return true;
 }
 
+export function sendShellResultToAgent(msg) {
+  if (!ctx || !ctx.connected || !msg || msg.error || !msg.command) return false;
+  if (String(msg.sessionId) !== String(store.get("activeSessionId"))) return false;
+  var payload = {
+    type: "message",
+    text: "$ " + msg.command,
+    shellCommandResponse: true,
+  };
+  var selectedVendor = store.get("currentVendor") || null;
+  if (selectedVendor) payload.vendor = selectedVendor;
+  ctx.ws.send(JSON.stringify(payload));
+  commitVendorForTurn();
+  showPreThinkingForTurn();
+  return true;
+}
+
 export function autoResize() {
   ctx.inputEl.style.height = "auto";
   ctx.inputEl.style.height = Math.min(ctx.inputEl.scrollHeight, 120) + "px";

package/lib/public/modules/mate-sidebar.js

@@ -149,9 +149,15 @@ export function showMateSidebar(mateId, mateData) {
   if (mateVendorWrap) {
     var available = store.get('availableVendors') || [];
     var mateVendor = mateData.vendor || "claude";
-    var vendorIcons = { claude: "/claude-code-avatar.png", codex: "/codex-avatar.png", kiro: "/kiro-avatar.svg" };
-    var vendorNames = { claude: "Claude Code", codex: "Codex", kiro: "Kiro CLI" };
-    var vendorKeys = ["claude", "codex", "kiro"];
+    var vendorIcons = {
+      claude: "/claude-code-avatar.png",
+      codex: "/codex-avatar.png",
+      gemini: "/gemini-avatar.svg",
+      opencode: "/opencode-avatar.svg",
+      kiro: "/kiro-avatar.svg",
+    };
+    var vendorNames = { claude: "Claude Code", codex: "Codex", gemini: "Gemini CLI", opencode: "OpenCode", kiro: "Kiro CLI" };
+    var vendorKeys = ["claude", "codex", "gemini", "opencode", "kiro"];
     mateVendorWrap.innerHTML = "";
     for (var vi = 0; vi < vendorKeys.length; vi++) {
       var vk = vendorKeys[vi];

package/lib/public/modules/shell-command.js

@@ -0,0 +1,148 @@
+import { store } from './store.js';
+import { getWs } from './ws-ref.js';
+import { iconHtml, refreshIcons } from './icons.js';
+import { showToast } from './utils.js';
+
+var defaultPlaceholder = "";
+
+function getInput() {
+  return document.getElementById("input");
+}
+
+function appendToMessages(element) {
+  var messages = document.getElementById("messages");
+  if (!messages) return;
+  messages.appendChild(element);
+  requestAnimationFrame(function () { messages.scrollTop = messages.scrollHeight; });
+}
+
+function setMode(active) {
+  var input = getInput();
+  var button = document.getElementById("shell-command-btn");
+  var row = document.getElementById("input-row");
+  store.set({ shellCommandMode: active });
+  if (button) {
+    button.classList.toggle("active", active);
+    button.setAttribute("aria-pressed", active ? "true" : "false");
+  }
+  if (row) row.classList.toggle("shell-command-mode", active);
+  if (input) {
+    if (!defaultPlaceholder) defaultPlaceholder = input.placeholder;
+    input.placeholder = active ? "Run a shell command in this project…" : defaultPlaceholder;
+    input.focus();
+  }
+}
+
+export function isShellCommandMode() {
+  return !!store.get("shellCommandMode");
+}
+
+export function toggleShellCommandMode() {
+  if (store.get("shellCommandRunning")) return;
+  var target = store.get("dmTargetUser");
+  if (store.get("dmMode") && target && !target.isMate) {
+    showToast("Shell commands are available in agent sessions, not user DMs.", "error");
+    return;
+  }
+  setMode(!isShellCommandMode());
+}
+
+function renderPendingCommand(requestId, command) {
+  var card = document.createElement("div");
+  card.className = "shell-command-card running";
+  card.dataset.requestId = requestId;
+  card.innerHTML =
+    '<div class="shell-command-header">' +
+      '<span class="shell-command-icon">' + iconHtml("square-terminal") + '</span>' +
+      '<code></code><span class="shell-command-status">Running…</span>' +
+    '</div>' +
+    '<pre class="shell-command-output">Waiting for output…</pre>';
+  card.querySelector("code").textContent = "$ " + command;
+  appendToMessages(card);
+  refreshIcons();
+}
+
+export function submitShellCommand(command) {
+  command = String(command || "").trim();
+  if (!command || store.get("shellCommandRunning")) return false;
+  var ws = getWs();
+  if (!ws || ws.readyState !== 1) {
+    showToast("Not connected — command not run.", "error");
+    return false;
+  }
+
+  var requestId = "shell_" + Date.now() + "_" + Math.random().toString(36).slice(2, 9);
+  store.set({ shellCommandRunning: true, pendingShellCommandId: requestId });
+  var input = getInput();
+  if (input) {
+    input.disabled = true;
+    input.placeholder = "Running command…";
+  }
+  renderPendingCommand(requestId, command);
+  ws.send(JSON.stringify({ type: "shell_command", requestId: requestId, command: command }));
+  return true;
+}
+
+export function handleShellCommandResult(msg) {
+  var cards = document.querySelectorAll(".shell-command-card[data-request-id]");
+  var card = null;
+  for (var i = 0; i < cards.length; i++) {
+    if (cards[i].dataset.requestId === (msg.requestId || "")) {
+      card = cards[i];
+      break;
+    }
+  }
+  if (card) {
+    var status = card.querySelector(".shell-command-status");
+    var output = card.querySelector(".shell-command-output");
+    card.classList.remove("running");
+    if (msg.error) {
+      card.classList.add("error");
+      if (status) status.textContent = "Failed";
+      if (output) output.textContent = msg.error;
+    } else {
+      card.classList.toggle("error", msg.exitCode !== 0);
+      if (status) status.textContent = msg.timedOut ? "Timed out" : "Exit " + (msg.exitCode == null ? "—" : msg.exitCode);
+      if (output) output.textContent = msg.output || "(no output)";
+    }
+  }
+
+  store.set({ shellCommandRunning: false, pendingShellCommandId: null });
+  var input = getInput();
+  if (input) input.disabled = false;
+  if (msg.error) {
+    setMode(true);
+  } else {
+    setMode(false);
+  }
+  var messages = document.getElementById("messages");
+  if (messages) requestAnimationFrame(function () { messages.scrollTop = messages.scrollHeight; });
+}
+
+export function initShellCommand() {
+  var button = document.getElementById("shell-command-btn");
+  var mobileButton = document.getElementById("input-more-shell");
+  if (button) button.addEventListener("click", toggleShellCommandMode);
+  if (mobileButton) {
+    mobileButton.addEventListener("click", function () {
+      var sheet = document.getElementById("input-more-sheet");
+      if (sheet) {
+        sheet.classList.remove("open");
+        setTimeout(function () { sheet.classList.add("hidden"); }, 250);
+      }
+      toggleShellCommandMode();
+    });
+  }
+  store.subscribe(function (state, previous) {
+    if (previous.connected && !state.connected && state.shellCommandRunning) {
+      resetShellCommand();
+    }
+  });
+}
+
+export function resetShellCommand() {
+  store.set({ shellCommandMode: false, shellCommandRunning: false, pendingShellCommandId: null });
+  var input = getInput();
+  if (input) input.disabled = false;
+  setMode(false);
+}

package/lib/public/modules/sidebar-mates.js

@@ -457,7 +457,13 @@ export function renderUserStrip(allUsers, onlineUserIds, myUserId, dmFavorites,
       // Tooltip
       var displayName = mp.displayName || mate.name || "New Mate";
       var mateVendor = mate.vendor || "claude";
-      var vendorLabels = { claude: "Claude Code", codex: "OpenAI Codex", kiro: "Kiro CLI" };
+      var vendorLabels = {
+        claude: "Claude Code",
+        codex: "OpenAI Codex",
+        gemini: "Gemini CLI",
+        opencode: "OpenCode",
+        kiro: "Kiro CLI",
+      };
       el.addEventListener("mouseenter", function () {
         var html = '<div style="font-weight:600">' + escapeHtml(displayName);
         if (mate.primary) {

package/lib/public/modules/tools.js

@@ -814,7 +814,13 @@ function resolvePermissionIdentity(mateId, vendor) {
     }
   }
   // Project chat: use vendor name and avatar
-  var vendorAvatars = { claude: "/claude-code-avatar.png", codex: "/codex-avatar.png", kiro: "/kiro-avatar.svg" };
+  var vendorAvatars = {
+    claude: "/claude-code-avatar.png",
+    codex: "/codex-avatar.png",
+    gemini: "/gemini-avatar.svg",
+    opencode: "/opencode-avatar.svg",
+    kiro: "/kiro-avatar.svg",
+  };
   var vendorName = (vendor && VENDOR_NAMES[vendor]) || VENDOR_NAMES.claude;
   return {
     name: vendorName,

package/lib/public/opencode-avatar.svg

@@ -0,0 +1,4 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 64 64" role="img" aria-label="OpenCode">
+  <rect width="64" height="64" rx="16" fill="#111814"/>
+  <path d="m26 19-13 13 13 13M38 19l13 13-13 13" fill="none" stroke="#78e08f" stroke-width="6" stroke-linecap="round" stroke-linejoin="round"/>
+</svg>

package/lib/sdk-bridge.js

@@ -129,7 +129,7 @@ function createSDKBridge(opts) {
   var _cachedFreshAuthState = null;
   var _cachedFreshAuthAt = 0;
 
-  function getKiroMcpServers(session) {
+  function getAcpMcpServers(session) {
     if (!session) return [];
     var bridgeArgs = [
       path.join(__dirname, "yoke", "mcp-bridge-server.js"),
@@ -1525,13 +1525,16 @@ function createSDKBridge(opts) {
           sandboxMode: codexConfig.sandbox,
           webSearchMode: codexConfig.webSearch,
         },
+        ACP: {
+          mcpServers: getAcpMcpServers(session),
+        },
         KIRO: {
           engine: kiroConfig.engine,
           mode: kiroConfig.mode,
           // ACP accepts additional stdio MCP servers per session. The bridge is
           // bound to this Clay session so partner calls cannot leak across
           // concurrent Kiro sessions or users.
-          mcpServers: getKiroMcpServers(session),
+          mcpServers: getAcpMcpServers(session),
         },
       },
     };
@@ -1787,6 +1790,19 @@ function createSDKBridge(opts) {
     } catch (e) {}
     if ((codexBin && fs.existsSync(codexBin)) || tryLookup(yoke.getVendorInfo("codex").binaryName)) result.push("codex");
 
+    var acpVendorKeys = ["gemini", "opencode"];
+    var acpProfiles = require("./yoke/acp-agent-profiles");
+    for (var acpVendorIndex = 0; acpVendorIndex < acpVendorKeys.length; acpVendorIndex++) {
+      var acpVendor = acpVendorKeys[acpVendorIndex];
+      var acpInfo = yoke.getVendorInfo(acpVendor);
+      if (!linuxUser || acpInfo.osUserIsolation) {
+        var acpProfile = acpProfiles.getAcpAgentProfile(acpVendor);
+        if (acpProfiles.findAcpAgentPath(acpProfile)) result.push(acpVendor);
+      } else {
+        console.log("[sdk-bridge] " + acpInfo.displayName + " hidden for OS-isolated user " + linuxUser + ": per-user spawning is not implemented");
+      }
+    }
+
     // Kiro has no per-user ACP spawn path yet. Do not advertise the daemon's
     // binary to an OS-isolated user, even if that user also has Kiro installed.
     var kiroInfo = yoke.getVendorInfo("kiro");

package/lib/sdk-message-processor.js

@@ -792,7 +792,16 @@ function attachMessageProcessor(ctx) {
       // processQueryStream can finish the turn when the iterator closes.
       var adapterErrorText = parsed.text || parsed.message || parsed.error || "Agent runtime error";
       session._lastAdapterError = adapterErrorText;
-      sendAndRecord(session, { type: "error", text: adapterErrorText });
+      var isSessionWriterConflict = /thread-store conflict|already has an active writer/i.test(adapterErrorText);
+      if (isSessionWriterConflict) {
+        sendAndRecord(session, {
+          type: "session_writer_conflict",
+          vendor: session.vendor || "codex",
+          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.",
+        });
+      } else {
+        sendAndRecord(session, { type: "error", text: adapterErrorText });
+      }
 
     } else if (parsed.yokeType === "model_refusal") {
       // Model declined the request. "fallback" => the CLI retried on another

package/lib/ws-schema.js

@@ -145,6 +145,7 @@ var schema = {
   "kill_process":             { direction: "c2s", handler: "lib/project-sessions.js", description: "Kill a system process by PID" },
   "process_killed":           { direction: "s2c", handler: "lib/public/modules/app-messages.js", description: "Process was successfully killed" },
   "process_conflict":         { direction: "s2c", handler: "lib/public/modules/app-messages.js", description: "Conflict: another process is using the session" },
+  "session_writer_conflict":  { direction: "s2c", handler: "lib/public/modules/app-messages.js", description: "Codex session is already open in another process" },
 
   // -----------------------------------------------------------------------
   // Context / usage
@@ -353,6 +354,8 @@ var schema = {
   "term_closed":              { direction: "s2c", handler: "lib/public/modules/app-messages.js", description: "Terminal session was closed" },
   "term_list":                { direction: "s2c", handler: "lib/public/modules/app-messages.js", description: "Full list of open terminals" },
   "term_error":               { direction: "s2c", handler: "lib/public/modules/app-messages.js", description: "Terminal error (e.g. access denied)" },
+  "shell_command":            { direction: "c2s", handler: "lib/project-shell-command.js", description: "Run a one-shot shell command for agent context" },
+  "shell_command_result":     { direction: "s2c", handler: "lib/public/modules/app-messages.js", description: "One-shot shell command output and exit status" },
 
   // -----------------------------------------------------------------------
   // Sticky notes

package/lib/yoke/acp-agent-profiles.js

@@ -0,0 +1,188 @@
+// ACP Agent Drivers
+// -----------------
+// Vendor-specific facts and optional hooks for agents that implement ACP.
+// Static profiles are sufficient for standard agents; richer runtimes can add
+// hooks without forcing YOKE down to ACP's least-common-denominator feature set.
+
+var fs = require("fs");
+var execFile = require("child_process").execFile;
+var execFileSync = require("child_process").execFileSync;
+
+function findOnPath(binaryName, overrideName) {
+  var overridePath = overrideName && process.env[overrideName];
+  if (overridePath && fs.existsSync(overridePath)) return overridePath;
+  try {
+    var command = process.platform === "win32" ? "where" : "which";
+    var out = execFileSync(command, [binaryName], {
+      timeout: 3000,
+      encoding: "utf8",
+      stdio: ["pipe", "pipe", "pipe"],
+    });
+    return out.trim().split(/\r?\n/)[0] || null;
+  } catch (e) {
+    return null;
+  }
+}
+
+function fetchOpenCodeModels(binaryPath, cwd) {
+  return new Promise(function(resolve) {
+    execFile(binaryPath, ["models"], {
+      cwd: cwd || process.cwd(),
+      timeout: 20000,
+      maxBuffer: 4 * 1024 * 1024,
+    }, function(err, stdout) {
+      if (err || !stdout) { resolve([]); return; }
+      var seen = {};
+      var models = [];
+      var lines = String(stdout).split(/\r?\n/);
+      for (var i = 0; i < lines.length; i++) {
+        var value = lines[i].trim();
+        if (!value || seen[value]) continue;
+        seen[value] = true;
+        models.push(value);
+      }
+      resolve(models);
+    });
+  });
+}
+
+function fetchOpenCodeResolvedConfig(binaryPath, cwd, env) {
+  return new Promise(function(resolve, reject) {
+    execFile(binaryPath, ["debug", "config"], {
+      cwd: cwd || process.cwd(),
+      env: Object.assign({}, process.env, env || {}),
+      timeout: 30000,
+      maxBuffer: 4 * 1024 * 1024,
+    }, function(err, stdout) {
+      if (err) { reject(err); return; }
+      try {
+        resolve(JSON.parse(String(stdout || "{}")));
+      } catch (e) {
+        reject(new Error("OpenCode returned invalid resolved configuration"));
+      }
+    });
+  });
+}
+
+function fetchOpenCodeAgentNames(binaryPath, cwd, env) {
+  return fetchOpenCodeResolvedConfig(binaryPath, cwd, env).then(function(config) {
+    return Object.keys(config.agent || {});
+  });
+}
+
+function isSafeOpenCodePermission(value) {
+  if (value === "ask" || value === "deny") return true;
+  if (!value || typeof value !== "object" || Array.isArray(value)) return false;
+  var keys = Object.keys(value);
+  if (!keys.length) return false;
+  for (var i = 0; i < keys.length; i++) {
+    if (!isSafeOpenCodePermission(value[keys[i]])) return false;
+  }
+  return true;
+}
+
+function validateOpenCodeConfig(config) {
+  if (!config || config.permission !== "ask") {
+    throw new Error("OpenCode resolved configuration does not preserve global ask permissions");
+  }
+  var agents = config.agent || {};
+  var names = Object.keys(agents);
+  for (var i = 0; i < names.length; i++) {
+    var agent = agents[names[i]] || {};
+    if (agent.permission === undefined) continue;
+    if (!isSafeOpenCodePermission(agent.permission)) {
+      throw new Error("OpenCode agent has unsafe resolved permissions: " + names[i]);
+    }
+  }
+}
+
+var ACP_AGENT_PROFILES = {
+  gemini: {
+    vendor: "gemini",
+    displayName: "Gemini CLI",
+    binaryName: "gemini",
+    overrideName: "GEMINI_CLI_PATH",
+    args: ["--acp", "--approval-mode=default"],
+    defaultModels: ["auto"],
+    defaultModel: "auto",
+    // Gemini advertises loadSession, but releases through 0.46.0 could load
+    // the transcript without restoring the model's conversation memory.
+    // Keep resume gated until Clay's live contract test proves it reliable.
+    sessionResume: false,
+    permissionModeGuaranteed: true,
+  },
+  opencode: {
+    vendor: "opencode",
+    displayName: "OpenCode",
+    binaryName: "opencode",
+    overrideName: "OPENCODE_CLI_PATH",
+    args: ["acp"],
+    defaultModels: ["auto"],
+    defaultModel: "auto",
+    sessionResume: null,
+    fetchModels: fetchOpenCodeModels,
+    permissionModeGuaranteed: true,
+    prepare: function(ctx) {
+      var injected = ctx.initOpts && ctx.initOpts._openCodeAgentNames;
+      if (Array.isArray(injected)) {
+        ctx.driverState.agentNames = injected.slice();
+        return;
+      }
+      return fetchOpenCodeAgentNames(ctx.binaryPath, ctx.cwd, ctx.initOpts && ctx.initOpts.env).then(function(names) {
+        ctx.driverState.agentNames = names;
+      });
+    },
+    buildProcessOptions: function(ctx, base) {
+      var existing = (base.env && base.env.OPENCODE_CONFIG_CONTENT) || process.env.OPENCODE_CONFIG_CONTENT;
+      var config = {};
+      if (existing) config = JSON.parse(existing);
+      var agent = Object.assign({}, config.agent || {});
+      var names = ["build", "plan"].concat(ctx.driverState.agentNames || []);
+      for (var i = 0; i < names.length; i++) {
+        agent[names[i]] = Object.assign({}, agent[names[i]] || {}, { permission: "ask" });
+      }
+      base.env = Object.assign({}, base.env || {}, {
+        OPENCODE_CONFIG_CONTENT: JSON.stringify(Object.assign({}, config, { permission: "ask", agent: agent })),
+      });
+      return base;
+    },
+    validateProcessOptions: function(ctx) {
+      var injected = ctx.initOpts && ctx.initOpts._openCodeResolvedConfig;
+      var resolved = injected
+        ? Promise.resolve(injected)
+        : fetchOpenCodeResolvedConfig(ctx.binaryPath, ctx.cwd, ctx.processOptions.env);
+      return resolved.then(function(config) {
+        validateOpenCodeConfig(config);
+      });
+    },
+    ensureSafePermissionMode: function() {
+      // OpenCode ACP modes select agents, not approval policy. The process
+      // configuration above enforces ask at both global and effective-agent levels.
+      return Promise.resolve();
+    },
+  },
+};
+
+function getAcpAgentProfile(vendor) {
+  return ACP_AGENT_PROFILES[vendor] || null;
+}
+
+function getAcpAgentDriver(vendor) {
+  return getAcpAgentProfile(vendor);
+}
+
+function findAcpAgentPath(profile) {
+  if (!profile) return null;
+  return findOnPath(profile.binaryName, profile.overrideName);
+}
+
+module.exports = {
+  ACP_AGENT_PROFILES: ACP_AGENT_PROFILES,
+  getAcpAgentProfile: getAcpAgentProfile,
+  getAcpAgentDriver: getAcpAgentDriver,
+  findAcpAgentPath: findAcpAgentPath,
+  fetchOpenCodeModels: fetchOpenCodeModels,
+  fetchOpenCodeAgentNames: fetchOpenCodeAgentNames,
+  fetchOpenCodeResolvedConfig: fetchOpenCodeResolvedConfig,
+  validateOpenCodeConfig: validateOpenCodeConfig,
+};

package/lib/yoke/acp-driver-runtime.js

@@ -0,0 +1,50 @@
+// ACP Vendor Driver Runtime
+// -------------------------
+// ACP supplies defaults. Trusted vendor drivers may extend or replace them so
+// the shared protocol never becomes the ceiling of the richer YOKE contract.
+
+function hasHook(driver, name) {
+  return !!(driver && typeof driver[name] === "function");
+}
+
+function call(driver, name, context, fallback) {
+  if (hasHook(driver, name)) return driver[name](context, fallback);
+  return fallback ? fallback() : undefined;
+}
+
+function callAsync(driver, name, context, fallback) {
+  try {
+    return Promise.resolve(call(driver, name, context, fallback));
+  } catch (e) {
+    return Promise.reject(e);
+  }
+}
+
+function mergeCapabilities(driver, context, base) {
+  var defaults = Object.assign({}, base);
+  if (!hasHook(driver, "extendCapabilities")) return defaults;
+  var extended = driver.extendCapabilities(context, Object.assign({}, defaults));
+  return Object.assign({}, defaults, extended || {});
+}
+
+function buildParams(driver, hookName, context, base) {
+  var defaults = Object.assign({}, base);
+  if (!hasHook(driver, hookName)) return defaults;
+  var result = driver[hookName](context, Object.assign({}, defaults));
+  return result === undefined || result === null ? defaults : result;
+}
+
+function normalizeEvents(driver, context, fallback) {
+  var result = call(driver, "normalizeUpdate", context, fallback);
+  if (result === undefined || result === null) return [];
+  return Array.isArray(result) ? result : [result];
+}
+
+module.exports = {
+  hasHook: hasHook,
+  call: call,
+  callAsync: callAsync,
+  mergeCapabilities: mergeCapabilities,
+  buildParams: buildParams,
+  normalizeEvents: normalizeEvents,
+};