claude-memory-layer 1.0.53 → 1.0.54

package/dist/hooks/post-tool-use.js

@@ -276,7 +276,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);
@@ -509,19 +515,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;
   }
   /**
@@ -627,11 +643,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
@@ -744,16 +761,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
@@ -2289,6 +2306,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";
 
@@ -2333,17 +2363,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);
@@ -2765,6 +2806,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 },
@@ -3109,6 +3151,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,
@@ -3468,11 +3519,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) => {
@@ -3509,55 +3566,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);
@@ -3574,8 +3593,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;
   }
   /**
@@ -3707,6 +3736,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
    */
@@ -3720,6 +3810,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)
    */
@@ -3921,25 +4076,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,
@@ -4543,7 +4695,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);
@@ -4706,10 +4858,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;
@@ -4738,6 +4894,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;
   }
   /**
@@ -4755,6 +4917,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();
@@ -4840,6 +5031,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);
@@ -4857,7 +5087,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")) {
@@ -4873,7 +5104,8 @@ var SQLiteEventStore = class {
           rewrittenSelectionRate: 0,
           rawSelectionRate: 0,
           avgSelectedCountForRewrittenQueries: 0,
-          avgSelectedCountForRawQueries: 0
+          avgSelectedCountForRawQueries: 0,
+          strategyBreakdown: []
         };
       }
       throw err;
@@ -4990,38 +5222,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
@@ -7594,7 +7807,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 ?? "";
 }
@@ -7631,7 +7844,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({
@@ -8746,6 +8959,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);
@@ -9714,11 +9951,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) {
@@ -9827,10 +10065,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);
@@ -12558,6 +12816,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
    */
@@ -12927,6 +13213,75 @@ function clearTurnState(sessionId) {
   }
 }
 
+// src/adapters/claude/hooks/hook-runtime.ts
+var DEFAULT_STDIN_TIMEOUT_MS = 1e4;
+var DEFAULT_OVERALL_TIMEOUT_MS = 3e4;
+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;
+}
+function readPositiveIntEnv(name, fallback) {
+  return readNumberEnv(name, fallback, { integer: true, min: 1 });
+}
+function readStdin(options = {}) {
+  const timeoutMs = options.timeoutMs ?? readPositiveIntEnv("CLAUDE_MEMORY_HOOK_STDIN_TIMEOUT_MS", DEFAULT_STDIN_TIMEOUT_MS);
+  return new Promise((resolve2) => {
+    const stdin = process.stdin;
+    let data = "";
+    let settled = false;
+    const onData = (chunk) => {
+      data += chunk;
+    };
+    const finish = () => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      stdin.off("data", onData);
+      stdin.off("end", finish);
+      stdin.off("error", finish);
+      resolve2(data);
+    };
+    const timer = setTimeout(finish, timeoutMs);
+    timer.unref?.();
+    stdin.setEncoding("utf8");
+    stdin.on("data", onData);
+    stdin.on("end", finish);
+    stdin.on("error", finish);
+  });
+}
+function emitHookOutput(json) {
+  process.stdout.write(json.endsWith("\n") ? json : `${json}
+`);
+}
+async function runHook(options, run) {
+  const debug = Boolean(process.env.CLAUDE_MEMORY_DEBUG);
+  const timeoutMs = options.timeoutMs ?? readPositiveIntEnv("CLAUDE_MEMORY_HOOK_TIMEOUT_MS", DEFAULT_OVERALL_TIMEOUT_MS);
+  let emitted = false;
+  const emit = (json) => {
+    if (emitted) return;
+    emitted = true;
+    emitHookOutput(json);
+  };
+  const watchdog = setTimeout(() => {
+    if (debug) console.error(`[${options.name}] hook timed out after ${timeoutMs}ms; forcing exit`);
+    emit(options.fallbackOutput);
+    process.exit(0);
+  }, timeoutMs);
+  watchdog.unref?.();
+  try {
+    emit(await run());
+  } catch (error) {
+    if (debug) console.error(`[${options.name}] hook error:`, error);
+    emit(options.fallbackOutput);
+  }
+}
+
 // src/adapters/claude/hooks/post-tool-use.ts
 var DEFAULT_CONFIG6 = {
   enabled: true,
@@ -12946,7 +13301,7 @@ var DEFAULT_CONFIG6 = {
     "Skill",
     "EnterPlanMode"
   ],
-  minOutputLength: parseInt(process.env.CLAUDE_MEMORY_TOOL_MIN_OUTPUT_LEN || "100"),
+  minOutputLength: readNumberEnv("CLAUDE_MEMORY_TOOL_MIN_OUTPUT_LEN", 100, { integer: true, min: 0 }),
   maxOutputLength: 1e4,
   maxOutputLines: 100,
   storeOnlyOnSuccess: false
@@ -13021,8 +13376,12 @@ function isToolSuccess(response) {
   return true;
 }
 async function main() {
-  const inputData = await readStdin();
-  const input = JSON.parse(inputData);
+  let input;
+  try {
+    input = JSON.parse(await readStdin());
+  } catch {
+    return JSON.stringify({});
+  }
   const config = { ...DEFAULT_CONFIG6 };
   const privacyConfig = DEFAULT_PRIVACY_CONFIG;
   const envBlocklist = process.env.CLAUDE_MEMORY_TOOL_BLOCKLIST;
@@ -13030,18 +13389,15 @@ async function main() {
     config.excludedTools = envBlocklist.split(",").map((s) => s.trim()).filter(Boolean);
   }
   if (!config.enabled) {
-    console.log(JSON.stringify({}));
-    return;
+    return JSON.stringify({});
   }
   if (config.excludedTools?.includes(input.tool_name)) {
-    console.log(JSON.stringify({}));
-    return;
+    return JSON.stringify({});
   }
   const toolOutput = extractToolOutput(input.tool_response);
   const success = isToolSuccess(input.tool_response);
   if (!success && config.storeOnlyOnSuccess) {
-    console.log(JSON.stringify({}));
-    return;
+    return JSON.stringify({});
   }
   if (!hasSignificantOutput(
     input.tool_name,
@@ -13049,8 +13405,7 @@ async function main() {
     input.tool_response,
     config.minOutputLength ?? 100
   )) {
-    console.log(JSON.stringify({}));
-    return;
+    return JSON.stringify({});
   }
   try {
     const memoryService = getLightweightMemoryService(input.session_id);
@@ -13082,27 +13437,15 @@ async function main() {
       }
     };
     await memoryService.storeToolObservation(input.session_id, payload);
-    console.log(JSON.stringify({}));
+    return JSON.stringify({});
   } catch (error) {
     if (process.env.CLAUDE_MEMORY_DEBUG) {
       console.error("PostToolUse hook error:", error);
     }
-    console.log(JSON.stringify({}));
+    return JSON.stringify({});
   }
 }
-function readStdin() {
-  return new Promise((resolve2) => {
-    let data = "";
-    process.stdin.setEncoding("utf8");
-    process.stdin.on("data", (chunk) => {
-      data += chunk;
-    });
-    process.stdin.on("end", () => {
-      resolve2(data);
-    });
-  });
-}
 
 // src/hooks/post-tool-use.ts
-main().catch(console.error);
+void runHook({ name: "post-tool-use", fallbackOutput: "{}" }, main);
 //# sourceMappingURL=post-tool-use.js.map