@askexenow/exe-os 0.9.34 → 0.9.35

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,811 @@ 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 (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',
-      content_rowid='rowid'
+    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 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;
+    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;
   `);
-  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 +3789,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;
   }
 });
 
@@ -4373,7 +4572,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 +4685,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 +4733,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 +4892,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));
@@ -4945,6 +5151,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 +5377,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");
@@ -9930,7 +10137,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;
@@ -26959,7 +27170,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 +27240,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 +27272,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 +27470,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 +27530,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 +27573,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;