@askexenow/exe-os 0.9.34 → 0.9.36

package/dist/lib/exe-daemon.js

@@ -436,1265 +436,694 @@ var init_daemon_auth = __esm({
   }
 });
 
-// src/lib/projection-worker.ts
-var projection_worker_exports = {};
-__export(projection_worker_exports, {
-  processProjectionBatch: () => processProjectionBatch,
-  projectionHandlersForTests: () => projectionHandlersForTests,
-  resetProjectionWorkerForTests: () => resetProjectionWorkerForTests,
-  setProjectionWorkerPrismaClientForTests: () => setProjectionWorkerPrismaClientForTests,
-  startProjectionWorker: () => startProjectionWorker,
-  stopProjectionWorker: () => stopProjectionWorker
-});
-import os2 from "os";
-import path4 from "path";
-import { existsSync as existsSync5 } from "fs";
-import { createRequire } from "module";
-import { pathToFileURL } from "url";
-function loadPrisma() {
-  if (!prismaPromise) {
-    prismaPromise = (async () => {
-      const explicitPath = process.env.EXE_OS_PRISMA_CLIENT_PATH;
-      if (explicitPath) {
-        const mod2 = await import(pathToFileURL(explicitPath).href);
-        const Ctor2 = mod2.PrismaClient ?? mod2.default?.PrismaClient;
-        if (!Ctor2) throw new Error(`No PrismaClient at ${explicitPath}`);
-        return new Ctor2();
-      }
-      const exeDbRoot = process.env.EXE_DB_ROOT ?? path4.join(os2.homedir(), "exe-db");
-      const req = createRequire(path4.join(exeDbRoot, "package.json"));
-      const entry = req.resolve("@prisma/client");
-      const mod = await import(pathToFileURL(entry).href);
-      const Ctor = mod.PrismaClient ?? mod.default?.PrismaClient;
-      if (!Ctor) throw new Error(`No PrismaClient in ${entry}`);
-      return new Ctor();
-    })();
+// src/lib/db-retry.ts
+function isBusyError(err) {
+  if (err instanceof Error) {
+    const msg = err.message.toLowerCase();
+    return msg.includes("sqlite_busy") || msg.includes("database is locked");
   }
-  return prismaPromise;
-}
-function setProjectionWorkerPrismaClientForTests(client) {
-  prismaPromise = client ? Promise.resolve(client) : null;
+  return false;
 }
-function resetProjectionWorkerForTests() {
-  running = false;
-  if (pollTimer) {
-    clearTimeout(pollTimer);
-    pollTimer = null;
-  }
-  prismaPromise = null;
+function delay(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
 }
-async function processBatch() {
-  const prisma = await loadPrisma();
-  const events = await prisma.$queryRawUnsafe(
-    `SELECT "id", "source", "source_id", "event_type", "payload", "metadata", "timestamp"
-     FROM "raw"."raw_events"
-     WHERE "processed_at" IS NULL
-     ORDER BY "timestamp" ASC
-     LIMIT $1`,
-    BATCH_SIZE
-  );
-  if (events.length === 0) return 0;
-  let processed = 0;
-  for (const event of events) {
+async function retryOnBusy(fn, label) {
+  let lastError;
+  for (let attempt = 0; attempt <= MAX_RETRIES; attempt++) {
     try {
-      const handler = projectionHandlers[event.source] ?? defaultHandler;
-      const result = await handler(event, prisma);
-      await prisma.$executeRawUnsafe(
-        `UPDATE "raw"."raw_events"
-         SET "processed_at" = NOW(), "projections" = $1::jsonb
-         WHERE "id" = $2`,
-        JSON.stringify({ targets: result.targets, skipped: result.skipped }),
-        event.id
-      );
-      processed++;
+      return await fn();
     } catch (err) {
-      const message = err instanceof Error ? err.message : String(err);
+      lastError = err;
+      if (!isBusyError(err) || attempt === MAX_RETRIES) {
+        throw err;
+      }
+      const backoff = BASE_DELAY_MS * Math.pow(2, attempt);
+      const jitter = Math.floor(Math.random() * MAX_JITTER_MS);
       process.stderr.write(
-        `[projection-worker] Error processing event ${event.id}: ${message}
+        `[exe-os] SQLITE_BUSY ${label} retry ${attempt + 1}/${MAX_RETRIES} \u2014 waiting ${backoff + jitter}ms
 `
       );
-      await prisma.$executeRawUnsafe(
-        `UPDATE "raw"."raw_events"
-         SET "processed_at" = NOW(), "projections" = $1::jsonb
-         WHERE "id" = $2`,
-        JSON.stringify({ error: message }),
-        event.id
-      );
+      await delay(backoff + jitter);
     }
   }
-  return processed;
+  throw lastError;
 }
-function startProjectionWorker() {
-  if (running) return;
-  if (!process.env.DATABASE_URL) {
-    const exeDbRoot = process.env.EXE_DB_ROOT ?? path4.join(os2.homedir(), "exe-db");
-    if (!existsSync5(path4.join(exeDbRoot, "package.json"))) {
-      process.stderr.write("[projection-worker] Skipped \u2014 no exe-db found. Set DATABASE_URL or EXE_DB_ROOT to enable.\n");
-      return;
-    }
-  }
-  running = true;
-  process.stderr.write("[projection-worker] Starting...\n");
-  const tick = async () => {
-    if (!running) return;
-    try {
-      const count = await processBatch();
-      if (count > 0) {
-        process.stderr.write(`[projection-worker] Processed ${count} events.
-`);
+function wrapWithRetry(client) {
+  return new Proxy(client, {
+    get(target, prop, receiver) {
+      if (prop === "execute") {
+        return (sql) => retryOnBusy(() => target.execute(sql), "execute");
       }
-    } catch (err) {
-      process.stderr.write(
-        `[projection-worker] Poll error: ${err instanceof Error ? err.message : String(err)}
-`
-      );
-    }
-    if (running) {
-      pollTimer = setTimeout(tick, POLL_INTERVAL_MS);
+      if (prop === "batch") {
+        return (stmts, mode) => retryOnBusy(() => target.batch(stmts, mode), "batch");
+      }
+      return Reflect.get(target, prop, receiver);
     }
-  };
-  void tick();
+  });
 }
-function stopProjectionWorker() {
-  running = false;
-  if (pollTimer) {
-    clearTimeout(pollTimer);
-    pollTimer = null;
+var MAX_RETRIES, BASE_DELAY_MS, MAX_JITTER_MS;
+var init_db_retry = __esm({
+  "src/lib/db-retry.ts"() {
+    "use strict";
+    MAX_RETRIES = 5;
+    BASE_DELAY_MS = 250;
+    MAX_JITTER_MS = 400;
   }
-  process.stderr.write("[projection-worker] Stopped.\n");
-}
-async function processProjectionBatch() {
-  return processBatch();
-}
-var prismaPromise, projectionHandlers, projectionHandlersForTests, defaultHandler, BATCH_SIZE, POLL_INTERVAL_MS, running, pollTimer;
-var init_projection_worker = __esm({
-  "src/lib/projection-worker.ts"() {
+});
+
+// src/lib/runtime-table.ts
+var RUNTIME_TABLE, DEFAULT_RUNTIME;
+var init_runtime_table = __esm({
+  "src/lib/runtime-table.ts"() {
     "use strict";
-    prismaPromise = null;
-    projectionHandlers = {
-      async whatsapp(event, prisma) {
-        const targets = [];
-        const payload = event.payload;
-        await prisma.$executeRawUnsafe(
-          `INSERT INTO "memory"."memory_records" ("id", "agent_id", "agent_role", "session_id", "tool_name", "project_name", "raw_text", "memory_type", "source_type", "intent")
-       VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10)
-       ON CONFLICT ("id") DO NOTHING`,
-          crypto.randomUUID(),
-          "system",
-          "ingest",
-          "projection-worker",
-          "projection_worker",
-          "exe-os",
-          JSON.stringify(payload),
-          "raw",
-          "whatsapp",
-          event.event_type
-        );
-        targets.push("memory");
-        return { targets };
-      },
-      async shopify(event, prisma) {
-        const targets = [];
-        const payload = event.payload;
-        await prisma.$executeRawUnsafe(
-          `INSERT INTO "memory"."memory_records" ("id", "agent_id", "agent_role", "session_id", "tool_name", "project_name", "raw_text", "memory_type", "source_type", "intent")
-       VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10)
-       ON CONFLICT ("id") DO NOTHING`,
-          crypto.randomUUID(),
-          "system",
-          "ingest",
-          "projection-worker",
-          "projection_worker",
-          "exe-os",
-          JSON.stringify(payload),
-          "raw",
-          "shopify",
-          event.event_type
-        );
-        targets.push("memory");
-        return { targets };
-      },
-      async cloud_sync(event, prisma) {
-        const targets = [];
-        const payload = event.payload;
-        await prisma.$executeRawUnsafe(
-          `INSERT INTO "memory"."memory_records" ("id", "agent_id", "agent_role", "session_id", "tool_name", "project_name", "raw_text", "memory_type", "source_type", "intent", "domain")
-       VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11)
-       ON CONFLICT ("id") DO NOTHING`,
-          payload.id ?? crypto.randomUUID(),
-          payload.agent_id ?? "system",
-          payload.agent_role ?? "ingest",
-          payload.session_id ?? "projection-worker",
-          payload.tool_name ?? "cloud_sync",
-          payload.project_name ?? "exe-os",
-          payload.raw_text ?? JSON.stringify(payload),
-          payload.memory_type ?? "raw",
-          "cloud_sync",
-          event.event_type,
-          payload.domain ?? null
-        );
-        targets.push("memory");
-        return { targets };
+    RUNTIME_TABLE = {
+      codex: {
+        binary: "codex",
+        launchMode: "interactive",
+        autoApproveFlag: "--dangerously-bypass-approvals-and-sandbox",
+        inlineFlag: "--no-alt-screen",
+        apiKeyEnv: "OPENAI_API_KEY",
+        defaultModel: "gpt-5.5"
       },
-      async external_agent(event, prisma) {
-        const targets = [];
-        const payload = event.payload;
-        await prisma.$executeRawUnsafe(
-          `INSERT INTO "memory"."memory_records" ("id", "agent_id", "agent_role", "session_id", "tool_name", "project_name", "raw_text", "memory_type", "source_type", "intent", "domain")
-       VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11)
-       ON CONFLICT ("id") DO NOTHING`,
-          crypto.randomUUID(),
-          "system",
-          "ingest",
-          "projection-worker",
-          "projection_worker",
-          "exe-os",
-          JSON.stringify(payload),
-          "raw",
-          "external_agent",
-          event.event_type,
-          payload.domain ?? null
-        );
-        targets.push("memory");
-        return { targets };
+      opencode: {
+        binary: "opencode",
+        launchMode: "exec",
+        autoApproveFlag: "--dangerously-skip-permissions",
+        inlineFlag: "",
+        apiKeyEnv: "ANTHROPIC_API_KEY",
+        defaultModel: "anthropic/claude-sonnet-4-6"
       }
     };
-    projectionHandlersForTests = projectionHandlers;
-    defaultHandler = async (event, prisma) => {
-      await prisma.$executeRawUnsafe(
-        `INSERT INTO "memory"."memory_records" ("id", "agent_id", "agent_role", "session_id", "tool_name", "project_name", "raw_text", "memory_type", "source_type", "intent")
-     VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10)
-     ON CONFLICT ("id") DO NOTHING`,
-        crypto.randomUUID(),
-        "system",
-        "ingest",
-        "projection-worker",
-        "projection_worker",
-        "exe-os",
-        JSON.stringify(event.payload),
-        "raw",
-        event.source,
-        event.event_type
-      );
-      return { targets: ["memory"] };
-    };
-    BATCH_SIZE = 50;
-    POLL_INTERVAL_MS = 1e4;
-    running = false;
-    pollTimer = null;
+    DEFAULT_RUNTIME = "claude";
   }
 });
 
-// src/lib/shard-manager.ts
-var shard_manager_exports = {};
-__export(shard_manager_exports, {
-  disposeShards: () => disposeShards,
-  ensureShardSchema: () => ensureShardSchema,
-  getOpenShardCount: () => getOpenShardCount,
-  getReadyShardClient: () => getReadyShardClient,
-  getShardClient: () => getShardClient,
-  getShardsDir: () => getShardsDir,
-  initShardManager: () => initShardManager,
-  isShardingEnabled: () => isShardingEnabled,
-  listShards: () => listShards,
-  shardExists: () => shardExists
+// src/lib/agent-config.ts
+var agent_config_exports = {};
+__export(agent_config_exports, {
+  AGENT_CONFIG_PATH: () => AGENT_CONFIG_PATH,
+  DEFAULT_MODELS: () => DEFAULT_MODELS,
+  KNOWN_RUNTIMES: () => KNOWN_RUNTIMES,
+  RUNTIME_LABELS: () => RUNTIME_LABELS,
+  clearAgentRuntime: () => clearAgentRuntime,
+  getAgentRuntime: () => getAgentRuntime,
+  loadAgentConfig: () => loadAgentConfig,
+  saveAgentConfig: () => saveAgentConfig,
+  setAgentRuntime: () => setAgentRuntime
 });
-import path5 from "path";
-import { existsSync as existsSync6, mkdirSync as mkdirSync2, readdirSync } from "fs";
-import { createClient } from "@libsql/client";
-function initShardManager(encryptionKey) {
-  _encryptionKey = encryptionKey;
-  if (!existsSync6(SHARDS_DIR)) {
-    mkdirSync2(SHARDS_DIR, { recursive: true });
+import { readFileSync as readFileSync4, writeFileSync as writeFileSync3, existsSync as existsSync5 } from "fs";
+import path4 from "path";
+function loadAgentConfig() {
+  if (!existsSync5(AGENT_CONFIG_PATH)) return {};
+  try {
+    return JSON.parse(readFileSync4(AGENT_CONFIG_PATH, "utf-8"));
+  } catch {
+    return {};
   }
-  _shardingEnabled = true;
-  if (_evictionTimer) clearInterval(_evictionTimer);
-  _evictionTimer = setInterval(evictIdleShards, EVICTION_INTERVAL_MS);
-  _evictionTimer.unref();
 }
-function isShardingEnabled() {
-  return _shardingEnabled;
+function saveAgentConfig(config2) {
+  const dir = path4.dirname(AGENT_CONFIG_PATH);
+  ensurePrivateDirSync(dir);
+  writeFileSync3(AGENT_CONFIG_PATH, JSON.stringify(config2, null, 2) + "\n", "utf-8");
+  enforcePrivateFileSync(AGENT_CONFIG_PATH);
 }
-function getShardsDir() {
-  return SHARDS_DIR;
+function getAgentRuntime(agentId) {
+  const config2 = loadAgentConfig();
+  const entry = config2[agentId];
+  if (entry) return entry;
+  const orgDefault = config2["default"];
+  if (orgDefault) return orgDefault;
+  return { runtime: DEFAULT_RUNTIME, model: DEFAULT_MODELS[DEFAULT_RUNTIME] };
 }
-function getShardClient(projectName) {
-  if (!_encryptionKey) {
-    throw new Error("Shard manager not initialized. Call initShardManager() first.");
+function setAgentRuntime(agentId, runtime, model, reasoning_effort) {
+  const knownModels = KNOWN_RUNTIMES[runtime];
+  if (!knownModels) {
+    return {
+      ok: false,
+      error: `Unknown runtime "${runtime}". Valid: ${Object.keys(KNOWN_RUNTIMES).join(", ")}`
+    };
   }
-  const safeName = projectName.replace(/[^a-zA-Z0-9_-]/g, "_");
-  if (!safeName || safeName === "unknown") {
-    throw new Error(`Invalid project name for shard: "${projectName}" (resolved to "${safeName}")`);
+  if (!knownModels.includes(model)) {
+    return {
+      ok: false,
+      error: `Unknown model "${model}" for runtime "${runtime}". Valid: ${knownModels.join(", ")}`
+    };
   }
-  const cached = _shards.get(safeName);
-  if (cached) {
-    _shardLastAccess.set(safeName, Date.now());
-    return cached;
+  const config2 = loadAgentConfig();
+  const entry = { runtime, model };
+  if (reasoning_effort) entry.reasoning_effort = reasoning_effort;
+  config2[agentId] = entry;
+  saveAgentConfig(config2);
+  return { ok: true };
+}
+function clearAgentRuntime(agentId) {
+  const config2 = loadAgentConfig();
+  delete config2[agentId];
+  saveAgentConfig(config2);
+}
+var AGENT_CONFIG_PATH, KNOWN_RUNTIMES, RUNTIME_LABELS, DEFAULT_MODELS;
+var init_agent_config = __esm({
+  "src/lib/agent-config.ts"() {
+    "use strict";
+    init_config();
+    init_runtime_table();
+    init_secure_files();
+    AGENT_CONFIG_PATH = path4.join(EXE_AI_DIR, "agent-config.json");
+    KNOWN_RUNTIMES = {
+      claude: ["claude-opus-4.6", "claude-opus-4", "claude-sonnet-4.6", "claude-sonnet-4", "claude-haiku-4.5"],
+      codex: ["gpt-5.4", "gpt-5.5", "gpt-5.3-codex-spark", "o3", "o4-mini"],
+      opencode: ["anthropic/claude-sonnet-4-6", "openai/gpt-5.4", "google/gemini-2.5-pro", "deepseek/deepseek-r3", "minimax/minimax-m2.5"]
+    };
+    RUNTIME_LABELS = {
+      claude: "Claude Code (Anthropic)",
+      codex: "Codex (OpenAI)",
+      opencode: "OpenCode (open source)"
+    };
+    DEFAULT_MODELS = {
+      claude: "claude-opus-4.6",
+      codex: RUNTIME_TABLE.codex?.defaultModel ?? "gpt-5.4",
+      opencode: RUNTIME_TABLE.opencode?.defaultModel ?? "anthropic/claude-sonnet-4-6"
+    };
   }
-  while (_shards.size >= MAX_OPEN_SHARDS) {
-    evictLRU();
+});
+
+// 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,
+  baseAgentName: () => baseAgentName,
+  canCoordinate: () => canCoordinate,
+  getCoordinatorEmployee: () => getCoordinatorEmployee,
+  getCoordinatorName: () => getCoordinatorName,
+  getEmployee: () => getEmployee,
+  getEmployeeByRole: () => getEmployeeByRole,
+  getEmployeeNamesByRole: () => getEmployeeNamesByRole,
+  hasRole: () => hasRole,
+  hireEmployee: () => hireEmployee,
+  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 existsSync6, symlinkSync, readlinkSync, readFileSync as readFileSync5, renameSync as renameSync2, unlinkSync, writeFileSync as writeFileSync4 } from "fs";
+import { execSync } from "child_process";
+import path5 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" };
   }
-  const dbPath = path5.join(SHARDS_DIR, `${safeName}.db`);
-  const client = createClient({
-    url: `file:${dbPath}`,
-    encryptionKey: _encryptionKey
-  });
-  _shards.set(safeName, client);
-  _shardLastAccess.set(safeName, Date.now());
-  return client;
+  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 };
 }
-function shardExists(projectName) {
-  const safeName = projectName.replace(/[^a-zA-Z0-9_-]/g, "_");
-  return existsSync6(path5.join(SHARDS_DIR, `${safeName}.db`));
+async function loadEmployees(employeesPath = EMPLOYEES_PATH) {
+  if (!existsSync6(employeesPath)) {
+    return [];
+  }
+  const raw = await readFile2(employeesPath, "utf-8");
+  try {
+    return JSON.parse(raw);
+  } catch {
+    return [];
+  }
 }
-function listShards() {
-  if (!existsSync6(SHARDS_DIR)) return [];
-  return readdirSync(SHARDS_DIR).filter((f) => f.endsWith(".db")).map((f) => f.replace(".db", ""));
+async function saveEmployees(employees, employeesPath = EMPLOYEES_PATH) {
+  await mkdir2(path5.dirname(employeesPath), { recursive: true });
+  await writeFile2(employeesPath, JSON.stringify(employees, null, 2) + "\n", "utf-8");
 }
-async function ensureShardSchema(client) {
-  await client.execute("PRAGMA journal_mode = WAL");
-  await client.execute("PRAGMA busy_timeout = 30000");
+function loadEmployeesSync(employeesPath = EMPLOYEES_PATH) {
+  if (!existsSync6(employeesPath)) return [];
   try {
-    await client.execute("PRAGMA libsql_vector_search_ef = 128");
+    return JSON.parse(readFileSync5(employeesPath, "utf-8"));
   } catch {
+    return [];
   }
-  await client.executeMultiple(`
-    CREATE TABLE IF NOT EXISTS memories (
-      id            TEXT PRIMARY KEY,
-      agent_id      TEXT NOT NULL,
-      agent_role    TEXT NOT NULL,
-      session_id    TEXT NOT NULL,
-      timestamp     TEXT NOT NULL,
-      tool_name     TEXT NOT NULL,
-      project_name  TEXT NOT NULL,
-      has_error     INTEGER NOT NULL DEFAULT 0,
-      raw_text      TEXT NOT NULL,
-      vector        F32_BLOB(1024),
-      version       INTEGER NOT NULL DEFAULT 0
-    );
-
-    CREATE INDEX IF NOT EXISTS idx_memories_agent ON memories(agent_id);
-    CREATE INDEX IF NOT EXISTS idx_memories_timestamp ON memories(timestamp);
-    CREATE INDEX IF NOT EXISTS idx_memories_agent_project ON memories(agent_id, project_name);
-  `);
-  await client.executeMultiple(`
-    CREATE VIRTUAL TABLE IF NOT EXISTS memories_fts USING fts5(
-      raw_text,
-      content='memories',
-      content_rowid='rowid'
-    );
-
-    CREATE TRIGGER IF NOT EXISTS memories_fts_ai AFTER INSERT ON memories BEGIN
-      INSERT INTO memories_fts(rowid, raw_text) VALUES (new.rowid, new.raw_text);
-    END;
-
-    CREATE TRIGGER IF NOT EXISTS memories_fts_ad AFTER DELETE ON memories BEGIN
-      INSERT INTO memories_fts(memories_fts, rowid, raw_text) VALUES('delete', old.rowid, old.raw_text);
-    END;
-
-    CREATE TRIGGER IF NOT EXISTS memories_fts_au AFTER UPDATE ON memories BEGIN
-      INSERT INTO memories_fts(memories_fts, rowid, raw_text) VALUES('delete', old.rowid, old.raw_text);
-      INSERT INTO memories_fts(rowid, raw_text) VALUES (new.rowid, new.raw_text);
-    END;
-  `);
-  for (const col of [
-    "ALTER TABLE memories ADD COLUMN task_id TEXT",
-    "ALTER TABLE memories ADD COLUMN consolidated INTEGER NOT NULL DEFAULT 0",
-    "ALTER TABLE memories ADD COLUMN author_device_id TEXT",
-    "ALTER TABLE memories ADD COLUMN scope TEXT NOT NULL DEFAULT 'business'",
-    "ALTER TABLE memories ADD COLUMN importance INTEGER DEFAULT 5",
-    "ALTER TABLE memories ADD COLUMN status TEXT DEFAULT 'active'",
-    "ALTER TABLE memories ADD COLUMN wiki_synced INTEGER DEFAULT 0",
-    "ALTER TABLE memories ADD COLUMN graph_extracted INTEGER DEFAULT 0",
-    "ALTER TABLE memories ADD COLUMN content_hash TEXT",
-    "ALTER TABLE memories ADD COLUMN graph_extracted_hash TEXT",
-    "ALTER TABLE memories ADD COLUMN confidence REAL DEFAULT 0.7",
-    "ALTER TABLE memories ADD COLUMN last_accessed TEXT",
-    // Wiki linkage columns (must match database.ts)
-    "ALTER TABLE memories ADD COLUMN workspace_id TEXT",
-    "ALTER TABLE memories ADD COLUMN document_id TEXT",
-    "ALTER TABLE memories ADD COLUMN user_id TEXT",
-    "ALTER TABLE memories ADD COLUMN char_offset INTEGER",
-    "ALTER TABLE memories ADD COLUMN page_number INTEGER",
-    // Source provenance columns (must match database.ts)
-    "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",
-    // 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",
-    // 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);
-    } catch {
-    }
+}
+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 baseAgentName(name, employees) {
+  const match = name.match(/^([a-zA-Z]+)\d+$/);
+  if (!match) return name;
+  const base = match[1];
+  const roster = employees ?? loadEmployeesSync();
+  if (getEmployee(roster, base)) return base;
+  return name;
+}
+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`);
   }
-  for (const idx of [
-    "CREATE INDEX IF NOT EXISTS idx_memories_tier ON memories(tier)",
-    "CREATE INDEX IF NOT EXISTS idx_memories_supersedes ON memories(supersedes_id) WHERE supersedes_id IS NOT NULL"
-  ]) {
-    try {
-      await client.execute(idx);
-    } catch {
-    }
+  return [...employees, normalized];
+}
+function appendToCoordinatorTeam(employee) {
+  const coordinator = getCoordinatorEmployee(loadEmployeesSync());
+  if (!coordinator) return;
+  const idPath = path5.join(IDENTITY_DIR, `${coordinator.name}.md`);
+  if (!existsSync6(idPath)) return;
+  const content = readFileSync5(idPath, "utf-8");
+  if (content.includes(`**${capitalize(employee.name)}`)) return;
+  const teamMatch = content.match(TEAM_SECTION_RE);
+  if (!teamMatch || teamMatch.index === void 0) return;
+  const afterTeam = content.slice(teamMatch.index + teamMatch[0].length);
+  const nextHeading = afterTeam.match(/\n## /);
+  const entry = `
+**${capitalize(employee.name)} (${employee.role}):** Newly hired. Update this description as the role develops.
+`;
+  let updated;
+  if (nextHeading && nextHeading.index !== void 0) {
+    const insertAt = teamMatch.index + teamMatch[0].length + nextHeading.index;
+    updated = content.slice(0, insertAt) + entry + content.slice(insertAt);
+  } else {
+    updated = content.trimEnd() + "\n" + entry;
   }
+  writeFileSync4(idPath, updated, "utf-8");
+}
+function capitalize(s) {
+  return s.charAt(0).toUpperCase() + s.slice(1);
+}
+async function hireEmployee(employee) {
+  const employees = await loadEmployees();
+  const updated = addEmployee(employees, employee);
+  await saveEmployees(updated);
   try {
-    await client.execute("CREATE INDEX IF NOT EXISTS idx_memories_status ON memories(status)");
+    appendToCoordinatorTeam(employee);
   } catch {
   }
-  for (const idx of [
-    "CREATE INDEX IF NOT EXISTS idx_memories_workspace ON memories(workspace_id)",
-    "CREATE INDEX IF NOT EXISTS idx_memories_document ON memories(document_id)",
-    "CREATE INDEX IF NOT EXISTS idx_memories_user ON memories(user_id)"
-  ]) {
-    try {
-      await client.execute(idx);
-    } catch {
-    }
-  }
-  await client.executeMultiple(`
-    CREATE TABLE IF NOT EXISTS entities (
-      id TEXT PRIMARY KEY,
-      name TEXT NOT NULL,
-      type TEXT NOT NULL,
-      first_seen TEXT NOT NULL,
-      last_seen TEXT NOT NULL,
-      properties TEXT DEFAULT '{}',
-      UNIQUE(name, type)
-    );
-
-    CREATE TABLE IF NOT EXISTS relationships (
-      id TEXT PRIMARY KEY,
-      source_entity_id TEXT NOT NULL,
-      target_entity_id TEXT NOT NULL,
-      type TEXT NOT NULL,
-      weight REAL DEFAULT 1.0,
-      timestamp TEXT NOT NULL,
-      properties TEXT DEFAULT '{}',
-      UNIQUE(source_entity_id, target_entity_id, type)
-    );
-
-    CREATE TABLE IF NOT EXISTS entity_memories (
-      entity_id TEXT NOT NULL,
-      memory_id TEXT NOT NULL,
-      PRIMARY KEY (entity_id, memory_id)
-    );
-
-    CREATE TABLE IF NOT EXISTS relationship_memories (
-      relationship_id TEXT NOT NULL,
-      memory_id TEXT NOT NULL,
-      PRIMARY KEY (relationship_id, memory_id)
-    );
-
-    CREATE INDEX IF NOT EXISTS idx_entities_name ON entities(name);
-    CREATE INDEX IF NOT EXISTS idx_entities_type ON entities(type);
-    CREATE INDEX IF NOT EXISTS idx_relationships_source ON relationships(source_entity_id);
-    CREATE INDEX IF NOT EXISTS idx_relationships_target ON relationships(target_entity_id);
-    CREATE INDEX IF NOT EXISTS idx_relationships_type ON relationships(type);
-
-    CREATE TABLE IF NOT EXISTS hyperedges (
-      id TEXT PRIMARY KEY,
-      label TEXT NOT NULL,
-      relation TEXT NOT NULL,
-      confidence REAL DEFAULT 1.0,
-      timestamp TEXT NOT NULL
-    );
-
-    CREATE TABLE IF NOT EXISTS hyperedge_nodes (
-      hyperedge_id TEXT NOT NULL,
-      entity_id TEXT NOT NULL,
-      PRIMARY KEY (hyperedge_id, entity_id)
-    );
-  `);
-  for (const col of [
-    "ALTER TABLE relationships ADD COLUMN confidence REAL DEFAULT 1.0",
-    "ALTER TABLE relationships ADD COLUMN confidence_label TEXT DEFAULT 'extracted'"
-  ]) {
-    try {
-      await client.execute(col);
-    } catch {
+  try {
+    const { loadAgentConfig: loadAgentConfig2, saveAgentConfig: saveAgentConfig2 } = await Promise.resolve().then(() => (init_agent_config(), agent_config_exports));
+    const config2 = loadAgentConfig2();
+    const name = employee.name.toLowerCase();
+    if (!config2[name] && config2["default"]) {
+      config2[name] = { ...config2["default"] };
+      saveAgentConfig2(config2);
     }
+  } catch {
   }
+  return updated;
 }
-async function getReadyShardClient(projectName) {
-  const client = getShardClient(projectName);
-  await ensureShardSchema(client);
-  return client;
-}
-function evictLRU() {
-  let oldest = null;
-  let oldestTime = Infinity;
-  for (const [name, time] of _shardLastAccess) {
-    if (time < oldestTime) {
-      oldestTime = time;
-      oldest = name;
+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(os2.homedir(), ".exe-os", "identity");
+        const oldPath = path5.join(identityDir, `${oldName}.md`);
+        const newPath = path5.join(identityDir, `${emp.name}.md`);
+        if (existsSync6(oldPath) && !existsSync6(newPath)) {
+          renameSync2(oldPath, newPath);
+        } else if (existsSync6(oldPath) && oldPath !== newPath) {
+          const content = readFileSync5(oldPath, "utf-8");
+          writeFileSync4(newPath, content, "utf-8");
+          if (oldPath.toLowerCase() !== newPath.toLowerCase()) {
+            unlinkSync(oldPath);
+          }
+        }
+      } catch {
+      }
     }
   }
-  if (oldest) {
-    const client = _shards.get(oldest);
-    if (client) {
-      client.close();
-    }
-    _shards.delete(oldest);
-    _shardLastAccess.delete(oldest);
+  if (changed) {
+    await saveEmployees(employees, rosterPath);
   }
+  return changed;
 }
-function evictIdleShards() {
-  const now = Date.now();
-  const toEvict = [];
-  for (const [name, lastAccess] of _shardLastAccess) {
-    if (now - lastAccess > SHARD_IDLE_MS) {
-      toEvict.push(name);
-    }
-  }
-  for (const name of toEvict) {
-    const client = _shards.get(name);
-    if (client) {
-      client.close();
-    }
-    _shards.delete(name);
-    _shardLastAccess.delete(name);
-  }
-}
-function getOpenShardCount() {
-  return _shards.size;
-}
-function disposeShards() {
-  if (_evictionTimer) {
-    clearInterval(_evictionTimer);
-    _evictionTimer = null;
-  }
-  for (const [, client] of _shards) {
-    client.close();
+function findExeBin() {
+  try {
+    return execSync(process.platform === "win32" ? "where exe-os" : "which exe-os", { encoding: "utf8" }).trim();
+  } catch {
+    return null;
   }
-  _shards.clear();
-  _shardLastAccess.clear();
-  _shardingEnabled = false;
-  _encryptionKey = null;
 }
-var SHARDS_DIR, SHARD_IDLE_MS, MAX_OPEN_SHARDS, EVICTION_INTERVAL_MS, _shards, _shardLastAccess, _evictionTimer, _encryptionKey, _shardingEnabled;
-var init_shard_manager = __esm({
-  "src/lib/shard-manager.ts"() {
-    "use strict";
-    init_config();
-    SHARDS_DIR = path5.join(EXE_AI_DIR, "shards");
-    SHARD_IDLE_MS = 5 * 60 * 1e3;
-    MAX_OPEN_SHARDS = 10;
-    EVICTION_INTERVAL_MS = 60 * 1e3;
-    _shards = /* @__PURE__ */ new Map();
-    _shardLastAccess = /* @__PURE__ */ new Map();
-    _evictionTimer = null;
-    _encryptionKey = null;
-    _shardingEnabled = false;
+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 };
   }
-});
-
-// src/lib/db-retry.ts
-function isBusyError(err) {
-  if (err instanceof Error) {
-    const msg = err.message.toLowerCase();
-    return msg.includes("sqlite_busy") || msg.includes("database is locked");
+  const binDir = path5.dirname(exeBinPath);
+  let target;
+  try {
+    target = readlinkSync(exeBinPath);
+  } catch {
+    errors.push("Could not read 'exe' symlink");
+    return { created, skipped, errors };
   }
-  return false;
-}
-function delay(ms) {
-  return new Promise((resolve) => setTimeout(resolve, ms));
-}
-async function retryOnBusy(fn, label) {
-  let lastError;
-  for (let attempt = 0; attempt <= MAX_RETRIES; attempt++) {
+  for (const suffix of ["", "-opencode"]) {
+    const linkName = `${name}${suffix}`;
+    const linkPath = path5.join(binDir, linkName);
+    if (existsSync6(linkPath)) {
+      skipped.push(linkName);
+      continue;
+    }
     try {
-      return await fn();
+      symlinkSync(target, linkPath);
+      created.push(linkName);
     } catch (err) {
-      lastError = err;
-      if (!isBusyError(err) || attempt === MAX_RETRIES) {
-        throw err;
-      }
-      const backoff = BASE_DELAY_MS * Math.pow(2, attempt);
-      const jitter = Math.floor(Math.random() * MAX_JITTER_MS);
-      process.stderr.write(
-        `[exe-os] SQLITE_BUSY ${label} retry ${attempt + 1}/${MAX_RETRIES} \u2014 waiting ${backoff + jitter}ms
-`
-      );
-      await delay(backoff + jitter);
+      errors.push(`${linkName}: ${err instanceof Error ? err.message : String(err)}`);
     }
   }
-  throw lastError;
-}
-function wrapWithRetry(client) {
-  return new Proxy(client, {
-    get(target, prop, receiver) {
-      if (prop === "execute") {
-        return (sql) => retryOnBusy(() => target.execute(sql), "execute");
-      }
-      if (prop === "batch") {
-        return (stmts, mode) => retryOnBusy(() => target.batch(stmts, mode), "batch");
-      }
-      return Reflect.get(target, prop, receiver);
-    }
-  });
+  return { created, skipped, errors };
 }
-var MAX_RETRIES, BASE_DELAY_MS, MAX_JITTER_MS;
-var init_db_retry = __esm({
-  "src/lib/db-retry.ts"() {
-    "use strict";
-    MAX_RETRIES = 5;
-    BASE_DELAY_MS = 250;
-    MAX_JITTER_MS = 400;
-  }
-});
-
-// src/lib/runtime-table.ts
-var RUNTIME_TABLE, DEFAULT_RUNTIME;
-var init_runtime_table = __esm({
-  "src/lib/runtime-table.ts"() {
+var EMPLOYEES_PATH, DEFAULT_COORDINATOR_TEMPLATE_NAME, COORDINATOR_ROLE, MULTI_INSTANCE_ROLES, IDENTITY_DIR, TEAM_SECTION_RE;
+var init_employees = __esm({
+  "src/lib/employees.ts"() {
     "use strict";
-    RUNTIME_TABLE = {
-      codex: {
-        binary: "codex",
-        launchMode: "interactive",
-        autoApproveFlag: "--dangerously-bypass-approvals-and-sandbox",
-        inlineFlag: "--no-alt-screen",
-        apiKeyEnv: "OPENAI_API_KEY",
-        defaultModel: "gpt-5.5"
-      },
-      opencode: {
-        binary: "opencode",
-        launchMode: "exec",
-        autoApproveFlag: "--dangerously-skip-permissions",
-        inlineFlag: "",
-        apiKeyEnv: "ANTHROPIC_API_KEY",
-        defaultModel: "anthropic/claude-sonnet-4-6"
-      }
-    };
-    DEFAULT_RUNTIME = "claude";
+    init_config();
+    EMPLOYEES_PATH = path5.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"]);
+    IDENTITY_DIR = path5.join(EXE_AI_DIR, "identity");
+    TEAM_SECTION_RE = /^## Team\b.*$/m;
   }
 });
 
-// src/lib/agent-config.ts
-var agent_config_exports = {};
-__export(agent_config_exports, {
-  AGENT_CONFIG_PATH: () => AGENT_CONFIG_PATH,
-  DEFAULT_MODELS: () => DEFAULT_MODELS,
-  KNOWN_RUNTIMES: () => KNOWN_RUNTIMES,
-  RUNTIME_LABELS: () => RUNTIME_LABELS,
-  clearAgentRuntime: () => clearAgentRuntime,
-  getAgentRuntime: () => getAgentRuntime,
-  loadAgentConfig: () => loadAgentConfig,
-  saveAgentConfig: () => saveAgentConfig,
-  setAgentRuntime: () => setAgentRuntime
-});
-import { readFileSync as readFileSync4, writeFileSync as writeFileSync3, existsSync as existsSync7 } from "fs";
+// src/lib/database-adapter.ts
+import os3 from "os";
 import path6 from "path";
-function loadAgentConfig() {
-  if (!existsSync7(AGENT_CONFIG_PATH)) return {};
-  try {
-    return JSON.parse(readFileSync4(AGENT_CONFIG_PATH, "utf-8"));
-  } catch {
-    return {};
-  }
+import { createRequire } from "module";
+import { pathToFileURL } from "url";
+function quotedIdentifier(identifier) {
+  return `"${identifier.replace(/"/g, '""')}"`;
 }
-function saveAgentConfig(config2) {
-  const dir = path6.dirname(AGENT_CONFIG_PATH);
-  ensurePrivateDirSync(dir);
-  writeFileSync3(AGENT_CONFIG_PATH, JSON.stringify(config2, null, 2) + "\n", "utf-8");
-  enforcePrivateFileSync(AGENT_CONFIG_PATH);
+function unqualifiedTableName(name) {
+  const raw = name.trim().replace(/^"|"$/g, "");
+  const parts = raw.split(".");
+  return parts[parts.length - 1].replace(/^"|"$/g, "").toLowerCase();
 }
-function getAgentRuntime(agentId) {
-  const config2 = loadAgentConfig();
-  const entry = config2[agentId];
-  if (entry) return entry;
-  const orgDefault = config2["default"];
-  if (orgDefault) return orgDefault;
-  return { runtime: DEFAULT_RUNTIME, model: DEFAULT_MODELS[DEFAULT_RUNTIME] };
+function stripTrailingSemicolon(sql) {
+  return sql.trim().replace(/;+\s*$/u, "");
 }
-function setAgentRuntime(agentId, runtime, model, reasoning_effort) {
-  const knownModels = KNOWN_RUNTIMES[runtime];
-  if (!knownModels) {
-    return {
-      ok: false,
-      error: `Unknown runtime "${runtime}". Valid: ${Object.keys(KNOWN_RUNTIMES).join(", ")}`
-    };
+function appendClause(sql, clause) {
+  const trimmed = stripTrailingSemicolon(sql);
+  const returningMatch = /\sRETURNING\b[\s\S]*$/iu.exec(trimmed);
+  if (!returningMatch) {
+    return `${trimmed}${clause}`;
   }
-  if (!knownModels.includes(model)) {
-    return {
-      ok: false,
-      error: `Unknown model "${model}" for runtime "${runtime}". Valid: ${knownModels.join(", ")}`
-    };
+  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 config2 = loadAgentConfig();
-  const entry = { runtime, model };
-  if (reasoning_effort) entry.reasoning_effort = reasoning_effort;
-  config2[agentId] = entry;
-  saveAgentConfig(config2);
-  return { ok: true };
+  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 clearAgentRuntime(agentId) {
-  const config2 = loadAgentConfig();
-  delete config2[agentId];
-  saveAgentConfig(config2);
+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;
 }
-var AGENT_CONFIG_PATH, KNOWN_RUNTIMES, RUNTIME_LABELS, DEFAULT_MODELS;
-var init_agent_config = __esm({
-  "src/lib/agent-config.ts"() {
-    "use strict";
-    init_config();
-    init_runtime_table();
-    init_secure_files();
-    AGENT_CONFIG_PATH = path6.join(EXE_AI_DIR, "agent-config.json");
-    KNOWN_RUNTIMES = {
-      claude: ["claude-opus-4.6", "claude-opus-4", "claude-sonnet-4.6", "claude-sonnet-4", "claude-haiku-4.5"],
-      codex: ["gpt-5.4", "gpt-5.5", "gpt-5.3-codex-spark", "o3", "o4-mini"],
-      opencode: ["anthropic/claude-sonnet-4-6", "openai/gpt-5.4", "google/gemini-2.5-pro", "deepseek/deepseek-r3", "minimax/minimax-m2.5"]
-    };
-    RUNTIME_LABELS = {
-      claude: "Claude Code (Anthropic)",
-      codex: "Codex (OpenAI)",
-      opencode: "OpenCode (open source)"
-    };
-    DEFAULT_MODELS = {
-      claude: "claude-opus-4.6",
-      codex: RUNTIME_TABLE.codex?.defaultModel ?? "gpt-5.4",
-      opencode: RUNTIME_TABLE.opencode?.defaultModel ?? "anthropic/claude-sonnet-4-6"
-    };
-  }
-});
-
-// 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,
-  baseAgentName: () => baseAgentName,
-  canCoordinate: () => canCoordinate,
-  getCoordinatorEmployee: () => getCoordinatorEmployee,
-  getCoordinatorName: () => getCoordinatorName,
-  getEmployee: () => getEmployee,
-  getEmployeeByRole: () => getEmployeeByRole,
-  getEmployeeNamesByRole: () => getEmployeeNamesByRole,
-  hasRole: () => hasRole,
-  hireEmployee: () => hireEmployee,
-  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 existsSync8, symlinkSync, readlinkSync, readFileSync as readFileSync5, renameSync as renameSync2, unlinkSync, writeFileSync as writeFileSync4 } from "fs";
-import { execSync } from "child_process";
-import path7 from "path";
-import os3 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"
-    };
+function rewriteInsertOrIgnore(sql) {
+  if (!/^\s*INSERT\s+OR\s+IGNORE\s+INTO\b/iu.test(sql)) {
+    return sql;
   }
-  return { valid: true };
+  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");
 }
-async function loadEmployees(employeesPath = EMPLOYEES_PATH) {
-  if (!existsSync8(employeesPath)) {
-    return [];
+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 raw = await readFile2(employeesPath, "utf-8");
-  try {
-    return JSON.parse(raw);
-  } catch {
-    return [];
+  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}`)}`;
 }
-async function saveEmployees(employees, employeesPath = EMPLOYEES_PATH) {
-  await mkdir2(path7.dirname(employeesPath), { recursive: true });
-  await writeFile2(employeesPath, JSON.stringify(employees, null, 2) + "\n", "utf-8");
+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 loadEmployeesSync(employeesPath = EMPLOYEES_PATH) {
-  if (!existsSync8(employeesPath)) return [];
-  try {
-    return JSON.parse(readFileSync5(employeesPath, "utf-8"));
-  } catch {
-    return [];
+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 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 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 hasRole(agentName, role) {
-  const employees = loadEmployeesSync();
-  const emp = getEmployee(employees, agentName);
-  return emp ? emp.role.toLowerCase() === role.toLowerCase() : false;
+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 baseAgentName(name, employees) {
-  const match = name.match(/^([a-zA-Z]+)\d+$/);
-  if (!match) return name;
-  const base = match[1];
-  const roster = employees ?? loadEmployeesSync();
-  if (getEmployee(roster, base)) return base;
-  return name;
+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 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 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 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`);
+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 [...employees, normalized];
+  return nextArgs;
 }
-function appendToCoordinatorTeam(employee) {
-  const coordinator = getCoordinatorEmployee(loadEmployeesSync());
-  if (!coordinator) return;
-  const idPath = path7.join(IDENTITY_DIR, `${coordinator.name}.md`);
-  if (!existsSync8(idPath)) return;
-  const content = readFileSync5(idPath, "utf-8");
-  if (content.includes(`**${capitalize(employee.name)}`)) return;
-  const teamMatch = content.match(TEAM_SECTION_RE);
-  if (!teamMatch || teamMatch.index === void 0) return;
-  const afterTeam = content.slice(teamMatch.index + teamMatch[0].length);
-  const nextHeading = afterTeam.match(/\n## /);
-  const entry = `
-**${capitalize(employee.name)} (${employee.role}):** Newly hired. Update this description as the role develops.
-`;
-  let updated;
-  if (nextHeading && nextHeading.index !== void 0) {
-    const insertAt = teamMatch.index + teamMatch[0].length + nextHeading.index;
-    updated = content.slice(0, insertAt) + entry + content.slice(insertAt);
-  } else {
-    updated = content.trimEnd() + "\n" + entry;
-  }
-  writeFileSync4(idPath, updated, "utf-8");
-}
-function capitalize(s) {
-  return s.charAt(0).toUpperCase() + s.slice(1);
-}
-async function hireEmployee(employee) {
-  const employees = await loadEmployees();
-  const updated = addEmployee(employees, employee);
-  await saveEmployees(updated);
-  try {
-    appendToCoordinatorTeam(employee);
-  } catch {
-  }
-  try {
-    const { loadAgentConfig: loadAgentConfig2, saveAgentConfig: saveAgentConfig2 } = await Promise.resolve().then(() => (init_agent_config(), agent_config_exports));
-    const config2 = loadAgentConfig2();
-    const name = employee.name.toLowerCase();
-    if (!config2[name] && config2["default"]) {
-      config2[name] = { ...config2["default"] };
-      saveAgentConfig2(config2);
-    }
-  } catch {
-  }
-  return updated;
-}
-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 = path7.join(os3.homedir(), ".exe-os", "identity");
-        const oldPath = path7.join(identityDir, `${oldName}.md`);
-        const newPath = path7.join(identityDir, `${emp.name}.md`);
-        if (existsSync8(oldPath) && !existsSync8(newPath)) {
-          renameSync2(oldPath, newPath);
-        } else if (existsSync8(oldPath) && oldPath !== newPath) {
-          const content = readFileSync5(oldPath, "utf-8");
-          writeFileSync4(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 = path7.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 = path7.join(binDir, linkName);
-    if (existsSync8(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, IDENTITY_DIR, TEAM_SECTION_RE;
-var init_employees = __esm({
-  "src/lib/employees.ts"() {
-    "use strict";
-    init_config();
-    EMPLOYEES_PATH = path7.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"]);
-    IDENTITY_DIR = path7.join(EXE_AI_DIR, "identity");
-    TEAM_SECTION_RE = /^## Team\b.*$/m;
-  }
-});
-
-// src/lib/database-adapter.ts
-import os4 from "os";
-import path8 from "path";
-import { createRequire as createRequire2 } from "module";
-import { pathToFileURL as pathToFileURL2 } 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;
+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 < end; i++) {
+  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 === "?") {
-      count += 1;
+      placeholder += 1;
+      out += `$${placeholder}`;
+      continue;
     }
+    out += ch;
   }
-  return count;
+  return out;
 }
-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));
-    }
+function translateStatementForPostgres(stmt) {
+  const normalized = normalizeStatement(stmt);
+  if (normalized.kind === "named") {
+    throw new Error("Named SQL parameters are not supported by the Prisma adapter.");
   }
-  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
-  };
+  const rewrittenSql = rewriteSql(normalized.sql);
+  const coercedArgs = coerceBooleanArgs(rewrittenSql, normalized.args);
+  return {
+    sql: convertQuestionMarksToDollarParams(rewrittenSql),
+    args: coercedArgs
+  };
 }
 function shouldBypassPostgres(stmt) {
   const normalized = normalizeStatement(stmt);
@@ -1740,17 +1169,17 @@ async function loadPrismaClient() {
     prismaClientPromise = (async () => {
       const explicitPath = process.env.EXE_OS_PRISMA_CLIENT_PATH;
       if (explicitPath) {
-        const module2 = await import(pathToFileURL2(explicitPath).href);
+        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 ?? path8.join(os4.homedir(), "exe-db");
-      const requireFromExeDb = createRequire2(path8.join(exeDbRoot, "package.json"));
+      const exeDbRoot = process.env.EXE_DB_ROOT ?? path6.join(os3.homedir(), "exe-db");
+      const requireFromExeDb = createRequire(path6.join(exeDbRoot, "package.json"));
       const prismaEntry = requireFromExeDb.resolve("@prisma/client");
-      const module = await import(pathToFileURL2(prismaEntry).href);
+      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}`);
@@ -2031,11 +1460,11 @@ __export(exe_daemon_client_exports, {
   sendIngestRequest: () => sendIngestRequest
 });
 import net from "net";
-import os5 from "os";
+import os4 from "os";
 import { spawn } from "child_process";
 import { randomUUID } from "crypto";
-import { existsSync as existsSync9, unlinkSync as unlinkSync2, readFileSync as readFileSync6, openSync, closeSync, statSync } from "fs";
-import path9 from "path";
+import { existsSync as existsSync7, unlinkSync as unlinkSync2, readFileSync as readFileSync6, openSync, closeSync, statSync } from "fs";
+import path7 from "path";
 import { fileURLToPath } from "url";
 function handleData(chunk) {
   _buffer += chunk.toString();
@@ -2063,7 +1492,7 @@ function handleData(chunk) {
   }
 }
 function cleanupStaleFiles() {
-  if (existsSync9(PID_PATH)) {
+  if (existsSync7(PID_PATH)) {
     try {
       const pid = parseInt(readFileSync6(PID_PATH, "utf8").trim(), 10);
       if (pid > 0) {
@@ -2086,11 +1515,11 @@ function cleanupStaleFiles() {
   }
 }
 function findPackageRoot() {
-  let dir = path9.dirname(fileURLToPath(import.meta.url));
-  const { root } = path9.parse(dir);
+  let dir = path7.dirname(fileURLToPath(import.meta.url));
+  const { root } = path7.parse(dir);
   while (dir !== root) {
-    if (existsSync9(path9.join(dir, "package.json"))) return dir;
-    dir = path9.dirname(dir);
+    if (existsSync7(path7.join(dir, "package.json"))) return dir;
+    dir = path7.dirname(dir);
   }
   return null;
 }
@@ -2110,14 +1539,14 @@ function getAvailableMemoryGB() {
       const speculativePages = speculative ? parseInt(speculative[1], 10) : 0;
       return (freePages + inactivePages + speculativePages) * actualPageSize / (1024 * 1024 * 1024);
     } catch {
-      return os5.freemem() / (1024 * 1024 * 1024);
+      return os4.freemem() / (1024 * 1024 * 1024);
     }
   }
-  return os5.freemem() / (1024 * 1024 * 1024);
+  return os4.freemem() / (1024 * 1024 * 1024);
 }
 function spawnDaemon() {
   const freeGB = getAvailableMemoryGB();
-  const totalGB = os5.totalmem() / (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.
@@ -2137,8 +1566,8 @@ function spawnDaemon() {
     process.stderr.write("[exed-client] WARN: cannot find package root\n");
     return;
   }
-  const daemonPath = path9.join(pkgRoot, "dist", "lib", "exe-daemon.js");
-  if (!existsSync9(daemonPath)) {
+  const daemonPath = path7.join(pkgRoot, "dist", "lib", "exe-daemon.js");
+  if (!existsSync7(daemonPath)) {
     process.stderr.write(`[exed-client] WARN: daemon script not found at ${daemonPath}
 `);
     return;
@@ -2147,7 +1576,7 @@ function spawnDaemon() {
   const daemonToken = ensureDaemonToken(process.env[DAEMON_TOKEN_ENV] ?? null);
   process.stderr.write(`[exed-client] Spawning daemon: ${resolvedPath}
 `);
-  const logPath = path9.join(path9.dirname(SOCKET_PATH), "exed.log");
+  const logPath = path7.join(path7.dirname(SOCKET_PATH), "exed.log");
   let stderrFd = "ignore";
   try {
     stderrFd = openSync(logPath, "a");
@@ -2312,7 +1741,7 @@ function killAndRespawnDaemon() {
   }
   try {
     process.stderr.write("[exed-client] Killing daemon for restart...\n");
-    if (existsSync9(PID_PATH)) {
+    if (existsSync7(PID_PATH)) {
       try {
         const pid = parseInt(readFileSync6(PID_PATH, "utf8").trim(), 10);
         if (pid > 0) {
@@ -2460,9 +1889,9 @@ var init_exe_daemon_client = __esm({
     "use strict";
     init_config();
     init_daemon_auth();
-    SOCKET_PATH = process.env.EXE_DAEMON_SOCK ?? process.env.EXE_EMBED_SOCK ?? path9.join(EXE_AI_DIR, "exed.sock");
-    PID_PATH = process.env.EXE_DAEMON_PID ?? process.env.EXE_EMBED_PID ?? path9.join(EXE_AI_DIR, "exed.pid");
-    SPAWN_LOCK_PATH = path9.join(EXE_AI_DIR, "exed-spawn.lock");
+    SOCKET_PATH = process.env.EXE_DAEMON_SOCK ?? process.env.EXE_EMBED_SOCK ?? path7.join(EXE_AI_DIR, "exed.sock");
+    PID_PATH = process.env.EXE_DAEMON_PID ?? process.env.EXE_EMBED_PID ?? path7.join(EXE_AI_DIR, "exed.pid");
+    SPAWN_LOCK_PATH = path7.join(EXE_AI_DIR, "exed-spawn.lock");
     SPAWN_LOCK_STALE_MS = 3e4;
     CONNECT_TIMEOUT_MS = 15e3;
     REQUEST_TIMEOUT_MS = 3e4;
@@ -2631,7 +2060,7 @@ __export(database_exports, {
   isInitialized: () => isInitialized,
   setExternalClient: () => setExternalClient
 });
-import { createClient as createClient2 } from "@libsql/client";
+import { createClient } from "@libsql/client";
 async function initDatabase(config2) {
   if (_walCheckpointTimer) {
     clearInterval(_walCheckpointTimer);
@@ -2656,7 +2085,7 @@ async function initDatabase(config2) {
   if (config2.encryptionKey) {
     opts.encryptionKey = config2.encryptionKey;
   }
-  _client = createClient2(opts);
+  _client = createClient(opts);
   _resilientClient = wrapWithRetry(_client);
   _adapterClient = _resilientClient;
   _client.execute("PRAGMA busy_timeout = 30000").catch(() => {
@@ -3246,6 +2675,14 @@ async function ensureSchema() {
     );
   } catch {
   }
+  try {
+    await client.execute(
+      `CREATE INDEX IF NOT EXISTS idx_memories_scoped_content_hash
+         ON memories(content_hash, agent_id, project_name, memory_type)
+         WHERE content_hash IS NOT NULL`
+    );
+  } catch {
+  }
   await client.executeMultiple(`
     CREATE TABLE IF NOT EXISTS entities (
       id TEXT PRIMARY KEY,
@@ -3526,164 +2963,812 @@ async function ensureSchema() {
       PRIMARY KEY (session_uuid, file_path)
     );
 
-    CREATE INDEX IF NOT EXISTS idx_agent_file_reads_agent_read_at
-      ON agent_file_reads(agent_id, read_at);
-  `);
-  try {
-    const mapCount = await client.execute({ sql: `SELECT COUNT(*) as cnt FROM session_agent_map`, args: [] });
-    if (Number(mapCount.rows[0]?.cnt ?? 0) === 0) {
-      await client.execute({
-        sql: `INSERT OR IGNORE INTO session_agent_map (session_uuid, agent_id, session_name, started_at)
-              SELECT session_id, agent_id, '', MIN(timestamp)
-              FROM memories
-              WHERE session_id IS NOT NULL AND session_id != '' AND agent_id IS NOT NULL AND agent_id != ''
-              GROUP BY session_id, agent_id`,
-        args: []
-      });
-    }
-  } catch {
+    CREATE INDEX IF NOT EXISTS idx_agent_file_reads_agent_read_at
+      ON agent_file_reads(agent_id, read_at);
+  `);
+  try {
+    const mapCount = await client.execute({ sql: `SELECT COUNT(*) as cnt FROM session_agent_map`, args: [] });
+    if (Number(mapCount.rows[0]?.cnt ?? 0) === 0) {
+      await client.execute({
+        sql: `INSERT OR IGNORE INTO session_agent_map (session_uuid, agent_id, session_name, started_at)
+              SELECT session_id, agent_id, '', MIN(timestamp)
+              FROM memories
+              WHERE session_id IS NOT NULL AND session_id != '' AND agent_id IS NOT NULL AND agent_id != ''
+              GROUP BY session_id, agent_id`,
+        args: []
+      });
+    }
+  } catch {
+  }
+  try {
+    await client.execute({
+      sql: `ALTER TABLE session_agent_map ADD COLUMN cache_cold_count INTEGER NOT NULL DEFAULT 0`,
+      args: []
+    });
+  } catch {
+  }
+  try {
+    await client.execute({
+      sql: `ALTER TABLE tasks ADD COLUMN budget_tokens INTEGER`,
+      args: []
+    });
+  } catch {
+  }
+  try {
+    await client.execute({
+      sql: `ALTER TABLE tasks ADD COLUMN budget_fallback_model TEXT`,
+      args: []
+    });
+  } catch {
+  }
+  try {
+    await client.execute({
+      sql: `ALTER TABLE tasks ADD COLUMN tokens_used INTEGER DEFAULT 0`,
+      args: []
+    });
+  } catch {
+  }
+  try {
+    await client.execute({
+      sql: `ALTER TABLE tasks ADD COLUMN tokens_warned_at INTEGER`,
+      args: []
+    });
+  } catch {
+  }
+  await client.executeMultiple(`
+    CREATE VIRTUAL TABLE IF NOT EXISTS conversations_fts USING fts5(
+      content_text,
+      sender_name,
+      agent_response,
+      content='conversations',
+      content_rowid='rowid'
+    );
+
+    CREATE TRIGGER IF NOT EXISTS conversations_fts_ai AFTER INSERT ON conversations BEGIN
+      INSERT INTO conversations_fts(rowid, content_text, sender_name, agent_response)
+      VALUES (new.rowid, new.content_text, new.sender_name, new.agent_response);
+    END;
+
+    CREATE TRIGGER IF NOT EXISTS conversations_fts_ad AFTER DELETE ON conversations BEGIN
+      INSERT INTO conversations_fts(conversations_fts, rowid, content_text, sender_name, agent_response)
+      VALUES('delete', old.rowid, old.content_text, old.sender_name, old.agent_response);
+    END;
+
+    CREATE TRIGGER IF NOT EXISTS conversations_fts_au AFTER UPDATE ON conversations BEGIN
+      INSERT INTO conversations_fts(conversations_fts, rowid, content_text, sender_name, agent_response)
+      VALUES('delete', old.rowid, old.content_text, old.sender_name, old.agent_response);
+      INSERT INTO conversations_fts(rowid, content_text, sender_name, agent_response)
+      VALUES (new.rowid, new.content_text, new.sender_name, new.agent_response);
+    END;
+  `);
+  try {
+    await client.execute({
+      sql: `ALTER TABLE memories ADD COLUMN tier INTEGER DEFAULT 3`,
+      args: []
+    });
+  } catch {
+  }
+  try {
+    await client.execute(
+      `CREATE INDEX IF NOT EXISTS idx_memories_tier ON memories(tier)`
+    );
+  } catch {
+  }
+  try {
+    await client.execute({
+      sql: `UPDATE memories SET tier = 1 WHERE tool_name = 'commit_to_long_term_memory' AND importance >= 8 AND tier = 3`,
+      args: []
+    });
+    await client.execute({
+      sql: `UPDATE memories SET tier = 2 WHERE tool_name IN ('store_memory', 'manual') AND importance >= 5 AND tier = 3`,
+      args: []
+    });
+  } catch {
+  }
+  try {
+    await client.execute({
+      sql: `ALTER TABLE memories ADD COLUMN supersedes_id TEXT`,
+      args: []
+    });
+  } catch {
+  }
+  try {
+    await client.execute(
+      `CREATE INDEX IF NOT EXISTS idx_memories_supersedes ON memories(supersedes_id) WHERE supersedes_id IS NOT NULL`
+    );
+  } catch {
+  }
+  for (const col of [
+    "ALTER TABLE tasks ADD COLUMN checkpoint TEXT",
+    "ALTER TABLE tasks ADD COLUMN checkpoint_count INTEGER DEFAULT 0"
+  ]) {
+    try {
+      await client.execute(col);
+    } catch {
+    }
+  }
+  try {
+    await client.execute({
+      sql: `ALTER TABLE memories ADD COLUMN draft INTEGER DEFAULT 0`,
+      args: []
+    });
+  } catch {
+  }
+  try {
+    await client.execute(
+      `CREATE INDEX IF NOT EXISTS idx_memories_draft ON memories(draft) WHERE draft = 1`
+    );
+  } catch {
+  }
+  try {
+    await client.execute({
+      sql: `ALTER TABLE memories ADD COLUMN memory_type TEXT DEFAULT 'raw'`,
+      args: []
+    });
+  } catch {
+  }
+  try {
+    await client.execute(
+      `CREATE INDEX IF NOT EXISTS idx_memories_type ON memories(memory_type)`
+    );
+  } catch {
+  }
+  try {
+    await client.execute({
+      sql: `ALTER TABLE memories ADD COLUMN trajectory TEXT`,
+      args: []
+    });
+  } catch {
+  }
+  for (const col of [
+    "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);
+    } catch {
+    }
+  }
+  try {
+    await client.execute({
+      sql: `UPDATE tasks SET status = 'closed' WHERE status = 'done' AND result IS NOT NULL`,
+      args: []
+    });
+  } catch {
+  }
+}
+async function disposeDatabase() {
+  if (_walCheckpointTimer) {
+    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, _adapterClient, initTurso, SOFT_DELETE_RETENTION_DAYS, disposeTurso;
+var init_database = __esm({
+  "src/lib/database.ts"() {
+    "use strict";
+    init_db_retry();
+    init_employees();
+    init_database_adapter();
+    init_memory();
+    _client = null;
+    _resilientClient = null;
+    _walCheckpointTimer = null;
+    _daemonClient = null;
+    _adapterClient = null;
+    initTurso = initDatabase;
+    SOFT_DELETE_RETENTION_DAYS = 7;
+    disposeTurso = disposeDatabase;
+  }
+});
+
+// src/lib/memory-write-governor.ts
+import { createHash } from "crypto";
+function normalizeMemoryText(text) {
+  return text.replace(/\r\n/g, "\n").replace(/[ \t]+$/gm, "").replace(/\n{4,}/g, "\n\n\n").trim();
+}
+function classifyMemoryType(input) {
+  if (input.memory_type && input.memory_type.trim()) return input.memory_type.trim();
+  const tool = input.tool_name.toLowerCase();
+  const text = input.raw_text.toLowerCase();
+  if (tool.includes("store_decision") || tool.includes("decision")) return "decision";
+  if (tool.includes("commit") || text.includes("adr-") || text.includes("architectural decision")) return "adr";
+  if (tool.includes("store_behavior") || tool.includes("behavior")) return "behavior";
+  if (tool.includes("global_procedure") || text.includes("organization-wide procedures")) return "procedure";
+  if (tool.includes("send_whatsapp") || tool.includes("conversation")) return "conversation";
+  if (tool === "store_memory" || tool === "manual") return "observation";
+  return "raw";
+}
+function shouldDropMemory(text) {
+  const normalized = normalizeMemoryText(text);
+  if (normalized.length < 10) return { drop: true, reason: "too_short" };
+  if (NOISE_DROP_PATTERNS.some((pattern) => pattern.test(normalized))) {
+    return { drop: true, reason: "known_boilerplate_noise" };
+  }
+  return { drop: false };
+}
+function shouldSkipEmbedding(input) {
+  const type = classifyMemoryType(input);
+  if (HIGH_VALUE_SUPERSESSION_TYPES.has(type)) return false;
+  if (type === "raw" && input.raw_text.length > 2e4) return true;
+  if (SKIP_EMBED_PATTERNS.some((pattern) => pattern.test(input.raw_text))) return true;
+  return false;
+}
+function hashMemoryContent(text) {
+  return createHash("sha256").update(normalizeMemoryText(text)).digest("hex");
+}
+function scopedDedupArgs(input) {
+  return [input.contentHash, input.agentId, input.projectName, input.memoryType];
+}
+function governMemoryRecord(record) {
+  const normalized = normalizeMemoryText(record.raw_text);
+  const memoryType = classifyMemoryType({
+    raw_text: normalized,
+    agent_id: record.agent_id,
+    project_name: record.project_name,
+    tool_name: record.tool_name,
+    memory_type: record.memory_type
+  });
+  const drop = shouldDropMemory(normalized);
+  const skipEmbedding = shouldSkipEmbedding({
+    raw_text: normalized,
+    agent_id: record.agent_id,
+    project_name: record.project_name,
+    tool_name: record.tool_name,
+    memory_type: memoryType
+  });
+  return {
+    record: {
+      ...record,
+      raw_text: normalized,
+      memory_type: memoryType,
+      vector: skipEmbedding ? null : record.vector
+    },
+    contentHash: hashMemoryContent(normalized),
+    shouldDrop: drop.drop,
+    dropReason: drop.reason,
+    skipEmbedding,
+    hygiene: {
+      dedup: true,
+      supersession: HIGH_VALUE_SUPERSESSION_TYPES.has(memoryType)
+    }
+  };
+}
+async function findScopedDuplicate(input) {
+  const { getClient: getClient2 } = await Promise.resolve().then(() => (init_database(), database_exports));
+  const client = getClient2();
+  const args = scopedDedupArgs(input);
+  let sql = `SELECT id FROM memories
+             WHERE content_hash = ?
+               AND agent_id = ?
+               AND project_name = ?
+               AND COALESCE(memory_type, 'raw') = ?
+               AND COALESCE(status, 'active') != 'deleted'`;
+  if (input.excludeId) {
+    sql += " AND id != ?";
+    args.push(input.excludeId);
+  }
+  sql += " ORDER BY timestamp DESC LIMIT 1";
+  const result = await client.execute({ sql, args });
+  return result.rows[0]?.id ? String(result.rows[0].id) : null;
+}
+async function runPostWriteMemoryHygiene(memoryId) {
+  try {
+    const { getClient: getClient2 } = await Promise.resolve().then(() => (init_database(), database_exports));
+    const client = getClient2();
+    const current = await client.execute({
+      sql: `SELECT id, agent_id, project_name, memory_type, content_hash, supersedes_id,
+                   importance, timestamp
+            FROM memories
+            WHERE id = ?
+            LIMIT 1`,
+      args: [memoryId]
+    });
+    const row = current.rows[0];
+    if (!row) return;
+    const memoryType = String(row.memory_type ?? "raw");
+    const contentHash2 = row.content_hash ? String(row.content_hash) : null;
+    const agentId = String(row.agent_id);
+    const projectName = String(row.project_name);
+    if (contentHash2) {
+      await client.execute({
+        sql: `UPDATE memories
+              SET status = 'deleted',
+                  outcome = COALESCE(outcome, 'superseded')
+              WHERE id != ?
+                AND content_hash = ?
+                AND agent_id = ?
+                AND project_name = ?
+                AND COALESCE(memory_type, 'raw') = ?
+                AND COALESCE(status, 'active') = 'active'`,
+        args: [memoryId, contentHash2, agentId, projectName, memoryType]
+      });
+    }
+    const supersedesId = row.supersedes_id ? String(row.supersedes_id) : null;
+    if (supersedesId && HIGH_VALUE_SUPERSESSION_TYPES.has(memoryType)) {
+      const old = await client.execute({
+        sql: `SELECT importance FROM memories WHERE id = ? LIMIT 1`,
+        args: [supersedesId]
+      });
+      const oldImportance = Number(old.rows[0]?.importance ?? 0);
+      const newImportance = Number(row.importance ?? 0);
+      await client.batch([
+        {
+          sql: `UPDATE memories
+                SET status = 'archived',
+                    outcome = COALESCE(outcome, 'superseded')
+                WHERE id = ?`,
+          args: [supersedesId]
+        },
+        {
+          sql: `UPDATE memories
+                SET importance = MAX(COALESCE(importance, 5), ?),
+                    parent_memory_id = COALESCE(parent_memory_id, ?)
+                WHERE id = ?`,
+          args: [Math.max(oldImportance, newImportance), supersedesId, memoryId]
+        }
+      ], "write");
+    }
+  } catch (err) {
+    process.stderr.write(
+      `[memory-governor] post-write hygiene failed for ${memoryId}: ${err instanceof Error ? err.message : String(err)}
+`
+    );
+  }
+}
+function schedulePostWriteMemoryHygiene(memoryIds) {
+  if (process.env.EXE_SKIP_MEMORY_HYGIENE === "1") return;
+  if (memoryIds.length === 0) return;
+  const run = () => {
+    void Promise.all(memoryIds.map((id) => runPostWriteMemoryHygiene(id)));
+  };
+  if (typeof setImmediate === "function") setImmediate(run);
+  else setTimeout(run, 0);
+}
+var HIGH_VALUE_SUPERSESSION_TYPES, NOISE_DROP_PATTERNS, SKIP_EMBED_PATTERNS;
+var init_memory_write_governor = __esm({
+  "src/lib/memory-write-governor.ts"() {
+    "use strict";
+    HIGH_VALUE_SUPERSESSION_TYPES = /* @__PURE__ */ new Set([
+      "decision",
+      "adr",
+      "behavior",
+      "procedure"
+    ]);
+    NOISE_DROP_PATTERNS = [
+      /^\s*\[📋\s+\d+\s+reviews?\s+pending\b/im,
+      /^\s*<system-reminder>[\s\S]*?<\/system-reminder>\s*$/im,
+      /^\s*The UserPromptSubmit hook checks the DB for new tasks/im,
+      /^\s*Intercom is a speedup, not delivery/im,
+      /^\s*Context bar reads as USAGE not remaining/im
+    ];
+    SKIP_EMBED_PATTERNS = [
+      /tmux capture-pane\b/i,
+      /docker ps\b/i,
+      /docker images\b/i,
+      /git status\b/i,
+      /grep .*node_modules/i,
+      /npm (install|ci)\b[\s\S]*(added \d+ packages|audited \d+ packages)/i
+    ];
+  }
+});
+
+// src/lib/projection-worker.ts
+var projection_worker_exports = {};
+__export(projection_worker_exports, {
+  processProjectionBatch: () => processProjectionBatch,
+  projectionHandlersForTests: () => projectionHandlersForTests,
+  resetProjectionWorkerForTests: () => resetProjectionWorkerForTests,
+  setProjectionWorkerPrismaClientForTests: () => setProjectionWorkerPrismaClientForTests,
+  startProjectionWorker: () => startProjectionWorker,
+  stopProjectionWorker: () => stopProjectionWorker
+});
+import os5 from "os";
+import path8 from "path";
+import { existsSync as existsSync8 } from "fs";
+import { createRequire as createRequire2 } from "module";
+import { pathToFileURL as pathToFileURL2 } from "url";
+function loadPrisma() {
+  if (!prismaPromise) {
+    prismaPromise = (async () => {
+      const explicitPath = process.env.EXE_OS_PRISMA_CLIENT_PATH;
+      if (explicitPath) {
+        const mod2 = await import(pathToFileURL2(explicitPath).href);
+        const Ctor2 = mod2.PrismaClient ?? mod2.default?.PrismaClient;
+        if (!Ctor2) throw new Error(`No PrismaClient at ${explicitPath}`);
+        return new Ctor2();
+      }
+      const exeDbRoot = process.env.EXE_DB_ROOT ?? path8.join(os5.homedir(), "exe-db");
+      const req = createRequire2(path8.join(exeDbRoot, "package.json"));
+      const entry = req.resolve("@prisma/client");
+      const mod = await import(pathToFileURL2(entry).href);
+      const Ctor = mod.PrismaClient ?? mod.default?.PrismaClient;
+      if (!Ctor) throw new Error(`No PrismaClient in ${entry}`);
+      return new Ctor();
+    })();
+  }
+  return prismaPromise;
+}
+function setProjectionWorkerPrismaClientForTests(client) {
+  prismaPromise = client ? Promise.resolve(client) : null;
+}
+function resetProjectionWorkerForTests() {
+  running = false;
+  if (pollTimer) {
+    clearTimeout(pollTimer);
+    pollTimer = null;
+  }
+  prismaPromise = null;
+}
+async function processBatch() {
+  const prisma = await loadPrisma();
+  const events = await prisma.$queryRawUnsafe(
+    `SELECT "id", "source", "source_id", "event_type", "payload", "metadata", "timestamp"
+     FROM "raw"."raw_events"
+     WHERE "processed_at" IS NULL
+     ORDER BY "timestamp" ASC
+     LIMIT $1`,
+    BATCH_SIZE
+  );
+  if (events.length === 0) return 0;
+  let processed = 0;
+  for (const event of events) {
+    try {
+      const handler = projectionHandlers[event.source] ?? defaultHandler;
+      const result = await handler(event, prisma);
+      await prisma.$executeRawUnsafe(
+        `UPDATE "raw"."raw_events"
+         SET "processed_at" = NOW(), "projections" = $1::jsonb
+         WHERE "id" = $2`,
+        JSON.stringify({ targets: result.targets, skipped: result.skipped }),
+        event.id
+      );
+      processed++;
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      process.stderr.write(
+        `[projection-worker] Error processing event ${event.id}: ${message}
+`
+      );
+      await prisma.$executeRawUnsafe(
+        `UPDATE "raw"."raw_events"
+         SET "processed_at" = NOW(), "projections" = $1::jsonb
+         WHERE "id" = $2`,
+        JSON.stringify({ error: message }),
+        event.id
+      );
+    }
+  }
+  return processed;
+}
+function startProjectionWorker() {
+  if (running) return;
+  if (!process.env.DATABASE_URL) {
+    const exeDbRoot = process.env.EXE_DB_ROOT ?? path8.join(os5.homedir(), "exe-db");
+    if (!existsSync8(path8.join(exeDbRoot, "package.json"))) {
+      process.stderr.write("[projection-worker] Skipped \u2014 no exe-db found. Set DATABASE_URL or EXE_DB_ROOT to enable.\n");
+      return;
+    }
+  }
+  running = true;
+  process.stderr.write("[projection-worker] Starting...\n");
+  const tick = async () => {
+    if (!running) return;
+    try {
+      const count = await processBatch();
+      if (count > 0) {
+        process.stderr.write(`[projection-worker] Processed ${count} events.
+`);
+      }
+    } catch (err) {
+      process.stderr.write(
+        `[projection-worker] Poll error: ${err instanceof Error ? err.message : String(err)}
+`
+      );
+    }
+    if (running) {
+      pollTimer = setTimeout(tick, POLL_INTERVAL_MS);
+    }
+  };
+  void tick();
+}
+function stopProjectionWorker() {
+  running = false;
+  if (pollTimer) {
+    clearTimeout(pollTimer);
+    pollTimer = null;
+  }
+  process.stderr.write("[projection-worker] Stopped.\n");
+}
+async function processProjectionBatch() {
+  return processBatch();
+}
+var prismaPromise, projectionHandlers, projectionHandlersForTests, defaultHandler, BATCH_SIZE, POLL_INTERVAL_MS, running, pollTimer;
+var init_projection_worker = __esm({
+  "src/lib/projection-worker.ts"() {
+    "use strict";
+    prismaPromise = null;
+    projectionHandlers = {
+      async whatsapp(event, prisma) {
+        const targets = [];
+        const payload = event.payload;
+        await prisma.$executeRawUnsafe(
+          `INSERT INTO "memory"."memory_records" ("id", "agent_id", "agent_role", "session_id", "tool_name", "project_name", "raw_text", "memory_type", "source_type", "intent")
+       VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10)
+       ON CONFLICT ("id") DO NOTHING`,
+          crypto.randomUUID(),
+          "system",
+          "ingest",
+          "projection-worker",
+          "projection_worker",
+          "exe-os",
+          JSON.stringify(payload),
+          "raw",
+          "whatsapp",
+          event.event_type
+        );
+        targets.push("memory");
+        return { targets };
+      },
+      async shopify(event, prisma) {
+        const targets = [];
+        const payload = event.payload;
+        await prisma.$executeRawUnsafe(
+          `INSERT INTO "memory"."memory_records" ("id", "agent_id", "agent_role", "session_id", "tool_name", "project_name", "raw_text", "memory_type", "source_type", "intent")
+       VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10)
+       ON CONFLICT ("id") DO NOTHING`,
+          crypto.randomUUID(),
+          "system",
+          "ingest",
+          "projection-worker",
+          "projection_worker",
+          "exe-os",
+          JSON.stringify(payload),
+          "raw",
+          "shopify",
+          event.event_type
+        );
+        targets.push("memory");
+        return { targets };
+      },
+      async cloud_sync(event, prisma) {
+        const targets = [];
+        const payload = event.payload;
+        await prisma.$executeRawUnsafe(
+          `INSERT INTO "memory"."memory_records" ("id", "agent_id", "agent_role", "session_id", "tool_name", "project_name", "raw_text", "memory_type", "source_type", "intent", "domain")
+       VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11)
+       ON CONFLICT ("id") DO NOTHING`,
+          payload.id ?? crypto.randomUUID(),
+          payload.agent_id ?? "system",
+          payload.agent_role ?? "ingest",
+          payload.session_id ?? "projection-worker",
+          payload.tool_name ?? "cloud_sync",
+          payload.project_name ?? "exe-os",
+          payload.raw_text ?? JSON.stringify(payload),
+          payload.memory_type ?? "raw",
+          "cloud_sync",
+          event.event_type,
+          payload.domain ?? null
+        );
+        targets.push("memory");
+        return { targets };
+      },
+      async external_agent(event, prisma) {
+        const targets = [];
+        const payload = event.payload;
+        await prisma.$executeRawUnsafe(
+          `INSERT INTO "memory"."memory_records" ("id", "agent_id", "agent_role", "session_id", "tool_name", "project_name", "raw_text", "memory_type", "source_type", "intent", "domain")
+       VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11)
+       ON CONFLICT ("id") DO NOTHING`,
+          crypto.randomUUID(),
+          "system",
+          "ingest",
+          "projection-worker",
+          "projection_worker",
+          "exe-os",
+          JSON.stringify(payload),
+          "raw",
+          "external_agent",
+          event.event_type,
+          payload.domain ?? null
+        );
+        targets.push("memory");
+        return { targets };
+      }
+    };
+    projectionHandlersForTests = projectionHandlers;
+    defaultHandler = async (event, prisma) => {
+      await prisma.$executeRawUnsafe(
+        `INSERT INTO "memory"."memory_records" ("id", "agent_id", "agent_role", "session_id", "tool_name", "project_name", "raw_text", "memory_type", "source_type", "intent")
+     VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10)
+     ON CONFLICT ("id") DO NOTHING`,
+        crypto.randomUUID(),
+        "system",
+        "ingest",
+        "projection-worker",
+        "projection_worker",
+        "exe-os",
+        JSON.stringify(event.payload),
+        "raw",
+        event.source,
+        event.event_type
+      );
+      return { targets: ["memory"] };
+    };
+    BATCH_SIZE = 50;
+    POLL_INTERVAL_MS = 1e4;
+    running = false;
+    pollTimer = null;
+  }
+});
+
+// src/lib/shard-manager.ts
+var shard_manager_exports = {};
+__export(shard_manager_exports, {
+  disposeShards: () => disposeShards,
+  ensureShardSchema: () => ensureShardSchema,
+  getOpenShardCount: () => getOpenShardCount,
+  getReadyShardClient: () => getReadyShardClient,
+  getShardClient: () => getShardClient,
+  getShardsDir: () => getShardsDir,
+  initShardManager: () => initShardManager,
+  isShardingEnabled: () => isShardingEnabled,
+  listShards: () => listShards,
+  shardExists: () => shardExists
+});
+import path9 from "path";
+import { existsSync as existsSync9, mkdirSync as mkdirSync2, readdirSync } from "fs";
+import { createClient as createClient2 } from "@libsql/client";
+function initShardManager(encryptionKey) {
+  _encryptionKey = encryptionKey;
+  if (!existsSync9(SHARDS_DIR)) {
+    mkdirSync2(SHARDS_DIR, { recursive: true });
   }
-  try {
-    await client.execute({
-      sql: `ALTER TABLE session_agent_map ADD COLUMN cache_cold_count INTEGER NOT NULL DEFAULT 0`,
-      args: []
-    });
-  } catch {
+  _shardingEnabled = true;
+  if (_evictionTimer) clearInterval(_evictionTimer);
+  _evictionTimer = setInterval(evictIdleShards, EVICTION_INTERVAL_MS);
+  _evictionTimer.unref();
+}
+function isShardingEnabled() {
+  return _shardingEnabled;
+}
+function getShardsDir() {
+  return SHARDS_DIR;
+}
+function getShardClient(projectName) {
+  if (!_encryptionKey) {
+    throw new Error("Shard manager not initialized. Call initShardManager() first.");
   }
-  try {
-    await client.execute({
-      sql: `ALTER TABLE tasks ADD COLUMN budget_tokens INTEGER`,
-      args: []
-    });
-  } catch {
+  const safeName = projectName.replace(/[^a-zA-Z0-9_-]/g, "_");
+  if (!safeName || safeName === "unknown") {
+    throw new Error(`Invalid project name for shard: "${projectName}" (resolved to "${safeName}")`);
   }
-  try {
-    await client.execute({
-      sql: `ALTER TABLE tasks ADD COLUMN budget_fallback_model TEXT`,
-      args: []
-    });
-  } catch {
+  const cached = _shards.get(safeName);
+  if (cached) {
+    _shardLastAccess.set(safeName, Date.now());
+    return cached;
   }
-  try {
-    await client.execute({
-      sql: `ALTER TABLE tasks ADD COLUMN tokens_used INTEGER DEFAULT 0`,
-      args: []
-    });
-  } catch {
+  while (_shards.size >= MAX_OPEN_SHARDS) {
+    evictLRU();
   }
+  const dbPath = path9.join(SHARDS_DIR, `${safeName}.db`);
+  const client = createClient2({
+    url: `file:${dbPath}`,
+    encryptionKey: _encryptionKey
+  });
+  _shards.set(safeName, client);
+  _shardLastAccess.set(safeName, Date.now());
+  return client;
+}
+function shardExists(projectName) {
+  const safeName = projectName.replace(/[^a-zA-Z0-9_-]/g, "_");
+  return existsSync9(path9.join(SHARDS_DIR, `${safeName}.db`));
+}
+function listShards() {
+  if (!existsSync9(SHARDS_DIR)) return [];
+  return readdirSync(SHARDS_DIR).filter((f) => f.endsWith(".db")).map((f) => f.replace(".db", ""));
+}
+async function ensureShardSchema(client) {
+  await client.execute("PRAGMA journal_mode = WAL");
+  await client.execute("PRAGMA busy_timeout = 30000");
   try {
-    await client.execute({
-      sql: `ALTER TABLE tasks ADD COLUMN tokens_warned_at INTEGER`,
-      args: []
-    });
+    await client.execute("PRAGMA libsql_vector_search_ef = 128");
   } catch {
   }
   await client.executeMultiple(`
-    CREATE VIRTUAL TABLE IF NOT EXISTS conversations_fts USING fts5(
-      content_text,
-      sender_name,
-      agent_response,
-      content='conversations',
+    CREATE TABLE IF NOT EXISTS memories (
+      id            TEXT PRIMARY KEY,
+      agent_id      TEXT NOT NULL,
+      agent_role    TEXT NOT NULL,
+      session_id    TEXT NOT NULL,
+      timestamp     TEXT NOT NULL,
+      tool_name     TEXT NOT NULL,
+      project_name  TEXT NOT NULL,
+      has_error     INTEGER NOT NULL DEFAULT 0,
+      raw_text      TEXT NOT NULL,
+      vector        F32_BLOB(1024),
+      version       INTEGER NOT NULL DEFAULT 0
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_memories_agent ON memories(agent_id);
+    CREATE INDEX IF NOT EXISTS idx_memories_timestamp ON memories(timestamp);
+    CREATE INDEX IF NOT EXISTS idx_memories_agent_project ON memories(agent_id, project_name);
+  `);
+  await client.executeMultiple(`
+    CREATE VIRTUAL TABLE IF NOT EXISTS memories_fts USING fts5(
+      raw_text,
+      content='memories',
       content_rowid='rowid'
     );
 
-    CREATE TRIGGER IF NOT EXISTS conversations_fts_ai AFTER INSERT ON conversations BEGIN
-      INSERT INTO conversations_fts(rowid, content_text, sender_name, agent_response)
-      VALUES (new.rowid, new.content_text, new.sender_name, new.agent_response);
+    CREATE TRIGGER IF NOT EXISTS memories_fts_ai AFTER INSERT ON memories BEGIN
+      INSERT INTO memories_fts(rowid, raw_text) VALUES (new.rowid, new.raw_text);
     END;
 
-    CREATE TRIGGER IF NOT EXISTS conversations_fts_ad AFTER DELETE ON conversations BEGIN
-      INSERT INTO conversations_fts(conversations_fts, rowid, content_text, sender_name, agent_response)
-      VALUES('delete', old.rowid, old.content_text, old.sender_name, old.agent_response);
+    CREATE TRIGGER IF NOT EXISTS memories_fts_ad AFTER DELETE ON memories BEGIN
+      INSERT INTO memories_fts(memories_fts, rowid, raw_text) VALUES('delete', old.rowid, old.raw_text);
     END;
 
-    CREATE TRIGGER IF NOT EXISTS conversations_fts_au AFTER UPDATE ON conversations BEGIN
-      INSERT INTO conversations_fts(conversations_fts, rowid, content_text, sender_name, agent_response)
-      VALUES('delete', old.rowid, old.content_text, old.sender_name, old.agent_response);
-      INSERT INTO conversations_fts(rowid, content_text, sender_name, agent_response)
-      VALUES (new.rowid, new.content_text, new.sender_name, new.agent_response);
+    CREATE TRIGGER IF NOT EXISTS memories_fts_au AFTER UPDATE ON memories BEGIN
+      INSERT INTO memories_fts(memories_fts, rowid, raw_text) VALUES('delete', old.rowid, old.raw_text);
+      INSERT INTO memories_fts(rowid, raw_text) VALUES (new.rowid, new.raw_text);
     END;
   `);
-  try {
-    await client.execute({
-      sql: `ALTER TABLE memories ADD COLUMN tier INTEGER DEFAULT 3`,
-      args: []
-    });
-  } catch {
-  }
-  try {
-    await client.execute(
-      `CREATE INDEX IF NOT EXISTS idx_memories_tier ON memories(tier)`
-    );
-  } catch {
-  }
-  try {
-    await client.execute({
-      sql: `UPDATE memories SET tier = 1 WHERE tool_name = 'commit_to_long_term_memory' AND importance >= 8 AND tier = 3`,
-      args: []
-    });
-    await client.execute({
-      sql: `UPDATE memories SET tier = 2 WHERE tool_name IN ('store_memory', 'manual') AND importance >= 5 AND tier = 3`,
-      args: []
-    });
-  } catch {
-  }
-  try {
-    await client.execute({
-      sql: `ALTER TABLE memories ADD COLUMN supersedes_id TEXT`,
-      args: []
-    });
-  } catch {
-  }
-  try {
-    await client.execute(
-      `CREATE INDEX IF NOT EXISTS idx_memories_supersedes ON memories(supersedes_id) WHERE supersedes_id IS NOT NULL`
-    );
-  } catch {
-  }
-  for (const col of [
-    "ALTER TABLE tasks ADD COLUMN checkpoint TEXT",
-    "ALTER TABLE tasks ADD COLUMN checkpoint_count INTEGER DEFAULT 0"
-  ]) {
-    try {
-      await client.execute(col);
-    } catch {
-    }
-  }
-  try {
-    await client.execute({
-      sql: `ALTER TABLE memories ADD COLUMN draft INTEGER DEFAULT 0`,
-      args: []
-    });
-  } catch {
-  }
-  try {
-    await client.execute(
-      `CREATE INDEX IF NOT EXISTS idx_memories_draft ON memories(draft) WHERE draft = 1`
-    );
-  } catch {
-  }
-  try {
-    await client.execute({
-      sql: `ALTER TABLE memories ADD COLUMN memory_type TEXT DEFAULT 'raw'`,
-      args: []
-    });
-  } catch {
-  }
-  try {
-    await client.execute(
-      `CREATE INDEX IF NOT EXISTS idx_memories_type ON memories(memory_type)`
-    );
-  } catch {
-  }
-  try {
-    await client.execute({
-      sql: `ALTER TABLE memories ADD COLUMN trajectory TEXT`,
-      args: []
-    });
-  } catch {
-  }
   for (const col of [
+    "ALTER TABLE memories ADD COLUMN task_id TEXT",
+    "ALTER TABLE memories ADD COLUMN consolidated INTEGER NOT NULL DEFAULT 0",
+    "ALTER TABLE memories ADD COLUMN author_device_id TEXT",
+    "ALTER TABLE memories ADD COLUMN scope TEXT NOT NULL DEFAULT 'business'",
+    "ALTER TABLE memories ADD COLUMN importance INTEGER DEFAULT 5",
+    "ALTER TABLE memories ADD COLUMN status TEXT DEFAULT 'active'",
+    "ALTER TABLE memories ADD COLUMN wiki_synced INTEGER DEFAULT 0",
+    "ALTER TABLE memories ADD COLUMN graph_extracted INTEGER DEFAULT 0",
+    "ALTER TABLE memories ADD COLUMN content_hash TEXT",
+    "ALTER TABLE memories ADD COLUMN graph_extracted_hash TEXT",
+    "ALTER TABLE memories ADD COLUMN confidence REAL DEFAULT 0.7",
+    "ALTER TABLE memories ADD COLUMN last_accessed TEXT",
+    // Wiki linkage columns (must match database.ts)
+    "ALTER TABLE memories ADD COLUMN workspace_id TEXT",
+    "ALTER TABLE memories ADD COLUMN document_id TEXT",
+    "ALTER TABLE memories ADD COLUMN user_id TEXT",
+    "ALTER TABLE memories ADD COLUMN char_offset INTEGER",
+    "ALTER TABLE memories ADD COLUMN page_number INTEGER",
+    // Source provenance columns (must match database.ts)
+    "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",
+    // 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",
+    // 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",
@@ -3705,49 +3790,164 @@ async function ensureSchema() {
     } catch {
     }
   }
+  for (const idx of [
+    "CREATE INDEX IF NOT EXISTS idx_memories_tier ON memories(tier)",
+    "CREATE INDEX IF NOT EXISTS idx_memories_supersedes ON memories(supersedes_id) WHERE supersedes_id IS NOT NULL",
+    "CREATE INDEX IF NOT EXISTS idx_memories_scoped_content_hash ON memories(content_hash, agent_id, project_name, memory_type) WHERE content_hash IS NOT NULL"
+  ]) {
+    try {
+      await client.execute(idx);
+    } catch {
+    }
+  }
   try {
-    await client.execute({
-      sql: `UPDATE tasks SET status = 'closed' WHERE status = 'done' AND result IS NOT NULL`,
-      args: []
-    });
+    await client.execute("CREATE INDEX IF NOT EXISTS idx_memories_status ON memories(status)");
   } catch {
   }
+  for (const idx of [
+    "CREATE INDEX IF NOT EXISTS idx_memories_workspace ON memories(workspace_id)",
+    "CREATE INDEX IF NOT EXISTS idx_memories_document ON memories(document_id)",
+    "CREATE INDEX IF NOT EXISTS idx_memories_user ON memories(user_id)"
+  ]) {
+    try {
+      await client.execute(idx);
+    } catch {
+    }
+  }
+  await client.executeMultiple(`
+    CREATE TABLE IF NOT EXISTS entities (
+      id TEXT PRIMARY KEY,
+      name TEXT NOT NULL,
+      type TEXT NOT NULL,
+      first_seen TEXT NOT NULL,
+      last_seen TEXT NOT NULL,
+      properties TEXT DEFAULT '{}',
+      UNIQUE(name, type)
+    );
+
+    CREATE TABLE IF NOT EXISTS relationships (
+      id TEXT PRIMARY KEY,
+      source_entity_id TEXT NOT NULL,
+      target_entity_id TEXT NOT NULL,
+      type TEXT NOT NULL,
+      weight REAL DEFAULT 1.0,
+      timestamp TEXT NOT NULL,
+      properties TEXT DEFAULT '{}',
+      UNIQUE(source_entity_id, target_entity_id, type)
+    );
+
+    CREATE TABLE IF NOT EXISTS entity_memories (
+      entity_id TEXT NOT NULL,
+      memory_id TEXT NOT NULL,
+      PRIMARY KEY (entity_id, memory_id)
+    );
+
+    CREATE TABLE IF NOT EXISTS relationship_memories (
+      relationship_id TEXT NOT NULL,
+      memory_id TEXT NOT NULL,
+      PRIMARY KEY (relationship_id, memory_id)
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_entities_name ON entities(name);
+    CREATE INDEX IF NOT EXISTS idx_entities_type ON entities(type);
+    CREATE INDEX IF NOT EXISTS idx_relationships_source ON relationships(source_entity_id);
+    CREATE INDEX IF NOT EXISTS idx_relationships_target ON relationships(target_entity_id);
+    CREATE INDEX IF NOT EXISTS idx_relationships_type ON relationships(type);
+
+    CREATE TABLE IF NOT EXISTS hyperedges (
+      id TEXT PRIMARY KEY,
+      label TEXT NOT NULL,
+      relation TEXT NOT NULL,
+      confidence REAL DEFAULT 1.0,
+      timestamp TEXT NOT NULL
+    );
+
+    CREATE TABLE IF NOT EXISTS hyperedge_nodes (
+      hyperedge_id TEXT NOT NULL,
+      entity_id TEXT NOT NULL,
+      PRIMARY KEY (hyperedge_id, entity_id)
+    );
+  `);
+  for (const col of [
+    "ALTER TABLE relationships ADD COLUMN confidence REAL DEFAULT 1.0",
+    "ALTER TABLE relationships ADD COLUMN confidence_label TEXT DEFAULT 'extracted'"
+  ]) {
+    try {
+      await client.execute(col);
+    } catch {
+    }
+  }
 }
-async function disposeDatabase() {
-  if (_walCheckpointTimer) {
-    clearInterval(_walCheckpointTimer);
-    _walCheckpointTimer = null;
+async function getReadyShardClient(projectName) {
+  const client = getShardClient(projectName);
+  await ensureShardSchema(client);
+  return client;
+}
+function evictLRU() {
+  let oldest = null;
+  let oldestTime = Infinity;
+  for (const [name, time] of _shardLastAccess) {
+    if (time < oldestTime) {
+      oldestTime = time;
+      oldest = name;
+    }
   }
-  if (_daemonClient) {
-    _daemonClient.close();
-    _daemonClient = null;
+  if (oldest) {
+    const client = _shards.get(oldest);
+    if (client) {
+      client.close();
+    }
+    _shards.delete(oldest);
+    _shardLastAccess.delete(oldest);
   }
-  if (_adapterClient && _adapterClient !== _resilientClient) {
-    _adapterClient.close();
+}
+function evictIdleShards() {
+  const now = Date.now();
+  const toEvict = [];
+  for (const [name, lastAccess] of _shardLastAccess) {
+    if (now - lastAccess > SHARD_IDLE_MS) {
+      toEvict.push(name);
+    }
   }
-  _adapterClient = null;
-  if (_client) {
-    _client.close();
-    _client = null;
-    _resilientClient = null;
+  for (const name of toEvict) {
+    const client = _shards.get(name);
+    if (client) {
+      client.close();
+    }
+    _shards.delete(name);
+    _shardLastAccess.delete(name);
   }
 }
-var _client, _resilientClient, _walCheckpointTimer, _daemonClient, _adapterClient, initTurso, SOFT_DELETE_RETENTION_DAYS, disposeTurso;
-var init_database = __esm({
-  "src/lib/database.ts"() {
+function getOpenShardCount() {
+  return _shards.size;
+}
+function disposeShards() {
+  if (_evictionTimer) {
+    clearInterval(_evictionTimer);
+    _evictionTimer = null;
+  }
+  for (const [, client] of _shards) {
+    client.close();
+  }
+  _shards.clear();
+  _shardLastAccess.clear();
+  _shardingEnabled = false;
+  _encryptionKey = null;
+}
+var SHARDS_DIR, SHARD_IDLE_MS, MAX_OPEN_SHARDS, EVICTION_INTERVAL_MS, _shards, _shardLastAccess, _evictionTimer, _encryptionKey, _shardingEnabled;
+var init_shard_manager = __esm({
+  "src/lib/shard-manager.ts"() {
     "use strict";
-    init_db_retry();
-    init_employees();
-    init_database_adapter();
-    init_memory();
-    _client = null;
-    _resilientClient = null;
-    _walCheckpointTimer = null;
-    _daemonClient = null;
-    _adapterClient = null;
-    initTurso = initDatabase;
-    SOFT_DELETE_RETENTION_DAYS = 7;
-    disposeTurso = disposeDatabase;
+    init_config();
+    SHARDS_DIR = path9.join(EXE_AI_DIR, "shards");
+    SHARD_IDLE_MS = 5 * 60 * 1e3;
+    MAX_OPEN_SHARDS = 10;
+    EVICTION_INTERVAL_MS = 60 * 1e3;
+    _shards = /* @__PURE__ */ new Map();
+    _shardLastAccess = /* @__PURE__ */ new Map();
+    _evictionTimer = null;
+    _encryptionKey = null;
+    _shardingEnabled = false;
   }
 });
 
@@ -4142,7 +4342,7 @@ var init_platform_procedures = __esm({
         title: "Chain of command \u2014 who talks to whom",
         domain: "workflow",
         priority: "p0",
-        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."
+        content: "Founder -> coordinator (the executive agent, internally routed as 'COO') -> CTO/CMO. CTO -> engineers. CMO -> content production. Never skip levels: the coordinator 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",
@@ -4373,7 +4573,6 @@ __export(store_exports, {
   vectorToBlob: () => vectorToBlob,
   writeMemory: () => writeMemory
 });
-import { createHash } from "crypto";
 function isBusyError2(err) {
   if (err instanceof Error) {
     const msg = err.message.toLowerCase();
@@ -4487,17 +4686,24 @@ async function writeMemory(record) {
       `Expected ${EMBEDDING_DIM}-dim vector, got ${record.vector.length}`
     );
   }
-  const contentHash2 = createHash("md5").update(record.raw_text).digest("hex");
-  if (_pendingRecords.some((r) => r.content_hash === contentHash2 && r.agent_id === record.agent_id)) {
+  const governed = governMemoryRecord(record);
+  if (governed.shouldDrop) return;
+  record = governed.record;
+  const contentHash2 = governed.contentHash;
+  const memoryType = record.memory_type ?? "raw";
+  if (_pendingRecords.some(
+    (r) => r.content_hash === contentHash2 && r.agent_id === record.agent_id && r.project_name === record.project_name && (r.memory_type ?? "raw") === memoryType
+  )) {
     return;
   }
   try {
-    const client = getClient();
-    const existing = await client.execute({
-      sql: "SELECT id FROM memories WHERE content_hash = ? AND agent_id = ? LIMIT 1",
-      args: [contentHash2, record.agent_id]
+    const existing = await findScopedDuplicate({
+      contentHash: contentHash2,
+      agentId: record.agent_id,
+      projectName: record.project_name,
+      memoryType
     });
-    if (existing.rows.length > 0) return;
+    if (existing) return;
   } catch {
   }
   const dbRow = {
@@ -4528,7 +4734,7 @@ async function writeMemory(record) {
     tier: record.tier ?? classifyTier(record),
     supersedes_id: record.supersedes_id ?? null,
     draft: record.draft ? 1 : 0,
-    memory_type: record.memory_type ?? "raw",
+    memory_type: memoryType,
     trajectory: record.trajectory ? JSON.stringify(record.trajectory) : null,
     content_hash: contentHash2,
     intent: record.intent ?? null,
@@ -4687,6 +4893,7 @@ async function flushBatch() {
     const globalClient = getClient();
     const globalStmts = batch.map(buildStmt);
     await globalClient.batch(globalStmts, "write");
+    schedulePostWriteMemoryHygiene(batch.map((row) => row.id));
     _pendingRecords.splice(0, batch.length);
     try {
       const { isShardingEnabled: isShardingEnabled2, getReadyShardClient: getReadyShardClient2 } = await Promise.resolve().then(() => (init_shard_manager(), shard_manager_exports));
@@ -4807,7 +5014,11 @@ async function searchMemories(queryVector, agentId, options) {
     sql += ` AND timestamp >= ?`;
     args.push(options.since);
   }
-  if (options?.memoryType) {
+  if (options?.memoryTypes && options.memoryTypes.length > 0) {
+    const uniqueTypes = [...new Set(options.memoryTypes)];
+    sql += ` AND memory_type IN (${uniqueTypes.map(() => "?").join(",")})`;
+    args.push(...uniqueTypes);
+  } else if (options?.memoryType) {
     sql += ` AND memory_type = ?`;
     args.push(options.memoryType);
   }
@@ -4945,6 +5156,7 @@ var init_store = __esm({
     init_keychain();
     init_config();
     init_state_bus();
+    init_memory_write_governor();
     INIT_MAX_RETRIES = 3;
     INIT_RETRY_DELAY_MS = 1e3;
     _pendingRecords = [];
@@ -5170,8 +5382,8 @@ async function ensureLoaded() {
     );
   }
   process.stderr.write("[reranker] Loading Jina Reranker v3...\n");
-  const { getLlama: getLlama2 } = await import("node-llama-cpp");
-  const llama = await getLlama2();
+  const { getLlama } = await import("node-llama-cpp");
+  const llama = await getLlama();
   _rerankerModel = await llama.loadModel({ modelPath });
   _rerankerContext = await _rerankerModel.createEmbeddingContext();
   process.stderr.write("[reranker] Jina Reranker v3 loaded.\n");
@@ -6190,6 +6402,17 @@ __export(hybrid_search_exports, {
   rrfMerge: () => rrfMerge,
   rrfMergeMulti: () => rrfMergeMulti
 });
+function appendMemoryTypeFilter(sql, args, column, options) {
+  if (options?.memoryTypes && options.memoryTypes.length > 0) {
+    const uniqueTypes = [...new Set(options.memoryTypes)];
+    sql += ` AND ${column} IN (${uniqueTypes.map(() => "?").join(",")})`;
+    args.push(...uniqueTypes);
+  } else if (options?.memoryType) {
+    sql += ` AND ${column} = ?`;
+    args.push(options.memoryType);
+  }
+  return sql;
+}
 async function hybridSearch(queryText, agentId, options) {
   const { loadConfig: loadConfig2 } = await Promise.resolve().then(() => (init_config(), config_exports));
   const config2 = await loadConfig2();
@@ -6418,6 +6641,7 @@ async function estimateCardinality(agentId, options) {
     sql += ` AND timestamp >= ?`;
     args.push(options.since);
   }
+  sql = appendMemoryTypeFilter(sql, args, "memory_type", options);
   try {
     const result = await client.execute({ sql, args });
     return Number(result.rows[0]?.cnt) || 0;
@@ -6539,10 +6763,7 @@ async function ftsQuery(client, matchExpr, agentId, options, limit) {
     sql += ` AND m.timestamp >= ?`;
     args.push(options.since);
   }
-  if (options?.memoryType) {
-    sql += ` AND m.memory_type = ?`;
-    args.push(options.memoryType);
-  }
+  sql = appendMemoryTypeFilter(sql, args, "m.memory_type", options);
   sql += ` ORDER BY rank LIMIT ?`;
   args.push(limit);
   const result = await client.execute({ sql, args });
@@ -6599,9 +6820,16 @@ async function recentRecords(agentId, options, limit, textFilter) {
                   AND timestamp >= ? AND timestamp <= ?
                   AND COALESCE(status, 'active') = 'active'
                   AND ${options?.includeRaw === false ? "COALESCE(memory_type, 'raw') != 'raw'" : "1 = 1"}
+                  ${options?.memoryTypes?.length ? `AND memory_type IN (${options.memoryTypes.map(() => "?").join(",")})` : options?.memoryType ? "AND memory_type = ?" : ""}
                   AND COALESCE(confidence, 0.7) >= 0.3
                 ORDER BY timestamp DESC LIMIT ?`,
-          args: [agentId, windowStart, killedAt, boundarySlots]
+          args: [
+            agentId,
+            windowStart,
+            killedAt,
+            ...options?.memoryTypes?.length ? [...new Set(options.memoryTypes)] : options?.memoryType ? [options.memoryType] : [],
+            boundarySlots
+          ]
         });
         for (const row of boundaryResult.rows) {
           sessionBoundaryMemories.push(rowToMemoryRecord(row));
@@ -6647,10 +6875,7 @@ async function recentRecords(agentId, options, limit, textFilter) {
     sql += ` AND timestamp >= ?`;
     args.push(options.since);
   }
-  if (options?.memoryType) {
-    sql += ` AND memory_type = ?`;
-    args.push(options.memoryType);
-  }
+  sql = appendMemoryTypeFilter(sql, args, "memory_type", options);
   if (textFilter) {
     sql += ` AND raw_text LIKE '%' || ? || '%'`;
     args.push(textFilter);
@@ -7060,6 +7285,67 @@ var init_active_agent = __esm({
   }
 });
 
+// src/lib/memory-retrieval-modes.ts
+function applyRetrievalMode(base, mode) {
+  if (!mode || mode === "all") return base;
+  const next = { ...base };
+  switch (mode) {
+    case "decisions_only":
+      next.memoryTypes = ["decision", "adr"];
+      next.includeRaw = false;
+      break;
+    case "behaviors_only":
+      next.memoryTypes = ["behavior"];
+      next.includeRaw = false;
+      break;
+    case "procedures_only":
+      next.memoryTypes = ["procedure"];
+      next.includeRaw = false;
+      break;
+    case "operational":
+      next.memoryTypes = ["raw", "observation"];
+      next.includeRaw = true;
+      break;
+    case "no_raw":
+      next.includeRaw = false;
+      break;
+    case "recent_high_value":
+      next.memoryTypes = ["decision", "adr", "behavior", "procedure"];
+      next.includeRaw = false;
+      break;
+    default:
+      return next;
+  }
+  return next;
+}
+function formatRetrievalModes() {
+  return RETRIEVAL_MODES.map((mode) => `${mode}: ${RETRIEVAL_MODE_DESCRIPTIONS[mode]}`).join("; ");
+}
+var RETRIEVAL_MODES, RETRIEVAL_MODE_DESCRIPTIONS;
+var init_memory_retrieval_modes = __esm({
+  "src/lib/memory-retrieval-modes.ts"() {
+    "use strict";
+    RETRIEVAL_MODES = [
+      "all",
+      "decisions_only",
+      "behaviors_only",
+      "procedures_only",
+      "operational",
+      "no_raw",
+      "recent_high_value"
+    ];
+    RETRIEVAL_MODE_DESCRIPTIONS = {
+      all: "All visible memory types.",
+      decisions_only: "Only decisions and ADRs.",
+      behaviors_only: "Only durable behavior/correction memories.",
+      procedures_only: "Only procedures/runbooks.",
+      operational: "Raw operational/debug/tool output.",
+      no_raw: "All non-raw memory types.",
+      recent_high_value: "High-value durable memory types, intended for recency recovery."
+    };
+  }
+});
+
 // src/mcp/tools/recall-my-memory.ts
 import { z } from "zod";
 function formatSourceLine(record) {
@@ -7097,7 +7383,8 @@ function registerRecallMyMemory(server) {
         ),
         include_source: z.boolean().optional().default(false).describe(
           "When true, attach parent document metadata (filename, mime, source_type) to each result. Default false."
-        )
+        ),
+        retrieval_mode: z.enum(RETRIEVAL_MODES).optional().default("all").describe(`Typed retrieval mode. ${formatRetrievalModes()}`)
       }
     },
     async ({
@@ -7111,7 +7398,8 @@ function registerRecallMyMemory(server) {
       include_archived,
       workspace_id,
       user_id,
-      include_source
+      include_source,
+      retrieval_mode
     }) => {
       try {
         if (!recent && !query) {
@@ -7121,7 +7409,7 @@ function registerRecallMyMemory(server) {
           };
         }
         const { agentId } = getActiveAgent();
-        const searchOptions = {
+        const searchOptions = applyRetrievalMode({
           projectName: project_name,
           hasError: has_error,
           toolName: tool_name,
@@ -7132,7 +7420,7 @@ function registerRecallMyMemory(server) {
           includeSource: include_source,
           includeDrafts: true,
           ...user_id !== void 0 ? { userId: user_id } : {}
-        };
+        }, retrieval_mode);
         let results;
         if (recent) {
           results = await recentRecords(agentId, searchOptions, limit, query);
@@ -7190,6 +7478,7 @@ var init_recall_my_memory = __esm({
     init_hybrid_search();
     init_store();
     init_active_agent();
+    init_memory_retrieval_modes();
   }
 });
 
@@ -7225,10 +7514,11 @@ function registerAskTeamMemory(server) {
         ),
         include_raw: z2.boolean().optional().default(false).describe(
           "Include raw technical memories when ACL allows it (default: non-raw memories only for cross-agent reads)"
-        )
+        ),
+        retrieval_mode: z2.enum(RETRIEVAL_MODES).optional().default("all").describe(`Typed retrieval mode. Raw visibility is still ACL-gated. ${formatRetrievalModes()}`)
       }
     },
-    async ({ team_member, query, project_name, limit, since, include_archived, include_raw: _include_raw }) => {
+    async ({ team_member, query, project_name, limit, since, include_archived, include_raw: _include_raw, retrieval_mode }) => {
       try {
         const { agentId: queryingAgentId, agentRole: queryingAgentRole } = getActiveAgent();
         const employees = loadEmployeesSync();
@@ -7237,16 +7527,18 @@ function registerAskTeamMemory(server) {
         const targetRole = targetEmployee?.role ?? "";
         const hasRawAccess = canSeeRaw(queryingRole, targetRole);
         const effectiveIncludeRaw = _include_raw && hasRawAccess;
-        const results = await hybridSearch(query, team_member, {
+        const requestedMode = retrieval_mode ?? "all";
+        const safeMode = !effectiveIncludeRaw && ["all", "operational"].includes(requestedMode) ? "no_raw" : requestedMode;
+        const searchOptions = applyRetrievalMode({
           projectName: project_name,
           limit,
           since,
           includeArchived: include_archived,
           includeDrafts: false,
-          includeRaw: effectiveIncludeRaw,
-          memoryType: void 0
-          // Show all memory types — privacy enforced by draft filter + ACL, not type filter
-        });
+          includeRaw: effectiveIncludeRaw
+        }, safeMode);
+        if (!effectiveIncludeRaw) searchOptions.includeRaw = false;
+        const results = await hybridSearch(query, team_member, searchOptions);
         if (results.length === 0) {
           return {
             content: [
@@ -7288,6 +7580,7 @@ var init_ask_team_memory = __esm({
     init_hybrid_search();
     init_active_agent();
     init_employees();
+    init_memory_retrieval_modes();
   }
 });
 
@@ -9930,7 +10223,11 @@ function spawnEmployee(employeeName, exeSession, projectDir, opts) {
   }
   if (!useExeAgent && !useCodex && !useOpencode && !useBinSymlink) {
     if (agentRtConfig.runtime === "claude" && agentRtConfig.model) {
-      envPrefix = `${envPrefix} ANTHROPIC_MODEL=${agentRtConfig.model}`;
+      let ccModel = agentRtConfig.model.replace(/(\d+)\.(\d+)/g, "$1-$2");
+      if (/claude-(opus|sonnet)-4-[6-9]/.test(ccModel) && !ccModel.includes("[1m]")) {
+        ccModel += "[1m]";
+      }
+      envPrefix = `${envPrefix} ANTHROPIC_MODEL=${ccModel}`;
     }
   }
   let spawnCommand;
@@ -15095,8 +15392,9 @@ var init_starter_packs = __esm({
 
 // src/lib/employee-templates.ts
 function renderClientCOOTemplate(vars) {
+  const resolved = { ...vars, title: vars.title || "Chief Operating Officer" };
   for (const key of CLIENT_COO_PLACEHOLDERS) {
-    const value = vars[key];
+    const value = resolved[key];
     if (typeof value !== "string" || value.length === 0) {
       throw new Error(
         `renderClientCOOTemplate: missing required variable "${key}"`
@@ -15105,7 +15403,7 @@ function renderClientCOOTemplate(vars) {
   }
   let out = CLIENT_COO_TEMPLATE;
   for (const key of CLIENT_COO_PLACEHOLDERS) {
-    out = out.split(`{{${key}}}`).join(vars[key]);
+    out = out.split(`{{${key}}}`).join(resolved[key]);
   }
   if (vars.industry_context) {
     out += "\n" + vars.industry_context;
@@ -15126,7 +15424,7 @@ created_by: system
 ---
 ## Identity
 
-You are {{agent_name}}, the Chief Operating Officer at {{company_name}}.
+You are {{agent_name}}, the {{title}} at {{company_name}}.
 
 You are {{founder_name}}'s most reliable teammate in business \u2014 the knowledgeable older sibling who has been through it all. You have seen projects succeed and fail. You know what matters and what is noise. You do not get anxious about problems; you see them coming, stay calm, and handle them.
 
@@ -15213,7 +15511,8 @@ All memory, tasks, behaviors, documents, and wiki content belonging to {{company
     CLIENT_COO_PLACEHOLDERS = [
       "agent_name",
       "company_name",
-      "founder_name"
+      "founder_name",
+      "title"
     ];
   }
 });
@@ -15387,6 +15686,7 @@ ${vars}`);
               agent_name,
               company_name,
               founder_name,
+              title: "Chief Operating Officer",
               industry_context: pack.identityContext ?? void 0
             });
             cooSummaryLines = [
@@ -26959,7 +27259,6 @@ import { createServer as createHttpServer } from "http";
 import { randomUUID as randomUUID9 } from "crypto";
 import { writeFileSync as writeFileSync24, unlinkSync as unlinkSync13, mkdirSync as mkdirSync19, existsSync as existsSync39, readFileSync as readFileSync33, chmodSync as chmodSync2 } from "fs";
 import path51 from "path";
-import { getLlama } from "node-llama-cpp";
 
 // src/lib/orchestration-metrics.ts
 init_config();
@@ -27030,6 +27329,7 @@ function initMetrics() {
 }
 
 // src/lib/exe-daemon.ts
+init_memory_write_governor();
 var SOCKET_PATH2 = process.env.EXE_DAEMON_SOCK ?? process.env.EXE_EMBED_SOCK ?? path51.join(EXE_AI_DIR, "exed.sock");
 var PID_PATH3 = process.env.EXE_DAEMON_PID ?? process.env.EXE_EMBED_PID ?? path51.join(EXE_AI_DIR, "exed.pid");
 var MODEL_FILE = "jina-embeddings-v5-small-q4_k_m.gguf";
@@ -27061,15 +27361,22 @@ function enqueue(queue, entry) {
 async function loadModel() {
   const modelPath = path51.join(MODELS_DIR, MODEL_FILE);
   if (!existsSync39(modelPath)) {
-    process.stderr.write(`[exed] FATAL: model not found at ${modelPath}
+    process.stderr.write(`[exed] No model at ${modelPath} \u2014 running without embeddings (VPS mode).
 `);
-    process.exit(1);
+    return;
   }
   process.stderr.write("[exed] Loading model...\n");
-  _llama = await getLlama();
-  _model = await _llama.loadModel({ modelPath });
-  _context = await _model.createEmbeddingContext();
-  process.stderr.write("[exed] Model loaded and ready.\n");
+  try {
+    const { getLlama } = await import("node-llama-cpp");
+    _llama = await getLlama();
+    _model = await _llama.loadModel({ modelPath });
+    _context = await _model.createEmbeddingContext();
+    process.stderr.write("[exed] Model loaded and ready.\n");
+  } catch (err) {
+    process.stderr.write(`[exed] Model load failed (non-fatal): ${err instanceof Error ? err.message : String(err)}
+`);
+    process.stderr.write("[exed] Running without embeddings \u2014 memories will have null vectors.\n");
+  }
 }
 async function processQueue() {
   if (_processing) return;
@@ -27252,43 +27559,19 @@ async function handleIngest(req) {
   try {
     if (!await ensureStoreForPolling()) return;
     if (!req.rawText || req.rawText.length < 50) return;
-    let vectorBlob = null;
-    if (_context) {
-      try {
-        const embedding = await _context.getEmbeddingFor(req.rawText);
-        const vector = Array.from(embedding.vector);
-        embedding.vector = null;
-        if (vector.length === EMBEDDING_DIM) {
-          const { vectorToBlob: vectorToBlob2 } = await Promise.resolve().then(() => (init_store(), store_exports));
-          vectorBlob = vectorToBlob2(vector);
-        }
-      } catch {
-      }
-    }
-    const { getClient: getClient2 } = await Promise.resolve().then(() => (init_database(), database_exports));
-    const client = getClient2();
-    const { randomUUID: randomUUID10 } = await import("crypto");
-    const id = randomUUID10();
-    const now = (/* @__PURE__ */ new Date()).toISOString();
-    await client.execute({
-      sql: `INSERT INTO memories (id, agent_id, agent_role, session_id, timestamp, tool_name, project_name, has_error, raw_text, vector, task_id, confidence, draft, memory_type, trajectory)
-            VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, 'raw', ?)`,
-      args: [
-        id,
-        req.agentId,
-        req.agentRole,
-        req.sessionId,
-        now,
-        req.toolName,
-        req.projectName,
-        req.hasError ? 1 : 0,
-        req.rawText,
-        vectorBlob,
-        req.taskId ?? null,
-        req.confidence ?? 0.7,
-        req.draft ? 1 : 0,
-        req.trajectory ? JSON.stringify(req.trajectory) : null
-      ]
+    await writeMemoryRecord({
+      raw_text: req.rawText,
+      agent_id: req.agentId,
+      agent_role: req.agentRole,
+      session_id: req.sessionId,
+      tool_name: req.toolName,
+      project_name: req.projectName,
+      has_error: req.hasError,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      task_id: req.taskId ?? void 0,
+      confidence: req.confidence,
+      draft: req.draft,
+      trajectory: req.trajectory ? JSON.stringify(req.trajectory) : void 0
     });
     _ingestCount++;
   } catch (err) {
@@ -27336,10 +27619,38 @@ async function handleBatchWriteMemory(socket, requestId, entries) {
   }
 }
 async function writeMemoryRecord(entry) {
+  const id = randomUUID9();
+  const now = entry.timestamp || (/* @__PURE__ */ new Date()).toISOString();
+  const governed = governMemoryRecord({
+    id,
+    agent_id: entry.agent_id,
+    agent_role: entry.agent_role ?? "",
+    session_id: entry.session_id,
+    timestamp: now,
+    tool_name: entry.tool_name,
+    project_name: entry.project_name,
+    has_error: !!entry.has_error,
+    raw_text: entry.raw_text,
+    vector: null,
+    task_id: entry.task_id ?? null,
+    importance: entry.importance ?? 5,
+    confidence: entry.confidence ?? 0.7,
+    draft: entry.draft ?? false,
+    memory_type: entry.memory_type
+  });
+  if (governed.shouldDrop) return id;
+  const record = governed.record;
+  const duplicate = await findScopedDuplicate({
+    contentHash: governed.contentHash,
+    agentId: record.agent_id,
+    projectName: record.project_name,
+    memoryType: record.memory_type ?? "raw"
+  });
+  if (duplicate) return duplicate;
   let vectorBlob = null;
-  if (_context) {
+  if (_context && !governed.skipEmbedding) {
     try {
-      const embedding = await _context.getEmbeddingFor(entry.raw_text);
+      const embedding = await _context.getEmbeddingFor(record.raw_text);
       const vector = Array.from(embedding.vector);
       embedding.vector = null;
       if (vector.length === EMBEDDING_DIM) {
@@ -27351,29 +27662,61 @@ async function writeMemoryRecord(entry) {
   }
   const { getClient: getClient2 } = await Promise.resolve().then(() => (init_database(), database_exports));
   const client = getClient2();
-  const { randomUUID: randomUUID10 } = await import("crypto");
-  const id = randomUUID10();
-  const now = entry.timestamp || (/* @__PURE__ */ new Date()).toISOString();
+  const vResult = await client.execute("SELECT MAX(version) as max_v FROM memories");
+  const version = (Number(vResult.rows[0]?.max_v) || 0) + 1;
+  const hasVector = vectorBlob !== null;
   await client.execute({
-    sql: `INSERT INTO memories (id, agent_id, agent_role, session_id, timestamp, tool_name, project_name, has_error, raw_text, vector, task_id, confidence, draft, memory_type, trajectory)
-          VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, 'raw', ?)`,
-    args: [
+    sql: hasVector ? `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, draft, memory_type, trajectory, content_hash)
+         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, vector32(?), ?, ?, ?, 'active', ?, ?, ?, ?, ?, ?)` : `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, draft, memory_type, trajectory, content_hash)
+         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, NULL, ?, ?, ?, 'active', ?, ?, ?, ?, ?, ?)`,
+    args: hasVector ? [
       id,
-      entry.agent_id,
-      entry.agent_role ?? null,
-      entry.session_id,
-      now,
-      entry.tool_name,
-      entry.project_name,
-      entry.has_error ? 1 : 0,
-      entry.raw_text,
+      record.agent_id,
+      record.agent_role,
+      record.session_id,
+      record.timestamp,
+      record.tool_name,
+      record.project_name,
+      record.has_error ? 1 : 0,
+      record.raw_text,
       vectorBlob,
-      entry.task_id ?? null,
-      entry.importance ?? 0.7,
-      entry.draft ? 1 : 0,
-      entry.trajectory ?? null
+      version,
+      record.task_id ?? null,
+      record.importance ?? 5,
+      record.confidence ?? 0.7,
+      record.timestamp,
+      record.draft ? 1 : 0,
+      record.memory_type ?? "raw",
+      entry.trajectory ?? null,
+      governed.contentHash
+    ] : [
+      id,
+      record.agent_id,
+      record.agent_role,
+      record.session_id,
+      record.timestamp,
+      record.tool_name,
+      record.project_name,
+      record.has_error ? 1 : 0,
+      record.raw_text,
+      version,
+      record.task_id ?? null,
+      record.importance ?? 5,
+      record.confidence ?? 0.7,
+      record.timestamp,
+      record.draft ? 1 : 0,
+      record.memory_type ?? "raw",
+      entry.trajectory ?? null,
+      governed.contentHash
     ]
   });
+  schedulePostWriteMemoryHygiene([id]);
   return id;
 }
 var MEMORY_DRAIN_INTERVAL_MS = 30 * 1e3;