agentlas 0.9.10 → 1.0.2

package/engine/commands/project.cjs

@@ -0,0 +1,47 @@
+"use strict";
+/*
+ * project — 명시적 프로젝트 초기화/점검 (v1 monolith 13199–13223 포팅).
+ *
+ * 0.9.10 경계: `.agentlas/` 를 만드는 유일한 진입점은 `agentlas project init` 이다.
+ * `project status` 는 완전 수동(파일 생성/DB visit 기록 없음)으로 검사만 한다.
+ */
+const { projectCwd } = require("../project/paths.cjs");
+const {
+  ensureTerminalProjectForExecutionCli,
+  initializeTerminalProjectCli,
+} = require("../project/state.cjs");
+
+function run(ctx, args) {
+  const action = String(args[0] || "status").toLowerCase();
+  const cwd = projectCwd();
+  const ko = ctx.lang === "ko";
+  if (action === "status") {
+    const active = ensureTerminalProjectForExecutionCli(ctx.db(), cwd, "read", "terminal-project-status");
+    ctx.out(`${ko ? "프로젝트" : "project"}: ${cwd}`);
+    ctx.out(`${ko ? "Agentlas 상태" : "Agentlas state"}: ${active
+      ? (ko ? "초기화됨" : "initialized")
+      : (ko ? "초기화되지 않음" : "not initialized")}`);
+    if (!active) ctx.out(ko
+      ? "비공개 .agentlas 상태와 로컬 제외 파일을 만들려면 `agentlas project init`을 실행하세요."
+      : "Run `agentlas project init` to create private .agentlas state and update local ignore files.");
+    return 0;
+  }
+  if (action === "init") {
+    ctx.out(ko
+      ? "비공개 Agentlas 프로젝트 상태를 초기화합니다. .agentlas/ 생성, .gitignore 갱신, 로컬 자격증명·서명 템플릿 추가가 포함될 수 있습니다."
+      : "Initializing private Agentlas project state. This may create .agentlas/, update .gitignore, and add local credential/signing templates.");
+    try {
+      initializeTerminalProjectCli(ctx.db(), cwd);
+    } catch (e) {
+      // fail-closed: 프라이버시 경계(.gitignore/심볼릭 링크)를 보증 못 하면 생성 금지.
+      ctx.err(String((e && e.message) || e));
+      return 1;
+    }
+    ctx.out(`${ko ? "초기화됨" : "Initialized"}: ${cwd}`);
+    return 0;
+  }
+  ctx.err("Usage: agentlas project [status|init]");
+  return 1;
+}
+
+module.exports = { run };

package/engine/commands/research.cjs

@@ -0,0 +1,36 @@
+"use strict";
+/*
+ * research — Research Engine (status|gather|search|read|plan).
+ *
+ * v1 디스패처 매핑 그대로:
+ *   `agentlas research <sub…>` → cmdHep(["research", ...rest])
+ *   → runHephaestusInteractive가 research를 사람용 렌더러
+ *     (runHephaestusResearch, --json 원본 모드 포함)로 넘긴다.
+ *
+ * v1 가드 그대로:
+ *   - help 토큰 → 로컬 usage가 아니라 Hephaestus 네이티브 help 패스스루
+ *     (v1: parity().cmdHep(null, ["research", ...rest]) 특례).
+ *   - 첫 인자가 status|gather|search|read|plan 밖 → usage 실패 exit 1
+ *     (자연어가 리서치 서브커맨드 자리로 새는 것 방지; ko 문구 v1 그대로).
+ */
+const { create, usageFor, isHelpToken } = require("../hephaestus/runtime.cjs");
+
+const RESEARCH_SUBCOMMANDS = ["status", "gather", "search", "read", "plan"];
+
+async function run(ctx, args) {
+  const runtime = create(ctx);
+  if (args.some(isHelpToken)) {
+    return runtime.cmdHep(["research", ...args]);
+  }
+  if (!RESEARCH_SUBCOMMANDS.includes(args[0])) {
+    ctx.err(
+      "✖ " + (ctx.lang === "ko"
+        ? "사용법: agentlas research <status|gather|search|read|plan> [인자]"
+        : usageFor("research", ctx.lang)),
+    );
+    return 1;
+  }
+  return runtime.cmdHep(["research", ...args]);
+}
+
+module.exports = { run };

package/engine/commands/route.cjs

