claude-memory-layer 1.0.9 → 1.0.11

package/dist/cli/index.js

@@ -5,18 +5,25 @@ 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/cli/index.ts
 import { Command } from "commander";
 import { exec } from "child_process";
-import * as fs4 from "fs";
-import * as path4 from "path";
-import * as os3 from "os";
+import * as fs6 from "fs";
+import * as path6 from "path";
+import * as os5 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
@@ -74,11 +81,11 @@ function toDate(value) {
     return new Date(value);
   return new Date(String(value));
 }
-function createDatabase(path5, options) {
+function createDatabase(path7, options) {
   if (options?.readOnly) {
-    return new duckdb.Database(path5, { access_mode: "READ_ONLY" });
+    return new duckdb.Database(path7, { access_mode: "READ_ONLY" });
   }
-  return new duckdb.Database(path5);
+  return new duckdb.Database(path7);
 }
 function dbRun(db, sql, params = []) {
   return new Promise((resolve2, reject) => {
@@ -748,8 +755,14 @@ import { randomUUID as randomUUID2 } from "crypto";
 
 // src/core/sqlite-wrapper.ts
 import Database from "better-sqlite3";
-function createSQLiteDatabase(path5, options) {
-  const db = new Database(path5, {
+import * as fs from "fs";
+import * as nodePath from "path";
+function createSQLiteDatabase(path7, options) {
+  const dir = nodePath.dirname(path7);
+  if (!fs.existsSync(dir)) {
+    fs.mkdirSync(dir, { recursive: true });
+  }
+  const db = new Database(path7, {
     readonly: options?.readonly ?? false
   });
   if (!options?.readonly && (options?.walMode ?? true)) {
@@ -1016,6 +1029,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,
@@ -1041,6 +1071,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);
@@ -1062,6 +1117,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);
@@ -1074,6 +1138,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;
   }
   /**
@@ -1098,9 +1168,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 (?, ?)
@@ -1117,7 +1189,8 @@ var SQLiteEventStore = class {
           input.content,
           canonicalKey,
           dedupeKey,
-          JSON.stringify(input.metadata || {})
+          JSON.stringify(metadata),
+          turnId
         );
         insertDedup.run(dedupeKey, id);
         insertLevel.run(id);
@@ -1467,11 +1540,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
@@ -1479,8 +1552,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
    */
@@ -1493,6 +1780,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
    */
@@ -1513,6 +1937,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;
   }
 };
@@ -1724,7 +2151,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]);
     }
@@ -1750,7 +2186,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);
     }
@@ -4496,7 +4941,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);
   }
