@askexenow/exe-os 0.8.0

package/dist/bin/git-sweep.js

@@ -0,0 +1,2185 @@
+#!/usr/bin/env node
+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 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 {
+    }
+  }
+  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);
+  `);
+  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;
+  `);
+}
+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 };
+}
+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);
+    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
+      }
+    };
+    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(projectName2) {
+  if (!_encryptionKey) {
+    throw new Error("Shard manager not initialized. Call initShardManager() first.");
+  }
+  const safeName = projectName2.replace(/[^a-zA-Z0-9_-]/g, "_");
+  if (!safeName) {
+    throw new Error(`Invalid project name for shard: "${projectName2}"`);
+  }
+  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(projectName2) {
+  const safeName = projectName2.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"
+  ]) {
+    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 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(projectName2) {
+  const client = getShardClient(projectName2);
+  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,
+  disposeStore: () => disposeStore,
+  flushBatch: () => flushBatch,
+  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;
+}
+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
+  };
+  _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;
+      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)
+              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)
+              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
+        ] : [
+          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
+        ]
+      };
+    };
+    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 args2 = [];
+  let clause = "";
+  if (options?.workspaceId !== void 0) {
+    clause += ` AND ${columnPrefix}workspace_id = ?`;
+    args2.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)`;
+    args2.push(options.userId);
+  }
+  return { clause, args: args2 };
+}
+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
+             FROM memories
+             WHERE agent_id = ?
+               AND vector IS NOT NULL${statusFilter}
+               AND COALESCE(confidence, 0.7) >= 0.3`;
+  const args2 = [agentId];
+  const scope = buildWikiScopeFilter(options, "");
+  sql += scope.clause;
+  args2.push(...scope.args);
+  if (options?.projectName) {
+    sql += ` AND project_name = ?`;
+    args2.push(options.projectName);
+  }
+  if (options?.toolName) {
+    sql += ` AND tool_name = ?`;
+    args2.push(options.toolName);
+  }
+  if (options?.hasError !== void 0) {
+    sql += ` AND has_error = ?`;
+    args2.push(options.hasError ? 1 : 0);
+  }
+  if (options?.since) {
+    sql += ` AND timestamp >= ?`;
+    args2.push(options.since);
+  }
+  sql += ` ORDER BY vector_distance_cos(vector, vector32(?))`;
+  args2.push(vectorToBlob(queryVector));
+  sql += ` LIMIT ?`;
+  args2.push(limit);
+  const result = await client.execute({ sql, args: args2 });
+  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
+  }));
+}
+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 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;
+}
+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
+});
+import crypto2 from "crypto";
+import path4 from "path";
+import { execSync } from "child_process";
+import { mkdir as mkdir3, writeFile as writeFile3, appendFile } from "fs/promises";
+import { existsSync as existsSync4, readFileSync as readFileSync2 } from "fs";
+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 {
+    }
+  }
+  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, 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,
+      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
+  };
+}
+async function listTasks(input) {
+  const client = getClient();
+  const conditions = [];
+  const args2 = [];
+  if (input.assignedTo) {
+    conditions.push("assigned_to = ?");
+    args2.push(input.assignedTo);
+  }
+  if (input.status) {
+    conditions.push("status = ?");
+    args2.push(input.status);
+  } else {
+    conditions.push("status IN ('open', 'in_progress', 'blocked')");
+  }
+  if (input.projectName) {
+    conditions.push("project_name = ?");
+    args2.push(input.projectName);
+  }
+  if (input.priority) {
+    conditions.push("priority = ?");
+    args2.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: args2
+  });
+  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)
+  }));
+}
+function checkStaleCompletion(taskContext, taskCreatedAt) {
+  if (!taskContext) return null;
+  if (!DELEGATION_KEYWORDS.test(taskContext)) return null;
+  try {
+    const since = new Date(taskCreatedAt).toISOString();
+    const commitCount = execSync(
+      `git log --oneline --since="${since}" 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}`);
+    }
+    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]
+    });
+  }
+  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, projectName2) {
+  const archPath = path4.join(baseDir, "exe", "ARCHITECTURE.md");
+  try {
+    if (existsSync4(archPath)) return;
+    const template = [
+      `# ${projectName2} \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/lib/git-task-sweep.ts
+import { execSync as execSync2 } from "child_process";
+var DEFAULT_COMMIT_LIMIT = 50;
+var DEFAULT_STALE_MINUTES = 10;
+var AUTO_ESCALATE_THRESHOLD = 0.6;
+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;
+}
+function getRecentCommits(limit = DEFAULT_COMMIT_LIMIT) {
+  try {
+    const SEPARATOR = "<<SEP>>";
+    const output = execSync2(
+      `git log --format="%h${SEPARATOR}%s${SEPARATOR}%aI" --name-only -n ${limit} -z`,
+      { encoding: "utf8", timeout: 1e4 }
+    );
+    const entries = output.split("\0").filter(Boolean);
+    const commits = [];
+    let current = null;
+    for (const entry of entries) {
+      if (entry.includes(SEPARATOR)) {
+        const lines = entry.split("\n");
+        const headerLine = lines[0];
+        const parts = headerLine.split(SEPARATOR);
+        if (parts.length >= 3) {
+          if (current) commits.push(current);
+          current = {
+            hash: parts[0],
+            message: parts[1],
+            files: lines.slice(1).filter(Boolean),
+            date: new Date(parts[2])
+          };
+        }
+      } else if (current) {
+        const files = entry.split("\n").filter(Boolean);
+        current.files.push(...files);
+      }
+    }
+    if (current) commits.push(current);
+    return commits;
+  } catch {
+    return [];
+  }
+}
+function isStale(updatedAt, staleMinutes2) {
+  const updated = new Date(updatedAt).getTime();
+  const threshold = Date.now() - staleMinutes2 * 6e4;
+  return updated < threshold;
+}
+function findBestMatch(task, commits) {
+  let best = null;
+  for (const commit of commits) {
+    const score = matchScore(task, commit.message, commit.files);
+    if (score >= AUTO_ESCALATE_THRESHOLD && (!best || score > best.score)) {
+      best = { commit, score };
+    }
+  }
+  return best;
+}
+async function sweepTasks(projectName2, options = {}) {
+  const commitLimit2 = options.commitLimit ?? DEFAULT_COMMIT_LIMIT;
+  const staleMinutes2 = options.staleMinutes ?? DEFAULT_STALE_MINUTES;
+  const dryRun2 = options.dryRun ?? false;
+  const result = { escalated: [], unchanged: 0, errors: [] };
+  const commits = getRecentCommits(commitLimit2);
+  if (commits.length === 0) {
+    result.errors.push("No git commits found (not a git repo or empty history)");
+    return result;
+  }
+  let tasks;
+  try {
+    const { initStore: initStore2 } = await Promise.resolve().then(() => (init_store(), store_exports));
+    await initStore2();
+    const { getClient: getClient2 } = await Promise.resolve().then(() => (init_database(), database_exports));
+    const client = getClient2();
+    const conditions = ["status = 'in_progress'"];
+    const args2 = [];
+    if (projectName2) {
+      conditions.push("project_name = ?");
+      args2.push(projectName2);
+    }
+    const queryResult = await client.execute({
+      sql: `SELECT id, title, assigned_to, project_name, status, updated_at, context
+            FROM tasks WHERE ${conditions.join(" AND ")}
+            ORDER BY updated_at ASC`,
+      args: args2
+    });
+    tasks = queryResult.rows.map((r) => ({
+      id: String(r.id),
+      title: String(r.title),
+      assignedTo: String(r.assigned_to),
+      projectName: String(r.project_name),
+      status: String(r.status),
+      updatedAt: String(r.updated_at),
+      context: r.context ? String(r.context) : void 0
+    }));
+  } catch (err) {
+    result.errors.push(`DB query failed: ${err instanceof Error ? err.message : String(err)}`);
+    return result;
+  }
+  if (tasks.length === 0) {
+    return result;
+  }
+  for (const task of tasks) {
+    if (!isStale(task.updatedAt, staleMinutes2)) {
+      result.unchanged++;
+      continue;
+    }
+    const match = findBestMatch(task, commits);
+    if (!match) {
+      result.unchanged++;
+      continue;
+    }
+    if (!dryRun2) {
+      try {
+        const { updateTaskStatus: updateTaskStatus2 } = await Promise.resolve().then(() => (init_tasks_crud(), tasks_crud_exports));
+        await updateTaskStatus2({
+          taskId: task.id,
+          status: "needs_review",
+          result: `Auto-escalated by git-sweep: matching commit ${match.commit.hash} found (score: ${match.score.toFixed(2)})`
+        });
+      } catch (err) {
+        result.errors.push(
+          `Failed to escalate task ${task.id}: ${err instanceof Error ? err.message : String(err)}`
+        );
+        continue;
+      }
+    }
+    result.escalated.push({
+      taskId: task.id,
+      title: task.title,
+      matchedCommit: match.commit.hash,
+      score: match.score
+    });
+    process.stderr.write(
+      `[git-sweep] ${dryRun2 ? "WOULD escalate" : "Escalated"} task ${task.id} \u2192 commit ${match.commit.hash} (score: ${match.score.toFixed(2)})
+`
+    );
+  }
+  return result;
+}
+
+// src/bin/git-sweep.ts
+import path5 from "path";
+var args = process.argv.slice(2);
+var dryRun = args.includes("--dry-run");
+var projectIdx = args.indexOf("--project");
+var limitIdx = args.indexOf("--limit");
+var staleIdx = args.indexOf("--stale");
+var projectName = projectIdx >= 0 ? args[projectIdx + 1] : process.cwd().split(path5.sep).pop();
+var commitLimit = limitIdx >= 0 ? Number(args[limitIdx + 1]) : void 0;
+var staleMinutes = staleIdx >= 0 ? Number(args[staleIdx + 1]) : void 0;
+async function main() {
+  console.log(`[git-sweep] Scanning ${projectName ?? "all projects"}${dryRun ? " (dry run)" : ""}...`);
+  const result = await sweepTasks(projectName, {
+    commitLimit,
+    staleMinutes,
+    dryRun
+  });
+  if (result.escalated.length > 0) {
+    console.log(`
+${dryRun ? "Would escalate" : "Escalated"} ${result.escalated.length} task(s):
+`);
+    for (const match of result.escalated) {
+      console.log(`  ${match.taskId.slice(0, 8)}  ${match.title.slice(0, 50).padEnd(50)}  \u2192 ${match.matchedCommit}  (${match.score.toFixed(2)})`);
+    }
+  }
+  if (result.unchanged > 0) {
+    console.log(`
+Unchanged: ${result.unchanged} task(s)`);
+  }
+  if (result.errors.length > 0) {
+    console.log(`
+Errors:`);
+    for (const err of result.errors) {
+      console.log(`  ${err}`);
+    }
+  }
+  if (result.escalated.length === 0 && result.errors.length === 0) {
+    console.log("\nAll in_progress tasks are current \u2014 no escalation needed.");
+  }
+}
+main().catch((err) => {
+  console.error(`[git-sweep] Fatal: ${err instanceof Error ? err.message : String(err)}`);
+  process.exit(1);
+});