@askexenow/exe-os 0.9.6 → 0.9.8

package/dist/bin/exe-boot.js

@@ -368,7 +368,7 @@ function registerBinSymlinks(name) {
   }
   return { created, skipped, errors };
 }
-var EMPLOYEES_PATH, DEFAULT_COORDINATOR_TEMPLATE_NAME, COORDINATOR_ROLE, MULTI_INSTANCE_ROLES;
+var EMPLOYEES_PATH, DEFAULT_COORDINATOR_TEMPLATE_NAME, COORDINATOR_ROLE, MULTI_INSTANCE_ROLES, IDENTITY_DIR;
 var init_employees = __esm({
   "src/lib/employees.ts"() {
     "use strict";
@@ -377,6 +377,7 @@ var init_employees = __esm({
     DEFAULT_COORDINATOR_TEMPLATE_NAME = "exe";
     COORDINATOR_ROLE = "COO";
     MULTI_INSTANCE_ROLES = /* @__PURE__ */ new Set(["principal engineer", "content production specialist", "staff code reviewer"]);
+    IDENTITY_DIR = path2.join(EXE_AI_DIR, "identity");
   }
 });
 
@@ -435,13 +436,597 @@ var init_db_retry = __esm({
   }
 });
 
+// src/lib/database-adapter.ts
+import os3 from "os";
+import path3 from "path";
+import { createRequire } from "module";
+import { pathToFileURL } from "url";
+function quotedIdentifier(identifier) {
+  return `"${identifier.replace(/"/g, '""')}"`;
+}
+function unqualifiedTableName(name) {
+  const raw = name.trim().replace(/^"|"$/g, "");
+  const parts = raw.split(".");
+  return parts[parts.length - 1].replace(/^"|"$/g, "").toLowerCase();
+}
+function stripTrailingSemicolon(sql) {
+  return sql.trim().replace(/;+\s*$/u, "");
+}
+function appendClause(sql, clause) {
+  const trimmed = stripTrailingSemicolon(sql);
+  const returningMatch = /\sRETURNING\b[\s\S]*$/iu.exec(trimmed);
+  if (!returningMatch) {
+    return `${trimmed}${clause}`;
+  }
+  const idx = returningMatch.index;
+  return `${trimmed.slice(0, idx)}${clause}${trimmed.slice(idx)}`;
+}
+function normalizeStatement(stmt) {
+  if (typeof stmt === "string") {
+    return { kind: "positional", sql: stmt, args: [] };
+  }
+  const sql = stmt.sql;
+  if (Array.isArray(stmt.args) || stmt.args === void 0) {
+    return { kind: "positional", sql, args: stmt.args ?? [] };
+  }
+  return { kind: "named", sql, args: stmt.args };
+}
+function rewriteBooleanLiterals(sql) {
+  let out = sql;
+  for (const column of BOOLEAN_COLUMN_NAMES) {
+    const scoped = `((?:\\b[a-z_][a-z0-9_]*\\.)?${column})`;
+    out = out.replace(new RegExp(`${scoped}\\s*=\\s*0\\b`, "giu"), "$1 = FALSE");
+    out = out.replace(new RegExp(`${scoped}\\s*=\\s*1\\b`, "giu"), "$1 = TRUE");
+    out = out.replace(new RegExp(`${scoped}\\s*!=\\s*0\\b`, "giu"), "$1 != FALSE");
+    out = out.replace(new RegExp(`${scoped}\\s*!=\\s*1\\b`, "giu"), "$1 != TRUE");
+    out = out.replace(new RegExp(`${scoped}\\s*<>\\s*0\\b`, "giu"), "$1 <> FALSE");
+    out = out.replace(new RegExp(`${scoped}\\s*<>\\s*1\\b`, "giu"), "$1 <> TRUE");
+  }
+  return out;
+}
+function rewriteInsertOrIgnore(sql) {
+  if (!/^\s*INSERT\s+OR\s+IGNORE\s+INTO\b/iu.test(sql)) {
+    return sql;
+  }
+  const replaced = sql.replace(/^\s*INSERT\s+OR\s+IGNORE\s+INTO\b/iu, "INSERT INTO");
+  return /\bON\s+CONFLICT\b/iu.test(replaced) ? replaced : appendClause(replaced, " ON CONFLICT DO NOTHING");
+}
+function rewriteInsertOrReplace(sql) {
+  const match = /^\s*INSERT\s+OR\s+REPLACE\s+INTO\s+([A-Za-z0-9_."]+)\s*\(([^)]+)\)([\s\S]*)$/iu.exec(sql);
+  if (!match) {
+    return sql;
+  }
+  const rawTable = match[1];
+  const rawColumns = match[2];
+  const remainder = match[3];
+  const tableName = unqualifiedTableName(rawTable);
+  const conflictKeys = UPSERT_KEYS[tableName];
+  if (!conflictKeys?.length) {
+    return sql;
+  }
+  const columns = rawColumns.split(",").map((col) => col.trim().replace(/^"|"$/g, ""));
+  const updateColumns = columns.filter((col) => !conflictKeys.includes(col));
+  const conflictTarget = conflictKeys.map(quotedIdentifier).join(", ");
+  const updateClause = updateColumns.length === 0 ? " DO NOTHING" : ` DO UPDATE SET ${updateColumns.map((col) => `${quotedIdentifier(col)} = EXCLUDED.${quotedIdentifier(col)}`).join(", ")}`;
+  return `INSERT INTO ${rawTable} (${rawColumns})${appendClause(remainder, ` ON CONFLICT (${conflictTarget})${updateClause}`)}`;
+}
+function rewriteSql(sql) {
+  let out = sql;
+  out = out.replace(/\bdatetime\(\s*['"]now['"]\s*\)/giu, "CURRENT_TIMESTAMP");
+  out = out.replace(/\bvector32\s*\(\s*\?\s*\)/giu, "?");
+  out = rewriteBooleanLiterals(out);
+  out = rewriteInsertOrReplace(out);
+  out = rewriteInsertOrIgnore(out);
+  return stripTrailingSemicolon(out);
+}
+function toBoolean(value) {
+  if (value === null || value === void 0) return value;
+  if (typeof value === "boolean") return value;
+  if (typeof value === "number") return value !== 0;
+  if (typeof value === "bigint") return value !== 0n;
+  if (typeof value === "string") {
+    const normalized = value.trim().toLowerCase();
+    if (normalized === "0" || normalized === "false") return false;
+    if (normalized === "1" || normalized === "true") return true;
+  }
+  return Boolean(value);
+}
+function countQuestionMarks(sql, end) {
+  let count = 0;
+  let inSingle = false;
+  let inDouble = false;
+  let inLineComment = false;
+  let inBlockComment = false;
+  for (let i = 0; i < end; i++) {
+    const ch = sql[i];
+    const next = sql[i + 1];
+    if (inLineComment) {
+      if (ch === "\n") inLineComment = false;
+      continue;
+    }
+    if (inBlockComment) {
+      if (ch === "*" && next === "/") {
+        inBlockComment = false;
+        i += 1;
+      }
+      continue;
+    }
+    if (!inSingle && !inDouble && ch === "-" && next === "-") {
+      inLineComment = true;
+      i += 1;
+      continue;
+    }
+    if (!inSingle && !inDouble && ch === "/" && next === "*") {
+      inBlockComment = true;
+      i += 1;
+      continue;
+    }
+    if (!inDouble && ch === "'" && sql[i - 1] !== "\\") {
+      inSingle = !inSingle;
+      continue;
+    }
+    if (!inSingle && ch === '"' && sql[i - 1] !== "\\") {
+      inDouble = !inDouble;
+      continue;
+    }
+    if (!inSingle && !inDouble && ch === "?") {
+      count += 1;
+    }
+  }
+  return count;
+}
+function findBooleanPlaceholderIndexes(sql) {
+  const indexes = /* @__PURE__ */ new Set();
+  for (const column of BOOLEAN_COLUMN_NAMES) {
+    const pattern = new RegExp(`(?:\\b[a-z_][a-z0-9_]*\\.)?${column}\\s*=\\s*\\?`, "giu");
+    for (const match of sql.matchAll(pattern)) {
+      const matchText = match[0];
+      const qIndex = match.index + matchText.lastIndexOf("?");
+      indexes.add(countQuestionMarks(sql, qIndex + 1));
+    }
+  }
+  return indexes;
+}
+function coerceInsertBooleanArgs(sql, args) {
+  const match = /^\s*INSERT(?:\s+OR\s+(?:IGNORE|REPLACE))?\s+INTO\s+([A-Za-z0-9_."]+)\s*\(([^)]+)\)/iu.exec(sql);
+  if (!match) return;
+  const rawTable = match[1];
+  const rawColumns = match[2];
+  const boolColumns = BOOLEAN_COLUMNS_BY_TABLE[unqualifiedTableName(rawTable)];
+  if (!boolColumns?.size) return;
+  const columns = rawColumns.split(",").map((col) => col.trim().replace(/^"|"$/g, ""));
+  for (const [index, column] of columns.entries()) {
+    if (boolColumns.has(column) && index < args.length) {
+      args[index] = toBoolean(args[index]);
+    }
+  }
+}
+function coerceUpdateBooleanArgs(sql, args) {
+  const match = /^\s*UPDATE\s+([A-Za-z0-9_."]+)\s+SET\s+([\s\S]+?)(?:\s+WHERE\b|$)/iu.exec(sql);
+  if (!match) return;
+  const rawTable = match[1];
+  const setClause = match[2];
+  const boolColumns = BOOLEAN_COLUMNS_BY_TABLE[unqualifiedTableName(rawTable)];
+  if (!boolColumns?.size) return;
+  const assignments = setClause.split(",");
+  let placeholderIndex = 0;
+  for (const assignment of assignments) {
+    if (!assignment.includes("?")) continue;
+    placeholderIndex += 1;
+    const colMatch = /^\s*(?:[A-Za-z_][A-Za-z0-9_]*\.)?([A-Za-z_][A-Za-z0-9_]*)\s*=\s*\?/iu.exec(assignment);
+    if (colMatch && boolColumns.has(colMatch[1])) {
+      args[placeholderIndex - 1] = toBoolean(args[placeholderIndex - 1]);
+    }
+  }
+}
+function coerceBooleanArgs(sql, args) {
+  const nextArgs = [...args];
+  coerceInsertBooleanArgs(sql, nextArgs);
+  coerceUpdateBooleanArgs(sql, nextArgs);
+  const placeholderIndexes = findBooleanPlaceholderIndexes(sql);
+  for (const index of placeholderIndexes) {
+    if (index > 0 && index <= nextArgs.length) {
+      nextArgs[index - 1] = toBoolean(nextArgs[index - 1]);
+    }
+  }
+  return nextArgs;
+}
+function convertQuestionMarksToDollarParams(sql) {
+  let out = "";
+  let placeholder = 0;
+  let inSingle = false;
+  let inDouble = false;
+  let inLineComment = false;
+  let inBlockComment = false;
+  for (let i = 0; i < sql.length; i++) {
+    const ch = sql[i];
+    const next = sql[i + 1];
+    if (inLineComment) {
+      out += ch;
+      if (ch === "\n") inLineComment = false;
+      continue;
+    }
+    if (inBlockComment) {
+      out += ch;
+      if (ch === "*" && next === "/") {
+        out += next;
+        inBlockComment = false;
+        i += 1;
+      }
+      continue;
+    }
+    if (!inSingle && !inDouble && ch === "-" && next === "-") {
+      out += ch + next;
+      inLineComment = true;
+      i += 1;
+      continue;
+    }
+    if (!inSingle && !inDouble && ch === "/" && next === "*") {
+      out += ch + next;
+      inBlockComment = true;
+      i += 1;
+      continue;
+    }
+    if (!inDouble && ch === "'" && sql[i - 1] !== "\\") {
+      inSingle = !inSingle;
+      out += ch;
+      continue;
+    }
+    if (!inSingle && ch === '"' && sql[i - 1] !== "\\") {
+      inDouble = !inDouble;
+      out += ch;
+      continue;
+    }
+    if (!inSingle && !inDouble && ch === "?") {
+      placeholder += 1;
+      out += `$${placeholder}`;
+      continue;
+    }
+    out += ch;
+  }
+  return out;
+}
+function translateStatementForPostgres(stmt) {
+  const normalized = normalizeStatement(stmt);
+  if (normalized.kind === "named") {
+    throw new Error("Named SQL parameters are not supported by the Prisma adapter.");
+  }
+  const rewrittenSql = rewriteSql(normalized.sql);
+  const coercedArgs = coerceBooleanArgs(rewrittenSql, normalized.args);
+  return {
+    sql: convertQuestionMarksToDollarParams(rewrittenSql),
+    args: coercedArgs
+  };
+}
+function shouldBypassPostgres(stmt) {
+  const normalized = normalizeStatement(stmt);
+  if (normalized.kind === "named") {
+    return true;
+  }
+  return IMMEDIATE_FALLBACK_PATTERNS.some((pattern) => pattern.test(normalized.sql));
+}
+function shouldFallbackOnError(error) {
+  const message = error instanceof Error ? error.message : String(error);
+  return /42P01|42883|42601|does not exist|syntax error|not supported|Named SQL parameters are not supported/iu.test(message);
+}
+function isReadQuery(sql) {
+  const trimmed = sql.trimStart();
+  return /^(SELECT|WITH|SHOW|EXPLAIN|VALUES)\b/iu.test(trimmed) || /\bRETURNING\b/iu.test(trimmed);
+}
+function buildRow(row, columns) {
+  const values = columns.map((column) => row[column]);
+  return Object.assign(values, row);
+}
+function buildResultSet(rows, rowsAffected = 0) {
+  const columns = rows[0] ? Object.keys(rows[0]) : [];
+  const resultRows = rows.map((row) => buildRow(row, columns));
+  return {
+    columns,
+    columnTypes: columns.map(() => ""),
+    rows: resultRows,
+    rowsAffected,
+    lastInsertRowid: void 0,
+    toJSON() {
+      return {
+        columns,
+        columnTypes: columns.map(() => ""),
+        rows,
+        rowsAffected,
+        lastInsertRowid: void 0
+      };
+    }
+  };
+}
+async function loadPrismaClient() {
+  if (!prismaClientPromise) {
+    prismaClientPromise = (async () => {
+      const explicitPath = process.env.EXE_OS_PRISMA_CLIENT_PATH;
+      if (explicitPath) {
+        const module2 = await import(pathToFileURL(explicitPath).href);
+        const PrismaClient2 = module2.PrismaClient ?? module2.default?.PrismaClient;
+        if (!PrismaClient2) {
+          throw new Error(`No PrismaClient export found at ${explicitPath}`);
+        }
+        return new PrismaClient2();
+      }
+      const exeDbRoot = process.env.EXE_DB_ROOT ?? path3.join(os3.homedir(), "exe-db");
+      const requireFromExeDb = createRequire(path3.join(exeDbRoot, "package.json"));
+      const prismaEntry = requireFromExeDb.resolve("@prisma/client");
+      const module = await import(pathToFileURL(prismaEntry).href);
+      const PrismaClient = module.PrismaClient ?? module.default?.PrismaClient;
+      if (!PrismaClient) {
+        throw new Error(`No PrismaClient export found in ${prismaEntry}`);
+      }
+      return new PrismaClient();
+    })();
+  }
+  return prismaClientPromise;
+}
+async function ensureCompatibilityViews(prisma) {
+  if (!compatibilityBootstrapPromise) {
+    compatibilityBootstrapPromise = (async () => {
+      for (const mapping of VIEW_MAPPINGS) {
+        const relation = mapping.source.replace(/"/g, "");
+        const rows = await prisma.$queryRawUnsafe(
+          "SELECT to_regclass($1) AS regclass",
+          relation
+        );
+        if (!rows[0]?.regclass) {
+          continue;
+        }
+        await prisma.$executeRawUnsafe(
+          `CREATE OR REPLACE VIEW public.${quotedIdentifier(mapping.view)} AS SELECT * FROM ${mapping.source}`
+        );
+      }
+    })();
+  }
+  return compatibilityBootstrapPromise;
+}
+async function executeOnPrisma(executor, stmt) {
+  const translated = translateStatementForPostgres(stmt);
+  if (isReadQuery(translated.sql)) {
+    const rows = await executor.$queryRawUnsafe(
+      translated.sql,
+      ...translated.args
+    );
+    return buildResultSet(rows, /\bRETURNING\b/iu.test(translated.sql) ? rows.length : 0);
+  }
+  const rowsAffected = await executor.$executeRawUnsafe(translated.sql, ...translated.args);
+  return buildResultSet([], rowsAffected);
+}
+function splitSqlStatements(sql) {
+  const parts = [];
+  let current = "";
+  let inSingle = false;
+  let inDouble = false;
+  let inLineComment = false;
+  let inBlockComment = false;
+  for (let i = 0; i < sql.length; i++) {
+    const ch = sql[i];
+    const next = sql[i + 1];
+    if (inLineComment) {
+      current += ch;
+      if (ch === "\n") inLineComment = false;
+      continue;
+    }
+    if (inBlockComment) {
+      current += ch;
+      if (ch === "*" && next === "/") {
+        current += next;
+        inBlockComment = false;
+        i += 1;
+      }
+      continue;
+    }
+    if (!inSingle && !inDouble && ch === "-" && next === "-") {
+      current += ch + next;
+      inLineComment = true;
+      i += 1;
+      continue;
+    }
+    if (!inSingle && !inDouble && ch === "/" && next === "*") {
+      current += ch + next;
+      inBlockComment = true;
+      i += 1;
+      continue;
+    }
+    if (!inDouble && ch === "'" && sql[i - 1] !== "\\") {
+      inSingle = !inSingle;
+      current += ch;
+      continue;
+    }
+    if (!inSingle && ch === '"' && sql[i - 1] !== "\\") {
+      inDouble = !inDouble;
+      current += ch;
+      continue;
+    }
+    if (!inSingle && !inDouble && ch === ";") {
+      if (current.trim()) {
+        parts.push(current.trim());
+      }
+      current = "";
+      continue;
+    }
+    current += ch;
+  }
+  if (current.trim()) {
+    parts.push(current.trim());
+  }
+  return parts;
+}
+async function createPrismaDbAdapter(fallbackClient) {
+  const prisma = await loadPrismaClient();
+  await ensureCompatibilityViews(prisma);
+  let closed = false;
+  let adapter;
+  const fallbackExecute = async (stmt, error) => {
+    if (!fallbackClient) {
+      if (error) throw error;
+      throw new Error("No fallback SQLite client is available for this Prisma-routed query.");
+    }
+    if (error) {
+      process.stderr.write(
+        `[database-adapter] Falling back to SQLite: ${error instanceof Error ? error.message : String(error)}
+`
+      );
+    }
+    return fallbackClient.execute(stmt);
+  };
+  adapter = {
+    async execute(stmt) {
+      if (shouldBypassPostgres(stmt)) {
+        return fallbackExecute(stmt);
+      }
+      try {
+        return await executeOnPrisma(prisma, stmt);
+      } catch (error) {
+        if (shouldFallbackOnError(error)) {
+          return fallbackExecute(stmt, error);
+        }
+        throw error;
+      }
+    },
+    async batch(stmts, mode) {
+      if (stmts.some((stmt) => shouldBypassPostgres(stmt))) {
+        if (!fallbackClient) {
+          throw new Error("Cannot batch unsupported SQLite-only statements without a fallback client.");
+        }
+        return fallbackClient.batch(stmts, mode);
+      }
+      try {
+        if (prisma.$transaction) {
+          return await prisma.$transaction(async (tx) => {
+            const results2 = [];
+            for (const stmt of stmts) {
+              results2.push(await executeOnPrisma(tx, stmt));
+            }
+            return results2;
+          });
+        }
+        const results = [];
+        for (const stmt of stmts) {
+          results.push(await executeOnPrisma(prisma, stmt));
+        }
+        return results;
+      } catch (error) {
+        if (fallbackClient && shouldFallbackOnError(error)) {
+          process.stderr.write(
+            `[database-adapter] Falling back batch to SQLite: ${error instanceof Error ? error.message : String(error)}
+`
+          );
+          return fallbackClient.batch(stmts, mode);
+        }
+        throw error;
+      }
+    },
+    async migrate(stmts) {
+      if (fallbackClient) {
+        return fallbackClient.migrate(stmts);
+      }
+      return adapter.batch(stmts, "deferred");
+    },
+    async transaction(mode) {
+      if (!fallbackClient) {
+        throw new Error("Interactive transactions are only supported on the SQLite fallback client.");
+      }
+      return fallbackClient.transaction(mode);
+    },
+    async executeMultiple(sql) {
+      if (fallbackClient && shouldBypassPostgres(sql)) {
+        return fallbackClient.executeMultiple(sql);
+      }
+      for (const statement of splitSqlStatements(sql)) {
+        await adapter.execute(statement);
+      }
+    },
+    async sync() {
+      if (fallbackClient) {
+        return fallbackClient.sync();
+      }
+      return { frame_no: 0, frames_synced: 0 };
+    },
+    close() {
+      closed = true;
+      prismaClientPromise = null;
+      compatibilityBootstrapPromise = null;
+      void prisma.$disconnect?.();
+    },
+    get closed() {
+      return closed;
+    },
+    get protocol() {
+      return "prisma-postgres";
+    }
+  };
+  return adapter;
+}
+var VIEW_MAPPINGS, UPSERT_KEYS, BOOLEAN_COLUMNS_BY_TABLE, BOOLEAN_COLUMN_NAMES, IMMEDIATE_FALLBACK_PATTERNS, prismaClientPromise, compatibilityBootstrapPromise;
+var init_database_adapter = __esm({
+  "src/lib/database-adapter.ts"() {
+    "use strict";
+    VIEW_MAPPINGS = [
+      { view: "memories", source: "memory.memory_records" },
+      { view: "tasks", source: "memory.tasks" },
+      { view: "behaviors", source: "memory.behaviors" },
+      { view: "entities", source: "memory.entities" },
+      { view: "relationships", source: "memory.relationships" },
+      { view: "entity_memories", source: "memory.entity_memories" },
+      { view: "entity_aliases", source: "memory.entity_aliases" },
+      { view: "notifications", source: "memory.notifications" },
+      { view: "messages", source: "memory.messages" },
+      { view: "users", source: "wiki.users" },
+      { view: "workspaces", source: "wiki.workspaces" },
+      { view: "workspace_users", source: "wiki.workspace_users" },
+      { view: "documents", source: "wiki.workspace_documents" },
+      { view: "chats", source: "wiki.workspace_chats" }
+    ];
+    UPSERT_KEYS = {
+      memories: ["id"],
+      tasks: ["id"],
+      behaviors: ["id"],
+      entities: ["id"],
+      relationships: ["id"],
+      entity_aliases: ["alias"],
+      notifications: ["id"],
+      messages: ["id"],
+      users: ["id"],
+      workspaces: ["id"],
+      workspace_users: ["id"],
+      documents: ["id"],
+      chats: ["id"]
+    };
+    BOOLEAN_COLUMNS_BY_TABLE = {
+      memories: /* @__PURE__ */ new Set(["has_error", "draft"]),
+      behaviors: /* @__PURE__ */ new Set(["active"]),
+      notifications: /* @__PURE__ */ new Set(["read"]),
+      users: /* @__PURE__ */ new Set(["has_personal_memory"])
+    };
+    BOOLEAN_COLUMN_NAMES = new Set(
+      Object.values(BOOLEAN_COLUMNS_BY_TABLE).flatMap((cols) => [...cols])
+    );
+    IMMEDIATE_FALLBACK_PATTERNS = [
+      /\bPRAGMA\b/i,
+      /\bsqlite_master\b/i,
+      /(?:^|[.\s])(?:memories|conversations|entities)_fts\b/i,
+      /\bMATCH\b/i,
+      /\bvector_distance_cos\s*\(/i,
+      /\bjson_extract\s*\(/i,
+      /\bjulianday\s*\(/i,
+      /\bstrftime\s*\(/i,
+      /\blast_insert_rowid\s*\(/i
+    ];
+    prismaClientPromise = null;
+    compatibilityBootstrapPromise = null;
+  }
+});
+
 // src/lib/exe-daemon-client.ts
 import net from "net";
-import os3 from "os";
+import os4 from "os";
 import { spawn } from "child_process";
 import { randomUUID } from "crypto";
 import { existsSync as existsSync3, unlinkSync as unlinkSync2, readFileSync as readFileSync3, openSync, closeSync, statSync } from "fs";
-import path3 from "path";
+import path4 from "path";
 import { fileURLToPath } from "url";
 function handleData(chunk) {
   _buffer += chunk.toString();
@@ -492,17 +1077,17 @@ function cleanupStaleFiles() {
   }
 }
 function findPackageRoot() {
-  let dir = path3.dirname(fileURLToPath(import.meta.url));
-  const { root } = path3.parse(dir);
+  let dir = path4.dirname(fileURLToPath(import.meta.url));
+  const { root } = path4.parse(dir);
   while (dir !== root) {
-    if (existsSync3(path3.join(dir, "package.json"))) return dir;
-    dir = path3.dirname(dir);
+    if (existsSync3(path4.join(dir, "package.json"))) return dir;
+    dir = path4.dirname(dir);
   }
   return null;
 }
 function spawnDaemon() {
-  const freeGB = os3.freemem() / (1024 * 1024 * 1024);
-  const totalGB = os3.totalmem() / (1024 * 1024 * 1024);
+  const freeGB = os4.freemem() / (1024 * 1024 * 1024);
+  const totalGB = os4.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.
@@ -522,7 +1107,7 @@ function spawnDaemon() {
     process.stderr.write("[exed-client] WARN: cannot find package root\n");
     return;
   }
-  const daemonPath = path3.join(pkgRoot, "dist", "lib", "exe-daemon.js");
+  const daemonPath = path4.join(pkgRoot, "dist", "lib", "exe-daemon.js");
   if (!existsSync3(daemonPath)) {
     process.stderr.write(`[exed-client] WARN: daemon script not found at ${daemonPath}
 `);
@@ -531,7 +1116,7 @@ function spawnDaemon() {
   const resolvedPath = daemonPath;
   process.stderr.write(`[exed-client] Spawning daemon: ${resolvedPath}
 `);
-  const logPath = path3.join(path3.dirname(SOCKET_PATH), "exed.log");
+  const logPath = path4.join(path4.dirname(SOCKET_PATH), "exed.log");
   let stderrFd = "ignore";
   try {
     stderrFd = openSync(logPath, "a");
@@ -678,9 +1263,9 @@ 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 ?? path3.join(EXE_AI_DIR, "exed.sock");
-    PID_PATH = process.env.EXE_DAEMON_PID ?? process.env.EXE_EMBED_PID ?? path3.join(EXE_AI_DIR, "exed.pid");
-    SPAWN_LOCK_PATH = path3.join(EXE_AI_DIR, "exed-spawn.lock");
+    SOCKET_PATH = process.env.EXE_DAEMON_SOCK ?? process.env.EXE_EMBED_SOCK ?? path4.join(EXE_AI_DIR, "exed.sock");
+    PID_PATH = process.env.EXE_DAEMON_PID ?? process.env.EXE_EMBED_PID ?? path4.join(EXE_AI_DIR, "exed.pid");
+    SPAWN_LOCK_PATH = path4.join(EXE_AI_DIR, "exed-spawn.lock");
     SPAWN_LOCK_STALE_MS = 3e4;
     CONNECT_TIMEOUT_MS = 15e3;
     REQUEST_TIMEOUT_MS = 3e4;
@@ -762,7 +1347,7 @@ __export(db_daemon_client_exports, {
   createDaemonDbClient: () => createDaemonDbClient,
   initDaemonDbClient: () => initDaemonDbClient
 });
-function normalizeStatement(stmt) {
+function normalizeStatement2(stmt) {
   if (typeof stmt === "string") {
     return { sql: stmt, args: [] };
   }
@@ -786,7 +1371,7 @@ function createDaemonDbClient(fallbackClient) {
       if (!_useDaemon || !isClientConnected()) {
         return fallbackClient.execute(stmt);
       }
-      const { sql, args } = normalizeStatement(stmt);
+      const { sql, args } = normalizeStatement2(stmt);
       const response = await sendDaemonRequest({
         type: "db-execute",
         sql,
@@ -811,7 +1396,7 @@ function createDaemonDbClient(fallbackClient) {
       if (!_useDaemon || !isClientConnected()) {
         return fallbackClient.batch(stmts, mode);
       }
-      const statements = stmts.map(normalizeStatement);
+      const statements = stmts.map(normalizeStatement2);
       const response = await sendDaemonRequest({
         type: "db-batch",
         statements,
@@ -906,6 +1491,18 @@ __export(database_exports, {
 });
 import { createClient } from "@libsql/client";
 async function initDatabase(config) {
+  if (_walCheckpointTimer) {
+    clearInterval(_walCheckpointTimer);
+    _walCheckpointTimer = null;
+  }
+  if (_daemonClient) {
+    _daemonClient.close();
+    _daemonClient = null;
+  }
+  if (_adapterClient && _adapterClient !== _resilientClient) {
+    _adapterClient.close();
+  }
+  _adapterClient = null;
   if (_client) {
     _client.close();
     _client = null;
@@ -919,6 +1516,7 @@ async function initDatabase(config) {
   }
   _client = createClient(opts);
   _resilientClient = wrapWithRetry(_client);
+  _adapterClient = _resilientClient;
   _client.execute("PRAGMA busy_timeout = 30000").catch(() => {
   });
   _client.execute("PRAGMA journal_mode = WAL").catch(() => {
@@ -929,14 +1527,20 @@ async function initDatabase(config) {
     });
   }, 3e4);
   _walCheckpointTimer.unref();
+  if (process.env.DATABASE_URL) {
+    _adapterClient = await createPrismaDbAdapter(_resilientClient);
+  }
 }
 function isInitialized() {
-  return _client !== null;
+  return _adapterClient !== null || _client !== null;
 }
 function getClient() {
-  if (!_resilientClient) {
+  if (!_adapterClient) {
     throw new Error("Database client not initialized. Call initDatabase() first.");
   }
+  if (process.env.DATABASE_URL) {
+    return _adapterClient;
+  }
   if (process.env.EXE_IS_DAEMON === "1") {
     return _resilientClient;
   }
@@ -946,6 +1550,7 @@ function getClient() {
   return _resilientClient;
 }
 async function initDaemonClient() {
+  if (process.env.DATABASE_URL) return;
   if (process.env.EXE_IS_DAEMON === "1") return;
   if (!_resilientClient) return;
   try {
@@ -1890,26 +2495,36 @@ async function ensureSchema() {
   }
 }
 async function disposeDatabase() {
+  if (_walCheckpointTimer) {
+    clearInterval(_walCheckpointTimer);
+    _walCheckpointTimer = null;
+  }
   if (_daemonClient) {
     _daemonClient.close();
     _daemonClient = null;
   }
+  if (_adapterClient && _adapterClient !== _resilientClient) {
+    _adapterClient.close();
+  }
+  _adapterClient = null;
   if (_client) {
     _client.close();
     _client = null;
     _resilientClient = null;
   }
 }
-var _client, _resilientClient, _walCheckpointTimer, _daemonClient, initTurso, disposeTurso;
+var _client, _resilientClient, _walCheckpointTimer, _daemonClient, _adapterClient, initTurso, disposeTurso;
 var init_database = __esm({
   "src/lib/database.ts"() {
     "use strict";
     init_db_retry();
     init_employees();
+    init_database_adapter();
     _client = null;
     _resilientClient = null;
     _walCheckpointTimer = null;
     _daemonClient = null;
+    _adapterClient = null;
     initTurso = initDatabase;
     disposeTurso = disposeDatabase;
   }
@@ -2120,13 +2735,13 @@ __export(keychain_exports, {
 });
 import { readFile as readFile3, writeFile as writeFile3, unlink, mkdir as mkdir3, chmod as chmod2 } from "fs/promises";
 import { existsSync as existsSync4 } from "fs";
-import path4 from "path";
-import os4 from "os";
+import path5 from "path";
+import os5 from "os";
 function getKeyDir() {
-  return process.env.EXE_OS_DIR ?? process.env.EXE_MEM_DIR ?? path4.join(os4.homedir(), ".exe-os");
+  return process.env.EXE_OS_DIR ?? process.env.EXE_MEM_DIR ?? path5.join(os5.homedir(), ".exe-os");
 }
 function getKeyPath() {
-  return path4.join(getKeyDir(), "master.key");
+  return path5.join(getKeyDir(), "master.key");
 }
 async function tryKeytar() {
   try {
@@ -2149,7 +2764,7 @@ async function getMasterKey() {
   const keyPath = getKeyPath();
   if (!existsSync4(keyPath)) {
     process.stderr.write(
-      `[keychain] Key not found at ${keyPath} (HOME=${os4.homedir()}, EXE_OS_DIR=${process.env.EXE_OS_DIR ?? "unset"})
+      `[keychain] Key not found at ${keyPath} (HOME=${os5.homedir()}, EXE_OS_DIR=${process.env.EXE_OS_DIR ?? "unset"})
 `
     );
     return null;
@@ -2300,7 +2915,7 @@ __export(shard_manager_exports, {
   listShards: () => listShards,
   shardExists: () => shardExists
 });
-import path5 from "path";
+import path6 from "path";
 import { existsSync as existsSync5, mkdirSync, readdirSync } from "fs";
 import { createClient as createClient2 } from "@libsql/client";
 function initShardManager(encryptionKey) {
@@ -2326,7 +2941,7 @@ function getShardClient(projectName) {
   }
   const cached = _shards.get(safeName);
   if (cached) return cached;
-  const dbPath = path5.join(SHARDS_DIR, `${safeName}.db`);
+  const dbPath = path6.join(SHARDS_DIR, `${safeName}.db`);
   const client = createClient2({
     url: `file:${dbPath}`,
     encryptionKey: _encryptionKey
@@ -2336,7 +2951,7 @@ function getShardClient(projectName) {
 }
 function shardExists(projectName) {
   const safeName = projectName.replace(/[^a-zA-Z0-9_-]/g, "_");
-  return existsSync5(path5.join(SHARDS_DIR, `${safeName}.db`));
+  return existsSync5(path6.join(SHARDS_DIR, `${safeName}.db`));
 }
 function listShards() {
   if (!existsSync5(SHARDS_DIR)) return [];
@@ -2413,7 +3028,23 @@ async function ensureShardSchema(client) {
     // MS-11: draft staging, MS-6a: memory_type, MS-7: trajectory
     "ALTER TABLE memories ADD COLUMN draft INTEGER DEFAULT 0",
     "ALTER TABLE memories ADD COLUMN memory_type TEXT DEFAULT 'raw'",
-    "ALTER TABLE memories ADD COLUMN trajectory TEXT"
+    "ALTER TABLE memories ADD COLUMN trajectory TEXT",
+    // Metadata enrichment columns (must match database.ts)
+    "ALTER TABLE memories ADD COLUMN intent TEXT",
+    "ALTER TABLE memories ADD COLUMN outcome TEXT",
+    "ALTER TABLE memories ADD COLUMN domain TEXT",
+    "ALTER TABLE memories ADD COLUMN referenced_entities TEXT",
+    "ALTER TABLE memories ADD COLUMN retrieval_count INTEGER DEFAULT 0",
+    "ALTER TABLE memories ADD COLUMN chain_position TEXT",
+    "ALTER TABLE memories ADD COLUMN review_status TEXT",
+    "ALTER TABLE memories ADD COLUMN context_window_pct INTEGER",
+    "ALTER TABLE memories ADD COLUMN file_paths TEXT",
+    "ALTER TABLE memories ADD COLUMN commit_hash TEXT",
+    "ALTER TABLE memories ADD COLUMN duration_ms INTEGER",
+    "ALTER TABLE memories ADD COLUMN token_cost REAL",
+    "ALTER TABLE memories ADD COLUMN audience TEXT",
+    "ALTER TABLE memories ADD COLUMN language_type TEXT",
+    "ALTER TABLE memories ADD COLUMN parent_memory_id TEXT"
   ]) {
     try {
       await client.execute(col);
@@ -2525,7 +3156,7 @@ var init_shard_manager = __esm({
   "src/lib/shard-manager.ts"() {
     "use strict";
     init_config();
-    SHARDS_DIR = path5.join(EXE_AI_DIR, "shards");
+    SHARDS_DIR = path6.join(EXE_AI_DIR, "shards");
     _shards = /* @__PURE__ */ new Map();
     _encryptionKey = null;
     _shardingEnabled = false;
@@ -2633,10 +3264,10 @@ __export(session_registry_exports, {
 });
 import { readFileSync as readFileSync4, writeFileSync as writeFileSync2, mkdirSync as mkdirSync2, existsSync as existsSync6 } from "fs";
 import { execSync as execSync2 } from "child_process";
-import path6 from "path";
-import os5 from "os";
+import path7 from "path";
+import os6 from "os";
 function registerSession(entry) {
-  const dir = path6.dirname(REGISTRY_PATH);
+  const dir = path7.dirname(REGISTRY_PATH);
   if (!existsSync6(dir)) {
     mkdirSync2(dir, { recursive: true });
   }
@@ -2680,7 +3311,7 @@ var REGISTRY_PATH;
 var init_session_registry = __esm({
   "src/lib/session-registry.ts"() {
     "use strict";
-    REGISTRY_PATH = path6.join(os5.homedir(), ".exe-os", "session-registry.json");
+    REGISTRY_PATH = path7.join(os6.homedir(), ".exe-os", "session-registry.json");
   }
 });
 
@@ -2961,7 +3592,7 @@ var init_runtime_table = __esm({
 
 // src/lib/agent-config.ts
 import { readFileSync as readFileSync5, writeFileSync as writeFileSync3, existsSync as existsSync7, mkdirSync as mkdirSync3 } from "fs";
-import path7 from "path";
+import path8 from "path";
 function loadAgentConfig() {
   if (!existsSync7(AGENT_CONFIG_PATH)) return {};
   try {
@@ -2984,7 +3615,7 @@ var init_agent_config = __esm({
     "use strict";
     init_config();
     init_runtime_table();
-    AGENT_CONFIG_PATH = path7.join(EXE_AI_DIR, "agent-config.json");
+    AGENT_CONFIG_PATH = path8.join(EXE_AI_DIR, "agent-config.json");
     DEFAULT_MODELS = {
       claude: "claude-opus-4",
       codex: RUNTIME_TABLE.codex?.defaultModel ?? "gpt-5.4",
@@ -3003,10 +3634,10 @@ __export(intercom_queue_exports, {
   readQueue: () => readQueue
 });
 import { readFileSync as readFileSync6, writeFileSync as writeFileSync4, renameSync as renameSync3, existsSync as existsSync8, mkdirSync as mkdirSync4 } from "fs";
-import path8 from "path";
-import os6 from "os";
+import path9 from "path";
+import os7 from "os";
 function ensureDir() {
-  const dir = path8.dirname(QUEUE_PATH);
+  const dir = path9.dirname(QUEUE_PATH);
   if (!existsSync8(dir)) mkdirSync4(dir, { recursive: true });
 }
 function readQueue() {
@@ -3112,10 +3743,10 @@ var QUEUE_PATH, MAX_RETRIES2, TTL_MS, INTERCOM_LOG;
 var init_intercom_queue = __esm({
   "src/lib/intercom-queue.ts"() {
     "use strict";
-    QUEUE_PATH = path8.join(os6.homedir(), ".exe-os", "intercom-queue.json");
+    QUEUE_PATH = path9.join(os7.homedir(), ".exe-os", "intercom-queue.json");
     MAX_RETRIES2 = 5;
     TTL_MS = 60 * 60 * 1e3;
-    INTERCOM_LOG = path8.join(os6.homedir(), ".exe-os", "intercom.log");
+    INTERCOM_LOG = path9.join(os7.homedir(), ".exe-os", "intercom.log");
   }
 });
 
@@ -3138,7 +3769,7 @@ __export(license_exports, {
 });
 import { readFileSync as readFileSync7, writeFileSync as writeFileSync5, existsSync as existsSync9, mkdirSync as mkdirSync5 } from "fs";
 import { randomUUID as randomUUID3 } from "crypto";
-import path9 from "path";
+import path10 from "path";
 import { jwtVerify, importSPKI } from "jose";
 async function fetchRetry(url, init) {
   try {
@@ -3149,7 +3780,7 @@ async function fetchRetry(url, init) {
   }
 }
 function loadDeviceId() {
-  const deviceJsonPath = path9.join(EXE_AI_DIR, "device.json");
+  const deviceJsonPath = path10.join(EXE_AI_DIR, "device.json");
   try {
     if (existsSync9(deviceJsonPath)) {
       const data = JSON.parse(readFileSync7(deviceJsonPath, "utf8"));
@@ -3314,7 +3945,7 @@ async function checkLicense() {
   let key = loadLicense();
   if (!key) {
     try {
-      const configPath = path9.join(EXE_AI_DIR, "config.json");
+      const configPath = path10.join(EXE_AI_DIR, "config.json");
       if (existsSync9(configPath)) {
         const raw = JSON.parse(readFileSync7(configPath, "utf8"));
         const cloud = raw.cloud;
@@ -3475,9 +4106,9 @@ 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");
     API_BASE = "https://askexe.com/cloud";
     RETRY_DELAY_MS = 500;
     LICENSE_PUBLIC_KEY_PEM = `-----BEGIN PUBLIC KEY-----
@@ -3508,7 +4139,7 @@ MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEeHztAMOpR/ZMh+rWuOASjEZ54CGY
 
 // src/lib/plan-limits.ts
 import { readFileSync as readFileSync8, existsSync as existsSync10 } from "fs";
-import path10 from "path";
+import path11 from "path";
 function getLicenseSync() {
   try {
     if (!existsSync10(CACHE_PATH2)) return freeLicense();
@@ -3580,14 +4211,14 @@ var init_plan_limits = __esm({
         this.name = "PlanLimitError";
       }
     };
-    CACHE_PATH2 = path10.join(EXE_AI_DIR, "license-cache.json");
+    CACHE_PATH2 = path11.join(EXE_AI_DIR, "license-cache.json");
   }
 });
 
 // src/lib/notifications.ts
 import crypto from "crypto";
-import path11 from "path";
-import os7 from "os";
+import path12 from "path";
+import os8 from "os";
 import {
   readFileSync as readFileSync9,
   readdirSync as readdirSync2,
@@ -3705,8 +4336,8 @@ async function markDoneTaskNotificationsAsRead() {
   }
 }
 async function migrateJsonNotifications() {
-  const base = process.env.EXE_OS_DIR || process.env.EXE_MEM_DIR || path11.join(os7.homedir(), ".exe-os");
-  const notifDir = path11.join(base, "notifications");
+  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;
   let migrated = 0;
   try {
@@ -3715,7 +4346,7 @@ async function migrateJsonNotifications() {
     const client = getClient();
     for (const file of files) {
       try {
-        const filePath = path11.join(notifDir, file);
+        const filePath = path12.join(notifDir, file);
         const data = JSON.parse(readFileSync9(filePath, "utf8"));
         await client.execute({
           sql: `INSERT OR IGNORE INTO notifications (id, agent_id, agent_role, event, project, summary, task_file, read, created_at)
@@ -3863,8 +4494,8 @@ var init_session_kill_telemetry = __esm({
 
 // src/lib/tasks-crud.ts
 import crypto3 from "crypto";
-import path12 from "path";
-import os8 from "os";
+import path13 from "path";
+import os9 from "os";
 import { execSync as execSync5 } from "child_process";
 import { mkdir as mkdir4, writeFile as writeFile4, appendFile } from "fs/promises";
 import { existsSync as existsSync12, readFileSync as readFileSync10 } from "fs";
@@ -4042,8 +4673,8 @@ ${laneWarning}` : laneWarning;
   }
   if (input.baseDir) {
     try {
-      await mkdir4(path12.join(input.baseDir, "exe", "output"), { recursive: true });
-      await mkdir4(path12.join(input.baseDir, "exe", "research"), { recursive: true });
+      await mkdir4(path13.join(input.baseDir, "exe", "output"), { recursive: true });
+      await mkdir4(path13.join(input.baseDir, "exe", "research"), { recursive: true });
       await ensureArchitectureDoc(input.baseDir, input.projectName);
       await ensureGitignoreExe(input.baseDir);
     } catch {
@@ -4079,9 +4710,9 @@ ${laneWarning}` : laneWarning;
   });
   if (input.baseDir) {
     try {
-      const EXE_OS_DIR = path12.join(os8.homedir(), ".exe-os");
-      const mdPath = path12.join(EXE_OS_DIR, taskFile);
-      const mdDir = path12.dirname(mdPath);
+      const EXE_OS_DIR = path13.join(os9.homedir(), ".exe-os");
+      const mdPath = path13.join(EXE_OS_DIR, taskFile);
+      const mdDir = path13.dirname(mdPath);
       if (!existsSync12(mdDir)) await mkdir4(mdDir, { recursive: true });
       const reviewer = input.reviewer ?? input.assignedBy;
       const mdContent = `# ${input.title}
@@ -4382,7 +5013,7 @@ async function deleteTaskCore(taskId, _baseDir) {
   return { taskFile, assignedTo, assignedBy, taskSlug };
 }
 async function ensureArchitectureDoc(baseDir, projectName) {
-  const archPath = path12.join(baseDir, "exe", "ARCHITECTURE.md");
+  const archPath = path13.join(baseDir, "exe", "ARCHITECTURE.md");
   try {
     if (existsSync12(archPath)) return;
     const template = [
@@ -4417,7 +5048,7 @@ async function ensureArchitectureDoc(baseDir, projectName) {
   }
 }
 async function ensureGitignoreExe(baseDir) {
-  const gitignorePath = path12.join(baseDir, ".gitignore");
+  const gitignorePath = path13.join(baseDir, ".gitignore");
   try {
     if (existsSync12(gitignorePath)) {
       const content = readFileSync10(gitignorePath, "utf-8");
@@ -4451,13 +5082,13 @@ var init_tasks_crud = __esm({
 });
 
 // src/lib/tasks-review.ts
-import path13 from "path";
+import path14 from "path";
 import { existsSync as existsSync13, readdirSync as readdirSync3, unlinkSync as unlinkSync4 } from "fs";
 async function countPendingReviews(sessionScope) {
   const client = getClient();
   if (sessionScope) {
     const result2 = await client.execute({
-      sql: "SELECT COUNT(*) as cnt FROM tasks WHERE status = 'needs_review' AND (session_scope = ? OR session_scope IS NULL)",
+      sql: "SELECT COUNT(*) as cnt FROM tasks WHERE status = 'needs_review' AND session_scope = ?",
       args: [sessionScope]
     });
     return Number(result2.rows[0]?.cnt) || 0;
@@ -4633,11 +5264,11 @@ async function cleanupReviewFile(row, taskFile, _baseDir) {
     );
   }
   try {
-    const cacheDir = path13.join(EXE_AI_DIR, "session-cache");
+    const cacheDir = path14.join(EXE_AI_DIR, "session-cache");
     if (existsSync13(cacheDir)) {
       for (const f of readdirSync3(cacheDir)) {
         if (f.startsWith("review-notified-")) {
-          unlinkSync4(path13.join(cacheDir, f));
+          unlinkSync4(path14.join(cacheDir, f));
         }
       }
     }
@@ -4658,7 +5289,7 @@ var init_tasks_review = __esm({
 });
 
 // src/lib/tasks-chain.ts
-import path14 from "path";
+import path15 from "path";
 import { readFile as readFile4, writeFile as writeFile5 } from "fs/promises";
 async function cascadeUnblock(taskId, baseDir, now) {
   const client = getClient();
@@ -4675,7 +5306,7 @@ async function cascadeUnblock(taskId, baseDir, now) {
     });
     for (const ur of unblockedRows.rows) {
       try {
-        const ubFile = path14.join(baseDir, String(ur.task_file));
+        const ubFile = path15.join(baseDir, String(ur.task_file));
         let ubContent = await readFile4(ubFile, "utf-8");
         ubContent = ubContent.replace(/\*\*Status:\*\* blocked/, "**Status:** open");
         ubContent = ubContent.replace(/\n\*\*Blocked by:\*\*.*\n/, "\n");
@@ -4749,7 +5380,7 @@ __export(project_name_exports, {
   getProjectName: () => getProjectName
 });
 import { execSync as execSync6 } from "child_process";
-import path15 from "path";
+import path16 from "path";
 function getProjectName(cwd) {
   const dir = cwd ?? process.cwd();
   if (_cached2 && _cachedCwd === dir) return _cached2;
@@ -4762,7 +5393,7 @@ function getProjectName(cwd) {
         timeout: 2e3,
         stdio: ["pipe", "pipe", "pipe"]
       }).trim();
-      repoRoot = path15.dirname(gitCommonDir);
+      repoRoot = path16.dirname(gitCommonDir);
     } catch {
       repoRoot = execSync6("git rev-parse --show-toplevel", {
         cwd: dir,
@@ -4771,11 +5402,11 @@ function getProjectName(cwd) {
         stdio: ["pipe", "pipe", "pipe"]
       }).trim();
     }
-    _cached2 = path15.basename(repoRoot);
+    _cached2 = path16.basename(repoRoot);
     _cachedCwd = dir;
     return _cached2;
   } catch {
-    _cached2 = path15.basename(dir);
+    _cached2 = path16.basename(dir);
     _cachedCwd = dir;
     return _cached2;
   }
@@ -5252,7 +5883,7 @@ __export(tasks_exports, {
   updateTaskStatus: () => updateTaskStatus,
   writeCheckpoint: () => writeCheckpoint
 });
-import path16 from "path";
+import path17 from "path";
 import { writeFileSync as writeFileSync6, mkdirSync as mkdirSync6, unlinkSync as unlinkSync5 } from "fs";
 async function createTask(input) {
   const result = await createTaskCore(input);
@@ -5272,8 +5903,8 @@ async function updateTask(input) {
   const { row, taskFile, now, taskId } = await updateTaskStatus(input);
   try {
     const agent = String(row.assigned_to);
-    const cacheDir = path16.join(EXE_AI_DIR, "session-cache");
-    const cachePath = path16.join(cacheDir, `current-task-${agent}.json`);
+    const cacheDir = path17.join(EXE_AI_DIR, "session-cache");
+    const cachePath = path17.join(cacheDir, `current-task-${agent}.json`);
     if (input.status === "in_progress") {
       mkdirSync6(cacheDir, { recursive: true });
       writeFileSync6(cachePath, JSON.stringify({ taskId, title: String(row.title) }));
@@ -5744,12 +6375,12 @@ __export(tmux_routing_exports, {
 });
 import { execFileSync as execFileSync2, execSync as execSync7 } from "child_process";
 import { readFileSync as readFileSync11, writeFileSync as writeFileSync7, mkdirSync as mkdirSync7, existsSync as existsSync14, appendFileSync, readdirSync as readdirSync4 } from "fs";
-import path17 from "path";
-import os9 from "os";
+import path18 from "path";
+import os10 from "os";
 import { fileURLToPath as fileURLToPath2 } from "url";
 import { unlinkSync as unlinkSync6 } from "fs";
 function spawnLockPath(sessionName) {
-  return path17.join(SPAWN_LOCK_DIR, `${sessionName}.lock`);
+  return path18.join(SPAWN_LOCK_DIR, `${sessionName}.lock`);
 }
 function isProcessAlive(pid) {
   try {
@@ -5786,8 +6417,8 @@ function releaseSpawnLock2(sessionName) {
 function resolveBehaviorsExporterScript() {
   try {
     const thisFile = fileURLToPath2(import.meta.url);
-    const scriptPath = path17.join(
-      path17.dirname(thisFile),
+    const scriptPath = path18.join(
+      path18.dirname(thisFile),
       "..",
       "bin",
       "exe-export-behaviors.js"
@@ -5862,7 +6493,7 @@ function registerParentExe(sessionKey, parentExe, dispatchedBy) {
     mkdirSync7(SESSION_CACHE, { recursive: true });
   }
   const rootExe = extractRootExe(parentExe) ?? parentExe;
-  const filePath = path17.join(SESSION_CACHE, `parent-exe-${sessionKey}.json`);
+  const filePath = path18.join(SESSION_CACHE, `parent-exe-${sessionKey}.json`);
   writeFileSync7(filePath, JSON.stringify({
     parentExe: rootExe,
     dispatchedBy: dispatchedBy || rootExe,
@@ -5871,7 +6502,7 @@ function registerParentExe(sessionKey, parentExe, dispatchedBy) {
 }
 function getParentExe(sessionKey) {
   try {
-    const data = JSON.parse(readFileSync11(path17.join(SESSION_CACHE, `parent-exe-${sessionKey}.json`), "utf8"));
+    const data = JSON.parse(readFileSync11(path18.join(SESSION_CACHE, `parent-exe-${sessionKey}.json`), "utf8"));
     return data.parentExe || null;
   } catch {
     return null;
@@ -5880,7 +6511,7 @@ function getParentExe(sessionKey) {
 function getDispatchedBy(sessionKey) {
   try {
     const data = JSON.parse(readFileSync11(
-      path17.join(SESSION_CACHE, `parent-exe-${sessionKey}.json`),
+      path18.join(SESSION_CACHE, `parent-exe-${sessionKey}.json`),
       "utf8"
     ));
     return data.dispatchedBy ?? data.parentExe ?? null;
@@ -5891,15 +6522,24 @@ function getDispatchedBy(sessionKey) {
 function resolveExeSession() {
   const mySession = getMySession();
   if (!mySession) return null;
+  const fromSessionName = extractRootExe(mySession);
   try {
     const key = getSessionKey();
     const parentExe = getParentExe(key);
     if (parentExe) {
-      return extractRootExe(parentExe) ?? 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 extractRootExe(mySession) ?? mySession;
+  return fromSessionName ?? mySession;
 }
 function isEmployeeAlive(sessionName) {
   return getTransport().isAlive(sessionName);
@@ -6057,7 +6697,7 @@ function sendIntercom(targetSession) {
     try {
       const rawAgent = targetSession.split("-")[0] ?? targetSession;
       const agent = baseAgentName(rawAgent);
-      const markerPath = path17.join(SESSION_CACHE, `current-task-${agent}.json`);
+      const markerPath = path18.join(SESSION_CACHE, `current-task-${agent}.json`);
       if (existsSync14(markerPath)) {
         logIntercom(`SKIP \u2192 ${targetSession} (has in_progress task marker \u2014 will auto-chain)`);
         return "debounced";
@@ -6067,7 +6707,7 @@ function sendIntercom(targetSession) {
     try {
       const rawAgent = targetSession.split("-")[0] ?? targetSession;
       const agent = baseAgentName(rawAgent);
-      const taskDir = path17.join(process.cwd(), "exe", agent);
+      const taskDir = path18.join(process.cwd(), "exe", agent);
       if (existsSync14(taskDir)) {
         const files = readdirSync4(taskDir).filter(
           (f) => f.endsWith(".md") && f !== "DONE.txt"
@@ -6201,8 +6841,8 @@ 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 = path17.join(os9.homedir(), ".exe-os", "session-logs");
-  const logFile = path17.join(logDir, `${instanceLabel}-${Date.now()}.log`);
+  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 });
   }
@@ -6210,14 +6850,14 @@ function spawnEmployee(employeeName, exeSession, projectDir, opts) {
   let cleanupSuffix = "";
   try {
     const thisFile = fileURLToPath2(import.meta.url);
-    const cleanupScript = path17.join(path17.dirname(thisFile), "..", "bin", "exe-session-cleanup.js");
+    const cleanupScript = path18.join(path18.dirname(thisFile), "..", "bin", "exe-session-cleanup.js");
     if (existsSync14(cleanupScript)) {
       cleanupSuffix = `; ${process.execPath} "${cleanupScript}" "${employeeName}" "${exeSession}"`;
     }
   } catch {
   }
   try {
-    const claudeJsonPath = path17.join(os9.homedir(), ".claude.json");
+    const claudeJsonPath = path18.join(os10.homedir(), ".claude.json");
     let claudeJson = {};
     try {
       claudeJson = JSON.parse(readFileSync11(claudeJsonPath, "utf8"));
@@ -6232,10 +6872,10 @@ function spawnEmployee(employeeName, exeSession, projectDir, opts) {
   } catch {
   }
   try {
-    const settingsDir = path17.join(os9.homedir(), ".claude", "projects");
+    const settingsDir = path18.join(os10.homedir(), ".claude", "projects");
     const normalizedKey = (opts?.cwd ?? projectDir).replace(/\//g, "-").replace(/^-/, "");
-    const projSettingsDir = path17.join(settingsDir, normalizedKey);
-    const settingsPath = path17.join(projSettingsDir, "settings.json");
+    const projSettingsDir = path18.join(settingsDir, normalizedKey);
+    const settingsPath = path18.join(projSettingsDir, "settings.json");
     let settings = {};
     try {
       settings = JSON.parse(readFileSync11(settingsPath, "utf8"));
@@ -6282,8 +6922,8 @@ function spawnEmployee(employeeName, exeSession, projectDir, opts) {
   let behaviorsFlag = "";
   let legacyFallbackWarned = false;
   if (!useExeAgent && !useBinSymlink) {
-    const identityPath = path17.join(
-      os9.homedir(),
+    const identityPath = path18.join(
+      os10.homedir(),
       ".exe-os",
       "identity",
       `${employeeName}.md`
@@ -6298,7 +6938,7 @@ function spawnEmployee(employeeName, exeSession, projectDir, opts) {
     }
     const behaviorsFile = exportBehaviorsSync(
       employeeName,
-      path17.basename(spawnCwd),
+      path18.basename(spawnCwd),
       sessionName
     );
     if (behaviorsFile) {
@@ -6313,9 +6953,9 @@ function spawnEmployee(employeeName, exeSession, projectDir, opts) {
   }
   let sessionContextFlag = "";
   try {
-    const ctxDir = path17.join(os9.homedir(), ".exe-os", "session-cache");
+    const ctxDir = path18.join(os10.homedir(), ".exe-os", "session-cache");
     mkdirSync7(ctxDir, { recursive: true });
-    const ctxFile = path17.join(ctxDir, `session-context-${sessionName}.md`);
+    const ctxFile = path18.join(ctxDir, `session-context-${sessionName}.md`);
     const ctxContent = [
       `## Session Context`,
       `You are running in tmux session: ${sessionName}.`,
@@ -6399,7 +7039,7 @@ function spawnEmployee(employeeName, exeSession, projectDir, opts) {
   transport.pipeLog(sessionName, logFile);
   try {
     const mySession = getMySession();
-    const dispatchInfo = path17.join(SESSION_CACHE, `dispatch-info-${sessionName}.json`);
+    const dispatchInfo = path18.join(SESSION_CACHE, `dispatch-info-${sessionName}.json`);
     writeFileSync7(dispatchInfo, JSON.stringify({
       dispatchedBy: mySession,
       rootExe: exeSession,
@@ -6474,15 +7114,15 @@ var init_tmux_routing = __esm({
     init_intercom_queue();
     init_plan_limits();
     init_employees();
-    SPAWN_LOCK_DIR = path17.join(os9.homedir(), ".exe-os", "spawn-locks");
-    SESSION_CACHE = path17.join(os9.homedir(), ".exe-os", "session-cache");
+    SPAWN_LOCK_DIR = path18.join(os10.homedir(), ".exe-os", "spawn-locks");
+    SESSION_CACHE = path18.join(os10.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 = path17.join(os9.homedir(), ".exe-os", "intercom.log");
-    DEBOUNCE_FILE = path17.join(SESSION_CACHE, "intercom-debounce.json");
+    INTERCOM_LOG2 = path18.join(os10.homedir(), ".exe-os", "intercom.log");
+    DEBOUNCE_FILE = path18.join(SESSION_CACHE, "intercom-debounce.json");
     DEBOUNCE_CLEANUP_AGE_MS = 5 * 60 * 1e3;
     BUSY_PATTERN = /[✻✽✶✳·].*…|Running…|• Working|• Ran |• Explored|• Called|esc to interrupt/;
   }
@@ -6540,12 +7180,12 @@ __export(worker_gate_exports, {
   tryAcquireWorkerSlot: () => tryAcquireWorkerSlot
 });
 import { readdirSync as readdirSync6, writeFileSync as writeFileSync9, unlinkSync as unlinkSync8, mkdirSync as mkdirSync9, existsSync as existsSync15 } from "fs";
-import path19 from "path";
+import path20 from "path";
 function tryAcquireWorkerSlot() {
   try {
     mkdirSync9(WORKER_PID_DIR, { recursive: true });
     const reservationId = `res-${process.pid}-${Date.now()}`;
-    const reservationPath = path19.join(WORKER_PID_DIR, `${reservationId}.pid`);
+    const reservationPath = path20.join(WORKER_PID_DIR, `${reservationId}.pid`);
     writeFileSync9(reservationPath, String(process.pid));
     const files = readdirSync6(WORKER_PID_DIR);
     let alive = 0;
@@ -6563,7 +7203,7 @@ function tryAcquireWorkerSlot() {
         alive++;
       } catch {
         try {
-          unlinkSync8(path19.join(WORKER_PID_DIR, f));
+          unlinkSync8(path20.join(WORKER_PID_DIR, f));
         } catch {
         }
       }
@@ -6587,13 +7227,13 @@ function tryAcquireWorkerSlot() {
 function registerWorkerPid(pid) {
   try {
     mkdirSync9(WORKER_PID_DIR, { recursive: true });
-    writeFileSync9(path19.join(WORKER_PID_DIR, `worker-${pid}.pid`), String(pid));
+    writeFileSync9(path20.join(WORKER_PID_DIR, `worker-${pid}.pid`), String(pid));
   } catch {
   }
 }
 function cleanupWorkerPid() {
   try {
-    unlinkSync8(path19.join(WORKER_PID_DIR, `worker-${process.pid}.pid`));
+    unlinkSync8(path20.join(WORKER_PID_DIR, `worker-${process.pid}.pid`));
   } catch {
   }
 }
@@ -6633,9 +7273,9 @@ var init_worker_gate = __esm({
   "src/lib/worker-gate.ts"() {
     "use strict";
     init_config();
-    WORKER_PID_DIR = path19.join(EXE_AI_DIR, "worker-pids");
+    WORKER_PID_DIR = path20.join(EXE_AI_DIR, "worker-pids");
     MAX_CONCURRENT_WORKERS = 3;
-    BACKFILL_LOCK = path19.join(WORKER_PID_DIR, "backfill.lock");
+    BACKFILL_LOCK = path20.join(WORKER_PID_DIR, "backfill.lock");
   }
 });
 
@@ -6738,7 +7378,7 @@ __export(crdt_sync_exports, {
 });
 import * as Y from "yjs";
 import { readFileSync as readFileSync13, writeFileSync as writeFileSync10, existsSync as existsSync16, mkdirSync as mkdirSync10, unlinkSync as unlinkSync9 } from "fs";
-import path20 from "path";
+import path21 from "path";
 import { homedir } from "os";
 function getStatePath() {
   return _statePathOverride ?? DEFAULT_STATE_PATH;
@@ -6894,7 +7534,7 @@ function persistState() {
   if (!doc) return;
   try {
     const sp = getStatePath();
-    const dir = path20.dirname(sp);
+    const dir = path21.dirname(sp);
     if (!existsSync16(dir)) mkdirSync10(dir, { recursive: true });
     const state = Y.encodeStateAsUpdate(doc);
     writeFileSync10(sp, Buffer.from(state));
@@ -6938,7 +7578,7 @@ var DEFAULT_STATE_PATH, _statePathOverride, doc;
 var init_crdt_sync = __esm({
   "src/lib/crdt-sync.ts"() {
     "use strict";
-    DEFAULT_STATE_PATH = path20.join(homedir(), ".exe-os", "crdt-state.bin");
+    DEFAULT_STATE_PATH = path21.join(homedir(), ".exe-os", "crdt-state.bin");
     _statePathOverride = null;
     doc = null;
   }
@@ -6974,14 +7614,14 @@ __export(cloud_sync_exports, {
 });
 import { readFileSync as readFileSync14, writeFileSync as writeFileSync11, existsSync as existsSync17, readdirSync as readdirSync7, mkdirSync as mkdirSync11, appendFileSync as appendFileSync2, unlinkSync as unlinkSync10, openSync as openSync2, closeSync as closeSync2 } from "fs";
 import crypto7 from "crypto";
-import path21 from "path";
+import path22 from "path";
 import { homedir as homedir2 } from "os";
 function sqlSafe(v) {
   return v === void 0 ? null : v;
 }
 function logError(msg) {
   try {
-    const logPath = path21.join(homedir2(), ".exe-os", "workers.log");
+    const logPath = path22.join(homedir2(), ".exe-os", "workers.log");
     appendFileSync2(logPath, `${(/* @__PURE__ */ new Date()).toISOString()} ${msg}
 `);
   } catch {
@@ -7376,7 +8016,7 @@ async function cloudSync(config) {
   try {
     const employees = await loadEmployees();
     rosterResult.employees = employees.length;
-    const idDir = path21.join(EXE_AI_DIR, "identity");
+    const idDir = path22.join(EXE_AI_DIR, "identity");
     if (existsSync17(idDir)) {
       rosterResult.identities = readdirSync7(idDir).filter((f) => f.endsWith(".md")).length;
     }
@@ -7417,9 +8057,9 @@ function consumeRosterDeletions() {
   }
 }
 function buildRosterBlob(paths) {
-  const rosterPath = paths?.rosterPath ?? path21.join(EXE_AI_DIR, "exe-employees.json");
-  const identityDir = paths?.identityDir ?? path21.join(EXE_AI_DIR, "identity");
-  const configPath = paths?.configPath ?? path21.join(EXE_AI_DIR, "config.json");
+  const rosterPath = paths?.rosterPath ?? path22.join(EXE_AI_DIR, "exe-employees.json");
+  const identityDir = paths?.identityDir ?? path22.join(EXE_AI_DIR, "identity");
+  const configPath = paths?.configPath ?? path22.join(EXE_AI_DIR, "config.json");
   let roster = [];
   if (existsSync17(rosterPath)) {
     try {
@@ -7431,7 +8071,7 @@ function buildRosterBlob(paths) {
   if (existsSync17(identityDir)) {
     for (const file of readdirSync7(identityDir).filter((f) => f.endsWith(".md"))) {
       try {
-        identities[file] = readFileSync14(path21.join(identityDir, file), "utf-8");
+        identities[file] = readFileSync14(path22.join(identityDir, file), "utf-8");
       } catch {
       }
     }
@@ -7444,7 +8084,7 @@ function buildRosterBlob(paths) {
     }
   }
   let agentConfig;
-  const agentConfigPath = path21.join(EXE_AI_DIR, "agent-config.json");
+  const agentConfigPath = path22.join(EXE_AI_DIR, "agent-config.json");
   if (existsSync17(agentConfigPath)) {
     try {
       agentConfig = JSON.parse(readFileSync14(agentConfigPath, "utf-8"));
@@ -7523,7 +8163,7 @@ async function cloudPullRoster(config) {
   }
 }
 function mergeConfig(remoteConfig, configPath) {
-  const cfgPath = configPath ?? path21.join(EXE_AI_DIR, "config.json");
+  const cfgPath = configPath ?? path22.join(EXE_AI_DIR, "config.json");
   let local = {};
   if (existsSync17(cfgPath)) {
     try {
@@ -7532,14 +8172,14 @@ function mergeConfig(remoteConfig, configPath) {
     }
   }
   const merged = { ...remoteConfig, ...local };
-  const dir = path21.dirname(cfgPath);
+  const dir = path22.dirname(cfgPath);
   if (!existsSync17(dir)) mkdirSync11(dir, { recursive: true });
   writeFileSync11(cfgPath, JSON.stringify(merged, null, 2), "utf-8");
 }
 async function mergeRosterFromRemote(remote, paths) {
   return withRosterLock(async () => {
     const rosterPath = paths?.rosterPath ?? void 0;
-    const identityDir = paths?.identityDir ?? path21.join(EXE_AI_DIR, "identity");
+    const identityDir = paths?.identityDir ?? path22.join(EXE_AI_DIR, "identity");
     const localEmployees = await loadEmployees(rosterPath);
     const localNames = new Set(localEmployees.map((e) => e.name));
     let added = 0;
@@ -7561,7 +8201,7 @@ async function mergeRosterFromRemote(remote, paths) {
       const remoteIdentity = remote.identities[matchedKey];
       if (remoteIdentity) {
         if (!existsSync17(identityDir)) mkdirSync11(identityDir, { recursive: true });
-        const idPath = path21.join(identityDir, `${remoteEmp.name}.md`);
+        const idPath = path22.join(identityDir, `${remoteEmp.name}.md`);
         let localIdentity = null;
         try {
           localIdentity = existsSync17(idPath) ? readFileSync14(idPath, "utf-8") : null;
@@ -7594,7 +8234,7 @@ async function mergeRosterFromRemote(remote, paths) {
     }
     if (remote.agentConfig && Object.keys(remote.agentConfig).length > 0) {
       try {
-        const agentConfigPath = path21.join(EXE_AI_DIR, "agent-config.json");
+        const agentConfigPath = path22.join(EXE_AI_DIR, "agent-config.json");
         let local = {};
         if (existsSync17(agentConfigPath)) {
           try {
@@ -8041,9 +8681,9 @@ var init_cloud_sync = __esm({
     LOCALHOST_PATTERNS = /^(localhost|127\.0\.0\.1|\[::1\])$/i;
     FETCH_TIMEOUT_MS = 3e4;
     PUSH_BATCH_SIZE = 5e3;
-    ROSTER_LOCK_PATH = path21.join(EXE_AI_DIR, "roster-merge.lock");
+    ROSTER_LOCK_PATH = path22.join(EXE_AI_DIR, "roster-merge.lock");
     LOCK_STALE_MS = 3e4;
-    ROSTER_DELETIONS_PATH = path21.join(EXE_AI_DIR, "roster-deletions.json");
+    ROSTER_DELETIONS_PATH = path22.join(EXE_AI_DIR, "roster-deletions.json");
   }
 });
 
@@ -8225,10 +8865,10 @@ var init_schedules = __esm({
 
 // src/bin/exe-boot.ts
 init_employees();
-import path22 from "path";
+import path23 from "path";
 import { mkdir as mkdir5, writeFile as writeFile6 } from "fs/promises";
 import { existsSync as existsSync18, readFileSync as readFileSync15, readdirSync as readdirSync8, unlinkSync as unlinkSync11 } from "fs";
-import os10 from "os";
+import os11 from "os";
 
 // src/lib/employee-templates.ts
 init_global_procedures();
@@ -8732,11 +9372,11 @@ init_session_key();
 init_employees();
 import { readFileSync as readFileSync12, writeFileSync as writeFileSync8, mkdirSync as mkdirSync8, unlinkSync as unlinkSync7, readdirSync as readdirSync5 } from "fs";
 import { execSync as execSync8 } from "child_process";
-import path18 from "path";
-var CACHE_DIR = path18.join(EXE_AI_DIR, "session-cache");
+import path19 from "path";
+var CACHE_DIR = path19.join(EXE_AI_DIR, "session-cache");
 var STALE_MS = 24 * 60 * 60 * 1e3;
 function getMarkerPath() {
-  return path18.join(CACHE_DIR, `active-agent-${getSessionKey()}.json`);
+  return path19.join(CACHE_DIR, `active-agent-${getSessionKey()}.json`);
 }
 function writeActiveAgent(agentId, agentRole) {
   try {
@@ -8751,11 +9391,11 @@ function writeActiveAgent(agentId, agentRole) {
 function cleanupSessionMarkers() {
   const key = getSessionKey();
   try {
-    unlinkSync7(path18.join(CACHE_DIR, `active-agent-${key}.json`));
+    unlinkSync7(path19.join(CACHE_DIR, `active-agent-${key}.json`));
   } catch {
   }
   try {
-    unlinkSync7(path18.join(CACHE_DIR, "active-agent-undefined.json"));
+    unlinkSync7(path19.join(CACHE_DIR, "active-agent-undefined.json"));
   } catch {
   }
 }
@@ -8845,7 +9485,7 @@ async function boot(options) {
       const employeeDirs = entries.filter((e) => e.isDirectory() && !["output", "research"].includes(e.name));
       for (const dir of employeeDirs) {
         const employee = dir.name;
-        const taskDir = path22.join(exeDir, employee);
+        const taskDir = path23.join(exeDir, employee);
         let files;
         try {
           files = readdirSync9(taskDir).filter((f) => f.endsWith(".md"));
@@ -8856,7 +9496,7 @@ async function boot(options) {
           const taskFilePath = `exe/${employee}/${file}`;
           let content;
           try {
-            content = readFs(path22.join(taskDir, file), "utf8");
+            content = readFs(path23.join(taskDir, file), "utf8");
           } catch {
             continue;
           }
@@ -8942,12 +9582,12 @@ async function boot(options) {
     }
     try {
       for (const reviewDirName of /* @__PURE__ */ new Set(["exe", coordinatorName])) {
-        const reviewDir = path22.join(process.cwd(), "exe", reviewDirName);
+        const reviewDir = path23.join(process.cwd(), "exe", reviewDirName);
         if (existsSync18(reviewDir)) {
           for (const f of readdirSync8(reviewDir)) {
             if (f.startsWith("review-") && f.endsWith(".md")) {
               try {
-                unlinkSync11(path22.join(reviewDir, f));
+                unlinkSync11(path23.join(reviewDir, f));
               } catch {
               }
             }
@@ -8993,7 +9633,7 @@ async function boot(options) {
           });
           const taskFile = String(r.task_file);
           try {
-            const filePath = path22.join(process.cwd(), taskFile);
+            const filePath = path23.join(process.cwd(), taskFile);
             if (existsSync18(filePath)) {
               let content = readFileSync15(filePath, "utf8");
               content = content.replace(/\*\*Status:\*\* needs_review/, "**Status:** done");
@@ -9492,8 +10132,8 @@ async function boot(options) {
     })()
   ]);
   try {
-    const configPath = path22.join(
-      process.env.EXE_OS_DIR ?? process.env.EXE_MEM_DIR ?? path22.join(os10.homedir(), ".exe-os"),
+    const configPath = path23.join(
+      process.env.EXE_OS_DIR ?? process.env.EXE_MEM_DIR ?? path23.join(os11.homedir(), ".exe-os"),
       "config.json"
     );
     if (existsSync18(configPath)) {
@@ -9503,7 +10143,7 @@ async function boot(options) {
   } catch {
   }
   try {
-    const backfillFlagPath = path22.join(EXE_AI_DIR, "session-cache", "needs-backfill");
+    const backfillFlagPath = path23.join(EXE_AI_DIR, "session-cache", "needs-backfill");
     const isBackfillNeeded = () => existsSync18(backfillFlagPath);
     const coverageResult = await client.execute({
       sql: `SELECT COUNT(*) as total,
@@ -9526,7 +10166,7 @@ async function boot(options) {
     let daemonRunning = false;
     let daemonUptime;
     let daemonRequestsServed;
-    const socketPath = path22.join(EXE_AI_DIR, "exed.sock");
+    const socketPath = path23.join(EXE_AI_DIR, "exed.sock");
     if (existsSync18(socketPath)) {
       try {
         const net2 = await import("net");
@@ -9569,7 +10209,7 @@ async function boot(options) {
       }
     }
     if (!daemonRunning) {
-      const pidPath = path22.join(EXE_AI_DIR, "exed.pid");
+      const pidPath = path23.join(EXE_AI_DIR, "exed.pid");
       if (existsSync18(pidPath)) {
         try {
           const pid = parseInt(readFileSync15(pidPath, "utf8").trim(), 10);
@@ -9583,7 +10223,7 @@ async function boot(options) {
     }
     if (nullCount === 0) {
       try {
-        const flagPath = path22.join(EXE_AI_DIR, "session-cache", "needs-backfill");
+        const flagPath = path23.join(EXE_AI_DIR, "session-cache", "needs-backfill");
         if (existsSync18(flagPath)) {
           const { unlinkSync: unlinkSync12 } = await import("fs");
           unlinkSync12(flagPath);
@@ -9610,10 +10250,10 @@ async function boot(options) {
           const { spawn: spawn2 } = await import("child_process");
           const { fileURLToPath: fileURLToPath4 } = await import("url");
           const thisFile = fileURLToPath4(import.meta.url);
-          const backfillPath = path22.resolve(path22.dirname(thisFile), "backfill-vectors.js");
+          const backfillPath = path23.resolve(path23.dirname(thisFile), "backfill-vectors.js");
           if (existsSync18(backfillPath)) {
             const { openSync: openSync3, closeSync: closeSync3 } = await import("fs");
-            const workerLogPath = path22.join(EXE_AI_DIR, "workers.log");
+            const workerLogPath = path23.join(EXE_AI_DIR, "workers.log");
             let stderrFd = "ignore";
             try {
               stderrFd = openSync3(workerLogPath, "a");
@@ -9643,7 +10283,7 @@ async function boot(options) {
     const criticalBinaries = ["backfill-vectors.js", "scan-tasks.js"];
     const missing = [];
     for (const bin of criticalBinaries) {
-      const binPath = path22.resolve(path22.dirname(thisFile), bin);
+      const binPath = path23.resolve(path23.dirname(thisFile), bin);
       if (!existsSync18(binPath)) {
         missing.push(`dist/bin/${bin}`);
       }
@@ -9673,7 +10313,7 @@ async function boot(options) {
     console.log(brief);
     return;
   }
-  const sessionDir = path22.join(EXE_AI_DIR, "sessions", coordinatorName);
+  const sessionDir = path23.join(EXE_AI_DIR, "sessions", coordinatorName);
   await mkdir5(sessionDir, { recursive: true });
   const claudeMdContent = `${getSessionPrompt(coordinatorEmployee.systemPrompt)}
 
@@ -9682,7 +10322,7 @@ async function boot(options) {
 # Status Brief
 
 ${brief}`;
-  await writeFile6(path22.join(sessionDir, "CLAUDE.md"), claudeMdContent, "utf-8");
+  await writeFile6(path23.join(sessionDir, "CLAUDE.md"), claudeMdContent, "utf-8");
   const unread = await readUnreadNotifications();
   if (unread.length > 0) {
     console.log(`\u{1F4EC} ${unread.length} unread notification${unread.length === 1 ? "" : "s"}`);
@@ -9691,8 +10331,8 @@ ${brief}`;
   await cleanupOldNotifications();
   console.log(brief);
   try {
-    const configPath2 = path22.join(
-      process.env.EXE_OS_DIR ?? process.env.EXE_MEM_DIR ?? path22.join(os10.homedir(), ".exe-os"),
+    const configPath2 = path23.join(
+      process.env.EXE_OS_DIR ?? process.env.EXE_MEM_DIR ?? path23.join(os11.homedir(), ".exe-os"),
       "config.json"
     );
     if (existsSync18(configPath2)) {