claude-memory-layer 1.0.11 → 1.0.12

package/dist/cli/index.js

@@ -16,14 +16,14 @@ var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require
 // src/cli/index.ts
 import { Command } from "commander";
 import { exec } from "child_process";
-import * as fs6 from "fs";
-import * as path6 from "path";
-import * as os5 from "os";
+import * as fs9 from "fs";
+import * as path9 from "path";
+import * as os6 from "os";
 
 // src/services/memory-service.ts
-import * as path from "path";
+import * as path3 from "path";
 import * as os from "os";
-import * as fs2 from "fs";
+import * as fs4 from "fs";
 import * as crypto2 from "crypto";
 
 // src/core/event-store.ts
@@ -81,57 +81,57 @@ function toDate(value) {
     return new Date(value);
   return new Date(String(value));
 }
-function createDatabase(path7, options) {
+function createDatabase(path10, options) {
   if (options?.readOnly) {
-    return new duckdb.Database(path7, { access_mode: "READ_ONLY" });
+    return new duckdb.Database(path10, { access_mode: "READ_ONLY" });
   }
-  return new duckdb.Database(path7);
+  return new duckdb.Database(path10);
 }
 function dbRun(db, sql, params = []) {
-  return new Promise((resolve2, reject) => {
+  return new Promise((resolve4, reject) => {
     if (params.length === 0) {
       db.run(sql, (err) => {
         if (err)
           reject(err);
         else
-          resolve2();
+          resolve4();
       });
     } else {
       db.run(sql, ...params, (err) => {
         if (err)
           reject(err);
         else
-          resolve2();
+          resolve4();
       });
     }
   });
 }
 function dbAll(db, sql, params = []) {
-  return new Promise((resolve2, reject) => {
+  return new Promise((resolve4, reject) => {
     if (params.length === 0) {
       db.all(sql, (err, rows) => {
         if (err)
           reject(err);
         else
-          resolve2(convertBigInts(rows || []));
+          resolve4(convertBigInts(rows || []));
       });
     } else {
       db.all(sql, ...params, (err, rows) => {
         if (err)
           reject(err);
         else
-          resolve2(convertBigInts(rows || []));
+          resolve4(convertBigInts(rows || []));
       });
     }
   });
 }
 function dbClose(db) {
-  return new Promise((resolve2, reject) => {
+  return new Promise((resolve4, reject) => {
     db.close((err) => {
       if (err)
         reject(err);
       else
-        resolve2();
+        resolve4();
     });
   });
 }
@@ -349,6 +349,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,
@@ -368,6 +379,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;
   }
@@ -757,12 +769,12 @@ import { randomUUID as randomUUID2 } from "crypto";
 import Database from "better-sqlite3";
 import * as fs from "fs";
 import * as nodePath from "path";
-function createSQLiteDatabase(path7, options) {
-  const dir = nodePath.dirname(path7);
+function createSQLiteDatabase(path10, options) {
+  const dir = nodePath.dirname(path10);
   if (!fs.existsSync(dir)) {
     fs.mkdirSync(dir, { recursive: true });
   }
-  const db = new Database(path7, {
+  const db = new Database(path10, {
     readonly: options?.readonly ?? false
   });
   if (!options?.readonly && (options?.walMode ?? true)) {
@@ -803,6 +815,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) {
@@ -812,10 +882,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
    */
@@ -1022,6 +1094,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,
@@ -1046,6 +1129,24 @@ var SQLiteEventStore = class {
         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,
@@ -1070,10 +1171,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(
@@ -1097,6 +1202,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")) {
@@ -1196,6 +1309,21 @@ var SQLiteEventStore = class {
         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 {
@@ -1254,6 +1382,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
    */
@@ -1416,6 +1630,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
    */
@@ -1774,6 +2017,79 @@ 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
    */
@@ -2091,7 +2407,7 @@ var SyncWorker = class {
    * Sleep utility
    */
   sleep(ms) {
-    return new Promise((resolve2) => setTimeout(resolve2, ms));
+    return new Promise((resolve4) => setTimeout(resolve4, ms));
   }
   /**
    * Get sync statistics
@@ -2635,7 +2951,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;
@@ -2645,6 +2974,7 @@ var Retriever = class {
   sharedStore;
   sharedVectorStore;
   graduation;
+  queryRewriter;
   constructor(eventStore, vectorStore, embedder, matcher, sharedOptions) {
     this.eventStore = eventStore;
     this.vectorStore = vectorStore;
@@ -2653,47 +2983,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) {
@@ -2701,22 +3089,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);
@@ -2731,50 +3116,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) {
@@ -2782,27 +3360,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);
@@ -2815,55 +3382,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(([path10, value]) => {
+      const actual = path10.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);
@@ -4154,14 +4752,67 @@ var ConsolidatedStore = class {
     );
   }
   /**
-   * Get count of consolidated memories
+   * Create a long-term rule promoted from stable summaries
    */
-  async count() {
-    const result = await dbAll(
+  async createRule(input) {
+    const ruleId = randomUUID6();
+    await dbRun(
       this.db,
-      `SELECT COUNT(*) as count FROM consolidated_memories`
+      `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 result[0]?.count || 0;
+    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
+   */
+  async count() {
+    const result = await dbAll(
+      this.db,
+      `SELECT COUNT(*) as count FROM consolidated_memories`
+    );
+    return result[0]?.count || 0;
   }
   /**
    * Get most accessed memories (for importance scoring)
@@ -4302,7 +4953,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
@@ -4342,12 +5000,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;
@@ -4356,14 +5023,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) => {
@@ -4377,7 +5046,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
@@ -4937,13 +5660,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 fs2.realpathSync(expanded);
+    return fs4.realpathSync(expanded);
   } catch {
-    return path.resolve(expanded);
+    return path3.resolve(expanded);
   }
 }
 function hashProjectPath(projectPath) {
@@ -4952,14 +5847,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 (fs2.existsSync(REGISTRY_PATH)) {
-      const data = fs2.readFileSync(REGISTRY_PATH, "utf-8");
+    if (fs4.existsSync(REGISTRY_PATH)) {
+      const data = fs4.readFileSync(REGISTRY_PATH, "utf-8");
       return JSON.parse(data);
     }
   } catch (error) {
@@ -4968,13 +5863,13 @@ function loadSessionRegistry() {
   return { version: 1, sessions: {} };
 }
 function saveSessionRegistry(registry) {
-  const dir = path.dirname(REGISTRY_PATH);
-  if (!fs2.existsSync(dir)) {
-    fs2.mkdirSync(dir, { recursive: true });
+  const dir = path3.dirname(REGISTRY_PATH);
+  if (!fs4.existsSync(dir)) {
+    fs4.mkdirSync(dir, { recursive: true });
   }
   const tempPath = REGISTRY_PATH + ".tmp";
-  fs2.writeFileSync(tempPath, JSON.stringify(registry, null, 2));
-  fs2.renameSync(tempPath, REGISTRY_PATH);
+  fs4.writeFileSync(tempPath, JSON.stringify(registry, null, 2));
+  fs4.renameSync(tempPath, REGISTRY_PATH);
 }
 function registerSession(sessionId, projectPath) {
   const registry = loadSessionRegistry();
@@ -5006,6 +5901,7 @@ var MemoryService = class {
   vectorWorker = null;
   graduationWorker = null;
   initialized = false;
+  ingestInterceptors = new IngestInterceptorRegistry();
   // Endless Mode components
   workingSetStore = null;
   consolidatedStore = null;
@@ -5019,20 +5915,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 && !fs2.existsSync(storagePath)) {
-      fs2.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) {
@@ -5040,7 +5943,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 {
@@ -5048,11 +5951,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(
@@ -5062,6 +5965,7 @@ var MemoryService = class {
       this.embedder,
       this.matcher
     );
+    this.retriever.setQueryRewriter((q) => this.rewriteQueryIntent(q));
     this.graduation = createGraduationPipeline(this.sqliteStore);
   }
   /**
@@ -5121,16 +6025,16 @@ var MemoryService = class {
    */
   async initializeSharedStore() {
     const sharedPath = this.sharedStoreConfig?.sharedStoragePath ? this.expandPath(this.sharedStoreConfig.sharedStoragePath) : SHARED_STORAGE_PATH;
-    if (!fs2.existsSync(sharedPath)) {
-      fs2.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(
@@ -5141,6 +6045,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
    */
@@ -5168,50 +6152,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
@@ -5220,40 +6211,181 @@ var MemoryService = class {
     await this.initialize();
     const content = JSON.stringify(payload);
     const turnId = payload.metadata?.turnId;
-    const result = await this.sqliteStore.append({
-      eventType: "tool_observation",
-      sessionId,
-      timestamp: /* @__PURE__ */ new Date(),
-      content,
-      metadata: {
-        toolName: payload.toolName,
-        success: payload.success,
-        ...turnId ? { 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
@@ -5295,6 +6427,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);
@@ -5785,7 +6929,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;
   }
@@ -5821,6 +6965,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
@@ -5831,8 +6976,8 @@ function getMemoryServiceForProject(projectPath, sharedStoreConfig) {
 }
 
 // src/services/session-history-importer.ts
-import * as fs3 from "fs";
-import * as path2 from "path";
+import * as fs5 from "fs";
+import * as path4 from "path";
 import * as os2 from "os";
 import * as readline from "readline";
 import { randomUUID as randomUUID9 } from "crypto";
@@ -5876,7 +7021,7 @@ var SessionHistoryImporter = class {
   claudeDir;
   constructor(memoryService) {
     this.memoryService = memoryService;
-    this.claudeDir = path2.join(os2.homedir(), ".claude");
+    this.claudeDir = path4.join(os2.homedir(), ".claude");
   }
   /**
    * Import all sessions from a project
@@ -5899,7 +7044,7 @@ var SessionHistoryImporter = class {
     }
     const sessionFiles = await this.findSessionFiles(projectDir);
     result.totalSessions = sessionFiles.length;
-    onProgress?.({ phase: "scan", message: `Found ${sessionFiles.length} sessions in ${path2.basename(projectDir)}` });
+    onProgress?.({ phase: "scan", message: `Found ${sessionFiles.length} sessions in ${path4.basename(projectDir)}` });
     if (options.verbose) {
       console.log(`Found ${sessionFiles.length} session files in ${projectDir}`);
     }
@@ -5940,11 +7085,11 @@ var SessionHistoryImporter = class {
       skippedDuplicates: 0,
       errors: []
     };
-    if (!fs3.existsSync(filePath)) {
+    if (!fs5.existsSync(filePath)) {
       result.errors.push(`File not found: ${filePath}`);
       return result;
     }
-    const sessionId = path2.basename(filePath, ".jsonl");
+    const sessionId = path4.basename(filePath, ".jsonl");
     if (options.force) {
       const deleted = await this.memoryService.deleteSessionEvents(sessionId);
       if (options.verbose && deleted > 0) {
@@ -5952,7 +7097,7 @@ var SessionHistoryImporter = class {
       }
     }
     await this.memoryService.startSession(sessionId, options.projectPath);
-    const fileStream = fs3.createReadStream(filePath);
+    const fileStream = fs5.createReadStream(filePath);
     const rl = readline.createInterface({
       input: fileStream,
       crlfDelay: Infinity
@@ -6057,13 +7202,13 @@ var SessionHistoryImporter = class {
       errors: []
     };
     const onProgress = options.onProgress;
-    const projectsDir = path2.join(this.claudeDir, "projects");
-    if (!fs3.existsSync(projectsDir)) {
+    const projectsDir = path4.join(this.claudeDir, "projects");
+    if (!fs5.existsSync(projectsDir)) {
       result.errors.push(`Projects directory not found: ${projectsDir}`);
       return result;
     }
     onProgress?.({ phase: "scan", message: "Scanning all projects..." });
-    const projectDirs = fs3.readdirSync(projectsDir).map((name) => path2.join(projectsDir, name)).filter((p) => fs3.statSync(p).isDirectory());
+    const projectDirs = fs5.readdirSync(projectsDir).map((name) => path4.join(projectsDir, name)).filter((p) => fs5.statSync(p).isDirectory());
     const allSessionFiles = [];
     for (const projectDir of projectDirs) {
       const sessionFiles = await this.findSessionFiles(projectDir);
@@ -6104,14 +7249,14 @@ var SessionHistoryImporter = class {
    * Find project directory from project path
    */
   async findProjectDir(projectPath) {
-    const projectsDir = path2.join(this.claudeDir, "projects");
-    if (!fs3.existsSync(projectsDir)) {
+    const projectsDir = path4.join(this.claudeDir, "projects");
+    if (!fs5.existsSync(projectsDir)) {
       return null;
     }
-    const projectDirs = fs3.readdirSync(projectsDir).map((name) => path2.join(projectsDir, name)).filter((p) => fs3.statSync(p).isDirectory());
+    const projectDirs = fs5.readdirSync(projectsDir).map((name) => path4.join(projectsDir, name)).filter((p) => fs5.statSync(p).isDirectory());
     const normalizedPath = projectPath.replace(/\//g, "-").replace(/^-/, "");
     for (const dir of projectDirs) {
-      const dirName = path2.basename(dir);
+      const dirName = path4.basename(dir);
       if (dirName.includes(normalizedPath) || normalizedPath.includes(dirName)) {
         return dir;
       }
@@ -6122,10 +7267,10 @@ var SessionHistoryImporter = class {
    * Find all JSONL session files in a directory
    */
   async findSessionFiles(dir) {
-    if (!fs3.existsSync(dir)) {
+    if (!fs5.existsSync(dir)) {
       return [];
     }
-    return fs3.readdirSync(dir).filter((name) => name.endsWith(".jsonl")).map((name) => path2.join(dir, name)).filter((p) => fs3.statSync(p).isFile());
+    return fs5.readdirSync(dir).filter((name) => name.endsWith(".jsonl")).map((name) => path4.join(dir, name)).filter((p) => fs5.statSync(p).isFile());
   }
   /**
    * Extract text content from Claude message
@@ -6156,17 +7301,17 @@ var SessionHistoryImporter = class {
         projectDirs = [projectDir];
       }
     } else {
-      const projectsDir = path2.join(this.claudeDir, "projects");
-      if (fs3.existsSync(projectsDir)) {
-        projectDirs = fs3.readdirSync(projectsDir).map((name) => path2.join(projectsDir, name)).filter((p) => fs3.statSync(p).isDirectory());
+      const projectsDir = path4.join(this.claudeDir, "projects");
+      if (fs5.existsSync(projectsDir)) {
+        projectDirs = fs5.readdirSync(projectsDir).map((name) => path4.join(projectsDir, name)).filter((p) => fs5.statSync(p).isDirectory());
       }
     }
     for (const projectDir of projectDirs) {
       const sessionFiles = await this.findSessionFiles(projectDir);
       for (const filePath of sessionFiles) {
-        const stats = fs3.statSync(filePath);
+        const stats = fs5.statSync(filePath);
         sessions.push({
-          sessionId: path2.basename(filePath, ".jsonl"),
+          sessionId: path4.basename(filePath, ".jsonl"),
           filePath,
           size: stats.size,
           modifiedAt: stats.mtime
@@ -6181,23 +7326,418 @@ function createSessionHistoryImporter(memoryService) {
   return new SessionHistoryImporter(memoryService);
 }
 
+// src/services/bootstrap-organizer.ts
+import * as fs6 from "node:fs";
+import * as path5 from "node:path";
+import { execSync } from "node:child_process";
+var EXCLUDED_DIRS = /* @__PURE__ */ new Set([".git", "node_modules", "dist", "build", "coverage", ".next", ".turbo", "memory"]);
+var CODE_EXTENSIONS = /* @__PURE__ */ new Set([
+  ".ts",
+  ".tsx",
+  ".js",
+  ".jsx",
+  ".mjs",
+  ".cjs",
+  ".py",
+  ".go",
+  ".rs",
+  ".java",
+  ".kt",
+  ".swift",
+  ".rb",
+  ".php",
+  ".cs",
+  ".scala",
+  ".sh",
+  ".zsh",
+  ".yaml",
+  ".yml",
+  ".json",
+  ".sql",
+  ".md"
+]);
+function safeRel(base, target) {
+  return path5.relative(base, target).replaceAll("\\", "/");
+}
+function mkdirp(dir) {
+  fs6.mkdirSync(dir, { recursive: true });
+}
+function walkCodeFiles(root) {
+  const out = [];
+  function walk(dir) {
+    const entries = fs6.readdirSync(dir, { withFileTypes: true }).sort((a, b) => a.name.localeCompare(b.name));
+    for (const e of entries) {
+      const full = path5.join(dir, e.name);
+      if (e.isDirectory()) {
+        if (!EXCLUDED_DIRS.has(e.name))
+          walk(full);
+      } else if (e.isFile()) {
+        const ext = path5.extname(e.name).toLowerCase();
+        if (CODE_EXTENSIONS.has(ext))
+          out.push(full);
+      }
+    }
+  }
+  walk(root);
+  return out.sort();
+}
+function detectLanguage(file) {
+  const ext = path5.extname(file).toLowerCase();
+  const map = {
+    ".ts": "TypeScript",
+    ".tsx": "TypeScript",
+    ".js": "JavaScript",
+    ".jsx": "JavaScript",
+    ".mjs": "JavaScript",
+    ".cjs": "JavaScript",
+    ".py": "Python",
+    ".go": "Go",
+    ".rs": "Rust",
+    ".java": "Java",
+    ".kt": "Kotlin",
+    ".swift": "Swift",
+    ".rb": "Ruby",
+    ".php": "PHP",
+    ".cs": "C#",
+    ".scala": "Scala",
+    ".sh": "Shell",
+    ".zsh": "Shell",
+    ".yaml": "YAML",
+    ".yml": "YAML",
+    ".json": "JSON",
+    ".sql": "SQL",
+    ".md": "Markdown"
+  };
+  return map[ext] || "Other";
+}
+function summarizeModules(repoPath, files) {
+  const modules = /* @__PURE__ */ new Map();
+  for (const abs of files) {
+    const rel = safeRel(repoPath, abs);
+    const seg = rel.split("/").filter(Boolean);
+    const top = seg[0] || "root";
+    if (!modules.has(top))
+      modules.set(top, { files: [], langs: /* @__PURE__ */ new Map() });
+    const bucket = modules.get(top);
+    bucket.files.push(rel);
+    const lang = detectLanguage(abs);
+    bucket.langs.set(lang, (bucket.langs.get(lang) || 0) + 1);
+  }
+  return [...modules.entries()].map(([name, data]) => ({
+    name,
+    root: name,
+    fileCount: data.files.length,
+    languages: [...data.langs.entries()].sort((a, b) => b[1] - a[1]).map(([l]) => l).slice(0, 5),
+    entryCandidates: data.files.filter((f) => /(index|main|app|server|cli)\./i.test(path5.basename(f))).slice(0, 10)
+  })).sort((a, b) => b.fileCount - a.fileCount || a.name.localeCompare(b.name));
+}
+function runGit(repoPath, command) {
+  return execSync(`git -C ${JSON.stringify(repoPath)} ${command}`, { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] });
+}
+function getGitCommits(repoPath, since = "180 days ago", maxCommits = 1e3) {
+  try {
+    const raw = runGit(
+      repoPath,
+      `log --since=${JSON.stringify(since)} -n ${Math.max(1, maxCommits)} --date=short --pretty=format:%H%x09%ad%x09%an%x09%s --name-only --reverse`
+    );
+    const lines = raw.split(/\r?\n/);
+    const commits = [];
+    let current = null;
+    for (const line of lines) {
+      if (!line.trim()) {
+        if (current) {
+          commits.push(current);
+          current = null;
+        }
+        continue;
+      }
+      if (line.includes("	") && line.split("	").length >= 4) {
+        if (current)
+          commits.push(current);
+        const [hash, date, author, ...subjectRest] = line.split("	");
+        current = { hash, date, author, subject: subjectRest.join("	").trim(), files: [] };
+      } else if (current) {
+        current.files.push(line.trim());
+      }
+    }
+    if (current)
+      commits.push(current);
+    return commits;
+  } catch {
+    return [];
+  }
+}
+function extractDecisions(commits) {
+  const decisionPattern = /(refactor|migrate|deprecat|remove|replace|introduce|adopt|switch|upgrade|breaking|architecture|feat|fix)/i;
+  return commits.filter((c) => decisionPattern.test(c.subject));
+}
+function buildTimeline(commits) {
+  const timeline = /* @__PURE__ */ new Map();
+  for (const c of commits) {
+    const key = (c.date || "").slice(0, 7) || "unknown";
+    if (!timeline.has(key))
+      timeline.set(key, []);
+    timeline.get(key).push(c);
+  }
+  return new Map([...timeline.entries()].sort((a, b) => a[0].localeCompare(b[0])));
+}
+function buildGlossary(files) {
+  const stop = /* @__PURE__ */ new Set(["src", "test", "dist", "lib", "core", "index", "main", "app", "server", "client", "utils"]);
+  const freq = /* @__PURE__ */ new Map();
+  for (const f of files) {
+    const base = path5.basename(f, path5.extname(f));
+    const tokens = base.split(/[^a-zA-Z0-9]+/).flatMap((t) => t.split(/(?=[A-Z])/)).map((t) => t.toLowerCase()).filter((t) => t.length >= 3 && !stop.has(t));
+    for (const t of tokens)
+      freq.set(t, (freq.get(t) || 0) + 1);
+  }
+  return [...freq.entries()].filter(([, count]) => count >= 2).sort((a, b) => b[1] - a[1] || a[0].localeCompare(b[0])).slice(0, 80).map(([term]) => term);
+}
+function writeFile(filePath, content) {
+  mkdirp(path5.dirname(filePath));
+  fs6.writeFileSync(filePath, content, "utf8");
+}
+function confidenceByEvidence(sourceCount) {
+  if (sourceCount >= 3)
+    return "high";
+  if (sourceCount >= 1)
+    return "mid";
+  return "low";
+}
+function sourceLine(source) {
+  return `- source: ${source}`;
+}
+function loadExistingManifest(outDir) {
+  try {
+    const p = path5.join(outDir, "sources", "manifest.json");
+    if (!fs6.existsSync(p))
+      return null;
+    const data = JSON.parse(fs6.readFileSync(p, "utf8"));
+    return data;
+  } catch {
+    return null;
+  }
+}
+function listMarkdownOutputs(outDir) {
+  const out = [];
+  const stack = [outDir];
+  while (stack.length) {
+    const dir = stack.pop();
+    for (const entry of fs6.readdirSync(dir, { withFileTypes: true })) {
+      const full = path5.join(dir, entry.name);
+      if (entry.isDirectory())
+        stack.push(full);
+      else if (entry.isFile() && entry.name.endsWith(".md"))
+        out.push(full);
+    }
+  }
+  return out.sort((a, b) => a.localeCompare(b));
+}
+async function bootstrapKnowledgeBase(options) {
+  const repoPath = path5.resolve(options.repoPath);
+  const outDir = path5.resolve(options.outDir);
+  const maxCommits = options.maxCommits ?? 1e3;
+  const existingManifest = options.incremental ? loadExistingManifest(outDir) : null;
+  const incrementalSince = existingManifest?.lastCommitDate || existingManifest?.generatedAt;
+  const since = options.since || incrementalSince || "180 days ago";
+  const codeFiles = walkCodeFiles(repoPath);
+  const modules = summarizeModules(repoPath, codeFiles);
+  const commits = getGitCommits(repoPath, since, maxCommits);
+  const decisions = extractDecisions(commits);
+  const timeline = buildTimeline(commits);
+  const glossary = buildGlossary(codeFiles);
+  const generatedFiles = [];
+  const sections = {
+    overview: path5.join(outDir, "overview"),
+    modules: path5.join(outDir, "modules"),
+    decisions: path5.join(outDir, "decisions"),
+    timeline: path5.join(outDir, "timeline"),
+    glossary: path5.join(outDir, "glossary"),
+    sources: path5.join(outDir, "sources")
+  };
+  for (const sectionDir of Object.values(sections)) {
+    mkdirp(sectionDir);
+  }
+  const overviewPath = path5.join(sections.overview, "overview.md");
+  const overview = [
+    "# Codebase Overview",
+    "",
+    `- generatedAt: ${(/* @__PURE__ */ new Date()).toISOString()}`,
+    "- deterministicPipeline: true",
+    `- repo: ${repoPath}`,
+    `- filesAnalyzed: ${codeFiles.length}`,
+    `- commitsAnalyzed: ${commits.length}`,
+    `- confidence: ${confidenceByEvidence(modules.length > 0 ? 3 : 0)}`,
+    "",
+    "## Directory / Module Map",
+    ...modules.slice(0, 50).map((m) => `- ${m.name}: ${m.fileCount} files (${m.languages.join(", ") || "n/a"})`),
+    "",
+    "## Fact",
+    "- Generated from deterministic file scan and git history parsing.",
+    "",
+    "## Inference",
+    "- Module responsibilities should be reviewed by maintainers for nuanced boundaries.",
+    "",
+    "## Sources",
+    sourceLine(`repo-scan:${repoPath}`),
+    sourceLine(`git-log:since=${since};max=${maxCommits}`),
+    ""
+  ].join("\n");
+  writeFile(overviewPath, overview);
+  generatedFiles.push(overviewPath);
+  const touchedRoots = new Set(
+    commits.flatMap((c) => c.files).map((f) => f.split("/").filter(Boolean)[0]).filter(Boolean)
+  );
+  const moduleTargets = options.incremental && touchedRoots.size > 0 ? modules.filter((m) => touchedRoots.has(m.root)).slice(0, 200) : modules.slice(0, 200);
+  for (const m of moduleTargets) {
+    const relatedCommits = commits.filter((c) => c.files.some((f) => f.startsWith(`${m.root}/`))).slice(0, 15);
+    const content = [
+      `# Module: ${m.name}`,
+      "",
+      `- responsibility: inferred from top-level path \`${m.root}/\``,
+      `- files: ${m.fileCount}`,
+      `- languages: ${m.languages.join(", ") || "n/a"}`,
+      `- confidence: ${confidenceByEvidence(relatedCommits.length)}`,
+      "",
+      "## Entry Candidates",
+      ...m.entryCandidates.length > 0 ? m.entryCandidates.map((f) => `- ${f}`) : ["- none detected"],
+      "",
+      "## Related Commits (recent sample)",
+      ...relatedCommits.length > 0 ? relatedCommits.map((c) => `- ${c.date} ${c.hash.slice(0, 8)} ${c.subject}`) : ["- none in selected range"],
+      "",
+      "## Sources",
+      sourceLine(`repo-path:${m.root}/**`),
+      ...relatedCommits.map((c) => sourceLine(`commit:${c.hash}`)),
+      ""
+    ].join("\n");
+    const modulePath = path5.join(sections.modules, `${m.name.replace(/[^a-z0-9._-]+/gi, "-").toLowerCase()}.md`);
+    writeFile(modulePath, content);
+    generatedFiles.push(modulePath);
+  }
+  const decisionsPath = path5.join(sections.decisions, "decisions.md");
+  const decisionsMd = [
+    "# Decisions (extracted)",
+    "",
+    `- confidence: ${confidenceByEvidence(decisions.length)}`,
+    "",
+    ...decisions.length > 0 ? decisions.slice(0, 500).map((d) => [
+      `## ${d.date} | ${d.subject}`,
+      "- status: active (inferred)",
+      sourceLine(`commit:${d.hash}`),
+      `- author: ${d.author}`,
+      `- changedFiles: ${d.files.length}`,
+      `- confidence: ${confidenceByEvidence(d.files.length > 0 ? 2 : 1)}`,
+      ""
+    ].join("\n")) : ["- No decision-like commits found in selected range.", ""],
+    "## Sources",
+    sourceLine(`git-log:since=${since};max=${maxCommits}`),
+    ""
+  ].join("\n");
+  writeFile(decisionsPath, decisionsMd);
+  generatedFiles.push(decisionsPath);
+  const timelinePath = path5.join(sections.timeline, "timeline.md");
+  const timelineMd = [
+    "# Timeline",
+    "",
+    `- confidence: ${confidenceByEvidence(commits.length > 0 ? 2 : 0)}`,
+    "",
+    ...[...timeline.entries()].flatMap(([month, list]) => [
+      `## ${month}`,
+      ...list.slice(0, 40).map((c) => `- ${c.date} ${c.hash.slice(0, 8)} ${c.subject}`),
+      ""
+    ]),
+    "## Sources",
+    sourceLine(`git-log:since=${since};max=${maxCommits}`),
+    ""
+  ].join("\n");
+  writeFile(timelinePath, timelineMd);
+  generatedFiles.push(timelinePath);
+  const glossaryPath = path5.join(sections.glossary, "glossary.md");
+  const glossaryMd = [
+    "# Glossary (auto-extracted)",
+    "",
+    `- confidence: ${confidenceByEvidence(glossary.length > 0 ? 1 : 0)}`,
+    "",
+    ...glossary.map((t) => `- ${t}`),
+    "",
+    "## Sources",
+    sourceLine(`repo-scan:${repoPath}`),
+    ""
+  ].join("\n");
+  writeFile(glossaryPath, glossaryMd);
+  generatedFiles.push(glossaryPath);
+  const outputs = generatedFiles.map((f) => safeRel(outDir, f)).sort((a, b) => a.localeCompare(b));
+  const allOutputs = listMarkdownOutputs(outDir).map((f) => safeRel(outDir, f));
+  const sourceItems = [
+    ...codeFiles.slice(0, 200).map((f) => ({ type: "file", ref: safeRel(repoPath, f) })),
+    ...commits.slice(0, 400).map((c) => ({ type: "commit", ref: c.hash, date: c.date, subject: c.subject }))
+  ];
+  const latestCommitDate = commits.length > 0 ? commits[commits.length - 1].date : void 0;
+  const manifest = {
+    generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    deterministicPipeline: true,
+    mode: options.incremental ? "incremental" : "full",
+    repoPath,
+    options: { since, maxCommits, incremental: Boolean(options.incremental) },
+    stats: {
+      filesAnalyzed: codeFiles.length,
+      modules: modules.length,
+      modulesGenerated: moduleTargets.length,
+      commits: commits.length,
+      decisions: decisions.length,
+      glossaryTerms: glossary.length
+    },
+    lastCommitDate: latestCommitDate,
+    outputs,
+    allOutputs,
+    sources: sourceItems
+  };
+  const manifestJsonPath = path5.join(sections.sources, "manifest.json");
+  writeFile(manifestJsonPath, `${JSON.stringify(manifest, null, 2)}
+`);
+  generatedFiles.push(manifestJsonPath);
+  const manifestMdPath = path5.join(sections.sources, "manifest.md");
+  const manifestMd = [
+    "# Sources Manifest",
+    "",
+    "- deterministicPipeline: true",
+    `- mode: ${options.incremental ? "incremental" : "full"}`,
+    `- sourceCount: ${sourceItems.length}`,
+    "",
+    "## Outputs",
+    ...outputs.map((o) => `- ${o}`),
+    "",
+    "## Sources (sample)",
+    ...sourceItems.slice(0, 300).map((s) => `- ${s.type}:${s.ref}`),
+    ""
+  ].join("\n");
+  writeFile(manifestMdPath, manifestMd);
+  generatedFiles.push(manifestMdPath);
+  return {
+    outDir,
+    fileCount: codeFiles.length,
+    moduleCount: modules.length,
+    commitCount: commits.length,
+    generatedFiles: generatedFiles.sort((a, b) => a.localeCompare(b))
+  };
+}
+
 // src/server/index.ts
-import { Hono as Hono10 } from "hono";
+import { Hono as Hono11 } from "hono";
 import { cors } from "hono/cors";
 import { logger } from "hono/logger";
 import { serve } from "@hono/node-server";
 import { serveStatic } from "@hono/node-server/serve-static";
-import * as path5 from "path";
-import * as fs5 from "fs";
+import * as path8 from "path";
+import * as fs8 from "fs";
 
 // src/server/api/index.ts
-import { Hono as Hono9 } from "hono";
+import { Hono as Hono10 } from "hono";
 
 // src/server/api/sessions.ts
 import { Hono } from "hono";
 
 // src/server/api/utils.ts
-import * as path3 from "path";
+import * as path6 from "path";
 import * as os3 from "os";
 function getServiceFromQuery(c) {
   const project = c.req.query("project");
@@ -6205,12 +7745,12 @@ function getServiceFromQuery(c) {
     const isHash = /^[a-f0-9]{8}$/.test(project);
     let storagePath;
     if (isHash) {
-      storagePath = path3.join(os3.homedir(), ".claude-code", "memory", "projects", project);
+      storagePath = path6.join(os3.homedir(), ".claude-code", "memory", "projects", project);
     } else {
       const crypto3 = __require("crypto");
       const normalized = project.replace(/\/+$/, "") || "/";
       const hash = crypto3.createHash("sha256").update(normalized).digest("hex").slice(0, 8);
-      storagePath = path3.join(os3.homedir(), ".claude-code", "memory", "projects", hash);
+      storagePath = path6.join(os3.homedir(), ".claude-code", "memory", "projects", hash);
     }
     return new MemoryService({
       storagePath,
@@ -6601,6 +8141,7 @@ statsRouter.get("/", async (c) => {
       acc[day] = (acc[day] || 0) + 1;
       return acc;
     }, {});
+    const retrievalTrace = await memoryService.getRetrievalTraceStats();
     return c.json({
       storage: {
         eventCount: stats.totalEvents,
@@ -6618,7 +8159,8 @@ statsRouter.get("/", async (c) => {
         heapUsed: Math.round(process.memoryUsage().heapUsed / 1024 / 1024),
         heapTotal: Math.round(process.memoryUsage().heapTotal / 1024 / 1024)
       },
-      levelStats: stats.levelStats
+      levelStats: stats.levelStats,
+      retrievalTrace
     });
   } catch (error) {
     return c.json({ error: error.message }, 500);
@@ -6720,6 +8262,42 @@ statsRouter.get("/helpfulness", async (c) => {
     await memoryService.shutdown();
   }
 });
+statsRouter.get("/retrieval-traces", async (c) => {
+  const limit = parseInt(c.req.query("limit") || "50", 10);
+  const memoryService = getServiceFromQuery(c);
+  try {
+    await memoryService.initialize();
+    const traces = await memoryService.getRecentRetrievalTraces(limit);
+    const traceStats = await memoryService.getRetrievalTraceStats();
+    return c.json({
+      stats: traceStats,
+      traces: traces.map((t) => ({
+        traceId: t.traceId,
+        sessionId: t.sessionId || null,
+        projectHash: t.projectHash || null,
+        queryText: t.queryText,
+        strategy: t.strategy || null,
+        candidateEventIds: t.candidateEventIds,
+        selectedEventIds: t.selectedEventIds,
+        candidateDetails: t.candidateDetails || [],
+        selectedDetails: t.selectedDetails || [],
+        candidateCount: t.candidateCount,
+        selectedCount: t.selectedCount,
+        confidence: t.confidence || null,
+        fallbackTrace: t.fallbackTrace,
+        createdAt: t.createdAt.toISOString()
+      }))
+    });
+  } catch (error) {
+    return c.json({
+      stats: { totalQueries: 0, avgCandidateCount: 0, avgSelectedCount: 0, selectionRate: 0 },
+      traces: [],
+      error: error.message
+    }, 500);
+  } finally {
+    await memoryService.shutdown();
+  }
+});
 statsRouter.post("/graduation/run", async (c) => {
   const memoryService = getServiceFromQuery(c);
   try {
@@ -6967,19 +8545,19 @@ turnsRouter.post("/backfill", async (c) => {
 
 // src/server/api/projects.ts
 import { Hono as Hono7 } from "hono";
-import * as fs4 from "fs";
-import * as path4 from "path";
+import * as fs7 from "fs";
+import * as path7 from "path";
 import * as os4 from "os";
 var projectsRouter = new Hono7();
 projectsRouter.get("/", async (c) => {
   try {
-    const projectsDir = path4.join(os4.homedir(), ".claude-code", "memory", "projects");
-    if (!fs4.existsSync(projectsDir)) {
+    const projectsDir = path7.join(os4.homedir(), ".claude-code", "memory", "projects");
+    if (!fs7.existsSync(projectsDir)) {
       return c.json({ projects: [] });
     }
-    const projectHashes = fs4.readdirSync(projectsDir).filter((name) => {
-      const fullPath = path4.join(projectsDir, name);
-      return fs4.statSync(fullPath).isDirectory();
+    const projectHashes = fs7.readdirSync(projectsDir).filter((name) => {
+      const fullPath = path7.join(projectsDir, name);
+      return fs7.statSync(fullPath).isDirectory();
     });
     const registry = loadSessionRegistry();
     const hashToPath = /* @__PURE__ */ new Map();
@@ -6989,17 +8567,17 @@ projectsRouter.get("/", async (c) => {
       }
     }
     const projects = projectHashes.map((hash) => {
-      const dirPath = path4.join(projectsDir, hash);
-      const dbPath = path4.join(dirPath, "events.sqlite");
+      const dirPath = path7.join(projectsDir, hash);
+      const dbPath = path7.join(dirPath, "events.sqlite");
       let dbSize = 0;
-      if (fs4.existsSync(dbPath)) {
-        dbSize = fs4.statSync(dbPath).size;
+      if (fs7.existsSync(dbPath)) {
+        dbSize = fs7.statSync(dbPath).size;
       }
       const projectPath = hashToPath.get(hash) || `unknown (${hash})`;
       return {
         hash,
         projectPath,
-        projectName: path4.basename(projectPath),
+        projectName: path7.basename(projectPath),
         dbSize,
         dbSizeHuman: formatBytes(dbSize)
       };
@@ -7124,7 +8702,7 @@ function buildPrompt(statsContext, memoryContext, history, currentMessage) {
   return parts.join("\n");
 }
 function streamClaudeResponse(prompt, stream) {
-  return new Promise((resolve2, reject) => {
+  return new Promise((resolve4, reject) => {
     const proc = spawn("claude", [
       "-p",
       "--output-format",
@@ -7196,29 +8774,71 @@ function streamClaudeResponse(prompt, stream) {
       if (code !== 0 && code !== null) {
         reject(new Error(`Claude CLI exited with code ${code}`));
       } else {
-        resolve2();
+        resolve4();
       }
     });
   });
 }
 
+// src/server/api/health.ts
+import { Hono as Hono9 } from "hono";
+var healthRouter = new Hono9();
+healthRouter.get("/", async (c) => {
+  const memoryService = getServiceFromQuery(c);
+  try {
+    await memoryService.initialize();
+    const [stats, outbox] = await Promise.all([
+      memoryService.getStats(),
+      memoryService.getOutboxStats()
+    ]);
+    const outboxPending = outbox.embedding.pending + outbox.vector.pending;
+    const outboxFailed = outbox.embedding.failed + outbox.vector.failed;
+    const status = outboxFailed > 0 ? "needs-attention" : "ok";
+    return c.json({
+      status,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      storage: {
+        totalEvents: stats.totalEvents,
+        vectorCount: stats.vectorCount
+      },
+      outbox: {
+        embedding: outbox.embedding,
+        vector: outbox.vector,
+        totals: {
+          pending: outboxPending,
+          failed: outboxFailed
+        }
+      },
+      levelStats: stats.levelStats
+    });
+  } catch (error) {
+    return c.json({
+      status: "error",
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      error: error.message
+    }, 500);
+  } finally {
+    await memoryService.shutdown();
+  }
+});
+
 // src/server/api/index.ts
-var apiRouter = new Hono9().route("/sessions", sessionsRouter).route("/events", eventsRouter).route("/search", searchRouter).route("/stats", statsRouter).route("/citations", citationsRouter).route("/turns", turnsRouter).route("/projects", projectsRouter).route("/chat", chatRouter);
+var apiRouter = new Hono10().route("/sessions", sessionsRouter).route("/events", eventsRouter).route("/search", searchRouter).route("/stats", statsRouter).route("/citations", citationsRouter).route("/turns", turnsRouter).route("/projects", projectsRouter).route("/chat", chatRouter).route("/health", healthRouter);
 
 // src/server/index.ts
-var app = new Hono10();
+var app = new Hono11();
 app.use("/*", cors());
 app.use("/*", logger());
 app.route("/api", apiRouter);
 app.get("/health", (c) => c.json({ status: "ok", timestamp: (/* @__PURE__ */ new Date()).toISOString() }));
-var uiPath = path5.join(__dirname, "../../dist/ui");
-if (fs5.existsSync(uiPath)) {
+var uiPath = path8.join(__dirname, "../../dist/ui");
+if (fs8.existsSync(uiPath)) {
   app.use("/*", serveStatic({ root: uiPath }));
 }
 app.get("*", (c) => {
-  const indexPath = path5.join(uiPath, "index.html");
-  if (fs5.existsSync(indexPath)) {
-    return c.html(fs5.readFileSync(indexPath, "utf-8"));
+  const indexPath = path8.join(uiPath, "index.html");
+  if (fs8.existsSync(indexPath)) {
+    return c.html(fs8.readFileSync(indexPath, "utf-8"));
   }
   return c.text('UI not built. Run "npm run build:ui" first.', 404);
 });
@@ -7255,29 +8875,303 @@ if (isMainModule) {
   startServer(port);
 }
 
+// src/core/mongo-sync-worker.ts
+import { randomUUID as randomUUID10 } from "crypto";
+import * as os5 from "os";
+import { MongoClient } from "mongodb";
+function redactMongoUri(uri) {
+  const schemeIdx = uri.indexOf("://");
+  if (schemeIdx === -1)
+    return uri;
+  const atIdx = uri.indexOf("@", schemeIdx + 3);
+  if (atIdx === -1)
+    return uri;
+  const creds = uri.slice(schemeIdx + 3, atIdx);
+  const colonIdx = creds.indexOf(":");
+  if (colonIdx === -1)
+    return uri;
+  const prefix = uri.slice(0, schemeIdx + 3 + colonIdx + 1);
+  const suffix = uri.slice(atIdx);
+  return `${prefix}***${suffix}`;
+}
+function parseIntOrZero(value) {
+  if (!value)
+    return 0;
+  const n = parseInt(value, 10);
+  return Number.isFinite(n) ? n : 0;
+}
+var MongoSyncWorker = class {
+  constructor(sqliteStore, config) {
+    this.sqliteStore = sqliteStore;
+    this.config = {
+      uri: config.uri,
+      dbName: config.dbName,
+      projectKey: config.projectKey,
+      direction: config.direction ?? "both",
+      intervalMs: config.intervalMs ?? 3e4,
+      batchSize: config.batchSize ?? 500,
+      instanceId: config.instanceId ?? randomUUID10()
+    };
+  }
+  config;
+  intervalHandle = null;
+  running = false;
+  client = null;
+  db = null;
+  counters = null;
+  events = null;
+  indexesEnsured = false;
+  stats = {
+    lastSyncAt: null,
+    pushedEvents: 0,
+    pulledEvents: 0,
+    errors: 0,
+    status: "idle"
+  };
+  start() {
+    if (this.running)
+      return;
+    this.running = true;
+    this.stats.status = "idle";
+    this.syncNow().catch((err) => {
+      console.error("[MongoSyncWorker] Initial sync failed:", err);
+    });
+    this.intervalHandle = setInterval(() => {
+      this.syncNow().catch((err) => {
+        console.error("[MongoSyncWorker] Periodic sync failed:", err);
+      });
+    }, this.config.intervalMs);
+  }
+  stop() {
+    this.running = false;
+    this.stats.status = "stopped";
+    if (this.intervalHandle) {
+      clearInterval(this.intervalHandle);
+      this.intervalHandle = null;
+    }
+  }
+  async shutdown() {
+    this.stop();
+    await this.disconnect();
+  }
+  getStats() {
+    return { ...this.stats };
+  }
+  isRunning() {
+    return this.running;
+  }
+  async syncNow() {
+    if (this.stats.status === "syncing")
+      return { pushed: 0, pulled: 0 };
+    this.stats.status = "syncing";
+    let pushed = 0;
+    let pulled = 0;
+    try {
+      await this.sqliteStore.initialize();
+      await this.ensureConnected();
+      await this.ensureIndexes();
+      if (this.config.direction === "push" || this.config.direction === "both") {
+        pushed = await this.pushEvents();
+        this.stats.pushedEvents += pushed;
+      }
+      if (this.config.direction === "pull" || this.config.direction === "both") {
+        pulled = await this.pullEvents();
+        this.stats.pulledEvents += pulled;
+      }
+      this.stats.lastSyncAt = /* @__PURE__ */ new Date();
+      this.stats.status = "idle";
+      return { pushed, pulled };
+    } catch (error) {
+      this.stats.errors++;
+      this.stats.status = "error";
+      throw error;
+    }
+  }
+  async ensureConnected() {
+    if (this.client && this.db && this.counters && this.events)
+      return;
+    try {
+      this.client = new MongoClient(this.config.uri, {
+        appName: "claude-memory-layer",
+        serverSelectionTimeoutMS: 5e3
+      });
+      await this.client.connect();
+      this.db = this.client.db(this.config.dbName);
+      this.counters = this.db.collection("cml_counters");
+      this.events = this.db.collection("cml_events");
+    } catch (err) {
+      const safeUri = redactMongoUri(this.config.uri);
+      throw new Error(`MongoDB connection failed (${safeUri}, db=${this.config.dbName}): ${String(err)}`);
+    }
+  }
+  async disconnect() {
+    try {
+      await this.client?.close();
+    } finally {
+      this.client = null;
+      this.db = null;
+      this.counters = null;
+      this.events = null;
+      this.indexesEnsured = false;
+    }
+  }
+  async ensureIndexes() {
+    if (this.indexesEnsured)
+      return;
+    if (!this.events || !this.counters)
+      throw new Error("Mongo not connected");
+    try {
+      await this.events.createIndex({ projectKey: 1, seq: 1 }, { unique: true });
+      await this.events.createIndex({ projectKey: 1, eventId: 1 }, { unique: true });
+      await this.events.createIndex({ projectKey: 1, dedupeKey: 1 });
+    } catch (err) {
+      console.warn("[MongoSyncWorker] Failed to ensure indexes (continuing):", err);
+    }
+    this.indexesEnsured = true;
+  }
+  counterKey(kind) {
+    return `${kind}:${this.config.projectKey}`;
+  }
+  async allocateSeqRange(kind, count) {
+    if (!this.counters)
+      throw new Error("Mongo not connected");
+    if (count <= 0)
+      return 1;
+    const key = this.counterKey(kind);
+    const doc = await this.counters.findOneAndUpdate(
+      { _id: key },
+      { $inc: { seq: count } },
+      { upsert: true, returnDocument: "after" }
+    );
+    const endSeq = doc?.seq;
+    if (typeof endSeq !== "number") {
+      throw new Error(`Failed to allocate seq range for ${key}`);
+    }
+    return endSeq - count + 1;
+  }
+  pushTargetName() {
+    return `mongo_push_events_rowid:${this.config.projectKey}`;
+  }
+  pullTargetName() {
+    return `mongo_pull_events_seq:${this.config.projectKey}`;
+  }
+  async pushEvents() {
+    if (!this.events)
+      throw new Error("Mongo not connected");
+    const position = await this.sqliteStore.getSyncPosition(this.pushTargetName());
+    let lastRowid = parseIntOrZero(position.lastEventId);
+    let pushed = 0;
+    while (true) {
+      const batch = await this.sqliteStore.getEventsSinceRowid(lastRowid, this.config.batchSize);
+      if (batch.length === 0)
+        break;
+      const startSeq = await this.allocateSeqRange("events", batch.length);
+      const now = /* @__PURE__ */ new Date();
+      const hostname2 = os5.hostname();
+      const ops = batch.map((item, idx) => {
+        const event = item.event;
+        const seq = startSeq + idx;
+        const docId = `${this.config.projectKey}:${event.id}`;
+        return {
+          updateOne: {
+            filter: { _id: docId },
+            update: {
+              $setOnInsert: {
+                _id: docId,
+                projectKey: this.config.projectKey,
+                seq,
+                eventId: event.id,
+                eventType: event.eventType,
+                sessionId: event.sessionId,
+                timestamp: event.timestamp,
+                content: event.content,
+                canonicalKey: event.canonicalKey,
+                dedupeKey: event.dedupeKey,
+                metadata: event.metadata ?? null,
+                insertedAt: now,
+                updatedAt: now,
+                source: { hostname: hostname2, instanceId: this.config.instanceId }
+              }
+            },
+            upsert: true
+          }
+        };
+      });
+      await this.events.bulkWrite(ops, { ordered: false });
+      const last = batch[batch.length - 1];
+      lastRowid = last.rowid;
+      await this.sqliteStore.updateSyncPosition(
+        this.pushTargetName(),
+        String(lastRowid),
+        last.event.timestamp.toISOString()
+      );
+      pushed += batch.length;
+      if (batch.length < this.config.batchSize)
+        break;
+    }
+    return pushed;
+  }
+  async pullEvents() {
+    if (!this.events)
+      throw new Error("Mongo not connected");
+    const position = await this.sqliteStore.getSyncPosition(this.pullTargetName());
+    let lastSeq = parseIntOrZero(position.lastEventId);
+    let pulled = 0;
+    while (true) {
+      const docs = await this.events.find(
+        { projectKey: this.config.projectKey, seq: { $gt: lastSeq } },
+        { sort: { seq: 1 }, limit: this.config.batchSize }
+      ).toArray();
+      if (docs.length === 0)
+        break;
+      const events = docs.map((d) => ({
+        id: d.eventId,
+        eventType: d.eventType,
+        sessionId: d.sessionId,
+        timestamp: d.timestamp instanceof Date ? d.timestamp : new Date(d.timestamp),
+        content: d.content,
+        canonicalKey: d.canonicalKey,
+        dedupeKey: d.dedupeKey,
+        metadata: d.metadata ?? void 0
+      }));
+      const result = await this.sqliteStore.importEvents(events);
+      pulled += result.inserted;
+      lastSeq = docs[docs.length - 1].seq;
+      await this.sqliteStore.updateSyncPosition(
+        this.pullTargetName(),
+        String(lastSeq),
+        (/* @__PURE__ */ new Date()).toISOString()
+      );
+      if (docs.length < this.config.batchSize)
+        break;
+    }
+    return pulled;
+  }
+};
+
 // src/cli/index.ts
-var CLAUDE_SETTINGS_PATH = path6.join(os5.homedir(), ".claude", "settings.json");
+var CLAUDE_SETTINGS_PATH = path9.join(os6.homedir(), ".claude", "settings.json");
 function getPluginPath() {
   const possiblePaths = [
-    path6.join(__dirname, ".."),
+    path9.join(__dirname, ".."),
     // When running from dist/cli
-    path6.join(__dirname, "../..", "dist"),
+    path9.join(__dirname, "../..", "dist"),
     // When running from src
-    path6.join(process.cwd(), "dist")
+    path9.join(process.cwd(), "dist")
     // Current working directory
   ];
   for (const p of possiblePaths) {
-    const hooksPath = path6.join(p, "hooks", "user-prompt-submit.js");
-    if (fs6.existsSync(hooksPath)) {
+    const hooksPath = path9.join(p, "hooks", "user-prompt-submit.js");
+    if (fs9.existsSync(hooksPath)) {
       return p;
     }
   }
-  return path6.join(os5.homedir(), ".npm-global", "lib", "node_modules", "claude-memory-layer", "dist");
+  return path9.join(os6.homedir(), ".npm-global", "lib", "node_modules", "claude-memory-layer", "dist");
 }
 function loadClaudeSettings() {
   try {
-    if (fs6.existsSync(CLAUDE_SETTINGS_PATH)) {
-      const content = fs6.readFileSync(CLAUDE_SETTINGS_PATH, "utf-8");
+    if (fs9.existsSync(CLAUDE_SETTINGS_PATH)) {
+      const content = fs9.readFileSync(CLAUDE_SETTINGS_PATH, "utf-8");
       return JSON.parse(content);
     }
   } catch (error) {
@@ -7286,13 +9180,13 @@ function loadClaudeSettings() {
   return {};
 }
 function saveClaudeSettings(settings) {
-  const dir = path6.dirname(CLAUDE_SETTINGS_PATH);
-  if (!fs6.existsSync(dir)) {
-    fs6.mkdirSync(dir, { recursive: true });
+  const dir = path9.dirname(CLAUDE_SETTINGS_PATH);
+  if (!fs9.existsSync(dir)) {
+    fs9.mkdirSync(dir, { recursive: true });
   }
   const tempPath = CLAUDE_SETTINGS_PATH + ".tmp";
-  fs6.writeFileSync(tempPath, JSON.stringify(settings, null, 2));
-  fs6.renameSync(tempPath, CLAUDE_SETTINGS_PATH);
+  fs9.writeFileSync(tempPath, JSON.stringify(settings, null, 2));
+  fs9.renameSync(tempPath, CLAUDE_SETTINGS_PATH);
 }
 function getHooksConfig(pluginPath) {
   return {
@@ -7302,7 +9196,7 @@ function getHooksConfig(pluginPath) {
         hooks: [
           {
             type: "command",
-            command: `node ${path6.join(pluginPath, "hooks", "user-prompt-submit.js")}`
+            command: `node ${path9.join(pluginPath, "hooks", "user-prompt-submit.js")}`
           }
         ]
       }
@@ -7313,7 +9207,7 @@ function getHooksConfig(pluginPath) {
         hooks: [
           {
             type: "command",
-            command: `node ${path6.join(pluginPath, "hooks", "post-tool-use.js")}`
+            command: `node ${path9.join(pluginPath, "hooks", "post-tool-use.js")}`
           }
         ]
       }
@@ -7321,12 +9215,12 @@ function getHooksConfig(pluginPath) {
   };
 }
 var program = new Command();
-program.name("claude-memory-layer").description("Claude Code Memory Plugin CLI").version("1.0.0");
+program.name("claude-memory-layer").description("Claude Code Memory Plugin CLI").version("1.0.12");
 program.command("install").description("Install hooks into Claude Code settings").option("--path <path>", "Custom plugin path (defaults to auto-detect)").action(async (options) => {
   try {
     const pluginPath = options.path || getPluginPath();
-    const userPromptHook = path6.join(pluginPath, "hooks", "user-prompt-submit.js");
-    if (!fs6.existsSync(userPromptHook)) {
+    const userPromptHook = path9.join(pluginPath, "hooks", "user-prompt-submit.js");
+    if (!fs9.existsSync(userPromptHook)) {
       console.error(`
 \u274C Hook files not found at: ${pluginPath}`);
       console.error('   Make sure you have built the plugin with "npm run build"');
@@ -7392,7 +9286,7 @@ program.command("status").description("Check plugin installation status").action
     console.log("Hooks:");
     console.log(`  UserPromptSubmit: ${hasUserPromptHook ? "\u2705 Installed" : "\u274C Not installed"}`);
     console.log(`  PostToolUse: ${hasPostToolHook ? "\u2705 Installed" : "\u274C Not installed"}`);
-    const hooksExist = fs6.existsSync(path6.join(pluginPath, "hooks", "user-prompt-submit.js"));
+    const hooksExist = fs9.existsSync(path9.join(pluginPath, "hooks", "user-prompt-submit.js"));
     console.log(`
 Plugin files: ${hooksExist ? "\u2705 Found" : "\u274C Not found"}`);
     console.log(`  Path: ${pluginPath}`);
@@ -7520,6 +9414,81 @@ program.command("process").description("Process pending embeddings").option("-p,
     process.exit(1);
   }
 });
+program.command("mongo-sync").description("Sync events with MongoDB for multi-server collaboration (optional)").option("-p, --project <path>", "Project path (defaults to cwd)").option("--mongo-uri <uri>", "MongoDB connection URI (env: CLAUDE_MEMORY_MONGO_URI)").option("--mongo-db <name>", "MongoDB database name (env: CLAUDE_MEMORY_MONGO_DB)").option("--mongo-project <key>", "Remote project key (env: CLAUDE_MEMORY_MONGO_PROJECT, default: basename(projectPath))").option("--direction <dir>", "push|pull|both", "both").option("--batch-size <n>", "Batch size", "500").option("--interval <ms>", "Watch interval ms", "30000").option("--watch", "Run continuously").action(async (options) => {
+  const projectPath = options.project || process.cwd();
+  const mongoUri = options.mongoUri || process.env.CLAUDE_MEMORY_MONGO_URI;
+  const mongoDb = options.mongoDb || process.env.CLAUDE_MEMORY_MONGO_DB;
+  const projectKey = options.mongoProject || process.env.CLAUDE_MEMORY_MONGO_PROJECT || path9.basename(projectPath);
+  const direction = String(options.direction || "both").toLowerCase();
+  if (!mongoUri || !mongoDb) {
+    console.error("\n\u274C MongoDB sync is not configured.");
+    console.error("   Set --mongo-uri/--mongo-db or env CLAUDE_MEMORY_MONGO_URI/CLAUDE_MEMORY_MONGO_DB.\n");
+    process.exit(1);
+  }
+  if (!["push", "pull", "both"].includes(direction)) {
+    console.error("\n\u274C Invalid --direction. Use: push | pull | both\n");
+    process.exit(1);
+  }
+  const storagePath = getProjectStoragePath(projectPath);
+  if (!fs9.existsSync(storagePath)) {
+    fs9.mkdirSync(storagePath, { recursive: true });
+  }
+  const batchSizeParsed = parseInt(options.batchSize, 10);
+  const intervalParsed = parseInt(options.interval, 10);
+  const batchSize = Number.isFinite(batchSizeParsed) && batchSizeParsed > 0 ? batchSizeParsed : 500;
+  const intervalMs = Number.isFinite(intervalParsed) && intervalParsed > 0 ? intervalParsed : 3e4;
+  const sqliteStore = new SQLiteEventStore(path9.join(storagePath, "events.sqlite"));
+  const worker = new MongoSyncWorker(sqliteStore, {
+    uri: mongoUri,
+    dbName: mongoDb,
+    projectKey,
+    direction,
+    batchSize,
+    intervalMs
+  });
+  const runOnce = async () => {
+    const { pushed, pulled } = await worker.syncNow();
+    const ts = (/* @__PURE__ */ new Date()).toISOString();
+    process.stdout.write(`[mongo-sync] ${ts} project=${projectKey} pushed=${pushed} pulled=${pulled}
+`);
+  };
+  try {
+    if (!options.watch) {
+      await runOnce();
+      await worker.shutdown();
+      sqliteStore.close();
+      return;
+    }
+    console.log(`[mongo-sync] Watch mode started (interval=${intervalMs}ms, project=${projectKey})`);
+    const handle = setInterval(() => {
+      runOnce().catch((err) => {
+        console.error("[mongo-sync] Sync failed:", err);
+      });
+    }, intervalMs);
+    const shutdown = async () => {
+      clearInterval(handle);
+      console.log("\n[mongo-sync] Shutting down...");
+      try {
+        await worker.shutdown();
+      } finally {
+        sqliteStore.close();
+      }
+      process.exit(0);
+    };
+    process.on("SIGINT", () => {
+      void shutdown();
+    });
+    process.on("SIGTERM", () => {
+      void shutdown();
+    });
+    await runOnce();
+    await new Promise(() => {
+    });
+  } catch (error) {
+    console.error("[mongo-sync] Failed:", error);
+    process.exit(1);
+  }
+});
 function renderProgress(event) {
   switch (event.phase) {
     case "scan":
@@ -7527,7 +9496,7 @@ function renderProgress(event) {
       break;
     case "session-start": {
       const pct = Math.round(event.sessionIndex / event.totalSessions * 100);
-      const sessionName = path6.basename(event.filePath, ".jsonl").slice(0, 8);
+      const sessionName = path9.basename(event.filePath, ".jsonl").slice(0, 8);
       process.stdout.write(
         `\r  \u{1F4C4} [${event.sessionIndex + 1}/${event.totalSessions}] ${pct}% | Session ${sessionName}... `
       );
@@ -7593,6 +9562,140 @@ function printImportSummary(result, embedCount) {
     }
   }
 }
+function sanitizeSegment3(input, fallback) {
+  const v = (input || "").trim().toLowerCase().replace(/[^a-z0-9._-]+/g, "-").replace(/^-+|-+$/g, "");
+  return v || fallback;
+}
+async function listMarkdownFiles(root) {
+  const out = [];
+  const stack = [root];
+  while (stack.length > 0) {
+    const dir = stack.pop();
+    const entries = await fs9.promises.readdir(dir, { withFileTypes: true });
+    for (const e of entries) {
+      const full = path9.join(dir, e.name);
+      if (e.isDirectory())
+        stack.push(full);
+      else if (e.isFile() && e.name.endsWith(".md") && e.name !== "_index.md")
+        out.push(full);
+    }
+  }
+  return out.sort();
+}
+function deriveNamespaceCategory(sourceRoot, filePath) {
+  const rel = path9.relative(sourceRoot, filePath);
+  const dirSeg = path9.dirname(rel).split(path9.sep).filter(Boolean);
+  if (dirSeg.length >= 2) {
+    const namespace = sanitizeSegment3(dirSeg[0], "default");
+    const categoryPath = dirSeg.slice(1).map((s) => sanitizeSegment3(s, "uncategorized"));
+    return { namespace, categoryPath: categoryPath.length > 0 ? categoryPath : ["uncategorized"] };
+  }
+  return { namespace: "default", categoryPath: ["uncategorized"] };
+}
+function extractImportEvidence(markdown) {
+  const confidenceMatch = markdown.match(/^-\s*confidence:\s*([^\n]+)/m);
+  const sources = markdown.split(/\r?\n/).map((line) => line.trim()).filter((line) => line.startsWith("- source:")).map((line) => line.replace(/^-\s*source:\s*/i, "").trim()).filter(Boolean).slice(0, 30);
+  return {
+    confidence: confidenceMatch ? confidenceMatch[1].trim() : void 0,
+    sources
+  };
+}
+program.command("organize-import [sourceDir]").description("Import existing markdown memory files, or bootstrap knowledge docs from codebase/git when markdown is missing").option("-p, --project <path>", "Project path (defaults to cwd)").option("--session <id>", "Session id for imported events (default: import:organized)").option("--limit <n>", "Limit number of files to import").option("--dry-run", "Preview mapping without writing").option("--bootstrap", "Force-generate structured markdown from codebase + git history before import").option("--bootstrap-if-empty", "Auto-bootstrap when source has no markdown files (default: true)", true).option("--no-bootstrap-if-empty", "Disable auto-bootstrap when source has no markdown files").option("--force-bootstrap", "Run bootstrap even when markdown files exist").option("--repo <path>", "Repository root for bootstrap analysis (default: project path)").option("--out <path>", "Output directory for generated bootstrap markdown (default: <sourceDir>/bootstrap-kb)").option("--since <range>", 'Git history range for bootstrap (default: "180 days ago")').option("--max-commits <n>", "Max commits to analyze for bootstrap (default: 1000)").option("--incremental", "Use previous bootstrap manifest as baseline for incremental updates (default: true)", true).option("--no-incremental", "Disable incremental bootstrap; regenerate full snapshot").action(async (sourceDir, options) => {
+  const projectPath = options.project || process.cwd();
+  const sessionId = options.session || "import:organized";
+  const sourceRoot = path9.resolve(sourceDir || options.out || projectPath);
+  const repoPath = path9.resolve(options.repo || projectPath);
+  if (!fs9.existsSync(sourceRoot)) {
+    fs9.mkdirSync(sourceRoot, { recursive: true });
+  }
+  const service = getMemoryServiceForProject(projectPath);
+  try {
+    let activeSourceRoot = sourceRoot;
+    let importRoot = sourceRoot;
+    let files = await listMarkdownFiles(importRoot);
+    const hasMarkdown = files.length > 0;
+    const shouldBootstrap = Boolean(options.forceBootstrap || options.bootstrap || !hasMarkdown && options.bootstrapIfEmpty);
+    if (shouldBootstrap) {
+      const outDir = path9.resolve(options.out || path9.join(sourceRoot, "bootstrap-kb"));
+      const since = options.since || "180 days ago";
+      const maxCommits = options.maxCommits ? Math.max(1, parseInt(options.maxCommits, 10)) : 1e3;
+      console.log("\n\u{1F9E0} Bootstrapping markdown knowledge base...");
+      const bootstrap = await bootstrapKnowledgeBase({
+        repoPath,
+        outDir,
+        since,
+        maxCommits,
+        incremental: options.incremental
+      });
+      console.log(`  Repo: ${repoPath}`);
+      console.log(`  Output: ${bootstrap.outDir}`);
+      console.log(`  Files analyzed: ${bootstrap.fileCount}`);
+      console.log(`  Commits analyzed: ${bootstrap.commitCount}`);
+      console.log(`  Modules: ${bootstrap.moduleCount}`);
+      activeSourceRoot = outDir;
+      importRoot = outDir;
+      files = await listMarkdownFiles(importRoot);
+    }
+    if (files.length === 0) {
+      console.error("\n\u274C organize-import found no markdown files to import.\n");
+      process.exit(1);
+    }
+    const limit = options.limit ? Math.max(1, parseInt(options.limit, 10)) : files.length;
+    const targets = files.slice(0, limit);
+    console.log(`
+\u{1F4E6} organize-import`);
+    console.log(`  Source: ${activeSourceRoot}`);
+    console.log(`  Project: ${projectPath}`);
+    console.log(`  Files: ${targets.length}${targets.length < files.length ? `/${files.length}` : ""}`);
+    console.log(`  Dry-run: ${options.dryRun ? "yes" : "no"}
+`);
+    if (!options.dryRun) {
+      await service.initialize();
+    }
+    let imported = 0;
+    let skipped = 0;
+    for (const file of targets) {
+      const text = await fs9.promises.readFile(file, "utf8");
+      if (!text.trim()) {
+        skipped += 1;
+        continue;
+      }
+      const { namespace, categoryPath } = deriveNamespaceCategory(activeSourceRoot, file);
+      const rel = path9.relative(activeSourceRoot, file);
+      const evidence = extractImportEvidence(text);
+      if (options.dryRun) {
+        console.log(`- ${rel} -> namespace=${namespace} category=${categoryPath.join("/")} confidence=${evidence.confidence || "n/a"} sources=${evidence.sources.length}`);
+        continue;
+      }
+      await service.storeSessionSummary(sessionId, text, {
+        namespace,
+        categoryPath,
+        confidence: evidence.confidence,
+        sources: evidence.sources,
+        import: {
+          sourceFile: rel,
+          importedAt: (/* @__PURE__ */ new Date()).toISOString(),
+          bootstrap: shouldBootstrap === true
+        }
+      });
+      imported += 1;
+    }
+    if (!options.dryRun) {
+      const embed = await service.processPendingEmbeddings();
+      await service.shutdown();
+      console.log(`
+\u2705 Imported: ${imported}, skipped-empty: ${skipped}, embeddings: ${embed}
+`);
+    } else {
+      console.log(`
+\u2705 Dry-run complete (planned imports: ${targets.length - skipped}, skipped-empty: ${skipped})
+`);
+    }
+  } catch (error) {
+    console.error("\n\u274C organize-import failed:", error);
+    process.exit(1);
+  }
+});
 program.command("import").description("Import existing Claude Code conversation history").option("-p, --project <path>", "Import from specific project path").option("-s, --session <file>", "Import specific session file (JSONL)").option("-a, --all", "Import all sessions from all projects").option("-l, --limit <number>", "Limit messages per session").option("-f, --force", "Force reimport: delete existing events and reimport with turn_id grouping").option("-v, --verbose", "Show detailed progress").action(async (options) => {
   const startTime = Date.now();
   const targetProjectPath = options.project || process.cwd();