agentlas 0.9.10 → 1.0.2

package/engine/commands/doctor.cjs

@@ -0,0 +1,68 @@
+"use strict";
+/*
+ * doctor — 런타임·데이터·자격증명 건강 점검.
+ * 진단/수리 규칙 자체는 engine/agentlas-doctor.cjs(3제품 패리티 계약)에 있고,
+ * 이 명령은 "현재 상태 관측"만 한다. 여기서 관측 항목을 바꿔도 패리티 게이트와
+ * 무관하지만, 실패 분류·수리 로직을 건드리려면 반드시 sync-runtime-doctor.sh를 통과시켜라.
+ */
+const fs = require("node:fs");
+const path = require("node:path");
+const { dbPath, userDataDir } = require("../core/paths.cjs");
+const { listAvailableCliRuntimes, activeRuntimeRow } = require("../runtimes/detect.cjs");
+
+function run(ctx) {
+  const en = ctx.lang === "en";
+  let failures = 0;
+  const ok = (label, detail) => ctx.out(`  ${ctx.ui.green("✓")} ${label}${detail ? ctx.ui.dim(" — " + detail) : ""}`);
+  const bad = (label, detail) => { failures += 1; ctx.out(`  ${ctx.ui.red("✗")} ${label}${detail ? ctx.ui.dim(" — " + detail) : ""}`); };
+
+  // 1) 데이터
+  const p = dbPath();
+  if (fs.existsSync(p)) {
+    try {
+      const db = ctx.db();
+      const agents = db.prepare("SELECT COUNT(*) AS n FROM installed_agents").get();
+      ok(en ? "database" : "데이터베이스", `${p} (${agents ? agents.n : 0} agents)`);
+    } catch (e) {
+      bad(en ? "database" : "데이터베이스", e.message);
+    }
+  } else {
+    bad(en ? "database" : "데이터베이스", (en ? "missing: " : "없음: ") + p);
+  }
+
+  // 2) 런타임
+  const clis = listAvailableCliRuntimes();
+  if (clis.length) {
+    ok(en ? "runtimes" : "런타임", clis.map((c) => `${c.kind}`).join(", "));
+  } else {
+    bad(en ? "runtimes" : "런타임", en
+      ? "no agent CLI on PATH (claude / codex / gemini / kimi / grok / cursor-agent)"
+      : "PATH에 에이전트 CLI 없음 (claude / codex / gemini / kimi / grok / cursor-agent)");
+    // 막다른 길 방지: 무엇을 설치해야 하는지 그 자리에서 알려준다.
+    ctx.out(ctx.ui.dim("      npm i -g @anthropic-ai/claude-code  ·  @openai/codex  ·  @google/gemini-cli"));
+  }
+  try {
+    const active = activeRuntimeRow(ctx.db());
+    if (active) ok(en ? "active runtime" : "활성 런타임", `${active.kind}${active.model ? ` (${active.model})` : ""}`);
+  } catch { /* db issue already reported */ }
+
+  // 3) 로그인 상태 (세션 파일 관측만 — 네트워크 호출 없음)
+  const sessionFile = path.join(userDataDir(), "auth", "cli-session.v1.json");
+  if (process.env.AGENTLAS_SESSION) {
+    ok(en ? "cloud session" : "클라우드 세션", "AGENTLAS_SESSION env");
+  } else if (fs.existsSync(sessionFile)) {
+    ok(en ? "cloud session" : "클라우드 세션", sessionFile);
+  } else {
+    ctx.out(`  ${ctx.ui.dim("·")} ${en ? "cloud session" : "클라우드 세션"}${ctx.ui.dim(en ? " — not signed in (agentlas login)" : " — 로그인 안 됨 (agentlas login)")}`);
+  }
+
+  ctx.out("");
+  if (failures) {
+    ctx.out(en ? `doctor: ${failures} problem(s) found` : `doctor: 문제 ${failures}건`);
+    return 1;
+  }
+  ctx.out(en ? "doctor: all clear" : "doctor: 이상 없음");
+  return 0;
+}
+
+module.exports = { run };

package/engine/commands/env.cjs

