agentlas 0.9.10 → 1.0.2

package/engine/ui/palette.cjs

@@ -0,0 +1,105 @@
+"use strict";
+/*
+ * ui/palette — v2 슬래시 명령 정본 + readline 완성기.
+ *
+ * 왜 v1 input 모듈의 SLASH_COMMANDS를 쓰지 않는가: 그 목록은 v1 REPL 전용이라
+ * v2에 없는 명령(/status /team /model /effort …)을 광고하고, v2의 오르카 명령
+ * (/spawn /sessions /s /steer /kill /broadcast …)은 빠져 있었다. 팔레트가
+ * 거짓말하면 사용자는 없는 기능을 부른다(실사용 Tab 테스트에서 실증).
+ * 경로 완성만 v1 모듈의 completePath를 재사용한다.
+ */
+const { completePath, isAbsolutePathTask } = require("../agentlas-input.cjs");
+
+// command, 인자 힌트, 한 줄 설명 — /help 팔레트와 Tab 완성이 같은 정본을 쓴다.
+const SLASH_COMMANDS = [
+  { command: "/help", args: "", ko: "명령·단축키 보기", en: "Show commands and shortcuts" },
+  { command: "/sessions", args: "", ko: "세션 표", en: "Session table" },
+  { command: "/tree", args: "", ko: "세션 트리", en: "Session tree" },
+  { command: "/s", args: "<n>", ko: "활성 세션 전환", en: "Switch active session" },
+  { command: "/switch", args: "<n>", ko: "활성 세션 전환", en: "Switch active session" },
+  { command: "/spawn", args: "<agent> [task]", ko: "서브에이전트 세션 생성", en: "Spawn a subagent session" },
+  { command: "/steer", args: "<n> <msg>", ko: "해당 세션에 지시 큐잉", en: "Queue steering for a session" },
+  { command: "/kill", args: "<n>", ko: "실행 중 턴 중단", en: "Interrupt a running turn" },
+  { command: "/rm", args: "<n>", ko: "세션 제거", en: "Remove a session" },
+  { command: "/broadcast", args: "<msg>", ko: "모든 세션에 지시", en: "Send to every session" },
+  { command: "/use", args: "<agent>", ko: "메인 세션 에이전트 교체", en: "Switch the main agent" },
+  { command: "/agents", args: "", ko: "설치 에이전트 목록", en: "List installed agents" },
+  { command: "/list", args: "", ko: "설치 에이전트 목록", en: "List installed agents" },
+  { command: "/chats", args: "[n]", ko: "최근 대화", en: "Recent conversations" },
+  { command: "/mcp", args: "", ko: "MCP 서버 목록", en: "MCP servers" },
+  { command: "/doctor", args: "", ko: "런타임·데이터 점검", en: "Health check" },
+  { command: "/runtime", args: "<kind>", ko: "새 세션 런타임 지정", en: "Set runtime for new sessions" },
+  { command: "/permission", args: "<level>", ko: "새 세션 권한 지정", en: "Set permission for new sessions" },
+  { command: "/login", args: "", ko: "Agentlas Cloud 로그인", en: "Sign in to Agentlas Cloud" },
+  { command: "/whoami", args: "", ko: "로그인 상태", en: "Signed-in account" },
+  { command: "/search", args: "\"<what you need>\"", ko: "Hub 에이전트 검색", en: "Search Hub agents" },
+  { command: "/install", args: "<slug>", ko: "Hub 에이전트 설치", en: "Install a Hub agent" },
+  { command: "/usage", args: "", ko: "로컬 사용 현황", en: "Local usage" },
+  { command: "/billing", args: "", ko: "크레딧 잔액", en: "Credit balance" },
+  { command: "/automation", args: "[sub]", ko: "자동화", en: "Automations" },
+  { command: "/storm", args: "<goal>", ko: "Goal+UltraCode 하니스", en: "Goal+UltraCode harness" },
+  { command: "/swarm", args: "<goal>", ko: "에이전트 스웜", en: "Agent swarm" },
+  { command: "/network", args: "<request>", ko: "Workforce 라우트", en: "Workforce route" },
+  { command: "/quit", args: "", ko: "종료", en: "Quit" },
+  { command: "/exit", args: "", ko: "종료", en: "Quit" },
+];
+
+const SLASH_NAMES = SLASH_COMMANDS.map((c) => c.command);
+const RUNTIME_KINDS = ["claude-code", "codex", "gemini"];
+const PERM_LEVELS = ["read", "write", "full"];
+// 세션 인자를 받는 명령 — 완성 후보를 살아있는 세션 키(s1, s2…)로 채운다.
+const SESSION_ARG_COMMANDS = new Set(["/s", "/switch", "/steer", "/kill", "/rm"]);
+const AGENT_ARG_COMMANDS = new Set(["/use", "/spawn"]);
+
+function uniqStartsWith(list, prefix) {
+  const p = String(prefix || "");
+  const hits = [...new Set(list)].filter((v) => v.startsWith(p));
+  return hits.length ? hits : [];
+}
+
+/**
+ * ctx: { getAgentSlugs, getFirmSlugs, getSessionKeys, getCwd }
+ * readline completer 계약: [candidates, prefix] 반환.
+ */
+function makeCompleter(ctx = {}) {
+  const getAgents = ctx.getAgentSlugs || (() => []);
+  const getFirms = ctx.getFirmSlugs || (() => []);
+  const getSessions = ctx.getSessionKeys || (() => []);
+  const getCwd = ctx.getCwd || (() => process.cwd());
+  return function completer(line) {
+    const lineStr = line || "";
+    const tokens = lineStr.split(/\s+/);
+    const last = tokens[tokens.length - 1] || "";
+
+    // @경로 멘션은 어느 위치에서나 파일 완성
+    if (last.startsWith("@")) return [completePath(last.slice(1), getCwd(), "@"), last];
+
+    if (tokens.length === 1) {
+      if (isAbsolutePathTask(lineStr)) return [completePath(lineStr, getCwd(), ""), last];
+      if (lineStr.startsWith("/")) return [uniqStartsWith(SLASH_NAMES, last), last];
+      // 첫 토큰이 자유 텍스트면 에이전트 이름을 제안한다(에이전트 점프 UX).
+      return [uniqStartsWith(getAgents().concat(getFirms()), last), last];
+    }
+
+    const cmd = tokens[0];
+    if (cmd === "/runtime") return [uniqStartsWith(RUNTIME_KINDS, last), last];
+    if (cmd === "/permission") return [uniqStartsWith(PERM_LEVELS, last), last];
+    if (SESSION_ARG_COMMANDS.has(cmd) && tokens.length === 2) return [uniqStartsWith(getSessions(), last), last];
+    if (AGENT_ARG_COMMANDS.has(cmd) && tokens.length === 2) {
+      return [uniqStartsWith(getAgents().concat(getFirms()), last), last];
+    }
+    return [[], last];
+  };
+}
+
+/** /help 팔레트 렌더 — Tab 완성과 같은 정본에서 나온다. */
+function renderPalette(lang) {
+  const ko = lang === "ko";
+  const width = Math.max(...SLASH_COMMANDS.map((c) => (c.command + " " + c.args).length));
+  return SLASH_COMMANDS
+    .filter((c, i, all) => all.findIndex((x) => (ko ? x.ko : x.en) === (ko ? c.ko : c.en)) === i)
+    .map((c) => `  ${(c.command + (c.args ? " " + c.args : "")).padEnd(width + 2)}${ko ? c.ko : c.en}`)
+    .join("\n");
+}
+
+module.exports = { SLASH_COMMANDS, SLASH_NAMES, makeCompleter, renderPalette };

