claude-memory-layer 1.0.52 → 1.0.54

package/dist/cli/index.js

@@ -9,8 +9,8 @@ const __dirname = dirname(__filename);
 // src/apps/cli/index.ts
 import { Command } from "commander";
 import { exec } from "child_process";
-import * as fs18 from "fs";
-import * as path24 from "path";
+import * as fs19 from "fs";
+import * as path25 from "path";
 import * as os13 from "os";
 
 // src/services/memory-service.ts
@@ -165,7 +165,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);
@@ -398,19 +404,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;
   }
   /**
@@ -516,11 +532,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
@@ -633,16 +650,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 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
@@ -2178,6 +2195,23 @@ 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;
+}
+function parseCitationId(formatted) {
+  const match = formatted.match(/\[?mem:([A-Za-z0-9]{6})\]?/);
+  return match ? match[1] : null;
+}
+
 // src/core/sqlite-event-store.ts
 import * as nodePath2 from "path";
 
@@ -2211,12 +2245,12 @@ function resolveProjectStoragePath(projectOrHash) {
 import Database from "better-sqlite3";
 import * as fs4 from "fs";
 import * as nodePath from "path";
-function createSQLiteDatabase(path25, options) {
-  const dir = nodePath.dirname(path25);
+function createSQLiteDatabase(path26, options) {
+  const dir = nodePath.dirname(path26);
   if (!fs4.existsSync(dir)) {
     fs4.mkdirSync(dir, { recursive: true });
   }
-  const db = new Database(path25, {
+  const db = new Database(path26, {
     readonly: options?.readonly ?? false
   });
   if (!options?.readonly && (options?.walMode ?? true)) {
@@ -2226,17 +2260,28 @@ function createSQLiteDatabase(path25, 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);
@@ -2658,6 +2703,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 },
@@ -2667,17 +2713,17 @@ function emptyOutboxRecoveryResult() {
 function isRecord(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
-function getNestedRecord(root, path25) {
+function getNestedRecord(root, path26) {
   let cursor = root;
-  for (const key of path25) {
+  for (const key of path26) {
     if (!isRecord(cursor)) return void 0;
     cursor = cursor[key];
   }
   return isRecord(cursor) ? cursor : void 0;
 }
-function getNestedString(root, path25) {
+function getNestedString(root, path26) {
   let cursor = root;
-  for (const key of path25) {
+  for (const key of path26) {
     if (!isRecord(cursor)) return void 0;
     cursor = cursor[key];
   }
@@ -3002,6 +3048,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,
@@ -3361,11 +3416,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) => {
@@ -3402,55 +3463,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);
@@ -3467,8 +3490,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;
   }
   /**
@@ -3600,6 +3633,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
    */
@@ -3613,6 +3707,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)
    */
@@ -3814,25 +3973,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,
@@ -4436,7 +4592,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);
@@ -4599,10 +4755,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;
@@ -4631,6 +4791,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;
   }
   /**
@@ -4648,6 +4814,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();
@@ -4733,6 +4928,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);
@@ -4750,7 +4984,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")) {
@@ -4766,7 +5001,8 @@ var SQLiteEventStore = class {
           rewrittenSelectionRate: 0,
           rawSelectionRate: 0,
           avgSelectedCountForRewrittenQueries: 0,
-          avgSelectedCountForRawQueries: 0
+          avgSelectedCountForRawQueries: 0,
+          strategyBreakdown: []
         };
       }
       throw err;
@@ -4883,38 +5119,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 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
@@ -7678,9 +7895,9 @@ function safeParseObject(value) {
     return void 0;
   }
 }
-function nestedString(root, path25) {
+function nestedString(root, path26) {
   let cursor = root;
-  for (const key of path25) {
+  for (const key of path26) {
     if (!isRecord2(cursor)) return void 0;
     cursor = cursor[key];
   }
@@ -7755,12 +7972,12 @@ var GraphPathService = class {
         }
       }
     }
-    const paths = Array.from(bestByTarget.entries()).map(([key, path25]) => ({
+    const paths = Array.from(bestByTarget.entries()).map(([key, path26]) => ({
       target: graph.node(nodeFromKey(key)),
-      hops: path25.hops,
-      totalCost: path25.totalCost,
-      scoreContribution: path25.totalCost > 0 ? 1 / path25.totalCost : 0,
-      steps: path25.steps
+      hops: path26.hops,
+      totalCost: path26.totalCost,
+      scoreContribution: path26.totalCost > 0 ? 1 / path26.totalCost : 0,
+      steps: path26.steps
     })).sort((a, b) => b.scoreContribution - a.scoreContribution || a.hops - b.hops || a.target.name.localeCompare(b.target.name)).slice(0, maxResults);
     return { startNodes, effectiveMaxHops, paths };
   }
@@ -8537,7 +8754,7 @@ var SessionActorRepository = class {
 };
 
 // src/core/operations/perspective-observation-repository.ts
-import { createHash as createHash3, randomUUID as randomUUID11 } from "crypto";
+import { createHash as createHash4, randomUUID as randomUUID11 } from "crypto";
 function projectHashToStorage4(projectHash) {
   return projectHash ?? "";
 }
@@ -8574,7 +8791,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({
@@ -9082,23 +9299,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;
-}
-function parseCitationId(formatted) {
-  const match = formatted.match(/\[?mem:([A-Za-z0-9]{6})\]?/);
-  return match ? match[1] : null;
-}
-
 // src/core/operations/perspective-session-actor-backfill.ts
 var DEFAULT_EVENT_LIMIT = 1e4;
 var DEFAULT_SAMPLE_LIMIT2 = 10;
@@ -9892,6 +10092,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);
@@ -10716,12 +10940,12 @@ var Retriever = class {
         direction: "both"
       });
       const titleByEntityId = new Map(startNodes.map((node) => [node.entityId, node.title]));
-      for (const path25 of expansion.paths) {
-        if (path25.target.type !== "event") continue;
-        const target = await this.eventStore.getEvent(path25.target.id);
+      for (const path26 of expansion.paths) {
+        if (path26.target.type !== "event") continue;
+        const target = await this.eventStore.getEvent(path26.target.id);
         if (!target) continue;
-        const graphPath = toRetrievalGraphPathDebug(path25, titleByEntityId);
-        const score = graphPathScore(path25, opts.hopPenalty);
+        const graphPath = toRetrievalGraphPathDebug(path26, titleByEntityId);
+        const score = graphPathScore(path26, opts.hopPenalty);
         const existing = byId.get(target.id);
         const graphPaths = mergeGraphPaths(existing?.graphPaths ?? [], [graphPath]);
         const graphLane = {
@@ -10730,7 +10954,7 @@ var Retriever = class {
           score
         };
         const row = {
-          id: existing?.id ?? `graph-path-${path25.hops}-${target.id}`,
+          id: existing?.id ?? `graph-path-${path26.hops}-${target.id}`,
           eventId: target.id,
           content: target.content,
           score: Math.max(existing?.score ?? 0, score),
@@ -10860,11 +11084,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) {
@@ -10973,10 +11198,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 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);
@@ -11049,8 +11294,8 @@ _Context:_ ${sessionContext}`;
   }
   matchesMetadataScope(metadata, expected) {
     if (!metadata) return false;
-    return Object.entries(expected).every(([path25, value]) => {
-      const actual = path25.split(".").reduce((acc, key) => {
+    return Object.entries(expected).every(([path26, value]) => {
+      const actual = path26.split(".").reduce((acc, key) => {
         if (typeof acc !== "object" || acc === null) return void 0;
         return acc[key];
       }, metadata);
@@ -11101,22 +11346,22 @@ function uniqueEntityStartNodes(candidates) {
   }
   return nodes;
 }
-function toRetrievalGraphPathDebug(path25, titleByEntityId) {
-  const firstStep = path25.steps[0];
+function toRetrievalGraphPathDebug(path26, titleByEntityId) {
+  const firstStep = path26.steps[0];
   const startNode = firstStep?.direction === "incoming" ? firstStep.to : firstStep?.from;
   const startEntityId = startNode?.type === "entity" ? startNode.id : "";
   return {
     startEntityId,
     startEntityTitle: titleByEntityId.get(startEntityId) ?? startNode?.name,
-    targetId: path25.target.id,
-    targetType: path25.target.type,
-    hops: path25.hops,
-    relationPath: path25.steps.map((step) => step.relationType)
+    targetId: path26.target.id,
+    targetType: path26.target.type,
+    hops: path26.hops,
+    relationPath: path26.steps.map((step) => step.relationType)
   };
 }
-function graphPathScore(path25, hopPenalty) {
-  const base = Math.min(0.95, Math.max(0, path25.scoreContribution));
-  return Math.max(0.05, base - hopPenalty * Math.max(0, path25.hops - 1));
+function graphPathScore(path26, hopPenalty) {
+  const base = Math.min(0.95, Math.max(0, path26.scoreContribution));
+  return Math.max(0.05, base - hopPenalty * Math.max(0, path26.hops - 1));
 }
 function clampGraphHops(maxHops) {
   if (!Number.isFinite(maxHops)) return 2;
@@ -11124,14 +11369,14 @@ function clampGraphHops(maxHops) {
 }
 function mergeGraphPaths(existing, incoming) {
   const byKey = /* @__PURE__ */ new Map();
-  for (const path25 of [...existing, ...incoming]) {
-    const key = [path25.startEntityId, path25.targetType, path25.targetId, path25.hops, ...path25.relationPath].join("\0");
-    if (!byKey.has(key)) byKey.set(key, path25);
+  for (const path26 of [...existing, ...incoming]) {
+    const key = [path26.startEntityId, path26.targetType, path26.targetId, path26.hops, ...path26.relationPath].join("\0");
+    if (!byKey.has(key)) byKey.set(key, path26);
   }
   return [...byKey.values()].sort((a, b) => a.hops - b.hops || compareStable(graphPathSignature(a), graphPathSignature(b))).slice(0, 3);
 }