@@ -0,0 +1,33 @@
+"use strict";
+/*
+ * env — 공유 env 키 열거 (값은 절대 출력하지 않음).
+ *
+ * standalone(비-Electron)에서는 keytar를 건드리지 않는다: 서명 안 된 Node에서
+ * keytar.findCredentials가 macOS 키체인에 막히면 무한 대기하고 process.exit로도
+ * 안 죽는다(v1 실사고). credentials.env 파일 기반 열거만 수행한다.
+ */
+const os = require("node:os");
+const path = require("node:path");
+const { userDataDir } = require("../core/paths.cjs");
+// readDotEnvFile 본체는 engine/project/env-file.cjs 로 이관 (creds 명령과 공유 —
+// 명령 파일끼리 import 금지 규칙 때문에 기능 모듈로 내려갔다). 여기서는 re-export.
+const { readDotEnvFile } = require("../project/env-file.cjs");
+
+function sharedEnvKeys() {
+  const fromFiles = {
+    ...readDotEnvFile(path.join(userDataDir(), "credentials.env")),
+    ...readDotEnvFile(path.join(os.homedir(), ".agentlas", "credentials.env")),
+  };
+  return Object.keys(fromFiles).sort();
+}
+
+function run(ctx) {
+  const keys = sharedEnvKeys();
+  ctx.out(`Shared env keys: ${keys.length} (values hidden; from credentials.env):`);
+  for (const k of keys) ctx.out(`  ${k}`);
+  ctx.out("");
+  ctx.out(ctx.ui.dim("Keychain entries are available in Desktop settings → Credentials."));
+  return 0;
+}
+
+module.exports = { run, readDotEnvFile, sharedEnvKeys };

package/engine/commands/evolve.cjs

@@ -0,0 +1,23 @@
+"use strict";
+/*
+ * evolve — 데스크탑 트리거가 만든 성장 제안 검토·적용·되돌리기 (Phase 2/2+).
+ *   agentlas evolve [list | apply <id> | revert <id>]
+ * 로직은 복원된 계약 모듈 engine/agentlas-evolution.cjs 가 소유한다.
+ * 적용/되돌리기 게이트는 타깃 파일 내용 해시(before_hash/after_hash)로만
+ * 판정한다 — 이 콘텐츠 해시 게이트는 계약이므로 여기서 절대 우회하지 않는다.
+ */
+const { cmdEvolve } = require("../agentlas-evolution.cjs");
+const { agentFolder } = require("../agents/files.cjs");
+
+function run(ctx, args) {
+  cmdEvolve({
+    db: ctx.db(),
+    args,
+    out: ctx.out,
+    fail: (msg) => { throw new Error(String(msg ?? "")); },
+    agentFolder,
+  });
+  return 0;
+}
+
+module.exports = { run };

package/engine/commands/experience.cjs

@@ -0,0 +1,34 @@
+"use strict";
+/*
+ * experience — Portable Experience Bundle 교환 표면
+ *   (list|inspect|validate|save|publish|status|export|unpublish|withdraw,
+ *    legacy-* 는 pack-only 로컬 의도 저장소).
+ *
+ * 복원된 계약 모듈 engine/agentlas-experience-exchange.cjs 가 전 로직을 소유하고,
+ * 이 파일은 v1 모놀리스 디스패치가 하던 의존성 주입만 재현한다:
+ *   getSessionCookie/fetchHub ← engine/cloud/hub-client.cjs (v1 D-bag의
+ *   cloudSessionCookieCli/fetchHubCli 대응), legacyCommand ← experience/intents.
+ * 폴백 없음: 서버 refusal/검증 실패 문구는 그대로 표면화된다(엔진이 stderr로
+ * 출력하고 exit 1).
+ */
+const { userDataDir } = require("../core/paths.cjs");
+
+async function run(ctx, args) {
+  const { cmdExperienceExchange } = require("../agentlas-experience-exchange.cjs");
+  const intents = require("../experience/intents.cjs");
+  const { cloudSessionCookie, fetchHub } = require("../cloud/hub-client.cjs");
+  await cmdExperienceExchange({
+    args,
+    userDataDir: userDataDir(),
+    cwd: process.cwd(),
+    out: ctx.out,
+    env: process.env,
+    getSessionCookie: cloudSessionCookie,
+    // fetchHub 3중 타임아웃/16MB 상한 강화판을 그대로 사용(v1 timeout-regression 계약).
+    fetchHub: (url, init) => fetchHub(url, init),
+    legacyCommand: (legacyOptions) => intents.cmdExperience(legacyOptions),
+  });
+  return 0;
+}
+
+module.exports = { run };

