@askexenow/exe-os 0.8.0 → 0.8.1

package/dist/hooks/session-start.js

@@ -95,6 +95,11 @@ function normalizeSessionLifecycle(raw) {
   const userSL = raw.sessionLifecycle ?? {};
   raw.sessionLifecycle = { ...defaultSL, ...userSL };
 }
+function normalizeAutoUpdate(raw) {
+  const defaultAU = DEFAULT_CONFIG.autoUpdate;
+  const userAU = raw.autoUpdate ?? {};
+  raw.autoUpdate = { ...defaultAU, ...userAU };
+}
 async function loadConfig() {
   const dir = process.env.EXE_OS_DIR ?? process.env.EXE_MEM_DIR ?? EXE_AI_DIR;
   await mkdir(dir, { recursive: true });
@@ -117,6 +122,7 @@ async function loadConfig() {
     }
     normalizeScalingRoadmap(migratedCfg);
     normalizeSessionLifecycle(migratedCfg);
+    normalizeAutoUpdate(migratedCfg);
     const config = { ...DEFAULT_CONFIG, dbPath: path.join(dir, "memories.db"), ...migratedCfg };
     if (config.dbPath.startsWith("~")) {
       config.dbPath = config.dbPath.replace(/^~/, os.homedir());
@@ -139,6 +145,7 @@ function loadConfigSync() {
     const { config: migratedCfg } = migrateConfig(parsed);
     normalizeScalingRoadmap(migratedCfg);
     normalizeSessionLifecycle(migratedCfg);
+    normalizeAutoUpdate(migratedCfg);
     return { ...DEFAULT_CONFIG, dbPath: path.join(dir, "memories.db"), ...migratedCfg };
   } catch {
     return { ...DEFAULT_CONFIG, dbPath: path.join(dir, "memories.db") };
@@ -158,6 +165,7 @@ async function loadConfigFrom(configPath) {
     const { config: migratedCfg } = migrateConfig(parsed);
     normalizeScalingRoadmap(migratedCfg);
     normalizeSessionLifecycle(migratedCfg);
+    normalizeAutoUpdate(migratedCfg);
     return { ...DEFAULT_CONFIG, ...migratedCfg };
   } catch {
     return { ...DEFAULT_CONFIG };
@@ -229,6 +237,11 @@ var init_config = __esm({
         idleKillTicksRequired: 3,
         idleKillIntercomAckWindowMs: 1e4,
         maxAutoInstances: 10
+      },
+      autoUpdate: {
+        checkOnBoot: true,
+        autoInstall: false,
+        checkIntervalMs: 24 * 60 * 60 * 1e3
       }
     };
     CONFIG_MIGRATIONS = [
@@ -253,63 +266,29 @@ var init_memory = __esm({
   }
 });
 
-// src/lib/shard-manager.ts
-var shard_manager_exports = {};
-__export(shard_manager_exports, {
-  disposeShards: () => disposeShards,
-  ensureShardSchema: () => ensureShardSchema,
-  getReadyShardClient: () => getReadyShardClient,
-  getShardClient: () => getShardClient,
-  getShardsDir: () => getShardsDir,
-  initShardManager: () => initShardManager,
-  isShardingEnabled: () => isShardingEnabled,
-  listShards: () => listShards,
-  shardExists: () => shardExists
-});
-import path3 from "path";
-import { existsSync as existsSync3, mkdirSync } from "fs";
-import { createClient as createClient2 } from "@libsql/client";
-function initShardManager(encryptionKey) {
-  _encryptionKey = encryptionKey;
-  if (!existsSync3(SHARDS_DIR)) {
-    mkdirSync(SHARDS_DIR, { recursive: true });
-  }
-  _shardingEnabled = true;
-}
-function isShardingEnabled() {
-  return _shardingEnabled;
-}
-function getShardsDir() {
-  return SHARDS_DIR;
-}
-function getShardClient(projectName) {
-  if (!_encryptionKey) {
-    throw new Error("Shard manager not initialized. Call initShardManager() first.");
+// src/lib/database.ts
+import { createClient } from "@libsql/client";
+async function initDatabase(config) {
+  if (_client) {
+    _client.close();
+    _client = null;
   }
-  const safeName = projectName.replace(/[^a-zA-Z0-9_-]/g, "_");
-  if (!safeName) {
-    throw new Error(`Invalid project name for shard: "${projectName}"`);
+  const opts = {
+    url: `file:${config.dbPath}`
+  };
+  if (config.encryptionKey) {
+    opts.encryptionKey = config.encryptionKey;
   }
-  const cached = _shards.get(safeName);
-  if (cached) return cached;
-  const dbPath = path3.join(SHARDS_DIR, `${safeName}.db`);
-  const client = createClient2({
-    url: `file:${dbPath}`,
-    encryptionKey: _encryptionKey
-  });
-  _shards.set(safeName, client);
-  return client;
-}
-function shardExists(projectName) {
-  const safeName = projectName.replace(/[^a-zA-Z0-9_-]/g, "_");
-  return existsSync3(path3.join(SHARDS_DIR, `${safeName}.db`));
+  _client = createClient(opts);
 }
-function listShards() {
-  if (!existsSync3(SHARDS_DIR)) return [];
-  const { readdirSync: readdirSync3 } = __require("fs");
-  return readdirSync3(SHARDS_DIR).filter((f) => f.endsWith(".db")).map((f) => f.replace(".db", ""));
+function getClient() {
+  if (!_client) {
+    throw new Error("Database client not initialized. Call initDatabase() first.");
+  }
+  return _client;
 }
-async function ensureShardSchema(client) {
+async function ensureSchema() {
+  const client = getClient();
   await client.execute("PRAGMA journal_mode = WAL");
   await client.execute("PRAGMA busy_timeout = 5000");
   try {
@@ -331,9 +310,26 @@ async function ensureShardSchema(client) {
       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);
+    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_session
+      ON memories(session_id);
+
+    CREATE INDEX IF NOT EXISTS idx_memories_project
+      ON memories(project_name);
+
+    CREATE INDEX IF NOT EXISTS idx_memories_tool
+      ON memories(tool_name);
+
+    CREATE INDEX IF NOT EXISTS idx_memories_version
+      ON memories(version);
+
+    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(
@@ -355,1481 +351,972 @@ async function ensureShardSchema(client) {
       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 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"
-  ]) {
-    try {
-      await client.execute(col);
-    } catch {
-    }
-  }
-  try {
-    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 sync_meta (
+      key   TEXT PRIMARY KEY,
+      value TEXT NOT NULL
     );
-
-    CREATE TABLE IF NOT EXISTS relationship_memories (
-      relationship_id TEXT NOT NULL,
-      memory_id TEXT NOT NULL,
-      PRIMARY KEY (relationship_id, memory_id)
+  `);
+  await client.executeMultiple(`
+    CREATE TABLE IF NOT EXISTS tasks (
+      id            TEXT PRIMARY KEY,
+      title         TEXT NOT NULL,
+      assigned_to   TEXT NOT NULL,
+      assigned_by   TEXT NOT NULL,
+      project_name  TEXT NOT NULL,
+      priority      TEXT NOT NULL DEFAULT 'p1',
+      status        TEXT NOT NULL DEFAULT 'open',
+      task_file     TEXT,
+      created_at    TEXT NOT NULL,
+      updated_at    TEXT NOT NULL
     );
 
-    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 INDEX IF NOT EXISTS idx_tasks_assignee_status
+      ON tasks(assigned_to, status);
+  `);
+  await client.executeMultiple(`
+    CREATE TABLE IF NOT EXISTS behaviors (
+      id           TEXT PRIMARY KEY,
+      agent_id     TEXT NOT NULL,
+      project_name TEXT,
+      domain       TEXT,
+      content      TEXT NOT NULL,
+      active       INTEGER NOT NULL DEFAULT 1,
+      created_at   TEXT NOT NULL,
+      updated_at   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)
-    );
+    CREATE INDEX IF NOT EXISTS idx_behaviors_agent
+      ON behaviors(agent_id, active);
   `);
-  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 existing = await client.execute({
+      sql: "SELECT COUNT(*) as cnt FROM behaviors WHERE agent_id = 'exe'",
+      args: []
+    });
+    if (Number(existing.rows[0]?.cnt) === 0) {
+      await client.executeMultiple(`
+        INSERT INTO behaviors (id, agent_id, project_name, domain, content, active, created_at, updated_at)
+        VALUES
+          (hex(randomblob(16)), 'exe', NULL, 'workflow', 'Don''t ask "keep going?" \u2014 just keep executing phases/plans autonomously', 1, '2026-03-25T00:00:00Z', '2026-03-25T00:00:00Z');
+        INSERT INTO behaviors (id, agent_id, project_name, domain, content, active, created_at, updated_at)
+        VALUES
+          (hex(randomblob(16)), 'exe', NULL, 'tool-use', 'Always use create_task MCP tool, never write .md files directly for task creation', 1, '2026-03-25T00:00:00Z', '2026-03-25T00:00:00Z');
+        INSERT INTO behaviors (id, agent_id, project_name, domain, content, active, created_at, updated_at)
+        VALUES
+          (hex(randomblob(16)), 'exe', NULL, 'workflow', 'Auto-start reviewing when idle and reviews are pending \u2014 never ask founder for permission', 1, '2026-03-25T00:00:00Z', '2026-03-25T00:00:00Z');
+      `);
     }
+  } catch {
   }
-}
-async function getReadyShardClient(projectName) {
-  const client = getShardClient(projectName);
-  await ensureShardSchema(client);
-  return client;
-}
-function disposeShards() {
-  for (const [, client] of _shards) {
-    client.close();
-  }
-  _shards.clear();
-  _shardingEnabled = false;
-  _encryptionKey = null;
-}
-var SHARDS_DIR, _shards, _encryptionKey, _shardingEnabled;
-var init_shard_manager = __esm({
-  "src/lib/shard-manager.ts"() {
-    "use strict";
-    init_config();
-    SHARDS_DIR = path3.join(EXE_AI_DIR, "shards");
-    _shards = /* @__PURE__ */ new Map();
-    _encryptionKey = null;
-    _shardingEnabled = false;
-  }
-});
-
-// src/lib/self-query-router.ts
-var self_query_router_exports = {};
-__export(self_query_router_exports, {
-  routeQuery: () => routeQuery
-});
-async function routeQuery(query, model = "claude-haiku-4-5-20251001") {
-  if (query.length < 10) {
-    return {
-      semanticQuery: query,
-      projectFilter: null,
-      roleFilter: null,
-      timeFilter: null,
-      isBroadQuery: false
-    };
+  try {
+    await client.execute({
+      sql: `ALTER TABLE behaviors ADD COLUMN priority TEXT DEFAULT 'p1'`,
+      args: []
+    });
+  } catch {
   }
   try {
-    const Anthropic = (await import("@anthropic-ai/sdk")).default;
-    const client = new Anthropic();
-    const now = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
-    const response = await client.messages.create({
-      model,
-      max_tokens: 256,
-      system: `You are a search query router. Extract metadata filters from the user's memory search query. Today is ${now}. Convert relative time references (yesterday, last week) to ISO timestamps.`,
-      messages: [{ role: "user", content: query }],
-      tools: [EXTRACT_TOOL],
-      tool_choice: { type: "tool", name: "extract_search_filters" }
+    await client.execute({
+      sql: `ALTER TABLE tasks ADD COLUMN blocked_by TEXT`,
+      args: []
     });
-    const toolBlock = response.content.find((b) => b.type === "tool_use");
-    if (toolBlock && toolBlock.type === "tool_use") {
-      const input2 = toolBlock.input;
-      return {
-        semanticQuery: input2.semantic_query || query,
-        projectFilter: input2.project_filter || null,
-        roleFilter: input2.role_filter || null,
-        timeFilter: input2.time_filter || null,
-        isBroadQuery: Boolean(input2.is_broad_query)
-      };
-    }
-  } catch (err) {
-    process.stderr.write(
-      `[self-query-router] LLM extraction failed, using passthrough: ${err instanceof Error ? err.message : String(err)}
-`
-    );
-  }
-  return {
-    semanticQuery: query,
-    projectFilter: null,
-    roleFilter: null,
-    timeFilter: null,
-    isBroadQuery: false
-  };
-}
-var EXTRACT_TOOL;
-var init_self_query_router = __esm({
-  "src/lib/self-query-router.ts"() {
-    "use strict";
-    EXTRACT_TOOL = {
-      name: "extract_search_filters",
-      description: "Extract metadata filters from a memory search query to improve retrieval precision.",
-      input_schema: {
-        type: "object",
-        properties: {
-          semantic_query: {
-            type: "string",
-            description: "The core semantic meaning of the query, stripped of metadata references. This is used for embedding search."
-          },
-          project_filter: {
-            type: ["string", "null"],
-            description: "Project name if the query references a specific project (e.g., 'exe-os', 'exe-create'). Null if no project specified."
-          },
-          role_filter: {
-            type: ["string", "null"],
-            description: "Agent role if the query targets a specific role (e.g., 'CTO', 'CMO'). Null if no role specified."
-          },
-          time_filter: {
-            type: ["string", "null"],
-            description: "ISO 8601 timestamp lower bound if the query references a time period (e.g., 'last week', 'yesterday'). Null if no time reference."
-          },
-          is_broad_query: {
-            type: "boolean",
-            description: "True if the query is exploratory/broad (e.g., 'what has yoshi been working on', 'summarize recent activity'). False if targeted (e.g., 'how did we fix the auth bug')."
-          }
-        },
-        required: ["semantic_query", "project_filter", "role_filter", "time_filter", "is_broad_query"]
-      }
-    };
-  }
-});
-
-// src/lib/exe-daemon-client.ts
-import net from "net";
-import { spawn } from "child_process";
-import { randomUUID } from "crypto";
-import { existsSync as existsSync4, unlinkSync, readFileSync as readFileSync2, openSync, closeSync, statSync } from "fs";
-import path4 from "path";
-import { fileURLToPath } from "url";
-function handleData(chunk) {
-  _buffer += chunk.toString();
-  let newlineIdx;
-  while ((newlineIdx = _buffer.indexOf("\n")) !== -1) {
-    const line = _buffer.slice(0, newlineIdx).trim();
-    _buffer = _buffer.slice(newlineIdx + 1);
-    if (!line) continue;
-    try {
-      const response = JSON.parse(line);
-      const entry = _pending.get(response.id);
-      if (entry) {
-        clearTimeout(entry.timer);
-        _pending.delete(response.id);
-        entry.resolve(response);
-      }
-    } catch {
-    }
+  } catch {
   }
-}
-function cleanupStaleFiles() {
-  if (existsSync4(PID_PATH)) {
-    try {
-      const pid = parseInt(readFileSync2(PID_PATH, "utf8").trim(), 10);
-      if (pid > 0) {
-        try {
-          process.kill(pid, 0);
-          return;
-        } catch {
-        }
-      }
-    } catch {
-    }
-    try {
-      unlinkSync(PID_PATH);
-    } catch {
-    }
-    try {
-      unlinkSync(SOCKET_PATH);
-    } catch {
-    }
+  try {
+    await client.execute({
+      sql: `ALTER TABLE tasks ADD COLUMN parent_task_id TEXT`,
+      args: []
+    });
+  } catch {
   }
-}
-function findPackageRoot() {
-  let dir = path4.dirname(fileURLToPath(import.meta.url));
-  const { root } = path4.parse(dir);
-  while (dir !== root) {
-    if (existsSync4(path4.join(dir, "package.json"))) return dir;
-    dir = path4.dirname(dir);
+  try {
+    await client.execute({
+      sql: `CREATE INDEX IF NOT EXISTS idx_tasks_parent_task_id
+              ON tasks(parent_task_id)
+              WHERE parent_task_id IS NOT NULL`,
+      args: []
+    });
+  } catch {
   }
-  return null;
-}
-function spawnDaemon() {
-  const pkgRoot = findPackageRoot();
-  if (!pkgRoot) {
-    process.stderr.write("[exed-client] WARN: cannot find package root\n");
-    return;
+  try {
+    await client.execute({
+      sql: `UPDATE tasks SET status = 'done' WHERE status = 'completed'`,
+      args: []
+    });
+  } catch {
   }
-  const daemonPath = path4.join(pkgRoot, "dist", "lib", "exe-daemon.js");
-  if (!existsSync4(daemonPath)) {
-    process.stderr.write(`[exed-client] WARN: daemon script not found at ${daemonPath}
-`);
-    return;
+  try {
+    await client.execute({
+      sql: `ALTER TABLE tasks ADD COLUMN reviewer TEXT`,
+      args: []
+    });
+  } catch {
   }
-  const resolvedPath = daemonPath;
-  process.stderr.write(`[exed-client] Spawning daemon: ${resolvedPath}
-`);
-  const logPath = path4.join(path4.dirname(SOCKET_PATH), "exed.log");
-  let stderrFd = "ignore";
   try {
-    stderrFd = openSync(logPath, "a");
+    await client.execute({
+      sql: `ALTER TABLE tasks ADD COLUMN context TEXT`,
+      args: []
+    });
   } catch {
   }
-  const child = spawn(process.execPath, [resolvedPath], {
-    detached: true,
-    stdio: ["ignore", "ignore", stderrFd],
-    env: {
-      ...process.env,
-      EXE_DAEMON_SOCK: SOCKET_PATH,
-      EXE_DAEMON_PID: PID_PATH
-    }
-  });
-  child.unref();
-  if (typeof stderrFd === "number") {
-    try {
-      closeSync(stderrFd);
-    } catch {
-    }
+  try {
+    await client.execute({
+      sql: `ALTER TABLE tasks ADD COLUMN result TEXT`,
+      args: []
+    });
+  } catch {
   }
-}
-function acquireSpawnLock() {
   try {
-    const fd = openSync(SPAWN_LOCK_PATH, "wx");
-    closeSync(fd);
-    return true;
+    await client.execute({
+      sql: `ALTER TABLE tasks ADD COLUMN assigned_tmux TEXT`,
+      args: []
+    });
   } catch {
-    try {
-      const stat = statSync(SPAWN_LOCK_PATH);
-      if (Date.now() - stat.mtimeMs > SPAWN_LOCK_STALE_MS) {
-        try {
-          unlinkSync(SPAWN_LOCK_PATH);
-        } catch {
-        }
-        try {
-          const fd = openSync(SPAWN_LOCK_PATH, "wx");
-          closeSync(fd);
-          return true;
-        } catch {
-        }
-      }
-    } catch {
-    }
-    return false;
   }
-}
-function releaseSpawnLock() {
   try {
-    unlinkSync(SPAWN_LOCK_PATH);
+    await client.execute({
+      sql: `ALTER TABLE tasks ADD COLUMN checkpoint TEXT`,
+      args: []
+    });
   } catch {
   }
-}
-function connectToSocket() {
-  return new Promise((resolve) => {
-    if (_socket && _connected) {
-      resolve(true);
-      return;
-    }
-    const socket = net.createConnection({ path: SOCKET_PATH });
-    const connectTimeout = setTimeout(() => {
-      socket.destroy();
-      resolve(false);
-    }, 2e3);
-    socket.on("connect", () => {
-      clearTimeout(connectTimeout);
-      _socket = socket;
-      _connected = true;
-      _buffer = "";
-      socket.on("data", handleData);
-      socket.on("close", () => {
-        _connected = false;
-        _socket = null;
-        for (const [id, entry] of _pending) {
-          clearTimeout(entry.timer);
-          _pending.delete(id);
-          entry.resolve({ error: "Connection closed" });
-        }
-      });
-      socket.on("error", () => {
-        _connected = false;
-        _socket = null;
-      });
-      resolve(true);
-    });
-    socket.on("error", () => {
-      clearTimeout(connectTimeout);
-      resolve(false);
+  try {
+    await client.execute({
+      sql: `ALTER TABLE tasks ADD COLUMN checkpoint_count INTEGER NOT NULL DEFAULT 0`,
+      args: []
     });
-  });
-}
-async function connectEmbedDaemon() {
-  if (_socket && _connected) return true;
-  if (await connectToSocket()) return true;
-  if (acquireSpawnLock()) {
-    try {
-      cleanupStaleFiles();
-      spawnDaemon();
-    } finally {
-      releaseSpawnLock();
-    }
-  }
-  const start = Date.now();
-  let delay = 100;
-  while (Date.now() - start < CONNECT_TIMEOUT_MS) {
-    await new Promise((r) => setTimeout(r, delay));
-    if (await connectToSocket()) return true;
-    delay = Math.min(delay * 2, 3e3);
+  } catch {
   }
-  return false;
-}
-function sendRequest(texts, priority) {
-  return new Promise((resolve) => {
-    if (!_socket || !_connected) {
-      resolve({ error: "Not connected" });
-      return;
-    }
-    const id = randomUUID();
-    const timer = setTimeout(() => {
-      _pending.delete(id);
-      resolve({ error: "Request timeout" });
-    }, REQUEST_TIMEOUT_MS);
-    _pending.set(id, { resolve, timer });
-    try {
-      _socket.write(JSON.stringify({ id, texts, priority }) + "\n");
-    } catch {
-      clearTimeout(timer);
-      _pending.delete(id);
-      resolve({ error: "Write failed" });
-    }
-  });
-}
-async function pingDaemon() {
-  if (!_socket || !_connected) return null;
-  return new Promise((resolve) => {
-    const id = randomUUID();
-    const timer = setTimeout(() => {
-      _pending.delete(id);
-      resolve(null);
-    }, 5e3);
-    _pending.set(id, {
-      resolve: (data) => {
-        if (data.health) {
-          resolve(data.health);
-        } else {
-          resolve(null);
-        }
-      },
-      timer
+  try {
+    await client.execute({
+      sql: `ALTER TABLE tasks ADD COLUMN complexity TEXT NOT NULL DEFAULT 'standard'`,
+      args: []
     });
-    try {
-      _socket.write(JSON.stringify({ id, type: "health" }) + "\n");
-    } catch {
-      clearTimeout(timer);
-      _pending.delete(id);
-      resolve(null);
-    }
-  });
-}
-function killAndRespawnDaemon() {
-  process.stderr.write("[exed-client] Killing daemon for restart...\n");
-  if (existsSync4(PID_PATH)) {
-    try {
-      const pid = parseInt(readFileSync2(PID_PATH, "utf8").trim(), 10);
-      if (pid > 0) {
-        try {
-          process.kill(pid, "SIGKILL");
-        } catch {
-        }
-      }
-    } catch {
-    }
-  }
-  if (_socket) {
-    _socket.destroy();
-    _socket = null;
+  } catch {
   }
-  _connected = false;
-  _buffer = "";
   try {
-    unlinkSync(PID_PATH);
+    await client.execute({
+      sql: `ALTER TABLE memories ADD COLUMN task_id TEXT`,
+      args: []
+    });
   } catch {
   }
   try {
-    unlinkSync(SOCKET_PATH);
+    await client.execute({
+      sql: `ALTER TABLE memories ADD COLUMN consolidated INTEGER NOT NULL DEFAULT 0`,
+      args: []
+    });
   } catch {
   }
-  spawnDaemon();
-}
-async function embedViaClient(text, priority = "high") {
-  if (!_connected && !await connectEmbedDaemon()) return null;
-  _requestCount++;
-  if (_requestCount % HEALTH_CHECK_INTERVAL === 0) {
-    const health = await pingDaemon();
-    if (!health) {
-      process.stderr.write(`[exed-client] Periodic health check failed at request ${_requestCount} \u2014 restarting daemon
-`);
-      killAndRespawnDaemon();
-      const start = Date.now();
-      let delay = 200;
-      while (Date.now() - start < CONNECT_TIMEOUT_MS) {
-        await new Promise((r) => setTimeout(r, delay));
-        if (await connectToSocket()) break;
-        delay = Math.min(delay * 2, 3e3);
-      }
-      if (!_connected) return null;
-    }
-  }
-  const result = await sendRequest([text], priority);
-  if (!result.error && result.vectors?.[0]) return result.vectors[0];
-  if (result.error) {
-    process.stderr.write(`[exed-client] Embed failed (${result.error}) \u2014 attempting restart
-`);
-    killAndRespawnDaemon();
-    const start = Date.now();
-    let delay = 200;
-    while (Date.now() - start < CONNECT_TIMEOUT_MS) {
-      await new Promise((r) => setTimeout(r, delay));
-      if (await connectToSocket()) break;
-      delay = Math.min(delay * 2, 3e3);
-    }
-    if (!_connected) return null;
-    const retry = await sendRequest([text], priority);
-    if (!retry.error && retry.vectors?.[0]) return retry.vectors[0];
-    process.stderr.write(`[exed-client] Embed retry also failed: ${retry.error ?? "no vector"}
-`);
-  }
-  return null;
-}
-function disconnectClient() {
-  if (_socket) {
-    _socket.destroy();
-    _socket = null;
-  }
-  _connected = false;
-  _buffer = "";
-  for (const [id, entry] of _pending) {
-    clearTimeout(entry.timer);
-    _pending.delete(id);
-    entry.resolve({ error: "Client disconnected" });
-  }
-}
-var SOCKET_PATH, PID_PATH, SPAWN_LOCK_PATH, SPAWN_LOCK_STALE_MS, CONNECT_TIMEOUT_MS, REQUEST_TIMEOUT_MS, _socket, _connected, _buffer, _requestCount, HEALTH_CHECK_INTERVAL, _pending;
-var init_exe_daemon_client = __esm({
-  "src/lib/exe-daemon-client.ts"() {
-    "use strict";
-    init_config();
-    SOCKET_PATH = process.env.EXE_DAEMON_SOCK ?? process.env.EXE_EMBED_SOCK ?? path4.join(EXE_AI_DIR, "exed.sock");
-    PID_PATH = process.env.EXE_DAEMON_PID ?? process.env.EXE_EMBED_PID ?? path4.join(EXE_AI_DIR, "exed.pid");
-    SPAWN_LOCK_PATH = path4.join(EXE_AI_DIR, "exed-spawn.lock");
-    SPAWN_LOCK_STALE_MS = 3e4;
-    CONNECT_TIMEOUT_MS = 15e3;
-    REQUEST_TIMEOUT_MS = 3e4;
-    _socket = null;
-    _connected = false;
-    _buffer = "";
-    _requestCount = 0;
-    HEALTH_CHECK_INTERVAL = 100;
-    _pending = /* @__PURE__ */ new Map();
+  try {
+    await client.execute({
+      sql: `ALTER TABLE memories ADD COLUMN author_device_id TEXT`,
+      args: []
+    });
+  } catch {
   }
-});
-
-// src/lib/embedder.ts
-var embedder_exports = {};
-__export(embedder_exports, {
-  disposeEmbedder: () => disposeEmbedder,
-  embed: () => embed,
-  embedDirect: () => embedDirect,
-  getEmbedder: () => getEmbedder
-});
-async function getEmbedder() {
-  const ok = await connectEmbedDaemon();
-  if (!ok) {
-    throw new Error(
-      "Could not connect to embedding daemon. Ensure the model is installed (run /exe-setup)."
-    );
+  try {
+    await client.execute({
+      sql: `ALTER TABLE memories ADD COLUMN scope TEXT NOT NULL DEFAULT 'business'`,
+      args: []
+    });
+  } catch {
   }
-}
-async function embed(text) {
-  const priority = process.env.EXE_EMBED_PRIORITY === "low" ? "low" : "high";
-  const vector = await embedViaClient(text, priority);
-  if (!vector) {
-    throw new Error(
-      "Embedding failed: daemon unavailable. Run /exe-setup to verify model installation."
+  await client.executeMultiple(`
+    CREATE TABLE IF NOT EXISTS consolidations (
+      id                    TEXT PRIMARY KEY,
+      consolidated_memory_id TEXT NOT NULL,
+      source_memory_id      TEXT NOT NULL,
+      created_at            TEXT NOT NULL
     );
-  }
-  if (vector.length !== EMBEDDING_DIM) {
-    throw new Error(
-      `Embedding dimension mismatch: expected ${EMBEDDING_DIM}, got ${vector.length}. Ensure the correct Jina v5-small Q4_K_M GGUF model is installed.`
+
+    CREATE INDEX IF NOT EXISTS idx_consolidations_source
+      ON consolidations(source_memory_id);
+
+    CREATE INDEX IF NOT EXISTS idx_consolidations_consolidated
+      ON consolidations(consolidated_memory_id);
+  `);
+  await client.executeMultiple(`
+    CREATE TABLE IF NOT EXISTS reminders (
+      id            TEXT PRIMARY KEY,
+      text          TEXT NOT NULL,
+      created_at    TEXT NOT NULL,
+      due_date      TEXT,
+      completed_at  TEXT
     );
-  }
-  return vector;
-}
-async function disposeEmbedder() {
-  disconnectClient();
-}
-async function embedDirect(text) {
-  const llamaCpp = await import("node-llama-cpp");
-  const { MODELS_DIR: MODELS_DIR2 } = await Promise.resolve().then(() => (init_config(), config_exports));
-  const { existsSync: existsSync7 } = await import("fs");
-  const path10 = await import("path");
-  const modelPath = path10.join(MODELS_DIR2, "jina-embeddings-v5-small-q4_k_m.gguf");
-  if (!existsSync7(modelPath)) {
-    throw new Error(`Embedding model not found at ${modelPath}. Run '/exe-setup' to download it.`);
-  }
-  const llama = await llamaCpp.getLlama();
-  const model = await llama.loadModel({ modelPath });
-  const context = await model.createEmbeddingContext();
+  `);
+  await client.executeMultiple(`
+    CREATE TABLE IF NOT EXISTS notifications (
+      id          TEXT PRIMARY KEY,
+      agent_id    TEXT NOT NULL,
+      agent_role  TEXT NOT NULL,
+      event       TEXT NOT NULL,
+      project     TEXT NOT NULL,
+      summary     TEXT NOT NULL,
+      task_file   TEXT,
+      read        INTEGER NOT NULL DEFAULT 0,
+      created_at  TEXT NOT NULL
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_notifications_read
+      ON notifications(read);
+
+    CREATE INDEX IF NOT EXISTS idx_notifications_agent
+      ON notifications(agent_id);
+
+    CREATE INDEX IF NOT EXISTS idx_notifications_task_file
+      ON notifications(task_file);
+  `);
+  await client.executeMultiple(`
+    CREATE TABLE IF NOT EXISTS schedules (
+      id            TEXT PRIMARY KEY,
+      cron          TEXT NOT NULL,
+      description   TEXT NOT NULL,
+      job_type      TEXT NOT NULL DEFAULT 'report',
+      prompt        TEXT,
+      assigned_to   TEXT,
+      project_name  TEXT,
+      active        INTEGER NOT NULL DEFAULT 1,
+      use_crontab   INTEGER NOT NULL DEFAULT 0,
+      created_at    TEXT NOT NULL
+    );
+  `);
+  await client.executeMultiple(`
+    CREATE TABLE IF NOT EXISTS device_registry (
+      device_id     TEXT PRIMARY KEY,
+      friendly_name TEXT NOT NULL,
+      hostname      TEXT NOT NULL,
+      projects      TEXT NOT NULL DEFAULT '[]',
+      agents        TEXT NOT NULL DEFAULT '[]',
+      connected     INTEGER DEFAULT 0,
+      last_seen     TEXT NOT NULL
+    );
+  `);
+  await client.executeMultiple(`
+    CREATE TABLE IF NOT EXISTS messages (
+      id              TEXT PRIMARY KEY,
+      from_agent      TEXT NOT NULL,
+      from_device     TEXT NOT NULL DEFAULT 'local',
+      target_agent    TEXT NOT NULL,
+      target_project  TEXT,
+      target_device   TEXT NOT NULL DEFAULT 'local',
+      content         TEXT NOT NULL,
+      priority        TEXT DEFAULT 'normal',
+      status          TEXT DEFAULT 'pending',
+      server_seq      INTEGER,
+      retry_count     INTEGER DEFAULT 0,
+      created_at      TEXT NOT NULL,
+      delivered_at    TEXT,
+      processed_at    TEXT,
+      failed_at       TEXT,
+      failure_reason  TEXT
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_messages_target
+      ON messages(target_agent, status);
+
+    CREATE INDEX IF NOT EXISTS idx_messages_conversation_order
+      ON messages(target_agent, from_agent, server_seq);
+  `);
   try {
-    const embedding = await context.getEmbeddingFor(text);
-    const vector = Array.from(embedding.vector);
-    if (vector.length !== EMBEDDING_DIM) {
-      throw new Error(
-        `Embedding dimension mismatch: expected ${EMBEDDING_DIM}, got ${vector.length}.`
-      );
-    }
-    return vector;
-  } finally {
-    await context.dispose();
-    await model.dispose();
+    await client.execute({
+      sql: `UPDATE memories SET project_name = 'exe-create' WHERE project_name = 'web'`,
+      args: []
+    });
+    await client.execute({
+      sql: `UPDATE memories SET project_name = 'exe-os' WHERE project_name = 'worker'`,
+      args: []
+    });
+    await client.execute({
+      sql: `UPDATE tasks SET project_name = 'exe-create' WHERE project_name = 'web'`,
+      args: []
+    });
+    await client.execute({
+      sql: `UPDATE tasks SET project_name = 'exe-os' WHERE project_name = 'worker'`,
+      args: []
+    });
+  } catch {
   }
-}
-var init_embedder = __esm({
-  "src/lib/embedder.ts"() {
-    "use strict";
-    init_memory();
-    init_exe_daemon_client();
+  await client.executeMultiple(`
+    CREATE TABLE IF NOT EXISTS trajectories (
+      id              TEXT PRIMARY KEY,
+      task_id         TEXT NOT NULL,
+      agent_id        TEXT NOT NULL,
+      project_name    TEXT NOT NULL,
+      task_title      TEXT NOT NULL,
+      signature       TEXT NOT NULL,
+      signature_hash  TEXT NOT NULL,
+      tool_count      INTEGER NOT NULL,
+      skill_id        TEXT,
+      created_at      TEXT NOT NULL
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_trajectories_hash
+      ON trajectories(signature_hash);
+
+    CREATE INDEX IF NOT EXISTS idx_trajectories_agent
+      ON trajectories(agent_id);
+  `);
+  try {
+    await client.execute("ALTER TABLE trajectories ADD COLUMN skill_id TEXT");
+  } catch {
   }
-});
+  await client.executeMultiple(`
+    CREATE TABLE IF NOT EXISTS consolidations (
+      id                    TEXT PRIMARY KEY,
+      consolidated_memory_id TEXT NOT NULL,
+      source_memory_id      TEXT NOT NULL,
+      created_at            TEXT NOT NULL
+    );
 
-// src/lib/project-name.ts
-var project_name_exports = {};
-__export(project_name_exports, {
-  _resetCache: () => _resetCache,
-  getProjectName: () => getProjectName
-});
-import { execSync } from "child_process";
-import path5 from "path";
-function getProjectName(cwd) {
-  const dir = cwd ?? process.cwd();
-  if (_cached && _cachedCwd === dir) return _cached;
+    CREATE INDEX IF NOT EXISTS idx_consolidations_source
+      ON consolidations(source_memory_id);
+  `);
+  await client.executeMultiple(`
+    CREATE TABLE IF NOT EXISTS audit_trail (
+      id                  INTEGER PRIMARY KEY AUTOINCREMENT,
+      timestamp           TEXT NOT NULL,
+      session_id          TEXT NOT NULL,
+      agent_id            TEXT NOT NULL,
+      tool                TEXT NOT NULL,
+      input               TEXT,
+      decision            TEXT NOT NULL,
+      reason              TEXT,
+      is_customer_facing  INTEGER NOT NULL DEFAULT 0
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_audit_trail_agent
+      ON audit_trail(agent_id, timestamp);
+
+    CREATE INDEX IF NOT EXISTS idx_audit_trail_session
+      ON audit_trail(session_id);
+  `);
   try {
-    const repoRoot = execSync("git rev-parse --show-toplevel", {
-      cwd: dir,
-      encoding: "utf8",
-      timeout: 2e3,
-      stdio: ["pipe", "pipe", "pipe"]
-    }).trim();
-    _cached = path5.basename(repoRoot);
-    _cachedCwd = dir;
-    return _cached;
+    await client.execute({
+      sql: `ALTER TABLE memories ADD COLUMN consolidated INTEGER NOT NULL DEFAULT 0`,
+      args: []
+    });
   } catch {
-    _cached = path5.basename(dir);
-    _cachedCwd = dir;
-    return _cached;
   }
-}
-function _resetCache() {
-  _cached = null;
-  _cachedCwd = null;
-}
-var _cached, _cachedCwd;
-var init_project_name = __esm({
-  "src/lib/project-name.ts"() {
-    "use strict";
-    _cached = null;
-    _cachedCwd = null;
+  try {
+    await client.execute({
+      sql: `ALTER TABLE memories ADD COLUMN importance INTEGER DEFAULT 5`,
+      args: []
+    });
+  } catch {
   }
-});
-
-// src/lib/file-grep.ts
-var file_grep_exports = {};
-__export(file_grep_exports, {
-  grepProjectFiles: () => grepProjectFiles
-});
-import { execSync as execSync2 } from "child_process";
-import { readFileSync as readFileSync3, readdirSync, statSync as statSync2, existsSync as existsSync5 } from "fs";
-import path6 from "path";
-import crypto2 from "crypto";
-async function grepProjectFiles(query, projectRoot, options) {
-  const maxResults = options?.maxResults ?? 10;
-  const terms = query.toLowerCase().split(/\s+/).filter((t) => t.length >= 3).map((t) => t.replace(/[^a-z0-9_-]/g, "")).filter((t) => t.length >= 3);
-  if (terms.length === 0) return [];
-  const pattern = terms.join("|");
-  let hits;
   try {
-    hits = grepWithRipgrep(pattern, projectRoot, options?.patterns);
+    await client.execute({
+      sql: `ALTER TABLE memories ADD COLUMN status TEXT DEFAULT 'active'`,
+      args: []
+    });
   } catch {
-    hits = grepWithNodeFs(pattern, projectRoot, options?.patterns);
   }
-  hits.sort((a, b) => b.density - a.density);
-  const topHits = hits.slice(0, maxResults);
-  return topHits.map((hit) => {
-    const chunkCtx = getChunkContext(hit.filePath, hit.lineNumber);
-    const prefix = chunkCtx ? `[file: ${hit.filePath}:${hit.lineNumber} in ${chunkCtx}]` : `[file: ${hit.filePath}:${hit.lineNumber}]`;
-    return {
-      id: crypto2.createHash("sha256").update(`${hit.filePath}:${hit.lineNumber}`).digest("hex").slice(0, 36),
-      agent_id: "project",
-      agent_role: "file",
-      session_id: "file-grep",
-      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-      tool_name: "file_grep",
-      project_name: path6.basename(projectRoot),
-      has_error: false,
-      raw_text: `${prefix} ${buildSnippet(hit, projectRoot)}`,
-      vector: null,
-      task_id: null
-    };
-  });
-}
-function getChunkContext(filePath, lineNumber) {
   try {
-    const ext = filePath.split(".").pop()?.toLowerCase();
-    if (ext !== "ts" && ext !== "tsx" && ext !== "js" && ext !== "jsx") return "";
-    const source = readFileSync3(filePath, "utf8");
-    const lines = source.split("\n");
-    for (let i = Math.min(lineNumber - 1, lines.length - 1); i >= 0; i--) {
-      const line = lines[i];
-      const fnMatch = line.match(/(?:export\s+)?(?:async\s+)?function\s+(\w+)/);
-      if (fnMatch) return `function ${fnMatch[1]}`;
-      const classMatch = line.match(/(?:export\s+)?class\s+(\w+)/);
-      if (classMatch) return `class ${classMatch[1]}`;
-      const arrowMatch = line.match(/(?:export\s+)?(?:const|let)\s+(\w+)\s*=\s*(?:async\s+)?\(/);
-      if (arrowMatch) return `function ${arrowMatch[1]}`;
-    }
+    await client.execute({
+      sql: `ALTER TABLE memories ADD COLUMN confidence REAL DEFAULT 0.7`,
+      args: []
+    });
   } catch {
   }
-  return "";
-}
-function grepWithRipgrep(pattern, projectRoot, patterns) {
-  const globs = (patterns ?? DEFAULT_PATTERNS).map((p) => `--glob '${p}'`).join(" ");
-  const excludes = EXCLUDE_DIRS.map((d) => `--glob '!${d}'`).join(" ");
-  const cmd = `rg -i -c --hidden '${pattern.replace(/'/g, "\\'")}' . ${globs} ${excludes} --max-filesize ${MAX_FILE_SIZE} 2>/dev/null || true`;
-  const output = execSync2(cmd, {
-    cwd: projectRoot,
-    encoding: "utf8",
-    timeout: 3e3,
-    maxBuffer: 1024 * 1024
-  });
-  if (!output.trim()) return [];
-  const hits = [];
-  for (const line of output.trim().split("\n")) {
-    const colonIdx = line.lastIndexOf(":");
-    if (colonIdx === -1) continue;
-    const filePath = line.slice(0, colonIdx);
-    const matchCount = parseInt(line.slice(colonIdx + 1));
-    if (isNaN(matchCount) || matchCount === 0) continue;
-    try {
-      const firstMatch = execSync2(
-        `rg -i -n --hidden '${pattern.replace(/'/g, "\\'")}' '${filePath}' --max-count 1 2>/dev/null | head -1`,
-        { cwd: projectRoot, encoding: "utf8", timeout: 1e3 }
-      ).trim();
-      const lineNum = parseInt(firstMatch.split(":")[0] ?? "1");
-      const totalLines = execSync2(`wc -l < '${filePath}'`, {
-        cwd: projectRoot,
-        encoding: "utf8",
-        timeout: 1e3
-      }).trim();
-      hits.push({
-        filePath,
-        lineNumber: isNaN(lineNum) ? 1 : lineNum,
-        matchLine: firstMatch.slice(firstMatch.indexOf(":") + 1).slice(0, 200),
-        matchCount,
-        totalLines: parseInt(totalLines) || 1,
-        density: matchCount / (parseInt(totalLines) || 1)
-      });
-    } catch {
-    }
+  try {
+    await client.execute({
+      sql: `ALTER TABLE memories ADD COLUMN last_accessed TEXT`,
+      args: []
+    });
+  } catch {
   }
-  return hits;
-}
-function grepWithNodeFs(pattern, projectRoot, patterns) {
-  const regex = new RegExp(pattern, "gi");
-  const files = collectFiles(projectRoot, patterns ?? DEFAULT_PATTERNS);
-  const hits = [];
-  for (const filePath of files.slice(0, MAX_FILES)) {
-    const absPath = path6.join(projectRoot, filePath);
+  try {
+    await client.execute({
+      sql: `UPDATE memories SET last_accessed = timestamp WHERE last_accessed IS NULL`,
+      args: []
+    });
+  } catch {
+  }
+  try {
+    await client.execute({
+      sql: `ALTER TABLE memories ADD COLUMN wiki_synced INTEGER DEFAULT 0`,
+      args: []
+    });
+  } catch {
+  }
+  try {
+    await client.execute({
+      sql: `ALTER TABLE memories ADD COLUMN graph_extracted INTEGER DEFAULT 0`,
+      args: []
+    });
+  } catch {
+  }
+  for (const col of [
+    "ALTER TABLE memories ADD COLUMN content_hash TEXT",
+    "ALTER TABLE memories ADD COLUMN graph_extracted_hash TEXT"
+  ]) {
     try {
-      const stat = statSync2(absPath);
-      if (stat.size > MAX_FILE_SIZE) continue;
-      const content = readFileSync3(absPath, "utf8");
-      const lines = content.split("\n");
-      const matches = content.match(regex);
-      if (!matches || matches.length === 0) continue;
-      const firstMatchIdx = lines.findIndex((l) => regex.test(l));
-      regex.lastIndex = 0;
-      hits.push({
-        filePath,
-        lineNumber: firstMatchIdx >= 0 ? firstMatchIdx + 1 : 1,
-        matchLine: firstMatchIdx >= 0 ? lines[firstMatchIdx].slice(0, 200) : "",
-        matchCount: matches.length,
-        totalLines: lines.length,
-        density: matches.length / lines.length
-      });
+      await client.execute(col);
     } catch {
     }
   }
-  return hits;
-}
-function collectFiles(root, patterns) {
-  const files = [];
-  function walk(dir, relative) {
-    if (files.length >= MAX_FILES) return;
-    const basename = path6.basename(dir);
-    if (EXCLUDE_DIRS.includes(basename)) return;
+  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 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)
+    );
+  `);
+  await client.executeMultiple(`
+    CREATE TABLE IF NOT EXISTS entity_aliases (
+      alias TEXT NOT NULL PRIMARY KEY,
+      canonical_entity_id TEXT NOT NULL
+    );
+    CREATE INDEX IF NOT EXISTS idx_entity_aliases_canonical ON entity_aliases(canonical_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 {
-      const entries = readdirSync(dir, { withFileTypes: true });
-      for (const entry of entries) {
-        if (files.length >= MAX_FILES) return;
-        const rel = path6.join(relative, entry.name);
-        if (entry.isDirectory()) {
-          walk(path6.join(dir, entry.name), rel);
-        } else if (entry.isFile()) {
-          for (const pat of patterns) {
-            if (matchGlob(rel, pat)) {
-              files.push(rel);
-              break;
-            }
-          }
-        }
-      }
+      await client.execute(col);
     } catch {
     }
   }
-  walk(root, "");
-  return files;
-}
-function matchGlob(filePath, pattern) {
-  if (!pattern.includes("*")) return filePath === pattern;
-  const doubleStarMatch = pattern.match(/^(.+?)\/\*\*\/\*(\.\w+)$/);
-  if (doubleStarMatch) {
-    const dir = doubleStarMatch[1];
-    const ext2 = doubleStarMatch[2];
-    return filePath.startsWith(dir + "/") && filePath.endsWith(ext2);
-  }
-  if (pattern.startsWith("**/")) {
-    const ext2 = pattern.slice(3).replace("*", "");
-    return filePath.endsWith(ext2);
-  }
-  const slashIdx = pattern.lastIndexOf("/");
-  if (slashIdx !== -1) {
-    const dir = pattern.slice(0, slashIdx);
-    const ext2 = pattern.slice(slashIdx + 1).replace("*", "");
-    const fileDir = path6.dirname(filePath);
-    return fileDir === dir && filePath.endsWith(ext2);
-  }
-  const ext = pattern.replace("*", "");
-  return filePath.endsWith(ext) && !filePath.includes("/");
-}
-function buildSnippet(hit, projectRoot) {
   try {
-    const absPath = path6.join(projectRoot, hit.filePath);
-    if (!existsSync5(absPath)) return hit.matchLine;
-    const lines = readFileSync3(absPath, "utf8").split("\n");
-    const start = Math.max(0, hit.lineNumber - 3);
-    const end = Math.min(lines.length, hit.lineNumber + 2);
-    return lines.slice(start, end).join("\n").slice(0, 500);
+    await client.execute(
+      `CREATE INDEX IF NOT EXISTS idx_memories_status ON memories(status)`
+    );
   } catch {
-    return hit.matchLine;
-  }
-}
-var DEFAULT_PATTERNS, EXCLUDE_DIRS, MAX_FILE_SIZE, MAX_FILES;
-var init_file_grep = __esm({
-  "src/lib/file-grep.ts"() {
-    "use strict";
-    DEFAULT_PATTERNS = [
-      ".planning/*.md",
-      "exe/output/*.md",
-      "README.md",
-      "src/**/*.ts"
-    ];
-    EXCLUDE_DIRS = ["node_modules", "dist", ".git", "coverage", ".worktrees"];
-    MAX_FILE_SIZE = 100 * 1024;
-    MAX_FILES = 500;
   }
-});
+  await client.executeMultiple(`
+    CREATE TABLE IF NOT EXISTS identity (
+      id          INTEGER PRIMARY KEY AUTOINCREMENT,
+      agent_id    TEXT NOT NULL UNIQUE,
+      content_hash TEXT NOT NULL,
+      updated_at  TEXT NOT NULL,
+      updated_by  TEXT NOT NULL
+    );
 
-// src/lib/reranker.ts
-var reranker_exports = {};
-__export(reranker_exports, {
-  disposeReranker: () => disposeReranker,
-  getRerankerModelPath: () => getRerankerModelPath,
-  isRerankerAvailable: () => isRerankerAvailable,
-  rerank: () => rerank,
-  rerankWithScores: () => rerankWithScores
-});
-import path7 from "path";
-import { existsSync as existsSync6 } from "fs";
-function resetIdleTimer() {
-  if (_idleTimer) clearTimeout(_idleTimer);
-  _idleTimer = setTimeout(() => {
-    void disposeReranker();
-  }, IDLE_TIMEOUT_MS);
-  if (_idleTimer && typeof _idleTimer === "object" && "unref" in _idleTimer) {
-    _idleTimer.unref();
-  }
-}
-function isRerankerAvailable() {
-  return existsSync6(path7.join(MODELS_DIR, RERANKER_MODEL_FILE));
-}
-function getRerankerModelPath() {
-  return path7.join(MODELS_DIR, RERANKER_MODEL_FILE);
-}
-async function ensureLoaded() {
-  if (_rerankerContext) {
-    resetIdleTimer();
-    return;
-  }
-  const modelPath = path7.join(MODELS_DIR, RERANKER_MODEL_FILE);
-  if (!existsSync6(modelPath)) {
-    throw new Error(
-      `Reranker model not found at ${modelPath}. Run /exe-setup to download it.`
+    CREATE INDEX IF NOT EXISTS idx_identity_agent ON identity(agent_id);
+  `);
+  await client.executeMultiple(`
+    CREATE TABLE IF NOT EXISTS chat_history (
+      id          INTEGER PRIMARY KEY AUTOINCREMENT,
+      session_id  TEXT NOT NULL,
+      role        TEXT NOT NULL,
+      content     TEXT NOT NULL,
+      tool_name   TEXT,
+      tool_id     TEXT,
+      is_error    INTEGER NOT NULL DEFAULT 0,
+      timestamp   INTEGER NOT NULL
     );
-  }
-  process.stderr.write("[reranker] Loading Jina Reranker v3...\n");
-  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");
-  resetIdleTimer();
-}
-async function disposeReranker() {
-  if (_idleTimer) {
-    clearTimeout(_idleTimer);
-    _idleTimer = null;
-  }
-  if (_rerankerContext) {
-    try {
-      await _rerankerContext.dispose();
-    } catch {
-    }
-    _rerankerContext = null;
-  }
-  if (_rerankerModel) {
+
+    CREATE INDEX IF NOT EXISTS idx_chat_history_session
+      ON chat_history(session_id, id);
+  `);
+  await client.executeMultiple(`
+    CREATE TABLE IF NOT EXISTS workspaces (
+      id              TEXT PRIMARY KEY,
+      slug            TEXT NOT NULL UNIQUE,
+      name            TEXT NOT NULL,
+      owner_agent_id  TEXT,
+      created_at      TEXT NOT NULL,
+      metadata        TEXT
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_workspaces_slug
+      ON workspaces(slug);
+  `);
+  await client.executeMultiple(`
+    CREATE TABLE IF NOT EXISTS documents (
+      id            TEXT PRIMARY KEY,
+      workspace_id  TEXT NOT NULL,
+      filename      TEXT NOT NULL,
+      mime          TEXT,
+      source_type   TEXT,
+      user_id       TEXT,
+      uploaded_at   TEXT NOT NULL,
+      metadata      TEXT,
+      FOREIGN KEY (workspace_id) REFERENCES workspaces(id)
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_documents_workspace
+      ON documents(workspace_id);
+
+    CREATE INDEX IF NOT EXISTS idx_documents_user
+      ON documents(user_id);
+  `);
+  for (const column of [
+    "workspace_id TEXT",
+    "document_id TEXT",
+    "user_id TEXT",
+    "char_offset INTEGER",
+    "page_number INTEGER"
+  ]) {
     try {
-      await _rerankerModel.dispose();
+      await client.execute({
+        sql: `ALTER TABLE memories ADD COLUMN ${column}`,
+        args: []
+      });
     } catch {
     }
-    _rerankerModel = null;
   }
-  process.stderr.write("[reranker] Unloaded (idle timeout).\n");
-}
-async function rerankWithScores(query, texts, topK) {
-  if (texts.length === 0) return [];
-  await ensureLoaded();
-  const ctx = _rerankerContext;
-  const scored = [];
-  for (let i = 0; i < texts.length; i++) {
-    const text = texts[i] ?? "";
+  for (const col of [
+    "ALTER TABLE memories ADD COLUMN source_path TEXT",
+    "ALTER TABLE memories ADD COLUMN source_type TEXT DEFAULT 'text'"
+  ]) {
     try {
-      const input2 = `query: ${query} document: ${text.slice(0, 512)}`;
-      const embedding = await ctx.getEmbeddingFor(input2);
-      const score = embedding.vector[0] ?? 0;
-      scored.push({ text, score, index: i });
+      await client.execute(col);
     } catch {
-      scored.push({ text, score: -1, index: i });
     }
   }
-  scored.sort((a, b) => b.score - a.score);
-  return typeof topK === "number" ? scored.slice(0, topK) : scored;
-}
-async function rerank(query, candidates, topK = 5) {
-  if (candidates.length === 0) return [];
-  if (candidates.length <= topK) return candidates;
-  const scored = await rerankWithScores(
-    query,
-    candidates.map((c) => c.raw_text),
-    topK
-  );
-  return scored.map((s) => candidates[s.index]);
-}
-var RERANKER_MODEL_FILE, IDLE_TIMEOUT_MS, _rerankerContext, _rerankerModel, _idleTimer;
-var init_reranker = __esm({
-  "src/lib/reranker.ts"() {
-    "use strict";
-    init_config();
-    RERANKER_MODEL_FILE = "jina-reranker-v3-q4_k_m.gguf";
-    IDLE_TIMEOUT_MS = 6e4;
-    _rerankerContext = null;
-    _rerankerModel = null;
-    _idleTimer = null;
-  }
-});
-
-// src/adapters/claude/hooks/session-start.ts
-init_config();
-init_config();
-import path9 from "path";
-import { unlinkSync as unlinkSync3 } from "fs";
+  await client.executeMultiple(`
+    CREATE INDEX IF NOT EXISTS idx_memories_workspace
+      ON memories(workspace_id);
 
-// src/lib/store.ts
-init_memory();
+    CREATE INDEX IF NOT EXISTS idx_memories_document
+      ON memories(document_id);
 
-// src/lib/database.ts
-import { createClient } from "@libsql/client";
-var _client = null;
-var initTurso = initDatabase;
-async function initDatabase(config) {
-  if (_client) {
-    _client.close();
-    _client = null;
-  }
-  const opts = {
-    url: `file:${config.dbPath}`
-  };
-  if (config.encryptionKey) {
-    opts.encryptionKey = config.encryptionKey;
-  }
-  _client = createClient(opts);
-}
-function getClient() {
-  if (!_client) {
-    throw new Error("Database client not initialized. Call initDatabase() first.");
-  }
-  return _client;
-}
-async function ensureSchema() {
-  const client = getClient();
-  await client.execute("PRAGMA journal_mode = WAL");
-  await client.execute("PRAGMA busy_timeout = 5000");
-  try {
-    await client.execute("PRAGMA libsql_vector_search_ef = 128");
-  } catch {
-  }
+    CREATE INDEX IF NOT EXISTS idx_memories_user
+      ON memories(user_id);
+  `);
   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 TABLE IF NOT EXISTS session_kills (
+      id                      TEXT PRIMARY KEY,
+      session_name            TEXT NOT NULL,
+      agent_id                TEXT NOT NULL,
+      killed_at               TIMESTAMP NOT NULL,
+      reason                  TEXT NOT NULL,
+      ticks_idle              INTEGER,
+      estimated_tokens_saved  INTEGER
     );
 
-    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_session_kills_killed_at
+      ON session_kills(killed_at);
 
-    CREATE INDEX IF NOT EXISTS idx_memories_session
-      ON memories(session_id);
-
-    CREATE INDEX IF NOT EXISTS idx_memories_project
-      ON memories(project_name);
-
-    CREATE INDEX IF NOT EXISTS idx_memories_tool
-      ON memories(tool_name);
-
-    CREATE INDEX IF NOT EXISTS idx_memories_version
-      ON memories(version);
-
-    CREATE INDEX IF NOT EXISTS idx_memories_agent_project
-      ON memories(agent_id, project_name);
+    CREATE INDEX IF NOT EXISTS idx_session_kills_agent
+      ON session_kills(agent_id);
   `);
   await client.executeMultiple(`
-    CREATE VIRTUAL TABLE IF NOT EXISTS memories_fts USING fts5(
-      raw_text,
-      content='memories',
-      content_rowid='rowid'
+    CREATE TABLE IF NOT EXISTS conversations (
+      id              TEXT PRIMARY KEY,
+      platform        TEXT NOT NULL,
+      external_id     TEXT,
+      sender_id       TEXT NOT NULL,
+      sender_name     TEXT,
+      sender_phone    TEXT,
+      sender_email    TEXT,
+      recipient_id    TEXT,
+      channel_id      TEXT NOT NULL,
+      thread_id       TEXT,
+      reply_to_id     TEXT,
+      content_text    TEXT,
+      content_media   TEXT,
+      content_metadata TEXT,
+      agent_response  TEXT,
+      agent_name      TEXT,
+      timestamp       TEXT NOT NULL,
+      ingested_at     TEXT NOT NULL
     );
 
-    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 INDEX IF NOT EXISTS idx_conversations_platform
+      ON conversations(platform);
 
-    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 INDEX IF NOT EXISTS idx_conversations_sender
+      ON conversations(sender_id);
 
-    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;
-  `);
-  await client.executeMultiple(`
-    CREATE TABLE IF NOT EXISTS sync_meta (
-      key   TEXT PRIMARY KEY,
-      value TEXT NOT NULL
-    );
-  `);
-  await client.executeMultiple(`
-    CREATE TABLE IF NOT EXISTS tasks (
-      id            TEXT PRIMARY KEY,
-      title         TEXT NOT NULL,
-      assigned_to   TEXT NOT NULL,
-      assigned_by   TEXT NOT NULL,
-      project_name  TEXT NOT NULL,
-      priority      TEXT NOT NULL DEFAULT 'p1',
-      status        TEXT NOT NULL DEFAULT 'open',
-      task_file     TEXT,
-      created_at    TEXT NOT NULL,
-      updated_at    TEXT NOT NULL
-    );
+    CREATE INDEX IF NOT EXISTS idx_conversations_timestamp
+      ON conversations(timestamp);
 
-    CREATE INDEX IF NOT EXISTS idx_tasks_assignee_status
-      ON tasks(assigned_to, status);
-  `);
-  await client.executeMultiple(`
-    CREATE TABLE IF NOT EXISTS behaviors (
-      id           TEXT PRIMARY KEY,
-      agent_id     TEXT NOT NULL,
-      project_name TEXT,
-      domain       TEXT,
-      content      TEXT NOT NULL,
-      active       INTEGER NOT NULL DEFAULT 1,
-      created_at   TEXT NOT NULL,
-      updated_at   TEXT NOT NULL
-    );
+    CREATE INDEX IF NOT EXISTS idx_conversations_thread
+      ON conversations(thread_id);
 
-    CREATE INDEX IF NOT EXISTS idx_behaviors_agent
-      ON behaviors(agent_id, active);
+    CREATE INDEX IF NOT EXISTS idx_conversations_channel
+      ON conversations(channel_id);
   `);
-  try {
-    const existing = await client.execute({
-      sql: "SELECT COUNT(*) as cnt FROM behaviors WHERE agent_id = 'exe'",
-      args: []
-    });
-    if (Number(existing.rows[0]?.cnt) === 0) {
-      await client.executeMultiple(`
-        INSERT INTO behaviors (id, agent_id, project_name, domain, content, active, created_at, updated_at)
-        VALUES
-          (hex(randomblob(16)), 'exe', NULL, 'workflow', 'Don''t ask "keep going?" \u2014 just keep executing phases/plans autonomously', 1, '2026-03-25T00:00:00Z', '2026-03-25T00:00:00Z');
-        INSERT INTO behaviors (id, agent_id, project_name, domain, content, active, created_at, updated_at)
-        VALUES
-          (hex(randomblob(16)), 'exe', NULL, 'tool-use', 'Always use create_task MCP tool, never write .md files directly for task creation', 1, '2026-03-25T00:00:00Z', '2026-03-25T00:00:00Z');
-        INSERT INTO behaviors (id, agent_id, project_name, domain, content, active, created_at, updated_at)
-        VALUES
-          (hex(randomblob(16)), 'exe', NULL, 'workflow', 'Auto-start reviewing when idle and reviews are pending \u2014 never ask founder for permission', 1, '2026-03-25T00:00:00Z', '2026-03-25T00:00:00Z');
-      `);
-    }
-  } catch {
-  }
   try {
     await client.execute({
-      sql: `ALTER TABLE behaviors ADD COLUMN priority TEXT DEFAULT 'p1'`,
+      sql: `ALTER TABLE tasks ADD COLUMN budget_tokens INTEGER`,
       args: []
     });
   } catch {
   }
   try {
     await client.execute({
-      sql: `ALTER TABLE tasks ADD COLUMN blocked_by TEXT`,
+      sql: `ALTER TABLE tasks ADD COLUMN budget_fallback_model TEXT`,
       args: []
     });
   } catch {
   }
   try {
     await client.execute({
-      sql: `ALTER TABLE tasks ADD COLUMN parent_task_id TEXT`,
+      sql: `ALTER TABLE tasks ADD COLUMN tokens_used INTEGER DEFAULT 0`,
       args: []
     });
   } catch {
   }
   try {
     await client.execute({
-      sql: `CREATE INDEX IF NOT EXISTS idx_tasks_parent_task_id
-              ON tasks(parent_task_id)
-              WHERE parent_task_id IS NOT NULL`,
+      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: `UPDATE tasks SET status = 'done' WHERE status = 'completed'`,
+      sql: `ALTER TABLE memories ADD COLUMN tier INTEGER DEFAULT 3`,
       args: []
     });
   } catch {
   }
   try {
-    await client.execute({
-      sql: `ALTER TABLE tasks ADD COLUMN reviewer TEXT`,
-      args: []
-    });
+    await client.execute(
+      `CREATE INDEX IF NOT EXISTS idx_memories_tier ON memories(tier)`
+    );
   } catch {
   }
   try {
     await client.execute({
-      sql: `ALTER TABLE tasks ADD COLUMN context TEXT`,
+      sql: `UPDATE memories SET tier = 1 WHERE tool_name = 'commit_to_long_term_memory' AND importance >= 8 AND tier = 3`,
       args: []
     });
-  } catch {
-  }
-  try {
     await client.execute({
-      sql: `ALTER TABLE tasks ADD COLUMN result TEXT`,
+      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 tasks ADD COLUMN assigned_tmux TEXT`,
+      sql: `ALTER TABLE memories ADD COLUMN supersedes_id TEXT`,
       args: []
     });
   } catch {
   }
   try {
-    await client.execute({
-      sql: `ALTER TABLE memories ADD COLUMN task_id TEXT`,
-      args: []
-    });
+    await client.execute(
+      `CREATE INDEX IF NOT EXISTS idx_memories_supersedes ON memories(supersedes_id) WHERE supersedes_id IS NOT NULL`
+    );
   } catch {
   }
-  try {
-    await client.execute({
-      sql: `ALTER TABLE memories ADD COLUMN consolidated INTEGER NOT NULL DEFAULT 0`,
-      args: []
-    });
-  } 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 {
+    }
+  }
+}
+async function disposeDatabase() {
+  if (_client) {
+    _client.close();
+    _client = null;
+  }
+}
+var _client, initTurso, disposeTurso;
+var init_database = __esm({
+  "src/lib/database.ts"() {
+    "use strict";
+    _client = null;
+    initTurso = initDatabase;
+    disposeTurso = disposeDatabase;
   }
+});
+
+// src/lib/keychain.ts
+import { readFile as readFile2, writeFile as writeFile2, unlink, mkdir as mkdir2, chmod } from "fs/promises";
+import { existsSync as existsSync2 } from "fs";
+import path2 from "path";
+import crypto from "crypto";
+function getKeyDir() {
+  return process.env.EXE_OS_DIR ?? process.env.EXE_MEM_DIR ?? path2.join(process.env.HOME ?? "/tmp", ".exe-os");
+}
+function getKeyPath() {
+  return path2.join(getKeyDir(), "master.key");
+}
+async function tryKeytar() {
   try {
-    await client.execute({
-      sql: `ALTER TABLE memories ADD COLUMN author_device_id TEXT`,
-      args: []
-    });
+    return await import("keytar");
   } catch {
+    return null;
+  }
+}
+async function getMasterKey() {
+  const keytar = await tryKeytar();
+  if (keytar) {
+    try {
+      const stored = await keytar.getPassword(SERVICE, ACCOUNT);
+      if (stored) {
+        return Buffer.from(stored, "base64");
+      }
+    } catch {
+    }
+  }
+  const keyPath = getKeyPath();
+  if (!existsSync2(keyPath)) {
+    return null;
   }
   try {
-    await client.execute({
-      sql: `ALTER TABLE memories ADD COLUMN scope TEXT NOT NULL DEFAULT 'business'`,
-      args: []
-    });
+    const content = await readFile2(keyPath, "utf-8");
+    return Buffer.from(content.trim(), "base64");
   } catch {
+    return null;
   }
-  await client.executeMultiple(`
-    CREATE TABLE IF NOT EXISTS consolidations (
-      id                    TEXT PRIMARY KEY,
-      consolidated_memory_id TEXT NOT NULL,
-      source_memory_id      TEXT NOT NULL,
-      created_at            TEXT NOT NULL
-    );
-
-    CREATE INDEX IF NOT EXISTS idx_consolidations_source
-      ON consolidations(source_memory_id);
+}
+var SERVICE, ACCOUNT;
+var init_keychain = __esm({
+  "src/lib/keychain.ts"() {
+    "use strict";
+    SERVICE = "exe-mem";
+    ACCOUNT = "master-key";
+  }
+});
 
-    CREATE INDEX IF NOT EXISTS idx_consolidations_consolidated
-      ON consolidations(consolidated_memory_id);
-  `);
-  await client.executeMultiple(`
-    CREATE TABLE IF NOT EXISTS reminders (
-      id            TEXT PRIMARY KEY,
-      text          TEXT NOT NULL,
-      created_at    TEXT NOT NULL,
-      due_date      TEXT,
-      completed_at  TEXT
-    );
-  `);
-  await client.executeMultiple(`
-    CREATE TABLE IF NOT EXISTS notifications (
-      id          TEXT PRIMARY KEY,
-      agent_id    TEXT NOT NULL,
-      agent_role  TEXT NOT NULL,
-      event       TEXT NOT NULL,
-      project     TEXT NOT NULL,
-      summary     TEXT NOT NULL,
-      task_file   TEXT,
-      read        INTEGER NOT NULL DEFAULT 0,
-      created_at  TEXT NOT NULL
-    );
-
-    CREATE INDEX IF NOT EXISTS idx_notifications_read
-      ON notifications(read);
-
-    CREATE INDEX IF NOT EXISTS idx_notifications_agent
-      ON notifications(agent_id);
-
-    CREATE INDEX IF NOT EXISTS idx_notifications_task_file
-      ON notifications(task_file);
-  `);
+// src/lib/shard-manager.ts
+var shard_manager_exports = {};
+__export(shard_manager_exports, {
+  disposeShards: () => disposeShards,
+  ensureShardSchema: () => ensureShardSchema,
+  getReadyShardClient: () => getReadyShardClient,
+  getShardClient: () => getShardClient,
+  getShardsDir: () => getShardsDir,
+  initShardManager: () => initShardManager,
+  isShardingEnabled: () => isShardingEnabled,
+  listShards: () => listShards,
+  shardExists: () => shardExists
+});
+import path3 from "path";
+import { existsSync as existsSync3, mkdirSync } from "fs";
+import { createClient as createClient2 } from "@libsql/client";
+function initShardManager(encryptionKey) {
+  _encryptionKey = encryptionKey;
+  if (!existsSync3(SHARDS_DIR)) {
+    mkdirSync(SHARDS_DIR, { recursive: true });
+  }
+  _shardingEnabled = true;
+}
+function isShardingEnabled() {
+  return _shardingEnabled;
+}
+function getShardsDir() {
+  return SHARDS_DIR;
+}
+function getShardClient(projectName) {
+  if (!_encryptionKey) {
+    throw new Error("Shard manager not initialized. Call initShardManager() first.");
+  }
+  const safeName = projectName.replace(/[^a-zA-Z0-9_-]/g, "_");
+  if (!safeName) {
+    throw new Error(`Invalid project name for shard: "${projectName}"`);
+  }
+  const cached = _shards.get(safeName);
+  if (cached) return cached;
+  const dbPath = path3.join(SHARDS_DIR, `${safeName}.db`);
+  const client = createClient2({
+    url: `file:${dbPath}`,
+    encryptionKey: _encryptionKey
+  });
+  _shards.set(safeName, client);
+  return client;
+}
+function shardExists(projectName) {
+  const safeName = projectName.replace(/[^a-zA-Z0-9_-]/g, "_");
+  return existsSync3(path3.join(SHARDS_DIR, `${safeName}.db`));
+}
+function listShards() {
+  if (!existsSync3(SHARDS_DIR)) return [];
+  const { readdirSync: readdirSync3 } = __require("fs");
+  return readdirSync3(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 = 5000");
+  try {
+    await client.execute("PRAGMA libsql_vector_search_ef = 128");
+  } catch {
+  }
   await client.executeMultiple(`
-    CREATE TABLE IF NOT EXISTS schedules (
+    CREATE TABLE IF NOT EXISTS memories (
       id            TEXT PRIMARY KEY,
-      cron          TEXT NOT NULL,
-      description   TEXT NOT NULL,
-      job_type      TEXT NOT NULL DEFAULT 'report',
-      prompt        TEXT,
-      assigned_to   TEXT,
-      project_name  TEXT,
-      active        INTEGER NOT NULL DEFAULT 1,
-      use_crontab   INTEGER NOT NULL DEFAULT 0,
-      created_at    TEXT NOT NULL
-    );
-  `);
-  await client.executeMultiple(`
-    CREATE TABLE IF NOT EXISTS device_registry (
-      device_id     TEXT PRIMARY KEY,
-      friendly_name TEXT NOT NULL,
-      hostname      TEXT NOT NULL,
-      projects      TEXT NOT NULL DEFAULT '[]',
-      agents        TEXT NOT NULL DEFAULT '[]',
-      connected     INTEGER DEFAULT 0,
-      last_seen     TEXT NOT NULL
+      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 TABLE IF NOT EXISTS messages (
-      id              TEXT PRIMARY KEY,
-      from_agent      TEXT NOT NULL,
-      from_device     TEXT NOT NULL DEFAULT 'local',
-      target_agent    TEXT NOT NULL,
-      target_project  TEXT,
-      target_device   TEXT NOT NULL DEFAULT 'local',
-      content         TEXT NOT NULL,
-      priority        TEXT DEFAULT 'normal',
-      status          TEXT DEFAULT 'pending',
-      server_seq      INTEGER,
-      retry_count     INTEGER DEFAULT 0,
-      created_at      TEXT NOT NULL,
-      delivered_at    TEXT,
-      processed_at    TEXT,
-      failed_at       TEXT,
-      failure_reason  TEXT
+    CREATE VIRTUAL TABLE IF NOT EXISTS memories_fts USING fts5(
+      raw_text,
+      content='memories',
+      content_rowid='rowid'
     );
 
-    CREATE INDEX IF NOT EXISTS idx_messages_target
-      ON messages(target_agent, status);
+    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 INDEX IF NOT EXISTS idx_messages_conversation_order
-      ON messages(target_agent, from_agent, server_seq);
+    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 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"
+  ]) {
+    try {
+      await client.execute(col);
+    } 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"
+  ]) {
+    try {
+      await client.execute(idx);
+    } catch {
+    }
+  }
   try {
-    await client.execute({
-      sql: `UPDATE memories SET project_name = 'exe-create' WHERE project_name = 'web'`,
-      args: []
-    });
-    await client.execute({
-      sql: `UPDATE memories SET project_name = 'exe-os' WHERE project_name = 'worker'`,
-      args: []
-    });
-    await client.execute({
-      sql: `UPDATE tasks SET project_name = 'exe-create' WHERE project_name = 'web'`,
-      args: []
-    });
-    await client.execute({
-      sql: `UPDATE tasks SET project_name = 'exe-os' WHERE project_name = 'worker'`,
-      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 trajectories (
-      id              TEXT PRIMARY KEY,
-      task_id         TEXT NOT NULL,
-      agent_id        TEXT NOT NULL,
-      project_name    TEXT NOT NULL,
-      task_title      TEXT NOT NULL,
-      signature       TEXT NOT NULL,
-      signature_hash  TEXT NOT NULL,
-      tool_count      INTEGER NOT NULL,
-      skill_id        TEXT,
-      created_at      TEXT NOT NULL
+    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 INDEX IF NOT EXISTS idx_trajectories_hash
-      ON trajectories(signature_hash);
-
-    CREATE INDEX IF NOT EXISTS idx_trajectories_agent
-      ON trajectories(agent_id);
-  `);
-  try {
-    await client.execute("ALTER TABLE trajectories ADD COLUMN skill_id TEXT");
-  } catch {
-  }
-  await client.executeMultiple(`
-    CREATE TABLE IF NOT EXISTS consolidations (
-      id                    TEXT PRIMARY KEY,
-      consolidated_memory_id TEXT NOT NULL,
-      source_memory_id      TEXT NOT NULL,
-      created_at            TEXT NOT NULL
-    );
-
-    CREATE INDEX IF NOT EXISTS idx_consolidations_source
-      ON consolidations(source_memory_id);
-  `);
-  await client.executeMultiple(`
-    CREATE TABLE IF NOT EXISTS audit_trail (
-      id                  INTEGER PRIMARY KEY AUTOINCREMENT,
-      timestamp           TEXT NOT NULL,
-      session_id          TEXT NOT NULL,
-      agent_id            TEXT NOT NULL,
-      tool                TEXT NOT NULL,
-      input               TEXT,
-      decision            TEXT NOT NULL,
-      reason              TEXT,
-      is_customer_facing  INTEGER NOT NULL DEFAULT 0
-    );
-
-    CREATE INDEX IF NOT EXISTS idx_audit_trail_agent
-      ON audit_trail(agent_id, timestamp);
-
-    CREATE INDEX IF NOT EXISTS idx_audit_trail_session
-      ON audit_trail(session_id);
-  `);
-  try {
-    await client.execute({
-      sql: `ALTER TABLE memories ADD COLUMN consolidated INTEGER NOT NULL DEFAULT 0`,
-      args: []
-    });
-  } catch {
-  }
-  try {
-    await client.execute({
-      sql: `ALTER TABLE memories ADD COLUMN importance INTEGER DEFAULT 5`,
-      args: []
-    });
-  } catch {
-  }
-  try {
-    await client.execute({
-      sql: `ALTER TABLE memories ADD COLUMN status TEXT DEFAULT 'active'`,
-      args: []
-    });
-  } catch {
-  }
-  try {
-    await client.execute({
-      sql: `ALTER TABLE memories ADD COLUMN confidence REAL DEFAULT 0.7`,
-      args: []
-    });
-  } catch {
-  }
-  try {
-    await client.execute({
-      sql: `ALTER TABLE memories ADD COLUMN last_accessed TEXT`,
-      args: []
-    });
-  } catch {
-  }
-  try {
-    await client.execute({
-      sql: `UPDATE memories SET last_accessed = timestamp WHERE last_accessed IS NULL`,
-      args: []
-    });
-  } catch {
-  }
-  try {
-    await client.execute({
-      sql: `ALTER TABLE memories ADD COLUMN wiki_synced INTEGER DEFAULT 0`,
-      args: []
-    });
-  } catch {
-  }
-  try {
-    await client.execute({
-      sql: `ALTER TABLE memories ADD COLUMN graph_extracted INTEGER DEFAULT 0`,
-      args: []
-    });
-  } catch {
-  }
-  for (const col of [
-    "ALTER TABLE memories ADD COLUMN content_hash TEXT",
-    "ALTER TABLE memories ADD COLUMN graph_extracted_hash TEXT"
-  ]) {
-    try {
-      await client.execute(col);
-    } 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 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 (
@@ -1848,6 +1335,7 @@ async function ensureSchema() {
     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,
@@ -1863,13 +1351,6 @@ async function ensureSchema() {
       PRIMARY KEY (hyperedge_id, entity_id)
     );
   `);
-  await client.executeMultiple(`
-    CREATE TABLE IF NOT EXISTS entity_aliases (
-      alias TEXT NOT NULL PRIMARY KEY,
-      canonical_entity_id TEXT NOT NULL
-    );
-    CREATE INDEX IF NOT EXISTS idx_entity_aliases_canonical ON entity_aliases(canonical_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'"
@@ -1879,396 +1360,1353 @@ async function ensureSchema() {
     } catch {
     }
   }
+}
+async function getReadyShardClient(projectName) {
+  const client = getShardClient(projectName);
+  await ensureShardSchema(client);
+  return client;
+}
+function disposeShards() {
+  for (const [, client] of _shards) {
+    client.close();
+  }
+  _shards.clear();
+  _shardingEnabled = false;
+  _encryptionKey = null;
+}
+var SHARDS_DIR, _shards, _encryptionKey, _shardingEnabled;
+var init_shard_manager = __esm({
+  "src/lib/shard-manager.ts"() {
+    "use strict";
+    init_config();
+    SHARDS_DIR = path3.join(EXE_AI_DIR, "shards");
+    _shards = /* @__PURE__ */ new Map();
+    _encryptionKey = null;
+    _shardingEnabled = false;
+  }
+});
+
+// src/lib/store.ts
+var store_exports = {};
+__export(store_exports, {
+  attachDocumentMetadata: () => attachDocumentMetadata,
+  buildWikiScopeFilter: () => buildWikiScopeFilter,
+  classifyTier: () => classifyTier,
+  disposeStore: () => disposeStore,
+  flushBatch: () => flushBatch,
+  flushTier3: () => flushTier3,
+  getMemoryCardinality: () => getMemoryCardinality,
+  initStore: () => initStore,
+  reserveVersions: () => reserveVersions,
+  searchMemories: () => searchMemories,
+  updateMemoryStatus: () => updateMemoryStatus,
+  vectorToBlob: () => vectorToBlob,
+  writeMemory: () => writeMemory
+});
+async function initStore(options) {
+  if (_flushTimer !== null) {
+    clearInterval(_flushTimer);
+    _flushTimer = null;
+  }
+  _pendingRecords = [];
+  _flushing = false;
+  _batchSize = options?.batchSize ?? 20;
+  _flushIntervalMs = options?.flushIntervalMs ?? 1e4;
+  let dbPath = options?.dbPath;
+  if (!dbPath) {
+    const config = await loadConfig();
+    dbPath = config.dbPath;
+  }
+  let masterKey = options?.masterKey ?? null;
+  if (!masterKey) {
+    masterKey = await getMasterKey();
+    if (!masterKey) {
+      throw new Error(
+        "No encryption key found. Run /exe-setup to generate one."
+      );
+    }
+  }
+  const hexKey = masterKey.toString("hex");
+  await initTurso({
+    dbPath,
+    encryptionKey: hexKey
+  });
+  await ensureSchema();
   try {
-    await client.execute(
-      `CREATE INDEX IF NOT EXISTS idx_memories_status ON memories(status)`
-    );
+    const { initShardManager: initShardManager2 } = await Promise.resolve().then(() => (init_shard_manager(), shard_manager_exports));
+    initShardManager2(hexKey);
   } catch {
   }
-  await client.executeMultiple(`
-    CREATE TABLE IF NOT EXISTS identity (
-      id          INTEGER PRIMARY KEY AUTOINCREMENT,
-      agent_id    TEXT NOT NULL UNIQUE,
-      content_hash TEXT NOT NULL,
-      updated_at  TEXT NOT NULL,
-      updated_by  TEXT NOT NULL
-    );
-
-    CREATE INDEX IF NOT EXISTS idx_identity_agent ON identity(agent_id);
-  `);
-  await client.executeMultiple(`
-    CREATE TABLE IF NOT EXISTS chat_history (
-      id          INTEGER PRIMARY KEY AUTOINCREMENT,
-      session_id  TEXT NOT NULL,
-      role        TEXT NOT NULL,
-      content     TEXT NOT NULL,
-      tool_name   TEXT,
-      tool_id     TEXT,
-      is_error    INTEGER NOT NULL DEFAULT 0,
-      timestamp   INTEGER NOT NULL
-    );
-
-    CREATE INDEX IF NOT EXISTS idx_chat_history_session
-      ON chat_history(session_id, id);
-  `);
-  await client.executeMultiple(`
-    CREATE TABLE IF NOT EXISTS workspaces (
-      id              TEXT PRIMARY KEY,
-      slug            TEXT NOT NULL UNIQUE,
-      name            TEXT NOT NULL,
-      owner_agent_id  TEXT,
-      created_at      TEXT NOT NULL,
-      metadata        TEXT
-    );
-
-    CREATE INDEX IF NOT EXISTS idx_workspaces_slug
-      ON workspaces(slug);
-  `);
-  await client.executeMultiple(`
-    CREATE TABLE IF NOT EXISTS documents (
-      id            TEXT PRIMARY KEY,
-      workspace_id  TEXT NOT NULL,
-      filename      TEXT NOT NULL,
-      mime          TEXT,
-      source_type   TEXT,
-      user_id       TEXT,
-      uploaded_at   TEXT NOT NULL,
-      metadata      TEXT,
-      FOREIGN KEY (workspace_id) REFERENCES workspaces(id)
+  const client = getClient();
+  const vResult = await client.execute("SELECT MAX(version) as max_v FROM memories");
+  _nextVersion = (Number(vResult.rows[0]?.max_v) || 0) + 1;
+}
+function classifyTier(record) {
+  if (record.tool_name === "commit_to_long_term_memory" && (record.importance ?? 0) >= 8) return 1;
+  if (["store_memory", "manual"].includes(record.tool_name ?? "") && (record.importance ?? 0) >= 5) return 2;
+  return 3;
+}
+async function writeMemory(record) {
+  if (record.vector !== null && record.vector.length !== EMBEDDING_DIM) {
+    throw new Error(
+      `Expected ${EMBEDDING_DIM}-dim vector, got ${record.vector.length}`
     );
-
-    CREATE INDEX IF NOT EXISTS idx_documents_workspace
-      ON documents(workspace_id);
-
-    CREATE INDEX IF NOT EXISTS idx_documents_user
-      ON documents(user_id);
-  `);
-  for (const column of [
-    "workspace_id TEXT",
-    "document_id TEXT",
-    "user_id TEXT",
-    "char_offset INTEGER",
-    "page_number INTEGER"
-  ]) {
-    try {
-      await client.execute({
-        sql: `ALTER TABLE memories ADD COLUMN ${column}`,
-        args: []
-      });
-    } catch {
-    }
   }
-  await client.executeMultiple(`
-    CREATE INDEX IF NOT EXISTS idx_memories_workspace
-      ON memories(workspace_id);
+  const dbRow = {
+    id: record.id,
+    agent_id: record.agent_id,
+    agent_role: record.agent_role,
+    session_id: record.session_id,
+    timestamp: record.timestamp,
+    tool_name: record.tool_name,
+    project_name: record.project_name,
+    has_error: record.has_error ? 1 : 0,
+    raw_text: record.raw_text,
+    vector: record.vector,
+    version: _nextVersion++,
+    task_id: record.task_id ?? null,
+    importance: record.importance ?? 5,
+    status: record.status ?? "active",
+    confidence: record.confidence ?? 0.7,
+    last_accessed: record.last_accessed ?? record.timestamp,
+    workspace_id: record.workspace_id ?? null,
+    document_id: record.document_id ?? null,
+    user_id: record.user_id ?? null,
+    char_offset: record.char_offset ?? null,
+    page_number: record.page_number ?? null,
+    source_path: record.source_path ?? null,
+    source_type: record.source_type ?? null,
+    tier: record.tier ?? classifyTier(record),
+    supersedes_id: record.supersedes_id ?? null
+  };
+  _pendingRecords.push(dbRow);
+  if (_flushTimer === null) {
+    _flushTimer = setInterval(() => {
+      void flushBatch();
+    }, _flushIntervalMs);
+    if (_flushTimer && typeof _flushTimer === "object" && "unref" in _flushTimer) {
+      _flushTimer.unref();
+    }
+  }
+  if (_pendingRecords.length >= _batchSize) {
+    await flushBatch();
+  }
+}
+async function flushBatch() {
+  if (_flushing || _pendingRecords.length === 0) return 0;
+  _flushing = true;
+  try {
+    const batch = _pendingRecords.slice(0);
+    const buildStmt = (row) => {
+      const hasVector = row.vector !== null;
+      const taskId = row.task_id ?? null;
+      const importance = row.importance ?? 5;
+      const status = row.status ?? "active";
+      const confidence = row.confidence ?? 0.7;
+      const lastAccessed = row.last_accessed ?? row.timestamp;
+      const workspaceId = row.workspace_id ?? null;
+      const documentId = row.document_id ?? null;
+      const userId = row.user_id ?? null;
+      const charOffset = row.char_offset ?? null;
+      const pageNumber = row.page_number ?? null;
+      const sourcePath = row.source_path ?? null;
+      const sourceType = row.source_type ?? null;
+      const tier = row.tier ?? 3;
+      const supersedesId = row.supersedes_id ?? null;
+      return {
+        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,
+               workspace_id, document_id, user_id, char_offset, page_number,
+               source_path, source_type, tier, supersedes_id)
+              VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, vector32(?), ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)` : `INSERT OR IGNORE INTO memories
+              (id, agent_id, agent_role, session_id, timestamp,
+               tool_name, project_name,
+               has_error, raw_text, vector, version, task_id, importance, status,
+               confidence, last_accessed,
+               workspace_id, document_id, user_id, char_offset, page_number,
+               source_path, source_type, tier, supersedes_id)
+              VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, NULL, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+        args: hasVector ? [
+          row.id,
+          row.agent_id,
+          row.agent_role,
+          row.session_id,
+          row.timestamp,
+          row.tool_name,
+          row.project_name,
+          row.has_error,
+          row.raw_text,
+          vectorToBlob(row.vector),
+          row.version,
+          taskId,
+          importance,
+          status,
+          confidence,
+          lastAccessed,
+          workspaceId,
+          documentId,
+          userId,
+          charOffset,
+          pageNumber,
+          sourcePath,
+          sourceType,
+          tier,
+          supersedesId
+        ] : [
+          row.id,
+          row.agent_id,
+          row.agent_role,
+          row.session_id,
+          row.timestamp,
+          row.tool_name,
+          row.project_name,
+          row.has_error,
+          row.raw_text,
+          row.version,
+          taskId,
+          importance,
+          status,
+          confidence,
+          lastAccessed,
+          workspaceId,
+          documentId,
+          userId,
+          charOffset,
+          pageNumber,
+          sourcePath,
+          sourceType,
+          tier,
+          supersedesId
+        ]
+      };
+    };
+    const globalClient = getClient();
+    const globalStmts = batch.map(buildStmt);
+    await globalClient.batch(globalStmts, "write");
+    _pendingRecords.splice(0, batch.length);
+    try {
+      const { isShardingEnabled: isShardingEnabled2, getReadyShardClient: getReadyShardClient2 } = await Promise.resolve().then(() => (init_shard_manager(), shard_manager_exports));
+      if (isShardingEnabled2()) {
+        const byProject = /* @__PURE__ */ new Map();
+        for (const row of batch) {
+          const proj = row.project_name || "unknown";
+          if (!byProject.has(proj)) byProject.set(proj, []);
+          byProject.get(proj).push(row);
+        }
+        for (const [project, rows] of byProject) {
+          try {
+            const shardClient = await getReadyShardClient2(project);
+            const shardStmts = rows.map(buildStmt);
+            await shardClient.batch(shardStmts, "write");
+          } catch (err) {
+            process.stderr.write(
+              `[store] Shard write failed for ${project}: ${err instanceof Error ? err.message : String(err)}
+`
+            );
+          }
+        }
+      }
+    } catch {
+    }
+    return batch.length;
+  } finally {
+    _flushing = false;
+  }
+}
+function buildWikiScopeFilter(options, columnPrefix) {
+  const args = [];
+  let clause = "";
+  if (options?.workspaceId !== void 0) {
+    clause += ` AND ${columnPrefix}workspace_id = ?`;
+    args.push(options.workspaceId);
+  }
+  if (options?.userId === void 0) {
+    clause += ` AND ${columnPrefix}user_id IS NULL`;
+  } else if (options.userId === null) {
+    clause += ` AND ${columnPrefix}user_id IS NULL`;
+  } else {
+    clause += ` AND (${columnPrefix}user_id = ? OR ${columnPrefix}user_id IS NULL)`;
+    args.push(options.userId);
+  }
+  return { clause, args };
+}
+async function searchMemories(queryVector, agentId, options) {
+  let client;
+  try {
+    const { isShardingEnabled: isShardingEnabled2, shardExists: shardExists2, getReadyShardClient: getReadyShardClient2 } = await Promise.resolve().then(() => (init_shard_manager(), shard_manager_exports));
+    if (isShardingEnabled2() && options?.projectName && shardExists2(options.projectName)) {
+      client = await getReadyShardClient2(options.projectName);
+    } else {
+      client = getClient();
+    }
+  } catch {
+    client = getClient();
+  }
+  const limit = options?.limit ?? 10;
+  const statusFilter = options?.includeArchived ? "" : `
+               AND COALESCE(status, 'active') = 'active'`;
+  let sql = `SELECT id, agent_id, agent_role, session_id, timestamp,
+                    tool_name, project_name,
+                    has_error, raw_text, vector, importance, status,
+                    confidence, last_accessed,
+                    workspace_id, document_id, user_id,
+                    char_offset, page_number,
+                    source_path, source_type
+             FROM memories
+             WHERE agent_id = ?
+               AND vector IS NOT NULL${statusFilter}
+               AND COALESCE(confidence, 0.7) >= 0.3`;
+  const args = [agentId];
+  const scope = buildWikiScopeFilter(options, "");
+  sql += scope.clause;
+  args.push(...scope.args);
+  if (options?.projectName) {
+    sql += ` AND project_name = ?`;
+    args.push(options.projectName);
+  }
+  if (options?.toolName) {
+    sql += ` AND tool_name = ?`;
+    args.push(options.toolName);
+  }
+  if (options?.hasError !== void 0) {
+    sql += ` AND has_error = ?`;
+    args.push(options.hasError ? 1 : 0);
+  }
+  if (options?.since) {
+    sql += ` AND timestamp >= ?`;
+    args.push(options.since);
+  }
+  sql += ` ORDER BY vector_distance_cos(vector, vector32(?))`;
+  args.push(vectorToBlob(queryVector));
+  sql += ` LIMIT ?`;
+  args.push(limit);
+  const result = await client.execute({ sql, args });
+  return result.rows.map((row) => ({
+    id: row.id,
+    agent_id: row.agent_id,
+    agent_role: row.agent_role,
+    session_id: row.session_id,
+    timestamp: row.timestamp,
+    tool_name: row.tool_name,
+    project_name: row.project_name,
+    has_error: row.has_error === 1,
+    raw_text: row.raw_text,
+    vector: row.vector == null ? [] : Array.isArray(row.vector) ? row.vector : Array.from(row.vector),
+    importance: row.importance ?? 5,
+    status: row.status ?? "active",
+    confidence: row.confidence ?? 0.7,
+    last_accessed: row.last_accessed ?? row.timestamp,
+    workspace_id: row.workspace_id ?? null,
+    document_id: row.document_id ?? null,
+    user_id: row.user_id ?? null,
+    char_offset: row.char_offset ?? null,
+    page_number: row.page_number ?? null,
+    source_path: row.source_path ?? null,
+    source_type: row.source_type ?? null
+  }));
+}
+async function attachDocumentMetadata(records) {
+  const docIds = [
+    ...new Set(
+      records.map((r) => r.document_id).filter((id) => typeof id === "string" && id.length > 0)
+    )
+  ];
+  if (docIds.length === 0) return records;
+  try {
+    const client = getClient();
+    const placeholders = docIds.map(() => "?").join(",");
+    const result = await client.execute({
+      sql: `SELECT id, filename, mime, source_type, uploaded_at
+            FROM documents
+            WHERE id IN (${placeholders})`,
+      args: docIds
+    });
+    const byId = /* @__PURE__ */ new Map();
+    for (const row of result.rows) {
+      const id = row.id;
+      byId.set(id, {
+        document_id: id,
+        filename: row.filename,
+        mime: row.mime ?? null,
+        source_type: row.source_type ?? null,
+        uploaded_at: row.uploaded_at
+      });
+    }
+    for (const record of records) {
+      if (!record.document_id) continue;
+      record.document_metadata = byId.get(record.document_id) ?? null;
+    }
+  } catch {
+  }
+  return records;
+}
+async function flushTier3(agentId, options) {
+  const client = getClient();
+  const maxAge = options?.maxAgeHours ?? 72;
+  const cutoff = new Date(Date.now() - maxAge * 36e5).toISOString();
+  if (options?.dryRun) {
+    const result2 = await client.execute({
+      sql: `SELECT COUNT(*) as cnt FROM memories
+            WHERE agent_id = ? AND tier = 3 AND status = 'active' AND timestamp < ?`,
+      args: [agentId, cutoff]
+    });
+    return { archived: Number(result2.rows[0]?.cnt ?? 0) };
+  }
+  const result = await client.execute({
+    sql: `UPDATE memories SET status = 'archived'
+          WHERE agent_id = ? AND tier = 3 AND status = 'active' AND timestamp < ?`,
+    args: [agentId, cutoff]
+  });
+  return { archived: result.rowsAffected };
+}
+async function disposeStore() {
+  if (_flushTimer !== null) {
+    clearInterval(_flushTimer);
+    _flushTimer = null;
+  }
+  if (_pendingRecords.length > 0) {
+    await flushBatch();
+  }
+  await disposeTurso();
+  _pendingRecords = [];
+  _nextVersion = 1;
+}
+function vectorToBlob(vector) {
+  const f32 = vector instanceof Float32Array ? vector : new Float32Array(vector);
+  return JSON.stringify(Array.from(f32));
+}
+async function updateMemoryStatus(id, status) {
+  const client = getClient();
+  await client.execute({
+    sql: `UPDATE memories SET status = ? WHERE id = ?`,
+    args: [status, id]
+  });
+}
+function reserveVersions(count) {
+  const reserved = [];
+  for (let i = 0; i < count; i++) {
+    reserved.push(_nextVersion++);
+  }
+  return reserved;
+}
+async function getMemoryCardinality(agentId) {
+  try {
+    const client = getClient();
+    const result = await client.execute({
+      sql: `SELECT COUNT(*) as cnt FROM memories WHERE agent_id = ? AND COALESCE(status, 'active') = 'active'`,
+      args: [agentId]
+    });
+    return Number(result.rows[0]?.cnt) || 0;
+  } catch {
+    return 0;
+  }
+}
+var _pendingRecords, _batchSize, _flushIntervalMs, _flushTimer, _flushing, _nextVersion;
+var init_store = __esm({
+  "src/lib/store.ts"() {
+    "use strict";
+    init_memory();
+    init_database();
+    init_keychain();
+    init_config();
+    _pendingRecords = [];
+    _batchSize = 20;
+    _flushIntervalMs = 1e4;
+    _flushTimer = null;
+    _flushing = false;
+    _nextVersion = 1;
+  }
+});
 
-    CREATE INDEX IF NOT EXISTS idx_memories_document
-      ON memories(document_id);
+// src/lib/self-query-router.ts
+var self_query_router_exports = {};
+__export(self_query_router_exports, {
+  routeQuery: () => routeQuery
+});
+async function routeQuery(query, model = "claude-haiku-4-5-20251001") {
+  if (query.length < 10) {
+    return {
+      semanticQuery: query,
+      projectFilter: null,
+      roleFilter: null,
+      timeFilter: null,
+      isBroadQuery: false
+    };
+  }
+  try {
+    const Anthropic = (await import("@anthropic-ai/sdk")).default;
+    const client = new Anthropic();
+    const now = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
+    const response = await client.messages.create({
+      model,
+      max_tokens: 256,
+      system: `You are a search query router. Extract metadata filters from the user's memory search query. Today is ${now}. Convert relative time references (yesterday, last week) to ISO timestamps.`,
+      messages: [{ role: "user", content: query }],
+      tools: [EXTRACT_TOOL],
+      tool_choice: { type: "tool", name: "extract_search_filters" }
+    });
+    const toolBlock = response.content.find((b) => b.type === "tool_use");
+    if (toolBlock && toolBlock.type === "tool_use") {
+      const input2 = toolBlock.input;
+      return {
+        semanticQuery: input2.semantic_query || query,
+        projectFilter: input2.project_filter || null,
+        roleFilter: input2.role_filter || null,
+        timeFilter: input2.time_filter || null,
+        isBroadQuery: Boolean(input2.is_broad_query)
+      };
+    }
+  } catch (err) {
+    process.stderr.write(
+      `[self-query-router] LLM extraction failed, using passthrough: ${err instanceof Error ? err.message : String(err)}
+`
+    );
+  }
+  return {
+    semanticQuery: query,
+    projectFilter: null,
+    roleFilter: null,
+    timeFilter: null,
+    isBroadQuery: false
+  };
+}
+var EXTRACT_TOOL;
+var init_self_query_router = __esm({
+  "src/lib/self-query-router.ts"() {
+    "use strict";
+    EXTRACT_TOOL = {
+      name: "extract_search_filters",
+      description: "Extract metadata filters from a memory search query to improve retrieval precision.",
+      input_schema: {
+        type: "object",
+        properties: {
+          semantic_query: {
+            type: "string",
+            description: "The core semantic meaning of the query, stripped of metadata references. This is used for embedding search."
+          },
+          project_filter: {
+            type: ["string", "null"],
+            description: "Project name if the query references a specific project (e.g., 'exe-os', 'exe-create'). Null if no project specified."
+          },
+          role_filter: {
+            type: ["string", "null"],
+            description: "Agent role if the query targets a specific role (e.g., 'CTO', 'CMO'). Null if no role specified."
+          },
+          time_filter: {
+            type: ["string", "null"],
+            description: "ISO 8601 timestamp lower bound if the query references a time period (e.g., 'last week', 'yesterday'). Null if no time reference."
+          },
+          is_broad_query: {
+            type: "boolean",
+            description: "True if the query is exploratory/broad (e.g., 'what has yoshi been working on', 'summarize recent activity'). False if targeted (e.g., 'how did we fix the auth bug')."
+          }
+        },
+        required: ["semantic_query", "project_filter", "role_filter", "time_filter", "is_broad_query"]
+      }
+    };
+  }
+});
+
+// src/lib/exe-daemon-client.ts
+import net from "net";
+import { spawn } from "child_process";
+import { randomUUID } from "crypto";
+import { existsSync as existsSync4, unlinkSync, readFileSync as readFileSync2, openSync, closeSync, statSync } from "fs";
+import path4 from "path";
+import { fileURLToPath } from "url";
+function handleData(chunk) {
+  _buffer += chunk.toString();
+  let newlineIdx;
+  while ((newlineIdx = _buffer.indexOf("\n")) !== -1) {
+    const line = _buffer.slice(0, newlineIdx).trim();
+    _buffer = _buffer.slice(newlineIdx + 1);
+    if (!line) continue;
+    try {
+      const response = JSON.parse(line);
+      const entry = _pending.get(response.id);
+      if (entry) {
+        clearTimeout(entry.timer);
+        _pending.delete(response.id);
+        entry.resolve(response);
+      }
+    } catch {
+    }
+  }
+}
+function cleanupStaleFiles() {
+  if (existsSync4(PID_PATH)) {
+    try {
+      const pid = parseInt(readFileSync2(PID_PATH, "utf8").trim(), 10);
+      if (pid > 0) {
+        try {
+          process.kill(pid, 0);
+          return;
+        } catch {
+        }
+      }
+    } catch {
+    }
+    try {
+      unlinkSync(PID_PATH);
+    } catch {
+    }
+    try {
+      unlinkSync(SOCKET_PATH);
+    } catch {
+    }
+  }
+}
+function findPackageRoot() {
+  let dir = path4.dirname(fileURLToPath(import.meta.url));
+  const { root } = path4.parse(dir);
+  while (dir !== root) {
+    if (existsSync4(path4.join(dir, "package.json"))) return dir;
+    dir = path4.dirname(dir);
+  }
+  return null;
+}
+function spawnDaemon() {
+  const pkgRoot = findPackageRoot();
+  if (!pkgRoot) {
+    process.stderr.write("[exed-client] WARN: cannot find package root\n");
+    return;
+  }
+  const daemonPath = path4.join(pkgRoot, "dist", "lib", "exe-daemon.js");
+  if (!existsSync4(daemonPath)) {
+    process.stderr.write(`[exed-client] WARN: daemon script not found at ${daemonPath}
+`);
+    return;
+  }
+  const resolvedPath = daemonPath;
+  process.stderr.write(`[exed-client] Spawning daemon: ${resolvedPath}
+`);
+  const logPath = path4.join(path4.dirname(SOCKET_PATH), "exed.log");
+  let stderrFd = "ignore";
+  try {
+    stderrFd = openSync(logPath, "a");
+  } catch {
+  }
+  const child = spawn(process.execPath, [resolvedPath], {
+    detached: true,
+    stdio: ["ignore", "ignore", stderrFd],
+    env: {
+      ...process.env,
+      EXE_DAEMON_SOCK: SOCKET_PATH,
+      EXE_DAEMON_PID: PID_PATH
+    }
+  });
+  child.unref();
+  if (typeof stderrFd === "number") {
+    try {
+      closeSync(stderrFd);
+    } catch {
+    }
+  }
+}
+function acquireSpawnLock() {
+  try {
+    const fd = openSync(SPAWN_LOCK_PATH, "wx");
+    closeSync(fd);
+    return true;
+  } catch {
+    try {
+      const stat = statSync(SPAWN_LOCK_PATH);
+      if (Date.now() - stat.mtimeMs > SPAWN_LOCK_STALE_MS) {
+        try {
+          unlinkSync(SPAWN_LOCK_PATH);
+        } catch {
+        }
+        try {
+          const fd = openSync(SPAWN_LOCK_PATH, "wx");
+          closeSync(fd);
+          return true;
+        } catch {
+        }
+      }
+    } catch {
+    }
+    return false;
+  }
+}
+function releaseSpawnLock() {
+  try {
+    unlinkSync(SPAWN_LOCK_PATH);
+  } catch {
+  }
+}
+function connectToSocket() {
+  return new Promise((resolve) => {
+    if (_socket && _connected) {
+      resolve(true);
+      return;
+    }
+    const socket = net.createConnection({ path: SOCKET_PATH });
+    const connectTimeout = setTimeout(() => {
+      socket.destroy();
+      resolve(false);
+    }, 2e3);
+    socket.on("connect", () => {
+      clearTimeout(connectTimeout);
+      _socket = socket;
+      _connected = true;
+      _buffer = "";
+      socket.on("data", handleData);
+      socket.on("close", () => {
+        _connected = false;
+        _socket = null;
+        for (const [id, entry] of _pending) {
+          clearTimeout(entry.timer);
+          _pending.delete(id);
+          entry.resolve({ error: "Connection closed" });
+        }
+      });
+      socket.on("error", () => {
+        _connected = false;
+        _socket = null;
+      });
+      resolve(true);
+    });
+    socket.on("error", () => {
+      clearTimeout(connectTimeout);
+      resolve(false);
+    });
+  });
+}
+async function connectEmbedDaemon() {
+  if (_socket && _connected) return true;
+  if (await connectToSocket()) return true;
+  if (acquireSpawnLock()) {
+    try {
+      cleanupStaleFiles();
+      spawnDaemon();
+    } finally {
+      releaseSpawnLock();
+    }
+  }
+  const start = Date.now();
+  let delay = 100;
+  while (Date.now() - start < CONNECT_TIMEOUT_MS) {
+    await new Promise((r) => setTimeout(r, delay));
+    if (await connectToSocket()) return true;
+    delay = Math.min(delay * 2, 3e3);
+  }
+  return false;
+}
+function sendRequest(texts, priority) {
+  return new Promise((resolve) => {
+    if (!_socket || !_connected) {
+      resolve({ error: "Not connected" });
+      return;
+    }
+    const id = randomUUID();
+    const timer = setTimeout(() => {
+      _pending.delete(id);
+      resolve({ error: "Request timeout" });
+    }, REQUEST_TIMEOUT_MS);
+    _pending.set(id, { resolve, timer });
+    try {
+      _socket.write(JSON.stringify({ id, texts, priority }) + "\n");
+    } catch {
+      clearTimeout(timer);
+      _pending.delete(id);
+      resolve({ error: "Write failed" });
+    }
+  });
+}
+async function pingDaemon() {
+  if (!_socket || !_connected) return null;
+  return new Promise((resolve) => {
+    const id = randomUUID();
+    const timer = setTimeout(() => {
+      _pending.delete(id);
+      resolve(null);
+    }, 5e3);
+    _pending.set(id, {
+      resolve: (data) => {
+        if (data.health) {
+          resolve(data.health);
+        } else {
+          resolve(null);
+        }
+      },
+      timer
+    });
+    try {
+      _socket.write(JSON.stringify({ id, type: "health" }) + "\n");
+    } catch {
+      clearTimeout(timer);
+      _pending.delete(id);
+      resolve(null);
+    }
+  });
+}
+function killAndRespawnDaemon() {
+  process.stderr.write("[exed-client] Killing daemon for restart...\n");
+  if (existsSync4(PID_PATH)) {
+    try {
+      const pid = parseInt(readFileSync2(PID_PATH, "utf8").trim(), 10);
+      if (pid > 0) {
+        try {
+          process.kill(pid, "SIGKILL");
+        } catch {
+        }
+      }
+    } catch {
+    }
+  }
+  if (_socket) {
+    _socket.destroy();
+    _socket = null;
+  }
+  _connected = false;
+  _buffer = "";
+  try {
+    unlinkSync(PID_PATH);
+  } catch {
+  }
+  try {
+    unlinkSync(SOCKET_PATH);
+  } catch {
+  }
+  spawnDaemon();
+}
+async function embedViaClient(text, priority = "high") {
+  if (!_connected && !await connectEmbedDaemon()) return null;
+  _requestCount++;
+  if (_requestCount % HEALTH_CHECK_INTERVAL === 0) {
+    const health = await pingDaemon();
+    if (!health) {
+      process.stderr.write(`[exed-client] Periodic health check failed at request ${_requestCount} \u2014 restarting daemon
+`);
+      killAndRespawnDaemon();
+      const start = Date.now();
+      let delay = 200;
+      while (Date.now() - start < CONNECT_TIMEOUT_MS) {
+        await new Promise((r) => setTimeout(r, delay));
+        if (await connectToSocket()) break;
+        delay = Math.min(delay * 2, 3e3);
+      }
+      if (!_connected) return null;
+    }
+  }
+  const result = await sendRequest([text], priority);
+  if (!result.error && result.vectors?.[0]) return result.vectors[0];
+  if (result.error) {
+    process.stderr.write(`[exed-client] Embed failed (${result.error}) \u2014 attempting restart
+`);
+    killAndRespawnDaemon();
+    const start = Date.now();
+    let delay = 200;
+    while (Date.now() - start < CONNECT_TIMEOUT_MS) {
+      await new Promise((r) => setTimeout(r, delay));
+      if (await connectToSocket()) break;
+      delay = Math.min(delay * 2, 3e3);
+    }
+    if (!_connected) return null;
+    const retry = await sendRequest([text], priority);
+    if (!retry.error && retry.vectors?.[0]) return retry.vectors[0];
+    process.stderr.write(`[exed-client] Embed retry also failed: ${retry.error ?? "no vector"}
+`);
+  }
+  return null;
+}
+function disconnectClient() {
+  if (_socket) {
+    _socket.destroy();
+    _socket = null;
+  }
+  _connected = false;
+  _buffer = "";
+  for (const [id, entry] of _pending) {
+    clearTimeout(entry.timer);
+    _pending.delete(id);
+    entry.resolve({ error: "Client disconnected" });
+  }
+}
+var SOCKET_PATH, PID_PATH, SPAWN_LOCK_PATH, SPAWN_LOCK_STALE_MS, CONNECT_TIMEOUT_MS, REQUEST_TIMEOUT_MS, _socket, _connected, _buffer, _requestCount, HEALTH_CHECK_INTERVAL, _pending;
+var init_exe_daemon_client = __esm({
+  "src/lib/exe-daemon-client.ts"() {
+    "use strict";
+    init_config();
+    SOCKET_PATH = process.env.EXE_DAEMON_SOCK ?? process.env.EXE_EMBED_SOCK ?? path4.join(EXE_AI_DIR, "exed.sock");
+    PID_PATH = process.env.EXE_DAEMON_PID ?? process.env.EXE_EMBED_PID ?? path4.join(EXE_AI_DIR, "exed.pid");
+    SPAWN_LOCK_PATH = path4.join(EXE_AI_DIR, "exed-spawn.lock");
+    SPAWN_LOCK_STALE_MS = 3e4;
+    CONNECT_TIMEOUT_MS = 15e3;
+    REQUEST_TIMEOUT_MS = 3e4;
+    _socket = null;
+    _connected = false;
+    _buffer = "";
+    _requestCount = 0;
+    HEALTH_CHECK_INTERVAL = 100;
+    _pending = /* @__PURE__ */ new Map();
+  }
+});
 
-    CREATE INDEX IF NOT EXISTS idx_memories_user
-      ON memories(user_id);
-  `);
-  await client.executeMultiple(`
-    CREATE TABLE IF NOT EXISTS session_kills (
-      id                      TEXT PRIMARY KEY,
-      session_name            TEXT NOT NULL,
-      agent_id                TEXT NOT NULL,
-      killed_at               TIMESTAMP NOT NULL,
-      reason                  TEXT NOT NULL,
-      ticks_idle              INTEGER,
-      estimated_tokens_saved  INTEGER
+// src/lib/embedder.ts
+var embedder_exports = {};
+__export(embedder_exports, {
+  disposeEmbedder: () => disposeEmbedder,
+  embed: () => embed,
+  embedDirect: () => embedDirect,
+  getEmbedder: () => getEmbedder
+});
+async function getEmbedder() {
+  const ok = await connectEmbedDaemon();
+  if (!ok) {
+    throw new Error(
+      "Could not connect to embedding daemon. Ensure the model is installed (run /exe-setup)."
     );
-
-    CREATE INDEX IF NOT EXISTS idx_session_kills_killed_at
-      ON session_kills(killed_at);
-
-    CREATE INDEX IF NOT EXISTS idx_session_kills_agent
-      ON session_kills(agent_id);
-  `);
-  await client.executeMultiple(`
-    CREATE TABLE IF NOT EXISTS conversations (
-      id              TEXT PRIMARY KEY,
-      platform        TEXT NOT NULL,
-      external_id     TEXT,
-      sender_id       TEXT NOT NULL,
-      sender_name     TEXT,
-      sender_phone    TEXT,
-      sender_email    TEXT,
-      recipient_id    TEXT,
-      channel_id      TEXT NOT NULL,
-      thread_id       TEXT,
-      reply_to_id     TEXT,
-      content_text    TEXT,
-      content_media   TEXT,
-      content_metadata TEXT,
-      agent_response  TEXT,
-      agent_name      TEXT,
-      timestamp       TEXT NOT NULL,
-      ingested_at     TEXT NOT NULL
+  }
+}
+async function embed(text) {
+  const priority = process.env.EXE_EMBED_PRIORITY === "low" ? "low" : "high";
+  const vector = await embedViaClient(text, priority);
+  if (!vector) {
+    throw new Error(
+      "Embedding failed: daemon unavailable. Run /exe-setup to verify model installation."
     );
-
-    CREATE INDEX IF NOT EXISTS idx_conversations_platform
-      ON conversations(platform);
-
-    CREATE INDEX IF NOT EXISTS idx_conversations_sender
-      ON conversations(sender_id);
-
-    CREATE INDEX IF NOT EXISTS idx_conversations_timestamp
-      ON conversations(timestamp);
-
-    CREATE INDEX IF NOT EXISTS idx_conversations_thread
-      ON conversations(thread_id);
-
-    CREATE INDEX IF NOT EXISTS idx_conversations_channel
-      ON conversations(channel_id);
-  `);
-  await client.executeMultiple(`
-    CREATE VIRTUAL TABLE IF NOT EXISTS conversations_fts USING fts5(
-      content_text,
-      sender_name,
-      agent_response,
-      content='conversations',
-      content_rowid='rowid'
+  }
+  if (vector.length !== EMBEDDING_DIM) {
+    throw new Error(
+      `Embedding dimension mismatch: expected ${EMBEDDING_DIM}, got ${vector.length}. Ensure the correct Jina v5-small Q4_K_M GGUF model is installed.`
     );
-
-    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;
-  `);
+  }
+  return vector;
 }
-
-// src/lib/keychain.ts
-import { readFile as readFile2, writeFile as writeFile2, unlink, mkdir as mkdir2, chmod } from "fs/promises";
-import { existsSync as existsSync2 } from "fs";
-import path2 from "path";
-import crypto from "crypto";
-var SERVICE = "exe-mem";
-var ACCOUNT = "master-key";
-function getKeyDir() {
-  return process.env.EXE_OS_DIR ?? process.env.EXE_MEM_DIR ?? path2.join(process.env.HOME ?? "/tmp", ".exe-os");
+async function disposeEmbedder() {
+  disconnectClient();
 }
-function getKeyPath() {
-  return path2.join(getKeyDir(), "master.key");
+async function embedDirect(text) {
+  const llamaCpp = await import("node-llama-cpp");
+  const { MODELS_DIR: MODELS_DIR2 } = await Promise.resolve().then(() => (init_config(), config_exports));
+  const { existsSync: existsSync7 } = await import("fs");
+  const path10 = await import("path");
+  const modelPath = path10.join(MODELS_DIR2, "jina-embeddings-v5-small-q4_k_m.gguf");
+  if (!existsSync7(modelPath)) {
+    throw new Error(`Embedding model not found at ${modelPath}. Run '/exe-setup' to download it.`);
+  }
+  const llama = await llamaCpp.getLlama();
+  const model = await llama.loadModel({ modelPath });
+  const context = await model.createEmbeddingContext();
+  try {
+    const embedding = await context.getEmbeddingFor(text);
+    const vector = Array.from(embedding.vector);
+    if (vector.length !== EMBEDDING_DIM) {
+      throw new Error(
+        `Embedding dimension mismatch: expected ${EMBEDDING_DIM}, got ${vector.length}.`
+      );
+    }
+    return vector;
+  } finally {
+    await context.dispose();
+    await model.dispose();
+  }
 }
-async function tryKeytar() {
+var init_embedder = __esm({
+  "src/lib/embedder.ts"() {
+    "use strict";
+    init_memory();
+    init_exe_daemon_client();
+  }
+});
+
+// src/lib/project-name.ts
+var project_name_exports = {};
+__export(project_name_exports, {
+  _resetCache: () => _resetCache,
+  getProjectName: () => getProjectName
+});
+import { execSync } from "child_process";
+import path5 from "path";
+function getProjectName(cwd) {
+  const dir = cwd ?? process.cwd();
+  if (_cached && _cachedCwd === dir) return _cached;
   try {
-    return await import("keytar");
+    let repoRoot;
+    try {
+      const gitCommonDir = execSync("git rev-parse --path-format=absolute --git-common-dir", {
+        cwd: dir,
+        encoding: "utf8",
+        timeout: 2e3,
+        stdio: ["pipe", "pipe", "pipe"]
+      }).trim();
+      repoRoot = path5.dirname(gitCommonDir);
+    } catch {
+      repoRoot = execSync("git rev-parse --show-toplevel", {
+        cwd: dir,
+        encoding: "utf8",
+        timeout: 2e3,
+        stdio: ["pipe", "pipe", "pipe"]
+      }).trim();
+    }
+    _cached = path5.basename(repoRoot);
+    _cachedCwd = dir;
+    return _cached;
   } catch {
-    return null;
+    _cached = path5.basename(dir);
+    _cachedCwd = dir;
+    return _cached;
   }
 }
-async function getMasterKey() {
-  const keytar = await tryKeytar();
-  if (keytar) {
+function _resetCache() {
+  _cached = null;
+  _cachedCwd = null;
+}
+var _cached, _cachedCwd;
+var init_project_name = __esm({
+  "src/lib/project-name.ts"() {
+    "use strict";
+    _cached = null;
+    _cachedCwd = null;
+  }
+});
+
+// src/lib/file-grep.ts
+var file_grep_exports = {};
+__export(file_grep_exports, {
+  grepProjectFiles: () => grepProjectFiles
+});
+import { execSync as execSync2 } from "child_process";
+import { readFileSync as readFileSync3, readdirSync, statSync as statSync2, existsSync as existsSync5 } from "fs";
+import path6 from "path";
+import crypto2 from "crypto";
+function hasRipgrep() {
+  if (_hasRg === null) {
     try {
-      const stored = await keytar.getPassword(SERVICE, ACCOUNT);
-      if (stored) {
-        return Buffer.from(stored, "base64");
-      }
+      execSync2("rg --version", { stdio: "ignore", timeout: 2e3 });
+      _hasRg = true;
     } catch {
+      _hasRg = false;
     }
   }
-  const keyPath = getKeyPath();
-  if (!existsSync2(keyPath)) {
-    return null;
+  return _hasRg;
+}
+async function grepProjectFiles(query, projectRoot, options) {
+  const maxResults = options?.maxResults ?? 10;
+  const terms = query.toLowerCase().split(/\s+/).filter((t) => t.length >= 3).map((t) => t.replace(/[^a-z0-9_-]/g, "")).filter((t) => t.length >= 3);
+  if (terms.length === 0) return [];
+  const pattern = terms.join("|");
+  let hits;
+  if (hasRipgrep()) {
+    try {
+      hits = grepWithRipgrep(pattern, projectRoot, options?.patterns);
+    } catch {
+      hits = grepWithNodeFs(pattern, projectRoot, options?.patterns);
+    }
+  } else {
+    hits = grepWithNodeFs(pattern, projectRoot, options?.patterns);
   }
+  hits.sort((a, b) => b.density - a.density);
+  const topHits = hits.slice(0, maxResults);
+  return topHits.map((hit) => {
+    const chunkCtx = getChunkContext(hit.filePath, hit.lineNumber);
+    const prefix = chunkCtx ? `[file: ${hit.filePath}:${hit.lineNumber} in ${chunkCtx}]` : `[file: ${hit.filePath}:${hit.lineNumber}]`;
+    return {
+      id: crypto2.createHash("sha256").update(`${hit.filePath}:${hit.lineNumber}`).digest("hex").slice(0, 36),
+      agent_id: "project",
+      agent_role: "file",
+      session_id: "file-grep",
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      tool_name: "file_grep",
+      project_name: path6.basename(projectRoot),
+      has_error: false,
+      raw_text: `${prefix} ${buildSnippet(hit, projectRoot)}`,
+      vector: null,
+      task_id: null
+    };
+  });
+}
+function getChunkContext(filePath, lineNumber) {
   try {
-    const content = await readFile2(keyPath, "utf-8");
-    return Buffer.from(content.trim(), "base64");
+    const ext = filePath.split(".").pop()?.toLowerCase();
+    if (ext !== "ts" && ext !== "tsx" && ext !== "js" && ext !== "jsx") return "";
+    const source = readFileSync3(filePath, "utf8");
+    const lines = source.split("\n");
+    for (let i = Math.min(lineNumber - 1, lines.length - 1); i >= 0; i--) {
+      const line = lines[i];
+      const fnMatch = line.match(/(?:export\s+)?(?:async\s+)?function\s+(\w+)/);
+      if (fnMatch) return `function ${fnMatch[1]}`;
+      const classMatch = line.match(/(?:export\s+)?class\s+(\w+)/);
+      if (classMatch) return `class ${classMatch[1]}`;
+      const arrowMatch = line.match(/(?:export\s+)?(?:const|let)\s+(\w+)\s*=\s*(?:async\s+)?\(/);
+      if (arrowMatch) return `function ${arrowMatch[1]}`;
+    }
   } catch {
-    return null;
   }
+  return "";
 }
-
-// src/lib/store.ts
-init_config();
-var _pendingRecords = [];
-var _batchSize = 20;
-var _flushIntervalMs = 1e4;
-var _flushTimer = null;
-var _flushing = false;
-var _nextVersion = 1;
-async function initStore(options) {
-  if (_flushTimer !== null) {
-    clearInterval(_flushTimer);
-    _flushTimer = null;
+function grepWithRipgrep(pattern, projectRoot, patterns) {
+  const globs = (patterns ?? DEFAULT_PATTERNS).map((p) => `--glob '${p}'`).join(" ");
+  const excludes = EXCLUDE_DIRS.map((d) => `--glob '!${d}'`).join(" ");
+  const cmd = `rg -i -c --hidden --no-config --no-ignore '${pattern.replace(/'/g, "\\'")}' . ${globs} ${excludes} --max-filesize ${MAX_FILE_SIZE} 2>/dev/null || true`;
+  const output = execSync2(cmd, {
+    cwd: projectRoot,
+    encoding: "utf8",
+    timeout: 3e3,
+    maxBuffer: 1024 * 1024
+  });
+  if (!output.trim()) return [];
+  const hits = [];
+  for (const line of output.trim().split("\n")) {
+    const colonIdx = line.lastIndexOf(":");
+    if (colonIdx === -1) continue;
+    const filePath = line.slice(0, colonIdx);
+    const matchCount = parseInt(line.slice(colonIdx + 1));
+    if (isNaN(matchCount) || matchCount === 0) continue;
+    try {
+      const firstMatch = execSync2(
+        `rg -i -n --hidden '${pattern.replace(/'/g, "\\'")}' '${filePath}' --max-count 1 2>/dev/null | head -1`,
+        { cwd: projectRoot, encoding: "utf8", timeout: 1e3 }
+      ).trim();
+      const lineNum = parseInt(firstMatch.split(":")[0] ?? "1");
+      const totalLines = execSync2(`wc -l < '${filePath}'`, {
+        cwd: projectRoot,
+        encoding: "utf8",
+        timeout: 1e3
+      }).trim();
+      hits.push({
+        filePath,
+        lineNumber: isNaN(lineNum) ? 1 : lineNum,
+        matchLine: firstMatch.slice(firstMatch.indexOf(":") + 1).slice(0, 200),
+        matchCount,
+        totalLines: parseInt(totalLines) || 1,
+        density: matchCount / (parseInt(totalLines) || 1)
+      });
+    } catch {
+    }
   }
-  _pendingRecords = [];
-  _flushing = false;
-  _batchSize = options?.batchSize ?? 20;
-  _flushIntervalMs = options?.flushIntervalMs ?? 1e4;
-  let dbPath = options?.dbPath;
-  if (!dbPath) {
-    const config = await loadConfig();
-    dbPath = config.dbPath;
+  return hits;
+}
+function grepWithNodeFs(pattern, projectRoot, patterns) {
+  const regex = new RegExp(pattern, "gi");
+  const files = collectFiles(projectRoot, patterns ?? DEFAULT_PATTERNS);
+  const hits = [];
+  for (const filePath of files.slice(0, MAX_FILES)) {
+    const absPath = path6.join(projectRoot, filePath);
+    try {
+      const stat = statSync2(absPath);
+      if (stat.size > MAX_FILE_SIZE) continue;
+      const content = readFileSync3(absPath, "utf8");
+      const lines = content.split("\n");
+      const matches = content.match(regex);
+      if (!matches || matches.length === 0) continue;
+      const firstMatchIdx = lines.findIndex((l) => regex.test(l));
+      regex.lastIndex = 0;
+      hits.push({
+        filePath,
+        lineNumber: firstMatchIdx >= 0 ? firstMatchIdx + 1 : 1,
+        matchLine: firstMatchIdx >= 0 ? lines[firstMatchIdx].slice(0, 200) : "",
+        matchCount: matches.length,
+        totalLines: lines.length,
+        density: matches.length / lines.length
+      });
+    } catch {
+    }
   }
-  let masterKey = options?.masterKey ?? null;
-  if (!masterKey) {
-    masterKey = await getMasterKey();
-    if (!masterKey) {
-      throw new Error(
-        "No encryption key found. Run /exe-setup to generate one."
-      );
+  return hits;
+}
+function collectFiles(root, patterns) {
+  const files = [];
+  function walk(dir, relative) {
+    if (files.length >= MAX_FILES) return;
+    const basename = path6.basename(dir);
+    if (EXCLUDE_DIRS.includes(basename)) return;
+    try {
+      const entries = readdirSync(dir, { withFileTypes: true });
+      for (const entry of entries) {
+        if (files.length >= MAX_FILES) return;
+        const rel = path6.join(relative, entry.name);
+        if (entry.isDirectory()) {
+          walk(path6.join(dir, entry.name), rel);
+        } else if (entry.isFile()) {
+          for (const pat of patterns) {
+            if (matchGlob(rel, pat)) {
+              files.push(rel);
+              break;
+            }
+          }
+        }
+      }
+    } catch {
     }
   }
-  const hexKey = masterKey.toString("hex");
-  await initTurso({
-    dbPath,
-    encryptionKey: hexKey
-  });
-  await ensureSchema();
+  walk(root, "");
+  return files;
+}
+function matchGlob(filePath, pattern) {
+  if (!pattern.includes("*")) return filePath === pattern;
+  const doubleStarMatch = pattern.match(/^(.+?)\/\*\*\/\*(\.\w+)$/);
+  if (doubleStarMatch) {
+    const dir = doubleStarMatch[1];
+    const ext2 = doubleStarMatch[2];
+    return filePath.startsWith(dir + "/") && filePath.endsWith(ext2);
+  }
+  if (pattern.startsWith("**/")) {
+    const ext2 = pattern.slice(3).replace("*", "");
+    return filePath.endsWith(ext2);
+  }
+  const slashIdx = pattern.lastIndexOf("/");
+  if (slashIdx !== -1) {
+    const dir = pattern.slice(0, slashIdx);
+    const ext2 = pattern.slice(slashIdx + 1).replace("*", "");
+    const fileDir = path6.dirname(filePath);
+    return fileDir === dir && filePath.endsWith(ext2);
+  }
+  const ext = pattern.replace("*", "");
+  return filePath.endsWith(ext) && !filePath.includes("/");
+}
+function buildSnippet(hit, projectRoot) {
   try {
-    const { initShardManager: initShardManager2 } = await Promise.resolve().then(() => (init_shard_manager(), shard_manager_exports));
-    initShardManager2(hexKey);
+    const absPath = path6.join(projectRoot, hit.filePath);
+    if (!existsSync5(absPath)) return hit.matchLine;
+    const lines = readFileSync3(absPath, "utf8").split("\n");
+    const start = Math.max(0, hit.lineNumber - 3);
+    const end = Math.min(lines.length, hit.lineNumber + 2);
+    return lines.slice(start, end).join("\n").slice(0, 500);
   } catch {
+    return hit.matchLine;
   }
-  const client = getClient();
-  const vResult = await client.execute("SELECT MAX(version) as max_v FROM memories");
-  _nextVersion = (Number(vResult.rows[0]?.max_v) || 0) + 1;
 }
-function buildWikiScopeFilter(options, columnPrefix) {
-  const args = [];
-  let clause = "";
-  if (options?.workspaceId !== void 0) {
-    clause += ` AND ${columnPrefix}workspace_id = ?`;
-    args.push(options.workspaceId);
+var _hasRg, DEFAULT_PATTERNS, EXCLUDE_DIRS, MAX_FILE_SIZE, MAX_FILES;
+var init_file_grep = __esm({
+  "src/lib/file-grep.ts"() {
+    "use strict";
+    _hasRg = null;
+    DEFAULT_PATTERNS = [
+      ".planning/*.md",
+      "exe/output/*.md",
+      "README.md",
+      "src/**/*.ts"
+    ];
+    EXCLUDE_DIRS = ["node_modules", "dist", ".git", "coverage", ".worktrees"];
+    MAX_FILE_SIZE = 100 * 1024;
+    MAX_FILES = 500;
   }
-  if (options?.userId === void 0) {
-    clause += ` AND ${columnPrefix}user_id IS NULL`;
-  } else if (options.userId === null) {
-    clause += ` AND ${columnPrefix}user_id IS NULL`;
-  } else {
-    clause += ` AND (${columnPrefix}user_id = ? OR ${columnPrefix}user_id IS NULL)`;
-    args.push(options.userId);
+});
+
+// src/lib/reranker.ts
+var reranker_exports = {};
+__export(reranker_exports, {
+  disposeReranker: () => disposeReranker,
+  getRerankerModelPath: () => getRerankerModelPath,
+  isRerankerAvailable: () => isRerankerAvailable,
+  rerank: () => rerank,
+  rerankWithScores: () => rerankWithScores
+});
+import path7 from "path";
+import { existsSync as existsSync6 } from "fs";
+function resetIdleTimer() {
+  if (_idleTimer) clearTimeout(_idleTimer);
+  _idleTimer = setTimeout(() => {
+    void disposeReranker();
+  }, IDLE_TIMEOUT_MS);
+  if (_idleTimer && typeof _idleTimer === "object" && "unref" in _idleTimer) {
+    _idleTimer.unref();
   }
-  return { clause, args };
 }
-async function searchMemories(queryVector, agentId, options) {
-  let client;
-  try {
-    const { isShardingEnabled: isShardingEnabled2, shardExists: shardExists2, getReadyShardClient: getReadyShardClient2 } = await Promise.resolve().then(() => (init_shard_manager(), shard_manager_exports));
-    if (isShardingEnabled2() && options?.projectName && shardExists2(options.projectName)) {
-      client = await getReadyShardClient2(options.projectName);
-    } else {
-      client = getClient();
-    }
-  } catch {
-    client = getClient();
+function isRerankerAvailable() {
+  return existsSync6(path7.join(MODELS_DIR, RERANKER_MODEL_FILE));
+}
+function getRerankerModelPath() {
+  return path7.join(MODELS_DIR, RERANKER_MODEL_FILE);
+}
+async function ensureLoaded() {
+  if (_rerankerContext) {
+    resetIdleTimer();
+    return;
   }
-  const limit = options?.limit ?? 10;
-  const statusFilter = options?.includeArchived ? "" : `
-               AND COALESCE(status, 'active') = 'active'`;
-  let sql = `SELECT id, agent_id, agent_role, session_id, timestamp,
-                    tool_name, project_name,
-                    has_error, raw_text, vector, importance, status,
-                    confidence, last_accessed,
-                    workspace_id, document_id, user_id,
-                    char_offset, page_number
-             FROM memories
-             WHERE agent_id = ?
-               AND vector IS NOT NULL${statusFilter}
-               AND COALESCE(confidence, 0.7) >= 0.3`;
-  const args = [agentId];
-  const scope = buildWikiScopeFilter(options, "");
-  sql += scope.clause;
-  args.push(...scope.args);
-  if (options?.projectName) {
-    sql += ` AND project_name = ?`;
-    args.push(options.projectName);
+  const modelPath = path7.join(MODELS_DIR, RERANKER_MODEL_FILE);
+  if (!existsSync6(modelPath)) {
+    throw new Error(
+      `Reranker model not found at ${modelPath}. Run /exe-setup to download it.`
+    );
   }
-  if (options?.toolName) {
-    sql += ` AND tool_name = ?`;
-    args.push(options.toolName);
+  process.stderr.write("[reranker] Loading Jina Reranker v3...\n");
+  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");
+  resetIdleTimer();
+}
+async function disposeReranker() {
+  if (_idleTimer) {
+    clearTimeout(_idleTimer);
+    _idleTimer = null;
   }
-  if (options?.hasError !== void 0) {
-    sql += ` AND has_error = ?`;
-    args.push(options.hasError ? 1 : 0);
+  if (_rerankerContext) {
+    try {
+      await _rerankerContext.dispose();
+    } catch {
+    }
+    _rerankerContext = null;
   }
-  if (options?.since) {
-    sql += ` AND timestamp >= ?`;
-    args.push(options.since);
+  if (_rerankerModel) {
+    try {
+      await _rerankerModel.dispose();
+    } catch {
+    }
+    _rerankerModel = null;
   }
-  sql += ` ORDER BY vector_distance_cos(vector, vector32(?))`;
-  args.push(vectorToBlob(queryVector));
-  sql += ` LIMIT ?`;
-  args.push(limit);
-  const result = await client.execute({ sql, args });
-  return result.rows.map((row) => ({
-    id: row.id,
-    agent_id: row.agent_id,
-    agent_role: row.agent_role,
-    session_id: row.session_id,
-    timestamp: row.timestamp,
-    tool_name: row.tool_name,
-    project_name: row.project_name,
-    has_error: row.has_error === 1,
-    raw_text: row.raw_text,
-    vector: row.vector == null ? [] : Array.isArray(row.vector) ? row.vector : Array.from(row.vector),
-    importance: row.importance ?? 5,
-    status: row.status ?? "active",
-    confidence: row.confidence ?? 0.7,
-    last_accessed: row.last_accessed ?? row.timestamp,
-    workspace_id: row.workspace_id ?? null,
-    document_id: row.document_id ?? null,
-    user_id: row.user_id ?? null,
-    char_offset: row.char_offset ?? null,
-    page_number: row.page_number ?? null
-  }));
+  process.stderr.write("[reranker] Unloaded (idle timeout).\n");
 }
-async function attachDocumentMetadata(records) {
-  const docIds = [
-    ...new Set(
-      records.map((r) => r.document_id).filter((id) => typeof id === "string" && id.length > 0)
-    )
-  ];
-  if (docIds.length === 0) return records;
-  try {
-    const client = getClient();
-    const placeholders = docIds.map(() => "?").join(",");
-    const result = await client.execute({
-      sql: `SELECT id, filename, mime, source_type, uploaded_at
-            FROM documents
-            WHERE id IN (${placeholders})`,
-      args: docIds
-    });
-    const byId = /* @__PURE__ */ new Map();
-    for (const row of result.rows) {
-      const id = row.id;
-      byId.set(id, {
-        document_id: id,
-        filename: row.filename,
-        mime: row.mime ?? null,
-        source_type: row.source_type ?? null,
-        uploaded_at: row.uploaded_at
-      });
-    }
-    for (const record of records) {
-      if (!record.document_id) continue;
-      record.document_metadata = byId.get(record.document_id) ?? null;
+async function rerankWithScores(query, texts, topK) {
+  if (texts.length === 0) return [];
+  await ensureLoaded();
+  const ctx = _rerankerContext;
+  const scored = [];
+  for (let i = 0; i < texts.length; i++) {
+    const text = texts[i] ?? "";
+    try {
+      const input2 = `query: ${query} document: ${text.slice(0, 512)}`;
+      const embedding = await ctx.getEmbeddingFor(input2);
+      const score = embedding.vector[0] ?? 0;
+      scored.push({ text, score, index: i });
+    } catch {
+      scored.push({ text, score: -1, index: i });
     }
-  } catch {
   }
-  return records;
+  scored.sort((a, b) => b.score - a.score);
+  return typeof topK === "number" ? scored.slice(0, topK) : scored;
 }
-function vectorToBlob(vector) {
-  const f32 = vector instanceof Float32Array ? vector : new Float32Array(vector);
-  return JSON.stringify(Array.from(f32));
+async function rerank(query, candidates, topK = 5) {
+  if (candidates.length === 0) return [];
+  if (candidates.length <= topK) return candidates;
+  const scored = await rerankWithScores(
+    query,
+    candidates.map((c) => c.raw_text),
+    topK
+  );
+  return scored.map((s) => candidates[s.index]);
 }
+var RERANKER_MODEL_FILE, IDLE_TIMEOUT_MS, _rerankerContext, _rerankerModel, _idleTimer;
+var init_reranker = __esm({
+  "src/lib/reranker.ts"() {
+    "use strict";
+    init_config();
+    RERANKER_MODEL_FILE = "jina-reranker-v3-q4_k_m.gguf";
+    IDLE_TIMEOUT_MS = 6e4;
+    _rerankerContext = null;
+    _rerankerModel = null;
+    _idleTimer = null;
+  }
+});
+
+// src/adapters/claude/hooks/session-start.ts
+init_config();
+init_config();
+init_store();
+init_database();
+import path9 from "path";
+import { unlinkSync as unlinkSync3 } from "fs";
 
 // src/lib/hybrid-search.ts
+init_store();
+init_database();
 var RRF_K = 60;
 async function hybridSearch(queryText, agentId, options) {
   const { loadConfig: loadConfig2 } = await Promise.resolve().then(() => (init_config(), config_exports));
@@ -2295,8 +2733,21 @@ async function hybridSearch(queryText, agentId, options) {
     } catch {
     }
   }
+  const { getMemoryCardinality: getMemoryCardinality2 } = await Promise.resolve().then(() => (init_store(), store_exports));
+  const cardinality = await getMemoryCardinality2(agentId);
+  const { rerankerAutoTrigger } = config.scalingRoadmap ?? {};
+  const minCardForBroad = rerankerAutoTrigger?.broadQueryMinCardinality ?? 5e4;
+  const useNarrowPath = cardinality < 1e4;
+  const useBroadPath = cardinality > minCardForBroad || _isBroadQuery && cardinality >= 1e4;
+  const effectiveIsBroad = useBroadPath && !useNarrowPath;
+  if (effectiveIsBroad !== _isBroadQuery) {
+    process.stderr.write(
+      `[hybrid-search] Adaptive routing override: cardinality=${cardinality}, router=${_isBroadQuery ? "broad" : "narrow"} \u2192 ${effectiveIsBroad ? "broad" : "narrow"}
+`
+    );
+  }
   const broadFetchTopK = config.scalingRoadmap?.rerankerAutoTrigger?.fetchTopK ?? 150;
-  const fetchLimit = _isBroadQuery ? Math.max(limit * 5, broadFetchTopK) : Math.max(limit * 3, 30);
+  const fetchLimit = effectiveIsBroad ? Math.max(limit * 5, broadFetchTopK) : Math.max(limit * 3, 30);
   const fetchOptions = { ...effectiveOptions, limit: fetchLimit, includeSource: false };
   let queryVector = null;
   try {
@@ -2340,8 +2791,8 @@ async function hybridSearch(queryText, agentId, options) {
     weights.push(0.5);
   }
   if (lists.length === 0) return [];
-  if (lists.length === 1 && !_isBroadQuery) return lists[0].slice(0, limit);
-  const rrfLimit = _isBroadQuery ? Math.max(limit * 5, 150) : limit;
+  if (lists.length === 1 && !effectiveIsBroad) return lists[0].slice(0, limit);
+  const rrfLimit = effectiveIsBroad ? Math.max(limit * 5, 150) : limit;
   const merged = lists.length === 1 ? lists[0].slice(0, rrfLimit) : rrfMergeMulti(lists, rrfLimit, RRF_K, weights);
   const auto = config.scalingRoadmap?.rerankerAutoTrigger ?? {
     enabled: config.rerankerEnabled ?? true,
@@ -2350,9 +2801,9 @@ async function hybridSearch(queryText, agentId, options) {
     returnTopK: 5
   };
   let rerankedAndBlended = null;
-  if (_isBroadQuery && auto.enabled) {
-    const cardinality = await estimateCardinality(agentId, effectiveOptions);
-    if (cardinality > auto.broadQueryMinCardinality) {
+  if (effectiveIsBroad && auto.enabled) {
+    const cardinality2 = await estimateCardinality(agentId, effectiveOptions);
+    if (cardinality2 > auto.broadQueryMinCardinality) {
       try {
         const { isRerankerAvailable: isRerankerAvailable2, rerank: rerank2 } = await Promise.resolve().then(() => (init_reranker(), reranker_exports));
         if (isRerankerAvailable2()) {
@@ -2429,6 +2880,11 @@ function recencyScore(timestamp) {
 function normalizedImportance(importance) {
   return ((importance ?? 5) - 1) / 9;
 }
+function frecencyBoost(lastAccessed, timestamp) {
+  const accessTime = lastAccessed ? new Date(lastAccessed).getTime() : new Date(timestamp).getTime();
+  const hoursSince = Math.max(0, (Date.now() - accessTime) / (1e3 * 60 * 60));
+  return Math.exp(-0.01 * hoursSince);
+}
 function rrfMergeMulti(lists, limit, k = RRF_K, weights) {
   const scores = /* @__PURE__ */ new Map();
   for (let listIdx = 0; listIdx < lists.length; listIdx++) {
@@ -2445,7 +2901,9 @@ function rrfMergeMulti(lists, limit, k = RRF_K, weights) {
     const recency = recencyScore(e.record.timestamp);
     const importance = normalizedImportance(e.record.importance);
     const confidence = e.record.confidence ?? 0.7;
-    const finalScore = e.rrfScore * 0.35 + recency * 0.14 + importance * 0.21 + confidence * 0.3;
+    const frecency = frecencyBoost(e.record.last_accessed, e.record.timestamp);
+    const baseScore = e.rrfScore * 0.35 + recency * 0.14 + importance * 0.21 + confidence * 0.3;
+    const finalScore = baseScore * (1 + 0.3 * frecency);
     return { score: finalScore, record: e.record };
   });
   return entries.sort((a, b) => b.score - a.score).slice(0, limit).map((e) => e.record);
@@ -2485,7 +2943,8 @@ async function ftsQuery(client, matchExpr, agentId, options, limit) {
                     m.has_error, m.raw_text, m.vector, m.task_id,
                     m.importance, m.status, m.confidence, m.last_accessed,
                     m.workspace_id, m.document_id, m.user_id,
-                    m.char_offset, m.page_number
+                    m.char_offset, m.page_number,
+                    m.source_path, m.source_type
              FROM memories m
              JOIN memories_fts fts ON m.rowid = fts.rowid
              WHERE memories_fts MATCH ?
@@ -2534,7 +2993,9 @@ async function ftsQuery(client, matchExpr, agentId, options, limit) {
     document_id: row.document_id ?? null,
     user_id: row.user_id ?? null,
     char_offset: row.char_offset ?? null,
-    page_number: row.page_number ?? null
+    page_number: row.page_number ?? null,
+    source_path: row.source_path ?? null,
+    source_type: row.source_type ?? null
   }));
 }
 async function recentRecords(agentId, options, limit) {
@@ -2546,7 +3007,8 @@ async function recentRecords(agentId, options, limit) {
                     has_error, raw_text, vector, task_id,
                     importance, status, confidence, last_accessed,
                     workspace_id, document_id, user_id,
-                    char_offset, page_number
+                    char_offset, page_number,
+                    source_path, source_type
              FROM memories
              WHERE agent_id = ?${statusFilter}
                AND COALESCE(confidence, 0.7) >= 0.3`;
@@ -2593,7 +3055,9 @@ async function recentRecords(agentId, options, limit) {
     document_id: row.document_id ?? null,
     user_id: row.user_id ?? null,
     char_offset: row.char_offset ?? null,
-    page_number: row.page_number ?? null
+    page_number: row.page_number ?? null,
+    source_path: row.source_path ?? null,
+    source_type: row.source_type ?? null
   }));
 }