agentlas 0.9.10 → 1.0.2

package/engine/commands/list.cjs

@@ -0,0 +1,49 @@
+"use strict";
+/*
+ * list — 설치 에이전트/회사 + 활성 런타임.
+ * 공유 DB(데스크탑과 동일)를 읽는다. visibility='background'/'private' 빌트인은
+ * 데스크탑과 동일하게 목록에서 숨긴다.
+ */
+const { activeRuntimeRow, listAvailableCliRuntimes } = require("../runtimes/detect.cjs");
+const { listAgents } = require("../agents/registry.cjs");
+
+function run(ctx) {
+  const db = ctx.db();
+  // 프라이버시 정책(웹 전용/백그라운드 제외)은 registry가 소유한다 — 직접 SQL 금지.
+  const agents = listAgents(db).map((a) => ({
+    slug: a.slug, name: a.name, name_en: a.nameEn, tagline: a.tagline, tagline_en: a.taglineEn, builtin: a.builtin,
+  }));
+  const firms = ctx.tableExists(db, "firms")
+    ? db.prepare("SELECT id, name FROM firms ORDER BY name").all()
+    : [];
+
+  const en = ctx.lang === "en";
+  ctx.out(ctx.ui.bold(en ? "Installed agents" : "설치된 에이전트"));
+  if (!agents.length) {
+    ctx.out("  " + (en ? "(none yet — try: agentlas search \"what you need\")" : "  (아직 없음 — agentlas search \"필요한 것\" 으로 찾아보세요)"));
+  }
+  for (const a of agents) {
+    const name = en && a.name_en ? a.name_en : a.name;
+    const tag = en && a.tagline_en ? a.tagline_en : a.tagline;
+    ctx.out(`  ${ctx.ui.accent(a.slug.padEnd(24))} ${name}${tag ? ctx.ui.dim(" — " + tag) : ""}`);
+  }
+  if (firms.length) {
+    ctx.out("");
+    ctx.out(ctx.ui.bold(en ? "Companies" : "회사"));
+    for (const f of firms) ctx.out(`  ${ctx.ui.accent(String(f.id).padEnd(24))} ${f.name}`);
+  }
+
+  const active = activeRuntimeRow(db);
+  const clis = listAvailableCliRuntimes();
+  ctx.out("");
+  ctx.out(ctx.ui.bold(en ? "Runtime" : "런타임"));
+  if (active) {
+    ctx.out(`  active: ${active.kind}${active.model ? ` (${active.model})` : ""}${active.backend ? ` via ${active.backend}` : ""}`);
+  } else {
+    ctx.out("  active: " + (en ? "(not set)" : "(미설정)"));
+  }
+  ctx.out(`  detected CLIs: ${clis.length ? clis.map((c) => c.kind).join(", ") : (en ? "none on PATH" : "PATH에 없음")}`);
+  return 0;
+}
+
+module.exports = { run };

package/engine/commands/login.cjs

