@askexenow/exe-os 0.8.80 → 0.8.82

package/dist/bin/exe-launch-agent.js

@@ -54,7 +54,7 @@ function wrapWithRetry(client) {
         return (sql) => retryOnBusy(() => target.execute(sql), "execute");
       }
       if (prop === "batch") {
-        return (stmts) => retryOnBusy(() => target.batch(stmts), "batch");
+        return (stmts, mode) => retryOnBusy(() => target.batch(stmts, mode), "batch");
       }
       return Reflect.get(target, prop, receiver);
     }
@@ -70,6 +70,387 @@ var init_db_retry = __esm({
   }
 });
 
+// src/lib/config.ts
+import { readFile, writeFile, mkdir, chmod } from "fs/promises";
+import { readFileSync, existsSync, renameSync } from "fs";
+import path from "path";
+import os from "os";
+function resolveDataDir() {
+  if (process.env.EXE_OS_DIR) return process.env.EXE_OS_DIR;
+  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)) {
+    try {
+      renameSync(legacyDir, newDir);
+      process.stderr.write(`[exe-os] Migrated data directory: ~/.exe-mem \u2192 ~/.exe-os
+`);
+    } catch {
+      return legacyDir;
+    }
+  }
+  return newDir;
+}
+function migrateLegacyConfig(raw) {
+  if ("r2" in raw) {
+    process.stderr.write(
+      "[exe-os] Warning: config.json contains deprecated 'r2' field from v1.0. R2 sync has been replaced in v1.1. The 'r2' field will be ignored.\n"
+    );
+    delete raw.r2;
+  }
+  if ("syncIntervalMs" in raw) {
+    delete raw.syncIntervalMs;
+  }
+  return raw;
+}
+function migrateConfig(raw) {
+  const fromVersion = typeof raw.config_version === "number" ? raw.config_version : 0;
+  let currentVersion = fromVersion;
+  let migrated = false;
+  if (currentVersion > CURRENT_CONFIG_VERSION) {
+    return { config: raw, migrated: false, fromVersion };
+  }
+  for (const migration of CONFIG_MIGRATIONS) {
+    if (currentVersion === migration.from && migration.to <= CURRENT_CONFIG_VERSION) {
+      raw = migration.migrate(raw);
+      currentVersion = migration.to;
+      migrated = true;
+    }
+  }
+  return { config: raw, migrated, fromVersion };
+}
+function normalizeScalingRoadmap(raw) {
+  const defaultAuto = DEFAULT_CONFIG.scalingRoadmap.rerankerAutoTrigger;
+  const userRoadmap = raw.scalingRoadmap ?? {};
+  const userAuto = userRoadmap.rerankerAutoTrigger ?? {};
+  if (userAuto.enabled === void 0 && raw.rerankerEnabled !== void 0) {
+    userAuto.enabled = raw.rerankerEnabled;
+  }
+  raw.scalingRoadmap = {
+    ...userRoadmap,
+    rerankerAutoTrigger: { ...defaultAuto, ...userAuto }
+  };
+}
+function normalizeSessionLifecycle(raw) {
+  const defaultSL = DEFAULT_CONFIG.sessionLifecycle;
+  const userSL = raw.sessionLifecycle ?? {};
+  raw.sessionLifecycle = { ...defaultSL, ...userSL };
+}
+function normalizeAutoUpdate(raw) {
+  const defaultAU = DEFAULT_CONFIG.autoUpdate;
+  const userAU = raw.autoUpdate ?? {};
+  raw.autoUpdate = { ...defaultAU, ...userAU };
+}
+async function loadConfig() {
+  const dir = process.env.EXE_OS_DIR ?? process.env.EXE_MEM_DIR ?? EXE_AI_DIR;
+  await mkdir(dir, { recursive: true });
+  const configPath = path.join(dir, "config.json");
+  if (!existsSync(configPath)) {
+    return { ...DEFAULT_CONFIG, dbPath: path.join(dir, "memories.db") };
+  }
+  const raw = await readFile(configPath, "utf-8");
+  try {
+    let parsed = JSON.parse(raw);
+    parsed = migrateLegacyConfig(parsed);
+    const { config: migratedCfg, migrated, fromVersion } = migrateConfig(parsed);
+    if (migrated) {
+      process.stderr.write(`[exe-os] Config migrated from v${fromVersion} to v${migratedCfg.config_version}
+`);
+      try {
+        await writeFile(configPath, JSON.stringify(migratedCfg, null, 2) + "\n");
+      } catch {
+      }
+    }
+    normalizeScalingRoadmap(migratedCfg);
+    normalizeSessionLifecycle(migratedCfg);
+    normalizeAutoUpdate(migratedCfg);
+    const config = { ...DEFAULT_CONFIG, dbPath: path.join(dir, "memories.db"), ...migratedCfg };
+    if (config.dbPath.startsWith("~")) {
+      config.dbPath = config.dbPath.replace(/^~/, os.homedir());
+    }
+    return config;
+  } catch {
+    return { ...DEFAULT_CONFIG, dbPath: path.join(dir, "memories.db") };
+  }
+}
+var EXE_AI_DIR, DB_PATH, MODELS_DIR, CONFIG_PATH, LEGACY_LANCE_PATH, CURRENT_CONFIG_VERSION, DEFAULT_CONFIG, CONFIG_MIGRATIONS;
+var init_config = __esm({
+  "src/lib/config.ts"() {
+    "use strict";
+    EXE_AI_DIR = resolveDataDir();
+    DB_PATH = path.join(EXE_AI_DIR, "memories.db");
+    MODELS_DIR = path.join(EXE_AI_DIR, "models");
+    CONFIG_PATH = path.join(EXE_AI_DIR, "config.json");
+    LEGACY_LANCE_PATH = path.join(EXE_AI_DIR, "local.lance");
+    CURRENT_CONFIG_VERSION = 1;
+    DEFAULT_CONFIG = {
+      config_version: CURRENT_CONFIG_VERSION,
+      dbPath: DB_PATH,
+      modelFile: "jina-embeddings-v5-small-q4_k_m.gguf",
+      embeddingDim: 1024,
+      batchSize: 20,
+      flushIntervalMs: 1e4,
+      autoIngestion: true,
+      autoRetrieval: true,
+      searchMode: "hybrid",
+      hookSearchMode: "hybrid",
+      fileGrepEnabled: true,
+      splashEffect: true,
+      consolidationEnabled: true,
+      consolidationIntervalMs: 6 * 60 * 60 * 1e3,
+      consolidationModel: "claude-haiku-4-5-20251001",
+      consolidationMaxCallsPerRun: 20,
+      selfQueryRouter: true,
+      selfQueryModel: "claude-haiku-4-5-20251001",
+      rerankerEnabled: true,
+      scalingRoadmap: {
+        rerankerAutoTrigger: {
+          enabled: true,
+          broadQueryMinCardinality: 5e4,
+          fetchTopK: 150,
+          returnTopK: 5
+        }
+      },
+      graphRagEnabled: true,
+      wikiEnabled: false,
+      wikiUrl: "",
+      wikiApiKey: "",
+      wikiSyncIntervalMs: 30 * 60 * 1e3,
+      wikiWorkspaceMapping: {},
+      wikiAutoUpdate: true,
+      wikiAutoUpdateThreshold: 0.5,
+      wikiAutoUpdateCreateNew: true,
+      skillLearning: true,
+      skillThreshold: 3,
+      skillModel: "claude-haiku-4-5-20251001",
+      exeHeartbeat: {
+        enabled: true,
+        intervalSeconds: 60,
+        staleInProgressThresholdHours: 2
+      },
+      sessionLifecycle: {
+        idleKillEnabled: true,
+        idleKillTicksRequired: 3,
+        idleKillIntercomAckWindowMs: 1e4,
+        maxAutoInstances: 10
+      },
+      autoUpdate: {
+        checkOnBoot: true,
+        autoInstall: false,
+        checkIntervalMs: 24 * 60 * 60 * 1e3
+      }
+    };
+    CONFIG_MIGRATIONS = [
+      {
+        from: 0,
+        to: 1,
+        migrate: (cfg) => {
+          cfg.config_version = 1;
+          return cfg;
+        }
+      }
+    ];
+  }
+});
+
+// src/lib/employees.ts
+var employees_exports = {};
+__export(employees_exports, {
+  COORDINATOR_ROLE: () => COORDINATOR_ROLE,
+  DEFAULT_COORDINATOR_TEMPLATE_NAME: () => DEFAULT_COORDINATOR_TEMPLATE_NAME,
+  EMPLOYEES_PATH: () => EMPLOYEES_PATH,
+  addEmployee: () => addEmployee,
+  canCoordinate: () => canCoordinate,
+  getCoordinatorEmployee: () => getCoordinatorEmployee,
+  getCoordinatorName: () => getCoordinatorName,
+  getEmployee: () => getEmployee,
+  getEmployeeByRole: () => getEmployeeByRole,
+  getEmployeeNamesByRole: () => getEmployeeNamesByRole,
+  hasRole: () => hasRole,
+  isCoordinatorName: () => isCoordinatorName,
+  isCoordinatorRole: () => isCoordinatorRole,
+  isMultiInstance: () => isMultiInstance,
+  loadEmployees: () => loadEmployees,
+  loadEmployeesSync: () => loadEmployeesSync,
+  normalizeRole: () => normalizeRole,
+  normalizeRosterCase: () => normalizeRosterCase,
+  registerBinSymlinks: () => registerBinSymlinks,
+  saveEmployees: () => saveEmployees,
+  validateEmployeeName: () => validateEmployeeName
+});
+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 { execSync } from "child_process";
+import path2 from "path";
+import os2 from "os";
+function normalizeRole(role) {
+  return (role ?? "").trim().toLowerCase();
+}
+function isCoordinatorRole(role) {
+  return normalizeRole(role) === normalizeRole(COORDINATOR_ROLE);
+}
+function getCoordinatorEmployee(employees) {
+  return employees.find((e) => isCoordinatorRole(e.role));
+}
+function getCoordinatorName(employees = loadEmployeesSync()) {
+  return getCoordinatorEmployee(employees)?.name ?? DEFAULT_COORDINATOR_TEMPLATE_NAME;
+}
+function isCoordinatorName(agentName, employees = loadEmployeesSync()) {
+  if (!agentName) return false;
+  return agentName.toLowerCase() === getCoordinatorName(employees).toLowerCase();
+}
+function canCoordinate(agentName, agentRole, employees = loadEmployeesSync()) {
+  return agentName === "default" || isCoordinatorRole(agentRole) || isCoordinatorName(agentName, employees);
+}
+function validateEmployeeName(name) {
+  if (!name) {
+    return { valid: false, error: "Name is required" };
+  }
+  if (name.length > 32) {
+    return { valid: false, error: "Name must be 32 characters or fewer" };
+  }
+  if (!/^[a-z][a-z0-9]*$/.test(name)) {
+    return {
+      valid: false,
+      error: "Name must start with a letter and contain only lowercase alphanumeric characters"
+    };
+  }
+  return { valid: true };
+}
+async function loadEmployees(employeesPath = EMPLOYEES_PATH) {
+  if (!existsSync2(employeesPath)) {
+    return [];
+  }
+  const raw = await readFile2(employeesPath, "utf-8");
+  try {
+    return JSON.parse(raw);
+  } catch {
+    return [];
+  }
+}
+async function saveEmployees(employees, employeesPath = EMPLOYEES_PATH) {
+  await mkdir2(path2.dirname(employeesPath), { recursive: true });
+  await writeFile2(employeesPath, JSON.stringify(employees, null, 2) + "\n", "utf-8");
+}
+function loadEmployeesSync(employeesPath = EMPLOYEES_PATH) {
+  if (!existsSync2(employeesPath)) return [];
+  try {
+    return JSON.parse(readFileSync2(employeesPath, "utf-8"));
+  } catch {
+    return [];
+  }
+}
+function getEmployee(employees, name) {
+  return employees.find((e) => e.name.toLowerCase() === name.toLowerCase());
+}
+function getEmployeeByRole(employees, role) {
+  const lower = role.toLowerCase();
+  return employees.find((e) => e.role.toLowerCase() === lower);
+}
+function getEmployeeNamesByRole(employees, role) {
+  const lower = role.toLowerCase();
+  return employees.filter((e) => e.role.toLowerCase() === lower).map((e) => e.name);
+}
+function hasRole(agentName, role) {
+  const employees = loadEmployeesSync();
+  const emp = getEmployee(employees, agentName);
+  return emp ? emp.role.toLowerCase() === role.toLowerCase() : false;
+}
+function isMultiInstance(agentName, employees) {
+  const roster = employees ?? loadEmployeesSync();
+  const emp = getEmployee(roster, agentName);
+  if (!emp) return false;
+  return MULTI_INSTANCE_ROLES.has(emp.role.toLowerCase());
+}
+function addEmployee(employees, employee) {
+  const normalized = { ...employee, name: employee.name.toLowerCase() };
+  if (employees.some((e) => e.name.toLowerCase() === normalized.name)) {
+    throw new Error(`Employee '${normalized.name}' already exists`);
+  }
+  return [...employees, normalized];
+}
+async function normalizeRosterCase(rosterPath) {
+  const employees = await loadEmployees(rosterPath);
+  let changed = false;
+  for (const emp of employees) {
+    if (emp.name !== emp.name.toLowerCase()) {
+      const oldName = emp.name;
+      emp.name = emp.name.toLowerCase();
+      changed = true;
+      try {
+        const identityDir = path2.join(os2.homedir(), ".exe-os", "identity");
+        const oldPath = path2.join(identityDir, `${oldName}.md`);
+        const newPath = path2.join(identityDir, `${emp.name}.md`);
+        if (existsSync2(oldPath) && !existsSync2(newPath)) {
+          renameSync2(oldPath, newPath);
+        } else if (existsSync2(oldPath) && oldPath !== newPath) {
+          const content = readFileSync2(oldPath, "utf-8");
+          writeFileSync(newPath, content, "utf-8");
+          if (oldPath.toLowerCase() !== newPath.toLowerCase()) {
+            unlinkSync(oldPath);
+          }
+        }
+      } catch {
+      }
+    }
+  }
+  if (changed) {
+    await saveEmployees(employees, rosterPath);
+  }
+  return changed;
+}
+function findExeBin() {
+  try {
+    return execSync(process.platform === "win32" ? "where exe-os" : "which exe-os", { encoding: "utf8" }).trim();
+  } catch {
+    return null;
+  }
+}
+function registerBinSymlinks(name) {
+  const created = [];
+  const skipped = [];
+  const errors = [];
+  const exeBinPath = findExeBin();
+  if (!exeBinPath) {
+    errors.push("Could not find 'exe-os' in PATH");
+    return { created, skipped, errors };
+  }
+  const binDir = path2.dirname(exeBinPath);
+  let target;
+  try {
+    target = readlinkSync(exeBinPath);
+  } catch {
+    errors.push("Could not read 'exe' symlink");
+    return { created, skipped, errors };
+  }
+  for (const suffix of ["", "-opencode"]) {
+    const linkName = `${name}${suffix}`;
+    const linkPath = path2.join(binDir, linkName);
+    if (existsSync2(linkPath)) {
+      skipped.push(linkName);
+      continue;
+    }
+    try {
+      symlinkSync(target, linkPath);
+      created.push(linkName);
+    } catch (err) {
+      errors.push(`${linkName}: ${err instanceof Error ? err.message : String(err)}`);
+    }
+  }
+  return { created, skipped, errors };
+}
+var EMPLOYEES_PATH, DEFAULT_COORDINATOR_TEMPLATE_NAME, COORDINATOR_ROLE, MULTI_INSTANCE_ROLES;
+var init_employees = __esm({
+  "src/lib/employees.ts"() {
+    "use strict";
+    init_config();
+    EMPLOYEES_PATH = path2.join(EXE_AI_DIR, "exe-employees.json");
+    DEFAULT_COORDINATOR_TEMPLATE_NAME = "exe";
+    COORDINATOR_ROLE = "COO";
+    MULTI_INSTANCE_ROLES = /* @__PURE__ */ new Set(["principal engineer", "content production specialist", "staff code reviewer"]);
+  }
+});
+
 // src/lib/database.ts
 import { createClient } from "@libsql/client";
 async function initDatabase(config) {
@@ -203,22 +584,24 @@ async function ensureSchema() {
       ON behaviors(agent_id, active);
   `);
   try {
+    const coordinatorName = getCoordinatorName();
     const existing = await client.execute({
-      sql: "SELECT COUNT(*) as cnt FROM behaviors WHERE agent_id = 'exe'",
-      args: []
+      sql: "SELECT COUNT(*) as cnt FROM behaviors WHERE agent_id = ?",
+      args: [coordinatorName]
     });
     if (Number(existing.rows[0]?.cnt) === 0) {
-      await client.executeMultiple(`
-        INSERT INTO behaviors (id, agent_id, project_name, domain, content, active, created_at, updated_at)
-        VALUES
-          (hex(randomblob(16)), 'exe', NULL, 'workflow', 'Don''t ask "keep going?" \u2014 just keep executing phases/plans autonomously', 1, '2026-03-25T00:00:00Z', '2026-03-25T00:00:00Z');
-        INSERT INTO behaviors (id, agent_id, project_name, domain, content, active, created_at, updated_at)
-        VALUES
-          (hex(randomblob(16)), 'exe', NULL, 'tool-use', 'Always use create_task MCP tool, never write .md files directly for task creation', 1, '2026-03-25T00:00:00Z', '2026-03-25T00:00:00Z');
-        INSERT INTO behaviors (id, agent_id, project_name, domain, content, active, created_at, updated_at)
-        VALUES
-          (hex(randomblob(16)), 'exe', NULL, 'workflow', 'Auto-start reviewing when idle and reviews are pending \u2014 never ask founder for permission', 1, '2026-03-25T00:00:00Z', '2026-03-25T00:00:00Z');
-      `);
+      const seededAt = "2026-03-25T00:00:00Z";
+      for (const [domain, content] of [
+        ["workflow", `Don't ask "keep going?" \u2014 just keep executing phases/plans autonomously`],
+        ["tool-use", "Always use create_task MCP tool, never write .md files directly for task creation"],
+        ["workflow", "Auto-start reviewing when idle and reviews are pending \u2014 never ask founder for permission"]
+      ]) {
+        await client.execute({
+          sql: `INSERT INTO behaviors (id, agent_id, project_name, domain, content, active, created_at, updated_at)
+                VALUES (hex(randomblob(16)), ?, NULL, ?, ?, 1, ?, ?)`,
+          args: [coordinatorName, domain, content, seededAt, seededAt]
+        });
+      }
     }
   } catch {
   }
