@askexenow/exe-os 0.9.8 → 0.9.9

package/dist/hooks/pre-tool-use.js

@@ -19,9 +19,47 @@ var __copyProps = (to, from, except, desc) => {
 };
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
+// 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
-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() {
@@ -29,7 +67,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
@@ -92,9 +130,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");
@@ -107,6 +145,7 @@ async function loadConfig() {
 `);
       try {
         await writeFile(configPath, JSON.stringify(migratedCfg, null, 2) + "\n");
+        await enforcePrivateFile(configPath);
       } catch {
       }
     }
@@ -126,6 +165,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");
@@ -310,10 +350,10 @@ __export(agent_config_exports, {
   saveAgentConfig: () => saveAgentConfig,
   setAgentRuntime: () => setAgentRuntime
 });
-import { readFileSync as readFileSync2, writeFileSync, existsSync as existsSync2, mkdirSync } from "fs";
+import { readFileSync as readFileSync2, writeFileSync, existsSync as existsSync3 } from "fs";
 import path2 from "path";
 function loadAgentConfig() {
-  if (!existsSync2(AGENT_CONFIG_PATH)) return {};
+  if (!existsSync3(AGENT_CONFIG_PATH)) return {};
   try {
     return JSON.parse(readFileSync2(AGENT_CONFIG_PATH, "utf-8"));
   } catch {
@@ -322,8 +362,9 @@ function loadAgentConfig() {
 }
 function saveAgentConfig(config) {
   const dir = path2.dirname(AGENT_CONFIG_PATH);
-  if (!existsSync2(dir)) mkdirSync(dir, { recursive: true });
+  ensurePrivateDirSync(dir);
   writeFileSync(AGENT_CONFIG_PATH, JSON.stringify(config, null, 2) + "\n", "utf-8");
+  enforcePrivateFileSync(AGENT_CONFIG_PATH);
 }
 function getAgentRuntime(agentId) {
   const config = loadAgentConfig();
@@ -363,6 +404,7 @@ var init_agent_config = __esm({
     "use strict";
     init_config();
     init_runtime_table();
+    init_secure_files();
     AGENT_CONFIG_PATH = path2.join(EXE_AI_DIR, "agent-config.json");
     KNOWN_RUNTIMES = {
       claude: ["claude-opus-4", "claude-sonnet-4", "claude-haiku-4.5"],
@@ -410,7 +452,7 @@ __export(employees_exports, {
   validateEmployeeName: () => validateEmployeeName
 });
 import { readFile as readFile2, writeFile as writeFile2, mkdir as mkdir2 } from "fs/promises";
-import { existsSync as existsSync3, symlinkSync, readlinkSync, readFileSync as readFileSync3, renameSync as renameSync2, unlinkSync, writeFileSync as writeFileSync2 } from "fs";
+import { existsSync as existsSync4, symlinkSync, readlinkSync, readFileSync as readFileSync3, renameSync as renameSync2, unlinkSync, writeFileSync as writeFileSync2 } from "fs";
 import { execSync as execSync2 } from "child_process";
 import path3 from "path";
 import os2 from "os";
@@ -449,7 +491,7 @@ function validateEmployeeName(name) {
   return { valid: true };
 }
 async function loadEmployees(employeesPath = EMPLOYEES_PATH) {
-  if (!existsSync3(employeesPath)) {
+  if (!existsSync4(employeesPath)) {
     return [];
   }
   const raw = await readFile2(employeesPath, "utf-8");
@@ -464,7 +506,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 (!existsSync3(employeesPath)) return [];
+  if (!existsSync4(employeesPath)) return [];
   try {
     return JSON.parse(readFileSync3(employeesPath, "utf-8"));
   } catch {
@@ -512,7 +554,7 @@ function appendToCoordinatorTeam(employee) {
   const coordinator = getCoordinatorEmployee(loadEmployeesSync());
   if (!coordinator) return;
   const idPath = path3.join(IDENTITY_DIR, `${coordinator.name}.md`);
-  if (!existsSync3(idPath)) return;
+  if (!existsSync4(idPath)) return;
   const content = readFileSync3(idPath, "utf-8");
   if (content.includes(`**${capitalize(employee.name)}`)) return;
   const teamMatch = content.match(TEAM_SECTION_RE);
@@ -566,9 +608,9 @@ async function normalizeRosterCase(rosterPath) {
         const identityDir = path3.join(os2.homedir(), ".exe-os", "identity");
         const oldPath = path3.join(identityDir, `${oldName}.md`);
         const newPath = path3.join(identityDir, `${emp.name}.md`);
-        if (existsSync3(oldPath) && !existsSync3(newPath)) {
+        if (existsSync4(oldPath) && !existsSync4(newPath)) {
           renameSync2(oldPath, newPath);
-        } else if (existsSync3(oldPath) && oldPath !== newPath) {
+        } else if (existsSync4(oldPath) && oldPath !== newPath) {
           const content = readFileSync3(oldPath, "utf-8");
           writeFileSync2(newPath, content, "utf-8");
           if (oldPath.toLowerCase() !== newPath.toLowerCase()) {
@@ -611,7 +653,7 @@ function registerBinSymlinks(name) {
   for (const suffix of ["", "-opencode"]) {
     const linkName = `${name}${suffix}`;
     const linkPath = path3.join(binDir, linkName);
-    if (existsSync3(linkPath)) {
+    if (existsSync4(linkPath)) {
       skipped.push(linkName);
       continue;
     }
@@ -786,7 +828,7 @@ var init_provider_table = __esm({
 });
 
 // src/lib/intercom-queue.ts
-import { readFileSync as readFileSync5, writeFileSync as writeFileSync4, renameSync as renameSync3, existsSync as existsSync4, mkdirSync as mkdirSync3 } from "fs";
+import { readFileSync as readFileSync5, writeFileSync as writeFileSync4, renameSync as renameSync3, existsSync as existsSync5, mkdirSync as mkdirSync3 } from "fs";
 import path6 from "path";
 import os4 from "os";
 var QUEUE_PATH, TTL_MS, INTERCOM_LOG;
@@ -1438,13 +1480,50 @@ var init_database_adapter = __esm({
   }
 });
 
+// src/lib/daemon-auth.ts
+import crypto from "crypto";
+import path8 from "path";
+import { existsSync as existsSync6, readFileSync as readFileSync6, writeFileSync as writeFileSync5 } from "fs";
+function normalizeToken(token) {
+  if (!token) return null;
+  const trimmed = token.trim();
+  return trimmed.length > 0 ? trimmed : null;
+}
+function readDaemonToken() {
+  try {
+    if (!existsSync6(DAEMON_TOKEN_PATH)) return null;
+    return normalizeToken(readFileSync6(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);
+  writeFileSync5(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 = path8.join(EXE_AI_DIR, "exed.token");
+  }
+});
+
 // src/lib/exe-daemon-client.ts
 import net from "net";
 import os6 from "os";
 import { spawn } from "child_process";
 import { randomUUID } from "crypto";
-import { existsSync as existsSync5, unlinkSync as unlinkSync3, readFileSync as readFileSync6, openSync, closeSync, statSync } from "fs";
-import path8 from "path";
+import { existsSync as existsSync7, unlinkSync as unlinkSync3, readFileSync as readFileSync7, openSync, closeSync, statSync } from "fs";
+import path9 from "path";
 import { fileURLToPath } from "url";
 function handleData(chunk) {
   _buffer += chunk.toString();
@@ -1472,9 +1551,9 @@ function handleData(chunk) {
   }
 }
 function cleanupStaleFiles() {
-  if (existsSync5(PID_PATH)) {
+  if (existsSync7(PID_PATH)) {
     try {
-      const pid = parseInt(readFileSync6(PID_PATH, "utf8").trim(), 10);
+      const pid = parseInt(readFileSync7(PID_PATH, "utf8").trim(), 10);
       if (pid > 0) {
         try {
           process.kill(pid, 0);
@@ -1495,11 +1574,11 @@ function cleanupStaleFiles() {
   }
 }
 function findPackageRoot() {
-  let dir = path8.dirname(fileURLToPath(import.meta.url));
-  const { root } = path8.parse(dir);
+  let dir = path9.dirname(fileURLToPath(import.meta.url));
+  const { root } = path9.parse(dir);
   while (dir !== root) {
-    if (existsSync5(path8.join(dir, "package.json"))) return dir;
-    dir = path8.dirname(dir);
+    if (existsSync7(path9.join(dir, "package.json"))) return dir;
+    dir = path9.dirname(dir);
   }
   return null;
 }
@@ -1525,16 +1604,17 @@ function spawnDaemon() {
     process.stderr.write("[exed-client] WARN: cannot find package root\n");
     return;
   }
-  const daemonPath = path8.join(pkgRoot, "dist", "lib", "exe-daemon.js");
-  if (!existsSync5(daemonPath)) {
+  const daemonPath = path9.join(pkgRoot, "dist", "lib", "exe-daemon.js");
+  if (!existsSync7(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 = path8.join(path8.dirname(SOCKET_PATH), "exed.log");
+  const logPath = path9.join(path9.dirname(SOCKET_PATH), "exed.log");
   let stderrFd = "ignore";
   try {
     stderrFd = openSync(logPath, "a");
@@ -1552,7 +1632,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();
@@ -1659,13 +1740,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);
@@ -1676,17 +1758,19 @@ function sendDaemonRequest(payload, timeoutMs = REQUEST_TIMEOUT_MS) {
 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, _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, _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 ?? path8.join(EXE_AI_DIR, "exed.sock");
-    PID_PATH = process.env.EXE_DAEMON_PID ?? process.env.EXE_EMBED_PID ?? path8.join(EXE_AI_DIR, "exed.pid");
-    SPAWN_LOCK_PATH = path8.join(EXE_AI_DIR, "exed-spawn.lock");
+    init_daemon_auth();
+    SOCKET_PATH = process.env.EXE_DAEMON_SOCK ?? process.env.EXE_EMBED_SOCK ?? path9.join(EXE_AI_DIR, "exed.sock");
+    PID_PATH = process.env.EXE_DAEMON_PID ?? process.env.EXE_EMBED_PID ?? path9.join(EXE_AI_DIR, "exed.pid");
+    SPAWN_LOCK_PATH = path9.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 = "";
@@ -2265,6 +2349,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
     );
@@ -2273,7 +2358,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);
@@ -2311,6 +2396,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',
@@ -2324,10 +2410,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({
@@ -2911,6 +3018,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) {
@@ -2949,24 +3063,27 @@ var init_database = __esm({
 });
 
 // src/lib/license.ts
-import { readFileSync as readFileSync7, writeFileSync as writeFileSync5, existsSync as existsSync6, mkdirSync as mkdirSync4 } from "fs";
+import { readFileSync as readFileSync8, writeFileSync as writeFileSync6, existsSync as existsSync8, mkdirSync as mkdirSync4 } from "fs";
 import { randomUUID as randomUUID2 } from "crypto";
-import path9 from "path";
+import { createRequire as createRequire2 } from "module";
+import { pathToFileURL as pathToFileURL2 } from "url";
+import os7 from "os";
+import path10 from "path";
 import { jwtVerify, importSPKI } from "jose";
 var LICENSE_PATH, CACHE_PATH, DEVICE_ID_PATH;
 var init_license = __esm({
   "src/lib/license.ts"() {
     "use strict";
     init_config();
-    LICENSE_PATH = path9.join(EXE_AI_DIR, "license.key");
-    CACHE_PATH = path9.join(EXE_AI_DIR, "license-cache.json");
-    DEVICE_ID_PATH = path9.join(EXE_AI_DIR, "device-id");
+    LICENSE_PATH = path10.join(EXE_AI_DIR, "license.key");
+    CACHE_PATH = path10.join(EXE_AI_DIR, "license-cache.json");
+    DEVICE_ID_PATH = path10.join(EXE_AI_DIR, "device-id");
   }
 });
 
 // src/lib/plan-limits.ts
-import { readFileSync as readFileSync8, existsSync as existsSync7 } from "fs";
-import path10 from "path";
+import { readFileSync as readFileSync9, existsSync as existsSync9 } from "fs";
+import path11 from "path";
 var CACHE_PATH2;
 var init_plan_limits = __esm({
   "src/lib/plan-limits.ts"() {
@@ -2975,14 +3092,14 @@ var init_plan_limits = __esm({
     init_employees();
     init_license();
     init_config();
-    CACHE_PATH2 = path10.join(EXE_AI_DIR, "license-cache.json");
+    CACHE_PATH2 = path11.join(EXE_AI_DIR, "license-cache.json");
   }
 });
 
 // src/lib/tmux-routing.ts
-import { readFileSync as readFileSync9, writeFileSync as writeFileSync6, mkdirSync as mkdirSync5, existsSync as existsSync8, appendFileSync, readdirSync as readdirSync2 } from "fs";
-import path11 from "path";
-import os7 from "os";
+import { readFileSync as readFileSync10, writeFileSync as writeFileSync7, mkdirSync as mkdirSync5, existsSync as existsSync10, appendFileSync, readdirSync as readdirSync2 } from "fs";
+import path12 from "path";
+import os8 from "os";
 import { fileURLToPath as fileURLToPath2 } from "url";
 function getMySession() {
   return getTransport().getMySession();
@@ -2995,7 +3112,7 @@ function extractRootExe(name) {
 }
 function getParentExe(sessionKey) {
   try {
-    const data = JSON.parse(readFileSync9(path11.join(SESSION_CACHE, `parent-exe-${sessionKey}.json`), "utf8"));
+    const data = JSON.parse(readFileSync10(path12.join(SESSION_CACHE, `parent-exe-${sessionKey}.json`), "utf8"));
     return data.parentExe || null;
   } catch {
     return null;
@@ -3038,10 +3155,10 @@ var init_tmux_routing = __esm({
     init_intercom_queue();
     init_plan_limits();
     init_employees();
-    SPAWN_LOCK_DIR = path11.join(os7.homedir(), ".exe-os", "spawn-locks");
-    SESSION_CACHE = path11.join(os7.homedir(), ".exe-os", "session-cache");
-    INTERCOM_LOG2 = path11.join(os7.homedir(), ".exe-os", "intercom.log");
-    DEBOUNCE_FILE = path11.join(SESSION_CACHE, "intercom-debounce.json");
+    SPAWN_LOCK_DIR = path12.join(os8.homedir(), ".exe-os", "spawn-locks");
+    SESSION_CACHE = path12.join(os8.homedir(), ".exe-os", "session-cache");
+    INTERCOM_LOG2 = path12.join(os8.homedir(), ".exe-os", "intercom.log");
+    DEBOUNCE_FILE = path12.join(SESSION_CACHE, "intercom-debounce.json");
     DEBOUNCE_CLEANUP_AGE_MS = 5 * 60 * 1e3;
   }
 });
@@ -3083,9 +3200,9 @@ __export(cto_delegation_gate_exports, {
   hasValidScratchpadEscape: () => hasValidScratchpadEscape,
   scratchpadPath: () => scratchpadPath
 });
-import os8 from "os";
-import path12 from "path";
-import { existsSync as existsSync9, readFileSync as readFileSync10, statSync as statSync2 } from "fs";
+import os9 from "os";
+import path13 from "path";
+import { existsSync as existsSync11, readFileSync as readFileSync11, statSync as statSync2 } from "fs";
 function resolveGatedAgent() {
   try {
     const employees = loadEmployeesSync();
@@ -3099,12 +3216,12 @@ function getGatedAgent() {
   return resolveGatedAgent() || GATED_AGENT;
 }
 function toWorkspaceRelative(filePath, cwd = process.cwd()) {
-  const normalized = path12.normalize(filePath);
-  if (normalized.startsWith(cwd + path12.sep)) {
+  const normalized = path13.normalize(filePath);
+  if (normalized.startsWith(cwd + path13.sep)) {
     return normalized.slice(cwd.length + 1);
   }
-  if (path12.isAbsolute(normalized)) {
-    return path12.basename(normalized);
+  if (path13.isAbsolute(normalized)) {
+    return path13.basename(normalized);
   }
   return normalized;
 }
@@ -3113,8 +3230,8 @@ function isDockerfile(basename) {
 }
 function classifyPath(filePath, cwd) {
   const rel = toWorkspaceRelative(filePath, cwd);
-  const basename = path12.basename(rel);
-  const ext = path12.extname(rel).toLowerCase();
+  const basename = path13.basename(rel);
+  const ext = path13.extname(rel).toLowerCase();
   if (ext === ".md") {
     for (const prefix of EXEMPT_MD_DIR_PREFIXES) {
       if (rel.startsWith(prefix)) return "exempt";
@@ -3156,22 +3273,22 @@ async function hasRecentEngineerDispatch(now = Date.now()) {
     return false;
   }
 }
-function scratchpadPath(sessionId, homeDir = os8.homedir()) {
-  return path12.join(
+function scratchpadPath(sessionId, homeDir = os9.homedir()) {
+  return path13.join(
     homeDir,
     ".exe-os",
     "session-cache",
     `cto-scratchpad-${sessionId}.txt`
   );
 }
-function hasValidScratchpadEscape(sessionId, now = Date.now(), homeDir = os8.homedir()) {
+function hasValidScratchpadEscape(sessionId, now = Date.now(), homeDir = os9.homedir()) {
   const paths = [scratchpadPath(sessionId, homeDir)];
   for (const filePath of paths) {
-    if (!existsSync9(filePath)) continue;
+    if (!existsSync11(filePath)) continue;
     try {
       const stat = statSync2(filePath);
       if (now - stat.mtimeMs > SCRATCHPAD_MAX_AGE_MS) continue;
-      const body = readFileSync10(filePath, "utf-8");
+      const body = readFileSync11(filePath, "utf-8");
       if (SCRATCHPAD_ESCAPE_PATTERN.test(body)) return true;
     } catch {
     }
@@ -3262,14 +3379,14 @@ var init_memory = __esm({
 
 // src/lib/keychain.ts
 import { readFile as readFile3, writeFile as writeFile3, unlink, mkdir as mkdir3, chmod as chmod2 } from "fs/promises";
-import { existsSync as existsSync10 } from "fs";
-import path13 from "path";
-import os9 from "os";
+import { existsSync as existsSync12 } from "fs";
+import path14 from "path";
+import os10 from "os";
 function getKeyDir() {
-  return process.env.EXE_OS_DIR ?? process.env.EXE_MEM_DIR ?? path13.join(os9.homedir(), ".exe-os");
+  return process.env.EXE_OS_DIR ?? process.env.EXE_MEM_DIR ?? path14.join(os10.homedir(), ".exe-os");
 }
 function getKeyPath() {
-  return path13.join(getKeyDir(), "master.key");
+  return path14.join(getKeyDir(), "master.key");
 }
 async function tryKeytar() {
   try {
@@ -3290,9 +3407,9 @@ async function getMasterKey() {
     }
   }
   const keyPath = getKeyPath();
-  if (!existsSync10(keyPath)) {
+  if (!existsSync12(keyPath)) {
     process.stderr.write(
-      `[keychain] Key not found at ${keyPath} (HOME=${os9.homedir()}, EXE_OS_DIR=${process.env.EXE_OS_DIR ?? "unset"})
+      `[keychain] Key not found at ${keyPath} (HOME=${os10.homedir()}, EXE_OS_DIR=${process.env.EXE_OS_DIR ?? "unset"})
 `
     );
     return null;
@@ -3377,6 +3494,7 @@ var shard_manager_exports = {};
 __export(shard_manager_exports, {
   disposeShards: () => disposeShards,
   ensureShardSchema: () => ensureShardSchema,
+  getOpenShardCount: () => getOpenShardCount,
   getReadyShardClient: () => getReadyShardClient,
   getShardClient: () => getShardClient,
   getShardsDir: () => getShardsDir,
@@ -3385,15 +3503,18 @@ __export(shard_manager_exports, {
   listShards: () => listShards,
   shardExists: () => shardExists
 });
-import path14 from "path";
-import { existsSync as existsSync11, mkdirSync as mkdirSync6, readdirSync as readdirSync3 } from "fs";
+import path15 from "path";
+import { existsSync as existsSync13, mkdirSync as mkdirSync6, readdirSync as readdirSync3 } from "fs";
 import { createClient as createClient2 } from "@libsql/client";
 function initShardManager(encryptionKey) {
   _encryptionKey = encryptionKey;
-  if (!existsSync11(SHARDS_DIR)) {
+  if (!existsSync13(SHARDS_DIR)) {
     mkdirSync6(SHARDS_DIR, { recursive: true });
   }
   _shardingEnabled = true;
+  if (_evictionTimer) clearInterval(_evictionTimer);
+  _evictionTimer = setInterval(evictIdleShards, EVICTION_INTERVAL_MS);
+  _evictionTimer.unref();
 }
 function isShardingEnabled() {
   return _shardingEnabled;
@@ -3410,21 +3531,28 @@ function getShardClient(projectName) {
     throw new Error(`Invalid project name for shard: "${projectName}"`);
   }
   const cached = _shards.get(safeName);
-  if (cached) return cached;
-  const dbPath = path14.join(SHARDS_DIR, `${safeName}.db`);
+  if (cached) {
+    _shardLastAccess.set(safeName, Date.now());
+    return cached;
+  }
+  while (_shards.size >= MAX_OPEN_SHARDS) {
+    evictLRU();
+  }
+  const dbPath = path15.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 existsSync11(path14.join(SHARDS_DIR, `${safeName}.db`));
+  return existsSync13(path15.join(SHARDS_DIR, `${safeName}.db`));
 }
 function listShards() {
-  if (!existsSync11(SHARDS_DIR)) return [];
+  if (!existsSync13(SHARDS_DIR)) return [];
   return readdirSync3(SHARDS_DIR).filter((f) => f.endsWith(".db")).map((f) => f.replace(".db", ""));
 }
 async function ensureShardSchema(client) {
@@ -3476,6 +3604,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",
@@ -3613,21 +3743,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 = path14.join(EXE_AI_DIR, "shards");
+    SHARDS_DIR = path15.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;
   }
@@ -4400,7 +4578,7 @@ __export(review_gate_exports, {
   runReviewGate: () => runReviewGate
 });
 import { execSync as execSync5 } from "child_process";
-import { existsSync as existsSync12 } from "fs";
+import { existsSync as existsSync14 } from "fs";
 function checkCommitsExist(taskCreatedAt) {
   try {
     const since = new Date(taskCreatedAt).toISOString();
@@ -4463,7 +4641,7 @@ function checkTestCoverage(taskCreatedAt) {
       const testPath = file.replace(/^src\//, "tests/").replace(/\.ts$/, ".test.ts");
       const baseName = file.split("/").pop()?.replace(/\.ts$/, "") ?? "";
       const testDir = testPath.substring(0, testPath.lastIndexOf("/"));
-      const hasDirectTest = existsSync12(testPath);
+      const hasDirectTest = existsSync14(testPath);
       let hasRelatedTest = false;
       try {
         const related = execSync5(
@@ -4517,9 +4695,9 @@ var init_review_gate = __esm({
 });
 
 // src/adapters/claude/hooks/pre-tool-use.ts
-import { existsSync as existsSync13, writeFileSync as writeFileSync7, mkdirSync as mkdirSync7 } from "fs";
+import { existsSync as existsSync15, writeFileSync as writeFileSync8, mkdirSync as mkdirSync7 } from "fs";
 import { execSync as execSync6 } from "child_process";
-import path15 from "path";
+import path16 from "path";
 
 // src/lib/active-agent.ts
 init_config();
@@ -4633,17 +4811,17 @@ if (!process.env.AGENT_ID) {
 }
 var DELEGATION_TASK_THRESHOLD = 3;
 var CTO_ROLES = ["CTO", "executive"];
-var CACHE_DIR2 = path15.join(EXE_AI_DIR, "session-cache");
+var CACHE_DIR2 = path16.join(EXE_AI_DIR, "session-cache");
 var timeout = setTimeout(() => {
   process.exit(0);
 }, 5e3);
 timeout.unref();
 function getDelegationFlagPath() {
-  return path15.join(CACHE_DIR2, `delegation-checkpoint-${getSessionKey()}.json`);
+  return path16.join(CACHE_DIR2, `delegation-checkpoint-${getSessionKey()}.json`);
 }
 function hasDelegationFired() {
   try {
-    return existsSync13(getDelegationFlagPath());
+    return existsSync15(getDelegationFlagPath());
   } catch {
     return false;
   }
@@ -4651,7 +4829,7 @@ function hasDelegationFired() {
 function markDelegationFired() {
   try {
     mkdirSync7(CACHE_DIR2, { recursive: true });
-    writeFileSync7(getDelegationFlagPath(), JSON.stringify({ fired: true }));
+    writeFileSync8(getDelegationFlagPath(), JSON.stringify({ fired: true }));
   } catch {
   }
 }