@askexenow/exe-os 0.9.12 → 0.9.13

package/dist/hooks/session-end.js

@@ -391,13 +391,13 @@ var init_employees = __esm({
 });
 
 // src/lib/session-registry.ts
-import { readFileSync as readFileSync4, writeFileSync as writeFileSync3, mkdirSync as mkdirSync3, existsSync as existsSync4 } from "fs";
-import path4 from "path";
-import os3 from "os";
+import { readFileSync as readFileSync5, writeFileSync as writeFileSync4, mkdirSync as mkdirSync4, existsSync as existsSync5 } from "fs";
+import path5 from "path";
+import os4 from "os";
 function registerSession(entry) {
-  const dir = path4.dirname(REGISTRY_PATH);
-  if (!existsSync4(dir)) {
-    mkdirSync3(dir, { recursive: true });
+  const dir = path5.dirname(REGISTRY_PATH);
+  if (!existsSync5(dir)) {
+    mkdirSync4(dir, { recursive: true });
   }
   const sessions = listSessions();
   const idx = sessions.findIndex((s) => s.windowName === entry.windowName);
@@ -406,11 +406,11 @@ function registerSession(entry) {
   } else {
     sessions.push(entry);
   }
-  writeFileSync3(REGISTRY_PATH, JSON.stringify(sessions, null, 2));
+  writeFileSync4(REGISTRY_PATH, JSON.stringify(sessions, null, 2));
 }
 function listSessions() {
   try {
-    const raw = readFileSync4(REGISTRY_PATH, "utf8");
+    const raw = readFileSync5(REGISTRY_PATH, "utf8");
     return JSON.parse(raw);
   } catch {
     return [];
@@ -420,7 +420,7 @@ var REGISTRY_PATH;
 var init_session_registry = __esm({
   "src/lib/session-registry.ts"() {
     "use strict";
-    REGISTRY_PATH = path4.join(os3.homedir(), ".exe-os", "session-registry.json");
+    REGISTRY_PATH = path5.join(os4.homedir(), ".exe-os", "session-registry.json");
   }
 });
 
@@ -632,12 +632,12 @@ var init_runtime_table = __esm({
 });
 
 // src/lib/agent-config.ts
-import { readFileSync as readFileSync5, writeFileSync as writeFileSync4, existsSync as existsSync5 } from "fs";
-import path5 from "path";
+import { readFileSync as readFileSync6, writeFileSync as writeFileSync5, existsSync as existsSync6 } from "fs";
+import path6 from "path";
 function loadAgentConfig() {
-  if (!existsSync5(AGENT_CONFIG_PATH)) return {};
+  if (!existsSync6(AGENT_CONFIG_PATH)) return {};
   try {
-    return JSON.parse(readFileSync5(AGENT_CONFIG_PATH, "utf-8"));
+    return JSON.parse(readFileSync6(AGENT_CONFIG_PATH, "utf-8"));
   } catch {
     return {};
   }
@@ -657,7 +657,7 @@ var init_agent_config = __esm({
     init_config();
     init_runtime_table();
     init_secure_files();
-    AGENT_CONFIG_PATH = path5.join(EXE_AI_DIR, "agent-config.json");
+    AGENT_CONFIG_PATH = path6.join(EXE_AI_DIR, "agent-config.json");
     DEFAULT_MODELS = {
       claude: "claude-opus-4",
       codex: RUNTIME_TABLE.codex?.defaultModel ?? "gpt-5.4",
@@ -675,17 +675,17 @@ __export(intercom_queue_exports, {
   queueIntercom: () => queueIntercom,
   readQueue: () => readQueue
 });
-import { readFileSync as readFileSync6, writeFileSync as writeFileSync5, renameSync as renameSync3, existsSync as existsSync6, mkdirSync as mkdirSync4 } from "fs";
-import path6 from "path";
-import os4 from "os";
+import { readFileSync as readFileSync7, writeFileSync as writeFileSync6, renameSync as renameSync3, existsSync as existsSync7, mkdirSync as mkdirSync5 } from "fs";
+import path7 from "path";
+import os5 from "os";
 function ensureDir() {
-  const dir = path6.dirname(QUEUE_PATH);
-  if (!existsSync6(dir)) mkdirSync4(dir, { recursive: true });
+  const dir = path7.dirname(QUEUE_PATH);
+  if (!existsSync7(dir)) mkdirSync5(dir, { recursive: true });
 }
 function readQueue() {
   try {
-    if (!existsSync6(QUEUE_PATH)) return [];
-    return JSON.parse(readFileSync6(QUEUE_PATH, "utf8"));
+    if (!existsSync7(QUEUE_PATH)) return [];
+    return JSON.parse(readFileSync7(QUEUE_PATH, "utf8"));
   } catch {
     return [];
   }
@@ -693,7 +693,7 @@ function readQueue() {
 function writeQueue(queue) {
   ensureDir();
   const tmp = `${QUEUE_PATH}.tmp`;
-  writeFileSync5(tmp, JSON.stringify(queue, null, 2));
+  writeFileSync6(tmp, JSON.stringify(queue, null, 2));
   renameSync3(tmp, QUEUE_PATH);
 }
 function queueIntercom(targetSession, reason) {
@@ -785,10 +785,10 @@ var QUEUE_PATH, MAX_RETRIES, TTL_MS, INTERCOM_LOG;
 var init_intercom_queue = __esm({
   "src/lib/intercom-queue.ts"() {
     "use strict";
-    QUEUE_PATH = path6.join(os4.homedir(), ".exe-os", "intercom-queue.json");
+    QUEUE_PATH = path7.join(os5.homedir(), ".exe-os", "intercom-queue.json");
     MAX_RETRIES = 5;
     TTL_MS = 60 * 60 * 1e3;
-    INTERCOM_LOG = path6.join(os4.homedir(), ".exe-os", "intercom.log");
+    INTERCOM_LOG = path7.join(os5.homedir(), ".exe-os", "intercom.log");
   }
 });
 
@@ -848,8 +848,8 @@ var init_db_retry = __esm({
 });
 
 // src/lib/database-adapter.ts
-import os5 from "os";
-import path7 from "path";
+import os6 from "os";
+import path8 from "path";
 import { createRequire } from "module";
 import { pathToFileURL } from "url";
 function quotedIdentifier(identifier) {
@@ -1160,8 +1160,8 @@ async function loadPrismaClient() {
         }
         return new PrismaClient2();
       }
-      const exeDbRoot = process.env.EXE_DB_ROOT ?? path7.join(os5.homedir(), "exe-db");
-      const requireFromExeDb = createRequire(path7.join(exeDbRoot, "package.json"));
+      const exeDbRoot = process.env.EXE_DB_ROOT ?? path8.join(os6.homedir(), "exe-db");
+      const requireFromExeDb = createRequire(path8.join(exeDbRoot, "package.json"));
       const prismaEntry = requireFromExeDb.resolve("@prisma/client");
       const module = await import(pathToFileURL(prismaEntry).href);
       const PrismaClient = module.PrismaClient ?? module.default?.PrismaClient;
@@ -1433,8 +1433,8 @@ var init_database_adapter = __esm({
 
 // src/lib/daemon-auth.ts
 import crypto from "crypto";
-import path8 from "path";
-import { existsSync as existsSync7, readFileSync as readFileSync7, writeFileSync as writeFileSync6 } from "fs";
+import path9 from "path";
+import { existsSync as existsSync8, readFileSync as readFileSync8, writeFileSync as writeFileSync7 } from "fs";
 function normalizeToken(token) {
   if (!token) return null;
   const trimmed = token.trim();
@@ -1442,8 +1442,8 @@ function normalizeToken(token) {
 }
 function readDaemonToken() {
   try {
-    if (!existsSync7(DAEMON_TOKEN_PATH)) return null;
-    return normalizeToken(readFileSync7(DAEMON_TOKEN_PATH, "utf8"));
+    if (!existsSync8(DAEMON_TOKEN_PATH)) return null;
+    return normalizeToken(readFileSync8(DAEMON_TOKEN_PATH, "utf8"));
   } catch {
     return null;
   }
@@ -1453,7 +1453,7 @@ function ensureDaemonToken(seed) {
   if (existing) return existing;
   const token = normalizeToken(seed) ?? crypto.randomBytes(32).toString("hex");
   ensurePrivateDirSync(EXE_AI_DIR);
-  writeFileSync6(DAEMON_TOKEN_PATH, `${token}
+  writeFileSync7(DAEMON_TOKEN_PATH, `${token}
 `, "utf8");
   enforcePrivateFileSync(DAEMON_TOKEN_PATH);
   return token;
@@ -1464,17 +1464,17 @@ var init_daemon_auth = __esm({
     "use strict";
     init_config();
     init_secure_files();
-    DAEMON_TOKEN_PATH = path8.join(EXE_AI_DIR, "exed.token");
+    DAEMON_TOKEN_PATH = path9.join(EXE_AI_DIR, "exed.token");
   }
 });
 
 // src/lib/exe-daemon-client.ts
 import net from "net";
-import os6 from "os";
+import os7 from "os";
 import { spawn } from "child_process";
 import { randomUUID } from "crypto";
-import { existsSync as existsSync8, unlinkSync as unlinkSync3, readFileSync as readFileSync8, openSync, closeSync, statSync } from "fs";
-import path9 from "path";
+import { existsSync as existsSync9, unlinkSync as unlinkSync4, readFileSync as readFileSync9, openSync, closeSync, statSync } from "fs";
+import path10 from "path";
 import { fileURLToPath } from "url";
 function handleData(chunk) {
   _buffer += chunk.toString();
@@ -1502,9 +1502,9 @@ function handleData(chunk) {
   }
 }
 function cleanupStaleFiles() {
-  if (existsSync8(PID_PATH)) {
+  if (existsSync9(PID_PATH)) {
     try {
-      const pid = parseInt(readFileSync8(PID_PATH, "utf8").trim(), 10);
+      const pid = parseInt(readFileSync9(PID_PATH, "utf8").trim(), 10);
       if (pid > 0) {
         try {
           process.kill(pid, 0);
@@ -1515,27 +1515,27 @@ function cleanupStaleFiles() {
     } catch {
     }
     try {
-      unlinkSync3(PID_PATH);
+      unlinkSync4(PID_PATH);
     } catch {
     }
     try {
-      unlinkSync3(SOCKET_PATH);
+      unlinkSync4(SOCKET_PATH);
     } catch {
     }
   }
 }
 function findPackageRoot() {
-  let dir = path9.dirname(fileURLToPath(import.meta.url));
-  const { root } = path9.parse(dir);
+  let dir = path10.dirname(fileURLToPath(import.meta.url));
+  const { root } = path10.parse(dir);
   while (dir !== root) {
-    if (existsSync8(path9.join(dir, "package.json"))) return dir;
-    dir = path9.dirname(dir);
+    if (existsSync9(path10.join(dir, "package.json"))) return dir;
+    dir = path10.dirname(dir);
   }
   return null;
 }
 function spawnDaemon() {
-  const freeGB = os6.freemem() / (1024 * 1024 * 1024);
-  const totalGB = os6.totalmem() / (1024 * 1024 * 1024);
+  const freeGB = os7.freemem() / (1024 * 1024 * 1024);
+  const totalGB = os7.totalmem() / (1024 * 1024 * 1024);
   if (totalGB <= 8) {
     process.stderr.write(
       `[exed-client] SKIP: ${totalGB.toFixed(0)}GB system \u2014 embedding daemon disabled. Using keyword search only. Minimum 16GB recommended for vector search.
@@ -1555,8 +1555,8 @@ function spawnDaemon() {
     process.stderr.write("[exed-client] WARN: cannot find package root\n");
     return;
   }
-  const daemonPath = path9.join(pkgRoot, "dist", "lib", "exe-daemon.js");
-  if (!existsSync8(daemonPath)) {
+  const daemonPath = path10.join(pkgRoot, "dist", "lib", "exe-daemon.js");
+  if (!existsSync9(daemonPath)) {
     process.stderr.write(`[exed-client] WARN: daemon script not found at ${daemonPath}
 `);
     return;
@@ -1565,7 +1565,7 @@ function spawnDaemon() {
   const daemonToken = ensureDaemonToken(process.env[DAEMON_TOKEN_ENV] ?? null);
   process.stderr.write(`[exed-client] Spawning daemon: ${resolvedPath}
 `);
-  const logPath = path9.join(path9.dirname(SOCKET_PATH), "exed.log");
+  const logPath = path10.join(path10.dirname(SOCKET_PATH), "exed.log");
   let stderrFd = "ignore";
   try {
     stderrFd = openSync(logPath, "a");
@@ -1605,7 +1605,7 @@ function acquireSpawnLock() {
       const stat = statSync(SPAWN_LOCK_PATH);
       if (Date.now() - stat.mtimeMs > SPAWN_LOCK_STALE_MS) {
         try {
-          unlinkSync3(SPAWN_LOCK_PATH);
+          unlinkSync4(SPAWN_LOCK_PATH);
         } catch {
         }
         try {
@@ -1622,7 +1622,7 @@ function acquireSpawnLock() {
 }
 function releaseSpawnLock() {
   try {
-    unlinkSync3(SPAWN_LOCK_PATH);
+    unlinkSync4(SPAWN_LOCK_PATH);
   } catch {
   }
 }
@@ -1715,9 +1715,9 @@ var init_exe_daemon_client = __esm({
     "use strict";
     init_config();
     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");
+    SOCKET_PATH = process.env.EXE_DAEMON_SOCK ?? process.env.EXE_EMBED_SOCK ?? path10.join(EXE_AI_DIR, "exed.sock");
+    PID_PATH = process.env.EXE_DAEMON_PID ?? process.env.EXE_EMBED_PID ?? path10.join(EXE_AI_DIR, "exed.pid");
+    SPAWN_LOCK_PATH = path10.join(EXE_AI_DIR, "exed-spawn.lock");
     SPAWN_LOCK_STALE_MS = 3e4;
     CONNECT_TIMEOUT_MS = 15e3;
     REQUEST_TIMEOUT_MS = 3e4;
@@ -2794,12 +2794,26 @@ async function ensureSchema() {
       session_name TEXT,
       task_id TEXT,
       project_name TEXT,
-      started_at TEXT NOT NULL
+      started_at TEXT NOT NULL,
+      cache_cold_count INTEGER NOT NULL DEFAULT 0
     );
 
     CREATE INDEX IF NOT EXISTS idx_session_agent_map_agent
       ON session_agent_map(agent_id);
   `);
+  await client.executeMultiple(`
+    CREATE TABLE IF NOT EXISTS agent_file_reads (
+      session_uuid TEXT NOT NULL,
+      agent_id TEXT NOT NULL,
+      file_path TEXT NOT NULL,
+      read_at TEXT NOT NULL,
+      commit_hash TEXT,
+      PRIMARY KEY (session_uuid, file_path)
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_agent_file_reads_agent_read_at
+      ON agent_file_reads(agent_id, read_at);
+  `);
   try {
     const mapCount = await client.execute({ sql: `SELECT COUNT(*) as cnt FROM session_agent_map`, args: [] });
     if (Number(mapCount.rows[0]?.cnt ?? 0) === 0) {
@@ -2814,6 +2828,13 @@ async function ensureSchema() {
     }
   } catch {
   }
+  try {
+    await client.execute({
+      sql: `ALTER TABLE session_agent_map ADD COLUMN cache_cold_count INTEGER NOT NULL DEFAULT 0`,
+      args: []
+    });
+  } catch {
+  }
   try {
     await client.execute({
       sql: `ALTER TABLE tasks ADD COLUMN budget_tokens INTEGER`,
@@ -3014,21 +3035,21 @@ var init_database = __esm({
 });
 
 // src/lib/license.ts
-import { readFileSync as readFileSync9, writeFileSync as writeFileSync7, existsSync as existsSync9, mkdirSync as mkdirSync5 } from "fs";
+import { readFileSync as readFileSync10, writeFileSync as writeFileSync8, existsSync as existsSync10, mkdirSync as mkdirSync6 } from "fs";
 import { randomUUID as randomUUID2 } from "crypto";
 import { createRequire as createRequire2 } from "module";
 import { pathToFileURL as pathToFileURL2 } from "url";
-import os7 from "os";
-import path10 from "path";
+import os8 from "os";
+import path11 from "path";
 import { jwtVerify, importSPKI } from "jose";
 var LICENSE_PATH, CACHE_PATH, DEVICE_ID_PATH, PLAN_LIMITS;
 var init_license = __esm({
   "src/lib/license.ts"() {
     "use strict";
     init_config();
-    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");
+    LICENSE_PATH = path11.join(EXE_AI_DIR, "license.key");
+    CACHE_PATH = path11.join(EXE_AI_DIR, "license-cache.json");
+    DEVICE_ID_PATH = path11.join(EXE_AI_DIR, "device-id");
     PLAN_LIMITS = {
       free: { devices: 1, employees: 1, memories: 5e3 },
       pro: { devices: 3, employees: 5, memories: 1e5 },
@@ -3040,12 +3061,12 @@ var init_license = __esm({
 });
 
 // src/lib/plan-limits.ts
-import { readFileSync as readFileSync10, existsSync as existsSync10 } from "fs";
-import path11 from "path";
+import { readFileSync as readFileSync11, existsSync as existsSync11 } from "fs";
+import path12 from "path";
 function getLicenseSync() {
   try {
-    if (!existsSync10(CACHE_PATH2)) return freeLicense();
-    const raw = JSON.parse(readFileSync10(CACHE_PATH2, "utf8"));
+    if (!existsSync11(CACHE_PATH2)) return freeLicense();
+    const raw = JSON.parse(readFileSync11(CACHE_PATH2, "utf8"));
     if (!raw.token || typeof raw.token !== "string") return freeLicense();
     const parts = raw.token.split(".");
     if (parts.length !== 3) return freeLicense();
@@ -3083,8 +3104,8 @@ function assertEmployeeLimitSync(rosterPath) {
   const filePath = rosterPath ?? EMPLOYEES_PATH;
   let count = 0;
   try {
-    if (existsSync10(filePath)) {
-      const raw = readFileSync10(filePath, "utf8");
+    if (existsSync11(filePath)) {
+      const raw = readFileSync11(filePath, "utf8");
       const employees = JSON.parse(raw);
       count = Array.isArray(employees) ? employees.length : 0;
     }
@@ -3113,7 +3134,7 @@ var init_plan_limits = __esm({
         this.name = "PlanLimitError";
       }
     };
-    CACHE_PATH2 = path11.join(EXE_AI_DIR, "license-cache.json");
+    CACHE_PATH2 = path12.join(EXE_AI_DIR, "license-cache.json");
   }
 });
 
@@ -3130,13 +3151,13 @@ __export(notifications_exports, {
   writeNotification: () => writeNotification
 });
 import crypto2 from "crypto";
-import path12 from "path";
-import os8 from "os";
+import path13 from "path";
+import os9 from "os";
 import {
-  readFileSync as readFileSync11,
+  readFileSync as readFileSync12,
   readdirSync as readdirSync2,
-  unlinkSync as unlinkSync4,
-  existsSync as existsSync11,
+  unlinkSync as unlinkSync5,
+  existsSync as existsSync12,
   rmdirSync
 } from "fs";
 async function writeNotification(notification) {
@@ -3282,9 +3303,9 @@ function formatNotifications(notifications) {
   return lines.join("\n");
 }
 async function migrateJsonNotifications() {
-  const base = process.env.EXE_OS_DIR || process.env.EXE_MEM_DIR || path12.join(os8.homedir(), ".exe-os");
-  const notifDir = path12.join(base, "notifications");
-  if (!existsSync11(notifDir)) return 0;
+  const base = process.env.EXE_OS_DIR || process.env.EXE_MEM_DIR || path13.join(os9.homedir(), ".exe-os");
+  const notifDir = path13.join(base, "notifications");
+  if (!existsSync12(notifDir)) return 0;
   let migrated = 0;
   try {
     const files = readdirSync2(notifDir).filter((f) => f.endsWith(".json"));
@@ -3292,8 +3313,8 @@ async function migrateJsonNotifications() {
     const client = getClient();
     for (const file of files) {
       try {
-        const filePath = path12.join(notifDir, file);
-        const data = JSON.parse(readFileSync11(filePath, "utf8"));
+        const filePath = path13.join(notifDir, file);
+        const data = JSON.parse(readFileSync12(filePath, "utf8"));
         await client.execute({
           sql: `INSERT OR IGNORE INTO notifications (id, agent_id, agent_role, event, project, summary, task_file, session_scope, read, created_at)
                 VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
@@ -3310,7 +3331,7 @@ async function migrateJsonNotifications() {
             data.timestamp ?? (/* @__PURE__ */ new Date()).toISOString()
           ]
         });
-        unlinkSync4(filePath);
+        unlinkSync5(filePath);
         migrated++;
       } catch {
       }
@@ -3455,7 +3476,7 @@ var init_state_bus = __esm({
 
 // src/lib/project-name.ts
 import { execSync as execSync5 } from "child_process";
-import path13 from "path";
+import path14 from "path";
 function getProjectName(cwd) {
   const dir = cwd ?? process.cwd();
   if (_cached2 && _cachedCwd === dir) return _cached2;
@@ -3468,7 +3489,7 @@ function getProjectName(cwd) {
         timeout: 2e3,
         stdio: ["pipe", "pipe", "pipe"]
       }).trim();
-      repoRoot = path13.dirname(gitCommonDir);
+      repoRoot = path14.dirname(gitCommonDir);
     } catch {
       repoRoot = execSync5("git rev-parse --show-toplevel", {
         cwd: dir,
@@ -3477,11 +3498,11 @@ function getProjectName(cwd) {
         stdio: ["pipe", "pipe", "pipe"]
       }).trim();
     }
-    _cached2 = path13.basename(repoRoot);
+    _cached2 = path14.basename(repoRoot);
     _cachedCwd = dir;
     return _cached2;
   } catch {
-    _cached2 = path13.basename(dir);
+    _cached2 = path14.basename(dir);
     _cachedCwd = dir;
     return _cached2;
   }
@@ -3575,11 +3596,11 @@ __export(tasks_crud_exports, {
   writeCheckpoint: () => writeCheckpoint
 });
 import crypto4 from "crypto";
-import path14 from "path";
-import os9 from "os";
+import path15 from "path";
+import os10 from "os";
 import { execSync as execSync6 } from "child_process";
 import { mkdir as mkdir3, writeFile as writeFile3, appendFile } from "fs/promises";
-import { existsSync as existsSync12, readFileSync as readFileSync12 } from "fs";
+import { existsSync as existsSync13, readFileSync as readFileSync13 } from "fs";
 async function writeCheckpoint(input2) {
   const client = getClient();
   const row = await resolveTask(client, input2.taskId);
@@ -3773,8 +3794,8 @@ ${scopeMismatchWarning}` : scopeMismatchWarning;
   }
   if (input2.baseDir) {
     try {
-      await mkdir3(path14.join(input2.baseDir, "exe", "output"), { recursive: true });
-      await mkdir3(path14.join(input2.baseDir, "exe", "research"), { recursive: true });
+      await mkdir3(path15.join(input2.baseDir, "exe", "output"), { recursive: true });
+      await mkdir3(path15.join(input2.baseDir, "exe", "research"), { recursive: true });
       await ensureArchitectureDoc(input2.baseDir, input2.projectName);
       await ensureGitignoreExe(input2.baseDir);
     } catch {
@@ -3810,10 +3831,10 @@ ${scopeMismatchWarning}` : scopeMismatchWarning;
   });
   if (input2.baseDir) {
     try {
-      const EXE_OS_DIR = path14.join(os9.homedir(), ".exe-os");
-      const mdPath = path14.join(EXE_OS_DIR, taskFile);
-      const mdDir = path14.dirname(mdPath);
-      if (!existsSync12(mdDir)) await mkdir3(mdDir, { recursive: true });
+      const EXE_OS_DIR = path15.join(os10.homedir(), ".exe-os");
+      const mdPath = path15.join(EXE_OS_DIR, taskFile);
+      const mdDir = path15.dirname(mdPath);
+      if (!existsSync13(mdDir)) await mkdir3(mdDir, { recursive: true });
       const reviewer = input2.reviewer ?? input2.assignedBy;
       const mdContent = `# ${input2.title}
 
@@ -4113,9 +4134,9 @@ async function deleteTaskCore(taskId, _baseDir) {
   return { taskFile, assignedTo, assignedBy, taskSlug };
 }
 async function ensureArchitectureDoc(baseDir, projectName) {
-  const archPath = path14.join(baseDir, "exe", "ARCHITECTURE.md");
+  const archPath = path15.join(baseDir, "exe", "ARCHITECTURE.md");
   try {
-    if (existsSync12(archPath)) return;
+    if (existsSync13(archPath)) return;
     const template = [
       `# ${projectName} \u2014 System Architecture`,
       "",
@@ -4148,10 +4169,10 @@ async function ensureArchitectureDoc(baseDir, projectName) {
   }
 }
 async function ensureGitignoreExe(baseDir) {
-  const gitignorePath = path14.join(baseDir, ".gitignore");
+  const gitignorePath = path15.join(baseDir, ".gitignore");
   try {
-    if (existsSync12(gitignorePath)) {
-      const content = readFileSync12(gitignorePath, "utf-8");
+    if (existsSync13(gitignorePath)) {
+      const content = readFileSync13(gitignorePath, "utf-8");
       if (/^\/?exe\/?$/m.test(content)) return;
       await appendFile(gitignorePath, "\n# Employee task assignments (private)\n/exe/\n");
     } else {
@@ -4194,8 +4215,8 @@ __export(tasks_review_exports, {
   isStale: () => isStale,
   listPendingReviews: () => listPendingReviews
 });
-import path15 from "path";
-import { existsSync as existsSync13, readdirSync as readdirSync3, unlinkSync as unlinkSync5 } from "fs";
+import path16 from "path";
+import { existsSync as existsSync14, readdirSync as readdirSync3, unlinkSync as unlinkSync6 } from "fs";
 function formatAge(isoTimestamp) {
   if (!isoTimestamp) return "";
   const ms = Date.now() - new Date(isoTimestamp).getTime();
@@ -4464,11 +4485,11 @@ async function cleanupReviewFile(row, taskFile, _baseDir) {
     );
   }
   try {
-    const cacheDir = path15.join(EXE_AI_DIR, "session-cache");
-    if (existsSync13(cacheDir)) {
+    const cacheDir = path16.join(EXE_AI_DIR, "session-cache");
+    if (existsSync14(cacheDir)) {
       for (const f of readdirSync3(cacheDir)) {
         if (f.startsWith("review-notified-")) {
-          unlinkSync5(path15.join(cacheDir, f));
+          unlinkSync6(path16.join(cacheDir, f));
         }
       }
     }
@@ -4490,7 +4511,7 @@ var init_tasks_review = __esm({
 });
 
 // src/lib/tasks-chain.ts
-import path16 from "path";
+import path17 from "path";
 import { readFile as readFile3, writeFile as writeFile4 } from "fs/promises";
 async function cascadeUnblock(taskId, baseDir, now) {
   const client = getClient();
@@ -4507,7 +4528,7 @@ async function cascadeUnblock(taskId, baseDir, now) {
     });
     for (const ur of unblockedRows.rows) {
       try {
-        const ubFile = path16.join(baseDir, String(ur.task_file));
+        const ubFile = path17.join(baseDir, String(ur.task_file));
         let ubContent = await readFile3(ubFile, "utf-8");
         ubContent = ubContent.replace(/\*\*Status:\*\* blocked/, "**Status:** open");
         ubContent = ubContent.replace(/\n\*\*Blocked by:\*\*.*\n/, "\n");
@@ -4971,8 +4992,8 @@ __export(tasks_exports, {
   updateTaskStatus: () => updateTaskStatus,
   writeCheckpoint: () => writeCheckpoint
 });
-import path17 from "path";
-import { writeFileSync as writeFileSync8, mkdirSync as mkdirSync6, unlinkSync as unlinkSync6 } from "fs";
+import path18 from "path";
+import { writeFileSync as writeFileSync9, mkdirSync as mkdirSync7, unlinkSync as unlinkSync7 } from "fs";
 async function createTask(input2) {
   const result = await createTaskCore(input2);
   if (!input2.skipDispatch && result.status !== "blocked" && !process.env.VITEST) {
@@ -4991,14 +5012,14 @@ async function updateTask(input2) {
   const { row, taskFile, now, taskId } = await updateTaskStatus(input2);
   try {
     const agent = String(row.assigned_to);
-    const cacheDir = path17.join(EXE_AI_DIR, "session-cache");
-    const cachePath = path17.join(cacheDir, `current-task-${agent}.json`);
+    const cacheDir = path18.join(EXE_AI_DIR, "session-cache");
+    const cachePath = path18.join(cacheDir, `current-task-${agent}.json`);
     if (input2.status === "in_progress") {
-      mkdirSync6(cacheDir, { recursive: true });
-      writeFileSync8(cachePath, JSON.stringify({ taskId, title: String(row.title) }));
+      mkdirSync7(cacheDir, { recursive: true });
+      writeFileSync9(cachePath, JSON.stringify({ taskId, title: String(row.title) }));
     } else if (input2.status === "done" || input2.status === "blocked" || input2.status === "cancelled" || input2.status === "closed") {
       try {
-        unlinkSync6(cachePath);
+        unlinkSync7(cachePath);
       } catch {
       }
     }
@@ -5463,13 +5484,13 @@ __export(tmux_routing_exports, {
   verifyPaneAtCapacity: () => verifyPaneAtCapacity
 });
 import { execFileSync as execFileSync2, execSync as execSync7 } from "child_process";
-import { readFileSync as readFileSync13, writeFileSync as writeFileSync9, mkdirSync as mkdirSync7, existsSync as existsSync14, appendFileSync, readdirSync as readdirSync4 } from "fs";
-import path18 from "path";
-import os10 from "os";
+import { readFileSync as readFileSync14, writeFileSync as writeFileSync10, mkdirSync as mkdirSync8, existsSync as existsSync15, appendFileSync, readdirSync as readdirSync4 } from "fs";
+import path19 from "path";
+import os11 from "os";
 import { fileURLToPath as fileURLToPath2 } from "url";
-import { unlinkSync as unlinkSync7 } from "fs";
+import { unlinkSync as unlinkSync8 } from "fs";
 function spawnLockPath(sessionName) {
-  return path18.join(SPAWN_LOCK_DIR, `${sessionName}.lock`);
+  return path19.join(SPAWN_LOCK_DIR, `${sessionName}.lock`);
 }
 function isProcessAlive(pid) {
   try {
@@ -5480,13 +5501,13 @@ function isProcessAlive(pid) {
   }
 }
 function acquireSpawnLock2(sessionName) {
-  if (!existsSync14(SPAWN_LOCK_DIR)) {
-    mkdirSync7(SPAWN_LOCK_DIR, { recursive: true });
+  if (!existsSync15(SPAWN_LOCK_DIR)) {
+    mkdirSync8(SPAWN_LOCK_DIR, { recursive: true });
   }
   const lockFile = spawnLockPath(sessionName);
-  if (existsSync14(lockFile)) {
+  if (existsSync15(lockFile)) {
     try {
-      const lock = JSON.parse(readFileSync13(lockFile, "utf8"));
+      const lock = JSON.parse(readFileSync14(lockFile, "utf8"));
       const age = Date.now() - lock.timestamp;
       if (isProcessAlive(lock.pid) && age < 6e4) {
         return false;
@@ -5494,25 +5515,25 @@ function acquireSpawnLock2(sessionName) {
     } catch {
     }
   }
-  writeFileSync9(lockFile, JSON.stringify({ pid: process.pid, timestamp: Date.now() }));
+  writeFileSync10(lockFile, JSON.stringify({ pid: process.pid, timestamp: Date.now() }));
   return true;
 }
 function releaseSpawnLock2(sessionName) {
   try {
-    unlinkSync7(spawnLockPath(sessionName));
+    unlinkSync8(spawnLockPath(sessionName));
   } catch {
   }
 }
 function resolveBehaviorsExporterScript() {
   try {
     const thisFile = fileURLToPath2(import.meta.url);
-    const scriptPath = path18.join(
-      path18.dirname(thisFile),
+    const scriptPath = path19.join(
+      path19.dirname(thisFile),
       "..",
       "bin",
       "exe-export-behaviors.js"
     );
-    return existsSync14(scriptPath) ? scriptPath : null;
+    return existsSync15(scriptPath) ? scriptPath : null;
   } catch {
     return null;
   }
@@ -5578,12 +5599,12 @@ function extractRootExe(name) {
   return parts.length > 0 ? parts[parts.length - 1] : null;
 }
 function registerParentExe(sessionKey, parentExe, dispatchedBy) {
-  if (!existsSync14(SESSION_CACHE)) {
-    mkdirSync7(SESSION_CACHE, { recursive: true });
+  if (!existsSync15(SESSION_CACHE)) {
+    mkdirSync8(SESSION_CACHE, { recursive: true });
   }
   const rootExe = extractRootExe(parentExe) ?? parentExe;
-  const filePath = path18.join(SESSION_CACHE, `parent-exe-${sessionKey}.json`);
-  writeFileSync9(filePath, JSON.stringify({
+  const filePath = path19.join(SESSION_CACHE, `parent-exe-${sessionKey}.json`);
+  writeFileSync10(filePath, JSON.stringify({
     parentExe: rootExe,
     dispatchedBy: dispatchedBy || rootExe,
     registeredAt: (/* @__PURE__ */ new Date()).toISOString()
@@ -5591,7 +5612,7 @@ function registerParentExe(sessionKey, parentExe, dispatchedBy) {
 }
 function getParentExe(sessionKey) {
   try {
-    const data = JSON.parse(readFileSync13(path18.join(SESSION_CACHE, `parent-exe-${sessionKey}.json`), "utf8"));
+    const data = JSON.parse(readFileSync14(path19.join(SESSION_CACHE, `parent-exe-${sessionKey}.json`), "utf8"));
     return data.parentExe || null;
   } catch {
     return null;
@@ -5599,8 +5620,8 @@ function getParentExe(sessionKey) {
 }
 function getDispatchedBy(sessionKey) {
   try {
-    const data = JSON.parse(readFileSync13(
-      path18.join(SESSION_CACHE, `parent-exe-${sessionKey}.json`),
+    const data = JSON.parse(readFileSync14(
+      path19.join(SESSION_CACHE, `parent-exe-${sessionKey}.json`),
       "utf8"
     ));
     return data.dispatchedBy ?? data.parentExe ?? null;
@@ -5670,8 +5691,8 @@ async function verifyPaneAtCapacity(sessionName) {
 }
 function readDebounceState() {
   try {
-    if (!existsSync14(DEBOUNCE_FILE)) return {};
-    const raw = JSON.parse(readFileSync13(DEBOUNCE_FILE, "utf8"));
+    if (!existsSync15(DEBOUNCE_FILE)) return {};
+    const raw = JSON.parse(readFileSync14(DEBOUNCE_FILE, "utf8"));
     const state = {};
     for (const [key, val] of Object.entries(raw)) {
       if (typeof val === "number") {
@@ -5687,8 +5708,8 @@ function readDebounceState() {
 }
 function writeDebounceState(state) {
   try {
-    if (!existsSync14(SESSION_CACHE)) mkdirSync7(SESSION_CACHE, { recursive: true });
-    writeFileSync9(DEBOUNCE_FILE, JSON.stringify(state));
+    if (!existsSync15(SESSION_CACHE)) mkdirSync8(SESSION_CACHE, { recursive: true });
+    writeFileSync10(DEBOUNCE_FILE, JSON.stringify(state));
   } catch {
   }
 }
@@ -5787,8 +5808,8 @@ function sendIntercom(targetSession) {
       try {
         const rawAgent = targetSession.split("-")[0] ?? targetSession;
         const agent = baseAgentName(rawAgent);
-        const markerPath = path18.join(SESSION_CACHE, `current-task-${agent}.json`);
-        if (existsSync14(markerPath)) {
+        const markerPath = path19.join(SESSION_CACHE, `current-task-${agent}.json`);
+        if (existsSync15(markerPath)) {
           logIntercom(`SKIP \u2192 ${targetSession} (has in_progress task marker + not idle \u2014 will auto-chain)`);
           return "debounced";
         }
@@ -5798,8 +5819,8 @@ function sendIntercom(targetSession) {
     try {
       const rawAgent = targetSession.split("-")[0] ?? targetSession;
       const agent = baseAgentName(rawAgent);
-      const taskDir = path18.join(process.cwd(), "exe", agent);
-      if (existsSync14(taskDir)) {
+      const taskDir = path19.join(process.cwd(), "exe", agent);
+      if (existsSync15(taskDir)) {
         const files = readdirSync4(taskDir).filter(
           (f) => f.endsWith(".md") && f !== "DONE.txt"
         );
@@ -5965,26 +5986,26 @@ function spawnEmployee(employeeName, exeSession, projectDir, opts) {
   const transport = getTransport();
   const sessionName = employeeSessionName(employeeName, exeSession, opts?.instance);
   const instanceLabel = opts?.instance != null && opts.instance > 0 ? `${employeeName}${opts.instance}` : employeeName;
-  const logDir = path18.join(os10.homedir(), ".exe-os", "session-logs");
-  const logFile = path18.join(logDir, `${instanceLabel}-${Date.now()}.log`);
-  if (!existsSync14(logDir)) {
-    mkdirSync7(logDir, { recursive: true });
+  const logDir = path19.join(os11.homedir(), ".exe-os", "session-logs");
+  const logFile = path19.join(logDir, `${instanceLabel}-${Date.now()}.log`);
+  if (!existsSync15(logDir)) {
+    mkdirSync8(logDir, { recursive: true });
   }
   transport.kill(sessionName);
   let cleanupSuffix = "";
   try {
     const thisFile = fileURLToPath2(import.meta.url);
-    const cleanupScript = path18.join(path18.dirname(thisFile), "..", "bin", "exe-session-cleanup.js");
-    if (existsSync14(cleanupScript)) {
+    const cleanupScript = path19.join(path19.dirname(thisFile), "..", "bin", "exe-session-cleanup.js");
+    if (existsSync15(cleanupScript)) {
       cleanupSuffix = `; ${process.execPath} "${cleanupScript}" "${employeeName}" "${exeSession}"`;
     }
   } catch {
   }
   try {
-    const claudeJsonPath = path18.join(os10.homedir(), ".claude.json");
+    const claudeJsonPath = path19.join(os11.homedir(), ".claude.json");
     let claudeJson = {};
     try {
-      claudeJson = JSON.parse(readFileSync13(claudeJsonPath, "utf8"));
+      claudeJson = JSON.parse(readFileSync14(claudeJsonPath, "utf8"));
     } catch {
     }
     if (!claudeJson.projects) claudeJson.projects = {};
@@ -5992,17 +6013,17 @@ function spawnEmployee(employeeName, exeSession, projectDir, opts) {
     const trustDir = opts?.cwd ?? projectDir;
     if (!projects[trustDir]) projects[trustDir] = {};
     projects[trustDir].hasTrustDialogAccepted = true;
-    writeFileSync9(claudeJsonPath, JSON.stringify(claudeJson, null, 2) + "\n");
+    writeFileSync10(claudeJsonPath, JSON.stringify(claudeJson, null, 2) + "\n");
   } catch {
   }
   try {
-    const settingsDir = path18.join(os10.homedir(), ".claude", "projects");
+    const settingsDir = path19.join(os11.homedir(), ".claude", "projects");
     const normalizedKey = (opts?.cwd ?? projectDir).replace(/\//g, "-").replace(/^-/, "");
-    const projSettingsDir = path18.join(settingsDir, normalizedKey);
-    const settingsPath = path18.join(projSettingsDir, "settings.json");
+    const projSettingsDir = path19.join(settingsDir, normalizedKey);
+    const settingsPath = path19.join(projSettingsDir, "settings.json");
     let settings = {};
     try {
-      settings = JSON.parse(readFileSync13(settingsPath, "utf8"));
+      settings = JSON.parse(readFileSync14(settingsPath, "utf8"));
     } catch {
     }
     const perms = settings.permissions ?? {};
@@ -6030,8 +6051,8 @@ function spawnEmployee(employeeName, exeSession, projectDir, opts) {
     if (changed) {
       perms.allow = allow;
       settings.permissions = perms;
-      mkdirSync7(projSettingsDir, { recursive: true });
-      writeFileSync9(settingsPath, JSON.stringify(settings, null, 2) + "\n");
+      mkdirSync8(projSettingsDir, { recursive: true });
+      writeFileSync10(settingsPath, JSON.stringify(settings, null, 2) + "\n");
     }
   } catch {
   }
@@ -6046,8 +6067,8 @@ function spawnEmployee(employeeName, exeSession, projectDir, opts) {
   let behaviorsFlag = "";
   let legacyFallbackWarned = false;
   if (!useExeAgent && !useBinSymlink) {
-    const identityPath = path18.join(
-      os10.homedir(),
+    const identityPath = path19.join(
+      os11.homedir(),
       ".exe-os",
       "identity",
       `${employeeName}.md`
@@ -6056,13 +6077,13 @@ function spawnEmployee(employeeName, exeSession, projectDir, opts) {
     const hasAgentFlag = claudeSupportsAgentFlag();
     if (hasAgentFlag) {
       identityFlag = ` --agent ${employeeName}`;
-    } else if (existsSync14(identityPath)) {
+    } else if (existsSync15(identityPath)) {
       identityFlag = ` --append-system-prompt-file ${identityPath}`;
       legacyFallbackWarned = true;
     }
     const behaviorsFile = exportBehaviorsSync(
       employeeName,
-      path18.basename(spawnCwd),
+      path19.basename(spawnCwd),
       sessionName
     );
     if (behaviorsFile) {
@@ -6077,16 +6098,16 @@ function spawnEmployee(employeeName, exeSession, projectDir, opts) {
   }
   let sessionContextFlag = "";
   try {
-    const ctxDir = path18.join(os10.homedir(), ".exe-os", "session-cache");
-    mkdirSync7(ctxDir, { recursive: true });
-    const ctxFile = path18.join(ctxDir, `session-context-${sessionName}.md`);
+    const ctxDir = path19.join(os11.homedir(), ".exe-os", "session-cache");
+    mkdirSync8(ctxDir, { recursive: true });
+    const ctxFile = path19.join(ctxDir, `session-context-${sessionName}.md`);
     const ctxContent = [
       `## Session Context`,
       `You are running in tmux session: ${sessionName}.`,
       `Your parent coordinator session is ${exeSession}.`,
       `Your employees (if any) use the -${exeSession} suffix.`
     ].join("\n");
-    writeFileSync9(ctxFile, ctxContent);
+    writeFileSync10(ctxFile, ctxContent);
     sessionContextFlag = ` --append-system-prompt-file ${ctxFile}`;
   } catch {
   }
@@ -6163,8 +6184,8 @@ function spawnEmployee(employeeName, exeSession, projectDir, opts) {
   transport.pipeLog(sessionName, logFile);
   try {
     const mySession = getMySession();
-    const dispatchInfo = path18.join(SESSION_CACHE, `dispatch-info-${sessionName}.json`);
-    writeFileSync9(dispatchInfo, JSON.stringify({
+    const dispatchInfo = path19.join(SESSION_CACHE, `dispatch-info-${sessionName}.json`);
+    writeFileSync10(dispatchInfo, JSON.stringify({
       dispatchedBy: mySession,
       rootExe: exeSession,
       provider: useBinSymlink ? ccProvider : useExeAgent ? opts.provider : useCodex ? "openai" : useOpencode ? "opencode" : "anthropic",
@@ -6238,15 +6259,15 @@ var init_tmux_routing = __esm({
     init_intercom_queue();
     init_plan_limits();
     init_employees();
-    SPAWN_LOCK_DIR = path18.join(os10.homedir(), ".exe-os", "spawn-locks");
-    SESSION_CACHE = path18.join(os10.homedir(), ".exe-os", "session-cache");
+    SPAWN_LOCK_DIR = path19.join(os11.homedir(), ".exe-os", "spawn-locks");
+    SESSION_CACHE = path19.join(os11.homedir(), ".exe-os", "session-cache");
     BEHAVIORS_EXPORT_TIMEOUT_MS = 1e4;
     VALID_SESSION_NAME = /^[a-z]+\d*-[a-zA-Z0-9_]+$/;
     VERIFY_PANE_LINES = 200;
     INTERCOM_DEBOUNCE_MS = 3e4;
     CODEX_DEBOUNCE_MS = 12e4;
-    INTERCOM_LOG2 = path18.join(os10.homedir(), ".exe-os", "intercom.log");
-    DEBOUNCE_FILE = path18.join(SESSION_CACHE, "intercom-debounce.json");
+    INTERCOM_LOG2 = path19.join(os11.homedir(), ".exe-os", "intercom.log");
+    DEBOUNCE_FILE = path19.join(SESSION_CACHE, "intercom-debounce.json");
     DEBOUNCE_CLEANUP_AGE_MS = 5 * 60 * 1e3;
     BUSY_PATTERN = /[✻✽✶✳·].*…|Running…|• Working|• Ran |• Explored|• Called|esc to interrupt/;
   }
@@ -6296,14 +6317,14 @@ var init_memory = __esm({
 
 // src/lib/keychain.ts
 import { readFile as readFile4, writeFile as writeFile5, unlink, mkdir as mkdir4, chmod as chmod2 } from "fs/promises";
-import { existsSync as existsSync15 } from "fs";
-import path19 from "path";
-import os11 from "os";
+import { existsSync as existsSync16 } from "fs";
+import path20 from "path";
+import os12 from "os";
 function getKeyDir() {
-  return process.env.EXE_OS_DIR ?? process.env.EXE_MEM_DIR ?? path19.join(os11.homedir(), ".exe-os");
+  return process.env.EXE_OS_DIR ?? process.env.EXE_MEM_DIR ?? path20.join(os12.homedir(), ".exe-os");
 }
 function getKeyPath() {
-  return path19.join(getKeyDir(), "master.key");
+  return path20.join(getKeyDir(), "master.key");
 }
 async function tryKeytar() {
   try {
@@ -6324,9 +6345,9 @@ async function getMasterKey() {
     }
   }
   const keyPath = getKeyPath();
-  if (!existsSync15(keyPath)) {
+  if (!existsSync16(keyPath)) {
     process.stderr.write(
-      `[keychain] Key not found at ${keyPath} (HOME=${os11.homedir()}, EXE_OS_DIR=${process.env.EXE_OS_DIR ?? "unset"})
+      `[keychain] Key not found at ${keyPath} (HOME=${os12.homedir()}, EXE_OS_DIR=${process.env.EXE_OS_DIR ?? "unset"})
 `
     );
     return null;
@@ -6365,13 +6386,13 @@ __export(shard_manager_exports, {
   listShards: () => listShards,
   shardExists: () => shardExists
 });
-import path20 from "path";
-import { existsSync as existsSync16, mkdirSync as mkdirSync8, readdirSync as readdirSync5 } from "fs";
+import path21 from "path";
+import { existsSync as existsSync17, mkdirSync as mkdirSync9, readdirSync as readdirSync5 } from "fs";
 import { createClient as createClient2 } from "@libsql/client";
 function initShardManager(encryptionKey) {
   _encryptionKey = encryptionKey;
-  if (!existsSync16(SHARDS_DIR)) {
-    mkdirSync8(SHARDS_DIR, { recursive: true });
+  if (!existsSync17(SHARDS_DIR)) {
+    mkdirSync9(SHARDS_DIR, { recursive: true });
   }
   _shardingEnabled = true;
   if (_evictionTimer) clearInterval(_evictionTimer);
@@ -6400,7 +6421,7 @@ function getShardClient(projectName) {
   while (_shards.size >= MAX_OPEN_SHARDS) {
     evictLRU();
   }
-  const dbPath = path20.join(SHARDS_DIR, `${safeName}.db`);
+  const dbPath = path21.join(SHARDS_DIR, `${safeName}.db`);
   const client = createClient2({
     url: `file:${dbPath}`,
     encryptionKey: _encryptionKey
@@ -6411,10 +6432,10 @@ function getShardClient(projectName) {
 }
 function shardExists(projectName) {
   const safeName = projectName.replace(/[^a-zA-Z0-9_-]/g, "_");
-  return existsSync16(path20.join(SHARDS_DIR, `${safeName}.db`));
+  return existsSync17(path21.join(SHARDS_DIR, `${safeName}.db`));
 }
 function listShards() {
-  if (!existsSync16(SHARDS_DIR)) return [];
+  if (!existsSync17(SHARDS_DIR)) return [];
   return readdirSync5(SHARDS_DIR).filter((f) => f.endsWith(".db")).map((f) => f.replace(".db", ""));
 }
 async function ensureShardSchema(client) {
@@ -6661,7 +6682,7 @@ var init_shard_manager = __esm({
   "src/lib/shard-manager.ts"() {
     "use strict";
     init_config();
-    SHARDS_DIR = path20.join(EXE_AI_DIR, "shards");
+    SHARDS_DIR = path21.join(EXE_AI_DIR, "shards");
     SHARD_IDLE_MS = 5 * 60 * 1e3;
     MAX_OPEN_SHARDS = 10;
     EVICTION_INTERVAL_MS = 60 * 1e3;
@@ -7430,6 +7451,115 @@ var init_store = __esm({
   }
 });
 
+// src/lib/git-staleness.ts
+var git_staleness_exports = {};
+__export(git_staleness_exports, {
+  clearSessionFileReads: () => clearSessionFileReads,
+  detectStaleFiles: () => detectStaleFiles,
+  recordFileRead: () => recordFileRead
+});
+import { execSync as execSync8 } from "child_process";
+import path22 from "path";
+function getHeadCommit(cwd) {
+  try {
+    return execSync8("git rev-parse --short HEAD", {
+      cwd,
+      timeout: GIT_TIMEOUT_MS,
+      encoding: "utf-8"
+    }).trim() || null;
+  } catch {
+    return null;
+  }
+}
+function normalizeTrackedPath(cwd, filePath) {
+  const resolved = path22.resolve(cwd, filePath);
+  const relative = path22.relative(cwd, resolved);
+  if (!relative || relative.startsWith("..") || path22.isAbsolute(relative)) {
+    return null;
+  }
+  return relative;
+}
+function formatGitSummary(filePath, summary) {
+  const match = summary.trim().match(/^([a-f0-9]+)\s+([^:]+):\s+(.+)$/i);
+  if (!match) return `${filePath} (${summary.trim()})`;
+  const [, hash, author, subject] = match;
+  return `${filePath} (modified by ${author} in commit ${hash}: "${subject}")`;
+}
+async function recordFileRead(sessionUuid, agentId, cwd, filePath) {
+  if (!sessionUuid || !filePath) return;
+  const trackedPath = normalizeTrackedPath(cwd, filePath);
+  if (!trackedPath) return;
+  const client = getClient();
+  await client.execute({
+    sql: `INSERT INTO agent_file_reads (session_uuid, agent_id, file_path, read_at, commit_hash)
+          VALUES (?, ?, ?, ?, ?)
+          ON CONFLICT(session_uuid, file_path) DO UPDATE SET
+            read_at = excluded.read_at,
+            commit_hash = excluded.commit_hash`,
+    args: [
+      sessionUuid,
+      agentId,
+      trackedPath,
+      (/* @__PURE__ */ new Date()).toISOString(),
+      getHeadCommit(cwd)
+    ]
+  });
+}
+async function detectStaleFiles(agentId, cwd) {
+  const client = getClient();
+  const recentCutoff = new Date(Date.now() - RECENT_READ_LOOKBACK_MS).toISOString();
+  const result = await client.execute({
+    sql: `SELECT file_path, MAX(read_at) AS read_at
+          FROM agent_file_reads
+          WHERE agent_id = ? AND read_at >= ?
+          GROUP BY file_path
+          ORDER BY MAX(read_at) DESC
+          LIMIT 10`,
+    args: [agentId, recentCutoff]
+  });
+  const stale = [];
+  for (const row of result.rows) {
+    if (stale.length >= MAX_STALE_FILES) break;
+    const record = row;
+    const filePath = String(record.file_path ?? "");
+    const readAt = String(record.read_at ?? "");
+    if (!filePath || !readAt) continue;
+    try {
+      const gitSummary = execSync8(
+        `git log -1 --oneline --after=${JSON.stringify(readAt)} --format="%h %an: %s" -- ${JSON.stringify(filePath)}`,
+        {
+          cwd,
+          timeout: GIT_TIMEOUT_MS,
+          encoding: "utf-8"
+        }
+      ).trim();
+      if (gitSummary) {
+        stale.push(formatGitSummary(filePath, gitSummary));
+      }
+    } catch {
+    }
+  }
+  return stale.slice(0, MAX_STALE_FILES);
+}
+async function clearSessionFileReads(sessionUuid) {
+  if (!sessionUuid) return;
+  const client = getClient();
+  await client.execute({
+    sql: "DELETE FROM agent_file_reads WHERE session_uuid = ?",
+    args: [sessionUuid]
+  });
+}
+var RECENT_READ_LOOKBACK_MS, MAX_STALE_FILES, GIT_TIMEOUT_MS;
+var init_git_staleness = __esm({
+  "src/lib/git-staleness.ts"() {
+    "use strict";
+    init_database();
+    RECENT_READ_LOOKBACK_MS = 24 * 60 * 60 * 1e3;
+    MAX_STALE_FILES = 10;
+    GIT_TIMEOUT_MS = 400;
+  }
+});
+
 // src/lib/git-task-sweep.ts
 var git_task_sweep_exports = {};
 __export(git_task_sweep_exports, {
@@ -7439,7 +7569,7 @@ __export(git_task_sweep_exports, {
   matchScore: () => matchScore,
   sweepTasks: () => sweepTasks
 });
-import { execSync as execSync8 } from "child_process";
+import { execSync as execSync9 } from "child_process";
 function extractKeywords(text) {
   return text.toLowerCase().replace(/[^a-z0-9\s-]/g, " ").split(/\s+/).filter((w) => w.length >= 3 && !STOP_WORDS.has(w));
 }
@@ -7468,7 +7598,7 @@ function matchScore(task, commitMessage, changedFiles) {
 function getRecentCommits(limit = DEFAULT_COMMIT_LIMIT) {
   try {
     const SEPARATOR = "<<SEP>>";
-    const output = execSync8(
+    const output = execSync9(
       `git log --format="%h${SEPARATOR}%s${SEPARATOR}%aI" --name-only -n ${limit} -z`,
       { encoding: "utf8", timeout: 1e4 }
     );
@@ -7751,6 +7881,28 @@ function getActiveAgent() {
   };
 }
 
+// src/adapters/claude/session-key.ts
+init_session_key();
+
+// src/lib/cache-warmth.ts
+import os3 from "os";
+import path4 from "path";
+import { existsSync as existsSync4, mkdirSync as mkdirSync3, readFileSync as readFileSync4, unlinkSync as unlinkSync3, writeFileSync as writeFileSync3 } from "fs";
+var CACHE_TTL_MS = 5 * 60 * 1e3;
+var CACHE_DIR2 = path4.join(
+  process.env.EXE_OS_DIR ?? path4.join(os3.homedir(), ".exe-os"),
+  "session-cache"
+);
+function getStatePath(sessionKey) {
+  return path4.join(CACHE_DIR2, `cache-warmth-${sessionKey}.json`);
+}
+function clearCacheState(sessionKey) {
+  try {
+    unlinkSync3(getStatePath(sessionKey));
+  } catch {
+  }
+}
+
 // src/adapters/claude/hooks/session-end.ts
 init_task_scope();
 init_employees();
@@ -7803,6 +7955,11 @@ Orphaned tasks at session end: ${orphanResult.rows.map((r) => `"${String(r.title
           vector: null
         });
         await flushBatch2();
+        try {
+          const { clearSessionFileReads: clearSessionFileReads2 } = await Promise.resolve().then(() => (init_git_staleness(), git_staleness_exports));
+          await clearSessionFileReads2(data.session_id);
+        } catch {
+        }
         if (!canCoordinate(agent.agentId, agent.agentRole)) {
           const inProgress = orphanResult.rows.filter((r) => String(r.status) === "in_progress");
           if (inProgress.length > 0) {
@@ -7891,6 +8048,7 @@ Orphaned tasks at session end: ${orphanResult.rows.map((r) => `"${String(r.title
       }
     }
     clearActiveAgent();
+    clearCacheState(getSessionKey());
   } catch {
   }
   clearTimeout(timeout);