@askexenow/exe-os 0.9.265 → 0.9.267

package/dist/chunk-E45SYT7G.js

@@ -0,0 +1,617 @@
+import {
+  assertValidDbPath
+} from "./chunk-2I23RPSI.js";
+import {
+  EXE_AI_DIR
+} from "./chunk-VXIMSRTO.js";
+
+// src/lib/shard-manager.ts
+import path from "path";
+import { existsSync, mkdirSync, readdirSync, renameSync, statSync } from "fs";
+import { createClient } from "@libsql/client";
+var SHARDS_DIR = path.join(EXE_AI_DIR, "shards");
+var SHARD_IDLE_MS = 5 * 60 * 1e3;
+var MAX_OPEN_SHARDS = 10;
+var EVICTION_INTERVAL_MS = 60 * 1e3;
+var _shards = /* @__PURE__ */ new Map();
+var _shardLastAccess = /* @__PURE__ */ new Map();
+var _evictionTimer = null;
+var _encryptionKey = null;
+var _shardingEnabled = false;
+var _keyValidated = false;
+var _keyValidationPromise = null;
+var _validationFailedForKey = null;
+var _validationWarningEmitted = false;
+function initShardManager(encryptionKey) {
+  _encryptionKey = encryptionKey;
+  _keyValidationPromise = null;
+  _keyValidated = false;
+  if (!existsSync(SHARDS_DIR)) {
+    mkdirSync(SHARDS_DIR, { recursive: true });
+  }
+  const existingShards = readdirSync(SHARDS_DIR).filter((f) => f.endsWith(".db"));
+  if (existingShards.length === 0) {
+    _keyValidated = true;
+    _validationFailedForKey = null;
+  }
+  if (_validationFailedForKey === encryptionKey && existingShards.length > 0) {
+    _keyValidated = true;
+    _shardingEnabled = false;
+  } else {
+    _shardingEnabled = true;
+  }
+  if (_evictionTimer) clearInterval(_evictionTimer);
+  _evictionTimer = setInterval(evictIdleShards, EVICTION_INTERVAL_MS);
+  _evictionTimer.unref();
+}
+async function validateEncryptionKey() {
+  if (_keyValidated) return _shardingEnabled;
+  if (!_encryptionKey) return false;
+  const existingShards = readdirSync(SHARDS_DIR).filter((f) => f.endsWith(".db"));
+  if (existingShards.length === 0) {
+    _keyValidated = true;
+    return true;
+  }
+  for (const shardFile of existingShards.slice(0, 3)) {
+    const dbPath = path.join(SHARDS_DIR, shardFile);
+    assertValidDbPath(dbPath, "shard-manager validateEncryptionKey");
+    const testClient = createClient({ url: `file:${dbPath}`, encryptionKey: _encryptionKey });
+    try {
+      await testClient.execute("SELECT COUNT(*) FROM sqlite_schema");
+      testClient.close();
+      _keyValidated = true;
+      _validationFailedForKey = null;
+      _validationWarningEmitted = false;
+      return true;
+    } catch {
+      try {
+        testClient.close();
+      } catch {
+      }
+    }
+  }
+  if (!_validationWarningEmitted) {
+    process.stderr.write(
+      `[shard-manager] WARNING: encryption key cannot read any existing shards (${existingShards.length} found). New shard creation disabled to prevent stranded files. Run /exe-doctor to audit.
+`
+    );
+    _validationWarningEmitted = true;
+  }
+  _validationFailedForKey = _encryptionKey;
+  _keyValidated = true;
+  _keyValidationPromise = null;
+  _shardingEnabled = false;
+  return false;
+}
+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 = safeShardName(projectName);
+  if (!safeName || safeName === "unknown") {
+    throw new Error(`Invalid project name for shard: "${projectName}" (resolved to "${safeName}")`);
+  }
+  const cached = _shards.get(safeName);
+  if (cached) {
+    _shardLastAccess.set(safeName, Date.now());
+    return cached;
+  }
+  while (_shards.size >= MAX_OPEN_SHARDS) {
+    evictLRU();
+  }
+  const dbPath = path.join(SHARDS_DIR, `${safeName}.db`);
+  assertValidDbPath(dbPath, "shard-manager getShardClient");
+  const client = createClient({
+    url: `file:${dbPath}`,
+    encryptionKey: _encryptionKey
+  });
+  _shards.set(safeName, client);
+  _shardLastAccess.set(safeName, Date.now());
+  return client;
+}
+function shardExists(projectName) {
+  const safeName = safeShardName(projectName);
+  return existsSync(path.join(SHARDS_DIR, `${safeName}.db`));
+}
+function safeShardName(projectName) {
+  return projectName.replace(/[^a-zA-Z0-9_-]/g, "_");
+}
+function listShards() {
+  if (!existsSync(SHARDS_DIR)) return [];
+  return readdirSync(SHARDS_DIR).filter((f) => f.endsWith(".db")).map((f) => f.replace(".db", ""));
+}
+async function auditShardHealth(options = {}) {
+  if (!_encryptionKey) {
+    throw new Error("Shard manager not initialized. Call initShardManager() first.");
+  }
+  const repair = options.repair === true;
+  const dryRun = options.dryRun === true;
+  const names = listShards();
+  const shards = [];
+  for (const name of names) {
+    const dbPath = path.join(SHARDS_DIR, `${name}.db`);
+    const stat = statSync(dbPath);
+    const item = {
+      name,
+      path: dbPath,
+      ok: false,
+      unreadable: false,
+      error: null,
+      schemaIssues: [],
+      size: stat.size,
+      mtime: stat.mtime.toISOString(),
+      memoryCount: null
+    };
+    const client = createClient({
+      url: `file:${dbPath}`,
+      encryptionKey: _encryptionKey
+    });
+    try {
+      await client.execute("SELECT COUNT(*) as cnt FROM sqlite_schema");
+      const hasMemories = await client.execute(
+        "SELECT COUNT(*) as cnt FROM sqlite_schema WHERE type = 'table' AND name = 'memories'"
+      );
+      if (Number(hasMemories.rows[0]?.cnt ?? 0) > 0) {
+        const mem = await client.execute("SELECT COUNT(*) as cnt FROM memories");
+        item.memoryCount = Number(mem.rows[0]?.cnt ?? 0);
+        const columns = await client.execute("PRAGMA table_info(memories)");
+        const colNames = new Set(columns.rows.map((r) => String(r.name)));
+        for (const required of ["keywords", "content_hash", "memory_type", "status", "session_scope"]) {
+          if (!colNames.has(required)) item.schemaIssues.push(`memories missing column ${required}`);
+        }
+        const fts = await client.execute(
+          "SELECT sql FROM sqlite_schema WHERE type='table' AND name='memories_fts'"
+        );
+        const ftsSql = String(fts.rows[0]?.sql ?? "");
+        if (!ftsSql.includes("keywords")) item.schemaIssues.push("memories_fts missing keywords column");
+        if (item.schemaIssues.length > 0 && repair && !dryRun) {
+          await ensureShardSchema(client);
+          item.schemaIssues = [];
+        }
+      }
+      item.ok = item.schemaIssues.length === 0;
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      item.error = message;
+      item.unreadable = /SQLITE_NOTADB|file is not a database/i.test(message);
+      if (item.unreadable && repair && !dryRun) {
+        client.close();
+        _shards.delete(name);
+        _shardLastAccess.delete(name);
+        const stamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
+        const archivedPath = path.join(SHARDS_DIR, `${name}.db.broken-${stamp}`);
+        renameSync(dbPath, archivedPath);
+        item.archivedPath = archivedPath;
+      }
+    } finally {
+      try {
+        client.close();
+      } catch {
+      }
+    }
+    shards.push(item);
+  }
+  return {
+    total: shards.length,
+    ok: shards.filter((s) => s.ok).length,
+    unreadable: shards.filter((s) => s.unreadable).length,
+    schemaMismatches: shards.filter((s) => s.schemaIssues.length > 0).length,
+    archived: shards.filter((s) => Boolean(s.archivedPath)).length,
+    shards
+  };
+}
+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);
+    CREATE INDEX IF NOT EXISTS idx_memories_version ON memories(version);
+  `);
+  for (const col of [
+    "ALTER TABLE memories ADD COLUMN status TEXT DEFAULT 'active'",
+    "ALTER TABLE memories ADD COLUMN keywords TEXT DEFAULT ''",
+    "ALTER TABLE memories ADD COLUMN founder_id TEXT"
+  ]) {
+    try {
+      await client.execute(col);
+    } catch {
+    }
+  }
+  let needsFtsMigration = false;
+  try {
+    await client.execute("SELECT keywords FROM memories_fts LIMIT 0");
+  } catch {
+    needsFtsMigration = true;
+  }
+  if (needsFtsMigration) {
+    for (const drop of [
+      "DROP TRIGGER IF EXISTS memories_fts_ai",
+      "DROP TRIGGER IF EXISTS memories_fts_ad",
+      "DROP TRIGGER IF EXISTS memories_fts_au",
+      "DROP TRIGGER IF EXISTS memories_fts_soft_delete",
+      "DROP TABLE IF EXISTS memories_fts"
+    ]) {
+      try {
+        await client.execute(drop);
+      } catch {
+      }
+    }
+  }
+  await client.executeMultiple(`
+    CREATE VIRTUAL TABLE IF NOT EXISTS memories_fts USING fts5(
+      raw_text,
+      keywords,
+      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, keywords) VALUES (new.rowid, new.raw_text, COALESCE(new.keywords, ''));
+    END;
+
+    CREATE TRIGGER IF NOT EXISTS memories_fts_ad AFTER DELETE ON memories BEGIN
+      INSERT INTO memories_fts(memories_fts, rowid, raw_text, keywords) VALUES('delete', old.rowid, old.raw_text, COALESCE(old.keywords, ''));
+    END;
+
+    CREATE TRIGGER IF NOT EXISTS memories_fts_au AFTER UPDATE ON memories BEGIN
+      INSERT INTO memories_fts(memories_fts, rowid, raw_text, keywords) VALUES('delete', old.rowid, old.raw_text, COALESCE(old.keywords, ''));
+      INSERT INTO memories_fts(rowid, raw_text, keywords) VALUES (new.rowid, new.raw_text, COALESCE(new.keywords, ''));
+    END;
+
+    CREATE TRIGGER IF NOT EXISTS memories_fts_soft_delete AFTER UPDATE OF status ON memories
+      WHEN new.status = 'deleted' AND (old.status IS NULL OR old.status != 'deleted') BEGIN
+      INSERT INTO memories_fts(memories_fts, rowid, raw_text, keywords) VALUES('delete', old.rowid, old.raw_text, COALESCE(old.keywords, ''));
+    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 author_device_id TEXT",
+    "ALTER TABLE memories ADD COLUMN scope TEXT NOT NULL DEFAULT 'business'",
+    "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",
+    // MS-11: draft staging, MS-6a: memory_type, MS-7: trajectory
+    "ALTER TABLE memories ADD COLUMN draft INTEGER DEFAULT 0",
+    "ALTER TABLE memories ADD COLUMN memory_type TEXT DEFAULT 'raw'",
+    "ALTER TABLE memories ADD COLUMN trajectory TEXT",
+    // Metadata enrichment columns (must match database.ts)
+    "ALTER TABLE memories ADD COLUMN intent TEXT",
+    "ALTER TABLE memories ADD COLUMN outcome TEXT",
+    "ALTER TABLE memories ADD COLUMN domain TEXT",
+    "ALTER TABLE memories ADD COLUMN referenced_entities TEXT",
+    "ALTER TABLE memories ADD COLUMN retrieval_count INTEGER DEFAULT 0",
+    "ALTER TABLE memories ADD COLUMN chain_position TEXT",
+    "ALTER TABLE memories ADD COLUMN review_status TEXT",
+    "ALTER TABLE memories ADD COLUMN context_window_pct INTEGER",
+    "ALTER TABLE memories ADD COLUMN file_paths TEXT",
+    "ALTER TABLE memories ADD COLUMN commit_hash TEXT",
+    "ALTER TABLE memories ADD COLUMN duration_ms INTEGER",
+    "ALTER TABLE memories ADD COLUMN token_cost REAL",
+    "ALTER TABLE memories ADD COLUMN audience TEXT",
+    "ALTER TABLE memories ADD COLUMN language_type TEXT",
+    "ALTER TABLE memories ADD COLUMN parent_memory_id TEXT",
+    "ALTER TABLE memories ADD COLUMN deleted_at TEXT",
+    // Temporal validity (must match database.ts)
+    "ALTER TABLE memories ADD COLUMN valid_from TEXT",
+    "ALTER TABLE memories ADD COLUMN invalid_at TEXT",
+    // Multi-agent visibility (must match database.ts)
+    "ALTER TABLE memories ADD COLUMN visibility TEXT DEFAULT 'private'",
+    // Procedure binding (AFM-3, must match database.ts)
+    "ALTER TABLE memories ADD COLUMN procedure_for TEXT",
+    // Memory strength scoring — Ebbinghaus decay (must match database.ts)
+    "ALTER TABLE memories ADD COLUMN strength REAL DEFAULT 1.0",
+    // Source trust level (must match database.ts)
+    "ALTER TABLE memories ADD COLUMN source_trust_level TEXT DEFAULT 'unknown'",
+    // Poisoning defense (must match database.ts)
+    "ALTER TABLE memories ADD COLUMN quarantined INTEGER DEFAULT 0",
+    "ALTER TABLE memories ADD COLUMN quarantine_reason TEXT",
+    // Multi-modal media (must match database.ts)
+    "ALTER TABLE memories ADD COLUMN media_url TEXT",
+    "ALTER TABLE memories ADD COLUMN media_type TEXT",
+    "ALTER TABLE memories ADD COLUMN media_meta TEXT",
+    // Session scope (must match database.ts)
+    "ALTER TABLE memories ADD COLUMN session_scope TEXT",
+    // Keywords for FTS5 dual-column search (must match database.ts)
+    "ALTER TABLE memories ADD COLUMN keywords TEXT DEFAULT ''",
+    // Multi-user founder scope (must match database.ts)
+    "ALTER TABLE memories ADD COLUMN founder_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",
+    "CREATE INDEX IF NOT EXISTS idx_memories_scoped_content_hash ON memories(content_hash, agent_id, project_name, memory_type) WHERE content_hash 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'",
+    // Temporal validity (must match database.ts)
+    "ALTER TABLE relationships ADD COLUMN valid_from TEXT",
+    "ALTER TABLE relationships ADD COLUMN valid_until TEXT"
+  ]) {
+    try {
+      await client.execute(col);
+    } catch {
+    }
+  }
+  try {
+    await client.execute("ALTER TABLE entities ADD COLUMN parent_type TEXT");
+  } catch {
+  }
+  for (const idx of [
+    "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_content_hash ON memories(content_hash, agent_id)",
+    "CREATE INDEX IF NOT EXISTS idx_memories_quarantined ON memories(quarantined) WHERE quarantined = 1",
+    "CREATE INDEX IF NOT EXISTS idx_memories_draft ON memories(draft) WHERE draft = 1",
+    "CREATE INDEX IF NOT EXISTS idx_memories_type ON memories(memory_type)",
+    "CREATE INDEX IF NOT EXISTS idx_memories_agent_scope_project ON memories(agent_id, session_scope, project_name)",
+    // UNIQUE dedup index — prevents duplicate memories at DB level
+    "CREATE UNIQUE INDEX IF NOT EXISTS idx_memories_unique_scoped_hash ON memories(content_hash, agent_id, project_name, memory_type) WHERE content_hash IS NOT NULL AND COALESCE(status, 'active') != 'deleted'",
+    // Entity indexes
+    "CREATE INDEX IF NOT EXISTS idx_entities_type_name ON entities(type, name)",
+    // Relationship temporal indexes
+    "CREATE INDEX IF NOT EXISTS idx_relationships_valid_from ON relationships(valid_from)",
+    "CREATE INDEX IF NOT EXISTS idx_relationships_valid_until ON relationships(valid_until)"
+  ]) {
+    try {
+      await client.execute(idx);
+    } catch {
+    }
+  }
+  await client.executeMultiple(`
+    CREATE VIRTUAL TABLE IF NOT EXISTS entities_fts USING fts5(
+      name,
+      content='entities',
+      content_rowid='rowid'
+    );
+
+    CREATE TRIGGER IF NOT EXISTS entities_fts_ai AFTER INSERT ON entities BEGIN
+      INSERT INTO entities_fts(rowid, name) VALUES (new.rowid, new.name);
+    END;
+
+    CREATE TRIGGER IF NOT EXISTS entities_fts_ad AFTER DELETE ON entities BEGIN
+      INSERT INTO entities_fts(entities_fts, rowid, name) VALUES('delete', old.rowid, old.name);
+    END;
+
+    CREATE TRIGGER IF NOT EXISTS entities_fts_au AFTER UPDATE ON entities BEGIN
+      INSERT INTO entities_fts(entities_fts, rowid, name) VALUES('delete', old.rowid, old.name);
+      INSERT INTO entities_fts(rowid, name) VALUES (new.rowid, new.name);
+    END;
+  `);
+}
+async function getReadyShardClient(projectName) {
+  if (!_shardingEnabled && _validationFailedForKey === _encryptionKey) {
+    throw new Error(
+      `Shard creation blocked: encryption key mismatch with existing shards. Run /exe-doctor to audit.`
+    );
+  }
+  if (!_keyValidated) {
+    if (!_keyValidationPromise) {
+      _keyValidationPromise = validateEncryptionKey();
+    }
+    const valid = await _keyValidationPromise;
+    if (!valid) {
+      throw new Error(
+        `Shard creation blocked: encryption key mismatch with existing shards. Run /exe-doctor to audit.`
+      );
+    }
+  }
+  if (!_shardingEnabled) {
+    throw new Error(
+      `Shard creation blocked: encryption key mismatch with existing shards. Run /exe-doctor to audit.`
+    );
+  }
+  const safeName = safeShardName(projectName);
+  let client = getShardClient(projectName);
+  try {
+    await ensureShardSchema(client);
+    return client;
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    if (!/SQLITE_NOTADB|file is not a database/i.test(message)) throw err;
+    client.close();
+    _shards.delete(safeName);
+    _shardLastAccess.delete(safeName);
+    const dbPath = path.join(SHARDS_DIR, `${safeName}.db`);
+    if (existsSync(dbPath)) {
+      const stat = statSync(dbPath);
+      const stamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
+      const archivedPath = path.join(SHARDS_DIR, `${safeName}.db.broken-${stamp}`);
+      renameSync(dbPath, archivedPath);
+      process.stderr.write(
+        `[shard-manager] Archived unreadable shard ${safeName}: ${archivedPath} (${stat.size} bytes, mtime ${stat.mtime.toISOString()})
+`
+      );
+    }
+    client = getShardClient(projectName);
+    await ensureShardSchema(client);
+    return client;
+  }
+}
+function evictLRU() {
+  let oldest = null;
+  let oldestTime = Infinity;
+  for (const [name, time] of _shardLastAccess) {
+    if (time < oldestTime) {
+      oldestTime = time;
+      oldest = name;
+    }
+  }
+  if (oldest) {
+    const client = _shards.get(oldest);
+    if (client) {
+      client.close();
+    }
+    _shards.delete(oldest);
+    _shardLastAccess.delete(oldest);
+  }
+}
+function evictIdleShards() {
+  const now = Date.now();
+  const toEvict = [];
+  for (const [name, lastAccess] of _shardLastAccess) {
+    if (now - lastAccess > SHARD_IDLE_MS) {
+      toEvict.push(name);
+    }
+  }
+  for (const name of toEvict) {
+    const client = _shards.get(name);
+    if (client) {
+      client.close();
+    }
+    _shards.delete(name);
+    _shardLastAccess.delete(name);
+  }
+}
+function getOpenShardCount() {
+  return _shards.size;
+}
+function disposeShards() {
+  if (_evictionTimer) {
+    clearInterval(_evictionTimer);
+    _evictionTimer = null;
+  }
+  for (const [, client] of _shards) {
+    client.close();
+  }
+  _shards.clear();
+  _shardLastAccess.clear();
+  _shardingEnabled = false;
+  _encryptionKey = null;
+}
+
+export {
+  initShardManager,
+  isShardingEnabled,
+  getShardsDir,
+  getShardClient,
+  shardExists,
+  listShards,
+  auditShardHealth,
+  ensureShardSchema,
+  getReadyShardClient,
+  getOpenShardCount,
+  disposeShards
+};

package/dist/chunk-EDNUE5L3.js

@@ -0,0 +1,38 @@
+import {
+  listReminders
+} from "./chunk-DEBLYXA2.js";
+
+// src/mcp/tools/list-reminders.ts
+import { z } from "zod";
+function registerListReminders(server) {
+  server.registerTool(
+    "list_reminders",
+    {
+      title: "List Reminders",
+      description: "List active reminders. Pass include_completed=true to see all.",
+      inputSchema: {
+        include_completed: z.boolean().optional().default(false).describe("Include completed reminders")
+      }
+    },
+    async ({ include_completed }) => {
+      const reminders = await listReminders(include_completed);
+      if (reminders.length === 0) {
+        return {
+          content: [{ type: "text", text: "No active reminders." }]
+        };
+      }
+      const lines = reminders.map((r) => {
+        const due = r.dueDate ? ` (due: ${r.dueDate})` : "";
+        const done = r.completedAt ? " [DONE]" : "";
+        return `\u2022 ${r.text}${due}${done}  [id: ${r.id.slice(0, 8)}]`;
+      });
+      return {
+        content: [{ type: "text", text: lines.join("\n") }]
+      };
+    }
+  );
+}
+
+export {
+  registerListReminders
+};