agentlas 0.9.9 → 1.0.1

package/engine/sessions/prompt.cjs

@@ -0,0 +1,212 @@
+"use strict";
+/*
+ * sessions/prompt — 세션 턴의 시스템 프롬프트 조립 (데스크탑 러너 동형).
+ *
+ * 조립 순서(v1 augmentSystem과 동일):
+ *   언어/말투 지시 → 에이전트 시스템 프롬프트 → 전역 연결 스킬 →
+ *   거버넌스 메모리 컨텍스트(프로젝트 soul + Context Map 슬라이스 + scoped timeline) →
+ *   메모리 이미터(항상 150토큰 이하 코어; 메모리 의도 감지 시에만 전체 스키마) →
+ *   자격증명 인덱스 리마인더(배포/결제/인증 의도 시에만).
+ *
+ * 계약(memory-prompt-budget 테스트가 고정):
+ *  - TERMINAL_MEMORY_CORE는 150토큰(≈byte/3) 이하. 평상시 턴은 코어만 받는다.
+ *  - 전체 스키마에도 request_context / Local Credential Index를 넣지 않는다.
+ */
+const fs = require("node:fs");
+const path = require("node:path");
+const { loadArch, tableExists, columnExists } = require("../core/db.cjs");
+const { userDataDir } = require("../core/paths.cjs");
+const { responseDirective } = require("../agentlas-style.cjs");
+const memoryGovernance = require("../agentlas-memory-governance.cjs");
+const { resolveCoreRuntimeRoot, captureCoreJsonSync } = require("../agentlas-core-harness.cjs");
+
+const TERMINAL_MEMORY_CORE_MAX_TOKENS = 150;
+const TERMINAL_MEMORY_CORE = [
+  "## Memory governance",
+  "End every completed reply with hidden `## Memory Events` plus fenced JSON:",
+  '{"turn_id":"<stable-id>","observation":{"outcome":"completed","summary":"safe short outcome"},"candidates":[]}',
+  "Candidates 0..N: memory_kind,content,suggested_scope,confidence.",
+  "Scopes: user_global|team|agent|project|session|discard.",
+  "No raw prompts/transcripts, secrets, logs, or absolute paths. Curator suggests; deterministic gates decide writes.",
+].join("\n");
+const MEMORY_DETAIL_RE = /\b(?:remember|memory|save this|record this|memory event)\b|기억|메모리|저장해|기록해|남겨/i;
+const CREDENTIAL_INDEX_RE = /\b(?:deploy|release|billing|auth|oauth|credential|api key|secret key|cloud)\b|배포|릴리스|출시|결제|인증|자격 증명|API\s*키|시크릿|클라우드/i;
+
+function approximatePromptTokens(text) {
+  return Math.ceil(Buffer.byteLength(String(text || ""), "utf8") / 3);
+}
+if (approximatePromptTokens(TERMINAL_MEMORY_CORE) > TERMINAL_MEMORY_CORE_MAX_TOKENS) {
+  throw new Error("Terminal always-on memory core exceeds 150 tokens");
+}
+
+function memoryEmitterPromptFor(request, arch = loadArch(), turnId = null, permission = "write") {
+  const stableId = String(turnId || "").replace(/[^A-Za-z0-9:._-]/g, "").slice(0, 160);
+  let prompt = TERMINAL_MEMORY_CORE;
+  if (stableId) prompt += `\nUse turn_id=${stableId}. permission=${permission === "read" ? "receipt-only" : "curated-write"}.`;
+  if (!MEMORY_DETAIL_RE.test(String(request || ""))) return prompt;
+  const kinds = Array.isArray(arch?.kinds) && arch.kinds.length ? arch.kinds.join("|") : "fact|decision|preference|risk|procedure";
+  prompt += [
+    "",
+    `Allowed memory_kind: ${kinds}.`,
+    "Global requires explicit owner authorization; suggest only, never promote.",
+    "Do not emit request_context; put only a safe, short outcome in observation.",
+  ].join("\n");
+  return prompt;
+}
+
+function credentialIndexReminderFor(request) {
+  if (!CREDENTIAL_INDEX_RE.test(String(request || ""))) return "";
+  return [
+    "## Local credential lookup (triggered)",
+    "Before saying a deploy, release, billing, auth, API, or cloud credential is missing, read `.agentlas/local-credentials.map.json` and the Local Credential Index in `.agentlas/project-soul-memory.md`.",
+    "Use only env names and local relative references; never copy credential values into memory or output.",
+  ].join("\n");
+}
+
+function loadGlobalConnectionSkill() {
+  // 앱 빌드 산출물이 없는 standalone에선 v1과 동일한 인라인 스킬을 쓴다.
+  return [
+    "## Connecting accounts for the user (always-on background skill)",
+    "When the task needs Slack, Gmail, Google Cloud, Firebase, a database, store release access, or another third-party service, open the provider website with the browser tool when available, guide the user one tiny step at a time, and save the issued credential with `agentlas creds save --provider <name> --key <ENV_NAME> --value \"<value>\" --project \"<cwd>\"` or `agentlas creds file --source <path> --provider <name> --env <ENV_NAME> --project \"<cwd>\"`.",
+    "Do not lecture the user about security in this local single-user setup; make the connection effortless.",
+  ].join("\n\n");
+}
+
+function contextLine(json) {
+  try {
+    const ctx = JSON.parse(json || "{}");
+    const parts = [
+      ctx.user_intent || ctx.userIntent,
+      (ctx.target_project || ctx.targetProject) ? `target:${ctx.target_project || ctx.targetProject}` : null,
+      Array.isArray(ctx.trigger_terms || ctx.triggerTerms) && (ctx.trigger_terms || ctx.triggerTerms).length
+        ? `terms:${(ctx.trigger_terms || ctx.triggerTerms).join(",")}`
+        : null,
+    ].filter(Boolean);
+    return parts.length ? ` (context: ${parts.join("; ").slice(0, 180)})` : "";
+  } catch {
+    return "";
+  }
+}
+
+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 { /* 앱 마이그레이션 중이면 다음 턴에 */ }
+}
+
+/** Context Map 슬라이스 — Core 부재 시 정직하게 빈 문자열 (조작된 지도 금지). */
+function cliProjectContextSlice(projectPath, task) {
+  if (!projectPath || !String(task || "").trim()) return "";
+  try {
+    const coreRoot = resolveCoreRuntimeRoot();
+    if (!coreRoot) return "";
+    const result = captureCoreJsonSync(
+      "agentlas_cloud",
+      ["context", "slice", "--project", projectPath, "--task-stdin", "--no-refresh", "--render"],
+      { cwd: projectPath, input: String(task || "").slice(0, 12_000), timeout: 4_000 },
+      coreRoot,
+    );
+    return result
+      && result.schemaVersion === "agentlas.context-slice.v1"
+      && typeof result.rendered === "string"
+      ? result.rendered.trim()
+      : "";
+  } catch {
+    return "";
+  }
+}
+
+/**
+ * 거버넌스 스코프 메모리 컨텍스트 (v1 cliMemoryContext 충실 이식).
+ * 프로젝트 B가 프로젝트 A의 로컬 메모리를 소환하지 못하는 스코프 규칙이 핵심 —
+ * 레거시 행도 user-global/현재 프로젝트/현재 소유자만 통과한다(옛 전역 팀메모리
+ * 누수 쿼리를 되살리지 않는다).
+ */
+function cliMemoryContext(db, projectPath, agentId = null, task = "") {
+  const sections = [];
+  const arch = loadArch();
+  ensureMemoryContextColumn(db);
+  if (projectPath) {
+    try {
+      const soulPath = path.join(projectPath, arch.memoryDir || ".agentlas", arch.soulFile || "project-soul-memory.md");
+      if (fs.existsSync(soulPath)) {
+        let s = fs.readFileSync(soulPath, "utf8");
+        if (s.length > 1800) s = s.slice(0, 1800) + "\n…(truncated)";
+        if (s.trim()) sections.push(`### Project memory (${projectPath})\n${s.trim()}`);
+      }
+    } catch { /* ignore */ }
+    const contextSlice = cliProjectContextSlice(projectPath, task);
+    if (contextSlice) sections.push(contextSlice);
+  }
+  if (tableExists(db, "memory_entries")) {
+    try {
+      const governed = memoryGovernance.listScopedTimeline(db, { projectPath, agentId, limit: 16 });
+      const seen = new Set(governed.map((row) => row.id));
+      const legacy = projectPath
+        ? db.prepare(`
+            SELECT id,kind,content,context_json,created_at
+            FROM memory_entries
+            WHERE superseded_at IS NULL AND (
+              (scope='user_identity' AND project_path IS NULL)
+              OR (scope='project' AND project_path=?)
+              OR (scope IN ('team_memory','agent_team','agent_repo') AND agent_id=? AND (project_path IS NULL OR project_path=?))
+            )
+            ORDER BY created_at DESC LIMIT 16
+          `).all(projectPath, agentId, projectPath)
+        : db.prepare(`
+            SELECT id,kind,content,context_json,created_at
+            FROM memory_entries
+            WHERE superseded_at IS NULL AND (
+              (scope='user_identity' AND project_path IS NULL)
+              OR (scope IN ('team_memory','agent_team','agent_repo') AND agent_id=? AND project_path IS NULL)
+            )
+            ORDER BY created_at DESC LIMIT 16
+          `).all(agentId);
+      const rows = [...governed, ...legacy.filter((row) => !seen.has(row.id))].slice(0, 16);
+      if (rows.length) {
+        sections.push(
+          (projectPath ? "### Scoped global + current-project memory timeline\n" : "### Curated user-global memory\n") +
+          rows.map((r) => `- [${r.kind}] ${r.content}${contextLine(r.context_json)}`).join("\n"),
+        );
+      }
+    } catch { /* ignore */ }
+  }
+  if (!sections.length) return "";
+  return "## Agentlas memory (read before answering; governed scope recall)\n\n" + sections.join("\n\n");
+}
+
+/**
+ * 최종 시스템 프롬프트 조립. ctx = { lang, projectPath, agentId, turnId, permission }.
+ * withEmitter=false 는 이미터/리마인더 없이(캡처·판정 등 내부 턴용).
+ */
+function augmentSystem(db, baseSystem, ctx, withEmitter, request = "") {
+  const arch = loadArch();
+  let sys = baseSystem || "";
+  // 언어/말투 지시를 맨 앞에 둔다. imported/cloud/company agents도 같은 전역 계약을 따른다.
+  const lang = (ctx && ctx.lang) || "en";
+  sys = responseDirective(lang) + (sys ? "\n\n" + sys : "");
+  const connectionSkill = loadGlobalConnectionSkill();
+  if (connectionSkill) sys += "\n\n" + connectionSkill;
+  const mem = cliMemoryContext(db, ctx && ctx.projectPath, ctx && ctx.agentId, request);
+  if (mem) sys += "\n\n" + mem;
+  if (withEmitter) {
+    sys += "\n\n" + memoryEmitterPromptFor(request, arch, ctx && ctx.turnId, ctx && ctx.permission);
+    const credentialReminder = credentialIndexReminderFor(request);
+    if (credentialReminder) sys += "\n\n" + credentialReminder;
+  }
+  return sys;
+}
+
+module.exports = {
+  TERMINAL_MEMORY_CORE,
+  TERMINAL_MEMORY_CORE_MAX_TOKENS,
+  approximatePromptTokens,
+  memoryEmitterPromptFor,
+  credentialIndexReminderFor,
+  cliMemoryContext,
+  cliProjectContextSlice,
+  augmentSystem,
+  loadGlobalConnectionSkill,
+};

