@askexenow/exe-os 0.9.8 → 0.9.9

package/dist/hooks/summary-worker.js

@@ -89,6 +89,44 @@ var init_db_retry = __esm({
   }
 });
 
+// src/lib/secure-files.ts
+import { chmodSync, existsSync, mkdirSync } from "fs";
+import { chmod, mkdir } from "fs/promises";
+async function ensurePrivateDir(dirPath) {
+  await mkdir(dirPath, { recursive: true, mode: PRIVATE_DIR_MODE });
+  try {
+    await chmod(dirPath, PRIVATE_DIR_MODE);
+  } catch {
+  }
+}
+function ensurePrivateDirSync(dirPath) {
+  mkdirSync(dirPath, { recursive: true, mode: PRIVATE_DIR_MODE });
+  try {
+    chmodSync(dirPath, PRIVATE_DIR_MODE);
+  } catch {
+  }
+}
+async function enforcePrivateFile(filePath) {
+  try {
+    await chmod(filePath, PRIVATE_FILE_MODE);
+  } catch {
+  }
+}
+function enforcePrivateFileSync(filePath) {
+  try {
+    if (existsSync(filePath)) chmodSync(filePath, PRIVATE_FILE_MODE);
+  } catch {
+  }
+}
+var PRIVATE_DIR_MODE, PRIVATE_FILE_MODE;
+var init_secure_files = __esm({
+  "src/lib/secure-files.ts"() {
+    "use strict";
+    PRIVATE_DIR_MODE = 448;
+    PRIVATE_FILE_MODE = 384;
+  }
+});
+
 // src/lib/config.ts
 var config_exports = {};
 __export(config_exports, {
@@ -105,8 +143,8 @@ __export(config_exports, {
   migrateConfig: () => migrateConfig,
   saveConfig: () => saveConfig
 });
-import { readFile, writeFile, mkdir, chmod } from "fs/promises";
-import { readFileSync, existsSync, renameSync } from "fs";
+import { readFile, writeFile } from "fs/promises";
+import { readFileSync, existsSync as existsSync2, renameSync } from "fs";
 import path from "path";
 import os from "os";
 function resolveDataDir() {
@@ -114,7 +152,7 @@ function resolveDataDir() {
   if (process.env.EXE_MEM_DIR) return process.env.EXE_MEM_DIR;
   const newDir = path.join(os.homedir(), ".exe-os");
   const legacyDir = path.join(os.homedir(), ".exe-mem");
-  if (!existsSync(newDir) && existsSync(legacyDir)) {
+  if (!existsSync2(newDir) && existsSync2(legacyDir)) {
     try {
       renameSync(legacyDir, newDir);
       process.stderr.write(`[exe-os] Migrated data directory: ~/.exe-mem \u2192 ~/.exe-os
@@ -177,9 +215,9 @@ function normalizeAutoUpdate(raw) {
 }
 async function loadConfig() {
   const dir = process.env.EXE_OS_DIR ?? process.env.EXE_MEM_DIR ?? EXE_AI_DIR;
-  await mkdir(dir, { recursive: true });
+  await ensurePrivateDir(dir);
   const configPath = path.join(dir, "config.json");
-  if (!existsSync(configPath)) {
+  if (!existsSync2(configPath)) {
     return { ...DEFAULT_CONFIG, dbPath: path.join(dir, "memories.db") };
   }
   const raw = await readFile(configPath, "utf-8");
@@ -192,6 +230,7 @@ async function loadConfig() {
 `);
       try {
         await writeFile(configPath, JSON.stringify(migratedCfg, null, 2) + "\n");
+        await enforcePrivateFile(configPath);
       } catch {
       }
     }
@@ -210,7 +249,7 @@ async function loadConfig() {
 function loadConfigSync() {
   const dir = process.env.EXE_OS_DIR ?? process.env.EXE_MEM_DIR ?? EXE_AI_DIR;
   const configPath = path.join(dir, "config.json");
-  if (!existsSync(configPath)) {
+  if (!existsSync2(configPath)) {
     return { ...DEFAULT_CONFIG, dbPath: path.join(dir, "memories.db") };
   }
   try {
@@ -228,12 +267,10 @@ function loadConfigSync() {
 }
 async function saveConfig(config) {
   const dir = process.env.EXE_OS_DIR ?? process.env.EXE_MEM_DIR ?? EXE_AI_DIR;
-  await mkdir(dir, { recursive: true });
+  await ensurePrivateDir(dir);
   const configPath = path.join(dir, "config.json");
   await writeFile(configPath, JSON.stringify(config, null, 2) + "\n");
-  if (config.cloud?.apiKey) {
-    await chmod(configPath, 384);
-  }
+  await enforcePrivateFile(configPath);
 }
 async function loadConfigFrom(configPath) {
   const raw = await readFile(configPath, "utf-8");
@@ -253,6 +290,7 @@ var EXE_AI_DIR, DB_PATH, MODELS_DIR, CONFIG_PATH, LEGACY_LANCE_PATH, CURRENT_CON
 var init_config = __esm({
   "src/lib/config.ts"() {
     "use strict";
+    init_secure_files();
     EXE_AI_DIR = resolveDataDir();
     DB_PATH = path.join(EXE_AI_DIR, "memories.db");
     MODELS_DIR = path.join(EXE_AI_DIR, "models");
@@ -331,7 +369,7 @@ var init_config = __esm({
 
 // src/lib/employees.ts
 import { readFile as readFile2, writeFile as writeFile2, mkdir as mkdir2 } from "fs/promises";
-import { existsSync as existsSync2, symlinkSync, readlinkSync, readFileSync as readFileSync2, renameSync as renameSync2, unlinkSync, writeFileSync } from "fs";
+import { existsSync as existsSync3, symlinkSync, readlinkSync, readFileSync as readFileSync2, renameSync as renameSync2, unlinkSync, writeFileSync } from "fs";
 import { execSync } from "child_process";
 import path2 from "path";
 import os2 from "os";
@@ -355,7 +393,7 @@ function canCoordinate(agentName, agentRole, employees = loadEmployeesSync()) {
   return agentName === "default" || isCoordinatorRole(agentRole) || isCoordinatorName(agentName, employees);
 }
 async function loadEmployees(employeesPath = EMPLOYEES_PATH) {
-  if (!existsSync2(employeesPath)) {
+  if (!existsSync3(employeesPath)) {
     return [];
   }
   const raw = await readFile2(employeesPath, "utf-8");
@@ -370,7 +408,7 @@ async function saveEmployees(employees, employeesPath = EMPLOYEES_PATH) {
   await writeFile2(employeesPath, JSON.stringify(employees, null, 2) + "\n", "utf-8");
 }
 function loadEmployeesSync(employeesPath = EMPLOYEES_PATH) {
-  if (!existsSync2(employeesPath)) return [];
+  if (!existsSync3(employeesPath)) return [];
   try {
     return JSON.parse(readFileSync2(employeesPath, "utf-8"));
   } catch {
@@ -404,7 +442,7 @@ function registerBinSymlinks(name) {
   for (const suffix of ["", "-opencode"]) {
     const linkName = `${name}${suffix}`;
     const linkPath = path2.join(binDir, linkName);
-    if (existsSync2(linkPath)) {
+    if (existsSync3(linkPath)) {
       skipped.push(linkName);
       continue;
     }
@@ -1013,13 +1051,50 @@ var init_database_adapter = __esm({
   }
 });
 
+// src/lib/daemon-auth.ts
+import crypto from "crypto";
+import path4 from "path";
+import { existsSync as existsSync4, readFileSync as readFileSync3, writeFileSync as writeFileSync2 } from "fs";
+function normalizeToken(token) {
+  if (!token) return null;
+  const trimmed = token.trim();
+  return trimmed.length > 0 ? trimmed : null;
+}
+function readDaemonToken() {
+  try {
+    if (!existsSync4(DAEMON_TOKEN_PATH)) return null;
+    return normalizeToken(readFileSync3(DAEMON_TOKEN_PATH, "utf8"));
+  } catch {
+    return null;
+  }
+}
+function ensureDaemonToken(seed) {
+  const existing = readDaemonToken();
+  if (existing) return existing;
+  const token = normalizeToken(seed) ?? crypto.randomBytes(32).toString("hex");
+  ensurePrivateDirSync(EXE_AI_DIR);
+  writeFileSync2(DAEMON_TOKEN_PATH, `${token}
+`, "utf8");
+  enforcePrivateFileSync(DAEMON_TOKEN_PATH);
+  return token;
+}
+var DAEMON_TOKEN_PATH;
+var init_daemon_auth = __esm({
+  "src/lib/daemon-auth.ts"() {
+    "use strict";
+    init_config();
+    init_secure_files();
+    DAEMON_TOKEN_PATH = path4.join(EXE_AI_DIR, "exed.token");
+  }
+});
+
 // src/lib/exe-daemon-client.ts
 import net from "net";
 import os4 from "os";
 import { spawn } from "child_process";
 import { randomUUID } from "crypto";
-import { existsSync as existsSync3, unlinkSync as unlinkSync2, readFileSync as readFileSync3, openSync, closeSync, statSync } from "fs";
-import path4 from "path";
+import { existsSync as existsSync5, unlinkSync as unlinkSync2, readFileSync as readFileSync4, openSync, closeSync, statSync } from "fs";
+import path5 from "path";
 import { fileURLToPath } from "url";
 function handleData(chunk) {
   _buffer += chunk.toString();
@@ -1047,9 +1122,9 @@ function handleData(chunk) {
   }
 }
 function cleanupStaleFiles() {
-  if (existsSync3(PID_PATH)) {
+  if (existsSync5(PID_PATH)) {
     try {
-      const pid = parseInt(readFileSync3(PID_PATH, "utf8").trim(), 10);
+      const pid = parseInt(readFileSync4(PID_PATH, "utf8").trim(), 10);
       if (pid > 0) {
         try {
           process.kill(pid, 0);
@@ -1070,11 +1145,11 @@ function cleanupStaleFiles() {
   }
 }
 function findPackageRoot() {
-  let dir = path4.dirname(fileURLToPath(import.meta.url));
-  const { root } = path4.parse(dir);
+  let dir = path5.dirname(fileURLToPath(import.meta.url));
+  const { root } = path5.parse(dir);
   while (dir !== root) {
-    if (existsSync3(path4.join(dir, "package.json"))) return dir;
-    dir = path4.dirname(dir);
+    if (existsSync5(path5.join(dir, "package.json"))) return dir;
+    dir = path5.dirname(dir);
   }
   return null;
 }
@@ -1100,16 +1175,17 @@ function spawnDaemon() {
     process.stderr.write("[exed-client] WARN: cannot find package root\n");
     return;
   }
-  const daemonPath = path4.join(pkgRoot, "dist", "lib", "exe-daemon.js");
-  if (!existsSync3(daemonPath)) {
+  const daemonPath = path5.join(pkgRoot, "dist", "lib", "exe-daemon.js");
+  if (!existsSync5(daemonPath)) {
     process.stderr.write(`[exed-client] WARN: daemon script not found at ${daemonPath}
 `);
     return;
   }
   const resolvedPath = daemonPath;
+  const daemonToken = ensureDaemonToken(process.env[DAEMON_TOKEN_ENV] ?? null);
   process.stderr.write(`[exed-client] Spawning daemon: ${resolvedPath}
 `);
-  const logPath = path4.join(path4.dirname(SOCKET_PATH), "exed.log");
+  const logPath = path5.join(path5.dirname(SOCKET_PATH), "exed.log");
   let stderrFd = "ignore";
   try {
     stderrFd = openSync(logPath, "a");
@@ -1127,7 +1203,8 @@ function spawnDaemon() {
       TMUX_PANE: void 0,
       // Prevents resolveExeSession() from scoping to one session
       EXE_DAEMON_SOCK: SOCKET_PATH,
-      EXE_DAEMON_PID: PID_PATH
+      EXE_DAEMON_PID: PID_PATH,
+      [DAEMON_TOKEN_ENV]: daemonToken
     }
   });
   child.unref();
@@ -1237,13 +1314,14 @@ function sendDaemonRequest(payload, timeoutMs = REQUEST_TIMEOUT_MS) {
       return;
     }
     const id = randomUUID();
+    const token = process.env[DAEMON_TOKEN_ENV] ?? readDaemonToken();
     const timer = setTimeout(() => {
       _pending.delete(id);
       resolve({ error: "Request timeout" });
     }, timeoutMs);
     _pending.set(id, { resolve, timer });
     try {
-      _socket.write(JSON.stringify({ id, ...payload }) + "\n");
+      _socket.write(JSON.stringify({ id, token, ...payload }) + "\n");
     } catch {
       clearTimeout(timer);
       _pending.delete(id);
@@ -1272,9 +1350,9 @@ function killAndRespawnDaemon() {
   }
   try {
     process.stderr.write("[exed-client] Killing daemon for restart...\n");
-    if (existsSync3(PID_PATH)) {
+    if (existsSync5(PID_PATH)) {
       try {
-        const pid = parseInt(readFileSync3(PID_PATH, "utf8").trim(), 10);
+        const pid = parseInt(readFileSync4(PID_PATH, "utf8").trim(), 10);
         if (pid > 0) {
           try {
             process.kill(pid, "SIGKILL");
@@ -1394,17 +1472,19 @@ function disconnectClient() {
 function isClientConnected() {
   return _connected;
 }
-var SOCKET_PATH, PID_PATH, SPAWN_LOCK_PATH, SPAWN_LOCK_STALE_MS, CONNECT_TIMEOUT_MS, REQUEST_TIMEOUT_MS, _socket, _connected, _buffer, _requestCount, _consecutiveFailures, HEALTH_CHECK_INTERVAL, MAX_RETRIES_BEFORE_RESTART, RETRY_DELAYS_MS, MIN_DAEMON_AGE_MS, _pending, MAX_BUFFER;
+var SOCKET_PATH, PID_PATH, SPAWN_LOCK_PATH, SPAWN_LOCK_STALE_MS, CONNECT_TIMEOUT_MS, REQUEST_TIMEOUT_MS, DAEMON_TOKEN_ENV, _socket, _connected, _buffer, _requestCount, _consecutiveFailures, HEALTH_CHECK_INTERVAL, MAX_RETRIES_BEFORE_RESTART, RETRY_DELAYS_MS, MIN_DAEMON_AGE_MS, _pending, MAX_BUFFER;
 var init_exe_daemon_client = __esm({
   "src/lib/exe-daemon-client.ts"() {
     "use strict";
     init_config();
-    SOCKET_PATH = process.env.EXE_DAEMON_SOCK ?? process.env.EXE_EMBED_SOCK ?? path4.join(EXE_AI_DIR, "exed.sock");
-    PID_PATH = process.env.EXE_DAEMON_PID ?? process.env.EXE_EMBED_PID ?? path4.join(EXE_AI_DIR, "exed.pid");
-    SPAWN_LOCK_PATH = path4.join(EXE_AI_DIR, "exed-spawn.lock");
+    init_daemon_auth();
+    SOCKET_PATH = process.env.EXE_DAEMON_SOCK ?? process.env.EXE_EMBED_SOCK ?? path5.join(EXE_AI_DIR, "exed.sock");
+    PID_PATH = process.env.EXE_DAEMON_PID ?? process.env.EXE_EMBED_PID ?? path5.join(EXE_AI_DIR, "exed.pid");
+    SPAWN_LOCK_PATH = path5.join(EXE_AI_DIR, "exed-spawn.lock");
     SPAWN_LOCK_STALE_MS = 3e4;
     CONNECT_TIMEOUT_MS = 15e3;
     REQUEST_TIMEOUT_MS = 3e4;
+    DAEMON_TOKEN_ENV = "EXE_DAEMON_TOKEN";
     _socket = null;
     _connected = false;
     _buffer = "";
@@ -1989,6 +2069,7 @@ async function ensureSchema() {
       project     TEXT NOT NULL,
       summary     TEXT NOT NULL,
       task_file   TEXT,
+      session_scope TEXT,
       read        INTEGER NOT NULL DEFAULT 0,
       created_at  TEXT NOT NULL
     );
@@ -1997,7 +2078,7 @@ async function ensureSchema() {
       ON notifications(read);
 
     CREATE INDEX IF NOT EXISTS idx_notifications_agent
-      ON notifications(agent_id);
+      ON notifications(agent_id, session_scope);
 
     CREATE INDEX IF NOT EXISTS idx_notifications_task_file
       ON notifications(task_file);
@@ -2035,6 +2116,7 @@ async function ensureSchema() {
       target_agent    TEXT NOT NULL,
       target_project  TEXT,
       target_device   TEXT NOT NULL DEFAULT 'local',
+      session_scope   TEXT,
       content         TEXT NOT NULL,
       priority        TEXT DEFAULT 'normal',
       status          TEXT DEFAULT 'pending',
@@ -2048,10 +2130,31 @@ async function ensureSchema() {
     );
 
     CREATE INDEX IF NOT EXISTS idx_messages_target
-      ON messages(target_agent, status);
+      ON messages(target_agent, session_scope, status);
 
     CREATE INDEX IF NOT EXISTS idx_messages_conversation_order
-      ON messages(target_agent, from_agent, server_seq);
+      ON messages(target_agent, session_scope, from_agent, server_seq);
+  `);
+  try {
+    await client.execute({
+      sql: `ALTER TABLE notifications ADD COLUMN session_scope TEXT`,
+      args: []
+    });
+  } catch {
+  }
+  try {
+    await client.execute({
+      sql: `ALTER TABLE messages ADD COLUMN session_scope TEXT`,
+      args: []
+    });
+  } catch {
+  }
+  await client.executeMultiple(`
+    CREATE INDEX IF NOT EXISTS idx_notifications_agent_scope_read
+      ON notifications(agent_id, session_scope, read, created_at);
+
+    CREATE INDEX IF NOT EXISTS idx_messages_target_scope_status
+      ON messages(target_agent, session_scope, status, created_at);
   `);
   try {
     await client.execute({
@@ -2635,6 +2738,13 @@ async function ensureSchema() {
     } catch {
     }
   }
+  try {
+    await client.execute({
+      sql: `UPDATE tasks SET status = 'closed' WHERE status = 'done' AND result IS NOT NULL`,
+      args: []
+    });
+  } catch {
+  }
 }
 async function disposeDatabase() {
   if (_walCheckpointTimer) {
@@ -2682,14 +2792,14 @@ __export(keychain_exports, {
   setMasterKey: () => setMasterKey
 });
 import { readFile as readFile3, writeFile as writeFile3, unlink, mkdir as mkdir3, chmod as chmod2 } from "fs/promises";
-import { existsSync as existsSync4 } from "fs";
-import path5 from "path";
+import { existsSync as existsSync6 } from "fs";
+import path6 from "path";
 import os5 from "os";
 function getKeyDir() {
-  return process.env.EXE_OS_DIR ?? process.env.EXE_MEM_DIR ?? path5.join(os5.homedir(), ".exe-os");
+  return process.env.EXE_OS_DIR ?? process.env.EXE_MEM_DIR ?? path6.join(os5.homedir(), ".exe-os");
 }
 function getKeyPath() {
-  return path5.join(getKeyDir(), "master.key");
+  return path6.join(getKeyDir(), "master.key");
 }
 async function tryKeytar() {
   try {
@@ -2710,7 +2820,7 @@ async function getMasterKey() {
     }
   }
   const keyPath = getKeyPath();
-  if (!existsSync4(keyPath)) {
+  if (!existsSync6(keyPath)) {
     process.stderr.write(
       `[keychain] Key not found at ${keyPath} (HOME=${os5.homedir()}, EXE_OS_DIR=${process.env.EXE_OS_DIR ?? "unset"})
 `
@@ -2753,7 +2863,7 @@ async function deleteMasterKey() {
     }
   }
   const keyPath = getKeyPath();
-  if (existsSync4(keyPath)) {
+  if (existsSync6(keyPath)) {
     await unlink(keyPath);
   }
 }
@@ -2855,6 +2965,7 @@ var shard_manager_exports = {};
 __export(shard_manager_exports, {
   disposeShards: () => disposeShards,
   ensureShardSchema: () => ensureShardSchema,
+  getOpenShardCount: () => getOpenShardCount,
   getReadyShardClient: () => getReadyShardClient,
   getShardClient: () => getShardClient,
   getShardsDir: () => getShardsDir,
@@ -2863,15 +2974,18 @@ __export(shard_manager_exports, {
   listShards: () => listShards,
   shardExists: () => shardExists
 });
-import path6 from "path";
-import { existsSync as existsSync5, mkdirSync, readdirSync } from "fs";
+import path7 from "path";
+import { existsSync as existsSync7, mkdirSync as mkdirSync2, readdirSync } from "fs";
 import { createClient as createClient2 } from "@libsql/client";
 function initShardManager(encryptionKey) {
   _encryptionKey = encryptionKey;
-  if (!existsSync5(SHARDS_DIR)) {
-    mkdirSync(SHARDS_DIR, { recursive: true });
+  if (!existsSync7(SHARDS_DIR)) {
+    mkdirSync2(SHARDS_DIR, { recursive: true });
   }
   _shardingEnabled = true;
+  if (_evictionTimer) clearInterval(_evictionTimer);
+  _evictionTimer = setInterval(evictIdleShards, EVICTION_INTERVAL_MS);
+  _evictionTimer.unref();
 }
 function isShardingEnabled() {
   return _shardingEnabled;
@@ -2888,21 +3002,28 @@ function getShardClient(projectName) {
     throw new Error(`Invalid project name for shard: "${projectName}"`);
   }
   const cached = _shards.get(safeName);
-  if (cached) return cached;
-  const dbPath = path6.join(SHARDS_DIR, `${safeName}.db`);
+  if (cached) {
+    _shardLastAccess.set(safeName, Date.now());
+    return cached;
+  }
+  while (_shards.size >= MAX_OPEN_SHARDS) {
+    evictLRU();
+  }
+  const dbPath = path7.join(SHARDS_DIR, `${safeName}.db`);
   const client = createClient2({
     url: `file:${dbPath}`,
     encryptionKey: _encryptionKey
   });
   _shards.set(safeName, client);
+  _shardLastAccess.set(safeName, Date.now());
   return client;
 }
 function shardExists(projectName) {
   const safeName = projectName.replace(/[^a-zA-Z0-9_-]/g, "_");
-  return existsSync5(path6.join(SHARDS_DIR, `${safeName}.db`));
+  return existsSync7(path7.join(SHARDS_DIR, `${safeName}.db`));
 }
 function listShards() {
-  if (!existsSync5(SHARDS_DIR)) return [];
+  if (!existsSync7(SHARDS_DIR)) return [];
   return readdirSync(SHARDS_DIR).filter((f) => f.endsWith(".db")).map((f) => f.replace(".db", ""));
 }
 async function ensureShardSchema(client) {
@@ -2954,6 +3075,8 @@ async function ensureShardSchema(client) {
   for (const col of [
     "ALTER TABLE memories ADD COLUMN task_id TEXT",
     "ALTER TABLE memories ADD COLUMN consolidated INTEGER NOT NULL DEFAULT 0",
+    "ALTER TABLE memories ADD COLUMN author_device_id TEXT",
+    "ALTER TABLE memories ADD COLUMN scope TEXT NOT NULL DEFAULT 'business'",
     "ALTER TABLE memories ADD COLUMN importance INTEGER DEFAULT 5",
     "ALTER TABLE memories ADD COLUMN status TEXT DEFAULT 'active'",
     "ALTER TABLE memories ADD COLUMN wiki_synced INTEGER DEFAULT 0",
@@ -3091,21 +3214,69 @@ async function getReadyShardClient(projectName) {
   await ensureShardSchema(client);
   return client;
 }
+function evictLRU() {
+  let oldest = null;
+  let oldestTime = Infinity;
+  for (const [name, time] of _shardLastAccess) {
+    if (time < oldestTime) {
+      oldestTime = time;
+      oldest = name;
+    }
+  }
+  if (oldest) {
+    const client = _shards.get(oldest);
+    if (client) {
+      client.close();
+    }
+    _shards.delete(oldest);
+    _shardLastAccess.delete(oldest);
+  }
+}
+function evictIdleShards() {
+  const now = Date.now();
+  const toEvict = [];
+  for (const [name, lastAccess] of _shardLastAccess) {
+    if (now - lastAccess > SHARD_IDLE_MS) {
+      toEvict.push(name);
+    }
+  }
+  for (const name of toEvict) {
+    const client = _shards.get(name);
+    if (client) {
+      client.close();
+    }
+    _shards.delete(name);
+    _shardLastAccess.delete(name);
+  }
+}
+function getOpenShardCount() {
+  return _shards.size;
+}
 function disposeShards() {
+  if (_evictionTimer) {
+    clearInterval(_evictionTimer);
+    _evictionTimer = null;
+  }
   for (const [, client] of _shards) {
     client.close();
   }
   _shards.clear();
+  _shardLastAccess.clear();
   _shardingEnabled = false;
   _encryptionKey = null;
 }
-var SHARDS_DIR, _shards, _encryptionKey, _shardingEnabled;
+var SHARDS_DIR, SHARD_IDLE_MS, MAX_OPEN_SHARDS, EVICTION_INTERVAL_MS, _shards, _shardLastAccess, _evictionTimer, _encryptionKey, _shardingEnabled;
 var init_shard_manager = __esm({
   "src/lib/shard-manager.ts"() {
     "use strict";
     init_config();
-    SHARDS_DIR = path6.join(EXE_AI_DIR, "shards");
+    SHARDS_DIR = path7.join(EXE_AI_DIR, "shards");
+    SHARD_IDLE_MS = 5 * 60 * 1e3;
+    MAX_OPEN_SHARDS = 10;
+    EVICTION_INTERVAL_MS = 60 * 1e3;
     _shards = /* @__PURE__ */ new Map();
+    _shardLastAccess = /* @__PURE__ */ new Map();
+    _evictionTimer = null;
     _encryptionKey = null;
     _shardingEnabled = false;
   }
@@ -3298,56 +3469,14 @@ ${p.content}`).join("\n\n");
   }
 });
 
-// src/lib/notifications.ts
-import crypto from "crypto";
-import path7 from "path";
-import os6 from "os";
-import {
-  readFileSync as readFileSync4,
-  readdirSync as readdirSync2,
-  unlinkSync as unlinkSync3,
-  existsSync as existsSync6,
-  rmdirSync
-} from "fs";
-async function writeNotification(notification) {
-  try {
-    const client = getClient();
-    const id = crypto.randomUUID();
-    const now = (/* @__PURE__ */ new Date()).toISOString();
-    await client.execute({
-      sql: `INSERT INTO notifications (id, agent_id, agent_role, event, project, summary, task_file, read, created_at)
-            VALUES (?, ?, ?, ?, ?, ?, ?, 0, ?)`,
-      args: [
-        id,
-        notification.agentId,
-        notification.agentRole,
-        notification.event,
-        notification.project,
-        notification.summary,
-        notification.taskFile ?? null,
-        now
-      ]
-    });
-  } catch (err) {
-    process.stderr.write(`[notifications] WRITE FAILED: ${err instanceof Error ? err.message : String(err)}
-`);
-  }
-}
-var init_notifications = __esm({
-  "src/lib/notifications.ts"() {
-    "use strict";
-    init_database();
-  }
-});
-
 // src/lib/session-registry.ts
 import path8 from "path";
-import os7 from "os";
+import os6 from "os";
 var REGISTRY_PATH;
 var init_session_registry = __esm({
   "src/lib/session-registry.ts"() {
     "use strict";
-    REGISTRY_PATH = path8.join(os7.homedir(), ".exe-os", "session-registry.json");
+    REGISTRY_PATH = path8.join(os6.homedir(), ".exe-os", "session-registry.json");
   }
 });
 
@@ -3582,7 +3711,7 @@ var init_runtime_table = __esm({
 });
 
 // src/lib/agent-config.ts
-import { readFileSync as readFileSync5, writeFileSync as writeFileSync2, existsSync as existsSync7, mkdirSync as mkdirSync2 } from "fs";
+import { readFileSync as readFileSync5, writeFileSync as writeFileSync3, existsSync as existsSync8 } from "fs";
 import path9 from "path";
 var AGENT_CONFIG_PATH, DEFAULT_MODELS;
 var init_agent_config = __esm({
@@ -3590,6 +3719,7 @@ var init_agent_config = __esm({
     "use strict";
     init_config();
     init_runtime_table();
+    init_secure_files();
     AGENT_CONFIG_PATH = path9.join(EXE_AI_DIR, "agent-config.json");
     DEFAULT_MODELS = {
       claude: "claude-opus-4",
@@ -3600,16 +3730,16 @@ var init_agent_config = __esm({
 });
 
 // src/lib/intercom-queue.ts
-import { readFileSync as readFileSync6, writeFileSync as writeFileSync3, renameSync as renameSync3, existsSync as existsSync8, mkdirSync as mkdirSync3 } from "fs";
+import { readFileSync as readFileSync6, writeFileSync as writeFileSync4, renameSync as renameSync3, existsSync as existsSync9, mkdirSync as mkdirSync3 } from "fs";
 import path10 from "path";
-import os8 from "os";
+import os7 from "os";
 var QUEUE_PATH, TTL_MS, INTERCOM_LOG;
 var init_intercom_queue = __esm({
   "src/lib/intercom-queue.ts"() {
     "use strict";
-    QUEUE_PATH = path10.join(os8.homedir(), ".exe-os", "intercom-queue.json");
+    QUEUE_PATH = path10.join(os7.homedir(), ".exe-os", "intercom-queue.json");
     TTL_MS = 60 * 60 * 1e3;
-    INTERCOM_LOG = path10.join(os8.homedir(), ".exe-os", "intercom.log");
+    INTERCOM_LOG = path10.join(os7.homedir(), ".exe-os", "intercom.log");
   }
 });
 
@@ -3630,8 +3760,11 @@ __export(license_exports, {
   stopLicenseRevalidation: () => stopLicenseRevalidation,
   validateLicense: () => validateLicense
 });
-import { readFileSync as readFileSync7, writeFileSync as writeFileSync4, existsSync as existsSync9, mkdirSync as mkdirSync4 } from "fs";
+import { readFileSync as readFileSync7, writeFileSync as writeFileSync5, existsSync as existsSync10, mkdirSync as mkdirSync4 } from "fs";
 import { randomUUID as randomUUID3 } from "crypto";
+import { createRequire as createRequire2 } from "module";
+import { pathToFileURL as pathToFileURL2 } from "url";
+import os8 from "os";
 import path11 from "path";
 import { jwtVerify, importSPKI } from "jose";
 async function fetchRetry(url, init) {
@@ -3645,14 +3778,14 @@ async function fetchRetry(url, init) {
 function loadDeviceId() {
   const deviceJsonPath = path11.join(EXE_AI_DIR, "device.json");
   try {
-    if (existsSync9(deviceJsonPath)) {
+    if (existsSync10(deviceJsonPath)) {
       const data = JSON.parse(readFileSync7(deviceJsonPath, "utf8"));
       if (data.deviceId) return data.deviceId;
     }
   } catch {
   }
   try {
-    if (existsSync9(DEVICE_ID_PATH)) {
+    if (existsSync10(DEVICE_ID_PATH)) {
       const id2 = readFileSync7(DEVICE_ID_PATH, "utf8").trim();
       if (id2) return id2;
     }
@@ -3660,12 +3793,12 @@ function loadDeviceId() {
   }
   const id = randomUUID3();
   mkdirSync4(EXE_AI_DIR, { recursive: true });
-  writeFileSync4(DEVICE_ID_PATH, id, "utf8");
+  writeFileSync5(DEVICE_ID_PATH, id, "utf8");
   return id;
 }
 function loadLicense() {
   try {
-    if (!existsSync9(LICENSE_PATH)) return null;
+    if (!existsSync10(LICENSE_PATH)) return null;
     return readFileSync7(LICENSE_PATH, "utf8").trim();
   } catch {
     return null;
@@ -3673,7 +3806,7 @@ function loadLicense() {
 }
 function saveLicense(apiKey) {
   mkdirSync4(EXE_AI_DIR, { recursive: true });
-  writeFileSync4(LICENSE_PATH, apiKey.trim(), { encoding: "utf8", mode: 384 });
+  writeFileSync5(LICENSE_PATH, apiKey.trim(), { encoding: "utf8", mode: 384 });
 }
 async function verifyLicenseJwt(token) {
   try {
@@ -3699,7 +3832,7 @@ async function verifyLicenseJwt(token) {
 }
 async function getCachedLicense() {
   try {
-    if (!existsSync9(CACHE_PATH)) return null;
+    if (!existsSync10(CACHE_PATH)) return null;
     const raw = JSON.parse(readFileSync7(CACHE_PATH, "utf8"));
     if (!raw.token || typeof raw.token !== "string") return null;
     return await verifyLicenseJwt(raw.token);
@@ -3709,7 +3842,7 @@ async function getCachedLicense() {
 }
 function readCachedToken() {
   try {
-    if (!existsSync9(CACHE_PATH)) return null;
+    if (!existsSync10(CACHE_PATH)) return null;
     const raw = JSON.parse(readFileSync7(CACHE_PATH, "utf8"));
     return typeof raw.token === "string" ? raw.token : null;
   } catch {
@@ -3744,56 +3877,130 @@ function getRawCachedPlan() {
 }
 function cacheResponse(token) {
   try {
-    writeFileSync4(CACHE_PATH, JSON.stringify({ token }), "utf8");
+    writeFileSync5(CACHE_PATH, JSON.stringify({ token }), "utf8");
   } catch {
   }
 }
-async function validateLicense(apiKey, deviceId) {
-  const did = deviceId ?? loadDeviceId();
+function loadPrismaForLicense() {
+  if (_prismaFailed) return null;
+  const dbUrl = process.env.DATABASE_URL;
+  if (!dbUrl) {
+    const exeDbRoot = process.env.EXE_DB_ROOT ?? path11.join(os8.homedir(), "exe-db");
+    if (!existsSync10(path11.join(exeDbRoot, "package.json"))) {
+      _prismaFailed = true;
+      return null;
+    }
+  }
+  if (!_prismaPromise) {
+    _prismaPromise = (async () => {
+      const explicitPath = process.env.EXE_OS_PRISMA_CLIENT_PATH;
+      if (explicitPath) {
+        const mod2 = await import(pathToFileURL2(explicitPath).href);
+        const Ctor2 = mod2.PrismaClient ?? mod2.default?.PrismaClient;
+        if (!Ctor2) throw new Error(`No PrismaClient at ${explicitPath}`);
+        return new Ctor2();
+      }
+      const exeDbRoot = process.env.EXE_DB_ROOT ?? path11.join(os8.homedir(), "exe-db");
+      const req = createRequire2(path11.join(exeDbRoot, "package.json"));
+      const entry = req.resolve("@prisma/client");
+      const mod = await import(pathToFileURL2(entry).href);
+      const Ctor = mod.PrismaClient ?? mod.default?.PrismaClient;
+      if (!Ctor) throw new Error(`No PrismaClient in ${entry}`);
+      return new Ctor();
+    })().catch((err) => {
+      _prismaFailed = true;
+      _prismaPromise = null;
+      throw err;
+    });
+  }
+  return _prismaPromise;
+}
+async function validateViaPostgres(apiKey) {
+  const loader = loadPrismaForLicense();
+  if (!loader) return null;
+  try {
+    const prisma = await loader;
+    const rows = await prisma.$queryRawUnsafe(
+      `SELECT plan, email, status, device_limit, employee_limit, memory_limit, expires_at
+       FROM billing.licenses WHERE key = $1 LIMIT 1`,
+      apiKey
+    );
+    if (!rows || rows.length === 0) return null;
+    const row = rows[0];
+    if (row.status !== "active") return null;
+    if (row.expires_at && new Date(row.expires_at) < /* @__PURE__ */ new Date()) return null;
+    const plan = row.plan;
+    const limits = PLAN_LIMITS[plan] ?? PLAN_LIMITS.free;
+    return {
+      valid: true,
+      plan,
+      email: row.email,
+      expiresAt: row.expires_at ? new Date(row.expires_at).toISOString() : null,
+      deviceLimit: row.device_limit ?? limits.devices,
+      employeeLimit: row.employee_limit ?? limits.employees,
+      memoryLimit: row.memory_limit ?? limits.memories
+    };
+  } catch {
+    return null;
+  }
+}
+async function validateViaCFWorker(apiKey, deviceId) {
   try {
     const res = await fetchRetry(`${API_BASE}/auth/activate`, {
       method: "POST",
       headers: { "Content-Type": "application/json" },
-      body: JSON.stringify({ apiKey, deviceId: did }),
+      body: JSON.stringify({ apiKey, deviceId }),
       signal: AbortSignal.timeout(1e4)
     });
-    if (res.ok) {
-      const data = await res.json();
-      if (data.error === "device_limit_exceeded") {
-        const cached2 = await getCachedLicense();
-        if (cached2) return cached2;
-        const raw2 = getRawCachedPlan();
-        if (raw2) return { ...raw2, valid: false };
-        return { ...FREE_LICENSE, valid: false, plan: "free" };
-      }
-      if (data.token) {
-        cacheResponse(data.token);
-        const verified = await verifyLicenseJwt(data.token);
-        if (verified) return verified;
+    if (!res.ok) return null;
+    const data = await res.json();
+    if (data.error === "device_limit_exceeded") return null;
+    if (!data.valid) return null;
+    if (data.token) {
+      cacheResponse(data.token);
+      const verified = await verifyLicenseJwt(data.token);
+      if (verified) return verified;
+    }
+    const limits = PLAN_LIMITS[data.plan] ?? PLAN_LIMITS.free;
+    return {
+      valid: data.valid,
+      plan: data.plan,
+      email: data.email,
+      expiresAt: data.expiresAt,
+      deviceLimit: limits.devices,
+      employeeLimit: limits.employees,
+      memoryLimit: limits.memories
+    };
+  } catch {
+    return null;
+  }
+}
+async function validateLicense(apiKey, deviceId) {
+  const did = deviceId ?? loadDeviceId();
+  const pgResult = await validateViaPostgres(apiKey);
+  if (pgResult) {
+    try {
+      writeFileSync5(CACHE_PATH, JSON.stringify({ pgLicense: pgResult, ts: Date.now() }), "utf8");
+    } catch {
+    }
+    return pgResult;
+  }
+  const cfResult = await validateViaCFWorker(apiKey, did);
+  if (cfResult) return cfResult;
+  const cached = await getCachedLicense();
+  if (cached) return cached;
+  try {
+    if (existsSync10(CACHE_PATH)) {
+      const raw = JSON.parse(readFileSync7(CACHE_PATH, "utf8"));
+      if (raw.pgLicense && raw.ts && Date.now() - raw.ts < 7 * 24 * 60 * 60 * 1e3) {
+        return raw.pgLicense;
       }
-      const limits = PLAN_LIMITS[data.plan] ?? PLAN_LIMITS.free;
-      return {
-        valid: data.valid,
-        plan: data.plan,
-        email: data.email,
-        expiresAt: data.expiresAt,
-        deviceLimit: limits.devices,
-        employeeLimit: limits.employees,
-        memoryLimit: limits.memories
-      };
     }
-    const cached = await getCachedLicense();
-    if (cached) return cached;
-    const raw = getRawCachedPlan();
-    if (raw) return raw;
-    return { ...FREE_LICENSE, valid: false, plan: "free" };
   } catch {
-    const cached = await getCachedLicense();
-    if (cached) return cached;
-    const rawFallback = getRawCachedPlan();
-    if (rawFallback) return rawFallback;
-    return { ...FREE_LICENSE, valid: false, error: "offline" };
   }
+  const rawFallback = getRawCachedPlan();
+  if (rawFallback) return rawFallback;
+  return { ...FREE_LICENSE, valid: false };
 }
 function getCacheAgeMs() {
   try {
@@ -3809,7 +4016,7 @@ async function checkLicense() {
   if (!key) {
     try {
       const configPath = path11.join(EXE_AI_DIR, "config.json");
-      if (existsSync9(configPath)) {
+      if (existsSync10(configPath)) {
         const raw = JSON.parse(readFileSync7(configPath, "utf8"));
         const cloud = raw.cloud;
         if (cloud?.apiKey) {
@@ -3964,7 +4171,7 @@ function stopLicenseRevalidation() {
     _revalTimer = null;
   }
 }
-var LICENSE_PATH, CACHE_PATH, DEVICE_ID_PATH, API_BASE, RETRY_DELAY_MS, LICENSE_PUBLIC_KEY_PEM, LICENSE_JWT_ALG, PLAN_LIMITS, FREE_LICENSE, CACHE_MAX_AGE_MS, _revalTimer;
+var LICENSE_PATH, CACHE_PATH, DEVICE_ID_PATH, API_BASE, RETRY_DELAY_MS, LICENSE_PUBLIC_KEY_PEM, LICENSE_JWT_ALG, PLAN_LIMITS, FREE_LICENSE, _prismaPromise, _prismaFailed, CACHE_MAX_AGE_MS, _revalTimer;
 var init_license = __esm({
   "src/lib/license.ts"() {
     "use strict";
@@ -3995,6 +4202,8 @@ MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEeHztAMOpR/ZMh+rWuOASjEZ54CGY
       employeeLimit: 1,
       memoryLimit: 5e3
     };
+    _prismaPromise = null;
+    _prismaFailed = false;
     CACHE_MAX_AGE_MS = 36e5;
     _revalTimer = null;
   }
@@ -4011,11 +4220,11 @@ __export(plan_limits_exports, {
   countActiveMemories: () => countActiveMemories,
   getLicenseSync: () => getLicenseSync
 });
-import { readFileSync as readFileSync8, existsSync as existsSync10 } from "fs";
+import { readFileSync as readFileSync8, existsSync as existsSync11 } from "fs";
 import path12 from "path";
 function getLicenseSync() {
   try {
-    if (!existsSync10(CACHE_PATH2)) return freeLicense();
+    if (!existsSync11(CACHE_PATH2)) return freeLicense();
     const raw = JSON.parse(readFileSync8(CACHE_PATH2, "utf8"));
     if (!raw.token || typeof raw.token !== "string") return freeLicense();
     const parts = raw.token.split(".");
@@ -4083,7 +4292,7 @@ function assertEmployeeLimitSync(rosterPath) {
   const filePath = rosterPath ?? EMPLOYEES_PATH;
   let count = 0;
   try {
-    if (existsSync10(filePath)) {
+    if (existsSync11(filePath)) {
       const raw = readFileSync8(filePath, "utf8");
       const employees = JSON.parse(raw);
       count = Array.isArray(employees) ? employees.length : 0;
@@ -4126,7 +4335,7 @@ var init_plan_limits = __esm({
 });
 
 // src/lib/tmux-routing.ts
-import { readFileSync as readFileSync9, writeFileSync as writeFileSync5, mkdirSync as mkdirSync5, existsSync as existsSync11, appendFileSync, readdirSync as readdirSync3 } from "fs";
+import { readFileSync as readFileSync9, writeFileSync as writeFileSync6, mkdirSync as mkdirSync5, existsSync as existsSync12, appendFileSync, readdirSync as readdirSync2 } from "fs";
 import path13 from "path";
 import os9 from "os";
 import { fileURLToPath as fileURLToPath2 } from "url";
@@ -4216,6 +4425,51 @@ var init_task_scope = __esm({
   }
 });
 
+// src/lib/notifications.ts
+import crypto2 from "crypto";
+import path14 from "path";
+import os10 from "os";
+import {
+  readFileSync as readFileSync10,
+  readdirSync as readdirSync3,
+  unlinkSync as unlinkSync3,
+  existsSync as existsSync13,
+  rmdirSync
+} from "fs";
+async function writeNotification(notification) {
+  try {
+    const client = getClient();
+    const id = crypto2.randomUUID();
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const sessionScope = notification.sessionScope === void 0 ? getCurrentSessionScope() : notification.sessionScope;
+    await client.execute({
+      sql: `INSERT INTO notifications (id, agent_id, agent_role, event, project, summary, task_file, session_scope, read, created_at)
+            VALUES (?, ?, ?, ?, ?, ?, ?, ?, 0, ?)`,
+      args: [
+        id,
+        notification.agentId,
+        notification.agentRole,
+        notification.event,
+        notification.project,
+        notification.summary,
+        notification.taskFile ?? null,
+        sessionScope,
+        now
+      ]
+    });
+  } catch (err) {
+    process.stderr.write(`[notifications] WRITE FAILED: ${err instanceof Error ? err.message : String(err)}
+`);
+  }
+}
+var init_notifications = __esm({
+  "src/lib/notifications.ts"() {
+    "use strict";
+    init_database();
+    init_task_scope();
+  }
+});
+
 // src/lib/embedder.ts
 var embedder_exports = {};
 __export(embedder_exports, {
@@ -4253,10 +4507,10 @@ async function disposeEmbedder() {
 async function embedDirect(text) {
   const llamaCpp = await import("node-llama-cpp");
   const { MODELS_DIR: MODELS_DIR2 } = await Promise.resolve().then(() => (init_config(), config_exports));
-  const { existsSync: existsSync16 } = await import("fs");
-  const path18 = await import("path");
-  const modelPath = path18.join(MODELS_DIR2, "jina-embeddings-v5-small-q4_k_m.gguf");
-  if (!existsSync16(modelPath)) {
+  const { existsSync: existsSync18 } = await import("fs");
+  const path19 = await import("path");
+  const modelPath = path19.join(MODELS_DIR2, "jina-embeddings-v5-small-q4_k_m.gguf");
+  if (!existsSync18(modelPath)) {
     throw new Error(`Embedding model not found at ${modelPath}. Run '/exe-setup' to download it.`);
   }
   const llama = await llamaCpp.getLlama();
@@ -4294,14 +4548,14 @@ __export(worker_gate_exports, {
   tryAcquireBackfillLock: () => tryAcquireBackfillLock,
   tryAcquireWorkerSlot: () => tryAcquireWorkerSlot
 });
-import { readdirSync as readdirSync4, writeFileSync as writeFileSync6, unlinkSync as unlinkSync4, mkdirSync as mkdirSync6, existsSync as existsSync12 } from "fs";
-import path14 from "path";
+import { readdirSync as readdirSync4, writeFileSync as writeFileSync7, unlinkSync as unlinkSync4, mkdirSync as mkdirSync6, existsSync as existsSync14 } from "fs";
+import path15 from "path";
 function tryAcquireWorkerSlot() {
   try {
     mkdirSync6(WORKER_PID_DIR, { recursive: true });
     const reservationId = `res-${process.pid}-${Date.now()}`;
-    const reservationPath = path14.join(WORKER_PID_DIR, `${reservationId}.pid`);
-    writeFileSync6(reservationPath, String(process.pid));
+    const reservationPath = path15.join(WORKER_PID_DIR, `${reservationId}.pid`);
+    writeFileSync7(reservationPath, String(process.pid));
     const files = readdirSync4(WORKER_PID_DIR);
     let alive = 0;
     for (const f of files) {
@@ -4318,7 +4572,7 @@ function tryAcquireWorkerSlot() {
         alive++;
       } catch {
         try {
-          unlinkSync4(path14.join(WORKER_PID_DIR, f));
+          unlinkSync4(path15.join(WORKER_PID_DIR, f));
         } catch {
         }
       }
@@ -4342,20 +4596,20 @@ function tryAcquireWorkerSlot() {
 function registerWorkerPid(pid) {
   try {
     mkdirSync6(WORKER_PID_DIR, { recursive: true });
-    writeFileSync6(path14.join(WORKER_PID_DIR, `worker-${pid}.pid`), String(pid));
+    writeFileSync7(path15.join(WORKER_PID_DIR, `worker-${pid}.pid`), String(pid));
   } catch {
   }
 }
 function cleanupWorkerPid() {
   try {
-    unlinkSync4(path14.join(WORKER_PID_DIR, `worker-${process.pid}.pid`));
+    unlinkSync4(path15.join(WORKER_PID_DIR, `worker-${process.pid}.pid`));
   } catch {
   }
 }
 function tryAcquireBackfillLock() {
   try {
     mkdirSync6(WORKER_PID_DIR, { recursive: true });
-    if (existsSync12(BACKFILL_LOCK)) {
+    if (existsSync14(BACKFILL_LOCK)) {
       try {
         const pid = parseInt(
           __require("fs").readFileSync(BACKFILL_LOCK, "utf8").trim(),
@@ -4371,7 +4625,7 @@ function tryAcquireBackfillLock() {
       } catch {
       }
     }
-    writeFileSync6(BACKFILL_LOCK, String(process.pid));
+    writeFileSync7(BACKFILL_LOCK, String(process.pid));
     return true;
   } catch {
     return true;
@@ -4388,9 +4642,9 @@ var init_worker_gate = __esm({
   "src/lib/worker-gate.ts"() {
     "use strict";
     init_config();
-    WORKER_PID_DIR = path14.join(EXE_AI_DIR, "worker-pids");
+    WORKER_PID_DIR = path15.join(EXE_AI_DIR, "worker-pids");
     MAX_CONCURRENT_WORKERS = 3;
-    BACKFILL_LOCK = path14.join(WORKER_PID_DIR, "backfill.lock");
+    BACKFILL_LOCK = path15.join(WORKER_PID_DIR, "backfill.lock");
   }
 });
 
@@ -4402,13 +4656,13 @@ __export(crypto_exports, {
   initSyncCrypto: () => initSyncCrypto,
   isSyncCryptoInitialized: () => isSyncCryptoInitialized
 });
-import crypto2 from "crypto";
+import crypto3 from "crypto";
 function initSyncCrypto(masterKey) {
   if (masterKey.length !== 32) {
     throw new Error(`Master key must be 32 bytes, got ${masterKey.length}`);
   }
   _syncKey = Buffer.from(
-    crypto2.hkdfSync("sha256", masterKey, "", SYNC_HKDF_INFO, 32)
+    crypto3.hkdfSync("sha256", masterKey, "", SYNC_HKDF_INFO, 32)
   );
 }
 function isSyncCryptoInitialized() {
@@ -4422,8 +4676,8 @@ function requireSyncKey() {
 }
 function encryptSyncBlob(data) {
   const key = requireSyncKey();
-  const iv = crypto2.randomBytes(IV_LENGTH);
-  const cipher = crypto2.createCipheriv(ALGORITHM, key, iv);
+  const iv = crypto3.randomBytes(IV_LENGTH);
+  const cipher = crypto3.createCipheriv(ALGORITHM, key, iv);
   const encrypted = Buffer.concat([cipher.update(data), cipher.final()]);
   const tag = cipher.getAuthTag();
   return Buffer.concat([iv, encrypted, tag]).toString("base64");
@@ -4437,7 +4691,7 @@ function decryptSyncBlob(ciphertext) {
   const iv = combined.subarray(0, IV_LENGTH);
   const tag = combined.subarray(combined.length - TAG_LENGTH);
   const encrypted = combined.subarray(IV_LENGTH, combined.length - TAG_LENGTH);
-  const decipher = crypto2.createDecipheriv(ALGORITHM, key, iv);
+  const decipher = crypto3.createDecipheriv(ALGORITHM, key, iv);
   decipher.setAuthTag(tag);
   return Buffer.concat([decipher.update(encrypted), decipher.final()]);
 }
@@ -4492,8 +4746,8 @@ __export(crdt_sync_exports, {
   rebuildFromDb: () => rebuildFromDb
 });
 import * as Y from "yjs";
-import { readFileSync as readFileSync10, writeFileSync as writeFileSync7, existsSync as existsSync13, mkdirSync as mkdirSync7, unlinkSync as unlinkSync5 } from "fs";
-import path15 from "path";
+import { readFileSync as readFileSync11, writeFileSync as writeFileSync8, existsSync as existsSync15, mkdirSync as mkdirSync7, unlinkSync as unlinkSync5 } from "fs";
+import path16 from "path";
 import { homedir } from "os";
 function getStatePath() {
   return _statePathOverride ?? DEFAULT_STATE_PATH;
@@ -4505,9 +4759,9 @@ function initCrdtDoc() {
   if (doc) return doc;
   doc = new Y.Doc();
   const sp = getStatePath();
-  if (existsSync13(sp)) {
+  if (existsSync15(sp)) {
     try {
-      const state = readFileSync10(sp);
+      const state = readFileSync11(sp);
       Y.applyUpdate(doc, new Uint8Array(state));
     } catch {
       console.warn("[crdt-sync] WARN: corrupted state file, rebuilding from DB");
@@ -4649,10 +4903,10 @@ function persistState() {
   if (!doc) return;
   try {
     const sp = getStatePath();
-    const dir = path15.dirname(sp);
-    if (!existsSync13(dir)) mkdirSync7(dir, { recursive: true });
+    const dir = path16.dirname(sp);
+    if (!existsSync15(dir)) mkdirSync7(dir, { recursive: true });
     const state = Y.encodeStateAsUpdate(doc);
-    writeFileSync7(sp, Buffer.from(state));
+    writeFileSync8(sp, Buffer.from(state));
   } catch {
   }
 }
@@ -4693,7 +4947,7 @@ var DEFAULT_STATE_PATH, _statePathOverride, doc;
 var init_crdt_sync = __esm({
   "src/lib/crdt-sync.ts"() {
     "use strict";
-    DEFAULT_STATE_PATH = path15.join(homedir(), ".exe-os", "crdt-state.bin");
+    DEFAULT_STATE_PATH = path16.join(homedir(), ".exe-os", "crdt-state.bin");
     _statePathOverride = null;
     doc = null;
   }
@@ -4725,39 +4979,107 @@ __export(cloud_sync_exports, {
   cloudSync: () => cloudSync,
   mergeConfig: () => mergeConfig,
   mergeRosterFromRemote: () => mergeRosterFromRemote,
+  pushToPostgres: () => pushToPostgres,
   recordRosterDeletion: () => recordRosterDeletion
 });
-import { readFileSync as readFileSync11, writeFileSync as writeFileSync8, existsSync as existsSync14, readdirSync as readdirSync5, mkdirSync as mkdirSync8, appendFileSync as appendFileSync2, unlinkSync as unlinkSync6, openSync as openSync2, closeSync as closeSync2 } from "fs";
-import crypto3 from "crypto";
-import path16 from "path";
+import { readFileSync as readFileSync12, writeFileSync as writeFileSync9, existsSync as existsSync16, readdirSync as readdirSync5, mkdirSync as mkdirSync8, appendFileSync as appendFileSync2, unlinkSync as unlinkSync6, openSync as openSync2, closeSync as closeSync2 } from "fs";
+import crypto4 from "crypto";
+import path17 from "path";
 import { homedir as homedir2 } from "os";
 function sqlSafe(v) {
   return v === void 0 ? null : v;
 }
 function logError(msg) {
   try {
-    const logPath = path16.join(homedir2(), ".exe-os", "workers.log");
+    const logPath = path17.join(homedir2(), ".exe-os", "workers.log");
     appendFileSync2(logPath, `${(/* @__PURE__ */ new Date()).toISOString()} ${msg}
 `);
   } catch {
   }
 }
+function loadPgClient() {
+  if (_pgFailed) return null;
+  const postgresUrl = process.env.DATABASE_URL;
+  const configPath = path17.join(EXE_AI_DIR, "config.json");
+  let cloudPostgresUrl;
+  try {
+    if (existsSync16(configPath)) {
+      const cfg = JSON.parse(readFileSync12(configPath, "utf8"));
+      cloudPostgresUrl = cfg.cloud?.postgresUrl;
+      if (cfg.cloud?.syncToPostgres === false) {
+        _pgFailed = true;
+        return null;
+      }
+    }
+  } catch {
+  }
+  const url = postgresUrl || cloudPostgresUrl;
+  if (!url) {
+    _pgFailed = true;
+    return null;
+  }
+  if (!_pgPromise) {
+    _pgPromise = (async () => {
+      const { createRequire: createRequire3 } = await import("module");
+      const { pathToFileURL: pathToFileURL3 } = await import("url");
+      const exeDbRoot = process.env.EXE_DB_ROOT ?? path17.join(homedir2(), "exe-db");
+      const req = createRequire3(path17.join(exeDbRoot, "package.json"));
+      const entry = req.resolve("@prisma/client");
+      const mod = await import(pathToFileURL3(entry).href);
+      const Ctor = mod.PrismaClient ?? mod.default?.PrismaClient;
+      if (!Ctor) throw new Error("No PrismaClient");
+      return new Ctor();
+    })().catch(() => {
+      _pgFailed = true;
+      _pgPromise = null;
+      throw new Error("pg_unavailable");
+    });
+  }
+  return _pgPromise;
+}
+async function pushToPostgres(records) {
+  const loader = loadPgClient();
+  if (!loader) return 0;
+  let prisma;
+  try {
+    prisma = await loader;
+  } catch {
+    return 0;
+  }
+  let inserted = 0;
+  for (const rec of records) {
+    try {
+      await prisma.$executeRawUnsafe(
+        `INSERT INTO raw.raw_events (id, source, source_id, event_type, payload, metadata, timestamp)
+         VALUES (gen_random_uuid(), 'cloud_sync', $1, 'memory', $2::jsonb, $3::jsonb, $4)
+         ON CONFLICT (source, source_id, event_type) DO NOTHING`,
+        String(rec.id ?? ""),
+        JSON.stringify(rec),
+        JSON.stringify({ agent_id: rec.agent_id, project_name: rec.project_name, tool_name: rec.tool_name }),
+        rec.timestamp ? new Date(String(rec.timestamp)) : /* @__PURE__ */ new Date()
+      );
+      inserted++;
+    } catch {
+    }
+  }
+  return inserted;
+}
 async function withRosterLock(fn) {
   try {
     const fd = openSync2(ROSTER_LOCK_PATH, "wx");
     closeSync2(fd);
-    writeFileSync8(ROSTER_LOCK_PATH, String(Date.now()));
+    writeFileSync9(ROSTER_LOCK_PATH, String(Date.now()));
   } catch (err) {
     if (err.code === "EEXIST") {
       try {
-        const ts = parseInt(readFileSync11(ROSTER_LOCK_PATH, "utf-8"), 10);
+        const ts = parseInt(readFileSync12(ROSTER_LOCK_PATH, "utf-8"), 10);
         if (Date.now() - ts < LOCK_STALE_MS) {
           throw new Error("Roster merge already in progress \u2014 another sync is running");
         }
         unlinkSync6(ROSTER_LOCK_PATH);
         const fd = openSync2(ROSTER_LOCK_PATH, "wx");
         closeSync2(fd);
-        writeFileSync8(ROSTER_LOCK_PATH, String(Date.now()));
+        writeFileSync9(ROSTER_LOCK_PATH, String(Date.now()));
       } catch (retryErr) {
         if (retryErr instanceof Error && retryErr.message.includes("already in progress")) throw retryErr;
         throw new Error("Roster merge already in progress \u2014 another sync is running");
@@ -5027,6 +5349,10 @@ async function cloudSync(config) {
     const maxVersion = Number(records[records.length - 1].version);
     const pushOk = await cloudPush(records, maxVersion, config);
     if (!pushOk) break;
+    try {
+      await pushToPostgres(records);
+    } catch {
+    }
     await client.execute({
       sql: "INSERT OR REPLACE INTO sync_meta (key, value) VALUES ('last_cloud_push_version', ?)",
       args: [String(maxVersion)]
@@ -5131,8 +5457,8 @@ async function cloudSync(config) {
   try {
     const employees = await loadEmployees();
     rosterResult.employees = employees.length;
-    const idDir = path16.join(EXE_AI_DIR, "identity");
-    if (existsSync14(idDir)) {
+    const idDir = path17.join(EXE_AI_DIR, "identity");
+    if (existsSync16(idDir)) {
       rosterResult.identities = readdirSync5(idDir).filter((f) => f.endsWith(".md")).length;
     }
   } catch {
@@ -5153,62 +5479,62 @@ async function cloudSync(config) {
 function recordRosterDeletion(name) {
   let deletions = [];
   try {
-    if (existsSync14(ROSTER_DELETIONS_PATH)) {
-      deletions = JSON.parse(readFileSync11(ROSTER_DELETIONS_PATH, "utf-8"));
+    if (existsSync16(ROSTER_DELETIONS_PATH)) {
+      deletions = JSON.parse(readFileSync12(ROSTER_DELETIONS_PATH, "utf-8"));
     }
   } catch {
   }
   if (!deletions.includes(name)) deletions.push(name);
-  writeFileSync8(ROSTER_DELETIONS_PATH, JSON.stringify(deletions));
+  writeFileSync9(ROSTER_DELETIONS_PATH, JSON.stringify(deletions));
 }
 function consumeRosterDeletions() {
   try {
-    if (!existsSync14(ROSTER_DELETIONS_PATH)) return [];
-    const deletions = JSON.parse(readFileSync11(ROSTER_DELETIONS_PATH, "utf-8"));
-    writeFileSync8(ROSTER_DELETIONS_PATH, "[]");
+    if (!existsSync16(ROSTER_DELETIONS_PATH)) return [];
+    const deletions = JSON.parse(readFileSync12(ROSTER_DELETIONS_PATH, "utf-8"));
+    writeFileSync9(ROSTER_DELETIONS_PATH, "[]");
     return deletions;
   } catch {
     return [];
   }
 }
 function buildRosterBlob(paths) {
-  const rosterPath = paths?.rosterPath ?? path16.join(EXE_AI_DIR, "exe-employees.json");
-  const identityDir = paths?.identityDir ?? path16.join(EXE_AI_DIR, "identity");
-  const configPath = paths?.configPath ?? path16.join(EXE_AI_DIR, "config.json");
+  const rosterPath = paths?.rosterPath ?? path17.join(EXE_AI_DIR, "exe-employees.json");
+  const identityDir = paths?.identityDir ?? path17.join(EXE_AI_DIR, "identity");
+  const configPath = paths?.configPath ?? path17.join(EXE_AI_DIR, "config.json");
   let roster = [];
-  if (existsSync14(rosterPath)) {
+  if (existsSync16(rosterPath)) {
     try {
-      roster = JSON.parse(readFileSync11(rosterPath, "utf-8"));
+      roster = JSON.parse(readFileSync12(rosterPath, "utf-8"));
     } catch {
     }
   }
   const identities = {};
-  if (existsSync14(identityDir)) {
+  if (existsSync16(identityDir)) {
     for (const file of readdirSync5(identityDir).filter((f) => f.endsWith(".md"))) {
       try {
-        identities[file] = readFileSync11(path16.join(identityDir, file), "utf-8");
+        identities[file] = readFileSync12(path17.join(identityDir, file), "utf-8");
       } catch {
       }
     }
   }
   let config;
-  if (existsSync14(configPath)) {
+  if (existsSync16(configPath)) {
     try {
-      config = JSON.parse(readFileSync11(configPath, "utf-8"));
+      config = JSON.parse(readFileSync12(configPath, "utf-8"));
     } catch {
     }
   }
   let agentConfig;
-  const agentConfigPath = path16.join(EXE_AI_DIR, "agent-config.json");
-  if (existsSync14(agentConfigPath)) {
+  const agentConfigPath = path17.join(EXE_AI_DIR, "agent-config.json");
+  if (existsSync16(agentConfigPath)) {
     try {
-      agentConfig = JSON.parse(readFileSync11(agentConfigPath, "utf-8"));
+      agentConfig = JSON.parse(readFileSync12(agentConfigPath, "utf-8"));
     } catch {
     }
   }
   const deletedNames = consumeRosterDeletions();
   const content = JSON.stringify({ roster, identities, config, agentConfig, deletedNames });
-  const hash = crypto3.createHash("sha256").update(content).digest("hex").slice(0, 16);
+  const hash = crypto4.createHash("sha256").update(content).digest("hex").slice(0, 16);
   return { roster, identities, config, agentConfig, deletedNames, version: hash };
 }
 async function cloudPushRoster(config) {
@@ -5278,23 +5604,24 @@ async function cloudPullRoster(config) {
   }
 }
 function mergeConfig(remoteConfig, configPath) {
-  const cfgPath = configPath ?? path16.join(EXE_AI_DIR, "config.json");
+  const cfgPath = configPath ?? path17.join(EXE_AI_DIR, "config.json");
   let local = {};
-  if (existsSync14(cfgPath)) {
+  if (existsSync16(cfgPath)) {
     try {
-      local = JSON.parse(readFileSync11(cfgPath, "utf-8"));
+      local = JSON.parse(readFileSync12(cfgPath, "utf-8"));
     } catch {
     }
   }
   const merged = { ...remoteConfig, ...local };
-  const dir = path16.dirname(cfgPath);
-  if (!existsSync14(dir)) mkdirSync8(dir, { recursive: true });
-  writeFileSync8(cfgPath, JSON.stringify(merged, null, 2), "utf-8");
+  const dir = path17.dirname(cfgPath);
+  ensurePrivateDirSync(dir);
+  writeFileSync9(cfgPath, JSON.stringify(merged, null, 2), "utf-8");
+  enforcePrivateFileSync(cfgPath);
 }
 async function mergeRosterFromRemote(remote, paths) {
   return withRosterLock(async () => {
     const rosterPath = paths?.rosterPath ?? void 0;
-    const identityDir = paths?.identityDir ?? path16.join(EXE_AI_DIR, "identity");
+    const identityDir = paths?.identityDir ?? path17.join(EXE_AI_DIR, "identity");
     const localEmployees = await loadEmployees(rosterPath);
     const localNames = new Set(localEmployees.map((e) => e.name));
     let added = 0;
@@ -5315,15 +5642,15 @@ async function mergeRosterFromRemote(remote, paths) {
       ) ?? lookupKey;
       const remoteIdentity = remote.identities[matchedKey];
       if (remoteIdentity) {
-        if (!existsSync14(identityDir)) mkdirSync8(identityDir, { recursive: true });
-        const idPath = path16.join(identityDir, `${remoteEmp.name}.md`);
+        if (!existsSync16(identityDir)) mkdirSync8(identityDir, { recursive: true });
+        const idPath = path17.join(identityDir, `${remoteEmp.name}.md`);
         let localIdentity = null;
         try {
-          localIdentity = existsSync14(idPath) ? readFileSync11(idPath, "utf-8") : null;
+          localIdentity = existsSync16(idPath) ? readFileSync12(idPath, "utf-8") : null;
         } catch {
         }
         if (localIdentity !== remoteIdentity) {
-          writeFileSync8(idPath, remoteIdentity, "utf-8");
+          writeFileSync9(idPath, remoteIdentity, "utf-8");
           identitiesUpdated++;
         }
       }
@@ -5349,16 +5676,18 @@ async function mergeRosterFromRemote(remote, paths) {
     }
     if (remote.agentConfig && Object.keys(remote.agentConfig).length > 0) {
       try {
-        const agentConfigPath = path16.join(EXE_AI_DIR, "agent-config.json");
+        const agentConfigPath = path17.join(EXE_AI_DIR, "agent-config.json");
         let local = {};
-        if (existsSync14(agentConfigPath)) {
+        if (existsSync16(agentConfigPath)) {
           try {
-            local = JSON.parse(readFileSync11(agentConfigPath, "utf-8"));
+            local = JSON.parse(readFileSync12(agentConfigPath, "utf-8"));
           } catch {
           }
         }
         const merged = { ...remote.agentConfig, ...local };
-        writeFileSync8(agentConfigPath, JSON.stringify(merged, null, 2) + "\n", "utf-8");
+        ensurePrivateDirSync(path17.dirname(agentConfigPath));
+        writeFileSync9(agentConfigPath, JSON.stringify(merged, null, 2) + "\n", "utf-8");
+        enforcePrivateFileSync(agentConfigPath);
       } catch {
       }
     }
@@ -5782,7 +6111,7 @@ async function cloudPullDocuments(config) {
   }
   return { pulled };
 }
-var LOCALHOST_PATTERNS, FETCH_TIMEOUT_MS, PUSH_BATCH_SIZE, ROSTER_LOCK_PATH, LOCK_STALE_MS, ROSTER_DELETIONS_PATH;
+var LOCALHOST_PATTERNS, FETCH_TIMEOUT_MS, PUSH_BATCH_SIZE, ROSTER_LOCK_PATH, LOCK_STALE_MS, _pgPromise, _pgFailed, ROSTER_DELETIONS_PATH;
 var init_cloud_sync = __esm({
   "src/lib/cloud-sync.ts"() {
     "use strict";
@@ -5793,12 +6122,15 @@ var init_cloud_sync = __esm({
     init_config();
     init_crdt_sync();
     init_employees();
+    init_secure_files();
     LOCALHOST_PATTERNS = /^(localhost|127\.0\.0\.1|\[::1\])$/i;
     FETCH_TIMEOUT_MS = 3e4;
     PUSH_BATCH_SIZE = 5e3;
-    ROSTER_LOCK_PATH = path16.join(EXE_AI_DIR, "roster-merge.lock");
+    ROSTER_LOCK_PATH = path17.join(EXE_AI_DIR, "roster-merge.lock");
     LOCK_STALE_MS = 3e4;
-    ROSTER_DELETIONS_PATH = path16.join(EXE_AI_DIR, "roster-deletions.json");
+    _pgPromise = null;
+    _pgFailed = false;
+    ROSTER_DELETIONS_PATH = path17.join(EXE_AI_DIR, "roster-deletions.json");
   }
 });
 
@@ -6165,10 +6497,10 @@ init_database();
 init_notifications();
 init_task_scope();
 init_employees();
-import crypto4 from "crypto";
+import crypto5 from "crypto";
 import { execSync as execSync4 } from "child_process";
-import { existsSync as existsSync15, mkdirSync as mkdirSync9, openSync as openSync3, closeSync as closeSync3 } from "fs";
-import path17 from "path";
+import { existsSync as existsSync17, mkdirSync as mkdirSync9, openSync as openSync3, closeSync as closeSync3 } from "fs";
+import path18 from "path";
 async function main() {
   const agentId = process.env.AGENT_ID ?? "default";
   const agentRole = process.env.AGENT_ROLE ?? "employee";
@@ -6248,7 +6580,7 @@ async function main() {
   if (limitReached) {
   } else {
     await writeMemory({
-      id: crypto4.randomUUID(),
+      id: crypto5.randomUUID(),
       agent_id: agentId,
       agent_role: agentRole,
       session_id: `auto-summary-${Date.now()}`,
@@ -6303,8 +6635,8 @@ async function main() {
     }
     try {
       const { EXE_AI_DIR: EXE_AI_DIR2 } = await Promise.resolve().then(() => (init_config(), config_exports));
-      const flagPath = path17.join(EXE_AI_DIR2, "session-cache", "needs-backfill");
-      if (existsSync15(flagPath)) {
+      const flagPath = path18.join(EXE_AI_DIR2, "session-cache", "needs-backfill");
+      if (existsSync17(flagPath)) {
         const { tryAcquireWorkerSlot: tryAcquireWorkerSlot2, registerWorkerPid: registerWorkerPid2 } = await Promise.resolve().then(() => (init_worker_gate(), worker_gate_exports));
         if (!tryAcquireWorkerSlot2()) {
           process.stderr.write("[summary-worker] Backfill needed but worker gate full \u2014 skipping\n");
@@ -6312,11 +6644,11 @@ async function main() {
           const { spawn: spawn2 } = await import("child_process");
           const { fileURLToPath: fileURLToPath3 } = await import("url");
           const thisFile = fileURLToPath3(import.meta.url);
-          const backfillPath = path17.resolve(path17.dirname(thisFile), "backfill-vectors.js");
-          if (existsSync15(backfillPath)) {
+          const backfillPath = path18.resolve(path18.dirname(thisFile), "backfill-vectors.js");
+          if (existsSync17(backfillPath)) {
             const { EXE_AI_DIR: exeDir2 } = await Promise.resolve().then(() => (init_config(), config_exports));
-            const bLogPath = path17.join(exeDir2, "workers.log");
-            mkdirSync9(path17.dirname(bLogPath), { recursive: true });
+            const bLogPath = path18.join(exeDir2, "workers.log");
+            mkdirSync9(path18.dirname(bLogPath), { recursive: true });
             const bLogFd = openSync3(bLogPath, "a");
             const child = spawn2(process.execPath, [backfillPath], {
               detached: true,