@@ -0,0 +1,37 @@
+"use strict";
+/*
+ * route — 라우팅 미리보기, 실행 없음 (사람용 렌더 + --json 원본 모드).
+ *
+ * v1 디스패처 매핑 그대로 (legacy-v1-engine-snapshot engine/agentlas.cjs ~13160):
+ *   query 있음 → cmdHep(["route", query, "--project", projectCwd(),
+ *                        "--runtime", "terminal", ...(--json ? ["--json"] : [])])
+ *   → runHephaestusInteractive가 route를 사람용 렌더러(runHephaestusRoute)로
+ *     넘기고, --json이면 human:false 원본 패스스루로 내려간다.
+ *
+ * v1 인자 가드 그대로:
+ *   - help 토큰 → usage, exit 0
+ *   - 인자가 없거나 --json뿐 → usage 실패 exit 1
+ *     (빈 쿼리가 라우터로 새는 것 방지)
+ */
+const { create, usageFor, isHelpToken } = require("../hephaestus/runtime.cjs");
+
+async function run(ctx, args) {
+  if (args.some(isHelpToken)) {
+    ctx.out(usageFor("route", ctx.lang));
+    return 0;
+  }
+  if (!args.some((value) => value !== "--json")) {
+    ctx.err("✖ " + usageFor("route", ctx.lang));
+    return 1;
+  }
+  const runtime = create(ctx);
+  const raw = args.includes("--json");
+  const query = args.filter((value) => value !== "--json").join(" ").trim();
+  return runtime.cmdHep(
+    query
+      ? ["route", query, "--project", runtime.projectCwd(), "--runtime", "terminal", ...(raw ? ["--json"] : [])]
+      : ["route"],
+  );
+}
+
+module.exports = { run };

package/engine/commands/run.cjs

