agentlas 1.0.46 → 1.0.48

package/CHANGELOG.md

@@ -1,5 +1,38 @@
 # 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
+Terminal surface.
+
+- `agy` is recognized as a first-class runtime in capabilities, detection,
+  resolution, permissions, and the interactive shell.
+- Terminal model and runtime choices use the same runtime contract as Desktop,
+  including honest no-runtime stops and project-scoped execution.
+- Workforce capture, local Core transport, graph commands, and the native host
+  preserve the synchronized Agentlas architecture without copying Desktop-only
+  SaaS state into Terminal.
+
+Verification: the local smoke suite passed 100 cases with 0 failures. The npm
+publication gate remains the authority for whether this tag is visible in the
+registry.
+
 ## 1.0.46 — 2026-08-11
 
 Pick from a list instead of retyping a slug.

package/README.md

@@ -9,7 +9,7 @@
  ╚═╝  ╚═╝ ╚═════╝ ╚══════╝╚═╝  ╚═══╝   ╚═╝   ╚══════╝╚═╝  ╚═╝╚══════╝
 ```
 
-**Agentlas Terminal CLI** — Independent AI agent runtime installed via `npm install -g agentlas` and launched with `agentlas`. Run exact installed agents, teams, and parallel sessions directly from your shell without keeping Desktop open. When Desktop is installed, Terminal reads the same local project, agent, and runtime state. Bring your own model — use your existing Claude Code, Codex, or Gemini CLI subscriptions or BYOK API keys.
+**Agentlas Terminal CLI** — Independent AI agent runtime installed via `npm install -g agentlas` and launched with `agentlas`. Run exact installed agents, teams, and parallel sessions directly from your shell without keeping Desktop open. When Desktop is installed, Terminal reads the same local project, agent, and runtime state. Bring your own model — use Antigravity (`agy`), Claude Code, Codex, legacy Gemini CLI, or BYOK API keys.
 
 Use this existing independent Terminal as the command-line runtime: inspect owner-private packages with `agentlas cloud list`, restore one with `agentlas cloud restore <slug>`, or install an eligible public package with `agentlas install <slug>`.
 
@@ -24,10 +24,10 @@ Agent Trust is our product principle: agent packages are treated as portable, ow
 | Category | Requirement |
 | --- | --- |
 | **Node.js** | **Node 22+ recommended.** `package.json` specifies `engines: ">=20"`, but if native optional dependency `better-sqlite3` build fails, the launcher falls back strictly to `node:sqlite` in Node 22+. Node 20 works when `better-sqlite3` native build succeeds. |
-| **Agent CLI** | Requires at least one supported runtime CLI (`claude`, `codex`, or `gemini`) in your `PATH`. Halts honestly with `no_runtime` if none are found (no fake model responses). |
+| **Agent CLI** | Requires at least one supported runtime CLI: `agy` (Antigravity, preferred), `claude`, `codex`, or legacy `gemini` in your `PATH`. Halts honestly with `no_runtime` if none are found (no fake model responses). |
 | **OS** | macOS is verified by the current local release gate. Linux is covered by the public adapter/CI contract. A Windows launcher is provided, but this release does not claim independent end-to-end Windows verification. |
 
-*Note: `kimi`, `grok`, and `cursor-agent` are detected by diagnostics (`doctor`) but not yet executable (`has no v2 streaming driver yet`). Supported active runtimes are `claude-code`, `codex`, and `gemini`.*
+*Note: `kimi`, `grok`, and `cursor-agent` are detected by diagnostics (`doctor`) but not yet executable (`has no v2 streaming driver yet`). Supported active runtimes are `claude-code`, `codex`, `agy` (Antigravity), and legacy `gemini`.*
 
 ## Installation
 
@@ -143,7 +143,7 @@ agentlas netadmin <sub>           # Local network administration (init|status|re
 agentlas version | help
 ```
 
-Common flags across subcommands: `-p|--print`, `--runtime claude-code|codex|gemini`, `--permission read|write|full`.
+Common flags across subcommands: `-p|--print`, `--runtime claude-code|codex|agy|gemini`, `--permission read|write|full`.
 
 ### Typo Guard & Desktop Surface Redirection
 