-function graphPathSignature(path25) {
-  return [path25.startEntityId, path25.targetType, path25.targetId, path25.hops, ...path25.relationPath].join("|");
+function graphPathSignature(path26) {
+  return [path26.startEntityId, path26.targetType, path26.targetId, path26.hops, ...path26.relationPath].join("|");
 }
 function compareStable(a, b) {
   if (a < b) return -1;
@@ -13730,19 +13975,47 @@ var MemoryService = class {
     return this.queryService.rebuildFtsIndex();
   }
   /**
-   * Get session history
+   * Get a single event by id (indexed lookup).
    */
-  async getSessionHistory(sessionId) {
-    return this.queryService.getSessionHistory(sessionId);
+  async getEvent(id) {
+    return this.queryService.getEvent(id);
   }
   /**
-   * Get recent events
+   * Resolve an event from its citation id via the reverse index.
    */
-  async getRecentEvents(limit = 100) {
-    return this.queryService.getRecentEvents(limit);
+  async getEventByCitationId(citationId) {
+    return this.queryService.getEventByCitationId(citationId);
   }
-  /**
-   * Get memory statistics
+  /** 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
+   */
+  async getSessionHistory(sessionId) {
+    return this.queryService.getSessionHistory(sessionId);
+  }
+  /**
+   * Get recent events
+   */
+  async getRecentEvents(limit = 100) {
+    return this.queryService.getRecentEvents(limit);
+  }
+  /**
+   * Get memory statistics
    */
   async getOutboxStats(options) {
     return this.queryService.getOutboxStats(options);
@@ -14058,6 +14331,20 @@ import * as path11 from "path";
 import * as os6 from "os";
 import * as readline from "readline";
 import { randomUUID as randomUUID14 } 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>");
@@ -14189,6 +14476,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 result = {
       totalSessions: 1,
@@ -14204,6 +14519,10 @@ var SessionHistoryImporter = class {
     }
     const sessionId = path11.basename(filePath, ".jsonl");
     if (options.force) {
+      if (!await this.hasParseableContent(filePath)) {
+        result.errors.push(`Skipped force reimport (no parseable records): ${filePath}`);
+        return result;
+      }
       const deleted = await this.memoryService.deleteSessionEvents(sessionId);
       if (options.verbose && deleted > 0) {
         console.log(`  Deleted ${deleted} existing events for session ${sessionId}`);
@@ -14225,13 +14544,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,
@@ -14245,55 +14563,60 @@ var SessionHistoryImporter = class {
       lineCount++;
       textBuffer = [];
     };
-    for await (const line of rl) {
-      if (lineCount >= limit) break;
-      try {
-        const entry = JSON.parse(line);
-        result.totalMessages++;
-        const msgClass = classifyEntry(entry);
-        if (msgClass === "user_prompt") {
-          await flushTextBuffer();
-          const content = this.extractContent(entry);
-          if (!content) continue;
-          if (!isWorthStoringPrompt(content)) {
-            result.skippedDuplicates++;
-            continue;
-          }
-          currentTurnId = randomUUID14();
-          const appendResult = await this.memoryService.storeUserPrompt(
-            sessionId,
-            content,
-            { importedFrom: filePath, originalTimestamp: entry.timestamp, turnId: currentTurnId }
-          );
-          if (appendResult.success && appendResult.isDuplicate) {
-            result.skippedDuplicates++;
-          } else {
-            result.importedPrompts++;
+    try {
+      for await (const line of rl) {
+        if (lineCount >= limit) break;
+        try {
+          const entry = JSON.parse(line);
+          result.totalMessages++;
+          const msgClass = classifyEntry(entry);
+          if (msgClass === "user_prompt") {
+            await flushTextBuffer();
+            const content = this.extractContent(entry);
+            if (!content) continue;
+            if (!isWorthStoringPrompt(content)) {
+              result.skippedDuplicates++;
+              continue;
+            }
+            currentTurnId = randomUUID14();
+            const appendResult = await this.memoryService.storeUserPrompt(
+              sessionId,
+              content,
+              { importedFrom: filePath, originalTimestamp: entry.timestamp, turnId: currentTurnId }
+            );
+            if (appendResult.success && appendResult.isDuplicate) {
+              result.skippedDuplicates++;
+            } else {
+              result.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: result.totalMessages,
+              imported: result.importedPrompts + result.importedResponses,
+              skipped: result.skippedDuplicates
+            });
           }
+        } catch (parseError) {
+          result.errors.push(`Parse error on line: ${parseError}`);
         }
-        const now = Date.now();
-        if (now - lastProgressAt > 200) {
-          lastProgressAt = now;
-          onProgress?.({
-            phase: "session-progress",
-            sessionIndex,
-            messagesProcessed: result.totalMessages,
-            imported: result.importedPrompts + result.importedResponses,
-            skipped: result.skippedDuplicates
-          });
-        }
-      } catch (parseError) {
-        result.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);
@@ -14804,29 +15127,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 });
@@ -14876,7 +15176,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 {
@@ -14941,7 +15241,7 @@ var CodexSessionHistoryImporter = class {
       return result;
     }
     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);
@@ -15020,13 +15320,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,
@@ -15110,7 +15409,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) {
@@ -15551,9 +15850,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;
@@ -16053,8 +16350,8 @@ import { getCookie, setCookie, deleteCookie } from "hono/cookie";
 import { logger } from "hono/logger";
 import { serve } from "@hono/node-server";
 import { serveStatic } from "@hono/node-server/serve-static";
-import * as path17 from "path";
-import * as fs15 from "fs";
+import * as path18 from "path";
+import * as fs16 from "fs";
 import { createHmac, timingSafeEqual } from "crypto";
 import { fileURLToPath as fileUrlToPath } from "url";
 
@@ -16065,6 +16362,11 @@ import { Hono as Hono11 } from "hono";
 import { Hono } from "hono";
 
 // src/apps/server/api/utils.ts
+function jsonError(c, error, options = {}) {
+  const status = options.status ?? 500;
+  console.error(`[api] ${c.req.method} ${c.req.path} failed:`, error);
+  return c.json({ error: options.message ?? "Internal server error" }, status);
+}
 function getServiceFromQuery(c) {
   const project = c.req.query("project") || c.req.query("projectId");
   if (project) {
@@ -16176,7 +16478,7 @@ sessionsRouter.get("/", async (c) => {
       hasMore: end < total
     });
   } catch (error) {
-    return c.json({ error: error.message }, 500);
+    return jsonError(c, error);
   } finally {
     await memoryService.shutdown();
   }
@@ -16212,7 +16514,7 @@ sessionsRouter.get("/:id", async (c) => {
       stats: eventsByType
     });
   } catch (error) {
-    return c.json({ error: error.message }, 500);
+    return jsonError(c, error);
   } finally {
     await memoryService.shutdown();
   }
@@ -16278,7 +16580,7 @@ eventsRouter.get("/", async (c) => {
       hasMore: offset + limit < total
     });
   } catch (error) {
-    return c.json({ error: error.message }, 500);
+    return jsonError(c, error);
   } finally {
     await memoryService.shutdown();
   }
@@ -16288,12 +16590,11 @@ eventsRouter.get("/:id", async (c) => {
   const memoryService = getLightweightServiceFromQuery(c);
   try {
     await memoryService.initialize();
-    const recentEvents = await memoryService.getRecentEvents(1e4);
-    const event = recentEvents.find((e) => e.id === id);
+    const event = await memoryService.getEvent(id);
     if (!event) {
       return c.json({ error: "Event not found" }, 404);
     }
-    const sessionEvents = recentEvents.filter((e) => e.sessionId === event.sessionId).sort((a, b) => a.timestamp.getTime() - b.timestamp.getTime());
+    const sessionEvents = (await memoryService.getSessionHistory(event.sessionId)).sort((a, b) => a.timestamp.getTime() - b.timestamp.getTime());
     const eventIndex = sessionEvents.findIndex((e) => e.id === id);
     const start = Math.max(0, eventIndex - 2);
     const end = Math.min(sessionEvents.length, eventIndex + 3);
@@ -16315,7 +16616,7 @@ eventsRouter.get("/:id", async (c) => {
       }))
     });
   } catch (error) {
-    return c.json({ error: error.message }, 500);
+    return jsonError(c, error);
   } finally {
     await memoryService.shutdown();
   }
@@ -16362,7 +16663,7 @@ searchRouter.post("/", async (c) => {
       }
     });
   } catch (error) {
-    return c.json({ error: error.message }, 500);
+    return jsonError(c, error);
   } finally {
     await memoryService.shutdown();
   }
@@ -16405,7 +16706,7 @@ searchRouter.post("/disclosure", async (c) => {
       throw error;
     }
   } catch (error) {
-    return c.json({ error: error.message }, 500);
+    return jsonError(c, error);
   } finally {
     await memoryService?.shutdown();
   }
@@ -16425,7 +16726,7 @@ searchRouter.get("/disclosure/:resultId/expand", async (c) => {
     }
     return c.json(result);
   } catch (error) {
-    return c.json({ error: error.message }, 500);
+    return jsonError(c, error);
   } finally {
     await memoryService.shutdown();
   }
@@ -16440,7 +16741,7 @@ searchRouter.get("/disclosure/:resultId/source", async (c) => {
     }
     return c.json(result);
   } catch (error) {
-    return c.json({ error: error.message }, 500);
+    return jsonError(c, error);
   } finally {
     await memoryService.shutdown();
   }
@@ -16469,7 +16770,7 @@ searchRouter.get("/", async (c) => {
       }
     });
   } catch (error) {
-    return c.json({ error: error.message }, 500);
+    return jsonError(c, error);
   } finally {
     await memoryService.shutdown();
   }
@@ -16477,9 +16778,89 @@ searchRouter.get("/", async (c) => {
 
 // src/apps/server/api/stats.ts
 import { Hono as Hono4 } from "hono";
-import * as fs13 from "fs";
+import * as fs14 from "fs";
 import * as os9 from "os";
+import * as path16 from "path";
+
+// src/apps/server/api/stats-metrics.ts
+import * as fs13 from "fs";
 import * as path15 from "path";
+var DEFAULT_KPI_THRESHOLDS = {
+  usefulRecallRateMin: 0.45,
+  reworkRateMax: 0.25,
+  postChangeFailureRateMax: 0.2,
+  avgCompletionTurnsMax: 12,
+  memoryHitRateMin: 0.35
+};
+function loadKpiThresholds() {
+  try {
+    const filePath = path15.resolve(process.cwd(), "config", "kpi-thresholds.json");
+    if (!fs13.existsSync(filePath)) return DEFAULT_KPI_THRESHOLDS;
+    const parsed = JSON.parse(fs13.readFileSync(filePath, "utf-8"));
+    return {
+      usefulRecallRateMin: Number(parsed.usefulRecallRateMin ?? DEFAULT_KPI_THRESHOLDS.usefulRecallRateMin),
+      reworkRateMax: Number(parsed.reworkRateMax ?? DEFAULT_KPI_THRESHOLDS.reworkRateMax),
+      postChangeFailureRateMax: Number(parsed.postChangeFailureRateMax ?? DEFAULT_KPI_THRESHOLDS.postChangeFailureRateMax),
+      avgCompletionTurnsMax: Number(parsed.avgCompletionTurnsMax ?? DEFAULT_KPI_THRESHOLDS.avgCompletionTurnsMax),
+      memoryHitRateMin: Number(parsed.memoryHitRateMin ?? DEFAULT_KPI_THRESHOLDS.memoryHitRateMin)
+    };
+  } catch {
+    return DEFAULT_KPI_THRESHOLDS;
+  }
+}
+function windowToMs(window) {
+  if (window === "24h") return 24 * 60 * 60 * 1e3;
+  if (window === "7d") return 7 * 24 * 60 * 60 * 1e3;
+  return 30 * 24 * 60 * 60 * 1e3;
+}
+function inWindow(e, now, window) {
+  return now - e.timestamp.getTime() <= windowToMs(window);
+}
+function isEditToolName(name) {
+  return ["Write", "Edit", "MultiEdit", "NotebookEdit"].includes(name);
+}
+function parseToolPayload(e) {
+  if (e.eventType !== "tool_observation") return null;
+  try {
+    const payload = JSON.parse(e.content);
+    return {
+      toolName: payload?.toolName,
+      success: payload?.success,
+      filePath: payload?.metadata?.filePath,
+      command: payload?.metadata?.command
+    };
+  } catch {
+    return {
+      toolName: e.metadata?.toolName,
+      success: e.metadata?.success,
+      filePath: e.metadata?.filePath,
+      command: e.metadata?.command
+    };
+  }
+}
+function isTestLikeCommand(command) {
+  if (!command) return false;
+  return /(test|jest|vitest|pytest|go test|cargo test|lint|eslint|build|tsc)/i.test(command);
+}
+function safeRatio(num, den) {
+  if (!Number.isFinite(num) || !Number.isFinite(den) || den <= 0) return 0;
+  return num / den;
+}
+function round2(value, digits = 4) {
+  const factor = 10 ** digits;
+  return Math.round(value * factor) / factor;
+}
+function computeSessionTurnCount(sessionEvents) {
+  const turnIds = /* @__PURE__ */ new Set();
+  for (const e of sessionEvents) {
+    const turnId = e.metadata?.turnId;
+    if (typeof turnId === "string" && turnId.length > 0) turnIds.add(turnId);
+  }
+  if (turnIds.size > 0) return turnIds.size;
+  return sessionEvents.filter((e) => e.eventType === "user_prompt").length;
+}
+
+// src/apps/server/api/stats.ts
 var statsRouter = new Hono4();
 var OPERATION_STATS_TABLES = [
   "memory_facets",
@@ -16506,7 +16887,7 @@ function operationsStatsHomeDir() {
 }
 function projectStoragePathForOperationsStats(projectOrHash) {
   const projectHash = /^[a-f0-9]{8}$/.test(projectOrHash) ? projectOrHash : hashProjectPath(projectOrHash);
-  return path15.join(operationsStatsHomeDir(), ".claude-code", "memory", "projects", projectHash);
+  return path16.join(operationsStatsHomeDir(), ".claude-code", "memory", "projects", projectHash);
 }
 function getOperationsStatsContext(project) {
   if (project && project.trim().length > 0) {
@@ -16516,13 +16897,13 @@ function getOperationsStatsContext(project) {
     return {
       projectHash,
       storagePath: storagePath2,
-      dbPath: path15.join(storagePath2, "events.sqlite")
+      dbPath: path16.join(storagePath2, "events.sqlite")
     };
   }
-  const storagePath = path15.join(operationsStatsHomeDir(), ".claude-code", "memory");
+  const storagePath = path16.join(operationsStatsHomeDir(), ".claude-code", "memory");
   return {
     storagePath,
-    dbPath: path15.join(storagePath, "events.sqlite")
+    dbPath: path16.join(storagePath, "events.sqlite")
   };
 }
 function countRowValue(db, sql, params = []) {
@@ -16540,6 +16921,23 @@ function sanitizeAggregateLabel(value) {
   const trimmed = sanitized.trim();
   return trimmed.length > 0 ? trimmed.slice(0, 96) : "unknown";
 }
+var SAFE_RETRIEVAL_TRACE_STRATEGIES = /* @__PURE__ */ new Set([
+  "auto",
+  "deep",
+  "fast",
+  "hybrid",
+  "keyword",
+  "semantic",
+  "mcp-context-pack",
+  "session-start-hook",
+  "unknown"
+]);
+function normalizeRetrievalTraceStrategy(value) {
+  const label = sanitizeAggregateLabel(value);
+  if (label === "[REDACTED]") return "unknown";
+  const normalized = label.trim().toLowerCase();
+  return SAFE_RETRIEVAL_TRACE_STRATEGIES.has(normalized) ? normalized : "unknown";
+}
 function emptyOperationsStatsPayload(context, databaseExists, missingTables, windowDays) {
   return {
     generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
@@ -16953,80 +17351,6 @@ function buildLessonConfidenceBuckets(db, projectHash) {
     }).length
   }));
 }
-var DEFAULT_KPI_THRESHOLDS = {
-  usefulRecallRateMin: 0.45,
-  reworkRateMax: 0.25,
-  postChangeFailureRateMax: 0.2,
-  avgCompletionTurnsMax: 12,
-  memoryHitRateMin: 0.35
-};
-function loadKpiThresholds() {
-  try {
-    const filePath = path15.resolve(process.cwd(), "config", "kpi-thresholds.json");
-    if (!fs13.existsSync(filePath)) return DEFAULT_KPI_THRESHOLDS;
-    const parsed = JSON.parse(fs13.readFileSync(filePath, "utf-8"));
-    return {
-      usefulRecallRateMin: Number(parsed.usefulRecallRateMin ?? DEFAULT_KPI_THRESHOLDS.usefulRecallRateMin),
-      reworkRateMax: Number(parsed.reworkRateMax ?? DEFAULT_KPI_THRESHOLDS.reworkRateMax),
-      postChangeFailureRateMax: Number(parsed.postChangeFailureRateMax ?? DEFAULT_KPI_THRESHOLDS.postChangeFailureRateMax),
-      avgCompletionTurnsMax: Number(parsed.avgCompletionTurnsMax ?? DEFAULT_KPI_THRESHOLDS.avgCompletionTurnsMax),
-      memoryHitRateMin: Number(parsed.memoryHitRateMin ?? DEFAULT_KPI_THRESHOLDS.memoryHitRateMin)
-    };
-  } catch {
-    return DEFAULT_KPI_THRESHOLDS;
-  }
-}
-function windowToMs(window) {
-  if (window === "24h") return 24 * 60 * 60 * 1e3;
-  if (window === "7d") return 7 * 24 * 60 * 60 * 1e3;
-  return 30 * 24 * 60 * 60 * 1e3;
-}
-function inWindow(e, now, window) {
-  return now - e.timestamp.getTime() <= windowToMs(window);
-}
-function isEditToolName(name) {
-  return ["Write", "Edit", "MultiEdit", "NotebookEdit"].includes(name);
-}
-function parseToolPayload(e) {
-  if (e.eventType !== "tool_observation") return null;
-  try {
-    const payload = JSON.parse(e.content);
-    return {
-      toolName: payload?.toolName,
-      success: payload?.success,
-      filePath: payload?.metadata?.filePath,
-      command: payload?.metadata?.command
-    };
-  } catch {
-    return {
-      toolName: e.metadata?.toolName,
-      success: e.metadata?.success,
-      filePath: e.metadata?.filePath,
-      command: e.metadata?.command
-    };
-  }
-}
-function isTestLikeCommand(command) {
-  if (!command) return false;
-  return /(test|jest|vitest|pytest|go test|cargo test|lint|eslint|build|tsc)/i.test(command);
-}
-function safeRatio(num, den) {
-  if (!Number.isFinite(num) || !Number.isFinite(den) || den <= 0) return 0;
-  return num / den;
-}
-function round2(value, digits = 4) {
-  const factor = 10 ** digits;
-  return Math.round(value * factor) / factor;
-}
-function computeSessionTurnCount(sessionEvents) {
-  const turnIds = /* @__PURE__ */ new Set();
-  for (const e of sessionEvents) {
-    const turnId = e.metadata?.turnId;
-    if (typeof turnId === "string" && turnId.length > 0) turnIds.add(turnId);
-  }
-  if (turnIds.size > 0) return turnIds.size;
-  return sessionEvents.filter((e) => e.eventType === "user_prompt").length;
-}
 function normalizeQueryRewriteKind2(value) {
   const normalized = (value || "").trim().toLowerCase();
   if (normalized === "follow-up-context" || normalized === "intent-rewrite") return normalized;
@@ -17054,6 +17378,63 @@ function getTraceSelectedCount(trace) {
 function getTraceCandidateCount(trace) {
   return Number(trace.candidateCount ?? trace.candidateEventIds?.length ?? trace.candidateDetails?.length ?? 0);
 }
+function normalizeStatsNumber(value) {
+  const numberValue = Number(value || 0);
+  return Number.isFinite(numberValue) ? Math.max(0, numberValue) : 0;
+}
+function sanitizeRetrievalTraceStrategyBreakdown(value) {
+  if (!Array.isArray(value)) return [];
+  const byStrategy = /* @__PURE__ */ new Map();
+  for (const item of value) {
+    const row = item && typeof item === "object" ? item : {};
+    const strategy = normalizeRetrievalTraceStrategy(row.strategy ?? "unknown");
+    const bucket = byStrategy.get(strategy) ?? {
+      strategy,
+      totalQueries: 0,
+      queriesWithSelection: 0,
+      rewrittenQueries: 0,
+      totalCandidateCount: 0,
+      totalSelectedCount: 0
+    };
+    bucket.totalQueries += normalizeStatsNumber(row.totalQueries);
+    bucket.queriesWithSelection += normalizeStatsNumber(row.queriesWithSelection);
+    bucket.rewrittenQueries += normalizeStatsNumber(row.rewrittenQueries);
+    bucket.totalCandidateCount += normalizeStatsNumber(row.totalCandidateCount);
+    bucket.totalSelectedCount += normalizeStatsNumber(row.totalSelectedCount);
+    byStrategy.set(strategy, bucket);
+  }
+  return Array.from(byStrategy.values()).map((row) => ({
+    strategy: row.strategy,
+    totalQueries: row.totalQueries,
+    queriesWithSelection: row.queriesWithSelection,
+    rewrittenQueries: row.rewrittenQueries,
+    rewriteRate: normalizeMetric(safeRatio(row.rewrittenQueries, row.totalQueries)),
+    totalCandidateCount: row.totalCandidateCount,
+    totalSelectedCount: row.totalSelectedCount,
+    avgCandidateCount: safeRatio(row.totalCandidateCount, row.totalQueries),
+    avgSelectedCount: safeRatio(row.totalSelectedCount, row.totalQueries),
+    selectionRate: normalizeMetric(safeRatio(row.totalSelectedCount, row.totalCandidateCount)),
+    queryYieldRate: normalizeMetric(safeRatio(row.queriesWithSelection, row.totalQueries))
+  }));
+}
+function sanitizeRetrievalTraceStats(stats) {
+  const s = stats && typeof stats === "object" ? stats : {};
+  return {
+    totalQueries: Number(s.totalQueries || 0),
+    avgCandidateCount: Number(s.avgCandidateCount || 0),
+    avgSelectedCount: Number(s.avgSelectedCount || 0),
+    selectionRate: normalizeMetric(s.selectionRate),
+    rewrittenQueries: Number(s.rewrittenQueries || 0),
+    rewriteRate: normalizeMetric(s.rewriteRate),
+    rewrittenQueriesWithSelection: Number(s.rewrittenQueriesWithSelection || 0),
+    rawQueriesWithSelection: Number(s.rawQueriesWithSelection || 0),
+    rewrittenSelectionRate: normalizeMetric(s.rewrittenSelectionRate),
+    rawSelectionRate: normalizeMetric(s.rawSelectionRate),
+    avgSelectedCountForRewrittenQueries: Number(s.avgSelectedCountForRewrittenQueries || 0),
+    avgSelectedCountForRawQueries: Number(s.avgSelectedCountForRawQueries || 0),
+    strategyBreakdown: sanitizeRetrievalTraceStrategyBreakdown(s.strategyBreakdown)
+  };
+}
 function makeRetrievalReviewItem(trace) {
   const candidateCount = getTraceCandidateCount(trace);
   const selectedCount = getTraceSelectedCount(trace);
@@ -17107,7 +17488,7 @@ function makeRetrievalReviewItem(trace) {
     action,
     queryRewriteKind,
     rewritten,
-    strategy: trace.strategy || null,
+    strategy: normalizeRetrievalTraceStrategy(trace.strategy ?? "unknown"),
     candidateCount,
     selectedCount,
     candidateEventIds: (trace.candidateEventIds || []).slice(0, 5),
@@ -17534,7 +17915,7 @@ statsRouter.get("/levels/:level", async (c) => {
       hasMore: events.length === limit
     });
   } catch (error) {
-    return c.json({ error: error.message }, 500);
+    return jsonError(c, error);
   } finally {
     await memoryService.shutdown();
   }
@@ -17543,7 +17924,7 @@ statsRouter.get("/operations", async (c) => {
   const context = getOperationsStatsContext(c.req.query("project") || c.req.query("projectId"));
   const windowDays = parseStatsLimit(c.req.query("windowDays"), 30, 365);
   const topFacetValues = parseStatsLimit(c.req.query("topFacetValues"), 5, 25);
-  const databaseExists = fs13.existsSync(context.dbPath);
+  const databaseExists = fs14.existsSync(context.dbPath);
   if (!databaseExists) {
     return c.json(emptyOperationsStatsPayload(context, false, [...OPERATION_STATS_TABLES], windowDays));
   }
@@ -17631,7 +18012,7 @@ statsRouter.get("/perspective", async (c) => {
   const windowDays = parseStatsLimit(c.req.query("windowDays"), 30, 365);
   const contradictionLimit = parseStatsLimit(c.req.query("contradictionLimit"), 10, 50);
   const graphLimit = parseStatsLimit(c.req.query("graphLimit"), 10, 50);
-  const databaseExists = fs13.existsSync(context.dbPath);
+  const databaseExists = fs14.existsSync(context.dbPath);
   if (!databaseExists) {
     return c.json(emptyPerspectiveStatsPayload(context, false, [...PERSPECTIVE_STATS_TABLES], windowDays));
   }
@@ -17707,33 +18088,29 @@ statsRouter.get("/", async (c) => {
   const memoryService = getLightweightServiceFromQuery(c);
   try {
     await memoryService.initialize();
-    const stats = await memoryService.getStats();
-    const recentEvents = await memoryService.getRecentEvents(1e4);
-    const eventsByType = recentEvents.reduce((acc, e) => {
-      acc[e.eventType] = (acc[e.eventType] || 0) + 1;
-      return acc;
-    }, {});
-    const uniqueSessions = new Set(recentEvents.map((e) => e.sessionId));
-    const now = /* @__PURE__ */ new Date();
-    const sevenDaysAgo = new Date(now.getTime() - 7 * 24 * 60 * 60 * 1e3);
-    const eventsByDay = recentEvents.filter((e) => e.timestamp >= sevenDaysAgo).reduce((acc, e) => {
-      const day = e.timestamp.toISOString().split("T")[0];
-      acc[day] = (acc[day] || 0) + 1;
-      return acc;
-    }, {});
-    const retrievalTrace = await memoryService.getRetrievalTraceStats();
+    const sevenDaysAgo = new Date(Date.now() - 7 * 24 * 60 * 60 * 1e3).toISOString();
+    const [stats, typeCounts, sessionTotal, dailyCounts, rawTrace] = await Promise.all([
+      memoryService.getStats(),
+      memoryService.getEventTypeCounts(),
+      memoryService.getDistinctSessionCount(),
+      memoryService.getDailyEventCounts(sevenDaysAgo),
+      memoryService.getRetrievalTraceStats()
+    ]);
+    const eventsByType = Object.fromEntries(typeCounts.map((t) => [t.eventType, t.count]));
+    const eventsByDay = Object.fromEntries(dailyCounts.map((d) => [d.day, d.total]));
+    const retrievalTrace = sanitizeRetrievalTraceStats(rawTrace);
     return c.json({
       storage: {
         eventCount: stats.totalEvents,
         vectorCount: stats.vectorCount
       },
       sessions: {
-        total: uniqueSessions.size
+        total: sessionTotal
       },
       eventsByType,
       activity: {
         daily: eventsByDay,
-        total7Days: recentEvents.filter((e) => e.timestamp >= sevenDaysAgo).length
+        total7Days: dailyCounts.reduce((sum, d) => sum + d.total, 0)
       },
       memory: {
         heapUsed: Math.round(process.memoryUsage().heapUsed / 1024 / 1024),
@@ -17743,7 +18120,7 @@ statsRouter.get("/", async (c) => {
       retrievalTrace
     });
   } catch (error) {
-    return c.json({ error: error.message }, 500);
+    return jsonError(c, error);
   } finally {
     await memoryService.shutdown();
   }
@@ -17780,30 +18157,22 @@ statsRouter.get("/most-accessed", async (c) => {
   }
 });
 statsRouter.get("/timeline", async (c) => {
-  const days = parseInt(c.req.query("days") || "7", 10);
+  const parsedDays = parseInt(c.req.query("days") || "7", 10);
+  const days = Number.isFinite(parsedDays) && parsedDays > 0 ? parsedDays : 7;
   const memoryService = getLightweightServiceFromQuery(c);
   try {
     await memoryService.initialize();
-    const recentEvents = await memoryService.getRecentEvents(1e4);
-    const cutoff = new Date(Date.now() - days * 24 * 60 * 60 * 1e3);
-    const filteredEvents = recentEvents.filter((e) => e.timestamp >= cutoff);
-    const daily = filteredEvents.reduce((acc, e) => {
-      const day = e.timestamp.toISOString().split("T")[0];
-      if (!acc[day]) {
-        acc[day] = { date: day, total: 0, prompts: 0, responses: 0, tools: 0 };
-      }
-      acc[day].total++;
-      if (e.eventType === "user_prompt") acc[day].prompts++;
-      if (e.eventType === "agent_response") acc[day].responses++;
-      if (e.eventType === "tool_observation") acc[day].tools++;
-      return acc;
-    }, {});
-    return c.json({
-      days,
-      daily: Object.values(daily).sort((a, b) => a.date.localeCompare(b.date))
-    });
+    const cutoff = new Date(Date.now() - days * 24 * 60 * 60 * 1e3).toISOString();
+    const daily = (await memoryService.getDailyEventCounts(cutoff)).map((d) => ({
+      date: d.day,
+      total: d.total,
+      prompts: d.prompts,
+      responses: d.responses,
+      tools: d.tools
+    }));
+    return c.json({ days, daily });
   } catch (error) {
-    return c.json({ error: error.message }, 500);
+    return jsonError(c, error);
   } finally {
     await memoryService.shutdown();
   }
@@ -17846,16 +18215,14 @@ statsRouter.get("/usefulness", async (c) => {
   try {
     await memoryService.initialize();
     const now = Date.now();
-    const eventLimit = 2e4;
     const traceLimit = 5e3;
     const windowStart = new Date(now - windowToMs(window));
     const [events, helpfulness, traces] = await Promise.all([
-      memoryService.getRecentEvents(eventLimit),
+      memoryService.getEventsAfter(windowStart.toISOString()),
       memoryService.getHelpfulnessStats(windowStart),
       memoryService.getRecentRetrievalTraces(traceLimit)
     ]);
     return c.json(computeMemoryUsefulnessSummary(events, helpfulness, traces, now, window, {
-      eventsLimit: eventLimit,
       tracesLimit: traceLimit
     }));
   } catch (error) {
@@ -17873,7 +18240,7 @@ statsRouter.get("/retrieval-traces", async (c) => {
     const traces = await memoryService.getRecentRetrievalTraces(limit);
     const traceStats = await memoryService.getRetrievalTraceStats();
     return c.json({
-      stats: traceStats,
+      stats: sanitizeRetrievalTraceStats(traceStats),
       traces: traces.map((t) => {
         const queryRewriteKind = normalizeQueryRewriteKind2(t.queryRewriteKind);
         return {
@@ -17882,7 +18249,7 @@ statsRouter.get("/retrieval-traces", async (c) => {
           projectHash: t.projectHash || null,
           queryRewriteKind,
           rewritten: queryRewriteKind !== "none",
-          strategy: t.strategy || null,
+          strategy: normalizeRetrievalTraceStrategy(t.strategy ?? "unknown"),
           candidateEventIds: t.candidateEventIds,
           selectedEventIds: t.selectedEventIds,
           candidateDetails: t.candidateDetails || [],
@@ -17909,7 +18276,8 @@ statsRouter.get("/retrieval-traces", async (c) => {
         rewrittenSelectionRate: 0,
         rawSelectionRate: 0,
         avgSelectedCountForRewrittenQueries: 0,
-        avgSelectedCountForRawQueries: 0
+        avgSelectedCountForRawQueries: 0,
+        strategyBreakdown: []
       },
       traces: [],
       error: error.message
@@ -17960,7 +18328,8 @@ statsRouter.get("/kpi", async (c) => {
     await memoryService.initialize();
     const now = Date.now();
     const thresholds = loadKpiThresholds();
-    const allEvents = await memoryService.getRecentEvents(2e4);
+    const lookbackMs = Math.max(2 * windowToMs(window), 30 * 24 * 60 * 60 * 1e3);
+    const allEvents = await memoryService.getEventsAfter(new Date(now - lookbackMs).toISOString());
     const events = allEvents.filter((e) => inWindow(e, now, window));
     const helpfulness = await memoryService.getHelpfulnessStats();
     const usefulRecallRate = helpfulness.totalEvaluated > 0 ? round2(safeRatio(helpfulness.helpful, helpfulness.totalEvaluated)) : 0;
@@ -18069,7 +18438,7 @@ statsRouter.get("/kpi", async (c) => {
       alerts
     });
   } catch (error) {
-    return c.json({ error: error.message }, 500);
+    return jsonError(c, error);
   } finally {
     await memoryService.shutdown();
   }
@@ -18120,11 +18489,7 @@ citationsRouter.get("/:id", async (c) => {
   const memoryService = getServiceFromQuery(c);
   try {
     await memoryService.initialize();
-    const recentEvents = await memoryService.getRecentEvents(1e4);
-    const event = recentEvents.find((e) => {
-      const eventCitationId = generateCitationId(e.id);
-      return eventCitationId === citationId;
-    });
+    const event = await memoryService.getEventByCitationId(citationId);
     if (!event) {
       return c.json({ error: "Citation not found" }, 404);
     }
@@ -18143,7 +18508,7 @@ citationsRouter.get("/:id", async (c) => {
       }
     });
   } catch (error) {
-    return c.json({ error: error.message }, 500);
+    return jsonError(c, error);
   } finally {
     await memoryService.shutdown();
   }
@@ -18154,15 +18519,11 @@ citationsRouter.get("/:id/related", async (c) => {
   const memoryService = getServiceFromQuery(c);
   try {
     await memoryService.initialize();
-    const recentEvents = await memoryService.getRecentEvents(1e4);
-    const event = recentEvents.find((e) => {
-      const eventCitationId = generateCitationId(e.id);
-      return eventCitationId === citationId;
-    });
+    const event = await memoryService.getEventByCitationId(citationId);
     if (!event) {
       return c.json({ error: "Citation not found" }, 404);
     }
-    const sessionEvents = recentEvents.filter((e) => e.sessionId === event.sessionId).sort((a, b) => a.timestamp.getTime() - b.timestamp.getTime());
+    const sessionEvents = (await memoryService.getSessionHistory(event.sessionId)).sort((a, b) => a.timestamp.getTime() - b.timestamp.getTime());
     const eventIndex = sessionEvents.findIndex((e) => e.id === event.id);
     const prev = eventIndex > 0 ? sessionEvents[eventIndex - 1] : null;
     const next = eventIndex < sessionEvents.length - 1 ? sessionEvents[eventIndex + 1] : null;
@@ -18181,7 +18542,7 @@ citationsRouter.get("/:id/related", async (c) => {
       } : null
     });
   } catch (error) {
-    return c.json({ error: error.message }, 500);
+    return jsonError(c, error);
   } finally {
     await memoryService.shutdown();
   }
@@ -18224,7 +18585,7 @@ turnsRouter.get("/", async (c) => {
       hasMore: offset + limit < totalTurns
     });
   } catch (error) {
-    return c.json({ error: error.message }, 500);
+    return jsonError(c, error);
   } finally {
     await memoryService.shutdown();
   }
@@ -18275,7 +18636,7 @@ turnsRouter.get("/:turnId", async (c) => {
       totalEvents: events.length
     });
   } catch (error) {
-    return c.json({ error: error.message }, 500);
+    return jsonError(c, error);
   } finally {
     await memoryService.shutdown();
   }
@@ -18302,8 +18663,8 @@ turnsRouter.post("/backfill", async (c) => {
 
 // src/apps/server/api/projects.ts
 import { Hono as Hono7 } from "hono";
-import * as fs14 from "fs";
-import * as path16 from "path";
+import * as fs15 from "fs";
+import * as path17 from "path";
 import * as os10 from "os";
 var projectsRouter = new Hono7();
 projectsRouter.get("/:hash/detail", async (c) => {
@@ -18332,7 +18693,7 @@ projectsRouter.get("/:hash/detail", async (c) => {
     return c.json({
       project: {
         hash,
-        projectName: projectPath ? path16.basename(projectPath) : `unknown (${hash})`,
+        projectName: projectPath ? path17.basename(projectPath) : `unknown (${hash})`,
         registered: Boolean(projectPath)
       },
       storage: {
@@ -18360,13 +18721,13 @@ projectsRouter.get("/:hash/detail", async (c) => {
 });
 projectsRouter.get("/", async (c) => {
   try {
-    const projectsDir = path16.join(os10.homedir(), ".claude-code", "memory", "projects");
-    if (!fs14.existsSync(projectsDir)) {
+    const projectsDir = path17.join(os10.homedir(), ".claude-code", "memory", "projects");
+    if (!fs15.existsSync(projectsDir)) {
       return c.json({ projects: [] });
     }
-    const projectHashes = fs14.readdirSync(projectsDir).filter((name) => {
-      const fullPath = path16.join(projectsDir, name);
-      return fs14.statSync(fullPath).isDirectory();
+    const projectHashes = fs15.readdirSync(projectsDir).filter((name) => {
+      const fullPath = path17.join(projectsDir, name);
+      return fs15.statSync(fullPath).isDirectory();
     });
     const registry = loadSessionRegistry();
     const hashToPath = /* @__PURE__ */ new Map();
@@ -18376,17 +18737,17 @@ projectsRouter.get("/", async (c) => {
       }
     }
     const projects = projectHashes.map((hash) => {
-      const dirPath = path16.join(projectsDir, hash);
-      const dbPath = path16.join(dirPath, "events.sqlite");
+      const dirPath = path17.join(projectsDir, hash);
+      const dbPath = path17.join(dirPath, "events.sqlite");
       let dbSize = 0;
-      if (fs14.existsSync(dbPath)) {
-        dbSize = fs14.statSync(dbPath).size;
+      if (fs15.existsSync(dbPath)) {
+        dbSize = fs15.statSync(dbPath).size;
       }
       const projectPath = hashToPath.get(hash) || `unknown (${hash})`;
       return {
         hash,
         projectPath,
-        projectName: path16.basename(projectPath),
+        projectName: path17.basename(projectPath),
         dbSize,
         dbSizeHuman: formatBytes(dbSize)
       };
@@ -18435,6 +18796,8 @@ function summarizeProjectOutbox(outbox) {
     pending: (embedding.pending || 0) + (vector.pending || 0),
     processing: (embedding.processing || 0) + (vector.processing || 0),
     failed: (embedding.failed || 0) + (vector.failed || 0),
+    retryableFailed: (embedding.retryableFailed || 0) + (vector.retryableFailed || 0),
+    quarantinedFailed: (embedding.quarantinedFailed || 0) + (vector.quarantinedFailed || 0),
     stuckProcessing: (embedding.stuckProcessing || 0) + (vector.stuckProcessing || 0)
   };
 }
@@ -18513,7 +18876,7 @@ chatRouter.post("/", async (c) => {
       }
     });
   } catch (error) {
-    return c.json({ error: error.message }, 500);
+    return jsonError(c, error);
   } finally {
     await memoryService.shutdown();
   }
@@ -19154,20 +19517,20 @@ playgroundRouter.post("/dry-run", async (c) => {
 var apiRouter = new Hono11().route("/sessions", sessionsRouter).route("/events", eventsRouter).route("/search", searchRouter).route("/stats", statsRouter).route("/citations", citationsRouter).route("/turns", turnsRouter).route("/projects", projectsRouter).route("/chat", chatRouter).route("/health", healthRouter).route("/playground", playgroundRouter);
 
 // src/apps/server/index.ts
-var moduleDir = path17.dirname(fileUrlToPath(import.meta.url));
+var moduleDir = path18.dirname(fileUrlToPath(import.meta.url));
 var DASHBOARD_SESSION_COOKIE = "cml_dashboard_session";
 var DEFAULT_SESSION_MAX_AGE_SECONDS = 60 * 60 * 24 * 30;
 function resolveUiPath() {
   const candidates = [
     // Built server: dist/server/index.js -> dist/ui
-    path17.resolve(moduleDir, "../ui"),
+    path18.resolve(moduleDir, "../ui"),
     // Source/dev server: src/apps/server/index.ts -> src/apps/dashboard
-    path17.resolve(moduleDir, "../dashboard"),
+    path18.resolve(moduleDir, "../dashboard"),
     // Fallback when running from a repository root.
-    path17.resolve(process.cwd(), "dist/ui"),
-    path17.resolve(process.cwd(), "src/apps/dashboard")
+    path18.resolve(process.cwd(), "dist/ui"),
+    path18.resolve(process.cwd(), "src/apps/dashboard")
   ];
-  return candidates.find((candidate) => fs15.existsSync(path17.join(candidate, "index.html"))) ?? candidates[0];
+  return candidates.find((candidate) => fs16.existsSync(path18.join(candidate, "index.html"))) ?? candidates[0];
 }
 function normalizeDashboardHost(host = "localhost") {
   const normalized = host.trim().toLowerCase();
@@ -19308,14 +19671,51 @@ function createAuthOptions(options) {
   return {
     password: options.password ?? "",
     cookieMaxAgeSeconds: options.cookieMaxAgeSeconds ?? DEFAULT_SESSION_MAX_AGE_SECONDS,
-    now: options.now ?? Date.now
+    now: options.now ?? Date.now,
+    allowedOrigins: options.allowedOrigins ?? []
   };
 }
+function resolveAllowedOrigins(explicit) {
+  if (explicit && explicit.length > 0) return explicit;
+  const raw = process.env.DASHBOARD_ALLOWED_ORIGINS;
+  if (!raw) return [];
+  return raw.split(",").map((value) => value.trim()).filter(Boolean);
+}
+function selfOrigins(c) {
+  const origins = [];
+  try {
+    origins.push(new URL(c.req.url).origin);
+  } catch {
+  }
+  const host = c.req.header("host");
+  if (host) origins.push(`${isSecureRequest(c) ? "https" : "http"}://${host}`);
+  return origins;
+}
+function isAllowedMutationOrigin(c, origin, allowedOrigins) {
+  return allowedOrigins.includes(origin) || selfOrigins(c).includes(origin);
+}
 function createDashboardApp(options = {}) {
   const app2 = new Hono12();
   const authOptions = createAuthOptions(options);
-  app2.use("*", cors());
+  const allowedOrigins = resolveAllowedOrigins(options.allowedOrigins);
+  if (allowedOrigins.length > 0) {
+    app2.use("*", cors({
+      origin: (origin) => allowedOrigins.includes(origin) ? origin : null,
+      credentials: true
+    }));
+  }
   app2.use("*", logger());
+  app2.use("/api/*", async (c, next) => {
+    const method = c.req.method;
+    if (method === "GET" || method === "HEAD" || method === "OPTIONS") {
+      return next();
+    }
+    const origin = c.req.header("origin");
+    if (origin && !isAllowedMutationOrigin(c, origin, allowedOrigins)) {
+      return c.json({ error: "Cross-origin request blocked" }, 403);
+    }
+    return next();
+  });
   app2.get("/health", (c) => c.json({ status: "ok", timestamp: (/* @__PURE__ */ new Date()).toISOString() }));
   app2.get("/api/auth/status", (c) => c.json({
     enabled: Boolean(authOptions.password),
@@ -19358,13 +19758,13 @@ function createDashboardApp(options = {}) {
   }
   app2.route("/api", apiRouter);
   const uiPath = resolveUiPath();
-  if (fs15.existsSync(uiPath)) {
+  if (fs16.existsSync(uiPath)) {
     app2.use("/*", serveStatic({ root: uiPath }));
   }
   app2.get("*", (c) => {
-    const indexPath = path17.join(uiPath, "index.html");
-    if (fs15.existsSync(indexPath)) {
-      return c.html(fs15.readFileSync(indexPath, "utf-8"));
+    const indexPath = path18.join(uiPath, "index.html");
+    if (fs16.existsSync(indexPath)) {
+      return c.html(fs16.readFileSync(indexPath, "utf-8"));
     }
     return c.text('UI not built. Run "npm run build:ui" first.', 404);
   });
@@ -19822,7 +20222,7 @@ function formatMetadataValue(value) {
 }
 
 // src/apps/cli/mcp-install.ts
-import { existsSync as existsSync13, mkdirSync as mkdirSync7, readFileSync as readFileSync6, renameSync as renameSync2, writeFileSync as writeFileSync4 } from "node:fs";
+import { existsSync as existsSync14, mkdirSync as mkdirSync7, readFileSync as readFileSync6, renameSync as renameSync2, writeFileSync as writeFileSync4 } from "node:fs";
 import { dirname as dirname7, join as join18 } from "node:path";
 import { homedir as homedir11 } from "node:os";
 function getDefaultClaudeDesktopConfigPath(platform = process.platform, env = process.env, home = homedir11()) {
@@ -19835,7 +20235,7 @@ function getDefaultClaudeDesktopConfigPath(platform = process.platform, env = pr
   return join18(env.XDG_CONFIG_HOME ?? join18(home, ".config"), "claude", "claude_desktop_config.json");
 }
 function readJsonConfig(configPath) {
-  if (!existsSync13(configPath)) {
+  if (!existsSync14(configPath)) {
     return {};
   }
   const content = readFileSync6(configPath, "utf8").trim();
@@ -19884,7 +20284,7 @@ function installMcpServer(options = {}) {
 }
 
 // src/apps/cli/claude-settings-hooks.ts
-import * as path18 from "path";
+import * as path19 from "path";
 var REQUIRED_HOOK_FILES = [
   "user-prompt-submit.js",
   "post-tool-use.js",
@@ -19903,7 +20303,7 @@ function shellQuotePathForNode(filePath) {
   return `'${filePath.replace(/'/g, `'\\''`)}'`;
 }
 function buildHookCommand(pluginPath, fileName) {
-  return `node ${shellQuotePathForNode(path18.join(pluginPath, "hooks", fileName))}`;
+  return `node ${shellQuotePathForNode(path19.join(pluginPath, "hooks", fileName))}`;
 }
 function getHooksConfig(pluginPath) {
   const makeHook = (fileName) => [
@@ -19974,8 +20374,8 @@ function mergePluginHooksIntoSettings(settings, pluginPath) {
 }
 
 // src/apps/cli/codex-validation-output.ts
-import * as fs16 from "fs";
-import * as path19 from "path";
+import * as fs17 from "fs";
+import * as path20 from "path";
 function formatNumber(value) {
   return Number.isFinite(value) ? value.toLocaleString("en-US") : String(value);
 }
@@ -20049,14 +20449,14 @@ function formatCodexValidationReport(report, format = "markdown") {
   return lines.join("\n");
 }
 function writeCodexValidationReport(outputPath, report, format = "markdown") {
-  const dir = path19.dirname(outputPath);
-  fs16.mkdirSync(dir, { recursive: true });
-  fs16.writeFileSync(outputPath, formatCodexValidationReport(report, format), "utf8");
+  const dir = path20.dirname(outputPath);
+  fs17.mkdirSync(dir, { recursive: true });
+  fs17.writeFileSync(outputPath, formatCodexValidationReport(report, format), "utf8");
 }
 
 // src/apps/cli/hermes-validation-output.ts
-import * as fs17 from "fs";
-import * as path20 from "path";
+import * as fs18 from "fs";
+import * as path21 from "path";
 function formatNumber2(value) {
   return Number.isFinite(value) ? value.toLocaleString("en-US") : String(value);
 }
@@ -20126,9 +20526,9 @@ function formatHermesValidationReport(report, format = "markdown") {
   return lines.join("\n");
 }
 function writeHermesValidationReport(outputPath, report, format = "markdown") {
-  const dir = path20.dirname(outputPath);
-  fs17.mkdirSync(dir, { recursive: true });
-  fs17.writeFileSync(outputPath, formatHermesValidationReport(report, format), "utf8");
+  const dir = path21.dirname(outputPath);
+  fs18.mkdirSync(dir, { recursive: true });
+  fs18.writeFileSync(outputPath, formatHermesValidationReport(report, format), "utf8");
 }
 
 // src/apps/cli/codex-import-runner.ts
@@ -20815,7 +21215,7 @@ function redactSecrets(input) {
 }
 
 // src/apps/cli/process-command.ts
-import * as path21 from "node:path";
+import * as path22 from "node:path";
 function resolveProcessCommandOptions(options, cwd = process.cwd(), deps = {}) {
   const explicitProject = options.project;
   if (explicitProject !== void 0 && explicitProject.trim().length === 0) {
@@ -20836,7 +21236,7 @@ function resolveProcessCommandOptions(options, cwd = process.cwd(), deps = {}) {
     projectPath,
     recoverStuck,
     dryRunRecovery,
-    lockPath: explicitLockPath ?? path21.join(getProjectStoragePath2(projectPath), "vector-worker.lock")
+    lockPath: explicitLockPath ?? path22.join(getProjectStoragePath2(projectPath), "vector-worker.lock")
   };
 }
 function formatProcessLockBusy(input) {
@@ -20900,14 +21300,12 @@ function resolveVectorStatusCommandOptions(options, cwd = process.cwd()) {
   if (options.project !== void 0 && options.project.trim().length === 0) {
     throw new Error("--project must not be empty");
   }
-  return { projectPath: options.project ?? cwd };
+  return { projectPath: options.project ?? cwd, json: options.json === true };
 }
 function formatVectorStatusReport(input) {
-  const embedding = normalizeQueue(input.outbox.embedding);
-  const vector = normalizeQueue(input.outbox.vector);
-  const totals = sumQueues(embedding, vector);
-  const status = totals.failed > 0 || totals.stuckProcessing > 0 ? "needs-attention" : "ok";
-  const oldestProcessingAge = maxNullable2(embedding.oldestProcessingAgeMs, vector.oldestProcessingAgeMs);
+  const report = buildVectorStatusReport(input);
+  const { embedding, vector, totals } = report.outbox;
+  const oldestProcessingAge = report.oldestProcessingAgeMs;
   const lines = [
     "Vector Outbox Status",
     `Vector count: ${input.stats.vectorCount}`,
@@ -20920,13 +21318,40 @@ function formatVectorStatusReport(input) {
     "",
     `Totals: pending=${totals.pending}, processing=${totals.processing}, failed=${totals.failed}, retryableFailed=${totals.retryableFailed ?? 0}, quarantinedFailed=${totals.quarantinedFailed ?? 0}, stuck=${totals.stuckProcessing}, total=${totals.total}`,
     `Oldest processing age: ${formatDuration2(oldestProcessingAge)}`,
-    `Status: ${status}`
+    `Status: ${report.status}`
   ];
-  if (status === "needs-attention") {
+  if (report.recommendedAction === "run-recovery") {
     lines.push("", "Next step: claude-memory-layer process --dry-run-recovery");
+  } else if (report.recommendedAction === "inspect-quarantined") {
+    lines.push("", "Next step: inspect quarantined outbox failures; recovery has no retryable failed rows.");
   }
   return lines.join("\n");
 }
+function formatVectorStatusJsonReport(input) {
+  return JSON.stringify(buildVectorStatusReport(input), null, 2);
+}
+function buildVectorStatusReport(input) {
+  const embedding = normalizeQueue(input.outbox.embedding);
+  const vector = normalizeQueue(input.outbox.vector);
+  const totals = sumQueues(embedding, vector);
+  const status = totals.failed > 0 || totals.stuckProcessing > 0 ? "needs-attention" : "ok";
+  const oldestProcessingAgeMs = maxNullable2(embedding.oldestProcessingAgeMs, vector.oldestProcessingAgeMs);
+  return {
+    storage: {
+      totalEvents: numberOrZero(input.stats.totalEvents),
+      vectorCount: numberOrZero(input.stats.vectorCount)
+    },
+    outbox: { embedding, vector, totals },
+    status,
+    recommendedAction: selectRecommendedAction(totals),
+    oldestProcessingAgeMs
+  };
+}
+function selectRecommendedAction(totals) {
+  if ((totals.retryableFailed ?? 0) > 0 || totals.stuckProcessing > 0) return "run-recovery";
+  if ((totals.quarantinedFailed ?? 0) > 0) return "inspect-quarantined";
+  return "none";
+}
 function normalizeQueue(queue) {
   return {
     pending: numberOrZero(queue.pending),
@@ -20989,12 +21414,12 @@ function formatDuration2(ms) {
 }
 
 // src/apps/cli/mongo-sync-command.ts
-import * as path23 from "node:path";
+import * as path24 from "node:path";
 
 // src/core/worker-lock.ts
-import { closeSync, existsSync as existsSync14, mkdirSync as mkdirSync10, openSync, readFileSync as readFileSync7, unlinkSync, writeFileSync as writeFileSync7 } from "node:fs";
+import { closeSync, existsSync as existsSync15, mkdirSync as mkdirSync10, openSync, readFileSync as readFileSync7, unlinkSync, writeFileSync as writeFileSync7 } from "node:fs";
 import * as os12 from "node:os";
-import * as path22 from "node:path";
+import * as path23 from "node:path";
 import { randomUUID as randomUUID18 } from "node:crypto";
 var WorkerLock = class {
   lockPath;
@@ -21003,7 +21428,7 @@ var WorkerLock = class {
   now;
   isProcessRunning;
   acquired = false;
-  constructor(lockPath = path22.join(os12.tmpdir(), "claude-memory-layer", "vector-worker.lock"), options = {}) {
+  constructor(lockPath = path23.join(os12.tmpdir(), "claude-memory-layer", "vector-worker.lock"), options = {}) {
     this.lockPath = lockPath;
     this.pid = options.pid ?? process.pid;
     this.ownerId = options.ownerId ?? randomUUID18();
@@ -21016,7 +21441,7 @@ var WorkerLock = class {
   acquire() {
     let staleRecovered = false;
     for (; ; ) {
-      mkdirSync10(path22.dirname(this.lockPath), { recursive: true });
+      mkdirSync10(path23.dirname(this.lockPath), { recursive: true });
       const createResult = this.tryCreateLockFile();
       if (createResult === "created") {
         this.acquired = true;
@@ -21050,7 +21475,7 @@ var WorkerLock = class {
     }
   }
   release() {
-    if (!this.acquired || !existsSync14(this.lockPath)) return false;
+    if (!this.acquired || !existsSync15(this.lockPath)) return false;
     const existing = this.readPayload();
     if (!this.isOwnedPayload(existing)) return false;
     try {
@@ -21148,7 +21573,7 @@ function resolveMongoSyncProcessOptions(options, cwd = process.cwd(), deps = {})
     projectPath,
     processAfterSync: options.processAfterSync === true,
     processIntervalMs,
-    lockPath: explicitLockPath ?? path23.join(getProjectStoragePath2(projectPath), "vector-worker.lock")
+    lockPath: explicitLockPath ?? path24.join(getProjectStoragePath2(projectPath), "vector-worker.lock")
   };
 }
 function createMongoSyncPostProcessor(options, deps = {}) {
@@ -21231,28 +21656,28 @@ function parsePositiveIntegerOption2(raw, flagName) {
 }
 
 // src/apps/cli/index.ts
-var CLAUDE_SETTINGS_PATH = path24.join(os13.homedir(), ".claude", "settings.json");
+var CLAUDE_SETTINGS_PATH = path25.join(os13.homedir(), ".claude", "settings.json");
 function getPluginPath() {
   const possiblePaths = [
-    path24.join(__dirname, ".."),
+    path25.join(__dirname, ".."),
     // When running from dist/cli
-    path24.join(__dirname, "../..", "dist"),
+    path25.join(__dirname, "../..", "dist"),
     // When running from src
-    path24.join(process.cwd(), "dist")
+    path25.join(process.cwd(), "dist")
     // Current working directory
   ];
   for (const p of possiblePaths) {
-    const hooksPath = path24.join(p, "hooks", "user-prompt-submit.js");
-    if (fs18.existsSync(hooksPath)) {
+    const hooksPath = path25.join(p, "hooks", "user-prompt-submit.js");
+    if (fs19.existsSync(hooksPath)) {
       return p;
     }
   }
-  return path24.join(os13.homedir(), ".npm-global", "lib", "node_modules", "claude-memory-layer", "dist");
+  return path25.join(os13.homedir(), ".npm-global", "lib", "node_modules", "claude-memory-layer", "dist");
 }
 function loadClaudeSettings() {
   try {
-    if (fs18.existsSync(CLAUDE_SETTINGS_PATH)) {
-      const content = fs18.readFileSync(CLAUDE_SETTINGS_PATH, "utf-8");
+    if (fs19.existsSync(CLAUDE_SETTINGS_PATH)) {
+      const content = fs19.readFileSync(CLAUDE_SETTINGS_PATH, "utf-8");
       return JSON.parse(content);
     }
   } catch (error) {
@@ -21261,13 +21686,13 @@ function loadClaudeSettings() {
   return {};
 }
 function saveClaudeSettings(settings) {
-  const dir = path24.dirname(CLAUDE_SETTINGS_PATH);
-  if (!fs18.existsSync(dir)) {
-    fs18.mkdirSync(dir, { recursive: true });
+  const dir = path25.dirname(CLAUDE_SETTINGS_PATH);
+  if (!fs19.existsSync(dir)) {
+    fs19.mkdirSync(dir, { recursive: true });
   }
   const tempPath = CLAUDE_SETTINGS_PATH + ".tmp";
-  fs18.writeFileSync(tempPath, JSON.stringify(settings, null, 2));
-  fs18.renameSync(tempPath, CLAUDE_SETTINGS_PATH);
+  fs19.writeFileSync(tempPath, JSON.stringify(settings, null, 2));
+  fs19.renameSync(tempPath, CLAUDE_SETTINGS_PATH);
 }
 function parseCommaList(value) {
   if (!value) return void 0;
@@ -21327,7 +21752,7 @@ async function runCodexValidationCommand(options) {
   process.stdout.write(rendered.endsWith("\n") ? rendered : `${rendered}
 `);
   if (options.output) {
-    const outputPath = path24.resolve(options.output);
+    const outputPath = path25.resolve(options.output);
     writeCodexValidationReport(outputPath, report, format);
     console.log(`
 Report written to ${outputPath}`);
@@ -21347,7 +21772,7 @@ async function runHermesValidationCommand(options) {
   process.stdout.write(rendered.endsWith("\n") ? rendered : `${rendered}
 `);
   if (options.output) {
-    const outputPath = path24.resolve(options.output);
+    const outputPath = path25.resolve(options.output);
     writeHermesValidationReport(outputPath, report, format);
     console.log(`
 Report written to ${outputPath}`);
@@ -21381,18 +21806,18 @@ var OPERATION_PRIVACY_CONFIG = {
   }
 };
 function resolveOperationProject(project) {
-  const projectPath = path24.resolve(project ?? process.cwd());
+  const projectPath = path25.resolve(project ?? process.cwd());
   const projectHash = hashProjectPath(projectPath);
   const storagePath = getProjectStoragePath(projectPath);
   return {
     projectPath,
     projectHash,
     storagePath,
-    dbPath: path24.join(storagePath, "events.sqlite")
+    dbPath: path25.join(storagePath, "events.sqlite")
   };
 }
 function openOperationReadDatabase(context) {
-  if (!fs18.existsSync(context.dbPath)) return null;
+  if (!fs19.existsSync(context.dbPath)) return null;
   return createSQLiteDatabase(context.dbPath, { readonly: true, walMode: false });
 }
 async function withOperationWriteDatabase(context, callback) {
@@ -21602,7 +22027,7 @@ async function runOperationCli(action, label) {
   }
 }
 var program = new Command();
-program.name("claude-memory-layer").description("Claude Code Memory Plugin CLI").version("1.0.52");
+program.name("claude-memory-layer").description("Claude Code Memory Plugin CLI").version("1.0.54");
 program.command("market-context").description("Fetch read-only DART/FRED/Finnhub context with structured MarketContextSnapshot bull/bear/risk/catalyst analysis").option("--company <name>", "Company name for DART fallback search and report subject").option("--dart-corp-code <code>", "Exact DART corp_code for issuer-specific filings").option("--symbol <ticker>", "Listed ticker for Finnhub company profile").option("--providers <list>", "Comma-separated providers: dart,fred,finnhub").option("--fred-series <list>", "Comma-separated FRED series IDs").option("--json", "Print structured JSON including analysis.marketSnapshot").option("--no-snapshot", "Disable MarketContextSnapshot and DART company snapshot analysis").action(async (options) => {
   try {
     await runMarketContextCommand(options);
@@ -21615,7 +22040,7 @@ program.command("install").description("Install hooks into Claude Code settings"
   try {
     const pluginPath = options.path || getPluginPath();
     const missingHooks = REQUIRED_HOOK_FILES.filter(
-      (file) => !fs18.existsSync(path24.join(pluginPath, "hooks", file))
+      (file) => !fs19.existsSync(path25.join(pluginPath, "hooks", file))
     );
     if (missingHooks.length > 0) {
       console.error(`
@@ -21681,7 +22106,7 @@ program.command("status").description("Check plugin installation status").action
     console.log(`  PostToolUse: ${hasPostToolHook ? "\u2705 Installed" : "\u274C Not installed"}`);
     console.log(`  Stop: ${hasStopHook ? "\u2705 Installed" : "\u274C Not installed"}`);
     console.log(`  SessionEnd: ${hasSessionEndHook ? "\u2705 Installed" : "\u274C Not installed"}`);
-    const hooksExist = REQUIRED_HOOK_FILES.every((file) => fs18.existsSync(path24.join(pluginPath, "hooks", file)));
+    const hooksExist = REQUIRED_HOOK_FILES.every((file) => fs19.existsSync(path25.join(pluginPath, "hooks", file)));
     console.log(`
 Plugin files: ${hooksExist ? "\u2705 Found" : "\u274C Not found"}`);
     console.log(`  Path: ${pluginPath}`);
@@ -21816,7 +22241,7 @@ program.command("stats").description("View memory statistics").option("-p, --pro
     process.exit(1);
   }
 });
-program.command("vector-status").description("Show aggregate vector outbox status").option("-p, --project <path>", "Project path (defaults to cwd)").action(async (options) => {
+program.command("vector-status").description("Show aggregate vector outbox status").option("-p, --project <path>", "Project path (defaults to cwd)").option("--json", "Print aggregate vector outbox status as JSON for automation").action(async (options) => {
   let service;
   try {
     const vectorOptions = resolveVectorStatusCommandOptions(options);
@@ -21825,7 +22250,8 @@ program.command("vector-status").description("Show aggregate vector outbox statu
       service.getStats(),
       service.getOutboxStats()
     ]);
-    console.log(formatVectorStatusReport({ stats, outbox }));
+    const rendered = vectorOptions.json ? formatVectorStatusJsonReport({ stats, outbox }) : formatVectorStatusReport({ stats, outbox });
+    console.log(rendered);
   } catch (error) {
     const message = error instanceof Error && error.message.startsWith("--") ? error.message : "Vector status failed";
     console.error(message);
@@ -21915,8 +22341,8 @@ repairCommand.command("legacy-project-scope").description("Dry-run or apply proj
       apply: options.apply
     });
     const storagePath = projectPath ? getProjectStoragePath(projectPath) : resolveProjectStoragePath(repairOptions.projectHash);
-    const dbPath = path24.join(storagePath, "events.sqlite");
-    if (repairOptions.dryRun && !fs18.existsSync(dbPath)) {
+    const dbPath = path25.join(storagePath, "events.sqlite");
+    if (repairOptions.dryRun && !fs19.existsSync(dbPath)) {
       const projectHash = repairOptions.projectHash || hashProjectPath(repairOptions.projectPath);
       console.log(formatLegacyProjectScopeRepairResult({
         dryRun: true,
@@ -22163,8 +22589,8 @@ retentionCommand.command("audit").description("Run a dry-run retention audit for
     });
     const projectHash = auditOptions.projectHash ?? hashProjectPath(auditOptions.projectPath);
     const storagePath = auditOptions.projectPath ? getProjectStoragePath(auditOptions.projectPath) : resolveProjectStoragePath(projectHash);
-    const dbPath = path24.join(storagePath, "events.sqlite");
-    if (!fs18.existsSync(dbPath)) {
+    const dbPath = path25.join(storagePath, "events.sqlite");
+    if (!fs19.existsSync(dbPath)) {
       const emptyReport = emptyRetentionAuditReport(projectHash, auditOptions.limit);
       console.log(formatRetentionAuditReport(emptyReport, { json: auditOptions.json }));
       return;
@@ -22191,7 +22617,7 @@ program.command("mongo-sync").description("Sync events with MongoDB for multi-se
   const projectPath = options.project || process.cwd();
   const mongoUri = options.mongoUri || process.env.CLAUDE_MEMORY_MONGO_URI;
   const mongoDb = options.mongoDb || process.env.CLAUDE_MEMORY_MONGO_DB;
-  const projectKey = options.mongoProject || process.env.CLAUDE_MEMORY_MONGO_PROJECT || path24.basename(projectPath);
+  const projectKey = options.mongoProject || process.env.CLAUDE_MEMORY_MONGO_PROJECT || path25.basename(projectPath);
   const direction = String(options.direction || "both").toLowerCase();
   if (!mongoUri || !mongoDb) {
     console.error("\n\u274C MongoDB sync is not configured.");
@@ -22221,14 +22647,14 @@ program.command("mongo-sync").description("Sync events with MongoDB for multi-se
     }
   })();
   const storagePath = getProjectStoragePath(projectPath);
-  if (!fs18.existsSync(storagePath)) {
-    fs18.mkdirSync(storagePath, { recursive: true });
+  if (!fs19.existsSync(storagePath)) {
+    fs19.mkdirSync(storagePath, { recursive: true });
   }
   const postProcessor = createMongoSyncPostProcessor(processOptions, {
     log: (message) => process.stdout.write(`${message}
 `)
   });
-  const sqliteStore = new SQLiteEventStore(path24.join(storagePath, "events.sqlite"));
+  const sqliteStore = new SQLiteEventStore(path25.join(storagePath, "events.sqlite"));
   const worker = new MongoSyncWorker(sqliteStore, {
     uri: mongoUri,
     dbName: mongoDb,
@@ -22288,7 +22714,7 @@ function renderProgress(event) {
       break;
     case "session-start": {
       const pct = Math.round(event.sessionIndex / event.totalSessions * 100);
-      const sessionName = path24.basename(event.filePath, ".jsonl").slice(0, 8);
+      const sessionName = path25.basename(event.filePath, ".jsonl").slice(0, 8);
       process.stdout.write(
         `\r  \u{1F4C4} [${event.sessionIndex + 1}/${event.totalSessions}] ${pct}% | Session ${sessionName}... `
       );
@@ -22363,9 +22789,9 @@ async function listMarkdownFiles(root) {
   const stack = [root];
   while (stack.length > 0) {
     const dir = stack.pop();
-    const entries = await fs18.promises.readdir(dir, { withFileTypes: true });
+    const entries = await fs19.promises.readdir(dir, { withFileTypes: true });
     for (const e of entries) {
-      const full = path24.join(dir, e.name);
+      const full = path25.join(dir, e.name);
       if (e.isDirectory()) stack.push(full);
       else if (e.isFile() && e.name.endsWith(".md") && e.name !== "_index.md") out.push(full);
     }
@@ -22373,8 +22799,8 @@ async function listMarkdownFiles(root) {
   return out.sort();
 }
 function deriveNamespaceCategory(sourceRoot, filePath) {
-  const rel = path24.relative(sourceRoot, filePath);
-  const dirSeg = path24.dirname(rel).split(path24.sep).filter(Boolean);
+  const rel = path25.relative(sourceRoot, filePath);
+  const dirSeg = path25.dirname(rel).split(path25.sep).filter(Boolean);
   if (dirSeg.length >= 2) {
     const namespace = sanitizeSegment3(dirSeg[0], "default");
     const categoryPath = dirSeg.slice(1).map((s) => sanitizeSegment3(s, "uncategorized"));
@@ -22393,10 +22819,10 @@ function extractImportEvidence(markdown) {
 program.command("organize-import [sourceDir]").description("Import existing markdown memory files, or bootstrap knowledge docs from codebase/git when markdown is missing").option("-p, --project <path>", "Project path (defaults to cwd)").option("--session <id>", "Session id for imported events (default: import:organized)").option("--limit <n>", "Limit number of files to import").option("--dry-run", "Preview mapping without writing").option("--bootstrap", "Force-generate structured markdown from codebase + git history before import").option("--bootstrap-if-empty", "Auto-bootstrap when source has no markdown files (default: true)", true).option("--no-bootstrap-if-empty", "Disable auto-bootstrap when source has no markdown files").option("--force-bootstrap", "Run bootstrap even when markdown files exist").option("--repo <path>", "Repository root for bootstrap analysis (default: project path)").option("--out <path>", "Output directory for generated bootstrap markdown (default: <sourceDir>/bootstrap-kb)").option("--since <range>", 'Git history range for bootstrap (default: "180 days ago")').option("--max-commits <n>", "Max commits to analyze for bootstrap (default: 1000)").option("--incremental", "Use previous bootstrap manifest as baseline for incremental updates (default: true)", true).option("--no-incremental", "Disable incremental bootstrap; regenerate full snapshot").action(async (sourceDir, options) => {
   const projectPath = options.project || process.cwd();
   const sessionId = options.session || "import:organized";
-  const sourceRoot = path24.resolve(sourceDir || options.out || projectPath);
-  const repoPath = path24.resolve(options.repo || projectPath);
-  if (!fs18.existsSync(sourceRoot)) {
-    fs18.mkdirSync(sourceRoot, { recursive: true });
+  const sourceRoot = path25.resolve(sourceDir || options.out || projectPath);
+  const repoPath = path25.resolve(options.repo || projectPath);
+  if (!fs19.existsSync(sourceRoot)) {
+    fs19.mkdirSync(sourceRoot, { recursive: true });
   }
   const service = getMemoryServiceForProject(projectPath);
   try {
@@ -22406,7 +22832,7 @@ program.command("organize-import [sourceDir]").description("Import existing mark
     const hasMarkdown = files.length > 0;
     const shouldBootstrap = Boolean(options.forceBootstrap || options.bootstrap || !hasMarkdown && options.bootstrapIfEmpty);
     if (shouldBootstrap) {
-      const outDir = path24.resolve(options.out || path24.join(sourceRoot, "bootstrap-kb"));
+      const outDir = path25.resolve(options.out || path25.join(sourceRoot, "bootstrap-kb"));
       const since = options.since || "180 days ago";
       const maxCommits = options.maxCommits ? Math.max(1, parseInt(options.maxCommits, 10)) : 1e3;
       console.log("\n\u{1F9E0} Bootstrapping markdown knowledge base...");
@@ -22445,13 +22871,13 @@ program.command("organize-import [sourceDir]").description("Import existing mark
     let imported = 0;
     let skipped = 0;
     for (const file of targets) {
-      const text = await fs18.promises.readFile(file, "utf8");
+      const text = await fs19.promises.readFile(file, "utf8");
       if (!text.trim()) {
         skipped += 1;
         continue;
       }
       const { namespace, categoryPath } = deriveNamespaceCategory(activeSourceRoot, file);
-      const rel = path24.relative(activeSourceRoot, file);
+      const rel = path25.relative(activeSourceRoot, file);
       const evidence = extractImportEvidence(text);
       if (options.dryRun) {
         console.log(`- ${rel} -> namespace=${namespace} category=${categoryPath.join("/")} confidence=${evidence.confidence || "n/a"} sources=${evidence.sources.length}`);