agentlas 1.0.11 → 1.0.14

package/engine/project/state.cjs

@@ -341,15 +341,16 @@ function activeProjectPath(db, options = {}) {
   return result.activated ? root : null;
 }
 
-// v1 시그니처 보존: permission/reason은 받되 절대 초기화 권한으로 쓰지 않는다.
 function ensureTerminalProjectForExecutionCli(db, projectPath, permission = "write", reason = "terminal-first-contact") {
   const root = terminalProjectCandidateCli(projectPath);
   if (!root) return null;
-  // Every ordinary execution mode is passive. Only `agentlas project init`
-  // may create .agentlas state or edit .gitignore; write/full permission is
-  // authority for the requested task, not consent to initialize the folder.
-  void permission;
-  void reason;
+  // A real write-capable execution is the product's first-contact boundary.
+  // Install the same private, merge-only Core infrastructure in whichever
+  // project the user opened; never key this behavior to the Agentlas_F repo.
+  if (permission === "write" || permission === "full") {
+    return initializeTerminalProjectCli(db, root, reason);
+  }
+  // Read-only inspection remains passive and never creates files.
   const active = activeProjectPath(db, { projectPath: root });
   if (!active) return null;
   return initializedAgentlasProjectPathCli(root);

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,
     });
@@ -116,6 +117,27 @@ class Orchestrator extends EventEmitter {
     if (!session) return;
     if (session.isBusy()) session.kill();
     this.sessions.delete(key);
+
+    // 부모를 지워도 자식 세션은 살아 있다(실행 중이며 병렬 슬롯을 쥔 채일 수 있다).
+    // 자식의 parent 포인터가 지워진 세션을 계속 가리키면 list()의 루트 판정
+    // (!s.parent)에서 탈락하고, 어떤 루트에서도 닿지 않아 /sessions·/tree 에서
+    // 통째로 사라진다 — 실행 중인데 보이지도 끌 수도 없는 유령 세션이 된다.
+    // 그래서 세션이 맵을 떠날 때 트리를 함께 정리한다: 남은 자식은 살아 있는
+    // 조부모로 승계하고(없으면 루트로 승격), 지워진 키는 부모 목록에서 뗀다.
+    const grandparent = session.parent && this.sessions.has(session.parent.key) ? session.parent : null;
+    for (const childKey of session.children) {
+      const child = this.sessions.get(childKey);
+      if (!child) continue;
+      child.parent = grandparent;
+      if (grandparent && !grandparent.children.includes(childKey)) grandparent.children.push(childKey);
+    }
+    session.children = [];
+    if (session.parent) {
+      const siblings = session.parent.children;
+      const at = siblings.indexOf(key);
+      if (at >= 0) siblings.splice(at, 1);
+    }
+
     if (this.activeKey === key) {
       const rest = [...this.sessions.keys()];
       this.activeKey = rest.length ? rest[rest.length - 1] : null;
@@ -123,14 +145,31 @@ class Orchestrator extends EventEmitter {
     this.emit("sessions-changed");
   }
 
+  /**
+   * 전 세션 브로드캐스트 — {sent, skipped}를 반환한다(throw 하지 않는다).
+   *
+   * WHY: 예전엔 루프 안에서 sendTo()의 throw가 그대로 올라갔다. 동시 상한(기본 4)보다
+   * 유휴 세션이 많으면 앞의 몇 개는 이미 프롬프트를 받아 실행을 시작한 뒤 상한 세션에서
+   * 터졌고, 그때까지 모은 sent 배열은 스택과 함께 버려졌다. 호출자(REPL)는 상한 에러
+   * 한 줄만 찍어 "전부 실패"로 보고했지만 실제로는 4개 세션이 그 지시를 받아 토큰을
+   * 쓰고 쓰기 작업까지 할 수 있는 상태였다 — 부분 성공을 전면 실패로 오보하는 것은
+   * 브로드캐스트에서 가장 위험한 거짓말이다.
+   * 그래서 실패는 세션 단위로 모으고, 실제 전달된 목록은 무슨 일이 있어도 반환한다.
+   * (sendTo/spawn의 "상한 초과는 정직한 거부" 계약 자체는 그대로 둔다.)
+   */
   broadcast(prompt) {
     const sent = [];
+    const skipped = [];
     for (const [key, session] of this.sessions) {
       if (session.status === "killed") continue;
-      this.sendTo(key, prompt);
-      sent.push(key);
+      try {
+        this.sendTo(key, prompt);
+        sent.push(key);
+      } catch (e) {
+        skipped.push({ key, error: String((e && e.message) || e) });
+      }
     }
-    return sent;
+    return { sent, skipped };
   }
 
   /** 세션 표: [{key, active, agent, status, elapsed, lastLine, parentKey, depth}] */

package/engine/sessions/prompt.cjs

@@ -88,13 +88,10 @@ function contextLine(json) {
   }
 }
 
-function ensureMemoryContextColumn(db) {
-  try {
-    if (tableExists(db, "memory_entries") && !columnExists(db, "memory_entries", "context_json")) {
-      db.exec("ALTER TABLE memory_entries ADD COLUMN context_json TEXT NOT NULL DEFAULT '{}'");
-    }
-  } catch { /* 앱 마이그레이션 중이면 다음 턴에 */ }
-}
+// 사본 3벌을 하나로 합치고 커넥션당 1회로 줄였다. 이 파일의 호출부는 **매 턴** 도는
+// 자리라(cliMemoryContext), 여기가 공유 DB 에 쓰기 락을 가장 자주 잡던 지점이었다.
+// 실패는 여전히 다음 호출에서 재시도된다 — 실패를 "완료"로 기억하지 않는다.
+const { ensureMemoryContextColumn } = require("../core/schema-ensure.cjs");
 
 /** Context Map 슬라이스 — Core 부재 시 정직하게 빈 문자열 (조작된 지도 금지). */
 function cliProjectContextSlice(projectPath, task) {

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,
@@ -122,6 +124,25 @@ class Session extends EventEmitter {
     return result;
   }
 
+  /**
+   * 이미 동의된 시스템 MCP 서버 목록. `full` 권한이 아니면 빈 배열이다.
+   *
+   * 권한 확인을 여기서 한 번 더 하는 이유: native-host 도 `full` 게이트를 갖고
+   * 있지만, 권한이 낮은 턴에서 목록을 **읽는 것 자체를** 하지 않는 편이 낫다.
+   * 읽지 않은 값은 실수로 새 나갈 수 없다.
+   */
+  _consentedMcpServers() {
+    if (permissions.normalize(this.permission) !== "full") return [];
+    try {
+      const consent = require("../mcp/consent.cjs");
+      return consent.readConsentedSystemMcpServers(this.db, { env: process.env }) || [];
+    } catch {
+      // 동의 상태를 못 읽으면 MCP 없이 간다. 여기서 실패해 턴을 죽이면,
+      // MCP 는 부가 기능인데 대화 자체가 불가능해진다.
+      return [];
+    }
+  }
+
   async _runTurn(prompt) {
     this.status = "running";
     this.startedAt = Date.now();
@@ -154,26 +175,68 @@ 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,
+        // 사용자가 이미 동의한 MCP 서버를 턴에 싣는다.
+        //
+        // 여기가 비어 있어서 챗 경로의 MCP 가 통째로 죽어 있었다(2026-07-28 확인:
+        // `mcpServers` 를 넘기는 호출자가 0곳). native-host 는 `full` 권한에서만
+        // 주입하도록 이미 게이팅돼 있었는데, 그 분기에 도달할 데이터를 아무도
+        // 채우지 않았다 — `agentlas mcp probe` 가 connected 를 찍어도 실제 턴에서는
+        // 그 서버를 쓸 수 없었다.
+        //
+        // 여기서 새로 묻지 않는다. `readConsentedSystemMcpServers` 는 이미 받아 둔
+        // 동의 영수증과 지문이 **지금도 일치하는** 서버만 돌려준다. 동의가 없으면
+        // 빈 배열이고, native-host 가 명시적 빈 격리로 간다. 턴 도중에 동의를 묻는
+        // 것은 사용자가 답할 수 없는 자리에서 묻는 것이라 하지 않는다.
+        mcpServers: this._consentedMcpServers(),
+        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 +296,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 */ }