agentlas 1.0.47 → 1.0.49

package/CHANGELOG.md

@@ -1,5 +1,21 @@
 # Changelog
 
+## Unreleased
+
+- `agentlas acp` — Agentlas as an Agent Client Protocol agent (Phase B-3). Zed,
+  JetBrains IDEs and other ACP clients can run the project controller (or an
+  installed agent via `_meta.agentlas.agent`) on the runtime you subscribe to,
+  with tool calls and streamed text projected onto ACP. `--info` prints the
+  registry-style descriptor. CLI-only (stdout is the wire).
+- kimi, grok, and cursor run through the desktop core's generic ACP runner
+  (`engine/runtimes/acp-driver.cjs`) instead of being refused as "no v2
+  streaming driver". Same file, same tool-call vocabulary as Desktop; an old
+  core without `electron/runtime/acp.js` still refuses honestly with a repair
+  hint. `agentlas doctor` lists the newly executable runtimes.
+- `npm test` is the smoke gate; the stale `.internal` copy of the architecture
+  sync script is gone (one canonical script under `scripts/`).
+
+
 ## 1.0.47 — 2026-08-14
 
 Antigravity and the shared runtime contracts now reach the independent

package/README.md

@@ -228,7 +228,9 @@ The launcher (`bin/agentlas.cjs`) runs system Node against `engine/`. The defaul
 | Windows | `%APPDATA%\Agentlas` |
 | Linux | `$XDG_CONFIG_HOME/Agentlas` (default `~/.config/Agentlas`) |
 
-The SQLite database file is `agentlas.sqlite` (`user_version=86`). When launched for the first time without an existing database, it bootstraps schemas using `engine/bootstrap-schema.sql`. Consequently, **projects, installed agents, task history, automation sessions, and MCP registrations are shared across Desktop and Terminal**. The first ordered project agent remains the controller; additional agents are task-scoped and are stored only as execution ledgers, never as global conversations or durable owners.
+The SQLite database file is `agentlas.sqlite` (`user_version=97`). When launched for the first time without an existing database, it bootstraps schemas using `engine/bootstrap-schema.sql`. Consequently, **projects, installed agents, task history, automation sessions, and MCP registrations are shared across Desktop and Terminal**. The first ordered project agent remains the controller; additional agents are task-scoped and are stored only as execution ledgers, never as global conversations or durable owners.
+
+**Single migration authority.** The Desktop app owns the schema migration ladder; the CLI never migrates the shared database. `engine/bootstrap-schema.sql` is generated by running that ladder to completion against an empty database, so a CLI-created store already sits at the ladder head and has nothing left for Desktop to upgrade. If the CLI opens a store older than the version it knows, it refuses with an actionable message instead of migrating or silently proceeding — a second migrator on this lock-free file is what corrupted the store once before. On a machine with no Desktop app, an operator can set `AGENTLAS_STORE_MIGRATION_ROLE=owner` for a single deliberate upgrade run with every other Agentlas process closed.
 
 SQLite driver priority: `better-sqlite3` (optional dependency native build), then Node 22+ `node:sqlite` when the first driver is unavailable.
 
@@ -289,7 +291,7 @@ Engine source code resides in `engine/*.cjs`.
 ```sh
 sh test/smoke.sh                              # Runs surface tests, guard tests, fresh DB tests, contract tests & parity gates
 npm run smoke                                 # Equivalent to npm run test:release-contracts
-sh scripts/gen-bootstrap-schema.sh [db-path]  # Regenerates engine/bootstrap-schema.sql
+node scripts/gen-bootstrap-schema.cjs         # Regenerates engine/bootstrap-schema.sql from the Desktop ladder (never reads a live store)
 ```
 
 Smoke tests run isolated inside a temporary `AGENTLAS_USER_DATA_DIR` and do not touch local user data.

package/bin/agentlas.cjs

@@ -155,12 +155,22 @@ function bootstrapDbIfMissing() {
     throw new Error(`Bootstrap schema not found: ${schemaFile}`);
   }
   const sql = fs.readFileSync(schemaFile, "utf8");