package/engine/commands/film.cjs

@@ -0,0 +1,8 @@
+"use strict";
+/*
+ * film — oberon의 별칭.
+ * v1 디스패처(§13061-13063)는 `case "oberon": case "film": return cmdOberon(rest.slice(1))`
+ * 로 두 이름을 완전히 동일하게 처리했다 (인자 변형·프리픽스 없음). 그대로 복제한다.
+ * v1 usage 표기도 동일 형태였다: "usage: agentlas film <scaffold|render|list|open> [args]".
+ */
+module.exports = require("./oberon.cjs");

package/engine/commands/firm.cjs

@@ -0,0 +1,115 @@
+"use strict";
+/*
+ * firm — 회사(CEO) 위임: agentlas firm <slug> [task…]
+ * 실행 경로는 세션 계층 하나다(제2 spawn 경로 금지).
+ * 무인자: 회사 목록. task 없이 slug만: 그 CEO와 REPL(기존 동작 유지).
+ * task가 있으면 데스크탑 firm-orchestrator 동형의 3-tier 위임을 돈다:
+ *   CEO PLAN(## Delegate 펜스) → 본부 병렬 실행(division 서브세션) → CEO SYNTHESIZE.
+ *   (firms/orchestrate.cjs runFirmTurn — 단순 CEO 챗 1턴이 아니다.)
+ */
+const { rowToAgent } = require("../agents/registry.cjs");
+
+function findFirm(db, token) {
+  const q = String(token || "").trim().toLowerCase();
+  if (!q) return null;
+  return db.prepare("SELECT * FROM firms WHERE lower(slug)=? OR lower(name)=?").get(q, q)
+    || db.prepare("SELECT * FROM firms WHERE lower(slug) LIKE ? ORDER BY slug LIMIT 1").get(`%${q}%`)
+    || null;
+}
+
+async function run(ctx, args) {
+  const ko = ctx.lang === "ko";
+  const db = ctx.db();
+  if (!ctx.tableExists(db, "firms")) {
+    ctx.out(ko ? "회사가 없습니다." : "No companies yet.");
+    return 0;
+  }
+  if (!args.length) {
+    const firms = db.prepare("SELECT slug, name, tagline FROM firms ORDER BY name").all();
+    if (!firms.length) {
+      ctx.out(ko ? "회사가 없습니다. (팀 폴더를 import 하면 회사로 등록됩니다)" : "No companies yet. (import a team folder to register one)");
+      return 0;
+    }
+    for (const f of firms) ctx.out(`  ${ctx.ui.accent(String(f.slug).padEnd(28))} ${f.name}${f.tagline ? ctx.ui.dim(" — " + f.tagline) : ""}`);
+    return 0;
+  }
+
+  const firm = findFirm(db, args[0]);
+  if (!firm) {
+    ctx.err((ko ? "회사를 찾을 수 없음: " : "firm not found: ") + args[0]);
+    return 1;
+  }
+  const ceoRow = firm.ceo_agent_id
+    ? db.prepare("SELECT * FROM installed_agents WHERE id=?").get(firm.ceo_agent_id)
+    : null;
+  if (!ceoRow) {
+    ctx.err(ko
+      ? `회사 ${firm.slug} 의 CEO 에이전트가 없습니다 (ceo_agent_id 미해결). 팀 폴더를 다시 import 하세요.`
+      : `Firm ${firm.slug} has no resolvable CEO agent. Re-import the team folder.`);
+    return 1;
+  }
+  const ceo = rowToAgent(ceoRow);
+
+  // 간단 플래그 파싱(--runtime/--permission) — 명령끼리 참조 금지 규칙상 run.cjs 미차용.
+  const rest = args.slice(1);
+  const flags = { runtime: null, permission: null, task: [] };
+  for (let i = 0; i < rest.length; i++) {
+    if (rest[i] === "--runtime") flags.runtime = rest[++i];
+    else if (rest[i] === "--permission") flags.permission = rest[++i];
+    else flags.task.push(rest[i]);
+  }
+  const task = flags.task.join(" ").trim();
+  if (task) {
+    // 3-tier 위임 실행 — PLAN → DELEGATE → SYNTHESIZE (firms/orchestrate.cjs).
+    const { runFirmTurn } = require("../firms/orchestrate.cjs");
+    const { resolveRuntimeForAgent, unavailableOverrideNote } = require("../runtimes/overrides.cjs");
+    const { Orchestrator } = require("../sessions/orchestrator.cjs");
+    const permissions = require("../agentlas-permissions.cjs");
+    let runtime;
+    try {
+      // 사다리: 명시 > (agent CEO > firm) 오버라이드 > prefs > active > detected.
+      runtime = resolveRuntimeForAgent({
+        db,
+        prefs: ctx.prefs,
+        explicit: flags.runtime,
+        targets: [
+          { scope: "agent", targetId: ceo.id },
+          { scope: "firm", targetId: firm.id },
+        ],
+      });
+    } catch (e) {
+      ctx.err(String((e && e.message) || e));
+      return 1;
+    }
+    if (runtime.unavailableOverride) ctx.err(ctx.ui.dim(unavailableOverrideNote(runtime, ctx.lang)));
+    const orch = new Orchestrator({ db, lang: ctx.lang });
+    const dim = ctx.ui.dim;
+    const result = await runFirmTurn({
+      db,
+      orch,
+      firm,
+      ceoAgent: ceo,
+      task,
+      runtime,
+      permission: permissions.normalize(flags.permission || (ctx.prefs && ctx.prefs.permission) || "write"),
+      cwd: process.cwd(),
+      onEvent: (ev) => {
+        if (ev.phase === "plan") ctx.err(dim(ko ? `${firm.name} · CEO가 작업을 분배하는 중…` : `${firm.name} · CEO is planning the work…`));
+        else if (ev.phase === "delegate") ctx.err(dim((ko ? "위임 → " : "delegating → ") + ev.targets.map((t) => t.name || t.role).join(", ")));
+        else if (ev.phase === "division-done") ctx.err(dim(`  ${ev.role}: ${ev.ok ? "ok" : "failed"}`));
+        else if (ev.phase === "synthesize") ctx.err(dim(ko ? "팀 결과를 종합하는 중…" : "Synthesizing team results…"));
+      },
+    });
+    orch.shutdown();
+    if (result.text) ctx.out(result.text.trimEnd());
+    if (!result.ok) {
+      ctx.err(ko ? "일부 본부/종합 턴이 실패했습니다 (위 status 참조)." : "Some division or synthesis turns failed (see status above).");
+      return 1;
+    }
+    return 0;
+  }
+  const { startRepl } = require("../ui/repl.cjs");
+  return startRepl(ctx, { agent: ceo.slug });
+}
+
+module.exports = { run, findFirm };

