claude-memory-layer 1.0.7 → 1.0.9

package/dist/server/index.js

@@ -9,7 +9,8 @@ const __dirname = dirname(__filename);
 import { Hono as Hono7 } from "hono";
 import { cors } from "hono/cors";
 import { logger } from "hono/logger";
-import { serveStatic } from "hono/bun";
+import { serve } from "@hono/node-server";
+import { serveStatic } from "@hono/node-server/serve-static";
 import * as path2 from "path";
 import * as fs2 from "fs";
 
@@ -80,7 +81,10 @@ function toDate(value) {
     return new Date(value);
   return new Date(String(value));
 }
-function createDatabase(path3) {
+function createDatabase(path3, options) {
+  if (options?.readOnly) {
+    return new duckdb.Database(path3, { access_mode: "READ_ONLY" });
+  }
   return new duckdb.Database(path3);
 }
 function dbRun(db, sql, params = []) {
@@ -134,18 +138,24 @@ function dbClose(db) {
 
 // src/core/event-store.ts
 var EventStore = class {
-  constructor(dbPath) {
+  constructor(dbPath, options) {
     this.dbPath = dbPath;
-    this.db = createDatabase(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,
@@ -622,6 +632,36 @@ var EventStore = class {
     );
     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
   // ============================================================
@@ -632,69 +672,1018 @@ var EventStore = class {
     return this.db;
   }
   /**
-   * Get config value for endless mode
+   * 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);
+  }
+  /**
+   * 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
+    };
+  }
+};
+
+// src/core/sqlite-event-store.ts
+import { randomUUID as randomUUID2 } from "crypto";
+
+// src/core/sqlite-wrapper.ts
+import Database from "better-sqlite3";
+function createSQLiteDatabase(path3, options) {
+  const db = new Database(path3, {
+    readonly: options?.readonly ?? false
+  });
+  if (!options?.readonly && (options?.walMode ?? true)) {
+    db.pragma("journal_mode = WAL");
+    db.pragma("synchronous = NORMAL");
+    db.pragma("busy_timeout = 5000");
+  }
+  return db;
+}
+function sqliteRun(db, sql, params = []) {
+  const stmt = db.prepare(sql);
+  return stmt.run(...params);
+}
+function sqliteAll(db, sql, params = []) {
+  const stmt = db.prepare(sql);
+  return stmt.all(...params);
+}
+function sqliteGet(db, sql, params = []) {
+  const stmt = db.prepare(sql);
+  return stmt.get(...params);
+}
+function sqliteExec(db, sql) {
+  db.exec(sql);
+}
+function sqliteClose(db) {
+  db.close();
+}
+function toDateFromSQLite(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 toSQLiteTimestamp(date) {
+  return date.toISOString();
+}
+
+// src/core/sqlite-event-store.ts
+var SQLiteEventStore = class {
+  constructor(dbPath, options) {
+    this.dbPath = dbPath;
+    this.readOnly = options?.readonly ?? false;
+    this.db = createSQLiteDatabase(dbPath, {
+      readonly: this.readOnly,
+      walMode: !this.readOnly
+    });
+  }
+  db;
+  initialized = false;
+  readOnly;
+  /**
+   * Initialize database schema
+   */
+  async initialize() {
+    if (this.initialized)
+      return;
+    if (this.readOnly) {
+      this.initialized = true;
+      return;
+    }
+    sqliteExec(this.db, `
+      -- L0 EventStore: Single Source of Truth (immutable, append-only)
+      CREATE TABLE IF NOT EXISTS events (
+        id TEXT PRIMARY KEY,
+        event_type TEXT NOT NULL,
+        session_id TEXT NOT NULL,
+        timestamp TEXT NOT NULL,
+        content TEXT NOT NULL,
+        canonical_key TEXT NOT NULL,
+        dedupe_key TEXT UNIQUE,
+        metadata TEXT,
+        access_count INTEGER DEFAULT 0,
+        last_accessed_at TEXT
+      );
+
+      -- Dedup table for idempotency
+      CREATE TABLE IF NOT EXISTS event_dedup (
+        dedupe_key TEXT PRIMARY KEY,
+        event_id TEXT NOT NULL,
+        created_at TEXT DEFAULT (datetime('now'))
+      );
+
+      -- Session metadata
+      CREATE TABLE IF NOT EXISTS sessions (
+        id TEXT PRIMARY KEY,
+        started_at TEXT NOT NULL,
+        ended_at TEXT,
+        project_path TEXT,
+        summary TEXT,
+        tags TEXT
+      );
+
+      -- Insights (derived data, rebuildable)
+      CREATE TABLE IF NOT EXISTS insights (
+        id TEXT PRIMARY KEY,
+        insight_type TEXT NOT NULL,
+        content TEXT NOT NULL,
+        canonical_key TEXT NOT NULL,
+        confidence REAL,
+        source_events TEXT,
+        created_at TEXT,
+        last_updated TEXT
+      );
+
+      -- Embedding Outbox (Single-Writer Pattern)
+      CREATE TABLE IF NOT EXISTS embedding_outbox (
+        id TEXT PRIMARY KEY,
+        event_id TEXT NOT NULL,
+        content TEXT NOT NULL,
+        status TEXT DEFAULT 'pending',
+        retry_count INTEGER DEFAULT 0,
+        created_at TEXT DEFAULT (datetime('now')),
+        processed_at TEXT,
+        error_message TEXT
+      );
+
+      -- Projection offset tracking
+      CREATE TABLE IF NOT EXISTS projection_offsets (
+        projection_name TEXT PRIMARY KEY,
+        last_event_id TEXT,
+        last_timestamp TEXT,
+        updated_at TEXT DEFAULT (datetime('now'))
+      );
+
+      -- Memory level tracking
+      CREATE TABLE IF NOT EXISTS memory_levels (
+        event_id TEXT PRIMARY KEY,
+        level TEXT NOT NULL DEFAULT 'L0',
+        promoted_at TEXT DEFAULT (datetime('now'))
+      );
+
+      -- Entries (immutable memory units)
+      CREATE TABLE IF NOT EXISTS entries (
+        entry_id TEXT PRIMARY KEY,
+        created_ts TEXT NOT NULL,
+        entry_type TEXT NOT NULL,
+        title TEXT NOT NULL,
+        content_json TEXT NOT NULL,
+        stage TEXT NOT NULL DEFAULT 'raw',
+        status TEXT DEFAULT 'active',
+        superseded_by TEXT,
+        build_id TEXT,
+        evidence_json TEXT,
+        canonical_key TEXT,
+        created_at TEXT DEFAULT (datetime('now'))
+      );
+
+      -- Entities (task/condition/artifact)
+      CREATE TABLE IF NOT EXISTS entities (
+        entity_id TEXT PRIMARY KEY,
+        entity_type TEXT NOT NULL,
+        canonical_key TEXT NOT NULL,
+        title TEXT NOT NULL,
+        stage TEXT NOT NULL DEFAULT 'raw',
+        status TEXT NOT NULL DEFAULT 'active',
+        current_json TEXT NOT NULL,
+        title_norm TEXT,
+        search_text TEXT,
+        created_at TEXT DEFAULT (datetime('now')),
+        updated_at TEXT DEFAULT (datetime('now'))
+      );
+
+      -- Entity aliases for canonical key lookup
+      CREATE TABLE IF NOT EXISTS entity_aliases (
+        entity_type TEXT NOT NULL,
+        canonical_key TEXT NOT NULL,
+        entity_id TEXT NOT NULL,
+        is_primary INTEGER DEFAULT 0,
+        created_at TEXT DEFAULT (datetime('now')),
+        PRIMARY KEY(entity_type, canonical_key)
+      );
+
+      -- Edges (relationships between entries/entities)
+      CREATE TABLE IF NOT EXISTS edges (
+        edge_id TEXT PRIMARY KEY,
+        src_type TEXT NOT NULL,
+        src_id TEXT NOT NULL,
+        rel_type TEXT NOT NULL,
+        dst_type TEXT NOT NULL,
+        dst_id TEXT NOT NULL,
+        meta_json TEXT,
+        created_at TEXT DEFAULT (datetime('now'))
+      );
+
+      -- Vector Outbox V2 Table
+      CREATE TABLE IF NOT EXISTS vector_outbox (
+        job_id TEXT PRIMARY KEY,
+        item_kind TEXT NOT NULL,
+        item_id TEXT NOT NULL,
+        embedding_version TEXT NOT NULL,
+        status TEXT NOT NULL DEFAULT 'pending',
+        retry_count INTEGER DEFAULT 0,
+        error TEXT,
+        created_at TEXT DEFAULT (datetime('now')),
+        updated_at TEXT DEFAULT (datetime('now')),
+        UNIQUE(item_kind, item_id, embedding_version)
+      );
+
+      -- Build Runs
+      CREATE TABLE IF NOT EXISTS build_runs (
+        build_id TEXT PRIMARY KEY,
+        started_at TEXT NOT NULL,
+        finished_at TEXT,
+        extractor_model TEXT NOT NULL,
+        extractor_prompt_hash TEXT NOT NULL,
+        embedder_model TEXT NOT NULL,
+        embedding_version TEXT NOT NULL,
+        idris_version TEXT NOT NULL,
+        schema_version TEXT NOT NULL,
+        status TEXT NOT NULL DEFAULT 'running',
+        error TEXT
+      );
+
+      -- Pipeline Metrics
+      CREATE TABLE IF NOT EXISTS pipeline_metrics (
+        id TEXT PRIMARY KEY,
+        ts TEXT NOT NULL,
+        stage TEXT NOT NULL,
+        latency_ms REAL NOT NULL,
+        success INTEGER NOT NULL,
+        error TEXT,
+        session_id TEXT
+      );
+
+      -- Working Set table (active memory window)
+      CREATE TABLE IF NOT EXISTS working_set (
+        id TEXT PRIMARY KEY,
+        event_id TEXT NOT NULL,
+        added_at TEXT DEFAULT (datetime('now')),
+        relevance_score REAL DEFAULT 1.0,
+        topics TEXT,
+        expires_at TEXT
+      );
+
+      -- Consolidated Memories table (long-term integrated memories)
+      CREATE TABLE IF NOT EXISTS consolidated_memories (
+        memory_id TEXT PRIMARY KEY,
+        summary TEXT NOT NULL,
+        topics TEXT,
+        source_events TEXT,
+        confidence REAL DEFAULT 0.5,
+        created_at TEXT DEFAULT (datetime('now')),
+        accessed_at TEXT,
+        access_count INTEGER DEFAULT 0
+      );
+
+      -- Continuity Log table (tracks context transitions)
+      CREATE TABLE IF NOT EXISTS continuity_log (
+        log_id TEXT PRIMARY KEY,
+        from_context_id TEXT,
+        to_context_id TEXT,
+        continuity_score REAL,
+        transition_type TEXT,
+        created_at TEXT DEFAULT (datetime('now'))
+      );
+
+      -- Endless Mode Config table
+      CREATE TABLE IF NOT EXISTS endless_config (
+        key TEXT PRIMARY KEY,
+        value TEXT,
+        updated_at TEXT DEFAULT (datetime('now'))
+      );
+
+      -- Sync position tracking (for SQLite -> DuckDB sync)
+      CREATE TABLE IF NOT EXISTS sync_positions (
+        target_name TEXT PRIMARY KEY,
+        last_event_id TEXT,
+        last_timestamp TEXT,
+        updated_at TEXT DEFAULT (datetime('now'))
+      );
+
+      -- Create indexes
+      CREATE INDEX IF NOT EXISTS idx_events_session ON events(session_id);
+      CREATE INDEX IF NOT EXISTS idx_events_timestamp ON events(timestamp);
+      CREATE INDEX IF NOT EXISTS idx_entries_type ON entries(entry_type);
+      CREATE INDEX IF NOT EXISTS idx_entries_stage ON entries(stage);
+      CREATE INDEX IF NOT EXISTS idx_entries_canonical ON entries(canonical_key);
+      CREATE INDEX IF NOT EXISTS idx_entities_type_key ON entities(entity_type, canonical_key);
+      CREATE INDEX IF NOT EXISTS idx_entities_status ON entities(status);
+      CREATE INDEX IF NOT EXISTS idx_edges_src ON edges(src_id, rel_type);
+      CREATE INDEX IF NOT EXISTS idx_edges_dst ON edges(dst_id, rel_type);
+      CREATE INDEX IF NOT EXISTS idx_edges_rel ON edges(rel_type);
+      CREATE INDEX IF NOT EXISTS idx_outbox_status ON vector_outbox(status);
+      CREATE INDEX IF NOT EXISTS idx_working_set_expires ON working_set(expires_at);
+      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_embedding_outbox_status ON embedding_outbox(status);
+    `);
+    const tableInfo = sqliteAll(this.db, "PRAGMA table_info(events)", []);
+    const columnNames = tableInfo.map((col) => col.name);
+    if (!columnNames.includes("access_count")) {
+      try {
+        sqliteExec(this.db, `
+          ALTER TABLE events ADD COLUMN access_count INTEGER DEFAULT 0;
+        `);
+      } catch (err) {
+        console.error("Error adding access_count column:", err);
+      }
+    }
+    if (!columnNames.includes("last_accessed_at")) {
+      try {
+        sqliteExec(this.db, `
+          ALTER TABLE events ADD COLUMN last_accessed_at TEXT;
+        `);
+      } catch (err) {
+        console.error("Error adding last_accessed_at column:", err);
+      }
+    }
+    try {
+      sqliteExec(this.db, `
+        CREATE INDEX IF NOT EXISTS idx_events_access_count ON events(access_count DESC);
+      `);
+    } catch (err) {
+    }
+    try {
+      sqliteExec(this.db, `
+        CREATE INDEX IF NOT EXISTS idx_events_last_accessed ON events(last_accessed_at DESC);
+      `);
+    } catch (err) {
+    }
+    this.initialized = true;
+  }
+  /**
+   * Append event to store (Append-only, Idempotent)
+   */
+  async append(input) {
+    await this.initialize();
+    const canonicalKey = makeCanonicalKey(input.content);
+    const dedupeKey = makeDedupeKey(input.content, input.sessionId);
+    const existing = sqliteGet(
+      this.db,
+      `SELECT event_id FROM event_dedup WHERE dedupe_key = ?`,
+      [dedupeKey]
+    );
+    if (existing) {
+      return {
+        success: true,
+        eventId: existing.event_id,
+        isDuplicate: true
+      };
+    }
+    const id = randomUUID2();
+    const timestamp = toSQLiteTimestamp(input.timestamp);
+    try {
+      const insertEvent = this.db.prepare(`
+        INSERT INTO events (id, event_type, session_id, timestamp, content, canonical_key, dedupe_key, metadata)
+        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')
+      `);
+      const transaction = this.db.transaction(() => {
+        insertEvent.run(
+          id,
+          input.eventType,
+          input.sessionId,
+          timestamp,
+          input.content,
+          canonicalKey,
+          dedupeKey,
+          JSON.stringify(input.metadata || {})
+        );
+        insertDedup.run(dedupeKey, id);
+        insertLevel.run(id);
+      });
+      transaction();
+      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 = sqliteAll(
+      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 = sqliteAll(
+      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 row = sqliteGet(
+      this.db,
+      `SELECT * FROM events WHERE id = ?`,
+      [id]
+    );
+    if (!row)
+      return null;
+    return this.rowToEvent(row);
+  }
+  /**
+   * Get events since a timestamp (for sync)
+   */
+  async getEventsSince(timestamp, limit = 1e3) {
+    await this.initialize();
+    const rows = sqliteAll(
+      this.db,
+      `SELECT * FROM events WHERE timestamp > ? ORDER BY timestamp ASC LIMIT ?`,
+      [timestamp, limit]
+    );
+    return rows.map(this.rowToEvent);
+  }
+  /**
+   * Create or update session
+   */
+  async upsertSession(session) {
+    await this.initialize();
+    const existing = sqliteGet(
+      this.db,
+      `SELECT id FROM sessions WHERE id = ?`,
+      [session.id]
+    );
+    if (!existing) {
+      sqliteRun(
+        this.db,
+        `INSERT INTO sessions (id, started_at, project_path, tags)
+         VALUES (?, ?, ?, ?)`,
+        [
+          session.id,
+          toSQLiteTimestamp(session.startedAt || /* @__PURE__ */ new Date()),
+          session.projectPath || null,
+          JSON.stringify(session.tags || [])
+        ]
+      );
+    } else {
+      const updates = [];
+      const values = [];
+      if (session.endedAt) {
+        updates.push("ended_at = ?");
+        values.push(toSQLiteTimestamp(session.endedAt));
+      }
+      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);
+        sqliteRun(
+          this.db,
+          `UPDATE sessions SET ${updates.join(", ")} WHERE id = ?`,
+          values
+        );
+      }
+    }
+  }
+  /**
+   * Get session by ID
+   */
+  async getSession(id) {
+    await this.initialize();
+    const row = sqliteGet(
+      this.db,
+      `SELECT * FROM sessions WHERE id = ?`,
+      [id]
+    );
+    if (!row)
+      return null;
+    return {
+      id: row.id,
+      startedAt: toDateFromSQLite(row.started_at),
+      endedAt: row.ended_at ? toDateFromSQLite(row.ended_at) : void 0,
+      projectPath: row.project_path,
+      summary: row.summary,
+      tags: row.tags ? JSON.parse(row.tags) : void 0
+    };
+  }
+  /**
+   * Get all sessions
+   */
+  async getAllSessions() {
+    await this.initialize();
+    const rows = sqliteAll(
+      this.db,
+      `SELECT * FROM sessions ORDER BY started_at DESC`
+    );
+    return rows.map((row) => ({
+      id: row.id,
+      startedAt: toDateFromSQLite(row.started_at),
+      endedAt: row.ended_at ? toDateFromSQLite(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
+   */
+  async enqueueForEmbedding(eventId, content) {
+    await this.initialize();
+    const id = randomUUID2();
+    sqliteRun(
+      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 = sqliteAll(
+      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(",");
+    sqliteRun(
+      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: toDateFromSQLite(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(",");
+    sqliteRun(
+      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(",");
+    sqliteRun(
+      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();
+    sqliteRun(
+      this.db,
+      `UPDATE memory_levels SET level = ?, promoted_at = datetime('now') WHERE event_id = ?`,
+      [level, eventId]
+    );
+  }
+  /**
+   * Get memory level statistics
+   */
+  async getLevelStats() {
+    await this.initialize();
+    const rows = sqliteAll(
+      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 = sqliteAll(
+      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 row = sqliteGet(
+      this.db,
+      `SELECT level FROM memory_levels WHERE event_id = ?`,
+      [eventId]
+    );
+    return row ? row.level : null;
+  }
+  /**
+   * Get sync position for a target
+   */
+  async getSyncPosition(targetName) {
+    await this.initialize();
+    const row = sqliteGet(
+      this.db,
+      `SELECT last_event_id, last_timestamp FROM sync_positions WHERE target_name = ?`,
+      [targetName]
+    );
+    return {
+      lastEventId: row?.last_event_id ?? null,
+      lastTimestamp: row?.last_timestamp ?? null
+    };
+  }
+  /**
+   * Update sync position for a target
+   */
+  async updateSyncPosition(targetName, lastEventId, lastTimestamp) {
+    await this.initialize();
+    sqliteRun(
+      this.db,
+      `INSERT OR REPLACE INTO sync_positions (target_name, last_event_id, last_timestamp, updated_at)
+       VALUES (?, ?, ?, datetime('now'))`,
+      [targetName, lastEventId, lastTimestamp]
+    );
+  }
+  /**
+   * Get config value for endless mode
+   */
+  async getEndlessConfig(key) {
+    await this.initialize();
+    const row = sqliteGet(
+      this.db,
+      `SELECT value FROM endless_config WHERE key = ?`,
+      [key]
+    );
+    if (!row)
+      return null;
+    return JSON.parse(row.value);
+  }
+  /**
+   * Set config value for endless mode
+   */
+  async setEndlessConfig(key, value) {
+    await this.initialize();
+    sqliteRun(
+      this.db,
+      `INSERT OR REPLACE INTO endless_config (key, value, updated_at)
+       VALUES (?, ?, datetime('now'))`,
+      [key, JSON.stringify(value)]
+    );
+  }
+  /**
+   * Increment access count for events
+   */
+  async incrementAccessCount(eventIds) {
+    if (eventIds.length === 0 || this.readOnly)
+      return;
+    await this.initialize();
+    const placeholders = eventIds.map(() => "?").join(",");
+    const currentTime = toSQLiteTimestamp(/* @__PURE__ */ new Date());
+    sqliteRun(
+      this.db,
+      `UPDATE events
+       SET access_count = access_count + 1,
+           last_accessed_at = ?
+       WHERE id IN (${placeholders})`,
+      [currentTime, ...eventIds]
+    );
+  }
+  /**
+   * Get most accessed memories
+   */
+  async getMostAccessed(limit = 10) {
+    await this.initialize();
+    const rows = sqliteAll(
+      this.db,
+      `SELECT * FROM events
+       WHERE access_count > 0
+       ORDER BY access_count DESC, last_accessed_at DESC
+       LIMIT ?`,
+      [limit]
+    );
+    return rows.map((row) => this.rowToEvent(row));
+  }
+  /**
+   * Get database instance for direct access
+   */
+  getDatabase() {
+    return this.db;
+  }
+  /**
+   * Close database connection
+   */
+  async close() {
+    sqliteClose(this.db);
+  }
+  /**
+   * Convert database row to MemoryEvent
+   */
+  rowToEvent(row) {
+    const event = {
+      id: row.id,
+      eventType: row.event_type,
+      sessionId: row.session_id,
+      timestamp: toDateFromSQLite(row.timestamp),
+      content: row.content,
+      canonicalKey: row.canonical_key,
+      dedupeKey: row.dedupe_key,
+      metadata: row.metadata ? JSON.parse(row.metadata) : void 0
+    };
+    if (row.access_count !== void 0) {
+      event.access_count = row.access_count;
+    }
+    if (row.last_accessed_at !== void 0) {
+      event.last_accessed_at = row.last_accessed_at;
+    }
+    return event;
+  }
+};
+
+// 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 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);
+  async insertEventToDuckDB(event) {
+    await this.duckdbStore.append({
+      eventType: event.eventType,
+      sessionId: event.sessionId,
+      timestamp: event.timestamp,
+      content: event.content,
+      metadata: event.metadata
+    });
   }
   /**
-   * Set config value for endless mode
+   * Retry operation with exponential backoff
    */
-  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)]
-    );
+  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;
   }
   /**
-   * Get all sessions
+   * Sleep utility
    */
-  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
-    }));
+  sleep(ms) {
+    return new Promise((resolve2) => setTimeout(resolve2, ms));
   }
   /**
-   * Close database connection
+   * Get sync statistics
    */
-  async close() {
-    await dbClose(this.db);
+  getStats() {
+    return { ...this.stats };
   }
   /**
-   * Convert database row to MemoryEvent
+   * Check if worker is running
    */
-  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
-    };
+  isRunning() {
+    return this.running;
   }
 };
 
@@ -926,7 +1915,7 @@ function getDefaultEmbedder() {
 }
 
 // src/core/vector-outbox.ts
-var DEFAULT_CONFIG = {
+var DEFAULT_CONFIG2 = {
   embeddingVersion: "v1",
   maxRetries: 3,
   stuckThresholdMs: 5 * 60 * 1e3,
@@ -935,7 +1924,7 @@ var DEFAULT_CONFIG = {
 };
 
 // src/core/vector-worker.ts
-var DEFAULT_CONFIG2 = {
+var DEFAULT_CONFIG3 = {
   batchSize: 32,
   pollIntervalMs: 1e3,
   maxRetries: 3
@@ -946,12 +1935,13 @@ var VectorWorker = class {
   embedder;
   config;
   running = false;
+  stopping = false;
   pollTimeout = null;
   constructor(eventStore, vectorStore, embedder, config = {}) {
     this.eventStore = eventStore;
     this.vectorStore = vectorStore;
     this.embedder = embedder;
-    this.config = { ...DEFAULT_CONFIG2, ...config };
+    this.config = { ...DEFAULT_CONFIG3, ...config };
   }
   /**
    * Start the worker polling loop
@@ -960,6 +1950,7 @@ var VectorWorker = class {
     if (this.running)
       return;
     this.running = true;
+    this.stopping = false;
     this.poll();
   }
   /**
@@ -967,6 +1958,7 @@ var VectorWorker = class {
    */
   stop() {
     this.running = false;
+    this.stopping = true;
     if (this.pollTimeout) {
       clearTimeout(this.pollTimeout);
       this.pollTimeout = null;
@@ -1016,9 +2008,15 @@ var VectorWorker = class {
       }
       return successful.length;
     } catch (error) {
-      const allIds = items.map((i) => i.id);
-      const errorMessage = error instanceof Error ? error.message : String(error);
-      await this.eventStore.failOutboxItems(allIds, errorMessage);
+      if (!this.stopping) {
+        try {
+          const allIds = items.map((i) => i.id);
+          const errorMessage = error instanceof Error ? error.message : String(error);
+          await this.eventStore.failOutboxItems(allIds, errorMessage);
+        } catch (failError) {
+          console.warn("Could not mark outbox items as failed (database may be closed)");
+        }
+      }
       throw error;
     }
   }
@@ -1026,14 +2024,18 @@ var VectorWorker = class {
    * Poll for new items
    */
   async poll() {
-    if (!this.running)
+    if (!this.running || this.stopping)
       return;
     try {
       await this.processBatch();
     } catch (error) {
-      console.error("Vector worker error:", error);
+      if (!this.stopping) {
+        console.error("Vector worker error:", error);
+      }
+    }
+    if (this.running && !this.stopping) {
+      this.pollTimeout = setTimeout(() => this.poll(), this.config.pollIntervalMs);
     }
-    this.pollTimeout = setTimeout(() => this.poll(), this.config.pollIntervalMs);
   }
   /**
    * Process all pending items (blocking)
@@ -1060,7 +2062,7 @@ function createVectorWorker(eventStore, vectorStore, embedder, config) {
 }
 
 // src/core/matcher.ts
-var DEFAULT_CONFIG3 = {
+var DEFAULT_CONFIG4 = {
   weights: {
     semanticSimilarity: 0.4,
     ftsScore: 0.25,
@@ -1075,9 +2077,9 @@ var Matcher = class {
   config;
   constructor(config = {}) {
     this.config = {
-      ...DEFAULT_CONFIG3,
+      ...DEFAULT_CONFIG4,
       ...config,
-      weights: { ...DEFAULT_CONFIG3.weights, ...config.weights }
+      weights: { ...DEFAULT_CONFIG4.weights, ...config.weights }
     };
   }
   /**
@@ -1204,6 +2206,7 @@ var Retriever = class {
   matcher;
   sharedStore;
   sharedVectorStore;
+  graduation;
   constructor(eventStore, vectorStore, embedder, matcher, sharedOptions) {
     this.eventStore = eventStore;
     this.vectorStore = vectorStore;
@@ -1212,6 +2215,12 @@ 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
    */
@@ -1334,6 +2343,13 @@ var Retriever = class {
       const event = await this.eventStore.getEvent(result.eventId);
       if (!event)
         continue;
+      if (this.graduation) {
+        this.graduation.recordAccess(
+          event.id,
+          options.sessionId || "unknown",
+          result.score
+        );
+      }
       let sessionContext;
       if (options.includeSessionContext) {
         sessionContext = await this.getSessionContext(event.sessionId, event.id);
@@ -1455,15 +2471,26 @@ var GraduationPipeline = class {
       L3toL4: { ...DEFAULT_CRITERIA.L3toL4, ...criteria.L3toL4 }
     };
   }
+  // Track which sessions have accessed each event
+  sessionAccesses = /* @__PURE__ */ new Map();
   /**
    * Record an access to an event (used for graduation scoring)
    */
   recordAccess(eventId, fromSessionId, confidence = 1) {
     const existing = this.metrics.get(eventId);
+    if (!this.sessionAccesses.has(eventId)) {
+      this.sessionAccesses.set(eventId, /* @__PURE__ */ new Set());
+    }
+    const sessions = this.sessionAccesses.get(eventId);
+    const isNewSession = !sessions.has(fromSessionId);
+    sessions.add(fromSessionId);
     if (existing) {
       existing.accessCount++;
       existing.lastAccessed = /* @__PURE__ */ new Date();
       existing.confidence = Math.max(existing.confidence, confidence);
+      if (isNewSession && sessions.size > 1) {
+        existing.crossSessionRefs = sessions.size - 1;
+      }
     } else {
       this.metrics.set(eventId, {
         eventId,
@@ -1760,7 +2787,7 @@ function createSharedEventStore(dbPath) {
 }
 
 // src/core/shared-store.ts
-import { randomUUID as randomUUID2 } from "crypto";
+import { randomUUID as randomUUID3 } from "crypto";
 var SharedStore = class {
   constructor(sharedEventStore) {
     this.sharedEventStore = sharedEventStore;
@@ -1772,7 +2799,7 @@ var SharedStore = class {
    * Promote a verified troubleshooting entry to shared storage
    */
   async promoteEntry(input) {
-    const entryId = randomUUID2();
+    const entryId = randomUUID3();
     await dbRun(
       this.db,
       `INSERT INTO shared_troubleshooting (
@@ -2137,7 +3164,7 @@ function createSharedVectorStore(dbPath) {
 }
 
 // src/core/shared-promoter.ts
-import { randomUUID as randomUUID3 } from "crypto";
+import { randomUUID as randomUUID4 } from "crypto";
 var SharedPromoter = class {
   constructor(sharedStore, sharedVectorStore, embedder, config) {
     this.sharedStore = sharedStore;
@@ -2205,7 +3232,7 @@ var SharedPromoter = class {
       const embeddingContent = this.createEmbeddingContent(input);
       const embedding = await this.embedder.embed(embeddingContent);
       await this.sharedVectorStore.upsert({
-        id: randomUUID3(),
+        id: randomUUID4(),
         entryId,
         entryType: "troubleshooting",
         content: embeddingContent,
@@ -2345,7 +3372,7 @@ function createToolObservationEmbedding(toolName, metadata, success) {
 }
 
 // src/core/working-set-store.ts
-import { randomUUID as randomUUID4 } from "crypto";
+import { randomUUID as randomUUID5 } from "crypto";
 var WorkingSetStore = class {
   constructor(eventStore, config) {
     this.eventStore = eventStore;
@@ -2366,7 +3393,7 @@ var WorkingSetStore = class {
       `INSERT OR REPLACE INTO working_set (id, event_id, added_at, relevance_score, topics, expires_at)
        VALUES (?, ?, CURRENT_TIMESTAMP, ?, ?, ?)`,
       [
-        randomUUID4(),
+        randomUUID5(),
         eventId,
         relevanceScore,
         JSON.stringify(topics || []),
@@ -2550,7 +3577,7 @@ function createWorkingSetStore(eventStore, config) {
 }
 
 // src/core/consolidated-store.ts
-import { randomUUID as randomUUID5 } from "crypto";
+import { randomUUID as randomUUID6 } from "crypto";
 var ConsolidatedStore = class {
   constructor(eventStore) {
     this.eventStore = eventStore;
@@ -2562,7 +3589,7 @@ var ConsolidatedStore = class {
    * Create a new consolidated memory
    */
   async create(input) {
-    const memoryId = randomUUID5();
+    const memoryId = randomUUID6();
     await dbRun(
       this.db,
       `INSERT INTO consolidated_memories
@@ -3089,7 +4116,7 @@ function createConsolidationWorker(workingSetStore, consolidatedStore, config) {
 }
 
 // src/core/continuity-manager.ts
-import { randomUUID as randomUUID6 } from "crypto";
+import { randomUUID as randomUUID7 } from "crypto";
 var ContinuityManager = class {
   constructor(eventStore, config) {
     this.eventStore = eventStore;
@@ -3243,7 +4270,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)`,
-      [randomUUID6(), previous.id, current.id, score, type]
+      [randomUUID7(), previous.id, current.id, score, type]
     );
   }
   /**
@@ -3351,6 +4378,127 @@ function createContinuityManager(eventStore, config) {
   return new ContinuityManager(eventStore, config);
 }
 
+// src/core/graduation-worker.ts
+var DEFAULT_CONFIG5 = {
+  evaluationIntervalMs: 3e5,
+  // 5 minutes
+  batchSize: 50,
+  cooldownMs: 36e5
+  // 1 hour cooldown between evaluations
+};
+var GraduationWorker = class {
+  constructor(eventStore, graduation, config = DEFAULT_CONFIG5) {
+    this.eventStore = eventStore;
+    this.graduation = graduation;
+    this.config = config;
+  }
+  running = false;
+  timeout = null;
+  lastEvaluated = /* @__PURE__ */ new Map();
+  /**
+   * Start the graduation worker
+   */
+  start() {
+    if (this.running)
+      return;
+    this.running = true;
+    this.scheduleNext();
+  }
+  /**
+   * Stop the graduation worker
+   */
+  stop() {
+    this.running = false;
+    if (this.timeout) {
+      clearTimeout(this.timeout);
+      this.timeout = null;
+    }
+  }
+  /**
+   * Check if currently running
+   */
+  isRunning() {
+    return this.running;
+  }
+  /**
+   * Force a graduation evaluation run
+   */
+  async forceRun() {
+    return await this.runGraduation();
+  }
+  /**
+   * Schedule the next graduation check
+   */
+  scheduleNext() {
+    if (!this.running)
+      return;
+    this.timeout = setTimeout(
+      () => this.run(),
+      this.config.evaluationIntervalMs
+    );
+  }
+  /**
+   * Run graduation evaluation
+   */
+  async run() {
+    if (!this.running)
+      return;
+    try {
+      await this.runGraduation();
+    } catch (error) {
+      console.error("Graduation error:", error);
+    }
+    this.scheduleNext();
+  }
+  /**
+   * Perform graduation evaluation across all levels
+   */
+  async runGraduation() {
+    const result = {
+      evaluated: 0,
+      graduated: 0,
+      byLevel: {}
+    };
+    const levels = ["L0", "L1", "L2", "L3"];
+    const now = Date.now();
+    for (const level of levels) {
+      const events = await this.eventStore.getEventsByLevel(level, {
+        limit: this.config.batchSize
+      });
+      let levelGraduated = 0;
+      for (const event of events) {
+        const lastEval = this.lastEvaluated.get(event.id);
+        if (lastEval && now - lastEval < this.config.cooldownMs) {
+          continue;
+        }
+        result.evaluated++;
+        this.lastEvaluated.set(event.id, now);
+        const gradResult = await this.graduation.evaluateGraduation(event.id, level);
+        if (gradResult.success) {
+          result.graduated++;
+          levelGraduated++;
+        }
+      }
+      if (levelGraduated > 0) {
+        result.byLevel[level] = levelGraduated;
+      }
+    }
+    if (this.lastEvaluated.size > 1e3) {
+      const entries = Array.from(this.lastEvaluated.entries());
+      entries.sort((a, b) => b[1] - a[1]);
+      this.lastEvaluated = new Map(entries.slice(0, 1e3));
+    }
+    return result;
+  }
+};
+function createGraduationWorker(eventStore, graduation, config) {
+  return new GraduationWorker(
+    eventStore,
+    graduation,
+    { ...DEFAULT_CONFIG5, ...config }
+  );
+}
+
 // src/services/memory-service.ts
 function normalizePath(projectPath) {
   const expanded = projectPath.startsWith("~") ? path.join(os.homedir(), projectPath.slice(1)) : projectPath;
@@ -3371,13 +4519,18 @@ function getProjectStoragePath(projectPath) {
 var REGISTRY_PATH = path.join(os.homedir(), ".claude-code", "memory", "session-registry.json");
 var SHARED_STORAGE_PATH = path.join(os.homedir(), ".claude-code", "memory", "shared");
 var MemoryService = class {
-  eventStore;
+  // 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;
   retriever;
   graduation;
   vectorWorker = null;
+  graduationWorker = null;
   initialized = false;
   // Endless Mode components
   workingSetStore = null;
@@ -3392,24 +4545,48 @@ var MemoryService = class {
   sharedPromoter = null;
   sharedStoreConfig = null;
   projectHash = null;
+  readOnly;
   constructor(config) {
     const storagePath = this.expandPath(config.storagePath);
-    if (!fs.existsSync(storagePath)) {
+    this.readOnly = config.readOnly ?? false;
+    if (!this.readOnly && !fs.existsSync(storagePath)) {
       fs.mkdirSync(storagePath, { recursive: true });
     }
     this.projectHash = config.projectHash || null;
     this.sharedStoreConfig = config.sharedStoreConfig ?? { enabled: true };
-    this.eventStore = new EventStore(path.join(storagePath, "events.duckdb"));
+    this.sqliteStore = new SQLiteEventStore(
+      path.join(storagePath, "events.sqlite"),
+      { readonly: this.readOnly }
+    );
+    const analyticsEnabled = config.analyticsEnabled ?? this.readOnly;
+    if (!analyticsEnabled) {
+      this.analyticsStore = null;
+    } else if (this.readOnly) {
+      try {
+        this.analyticsStore = new EventStore(
+          path.join(storagePath, "analytics.duckdb"),
+          { readOnly: true }
+        );
+      } catch {
+        this.analyticsStore = null;
+      }
+    } else {
+      this.analyticsStore = new EventStore(
+        path.join(storagePath, "analytics.duckdb"),
+        { readOnly: false }
+      );
+    }
     this.vectorStore = new VectorStore(path.join(storagePath, "vectors"));
     this.embedder = config.embeddingModel ? new Embedder(config.embeddingModel) : getDefaultEmbedder();
     this.matcher = getDefaultMatcher();
     this.retriever = createRetriever(
-      this.eventStore,
+      this.sqliteStore,
+      // Interface compatible
       this.vectorStore,
       this.embedder,
       this.matcher
     );
-    this.graduation = createGraduationPipeline(this.eventStore);
+    this.graduation = createGraduationPipeline(this.sqliteStore);
   }
   /**
    * Initialize all components
@@ -3417,22 +4594,45 @@ var MemoryService = class {
   async initialize() {
     if (this.initialized)
       return;
-    await this.eventStore.initialize();
+    await this.sqliteStore.initialize();
+    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();
-    this.vectorWorker = createVectorWorker(
-      this.eventStore,
-      this.vectorStore,
-      this.embedder
-    );
-    this.vectorWorker.start();
-    const savedMode = await this.eventStore.getEndlessConfig("mode");
-    if (savedMode === "endless") {
-      this.endlessMode = "endless";
-      await this.initializeEndlessMode();
-    }
-    if (this.sharedStoreConfig?.enabled !== false) {
-      await this.initializeSharedStore();
+    if (!this.readOnly) {
+      this.vectorWorker = createVectorWorker(
+        this.sqliteStore,
+        this.vectorStore,
+        this.embedder
+      );
+      this.vectorWorker.start();
+      this.retriever.setGraduationPipeline(this.graduation);
+      this.graduationWorker = createGraduationWorker(
+        this.sqliteStore,
+        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") {
+        this.endlessMode = "endless";
+        await this.initializeEndlessMode();
+      }
+      if (this.sharedStoreConfig?.enabled !== false) {
+        await this.initializeSharedStore();
+      }
     }
     this.initialized = true;
   }
@@ -3466,7 +4666,7 @@ var MemoryService = class {
    */
   async startSession(sessionId, projectPath) {
     await this.initialize();
-    await this.eventStore.upsertSession({
+    await this.sqliteStore.upsertSession({
       id: sessionId,
       startedAt: /* @__PURE__ */ new Date(),
       projectPath
@@ -3477,7 +4677,7 @@ var MemoryService = class {
    */
   async endSession(sessionId, summary) {
     await this.initialize();
-    await this.eventStore.upsertSession({
+    await this.sqliteStore.upsertSession({
       id: sessionId,
       endedAt: /* @__PURE__ */ new Date(),
       summary
@@ -3488,7 +4688,7 @@ var MemoryService = class {
    */
   async storeUserPrompt(sessionId, content, metadata) {
     await this.initialize();
-    const result = await this.eventStore.append({
+    const result = await this.sqliteStore.append({
       eventType: "user_prompt",
       sessionId,
       timestamp: /* @__PURE__ */ new Date(),
@@ -3496,7 +4696,7 @@ var MemoryService = class {
       metadata
     });
     if (result.success && !result.isDuplicate) {
-      await this.eventStore.enqueueForEmbedding(result.eventId, content);
+      await this.sqliteStore.enqueueForEmbedding(result.eventId, content);
     }
     return result;
   }
@@ -3505,7 +4705,7 @@ var MemoryService = class {
    */
   async storeAgentResponse(sessionId, content, metadata) {
     await this.initialize();
-    const result = await this.eventStore.append({
+    const result = await this.sqliteStore.append({
       eventType: "agent_response",
       sessionId,
       timestamp: /* @__PURE__ */ new Date(),
@@ -3513,7 +4713,7 @@ var MemoryService = class {
       metadata
     });
     if (result.success && !result.isDuplicate) {
-      await this.eventStore.enqueueForEmbedding(result.eventId, content);
+      await this.sqliteStore.enqueueForEmbedding(result.eventId, content);
     }
     return result;
   }
@@ -3522,14 +4722,14 @@ var MemoryService = class {
    */
   async storeSessionSummary(sessionId, summary) {
     await this.initialize();
-    const result = await this.eventStore.append({
+    const result = await this.sqliteStore.append({
       eventType: "session_summary",
       sessionId,
       timestamp: /* @__PURE__ */ new Date(),
       content: summary
     });
     if (result.success && !result.isDuplicate) {
-      await this.eventStore.enqueueForEmbedding(result.eventId, summary);
+      await this.sqliteStore.enqueueForEmbedding(result.eventId, summary);
     }
     return result;
   }
@@ -3539,7 +4739,7 @@ var MemoryService = class {
   async storeToolObservation(sessionId, payload) {
     await this.initialize();
     const content = JSON.stringify(payload);
-    const result = await this.eventStore.append({
+    const result = await this.sqliteStore.append({
       eventType: "tool_observation",
       sessionId,
       timestamp: /* @__PURE__ */ new Date(),
@@ -3555,7 +4755,7 @@ var MemoryService = class {
         payload.metadata || {},
         payload.success
       );
-      await this.eventStore.enqueueForEmbedding(result.eventId, embeddingContent);
+      await this.sqliteStore.enqueueForEmbedding(result.eventId, embeddingContent);
     }
     return result;
   }
@@ -3581,21 +4781,21 @@ var MemoryService = class {
    */
   async getSessionHistory(sessionId) {
     await this.initialize();
-    return this.eventStore.getSessionEvents(sessionId);
+    return this.sqliteStore.getSessionEvents(sessionId);
   }
   /**
    * Get recent events
    */
   async getRecentEvents(limit = 100) {
     await this.initialize();
-    return this.eventStore.getRecentEvents(limit);
+    return this.sqliteStore.getRecentEvents(limit);
   }
   /**
    * Get memory statistics
    */
   async getStats() {
     await this.initialize();
-    const recentEvents = await this.eventStore.getRecentEvents(1e4);
+    const recentEvents = await this.sqliteStore.getRecentEvents(1e4);
     const vectorCount = await this.vectorStore.count();
     const levelStats = await this.graduation.getStats();
     return {
@@ -3613,6 +4813,20 @@ var MemoryService = class {
     }
     return 0;
   }
+  /**
+   * Get events by memory level
+   */
+  async getEventsByLevel(level, options) {
+    await this.initialize();
+    return this.sqliteStore.getEventsByLevel(level, options);
+  }
+  /**
+   * Get memory level for a specific event
+   */
+  async getEventLevel(eventId) {
+    await this.initialize();
+    return this.sqliteStore.getEventLevel(eventId);
+  }
   /**
    * Format retrieval results as context for Claude
    */
@@ -3705,21 +4919,21 @@ var MemoryService = class {
    */
   async initializeEndlessMode() {
     const config = await this.getEndlessConfig();
-    this.workingSetStore = createWorkingSetStore(this.eventStore, config);
-    this.consolidatedStore = createConsolidatedStore(this.eventStore);
+    this.workingSetStore = createWorkingSetStore(this.sqliteStore, config);
+    this.consolidatedStore = createConsolidatedStore(this.sqliteStore);
     this.consolidationWorker = createConsolidationWorker(
       this.workingSetStore,
       this.consolidatedStore,
       config
     );
-    this.continuityManager = createContinuityManager(this.eventStore, config);
+    this.continuityManager = createContinuityManager(this.sqliteStore, config);
     this.consolidationWorker.start();
   }
   /**
    * Get Endless Mode configuration
    */
   async getEndlessConfig() {
-    const savedConfig = await this.eventStore.getEndlessConfig("config");
+    const savedConfig = await this.sqliteStore.getEndlessConfig("config");
     return savedConfig || this.getDefaultEndlessConfig();
   }
   /**
@@ -3728,7 +4942,7 @@ var MemoryService = class {
   async setEndlessConfig(config) {
     const current = await this.getEndlessConfig();
     const merged = { ...current, ...config };
-    await this.eventStore.setEndlessConfig("config", merged);
+    await this.sqliteStore.setEndlessConfig("config", merged);
   }
   /**
    * Set memory mode (session or endless)
@@ -3738,7 +4952,7 @@ var MemoryService = class {
     if (mode === this.endlessMode)
       return;
     this.endlessMode = mode;
-    await this.eventStore.setEndlessConfig("mode", mode);
+    await this.sqliteStore.setEndlessConfig("mode", mode);
     if (mode === "endless") {
       await this.initializeEndlessMode();
     } else {
@@ -3795,6 +5009,59 @@ var MemoryService = class {
       return [];
     return this.consolidatedStore.getAll({ limit });
   }
+  /**
+   * Increment access count for memories that were used in prompts
+   */
+  async incrementMemoryAccess(eventIds) {
+    if (eventIds.length === 0)
+      return;
+    if (this.sqliteStore) {
+      await this.sqliteStore.incrementAccessCount(eventIds);
+    } else if (this.eventStore) {
+      await this.eventStore.incrementAccessCount(eventIds);
+    }
+  }
+  /**
+   * Get most accessed memories from events
+   */
+  async getMostAccessedMemories(limit = 10) {
+    console.log("[getMostAccessedMemories] sqliteStore available:", !!this.sqliteStore);
+    if (this.sqliteStore) {
+      const events = await this.sqliteStore.getMostAccessed(limit);
+      console.log("[getMostAccessedMemories] Got events from SQLite:", events.length);
+      return events.map((event) => ({
+        memoryId: event.id,
+        summary: event.content.substring(0, 200) + (event.content.length > 200 ? "..." : ""),
+        topics: [],
+        // Could extract topics from content if needed
+        accessCount: event.access_count || 0,
+        lastAccessed: event.last_accessed_at || null,
+        confidence: 1,
+        createdAt: event.timestamp
+      }));
+    }
+    if (this.consolidatedStore) {
+      const consolidated = await this.consolidatedStore.getMostAccessed(limit);
+      return consolidated.map((m) => ({
+        memoryId: m.memoryId,
+        summary: m.summary,
+        topics: m.topics,
+        accessCount: m.accessCount,
+        lastAccessed: m.accessedAt,
+        confidence: m.confidence,
+        createdAt: m.createdAt
+      }));
+    }
+    return [];
+  }
+  /**
+   * Mark a consolidated memory as accessed
+   */
+  async markMemoryAccessed(memoryId) {
+    if (!this.consolidatedStore)
+      return;
+    await this.consolidatedStore.markAccessed(memoryId);
+  }
   /**
    * Calculate continuity score for current context
    */
@@ -3882,20 +5149,44 @@ var MemoryService = class {
     }
     return parts.join("\n");
   }
+  /**
+   * Force a graduation evaluation run
+   */
+  async forceGraduation() {
+    if (!this.graduationWorker) {
+      return { evaluated: 0, graduated: 0, byLevel: {} };
+    }
+    return this.graduationWorker.forceRun();
+  }
+  /**
+   * Record access to a memory event (for graduation scoring)
+   */
+  recordMemoryAccess(eventId, sessionId, confidence = 1) {
+    this.graduation.recordAccess(eventId, sessionId, confidence);
+  }
   /**
    * Shutdown service
    */
   async shutdown() {
+    if (this.graduationWorker) {
+      this.graduationWorker.stop();
+    }
     if (this.consolidationWorker) {
       this.consolidationWorker.stop();
     }
     if (this.vectorWorker) {
       this.vectorWorker.stop();
     }
+    if (this.syncWorker) {
+      this.syncWorker.stop();
+    }
     if (this.sharedEventStore) {
       await this.sharedEventStore.close();
     }
-    await this.eventStore.close();
+    await this.sqliteStore.close();
+    if (this.analyticsStore) {
+      await this.analyticsStore.close();
+    }
   }
   /**
    * Expand ~ to home directory
@@ -3908,14 +5199,15 @@ var MemoryService = class {
   }
 };
 var serviceCache = /* @__PURE__ */ new Map();
-var GLOBAL_KEY = "__global__";
-function getDefaultMemoryService() {
-  if (!serviceCache.has(GLOBAL_KEY)) {
-    serviceCache.set(GLOBAL_KEY, new MemoryService({
-      storagePath: "~/.claude-code/memory"
-    }));
-  }
-  return serviceCache.get(GLOBAL_KEY);
+function getReadOnlyMemoryService() {
+  return new MemoryService({
+    storagePath: "~/.claude-code/memory",
+    readOnly: true,
+    analyticsEnabled: false,
+    // Use SQLite for reads (WAL supports concurrent readers)
+    sharedStoreConfig: { enabled: false }
+    // Skip shared store for now
+  });
 }
 function getMemoryServiceForProject(projectPath, sharedStoreConfig) {
   const hash = hashProjectPath(projectPath);
@@ -3924,7 +5216,10 @@ function getMemoryServiceForProject(projectPath, sharedStoreConfig) {
     serviceCache.set(hash, new MemoryService({
       storagePath,
       projectHash: hash,
-      sharedStoreConfig
+      // Override shared store config - hooks don't need DuckDB
+      sharedStoreConfig: sharedStoreConfig ?? { enabled: false },
+      analyticsEnabled: false
+      // Hooks don't need DuckDB
     }));
   }
   return serviceCache.get(hash);
@@ -3935,8 +5230,8 @@ var sessionsRouter = new Hono();
 sessionsRouter.get("/", async (c) => {
   const page = parseInt(c.req.query("page") || "1", 10);
   const pageSize = parseInt(c.req.query("pageSize") || "20", 10);
+  const memoryService = getReadOnlyMemoryService();
   try {
-    const memoryService = getDefaultMemoryService();
     await memoryService.initialize();
     const recentEvents = await memoryService.getRecentEvents(1e3);
     const sessionMap = /* @__PURE__ */ new Map();
@@ -3973,12 +5268,14 @@ sessionsRouter.get("/", async (c) => {
     });
   } catch (error) {
     return c.json({ error: error.message }, 500);
+  } finally {
+    await memoryService.shutdown();
   }
 });
 sessionsRouter.get("/:id", async (c) => {
   const { id } = c.req.param();
+  const memoryService = getReadOnlyMemoryService();
   try {
-    const memoryService = getDefaultMemoryService();
     await memoryService.initialize();
     const events = await memoryService.getSessionHistory(id);
     if (events.length === 0) {
@@ -4007,6 +5304,8 @@ sessionsRouter.get("/:id", async (c) => {
     });
   } catch (error) {
     return c.json({ error: error.message }, 500);
+  } finally {
+    await memoryService.shutdown();
   }
 });
 
@@ -4018,8 +5317,8 @@ eventsRouter.get("/", async (c) => {
   const eventType = c.req.query("type");
   const limit = parseInt(c.req.query("limit") || "100", 10);
   const offset = parseInt(c.req.query("offset") || "0", 10);
+  const memoryService = getReadOnlyMemoryService();
   try {
-    const memoryService = getDefaultMemoryService();
     await memoryService.initialize();
     let events = await memoryService.getRecentEvents(limit + offset + 1e3);
     if (sessionId) {
@@ -4046,12 +5345,14 @@ eventsRouter.get("/", async (c) => {
     });
   } catch (error) {
     return c.json({ error: error.message }, 500);
+  } finally {
+    await memoryService.shutdown();
   }
 });
 eventsRouter.get("/:id", async (c) => {
   const { id } = c.req.param();
+  const memoryService = getReadOnlyMemoryService();
   try {
-    const memoryService = getDefaultMemoryService();
     await memoryService.initialize();
     const recentEvents = await memoryService.getRecentEvents(1e4);
     const event = recentEvents.find((e) => e.id === id);
@@ -4081,6 +5382,8 @@ eventsRouter.get("/:id", async (c) => {
     });
   } catch (error) {
     return c.json({ error: error.message }, 500);
+  } finally {
+    await memoryService.shutdown();
   }
 });
 
@@ -4088,12 +5391,12 @@ eventsRouter.get("/:id", async (c) => {
 import { Hono as Hono3 } from "hono";
 var searchRouter = new Hono3();
 searchRouter.post("/", async (c) => {
+  const memoryService = getReadOnlyMemoryService();
   try {
     const body = await c.req.json();
     if (!body.query) {
       return c.json({ error: "Query is required" }, 400);
     }
-    const memoryService = getDefaultMemoryService();
     await memoryService.initialize();
     const startTime = Date.now();
     const result = await memoryService.retrieveMemories(body.query, {
@@ -4122,6 +5425,8 @@ searchRouter.post("/", async (c) => {
     });
   } catch (error) {
     return c.json({ error: error.message }, 500);
+  } finally {
+    await memoryService.shutdown();
   }
 });
 searchRouter.get("/", async (c) => {
@@ -4130,8 +5435,8 @@ searchRouter.get("/", async (c) => {
     return c.json({ error: 'Query parameter "q" is required' }, 400);
   }
   const topK = parseInt(c.req.query("topK") || "5", 10);
+  const memoryService = getReadOnlyMemoryService();
   try {
-    const memoryService = getDefaultMemoryService();
     await memoryService.initialize();
     const result = await memoryService.retrieveMemories(query, { topK });
     return c.json({
@@ -4149,6 +5454,8 @@ searchRouter.get("/", async (c) => {
     });
   } catch (error) {
     return c.json({ error: error.message }, 500);
+  } finally {
+    await memoryService.shutdown();
   }
 });
 
@@ -4156,8 +5463,8 @@ searchRouter.get("/", async (c) => {
 import { Hono as Hono4 } from "hono";
 var statsRouter = new Hono4();
 statsRouter.get("/shared", async (c) => {
+  const memoryService = getReadOnlyMemoryService();
   try {
-    const memoryService = getDefaultMemoryService();
     await memoryService.initialize();
     const sharedStats = await memoryService.getSharedStoreStats();
     return c.json({
@@ -4175,12 +5482,14 @@ statsRouter.get("/shared", async (c) => {
       totalUsageCount: 0,
       lastUpdated: null
     });
+  } finally {
+    await memoryService.shutdown();
   }
 });
 statsRouter.get("/endless", async (c) => {
+  const projectPath = c.req.query("project") || process.cwd();
+  const memoryService = getMemoryServiceForProject(projectPath);
   try {
-    const projectPath = c.req.query("project") || process.cwd();
-    const memoryService = getMemoryServiceForProject(projectPath);
     await memoryService.initialize();
     const status = await memoryService.getEndlessModeStatus();
     return c.json({
@@ -4198,11 +5507,68 @@ statsRouter.get("/endless", async (c) => {
       consolidatedCount: 0,
       lastConsolidation: null
     });
+  } finally {
+    await memoryService.shutdown();
+  }
+});
+statsRouter.get("/levels/:level", async (c) => {
+  const { level } = c.req.param();
+  const limit = parseInt(c.req.query("limit") || "20", 10);
+  const offset = parseInt(c.req.query("offset") || "0", 10);
+  const sort = c.req.query("sort") || "recent";
+  const validLevels = ["L0", "L1", "L2", "L3", "L4"];
+  if (!validLevels.includes(level)) {
+    return c.json({ error: `Invalid level. Must be one of: ${validLevels.join(", ")}` }, 400);
+  }
+  const memoryService = getReadOnlyMemoryService();
+  try {
+    await memoryService.initialize();
+    let events = await memoryService.getEventsByLevel(level, { limit: limit * 2, offset });
+    const stats = await memoryService.getStats();
+    const levelStat = stats.levelStats.find((s) => s.level === level);
+    if (sort === "accessed") {
+      const sqliteStore = memoryService.sqliteEventStore;
+      if (sqliteStore) {
+        const eventIds = events.map((e) => e.id);
+        const accessedEvents = await sqliteStore.getMostAccessed(1e3);
+        const accessMap = new Map(accessedEvents.map((e) => [e.id, e.access_count || 0]));
+        events = events.map((e) => ({
+          ...e,
+          accessCount: accessMap.get(e.id) || 0
+        }));
+        events.sort((a, b) => b.accessCount - a.accessCount);
+      }
+    } else if (sort === "oldest") {
+      events.sort((a, b) => a.timestamp.getTime() - b.timestamp.getTime());
+    } else {
+      events.sort((a, b) => b.timestamp.getTime() - a.timestamp.getTime());
+    }
+    events = events.slice(0, limit);
+    return c.json({
+      level,
+      events: events.map((e) => ({
+        id: e.id,
+        eventType: e.eventType,
+        sessionId: e.sessionId,
+        timestamp: e.timestamp.toISOString(),
+        content: e.content.slice(0, 500) + (e.content.length > 500 ? "..." : ""),
+        metadata: e.metadata,
+        accessCount: e.accessCount || 0
+      })),
+      total: levelStat?.count || 0,
+      limit,
+      offset,
+      hasMore: events.length === limit
+    });
+  } catch (error) {
+    return c.json({ error: error.message }, 500);
+  } finally {
+    await memoryService.shutdown();
   }
 });
 statsRouter.get("/", async (c) => {
+  const memoryService = getReadOnlyMemoryService();
   try {
-    const memoryService = getDefaultMemoryService();
     await memoryService.initialize();
     const stats = await memoryService.getStats();
     const recentEvents = await memoryService.getRecentEvents(1e4);
@@ -4239,12 +5605,45 @@ statsRouter.get("/", async (c) => {
     });
   } catch (error) {
     return c.json({ error: error.message }, 500);
+  } finally {
+    await memoryService.shutdown();
+  }
+});
+statsRouter.get("/most-accessed", async (c) => {
+  const limit = parseInt(c.req.query("limit") || "10", 10);
+  const memoryService = getReadOnlyMemoryService();
+  try {
+    await memoryService.initialize();
+    console.log("[most-accessed] Fetching most accessed memories, limit:", limit);
+    const memories = await memoryService.getMostAccessedMemories(limit);
+    console.log("[most-accessed] Got memories:", memories.length);
+    return c.json({
+      memories: memories.map((m) => ({
+        memoryId: m.memoryId,
+        summary: m.summary,
+        topics: m.topics,
+        accessCount: m.accessCount,
+        lastAccessed: m.lastAccessed || null,
+        confidence: m.confidence,
+        createdAt: m.createdAt instanceof Date ? m.createdAt.toISOString() : m.createdAt
+      })),
+      total: memories.length
+    });
+  } catch (error) {
+    console.error("[most-accessed] Error:", error);
+    return c.json({
+      memories: [],
+      total: 0,
+      error: error.message
+    });
+  } finally {
+    await memoryService.shutdown();
   }
 });
 statsRouter.get("/timeline", async (c) => {
   const days = parseInt(c.req.query("days") || "7", 10);
+  const memoryService = getReadOnlyMemoryService();
   try {
-    const memoryService = getDefaultMemoryService();
     await memoryService.initialize();
     const recentEvents = await memoryService.getRecentEvents(1e4);
     const cutoff = new Date(Date.now() - days * 24 * 60 * 60 * 1e3);
@@ -4269,8 +5668,46 @@ statsRouter.get("/timeline", async (c) => {
     });
   } catch (error) {
     return c.json({ error: error.message }, 500);
+  } finally {
+    await memoryService.shutdown();
+  }
+});
+statsRouter.post("/graduation/run", async (c) => {
+  const memoryService = getReadOnlyMemoryService();
+  try {
+    await memoryService.initialize();
+    const result = await memoryService.forceGraduation();
+    return c.json({
+      success: true,
+      evaluated: result.evaluated,
+      graduated: result.graduated,
+      byLevel: result.byLevel
+    });
+  } catch (error) {
+    return c.json({
+      success: false,
+      error: error.message
+    }, 500);
+  } finally {
+    await memoryService.shutdown();
   }
 });
+statsRouter.get("/graduation", async (c) => {
+  return c.json({
+    criteria: {
+      L0toL1: { minAccessCount: 1, minConfidence: 0.5, minCrossSessionRefs: 0, maxAgeDays: 30 },
+      L1toL2: { minAccessCount: 3, minConfidence: 0.7, minCrossSessionRefs: 1, maxAgeDays: 60 },
+      L2toL3: { minAccessCount: 5, minConfidence: 0.85, minCrossSessionRefs: 2, maxAgeDays: 90 },
+      L3toL4: { minAccessCount: 10, minConfidence: 0.92, minCrossSessionRefs: 3, maxAgeDays: 180 }
+    },
+    description: {
+      accessCount: "Number of times the memory was retrieved/referenced",
+      confidence: "Match confidence score when retrieved (0.0-1.0)",
+      crossSessionRefs: "Number of different sessions that referenced this memory",
+      maxAgeDays: "Maximum days since last access (prevents stale promotion)"
+    }
+  });
+});
 
 // src/server/api/citations.ts
 import { Hono as Hono5 } from "hono";
@@ -4297,8 +5734,8 @@ var citationsRouter = new Hono5();
 citationsRouter.get("/:id", async (c) => {
   const { id } = c.req.param();
   const citationId = parseCitationId(id) || id;
+  const memoryService = getReadOnlyMemoryService();
   try {
-    const memoryService = getDefaultMemoryService();
     await memoryService.initialize();
     const recentEvents = await memoryService.getRecentEvents(1e4);
     const event = recentEvents.find((e) => {
@@ -4324,13 +5761,15 @@ citationsRouter.get("/:id", async (c) => {
     });
   } catch (error) {
     return c.json({ error: error.message }, 500);
+  } finally {
+    await memoryService.shutdown();
   }
 });
 citationsRouter.get("/:id/related", async (c) => {
   const { id } = c.req.param();
   const citationId = parseCitationId(id) || id;
+  const memoryService = getReadOnlyMemoryService();
   try {
-    const memoryService = getDefaultMemoryService();
     await memoryService.initialize();
     const recentEvents = await memoryService.getRecentEvents(1e4);
     const event = recentEvents.find((e) => {
@@ -4360,6 +5799,8 @@ citationsRouter.get("/:id/related", async (c) => {
     });
   } catch (error) {
     return c.json({ error: error.message }, 500);
+  } finally {
+    await memoryService.shutdown();
   }
 });
 
@@ -4372,7 +5813,7 @@ 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 = path2.join(import.meta.dir, "../../dist/ui");
+var uiPath = path2.join(__dirname, "../../dist/ui");
 if (fs2.existsSync(uiPath)) {
   app.use("/*", serveStatic({ root: uiPath }));
 }
@@ -4388,17 +5829,17 @@ function startServer(port = 37777) {
   if (serverInstance) {
     return serverInstance;
   }
-  serverInstance = Bun.serve({
-    hostname: "127.0.0.1",
+  serverInstance = serve({
+    fetch: app.fetch,
     port,
-    fetch: app.fetch
+    hostname: "127.0.0.1"
   });
   console.log(`\u{1F9E0} Code Memory viewer started at http://localhost:${port}`);
   return serverInstance;
 }
 function stopServer() {
   if (serverInstance) {
-    serverInstance.stop();
+    serverInstance.close();
     serverInstance = null;
   }
 }
@@ -4410,7 +5851,8 @@ async function isServerRunning(port = 37777) {
     return false;
   }
 }
-if (import.meta.main) {
+var isMainModule = process.argv[1]?.includes("server/index") || process.argv[1]?.endsWith("server.js");
+if (isMainModule) {
   const port = parseInt(process.env.PORT || "37777", 10);
   startServer(port);
 }