@@ -0,0 +1,68 @@
+"use strict";
+/*
+ * login — Agentlas Cloud 로그인 (데스크탑과 동일한 loopback 브라우저 플로우).
+ * 웹 /account?desktop=1&callback=<loopback+state> 이 유효 세션이면 callback의 state를
+ * 보존한 채 session을 추가해 302한다. Terminal은 state를 1회 검증한 뒤에만 저장한다.
+ * 보안 속성(1회용 state guard, GET-only, no-store)은 cloud/auth.cjs 가 소유한다.
+ */
+const auth = require("../cloud/auth.cjs");
+
+async function run(ctx, args = []) {
+  const ko = ctx.lang === "ko";
+  const force = args.includes("--force");
+  if (!force) {
+    const existing = auth.cloudSessionCookie();
+    if (existing) {
+      try {
+        const j = await auth.fetchSessionMeta(existing);
+        if (j && j.authenticated) {
+          ctx.out(ko
+            ? `이미 로그인되어 있습니다 (${(j.user && j.user.email) || "?"}). 다시 인증하려면: agentlas login --force`
+            : `Already signed in (${(j.user && j.user.email) || "?"}). Re-authenticate with agentlas login --force`);
+          return 0;
+        }
+      } catch { /* 확인 실패 — 새로 로그인 진행 */ }
+    }
+  }
+
+  let value;
+  try {
+    value = await auth.waitForLoopbackSession({
+      onLoginUrl(url) {
+        ctx.out(ko
+          ? "브라우저에서 Agentlas에 로그인하세요 (자동으로 열립니다):"
+          : "Sign in to Agentlas in the browser (opening automatically):");
+        ctx.out("  " + ctx.ui.accent(url));
+        auth.openInBrowser(url);
+      },
+    });
+  } catch (e) {
+    ctx.err(String((e && e.message) || e));
+    return 1;
+  }
+
+  const p = auth.saveCliSession(value);
+  ctx.out((ko ? "세션 저장됨: " : "Session saved: ") + ctx.ui.dim(p));
+
+  // 저장 직후 세션 유효성 확인 (whoami 와 동일한 출력 — 명령끼리 참조 금지 규칙 때문에 인라인)
+  try {
+    const j = await auth.fetchSessionMeta(auth.cloudSessionCookie());
+    if (j && j.authenticated) {
+      const email = (j.user && j.user.email) || "?";
+      const ws = j.workspace || {};
+      ctx.out(ko
+        ? `로그인됨: ${ctx.ui.bold(email)}  ·  작업 공간: ${ws.name || "?"} (${ws.plan || "free"})`
+        : `Signed in: ${ctx.ui.bold(email)}  ·  workspace: ${ws.name || "?"} (${ws.plan || "free"})`);
+      return 0;
+    }
+    ctx.out(ko
+      ? "세션이 만료되었거나 유효하지 않습니다. `agentlas login`으로 다시 로그인하세요."
+      : "The session is expired or invalid. Sign in again with agentlas login.");
+    return 1;
+  } catch (e) {
+    ctx.err((ko ? "세션 확인 실패: " : "Session check failed: ") + String((e && e.message) || e));
+    return 1;
+  }
+}
+
+module.exports = { run };

package/engine/commands/logout.cjs

@@ -0,0 +1,28 @@
+"use strict";
+/*
+ * logout — CLI 세션 파일 삭제. 네트워크 호출 없음(서버 세션은 웹에서 관리).
+ * AGENTLAS_SESSION env 는 파일과 별개 경로라 삭제 후에도 로그인 상태로 보일 수 있다 — 경고만 한다.
+ */
+const auth = require("../cloud/auth.cjs");
+
+function run(ctx) {
+  const ko = ctx.lang === "ko";
+  let result;
+  try {
+    result = auth.deleteCliSession();
+  } catch (e) {
+    ctx.err((ko ? "세션 파일을 삭제하지 못했습니다: " : "Could not delete the session file: ") + String((e && e.message) || e));
+    return 1;
+  }
+  ctx.out(result.existed
+    ? (ko ? "로그아웃되었습니다 (CLI 세션 삭제)." : "Signed out (CLI session deleted).")
+    : (ko ? "저장된 CLI 세션이 없습니다." : "No saved CLI session."));
+  if (process.env.AGENTLAS_SESSION) {
+    ctx.out(ko
+      ? "경고: AGENTLAS_SESSION 이 아직 설정되어 있어 CLI가 로그인 상태로 보일 수 있습니다."
+      : "Warning: AGENTLAS_SESSION is still set, so the CLI may appear signed in.");
+  }
+  return 0;
+}
+
+module.exports = { run };

package/engine/commands/mcp.cjs

