claude-memory-layer 1.0.53 → 1.0.55

package/dist/mcp/index.js

@@ -11261,7 +11261,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);
@@ -11494,19 +11500,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;
   }
   /**
@@ -11612,11 +11628,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
@@ -11729,16 +11746,16 @@ var ConsolidatedStore = class {
    * Check if source events are already consolidated
    */
   async isAlreadyConsolidated(eventIds) {
-    for (const eventId of eventIds) {
-      const result2 = await dbAll(
-        this.db,
-        `SELECT COUNT(*) as count FROM consolidated_memories
-         WHERE source_events LIKE ?`,
-        [`%"${eventId}"%`]
-      );
-      if ((result2[0]?.count || 0) > 0) return true;
-    }
-    return false;
+    if (eventIds.length === 0) return false;
+    const placeholders2 = eventIds.map(() => "?").join(",");
+    const rows = await dbAll(
+      this.db,
+      `SELECT memory_id FROM consolidated_memory_events
+       WHERE event_id IN (${placeholders2})
+       LIMIT 1`,
+      eventIds
+    );
+    return rows.length > 0;
   }
   /**
    * Get the last consolidation time
@@ -13274,6 +13291,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";
 
@@ -13318,17 +13348,28 @@ function createSQLiteDatabase(path15, 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);
@@ -13750,6 +13791,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 },
@@ -14094,6 +14136,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,
@@ -14453,11 +14504,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) => {
@@ -14494,55 +14551,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);
@@ -14559,8 +14578,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;
   }
   /**
@@ -14692,6 +14721,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
    */
@@ -14705,6 +14795,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 placeholders2 = ids.map(() => "?").join(",");
+    const rows = sqliteAll(
+      this.db,
+      `SELECT * FROM events WHERE id IN (${placeholders2}) 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)
    */
@@ -14906,25 +15061,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 placeholders2 = 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 (${placeholders2})`,
-      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,
@@ -15528,7 +15680,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);
@@ -15691,10 +15843,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;
@@ -15723,6 +15879,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;
   }
   /**
@@ -15740,6 +15902,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();
@@ -15825,6 +16016,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);
@@ -15842,7 +16072,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")) {
@@ -15858,7 +16089,8 @@ var SQLiteEventStore = class {
           rewrittenSelectionRate: 0,
           rawSelectionRate: 0,
           avgSelectedCountForRewrittenQueries: 0,
-          avgSelectedCountForRawQueries: 0
+          avgSelectedCountForRawQueries: 0,
+          strategyBreakdown: []
         };
       }
       throw err;
@@ -15975,38 +16207,19 @@ var SQLiteEventStore = class {
     if (events.length === 0) return 0;
     const eventIds = events.map((e) => e.id);
     const placeholders2 = 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 (${placeholders2})`, eventIds);
-      } catch {
-      }
-    }
-    const result2 = 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 result2.changes || 0;
+      const result2 = sqliteRun(this.db, `DELETE FROM events WHERE session_id = ?`, [sessionId]);
+      this.recreateEventsFtsTable();
+      return result2.changes || 0;
+    });
+    return runDelete();
   }
   /**
    * Convert database row to MemoryEvent
@@ -19937,7 +20150,7 @@ var ActorCardRepository = class {
 };
 
 // src/core/operations/perspective-observation-repository.ts
-import { createHash as createHash3, randomUUID as randomUUID13 } from "crypto";
+import { createHash as createHash4, randomUUID as randomUUID13 } from "crypto";
 function projectHashToStorage6(projectHash) {
   return projectHash ?? "";
 }
@@ -19974,7 +20187,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({
@@ -20482,19 +20695,6 @@ function createPerspectiveDeriver(options) {
   return new PerspectiveDeriver(options);
 }
 
-// src/core/citation-generator.ts
-import { createHash as createHash4 } from "crypto";
-var ID_LENGTH = 6;
-var CHARSET = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
-function generateCitationId(eventId) {
-  const hash = createHash4("sha256").update(eventId).digest();
-  let id = "";
-  for (let i = 0; i < ID_LENGTH; i++) {
-    id += CHARSET[hash[i] % CHARSET.length];
-  }
-  return id;
-}
-
 // src/core/vector-store.ts
 import * as lancedb from "@lancedb/lancedb";
 var VectorStore = class {
@@ -21102,6 +21302,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);
@@ -22070,11 +22294,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 result2 of results) {
       if (scope?.sessionId && result2.sessionId !== scope.sessionId) continue;
       if (scope?.sessionIdPrefix && !result2.sessionId.startsWith(scope.sessionIdPrefix)) continue;
       if (scope?.eventTypes && scope.eventTypes.length > 0 && !scope.eventTypes.includes(result2.eventType)) continue;
-      const event = await this.eventStore.getEvent(result2.eventId);
+      const event = eventMap.get(result2.eventId);
       if (!event) continue;
       if (scope?.canonicalKeyPrefix && !event.canonicalKey.startsWith(scope.canonicalKeyPrefix)) continue;
       if (normalizedIncludes.length > 0) {
@@ -22183,10 +22408,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 unique2 = [...new Set(ids)];
+    if (typeof this.eventStore.getEvents === "function") {
+      const events = await this.eventStore.getEvents(unique2);
+      for (const event of events) map.set(event.id, event);
+    } else {
+      const events = await Promise.all(unique2.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 result2 of results) {
-      const event = await this.eventStore.getEvent(result2.eventId);
+      const event = eventMap.get(result2.eventId);
       if (!event) continue;
       if (this.graduation) {
         this.graduation.recordAccess(event.id, options.sessionId || "unknown", result2.score);
@@ -24939,6 +25184,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
    */