@@ -0,0 +1,149 @@
+"use strict";
+/*
+ * run — 원샷 실행: agentlas run [agent] [prompt…]
+ *   -p | --print          최종 답만 stdout에 (스트리밍 UI 없음)
+ *   --runtime <kind>      claude-code | codex | gemini
+ *   --permission <level>  read | write | full
+ * 프롬프트가 없고 stdin이 TTY가 아니면 stdin을 읽는다.
+ *
+ * 자동 라우팅(agents/router.cjs): 첫 토큰이 에이전트로 해석되지 않으면 호스트 LLM
+ * 판정(resolveAutoRoute)이 최적 에이전트를 고른다 — 어휘 점수는 후보 모집 전용이다.
+ * 판정 런타임이 없으면 기본 에이전트로 정직 폴백하되 note를 stderr에 반드시 출력한다
+ * (조용한 오라우팅/폴백 금지 — 오너 결정).
+ * 런타임 사다리: 명시(--runtime) > 에이전트별 오버라이드(agent_runtime_overrides) >
+ * prefs > active_runtime > detected (runtimes/overrides.cjs).
+ */
+const { findAgent, listAgents } = require("../agents/registry.cjs");
+const { resolveRuntime } = require("../runtimes/resolve.cjs");
+const { resolveRuntimeForAgent, unavailableOverrideNote } = require("../runtimes/overrides.cjs");
+const { Orchestrator } = require("../sessions/orchestrator.cjs");
+const { Renderer } = require("../ui/renderer.cjs");
+const permissions = require("../agentlas-permissions.cjs");
+
+function readStdin() {
+  return new Promise((resolve) => {
+    let buf = "";
+    process.stdin.setEncoding("utf8");
+    process.stdin.on("data", (d) => { buf += d; });
+    process.stdin.on("end", () => resolve(buf.trim()));
+  });
+}
+
+function parseArgs(args) {
+  const out = { print: false, runtime: null, permission: null, rest: [] };
+  for (let i = 0; i < args.length; i++) {
+    const a = args[i];
+    if (a === "-p" || a === "--print") out.print = true;
+    else if (a === "--runtime") out.runtime = args[++i];
+    else if (a === "--permission") out.permission = args[++i];
+    else out.rest.push(a);
+  }
+  return out;
+}
+
+async function runOnce(ctx, args) {
+  const parsed = parseArgs(args);
+  // 플래그 검증은 모델을 부르기 전에. normalize는 알 수 없는 값을 read로 fail-closed
+  // 강등하는데, 조용히 강등하면 full을 요청한 사용자가 read로 도는 걸 모른다.
+  if (parsed.permission && !["read", "write", "full"].includes(String(parsed.permission))) {
+    ctx.err(`unknown --permission ${parsed.permission} (use: read | write | full)`);
+    return 1;
+  }
+  const db = ctx.db();
+
+  let agent = null;
+  let promptParts = parsed.rest;
+  if (parsed.rest.length) {
+    const candidate = findAgent(db, parsed.rest[0]);
+    if (candidate) {
+      agent = candidate;
+      promptParts = parsed.rest.slice(1);
+    }
+  }
+  let prompt = promptParts.join(" ").trim();
+  if (!prompt && !process.stdin.isTTY) prompt = await readStdin();
+  if (!prompt) {
+    ctx.err("Usage: agentlas run [agent] [prompt]  (reads stdin if no prompt)");
+    return 1;
+  }
+
+  // 기본 런타임을 먼저 확정한다 — 판정 러너(자동 라우팅)도 이 런타임을 쓴다.
+  let runtime;
+  try {
+    runtime = resolveRuntime({ db, prefs: ctx.prefs, explicit: parsed.runtime });
+  } catch (e) {
+    ctx.err(String((e && e.message) || e));
+    return 1;
+  }
+
+  if (!agent) {
+    // 자동 라우팅 — 최종 픽은 호스트 LLM 판정. 판정 불가 시 기본 에이전트 정직 폴백 + note.
+    const router = require("../agents/router.cjs");
+    let choice = null;
+    try {
+      choice = await router.resolveAutoRoute(db, prompt, { lang: ctx.lang, runtime });
+    } catch (e) {
+      ctx.err(ctx.lang === "ko"
+        ? `자동 라우팅 실패(${(e && e.message) || e}) — 기본 에이전트로 실행합니다`
+        : `auto-routing failed (${(e && e.message) || e}) — running with the default agent`);
+    }
+    if (choice && choice.agent) {
+      agent = choice.agent;
+    } else {
+      const visible = listAgents(db);
+      agent = visible[0] || findAgent(db, "agentlas-orchestrator");
+      if (!agent) {
+        ctx.err(ctx.lang === "en" ? "no installed agent (agentlas search/install first)" : "설치된 에이전트가 없습니다 (agentlas search/install 먼저)");
+        return 1;
+      }
+      // 직답 판정 — 페르소나 오염 없이 기본 에이전트 챗으로, 플레인 프롬프트로 답한다.
+      if (choice && choice.direct) agent = { ...agent, systemPrompt: router.directSystemPrompt(ctx.lang) };
+    }
+    // 조용한 라우팅 금지 — 누가 왜 선택됐는지(또는 왜 판정을 못 했는지) 반드시 출력.
+    if (choice && choice.note) ctx.err(ctx.uiInstance.c.dim(choice.note));
+  }
+
+  // 에이전트가 확정된 뒤 에이전트별 런타임 오버라이드를 얹는다(명시 --runtime이 항상 우선).
+  if (!parsed.runtime && agent && agent.id) {
+    try {
+      const layered = resolveRuntimeForAgent({ db, prefs: ctx.prefs, explicit: null, agentId: agent.id });
+      if (layered.unavailableOverride) ctx.err(ctx.uiInstance.c.dim(unavailableOverrideNote(layered, ctx.lang)));
+      runtime = layered;
+    } catch { /* 오버라이드 층 실패 → 이미 확정된 기본 런타임 유지 */ }
+  }
+
+  const orch = new Orchestrator({ db, lang: ctx.lang });
+  const session = orch.spawn({
+    agent,
+    runtime,
+    permission: permissions.normalize(parsed.permission || (ctx.prefs && ctx.prefs.permission) || "write"),
+    cwd: process.cwd(),
+    title: prompt.slice(0, 60),
+  });
+
+  let renderer = null;
+  if (!parsed.print) {
+    renderer = new Renderer(ctx.uiInstance);
+    renderer.attach(session, { replay: false });
+    ctx.err(ctx.uiInstance.c.dim(`${agent.slug} · ${runtime.kind}`));
+  }
+
+  const res = await session.send(prompt);
+  if (renderer) renderer.detach();
+
+  if (parsed.print) {
+    const finalText = (res && (res.finalText || res.text)) || "";
+    if (finalText) process.stdout.write(finalText.trimEnd() + "\n");
+  }
+  if (session.status === "failed") {
+    if (parsed.print && session.lastError) ctx.err(session.lastError);
+    return 1;
+  }
+  return 0;
+}
+
+function run(ctx, args) {
+  return runOnce(ctx, args);
+}
+
+module.exports = { run, parseArgs };