package/engine/commands/help.cjs

@@ -0,0 +1,65 @@
+"use strict";
+/* help / usage — v2 명령 표면. 재구축이 진행되며 이 표가 곧 진실이다. */
+
+const HELP = `agentlas — the operating system for agents, in your terminal
+
+  agentlas                 open the terminal (REPL)
+  agentlas <agent>         jump into a chat with one agent
+  agentlas "<task>"        auto-route to the best agent and run once
+
+TALK & RUN
+  <agent> · chat <agent>   jump into a chat with one agent
+  run [agent] [prompt]     one-shot (-p print · --runtime · --permission; stdin ok)
+  firm <firm> [task]       delegate to a company's CEO
+  chats [n] · open <id>    recent conversations · resume one
+
+AGENTS & HUB
+  search "<what you need>" discover agents in the Hub
+  install <slug>           install an agent from the Hub
+  plugin add <slug> · plugin list      Hub plugins (MCP servers)
+  build "<request>"        build/repair/package an agent or team
+  upload <path>            save owner-private in Agent Cloud (--visibility marketplace to publish)
+  import <path> · cd · native prepare  local folder agents
+  list                     installed agents/companies + active runtime
+  experience <sub>         portable Experience: list|inspect|validate|save|publish|status|export|unpublish
+  variant resolve          local variant selection
+
+EXECUTE
+  storm <goal>             Goal+UltraCode harness: plan → allocate → execute → verify  [--research]
+  swarm <goal>             emergent agent swarm  [--parallel N]
+  workforce | network <request>   Agent Workforce Ontology route
+  call "a,b" "<ctx>" · browser · route "<req>" [--json] · research <sub>
+
+KNOWLEDGE
+  memory import · evolve   memory & prompt-evolution proposals
+  ontology · career-graph  project knowledge & source routing
+  journal <sub>            Stormbreaker run journal
+  project [status|init]    private .agentlas project state (init is explicit)
+  context <sub>            dependency map: refresh|locate|refs|slice|impact|verify
+
+ACCOUNT & OPS
+  login | logout | whoami  Agentlas Cloud sign-in (browser flow)
+  cloud <sub>              cloud assets: save|publish|package|list|restore|field-test
+  automation <sub>         list|add|on|off|remove|run <id>|runs|daemon
+  creds <sub> · env        credentials and shared env keys
+  usage · telegram · mcp   local usage · telegram bindings · MCP servers (mcp probe <id>)
+  multimodal               image/video/audio provider settings
+  doctor · setup · update  health check · first-run wizard · npm update check
+  oberon | film <sub>      AI film render (scaffold|render|list|open)
+  hep <sub…> · netadmin    Hephaestus passthrough · local network admin
+  version · help
+
+IN-REPL (agentlas → interactive, Orca multi-session)
+  /spawn <agent> [task] · /sessions · /tree · /s <n> · /steer <n> <msg> ·
+  /kill <n> · /rm <n> · /broadcast <msg> · /use · /runtime · /permission
+  typing during a running turn queues steering; ctrl-c interrupts the turn
+
+Options: -p|--print · --runtime claude-code|codex|gemini · --permission read|write|full
+`;
+
+function run(ctx) {
+  ctx.out(HELP.trimEnd());
+  return 0;
+}
+
+module.exports = { run, HELP };

