claude-memory-layer 1.0.53 → 1.0.55

package/dist/server/index.js

@@ -12,8 +12,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 path13 from "path";
-import * as fs11 from "fs";
+import * as path15 from "path";
+import * as fs13 from "fs";
 import { createHmac, timingSafeEqual } from "crypto";
 import { fileURLToPath as fileUrlToPath } from "url";
 
@@ -175,7 +175,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);
@@ -408,19 +414,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;
   }
   /**
@@ -526,11 +542,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
@@ -643,16 +660,16 @@ var ConsolidatedStore = class {
    * Check if source events are already consolidated
    */
   async isAlreadyConsolidated(eventIds) {
-    for (const eventId of eventIds) {
-      const result = await dbAll(
-        this.db,
-        `SELECT COUNT(*) as count FROM consolidated_memories
-         WHERE source_events LIKE ?`,
-        [`%"${eventId}"%`]
-      );
-      if ((result[0]?.count || 0) > 0) return true;
-    }
-    return false;
+    if (eventIds.length === 0) return false;
+    const placeholders = eventIds.map(() => "?").join(",");
+    const rows = await dbAll(
+      this.db,
+      `SELECT memory_id FROM consolidated_memory_events
+       WHERE event_id IN (${placeholders})
+       LIMIT 1`,
+      eventIds
+    );
+    return rows.length > 0;
   }
   /**
    * Get the last consolidation time
@@ -2188,6 +2205,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";
 
@@ -2221,12 +2255,12 @@ function resolveProjectStoragePath(projectOrHash) {
 import Database from "better-sqlite3";
 import * as fs4 from "fs";
 import * as nodePath from "path";
-function createSQLiteDatabase(path14, options) {
-  const dir = nodePath.dirname(path14);
+function createSQLiteDatabase(path16, options) {
+  const dir = nodePath.dirname(path16);
   if (!fs4.existsSync(dir)) {
     fs4.mkdirSync(dir, { recursive: true });
   }
-  const db = new Database(path14, {
+  const db = new Database(path16, {
     readonly: options?.readonly ?? false
   });
   if (!options?.readonly && (options?.walMode ?? true)) {
@@ -2236,17 +2270,28 @@ function createSQLiteDatabase(path14, 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);
@@ -2668,6 +2713,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 },
@@ -2677,17 +2723,17 @@ function emptyOutboxRecoveryResult() {
 function isRecord(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
-function getNestedRecord(root, path14) {
+function getNestedRecord(root, path16) {
   let cursor = root;
-  for (const key of path14) {
+  for (const key of path16) {
     if (!isRecord(cursor)) return void 0;
     cursor = cursor[key];
   }
   return isRecord(cursor) ? cursor : void 0;
 }
-function getNestedString(root, path14) {
+function getNestedString(root, path16) {
   let cursor = root;
-  for (const key of path14) {
+  for (const key of path16) {
     if (!isRecord(cursor)) return void 0;
     cursor = cursor[key];
   }
@@ -3012,6 +3058,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,
@@ -3371,11 +3426,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) => {
@@ -3412,55 +3473,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);
@@ -3477,8 +3500,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;
   }
   /**
@@ -3610,6 +3643,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
    */
@@ -3623,6 +3717,71 @@ var SQLiteEventStore = class {
     if (!row) return null;
     return this.rowToEvent(row);
   }
+  /**
+   * Batch-fetch events by id in a single query, applying the same quarantine
+   * predicate as getEvent. Lets hot paths replace N sequential round-trips with
+   * one. Missing ids are simply absent from the result (order not guaranteed).
+   */
+  async getEvents(ids, options) {
+    await this.initialize();
+    if (ids.length === 0) return [];
+    const placeholders = ids.map(() => "?").join(",");
+    const rows = sqliteAll(
+      this.db,
+      `SELECT * FROM events WHERE id IN (${placeholders}) AND ${maybeQuarantinePredicate(options)}`,
+      ids
+    );
+    return rows.map((row) => this.rowToEvent(row));
+  }
+  /**
+   * Resolve an event from its citation id via the reverse index, instead of
+   * scanning recent events and hashing each one. The index is self-healing: a
+   * miss triggers a one-time backfill of any events not yet indexed (covering
+   * freshly appended events) before retrying.
+   */
+  async getEventByCitationId(citationId, options) {
+    await this.initialize();
+    if (!citationId) return null;
+    let row = sqliteGet(
+      this.db,
+      `SELECT event_id FROM event_citations WHERE citation_id = ? LIMIT 1`,
+      [citationId]
+    );
+    if (!row) {
+      this.indexMissingCitations();
+      row = sqliteGet(
+        this.db,
+        `SELECT event_id FROM event_citations WHERE citation_id = ? LIMIT 1`,
+        [citationId]
+      );
+    }
+    if (!row) return null;
+    return this.getEvent(row.event_id, options);
+  }
+  /**
+   * Backfill citation ids for any events not yet present in event_citations.
+   * Gated on a cheap count comparison so the common (fully-indexed) path does no
+   * work, and the scan only runs when there are genuinely new events to index.
+   */
+  indexMissingCitations() {
+    const eventCount = sqliteGet(this.db, `SELECT COUNT(*) as c FROM events`, [])?.c ?? 0;
+    const indexedCount = sqliteGet(this.db, `SELECT COUNT(*) as c FROM event_citations`, [])?.c ?? 0;
+    if (indexedCount >= eventCount) return;
+    const unindexed = sqliteAll(
+      this.db,
+      `SELECT e.id FROM events e
+       LEFT JOIN event_citations ec ON ec.event_id = e.id
+       WHERE ec.event_id IS NULL`,
+      []
+    );
+    if (unindexed.length === 0) return;
+    const insert = this.db.prepare(`INSERT OR IGNORE INTO event_citations (event_id, citation_id) VALUES (?, ?)`);
+    this.db.transaction(() => {
+      for (const { id } of unindexed) {
+        insert.run(id, generateCitationId(id));
+      }
+    })();
+  }
   /**
    * Get events since a timestamp (for sync)
    */
