agentlas 1.0.48 → 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/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 = {

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/project/memory-context.cjs

@@ -123,6 +123,13 @@ function cliProjectContextSlice(projectPath, task) {
         "--task-stdin",
         "--no-refresh",
         "--render",
+        // Recall degrades to a labelled map, never to nothing. Core's passive
+        // freshness check walks the whole repository (measured 11.0s on the
+        // pilot) against this 4s timeout, and any non-zero exit is swallowed
+        // into "" below — so without a budget a large project silently lost
+        // its slice on every turn.
+        "--allow-stale",
+        "--freshness-budget", "0.4",
       ],
       {
         cwd: projectPath,

package/engine/workforce/deps.cjs

@@ -523,6 +523,13 @@ function projectContextSlice(projectPath, task) {
         "--task-stdin",
         "--no-refresh",
         "--render",
+        // Recall degrades to a labelled map, never to nothing. Core's passive
+        // freshness check walks the whole repository (measured 11.0s on the
+        // pilot) against this 4s timeout, and any non-zero exit is swallowed
+        // into "" below — so without a budget a large project silently lost
+        // its slice on every turn.
+        "--allow-stale",
+        "--freshness-budget", "0.4",
       ],
       {
         cwd: projectPath,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agentlas",
-  "version": "1.0.48",
+  "version": "1.0.49",
   "description": "Agentlas project terminal — run project controllers and task-scoped agent teams from the terminal. Standalone: no desktop app process required.",
   "bin": {
     "agentlas": "bin/agentlas.cjs"