@@ -183,7 +183,7 @@ Executing `agentlas` with no arguments resolves the current folder to an Agentla
 | `/agents` · `/list` | List installed agents |
 | `/mcp` | List active MCP servers |
 | `/doctor` | Run runtime & database diagnostics |
-| `/runtime <kind>` | Set runtime for new sessions (`claude-code` \| `codex` \| `gemini`) |
+| `/runtime <kind>` | Set runtime for new sessions (`claude-code` \| `codex` \| `agy` (Antigravity) \| legacy `gemini`) |
 | `/permission <level>` | Set permission level for new sessions (`read` \| `write` \| `full`) |
 | `/quit` · `/exit` | Exit REPL |
 
@@ -276,8 +276,8 @@ agentlas doctor      # Checks database, PATH runtimes, active CLI drivers, and c
 agentlas --where     # Outputs JSON diagnostic of launcher, engine, DB paths, driver, and Node version
 ```
 
-- **`no_runtime: no agent CLI found`**: Install `claude`, `codex`, or `gemini` CLI and add to `PATH`. Note that `kimi`/`grok`/`cursor-agent` are detected by `doctor` but do not yet have streaming execution drivers.
-- **`runtime '<kind>' has no v2 streaming driver yet`**: Specified `--runtime` is not supported for active execution. Supported values: `claude-code`, `codex`, `gemini`.
+- **`no_runtime: no agent CLI found`**: Connect Antigravity and put `agy` on `PATH` first, or install `claude`/`codex`; `gemini` remains available as a legacy CLI. Note that `kimi`/`grok`/`cursor-agent` are detected by `doctor` but do not yet have streaming execution drivers.
+- **`runtime '<kind>' has no v2 streaming driver yet`**: Specified `--runtime` is not supported for active execution. Supported values: `claude-code`, `codex`, `agy` (Antigravity), `gemini` (legacy).
 - **`Node vX — Node 22+ (node:sqlite) is required when better-sqlite3 is unavailable`**: `better-sqlite3` native build failed on Node 20/21. Upgrade to Node 22+ or install build tools for native compilation.
 - **`storm`/`context`/`hep` halting due to missing runtime**: Agentlas OS core runtime is missing. Install Agentlas OS or set `HEPHAESTUS_BIN=<path>`.
 - **`'xxx' is not an agentlas command`**: Typo guard intercepted an unrecognized command. Use `agentlas run -p "xxx"` to run it as a prompt.

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

@@ -15,6 +15,7 @@ const RUNTIME_CAPS = {
   "claude-code": { code: true, image: false, label: "claude" },
   codex: { code: true, image: true, label: "codex" }, // Imagen
   gemini: { code: true, image: true, label: "gemini" }, // nano-banana
+  agy: { code: true, image: true, label: "antigravity" },
   grok: { code: true, image: true, label: "grok" }, // Grok Imagine (generate_image/generate_video, 구독 키리스)
   anthropic: { code: true, image: false, label: "anthropic" },
   openai: { code: true, image: true, label: "openai" }, // gpt-image
@@ -25,7 +26,8 @@ const RUNTIME_CAPS = {
 
 // NOTE: grok은 CAPS(멀티모달 능력 인지)만 등록 — 터미널 스폰 러너(RUNTIME_BIN)가 아직 없어
 // CLI_KINDS에 넣으면 repl의 which(RUNTIME_BIN[k]) 탐지가 깨진다. 러너 추가 시 함께 확장할 것.
-const CLI_KINDS = ["claude-code", "codex", "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 || "?" };
@@ -115,7 +117,7 @@ function clearImageJudgments() {
 function autoRuntimeFor(agent, { installedKinds, activeSpec }) {
   if (needsImage(agent)) {
     if (capsFor(activeSpec).image) return activeSpec;
-    for (const k of ["gemini", "codex"]) if ((installedKinds || []).includes(k)) return k;
+    for (const k of ["agy", "gemini", "codex"]) if ((installedKinds || []).includes(k)) return k;
   }
   return activeSpec;
 }

package/engine/agentlas-core-harness.cjs

@@ -17,6 +17,10 @@ const CORE_RUNTIME_MARKERS = [
   ["schemas", "workforce-work-order.schema.json"],
   ["schemas", "workforce-selection.schema.json"],
 ];
+const CONTEXT_MAP_V3_RUNTIME_MARKERS = [
+  ["agentlas_cloud", "project_bootstrap.py"],
+  ["schemas", "context-index-policy.schema.json"],
+];
 
 const PY_BOOTSTRAP =
   "import os, runpy, sys; " +
@@ -116,6 +120,18 @@ function resolveCoreRuntimeRoot(explicitRoot, requiredMarkers = [], options = {}
   return resolveCoreRuntimeRootFromCandidates(runtimeRoots(explicitRoot), requiredMarkers, options);
 }
 
+// Context Map is a versioned Core capability. Every Terminal caller that
+// injects a slice must use the same marker and minimum-version gate as the
+// explicit `agentlas context` command; otherwise a stale runtime can silently
+// supply a pre-v3 map to prompts, memory, or Workforce.
+function resolveContextMapCoreRoot(explicitRoot) {
+  return resolveCoreRuntimeRoot(
+    explicitRoot,
+    CONTEXT_MAP_V3_RUNTIME_MARKERS,
+    { minVersion: CONTEXT_MAP_MIN_CORE_VERSION },
+  );
+}
+
 function pythonCandidates() {
   return [...new Set([
     process.env.HEPHAESTUS_PYTHON,
@@ -262,10 +278,12 @@ module.exports = {
   HARNESS_ID,
   HARNESS_MODE,
   CONTEXT_MAP_MIN_CORE_VERSION,
+  CONTEXT_MAP_V3_RUNTIME_MARKERS,
   PY_BOOTSTRAP,
   readCoreRuntimeVersion,
   resolveCoreRuntimeRootFromCandidates,
   resolveCoreRuntimeRoot,
+  resolveContextMapCoreRoot,
   resolvePython,
   spawnCoreModule,
   parseJsonOutput,

package/engine/agentlas-i18n.cjs

@@ -62,9 +62,9 @@ const STRINGS = {
     "noKey": "No %s API key. Add one in the app (Settings → BYOK), or switch with /runtime.",
     "runtimeSet": "runtime → %s",
     "runtimeNotInstalled": "%s CLI is not installed.",
-    "runtimeUnknown": "Unknown runtime: %s (claude-code|codex|gemini)",
-    "runtimeUnavailable": "No runtime is available. Install a CLI (claude/codex/gemini) or configure an API key/Ollama in the app.",
-    "runtimeUsage": "usage: /runtime claude-code|codex|gemini|anthropic|openai|google|ollama|upstage",
+    "runtimeUnknown": "Unknown runtime: %s (claude-code|codex|agy|gemini)",
+    "runtimeUnavailable": "No runtime is available. Install a CLI (claude/codex/agy; legacy gemini is supported) or configure an API key/Ollama in the app.",
+    "runtimeUsage": "usage: /runtime claude-code|codex|agy|gemini|anthropic|openai|google|ollama|upstage",
     "modelOnlyApi": "/model only applies to BYOK/Ollama (api) runtimes.",
     "modelSet": "model → %s",
     "modelCurrent": "current model: %s",
@@ -166,7 +166,7 @@ const STRINGS = {
     "help.team": "view/assign each agent's LLM (auto-routed by capability)",
     "help.agent": "switch to another agent",
     "help.firms": "list companies / switch to one",
-    "help.runtime": "switch runtime (claude-code|codex|gemini|anthropic|openai|google|ollama|upstage)",
+    "help.runtime": "switch runtime (claude-code|codex|agy|legacy gemini|anthropic|openai|google|ollama|upstage)",
     "help.model": "set the model (claude/codex/gemini alias or BYOK/Ollama id)",
     "help.effort": "set reasoning effort (low|medium|high|max|off|auto)",
     "help.permission": "what it may do (read|write|full)",
@@ -311,9 +311,9 @@ const STRINGS = {
     "noKey": "%s API 키가 없습니다. 앱 설정 → BYOK에서 등록하거나 /runtime으로 전환하세요.",
     "runtimeSet": "런타임 → %s",
     "runtimeNotInstalled": "%s CLI가 설치돼 있지 않습니다.",
-    "runtimeUnknown": "알 수 없는 런타임: %s (claude-code|codex|gemini)",
-    "runtimeUnavailable": "사용 가능한 런타임이 없습니다. CLI(claude/codex/gemini)를 설치하거나 앱에서 API 키/Ollama를 설정하세요.",
-    "runtimeUsage": "사용법: /runtime claude-code|codex|gemini|anthropic|openai|google|ollama|upstage",
+    "runtimeUnknown": "알 수 없는 런타임: %s (claude-code|codex|agy|gemini)",
+    "runtimeUnavailable": "사용 가능한 런타임이 없습니다. CLI(claude/codex/agy, 레거시 gemini 지원)를 설치하거나 앱에서 API 키/Ollama를 설정하세요.",
+    "runtimeUsage": "사용법: /runtime claude-code|codex|agy|gemini|anthropic|openai|google|ollama|upstage",
     "modelOnlyApi": "/model은 BYOK/Ollama(api) 런타임에서만 적용됩니다.",
     "modelSet": "모델 → %s",
     "modelCurrent": "현재 모델: %s",
@@ -414,7 +414,7 @@ const STRINGS = {
     "help.team": "에이전트별 LLM 보기/지정 (능력 기반 자동)",
     "help.agent": "다른 에이전트로 전환",
     "help.firms": "회사 목록 / 전환",
-    "help.runtime": "런타임 전환 (claude-code|codex|gemini|anthropic|openai|google|ollama|upstage)",
+    "help.runtime": "런타임 전환 (claude-code|codex|agy|레거시 gemini|anthropic|openai|google|ollama|upstage)",
     "help.model": "모델 지정 (claude/codex/gemini 별칭 또는 BYOK/Ollama id)",
     "help.effort": "추론 강도 지정 (low|medium|high|max|off|auto)",
     "help.permission": "허용 범위 (read|write|full)",

package/engine/agentlas-input.cjs

@@ -270,7 +270,7 @@ const SLASH_COMMAND_META = [
   { command: "/agent", description: "Switch to another agent", category: "Routing", usage: "/agent <name>", detail: "Switch the current conversation to an installed agent." },
   { command: "/firms", description: "List installed companies", category: "Routing", usage: "/firms", detail: "Show company CEOs available in this terminal." },
   { command: "/firm", description: "Switch to a company CEO", category: "Routing", usage: "/firm <name>", detail: "Switch the current conversation to a company CEO agent." },
-  { command: "/runtime", description: "Switch runtime: claude-code, codex, gemini, BYOK, or Ollama", category: "Settings", usage: "/runtime codex", detail: "Change the engine Agentlas uses for subsequent turns." },
+  { command: "/runtime", description: "Switch runtime: claude-code, codex, agy, legacy gemini, BYOK, or Ollama", category: "Settings", usage: "/runtime agy", detail: "Change the engine Agentlas uses for subsequent turns." },
   { command: "/model", description: "Pin a model or return to auto allocation", category: "Settings", usage: "/model <id|auto>", detail: "An id is an explicit session pin; auto lets the higher-level allocator choose a provider-compatible tier." },
   { command: "/effort", description: "Pin reasoning effort or return to auto", category: "Settings", usage: "/effort low|medium|high|max|off|auto", detail: "A level is an explicit pin; auto lets the higher-level allocator choose per task; off is an explicit no-effort pin." },
   { command: "/permission", description: "Set read/write/full permission", category: "Settings", usage: "/permission full", detail: "No argument shows what read, write, and full mean.", aliases: ["/perm"] },
@@ -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", "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 = {