@@ -0,0 +1,91 @@
+"use strict";
+/*
+ * mcp — 등록된 MCP 서버 목록 + stdio 연결 프리플라이트.
+ *
+ *   agentlas mcp             공유 DB의 레지스트리 목록 (기존 동작 유지)
+ *   agentlas mcp probe <id>  신뢰 레지스트리 행을 격리 자식 env로 띄워
+ *                            initialize→tools/list 핸드셰이크만 확인
+ *
+ * probe는 engine/mcp 모듈만 쓴다: 서버 정의는 항상 신뢰 레지스트리 행에서
+ * 물질화하고(materialize), 자식 env는 agentlas.mcp-child-launch.v1 경계를 따른다.
+ * "연결됨"은 툴 호출 성공을 의미하지 않는다 — 프리플라이트일 뿐이다.
+ */
+const { userDataDir } = require("../core/paths.cjs");
+const { materializeTrustedSystemMcpServer } = require("../mcp/inventory.cjs");
+const { probeSystemMcpServerConnection } = require("../mcp/probe.cjs");
+
+function list(ctx) {
+  const en = ctx.lang === "en";
+  const db = ctx.db();
+  if (!ctx.tableExists(db, "mcp_servers")) {
+    ctx.out(en ? "No MCP servers registered." : "등록된 MCP 서버가 없습니다.");
+    return 0;
+  }
+  const rows = db.prepare("SELECT id, name FROM mcp_servers ORDER BY name").all();
+  if (!rows.length) {
+    ctx.out(en ? "No MCP servers registered." : "등록된 MCP 서버가 없습니다.");
+    return 0;
+  }
+  ctx.out(ctx.ui.bold(en ? "MCP servers" : "MCP 서버"));
+  for (const r of rows) ctx.out(`  ${ctx.ui.accent(String(r.id).padEnd(28))} ${r.name || ""}`);
+  return 0;
+}
+
+async function probe(ctx, args) {
+  const en = ctx.lang === "en";
+  const ref = String(args[0] || "").trim();
+  if (!ref) {
+    ctx.err(en ? "Usage: agentlas mcp probe <server-id|catalog-id>" : "사용법: agentlas mcp probe <server-id|catalog-id>");
+    return 1;
+  }
+  const db = ctx.db();
+  if (!ctx.tableExists(db, "mcp_servers")) {
+    ctx.err(en ? "No MCP servers registered." : "등록된 MCP 서버가 없습니다.");
+    return 1;
+  }
+  // catalog_id는 데스크탑 스키마 열 — 오래된 DB에는 없을 수 있어 방어적으로 조회.
+  const byCatalog = ctx.columnExists(db, "mcp_servers", "catalog_id");
+  const row = byCatalog
+    ? db.prepare("SELECT id, catalog_id, name, name_en, transport, command, args_json, env_keys_json, enabled FROM mcp_servers WHERE id=? OR catalog_id=? LIMIT 1").get(ref, ref)
+    : db.prepare("SELECT id, NULL AS catalog_id, name, name_en, transport, command, args_json, env_keys_json, enabled FROM mcp_servers WHERE id=? LIMIT 1").get(ref);
+  if (!row) {
+    ctx.err(en ? `MCP server not found: ${ref}` : `MCP 서버를 찾을 수 없습니다: ${ref}`);
+    return 1;
+  }
+  const server = materializeTrustedSystemMcpServer(row, { userDataDir: userDataDir() });
+  if (!server) {
+    // 이유를 지어내지 않는다 — materialize는 비활성/비-stdio/안전하지 않은
+    // 정의를 하나의 fail-closed로 접기 때문에 관찰 가능한 사실만 알린다.
+    ctx.err(en
+      ? `'${ref}' is not probe-eligible (disabled, non-stdio transport, or an unsafe runtime definition).`
+      : `'${ref}' 은(는) probe 대상이 아닙니다 (비활성, stdio가 아닌 transport, 또는 안전하지 않은 실행 정의).`);
+    return 1;
+  }
+  ctx.out(ctx.ui.dim(en
+    ? `Probing ${server.catalog_id} (isolated child env, handshake only)…`
+    : `${server.catalog_id} 연결 확인 중 (격리 자식 env, 핸드셰이크만)…`));
+  const result = await probeSystemMcpServerConnection(server, { userDataDir: userDataDir(), cwd: process.cwd() });
+  if (result.connected) {
+    const toolCount = Array.isArray(result.tools) ? result.tools.length : 0;
+    ctx.out(`${ctx.ui.green("connected")} ${ctx.ui.bold(server.catalog_id)} · ${en ? `${toolCount} tool(s) listed` : `툴 ${toolCount}개 확인`}`);
+    ctx.out(ctx.ui.dim(en
+      ? "Preflight only: connection readiness does not imply tool-call success."
+      : "프리플라이트일 뿐입니다: 연결 준비됨 ≠ 툴 호출 성공."));
+    return 0;
+  }
+  ctx.err(`${ctx.ui.red("failed")} ${ctx.ui.bold(server.catalog_id)} · ${result.reason}`);
+  return 1;
+}
+
+function run(ctx, args = []) {
+  const [sub, ...rest] = args;
+  if (!sub) return list(ctx);
+  if (sub === "probe") return probe(ctx, rest);
+  const en = ctx.lang === "en";
+  ctx.err(en
+    ? `unknown mcp subcommand: ${sub} (available: probe)`
+    : `알 수 없는 mcp 하위 명령: ${sub} (사용 가능: probe)`);
+  return 1;
+}
+
+module.exports = { run };

package/engine/commands/memory.cjs

