agentlas 1.0.12 → 1.0.15

package/engine/commands/uninstall.cjs

@@ -11,7 +11,8 @@ const { runWriteTransaction } = require("../agentlas-sqlite-policy.cjs");
 
 function run(ctx, args) {
   const ko = ctx.lang === "ko";
-  const token = args[0];
+  // 동의 플래그를 슬러그보다 앞에 써도 되도록 첫 번째 비플래그 인자를 대상으로 본다.
+  const token = args.find((a) => !String(a).startsWith("-"));
   if (!token) {
     ctx.err(ko ? "사용법: agentlas uninstall <agent>" : "Usage: agentlas uninstall <agent>");
     return 1;
@@ -45,6 +46,35 @@ function run(ctx, args) {
     }
   }
 
+  /*
+   * 대화 파괴 게이트 — bootstrap-schema.sql:50 chats.agent_id 는
+   * `ON DELETE CASCADE`, :61 chat_messages.chat_id 도 CASCADE 다. 즉
+   * installed_agents 행 하나를 지우면 그 에이전트의 모든 챗과 메시지가 같이
+   * 사라진다(데스크탑과 공유하는 SQLite라 데스크탑 쪽 이력도 함께 증발한다).
+   * 그런데 이 명령은 그 사실을 한 줄도 알리지 않고 `✓ 제거됨`만 찍었다 —
+   * 되돌릴 수 없는 삭제가 무고지·무확인으로 일어나던 자리다.
+   * 그래서 지우기 "전에" 파급 건수를 세고, 대화가 있으면 명시적 동의
+   * (--yes/-y/--force) 없이는 아무것도 지우지 않는다. 대화가 0건이면
+   * 파괴할 이력이 없으므로 종전대로 그냥 진행한다(불필요한 마찰 금지).
+   */
+  const consented = args.some((a) => a === "--yes" || a === "-y" || a === "--force");
+  let chatCount = 0;
+  let messageCount = 0;
+  if (ctx.tableExists(db, "chats")) {
+    chatCount = db.prepare("SELECT COUNT(*) AS n FROM chats WHERE agent_id=?").get(agent.id).n;
+    if (chatCount && ctx.tableExists(db, "chat_messages")) {
+      messageCount = db.prepare(
+        "SELECT COUNT(*) AS n FROM chat_messages WHERE chat_id IN (SELECT id FROM chats WHERE agent_id=?)",
+      ).get(agent.id).n;
+    }
+  }
+  if (chatCount && !consented) {
+    ctx.err(ko
+      ? `"${agent.slug}" 제거는 대화 ${chatCount}개와 메시지 ${messageCount}개를 함께 영구 삭제합니다 (데스크탑 앱과 공유하는 DB이며 되돌릴 수 없습니다).\n계속하려면: agentlas uninstall ${agent.slug} --yes`
+      : `Uninstalling "${agent.slug}" will also permanently delete ${chatCount} chat(s) and ${messageCount} message(s) (shared with the Desktop app; this cannot be undone).\nRe-run to confirm: agentlas uninstall ${agent.slug} --yes`);
+    return 1;
+  }
+
   let deleted = false;
   runWriteTransaction(db, () => {
     deleted = db.prepare("DELETE FROM installed_agents WHERE id=?").run(agent.id).changes > 0;
@@ -58,7 +88,11 @@ function run(ctx, args) {
         saveRoutes(routes);
       }
     } catch { /* 라우트 정리는 best-effort */ }
-    ctx.out(`${ctx.ui.green("✓")} ${ko ? "제거됨" : "Uninstalled"}: ${agent.slug}`);
+    // 실제로 무엇이 사라졌는지 성공 줄에 남긴다 — 조용한 파괴 금지.
+    const cascade = chatCount
+      ? (ko ? ` (대화 ${chatCount}개 · 메시지 ${messageCount}개 삭제됨)` : ` (deleted ${chatCount} chat(s), ${messageCount} message(s))`)
+      : "";
+    ctx.out(`${ctx.ui.green("✓")} ${ko ? "제거됨" : "Uninstalled"}: ${agent.slug}${cascade}`);
     return 0;
   }
   ctx.err(ko ? "제거하지 못했습니다." : "Nothing was uninstalled.");

package/engine/commands/version.cjs

@@ -1,8 +1,37 @@
 "use strict";
+/*
+ * version — 터미널 버전과 함께 **지금 붙어 있는 Agentlas-OS Core** 를 보고한다.
+ *
+ * 왜 Core 도 같이 찍나 (2026-07-28):
+ *   터미널의 계약 표면(build/upload/workforce/context/…)은 Core 릴리스가 소유한다.
+ *   Core 는 스스로 갱신되고(agentlas_cloud/update.py), 셸은 그때그때 해석된 루트에
+ *   붙는다. 그런데 `version`·`--where`·`doctor` 어디에서도 Core 를 찍지 않아서,
+ *   사용자도 지원 담당도 **어떤 Core 위에서 돌고 있는지 알 방법이 없었다**.
+ *   "최신인데 안 맞는다" 류의 오진이 그 공백에서 나온다. 붙은 대상을 보여주는 것이
+ *   진단의 출발점이다.
+ *
+ * Core 가 없어도 실패하지 않는다 — 56개 명령은 Core 없이 동작한다. 없으면 없다고
+ * 정직하게 적는다(조용한 생략 금지).
+ */
 const { readVersion } = require("../agentlas-banner.cjs");
 
+function coreLine() {
+  try {
+    const core = require("../agentlas-core-harness.cjs");
+    const root = core.resolveCoreRuntimeRoot();
+    if (!root) return "agentlas-os  not attached (install: hephaestus update)";
+    const version = core.readCoreRuntimeVersion(root);
+    // 버전을 못 읽는 루트는 "낡음"이 아니라 "모름"이다. 두 상태를 구분해 적는다 —
+    // 모름을 그럴듯한 값으로 메꾸면 그 순간 진단이 거짓이 된다.
+    return `agentlas-os  ${version || "unknown version"}  (${root})`;
+  } catch (error) {
+    return `agentlas-os  unavailable (${(error && error.message) || error})`;
+  }
+}
+
 function run(ctx) {
   ctx.out(`agentlas ${readVersion()}`);
+  ctx.out(coreLine());
   return 0;
 }
 

package/engine/commands/workforce.cjs

@@ -11,17 +11,12 @@
  * parity().cmdHep(["hep-network", ...]) 호환 탈출구였는데, 그 parity 모듈이 아직
  * v2에 없으므로 정직 정지로 안내만 한다(가짜 성공 금지).
  *
- * projectPath 에 대한 정직한 메모: v1은 ensureTerminalProjectForExecutionCli(db,
- * cwd, permission, "terminal-workforce")로 프로젝트 상태 머신을 돌려 활성 프로젝트
- * 경로를 만들었다. 그 프로젝트-상태 기계(폴더 방문 기록/활성화 판정)는 아직 v2로
- * 포팅되지 않았다. cmdWorkforce 가 projectPath 를 쓰는 곳은 buildChildEnv 의
- * 프로젝트 dotenv 스코핑뿐이고(agentlas-workforce.cjs 1926행) 부재 시 fail-closed
- * 의존이 없음을 확인했다 — 그래서 여기서는 cwd 를 projectPath 로 넘긴다(같은 폴더
- * 의 .env/.env.local 이 비신뢰 소스로 한 번 더 스캔될 뿐, 권한이 넓어지지 않는다).
- * 프로젝트-상태 모듈이 v2에 착륙하면 이 자리를 그 결과로 교체한다.
+ * Write-capable first contact bootstraps the exact current project through the
+ * canonical Core merge-only boundary. Read-only inspection remains passive.
  */
 const { workforceRuntime } = require("../workforce/deps.cjs");
 const { projectCwd } = require("../workforce/capture.cjs");
+const { ensureTerminalProjectForExecutionCli } = require("../project/state.cjs");
 
 function resolvePermission(ctx) {
   // v1 resolveTerminalPermission 포팅: 저장된 `full` 은 세션 한정 계약이라
@@ -70,11 +65,16 @@ async function dispatch(ctx, command, args) {
       const db = ctx.db();
       const cwd = projectCwd();
       const permission = resolvePermission(ctx);
+      const projectPath = ensureTerminalProjectForExecutionCli(
+        db,
+        cwd,
+        permission,
+        `terminal-${command}`,
+      ) || cwd;
       const runtime = workforceRuntime({ lang: ctx.lang, out: ctx.out });
       const result = await runtime.cmdWorkforce(db, rest, runtimeOverride, {
         cwd,
-        // v1 ensureTerminalProjectForExecutionCli 미포팅 — 위 파일 머리 주석 참조.
-        projectPath: cwd,
+        projectPath,
         permission,
       });
       return result && result.ok ? 0 : 1;

package/engine/core/schema-ensure.cjs

@@ -0,0 +1,75 @@
+"use strict";
+/*
+ * core/schema-ensure — 공유 SQLite 에 대한 스키마 보정을 **커넥션당 한 번만** 한다.
+ *
+ * 왜 (2026-07-28 실측):
+ *   `agentlas.sqlite` 는 데스크탑 앱과 공유하는 파일이다(제품 계약, `core/paths.cjs`).
+ *   그런데 터미널이 **매 턴** 그 파일에 DDL 을 날리고 있었다 —
+ *     · `ALTER TABLE memory_entries ADD COLUMN context_json` (사본 3벌)
+ *     · `CREATE TABLE IF NOT EXISTS terminal_memory_*` 4개 + 인덱스 5개
+ *   전부 `IF NOT EXISTS`/조건부라 결과는 멱등이지만, **쓰기 락을 잡는 것은 매번**이다.
+ *   데스크탑이 마이그레이션 트랜잭션 중이면 15초 busy_timeout 을 소진하고, 호출부가
+ *   전부 빈 catch 라 그 실패가 조용히 사라진다.
+ *
+ *   스키마 소유자는 데스크탑이다(`core/db.cjs:7-9`). 터미널의 이 보정은 "앱보다 먼저
+ *   깔린 DB" 같은 경우를 위한 안전망이지 상시 작업이 아니다. 프로세스가 사는 동안
+ *   한 번이면 충분하다.
+ *
+ * 왜 커넥션당인가 (프로세스당이 아니라):
+ *   테스트와 일부 명령이 임시 DB 를 따로 연다. 프로세스 단위로 기억하면 두 번째
+ *   DB 가 보정을 건너뛰어 조용히 깨진다. WeakMap 이면 커넥션이 사라질 때 같이 사라진다.
+ */
+const applied = new WeakMap();
+
+/**
+ * `key` 작업을 이 커넥션에서 아직 안 했으면 실행한다.
+ * 실패는 삼키되 **기억하지 않는다** — 다음 호출이 다시 시도할 수 있어야 한다.
+ * (일시적 락 경합으로 실패한 것을 "완료"로 기억하면 스키마가 영구히 안 맞는다.)
+ */
+function ensureOnce(db, key, fn) {
+  if (!db) return false;
+  let done = applied.get(db);
+  if (!done) {
+    done = new Set();
+    applied.set(db, done);
+  }
+  if (done.has(key)) return true;
+  try {
+    fn(db);
+    done.add(key);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function tableExists(db, name) {
+  try {
+    return Boolean(db.prepare("SELECT 1 FROM sqlite_master WHERE type='table' AND name=?").get(name));
+  } catch {
+    return false;
+  }
+}
+
+function columnExists(db, table, column) {
+  try {
+    return db.prepare(`PRAGMA table_info(${table})`).all().some((row) => row.name === column);
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * `memory_entries.context_json` 보정. 이전에는 이 함수가 세 파일에 각각 복제돼 있었고
+ * (`sessions/prompt.cjs`, `project/memory-context.cjs`, `memory-cli/curate.cjs`)
+ * 그중 하나는 매 턴 호출됐다. 하나로 합치고 커넥션당 1회로 줄인다.
+ */
+function ensureMemoryContextColumn(db) {
+  return ensureOnce(db, "memory_entries.context_json", (conn) => {
+    if (tableExists(conn, "memory_entries") && !columnExists(conn, "memory_entries", "context_json")) {
+      conn.exec("ALTER TABLE memory_entries ADD COLUMN context_json TEXT NOT NULL DEFAULT '{}'");
+    }
+  });
+}
+
+module.exports = { ensureOnce, ensureMemoryContextColumn, tableExists, columnExists };

package/engine/experience/variant.cjs

@@ -139,6 +139,37 @@ function resolveVariantCandidates(options) {
   };
 }
 
+/*
+ * usage/설명은 사람 출력 전용이다 — JSON 결과(schemaVersion v1)와 decision 어휘는
+ * 손대지 않는다. README·`agentlas help`가 광고하는 `agentlas variant resolve`는
+ * 인자 없이 부르면 항상 decision=error 로 끝나는데, 그동안 사람에게 보인 건
+ * 내부 enum 한 줄(`error: EXACT_BASE_RELEASE_REQUIRED`) 뿐이라 필요한 플래그
+ * 이름이 소스 주석에만 존재했다. 그래서 (1) error 코드마다 사람이 읽고 바로
+ * 고칠 수 있는 사유 + usage 를 붙이고, (2) help 서브커맨드를 뚫는다.
+ */
+const VARIANT_USAGE_LINES = Object.freeze([
+  "usage: agentlas variant resolve [candidates.json] [--base-release <agent-release-id>]",
+  "                                [--prefer <variant-id>] [--no-base-only] [--json]",
+  "  --base-release <id>  required: the exact base agent release to resolve against.",
+  "                       May instead come from candidates.json's baseAgentReleaseId.",
+  "  candidates.json      variant candidates: a JSON array, or {baseAgentReleaseId, candidates[]}.",
+  "  --prefer <id>        preferred variant; picking another one reports decision=fallback.",
+  "  --no-base-only       fail instead of falling back to the base release with no Experience Pack.",
+  "  --json               emit the agentlas.terminal-variant-resolution.v1 document.",
+  "Local advisory preview only: it never authorizes execution, rental, or reputation.",
+]);
+
+const VARIANT_ERROR_HINTS = Object.freeze({
+  EXACT_BASE_RELEASE_REQUIRED:
+    "no base agent release was given — pass --base-release <agent-release-id>, or a candidates.json carrying baseAgentReleaseId.",
+  NO_ELIGIBLE_VARIANT_AND_NO_BASE_FALLBACK:
+    "no candidate survived the checks above and --no-base-only forbids the base-only fallback.",
+});
+
+function variantUsage() {
+  return VARIANT_USAGE_LINES.join("\n");
+}
+
 function renderVariantResolution(result) {
   const lines = [
     `VARIANT RESOLUTION: ${result.decision}`,
@@ -148,17 +179,29 @@ function renderVariantResolution(result) {
   if (result.decision === "selected") lines.push(`selected: ${result.selectedVariantId}`);
   else if (result.decision === "fallback") lines.push(`fallback selected: ${result.selectedVariantId}`);
   else if (result.decision === "base-only") lines.push(`base-only: ${result.baseAgentReleaseId} (no Experience Pack attached)`);
-  else lines.push(`error: ${result.code}`);
+  else {
+    lines.push(`error: ${result.code}`);
+    const hint = VARIANT_ERROR_HINTS[result.code];
+    if (hint) lines.push(hint);
+  }
   if (result.fallbackOrder.length) lines.push(`next fallbacks: ${result.fallbackOrder.join(", ")}`);
   for (const excluded of result.excluded) lines.push(`excluded only ${excluded.variantId}: ${excluded.reasons.join(", ")}`);
   lines.push("Required MCP shortages exclude only the affected variant; they never create an agent-wide shortage.");
+  // 실패했을 때만 usage를 붙인다 — 성공 출력은 v1과 바이트 동일하게 유지한다.
+  if (result.decision === "error") lines.push("", variantUsage());
   return lines.join("\n");
 }
 
 function cmdVariant(options) {
   const args = options.args || [];
   const sub = args[0] || "resolve";
-  if (sub !== "resolve") throw new Error(`unknown variant subcommand: ${sub} (resolve)`);
+  // help 탈출구: 상위 라우터가 -h/--help 를 "help" 로 정규화하지만, 직접 호출도
+  // 받도록 셋 다 인정한다. usage는 성공(exit 0)이지 알 수 없는 서브커맨드가 아니다.
+  if (sub === "help" || sub === "--help" || sub === "-h") {
+    (options.out || console.log)(variantUsage());
+    return null;
+  }
+  if (sub !== "resolve") throw new Error(`unknown variant subcommand: ${sub} (resolve|help)`);
   const flags = parseSimpleFlags(args.slice(1));
   let candidates = [];
   let baseAgentReleaseId = flags["base-release"] || null;
@@ -192,5 +235,6 @@ module.exports = {
   validateVariantCandidate,
   resolveVariantCandidates,
   renderVariantResolution,
+  variantUsage,
   cmdVariant,
 };

package/engine/hephaestus/runtime.cjs

@@ -40,6 +40,13 @@ const USAGE = Object.freeze({
   call: 'usage: agentlas call "<agent-slugs>" "<context>"',
   connect: "usage: agentlas connect [status|telegram|help]",
   hep: "usage: agentlas hep <subcommand> [args]",
+  // 소스 스코프를 지키는 스태핑 표면 3종. 이름이 곧 계약이라 usage 도 스코프를
+  // 문장으로 적는다 — 이전에는 별칭이 스코프를 버려 hep-cloud 가 자산 보관함
+  // usage 를, hep-hub 가 검색 목록을 뱉었다(2026-07-28 수리).
+  "hep-network": 'usage: agentlas hep-network "<request>"  # Local + owner Cloud + public Hub, federated by Core',
+  "hep-local": 'usage: agentlas hep-local "<request>"   # registered Local agents only',
+  "hep-cloud": 'usage: agentlas hep-cloud "<request>"   # owner Agent Cloud agents only',
+  "hep-hub": 'usage: agentlas hep-hub "<request>"     # public Agentlas Hub agents only',
   hephaestus: "usage: agentlas hephaestus <subcommand> [args]",
   journal: "usage: agentlas journal <status|verify|repair|gate> --run-id <id> | --journal <path>",
   "legacy-network": 'usage: agentlas legacy-network "<request>"',

package/engine/memory-cli/curate.cjs

@@ -31,13 +31,9 @@ function loadArch() {
   return _arch;
 }
 
-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 { /* ignore */ }
-}
+// 사본 3벌을 하나로 합치고 커넥션당 1회로 줄였다 — 이 보정이 매 턴 공유 DB 에
+// 쓰기 락을 잡고 있었다(2026-07-28). 소유자는 데스크탑 스키마다.
+const { ensureMemoryContextColumn } = require("../core/schema-ensure.cjs");
 
 const SECRET_RE = [/\b(?:sk|pk|rk)-[A-Za-z0-9]{16,}/, /AKIA[0-9A-Z]{16}/, /ghp_[A-Za-z0-9]{20,}/, /xox[baprs]-[A-Za-z0-9-]{10,}/, /-----BEGIN [A-Z ]*PRIVATE KEY-----/, /\b(?:password|passwd|secret|api[_-]?key|access[_-]?token|bearer)\b\s*[:=]\s*\S+/i];
 

package/engine/project/memory-context.cjs

@@ -32,13 +32,9 @@ function sha(value) {
   return crypto.createHash("sha256").update(value).digest("hex");
 }
 
-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 { /* ignore */ }
-}
+// 사본 3벌을 하나로 합치고 커넥션당 1회로 줄였다 — 이 보정이 매 턴 공유 DB 에
+// 쓰기 락을 잡고 있었다(2026-07-28). 소유자는 데스크탑 스키마다.
+const { ensureMemoryContextColumn } = require("../core/schema-ensure.cjs");
 
 function prefsLangCli() {
   try {

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/sessions/orchestrator.cjs

@@ -117,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;
@@ -124,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

@@ -124,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();
@@ -196,6 +215,19 @@ class Session extends EventEmitter {
         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;

package/engine/storm/swarm.cjs

@@ -427,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

@@ -44,6 +44,13 @@ const SLASH_COMMANDS = [
   { 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" },
@@ -61,7 +68,11 @@ const SLASH_COMMANDS = [
   { command: "/variant", args: "resolve", ko: "로컬 변형 선택", en: "Local variant selection" },
   { command: "/memory", args: "<sub>", ko: "메모리", en: "Memory" },
   { command: "/evolve", args: "", ko: "프롬프트 진화 제안", en: "Prompt-evolution proposals" },
-  { command: "/ontology", args: "", ko: "프로젝트 지식", en: "Project knowledge" },
+  // 데스크탑의 `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" },
@@ -77,7 +88,8 @@ const SLASH_COMMANDS = [
   { command: "/update", args: "", ko: "npm 업데이트 확인", en: "npm update check" },
   { command: "/version", args: "", ko: "버전", en: "Version" },
   { command: "/logout", args: "", ko: "로그아웃", en: "Sign out" },
-  { command: "/uninstall", args: "<slug>", ko: "에이전트 제거", en: "Uninstall an agent" },
+  // 대화가 있으면 --yes 없이는 거절한다(챗/메시지 CASCADE 삭제) — 팔레트에도 노출.
+  { command: "/uninstall", args: "<slug> [--yes]", ko: "에이전트 제거", en: "Uninstall an agent" },
   { command: "/quit", args: "", ko: "종료", en: "Quit" },
   { command: "/exit", args: "", ko: "종료", en: "Quit" },
 ];

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

@@ -616,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;
     }