@askexenow/exe-os 0.8.1 → 0.8.2

package/dist/hooks/commit-complete.js

@@ -1,2364 +0,0 @@
-var __defProp = Object.defineProperty;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
-  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
-}) : x)(function(x) {
-  if (typeof require !== "undefined") return require.apply(this, arguments);
-  throw Error('Dynamic require of "' + x + '" is not supported');
-});
-var __esm = (fn, res) => function __init() {
-  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
-};
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-
-// src/types/memory.ts
-var EMBEDDING_DIM;
-var init_memory = __esm({
-  "src/types/memory.ts"() {
-    "use strict";
-    EMBEDDING_DIM = 1024;
-  }
-});
-
-// src/lib/database.ts
-var database_exports = {};
-__export(database_exports, {
-  disposeDatabase: () => disposeDatabase,
-  disposeTurso: () => disposeTurso,
-  ensureSchema: () => ensureSchema,
-  getClient: () => getClient,
-  initDatabase: () => initDatabase,
-  initTurso: () => initTurso,
-  isInitialized: () => isInitialized
-});
-import { createClient } from "@libsql/client";
-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 isInitialized() {
-  return _client !== null;
-}
-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 {
-  }
-  await client.executeMultiple(`
-    CREATE TABLE IF NOT EXISTS memories (
-      id            TEXT PRIMARY KEY,
-      agent_id      TEXT NOT NULL,
-      agent_role    TEXT NOT NULL,
-      session_id    TEXT NOT NULL,
-      timestamp     TEXT NOT NULL,
-      tool_name     TEXT NOT NULL,
-      project_name  TEXT NOT NULL,
-      has_error     INTEGER NOT NULL DEFAULT 0,
-      raw_text      TEXT NOT NULL,
-      vector        F32_BLOB(1024),
-      version       INTEGER NOT NULL DEFAULT 0
-    );
-
-    CREATE INDEX IF NOT EXISTS idx_memories_agent
-      ON memories(agent_id);
-
-    CREATE INDEX IF NOT EXISTS idx_memories_timestamp
-      ON memories(timestamp);
-
-    CREATE INDEX IF NOT EXISTS idx_memories_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(
-      raw_text,
-      content='memories',
-      content_rowid='rowid'
-    );
-
-    CREATE TRIGGER IF NOT EXISTS memories_fts_ai AFTER INSERT ON memories BEGIN
-      INSERT INTO memories_fts(rowid, raw_text) VALUES (new.rowid, new.raw_text);
-    END;
-
-    CREATE TRIGGER IF NOT EXISTS memories_fts_ad AFTER DELETE ON memories BEGIN
-      INSERT INTO memories_fts(memories_fts, rowid, raw_text) VALUES('delete', old.rowid, old.raw_text);
-    END;
-
-    CREATE TRIGGER IF NOT EXISTS memories_fts_au AFTER UPDATE ON memories BEGIN
-      INSERT INTO memories_fts(memories_fts, rowid, raw_text) VALUES('delete', old.rowid, old.raw_text);
-      INSERT INTO memories_fts(rowid, raw_text) VALUES (new.rowid, new.raw_text);
-    END;
-  `);
-  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_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_behaviors_agent
-      ON behaviors(agent_id, active);
-  `);
-  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'`,
-      args: []
-    });
-  } catch {
-  }
-  try {
-    await client.execute({
-      sql: `ALTER TABLE tasks ADD COLUMN blocked_by TEXT`,
-      args: []
-    });
-  } catch {
-  }
-  try {
-    await client.execute({
-      sql: `ALTER TABLE tasks ADD COLUMN parent_task_id TEXT`,
-      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`,
-      args: []
-    });
-  } catch {
-  }
-  try {
-    await client.execute({
-      sql: `UPDATE tasks SET status = 'done' WHERE status = 'completed'`,
-      args: []
-    });
-  } catch {
-  }
-  try {
-    await client.execute({
-      sql: `ALTER TABLE tasks ADD COLUMN reviewer TEXT`,
-      args: []
-    });
-  } catch {
-  }
-  try {
-    await client.execute({
-      sql: `ALTER TABLE tasks ADD COLUMN context TEXT`,
-      args: []
-    });
-  } catch {
-  }
-  try {
-    await client.execute({
-      sql: `ALTER TABLE tasks ADD COLUMN result TEXT`,
-      args: []
-    });
-  } catch {
-  }
-  try {
-    await client.execute({
-      sql: `ALTER TABLE tasks ADD COLUMN assigned_tmux TEXT`,
-      args: []
-    });
-  } catch {
-  }
-  try {
-    await client.execute({
-      sql: `ALTER TABLE tasks ADD COLUMN checkpoint TEXT`,
-      args: []
-    });
-  } catch {
-  }
-  try {
-    await client.execute({
-      sql: `ALTER TABLE tasks ADD COLUMN checkpoint_count INTEGER NOT NULL DEFAULT 0`,
-      args: []
-    });
-  } catch {
-  }
-  try {
-    await client.execute({
-      sql: `ALTER TABLE tasks ADD COLUMN complexity TEXT NOT NULL DEFAULT 'standard'`,
-      args: []
-    });
-  } catch {
-  }
-  try {
-    await client.execute({
-      sql: `ALTER TABLE memories ADD COLUMN task_id TEXT`,
-      args: []
-    });
-  } catch {
-  }
-  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 author_device_id TEXT`,
-      args: []
-    });
-  } catch {
-  }
-  try {
-    await client.execute({
-      sql: `ALTER TABLE memories ADD COLUMN scope TEXT NOT NULL DEFAULT 'business'`,
-      args: []
-    });
-  } 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);
-
-    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);
-  `);
-  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 {
-    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 {
-  }
-  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
-    );
-
-    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 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 {
-      await client.execute(col);
-    } catch {
-    }
-  }
-  try {
-    await client.execute(
-      `CREATE INDEX IF NOT EXISTS idx_memories_status ON memories(status)`
-    );
-  } 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)
-    );
-
-    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 {
-    }
-  }
-  for (const col of [
-    "ALTER TABLE memories ADD COLUMN source_path TEXT",
-    "ALTER TABLE memories ADD COLUMN source_type TEXT DEFAULT 'text'"
-  ]) {
-    try {
-      await client.execute(col);
-    } catch {
-    }
-  }
-  await client.executeMultiple(`
-    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);
-  `);
-  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
-    );
-
-    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
-    );
-
-    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);
-  `);
-  try {
-    await client.execute({
-      sql: `ALTER TABLE tasks ADD COLUMN budget_tokens INTEGER`,
-      args: []
-    });
-  } catch {
-  }
-  try {
-    await client.execute({
-      sql: `ALTER TABLE tasks ADD COLUMN budget_fallback_model TEXT`,
-      args: []
-    });
-  } catch {
-  }
-  try {
-    await client.execute({
-      sql: `ALTER TABLE tasks ADD COLUMN tokens_used INTEGER DEFAULT 0`,
-      args: []
-    });
-  } catch {
-  }
-  try {
-    await client.execute({
-      sql: `ALTER TABLE tasks ADD COLUMN tokens_warned_at INTEGER`,
-      args: []
-    });
-  } catch {
-  }
-  await client.executeMultiple(`
-    CREATE VIRTUAL TABLE IF NOT EXISTS conversations_fts USING fts5(
-      content_text,
-      sender_name,
-      agent_response,
-      content='conversations',
-      content_rowid='rowid'
-    );
-
-    CREATE TRIGGER IF NOT EXISTS conversations_fts_ai AFTER INSERT ON conversations BEGIN
-      INSERT INTO conversations_fts(rowid, content_text, sender_name, agent_response)
-      VALUES (new.rowid, new.content_text, new.sender_name, new.agent_response);
-    END;
-
-    CREATE TRIGGER IF NOT EXISTS conversations_fts_ad AFTER DELETE ON conversations BEGIN
-      INSERT INTO conversations_fts(conversations_fts, rowid, content_text, sender_name, agent_response)
-      VALUES('delete', old.rowid, old.content_text, old.sender_name, old.agent_response);
-    END;
-
-    CREATE TRIGGER IF NOT EXISTS conversations_fts_au AFTER UPDATE ON conversations BEGIN
-      INSERT INTO conversations_fts(conversations_fts, rowid, content_text, sender_name, agent_response)
-      VALUES('delete', old.rowid, old.content_text, old.sender_name, old.agent_response);
-      INSERT INTO conversations_fts(rowid, content_text, sender_name, agent_response)
-      VALUES (new.rowid, new.content_text, new.sender_name, new.agent_response);
-    END;
-  `);
-  try {
-    await client.execute({
-      sql: `ALTER TABLE memories ADD COLUMN tier INTEGER DEFAULT 3`,
-      args: []
-    });
-  } catch {
-  }
-  try {
-    await client.execute(
-      `CREATE INDEX IF NOT EXISTS idx_memories_tier ON memories(tier)`
-    );
-  } catch {
-  }
-  try {
-    await client.execute({
-      sql: `UPDATE memories SET tier = 1 WHERE tool_name = 'commit_to_long_term_memory' AND importance >= 8 AND tier = 3`,
-      args: []
-    });
-    await client.execute({
-      sql: `UPDATE memories SET tier = 2 WHERE tool_name IN ('store_memory', 'manual') AND importance >= 5 AND tier = 3`,
-      args: []
-    });
-  } catch {
-  }
-  try {
-    await client.execute({
-      sql: `ALTER TABLE memories ADD COLUMN supersedes_id TEXT`,
-      args: []
-    });
-  } catch {
-  }
-  try {
-    await client.execute(
-      `CREATE INDEX IF NOT EXISTS idx_memories_supersedes ON memories(supersedes_id) WHERE supersedes_id IS NOT NULL`
-    );
-  } catch {
-  }
-  for (const col of [
-    "ALTER TABLE tasks ADD COLUMN checkpoint TEXT",
-    "ALTER TABLE tasks ADD COLUMN checkpoint_count INTEGER DEFAULT 0"
-  ]) {
-    try {
-      await client.execute(col);
-    } catch {
-    }
-  }
-}
-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, writeFile, unlink, mkdir, chmod } from "fs/promises";
-import { existsSync } from "fs";
-import path from "path";
-import crypto from "crypto";
-function getKeyDir() {
-  return process.env.EXE_OS_DIR ?? process.env.EXE_MEM_DIR ?? path.join(process.env.HOME ?? "/tmp", ".exe-os");
-}
-function getKeyPath() {
-  return path.join(getKeyDir(), "master.key");
-}
-async function tryKeytar() {
-  try {
-    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 (!existsSync(keyPath)) {
-    return null;
-  }
-  try {
-    const content = await readFile(keyPath, "utf-8");
-    return Buffer.from(content.trim(), "base64");
-  } catch {
-    return null;
-  }
-}
-var SERVICE, ACCOUNT;
-var init_keychain = __esm({
-  "src/lib/keychain.ts"() {
-    "use strict";
-    SERVICE = "exe-mem";
-    ACCOUNT = "master-key";
-  }
-});
-
-// src/lib/config.ts
-import { readFile as readFile2, writeFile as writeFile2, mkdir as mkdir2 } from "fs/promises";
-import { readFileSync, existsSync as existsSync2, renameSync } from "fs";
-import path2 from "path";
-import os from "os";
-function resolveDataDir() {
-  if (process.env.EXE_OS_DIR) return process.env.EXE_OS_DIR;
-  if (process.env.EXE_MEM_DIR) return process.env.EXE_MEM_DIR;
-  const newDir = path2.join(os.homedir(), ".exe-os");
-  const legacyDir = path2.join(os.homedir(), ".exe-mem");
-  if (!existsSync2(newDir) && existsSync2(legacyDir)) {
-    try {
-      renameSync(legacyDir, newDir);
-      process.stderr.write(`[exe-os] Migrated data directory: ~/.exe-mem \u2192 ~/.exe-os
-`);
-    } catch {
-      return legacyDir;
-    }
-  }
-  return newDir;
-}
-function migrateLegacyConfig(raw) {
-  if ("r2" in raw) {
-    process.stderr.write(
-      "[exe-os] Warning: config.json contains deprecated 'r2' field from v1.0. R2 sync has been replaced in v1.1. The 'r2' field will be ignored.\n"
-    );
-    delete raw.r2;
-  }
-  if ("syncIntervalMs" in raw) {
-    delete raw.syncIntervalMs;
-  }
-  return raw;
-}
-function migrateConfig(raw) {
-  const fromVersion = typeof raw.config_version === "number" ? raw.config_version : 0;
-  let currentVersion = fromVersion;
-  let migrated = false;
-  if (currentVersion > CURRENT_CONFIG_VERSION) {
-    return { config: raw, migrated: false, fromVersion };
-  }
-  for (const migration of CONFIG_MIGRATIONS) {
-    if (currentVersion === migration.from && migration.to <= CURRENT_CONFIG_VERSION) {
-      raw = migration.migrate(raw);
-      currentVersion = migration.to;
-      migrated = true;
-    }
-  }
-  return { config: raw, migrated, fromVersion };
-}
-function normalizeScalingRoadmap(raw) {
-  const defaultAuto = DEFAULT_CONFIG.scalingRoadmap.rerankerAutoTrigger;
-  const userRoadmap = raw.scalingRoadmap ?? {};
-  const userAuto = userRoadmap.rerankerAutoTrigger ?? {};
-  if (userAuto.enabled === void 0 && raw.rerankerEnabled !== void 0) {
-    userAuto.enabled = raw.rerankerEnabled;
-  }
-  raw.scalingRoadmap = {
-    ...userRoadmap,
-    rerankerAutoTrigger: { ...defaultAuto, ...userAuto }
-  };
-}
-function normalizeSessionLifecycle(raw) {
-  const defaultSL = DEFAULT_CONFIG.sessionLifecycle;
-  const userSL = raw.sessionLifecycle ?? {};
-  raw.sessionLifecycle = { ...defaultSL, ...userSL };
-}
-function normalizeAutoUpdate(raw) {
-  const defaultAU = DEFAULT_CONFIG.autoUpdate;
-  const userAU = raw.autoUpdate ?? {};
-  raw.autoUpdate = { ...defaultAU, ...userAU };
-}
-async function loadConfig() {
-  const dir = process.env.EXE_OS_DIR ?? process.env.EXE_MEM_DIR ?? EXE_AI_DIR;
-  await mkdir2(dir, { recursive: true });
-  const configPath = path2.join(dir, "config.json");
-  if (!existsSync2(configPath)) {
-    return { ...DEFAULT_CONFIG, dbPath: path2.join(dir, "memories.db") };
-  }
-  const raw = await readFile2(configPath, "utf-8");
-  try {
-    let parsed = JSON.parse(raw);
-    parsed = migrateLegacyConfig(parsed);
-    const { config: migratedCfg, migrated, fromVersion } = migrateConfig(parsed);
-    if (migrated) {
-      process.stderr.write(`[exe-os] Config migrated from v${fromVersion} to v${migratedCfg.config_version}
-`);
-      try {
-        await writeFile2(configPath, JSON.stringify(migratedCfg, null, 2) + "\n");
-      } catch {
-      }
-    }
-    normalizeScalingRoadmap(migratedCfg);
-    normalizeSessionLifecycle(migratedCfg);
-    normalizeAutoUpdate(migratedCfg);
-    const config = { ...DEFAULT_CONFIG, dbPath: path2.join(dir, "memories.db"), ...migratedCfg };
-    if (config.dbPath.startsWith("~")) {
-      config.dbPath = config.dbPath.replace(/^~/, os.homedir());
-    }
-    return config;
-  } catch {
-    return { ...DEFAULT_CONFIG, dbPath: path2.join(dir, "memories.db") };
-  }
-}
-var EXE_AI_DIR, DB_PATH, MODELS_DIR, CONFIG_PATH, LEGACY_LANCE_PATH, CURRENT_CONFIG_VERSION, DEFAULT_CONFIG, CONFIG_MIGRATIONS;
-var init_config = __esm({
-  "src/lib/config.ts"() {
-    "use strict";
-    EXE_AI_DIR = resolveDataDir();
-    DB_PATH = path2.join(EXE_AI_DIR, "memories.db");
-    MODELS_DIR = path2.join(EXE_AI_DIR, "models");
-    CONFIG_PATH = path2.join(EXE_AI_DIR, "config.json");
-    LEGACY_LANCE_PATH = path2.join(EXE_AI_DIR, "local.lance");
-    CURRENT_CONFIG_VERSION = 1;
-    DEFAULT_CONFIG = {
-      config_version: CURRENT_CONFIG_VERSION,
-      dbPath: DB_PATH,
-      modelFile: "jina-embeddings-v5-small-q4_k_m.gguf",
-      embeddingDim: 1024,
-      batchSize: 20,
-      flushIntervalMs: 1e4,
-      autoIngestion: true,
-      autoRetrieval: true,
-      searchMode: "hybrid",
-      hookSearchMode: "hybrid",
-      fileGrepEnabled: true,
-      splashEffect: true,
-      consolidationEnabled: true,
-      consolidationIntervalMs: 6 * 60 * 60 * 1e3,
-      consolidationModel: "claude-haiku-4-5-20251001",
-      consolidationMaxCallsPerRun: 20,
-      selfQueryRouter: true,
-      selfQueryModel: "claude-haiku-4-5-20251001",
-      rerankerEnabled: true,
-      scalingRoadmap: {
-        rerankerAutoTrigger: {
-          enabled: true,
-          broadQueryMinCardinality: 5e4,
-          fetchTopK: 150,
-          returnTopK: 5
-        }
-      },
-      graphRagEnabled: true,
-      wikiEnabled: false,
-      wikiUrl: "",
-      wikiApiKey: "",
-      wikiSyncIntervalMs: 30 * 60 * 1e3,
-      wikiWorkspaceMapping: {
-        exe: "Executive",
-        yoshi: "Engineering",
-        mari: "Marketing",
-        tom: "Engineering",
-        sasha: "Production"
-      },
-      wikiAutoUpdate: true,
-      wikiAutoUpdateThreshold: 0.5,
-      wikiAutoUpdateCreateNew: true,
-      skillLearning: true,
-      skillThreshold: 3,
-      skillModel: "claude-haiku-4-5-20251001",
-      exeHeartbeat: {
-        enabled: true,
-        intervalSeconds: 60,
-        staleInProgressThresholdHours: 2
-      },
-      sessionLifecycle: {
-        idleKillEnabled: true,
-        idleKillTicksRequired: 3,
-        idleKillIntercomAckWindowMs: 1e4,
-        maxAutoInstances: 10
-      },
-      autoUpdate: {
-        checkOnBoot: true,
-        autoInstall: false,
-        checkIntervalMs: 24 * 60 * 60 * 1e3
-      }
-    };
-    CONFIG_MIGRATIONS = [
-      {
-        from: 0,
-        to: 1,
-        migrate: (cfg) => {
-          cfg.config_version = 1;
-          return cfg;
-        }
-      }
-    ];
-  }
-});
-
-// 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 } = __require("fs");
-  return readdirSync(SHARDS_DIR).filter((f) => f.endsWith(".db")).map((f) => f.replace(".db", ""));
-}
-async function ensureShardSchema(client) {
-  await client.execute("PRAGMA journal_mode = WAL");
-  await client.execute("PRAGMA busy_timeout = 5000");
-  try {
-    await client.execute("PRAGMA libsql_vector_search_ef = 128");
-  } catch {
-  }
-  await client.executeMultiple(`
-    CREATE TABLE IF NOT EXISTS memories (
-      id            TEXT PRIMARY KEY,
-      agent_id      TEXT NOT NULL,
-      agent_role    TEXT NOT NULL,
-      session_id    TEXT NOT NULL,
-      timestamp     TEXT NOT NULL,
-      tool_name     TEXT NOT NULL,
-      project_name  TEXT NOT NULL,
-      has_error     INTEGER NOT NULL DEFAULT 0,
-      raw_text      TEXT NOT NULL,
-      vector        F32_BLOB(1024),
-      version       INTEGER NOT NULL DEFAULT 0
-    );
-
-    CREATE INDEX IF NOT EXISTS idx_memories_agent ON memories(agent_id);
-    CREATE INDEX IF NOT EXISTS idx_memories_timestamp ON memories(timestamp);
-    CREATE INDEX IF NOT EXISTS idx_memories_agent_project ON memories(agent_id, project_name);
-  `);
-  await client.executeMultiple(`
-    CREATE VIRTUAL TABLE IF NOT EXISTS memories_fts USING fts5(
-      raw_text,
-      content='memories',
-      content_rowid='rowid'
-    );
-
-    CREATE TRIGGER IF NOT EXISTS memories_fts_ai AFTER INSERT ON memories BEGIN
-      INSERT INTO memories_fts(rowid, raw_text) VALUES (new.rowid, new.raw_text);
-    END;
-
-    CREATE TRIGGER IF NOT EXISTS memories_fts_ad AFTER DELETE ON memories BEGIN
-      INSERT INTO memories_fts(memories_fts, rowid, raw_text) VALUES('delete', old.rowid, old.raw_text);
-    END;
-
-    CREATE TRIGGER IF NOT EXISTS memories_fts_au AFTER UPDATE ON memories BEGIN
-      INSERT INTO memories_fts(memories_fts, rowid, raw_text) VALUES('delete', old.rowid, old.raw_text);
-      INSERT INTO memories_fts(rowid, raw_text) VALUES (new.rowid, new.raw_text);
-    END;
-  `);
-  for (const col of [
-    "ALTER TABLE memories ADD COLUMN task_id TEXT",
-    "ALTER TABLE memories ADD COLUMN consolidated INTEGER NOT NULL DEFAULT 0",
-    "ALTER TABLE memories ADD COLUMN 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("CREATE INDEX IF NOT EXISTS idx_memories_status ON memories(status)");
-  } catch {
-  }
-  for (const idx of [
-    "CREATE INDEX IF NOT EXISTS idx_memories_workspace ON memories(workspace_id)",
-    "CREATE INDEX IF NOT EXISTS idx_memories_document ON memories(document_id)",
-    "CREATE INDEX IF NOT EXISTS idx_memories_user ON memories(user_id)"
-  ]) {
-    try {
-      await client.execute(idx);
-    } catch {
-    }
-  }
-  await client.executeMultiple(`
-    CREATE TABLE IF NOT EXISTS entities (
-      id TEXT PRIMARY KEY,
-      name TEXT NOT NULL,
-      type TEXT NOT NULL,
-      first_seen TEXT NOT NULL,
-      last_seen TEXT NOT NULL,
-      properties TEXT DEFAULT '{}',
-      UNIQUE(name, type)
-    );
-
-    CREATE TABLE IF NOT EXISTS relationships (
-      id TEXT PRIMARY KEY,
-      source_entity_id TEXT NOT NULL,
-      target_entity_id TEXT NOT NULL,
-      type TEXT NOT NULL,
-      weight REAL DEFAULT 1.0,
-      timestamp TEXT NOT NULL,
-      properties TEXT DEFAULT '{}',
-      UNIQUE(source_entity_id, target_entity_id, type)
-    );
-
-    CREATE TABLE IF NOT EXISTS entity_memories (
-      entity_id TEXT NOT NULL,
-      memory_id TEXT NOT NULL,
-      PRIMARY KEY (entity_id, memory_id)
-    );
-
-    CREATE TABLE IF NOT EXISTS relationship_memories (
-      relationship_id TEXT NOT NULL,
-      memory_id TEXT NOT NULL,
-      PRIMARY KEY (relationship_id, memory_id)
-    );
-
-    CREATE INDEX IF NOT EXISTS idx_entities_name ON entities(name);
-    CREATE INDEX IF NOT EXISTS idx_entities_type ON entities(type);
-    CREATE INDEX IF NOT EXISTS idx_relationships_source ON relationships(source_entity_id);
-    CREATE INDEX IF NOT EXISTS idx_relationships_target ON relationships(target_entity_id);
-    CREATE INDEX IF NOT EXISTS idx_relationships_type ON relationships(type);
-
-    CREATE TABLE IF NOT EXISTS hyperedges (
-      id TEXT PRIMARY KEY,
-      label TEXT NOT NULL,
-      relation TEXT NOT NULL,
-      confidence REAL DEFAULT 1.0,
-      timestamp TEXT NOT NULL
-    );
-
-    CREATE TABLE IF NOT EXISTS hyperedge_nodes (
-      hyperedge_id TEXT NOT NULL,
-      entity_id TEXT NOT NULL,
-      PRIMARY KEY (hyperedge_id, entity_id)
-    );
-  `);
-  for (const col of [
-    "ALTER TABLE relationships ADD COLUMN confidence REAL DEFAULT 1.0",
-    "ALTER TABLE relationships ADD COLUMN confidence_label TEXT DEFAULT 'extracted'"
-  ]) {
-    try {
-      await client.execute(col);
-    } catch {
-    }
-  }
-}
-async function 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 {
-    const { initShardManager: initShardManager2 } = await Promise.resolve().then(() => (init_shard_manager(), shard_manager_exports));
-    initShardManager2(hexKey);
-  } catch {
-  }
-  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}`
-    );
-  }
-  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;
-  }
-});
-
-// src/lib/tasks-crud.ts
-var tasks_crud_exports = {};
-__export(tasks_crud_exports, {
-  TASK_ALREADY_CLAIMED_PREFIX: () => TASK_ALREADY_CLAIMED_PREFIX,
-  checkStaleCompletion: () => checkStaleCompletion,
-  createTaskCore: () => createTaskCore,
-  deleteTaskCore: () => deleteTaskCore,
-  ensureArchitectureDoc: () => ensureArchitectureDoc,
-  ensureGitignoreExe: () => ensureGitignoreExe,
-  extractParentFromContext: () => extractParentFromContext,
-  listTasks: () => listTasks,
-  resolveTask: () => resolveTask,
-  slugify: () => slugify,
-  updateTaskStatus: () => updateTaskStatus,
-  writeCheckpoint: () => writeCheckpoint
-});
-import crypto2 from "crypto";
-import path4 from "path";
-import { execSync as execSync2 } from "child_process";
-import { mkdir as mkdir3, writeFile as writeFile3, appendFile } from "fs/promises";
-import { existsSync as existsSync4, readFileSync as readFileSync2 } from "fs";
-async function writeCheckpoint(input) {
-  const client = getClient();
-  const row = await resolveTask(client, input.taskId);
-  const taskId = String(row.id);
-  const now = (/* @__PURE__ */ new Date()).toISOString();
-  const blockedByIds = [];
-  if (row.blocked_by) {
-    blockedByIds.push(String(row.blocked_by));
-  }
-  const checkpoint = {
-    step: input.step,
-    context_summary: input.contextSummary,
-    files_touched: input.filesTouched ?? [],
-    blocked_by_ids: blockedByIds,
-    last_checkpoint_at: now
-  };
-  const result = await client.execute({
-    sql: `UPDATE tasks SET checkpoint = ?, checkpoint_count = checkpoint_count + 1, updated_at = ? WHERE id = ?`,
-    args: [JSON.stringify(checkpoint), now, taskId]
-  });
-  if (result.rowsAffected === 0) {
-    throw new Error(`Checkpoint write failed: task ${taskId} not found`);
-  }
-  const countResult = await client.execute({
-    sql: "SELECT checkpoint_count FROM tasks WHERE id = ?",
-    args: [taskId]
-  });
-  const checkpointCount = Number(countResult.rows[0]?.checkpoint_count ?? 1);
-  return { checkpointCount };
-}
-function extractParentFromContext(contextBody) {
-  if (!contextBody) return null;
-  const match = contextBody.match(
-    /Parent task:\s*([0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})/i
-  );
-  return match ? match[1].toLowerCase() : null;
-}
-function slugify(title) {
-  return title.toLowerCase().replace(/[^a-z0-9-]/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "");
-}
-async function resolveTask(client, identifier) {
-  let result = await client.execute({
-    sql: "SELECT * FROM tasks WHERE id = ?",
-    args: [identifier]
-  });
-  if (result.rows.length === 1) return result.rows[0];
-  result = await client.execute({
-    sql: "SELECT * FROM tasks WHERE task_file LIKE ?",
-    args: [`%${identifier}%`]
-  });
-  if (result.rows.length === 1) return result.rows[0];
-  if (result.rows.length > 1) {
-    const exact = result.rows.filter(
-      (r) => String(r.task_file).endsWith(`/${identifier}.md`)
-    );
-    if (exact.length === 1) return exact[0];
-    const candidates = exact.length > 1 ? exact : result.rows;
-    const active = candidates.filter(
-      (r) => !["done", "cancelled"].includes(String(r.status))
-    );
-    if (active.length === 1) return active[0];
-    const matches = (active.length > 1 ? active : candidates).map((r) => `${String(r.task_file)} (${String(r.status)}, ${String(r.id)})`).join(", ");
-    throw new Error(
-      `Multiple tasks match "${identifier}": ${matches}. Use a UUID to disambiguate.`
-    );
-  }
-  result = await client.execute({
-    sql: "SELECT * FROM tasks WHERE title LIKE ?",
-    args: [`%${identifier}%`]
-  });
-  if (result.rows.length === 1) return result.rows[0];
-  if (result.rows.length > 1) {
-    const active = result.rows.filter(
-      (r) => !["done", "cancelled"].includes(String(r.status))
-    );
-    if (active.length === 1) return active[0];
-    const matches = (active.length > 1 ? active : result.rows).map((r) => `"${String(r.title)}" (${String(r.status)}, ${String(r.id)})`).join(", ");
-    throw new Error(
-      `Multiple tasks match "${identifier}": ${matches}. Use a UUID to disambiguate.`
-    );
-  }
-  throw new Error(`Task not found: ${identifier}`);
-}
-async function createTaskCore(input) {
-  const client = getClient();
-  const id = crypto2.randomUUID();
-  const now = (/* @__PURE__ */ new Date()).toISOString();
-  const slug = slugify(input.title);
-  const taskFile = input.taskFile ?? `exe/${input.assignedTo}/${slug}.md`;
-  let blockedById = null;
-  const initialStatus = input.blockedBy ? "blocked" : "open";
-  if (input.blockedBy) {
-    const blocker = await resolveTask(client, input.blockedBy);
-    blockedById = String(blocker.id);
-  }
-  let parentTaskId = null;
-  let parentRef = input.parentTaskId;
-  if (!parentRef) {
-    const extracted = extractParentFromContext(input.context);
-    if (extracted) {
-      parentRef = extracted;
-      process.stderr.write(
-        "[create_task] auto-populated parent_task_id from context body \u2014 dispatchers should pass parent_task_id explicitly\n"
-      );
-    }
-  }
-  if (parentRef) {
-    try {
-      const parent = await resolveTask(client, parentRef);
-      parentTaskId = String(parent.id);
-    } catch (err) {
-      if (!input.parentTaskId) {
-        throw new Error(
-          `create_task: parent reference "${parentRef}" in context body does not resolve to an existing task`
-        );
-      }
-      throw err;
-    }
-  }
-  let warning;
-  const dupCheck = await client.execute({
-    sql: "SELECT id FROM tasks WHERE title = ? AND assigned_to = ? AND status IN ('open', 'in_progress', 'blocked')",
-    args: [input.title, input.assignedTo]
-  });
-  if (dupCheck.rows.length > 0) {
-    warning = `similar active task already exists (${String(dupCheck.rows[0].id)}). Created new task anyway.`;
-  }
-  if (input.baseDir) {
-    try {
-      await mkdir3(path4.join(input.baseDir, "exe", "output"), { recursive: true });
-      await mkdir3(path4.join(input.baseDir, "exe", "research"), { recursive: true });
-      await ensureArchitectureDoc(input.baseDir, input.projectName);
-      await ensureGitignoreExe(input.baseDir);
-    } catch {
-    }
-  }
-  const complexity = input.complexity ?? "standard";
-  await client.execute({
-    sql: `INSERT INTO tasks (id, title, assigned_to, assigned_by, project_name, priority, status, task_file, blocked_by, parent_task_id, reviewer, context, complexity, budget_tokens, budget_fallback_model, tokens_used, tokens_warned_at, created_at, updated_at)
-          VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
-    args: [
-      id,
-      input.title,
-      input.assignedTo,
-      input.assignedBy,
-      input.projectName,
-      input.priority,
-      initialStatus,
-      taskFile,
-      blockedById,
-      parentTaskId,
-      input.reviewer ?? null,
-      input.context,
-      input.budgetTokens ?? null,
-      input.budgetFallbackModel ?? null,
-      0,
-      null,
-      complexity,
-      now,
-      now
-    ]
-  });
-  return {
-    id,
-    title: input.title,
-    assignedTo: input.assignedTo,
-    assignedBy: input.assignedBy,
-    projectName: input.projectName,
-    priority: input.priority,
-    status: initialStatus,
-    taskFile,
-    createdAt: now,
-    updatedAt: now,
-    warning,
-    budgetTokens: input.budgetTokens ?? null,
-    budgetFallbackModel: input.budgetFallbackModel ?? null,
-    tokensUsed: 0,
-    tokensWarnedAt: null
-  };
-}
-async function listTasks(input) {
-  const client = getClient();
-  const conditions = [];
-  const args = [];
-  if (input.assignedTo) {
-    conditions.push("assigned_to = ?");
-    args.push(input.assignedTo);
-  }
-  if (input.status) {
-    conditions.push("status = ?");
-    args.push(input.status);
-  } else {
-    conditions.push("status IN ('open', 'in_progress', 'blocked')");
-  }
-  if (input.projectName) {
-    conditions.push("project_name = ?");
-    args.push(input.projectName);
-  }
-  if (input.priority) {
-    conditions.push("priority = ?");
-    args.push(input.priority);
-  }
-  const where = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
-  const result = await client.execute({
-    sql: `SELECT * FROM tasks ${where} ORDER BY CASE status WHEN 'blocked' THEN 0 WHEN 'in_progress' THEN 1 WHEN 'open' THEN 2 ELSE 3 END, priority ASC, created_at DESC`,
-    args
-  });
-  return result.rows.map((r) => ({
-    id: String(r.id),
-    title: String(r.title),
-    assignedTo: String(r.assigned_to),
-    assignedBy: String(r.assigned_by),
-    projectName: String(r.project_name),
-    priority: String(r.priority),
-    status: String(r.status),
-    taskFile: String(r.task_file),
-    createdAt: String(r.created_at),
-    updatedAt: String(r.updated_at),
-    checkpointCount: Number(r.checkpoint_count ?? 0),
-    budgetTokens: r.budget_tokens !== null ? Number(r.budget_tokens) : null,
-    budgetFallbackModel: r.budget_fallback_model !== null ? String(r.budget_fallback_model) : null,
-    tokensUsed: Number(r.tokens_used ?? 0),
-    tokensWarnedAt: r.tokens_warned_at !== null ? Number(r.tokens_warned_at) : null
-  }));
-}
-function checkStaleCompletion(taskContext, taskCreatedAt) {
-  if (!taskContext) return null;
-  if (!DELEGATION_KEYWORDS.test(taskContext)) return null;
-  try {
-    const since = new Date(taskCreatedAt).toISOString();
-    const branch = execSync2(
-      "git rev-parse --abbrev-ref HEAD 2>/dev/null",
-      { encoding: "utf8", timeout: 3e3 }
-    ).trim();
-    const branchArg = branch && branch !== "HEAD" ? branch : "";
-    const commitCount = execSync2(
-      `git log --oneline --since="${since}" ${branchArg} 2>/dev/null | wc -l`,
-      { encoding: "utf8", timeout: 5e3 }
-    ).trim();
-    const count = parseInt(commitCount, 10);
-    if (count === 0) {
-      return "WARNING: task closed with no new commits since creation. Verify work was actually produced.";
-    }
-    return null;
-  } catch {
-    return null;
-  }
-}
-async function updateTaskStatus(input) {
-  const client = getClient();
-  const now = (/* @__PURE__ */ new Date()).toISOString();
-  const row = await resolveTask(client, input.taskId);
-  const taskId = String(row.id);
-  const taskFile = String(row.task_file);
-  if (input.status === "done" && String(row.assigned_by) === "system" && taskFile.includes("review-")) {
-    process.stderr.write(
-      `[updateTask] Review task "${String(row.title)}" being marked done (assigned to ${String(row.assigned_to)})
-`
-    );
-  }
-  if (input.status === "done") {
-    const existingRow = await client.execute({
-      sql: "SELECT context, created_at FROM tasks WHERE id = ?",
-      args: [taskId]
-    });
-    if (existingRow.rows.length > 0) {
-      const ctx = existingRow.rows[0];
-      const warning = checkStaleCompletion(ctx.context, ctx.created_at);
-      if (warning) {
-        input.result = input.result ? `\u26A0\uFE0F ${warning}
-
-${input.result}` : `\u26A0\uFE0F ${warning}`;
-        process.stderr.write(`[tasks] ${warning} (task: ${taskId})
-`);
-      }
-    }
-  }
-  if (input.status === "in_progress") {
-    const tmuxSession = process.env.TMUX_PANE ?? process.env.MY_TMUX_SESSION ?? "unknown";
-    const claim = await client.execute({
-      sql: `UPDATE tasks
-            SET status = 'in_progress', assigned_tmux = ?, updated_at = ?
-            WHERE id = ? AND status = 'open'`,
-      args: [tmuxSession, now, taskId]
-    });
-    if (claim.rowsAffected === 0) {
-      const current = await client.execute({
-        sql: "SELECT status, assigned_tmux FROM tasks WHERE id = ?",
-        args: [taskId]
-      });
-      const cur = current.rows[0];
-      const status = cur?.status ?? "unknown";
-      const claimedBy = cur?.assigned_tmux ? ` (claimed by ${cur.assigned_tmux})` : "";
-      throw new Error(`${TASK_ALREADY_CLAIMED_PREFIX}: task ${taskId} is ${status}${claimedBy}`);
-    }
-    try {
-      await writeCheckpoint({
-        taskId,
-        step: "claimed",
-        contextSummary: `Task claimed by session. Transitioning open \u2192 in_progress.`
-      });
-    } catch {
-    }
-    return { row, taskFile, now, taskId };
-  }
-  if (input.result) {
-    await client.execute({
-      sql: "UPDATE tasks SET status = ?, result = ?, updated_at = ? WHERE id = ?",
-      args: [input.status, input.result, now, taskId]
-    });
-  } else {
-    await client.execute({
-      sql: "UPDATE tasks SET status = ?, updated_at = ? WHERE id = ?",
-      args: [input.status, now, taskId]
-    });
-  }
-  try {
-    await writeCheckpoint({
-      taskId,
-      step: `status_transition:${input.status}`,
-      contextSummary: input.result ? `Transitioned to ${input.status}. Result: ${input.result.slice(0, 500)}` : `Transitioned to ${input.status}.`
-    });
-  } catch {
-  }
-  return { row, taskFile, now, taskId };
-}
-async function deleteTaskCore(taskId, _baseDir) {
-  const client = getClient();
-  const row = await resolveTask(client, taskId);
-  const id = String(row.id);
-  const taskFile = String(row.task_file);
-  const assignedTo = String(row.assigned_to);
-  const assignedBy = String(row.assigned_by);
-  await client.execute({ sql: "DELETE FROM tasks WHERE id = ?", args: [id] });
-  const taskSlug = taskFile.split("/").pop()?.replace(".md", "") ?? "";
-  return { taskFile, assignedTo, assignedBy, taskSlug };
-}
-async function ensureArchitectureDoc(baseDir, projectName) {
-  const archPath = path4.join(baseDir, "exe", "ARCHITECTURE.md");
-  try {
-    if (existsSync4(archPath)) return;
-    const template = [
-      `# ${projectName} \u2014 System Architecture`,
-      "",
-      "> Employees: read this before every task. Update it when you change system structure.",
-      `> Last updated: ${(/* @__PURE__ */ new Date()).toISOString().split("T")[0]}`,
-      "",
-      "## Overview",
-      "",
-      "<!-- Describe what this system does, its main components, and how they connect. -->",
-      "",
-      "## Key Components",
-      "",
-      "<!-- List the major modules, services, or subsystems. -->",
-      "",
-      "## Data Flow",
-      "",
-      "<!-- How does data move through the system? What writes where? -->",
-      "",
-      "## Invariants",
-      "",
-      "<!-- Rules that must never be violated. What breaks if these are wrong? -->",
-      "",
-      "## Dependencies",
-      "",
-      "<!-- What depends on what? If I change X, what else is affected? -->",
-      ""
-    ].join("\n");
-    await writeFile3(archPath, template, "utf-8");
-  } catch {
-  }
-}
-async function ensureGitignoreExe(baseDir) {
-  const gitignorePath = path4.join(baseDir, ".gitignore");
-  try {
-    if (existsSync4(gitignorePath)) {
-      const content = readFileSync2(gitignorePath, "utf-8");
-      if (/^\/?exe\/?$/m.test(content)) return;
-      await appendFile(gitignorePath, "\n# Employee task assignments (private)\n/exe/\n");
-    } else {
-      await writeFile3(gitignorePath, "# Employee task assignments (private)\n/exe/\n", "utf-8");
-    }
-  } catch {
-  }
-}
-var DELEGATION_KEYWORDS, TASK_ALREADY_CLAIMED_PREFIX;
-var init_tasks_crud = __esm({
-  "src/lib/tasks-crud.ts"() {
-    "use strict";
-    init_database();
-    DELEGATION_KEYWORDS = /parallel|delegate|wave|tom\d*-exe/i;
-    TASK_ALREADY_CLAIMED_PREFIX = "TASK_ALREADY_CLAIMED";
-  }
-});
-
-// src/adapters/claude/hooks/commit-complete.ts
-import { execSync as execSync3 } from "child_process";
-
-// src/lib/git-task-sweep.ts
-import { execSync } from "child_process";
-var EXACT_UUID_SCORE = 1;
-var TITLE_KEYWORD_SCORE = 0.5;
-var FILE_PATH_SCORE = 0.3;
-var MIN_KEYWORD_OVERLAP = 3;
-var STOP_WORDS = /* @__PURE__ */ new Set([
-  "a",
-  "an",
-  "the",
-  "and",
-  "or",
-  "but",
-  "in",
-  "on",
-  "at",
-  "to",
-  "for",
-  "of",
-  "with",
-  "by",
-  "from",
-  "is",
-  "it",
-  "as",
-  "be",
-  "was",
-  "are",
-  "this",
-  "that",
-  "not",
-  "no",
-  "if",
-  "so",
-  "do",
-  "up"
-]);
-function extractKeywords(text) {
-  return text.toLowerCase().replace(/[^a-z0-9\s-]/g, " ").split(/\s+/).filter((w) => w.length >= 3 && !STOP_WORDS.has(w));
-}
-function matchScore(task, commitMessage, changedFiles) {
-  if (task.id.length >= 8 && commitMessage.includes(task.id)) {
-    return EXACT_UUID_SCORE;
-  }
-  let score = 0;
-  const titleWords = extractKeywords(task.title);
-  const commitWords = new Set(extractKeywords(commitMessage));
-  const overlap = titleWords.filter((w) => commitWords.has(w));
-  if (overlap.length >= MIN_KEYWORD_OVERLAP) {
-    score += TITLE_KEYWORD_SCORE;
-  }
-  if (task.context && changedFiles.length > 0) {
-    const contextLower = task.context.toLowerCase();
-    const hasFileMatch = changedFiles.some(
-      (f) => contextLower.includes(f.toLowerCase())
-    );
-    if (hasFileMatch) {
-      score += FILE_PATH_SCORE;
-    }
-  }
-  return score;
-}
-
-// src/adapters/claude/hooks/commit-complete.ts
-var AUTO_CLOSE_THRESHOLD = 0.6;
-function parseGitCommitOutput(output) {
-  const match = output.match(/\[(\S+)\s+([a-f0-9]{7,40})\]\s+(.+)/);
-  if (!match) return null;
-  return {
-    hash: match[2],
-    message: match[3].trim()
-  };
-}
-function getChangedFiles(hash) {
-  try {
-    const output = execSync3(
-      `git diff-tree --no-commit-id --name-only -r ${hash}`,
-      { encoding: "utf8", timeout: 5e3 }
-    );
-    return output.trim().split("\n").filter(Boolean);
-  } catch {
-    return [];
-  }
-}
-async function main() {
-  const commitHash = process.env.COMMIT_HASH;
-  const commitMessage = process.env.COMMIT_MESSAGE;
-  const agentId = process.env.AGENT_ID;
-  const projectName = process.env.PROJECT_NAME;
-  if (!commitHash || !commitMessage || !agentId) {
-    process.stderr.write("[commit-complete] Missing required env vars\n");
-    return;
-  }
-  const changedFiles = getChangedFiles(commitHash);
-  try {
-    const { initStore: initStore2 } = await Promise.resolve().then(() => (init_store(), store_exports));
-    await initStore2();
-  } catch {
-    process.stderr.write("[commit-complete] DB init failed \u2014 skipping\n");
-    return;
-  }
-  const { listTasks: listTasks2, updateTaskStatus: updateTaskStatus2 } = await Promise.resolve().then(() => (init_tasks_crud(), tasks_crud_exports));
-  const tasks = await listTasks2({
-    assignedTo: agentId,
-    status: "in_progress",
-    ...projectName ? { projectName } : {}
-  });
-  if (tasks.length === 0) return;
-  const { getClient: getClient2 } = await Promise.resolve().then(() => (init_database(), database_exports));
-  const client = getClient2();
-  const tasksWithContext = [];
-  for (const t of tasks) {
-    let context;
-    try {
-      const result = await client.execute({
-        sql: "SELECT context FROM tasks WHERE id = ?",
-        args: [t.id]
-      });
-      context = result.rows[0]?.context ? String(result.rows[0].context) : void 0;
-    } catch {
-    }
-    tasksWithContext.push({
-      id: t.id,
-      title: t.title,
-      assignedTo: t.assignedTo,
-      projectName: t.projectName,
-      status: t.status,
-      context
-    });
-  }
-  for (const task of tasksWithContext) {
-    const score = matchScore(task, commitMessage, changedFiles);
-    if (score >= AUTO_CLOSE_THRESHOLD) {
-      try {
-        await updateTaskStatus2({
-          taskId: task.id,
-          status: "done",
-          result: `Auto-completed via commit ${commitHash}: ${commitMessage}`
-        });
-        process.stderr.write(
-          `[commit-complete] Task ${task.id} auto-closed by commit ${commitHash} (score: ${score.toFixed(2)})
-`
-        );
-      } catch (err) {
-        process.stderr.write(
-          `[commit-complete] Failed to close task ${task.id}: ${err instanceof Error ? err.message : String(err)}
-`
-        );
-      }
-    }
-  }
-}
-main().catch((err) => {
-  process.stderr.write(
-    `[commit-complete] Worker error: ${err instanceof Error ? err.message : String(err)}
-`
-  );
-});
-export {
-  extractKeywords,
-  matchScore,
-  parseGitCommitOutput
-};