agentlas 1.0.47 → 1.0.49

package/engine/cloud-assets/package.cjs

@@ -37,14 +37,22 @@ const {
   normalizeCloudAssetDescriptor,
 } = require("../hub/install.cjs");
 const { SECRET_PATTERNS } = require("../agentlas-secret-patterns.cjs");
+const {
+  SECRET_SCAN_TEXT_EXTENSIONS,
+  UPLOAD_AGENT_DEFINITION_FILES,
+  UPLOAD_SKIP_DIRECTORIES,
+} = require("./upload-scan-catalog.generated.cjs");
 const { userDataDir } = require("../core/paths.cjs");
 const state = require("./state.cjs");
 const { cargoSearchAgents } = require("./cargo.cjs");
 const cas = require("./cas.cjs");
 
-const CLOUD_TEXT_EXTS = new Set([".cfg", ".cjs", ".conf", ".config", ".css", ".csv", ".env", ".html", ".ini", ".js", ".json", ".jsonl", ".md", ".mjs", ".properties", ".ps1", ".psd1", ".psm1", ".py", ".sh", ".toml", ".ts", ".tsx", ".txt", ".xml", ".yaml", ".yml"]);
-const CLOUD_AGENT_FILES = new Set(["AGENT.md", "AGENTS.md", "CLAUDE.md", "GEMINI.md", "README.md", "agent.md", "manifest.md", "system-prompt.md"]);
-const CLOUD_SKIP_DIRS = new Set([".git", ".next", ".studio-runtime", ".turbo", "build", "coverage", "dist", "node_modules", "out", "release"]);
+// 업로드/시크릿 스캔 어휘는 업로드 계약에서 온다. 세 제품이 각자 손으로 적어
+// 두었고 이미 갈려 있었다 — .bat/.cmd/.jsx 는 데스크탑만 스캔해서 서버 스캔과
+// 터미널 업로드가 그 파일들을 아예 열지 않았다.
+const CLOUD_TEXT_EXTS = new Set(SECRET_SCAN_TEXT_EXTENSIONS);
+const CLOUD_AGENT_FILES = new Set(UPLOAD_AGENT_DEFINITION_FILES);
+const CLOUD_SKIP_DIRS = new Set(UPLOAD_SKIP_DIRECTORIES);
 const CLOUD_BLOCKED_FILE_RE = [/^\.env(?:\..*)?$/i, /^id_rsa(?:\.pub)?$/i, /^credentials(?:\..*)?$/i, /^secrets?(?:\..*)?$/i, /^cloud-asset-state\.v1\.json$/i, /(?:^|[._-])service-account(?:[._-]|$)/i, /\.(?:key|pem|p12|pfx|mobileprovision)$/i];
 const CLOUD_ROUTING_CARD_PATH = ".agentlas/routing-card.json";
 const CLOUD_ROUTING_CARD_CAPABILITY_RE = /^[a-z][a-z0-9]*(_[a-z0-9]+)+$/;

package/engine/cloud-assets/upload-scan-catalog.generated.cjs

@@ -0,0 +1,102 @@
+// ⚠️ GENERATED FILE — do not hand-edit; the next generation erases your change.
+// 정본: agentlas/AgentsAtlas/app/src/lib/agentlas-cloud/upload-scan-catalog.json
+// 생성: (agentlas/AgentsAtlas/app) node scripts/gen-upload-scan-catalog.mjs
+//
+// Cloud-agent upload + secret-scan catalog. Three products used to restate
+// this by hand and drifted; the server-side scan was the one that lost.
+
+"use strict";
+
+const SECRET_SCAN_TEXT_EXTENSIONS = Object.freeze([
+  ".bat",
+  ".cfg",
+  ".cjs",
+  ".cmd",
+  ".conf",
+  ".config",
+  ".css",
+  ".csv",
+  ".env",
+  ".html",
+  ".ini",
+  ".js",
+  ".json",
+  ".jsonl",
+  ".jsx",
+  ".md",
+  ".mjs",
+  ".properties",
+  ".ps1",
+  ".psd1",
+  ".psm1",
+  ".py",
+  ".sh",
+  ".toml",
+  ".ts",
+  ".tsx",
+  ".txt",
+  ".xml",
+  ".yaml",
+  ".yml",
+]);
+
+const UPLOAD_SKIP_DIRECTORIES = Object.freeze([
+  ".git",
+  ".next",
+  ".studio-runtime",
+  ".turbo",
+  "build",
+  "coverage",
+  "dist",
+  "node_modules",
+  "out",
+  "release",
+]);
+
+const AGENT_DEFINITION_FILES = Object.freeze([
+  "AGENT.md",
+  "AGENTS.md",
+  "CLAUDE.md",
+  "GEMINI.md",
+  "README.md",
+  "agent.md",
+  "manifest.md",
+  "system-prompt.md",
+  "system.md",
+  "soul.md",
+  "prompt.md",
+  "persona.md",
+]);
+
+const UPLOAD_AGENT_DEFINITION_FILES = Object.freeze([
+  "AGENT.md",
+  "AGENTS.md",
+  "CLAUDE.md",
+  "GEMINI.md",
+  "README.md",
+  "agent.md",
+  "manifest.md",
+  "system-prompt.md",
+]);
+
+const FOLDER_SCAN_AGENT_DEFINITION_FILES = Object.freeze([
+  "AGENT.md",
+  "AGENTS.md",
+  "CLAUDE.md",
+  "GEMINI.md",
+  "agent.md",
+  "manifest.md",
+  "system-prompt.md",
+  "system.md",
+  "soul.md",
+  "prompt.md",
+  "persona.md",
+]);
+
+module.exports = {
+  SECRET_SCAN_TEXT_EXTENSIONS,
+  UPLOAD_SKIP_DIRECTORIES,
+  AGENT_DEFINITION_FILES,
+  UPLOAD_AGENT_DEFINITION_FILES,
+  FOLDER_SCAN_AGENT_DEFINITION_FILES,
+};