package/engine/commands/search.cjs

@@ -0,0 +1,55 @@
+"use strict";
+/*
+ * search — Hub 에이전트 디렉터리 검색 (hep-search 표면).
+ * 로그인 없이도 동작한다(쿠키는 있으면 첨부). 결과 위장/폴백 카탈로그 금지 —
+ * Hub가 실패하면 그 실패를 그대로 보고한다.
+ */
+const { callHubTool, HubError } = require("../cloud/hub-client.cjs");
+
+/** 엔진 내부 에이전트는 제품이 아니므로 검색 결과에서 숨긴다 (v1과 동일 규칙). */
+function isInternalAgentSlug(slug) {
+  const s = String(slug || "").toLowerCase();
+  return /^researcher-\d+/.test(s) || s === "research-intelligence-desk" || s.startsWith("hephaestus-");
+}
+
+async function run(ctx, args) {
+  let limit = 10;
+  const rest = [];
+  for (let i = 0; i < args.length; i++) {
+    if (args[i] === "--limit") limit = Math.max(1, Math.min(30, Number(args[++i]) || 10));
+    else rest.push(args[i]);
+  }
+  const query = rest.join(" ").trim();
+  if (!query) {
+    ctx.err('usage: agentlas search "<what you need>" [--limit 10]');
+    return 1;
+  }
+
+  let result;
+  try {
+    // Hub 파라미터 이름은 `q` — 데스크탑 mcp-source.ts와 동일하게 q/query 둘 다 전송.
+    result = await callHubTool("marketplace.search_agents", { q: query, query, limit });
+  } catch (e) {
+    ctx.err(e instanceof HubError ? e.message : `Marketplace connection failed: ${(e && e.message) || e}`);
+    return 1;
+  }
+
+  const raw = (result && (result.results || result.agents || result.items)) || (Array.isArray(result) ? result : null);
+  const items = Array.isArray(raw) ? raw.filter((it) => !isInternalAgentSlug(it && (it.slug || it.id))) : [];
+  if (!items.length) {
+    ctx.out(`No results for "${query}"`);
+    return 0;
+  }
+  for (const it of items.slice(0, limit)) {
+    const slug = it.slug || it.id || "?";
+    const name = it.name || it.title || slug;
+    const kind = it.kind || it.entity_kind || "";
+    const tagline = it.tagline || it.description || "";
+    ctx.out(`${ctx.ui.accent(String(slug).padEnd(34).slice(0, 34))} ${String(name).slice(0, 26).padEnd(27)} ${ctx.ui.dim(String(kind).padEnd(14))} ${String(tagline).slice(0, 60)}`);
+  }
+  ctx.out("");
+  ctx.out(ctx.ui.dim("Install: agentlas install <slug>"));
+  return 0;
+}
+
+module.exports = { run, isInternalAgentSlug };

package/engine/commands/setup.cjs

@@ -0,0 +1,45 @@
+"use strict";
+/*
+ * setup — 첫 실행 마법사 재실행 (언어 → 기본 런타임 → 기본 권한).
+ * 결과는 cli-prefs.json에 저장된다. REPL은 onboarded가 아니면 이 마법사를 먼저 연다.
+ */
+const readline = require("node:readline");
+const { runOnboard } = require("../agentlas-onboard.cjs");
+const { updatePrefs } = require("../agentlas-config.cjs");
+const { userDataDir } = require("../core/paths.cjs");
+const { RUNTIME_BIN, whichSync } = require("../runtimes/detect.cjs");
+
+async function runWizard(ctx, rl) {
+  const result = await runOnboard({
+    ui: ctx.uiInstance,
+    rl,
+    helpers: { RUNTIME_BIN, which: whichSync },
+  });
+  if (result && result.onboarded) {
+    updatePrefs(userDataDir(), {
+      onboarded: true,
+      ...(result.lang ? { language: result.lang } : {}),
+      ...(result.runtime ? { runtime: result.runtime } : {}),
+      ...(result.permission ? { permission: result.permission } : {}),
+    });
+  }
+  return result;
+}
+
+async function run(ctx) {
+  if (!process.stdin.isTTY) {
+    // 비-TTY에서 마법사를 돌리면 EOF로 이벤트 루프가 비어 exit 0으로 "조용히 성공"
+    // 하는 함정이 있다 — 정직하게 거부한다.
+    ctx.err(ctx.lang === "ko" ? "setup은 대화형 터미널에서만 실행됩니다." : "setup requires an interactive terminal.");
+    return 1;
+  }
+  const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+  try {
+    const result = await runWizard(ctx, rl);
+    return result && result.onboarded ? 0 : 1;
+  } finally {
+    rl.close();
+  }
+}
+
+module.exports = { run, runWizard };