@@ -0,0 +1,21 @@
+"use strict";
+/*
+ * memory — 레거시 마크다운 메모리 → 공유 agentlas.sqlite 이관 (Phase 1b).
+ *   agentlas memory import <folder-or-file> --agent <agentId> [--apply]
+ * 기본은 dry-run 프리뷰, --apply 일 때만 쓴다. 로직은 복원된 계약 모듈
+ * engine/agentlas-memory-import.cjs 가 소유한다(여기서는 주입만).
+ * v1의 fail(process.exit)은 v2에서 throw 로 바꿔 엔진이 stderr+exit 1 처리한다.
+ */
+const { cmdMemory } = require("../agentlas-memory-import.cjs");
+
+function run(ctx, args) {
+  cmdMemory({
+    db: ctx.db(),
+    args,
+    out: ctx.out,
+    fail: (msg) => { throw new Error(String(msg ?? "")); },
+  });
+  return 0;
+}
+
+module.exports = { run };

package/engine/commands/multimodal.cjs

@@ -0,0 +1,91 @@
+"use strict";
+/*
+ * multimodal — 이미지/영상/오디오 공급자 상태·선택 (공유 DB meta에 저장, 데스크탑과 공유).
+ *   agentlas multimodal                 현재 선택 + 카탈로그
+ *   agentlas multimodal set <modality> <provider-id>
+ * 키 존재 여부는 credentials.env(standalone)만 관측한다 — 값은 출력하지 않는다.
+ */
+const { sharedEnvKeys } = require("./env.cjs");
+
+const MULTIMODAL_META_KEY = "multimodal_settings_v1";
+
+const PROVIDERS = [
+  { id: "codex-cli-image", modality: "image", label: "Codex CLI image", labelKo: "Codex CLI 이미지", envKeys: [], billing: "subscription" },
+  { id: "grok-cli-image", modality: "image", label: "Grok CLI image (Imagine)", labelKo: "Grok CLI 이미지 (Imagine)", envKeys: [], billing: "subscription" },
+  { id: "grok-cli-video", modality: "video", label: "Grok CLI video (Imagine)", labelKo: "Grok CLI 영상 (Imagine)", envKeys: [], billing: "subscription" },
+  { id: "openai-image", modality: "image", label: "OpenAI Images API", labelKo: "OpenAI 이미지 API", envKeys: ["OPENAI_API_KEY"], billing: "paid-api" },
+  { id: "google-image", modality: "image", label: "Google Gemini Image", labelKo: "Google Gemini 이미지", envKeys: ["GOOGLE_API_KEY"], billing: "paid-api" },
+  { id: "runway-video", modality: "video", label: "Runway API", labelKo: "Runway API", envKeys: ["RUNWAY_API_KEY"], billing: "paid-api" },
+  { id: "google-veo", modality: "video", label: "Google Veo", labelKo: "Google Veo", envKeys: ["GOOGLE_CLOUD_PROJECT", "GOOGLE_APPLICATION_CREDENTIALS"], billing: "provider-billing" },
+  { id: "openai-sora", modality: "video", label: "OpenAI Sora API", labelKo: "OpenAI Sora API", envKeys: ["OPENAI_API_KEY"], billing: "paid-api" },
+  { id: "openai-audio", modality: "audio", label: "OpenAI Audio", labelKo: "OpenAI 오디오", envKeys: ["OPENAI_API_KEY"], billing: "paid-api" },
+  { id: "elevenlabs-audio", modality: "audio", label: "ElevenLabs", labelKo: "ElevenLabs", envKeys: ["ELEVENLABS_API_KEY"], billing: "paid-api" },
+  { id: "deepgram-audio", modality: "audio", label: "Deepgram", labelKo: "Deepgram", envKeys: ["DEEPGRAM_API_KEY"], billing: "paid-api" },
+  { id: "replicate-video", modality: "video", label: "Replicate", labelKo: "Replicate", envKeys: ["REPLICATE_API_TOKEN"], billing: "paid-api" },
+];
+const DEFAULTS = { imageProvider: "codex-cli-image", videoProvider: "runway-video", audioProvider: "openai-audio" };
+
+function normalizeSettings(input) {
+  return { ...DEFAULTS, ...(input || {}) };
+}
+
+function getSettings(db) {
+  let raw = null;
+  try {
+    const row = db.prepare("SELECT value FROM meta WHERE key=?").get(MULTIMODAL_META_KEY);
+    raw = row && row.value;
+  } catch { raw = null; }
+  try {
+    return normalizeSettings(raw ? JSON.parse(raw) : null);
+  } catch {
+    return normalizeSettings(null);
+  }
+}
+
+function saveSettings(db, patch) {
+  const next = normalizeSettings({ ...getSettings(db), ...patch, updatedAt: new Date().toISOString() });
+  db.prepare("INSERT INTO meta(key,value) VALUES(?,?) ON CONFLICT(key) DO UPDATE SET value=excluded.value")
+    .run(MULTIMODAL_META_KEY, JSON.stringify(next));
+  return next;
+}
+
+function run(ctx, args) {
+  const ko = ctx.lang === "ko";
+  const db = ctx.db();
+
+  if (args[0] === "set") {
+    const modality = String(args[1] || "");
+    const providerId = String(args[2] || "");
+    const provider = PROVIDERS.find((p) => p.id === providerId);
+    if (!["image", "video", "audio"].includes(modality) || !provider || provider.modality !== modality) {
+      ctx.err(ko
+        ? "사용법: agentlas multimodal set <image|video|audio> <provider-id>  (id는 agentlas multimodal 목록 참고)"
+        : "Usage: agentlas multimodal set <image|video|audio> <provider-id>  (ids: agentlas multimodal)");
+      return 1;
+    }
+    const key = modality === "image" ? "imageProvider" : modality === "video" ? "videoProvider" : "audioProvider";
+    saveSettings(db, { [key]: providerId });
+    ctx.out(`${ctx.ui.green("✓")} ${modality} → ${providerId}`);
+    return 0;
+  }
+
+  const settings = getSettings(db);
+  const keys = new Set(sharedEnvKeys());
+  const selected = { image: settings.imageProvider, video: settings.videoProvider, audio: settings.audioProvider };
+  for (const modality of ["image", "video", "audio"]) {
+    ctx.out(ctx.ui.bold(modality));
+    for (const p of PROVIDERS.filter((x) => x.modality === modality)) {
+      const isSel = p.id === selected[modality];
+      const needsKeys = (p.envKeys || []).filter((k) => !keys.has(k) && !process.env[k]);
+      const keyNote = p.envKeys.length
+        ? (needsKeys.length ? ctx.ui.dim(` (${ko ? "키 필요" : "needs"}: ${needsKeys.join(", ")})`) : ctx.ui.dim(` (${ko ? "키 있음" : "keys ok"})`))
+        : "";
+      ctx.out(`  ${isSel ? ctx.ui.accent("▸") : " "} ${p.id.padEnd(20)} ${ko ? p.labelKo : p.label}${keyNote}`);
+    }
+  }
+  ctx.out("");
+  ctx.out(ctx.ui.dim(ko ? "변경: agentlas multimodal set <image|video|audio> <provider-id>" : "Change: agentlas multimodal set <image|video|audio> <provider-id>"));
+  return 0;
+}
+
+module.exports = { run, getSettings, saveSettings, PROVIDERS, DEFAULTS, MULTIMODAL_META_KEY };