@@ -3824,25 +3983,22 @@ var SQLiteEventStore = class {
    */
   async getPendingOutboxItems(limit = 32) {
     await this.initialize();
-    const pending = sqliteAll(
-      this.db,
-      `SELECT * FROM embedding_outbox
-       WHERE status = 'pending'
-       ORDER BY created_at
-       LIMIT ?`,
-      [limit]
-    );
-    if (pending.length === 0) return [];
-    const ids = pending.map((r) => r.id);
-    const placeholders = ids.map(() => "?").join(",");
-    sqliteRun(
+    const claimed = sqliteAll(
       this.db,
       `UPDATE embedding_outbox
        SET status = 'processing', processed_at = datetime('now'), error_message = NULL
-       WHERE id IN (${placeholders})`,
-      ids
+       WHERE id IN (
+         SELECT id FROM embedding_outbox
+         WHERE status = 'pending'
+         ORDER BY created_at
+         LIMIT ?
+       )
+       RETURNING *`,
+      [limit]
     );
-    return pending.map((row) => ({
+    if (claimed.length === 0) return [];
+    claimed.sort((a, b) => String(a.created_at).localeCompare(String(b.created_at)));
+    return claimed.map((row) => ({
       id: row.id,
       eventId: row.event_id,
       content: row.content,
@@ -4446,7 +4602,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);
@@ -4609,10 +4765,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;
@@ -4641,6 +4801,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;
   }
   /**
@@ -4658,6 +4824,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();
@@ -4743,6 +4938,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);
@@ -4760,7 +4994,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")) {
@@ -4776,7 +5011,8 @@ var SQLiteEventStore = class {
           rewrittenSelectionRate: 0,
           rawSelectionRate: 0,
           avgSelectedCountForRewrittenQueries: 0,
-          avgSelectedCountForRawQueries: 0
+          avgSelectedCountForRawQueries: 0,
+          strategyBreakdown: []
         };
       }
       throw err;
@@ -4893,38 +5129,19 @@ var SQLiteEventStore = class {
     if (events.length === 0) return 0;
     const eventIds = events.map((e) => e.id);
     const placeholders = eventIds.map(() => "?").join(",");
-    const ftsTriggersDropped = [];
-    for (const triggerName of ["events_fts_delete", "events_fts_update", "events_fts_insert"]) {
-      try {
+    const relatedTables = ["event_dedup", "memory_levels", "embedding_queue", "embedding_outbox", "vector_outbox", "event_citations"].filter((table) => this.hasTable(table) && this.hasTableColumn(table, "event_id"));
+    const runDelete = this.db.transaction(() => {
+      for (const triggerName of ["events_fts_delete", "events_fts_update", "events_fts_insert"]) {
         sqliteRun(this.db, `DROP TRIGGER IF EXISTS ${triggerName}`);
-        ftsTriggersDropped.push(triggerName);
-      } catch {
       }
-    }
-    for (const table of ["event_dedup", "memory_levels", "embedding_queue", "embedding_outbox", "vector_outbox"]) {
-      try {
+      for (const table of relatedTables) {
         sqliteRun(this.db, `DELETE FROM ${table} WHERE event_id IN (${placeholders})`, eventIds);
-      } catch {
-      }
-    }
-    const result = sqliteRun(this.db, `DELETE FROM events WHERE session_id = ?`, [sessionId]);
-    if (ftsTriggersDropped.length > 0) {
-      try {
-        sqliteRun(this.db, `INSERT INTO events_fts(events_fts) VALUES('rebuild')`);
-        sqliteRun(this.db, `CREATE TRIGGER IF NOT EXISTS events_fts_insert AFTER INSERT ON events BEGIN
-          INSERT INTO events_fts(rowid, content, event_id) VALUES (NEW.rowid, NEW.content, NEW.id);
-        END`);
-        sqliteRun(this.db, `CREATE TRIGGER IF NOT EXISTS events_fts_delete AFTER DELETE ON events BEGIN
-          DELETE FROM events_fts WHERE rowid = OLD.rowid;
-        END`);
-        sqliteRun(this.db, `CREATE TRIGGER IF NOT EXISTS events_fts_update AFTER UPDATE ON events BEGIN
-          DELETE FROM events_fts WHERE rowid = OLD.rowid;
-          INSERT INTO events_fts(rowid, content, event_id) VALUES (NEW.rowid, NEW.content, NEW.id);
-        END`);
-      } catch {
       }
-    }
-    return result.changes || 0;
+      const result = sqliteRun(this.db, `DELETE FROM events WHERE session_id = ?`, [sessionId]);
+      this.recreateEventsFtsTable();
+      return result.changes || 0;
+    });
+    return runDelete();
   }
   /**
    * Convert database row to MemoryEvent
@@ -6479,12 +6696,12 @@ var GraphPathService = class {
         }
       }
     }
-    const paths = Array.from(bestByTarget.entries()).map(([key, path14]) => ({
+    const paths = Array.from(bestByTarget.entries()).map(([key, path16]) => ({
       target: graph.node(nodeFromKey(key)),
-      hops: path14.hops,
-      totalCost: path14.totalCost,
-      scoreContribution: path14.totalCost > 0 ? 1 / path14.totalCost : 0,
-      steps: path14.steps
+      hops: path16.hops,
+      totalCost: path16.totalCost,
+      scoreContribution: path16.totalCost > 0 ? 1 / path16.totalCost : 0,
+      steps: path16.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 };
   }
@@ -7257,7 +7474,7 @@ var SessionActorRepository = class {
 };
 
 // src/core/operations/perspective-observation-repository.ts
-import { createHash as createHash3, randomUUID as randomUUID9 } from "crypto";
+import { createHash as createHash4, randomUUID as randomUUID9 } from "crypto";
 function projectHashToStorage4(projectHash) {
   return projectHash ?? "";
 }
@@ -7294,7 +7511,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({
@@ -7802,23 +8019,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/vector-store.ts
 import * as lancedb from "@lancedb/lancedb";
 var VectorStore = class {
@@ -8426,6 +8626,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);
@@ -9250,12 +9474,12 @@ var Retriever = class {
         direction: "both"
       });
       const titleByEntityId = new Map(startNodes.map((node) => [node.entityId, node.title]));
-      for (const path14 of expansion.paths) {
-        if (path14.target.type !== "event") continue;
-        const target = await this.eventStore.getEvent(path14.target.id);
+      for (const path16 of expansion.paths) {
+        if (path16.target.type !== "event") continue;
+        const target = await this.eventStore.getEvent(path16.target.id);
         if (!target) continue;
-        const graphPath = toRetrievalGraphPathDebug(path14, titleByEntityId);
-        const score = graphPathScore(path14, opts.hopPenalty);
+        const graphPath = toRetrievalGraphPathDebug(path16, titleByEntityId);
+        const score = graphPathScore(path16, opts.hopPenalty);
         const existing = byId.get(target.id);
         const graphPaths = mergeGraphPaths(existing?.graphPaths ?? [], [graphPath]);
         const graphLane = {
@@ -9264,7 +9488,7 @@ var Retriever = class {
           score
         };
         const row = {
-          id: existing?.id ?? `graph-path-${path14.hops}-${target.id}`,
+          id: existing?.id ?? `graph-path-${path16.hops}-${target.id}`,
           eventId: target.id,
           content: target.content,
           score: Math.max(existing?.score ?? 0, score),
@@ -9394,11 +9618,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) {
@@ -9507,10 +9732,30 @@ var Retriever = class {
   async retrieveRecent(limit = 100) {
     return this.eventStore.getRecentEvents(limit);
   }
+  /**
+   * Batch-load events by id into a Map in a single query, de-duplicating ids.
+   * Replaces per-result getEvent round-trips in the scope/enrich hot paths.
+   */
+  async fetchEventsByIds(ids) {
+    const map = /* @__PURE__ */ new Map();
+    if (ids.length === 0) return map;
+    const unique = [...new Set(ids)];
+    if (typeof this.eventStore.getEvents === "function") {
+      const events = await this.eventStore.getEvents(unique);
+      for (const event of events) map.set(event.id, event);
+    } else {
+      const events = await Promise.all(unique.map((id) => this.eventStore.getEvent(id)));
+      for (const event of events) {
+        if (event) map.set(event.id, event);
+      }
+    }
+    return map;
+  }
   async enrichResults(results, options, query) {
     const memories = [];
+    const eventMap = await this.fetchEventsByIds(results.map((r) => r.eventId));
     for (const result of results) {
-      const event = await this.eventStore.getEvent(result.eventId);
+      const event = eventMap.get(result.eventId);
       if (!event) continue;
       if (this.graduation) {
         this.graduation.recordAccess(event.id, options.sessionId || "unknown", result.score);
@@ -9583,8 +9828,8 @@ _Context:_ ${sessionContext}`;
   }
   matchesMetadataScope(metadata, expected) {
     if (!metadata) return false;
-    return Object.entries(expected).every(([path14, value]) => {
-      const actual = path14.split(".").reduce((acc, key) => {
+    return Object.entries(expected).every(([path16, value]) => {
+      const actual = path16.split(".").reduce((acc, key) => {
         if (typeof acc !== "object" || acc === null) return void 0;
         return acc[key];
       }, metadata);
@@ -9635,22 +9880,22 @@ function uniqueEntityStartNodes(candidates) {
   }
   return nodes;
 }
-function toRetrievalGraphPathDebug(path14, titleByEntityId) {
-  const firstStep = path14.steps[0];
+function toRetrievalGraphPathDebug(path16, titleByEntityId) {
+  const firstStep = path16.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: path14.target.id,
-    targetType: path14.target.type,
-    hops: path14.hops,
-    relationPath: path14.steps.map((step) => step.relationType)
+    targetId: path16.target.id,
+    targetType: path16.target.type,
+    hops: path16.hops,
+    relationPath: path16.steps.map((step) => step.relationType)
   };
 }
-function graphPathScore(path14, hopPenalty) {
-  const base = Math.min(0.95, Math.max(0, path14.scoreContribution));
-  return Math.max(0.05, base - hopPenalty * Math.max(0, path14.hops - 1));
+function graphPathScore(path16, hopPenalty) {
+  const base = Math.min(0.95, Math.max(0, path16.scoreContribution));
+  return Math.max(0.05, base - hopPenalty * Math.max(0, path16.hops - 1));
 }
 function clampGraphHops(maxHops) {
   if (!Number.isFinite(maxHops)) return 2;
@@ -9658,14 +9903,14 @@ function clampGraphHops(maxHops) {
 }
 function mergeGraphPaths(existing, incoming) {
   const byKey = /* @__PURE__ */ new Map();
-  for (const path14 of [...existing, ...incoming]) {
-    const key = [path14.startEntityId, path14.targetType, path14.targetId, path14.hops, ...path14.relationPath].join("\0");
-    if (!byKey.has(key)) byKey.set(key, path14);
+  for (const path16 of [...existing, ...incoming]) {
+    const key = [path16.startEntityId, path16.targetType, path16.targetId, path16.hops, ...path16.relationPath].join("\0");
+    if (!byKey.has(key)) byKey.set(key, path16);
   }
   return [...byKey.values()].sort((a, b) => a.hops - b.hops || compareStable(graphPathSignature(a), graphPathSignature(b))).slice(0, 3);
 }
-function graphPathSignature(path14) {
-  return [path14.startEntityId, path14.targetType, path14.targetId, path14.hops, ...path14.relationPath].join("|");
+function graphPathSignature(path16) {
+  return [path16.startEntityId, path16.targetType, path16.targetId, path16.hops, ...path16.relationPath].join("|");
 }
 function compareStable(a, b) {
   if (a < b) return -1;
@@ -12239,18 +12484,46 @@ 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);
   }
-  /**
+  /** 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) {
@@ -12562,6 +12835,11 @@ var getLightweightMemoryServiceForProject = defaultRegistry.getLightweightMemory
 var createMemoryService = defaultRegistry.createMemoryService;
 
 // 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) {
@@ -12673,7 +12951,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();
   }
@@ -12709,7 +12987,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();
   }
@@ -12775,7 +13053,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();
   }
@@ -12785,12 +13063,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);
@@ -12812,7 +13089,7 @@ eventsRouter.get("/:id", async (c) => {
       }))
     });
   } catch (error) {
-    return c.json({ error: error.message }, 500);
+    return jsonError(c, error);
   } finally {
     await memoryService.shutdown();
   }
@@ -12859,7 +13136,7 @@ searchRouter.post("/", async (c) => {
       }
     });
   } catch (error) {
-    return c.json({ error: error.message }, 500);
+    return jsonError(c, error);
   } finally {
     await memoryService.shutdown();
   }
@@ -12902,7 +13179,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();
   }
@@ -12922,7 +13199,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();
   }
@@ -12937,7 +13214,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();
   }
@@ -12966,7 +13243,7 @@ searchRouter.get("/", async (c) => {
       }
     });
   } catch (error) {
-    return c.json({ error: error.message }, 500);
+    return jsonError(c, error);
   } finally {
     await memoryService.shutdown();
   }
@@ -12974,9 +13251,89 @@ searchRouter.get("/", async (c) => {
 
 // src/apps/server/api/stats.ts
 import { Hono as Hono4 } from "hono";
-import * as fs9 from "fs";
+import * as fs10 from "fs";
 import * as os6 from "os";
+import * as path12 from "path";
+
+// src/apps/server/api/stats-metrics.ts
+import * as fs9 from "fs";
 import * as path11 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 = path11.resolve(process.cwd(), "config", "kpi-thresholds.json");
+    if (!fs9.existsSync(filePath)) return DEFAULT_KPI_THRESHOLDS;
+    const parsed = JSON.parse(fs9.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 round(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",
@@ -13003,7 +13360,7 @@ function operationsStatsHomeDir() {
 }
 function projectStoragePathForOperationsStats(projectOrHash) {
   const projectHash = /^[a-f0-9]{8}$/.test(projectOrHash) ? projectOrHash : hashProjectPath(projectOrHash);
-  return path11.join(operationsStatsHomeDir(), ".claude-code", "memory", "projects", projectHash);
+  return path12.join(operationsStatsHomeDir(), ".claude-code", "memory", "projects", projectHash);
 }
 function getOperationsStatsContext(project) {
   if (project && project.trim().length > 0) {
@@ -13013,13 +13370,13 @@ function getOperationsStatsContext(project) {
     return {
       projectHash,
       storagePath: storagePath2,
-      dbPath: path11.join(storagePath2, "events.sqlite")
+      dbPath: path12.join(storagePath2, "events.sqlite")
     };
   }
-  const storagePath = path11.join(operationsStatsHomeDir(), ".claude-code", "memory");
+  const storagePath = path12.join(operationsStatsHomeDir(), ".claude-code", "memory");
   return {
     storagePath,
-    dbPath: path11.join(storagePath, "events.sqlite")
+    dbPath: path12.join(storagePath, "events.sqlite")
   };
 }
 function countRowValue(db, sql, params = []) {
@@ -13037,6 +13394,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(),
@@ -13450,80 +13824,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 = path11.resolve(process.cwd(), "config", "kpi-thresholds.json");
-    if (!fs9.existsSync(filePath)) return DEFAULT_KPI_THRESHOLDS;
-    const parsed = JSON.parse(fs9.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 round(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;
@@ -13551,6 +13851,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);
@@ -13604,7 +13961,7 @@ function makeRetrievalReviewItem(trace) {
     action,
     queryRewriteKind,
     rewritten,
-    strategy: trace.strategy || null,
+    strategy: normalizeRetrievalTraceStrategy(trace.strategy ?? "unknown"),
     candidateCount,
     selectedCount,
     candidateEventIds: (trace.candidateEventIds || []).slice(0, 5),
@@ -14031,7 +14388,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();
   }
@@ -14040,7 +14397,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 = fs9.existsSync(context.dbPath);
+  const databaseExists = fs10.existsSync(context.dbPath);
   if (!databaseExists) {
     return c.json(emptyOperationsStatsPayload(context, false, [...OPERATION_STATS_TABLES], windowDays));
   }
@@ -14128,7 +14485,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 = fs9.existsSync(context.dbPath);
+  const databaseExists = fs10.existsSync(context.dbPath);
   if (!databaseExists) {
     return c.json(emptyPerspectiveStatsPayload(context, false, [...PERSPECTIVE_STATS_TABLES], windowDays));
   }
@@ -14204,33 +14561,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),
@@ -14240,7 +14593,7 @@ statsRouter.get("/", async (c) => {
       retrievalTrace
     });
   } catch (error) {
-    return c.json({ error: error.message }, 500);
+    return jsonError(c, error);
   } finally {
     await memoryService.shutdown();
   }
@@ -14277,30 +14630,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();
   }
@@ -14343,16 +14688,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) {
@@ -14370,7 +14713,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 {
@@ -14379,7 +14722,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 || [],
@@ -14406,7 +14749,8 @@ statsRouter.get("/retrieval-traces", async (c) => {
         rewrittenSelectionRate: 0,
         rawSelectionRate: 0,
         avgSelectedCountForRewrittenQueries: 0,
-        avgSelectedCountForRawQueries: 0
+        avgSelectedCountForRawQueries: 0,
+        strategyBreakdown: []
       },
       traces: [],
       error: error.message
@@ -14457,7 +14801,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 ? round(safeRatio(helpfulness.helpful, helpfulness.totalEvaluated)) : 0;
@@ -14566,7 +14911,7 @@ statsRouter.get("/kpi", async (c) => {
       alerts
     });
   } catch (error) {
-    return c.json({ error: error.message }, 500);
+    return jsonError(c, error);
   } finally {
     await memoryService.shutdown();
   }
@@ -14617,11 +14962,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);
     }
@@ -14640,7 +14981,7 @@ citationsRouter.get("/:id", async (c) => {
       }
     });
   } catch (error) {
-    return c.json({ error: error.message }, 500);
+    return jsonError(c, error);
   } finally {
     await memoryService.shutdown();
   }
@@ -14651,15 +14992,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;
@@ -14678,7 +15015,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();
   }
@@ -14721,7 +15058,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();
   }
@@ -14772,7 +15109,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();
   }
@@ -14799,8 +15136,8 @@ turnsRouter.post("/backfill", async (c) => {
 
 // src/apps/server/api/projects.ts
 import { Hono as Hono7 } from "hono";
-import * as fs10 from "fs";
-import * as path12 from "path";
+import * as fs11 from "fs";
+import * as path13 from "path";
 import * as os7 from "os";
 var projectsRouter = new Hono7();
 projectsRouter.get("/:hash/detail", async (c) => {
@@ -14829,7 +15166,7 @@ projectsRouter.get("/:hash/detail", async (c) => {
     return c.json({
       project: {
         hash,
-        projectName: projectPath ? path12.basename(projectPath) : `unknown (${hash})`,
+        projectName: projectPath ? path13.basename(projectPath) : `unknown (${hash})`,
         registered: Boolean(projectPath)
       },
       storage: {
@@ -14857,13 +15194,13 @@ projectsRouter.get("/:hash/detail", async (c) => {
 });
 projectsRouter.get("/", async (c) => {
   try {
-    const projectsDir = path12.join(os7.homedir(), ".claude-code", "memory", "projects");
-    if (!fs10.existsSync(projectsDir)) {
+    const projectsDir = path13.join(os7.homedir(), ".claude-code", "memory", "projects");
+    if (!fs11.existsSync(projectsDir)) {
       return c.json({ projects: [] });
     }
-    const projectHashes = fs10.readdirSync(projectsDir).filter((name) => {
-      const fullPath = path12.join(projectsDir, name);
-      return fs10.statSync(fullPath).isDirectory();
+    const projectHashes = fs11.readdirSync(projectsDir).filter((name) => {
+      const fullPath = path13.join(projectsDir, name);
+      return fs11.statSync(fullPath).isDirectory();
     });
     const registry = loadSessionRegistry();
     const hashToPath = /* @__PURE__ */ new Map();
@@ -14873,17 +15210,17 @@ projectsRouter.get("/", async (c) => {
       }
     }
     const projects = projectHashes.map((hash) => {
-      const dirPath = path12.join(projectsDir, hash);
-      const dbPath = path12.join(dirPath, "events.sqlite");
+      const dirPath = path13.join(projectsDir, hash);
+      const dbPath = path13.join(dirPath, "events.sqlite");
       let dbSize = 0;
-      if (fs10.existsSync(dbPath)) {
-        dbSize = fs10.statSync(dbPath).size;
+      if (fs11.existsSync(dbPath)) {
+        dbSize = fs11.statSync(dbPath).size;
       }
       const projectPath = hashToPath.get(hash) || `unknown (${hash})`;
       return {
         hash,
         projectPath,
-        projectName: path12.basename(projectPath),
+        projectName: path13.basename(projectPath),
         dbSize,
         dbSizeHuman: formatBytes(dbSize)
       };
@@ -15012,7 +15349,7 @@ chatRouter.post("/", async (c) => {
       }
     });
   } catch (error) {
-    return c.json({ error: error.message }, 500);
+    return jsonError(c, error);
   } finally {
     await memoryService.shutdown();
   }
@@ -15236,6 +15573,150 @@ function streamClaudeResponse(prompt, stream) {
 // src/apps/server/api/health.ts
 import { Hono as Hono9 } from "hono";
 import { spawnSync } from "child_process";
+import * as fs12 from "fs";
+import * as path14 from "path";
+
+// src/core/productivity-health-report.ts
+var PRODUCTIVITY_HEALTH_SCHEMA_VERSION = "agent-productivity-health-v1";
+var PRODUCTIVITY_HEALTH_PROFILES = ["coder", "reviewer", "pm", "support", "researcher", "team"];
+var PRODUCTIVITY_HEALTH_MODES = ["observe", "preview", "enforce"];
+function parseProductivityHealthProfile(value) {
+  const normalized = typeof value === "string" && value.trim().length > 0 ? value.trim() : "coder";
+  if (PRODUCTIVITY_HEALTH_PROFILES.includes(normalized)) {
+    return normalized;
+  }
+  throw new Error(`Invalid --profile: expected one of ${PRODUCTIVITY_HEALTH_PROFILES.join(", ")}`);
+}
+function parseProductivityHealthMode(value) {
+  const normalized = typeof value === "string" && value.trim().length > 0 ? value.trim() : "preview";
+  if (PRODUCTIVITY_HEALTH_MODES.includes(normalized)) {
+    return normalized;
+  }
+  throw new Error(`Invalid --mode: expected one of ${PRODUCTIVITY_HEALTH_MODES.join(", ")}`);
+}
+function buildProductivityHealthReport(input) {
+  const profile = input.profile ?? "coder";
+  const mode = input.mode ?? "preview";
+  const embedding = normalizeQueue(input.outbox.embedding);
+  const vector = normalizeQueue(input.outbox.vector);
+  const totals = sumQueues(embedding, vector);
+  const storage = {
+    totalEvents: numberOrZero(input.stats.totalEvents),
+    vectorCount: numberOrZero(input.stats.vectorCount),
+    levelStats: normalizeLevelStats(input.stats.levelStats)
+  };
+  const warningReasons = [];
+  const projectGate = buildProjectScopeGate(input.project);
+  const outboxGate = buildOutboxGate(totals);
+  const densityGate = buildMemoryDensityGate(storage.totalEvents);
+  const riskGates = [projectGate, outboxGate, densityGate];
+  if (projectGate.status === "warn") warningReasons.push("project_scope_unknown");
+  if (outboxGate.status === "warn") warningReasons.push("outbox_requires_attention");
+  if (densityGate.status === "warn") warningReasons.push("memory_density_low");
+  const status = riskGates.some((gate) => gate.status === "warn") ? "needs-attention" : "ok";
+  return {
+    schemaVersion: PRODUCTIVITY_HEALTH_SCHEMA_VERSION,
+    generatedAt: (input.generatedAt ?? /* @__PURE__ */ new Date()).toISOString(),
+    status,
+    profile,
+    mode,
+    project: input.project,
+    summary: { warningReasons },
+    signals: {
+      storage,
+      outbox: { embedding, vector, totals }
+    },
+    riskGates,
+    nextBestAction: selectNextBestAction({ projectGate, outboxGate, densityGate })
+  };
+}
+function buildProjectScopeGate(project) {
+  if (project.scope === "project") {
+    return { id: "project-scope-known", severity: "blocker", status: "pass" };
+  }
+  return {
+    id: "project-scope-known",
+    severity: "blocker",
+    status: "warn",
+    message: "No project parameter supplied; report uses global memory scope."
+  };
+}
+function buildOutboxGate(totals) {
+  if (totals.failed > 0 || totals.stuckProcessing > 0) {
+    return {
+      id: "outbox-healthy",
+      severity: "warning",
+      status: "warn",
+      message: "Outbox has failed or stuck processing items; run recovery before trusting retrieval freshness."
+    };
+  }
+  return { id: "outbox-healthy", severity: "warning", status: "pass" };
+}
+function buildMemoryDensityGate(totalEvents) {
+  if (totalEvents <= 0) {
+    return {
+      id: "memory-density",
+      severity: "warning",
+      status: "warn",
+      message: "No memories are available for this scope yet."
+    };
+  }
+  return { id: "memory-density", severity: "warning", status: "pass" };
+}
+function selectNextBestAction(input) {
+  if (input.outboxGate.status === "warn") {
+    return "Run claude-memory-layer process --dry-run-recovery, then process pending embeddings.";
+  }
+  if (input.densityGate.status === "warn") {
+    return "Import or capture project context before relying on productivity memory guidance.";
+  }
+  if (input.projectGate.status === "warn") {
+    return "Provide a project path or project hash before relying on project-scoped productivity guidance.";
+  }
+  return "No immediate maintenance action required.";
+}
+function normalizeLevelStats(levelStats) {
+  if (!Array.isArray(levelStats)) return [];
+  return levelStats.filter((entry) => typeof entry.level === "string" && entry.level.trim().length > 0).map((entry) => ({ level: entry.level.trim().slice(0, 20), count: numberOrZero(entry.count) }));
+}
+function normalizeQueue(queue) {
+  return {
+    pending: numberOrZero(queue.pending),
+    processing: numberOrZero(queue.processing),
+    failed: numberOrZero(queue.failed),
+    retryableFailed: numberOrZero(queue.retryableFailed),
+    quarantinedFailed: numberOrZero(queue.quarantinedFailed),
+    total: numberOrZero(queue.total),
+    stuckProcessing: numberOrZero(queue.stuckProcessing),
+    oldestProcessingAgeMs: normalizeNullableAge(queue.oldestProcessingAgeMs)
+  };
+}
+function sumQueues(a, b) {
+  return {
+    pending: a.pending + b.pending,
+    processing: a.processing + b.processing,
+    failed: a.failed + b.failed,
+    retryableFailed: (a.retryableFailed ?? 0) + (b.retryableFailed ?? 0),
+    quarantinedFailed: (a.quarantinedFailed ?? 0) + (b.quarantinedFailed ?? 0),
+    total: a.total + b.total,
+    stuckProcessing: a.stuckProcessing + b.stuckProcessing,
+    oldestProcessingAgeMs: maxNullable(a.oldestProcessingAgeMs, b.oldestProcessingAgeMs)
+  };
+}
+function normalizeNullableAge(value) {
+  return typeof value === "number" && Number.isFinite(value) && value >= 0 ? Math.floor(value) : null;
+}
+function maxNullable(a, b) {
+  if (a === null) return b;
+  if (b === null) return a;
+  return Math.max(a, b);
+}
+function numberOrZero(value) {
+  if (typeof value !== "number" || !Number.isFinite(value) || value <= 0) return 0;
+  return Math.floor(value);
+}
+
+// src/apps/server/api/health.ts
 var healthRouter = new Hono9();
 function hasEnvSignal(name) {
   const value = process.env[name];
@@ -15276,6 +15757,33 @@ function aggregateOutbox(outbox) {
   const stuckProcessing = (outbox.embedding?.stuckProcessing || 0) + (outbox.vector?.stuckProcessing || 0);
   return { pending, processing, failed, retryableFailed, quarantinedFailed, stuckProcessing };
 }
+function resolveProductivityProjectIdentity(project) {
+  if (!project || project.trim().length === 0) return { scope: "global", id: "global" };
+  const normalized = project.trim();
+  return { scope: "project", id: /^[a-f0-9]{8}$/.test(normalized) ? normalized : hashProjectPath(normalized) };
+}
+function explicitProjectStoreExists(project) {
+  if (!project || project.trim().length === 0) return true;
+  return fs12.existsSync(path14.join(resolveProjectStoragePath(project.trim()), "events.sqlite"));
+}
+function emptyProductivityStats() {
+  return { totalEvents: 0, vectorCount: 0, levelStats: [] };
+}
+function emptyProductivityQueue() {
+  return {
+    pending: 0,
+    processing: 0,
+    failed: 0,
+    retryableFailed: 0,
+    quarantinedFailed: 0,
+    total: 0,
+    stuckProcessing: 0,
+    oldestProcessingAgeMs: null
+  };
+}
+function emptyProductivityOutbox() {
+  return { embedding: emptyProductivityQueue(), vector: emptyProductivityQueue() };
+}
 healthRouter.get("/setup", async (c) => {
   const memoryService = getLightweightServiceFromQuery(c);
   try {
@@ -15332,6 +15840,40 @@ healthRouter.get("/setup", async (c) => {
     await memoryService.shutdown();
   }
 });
+healthRouter.get("/productivity", async (c) => {
+  let memoryService;
+  try {
+    const profile = parseProductivityHealthProfile(c.req.query("profile"));
+    const mode = parseProductivityHealthMode(c.req.query("mode"));
+    const projectQuery = c.req.query("project") || c.req.query("projectId");
+    const project = resolveProductivityProjectIdentity(projectQuery);
+    if (!explicitProjectStoreExists(projectQuery)) {
+      return c.json(buildProductivityHealthReport({
+        stats: emptyProductivityStats(),
+        outbox: emptyProductivityOutbox(),
+        project,
+        profile,
+        mode
+      }));
+    }
+    memoryService = getLightweightServiceFromQuery(c);
+    await memoryService.initialize();
+    const [stats, outbox] = await Promise.all([
+      memoryService.getStats(),
+      memoryService.getOutboxStats()
+    ]);
+    return c.json(buildProductivityHealthReport({ stats, outbox, project, profile, mode }));
+  } catch (error) {
+    const status = error instanceof Error && error.message.startsWith("Invalid --") ? 400 : 500;
+    return c.json({
+      status: "error",
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      error: status === 400 ? "Invalid productivity health option" : "Productivity health check failed"
+    }, status);
+  } finally {
+    if (memoryService) await memoryService.shutdown();
+  }
+});
 healthRouter.get("/", async (c) => {
   const memoryService = getLightweightServiceFromQuery(c);
   try {
@@ -15653,20 +16195,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 = path13.dirname(fileUrlToPath(import.meta.url));
+var moduleDir = path15.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
-    path13.resolve(moduleDir, "../ui"),
+    path15.resolve(moduleDir, "../ui"),
     // Source/dev server: src/apps/server/index.ts -> src/apps/dashboard
-    path13.resolve(moduleDir, "../dashboard"),
+    path15.resolve(moduleDir, "../dashboard"),
     // Fallback when running from a repository root.
-    path13.resolve(process.cwd(), "dist/ui"),
-    path13.resolve(process.cwd(), "src/apps/dashboard")
+    path15.resolve(process.cwd(), "dist/ui"),
+    path15.resolve(process.cwd(), "src/apps/dashboard")
   ];
-  return candidates.find((candidate) => fs11.existsSync(path13.join(candidate, "index.html"))) ?? candidates[0];
+  return candidates.find((candidate) => fs13.existsSync(path15.join(candidate, "index.html"))) ?? candidates[0];
 }
 function normalizeDashboardHost(host = "localhost") {
   const normalized = host.trim().toLowerCase();
@@ -15807,14 +16349,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),
@@ -15857,13 +16436,13 @@ function createDashboardApp(options = {}) {
   }
   app2.route("/api", apiRouter);
   const uiPath = resolveUiPath();
-  if (fs11.existsSync(uiPath)) {
+  if (fs13.existsSync(uiPath)) {
     app2.use("/*", serveStatic({ root: uiPath }));
   }
   app2.get("*", (c) => {
-    const indexPath = path13.join(uiPath, "index.html");
-    if (fs11.existsSync(indexPath)) {
-      return c.html(fs11.readFileSync(indexPath, "utf-8"));
+    const indexPath = path15.join(uiPath, "index.html");
+    if (fs13.existsSync(indexPath)) {
+      return c.html(fs13.readFileSync(indexPath, "utf-8"));
     }
     return c.text('UI not built. Run "npm run build:ui" first.', 404);
   });