package/engine/commands/acp.cjs

@@ -0,0 +1,45 @@
+"use strict";
+/*
+ * acp — run Agentlas as an Agent Client Protocol agent on stdio (PRD 2026-08-15 B-3).
+ *
+ *   agentlas acp            start the ACP v1 agent server (stdin/stdout are the wire)
+ *   agentlas acp --info     print the registry-style descriptor and exit
+ *
+ * Register in an ACP client (Zed settings.json example):
+ *   "agent_servers": { "Agentlas": { "command": "agentlas", "args": ["acp"] } }
+ * JetBrains / other clients: same command + args. The client then runs Agentlas'
+ * project controller on the runtime you subscribe to — no keys leave your machine.
+ */
+const { AcpAgentServer, PROTOCOL_VERSION } = require("../acp/server.cjs");
+
+function descriptor() {
+  let version = "0.0.0";
+  try { version = require("../../package.json").version || version; } catch { /* keep */ }
+  return {
+    id: "agentlas",
+    name: "Agentlas",
+    version,
+    description: "Agentlas project controller over ACP — runs on the coding runtime you already subscribe to (Claude Code, Codex, Antigravity, ACP agents).",
+    protocolVersion: PROTOCOL_VERSION,
+    distribution: { npm: { package: `agentlas@${version}`, args: ["acp"] } },
+    authMethods: [],
+    capabilities: { loadSession: false, promptCapabilities: { image: false, audio: false, embeddedContext: true } },
+  };
+}
+
+async function run(ctx, args) {
+  if (args.includes("--info") || args.includes("--json")) {
+    ctx.out(JSON.stringify(descriptor(), null, 2));
+    return 0;
+  }
+  if (args.includes("--help") || args.includes("help")) {
+    ctx.out("Usage: agentlas acp [--info]\n  Speak the Agent Client Protocol (v1) on stdio so an editor can run Agentlas as its agent.");
+    return 0;
+  }
+  // stdout is the protocol wire from here on: route everything human to stderr.
+  const server = new AcpAgentServer({ ctx, input: process.stdin, output: process.stdout });
+  await server.start();
+  return 0;
+}
+
+module.exports = { run, descriptor };

package/engine/commands/billing.cjs

@@ -26,8 +26,8 @@ function usage(ko) {
       ? "  구독 계좌(A)와 렌트수익 계좌(B) 잔액을 표시합니다."
       : "  Shows the subscription account (A) and rental-earnings account (B) balances.",
     ko
-      ? "  크레딧은 Hub 에이전트 호출(공개 에이전트 3·팀 10, 활성 리스는 0)에 쓰입니다."
-      : "  Credits pay for Hub agent calls (public agent 3 · team 10; active leases cost 0).",
+      ? "  크레딧은 Hub 에이전트 호출에 작업당 쓰입니다(기본 공개 에이전트 3·팀 10, 크리에이터 가격이 있으면 그 가격). 활성 장기대여 중에는 0."
+      : "  Credits pay per work order for Hub agent calls (base: public agent 3 · team 10; creator-priced agents charge their price). 0 while a day-lease is active.",
     ko
       ? "  참고: 렌트수익(B) → 구독(A) 전송은 Agentlas Desktop 에서만 가능합니다 (터미널 전송 명령 없음)."
       : "  Note: earnings (B) → subscription (A) transfer is Desktop-only (no transfer command in the terminal).",

package/engine/commands/call.cjs

@@ -18,6 +18,10 @@ async function run(ctx, args) {
     ctx.err("✖ " + usageFor("call", ctx.lang));
     return 1;
   }
+  // 과금 사전 고지 — 가격은 서버가 청구 시 확정하므로 숫자를 지어내지 않는다.
+  ctx.out(ctx.lang !== "en"
+    ? "ℹ 공개 Hub 에이전트·팀 호출은 크레딧이 소모됩니다(활성 장기대여 중에는 0). 잔액 확인: agentlas billing"
+    : "ℹ Public Hub agent/team calls consume credits (0 while a day-lease is active). Check balance: agentlas billing");
   return create(ctx).cmdHep(["hep-call", ...args]);
 }
 

