claude-memory-layer 1.0.24 → 1.0.25

package/dist/services/memory-service.js

@@ -11,744 +11,31 @@ import * as os from "os";
 import * as fs4 from "fs";
 import * as crypto2 from "crypto";
 
-// src/core/event-store.ts
-import { randomUUID } from "crypto";
-
-// src/core/canonical-key.ts
-import { createHash } from "crypto";
-var MAX_KEY_LENGTH = 200;
-function makeCanonicalKey(title, context) {
-  let normalized = title.normalize("NFKC");
-  normalized = normalized.toLowerCase();
-  normalized = normalized.replace(/[^\p{L}\p{N}\s]/gu, "");
-  normalized = normalized.replace(/\s+/g, " ").trim();
-  let key = normalized;
-  if (context?.project) {
-    key = `${context.project}::${key}`;
-  }
-  if (key.length > MAX_KEY_LENGTH) {
-    const hashSuffix = createHash("md5").update(key).digest("hex").slice(0, 8);
-    key = key.slice(0, MAX_KEY_LENGTH - 9) + "_" + hashSuffix;
-  }
-  return key;
-}
-function makeDedupeKey(content, sessionId) {
-  const contentHash = createHash("sha256").update(content).digest("hex");
-  return `${sessionId}:${contentHash}`;
-}
-
-// src/core/db-wrapper.ts
-import duckdb from "duckdb";
-function convertBigInts(obj) {
-  if (obj === null || obj === void 0)
-    return obj;
-  if (typeof obj === "bigint")
-    return Number(obj);
-  if (obj instanceof Date)
-    return obj;
-  if (Array.isArray(obj))
-    return obj.map(convertBigInts);
-  if (typeof obj === "object") {
-    const result = {};
-    for (const [key, value] of Object.entries(obj)) {
-      result[key] = convertBigInts(value);
-    }
-    return result;
-  }
-  return obj;
-}
-function toDate(value) {
-  if (value instanceof Date)
-    return value;
-  if (typeof value === "string")
-    return new Date(value);
-  if (typeof value === "number")
-    return new Date(value);
-  return new Date(String(value));
-}
-function createDatabase(path4, options) {
-  if (options?.readOnly) {
-    return new duckdb.Database(path4, { access_mode: "READ_ONLY" });
-  }
-  return new duckdb.Database(path4);
-}
-function dbRun(db, sql, params = []) {
-  return new Promise((resolve2, reject) => {
-    if (params.length === 0) {
-      db.run(sql, (err) => {
-        if (err)
-          reject(err);
-        else
-          resolve2();
-      });
-    } else {
-      db.run(sql, ...params, (err) => {
-        if (err)
-          reject(err);
-        else
-          resolve2();
-      });
-    }
-  });
-}
-function dbAll(db, sql, params = []) {
-  return new Promise((resolve2, reject) => {
-    if (params.length === 0) {
-      db.all(sql, (err, rows) => {
-        if (err)
-          reject(err);
-        else
-          resolve2(convertBigInts(rows || []));
-      });
-    } else {
-      db.all(sql, ...params, (err, rows) => {
-        if (err)
-          reject(err);
-        else
-          resolve2(convertBigInts(rows || []));
-      });
-    }
-  });
-}
-function dbClose(db) {
-  return new Promise((resolve2, reject) => {
-    db.close((err) => {
-      if (err)
-        reject(err);
-      else
-        resolve2();
-    });
-  });
-}
-
-// src/core/event-store.ts
-var EventStore = class {
-  constructor(dbPath, options) {
-    this.dbPath = dbPath;
-    this.readOnly = options?.readOnly ?? false;
-    this.db = createDatabase(dbPath, { readOnly: this.readOnly });
-  }
-  db;
-  initialized = false;
-  readOnly;
-  /**
-   * Initialize database schema
-   */
-  async initialize() {
-    if (this.initialized)
-      return;
-    if (this.readOnly) {
-      this.initialized = true;
-      return;
-    }
-    await dbRun(this.db, `
-      CREATE TABLE IF NOT EXISTS events (
-        id VARCHAR PRIMARY KEY,
-        event_type VARCHAR NOT NULL,
-        session_id VARCHAR NOT NULL,
-        timestamp TIMESTAMP NOT NULL,
-        content TEXT NOT NULL,
-        canonical_key VARCHAR NOT NULL,
-        dedupe_key VARCHAR UNIQUE,
-        metadata JSON
-      )
-    `);
-    await dbRun(this.db, `
-      CREATE TABLE IF NOT EXISTS event_dedup (
-        dedupe_key VARCHAR PRIMARY KEY,
-        event_id VARCHAR NOT NULL,
-        created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
-      )
-    `);
-    await dbRun(this.db, `
-      CREATE TABLE IF NOT EXISTS sessions (
-        id VARCHAR PRIMARY KEY,
-        started_at TIMESTAMP NOT NULL,
-        ended_at TIMESTAMP,
-        project_path VARCHAR,
-        summary TEXT,
-        tags JSON
-      )
-    `);
-    await dbRun(this.db, `
-      CREATE TABLE IF NOT EXISTS insights (
-        id VARCHAR PRIMARY KEY,
-        insight_type VARCHAR NOT NULL,
-        content TEXT NOT NULL,
-        canonical_key VARCHAR NOT NULL,
-        confidence FLOAT,
-        source_events JSON,
-        created_at TIMESTAMP,
-        last_updated TIMESTAMP
-      )
-    `);
-    await dbRun(this.db, `
-      CREATE TABLE IF NOT EXISTS embedding_outbox (
-        id VARCHAR PRIMARY KEY,
-        event_id VARCHAR NOT NULL,
-        content TEXT NOT NULL,
-        status VARCHAR DEFAULT 'pending',
-        retry_count INT DEFAULT 0,
-        created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
-        processed_at TIMESTAMP,
-        error_message TEXT
-      )
-    `);
-    await dbRun(this.db, `
-      CREATE TABLE IF NOT EXISTS projection_offsets (
-        projection_name VARCHAR PRIMARY KEY,
-        last_event_id VARCHAR,
-        last_timestamp TIMESTAMP,
-        updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
-      )
-    `);
-    await dbRun(this.db, `
-      CREATE TABLE IF NOT EXISTS memory_levels (
-        event_id VARCHAR PRIMARY KEY,
-        level VARCHAR NOT NULL DEFAULT 'L0',
-        promoted_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
-      )
-    `);
-    await dbRun(this.db, `
-      CREATE TABLE IF NOT EXISTS entries (
-        entry_id VARCHAR PRIMARY KEY,
-        created_ts TIMESTAMP NOT NULL,
-        entry_type VARCHAR NOT NULL,
-        title VARCHAR NOT NULL,
-        content_json JSON NOT NULL,
-        stage VARCHAR NOT NULL DEFAULT 'raw',
-        status VARCHAR DEFAULT 'active',
-        superseded_by VARCHAR,
-        build_id VARCHAR,
-        evidence_json JSON,
-        canonical_key VARCHAR,
-        created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
-      )
-    `);
-    await dbRun(this.db, `
-      CREATE TABLE IF NOT EXISTS entities (
-        entity_id VARCHAR PRIMARY KEY,
-        entity_type VARCHAR NOT NULL,
-        canonical_key VARCHAR NOT NULL,
-        title VARCHAR NOT NULL,
-        stage VARCHAR NOT NULL DEFAULT 'raw',
-        status VARCHAR NOT NULL DEFAULT 'active',
-        current_json JSON NOT NULL,
-        title_norm VARCHAR,
-        search_text VARCHAR,
-        created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
-        updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
-      )
-    `);
-    await dbRun(this.db, `
-      CREATE TABLE IF NOT EXISTS entity_aliases (
-        entity_type VARCHAR NOT NULL,
-        canonical_key VARCHAR NOT NULL,
-        entity_id VARCHAR NOT NULL,
-        is_primary BOOLEAN DEFAULT FALSE,
-        created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
-        PRIMARY KEY(entity_type, canonical_key)
-      )
-    `);
-    await dbRun(this.db, `
-      CREATE TABLE IF NOT EXISTS edges (
-        edge_id VARCHAR PRIMARY KEY,
-        src_type VARCHAR NOT NULL,
-        src_id VARCHAR NOT NULL,
-        rel_type VARCHAR NOT NULL,
-        dst_type VARCHAR NOT NULL,
-        dst_id VARCHAR NOT NULL,
-        meta_json JSON,
-        created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
-      )
-    `);
-    await dbRun(this.db, `
-      CREATE TABLE IF NOT EXISTS vector_outbox (
-        job_id VARCHAR PRIMARY KEY,
-        item_kind VARCHAR NOT NULL,
-        item_id VARCHAR NOT NULL,
-        embedding_version VARCHAR NOT NULL,
-        status VARCHAR NOT NULL DEFAULT 'pending',
-        retry_count INT DEFAULT 0,
-        error VARCHAR,
-        created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
-        updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
-        UNIQUE(item_kind, item_id, embedding_version)
-      )
-    `);
-    await dbRun(this.db, `
-      CREATE TABLE IF NOT EXISTS build_runs (
-        build_id VARCHAR PRIMARY KEY,
-        started_at TIMESTAMP NOT NULL,
-        finished_at TIMESTAMP,
-        extractor_model VARCHAR NOT NULL,
-        extractor_prompt_hash VARCHAR NOT NULL,
-        embedder_model VARCHAR NOT NULL,
-        embedding_version VARCHAR NOT NULL,
-        idris_version VARCHAR NOT NULL,
-        schema_version VARCHAR NOT NULL,
-        status VARCHAR NOT NULL DEFAULT 'running',
-        error VARCHAR
-      )
-    `);
-    await dbRun(this.db, `
-      CREATE TABLE IF NOT EXISTS pipeline_metrics (
-        id VARCHAR PRIMARY KEY,
-        ts TIMESTAMP NOT NULL,
-        stage VARCHAR NOT NULL,
-        latency_ms DOUBLE NOT NULL,
-        success BOOLEAN NOT NULL,
-        error VARCHAR,
-        session_id VARCHAR
-      )
-    `);
-    await dbRun(this.db, `
-      CREATE TABLE IF NOT EXISTS working_set (
-        id VARCHAR PRIMARY KEY,
-        event_id VARCHAR NOT NULL,
-        added_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
-        relevance_score FLOAT DEFAULT 1.0,
-        topics JSON,
-        expires_at TIMESTAMP
-      )
-    `);
-    await dbRun(this.db, `
-      CREATE TABLE IF NOT EXISTS consolidated_memories (
-        memory_id VARCHAR PRIMARY KEY,
-        summary TEXT NOT NULL,
-        topics JSON,
-        source_events JSON,
-        confidence FLOAT DEFAULT 0.5,
-        created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
-        accessed_at TIMESTAMP,
-        access_count INTEGER DEFAULT 0
-      )
-    `);
-    await dbRun(this.db, `
-      CREATE TABLE IF NOT EXISTS continuity_log (
-        log_id VARCHAR PRIMARY KEY,
-        from_context_id VARCHAR,
-        to_context_id VARCHAR,
-        continuity_score FLOAT,
-        transition_type VARCHAR,
-        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,
-        value JSON,
-        updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
-      )
-    `);
-    await dbRun(this.db, `CREATE INDEX IF NOT EXISTS idx_entries_type ON entries(entry_type)`);
-    await dbRun(this.db, `CREATE INDEX IF NOT EXISTS idx_entries_stage ON entries(stage)`);
-    await dbRun(this.db, `CREATE INDEX IF NOT EXISTS idx_entries_canonical ON entries(canonical_key)`);
-    await dbRun(this.db, `CREATE INDEX IF NOT EXISTS idx_entities_type_key ON entities(entity_type, canonical_key)`);
-    await dbRun(this.db, `CREATE INDEX IF NOT EXISTS idx_entities_status ON entities(status)`);
-    await dbRun(this.db, `CREATE INDEX IF NOT EXISTS idx_edges_src ON edges(src_id, rel_type)`);
-    await dbRun(this.db, `CREATE INDEX IF NOT EXISTS idx_edges_dst ON edges(dst_id, rel_type)`);
-    await dbRun(this.db, `CREATE INDEX IF NOT EXISTS idx_edges_rel ON edges(rel_type)`);
-    await dbRun(this.db, `CREATE INDEX IF NOT EXISTS idx_outbox_status ON vector_outbox(status)`);
-    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;
-  }
-  /**
-   * Append event to store (AXIOMMIND Principle 2: Append-only)
-   * Returns existing event ID if duplicate (Principle 3: Idempotency)
-   */
-  async append(input) {
-    await this.initialize();
-    const canonicalKey = makeCanonicalKey(input.content);
-    const dedupeKey = makeDedupeKey(input.content, input.sessionId);
-    const existing = await dbAll(
-      this.db,
-      `SELECT event_id FROM event_dedup WHERE dedupe_key = ?`,
-      [dedupeKey]
-    );
-    if (existing.length > 0) {
-      return {
-        success: true,
-        eventId: existing[0].event_id,
-        isDuplicate: true
-      };
-    }
-    const id = randomUUID();
-    const timestamp = input.timestamp.toISOString();
-    try {
-      await dbRun(
-        this.db,
-        `INSERT INTO events (id, event_type, session_id, timestamp, content, canonical_key, dedupe_key, metadata)
-         VALUES (?, ?, ?, ?, ?, ?, ?, ?)`,
-        [
-          id,
-          input.eventType,
-          input.sessionId,
-          timestamp,
-          input.content,
-          canonicalKey,
-          dedupeKey,
-          JSON.stringify(input.metadata || {})
-        ]
-      );
-      await dbRun(
-        this.db,
-        `INSERT INTO event_dedup (dedupe_key, event_id) VALUES (?, ?)`,
-        [dedupeKey, id]
-      );
-      await dbRun(
-        this.db,
-        `INSERT INTO memory_levels (event_id, level) VALUES (?, 'L0')`,
-        [id]
-      );
-      return { success: true, eventId: id, isDuplicate: false };
-    } catch (error) {
-      return {
-        success: false,
-        error: error instanceof Error ? error.message : String(error)
-      };
-    }
-  }
-  /**
-   * Get events by session ID
-   */
-  async getSessionEvents(sessionId) {
-    await this.initialize();
-    const rows = await dbAll(
-      this.db,
-      `SELECT * FROM events WHERE session_id = ? ORDER BY timestamp ASC`,
-      [sessionId]
-    );
-    return rows.map(this.rowToEvent);
-  }
-  /**
-   * Get recent events
-   */
-  async getRecentEvents(limit = 100) {
-    await this.initialize();
-    const rows = await dbAll(
-      this.db,
-      `SELECT * FROM events ORDER BY timestamp DESC LIMIT ?`,
-      [limit]
-    );
-    return rows.map(this.rowToEvent);
-  }
-  /**
-   * Get event by ID
-   */
-  async getEvent(id) {
-    await this.initialize();
-    const rows = await dbAll(
-      this.db,
-      `SELECT * FROM events WHERE id = ?`,
-      [id]
-    );
-    if (rows.length === 0)
-      return null;
-    return this.rowToEvent(rows[0]);
-  }
-  /**
-   * Create or update session
-   */
-  async upsertSession(session) {
-    await this.initialize();
-    const existing = await dbAll(
-      this.db,
-      `SELECT id FROM sessions WHERE id = ?`,
-      [session.id]
-    );
-    if (existing.length === 0) {
-      await dbRun(
-        this.db,
-        `INSERT INTO sessions (id, started_at, project_path, tags)
-         VALUES (?, ?, ?, ?)`,
-        [
-          session.id,
-          (session.startedAt || /* @__PURE__ */ new Date()).toISOString(),
-          session.projectPath || null,
-          JSON.stringify(session.tags || [])
-        ]
-      );
-    } else {
-      const updates = [];
-      const values = [];
-      if (session.endedAt) {
-        updates.push("ended_at = ?");
-        values.push(session.endedAt.toISOString());
-      }
-      if (session.summary) {
-        updates.push("summary = ?");
-        values.push(session.summary);
-      }
-      if (session.tags) {
-        updates.push("tags = ?");
-        values.push(JSON.stringify(session.tags));
-      }
-      if (updates.length > 0) {
-        values.push(session.id);
-        await dbRun(
-          this.db,
-          `UPDATE sessions SET ${updates.join(", ")} WHERE id = ?`,
-          values
-        );
-      }
-    }
-  }
-  /**
-   * Get session by ID
-   */
-  async getSession(id) {
-    await this.initialize();
-    const rows = await dbAll(
-      this.db,
-      `SELECT * FROM sessions WHERE id = ?`,
-      [id]
-    );
-    if (rows.length === 0)
-      return null;
-    const row = rows[0];
-    return {
-      id: row.id,
-      startedAt: toDate(row.started_at),
-      endedAt: row.ended_at ? toDate(row.ended_at) : void 0,
-      projectPath: row.project_path,
-      summary: row.summary,
-      tags: row.tags ? JSON.parse(row.tags) : void 0
-    };
-  }
-  /**
-   * Add to embedding outbox (Single-Writer Pattern)
-   */
-  async enqueueForEmbedding(eventId, content) {
-    await this.initialize();
-    const id = randomUUID();
-    await dbRun(
-      this.db,
-      `INSERT INTO embedding_outbox (id, event_id, content, status, retry_count)
-       VALUES (?, ?, ?, 'pending', 0)`,
-      [id, eventId, content]
-    );
-    return id;
-  }
-  /**
-   * Get pending outbox items
-   */
-  async getPendingOutboxItems(limit = 32) {
-    await this.initialize();
-    const pending = await dbAll(
-      this.db,
-      `SELECT * FROM embedding_outbox
-       WHERE status = 'pending'
-       ORDER BY created_at
-       LIMIT ?`,
-      [limit]
-    );
-    if (pending.length === 0)
-      return [];
-    const ids = pending.map((r) => r.id);
-    const placeholders = ids.map(() => "?").join(",");
-    await dbRun(
-      this.db,
-      `UPDATE embedding_outbox SET status = 'processing' WHERE id IN (${placeholders})`,
-      ids
-    );
-    return pending.map((row) => ({
-      id: row.id,
-      eventId: row.event_id,
-      content: row.content,
-      status: "processing",
-      retryCount: row.retry_count,
-      createdAt: toDate(row.created_at),
-      errorMessage: row.error_message
-    }));
-  }
-  /**
-   * Mark outbox items as done
-   */
-  async completeOutboxItems(ids) {
-    if (ids.length === 0)
-      return;
-    const placeholders = ids.map(() => "?").join(",");
-    await dbRun(
-      this.db,
-      `DELETE FROM embedding_outbox WHERE id IN (${placeholders})`,
-      ids
-    );
-  }
-  /**
-   * Mark outbox items as failed
-   */
-  async failOutboxItems(ids, error) {
-    if (ids.length === 0)
-      return;
-    const placeholders = ids.map(() => "?").join(",");
-    await dbRun(
-      this.db,
-      `UPDATE embedding_outbox
-       SET status = CASE WHEN retry_count >= 3 THEN 'failed' ELSE 'pending' END,
-           retry_count = retry_count + 1,
-           error_message = ?
-       WHERE id IN (${placeholders})`,
-      [error, ...ids]
-    );
-  }
-  /**
-   * Update memory level
-   */
-  async updateMemoryLevel(eventId, level) {
-    await this.initialize();
-    await dbRun(
-      this.db,
-      `UPDATE memory_levels SET level = ?, promoted_at = CURRENT_TIMESTAMP WHERE event_id = ?`,
-      [level, eventId]
-    );
-  }
-  /**
-   * Get memory level statistics
-   */
-  async getLevelStats() {
-    await this.initialize();
-    const rows = await dbAll(
-      this.db,
-      `SELECT level, COUNT(*) as count FROM memory_levels GROUP BY level`
-    );
-    return rows;
-  }
-  /**
-   * Get events by memory level
-   */
-  async getEventsByLevel(level, options) {
-    await this.initialize();
-    const limit = options?.limit || 50;
-    const offset = options?.offset || 0;
-    const rows = await dbAll(
-      this.db,
-      `SELECT e.* FROM events e
-       INNER JOIN memory_levels ml ON e.id = ml.event_id
-       WHERE ml.level = ?
-       ORDER BY e.timestamp DESC
-       LIMIT ? OFFSET ?`,
-      [level, limit, offset]
-    );
-    return rows.map((row) => this.rowToEvent(row));
-  }
-  /**
-   * Get memory level for a specific event
-   */
-  async getEventLevel(eventId) {
-    await this.initialize();
-    const rows = await dbAll(
-      this.db,
-      `SELECT level FROM memory_levels WHERE event_id = ?`,
-      [eventId]
-    );
-    return rows.length > 0 ? rows[0].level : null;
-  }
-  // ============================================================
-  // Endless Mode Helper Methods
-  // ============================================================
-  /**
-   * Get database instance for Endless Mode stores
-   */
-  getDatabase() {
-    return this.db;
-  }
-  /**
-   * Get config value for endless mode
-   */
-  async getEndlessConfig(key) {
-    await this.initialize();
-    const rows = await dbAll(
-      this.db,
-      `SELECT value FROM endless_config WHERE key = ?`,
-      [key]
-    );
-    if (rows.length === 0)
-      return null;
-    return JSON.parse(rows[0].value);
-  }
-  /**
-   * Set config value for endless mode
-   */
-  async setEndlessConfig(key, value) {
-    await this.initialize();
-    await dbRun(
-      this.db,
-      `INSERT OR REPLACE INTO endless_config (key, value, updated_at)
-       VALUES (?, ?, CURRENT_TIMESTAMP)`,
-      [key, JSON.stringify(value)]
-    );
-  }
-  /**
-   * Get all sessions
-   */
-  async getAllSessions() {
-    await this.initialize();
-    const rows = await dbAll(
-      this.db,
-      `SELECT * FROM sessions ORDER BY started_at DESC`
-    );
-    return rows.map((row) => ({
-      id: row.id,
-      startedAt: toDate(row.started_at),
-      endedAt: row.ended_at ? toDate(row.ended_at) : void 0,
-      projectPath: row.project_path,
-      summary: row.summary,
-      tags: row.tags ? JSON.parse(row.tags) : void 0
-    }));
-  }
-  /**
-   * Increment access count for events (stub for compatibility)
-   */
-  async incrementAccessCount(eventIds) {
-    return Promise.resolve();
-  }
-  /**
-   * Get most accessed memories (stub for compatibility)
-   */
-  async getMostAccessed(limit = 10) {
-    return [];
-  }
-  /**
-   * Close database connection
-   */
-  async close() {
-    await dbClose(this.db);
+// src/core/sqlite-event-store.ts
+import { randomUUID } from "crypto";
+
+// src/core/canonical-key.ts
+import { createHash } from "crypto";
+var MAX_KEY_LENGTH = 200;
+function makeCanonicalKey(title, context) {
+  let normalized = title.normalize("NFKC");
+  normalized = normalized.toLowerCase();
+  normalized = normalized.replace(/[^\p{L}\p{N}\s]/gu, "");
+  normalized = normalized.replace(/\s+/g, " ").trim();
+  let key = normalized;
+  if (context?.project) {
+    key = `${context.project}::${key}`;
   }
-  /**
-   * Convert database row to MemoryEvent
-   */
-  rowToEvent(row) {
-    return {
-      id: row.id,
-      eventType: row.event_type,
-      sessionId: row.session_id,
-      timestamp: toDate(row.timestamp),
-      content: row.content,
-      canonicalKey: row.canonical_key,
-      dedupeKey: row.dedupe_key,
-      metadata: row.metadata ? JSON.parse(row.metadata) : void 0
-    };
+  if (key.length > MAX_KEY_LENGTH) {
+    const hashSuffix = createHash("md5").update(key).digest("hex").slice(0, 8);
+    key = key.slice(0, MAX_KEY_LENGTH - 9) + "_" + hashSuffix;
   }
-};
-
-// src/core/sqlite-event-store.ts
-import { randomUUID as randomUUID2 } from "crypto";
+  return key;
+}
+function makeDedupeKey(content, sessionId) {
+  const contentHash = createHash("sha256").update(content).digest("hex");
+  return `${sessionId}:${contentHash}`;
+}
 
 // src/core/sqlite-wrapper.ts
 import Database from "better-sqlite3";
@@ -1263,7 +550,7 @@ var SQLiteEventStore = class {
         isDuplicate: true
       };
     }
-    const id = randomUUID2();
+    const id = randomUUID();
     const timestamp = toSQLiteTimestamp(input.timestamp);
     try {
       const metadata = input.metadata || {};
@@ -1317,6 +604,29 @@ var SQLiteEventStore = class {
       };
     }
   }