+  // ★새 저장소는 태어날 때부터 WAL 이어야 한다 (2026-08-18 실측).
+  // journal_mode 는 파일에 박히는 값이고, delete→WAL 전환은 **배타 락**을 요구하며
+  // busy_timeout 이 걸려 있어도 즉시 SQLITE_BUSY 로 실패할 수 있다. 그래서 터미널이
+  // 만든 DB 를 delete 모드로 남기면, 데스크탑과 터미널이 그 파일을 처음 동시에 여는
+  // 순간 한쪽이 "database is locked" 로 죽는다 — 첫 부팅에서만 나는, 재현이 어려운
+  // 결함이다. 여기서 한 번 켜 두면 그 전환 자체가 존재하지 않는다.
+  const WAL_PRAGMA = "PRAGMA journal_mode=WAL;\n";
   // DB를 정식 경로에서 직접 만들면 두 첫 실행이 모두 exists=false를 본 뒤 한 프로세스의
   // 실패 cleanup이 다른 프로세스의 정상 DB까지 지울 수 있다. 각자 같은 볼륨의 임시 DB를
   // 완성하고 hard-link(EEXIST=다른 프로세스 승리)로만 정식 이름을 원자 획득한다.
   const temp = `${p}.bootstrap-${process.pid}-${Date.now()}-${Math.random().toString(16).slice(2)}.tmp`;
   const db = openSqlite(temp);
   try {
+    // 임시 파일에서 켠다. journal_mode 는 DB 헤더에 박히므로 hard-link 로 정식 이름을
+    // 얻은 뒤에도 유지된다(닫을 때 -wal 은 체크포인트되고 사라진다).
+    db.exec(WAL_PRAGMA);
     db.exec(sql);
   } catch (e) {
     db.close();

package/engine/acp/server.cjs

@@ -0,0 +1,279 @@
+"use strict";
+/*
+ * acp/server — Agentlas as an ACP *agent* (PRD 2026-08-15 Phase B-3, plan-acp §2 (B)).
+ *
+ * `agentlas acp` speaks the Agent Client Protocol v1 on stdio (JSON-RPC 2.0, ndjson)
+ * as the AGENT side. Any ACP client — Zed, JetBrains IDEs, VS Code extensions,
+ * Emacs/neovim, other Agentlas surfaces — can now run Agentlas' project controller
+ * (the agent Desktop/Terminal already run for `agentlas run`) on the runtime the
+ * user subscribes to (Claude Code, Codex, Antigravity, …), inside their editor.
+ *
+ * BYOM stays true: Agentlas has no model of its own. A prompt turn is exactly an
+ * `agentlas run` turn (engine/sessions/session.cjs → native-host / ACP driver),
+ * projected onto ACP notifications:
+ *   stream-delta → agent_message_chunk · tool → tool_call(completed) ·
+ *   tool-result → tool_call_update · status → (dropped) · error → stopReason/refusal
+ * Nothing here executes anything a plain `agentlas run` would not; the same
+ * permission model (prefs.permission, default read for a remote client) applies.
+ *
+ * Wire choices, all measured against the registry matrix behaviour:
+ *   protocolVersion 1 only (v2 is a draft) · authMethods [] (Agentlas login is a
+ *   separate `agentlas login`; nothing to authenticate over ACP) ·
+ *   session/cancel kills the child · unknown methods → -32601.
+ */
+const readline = require("node:readline");
+const path = require("node:path");
+
+const PROTOCOL_VERSION = 1;
+
+function pkgVersion() {
+  try { return require(path.join(__dirname, "..", "..", "package.json")).version || "0.0.0"; } catch { return "0.0.0"; }
+}
+
+function textOfPrompt(blocks) {
+  if (!Array.isArray(blocks)) return String(blocks || "");
+  return blocks.map((b) => {
+    if (!b || typeof b !== "object") return "";
+    if (b.type === "text") return String(b.text || "");
+    if (b.type === "resource" && b.resource && typeof b.resource.text === "string") return `\n[resource ${b.resource.uri || ""}]\n${b.resource.text}\n`;
+    if (b.type === "resource_link") return `[${b.name || "resource"}](${b.uri || ""})`;
+    return "";
+  }).join("");
+}
+
+/**
+ * Turn-execution boundary. Production uses engine/sessions (Orchestrator + project
+ * controller); contract tests inject a fake `runTurn` so no runtime is spawned.
+ *
+ * runTurn(ctx, {cwd, prompt, permission, runtimeKind?, sessionKey?, events}) →
+ *   Promise<{ text, error, errorKind, session }>
+ * events: { onDelta(text), onTool(name, summary, id), onToolResult(text, ok, id), onStatus(text) }
+ * cancel(sessionKey) → void
+ */
+function productionTurnRunner() {
+  const sessions = new Map(); // acp sessionId → { session, agent, runtime }
+  return {
+    async newSession(ctx, { cwd, runtimeKind, agentSlug }) {
+      const { projectCwd } = require("../project/paths.cjs");
+      const { resolveProjectController, withProjectControllerContext } = require("../project/controller.cjs");
+      const { resolveRuntimeForAgent } = require("../runtimes/overrides.cjs");
+      const { ensureTerminalProjectForExecutionCli } = require("../project/state.cjs");
+      const { findAgent } = require("../agents/registry.cjs");
+      const permissions = require("../agentlas-permissions.cjs");
+      const db = ctx.db();
+      const workdir = cwd || projectCwd();
+      // Same ladder as `agentlas run [agent]`: an explicit installed agent
+      // (session/new _meta.agentlas.agent) is the advanced direct call; otherwise
+      // the folder's project controller — and no silent substitution when neither.
+      let agent = null;
+      let resolved = null;
+      if (agentSlug) {
+        agent = findAgent(db, String(agentSlug));
+        if (!agent) throw new Error(`unknown agent: ${agentSlug} (agentlas agents lists installed agents)`);
+      } else {
+        resolved = resolveProjectController(db, workdir);
+        agent = withProjectControllerContext(resolved.controller, resolved.project);
+      }
+      const runtime = resolveRuntimeForAgent({ db, prefs: ctx.prefs, explicit: runtimeKind || null, role: "orchestrator", agentId: agent.id });
+      // A remote editor client is unattended: never widen beyond the saved preference, default read.
+      const permission = permissions.normalize((ctx.prefs && ctx.prefs.permission) || "read");
+      ensureTerminalProjectForExecutionCli(db, workdir, permission, "terminal-acp");
+      return { agent, runtime, permission, cwd: workdir, project: resolved ? resolved.project : null };
+    },
+    async runTurn(ctx, spec, prompt, events) {
+      const { Orchestrator } = require("../sessions/orchestrator.cjs");
+      const orch = new Orchestrator({ db: ctx.db(), lang: ctx.lang });
+      const session = orch.spawn({ agent: spec.agent, runtime: spec.runtime, permission: spec.permission, cwd: spec.cwd, title: prompt.slice(0, 60) });
+      sessions.set(spec.acpSessionId, session);
+      const listener = (ev) => {
+        try {
+          if (ev.type === "stream-delta") events.onDelta(ev.text);
+          else if (ev.type === "tool") events.onTool(ev.name, ev.summary, ev.id);
+          else if (ev.type === "tool-result") events.onToolResult(ev.text, ev.ok, ev.id);
+          else if (ev.type === "status") events.onStatus(ev.text);
+        } catch { /* a projection failure must not break the turn */ }
+      };
+      session.on("event", listener);
+      try {
+        const res = await session.send(prompt);
+        return {
+          text: (res && (res.finalText || res.text)) || "",
+          error: session.status === "failed" ? (session.lastError || (res && res.error) || "failed") : (res && res.error) || null,
+          errorKind: res && res.errorKind,
+          cancelled: session.status === "killed",
+        };
+      } finally {
+        session.removeListener("event", listener);
+        sessions.delete(spec.acpSessionId);
+      }
+    },
+    cancel(acpSessionId) {
+      const s = sessions.get(acpSessionId);
+      if (s) { try { s.kill(); } catch { /* best effort */ } }
+    },
+  };
+}
+
+class AcpAgentServer {
+  /**
+   * @param {object} opts { ctx, input?, output?, runner? }
+   *   ctx: agentlas command ctx (db(), prefs, lang) — may be null in tests with a fake runner
+   */
+  constructor(opts) {
+    this.ctx = opts.ctx || null;
+    this.input = opts.input || process.stdin;
+    this.output = opts.output || process.stdout;
+    this.runner = opts.runner || productionTurnRunner();
+    this.sessions = new Map(); // sessionId → spec
+    this.initialized = false;
+    this.nextSessionSeq = 1;
+    this.closed = false;
+  }
+
+  send(obj) {
+    if (this.closed) return;
+    this.output.write(JSON.stringify(obj) + "\n");
+  }
+  notify(method, params) { this.send({ jsonrpc: "2.0", method, params }); }
+  reply(id, result) { this.send({ jsonrpc: "2.0", id, result }); }
+  error(id, code, message, data) { this.send({ jsonrpc: "2.0", id, error: { code, message, ...(data !== undefined ? { data } : {}) } }); }
+
+  start() {
+    const rl = readline.createInterface({ input: this.input, crlfDelay: Infinity });
+    rl.on("line", (line) => {
+      const trimmed = line.trim();
+      if (!trimmed) return;
+      let msg;
+      try { msg = JSON.parse(trimmed); } catch { return; }
+      if (!msg || typeof msg !== "object" || !msg.method) return;
+      void this.handle(msg);
+    });
+    rl.on("close", () => { this.closed = true; });
+    return new Promise((resolve) => rl.on("close", resolve));
+  }
+
+  async handle(msg) {
+    const { id, method } = msg;
+    const params = msg.params || {};
+    try {
+      switch (method) {
+        case "initialize": {
+          const requested = Number(params.protocolVersion);
+          if (requested !== PROTOCOL_VERSION) {
+            return this.error(id, -32602, `unsupported protocolVersion ${params.protocolVersion}; this agent speaks v${PROTOCOL_VERSION}`);
+          }
+          this.initialized = true;
+          return this.reply(id, {
+            protocolVersion: PROTOCOL_VERSION,
+            agentCapabilities: {
+              loadSession: false,
+              promptCapabilities: { image: false, audio: false, embeddedContext: true },
+              mcpCapabilities: { http: false, sse: false },
+            },
+            authMethods: [],
+            agentInfo: { name: "agentlas", title: "Agentlas", version: pkgVersion() },
+          });
+        }
+        case "authenticate":
+          return this.reply(id, {});
+        case "session/new": {
+          if (!this.initialized) return this.error(id, -32002, "initialize first");
+          const sessionId = `agentlas-${process.pid}-${this.nextSessionSeq++}`;
+          const meta = (params._meta && params._meta.agentlas) || params._meta || {};
+          const spec = await this.runner.newSession(this.ctx, { cwd: params.cwd, runtimeKind: meta.runtime, agentSlug: meta.agent });
+          spec.acpSessionId = sessionId;
+          this.sessions.set(sessionId, spec);
+          const rt = spec.runtime || {};
+          return this.reply(id, {
+            sessionId,
+            configOptions: [
+              {
+                id: "runtime", category: "mode", type: "select", name: "Runtime",
+                currentValue: rt.kind || "",
+                options: [{ value: rt.kind || "", name: `${rt.kind || "runtime"}${rt.model ? ` · ${rt.model}` : ""}` }],
+              },
+              ...(rt.model ? [{ id: "model", category: "model", type: "select", name: "Model", currentValue: rt.model, options: [{ value: rt.model, name: rt.model }] }] : []),
+            ],
+            _meta: {
+              agentlas: {
+                controller: spec.agent && (spec.agent.slug || spec.agent.name),
+                project: spec.project && spec.project.name,
+                permission: spec.permission,
+                runtime: rt.kind,
+              },
+            },
+          });
+        }
+        case "session/prompt": {
+          const spec = this.sessions.get(String(params.sessionId));
+          if (!spec) return this.error(id, -32602, "unknown sessionId");
+          const prompt = textOfPrompt(params.prompt).trim();
+          if (!prompt) return this.reply(id, { stopReason: "end_turn" });
+          const sid = spec.acpSessionId;
+          let streamed = false;
+          const events = {
+            onDelta: (text) => {
+              if (!text) return;
+              streamed = true;
+              this.notify("session/update", { sessionId: sid, update: { sessionUpdate: "agent_message_chunk", content: { type: "text", text } } });
+            },
+            onTool: (name, summary, toolId) => {
+              this.notify("session/update", { sessionId: sid, update: {
+                sessionUpdate: "tool_call", toolCallId: String(toolId || `${name}-${Date.now()}`), title: [name, summary].filter(Boolean).join(" "),
+                kind: kindOfTool(name), status: "completed",
+              } });
+            },
+            onToolResult: (text, ok, toolId) => {
+              if (!toolId) return;
+              this.notify("session/update", { sessionId: sid, update: {
+                sessionUpdate: "tool_call_update", toolCallId: String(toolId), status: ok === false ? "failed" : "completed",
+                content: text ? [{ type: "content", content: { type: "text", text: String(text).slice(0, 4000) } }] : undefined,
+              } });
+            },
+            onStatus: () => {},
+          };
+          const res = await this.runner.runTurn(this.ctx, spec, prompt, events);
+          if (res && res.cancelled) return this.reply(id, { stopReason: "cancelled" });
+          if (res && res.error) {
+            const kind = String(res.errorKind || "");
+            if (kind === "refused") return this.reply(id, { stopReason: "refusal" });
+            if (kind === "auth") return this.error(id, -32000, `auth_required: ${res.error}`);
+            // Non-marker failures: surface the runtime's own words as the answer, then end the turn.
+            if (!streamed) events.onDelta(String(res.error));
+            return this.reply(id, { stopReason: "end_turn", _meta: { agentlas: { error: String(res.error), errorKind: kind || null } } });
+          }
+          if (!streamed && res && res.text) events.onDelta(res.text);
+          return this.reply(id, { stopReason: "end_turn" });
+        }
+        case "session/cancel": {
+          const spec = this.sessions.get(String(params.sessionId));
+          if (spec) this.runner.cancel(spec.acpSessionId);
+          return; // notification: no reply
+        }
+        case "session/set_mode":
+        case "session/set_model":
+          return this.error(id, -32601, `Method not found: ${method}`);
+        default:
+          if (id !== undefined) return this.error(id, -32601, `Method not found: ${method}`);
+          return;
+      }
+    } catch (e) {
+      if (id !== undefined) this.error(id, -32603, (e && e.message) || String(e));
+    }
+  }
+}
+
+function kindOfTool(name) {
+  const n = String(name || "").toLowerCase();
+  if (/^(bash|shell|exec|command|run)/.test(n)) return "execute";
+  if (/read|cat|view|open/.test(n)) return "read";
+  if (/edit|write|patch|apply|create/.test(n)) return "edit";
+  if (/delete|remove|rm/.test(n)) return "delete";
+  if (/move|rename/.test(n)) return "move";
+  if (/grep|search|find|glob/.test(n)) return "search";
+  if (/fetch|http|web|browse/.test(n)) return "fetch";
+  if (/think|plan/.test(n)) return "think";
+  return "other";
+}
+
+module.exports = { AcpAgentServer, PROTOCOL_VERSION, textOfPrompt, kindOfTool, productionTurnRunner };

package/engine/agentlas-capabilities.cjs

@@ -26,7 +26,8 @@ const RUNTIME_CAPS = {
 
 // NOTE: grok은 CAPS(멀티모달 능력 인지)만 등록 — 터미널 스폰 러너(RUNTIME_BIN)가 아직 없어
 // CLI_KINDS에 넣으면 repl의 which(RUNTIME_BIN[k]) 탐지가 깨진다. 러너 추가 시 함께 확장할 것.
-const CLI_KINDS = ["claude-code", "codex", "agy", "gemini"];
+// 목록의 정본은 runtimes/kinds.cjs — 여기서는 네이티브 스폰 러너 4종만 가져다 쓴다.
+const CLI_KINDS = require("./runtimes/kinds.cjs").NATIVE_CLI_KINDS;
 
 function capsFor(spec) {
   return RUNTIME_CAPS[spec] || { code: true, image: false, label: spec || "?" };

package/engine/agentlas-input.cjs

@@ -306,7 +306,8 @@ const SLASH_COMMAND_META = [
   { command: "/exit", description: "Quit Agentlas", category: "Session", usage: "/exit", detail: "Close the terminal session.", aliases: ["/quit"] },
 ];
 const SLASH_COMMANDS = SLASH_COMMAND_META.flatMap((entry) => [entry.command].concat(entry.aliases || []));
-const RUNTIME_SPECS = ["claude-code", "codex", "agy", "gemini", "anthropic", "openai", "google", "ollama", "upstage"];
+// /runtime 이 받는 spec 전체(네이티브 CLI + API 백엔드) — 정본은 runtimes/kinds.cjs.
+const RUNTIME_SPECS = require("./runtimes/kinds.cjs").RUNTIME_SPECS;
 const PERM_LEVELS = ["read", "write", "full"];
 
 const HELP_KEY_BY_COMMAND = {

package/engine/agentlas-native-host.cjs

@@ -19,6 +19,7 @@ const fs = require("node:fs");
 const os = require("node:os");
 const path = require("node:path");
 const permissions = require("./agentlas-permissions.cjs");
+const acpDriver = require("./runtimes/acp-driver.cjs");
 const i18n = require("./agentlas-i18n.cjs");
 const { wrapStdioServer } = require("./agentlas-mcp-env.cjs");
 
@@ -915,6 +916,11 @@ function handleGeminiLine(line, st, ui) {
 function runNativeTurn(req) {
   const { kind, bin, ui } = req;
   const cwd = req.cwd;
+  // kimi/grok/cursor: 손코딩 3번째 대신 벤더 코어의 공용 ACP 러너로 (PRD 2026-08-15 T-2).
+  // 같은 결과 계약({text, session, usage, error, errorKind, errorSource})으로 돌아온다.
+  if (acpDriver.ACP_KINDS.has(kind)) {
+    return acpDriver.runAcpTurn(req);
+  }
   let launchReq = req;
   if (
     kind === "gemini" && permissions.normalize(req.permission) === "full" &&

package/engine/agentlas-onboard.cjs

@@ -133,7 +133,8 @@ async function runOnboard({ ui, rl, helpers, persist }) {
   // Step 2 — default runtime
   ui.line("");
   printIndented(ui.t("wiz.runtimeQ"), c.bold);
-  const cliKinds = ["claude-code", "codex", "agy", "gemini"];
+  // 위저드 선택지 = 네이티브 스폰 러너 4종 (정본 runtimes/kinds.cjs, 표시 순서 포함).
+  const cliKinds = require("./runtimes/kinds.cjs").NATIVE_CLI_KINDS;
   const rtOpts = [{ value: "auto", label: ui.t("wiz.runtimeAuto") }];
   for (const k of cliKinds) {
     const has = !!H.which(H.RUNTIME_BIN[k]);

package/engine/agentlas-sqlite-policy.cjs

@@ -4,6 +4,15 @@
 // lock waits bounded, and acquire writer authority before a transaction reads
 // state that it may subsequently update. A deferred read-to-write upgrade can
 // fail immediately with SQLITE_BUSY even when busy_timeout is configured.
+//
+// ★This value must stay identical to `STORE_BUSY_TIMEOUT_MS` in
+// agentlas_desktop/electron/store/db.ts. Until 2026-08-18 the Desktop waited 5s
+// and the terminal 15s on the very same file, so under contention the Desktop
+// was always the first to give up with SQLITE_BUSY — even when the terminal was
+// the slow writer. That asymmetry made shared-file contention look like a
+// Desktop-only bug. 15s is the agreed value: nothing holds a transaction on this
+// file for long (the longest writer is the migration ladder), so it is a ceiling
+// that is essentially never reached rather than added latency.
 const SQLITE_BUSY_TIMEOUT_MS = 15_000;
 
 // `foreign_keys` 는 파일이 아니라 **커넥션** 속성이다. 데스크탑은

package/engine/automation/daemon.cjs

@@ -24,13 +24,9 @@ const store = require("./store.cjs");
 //    getAutomationExecutionContractState 동형) ──────────────────────────────
 // 손상된/미래 계약 값은 절대 조용히 넓혀 실행하지 않는다 — raw-row 게이트로
 // 무인 실행 직전에 검사한다(데스크탑 automation-scheduler.ts:538-549).
-const RUNTIME_KINDS = new Set([
-  "claude-code", "codex", "agy", "gemini", "kimi", "grok", "cursor", "byok", "ollama", "lmstudio", "mlx",
-]);
-const RUNTIME_BACKENDS = new Set([
-  "anthropic", "openai", "google", "ollama", "lmstudio", "mlx", "upstage", "custom", "glm",
-  "kimi", "deepseek", "minimax", "xai", "openrouter", "cursor",
-]);
+const { CONTRACT_RUNTIME_KINDS, CONTRACT_RUNTIME_BACKENDS } = require("../runtimes/kinds.cjs");
+const RUNTIME_KINDS = new Set(CONTRACT_RUNTIME_KINDS);
+const RUNTIME_BACKENDS = new Set(CONTRACT_RUNTIME_BACKENDS);
 const RUNTIME_SELECTION_KEYS = new Set(["kind", "backend", "source", "model", "longContext", "effort"]);
 
 function decodeRuntimeSelection(raw) {