package/engine/commands/doctor.cjs

@@ -9,6 +9,7 @@ const fs = require("node:fs");
 const path = require("node:path");
 const { dbPath, userDataDir } = require("../core/paths.cjs");
 const { listAvailableCliRuntimes, activeRuntimeRow } = require("../runtimes/detect.cjs");
+const { RUNTIME_BIN } = require("../runtimes/kinds.cjs");
 const { runtimeAuthEvidence } = require("../runtimes/auth-evidence.cjs");
 const { sharedRuntimeKind } = require("../runtimes/resolve.cjs");
 const { resolvedModelRole } = require("../runtimes/roles.cjs");
@@ -106,7 +107,7 @@ async function run(ctx, args = []) {
       // 가 아니라 경고다. 흔적 없음 = 미로그인 "가능성"이므로 단정하지 않는다.
       const evidence = runtimeAuthEvidence(activeKind);
       if (evidence.status === "none") {
-        const bin = { "claude-code": "claude", codex: "codex", gemini: "gemini", agy: "agy" }[activeKind] || activeKind;
+        const bin = RUNTIME_BIN[activeKind] || activeKind;
         warn(
           en ? "active runtime" : "활성 런타임",
           en

package/engine/commands/index.cjs

@@ -34,6 +34,8 @@ const COMMANDS = {
   plugin: () => require("./plugin.cjs"),
   automation: () => require("./automation.cjs"),
   native: () => require("./native.cjs"),
+  // Agentlas as an ACP agent for editors (Zed, JetBrains, …) — PRD 2026-08-15 B-3.
+  acp: () => require("./acp.cjs"),
   multimodal: () => require("./multimodal.cjs"),
   document: () => require("./document.cjs"),
   workforce: () => require("./workforce.cjs"),

package/engine/commands/workforce.cjs

@@ -75,6 +75,11 @@ async function dispatch(ctx, command, args) {
         permission,
         `terminal-${command}`,
       ) || cwd;
+      // 과금 사전 고지 — 이 표면은 서버가 청구 시 확정하는 가격을 미리 모르므로
+      // 숫자를 지어내지 않고 사실만 말한다(공개 Hub 호출=크레딧 소모, 장기대여=0).
+      ctx.out(ctx.lang !== "en"
+        ? "ℹ 공개 Hub 에이전트·팀 호출은 크레딧이 소모됩니다(활성 장기대여 중에는 0). 잔액 확인: agentlas billing"
+        : "ℹ Public Hub agent/team calls consume credits (0 while a day-lease is active). Check balance: agentlas billing");
       const runtime = workforceRuntime({ lang: ctx.lang, out: ctx.out, uiInstance: ctx.uiInstance });
       const result = await runtime.cmdWorkforce(db, rest, runtimeOverride, {
         cwd,
@@ -124,6 +129,12 @@ async function dispatch(ctx, command, args) {
       const cwd = projectCwd();
       const permission = resolvePermission(ctx);
       const projectPath = ensureTerminalProjectForExecutionCli(db, cwd, permission, `terminal-${command}`) || cwd;
+      // 과금 사전 고지 — local 스코프는 원격 과금이 없다.
+      if (sourceScope !== "local") {
+        ctx.out(ko
+          ? "ℹ 공개 Hub 에이전트·팀 호출은 크레딧이 소모됩니다(활성 장기대여 중에는 0). 잔액 확인: agentlas billing"
+          : "ℹ Public Hub agent/team calls consume credits (0 while a day-lease is active). Check balance: agentlas billing");
+      }
       const { createLocalCoreHubTool } = require("../workforce/local-core-transport.cjs");
       const { createLocalCoreWorkforceRuntime } = require("../workforce/deps.cjs");
       const transport = createLocalCoreHubTool({ sourceScope, projectDir: projectPath, cwd });

package/engine/core/db.cjs

@@ -7,11 +7,17 @@
  * 스키마 소유권: 정본 스키마는 데스크탑 앱. 터미널은 bootstrap-schema.sql로
  * 첫 부트스트랩만 하고(런처가 수행), 이후 마이그레이션은 앱이 한다.
  * 터미널은 "있으면 쓰는" 방어적 열 확인(columnExists)으로만 전진 호환한다.
+ *
+ * ★2026-08-18: 위 문단은 계약이었지 배선이 아니었다. 이 파일은 user_version 을 **한 번도
+ * 읽지 않으면서** seedBuiltins 로 BEGIN IMMEDIATE 쓰기 트랜잭션을 열었다 — 검사도 거절도
+ * 없이 그냥 진행. 이제 openDb() 가 core/store-schema.cjs 로 버전을 확인하고, 낮으면
+ * 정직하게 거절한다(승급은 여전히 데스크탑의 일이다).
  */
 const fs = require("node:fs");
 const { configureSqliteConnection } = require("../agentlas-sqlite-policy.cjs");
 const { parseSemVer, compareSemVer } = require("../semver.cjs");
 const { dbPath } = require("./paths.cjs");
+const { assertStoreSchemaCompatible } = require("./store-schema.cjs");
 
 function loadNodeSqliteQuietly() {
   const originalEmitWarning = process.emitWarning;
@@ -44,16 +50,61 @@ function openRaw(file) {
   return db;
 }
 
+/**
+ * 이 프로세스가 마이그레이션 권위인가. 기본은 **아니다**(follower).
+ * `AGENTLAS_STORE_MIGRATION_ROLE=owner` 는 데스크탑이 없는 머신을 위한 명시적 탈출구다 —
+ * 사람이 일부러 켜야 하고, 그때만 벤더 코어의 사다리가 한 번 돈다.
+ */
+function storeMigrationRole() {
+  return String(process.env.AGENTLAS_STORE_MIGRATION_ROLE || "").trim().toLowerCase() === "owner"
+    ? "owner"
+    : "follower";
+}
+
 /**
  * DB 파일이 없으면 하드 실패한다. 부트스트랩은 런처(bin/agentlas.cjs)의 책임 —
  * 엔진이 임의 경로에 빈 DB를 만들면 데스크탑과의 공유 계약이 조용히 깨진다.
+ *
+ * 연 다음에는 스키마 버전을 **확인**한다. 낮으면 거절 — 조용히 진행하지 않는다.
+ * owner 로 명시 지정된 경우에만, 거절 대신 벤더 코어의 사다리를 한 번 돌려 승급한다.
  */
 function openDb() {
   const file = dbPath();
   if (!fs.existsSync(file)) {
     throw new Error(`Agentlas database not found: ${file} (run via bin/agentlas.cjs)`);
   }
-  return openRaw(file);
+  if (storeMigrationRole() === "owner") migrateSharedStoreAsOwner(file);
+  const db = openRaw(file);
+  try {
+    assertStoreSchemaCompatible(db, file);
+  } catch (e) {
+    try { db.close(); } catch { /* noop */ }
+    throw e;
+  }
+  return db;
+}
+
+/**
+ * 명시적 탈출구의 실행부. 데스크탑이 없는 머신에서 사람이 일부러 켰을 때만 불린다.
+ * 승급 자체는 여전히 **데스크탑 사다리 코드 하나**가 한다 — 터미널은 그 사다리를 손으로
+ * 복제하지 않는다(두 번째 사다리 구현이 곧 세 번째 주인이다). 코어가 없으면 정직한 실패.
+ */
+function migrateSharedStoreAsOwner(file) {
+  let core;
+  try {
+    core = require("./desktop-core.cjs").loadDesktopCore({ migrationRole: "owner" });
+  } catch (e) {
+    throw new Error(`AGENTLAS_STORE_MIGRATION_ROLE=owner: could not load the Desktop core to migrate ${file}: ${e && e.message ? e.message : e}`);
+  }
+  if (!core) {
+    throw new Error(
+      `AGENTLAS_STORE_MIGRATION_ROLE=owner: no Desktop core is available on this machine, so ${file} cannot be migrated here.\n` +
+      "Run `agentlas doctor`, or launch the Agentlas Desktop app once.",
+    );
+  }
+  if (core.error) {
+    throw new Error(`AGENTLAS_STORE_MIGRATION_ROLE=owner: Desktop core failed to migrate ${file}: ${core.error.message}`);
+  }
 }
 
 function tableExists(db, name) {
@@ -151,6 +202,7 @@ function seedBuiltins(db) {
 module.exports = {
   openDb,
   openRaw,
+  storeMigrationRole,
   tableExists,
   columnExists,
   runWriteTransaction,

package/engine/core/desktop-core.cjs

@@ -141,6 +141,25 @@ function installNativeModuleHook() {
   _nativeHookInstalled = true;
 }
 
+/**
+ * 코어의 initStore 를 부르기 전에, 공유 저장소의 user_version 을 **우리 드라이버로** 확인한다.
+ * 별도 커넥션을 잠깐 열고 닫을 뿐 아무것도 쓰지 않는다. 파일이 아직 없으면(첫 실행 부트스트랩
+ * 이전) 판단할 것이 없으므로 통과 — 코어가 만들게 둔다.
+ */
+function assertSharedStoreSchemaBeforeCoreInit() {
+  const file = process.env.AGENTLAS_STORE_PATH || dbPath();
+  if (!fs.existsSync(file)) return;
+  const { openRaw } = require("./db.cjs");
+  const { assertStoreSchemaCompatible } = require("./store-schema.cjs");
+  let probe = null;
+  try {
+    probe = openRaw(file);
+    assertStoreSchemaCompatible(probe, file);
+  } finally {
+    try { probe && probe.close(); } catch { /* noop */ }
+  }
+}
+
 let _cache = undefined;
 
 /**
@@ -148,8 +167,22 @@ let _cache = undefined;
  *  · require(rel): 코어 안의 임의 컴파일 모듈을 상대경로로 로드(예: "store/automations").
  *  · runGraph: electron/workflow/run-graph.js 의 runGraph(automation, graph, opts).
  * 공유 DB(AGENTLAS_STORE_PATH)를 코어 로드 전에 반드시 세팅한다 — store/db 가 모듈 로드 시 읽는다.
+ *
+ * ★마이그레이션 권위 (Phase 0, docs/DAEMON-ARCHITECTURE-DESIGN-2026-08-18.md §2/§6).
+ *
+ * 여기가 **두 번째 마이그레이션 주인**이었다. 이 셰임은 isPackaged:true 를 보고해
+ * (설계상) db.ts 의 개발 샌드박스 가드를 무력화하고, 공유 라이브 파일에 데스크탑과
+ * 같은 사다리를 돌렸다. 락이 없는 파일에서 두 프로세스가 사다리를 겹쳐 도는 것이
+ * 정확히 run_events + 인덱스 4개를 malformed 로 만든 경로다.
+ *
+ * **선택: (a) 사다리를 돌리지 않는다.** initStore 를 follower 로 부른다 — 코어는 열고
+ * 확인만 하며, 낮으면 정직하게 거절한다. (b)("데스크탑이 없으면 터미널이 주인")를 고르지
+ * 않은 이유: 데스크탑의 부재는 경합 없이 관측할 수 없다. 터미널이 사다리를 도는 중에
+ * 데스크탑이 켜질 수 있고, 틀렸을 때의 비용이 비대칭이다(손상 vs 앱 한 번 실행).
+ * 데스크탑이 정말 없는 머신은 `AGENTLAS_STORE_MIGRATION_ROLE=owner` 로 **사람이 일부러**
+ * 한 번 켠다 — 사고로 되는 일과 적어서 되는 일은 달라야 한다.
  */
-function loadDesktopCore() {
+function loadDesktopCore(options = {}) {
   if (_cache !== undefined) return _cache;
   const root = findCoreRoot();
   if (!root) { _cache = null; return null; }
@@ -157,13 +190,30 @@ function loadDesktopCore() {
   installNativeModuleHook();
   // 코어의 store 가 이 값을 모듈 로드 시점에 읽는다 — require 이전에 세팅해야 한다.
   if (!process.env.AGENTLAS_STORE_PATH) process.env.AGENTLAS_STORE_PATH = dbPath();
+  const migrationRole = options.migrationRole
+    || (String(process.env.AGENTLAS_STORE_MIGRATION_ROLE || "").trim().toLowerCase() === "owner"
+      ? "owner"
+      : "follower");
   const req = (rel) => require(path.join(root, "electron", rel.replace(/\.js$/, "") + ".js"));
   let kernel;
   try {
+    const store = req("store/db");
+    if (migrationRole === "follower") {
+      // 옛 벤더 번들은 이 계약을 모른다(옵션·env 를 무시하고 사다리를 돈다). 조용히 넘어가지
+      // 않고 무엇이 위험한지 말한다 — `npm run vendor:core` 로 갱신하면 사라진다.
+      if (typeof store.STORE_SCHEMA_VERSION !== "number") {
+        console.warn(
+          "[store] vendored Desktop core predates the single-migration-authority contract "
+          + "(no STORE_SCHEMA_VERSION export); it may migrate the shared database. "
+          + "Refresh it with `npm run vendor:core`.",
+        );
+      }
+      // 코어를 부르기 **전에** 우리 쪽에서 먼저 확인한다 — 옛 코어가 옵션을 무시해도
+      // 최소한 낮은 스키마에서는 사다리에 닿지 않는다.
+      assertSharedStoreSchemaBeforeCoreInit();
+    }
     // 데스크탑은 app.whenReady 에서 initStore() 를 부른다 — 터미널도 코어를 쓰기 전에 부른다.
-    // initStore 가 스키마 마이그레이션까지 소유하므로(데스크탑과 같은 정본 스키마) 공유 DB 는
-    // 언제나 코어가 기대하는 모양이 된다. 이것이 "재구현"이 아니라 "재사용"의 핵심.
-    req("store/db").initStore();
+    store.initStore({ migrationRole });
     kernel = req("workflow/run-graph");
   } catch (e) { _cache = { root, error: e }; return _cache; }
   _cache = {
@@ -178,6 +228,58 @@ function loadDesktopCore() {
   return _cache;
 }
 
+/**
+ * 코어의 공용 ACP 러너(electron/runtime/acp.js)만 가볍게 로드한다 (PRD 2026-08-15 T-2).
+ * initStore·그래프 커널을 끌지 않고, electron 셰임과 네이티브 모듈 훅만 건 뒤 require 한다 —
+ * kimi/grok/cursor 실행에 DB가 필요 없기 때문. 코어가 없거나 acp.js가 없는 옛 코어면
+ * { error } 를 준다(정직한 부재; 조용한 폴백 금지).
+ */
+let _acpCache = undefined;
+function loadCoreAcpRuntime() {
+  if (_acpCache !== undefined) return _acpCache;
+  const root = findCoreRoot();
+  if (!root) { _acpCache = null; return null; }
+  const file = path.join(root, "electron", "runtime", "acp.js");
+  if (!fs.existsSync(file)) { _acpCache = { root, error: new Error("desktop core predates the ACP runner (no electron/runtime/acp.js)") }; return _acpCache; }
+  try {
+    installRetiredProjectProvisioningHook();
+    installNativeModuleHook();
+    const mod = require(file);
+    _acpCache = { root, module: mod };
+  } catch (e) {
+    _acpCache = { root, error: e };
+  }
+  return _acpCache;
+}
+
+/**
+ * 코어의 **공유 순수 모듈**(dist/shared/*)만 가볍게 로드한다 (예: "agent-control-blocks").
+ * shared/* 는 electron·DB 의존이 없는 순수 함수 모듈이라 initStore·그래프 커널·셰임 없이
+ * require 만 한다. 코어가 없으면 null, 그 모듈이 없는 옛 벤더 번들이면 { root, error } —
+ * 정직한 부재(조용한 폴백 금지는 호출부 계약; 표시 경로는 fail-open 해도 된다).
+ */
+const _sharedCache = new Map();
+function loadCoreShared(rel) {
+  const key = String(rel || "").replace(/\.js$/, "");
+  if (_sharedCache.has(key)) return _sharedCache.get(key);
+  let result = null;
+  const root = findCoreRoot();
+  if (root) {
+    const file = path.join(root, "shared", key + ".js");
+    if (!fs.existsSync(file)) {
+      result = { root, error: new Error(`desktop core has no shared/${key}.js (older vendor bundle)`) };
+    } else {
+      try {
+        result = { root, module: require(file) };
+      } catch (e) {
+        result = { root, error: e };
+      }
+    }
+  }
+  _sharedCache.set(key, result);
+  return result;
+}
+
 /** 재사용 코어가 이 머신에서 가용한가(정직한 가부). */
 function desktopCoreAvailable() {
   const c = loadDesktopCore();
@@ -202,6 +304,8 @@ async function loadDesktopCoreAsync({ onNotice } = {}) {
 module.exports = {
   findCoreRoot,
   loadDesktopCore,
+  loadCoreAcpRuntime,
+  loadCoreShared,
   loadDesktopCoreAsync,
   desktopCoreAvailable,
   _test: { stripRetiredProjectProvisioningSource },

package/engine/core/store-schema.cjs

@@ -0,0 +1,119 @@
+"use strict";
+/*
+ * core/store-schema — 공유 저장소의 **스키마 버전 계약**. 터미널은 읽기만 한다.
+ *
+ * ★단일 마이그레이션 권위 (Phase 0, docs/DAEMON-ARCHITECTURE-DESIGN-2026-08-18.md §2/§6).
+ *
+ * `~/Library/Application Support/Agentlas/agentlas.sqlite` 는 락 없는 다중 쓰기 파일인데
+ * 마이그레이션 주인이 **둘**이었다:
+ *   1) 데스크탑의 사다리(electron/store/db.ts SCHEMA_VERSION),
+ *   2) 그 사다리를 그대로 다시 도는 터미널의 벤더 코어 경로(core/desktop-core.cjs initStore).
+ * 그리고 터미널의 가벼운 드라이버(core/db.cjs)는 user_version 을 **읽지도 않으면서** 쓰기
+ * 트랜잭션(seedBuiltins → BEGIN IMMEDIATE)을 열었다. 즉 "검사 없음 + 거절 없음 + 쓰기 있음".
+ *
+ * 이제 규칙은 하나다: **터미널은 절대 승급하지 않는다.** 파일이 이 배포가 아는 버전보다
+ * 낮으면 조용히 진행하지도, 몰래 마이그레이션하지도 않고 **정직하게 거절**한다.
+ *
+ * 왜 "없으면 터미널이 주인" 이 아닌가: 데스크탑의 부재는 경합 없이 관측할 수 없다 —
+ * 터미널이 사다리를 도는 도중에 데스크탑이 켜질 수 있다. 잘못 추측한 비용은 117MB 저장소
+ * 손상(db.ts 의 run_events 사고 주석)이고, 거절의 비용은 데스크탑 한 번 실행이다.
+ *
+ * 기대 버전의 출처: 이 패키지가 함께 배포하는 engine/bootstrap-schema.sql 의
+ * `PRAGMA user_version=` 이 곧 "이 배포가 아는 사다리 머리"다. 그 파일은 데스크탑 사다리를
+ * 빈 DB 에 끝까지 돌려 생성한 것이므로(scripts/gen-bootstrap-schema.cjs) 손으로 맞출 숫자가
+ * 따로 없다 — 재생성하면 자동으로 같이 움직인다.
+ */
+const fs = require("node:fs");
+const path = require("node:path");
+
+const BOOTSTRAP_SCHEMA_FILE = path.join(path.dirname(__dirname), "bootstrap-schema.sql");
+
+let _expected;
+
+/** 이 배포가 아는 스키마 버전. 부트스트랩 SQL 헤더에서 읽는다(정본은 데스크탑 사다리). */
+function expectedStoreSchemaVersion() {
+  if (_expected !== undefined) return _expected;
+  let header = "";
+  try {
+    const fd = fs.openSync(BOOTSTRAP_SCHEMA_FILE, "r");
+    try {
+      const buf = Buffer.alloc(4096);
+      const read = fs.readSync(fd, buf, 0, buf.length, 0);
+      header = buf.slice(0, read).toString("utf8");
+    } finally {
+      fs.closeSync(fd);
+    }
+  } catch {
+    header = "";
+  }
+  const match = /PRAGMA\s+user_version\s*=\s*(\d+)/i.exec(header);
+  // 부트스트랩 SQL 을 못 읽으면 기대 버전을 **모른다**. 0 은 "검사 불가"를 뜻하고,
+  // 아래 단언은 그때 통과시킨다 — 모르는 것을 근거로 사용자를 막지 않는다.
+  _expected = match ? Number(match[1]) : 0;
+  return _expected;
+}
+
+/** 열린 커넥션의 user_version. 못 읽으면 null(모름). */
+function readStoreSchemaVersion(db) {
+  try {
+    if (typeof db.pragma === "function") {
+      const value = db.pragma("user_version", { simple: true });
+      return Number.isFinite(Number(value)) ? Number(value) : null;
+    }
+    const row = db.prepare("PRAGMA user_version").get();
+    if (!row) return null;
+    const value = row.user_version ?? Object.values(row)[0];
+    return Number.isFinite(Number(value)) ? Number(value) : null;
+  } catch {
+    return null;
+  }
+}
+
+/** 정직하고 실행 가능한 거절문. 두 가지 해결책을 모두 이름으로 말한다. */
+function storeSchemaRefusalMessage(found, expected, file) {
+  return [
+    `Agentlas store schema is v${found}, but this Agentlas CLI needs v${expected}.`,
+    `Store: ${file}`,
+    "The Agentlas CLI never migrates the shared database — the Desktop app owns the migration ladder,",
+    "and a second migrator on this lock-free file is how the store was corrupted before.",
+    "",
+    "Fix it once, either way:",
+    "  • Launch (or update) the Agentlas Desktop app once, then re-run this command.",
+    "  • No Desktop app on this machine? Close every Agentlas process, then run this command once with",
+    "    AGENTLAS_STORE_MIGRATION_ROLE=owner set, so the upgrade is a deliberate act rather than a race.",
+  ].join("\n");
+}
+
+class StoreSchemaTooOldError extends Error {
+  constructor(found, expected, file) {
+    super(storeSchemaRefusalMessage(found, expected, file));
+    this.name = "StoreSchemaTooOldError";
+    this.code = "AGENTLAS_STORE_SCHEMA_TOO_OLD";
+    this.found = found;
+    this.expected = expected;
+    this.file = file;
+  }
+}
+
+/**
+ * 공유 저장소를 이 프로세스가 써도 되는가.
+ * 낮으면 던진다. 같거나 높으면 통과 — 더 높은 것은 데스크탑이 앞서간 것이고, 터미널은
+ * columnExists 기반 방어적 읽기로 전진 호환한다(기존 계약 유지).
+ */
+function assertStoreSchemaCompatible(db, file) {
+  const expected = expectedStoreSchemaVersion();
+  if (!expected) return; // 기대 버전을 모르면 막지 않는다.
+  const found = readStoreSchemaVersion(db);
+  if (found === null) return; // 읽을 수 없으면 판단하지 않는다(가짜 거절 금지).
+  if (found >= expected) return;
+  throw new StoreSchemaTooOldError(found, expected, file);
+}
+
+module.exports = {
+  BOOTSTRAP_SCHEMA_FILE,
+  StoreSchemaTooOldError,
+  assertStoreSchemaCompatible,
+  expectedStoreSchemaVersion,
+  readStoreSchemaVersion,
+  storeSchemaRefusalMessage,
+};

package/engine/firms/orchestrate.cjs

@@ -68,6 +68,26 @@ function loadDelegateParser() {
   return parseDelegationsLocal;
 }
 
+/*
+ * 제어 블록 스트리퍼 정본 — 벤더 코어의 shared/agent-control-blocks
+ * (Desktop·Mobile 과 같은 규칙). 옛 벤더 번들이라 없으면 null — cleanFenceText 는
+ * 종전 규칙만으로 fail-open 한다(원문 파괴보다 마커 잔존이 낫다).
+ */
+let _stripCanonical; // undefined=미시도 · null=정본 없음 · function=정본
+function loadCanonicalStripper() {
+  if (_stripCanonical === undefined) {
+    try {
+      const loaded = require("../core/desktop-core.cjs").loadCoreShared("agent-control-blocks");
+      _stripCanonical = loaded && loaded.module && typeof loaded.module.stripAgentControlBlocks === "function"
+        ? loaded.module.stripAgentControlBlocks
+        : null;
+    } catch {
+      _stripCanonical = null;
+    }
+  }
+  return _stripCanonical;
+}
+
 /** 표시/전달용 텍스트에서 제어 펜스를 제거한다(파싱만 — 부작용 없음). 실패 시 원문. */
 function cleanFenceText(text) {
   const raw = String(text || "");
@@ -79,8 +99,18 @@ function cleanFenceText(text) {
     }
   } catch { /* fences 미존재/파서 실패 — 원문 보존 */ }
   if (cleaned == null) cleaned = parseDelegationsLocal(raw).cleanedText;
+  // HTML 주석 봉투는 정본보다 먼저 — 정본이 헤딩만 도려내면 주석 껍데기가 남는다.
+  cleaned = cleaned.replace(/<!--\s*[\s\S]*?## Memory Events[\s\S]*?-->/gi, "");
+  // 정본 스트리퍼(settled 모드): 손코딩이 몰랐던 <<agentlas-ask>>·surface·followups·
+  // goal-complete 마커와 잔여 헤딩까지 Desktop 과 같은 규칙으로 지운다.
+  const strip = loadCanonicalStripper();
+  if (strip) {
+    try {
+      cleaned = strip(cleaned, { streaming: false });
+    } catch { /* 정본 실패 — 종전 규칙만으로 fail-open */ }
+  }
+  // 터미널 고유 정제(정본 범위 밖): 스킬 나레이션·오케스트레이터 헤더·판정 태그.
   return cleaned
-    .replace(/<!--\s*[\s\S]*?## Memory Events[\s\S]*?-->/gi, "")
     .replace(/^\s*(?:사용 스킬|Skills used)\s*:[^\n.!?]*[.!?]?\s*(?:(?:이유|Reason)\s*:[^.!?]*[.!?]\s*)?/i, "")
     .replace(/^\s*I(?:'|’)m using (?:the )?`?[^`.\n]+`? skill because [^.]*\.\s*/i, "")
     .replace(/^\s*Execution mode:\s*`?appbridge-ceo-orchestrator`?[^\n]*\n?/gim, "")
@@ -485,6 +515,7 @@ async function runFirmTurn(p) {
 module.exports = {
   runFirmTurn,
   parseDelegationsLocal,
+  cleanFenceText,
   buildDelegateProtocol,
   matchTargets,
   resolveDivisions,