package/engine/commands/hep.cjs

@@ -0,0 +1,23 @@
+"use strict";
+/*
+ * hep — 전체 Hephaestus 네이티브 패스스루 (v1 cmdHep 이식).
+ *
+ * v1 디스패처 계약 그대로:
+ *   - `agentlas hep` (무인자)      → HEP_USAGE 출력, exit 0
+ *   - `agentlas hep help|--help`   → 짧은 usage 한 줄, exit 0
+ *     (v1 사전 가드: 리터럴 --help가 Hub/Cloud 라우팅 쿼리로 새는 것을 막는
+ *      로컬·무네트워크 처리 — MCP 키워드 선택 사고 계열의 방어선이다.)
+ *   - 그 외                        → runHephaestusInteractive 인자 그대로 전달,
+ *                                    자식 exit code 반환. 런타임 부재 = 정직 정지 1.
+ */
+const { create, usageFor, isHelpToken } = require("../hephaestus/runtime.cjs");
+
+async function run(ctx, args) {
+  if (args.length && args.some(isHelpToken)) {
+    ctx.out(usageFor("hep", ctx.lang));
+    return 0;
+  }
+  return create(ctx).cmdHep(args);
+}
+
+module.exports = { run };

package/engine/commands/import.cjs

@@ -0,0 +1,35 @@
+"use strict";
+/* import — 로컬 에이전트/팀 폴더 임포트 (데스크탑 폴더 드래그와 동일 규칙). */
+const { importLocalFolder } = require("../agents/import-local.cjs");
+
+function run(ctx, args) {
+  const ko = ctx.lang === "ko";
+  const absPath = args[0];
+  if (!absPath) {
+    ctx.err(ko ? "사용법: agentlas import <폴더-경로>" : "Usage: agentlas import <folder-path>");
+    return 1;
+  }
+  let r;
+  try {
+    r = importLocalFolder(ctx.db(), absPath);
+  } catch (e) {
+    ctx.err(String((e && e.message) || e));
+    return 1;
+  }
+  ctx.out(`${r.updated ? (ko ? "업데이트됨" : "Updated") : (ko ? "가져옴" : "Imported")}: ${r.name}  (${r.kind})`);
+  ctx.out(`  ${ko ? "슬러그" : "slug"}:    ${ctx.ui.accent(r.slug)}`);
+  ctx.out(`  ${ko ? "런타임" : "runtime"}: ${r.runtime}  [${r.labels.join(", ")}]`);
+  ctx.out(`  ${ko ? "경로" : "path"}:    ${r.path}`);
+  if (r.firmSlug) {
+    ctx.out(ko
+      ? `  회사:    ${r.firmSlug}  (회사로 등록됨 — Desktop 사이드바 + 'agentlas firm ${r.firmSlug}')`
+      : `  firm:    ${r.firmSlug}  (registered in Firms — Desktop sidebar + 'agentlas firm ${r.firmSlug}')`);
+  }
+  ctx.out("");
+  ctx.out(ctx.ui.dim(ko
+    ? `실행: agentlas ${r.slug} "..."   ·   agentlas run ${r.slug} "..."   (대상 프로젝트 폴더에서 실행)`
+    : `Run: agentlas ${r.slug} "..."   ·   agentlas run ${r.slug} "..."   (run from the target project folder)`));
+  return 0;
+}
+
+module.exports = { run };