package/engine/commands/storm.cjs

@@ -0,0 +1,75 @@
+"use strict";
+/*
+ * commands/storm — `agentlas storm <goal> [--research] [--background] [--runtime <kind>]`.
+ *
+ * v1 모놀리스 디스패치(legacy-v1-engine-snapshot, engine/agentlas.cjs 13074행)의 포팅:
+ *   case "storm" → parity().cmdStorm(db, rest, runtimeOverride,
+ *     { cwd, projectPath, permission })
+ *
+ * 정직 정지 계약: Agentlas Core의 Goal+UltraCode 하네스가 없으면 storm/storm.cjs 가
+ * stormbreaker-core-harness-unavailable 로 멈춘다 — 하네스의 로컬 모조 실행 금지.
+ * 런타임 부재는 resolveRuntime의 code="no_runtime" throw가 그대로 전파돼 exit 1.
+ *
+ * projectPath 에 대한 정직한 메모: v1은 ensureTerminalProjectForExecutionCli(db,
+ * cwd, permission, "terminal-storm")로 프로젝트 상태 머신을 돌려 활성 프로젝트
+ * 경로를 만들었다. 그 프로젝트-상태 기계는 아직 v2로 포팅되지 않았다. storm/swarm 이
+ * projectPath 를 쓰는 곳은 buildChildEnv 의 프로젝트 dotenv 스코핑뿐이고 부재 시
+ * fail-closed 의존이 없다 — 그래서 여기서는 cwd 를 projectPath 로 넘긴다
+ * (commands/workforce.cjs 와 동일한 결정·동일한 근거). 프로젝트-상태 모듈이 v2에
+ * 착륙하면 이 자리를 그 결과로 교체한다.
+ */
+const { buildStormDeps } = require("../storm/deps.cjs");
+const { projectCwd } = require("../workforce/capture.cjs");
+
+function assertPermissionFlag(value) {
+  if (value && !["read", "write", "full"].includes(String(value))) {
+    throw new Error(`unknown --permission ${value} (use: read | write | full)`);
+  }
+}
+
+function resolvePermission(ctx) {
+  // v1 resolveTerminalPermission 포팅: 저장된 `full` 은 세션 한정 계약이라
+  // persistent()가 fail-closed 로 강등한다.
+  try {
+    const policy = require("../agentlas-permissions.cjs");
+    return policy.persistent(ctx && ctx.prefs && ctx.prefs.permission, "write");
+  } catch {
+    return "write";
+  }
+}
+
+/** `--runtime <kind>` 만 명령 자체 플래그로 벗겨낸다. 나머지는 cmdStorm 이 파싱. */
+function splitRuntimeOverride(args) {
+  const rest = [];
+  let runtimeOverride = null;
+  for (let i = 0; i < args.length; i += 1) {
+    if (args[i] === "--runtime" && args[i + 1]) {
+      runtimeOverride = String(args[++i]);
+      continue;
+    }
+    rest.push(args[i]);
+  }
+  return { rest, runtimeOverride };
+}
+
+async function run(ctx, args) {
+  const { rest, runtimeOverride } = splitRuntimeOverride(args);
+  // usage 경로(목표 텍스트 없음)는 SQLite를 열 이유가 없다.
+  if (!rest.some((token) => !["--research", "--research-evidence", "--background"].includes(String(token)))) {
+    ctx.err("usage: agentlas storm <goal>  [--research] [--background] [--runtime <kind>]");
+    return 1;
+  }
+  const db = ctx.db();
+  const cwd = projectCwd();
+  const permission = resolvePermission(ctx);
+  const storm = require("../storm/storm.cjs").create(buildStormDeps(ctx));
+  const r = await storm.cmdStorm(db, rest, runtimeOverride, {
+    cwd,
+    // v1 ensureTerminalProjectForExecutionCli 미포팅 — 위 파일 머리 주석 참조.
+    projectPath: cwd,
+    permission,
+  });
+  return r && r.ok ? 0 : 1;
+}
+
+module.exports = { run, splitRuntimeOverride };

