claude-memory-layer 1.0.9 → 1.0.11

package/dist/hooks/user-prompt-submit.js

@@ -6,10 +6,13 @@ const require = createRequire(import.meta.url);
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
 
+// src/hooks/user-prompt-submit.ts
+import { randomUUID as randomUUID9 } from "crypto";
+
 // 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
@@ -67,11 +70,11 @@ function toDate(value) {
     return new Date(value);
   return new Date(String(value));
 }
-function createDatabase(path2, options) {
+function createDatabase(path3, options) {
   if (options?.readOnly) {
-    return new duckdb.Database(path2, { access_mode: "READ_ONLY" });
+    return new duckdb.Database(path3, { access_mode: "READ_ONLY" });
   }
-  return new duckdb.Database(path2);
+  return new duckdb.Database(path3);
 }
 function dbRun(db, sql, params = []) {
   return new Promise((resolve2, reject) => {
@@ -741,8 +744,14 @@ import { randomUUID as randomUUID2 } from "crypto";
 
 // src/core/sqlite-wrapper.ts
 import Database from "better-sqlite3";
-function createSQLiteDatabase(path2, options) {
-  const db = new Database(path2, {
+import * as fs from "fs";
+import * as nodePath from "path";
+function createSQLiteDatabase(path3, options) {
+  const dir = nodePath.dirname(path3);
+  if (!fs.existsSync(dir)) {
+    fs.mkdirSync(dir, { recursive: true });
+  }
+  const db = new Database(path3, {
     readonly: options?.readonly ?? false
   });
   if (!options?.readonly && (options?.walMode ?? true)) {
@@ -1009,6 +1018,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,
@@ -1034,6 +1060,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);
@@ -1055,6 +1106,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);
@@ -1067,6 +1127,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;
   }
   /**
@@ -1091,9 +1157,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 (?, ?)
@@ -1110,7 +1178,8 @@ var SQLiteEventStore = class {
           input.content,
           canonicalKey,
           dedupeKey,
-          JSON.stringify(input.metadata || {})
+          JSON.stringify(metadata),
+          turnId
         );
         insertDedup.run(dedupeKey, id);
         insertLevel.run(id);
@@ -1460,11 +1529,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
@@ -1472,8 +1541,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
    */
@@ -1486,6 +1769,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
    */
@@ -1506,6 +1926,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;
   }
 };
@@ -1717,7 +2140,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]);
     }
@@ -1743,7 +2175,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);
     }
@@ -4489,7 +4930,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);
   }