package/engine/commands/index.cjs

@@ -0,0 +1,136 @@
+"use strict";
+/*
+ * commands/index — 명령 디스패치 테이블.
+ * 규칙:
+ *  - 명령 하나 = 파일 하나. 명령 파일은 기능 모듈만 import한다(명령끼리 참조 금지).
+ *  - 아직 v2로 포팅되지 않은 명령은 "정직 정지": 안내 + exit 1. 가짜 성공 금지.
+ *  - 무인자 search/install/upload는 usage + exit 1 (프롬프트 오라우팅 방지 가드).
+ */
+const path = require("node:path");
+
+// 각 명령 파일은 { run(ctx, args) } 를 export한다. ctx는 엔진이 만든 얕은 DI 객체.
+const COMMANDS = {
+  version: () => require("./version.cjs"),
+  list: () => require("./list.cjs"),
+  chats: () => require("./chats.cjs"),
+  doctor: () => require("./doctor.cjs"),
+  mcp: () => require("./mcp.cjs"),
+  help: () => require("./help.cjs"),
+  run: () => require("./run.cjs"),
+  login: () => require("./login.cjs"),
+  logout: () => require("./logout.cjs"),
+  whoami: () => require("./whoami.cjs"),
+  search: () => require("./search.cjs"),
+  update: () => require("./update.cjs"),
+  usage: () => require("./usage.cjs"),
+  telegram: () => require("./telegram.cjs"),
+  setup: () => require("./setup.cjs"),
+  env: () => require("./env.cjs"),
+  import: () => require("./import.cjs"),
+  firm: () => require("./firm.cjs"),
+  cd: () => require("./cd.cjs"),
+  install: () => require("./install.cjs"),
+  plugin: () => require("./plugin.cjs"),
+  plugins: () => require("./plugin.cjs"),
+  open: () => require("./open.cjs"),
+  automation: () => require("./automation.cjs"),
+  native: () => require("./native.cjs"),
+  chat: () => require("./chat.cjs"),
+  multimodal: () => require("./multimodal.cjs"),
+  workforce: () => require("./workforce.cjs"),
+  network: () => require("./workforce.cjs"),
+  taskforce: () => require("./workforce.cjs"),
+  oberon: () => require("./oberon.cjs"),
+  film: () => require("./film.cjs"),
+  experience: () => require("./experience.cjs"),
+  memory: () => require("./memory.cjs"),
+  evolve: () => require("./evolve.cjs"),
+  variant: () => require("./variant.cjs"),
+  hep: () => require("./hep.cjs"),
+  build: () => require("./build.cjs"),
+  connect: () => require("./connect.cjs"),
+  call: () => require("./call.cjs"),
+  browser: () => require("./browser.cjs"),
+  route: () => require("./route.cjs"),
+  research: () => require("./research.cjs"),
+  netadmin: () => require("./netadmin.cjs"),
+  journal: () => require("./journal.cjs"),
+  "legacy-network": () => require("./legacy-network.cjs"),
+  cloud: () => require("./cloud.cjs"),
+  upload: () => require("./upload.cjs"),
+  storm: () => require("./storm.cjs"),
+  swarm: () => require("./swarm.cjs"),
+  project: () => require("./project.cjs"),
+  context: () => require("./context.cjs"),
+  ontology: () => require("./ontology.cjs"),
+  "career-graph": () => require("./career-graph.cjs"),
+  creds: () => require("./creds.cjs"),
+  billing: () => require("./billing.cjs"),
+  uninstall: () => require("./uninstall.cjs"),
+};
+
+// v1에 존재했으나 아직 v2로 재구축되지 않은 명령 — 정직 정지 목록.
+// 재구축이 끝나면 여기서 지우고 COMMANDS에 올린다.
+const NOT_YET_PORTED = [
+  
+      
+        ];
+
+/*
+ * 데스크탑 전용 표면 — 터미널에 같은 이름의 명령이 없다.
+ * 이 이름들을 그냥 프롬프트로 흘리면 사용자가 "명령을 쳤는데" 에이전트가
+ * 저장소를 뒤지고 토큰을 쓴다(실사용 테스트에서 실증). 정직하게 멈추고
+ * 데스크탑/대체 경로를 안내한다.
+ */
+const DESKTOP_ONLY_SURFACES = {
+  site: "Site studio (웹·모바일·Agent App 디자인) is Desktop-only.",
+  sites: "Site studio (웹·모바일·Agent App 디자인) is Desktop-only.",
+  trex: "T-rex slide studio is Desktop-only.",
+  slides: "T-rex slide studio is Desktop-only.",
+  prompts: "Prompt Store is Desktop-only.",
+  dashboard: "Dashboard is Desktop-only — use: agentlas doctor · usage · list · chats",
+  marketplace: "Marketplace browsing is Desktop-only — use: agentlas search \"<what you need>\"",
+  library: "Library is Desktop-only — use: agentlas list · env · mcp",
+  groups: "Agent groups (조합) are Desktop-only.",
+  "agent-groups": "Agent groups (조합) are Desktop-only.",
+  settings: "Settings UI is Desktop-only — use: agentlas setup · env · creds · multimodal · doctor",
+  apps: "Apps surface is Desktop-only.",
+  quests: "Quests are Desktop-only.",
+  bookmarks: "Hub bookmarks are Desktop-only.",
+  one: "Agentlas One is a separate Desktop/Mobile product surface.",
+};
+
+// 무인자 호출이 프롬프트로 오라우팅되면 안 되는 명령 (smoke 가드 대상)
+const GUARDED_NO_ARG = new Set(["search", "install", "upload"]);
+
+function dispatch(ctx, argv) {
+  const [cmd, ...rest] = argv;
+  if (!cmd) return null; // 엔진이 REPL로 진입
+
+  if (COMMANDS[cmd]) {
+    return COMMANDS[cmd]().run(ctx, rest);
+  }
+
+  if (GUARDED_NO_ARG.has(cmd) && rest.length === 0) {
+    ctx.err(`Usage: agentlas ${cmd} <args…>`);
+    return 1;
+  }
+
+  if (DESKTOP_ONLY_SURFACES[cmd] && rest.length === 0) {
+    ctx.err(`${DESKTOP_ONLY_SURFACES[cmd]}\nIt was not run as a prompt — rerun with quotes if you meant a task: agentlas "${cmd} …"`);
+    return 1;
+  }
+
+  if (NOT_YET_PORTED.includes(cmd)) {
+    ctx.err(
+      `'${cmd}' is not wired into the v2 engine yet.\n` +
+      `The terminal is being rebuilt from the frame up; this command returns as its module lands.\n` +
+      `Last full v1 build: git tag legacy-v1-engine-snapshot (agentlas v0.9.10 on npm).`,
+    );
+    return 1;
+  }
+
+  return undefined; // 알 수 없는 토큰 — 엔진이 에이전트 이름/프롬프트로 해석 시도
+}
+
+module.exports = { dispatch, COMMANDS, NOT_YET_PORTED, GUARDED_NO_ARG, DESKTOP_ONLY_SURFACES };