@@ -4511,6 +4956,42 @@ 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: {} };
+}
+function saveSessionRegistry(registry) {
+  const dir = path.dirname(REGISTRY_PATH);
+  if (!fs2.existsSync(dir)) {
+    fs2.mkdirSync(dir, { recursive: true });
+  }
+  const tempPath = REGISTRY_PATH + ".tmp";
+  fs2.writeFileSync(tempPath, JSON.stringify(registry, null, 2));
+  fs2.renameSync(tempPath, REGISTRY_PATH);
+}
+function registerSession(sessionId, projectPath) {
+  const registry = loadSessionRegistry();
+  registry.sessions[sessionId] = {
+    projectPath: normalizePath(projectPath),
+    projectHash: hashProjectPath(projectPath),
+    registeredAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  const entries = Object.entries(registry.sessions);
+  if (entries.length > 1e3) {
+    const sorted = entries.sort(
+      (a, b) => new Date(b[1].registeredAt).getTime() - new Date(a[1].registeredAt).getTime()
+    );
+    registry.sessions = Object.fromEntries(sorted.slice(0, 1e3));
+  }
+  saveSessionRegistry(registry);
+}
 var MemoryService = class {
   // Primary store: SQLite (WAL mode) - for hooks, always available
   sqliteStore;
@@ -4539,11 +5020,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 };
@@ -4588,6 +5071,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();
@@ -4634,8 +5121,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")
@@ -4732,6 +5219,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,
@@ -4739,7 +5227,8 @@ var MemoryService = class {
       content,
       metadata: {
         toolName: payload.toolName,
-        success: payload.success
+        success: payload.success,
+        ...turnId ? { turnId } : {}
       }
     });
     if (result.success && !result.isDuplicate) {
@@ -4757,9 +5246,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,
@@ -4769,6 +5255,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
    */
@@ -5002,6 +5511,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
    */
@@ -5025,8 +5559,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,
@@ -5047,6 +5580,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
    */
@@ -5110,6 +5671,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
    */
@@ -5232,10 +5831,46 @@ function getMemoryServiceForProject(projectPath, sharedStoreConfig) {
 }
 
 // src/services/session-history-importer.ts
-import * as fs2 from "fs";
+import * as fs3 from "fs";
 import * as path2 from "path";
 import * as os2 from "os";
 import * as readline from "readline";
+import { randomUUID as randomUUID9 } from "crypto";
+function classifyEntry(entry) {
+  if (entry.type !== "user" && entry.type !== "assistant") {
+    return "skip";
+  }
+  const content = entry.message?.content;
+  if (!content)
+    return "skip";
+  if (entry.type === "user") {
+    if (typeof content === "string")
+      return "user_prompt";
+    if (Array.isArray(content)) {
+      const hasToolResult = content.some((b) => b.type === "tool_result");
+      if (hasToolResult)
+        return "tool_result";
+      const hasText = content.some((b) => b.type === "text" && b.text);
+      if (hasText)
+        return "user_prompt";
+    }
+    return "skip";
+  }
+  if (Array.isArray(content)) {
+    const hasToolUse = content.some((b) => b.type === "tool_use");
+    if (hasToolUse)
+      return "tool_use";
+    const hasText = content.some((b) => b.type === "text" && b.text);
+    if (hasText)
+      return "agent_text";
+    const hasThinking = content.some((b) => b.type === "thinking");
+    if (hasThinking)
+      return "thinking";
+  } else if (typeof content === "string" && content.length > 0) {
+    return "agent_text";
+  }
+  return "skip";
+}
 var SessionHistoryImporter = class {
   memoryService;
   claudeDir;
@@ -5255,6 +5890,8 @@ var SessionHistoryImporter = class {
       skippedDuplicates: 0,
       errors: []
     };
+    const onProgress = options.onProgress;
+    onProgress?.({ phase: "scan", message: "Scanning for session files..." });
     const projectDir = await this.findProjectDir(projectPath);
     if (!projectDir) {
       result.errors.push(`Project directory not found for: ${projectPath}`);
@@ -5262,16 +5899,29 @@ var SessionHistoryImporter = class {
     }
     const sessionFiles = await this.findSessionFiles(projectDir);
     result.totalSessions = sessionFiles.length;
+    onProgress?.({ phase: "scan", message: `Found ${sessionFiles.length} sessions in ${path2.basename(projectDir)}` });
     if (options.verbose) {
       console.log(`Found ${sessionFiles.length} session files in ${projectDir}`);
     }
-    for (const sessionFile of sessionFiles) {
+    for (let i = 0; i < sessionFiles.length; i++) {
+      const sessionFile = sessionFiles[i];
       try {
-        const sessionResult = await this.importSessionFile(sessionFile, options);
+        onProgress?.({ phase: "session-start", sessionIndex: i, totalSessions: sessionFiles.length, filePath: sessionFile });
+        const sessionResult = await this.importSessionFile(sessionFile, {
+          ...options,
+          _sessionIndex: i
+        });
         result.totalMessages += sessionResult.totalMessages;
         result.importedPrompts += sessionResult.importedPrompts;
         result.importedResponses += sessionResult.importedResponses;
         result.skippedDuplicates += sessionResult.skippedDuplicates;
+        onProgress?.({
+          phase: "session-done",
+          sessionIndex: i,
+          importedPrompts: sessionResult.importedPrompts,
+          importedResponses: sessionResult.importedResponses,
+          skipped: sessionResult.skippedDuplicates
+        });
       } catch (error) {
         result.errors.push(`Failed to import ${sessionFile}: ${error}`);
       }
@@ -5290,60 +5940,105 @@ var SessionHistoryImporter = class {
       skippedDuplicates: 0,
       errors: []
     };
-    if (!fs2.existsSync(filePath)) {
+    if (!fs3.existsSync(filePath)) {
       result.errors.push(`File not found: ${filePath}`);
       return result;
     }
     const sessionId = path2.basename(filePath, ".jsonl");
+    if (options.force) {
+      const deleted = await this.memoryService.deleteSessionEvents(sessionId);
+      if (options.verbose && deleted > 0) {
+        console.log(`  Deleted ${deleted} existing events for session ${sessionId}`);
+      }
+    }
     await this.memoryService.startSession(sessionId, options.projectPath);
-    const fileStream = fs2.createReadStream(filePath);
+    const fileStream = fs3.createReadStream(filePath);
     const rl = readline.createInterface({
       input: fileStream,
       crlfDelay: Infinity
     });
     let lineCount = 0;
     const limit = options.limit || Infinity;
+    const onProgress = options.onProgress;
+    const sessionIndex = options._sessionIndex ?? 0;
+    let lastProgressAt = 0;
+    let currentTurnId = null;
+    let textBuffer = [];
+    let lastTimestamp;
+    const flushTextBuffer = async () => {
+      if (textBuffer.length === 0 || !currentTurnId)
+        return;
+      const substantive = textBuffer.filter((t) => t.length >= 100);
+      const merged = substantive.length > 0 ? substantive.join("\n\n") : textBuffer.reduce((a, b) => a.length >= b.length ? a : b, "");
+      if (!merged) {
+        textBuffer = [];
+        return;
+      }
+      const truncated = merged.length > 1e4 ? merged.slice(0, 1e4) + "...[truncated]" : merged;
+      const appendResult = await this.memoryService.storeAgentResponse(
+        sessionId,
+        truncated,
+        { importedFrom: filePath, originalTimestamp: lastTimestamp, turnId: currentTurnId }
+      );
+      if (appendResult.isDuplicate) {
+        result.skippedDuplicates++;
+      } else {
+        result.importedResponses++;
+      }
+      lineCount++;
+      textBuffer = [];
+    };
     for await (const line of rl) {
       if (lineCount >= limit)
         break;
       try {
         const entry = JSON.parse(line);
         result.totalMessages++;
-        if (entry.type === "user" || entry.type === "assistant") {
+        const msgClass = classifyEntry(entry);
+        if (msgClass === "user_prompt") {
+          await flushTextBuffer();
           const content = this.extractContent(entry);
           if (!content)
             continue;
-          if (entry.type === "user") {
-            const appendResult = await this.memoryService.storeUserPrompt(
-              sessionId,
-              content,
-              { importedFrom: filePath, originalTimestamp: entry.timestamp }
-            );
-            if (appendResult.isDuplicate) {
-              result.skippedDuplicates++;
-            } else {
-              result.importedPrompts++;
-            }
-          } else if (entry.type === "assistant") {
-            const truncatedContent = content.length > 5e3 ? content.slice(0, 5e3) + "...[truncated]" : content;
-            const appendResult = await this.memoryService.storeAgentResponse(
-              sessionId,
-              truncatedContent,
-              { importedFrom: filePath, originalTimestamp: entry.timestamp }
-            );
-            if (appendResult.isDuplicate) {
-              result.skippedDuplicates++;
-            } else {
-              result.importedResponses++;
-            }
+          currentTurnId = randomUUID9();
+          const appendResult = await this.memoryService.storeUserPrompt(
+            sessionId,
+            content,
+            { importedFrom: filePath, originalTimestamp: entry.timestamp, turnId: currentTurnId }
+          );
+          if (appendResult.isDuplicate) {
+            result.skippedDuplicates++;
+          } else {
+            result.importedPrompts++;
           }
           lineCount++;
+        } else if (msgClass === "agent_text") {
+          const content = this.extractContent(entry);
+          if (content) {
+            textBuffer.push(content);
+            lastTimestamp = entry.timestamp;
+          }
+        }
+        const now = Date.now();
+        if (now - lastProgressAt > 200) {
+          lastProgressAt = now;
+          onProgress?.({
+            phase: "session-progress",
+            sessionIndex,
+            messagesProcessed: result.totalMessages,
+            imported: result.importedPrompts + result.importedResponses,
+            skipped: result.skippedDuplicates
+          });
         }
       } catch (parseError) {
         result.errors.push(`Parse error on line: ${parseError}`);
       }
     }
+    await flushTextBuffer();
     await this.memoryService.endSession(sessionId);
+    if (options.projectPath) {
+      registerSession(sessionId, options.projectPath);
+    }
     if (options.verbose) {
       console.log(`Imported ${result.importedPrompts} prompts, ${result.importedResponses} responses from ${filePath}`);
     }
@@ -5361,29 +6056,46 @@ var SessionHistoryImporter = class {
       skippedDuplicates: 0,
       errors: []
     };
+    const onProgress = options.onProgress;
     const projectsDir = path2.join(this.claudeDir, "projects");
-    if (!fs2.existsSync(projectsDir)) {
+    if (!fs3.existsSync(projectsDir)) {
       result.errors.push(`Projects directory not found: ${projectsDir}`);
       return result;
     }
-    const projectDirs = fs2.readdirSync(projectsDir).map((name) => path2.join(projectsDir, name)).filter((p) => fs2.statSync(p).isDirectory());
+    onProgress?.({ phase: "scan", message: "Scanning all projects..." });
+    const projectDirs = fs3.readdirSync(projectsDir).map((name) => path2.join(projectsDir, name)).filter((p) => fs3.statSync(p).isDirectory());
+    const allSessionFiles = [];
+    for (const projectDir of projectDirs) {
+      const sessionFiles = await this.findSessionFiles(projectDir);
+      allSessionFiles.push(...sessionFiles);
+    }
+    onProgress?.({ phase: "scan", message: `Found ${allSessionFiles.length} sessions across ${projectDirs.length} projects` });
     if (options.verbose) {
-      console.log(`Found ${projectDirs.length} project directories`);
+      console.log(`Found ${projectDirs.length} project directories, ${allSessionFiles.length} sessions`);
     }
-    for (const projectDir of projectDirs) {
+    for (let i = 0; i < allSessionFiles.length; i++) {
+      const sessionFile = allSessionFiles[i];
       try {
-        const sessionFiles = await this.findSessionFiles(projectDir);
-        for (const sessionFile of sessionFiles) {
-          const sessionResult = await this.importSessionFile(sessionFile, options);
-          result.totalSessions++;
-          result.totalMessages += sessionResult.totalMessages;
-          result.importedPrompts += sessionResult.importedPrompts;
-          result.importedResponses += sessionResult.importedResponses;
-          result.skippedDuplicates += sessionResult.skippedDuplicates;
-          result.errors.push(...sessionResult.errors);
-        }
+        onProgress?.({ phase: "session-start", sessionIndex: i, totalSessions: allSessionFiles.length, filePath: sessionFile });
+        const sessionResult = await this.importSessionFile(sessionFile, {
+          ...options,
+          _sessionIndex: i
+        });
+        result.totalSessions++;
+        result.totalMessages += sessionResult.totalMessages;
+        result.importedPrompts += sessionResult.importedPrompts;
+        result.importedResponses += sessionResult.importedResponses;
+        result.skippedDuplicates += sessionResult.skippedDuplicates;
+        result.errors.push(...sessionResult.errors);
+        onProgress?.({
+          phase: "session-done",
+          sessionIndex: i,
+          importedPrompts: sessionResult.importedPrompts,
+          importedResponses: sessionResult.importedResponses,
+          skipped: sessionResult.skippedDuplicates
+        });
       } catch (error) {
-        result.errors.push(`Failed to process ${projectDir}: ${error}`);
+        result.errors.push(`Failed to process ${sessionFile}: ${error}`);
       }
     }
     return result;
@@ -5393,10 +6105,10 @@ var SessionHistoryImporter = class {
    */
   async findProjectDir(projectPath) {
     const projectsDir = path2.join(this.claudeDir, "projects");
-    if (!fs2.existsSync(projectsDir)) {
+    if (!fs3.existsSync(projectsDir)) {
       return null;
     }
-    const projectDirs = fs2.readdirSync(projectsDir).map((name) => path2.join(projectsDir, name)).filter((p) => fs2.statSync(p).isDirectory());
+    const projectDirs = fs3.readdirSync(projectsDir).map((name) => path2.join(projectsDir, name)).filter((p) => fs3.statSync(p).isDirectory());
     const normalizedPath = projectPath.replace(/\//g, "-").replace(/^-/, "");
     for (const dir of projectDirs) {
       const dirName = path2.basename(dir);
@@ -5410,10 +6122,10 @@ var SessionHistoryImporter = class {
    * Find all JSONL session files in a directory
    */
   async findSessionFiles(dir) {
-    if (!fs2.existsSync(dir)) {
+    if (!fs3.existsSync(dir)) {
       return [];
     }
-    return fs2.readdirSync(dir).filter((name) => name.endsWith(".jsonl")).map((name) => path2.join(dir, name)).filter((p) => fs2.statSync(p).isFile());
+    return fs3.readdirSync(dir).filter((name) => name.endsWith(".jsonl")).map((name) => path2.join(dir, name)).filter((p) => fs3.statSync(p).isFile());
   }
   /**
    * Extract text content from Claude message
@@ -5445,14 +6157,14 @@ var SessionHistoryImporter = class {
       }
     } else {
       const projectsDir = path2.join(this.claudeDir, "projects");
-      if (fs2.existsSync(projectsDir)) {
-        projectDirs = fs2.readdirSync(projectsDir).map((name) => path2.join(projectsDir, name)).filter((p) => fs2.statSync(p).isDirectory());
+      if (fs3.existsSync(projectsDir)) {
+        projectDirs = fs3.readdirSync(projectsDir).map((name) => path2.join(projectsDir, name)).filter((p) => fs3.statSync(p).isDirectory());
       }
     }
     for (const projectDir of projectDirs) {
       const sessionFiles = await this.findSessionFiles(projectDir);
       for (const filePath of sessionFiles) {
-        const stats = fs2.statSync(filePath);
+        const stats = fs3.statSync(filePath);
         sessions.push({
           sessionId: path2.basename(filePath, ".jsonl"),
           filePath,
@@ -5470,24 +6182,52 @@ function createSessionHistoryImporter(memoryService) {
 }
 
 // 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 path3 from "path";
-import * as fs3 from "fs";
+import * as path5 from "path";
+import * as fs5 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 path3 from "path";
+import * as os3 from "os";
+function getServiceFromQuery(c) {
+  const project = c.req.query("project");
+  if (project) {
+    const isHash = /^[a-f0-9]{8}$/.test(project);
+    let storagePath;
+    if (isHash) {
+      storagePath = path3.join(os3.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 = path3.join(os3.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);
@@ -5531,7 +6271,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);
@@ -5572,18 +6312,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({
@@ -5593,7 +6351,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,
@@ -5608,7 +6368,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);
@@ -5648,7 +6408,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) {
@@ -5692,7 +6452,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 });
@@ -5720,7 +6480,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();
@@ -5777,7 +6537,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 });
@@ -5824,7 +6584,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();
@@ -5868,7 +6628,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);
@@ -5899,7 +6659,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);
@@ -5929,8 +6689,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();
@@ -5991,7 +6782,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);
@@ -6025,7 +6816,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);
@@ -6061,23 +6852,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 fs4 from "fs";
+import * as path4 from "path";
+import * as os4 from "os";
+var projectsRouter = new Hono7();
+projectsRouter.get("/", async (c) => {
+  try {
+    const projectsDir = path4.join(os4.homedir(), ".claude-code", "memory", "projects");
+    if (!fs4.existsSync(projectsDir)) {
+      return c.json({ projects: [] });
+    }
+    const projectHashes = fs4.readdirSync(projectsDir).filter((name) => {
+      const fullPath = path4.join(projectsDir, name);
+      return fs4.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 = path4.join(projectsDir, hash);
+      const dbPath = path4.join(dirPath, "events.sqlite");
+      let dbSize = 0;
+      if (fs4.existsSync(dbPath)) {
+        dbSize = fs4.statSync(dbPath).size;
+      }
+      const projectPath = hashToPath.get(hash) || `unknown (${hash})`;
+      return {
+        hash,
+        projectPath,
+        projectName: path4.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 = path3.join(__dirname, "../../dist/ui");
-if (fs3.existsSync(uiPath)) {
+var uiPath = path5.join(__dirname, "../../dist/ui");
+if (fs5.existsSync(uiPath)) {
   app.use("/*", serveStatic({ root: uiPath }));
 }
 app.get("*", (c) => {
-  const indexPath = path3.join(uiPath, "index.html");
-  if (fs3.existsSync(indexPath)) {
-    return c.html(fs3.readFileSync(indexPath, "utf-8"));
+  const indexPath = path5.join(uiPath, "index.html");
+  if (fs5.existsSync(indexPath)) {
+    return c.html(fs5.readFileSync(indexPath, "utf-8"));
   }
   return c.text('UI not built. Run "npm run build:ui" first.', 404);
 });
@@ -6115,28 +7256,28 @@ if (isMainModule) {
 }
 
 // src/cli/index.ts
-var CLAUDE_SETTINGS_PATH = path4.join(os3.homedir(), ".claude", "settings.json");
+var CLAUDE_SETTINGS_PATH = path6.join(os5.homedir(), ".claude", "settings.json");
 function getPluginPath() {
   const possiblePaths = [
-    path4.join(__dirname, ".."),
+    path6.join(__dirname, ".."),
     // When running from dist/cli
-    path4.join(__dirname, "../..", "dist"),
+    path6.join(__dirname, "../..", "dist"),
     // When running from src
-    path4.join(process.cwd(), "dist")
+    path6.join(process.cwd(), "dist")
     // Current working directory
   ];
   for (const p of possiblePaths) {
-    const hooksPath = path4.join(p, "hooks", "user-prompt-submit.js");
-    if (fs4.existsSync(hooksPath)) {
+    const hooksPath = path6.join(p, "hooks", "user-prompt-submit.js");
+    if (fs6.existsSync(hooksPath)) {
       return p;
     }
   }
-  return path4.join(os3.homedir(), ".npm-global", "lib", "node_modules", "claude-memory-layer", "dist");
+  return path6.join(os5.homedir(), ".npm-global", "lib", "node_modules", "claude-memory-layer", "dist");
 }
 function loadClaudeSettings() {
   try {
-    if (fs4.existsSync(CLAUDE_SETTINGS_PATH)) {
-      const content = fs4.readFileSync(CLAUDE_SETTINGS_PATH, "utf-8");
+    if (fs6.existsSync(CLAUDE_SETTINGS_PATH)) {
+      const content = fs6.readFileSync(CLAUDE_SETTINGS_PATH, "utf-8");
       return JSON.parse(content);
     }
   } catch (error) {
@@ -6145,13 +7286,13 @@ function loadClaudeSettings() {
   return {};
 }
 function saveClaudeSettings(settings) {
-  const dir = path4.dirname(CLAUDE_SETTINGS_PATH);
-  if (!fs4.existsSync(dir)) {
-    fs4.mkdirSync(dir, { recursive: true });
+  const dir = path6.dirname(CLAUDE_SETTINGS_PATH);
+  if (!fs6.existsSync(dir)) {
+    fs6.mkdirSync(dir, { recursive: true });
   }
   const tempPath = CLAUDE_SETTINGS_PATH + ".tmp";
-  fs4.writeFileSync(tempPath, JSON.stringify(settings, null, 2));
-  fs4.renameSync(tempPath, CLAUDE_SETTINGS_PATH);
+  fs6.writeFileSync(tempPath, JSON.stringify(settings, null, 2));
+  fs6.renameSync(tempPath, CLAUDE_SETTINGS_PATH);
 }
 function getHooksConfig(pluginPath) {
   return {
@@ -6161,7 +7302,7 @@ function getHooksConfig(pluginPath) {
         hooks: [
           {
             type: "command",
-            command: `node ${path4.join(pluginPath, "hooks", "user-prompt-submit.js")}`
+            command: `node ${path6.join(pluginPath, "hooks", "user-prompt-submit.js")}`
           }
         ]
       }
@@ -6172,7 +7313,7 @@ function getHooksConfig(pluginPath) {
         hooks: [
           {
             type: "command",
-            command: `node ${path4.join(pluginPath, "hooks", "post-tool-use.js")}`
+            command: `node ${path6.join(pluginPath, "hooks", "post-tool-use.js")}`
           }
         ]
       }
@@ -6184,8 +7325,8 @@ program.name("claude-memory-layer").description("Claude Code Memory Plugin CLI")
 program.command("install").description("Install hooks into Claude Code settings").option("--path <path>", "Custom plugin path (defaults to auto-detect)").action(async (options) => {
   try {
     const pluginPath = options.path || getPluginPath();
-    const userPromptHook = path4.join(pluginPath, "hooks", "user-prompt-submit.js");
-    if (!fs4.existsSync(userPromptHook)) {
+    const userPromptHook = path6.join(pluginPath, "hooks", "user-prompt-submit.js");
+    if (!fs6.existsSync(userPromptHook)) {
       console.error(`
 \u274C Hook files not found at: ${pluginPath}`);
       console.error('   Make sure you have built the plugin with "npm run build"');
@@ -6251,7 +7392,7 @@ program.command("status").description("Check plugin installation status").action
     console.log("Hooks:");
     console.log(`  UserPromptSubmit: ${hasUserPromptHook ? "\u2705 Installed" : "\u274C Not installed"}`);
     console.log(`  PostToolUse: ${hasPostToolHook ? "\u2705 Installed" : "\u274C Not installed"}`);
-    const hooksExist = fs4.existsSync(path4.join(pluginPath, "hooks", "user-prompt-submit.js"));
+    const hooksExist = fs6.existsSync(path6.join(pluginPath, "hooks", "user-prompt-submit.js"));
     console.log(`
 Plugin files: ${hooksExist ? "\u2705 Found" : "\u274C Not found"}`);
     console.log(`  Path: ${pluginPath}`);
@@ -6379,95 +7520,143 @@ program.command("process").description("Process pending embeddings").option("-p,
     process.exit(1);
   }
 });
-program.command("import").description("Import existing Claude Code conversation history").option("-p, --project <path>", "Import from specific project path").option("-s, --session <file>", "Import specific session file (JSONL)").option("-a, --all", "Import all sessions from all projects").option("-l, --limit <number>", "Limit messages per session").option("-v, --verbose", "Show detailed progress").action(async (options) => {
+function renderProgress(event) {
+  switch (event.phase) {
+    case "scan":
+      console.log(`  \u{1F50D} ${event.message}`);
+      break;
+    case "session-start": {
+      const pct = Math.round(event.sessionIndex / event.totalSessions * 100);
+      const sessionName = path6.basename(event.filePath, ".jsonl").slice(0, 8);
+      process.stdout.write(
+        `\r  \u{1F4C4} [${event.sessionIndex + 1}/${event.totalSessions}] ${pct}% | Session ${sessionName}... `
+      );
+      break;
+    }
+    case "session-progress": {
+      process.stdout.write(
+        `\r  \u{1F4C4} [${event.sessionIndex + 1}/...] ${event.messagesProcessed} msgs | +${event.imported} imported, ~${event.skipped} skipped `
+      );
+      break;
+    }
+    case "session-done": {
+      const imported = event.importedPrompts + event.importedResponses;
+      if (imported > 0) {
+        process.stdout.write(
+          `\r  \u2705 [${event.sessionIndex + 1}] +${event.importedPrompts} prompts, +${event.importedResponses} responses${event.skipped > 0 ? `, ~${event.skipped} skipped` : ""}     
+`
+        );
+      } else if (event.skipped > 0) {
+        process.stdout.write(
+          `\r  \u23ED\uFE0F  [${event.sessionIndex + 1}] All ${event.skipped} already imported                          
+`
+        );
+      } else {
+        process.stdout.write(
+          `\r  \u23ED\uFE0F  [${event.sessionIndex + 1}] Empty session                                              
+`
+        );
+      }
+      break;
+    }
+    case "embedding":
+      process.stdout.write(
+        `\r  \u{1F9E0} Embeddings: ${event.processed}/${event.total} processed `
+      );
+      if (event.processed >= event.total) {
+        process.stdout.write("\n");
+      }
+      break;
+    case "done":
+      break;
+  }
+}
+function printImportSummary(result, embedCount) {
+  console.log("\n\u250C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2510");
+  console.log("\u2502       \u2705 Import Complete         \u2502");
+  console.log("\u251C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2524");
+  console.log(`\u2502  Sessions processed:  ${String(result.totalSessions).padStart(8)} \u2502`);
+  console.log(`\u2502  Total messages:      ${String(result.totalMessages).padStart(8)} \u2502`);
+  console.log(`\u2502  Imported prompts:    ${String(result.importedPrompts).padStart(8)} \u2502`);
+  console.log(`\u2502  Imported responses:  ${String(result.importedResponses).padStart(8)} \u2502`);
+  console.log(`\u2502  Skipped duplicates:  ${String(result.skippedDuplicates).padStart(8)} \u2502`);
+  console.log(`\u2502  Embeddings queued:   ${String(embedCount).padStart(8)} \u2502`);
+  console.log("\u2514\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2518");
+  if (result.errors.length > 0) {
+    console.log(`
+\u26A0\uFE0F  Errors (${result.errors.length}):`);
+    for (const error of result.errors.slice(0, 5)) {
+      console.log(`  - ${error}`);
+    }
+    if (result.errors.length > 5) {
+      console.log(`  ... and ${result.errors.length - 5} more`);
+    }
+  }
+}
+program.command("import").description("Import existing Claude Code conversation history").option("-p, --project <path>", "Import from specific project path").option("-s, --session <file>", "Import specific session file (JSONL)").option("-a, --all", "Import all sessions from all projects").option("-l, --limit <number>", "Limit messages per session").option("-f, --force", "Force reimport: delete existing events and reimport with turn_id grouping").option("-v, --verbose", "Show detailed progress").action(async (options) => {
+  const startTime = Date.now();
   const targetProjectPath = options.project || process.cwd();
   const service = getMemoryServiceForProject(targetProjectPath);
   const importer = createSessionHistoryImporter(service);
+  const importOpts = {
+    limit: options.limit ? parseInt(options.limit) : void 0,
+    force: options.force,
+    verbose: options.verbose,
+    onProgress: renderProgress
+  };
   try {
+    console.log("\n\u23F3 Initializing memory service...");
     await service.initialize();
+    console.log("  \u2705 Ready\n");
+    if (options.force) {
+      console.log("\u{1F504} Force mode: existing events will be deleted and reimported with turn_id grouping\n");
+    }
     let result;
     if (options.session) {
-      console.log(`
-\u{1F4E5} Importing session: ${options.session}`);
-      console.log(`   Target project: ${targetProjectPath}
+      console.log(`\u{1F4E5} Importing session: ${options.session}`);
+      console.log(`   Target: ${targetProjectPath}
 `);
       result = await importer.importSessionFile(options.session, {
-        projectPath: targetProjectPath,
-        limit: options.limit ? parseInt(options.limit) : void 0,
-        verbose: options.verbose
+        ...importOpts,
+        projectPath: targetProjectPath
       });
     } else if (options.project) {
-      console.log(`
-\u{1F4E5} Importing project: ${options.project}
+      console.log(`\u{1F4E5} Importing project: ${options.project}
 `);
-      result = await importer.importProject(options.project, {
-        limit: options.limit ? parseInt(options.limit) : void 0,
-        verbose: options.verbose
-      });
+      result = await importer.importProject(options.project, importOpts);
     } else if (options.all) {
-      console.log("\n\u{1F4E5} Importing all sessions from all projects");
+      console.log("\u{1F4E5} Importing all sessions from all projects");
       console.log("   \u26A0\uFE0F  Using global storage (use -p for project-specific)\n");
       const globalService = getDefaultMemoryService();
       const globalImporter = createSessionHistoryImporter(globalService);
       await globalService.initialize();
-      result = await globalImporter.importAll({
-        limit: options.limit ? parseInt(options.limit) : void 0,
-        verbose: options.verbose
-      });
-      console.log("\n\u23F3 Processing embeddings...");
+      result = await globalImporter.importAll(importOpts);
+      console.log("\n\u{1F9E0} Processing embeddings...");
       const embedCount2 = await globalService.processPendingEmbeddings();
-      console.log("\n\u2705 Import Complete\n");
-      console.log(`Sessions processed: ${result.totalSessions}`);
-      console.log(`Total messages: ${result.totalMessages}`);
-      console.log(`Imported prompts: ${result.importedPrompts}`);
-      console.log(`Imported responses: ${result.importedResponses}`);
-      console.log(`Skipped duplicates: ${result.skippedDuplicates}`);
-      console.log(`Embeddings processed: ${embedCount2}`);
-      if (result.errors.length > 0) {
-        console.log(`
-\u26A0\uFE0F  Errors (${result.errors.length}):`);
-        for (const error of result.errors.slice(0, 5)) {
-          console.log(`  - ${error}`);
-        }
-        if (result.errors.length > 5) {
-          console.log(`  ... and ${result.errors.length - 5} more`);
-        }
-      }
+      const elapsed2 = ((Date.now() - startTime) / 1e3).toFixed(1);
+      printImportSummary(result, embedCount2);
+      console.log(`
+\u23F1\uFE0F  Completed in ${elapsed2}s`);
       await globalService.shutdown();
       return;
     } else {
       const cwd = process.cwd();
-      console.log(`
-\u{1F4E5} Importing sessions for current project: ${cwd}
+      console.log(`\u{1F4E5} Importing sessions for: ${cwd}
 `);
       result = await importer.importProject(cwd, {
-        projectPath: cwd,
-        limit: options.limit ? parseInt(options.limit) : void 0,
-        verbose: options.verbose
+        ...importOpts,
+        projectPath: cwd
       });
     }
-    console.log("\n\u23F3 Processing embeddings...");
+    console.log("\n\u{1F9E0} Processing embeddings...");
     const embedCount = await service.processPendingEmbeddings();
-    console.log("\n\u2705 Import Complete\n");
-    console.log(`Sessions processed: ${result.totalSessions}`);
-    console.log(`Total messages: ${result.totalMessages}`);
-    console.log(`Imported prompts: ${result.importedPrompts}`);
-    console.log(`Imported responses: ${result.importedResponses}`);
-    console.log(`Skipped duplicates: ${result.skippedDuplicates}`);
-    console.log(`Embeddings processed: ${embedCount}`);
-    if (result.errors.length > 0) {
-      console.log(`
-\u26A0\uFE0F  Errors (${result.errors.length}):`);
-      for (const error of result.errors.slice(0, 5)) {
-        console.log(`  - ${error}`);
-      }
-      if (result.errors.length > 5) {
-        console.log(`  ... and ${result.errors.length - 5} more`);
-      }
-    }
+    const elapsed = ((Date.now() - startTime) / 1e3).toFixed(1);
+    printImportSummary(result, embedCount);
+    console.log(`
+\u23F1\uFE0F  Completed in ${elapsed}s`);
     await service.shutdown();
   } catch (error) {
-    console.error("Import failed:", error);
+    console.error("\n\u274C Import failed:", error);
     process.exit(1);
   }
 });