@askexenow/exe-os 0.8.41 → 0.8.43

package/dist/bin/exe-review.js

@@ -198,282 +198,7 @@ var init_config = __esm({
   }
 });
 
-// src/lib/shard-manager.ts
-var shard_manager_exports = {};
-__export(shard_manager_exports, {
-  disposeShards: () => disposeShards,
-  ensureShardSchema: () => ensureShardSchema,
-  getReadyShardClient: () => getReadyShardClient,
-  getShardClient: () => getShardClient,
-  getShardsDir: () => getShardsDir,
-  initShardManager: () => initShardManager,
-  isShardingEnabled: () => isShardingEnabled,
-  listShards: () => listShards,
-  shardExists: () => shardExists
-});
-import path4 from "path";
-import { existsSync as existsSync4, mkdirSync, readdirSync } 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 = path4.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(path4.join(SHARDS_DIR, `${safeName}.db`));
-}
-function listShards() {
-  if (!existsSync4(SHARDS_DIR)) return [];
-  return readdirSync(SHARDS_DIR).filter((f) => f.endsWith(".db")).map((f) => f.replace(".db", ""));
-}
-async function ensureShardSchema(client) {
-  await client.execute("PRAGMA journal_mode = WAL");
-  await client.execute("PRAGMA busy_timeout = 30000");
-  try {
-    await client.execute("PRAGMA libsql_vector_search_ef = 128");
-  } catch {
-  }
-  await client.executeMultiple(`
-    CREATE TABLE IF NOT EXISTS memories (
-      id            TEXT PRIMARY KEY,
-      agent_id      TEXT NOT NULL,
-      agent_role    TEXT NOT NULL,
-      session_id    TEXT NOT NULL,
-      timestamp     TEXT NOT NULL,
-      tool_name     TEXT NOT NULL,
-      project_name  TEXT NOT NULL,
-      has_error     INTEGER NOT NULL DEFAULT 0,
-      raw_text      TEXT NOT NULL,
-      vector        F32_BLOB(1024),
-      version       INTEGER NOT NULL DEFAULT 0
-    );
-
-    CREATE INDEX IF NOT EXISTS idx_memories_agent ON memories(agent_id);
-    CREATE INDEX IF NOT EXISTS idx_memories_timestamp ON memories(timestamp);
-    CREATE INDEX IF NOT EXISTS idx_memories_agent_project ON memories(agent_id, project_name);
-  `);
-  await client.executeMultiple(`
-    CREATE VIRTUAL TABLE IF NOT EXISTS memories_fts USING fts5(
-      raw_text,
-      content='memories',
-      content_rowid='rowid'
-    );
-
-    CREATE TRIGGER IF NOT EXISTS memories_fts_ai AFTER INSERT ON memories BEGIN
-      INSERT INTO memories_fts(rowid, raw_text) VALUES (new.rowid, new.raw_text);
-    END;
-
-    CREATE TRIGGER IF NOT EXISTS memories_fts_ad AFTER DELETE ON memories BEGIN
-      INSERT INTO memories_fts(memories_fts, rowid, raw_text) VALUES('delete', old.rowid, old.raw_text);
-    END;
-
-    CREATE TRIGGER IF NOT EXISTS memories_fts_au AFTER UPDATE ON memories BEGIN
-      INSERT INTO memories_fts(memories_fts, rowid, raw_text) VALUES('delete', old.rowid, old.raw_text);
-      INSERT INTO memories_fts(rowid, raw_text) VALUES (new.rowid, new.raw_text);
-    END;
-  `);
-  for (const col of [
-    "ALTER TABLE memories ADD COLUMN task_id TEXT",
-    "ALTER TABLE memories ADD COLUMN consolidated INTEGER NOT NULL DEFAULT 0",
-    "ALTER TABLE memories ADD COLUMN importance INTEGER DEFAULT 5",
-    "ALTER TABLE memories ADD COLUMN status TEXT DEFAULT 'active'",
-    "ALTER TABLE memories ADD COLUMN wiki_synced INTEGER DEFAULT 0",
-    "ALTER TABLE memories ADD COLUMN graph_extracted INTEGER DEFAULT 0",
-    "ALTER TABLE memories ADD COLUMN content_hash TEXT",
-    "ALTER TABLE memories ADD COLUMN graph_extracted_hash TEXT",
-    "ALTER TABLE memories ADD COLUMN confidence REAL DEFAULT 0.7",
-    "ALTER TABLE memories ADD COLUMN last_accessed TEXT",
-    // Wiki linkage columns (must match database.ts)
-    "ALTER TABLE memories ADD COLUMN workspace_id TEXT",
-    "ALTER TABLE memories ADD COLUMN document_id TEXT",
-    "ALTER TABLE memories ADD COLUMN user_id TEXT",
-    "ALTER TABLE memories ADD COLUMN char_offset INTEGER",
-    "ALTER TABLE memories ADD COLUMN page_number INTEGER",
-    // Source provenance columns (must match database.ts)
-    "ALTER TABLE memories ADD COLUMN source_path TEXT",
-    "ALTER TABLE memories ADD COLUMN source_type TEXT DEFAULT 'text'",
-    "ALTER TABLE memories ADD COLUMN tier INTEGER DEFAULT 3",
-    "ALTER TABLE memories ADD COLUMN supersedes_id TEXT"
-  ]) {
-    try {
-      await client.execute(col);
-    } catch {
-    }
-  }
-  for (const idx of [
-    "CREATE INDEX IF NOT EXISTS idx_memories_tier ON memories(tier)",
-    "CREATE INDEX IF NOT EXISTS idx_memories_supersedes ON memories(supersedes_id) WHERE supersedes_id IS NOT NULL"
-  ]) {
-    try {
-      await client.execute(idx);
-    } catch {
-    }
-  }
-  try {
-    await client.execute("CREATE INDEX IF NOT EXISTS idx_memories_status ON memories(status)");
-  } catch {
-  }
-  for (const idx of [
-    "CREATE INDEX IF NOT EXISTS idx_memories_workspace ON memories(workspace_id)",
-    "CREATE INDEX IF NOT EXISTS idx_memories_document ON memories(document_id)",
-    "CREATE INDEX IF NOT EXISTS idx_memories_user ON memories(user_id)"
-  ]) {
-    try {
-      await client.execute(idx);
-    } catch {
-    }
-  }
-  await client.executeMultiple(`
-    CREATE TABLE IF NOT EXISTS entities (
-      id TEXT PRIMARY KEY,
-      name TEXT NOT NULL,
-      type TEXT NOT NULL,
-      first_seen TEXT NOT NULL,
-      last_seen TEXT NOT NULL,
-      properties TEXT DEFAULT '{}',
-      UNIQUE(name, type)
-    );
-
-    CREATE TABLE IF NOT EXISTS relationships (
-      id TEXT PRIMARY KEY,
-      source_entity_id TEXT NOT NULL,
-      target_entity_id TEXT NOT NULL,
-      type TEXT NOT NULL,
-      weight REAL DEFAULT 1.0,
-      timestamp TEXT NOT NULL,
-      properties TEXT DEFAULT '{}',
-      UNIQUE(source_entity_id, target_entity_id, type)
-    );
-
-    CREATE TABLE IF NOT EXISTS entity_memories (
-      entity_id TEXT NOT NULL,
-      memory_id TEXT NOT NULL,
-      PRIMARY KEY (entity_id, memory_id)
-    );
-
-    CREATE TABLE IF NOT EXISTS relationship_memories (
-      relationship_id TEXT NOT NULL,
-      memory_id TEXT NOT NULL,
-      PRIMARY KEY (relationship_id, memory_id)
-    );
-
-    CREATE INDEX IF NOT EXISTS idx_entities_name ON entities(name);
-    CREATE INDEX IF NOT EXISTS idx_entities_type ON entities(type);
-    CREATE INDEX IF NOT EXISTS idx_relationships_source ON relationships(source_entity_id);
-    CREATE INDEX IF NOT EXISTS idx_relationships_target ON relationships(target_entity_id);
-    CREATE INDEX IF NOT EXISTS idx_relationships_type ON relationships(type);
-
-    CREATE TABLE IF NOT EXISTS hyperedges (
-      id TEXT PRIMARY KEY,
-      label TEXT NOT NULL,
-      relation TEXT NOT NULL,
-      confidence REAL DEFAULT 1.0,
-      timestamp TEXT NOT NULL
-    );
-
-    CREATE TABLE IF NOT EXISTS hyperedge_nodes (
-      hyperedge_id TEXT NOT NULL,
-      entity_id TEXT NOT NULL,
-      PRIMARY KEY (hyperedge_id, entity_id)
-    );
-  `);
-  for (const col of [
-    "ALTER TABLE relationships ADD COLUMN confidence REAL DEFAULT 1.0",
-    "ALTER TABLE relationships ADD COLUMN confidence_label TEXT DEFAULT 'extracted'"
-  ]) {
-    try {
-      await client.execute(col);
-    } catch {
-    }
-  }
-}
-async function getReadyShardClient(projectName) {
-  const client = getShardClient(projectName);
-  await ensureShardSchema(client);
-  return client;
-}
-function disposeShards() {
-  for (const [, client] of _shards) {
-    client.close();
-  }
-  _shards.clear();
-  _shardingEnabled = false;
-  _encryptionKey = null;
-}
-var SHARDS_DIR, _shards, _encryptionKey, _shardingEnabled;
-var init_shard_manager = __esm({
-  "src/lib/shard-manager.ts"() {
-    "use strict";
-    init_config();
-    SHARDS_DIR = path4.join(EXE_AI_DIR, "shards");
-    _shards = /* @__PURE__ */ new Map();
-    _encryptionKey = null;
-    _shardingEnabled = false;
-  }
-});
-
-// src/bin/exe-review.ts
-import { randomUUID } from "crypto";
-
-// src/lib/employees.ts
-init_config();
-import { readFile as readFile2, writeFile as writeFile2, mkdir as mkdir2 } from "fs/promises";
-import { existsSync as existsSync2, symlinkSync, readlinkSync, readFileSync as readFileSync2 } from "fs";
-import { execSync } from "child_process";
-import path2 from "path";
-var EMPLOYEES_PATH = path2.join(EXE_AI_DIR, "exe-employees.json");
-async function loadEmployees(employeesPath = EMPLOYEES_PATH) {
-  if (!existsSync2(employeesPath)) {
-    return [];
-  }
-  const raw = await readFile2(employeesPath, "utf-8");
-  try {
-    return JSON.parse(raw);
-  } catch {
-    return [];
-  }
-}
-function getEmployee(employees, name) {
-  return employees.find((e) => e.name.toLowerCase() === name.toLowerCase());
-}
-
-// src/types/memory.ts
-var EMBEDDING_DIM = 1024;
-
-// src/lib/database.ts
-import { createClient } from "@libsql/client";
-
 // src/lib/db-retry.ts
