claude-memory-layer 1.0.10 → 1.0.12

package/dist/hooks/session-start.js

@@ -7,9 +7,9 @@ const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
 
 // src/services/memory-service.ts
-import * as path from "path";
+import * as path3 from "path";
 import * as os from "os";
-import * as fs from "fs";
+import * as fs4 from "fs";
 import * as crypto2 from "crypto";
 
 // src/core/event-store.ts
@@ -67,11 +67,11 @@ function toDate(value) {
     return new Date(value);
   return new Date(String(value));
 }
-function createDatabase(path2, options) {
+function createDatabase(path4, options) {
   if (options?.readOnly) {
-    return new duckdb.Database(path2, { access_mode: "READ_ONLY" });
+    return new duckdb.Database(path4, { access_mode: "READ_ONLY" });
   }
-  return new duckdb.Database(path2);
+  return new duckdb.Database(path4);
 }
 function dbRun(db, sql, params = []) {
   return new Promise((resolve2, reject) => {
@@ -335,6 +335,17 @@ var EventStore = class {
         created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
       )
     `);
+    await dbRun(this.db, `
+      CREATE TABLE IF NOT EXISTS consolidated_rules (
+        rule_id VARCHAR PRIMARY KEY,
+        rule TEXT NOT NULL,
+        topics JSON,
+        source_memory_ids JSON,
+        source_events JSON,
+        confidence FLOAT DEFAULT 0.5,
+        created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+      )
+    `);
     await dbRun(this.db, `
       CREATE TABLE IF NOT EXISTS endless_config (
         key VARCHAR PRIMARY KEY,
@@ -354,6 +365,7 @@ var EventStore = class {
     await dbRun(this.db, `CREATE INDEX IF NOT EXISTS idx_working_set_expires ON working_set(expires_at)`);
     await dbRun(this.db, `CREATE INDEX IF NOT EXISTS idx_working_set_relevance ON working_set(relevance_score DESC)`);
     await dbRun(this.db, `CREATE INDEX IF NOT EXISTS idx_consolidated_confidence ON consolidated_memories(confidence DESC)`);
+    await dbRun(this.db, `CREATE INDEX IF NOT EXISTS idx_consolidated_rules_confidence ON consolidated_rules(confidence DESC)`);
     await dbRun(this.db, `CREATE INDEX IF NOT EXISTS idx_continuity_created ON continuity_log(created_at)`);
     this.initialized = true;
   }
@@ -741,8 +753,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(path4, options) {
+  const dir = nodePath.dirname(path4);
+  if (!fs.existsSync(dir)) {
+    fs.mkdirSync(dir, { recursive: true });
+  }
+  const db = new Database(path4, {
     readonly: options?.readonly ?? false
   });
   if (!options?.readonly && (options?.walMode ?? true)) {
@@ -783,6 +801,64 @@ function toSQLiteTimestamp(date) {
   return date.toISOString();
 }
 
+// src/core/markdown-mirror.ts
+import * as fs2 from "fs/promises";
+import * as path from "path";
+var DEFAULT_NAMESPACE = "default";
+var DEFAULT_CATEGORY = "uncategorized";
+function sanitizeSegment(input, fallback) {
+  const raw = String(input ?? "").trim().toLowerCase();
+  const safe = raw.normalize("NFKD").replace(/[^a-z0-9_-]+/g, "-").replace(/^-+|-+$/g, "");
+  if (!safe || safe === "." || safe === "..")
+    return fallback;
+  return safe;
+}
+function getCategorySegments(metadata, eventType) {
+  const raw = metadata?.categoryPath;
+  if (Array.isArray(raw) && raw.length > 0) {
+    return raw.map((s) => sanitizeSegment(s, DEFAULT_CATEGORY));
+  }
+  const single = metadata?.category;
+  if (typeof single === "string" && single.trim()) {
+    return [sanitizeSegment(single, DEFAULT_CATEGORY)];
+  }
+  return [sanitizeSegment(eventType, DEFAULT_CATEGORY)];
+}
+function buildMirrorPath(rootDir, event) {
+  const metadata = event.metadata;
+  const namespace = sanitizeSegment(metadata?.namespace, DEFAULT_NAMESPACE);
+  const categories = getCategorySegments(metadata, event.eventType);
+  const d = event.timestamp;
+  const yyyy = d.getFullYear();
+  const mm = String(d.getMonth() + 1).padStart(2, "0");
+  const dd = String(d.getDate()).padStart(2, "0");
+  return path.join(rootDir, "memory", namespace, ...categories, `${yyyy}-${mm}-${dd}.md`);
+}
+function formatMirrorEntry(event) {
+  const category = Array.isArray(event.metadata?.categoryPath) ? event.metadata.categoryPath.join("/") : String(event.metadata?.category ?? event.eventType);
+  return [
+    "",
+    `- ts: ${event.timestamp.toISOString()}`,
+    `  id: ${event.id}`,
+    `  type: ${event.eventType}`,
+    `  session: ${event.sessionId}`,
+    `  category: ${category}`,
+    "  content: |",
+    ...event.content.split("\n").map((line) => `    ${line}`)
+  ].join("\n") + "\n";
+}
+var MarkdownMirror = class {
+  constructor(rootDir) {
+    this.rootDir = rootDir;
+  }
+  async append(event) {
+    const outPath = buildMirrorPath(this.rootDir, event);
+    await fs2.mkdir(path.dirname(outPath), { recursive: true });
+    await fs2.appendFile(outPath, formatMirrorEntry(event), "utf8");
+    return outPath;
+  }
+};
+
 // src/core/sqlite-event-store.ts
 var SQLiteEventStore = class {
   constructor(dbPath, options) {
@@ -792,10 +868,12 @@ var SQLiteEventStore = class {
       readonly: this.readOnly,
       walMode: !this.readOnly
     });
+    this.markdownMirror = this.readOnly || !options?.markdownMirrorRoot ? null : new MarkdownMirror(options.markdownMirrorRoot);
   }
   db;
   initialized = false;
   readOnly;
+  markdownMirror;
   /**
    * Initialize database schema
    */
@@ -1002,6 +1080,17 @@ var SQLiteEventStore = class {
         created_at TEXT DEFAULT (datetime('now'))
       );
 
+      -- Consolidated Rules table (long-term stable memory)
+      CREATE TABLE IF NOT EXISTS consolidated_rules (
+        rule_id TEXT PRIMARY KEY,
+        rule TEXT NOT NULL,
+        topics TEXT,
+        source_memory_ids TEXT,
+        source_events TEXT,
+        confidence REAL DEFAULT 0.5,
+        created_at TEXT DEFAULT (datetime('now'))
+      );
+
       -- Endless Mode Config table
       CREATE TABLE IF NOT EXISTS endless_config (
         key TEXT PRIMARY KEY,
@@ -1009,6 +1098,41 @@ 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
+      );
+
+      -- Retrieval trace log (query -> candidates -> selected for context)
+      CREATE TABLE IF NOT EXISTS retrieval_traces (
+        trace_id TEXT PRIMARY KEY,
+        session_id TEXT,
+        project_hash TEXT,
+        query_text TEXT NOT NULL,
+        strategy TEXT,
+        candidate_event_ids TEXT,
+        selected_event_ids TEXT,
+        candidate_details_json TEXT,
+        selected_details_json TEXT,
+        candidate_count INTEGER DEFAULT 0,
+        selected_count INTEGER DEFAULT 0,
+        confidence TEXT,
+        fallback_trace TEXT,
+        created_at TEXT DEFAULT (datetime('now'))
+      );
+
       -- Sync position tracking (for SQLite -> DuckDB sync)
       CREATE TABLE IF NOT EXISTS sync_positions (
         target_name TEXT PRIMARY KEY,
@@ -1033,7 +1157,14 @@ var SQLiteEventStore = class {
       CREATE INDEX IF NOT EXISTS idx_working_set_relevance ON working_set(relevance_score);
       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_consolidated_rules_confidence ON consolidated_rules(confidence);
       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);
+      CREATE INDEX IF NOT EXISTS idx_retrieval_traces_created_at ON retrieval_traces(created_at DESC);
+      CREATE INDEX IF NOT EXISTS idx_retrieval_traces_project_hash ON retrieval_traces(project_hash);
+      CREATE INDEX IF NOT EXISTS idx_retrieval_traces_session_id ON retrieval_traces(session_id);
 
       -- FTS5 Full-Text Search for fast keyword search
       CREATE VIRTUAL TABLE IF NOT EXISTS events_fts USING fts5(
@@ -1057,6 +1188,14 @@ var SQLiteEventStore = class {
         INSERT INTO events_fts(rowid, content, event_id) VALUES (NEW.rowid, NEW.content, NEW.id);
       END;
     `);
+    try {
+      sqliteExec(this.db, `ALTER TABLE retrieval_traces ADD COLUMN selected_details_json TEXT;`);
+    } catch {
+    }
+    try {
+      sqliteExec(this.db, `ALTER TABLE retrieval_traces ADD COLUMN candidate_details_json TEXT;`);
+    } catch {
+    }
     const tableInfo = sqliteAll(this.db, "PRAGMA table_info(events)", []);
     const columnNames = tableInfo.map((col) => col.name);
     if (!columnNames.includes("access_count")) {
@@ -1077,6 +1216,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);
@@ -1089,6 +1237,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;
   }
   /**
@@ -1113,9 +1267,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 (?, ?)
@@ -1132,12 +1288,28 @@ var SQLiteEventStore = class {
           input.content,
           canonicalKey,
           dedupeKey,
-          JSON.stringify(input.metadata || {})
+          JSON.stringify(metadata),
+          turnId
         );
         insertDedup.run(dedupeKey, id);
         insertLevel.run(id);
       });
       transaction();
+      if (this.markdownMirror) {
+        const event = {
+          id,
+          eventType: input.eventType,
+          sessionId: input.sessionId,
+          timestamp: input.timestamp,
+          content: input.content,
+          canonicalKey,
+          dedupeKey,
+          metadata
+        };
+        this.markdownMirror.append(event).catch((err) => {
+          console.warn("[SQLiteEventStore] markdown mirror append failed:", err);
+        });
+      }
       return { success: true, eventId: id, isDuplicate: false };
     } catch (error) {
       return {
@@ -1196,6 +1368,92 @@ var SQLiteEventStore = class {
     );
     return rows.map(this.rowToEvent);
   }
+  /**
+   * Get events since a SQLite rowid (for robust incremental replication).
+   * Rowid is monotonic for append-only tables, independent of client timestamps.
+   */
+  async getEventsSinceRowid(lastRowid, limit = 1e3) {
+    await this.initialize();
+    const rows = sqliteAll(
+      this.db,
+      `SELECT rowid as _rowid, * FROM events WHERE rowid > ? ORDER BY rowid ASC LIMIT ?`,
+      [lastRowid, limit]
+    );
+    return rows.map((row) => ({
+      rowid: row._rowid,
+      event: this.rowToEvent(row)
+    }));
+  }
+  /**
+   * Import events with fixed IDs (used for cross-machine replication).
+   * Idempotent: skips if event id or dedupeKey already exists.
+   *
+   * NOTE: This bypasses the append() id generation to preserve stable IDs.
+   */
+  async importEvents(events) {
+    if (events.length === 0)
+      return { inserted: 0, skipped: 0 };
+    if (this.readOnly)
+      return { inserted: 0, skipped: events.length };
+    await this.initialize();
+    const getById = this.db.prepare(`SELECT id FROM events WHERE id = ?`);
+    const getByDedupe = this.db.prepare(`SELECT event_id FROM event_dedup WHERE dedupe_key = ?`);
+    const insertEvent = this.db.prepare(`
+      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 (?, ?)
+    `);
+    const insertLevel = this.db.prepare(`
+      INSERT INTO memory_levels (event_id, level) VALUES (?, 'L0')
+    `);
+    let inserted = 0;
+    let skipped = 0;
+    const insertedEvents = [];
+    const tx = this.db.transaction((batch) => {
+      for (const ev of batch) {
+        const existingById = getById.get(ev.id);
+        if (existingById) {
+          skipped++;
+          continue;
+        }
+        const canonicalKey = ev.canonicalKey || makeCanonicalKey(ev.content);
+        const dedupeKey = ev.dedupeKey || makeDedupeKey(ev.content, ev.sessionId);
+        const existingByDedupe = getByDedupe.get(dedupeKey);
+        if (existingByDedupe) {
+          skipped++;
+          continue;
+        }
+        const metadata = ev.metadata || {};
+        const turnId = metadata.turnId;
+        insertEvent.run(
+          ev.id,
+          ev.eventType,
+          ev.sessionId,
+          toSQLiteTimestamp(ev.timestamp),
+          ev.content,
+          canonicalKey,
+          dedupeKey,
+          JSON.stringify(metadata),
+          turnId ?? null
+        );
+        insertDedup.run(dedupeKey, ev.id);
+        insertLevel.run(ev.id);
+        inserted++;
+        insertedEvents.push(ev);
+      }
+    });
+    tx(events);
+    if (this.markdownMirror && insertedEvents.length > 0) {
+      for (const ev of insertedEvents) {
+        this.markdownMirror.append(ev).catch((err) => {
+          console.warn("[SQLiteEventStore] markdown mirror append failed:", err);
+        });
+      }
+    }
+    return { inserted, skipped };
+  }
   /**
    * Create or update session
    */
@@ -1358,6 +1616,35 @@ var SQLiteEventStore = class {
       [error, ...ids]
     );
   }
+  /**
+   * Get embedding/vector outbox health statistics
+   */
+  async getOutboxStats() {
+    await this.initialize();
+    const embeddingRows = sqliteAll(
+      this.db,
+      `SELECT status, COUNT(*) as count FROM embedding_outbox GROUP BY status`
+    );
+    const vectorRows = sqliteAll(
+      this.db,
+      `SELECT status, COUNT(*) as count FROM vector_outbox GROUP BY status`
+    );
+    const fromRows = (rows) => {
+      const out = { pending: 0, processing: 0, failed: 0, total: 0 };
+      for (const row of rows) {
+        const key = row.status;
+        if (key === "pending" || key === "processing" || key === "failed") {
+          out[key] += row.count;
+        }
+        out.total += row.count;
+      }
+      return out;
+    };
+    return {
+      embedding: fromRows(embeddingRows),
+      vector: fromRows(vectorRows)
+    };
+  }
   /**
    * Update memory level
    */
@@ -1482,11 +1769,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
@@ -1494,8 +1781,166 @@ 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
@@ -1558,12 +2003,222 @@ var SQLiteEventStore = class {
   getDatabase() {
     return this.db;
   }
+  async recordRetrievalTrace(input) {
+    await this.initialize();
+    const traceId = randomUUID2();
+    sqliteRun(
+      this.db,
+      `INSERT INTO retrieval_traces (
+        trace_id, session_id, project_hash, query_text, strategy,
+        candidate_event_ids, selected_event_ids, candidate_details_json, selected_details_json,
+        candidate_count, selected_count, confidence, fallback_trace
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+      [
+        traceId,
+        input.sessionId || null,
+        input.projectHash || null,
+        input.queryText,
+        input.strategy || null,
+        JSON.stringify(input.candidateEventIds || []),
+        JSON.stringify(input.selectedEventIds || []),
+        JSON.stringify(input.candidateDetails || []),
+        JSON.stringify(input.selectedDetails || []),
+        (input.candidateEventIds || []).length,
+        (input.selectedEventIds || []).length,
+        input.confidence || null,
+        JSON.stringify(input.fallbackTrace || [])
+      ]
+    );
+  }
+  async getRecentRetrievalTraces(limit = 50) {
+    await this.initialize();
+    const rows = sqliteAll(
+      this.db,
+      `SELECT * FROM retrieval_traces ORDER BY created_at DESC LIMIT ?`,
+      [limit]
+    );
+    return rows.map((row) => ({
+      traceId: row.trace_id,
+      sessionId: row.session_id || void 0,
+      projectHash: row.project_hash || void 0,
+      queryText: row.query_text,
+      strategy: row.strategy || void 0,
+      candidateEventIds: row.candidate_event_ids ? JSON.parse(row.candidate_event_ids) : [],
+      selectedEventIds: row.selected_event_ids ? JSON.parse(row.selected_event_ids) : [],
+      candidateDetails: row.candidate_details_json ? JSON.parse(row.candidate_details_json) : [],
+      selectedDetails: row.selected_details_json ? JSON.parse(row.selected_details_json) : [],
+      candidateCount: Number(row.candidate_count || 0),
+      selectedCount: Number(row.selected_count || 0),
+      confidence: row.confidence || void 0,
+      fallbackTrace: row.fallback_trace ? JSON.parse(row.fallback_trace) : [],
+      createdAt: toDateFromSQLite(row.created_at)
+    }));
+  }
+  async getRetrievalTraceStats() {
+    await this.initialize();
+    const row = sqliteGet(
+      this.db,
+      `SELECT
+        COUNT(*) as total_queries,
+        AVG(candidate_count) as avg_candidate_count,
+        AVG(selected_count) as avg_selected_count,
+        CASE
+          WHEN SUM(candidate_count) > 0 THEN (SUM(selected_count) * 1.0 / SUM(candidate_count))
+          ELSE 0
+        END as selection_rate
+       FROM retrieval_traces`,
+      []
+    );
+    return {
+      totalQueries: Number(row?.total_queries || 0),
+      avgCandidateCount: Number(row?.avg_candidate_count || 0),
+      avgSelectedCount: Number(row?.avg_selected_count || 0),
+      selectionRate: Number(row?.selection_rate || 0)
+    };
+  }
   /**
    * Close database connection
    */
   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
    */
@@ -1584,6 +2239,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;
   }
 };
@@ -1795,7 +2453,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]);
     }
@@ -1821,7 +2488,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);
     }
@@ -2261,7 +2937,20 @@ var DEFAULT_OPTIONS = {
   topK: 5,
   minScore: 0.7,
   maxTokens: 2e3,
-  includeSessionContext: true
+  includeSessionContext: true,
+  strategy: "auto",
+  rerankWithKeyword: true,
+  decayPolicy: {
+    enabled: true,
+    windowDays: 30,
+    maxPenalty: 0.15
+  },
+  graphHop: {
+    enabled: true,
+    maxHops: 1,
+    hopPenalty: 0.08
+  },
+  projectScopeMode: "global"
 };
 var Retriever = class {
   eventStore;
@@ -2271,6 +2960,7 @@ var Retriever = class {
   sharedStore;
   sharedVectorStore;
   graduation;
+  queryRewriter;
   constructor(eventStore, vectorStore, embedder, matcher, sharedOptions) {
     this.eventStore = eventStore;
     this.vectorStore = vectorStore;
@@ -2279,47 +2969,105 @@ var Retriever = class {
     this.sharedStore = sharedOptions?.sharedStore;
     this.sharedVectorStore = sharedOptions?.sharedVectorStore;
   }
-  /**
-   * Set graduation pipeline for access tracking
-   */
   setGraduationPipeline(graduation) {
     this.graduation = graduation;
   }
-  /**
-   * Set shared stores after construction
-   */
   setSharedStores(sharedStore, sharedVectorStore) {
     this.sharedStore = sharedStore;
     this.sharedVectorStore = sharedVectorStore;
   }
-  /**
-   * Retrieve relevant memories for a query
-   */
+  setQueryRewriter(rewriter) {
+    this.queryRewriter = rewriter;
+  }
   async retrieve(query, options = {}) {
     const opts = { ...DEFAULT_OPTIONS, ...options };
-    const queryEmbedding = await this.embedder.embed(query);
-    const searchResults = await this.vectorStore.search(queryEmbedding.vector, {
-      limit: opts.topK * 2,
-      // Get extra for filtering
+    const sessionFilter = opts.scope?.sessionId ?? opts.sessionId;
+    const fallbackTrace = [];
+    const fallbackEnabled = (opts.strategy ?? "auto") === "auto";
+    const primaryStrategy = opts.strategy === "auto" ? "fast" : opts.strategy || "fast";
+    let current = await this.runStage(query, {
+      strategy: primaryStrategy,
+      topK: opts.topK,
       minScore: opts.minScore,
-      sessionId: opts.sessionId
+      sessionId: sessionFilter,
+      scope: opts.scope,
+      rerankWithKeyword: opts.rerankWithKeyword !== false,
+      rerankWeights: opts.rerankWeights,
+      decayPolicy: opts.decayPolicy,
+      intentRewrite: opts.intentRewrite === true,
+      graphHop: opts.graphHop,
+      projectScopeMode: opts.projectScopeMode,
+      projectHash: opts.projectHash,
+      allowedProjectHashes: opts.allowedProjectHashes
     });
-    const matchResult = this.matcher.matchSearchResults(
-      searchResults,
-      (eventId) => this.getEventAgeDays(eventId)
-    );
-    const memories = await this.enrichResults(searchResults.slice(0, opts.topK), opts);
+    fallbackTrace.push(`stage:primary:${primaryStrategy}`);
+    if (fallbackEnabled && this.shouldFallback(current.matchResult, current.results) && primaryStrategy !== "deep") {
+      current = await this.runStage(query, {
+        strategy: "deep",
+        topK: opts.topK,
+        minScore: opts.minScore,
+        sessionId: sessionFilter,
+        scope: opts.scope,
+        rerankWithKeyword: opts.rerankWithKeyword !== false,
+        rerankWeights: opts.rerankWeights,
+        decayPolicy: opts.decayPolicy,
+        graphHop: opts.graphHop,
+        projectScopeMode: opts.projectScopeMode,
+        projectHash: opts.projectHash,
+        allowedProjectHashes: opts.allowedProjectHashes
+      });
+      fallbackTrace.push("fallback:deep");
+    }
+    if (fallbackEnabled && this.shouldFallback(current.matchResult, current.results)) {
+      current = await this.runStage(query, {
+        strategy: "deep",
+        topK: opts.topK,
+        minScore: Math.max(0.5, opts.minScore - 0.15),
+        sessionId: void 0,
+        scope: void 0,
+        rerankWithKeyword: true,
+        rerankWeights: opts.rerankWeights,
+        decayPolicy: opts.decayPolicy,
+        graphHop: opts.graphHop,
+        projectScopeMode: opts.projectScopeMode,
+        projectHash: opts.projectHash,
+        allowedProjectHashes: opts.allowedProjectHashes
+      });
+      fallbackTrace.push("fallback:scope-expanded");
+    }
+    if (fallbackEnabled && this.shouldFallback(current.matchResult, current.results)) {
+      const summary = await this.buildSummaryFallback(query, opts.topK);
+      current = {
+        results: summary,
+        candidateResults: summary,
+        matchResult: this.matcher.matchSearchResults(summary, () => 0)
+      };
+      fallbackTrace.push("fallback:summary");
+    }
+    const memories = await this.enrichResults(current.results.slice(0, opts.topK), opts);
     const context = this.buildContext(memories, opts.maxTokens);
     return {
       memories,
-      matchResult,
+      matchResult: current.matchResult,
       totalTokens: this.estimateTokens(context),
-      context
+      context,
+      fallbackTrace,
+      selectedDebug: current.results.slice(0, opts.topK).map((r) => ({
+        eventId: r.eventId,
+        score: r.score,
+        semanticScore: r.semanticScore,
+        lexicalScore: r.lexicalScore,
+        recencyScore: r.recencyScore
+      })),
+      candidateDebug: (current.candidateResults || []).slice(0, Math.max(opts.topK * 3, 20)).map((r) => ({
+        eventId: r.eventId,
+        score: r.score,
+        semanticScore: r.semanticScore,
+        lexicalScore: r.lexicalScore,
+        recencyScore: r.recencyScore
+      }))
     };
   }
-  /**
-   * Retrieve with unified search (project + shared)
-   */
   async retrieveUnified(query, options = {}) {
     const projectResult = await this.retrieve(query, options);
     if (!options.includeShared || !this.sharedStore || !this.sharedVectorStore) {
@@ -2327,22 +3075,19 @@ var Retriever = class {
     }
     try {
       const queryEmbedding = await this.embedder.embed(query);
-      const sharedVectorResults = await this.sharedVectorStore.search(
-        queryEmbedding.vector,
-        {
-          limit: options.topK || 5,
-          minScore: options.minScore || 0.7,
-          excludeProjectHash: options.projectHash
-        }
-      );
+      const sharedVectorResults = await this.sharedVectorStore.search(queryEmbedding.vector, {
+        limit: options.topK || 5,
+        minScore: options.minScore || 0.7,
+        excludeProjectHash: options.projectHash
+      });
       const sharedMemories = [];
       for (const result of sharedVectorResults) {
         const entry = await this.sharedStore.get(result.entryId);
-        if (entry) {
-          if (!options.projectHash || entry.sourceProjectHash !== options.projectHash) {
-            sharedMemories.push(entry);
-            await this.sharedStore.recordUsage(entry.entryId);
-          }
+        if (!entry)
+          continue;
+        if (!options.projectHash || entry.sourceProjectHash !== options.projectHash) {
+          sharedMemories.push(entry);
+          await this.sharedStore.recordUsage(entry.entryId);
         }
       }
       const unifiedContext = this.buildUnifiedContext(projectResult, sharedMemories);
@@ -2357,50 +3102,243 @@ var Retriever = class {
       return projectResult;
     }
   }
-  /**
-   * Build unified context combining project and shared memories
-   */
-  buildUnifiedContext(projectResult, sharedMemories) {
-    let context = projectResult.context;
-    if (sharedMemories.length > 0) {
-      context += "\n\n## Cross-Project Knowledge\n\n";
-      for (const memory of sharedMemories.slice(0, 3)) {
-        context += `### ${memory.title}
-`;
-        if (memory.symptoms.length > 0) {
-          context += `**Symptoms:** ${memory.symptoms.join(", ")}
-`;
-        }
-        context += `**Root Cause:** ${memory.rootCause}
-`;
-        context += `**Solution:** ${memory.solution}
-`;
-        if (memory.technologies && memory.technologies.length > 0) {
-          context += `**Technologies:** ${memory.technologies.join(", ")}
-`;
+  async runStage(query, input) {
+    let initialResults = await this.searchByStrategy(query, {
+      strategy: input.strategy,
+      topK: input.topK,
+      minScore: input.minScore,
+      sessionId: input.sessionId
+    });
+    if (input.intentRewrite && input.strategy === "deep" && this.queryRewriter) {
+      const rewritten = (await this.queryRewriter(query))?.trim();
+      if (rewritten && rewritten !== query) {
+        const rewrittenResults = await this.searchByStrategy(rewritten, {
+          strategy: "deep",
+          topK: input.topK,
+          minScore: Math.max(0.5, input.minScore - 0.1),
+          sessionId: input.sessionId
+        });
+        initialResults = this.mergeResults(initialResults, rewrittenResults, input.topK * 3);
+      }
+    }
+    const expandedResults = input.graphHop?.enabled === false ? initialResults : await this.expandGraphHops(initialResults, {
+      maxHops: Math.max(1, input.graphHop?.maxHops ?? 1),
+      hopPenalty: Math.max(0, input.graphHop?.hopPenalty ?? 0.08),
+      limit: input.topK * 4
+    });
+    const rerankedResults = input.rerankWithKeyword ? this.rerankByKeywordOverlap(expandedResults, query, input.rerankWeights, input.decayPolicy) : expandedResults;
+    const filtered = await this.applyScopeFilters(rerankedResults, {
+      scope: input.scope,
+      projectScopeMode: input.projectScopeMode,
+      projectHash: input.projectHash,
+      allowedProjectHashes: input.allowedProjectHashes
+    });
+    const top = filtered.slice(0, input.topK);
+    const matchResult = this.matcher.matchSearchResults(top, () => 0);
+    return { results: top, candidateResults: filtered, matchResult };
+  }
+  mergeResults(primary, secondary, limit) {
+    const byId = /* @__PURE__ */ new Map();
+    for (const row of primary)
+      byId.set(row.eventId, row);
+    for (const row of secondary) {
+      const prev = byId.get(row.eventId);
+      if (!prev || row.score > prev.score) {
+        byId.set(row.eventId, row);
+      }
+    }
+    return [...byId.values()].sort((a, b) => b.score - a.score).slice(0, limit);
+  }
+  async expandGraphHops(seeds, opts) {
+    const byId = /* @__PURE__ */ new Map();
+    for (const s of seeds)
+      byId.set(s.eventId, s);
+    let frontier = seeds.map((s) => ({ row: s, hop: 0 }));
+    for (let hop = 1; hop <= opts.maxHops; hop += 1) {
+      const next = [];
+      for (const f of frontier) {
+        const ev = await this.eventStore.getEvent(f.row.eventId);
+        if (!ev)
+          continue;
+        const rel = ev.metadata?.relatedEventIds ?? [];
+        const relatedIds = Array.isArray(rel) ? rel.filter((x) => typeof x === "string") : [];
+        for (const rid of relatedIds) {
+          if (byId.has(rid))
+            continue;
+          const target = await this.eventStore.getEvent(rid);
+          if (!target)
+            continue;
+          const score = Math.max(0, f.row.score - opts.hopPenalty * hop);
+          const row = {
+            id: `hop-${hop}-${rid}`,
+            eventId: target.id,
+            content: target.content,
+            score,
+            sessionId: target.sessionId,
+            eventType: target.eventType,
+            timestamp: target.timestamp.toISOString()
+          };
+          byId.set(row.eventId, row);
+          next.push({ row, hop });
+          if (byId.size >= opts.limit)
+            break;
         }
-        context += `_Confidence: ${(memory.confidence * 100).toFixed(0)}%_
-
-`;
+        if (byId.size >= opts.limit)
+          break;
       }
+      frontier = next;
+      if (frontier.length === 0 || byId.size >= opts.limit)
+        break;
     }
-    return context;
+    return [...byId.values()].sort((a, b) => b.score - a.score).slice(0, opts.limit);
+  }
+  shouldFallback(matchResult, results) {
+    if (results.length === 0)
+      return true;
+    if (matchResult.confidence === "none")
+      return true;
+    return false;
+  }
+  async buildSummaryFallback(query, topK) {
+    const recent = await this.eventStore.getRecentEvents(Math.max(topK * 6, 20));
+    const q = this.tokenize(query);
+    const ranked = recent.map((e) => ({ e, overlap: this.keywordOverlap(q, this.tokenize(e.content)) })).filter((r) => r.overlap > 0).sort((a, b) => b.overlap - a.overlap).slice(0, topK).map((row, idx) => ({
+      id: `summary-${row.e.id}`,
+      eventId: row.e.id,
+      content: row.e.content,
+      score: Math.max(0.25, 0.6 - idx * 0.05),
+      sessionId: row.e.sessionId,
+      eventType: row.e.eventType,
+      timestamp: row.e.timestamp.toISOString()
+    }));
+    return ranked;
+  }
+  async searchByStrategy(query, input) {
+    const strategy = input.strategy === "auto" ? "deep" : input.strategy;
+    if (strategy === "fast") {
+      const keyword = await this.searchByKeyword(query, {
+        limit: Math.max(5, input.topK * 3),
+        sessionId: input.sessionId
+      });
+      return keyword;
+    }
+    const queryEmbedding = await this.embedder.embed(query);
+    return this.vectorStore.search(queryEmbedding.vector, {
+      limit: Math.max(5, input.topK * 3),
+      minScore: input.minScore,
+      sessionId: input.sessionId
+    });
+  }
+  async searchByKeyword(query, input) {
+    if (this.eventStore.keywordSearch) {
+      const rows = await this.eventStore.keywordSearch(query, input.limit);
+      const filtered2 = input.sessionId ? rows.filter((r) => r.event.sessionId === input.sessionId) : rows;
+      return filtered2.map((row, idx) => ({
+        id: `kw-${row.event.id}`,
+        eventId: row.event.id,
+        content: row.event.content,
+        score: Math.max(0.4, 1 - idx * 0.04),
+        sessionId: row.event.sessionId,
+        eventType: row.event.eventType,
+        timestamp: row.event.timestamp.toISOString()
+      }));
+    }
+    const recent = await this.eventStore.getRecentEvents(input.limit * 4);
+    const tokens = this.tokenize(query);
+    const filtered = recent.filter((e) => input.sessionId ? e.sessionId === input.sessionId : true).map((e) => ({ e, overlap: this.keywordOverlap(tokens, this.tokenize(e.content)) })).filter((r) => r.overlap > 0).sort((a, b) => b.overlap - a.overlap).slice(0, input.limit);
+    return filtered.map((row, idx) => ({
+      id: `kw-fallback-${row.e.id}`,
+      eventId: row.e.id,
+      content: row.e.content,
+      score: Math.max(0.3, 0.9 - idx * 0.05),
+      sessionId: row.e.sessionId,
+      eventType: row.e.eventType,
+      timestamp: row.e.timestamp.toISOString()
+    }));
+  }
+  rerankByKeywordOverlap(results, query, weights, decayPolicy) {
+    const q = this.tokenize(query);
+    const now = Date.now();
+    const sw = Math.max(0, weights?.semantic ?? 0.7);
+    const lw = Math.max(0, weights?.lexical ?? 0.2);
+    const rw = Math.max(0, weights?.recency ?? 0.1);
+    const total = sw + lw + rw || 1;
+    const decayEnabled = decayPolicy?.enabled !== false;
+    const decayWindow = Math.max(1, decayPolicy?.windowDays ?? 30);
+    const decayMaxPenalty = Math.max(0, decayPolicy?.maxPenalty ?? 0.15);
+    return [...results].map((r) => {
+      const overlap = this.keywordOverlap(q, this.tokenize(r.content));
+      const recencyDays = Math.max(0, (now - new Date(r.timestamp).getTime()) / (1e3 * 60 * 60 * 24));
+      const recency = Math.max(0, 1 - recencyDays / decayWindow);
+      let blended = (r.score * sw + overlap * lw + recency * rw) / total;
+      if (decayEnabled && recencyDays > decayWindow && overlap < 0.5) {
+        const ageFactor = Math.min(1, (recencyDays - decayWindow) / decayWindow);
+        blended -= decayMaxPenalty * ageFactor;
+      }
+      return { ...r, score: Math.max(0, blended), semanticScore: r.score, lexicalScore: overlap, recencyScore: recency };
+    }).sort((a, b) => b.score - a.score);
+  }
+  async applyScopeFilters(results, options) {
+    const scope = options?.scope;
+    const projectScopeMode = options?.projectScopeMode ?? "global";
+    const allowedProjectHashes = new Set(
+      [options?.projectHash, ...options?.allowedProjectHashes || []].filter(
+        (value) => typeof value === "string" && value.length > 0
+      )
+    );
+    if (!scope && projectScopeMode === "global")
+      return results;
+    const normalizedIncludes = (scope?.contentIncludes || []).map((s) => s.toLowerCase());
+    const filtered = [];
+    for (const result of results) {
+      if (scope?.sessionId && result.sessionId !== scope.sessionId)
+        continue;
+      if (scope?.sessionIdPrefix && !result.sessionId.startsWith(scope.sessionIdPrefix))
+        continue;
+      if (scope?.eventTypes && scope.eventTypes.length > 0 && !scope.eventTypes.includes(result.eventType))
+        continue;
+      const event = await this.eventStore.getEvent(result.eventId);
+      if (!event)
+        continue;
+      if (scope?.canonicalKeyPrefix && !event.canonicalKey.startsWith(scope.canonicalKeyPrefix))
+        continue;
+      if (normalizedIncludes.length > 0) {
+        const lc = event.content.toLowerCase();
+        if (!normalizedIncludes.some((needle) => lc.includes(needle)))
+          continue;
+      }
+      if (scope?.metadata && !this.matchesMetadataScope(event.metadata, scope.metadata))
+        continue;
+      const projectHash = this.extractProjectHash(event.metadata);
+      filtered.push({ result, projectHash });
+    }
+    if (projectScopeMode === "global" || allowedProjectHashes.size === 0) {
+      return filtered.map((x) => x.result);
+    }
+    const projectMatched = filtered.filter((x) => x.projectHash && allowedProjectHashes.has(x.projectHash));
+    if (projectScopeMode === "strict") {
+      return projectMatched.map((x) => x.result);
+    }
+    return (projectMatched.length > 0 ? projectMatched : filtered).map((x) => x.result);
+  }
+  extractProjectHash(metadata) {
+    if (!metadata || typeof metadata !== "object")
+      return void 0;
+    const scope = metadata.scope;
+    if (!scope || typeof scope !== "object")
+      return void 0;
+    const project = scope.project;
+    if (!project || typeof project !== "object")
+      return void 0;
+    const hash = project.hash;
+    return typeof hash === "string" && hash.length > 0 ? hash : void 0;
   }
-  /**
-   * Retrieve memories from a specific session
-   */
   async retrieveFromSession(sessionId) {
     return this.eventStore.getSessionEvents(sessionId);
   }
-  /**
-   * Get recent memories across all sessions
-   */
   async retrieveRecent(limit = 100) {
     return this.eventStore.getRecentEvents(limit);
   }
-  /**
-   * Enrich search results with full event data
-   */
   async enrichResults(results, options) {
     const memories = [];
     for (const result of results) {
@@ -2408,27 +3346,16 @@ var Retriever = class {
       if (!event)
         continue;
       if (this.graduation) {
-        this.graduation.recordAccess(
-          event.id,
-          options.sessionId || "unknown",
-          result.score
-        );
+        this.graduation.recordAccess(event.id, options.sessionId || "unknown", result.score);
       }
       let sessionContext;
       if (options.includeSessionContext) {
         sessionContext = await this.getSessionContext(event.sessionId, event.id);
       }
-      memories.push({
-        event,
-        score: result.score,
-        sessionContext
-      });
+      memories.push({ event, score: result.score, sessionContext });
     }
     return memories;
   }
-  /**
-   * Get surrounding context from the same session
-   */
   async getSessionContext(sessionId, eventId) {
     const sessionEvents = await this.eventStore.getSessionEvents(sessionId);
     const eventIndex = sessionEvents.findIndex((e) => e.id === eventId);
@@ -2441,55 +3368,86 @@ var Retriever = class {
       return void 0;
     return contextEvents.filter((e) => e.id !== eventId).map((e) => `[${e.eventType}]: ${e.content.slice(0, 200)}...`).join("\n");
   }
-  /**
-   * Build context string from memories (respecting token limit)
-   */
+  buildUnifiedContext(projectResult, sharedMemories) {
+    let context = projectResult.context;
+    if (sharedMemories.length === 0)
+      return context;
+    context += "\n\n## Cross-Project Knowledge\n\n";
+    for (const memory of sharedMemories.slice(0, 3)) {
+      context += `### ${memory.title}
+`;
+      if (memory.symptoms.length > 0)
+        context += `**Symptoms:** ${memory.symptoms.join(", ")}
+`;
+      context += `**Root Cause:** ${memory.rootCause}
+`;
+      context += `**Solution:** ${memory.solution}
+`;
+      if (memory.technologies && memory.technologies.length > 0)
+        context += `**Technologies:** ${memory.technologies.join(", ")}
+`;
+      context += `_Confidence: ${(memory.confidence * 100).toFixed(0)}%_
+
+`;
+    }
+    return context;
+  }
   buildContext(memories, maxTokens) {
     const parts = [];
     let currentTokens = 0;
     for (const memory of memories) {
       const memoryText = this.formatMemory(memory);
       const memoryTokens = this.estimateTokens(memoryText);
-      if (currentTokens + memoryTokens > maxTokens) {
+      if (currentTokens + memoryTokens > maxTokens)
         break;
-      }
       parts.push(memoryText);
       currentTokens += memoryTokens;
     }
-    if (parts.length === 0) {
+    if (parts.length === 0)
       return "";
-    }
     return `## Relevant Memories
 
 ${parts.join("\n\n---\n\n")}`;
   }
-  /**
-   * Format a single memory for context
-   */
   formatMemory(memory) {
     const { event, score, sessionContext } = memory;
     const date = event.timestamp.toISOString().split("T")[0];
     let text = `**${event.eventType}** (${date}, score: ${score.toFixed(2)})
 ${event.content}`;
-    if (sessionContext) {
+    if (sessionContext)
       text += `
 
 _Context:_ ${sessionContext}`;
-    }
     return text;
   }
-  /**
-   * Estimate token count (rough approximation)
-   */
+  matchesMetadataScope(metadata, expected) {
+    if (!metadata)
+      return false;
+    return Object.entries(expected).every(([path4, value]) => {
+      const actual = path4.split(".").reduce((acc, key) => {
+        if (typeof acc !== "object" || acc === null)
+          return void 0;
+        return acc[key];
+      }, metadata);
+      return actual === value;
+    });
+  }
+  tokenize(text) {
+    return text.toLowerCase().replace(/[^\p{L}\p{N}\s]/gu, " ").split(/\s+/).filter((t) => t.length >= 2).slice(0, 64);
+  }
+  keywordOverlap(a, b) {
+    if (a.length === 0 || b.length === 0)
+      return 0;
+    const bs = new Set(b);
+    let hit = 0;
+    for (const t of a)
+      if (bs.has(t))
+        hit += 1;
+    return hit / a.length;
+  }
   estimateTokens(text) {
     return Math.ceil(text.length / 4);
   }
-  /**
-   * Get event age in days (for recency scoring)
-   */
-  getEventAgeDays(eventId) {
-    return 0;
-  }
 };
 function createRetriever(eventStore, vectorStore, embedder, matcher) {
   return new Retriever(eventStore, vectorStore, embedder, matcher);
@@ -3779,6 +4737,59 @@ var ConsolidatedStore = class {
       [memoryId]
     );
   }
+  /**
+   * Create a long-term rule promoted from stable summaries
+   */
+  async createRule(input) {
+    const ruleId = randomUUID6();
+    await dbRun(
+      this.db,
+      `INSERT INTO consolidated_rules
+        (rule_id, rule, topics, source_memory_ids, source_events, confidence, created_at)
+       VALUES (?, ?, ?, ?, ?, ?, CURRENT_TIMESTAMP)`,
+      [
+        ruleId,
+        input.rule,
+        JSON.stringify(input.topics),
+        JSON.stringify(input.sourceMemoryIds),
+        JSON.stringify(input.sourceEvents),
+        input.confidence
+      ]
+    );
+    return ruleId;
+  }
+  async getRules(options) {
+    const limit = options?.limit || 100;
+    const rows = await dbAll(
+      this.db,
+      `SELECT * FROM consolidated_rules ORDER BY confidence DESC, created_at DESC LIMIT ?`,
+      [limit]
+    );
+    return rows.map((row) => ({
+      ruleId: row.rule_id,
+      rule: row.rule,
+      topics: JSON.parse(row.topics || "[]"),
+      sourceMemoryIds: JSON.parse(row.source_memory_ids || "[]"),
+      sourceEvents: JSON.parse(row.source_events || "[]"),
+      confidence: Number(row.confidence ?? 0.5),
+      createdAt: toDate(row.created_at) || /* @__PURE__ */ new Date()
+    }));
+  }
+  async countRules() {
+    const result = await dbAll(
+      this.db,
+      `SELECT COUNT(*) as count FROM consolidated_rules`
+    );
+    return result[0]?.count || 0;
+  }
+  async hasRuleForSourceMemory(memoryId) {
+    const rows = await dbAll(
+      this.db,
+      `SELECT COUNT(*) as count FROM consolidated_rules WHERE source_memory_ids LIKE ?`,
+      [`%"${memoryId}"%`]
+    );
+    return (rows[0]?.count || 0) > 0;
+  }
   /**
    * Get count of consolidated memories
    */
@@ -3928,7 +4939,14 @@ var ConsolidationWorker = class {
    * Force a consolidation run (manual trigger)
    */
   async forceRun() {
-    return await this.consolidate();
+    const out = await this.consolidateWithReport();
+    return out.consolidatedCount;
+  }
+  /**
+   * Force a consolidation run and return metrics report
+   */
+  async forceRunWithReport() {
+    return this.consolidateWithReport();
   }
   /**
    * Schedule the next consolidation check
@@ -3968,12 +4986,21 @@ var ConsolidationWorker = class {
    * Perform consolidation
    */
   async consolidate() {
+    const out = await this.consolidateWithReport();
+    return out.consolidatedCount;
+  }
+  async consolidateWithReport() {
     const workingSet = await this.workingSetStore.get();
     if (workingSet.recentEvents.length < 3) {
-      return 0;
+      return {
+        consolidatedCount: 0,
+        promotedRuleCount: 0,
+        report: this.buildCostQualityReport(workingSet.recentEvents, [], 0)
+      };
     }
     const groups = this.groupByTopic(workingSet.recentEvents);
     let consolidatedCount = 0;
+    const createdMemoryIds = [];
     for (const group of groups) {
       if (group.events.length < 3)
         continue;
@@ -3982,14 +5009,16 @@ var ConsolidationWorker = class {
       if (alreadyConsolidated)
         continue;
       const summary = await this.summarize(group);
-      await this.consolidatedStore.create({
+      const memoryId = await this.consolidatedStore.create({
         summary,
         topics: group.topics,
         sourceEvents: eventIds,
         confidence: this.calculateConfidence(group)
       });
+      createdMemoryIds.push(memoryId);
       consolidatedCount++;
     }
+    const promotedRuleCount = await this.promoteStableSummariesToRules(createdMemoryIds);
     if (consolidatedCount > 0) {
       const consolidatedEventIds = groups.filter((g) => g.events.length >= 3).flatMap((g) => g.events.map((e) => e.id));
       const oldEventIds = consolidatedEventIds.filter((id) => {
@@ -4003,7 +5032,61 @@ var ConsolidationWorker = class {
         await this.workingSetStore.prune(oldEventIds);
       }
     }
-    return consolidatedCount;
+    const report = this.buildCostQualityReport(workingSet.recentEvents, groups, consolidatedCount);
+    return { consolidatedCount, promotedRuleCount, report };
+  }
+  async promoteStableSummariesToRules(memoryIds) {
+    let promoted = 0;
+    for (const memoryId of memoryIds) {
+      const memory = await this.consolidatedStore.get(memoryId);
+      if (!memory)
+        continue;
+      if (memory.confidence < 0.55)
+        continue;
+      if (memory.sourceEvents.length < 4)
+        continue;
+      const exists = await this.consolidatedStore.hasRuleForSourceMemory(memoryId);
+      if (exists)
+        continue;
+      const rule = this.buildRuleFromSummary(memory.summary, memory.topics);
+      if (!rule)
+        continue;
+      await this.consolidatedStore.createRule({
+        rule,
+        topics: memory.topics,
+        sourceMemoryIds: [memory.memoryId],
+        sourceEvents: memory.sourceEvents,
+        confidence: Math.min(1, memory.confidence + 0.08)
+      });
+      promoted++;
+    }
+    return promoted;
+  }
+  buildRuleFromSummary(summary, topics) {
+    const lines = summary.split(/\r?\n/).map((l) => l.trim()).filter(Boolean).filter((l) => !l.toLowerCase().startsWith("topics:"));
+    const bullet = lines.find((l) => l.startsWith("- "))?.replace(/^-\s*/, "");
+    const seed = bullet || lines[0];
+    if (!seed || seed.length < 8)
+      return null;
+    const topicPrefix = topics.length > 0 ? `[${topics.slice(0, 2).join(", ")}] ` : "";
+    return `${topicPrefix}${seed}`;
+  }
+  buildCostQualityReport(events, groups, consolidatedCount) {
+    const beforeTokenEstimate = events.reduce((acc, e) => acc + this.estimateTokens(e.content), 0);
+    const afterSummaries = groups.filter((g) => g.events.length >= 3).slice(0, Math.max(consolidatedCount, 1));
+    const afterTokenEstimate = afterSummaries.length > 0 ? afterSummaries.reduce((acc, g) => acc + this.estimateTokens(this.ruleBasedSummary(g)), 0) : beforeTokenEstimate;
+    const reductionRatio = beforeTokenEstimate > 0 ? Math.max(0, (beforeTokenEstimate - afterTokenEstimate) / beforeTokenEstimate) : 0;
+    const qualityGuardPassed = consolidatedCount === 0 ? true : groups.filter((g) => g.events.length >= 3).every((g) => this.calculateConfidence(g) >= 0.55);
+    return {
+      beforeTokenEstimate,
+      afterTokenEstimate,
+      reductionRatio,
+      qualityGuardPassed,
+      details: `groups=${groups.length}, consolidated=${consolidatedCount}`
+    };
+  }
+  estimateTokens(text) {
+    return Math.ceil((text || "").length / 4);
   }
   /**
    * Check if consolidation should run
@@ -4563,13 +5646,185 @@ function createGraduationWorker(eventStore, graduation, config) {
   );
 }
 
+// src/core/md-mirror.ts
+import * as fs3 from "node:fs";
+import * as path2 from "node:path";
+function sanitizeSegment2(input, fallback) {
+  const v = (input || "").trim().toLowerCase().replace(/[^a-z0-9._-]+/g, "-").replace(/^-+|-+$/g, "");
+  return v || fallback;
+}
+function getAtPath(obj, dotted) {
+  if (!obj)
+    return void 0;
+  return dotted.split(".").reduce((acc, key) => {
+    if (!acc || typeof acc !== "object")
+      return void 0;
+    return acc[key];
+  }, obj);
+}
+function buildMirrorPath2(rootDir, event) {
+  const meta = event.metadata;
+  const namespaceRaw = getAtPath(meta, "namespace") ?? getAtPath(meta, "scope.namespace") ?? event.eventType;
+  const namespace = sanitizeSegment2(typeof namespaceRaw === "string" ? namespaceRaw : void 0, "general");
+  const categoryRaw = getAtPath(meta, "categoryPath") ?? getAtPath(meta, "scope.categoryPath");
+  const categoryPath = Array.isArray(categoryRaw) && categoryRaw.length > 0 ? categoryRaw.map((x) => sanitizeSegment2(typeof x === "string" ? x : void 0, "uncategorized")) : ["uncategorized"];
+  const d = event.timestamp;
+  const yyyy = d.getFullYear();
+  const mm = String(d.getMonth() + 1).padStart(2, "0");
+  const dd = String(d.getDate()).padStart(2, "0");
+  return path2.join(rootDir, "memory", namespace, ...categoryPath, `${yyyy}-${mm}-${dd}.md`);
+}
+var MarkdownMirror2 = class {
+  constructor(rootDir) {
+    this.rootDir = rootDir;
+  }
+  async append(event, eventId) {
+    const out = buildMirrorPath2(this.rootDir, event);
+    fs3.mkdirSync(path2.dirname(out), { recursive: true });
+    const lines = [
+      "",
+      `## ${event.timestamp.toISOString()} | ${eventId ?? "pending-id"}`,
+      `- type: ${event.eventType}`,
+      `- session: ${event.sessionId}`,
+      event.content
+    ];
+    await fs3.promises.appendFile(out, lines.join("\n"), "utf8");
+    await this.refreshIndex();
+  }
+  async refreshIndex() {
+    const memoryRoot = path2.join(this.rootDir, "memory");
+    await fs3.promises.mkdir(memoryRoot, { recursive: true });
+    const files = [];
+    await this.walk(memoryRoot, files);
+    const mdFiles = files.filter((f) => f.endsWith(".md")).map((f) => path2.relative(this.rootDir, f)).filter((rel) => rel !== path2.join("memory", "_index.md")).sort();
+    const index = [
+      "# Memory Index",
+      "",
+      "Generated automatically by MarkdownMirror.",
+      "",
+      ...mdFiles.map((rel) => `- ${rel}`),
+      ""
+    ].join("\n");
+    await fs3.promises.writeFile(path2.join(memoryRoot, "_index.md"), index, "utf8");
+  }
+  async walk(dir, out) {
+    const entries = await fs3.promises.readdir(dir, { withFileTypes: true });
+    for (const e of entries) {
+      const full = path2.join(dir, e.name);
+      if (e.isDirectory()) {
+        await this.walk(full, out);
+      } else {
+        out.push(full);
+      }
+    }
+  }
+};
+
+// src/core/ingest-interceptor.ts
+var IngestInterceptorRegistry = class {
+  before = [];
+  after = [];
+  onError = [];
+  registerBefore(interceptor) {
+    this.before.push(interceptor);
+    return () => {
+      this.before = this.before.filter((i) => i !== interceptor);
+    };
+  }
+  registerAfter(interceptor) {
+    this.after.push(interceptor);
+    return () => {
+      this.after = this.after.filter((i) => i !== interceptor);
+    };
+  }
+  registerOnError(interceptor) {
+    this.onError.push(interceptor);
+    return () => {
+      this.onError = this.onError.filter((i) => i !== interceptor);
+    };
+  }
+  async run(stage, context) {
+    const interceptors = stage === "before" ? this.before : stage === "after" ? this.after : this.onError;
+    for (const interceptor of interceptors) {
+      await interceptor({ ...context, stage });
+    }
+  }
+};
+function mergeHierarchicalMetadata(base, patch) {
+  if (!base && !patch)
+    return void 0;
+  if (!base)
+    return patch;
+  if (!patch)
+    return base;
+  const result = { ...base };
+  for (const [key, value] of Object.entries(patch)) {
+    const current = result[key];
+    if (typeof current === "object" && current !== null && !Array.isArray(current) && typeof value === "object" && value !== null && !Array.isArray(value)) {
+      result[key] = mergeHierarchicalMetadata(
+        current,
+        value
+      );
+    } else {
+      result[key] = value;
+    }
+  }
+  return result;
+}
+
+// src/core/tag-taxonomy.ts
+var TAG_NAMESPACES = {
+  SYSTEM: "sys:",
+  QUALITY: "q:",
+  PROJECT: "proj:",
+  TOPIC: "topic:",
+  TEMPORAL: "t:",
+  USER: "user:",
+  AGENT: "agent:"
+};
+var VALID_TAG_NAMESPACES = new Set(Object.values(TAG_NAMESPACES));
+function parseTag(tag) {
+  const value = (tag || "").trim();
+  const idx = value.indexOf(":");
+  if (idx <= 0)
+    return { value };
+  const namespace = `${value.slice(0, idx)}:`;
+  const tagValue = value.slice(idx + 1);
+  if (!tagValue)
+    return { value };
+  return { namespace, value: tagValue };
+}
+function validateTag(tag) {
+  const normalized = (tag || "").trim();
+  if (!normalized)
+    return false;
+  const { namespace } = parseTag(normalized);
+  if (!namespace)
+    return true;
+  return VALID_TAG_NAMESPACES.has(namespace);
+}
+function normalizeTags(tags) {
+  if (!Array.isArray(tags))
+    return [];
+  const dedup = /* @__PURE__ */ new Set();
+  for (const item of tags) {
+    if (typeof item !== "string")
+      continue;
+    const normalized = item.trim();
+    if (!validateTag(normalized))
+      continue;
+    dedup.add(normalized);
+  }
+  return [...dedup];
+}
+
 // src/services/memory-service.ts
 function normalizePath(projectPath) {
-  const expanded = projectPath.startsWith("~") ? path.join(os.homedir(), projectPath.slice(1)) : projectPath;
+  const expanded = projectPath.startsWith("~") ? path3.join(os.homedir(), projectPath.slice(1)) : projectPath;
   try {
-    return fs.realpathSync(expanded);
+    return fs4.realpathSync(expanded);
   } catch {
-    return path.resolve(expanded);
+    return path3.resolve(expanded);
   }
 }
 function hashProjectPath(projectPath) {
@@ -4578,14 +5833,14 @@ function hashProjectPath(projectPath) {
 }
 function getProjectStoragePath(projectPath) {
   const hash = hashProjectPath(projectPath);
-  return path.join(os.homedir(), ".claude-code", "memory", "projects", hash);
+  return path3.join(os.homedir(), ".claude-code", "memory", "projects", hash);
 }
-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");
+var REGISTRY_PATH = path3.join(os.homedir(), ".claude-code", "memory", "session-registry.json");
+var SHARED_STORAGE_PATH = path3.join(os.homedir(), ".claude-code", "memory", "shared");
 function loadSessionRegistry() {
   try {
-    if (fs.existsSync(REGISTRY_PATH)) {
-      const data = fs.readFileSync(REGISTRY_PATH, "utf-8");
+    if (fs4.existsSync(REGISTRY_PATH)) {
+      const data = fs4.readFileSync(REGISTRY_PATH, "utf-8");
       return JSON.parse(data);
     }
   } catch (error) {
@@ -4594,13 +5849,13 @@ function loadSessionRegistry() {
   return { version: 1, sessions: {} };
 }
 function saveSessionRegistry(registry) {
-  const dir = path.dirname(REGISTRY_PATH);
-  if (!fs.existsSync(dir)) {
-    fs.mkdirSync(dir, { recursive: true });
+  const dir = path3.dirname(REGISTRY_PATH);
+  if (!fs4.existsSync(dir)) {
+    fs4.mkdirSync(dir, { recursive: true });
   }
   const tempPath = REGISTRY_PATH + ".tmp";
-  fs.writeFileSync(tempPath, JSON.stringify(registry, null, 2));
-  fs.renameSync(tempPath, REGISTRY_PATH);
+  fs4.writeFileSync(tempPath, JSON.stringify(registry, null, 2));
+  fs4.renameSync(tempPath, REGISTRY_PATH);
 }
 function registerSession(sessionId, projectPath) {
   const registry = loadSessionRegistry();
@@ -4632,6 +5887,7 @@ var MemoryService = class {
   vectorWorker = null;
   graduationWorker = null;
   initialized = false;
+  ingestInterceptors = new IngestInterceptorRegistry();
   // Endless Mode components
   workingSetStore = null;
   consolidatedStore = null;
@@ -4645,20 +5901,27 @@ var MemoryService = class {
   sharedPromoter = null;
   sharedStoreConfig = null;
   projectHash = null;
+  projectPath = null;
   readOnly;
   lightweightMode;
+  mdMirror;
   constructor(config) {
     const storagePath = this.expandPath(config.storagePath);
     this.readOnly = config.readOnly ?? false;
     this.lightweightMode = config.lightweightMode ?? false;
-    if (!this.readOnly && !fs.existsSync(storagePath)) {
-      fs.mkdirSync(storagePath, { recursive: true });
+    this.mdMirror = new MarkdownMirror2(process.cwd());
+    if (!this.readOnly && !fs4.existsSync(storagePath)) {
+      fs4.mkdirSync(storagePath, { recursive: true });
     }
     this.projectHash = config.projectHash || null;
+    this.projectPath = config.projectPath || null;
     this.sharedStoreConfig = config.sharedStoreConfig ?? { enabled: true };
     this.sqliteStore = new SQLiteEventStore(
-      path.join(storagePath, "events.sqlite"),
-      { readonly: this.readOnly }
+      path3.join(storagePath, "events.sqlite"),
+      {
+        readonly: this.readOnly,
+        markdownMirrorRoot: storagePath
+      }
     );
     const analyticsEnabled = config.analyticsEnabled ?? this.readOnly;
     if (!analyticsEnabled) {
@@ -4666,7 +5929,7 @@ var MemoryService = class {
     } else if (this.readOnly) {
       try {
         this.analyticsStore = new EventStore(
-          path.join(storagePath, "analytics.duckdb"),
+          path3.join(storagePath, "analytics.duckdb"),
           { readOnly: true }
         );
       } catch {
@@ -4674,11 +5937,11 @@ var MemoryService = class {
       }
     } else {
       this.analyticsStore = new EventStore(
-        path.join(storagePath, "analytics.duckdb"),
+        path3.join(storagePath, "analytics.duckdb"),
         { readOnly: false }
       );
     }
-    this.vectorStore = new VectorStore(path.join(storagePath, "vectors"));
+    this.vectorStore = new VectorStore(path3.join(storagePath, "vectors"));
     this.embedder = config.embeddingModel ? new Embedder(config.embeddingModel) : getDefaultEmbedder();
     this.matcher = getDefaultMatcher();
     this.retriever = createRetriever(
@@ -4688,6 +5951,7 @@ var MemoryService = class {
       this.embedder,
       this.matcher
     );
+    this.retriever.setQueryRewriter((q) => this.rewriteQueryIntent(q));
     this.graduation = createGraduationPipeline(this.sqliteStore);
   }
   /**
@@ -4747,16 +6011,16 @@ 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 (!fs4.existsSync(sharedPath)) {
+      fs4.mkdirSync(sharedPath, { recursive: true });
     }
     this.sharedEventStore = createSharedEventStore(
-      path.join(sharedPath, "shared.duckdb")
+      path3.join(sharedPath, "shared.duckdb")
     );
     await this.sharedEventStore.initialize();
     this.sharedStore = createSharedStore(this.sharedEventStore);
     this.sharedVectorStore = createSharedVectorStore(
-      path.join(sharedPath, "vectors")
+      path3.join(sharedPath, "vectors")
     );
     await this.sharedVectorStore.initialize();
     this.sharedPromoter = createSharedPromoter(
@@ -4767,6 +6031,86 @@ var MemoryService = class {
     );
     this.retriever.setSharedStores(this.sharedStore, this.sharedVectorStore);
   }
+  registerIngestBefore(interceptor) {
+    return this.ingestInterceptors.registerBefore(interceptor);
+  }
+  registerIngestAfter(interceptor) {
+    return this.ingestInterceptors.registerAfter(interceptor);
+  }
+  registerIngestOnError(interceptor) {
+    return this.ingestInterceptors.registerOnError(interceptor);
+  }
+  async ingestWithInterceptors(operation, input, onSuccess) {
+    const normalizedInput = {
+      ...input,
+      metadata: mergeHierarchicalMetadata(
+        {
+          ingest: {
+            operation,
+            pipeline: "default",
+            ts: (/* @__PURE__ */ new Date()).toISOString()
+          },
+          ...this.projectHash ? {
+            scope: {
+              project: {
+                hash: this.projectHash,
+                ...this.projectPath ? { path: this.projectPath } : {}
+              }
+            },
+            tags: [`proj:${this.projectHash}`]
+          } : {}
+        },
+        input.metadata
+      )
+    };
+    if (this.projectHash && normalizedInput.metadata) {
+      const meta = normalizedInput.metadata;
+      const currentTags = Array.isArray(meta.tags) ? meta.tags.filter((x) => typeof x === "string") : [];
+      const projectTag = `proj:${this.projectHash}`;
+      if (!currentTags.includes(projectTag)) {
+        meta.tags = [...currentTags, projectTag];
+      }
+    }
+    if (normalizedInput.metadata) {
+      const meta = normalizedInput.metadata;
+      const normalizedTags = normalizeTags(meta.tags);
+      if (normalizedTags.length > 0) {
+        meta.tags = normalizedTags;
+      }
+    }
+    await this.ingestInterceptors.run("before", {
+      operation,
+      sessionId: normalizedInput.sessionId,
+      event: normalizedInput
+    });
+    try {
+      const result = await this.sqliteStore.append(normalizedInput);
+      if (result.success && !result.isDuplicate) {
+        if (onSuccess) {
+          await onSuccess(result.eventId);
+        }
+        try {
+          await this.mdMirror.append(normalizedInput, result.eventId);
+        } catch {
+        }
+      }
+      await this.ingestInterceptors.run("after", {
+        operation,
+        sessionId: normalizedInput.sessionId,
+        event: normalizedInput
+      });
+      return result;
+    } catch (error) {
+      const normalizedError = error instanceof Error ? error : new Error(String(error));
+      await this.ingestInterceptors.run("error", {
+        operation,
+        sessionId: normalizedInput.sessionId,
+        event: normalizedInput,
+        error: normalizedError
+      });
+      throw error;
+    }
+  }
   /**
    * Start a new session
    */
@@ -4794,50 +6138,57 @@ var MemoryService = class {
    */
   async storeUserPrompt(sessionId, content, metadata) {
     await this.initialize();
-    const result = await this.sqliteStore.append({
-      eventType: "user_prompt",
-      sessionId,
-      timestamp: /* @__PURE__ */ new Date(),
-      content,
-      metadata
-    });
-    if (result.success && !result.isDuplicate) {
-      await this.sqliteStore.enqueueForEmbedding(result.eventId, content);
-    }
-    return result;
+    return this.ingestWithInterceptors(
+      "user_prompt",
+      {
+        eventType: "user_prompt",
+        sessionId,
+        timestamp: /* @__PURE__ */ new Date(),
+        content,
+        metadata
+      },
+      async (eventId) => {
+        await this.sqliteStore.enqueueForEmbedding(eventId, content);
+      }
+    );
   }
   /**
    * Store an agent response
    */
   async storeAgentResponse(sessionId, content, metadata) {
     await this.initialize();
-    const result = await this.sqliteStore.append({
-      eventType: "agent_response",
-      sessionId,
-      timestamp: /* @__PURE__ */ new Date(),
-      content,
-      metadata
-    });
-    if (result.success && !result.isDuplicate) {
-      await this.sqliteStore.enqueueForEmbedding(result.eventId, content);
-    }
-    return result;
+    return this.ingestWithInterceptors(
+      "agent_response",
+      {
+        eventType: "agent_response",
+        sessionId,
+        timestamp: /* @__PURE__ */ new Date(),
+        content,
+        metadata
+      },
+      async (eventId) => {
+        await this.sqliteStore.enqueueForEmbedding(eventId, content);
+      }
+    );
   }
   /**
    * Store a session summary
    */
-  async storeSessionSummary(sessionId, summary) {
+  async storeSessionSummary(sessionId, summary, metadata) {
     await this.initialize();
-    const result = await this.sqliteStore.append({
-      eventType: "session_summary",
-      sessionId,
-      timestamp: /* @__PURE__ */ new Date(),
-      content: summary
-    });
-    if (result.success && !result.isDuplicate) {
-      await this.sqliteStore.enqueueForEmbedding(result.eventId, summary);
-    }
-    return result;
+    return this.ingestWithInterceptors(
+      "session_summary",
+      {
+        eventType: "session_summary",
+        sessionId,
+        timestamp: /* @__PURE__ */ new Date(),
+        content: summary,
+        metadata
+      },
+      async (eventId) => {
+        await this.sqliteStore.enqueueForEmbedding(eventId, summary);
+      }
+    );
   }
   /**
    * Store a tool observation
@@ -4845,39 +6196,182 @@ var MemoryService = class {
   async storeToolObservation(sessionId, payload) {
     await this.initialize();
     const content = JSON.stringify(payload);
-    const result = await this.sqliteStore.append({
-      eventType: "tool_observation",
-      sessionId,
-      timestamp: /* @__PURE__ */ new Date(),
-      content,
-      metadata: {
-        toolName: payload.toolName,
-        success: payload.success
+    const turnId = payload.metadata?.turnId;
+    return this.ingestWithInterceptors(
+      "tool_observation",
+      {
+        eventType: "tool_observation",
+        sessionId,
+        timestamp: /* @__PURE__ */ new Date(),
+        content,
+        metadata: {
+          toolName: payload.toolName,
+          success: payload.success,
+          ...turnId ? { turnId } : {}
+        }
+      },
+      async (eventId) => {
+        const embeddingContent = createToolObservationEmbedding(
+          payload.toolName,
+          payload.metadata || {},
+          payload.success
+        );
+        await this.sqliteStore.enqueueForEmbedding(eventId, embeddingContent);
       }
-    });
-    if (result.success && !result.isDuplicate) {
-      const embeddingContent = createToolObservationEmbedding(
-        payload.toolName,
-        payload.metadata || {},
-        payload.success
-      );
-      await this.sqliteStore.enqueueForEmbedding(result.eventId, embeddingContent);
-    }
-    return result;
+    );
   }
   /**
    * Retrieve relevant memories for a query
    */
   async retrieveMemories(query, options) {
     await this.initialize();
+    const rerankWeights = await this.getRerankWeights(options?.adaptiveRerank === true);
+    let result;
     if (options?.includeShared && this.sharedStore) {
-      return this.retriever.retrieveUnified(query, {
+      result = await this.retriever.retrieveUnified(query, {
         ...options,
+        intentRewrite: options?.intentRewrite === true,
+        rerankWeights,
         includeShared: true,
-        projectHash: this.projectHash || void 0
+        projectHash: this.projectHash || void 0,
+        projectScopeMode: options?.projectScopeMode ?? (this.projectHash ? "strict" : "global"),
+        allowedProjectHashes: options?.allowedProjectHashes
+      });
+    } else {
+      result = await this.retriever.retrieve(query, {
+        ...options,
+        intentRewrite: options?.intentRewrite === true,
+        rerankWeights,
+        projectHash: this.projectHash || void 0,
+        projectScopeMode: options?.projectScopeMode ?? (this.projectHash ? "strict" : "global"),
+        allowedProjectHashes: options?.allowedProjectHashes
+      });
+    }
+    try {
+      const selectedEventIds = result.memories.map((m) => m.event.id);
+      const selectedDetails = (result.selectedDebug || []).map((d) => ({
+        eventId: d.eventId,
+        score: d.score,
+        semanticScore: d.semanticScore,
+        lexicalScore: d.lexicalScore,
+        recencyScore: d.recencyScore
+      }));
+      const candidateDetails = (result.candidateDebug || []).map((d) => ({
+        eventId: d.eventId,
+        score: d.score,
+        semanticScore: d.semanticScore,
+        lexicalScore: d.lexicalScore,
+        recencyScore: d.recencyScore
+      }));
+      const candidateEventIds = candidateDetails.length > 0 ? candidateDetails.map((d) => d.eventId) : selectedEventIds;
+      await this.sqliteStore.recordRetrievalTrace({
+        sessionId: options?.sessionId,
+        projectHash: this.projectHash || void 0,
+        queryText: query,
+        strategy: options?.strategy || "auto",
+        candidateEventIds,
+        selectedEventIds,
+        candidateDetails,
+        selectedDetails,
+        confidence: result.matchResult.confidence,
+        fallbackTrace: result.fallbackTrace || []
+      });
+    } catch {
+    }
+    return result;
+  }
+  getConfiguredRerankWeights() {
+    const semantic = Number(process.env.MEMORY_RERANK_WEIGHT_SEMANTIC ?? "");
+    const lexical = Number(process.env.MEMORY_RERANK_WEIGHT_LEXICAL ?? "");
+    const recency = Number(process.env.MEMORY_RERANK_WEIGHT_RECENCY ?? "");
+    const allFinite = [semantic, lexical, recency].every((v) => Number.isFinite(v));
+    if (!allFinite)
+      return void 0;
+    const nonNegative = [semantic, lexical, recency].every((v) => v >= 0);
+    const total = semantic + lexical + recency;
+    if (!nonNegative || total <= 0)
+      return void 0;
+    return {
+      semantic: semantic / total,
+      lexical: lexical / total,
+      recency: recency / total
+    };
+  }
+  async getRerankWeights(adaptive) {
+    const configured = this.getConfiguredRerankWeights();
+    if (configured)
+      return configured;
+    if (adaptive)
+      return this.getAdaptiveRerankWeights();
+    return void 0;
+  }
+  async rewriteQueryIntent(query) {
+    if (process.env.MEMORY_INTENT_REWRITE_ENABLED !== "1")
+      return null;
+    const apiUrl = process.env.COMPANY_STOCK_API_URL || process.env.COMPANY_INT_API_URL;
+    if (!apiUrl)
+      return null;
+    const controller = new AbortController();
+    const timeoutMs = Number(process.env.MEMORY_INTENT_REWRITE_TIMEOUT_MS || 5e3);
+    const timeout = setTimeout(() => controller.abort(), timeoutMs);
+    try {
+      const prompt = [
+        "Rewrite user query for memory retrieval intent expansion.",
+        "Return plain text only, one line, no markdown.",
+        `Query: ${query}`
+      ].join("\n");
+      const res = await fetch(apiUrl, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          Accept: "*/*",
+          Origin: process.env.COMPANY_INT_ORIGIN || "http://company-int.aplusai.ai",
+          Referer: process.env.COMPANY_INT_REFERER || "http://company-int.aplusai.ai/"
+        },
+        body: JSON.stringify({
+          question: prompt,
+          company_name: null,
+          conversation_id: null
+        }),
+        signal: controller.signal
       });
+      const text = (await res.text()).trim();
+      if (!text)
+        return null;
+      const oneLine = text.replace(/^data:\s*/gm, "").split(/\r?\n/).map((x) => x.trim()).filter(Boolean).join(" ").slice(0, 240);
+      if (!oneLine || oneLine.toLowerCase() === query.toLowerCase())
+        return null;
+      return oneLine;
+    } catch {
+      return null;
+    } finally {
+      clearTimeout(timeout);
+    }
+  }
+  async getAdaptiveRerankWeights() {
+    try {
+      const s = await this.sqliteStore.getHelpfulnessStats();
+      if (s.totalEvaluated < 20)
+        return void 0;
+      let semantic = 0.7;
+      let lexical = 0.2;
+      let recency = 0.1;
+      if (s.avgScore < 0.45) {
+        semantic -= 0.1;
+        lexical += 0.1;
+      } else if (s.avgScore > 0.75) {
+        semantic += 0.05;
+        lexical -= 0.05;
+      }
+      if (s.unhelpful > s.helpful) {
+        recency += 0.05;
+        semantic -= 0.03;
+        lexical -= 0.02;
+      }
+      return { semantic, lexical, recency };
+    } catch {
+      return void 0;
     }
-    return this.retriever.retrieve(query, options);
   }
   /**
    * Fast keyword search using SQLite FTS5
@@ -4919,6 +6413,18 @@ var MemoryService = class {
   /**
    * Get memory statistics
    */
+  async getOutboxStats() {
+    await this.initialize();
+    return this.sqliteStore.getOutboxStats();
+  }
+  async getRetrievalTraceStats() {
+    await this.initialize();
+    return this.sqliteStore.getRetrievalTraceStats();
+  }
+  async getRecentRetrievalTraces(limit = 50) {
+    await this.initialize();
+    return this.sqliteStore.getRecentRetrievalTraces(limit);
+  }
   async getStats() {
     await this.initialize();
     const recentEvents = await this.sqliteStore.getRecentEvents(1e4);
@@ -5135,6 +6641,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
    */
@@ -5158,8 +6689,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,
@@ -5180,6 +6710,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
    */
@@ -5243,6 +6801,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
    */
@@ -5319,7 +6915,7 @@ var MemoryService = class {
    */
   expandPath(p) {
     if (p.startsWith("~")) {
-      return path.join(os.homedir(), p.slice(1));
+      return path3.join(os.homedir(), p.slice(1));
     }
     return p;
   }
@@ -5332,6 +6928,7 @@ function getMemoryServiceForProject(projectPath, sharedStoreConfig) {
     serviceCache.set(hash, new MemoryService({
       storagePath,
       projectHash: hash,
+      projectPath,
       // Override shared store config - hooks don't need DuckDB
       sharedStoreConfig: sharedStoreConfig ?? { enabled: false },
       analyticsEnabled: false