claude-memory-layer 1.0.9 → 1.0.11

package/dist/server/index.js

@@ -4,26 +4,37 @@ import { dirname } from 'path';
 const require = createRequire(import.meta.url);
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined")
+    return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
 
 // src/server/index.ts
-import { Hono as Hono7 } from "hono";
+import { Hono as Hono10 } from "hono";
 import { cors } from "hono/cors";
 import { logger } from "hono/logger";
 import { serve } from "@hono/node-server";
 import { serveStatic } from "@hono/node-server/serve-static";
-import * as path2 from "path";
-import * as fs2 from "fs";
+import * as path4 from "path";
+import * as fs4 from "fs";
 
 // src/server/api/index.ts
-import { Hono as Hono6 } from "hono";
+import { Hono as Hono9 } from "hono";
 
 // src/server/api/sessions.ts
 import { Hono } from "hono";
 
+// src/server/api/utils.ts
+import * as path2 from "path";
+import * as os2 from "os";
+
 // src/services/memory-service.ts
 import * as path from "path";
 import * as os from "os";
-import * as fs from "fs";
+import * as fs2 from "fs";
 import * as crypto2 from "crypto";
 
 // src/core/event-store.ts
@@ -81,11 +92,11 @@ function toDate(value) {
     return new Date(value);
   return new Date(String(value));
 }
