agentlas 1.0.11 → 1.0.14

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;
@@ -411,6 +427,18 @@ function create(deps) {
       if (args[i] === "--parallel" || args[i] === "-n") concurrency = Number(args[++i]);
       else rest.push(args[i]);
     }
+    // storm.cjs stormRun 의 leading-dash 가드와 동일 계약. 여기서 안 막으면 미지원·
+    // 오타 플래그(--permission, --model …)가 rest 에 남아 rest.join(" ") 로 목표가
+    // 되어버린다: 유료 플래너가 플래그 텍스트를 목표로 실제 실행되고, 플래그가
+    // 의도한 동작(예: 권한 상승)은 조용히 일어나지 않는다. 목표는 프롬프트까지
+    // 오염된다. 그래서 소비되지 않은 대시 토큰은 실행 전에 fail-closed 로 거절한다.
+    const strayFlag = rest.find((token) => String(token).startsWith("-"));
+    if (strayFlag) {
+      const ui = executionContext.ui || newUi();
+      ui.error(`unknown option ${strayFlag} — swarm accepts: --parallel N | -n N, --runtime <kind>`);
+      process.exitCode = 1;
+      return { ok: false, error: "unknown-option" };
+    }
     const r = await swarmRun(db, rest.join(" "), { ...executionContext, concurrency, runtimeOverride });
     if (!r.ok) process.exitCode = 1;
     return r;

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,61 @@ 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" },
+  // 소스 스코프가 이름에 붙은 스태핑 3종. 스코프를 문장에 적는다 — 예전에는
+  // 별칭이 스코프를 버려 /hep-cloud 가 자산 보관함으로, /hep-hub 가 검색으로
+  // 갔다(2026-07-28 수리). 팔레트 문구가 곧 사용자에게 하는 약속이다.
+  { command: "/hep-network", args: "\"<request>\"", ko: "로컬+오너 클라우드+공개 Hub 연합 편성", en: "Staff across Local + owner Cloud + public Hub" },
+  { command: "/hep-local", args: "\"<request>\"", ko: "등록된 로컬 에이전트만으로 편성", en: "Staff from registered Local agents only" },
+  { command: "/hep-cloud", args: "\"<request>\"", ko: "오너 Agent Cloud만으로 편성", en: "Staff from owner Agent Cloud only" },
+  { command: "/hep-hub", args: "\"<request>\"", ko: "공개 Hub 에이전트만으로 편성", en: "Staff from public Hub agents only" },
+  { 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" },
+  // 데스크탑의 `ontology` 는 Core 의 지식·메모리 **런타임**(임베딩 포함)이고, 터미널의
+  // 이것은 **이 프로젝트의 지식 소스 등록부**다. 서로 다른 것이 같은 이름을 쓰고 있어
+  // (감사 D6) 라벨이라도 정확해야 한다 — 명령 이름은 사용자 습관과 스크립트가 걸려
+  // 있어 바꾸지 않는다. Core 의 지식 런타임은 터미널에 아직 미노출이다(결함 아님).
+  { command: "/ontology", args: "", ko: "프로젝트 지식 소스 등록", en: "Project knowledge sources" },
+  { 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" },
+  // 대화가 있으면 --yes 없이는 거절한다(챗/메시지 CASCADE 삭제) — 팔레트에도 노출.
+  { command: "/uninstall", args: "<slug> [--yes]", 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 +134,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) {

package/engine/ui/renderer.cjs

@@ -77,6 +77,43 @@ class Renderer {
       case "task-result": ui.applyTaskResult(ev.name, ev.result, ev.id); return;
       case "cost": ui.cost(ev.usage); return;
       case "queued": ui.line(ui.c.dim(`  ↳ queued for next turn: ${ev.text}`)); return;
+
+      /* ── 펜스 영수증 (apply-fences.cjs) ──────────────────────────────────
+       * WHY: 펜스 블록은 cleanText 에서 통째로 제거되므로, 이 case 들이 없으면
+       * default 로 떨어져 화면에 아무 흔적도 남지 않는다. 그 결과 이미 enabled
+       * 상태로 등록된 반복 자동화(데몬/데스크탑 스케줄러가 실제로 실행한다)나
+       * 스폰된 위임 세션이 사용자 모르게 생기고, 에이전트의 확인 질문(ask)은
+       * 본문에서 삭제된 채 영영 묻지 않는다. 부작용에는 반드시 영수증이 따른다 —
+       * 새 펜스 이벤트를 apply-fences 에 추가하면 여기에도 case 를 추가할 것. */
+      case "ask": {
+        const p = ev.payload || {};
+        ui.ensureNl();
+        if (p.header) ui.line(ui.c.dim(`  ${p.header}`));
+        ui.warn(p.question || "(question)");
+        (p.options || []).forEach((o, i) => {
+          const desc = o && o.description ? ` — ${o.description}` : "";
+          ui.line(ui.c.dim(`    ${i + 1}. ${(o && o.label) || ""}${desc}`));
+        });
+        ui.line(ui.c.dim(`    ↳ 답을 그대로 입력하세요${p.multiSelect ? " (복수 선택 가능)" : ""}`));
+        return;
+      }
+      case "automation-registered": {
+        const steps = ev.stepsIgnored ? ` · steps ${ev.stepsIgnored}개 무시(터미널은 그래프 합성 없음)` : "";
+        ui.ok(`automation registered: ${ev.name} · ${ev.schedule} · next ${ev.nextRunAt}${steps}`);
+        // 취소 경로를 함께 제시한다. 실제 서브커맨드는 off (commands/automation.cjs:125).
+        ui.line(ui.c.dim(`    ↳ agentlas automation list  ·  agentlas automation off ${String(ev.id || "").slice(0, 8)}`));
+        return;
+      }
+      case "automation-refused": ui.warn(`automation refused: ${ev.name} — ${ev.reason}`); return;
+      case "delegate-spawned":
+        ui.ok(`delegate spawned: ${ev.target} → ${ev.key}`);
+        return;
+      case "delegate-refused": ui.warn(`delegate refused: ${ev.target} — ${ev.reason}`); return;
+      case "fence-error": ui.error(`fence: ${ev.text}`); return;
+      case "memory-curated":
+        ui.line(ui.c.dim(`  ↳ memory: ${ev.written}/${ev.candidates} written (permission: ${ev.permission})`));
+        return;
+
       default: return;
     }
   }

package/engine/ui/repl.cjs

@@ -20,7 +20,8 @@ const { renderBanner, readVersion } = require("../agentlas-banner.cjs");
 const { Orchestrator, maxParallel } = require("../sessions/orchestrator.cjs");
 const { Renderer } = require("./renderer.cjs");
 const { findAgent, listAgents } = require("../agents/registry.cjs");
-const { resolveRuntime, NoRuntimeError } = require("../runtimes/resolve.cjs");
+const { resolveRuntimeForAgent } = require("../runtimes/overrides.cjs");
+const { EFFORTS } = require("../agentlas-workload-routing.cjs");
 const permissions = require("../agentlas-permissions.cjs");
 const i18n = require("../agentlas-i18n.cjs");
 const { tokenizeCommandLine } = require("../agentlas-input.cjs");
@@ -133,8 +134,18 @@ async function startRepl(ctx, opts = {}) {
   const renderer = new Renderer(ui);
   let permission = permissions.normalize(opts.permission || (ctx.prefs && ctx.prefs.permission) || "write");
   let runtimeOverride = opts.runtime || null;
-
-  const resolveRt = () => resolveRuntime({ db, prefs: ctx.prefs, explicit: runtimeOverride });
+  let modelOverride = opts.model || null;
+  let effortOverride = opts.effort || null;
+
+  const resolveRt = (agentId = null) => resolveRuntimeForAgent({
+    db,
+    prefs: ctx.prefs,
+    explicit: runtimeOverride,
+    model: modelOverride,
+    effort: effortOverride,
+    role: "orchestrator",
+    agentId,
+  });
 
   let resumeChatId = opts.chatId || null;
   const ensureMainSession = (agentToken) => {
@@ -146,7 +157,14 @@ async function startRepl(ctx, opts = {}) {
     }
     const active = orch.active();
     if (active && active.agent.id === agent.id) return active;
-    const session = orch.spawn({ agent, runtime: resolveRt(), permission, cwd: process.cwd(), activate: true, chatId: resumeChatId });
+    const session = orch.spawn({
+      agent,
+      runtime: resolveRt(agent.id),
+      permission,
+      cwd: process.cwd(),
+      activate: true,
+      chatId: resumeChatId,
+    });
     resumeChatId = null; // 재개는 첫 세션에만 적용
     renderer.attach(session, { replay: false });
     return session;
@@ -318,7 +336,18 @@ async function startRepl(ctx, opts = {}) {
 
       if (input.startsWith("/")) {
         try {
-          const quit = handleSlash(ctx, input.slice(1), { orch, renderer, ensureMainSession, resolveRt, track: trackCommand, setPermission: (p) => { permission = p; }, getPermission: () => permission, setRuntime: (r) => { runtimeOverride = r; } });
+          const quit = handleSlash(ctx, input.slice(1), {
+            orch,
+            renderer,
+            ensureMainSession,
+            resolveRt,
+            track: trackCommand,
+            setPermission: (p) => { permission = p; },
+            getPermission: () => permission,
+            setRuntime: (r) => { runtimeOverride = r; },
+            setModel: (model) => { modelOverride = model; },
+            setEffort: (effort) => { effortOverride = effort; },
+          });
           if (quit === "quit") { rl.close(); return; }
         } catch (e) {
           ui.error(String((e && e.message) || e));
@@ -482,6 +511,18 @@ function printSessions(ctx, orch) {
   }
 }
 
+/*
+ * 세션 키 파싱. 인자가 없으면 사용법을 낸다 — 예전에는 `s${undefined}` 가 그대로
+ * 조립돼 `/kill` 이 "no such session: sundefined" 를, `/steer` 는 rest[0].length 에서
+ * 날 TypeError 를 냈다. 팔레트가 `/steer <n> <msg>` 라고 안내하므로 인자 없이 Enter 를
+ * 눌러 사용법을 보려는 것은 정상적인 탐색이다.
+ */
+function sessionKeyArg(rest, usage) {
+  const token = rest[0];
+  if (!token) throw new Error(usage);
+  return String(token).startsWith("s") ? token : `s${token}`;
+}
+
 function handleSlash(ctx, cmdline, api) {
   const en = ctx.lang === "en";
   const ui = ctx.uiInstance;
@@ -524,7 +565,7 @@ function handleSlash(ctx, cmdline, api) {
     case "sessions": case "tree": printSessions(ctx, orch); return;
 
     case "s": case "switch": {
-      const key = rest[0] && rest[0].startsWith("s") ? rest[0] : `s${rest[0]}`;
+      const key = sessionKeyArg(rest, `Usage: /${cmd} <n>`);
       const session = orch.setActive(key);
       renderer.attach(session, { replay: true });
       return;
@@ -552,7 +593,7 @@ function handleSlash(ctx, cmdline, api) {
     }
 
     case "steer": {
-      const key = rest[0] && rest[0].startsWith("s") ? rest[0] : `s${rest[0]}`;
+      const key = sessionKeyArg(rest, `Usage: /${cmd} <n> <message>`);
       const msg = restStr.slice(rest[0].length).trim();
       if (!msg) throw new Error("Usage: /steer <n> <message>");
       orch.sendTo(key, msg);
@@ -561,12 +602,12 @@ function handleSlash(ctx, cmdline, api) {
     }
 
     case "kill": {
-      const key = rest[0] && rest[0].startsWith("s") ? rest[0] : `s${rest[0]}`;
+      const key = sessionKeyArg(rest, `Usage: /${cmd} <n>`);
       orch.kill(key);
       return;
     }
     case "rm": {
-      const key = rest[0] && rest[0].startsWith("s") ? rest[0] : `s${rest[0]}`;
+      const key = sessionKeyArg(rest, `Usage: /${cmd} <n>`);
       orch.remove(key);
       const active = orch.active();
       if (active) renderer.attach(active, { replay: false });
@@ -575,8 +616,14 @@ function handleSlash(ctx, cmdline, api) {
 
     case "broadcast": {
       if (!restStr) throw new Error("Usage: /broadcast <message>");
-      const sent = orch.broadcast(restStr);
+      /*
+       * broadcast 는 {sent, skipped} 를 준다. 전달된 목록을 먼저 찍고 못 보낸 세션은
+       * 사유와 함께 경고로 덧붙인다 — 예전엔 상한 throw 가 이 catch 로 떨어져 에러 한
+       * 줄만 보였고, 이미 지시를 받아 돌기 시작한 세션이 화면에 전혀 안 나왔다.
+       */
+      const { sent, skipped } = orch.broadcast(restStr);
       ctx.out(ui.c.dim(`→ ${sent.join(", ") || "(none)"}`));
+      for (const s of skipped) ui.warn(`${s.key} ${en ? "not sent" : "미전송"}: ${s.error}`);
       return;
     }
 
@@ -594,6 +641,27 @@ function handleSlash(ctx, cmdline, api) {
       ctx.out(ui.c.dim(`runtime: ${rest[0]} (${en ? "applies to new sessions" : "새 세션부터 적용"})`));
       return;
     }
+    case "model": {
+      const model = String(rest[0] || "").trim();
+      if (!model) throw new Error("Usage: /model <provider-model-id|default>");
+      const next = ["default", "inherit"].includes(model.toLowerCase()) ? null : model;
+      api.setModel(next);
+      ctx.out(ui.c.dim(
+        `model: ${next || "default"} (${en ? "applies to new sessions" : "새 세션부터 적용"})`,
+      ));
+      return;
+    }
+    case "effort": {
+      const effort = String(rest[0] || "").trim().toLowerCase();
+      if (!EFFORTS.includes(effort)) {
+        throw new Error(`Usage: /effort ${EFFORTS.join("|")}`);
+      }
+      api.setEffort(effort === "none" ? null : effort);
+      ctx.out(ui.c.dim(
+        `effort: ${effort} (${en ? "applies to new sessions" : "새 세션부터 적용"})`,
+      ));
+      return;
+    }
     case "permission": {
       if (!["read", "write", "full"].includes(String(rest[0] || ""))) {
         throw new Error("Usage: /permission read|write|full");