package/engine/ui/renderer.cjs

@@ -0,0 +1,85 @@
+"use strict";
+/*
+ * ui/renderer — 세션 이벤트를 Ui(터미널)로 그리는 유일한 곳.
+ * 활성 세션 하나에만 attach된다. 백그라운드 세션 이벤트는 orchestrator의
+ * notice로만 표면화된다(오르카 규칙: 화면은 한 세션, 나머지는 상태로).
+ */
+
+class Renderer {
+  constructor(ui) {
+    this.ui = ui;
+    this.session = null;
+    this._listener = null;
+  }
+
+  attach(session, { replay = true } = {}) {
+    this.detach();
+    this.session = session;
+    if (replay) this._replayTail(session);
+    this._listener = (ev) => this._render(ev);
+    session.on("event", this._listener);
+    if (session.isBusy()) this._beginChrome();
+  }
+
+  detach() {
+    if (this.session && this._listener) this.session.removeListener("event", this._listener);
+    if (this.session) this.ui.endTurn();
+    this.session = null;
+    this._listener = null;
+  }
+
+  _beginChrome() {
+    this.ui.beginTurn({
+      permissionLabel: this.session ? this.session.permission : "",
+      status: this.session ? this.session.agent.slug : "",
+    });
+  }
+
+  _replayTail(session) {
+    const tail = session.eventsTail(120);
+    if (!tail.length) return;
+    this.ui.ensureNl();
+    this.ui.rule(`${session.key || ""} ${session.agent.slug} · ${session.status}`);
+    // 마지막 턴의 스트림 텍스트만 복원한다(도구 소음 제외) — 전환 시 맥락 파악용.
+    let text = "";
+    for (const ev of tail) {
+      if (ev.type === "turn-start") text = "";
+      else if (ev.type === "stream-delta") text += ev.text;
+    }
+    const lines = text.trim().split(/\r?\n/).slice(-12);
+    for (const l of lines) this.ui.line("  " + l);
+    if (session.lastError) this.ui.error(session.lastError);
+  }
+
+  _render(ev) {
+    const ui = this.ui;
+    switch (ev.type) {
+      case "turn-start": this._beginChrome(); return;
+      case "turn-end":
+        ui.endTurn();
+        if (!ev.ok && ev.error) ui.error(ev.error);
+        return;
+      case "status": ui.status(ev.text); return;
+      case "warn": ui.warn(ev.text); return;
+      case "error":
+        // 사용자가 의도적으로 중단(kill)한 턴의 종료 에러(SIGTERM exit 등)는 소음 —
+        // 실사용 테스트에서 확인된 UX 결함. 중단 안내는 REPL이 이미 출력했다.
+        if (this.session && this.session.status === "killed") return;
+        ui.error(ev.text);
+        return;
+      case "line": ui.line(ev.text); return;
+      case "tool": ui.tool(ev.name, ev.summary); return;
+      case "tool-result": ui.toolResult(ev.text, ev.ok); return;
+      case "stream-start": ui.streamStart(); return;
+      case "stream-delta": ui.streamDelta(ev.text); return;
+      case "stream-end": ui.streamEnd(); return;
+      case "task-tool": ui.applyTaskTool(ev.name, ev.input, ev.id); return;
+      case "task-result": ui.applyTaskResult(ev.name, ev.result, ev.id); return;
+      case "cost": ui.cost(ev.usage); return;
+      case "queued": ui.line(ui.c.dim(`  ↳ queued for next turn: ${ev.text}`)); return;
+      default: return;
+    }
+  }
+}
+
+module.exports = { Renderer };