@@ -25268,6 +25541,20 @@ import * as path11 from "path";
 import * as os6 from "os";
 import * as readline from "readline";
 import { randomUUID as randomUUID16 } from "crypto";
+
+// src/services/turn-buffering.ts
+var MIN_SUBSTANTIVE_RESPONSE_LEN = 100;
+var MAX_AGENT_RESPONSE_LEN = 1e4;
+function mergeAgentResponseBlocks(blocks) {
+  const substantive = blocks.filter((block) => block.length >= MIN_SUBSTANTIVE_RESPONSE_LEN);
+  if (substantive.length > 0) return substantive.join("\n\n");
+  return blocks.reduce((longest, block) => longest.length >= block.length ? longest : block, "");
+}
+function truncateAgentResponse(text) {
+  return text.length > MAX_AGENT_RESPONSE_LEN ? `${text.slice(0, MAX_AGENT_RESPONSE_LEN)}...[truncated]` : text;
+}
+
+// src/services/session-history-importer.ts
 function isClaudeLocalCommandArtifact(content) {
   const trimmed = content.trim();
   return /^<local-command-(stdout|stderr)>/.test(trimmed) || /^<command-(name|message)>/.test(trimmed) || trimmed.includes("<command-name>") && trimmed.includes("<local-command-stdout>");
@@ -25399,6 +25686,34 @@ var SessionHistoryImporter = class {
   /**
    * Import a specific session file
    */
+  /**
+   * Pre-flight check used before a destructive force-reimport: returns true only
+   * if the file can be opened and contains at least one line that parses as JSON.
+   * Streams the file and short-circuits on the first valid record.
+   */
+  async hasParseableContent(filePath) {
+    let stream;
+    let rl;
+    try {
+      stream = fs9.createReadStream(filePath);
+      rl = readline.createInterface({ input: stream, crlfDelay: Infinity });
+      for await (const line of rl) {
+        const trimmed = line.trim();
+        if (!trimmed) continue;
+        try {
+          JSON.parse(trimmed);
+          return true;
+        } catch {
+        }
+      }
+      return false;
+    } catch {
+      return false;
+    } finally {
+      rl?.close();
+      stream?.close();
+    }
+  }
   async importSessionFile(filePath, options = {}) {
     const result2 = {
       totalSessions: 1,
@@ -25414,6 +25729,10 @@ var SessionHistoryImporter = class {
     }
     const sessionId = path11.basename(filePath, ".jsonl");
     if (options.force) {
+      if (!await this.hasParseableContent(filePath)) {
+        result2.errors.push(`Skipped force reimport (no parseable records): ${filePath}`);
+        return result2;
+      }
       const deleted = await this.memoryService.deleteSessionEvents(sessionId);
       if (options.verbose && deleted > 0) {
         console.log(`  Deleted ${deleted} existing events for session ${sessionId}`);
@@ -25435,13 +25754,12 @@ var SessionHistoryImporter = class {
     let lastTimestamp;
     const flushTextBuffer = async () => {
       if (textBuffer.length === 0 || !currentTurnId) return;
-      const substantive = textBuffer.filter((t) => t.length >= 100);
-      const merged = substantive.length > 0 ? substantive.join("\n\n") : textBuffer.reduce((a, b) => a.length >= b.length ? a : b, "");
+      const merged = mergeAgentResponseBlocks(textBuffer);
       if (!merged) {
         textBuffer = [];
         return;
       }
-      const truncated = merged.length > 1e4 ? merged.slice(0, 1e4) + "...[truncated]" : merged;
+      const truncated = truncateAgentResponse(merged);
       const appendResult = await this.memoryService.storeAgentResponse(
         sessionId,
         truncated,
@@ -25455,55 +25773,60 @@ var SessionHistoryImporter = class {
       lineCount++;
       textBuffer = [];
     };
-    for await (const line of rl) {
-      if (lineCount >= limit) break;
-      try {
-        const entry = JSON.parse(line);
-        result2.totalMessages++;
-        const msgClass = classifyEntry(entry);
-        if (msgClass === "user_prompt") {
-          await flushTextBuffer();
-          const content = this.extractContent(entry);
-          if (!content) continue;
-          if (!isWorthStoringPrompt(content)) {
-            result2.skippedDuplicates++;
-            continue;
-          }
-          currentTurnId = randomUUID16();
-          const appendResult = await this.memoryService.storeUserPrompt(
-            sessionId,
-            content,
-            { importedFrom: filePath, originalTimestamp: entry.timestamp, turnId: currentTurnId }
-          );
-          if (appendResult.success && appendResult.isDuplicate) {
-            result2.skippedDuplicates++;
-          } else {
-            result2.importedPrompts++;
+    try {
+      for await (const line of rl) {
+        if (lineCount >= limit) break;
+        try {
+          const entry = JSON.parse(line);
+          result2.totalMessages++;
+          const msgClass = classifyEntry(entry);
+          if (msgClass === "user_prompt") {
+            await flushTextBuffer();
+            const content = this.extractContent(entry);
+            if (!content) continue;
+            if (!isWorthStoringPrompt(content)) {
+              result2.skippedDuplicates++;
+              continue;
+            }
+            currentTurnId = randomUUID16();
+            const appendResult = await this.memoryService.storeUserPrompt(
+              sessionId,
+              content,
+              { importedFrom: filePath, originalTimestamp: entry.timestamp, turnId: currentTurnId }
+            );
+            if (appendResult.success && appendResult.isDuplicate) {
+              result2.skippedDuplicates++;
+            } else {
+              result2.importedPrompts++;
+            }
+            lineCount++;
+          } else if (msgClass === "agent_text") {
+            const content = this.extractContent(entry);
+            if (content) {
+              textBuffer.push(content);
+              lastTimestamp = entry.timestamp;
+            }
           }
-          lineCount++;
-        } else if (msgClass === "agent_text") {
-          const content = this.extractContent(entry);
-          if (content) {
-            textBuffer.push(content);
-            lastTimestamp = entry.timestamp;
+          const now = Date.now();
+          if (now - lastProgressAt > 200) {
+            lastProgressAt = now;
+            onProgress?.({
+              phase: "session-progress",
+              sessionIndex,
+              messagesProcessed: result2.totalMessages,
+              imported: result2.importedPrompts + result2.importedResponses,
+              skipped: result2.skippedDuplicates
+            });
           }
+        } catch (parseError) {
+          result2.errors.push(`Parse error on line: ${parseError}`);
         }
-        const now = Date.now();
-        if (now - lastProgressAt > 200) {
-          lastProgressAt = now;
-          onProgress?.({
-            phase: "session-progress",
-            sessionIndex,
-            messagesProcessed: result2.totalMessages,
-            imported: result2.importedPrompts + result2.importedResponses,
-            skipped: result2.skippedDuplicates
-          });
-        }
-      } catch (parseError) {
-        result2.errors.push(`Parse error on line: ${parseError}`);
       }
+      await flushTextBuffer();
+    } finally {
+      rl.close();
+      fileStream.close();
     }
-    await flushTextBuffer();
     await this.memoryService.endSession(sessionId);
     if (options.projectPath) {
       registerSession(sessionId, options.projectPath);
@@ -25711,6 +26034,29 @@ function extractCodexContentText(content, maxContentChars = CODEX_VALIDATION_DEF
 function extractTextFromContent(content) {
   return extractCodexContentText(content).text;
 }
+function listCodexSessionFilesRecursive(rootDir) {
+  if (!fs10.existsSync(rootDir)) return [];
+  const out = [];
+  const stack = [rootDir];
+  while (stack.length > 0) {
+    const dir = stack.pop();
+    let entries;
+    try {
+      entries = fs10.readdirSync(dir, { withFileTypes: true });
+    } catch {
+      continue;
+    }
+    for (const ent of entries) {
+      const fullPath = path12.join(dir, ent.name);
+      if (ent.isDirectory()) {
+        stack.push(fullPath);
+      } else if (ent.isFile() && ent.name.endsWith(".jsonl")) {
+        out.push(fullPath);
+      }
+    }
+  }
+  return out.sort();
+}
 function getFileMtimeMs2(filePath) {
   try {
     return fs10.statSync(filePath).mtimeMs;
@@ -25741,29 +26087,6 @@ var CodexSessionHistoryImporter = class {
   getSessionsRoot() {
     return this.sessionsRoot;
   }
-  listSessionFilesRecursive(rootDir) {
-    if (!fs10.existsSync(rootDir)) return [];
-    const out = [];
-    const stack = [rootDir];
-    while (stack.length > 0) {
-      const dir = stack.pop();
-      let entries;
-      try {
-        entries = fs10.readdirSync(dir, { withFileTypes: true });
-      } catch {
-        continue;
-      }
-      for (const ent of entries) {
-        const fullPath = path12.join(dir, ent.name);
-        if (ent.isDirectory()) {
-          stack.push(fullPath);
-        } else if (ent.isFile() && ent.name.endsWith(".jsonl")) {
-          out.push(fullPath);
-        }
-      }
-    }
-    return out;
-  }
   async readSessionMeta(filePath) {
     const fileStream = fs10.createReadStream(filePath, { encoding: "utf-8" });
     const rl = readline2.createInterface({ input: fileStream, crlfDelay: Infinity });
@@ -25813,7 +26136,7 @@ var CodexSessionHistoryImporter = class {
     }
     const normalizedTarget = normalizeMaybeRealpath(projectPath);
     onProgress?.({ phase: "scan", message: "Scanning Codex session files..." });
-    const sessionFiles = this.listSessionFilesRecursive(sessionsRoot);
+    const sessionFiles = listCodexSessionFilesRecursive(sessionsRoot);
     const matchingFiles = [];
     for (const filePath of sessionFiles) {
       try {
@@ -25878,7 +26201,7 @@ var CodexSessionHistoryImporter = class {
       return result2;
     }
     onProgress?.({ phase: "scan", message: "Scanning all Codex sessions..." });
-    const sessionFiles = this.listSessionFilesRecursive(sessionsRoot);
+    const sessionFiles = listCodexSessionFilesRecursive(sessionsRoot);
     const selectedFiles = selectRecentCodexSessionFiles(sessionFiles, options.sessionLimit);
     onProgress?.({ phase: "scan", message: `Found ${sessionFiles.length} Codex session file(s)` });
     const totalLimit = normalizePositiveImportLimit(options.limit);
@@ -25957,13 +26280,12 @@ var CodexSessionHistoryImporter = class {
         return;
       }
       if (textBuffer.length === 0 || !currentTurnId) return;
-      const substantive = textBuffer.filter((t) => t.length >= 100);
-      const merged = substantive.length > 0 ? substantive.join("\n\n") : textBuffer.reduce((a, b) => a.length >= b.length ? a : b, "");
+      const merged = mergeAgentResponseBlocks(textBuffer);
       if (!merged) {
         textBuffer = [];
         return;
       }
-      const truncated = merged.length > 1e4 ? merged.slice(0, 1e4) + "...[truncated]" : merged;
+      const truncated = truncateAgentResponse(merged);
       const appendResult = await this.memoryService.storeAgentResponse(
         sessionId,
         truncated,
@@ -26047,7 +26369,7 @@ var CodexSessionHistoryImporter = class {
   async listAvailableSessions(projectPath) {
     const sessionsRoot = this.getSessionsRoot();
     if (!fs10.existsSync(sessionsRoot)) return [];
-    const files = this.listSessionFilesRecursive(sessionsRoot);
+    const files = listCodexSessionFilesRecursive(sessionsRoot);
     const sessions = [];
     const normalizedTarget = projectPath ? normalizeMaybeRealpath(projectPath) : null;
     for (const filePath of files) {
@@ -26345,9 +26667,7 @@ var HermesSessionHistoryImporter = class {
         return;
       }
       if (textBuffer.length === 0 || !currentTurnId) return;
-      const contentBlocks = textBuffer.map((item) => item.content);
-      const substantive = contentBlocks.filter((content) => content.length >= 100);
-      const merged = substantive.length > 0 ? substantive.join("\n\n") : contentBlocks.reduce((a, b) => a.length >= b.length ? a : b, "");
+      const merged = mergeAgentResponseBlocks(textBuffer.map((item) => item.content));
       if (!merged) {
         textBuffer = [];
         return;
@@ -27959,10 +28279,10 @@ async function handleExternalMarketContext(args) {
   return textResult(renderExternalMarketContextReport(report));
 }
 async function handleMemSearch(memoryService, args) {
-  const query = args.query;
+  const query = requiredOperationString(args.query, "query");
   const topK = numberArg(args.topK, 5, 1, 20);
   const fetchTopK = Math.min(topK * 3, 20);
-  const sessionId = args.sessionId;
+  const sessionId = optionalString(args.sessionId);
   const eventType = eventTypeArg(args.eventType);
   const search = await retrieveMcpMemories(memoryService, query, { topK, fetchTopK, sessionId, eventType });
   const lines = [
@@ -28050,8 +28370,8 @@ function scoreKeywordMatch(content, queryTokens) {
   return hits / queryTokens.length;
 }
 async function handleMemTimeline(memoryService, args) {
-  const ids = args.ids;
-  const windowSize = args.windowSize || 3;
+  const ids = stringArrayOperationArg(args.ids, 100);
+  const windowSize = numberArg(args.windowSize, 3, 0, 50);
   const recentEvents = await memoryService.getRecentEvents(1e4);
   const lines = [
     "## Timeline Context",
@@ -28088,7 +28408,10 @@ async function handleMemTimeline(memoryService, args) {
   };
 }
 async function handleMemDetails(memoryService, args) {
-  const ids = args.ids;
+  const ids = stringArrayOperationArg(args.ids, 200);
+  if (ids.length === 0) {
+    return { content: [{ type: "text", text: "## No memory ids provided." }] };
+  }
   const recentEvents = await memoryService.getRecentEvents(1e4);
   const lines = [];
   for (const targetId of ids) {
@@ -28110,7 +28433,7 @@ async function handleMemDetails(memoryService, args) {
     lines.push("");
     lines.push("**Content**:");
     lines.push("```");
-    lines.push(event.content);
+    lines.push(applyPrivacyFilter(event.content, MCP_PRIVACY_CONFIG).content);
     lines.push("```");
     lines.push("");
     lines.push("---");
@@ -28165,6 +28488,12 @@ async function handleMemContextPack(memoryService, args) {
     recentSessionIds,
     projectPath
   });
+  await recordMcpContextPackTrace(memoryService, {
+    query,
+    sessionId,
+    candidates: search.memories,
+    selected: relevantMemories
+  });
   const hasPerspectiveContext = optionalString(args.observerActorId) !== void 0 || optionalString(args.targetActorId) !== void 0 || optionalString(args.observedActorId) !== void 0;
   let perspectiveBundle;
   let perspectiveWarning;
@@ -28251,6 +28580,23 @@ async function handleMemContextPack(memoryService, args) {
   }
   return textResult(applyContextPackBudget(lines.join("\n"), maxContextChars));
 }
+async function recordMcpContextPackTrace(memoryService, input) {
+  try {
+    await memoryService.recordQueryTrace({
+      sessionId: input.sessionId,
+      queryText: sanitizeOperationString(input.query, 1e3),
+      queryRewriteKind: "none",
+      strategy: "mcp-context-pack",
+      candidateEventIds: uniqueContextPackEventIds(input.candidates),
+      selectedEventIds: uniqueContextPackEventIds(input.selected),
+      confidence: input.selected.length > 0 ? "suggested" : "none"
+    });
+  } catch {
+  }
+}
+function uniqueContextPackEventIds(memories) {
+  return Array.from(new Set(memories.map((memory) => memory.event.id).filter(Boolean)));
+}
 async function runLatestImport(memoryService, options) {
   const summaries = [];
   for (const source of options.sources) {