package/engine/commands/native.cjs

@@ -0,0 +1,34 @@
+"use strict";
+/* native — 네이티브 CLI 문맥 파일 명시 생성: agentlas native prepare <agent> */
+const { findAgent } = require("../agents/registry.cjs");
+const { agentFolder, ensureNativeFiles } = require("../agents/files.cjs");
+
+function run(ctx, args) {
+  const ko = ctx.lang === "ko";
+  const sub = String(args[0] || "help");
+  const query = args[1];
+  if (sub === "help" || sub === "--help" || sub === "-h") {
+    ctx.out(ko
+      ? "사용법: agentlas native prepare <에이전트>  ·  네이티브 CLI 문맥 파일을 명시적으로 생성"
+      : "usage: agentlas native prepare <agent>  ·  explicitly create native CLI context files");
+    return 0;
+  }
+  if (sub !== "prepare" || !query) {
+    ctx.err(ko ? "사용법: agentlas native prepare <에이전트>" : "usage: agentlas native prepare <agent>");
+    return 1;
+  }
+  const agent = findAgent(ctx.db(), query);
+  if (!agent) {
+    ctx.err(ko ? `에이전트를 찾지 못했습니다: ${query}` : `Agent not found: ${query}`);
+    return 1;
+  }
+  const folder = agentFolder(agent);
+  const created = ensureNativeFiles(agent, folder);
+  ctx.out(`${ko ? "네이티브 CLI 문맥" : "Native CLI context"}: ${folder}`);
+  ctx.out(created.length
+    ? `${ko ? "생성됨" : "Created"}: ${created.join(", ")}`
+    : (ko ? "변경 없음: 필요한 파일이 이미 있습니다." : "No changes: the context files already exist."));
+  return 0;
+}
+
+module.exports = { run };