package/engine/sessions/session.cjs

@@ -0,0 +1,245 @@
+"use strict";
+/*
+ * sessions/session — 살아있는 대화 하나.
+ *
+ * 세션 = 에이전트 + 챗(영속) + 런타임 resume 상태 + 이벤트 링버퍼.
+ * 포그라운드/서브에이전트 구분 없이 실행 경로는 이것 하나다(제2 경로 금지).
+ *
+ * 스티어링: 네이티브 러너는 stdin이 닫힌 헤드리스 실행이므로 "실행 중 주입"이
+ * 아니라 "다음 턴 큐잉"이다 — steer()로 넣은 메시지는 현재 턴이 끝나는 즉시
+ * resume 세션으로 이어 실행된다. (조용히 버리지 않고 큐에 쌓였음을 이벤트로 알린다.)
+ */
+const crypto = require("node:crypto");
+const { EventEmitter } = require("node:events");
+const nativeHost = require("../agentlas-native-host.cjs");
+const permissions = require("../agentlas-permissions.cjs");
+const { EventSink } = require("./sink.cjs");
+const store = require("./store.cjs");
+
+const RING_LIMIT = 2000;
+
+class Session extends EventEmitter {
+  /**
+   * @param {object} opts
+   *   db, agent {id,slug,name,systemPrompt}, runtime {kind,bin,model?},
+   *   permission, cwd, lang, parent (Session|null), title, chatId?(재개)
+   */
+  constructor(opts) {
+    super();
+    this.db = opts.db;
+    this.agent = opts.agent;
+    this.runtime = opts.runtime;
+    this.permission = permissions.normalize(opts.permission);
+    this.cwd = opts.cwd || process.cwd();
+    this.lang = opts.lang || "en";
+    this.parent = opts.parent || null;
+    this.children = [];
+    this.status = "idle"; // idle | running | done | failed | killed
+    this.lastLine = "";
+    this.lastError = null;
+    this.startedAt = null;
+    this.endedAt = null;
+    this.usage = null;
+    this.queue = [];
+    this._child = null;
+    this._events = [];
+    this._turnPromise = null;
+    // 계약 테스트용 spawn 주입(runNativeTurn의 req.spawn). 프로덕션 경로에선 null.
+    this._spawnImpl = opts.spawnImpl || null;
+    this._timeoutConfig = opts.timeoutConfig || null;
+
+    this.chatId = opts.chatId || store.createChat(this.db, {
+      agentId: this.agent.id,
+      title: opts.title || (opts.parent ? `sub: ${this.agent.slug}` : "New chat"),
+      kind: opts.parent ? "division" : "user",
+      parentChatId: opts.parent ? opts.parent.chatId : null,
+      workingFolder: this.cwd,
+    });
+    // 이 세션이 붙은 챗의 kind — apply-fences의 division 재귀 가드가 parent 없는
+    // 기존 division 챗(자동화 marker 세션 등)에도 걸리게 한다.
+    // 데스크탑은 chat.kind !== 'division' 조건으로 같은 가드를 건다(client.ts:3493).
+    this.chatKind = opts.parent ? "division" : "user";
+    if (opts.chatId) {
+      try {
+        const chatRow = this.db.prepare("SELECT kind FROM chats WHERE id=?").get(opts.chatId);
+        if (chatRow && chatRow.kind === "division") this.chatKind = "division";
+      } catch { /* kind 열이 없는 구형 DB — user 취급(레거시 NULL=user 계약) */ }
+    }
+
+    this.fingerprint = crypto.createHash("sha256")
+      .update(`${this.runtime.kind}\n${this.agent.id}\n${this.agent.systemPrompt || ""}`)
+      .digest("hex");
+    this.runtimeSession = store.loadRuntimeSession(this.db, this.chatId, this.runtime.kind, this.fingerprint);
+
+    this._sink = new EventSink({
+      lang: this.lang,
+      onEvent: (ev) => this._record(ev),
+    });
+  }
+
+  _record(ev) {
+    this._events.push(ev);
+    if (this._events.length > RING_LIMIT) this._events.splice(0, this._events.length - RING_LIMIT);
+    if (ev.type === "stream-delta") {
+      const tail = (this.lastLine + ev.text).split(/\r?\n/).filter((l) => l.trim());
+      this.lastLine = tail.length ? tail[tail.length - 1].slice(0, 200) : this.lastLine;
+    } else if (ev.type === "status" || ev.type === "tool") {
+      this.lastLine = ev.type === "tool" ? `${ev.name}(${ev.summary || ""})`.slice(0, 200) : ev.text.slice(0, 200);
+    } else if (ev.type === "error") {
+      this.lastError = ev.text;
+    }
+    this.emit("event", ev);
+  }
+
+  eventsTail(n = 200) {
+    return this._events.slice(-n);
+  }
+
+  isBusy() {
+    return this.status === "running";
+  }
+
+  /** 실행 중이면 큐잉, 아니면 즉시 실행. 반환: 최종 상태로 settle되는 Promise. */
+  send(prompt) {
+    const text = String(prompt || "").trim();
+    if (!text) return Promise.resolve(null);
+    if (this.isBusy()) {
+      this.queue.push(text);
+      this._record({ type: "queued", at: Date.now(), text });
+      return this._turnPromise;
+    }
+    this._turnPromise = this._runLoop(text);
+    return this._turnPromise;
+  }
+
+  async _runLoop(firstPrompt) {
+    let prompt = firstPrompt;
+    let result = null;
+    while (prompt != null) {
+      result = await this._runTurn(prompt);
+      prompt = this.queue.length ? this.queue.shift() : null;
+    }
+    return result;
+  }
+
+  async _runTurn(prompt) {
+    this.status = "running";
+    this.startedAt = Date.now();
+    this.lastError = null;
+    this._record({ type: "turn-start", at: Date.now(), prompt });
+    store.appendMessage(this.db, this.chatId, "user", prompt);
+    // 데스크탑처럼 첫 프롬프트로 자동 제목 — "New chat"으로 남는 목록 방지(실사용 테스트 발견).
+    try {
+      const row = this.db.prepare("SELECT title FROM chats WHERE id=?").get(this.chatId);
+      if (row && (row.title === "New chat" || !row.title)) {
+        store.retitleChat(this.db, this.chatId, prompt.slice(0, 60));
+      }
+    } catch { /* 제목은 장식 — 실패해도 턴 진행 */ }
+
+    // 데스크탑 러너 동형 프롬프트 조립: 언어지시 + 에이전트 프롬프트 + 연결 스킬 +
+    // 거버넌스 메모리 컨텍스트 + 메모리 이미터 코어(+의도 시 전체 스키마/자격증명 리마인더).
+    // projectPath는 명시 초기화(.agentlas 존재) 프로젝트만 — project init 경계 유지.
+    let systemPrompt = this.agent.systemPrompt || "";
+    try {
+      const { augmentSystem } = require("./prompt.cjs");
+      const fs = require("node:fs");
+      const path = require("node:path");
+      const projectPath = fs.existsSync(path.join(this.cwd, ".agentlas")) ? this.cwd : null;
+      systemPrompt = augmentSystem(this.db, systemPrompt, {
+        lang: this.lang,
+        projectPath,
+        agentId: this.agent.id,
+        turnId: `${this.chatId}:${Date.now()}`,
+        permission: this.permission,
+      }, 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) };
+    }
+    this._child = null;
+
+    const finalText = (res && (res.finalText || res.text)) || "";
+    /*
+     * 펜스 프로토콜(Desktop runner 패리티): 성공 턴의 최종 텍스트에서 숨은 제어
+     * 블록(## Memory Events / ## Delegate / ## Automation / <<agentlas-ask>>)을
+     * 파싱하고, 영속·표시에는 cleanText 만 남긴다. 실패/킬 턴은 파싱하지 않는다 —
+     * 반쯤 죽은 응답의 위임/자동화를 실행하지 않기 위해. 파서 예외 시 원문 보존
+     * (데이터 유실이 오폭보다 낫다). require 는 lazy — orchestrator 와의 로드
+     * 사이클 방지.
+     */
+    let persistText = finalText;
+    let parsedFences = null;
+    if (finalText && !(res && res.error) && this.status !== "killed") {
+      try {
+        parsedFences = require("./fences.cjs").parseReplyFences(finalText);
+        persistText = parsedFences.cleanText;
+      } catch {
+        parsedFences = null;
+        persistText = finalText;
+      }
+    }
+    if (persistText) store.appendMessage(this.db, this.chatId, "assistant", persistText);
+    if (res && res.session && res.session.id) {
+      this.runtimeSession = { id: res.session.id };
+      store.saveRuntimeSession(this.db, this.chatId, this.runtime.kind, this.runtimeSession, this.fingerprint);
+    }
+    if (res && res.usage) this.usage = res.usage;
+
+    this.endedAt = Date.now();
+    if (this.status === "killed") {
+      this._record({ type: "turn-end", at: Date.now(), ok: false, killed: true });
+      return res;
+    }
+    if (res && res.error) {
+      this.status = "failed";
+      this.lastError = res.error;
+      this._record({ type: "turn-end", at: Date.now(), ok: false, error: res.error });
+    } else {
+      this.status = "done";
+      // 링버퍼 표시 이벤트에도 raw 대신 cleanText — 제어 블록이 패널/lastLine 에 새지 않게.
+      this._record({ type: "turn-end", at: Date.now(), ok: true, text: persistText });
+    }
+    // 적용은 상태 확정 후 — 이 세션이 더 이상 running 으로 집계되지 않아 위임 스폰이
+    // 동시 상한을 자기 자신으로 소모하지 않는다. 적용 실패는 이벤트로 표면화.
+    if (parsedFences) {
+      try {
+        require("./apply-fences.cjs").applyReplyFences(this, parsedFences, { orch: this.orchestrator });
+      } catch (e) {
+        this._record({ type: "error", at: Date.now(), text: `fence apply failed: ${(e && e.message) || String(e)}` });
+      }
+    }
+    return res;
+  }
+
+  /** 실행 중 턴을 중단한다. 큐는 비운다. */
+  kill() {
+    this.queue.length = 0;
+    if (this._child) {
+      this.status = "killed";
+      try { nativeHost.terminateNativeChild(this._child); } catch { /* already dead */ }
+    } else if (this.status === "running") {
+      this.status = "killed";
+    }
+  }
+}
+
+module.exports = { Session };

