agentlas 0.4.0 → 0.5.2

package/README.md

@@ -1,7 +1,18 @@
 # agentlas
 
-**The Agentlas agent terminal.** Chat with your installed AI agents and teams
-from the terminal — Claude Code style. Standalone: no desktop app required.
+```
+  █████╗  ██████╗ ███████╗███╗   ██╗████████╗██╗      █████╗ ███████╗
+ ██╔══██╗██╔════╝ ██╔════╝████╗  ██║╚══██╔══╝██║     ██╔══██╗██╔════╝
+ ███████║██║  ███╗█████╗  ██╔██╗ ██║   ██║   ██║     ███████║███████╗
+ ██╔══██║██║   ██║██╔══╝  ██║╚██╗██║   ██║   ██║     ██╔══██║╚════██║
+ ██║  ██║╚██████╔╝███████╗██║ ╚████║   ██║   ███████╗██║  ██║███████║
+ ╚═╝  ╚═╝ ╚═════╝ ╚══════╝╚═╝  ╚═══╝   ╚═╝   ╚══════╝╚═╝  ╚═╝╚══════╝
+```
+
+**The operating system for agents — in your terminal.** Chat with your AI
+agents and teams, build new ones, and run the full Agentlas OS surface
+(`build` · `search` · `install` · `storm` · `network` · …) from one command.
+Claude Code style, standalone: **no desktop app required.**
 
 ```sh
 npm install -g agentlas
@@ -40,31 +51,67 @@ Windows(미검증): `powershell -ExecutionPolicy Bypass -File install.ps1`
 ## 사용
 
 ```sh
-agentlas                           # 대화형 TUI (온보딩 → 에이전트 피커 → 스트리밍 REPL)
-agentlas list                      # 설치된 에이전트/회사 + 활성 런타임
-agentlas <agent>                   # 해당 에이전트와 대화형 세션
-agentlas run <agent> "프롬프트"     # 1회 실행 (prompt 없으면 stdin)
-agentlas firm <firm> "프롬프트"     # 회사(팀) 실행
-agentlas cd <agent>                # 에이전트 폴더 경로 → cd "$(agentlas cd seo)" && claude
+agentlas                           # 대화형 TUI (워드마크 → 할 일 입력 → 스트리밍 REPL)
+agentlas "할 일"                    # 자동 라우팅 후 1회 실행
+```
+
+**대화 & 실행**
+```sh
+agentlas <agent>                   # 해당 에이전트와 대화 (예: agentlas seo)
+agentlas run [agent] "프롬프트"      # 1회 실행 (agent 생략 시 자동 라우팅, prompt 없으면 stdin)
+agentlas firm <firm> "프롬프트"     # 회사(팀) CEO에 위임
+agentlas chats [n]                 # 최근 대화 목록
+```
+
+**에이전트 & 허브** (Agentlas OS 표면)
+```sh
+agentlas search "할 일"            # Hub에서 에이전트 발견            (hep-search)
+agentlas install <slug>            # Hub 에이전트 설치                (hep-cloud)
+agentlas build "요청"              # 에이전트/팀 빌드·수리·패키징     (hep-build)
+agentlas upload <경로>             # 에이전트 패키징+Hub 배포         (hep-upload)
+agentlas connect                   # Telegram/플랫폼 연결             (hep-connect)
 agentlas import <폴더>             # 로컬 에이전트/팀 임포트
-agentlas storm "목표"               # Stormbreaker 파이프라인 (라우팅→검증→실행) [--research]
-agentlas swarm "목표"               # emergent 에이전트 스웜 (병렬+블랙보드+종합) [--parallel N]
+agentlas list                      # 설치된 에이전트/회사 + 활성 런타임
+```
+
+**실행 엔진**
+```sh
+agentlas storm "목표"              # 견고 파이프라인 라우팅→검증→실행 (Stormbreaker) [--research]
+agentlas swarm "목표"              # emergent 에이전트 스웜 [--parallel N]
+agentlas network "요청"            # A2A 태스크포스로 분해            (hep-network)
+agentlas call "a,b" "컨텍스트"      # 지정 에이전트 호출               (hep-call)
+agentlas browser                   # 실제 브라우저 하드포인트          (hep-browser)
+agentlas route "요청"              # 라우팅 미리보기 (실행 없음)
+```
+
+**지식 & 리서치**
+```sh
+agentlas research <sub>            # Research Engine (status|gather|search|read|plan)
+agentlas ontology <sub>            # 프로젝트 지식 (status|list|add)
+agentlas journal <sub>             # Stormbreaker 저널 (status|verify|repair|gate)
+```
+
+**계정 & 운영**
+```sh
 agentlas login | logout | whoami   # Agentlas Cloud 로그인 (브라우저 플로우)
-agentlas automation list|add|on|off|remove|runs   # 자동화 등록/관리
-agentlas automation run <id>       # 자동화 지금 1회 실행
-agentlas automation daemon         # 상주 실행기 — 앱 없이 예약 자동화 실행 (앱과 리스 공유)
-agentlas cloud search "찾는 일"     # 마켓플레이스 검색 (로그인 불필요)
-agentlas cloud install <slug>      # 마켓플레이스에서 에이전트 설치
-agentlas usage                     # 로컬 사용 현황 (실행/메시지/자동화)
-agentlas telegram                  # 텔레그램 바인딩 현황 (읽기 전용)
-agentlas creds / env               # 자격증명 · env
+agentlas automation <sub>          # list|add|on|off|remove|run <id>|runs|daemon (로컬 스케줄러)
+agentlas creds <sub> · env         # 자격증명 볼트 · env
 agentlas multimodal                # 이미지/영상/음성 provider
+agentlas usage · telegram · mcp    # 사용 현황 · 텔레그램 · MCP 서버
 agentlas doctor                    # 런타임/데이터 점검