+  /**
+   * Get session IDs that have events but no session_summary event.
+   * Used to backfill summaries for sessions that ended without Stop hook.
+   */
+  async getSessionsWithoutSummary(currentSessionId, limit = 5) {
+    await this.initialize();
+    const rows = sqliteAll(
+      this.db,
+      `SELECT DISTINCT e.session_id
+       FROM events e
+       WHERE e.session_id != ?
+         AND e.event_type != 'session_summary'
+         AND e.session_id NOT IN (
+           SELECT DISTINCT session_id FROM events WHERE event_type = 'session_summary'
+         )
+       GROUP BY e.session_id
+       HAVING COUNT(*) >= 3
+       ORDER BY MAX(e.timestamp) DESC
+       LIMIT ?`,
+      [currentSessionId, limit]
+    );
+    return rows.map((r) => r.session_id);
+  }
   /**
    * Get events by session ID
    */
@@ -1544,7 +854,7 @@ var SQLiteEventStore = class {
    */
   async enqueueForEmbedding(eventId, content) {
     await this.initialize();
-    const id = randomUUID2();
+    const id = randomUUID();
     sqliteRun(
       this.db,
       `INSERT INTO embedding_outbox (id, event_id, content, status, retry_count)
@@ -1825,7 +1135,7 @@ var SQLiteEventStore = class {
     if (this.readOnly)
       return;
     await this.initialize();
-    const id = randomUUID2();
+    const id = randomUUID();
     sqliteRun(
       this.db,
       `INSERT INTO memory_helpfulness (id, event_id, session_id, retrieval_score, query_preview, created_at)
@@ -2046,7 +1356,7 @@ var SQLiteEventStore = class {
   }
   async recordRetrievalTrace(input) {
     await this.initialize();
-    const traceId = randomUUID2();
+    const traceId = randomUUID();
     sqliteRun(
       this.db,
       `INSERT INTO retrieval_traces (
@@ -2300,169 +1610,6 @@ var SQLiteEventStore = class {
   }
 };
 
-// src/core/sync-worker.ts
-var DEFAULT_CONFIG = {
-  intervalMs: 3e4,
-  batchSize: 500,
-  maxRetries: 3,
-  retryDelayMs: 5e3
-};
-var SyncWorker = class {
-  constructor(sqliteStore, duckdbStore, config) {
-    this.sqliteStore = sqliteStore;
-    this.duckdbStore = duckdbStore;
-    this.config = { ...DEFAULT_CONFIG, ...config };
-  }
-  config;
-  intervalHandle = null;
-  running = false;
-  stats = {
-    lastSyncAt: null,
-    eventsSynced: 0,
-    sessionsSynced: 0,
-    errors: 0,
-    status: "idle"
-  };
-  /**
-   * Start the sync worker
-   */
-  start() {
-    if (this.running)
-      return;
-    this.running = true;
-    this.stats.status = "idle";
-    this.syncNow().catch((err) => {
-      console.error("[SyncWorker] Initial sync failed:", err);
-    });
-    this.intervalHandle = setInterval(() => {
-      this.syncNow().catch((err) => {
-        console.error("[SyncWorker] Periodic sync failed:", err);
-      });
-    }, this.config.intervalMs);
-  }
-  /**
-   * Stop the sync worker
-   */
-  stop() {
-    this.running = false;
-    this.stats.status = "stopped";
-    if (this.intervalHandle) {
-      clearInterval(this.intervalHandle);
-      this.intervalHandle = null;
-    }
-  }
-  /**
-   * Trigger immediate sync
-   */
-  async syncNow() {
-    if (this.stats.status === "syncing") {
-      return;
-    }
-    this.stats.status = "syncing";
-    try {
-      await this.syncEvents();
-      await this.syncSessions();
-      this.stats.lastSyncAt = /* @__PURE__ */ new Date();
-      this.stats.status = "idle";
-    } catch (error) {
-      this.stats.errors++;
-      this.stats.status = "error";
-      throw error;
-    }
-  }
-  /**
-   * Sync events from SQLite to DuckDB
-   */
-  async syncEvents() {
-    const targetName = "duckdb_analytics";
-    const position = await this.sqliteStore.getSyncPosition(targetName);
-    const lastTimestamp = position.lastTimestamp || "1970-01-01T00:00:00.000Z";
-    let hasMore = true;
-    let totalSynced = 0;
-    while (hasMore) {
-      const events = await this.sqliteStore.getEventsSince(lastTimestamp, this.config.batchSize);
-      if (events.length === 0) {
-        hasMore = false;
-        break;
-      }
-      await this.retryWithBackoff(async () => {
-        for (const event of events) {
-          await this.insertEventToDuckDB(event);
-        }
-      });
-      totalSynced += events.length;
-      const lastEvent = events[events.length - 1];
-      await this.sqliteStore.updateSyncPosition(
-        targetName,
-        lastEvent.id,
-        lastEvent.timestamp.toISOString()
-      );
-      hasMore = events.length === this.config.batchSize;
-    }
-    this.stats.eventsSynced += totalSynced;
-  }
-  /**
-   * Sync sessions from SQLite to DuckDB
-   */
-  async syncSessions() {
-    const sessions = await this.sqliteStore.getAllSessions();
-    for (const session of sessions) {
-      await this.retryWithBackoff(async () => {
-        await this.duckdbStore.upsertSession(session);
-      });
-    }
-    this.stats.sessionsSynced = sessions.length;
-  }
-  /**
-   * Insert a single event into DuckDB
-   */
-  async insertEventToDuckDB(event) {
-    await this.duckdbStore.append({
-      eventType: event.eventType,
-      sessionId: event.sessionId,
-      timestamp: event.timestamp,
-      content: event.content,
-      metadata: event.metadata
-    });
-  }
-  /**
-   * Retry operation with exponential backoff
-   */
-  async retryWithBackoff(fn) {
-    let lastError = null;
-    for (let attempt = 0; attempt < this.config.maxRetries; attempt++) {
-      try {
-        return await fn();
-      } catch (error) {
-        lastError = error instanceof Error ? error : new Error(String(error));
-        if (attempt < this.config.maxRetries - 1) {
-          const delay = this.config.retryDelayMs * Math.pow(2, attempt);
-          await this.sleep(delay);
-        }
-      }
-    }
-    throw lastError;
-  }
-  /**
-   * Sleep utility
-   */
-  sleep(ms) {
-    return new Promise((resolve2) => setTimeout(resolve2, ms));
-  }
-  /**
-   * Get sync statistics
-   */
-  getStats() {
-    return { ...this.stats };
-  }
-  /**
-   * Check if worker is running
-   */
-  isRunning() {
-    return this.running;
-  }
-};
-
 // src/core/vector-store.ts
 import * as lancedb from "@lancedb/lancedb";
 var VectorStore = class {
@@ -2750,8 +1897,34 @@ function getDefaultEmbedder() {
   return defaultEmbedder;
 }
 
+// src/core/db-wrapper.ts
+import BetterSqlite3 from "better-sqlite3";
+function toDate(value) {
+  if (value instanceof Date)
+    return value;
+  if (typeof value === "string")
+    return new Date(value);
+  if (typeof value === "number")
+    return new Date(value);
+  return new Date(String(value));
+}
+function createDatabase(dbPath, options) {
+  return new BetterSqlite3(dbPath, { readonly: options?.readOnly });
+}
+function dbRun(db, sql, params = []) {
+  db.prepare(sql).run(...params);
+  return Promise.resolve();
+}
+function dbAll(db, sql, params = []) {
+  return Promise.resolve(db.prepare(sql).all(...params));
+}
+function dbClose(db) {
+  db.close();
+  return Promise.resolve();
+}
+
 // src/core/vector-outbox.ts
-var DEFAULT_CONFIG2 = {
+var DEFAULT_CONFIG = {
   embeddingVersion: "v1",
   maxRetries: 3,
   stuckThresholdMs: 5 * 60 * 1e3,
@@ -2760,7 +1933,7 @@ var DEFAULT_CONFIG2 = {
 };
 
 // src/core/vector-worker.ts
-var DEFAULT_CONFIG3 = {
+var DEFAULT_CONFIG2 = {
   batchSize: 32,
   pollIntervalMs: 1e3,
   maxRetries: 3
@@ -2777,7 +1950,7 @@ var VectorWorker = class {
     this.eventStore = eventStore;
     this.vectorStore = vectorStore;
     this.embedder = embedder;
-    this.config = { ...DEFAULT_CONFIG3, ...config };
+    this.config = { ...DEFAULT_CONFIG2, ...config };
   }
   /**
    * Start the worker polling loop
@@ -2898,7 +2071,7 @@ function createVectorWorker(eventStore, vectorStore, embedder, config) {
 }
 
 // src/core/matcher.ts
-var DEFAULT_CONFIG4 = {
+var DEFAULT_CONFIG3 = {
   weights: {
     semanticSimilarity: 0.4,
     ftsScore: 0.25,
@@ -2913,9 +2086,9 @@ var Matcher = class {
   config;
   constructor(config = {}) {
     this.config = {
-      ...DEFAULT_CONFIG4,
+      ...DEFAULT_CONFIG3,
       ...config,
-      weights: { ...DEFAULT_CONFIG4.weights, ...config.weights }
+      weights: { ...DEFAULT_CONFIG3.weights, ...config.weights }
     };
   }
   /**
@@ -3905,7 +3078,7 @@ function createSharedEventStore(dbPath) {
 }
 
 // src/core/shared-store.ts
-import { randomUUID as randomUUID3 } from "crypto";
+import { randomUUID as randomUUID2 } from "crypto";
 var SharedStore = class {
   constructor(sharedEventStore) {
     this.sharedEventStore = sharedEventStore;
@@ -3917,7 +3090,7 @@ var SharedStore = class {
    * Promote a verified troubleshooting entry to shared storage
    */
   async promoteEntry(input) {
-    const entryId = randomUUID3();
+    const entryId = randomUUID2();
     await dbRun(
       this.db,
       `INSERT INTO shared_troubleshooting (
@@ -4282,7 +3455,7 @@ function createSharedVectorStore(dbPath) {
 }
 
 // src/core/shared-promoter.ts
-import { randomUUID as randomUUID4 } from "crypto";
+import { randomUUID as randomUUID3 } from "crypto";
 var SharedPromoter = class {
   constructor(sharedStore, sharedVectorStore, embedder, config) {
     this.sharedStore = sharedStore;
@@ -4350,7 +3523,7 @@ var SharedPromoter = class {
       const embeddingContent = this.createEmbeddingContent(input);
       const embedding = await this.embedder.embed(embeddingContent);
       await this.sharedVectorStore.upsert({
-        id: randomUUID4(),
+        id: randomUUID3(),
         entryId,
         entryType: "troubleshooting",
         content: embeddingContent,
@@ -4490,7 +3663,7 @@ function createToolObservationEmbedding(toolName, metadata, success) {
 }
 
 // src/core/working-set-store.ts
-import { randomUUID as randomUUID5 } from "crypto";
+import { randomUUID as randomUUID4 } from "crypto";
 var WorkingSetStore = class {
   constructor(eventStore, config) {
     this.eventStore = eventStore;
@@ -4511,7 +3684,7 @@ var WorkingSetStore = class {
       `INSERT OR REPLACE INTO working_set (id, event_id, added_at, relevance_score, topics, expires_at)
        VALUES (?, ?, CURRENT_TIMESTAMP, ?, ?, ?)`,
       [
-        randomUUID5(),
+        randomUUID4(),
         eventId,
         relevanceScore,
         JSON.stringify(topics || []),
@@ -4695,7 +3868,7 @@ function createWorkingSetStore(eventStore, config) {
 }
 
 // src/core/consolidated-store.ts
-import { randomUUID as randomUUID6 } from "crypto";
+import { randomUUID as randomUUID5 } from "crypto";
 var ConsolidatedStore = class {
   constructor(eventStore) {
     this.eventStore = eventStore;
@@ -4707,7 +3880,7 @@ var ConsolidatedStore = class {
    * Create a new consolidated memory
    */
   async create(input) {
-    const memoryId = randomUUID6();
+    const memoryId = randomUUID5();
     await dbRun(
       this.db,
       `INSERT INTO consolidated_memories
@@ -4837,7 +4010,7 @@ var ConsolidatedStore = class {
    * Create a long-term rule promoted from stable summaries
    */
   async createRule(input) {
-    const ruleId = randomUUID6();
+    const ruleId = randomUUID5();
     await dbRun(
       this.db,
       `INSERT INTO consolidated_rules
@@ -5359,7 +4532,7 @@ function createConsolidationWorker(workingSetStore, consolidatedStore, config) {
 }
 
 // src/core/continuity-manager.ts
-import { randomUUID as randomUUID7 } from "crypto";
+import { randomUUID as randomUUID6 } from "crypto";
 var ContinuityManager = class {
   constructor(eventStore, config) {
     this.eventStore = eventStore;
@@ -5513,7 +4686,7 @@ var ContinuityManager = class {
       `INSERT INTO continuity_log
         (log_id, from_context_id, to_context_id, continuity_score, transition_type, created_at)
        VALUES (?, ?, ?, ?, ?, CURRENT_TIMESTAMP)`,
-      [randomUUID7(), previous.id, current.id, score, type]
+      [randomUUID6(), previous.id, current.id, score, type]
     );
   }
   /**
@@ -5622,7 +4795,7 @@ function createContinuityManager(eventStore, config) {
 }
 
 // src/core/graduation-worker.ts
-var DEFAULT_CONFIG5 = {
+var DEFAULT_CONFIG4 = {
   evaluationIntervalMs: 3e5,
   // 5 minutes
   batchSize: 50,
@@ -5630,7 +4803,7 @@ var DEFAULT_CONFIG5 = {
   // 1 hour cooldown between evaluations
 };
 var GraduationWorker = class {
-  constructor(eventStore, graduation, config = DEFAULT_CONFIG5) {
+  constructor(eventStore, graduation, config = DEFAULT_CONFIG4) {
     this.eventStore = eventStore;
     this.graduation = graduation;
     this.config = config;
@@ -5738,7 +4911,7 @@ function createGraduationWorker(eventStore, graduation, config) {
   return new GraduationWorker(
     eventStore,
     graduation,
-    { ...DEFAULT_CONFIG5, ...config }
+    { ...DEFAULT_CONFIG4, ...config }
   );
 }
 
@@ -5976,9 +5149,6 @@ function getSessionProject(sessionId) {
 var MemoryService = class {
   // Primary store: SQLite (WAL mode) - for hooks, always available
   sqliteStore;
-  // Analytics store: DuckDB - for server reads (optional, synced from SQLite)
-  analyticsStore;
-  syncWorker = null;
   vectorStore;
   embedder;
   matcher;
@@ -6027,24 +5197,6 @@ var MemoryService = class {
         markdownMirrorRoot: storagePath
       }
     );
-    const analyticsEnabled = config.analyticsEnabled ?? this.readOnly;
-    if (!analyticsEnabled) {
-      this.analyticsStore = null;
-    } else if (this.readOnly) {
-      try {
-        this.analyticsStore = new EventStore(
-          path3.join(storagePath, "analytics.duckdb"),
-          { readOnly: true }
-        );
-      } catch {
-        this.analyticsStore = null;
-      }
-    } else {
-      this.analyticsStore = new EventStore(
-        path3.join(storagePath, "analytics.duckdb"),
-        { readOnly: false }
-      );
-    }
     this.vectorStore = new VectorStore(path3.join(storagePath, "vectors"));
     const embeddingModel = config.embeddingModel || process.env.CLAUDE_MEMORY_EMBEDDING_MODEL;
     this.embedder = embeddingModel ? new Embedder(embeddingModel) : getDefaultEmbedder();
@@ -6070,13 +5222,6 @@ var MemoryService = class {
       this.initialized = true;
       return;
     }
-    if (this.analyticsStore) {
-      try {
-        await this.analyticsStore.initialize();
-      } catch (error) {
-        console.warn("[MemoryService] Analytics store (DuckDB) initialization failed, using SQLite for reads:", error);
-      }
-    }
     await this.vectorStore.initialize();
     await this.embedder.initialize();
     if (!this.readOnly) {
@@ -6093,14 +5238,6 @@ var MemoryService = class {
           this.graduation
         );
         this.graduationWorker.start();
-        if (this.analyticsStore) {
-          this.syncWorker = new SyncWorker(
-            this.sqliteStore,
-            this.analyticsStore,
-            { intervalMs: 3e4, batchSize: 500 }
-          );
-          this.syncWorker.start();
-        }
       }
       const savedMode = await this.sqliteStore.getEndlessConfig("mode");
       if (savedMode === "endless") {
@@ -6297,6 +5434,57 @@ var MemoryService = class {
       }
     );
   }
+  /**
+   * Backfill session summaries for recent sessions that are missing them.
+   * Called from session-start hook to catch sessions that ended without Stop hook.
+   */
+  async backfillMissingSummaries(currentSessionId, limit = 5) {
+    await this.initialize();
+    const recentSessionIds = await this.sqliteStore.getSessionsWithoutSummary(currentSessionId, limit);
+    for (const sid of recentSessionIds) {
+      try {
+        await this.generateSessionSummary(sid);
+      } catch {
+      }
+    }
+  }
+  /**
+   * Generate a rule-based session summary from stored events.
+   * Called at session end (Stop hook) when no LLM-generated summary exists.
+   * Skips if a summary already exists for this session.
+   */
+  async generateSessionSummary(sessionId) {
+    await this.initialize();
+    const events = await this.sqliteStore.getSessionEvents(sessionId);
+    if (events.length < 3)
+      return;
+    const hasSummary = events.some((e) => e.eventType === "session_summary");
+    if (hasSummary)
+      return;
+    const prompts = events.filter((e) => e.eventType === "user_prompt");
+    const toolObs = events.filter((e) => e.eventType === "tool_observation");
+    const toolNames = [...new Set(
+      toolObs.map((e) => e.metadata?.toolName).filter(Boolean)
+    )];
+    const errorObs = toolObs.filter((e) => {
+      const meta = e.metadata;
+      return meta?.exitCode !== void 0 && meta.exitCode !== 0;
+    });
+    const datePart = events[0].timestamp.toISOString().split("T")[0];
+    const parts = [`[${datePart}] ${prompts.length}\uD134 \uC138\uC158.`];
+    if (prompts.length > 0) {
+      const firstPrompt = prompts[0].content.slice(0, 120).replace(/\n/g, " ");
+      parts.push(`\uC8FC\uC694 \uC791\uC5C5: ${firstPrompt}`);
+    }
+    if (toolNames.length > 0) {
+      parts.push(`\uC0AC\uC6A9 \uD234: ${toolNames.slice(0, 6).join(", ")}`);
+    }
+    if (errorObs.length > 0) {
+      parts.push(`\uC624\uB958 ${errorObs.length}\uAC74 \uBC1C\uC0DD`);
+    }
+    const summary = parts.join(". ");
+    await this.storeSessionSummary(sessionId, summary, { generated: "rule-based", eventCount: events.length });
+  }
   /**
    * Store a tool observation
    */
@@ -6832,6 +6020,7 @@ var MemoryService = class {
     await this.initialize();
     await this.sqliteStore.recordRetrievalTrace({
       ...input,
+      projectHash: this.projectHash || void 0,
       candidateDetails: [],
       selectedDetails: [],
       fallbackTrace: []
@@ -7122,16 +6311,10 @@ var MemoryService = class {
     if (this.vectorWorker) {
       this.vectorWorker.stop();
     }
-    if (this.syncWorker) {
-      this.syncWorker.stop();
-    }
     if (this.sharedEventStore) {
       await this.sharedEventStore.close();
     }
     await this.sqliteStore.close();
-    if (this.analyticsStore) {
-      await this.analyticsStore.close();
-    }
   }
   /**
    * Expand ~ to home directory