package/engine/ui/repl.cjs

@@ -0,0 +1,444 @@
+"use strict";
+/*
+ * ui/repl — v2 REPL (Claude Code 방식 + 오르카 멀티세션).
+ *
+ * 원칙:
+ *  - 실행 경로는 orchestrator 하나. 포그라운드 턴도 세션이다.
+ *  - 화면은 활성 세션 하나만 스트리밍(Renderer). 백그라운드 턴 종료는 한 줄 notice.
+ *  - 실행 중 입력: 텍스트는 다음 턴 스티어링 큐로, ctrl-c는 현재 턴 중단.
+ *
+ * 세션 조종(오르카):
+ *  /spawn <agent> [task]   백그라운드 서브세션 생성(+실행)
+ *  /sessions · /tree       세션 표 / 부모-자식 트리
+ *  /s <n> · /switch <n>    활성 세션 전환 (tail 재생 + 라이브 구독)
+ *  /steer <n> <msg>        해당 세션 다음 턴 큐잉
+ *  /kill <n> · /rm <n>     턴 중단 / 세션 제거
+ *  /broadcast <msg>        전 세션에 동일 지시
+ */
+const readline = require("node:readline");
+const { renderBanner, readVersion } = require("../agentlas-banner.cjs");
+const { Orchestrator, maxParallel } = require("../sessions/orchestrator.cjs");
+const { Renderer } = require("./renderer.cjs");
+const { findAgent, listAgents } = require("../agents/registry.cjs");
+const { resolveRuntime, NoRuntimeError } = require("../runtimes/resolve.cjs");
+const permissions = require("../agentlas-permissions.cjs");
+
+const DEFAULT_AGENT_SLUG = "agentlas-orchestrator";
+
+function pickDefaultAgent(db) {
+  const visible = listAgents(db);
+  if (visible.length) return visible[0];
+  const builtin = findAgent(db, DEFAULT_AGENT_SLUG);
+  if (builtin) return builtin;
+  return null;
+}
+
+async function startRepl(ctx, opts = {}) {
+  const en = ctx.lang === "en";
+  const ui = ctx.uiInstance;
+  const db = ctx.db();
+
+  try {
+    process.stdout.write(renderBanner({ version: readVersion(), lang: ctx.lang }) + "\n");
+  } catch {
+    ctx.out(`agentlas ${readVersion()}`);
+  }
+
+  // 첫 실행 온보딩 (언어 → 런타임 → 권한). setup 명령으로 언제든 재실행 가능.
+  if (!ctx.prefs.onboarded && process.stdin.isTTY) {
+    const wizardRl = readline.createInterface({ input: process.stdin, output: process.stdout });
+    try {
+      const { runWizard } = require("../commands/setup.cjs");
+      const result = await runWizard(ctx, wizardRl);
+      if (result) {
+        if (result.lang) { ctx.prefs.language = result.lang; }
+        if (result.permission) ctx.prefs.permission = result.permission;
+        if (result.runtime) ctx.prefs.runtime = result.runtime;
+        ctx.prefs.onboarded = !!result.onboarded;
+      }
+    } catch (e) {
+      // 온보딩 실패는 REPL 진입을 막지 않지만, 조용히 삼키면 마법사 프롬프트와
+      // REPL이 stdin을 경합하는 사고(실사용 테스트에서 실증)가 위장된다 — 표시한다.
+      ctx.err(ui.c.dim((en ? "setup wizard failed: " : "설정 마법사 실패: ") + String((e && e.message) || e)));
+    } finally {
+      wizardRl.close();
+    }
+  }
+
+  const orch = new Orchestrator({ db, lang: ctx.lang });
+  const renderer = new Renderer(ui);
+  let permission = permissions.normalize(opts.permission || (ctx.prefs && ctx.prefs.permission) || "write");
+  let runtimeOverride = opts.runtime || null;
+
+  const resolveRt = () => resolveRuntime({ db, prefs: ctx.prefs, explicit: runtimeOverride });
+
+  let resumeChatId = opts.chatId || null;
+  const ensureMainSession = (agentToken) => {
+    const agent = agentToken ? findAgent(db, agentToken) : (orch.active() ? orch.active().agent : pickDefaultAgent(db));
+    if (!agent) {
+      throw new Error(en
+        ? (agentToken ? `agent not found: ${agentToken}` : "no installed agent (agentlas search/install first)")
+        : (agentToken ? `에이전트를 찾을 수 없음: ${agentToken}` : "설치된 에이전트가 없습니다 (agentlas search/install 먼저)"));
+    }
+    const active = orch.active();
+    if (active && active.agent.id === agent.id) return active;
+    const session = orch.spawn({ agent, runtime: resolveRt(), permission, cwd: process.cwd(), activate: true, chatId: resumeChatId });
+    resumeChatId = null; // 재개는 첫 세션에만 적용
+    renderer.attach(session, { replay: false });
+    return session;
+  };
+
+  ctx.out(ui.c.dim(en
+    ? `v2 engine · runtime auto · permission ${permission} · parallel ≤${maxParallel()} — /help, /sessions, /quit`
+    : `v2 엔진 · 런타임 auto · 권한 ${permission} · 동시 ≤${maxParallel()} — /help, /sessions, /quit`));
+
+  if (opts.agent) {
+    try {
+      const session = ensureMainSession(opts.agent);
+      ctx.out(ui.c.dim(`agent: ${session.agent.slug} · ${session.runtime.kind}`));
+    } catch (e) {
+      ctx.err(String((e && e.message) || e));
+    }
+  }
+
+  return new Promise((resolve) => {
+    // 히스토리는 v1 input 모듈 재사용, 완성기는 v2 팔레트(ui/palette)가 정본이다.
+    const input = require("../agentlas-input.cjs");
+    const palette = require("./palette.cjs");
+    const rl = readline.createInterface({
+      input: process.stdin,
+      output: process.stdout,
+      completer: palette.makeCompleter({
+        getAgentSlugs: () => { try { return listAgents(db).map((a) => a.slug); } catch { return []; } },
+        getFirmSlugs: () => {
+          try { return db.prepare("SELECT slug FROM firms ORDER BY slug").all().map((r) => r.slug); } catch { return []; }
+        },
+        getSessionKeys: () => orch.list().map((r) => r.key),
+        getCwd: () => process.cwd(),
+      }),
+    });
+    input.attachHistory(rl);
+    const PROMPT = "› ";
+    const prompt = () => {
+      if (!renderer.session || !renderer.session.isBusy()) {
+        rl.setPrompt(PROMPT);
+        rl.prompt();
+      }
+    };
+
+    orch.on("notice", ({ text, ok }) => {
+      ui.ensureNl();
+      ui.line((ok ? ui.c.emerald("◆ ") : ui.c.amber("◆ ")) + ui.c.dim(text));
+      prompt();
+    });
+
+    let sigints = 0;
+    rl.on("SIGINT", () => {
+      const active = orch.active();
+      if (active && active.isBusy()) {
+        active.kill();
+        ui.ensureNl();
+        ui.line(ui.c.dim(en ? "(turn interrupted)" : "(턴 중단됨)"));
+        sigints = 0;
+        prompt();
+        return;
+      }
+      sigints += 1;
+      if (sigints >= 2) { rl.close(); return; }
+      ui.line(ui.c.dim(en ? "(ctrl-c again to quit)" : "(한 번 더 ctrl-c 하면 종료)"));
+      prompt();
+    });
+
+    const runForeground = (session, text) => {
+      const p = orch.sendTo(session.key, text);
+      if (p && typeof p.then === "function") {
+        p.then(() => prompt(), (e) => { ui.error(String((e && e.message) || e)); prompt(); });
+      }
+    };
+
+    rl.on("line", (line) => {
+      sigints = 0;
+      const input = line.trim();
+      if (!input) { prompt(); return; }
+
+      if (input.startsWith("/")) {
+        try {
+          const quit = handleSlash(ctx, input.slice(1), { orch, renderer, ensureMainSession, resolveRt, setPermission: (p) => { permission = p; }, getPermission: () => permission, setRuntime: (r) => { runtimeOverride = r; } });
+          if (quit === "quit") { rl.close(); return; }
+        } catch (e) {
+          ui.error(String((e && e.message) || e));
+        }
+        prompt();
+        return;
+      }
+
+      if (input.startsWith("!")) {
+        runShell(ctx, input.slice(1).trim(), permission).then(prompt, (e) => { ui.error(String((e && e.message) || e)); prompt(); });
+        return;
+      }
+
+      let session;
+      try {
+        session = orch.active() || ensureMainSession(null);
+        if (!renderer.session) renderer.attach(session, { replay: false });
+      } catch (e) {
+        ui.error(String((e && e.message) || e));
+        prompt();
+        return;
+      }
+
+      if (session.isBusy()) {
+        // 실행 중 타이핑 = 스티어링(다음 턴 큐)
+        session.send(input);
+        return;
+      }
+      try {
+        runForeground(session, input);
+      } catch (e) {
+        ui.error(String((e && e.message) || e));
+        prompt();
+      }
+    });
+
+    rl.on("close", () => {
+      input.persistHistory(rl);
+      renderer.detach();
+      orch.shutdown();
+      ui.ensureNl();
+      resolve(0);
+    });
+
+    prompt();
+  });
+}
+
+/*
+ * !셸 실행 (v1 runShell의 v2 이식 — 핵심 계약 보존):
+ *  - full 권한에서만 실행 (셸은 작업 공간 경계를 강제할 수 없다).
+ *  - env는 턴 한정: buildChildEnv 결과를 spawn에만 전달하고 호스트 프로세스의
+ *    env 객체는 절대 변형하지 않는다 (credential-env-regression 계약).
+ *  - 출력 8MB 캡, 표시 전 시크릿 마스킹, 프로세스 그룹 종료.
+ */
+async function runShell(ctx, cmd, permission) {
+  const ui = ctx.uiInstance;
+  const en = ctx.lang === "en";
+  if (!cmd) return;
+  if (permission !== "full") {
+    ui.warn(en
+      ? "Shell commands require full permission because they cannot enforce the workspace boundary."
+      : "셸 명령은 작업 공간 경계를 강제할 수 없어 무제한 권한에서만 실행됩니다.");
+    return;
+  }
+  const { spawn } = require("node:child_process");
+  const { buildChildEnv } = require("../workforce/capture.cjs");
+  const { redactCommandSecrets } = (() => {
+    try { return require("../agentlas-ui.cjs"); } catch { return { redactCommandSecrets: (s) => s }; }
+  })();
+  let turnEnv;
+  try {
+    turnEnv = await buildChildEnv(ctx.db(), { cwd: process.cwd() });
+  } catch {
+    turnEnv = { ...process.env };
+  }
+  ui.tool("$", typeof redactCommandSecrets === "function" ? redactCommandSecrets(cmd) : cmd);
+  const maxBytes = 8 * 1024 * 1024;
+  await new Promise((resolve) => {
+    const grouped = process.platform !== "win32";
+    const child = spawn(cmd, {
+      shell: true,
+      cwd: process.cwd(),
+      env: turnEnv,
+      stdio: ["ignore", "pipe", "pipe"],
+      detached: grouped,
+    });
+    let bytes = 0;
+    let capped = false;
+    const onData = (d) => {
+      bytes += d.length;
+      if (bytes > maxBytes) {
+        if (!capped) {
+          capped = true;
+          ui.warn(en ? "(output capped at 8MB — command stopped)" : "(출력 8MB 초과 — 명령 중단)");
+          try { grouped ? process.kill(-child.pid, "SIGTERM") : child.kill("SIGTERM"); } catch { /* dead */ }
+        }
+        return;
+      }
+      ui.streamDelta(d.toString("utf8"));
+    };
+    ui.streamStart(true);
+    child.stdout.on("data", onData);
+    child.stderr.on("data", onData);
+    child.on("error", (e) => { ui.streamEnd(); ui.error(e.message); resolve(); });
+    child.on("close", (code) => {
+      ui.streamEnd();
+      if (code !== 0 && !capped) ui.line(ui.c.dim(`exit ${code}`));
+      resolve();
+    });
+  });
+}
+
+function fmtElapsed(ms) {
+  const s = Math.floor(ms / 1000);
+  return s >= 60 ? `${Math.floor(s / 60)}m${s % 60}s` : `${s}s`;
+}
+
+function statusGlyph(ui, row) {
+  if (row.busy) return ui.c.emerald("●");
+  if (row.status === "failed") return ui.c.amber("✗");
+  if (row.status === "killed") return ui.c.dim("■");
+  if (row.status === "done") return ui.c.dim("✓");
+  return ui.c.dim("○");
+}
+
+function printSessions(ctx, orch) {
+  const ui = ctx.uiInstance;
+  const rows = orch.list();
+  if (!rows.length) {
+    ctx.out(ui.c.dim(ctx.lang === "en" ? "no sessions yet — type a task or /spawn <agent> <task>" : "세션 없음 — 작업을 입력하거나 /spawn <agent> <task>"));
+    return;
+  }
+  for (const r of rows) {
+    const indent = "  ".repeat(r.depth);
+    const mark = r.active ? ui.c.paw("▸") : " ";
+    const queued = r.queued ? ui.c.dim(` +${r.queued}q`) : "";
+    const elapsed = r.busy ? ui.c.dim(` ${fmtElapsed(r.elapsedMs)}`) : "";
+    ctx.out(` ${mark} ${statusGlyph(ui, r)} ${ui.c.bold(r.key.padEnd(4))}${indent}${ui.c.paw(r.agent.padEnd(20))}${elapsed}${queued} ${ui.c.dim(r.lastLine || r.status)}`);
+  }
+}
+
+function handleSlash(ctx, cmdline, api) {
+  const en = ctx.lang === "en";
+  const ui = ctx.uiInstance;
+  const { orch, renderer, ensureMainSession } = api;
+  const [cmd, ...rest] = cmdline.split(/\s+/);
+  const restStr = cmdline.slice(cmd.length).trim();
+
+  switch (cmd) {
+    case "quit": case "exit": return "quit";
+    case "help": {
+      require("../commands/help.cjs").run(ctx, rest);
+      ctx.out("");
+      ctx.out(ui.c.bold(en ? "In-REPL session control (Orca)" : "REPL 세션 조종 (오르카)"));
+      // 팔레트는 Tab 완성과 같은 정본(ui/palette)에서 렌더한다 — 목록 드리프트 금지.
+      ctx.out(require("./palette.cjs").renderPalette(ctx.lang));
+      ctx.out("");
+      ctx.out(ctx.uiInstance.c.dim(en
+        ? "Tab completes commands, agent names and session keys · ↑/↓ history · typing during a run queues steering · ctrl-c interrupts"
+        : "Tab: 명령·에이전트·세션키 완성 · ↑/↓ 히스토리 · 실행 중 입력은 스티어링 큐 · ctrl-c 턴 중단"));
+      return;
+    }
+    case "agents": case "list": require("../commands/list.cjs").run(ctx, rest); return;
+    case "chats": require("../commands/chats.cjs").run(ctx, rest); return;
+    case "doctor": require("../commands/doctor.cjs").run(ctx, rest); return;
+    case "mcp": require("../commands/mcp.cjs").run(ctx, rest); return;
+
+    case "sessions": case "tree": printSessions(ctx, orch); return;
+
+    case "s": case "switch": {
+      const key = rest[0] && rest[0].startsWith("s") ? rest[0] : `s${rest[0]}`;
+      const session = orch.setActive(key);
+      renderer.attach(session, { replay: true });
+      return;
+    }
+
+    case "spawn": {
+      const agentToken = rest[0];
+      if (!agentToken) throw new Error("Usage: /spawn <agent> [task]");
+      const agent = findAgent(ctx.db(), agentToken);
+      if (!agent) throw new Error((en ? "agent not found: " : "에이전트를 찾을 수 없음: ") + agentToken);
+      const task = restStr.slice(agentToken.length).trim();
+      const parent = orch.active();
+      const session = orch.spawn({
+        agent,
+        runtime: parent ? parent.runtime : api.resolveRt(),
+        permission: api.getPermission(),
+        cwd: process.cwd(),
+        parentKey: parent ? parent.key : null,
+        activate: false,
+        title: task ? `sub: ${task.slice(0, 60)}` : undefined,
+      });
+      if (task) orch.sendTo(session.key, task);
+      ctx.out(ui.c.dim(`${session.key} ${agent.slug} ${task ? (en ? "started" : "시작됨") : (en ? "ready (use /steer)" : "대기 (—/steer 로 지시)")}`));
+      return;
+    }
+
+    case "steer": {
+      const key = rest[0] && rest[0].startsWith("s") ? rest[0] : `s${rest[0]}`;
+      const msg = restStr.slice(rest[0].length).trim();
+      if (!msg) throw new Error("Usage: /steer <n> <message>");
+      orch.sendTo(key, msg);
+      ctx.out(ui.c.dim(`→ ${key}`));
+      return;
+    }
+
+    case "kill": {
+      const key = rest[0] && rest[0].startsWith("s") ? rest[0] : `s${rest[0]}`;
+      orch.kill(key);
+      return;
+    }
+    case "rm": {
+      const key = rest[0] && rest[0].startsWith("s") ? rest[0] : `s${rest[0]}`;
+      orch.remove(key);
+      const active = orch.active();
+      if (active) renderer.attach(active, { replay: false });
+      return;
+    }
+
+    case "broadcast": {
+      if (!restStr) throw new Error("Usage: /broadcast <message>");
+      const sent = orch.broadcast(restStr);
+      ctx.out(ui.c.dim(`→ ${sent.join(", ") || "(none)"}`));
+      return;
+    }
+
+    case "use": {
+      if (!rest[0]) throw new Error("Usage: /use <agent>");
+      const session = ensureMainSession(rest[0]);
+      renderer.attach(session, { replay: false });
+      ctx.out(ui.c.dim(`agent: ${session.agent.slug}`));
+      return;
+    }
+
+    case "runtime": {
+      if (!rest[0]) throw new Error("Usage: /runtime claude-code|codex|gemini");
+      api.setRuntime(rest[0]);
+      ctx.out(ui.c.dim(`runtime: ${rest[0]} (${en ? "applies to new sessions" : "새 세션부터 적용"})`));
+      return;
+    }
+    case "permission": {
+      if (!["read", "write", "full"].includes(String(rest[0] || ""))) {
+        throw new Error("Usage: /permission read|write|full");
+      }
+      const level = permissions.normalize(rest[0]);
+      api.setPermission(level);
+      ctx.out(ui.c.dim(`permission: ${level} (${en ? "applies to new sessions" : "새 세션부터 적용"})`));
+      return;
+    }
+
+    default: {
+      /*
+       * 최상위 명령 폴스루: REPL 안에서 /search /install /storm /usage … 를 그대로
+       * 쓸 수 있어야 한다(없으면 사용자가 REPL을 나갔다 들어와야 했다).
+       * 제외: 자기 자신을 다시 여는 대화형 명령(chat/open/firm/setup)과 run
+       * (REPL의 평문 입력이 곧 run이다).
+       */
+      // help/agents/list/chats/mcp/doctor 등은 위 케이스에서 이미 처리된다.
+      const REPL_EXCLUDED = new Set(["chat", "open", "firm", "setup", "run"]);
+      const commands = require("../commands/index.cjs");
+      if (!REPL_EXCLUDED.has(cmd) && commands.COMMANDS[cmd]) {
+        const result = commands.COMMANDS[cmd]().run(ctx, rest);
+        if (result && typeof result.catch === "function") {
+          result.catch((e) => ctx.err(String((e && e.message) || e)));
+        }
+        return;
+      }
+      if (commands.DESKTOP_ONLY_SURFACES && commands.DESKTOP_ONLY_SURFACES[cmd]) {
+        ctx.out(ui.c.dim(commands.DESKTOP_ONLY_SURFACES[cmd]));
+        return;
+      }
+      ctx.out(ui.c.dim(en ? `unknown: /${cmd} (see /help)` : `알 수 없는 명령: /${cmd} (/help 참고)`));
+    }
+  }
+}
+
+module.exports = { startRepl, printSessions };