package/engine/commands/install.cjs

@@ -0,0 +1,27 @@
+"use strict";
+/*
+ * install — `agentlas install <slug>`: Hub 에이전트 소스 설치.
+ * 기능 로직은 전부 hub/install.cjs에 있다. 여기서는 인자 검증 + 출력만.
+ * 오류는 ctx.err로 출력하고 1을 반환한다 (모듈 안 process.exit 금지).
+ */
+const { installHubAgent } = require("../hub/install.cjs");
+
+async function run(ctx, args) {
+  const slug = (args[0] || "").trim();
+  if (!slug) {
+    ctx.err("usage: agentlas install <slug>");
+    return 1;
+  }
+  let agent;
+  try {
+    agent = await installHubAgent(ctx.db(), slug);
+  } catch (e) {
+    ctx.err(String((e && e.message) || e));
+    return 1;
+  }
+  ctx.out(`${ctx.ui.green("✓")} Hub installed ${ctx.ui.accent(agent.slug)} — ${agent.name}`);
+  if (agent.localPath) ctx.out(ctx.ui.dim(`  files: ${agent.localPath}`));
+  return 0;
+}
+
+module.exports = { run };

package/engine/commands/journal.cjs

@@ -0,0 +1,31 @@
+"use strict";
+/*
+ * journal — Stormbreaker 런 저널 (status|verify|repair|gate).
+ *
+ * v1 디스패처 매핑 그대로:
+ *   `agentlas journal <sub…>` → cmdHep(["stormbreaker", "journal", ...rest])
+ *
+ * v1 가드 그대로:
+ *   - help 토큰 → usage, exit 0
+ *   - `journal status`에 --run-id/--journal 둘 다 없으면 → usage 실패 exit 1
+ *     (대상 없는 status가 네이티브에서 모호하게 도는 것 방지)
+ *   - 무인자는 v1처럼 가드 없이 패스스루 — 네이티브 usage가 나온다.
+ */
+const { create, usageFor, isHelpToken } = require("../hephaestus/runtime.cjs");
+
+async function run(ctx, args) {
+  if (args.some(isHelpToken)) {
+    ctx.out(usageFor("journal", ctx.lang));
+    return 0;
+  }
+  if (
+    args[0] === "status"
+    && !args.slice(1).some((value) => value === "--run-id" || value === "--journal")
+  ) {
+    ctx.err("✖ " + usageFor("journal", ctx.lang));
+    return 1;
+  }
+  return create(ctx).cmdHep(["stormbreaker", "journal", ...args]);
+}
+
+module.exports = { run };