-var MAX_RETRIES = 3;
-var BASE_DELAY_MS = 200;
-var MAX_JITTER_MS = 300;
 function isBusyError(err) {
   if (err instanceof Error) {
     const msg = err.message.toLowerCase();
@@ -518,11 +243,18 @@ function wrapWithRetry(client) {
     }
   });
 }
+var MAX_RETRIES, BASE_DELAY_MS, MAX_JITTER_MS;
+var init_db_retry = __esm({
+  "src/lib/db-retry.ts"() {
+    "use strict";
+    MAX_RETRIES = 3;
+    BASE_DELAY_MS = 200;
+    MAX_JITTER_MS = 300;
+  }
+});
 
 // src/lib/database.ts
-var _client = null;
-var _resilientClient = null;
-var initTurso = initDatabase;
+import { createClient } from "@libsql/client";
 async function initDatabase(config) {
   if (_client) {
     _client.close();
@@ -759,6 +491,13 @@ async function ensureSchema() {
     });
   } catch {
   }
+  try {
+    await client.execute({
+      sql: `ALTER TABLE tasks ADD COLUMN session_scope TEXT`,
+      args: []
+    });
+  } catch {
+  }
   try {
     await client.execute({
       sql: `ALTER TABLE memories ADD COLUMN task_id TEXT`,
@@ -1205,6 +944,18 @@ async function ensureSchema() {
     CREATE INDEX IF NOT EXISTS idx_session_kills_agent
       ON session_kills(agent_id);
   `);
+  await client.execute(`
+    CREATE TABLE IF NOT EXISTS global_procedures (
+      id TEXT PRIMARY KEY,
+      title TEXT NOT NULL,
+      content TEXT NOT NULL,
+      priority TEXT NOT NULL DEFAULT 'p0',
+      domain TEXT,
+      active INTEGER NOT NULL DEFAULT 1,
+      created_at TEXT NOT NULL,
+      updated_at TEXT NOT NULL
+    )
+  `);
   await client.executeMultiple(`
     CREATE TABLE IF NOT EXISTS conversations (
       id              TEXT PRIMARY KEY,
@@ -1271,71 +1022,298 @@ async function ensureSchema() {
   } catch {
   }
   await client.executeMultiple(`
-    CREATE VIRTUAL TABLE IF NOT EXISTS conversations_fts USING fts5(
-      content_text,
-      sender_name,
-      agent_response,
-      content='conversations',
+    CREATE VIRTUAL TABLE IF NOT EXISTS conversations_fts USING fts5(
+      content_text,
+      sender_name,
+      agent_response,
+      content='conversations',
+      content_rowid='rowid'
+    );
+
+    CREATE TRIGGER IF NOT EXISTS conversations_fts_ai AFTER INSERT ON conversations BEGIN
+      INSERT INTO conversations_fts(rowid, content_text, sender_name, agent_response)
+      VALUES (new.rowid, new.content_text, new.sender_name, new.agent_response);
+    END;
+
+    CREATE TRIGGER IF NOT EXISTS conversations_fts_ad AFTER DELETE ON conversations BEGIN
+      INSERT INTO conversations_fts(conversations_fts, rowid, content_text, sender_name, agent_response)
+      VALUES('delete', old.rowid, old.content_text, old.sender_name, old.agent_response);
+    END;
+
+    CREATE TRIGGER IF NOT EXISTS conversations_fts_au AFTER UPDATE ON conversations BEGIN
+      INSERT INTO conversations_fts(conversations_fts, rowid, content_text, sender_name, agent_response)
+      VALUES('delete', old.rowid, old.content_text, old.sender_name, old.agent_response);
+      INSERT INTO conversations_fts(rowid, content_text, sender_name, agent_response)
+      VALUES (new.rowid, new.content_text, new.sender_name, new.agent_response);
+    END;
+  `);
+  try {
+    await client.execute({
+      sql: `ALTER TABLE memories ADD COLUMN tier INTEGER DEFAULT 3`,
+      args: []
+    });
+  } catch {
+  }
+  try {
+    await client.execute(
+      `CREATE INDEX IF NOT EXISTS idx_memories_tier ON memories(tier)`
+    );
+  } catch {
+  }
+  try {
+    await client.execute({
+      sql: `UPDATE memories SET tier = 1 WHERE tool_name = 'commit_to_long_term_memory' AND importance >= 8 AND tier = 3`,
+      args: []
+    });
+    await client.execute({
+      sql: `UPDATE memories SET tier = 2 WHERE tool_name IN ('store_memory', 'manual') AND importance >= 5 AND tier = 3`,
+      args: []
+    });
+  } catch {
+  }
+  try {
+    await client.execute({
+      sql: `ALTER TABLE memories ADD COLUMN supersedes_id TEXT`,
+      args: []
+    });
+  } catch {
+  }
+  try {
+    await client.execute(
+      `CREATE INDEX IF NOT EXISTS idx_memories_supersedes ON memories(supersedes_id) WHERE supersedes_id IS NOT NULL`
+    );
+  } catch {
+  }
+  for (const col of [
+    "ALTER TABLE tasks ADD COLUMN checkpoint TEXT",
+    "ALTER TABLE tasks ADD COLUMN checkpoint_count INTEGER DEFAULT 0"
+  ]) {
+    try {
+      await client.execute(col);
+    } catch {
+    }
+  }
+}
+var _client, _resilientClient, initTurso;
+var init_database = __esm({
+  "src/lib/database.ts"() {
+    "use strict";
+    init_db_retry();
+    _client = null;
+    _resilientClient = null;
+    initTurso = initDatabase;
+  }
+});
+
+// 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 path4 from "path";
+import { existsSync as existsSync4, mkdirSync, readdirSync } 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 = path4.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(path4.join(SHARDS_DIR, `${safeName}.db`));
+}
+function listShards() {
+  if (!existsSync4(SHARDS_DIR)) return [];
+  return readdirSync(SHARDS_DIR).filter((f) => f.endsWith(".db")).map((f) => f.replace(".db", ""));
+}
+async function ensureShardSchema(client) {
+  await client.execute("PRAGMA journal_mode = WAL");
+  await client.execute("PRAGMA busy_timeout = 30000");
+  try {
+    await client.execute("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 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);
+    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 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);
+    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 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);
+    CREATE TRIGGER IF NOT EXISTS memories_fts_au AFTER UPDATE ON memories BEGIN
+      INSERT INTO memories_fts(memories_fts, rowid, raw_text) VALUES('delete', old.rowid, old.raw_text);
+      INSERT INTO memories_fts(rowid, raw_text) VALUES (new.rowid, new.raw_text);
     END;
   `);
-  try {
-    await client.execute({
-      sql: `ALTER TABLE memories ADD COLUMN tier INTEGER DEFAULT 3`,
-      args: []
-    });
-  } catch {
+  for (const col of [
+    "ALTER TABLE memories ADD COLUMN task_id TEXT",
+    "ALTER TABLE memories ADD COLUMN consolidated INTEGER NOT NULL DEFAULT 0",
+    "ALTER TABLE memories ADD COLUMN importance INTEGER DEFAULT 5",
+    "ALTER TABLE memories ADD COLUMN status TEXT DEFAULT 'active'",
+    "ALTER TABLE memories ADD COLUMN wiki_synced INTEGER DEFAULT 0",
+    "ALTER TABLE memories ADD COLUMN graph_extracted INTEGER DEFAULT 0",
+    "ALTER TABLE memories ADD COLUMN content_hash TEXT",
+    "ALTER TABLE memories ADD COLUMN graph_extracted_hash TEXT",
+    "ALTER TABLE memories ADD COLUMN confidence REAL DEFAULT 0.7",
+    "ALTER TABLE memories ADD COLUMN last_accessed TEXT",
+    // Wiki linkage columns (must match database.ts)
+    "ALTER TABLE memories ADD COLUMN workspace_id TEXT",
+    "ALTER TABLE memories ADD COLUMN document_id TEXT",
+    "ALTER TABLE memories ADD COLUMN user_id TEXT",
+    "ALTER TABLE memories ADD COLUMN char_offset INTEGER",
+    "ALTER TABLE memories ADD COLUMN page_number INTEGER",
+    // Source provenance columns (must match database.ts)
+    "ALTER TABLE memories ADD COLUMN source_path TEXT",
+    "ALTER TABLE memories ADD COLUMN source_type TEXT DEFAULT 'text'",
+    "ALTER TABLE memories ADD COLUMN tier INTEGER DEFAULT 3",
+    "ALTER TABLE memories ADD COLUMN supersedes_id TEXT"
+  ]) {
+    try {
+      await client.execute(col);
+    } catch {
+    }
   }
-  try {
-    await client.execute(
-      `CREATE INDEX IF NOT EXISTS idx_memories_tier ON memories(tier)`
-    );
-  } catch {
+  for (const idx of [
+    "CREATE INDEX IF NOT EXISTS idx_memories_tier ON memories(tier)",
+    "CREATE INDEX IF NOT EXISTS idx_memories_supersedes ON memories(supersedes_id) WHERE supersedes_id IS NOT NULL"
+  ]) {
+    try {
+      await client.execute(idx);
+    } catch {
+    }
   }
   try {
-    await client.execute({
-      sql: `UPDATE memories SET tier = 1 WHERE tool_name = 'commit_to_long_term_memory' AND importance >= 8 AND tier = 3`,
-      args: []
-    });
-    await client.execute({
-      sql: `UPDATE memories SET tier = 2 WHERE tool_name IN ('store_memory', 'manual') AND importance >= 5 AND tier = 3`,
-      args: []
-    });
+    await client.execute("CREATE INDEX IF NOT EXISTS idx_memories_status ON memories(status)");
   } catch {
   }
-  try {
-    await client.execute({
-      sql: `ALTER TABLE memories ADD COLUMN supersedes_id TEXT`,
-      args: []
-    });
-  } 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 {
+    }
   }
-  try {
-    await client.execute(
-      `CREATE INDEX IF NOT EXISTS idx_memories_supersedes ON memories(supersedes_id) WHERE supersedes_id IS NOT NULL`
+  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)
     );
-  } catch {
-  }
+
+    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 tasks ADD COLUMN checkpoint TEXT",
-    "ALTER TABLE tasks ADD COLUMN checkpoint_count INTEGER DEFAULT 0"
+    "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);
@@ -1343,6 +1321,126 @@ async function ensureSchema() {
     }
   }
 }
+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 = path4.join(EXE_AI_DIR, "shards");
+    _shards = /* @__PURE__ */ new Map();
+    _encryptionKey = null;
+    _shardingEnabled = false;
+  }
+});
+
+// src/lib/global-procedures.ts
+var global_procedures_exports = {};
+__export(global_procedures_exports, {
+  deactivateGlobalProcedure: () => deactivateGlobalProcedure,
+  getGlobalProceduresBlock: () => getGlobalProceduresBlock,
+  loadGlobalProcedures: () => loadGlobalProcedures,
+  storeGlobalProcedure: () => storeGlobalProcedure
+});
+import { randomUUID } from "crypto";
+async function loadGlobalProcedures() {
+  const client = getClient();
+  const result = await client.execute({
+    sql: "SELECT * FROM global_procedures WHERE active = 1 ORDER BY priority ASC, created_at ASC",
+    args: []
+  });
+  const procedures = result.rows;
+  if (procedures.length > 0) {
+    _cache = procedures.map((p) => `### ${p.title}
+${p.content}`).join("\n\n");
+  } else {
+    _cache = "";
+  }
+  _cacheLoaded = true;
+  return procedures;
+}
+function getGlobalProceduresBlock() {
+  if (!_cacheLoaded) return "";
+  if (!_cache) return "";
+  return `## Organization-Wide Procedures (MANDATORY \u2014 supersedes all other rules)
+
+${_cache}
+`;
+}
+async function storeGlobalProcedure(input) {
+  const id = randomUUID();
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const client = getClient();
+  await client.execute({
+    sql: `INSERT INTO global_procedures (id, title, content, priority, domain, active, created_at, updated_at)
+          VALUES (?, ?, ?, ?, ?, 1, ?, ?)`,
+    args: [id, input.title, input.content, input.priority ?? "p0", input.domain ?? null, now, now]
+  });
+  await loadGlobalProcedures();
+  return id;
+}
+async function deactivateGlobalProcedure(id) {
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const client = getClient();
+  const result = await client.execute({
+    sql: "UPDATE global_procedures SET active = 0, updated_at = ? WHERE id = ?",
+    args: [now, id]
+  });
+  await loadGlobalProcedures();
+  return result.rowsAffected > 0;
+}
+var _cache, _cacheLoaded;
+var init_global_procedures = __esm({
+  "src/lib/global-procedures.ts"() {
+    "use strict";
+    init_database();
+    _cache = "";
+    _cacheLoaded = false;
+  }
+});
+
+// src/bin/exe-review.ts
+import { randomUUID as randomUUID2 } from "crypto";
+
+// src/lib/employees.ts
+init_config();
+import { readFile as readFile2, writeFile as writeFile2, mkdir as mkdir2 } from "fs/promises";
+import { existsSync as existsSync2, symlinkSync, readlinkSync, readFileSync as readFileSync2 } from "fs";
+import { execSync } from "child_process";
+import path2 from "path";
+var EMPLOYEES_PATH = path2.join(EXE_AI_DIR, "exe-employees.json");
+async function loadEmployees(employeesPath = EMPLOYEES_PATH) {
+  if (!existsSync2(employeesPath)) {
+    return [];
+  }
+  const raw = await readFile2(employeesPath, "utf-8");
+  try {
+    return JSON.parse(raw);
+  } catch {
+    return [];
+  }
+}
+function getEmployee(employees, name) {
+  return employees.find((e) => e.name.toLowerCase() === name.toLowerCase());
+}
+
+// src/types/memory.ts
+var EMBEDDING_DIM = 1024;
+
+// src/lib/store.ts
+init_database();
 
 // src/lib/keychain.ts
 import { readFile as readFile3, writeFile as writeFile3, unlink, mkdir as mkdir3, chmod as chmod2 } from "fs/promises";
@@ -1390,6 +1488,57 @@ async function getMasterKey() {
 
 // src/lib/store.ts
 init_config();
+
+// src/lib/state-bus.ts
+var StateBus = class {
+  handlers = /* @__PURE__ */ new Map();
+  globalHandlers = /* @__PURE__ */ new Set();
+  /** Emit an event to all subscribers */
+  emit(event) {
+    const typeHandlers = this.handlers.get(event.type);
+    if (typeHandlers) {
+      for (const handler of typeHandlers) {
+        try {
+          handler(event);
+        } catch {
+        }
+      }
+    }
+    for (const handler of this.globalHandlers) {
+      try {
+        handler(event);
+      } catch {
+      }
+    }
+  }
+  /** Subscribe to a specific event type */
+  on(type, handler) {
+    if (!this.handlers.has(type)) {
+      this.handlers.set(type, /* @__PURE__ */ new Set());
+    }
+    this.handlers.get(type).add(handler);
+  }
+  /** Subscribe to ALL events */
+  onAny(handler) {
+    this.globalHandlers.add(handler);
+  }
+  /** Unsubscribe from a specific event type */
+  off(type, handler) {
+    this.handlers.get(type)?.delete(handler);
+  }
+  /** Unsubscribe from ALL events */
+  offAny(handler) {
+    this.globalHandlers.delete(handler);
+  }
+  /** Remove all listeners */
+  clear() {
+    this.handlers.clear();
+    this.globalHandlers.clear();
+  }
+};
+var orgBus = new StateBus();
+
+// src/lib/store.ts
 var INIT_MAX_RETRIES = 3;
 var INIT_RETRY_DELAY_MS = 1e3;
 function isBusyError2(err) {
@@ -1460,6 +1609,11 @@ async function initStore(options) {
     "version-query"
   );
   _nextVersion = (Number(vResult.rows[0]?.max_v) || 0) + 1;
+  try {
+    const { loadGlobalProcedures: loadGlobalProcedures2 } = await Promise.resolve().then(() => (init_global_procedures(), global_procedures_exports));
+    await loadGlobalProcedures2();
+  } catch {
+  }
 }
 function classifyTier(record) {
   if (record.tool_name === "commit_to_long_term_memory" && (record.importance ?? 0) >= 8) return 1;
@@ -1501,6 +1655,12 @@ async function writeMemory(record) {
     supersedes_id: record.supersedes_id ?? null
   };
   _pendingRecords.push(dbRow);
+  orgBus.emit({
+    type: "memory_stored",
+    agentId: record.agent_id,
+    project: record.project_name,
+    timestamp: record.timestamp
+  });
   const MAX_PENDING = 1e3;
   if (_pendingRecords.length > MAX_PENDING) {
     const dropped = _pendingRecords.length - MAX_PENDING;
@@ -1655,6 +1815,9 @@ function vectorToBlob(vector) {
   return JSON.stringify(Array.from(f32));
 }
 
+// src/bin/exe-review.ts
+init_database();
+
 // src/lib/is-main.ts
 import { realpathSync } from "fs";
 import { fileURLToPath } from "url";
@@ -1747,7 +1910,7 @@ function generateReviewReport(employeeName, analysis, memories) {
 }
 function createReviewMemory(employeeName, report) {
   return {
-    id: randomUUID(),
+    id: randomUUID2(),
     agent_id: "exe",
     agent_role: "COO",
     session_id: `review-${employeeName}-${Date.now()}`,