claude-memory-layer 1.0.52 → 1.0.54

package/dist/hooks/semantic-daemon.js

@@ -164,7 +164,13 @@ function toDate(value) {
   return new Date(String(value));
 }
 function createDatabase(dbPath, options) {
-  return new BetterSqlite3(dbPath, { readonly: options?.readOnly });
+  const db = new BetterSqlite3(dbPath, { readonly: options?.readOnly });
+  db.pragma("busy_timeout = 5000");
+  if (!options?.readOnly) {
+    db.pragma("journal_mode = WAL");
+    db.pragma("synchronous = NORMAL");
+  }
+  return db;
 }
 function dbRun(db, sql, params = []) {
   db.prepare(sql).run(...params);
@@ -397,19 +403,29 @@ var ConsolidatedStore = class {
    */
   async create(input) {
     const memoryId = randomUUID2();
-    await dbRun(
-      this.db,
+    const sourceEvents = Array.isArray(input.sourceEvents) ? input.sourceEvents : [];
+    const insertMemory = this.db.prepare(
       `INSERT INTO consolidated_memories
         (memory_id, summary, topics, source_events, confidence, created_at)
-       VALUES (?, ?, ?, ?, ?, CURRENT_TIMESTAMP)`,
-      [
+       VALUES (?, ?, ?, ?, ?, CURRENT_TIMESTAMP)`
+    );
+    const insertEvent = this.db.prepare(
+      `INSERT OR IGNORE INTO consolidated_memory_events (memory_id, event_id) VALUES (?, ?)`
+    );
+    this.db.transaction(() => {
+      insertMemory.run(
         memoryId,
         input.summary,
         JSON.stringify(input.topics),
-        JSON.stringify(input.sourceEvents),
+        JSON.stringify(sourceEvents),
         input.confidence
-      ]
-    );
+      );
+      for (const eventId of sourceEvents) {
+        if (typeof eventId === "string" && eventId.length > 0) {
+          insertEvent.run(memoryId, eventId);
+        }
+      }
+    })();
     return memoryId;
   }
   /**
@@ -515,11 +531,12 @@ var ConsolidatedStore = class {
    * Delete a consolidated memory
    */
   async delete(memoryId) {
-    await dbRun(
-      this.db,
-      `DELETE FROM consolidated_memories WHERE memory_id = ?`,
-      [memoryId]
-    );
+    const deleteEvents = this.db.prepare(`DELETE FROM consolidated_memory_events WHERE memory_id = ?`);
+    const deleteMemory = this.db.prepare(`DELETE FROM consolidated_memories WHERE memory_id = ?`);
+    this.db.transaction(() => {
+      deleteEvents.run(memoryId);
+      deleteMemory.run(memoryId);
+    })();
   }
   /**
    * Create a long-term rule promoted from stable summaries
@@ -632,16 +649,16 @@ var ConsolidatedStore = class {
    * Check if source events are already consolidated
    */
   async isAlreadyConsolidated(eventIds) {
-    for (const eventId of eventIds) {
-      const result = await dbAll(
-        this.db,
-        `SELECT COUNT(*) as count FROM consolidated_memories
-         WHERE source_events LIKE ?`,
-        [`%"${eventId}"%`]
-      );
-      if ((result[0]?.count || 0) > 0) return true;
-    }
-    return false;
+    if (eventIds.length === 0) return false;
+    const placeholders = eventIds.map(() => "?").join(",");
+    const rows = await dbAll(
+      this.db,
+      `SELECT memory_id FROM consolidated_memory_events
+       WHERE event_id IN (${placeholders})
+       LIMIT 1`,
+      eventIds
+    );
+    return rows.length > 0;
   }
   /**
    * Get the last consolidation time
@@ -2177,6 +2194,19 @@ function makeDedupeKey(content, sessionId) {
   return `${sessionId}:${contentHash}`;
 }
 
+// src/core/citation-generator.ts
+import { createHash as createHash2 } from "crypto";
+var ID_LENGTH = 6;
+var CHARSET = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
+function generateCitationId(eventId) {
+  const hash = createHash2("sha256").update(eventId).digest();
+  let id = "";
+  for (let i = 0; i < ID_LENGTH; i++) {
+    id += CHARSET[hash[i] % CHARSET.length];
+  }
+  return id;
+}
+
 // src/core/sqlite-event-store.ts
 import * as nodePath2 from "path";
 
@@ -2221,17 +2251,28 @@ function createSQLiteDatabase(path12, options) {
   }
   return db;
 }
+var statementCache = /* @__PURE__ */ new WeakMap();
+function prepareCached(db, sql) {
+  let cache = statementCache.get(db);
+  if (!cache) {
+    cache = /* @__PURE__ */ new Map();
+    statementCache.set(db, cache);
+  }
+  let stmt = cache.get(sql);
+  if (!stmt) {
+    stmt = db.prepare(sql);
+    cache.set(sql, stmt);
+  }
+  return stmt;
+}
 function sqliteRun(db, sql, params = []) {
-  const stmt = db.prepare(sql);
-  return stmt.run(...params);
+  return prepareCached(db, sql).run(...params);
 }
 function sqliteAll(db, sql, params = []) {
-  const stmt = db.prepare(sql);
-  return stmt.all(...params);
+  return prepareCached(db, sql).all(...params);
 }
 function sqliteGet(db, sql, params = []) {
-  const stmt = db.prepare(sql);
-  return stmt.get(...params);
+  return prepareCached(db, sql).get(...params);
 }
 function sqliteExec(db, sql) {
   db.exec(sql);
@@ -2653,6 +2694,7 @@ function normalizeQueryRewriteKind(value) {
 var REWRITTEN_QUERY_REWRITE_KIND_SQL = `LOWER(TRIM(COALESCE(query_rewrite_kind, 'none'))) IN ('follow-up-context', 'intent-rewrite')`;
 var DEFAULT_OUTBOX_STUCK_THRESHOLD_MS = 5 * 60 * 1e3;
 var DEFAULT_OUTBOX_MAX_RETRIES = 3;
+var SQLITE_SCHEMA_VERSION = 1;
 function emptyOutboxRecoveryResult() {
   return {
     embedding: { recoveredProcessing: 0, retriedFailed: 0 },
@@ -2997,6 +3039,15 @@ var SQLiteEventStore = class {
         access_count INTEGER DEFAULT 0
       );
 
+      -- Junction: consolidated memory -> source event id (indexed lookup that
+      -- replaces per-event source_events LIKE scans during consolidation).
+      CREATE TABLE IF NOT EXISTS consolidated_memory_events (
+        memory_id TEXT NOT NULL,
+        event_id TEXT NOT NULL,
+        PRIMARY KEY (memory_id, event_id)
+      );
+      CREATE INDEX IF NOT EXISTS idx_cme_event ON consolidated_memory_events(event_id);
+
       -- Continuity Log table (tracks context transitions)
       CREATE TABLE IF NOT EXISTS continuity_log (
         log_id TEXT PRIMARY KEY,
@@ -3356,11 +3407,17 @@ var SQLiteEventStore = class {
         DELETE FROM events_fts WHERE rowid = OLD.rowid;
         INSERT INTO events_fts(rowid, content, event_id) VALUES (NEW.rowid, NEW.content, NEW.id);
       END;
+
+      -- Reverse index for citation ids (a non-reversible hash of event id), so
+      -- citation lookups are O(1) instead of scanning recent events and hashing
+      -- each one. Populated lazily/self-healing by getEventByCitationId.
+      CREATE TABLE IF NOT EXISTS event_citations (
+        event_id TEXT PRIMARY KEY,
+        citation_id TEXT NOT NULL
+      );
+      CREATE INDEX IF NOT EXISTS idx_event_citations_citation ON event_citations(citation_id);
     `);
-    try {
-      sqliteExec(this.db, `ALTER TABLE memory_action_edges ADD COLUMN source TEXT NOT NULL DEFAULT 'manual';`);
-    } catch {
-    }
+    this.addColumnIfMissing("memory_action_edges", "source", `TEXT NOT NULL DEFAULT 'manual'`);
     try {
       const edgeIndexes = sqliteAll(this.db, `PRAGMA index_list(memory_action_edges)`, []);
       const hasSourceAwareUnique = edgeIndexes.some((index) => {
@@ -3397,55 +3454,17 @@ var SQLiteEventStore = class {
       }
     } catch {
     }
-    try {
-      sqliteExec(this.db, `ALTER TABLE retrieval_traces ADD COLUMN selected_details_json TEXT;`);
-    } catch {
-    }
-    try {
-      sqliteExec(this.db, `ALTER TABLE retrieval_traces ADD COLUMN candidate_details_json TEXT;`);
-    } catch {
-    }
-    try {
-      sqliteExec(this.db, `ALTER TABLE retrieval_traces ADD COLUMN raw_query_text TEXT;`);
-    } catch {
-    }
-    try {
-      sqliteExec(this.db, `ALTER TABLE retrieval_traces ADD COLUMN query_rewrite_kind TEXT;`);
-    } catch {
-    }
+    this.addColumnIfMissing("retrieval_traces", "selected_details_json", "TEXT");
+    this.addColumnIfMissing("retrieval_traces", "candidate_details_json", "TEXT");
+    this.addColumnIfMissing("retrieval_traces", "raw_query_text", "TEXT");
+    this.addColumnIfMissing("retrieval_traces", "query_rewrite_kind", "TEXT");
     try {
       sqliteExec(this.db, `CREATE INDEX IF NOT EXISTS idx_retrieval_traces_query_rewrite_kind ON retrieval_traces(query_rewrite_kind);`);
     } catch {
     }
-    const tableInfo = sqliteAll(this.db, "PRAGMA table_info(events)", []);
-    const columnNames = tableInfo.map((col) => col.name);
-    if (!columnNames.includes("access_count")) {
-      try {
-        sqliteExec(this.db, `
-          ALTER TABLE events ADD COLUMN access_count INTEGER DEFAULT 0;
-        `);
-      } catch (err) {
-        console.error("Error adding access_count column:", err);
-      }
-    }
-    if (!columnNames.includes("last_accessed_at")) {
-      try {
-        sqliteExec(this.db, `
-          ALTER TABLE events ADD COLUMN last_accessed_at TEXT;
-        `);
-      } catch (err) {
-        console.error("Error adding last_accessed_at column:", err);
-      }
-    }
-    if (!columnNames.includes("turn_id")) {
-      try {
-        sqliteExec(this.db, `
-          ALTER TABLE events ADD COLUMN turn_id TEXT;
-        `);
-      } catch (err) {
-        console.error("Error adding turn_id column:", err);
-      }
-    }
+    this.addColumnIfMissing("events", "access_count", "INTEGER DEFAULT 0");
+    this.addColumnIfMissing("events", "last_accessed_at", "TEXT");
+    this.addColumnIfMissing("events", "turn_id", "TEXT");
     try {
       sqliteExec(this.db, `
         CREATE INDEX IF NOT EXISTS idx_events_access_count ON events(access_count DESC);
@@ -3462,8 +3481,18 @@ var SQLiteEventStore = class {
       sqliteExec(this.db, `
         CREATE INDEX IF NOT EXISTS idx_events_turn_id ON events(turn_id);
       `);
-    } catch (err) {
+    } catch {
     }
+    const cmeCount = sqliteGet(this.db, `SELECT COUNT(*) as c FROM consolidated_memory_events`, []);
+    if ((cmeCount?.c ?? 0) === 0) {
+      sqliteExec(this.db, `
+        INSERT OR IGNORE INTO consolidated_memory_events (memory_id, event_id)
+        SELECT cm.memory_id, je.value
+        FROM consolidated_memories cm, json_each(cm.source_events) je
+        WHERE json_valid(cm.source_events);
+      `);
+    }
+    sqliteExec(this.db, `PRAGMA user_version = ${SQLITE_SCHEMA_VERSION}`);
     this.initialized = true;
   }
   /**
@@ -3595,6 +3624,67 @@ var SQLiteEventStore = class {
     );
     return rows.map(this.rowToEvent);
   }
+  /**
+   * Aggregate event counts by type via SQL GROUP BY, instead of loading rows
+   * into memory and counting in JS. Counts all events (the old recent-window
+   * scan also under-counted stores larger than its cap).
+   */
+  async getEventTypeCounts(options) {
+    await this.initialize();
+    const rows = sqliteAll(
+      this.db,
+      `SELECT event_type, COUNT(*) as count FROM events WHERE ${maybeQuarantinePredicate(options)} GROUP BY event_type`,
+      []
+    );
+    return rows.map((row) => ({ eventType: row.event_type, count: row.count }));
+  }
+  /**
+   * Fetch every event at/after an ISO timestamp (ascending), with no row cap.
+   * For window-scoped analytics (KPI/usefulness) this fetches exactly the events
+   * the window needs instead of an arbitrary "most recent N" slice that both
+   * over-fetches sparse windows and truncates very active ones.
+   */
+  async getEventsAfter(sinceIso, options) {
+    await this.initialize();
+    const rows = sqliteAll(
+      this.db,
+      `SELECT * FROM events WHERE timestamp >= ? AND ${maybeQuarantinePredicate(options)} ORDER BY timestamp ASC`,
+      [sinceIso]
+    );
+    return rows.map((row) => this.rowToEvent(row));
+  }
+  /** Count distinct sessions via SQL instead of materializing a Set in JS. */
+  async getDistinctSessionCount(options) {
+    await this.initialize();
+    const row = sqliteGet(
+      this.db,
+      `SELECT COUNT(DISTINCT session_id) as count FROM events WHERE ${maybeQuarantinePredicate(options)}`,
+      []
+    );
+    return row?.count ?? 0;
+  }
+  /**
+   * Per-day event counts (with type breakdown) since an ISO timestamp, computed
+   * by SQL GROUP BY on the date prefix. Timestamps are stored as ISO-8601
+   * strings, so substr(...,1,10) is the UTC day and `timestamp >= ?` compares
+   * lexicographically.
+   */
+  async getDailyEventCounts(sinceIso, options) {
+    await this.initialize();
+    return sqliteAll(
+      this.db,
+      `SELECT substr(timestamp, 1, 10) as day,
+              COUNT(*) as total,
+              SUM(CASE WHEN event_type = 'user_prompt' THEN 1 ELSE 0 END) as prompts,
+              SUM(CASE WHEN event_type = 'agent_response' THEN 1 ELSE 0 END) as responses,
+              SUM(CASE WHEN event_type = 'tool_observation' THEN 1 ELSE 0 END) as tools
+       FROM events
+       WHERE timestamp >= ? AND ${maybeQuarantinePredicate(options)}
+       GROUP BY day
+       ORDER BY day ASC`,
+      [sinceIso]
+    );
+  }
   /**
    * Get event by ID
    */
@@ -3608,6 +3698,71 @@ var SQLiteEventStore = class {
     if (!row) return null;
     return this.rowToEvent(row);
   }
+  /**
+   * Batch-fetch events by id in a single query, applying the same quarantine
+   * predicate as getEvent. Lets hot paths replace N sequential round-trips with
+   * one. Missing ids are simply absent from the result (order not guaranteed).
+   */
+  async getEvents(ids, options) {
+    await this.initialize();
+    if (ids.length === 0) return [];
+    const placeholders = ids.map(() => "?").join(",");
+    const rows = sqliteAll(
+      this.db,
+      `SELECT * FROM events WHERE id IN (${placeholders}) AND ${maybeQuarantinePredicate(options)}`,
+      ids
+    );
+    return rows.map((row) => this.rowToEvent(row));
+  }
+  /**
+   * Resolve an event from its citation id via the reverse index, instead of
+   * scanning recent events and hashing each one. The index is self-healing: a
+   * miss triggers a one-time backfill of any events not yet indexed (covering
+   * freshly appended events) before retrying.
+   */
+  async getEventByCitationId(citationId, options) {
+    await this.initialize();
+    if (!citationId) return null;
+    let row = sqliteGet(
+      this.db,
+      `SELECT event_id FROM event_citations WHERE citation_id = ? LIMIT 1`,
+      [citationId]
+    );
+    if (!row) {
+      this.indexMissingCitations();
+      row = sqliteGet(
+        this.db,
+        `SELECT event_id FROM event_citations WHERE citation_id = ? LIMIT 1`,
+        [citationId]
+      );
+    }
+    if (!row) return null;
+    return this.getEvent(row.event_id, options);
+  }
+  /**
+   * Backfill citation ids for any events not yet present in event_citations.
+   * Gated on a cheap count comparison so the common (fully-indexed) path does no
+   * work, and the scan only runs when there are genuinely new events to index.
+   */
+  indexMissingCitations() {
+    const eventCount = sqliteGet(this.db, `SELECT COUNT(*) as c FROM events`, [])?.c ?? 0;
+    const indexedCount = sqliteGet(this.db, `SELECT COUNT(*) as c FROM event_citations`, [])?.c ?? 0;
+    if (indexedCount >= eventCount) return;
+    const unindexed = sqliteAll(
+      this.db,
+      `SELECT e.id FROM events e
+       LEFT JOIN event_citations ec ON ec.event_id = e.id
+       WHERE ec.event_id IS NULL`,
+      []
+    );
+    if (unindexed.length === 0) return;
+    const insert = this.db.prepare(`INSERT OR IGNORE INTO event_citations (event_id, citation_id) VALUES (?, ?)`);
+    this.db.transaction(() => {
+      for (const { id } of unindexed) {
+        insert.run(id, generateCitationId(id));
+      }
+    })();
+  }
   /**
    * Get events since a timestamp (for sync)
    */
@@ -3809,25 +3964,22 @@ var SQLiteEventStore = class {
    */
   async getPendingOutboxItems(limit = 32) {
     await this.initialize();
-    const pending = sqliteAll(
-      this.db,
-      `SELECT * FROM embedding_outbox
-       WHERE status = 'pending'
-       ORDER BY created_at
-       LIMIT ?`,
-      [limit]
-    );
-    if (pending.length === 0) return [];
-    const ids = pending.map((r) => r.id);
-    const placeholders = ids.map(() => "?").join(",");
-    sqliteRun(
+    const claimed = sqliteAll(
       this.db,
       `UPDATE embedding_outbox
        SET status = 'processing', processed_at = datetime('now'), error_message = NULL
-       WHERE id IN (${placeholders})`,
-      ids
+       WHERE id IN (
+         SELECT id FROM embedding_outbox
+         WHERE status = 'pending'
+         ORDER BY created_at
+         LIMIT ?
+       )
+       RETURNING *`,
+      [limit]
     );
-    return pending.map((row) => ({
+    if (claimed.length === 0) return [];
+    claimed.sort((a, b) => String(a.created_at).localeCompare(String(b.created_at)));
+    return claimed.map((row) => ({
       id: row.id,
       eventId: row.event_id,
       content: row.content,
@@ -4431,7 +4583,7 @@ var SQLiteEventStore = class {
     const promptEvents = sessionEvents.filter((e) => e.event_type === "user_prompt");
     const toolEvents = sessionEvents.filter((e) => e.event_type === "tool_observation");
     let toolSuccessCount = 0;
-    let toolTotalCount = toolEvents.length;
+    const toolTotalCount = toolEvents.length;
     for (const t of toolEvents) {
       try {
         const content = JSON.parse(t.content);
@@ -4594,10 +4746,14 @@ var SQLiteEventStore = class {
    * Rebuild FTS index from existing events
    * Call this once after upgrading to FTS5
    */
-  async rebuildFtsIndex() {
-    await this.initialize();
-    const countRow = sqliteGet(this.db, "SELECT COUNT(*) as count FROM events", []);
-    const totalEvents = countRow?.count ?? 0;
+  /**
+   * Drop and recreate the events_fts virtual table + sync triggers, repopulating
+   * from the current events table. Recreating the table (instead of issuing
+   * DELETEs against it) sidesteps a quirk where older migrated FTS5 tables fail
+   * with `no such column: T.event_id` on synthetic deletes. Safe to call inside
+   * a transaction (pure DDL + INSERT...SELECT, no transaction control).
+   */
+  recreateEventsFtsTable() {
     sqliteExec(this.db, `
       DROP TRIGGER IF EXISTS events_fts_insert;
       DROP TRIGGER IF EXISTS events_fts_delete;
@@ -4626,6 +4782,12 @@ var SQLiteEventStore = class {
         INSERT INTO events_fts(rowid, content, event_id) VALUES (NEW.rowid, NEW.content, NEW.id);
       END;
     `);
+  }
+  async rebuildFtsIndex() {
+    await this.initialize();
+    const countRow = sqliteGet(this.db, "SELECT COUNT(*) as count FROM events", []);
+    const totalEvents = countRow?.count ?? 0;
+    this.recreateEventsFtsTable();
     return totalEvents;
   }
   /**
@@ -4643,6 +4805,35 @@ var SQLiteEventStore = class {
       return false;
     }
   }
+  hasTable(tableName) {
+    if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(tableName)) return false;
+    try {
+      const rows = sqliteAll(
+        this.db,
+        `SELECT name FROM sqlite_master WHERE type = 'table' AND name = ? LIMIT 1`,
+        [tableName]
+      );
+      return rows.length > 0;
+    } catch {
+      return false;
+    }
+  }
+  /**
+   * Add a column only when its table exists and the column is missing.
+   *
+   * Unlike a blind `try { ALTER } catch {}`, this distinguishes "already
+   * migrated" / "table not present yet" (both safely skipped) from a genuine
+   * failure (disk full, corruption), which is allowed to surface instead of
+   * being silently swallowed as if the migration had succeeded.
+   */
+  addColumnIfMissing(table, column, definition) {
+    if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(table) || !/^[A-Za-z_][A-Za-z0-9_]*$/.test(column)) {
+      throw new Error(`Invalid identifier in migration: ${table}.${column}`);
+    }
+    if (!this.hasTable(table)) return;
+    if (this.hasTableColumn(table, column)) return;
+    sqliteExec(this.db, `ALTER TABLE ${table} ADD COLUMN ${column} ${definition};`);
+  }
   async recordRetrievalTrace(input) {
     await this.initialize();
     const traceId = randomUUID6();
@@ -4728,6 +4919,45 @@ var SQLiteEventStore = class {
          FROM retrieval_traces`,
         []
       );
+      const strategyColumnSql = this.hasTableColumn("retrieval_traces", "strategy") ? "COALESCE(NULLIF(TRIM(strategy), ''), 'unknown')" : "'unknown'";
+      const strategyRows = sqliteAll(
+        this.db,
+        `SELECT
+          ${strategyColumnSql} as strategy,
+          COUNT(*) as total_queries,
+          SUM(CASE WHEN selected_count > 0 THEN 1 ELSE 0 END) as queries_with_selection,
+          SUM(CASE WHEN ${rewrittenQueryRewriteKindSql} THEN 1 ELSE 0 END) as rewritten_queries,
+          SUM(candidate_count) as total_candidate_count,
+          SUM(selected_count) as total_selected_count,
+          AVG(candidate_count) as avg_candidate_count,
+          AVG(selected_count) as avg_selected_count,
+          CASE
+            WHEN SUM(candidate_count) > 0 THEN (SUM(selected_count) * 1.0 / SUM(candidate_count))
+            ELSE 0
+          END as selection_rate
+         FROM retrieval_traces
+         GROUP BY ${strategyColumnSql}
+         ORDER BY total_queries DESC, strategy ASC`,
+        []
+      );
+      const strategyBreakdown = strategyRows.map((strategyRow) => {
+        const strategyTotalQueries = Number(strategyRow.total_queries || 0);
+        const strategyQueriesWithSelection = Number(strategyRow.queries_with_selection || 0);
+        const strategyRewrittenQueries = Number(strategyRow.rewritten_queries || 0);
+        return {
+          strategy: String(strategyRow.strategy || "unknown"),
+          totalQueries: strategyTotalQueries,
+          queriesWithSelection: strategyQueriesWithSelection,
+          rewrittenQueries: strategyRewrittenQueries,
+          rewriteRate: strategyTotalQueries > 0 ? strategyRewrittenQueries / strategyTotalQueries : 0,
+          totalCandidateCount: Number(strategyRow.total_candidate_count || 0),
+          totalSelectedCount: Number(strategyRow.total_selected_count || 0),
+          avgCandidateCount: Number(strategyRow.avg_candidate_count || 0),
+          avgSelectedCount: Number(strategyRow.avg_selected_count || 0),
+          selectionRate: Number(strategyRow.selection_rate || 0),
+          queryYieldRate: strategyTotalQueries > 0 ? strategyQueriesWithSelection / strategyTotalQueries : 0
+        };
+      });
       const totalQueries = Number(row?.total_queries || 0);
       const rewrittenQueries = Number(row?.rewritten_queries || 0);
       const rawQueries = Math.max(0, totalQueries - rewrittenQueries);
@@ -4745,7 +4975,8 @@ var SQLiteEventStore = class {
         rewrittenSelectionRate: rewrittenQueries > 0 ? rewrittenQueriesWithSelection / rewrittenQueries : 0,
         rawSelectionRate: rawQueries > 0 ? rawQueriesWithSelection / rawQueries : 0,
         avgSelectedCountForRewrittenQueries: Number(row?.avg_selected_count_for_rewritten_queries || 0),
-        avgSelectedCountForRawQueries: Number(row?.avg_selected_count_for_raw_queries || 0)
+        avgSelectedCountForRawQueries: Number(row?.avg_selected_count_for_raw_queries || 0),
+        strategyBreakdown
       };
     } catch (err) {
       if (err?.message?.includes("no such table")) {
@@ -4761,7 +4992,8 @@ var SQLiteEventStore = class {
           rewrittenSelectionRate: 0,
           rawSelectionRate: 0,
           avgSelectedCountForRewrittenQueries: 0,
-          avgSelectedCountForRawQueries: 0
+          avgSelectedCountForRawQueries: 0,
+          strategyBreakdown: []
         };
       }
       throw err;
@@ -4878,38 +5110,19 @@ var SQLiteEventStore = class {
     if (events.length === 0) return 0;
     const eventIds = events.map((e) => e.id);
     const placeholders = eventIds.map(() => "?").join(",");
-    const ftsTriggersDropped = [];
-    for (const triggerName of ["events_fts_delete", "events_fts_update", "events_fts_insert"]) {
-      try {
+    const relatedTables = ["event_dedup", "memory_levels", "embedding_queue", "embedding_outbox", "vector_outbox", "event_citations"].filter((table) => this.hasTable(table) && this.hasTableColumn(table, "event_id"));
+    const runDelete = this.db.transaction(() => {
+      for (const triggerName of ["events_fts_delete", "events_fts_update", "events_fts_insert"]) {
         sqliteRun(this.db, `DROP TRIGGER IF EXISTS ${triggerName}`);
-        ftsTriggersDropped.push(triggerName);
-      } catch {
       }
-    }
-    for (const table of ["event_dedup", "memory_levels", "embedding_queue", "embedding_outbox", "vector_outbox"]) {
-      try {
+      for (const table of relatedTables) {
         sqliteRun(this.db, `DELETE FROM ${table} WHERE event_id IN (${placeholders})`, eventIds);
-      } catch {
-      }
-    }
-    const result = sqliteRun(this.db, `DELETE FROM events WHERE session_id = ?`, [sessionId]);
-    if (ftsTriggersDropped.length > 0) {
-      try {
-        sqliteRun(this.db, `INSERT INTO events_fts(events_fts) VALUES('rebuild')`);
-        sqliteRun(this.db, `CREATE TRIGGER IF NOT EXISTS events_fts_insert AFTER INSERT ON events BEGIN
-          INSERT INTO events_fts(rowid, content, event_id) VALUES (NEW.rowid, NEW.content, NEW.id);
-        END`);
-        sqliteRun(this.db, `CREATE TRIGGER IF NOT EXISTS events_fts_delete AFTER DELETE ON events BEGIN
-          DELETE FROM events_fts WHERE rowid = OLD.rowid;
-        END`);
-        sqliteRun(this.db, `CREATE TRIGGER IF NOT EXISTS events_fts_update AFTER UPDATE ON events BEGIN
-          DELETE FROM events_fts WHERE rowid = OLD.rowid;
-          INSERT INTO events_fts(rowid, content, event_id) VALUES (NEW.rowid, NEW.content, NEW.id);
-        END`);
-      } catch {
       }
-    }
-    return result.changes || 0;
+      const result = sqliteRun(this.db, `DELETE FROM events WHERE session_id = ?`, [sessionId]);
+      this.recreateEventsFtsTable();
+      return result.changes || 0;
+    });
+    return runDelete();
   }
   /**
    * Convert database row to MemoryEvent
@@ -7242,7 +7455,7 @@ var SessionActorRepository = class {
 };
 
 // src/core/operations/perspective-observation-repository.ts
-import { createHash as createHash3, randomUUID as randomUUID9 } from "crypto";
+import { createHash as createHash4, randomUUID as randomUUID9 } from "crypto";
 function projectHashToStorage4(projectHash) {
   return projectHash ?? "";
 }
@@ -7279,7 +7492,7 @@ function sanitizeStoredRecord(value) {
   return sanitizeGovernanceAuditValue(value);
 }
 function stableHash(value) {
-  return createHash3("sha256").update(JSON.stringify(value)).digest("hex");
+  return createHash4("sha256").update(JSON.stringify(value)).digest("hex");
 }
 function evidenceHash(sourceEventIds, sourceObservationIds) {
   return stableHash({
@@ -8394,6 +8607,30 @@ var MemoryQueryService = class {
       score: 1 - (r.rank - minRank) / rankRange
     })).filter((r) => !options?.minScore || r.score >= options.minScore);
   }
+  async getEvent(id) {
+    await this.initialize();
+    return this.queryStore.getEvent(id);
+  }
+  async getEventByCitationId(citationId) {
+    await this.initialize();
+    return this.getMaintenanceStore("getEventByCitationId").getEventByCitationId(citationId);
+  }
+  async getEventsAfter(sinceIso) {
+    await this.initialize();
+    return this.getMaintenanceStore("getEventsAfter").getEventsAfter(sinceIso);
+  }
+  async getEventTypeCounts() {
+    await this.initialize();
+    return this.getMaintenanceStore("getEventTypeCounts").getEventTypeCounts();
+  }
+  async getDistinctSessionCount() {
+    await this.initialize();
+    return this.getMaintenanceStore("getDistinctSessionCount").getDistinctSessionCount();
+  }
+  async getDailyEventCounts(sinceIso) {
+    await this.initialize();
+    return this.getMaintenanceStore("getDailyEventCounts").getDailyEventCounts(sinceIso);
+  }
   async getSessionHistory(sessionId) {
     await this.initialize();
     return this.queryStore.getSessionEvents(sessionId);
@@ -9362,11 +9599,12 @@ var Retriever = class {
     if (!scope && projectScopeMode === "global" && facetFilters === null) return results;
     const normalizedIncludes = (scope?.contentIncludes || []).map((s) => s.toLowerCase());
     const filtered = [];
+    const eventMap = await this.fetchEventsByIds(results.map((r) => r.eventId));
     for (const result of results) {
       if (scope?.sessionId && result.sessionId !== scope.sessionId) continue;
       if (scope?.sessionIdPrefix && !result.sessionId.startsWith(scope.sessionIdPrefix)) continue;
       if (scope?.eventTypes && scope.eventTypes.length > 0 && !scope.eventTypes.includes(result.eventType)) continue;
-      const event = await this.eventStore.getEvent(result.eventId);
+      const event = eventMap.get(result.eventId);
       if (!event) continue;
       if (scope?.canonicalKeyPrefix && !event.canonicalKey.startsWith(scope.canonicalKeyPrefix)) continue;
       if (normalizedIncludes.length > 0) {
@@ -9475,10 +9713,30 @@ var Retriever = class {
   async retrieveRecent(limit = 100) {
     return this.eventStore.getRecentEvents(limit);
   }
+  /**
+   * Batch-load events by id into a Map in a single query, de-duplicating ids.
+   * Replaces per-result getEvent round-trips in the scope/enrich hot paths.
+   */
+  async fetchEventsByIds(ids) {
+    const map = /* @__PURE__ */ new Map();
+    if (ids.length === 0) return map;
+    const unique = [...new Set(ids)];
+    if (typeof this.eventStore.getEvents === "function") {
+      const events = await this.eventStore.getEvents(unique);
+      for (const event of events) map.set(event.id, event);
+    } else {
+      const events = await Promise.all(unique.map((id) => this.eventStore.getEvent(id)));
+      for (const event of events) {
+        if (event) map.set(event.id, event);
+      }
+    }
+    return map;
+  }
   async enrichResults(results, options, query) {
     const memories = [];
+    const eventMap = await this.fetchEventsByIds(results.map((r) => r.eventId));
     for (const result of results) {
-      const event = await this.eventStore.getEvent(result.eventId);
+      const event = eventMap.get(result.eventId);
       if (!event) continue;
       if (this.graduation) {
         this.graduation.recordAccess(event.id, options.sessionId || "unknown", result.score);
@@ -12206,6 +12464,34 @@ var MemoryService = class {
   async rebuildFtsIndex() {
     return this.queryService.rebuildFtsIndex();
   }
+  /**
+   * Get a single event by id (indexed lookup).
+   */
+  async getEvent(id) {
+    return this.queryService.getEvent(id);
+  }
+  /**
+   * Resolve an event from its citation id via the reverse index.
+   */
+  async getEventByCitationId(citationId) {
+    return this.queryService.getEventByCitationId(citationId);
+  }
+  /** All events at/after an ISO timestamp (ascending, uncapped). */
+  async getEventsAfter(sinceIso) {
+    return this.queryService.getEventsAfter(sinceIso);
+  }
+  /** Aggregate event counts by type (SQL GROUP BY). */
+  async getEventTypeCounts() {
+    return this.queryService.getEventTypeCounts();
+  }
+  /** Count distinct sessions (SQL). */
+  async getDistinctSessionCount() {
+    return this.queryService.getDistinctSessionCount();
+  }
+  /** Per-day event counts with type breakdown since an ISO timestamp (SQL). */
+  async getDailyEventCounts(sinceIso) {
+    return this.queryService.getDailyEventCounts(sinceIso);
+  }
   /**
    * Get session history
    */
@@ -12529,6 +12815,18 @@ var getLightweightMemoryService = defaultRegistry.getLightweightMemoryService;
 var getLightweightMemoryServiceForProject = defaultRegistry.getLightweightMemoryServiceForProject;
 var createMemoryService = defaultRegistry.createMemoryService;
 
+// src/adapters/claude/hooks/hook-runtime.ts
+function readNumberEnv(name, fallback, options = {}) {
+  const raw = process.env[name];
+  if (raw === void 0 || raw.trim() === "") return fallback;
+  const parsed = options.integer ? Number.parseInt(raw, 10) : Number.parseFloat(raw);
+  if (!Number.isFinite(parsed)) return fallback;
+  let value = parsed;
+  if (options.min !== void 0) value = Math.max(options.min, value);
+  if (options.max !== void 0) value = Math.min(options.max, value);
+  return value;
+}
+
 // src/adapters/claude/hooks/semantic-daemon.ts
 var SOCKET_PATH = process.env.CLAUDE_MEMORY_SEMANTIC_SOCKET || path11.join(
   os6.homedir(),
@@ -12536,7 +12834,7 @@ var SOCKET_PATH = process.env.CLAUDE_MEMORY_SEMANTIC_SOCKET || path11.join(
   "memory",
   "semantic-daemon.sock"
 );
-var IDLE_TIMEOUT_MS = parseInt(process.env.CLAUDE_MEMORY_SEMANTIC_DAEMON_IDLE_MS || "600000");
+var IDLE_TIMEOUT_MS = readNumberEnv("CLAUDE_MEMORY_SEMANTIC_DAEMON_IDLE_MS", 6e5, { integer: true, min: 1e3 });
 var serviceCache = /* @__PURE__ */ new Map();
 var server = null;
 var idleTimer = null;