package/engine/commands/netadmin.cjs

@@ -0,0 +1,31 @@
+"use strict";
+/*
+ * netadmin — 로컬 에이전트 네트워크 관리 (init|status|reindex|bench|add-source).
+ *
+ * v1 디스패처 매핑 그대로:
+ *   `agentlas netadmin <sub…>` → cmdHep(["network", ...rest])
+ *   (Hephaestus의 `network` 서브커맨드가 로컬 네트워크 admin이다.
+ *    터미널의 `agentlas network`는 Workforce Ontology 경로로 따로 살고,
+ *    netadmin이 그 이름 충돌을 피해 admin 표면만 노출한다.)
+ *
+ * v1 가드 그대로:
+ *   - help 토큰 → usage, exit 0
+ *   - 첫 인자가 init|status|reindex|bench|add-source 밖 → usage 실패 exit 1
+ */
+const { create, usageFor, isHelpToken } = require("../hephaestus/runtime.cjs");
+
+const NETADMIN_SUBCOMMANDS = ["init", "status", "reindex", "bench", "add-source"];
+
+async function run(ctx, args) {
+  if (args.some(isHelpToken)) {
+    ctx.out(usageFor("netadmin", ctx.lang));
+    return 0;
+  }
+  if (!NETADMIN_SUBCOMMANDS.includes(args[0])) {
+    ctx.err("✖ " + usageFor("netadmin", ctx.lang));
+    return 1;
+  }
+  return create(ctx).cmdHep(["network", ...args]);
+}
+
+module.exports = { run };

package/engine/commands/oberon.cjs

@@ -0,0 +1,70 @@
+"use strict";
+/*
+ * oberon — Oberon 필름 스튜디오 (터미널 헤드리스 렌더).
+ * v1 모놀리스 §12213-12580 (cmdOberon + oberonHelp) 포팅 — 얇은 명령 래퍼.
+ * GUI 없이 매니페스트 하나로 영상 렌더를 돌린다. 손으로 쓰던 JSON+env 노가다 대신:
+ *   agentlas oberon scaffold my.json      → 편집 가능한 렌더 매니페스트 생성
+ *   agentlas oberon render my.json        → 헤드리스 렌더 스폰 + 진행률 스트리밍
+ *   agentlas oberon list                  → 최근 렌더 산출물
+ *
+ * v2 규칙: 기능 로직은 engine/oberon/*에만 있다. 이 파일은 서브커맨드 디스패치와
+ * OberonFail → "✖ msg" + exit 1 변환(v1 fail 계약)만 담당한다.
+ */
+const { scaffold } = require("../oberon/manifest.cjs");
+const { render } = require("../oberon/render.cjs");
+const { list, open } = require("../oberon/outputs.cjs");
+
+function help(io) {
+  io.out(
+    [
+      "agentlas oberon — AI film rendering from the terminal",
+      "",
+      "  oberon scaffold [out.json] [--title T] [--aspect 16:9] [--shots N] [--titles] [--overwrite]",
+      "                         create an editable manifest; existing files require explicit --overwrite",
+      "  oberon render <manifest.json> [--delivery DIR] [--max-shots N] [--open] [--dry-run]",
+      "                         spawn full Electron render + stream progress (GEMINI_API_KEY vault required)",
+      "  oberon list            최근 렌더 산출물",
+      "  oberon open [path]     산출물 폴더 열기",
+      "",
+      "Fill prompts directly, or ask an agent: agentlas run oberon-film-studio \"30-second fragrance ad\"",
+    ].join("\n"),
+  );
+  return 0;
+}
+
+// deps는 테스트/장래 배선용 seam (render의 진입점·spawn 주입) — 일반 경로에서는 미사용.
+async function run(ctx, args, deps) {
+  const sub = args[0] || "help";
+  const rest = args.slice(1);
+  const io = { out: ctx.out, err: ctx.err };
+  try {
+    switch (sub) {
+      case "scaffold":
+      case "new":
+        return scaffold(io, rest);
+      case "render":
+        return await render(io, rest, deps || {});
+      case "list":
+      case "ls":
+        return list(io);
+      case "open":
+        return open(io, rest);
+      case "help":
+      case "--help":
+      case "-h":
+        return help(io);
+      default:
+        ctx.err(`✖ Unknown oberon subcommand: ${sub}  (scaffold|render|list|open|help)`);
+        return 1;
+    }
+  } catch (e) {
+    if (e && e.oberonFail) {
+      // v1 fail() 계약: stderr에 "✖ " 접두 + exit 1. v2는 exit 대신 코드 반환.
+      ctx.err(`✖ ${e.message}`);
+      return 1;
+    }
+    throw e;
+  }
+}
+
+module.exports = { run };

