agentlas 1.0.10 → 1.0.12

package/engine/agentlas-workload-routing.cjs

@@ -397,10 +397,32 @@ function resolveAllocationAcrossRuntimes(options = {}) {
   return { ...resolution, runtime, runtimeId, requestedRuntimeId: requestedId || null };
 }
 
-function createDecisionReceipt({ taskId, stage, decision, resolution }) {
+function modelRoleForStage(stage) {
+  return ["plan", "planner", "leader", "verify", "verifier", "synthesize", "synthesis", "route", "clarify"]
+    .includes(cleanText(stage, 80).toLowerCase())
+    ? "orchestrator"
+    : "worker";
+}
+
+function normalizeObservedUsage(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return null;
+  const inputTokens = value.inputTokens;
+  const outputTokens = value.outputTokens;
+  return Number.isInteger(inputTokens) && inputTokens >= 0
+    && Number.isInteger(outputTokens) && outputTokens >= 0
+    ? { inputTokens, outputTokens }
+    : null;
+}
+
+function createDecisionReceipt({ taskId, stage, decision, resolution, role, usage }) {
   const normalized = normalizeAllocation(decision);
   const validationIssues = [];
-  if (!normalized) validationIssues.push("invalid-ai-allocation");
+  const decisionProvided = decision != null;
+  if (!decisionProvided) validationIssues.push("allocation_not_provided");
+  else if (!normalized) validationIssues.push("invalid_ai_allocation");
+  const resolvedRole = role === "worker" || role === "orchestrator"
+    ? role
+    : modelRoleForStage(stage);
   const resolutionCodes = cleanText(resolution && resolution.fallbackReason, 500)
     .split(",")
     .map((code) => cleanText(code, 120))
@@ -411,12 +433,13 @@ function createDecisionReceipt({ taskId, stage, decision, resolution }) {
   ])].slice(0, 32);
   const featurePayload = JSON.stringify(normalized ? {
     phase: normalized.phase,
+    role: resolvedRole,
     tier: normalized.tier,
     effort: normalized.effort,
     reasonCodes: normalized.reasonCodes,
     requiredCapabilities: normalized.requiredCapabilities,
     estimatedContextTokens: normalized.estimatedContextTokens,
-  } : { phase: cleanText(stage, 80) || null, allocation: null });
+  } : { phase: cleanText(stage, 80) || null, role: resolvedRole, allocation: null });
   const featureHash = `sha256:${crypto.createHash("sha256").update(featurePayload, "utf8").digest("hex")}`;
   const source = resolution && resolution.source;
   const hasResolvedCurrent = Boolean(
@@ -439,6 +462,7 @@ function createDecisionReceipt({ taskId, stage, decision, resolution }) {
       ? normalized.decisionId
       : `terminal:model-allocation:${featureHash.slice("sha256:".length, "sha256:".length + 24)}`,
     packetId: cleanText(taskId, 255) || null,
+    role: resolvedRole,
     status,
     requested: {
       tier: normalized ? normalized.tier : null,
@@ -460,6 +484,7 @@ function createDecisionReceipt({ taskId, stage, decision, resolution }) {
     selectorVersion: normalized ? normalized.selectorVersion : "deterministic-host-fallback",
     independentVerificationRequired:
       riskCodes.has("high-risk") || riskCodes.has("critical-risk") || riskCodes.has("independent-verification"),
+    usage: normalizeObservedUsage(usage),
     validationIssues,
     privacy: { rawPromptIncluded: false, rawTranscriptIncluded: false },
   };
@@ -522,6 +547,7 @@ module.exports = {
   resolveAllocation,
   resolveAllocationAcrossRuntimes,
   createDecisionReceipt,
+  modelRoleForStage,
   appendDecisionReceipt,
   defaultReceiptPath,
   plannerSystemPrompt,

package/engine/automation/daemon.cjs

@@ -167,6 +167,14 @@ async function runAutomationOnce(ctx, db, row, opts = {}) {
     return { ok: false, skipped: true, reason: "lease" };
   }
 
+  // 데스크탑 스케줄러는 60초마다 리스를 갱신한다. 여기는 한 번 잡고 끝이라
+  // TTL(15분)을 넘긴 실행은 프로세스가 살아 있어도 회수 대상이 됐다 — 같은
+  // 자동화가 두 실행기에서 겹쳐 도는 경로. 같은 주기로 심장박동을 보낸다.
+  const leaseHeartbeat = setInterval(() => {
+    try { store.renewAutomationLease(db, row.id); } catch { /* best-effort */ }
+  }, 60_000);
+  if (typeof leaseHeartbeat.unref === "function") leaseHeartbeat.unref();
+
   try {
     // ── raw-row 실행 계약 게이트 (데스크탑 automation-scheduler.ts:538-549 동형) ──
     // 손상된 계약 값으로는 무인 실행하지 않는다 — 문구까지 데스크탑과 동일.
@@ -246,6 +254,7 @@ async function runAutomationOnce(ctx, db, row, opts = {}) {
     store.advanceAfterRun(db, row, { ok: false, advanceSchedule: !!opts.advanceSchedule });
     return { ok: false, error: msg };
   } finally {
+    clearInterval(leaseHeartbeat);
     store.releaseAutomation(db, row.id);
   }
 }

package/engine/automation/store.cjs

@@ -105,6 +105,27 @@ function claimAutomation(db, id, now = new Date(), owner = LEASE_OWNER) {
   return (result.changes ?? result.rowsAffected ?? 0) > 0;
 }
 
+/**
+ * 이 프로세스가 아직 들고 있는 리스의 claimed_at 을 현재로 민다.
+ *
+ * claimAutomation 은 한 번만 부르고 갱신이 없었다. 데스크탑 스케줄러는 60초마다
+ * 갱신하므로, TTL(15분)을 넘긴 CLI 실행은 프로세스가 멀쩡히 살아 있는데도
+ * 회수 대상이 된다 — 에이전트 세션에서 15분은 평범하고, 그러면 같은 자동화가
+ * 두 실행기에서 겹쳐 돈다. 소유자가 나일 때만 갱신하므로, 이미 남에게 넘어간
+ * 리스를 되빼앗지는 않는다.
+ */
+function renewAutomationLease(db, id, now = new Date(), owner = LEASE_OWNER) {
+  if (!leaseSupported(db)) return false;
+  try {
+    const result = db
+      .prepare("UPDATE automations SET claimed_at = ? WHERE id = ? AND lease_owner = ?")
+      .run(now.toISOString(), id, owner);
+    return (result.changes ?? result.rowsAffected ?? 0) > 0;
+  } catch {
+    return false;
+  }
+}
+
 function releaseAutomation(db, id) {
   try {
     db.prepare("UPDATE automations SET claimed_at = NULL, lease_owner = NULL WHERE id = ?").run(id);
@@ -201,6 +222,7 @@ module.exports = {
   setEnabled,
   removeAutomation,
   claimAutomation,
+  renewAutomationLease,
   releaseAutomation,
   recordRun,
   listRuns,

package/engine/bootstrap-schema.sql

@@ -5,6 +5,30 @@ CREATE TABLE active_runtime (
         id INTEGER PRIMARY KEY CHECK(id = 1),
         kind TEXT NOT NULL
       , backend TEXT, source TEXT, model TEXT, long_context INTEGER NOT NULL DEFAULT 0);
+CREATE TABLE model_roles (
+        role TEXT PRIMARY KEY CHECK(role IN ('orchestrator','worker')),
+        kind TEXT NOT NULL,
+        backend TEXT,
+        source TEXT,
+        model TEXT,
+        effort TEXT,
+        long_context INTEGER NOT NULL DEFAULT 0 CHECK(long_context IN (0,1)),
+        inherit INTEGER NOT NULL DEFAULT 0 CHECK(inherit IN (0,1)),
+        updated_at TEXT NOT NULL,
+        CHECK(role = 'worker' OR inherit = 0)
+      );
+CREATE TABLE model_role_members (
+        role TEXT NOT NULL CHECK(role IN ('orchestrator','worker')),
+        position INTEGER NOT NULL CHECK(position >= 1),
+        kind TEXT NOT NULL,
+        backend TEXT,
+        source TEXT,
+        model TEXT,
+        effort TEXT,
+        long_context INTEGER NOT NULL DEFAULT 0 CHECK(long_context IN (0,1)),
+        updated_at TEXT NOT NULL,
+        PRIMARY KEY(role, position)
+      );
 CREATE TABLE installed_agents (
         id TEXT PRIMARY KEY,
         slug TEXT UNIQUE NOT NULL,

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,64 @@ 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");
+    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 +132,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,7 +20,7 @@ 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
 
@@ -51,10 +51,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) {

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/run.cjs

@@ -3,6 +3,9 @@
  * run — 원샷 실행: agentlas run [agent] [prompt…]
  *   -p | --print          최종 답만 stdout에 (스트리밍 UI 없음)
  *   --runtime <kind>      claude-code | codex | gemini
+ *   --model <id>          exact provider model id
+ *   --effort <level>      none | minimal | low | medium | high | xhigh | max
+ *   --tier <tier>         economy | balanced | frontier (requires --model)
  *   --permission <level>  read | write | full
  * 프롬프트가 없고 stdin이 TTY가 아니면 stdin을 읽는다.
  *
@@ -10,15 +13,19 @@
  * 판정(resolveAutoRoute)이 최적 에이전트를 고른다 — 어휘 점수는 후보 모집 전용이다.
  * 판정 런타임이 없으면 기본 에이전트로 정직 폴백하되 note를 stderr에 반드시 출력한다
  * (조용한 오라우팅/폴백 금지 — 오너 결정).
- * 런타임 사다리: 명시(--runtime) > 에이전트별 오버라이드(agent_runtime_overrides) >
- * prefs > active_runtime > detected (runtimes/overrides.cjs).
+ * 런타임 사다리: 명시 핀 > 에이전트별 오버라이드(agent_runtime_overrides) >
+ * model_roles[orchestrator] > active_runtime > detected (runtimes/overrides.cjs).
  */
 const { findAgent, listAgents } = require("../agents/registry.cjs");
-const { resolveRuntime } = require("../runtimes/resolve.cjs");
-const { resolveRuntimeForAgent, unavailableOverrideNote } = require("../runtimes/overrides.cjs");
+const {
+  resolveRuntimeForAgent,
+  unavailableOverrideNote,
+  unavailableRoleNote,
+} = require("../runtimes/overrides.cjs");
 const { Orchestrator } = require("../sessions/orchestrator.cjs");
 const { Renderer } = require("../ui/renderer.cjs");
 const permissions = require("../agentlas-permissions.cjs");
+const { EFFORTS, TIERS } = require("../agentlas-workload-routing.cjs");
 
 function readStdin() {
   return new Promise((resolve) => {
@@ -30,11 +37,22 @@ function readStdin() {
 }
 
 function parseArgs(args) {
-  const out = { print: false, runtime: null, permission: null, rest: [] };
+  const out = {
+    print: false,
+    runtime: null,
+    model: null,
+    effort: null,
+    tier: null,
+    permission: null,
+    rest: [],
+  };
   for (let i = 0; i < args.length; i++) {
     const a = args[i];
     if (a === "-p" || a === "--print") out.print = true;
     else if (a === "--runtime") out.runtime = args[++i];
+    else if (a === "--model") out.model = args[++i];
+    else if (a === "--effort") out.effort = args[++i];
+    else if (a === "--tier") out.tier = args[++i];
     else if (a === "--permission") out.permission = args[++i];
     else out.rest.push(a);
   }
@@ -49,6 +67,18 @@ async function runOnce(ctx, args) {
     ctx.err(`unknown --permission ${parsed.permission} (use: read | write | full)`);
     return 1;
   }
+  if (parsed.effort && !EFFORTS.includes(String(parsed.effort))) {
+    ctx.err(`unknown --effort ${parsed.effort} (use: ${EFFORTS.join(" | ")})`);
+    return 1;
+  }
+  if (parsed.tier && !TIERS.includes(String(parsed.tier))) {
+    ctx.err(`unknown --tier ${parsed.tier} (use: ${TIERS.join(" | ")})`);
+    return 1;
+  }
+  if (parsed.tier && !parsed.model) {
+    ctx.err("--tier requires --model: Terminal never guesses a provider model id from a cost tier");
+    return 1;
+  }
   const db = ctx.db();
 
   let agent = null;
@@ -70,7 +100,15 @@ async function runOnce(ctx, args) {
   // 기본 런타임을 먼저 확정한다 — 판정 러너(자동 라우팅)도 이 런타임을 쓴다.
   let runtime;
   try {
-    runtime = resolveRuntime({ db, prefs: ctx.prefs, explicit: parsed.runtime });
+    runtime = resolveRuntimeForAgent({
+      db,
+      prefs: ctx.prefs,
+      explicit: parsed.runtime,
+      model: parsed.model,
+      effort: parsed.effort,
+      role: "orchestrator",
+    });
+    if (parsed.tier) runtime.modelTier = parsed.tier;
   } catch (e) {
     ctx.err(String((e && e.message) || e));
     return 1;
@@ -103,13 +141,27 @@ async function runOnce(ctx, args) {
     if (choice && choice.note) ctx.err(ctx.uiInstance.c.dim(choice.note));
   }
 
-  // 에이전트가 확정된 뒤 에이전트별 런타임 오버라이드를 얹는다(명시 --runtime이 항상 우선).
-  if (!parsed.runtime && agent && agent.id) {
+  // 에이전트가 확정된 뒤 에이전트별 오버라이드를 포함한 전체 사다리를 다시 해석한다.
+  // 명시 runtime/model/effort 핀은 항상 최상단이라 에이전트 기본값보다 우선한다.
+  if (agent && agent.id) {
     try {
-      const layered = resolveRuntimeForAgent({ db, prefs: ctx.prefs, explicit: null, agentId: agent.id });
+      const layered = resolveRuntimeForAgent({
+        db,
+        prefs: ctx.prefs,
+        explicit: parsed.runtime,
+        model: parsed.model,
+        effort: parsed.effort,
+        role: "orchestrator",
+        agentId: agent.id,
+      });
       if (layered.unavailableOverride) ctx.err(ctx.uiInstance.c.dim(unavailableOverrideNote(layered, ctx.lang)));
+      if (layered.unavailableRoleSelection) ctx.err(ctx.uiInstance.c.dim(unavailableRoleNote(layered, ctx.lang)));
+      if (parsed.tier) layered.modelTier = parsed.tier;
       runtime = layered;
-    } catch { /* 오버라이드 층 실패 → 이미 확정된 기본 런타임 유지 */ }
+    } catch (e) {
+      ctx.err(String((e && e.message) || e));
+      return 1;
+    }
   }
 
   const orch = new Orchestrator({ db, lang: ctx.lang });
@@ -125,7 +177,9 @@ async function runOnce(ctx, args) {
   if (!parsed.print) {
     renderer = new Renderer(ctx.uiInstance);
     renderer.attach(session, { replay: false });
-    ctx.err(ctx.uiInstance.c.dim(`${agent.slug} · ${runtime.kind}`));
+    ctx.err(ctx.uiInstance.c.dim(
+      `${agent.slug} · ${runtime.kind}${runtime.model ? ` · ${runtime.model}` : ""}${runtime.effort ? ` · ${runtime.effort}` : ""}`,
+    ));
   }
 
   const res = await session.send(prompt);

package/engine/firms/orchestrate.cjs

@@ -204,13 +204,15 @@ function turnText(res) {
  * 회사 1태스크 실행: PLAN → DELEGATE → SYNTHESIZE.
  * @param {object} p
  *   db, orch(Orchestrator), firm(firms 행), ceoAgent(rowToAgent 결과),
- *   task, runtime, permission, cwd, onEvent?({phase,...}),
+ *   task, runtime(orchestrator), workerRuntime?, resolveWorkerRuntime?(division),
+ *   permission, cwd, onEvent?({phase,...}),
  *   spawnImplFor?({kind:'ceo'|'division', role?}) — 계약 테스트 전용 fake spawn 주입,
  *   timeoutConfig? — 테스트 전용.
  * @returns {ok, text, chatId, plan:{text,delegations}, divisions:[{role,name,ok,text,chatId}]}
  */
 async function runFirmTurn(p) {
   const { db, orch, firm, ceoAgent, task, runtime, permission, cwd } = p;
+  const workerRuntime = p.workerRuntime || runtime;
   const onEvent = typeof p.onEvent === "function" ? p.onEvent : () => {};
   const parseDelegations = loadDelegateParser();
   const divisions = resolveDivisions(db, firm, ceoAgent);
@@ -269,15 +271,20 @@ async function runFirmTurn(p) {
   // kind='division' + parent_chat_id(CEO 챗)로 영속된다. 한 본부의 실패는 격리한다.
   onEvent({ phase: "delegate", targets: matched.map((m) => ({ role: m.node.role, name: m.node.name, brief: m.brief })) });
   const divisionResults = await parallelCap(matched, maxParallel(), async (m) => {
+    const divisionRuntime = typeof p.resolveWorkerRuntime === "function"
+      ? p.resolveWorkerRuntime(m.node)
+      : workerRuntime;
     const session = orch.spawn({
       agent: m.node.agent,
-      runtime,
+      runtime: divisionRuntime,
       permission,
       cwd,
       title: `division: ${m.node.role}`,
       parentKey: ceoSession.key,
       activate: false,
-      spawnImpl: p.spawnImplFor ? p.spawnImplFor({ kind: "division", role: m.node.role }) : undefined,
+      spawnImpl: p.spawnImplFor
+        ? p.spawnImplFor({ kind: "division", role: m.node.role, runtime: divisionRuntime })
+        : undefined,
       timeoutConfig: p.timeoutConfig,
     });
     // 본부 세션도 generic 자동 위임을 끈다 — 터미널 firm 은 아직 tier-3(전문가) 배선이