agentlas 1.0.11 → 1.0.14

package/engine/commands/automation.cjs

@@ -92,6 +92,14 @@ async function run(ctx, args) {
       targetId = f.id;
       targetLabel = f.name;
     }
+    // 잘못된 IANA 존이면 nextCronRun 이 cron 파싱 실패와 똑같이 null 을 돌려준다.
+    // 그대로 두면 멀쩡한 cron 을 범인으로 지목해서, 사용자가 cron 만 계속 고쳐 쓰며
+    // 매번 같은 실패를 본다. 존을 먼저 검증해 틀린 필드를 정확히 지목한다.
+    if (flags.tz && !schedule.isValidTimezone(flags.tz)) {
+      return fail(ko
+        ? `타임존을 해석하지 못했습니다: "${flags.tz}" (IANA 형식이 필요합니다 — 예: Asia/Seoul, UTC, America/New_York)`
+        : `Could not parse timezone: "${flags.tz}" (needs IANA format — e.g. Asia/Seoul, UTC, America/New_York)`);
+    }
     const next = schedule.nextCronRun(flags.cron, new Date(), flags.tz || null);
     if (!next) {
       return fail(ko

package/engine/commands/chats.cjs

@@ -20,8 +20,13 @@ function run(ctx, args) {
   }
   for (const r of rows) {
     const when = String(r.updated_at || "").replace("T", " ").slice(0, 16);
-    ctx.out(`  ${ctx.ui.dim(when)}  ${ctx.ui.accent((r.agent_slug || "?").padEnd(20))} ${r.title}`);
+    // id 앞 8자를 먼저 찍는다 — `open <id 앞부분>`이 유일한 재개 경로인데
+    // 목록에 id가 없으면 SQLite를 직접 열지 않는 한 재개가 불가능했다.
+    // 8자는 open.cjs의 모호성 안내(id.slice(0,8))와 같은 규약.
+    const id = String(r.id || "").slice(0, 8);
+    ctx.out(`  ${ctx.ui.bold(id)}  ${ctx.ui.dim(when)}  ${ctx.ui.accent((r.agent_slug || "?").padEnd(20))} ${r.title}`);
   }
+  ctx.out(ctx.ui.dim(ctx.lang === "en" ? "  resume: agentlas open <id>" : "  재개: agentlas open <id>"));
   return 0;
 }
 

package/engine/commands/doctor.cjs

@@ -9,6 +9,19 @@ const fs = require("node:fs");
 const path = require("node:path");
 const { dbPath, userDataDir } = require("../core/paths.cjs");
 const { listAvailableCliRuntimes, activeRuntimeRow } = require("../runtimes/detect.cjs");
+const { resolvedModelRole } = require("../runtimes/roles.cjs");
+
+function roleDetail(selection, role, en) {
+  if (!selection) return en ? "not set" : "미설정";
+  const provider = selection.kind === "byok" ? selection.backend || "byok" : selection.kind;
+  return [
+    `${role}=${provider}${selection.model ? `/${selection.model}` : ""}`,
+    selection.effort ? `effort=${selection.effort}` : null,
+    role === "worker" && selection.inherit
+      ? (en ? "inherits orchestrator" : "오케스트레이터 상속")
+      : null,
+  ].filter(Boolean).join(" · ");
+}
 
 function run(ctx) {
   const en = ctx.lang === "en";
@@ -42,8 +55,17 @@ function run(ctx) {
     ctx.out(ctx.ui.dim("      npm i -g @anthropic-ai/claude-code  ·  @openai/codex  ·  @google/gemini-cli"));
   }
   try {
-    const active = activeRuntimeRow(ctx.db());
+    const db = ctx.db();
+    const active = activeRuntimeRow(db);
     if (active) ok(en ? "active runtime" : "활성 런타임", `${active.kind}${active.model ? ` (${active.model})` : ""}`);
+    const orchestrator = resolvedModelRole(db, "orchestrator");
+    const worker = resolvedModelRole(db, "worker");
+    if (orchestrator && worker) {
+      ok(
+        en ? "model roles" : "모델 역할",
+        `${roleDetail(orchestrator, "orchestrator", en)} · ${roleDetail(worker, "worker", en)}`,
+      );
+    }
   } catch { /* db issue already reported */ }
 
   // 3) 로그인 상태 (세션 파일 관측만 — 네트워크 호출 없음)

package/engine/commands/firm.cjs

@@ -50,11 +50,14 @@ async function run(ctx, args) {
   }
   const ceo = rowToAgent(ceoRow);
 
-  // 간단 플래그 파싱(--runtime/--permission) — 명령끼리 참조 금지 규칙상 run.cjs 미차용.
+  // 간단 플래그 파싱 — 명령끼리 참조 금지 규칙상 run.cjs 미차용.
   const rest = args.slice(1);
-  const flags = { runtime: null, permission: null, task: [] };
+  const flags = { runtime: null, model: null, effort: null, tier: null, permission: null, task: [] };
   for (let i = 0; i < rest.length; i++) {
     if (rest[i] === "--runtime") flags.runtime = rest[++i];
+    else if (rest[i] === "--model") flags.model = rest[++i];
+    else if (rest[i] === "--effort") flags.effort = rest[++i];
+    else if (rest[i] === "--tier") flags.tier = rest[++i];
     else if (rest[i] === "--permission") flags.permission = rest[++i];
     else flags.task.push(rest[i]);
   }
@@ -62,26 +65,71 @@ async function run(ctx, args) {
   if (task) {
     // 3-tier 위임 실행 — PLAN → DELEGATE → SYNTHESIZE (firms/orchestrate.cjs).
     const { runFirmTurn } = require("../firms/orchestrate.cjs");
-    const { resolveRuntimeForAgent, unavailableOverrideNote } = require("../runtimes/overrides.cjs");
+    const {
+      resolveRuntimeForAgent,
+      unavailableOverrideNote,
+      unavailableRoleNote,
+    } = require("../runtimes/overrides.cjs");
+    const { EFFORTS, TIERS } = require("../agentlas-workload-routing.cjs");
     const { Orchestrator } = require("../sessions/orchestrator.cjs");
     const permissions = require("../agentlas-permissions.cjs");
+    // 플래그 검증은 CEO 계획 턴을 부르기 전에. normalize는 모르는 값을 read로 fail-closed
+    // 강등하는데, firm은 그 권한을 CEO·본부 전 세션·종합 턴까지 그대로 물려주므로 조용히
+    // 강등하면 full을 요청한 사용자가 쓰기 차단된 채 3-tier 전체를 돌린 줄 모른다 (run.cjs 동일 가드).
+    if (flags.permission && !permissions.LEVELS.includes(String(flags.permission))) {
+      ctx.err(`unknown --permission ${flags.permission} (use: ${permissions.LEVELS.join(" | ")})`);
+      return 1;
+    }
+    if (flags.effort && !EFFORTS.includes(String(flags.effort))) {
+      ctx.err(`unknown --effort ${flags.effort} (use: ${EFFORTS.join(" | ")})`);
+      return 1;
+    }
+    if (flags.tier && !TIERS.includes(String(flags.tier))) {
+      ctx.err(`unknown --tier ${flags.tier} (use: ${TIERS.join(" | ")})`);
+      return 1;
+    }
+    if (flags.tier && !flags.model) {
+      ctx.err("--tier requires --model: Terminal never guesses a provider model id from a cost tier");
+      return 1;
+    }
     let runtime;
+    let workerRuntime;
     try {
-      // 사다리: 명시 > (agent CEO > firm) 오버라이드 > prefs > active > detected.
+      // CEO는 orchestrator, 본부는 worker. 명시 핀은 기존 firm 호출과의 호환을 위해
+      // 두 역할 모두에 적용하고, 미지정 시 각각 model_roles 기본값을 사용한다.
       runtime = resolveRuntimeForAgent({
         db,
         prefs: ctx.prefs,
         explicit: flags.runtime,
+        model: flags.model,
+        effort: flags.effort,
+        role: "orchestrator",
         targets: [
           { scope: "agent", targetId: ceo.id },
           { scope: "firm", targetId: firm.id },
         ],
       });
+      workerRuntime = resolveRuntimeForAgent({
+        db,
+        prefs: ctx.prefs,
+        explicit: flags.runtime,
+        model: flags.model,
+        effort: flags.effort,
+        role: "worker",
+        targets: [{ scope: "firm", targetId: firm.id }],
+      });
+      if (flags.tier) {
+        runtime.modelTier = flags.tier;
+        workerRuntime.modelTier = flags.tier;
+      }
     } catch (e) {
       ctx.err(String((e && e.message) || e));
       return 1;
     }
     if (runtime.unavailableOverride) ctx.err(ctx.ui.dim(unavailableOverrideNote(runtime, ctx.lang)));
+    if (runtime.unavailableRoleSelection) ctx.err(ctx.ui.dim(unavailableRoleNote(runtime, ctx.lang)));
+    if (workerRuntime.unavailableOverride) ctx.err(ctx.ui.dim(unavailableOverrideNote(workerRuntime, ctx.lang)));
+    if (workerRuntime.unavailableRoleSelection) ctx.err(ctx.ui.dim(unavailableRoleNote(workerRuntime, ctx.lang)));
     const orch = new Orchestrator({ db, lang: ctx.lang });
     const dim = ctx.ui.dim;
     const result = await runFirmTurn({
@@ -91,6 +139,20 @@ async function run(ctx, args) {
       ceoAgent: ceo,
       task,
       runtime,
+      workerRuntime,
+      resolveWorkerRuntime: flags.runtime || flags.model || flags.effort
+        ? null
+        : (node) => resolveRuntimeForAgent({
+            db,
+            prefs: ctx.prefs,
+            explicit: null,
+            role: "worker",
+            targets: [
+              { scope: "agent", targetId: node.agent.id },
+              { scope: "division", targetId: `${firm.id}:${node.role}` },
+              { scope: "firm", targetId: firm.id },
+            ],
+          }),
       permission: permissions.normalize(flags.permission || (ctx.prefs && ctx.prefs.permission) || "write"),
       cwd: process.cwd(),
       onEvent: (ev) => {

package/engine/commands/help.cjs

@@ -9,8 +9,8 @@ const HELP = `agentlas — the operating system for agents, in your terminal
 
 TALK & RUN
   <agent> · chat <agent>   jump into a chat with one agent
-  run [agent] [prompt]     one-shot (-p print · --runtime · --permission; stdin ok)
-  firm <firm> [task]       delegate to a company's CEO
+  run [agent] [prompt]     one-shot (-p · --runtime · --model · --effort · --permission)
+  firm <firm> [task]       delegate to a CEO (--runtime · --model · --effort)
   chats [n] · open <id>    recent conversations · resume one
 
 AGENTS & HUB
@@ -20,14 +20,15 @@ AGENTS & HUB
   build "<request>"        build/repair/package an agent or team
   upload <path>            save owner-private in Agent Cloud (--visibility marketplace to publish)
   import <path> · cd · native prepare  local folder agents
-  list                     installed agents/companies + active runtime
+  list                     installed agents/companies + orchestrator/worker runtimes
   experience <sub>         portable Experience: list|inspect|validate|save|publish|status|export|unpublish
-  variant resolve          local variant selection
+  variant resolve --base-release <id>   local variant selection (variant help)
 
 EXECUTE
   storm <goal>             Goal+UltraCode harness: plan → allocate → execute → verify  [--research]
   swarm <goal>             emergent agent swarm  [--parallel N]
   workforce | network <request>   Agent Workforce Ontology route
+  hep-local | hep-cloud | hep-hub "<request>"   same, restricted to one source scope
   call "a,b" "<ctx>" · browser · route "<req>" [--json] · research <sub>
 
 KNOWLEDGE
@@ -51,10 +52,13 @@ ACCOUNT & OPS
 
 IN-REPL (agentlas → interactive, Orca multi-session)
   /spawn <agent> [task] · /sessions · /tree · /s <n> · /steer <n> <msg> ·
-  /kill <n> · /rm <n> · /broadcast <msg> · /use · /runtime · /permission
+  /kill <n> · /rm <n> · /broadcast <msg> · /use · /runtime · /model · /effort · /permission
   typing during a running turn queues steering; ctrl-c interrupts the turn
 
-Options: -p|--print · --runtime claude-code|codex|gemini · --permission read|write|full
+Options: -p|--print · --runtime claude-code|codex|gemini · --model <exact-id> ·
+         --effort none|minimal|low|medium|high|xhigh|max ·
+         --tier economy|balanced|frontier (requires --model) ·
+         --permission read|write|full
 `;
 
 function run(ctx) {
@@ -62,4 +66,24 @@ function run(ctx) {
   return 0;
 }
 
-module.exports = { run, HELP };
+function runForCommand(ctx, command) {
+  const name = String(command || "").trim();
+  const rows = HELP.split("\n")
+    .map((line) => line.trim())
+    .filter((line) => line && !line.endsWith(":"))
+    .filter((line) => {
+      const commandColumn = line.split(/\s{2,}/, 1)[0];
+      return commandColumn
+        .split(/\s*·\s*|\s*\|\s*/)
+        .some((entry) => entry === name || entry.startsWith(`${name} `));
+    });
+  ctx.out(`Usage: agentlas ${name} [options]`);
+  if (rows.length > 0) {
+    for (const row of rows) ctx.out(`  ${row}`);
+  } else {
+    ctx.out(`  See "agentlas help" for the full command list.`);
+  }
+  return 0;
+}
+
+module.exports = { run, runForCommand, HELP };

package/engine/commands/hep-cloud.cjs

@@ -0,0 +1,31 @@
+"use strict";
+/*
+ * hep-cloud — 로그인한 오너의 Agent Cloud 에이전트만으로 임시 태스크포스 편성.
+ *
+ * WHY 이 파일이 따로 있는가 (2026-07-28 수리):
+ *   COMMAND_ALIASES 가 `hep-cloud → cloud` 로 접혀 있었다. `cloud` 는 이름만 같은
+ *   전혀 다른 명령 — 클라우드 자산 보관함(save|publish|package|list|restore|
+ *   install|delete|field-test)이다. 그래서 `agentlas hep-cloud "<과제>"` 는
+ *   과제를 서브커맨드로 읽고 `usage: agentlas cloud <save|…>` 를 뱉으며 exit 1 —
+ *   hep-cloud 를 한 글자도 언급하지 않는 에러라 사용자에게 다음 수가 없었다.
+ *   스코프(오너 Cloud 한정)를 실제로 지키는 표면은 Hephaestus 네이티브 런타임
+ *   (`hephaestus hep-cloud`)뿐이므로 build/call/legacy-network 와 동일한
+ *   패스스루 계약으로 그쪽에 넘긴다. 자산 보관함은 계속 `agentlas cloud …` 다.
+ *
+ * v1 인자 가드 그대로: help 토큰 → usage 0, 무인자 → usage 실패 exit 1.
+ */
+const { create, usageFor, isHelpToken } = require("../hephaestus/runtime.cjs");
+
+async function run(ctx, args) {
+  if (args.some(isHelpToken)) {
+    ctx.out(usageFor("hep-cloud", ctx.lang));
+    return 0;
+  }
+  if (!args.length) {
+    ctx.err("✖ " + usageFor("hep-cloud", ctx.lang));
+    return 1;
+  }
+  return create(ctx).cmdHep(["hep-cloud", ...args]);
+}
+
+module.exports = { run };

package/engine/commands/hep-hub.cjs

@@ -0,0 +1,30 @@
+"use strict";
+/*
+ * hep-hub — 공개 Agentlas Hub 에이전트만으로 임시 태스크포스 편성.
+ *
+ * WHY 이 파일이 따로 있는가 (2026-07-28 수리):
+ *   COMMAND_ALIASES 가 `hep-hub → search` 로 접혀 있었다. search 는 스태핑이 아니라
+ *   마켓플레이스 디렉터리 나열이고(그마저 Cloud+Hub 혼합 표면이다), 실행은 하지
+ *   않는다. 그래서 `agentlas hep-hub "<과제>"` 는 과제를 검색어로 읽고 슬러그
+ *   목록만 찍은 뒤 exit 0 — 아무것도 실행하지 않고 성공한 척했다(가짜 성공 금지).
+ *   공개 Hub 한정 스태핑을 실제로 수행하는 표면은 Hephaestus 네이티브 런타임
+ *   (`hephaestus hep-hub`)이므로 그쪽에 그대로 넘긴다. 후보만 보고 싶으면
+ *   기존 `agentlas search`(=hep-search)가 그대로 남아 있다.
+ *
+ * v1 인자 가드 그대로: help 토큰 → usage 0, 무인자 → usage 실패 exit 1.
+ */
+const { create, usageFor, isHelpToken } = require("../hephaestus/runtime.cjs");
+
+async function run(ctx, args) {
+  if (args.some(isHelpToken)) {
+    ctx.out(usageFor("hep-hub", ctx.lang));
+    return 0;
+  }
+  if (!args.length) {
+    ctx.err("✖ " + usageFor("hep-hub", ctx.lang));
+    return 1;
+  }
+  return create(ctx).cmdHep(["hep-hub", ...args]);
+}
+
+module.exports = { run };

package/engine/commands/hep-local.cjs

@@ -0,0 +1,32 @@
+"use strict";
+/*
+ * hep-local — 이 머신에 등록된 Local 에이전트만으로 임시 태스크포스 편성.
+ *
+ * WHY 이 파일이 따로 있는가 (2026-07-28 수리):
+ *   COMMAND_ALIASES 가 `hep-local → workforce` 로 접혀 있었다. 터미널 workforce 는
+ *   공개 Hub 메뉴로 스태핑하는 Agent Workforce Ontology 경로이고(엔드포인트:
+ *   AGENTLAS_MCP_BASE_URL, search_candidates 스키마에 sourceScope 자체가 없음),
+ *   cmdWorkforce 는 스코프 플래그를 받지 않는다. 즉 "등록된 로컬만" 이라고
+ *   문서화된 명령이 조용히 Local+Cloud+공개 Hub 전체로 넓혀 실행됐다 —
+ *   사용자가 의도하지 않은 Hub 크레딧 소모까지 포함해서. 스코프는 이름의 전부다.
+ *   스코프를 지킬 수 있는 표면은 Hephaestus 네이티브 런타임(`hephaestus hep-local`)
+ *   뿐이므로, build/call/legacy-network 와 동일한 패스스루 계약으로 그쪽에 넘긴다.
+ *
+ * v1 인자 가드 그대로: help 토큰 → usage 0, 무인자 → usage 실패 exit 1
+ * (요청 문자열 없는 호출이 자연어 라우팅으로 새는 것 방지).
+ */
+const { create, usageFor, isHelpToken } = require("../hephaestus/runtime.cjs");
+
+async function run(ctx, args) {
+  if (args.some(isHelpToken)) {
+    ctx.out(usageFor("hep-local", ctx.lang));
+    return 0;
+  }
+  if (!args.length) {
+    ctx.err("✖ " + usageFor("hep-local", ctx.lang));
+    return 1;
+  }
+  return create(ctx).cmdHep(["hep-local", ...args]);
+}
+
+module.exports = { run };

package/engine/commands/hep-network.cjs

@@ -0,0 +1,43 @@
+"use strict";
+/*
+ * hep-network — 등록된 Local + 오너 Cloud + 공개 Hub 를 연합해 임시 태스크포스 편성.
+ *
+ * WHY 이 파일이 따로 있는가 (2026-07-28 수리):
+ *   COMMAND_ALIASES 가 `hep-network → workforce` 로 접혀 있었다. hep-local/hep-cloud/
+ *   hep-hub 와 정확히 같은 결함이다 — 별칭은 이름만 바꿔주고 스코프는 어디에도
+ *   전달하지 않는다. 터미널 workforce(cmdWorkforce)는 callHubTool 로
+ *   AGENTLAS_MCP_BASE_URL(기본 https://agentlas.cloud/api/mcp/v1)을 직접 치고
+ *   `{workOrder}` 만 보낸다(engine/agentlas-workforce.cjs:3043). 그 서버는
+ *   sourceScope 가 없으면 "hub" 로 기본값을 잡는다
+ *   (agentlas/AgentsAtlas/app/src/lib/mcp/workforce.ts:228). 결과:
+ *
+ *     - 로컬 에이전트와 오너 Cloud 에이전트는 후보 집합에 들어간 적이 없다.
+ *     - 그런데 영수증의 로스터 핀은 전부 source:"hub" 로 기록된다
+ *       (engine/workforce/deps.cjs). "네트워크 전량을 봤다" 로 읽힌다.
+ *
+ *   연합(federation)은 Core 가 소유한다: 세 소스 메뉴를 각각 받아 출처·계보를
+ *   증명하고 하나의 CandidateSet 으로 합친 뒤, 선택은 호스트 LLM 이 한다. 터미널이
+ *   Hub 를 직접 치는 경로에는 그 계층이 통째로 없다. 그래서 build/call/hep-local
+ *   과 동일한 패스스루 계약으로 Hephaestus 네이티브 표면에 넘긴다.
+ *
+ *   `agentlas workforce` 자체는 남겨둔다 — 공개 Hub 스태핑을 그 이름으로 명시해
+ *   부르는 것은 정직한 사용이다. 이름이 소스 스코프를 약속하는 hep-* 만 옮긴다.
+ *
+ * v1 인자 가드 그대로: help 토큰 → usage 0, 무인자 → usage 실패 exit 1
+ * (요청 문자열 없는 호출이 자연어 라우팅으로 새는 것 방지).
+ */
+const { create, usageFor, isHelpToken } = require("../hephaestus/runtime.cjs");
+
+async function run(ctx, args) {
+  if (args.some(isHelpToken)) {
+    ctx.out(usageFor("hep-network", ctx.lang));
+    return 0;
+  }
+  if (!args.length) {
+    ctx.err("✖ " + usageFor("hep-network", ctx.lang));
+    return 1;
+  }
+  return create(ctx).cmdHep(["hep-network", ...args]);
+}
+
+module.exports = { run };

package/engine/commands/index.cjs

@@ -47,6 +47,12 @@ const COMMANDS = {
   evolve: () => require("./evolve.cjs"),
   variant: () => require("./variant.cjs"),
   hep: () => require("./hep.cjs"),
+  // 소스 스코프 스태핑 3종은 1급 명령이다 — 별칭으로 접으면 스코프가 사라진다.
+  // (아래 COMMAND_ALIASES 주석의 2026-07-28 수리 참조.)
+  "hep-network": () => require("./hep-network.cjs"),
+  "hep-local": () => require("./hep-local.cjs"),
+  "hep-cloud": () => require("./hep-cloud.cjs"),
+  "hep-hub": () => require("./hep-hub.cjs"),
   build: () => require("./build.cjs"),
   connect: () => require("./connect.cjs"),
   call: () => require("./call.cjs"),
@@ -106,10 +112,25 @@ const GUARDED_NO_ARG = new Set(["search", "install", "upload"]);
 // 플랫폼 간 이름 통일(오너 결정 2026-07-27): 클로드코드/코덱스에서 부르는 hep-*
 // 스킬명과 터미널 명령이 서로 다르면 사용자가 어느 표면에 있는지에 따라 이름을
 // 바꿔 써야 한다. 같은 기능은 어디서든 같은 이름으로 부른다.
+//
+// 불변식(2026-07-28 수리): 별칭은 "같은 기능"에만 건다. 소스 스코프를 이름에
+// 달고 있는 hep-local / hep-cloud / hep-hub 는 여기 넣으면 안 된다 — 별칭은
+// 이름만 바꿔주고 스코프는 어디에도 전달되지 않기 때문이다. 실제로 그랬다:
+//   hep-cloud → cloud      : 자산 보관함 명령. 과제 문자열을 서브커맨드로 읽어
+//                            `usage: agentlas cloud <save|…>` + exit 1.
+//   hep-local → workforce  : cmdWorkforce 는 스코프 플래그를 받지 않는다(전량
+//                            공개 Hub 메뉴 스태핑). "로컬 전용"이 조용히 넓어짐.
+//   hep-hub   → search     : 디렉터리 나열만 하고 아무것도 실행하지 않음.
+// 세 명령은 스코프를 실제로 지키는 Hephaestus 네이티브 표면으로 가는 1급 명령
+// (COMMANDS 의 hep-local/hep-cloud/hep-hub)으로 승격했다.
+//
+// 같은 이유로 hep-network 도 별칭에서 뺐다(2026-07-28). 이름은 "Local + owner
+// Cloud + public Hub"인데 cmdWorkforce 는 스코프를 어디에도 싣지 않고
+// agentlas.cloud/api/mcp/v1 을 직접 친다. 그 서버는 sourceScope 가 없으면 "hub"
+// 로 기본값을 잡으므로(agentlas/.../lib/mcp/workforce.ts:228) 로컬·클라우드
+// 에이전트는 후보에 들어간 적이 없는데 결과는 네트워크 전량을 본 것처럼 남았다.
+// 연합은 Core 가 소유한다 — 네이티브 표면으로 넘긴다.
 const COMMAND_ALIASES = {
-  "hep-network": "workforce",
-  network: "workforce",
-  "hep-cloud": "cloud",
   "hep-build": "build",
   "hep-call": "call",
   "hep-search": "search",
@@ -117,8 +138,6 @@ const COMMAND_ALIASES = {
   "hep-storm": "storm",
   "hep-browser": "browser",
   "hep-connect": "connect",
-  "hep-local": "workforce",
-  "hep-hub": "search",
 };
 
 function resolveCommandName(cmd) {
@@ -139,8 +158,20 @@ function dispatch(ctx, argv) {
     return 1;
   }
 
-  if (DESKTOP_ONLY_SURFACES[cmd] && rest.length === 0) {
-    ctx.err(`${DESKTOP_ONLY_SURFACES[cmd]}\nIt was not run as a prompt — rerun with quotes if you meant a task: agentlas "${cmd} …"`);
+  /*
+   * 인자 유무와 무관하게 막는다. `rest.length === 0` 조건이 붙어 있던 동안은
+   * 단어 하나만 더 붙이면(`agentlas settings theme`, `marketplace browse`)
+   * 가드를 그냥 지나쳐 dispatch가 undefined를 반환했고, 엔진은 그걸 프롬프트로
+   * 보고 실제 에이전트를 띄웠다 — 제품이 "데스크탑 전용"이라고 선언한 화면
+   * 이름에 토큰이 청구되고 에이전트가 사용자 저장소에서 셸까지 돌렸다(실사용
+   * 실증: settings theme → System Optimizer가 Bash 실행, marketplace browse →
+   * 20883 토큰 소진). agentlas.cjs의 오타 가드는 `normalized.length === 1`
+   * 이라 이 경로를 못 받는다. 여기가 유일한 차단 지점이므로 arity를 보지 않는다.
+   * 진짜 작업이면 안내대로 따옴표로 묶어 하나의 프롬프트로 넘긴다.
+   */
+  if (DESKTOP_ONLY_SURFACES[cmd]) {
+    const asTask = [rawCmd, ...rest].join(" ");
+    ctx.err(`${DESKTOP_ONLY_SURFACES[cmd]}\nIt was not run as a prompt — rerun with quotes if you meant a task: agentlas "${asTask}"`);
     return 1;
   }
 

package/engine/commands/list.cjs

@@ -5,8 +5,25 @@
  * 데스크탑과 동일하게 목록에서 숨긴다.
  */
 const { activeRuntimeRow, listAvailableCliRuntimes } = require("../runtimes/detect.cjs");
+const { resolvedModelRole } = require("../runtimes/roles.cjs");
 const { listAgents } = require("../agents/registry.cjs");
 
+function roleRuntimeLabel(selection, role, en) {
+  if (!selection) return en ? "(not set)" : "(미설정)";
+  const provider = selection.kind === "byok"
+    ? selection.backend || "byok"
+    : selection.kind;
+  const bits = [
+    provider,
+    selection.model ? `(${selection.model})` : "",
+    selection.effort ? `· effort ${selection.effort}` : "",
+  ].filter(Boolean);
+  if (role === "worker" && selection.inherit) {
+    bits.push(en ? "· inherits orchestrator" : "· 오케스트레이터 상속");
+  }
+  return bits.join(" ");
+}
+
 function run(ctx) {
   const db = ctx.db();
   // 프라이버시 정책(웹 전용/백그라운드 제외)은 registry가 소유한다 — 직접 SQL 금지.
@@ -36,7 +53,14 @@ function run(ctx) {
   const active = activeRuntimeRow(db);
   const clis = listAvailableCliRuntimes();
   ctx.out("");
-  ctx.out(ctx.ui.bold(en ? "Runtime" : "런타임"));
+  ctx.out(ctx.ui.bold(en ? "Model roles" : "모델 역할"));
+  const orchestrator = resolvedModelRole(db, "orchestrator");
+  const worker = resolvedModelRole(db, "worker");
+  ctx.out(`  orchestrator: ${roleRuntimeLabel(orchestrator, "orchestrator", en)}`);
+  ctx.out(`  worker:       ${roleRuntimeLabel(worker, "worker", en)}`);
+
+  ctx.out("");
+  ctx.out(ctx.ui.bold(en ? "Legacy runtime compatibility" : "레거시 런타임 호환"));
   if (active) {
     ctx.out(`  active: ${active.kind}${active.model ? ` (${active.model})` : ""}${active.backend ? ` via ${active.backend}` : ""}`);
   } else {

package/engine/commands/open.cjs

@@ -25,7 +25,11 @@ function run(ctx, args) {
     return 1;
   }
   if (rows.length > 1) {
-    ctx.err(ko ? `모호합니다 — 더 긴 접두사를 쓰세요 (${rows.map((r) => r.id.slice(0, 8)).join(", ")})` : `Ambiguous — use a longer prefix (${rows.map((r) => r.id.slice(0, 8)).join(", ")})`);
+    // 안내 접두사는 사용자가 입력한 것보다 반드시 길어야 한다 — chats 목록이
+    // 8자를 찍으므로, 8자로 고정하면 8자 충돌 시 같은 문자열 두 개를 돌려주는
+    // 막다른 길이 된다("더 긴 접두사"를 만들 방법이 없음).
+    const hintLen = Math.max(8, prefix.length + 4);
+    ctx.err(ko ? `모호합니다 — 더 긴 접두사를 쓰세요 (${rows.map((r) => r.id.slice(0, hintLen)).join(", ")})` : `Ambiguous — use a longer prefix (${rows.map((r) => r.id.slice(0, hintLen)).join(", ")})`);
     return 1;
   }
   const chat = rows[0];