package/engine/commands/ontology.cjs

@@ -0,0 +1,24 @@
+"use strict";
+/*
+ * ontology — 프로젝트 온톨로지 상태/소스 등록 (v1 cmdOntology 포팅).
+ * status/list는 비변형, add/open은 초기화된 프로젝트에서만 동작한다.
+ */
+const { runOntologyCli } = require("../project/ontology.cjs");
+
+function run(ctx, args) {
+  try {
+    const lines = runOntologyCli(args, {
+      cwd: process.cwd(),
+      projectPath: process.cwd(),
+      lang: ctx.lang,
+      notify: (line) => ctx.out(line),
+    });
+    for (const line of lines) ctx.out(line);
+    return 0;
+  } catch (e) {
+    ctx.err(String((e && e.message) || e));
+    return 1;
+  }
+}
+
+module.exports = { run };

package/engine/commands/open.cjs

@@ -0,0 +1,48 @@
+"use strict";
+/*
+ * open — 기존 대화 재개: agentlas open <chat-id-prefix>
+ * 해당 챗의 에이전트로 REPL을 열고 같은 chatId에 이어 쓴다
+ * (CLI resume 세션도 chat_runtime_sessions에서 fingerprint 일치 시 복원).
+ */
+const { rowToAgent, isPrivateWebOnlyAgentRow } = require("../agents/registry.cjs");
+
+function run(ctx, args) {
+  const ko = ctx.lang === "ko";
+  const prefix = String(args[0] || "").trim();
+  if (!prefix) {
+    ctx.err(ko ? "사용법: agentlas open <chat-id 앞부분>  (agentlas chats 로 목록)" : "Usage: agentlas open <chat-id-prefix>  (list with: agentlas chats)");
+    return 1;
+  }
+  const db = ctx.db();
+  // 사용자 표면은 kind='user' 챗만 연다 — 데스크탑 사용자 챗 목록과 동일 필터
+  // (electron/store/chats.ts:86; 레거시 NULL=user 취급은 electron/store/db.ts:717).
+  // 숨김 division 세션(자동화/본부 인프라)은 접두사를 알아도 재개 대상이 아니다.
+  const rows = db.prepare(
+    "SELECT c.id, c.title, c.agent_id FROM chats c WHERE c.id LIKE ? AND c.archived_at IS NULL AND (c.kind IS NULL OR c.kind = 'user') ORDER BY c.updated_at DESC LIMIT 2",
+  ).all(prefix + "%");
+  if (!rows.length) {
+    ctx.err((ko ? "대화를 찾을 수 없음: " : "chat not found: ") + prefix);
+    return 1;
+  }
+  if (rows.length > 1) {
+    ctx.err(ko ? `모호합니다 — 더 긴 접두사를 쓰세요 (${rows.map((r) => r.id.slice(0, 8)).join(", ")})` : `Ambiguous — use a longer prefix (${rows.map((r) => r.id.slice(0, 8)).join(", ")})`);
+    return 1;
+  }
+  const chat = rows[0];
+  const agentRow = db.prepare("SELECT * FROM installed_agents WHERE id=?").get(chat.agent_id);
+  if (!agentRow) {
+    ctx.err(ko ? "이 대화의 에이전트가 더 이상 없습니다." : "The agent for this chat no longer exists.");
+    return 1;
+  }
+  // registry 정책과 동일: 웹 전용(private) 에이전트는 챗 id를 알아도 터미널에서
+  // 실행되면 안 된다 (hub/install.cjs 설치 게이트와 같은 문구).
+  if (isPrivateWebOnlyAgentRow(agentRow)) {
+    ctx.err("This web-only agent is not available in the Agentlas terminal.");
+    return 1;
+  }
+  const { startRepl } = require("../ui/repl.cjs");
+  ctx.out(ctx.ui.dim(`${ko ? "재개" : "resume"}: ${chat.title}`));
+  return startRepl(ctx, { agent: rowToAgent(agentRow).slug, chatId: chat.id });
+}
+
+module.exports = { run };

package/engine/commands/plugin.cjs