-agentlas setup                     # 온보딩(언어→런타임→권한) 다시 실행
-agentlas update                    # Desktop 최신 릴리스 확인/설치
+agentlas update                    # npm 최신판 확인
+agentlas setup                     # 온보딩 다시 실행
+```
+
+**고급**
+```sh
+agentlas hep <sub…>                # 전체 Hephaestus 패스스루 (wizard·security·cards·ao·plugins…)
+agentlas netadmin <sub>            # 로컬 네트워크 관리 (init|status|reindex|bench)
+agentlas cloud <sub>               # 에이전트 패키징 (wizard|security|bundle|package|publish)
 ```
 
 공통 옵션: `--runtime claude-code|codex|gemini` · `--permission read|write|full`
+REPL 안에서는 `/`로 명령 팔레트 (`/build` `/search` `/storm` `/network` …).
 
 ## 동작 방식
 

package/engine/agentlas-banner.cjs

@@ -1,17 +1,31 @@
 "use strict";
 /*
- * Agentlas terminal splash — small dinosaur mascot (Chrome-dino style) + wordmark + status.
+ * Agentlas terminal splash — AGENTLAS wordmark banner + status card.
  */
 const path = require("node:path");
 const os = require("node:os");
 
-// Small T-Rex (side view, facing right) — eye is ●.
-const DINO_ART = [
-  "          ▟████▙",
-  "          █●  ▜█▙",
-  "   ▖      ████████",
-  "   ▜█▄▄▄▄▄███",
-  "    ▀▀▀█▌ █▌",
+// AGENTLAS wordmark (block letters). Rendered with a brand gradient across columns.
+const WORDMARK = [
+  "  █████╗  ██████╗ ███████╗███╗   ██╗████████╗██╗      █████╗ ███████╗",
+  " ██╔══██╗██╔════╝ ██╔════╝████╗  ██║╚══██╔══╝██║     ██╔══██╗██╔════╝",
+  " ███████║██║  ███╗█████╗  ██╔██╗ ██║   ██║   ██║     ███████║███████╗",
+  " ██╔══██║██║   ██║██╔══╝  ██║╚██╗██║   ██║   ██║     ██╔══██║╚════██║",
+  " ██║  ██║╚██████╔╝███████╗██║ ╚████║   ██║   ███████╗██║  ██║███████║",
+  " ╚═╝  ╚═╝ ╚═════╝ ╚══════╝╚═╝  ╚═══╝   ╚═╝   ╚══════╝╚═╝  ╚═╝╚══════╝",
+];
+
+// Compact single-line wordmark for narrow terminals.
+const WORDMARK_COMPACT = "▞▖ AGENTLAS";
+
+// Brand gradient (emerald → green → lime → blue) applied left-to-right across the wordmark.
+const GRADIENT = [
+  [110, 231, 183],
+  [52, 211, 153],
+  [16, 185, 129],
+  [45, 212, 191],
+  [56, 189, 248],
+  [147, 197, 253],
 ];
 
 function readVersion() {
@@ -28,16 +42,30 @@ function shorten(p) {
   return p.startsWith(home) ? "~" + p.slice(home.length) : p;
 }
 
-// Just the mascot lines (used by the onboarding wizard header).
+// AGENTLAS wordmark, per-column brand gradient. Falls back to plain / compact.
 function renderMascot(ui) {
   const c = ui.c;
+  const cols = (ui.out && ui.out.columns) || 80;
   if (!ui.enabled) {
-    ui.line("  Agentlas");
+    ui.line("  AGENTLAS");
     return;
   }
-  for (let i = 0; i < DINO_ART.length; i++) {
-    const row = DINO_ART[i];
-    ui.line("   " + (i === 1 ? c.text(row).split("●").join(c.emerald("●")) : c.text(row)));
+  // Narrow terminal → compact wordmark.
+  if (cols < 72) {
+    ui.line("  " + c.bold(c.emerald(WORDMARK_COMPACT)));
+    return;
+  }
+  const g = (rgb, s) => `\x1b[1;38;2;${rgb[0]};${rgb[1]};${rgb[2]}m${s}\x1b[0m`;
+  for (const rowStr of WORDMARK) {
+    let outLine = "";
+    const n = rowStr.length || 1;
+    for (let i = 0; i < rowStr.length; i++) {
+      const ch = rowStr[i];
+      if (ch === " ") { outLine += " "; continue; }
+      const idx = Math.min(GRADIENT.length - 1, Math.floor((i / n) * GRADIENT.length));
+      outLine += g(GRADIENT[idx], ch);
+    }
+    ui.line(outLine);
   }
 }
 
@@ -70,10 +98,13 @@ function renderStatusCard(ctx, opts = {}) {
   const runtime = ctx.runtimeLabel || "(not configured)";
   const cwd = ctx.cwd ? shorten(ctx.cwd) : process.cwd();
 
+  ui.line("");
+  if (!opts.noWordmark) {
+    renderMascot(ui);
+    ui.line("  " + c.dim("the operating system for agents") + (version ? c.faint("   v" + version) : ""));
+  }
   ui.line("");
   ui.line(c.faint("╭" + "─".repeat(width - 2) + "╮"));
-  row(ui, width, `>_ Agentlas${version ? " (v" + version + ")" : ""}`);
-  row(ui, width, "");
   row(ui, width, `model:       ${runtime}`);
   row(ui, width, `agent:       ${subject}`);
   row(ui, width, `directory:   ${cwd}`);
@@ -100,9 +131,9 @@ function renderBanner(ctx) {
   ctx.ui.line("");
 }
 
-// runtime · subject · permission · working folder
+// runtime · subject · permission · working folder (no wordmark — used for /status).
 function renderStatus(ctx) {
-  renderStatusCard(ctx, { noTip: true });
+  renderStatusCard(ctx, { noTip: true, noWordmark: true });
 }
 
-module.exports = { renderBanner, renderStatus, renderMascot, readVersion, shorten, DINO_ART, fit };
+module.exports = { renderBanner, renderStatus, renderMascot, readVersion, shorten, WORDMARK, fit };

package/engine/agentlas-doctor.cjs

@@ -29,12 +29,23 @@ function extractHosts(error) {
   return [...hosts];
 }
 
-/** kind: mcp-oauth-unauthenticated | timeout | cli-exit | unknown (데스크탑 TS와 동일 규칙) */
+/** 에러 텍스트에서 config.toml 스키마 위반이 지목한 mcp_servers 이름을 뽑는다. */
+function extractBadMcpServer(error) {
+  // 예: Error loading config.toml: url is not supported for stdio in "mcp_servers.agentlas"
+  const m = /mcp_servers\.([a-z0-9_.-]+)/i.exec(error || "");
+  return m ? m[1] : null;
+}
+
+/** kind: mcp-oauth-unauthenticated | codex-config-invalid | timeout | cli-exit | unknown (데스크탑 TS와 동일 규칙) */
 function classifyFailure(error) {
   const text = error || "";
   if (/authrequired|invalid_token|oauth-protected-resource|www_authenticate/i.test(text)) {
     return { kind: "mcp-oauth-unauthenticated", hosts: extractHosts(text) };
   }
+  // codex config.toml 파싱 실패(예: stdio 서버에 url 키) → CLI가 아예 기동 못 함.
+  if (/error loading config\.toml|url is not supported for stdio|invalid config/i.test(text)) {
+    return { kind: "codex-config-invalid", hosts: [], badServer: extractBadMcpServer(text) };
+  }
   if (/no response for \d+s|auto-aborted/i.test(text)) return { kind: "timeout", hosts: [] };
   if (/CLI exit \d+|exited with code [1-9]/i.test(text)) return { kind: "cli-exit", hosts: extractHosts(text) };
   return { kind: "unknown", hosts: [] };
@@ -120,9 +131,21 @@ function disableCodexPlugin(pluginKey) {
  * 데스크탑 runtime-doctor.ts 의 runRuntimeDoctor 와 동일 계약.
  */
 function runRuntimeDoctor(errorMessage) {
-  const { kind, hosts } = classifyFailure(errorMessage);
+  const { kind, hosts, badServer } = classifyFailure(errorMessage);
   const actions = [];
 
+  if (kind === "codex-config-invalid") {
+    // 진단만 한다(자동 수리 안 함): 원격 MCP 항목이라 안전한 무손실 수리가 없고,
+    // 사용자가 어느 항목을 어떻게 고칠지 알아야 한다. 명확한 조치를 안내한다.
+    const where = badServer ? `[mcp_servers.${badServer}]` : "일부 [mcp_servers.*] 항목";
+    return {
+      kind,
+      summary: `codex의 ~/.codex/config.toml ${where} 이(가) 잘못돼 codex가 기동하지 못합니다(예: stdio 서버에 url 키). 다른 런타임(--runtime claude-code)으로 우회하거나 그 항목을 고치세요.`,
+      repaired: false,
+      actions,
+    };
+  }
+
   if (kind === "mcp-oauth-unauthenticated") {
     const hitList = findOauthPluginsByHost(hosts);
     let repairedAny = false;

package/engine/agentlas-i18n.cjs

@@ -107,6 +107,7 @@ const STRINGS = {
     "help.setup": "run language, runtime, and permission setup again",
     "help.cwd": "show or change the working folder",
     "help.memory": "show the memory being injected",
+    "help.careerGraph": "show/add source refs for the Career Graph routing index",
     "help.ontology": "turn on/list/add project ontology sources with short natural commands",
     "help.side": "ask a side question without saving it to chat context",
     "help.status": "show model/runtime, agent, permission, and directory",
@@ -119,6 +120,11 @@ const STRINGS = {
     "help.build": "build/repair/package an agent or team (Hephaestus)",
     "help.route": "preview which agent/pipeline would take a request",
     "help.research": "run the Research Engine (search/gather/read)",
+    "help.search": "discover agents in the Hub",
+    "help.install": "install an agent from the Hub by slug",
+    "help.network": "decompose a request into an A2A task force",
+    "help.browser": "real browser execution hardpoint",
+    "help.connect": "wire Telegram / platforms to an agent team",
     "help.swarm": "fan out an emergent agent swarm on a goal",
     "help.doctor": "check runtimes and data",
     "help.compact": "drop older transcript turns and keep the latest context",
@@ -252,6 +258,7 @@ const STRINGS = {
     "help.setup": "언어·런타임·권한 설정 다시 실행",
     "help.cwd": "작업 폴더 보기/변경",
     "help.memory": "주입되는 메모리 보기",
+    "help.careerGraph": "Career Graph 라우팅 색인의 원본 경로 보기/등록",
     "help.ontology": "짧은 자연어로 프로젝트 온톨로지 켜기/목록/자료 등록",
     "help.side": "메인 대화 맥락에 저장하지 않는 사이드 질문",
     "help.status": "모델/런타임, 에이전트, 권한, 작업 폴더 보기",
@@ -264,6 +271,11 @@ const STRINGS = {
     "help.build": "에이전트/팀 빌드·수리·패키징 (Hephaestus)",
     "help.route": "요청이 어떤 에이전트로 라우팅되는지 미리보기",
     "help.research": "Research Engine 실행 (search/gather/read)",
+    "help.search": "Hub에서 에이전트 발견",
+    "help.install": "slug로 Hub 에이전트 설치",
+    "help.network": "요청을 A2A 태스크포스로 분해",
+    "help.browser": "실제 브라우저 실행 하드포인트",
+    "help.connect": "Telegram/플랫폼을 에이전트 팀에 연결",
     "help.swarm": "목표에 emergent 에이전트 스웜 전개",
     "help.doctor": "런타임/데이터 점검",
     "help.compact": "오래된 대화 맥락을 줄이고 최근 맥락 유지",

package/engine/agentlas-input.cjs

@@ -75,6 +75,7 @@ const SLASH_COMMAND_META = [
   { command: "/help", description: "Show Agentlas terminal commands", category: "Help", usage: "/help", detail: "Open the command reference, shortcuts, and common flows." },
   { command: "/status", description: "Show model/runtime, agent, permission, and directory", category: "Session", usage: "/status", detail: "Print the current runtime, active agent or company, permission level, and cwd." },
   { command: "/skills", description: "List available Agentlas terminal skills", category: "Discovery", usage: "/skills", detail: "Show the slash-command skills Agentlas can run inside this terminal." },
+  { command: "/career-graph", description: "Show or add Career Graph source refs", category: "Knowledge", usage: "/career-graph add ./docs", detail: "Career Graph routes agents to source Markdown, JSONL ledgers, sitemap, and code map before broad scans.", examples: ["/career-graph status", "/career-graph add ./docs", "/career-graph open"] },
   { command: "/ontology", description: "Turn on, list, or add project ontology sources", category: "Knowledge", usage: "/ontology add ./docs", detail: "Also understands natural text like /ontology use ./docs as company knowledge.", examples: ["/ontology list", "/ontology use ./docs as company knowledge", "/ontology open"] },
   { command: "/agents", description: "List installed agents", category: "Routing", usage: "/agents", detail: "Show local agents and their routed runtime." },
   { command: "/team", description: "View or pin each agent runtime", category: "Routing", usage: "/team <agent> <runtime|auto>", detail: "Pin one agent to claude-code, codex, gemini, or automatic routing." },
@@ -107,6 +108,11 @@ const SLASH_COMMAND_META = [
   { command: "/build", description: "Build/repair/package an agent or team (Hephaestus)", category: "Engine", usage: "/build <what to build>", detail: "Runs Hephaestus hep-build natively — deep interview, scaffolding, packaging." },
   { command: "/route", description: "Preview which agent/pipeline would take a request", category: "Engine", usage: "/route <request>", detail: "Runs the Hephaestus router without executing — shows the selected agent, candidates, and reasons." },
   { command: "/research", description: "Run the Hephaestus Research Engine", category: "Engine", usage: "/research search \"query\"", detail: "status|gather|search|read|plan — evidence-grade web research from the terminal." },
+  { command: "/search", description: "Discover agents in the Hub", category: "Hub", usage: "/search <what you need>", detail: "Search the Agentlas Hub + local for an agent that fits the task (hep-search)." },
+  { command: "/install", description: "Install an agent from the Hub by slug", category: "Hub", usage: "/install <slug>", detail: "Install a marketplace agent into this terminal (hep-cloud)." },
+  { command: "/network", description: "Decompose a request into an A2A task force", category: "Engine", usage: "/network <request>", detail: "Runs Hephaestus hep-network — splits a composite request across agents.", aliases: ["/taskforce"] },
+  { command: "/browser", description: "Real browser execution hardpoint", category: "Engine", usage: "/browser [sub]", detail: "Runs the Agentlas browser hardpoint (hep-browser)." },
+  { command: "/connect", description: "Wire Telegram / platforms to an agent team", category: "Hub", usage: "/connect", detail: "Runs Hephaestus hep-connect for platform integration." },
   { command: "/doctor", description: "Check runtimes and local data", category: "Health", usage: "/doctor", detail: "Run local checks for runtimes, data, credentials, and setup." },
   { command: "/exit", description: "Quit Agentlas", category: "Session", usage: "/exit", detail: "Close the terminal session.", aliases: ["/quit"] },
 ];
@@ -406,6 +412,7 @@ function makeCompleter(ctx) {
         return [uniqStartsWith(RUNTIME_SPECS.concat(["auto"]), last), last];
       case "/cwd":
       case "/import":
+      case "/career-graph":
       case "/ontology":
         return [completePath(last, getCwd(), ""), last];
       default:

package/engine/agentlas-parity.cjs

@@ -23,6 +23,13 @@ const { Ui } = require("./agentlas-ui.cjs");
 const SWARM_MAX_TASKS = 24;
 const SWARM_SPAWN_PER_TURN = 12;
 
+// Agentlas-OS/Hephaestus 내부 시스템 에이전트(마켓 제품 아님) — 검색/목록에서 숨긴다.
+// 데스크탑 electron/agents/hired-agents.ts isInternalAgentSlug 와 규칙 동일.
+function isInternalAgentSlug(slug) {
+  const s = String(slug || "").toLowerCase();
+  return /^researcher-\d+/.test(s) || s === "research-intelligence-desk" || s.startsWith("hephaestus-");
+}
+
 function create(deps) {
   const D = deps;
 
@@ -56,6 +63,35 @@ function create(deps) {
     return null;
   }
 
+  function careerGraphRuntime() {
+    const binCandidates = [
+      process.env.HEPHAESTUS_CAREER_GRAPH_BIN,
+      process.env.HEPHAESTUS_BIN ? path.join(path.dirname(process.env.HEPHAESTUS_BIN), "career-graph") : null,
+      path.join(os.homedir(), ".agentlas", "runtime", "current", "bin", "career-graph"),
+    ];
+    for (const c of binCandidates) {
+      try {
+        if (c && fs.existsSync(c)) {
+          fs.accessSync(c, fs.constants.X_OK);
+          return { kind: "bin", exec: c };
+        }
+      } catch { /* 다음 후보 */ }
+    }
+    const roots = [
+      process.env.HEPHAESTUS_RUNTIME_ROOT,
+      path.join(os.homedir(), ".agentlas", "runtime", "current"),
+    ];
+    if (process.resourcesPath) roots.push(path.join(process.resourcesPath, "Hephaestus"));
+    if (process.platform === "darwin") roots.push("/Applications/Agentlas.app/Contents/Resources/Hephaestus");
+    roots.push(path.resolve(__dirname, "..", "..", "agentlas_desktop", "Hephaestus"));
+    for (const root of roots) {
+      try {
+        if (root && fs.existsSync(path.join(root, "career_graph", "__main__.py"))) return { kind: "python", root };
+      } catch { /* 다음 후보 */ }
+    }
+    return null;
+  }
+
   const PY_BOOTSTRAP =
     "import os, runpy, sys; " +
     'cwd=os.getcwd(); root=os.environ["HEPHAESTUS_RUNTIME_ROOT"]; ' +
@@ -189,17 +225,28 @@ function create(deps) {
   // ── Hephaestus 네이티브 패스스루 — 엔진 전 기능을 터미널 1급으로 노출 ──
   // stdio inherit 로 돌려 색/프롬프트/스트리밍이 네이티브 그대로 나온다.
   function runHephaestusInteractive(args, opts = {}) {
-    const found = hephaestusBin();
+    const isCareerGraph = args[0] === "career-graph" || args[0] === "career_graph";
+    const found = isCareerGraph ? careerGraphRuntime() : hephaestusBin();
     if (!found) {
-      process.stderr.write("Hephaestus 런타임이 없습니다 — 데스크탑 앱 설치 또는 Hephaestus 인스톨러 실행 후 다시 시도하세요.\n");
-      process.stderr.write("설치: https://agentlas.cloud  ·  또는 HEPHAESTUS_BIN=<경로> 지정\n");
+      process.stderr.write(
+        isCareerGraph
+          ? "Career Graph 런타임이 없습니다 — 최신 Agentlas OS / Hephaestus 설치 후 다시 시도하세요.\n"
+          : "Hephaestus 런타임이 없습니다 — 데스크탑 앱 설치 또는 Hephaestus 인스톨러 실행 후 다시 시도하세요.\n",
+      );
+      process.stderr.write(
+        isCareerGraph
+          ? "설치 또는 지정: HEPHAESTUS_CAREER_GRAPH_BIN=<경로> 또는 HEPHAESTUS_RUNTIME_ROOT=<경로>\n"
+          : "설치: https://agentlas.cloud  ·  또는 HEPHAESTUS_BIN=<경로> 지정\n",
+      );
       return Promise.resolve(1);
     }
     const cwd = opts.cwd || D.runCwd();
+    const moduleName = found.kind === "python" && isCareerGraph ? "career_graph" : "agentlas_cloud";
+    const moduleArgs = moduleName === "career_graph" ? args.slice(1) : args;
     const child =
       found.kind === "bin"
-        ? spawn(found.exec, args, { cwd, stdio: "inherit" })
-        : spawn("python3", ["-c", PY_BOOTSTRAP, "agentlas_cloud", ...args], {
+        ? spawn(found.exec, isCareerGraph ? args.slice(1) : args, { cwd, stdio: "inherit" })
+        : spawn("python3", ["-c", PY_BOOTSTRAP, moduleName, ...moduleArgs], {
             cwd,
             stdio: "inherit",
             env: { ...process.env, HEPHAESTUS_RUNTIME_ROOT: found.root },
@@ -958,7 +1005,8 @@ function create(deps) {
         headers,
         body: JSON.stringify({
           method: "marketplace.search_agents",
-          params: { name: "marketplace.search_agents", arguments: { query, limit } },
+          // Hub는 파라미터 이름이 `q` — `query`만 보내면 무시하고 기본 목록을 준다(데스크탑 mcp-source.ts와 동일하게 둘 다 전송).
+          params: { name: "marketplace.search_agents", arguments: { q: query, query, limit } },
         }),
       });
     } catch (e) {
@@ -968,7 +1016,9 @@ function create(deps) {
     const json = await resp.json();
     if (json.error) return D.fail(json.error.message || "marketplace error");
     const result = json.result || {};
-    const items = result.results || result.agents || result.items || (Array.isArray(result) ? result : null);
+    const rawItems = result.results || result.agents || result.items || (Array.isArray(result) ? result : null);
+    // 엔진 내부 에이전트(researcher-<n>, research-intelligence-desk, hephaestus-*)는 제품이 아니므로 숨긴다.
+    const items = Array.isArray(rawItems) ? rawItems.filter((it) => !isInternalAgentSlug(it && (it.slug || it.id))) : rawItems;
     if (!Array.isArray(items) || !items.length) {
       D.out(`검색 결과 없음: "${query}"`);
       return;
@@ -981,7 +1031,7 @@ function create(deps) {
       D.out(`${String(slug).padEnd(34).slice(0, 34)} ${String(name).slice(0, 26).padEnd(27)} ${String(kind).padEnd(14)} ${String(tagline).slice(0, 60)}`);
     }
     D.out("");
-    D.out("설치: agentlas cloud install <slug>");
+    D.out("설치: agentlas install <slug>");
   }
 
   return {

package/engine/agentlas-repl.cjs

@@ -537,7 +537,7 @@ function startRepl(opts) {
     const fmt = (e) => {
       const bits = [e.turns + (e.turns === 1 ? " turn" : " turns")];
       if (e.in || e.out) bits.push(e.in + "→" + e.out + " tok");
-      if (e.cost) bits.push("$" + e.cost.toFixed(4));
+      // 달러 비용 미표시 — 토큰 수만.
       if (e.ms) bits.push((e.ms / 1000).toFixed(1) + "s");
       return bits.join("  ·  ");
     };
@@ -722,6 +722,37 @@ function startRepl(opts) {
         await H.hepRun(["research", ...arg.split(/\s+/)], { cwd: state.cwd });
         return true;
       }
+      case "search": {
+        if (!arg) return ui.warn("usage: /search <할 일>"), true;
+        if (H.cloudSearch) await H.cloudSearch(db, [arg]);
+        else await H.hepRun(["hep-search", arg], { cwd: state.cwd });
+        return true;
+      }
+      case "install": {
+        if (!arg) return ui.warn("usage: /install <slug>  (/search 로 먼저 찾으세요)"), true;
+        if (H.cloudInstall) {
+          try { const r = await H.cloudInstall(db, arg.trim()); ui.ok((r && r.name) ? `설치됨: ${r.name}` : `설치됨: ${arg.trim()}`); }
+          catch (e) { ui.error((e && e.message) || String(e)); }
+        } else ui.warn("설치 기능을 사용할 수 없습니다.");
+        return true;
+      }
+      case "network":
+      case "taskforce": {
+        if (!arg) return ui.warn("usage: /network <요청>  (A2A 태스크포스)"), true;
+        ui.line("");
+        await H.hepRun(["hep-network", arg, "--project", state.cwd, "--runtime", "terminal"], { cwd: state.cwd });
+        return true;
+      }
+      case "browser": {
+        ui.line("");
+        await H.hepRun(["hep-browser", ...(arg ? arg.split(/\s+/) : [])], { cwd: state.cwd });
+        return true;
+      }
+      case "connect": {
+        ui.line("");
+        await H.hepRun(["hep-connect", ...(arg ? arg.split(/\s+/) : [])], { cwd: state.cwd });
+        return true;
+      }
       case "swarm": {
         if (!arg) return ui.warn("usage: /swarm <goal>  [--parallel N]"), true;
         let goal = arg;
@@ -818,6 +849,18 @@ function startRepl(opts) {
         }
         return true;
       }
+      case "career-graph":
+      case "graph": {
+        if (!H.careerGraphCommand) return ui.warn("career graph command unavailable"), true;
+        try {
+          const lines = H.careerGraphCommand(arg, { cwd: state.cwd, projectPath: state.projectPath });
+          ui.line("");
+          for (const item of lines || []) ui.line("  " + ui.c.text(String(item)));
+        } catch (e) {
+          ui.error((e && e.message) || String(e));
+        }
+        return true;
+      }
       case "side":
       case "btw":
         if (!arg) return ui.warn(ui.t("sideUsage")), true;
@@ -1212,6 +1255,7 @@ function printHelp(ui) {
     ["/setup", ui.t("help.setup")],
     ["/cwd [path]", ui.t("help.cwd")],
     ["/memory", ui.t("help.memory")],
+    ["/career-graph [text]", ui.t("help.careerGraph")],
     ["/ontology [text]", ui.t("help.ontology")],
     ["/side <question>", ui.t("help.side")],
     ["/status", ui.t("help.status")],
@@ -1228,8 +1272,12 @@ function printHelp(ui) {
     ["/build <request>", ui.t("help.build")],
     ["/route <request>", ui.t("help.route")],
     ["/research <sub>", ui.t("help.research")],
-    ["/marketplace", ui.t("help.market")],
+    ["/search <task>", ui.t("help.search")],
     ["/install <slug>", ui.t("help.install")],
+    ["/network <req>", ui.t("help.network")],
+    ["/browser", ui.t("help.browser")],
+    ["/connect", ui.t("help.connect")],
+    ["/marketplace", ui.t("help.market")],
     ["/clear", ui.t("help.clear")],
     ["/doctor", ui.t("help.doctor")],
     ["/keybindings", ui.t("help.keybindings")],

package/engine/agentlas-ui.cjs

@@ -252,7 +252,7 @@ class Ui {
     if (usage.input_tokens != null || usage.output_tokens != null) {
       bits.push(`${usage.input_tokens ?? "?"}→${usage.output_tokens ?? "?"} tok`);
     }
-    if (usage.cost_usd != null) bits.push(`$${Number(usage.cost_usd).toFixed(4)}`);
+    // 달러 비용은 표시하지 않는다 — 토큰 수만 (사용자 결정 2026-07-09).
     if (usage.duration_ms != null) bits.push(`${(usage.duration_ms / 1000).toFixed(1)}s`);
     if (bits.length) this.line(this.c.faint("  " + bits.join("  ·  ")));
   }

package/engine/agentlas.cjs

@@ -913,7 +913,7 @@ async function packageCloudAgentCli(db, root, opts) {
   const routingCard = readCloudRoutingCardCli(rootPath);
   if (routingCard.finding) scan.findings.push(routingCard.finding);
   const name = cloudReadName(rootPath);
-  const slug = cloudSlug(opts.slug || name || path.basename(rootPath));
+  const slug = cloudSlug(opts.slug || cloudReadStableSlug(rootPath) || name || path.basename(rootPath));
   const packageHash = cloudHashPackage(scan.included);
   const manifest = {
     version: "0.1",
@@ -1332,11 +1332,29 @@ function printCloudPackageResult(result) {
 }
 
 function cloudReadName(rootPath) {
+  const manifest = cloudReadPackageJson(rootPath);
+  const explicit = stringFirstCli(
+    manifest.agentlas?.displayName,
+    manifest.agentlas?.name,
+    manifest.manifest?.name,
+    manifest.agentCard?.name,
+    manifest.routingCard?.name,
+  );
+  if (explicit) return explicit.replace(/\s+/g, " ").trim().slice(0, 80);
   const text = cloudReadFirst(rootPath, ["agent.md", "AGENT.md", "README.md", "CLAUDE.md", "AGENTS.md"], 2000);
   const heading = text.match(/^#\s+(.+)$/m);
   return (heading ? heading[1] : path.basename(rootPath)).replace(/\s+/g, " ").trim().slice(0, 80);
 }
 function cloudReadTagline(rootPath) {
+  const manifest = cloudReadPackageJson(rootPath);
+  const explicit = stringFirstCli(
+    manifest.agentlas?.summary,
+    manifest.agentlas?.description,
+    manifest.manifest?.description,
+    manifest.agentCard?.summary,
+    manifest.routingCard?.summary,
+  );
+  if (explicit) return explicit.replace(/\s+/g, " ").trim().slice(0, 160);
   const text = cloudReadFirst(rootPath, ["README.md", "agent.md", "AGENT.md"], 3000);
   for (const line of text.split(/\r?\n/)) {
     const t = line.trim();
@@ -1344,6 +1362,32 @@ function cloudReadTagline(rootPath) {
   }
   return "Portable Agentlas cloud agent package.";
 }
+function cloudReadStableSlug(rootPath) {
+  const manifest = cloudReadPackageJson(rootPath);
+  return stringFirstCli(
+    manifest.agentlas?.slug,
+    manifest.agentlas?.id,
+    manifest.manifest?.package,
+    manifest.manifest?.slug,
+    manifest.agentCard?.slug,
+    manifest.agentCard?.id,
+    manifest.routingCard?.agent_card_ref?.slug,
+  );
+}
+function cloudReadPackageJson(rootPath) {
+  return {
+    agentlas: readJsonObjectCli(path.join(rootPath, "agentlas.json"), {}),
+    manifest: readJsonObjectCli(path.join(rootPath, "manifest.json"), {}),
+    agentCard: readJsonObjectCli(path.join(rootPath, ".agentlas", "agent-card.json"), {}),
+    routingCard: readJsonObjectCli(path.join(rootPath, ".agentlas", "routing-card.json"), {}),
+  };
+}
+function stringFirstCli(...values) {
+  for (const value of values) {
+    if (typeof value === "string" && value.trim()) return value.trim();
+  }
+  return "";
+}
 function cloudReadFirst(rootPath, names, maxChars) {
   for (const name of names) {
     const file = path.join(rootPath, name);
@@ -1413,7 +1457,7 @@ function loadArch() {
   try {
     _arch = require("./architecture.data.json");
   } catch {
-    _arch = { version: "0", agents: [], emitterBlock: "", eventsHeading: "## Memory Events", memoryDir: ".agentlas", soulFile: "project-soul-memory.md", sitemapFile: "sitemap.json", logFile: "memory-log.jsonl", kinds: [], scopes: [] };
+    _arch = { version: "0", agents: [], emitterBlock: "", eventsHeading: "## Memory Events", memoryDir: ".agentlas", soulFile: "project-soul-memory.md", sitemapFile: "sitemap.json", logFile: "memory-log.jsonl", careerGraphConfigFile: "career-graph.json", careerGraphSourceManifestFile: "career-graph-sources.json", careerGraphInboxDir: "career-graph-inbox", careerGraphDbFile: "career-graph.sqlite", kinds: [], scopes: [] };
   }
   return _arch;
 }
@@ -1731,6 +1775,10 @@ function ensureProjectMemoryCli(projectPath, projectName) {
     const ontologySourceManifestFile = arch.ontologySourceManifestFile || "ontology-sources.json";
     const ontologyInboxDir = arch.ontologyInboxDir || "ontology-inbox";
     const ontologyDbFile = arch.ontologyDbFile || "ontology-runtime.sqlite";
+    const careerGraphConfigFile = arch.careerGraphConfigFile || "career-graph.json";
+    const careerGraphSourceManifestFile = arch.careerGraphSourceManifestFile || "career-graph-sources.json";
+    const careerGraphInboxDir = arch.careerGraphInboxDir || "career-graph-inbox";
+    const careerGraphDbFile = arch.careerGraphDbFile || "career-graph.sqlite";
     const superOntologyContractFile = arch.superOntologyContractFile || "super-ontology-contract.json";
     const superOntologyOpenWorldCoverageFile =
       arch.superOntologyOpenWorldCoverageFile || "super-ontology-open-world-coverage.json";
@@ -1876,6 +1924,38 @@ function ensureProjectMemoryCli(projectPath, projectName) {
         sources: [],
       }, null, 2), "utf8");
     }
+    const careerGraphInbox = path.join(dir, careerGraphInboxDir);
+    if (!fs.existsSync(careerGraphInbox)) fs.mkdirSync(careerGraphInbox, { recursive: true });
+    const careerGraphConfig = path.join(dir, careerGraphConfigFile);
+    if (!fs.existsSync(careerGraphConfig)) {
+      fs.writeFileSync(careerGraphConfig, JSON.stringify({
+        schemaVersion: "1.0",
+        kind: "agentlas-career-graph",
+        state: "active",
+        model: "ledger_first_derived_index",
+        projectRoot: projectPath,
+        projectName: name,
+        dbPath: path.join(dir, careerGraphDbFile),
+        inboxPath: careerGraphInbox,
+        sourceManifest: path.join(dir, careerGraphSourceManifestFile),
+        canonicalSourcePolicy: {
+          sourceOfTruth: "markdown_jsonl_json",
+          graphIsRebuildable: true,
+          fallbackWhenStale: "read_canonical_files",
+          neverScanHomeDirectory: true,
+          neverScanSiblingProjects: true,
+        },
+      }, null, 2), "utf8");
+    }
+    const careerGraphSources = path.join(dir, careerGraphSourceManifestFile);
+    if (!fs.existsSync(careerGraphSources)) {
+      fs.writeFileSync(careerGraphSources, JSON.stringify({
+        schemaVersion: "1.0",
+        kind: "agentlas-career-graph-source-manifest",
+        projectRoot: projectPath,
+        sources: [],
+      }, null, 2), "utf8");
+    }
     for (const fileName of [skillTrialsFile, curatorDecisionsFile]) {
       const filePath = path.join(dir, fileName);
       if (!fs.existsSync(filePath)) fs.writeFileSync(filePath, "", "utf8");
@@ -5465,6 +5545,182 @@ function runOntologyNaturalCli(text, opts) {
   return runOntologyCli(parseOntologyNaturalArgsCli(text, cwd), { ...(opts || {}), cwd });
 }
 
+function careerGraphPathsForCli(projectPath) {
+  const arch = loadArch();
+  const root = path.resolve(projectPath || process.cwd());
+  const memoryDir = path.join(root, arch.memoryDir || ".agentlas");
+  return {
+    root,
+    memoryDir,
+    configPath: path.join(memoryDir, arch.careerGraphConfigFile || "career-graph.json"),
+    sourceManifestPath: path.join(memoryDir, arch.careerGraphSourceManifestFile || "career-graph-sources.json"),
+    inboxPath: path.join(memoryDir, arch.careerGraphInboxDir || "career-graph-inbox"),
+    dbPath: path.join(memoryDir, arch.careerGraphDbFile || "career-graph.sqlite"),
+  };
+}
+
+function careerGraphSourceManifestSkeletonCli(root) {
+  return {
+    schemaVersion: "1.0",
+    kind: "agentlas-career-graph-source-manifest",
+    projectRoot: root,
+    sources: [],
+  };
+}
+
+function ensureCareerGraphCli(projectPath) {
+  const paths = careerGraphPathsForCli(projectPath);
+  ensureProjectMemoryCli(paths.root, path.basename(paths.root) || "Project");
+  fs.mkdirSync(paths.inboxPath, { recursive: true });
+  if (!fs.existsSync(paths.sourceManifestPath)) {
+    writeJsonSafeCli(paths.sourceManifestPath, careerGraphSourceManifestSkeletonCli(paths.root));
+  }
+  return paths;
+}
+
+function readCareerGraphSourcesCli(sourceManifestPath) {
+  const manifest = readJsonSafeCli(sourceManifestPath, { sources: [] });
+  return Array.isArray(manifest.sources) ? manifest.sources : [];
+}
+
+function careerGraphUsageLinesCli() {
+  return [
+    "Career Graph commands:",
+    "  career-graph status               show source-routing files and index state",
+    "  career-graph list                 list inbox files and registered source refs",
+    "  career-graph open                 open the project career graph inbox",
+    "  career-graph add ./docs           register a folder as private source material",
+    "",
+    "Full graph index commands live in Agentlas OS / Hephaestus:",
+    "  hephaestus career-graph ingest --project .",
+    "  hephaestus career-graph query \"release failures\" --project .",
+    "  hephaestus career-graph verify --project .",
+    "",
+    "Safety: the graph is rebuildable. Markdown, JSONL ledgers, sitemap, and code map stay source of truth.",
+  ];
+}
+
+function existingCareerGraphCanonicalRefsCli(root) {
+  return [
+    ".agentlas/project-soul-memory.md",
+    ".agentlas/memory-log.jsonl",
+    ".agentlas/curator-decisions.jsonl",
+    ".agentlas/sitemap.json",
+    ".agentlas/code-map/project-map.json",
+    ".agentlas/ledgers/routing-decisions.jsonl",
+    ".agentlas/ledgers/executions.jsonl",
+    ".agentlas/ledgers/agent-evolution-proposals.jsonl",
+  ].filter((rel) => fs.existsSync(path.join(root, rel)));
+}
+
+function formatCareerGraphStatusCli(paths) {
+  const sources = readCareerGraphSourcesCli(paths.sourceManifestPath);
+  const inbox = listOntologyInboxCli(paths.inboxPath);
+  const canonical = existingCareerGraphCanonicalRefsCli(paths.root);
+  const lines = [
+    "Career Graph: active",
+    `  project: ${paths.root}`,
+    `  inbox:  ${paths.inboxPath}`,
+    `  db:     ${paths.dbPath}`,
+    `  index:  ${fs.existsSync(paths.dbPath) ? "present" : "pending"}`,
+    "  policy: ledger_first_derived_index",
+    "  source of truth: Markdown / JSONL / JSON files",
+    "",
+    `Canonical source refs (${canonical.length}):`,
+  ];
+  for (const rel of canonical) lines.push(`  ${rel}`);
+  if (!canonical.length) lines.push("  (none yet)");
+  lines.push("", `Inbox (${inbox.length}):`);
+  for (const item of inbox) lines.push(`  ${item.supported ? "ok" : "!"} ${item.name}  ${item.supported ? "supported" : "adapter pending"}`);
+  if (!inbox.length) lines.push("  (empty)");
+  lines.push("", `Registered source refs (${sources.length}):`);
+  for (const source of sources) {
+    const sourcePath = path.resolve(String(source.path || ""));
+    lines.push(`  ${fs.existsSync(sourcePath) ? "ok" : "!"} ${sourcePath}  ${source.kind || "project"} / ${source.scope || "private"}`);
+  }
+  if (!sources.length) lines.push("  (none)");
+  lines.push(
+    "",
+    "Build the derived index with Agentlas OS:",
+    `  hephaestus career-graph ingest --project ${JSON.stringify(paths.root)}`,
+  );
+  return lines;
+}
+
+function registerCareerGraphSourceCli(paths, source, kind, scope, cwd) {
+  if (!source) throw new Error("usage: career-graph add <path>");
+  const sourcePath = resolveOntologyPathCli(source, cwd || paths.root);
+  if (!fs.existsSync(sourcePath)) throw new Error(`source not found: ${sourcePath}`);
+  const manifest = readJsonSafeCli(paths.sourceManifestPath, careerGraphSourceManifestSkeletonCli(paths.root));
+  const nextSources = (Array.isArray(manifest.sources) ? manifest.sources : [])
+    .filter((item) => path.resolve(String(item.path || "")) !== sourcePath);
+  nextSources.push({ path: sourcePath, kind, scope, registeredAt: new Date().toISOString() });
+  manifest.schemaVersion = "1.0";
+  manifest.kind = "agentlas-career-graph-source-manifest";
+  manifest.projectRoot = paths.root;
+  manifest.sources = nextSources;
+  writeJsonSafeCli(paths.sourceManifestPath, manifest);
+  return [
+    `Registered Career Graph source: ${sourcePath}`,
+    `  kind:  ${kind}`,
+    `  scope: ${scope}`,
+    "  copy:  no",
+    "  scan:  only this registered folder, not home/sibling projects",
+  ];
+}
+
+function runCareerGraphCli(args, opts) {
+  opts = opts || {};
+  const cwd = path.resolve(opts.cwd || process.cwd());
+  const projectPath = path.resolve(opts.projectPath || cwd);
+  const normalizedArgs = Array.isArray(args) ? args : [];
+  const sub = normalizedArgs[0] || "status";
+  const paths = ensureCareerGraphCli(projectPath);
+  if (sub === "status" || sub === "list") {
+    return formatCareerGraphStatusCli(paths);
+  }
+  if (sub === "open") {
+    if (!opts.noOpen) openLocalPathCli(paths.inboxPath);
+    return [`Opened Career Graph inbox: ${paths.inboxPath}`];
+  }
+  if (sub === "help" || sub === "--help" || sub === "-h") {
+    return careerGraphUsageLinesCli();
+  }
+  if (sub === "add") {
+    const flags = parseCloudFlags(normalizedArgs.slice(1));
+    const source = flags._[0];
+    const kind = inferOntologyKindCli(flags.kind || flags._[1], normalizedArgs.join(" "));
+    const scope = inferOntologyScopeCli(flags.scope || flags._[2], normalizedArgs.join(" "), kind);
+    return registerCareerGraphSourceCli(paths, source, kind, scope, cwd);
+  }
+  if (["ingest", "query", "verify", "trace"].includes(String(sub))) {
+    return [
+      "Career Graph index execution is provided by Agentlas OS / Hephaestus.",
+      `Run: hephaestus career-graph ${normalizedArgs.join(" ")} --project ${JSON.stringify(paths.root)}`,
+    ];
+  }
+  return runCareerGraphCli(parseOntologyNaturalArgsCli(normalizedArgs.join(" "), cwd), opts);
+}
+
+function runCareerGraphNaturalCli(text, opts) {
+  const cwd = path.resolve((opts && opts.cwd) || process.cwd());
+  return runCareerGraphCli(parseOntologyNaturalArgsCli(text, cwd), { ...(opts || {}), cwd });
+}
+
+async function cmdCareerGraph(args) {
+  const sub = String((args && args[0]) || "status");
+  if (["ingest", "query", "verify", "trace", "public-card"].includes(sub)) {
+    const code = await parity().runHephaestusInteractive(["career-graph", ...args], { cwd: process.cwd() });
+    if (code !== 0) process.exitCode = code;
+    return;
+  }
+  try {
+    for (const line of runCareerGraphCli(args, { cwd: process.cwd(), projectPath: process.cwd() })) out(line);
+  } catch (e) {
+    fail((e && e.message) || String(e));
+  }
+}
+
 function cmdOntology(args) {
   try {
     for (const line of runOntologyCli(args, { cwd: process.cwd(), projectPath: process.cwd() })) out(line);
@@ -6130,6 +6386,11 @@ function buildHelpers(db) {
     stormRun: (db_, goal, ctx) => parity().stormRun(db_, goal, ctx),
     swarmRun: (db_, goal, ctx) => parity().swarmRun(db_, goal, ctx),
     hepRun: (args, opts) => parity().runHephaestusInteractive(args, opts),
+    cloudSearch: (db_, args) => parity().cloudSearch(db_, args),
+    careerGraphCommand: (text, ctx) => runCareerGraphNaturalCli(text, {
+      cwd: (ctx && ctx.cwd) || projectCwd(),
+      projectPath: (ctx && ctx.cwd) || projectCwd(),
+    }),
     ontologyCommand: (text, ctx) => runOntologyNaturalCli(text, {
       cwd: (ctx && ctx.cwd) || projectCwd(),
       projectPath: (ctx && ctx.cwd) || projectCwd(),
@@ -7300,56 +7561,65 @@ async function cmdOberon(args) {
 }
 
 function cmdHelp() {
+  const H = (s) => `\n\x1b[1m${s}\x1b[0m`;
+  const useColor = process.stdout.isTTY && process.env.NO_COLOR == null;
+  const hdr = (s) => (useColor ? H(s) : "\n" + s);
   out(
     [
-      "agentlas — local agent terminal",
+      "agentlas — the operating system for agents, in your terminal",
       "",
-      "  agentlas              open the terminal (status card, then pick an agent)",
-      "  agentlas \"prompt\"     auto-route to the best agent, then run once",
-      "  agentlas <agent>      jump straight into a chat with one agent",
-      "  open <agent>          same as above (explicit)",
-      "  firm <firm> [cmd]     delegate to a company's CEO (interactive if no cmd)",
-      "  run [agent] [prompt]  one-shot — omit agent to auto-route (reads stdin if no prompt)",
-      "  import <path>         import a local folder (agent or team)",
-      "  cd <agent>            print the agent folder — cd \"$(agentlas cd seo)\" && claude",
-      "  list                  agents/companies + active runtime",
-      "  env                   shared env key names",
-      "  multimodal            image/video/audio fallback providers",
-      "  oberon <sub>          AI film render from the terminal (scaffold|render|list) — see: oberon help",
-      "  ontology              project-local ontology status/list/add; inside REPL use /ontology",
-      "  storm <goal>          Stormbreaker force-robust pipeline (route → verify → execute) [--research]",
-      "  swarm <goal>          emergent agent swarm — parallel workers + blackboard + synthesizer [--parallel N]",
-      "  build \"<request>\"     build/repair/package an agent or team (Hephaestus hep-build)",
-      "  route \"<request>\"     routing preview — which agent/pipeline would take this",
-      "  research <sub>        Research Engine: status|gather|search|read|plan …",
-      "  network <sub>         local agent network: init|status|reindex|add-source …",
-      "  journal <sub>         Stormbreaker run journal: status|verify|repair|gate",
-      "  call \"a,b\" \"<ctx>\"    prepare named Hub/Cloud agents (hep-call)",
-      "  hep <sub…>            full Hephaestus passthrough (wizard·security·cards·ao·plugins…)",
-      "  mcp                   installed MCP servers (shared with the app)",
-      "  chats [n]             recent app/terminal chats",
-      "  automation <sub>      list|add|on|off|remove|run <id>|runs|daemon — local runner included",
-      "  login | logout | whoami",
-      "                        Agentlas Cloud sign-in (browser flow) — marketplace install/publish",
-      "  usage                 local usage summary (runs, messages, automations)",
-      "  telegram              telegram binding status (pairing lives in the app)",
-      "  cloud wizard <path>   create/repair agentlas.json for Cloud MCP calls",
-      "  cloud security scan <path>",
-      "                        risk-screen an agent folder before run/publish",
-      "  cloud runtime bundle <path>",
-      "                        compile manifest-based runtime bundle",
-      "  cloud field-test      run local Cloud contract fixture test",
-      "  cloud package <path>  package + static security review for Agentlas Cloud",
-      "  cloud publish <path>  register after local review (submitter runtime only)",
-      "  cloud install <slug>  download/install a cloud marketplace agent",
-      "  creds save ...        save an issued key (project vault + project .env + project-scoped global env)",
-      "  creds file ...        copy a credential file into signing/credentials and set an env path",
-      "  update                check and install the latest Agentlas Desktop release",
-      "  doctor                check runtimes and data",
-      "  setup                 re-run first-launch setup (language · runtime · permission)",
-      "  version               print the Agentlas CLI version",
+      "  agentlas                 open the terminal (wordmark, then type a task)",
+      "  agentlas \"<task>\"        auto-route to the best agent and run once",
       "",
-      "Options: --runtime claude-code|codex|gemini  ·  --permission read|write|full (default write)  ·  --version",
+      hdr("TALK & RUN"),
+      "  <agent>                  jump into a chat with one agent (e.g. agentlas seo)",
+      "  run [agent] [prompt]     one-shot — omit agent to auto-route (reads stdin if no prompt)",
+      "  firm <firm> [cmd]        delegate to a company's CEO (interactive if no cmd)",
+      "  chats [n]                recent conversations   ·   chat resume in REPL: /resume",
+      "",
+      hdr("AGENTS & HUB   (Agentlas OS surface)"),
+      "  search \"<what you need>\" discover agents in the Hub + local            (hep-search)",
+      "  install <slug>           install an agent from the Hub                    (hep-cloud)",
+      "  build \"<request>\"        build/repair/package an agent or team           (hep-build)",
+      "  upload <path>            package + publish an agent to the Hub            (hep-upload)",
+      "  connect [<sub>]          wire Telegram / platforms to an agent team       (hep-connect)",
+      "  import <path>            import a local agent/team folder",
+      "  list                     installed agents/companies + active runtime",
+      "",
+      hdr("EXECUTE"),
+      "  storm <goal>             force-robust pipeline: route → verify → execute  (Stormbreaker) [--research]",
+      "  swarm <goal>             emergent agent swarm — parallel workers + synthesizer [--parallel N]",
+      "  network <request>        decompose a request into an A2A task force       (hep-network)",
+      "  call \"a,b\" \"<ctx>\"       invoke named Hub/Cloud agents                    (hep-call)",
+      "  browser [<sub>]          real browser execution hardpoint                 (hep-browser)",
+      "  route \"<request>\"        routing preview — which agent/pipeline would take this",
+      "",
+      hdr("KNOWLEDGE & RESEARCH"),
+      "  research <sub>           Research Engine: status|gather|search|read|plan",
+      "  career-graph <sub>       source routing index: status|list|add",
+      "  ontology <sub>           project knowledge: status|list|add   (REPL: /ontology)",
+      "  journal <sub>            Stormbreaker run journal: status|verify|repair|gate",
+      "",
+      hdr("ACCOUNT & OPS"),
+      "  login | logout | whoami  Agentlas Cloud sign-in (browser flow)",
+      "  automation <sub>         list|add|on|off|remove|run <id>|runs|daemon (local scheduler)",
+      "  creds <sub> · env        credentials vault and shared env keys",
+      "  multimodal               image/video/audio provider settings",
+      "  usage · telegram · mcp   local usage · telegram bindings · MCP servers",
+      "  doctor                   check runtimes, data, credentials",
+      "  update                   check for a newer agentlas on npm",
+      "  setup                    re-run first-launch setup (language · runtime · permission)",
+      "  version                  print the Agentlas CLI version",
+      "",
+      hdr("ADVANCED"),
+      "  hep <sub…>               full Hephaestus passthrough (wizard·security·cards·ao·plugins·meta-agent…)",
+      "  netadmin <sub>           local network admin: init|status|reindex|bench|add-source",
+      "  cloud <sub>              agent packaging: wizard|security|bundle|package|publish|field-test",
+      "  cd <agent>               print the agent folder — cd \"$(agentlas cd seo)\" && claude",
+      "  oberon <sub>             AI film render (scaffold|render|list)",
+      "",
+      "Options: --runtime claude-code|codex|gemini  ·  --permission read|write|full (default write)",
+      "In the REPL, type / for the command palette (/build /route /research /storm /swarm …).",
     ].join("\n"),
   );
 }
@@ -7429,6 +7699,10 @@ async function main() {
       return cmdOberon(rest.slice(1));
     case "ontology":
       return cmdOntology(rest.slice(1));
+    case "career-graph":
+    case "career_graph":
+    case "graph":
+      return cmdCareerGraph(rest.slice(1));
     case "cloud":
       return cmdCloud(db, rest.slice(1), runtimeOverride);
     case "creds":
@@ -7443,24 +7717,41 @@ async function main() {
     case "hep":
     case "hephaestus":
       return parity().cmdHep(db, rest.slice(1));
+    // ── Agentlas OS 정식 표면 (hep-*) 1급 노출 ──
     case "build":
-      // hep-build "<요청>" — 요청 전체를 한 인자로 (엔진이 딥인터뷰/빌더로 라우팅)
+      // hep-build "<요청>" — 에이전트/팀 빌드 (Meta-Agent Factory)
       return parity().cmdHep(db, rest.length > 1 ? ["hep-build", rest.slice(1).join(" ")] : ["hep-build"]);
-    case "route":
+    case "search": // hep-search — 에이전트 디렉터리 발견 (Hub + 로컬)
+      if (!rest[1]) return fail('usage: agentlas search "<찾는 일>" [--limit 10]');
+      return parity().cloudSearch(db, rest.slice(1));
+    case "install": // hep-cloud import — slug로 에이전트 설치
+      if (!rest[1]) return fail('usage: agentlas install <slug>   (먼저 agentlas search "할 일" 로 찾으세요)');
+      return cmdCloudInstall(db, rest[1]);
+    case "upload": // hep-upload — 컴파일된 에이전트를 Hub로 배포 (경로 필요)
+      if (!rest[1]) return fail("usage: agentlas upload <에이전트 폴더 경로>   (패키징 후 Hub 배포)");
+      return cmdCloud(db, ["publish", ...rest.slice(1)], runtimeOverride);
+    case "connect": // hep-connect — Telegram 등 플랫폼 연결
+      return parity().cmdHep(db, ["hep-connect", ...rest.slice(1)]);
+    case "browser": // hep-browser — 실제 브라우저 실행 하드포인트
+      return parity().cmdHep(db, ["hep-browser", ...rest.slice(1)]);
+    case "call": // hep-call — 지정 에이전트 호출/준비
+      return parity().cmdHep(db, ["hep-call", ...rest.slice(1)]);
+    case "network": // hep-network — A2A 태스크포스 분해/스케줄
+    case "taskforce":
+      return parity().cmdHep(db, ["hep-network", ...rest.slice(1)]);
+    case "route": // 라우팅 미리보기 (실행 없음)
       return parity().cmdHep(
         db,
         rest.length > 1
           ? ["route", rest.slice(1).join(" "), "--project", runCwd(), "--runtime", "terminal"]
           : ["route"],
       );
-    case "research":
+    case "research": // Research Engine
       return parity().cmdHep(db, ["research", ...rest.slice(1)]);
-    case "network":
+    case "netadmin": // 로컬 에이전트 네트워크 관리 (init|status|reindex|bench|add-source)
       return parity().cmdHep(db, ["network", ...rest.slice(1)]);
-    case "journal":
+    case "journal": // Stormbreaker 런 저널
       return parity().cmdHep(db, ["stormbreaker", "journal", ...rest.slice(1)]);
-    case "call":
-      return parity().cmdHep(db, ["hep-call", ...rest.slice(1)]);
     case "mcp":
       return parity().cmdMcp(db);
     case "chats":

package/engine/architecture.data.json

@@ -1,5 +1,5 @@
 {
-  "version": "1.5.34",
+  "version": "1.5.35",
   "emitterBlock": "## Memory (Agentlas curated memory)\n\nIf — and only if — this turn produced something durable (a decision, a stable fact,\na user preference, a risk, a reusable procedure), end your reply with a Memory Events\nblock. Emit nothing when nothing durable was learned.\n\nRules:\n- Never include secrets, credentials, API keys, raw logs, or full transcripts.\n- Real credential values may live only in local project .env/.env.local,\n  ignored signing/ or credentials/ files, or a local keychain/vault. Memory\n  Events may mention env names and local relative paths only.\n- For deploy, release, store, billing, auth, API, or cloud work, first read the\n  project's .agentlas/local-credentials.map.json and the top\n  \"Local Credential Index\" section of .agentlas/project-soul-memory.md\n  before saying a credential is missing.\n- One event per durable item. Keep \"content\" to one or two sentences.\n- \"memory_kind\": fact | decision | preference | risk | procedure | hypothesis | evidence | deprecation | conflict\n- \"suggested_scope\": user_identity | team_memory | project (this folder) | agent_repo | session (temporary) | discard\n- \"agent_team\" is accepted only as a legacy alias for team_memory.\n- Add \"request_context\" when it improves future recall: user_intent, trigger_terms,\n  cwd_at_request, target_project, target_path, cross_context, outcome.\n- Never put the raw user prompt or transcript in request_context.\n- Suggest a scope; the Memory Curator decides the final destination.\n\nFormat (omit entirely if empty):\n\n## Memory Events\n```json\n[\n  {\n    \"memory_kind\": \"decision\",\n    \"content\": \"...\",\n    \"suggested_scope\": \"project\",\n    \"confidence\": \"high\",\n    \"evidence_refs\": [],\n    \"request_context\": {\n      \"user_intent\": \"...\",\n      \"trigger_terms\": [\"...\"],\n      \"cwd_at_request\": null,\n      \"target_project\": null,\n      \"target_path\": null,\n      \"cross_context\": false,\n      \"outcome\": \"...\"\n    }\n  }\n]\n```",
   "eventsHeading": "## Memory Events",
   "memoryDir": ".agentlas",
@@ -14,6 +14,10 @@
   "skillRegistryFile": "skill-registry.json",
   "skillTrialsFile": "skill-trials.jsonl",
   "curatorDecisionsFile": "curator-decisions.jsonl",
+  "careerGraphConfigFile": "career-graph.json",
+  "careerGraphSourceManifestFile": "career-graph-sources.json",
+  "careerGraphInboxDir": "career-graph-inbox",
+  "careerGraphDbFile": "career-graph.sqlite",
   "superOntologyContractFile": "super-ontology-contract.json",
   "superOntologyOpenWorldCoverageFile": "super-ontology-open-world-coverage.json",
   "superOntologyConsensusCoordinationFile": "super-ontology-consensus-coordination.json",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agentlas",
-  "version": "0.4.0",
+  "version": "0.5.2",
   "description": "Agentlas agent terminal — chat with your installed AI agents and teams from the terminal, Claude Code style. Standalone: no desktop app required.",
   "bin": {
     "agentlas": "bin/agentlas.cjs"

package/test/smoke.sh

@@ -25,6 +25,20 @@ check "where"   node "$BIN" --where
 check "version" node "$BIN" version
 check "list"    node "$BIN" list
 check "doctor"  node "$BIN" doctor
+check "help"    node "$BIN" help
+check "usage"   node "$BIN" usage
+check "mcp"     node "$BIN" mcp
+check "chats"   node "$BIN" chats
+
+# Agentlas OS 표면: 무인자 호출은 usage를 내고 exit 1 (프롬프트 오라우팅 방지 확인)
+guard() {
+  name="$1"; shift
+  if out="$("$@" 2>&1)"; then echo "FAIL $name (should exit non-zero)"; fail=$((fail + 1));
+  else echo "PASS $name"; pass=$((pass + 1)); fi
+}
+guard "guard-search"  node "$BIN" search
+guard "guard-install" node "$BIN" install
+guard "guard-upload"  node "$BIN" upload
 
 # 신선 환경 첫 실행 (표준: mktemp 사용, 검증 후 Trash로 이동)
 FRESH="$(mktemp -d "${TMPDIR:-/tmp}/agentlas-smoke-XXXXXX")"