agentlas 1.0.48 → 1.0.50

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/graph.cjs

@@ -506,6 +506,47 @@ async function runGraph(ctx, needle, flags) {
     return 1;
   }
 
+  const fallbackRow = {
+    id: row.id,
+    name: row.name,
+    scheduleHuman: row.schedule,
+    targetType: row.target_type,
+    targetId: row.target_id,
+    enabled: Boolean(row.enabled),
+    createdBy: row.created_by || "terminal",
+    graph,
+  };
+  const initialVars = requirement && flags.input ? { [requirement.varName]: flags.input } : {};
+
+  /*
+   * ★데몬 우선 (Phase 3). 데몬이 떠 있으면 이 터미널은 코어를 **로드하지 않는다** —
+   * 64MB 벤더 사본도, 두 번째 DB 주인도 그 순간에는 없다. 그래프 실행은 완주 후
+   * 결과 JSON 하나라 요청/응답 소켓으로 손실 없이 옮겨진다.
+   *
+   * 데몬이 있는데 실행이 **실패한 것**은 폴백 사유가 아니다 — 같은 그래프를 코어로
+   * 다시 돌리면 부작용(외부 게시·파일 쓰기)이 두 번 난다. 폴백은 "데몬 없음"에만 걸린다.
+   */
+  const daemon = require("../core/daemon-client.cjs");
+  if (await daemon.daemonAvailable()) {
+    try {
+      const result = await daemon.callDaemon("graph.run", {
+        automationId: row.id,
+        automation: fallbackRow,
+        graph,
+        initialVars,
+      }, 30 * 60 * 1000);
+      ctx.out(JSON.stringify(result, null, 2));
+      return result && result.ok === true ? 0 : 1;
+    } catch (error) {
+      ctx.err(JSON.stringify({
+        ok: false,
+        via: "daemon",
+        error: error instanceof Error ? error.message : String(error),
+      }, null, 2));
+      return 1;
+    }
+  }
+
   const core = ctx.desktopCore || desktopCore.loadDesktopCore();
   if (!core || core.error || typeof core.runGraph !== "function") {
     const cause = core?.error instanceof Error ? core.error.message : "vendored Desktop Core is unavailable";
@@ -518,18 +559,8 @@ async function runGraph(ctx, needle, flags) {
       ? core.require("store/automations").getAutomation(row.id)
       : null;
   } catch { /* test/fallback row below */ }
-  automation ||= {
-    id: row.id,
-    name: row.name,
-    scheduleHuman: row.schedule,
-    targetType: row.target_type,
-    targetId: row.target_id,
-    enabled: Boolean(row.enabled),
-    createdBy: row.created_by || "terminal",
-    graph,
-  };
+  automation ||= fallbackRow;
   automation.graph = graph;
-  const initialVars = requirement && flags.input ? { [requirement.varName]: flags.input } : {};
   try {
     const result = await core.runGraph(automation, graph, { initialVars });
     ctx.out(JSON.stringify(result, null, 2));

package/engine/commands/roles.cjs

@@ -17,6 +17,7 @@
  */
 const { RUNTIME_BIN, whichSync } = require("../runtimes/detect.cjs");
 const { runtimeAuthEvidence } = require("../runtimes/auth-evidence.cjs");
+const { canonicalRuntimeKind, storedRuntimeKind } = require("../runtimes/kinds.cjs");
 const { MODEL_ROLE_TABLE, VALID_ROLES, resolvedModelRole, roleMembers } = require("../runtimes/roles.cjs");
 const { runWriteTransaction } = require("../agentlas-sqlite-policy.cjs");
 const { EFFORTS } = require("../agentlas-workload-routing.cjs");
@@ -137,11 +138,13 @@ function set(ctx, args) {
     if (existing) {
       // kind가 바뀌면 이전 모델 id는 새 런타임의 어휘가 아니다(예: kimi에 opus).
       // --model 미지정 시 유지가 아니라 초기화 — 무의미한 좌표를 승계하지 않는다.
-      const keepModel = existing.kind === kind ? existing.model : null;
+      const keepModel = canonicalRuntimeKind(existing.kind) === kind ? existing.model : null;
       db.prepare(
         "UPDATE model_roles SET kind=?, model=?, effort=?, inherit=?, updated_at=? WHERE role=?",
       ).run(
-        kind,
+        // 공유 DB 는 데스크탑 어휘로 적는다(runtimes/kinds.cjs) — 여기서 이 저장소의
+        // 이름을 그대로 넣으면 데스크탑이 그 역할을 못 읽는다.
+        storedRuntimeKind(kind),
         model === undefined ? keepModel : model,
         flags.effort === undefined ? existing.effort : (flags.effort === "none" ? null : flags.effort),
         inherit,
@@ -151,7 +154,7 @@ function set(ctx, args) {
     } else {
       db.prepare(
         "INSERT INTO model_roles (role, kind, model, effort, inherit, updated_at) VALUES (?,?,?,?,?,?)",
-      ).run(role, kind, model === undefined ? null : model, flags.effort === undefined || flags.effort === "none" ? null : flags.effort, inherit, now);
+      ).run(role, storedRuntimeKind(kind), model === undefined ? null : model, flags.effort === undefined || flags.effort === "none" ? null : flags.effort, inherit, now);
     }
   });
 

package/engine/core/daemon-client.cjs

@@ -0,0 +1,121 @@
+"use strict";
+/*
+ * core/daemon-client — 같은 머신의 Agentlas 데몬(agentlasd)에 일을 시키는 클라이언트.
+ *
+ * ★왜 있나 (데몬 Phase 3). 이 터미널은 지금 데스크탑 코어를 **자기 프로세스에서**
+ * 돌린다 — 64MB 벤더 사본을 로드하고, 같은 DB 를 여는 두 번째 주인이 된다. 데몬이
+ * 떠 있으면 그럴 이유가 없다: "이거 해 줘" 한 줄이면 되고, 코어는 한 곳에서만 돈다.
+ *
+ * 프로토콜은 데몬 쪽(electron/daemon/control-socket.ts)과 같은 줄 단위 JSON-RPC.
+ * 주소 규칙도 같은 계산이다 — userDataDir()/daemon.sock (Windows 는 named pipe).
+ * **이 두 파일의 주소 계산이 어긋나면 서로를 영영 못 찾는다.** 여기 경로는
+ * core/paths.cjs 의 userDataDir 를 쓰므로, 데스크탑 앱과 같은 곳을 본다.
+ *
+ * 데몬이 없으면? 없다고 답할 뿐이다. 호출자는 예전처럼 벤더 코어로 폴백한다 —
+ * 데몬은 빠른 길이지 유일한 길이 아니다(그게 유일한 길이 되는 순간, 데몬이 죽으면
+ * 터미널 전체가 죽는다).
+ */
+const net = require("node:net");
+const crypto = require("node:crypto");
+const path = require("node:path");
+const { userDataDir } = require("./paths.cjs");
+
+/** 데몬 소켓 주소 — control-socket.ts 의 defaultControlSocketPath 와 같은 규칙. */
+function daemonSocketPath() {
+  const dir = userDataDir();
+  if (process.platform === "win32") {
+    const tag = Buffer.from(dir).toString("base64url").slice(-16);
+    return `\\\\.\\pipe\\agentlas-daemon-${tag}`;
+  }
+  // ★유닉스 소켓 경로 ~104바이트 한계(sockaddr_un). 실측: 128바이트에서 bind 는
+  // 조용히 지나가고 connect 만 EINVAL — 데몬 쪽(control-socket.ts)과 같은 폴백 규칙.
+  const preferred = path.join(dir, "daemon.sock");
+  if (Buffer.byteLength(preferred, "utf8") <= 100) return preferred;
+  const tag = crypto.createHash("sha256").update(dir).digest("hex").slice(0, 16);
+  return path.join(require("node:os").tmpdir(), `agentlas-daemon-${tag}.sock`);
+}
+
+/** JSON-RPC 한 번. 데몬이 에러를 주면 그 문장 그대로 throw 한다. */
+function callDaemon(method, params, timeoutMs) {
+  const limit = Number.isFinite(timeoutMs) && timeoutMs > 0 ? timeoutMs : 120000;
+  return new Promise((resolve, reject) => {
+    const socket = net.connect(daemonSocketPath());
+    const id = crypto.randomUUID();
+    let buffer = "";
+    let settled = false;
+    const finish = (fn) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      socket.destroy();
+      fn();
+    };
+    const timer = setTimeout(
+      () => finish(() => reject(new Error(`daemon did not answer ${method} within ${limit}ms`))),
+      limit,
+    );
+    socket.on("connect", () => socket.write(`${JSON.stringify({ id, method, params })}\n`));
+    socket.on("data", (chunk) => {
+      buffer += chunk.toString("utf8");
+      let nl;
+      while ((nl = buffer.indexOf("\n")) >= 0) {
+        const line = buffer.slice(0, nl).trim();
+        buffer = buffer.slice(nl + 1);
+        if (!line) continue;
+        let message;
+        try { message = JSON.parse(line); } catch { continue; }
+        if (message.id !== id) continue;
+        if (message.error) finish(() => reject(new Error(message.error.message || "daemon error")));
+        else finish(() => resolve(message.result));
+      }
+    });
+    socket.on("error", (error) => finish(() => reject(error)));
+  });
+}
+
+/**
+ * 데몬이 지금 떠서 답하는가. **접속이 아니라 응답**으로 판정한다 — 죽은 데몬이 남긴
+ * 소켓 파일에는 접속 자체가 실패하고, 산 데몬이라도 멎어 있으면 쓸 수 없다.
+ */
+async function daemonAvailable() {
+  try {
+    const pong = await callDaemon("daemon.ping", undefined, 2000);
+    if (!pong || pong.ok !== true) return false;
+    return sharesOurStore(pong);
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * 데몬이 **우리와 같은 DB** 를 열었는가.
+ *
+ * ★`AGENTLAS_STORE_PATH` 는 이 프로세스에만 있다 — 소켓 너머 데몬은 그 값을 모른다.
+ *   그래서 사본을 지정해 놓고 일을 넘기면, 우리는 사본에 자동화를 만들고 데몬은
+ *   **라이브에** 실행 기록·부수효과를 남긴다. 둘 다 "성공" 이라고 답하는데 결과는
+ *   두 데이터베이스에 반씩 흩어진다. 넘기기 전에 물어보고, 다르면 넘기지 않는다.
+ *
+ *   경로를 못 받는 옛 데몬은 예전처럼 신뢰한다 — 그때는 양쪽 다 기본 경로였다.
+ *   우리가 경로를 명시했는데 상대가 답을 못 하면, 그건 확인할 수 없는 상태이므로 거절한다.
+ */
+function sharesOurStore(pong) {
+  const ours = String(process.env.AGENTLAS_STORE_PATH || "").trim();
+  if (!ours) return true;
+  const theirs = typeof pong.storePath === "string" ? pong.storePath.trim() : "";
+  if (!theirs) {
+    console.error(
+      "[daemon] AGENTLAS_STORE_PATH is set here, but the daemon does not report which database it opened.\n"
+      + "[daemon] Running the graph locally instead, so the work cannot land in a different store.",
+    );
+    return false;
+  }
+  const path = require("node:path");
+  if (path.resolve(theirs) === path.resolve(ours)) return true;
+  console.error(
+    `[daemon] the daemon opened a different database (${theirs}) than this command (${ours}).\n`
+    + "[daemon] Running the graph locally instead, so the work cannot land in a different store.",
+  );
+  return false;
+}
+
+module.exports = { daemonSocketPath, callDaemon, daemonAvailable, sharesOurStore };

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,70 @@ 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();
+  /*
+   * ★AGENTLAS_STORE_PATH 를 존중한다 — 이 줄이 없어서 CLI 는 무슨 값을 주든 **항상 라이브
+   *   DB** 를 열었다. 실측 2026-08-19: 복사본 스토어를 지정하고 `graph new` 로 자동화를
+   *   만들었는데 사용자의 라이브 데이터베이스에 저장됐다. 벤더 코어(desktop-core.cjs:150)
+   *   와 데스크탑(store/db)은 이 환경변수를 이미 존중하므로, 이 모듈만 어긋나 있었다.
+   *
+   *   그 결과 (1) 격리 QA 가 불가능하고 (2) 같은 명령이 여는 파일이 코어 경로냐 이 경로냐에
+   *   따라 갈린다 — 같은 프로세스가 두 DB 를 동시에 보게 된다.
+   */
+  const file = process.env.AGENTLAS_STORE_PATH || 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 +211,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 = {

package/engine/core/keychain-read.cjs

@@ -0,0 +1,69 @@
+"use strict";
+/*
+ * core/keychain-read — 키체인 읽기를 "죽일 수 있는 곳"에서 한다.
+ *
+ * ★이 저장소는 이 함정을 이미 한 번 만났다: telegram/connect.cjs 는 "standalone Node 에서
+ *   keytar 는 macOS 키체인에 막혀 멈추므로" 라며 keytar 를 아예 쓰지 않고 0600 파일로 갔다.
+ *   그런데 그 회피는 그 한 곳에만 있었고, 나머지는 `.catch(() => null)` 로 "거부는 없는 키로
+ *   본다" 는 가정을 들고 있었다. **거부가 아니라 정지가 실제 실패 모양이다.**
+ *
+ *   macOS 키체인 항목에는 그것을 만든 프로그램의 ACL 이 붙는다. 다른 실행 파일이 읽으려 하면
+ *   OS 가 승인 창을 띄우고, 띄울 화면이 없는 호스트에서는 답할 사람이 없어 호출이 안 돌아온다.
+ *   그리고 그건 **이벤트 루프 정지**다 — 같은 프로세스의 25초 setTimeout 조차 발화하지 않는
+ *   것을 측정했다(2026-08-19). 그래서 `Promise.race([call, timeout])` 은 원리적으로 못 막는다.
+ *   상한이 실제로 동작하려면 호출이 **다른 프로세스**에 있어야 한다.
+ *
+ * 데스크탑 쪽 같은 계약: agentlas_desktop/electron/secrets/keychain-host.ts.
+ */
+const { execFile } = require("node:child_process");
+
+const DEFAULT_TIMEOUT_MS = 10_000;
+const MAX_TIMEOUT_MS = 120_000;
+
+function keychainTimeoutMs() {
+  const raw = Number(process.env.AGENTLAS_KEYCHAIN_TIMEOUT_MS);
+  if (Number.isFinite(raw) && raw > 0) return Math.min(Math.floor(raw), MAX_TIMEOUT_MS);
+  return DEFAULT_TIMEOUT_MS;
+}
+
+/**
+ * 키체인 값 하나를 상한 안에서 읽는다. 못 읽으면 `null` — 호출부는 "키 없음" 갈래를 이미 갖고
+ * 있고, 멈춰 서는 것보다 그 갈래가 낫다. 값은 stdout(파이프)으로만 오고 argv 에는 안 실린다.
+ */
+function readKeychainPassword(service, account) {
+  return new Promise((resolve) => {
+    let keytarPath;
+    try {
+      keytarPath = require.resolve("keytar");
+    } catch {
+      resolve(null);
+      return;
+    }
+    const script = `
+const [modPath, service, account] = process.argv.slice(1);
+const keytar = require(modPath);
+keytar.getPassword(service, account)
+  .then((v) => { process.stdout.write(JSON.stringify({ value: v ?? null })); process.exit(0); })
+  .catch(() => { process.stdout.write(JSON.stringify({ value: null })); process.exit(0); });
+`;
+    execFile(
+      process.execPath,
+      ["-e", script, keytarPath, String(service), String(account)],
+      { timeout: keychainTimeoutMs(), killSignal: "SIGKILL", maxBuffer: 1024 * 1024 },
+      (error, stdout) => {
+        if (error) {
+          resolve(null);
+          return;
+        }
+        try {
+          const parsed = JSON.parse(String(stdout || "{}"));
+          resolve(typeof parsed.value === "string" ? parsed.value : null);
+        } catch {
+          resolve(null);
+        }
+      },
+    );
+  });
+}
+
+module.exports = { readKeychainPassword, keychainTimeoutMs };