-function createDatabase(path3, options) {
+function createDatabase(path5, options) {
   if (options?.readOnly) {
-    return new duckdb.Database(path3, { access_mode: "READ_ONLY" });
+    return new duckdb.Database(path5, { access_mode: "READ_ONLY" });
   }
-  return new duckdb.Database(path3);
+  return new duckdb.Database(path5);
 }
 function dbRun(db, sql, params = []) {
   return new Promise((resolve2, reject) => {
@@ -755,8 +766,14 @@ import { randomUUID as randomUUID2 } from "crypto";
 
 // src/core/sqlite-wrapper.ts
 import Database from "better-sqlite3";
-function createSQLiteDatabase(path3, options) {
-  const db = new Database(path3, {
+import * as fs from "fs";
+import * as nodePath from "path";
+function createSQLiteDatabase(path5, options) {
+  const dir = nodePath.dirname(path5);
+  if (!fs.existsSync(dir)) {
+    fs.mkdirSync(dir, { recursive: true });
+  }
+  const db = new Database(path5, {
     readonly: options?.readonly ?? false
   });
   if (!options?.readonly && (options?.walMode ?? true)) {
@@ -1023,6 +1040,23 @@ var SQLiteEventStore = class {
         updated_at TEXT DEFAULT (datetime('now'))
       );
 
+      -- Memory Helpfulness tracking
+      CREATE TABLE IF NOT EXISTS memory_helpfulness (
+        id TEXT PRIMARY KEY,
+        event_id TEXT NOT NULL,
+        session_id TEXT NOT NULL,
+        retrieval_score REAL DEFAULT 0,
+        query_preview TEXT,
+        session_continued INTEGER DEFAULT 0,
+        prompt_count_after INTEGER DEFAULT 0,
+        tool_success_count INTEGER DEFAULT 0,
+        tool_total_count INTEGER DEFAULT 0,
+        was_reasked INTEGER DEFAULT 0,
+        helpfulness_score REAL DEFAULT 0.5,
+        created_at TEXT DEFAULT (datetime('now')),
+        measured_at TEXT
+      );
+
       -- Sync position tracking (for SQLite -> DuckDB sync)
       CREATE TABLE IF NOT EXISTS sync_positions (
         target_name TEXT PRIMARY KEY,
@@ -1048,6 +1082,31 @@ var SQLiteEventStore = class {
       CREATE INDEX IF NOT EXISTS idx_consolidated_confidence ON consolidated_memories(confidence);
       CREATE INDEX IF NOT EXISTS idx_continuity_created ON continuity_log(created_at);
       CREATE INDEX IF NOT EXISTS idx_embedding_outbox_status ON embedding_outbox(status);
+      CREATE INDEX IF NOT EXISTS idx_helpfulness_event ON memory_helpfulness(event_id);
+      CREATE INDEX IF NOT EXISTS idx_helpfulness_session ON memory_helpfulness(session_id);
+      CREATE INDEX IF NOT EXISTS idx_helpfulness_score ON memory_helpfulness(helpfulness_score DESC);
+
+      -- FTS5 Full-Text Search for fast keyword search
+      CREATE VIRTUAL TABLE IF NOT EXISTS events_fts USING fts5(
+        content,
+        event_id UNINDEXED,
+        content='events',
+        content_rowid='rowid'
+      );
+
+      -- Triggers to keep FTS in sync with events table
+      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;
+
+      CREATE TRIGGER IF NOT EXISTS events_fts_delete AFTER DELETE ON events BEGIN
+        INSERT INTO events_fts(events_fts, rowid, content, event_id) VALUES('delete', OLD.rowid, OLD.content, OLD.id);
+      END;
+
+      CREATE TRIGGER IF NOT EXISTS events_fts_update AFTER UPDATE ON events BEGIN
+        INSERT INTO events_fts(events_fts, rowid, content, event_id) VALUES('delete', OLD.rowid, OLD.content, OLD.id);
+        INSERT INTO events_fts(rowid, content, event_id) VALUES (NEW.rowid, NEW.content, NEW.id);
+      END;
     `);
     const tableInfo = sqliteAll(this.db, "PRAGMA table_info(events)", []);
     const columnNames = tableInfo.map((col) => col.name);
@@ -1069,6 +1128,15 @@ var SQLiteEventStore = class {
         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);
+      }
+    }
     try {
       sqliteExec(this.db, `
         CREATE INDEX IF NOT EXISTS idx_events_access_count ON events(access_count DESC);
@@ -1081,6 +1149,12 @@ var SQLiteEventStore = class {
       `);
     } catch (err) {
     }
+    try {
+      sqliteExec(this.db, `
+        CREATE INDEX IF NOT EXISTS idx_events_turn_id ON events(turn_id);
+      `);
+    } catch (err) {
+    }
     this.initialized = true;
   }
   /**
@@ -1105,9 +1179,11 @@ var SQLiteEventStore = class {
     const id = randomUUID2();
     const timestamp = toSQLiteTimestamp(input.timestamp);
     try {
+      const metadata = input.metadata || {};
+      const turnId = metadata.turnId || null;
       const insertEvent = this.db.prepare(`
-        INSERT INTO events (id, event_type, session_id, timestamp, content, canonical_key, dedupe_key, metadata)
-        VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+        INSERT INTO events (id, event_type, session_id, timestamp, content, canonical_key, dedupe_key, metadata, turn_id)
+        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
       `);
       const insertDedup = this.db.prepare(`
         INSERT INTO event_dedup (dedupe_key, event_id) VALUES (?, ?)
@@ -1124,7 +1200,8 @@ var SQLiteEventStore = class {
           input.content,
           canonicalKey,
           dedupeKey,
-          JSON.stringify(input.metadata || {})
+          JSON.stringify(metadata),
+          turnId
         );
         insertDedup.run(dedupeKey, id);
         insertLevel.run(id);
@@ -1474,11 +1551,11 @@ var SQLiteEventStore = class {
     );
   }
   /**
-   * Get most accessed memories
+   * Get most accessed memories (falls back to recent events if none accessed)
    */
   async getMostAccessed(limit = 10) {
     await this.initialize();
-    const rows = sqliteAll(
+    let rows = sqliteAll(
       this.db,
       `SELECT * FROM events
        WHERE access_count > 0
@@ -1486,8 +1563,222 @@ var SQLiteEventStore = class {
        LIMIT ?`,
       [limit]
     );
+    if (rows.length === 0) {
+      rows = sqliteAll(
+        this.db,
+        `SELECT * FROM events
+         ORDER BY timestamp DESC
+         LIMIT ?`,
+        [limit]
+      );
+    }
     return rows.map((row) => this.rowToEvent(row));
   }
+  /**
+   * Record a memory retrieval for helpfulness tracking
+   */
+  async recordRetrieval(eventId, sessionId, score, query) {
+    if (this.readOnly)
+      return;
+    await this.initialize();
+    const id = randomUUID2();
+    sqliteRun(
+      this.db,
+      `INSERT INTO memory_helpfulness (id, event_id, session_id, retrieval_score, query_preview, created_at)
+       VALUES (?, ?, ?, ?, ?, datetime('now'))`,
+      [id, eventId, sessionId, score, query.slice(0, 100)]
+    );
+  }
+  /**
+   * Evaluate helpfulness for all retrievals in a session
+   * Called at session end - uses behavioral signals to compute score
+   */
+  async evaluateSessionHelpfulness(sessionId) {
+    if (this.readOnly)
+      return;
+    await this.initialize();
+    const retrievals = sqliteAll(
+      this.db,
+      `SELECT * FROM memory_helpfulness WHERE session_id = ? AND measured_at IS NULL`,
+      [sessionId]
+    );
+    if (retrievals.length === 0)
+      return;
+    const sessionEvents = sqliteAll(
+      this.db,
+      `SELECT * FROM events WHERE session_id = ? ORDER BY timestamp ASC`,
+      [sessionId]
+    );
+    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;
+    for (const t of toolEvents) {
+      try {
+        const content = JSON.parse(t.content);
+        if (content.success !== false)
+          toolSuccessCount++;
+      } catch {
+        toolSuccessCount++;
+      }
+    }
+    const toolSuccessRatio = toolTotalCount > 0 ? toolSuccessCount / toolTotalCount : 0.5;
+    for (const retrieval of retrievals) {
+      const retrievalTime = retrieval.created_at;
+      const eventsAfter = sessionEvents.filter((e) => e.timestamp > retrievalTime);
+      const sessionContinued = eventsAfter.length > 0 ? 1 : 0;
+      const promptsAfter = promptEvents.filter((e) => e.timestamp > retrievalTime);
+      const promptCountAfter = promptsAfter.length;
+      const queryWords = new Set((retrieval.query_preview || "").toLowerCase().split(/\s+/).filter((w) => w.length > 2));
+      let wasReasked = 0;
+      for (const p of promptsAfter) {
+        const pWords = new Set(p.content.toLowerCase().split(/\s+/).filter((w) => w.length > 2));
+        let overlap = 0;
+        for (const w of queryWords) {
+          if (pWords.has(w))
+            overlap++;
+        }
+        if (queryWords.size > 0 && overlap / queryWords.size > 0.5) {
+          wasReasked = 1;
+          break;
+        }
+      }
+      const retrievalScore = retrieval.retrieval_score || 0;
+      const helpfulnessScore = 0.3 * Math.min(retrievalScore, 1) + 0.25 * (sessionContinued ? 1 : 0) + 0.25 * toolSuccessRatio + 0.2 * (wasReasked ? 0 : 1);
+      sqliteRun(
+        this.db,
+        `UPDATE memory_helpfulness
+         SET session_continued = ?, prompt_count_after = ?,
+             tool_success_count = ?, tool_total_count = ?,
+             was_reasked = ?, helpfulness_score = ?,
+             measured_at = datetime('now')
+         WHERE id = ?`,
+        [
+          sessionContinued,
+          promptCountAfter,
+          toolSuccessCount,
+          toolTotalCount,
+          wasReasked,
+          helpfulnessScore,
+          retrieval.id
+        ]
+      );
+    }
+  }
+  /**
+   * Get most helpful memories ranked by helpfulness score
+   */
+  async getHelpfulMemories(limit = 10) {
+    await this.initialize();
+    const rows = sqliteAll(
+      this.db,
+      `SELECT
+         mh.event_id,
+         AVG(mh.helpfulness_score) as avg_score,
+         COUNT(*) as eval_count,
+         e.content,
+         e.access_count
+       FROM memory_helpfulness mh
+       JOIN events e ON e.id = mh.event_id
+       WHERE mh.measured_at IS NOT NULL
+       GROUP BY mh.event_id
+       ORDER BY avg_score DESC
+       LIMIT ?`,
+      [limit]
+    );
+    return rows.map((r) => ({
+      eventId: r.event_id,
+      summary: r.content.substring(0, 200) + (r.content.length > 200 ? "..." : ""),
+      helpfulnessScore: Math.round(r.avg_score * 100) / 100,
+      accessCount: r.access_count || 0,
+      evaluationCount: r.eval_count
+    }));
+  }
+  /**
+   * Get helpfulness statistics for dashboard
+   */
+  async getHelpfulnessStats() {
+    await this.initialize();
+    const stats = sqliteGet(
+      this.db,
+      `SELECT
+         AVG(helpfulness_score) as avg_score,
+         COUNT(*) as total_evaluated,
+         SUM(CASE WHEN helpfulness_score >= 0.7 THEN 1 ELSE 0 END) as helpful,
+         SUM(CASE WHEN helpfulness_score >= 0.4 AND helpfulness_score < 0.7 THEN 1 ELSE 0 END) as neutral,
+         SUM(CASE WHEN helpfulness_score < 0.4 THEN 1 ELSE 0 END) as unhelpful
+       FROM memory_helpfulness
+       WHERE measured_at IS NOT NULL`
+    );
+    const totalRow = sqliteGet(
+      this.db,
+      `SELECT COUNT(*) as total FROM memory_helpfulness`
+    );
+    return {
+      avgScore: Math.round((stats?.avg_score || 0) * 100) / 100,
+      totalEvaluated: stats?.total_evaluated || 0,
+      totalRetrievals: totalRow?.total || 0,
+      helpful: stats?.helpful || 0,
+      neutral: stats?.neutral || 0,
+      unhelpful: stats?.unhelpful || 0
+    };
+  }
+  /**
+   * Fast keyword search using FTS5
+   * Returns events matching the search query, ranked by relevance
+   */
+  async keywordSearch(query, limit = 10) {
+    await this.initialize();
+    const searchTerms = query.replace(/['"(){}[\]^~*?:\\/-]/g, " ").split(/\s+/).filter((term) => term.length > 1).map((term) => `"${term}"*`).join(" OR ");
+    if (!searchTerms) {
+      return [];
+    }
+    try {
+      const rows = sqliteAll(
+        this.db,
+        `SELECT e.*, fts.rank
+         FROM events_fts fts
+         JOIN events e ON e.id = fts.event_id
+         WHERE events_fts MATCH ?
+         ORDER BY fts.rank
+         LIMIT ?`,
+        [searchTerms, limit]
+      );
+      return rows.map((row) => ({
+        event: this.rowToEvent(row),
+        rank: row.rank
+      }));
+    } catch (error) {
+      const likePattern = `%${query}%`;
+      const rows = sqliteAll(
+        this.db,
+        `SELECT *, 0 as rank FROM events
+         WHERE content LIKE ?
+         ORDER BY timestamp DESC
+         LIMIT ?`,
+        [likePattern, limit]
+      );
+      return rows.map((row) => ({
+        event: this.rowToEvent(row),
+        rank: 0
+      }));
+    }
+  }
+  /**
+   * 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;
+    sqliteExec(this.db, `
+      DELETE FROM events_fts;
+      INSERT INTO events_fts(rowid, content, event_id)
+      SELECT rowid, content, id FROM events;
+    `);
+    return totalEvents;
+  }
   /**
    * Get database instance for direct access
    */
@@ -1500,6 +1791,143 @@ var SQLiteEventStore = class {
   async close() {
     sqliteClose(this.db);
   }
+  /**
+   * Get events grouped by turn_id for a session
+   * Returns turns ordered by first event timestamp (newest first)
+   */
+  async getSessionTurns(sessionId, options) {
+    await this.initialize();
+    const limit = options?.limit || 20;
+    const offset = options?.offset || 0;
+    const turnRows = sqliteAll(
+      this.db,
+      `SELECT turn_id, MIN(timestamp) as min_ts
+       FROM events
+       WHERE session_id = ? AND turn_id IS NOT NULL
+       GROUP BY turn_id
+       ORDER BY min_ts DESC
+       LIMIT ? OFFSET ?`,
+      [sessionId, limit, offset]
+    );
+    const turns = [];
+    for (const turnRow of turnRows) {
+      const events = await this.getEventsByTurn(turnRow.turn_id);
+      const promptEvent = events.find((e) => e.eventType === "user_prompt");
+      const toolEvents = events.filter((e) => e.eventType === "tool_observation");
+      const hasResponse = events.some((e) => e.eventType === "agent_response");
+      turns.push({
+        turnId: turnRow.turn_id,
+        events,
+        startedAt: toDateFromSQLite(turnRow.min_ts),
+        promptPreview: promptEvent ? promptEvent.content.slice(0, 200) + (promptEvent.content.length > 200 ? "..." : "") : "(no prompt)",
+        eventCount: events.length,
+        toolCount: toolEvents.length,
+        hasResponse
+      });
+    }
+    return turns;
+  }
+  /**
+   * Get all events for a specific turn_id
+   */
+  async getEventsByTurn(turnId) {
+    await this.initialize();
+    const rows = sqliteAll(
+      this.db,
+      `SELECT * FROM events WHERE turn_id = ? ORDER BY timestamp ASC`,
+      [turnId]
+    );
+    return rows.map(this.rowToEvent);
+  }
+  /**
+   * Count total turns for a session
+   */
+  async countSessionTurns(sessionId) {
+    await this.initialize();
+    const row = sqliteGet(
+      this.db,
+      `SELECT COUNT(DISTINCT turn_id) as count
+       FROM events
+       WHERE session_id = ? AND turn_id IS NOT NULL`,
+      [sessionId]
+    );
+    return row?.count || 0;
+  }
+  /**
+   * Migrate existing events: backfill turn_id for events that have turnId in metadata
+   * but no turn_id column value (for events stored before this migration)
+   */
+  async backfillTurnIds() {
+    await this.initialize();
+    const rows = sqliteAll(
+      this.db,
+      `SELECT id, metadata FROM events
+       WHERE turn_id IS NULL AND metadata IS NOT NULL AND metadata LIKE '%turnId%'`
+    );
+    let updated = 0;
+    for (const row of rows) {
+      try {
+        const metadata = JSON.parse(row.metadata);
+        if (metadata.turnId) {
+          sqliteRun(
+            this.db,
+            `UPDATE events SET turn_id = ? WHERE id = ?`,
+            [metadata.turnId, row.id]
+          );
+          updated++;
+        }
+      } catch {
+      }
+    }
+    return updated;
+  }
+  /**
+   * Delete all events for a session (for force reimport)
+   */
+  async deleteSessionEvents(sessionId) {
+    await this.initialize();
+    const events = sqliteAll(
+      this.db,
+      `SELECT id FROM events WHERE session_id = ?`,
+      [sessionId]
+    );
+    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 {
+        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 {
+        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) VALUES (NEW.rowid, NEW.content);
+        END`);
+        sqliteRun(this.db, `CREATE TRIGGER IF NOT EXISTS events_fts_delete AFTER DELETE ON events BEGIN
+          INSERT INTO events_fts(events_fts, rowid, content) VALUES('delete', OLD.rowid, OLD.content);
+        END`);
+        sqliteRun(this.db, `CREATE TRIGGER IF NOT EXISTS events_fts_update AFTER UPDATE ON events BEGIN
+          INSERT INTO events_fts(events_fts, rowid, content) VALUES('delete', OLD.rowid, OLD.content);
+          INSERT INTO events_fts(rowid, content) VALUES (NEW.rowid, NEW.content);
+        END`);
+      } catch {
+      }
+    }
+    return result.changes || 0;
+  }
   /**
    * Convert database row to MemoryEvent
    */
@@ -1520,6 +1948,9 @@ var SQLiteEventStore = class {
     if (row.last_accessed_at !== void 0) {
       event.last_accessed_at = row.last_accessed_at;
     }
+    if (row.turn_id !== void 0 && row.turn_id !== null) {
+      event.turn_id = row.turn_id;
+    }
     return event;
   }
 };
@@ -1731,7 +2162,16 @@ var VectorStore = class {
       metadata: JSON.stringify(record.metadata || {})
     };
     if (!this.table) {
-      this.table = await this.db.createTable(this.tableName, [data]);
+      try {
+        this.table = await this.db.createTable(this.tableName, [data]);
+      } catch (e) {
+        if (e?.message?.includes("already exists")) {
+          this.table = await this.db.openTable(this.tableName);
+          await this.table.add([data]);
+        } else {
+          throw e;
+        }
+      }
     } else {
       await this.table.add([data]);
     }
@@ -1757,7 +2197,16 @@ var VectorStore = class {
       metadata: JSON.stringify(record.metadata || {})
     }));
     if (!this.table) {
-      this.table = await this.db.createTable(this.tableName, data);
+      try {
+        this.table = await this.db.createTable(this.tableName, data);
+      } catch (e) {
+        if (e?.message?.includes("already exists")) {
+          this.table = await this.db.openTable(this.tableName);
+          await this.table.add(data);
+        } else {
+          throw e;
+        }
+      }
     } else {
       await this.table.add(data);
     }
@@ -4503,7 +4952,7 @@ function createGraduationWorker(eventStore, graduation, config) {
 function normalizePath(projectPath) {
   const expanded = projectPath.startsWith("~") ? path.join(os.homedir(), projectPath.slice(1)) : projectPath;
   try {
-    return fs.realpathSync(expanded);
+    return fs2.realpathSync(expanded);
   } catch {
     return path.resolve(expanded);
   }
@@ -4518,6 +4967,17 @@ function getProjectStoragePath(projectPath) {
 }
 var REGISTRY_PATH = path.join(os.homedir(), ".claude-code", "memory", "session-registry.json");
 var SHARED_STORAGE_PATH = path.join(os.homedir(), ".claude-code", "memory", "shared");
+function loadSessionRegistry() {
+  try {
+    if (fs2.existsSync(REGISTRY_PATH)) {
+      const data = fs2.readFileSync(REGISTRY_PATH, "utf-8");
+      return JSON.parse(data);
+    }
+  } catch (error) {
+    console.error("Failed to load session registry:", error);
+  }
+  return { version: 1, sessions: {} };
+}
 var MemoryService = class {
   // Primary store: SQLite (WAL mode) - for hooks, always available
   sqliteStore;
@@ -4546,11 +5006,13 @@ var MemoryService = class {
   sharedStoreConfig = null;
   projectHash = null;
   readOnly;
+  lightweightMode;
   constructor(config) {
     const storagePath = this.expandPath(config.storagePath);
     this.readOnly = config.readOnly ?? false;
-    if (!this.readOnly && !fs.existsSync(storagePath)) {
-      fs.mkdirSync(storagePath, { recursive: true });
+    this.lightweightMode = config.lightweightMode ?? false;
+    if (!this.readOnly && !fs2.existsSync(storagePath)) {
+      fs2.mkdirSync(storagePath, { recursive: true });
     }
     this.projectHash = config.projectHash || null;
     this.sharedStoreConfig = config.sharedStoreConfig ?? { enabled: true };
@@ -4595,6 +5057,10 @@ var MemoryService = class {
     if (this.initialized)
       return;
     await this.sqliteStore.initialize();
+    if (this.lightweightMode) {
+      this.initialized = true;
+      return;
+    }
     if (this.analyticsStore) {
       try {
         await this.analyticsStore.initialize();
@@ -4641,8 +5107,8 @@ var MemoryService = class {
    */
   async initializeSharedStore() {
     const sharedPath = this.sharedStoreConfig?.sharedStoragePath ? this.expandPath(this.sharedStoreConfig.sharedStoragePath) : SHARED_STORAGE_PATH;
-    if (!fs.existsSync(sharedPath)) {
-      fs.mkdirSync(sharedPath, { recursive: true });
+    if (!fs2.existsSync(sharedPath)) {
+      fs2.mkdirSync(sharedPath, { recursive: true });
     }
     this.sharedEventStore = createSharedEventStore(
       path.join(sharedPath, "shared.duckdb")
@@ -4739,6 +5205,7 @@ var MemoryService = class {
   async storeToolObservation(sessionId, payload) {
     await this.initialize();
     const content = JSON.stringify(payload);
+    const turnId = payload.metadata?.turnId;
     const result = await this.sqliteStore.append({
       eventType: "tool_observation",
       sessionId,
@@ -4746,7 +5213,8 @@ var MemoryService = class {
       content,
       metadata: {
         toolName: payload.toolName,
-        success: payload.success
+        success: payload.success,
+        ...turnId ? { turnId } : {}
       }
     });
     if (result.success && !result.isDuplicate) {
@@ -4764,9 +5232,6 @@ var MemoryService = class {
    */
   async retrieveMemories(query, options) {
     await this.initialize();
-    if (this.vectorWorker) {
-      await this.vectorWorker.processAll();
-    }
     if (options?.includeShared && this.sharedStore) {
       return this.retriever.retrieveUnified(query, {
         ...options,
@@ -4776,6 +5241,29 @@ var MemoryService = class {
     }
     return this.retriever.retrieve(query, options);
   }
+  /**
+   * Fast keyword search using SQLite FTS5
+   * Much faster than vector search - no embedding model needed
+   */
+  async keywordSearch(query, options) {
+    await this.initialize();
+    const results = await this.sqliteStore.keywordSearch(query, options?.topK ?? 10);
+    const maxRank = Math.min(...results.map((r) => r.rank), -1e-3);
+    const minRank = Math.max(...results.map((r) => r.rank), -1e3);
+    const rankRange = maxRank - minRank || 1;
+    return results.map((r) => ({
+      event: r.event,
+      score: 1 - (r.rank - minRank) / rankRange
+      // Normalize to 0-1
+    })).filter((r) => !options?.minScore || r.score >= options.minScore);
+  }
+  /**
+   * Rebuild FTS index (call after database upgrade)
+   */
+  async rebuildFtsIndex() {
+    await this.initialize();
+    return this.sqliteStore.rebuildFtsIndex();
+  }
   /**
    * Get session history
    */
@@ -5009,6 +5497,31 @@ var MemoryService = class {
       return [];
     return this.consolidatedStore.getAll({ limit });
   }
+  /**
+   * Extract topic keywords from event content (markdown headings and key terms)
+   */
+  extractTopicsFromContent(content) {
+    const topics = /* @__PURE__ */ new Set();
+    const headings = content.match(/^#{1,3}\s+(.+)$/gm);
+    if (headings) {
+      for (const h of headings.slice(0, 5)) {
+        const text = h.replace(/^#+\s+/, "").replace(/[*_`#]/g, "").trim();
+        if (text.length > 2 && text.length < 50) {
+          topics.add(text);
+        }
+      }
+    }
+    const boldTerms = content.match(/\*\*([^*]+)\*\*/g);
+    if (boldTerms) {
+      for (const b of boldTerms.slice(0, 5)) {
+        const text = b.replace(/\*\*/g, "").trim();
+        if (text.length > 2 && text.length < 30) {
+          topics.add(text);
+        }
+      }
+    }
+    return Array.from(topics).slice(0, 5);
+  }
   /**
    * Increment access count for memories that were used in prompts
    */
@@ -5032,8 +5545,7 @@ var MemoryService = class {
       return events.map((event) => ({
         memoryId: event.id,
         summary: event.content.substring(0, 200) + (event.content.length > 200 ? "..." : ""),
-        topics: [],
-        // Could extract topics from content if needed
+        topics: this.extractTopicsFromContent(event.content),
         accessCount: event.access_count || 0,
         lastAccessed: event.last_accessed_at || null,
         confidence: 1,
@@ -5054,6 +5566,34 @@ var MemoryService = class {
     }
     return [];
   }
+  /**
+   * Record a memory retrieval for helpfulness tracking
+   */
+  async recordRetrieval(eventId, sessionId, score, query) {
+    await this.initialize();
+    await this.sqliteStore.recordRetrieval(eventId, sessionId, score, query);
+  }
+  /**
+   * Evaluate helpfulness of retrievals in a session (called at session end)
+   */
+  async evaluateSessionHelpfulness(sessionId) {
+    await this.initialize();
+    await this.sqliteStore.evaluateSessionHelpfulness(sessionId);
+  }
+  /**
+   * Get most helpful memories ranked by helpfulness score
+   */
+  async getHelpfulMemories(limit = 10) {
+    await this.initialize();
+    return this.sqliteStore.getHelpfulMemories(limit);
+  }
+  /**
+   * Get helpfulness statistics for dashboard
+   */
+  async getHelpfulnessStats() {
+    await this.initialize();
+    return this.sqliteStore.getHelpfulnessStats();
+  }
   /**
    * Mark a consolidated memory as accessed
    */
@@ -5117,6 +5657,44 @@ var MemoryService = class {
       lastConsolidation
     };
   }
+  // ============================================================
+  // Turn Grouping Methods
+  // ============================================================
+  /**
+   * Get events grouped by turn for a session
+   */
+  async getSessionTurns(sessionId, options) {
+    await this.initialize();
+    return this.sqliteStore.getSessionTurns(sessionId, options);
+  }
+  /**
+   * Get all events for a specific turn
+   */
+  async getEventsByTurn(turnId) {
+    await this.initialize();
+    return this.sqliteStore.getEventsByTurn(turnId);
+  }
+  /**
+   * Count total turns for a session
+   */
+  async countSessionTurns(sessionId) {
+    await this.initialize();
+    return this.sqliteStore.countSessionTurns(sessionId);
+  }
+  /**
+   * Backfill turn_ids from metadata for events stored before the migration
+   */
+  async backfillTurnIds() {
+    await this.initialize();
+    return this.sqliteStore.backfillTurnIds();
+  }
+  /**
+   * Delete all events for a session (for force reimport)
+   */
+  async deleteSessionEvents(sessionId) {
+    await this.initialize();
+    return this.sqliteStore.deleteSessionEvents(sessionId);
+  }
   /**
    * Format Endless Mode context for Claude
    */
@@ -5225,12 +5803,36 @@ function getMemoryServiceForProject(projectPath, sharedStoreConfig) {
   return serviceCache.get(hash);
 }
 
+// src/server/api/utils.ts
+function getServiceFromQuery(c) {
+  const project = c.req.query("project");
+  if (project) {
+    const isHash = /^[a-f0-9]{8}$/.test(project);
+    let storagePath;
+    if (isHash) {
+      storagePath = path2.join(os2.homedir(), ".claude-code", "memory", "projects", project);
+    } else {
+      const crypto3 = __require("crypto");
+      const normalized = project.replace(/\/+$/, "") || "/";
+      const hash = crypto3.createHash("sha256").update(normalized).digest("hex").slice(0, 8);
+      storagePath = path2.join(os2.homedir(), ".claude-code", "memory", "projects", hash);
+    }
+    return new MemoryService({
+      storagePath,
+      readOnly: true,
+      analyticsEnabled: false,
+      sharedStoreConfig: { enabled: false }
+    });
+  }
+  return getReadOnlyMemoryService();
+}
+
 // src/server/api/sessions.ts
 var sessionsRouter = new Hono();
 sessionsRouter.get("/", async (c) => {
   const page = parseInt(c.req.query("page") || "1", 10);
   const pageSize = parseInt(c.req.query("pageSize") || "20", 10);
-  const memoryService = getReadOnlyMemoryService();
+  const memoryService = getServiceFromQuery(c);
   try {
     await memoryService.initialize();
     const recentEvents = await memoryService.getRecentEvents(1e3);
@@ -5274,7 +5876,7 @@ sessionsRouter.get("/", async (c) => {
 });
 sessionsRouter.get("/:id", async (c) => {
   const { id } = c.req.param();
-  const memoryService = getReadOnlyMemoryService();
+  const memoryService = getServiceFromQuery(c);
   try {
     await memoryService.initialize();
     const events = await memoryService.getSessionHistory(id);
@@ -5315,18 +5917,36 @@ var eventsRouter = new Hono2();
 eventsRouter.get("/", async (c) => {
   const sessionId = c.req.query("sessionId");
   const eventType = c.req.query("type");
+  const level = c.req.query("level");
+  const sort = c.req.query("sort") || "recent";
   const limit = parseInt(c.req.query("limit") || "100", 10);
   const offset = parseInt(c.req.query("offset") || "0", 10);
-  const memoryService = getReadOnlyMemoryService();
+  const memoryService = getServiceFromQuery(c);
   try {
     await memoryService.initialize();
-    let events = await memoryService.getRecentEvents(limit + offset + 1e3);
+    let events;
+    if (level) {
+      events = await memoryService.getEventsByLevel(level, { limit: limit + offset + 1e3, offset: 0 });
+    } else {
+      events = await memoryService.getRecentEvents(limit + offset + 1e3);
+    }
     if (sessionId) {
       events = events.filter((e) => e.sessionId === sessionId);
     }
     if (eventType) {
       events = events.filter((e) => e.eventType === eventType);
     }
+    if (sort === "accessed") {
+      events.sort((a, b) => {
+        const aTime = a.last_accessed_at || "";
+        const bTime = b.last_accessed_at || "";
+        return bTime.localeCompare(aTime);
+      });
+    } else if (sort === "most-accessed") {
+      events.sort((a, b) => (b.access_count || 0) - (a.access_count || 0));
+    } else if (sort === "oldest") {
+      events.sort((a, b) => new Date(a.timestamp).getTime() - new Date(b.timestamp).getTime());
+    }
     const total = events.length;
     events = events.slice(offset, offset + limit);
     return c.json({
@@ -5336,7 +5956,9 @@ eventsRouter.get("/", async (c) => {
         timestamp: e.timestamp,
         sessionId: e.sessionId,
         preview: e.content.slice(0, 200) + (e.content.length > 200 ? "..." : ""),
-        contentLength: e.content.length
+        contentLength: e.content.length,
+        accessCount: e.access_count || 0,
+        lastAccessedAt: e.last_accessed_at || null
       })),
       total,
       limit,
@@ -5351,7 +5973,7 @@ eventsRouter.get("/", async (c) => {
 });
 eventsRouter.get("/:id", async (c) => {
   const { id } = c.req.param();
-  const memoryService = getReadOnlyMemoryService();
+  const memoryService = getServiceFromQuery(c);
   try {
     await memoryService.initialize();
     const recentEvents = await memoryService.getRecentEvents(1e4);
@@ -5391,7 +6013,7 @@ eventsRouter.get("/:id", async (c) => {
 import { Hono as Hono3 } from "hono";
 var searchRouter = new Hono3();
 searchRouter.post("/", async (c) => {
-  const memoryService = getReadOnlyMemoryService();
+  const memoryService = getServiceFromQuery(c);
   try {
     const body = await c.req.json();
     if (!body.query) {
@@ -5435,7 +6057,7 @@ searchRouter.get("/", async (c) => {
     return c.json({ error: 'Query parameter "q" is required' }, 400);
   }
   const topK = parseInt(c.req.query("topK") || "5", 10);
-  const memoryService = getReadOnlyMemoryService();
+  const memoryService = getServiceFromQuery(c);
   try {
     await memoryService.initialize();
     const result = await memoryService.retrieveMemories(query, { topK });
@@ -5463,7 +6085,7 @@ searchRouter.get("/", async (c) => {
 import { Hono as Hono4 } from "hono";
 var statsRouter = new Hono4();
 statsRouter.get("/shared", async (c) => {
-  const memoryService = getReadOnlyMemoryService();
+  const memoryService = getServiceFromQuery(c);
   try {
     await memoryService.initialize();
     const sharedStats = await memoryService.getSharedStoreStats();
@@ -5520,7 +6142,7 @@ statsRouter.get("/levels/:level", async (c) => {
   if (!validLevels.includes(level)) {
     return c.json({ error: `Invalid level. Must be one of: ${validLevels.join(", ")}` }, 400);
   }
-  const memoryService = getReadOnlyMemoryService();
+  const memoryService = getServiceFromQuery(c);
   try {
     await memoryService.initialize();
     let events = await memoryService.getEventsByLevel(level, { limit: limit * 2, offset });
@@ -5567,7 +6189,7 @@ statsRouter.get("/levels/:level", async (c) => {
   }
 });
 statsRouter.get("/", async (c) => {
-  const memoryService = getReadOnlyMemoryService();
+  const memoryService = getServiceFromQuery(c);
   try {
     await memoryService.initialize();
     const stats = await memoryService.getStats();
@@ -5611,7 +6233,7 @@ statsRouter.get("/", async (c) => {
 });
 statsRouter.get("/most-accessed", async (c) => {
   const limit = parseInt(c.req.query("limit") || "10", 10);
-  const memoryService = getReadOnlyMemoryService();
+  const memoryService = getServiceFromQuery(c);
   try {
     await memoryService.initialize();
     console.log("[most-accessed] Fetching most accessed memories, limit:", limit);
@@ -5642,7 +6264,7 @@ statsRouter.get("/most-accessed", async (c) => {
 });
 statsRouter.get("/timeline", async (c) => {
   const days = parseInt(c.req.query("days") || "7", 10);
-  const memoryService = getReadOnlyMemoryService();
+  const memoryService = getServiceFromQuery(c);
   try {
     await memoryService.initialize();
     const recentEvents = await memoryService.getRecentEvents(1e4);
@@ -5672,8 +6294,39 @@ statsRouter.get("/timeline", async (c) => {
     await memoryService.shutdown();
   }
 });
+statsRouter.get("/helpfulness", async (c) => {
+  const limit = parseInt(c.req.query("limit") || "10", 10);
+  const memoryService = getServiceFromQuery(c);
+  try {
+    await memoryService.initialize();
+    const stats = await memoryService.getHelpfulnessStats();
+    const topMemories = await memoryService.getHelpfulMemories(limit);
+    return c.json({
+      ...stats,
+      topMemories: topMemories.map((m) => ({
+        eventId: m.eventId,
+        summary: m.summary,
+        helpfulnessScore: m.helpfulnessScore,
+        accessCount: m.accessCount,
+        evaluationCount: m.evaluationCount
+      }))
+    });
+  } catch (error) {
+    return c.json({
+      avgScore: 0,
+      totalEvaluated: 0,
+      totalRetrievals: 0,
+      helpful: 0,
+      neutral: 0,
+      unhelpful: 0,
+      topMemories: []
+    });
+  } finally {
+    await memoryService.shutdown();
+  }
+});
 statsRouter.post("/graduation/run", async (c) => {
-  const memoryService = getReadOnlyMemoryService();
+  const memoryService = getServiceFromQuery(c);
   try {
     await memoryService.initialize();
     const result = await memoryService.forceGraduation();
@@ -5734,7 +6387,7 @@ var citationsRouter = new Hono5();
 citationsRouter.get("/:id", async (c) => {
   const { id } = c.req.param();
   const citationId = parseCitationId(id) || id;
-  const memoryService = getReadOnlyMemoryService();
+  const memoryService = getServiceFromQuery(c);
   try {
     await memoryService.initialize();
     const recentEvents = await memoryService.getRecentEvents(1e4);
@@ -5768,7 +6421,7 @@ citationsRouter.get("/:id", async (c) => {
 citationsRouter.get("/:id/related", async (c) => {
   const { id } = c.req.param();
   const citationId = parseCitationId(id) || id;
-  const memoryService = getReadOnlyMemoryService();
+  const memoryService = getServiceFromQuery(c);
   try {
     await memoryService.initialize();
     const recentEvents = await memoryService.getRecentEvents(1e4);
@@ -5804,23 +6457,373 @@ citationsRouter.get("/:id/related", async (c) => {
   }
 });
 
+// src/server/api/turns.ts
+import { Hono as Hono6 } from "hono";
+var turnsRouter = new Hono6();
+turnsRouter.get("/", async (c) => {
+  const sessionId = c.req.query("sessionId");
+  const limit = parseInt(c.req.query("limit") || "20", 10);
+  const offset = parseInt(c.req.query("offset") || "0", 10);
+  if (!sessionId) {
+    return c.json({ error: "sessionId is required" }, 400);
+  }
+  const memoryService = getServiceFromQuery(c);
+  try {
+    await memoryService.initialize();
+    const turns = await memoryService.getSessionTurns(sessionId, { limit, offset });
+    const totalTurns = await memoryService.countSessionTurns(sessionId);
+    return c.json({
+      turns: turns.map((t) => ({
+        turnId: t.turnId,
+        startedAt: t.startedAt.toISOString(),
+        promptPreview: t.promptPreview,
+        eventCount: t.eventCount,
+        toolCount: t.toolCount,
+        hasResponse: t.hasResponse,
+        events: t.events.map((e) => ({
+          id: e.id,
+          eventType: e.eventType,
+          timestamp: e.timestamp instanceof Date ? e.timestamp.toISOString() : e.timestamp,
+          preview: e.content.slice(0, 300) + (e.content.length > 300 ? "..." : ""),
+          contentLength: e.content.length
+        }))
+      })),
+      total: totalTurns,
+      limit,
+      offset,
+      hasMore: offset + limit < totalTurns
+    });
+  } catch (error) {
+    return c.json({ error: error.message }, 500);
+  } finally {
+    await memoryService.shutdown();
+  }
+});
+turnsRouter.get("/:turnId", async (c) => {
+  const { turnId } = c.req.param();
+  const memoryService = getServiceFromQuery(c);
+  try {
+    await memoryService.initialize();
+    const events = await memoryService.getEventsByTurn(turnId);
+    if (events.length === 0) {
+      return c.json({ error: "Turn not found" }, 404);
+    }
+    const promptEvent = events.find((e) => e.eventType === "user_prompt");
+    const toolEvents = events.filter((e) => e.eventType === "tool_observation");
+    const responseEvents = events.filter((e) => e.eventType === "agent_response");
+    return c.json({
+      turnId,
+      sessionId: events[0].sessionId,
+      startedAt: events[0].timestamp instanceof Date ? events[0].timestamp.toISOString() : events[0].timestamp,
+      prompt: promptEvent ? {
+        id: promptEvent.id,
+        content: promptEvent.content,
+        timestamp: promptEvent.timestamp instanceof Date ? promptEvent.timestamp.toISOString() : promptEvent.timestamp
+      } : null,
+      tools: toolEvents.map((e) => {
+        let toolName = "";
+        let success = true;
+        try {
+          const parsed = JSON.parse(e.content);
+          toolName = parsed.toolName || "";
+          success = parsed.success !== false;
+        } catch {
+        }
+        return {
+          id: e.id,
+          toolName,
+          success,
+          timestamp: e.timestamp instanceof Date ? e.timestamp.toISOString() : e.timestamp,
+          preview: e.content.slice(0, 500) + (e.content.length > 500 ? "..." : "")
+        };
+      }),
+      responses: responseEvents.map((e) => ({
+        id: e.id,
+        content: e.content,
+        timestamp: e.timestamp instanceof Date ? e.timestamp.toISOString() : e.timestamp
+      })),
+      totalEvents: events.length
+    });
+  } catch (error) {
+    return c.json({ error: error.message }, 500);
+  } finally {
+    await memoryService.shutdown();
+  }
+});
+turnsRouter.post("/backfill", async (c) => {
+  const memoryService = getServiceFromQuery(c);
+  try {
+    await memoryService.initialize();
+    const updated = await memoryService.backfillTurnIds();
+    return c.json({
+      success: true,
+      updated,
+      message: `Backfilled turn_id for ${updated} events`
+    });
+  } catch (error) {
+    return c.json({
+      success: false,
+      error: error.message
+    }, 500);
+  } finally {
+    await memoryService.shutdown();
+  }
+});
+
+// src/server/api/projects.ts
+import { Hono as Hono7 } from "hono";
+import * as fs3 from "fs";
+import * as path3 from "path";
+import * as os3 from "os";
+var projectsRouter = new Hono7();
+projectsRouter.get("/", async (c) => {
+  try {
+    const projectsDir = path3.join(os3.homedir(), ".claude-code", "memory", "projects");
+    if (!fs3.existsSync(projectsDir)) {
+      return c.json({ projects: [] });
+    }
+    const projectHashes = fs3.readdirSync(projectsDir).filter((name) => {
+      const fullPath = path3.join(projectsDir, name);
+      return fs3.statSync(fullPath).isDirectory();
+    });
+    const registry = loadSessionRegistry();
+    const hashToPath = /* @__PURE__ */ new Map();
+    for (const entry of Object.values(registry.sessions)) {
+      if (!hashToPath.has(entry.projectHash)) {
+        hashToPath.set(entry.projectHash, entry.projectPath);
+      }
+    }
+    const projects = projectHashes.map((hash) => {
+      const dirPath = path3.join(projectsDir, hash);
+      const dbPath = path3.join(dirPath, "events.sqlite");
+      let dbSize = 0;
+      if (fs3.existsSync(dbPath)) {
+        dbSize = fs3.statSync(dbPath).size;
+      }
+      const projectPath = hashToPath.get(hash) || `unknown (${hash})`;
+      return {
+        hash,
+        projectPath,
+        projectName: path3.basename(projectPath),
+        dbSize,
+        dbSizeHuman: formatBytes(dbSize)
+      };
+    });
+    projects.sort((a, b) => a.projectName.localeCompare(b.projectName));
+    return c.json({ projects });
+  } catch (error) {
+    return c.json({ projects: [], error: error.message }, 500);
+  }
+});
+function formatBytes(bytes) {
+  if (bytes === 0)
+    return "0 B";
+  const k = 1024;
+  const sizes = ["B", "KB", "MB", "GB"];
+  const i = Math.floor(Math.log(bytes) / Math.log(k));
+  return parseFloat((bytes / Math.pow(k, i)).toFixed(1)) + " " + sizes[i];
+}
+
+// src/server/api/chat.ts
+import { Hono as Hono8 } from "hono";
+import { streamSSE } from "hono/streaming";
+import { spawn } from "child_process";
+var chatRouter = new Hono8();
+var CLAUDE_TIMEOUT_MS = 12e4;
+chatRouter.post("/", async (c) => {
+  let body;
+  try {
+    body = await c.req.json();
+  } catch {
+    return c.json({ error: "Invalid JSON body" }, 400);
+  }
+  if (!body.message?.trim()) {
+    return c.json({ error: "Message is required" }, 400);
+  }
+  const memoryService = getServiceFromQuery(c);
+  try {
+    await memoryService.initialize();
+    let memoryContext = "";
+    let statsContext = "";
+    try {
+      const result = await memoryService.retrieveMemories(body.message, {
+        topK: 8,
+        minScore: 0.5
+      });
+      if (result.memories.length > 0) {
+        const parts = ["## Relevant Memories\n"];
+        for (const m of result.memories) {
+          const date = new Date(m.event.timestamp).toISOString().split("T")[0];
+          const content = m.event.content.slice(0, 500);
+          parts.push(`### [${m.event.eventType}] ${date} (score: ${m.score.toFixed(2)})`);
+          parts.push(content);
+          if (m.sessionContext) {
+            parts.push(`_Context: ${m.sessionContext}_`);
+          }
+          parts.push("");
+        }
+        memoryContext = parts.join("\n");
+      }
+    } catch {
+    }
+    try {
+      const stats = await memoryService.getStats();
+      const levels = stats.levelStats.map((l) => `${l.level}: ${l.count}`).join(", ");
+      statsContext = [
+        "## Memory Stats",
+        `- Total events: ${stats.totalEvents}`,
+        `- Vector nodes: ${stats.vectorCount}`,
+        `- By level: ${levels}`
+      ].join("\n");
+    } catch {
+    }
+    const fullPrompt = buildPrompt(
+      statsContext,
+      memoryContext,
+      body.history || [],
+      body.message
+    );
+    return streamSSE(c, async (stream) => {
+      try {
+        await streamClaudeResponse(fullPrompt, stream);
+      } catch (err) {
+        await stream.writeSSE({
+          event: "error",
+          data: JSON.stringify({ error: err.message })
+        });
+      }
+    });
+  } catch (error) {
+    return c.json({ error: error.message }, 500);
+  } finally {
+    await memoryService.shutdown();
+  }
+});
+function buildPrompt(statsContext, memoryContext, history, currentMessage) {
+  const parts = [];
+  parts.push("You are a helpful assistant that answers questions about the user's code memory data.");
+  parts.push("The memory system tracks coding sessions, tool usage, prompts, and responses.");
+  parts.push("Answer concisely based on the memory context below. If you don't have enough data, say so.");
+  parts.push("Use markdown formatting in your responses.\n");
+  if (statsContext) {
+    parts.push(statsContext);
+    parts.push("");
+  }
+  if (memoryContext) {
+    parts.push(memoryContext);
+  } else {
+    parts.push("No directly relevant memories found for this query.");
+    parts.push("Answer based on general knowledge or suggest the user rephrase.\n");
+  }
+  parts.push("---\n");
+  const recentHistory = history.slice(-10);
+  if (recentHistory.length > 0) {
+    parts.push("## Conversation History\n");
+    for (const msg of recentHistory) {
+      const prefix = msg.role === "user" ? "User" : "Assistant";
+      parts.push(`**${prefix}:** ${msg.content}
+`);
+    }
+  }
+  parts.push(`**User:** ${currentMessage}`);
+  return parts.join("\n");
+}
+function streamClaudeResponse(prompt, stream) {
+  return new Promise((resolve2, reject) => {
+    const proc = spawn("claude", [
+      "-p",
+      "--output-format",
+      "stream-json",
+      "--verbose"
+    ], {
+      stdio: ["pipe", "pipe", "pipe"],
+      env: { ...process.env }
+    });
+    const timeout = setTimeout(() => {
+      proc.kill("SIGTERM");
+      reject(new Error("Chat response timed out after 2 minutes"));
+    }, CLAUDE_TIMEOUT_MS);
+    proc.stdin.write(prompt);
+    proc.stdin.end();
+    let buffer = "";
+    let lastSentText = "";
+    proc.stdout.on("data", async (chunk) => {
+      buffer += chunk.toString();
+      const lines = buffer.split("\n");
+      buffer = lines.pop() || "";
+      for (const line of lines) {
+        if (!line.trim())
+          continue;
+        try {
+          const parsed = JSON.parse(line);
+          if (parsed.type === "assistant" && parsed.message?.content) {
+            const textBlocks = parsed.message.content.filter((b) => b.type === "text").map((b) => b.text).join("");
+            if (textBlocks.length > lastSentText.length) {
+              const delta = textBlocks.slice(lastSentText.length);
+              lastSentText = textBlocks;
+              await stream.writeSSE({
+                event: "message",
+                data: JSON.stringify({ content: delta })
+              });
+            }
+          }
+          if (parsed.type === "result") {
+            await stream.writeSSE({ event: "done", data: "{}" });
+          }
+        } catch {
+        }
+      }
+    });
+    proc.stderr.on("data", (chunk) => {
+      if (process.env.CLAUDE_MEMORY_DEBUG) {
+        console.error("[chat] claude stderr:", chunk.toString());
+      }
+    });
+    proc.on("error", (err) => {
+      clearTimeout(timeout);
+      if (err.code === "ENOENT") {
+        reject(new Error("Claude CLI not found. Install with: npm install -g @anthropic-ai/claude-code"));
+      } else {
+        reject(err);
+      }
+    });
+    proc.on("close", async (code) => {
+      clearTimeout(timeout);
+      if (buffer.trim()) {
+        try {
+          const parsed = JSON.parse(buffer);
+          if (parsed.type === "result") {
+            await stream.writeSSE({ event: "done", data: "{}" });
+          }
+        } catch {
+        }
+      }
+      if (code !== 0 && code !== null) {
+        reject(new Error(`Claude CLI exited with code ${code}`));
+      } else {
+        resolve2();
+      }
+    });
+  });
+}
+
 // src/server/api/index.ts
-var apiRouter = new Hono6().route("/sessions", sessionsRouter).route("/events", eventsRouter).route("/search", searchRouter).route("/stats", statsRouter).route("/citations", citationsRouter);
+var apiRouter = new Hono9().route("/sessions", sessionsRouter).route("/events", eventsRouter).route("/search", searchRouter).route("/stats", statsRouter).route("/citations", citationsRouter).route("/turns", turnsRouter).route("/projects", projectsRouter).route("/chat", chatRouter);
 
 // src/server/index.ts
-var app = new Hono7();
+var app = new Hono10();
 app.use("/*", cors());
 app.use("/*", logger());
 app.route("/api", apiRouter);
 app.get("/health", (c) => c.json({ status: "ok", timestamp: (/* @__PURE__ */ new Date()).toISOString() }));
-var uiPath = path2.join(__dirname, "../../dist/ui");
-if (fs2.existsSync(uiPath)) {
+var uiPath = path4.join(__dirname, "../../dist/ui");
+if (fs4.existsSync(uiPath)) {
   app.use("/*", serveStatic({ root: uiPath }));
 }
 app.get("*", (c) => {
-  const indexPath = path2.join(uiPath, "index.html");
-  if (fs2.existsSync(indexPath)) {
-    return c.html(fs2.readFileSync(indexPath, "utf-8"));
+  const indexPath = path4.join(uiPath, "index.html");
+  if (fs4.existsSync(indexPath)) {
+    return c.html(fs4.readFileSync(indexPath, "utf-8"));
   }
   return c.text('UI not built. Run "npm run build:ui" first.', 404);
 });