@@ -0,0 +1,101 @@
+"use strict";
+/*
+ * plugin — `agentlas plugin add <slug>` / `agentlas plugin list`.
+ * 기능 로직은 hub/plugins.cjs. v1 cmdPluginAdd/cmdPluginList의 출력 계약 유지:
+ *  - 설치할 MCP 서버가 없으면 조용히 성공했다고 하지 않는다 — 사용자는 이 플러그인이
+ *    붙었다고 믿고 도구를 기대하게 된다. 레포 URL을 http MCP 서버로 등록하는 일도
+ *    절대 하지 않는다(연결 불가능한 가짜 서버).
+ */
+const {
+  fetchPluginManifest,
+  planPluginMcpInstall,
+  installPluginMcpRows,
+  listHubPlugins,
+} = require("../hub/plugins.cjs");
+
+async function pluginAdd(ctx, slug) {
+  if (!slug) {
+    ctx.err("usage: agentlas plugin add <slug>   (run agentlas plugin list first)");
+    return 1;
+  }
+  let manifest;
+  try {
+    manifest = await fetchPluginManifest(slug);
+  } catch (e) {
+    ctx.err(String((e && e.message) || e));
+    return 1;
+  }
+  if (!manifest) {
+    ctx.err(`Hub plugin not found: ${slug}`);
+    return 1;
+  }
+  const { rows, refused } = planPluginMcpInstall(slug, manifest);
+  const docsLink = manifest.docs || manifest.source?.repo || manifest.source?.homepage || null;
+  if (!rows.length) {
+    const reasonLines = refused.map((item) => `  ✗ ${item.name}: ${item.reason}${item.source ? ` (${item.source})` : ""}`);
+    ctx.err(
+      [
+        `${slug} ships no machine-connectable MCP endpoint yet. Nothing was registered.`,
+        ...reasonLines,
+        docsLink ? `  docs: ${docsLink} (upstream project page — not an MCP endpoint)` : null,
+        "  When the catalog gains verified connection info for this plugin, re-run: agentlas plugin add " + slug,
+      ].filter(Boolean).join("\n"),
+    );
+    return 1;
+  }
+  let installed, reused, needsApproval;
+  try {
+    ({ installed, reused, needsApproval } = installPluginMcpRows(ctx.db(), rows));
+  } catch (e) {
+    ctx.err(String((e && e.message) || e));
+    return 1;
+  }
+  ctx.out(`${ctx.ui.green("✓")} Plugin installed ${ctx.ui.accent(manifest.slug)} — ${manifest.name}`);
+  for (const item of refused) {
+    ctx.out(`  ⚠ skipped ${item.name}: ${item.reason}${item.source ? ` (${item.source})` : ""}`);
+  }
+  ctx.out(`  MCP servers: ${installed} added${reused ? `, ${reused} already present` : ""}`);
+  // 데스크탑 hub-plugin-bridge.ts:219-227 동형: stdio는 비활성 등록 + 승인 필요 표면화.
+  for (const name of needsApproval || []) {
+    ctx.out(`  ⚠ needs-approval ${name}: local execution requires one-click approval in MCP settings`);
+  }
+  const authKind = manifest.auth?.kind;
+  if (authKind && authKind !== "none") {
+    ctx.out(`  ⚠ Requires ${authKind} — set credentials before use (agentlas creds).`);
+  }
+  if (Array.isArray(manifest.skills) && manifest.skills.length) {
+    ctx.out(`  skills declared: ${manifest.skills.map((skill) => skill.name).filter(Boolean).join(", ")}`);
+  }
+  ctx.out(ctx.ui.dim("  Only full-access turns wire active stdio servers into the runtime (agentlas mcp)."));
+  return 0;
+}
+
+async function pluginList(ctx) {
+  let plugins;
+  try {
+    plugins = await listHubPlugins();
+  } catch (e) {
+    ctx.err(String((e && e.message) || e));
+    return 1;
+  }
+  if (!plugins.length) {
+    ctx.out("No Hub plugins are available.");
+    return 0;
+  }
+  for (const plugin of plugins.slice(0, 60)) {
+    ctx.out(`${ctx.ui.accent(String(plugin.slug || "").padEnd(32).slice(0, 32))} ${String(plugin.name || "").slice(0, 44)}`);
+  }
+  ctx.out("");
+  ctx.out(ctx.ui.dim("Install: agentlas plugin add <slug>"));
+  return 0;
+}
+
+function run(ctx, args) {
+  const action = args[0];
+  if (action === "add") return pluginAdd(ctx, args[1]);
+  if (action === "list" || !action) return pluginList(ctx);
+  ctx.err("usage: agentlas plugin add <slug> | agentlas plugin list");
+  return 1;
+}
+
+module.exports = { run };