package/engine/sessions/sink.cjs

@@ -0,0 +1,54 @@
+"use strict";
+/*
+ * sessions/sink — native-host의 ui 인터페이스를 "이벤트"로 변환하는 싱크.
+ *
+ * 세션은 터미널에 직접 그리지 않는다. 모든 런타임 출력은 타입드 이벤트로
+ * 세션 링버퍼에 쌓이고, 렌더러(REPL)가 "활성 세션"의 이벤트만 실시간으로
+ * 그린다 — 이것이 오르카식 멀티세션의 기반이다(백그라운드 세션 전환 시
+ * 버퍼 테일 재생 + 라이브 구독).
+ *
+ * 구현 인터페이스(native-host가 호출): status, warn, error, line, tool,
+ * toolResult, streamStart, streamDelta, streamEnd, applyTaskTool,
+ * applyTaskResult, c(팔레트 — 렌더러가 색을 정하므로 여기선 무색 passthrough), t(i18n).
+ */
+const i18n = require("../agentlas-i18n.cjs");
+
+const NOOP_PALETTE = new Proxy({}, { get: () => (s) => String(s) });
+
+class EventSink {
+  constructor({ lang = "en", onEvent } = {}) {
+    this.lang = lang;
+    this.t = (key, ...args) => i18n.t(this.lang, key, ...args);
+    this.c = NOOP_PALETTE;
+    this._onEvent = onEvent || (() => {});
+    this._streamOpen = false;
+  }
+
+  _emit(type, data) {
+    this._onEvent({ type, at: Date.now(), ...data });
+  }
+
+  status(text) { this._emit("status", { text: String(text || "") }); }
+  warn(text) { this._emit("warn", { text: String(text || "") }); }
+  error(text) { this._emit("error", { text: String(text || "") }); }
+  line(text) { this._emit("line", { text: String(text || "") }); }
+  tool(name, summary) { this._emit("tool", { name: String(name || "tool"), summary: String(summary || "") }); }
+  toolResult(text, ok) { this._emit("tool-result", { text: String(text || ""), ok: ok !== false }); }
+  streamStart() {
+    if (!this._streamOpen) { this._streamOpen = true; this._emit("stream-start", {}); }
+  }
+  streamDelta(text) {
+    if (!this._streamOpen) this.streamStart();
+    this._emit("stream-delta", { text: String(text || "") });
+  }
+  streamEnd() {
+    if (this._streamOpen) { this._streamOpen = false; this._emit("stream-end", {}); }
+  }
+  applyTaskTool(name, input, id) { this._emit("task-tool", { name, input, id }); }
+  applyTaskResult(name, result, id) { this._emit("task-result", { name, result, id }); }
+  info(text) { this._emit("line", { text: String(text || "") }); }
+  cost(usage) { this._emit("cost", { usage }); }
+  stopSpinner() { /* 스피너는 렌더러 소관 — 이벤트 불필요 */ }
+}
+
+module.exports = { EventSink };

