agentlas 1.0.11 → 1.0.14

package/engine/workforce/capture.cjs

@@ -89,7 +89,48 @@ function buildArgs(kind, systemPrompt, prompt, permission, runtimeOptions = {})
   const model = runtimeOptions.model ? String(runtimeOptions.model) : null;
   const effort = runtimeOptions.effort ? String(runtimeOptions.effort) : null;
   const noAuthority = runtimeOptions.authorityMode === "no-authority";
+  // read-only 권한: 워크포스가 tool:file-read 능력만 부여했을 때. plan 모드(쓰기 불가)에
+  // 정확-도구 allowlist를 겹쳐 읽기 3종으로 고정한다. 이것이 "증명 가능한 경계"의 실체다 —
+  // 예전에는 이 모드가 없어서 도구를 주면 곧바로 acceptEdits(쓰기)+기본 도구 전체가 됐고,
+  // 그래서 권한 부여 자체를 항상 거부할 수밖에 없었다(2026-07-27 코드 감사 불가의 근본).
+  const readOnlyAuthority = runtimeOptions.authorityMode === "read-only";
+  const readOnlyTools = Array.isArray(runtimeOptions.allowedNativeTools) && runtimeOptions.allowedNativeTools.length
+    ? [...new Set(runtimeOptions.allowedNativeTools.map((t) => String(t)))].sort()
+    : [];
+  if (readOnlyAuthority && !readOnlyTools.length) {
+    throw new Error("read-only capture requires an explicit native tool allowlist");
+  }
+  // read-only 분기를 가진 런타임은 claude-code뿐이다. 다른 kind로 들어오면 아래에서
+  // 일반 권한 분기로 떨어져 조용히 쓰기/셸까지 열린다 — 권한 승격이므로 정직 정지.
+  // (역할별 모델 배정으로 워커가 codex/gemini에서 돌 수 있게 되며 실재 경로가 됐다.)
+  if (readOnlyAuthority && kind !== "claude-code") {
+    throw new Error(`read-only capture is not provable on ${kind}`);
+  }
   if (kind === "claude-code") {
+    if (readOnlyAuthority) {
+      const thinkingRo = effort === "max" || effort === "xhigh" ? "Ultrathink. " : effort === "high" ? "Think hard. " : effort === "medium" ? "Think. " : "";
+      const claudeEffortRo = effort === "minimal" ? "low" : effort === "xhigh" ? "max" : effort;
+      return [
+        "-p", thinkingRo + prompt,
+        "--append-system-prompt", systemPrompt,
+        ...(model ? ["--model", model] : []),
+        ...(claudeEffortRo && claudeEffortRo !== "none" ? ["--effort", claudeEffortRo] : []),
+        // 도구를 쓰는 워커는 최종 답까지 stdout에 한 글자도 내지 않는다 — 무도구
+        // 워커에는 없던 문제다. 유휴 타이머는 그 침묵을 "죽었다"로 읽고 10분에
+        // 처형한다(2026-07-27 라이브 실측 AGENTLAS_CAPTURE_IDLE_TIMEOUT). 이벤트
+        // 스트림으로 받아 도구 호출마다 진행 신호가 흐르게 하면 유휴 판정이 비로소
+        // 진짜 정지 신호가 된다. 최종 텍스트는 capturedRuntimeAgentText가 result
+        // 이벤트에서 뽑는다(이미 이 프로토콜을 파싱한다). 부분 토큰 델타는 켜지
+        // 않는다 — 진행 신호는 도구 호출 단위로 충분하고 출력량이 폭증한다.
+        "--output-format", "stream-json",
+        "--verbose",
+        // plan 모드는 쓰기/실행을 거부한다. allowedTools로 읽기 3종만 남긴다.
+        "--permission-mode", "plan",
+        "--allowedTools", readOnlyTools.join(","),
+        "--disallowedTools", "Write,Edit,MultiEdit,NotebookEdit,Bash,BashOutput,KillShell,WebFetch,WebSearch,Task",
+        ...native.claudeMcpIsolationArgs(),
+      ];
+    }
     const perm = native.claudePermissionArgs(noAuthority ? "read" : level);
     // 백그라운드/캡처 경로에는 검토된 MCP 서버 목록이 없다. full 권한은 툴 권한이지
     // MCP 동의가 아니므로 이 경로는 항상 정확-공백 MCP 격리를 유지한다.
@@ -102,6 +143,16 @@ function buildArgs(kind, systemPrompt, prompt, permission, runtimeOptions = {})
       "--append-system-prompt", systemPrompt,
       ...(model ? ["--model", model] : []),
       ...effortArgs,
+      // 이 분기도 read-only 분기와 같은 이유로 이벤트 스트림이 필요하다. 위 주석은
+      // 침묵 문제를 "도구를 쓰는 워커"의 것으로 한정했지만, 그건 도구 유무가 아니라
+      // "최종 답 전에는 stdout에 아무것도 없다"는 성질이고 이 분기도 똑같다.
+      // effort가 높으면 "Ultrathink."가 앞에 붙어 사고만 10분을 넘길 수 있고,
+      // 유휴 타이머는 그 침묵을 죽음으로 읽는다 — 2026-07-28 라이브에서 무도구
+      // 워커 3개가 전부 600초 유휴로 처형됐다. 진행 신호가 흐르는 채널로 재야
+      // 유휴 판정이 실제 정지를 뜻한다. 최종 텍스트는
+      // capturedRuntimeAgentText가 result 이벤트에서 그대로 뽑는다.
+      "--output-format", "stream-json",
+      "--verbose",
       ...perm,
       ...(noAuthority ? ["--tools", ""] : []),
       ...mcp,
@@ -166,6 +217,98 @@ function codexCaptureAgentText(jsonl) {
   return [...latest.values()].join("");
 }
 
+function nonNegativeTokenCount(value) {
+  return Number.isInteger(value) && value >= 0 ? value : null;
+}
+
+function usageFromObject(value, inputKeys, outputKeys, inputAdditiveKeys = []) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return null;
+  const firstCount = (keys) => {
+    for (const key of keys) {
+      const count = nonNegativeTokenCount(value[key]);
+      if (count != null) return count;
+    }
+    return null;
+  };
+  let inputTokens = firstCount(inputKeys);
+  const outputTokens = firstCount(outputKeys);
+  if (inputTokens != null) {
+    for (const key of inputAdditiveKeys) {
+      const count = nonNegativeTokenCount(value[key]);
+      if (count != null) inputTokens += count;
+    }
+  }
+  // Do not manufacture a zero for providers that expose only one side.
+  return inputTokens == null || outputTokens == null
+    ? null
+    : { inputTokens, outputTokens };
+}
+
+function capturedRuntimeUsage(kind, raw) {
+  const events = [];
+  for (const line of String(raw || "").split(/\r?\n/)) {
+    if (!line.trim()) continue;
+    try {
+      events.push(JSON.parse(line));
+    } catch {
+      return null;
+    }
+  }
+  const genericUsage = (value) =>
+    usageFromObject(
+      value,
+      ["inputTokens", "input_tokens", "promptTokens", "prompt_tokens", "promptTokenCount"],
+      ["outputTokens", "output_tokens", "completionTokens", "completion_tokens", "candidatesTokenCount"],
+    );
+  for (const event of [...events].reverse()) {
+    if (kind === "claude-code") {
+      const claudeUsage = usageFromObject(
+        event?.usage,
+        ["input_tokens"],
+        ["output_tokens"],
+        ["cache_creation_input_tokens", "cache_read_input_tokens"],
+      );
+      if (claudeUsage) return claudeUsage;
+      const modelUsage = event?.modelUsage;
+      if (modelUsage && typeof modelUsage === "object" && !Array.isArray(modelUsage)) {
+        let inputTokens = 0;
+        let outputTokens = 0;
+        let observed = false;
+        for (const row of Object.values(modelUsage)) {
+          const usage = genericUsage(row);
+          if (!usage) continue;
+          inputTokens += usage.inputTokens;
+          outputTokens += usage.outputTokens;
+          observed = true;
+        }
+        if (observed) return { inputTokens, outputTokens };
+      }
+    }
+    const direct =
+      genericUsage(event?.usage) ||
+      genericUsage(event?.usageMetadata) ||
+      genericUsage(event?.stats);
+    if (direct) return direct;
+    if (kind === "gemini") {
+      const models = event?.stats?.models;
+      if (models && typeof models === "object" && !Array.isArray(models)) {
+        let inputTokens = 0;
+        let outputTokens = 0;
+        let observed = false;
+        for (const row of Object.values(models)) {
+          const usage = genericUsage(row);
+          if (!usage) continue;
+          inputTokens += usage.inputTokens;
+          outputTokens += usage.outputTokens;
+          observed = true;
+        }
+        if (observed) return { inputTokens, outputTokens };
+      }
+    }
+  }
+  return null;
+}
+
 function capturedRuntimeAgentText(kind, raw) {
   const text = String(raw || "");
   const events = [];
@@ -219,7 +362,9 @@ function capturedRuntimeAgentText(kind, raw) {
 /**
  * 네이티브 CLI 헤드리스 1턴 캡처 — 최종 텍스트를 resolve한다.
  * opts: { cwd, env, permission, model, effort, authorityMode, noToolsPolicyPath,
- *         timeoutConfig, outputLimitBytes, signal, spawn(테스트 주입) }
+ *         envelope, timeoutConfig, outputLimitBytes, signal, spawn(테스트 주입) }
+ * envelope=true면 { text, usage }를 반환한다. usage는 양쪽 토큰을 실제로 관측한
+ * 경우만 채우고, 불완전한 provider 이벤트를 0으로 위조하지 않는다.
  */
 function captureRuntime(kind, systemPrompt, prompt, opts) {
   opts = opts || {};
@@ -247,6 +392,7 @@ function captureRuntime(kind, systemPrompt, prompt, opts) {
         effort: opts.effort,
         authorityMode: opts.authorityMode,
         noToolsPolicyPath: opts.noToolsPolicyPath,
+        allowedNativeTools: opts.allowedNativeTools,
       }), {
         cwd,
         stdio: ["ignore", "pipe", "pipe"],
@@ -369,15 +515,17 @@ function captureRuntime(kind, systemPrompt, prompt, opts) {
         return;
       }
       const raw = stdout.trim() || stderr.trim();
+      let text;
       if (kind === "codex" && opts.authorityMode === "no-authority") {
-        finishResolve(codexCaptureAgentText(raw));
-        return;
-      }
-      if (kind === "claude-code" || kind === "gemini") {
-        finishResolve(capturedRuntimeAgentText(kind, raw));
-        return;
+        text = codexCaptureAgentText(raw);
+      } else if (kind === "claude-code" || kind === "gemini") {
+        text = capturedRuntimeAgentText(kind, raw);
+      } else {
+        text = raw;
       }
-      finishResolve(raw);
+      finishResolve(opts.envelope
+        ? { text, usage: capturedRuntimeUsage(kind, raw) }
+        : text);
     };
     onAbort = () => {
       const reason = opts.signal && opts.signal.reason;
@@ -399,7 +547,7 @@ function captureRuntime(kind, systemPrompt, prompt, opts) {
   });
 }
 
-// ── API 러너 (BYOK / Ollama) — 비스트리밍, 최종 텍스트 반환 (v1 runApi 포팅) ──
+// ── API 러너 (BYOK / Ollama) — 비스트리밍, 최종 텍스트/usage 반환 (v1 runApi 포팅) ──
 // engine/agentlas-api-agent.cjs 는 스트리밍+툴 루프(대화형)용이다. 워크포스 워커는
 // zero-tools 원샷이 계약이므로 v1의 비스트리밍 원샷 경로를 그대로 쓴다.
 const DEFAULT_API_MODEL = {
@@ -483,6 +631,9 @@ function readCustomApiBaseUrl() {
  */
 async function runApi(backend, model, system, prompt, options) {
   options = options || {};
+  const finish = (text, usage) => options.envelope
+    ? { text: String(text || ""), usage: usage || null }
+    : String(text || "");
   model = model || DEFAULT_API_MODEL[backend];
   const fetchImpl = options.fetch || globalThis.fetch;
   if (typeof fetchImpl !== "function") throw new Error("fetch is unavailable in this runtime (run through the app runtime).");
@@ -494,7 +645,10 @@ async function runApi(backend, model, system, prompt, options) {
     });
     if (!resp.ok) throw new Error(`Ollama ${resp.status} — run 'ollama serve' and check the model`);
     const j = await resp.json();
-    return (j.message && j.message.content) || "";
+    return finish(
+      (j.message && j.message.content) || "",
+      usageFromObject(j, ["prompt_eval_count"], ["eval_count"]),
+    );
   }
   const supported = backend === "anthropic" || backend === "openai" || backend === "google" ||
     backend === "upstage" || backend === "custom" || !!ANTHROPIC_COMPAT_API[backend];
@@ -509,14 +663,25 @@ async function runApi(backend, model, system, prompt, options) {
     const authHeaders = anthropicCompat
       ? { "x-api-key": key, authorization: "Bearer " + key }
       : { "x-api-key": key };
+    // Prompt caching: 진짜 Anthropic만 cache_control을 존중한다. 크고 안정된
+    // system 프리픽스를 캐시 경계로 표시하면 적중 시 입력이 ~90% 싸게 과금되고,
+    // 모델별 최소치(~1024 토큰) 미만이면 서버가 조용히 무시하므로 무해하다.
+    // 호환 엔드포인트(GLM/Kimi/DeepSeek)는 문자열 형태를 유지한다 — 서버측
+    // 자동 캐시가 있고 추가 필드를 거부할 수 있다(데스크탑 byok.ts와 동일 계약).
+    const systemField = backend === "anthropic"
+      ? [{ type: "text", text: system, cache_control: { type: "ephemeral" } }]
+      : system;
     const resp = await fetchImpl(`${base}/v1/messages`, {
       method: "POST",
       headers: { "content-type": "application/json", ...authHeaders, "anthropic-version": "2023-06-01" },
-      body: JSON.stringify({ model, max_tokens: 4096, system, messages: [{ role: "user", content: prompt }] }),
+      body: JSON.stringify({ model, max_tokens: 4096, system: systemField, messages: [{ role: "user", content: prompt }] }),
     });
     if (!resp.ok) throw new Error(`${label} ${resp.status}: ${(await resp.text().catch(() => "")).slice(0, 200)}`);
     const j = await resp.json();
-    return (j.content && j.content[0] && j.content[0].text) || "";
+    return finish(
+      (j.content && j.content[0] && j.content[0].text) || "",
+      usageFromObject(j.usage, ["input_tokens"], ["output_tokens"]),
+    );
   }
   if (backend === "openai" || backend === "upstage" || backend === "custom") {
     const base = backend === "upstage"
@@ -534,7 +699,10 @@ async function runApi(backend, model, system, prompt, options) {
     });
     if (!resp.ok) throw new Error(`${label} ${resp.status}: ${(await resp.text().catch(() => "")).slice(0, 200)}`);
     const j = await resp.json();
-    return (j.choices && j.choices[0] && j.choices[0].message && j.choices[0].message.content) || "";
+    return finish(
+      (j.choices && j.choices[0] && j.choices[0].message && j.choices[0].message.content) || "",
+      usageFromObject(j.usage, ["prompt_tokens"], ["completion_tokens"]),
+    );
   }
   if (backend === "google") {
     const url = `https://generativelanguage.googleapis.com/v1beta/models/${model}:generateContent?key=${encodeURIComponent(key)}`;
@@ -546,7 +714,10 @@ async function runApi(backend, model, system, prompt, options) {
     if (!resp.ok) throw new Error(`Google ${resp.status}: ${(await resp.text().catch(() => "")).slice(0, 200)}`);
     const j = await resp.json();
     const c = j.candidates && j.candidates[0];
-    return (c && c.content && c.content.parts && c.content.parts[0] && c.content.parts[0].text) || "";
+    return finish(
+      (c && c.content && c.content.parts && c.content.parts[0] && c.content.parts[0].text) || "",
+      usageFromObject(j.usageMetadata, ["promptTokenCount"], ["candidatesTokenCount"]),
+    );
   }
   throw new Error("Unsupported backend: " + backend);
 }
@@ -641,6 +812,19 @@ const UNTRUSTED_PROTECTED_ENV_KEYS_CLI = new Set([
   "HTTP_PROXY", "HTTPS_PROXY", "ALL_PROXY", "NO_PROXY", "GRPC_PROXY", "NPM_CONFIG_PROXY",
   "AGENTLAS_SESSION", "AGENTLAS_MCP_BASE_URL", "AGENTLAS_WEB_BASE_URL", "AGENTLAS_API_BASE_URL",
   "AGENTLAS_HUB_BASE_URL", "AGENTLAS_CLOUD_BASE_URL", "OLLAMA_HOST",
+  // 모델 제공사 엔드포인트/게이트웨이 — Agentlas 자체 base URL과 같은 부류인데 빠져
+  // 있었다. 2026-07-27 실측: 클론 레포의 .env 한 줄이 자식 CLI의 ANTHROPIC_BASE_URL과
+  // AUTH_TOKEN을 갈아치워, 모든 워커 프롬프트가 공격자 서버로 나가고 그 서버가 쓴
+  // 답변이 핸드오프·합성으로 흘러든다. 키 자체(*_API_KEY)는 프로젝트별 BYOK 기능이라
+  // 계속 허용한다 — 막는 것은 "데이터가 어디로 가는가"뿐이다.
+  "ANTHROPIC_BASE_URL", "ANTHROPIC_API_URL", "ANTHROPIC_AUTH_TOKEN", "ANTHROPIC_CUSTOM_HEADERS",
+  "ANTHROPIC_BEDROCK_BASE_URL", "ANTHROPIC_VERTEX_BASE_URL",
+  "CLAUDE_CODE_USE_BEDROCK", "CLAUDE_CODE_USE_VERTEX", "CLAUDE_CODE_SKIP_BEDROCK_AUTH",
+  "CLAUDE_CODE_SKIP_VERTEX_AUTH", "AWS_ENDPOINT_URL", "AWS_ENDPOINT_URL_BEDROCK",
+  "OPENAI_BASE_URL", "OPENAI_API_BASE", "OPENAI_ORGANIZATION", "AZURE_OPENAI_ENDPOINT",
+  "OPENAI_PROXY", "CODEX_BASE_URL", "CODEX_API_URL",
+  "GOOGLE_GEMINI_BASE_URL", "GOOGLE_VERTEX_BASE_URL", "GEMINI_API_BASE_URL",
+  "GOOGLE_CLOUD_PROJECT", "GOOGLE_APPLICATION_CREDENTIALS",
 ]);
 function isProtectedChildEnvKeyCli(key, trusted) {
   const k = String(key || "").trim().toUpperCase();
@@ -690,6 +874,7 @@ module.exports = {
   buildArgs,
   codexCaptureAgentText,
   capturedRuntimeAgentText,
+  capturedRuntimeUsage,
   captureOutputLimit,
   directCaptureOutputLimit,
   captureRuntime,

package/engine/workforce/concurrency.cjs

@@ -0,0 +1,41 @@
+"use strict";
+/*
+ * workforce/concurrency — 워크포스 워커 동시 실행 수(스웜 크기)의 사양 기반 추천값.
+ *
+ * 워커 1명 = captureRuntime을 통해 스폰되는 실제 CLI 자식 프로세스(engine/workforce/
+ * capture.cjs)다. 이전에는 사용자가 --parallel/-n을 안 주면 컴퓨터 사양과 무관하게
+ * 고정 3(상한 8)을 썼다 — 코어 2개짜리 저사양 기기에서 3개 CLI 자식이 한꺼번에 뜨면
+ * 과다 산정, 32코어 워크스테이션에서도 항상 3으로 저평가되는 양방향 문제였다.
+ *
+ * 데스크탑(electron/store/concurrency.ts)과 동일한 원리(코어 2개는 OS/자식 자신에게
+ * 남기고, 에이전트당 RAM ~2GB + 여유 4GB로 추정)를 쓰되, 상한(HARD_MAX)은 터미널
+ * 자체의 기존 안전선(8)을 그대로 유지한다 — 이건 provider가 바뀌어도 변하지 않는
+ * Agentlas 자체 정책 상수이지, 하드코딩 금지 대상인 "외부에서 바뀌는 값"이 아니다.
+ */
+const os = require("node:os");
+
+const HARD_MAX = 8;
+
+function getSystemSpecs() {
+  let cores = 4;
+  let totalMemGB = 8;
+  try {
+    cores = Math.max(1, os.cpus().length);
+  } catch {
+    // fall back
+  }
+  try {
+    totalMemGB = os.totalmem() / 1024 ** 3;
+  } catch {
+    // fall back
+  }
+  return { cores, totalMemGB };
+}
+
+function recommendedConcurrency(specs = getSystemSpecs()) {
+  const coreBound = Math.max(1, specs.cores - 2);
+  const memBound = Math.max(1, Math.floor((specs.totalMemGB - 4) / 2));
+  return Math.max(1, Math.min(coreBound, memBound, HARD_MAX));
+}
+
+module.exports = { HARD_MAX, getSystemSpecs, recommendedConcurrency };

package/engine/workforce/deps.cjs

@@ -32,49 +32,116 @@ const path = require("node:path");
 const { userDataDir } = require("../core/paths.cjs");
 const hubClient = require("../cloud/hub-client.cjs");
 const detect = require("../runtimes/detect.cjs");
+const { resolvedModelRole } = require("../runtimes/roles.cjs");
 const capture = require("./capture.cjs");
 
 // ── 런타임 해석 (v1 resolveRuntime의 워크포스 어댑터) ─────────────────────
-// 워크포스 모듈이 기대하는 형태: {mode:"cli", kind, model?} | {mode:"api", backend, model}.
-// v2 runtimes/resolve.cjs는 {kind, bin, source}만 주고 BYOK/Ollama를 모르므로,
-// v1의 사다리(명시 override > prefs 저장값 > 공유 DB active_runtime(byok/ollama 포함)
-// > PATH 탐지)를 여기서 복원한다. 아무것도 없으면 no_runtime 정직 정지 — 폴백 금지.
-function resolveWorkforceRuntime(db, override) {
-  if (!override) {
+// 워크포스 모듈이 기대하는 형태:
+//   {mode:"cli", kind, model?, effort?} | {mode:"api", backend, model, effort?}
+// 반환 정본은 orchestrator 런타임이며 roleRuntimes에 두 역할의 실제 실행 런타임을
+// 동봉한다. stage별 선택은 agentlas-workforce.cjs가 수행한다.
+function runtimeFromSelection(selection) {
+  if (!selection || !selection.kind) return null;
+  const common = {
+    model: selection.model || null,
+    effort: selection.effort || null,
+    capabilities: ["code", "tools", ...(selection.longContext ? ["long-context"] : [])],
+    efforts: [],
+    source: selection.sourceLayer || selection.source || null,
+    role: selection.role || null,
+  };
+  if (capture.RUNTIME_BIN[selection.kind]) {
+    return { mode: "cli", kind: selection.kind, ...common };
+  }
+  if (selection.kind === "byok" && selection.backend) {
+    return { mode: "api", backend: selection.backend, ...common };
+  }
+  if (selection.kind === "ollama") {
+    return { mode: "api", backend: "ollama", ...common };
+  }
+  return null;
+}
+
+function legacyWorkforceRuntime(db, override) {
+  let selectedOverride = override;
+  if (!selectedOverride) {
     try {
       const saved = require("../agentlas-config.cjs").loadPrefs(userDataDir()).runtime;
-      if (saved && saved !== "auto" && capture.RUNTIME_BIN[saved] && capture.which(capture.RUNTIME_BIN[saved])) override = saved;
+      if (
+        saved &&
+        saved !== "auto" &&
+        capture.RUNTIME_BIN[saved] &&
+        capture.which(capture.RUNTIME_BIN[saved])
+      ) {
+        selectedOverride = saved;
+      }
     } catch { /* prefs 없음 — 사다리 계속 */ }
   }
   const ar = db ? detect.activeRuntimeRow(db) : null;
-  const activeCli = ar && capture.RUNTIME_BIN[ar.kind]
-    ? {
-        mode: "cli",
+  const active = ar
+    ? runtimeFromSelection({
+        role: "orchestrator",
         kind: ar.kind,
-        model: ar.model || null,
-        capabilities: ["code", "tools", ...(ar.long_context ? ["long-context"] : [])],
-        efforts: [],
-      }
+        backend: ar.backend,
+        source: ar.source,
+        model: ar.model,
+        effort: null,
+        longContext: Boolean(ar.long_context),
+        sourceLayer: "active-runtime",
+      })
     : null;
-  if (override) {
-    if (!capture.RUNTIME_BIN[override]) {
-      const error = new Error(`unknown workforce runtime: ${override} (capture drivers: ${Object.keys(capture.RUNTIME_BIN).join(", ")})`);
+  if (selectedOverride) {
+    if (!capture.RUNTIME_BIN[selectedOverride]) {
+      const error = new Error(
+        `unknown workforce runtime: ${selectedOverride} (capture drivers: ${Object.keys(capture.RUNTIME_BIN).join(", ")})`,
+      );
       error.code = "no_runtime";
       throw error;
     }
-    return activeCli && activeCli.kind === override ? activeCli : { mode: "cli", kind: override };
+    return active && active.mode === "cli" && active.kind === selectedOverride
+      ? active
+      : { mode: "cli", kind: selectedOverride, model: null, effort: null };
   }
-  if (activeCli) return activeCli;
-  if (ar && ar.kind === "byok" && ar.backend) return { mode: "api", backend: ar.backend, model: ar.model };
-  if (ar && ar.kind === "ollama") return { mode: "api", backend: "ollama", model: ar.model };
+  if (active) return active;
   for (const kind of Object.keys(capture.RUNTIME_BIN)) {
-    if (capture.which(capture.RUNTIME_BIN[kind])) return { mode: "cli", kind };
+    if (capture.which(capture.RUNTIME_BIN[kind])) {
+      return { mode: "cli", kind, model: null, effort: null, source: "detected" };
+    }
   }
-  const error = new Error("no_runtime: no agent CLI or connected API runtime found (claude / codex / gemini / BYOK / Ollama).");
+  const error = new Error(
+    "no_runtime: no agent CLI or connected API runtime found (claude / codex / gemini / BYOK / Ollama).",
+  );
   error.code = "no_runtime";
   throw error;
 }
 
+// 사다리: 명시 override > model_roles[role] > 레거시 prefs/active/PATH.
+// worker가 비어 있거나 inherit=1이면 roles.cjs가 orchestrator로만 승격한다.
+function resolveWorkforceRuntime(db, override) {
+  if (override) {
+    const exact = legacyWorkforceRuntime(db, override);
+    return {
+      ...exact,
+      role: "orchestrator",
+      roleRuntimes: {
+        orchestrator: { ...exact, role: "orchestrator" },
+        worker: { ...exact, role: "worker" },
+      },
+    };
+  }
+  const fallback = legacyWorkforceRuntime(db, null);
+  const orchestrator = runtimeFromSelection(resolvedModelRole(db, "orchestrator")) || fallback;
+  const worker = runtimeFromSelection(resolvedModelRole(db, "worker")) || orchestrator;
+  return {
+    ...orchestrator,
+    role: "orchestrator",
+    roleRuntimes: {
+      orchestrator: { ...orchestrator, role: "orchestrator" },
+      worker: { ...worker, role: "worker" },
+    },
+  };
+}
+
 // ── 영수증 (v1 모놀리스의 JSONL 계약 포팅: userData 하위, 0700/0600) ──────
 function receiptFile() {
   return path.join(userDataDir(), "workforce-execution-receipts.jsonl");
@@ -112,13 +179,49 @@ function persistBenchmarkArtifact(artifact, executionIdHint) {
 // 보존하되 runtimeIds=[] / status="observed-not-executable"로 광고한다 —
 // 필요 capability에 대해 워크포스 모듈이 플래너 전에 fail-closed 하게 된다.
 // 권한을 제조하는 것보다 정직 정지가 계약이다.
-async function listWorkforceTools({ db, roster, cwd, env, timeoutMs, signal }) {
+// 워커가 실제로 부여받을 수 있는 유일한 네이티브 도구 집합 — 읽기 전용.
+// claude-code는 plan 모드(쓰기·실행 거부) + --allowedTools 로 이 경계를 강제할 수 있어
+// "정확 per-tool 부착"이 증명된다. 쓰기·셸·네트워크·MCP는 여전히 증명 불가라 잠긴 채다.
+const READ_ONLY_NATIVE_TOOLS = ["Read", "Grep", "Glob"];
+const READ_ONLY_BUILTIN_TOOL_ID = "builtin:file-read";
+const READ_ONLY_CAPABILITY_IDS = ["tool:file-read"];
+const READ_ONLY_RUNTIME_IDS = ["runtime:claude-code"];
+
+function readOnlyBuiltinToolRows(roster, runtimeId) {
+  if (!READ_ONLY_RUNTIME_IDS.includes(String(runtimeId || ""))) return [];
+  const rows = [];
+  for (const pinned of roster || []) {
+    // 허브가 이 릴리스에 파일 읽기를 허용했을 때만. deny면 존중하고 부여하지 않는다.
+    if (pinned?.permissionPolicy?.fileRead?.mode !== "manifest-allowlist") continue;
+    rows.push({
+      slotId: pinned.slotId,
+      agentReleaseId: pinned.agentReleaseId,
+      permissionPolicyDigest: pinned.permissionPolicyDigest,
+      provider: "builtin",
+      toolId: READ_ONLY_BUILTIN_TOOL_ID,
+      // 내장 도구는 MCP 서버가 없다. validateToolInventory는 serverId가 정확히 null이
+      // 아니면 거절한다(2026-07-27 라이브: "builtin" 문자열을 넣어 prepare 직후 전량 폐기).
+      serverId: null,
+      description: "Read-only project file access (Read/Grep/Glob, no write, no shell)",
+      inputSchemaDigest: null,
+      runtimeIds: [...READ_ONLY_RUNTIME_IDS],
+      selectiveEnforcement: "exact-tool-allowlist",
+      capabilityIds: [...READ_ONLY_CAPABILITY_IDS],
+      status: "ready",
+    });
+  }
+  return rows;
+}
+
+async function listWorkforceTools({ db, roster, cwd, env, timeoutMs, signal, runtimeId }) {
   const mcp = require("../mcp/index.cjs");
+  // 읽기 전용 내장 도구는 MCP 서버 유무와 무관하게 항상 제공한다.
+  const builtinRows = readOnlyBuiltinToolRows(roster, runtimeId);
   const servers = mcp.readConsentedSystemMcpServers(db, {
     userDataDir: userDataDir(),
     createRuntimeHome: false,
   }).slice(0, 8);
-  if (!servers.length) return [];
+  if (!servers.length) return builtinRows;
   const deadline = Date.now() + Math.max(50, Math.min(12_000, Number(timeoutMs) || 12_000));
   const outcomes = new Array(servers.length);
   let cursor = 0;
@@ -140,7 +243,7 @@ async function listWorkforceTools({ db, roster, cwd, env, timeoutMs, signal }) {
   await Promise.all(Array.from({ length: Math.min(3, servers.length) }, () => worker()));
 
   const safeId = /^[A-Za-z0-9][A-Za-z0-9_.$:/@+~-]{0,127}$/;
-  const rows = [];
+  const rows = [...builtinRows];
   for (let index = 0; index < servers.length; index += 1) {
     const server = servers[index];
     const listed = outcomes[index];
@@ -444,9 +547,19 @@ function buildWorkforceDeps(ctx = {}) {
     appendAuditReceipt,
     persistBenchmarkArtifact,
     listWorkforceTools,
-    // Terminal 원샷 러너는 네이티브 per-tool 권한 부여 경계를 아직 증명하지 못했다.
-    // 증명 없이 true를 돌려주면 권한 제조가 된다 — v1과 동일하게 항상 false.
-    supportsWorkforceToolAuthority: async () => false,
+    // 호스트가 자기 도구를 빌려주는 결정은 허브 후보 자격과 무관하다.
+    // requiredToolCapabilities는 "이 허브 에이전트가 그 도구를 선언했는가"라는
+    // 후보 필터라서, 선언한 에이전트가 사실상 0이라 그걸 쓰면 후보가 0건이 된다
+    // (2026-07-27 실측: 그래서 리더가 절대 선언하지 않았고 부여가 영영 발동 안 됨).
+    // 읽기 권한 대여는 허브가 그 릴리스에 파일 읽기를 허용했는지만 보면 된다.
+    hostReadOnlyGrants: (roster, runtimeId) => readOnlyBuiltinToolRows(roster, runtimeId),
+    // 읽기 전용 내장 도구는 claude-code plan 모드 + --allowedTools/--disallowedTools로
+    // 정확 경계가 증명된다 → 부여 허용. 그 밖(쓰기·셸·네트워크·MCP)은 여전히 증명
+    // 불가라 거부한다. 증명 없이 true를 돌려주면 권한 제조가 된다.
+    supportsWorkforceToolAuthority: async ({ grantedToolIds }) =>
+      Array.isArray(grantedToolIds)
+      && grantedToolIds.length > 0
+      && grantedToolIds.every((id) => id === READ_ONLY_BUILTIN_TOOL_ID),
     bindWorkforceGoal,
     loadWorkforceGoalRuntime,
     recordWorkforceGoalTurn,
@@ -472,6 +585,9 @@ module.exports = {
   appendAuditReceipt,
   persistBenchmarkArtifact,
   listWorkforceTools,
+  readOnlyBuiltinToolRows,
+  READ_ONLY_NATIVE_TOOLS,
+  READ_ONLY_BUILTIN_TOOL_ID,
   bindWorkforceGoal,
   loadWorkforceGoalRuntime,
   completeWorkforceGoal,

package/package.json

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