agentlas 1.0.11 → 1.0.12

package/engine/runtimes/overrides.cjs

@@ -13,7 +13,13 @@
  */
 const { tableExists, columnExists } = require("../core/db.cjs");
 const { RUNTIME_BIN, whichSync } = require("./detect.cjs");
-const { resolveRuntime, EXECUTABLE_KINDS } = require("./resolve.cjs");
+const {
+  resolveRuntime,
+  EXECUTABLE_KINDS,
+  CLI_EXECUTABLE_KINDS,
+  API_EXECUTABLE_KINDS,
+} = require("./resolve.cjs");
+const { pickRoleFromPool } = require("./roles.cjs");
 
 const OVERRIDE_TABLE = "agent_runtime_overrides";
 // 데스크탑 VALID_SCOPES 동형. v2 터미널 호출자는 주로 'agent'지만 firm/division도 읽을 수 있다.
@@ -78,7 +84,7 @@ function findRuntimeOverride(db, targets) {
 
 /**
  * 오버라이드를 얹은 런타임 해석.
- * @param {object} p { db, prefs, explicit, agentId, targets?, deps? }
+ * @param {object} p { db, prefs, explicit, model?, effort?, role?, agentId, targets?, deps? }
  *   targets: [{scope,targetId}] — 주면 agentId 대신 이 우선순위로 오버라이드를 찾는다
  *            (firm 경로: agent > division > firm).
  *   deps: 테스트 주입 { which, resolve } — 상용 호출자는 사용하지 않는다.
@@ -86,10 +92,48 @@ function findRuntimeOverride(db, targets) {
  *          { ..., unavailableOverride } (오버라이드가 있으나 이 머신/v2에서 실행 불가 —
  *          조용히 무시하지 않고 사유를 실어 보내며, 호출자가 note를 출력해야 한다)
  */
-function resolveRuntimeForAgent({ db, prefs, explicit, agentId, targets, deps } = {}) {
+function resolveRuntimeForAgent({
+  db,
+  prefs,
+  explicit,
+  model,
+  effort,
+  role = "orchestrator",
+  agentId,
+  targets,
+  deps,
+} = {}) {
   const resolveImpl = (deps && deps.resolve) || resolveRuntime;
+  const withPins = (runtime) => ({
+    ...runtime,
+    ...(cleanText(model) ? { model: cleanText(model) } : {}),
+    ...(cleanText(effort) ? { effort: cleanText(effort) } : {}),
+  });
+  const selectedRuntime = (selection, source) => {
+    const kind = selection && selection.kind;
+    if (API_EXECUTABLE_KINDS.has(kind)) {
+      return {
+        kind,
+        backend: selection.backend || kind,
+        model: cleanText(model) || cleanText(selection.model) || undefined,
+        effort: cleanText(effort) || cleanText(selection.effort) || undefined,
+        source,
+      };
+    }
+    if (!CLI_EXECUTABLE_KINDS.has(kind)) return null;
+    const which = (deps && deps.which) || whichSync;
+    const bin = which(RUNTIME_BIN[kind]);
+    if (!bin) return null;
+    return {
+      kind,
+      bin,
+      model: cleanText(model) || cleanText(selection.model) || undefined,
+      effort: cleanText(effort) || cleanText(selection.effort) || undefined,
+      source,
+    };
+  };
   // 명시(--runtime)가 항상 이긴다 — 오버라이드는 "사용자가 고르지 않았을 때"의 기본값이다.
-  if (explicit) return resolveImpl({ db, prefs, explicit });
+  if (explicit) return withPins(resolveImpl({ db, prefs, explicit }));
 
   const override = targets && targets.length
     ? findRuntimeOverride(db, targets)
@@ -98,27 +142,43 @@ function resolveRuntimeForAgent({ db, prefs, explicit, agentId, targets, deps }
       : null;
   if (override) {
     const kind = override.selection.kind;
-    // v2 스트리밍 드라이버가 있는 CLI 런타임만 실제 실행 대상이다. byok/ollama/kimi
-    // 오버라이드는 데스크탑에서는 유효하지만 터미널 v2 실행 사다리에는 아직 없다 —
-    // 조용히 다른 런타임으로 둔갑시키지 않고 unavailableOverride로 정직하게 알린다.
+    // CLI 스트리밍과 로컬 API(Ollama)는 같은 Session 경로를 쓴다. 아직 연결되지
+    // 않은 BYOK/kimi 등은 조용히 다른 런타임으로 둔갑시키지 않는다.
     if (EXECUTABLE_KINDS.has(kind)) {
-      const which = (deps && deps.which) || whichSync;
-      const bin = which(RUNTIME_BIN[kind]);
-      if (bin) {
-        return {
-          kind,
-          bin,
-          model: override.selection.model,
-          effort: override.selection.effort,
-          source: "agent-override",
-          override,
-        };
-      }
+      const selected = selectedRuntime(override.selection, "agent-override");
+      if (selected) return { ...selected, override, role };
+    }
+    const resolved = withPins(resolveImpl({ db, prefs, explicit: null }));
+    return { ...resolved, unavailableOverride: override, role };
+  }
+
+  // Role defaults sit above active_runtime/detected but below exact per-call
+  // pins and agent/firm/division overrides. v80 풀(순서=우선순위)이 있으면
+  // 이 Terminal에서 실행 가능한 첫 멤버를 쓰고, 스킵 내역은 결과에 남긴다.
+  // 풀이 없으면 pickRoleFromPool이 단일 행/레거시 해석으로 내려간다.
+  const roleSelection = pickRoleFromPool(db, role, (member) => {
+    if (!EXECUTABLE_KINDS.has(member.kind)) return false;
+    return Boolean(selectedRuntime(member, member.sourceLayer));
+  });
+  if (roleSelection && EXECUTABLE_KINDS.has(roleSelection.kind)) {
+    const selected = selectedRuntime(roleSelection, roleSelection.sourceLayer);
+    if (selected) {
+      return {
+        ...selected,
+        role,
+        inheritedRole: roleSelection.inherit,
+        ...(roleSelection.skipped?.length
+          ? { rolePoolSkipped: roleSelection.skipped }
+          : {}),
+      };
     }
-    const resolved = resolveImpl({ db, prefs, explicit: null });
-    return { ...resolved, unavailableOverride: override };
   }
-  return resolveImpl({ db, prefs, explicit: null });
+  const resolved = withPins(resolveImpl({ db, prefs, explicit: null }));
+  return {
+    ...resolved,
+    role,
+    ...(roleSelection ? { unavailableRoleSelection: roleSelection } : {}),
+  };
 }
 
 /** 오버라이드 실행 불가 시 사용자에게 출력할 한 줄 (데스크탑 문구 동형). */
@@ -130,10 +190,19 @@ function unavailableOverrideNote(runtime, lang) {
     : `Assigned runtime (${kind}) is unavailable here — using the default runtime (${runtime.kind}).`;
 }
 
+function unavailableRoleNote(runtime, lang) {
+  if (!runtime || !runtime.unavailableRoleSelection) return "";
+  const selected = runtime.unavailableRoleSelection;
+  return lang === "ko"
+    ? `${selected.role} 기본 런타임(${selected.kind})을 이 Terminal에서 실행할 수 없어 ${runtime.kind}으로 실행합니다.`
+    : `${selected.role} default runtime (${selected.kind}) is unavailable in this Terminal — using ${runtime.kind}.`;
+}
+
 module.exports = {
   readAgentRuntimeOverride,
   readRuntimeOverride,
   findRuntimeOverride,
   resolveRuntimeForAgent,
   unavailableOverrideNote,
+  unavailableRoleNote,
 };

package/engine/runtimes/resolve.cjs

@@ -7,9 +7,25 @@
  */
 const { RUNTIME_BIN, whichSync, listAvailableCliRuntimes, activeRuntimeRow } = require("./detect.cjs");
 
-// native-host가 스트리밍 드라이버를 갖춘 런타임만 실행 대상으로 삼는다.
-// kimi/grok/cursor 드라이버가 포팅되면 여기에 추가한다 (조용한 오폭 방지).
-const EXECUTABLE_KINDS = new Set(["claude-code", "codex", "gemini"]);
+// Session이 실제 드라이버를 갖춘 런타임만 실행 대상으로 삼는다.
+// CLI는 native-host, Ollama는 로컬 API loop를 쓴다. 다른 드라이버가 포팅되면
+// 해당 집합에 추가한다(조용한 오폭 방지).
+const CLI_EXECUTABLE_KINDS = new Set(["claude-code", "codex", "gemini"]);
+const API_EXECUTABLE_KINDS = new Set(["ollama"]);
+const EXECUTABLE_KINDS = new Set([
+  ...CLI_EXECUTABLE_KINDS,
+  ...API_EXECUTABLE_KINDS,
+]);
+
+function apiRuntime(kind, model, source) {
+  if (!API_EXECUTABLE_KINDS.has(kind)) return null;
+  return {
+    kind,
+    backend: kind,
+    ...(model ? { model } : {}),
+    source,
+  };
+}
 
 class NoRuntimeError extends Error {
   constructor(message) {
@@ -24,9 +40,11 @@ class NoRuntimeError extends Error {
  */
 function resolveRuntime({ db, prefs, explicit }) {
   if (explicit) {
+    const api = apiRuntime(explicit, null, "explicit");
+    if (api) return api;
     const bin = RUNTIME_BIN[explicit];
     if (!bin) throw new NoRuntimeError(`unknown runtime: ${explicit}`);
-    if (!EXECUTABLE_KINDS.has(explicit)) {
+    if (!CLI_EXECUTABLE_KINDS.has(explicit)) {
       throw new NoRuntimeError(`runtime '${explicit}' has no v2 streaming driver yet (available: ${[...EXECUTABLE_KINDS].join(", ")})`);
     }
     const p = whichSync(bin);
@@ -34,18 +52,24 @@ function resolveRuntime({ db, prefs, explicit }) {
     return { kind: explicit, bin: p, source: "explicit" };
   }
   const pref = prefs && prefs.runtime;
-  if (pref && EXECUTABLE_KINDS.has(pref)) {
+  if (pref && API_EXECUTABLE_KINDS.has(pref)) {
+    return apiRuntime(pref, null, "prefs");
+  }
+  if (pref && CLI_EXECUTABLE_KINDS.has(pref)) {
     const p = whichSync(RUNTIME_BIN[pref]);
     if (p) return { kind: pref, bin: p, source: "prefs" };
   }
   if (db) {
     const active = activeRuntimeRow(db);
-    if (active && EXECUTABLE_KINDS.has(active.kind)) {
+    if (active && API_EXECUTABLE_KINDS.has(active.kind)) {
+      return apiRuntime(active.kind, active.model || undefined, "active");
+    }
+    if (active && CLI_EXECUTABLE_KINDS.has(active.kind)) {
       const p = whichSync(RUNTIME_BIN[active.kind]);
       if (p) return { kind: active.kind, bin: p, model: active.model || undefined, source: "active" };
     }
   }
-  const found = listAvailableCliRuntimes().filter((r) => EXECUTABLE_KINDS.has(r.kind));
+  const found = listAvailableCliRuntimes().filter((r) => CLI_EXECUTABLE_KINDS.has(r.kind));
   if (found.length) return { kind: found[0].kind, bin: found[0].path, source: "detected" };
   // 신규 사용자의 최빈 막다른 길: "설치하라"만 있고 방법이 없으면 여기서 이탈한다.
   // 실제 설치 명령을 그대로 준다(데스크탑 온보딩의 "Claude Code 무료로 설치하기"와 동형).
@@ -61,4 +85,10 @@ function resolveRuntime({ db, prefs, explicit }) {
   ].join("\n"));
 }
 
-module.exports = { resolveRuntime, NoRuntimeError, EXECUTABLE_KINDS };
+module.exports = {
+  resolveRuntime,
+  NoRuntimeError,
+  EXECUTABLE_KINDS,
+  CLI_EXECUTABLE_KINDS,
+  API_EXECUTABLE_KINDS,
+};

package/engine/runtimes/roles.cjs

@@ -0,0 +1,162 @@
+"use strict";
+/*
+ * Shared Desktop/Terminal model-role reader.
+ *
+ * Persistence is owned by Desktop migration v79. Terminal reads defensively:
+ *   orchestrator row -> legacy active_runtime -> null
+ *   worker direct row -> orchestrator row/legacy active_runtime
+ *
+ * The worker may inherit upward for quality; the orchestrator never falls
+ * downward to the worker row.
+ */
+const { tableExists, columnExists } = require("../core/db.cjs");
+
+const MODEL_ROLE_TABLE = "model_roles";
+const VALID_ROLES = new Set(["orchestrator", "worker"]);
+
+function cleanText(value) {
+  const trimmed = typeof value === "string" ? value.trim() : "";
+  return trimmed || null;
+}
+
+function roleRow(db, role) {
+  if (!db || !VALID_ROLES.has(role) || !tableExists(db, MODEL_ROLE_TABLE)) return null;
+  for (const column of ["role", "kind", "inherit"]) {
+    if (!columnExists(db, MODEL_ROLE_TABLE, column)) return null;
+  }
+  try {
+    return db.prepare("SELECT * FROM model_roles WHERE role=?").get(role) || null;
+  } catch {
+    return null;
+  }
+}
+
+function legacyOrchestrator(db) {
+  if (!db || !tableExists(db, "active_runtime")) return null;
+  try {
+    const row = db
+      .prepare(
+        "SELECT kind, backend, source, model, long_context FROM active_runtime WHERE id=1",
+      )
+      .get();
+    if (!row || !cleanText(row.kind)) return null;
+    let effort = null;
+    if (tableExists(db, "meta")) {
+      effort = cleanText(
+        db.prepare("SELECT value FROM meta WHERE key='claude_effort'").get()
+          ?.value,
+      );
+    }
+    return {
+      role: "orchestrator",
+      kind: cleanText(row.kind),
+      backend: cleanText(row.backend),
+      source: cleanText(row.source),
+      model: cleanText(row.model),
+      effort,
+      longContext: Boolean(row.long_context),
+      inherit: false,
+      updatedAt: null,
+      sourceLayer: "active-runtime",
+    };
+  } catch {
+    return null;
+  }
+}
+
+function normalizedRow(row, role) {
+  if (!row || !cleanText(row.kind)) return null;
+  return {
+    role,
+    kind: cleanText(row.kind),
+    backend: cleanText(row.backend),
+    source: cleanText(row.source),
+    model: cleanText(row.model),
+    effort: cleanText(row.effort),
+    longContext: Boolean(row.long_context),
+    inherit: role === "worker" && Boolean(row.inherit),
+    updatedAt: cleanText(row.updated_at),
+    sourceLayer: "model-role",
+  };
+}
+
+const MODEL_ROLE_MEMBER_TABLE = "model_role_members";
+
+/** Desktop v80 역할 풀(순서=우선순위). 테이블이 없거나 비면 []. */
+function roleMembers(db, role) {
+  if (!db || !VALID_ROLES.has(role) || !tableExists(db, MODEL_ROLE_MEMBER_TABLE)) return [];
+  for (const column of ["role", "position", "kind"]) {
+    if (!columnExists(db, MODEL_ROLE_MEMBER_TABLE, column)) return [];
+  }
+  try {
+    return db
+      .prepare("SELECT * FROM model_role_members WHERE role=? ORDER BY position ASC")
+      .all(role)
+      .map((row) => ({
+        ...normalizedRow({ ...row, inherit: 0 }, role),
+        position: row.position,
+        sourceLayer: "model-role-pool",
+      }))
+      .filter((row) => row && row.kind);
+  } catch {
+    return [];
+  }
+}
+
+/**
+ * 풀에서 첫 가용 멤버를 고른다. isAvailable(member)가 없으면 순서 1위.
+ * 전원 불가면 조용한 대체 없이 1위를 그대로 쓰고 skipped를 남긴다.
+ * worker 풀이 비면 오케스트레이터 풀을 상속하며, 풀 자체가 없으면
+ * 기존 단일 행 해석(resolvedModelRole)으로 내려간다.
+ */
+function pickRoleFromPool(db, role = "orchestrator", isAvailable = null) {
+  if (!VALID_ROLES.has(role)) throw new TypeError(`unknown model role: ${role}`);
+  const own = roleMembers(db, role);
+  const inherited = role === "worker" && own.length === 0;
+  const members = inherited ? roleMembers(db, "orchestrator") : own;
+  const skipped = [];
+  for (const member of members) {
+    if (typeof isAvailable === "function" && !isAvailable(member)) {
+      skipped.push({ position: member.position, kind: member.kind, reason: "runtime-unavailable" });
+      continue;
+    }
+    return { ...member, role, inherit: inherited, skipped };
+  }
+  if (members.length > 0) {
+    return { ...members[0], role, inherit: inherited, skipped };
+  }
+  const single = resolvedModelRole(db, role);
+  return single ? { ...single, position: null, skipped } : null;
+}
+
+function resolvedModelRole(db, role = "orchestrator") {
+  if (!VALID_ROLES.has(role)) throw new TypeError(`unknown model role: ${role}`);
+  if (role === "orchestrator") {
+    return normalizedRow(roleRow(db, "orchestrator"), role) || legacyOrchestrator(db);
+  }
+  const worker = normalizedRow(roleRow(db, "worker"), "worker");
+  if (worker && !worker.inherit) return worker;
+  const orchestrator = resolvedModelRole(db, "orchestrator");
+  if (!orchestrator) return null;
+  return {
+    ...orchestrator,
+    role: "worker",
+    inherit: true,
+    updatedAt: worker?.updatedAt || orchestrator.updatedAt,
+    sourceLayer:
+      worker?.sourceLayer === "model-role"
+        ? "model-role-inherit"
+        : "active-runtime-inherit",
+  };
+}
+
+module.exports = {
+  MODEL_ROLE_TABLE,
+  MODEL_ROLE_MEMBER_TABLE,
+  VALID_ROLES,
+  roleRow,
+  roleMembers,
+  pickRoleFromPool,
+  legacyOrchestrator,
+  resolvedModelRole,
+};

package/engine/sessions/orchestrator.cjs

@@ -43,7 +43,7 @@ class Orchestrator extends EventEmitter {
    * 세션 생성(+선택적 즉시 실행). parentKey를 주면 그 세션의 서브에이전트
    * (division 챗)로 붙는다.
    */
-  spawn({ agent, runtime, permission, cwd, title, parentKey, activate = true, spawnImpl, timeoutConfig, chatId }) {
+  spawn({ agent, runtime, permission, cwd, title, parentKey, activate = true, spawnImpl, apiTurnImpl, timeoutConfig, chatId }) {
     const parent = parentKey ? this.sessions.get(parentKey) || null : null;
     const session = new Session({
       db: this.db,
@@ -55,6 +55,7 @@ class Orchestrator extends EventEmitter {
       parent,
       title,
       spawnImpl,
+      apiTurnImpl,
       timeoutConfig,
       chatId,
     });

package/engine/sessions/session.cjs

@@ -21,7 +21,7 @@ const RING_LIMIT = 2000;
 class Session extends EventEmitter {
   /**
    * @param {object} opts
-   *   db, agent {id,slug,name,systemPrompt}, runtime {kind,bin,model?},
+   *   db, agent {id,slug,name,systemPrompt}, runtime {kind,bin,model?,effort?},
    *   permission, cwd, lang, parent (Session|null), title, chatId?(재개)
    */
   constructor(opts) {
@@ -46,7 +46,9 @@ class Session extends EventEmitter {
     this._turnPromise = null;
     // 계약 테스트용 spawn 주입(runNativeTurn의 req.spawn). 프로덕션 경로에선 null.
     this._spawnImpl = opts.spawnImpl || null;
+    this._apiTurnImpl = opts.apiTurnImpl || null;
     this._timeoutConfig = opts.timeoutConfig || null;
+    this._apiAbort = null;
 
     this.chatId = opts.chatId || store.createChat(this.db, {
       agentId: this.agent.id,
@@ -154,26 +156,55 @@ class Session extends EventEmitter {
       }, true, prompt);
     } catch { /* 프롬프트 증강 실패는 턴을 막지 않는다 — 원 프롬프트로 진행 */ }
 
-    const req = {
-      kind: this.runtime.kind,
-      bin: this.runtime.bin,
-      ui: this._sink,
-      cwd: this.cwd,
-      prompt,
-      systemPrompt,
-      permission: this.permission,
-      session: { ...this.runtimeSession },
-      model: this.runtime.model,
-      onSpawn: (child) => { this._child = child; },
-    };
-    if (this._spawnImpl) req.spawn = this._spawnImpl;
-    if (this._timeoutConfig) req.timeoutConfig = this._timeoutConfig;
-
     let res;
-    try {
-      res = await nativeHost.runNativeTurn(req);
-    } catch (e) {
-      res = { text: "", session: req.session, error: (e && e.message) || String(e) };
+    if (this.runtime.kind === "ollama") {
+      const ctrl = new AbortController();
+      this._apiAbort = ctrl;
+      const apiTurn = this._apiTurnImpl || require("../agentlas-api-agent.cjs").runApiTurn;
+      try {
+        const history = store.chatHistory(this.db, this.chatId).map((row) => ({
+          role: row.role,
+          content: row.text,
+        }));
+        res = await apiTurn({
+          backend: "ollama",
+          model: this.runtime.model || "llama3.1",
+          system: systemPrompt,
+          messages: history,
+          ctx: {
+            cwd: this.cwd,
+            permission: this.permission,
+            env: process.env,
+          },
+          ui: this._sink,
+          signal: ctrl.signal,
+        });
+      } catch (e) {
+        res = { text: "", error: (e && e.message) || String(e) };
+      } finally {
+        this._apiAbort = null;
+      }
+    } else {
+      const req = {
+        kind: this.runtime.kind,
+        bin: this.runtime.bin,
+        ui: this._sink,
+        cwd: this.cwd,
+        prompt,
+        systemPrompt,
+        permission: this.permission,
+        session: { ...this.runtimeSession },
+        model: this.runtime.model,
+        effort: this.runtime.effort,
+        onSpawn: (child) => { this._child = child; },
+      };
+      if (this._spawnImpl) req.spawn = this._spawnImpl;
+      if (this._timeoutConfig) req.timeoutConfig = this._timeoutConfig;
+      try {
+        res = await nativeHost.runNativeTurn(req);
+      } catch (e) {
+        res = { text: "", session: req.session, error: (e && e.message) || String(e) };
+      }
     }
     this._child = null;
 
@@ -233,6 +264,11 @@ class Session extends EventEmitter {
   /** 실행 중 턴을 중단한다. 큐는 비운다. */
   kill() {
     this.queue.length = 0;
+    if (this._apiAbort) {
+      this.status = "killed";
+      try { this._apiAbort.abort(new Error("session killed")); } catch { /* already aborted */ }
+      return;
+    }
     if (this._child) {
       this.status = "killed";
       try { nativeHost.terminateNativeChild(this._child); } catch { /* already dead */ }

package/engine/storm/swarm.cjs

@@ -191,7 +191,7 @@ function create(deps) {
       return typeof text === "string" ? text : (text && text.text) || "";
     }
 
-    function recordAllocation(task, stage, decision, resolution, parentTaskId = null) {
+    function recordAllocation(task, stage, decision, resolution, parentTaskId = null, usage = null) {
       const receipt = workloadRouting.createDecisionReceipt({
         taskId: `${stage}-${task.id || "synthesis"}`,
         parentTaskId,
@@ -199,6 +199,7 @@ function create(deps) {
         stage,
         decision,
         resolution,
+        usage,
       });
       try {
         workloadRouting.appendDecisionReceipt(
@@ -221,9 +222,9 @@ function create(deps) {
         availableModels: ctx.availableModels,
         maxTier: ctx.maxTier || process.env.AGENTLAS_MODEL_MAX_TIER,
       });
-      recordAllocation(task, stage, task.allocation, resolution, parentTaskId);
       // 할당 거부 후 CLI 기본 모델로 조용히 실행 금지 — fail-closed (계약 테스트 고정).
       if (!resolution.ok) {
+        recordAllocation(task, stage, task.allocation, resolution, parentTaskId);
         throw new Error(`model allocation failed closed: ${resolution.fallbackReason || "no compliant live model"}`);
       }
       if (resolution.fallbackReason) {
@@ -238,17 +239,32 @@ function create(deps) {
         source: resolution.source,
         fallbackReason: resolution.fallbackReason || null,
       };
-      if (selectedRuntime.mode === "cli") {
-        return await D.captureRuntime(selectedRuntime.kind, system, prompt, {
-          cwd,
-          env,
-          permission,
-          model: resolution.model,
-          effort: resolution.effort,
-        });
+      let observed;
+      try {
+        observed = selectedRuntime.mode === "cli"
+          ? await D.captureRuntime(selectedRuntime.kind, system, prompt, {
+            cwd,
+            env,
+            permission,
+            model: resolution.model,
+            effort: resolution.effort,
+            envelope: true,
+          })
+          : await D.runApi(
+            selectedRuntime.backend,
+            resolution.model || selectedRuntime.model,
+            system,
+            prompt,
+            { envelope: true },
+          );
+      } catch (error) {
+        recordAllocation(task, stage, task.allocation, resolution, parentTaskId);
+        throw error;
       }
-      const text = await D.runApi(selectedRuntime.backend, resolution.model || selectedRuntime.model, system, prompt);
-      return typeof text === "string" ? text : (text && text.text) || "";
+      const text = typeof observed === "string" ? observed : (observed && observed.text) || "";
+      const usage = observed && typeof observed === "object" ? observed.usage : null;
+      recordAllocation(task, stage, task.allocation, resolution, parentTaskId, usage);
+      return text;
     }
 
     const label = runtime.mode === "cli" ? runtime.kind : runtime.backend;

package/engine/ui/palette.cjs

@@ -29,6 +29,8 @@ const SLASH_COMMANDS = [
   { command: "/mcp", args: "", ko: "MCP 서버 목록", en: "MCP servers" },
   { command: "/doctor", args: "", ko: "런타임·데이터 점검", en: "Health check" },
   { command: "/runtime", args: "<kind>", ko: "새 세션 런타임 지정", en: "Set runtime for new sessions" },
+  { command: "/model", args: "<id|default>", ko: "새 세션 모델 지정", en: "Set model for new sessions" },
+  { command: "/effort", args: "<level|none>", ko: "새 세션 추론 강도 지정", en: "Set effort for new sessions" },
   { command: "/permission", args: "<level>", ko: "새 세션 권한 지정", en: "Set permission for new sessions" },
   { command: "/login", args: "", ko: "Agentlas Cloud 로그인", en: "Sign in to Agentlas Cloud" },
   { command: "/whoami", args: "", ko: "로그인 상태", en: "Signed-in account" },
@@ -40,12 +42,49 @@ const SLASH_COMMANDS = [
   { command: "/storm", args: "<goal>", ko: "Goal+UltraCode 하니스", en: "Goal+UltraCode harness" },
   { command: "/swarm", args: "<goal>", ko: "에이전트 스웜", en: "Agent swarm" },
   { command: "/network", args: "<request>", ko: "Workforce 라우트", en: "Workforce route" },
+  { command: "/workforce", args: "<request>", ko: "Workforce 라우트", en: "Workforce route" },
+  { command: "/taskforce", args: "<request>", ko: "임시 태스크포스 편성", en: "Assemble a task force" },
+  { command: "/build", args: "\"<request>\"", ko: "에이전트·팀 제작/수리/패키징", en: "Build, repair or package an agent or team" },
+  { command: "/call", args: "\"a,b\" \"<ctx>\"", ko: "지정 에이전트 호출", en: "Call named agents" },
+  { command: "/route", args: "\"<req>\"", ko: "최적 에이전트 라우팅", en: "Route to the best agent" },
+  { command: "/browser", args: "[sub]", ko: "브라우저 하드포인트", en: "Browser hardpoint" },
+  { command: "/connect", args: "<target>", ko: "에이전트·팀 연결", en: "Connect an agent or team" },
+  { command: "/research", args: "<sub>", ko: "리서치", en: "Research" },
+  { command: "/upload", args: "<path>", ko: "Agent Cloud에 저장·발행", en: "Save to Agent Cloud or publish" },
+  { command: "/cloud", args: "<sub>", ko: "클라우드 자산 관리", en: "Cloud assets" },
+  { command: "/import", args: "<path>", ko: "로컬 폴더 에이전트 가져오기", en: "Import a local folder agent" },
+  { command: "/cd", args: "[path]", ko: "작업 폴더 이동", en: "Change working folder" },
+  { command: "/native", args: "prepare <agent>", ko: "네이티브 CLI 컨텍스트 생성", en: "Prepare native CLI context" },
+  { command: "/plugin", args: "<sub>", ko: "Hub 플러그인(MCP)", en: "Hub plugins (MCP servers)" },
+  { command: "/plugins", args: "", ko: "설치된 플러그인", en: "Installed plugins" },
+  { command: "/experience", args: "<sub>", ko: "이식 가능한 Experience", en: "Portable Experience" },
+  { command: "/variant", args: "resolve", ko: "로컬 변형 선택", en: "Local variant selection" },
+  { command: "/memory", args: "<sub>", ko: "메모리", en: "Memory" },
+  { command: "/evolve", args: "", ko: "프롬프트 진화 제안", en: "Prompt-evolution proposals" },
+  { command: "/ontology", args: "", ko: "프로젝트 지식", en: "Project knowledge" },
+  { command: "/career-graph", args: "", ko: "소스 라우팅 그래프", en: "Source routing graph" },
+  { command: "/journal", args: "<sub>", ko: "Stormbreaker 실행 일지", en: "Stormbreaker run journal" },
+  { command: "/project", args: "[status|init]", ko: ".agentlas 프로젝트 상태", en: "Private project state" },
+  { command: "/context", args: "<sub>", ko: "의존성 맵", en: "Dependency map" },
+  { command: "/creds", args: "<sub>", ko: "자격증명", en: "Credentials" },
+  { command: "/env", args: "", ko: "공유 환경 키", en: "Shared env keys" },
+  { command: "/multimodal", args: "", ko: "이미지·영상·음성 설정", en: "Image/video/audio providers" },
+  { command: "/telegram", args: "[sub]", ko: "텔레그램 연결", en: "Telegram bindings" },
+  { command: "/oberon", args: "[sub]", ko: "AI 필름", en: "AI film" },
+  { command: "/film", args: "<sub>", ko: "필름 렌더", en: "Film render" },
+  { command: "/hep", args: "<sub…>", ko: "Hephaestus 패스스루", en: "Hephaestus passthrough" },
+  { command: "/netadmin", args: "[sub]", ko: "로컬 네트워크 관리", en: "Local network admin" },
+  { command: "/update", args: "", ko: "npm 업데이트 확인", en: "npm update check" },
+  { command: "/version", args: "", ko: "버전", en: "Version" },
+  { command: "/logout", args: "", ko: "로그아웃", en: "Sign out" },
+  { command: "/uninstall", args: "<slug>", ko: "에이전트 제거", en: "Uninstall an agent" },
   { command: "/quit", args: "", ko: "종료", en: "Quit" },
   { command: "/exit", args: "", ko: "종료", en: "Quit" },
 ];
 
 const SLASH_NAMES = SLASH_COMMANDS.map((c) => c.command);
 const RUNTIME_KINDS = ["claude-code", "codex", "gemini"];
+const EFFORT_LEVELS = ["none", "minimal", "low", "medium", "high", "xhigh", "max"];
 const PERM_LEVELS = ["read", "write", "full"];
 // 세션 인자를 받는 명령 — 완성 후보를 살아있는 세션 키(s1, s2…)로 채운다.
 const SESSION_ARG_COMMANDS = new Set(["/s", "/switch", "/steer", "/kill", "/rm"]);
@@ -83,6 +122,7 @@ function makeCompleter(ctx = {}) {
 
     const cmd = tokens[0];
     if (cmd === "/runtime") return [uniqStartsWith(RUNTIME_KINDS, last), last];
+    if (cmd === "/effort") return [uniqStartsWith(EFFORT_LEVELS, last), last];
     if (cmd === "/permission") return [uniqStartsWith(PERM_LEVELS, last), last];
     if (SESSION_ARG_COMMANDS.has(cmd) && tokens.length === 2) return [uniqStartsWith(getSessions(), last), last];
     if (AGENT_ARG_COMMANDS.has(cmd) && tokens.length === 2) {