package/engine/commands/legacy-network.cjs

@@ -0,0 +1,29 @@
+"use strict";
+/*
+ * legacy-network — 호환 전용 Hephaestus 네트워크 경로 (명시적 탈출구).
+ *
+ * v1 디스패처 매핑 그대로:
+ *   `agentlas legacy-network "<request>"` → cmdHep(["hep-network", ...rest])
+ *
+ * 오너 결정 배경: 기본 `network`/`workforce`는 host-LLM Agent Workforce
+ * Ontology(fail-closed) 경로다. 구 Hephaestus hep-network 라우터는 이
+ * "legacy-" 접두 명령으로만, 사용자가 이름으로 정확히 지목했을 때만 연다.
+ * 절대 기본 경로의 폴백으로 쓰지 않는다.
+ *
+ * v1 가드 그대로: help 토큰 → usage 0, 무인자 → usage 실패 exit 1.
+ */
+const { create, usageFor, isHelpToken } = require("../hephaestus/runtime.cjs");
+
+async function run(ctx, args) {
+  if (args.some(isHelpToken)) {
+    ctx.out(usageFor("legacy-network", ctx.lang));
+    return 0;
+  }
+  if (!args.length) {
+    ctx.err("✖ " + usageFor("legacy-network", ctx.lang));
+    return 1;
+  }
+  return create(ctx).cmdHep(["hep-network", ...args]);
+}
+
+module.exports = { run };