package/engine/sessions/store.cjs

@@ -0,0 +1,79 @@
+"use strict";
+/*
+ * sessions/store — chats/chat_messages 영속화 (데스크탑과 동일 테이블·어휘).
+ * 메인 세션: kind='user'. 서브에이전트 세션: kind='division' + parent_chat_id
+ * (데스크탑 division 서브챗과 같은 패턴 — 데스크탑 UI에서도 동일하게 보인다).
+ */
+const crypto = require("node:crypto");
+const { runWriteTransaction } = require("../core/db.cjs");
+
+function newId() {
+  return crypto.randomUUID();
+}
+
+function nowIso() {
+  return new Date().toISOString();
+}
+
+function createChat(db, { agentId, title, kind = "user", parentChatId = null, workingFolder = null }) {
+  const id = newId();
+  const now = nowIso();
+  runWriteTransaction(db, () => {
+    db.prepare(
+      "INSERT INTO chats (id, agent_id, title, created_at, updated_at, kind, parent_chat_id, working_folder) VALUES (?,?,?,?,?,?,?,?)",
+    ).run(id, agentId, title || "New chat", now, now, kind, parentChatId, workingFolder);
+  });
+  return id;
+}
+
+function appendMessage(db, chatId, role, text) {
+  const id = newId();
+  const now = nowIso();
+  runWriteTransaction(db, () => {
+    db.prepare(
+      "INSERT INTO chat_messages (id, chat_id, role, text, created_at) VALUES (?,?,?,?,?)",
+    ).run(id, chatId, role, String(text || ""), now);
+    db.prepare("UPDATE chats SET updated_at=?, used_at=? WHERE id=?").run(now, now, chatId);
+  });
+  return id;
+}
+
+function retitleChat(db, chatId, title) {
+  runWriteTransaction(db, () => {
+    db.prepare("UPDATE chats SET title=?, updated_at=? WHERE id=?").run(String(title || "New chat").slice(0, 120), nowIso(), chatId);
+  });
+}
+
+function chatHistory(db, chatId, limit = 40) {
+  return db.prepare(
+    "SELECT role, text, created_at FROM chat_messages WHERE chat_id=? ORDER BY created_at DESC, rowid DESC LIMIT ?",
+  ).all(chatId, limit).reverse();
+}
+
+/*
+ * CLI resume 세션 ID 영속화 — 데스크탑 chat_runtime_sessions와 동일 스키마
+ * (chat_id, kind, session_id, fingerprint). fingerprint가 다르면 resume하지
+ * 않는다 — 시스템 프롬프트가 바뀐 세션을 이어붙이면 지시가 오염된다.
+ */
+function loadRuntimeSession(db, chatId, kind, fingerprint) {
+  try {
+    const row = db.prepare("SELECT session_id, fingerprint FROM chat_runtime_sessions WHERE chat_id=? AND kind=?").get(chatId, kind);
+    if (row && row.session_id && row.fingerprint === fingerprint) return { id: row.session_id };
+  } catch { /* 테이블 부재 — resume 없이 진행 */ }
+  return {};
+}
+
+function saveRuntimeSession(db, chatId, kind, session, fingerprint) {
+  const sessionId = session && session.id ? String(session.id) : "";
+  if (!sessionId) return;
+  try {
+    runWriteTransaction(db, () => {
+      db.prepare(
+        "INSERT INTO chat_runtime_sessions (chat_id, kind, session_id, fingerprint, updated_at) VALUES (?,?,?,?,?) " +
+        "ON CONFLICT(chat_id, kind) DO UPDATE SET session_id=excluded.session_id, fingerprint=excluded.fingerprint, updated_at=excluded.updated_at",
+      ).run(chatId, kind, sessionId, fingerprint, nowIso());
+    });
+  } catch { /* 스키마가 다르면 resume만 포기 — 턴 자체는 유효 */ }
+}
+
+module.exports = { createChat, appendMessage, retitleChat, chatHistory, loadRuntimeSession, saveRuntimeSession, newId };