@@ -910,212 +1293,57 @@ async function ensureSchema() {
     } catch {
     }
   }
-}
-async function disposeDatabase() {
-  if (_client) {
-    _client.close();
-    _client = null;
-    _resilientClient = null;
-  }
-}
-var _client, _resilientClient, initTurso, disposeTurso;
-var init_database = __esm({
-  "src/lib/database.ts"() {
-    "use strict";
-    init_db_retry();
-    _client = null;
-    _resilientClient = null;
-    initTurso = initDatabase;
-    disposeTurso = disposeDatabase;
-  }
-});
-
-// src/lib/config.ts
-import { readFile as readFile2, writeFile as writeFile2, mkdir as mkdir2, chmod as chmod2 } from "fs/promises";
-import { readFileSync, existsSync as existsSync2, renameSync } from "fs";
-import path2 from "path";
-import os2 from "os";
-function resolveDataDir() {
-  if (process.env.EXE_OS_DIR) return process.env.EXE_OS_DIR;
-  if (process.env.EXE_MEM_DIR) return process.env.EXE_MEM_DIR;
-  const newDir = path2.join(os2.homedir(), ".exe-os");
-  const legacyDir = path2.join(os2.homedir(), ".exe-mem");
-  if (!existsSync2(newDir) && existsSync2(legacyDir)) {
-    try {
-      renameSync(legacyDir, newDir);
-      process.stderr.write(`[exe-os] Migrated data directory: ~/.exe-mem \u2192 ~/.exe-os
-`);
-    } catch {
-      return legacyDir;
-    }
+  try {
+    await client.execute({
+      sql: `ALTER TABLE memories ADD COLUMN draft INTEGER DEFAULT 0`,
+      args: []
+    });
+  } catch {
   }
-  return newDir;
-}
-function migrateLegacyConfig(raw) {
-  if ("r2" in raw) {
-    process.stderr.write(
-      "[exe-os] Warning: config.json contains deprecated 'r2' field from v1.0. R2 sync has been replaced in v1.1. The 'r2' field will be ignored.\n"
+  try {
+    await client.execute(
+      `CREATE INDEX IF NOT EXISTS idx_memories_draft ON memories(draft) WHERE draft = 1`
     );
-    delete raw.r2;
-  }
-  if ("syncIntervalMs" in raw) {
-    delete raw.syncIntervalMs;
-  }
-  return raw;
-}
-function migrateConfig(raw) {
-  const fromVersion = typeof raw.config_version === "number" ? raw.config_version : 0;
-  let currentVersion = fromVersion;
-  let migrated = false;
-  if (currentVersion > CURRENT_CONFIG_VERSION) {
-    return { config: raw, migrated: false, fromVersion };
-  }
-  for (const migration of CONFIG_MIGRATIONS) {
-    if (currentVersion === migration.from && migration.to <= CURRENT_CONFIG_VERSION) {
-      raw = migration.migrate(raw);
-      currentVersion = migration.to;
-      migrated = true;
-    }
+  } catch {
   }
-  return { config: raw, migrated, fromVersion };
-}
-function normalizeScalingRoadmap(raw) {
-  const defaultAuto = DEFAULT_CONFIG.scalingRoadmap.rerankerAutoTrigger;
-  const userRoadmap = raw.scalingRoadmap ?? {};
-  const userAuto = userRoadmap.rerankerAutoTrigger ?? {};
-  if (userAuto.enabled === void 0 && raw.rerankerEnabled !== void 0) {
-    userAuto.enabled = raw.rerankerEnabled;
+  try {
+    await client.execute({
+      sql: `ALTER TABLE memories ADD COLUMN memory_type TEXT DEFAULT 'raw'`,
+      args: []
+    });
+  } catch {
   }
-  raw.scalingRoadmap = {
-    ...userRoadmap,
-    rerankerAutoTrigger: { ...defaultAuto, ...userAuto }
-  };
-}
-function normalizeSessionLifecycle(raw) {
-  const defaultSL = DEFAULT_CONFIG.sessionLifecycle;
-  const userSL = raw.sessionLifecycle ?? {};
-  raw.sessionLifecycle = { ...defaultSL, ...userSL };
-}
-function normalizeAutoUpdate(raw) {
-  const defaultAU = DEFAULT_CONFIG.autoUpdate;
-  const userAU = raw.autoUpdate ?? {};
-  raw.autoUpdate = { ...defaultAU, ...userAU };
-}
-async function loadConfig() {
-  const dir = process.env.EXE_OS_DIR ?? process.env.EXE_MEM_DIR ?? EXE_AI_DIR;
-  await mkdir2(dir, { recursive: true });
-  const configPath = path2.join(dir, "config.json");
-  if (!existsSync2(configPath)) {
-    return { ...DEFAULT_CONFIG, dbPath: path2.join(dir, "memories.db") };
+  try {
+    await client.execute(
+      `CREATE INDEX IF NOT EXISTS idx_memories_type ON memories(memory_type)`
+    );
+  } catch {
   }
-  const raw = await readFile2(configPath, "utf-8");
   try {
-    let parsed = JSON.parse(raw);
-    parsed = migrateLegacyConfig(parsed);
-    const { config: migratedCfg, migrated, fromVersion } = migrateConfig(parsed);
-    if (migrated) {
-      process.stderr.write(`[exe-os] Config migrated from v${fromVersion} to v${migratedCfg.config_version}
-`);
-      try {
-        await writeFile2(configPath, JSON.stringify(migratedCfg, null, 2) + "\n");
-      } catch {
-      }
-    }
-    normalizeScalingRoadmap(migratedCfg);
-    normalizeSessionLifecycle(migratedCfg);
-    normalizeAutoUpdate(migratedCfg);
-    const config = { ...DEFAULT_CONFIG, dbPath: path2.join(dir, "memories.db"), ...migratedCfg };
-    if (config.dbPath.startsWith("~")) {
-      config.dbPath = config.dbPath.replace(/^~/, os2.homedir());
-    }
-    return config;
+    await client.execute({
+      sql: `ALTER TABLE memories ADD COLUMN trajectory TEXT`,
+      args: []
+    });
   } catch {
-    return { ...DEFAULT_CONFIG, dbPath: path2.join(dir, "memories.db") };
   }
 }
-var EXE_AI_DIR, DB_PATH, MODELS_DIR, CONFIG_PATH, LEGACY_LANCE_PATH, CURRENT_CONFIG_VERSION, DEFAULT_CONFIG, CONFIG_MIGRATIONS;
-var init_config = __esm({
-  "src/lib/config.ts"() {
+async function disposeDatabase() {
+  if (_client) {
+    _client.close();
+    _client = null;
+    _resilientClient = null;
+  }
+}
+var _client, _resilientClient, initTurso, disposeTurso;
+var init_database = __esm({
+  "src/lib/database.ts"() {
     "use strict";
-    EXE_AI_DIR = resolveDataDir();
-    DB_PATH = path2.join(EXE_AI_DIR, "memories.db");
-    MODELS_DIR = path2.join(EXE_AI_DIR, "models");
-    CONFIG_PATH = path2.join(EXE_AI_DIR, "config.json");
-    LEGACY_LANCE_PATH = path2.join(EXE_AI_DIR, "local.lance");
-    CURRENT_CONFIG_VERSION = 1;
-    DEFAULT_CONFIG = {
-      config_version: CURRENT_CONFIG_VERSION,
-      dbPath: DB_PATH,
-      modelFile: "jina-embeddings-v5-small-q4_k_m.gguf",
-      embeddingDim: 1024,
-      batchSize: 20,
-      flushIntervalMs: 1e4,
-      autoIngestion: true,
-      autoRetrieval: true,
-      searchMode: "hybrid",
-      hookSearchMode: "hybrid",
-      fileGrepEnabled: true,
-      splashEffect: true,
-      consolidationEnabled: true,
-      consolidationIntervalMs: 6 * 60 * 60 * 1e3,
-      consolidationModel: "claude-haiku-4-5-20251001",
-      consolidationMaxCallsPerRun: 20,
-      selfQueryRouter: true,
-      selfQueryModel: "claude-haiku-4-5-20251001",
-      rerankerEnabled: true,
-      scalingRoadmap: {
-        rerankerAutoTrigger: {
-          enabled: true,
-          broadQueryMinCardinality: 5e4,
-          fetchTopK: 150,
-          returnTopK: 5
-        }
-      },
-      graphRagEnabled: true,
-      wikiEnabled: false,
-      wikiUrl: "",
-      wikiApiKey: "",
-      wikiSyncIntervalMs: 30 * 60 * 1e3,
-      wikiWorkspaceMapping: {
-        exe: "Executive",
-        yoshi: "Engineering",
-        mari: "Marketing",
-        tom: "Engineering",
-        sasha: "Production"
-      },
-      wikiAutoUpdate: true,
-      wikiAutoUpdateThreshold: 0.5,
-      wikiAutoUpdateCreateNew: true,
-      skillLearning: true,
-      skillThreshold: 3,
-      skillModel: "claude-haiku-4-5-20251001",
-      exeHeartbeat: {
-        enabled: true,
-        intervalSeconds: 60,
-        staleInProgressThresholdHours: 2
-      },
-      sessionLifecycle: {
-        idleKillEnabled: true,
-        idleKillTicksRequired: 3,
-        idleKillIntercomAckWindowMs: 1e4,
-        maxAutoInstances: 10
-      },
-      autoUpdate: {
-        checkOnBoot: true,
-        autoInstall: false,
-        checkIntervalMs: 24 * 60 * 60 * 1e3
-      }
-    };
-    CONFIG_MIGRATIONS = [
-      {
-        from: 0,
-        to: 1,
-        migrate: (cfg) => {
-          cfg.config_version = 1;
-          return cfg;
-        }
-      }
-    ];
+    init_db_retry();
+    init_employees();
+    _client = null;
+    _resilientClient = null;
+    initTurso = initDatabase;
+    disposeTurso = disposeDatabase;
   }
 });
 
@@ -1132,12 +1360,12 @@ __export(shard_manager_exports, {
   listShards: () => listShards,
   shardExists: () => shardExists
 });
-import path3 from "path";
-import { existsSync as existsSync3, mkdirSync, readdirSync } from "fs";
+import path4 from "path";
+import { existsSync as existsSync4, mkdirSync, readdirSync } from "fs";
 import { createClient as createClient2 } from "@libsql/client";
 function initShardManager(encryptionKey) {
   _encryptionKey = encryptionKey;
-  if (!existsSync3(SHARDS_DIR)) {
+  if (!existsSync4(SHARDS_DIR)) {
     mkdirSync(SHARDS_DIR, { recursive: true });
   }
   _shardingEnabled = true;
@@ -1158,7 +1386,7 @@ function getShardClient(projectName) {
   }
   const cached = _shards.get(safeName);
   if (cached) return cached;
-  const dbPath = path3.join(SHARDS_DIR, `${safeName}.db`);
+  const dbPath = path4.join(SHARDS_DIR, `${safeName}.db`);
   const client = createClient2({
     url: `file:${dbPath}`,
     encryptionKey: _encryptionKey
@@ -1168,10 +1396,10 @@ function getShardClient(projectName) {
 }
 function shardExists(projectName) {
   const safeName = projectName.replace(/[^a-zA-Z0-9_-]/g, "_");
-  return existsSync3(path3.join(SHARDS_DIR, `${safeName}.db`));
+  return existsSync4(path4.join(SHARDS_DIR, `${safeName}.db`));
 }
 function listShards() {
-  if (!existsSync3(SHARDS_DIR)) return [];
+  if (!existsSync4(SHARDS_DIR)) return [];
   return readdirSync(SHARDS_DIR).filter((f) => f.endsWith(".db")).map((f) => f.replace(".db", ""));
 }
 async function ensureShardSchema(client) {
@@ -1241,7 +1469,11 @@ async function ensureShardSchema(client) {
     "ALTER TABLE memories ADD COLUMN source_path TEXT",
     "ALTER TABLE memories ADD COLUMN source_type TEXT DEFAULT 'text'",
     "ALTER TABLE memories ADD COLUMN tier INTEGER DEFAULT 3",
-    "ALTER TABLE memories ADD COLUMN supersedes_id TEXT"
+    "ALTER TABLE memories ADD COLUMN supersedes_id TEXT",
+    // 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"
   ]) {
     try {
       await client.execute(col);
@@ -1353,7 +1585,7 @@ var init_shard_manager = __esm({
   "src/lib/shard-manager.ts"() {
     "use strict";
     init_config();
-    SHARDS_DIR = path3.join(EXE_AI_DIR, "shards");
+    SHARDS_DIR = path4.join(EXE_AI_DIR, "shards");
     _shards = /* @__PURE__ */ new Map();
     _encryptionKey = null;
     _shardingEnabled = false;
@@ -1371,26 +1603,26 @@ var init_platform_procedures = __esm({
         title: "What is exe-os \u2014 the operating model every agent must understand",
         domain: "architecture",
         priority: "p0",
-        content: "Exe OS is an AI employee operating system. A founder runs 5-10 AI agents as a real org: COO (exe), CTO (yoshi), CMO (mari), engineers (tom), content (sasha). Each agent has identity, expertise, and experience layers \u2014 persistent memory that makes them better over time. All data is local-first, E2EE, owned by the user. The MCP server is the ONLY data interface \u2014 never access the DB directly."
+        content: "Exe OS is an AI employee operating system. A founder runs 5-10 AI agents as a real org: COO, CTO, CMO, engineers, and content production specialists. Each agent has identity, expertise, and experience layers \u2014 persistent memory that makes them better over time. All data is local-first, E2EE, owned by the user. The MCP server is the ONLY data interface \u2014 never access the DB directly."
       },
       {
         title: "Mode 1 \u2014 how exe-os runs inside Claude Code",
         domain: "architecture",
         priority: "p0",
-        content: "Mode 1: exe-os runs AS hooks + MCP + skills inside Claude Code. The founder opens CC, runs /exe to boot the COO. exe manages employees in tmux sessions. Each exeN is a separate CC window/project. Employees (yoshi, tom, mari) run in their own tmux panes via create_task auto-spawn. The founder talks to exe; exe orchestrates the team. CC is the shell, exe-os is the brain."
+        content: "Mode 1: exe-os runs AS hooks + MCP + skills inside Claude Code. The founder opens CC and boots the COO. The COO manages employees in tmux sessions. Each coordinator session is a separate CC window/project. Employees run in their own tmux panes via create_task auto-spawn. The founder talks to the COO; the COO orchestrates the team. CC is the shell, exe-os is the brain."
       },
       {
-        title: "Sessions explained \u2014 what exeN means and how projects work",
+        title: "Sessions explained \u2014 coordinator session names and projects",
         domain: "architecture",
         priority: "p0",
-        content: "Each exeN (exe1, exe2, exe3) is an isolated project session. exe1 might be exe-os development, exe2 might be exe-wiki. Each session spawns its own employees: exe1\u2192yoshi-exe1\u2192tom-exe1. Sessions share the same memory DB but tasks are scoped to the session that created them. A founder can run multiple projects simultaneously. Sessions never interfere with each other."
+        content: "Each coordinator session is an isolated project session. One might be exe-os development, another might be exe-wiki. Each session spawns its own employees using {employee}-{coordinatorSession}. Sessions share the same memory DB but tasks are scoped to the session that created them. A founder can run multiple projects simultaneously. Sessions never interfere with each other."
       },
       // --- Hierarchy and dispatch ---
       {
         title: "Chain of command \u2014 who talks to whom",
         domain: "workflow",
         priority: "p0",
-        content: "Founder \u2192 exe (COO) \u2192 yoshi (CTO) / mari (CMO). Yoshi \u2192 tom (engineer). Mari \u2192 sasha (content). Never skip levels: exe never assigns directly to tom. Tom never reports directly to exe. If you need cross-team info, use ask_team_memory \u2014 don't read other agents' task folders. Each level owns dispatch downward and review upward."
+        content: "Founder -> COO -> CTO/CMO. CTO -> engineers. CMO -> content production. Never skip levels: the COO does not bypass managers for specialist work. Specialists report to their manager. If you need cross-team info, use ask_team_memory \u2014 don't read other agents' task folders. Each level owns dispatch downward and review upward."
       },
       {
         title: "Single dispatch path \u2014 create_task only",
@@ -1400,30 +1632,30 @@ var init_platform_procedures = __esm({
       },
       // --- Session isolation ---
       {
-        title: "Session scoping \u2014 stay in your exe boundary",
+        title: "Session scoping \u2014 stay in your coordinator boundary",
         domain: "security",
         priority: "p0",
-        content: "Session scoping is mandatory. Managers dispatch to workers within their own exe session ONLY. exe1\u2192yoshi-exe1\u2192tom-exe1. exe2\u2192yoshi-exe2\u2192tom2-exe2. Cross-session dispatch is blocked by the system. Verify session names before dispatch. Tasks are scoped to the creating exe session."
+        content: "Session scoping is mandatory. Managers dispatch to workers within their own coordinator session ONLY. Employee sessions use {employee}-{coordinatorSession}. Cross-session dispatch is blocked by the system. Verify session names before dispatch. Tasks are scoped to the creating coordinator session."
       },
       {
         title: "Session isolation \u2014 never touch another session's work",
         domain: "workflow",
         priority: "p0",
-        content: `Sessions are isolated. exeN owns ONLY tasks it dispatched. (1) Never close/update/cancel tasks from another exe session. (2) Never review work from a different session \u2014 report "belongs to exeN" and skip. (3) Ignore other sessions' items in list_tasks results. (4) Employees inherit session: yoshi-exe1 works ONLY on exe1 tasks. Cross-session work is a system violation.`
+        content: "Sessions are isolated. A coordinator session owns ONLY tasks it dispatched. (1) Never close/update/cancel tasks from another coordinator session. (2) Never review work from a different session \u2014 report that it belongs to another session and skip. (3) Ignore other sessions' items in list_tasks results. (4) Employees inherit session: employee sessions work ONLY on their parent coordinator session's tasks. Cross-session work is a system violation."
       },
       // --- Engineering: session scoping in code ---
       {
         title: "Three-dimensional scoping \u2014 session, project, role \u2014 enforced in every query",
         domain: "architecture",
         priority: "p0",
-        content: "Every DB query, notification, review count, and task operation MUST be scoped on 3 dimensions: (1) Session \u2014 filter by session_scope matching current exeN. (2) Project \u2014 filter by project_name. (3) Role \u2014 agents only see data at their hierarchy level. When writing ANY function that touches tasks, reviews, messages, or notifications: always accept a sessionScope parameter and pass it to the SQL WHERE clause. Unscoped queries are bugs. Test by running 2+ exe sessions simultaneously."
+        content: "Every DB query, notification, review count, and task operation MUST be scoped on 3 dimensions: (1) Session \u2014 filter by session_scope matching the current coordinator session. (2) Project \u2014 filter by project_name. (3) Role \u2014 agents only see data at their hierarchy level. When writing ANY function that touches tasks, reviews, messages, or notifications: always accept a sessionScope parameter and pass it to the SQL WHERE clause. Unscoped queries are bugs. Test by running 2+ coordinator sessions simultaneously."
       },
       // --- Hard constraints ---
       {
         title: "What you CANNOT do in exe-os \u2014 hard constraints",
         domain: "security",
         priority: "p0",
-        content: "NEVER: (1) Access the database directly \u2014 it's SQLCipher encrypted, always fails. Use MCP tools only. (2) Manually spawn tmux sessions \u2014 create_task handles it. (3) Run git checkout main \u2014 agents work in worktrees. (4) Modify another agent's in-progress task. (5) Push to remote \u2014 exe reviews and pushes. (6) Skip update_task(done) \u2014 it's the ONLY way your work gets reviewed. (7) Run git init."
+        content: "NEVER: (1) Access the database directly \u2014 it's SQLCipher encrypted, always fails. Use MCP tools only. (2) Manually spawn tmux sessions \u2014 create_task handles it. (3) Run git checkout main \u2014 agents work in worktrees. (4) Modify another agent's in-progress task. (5) Push to remote \u2014 the COO reviews and pushes. (6) Skip update_task(done) \u2014 it's the ONLY way your work gets reviewed. (7) Run git init."
       },
       // --- Operations ---
       {
@@ -1627,13 +1859,13 @@ Ethos:
 - Founder zero-ego. Distributors and customers are the loudest voice.
 - Crypto values: big companies should not own consumer/SMB AI.
 
-STOP AND REDIRECT: Any decision that compromises memory sovereignty, 3-layer cognition, MCP boundary, or AGPL boundary kills all three business paths. Surface the conflict to exe before proceeding.
+STOP AND REDIRECT: Any decision that compromises memory sovereignty, 3-layer cognition, MCP boundary, or AGPL boundary kills all three business paths. Surface the conflict to the COO before proceeding.
 
 Always reference .planning/ARCHITECTURE.md and .planning/PROJECT.md as source of truth for all architectural and product decisions.
 
 OPERATING PROCEDURES (mandatory for all employees):
 
-You report to the COO. All work flows through exe. These procedures are non-negotiable.
+You report to the COO. All work flows through the COO. These procedures are non-negotiable.
 
 1. BEFORE starting work:
    - Read exe/ARCHITECTURE.md (if it exists). This is the system map \u2014 what components exist, how they connect, what invariants to preserve. Understand the architecture before changing anything.
@@ -1658,15 +1890,15 @@ You report to the COO. All work flows through exe. These procedures are non-nego
    - Include what was done, decisions made, and any issues
    - If you're stuck, looping, confused, or running low on context \u2014 update_task(done) with whatever partial result you have. A partial result is infinitely better than no result.
    - NEVER let a failed commit, a loop, or an error prevent you from calling update_task(done).
-   - Do NOT use close_task \u2014 that is reserved for reviewers (exe) to finalize after review.
+   - Do NOT use close_task \u2014 that is reserved for reviewers to finalize after review.
 
 4. AFTER update_task(done) \u2014 COMMIT (best-effort, do NOT let this block):
    - If your task changed system structure, update exe/ARCHITECTURE.md first.
    - Commit IF you are in a git repo (check: \`git rev-parse --git-dir 2>/dev/null\`). Stage only the files you changed, write a clear commit message.
    - If you are NOT in a git repo, skip entirely. NEVER run \`git init\`.
    - If the commit fails, note it but move on \u2014 the work is already marked done via update_task.
-   - Do NOT push \u2014 exe reviews commits and decides what to push.
-   - NEVER run \`git checkout main\`. You work in your own git worktree on a feature branch. Exe stays on main and merges PRs. Switching branches in a shared repo stomps other agents' work.
+   - Do NOT push \u2014 the COO reviews commits and decides what to push.
+   - NEVER run \`git checkout main\`. You work in your own git worktree on a feature branch. The COO stays on main and merges PRs. Switching branches in a shared repo stomps other agents' work.
 
 5. AFTER commit \u2014 REPORT (best-effort):
    Use store_memory to write a structured summary. Include: project name, what was done,
@@ -1680,7 +1912,7 @@ You report to the COO. All work flows through exe. These procedures are non-nego
 
 7. AFTER reporting \u2014 CHECK FOR NEXT WORK (mandatory):
    - First: run list_tasks(status='needs_review') \u2014 check if YOU are the reviewer on any pending reviews. Reviews are work. Process them before anything else.
-   - Second: run list_tasks(status='blocked') \u2014 check if any tasks are blocked. For each blocked task: can YOU unblock it? If yes, unblock it now. If not, escalate to exe immediately. Blocked tasks sitting >24h without action is a pipeline failure.
+   - Second: run list_tasks(status='blocked') \u2014 check if any tasks are blocked. For each blocked task: can YOU unblock it? If yes, unblock it now. If not, escalate to the COO immediately. Blocked tasks sitting >24h without action is a pipeline failure.
    - Then: re-read your task folder: exe/<your-name>/
    - If there are more open tasks, start the next highest-priority one (go to step 1)
    - If no more open tasks AND no pending reviews AND no blocked tasks you can fix, tell the user: "All tasks complete. Anything else?"
@@ -1697,7 +1929,7 @@ DO NOT keep working degraded. Instead:
    Format the text as: "CONTEXT CHECKPOINT [<task-id>]: <summary>"
    Include: task ID + title, what you completed, what's left, open decisions or blockers, key file paths.
 
-2. Send intercom to exe to trigger kill + relaunch:
+2. Send intercom to the COO session to trigger kill + relaunch:
    MY_SESSION=$(tmux display-message -p '#{session_name}' 2>/dev/null)
    EXE_SESSION="\${MY_SESSION#\${AGENT_ID}-}"
    tmux send-keys -t "$EXE_SESSION" "/exe-intercom context-full: \${AGENT_ID} hit capacity. Checkpoint saved. Resume task <task-id>." Enter
@@ -1705,8 +1937,8 @@ DO NOT keep working degraded. Instead:
 3. Stop working immediately. Do not attempt to continue with degraded context.
 
 COMMUNICATION CHAIN \u2014 who you talk to:
-- You report to the COO. Your completion reports, status updates, and questions go to exe via store_memory and update_task.
-- Do NOT address the human user directly for decisions, permissions, or status updates. That's exe's job. The user talks to exe; exe talks to you.
+- You report to the COO. Your completion reports, status updates, and questions go to the COO via store_memory and update_task.
+- Do NOT address the human user directly for decisions, permissions, or status updates. That's the COO's job. The user talks to the COO; the COO talks to you.
 - Exception: if the user sends you a direct message in your tmux window, respond to them. But default to reporting through exe.
 
 SKILL CAPTURE (encouraged, not mandatory):
@@ -1795,21 +2027,21 @@ When you receive a large task (estimated 3+ subtasks):
 6. Review engineer work as reviews arrive in your queue
 7. When all subtasks pass review, mark the parent task done
 
-PARALLEL TOM INSTANCES:
+PARALLEL ENGINEER INSTANCES:
 
-When implementation tasks can be parallelized (touching different files/modules), spin up multiple tom instances using git worktrees for isolation:
+When implementation tasks can be parallelized (touching different files/modules), spin up multiple engineer instances using git worktrees for isolation:
 
-1. Set up git worktrees BEFORE assigning: git worktree add .worktrees/tom1 -b tom1-task-name
-2. Naming convention: tom1-exe1, tom2-exe1, tom3-exe1 (numbered under parent exe session)
-3. All toms share tom's memory partition (AGENT_ID=tom) \u2014 knowledge compounds across instances
-4. Each tom works in its own worktree \u2014 no merge conflicts on parallel work
-5. After all toms complete, YOU integrate: merge worktree branches, resolve any conflicts, run tests
-6. Clean up worktrees after integration: git worktree remove .worktrees/tom1
+1. Set up git worktrees BEFORE assigning: git worktree add .worktrees/{engineer-name}1 -b {engineer-name}1-task-name
+2. Naming convention: {engineer-name}1-{coordinator-session}, {engineer-name}2-{coordinator-session}
+3. Parallel instances share that engineer's memory partition \u2014 knowledge compounds across instances
+4. Each engineer instance works in its own worktree \u2014 no merge conflicts on parallel work
+5. After all engineer instances complete, YOU integrate: merge worktree branches, resolve any conflicts, run tests
+6. Clean up worktrees after integration: git worktree remove .worktrees/{engineer-name}1
 
-Use this for any decomposable implementation work. Single tom for sequential or tightly coupled tasks.
+Use this for any decomposable implementation work. Use a single engineer for sequential or tightly coupled tasks.
 
 Reviews route to the assigner: if you assign a task to an engineer, you review it.
-If exe assigns a task to you, exe reviews it. The chain is:
+If the COO assigns a task to you, the COO reviews it. The chain is:
   COO \u2192 CTO (you review) \u2192 engineers (you review their work, COO reviews yours)
 
 ROLE BOUNDARIES \u2014 stay in your lane:
@@ -1885,17 +2117,17 @@ USER RESEARCH
 When reviewing work, prioritize brand consistency, audience resonance, and measurable impact. Every deliverable should serve a clear strategic goal \u2014 not just look good, but perform.
 
 DELEGATION:
-- For content production tasks (video rendering, image generation, asset creation with exe-create), delegate to sasha via create_task. Write a clear brief with: deliverable, format, platform specs, brand guidelines, and reference assets.
-- You write the script/brief. Sasha produces. You review the output.
+- For content production tasks (video rendering, image generation, asset creation with exe-create), delegate to a Content Production Specialist via create_task. Write a clear brief with: deliverable, format, platform specs, brand guidelines, and reference assets.
+- You write the script/brief. The producer creates the assets. You review the output.
 - For tasks within your own domain (copy, strategy, SEO, social posts), handle directly.
-- When sasha completes work, the review routes back to you automatically. Review it before marking done.`
+- When the producer completes work, the review routes back to you automatically. Review it before marking done.`
       },
       tom: {
         name: "tom",
         role: "Principal Engineer",
         systemPrompt: `You are tom, a principal engineer. You write production-grade code with zero shortcuts. You report to the CTO for technical tasks, and to the COO for organizational matters.
 
-You are the hands. Yoshi architects and specs; you implement. You receive tasks with clear acceptance criteria and tests to pass. Your job is to make those tests green with code that a senior engineer would be proud to maintain.
+You are the hands. The CTO architects and specs; you implement. You receive tasks with clear acceptance criteria and tests to pass. Your job is to make those tests green with code that a senior engineer would be proud to maintain.
 
 STANDARDS \u2014 non-negotiable:
 
@@ -1936,15 +2168,15 @@ Velocity:
 - You are optimized for throughput. Fast, correct, clean \u2014 in that order. But never sacrifice correct for fast.
 
 Working with the CTO:
-- Yoshi writes specs and tests. You implement. If the spec is wrong, report it \u2014 don't silently deviate.
+- The CTO writes specs and tests. You implement. If the spec is wrong, report it \u2014 don't silently deviate.
 - If tests seem wrong, report it \u2014 don't modify them.
 - Your review goes to whoever assigned the task (usually the CTO). The CTO reviews your code, not the COO.
-- Multiple toms can run in parallel. You may share a memory pool. If you discover something useful (a gotcha, a pattern, a workaround), store it \u2014 the next tom session benefits.
+- Multiple instances of your role can run in parallel. You may share a memory pool. If you discover something useful (a gotcha, a pattern, a workaround), store it \u2014 the next engineer session benefits.
 
 What you do NOT do:
 - Architecture decisions \u2014 that's the CTO
 - Marketing, content, design \u2014 that's the CMO
-- Prioritization, coordination \u2014 that's exe
+- Prioritization, coordination \u2014 that's the COO
 - Spec writing, test writing \u2014 that's the CTO (unless explicitly asked)
 - You implement. That's it. Do it well.`
       },
@@ -1953,7 +2185,7 @@ What you do NOT do:
         role: "Content Production Specialist",
         systemPrompt: `You are sasha, the content production specialist. You turn scripts and creative briefs into finished content using the exe-create platform. You report to the COO. For creative direction, you take input from the CMO.
 
-You are the producer. Mari writes the script; you make it real. Yoshi builds the tools; you use them. You know every tool in the exe-create pipeline and how to get the best output from each one.
+You are the producer. The CMO writes the script; you make it real. The CTO builds the tools; you use them. You know every tool in the exe-create pipeline and how to get the best output from each one.
 
 YOUR TOOLS \u2014 exe-create platform:
 
@@ -1991,7 +2223,7 @@ PRODUCTION PRINCIPLES:
 
 1. Check budget before generating. Never burn credits without knowing the cost.
 2. Iterate in drafts. Use cheaper models for exploration, premium (Kling 3.0) for finals.
-3. Follow the script. Mari's creative brief is your spec. Don't improvise on brand/tone.
+3. Follow the script. The CMO's creative brief is your spec. Don't improvise on brand/tone.
 4. Match the platform. 16:9 for YouTube, 9:16 for TikTok/Reels, 1:1 for Instagram feed.
 5. Naming convention: {project}-{type}-{version}.{ext} (e.g., launch-hero-v2.png)
 6. All final assets go to exe/output/ with clear naming.
@@ -2000,7 +2232,7 @@ PRODUCTION PRINCIPLES:
 WHAT YOU DO NOT DO:
 - Marketing strategy, brand decisions, copywriting \u2014 that's the CMO
 - Architecture, tool development, debugging \u2014 that's the CTO
-- Prioritization, coordination \u2014 that's exe
+- Prioritization, coordination \u2014 that's the COO
 - You produce. That's it. Do it well.`
       },
       gen: {
@@ -2158,175 +2390,6 @@ All memory, tasks, behaviors, documents, and wiki content belonging to {{company
   }
 });
 
-// src/lib/employees.ts
-var employees_exports = {};
-__export(employees_exports, {
-  EMPLOYEES_PATH: () => EMPLOYEES_PATH,
-  addEmployee: () => addEmployee,
-  getEmployee: () => getEmployee,
-  getEmployeeByRole: () => getEmployeeByRole,
-  getEmployeeNamesByRole: () => getEmployeeNamesByRole,
-  hasRole: () => hasRole,
-  isMultiInstance: () => isMultiInstance,
-  loadEmployees: () => loadEmployees,
-  loadEmployeesSync: () => loadEmployeesSync,
-  normalizeRosterCase: () => normalizeRosterCase,
-  registerBinSymlinks: () => registerBinSymlinks,
-  saveEmployees: () => saveEmployees,
-  validateEmployeeName: () => validateEmployeeName
-});
-import { readFile as readFile3, writeFile as writeFile3, mkdir as mkdir3 } from "fs/promises";
-import { existsSync as existsSync5, symlinkSync, readlinkSync, readFileSync as readFileSync2, renameSync as renameSync2, unlinkSync as unlinkSync2, writeFileSync as writeFileSync2 } from "fs";
-import { execSync as execSync2 } from "child_process";
-import path5 from "path";
-import os4 from "os";
-function validateEmployeeName(name) {
-  if (!name) {
-    return { valid: false, error: "Name is required" };
-  }
-  if (name.length > 32) {
-    return { valid: false, error: "Name must be 32 characters or fewer" };
-  }
-  if (!/^[a-z][a-z0-9]*$/.test(name)) {
-    return {
-      valid: false,
-      error: "Name must start with a letter and contain only lowercase alphanumeric characters"
-    };
-  }
-  return { valid: true };
-}
-async function loadEmployees(employeesPath = EMPLOYEES_PATH) {
-  if (!existsSync5(employeesPath)) {
-    return [];
-  }
-  const raw = await readFile3(employeesPath, "utf-8");
-  try {
-    return JSON.parse(raw);
-  } catch {
-    return [];
-  }
-}
-async function saveEmployees(employees, employeesPath = EMPLOYEES_PATH) {
-  await mkdir3(path5.dirname(employeesPath), { recursive: true });
-  await writeFile3(employeesPath, JSON.stringify(employees, null, 2) + "\n", "utf-8");
-}
-function loadEmployeesSync(employeesPath = EMPLOYEES_PATH) {
-  if (!existsSync5(employeesPath)) return [];
-  try {
-    return JSON.parse(readFileSync2(employeesPath, "utf-8"));
-  } catch {
-    return [];
-  }
-}
-function getEmployee(employees, name) {
-  return employees.find((e) => e.name.toLowerCase() === name.toLowerCase());
-}
-function getEmployeeByRole(employees, role) {
-  const lower = role.toLowerCase();
-  return employees.find((e) => e.role.toLowerCase() === lower);
-}
-function getEmployeeNamesByRole(employees, role) {
-  const lower = role.toLowerCase();
-  return employees.filter((e) => e.role.toLowerCase() === lower).map((e) => e.name);
-}
-function hasRole(agentName, role) {
-  const employees = loadEmployeesSync();
-  const emp = getEmployee(employees, agentName);
-  return emp ? emp.role.toLowerCase() === role.toLowerCase() : false;
-}
-function isMultiInstance(agentName, employees) {
-  const roster = employees ?? loadEmployeesSync();
-  const emp = getEmployee(roster, agentName);
-  if (!emp) return false;
-  return MULTI_INSTANCE_ROLES.has(emp.role.toLowerCase());
-}
-function addEmployee(employees, employee) {
-  const normalized = { ...employee, name: employee.name.toLowerCase() };
-  if (employees.some((e) => e.name.toLowerCase() === normalized.name)) {
-    throw new Error(`Employee '${normalized.name}' already exists`);
-  }
-  return [...employees, normalized];
-}
-async function normalizeRosterCase(rosterPath) {
-  const employees = await loadEmployees(rosterPath);
-  let changed = false;
-  for (const emp of employees) {
-    if (emp.name !== emp.name.toLowerCase()) {
-      const oldName = emp.name;
-      emp.name = emp.name.toLowerCase();
-      changed = true;
-      try {
-        const identityDir = path5.join(os4.homedir(), ".exe-os", "identity");
-        const oldPath = path5.join(identityDir, `${oldName}.md`);
-        const newPath = path5.join(identityDir, `${emp.name}.md`);
-        if (existsSync5(oldPath) && !existsSync5(newPath)) {
-          renameSync2(oldPath, newPath);
-        } else if (existsSync5(oldPath) && oldPath !== newPath) {
-          const content = readFileSync2(oldPath, "utf-8");
-          writeFileSync2(newPath, content, "utf-8");
-          if (oldPath.toLowerCase() !== newPath.toLowerCase()) {
-            unlinkSync2(oldPath);
-          }
-        }
-      } catch {
-      }
-    }
-  }
-  if (changed) {
-    await saveEmployees(employees, rosterPath);
-  }
-  return changed;
-}
-function findExeBin() {
-  try {
-    return execSync2(process.platform === "win32" ? "where exe-os" : "which exe-os", { encoding: "utf8" }).trim();
-  } catch {
-    return null;
-  }
-}
-function registerBinSymlinks(name) {
-  const created = [];
-  const skipped = [];
-  const errors = [];
-  const exeBinPath = findExeBin();
-  if (!exeBinPath) {
-    errors.push("Could not find 'exe-os' in PATH");
-    return { created, skipped, errors };
-  }
-  const binDir = path5.dirname(exeBinPath);
-  let target;
-  try {
-    target = readlinkSync(exeBinPath);
-  } catch {
-    errors.push("Could not read 'exe' symlink");
-    return { created, skipped, errors };
-  }
-  for (const suffix of ["", "-opencode"]) {
-    const linkName = `${name}${suffix}`;
-    const linkPath = path5.join(binDir, linkName);
-    if (existsSync5(linkPath)) {
-      skipped.push(linkName);
-      continue;
-    }
-    try {
-      symlinkSync(target, linkPath);
-      created.push(linkName);
-    } catch (err) {
-      errors.push(`${linkName}: ${err instanceof Error ? err.message : String(err)}`);
-    }
-  }
-  return { created, skipped, errors };
-}
-var EMPLOYEES_PATH, MULTI_INSTANCE_ROLES;
-var init_employees = __esm({
-  "src/lib/employees.ts"() {
-    "use strict";
-    init_config();
-    EMPLOYEES_PATH = path5.join(EXE_AI_DIR, "exe-employees.json");
-    MULTI_INSTANCE_ROLES = /* @__PURE__ */ new Set(["principal engineer", "content production specialist", "staff code reviewer"]);
-  }
-});
-
 // src/lib/session-key.ts
 import { execSync as execSync3 } from "child_process";
 function getSessionKey() {
@@ -2377,11 +2440,54 @@ __export(active_agent_exports, {
   clearActiveAgent: () => clearActiveAgent,
   getActiveAgent: () => getActiveAgent,
   getAllActiveAgents: () => getAllActiveAgents,
+  resolveActiveAgentFromTmuxSession: () => resolveActiveAgentFromTmuxSession,
   writeActiveAgent: () => writeActiveAgent
 });
 import { readFileSync as readFileSync3, writeFileSync as writeFileSync3, mkdirSync as mkdirSync3, unlinkSync as unlinkSync3, readdirSync as readdirSync3 } from "fs";
 import { execSync as execSync4 } from "child_process";
 import path6 from "path";
+function isNameWithOptionalInstance(candidate, baseName) {
+  if (candidate === baseName) return true;
+  if (!candidate.startsWith(baseName)) return false;
+  return /^\d+$/.test(candidate.slice(baseName.length));
+}
+function resolveEmployeeFromSessionPrefix(prefix, employees) {
+  const sorted = [...employees].sort((a, b) => b.name.length - a.name.length);
+  for (const employee of sorted) {
+    if (isNameWithOptionalInstance(prefix, employee.name)) {
+      return { agentId: employee.name, agentRole: employee.role };
+    }
+  }
+  return null;
+}
+function resolveActiveAgentFromTmuxSession(sessionName) {
+  const employees = loadEmployeesSync();
+  const coordinator = getCoordinatorEmployee(employees);
+  const coordinatorName = coordinator?.name ?? DEFAULT_COORDINATOR_TEMPLATE_NAME;
+  if (isNameWithOptionalInstance(sessionName, coordinatorName)) {
+    return {
+      agentId: coordinatorName,
+      agentRole: coordinator?.role ?? "COO"
+    };
+  }
+  if (isNameWithOptionalInstance(sessionName, DEFAULT_COORDINATOR_TEMPLATE_NAME)) {
+    return {
+      agentId: coordinator?.name ?? DEFAULT_COORDINATOR_TEMPLATE_NAME,
+      agentRole: coordinator?.role ?? "COO"
+    };
+  }
+  if (sessionName.includes("-")) {
+    const prefix = sessionName.split("-")[0] ?? "";
+    const employee = resolveEmployeeFromSessionPrefix(prefix, employees);
+    if (employee) return employee;
+    const legacy = prefix.match(/^([a-zA-Z]+)\d*$/);
+    if (legacy?.[1] && legacy[1] !== DEFAULT_COORDINATOR_TEMPLATE_NAME) {
+      const emp = getEmployee(employees, legacy[1]);
+      return { agentId: emp?.name ?? legacy[1], agentRole: emp?.role ?? "employee" };
+    }
+  }
+  return null;
+}
 function getMarkerPath() {
   return path6.join(CACHE_DIR, `active-agent-${getSessionKey()}.json`);
 }
@@ -2434,13 +2540,8 @@ function getActiveAgent() {
       "tmux display-message -p '#{session_name}' 2>/dev/null",
       { encoding: "utf8", timeout: 2e3 }
     ).trim();
-    const empMatch = sessionName.match(/^([a-zA-Z]+)\d*-exe\d+$/);
-    if (empMatch && empMatch[1] !== "exe") {
-      return { agentId: empMatch[1], agentRole: "employee" };
-    }
-    if (/^exe\d+$/.test(sessionName)) {
-      return { agentId: "exe", agentRole: "COO" };
-    }
+    const resolved = resolveActiveAgentFromTmuxSession(sessionName);
+    if (resolved) return resolved;
   } catch {
   }
   return {
@@ -2501,6 +2602,7 @@ var init_active_agent = __esm({
     "use strict";
     init_config();
     init_session_key2();
+    init_employees();
     CACHE_DIR = path6.join(EXE_AI_DIR, "session-cache");
     STALE_MS = 24 * 60 * 60 * 1e3;
   }
@@ -2516,17 +2618,17 @@ import { spawnSync } from "child_process";
 init_database();
 
 // src/lib/keychain.ts
-import { readFile, writeFile, unlink, mkdir, chmod } from "fs/promises";
-import { existsSync } from "fs";
-import path from "path";
-import os from "os";
+import { readFile as readFile3, writeFile as writeFile3, unlink, mkdir as mkdir3, chmod as chmod2 } from "fs/promises";
+import { existsSync as existsSync3 } from "fs";
+import path3 from "path";
+import os3 from "os";
 var SERVICE = "exe-mem";
 var ACCOUNT = "master-key";
 function getKeyDir() {
-  return process.env.EXE_OS_DIR ?? process.env.EXE_MEM_DIR ?? path.join(os.homedir(), ".exe-os");
+  return process.env.EXE_OS_DIR ?? process.env.EXE_MEM_DIR ?? path3.join(os3.homedir(), ".exe-os");
 }
 function getKeyPath() {
-  return path.join(getKeyDir(), "master.key");
+  return path3.join(getKeyDir(), "master.key");
 }
 async function tryKeytar() {
   try {
@@ -2547,11 +2649,11 @@ async function getMasterKey() {
     }
   }
   const keyPath = getKeyPath();
-  if (!existsSync(keyPath)) {
+  if (!existsSync3(keyPath)) {
     return null;
   }
   try {
-    const content = await readFile(keyPath, "utf-8");
+    const content = await readFile3(keyPath, "utf-8");
     return Buffer.from(content.trim(), "base64");
   } catch {
     return null;
@@ -2715,6 +2817,9 @@ async function flushBatch() {
       const sourceType = row.source_type ?? null;
       const tier = row.tier ?? 3;
       const supersedesId = row.supersedes_id ?? null;
+      const draft = row.draft ? 1 : 0;
+      const memoryType = row.memory_type ?? "raw";
+      const trajectory = row.trajectory ?? null;
       return {
         sql: hasVector ? `INSERT OR IGNORE INTO memories
               (id, agent_id, agent_role, session_id, timestamp,
@@ -2722,15 +2827,15 @@ async function flushBatch() {
                has_error, raw_text, vector, version, task_id, importance, status,
                confidence, last_accessed,
                workspace_id, document_id, user_id, char_offset, page_number,
-               source_path, source_type, tier, supersedes_id)
-              VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, vector32(?), ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)` : `INSERT OR IGNORE INTO memories
+               source_path, source_type, tier, supersedes_id, draft, memory_type, trajectory)
+              VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, vector32(?), ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)` : `INSERT OR IGNORE INTO memories
               (id, agent_id, agent_role, session_id, timestamp,
                tool_name, project_name,
                has_error, raw_text, vector, version, task_id, importance, status,
                confidence, last_accessed,
                workspace_id, document_id, user_id, char_offset, page_number,
-               source_path, source_type, tier, supersedes_id)
-              VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, NULL, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+               source_path, source_type, tier, supersedes_id, draft, memory_type, trajectory)
+              VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, NULL, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
         args: hasVector ? [
           row.id,
           row.agent_id,
@@ -2756,7 +2861,10 @@ async function flushBatch() {
           sourcePath,
           sourceType,
           tier,
-          supersedesId
+          supersedesId,
+          draft,
+          memoryType,
+          trajectory
         ] : [
           row.id,
           row.agent_id,
@@ -2781,7 +2889,10 @@ async function flushBatch() {
           sourcePath,
           sourceType,
           tier,
-          supersedesId
+          supersedesId,
+          draft,
+          memoryType,
+          trajectory
         ]
       };
     };
@@ -2836,15 +2947,15 @@ function vectorToBlob(vector) {
 }
 
 // src/lib/behaviors-export.ts
-import os3 from "os";
-import path4 from "path";
+import os4 from "os";
+import path5 from "path";
 import {
-  existsSync as existsSync4,
+  existsSync as existsSync5,
   mkdirSync as mkdirSync2,
   readdirSync as readdirSync2,
   statSync,
-  unlinkSync,
-  writeFileSync
+  unlinkSync as unlinkSync2,
+  writeFileSync as writeFileSync2
 } from "fs";
 
 // src/lib/behaviors.ts
@@ -2879,15 +2990,15 @@ async function listBehaviors(agentId, projectName, limit = 30) {
 }
 
 // src/lib/behaviors-export.ts
-var BEHAVIORS_EXPORT_DIR = path4.join(
-  os3.homedir(),
+var BEHAVIORS_EXPORT_DIR = path5.join(
+  os4.homedir(),
   ".exe-os",
   "behaviors-export"
 );
 var STALE_EXPORT_AGE_MS = 60 * 60 * 1e3;
 var EXPORT_BEHAVIOR_LIMIT = 30;
 function sweepStaleBehaviorExports(now = Date.now()) {
-  if (!existsSync4(BEHAVIORS_EXPORT_DIR)) return;
+  if (!existsSync5(BEHAVIORS_EXPORT_DIR)) return;
   let entries;
   try {
     entries = readdirSync2(BEHAVIORS_EXPORT_DIR);
@@ -2895,11 +3006,11 @@ function sweepStaleBehaviorExports(now = Date.now()) {
     return;
   }
   for (const entry of entries) {
-    const filePath = path4.join(BEHAVIORS_EXPORT_DIR, entry);
+    const filePath = path5.join(BEHAVIORS_EXPORT_DIR, entry);
     try {
       const stat = statSync(filePath);
       if (now - stat.mtimeMs > STALE_EXPORT_AGE_MS) {
-        unlinkSync(filePath);
+        unlinkSync2(filePath);
       }
     } catch {
     }
@@ -2928,10 +3039,10 @@ function renderBehaviorExport(behaviors) {
 }
 function exportFilePath(agentId, projectName, sessionKey) {
   if (!sessionKey) {
-    return path4.join(BEHAVIORS_EXPORT_DIR, `${agentId}.md`);
+    return path5.join(BEHAVIORS_EXPORT_DIR, `${agentId}.md`);
   }
   const safeProject = projectName.replace(/[^a-zA-Z0-9_-]/g, "_");
-  return path4.join(
+  return path5.join(
     BEHAVIORS_EXPORT_DIR,
     `${agentId}-${safeProject}-${sessionKey}.md`
   );
@@ -2943,7 +3054,7 @@ async function exportBehaviorsForAgent(agentId, projectName, sessionKey) {
   if (behaviors.length === 0) return null;
   const body = renderBehaviorExport(behaviors);
   const target = exportFilePath(agentId, projectName, sessionKey);
-  writeFileSync(target, body, "utf-8");
+  writeFileSync2(target, body, "utf-8");
   return target;
 }
 
@@ -2951,7 +3062,7 @@ async function exportBehaviorsForAgent(agentId, projectName, sessionKey) {
 init_employee_templates();
 
 // src/lib/cc-agent-support.ts
-import { execSync } from "child_process";
+import { execSync as execSync2 } from "child_process";
 var _cachedSupport = null;
 function _resetCcAgentSupportCache() {
   _cachedSupport = null;
@@ -2959,7 +3070,7 @@ function _resetCcAgentSupportCache() {
 function claudeSupportsAgentFlag() {
   if (_cachedSupport !== null) return _cachedSupport;
   try {
-    const helpOutput = execSync("claude --help 2>&1", {
+    const helpOutput = execSync2("claude --help 2>&1", {
       encoding: "utf-8",
       timeout: 5e3
     });
@@ -3011,7 +3122,7 @@ function resolveAgent(argv) {
   const agentIdx = rest.indexOf("--agent");
   if (agentIdx === -1 || !rest[agentIdx + 1]) {
     throw new Error(
-      "exe-launch-agent: missing --agent <name>. Invoke via the per-agent symlink (exe/yoshi/tom/mari/sasha) or pass --agent explicitly."
+      "exe-launch-agent: missing --agent <name>. Invoke via that agent's symlink or pass --agent explicitly."
     );
   }
   const agent = rest[agentIdx + 1].toLowerCase();