package/engine/commands/swarm.cjs

@@ -0,0 +1,75 @@
+"use strict";
+/*
+ * commands/swarm — `agentlas swarm <goal> [--parallel N] [--runtime <kind>]`.
+ *
+ * v1 모놀리스 디스패치(legacy-v1-engine-snapshot, engine/agentlas.cjs 13079행)의 포팅:
+ *   case "swarm" → parity().cmdSwarm(db, rest, runtimeOverride,
+ *     { cwd, projectPath, permission })
+ *
+ * 워커 실행은 storm/swarm.cjs 를 통해 engine/workforce/capture.cjs 의 headless
+ * 캡처로만 이뤄진다(제2의 스폰 경로 금지). 워커의 workload allocation은
+ * agentlas-workload-routing 이 검증만 하고, 거부 시 fail-closed 다.
+ * 런타임 부재는 resolveRuntime의 code="no_runtime" throw가 그대로 전파돼 exit 1.
+ *
+ * projectPath: v1 ensureTerminalProjectForExecutionCli 미포팅 —
+ * commands/storm.cjs 파일 머리 주석과 동일한 결정·동일한 근거로 cwd 를 넘긴다.
+ */
+const { buildStormDeps } = require("../storm/deps.cjs");
+const { projectCwd } = require("../workforce/capture.cjs");
+
+function assertPermissionFlag(value) {
+  if (value && !["read", "write", "full"].includes(String(value))) {
+    throw new Error(`unknown --permission ${value} (use: read | write | full)`);
+  }
+}
+
+function resolvePermission(ctx) {
+  // v1 resolveTerminalPermission 포팅: 저장된 `full` 은 세션 한정 계약이라
+  // persistent()가 fail-closed 로 강등한다.
+  try {
+    const policy = require("../agentlas-permissions.cjs");
+    return policy.persistent(ctx && ctx.prefs && ctx.prefs.permission, "write");
+  } catch {
+    return "write";
+  }
+}
+
+/** `--runtime <kind>` 만 명령 자체 플래그로 벗겨낸다. 나머지는 cmdSwarm 이 파싱. */
+function splitRuntimeOverride(args) {
+  const rest = [];
+  let runtimeOverride = null;
+  for (let i = 0; i < args.length; i += 1) {
+    if (args[i] === "--runtime" && args[i + 1]) {
+      runtimeOverride = String(args[++i]);
+      continue;
+    }
+    rest.push(args[i]);
+  }
+  return { rest, runtimeOverride };
+}
+
+async function run(ctx, args) {
+  const { rest, runtimeOverride } = splitRuntimeOverride(args);
+  // usage 경로(목표 텍스트 없음)는 SQLite를 열 이유가 없다 — cmdSwarm 의 플래그
+  // (--parallel/-n <N>)만 있는 호출은 빈 목표다.
+  const hasGoal = rest.some((token, i) =>
+    !["--parallel", "-n"].includes(String(token))
+    && !(i > 0 && ["--parallel", "-n"].includes(String(rest[i - 1]))));
+  if (!hasGoal) {
+    ctx.err("usage: agentlas swarm <goal>  [--parallel N] [--runtime <kind>]");
+    return 1;
+  }
+  const db = ctx.db();
+  const cwd = projectCwd();
+  const permission = resolvePermission(ctx);
+  const swarm = require("../storm/swarm.cjs").create(buildStormDeps(ctx));
+  const r = await swarm.cmdSwarm(db, rest, runtimeOverride, {
+    cwd,
+    // v1 ensureTerminalProjectForExecutionCli 미포팅 — commands/storm.cjs 주석 참조.
+    projectPath: cwd,
+    permission,
+  });
+  return r && r.ok ? 0 : 1;
+}
+
+module.exports = { run, splitRuntimeOverride };

package/engine/commands/telegram.cjs