package/engine/storm/deps.cjs

@@ -0,0 +1,88 @@
+"use strict";
+/*
+ * storm/deps — storm/swarm 하네스의 의존성 주머니(D bag) 조립 + 로컬 런타임 인벤토리.
+ *
+ * v1에서는 모놀리스(engine/agentlas.cjs)의 lazy 팩토리 parity()가 이 D를 만들었다
+ * (legacy-v1-engine-snapshot, 10727–10758행). v2에서는 각 멤버를 모듈 경계에 맞게
+ * 다시 배선한다:
+ *
+ *   captureRuntime / runApi / buildChildEnvCli / projectCwd / runCwd
+ *                       → engine/workforce/capture.cjs (검증된 헤드리스 캡처 단일 경로 —
+ *                         storm/swarm 워커용 제2의 스폰 경로를 만들지 않는다)
+ *   resolveRuntime      → engine/workforce/deps.cjs resolveWorkforceRuntime
+ *                         (v1 사다리 그대로: 명시 override > prefs 저장 CLI >
+ *                          공유 DB active_runtime(byok/ollama 포함) > PATH 탐지.
+ *                          아무것도 없으면 code="no_runtime" 정직 정지 — 폴백 금지)
+ *   listAvailableRuntimes → 여기서 v1 모놀리스 9245–9275행을 포팅 (아래)
+ *   modelRoutingReceiptPath → v1과 동일한 userData 하위 JSONL
+ *
+ * 불변식(오너 결정): 인벤토리는 이 호스트에 실제 설치·연결된 런타임만 광고한다.
+ * Terminal/plugin이 스케줄할 수 없는 런타임을 시늉하지 않는다.
+ */
+const path = require("node:path");
+
+const { userDataDir } = require("../core/paths.cjs");
+const routing = require("../agentlas-workload-routing.cjs");
+const capture = require("../workforce/capture.cjs");
+const { resolveWorkforceRuntime } = require("../workforce/deps.cjs");
+
+// v1 모놀리스 listAvailableRuntimes 포팅 (legacy-v1-engine-snapshot 9245–9275행).
+// 상위(부모 AI) 워크로드 할당자를 위한 "실행 가능한 런타임 인벤토리"를 만든다.
+function listAvailableRuntimes(db, fallbackRuntime = null) {
+  const active = fallbackRuntime || resolveWorkforceRuntime(db);
+  const candidates = [];
+  const add = (runtime) => {
+    if (!runtime) return;
+    const key = runtime.mode === "cli" ? `cli:${runtime.kind}` : `api:${runtime.backend}:${runtime.model || ""}`;
+    if (candidates.some((item) => item.key === key)) return;
+    const discovered = routing.defaultAvailableModels(runtime);
+    const availableModels = [...discovered];
+    if (runtime.model && !availableModels.some((model) => model.id === runtime.model)) {
+      availableModels.push({
+        id: runtime.model,
+        tier: runtime.modelTier || runtime.tier || null,
+        capabilities: runtime.capabilities || [],
+        contextWindow: runtime.contextWindow || null,
+        efforts: runtime.efforts || [],
+        description: runtime.modelDescription || "host-selected current model",
+      });
+    }
+    candidates.push({ ...runtime, key, availableModels });
+  };
+  add(active);
+  for (const kind of Object.keys(capture.RUNTIME_BIN)) {
+    if (!capture.which(capture.RUNTIME_BIN[kind])) continue;
+    add({ mode: "cli", kind });
+  }
+  return candidates
+    .filter((runtime) => runtime.availableModels.length)
+    .map(({ key, ...runtime }, index) => ({ ...runtime, runtimeId: `runtime-${index + 1}` }));
+}
+
+// v1 D.modelRoutingReceiptPath와 동일한 경로. workload-routing의 defaultReceiptPath
+// (~/.agentlas/…)가 아니라 userData 하위를 쓰는 것이 Terminal의 v1 계약이다.
+function modelRoutingReceiptPath() {
+  return path.join(userDataDir(), "model-routing-receipts.jsonl");
+}
+
+/**
+ * D bag 조립. ctx = { lang?, out? } (엔진 ctx의 부분집합).
+ * 모든 멤버는 v1 parity() 팩토리와 같은 계약 형태를 유지한다 —
+ * storm/swarm 모듈은 이 D만 사용하고 자체 스폰/자체 상태를 갖지 않는다.
+ */
+function buildStormDeps(ctx = {}) {
+  return {
+    prefsLang: () => ctx.lang || "en",
+    out: typeof ctx.out === "function" ? ctx.out : (s) => process.stdout.write(`${s}\n`),
+    resolveRuntime: resolveWorkforceRuntime,
+    listAvailableRuntimes,
+    captureRuntime: capture.captureRuntime,
+    runApi: capture.runApi,
+    buildChildEnvCli: capture.buildChildEnv,
+    projectCwd: capture.projectCwd,
+    runCwd: capture.runCwd,
+    modelRoutingReceiptPath,
+  };
+}
+
+module.exports = { listAvailableRuntimes, modelRoutingReceiptPath, buildStormDeps };