@askexenow/exe-os 0.9.8 → 0.9.9

package/dist/bin/exe-pending-reviews.js

@@ -1,6 +1,8 @@
 #!/usr/bin/env node
 var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __esm = (fn, res) => function __init() {
   return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
 };
@@ -8,6 +10,15 @@ var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, { get: all[name], enumerable: true });
 };
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 // src/lib/db-retry.ts
 function isBusyError(err) {
@@ -64,9 +75,34 @@ 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 {
+  }
+}
+async function enforcePrivateFile(filePath) {
+  try {
+    await chmod(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() {
@@ -74,7 +110,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
@@ -137,9 +173,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");
@@ -152,6 +188,7 @@ async function loadConfig() {
 `);
       try {
         await writeFile(configPath, JSON.stringify(migratedCfg, null, 2) + "\n");
+        await enforcePrivateFile(configPath);
       } catch {
       }
     }
@@ -171,6 +208,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");
@@ -249,7 +287,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";
@@ -266,7 +304,7 @@ function getCoordinatorName(employees = loadEmployeesSync()) {
   return getCoordinatorEmployee(employees)?.name ?? DEFAULT_COORDINATOR_TEMPLATE_NAME;
 }
 function loadEmployeesSync(employeesPath = EMPLOYEES_PATH) {
-  if (!existsSync2(employeesPath)) return [];
+  if (!existsSync3(employeesPath)) return [];
   try {
     return JSON.parse(readFileSync2(employeesPath, "utf-8"));
   } catch {
@@ -1211,6 +1249,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
     );
@@ -1219,7 +1258,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);
@@ -1257,6 +1296,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',
@@ -1270,10 +1310,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({
@@ -1857,6 +1918,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 {
+  }
 }
 var _client, _resilientClient, _walCheckpointTimer, _daemonClient, _adapterClient, initTurso;
 var init_database = __esm({
@@ -1934,6 +2002,7 @@ var shard_manager_exports = {};
 __export(shard_manager_exports, {
   disposeShards: () => disposeShards,
   ensureShardSchema: () => ensureShardSchema,
+  getOpenShardCount: () => getOpenShardCount,
   getReadyShardClient: () => getReadyShardClient,
   getShardClient: () => getShardClient,
   getShardsDir: () => getShardsDir,
@@ -1943,14 +2012,17 @@ __export(shard_manager_exports, {
   shardExists: () => shardExists
 });
 import path5 from "path";
-import { existsSync as existsSync4, mkdirSync, readdirSync } from "fs";
+import { existsSync as existsSync5, mkdirSync as mkdirSync2, readdirSync } from "fs";
 import { createClient as createClient2 } from "@libsql/client";
 function initShardManager(encryptionKey) {
   _encryptionKey = encryptionKey;
-  if (!existsSync4(SHARDS_DIR)) {
-    mkdirSync(SHARDS_DIR, { recursive: true });
+  if (!existsSync5(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;
@@ -1967,21 +2039,28 @@ function getShardClient(projectName) {
     throw new Error(`Invalid project name for shard: "${projectName}"`);
   }
   const cached = _shards.get(safeName);
-  if (cached) return cached;
+  if (cached) {
+    _shardLastAccess.set(safeName, Date.now());
+    return cached;
+  }
+  while (_shards.size >= MAX_OPEN_SHARDS) {
+    evictLRU();
+  }
   const dbPath = path5.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 existsSync4(path5.join(SHARDS_DIR, `${safeName}.db`));
+  return existsSync5(path5.join(SHARDS_DIR, `${safeName}.db`));
 }
 function listShards() {
-  if (!existsSync4(SHARDS_DIR)) return [];
+  if (!existsSync5(SHARDS_DIR)) return [];
   return readdirSync(SHARDS_DIR).filter((f) => f.endsWith(".db")).map((f) => f.replace(".db", ""));
 }
 async function ensureShardSchema(client) {
@@ -2033,6 +2112,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",
@@ -2170,21 +2251,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 = path5.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;
   }
@@ -2377,47 +2506,189 @@ ${p.content}`).join("\n\n");
   }
 });
 
-// src/lib/notifications.ts
-import crypto from "crypto";
+// src/lib/session-registry.ts
 import path6 from "path";
 import os5 from "os";
-import {
-  readFileSync as readFileSync3,
-  readdirSync as readdirSync2,
-  unlinkSync as unlinkSync2,
-  existsSync as existsSync5,
-  rmdirSync
-} from "fs";
-var init_notifications = __esm({
-  "src/lib/notifications.ts"() {
-    "use strict";
-    init_database();
-  }
-});
-
-// src/lib/session-registry.ts
-import path7 from "path";
-import os6 from "os";
 var REGISTRY_PATH;
 var init_session_registry = __esm({
   "src/lib/session-registry.ts"() {
     "use strict";
-    REGISTRY_PATH = path7.join(os6.homedir(), ".exe-os", "session-registry.json");
+    REGISTRY_PATH = path6.join(os5.homedir(), ".exe-os", "session-registry.json");
   }
 });
 
 // src/lib/session-key.ts
 import { execSync as execSync2 } from "child_process";
+function normalizeCommand(command) {
+  const trimmed = command.trim().toLowerCase();
+  const parts = trimmed.split(/[\\/]/);
+  return parts[parts.length - 1] ?? trimmed;
+}
+function detectRuntimeFromCommand(command) {
+  const normalized = normalizeCommand(command);
+  for (const [runtime, commands] of Object.entries(RUNTIME_COMMANDS)) {
+    if (commands.includes(normalized)) {
+      return runtime;
+    }
+  }
+  return null;
+}
+function resolveRuntimeProcess() {
+  let pid = process.ppid;
+  for (let i = 0; i < 10; i++) {
+    try {
+      const info = execSync2(`ps -p ${pid} -o ppid=,comm=`, {
+        encoding: "utf8",
+        timeout: 2e3
+      }).trim();
+      const match = info.match(/^\s*(\d+)\s+(.+)$/);
+      if (!match) break;
+      const [, ppid, cmd] = match;
+      const runtime = detectRuntimeFromCommand(cmd ?? "");
+      if (runtime) {
+        return { pid: String(pid), runtime };
+      }
+      pid = parseInt(ppid, 10);
+      if (pid <= 1) break;
+    } catch {
+      break;
+    }
+  }
+  return null;
+}
+function getSessionKey() {
+  if (_cached) return _cached;
+  if (process.env.EXE_SESSION_KEY) {
+    _cached = process.env.EXE_SESSION_KEY;
+    return _cached;
+  }
+  const resolved = resolveRuntimeProcess();
+  if (resolved) {
+    _cachedRuntime = resolved.runtime;
+    _cached = resolved.pid;
+    return _cached;
+  }
+  _cached = process.env.CLAUDE_CODE_SSE_PORT ?? String(process.ppid);
+  return _cached;
+}
+var _cached, _cachedRuntime, RUNTIME_COMMANDS;
 var init_session_key = __esm({
   "src/lib/session-key.ts"() {
     "use strict";
+    _cached = null;
+    _cachedRuntime = null;
+    RUNTIME_COMMANDS = {
+      claude: ["claude", "claude.exe", "claude-native"],
+      codex: ["codex"],
+      opencode: ["opencode"]
+    };
+  }
+});
+
+// src/lib/tmux-transport.ts
+var tmux_transport_exports = {};
+__export(tmux_transport_exports, {
+  TmuxTransport: () => TmuxTransport
+});
+import { execFileSync } from "child_process";
+var QUIET, TmuxTransport;
+var init_tmux_transport = __esm({
+  "src/lib/tmux-transport.ts"() {
+    "use strict";
+    QUIET = {
+      encoding: "utf8",
+      stdio: ["pipe", "pipe", "pipe"]
+    };
+    TmuxTransport = class {
+      getMySession() {
+        try {
+          return execFileSync("tmux", ["display-message", "-p", "#{session_name}"], QUIET).trim() || null;
+        } catch {
+          return null;
+        }
+      }
+      listSessions() {
+        try {
+          return execFileSync("tmux", ["list-sessions", "-F", "#{session_name}"], QUIET).trim().split("\n").filter(Boolean);
+        } catch {
+          return [];
+        }
+      }
+      isAlive(target) {
+        try {
+          const sessions = this.listSessions();
+          if (!sessions.includes(target)) return false;
+          const paneStatus = execFileSync(
+            "tmux",
+            ["list-panes", "-t", target, "-F", "#{pane_dead}"],
+            QUIET
+          ).trim();
+          return paneStatus !== "1";
+        } catch {
+          return false;
+        }
+      }
+      sendKeys(target, keys) {
+        execFileSync("tmux", ["send-keys", "-t", target, keys, "Enter"], QUIET);
+      }
+      capturePane(target, lines) {
+        const args = ["capture-pane", "-t", target, "-p"];
+        if (lines) args.push("-S", `-${lines}`);
+        return execFileSync("tmux", args, { ...QUIET, timeout: 3e3 });
+      }
+      isPaneInCopyMode(target) {
+        try {
+          const result = execFileSync(
+            "tmux",
+            ["display-message", "-p", "-t", target, "#{pane_in_mode}"],
+            { ...QUIET, timeout: 3e3 }
+          ).trim();
+          return result === "1";
+        } catch {
+          return false;
+        }
+      }
+      spawn(name, config) {
+        try {
+          const args = ["new-session", "-d", "-s", name];
+          if (config.cwd) args.push("-c", config.cwd);
+          args.push(config.command);
+          execFileSync("tmux", args);
+          return { sessionName: name };
+        } catch (e) {
+          return { sessionName: name, error: `spawn failed: ${e}` };
+        }
+      }
+      kill(target) {
+        try {
+          execFileSync("tmux", ["kill-session", "-t", target], QUIET);
+        } catch {
+        }
+      }
+      pipeLog(target, logFile) {
+        try {
+          const safePath = logFile.replace(/'/g, "'\\''");
+          execFileSync("tmux", ["pipe-pane", "-t", target, `cat >> '${safePath}'`], QUIET);
+        } catch {
+        }
+      }
+    };
   }
 });
 
 // src/lib/transport.ts
+function getTransport() {
+  if (!_transport) {
+    const { TmuxTransport: TmuxTransport2 } = (init_tmux_transport(), __toCommonJS(tmux_transport_exports));
+    _transport = new TmuxTransport2();
+  }
+  return _transport;
+}
+var _transport;
 var init_transport = __esm({
   "src/lib/transport.ts"() {
     "use strict";
+    _transport = null;
   }
 });
 
@@ -2477,15 +2748,16 @@ var init_runtime_table = __esm({
 });
 
 // src/lib/agent-config.ts
-import { readFileSync as readFileSync4, writeFileSync as writeFileSync2, existsSync as existsSync6, mkdirSync as mkdirSync2 } from "fs";
-import path8 from "path";
+import { readFileSync as readFileSync3, writeFileSync as writeFileSync2, existsSync as existsSync6 } from "fs";
+import path7 from "path";
 var AGENT_CONFIG_PATH, DEFAULT_MODELS;
 var init_agent_config = __esm({
   "src/lib/agent-config.ts"() {
     "use strict";
     init_config();
     init_runtime_table();
-    AGENT_CONFIG_PATH = path8.join(EXE_AI_DIR, "agent-config.json");
+    init_secure_files();
+    AGENT_CONFIG_PATH = path7.join(EXE_AI_DIR, "agent-config.json");
     DEFAULT_MODELS = {
       claude: "claude-opus-4",
       codex: RUNTIME_TABLE.codex?.defaultModel ?? "gpt-5.4",
@@ -2495,38 +2767,41 @@ var init_agent_config = __esm({
 });
 
 // src/lib/intercom-queue.ts
-import { readFileSync as readFileSync5, writeFileSync as writeFileSync3, renameSync as renameSync3, existsSync as existsSync7, mkdirSync as mkdirSync3 } from "fs";
-import path9 from "path";
-import os7 from "os";
+import { readFileSync as readFileSync4, writeFileSync as writeFileSync3, renameSync as renameSync3, existsSync as existsSync7, mkdirSync as mkdirSync3 } from "fs";
+import path8 from "path";
+import os6 from "os";
 var QUEUE_PATH, TTL_MS, INTERCOM_LOG;
 var init_intercom_queue = __esm({
   "src/lib/intercom-queue.ts"() {
     "use strict";
-    QUEUE_PATH = path9.join(os7.homedir(), ".exe-os", "intercom-queue.json");
+    QUEUE_PATH = path8.join(os6.homedir(), ".exe-os", "intercom-queue.json");
     TTL_MS = 60 * 60 * 1e3;
-    INTERCOM_LOG = path9.join(os7.homedir(), ".exe-os", "intercom.log");
+    INTERCOM_LOG = path8.join(os6.homedir(), ".exe-os", "intercom.log");
   }
 });
 
 // src/lib/license.ts
-import { readFileSync as readFileSync6, writeFileSync as writeFileSync4, existsSync as existsSync8, mkdirSync as mkdirSync4 } from "fs";
+import { readFileSync as readFileSync5, writeFileSync as writeFileSync4, existsSync as existsSync8, mkdirSync as mkdirSync4 } from "fs";
 import { randomUUID as randomUUID2 } from "crypto";
-import path10 from "path";
+import { createRequire as createRequire2 } from "module";
+import { pathToFileURL as pathToFileURL2 } from "url";
+import os7 from "os";
+import path9 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 = 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 = 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");
   }
 });
 
 // src/lib/plan-limits.ts
-import { readFileSync as readFileSync7, existsSync as existsSync9 } from "fs";
-import path11 from "path";
+import { readFileSync as readFileSync6, existsSync as existsSync9 } from "fs";
+import path10 from "path";
 var CACHE_PATH2;
 var init_plan_limits = __esm({
   "src/lib/plan-limits.ts"() {
@@ -2535,20 +2810,54 @@ var init_plan_limits = __esm({
     init_employees();
     init_license();
     init_config();
-    CACHE_PATH2 = path11.join(EXE_AI_DIR, "license-cache.json");
+    CACHE_PATH2 = path10.join(EXE_AI_DIR, "license-cache.json");
   }
 });
 
 // src/lib/tmux-routing.ts
-import path12 from "path";
+import { readFileSync as readFileSync7, writeFileSync as writeFileSync5, mkdirSync as mkdirSync5, existsSync as existsSync10, appendFileSync, readdirSync as readdirSync2 } from "fs";
+import path11 from "path";
 import os8 from "os";
 import { fileURLToPath as fileURLToPath2 } from "url";
+function getMySession() {
+  return getTransport().getMySession();
+}
 function extractRootExe(name) {
   if (!name) return null;
   if (!name.includes("-")) return name;
   const parts = name.split("-").filter(Boolean);
   return parts.length > 0 ? parts[parts.length - 1] : null;
 }
+function getParentExe(sessionKey) {
+  try {
+    const data = JSON.parse(readFileSync7(path11.join(SESSION_CACHE, `parent-exe-${sessionKey}.json`), "utf8"));
+    return data.parentExe || null;
+  } catch {
+    return null;
+  }
+}
+function resolveExeSession() {
+  const mySession = getMySession();
+  if (!mySession) return null;
+  const fromSessionName = extractRootExe(mySession);
+  try {
+    const key = getSessionKey();
+    const parentExe = getParentExe(key);
+    if (parentExe) {
+      const fromCache = extractRootExe(parentExe) ?? parentExe;
+      if (fromSessionName && fromCache !== fromSessionName) {
+        process.stderr.write(
+          `[tmux-routing] WARN: cache says "${fromCache}" but session name says "${fromSessionName}". Trusting session name.
+`
+        );
+        return fromSessionName;
+      }
+      return fromCache;
+    }
+  } catch {
+  }
+  return fromSessionName ?? mySession;
+}
 function isExeSession(sessionName) {
   const matchesBaseWithInstance = (baseName) => sessionName === baseName || sessionName.startsWith(baseName) && /^\d+$/.test(sessionName.slice(baseName.length));
   const coordinatorName = getCoordinatorName();
@@ -2569,17 +2878,60 @@ var init_tmux_routing = __esm({
     init_intercom_queue();
     init_plan_limits();
     init_employees();
-    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");
+    SPAWN_LOCK_DIR = path11.join(os8.homedir(), ".exe-os", "spawn-locks");
+    SESSION_CACHE = path11.join(os8.homedir(), ".exe-os", "session-cache");
+    INTERCOM_LOG2 = path11.join(os8.homedir(), ".exe-os", "intercom.log");
+    DEBOUNCE_FILE = path11.join(SESSION_CACHE, "intercom-debounce.json");
     DEBOUNCE_CLEANUP_AGE_MS = 5 * 60 * 1e3;
   }
 });
 
+// src/lib/task-scope.ts
+function getCurrentSessionScope() {
+  try {
+    return resolveExeSession();
+  } catch {
+    return null;
+  }
+}
+function strictSessionScopeFilter(sessionScope, tableAlias) {
+  const scope = sessionScope !== void 0 ? sessionScope : getCurrentSessionScope();
+  if (!scope) return { sql: "", args: [] };
+  const col = tableAlias ? `${tableAlias}.session_scope` : "session_scope";
+  return {
+    sql: ` AND ${col} = ?`,
+    args: [scope]
+  };
+}
+var init_task_scope = __esm({
+  "src/lib/task-scope.ts"() {
+    "use strict";
+    init_tmux_routing();
+  }
+});
+
+// src/lib/notifications.ts
+import crypto from "crypto";
+import path12 from "path";
+import os9 from "os";
+import {
+  readFileSync as readFileSync8,
+  readdirSync as readdirSync3,
+  unlinkSync as unlinkSync2,
+  existsSync as existsSync11,
+  rmdirSync
+} from "fs";
+var init_notifications = __esm({
+  "src/lib/notifications.ts"() {
+    "use strict";
+    init_database();
+    init_task_scope();
+  }
+});
+
 // src/lib/tasks-review.ts
 import path13 from "path";
-import { existsSync as existsSync10, readdirSync as readdirSync3, unlinkSync as unlinkSync3 } from "fs";
+import { existsSync as existsSync12, readdirSync as readdirSync4, unlinkSync as unlinkSync3 } from "fs";
 function formatAge(isoTimestamp) {
   if (!isoTimestamp) return "";
   const ms = Date.now() - new Date(isoTimestamp).getTime();
@@ -2597,21 +2949,14 @@ function isStale(isoTimestamp) {
 }
 async function listPendingReviews(limit, sessionScope) {
   const client = getClient();
-  if (sessionScope) {
-    const result2 = await client.execute({
-      sql: `SELECT title, assigned_to, project_name, updated_at FROM tasks
-            WHERE status = 'needs_review'
-              AND session_scope = ?
-            ORDER BY updated_at ASC LIMIT ?`,
-      args: [sessionScope, limit]
-    });
-    return result2.rows;
-  }
+  const scope = strictSessionScopeFilter(
+    sessionScope === void 0 ? getCurrentSessionScope() : sessionScope
+  );
   const result = await client.execute({
     sql: `SELECT title, assigned_to, project_name, updated_at FROM tasks
-          WHERE status = 'needs_review'
+          WHERE status = 'needs_review'${scope.sql}
           ORDER BY updated_at ASC LIMIT ?`,
-    args: [limit]
+    args: [...scope.args, limit]
   });
   return result.rows;
 }
@@ -2623,7 +2968,7 @@ async function cleanupOrphanedReviews() {
           WHERE status IN ('open', 'needs_review', 'in_progress')
           AND assigned_by = 'system'
           AND title LIKE 'Review:%'
-          AND parent_task_id IN (SELECT id FROM tasks WHERE status IN ('done', 'cancelled'))`,
+          AND parent_task_id IN (SELECT id FROM tasks WHERE status IN ('done', 'cancelled', 'closed'))`,
     args: [now]
   });
   const r1b = await client.execute({
@@ -2660,6 +3005,7 @@ var init_tasks_review = __esm({
     init_tmux_routing();
     init_session_key();
     init_state_bus();
+    init_task_scope();
   }
 });
 
@@ -2669,7 +3015,7 @@ init_database();
 
 // src/lib/keychain.ts
 import { readFile as readFile3, writeFile as writeFile3, unlink, mkdir as mkdir3, chmod as chmod2 } from "fs/promises";
-import { existsSync as existsSync3 } from "fs";
+import { existsSync as existsSync4 } from "fs";
 import path4 from "path";
 import os4 from "os";
 var SERVICE = "exe-mem";
@@ -2699,7 +3045,7 @@ async function getMasterKey() {
     }
   }
   const keyPath = getKeyPath();
-  if (!existsSync3(keyPath)) {
+  if (!existsSync4(keyPath)) {
     process.stderr.write(
       `[keychain] Key not found at ${keyPath} (HOME=${os4.homedir()}, EXE_OS_DIR=${process.env.EXE_OS_DIR ?? "unset"})
 `