@askexenow/exe-os 0.8.0 → 0.8.2

package/dist/hooks/ingest-worker.js

@@ -1,4793 +0,0 @@
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-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 });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
-// src/lib/mcp-prefix.ts
-function isExeMcpTool(toolName) {
-  if (!toolName) return false;
-  return MCP_TOOL_PREFIXES.some((p) => toolName.startsWith(p));
-}
-function stripExeMcpPrefix(toolName) {
-  for (const p of MCP_TOOL_PREFIXES) {
-    if (toolName.startsWith(p)) return toolName.slice(p.length);
-  }
-  return toolName;
-}
-function expandDualPrefixTools(shortNames) {
-  const out = [];
-  for (const name of shortNames) {
-    for (const prefix of MCP_TOOL_PREFIXES) {
-      out.push(prefix + name);
-    }
-  }
-  return out;
-}
-var MCP_PRIMARY_KEY, MCP_LEGACY_KEY, MCP_TOOL_PREFIXES;
-var init_mcp_prefix = __esm({
-  "src/lib/mcp-prefix.ts"() {
-    "use strict";
-    MCP_PRIMARY_KEY = "exe-os";
-    MCP_LEGACY_KEY = "exe-mem";
-    MCP_TOOL_PREFIXES = [
-      `mcp__${MCP_PRIMARY_KEY}__`,
-      `mcp__${MCP_LEGACY_KEY}__`
-    ];
-  }
-});
-
-// src/lib/project-name.ts
-import { execSync as execSync2 } from "child_process";
-import path2 from "path";
-function getProjectName(cwd) {
-  const dir = cwd ?? process.cwd();
-  if (_cached && _cachedCwd === dir) return _cached;
-  try {
-    const repoRoot = execSync2("git rev-parse --show-toplevel", {
-      cwd: dir,
-      encoding: "utf8",
-      timeout: 2e3,
-      stdio: ["pipe", "pipe", "pipe"]
-    }).trim();
-    _cached = path2.basename(repoRoot);
-    _cachedCwd = dir;
-    return _cached;
-  } catch {
-    _cached = path2.basename(dir);
-    _cachedCwd = dir;
-    return _cached;
-  }
-}
-var _cached, _cachedCwd;
-var init_project_name = __esm({
-  "src/lib/project-name.ts"() {
-    "use strict";
-    _cached = null;
-    _cachedCwd = null;
-  }
-});
-
-// 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/config.ts
-var config_exports = {};
-__export(config_exports, {
-  CONFIG_MIGRATIONS: () => CONFIG_MIGRATIONS,
-  CONFIG_PATH: () => CONFIG_PATH,
-  CURRENT_CONFIG_VERSION: () => CURRENT_CONFIG_VERSION,
-  DB_PATH: () => DB_PATH,
-  EXE_AI_DIR: () => EXE_AI_DIR,
-  LEGACY_LANCE_PATH: () => LEGACY_LANCE_PATH,
-  MODELS_DIR: () => MODELS_DIR,
-  loadConfig: () => loadConfig,
-  loadConfigFrom: () => loadConfigFrom,
-  loadConfigSync: () => loadConfigSync,
-  migrateConfig: () => migrateConfig,
-  saveConfig: () => saveConfig
-});
-import { readFile as readFile2, writeFile as writeFile2, mkdir as mkdir2 } from "fs/promises";
-import { readFileSync as readFileSync2, existsSync as existsSync3, renameSync } from "fs";
-import path4 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 = path4.join(os.homedir(), ".exe-os");
-  const legacyDir = path4.join(os.homedir(), ".exe-mem");
-  if (!existsSync3(newDir) && existsSync3(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 = path4.join(dir, "config.json");
-  if (!existsSync3(configPath)) {
-    return { ...DEFAULT_CONFIG, dbPath: path4.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: path4.join(dir, "memories.db"), ...migratedCfg };
-    if (config.dbPath.startsWith("~")) {
-      config.dbPath = config.dbPath.replace(/^~/, os.homedir());
-    }
-    return config;
-  } catch {
-    return { ...DEFAULT_CONFIG, dbPath: path4.join(dir, "memories.db") };
-  }
-}
-function loadConfigSync() {
-  const dir = process.env.EXE_OS_DIR ?? process.env.EXE_MEM_DIR ?? EXE_AI_DIR;
-  const configPath = path4.join(dir, "config.json");
-  if (!existsSync3(configPath)) {
-    return { ...DEFAULT_CONFIG, dbPath: path4.join(dir, "memories.db") };
-  }
-  try {
-    const raw = readFileSync2(configPath, "utf-8");
-    let parsed = JSON.parse(raw);
-    parsed = migrateLegacyConfig(parsed);
-    const { config: migratedCfg } = migrateConfig(parsed);
-    normalizeScalingRoadmap(migratedCfg);
-    normalizeSessionLifecycle(migratedCfg);
-    return { ...DEFAULT_CONFIG, dbPath: path4.join(dir, "memories.db"), ...migratedCfg };
-  } catch {
-    return { ...DEFAULT_CONFIG, dbPath: path4.join(dir, "memories.db") };
-  }
-}
-async function saveConfig(config) {
-  const dir = process.env.EXE_OS_DIR ?? process.env.EXE_MEM_DIR ?? EXE_AI_DIR;
-  await mkdir2(dir, { recursive: true });
-  const configPath = path4.join(dir, "config.json");
-  await writeFile2(configPath, JSON.stringify(config, null, 2) + "\n");
-}
-async function loadConfigFrom(configPath) {
-  const raw = await readFile2(configPath, "utf-8");
-  try {
-    let parsed = JSON.parse(raw);
-    parsed = migrateLegacyConfig(parsed);
-    const { config: migratedCfg } = migrateConfig(parsed);
-    normalizeScalingRoadmap(migratedCfg);
-    normalizeSessionLifecycle(migratedCfg);
-    return { ...DEFAULT_CONFIG, ...migratedCfg };
-  } catch {
-    return { ...DEFAULT_CONFIG };
-  }
-}
-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 = path4.join(EXE_AI_DIR, "memories.db");
-    MODELS_DIR = path4.join(EXE_AI_DIR, "models");
-    CONFIG_PATH = path4.join(EXE_AI_DIR, "config.json");
-    LEGACY_LANCE_PATH = path4.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 path5 from "path";
-import { existsSync as existsSync4, mkdirSync } from "fs";
-import { createClient as createClient2 } from "@libsql/client";
-function initShardManager(encryptionKey) {
-  _encryptionKey = encryptionKey;
-  if (!existsSync4(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 = path5.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 existsSync4(path5.join(SHARDS_DIR, `${safeName}.db`));
-}
-function listShards() {
-  if (!existsSync4(SHARDS_DIR)) return [];
-  const { readdirSync: readdirSync4 } = __require("fs");
-  return readdirSync4(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(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 = path5.join(EXE_AI_DIR, "shards");
-    _shards = /* @__PURE__ */ new Map();
-    _encryptionKey = null;
-    _shardingEnabled = false;
-  }
-});
-
-// src/lib/notifications.ts
-import crypto3 from "crypto";
-import path6 from "path";
-import os2 from "os";
-import {
-  readFileSync as readFileSync3,
-  readdirSync as readdirSync2,
-  unlinkSync,
-  existsSync as existsSync5,
-  rmdirSync
-} from "fs";
-async function writeNotification(notification) {
-  try {
-    const client = getClient();
-    const id = crypto3.randomUUID();
-    const now = (/* @__PURE__ */ new Date()).toISOString();
-    await client.execute({
-      sql: `INSERT INTO notifications (id, agent_id, agent_role, event, project, summary, task_file, read, created_at)
-            VALUES (?, ?, ?, ?, ?, ?, ?, 0, ?)`,
-      args: [
-        id,
-        notification.agentId,
-        notification.agentRole,
-        notification.event,
-        notification.project,
-        notification.summary,
-        notification.taskFile ?? null,
-        now
-      ]
-    });
-  } catch (err) {
-    process.stderr.write(`[notifications] WRITE FAILED: ${err instanceof Error ? err.message : String(err)}
-`);
-  }
-}
-async function markAsReadByTaskFile(taskFile) {
-  try {
-    const client = getClient();
-    await client.execute({
-      sql: "UPDATE notifications SET read = 1 WHERE task_file = ? AND read = 0",
-      args: [taskFile]
-    });
-  } catch {
-  }
-}
-var init_notifications = __esm({
-  "src/lib/notifications.ts"() {
-    "use strict";
-    init_database();
-  }
-});
-
-// src/lib/employees.ts
-import { readFile as readFile3, writeFile as writeFile3, mkdir as mkdir3 } from "fs/promises";
-import { existsSync as existsSync6, symlinkSync, readlinkSync } from "fs";
-import { execSync as execSync3 } from "child_process";
-import path7 from "path";
-var EMPLOYEES_PATH;
-var init_employees = __esm({
-  "src/lib/employees.ts"() {
-    "use strict";
-    init_config();
-    EMPLOYEES_PATH = path7.join(EXE_AI_DIR, "exe-employees.json");
-  }
-});
-
-// src/lib/license.ts
-import { readFileSync as readFileSync4, writeFileSync, existsSync as existsSync7, mkdirSync as mkdirSync2 } from "fs";
-import { randomUUID } from "crypto";
-import path8 from "path";
-import { jwtVerify, importSPKI } from "jose";
-function loadDeviceId() {
-  const deviceJsonPath = path8.join(EXE_AI_DIR, "device.json");
-  try {
-    if (existsSync7(deviceJsonPath)) {
-      const data = JSON.parse(readFileSync4(deviceJsonPath, "utf8"));
-      if (data.deviceId) return data.deviceId;
-    }
-  } catch {
-  }
-  try {
-    if (existsSync7(DEVICE_ID_PATH)) {
-      const id2 = readFileSync4(DEVICE_ID_PATH, "utf8").trim();
-      if (id2) return id2;
-    }
-  } catch {
-  }
-  const id = randomUUID();
-  mkdirSync2(EXE_AI_DIR, { recursive: true });
-  writeFileSync(DEVICE_ID_PATH, id, "utf8");
-  return id;
-}
-function loadLicense() {
-  try {
-    if (!existsSync7(LICENSE_PATH)) return null;
-    return readFileSync4(LICENSE_PATH, "utf8").trim();
-  } catch {
-    return null;
-  }
-}
-async function verifyLicenseJwt(token) {
-  try {
-    const key = await importSPKI(LICENSE_PUBLIC_KEY_PEM, LICENSE_JWT_ALG);
-    const { payload } = await jwtVerify(token, key, {
-      algorithms: [LICENSE_JWT_ALG]
-    });
-    const plan = payload.plan ?? "free";
-    const email = payload.sub ?? "";
-    const limits = PLAN_LIMITS[plan] ?? PLAN_LIMITS.free;
-    return {
-      valid: true,
-      plan,
-      email,
-      expiresAt: payload.exp ? new Date(payload.exp * 1e3).toISOString() : null,
-      deviceLimit: limits.devices,
-      employeeLimit: limits.employees,
-      memoryLimit: limits.memories
-    };
-  } catch {
-    return null;
-  }
-}
-async function getCachedLicense() {
-  try {
-    if (!existsSync7(CACHE_PATH)) return null;
-    const raw = JSON.parse(readFileSync4(CACHE_PATH, "utf8"));
-    if (!raw.token || typeof raw.token !== "string") return null;
-    return await verifyLicenseJwt(raw.token);
-  } catch {
-    return null;
-  }
-}
-function cacheResponse(token) {
-  try {
-    writeFileSync(CACHE_PATH, JSON.stringify({ token }), "utf8");
-  } catch {
-  }
-}
-async function validateLicense(apiKey, deviceId) {
-  const did = deviceId ?? loadDeviceId();
-  try {
-    const res = await fetch(`${API_BASE}/auth/activate`, {
-      method: "POST",
-      headers: { "Content-Type": "application/json" },
-      body: JSON.stringify({ apiKey, deviceId: did }),
-      signal: AbortSignal.timeout(1e4)
-    });
-    if (res.ok) {
-      const data = await res.json();
-      if (data.error === "device_limit_exceeded") {
-        const cached2 = await getCachedLicense();
-        if (cached2) return cached2;
-        return { ...FREE_LICENSE, valid: false, plan: "free" };
-      }
-      if (data.token) {
-        cacheResponse(data.token);
-        const verified = await verifyLicenseJwt(data.token);
-        if (verified) return verified;
-      }
-      const limits = PLAN_LIMITS[data.plan] ?? PLAN_LIMITS.free;
-      return {
-        valid: data.valid,
-        plan: data.plan,
-        email: data.email,
-        expiresAt: data.expiresAt,
-        deviceLimit: limits.devices,
-        employeeLimit: limits.employees,
-        memoryLimit: limits.memories
-      };
-    }
-    const cached = await getCachedLicense();
-    if (cached) return cached;
-    return { ...FREE_LICENSE, valid: false, plan: "free" };
-  } catch {
-    const cached = await getCachedLicense();
-    if (cached) return cached;
-    return FREE_LICENSE;
-  }
-}
-async function checkLicense() {
-  const key = loadLicense();
-  if (!key) return FREE_LICENSE;
-  const cached = await getCachedLicense();
-  if (cached) return cached;
-  const deviceId = loadDeviceId();
-  return validateLicense(key, deviceId);
-}
-var LICENSE_PATH, CACHE_PATH, DEVICE_ID_PATH, API_BASE, LICENSE_PUBLIC_KEY_PEM, LICENSE_JWT_ALG, PLAN_LIMITS, FREE_LICENSE;
-var init_license = __esm({
-  "src/lib/license.ts"() {
-    "use strict";
-    init_config();
-    LICENSE_PATH = path8.join(EXE_AI_DIR, "license.key");
-    CACHE_PATH = path8.join(EXE_AI_DIR, "license-cache.json");
-    DEVICE_ID_PATH = path8.join(EXE_AI_DIR, "device-id");
-    API_BASE = "https://askexe.com/cloud";
-    LICENSE_PUBLIC_KEY_PEM = `-----BEGIN PUBLIC KEY-----
-MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEeHztAMOpR/ZMh+rWuOASjEZ54CGY
-4uj+UqeKCcvtgNHKmOK278HJaJcANe9xAeji8AFYu27q3WtzCi04pHudow==
------END PUBLIC KEY-----`;
-    LICENSE_JWT_ALG = "ES256";
-    PLAN_LIMITS = {
-      free: { devices: 1, employees: 1, memories: 5e3 },
-      pro: { devices: 2, employees: 5, memories: 1e5 },
-      team: { devices: 10, employees: 20, memories: 1e6 },
-      agency: { devices: 50, employees: 100, memories: 1e7 },
-      enterprise: { devices: -1, employees: -1, memories: -1 }
-    };
-    FREE_LICENSE = {
-      valid: true,
-      plan: "free",
-      email: "",
-      expiresAt: null,
-      deviceLimit: 1,
-      employeeLimit: 1,
-      memoryLimit: 5e3
-    };
-  }
-});
-
-// src/lib/plan-limits.ts
-import { readFileSync as readFileSync5, existsSync as existsSync8 } from "fs";
-import path9 from "path";
-function getLicenseSync() {
-  try {
-    if (!existsSync8(CACHE_PATH2)) return freeLicense();
-    const raw = JSON.parse(readFileSync5(CACHE_PATH2, "utf8"));
-    if (!raw.token || typeof raw.token !== "string") return freeLicense();
-    const parts = raw.token.split(".");
-    if (parts.length !== 3) return freeLicense();
-    const payload = JSON.parse(Buffer.from(parts[1], "base64url").toString());
-    const plan = payload.plan ?? "free";
-    const limits = PLAN_LIMITS[plan] ?? PLAN_LIMITS.free;
-    return {
-      valid: true,
-      plan,
-      email: payload.sub ?? "",
-      expiresAt: payload.exp ? new Date(payload.exp * 1e3).toISOString() : null,
-      deviceLimit: limits.devices,
-      employeeLimit: limits.employees,
-      memoryLimit: limits.memories
-    };
-  } catch {
-    return freeLicense();
-  }
-}
-function freeLicense() {
-  const limits = PLAN_LIMITS.free;
-  return {
-    valid: true,
-    plan: "free",
-    email: "",
-    expiresAt: null,
-    deviceLimit: limits.devices,
-    employeeLimit: limits.employees,
-    memoryLimit: limits.memories
-  };
-}
-async function countActiveMemories() {
-  if (!isInitialized()) return 0;
-  const client = getClient();
-  const result = await client.execute(
-    "SELECT COUNT(*) as cnt FROM memories WHERE status = 'active' OR status IS NULL"
-  );
-  const row = result.rows[0];
-  return Number(row?.cnt ?? 0);
-}
-async function assertMemoryLimit() {
-  const license = await checkLicense();
-  if (license.memoryLimit < 0) return;
-  const count = await countActiveMemories();
-  if (count >= license.memoryLimit) {
-    throw new PlanLimitError(
-      `Memory limit reached: ${count}/${license.memoryLimit} active memories on the ${license.plan} plan. Upgrade at https://askexe.com to store more.`
-    );
-  }
-}
-function assertEmployeeLimitSync(rosterPath) {
-  const license = getLicenseSync();
-  if (license.employeeLimit < 0) return;
-  const filePath = rosterPath ?? EMPLOYEES_PATH;
-  let count = 0;
-  try {
-    if (existsSync8(filePath)) {
-      const raw = readFileSync5(filePath, "utf8");
-      const employees = JSON.parse(raw);
-      count = Array.isArray(employees) ? employees.length : 0;
-    }
-  } catch {
-    throw new PlanLimitError(
-      `Cannot verify employee count: roster unreadable at ${filePath}. Refusing to proceed. Check file permissions or upgrade plan.`
-    );
-  }
-  if (count >= license.employeeLimit) {
-    throw new PlanLimitError(
-      `Employee limit reached: ${count}/${license.employeeLimit} employees on the ${license.plan} plan. Upgrade at https://askexe.com to add more.`
-    );
-  }
-}
-var PlanLimitError, CACHE_PATH2;
-var init_plan_limits = __esm({
-  "src/lib/plan-limits.ts"() {
-    "use strict";
-    init_database();
-    init_employees();
-    init_license();
-    init_config();
-    PlanLimitError = class extends Error {
-      constructor(message) {
-        super(message);
-        this.name = "PlanLimitError";
-      }
-    };
-    CACHE_PATH2 = path9.join(EXE_AI_DIR, "license-cache.json");
-  }
-});
-
-// src/lib/exe-daemon-client.ts
-import net from "net";
-import { spawn } from "child_process";
-import { randomUUID as randomUUID2 } from "crypto";
-import { existsSync as existsSync9, unlinkSync as unlinkSync2, readFileSync as readFileSync6, openSync, closeSync, statSync as statSync2 } from "fs";
-import path10 from "path";
-import { fileURLToPath } from "url";
-function handleData(chunk) {
-  _buffer += chunk.toString();
-  let newlineIdx;
-  while ((newlineIdx = _buffer.indexOf("\n")) !== -1) {
-    const line = _buffer.slice(0, newlineIdx).trim();
-    _buffer = _buffer.slice(newlineIdx + 1);
-    if (!line) continue;
-    try {
-      const response = JSON.parse(line);
-      const entry = _pending.get(response.id);
-      if (entry) {
-        clearTimeout(entry.timer);
-        _pending.delete(response.id);
-        entry.resolve(response);
-      }
-    } catch {
-    }
-  }
-}
-function cleanupStaleFiles() {
-  if (existsSync9(PID_PATH)) {
-    try {
-      const pid = parseInt(readFileSync6(PID_PATH, "utf8").trim(), 10);
-      if (pid > 0) {
-        try {
-          process.kill(pid, 0);
-          return;
-        } catch {
-        }
-      }
-    } catch {
-    }
-    try {
-      unlinkSync2(PID_PATH);
-    } catch {
-    }
-    try {
-      unlinkSync2(SOCKET_PATH);
-    } catch {
-    }
-  }
-}
-function findPackageRoot() {
-  let dir = path10.dirname(fileURLToPath(import.meta.url));
-  const { root } = path10.parse(dir);
-  while (dir !== root) {
-    if (existsSync9(path10.join(dir, "package.json"))) return dir;
-    dir = path10.dirname(dir);
-  }
-  return null;
-}
-function spawnDaemon() {
-  const pkgRoot = findPackageRoot();
-  if (!pkgRoot) {
-    process.stderr.write("[exed-client] WARN: cannot find package root\n");
-    return;
-  }
-  const daemonPath = path10.join(pkgRoot, "dist", "lib", "exe-daemon.js");
-  if (!existsSync9(daemonPath)) {
-    process.stderr.write(`[exed-client] WARN: daemon script not found at ${daemonPath}
-`);
-    return;
-  }
-  const resolvedPath = daemonPath;
-  process.stderr.write(`[exed-client] Spawning daemon: ${resolvedPath}
-`);
-  const logPath = path10.join(path10.dirname(SOCKET_PATH), "exed.log");
-  let stderrFd = "ignore";
-  try {
-    stderrFd = openSync(logPath, "a");
-  } catch {
-  }
-  const child = spawn(process.execPath, [resolvedPath], {
-    detached: true,
-    stdio: ["ignore", "ignore", stderrFd],
-    env: {
-      ...process.env,
-      EXE_DAEMON_SOCK: SOCKET_PATH,
-      EXE_DAEMON_PID: PID_PATH
-    }
-  });
-  child.unref();
-  if (typeof stderrFd === "number") {
-    try {
-      closeSync(stderrFd);
-    } catch {
-    }
-  }
-}
-function acquireSpawnLock() {
-  try {
-    const fd = openSync(SPAWN_LOCK_PATH, "wx");
-    closeSync(fd);
-    return true;
-  } catch {
-    try {
-      const stat = statSync2(SPAWN_LOCK_PATH);
-      if (Date.now() - stat.mtimeMs > SPAWN_LOCK_STALE_MS) {
-        try {
-          unlinkSync2(SPAWN_LOCK_PATH);
-        } catch {
-        }
-        try {
-          const fd = openSync(SPAWN_LOCK_PATH, "wx");
-          closeSync(fd);
-          return true;
-        } catch {
-        }
-      }
-    } catch {
-    }
-    return false;
-  }
-}
-function releaseSpawnLock() {
-  try {
-    unlinkSync2(SPAWN_LOCK_PATH);
-  } catch {
-  }
-}
-function connectToSocket() {
-  return new Promise((resolve) => {
-    if (_socket && _connected) {
-      resolve(true);
-      return;
-    }
-    const socket = net.createConnection({ path: SOCKET_PATH });
-    const connectTimeout = setTimeout(() => {
-      socket.destroy();
-      resolve(false);
-    }, 2e3);
-    socket.on("connect", () => {
-      clearTimeout(connectTimeout);
-      _socket = socket;
-      _connected = true;
-      _buffer = "";
-      socket.on("data", handleData);
-      socket.on("close", () => {
-        _connected = false;
-        _socket = null;
-        for (const [id, entry] of _pending) {
-          clearTimeout(entry.timer);
-          _pending.delete(id);
-          entry.resolve({ error: "Connection closed" });
-        }
-      });
-      socket.on("error", () => {
-        _connected = false;
-        _socket = null;
-      });
-      resolve(true);
-    });
-    socket.on("error", () => {
-      clearTimeout(connectTimeout);
-      resolve(false);
-    });
-  });
-}
-async function connectEmbedDaemon() {
-  if (_socket && _connected) return true;
-  if (await connectToSocket()) return true;
-  if (acquireSpawnLock()) {
-    try {
-      cleanupStaleFiles();
-      spawnDaemon();
-    } finally {
-      releaseSpawnLock();
-    }
-  }
-  const start = Date.now();
-  let delay = 100;
-  while (Date.now() - start < CONNECT_TIMEOUT_MS) {
-    await new Promise((r) => setTimeout(r, delay));
-    if (await connectToSocket()) return true;
-    delay = Math.min(delay * 2, 3e3);
-  }
-  return false;
-}
-function sendRequest(texts, priority) {
-  return new Promise((resolve) => {
-    if (!_socket || !_connected) {
-      resolve({ error: "Not connected" });
-      return;
-    }
-    const id = randomUUID2();
-    const timer = setTimeout(() => {
-      _pending.delete(id);
-      resolve({ error: "Request timeout" });
-    }, REQUEST_TIMEOUT_MS);
-    _pending.set(id, { resolve, timer });
-    try {
-      _socket.write(JSON.stringify({ id, texts, priority }) + "\n");
-    } catch {
-      clearTimeout(timer);
-      _pending.delete(id);
-      resolve({ error: "Write failed" });
-    }
-  });
-}
-async function pingDaemon() {
-  if (!_socket || !_connected) return null;
-  return new Promise((resolve) => {
-    const id = randomUUID2();
-    const timer = setTimeout(() => {
-      _pending.delete(id);
-      resolve(null);
-    }, 5e3);
-    _pending.set(id, {
-      resolve: (data) => {
-        if (data.health) {
-          resolve(data.health);
-        } else {
-          resolve(null);
-        }
-      },
-      timer
-    });
-    try {
-      _socket.write(JSON.stringify({ id, type: "health" }) + "\n");
-    } catch {
-      clearTimeout(timer);
-      _pending.delete(id);
-      resolve(null);
-    }
-  });
-}
-function killAndRespawnDaemon() {
-  process.stderr.write("[exed-client] Killing daemon for restart...\n");
-  if (existsSync9(PID_PATH)) {
-    try {
-      const pid = parseInt(readFileSync6(PID_PATH, "utf8").trim(), 10);
-      if (pid > 0) {
-        try {
-          process.kill(pid, "SIGKILL");
-        } catch {
-        }
-      }
-    } catch {
-    }
-  }
-  if (_socket) {
-    _socket.destroy();
-    _socket = null;
-  }
-  _connected = false;
-  _buffer = "";
-  try {
-    unlinkSync2(PID_PATH);
-  } catch {
-  }
-  try {
-    unlinkSync2(SOCKET_PATH);
-  } catch {
-  }
-  spawnDaemon();
-}
-async function embedViaClient(text, priority = "high") {
-  if (!_connected && !await connectEmbedDaemon()) return null;
-  _requestCount++;
-  if (_requestCount % HEALTH_CHECK_INTERVAL === 0) {
-    const health = await pingDaemon();
-    if (!health) {
-      process.stderr.write(`[exed-client] Periodic health check failed at request ${_requestCount} \u2014 restarting daemon
-`);
-      killAndRespawnDaemon();
-      const start = Date.now();
-      let delay = 200;
-      while (Date.now() - start < CONNECT_TIMEOUT_MS) {
-        await new Promise((r) => setTimeout(r, delay));
-        if (await connectToSocket()) break;
-        delay = Math.min(delay * 2, 3e3);
-      }
-      if (!_connected) return null;
-    }
-  }
-  const result = await sendRequest([text], priority);
-  if (!result.error && result.vectors?.[0]) return result.vectors[0];
-  if (result.error) {
-    process.stderr.write(`[exed-client] Embed failed (${result.error}) \u2014 attempting restart
-`);
-    killAndRespawnDaemon();
-    const start = Date.now();
-    let delay = 200;
-    while (Date.now() - start < CONNECT_TIMEOUT_MS) {
-      await new Promise((r) => setTimeout(r, delay));
-      if (await connectToSocket()) break;
-      delay = Math.min(delay * 2, 3e3);
-    }
-    if (!_connected) return null;
-    const retry = await sendRequest([text], priority);
-    if (!retry.error && retry.vectors?.[0]) return retry.vectors[0];
-    process.stderr.write(`[exed-client] Embed retry also failed: ${retry.error ?? "no vector"}
-`);
-  }
-  return null;
-}
-function disconnectClient() {
-  if (_socket) {
-    _socket.destroy();
-    _socket = null;
-  }
-  _connected = false;
-  _buffer = "";
-  for (const [id, entry] of _pending) {
-    clearTimeout(entry.timer);
-    _pending.delete(id);
-    entry.resolve({ error: "Client disconnected" });
-  }
-}
-var SOCKET_PATH, PID_PATH, SPAWN_LOCK_PATH, SPAWN_LOCK_STALE_MS, CONNECT_TIMEOUT_MS, REQUEST_TIMEOUT_MS, _socket, _connected, _buffer, _requestCount, HEALTH_CHECK_INTERVAL, _pending;
-var init_exe_daemon_client = __esm({
-  "src/lib/exe-daemon-client.ts"() {
-    "use strict";
-    init_config();
-    SOCKET_PATH = process.env.EXE_DAEMON_SOCK ?? process.env.EXE_EMBED_SOCK ?? path10.join(EXE_AI_DIR, "exed.sock");
-    PID_PATH = process.env.EXE_DAEMON_PID ?? process.env.EXE_EMBED_PID ?? path10.join(EXE_AI_DIR, "exed.pid");
-    SPAWN_LOCK_PATH = path10.join(EXE_AI_DIR, "exed-spawn.lock");
-    SPAWN_LOCK_STALE_MS = 3e4;
-    CONNECT_TIMEOUT_MS = 15e3;
-    REQUEST_TIMEOUT_MS = 3e4;
-    _socket = null;
-    _connected = false;
-    _buffer = "";
-    _requestCount = 0;
-    HEALTH_CHECK_INTERVAL = 100;
-    _pending = /* @__PURE__ */ new Map();
-  }
-});
-
-// src/lib/embedder.ts
-var embedder_exports = {};
-__export(embedder_exports, {
-  disposeEmbedder: () => disposeEmbedder,
-  embed: () => embed,
-  embedDirect: () => embedDirect,
-  getEmbedder: () => getEmbedder
-});
-async function getEmbedder() {
-  const ok = await connectEmbedDaemon();
-  if (!ok) {
-    throw new Error(
-      "Could not connect to embedding daemon. Ensure the model is installed (run /exe-setup)."
-    );
-  }
-}
-async function embed(text) {
-  const priority = process.env.EXE_EMBED_PRIORITY === "low" ? "low" : "high";
-  const vector = await embedViaClient(text, priority);
-  if (!vector) {
-    throw new Error(
-      "Embedding failed: daemon unavailable. Run /exe-setup to verify model installation."
-    );
-  }
-  if (vector.length !== EMBEDDING_DIM) {
-    throw new Error(
-      `Embedding dimension mismatch: expected ${EMBEDDING_DIM}, got ${vector.length}. Ensure the correct Jina v5-small Q4_K_M GGUF model is installed.`
-    );
-  }
-  return vector;
-}
-async function disposeEmbedder() {
-  disconnectClient();
-}
-async function embedDirect(text) {
-  const llamaCpp = await import("node-llama-cpp");
-  const { MODELS_DIR: MODELS_DIR2 } = await Promise.resolve().then(() => (init_config(), config_exports));
-  const { existsSync: existsSync16 } = await import("fs");
-  const path20 = await import("path");
-  const modelPath = path20.join(MODELS_DIR2, "jina-embeddings-v5-small-q4_k_m.gguf");
-  if (!existsSync16(modelPath)) {
-    throw new Error(`Embedding model not found at ${modelPath}. Run '/exe-setup' to download it.`);
-  }
-  const llama = await llamaCpp.getLlama();
-  const model = await llama.loadModel({ modelPath });
-  const context = await model.createEmbeddingContext();
-  try {
-    const embedding = await context.getEmbeddingFor(text);
-    const vector = Array.from(embedding.vector);
-    if (vector.length !== EMBEDDING_DIM) {
-      throw new Error(
-        `Embedding dimension mismatch: expected ${EMBEDDING_DIM}, got ${vector.length}.`
-      );
-    }
-    return vector;
-  } finally {
-    await context.dispose();
-    await model.dispose();
-  }
-}
-var init_embedder = __esm({
-  "src/lib/embedder.ts"() {
-    "use strict";
-    init_memory();
-    init_exe_daemon_client();
-  }
-});
-
-// src/lib/tasks-crud.ts
-import crypto4 from "crypto";
-import path11 from "path";
-import { execSync as execSync4 } from "child_process";
-import { mkdir as mkdir4, writeFile as writeFile4, appendFile } from "fs/promises";
-import { existsSync as existsSync10, readFileSync as readFileSync7 } 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(input2) {
-  const client = getClient();
-  const id = crypto4.randomUUID();
-  const now = (/* @__PURE__ */ new Date()).toISOString();
-  const slug = slugify(input2.title);
-  const taskFile = input2.taskFile ?? `exe/${input2.assignedTo}/${slug}.md`;
-  let blockedById = null;
-  const initialStatus = input2.blockedBy ? "blocked" : "open";
-  if (input2.blockedBy) {
-    const blocker = await resolveTask(client, input2.blockedBy);
-    blockedById = String(blocker.id);
-  }
-  let parentTaskId = null;
-  let parentRef = input2.parentTaskId;
-  if (!parentRef) {
-    const extracted = extractParentFromContext(input2.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 (!input2.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: [input2.title, input2.assignedTo]
-  });
-  if (dupCheck.rows.length > 0) {
-    warning = `similar active task already exists (${String(dupCheck.rows[0].id)}). Created new task anyway.`;
-  }
-  if (input2.baseDir) {
-    try {
-      await mkdir4(path11.join(input2.baseDir, "exe", "output"), { recursive: true });
-      await mkdir4(path11.join(input2.baseDir, "exe", "research"), { recursive: true });
-      await ensureArchitectureDoc(input2.baseDir, input2.projectName);
-      await ensureGitignoreExe(input2.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,
-      input2.title,
-      input2.assignedTo,
-      input2.assignedBy,
-      input2.projectName,
-      input2.priority,
-      initialStatus,
-      taskFile,
-      blockedById,
-      parentTaskId,
-      input2.reviewer ?? null,
-      input2.context,
-      now,
-      now
-    ]
-  });
-  return {
-    id,
-    title: input2.title,
-    assignedTo: input2.assignedTo,
-    assignedBy: input2.assignedBy,
-    projectName: input2.projectName,
-    priority: input2.priority,
-    status: initialStatus,
-    taskFile,
-    createdAt: now,
-    updatedAt: now,
-    warning
-  };
-}
-async function listTasks(input2) {
-  const client = getClient();
-  const conditions = [];
-  const args = [];
-  if (input2.assignedTo) {
-    conditions.push("assigned_to = ?");
-    args.push(input2.assignedTo);
-  }
-  if (input2.status) {
-    conditions.push("status = ?");
-    args.push(input2.status);
-  } else {
-    conditions.push("status IN ('open', 'in_progress', 'blocked')");
-  }
-  if (input2.projectName) {
-    conditions.push("project_name = ?");
-    args.push(input2.projectName);
-  }
-  if (input2.priority) {
-    conditions.push("priority = ?");
-    args.push(input2.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)
-  }));
-}
-function checkStaleCompletion(taskContext, taskCreatedAt) {
-  if (!taskContext) return null;
-  if (!DELEGATION_KEYWORDS.test(taskContext)) return null;
-  try {
-    const since = new Date(taskCreatedAt).toISOString();
-    const commitCount = execSync4(
-      `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(input2) {
-  const client = getClient();
-  const now = (/* @__PURE__ */ new Date()).toISOString();
-  const row = await resolveTask(client, input2.taskId);
-  const taskId = String(row.id);
-  const taskFile = String(row.task_file);
-  if (input2.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 (input2.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) {
-        input2.result = input2.result ? `\u26A0\uFE0F ${warning}
-
-${input2.result}` : `\u26A0\uFE0F ${warning}`;
-        process.stderr.write(`[tasks] ${warning} (task: ${taskId})
-`);
-      }
-    }
-  }
-  if (input2.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 (input2.result) {
-    await client.execute({
-      sql: "UPDATE tasks SET status = ?, result = ?, updated_at = ? WHERE id = ?",
-      args: [input2.status, input2.result, now, taskId]
-    });
-  } else {
-    await client.execute({
-      sql: "UPDATE tasks SET status = ?, updated_at = ? WHERE id = ?",
-      args: [input2.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, projectName) {
-  const archPath = path11.join(baseDir, "exe", "ARCHITECTURE.md");
-  try {
-    if (existsSync10(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 writeFile4(archPath, template, "utf-8");
-  } catch {
-  }
-}
-async function ensureGitignoreExe(baseDir) {
-  const gitignorePath = path11.join(baseDir, ".gitignore");
-  try {
-    if (existsSync10(gitignorePath)) {
-      const content = readFileSync7(gitignorePath, "utf-8");
-      if (/^\/?exe\/?$/m.test(content)) return;
-      await appendFile(gitignorePath, "\n# Employee task assignments (private)\n/exe/\n");
-    } else {
-      await writeFile4(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/session-registry.ts
-import { readFileSync as readFileSync8, writeFileSync as writeFileSync2, mkdirSync as mkdirSync3, existsSync as existsSync11 } from "fs";
-import path12 from "path";
-import os3 from "os";
-function registerSession(entry) {
-  const dir = path12.dirname(REGISTRY_PATH);
-  if (!existsSync11(dir)) {
-    mkdirSync3(dir, { recursive: true });
-  }
-  const sessions = listSessions();
-  const idx = sessions.findIndex((s) => s.windowName === entry.windowName);
-  if (idx >= 0) {
-    sessions[idx] = entry;
-  } else {
-    sessions.push(entry);
-  }
-  writeFileSync2(REGISTRY_PATH, JSON.stringify(sessions, null, 2));
-}
-function listSessions() {
-  try {
-    const raw = readFileSync8(REGISTRY_PATH, "utf8");
-    return JSON.parse(raw);
-  } catch {
-    return [];
-  }
-}
-var REGISTRY_PATH;
-var init_session_registry = __esm({
-  "src/lib/session-registry.ts"() {
-    "use strict";
-    REGISTRY_PATH = path12.join(os3.homedir(), ".exe-os", "session-registry.json");
-  }
-});
-
-// src/lib/session-key.ts
-import { execSync as execSync5 } from "child_process";
-function getSessionKey() {
-  if (_cached2) return _cached2;
-  let pid = process.ppid;
-  for (let i = 0; i < 10; i++) {
-    try {
-      const info = execSync5(`ps -p ${pid} -o ppid=,comm=`, {
-        encoding: "utf8",
-        timeout: 2e3
-      }).trim();
-      const match = info.match(/^\s*(\d+)\s+(.+)$/);
-      if (!match) break;
-      const [, ppid, cmd] = match;
-      if (cmd === "claude" || cmd.endsWith("/claude")) {
-        _cached2 = String(pid);
-        return _cached2;
-      }
-      pid = parseInt(ppid, 10);
-      if (pid <= 1) break;
-    } catch {
-      break;
-    }
-  }
-  _cached2 = process.env.CLAUDE_CODE_SSE_PORT ?? String(process.ppid);
-  return _cached2;
-}
-var _cached2;
-var init_session_key = __esm({
-  "src/lib/session-key.ts"() {
-    "use strict";
-    _cached2 = null;
-  }
-});
-
-// src/lib/tmux-transport.ts
-var tmux_transport_exports = {};
-__export(tmux_transport_exports, {
-  TmuxTransport: () => TmuxTransport
-});
-import { execFileSync } from "child_process";
-var QUIET, TmuxTransport;
-var init_tmux_transport = __esm({
-  "src/lib/tmux-transport.ts"() {
-    "use strict";
-    QUIET = {
-      encoding: "utf8",
-      stdio: ["pipe", "pipe", "pipe"]
-    };
-    TmuxTransport = class {
-      getMySession() {
-        try {
-          return execFileSync("tmux", ["display-message", "-p", "#{session_name}"], QUIET).trim() || null;
-        } catch {
-          return null;
-        }
-      }
-      listSessions() {
-        try {
-          return execFileSync("tmux", ["list-sessions", "-F", "#{session_name}"], QUIET).trim().split("\n").filter(Boolean);
-        } catch {
-          return [];
-        }
-      }
-      isAlive(target) {
-        try {
-          const sessions = this.listSessions();
-          if (!sessions.includes(target)) return false;
-          const paneStatus = execFileSync(
-            "tmux",
-            ["list-panes", "-t", target, "-F", "#{pane_dead}"],
-            QUIET
-          ).trim();
-          return paneStatus !== "1";
-        } catch {
-          return false;
-        }
-      }
-      sendKeys(target, keys) {
-        execFileSync("tmux", ["send-keys", "-t", target, keys, "Enter"], QUIET);
-      }
-      capturePane(target, lines) {
-        const args = ["capture-pane", "-t", target, "-p"];
-        if (lines) args.push("-S", `-${lines}`);
-        return execFileSync("tmux", args, { ...QUIET, timeout: 3e3 });
-      }
-      isPaneInCopyMode(target) {
-        try {
-          const result = execFileSync(
-            "tmux",
-            ["display-message", "-p", "-t", target, "#{pane_in_mode}"],
-            { ...QUIET, timeout: 3e3 }
-          ).trim();
-          return result === "1";
-        } catch {
-          return false;
-        }
-      }
-      spawn(name, config) {
-        try {
-          const args = ["new-session", "-d", "-s", name];
-          if (config.cwd) args.push("-c", config.cwd);
-          args.push(config.command);
-          execFileSync("tmux", args);
-          return { sessionName: name };
-        } catch (e) {
-          return { sessionName: name, error: `spawn failed: ${e}` };
-        }
-      }
-      kill(target) {
-        try {
-          execFileSync("tmux", ["kill-session", "-t", target], QUIET);
-        } catch {
-        }
-      }
-      pipeLog(target, logFile) {
-        try {
-          const safePath = logFile.replace(/'/g, "'\\''");
-          execFileSync("tmux", ["pipe-pane", "-t", target, `cat >> '${safePath}'`], QUIET);
-        } catch {
-        }
-      }
-    };
-  }
-});
-
-// src/lib/transport.ts
-function getTransport() {
-  if (!_transport) {
-    const { TmuxTransport: TmuxTransport2 } = (init_tmux_transport(), __toCommonJS(tmux_transport_exports));
-    _transport = new TmuxTransport2();
-  }
-  return _transport;
-}
-var _transport;
-var init_transport = __esm({
-  "src/lib/transport.ts"() {
-    "use strict";
-    _transport = null;
-  }
-});
-
-// src/lib/cc-agent-support.ts
-import { execSync as execSync6 } from "child_process";
-function _resetCcAgentSupportCache() {
-  _cachedSupport = null;
-}
-function claudeSupportsAgentFlag() {
-  if (_cachedSupport !== null) return _cachedSupport;
-  try {
-    const helpOutput = execSync6("claude --help 2>&1", {
-      encoding: "utf-8",
-      timeout: 5e3
-    });
-    _cachedSupport = /(^|\s)--agent(\b|=)/.test(helpOutput);
-  } catch {
-    _cachedSupport = false;
-  }
-  return _cachedSupport;
-}
-var _cachedSupport;
-var init_cc_agent_support = __esm({
-  "src/lib/cc-agent-support.ts"() {
-    "use strict";
-    _cachedSupport = null;
-  }
-});
-
-// src/lib/provider-table.ts
-function detectActiveProvider(env = process.env) {
-  const baseUrl = env.ANTHROPIC_BASE_URL;
-  if (!baseUrl) return DEFAULT_PROVIDER;
-  for (const [name, cfg] of Object.entries(PROVIDER_TABLE)) {
-    if (cfg.baseUrl === baseUrl) return name;
-  }
-  return DEFAULT_PROVIDER;
-}
-var PROVIDER_TABLE, DEFAULT_PROVIDER;
-var init_provider_table = __esm({
-  "src/lib/provider-table.ts"() {
-    "use strict";
-    PROVIDER_TABLE = {
-      opencode: {
-        baseUrl: "https://opencode.ai/zen/go",
-        apiKeyEnv: "OPENCODE_API_KEY",
-        defaultModel: "minimax-m2.7"
-      }
-    };
-    DEFAULT_PROVIDER = "default";
-  }
-});
-
-// src/lib/intercom-queue.ts
-import { readFileSync as readFileSync9, writeFileSync as writeFileSync3, renameSync as renameSync2, existsSync as existsSync12, mkdirSync as mkdirSync4 } from "fs";
-import path13 from "path";
-import os4 from "os";
-function ensureDir() {
-  const dir = path13.dirname(QUEUE_PATH);
-  if (!existsSync12(dir)) mkdirSync4(dir, { recursive: true });
-}
-function readQueue() {
-  try {
-    if (!existsSync12(QUEUE_PATH)) return [];
-    return JSON.parse(readFileSync9(QUEUE_PATH, "utf8"));
-  } catch {
-    return [];
-  }
-}
-function writeQueue(queue) {
-  ensureDir();
-  const tmp = `${QUEUE_PATH}.tmp`;
-  writeFileSync3(tmp, JSON.stringify(queue, null, 2));
-  renameSync2(tmp, QUEUE_PATH);
-}
-function queueIntercom(targetSession, reason) {
-  const queue = readQueue();
-  const existing = queue.find((q) => q.targetSession === targetSession);
-  if (existing) {
-    existing.attempts++;
-    existing.queuedAt = (/* @__PURE__ */ new Date()).toISOString();
-    existing.reason = reason;
-  } else {
-    queue.push({
-      targetSession,
-      queuedAt: (/* @__PURE__ */ new Date()).toISOString(),
-      attempts: 0,
-      reason
-    });
-  }
-  writeQueue(queue);
-}
-var QUEUE_PATH, INTERCOM_LOG;
-var init_intercom_queue = __esm({
-  "src/lib/intercom-queue.ts"() {
-    "use strict";
-    QUEUE_PATH = path13.join(os4.homedir(), ".exe-os", "intercom-queue.json");
-    INTERCOM_LOG = path13.join(os4.homedir(), ".exe-os", "intercom.log");
-  }
-});
-
-// src/lib/worktree.ts
-import { execSync as execSync7 } from "child_process";
-import { existsSync as existsSync13, readFileSync as readFileSync10, appendFileSync, mkdirSync as mkdirSync5, realpathSync } from "fs";
-import path14 from "path";
-function getGitRoot(dir) {
-  try {
-    const root = execSync7("git rev-parse --show-toplevel", {
-      cwd: dir,
-      encoding: "utf-8",
-      timeout: GIT_TIMEOUT_MS,
-      stdio: ["pipe", "pipe", "pipe"]
-    }).trim();
-    return realpath(root);
-  } catch {
-    return null;
-  }
-}
-function worktreePath(repoRoot, employeeName, instance) {
-  const label = instanceLabel(employeeName, instance);
-  return path14.join(repoRoot, ".worktrees", label);
-}
-function worktreeBranch(employeeName, instance) {
-  return `${instanceLabel(employeeName, instance)}-work`;
-}
-function instanceLabel(name, instance) {
-  return instance != null && instance > 0 ? `${name}${instance}` : name;
-}
-function ensureWorktree(projectDir, employeeName, instance) {
-  const repoRoot = getGitRoot(projectDir);
-  if (!repoRoot) return null;
-  const wtPath = worktreePath(repoRoot, employeeName, instance);
-  const branch = worktreeBranch(employeeName, instance);
-  if (existsSync13(path14.join(wtPath, ".git"))) {
-    return wtPath;
-  }
-  const worktreesDir = path14.join(repoRoot, ".worktrees");
-  mkdirSync5(worktreesDir, { recursive: true });
-  ensureGitignoreEntry(repoRoot, "/.worktrees/");
-  try {
-    execSync7("git worktree prune", {
-      cwd: repoRoot,
-      encoding: "utf-8",
-      timeout: GIT_TIMEOUT_MS,
-      stdio: ["pipe", "pipe", "pipe"]
-    });
-  } catch {
-  }
-  const branchExists = branchExistsLocally(repoRoot, branch);
-  try {
-    if (branchExists) {
-      execSync7(`git worktree add "${wtPath}" "${branch}"`, {
-        cwd: repoRoot,
-        encoding: "utf-8",
-        timeout: GIT_TIMEOUT_MS,
-        stdio: ["pipe", "pipe", "pipe"]
-      });
-    } else {
-      execSync7(`git worktree add "${wtPath}" -b "${branch}" HEAD`, {
-        cwd: repoRoot,
-        encoding: "utf-8",
-        timeout: GIT_TIMEOUT_MS,
-        stdio: ["pipe", "pipe", "pipe"]
-      });
-    }
-    return wtPath;
-  } catch (err) {
-    process.stderr.write(
-      `[worktree] Failed to create worktree for ${employeeName}: ${err instanceof Error ? err.message : String(err)}
-`
-    );
-    return null;
-  }
-}
-function branchExistsLocally(repoRoot, branch) {
-  try {
-    execSync7(`git rev-parse --verify "refs/heads/${branch}"`, {
-      cwd: repoRoot,
-      encoding: "utf-8",
-      timeout: GIT_TIMEOUT_MS,
-      stdio: ["pipe", "pipe", "pipe"]
-    });
-    return true;
-  } catch {
-    return false;
-  }
-}
-function realpath(p) {
-  try {
-    return realpathSync(p);
-  } catch {
-    return p;
-  }
-}
-function ensureGitignoreEntry(repoRoot, entry) {
-  try {
-    const gitignorePath = path14.join(repoRoot, ".gitignore");
-    if (existsSync13(gitignorePath)) {
-      const content = readFileSync10(gitignorePath, "utf-8");
-      if (content.includes(entry)) return;
-      appendFileSync(gitignorePath, `
-# Agent worktrees (exe-os)
-${entry}
-`);
-    } else {
-    }
-  } catch {
-  }
-}
-var GIT_TIMEOUT_MS;
-var init_worktree = __esm({
-  "src/lib/worktree.ts"() {
-    "use strict";
-    GIT_TIMEOUT_MS = 1e4;
-  }
-});
-
-// src/lib/tmux-routing.ts
-import { execFileSync as execFileSync2, execSync as execSync8 } from "child_process";
-import { readFileSync as readFileSync11, writeFileSync as writeFileSync4, mkdirSync as mkdirSync6, existsSync as existsSync14, appendFileSync as appendFileSync2 } from "fs";
-import path15 from "path";
-import os5 from "os";
-import { fileURLToPath as fileURLToPath2 } from "url";
-function resolveBehaviorsExporterScript() {
-  try {
-    const thisFile = fileURLToPath2(import.meta.url);
-    const scriptPath = path15.join(
-      path15.dirname(thisFile),
-      "..",
-      "bin",
-      "exe-export-behaviors.js"
-    );
-    return existsSync14(scriptPath) ? scriptPath : null;
-  } catch {
-    return null;
-  }
-}
-function exportBehaviorsSync(agentId, projectName, sessionKey) {
-  const script = resolveBehaviorsExporterScript();
-  if (!script) return null;
-  try {
-    const output = execFileSync2(
-      process.execPath,
-      [script, agentId, projectName, sessionKey],
-      { encoding: "utf-8", timeout: BEHAVIORS_EXPORT_TIMEOUT_MS }
-    ).trim();
-    return output.length > 0 ? output : null;
-  } catch (err) {
-    process.stderr.write(
-      `[tmux-routing] behaviors export failed for ${agentId}: ${err instanceof Error ? err.message : String(err)}
-`
-    );
-    return null;
-  }
-}
-function getMySession() {
-  return getTransport().getMySession();
-}
-function employeeSessionName(employee, exeSession, instance) {
-  const suffix = instance != null && instance > 0 ? String(instance) : "";
-  return `${employee}${suffix}-${exeSession}`;
-}
-function extractRootExe(name) {
-  const match = name.match(/(exe\d+)$/);
-  return match?.[1] ?? null;
-}
-function getParentExe(sessionKey) {
-  try {
-    const data = JSON.parse(readFileSync11(path15.join(SESSION_CACHE, `parent-exe-${sessionKey}.json`), "utf8"));
-    return data.parentExe || null;
-  } catch {
-    return null;
-  }
-}
-function getDispatchedBy(sessionKey) {
-  try {
-    const data = JSON.parse(readFileSync11(
-      path15.join(SESSION_CACHE, `parent-exe-${sessionKey}.json`),
-      "utf8"
-    ));
-    return data.dispatchedBy ?? data.parentExe ?? null;
-  } catch {
-    return null;
-  }
-}
-function resolveExeSession() {
-  const mySession = getMySession();
-  if (!mySession) return null;
-  try {
-    const key = getSessionKey();
-    const parentExe = getParentExe(key);
-    if (parentExe) {
-      return extractRootExe(parentExe) ?? parentExe;
-    }
-  } catch {
-  }
-  return extractRootExe(mySession) ?? mySession;
-}
-function isEmployeeAlive(sessionName) {
-  return getTransport().isAlive(sessionName);
-}
-function findFreeInstance(employeeName, exeSession, maxInstances = 10, isAlive = isEmployeeAlive) {
-  const base = employeeSessionName(employeeName, exeSession);
-  if (!isAlive(base)) return 0;
-  for (let i = 2; i <= maxInstances; i++) {
-    const candidate = employeeSessionName(employeeName, exeSession, i);
-    if (!isAlive(candidate)) return i;
-  }
-  return null;
-}
-function readDebounceState() {
-  try {
-    if (!existsSync14(DEBOUNCE_FILE)) return {};
-    return JSON.parse(readFileSync11(DEBOUNCE_FILE, "utf8"));
-  } catch {
-    return {};
-  }
-}
-function writeDebounceState(state) {
-  try {
-    if (!existsSync14(SESSION_CACHE)) mkdirSync6(SESSION_CACHE, { recursive: true });
-    writeFileSync4(DEBOUNCE_FILE, JSON.stringify(state));
-  } catch {
-  }
-}
-function isDebounced(targetSession) {
-  const state = readDebounceState();
-  const lastSent = state[targetSession] ?? 0;
-  return Date.now() - lastSent < INTERCOM_DEBOUNCE_MS;
-}
-function recordDebounce(targetSession) {
-  const state = readDebounceState();
-  state[targetSession] = Date.now();
-  const cutoff = Date.now() - DEBOUNCE_CLEANUP_AGE_MS;
-  for (const key of Object.keys(state)) {
-    if ((state[key] ?? 0) < cutoff) delete state[key];
-  }
-  writeDebounceState(state);
-}
-function logIntercom(msg) {
-  const line = `[${(/* @__PURE__ */ new Date()).toISOString()}] ${msg}
-`;
-  process.stderr.write(`[intercom] ${msg}
-`);
-  try {
-    appendFileSync2(INTERCOM_LOG2, line);
-  } catch {
-  }
-}
-function getSessionState(sessionName) {
-  const transport = getTransport();
-  if (!transport.isAlive(sessionName)) return "offline";
-  try {
-    const pane = transport.capturePane(sessionName, 5);
-    if (/Running…/.test(pane)) return "tool";
-    if (BUSY_PATTERN.test(pane)) return "thinking";
-    return "idle";
-  } catch {
-    return "offline";
-  }
-}
-function isSessionBusy(sessionName) {
-  const state = getSessionState(sessionName);
-  return state === "thinking" || state === "tool";
-}
-function isExeSession(sessionName) {
-  return /^exe\d*$/.test(sessionName);
-}
-function sendIntercom(targetSession) {
-  const transport = getTransport();
-  if (isExeSession(targetSession)) {
-    logIntercom(`SKIP_EXE \u2192 ${targetSession} (exe sessions use prompt-submit hook)`);
-    return "skipped_exe";
-  }
-  if (isDebounced(targetSession)) {
-    logIntercom(`DEBOUNCE \u2192 ${targetSession} (cross-process file debounce)`);
-    return "debounced";
-  }
-  try {
-    const sessions = transport.listSessions();
-    if (!sessions.includes(targetSession)) {
-      logIntercom(`SKIP \u2192 ${targetSession} (session not found)`);
-      return "failed";
-    }
-    if (isSessionBusy(targetSession)) {
-      queueIntercom(targetSession, "session busy at send time");
-      recordDebounce(targetSession);
-      logIntercom(`QUEUED \u2192 ${targetSession} (session busy, will retry from queue)`);
-      return "queued";
-    }
-    if (transport.isPaneInCopyMode(targetSession)) {
-      logIntercom(`COPY_MODE \u2192 ${targetSession} (exiting copy mode first)`);
-      transport.sendKeys(targetSession, "q");
-    }
-    transport.sendKeys(targetSession, "/exe-intercom");
-    recordDebounce(targetSession);
-    for (let i = 0; i < INTERCOM_POLL_MAX_ATTEMPTS; i++) {
-      try {
-        execSync8(`sleep ${INTERCOM_POLL_INTERVAL_S}`);
-      } catch {
-      }
-      const state = getSessionState(targetSession);
-      if (state === "thinking" || state === "tool") {
-        logIntercom(`ACKNOWLEDGED \u2192 ${targetSession} (state=${state}, poll=${i + 1})`);
-        return "acknowledged";
-      }
-    }
-    logIntercom(`DELIVERED \u2192 ${targetSession} (no state transition after ${INTERCOM_POLL_MAX_ATTEMPTS}s)`);
-    return "delivered";
-  } catch {
-    logIntercom(`FAIL \u2192 ${targetSession}`);
-    return "failed";
-  }
-}
-function notifyParentExe(sessionKey) {
-  const target = getDispatchedBy(sessionKey);
-  if (!target) {
-    process.stderr.write(`[intercom] notifyParentExe: no dispatcher found for key ${sessionKey}
-`);
-    return false;
-  }
-  process.stderr.write(`[intercom] notifyParentExe \u2192 ${target}
-`);
-  const result = sendIntercom(target);
-  return result !== "failed";
-}
-function ensureEmployee(employeeName, exeSession, projectDir, opts) {
-  if (employeeName === "exe") {
-    return { status: "failed", sessionName: "", error: "exe is the COO, not a dispatchable employee" };
-  }
-  try {
-    assertEmployeeLimitSync();
-  } catch (err) {
-    if (err instanceof PlanLimitError) {
-      return { status: "failed", sessionName: "", error: err.message };
-    }
-  }
-  if (/-exe\d*$/.test(employeeName)) {
-    const bare = employeeName.replace(/-exe\d*$/, "").replace(/\d+$/, "");
-    return {
-      status: "failed",
-      sessionName: "",
-      error: `Error: pass employee name ('${bare}'), not session name ('${employeeName}')`
-    };
-  }
-  let effectiveInstance = opts?.instance;
-  if (effectiveInstance === void 0 && opts?.autoInstance) {
-    const free = findFreeInstance(
-      employeeName,
-      exeSession,
-      opts.maxAutoInstances ?? 10
-    );
-    if (free === null) {
-      return {
-        status: "failed",
-        sessionName: employeeSessionName(employeeName, exeSession),
-        error: `All ${opts.maxAutoInstances ?? 10} instances of ${employeeName} are alive \u2014 cap reached`
-      };
-    }
-    effectiveInstance = free === 0 ? void 0 : free;
-  }
-  const sessionName = employeeSessionName(employeeName, exeSession, effectiveInstance);
-  if (isEmployeeAlive(sessionName)) {
-    const result2 = sendIntercom(sessionName);
-    if (result2 === "acknowledged" || result2 === "skipped_exe" || result2 === "debounced" || result2 === "queued") {
-      return { status: "intercom_sent", sessionName };
-    }
-    if (result2 === "delivered") {
-      return { status: "intercom_unprocessed", sessionName };
-    }
-    return { status: "failed", sessionName, error: "intercom delivery failed" };
-  }
-  const spawnOpts = { ...opts, instance: effectiveInstance };
-  const wtPath = ensureWorktree(projectDir, employeeName, effectiveInstance);
-  if (wtPath) {
-    spawnOpts.cwd = wtPath;
-  }
-  const result = spawnEmployee(employeeName, exeSession, projectDir, spawnOpts);
-  if (result.error) {
-    return { status: "failed", sessionName, error: result.error };
-  }
-  return { status: "spawned", sessionName };
-}
-function spawnEmployee(employeeName, exeSession, projectDir, opts) {
-  const transport = getTransport();
-  const sessionName = employeeSessionName(employeeName, exeSession, opts?.instance);
-  const instanceLabel2 = opts?.instance != null && opts.instance > 0 ? `${employeeName}${opts.instance}` : employeeName;
-  const logDir = path15.join(os5.homedir(), ".exe-os", "session-logs");
-  const logFile = path15.join(logDir, `${instanceLabel2}-${Date.now()}.log`);
-  if (!existsSync14(logDir)) {
-    mkdirSync6(logDir, { recursive: true });
-  }
-  transport.kill(sessionName);
-  let cleanupSuffix = "";
-  try {
-    const thisFile = fileURLToPath2(import.meta.url);
-    const cleanupScript = path15.join(path15.dirname(thisFile), "..", "bin", "exe-session-cleanup.js");
-    if (existsSync14(cleanupScript)) {
-      cleanupSuffix = `; ${process.execPath} "${cleanupScript}" "${employeeName}" "${exeSession}"`;
-    }
-  } catch {
-  }
-  try {
-    const claudeJsonPath = path15.join(os5.homedir(), ".claude.json");
-    let claudeJson = {};
-    try {
-      claudeJson = JSON.parse(readFileSync11(claudeJsonPath, "utf8"));
-    } catch {
-    }
-    if (!claudeJson.projects) claudeJson.projects = {};
-    const projects = claudeJson.projects;
-    const trustDir = opts?.cwd ?? projectDir;
-    if (!projects[trustDir]) projects[trustDir] = {};
-    projects[trustDir].hasTrustDialogAccepted = true;
-    writeFileSync4(claudeJsonPath, JSON.stringify(claudeJson, null, 2) + "\n");
-  } catch {
-  }
-  try {
-    const settingsDir = path15.join(os5.homedir(), ".claude", "projects");
-    const normalizedKey = (opts?.cwd ?? projectDir).replace(/\//g, "-").replace(/^-/, "");
-    const projSettingsDir = path15.join(settingsDir, normalizedKey);
-    const settingsPath = path15.join(projSettingsDir, "settings.json");
-    let settings = {};
-    try {
-      settings = JSON.parse(readFileSync11(settingsPath, "utf8"));
-    } catch {
-    }
-    const perms = settings.permissions ?? {};
-    const allow = perms.allow ?? [];
-    const toolNames = [
-      "recall_my_memory",
-      "store_memory",
-      "create_task",
-      "update_task",
-      "list_tasks",
-      "get_task",
-      "ask_team_memory",
-      "store_behavior",
-      "get_identity",
-      "send_message"
-    ];
-    const requiredTools = expandDualPrefixTools(toolNames);
-    let changed = false;
-    for (const tool of requiredTools) {
-      if (!allow.includes(tool)) {
-        allow.push(tool);
-        changed = true;
-      }
-    }
-    if (changed) {
-      perms.allow = allow;
-      settings.permissions = perms;
-      mkdirSync6(projSettingsDir, { recursive: true });
-      writeFileSync4(settingsPath, JSON.stringify(settings, null, 2) + "\n");
-    }
-  } catch {
-  }
-  const spawnCwd = opts?.cwd ?? projectDir;
-  const useExeAgent = !!(opts?.model && opts?.provider);
-  const ccProvider = useExeAgent ? DEFAULT_PROVIDER : detectActiveProvider();
-  const useBinSymlink = ccProvider !== DEFAULT_PROVIDER;
-  let identityFlag = "";
-  let behaviorsFlag = "";
-  let legacyFallbackWarned = false;
-  if (!useExeAgent && !useBinSymlink) {
-    const identityPath = path15.join(
-      os5.homedir(),
-      ".exe-os",
-      "identity",
-      `${employeeName}.md`
-    );
-    _resetCcAgentSupportCache();
-    const hasAgentFlag = claudeSupportsAgentFlag();
-    if (hasAgentFlag) {
-      identityFlag = ` --agent ${employeeName}`;
-    } else if (existsSync14(identityPath)) {
-      identityFlag = ` --append-system-prompt-file ${identityPath}`;
-      legacyFallbackWarned = true;
-    }
-    const behaviorsFile = exportBehaviorsSync(
-      employeeName,
-      path15.basename(spawnCwd),
-      sessionName
-    );
-    if (behaviorsFile) {
-      behaviorsFlag = ` --append-system-prompt-file ${behaviorsFile}`;
-    }
-  }
-  if (legacyFallbackWarned) {
-    process.stderr.write(
-      `[tmux-routing] claude --agent not supported by installed CC. Falling back to --append-system-prompt-file for ${employeeName}. Upgrade Claude Code to enable native --agent launch.
-`
-    );
-  }
-  let sessionContextFlag = "";
-  try {
-    const ctxDir = path15.join(os5.homedir(), ".exe-os", "session-cache");
-    mkdirSync6(ctxDir, { recursive: true });
-    const ctxFile = path15.join(ctxDir, `session-context-${sessionName}.md`);
-    const ctxContent = [
-      `## Session Context`,
-      `You are running in tmux session: ${sessionName}.`,
-      `Your parent exe session is ${exeSession}.`,
-      `Your employees (if any) use the -${exeSession} suffix (e.g., tom-${exeSession}).`
-    ].join("\n");
-    writeFileSync4(ctxFile, ctxContent);
-    sessionContextFlag = ` --append-system-prompt-file ${ctxFile}`;
-  } catch {
-  }
-  let envPrefix = `EXE_SESSION=${exeSession} EXE_SESSION_NAME=${sessionName}`;
-  if (ccProvider !== DEFAULT_PROVIDER) {
-    const cfg = PROVIDER_TABLE[ccProvider];
-    if (cfg?.apiKeyEnv) {
-      const keyVal = process.env[cfg.apiKeyEnv];
-      if (keyVal) {
-        envPrefix = `${envPrefix} ${cfg.apiKeyEnv}=${keyVal}`;
-      }
-    }
-  }
-  let spawnCommand;
-  if (useExeAgent) {
-    spawnCommand = `${envPrefix} exe-agent --employee ${employeeName} --model ${opts.model} --provider ${opts.provider}${cleanupSuffix}`;
-  } else if (useBinSymlink) {
-    const binName = `${employeeName}-${ccProvider}`;
-    process.stderr.write(
-      `[tmux-routing] provider cascade: ${ccProvider} \u2192 spawning ${binName}
-`
-    );
-    spawnCommand = `${envPrefix} ${binName}${cleanupSuffix}`;
-  } else {
-    spawnCommand = `${envPrefix} claude --dangerously-skip-permissions${identityFlag}${behaviorsFlag}${sessionContextFlag}${cleanupSuffix}`;
-  }
-  const spawnResult = transport.spawn(sessionName, {
-    cwd: spawnCwd,
-    command: spawnCommand
-  });
-  if (spawnResult.error) {
-    return { sessionName, error: `tmux new-session failed: ${spawnResult.error}` };
-  }
-  transport.pipeLog(sessionName, logFile);
-  try {
-    const mySession = getMySession();
-    const dispatchInfo = path15.join(SESSION_CACHE, `dispatch-info-${sessionName}.json`);
-    writeFileSync4(dispatchInfo, JSON.stringify({
-      dispatchedBy: mySession,
-      rootExe: exeSession,
-      provider: useBinSymlink ? ccProvider : useExeAgent ? opts.provider : "anthropic",
-      createdAt: (/* @__PURE__ */ new Date()).toISOString()
-    }));
-  } catch {
-  }
-  let booted = false;
-  for (let i = 0; i < 30; i++) {
-    try {
-      execSync8("sleep 1");
-    } catch {
-    }
-    try {
-      const pane = transport.capturePane(sessionName);
-      if (useExeAgent) {
-        if (pane.includes("[exe-agent]") || pane.includes("online")) {
-          booted = true;
-          break;
-        }
-      } else {
-        if (pane.includes("Claude Code") || pane.includes("\u276F")) {
-          booted = true;
-          break;
-        }
-      }
-    } catch {
-    }
-  }
-  if (!booted) {
-    return { sessionName, error: `${useExeAgent ? "exe-agent" : "claude"} did not boot within 30s` };
-  }
-  if (!useExeAgent) {
-    try {
-      transport.sendKeys(sessionName, `/exe-call ${employeeName}`);
-    } catch {
-    }
-  }
-  registerSession({
-    windowName: sessionName,
-    agentId: employeeName,
-    projectDir: spawnCwd,
-    parentExe: exeSession,
-    pid: 0,
-    registeredAt: (/* @__PURE__ */ new Date()).toISOString()
-  });
-  return { sessionName };
-}
-var SESSION_CACHE, BEHAVIORS_EXPORT_TIMEOUT_MS, INTERCOM_DEBOUNCE_MS, INTERCOM_LOG2, DEBOUNCE_FILE, DEBOUNCE_CLEANUP_AGE_MS, BUSY_PATTERN, INTERCOM_POLL_INTERVAL_S, INTERCOM_POLL_MAX_ATTEMPTS;
-var init_tmux_routing = __esm({
-  "src/lib/tmux-routing.ts"() {
-    "use strict";
-    init_session_registry();
-    init_session_key();
-    init_transport();
-    init_cc_agent_support();
-    init_mcp_prefix();
-    init_provider_table();
-    init_intercom_queue();
-    init_plan_limits();
-    init_worktree();
-    SESSION_CACHE = path15.join(os5.homedir(), ".exe-os", "session-cache");
-    BEHAVIORS_EXPORT_TIMEOUT_MS = 1e4;
-    INTERCOM_DEBOUNCE_MS = 3e4;
-    INTERCOM_LOG2 = path15.join(os5.homedir(), ".exe-os", "intercom.log");
-    DEBOUNCE_FILE = path15.join(SESSION_CACHE, "intercom-debounce.json");
-    DEBOUNCE_CLEANUP_AGE_MS = 5 * 60 * 1e3;
-    BUSY_PATTERN = /[✻✽✶✳·].*…|Running…/;
-    INTERCOM_POLL_INTERVAL_S = 1;
-    INTERCOM_POLL_MAX_ATTEMPTS = 8;
-  }
-});
-
-// src/lib/tasks-review.ts
-import path16 from "path";
-import { existsSync as existsSync15, readdirSync as readdirSync3, unlinkSync as unlinkSync3 } from "fs";
-async function countPendingReviews() {
-  const client = getClient();
-  const result = await client.execute({
-    sql: "SELECT COUNT(*) as cnt FROM tasks WHERE status = 'needs_review'",
-    args: []
-  });
-  return Number(result.rows[0]?.cnt) || 0;
-}
-async function countNewPendingReviewsSince(sinceIso) {
-  const client = getClient();
-  const result = await client.execute({
-    sql: `SELECT COUNT(*) as cnt FROM tasks
-          WHERE status = 'needs_review' AND updated_at > ?`,
-    args: [sinceIso]
-  });
-  return Number(result.rows[0]?.cnt) || 0;
-}
-async function listPendingReviews(limit) {
-  const client = getClient();
-  const result = await client.execute({
-    sql: `SELECT title, assigned_to, project_name FROM tasks
-          WHERE status = 'needs_review'
-          ORDER BY priority ASC, created_at DESC LIMIT ?`,
-    args: [limit]
-  });
-  return result.rows;
-}
-function getReviewChecklist(role, agent, taskSlug) {
-  const roleLower = role.toLowerCase();
-  if (roleLower.includes("engineer") || roleLower === "principal engineer") {
-    return {
-      lens: "Code Quality (Engineer)",
-      checklist: [
-        "1. Do all tests pass? Any new tests needed?",
-        "2. Is the code clean \u2014 no dead code, no TODOs left?",
-        "3. Does it follow existing patterns and conventions in the codebase?",
-        "4. Any regressions in the test suite?"
-      ]
-    };
-  }
-  if (roleLower === "cto" || roleLower.includes("architect")) {
-    return {
-      lens: "Architecture (CTO)",
-      checklist: [
-        "1. Does this fit the existing architecture? Consistent with ARCHITECTURE.md?",
-        "2. Is it backward compatible? Any breaking changes?",
-        "3. Does it introduce technical debt? Is that debt justified?",
-        "4. Security implications? Any new attack surface?",
-        "5. Does it scale? Performance considerations?",
-        "6. Coordination: does this affect other employees' work or other projects?"
-      ]
-    };
-  }
-  if (roleLower === "coo" || roleLower.includes("operations")) {
-    return {
-      lens: "Strategic (COO)",
-      checklist: [
-        "1. Does this serve the project mission?",
-        "2. Is this the right work at the right time?",
-        "3. Does the architectural assessment make sense for the business?",
-        "4. Any cross-project implications?"
-      ]
-    };
-  }
-  return {
-    lens: "General",
-    checklist: [
-      "1. Read the original task's acceptance criteria",
-      `2. Check git log for related commits: \`git log --oneline --author-date-order -10\``,
-      "3. Verify code changes match requirements",
-      "4. Check if tests were added/updated",
-      `5. Look for output files in exe/output/${agent}-${taskSlug}*`
-    ]
-  };
-}
-async function cleanupReviewFile(row, taskFile, _baseDir) {
-  if (String(row.assigned_by) !== "system" || !taskFile.includes("review-")) return;
-  try {
-    const client = getClient();
-    const fileName = taskFile.split("/").pop() ?? "";
-    const reviewPrefix = fileName.replace(".md", "");
-    const parts = reviewPrefix.split("-");
-    if (parts.length >= 3 && parts[0] === "review") {
-      const agent = parts[1];
-      const slug = parts.slice(2).join("-");
-      const originalTaskFile = `exe/${agent}/${slug}.md`;
-      const result = await client.execute({
-        sql: "UPDATE tasks SET status = 'done', updated_at = ? WHERE task_file = ? AND status = 'needs_review'",
-        args: [(/* @__PURE__ */ new Date()).toISOString(), originalTaskFile]
-      });
-      if (result.rowsAffected > 0) {
-        process.stderr.write(
-          `[review-cleanup] Cascaded original task to done: ${originalTaskFile}
-`
-        );
-      }
-    }
-  } catch (err) {
-    process.stderr.write(
-      `[review-cleanup] Failed to cascade original task: ${err instanceof Error ? err.message : String(err)}
-`
-    );
-  }
-  try {
-    const cacheDir = path16.join(EXE_AI_DIR, "session-cache");
-    if (existsSync15(cacheDir)) {
-      for (const f of readdirSync3(cacheDir)) {
-        if (f.startsWith("review-notified-")) {
-          unlinkSync3(path16.join(cacheDir, f));
-        }
-      }
-    }
-  } catch {
-  }
-}
-var init_tasks_review = __esm({
-  "src/lib/tasks-review.ts"() {
-    "use strict";
-    init_database();
-    init_config();
-    init_employees();
-    init_notifications();
-    init_tasks_crud();
-    init_tmux_routing();
-    init_session_key();
-  }
-});
-
-// src/lib/tasks-chain.ts
-import path17 from "path";
-import { readFile as readFile4, writeFile as writeFile5 } from "fs/promises";
-async function cascadeUnblock(taskId, baseDir, now) {
-  const client = getClient();
-  const unblocked = await client.execute({
-    sql: `UPDATE tasks SET status = 'open', blocked_by = NULL, updated_at = ?
-          WHERE blocked_by = ? AND status = 'blocked'`,
-    args: [now, taskId]
-  });
-  if (baseDir && unblocked.rowsAffected > 0) {
-    const unblockedRows = await client.execute({
-      sql: `SELECT task_file FROM tasks WHERE blocked_by IS NULL AND updated_at = ?`,
-      args: [now]
-    });
-    for (const ur of unblockedRows.rows) {
-      try {
-        const ubFile = path17.join(baseDir, String(ur.task_file));
-        let ubContent = await readFile4(ubFile, "utf-8");
-        ubContent = ubContent.replace(/\*\*Status:\*\* blocked/, "**Status:** open");
-        ubContent = ubContent.replace(/\n\*\*Blocked by:\*\*.*\n/, "\n");
-        await writeFile5(ubFile, ubContent, "utf-8");
-      } catch {
-      }
-    }
-  }
-}
-async function findNextTask(assignedTo) {
-  const client = getClient();
-  const nextResult = await client.execute({
-    sql: `SELECT title, task_file, priority FROM tasks
-          WHERE assigned_to = ? AND status = 'open'
-          ORDER BY priority ASC, created_at ASC
-          LIMIT 1`,
-    args: [assignedTo]
-  });
-  if (nextResult.rows.length === 1) {
-    const nr = nextResult.rows[0];
-    return {
-      title: String(nr.title),
-      priority: String(nr.priority),
-      taskFile: String(nr.task_file)
-    };
-  }
-  return void 0;
-}
-async function checkSubtaskCompletion(parentTaskId, projectName) {
-  const client = getClient();
-  const remaining = await client.execute({
-    sql: `SELECT COUNT(*) as cnt FROM tasks
-          WHERE parent_task_id = ? AND status NOT IN ('done', 'cancelled')`,
-    args: [parentTaskId]
-  });
-  const cnt = Number(remaining.rows[0]?.cnt ?? 1);
-  if (cnt === 0) {
-    const parentRow = await client.execute({
-      sql: `SELECT assigned_to, title, task_file, project_name FROM tasks WHERE id = ?`,
-      args: [parentTaskId]
-    });
-    if (parentRow.rows.length === 1) {
-      const pr = parentRow.rows[0];
-      const parentProject = pr.project_name == null ? projectName : String(pr.project_name);
-      await writeNotification({
-        agentId: String(pr.assigned_to),
-        agentRole: "system",
-        event: "subtasks_complete",
-        project: parentProject,
-        summary: `All subtasks complete for "${String(pr.title)}" \u2014 ready for rollup review`,
-        taskFile: String(pr.task_file)
-      });
-    }
-  }
-}
-var init_tasks_chain = __esm({
-  "src/lib/tasks-chain.ts"() {
-    "use strict";
-    init_database();
-    init_notifications();
-  }
-});
-
-// src/lib/session-scope.ts
-var session_scope_exports = {};
-__export(session_scope_exports, {
-  assertSessionScope: () => assertSessionScope,
-  findSessionForProject: () => findSessionForProject,
-  getSessionProject: () => getSessionProject
-});
-function getSessionProject(sessionName) {
-  const sessions = listSessions();
-  const entry = sessions.find((s) => s.windowName === sessionName);
-  if (!entry) return null;
-  const parts = entry.projectDir.split("/").filter(Boolean);
-  return parts[parts.length - 1] ?? null;
-}
-function findSessionForProject(projectName) {
-  const sessions = listSessions();
-  for (const s of sessions) {
-    const proj = s.projectDir.split("/").filter(Boolean).pop();
-    if (proj === projectName && s.agentId === "exe") return s;
-  }
-  return null;
-}
-function assertSessionScope(actionType, targetProject) {
-  try {
-    const currentProject = getProjectName();
-    const exeSession = resolveExeSession();
-    if (!exeSession) {
-      return { allowed: true, reason: "no_session" };
-    }
-    if (currentProject === targetProject) {
-      return {
-        allowed: true,
-        reason: "same_session",
-        currentProject,
-        targetProject
-      };
-    }
-    process.stderr.write(
-      `[session-scope] Cross-project ${actionType}: session project="${currentProject}" \u2260 target project="${targetProject}"
-`
-    );
-    return {
-      allowed: true,
-      // v1: warn-only, don't block
-      reason: "cross_session_granted",
-      currentProject,
-      targetProject,
-      targetSession: findSessionForProject(targetProject)?.windowName
-    };
-  } catch {
-    return { allowed: true, reason: "no_session" };
-  }
-}
-var init_session_scope = __esm({
-  "src/lib/session-scope.ts"() {
-    "use strict";
-    init_session_registry();
-    init_project_name();
-    init_tmux_routing();
-  }
-});
-
-// src/lib/tasks-notify.ts
-async function dispatchTaskToEmployee(input2) {
-  if (input2.assignedTo === "exe") return { dispatched: "skipped" };
-  let crossProject = false;
-  if (input2.projectName) {
-    try {
-      const { assertSessionScope: assertSessionScope2 } = (init_session_scope(), __toCommonJS(session_scope_exports));
-      const check = assertSessionScope2("dispatch_task", input2.projectName);
-      if (check.reason === "cross_session_granted") {
-        crossProject = true;
-      }
-    } catch {
-    }
-  }
-  try {
-    const transport = getTransport();
-    const exeSession = resolveExeSession();
-    if (!exeSession) return { dispatched: "session_missing" };
-    const sessionName = employeeSessionName(input2.assignedTo, exeSession);
-    if (transport.isAlive(sessionName)) {
-      const result = sendIntercom(sessionName);
-      const dispatched = result === "acknowledged" || result === "debounced" || result === "queued" ? "verified" : result === "delivered" ? "sent_unverified" : "session_dead";
-      return { dispatched, session: sessionName, crossProject };
-    } else {
-      const projectDir = input2.projectDir ?? process.cwd();
-      const result = ensureEmployee(input2.assignedTo, exeSession, projectDir);
-      if (result.status === "failed") {
-        process.stderr.write(
-          `[dispatch] Failed to spawn ${input2.assignedTo}: ${result.error}
-`
-        );
-        return { dispatched: "session_missing" };
-      }
-      return { dispatched: "spawned", session: result.sessionName, crossProject };
-    }
-  } catch {
-    return { dispatched: "session_missing" };
-  }
-}
-function notifyTaskDone() {
-  try {
-    const key = getSessionKey();
-    if (key && !process.env.VITEST) notifyParentExe(key);
-  } catch {
-  }
-}
-async function markTaskNotificationsRead(taskFile) {
-  try {
-    await markAsReadByTaskFile(taskFile);
-  } catch {
-  }
-}
-var init_tasks_notify = __esm({
-  "src/lib/tasks-notify.ts"() {
-    "use strict";
-    init_tmux_routing();
-    init_session_key();
-    init_notifications();
-    init_transport();
-  }
-});
-
-// src/lib/behaviors.ts
-import crypto5 from "crypto";
-async function storeBehavior(opts) {
-  const client = getClient();
-  const id = crypto5.randomUUID();
-  const now = (/* @__PURE__ */ new Date()).toISOString();
-  await client.execute({
-    sql: `INSERT INTO behaviors (id, agent_id, project_name, domain, priority, content, active, created_at, updated_at)
-          VALUES (?, ?, ?, ?, ?, ?, 1, ?, ?)`,
-    args: [id, opts.agentId, opts.projectName ?? null, opts.domain ?? null, opts.priority ?? "p1", opts.content, now, now]
-  });
-  return id;
-}
-var init_behaviors = __esm({
-  "src/lib/behaviors.ts"() {
-    "use strict";
-    init_database();
-  }
-});
-
-// src/lib/skill-learning.ts
-var skill_learning_exports = {};
-__export(skill_learning_exports, {
-  captureAndLearn: () => captureAndLearn,
-  captureTrajectory: () => captureTrajectory,
-  editDistance: () => editDistance,
-  extractSkill: () => extractSkill,
-  extractTrajectory: () => extractTrajectory,
-  findSimilarTrajectories: () => findSimilarTrajectories,
-  hashSignature: () => hashSignature,
-  storeTrajectory: () => storeTrajectory,
-  sweepTrajectories: () => sweepTrajectories
-});
-import crypto6 from "crypto";
-async function extractTrajectory(taskId, agentId) {
-  const client = getClient();
-  const result = await client.execute({
-    sql: `SELECT tool_name, raw_text
-          FROM memories
-          WHERE task_id = ? AND agent_id = ?
-          ORDER BY timestamp ASC`,
-    args: [taskId, agentId]
-  });
-  if (result.rows.length === 0) return [];
-  const rawTools = result.rows.map((r) => {
-    const toolName = String(r.tool_name);
-    if (toolName === "Bash") {
-      const text = String(r.raw_text);
-      const cmdMatch = text.match(/(?:command|Command).*?[:\s]+"?(\w+)/);
-      return cmdMatch ? `Bash:${cmdMatch[1]}` : "Bash";
-    }
-    return toolName;
-  });
-  const signature = [];
-  for (const tool of rawTools) {
-    if (signature.length === 0 || signature[signature.length - 1] !== tool) {
-      signature.push(tool);
-    }
-  }
-  return signature;
-}
-function hashSignature(signature) {
-  return crypto6.createHash("sha256").update(signature.join("|")).digest("hex").slice(0, 16);
-}
-async function storeTrajectory(opts) {
-  const client = getClient();
-  const id = crypto6.randomUUID();
-  const now = (/* @__PURE__ */ new Date()).toISOString();
-  const signatureHash = hashSignature(opts.signature);
-  await client.execute({
-    sql: `INSERT INTO trajectories (id, task_id, agent_id, project_name, task_title, signature, signature_hash, tool_count, created_at)
-          VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`,
-    args: [
-      id,
-      opts.taskId,
-      opts.agentId,
-      opts.projectName,
-      opts.taskTitle,
-      JSON.stringify(opts.signature),
-      signatureHash,
-      opts.signature.length,
-      now
-    ]
-  });
-  return id;
-}
-async function findSimilarTrajectories(signature, threshold = DEFAULT_SKILL_THRESHOLD) {
-  const client = getClient();
-  const hash = hashSignature(signature);
-  const result = await client.execute({
-    sql: `SELECT id, task_id, agent_id, project_name, task_title, signature, signature_hash, tool_count, skill_id, created_at
-          FROM trajectories
-          WHERE signature_hash = ?
-          ORDER BY created_at DESC
-          LIMIT 20`,
-    args: [hash]
-  });
-  const mapRow = (r) => ({
-    id: String(r.id),
-    taskId: String(r.task_id),
-    agentId: String(r.agent_id),
-    projectName: String(r.project_name),
-    taskTitle: String(r.task_title),
-    signature: JSON.parse(String(r.signature)),
-    signatureHash: String(r.signature_hash),
-    toolCount: Number(r.tool_count),
-    skillId: r.skill_id ? String(r.skill_id) : null,
-    createdAt: String(r.created_at)
-  });
-  const matches = result.rows.map(mapRow);
-  if (matches.length >= threshold) return matches;
-  const nearResult = await client.execute({
-    sql: `SELECT id, task_id, agent_id, project_name, task_title, signature, signature_hash, tool_count, skill_id, created_at
-          FROM trajectories
-          WHERE tool_count BETWEEN ? AND ?
-            AND signature_hash != ?
-          ORDER BY created_at DESC
-          LIMIT 50`,
-    args: [
-      Math.max(1, signature.length - 3),
-      signature.length + 3,
-      hash
-    ]
-  });
-  for (const r of nearResult.rows) {
-    const candidateSig = JSON.parse(String(r.signature));
-    if (editDistance(signature, candidateSig) <= 2) {
-      matches.push(mapRow(r));
-    }
-  }
-  return matches;
-}
-async function captureTrajectory(opts) {
-  const signature = await extractTrajectory(opts.taskId, opts.agentId);
-  if (signature.length < 3) {
-    return { trajectoryId: "", similarCount: 0, similar: [] };
-  }
-  const trajectoryId = await storeTrajectory({
-    taskId: opts.taskId,
-    agentId: opts.agentId,
-    projectName: opts.projectName,
-    taskTitle: opts.taskTitle,
-    signature
-  });
-  const similar = await findSimilarTrajectories(
-    signature,
-    opts.skillThreshold ?? DEFAULT_SKILL_THRESHOLD
-  );
-  return { trajectoryId, similarCount: similar.length, similar };
-}
-function buildExtractionPrompt(trajectories) {
-  const items = trajectories.map((t, i) => {
-    const sig = t.signature.join(" \u2192 ");
-    return `Task ${i + 1}: "${t.taskTitle}" (${t.agentId}, ${t.projectName}) \u2014 ${t.toolCount} tool calls
-Signature: ${sig}`;
-  }).join("\n\n");
-  return `You are analyzing ${trajectories.length} completed tasks that followed similar procedures:
-
-${items}
-
-Extract the reusable procedure. Format your response EXACTLY like this:
-
-SKILL: {name \u2014 short, descriptive}
-TRIGGER: {when to use this \u2014 one sentence}
-STEPS:
-1. ...
-2. ...
-PITFALLS: {common mistakes to avoid}
-
-Be specific and actionable. Include tool names, file patterns, and concrete commands where applicable.`;
-}
-async function extractSkill(trajectories, model) {
-  if (trajectories.length === 0) return null;
-  const config = await loadConfig();
-  const skillModel = model ?? config.skillModel;
-  const Anthropic = (await import("@anthropic-ai/sdk")).default;
-  const client = new Anthropic();
-  const prompt = buildExtractionPrompt(trajectories);
-  const response = await client.messages.create({
-    model: skillModel,
-    max_tokens: 500,
-    messages: [{ role: "user", content: prompt }]
-  });
-  const textBlock = response.content.find((b) => b.type === "text");
-  const skillText = textBlock?.text;
-  if (!skillText) return null;
-  const agentId = trajectories[0].agentId;
-  const projectName = trajectories[0].projectName;
-  const skillId = await storeBehavior({
-    agentId,
-    content: skillText,
-    domain: "skill",
-    projectName
-  });
-  const dbClient = getClient();
-  for (const t of trajectories) {
-    await dbClient.execute({
-      sql: "UPDATE trajectories SET skill_id = ? WHERE id = ?",
-      args: [skillId, t.id]
-    });
-  }
-  process.stderr.write(
-    `[skill-learning] Skill extracted from ${trajectories.length} trajectories \u2192 behavior ${skillId}
-`
-  );
-  return skillId;
-}
-async function captureAndLearn(opts) {
-  try {
-    const config = await loadConfig();
-    if (!config.skillLearning) return;
-    const { trajectoryId, similarCount, similar } = await captureTrajectory({
-      ...opts,
-      skillThreshold: config.skillThreshold
-    });
-    if (!trajectoryId) return;
-    if (similarCount >= config.skillThreshold) {
-      const unprocessed = similar.filter((t) => !t.skillId);
-      if (unprocessed.length >= config.skillThreshold) {
-        extractSkill(unprocessed, config.skillModel).catch((err) => {
-          process.stderr.write(
-            `[skill-learning] Extraction failed: ${err instanceof Error ? err.message : String(err)}
-`
-          );
-        });
-      }
-    }
-  } catch (err) {
-    process.stderr.write(
-      `[skill-learning] captureAndLearn failed: ${err instanceof Error ? err.message : String(err)}
-`
-    );
-  }
-}
-async function sweepTrajectories(threshold, model) {
-  const config = await loadConfig();
-  if (!config.skillLearning) return { clustersProcessed: 0, skillsExtracted: 0 };
-  const t = threshold ?? config.skillThreshold;
-  const client = getClient();
-  const result = await client.execute({
-    sql: `SELECT signature_hash, COUNT(*) as cnt
-          FROM trajectories
-          WHERE skill_id IS NULL
-          GROUP BY signature_hash
-          HAVING cnt >= ?
-          ORDER BY cnt DESC
-          LIMIT 10`,
-    args: [t]
-  });
-  let clustersProcessed = 0;
-  let skillsExtracted = 0;
-  for (const row of result.rows) {
-    const hash = String(row.signature_hash);
-    const trajResult = await client.execute({
-      sql: `SELECT id, task_id, agent_id, project_name, task_title, signature, signature_hash, tool_count, created_at
-            FROM trajectories
-            WHERE signature_hash = ? AND skill_id IS NULL
-            ORDER BY created_at DESC
-            LIMIT 10`,
-      args: [hash]
-    });
-    const trajectories = trajResult.rows.map((r) => ({
-      id: String(r.id),
-      taskId: String(r.task_id),
-      agentId: String(r.agent_id),
-      projectName: String(r.project_name),
-      taskTitle: String(r.task_title),
-      signature: JSON.parse(String(r.signature)),
-      signatureHash: String(r.signature_hash),
-      toolCount: Number(r.tool_count),
-      skillId: null,
-      createdAt: String(r.created_at)
-    }));
-    if (trajectories.length >= t) {
-      clustersProcessed++;
-      const skillId = await extractSkill(trajectories, model ?? config.skillModel);
-      if (skillId) skillsExtracted++;
-    }
-  }
-  return { clustersProcessed, skillsExtracted };
-}
-function editDistance(a, b) {
-  const m = a.length;
-  const n = b.length;
-  const dp = Array.from({ length: m + 1 }, () => Array(n + 1).fill(0));
-  for (let i = 0; i <= m; i++) dp[i][0] = i;
-  for (let j = 0; j <= n; j++) dp[0][j] = j;
-  for (let i = 1; i <= m; i++) {
-    for (let j = 1; j <= n; j++) {
-      const cost = a[i - 1] === b[j - 1] ? 0 : 1;
-      dp[i][j] = Math.min(
-        dp[i - 1][j] + 1,
-        dp[i][j - 1] + 1,
-        dp[i - 1][j - 1] + cost
-      );
-    }
-  }
-  return dp[m][n];
-}
-var DEFAULT_SKILL_THRESHOLD;
-var init_skill_learning = __esm({
-  "src/lib/skill-learning.ts"() {
-    "use strict";
-    init_database();
-    init_behaviors();
-    init_config();
-    DEFAULT_SKILL_THRESHOLD = 3;
-  }
-});
-
-// src/lib/tasks.ts
-var tasks_exports = {};
-__export(tasks_exports, {
-  countNewPendingReviewsSince: () => countNewPendingReviewsSince,
-  countPendingReviews: () => countPendingReviews,
-  createTask: () => createTask,
-  createTaskCore: () => createTaskCore,
-  deleteTask: () => deleteTask,
-  deleteTaskCore: () => deleteTaskCore,
-  ensureArchitectureDoc: () => ensureArchitectureDoc,
-  ensureGitignoreExe: () => ensureGitignoreExe,
-  getReviewChecklist: () => getReviewChecklist,
-  listPendingReviews: () => listPendingReviews,
-  listTasks: () => listTasks,
-  resolveTask: () => resolveTask,
-  slugify: () => slugify,
-  updateTask: () => updateTask,
-  updateTaskStatus: () => updateTaskStatus
-});
-import path18 from "path";
-import { writeFileSync as writeFileSync5, mkdirSync as mkdirSync7, unlinkSync as unlinkSync4 } from "fs";
-async function createTask(input2) {
-  const result = await createTaskCore(input2);
-  if (!input2.skipDispatch && result.status !== "blocked" && !process.env.VITEST) {
-    dispatchTaskToEmployee({
-      assignedTo: input2.assignedTo,
-      title: input2.title,
-      priority: input2.priority,
-      taskFile: result.taskFile,
-      initialStatus: result.status,
-      projectName: input2.projectName
-    });
-  }
-  return result;
-}
-async function updateTask(input2) {
-  const { row, taskFile, now, taskId } = await updateTaskStatus(input2);
-  try {
-    const agent = String(row.assigned_to);
-    const cacheDir = path18.join(EXE_AI_DIR, "session-cache");
-    const cachePath = path18.join(cacheDir, `current-task-${agent}.json`);
-    if (input2.status === "in_progress") {
-      mkdirSync7(cacheDir, { recursive: true });
-      writeFileSync5(cachePath, JSON.stringify({ taskId, title: String(row.title) }));
-    } else if (input2.status === "done" || input2.status === "blocked" || input2.status === "cancelled") {
-      try {
-        unlinkSync4(cachePath);
-      } catch {
-      }
-    }
-  } catch {
-  }
-  if (input2.status === "done") {
-    await cleanupReviewFile(row, taskFile, input2.baseDir);
-  }
-  if (input2.status === "done" || input2.status === "cancelled") {
-    try {
-      const client = getClient();
-      const taskTitle = String(row.title);
-      await client.execute({
-        sql: `UPDATE tasks SET status = 'cancelled', updated_at = ?
-              WHERE title LIKE ? AND status IN ('open', 'in_progress')`,
-        args: [now, `%left%${taskTitle}%in_progress`]
-      });
-    } catch {
-    }
-  }
-  const isTerminal = input2.status === "done" || input2.status === "needs_review";
-  if (isTerminal) {
-    const isExe = String(row.assigned_to) === "exe";
-    if (!isExe) {
-      notifyTaskDone();
-    }
-    await markTaskNotificationsRead(taskFile);
-    if (input2.status === "done") {
-      try {
-        await cascadeUnblock(taskId, input2.baseDir, now);
-      } catch {
-      }
-      if (row.parent_task_id) {
-        try {
-          await checkSubtaskCompletion(String(row.parent_task_id), String(row.project_name));
-        } catch {
-        }
-      }
-    }
-  }
-  if (input2.status === "done" && String(row.assigned_to) !== "exe" && !process.env.VITEST) {
-    Promise.resolve().then(() => (init_skill_learning(), skill_learning_exports)).then(
-      ({ captureAndLearn: captureAndLearn2 }) => captureAndLearn2({
-        taskId,
-        agentId: String(row.assigned_to),
-        projectName: String(row.project_name),
-        taskTitle: String(row.title)
-      })
-    ).catch((err) => {
-      process.stderr.write(
-        `[updateTask] skill learning failed: ${err instanceof Error ? err.message : String(err)}
-`
-      );
-    });
-  }
-  let nextTask;
-  if (isTerminal && String(row.assigned_to) !== "exe") {
-    try {
-      nextTask = await findNextTask(String(row.assigned_to));
-    } catch {
-    }
-  }
-  return {
-    id: String(row.id),
-    title: String(row.title),
-    assignedTo: String(row.assigned_to),
-    assignedBy: String(row.assigned_by),
-    projectName: String(row.project_name),
-    priority: String(row.priority),
-    status: input2.status,
-    taskFile,
-    createdAt: String(row.created_at),
-    updatedAt: now,
-    nextTask
-  };
-}
-async function deleteTask(taskId, baseDir) {
-  const client = getClient();
-  const { taskFile, assignedTo, assignedBy, taskSlug } = await deleteTaskCore(taskId, baseDir);
-  const reviewer = assignedBy || "exe";
-  const reviewSlug = `review-${assignedTo}-${taskSlug}`;
-  const reviewFile = `exe/${reviewer}/${reviewSlug}.md`;
-  await client.execute({
-    sql: "DELETE FROM tasks WHERE task_file = ? OR task_file = ?",
-    args: [reviewFile, `exe/exe/${reviewSlug}.md`]
-  });
-  await markAsReadByTaskFile(taskFile);
-  await markAsReadByTaskFile(reviewFile);
-}
-var init_tasks = __esm({
-  "src/lib/tasks.ts"() {
-    "use strict";
-    init_database();
-    init_config();
-    init_notifications();
-    init_tasks_crud();
-    init_tasks_review();
-    init_tasks_crud();
-    init_tasks_chain();
-    init_tasks_review();
-    init_tasks_notify();
-  }
-});
-
-// src/adapters/claude/hooks/ingest-worker.ts
-import crypto7 from "crypto";
-import { execSync as execSync9 } from "child_process";
-import { mkdirSync as mkdirSync8, writeFileSync as writeFileSync6 } from "fs";
-import path19 from "path";
-
-// src/lib/error-detector.ts
-init_mcp_prefix();
-import crypto from "crypto";
-var ERROR_PATTERNS = [
-  /\bError\b/i,
-  /\bERR!\b/,
-  /\bFAIL(ED|URE)?\b/i,
-  /\bException\b/i,
-  /\bTraceback\b/,
-  /\bpanic\b/,
-  /\bSIGSEGV\b/,
-  /\bSIGABRT\b/,
-  /exit code [1-9]/i,
-  /non-zero (exit|status)/i,
-  /command not found/i,
-  /permission denied/i,
-  /ENOENT/,
-  /EACCES/,
-  /ENOMEM/
-];
-var FILE_CONTENT_TOOLS = /* @__PURE__ */ new Set([
-  "Read",
-  "Write",
-  "Edit",
-  "Glob",
-  "Grep",
-  "NotebookEdit"
-]);
-var STDERR_IGNORE_PATTERNS = [
-  /^warning\b/i,
-  /\bDeprecationWarning\b/,
-  /^hint:/i,
-  /^npm warn\b/i,
-  /^npm notice\b/i,
-  /^\(node:\d+\) \w*Warning:/,
-  /^Cloning into/,
-  /^Already on/,
-  /^Switched to/,
-  /^Your branch is/,
-  /^Auto-merging/,
-  /^\s*$/
-];
-function isRealStderr(stderr) {
-  const lines = stderr.trim().split("\n");
-  const meaningful = lines.filter(
-    (line) => line.trim().length > 0 && !STDERR_IGNORE_PATTERNS.some((p) => p.test(line))
-  );
-  return meaningful.length > 0;
-}
-function logSuppression(exitCode, stderr, stdout) {
-  process.stderr.write(
-    `[error-detector] suppressed bash non-zero exit: code=${exitCode} stderr_len=${stderr.length} stdout_len=${stdout.length}
-`
-  );
-}
-function detectError(data) {
-  const response = data.tool_response;
-  if (!response) return false;
-  const toolName = data.tool_name ?? "";
-  if (FILE_CONTENT_TOOLS.has(toolName)) {
-    return response.type === "error" || response.error != null;
-  }
-  if (toolName === "Bash") {
-    const exitCode = typeof response.exitCode === "number" ? response.exitCode : 0;
-    const stderr = typeof response.stderr === "string" ? response.stderr : "";
-    const stdout = typeof response.stdout === "string" ? response.stdout : "";
-    if (exitCode === 141) {
-      logSuppression(exitCode, stderr, stdout);
-      return false;
-    }
-    if (stderr.trim().length > 0 && isRealStderr(stderr)) return true;
-    if (exitCode !== 0 && !isRealStderr(stderr) && stdout.trim().length > 0) {
-      logSuppression(exitCode, stderr, stdout);
-      return false;
-    }
-    if (exitCode !== 0) return true;
-    return false;
-  }
-  if (response.type === "error" || response.error != null || response.isError === true) {
-    return true;
-  }
-  if (typeof response.stderr === "string" && response.stderr.trim().length > 0) {
-    if (isRealStderr(response.stderr)) return true;
-  }
-  const textParts = [];
-  if (typeof response.stdout === "string") textParts.push(response.stdout);
-  if (typeof response.output === "string") textParts.push(response.output);
-  if (typeof response.text === "string") textParts.push(response.text);
-  if (typeof response.message === "string") textParts.push(response.message);
-  if (textParts.length === 0) return false;
-  const text = textParts.join("\n");
-  return ERROR_PATTERNS.some((pattern) => pattern.test(text));
-}
-
-// src/lib/task-scanner.ts
-import { readdirSync, readFileSync, existsSync, statSync } from "fs";
-import { execSync } from "child_process";
-import path from "path";
-var STATUS_RE = /^\*\*Status:\*\*\s*(\w+)/m;
-var TITLE_RE = /^# (.+)/m;
-
-// src/adapters/claude/hooks/ingest-worker.ts
-init_project_name();
-
-// src/lib/store.ts
-init_memory();
-init_database();
-
-// src/lib/keychain.ts
-import { readFile, writeFile, unlink, mkdir, chmod } from "fs/promises";
-import { existsSync as existsSync2 } from "fs";
-import path3 from "path";
-import crypto2 from "crypto";
-var SERVICE = "exe-mem";
-var ACCOUNT = "master-key";
-function getKeyDir() {
-  return process.env.EXE_OS_DIR ?? process.env.EXE_MEM_DIR ?? path3.join(process.env.HOME ?? "/tmp", ".exe-os");
-}
-function getKeyPath() {
-  return path3.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 (!existsSync2(keyPath)) {
-    return null;
-  }
-  try {
-    const content = await readFile(keyPath, "utf-8");
-    return Buffer.from(content.trim(), "base64");
-  } catch {
-    return null;
-  }
-}
-
-// src/lib/store.ts
-init_config();
-var _pendingRecords = [];
-var _batchSize = 20;
-var _flushIntervalMs = 1e4;
-var _flushTimer = null;
-var _flushing = false;
-var _nextVersion = 1;
-async function initStore(options) {
-  if (_flushTimer !== null) {
-    clearInterval(_flushTimer);
-    _flushTimer = null;
-  }
-  _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 vectorToBlob(vector) {
-  const f32 = vector instanceof Float32Array ? vector : new Float32Array(vector);
-  return JSON.stringify(Array.from(f32));
-}
-
-// src/adapters/claude/hooks/ingest-worker.ts
-init_notifications();
-
-// src/lib/content-extractor.ts
-init_mcp_prefix();
-var MAX_CONTENT = 2e3;
-var MAX_OUTPUT = 1e3;
-function extractSemanticText(toolName, toolInput, toolResponse) {
-  switch (toolName) {
-    case "Write":
-      return extractWrite(toolInput);
-    case "Edit":
-      return extractEdit(toolInput);
-    case "Read":
-      return extractRead(toolInput, toolResponse);
-    case "Bash":
-      return extractBash(toolInput, toolResponse);
-    case "Grep":
-      return extractGrep(toolInput, toolResponse);
-    case "Glob":
-      return extractGlob(toolInput, toolResponse);
-    default:
-      if (isExeMcpTool(toolName)) {
-        return extractExeMemMcp(toolName, toolInput, toolResponse);
-      }
-      if (toolName.startsWith("mcp__")) {
-        return extractGenericMcp(toolName, toolInput, toolResponse);
-      }
-      return extractDefault(toolName, toolInput, toolResponse);
-  }
-}
-function findContainingChunk(filePath, snippet) {
-  try {
-    const ext = filePath.split(".").pop()?.toLowerCase();
-    if (ext !== "ts" && ext !== "tsx" && ext !== "js" && ext !== "jsx") return "";
-    const { readFileSync: readFileSync12 } = __require("fs");
-    const source = readFileSync12(filePath, "utf8");
-    const lines = source.split("\n");
-    const lowerSnippet = snippet.toLowerCase().slice(0, 80);
-    let matchLine = -1;
-    for (let i = 0; i < lines.length; i++) {
-      if (lines[i].toLowerCase().includes(lowerSnippet)) {
-        matchLine = i;
-        break;
-      }
-    }
-    if (matchLine === -1) return "";
-    for (let i = matchLine; i >= 0; i--) {
-      const line = lines[i];
-      const fnMatch = line.match(/(?:export\s+)?(?:async\s+)?function\s+(\w+)/);
-      if (fnMatch) return `Function ${fnMatch[1]} in ${filePath}:${i + 1}`;
-      const classMatch = line.match(/(?:export\s+)?class\s+(\w+)/);
-      if (classMatch) return `Class ${classMatch[1]} in ${filePath}:${i + 1}`;
-      const arrowMatch = line.match(/(?:export\s+)?(?:const|let)\s+(\w+)\s*=\s*(?:async\s+)?\(/);
-      if (arrowMatch) return `Function ${arrowMatch[1]} in ${filePath}:${i + 1}`;
-    }
-  } catch {
-  }
-  return "";
-}
-function extractWrite(input2) {
-  const filePath = String(input2.file_path ?? "");
-  const content = String(input2.content ?? "");
-  const chunkContext = findContainingChunk(filePath, content.slice(0, 200));
-  const prefix = chunkContext ? `Wrote ${filePath} (${chunkContext})` : `Wrote ${filePath}`;
-  return `${prefix}
-${content.slice(0, MAX_CONTENT)}`;
-}
-function extractEdit(input2) {
-  const filePath = String(input2.file_path ?? "");
-  const oldStr = String(input2.old_string ?? "");
-  const newStr = String(input2.new_string ?? "");
-  const chunkContext = findContainingChunk(filePath, oldStr.slice(0, 200));
-  const prefix = chunkContext ? `Edited ${filePath} (${chunkContext})` : `Edited ${filePath}`;
-  return `${prefix}
-Removed: ${oldStr.slice(0, MAX_CONTENT / 2)}
-Added: ${newStr.slice(0, MAX_CONTENT / 2)}`;
-}
-function extractRead(input2, response) {
-  const filePath = String(input2.file_path ?? "");
-  const file = response.file;
-  const content = file ? String(file.content ?? "") : "";
-  if (!content) {
-    const text = String(response.text ?? response.content ?? "");
-    return `Read ${filePath}
-${text.slice(0, MAX_CONTENT)}`;
-  }
-  return `Read ${filePath}
-${content.slice(0, MAX_CONTENT)}`;
-}
-function extractBash(input2, response) {
-  const command = String(input2.command ?? "");
-  const description = input2.description ? String(input2.description) : "";
-  const stdout = String(response.stdout ?? response.text ?? "");
-  const stderr = String(response.stderr ?? "");
-  const parts = [description ? `${description}: ${command}` : `Ran: ${command}`];
-  if (stdout) parts.push(`Output: ${stdout.slice(0, MAX_OUTPUT)}`);
-  if (stderr && !stdout) parts.push(`Error: ${stderr.slice(0, MAX_OUTPUT)}`);
-  return parts.join("\n");
-}
-function extractGrep(input2, response) {
-  const pattern = String(input2.pattern ?? "");
-  const path20 = input2.path ? String(input2.path) : "";
-  const output = String(response.text ?? response.content ?? JSON.stringify(response).slice(0, MAX_OUTPUT));
-  return `Searched for "${pattern}"${path20 ? ` in ${path20}` : ""}
-${output.slice(0, MAX_OUTPUT)}`;
-}
-function extractGlob(input2, response) {
-  const pattern = String(input2.pattern ?? "");
-  const output = String(response.text ?? response.content ?? JSON.stringify(response).slice(0, MAX_OUTPUT));
-  return `Found files matching "${pattern}"
-${output.slice(0, MAX_OUTPUT)}`;
-}
-function extractExeMemMcp(toolName, input2, response) {
-  const shortName = stripExeMcpPrefix(toolName);
-  switch (shortName) {
-    case "store_memory": {
-      const text = String(input2.text ?? input2.query ?? "");
-      return `Stored memory: ${text.slice(0, MAX_CONTENT)}`;
-    }
-    case "recall_my_memory":
-    case "ask_team_memory": {
-      const query = String(input2.query ?? "");
-      const member = input2.team_member ? ` (from ${input2.team_member})` : "";
-      const resultText = extractResponseText(response);
-      return `Memory search${member}: "${query}"
-${resultText.slice(0, MAX_OUTPUT)}`;
-    }
-    case "create_task": {
-      const title = String(input2.title ?? "");
-      const assignedTo = String(input2.assigned_to ?? "");
-      const priority = String(input2.priority ?? "p1");
-      const context = String(input2.context ?? "");
-      return `Task created: "${title}" assigned to ${assignedTo} [${priority}]
-${context.slice(0, MAX_CONTENT)}`;
-    }
-    case "update_task": {
-      const taskId = String(input2.task_id ?? "");
-      const status = String(input2.status ?? "");
-      const result = input2.result ? String(input2.result) : "";
-      return `Task updated: ${taskId} \u2192 ${status}${result ? `
-Result: ${result.slice(0, MAX_CONTENT)}` : ""}`;
-    }
-    case "list_tasks": {
-      const resultText = extractResponseText(response);
-      return `Listed tasks
-${resultText.slice(0, MAX_OUTPUT)}`;
-    }
-    default: {
-      return extractGenericMcp(toolName, input2, response);
-    }
-  }
-}
-function extractGenericMcp(toolName, input2, response) {
-  const shortName = toolName.replace(/^mcp__[^_]+__/, "");
-  const inputParts = Object.entries(input2).filter(([, v]) => v != null && String(v).length > 0).map(([k, v]) => `${k}: ${String(v).slice(0, 200)}`).join(", ");
-  const resultText = extractResponseText(response);
-  return `${shortName}(${inputParts})
-${resultText.slice(0, MAX_OUTPUT)}`;
-}
-function extractDefault(toolName, input2, response) {
-  const inputStr = JSON.stringify(input2);
-  const resultText = extractResponseText(response);
-  return `Tool: ${toolName}
-${inputStr.slice(0, MAX_CONTENT / 2)}
-${resultText.slice(0, MAX_OUTPUT)}`;
-}
-function extractResponseText(response) {
-  if (typeof response.text === "string") return response.text;
-  if (typeof response.content === "string") return response.content;
-  if (Array.isArray(response.content)) {
-    return response.content.map((block) => {
-      if (typeof block === "object" && block !== null && "text" in block) {
-        return String(block.text);
-      }
-      return "";
-    }).filter(Boolean).join("\n");
-  }
-  if (Array.isArray(response)) {
-    return response.map((item) => {
-      if (typeof item === "object" && item !== null && "text" in item) {
-        return String(item.text);
-      }
-      return "";
-    }).filter(Boolean).join("\n");
-  }
-  return JSON.stringify(response).slice(0, MAX_OUTPUT);
-}
-
-// src/adapters/claude/hooks/ingest-worker.ts
-init_plan_limits();
-process.env.EXE_EMBED_PRIORITY = "low";
-function assignConfidence(toolName, agentId) {
-  if (agentId === "default") return 0.9;
-  if (toolName === "manual" || toolName === "mcp__exe-os__store_memory" || toolName === "mcp__exe-mem__store_memory")
-    return 0.9;
-  if (toolName === "consolidation") return 0.5;
-  if (toolName === "task-assignment") return 0.4;
-  return 0.7;
-}
-var input = "";
-process.stdin.setEncoding("utf8");
-process.stdin.on("data", (chunk) => {
-  input += chunk;
-});
-process.stdin.on("end", async () => {
-  try {
-    const data = JSON.parse(input);
-    const rawText = extractSemanticText(data.tool_name, data.tool_input, data.tool_response);
-    if (rawText.length < 50) {
-      process.exit(0);
-    }
-    await initStore();
-    try {
-      await assertMemoryLimit();
-    } catch (err) {
-      if (err instanceof PlanLimitError) {
-        process.stderr.write(`[ingest-worker] LIMIT: ${err.message}
-`);
-        process.exit(0);
-      }
-      process.stderr.write(`[ingest-worker] limit check skipped: ${err instanceof Error ? err.message : String(err)}
-`);
-    }
-    let vector;
-    let needsBackfill = false;
-    try {
-      const { embed: embed2 } = await Promise.resolve().then(() => (init_embedder(), embedder_exports));
-      vector = await embed2(rawText);
-    } catch (err) {
-      process.stderr.write(`[ingest-worker] EMBED FAILED: ${err instanceof Error ? err.message : String(err)}
-`);
-      vector = null;
-      needsBackfill = true;
-    }
-    let taskId = null;
-    try {
-      const { EXE_AI_DIR: exeDir } = await Promise.resolve().then(() => (init_config(), config_exports));
-      const agentId2 = process.env.AGENT_ID;
-      const cachePath = path19.join(exeDir, "session-cache", `current-task-${agentId2}.json`);
-      const { readFileSync: rf } = await import("fs");
-      const cached = JSON.parse(rf(cachePath, "utf8"));
-      taskId = cached.taskId ?? null;
-    } catch {
-    }
-    const agentId = process.env.AGENT_ID;
-    await writeMemory({
-      id: crypto7.randomUUID(),
-      agent_id: agentId,
-      agent_role: process.env.AGENT_ROLE ?? "unknown",
-      session_id: data.session_id,
-      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-      tool_name: data.tool_name,
-      project_name: getProjectName(data.cwd ?? process.cwd()),
-      has_error: detectError(data),
-      raw_text: rawText,
-      vector,
-      task_id: taskId,
-      confidence: assignConfidence(data.tool_name, agentId)
-    });
-    await flushBatch();
-    if (needsBackfill) {
-      try {
-        const { EXE_AI_DIR: exeDir } = await Promise.resolve().then(() => (init_config(), config_exports));
-        const flagPath = path19.join(exeDir, "session-cache", "needs-backfill");
-        writeFileSync6(flagPath, "1");
-      } catch (err) {
-        process.stderr.write(`[ingest-worker] backfill flag write failed: ${err instanceof Error ? err.message : String(err)}
-`);
-      }
-    }
-    const agentRole = process.env.AGENT_ROLE ?? "employee";
-    if (agentId !== "exe" && agentId !== "default" && (data.tool_name === "Edit" || data.tool_name === "Write")) {
-      const filePath = data.tool_input?.file_path ?? "";
-      const taskFileMatch = filePath.match(/exe\/([^/]+)\/([^/]+\.md)$/);
-      if (taskFileMatch) {
-        const content = data.tool_name === "Edit" ? data.tool_input?.new_string ?? "" : data.tool_input?.content ?? "";
-        const statusMatch = content.match(/\*\*Status:\*\*\s*(done|needs-fix)/i) ?? (data.tool_name === "Edit" ? content.match(/^\s*(done|needs-fix)\s*$/i) : null);
-        if (statusMatch) {
-          const status = statusMatch[1].toLowerCase();
-          const taskFile = `exe/${taskFileMatch[1]}/${taskFileMatch[2]}`;
-          const titleMatch = content.match(TITLE_RE);
-          const title = titleMatch?.[1] ?? taskFileMatch[2].replace(/\.md$/, "").replace(/-/g, " ");
-          await writeNotification({
-            agentId,
-            agentRole,
-            event: status === "done" ? "task_complete" : "task_needs_fix",
-            project: getProjectName(data.cwd ?? process.cwd()),
-            summary: title,
-            taskFile
-          });
-          if (status === "done") {
-            const cwd = data.cwd ?? process.cwd();
-            try {
-              execSync9("git add -u", { cwd, timeout: 1e4, stdio: "ignore" });
-              const msg = `task(${agentId}): ${title}`;
-              execSync9(`git commit --no-verify -m ${JSON.stringify(msg)}`, { cwd, timeout: 3e4, stdio: "ignore" });
-            } catch (err) {
-              process.stderr.write(`[ingest-worker] auto-commit failed: ${err instanceof Error ? err.message : String(err)}
-`);
-            }
-          }
-        }
-      }
-    }
-    if (data.tool_name === "Write" || data.tool_name === "Edit") {
-      const filePath = data.tool_input?.file_path ?? "";
-      const taskMatch = filePath.match(/exe\/([^/]+)\/([^/]+\.md)$/);
-      if (taskMatch && taskMatch[1] !== "output" && taskMatch[1] !== "research" && taskMatch[1] !== "exe") {
-        const employee = taskMatch[1];
-        const slug = taskMatch[2];
-        const taskFilePath = `exe/${employee}/${slug}`;
-        let fileContent = "";
-        if (data.tool_name === "Write") {
-          fileContent = data.tool_input?.content ?? "";
-        } else {
-          try {
-            const { readFileSync: readFileSync12 } = await import("fs");
-            fileContent = readFileSync12(filePath, "utf8");
-          } catch (err) {
-            process.stderr.write(`[ingest-worker] file read failed (${filePath}): ${err instanceof Error ? err.message : String(err)}
-`);
-          }
-        }
-        const statusMatch = fileContent.match(STATUS_RE);
-        const status = statusMatch?.[1]?.toLowerCase();
-        if (status === "open" || status === "in_progress") {
-          try {
-            const { getClient: getClient2 } = await Promise.resolve().then(() => (init_database(), database_exports));
-            const client = getClient2();
-            const existing = await client.execute({
-              sql: "SELECT id FROM tasks WHERE task_file = ?",
-              args: [taskFilePath]
-            });
-            if (existing.rows.length === 0) {
-              const titleMatch = fileContent.match(TITLE_RE);
-              const title = titleMatch?.[1] ?? slug.replace(/\.md$/, "").replace(/-/g, " ");
-              const priMatch = fileContent.match(/^\*\*Priority:\*\*\s*(\w+)/im);
-              const priority = priMatch?.[1]?.toLowerCase() ?? "p1";
-              const assignedByMatch = fileContent.match(/^\*\*Assigned by:\*\*\s*(\w+)/im);
-              const assignedBy = assignedByMatch?.[1] ?? "exe";
-              const projMatch = fileContent.match(/^\*\*Project:\*\*\s*(.+)/im);
-              const projectName = projMatch?.[1]?.trim() ?? getProjectName(data.cwd ?? process.cwd());
-              const now = (/* @__PURE__ */ new Date()).toISOString();
-              const { createTask: createTask2 } = await Promise.resolve().then(() => (init_tasks(), tasks_exports));
-              await createTask2({
-                title,
-                assignedTo: employee,
-                assignedBy,
-                projectName,
-                priority,
-                context: "",
-                taskFile: taskFilePath,
-                skipDispatch: true
-              });
-              const assignmentText = `TASK ASSIGNED: ${title} \u2192 ${employee} [${priority}] in ${projectName}`;
-              await writeMemory({
-                id: crypto7.randomUUID(),
-                agent_id: assignedBy,
-                agent_role: "COO",
-                session_id: data.session_id,
-                timestamp: now,
-                tool_name: "task-assignment",
-                project_name: projectName,
-                has_error: false,
-                raw_text: assignmentText,
-                vector: null
-                // Will be backfilled
-              });
-              await flushBatch();
-            }
-          } catch (err) {
-            process.stderr.write(`[ingest-worker] task auto-registration failed: ${err instanceof Error ? err.message : String(err)}
-`);
-          }
-          const cwd = data.cwd ?? process.cwd();
-          try {
-            mkdirSync8(path19.join(cwd, "exe/output"), { recursive: true });
-            mkdirSync8(path19.join(cwd, "exe/research"), { recursive: true });
-            const { ensureGitignoreExe: ensureGitignoreExe2 } = await Promise.resolve().then(() => (init_tasks(), tasks_exports));
-            await ensureGitignoreExe2(cwd);
-          } catch (err) {
-            process.stderr.write(`[ingest-worker] folder/gitignore setup failed: ${err instanceof Error ? err.message : String(err)}
-`);
-          }
-        }
-      }
-    }
-  } catch (err) {
-    process.stderr.write(`[ingest-worker] FATAL: ${err instanceof Error ? err.message : String(err)}
-`);
-  }
-  process.exit(0);
-});