@@ -4506,8 +4947,8 @@ var REGISTRY_PATH = path.join(os.homedir(), ".claude-code", "memory", "session-r
 var SHARED_STORAGE_PATH = path.join(os.homedir(), ".claude-code", "memory", "shared");
 function loadSessionRegistry() {
   try {
-    if (fs.existsSync(REGISTRY_PATH)) {
-      const data = fs.readFileSync(REGISTRY_PATH, "utf-8");
+    if (fs2.existsSync(REGISTRY_PATH)) {
+      const data = fs2.readFileSync(REGISTRY_PATH, "utf-8");
       return JSON.parse(data);
     }
   } catch (error) {
@@ -4547,11 +4988,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 };
@@ -4596,6 +5039,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();
@@ -4642,8 +5089,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")
@@ -4740,6 +5187,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,
@@ -4747,7 +5195,8 @@ var MemoryService = class {
       content,
       metadata: {
         toolName: payload.toolName,
-        success: payload.success
+        success: payload.success,
+        ...turnId ? { turnId } : {}
       }
     });
     if (result.success && !result.isDuplicate) {
@@ -4765,9 +5214,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,
@@ -4777,6 +5223,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
    */
@@ -5010,6 +5479,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
    */
@@ -5033,8 +5527,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,
@@ -5055,6 +5548,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
    */
@@ -5118,6 +5639,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
    */
@@ -5200,94 +5759,115 @@ var MemoryService = class {
   }
 };
 var serviceCache = /* @__PURE__ */ new Map();
-var GLOBAL_KEY = "__global__";
-function getDefaultMemoryService() {
-  if (!serviceCache.has(GLOBAL_KEY)) {
-    serviceCache.set(GLOBAL_KEY, new MemoryService({
-      storagePath: "~/.claude-code/memory",
+function getLightweightMemoryService(sessionId) {
+  const projectInfo = getSessionProject(sessionId);
+  const key = projectInfo ? `lightweight_${projectInfo.projectHash}` : "lightweight_global";
+  if (!serviceCache.has(key)) {
+    const storagePath = projectInfo ? getProjectStoragePath(projectInfo.projectPath) : path.join(os.homedir(), ".claude-code", "memory");
+    serviceCache.set(key, new MemoryService({
+      storagePath,
+      projectHash: projectInfo?.projectHash,
+      lightweightMode: true,
+      // Skip embedder/vector/workers
       analyticsEnabled: false,
-      // Hooks don't need DuckDB
       sharedStoreConfig: { enabled: false }
-      // Shared store uses DuckDB too
     }));
   }
-  return serviceCache.get(GLOBAL_KEY);
+  return serviceCache.get(key);
 }
-function getMemoryServiceForProject(projectPath, sharedStoreConfig) {
-  const hash = hashProjectPath(projectPath);
-  if (!serviceCache.has(hash)) {
-    const storagePath = getProjectStoragePath(projectPath);
-    serviceCache.set(hash, new MemoryService({
-      storagePath,
-      projectHash: hash,
-      // Override shared store config - hooks don't need DuckDB
-      sharedStoreConfig: sharedStoreConfig ?? { enabled: false },
-      analyticsEnabled: false
-      // Hooks don't need DuckDB
-    }));
-  }
-  return serviceCache.get(hash);
+
+// src/core/turn-state.ts
+import * as fs3 from "fs";
+import * as path2 from "path";
+import * as os2 from "os";
+var TURN_STATE_DIR = path2.join(os2.homedir(), ".claude-code", "memory");
+function getStatePath(sessionId) {
+  return path2.join(TURN_STATE_DIR, `.turn-state-${sessionId}.json`);
 }
-function getMemoryServiceForSession(sessionId) {
-  const projectInfo = getSessionProject(sessionId);
-  if (projectInfo) {
-    return getMemoryServiceForProject(projectInfo.projectPath);
+function writeTurnState(sessionId, turnId) {
+  try {
+    if (!fs3.existsSync(TURN_STATE_DIR)) {
+      fs3.mkdirSync(TURN_STATE_DIR, { recursive: true });
+    }
+    const state = {
+      turnId,
+      sessionId,
+      createdAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    const filePath = getStatePath(sessionId);
+    const tempPath = filePath + ".tmp";
+    fs3.writeFileSync(tempPath, JSON.stringify(state));
+    fs3.renameSync(tempPath, filePath);
+  } catch (error) {
+    if (process.env.CLAUDE_MEMORY_DEBUG) {
+      console.error("Failed to write turn state:", error);
+    }
   }
-  return getDefaultMemoryService();
 }
 
 // src/hooks/user-prompt-submit.ts
+var MAX_MEMORIES = parseInt(process.env.CLAUDE_MEMORY_MAX_COUNT || "5");
+var MIN_SCORE = parseFloat(process.env.CLAUDE_MEMORY_MIN_SCORE || "0.3");
+var ENABLE_SEARCH = process.env.CLAUDE_MEMORY_SEARCH !== "false";
+function shouldStorePrompt(prompt) {
+  const trimmed = prompt.trim();
+  if (trimmed.startsWith("/"))
+    return false;
+  if (trimmed.length < 15)
+    return false;
+  if (!/[a-zA-Z가-힣]{2,}/.test(trimmed))
+    return false;
+  return true;
+}
 async function main() {
   const inputData = await readStdin();
   const input = JSON.parse(inputData);
-  const memoryService = getMemoryServiceForSession(input.session_id);
-  const config = {
-    candidateCount: parseInt(process.env.CLAUDE_MEMORY_CANDIDATES || "10"),
-    minScore: parseFloat(process.env.CLAUDE_MEMORY_MIN_SCORE || "0.7"),
-    maxMemories: parseInt(process.env.CLAUDE_MEMORY_MAX_COUNT || "5"),
-    dynamicThresholdRatio: parseFloat(process.env.CLAUDE_MEMORY_THRESHOLD_RATIO || "0.85"),
-    strictMinScore: parseFloat(process.env.CLAUDE_MEMORY_STRICT_MIN || "0.75")
-  };
+  const turnId = randomUUID9();
+  writeTurnState(input.session_id, turnId);
+  const memoryService = getLightweightMemoryService(input.session_id);
   try {
-    const includeShared = memoryService.isSharedStoreEnabled();
-    const retrievalResult = await memoryService.retrieveMemories(input.prompt, {
-      topK: config.candidateCount,
-      // Get more candidates initially
-      minScore: config.minScore,
-      includeShared
-    });
-    await memoryService.storeUserPrompt(
-      input.session_id,
-      input.prompt
-    );
-    let relevantMemories = [];
-    if (retrievalResult.memories && retrievalResult.memories.length > 0) {
-      const bestScore = Math.max(...retrievalResult.memories.map((m) => m.score));
-      const dynamicThreshold = Math.max(config.strictMinScore, bestScore * config.dynamicThresholdRatio);
-      relevantMemories = retrievalResult.memories.filter((m) => m.score >= dynamicThreshold);
-      relevantMemories = relevantMemories.slice(0, config.maxMemories);
-      if (relevantMemories.length === 0) {
-        const fallbackCount = Math.min(3, config.maxMemories);
-        relevantMemories = retrievalResult.memories.filter((m) => m.score >= config.minScore).slice(0, fallbackCount);
-      }
-      if (process.env.CLAUDE_MEMORY_DEBUG) {
-        console.error(`Memory filtering: ${retrievalResult.memories.length} candidates -> ${relevantMemories.length} selected`);
-        console.error(`Threshold: ${dynamicThreshold.toFixed(3)}, Best score: ${bestScore.toFixed(3)}`);
-      }
-      if (relevantMemories.length > 0) {
-        const eventIds = relevantMemories.map((m) => m.event.id);
+    if (shouldStorePrompt(input.prompt)) {
+      await memoryService.storeUserPrompt(
+        input.session_id,
+        input.prompt,
+        { turnId }
+      );
+    }
+    let context = "";
+    if (ENABLE_SEARCH && input.prompt.length > 10) {
+      const results = await memoryService.keywordSearch(input.prompt, {
+        topK: MAX_MEMORIES,
+        minScore: MIN_SCORE
+      });
+      if (results.length > 0) {
+        const eventIds = results.map((r) => r.event.id);
         await memoryService.incrementMemoryAccess(eventIds);
+        for (const r of results) {
+          try {
+            await memoryService.recordRetrieval(
+              r.event.id,
+              input.session_id,
+              r.score,
+              input.prompt
+            );
+          } catch {
+          }
+        }
+        const memories = results.map((r) => {
+          const preview = r.event.content.length > 300 ? r.event.content.substring(0, 300) + "..." : r.event.content;
+          return `- [${r.event.eventType}] ${preview}`;
+        });
+        context = `\u{1F4A1} **Related memories found:**
+
+${memories.join("\n\n")}`;
       }
     }
-    const filteredResult = {
-      ...retrievalResult,
-      memories: relevantMemories
-    };
-    const context = memoryService.formatAsContext(filteredResult);
     const output = { context };
     console.log(JSON.stringify(output));
   } catch (error) {
-    console.error("Memory hook error:", error);
+    if (process.env.CLAUDE_MEMORY_DEBUG) {
+      console.error("Memory hook error:", error);
+    }
     console.log(JSON.stringify({ context: "" }));
   }
 }