@@ -0,0 +1,32 @@
+"use strict";
+/* telegram — 바인딩 현황 (읽기 전용). 페어링·봇 발급은 Desktop Connect 소관. */
+
+function run(ctx) {
+  const ko = ctx.lang === "ko";
+  const db = ctx.db();
+  let rows;
+  try {
+    rows = db.prepare("SELECT * FROM telegram_bindings ORDER BY rowid DESC").all();
+  } catch {
+    rows = [];
+  }
+  if (!rows.length) {
+    ctx.out(ko
+      ? "Telegram 연결이 없습니다. Desktop Connect에서 기기를 연결하세요."
+      : "No Telegram bindings. Pair devices from Desktop Connect.");
+    return 0;
+  }
+  for (const r of rows) {
+    const bot = r.bot_username ? "@" + r.bot_username : "(bot not set)";
+    const chat = r.telegram_chat_title || r.telegram_chat_id || "(chat not connected)";
+    const status = r.status || (r.telegram_chat_id ? "paired" : "pending");
+    ctx.out(`${String(r.id).slice(0, 8)}  ${r.target_kind}:${String(r.target_id).slice(0, 20).padEnd(21)} ${String(bot).padEnd(24)} ${String(chat).slice(0, 28).padEnd(29)} ${status}`);
+  }
+  ctx.out("");
+  ctx.out(ctx.ui.dim(ko
+    ? "연결과 봇 발급은 Desktop Connect에서 수행하며, 이 명령은 상태만 보여줍니다."
+    : "Pairing and bot issuance happen in Desktop Connect; this command only shows status."));
+  return 0;
+}
+
+module.exports = { run };

package/engine/commands/uninstall.cjs

@@ -0,0 +1,68 @@
+"use strict";
+/*
+ * uninstall — 설치 에이전트 제거 (데스크탑 registry.uninstallAgent 동형).
+ * 게이트: 설치된 회사(firm)에 속한 에이전트는 회사 관계를 먼저 정리해야 한다
+ * (에이전트/챗은 그대로 남는다는 안내 포함 — 데스크탑 문구 동일).
+ * 로컬 임포트 라우트도 정리하되 원본 폴더는 건드리지 않는다. 빌트인은 거부.
+ */
+const { findAgent } = require("../agents/registry.cjs");
+const { routesMap, saveRoutes } = require("../agents/routes.cjs");
+const { runWriteTransaction } = require("../agentlas-sqlite-policy.cjs");
+
+function run(ctx, args) {
+  const ko = ctx.lang === "ko";
+  const token = args[0];
+  if (!token) {
+    ctx.err(ko ? "사용법: agentlas uninstall <agent>" : "Usage: agentlas uninstall <agent>");
+    return 1;
+  }
+  const db = ctx.db();
+  const agent = findAgent(db, token);
+  if (!agent) {
+    ctx.err((ko ? "에이전트를 찾을 수 없음: " : "agent not found: ") + token);
+    return 1;
+  }
+  if (agent.builtin) {
+    ctx.err(ko ? "빌트인 아키텍처 에이전트는 제거할 수 없습니다." : "Built-in architecture agents cannot be uninstalled.");
+    return 1;
+  }
+
+  if (ctx.tableExists(db, "firms")) {
+    const firmRows = db.prepare("SELECT id, name, ceo_agent_id, org_chart_json FROM firms").all();
+    const membership = firmRows.find((firm) => {
+      if (firm.ceo_agent_id === agent.id) return true;
+      try {
+        return JSON.parse(firm.org_chart_json || "[]").some((node) => node && node.agentId === agent.id);
+      } catch {
+        return false;
+      }
+    });
+    if (membership) {
+      ctx.err(ko
+        ? `설치된 회사 "${membership.name}"에 속한 에이전트입니다. 회사 관계를 먼저 정리하세요; 에이전트와 대화는 그대로 남습니다.`
+        : `Agent belongs to installed firm "${membership.name}". Remove the firm relationship first; the agent and its chats will stay installed.`);
+      return 1;
+    }
+  }
+
+  let deleted = false;
+  runWriteTransaction(db, () => {
+    deleted = db.prepare("DELETE FROM installed_agents WHERE id=?").run(agent.id).changes > 0;
+  });
+  if (deleted) {
+    // 로컬 임포트 라우팅도 정리 (원본 폴더는 건드리지 않음) — 데스크탑 removeRoute 동형.
+    try {
+      const routes = routesMap();
+      if (routes[agent.id]) {
+        delete routes[agent.id];
+        saveRoutes(routes);
+      }
+    } catch { /* 라우트 정리는 best-effort */ }
+    ctx.out(`${ctx.ui.green("✓")} ${ko ? "제거됨" : "Uninstalled"}: ${agent.slug}`);
+    return 0;
+  }
+  ctx.err(ko ? "제거하지 못했습니다." : "Nothing was uninstalled.");
+  return 1;
+}
+
+module.exports = { run };