agentlas 1.0.47 → 1.0.48

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/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/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) {

package/engine/commands/acp.cjs

@@ -0,0 +1,45 @@
+"use strict";
+/*
+ * acp — run Agentlas as an Agent Client Protocol agent on stdio (PRD 2026-08-15 B-3).
+ *
+ *   agentlas acp            start the ACP v1 agent server (stdin/stdout are the wire)
+ *   agentlas acp --info     print the registry-style descriptor and exit
+ *
+ * Register in an ACP client (Zed settings.json example):
+ *   "agent_servers": { "Agentlas": { "command": "agentlas", "args": ["acp"] } }
+ * JetBrains / other clients: same command + args. The client then runs Agentlas'
+ * project controller on the runtime you subscribe to — no keys leave your machine.
+ */
+const { AcpAgentServer, PROTOCOL_VERSION } = require("../acp/server.cjs");
+
+function descriptor() {
+  let version = "0.0.0";
+  try { version = require("../../package.json").version || version; } catch { /* keep */ }
+  return {
+    id: "agentlas",
+    name: "Agentlas",
+    version,
+    description: "Agentlas project controller over ACP — runs on the coding runtime you already subscribe to (Claude Code, Codex, Antigravity, ACP agents).",
+    protocolVersion: PROTOCOL_VERSION,
+    distribution: { npm: { package: `agentlas@${version}`, args: ["acp"] } },
+    authMethods: [],
+    capabilities: { loadSession: false, promptCapabilities: { image: false, audio: false, embeddedContext: true } },
+  };
+}
+
+async function run(ctx, args) {
+  if (args.includes("--info") || args.includes("--json")) {
+    ctx.out(JSON.stringify(descriptor(), null, 2));
+    return 0;
+  }
+  if (args.includes("--help") || args.includes("help")) {
+    ctx.out("Usage: agentlas acp [--info]\n  Speak the Agent Client Protocol (v1) on stdio so an editor can run Agentlas as its agent.");
+    return 0;
+  }
+  // stdout is the protocol wire from here on: route everything human to stderr.
+  const server = new AcpAgentServer({ ctx, input: process.stdin, output: process.stdout });
+  await server.start();
+  return 0;
+}
+
+module.exports = { run, descriptor };

package/engine/commands/billing.cjs

@@ -26,8 +26,8 @@ function usage(ko) {
       ? "  구독 계좌(A)와 렌트수익 계좌(B) 잔액을 표시합니다."
       : "  Shows the subscription account (A) and rental-earnings account (B) balances.",
     ko
-      ? "  크레딧은 Hub 에이전트 호출(공개 에이전트 3·팀 10, 활성 리스는 0)에 쓰입니다."
-      : "  Credits pay for Hub agent calls (public agent 3 · team 10; active leases cost 0).",
+      ? "  크레딧은 Hub 에이전트 호출에 작업당 쓰입니다(기본 공개 에이전트 3·팀 10, 크리에이터 가격이 있으면 그 가격). 활성 장기대여 중에는 0."
+      : "  Credits pay per work order for Hub agent calls (base: public agent 3 · team 10; creator-priced agents charge their price). 0 while a day-lease is active.",
     ko
       ? "  참고: 렌트수익(B) → 구독(A) 전송은 Agentlas Desktop 에서만 가능합니다 (터미널 전송 명령 없음)."
       : "  Note: earnings (B) → subscription (A) transfer is Desktop-only (no transfer command in the terminal).",

package/engine/commands/call.cjs

@@ -18,6 +18,10 @@ async function run(ctx, args) {
     ctx.err("✖ " + usageFor("call", ctx.lang));
     return 1;
   }
+  // 과금 사전 고지 — 가격은 서버가 청구 시 확정하므로 숫자를 지어내지 않는다.
+  ctx.out(ctx.lang !== "en"
+    ? "ℹ 공개 Hub 에이전트·팀 호출은 크레딧이 소모됩니다(활성 장기대여 중에는 0). 잔액 확인: agentlas billing"
+    : "ℹ Public Hub agent/team calls consume credits (0 while a day-lease is active). Check balance: agentlas billing");
   return create(ctx).cmdHep(["hep-call", ...args]);
 }
 

package/engine/commands/doctor.cjs

@@ -9,6 +9,7 @@ const fs = require("node:fs");
 const path = require("node:path");
 const { dbPath, userDataDir } = require("../core/paths.cjs");
 const { listAvailableCliRuntimes, activeRuntimeRow } = require("../runtimes/detect.cjs");
+const { RUNTIME_BIN } = require("../runtimes/kinds.cjs");
 const { runtimeAuthEvidence } = require("../runtimes/auth-evidence.cjs");
 const { sharedRuntimeKind } = require("../runtimes/resolve.cjs");
 const { resolvedModelRole } = require("../runtimes/roles.cjs");
@@ -106,7 +107,7 @@ async function run(ctx, args = []) {
       // 가 아니라 경고다. 흔적 없음 = 미로그인 "가능성"이므로 단정하지 않는다.
       const evidence = runtimeAuthEvidence(activeKind);
       if (evidence.status === "none") {
-        const bin = { "claude-code": "claude", codex: "codex", gemini: "gemini", agy: "agy" }[activeKind] || activeKind;
+        const bin = RUNTIME_BIN[activeKind] || activeKind;
         warn(
           en ? "active runtime" : "활성 런타임",
           en

package/engine/commands/index.cjs

@@ -34,6 +34,8 @@ const COMMANDS = {
   plugin: () => require("./plugin.cjs"),
   automation: () => require("./automation.cjs"),
   native: () => require("./native.cjs"),
+  // Agentlas as an ACP agent for editors (Zed, JetBrains, …) — PRD 2026-08-15 B-3.
+  acp: () => require("./acp.cjs"),
   multimodal: () => require("./multimodal.cjs"),
   document: () => require("./document.cjs"),
   workforce: () => require("./workforce.cjs"),

package/engine/commands/workforce.cjs

@@ -75,6 +75,11 @@ async function dispatch(ctx, command, args) {
         permission,
         `terminal-${command}`,
       ) || cwd;
+      // 과금 사전 고지 — 이 표면은 서버가 청구 시 확정하는 가격을 미리 모르므로
+      // 숫자를 지어내지 않고 사실만 말한다(공개 Hub 호출=크레딧 소모, 장기대여=0).
+      ctx.out(ctx.lang !== "en"
+        ? "ℹ 공개 Hub 에이전트·팀 호출은 크레딧이 소모됩니다(활성 장기대여 중에는 0). 잔액 확인: agentlas billing"
+        : "ℹ Public Hub agent/team calls consume credits (0 while a day-lease is active). Check balance: agentlas billing");
       const runtime = workforceRuntime({ lang: ctx.lang, out: ctx.out, uiInstance: ctx.uiInstance });
       const result = await runtime.cmdWorkforce(db, rest, runtimeOverride, {
         cwd,
@@ -124,6 +129,12 @@ async function dispatch(ctx, command, args) {
       const cwd = projectCwd();
       const permission = resolvePermission(ctx);
       const projectPath = ensureTerminalProjectForExecutionCli(db, cwd, permission, `terminal-${command}`) || cwd;
+      // 과금 사전 고지 — local 스코프는 원격 과금이 없다.
+      if (sourceScope !== "local") {
+        ctx.out(ko
+          ? "ℹ 공개 Hub 에이전트·팀 호출은 크레딧이 소모됩니다(활성 장기대여 중에는 0). 잔액 확인: agentlas billing"
+          : "ℹ Public Hub agent/team calls consume credits (0 while a day-lease is active). Check balance: agentlas billing");
+      }
       const { createLocalCoreHubTool } = require("../workforce/local-core-transport.cjs");
       const { createLocalCoreWorkforceRuntime } = require("../workforce/deps.cjs");
       const transport = createLocalCoreHubTool({ sourceScope, projectDir: projectPath, cwd });

package/engine/core/desktop-core.cjs

@@ -178,6 +178,58 @@ function loadDesktopCore() {
   return _cache;
 }
 
+/**
+ * 코어의 공용 ACP 러너(electron/runtime/acp.js)만 가볍게 로드한다 (PRD 2026-08-15 T-2).
+ * initStore·그래프 커널을 끌지 않고, electron 셰임과 네이티브 모듈 훅만 건 뒤 require 한다 —
+ * kimi/grok/cursor 실행에 DB가 필요 없기 때문. 코어가 없거나 acp.js가 없는 옛 코어면
+ * { error } 를 준다(정직한 부재; 조용한 폴백 금지).
+ */
+let _acpCache = undefined;
+function loadCoreAcpRuntime() {
+  if (_acpCache !== undefined) return _acpCache;
+  const root = findCoreRoot();
+  if (!root) { _acpCache = null; return null; }
+  const file = path.join(root, "electron", "runtime", "acp.js");
+  if (!fs.existsSync(file)) { _acpCache = { root, error: new Error("desktop core predates the ACP runner (no electron/runtime/acp.js)") }; return _acpCache; }
+  try {
+    installRetiredProjectProvisioningHook();
+    installNativeModuleHook();
+    const mod = require(file);
+    _acpCache = { root, module: mod };
+  } catch (e) {
+    _acpCache = { root, error: e };
+  }
+  return _acpCache;
+}
+
+/**
+ * 코어의 **공유 순수 모듈**(dist/shared/*)만 가볍게 로드한다 (예: "agent-control-blocks").
+ * shared/* 는 electron·DB 의존이 없는 순수 함수 모듈이라 initStore·그래프 커널·셰임 없이
+ * require 만 한다. 코어가 없으면 null, 그 모듈이 없는 옛 벤더 번들이면 { root, error } —
+ * 정직한 부재(조용한 폴백 금지는 호출부 계약; 표시 경로는 fail-open 해도 된다).
+ */
+const _sharedCache = new Map();
+function loadCoreShared(rel) {
+  const key = String(rel || "").replace(/\.js$/, "");
+  if (_sharedCache.has(key)) return _sharedCache.get(key);
+  let result = null;
+  const root = findCoreRoot();
+  if (root) {
+    const file = path.join(root, "shared", key + ".js");
+    if (!fs.existsSync(file)) {
+      result = { root, error: new Error(`desktop core has no shared/${key}.js (older vendor bundle)`) };
+    } else {
+      try {
+        result = { root, module: require(file) };
+      } catch (e) {
+        result = { root, error: e };
+      }
+    }
+  }
+  _sharedCache.set(key, result);
+  return result;
+}
+
 /** 재사용 코어가 이 머신에서 가용한가(정직한 가부). */
 function desktopCoreAvailable() {
   const c = loadDesktopCore();
@@ -202,6 +254,8 @@ async function loadDesktopCoreAsync({ onNotice } = {}) {
 module.exports = {
   findCoreRoot,
   loadDesktopCore,
+  loadCoreAcpRuntime,
+  loadCoreShared,
   loadDesktopCoreAsync,
   desktopCoreAvailable,
   _test: { stripRetiredProjectProvisioningSource },

package/engine/firms/orchestrate.cjs

@@ -68,6 +68,26 @@ function loadDelegateParser() {
   return parseDelegationsLocal;
 }
 
+/*
+ * 제어 블록 스트리퍼 정본 — 벤더 코어의 shared/agent-control-blocks
+ * (Desktop·Mobile 과 같은 규칙). 옛 벤더 번들이라 없으면 null — cleanFenceText 는
+ * 종전 규칙만으로 fail-open 한다(원문 파괴보다 마커 잔존이 낫다).
+ */
+let _stripCanonical; // undefined=미시도 · null=정본 없음 · function=정본
+function loadCanonicalStripper() {
+  if (_stripCanonical === undefined) {
+    try {
+      const loaded = require("../core/desktop-core.cjs").loadCoreShared("agent-control-blocks");
+      _stripCanonical = loaded && loaded.module && typeof loaded.module.stripAgentControlBlocks === "function"
+        ? loaded.module.stripAgentControlBlocks
+        : null;
+    } catch {
+      _stripCanonical = null;
+    }
+  }
+  return _stripCanonical;
+}
+
 /** 표시/전달용 텍스트에서 제어 펜스를 제거한다(파싱만 — 부작용 없음). 실패 시 원문. */
 function cleanFenceText(text) {
   const raw = String(text || "");
@@ -79,8 +99,18 @@ function cleanFenceText(text) {
     }
   } catch { /* fences 미존재/파서 실패 — 원문 보존 */ }
   if (cleaned == null) cleaned = parseDelegationsLocal(raw).cleanedText;
+  // HTML 주석 봉투는 정본보다 먼저 — 정본이 헤딩만 도려내면 주석 껍데기가 남는다.
+  cleaned = cleaned.replace(/<!--\s*[\s\S]*?## Memory Events[\s\S]*?-->/gi, "");
+  // 정본 스트리퍼(settled 모드): 손코딩이 몰랐던 <<agentlas-ask>>·surface·followups·
+  // goal-complete 마커와 잔여 헤딩까지 Desktop 과 같은 규칙으로 지운다.
+  const strip = loadCanonicalStripper();
+  if (strip) {
+    try {
+      cleaned = strip(cleaned, { streaming: false });
+    } catch { /* 정본 실패 — 종전 규칙만으로 fail-open */ }
+  }
+  // 터미널 고유 정제(정본 범위 밖): 스킬 나레이션·오케스트레이터 헤더·판정 태그.
   return cleaned
-    .replace(/<!--\s*[\s\S]*?## Memory Events[\s\S]*?-->/gi, "")
     .replace(/^\s*(?:사용 스킬|Skills used)\s*:[^\n.!?]*[.!?]?\s*(?:(?:이유|Reason)\s*:[^.!?]*[.!?]\s*)?/i, "")
     .replace(/^\s*I(?:'|’)m using (?:the )?`?[^`.\n]+`? skill because [^.]*\.\s*/i, "")
     .replace(/^\s*Execution mode:\s*`?appbridge-ceo-orchestrator`?[^\n]*\n?/gim, "")
@@ -485,6 +515,7 @@ async function runFirmTurn(p) {
 module.exports = {
   runFirmTurn,
   parseDelegationsLocal,
+  cleanFenceText,
   buildDelegateProtocol,
   matchTargets,
   resolveDivisions,

package/engine/runtimes/acp-driver.cjs

@@ -0,0 +1,96 @@
+"use strict";
+/*
+ * runtimes/acp-driver — kimi · grok · cursor 를 위한 ACP 드라이버 (PRD 2026-08-15 T-2).
+ *
+ * 세 번째 손코딩이 아니다. Desktop 이 만든 공용 ACP 러너(electron/runtime/acp.js)를 벤더 코어에서
+ * 그대로 로드해 쓴다 — 데스크탑·터미널이 같은 파일 하나로 같은 런타임을 같은 품질로 돈다.
+ * (터미널이 손으로 미러링해 온 native-host 4종과 달리 드리프트가 구조적으로 없다.)
+ *
+ * 벤더 코어에 acp.js 가 없으면(옛 코어) — 종전 그대로 "드라이버 없음"으로 정직하게 거부한다.
+ * 조용히 다른 런타임으로 넘어가지 않는다.
+ */
+const { loadCoreAcpRuntime } = require("../core/desktop-core.cjs");
+
+// 정본(runtimes/kinds.cjs)의 ACP 3종에서 파생 — resolve.cjs의 ACP_CLI_KINDS와 같은 원소.
+const ACP_KINDS = new Set(require("./kinds.cjs").ACP_CLI_KINDS);
+
+/** 이 머신에서 ACP 드라이버를 쓸 수 있는가. { ok, reason?, module? } */
+function acpDriverAvailability() {
+  const loaded = loadCoreAcpRuntime();
+  if (!loaded) return { ok: false, reason: "desktop core not available (run `agentlas doctor`)" };
+  if (loaded.error) return { ok: false, reason: loaded.error.message };
+  if (!loaded.module || typeof loaded.module.createAcpRunner !== "function") {
+    return { ok: false, reason: "desktop core exposes no createAcpRunner" };
+  }
+  return { ok: true, module: loaded.module };
+}
+
+function acpSpecFor(kind, mod) {
+  const spec = mod.ACP_AGENTS && mod.ACP_AGENTS[kind];
+  return spec || null;
+}
+
+/**
+ * native-host 계약으로 ACP 턴을 돈다.
+ * req = { kind, bin, prompt, systemPrompt, cwd, permission, ui, env, signal, model, locale }
+ * 반환: { text, session, usage, error, errorKind, errorSource }
+ */
+async function runAcpTurn(req) {
+  const { kind, bin, ui } = req;
+  const avail = acpDriverAvailability();
+  if (!avail.ok) {
+    return { text: "", session: req.session || {}, error: `runtime '${kind}' has no ACP driver here: ${avail.reason}`, errorKind: "unsupported", errorSource: "marker" };
+  }
+  const mod = avail.module;
+  const spec = acpSpecFor(kind, mod);
+  if (!spec) {
+    return { text: "", session: req.session || {}, error: `runtime '${kind}' is not an ACP agent in this core`, errorKind: "unsupported", errorSource: "marker" };
+  }
+  const runner = mod.createAcpRunner(spec);
+  const locale = req.locale === "ko" ? "ko" : "en";
+  let streaming = false;
+  let lastText = "";
+  const events = {
+    onPartial: (full) => {
+      const text = String(full || "");
+      if (!streaming) { ui.streamStart(); streaming = true; }
+      const delta = text.startsWith(lastText) ? text.slice(lastText.length) : text;
+      lastText = text;
+      if (delta) ui.streamDelta(delta);
+    },
+    onStatus: (status) => ui.status(status),
+    onTool: (name, args, result, id, isError) => {
+      ui.tool(name, args || "");
+      if (result) ui.toolResult(result, !isError);
+    },
+    onThinking: (phase) => { if (phase === "start") ui.status(locale === "ko" ? "생각 중..." : "thinking..."); },
+    onNotice: (notice) => { if (notice && notice.message) ui.status(notice.message); },
+  };
+  try {
+    const result = await runner({
+      systemPrompt: req.systemPrompt || "",
+      history: [],
+      userPrompt: req.prompt || "",
+      backendLabel: spec.label,
+      locale,
+      permission: req.permission,
+      runtimeSource: bin,
+      cwd: req.cwd,
+      env: req.env || process.env,
+      signal: req.signal,
+      ...(req.model ? { model: req.model } : {}),
+    }, events);
+    if (streaming) ui.streamEnd();
+    const session = { ...(req.session || {}), ...(result.sessionId ? { acpSessionId: result.sessionId } : {}) };
+    if (result.failure) {
+      return { text: result.text || "", session, usage: null, error: result.failure.message, errorKind: result.failure.kind, errorSource: result.failure.source };
+    }
+    return { text: result.text || "", session, usage: null, error: null };
+  } catch (e) {
+    if (streaming) ui.streamEnd();
+    const message = e && e.message ? e.message : String(e);
+    return { text: "", session: req.session || {}, usage: null, error: message, errorKind: /abort/i.test(message) ? "cancelled" : "exit", errorSource: "marker" };
+  }
+}
+
+module.exports = { ACP_KINDS, acpDriverAvailability, acpSpecFor, runAcpTurn };

package/engine/runtimes/detect.cjs

@@ -7,20 +7,10 @@
  * (없으면 no_runtime 정직 정지 — 폴백 금지는 상위 계층의 계약).
  */
 const { spawnSync } = require("node:child_process");
+// kind 목록/실행 파일 이름의 정본은 runtimes/kinds.cjs 하나다 — 여기서 다시 적지 않는다.
+const { RUNTIME_BIN, CLI_KINDS } = require("./kinds.cjs");
 
-const RUNTIME_BIN = {
-  "claude-code": "claude",
-  codex: "codex",
-  // Antigravity CLI — gemini 후속. 공식 gemini CLI가 계정 티어로 죽어도(IneligibleTierError,
-  // 실측 2026-08-06) 이쪽은 산다. 데스크탑 gemini 러너의 agy 경로와 같은 실물.
-  agy: "agy",
-  gemini: "gemini",
-  kimi: "kimi",
-  grok: "grok",
-  cursor: "cursor-agent",
-};
-
-const CLI_RUNTIMES = Object.keys(RUNTIME_BIN);
+const CLI_RUNTIMES = CLI_KINDS;
 
 function whichSync(bin) {
   const cmd = process.platform === "win32" ? "where" : "which";

package/engine/runtimes/kinds.cjs

@@ -0,0 +1,84 @@
+"use strict";
+/*
+ * runtimes/kinds — 런타임 종류(RuntimeKind)의 단일 정본 (2026-08-18).
+ *
+ * 배경: 같은 어휘가 8곳(detect·capture·resolve·acp-driver·capabilities·onboard·
+ * palette·input)에 손 목록으로 흩어져 있었다 — 새 kind 를 추가하면 한두 곳이
+ * 반드시 빠진다. 여기 한 벌만 두고, 다른 표면은 이 상수를 **가져다 쓴다**.
+ * 좁은 목록(캡처 4종 등)도 정본에서 파생해야 새 kind 가 모든 표면에 보인다.
+ *
+ * 순서가 곧 계약이다:
+ *  - detect.listAvailableCliRuntimes 는 이 순서로 PATH 를 훑고, resolve 의
+ *    "detected" 폴백은 그 첫 항목을 쓴다.
+ *  - 온보딩 위저드 선택지·팔레트/입력 완성 후보도 이 순서로 표시된다.
+ */
+
+const RUNTIME_KIND_SPECS = [
+  { kind: "claude-code", bin: "claude", driver: "native", capture: true },
+  { kind: "codex", bin: "codex", driver: "native", capture: true },
+  // Antigravity CLI — gemini 후속. 공식 gemini CLI가 계정 티어로 죽어도(IneligibleTierError,
+  // 실측 2026-08-06) 이쪽은 산다. 데스크탑 gemini 러너의 agy 경로와 같은 실물.
+  { kind: "agy", bin: "agy", driver: "native", capture: true },
+  { kind: "gemini", bin: "gemini", driver: "native", capture: true },
+  // kimi/grok/cursor 는 ACP 드라이버(runtimes/acp-driver.cjs → 벤더 코어의 공용
+  // ACP 러너)로 돈다 (PRD 2026-08-15 T-2). 캡처(buildArgs/텍스트 추출) 계약은 없다.
+  { kind: "kimi", bin: "kimi", driver: "acp" },
+  { kind: "grok", bin: "grok", driver: "acp" },
+  { kind: "cursor", bin: "cursor-agent", driver: "acp" },
+];
+
+/** kind → 실행 파일 이름. CLI 런타임 전체(네이티브 + ACP). */
+const RUNTIME_BIN = Object.fromEntries(RUNTIME_KIND_SPECS.map((s) => [s.kind, s.bin]));
+
+/** CLI 런타임 kind 전체(탐지 순서). */
+const CLI_KINDS = RUNTIME_KIND_SPECS.map((s) => s.kind);
+
+/** native-host 드라이버(스폰 러너)를 갖춘 CLI 4종. */
+const NATIVE_CLI_KINDS = RUNTIME_KIND_SPECS.filter((s) => s.driver === "native").map((s) => s.kind);
+
+/** 벤더 코어의 공용 ACP 러너로 도는 3종. */
+const ACP_CLI_KINDS = RUNTIME_KIND_SPECS.filter((s) => s.driver === "acp").map((s) => s.kind);
+
+/** 캡처(no-authority headless) 드라이버가 검증된 kind — buildArgs/텍스트 추출 계약 보유. */
+const CAPTURE_CLI_KINDS = RUNTIME_KIND_SPECS.filter((s) => s.capture).map((s) => s.kind);
+
+/** kind → bin, 캡처 검증본만. workforce/capture 가 쓴다. */
+const CAPTURE_RUNTIME_BIN = Object.fromEntries(
+  RUNTIME_KIND_SPECS.filter((s) => s.capture).map((s) => [s.kind, s.bin]),
+);
+
+/** CLI 가 아니라 로컬 API loop 로 실행되는 kind. */
+const API_EXECUTABLE_KINDS = ["ollama"];
+
+/** BYOK/API 백엔드 spec 문자열(/runtime 완성 후보의 API 절반). */
+const API_BACKEND_SPECS = ["anthropic", "openai", "google", "ollama", "upstage"];
+
+/** /runtime 이 받는 spec 전체: 네이티브 CLI kind + API 백엔드. */
+const RUNTIME_SPECS = [...NATIVE_CLI_KINDS, ...API_BACKEND_SPECS];
+
+/**
+ * 저장 계약(automation 등)이 허용하는 kind 전체 — CLI + 로컬/BYOK 실행 kind.
+ * 데스크탑 shared/runtime-kinds.ts 와 동형(터미널 표기: antigravity→agy, acp 미지원).
+ */
+const CONTRACT_RUNTIME_KINDS = [...CLI_KINDS, "byok", "ollama", "lmstudio", "mlx"];
+
+/** 저장 계약이 허용하는 LLM 백엔드 — 데스크탑 shared/runtime-backends.ts 와 동일 15종. */
+const CONTRACT_RUNTIME_BACKENDS = [
+  "anthropic", "openai", "google", "ollama", "lmstudio", "mlx", "upstage", "custom", "glm",
+  "kimi", "deepseek", "minimax", "xai", "openrouter", "cursor",
+];
+
+module.exports = {
+  RUNTIME_KIND_SPECS,
+  RUNTIME_BIN,
+  CLI_KINDS,
+  NATIVE_CLI_KINDS,
+  ACP_CLI_KINDS,
+  CAPTURE_CLI_KINDS,
+  CAPTURE_RUNTIME_BIN,
+  API_EXECUTABLE_KINDS,
+  API_BACKEND_SPECS,
+  RUNTIME_SPECS,
+  CONTRACT_RUNTIME_KINDS,
+  CONTRACT_RUNTIME_BACKENDS,
+};

package/engine/runtimes/resolve.cjs

@@ -6,17 +6,45 @@
  * 아무것도 없으면 no_runtime "정직 정지" — 키워드/저품질 폴백 금지(오너 결정).
  */
 const { RUNTIME_BIN, whichSync, listAvailableCliRuntimes, activeRuntimeRow } = require("./detect.cjs");
+const KINDS = require("./kinds.cjs");
 const path = require("node:path");
 
 // Session이 실제 드라이버를 갖춘 런타임만 실행 대상으로 삼는다.
 // CLI는 native-host, Ollama는 로컬 API loop를 쓴다. 다른 드라이버가 포팅되면
 // 해당 집합에 추가한다(조용한 오폭 방지).
-const CLI_EXECUTABLE_KINDS = new Set(["claude-code", "codex", "gemini", "agy"]);
-const API_EXECUTABLE_KINDS = new Set(["ollama"]);
-const EXECUTABLE_KINDS = new Set([
-  ...CLI_EXECUTABLE_KINDS,
-  ...API_EXECUTABLE_KINDS,
-]);
+//
+// kimi/grok/cursor 는 ACP 드라이버(runtimes/acp-driver.cjs → 벤더 코어의 공용 ACP 러너)로 돈다
+// (PRD 2026-08-15 T-2). 벤더 코어가 그 러너를 갖고 있을 때만 실행 대상에 든다 — 옛 코어면
+// 종전과 같은 "드라이버 없음" 정직 거부.
+// 집합의 원소는 정본(runtimes/kinds.cjs)에서 파생한다 — 여기서 다시 적지 않는다.
+const NATIVE_CLI_KINDS = new Set(KINDS.NATIVE_CLI_KINDS);
+const ACP_CLI_KINDS = new Set(KINDS.ACP_CLI_KINDS);
+const API_EXECUTABLE_KINDS = new Set(KINDS.API_EXECUTABLE_KINDS);
+
+function acpKindsAvailable() {
+  try {
+    const { acpDriverAvailability } = require("./acp-driver.cjs");
+    return acpDriverAvailability().ok ? ACP_CLI_KINDS : new Set();
+  } catch {
+    return new Set();
+  }
+}
+
+// 라이브 집합: 네이티브 4종 + (코어가 ACP 러너를 갖고 있으면) ACP 3종.
+const CLI_EXECUTABLE_KINDS = new Proxy(NATIVE_CLI_KINDS, {
+  get(target, prop) {
+    const live = new Set([...target, ...acpKindsAvailable()]);
+    const value = live[prop];
+    return typeof value === "function" ? value.bind(live) : value;
+  },
+});
+const EXECUTABLE_KINDS = new Proxy(NATIVE_CLI_KINDS, {
+  get(target, prop) {
+    const live = new Set([...target, ...acpKindsAvailable(), ...API_EXECUTABLE_KINDS]);
+    const value = live[prop];
+    return typeof value === "function" ? value.bind(live) : value;
+  },
+});
 
 function apiRuntime(kind, model, source) {
   if (!API_EXECUTABLE_KINDS.has(kind)) return null;
@@ -56,7 +84,10 @@ function resolveRuntime({ db, prefs, explicit }) {
     const bin = RUNTIME_BIN[explicit];
     if (!bin) throw new NoRuntimeError(`unknown runtime: ${explicit}`);
     if (!CLI_EXECUTABLE_KINDS.has(explicit)) {
-      throw new NoRuntimeError(`runtime '${explicit}' has no v2 streaming driver yet (available: ${[...EXECUTABLE_KINDS].join(", ")})`);
+      const acpHint = ACP_CLI_KINDS.has(explicit)
+        ? ` — its ACP driver needs the desktop core with electron/runtime/acp.js (npm run vendor:core / agentlas doctor)`
+        : "";
+      throw new NoRuntimeError(`runtime '${explicit}' has no v2 streaming driver yet (available: ${[...EXECUTABLE_KINDS].join(", ")})${acpHint}`);
     }
     const p = whichSync(bin);
     if (!p) throw new NoRuntimeError(`runtime '${explicit}' requested but '${bin}' is not on PATH`);
@@ -109,6 +140,8 @@ module.exports = {
   NoRuntimeError,
   EXECUTABLE_KINDS,
   CLI_EXECUTABLE_KINDS,
+  NATIVE_CLI_KINDS,
+  ACP_CLI_KINDS,
   API_EXECUTABLE_KINDS,
   sharedRuntimeKind,
 };

package/engine/ui/commands-catalog.cjs

@@ -107,6 +107,8 @@ const CATALOG = [
   { name: "import", group: "advanced", tier: "more", surfaces: BOTH, args: "<path>", argsKo: "<경로>", ko: "로컬 폴더 에이전트 가져오기", en: "Import a local folder agent" },
   { name: "cd", group: "advanced", tier: "more", surfaces: BOTH, args: "<agent>", argsKo: "<에이전트>", ko: "그 에이전트의 폴더 경로를 출력", en: "Print that agent's folder path" },
   { name: "native", group: "advanced", tier: "more", surfaces: BOTH, args: "prepare <agent>", argsKo: "prepare <에이전트>", ko: "네이티브 CLI 컨텍스트 생성", en: "Prepare native CLI context" },
+  // CLI only: stdout is the protocol wire, so it cannot run inside the REPL.
+  { name: "acp", group: "advanced", tier: "more", surfaces: CLI, args: "[--info]", ko: "에디터(Zed·JetBrains)용 ACP 에이전트로 실행", en: "Serve Agentlas as an ACP agent for editors (Zed, JetBrains)" },
   { name: "mcp", group: "advanced", tier: "more", surfaces: BOTH, args: "[list|probe <id>]", ko: "MCP 서버", en: "MCP servers" },
   { name: "plugin", group: "advanced", tier: "more", surfaces: BOTH, args: "<add <slug>|list|remove>", ko: "Hub 플러그인 (MCP 서버)", en: "Hub plugins (MCP servers)" },
   { name: "creds", group: "advanced", tier: "more", surfaces: BOTH, args: "<list|save|file>", ko: "API 키 보관 (값은 절대 표시 안 함)", en: "API keys (values are never printed)" },

package/engine/ui/palette.cjs

@@ -28,7 +28,8 @@ const SLASH_COMMANDS = catalog.forSurface("repl").map((entry) => ({
 }));
 
 const SLASH_NAMES = SLASH_COMMANDS.map((c) => c.command);
-const RUNTIME_KINDS = ["claude-code", "codex", "agy", "gemini"];
+// /runtime 완성 후보 — 정본(runtimes/kinds.cjs)의 네이티브 스폰 러너 4종.
+const RUNTIME_KINDS = require("../runtimes/kinds.cjs").NATIVE_CLI_KINDS;
 const EFFORT_LEVELS = ["none", "minimal", "low", "medium", "high", "xhigh", "max"];
 const PERM_LEVELS = ["read", "write", "full"];
 // 세션 인자를 받는 명령 — 완성 후보를 살아있는 세션 키(s1, s2…)로 채운다.

package/engine/ui/repl.cjs

@@ -791,7 +791,8 @@ function handleSlash(ctx, cmdline, api) {
        * (REPL의 평문 입력이 곧 run이다).
        */
       // help/agents/list/mcp/doctor 등은 위 케이스에서 이미 처리된다.
-      const REPL_EXCLUDED = new Set(["firm", "setup", "run"]);
+      // acp: stdout becomes the protocol wire — meaningless (and destructive) inside the REPL.
+      const REPL_EXCLUDED = new Set(["firm", "setup", "run", "acp"]);
       if (!REPL_EXCLUDED.has(cmd) && commands.COMMANDS[cmd]) {
         const result = commands.COMMANDS[cmd]().run(ctx, rest);
         if (result && typeof result.then === "function") {

package/engine/ui/shell.cjs

@@ -45,6 +45,35 @@ function loadRenderer() {
   }
 }
 
+/*
+ * 제어 블록 스트리퍼 — 정본은 벤더 코어의 shared/agent-control-blocks
+ * (Desktop·Mobile 과 같은 규칙: Memory Events/Delegate/Automation 헤딩,
+ * <<agentlas-ask>>·<<agentlas-surface>>·<<agentlas-one-followups>>·goal-complete
+ * 마커, 스트리밍 미완성 꼬리까지). 손 regex 는 Memory Events 만 알아 나머지
+ * 마커가 화면에 원문으로 샜다. 옛 벤더 번들이라 정본이 없으면 종전 regex 로
+ * fail-open — 스트리퍼 부재가 TUI 를 죽여선 안 된다.
+ */
+let _stripCanonical; // undefined=미시도 · null=정본 없음 · function=정본
+function stripControlBlocksForDisplay(text, streaming) {
+  if (_stripCanonical === undefined) {
+    try {
+      const loaded = require("../core/desktop-core.cjs").loadCoreShared("agent-control-blocks");
+      _stripCanonical = loaded && loaded.module && typeof loaded.module.stripAgentControlBlocks === "function"
+        ? loaded.module.stripAgentControlBlocks
+        : null;
+    } catch {
+      _stripCanonical = null;
+    }
+  }
+  const value = String(text);
+  if (_stripCanonical) {
+    try {
+      return _stripCanonical(value, { streaming: !!streaming });
+    } catch { /* 정본 실패 → 아래 종전 regex 로 fail-open */ }
+  }
+  return value.replace(/\n#{1,3} Memory Events\b[\s\S]*$/, "\n");
+}
+
 /* Ui 를 상속해 write 초크포인트만 렌더러로 돌린다. */
 class ShellUi extends Ui {
   /*
@@ -127,16 +156,22 @@ class ShellUi extends Ui {
     if (!this._md) this.streamStart();
     this._mdText += String(text);
     /*
-     * Memory Events 봉투는 런타임 계약(펜스 파이프라인이 수확)이지 사용자용이 아니다.
+     * 제어 블록은 런타임 계약(펜스 파이프라인이 수확)이지 사용자용이 아니다.
      * append-only 기본 REPL은 이미 찍힌 봉투를 지울 수 없지만, 누적 재렌더는
      * 표시만 잘라낼 수 있다 — 수확 경로(st.text/fences)는 건드리지 않는다.
+     * 정본 스트리퍼의 streaming 모드가 미완성 마커 꼬리도 한 프레임 감춘다.
      */
-    const visible = this._mdText.replace(/\n#{1,3} Memory Events\b[\s\S]*$/, "\n");
+    const visible = stripControlBlocksForDisplay(this._mdText, true);
     this._md.setText(visible);
     this._tui.requestRender();
     this._streaming = true;
   }
   streamEnd() {
+    // 확정 렌더 — streaming 모드가 감춰 두던 꼬리를 settled 규칙으로 최종 판정한다.
+    if (this._md && this._mdText) {
+      this._md.setText(stripControlBlocksForDisplay(this._mdText, false));
+      this._tui.requestRender();
+    }
     this._md = null;
     this._mdText = "";
     this._streaming = false;
@@ -615,4 +650,4 @@ async function startShell(ctx, opts = {}) {
   return new Promise(() => {});
 }
 
-module.exports = { startShell };
+module.exports = { startShell, stripControlBlocksForDisplay };

package/engine/vendor/desktop-core.manifest.json

@@ -1,7 +1,7 @@
 {
-  "version": "2",
-  "url": "https://github.com/agentlas-ai/agentlas-terminal/releases/download/desktop-core-v2/desktop-core.tar.gz",
-  "sha256": "782760c34af1d06b9efd212d48ba032fe46907bdc8bc836025c44fc658968d6f",
-  "sizeBytes": 12295321,
-  "writtenAt": "2026-08-09T21:43:34.707Z"
+  "version": "3",
+  "url": "https://github.com/agentlas-ai/agentlas-terminal/releases/download/desktop-core-v3/desktop-core.tar.gz",
+  "sha256": "a72cce0ccfe718e2a9255b1b4722d330ef9887e22be92c654a0435f17f5ee178",
+  "sizeBytes": 12437404,
+  "writtenAt": "2026-08-18T04:09:04.540Z"
 }

package/engine/workforce/capture.cjs

@@ -24,14 +24,10 @@ const path = require("node:path");
 const { spawn } = require("node:child_process");
 const { dbPath, userDataDir } = require("../core/paths.cjs");
 
-// 캡처 드라이버가 검증된 런타임만. v2 detect.cjs의 RUNTIME_BIN에는 kimi/grok/cursor도
-// 있지만 buildArgs/텍스트 추출 계약이 없으므로 여기 목록에 절대 조용히 추가하지 않는다.
-const RUNTIME_BIN = {
-  "claude-code": "claude",
-  codex: "codex",
-  agy: "agy",
-  gemini: "gemini",
-};
+// 캡처 드라이버가 검증된 런타임만. 정본(runtimes/kinds.cjs)의 RUNTIME_BIN에는 kimi/grok/cursor도
+// 있지만 buildArgs/텍스트 추출 계약이 없으므로 캡처 검증 파생본만 쓴다 — 새 kind 를
+// 정본에 추가해도 capture:true 를 명시하기 전엔 여기 조용히 들어오지 않는다.
+const { CAPTURE_RUNTIME_BIN: RUNTIME_BIN } = require("../runtimes/kinds.cjs");
 
 const SERVICE = "com.agentlas.desktop";
 

package/package.json

@@ -1,11 +1,12 @@
 {
   "name": "agentlas",
-  "version": "1.0.47",
+  "version": "1.0.48",
   "description": "Agentlas project terminal — run project controllers and task-scoped agent teams from the terminal. Standalone: no desktop app process required.",
   "bin": {
     "agentlas": "bin/agentlas.cjs"
   },
   "scripts": {
+    "test": "sh test/smoke.sh",
     "smoke": "sh test/smoke.sh",
     "test:release-contracts": "npm run smoke",
     "sync:architecture": "node scripts/sync-architecture-from-desktop.cjs",