claude-memory-layer 1.0.7 → 1.0.8

package/dist/cli/index.js

@@ -9,6 +9,9 @@ const __dirname = dirname(__filename);
 // src/cli/index.ts
 import { Command } from "commander";
 import { exec } from "child_process";
+import * as fs4 from "fs";
+import * as path4 from "path";
+import * as os3 from "os";
 
 // src/services/memory-service.ts
 import * as path from "path";
@@ -71,8 +74,11 @@ function toDate(value) {
     return new Date(value);
   return new Date(String(value));
 }
-function createDatabase(path4) {
-  return new duckdb.Database(path4);
+function createDatabase(path5, options) {
+  if (options?.readOnly) {
+    return new duckdb.Database(path5, { access_mode: "READ_ONLY" });
+  }
+  return new duckdb.Database(path5);
 }
 function dbRun(db, sql, params = []) {
   return new Promise((resolve2, reject) => {
@@ -125,18 +131,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,
@@ -613,6 +625,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
   // ============================================================
@@ -1195,6 +1237,7 @@ var Retriever = class {
   matcher;
   sharedStore;
   sharedVectorStore;
+  graduation;
   constructor(eventStore, vectorStore, embedder, matcher, sharedOptions) {
     this.eventStore = eventStore;
     this.vectorStore = vectorStore;
@@ -1203,6 +1246,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
    */
@@ -1325,6 +1374,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);
@@ -1446,15 +1502,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,
@@ -3342,6 +3409,127 @@ function createContinuityManager(eventStore, config) {
   return new ContinuityManager(eventStore, config);
 }
 
+// src/core/graduation-worker.ts
+var DEFAULT_CONFIG4 = {
+  evaluationIntervalMs: 3e5,
+  // 5 minutes
+  batchSize: 50,
+  cooldownMs: 36e5
+  // 1 hour cooldown between evaluations
+};
+var GraduationWorker = class {
+  constructor(eventStore, graduation, config = DEFAULT_CONFIG4) {
+    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_CONFIG4, ...config }
+  );
+}
+
 // src/services/memory-service.ts
 function normalizePath(projectPath) {
   const expanded = projectPath.startsWith("~") ? path.join(os.homedir(), projectPath.slice(1)) : projectPath;
@@ -3369,6 +3557,7 @@ var MemoryService = class {
   retriever;
   graduation;
   vectorWorker = null;
+  graduationWorker = null;
   initialized = false;
   // Endless Mode components
   workingSetStore = null;
@@ -3383,14 +3572,16 @@ 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.eventStore = new EventStore(path.join(storagePath, "events.duckdb"), { readOnly: this.readOnly });
     this.vectorStore = new VectorStore(path.join(storagePath, "vectors"));
     this.embedder = config.embeddingModel ? new Embedder(config.embeddingModel) : getDefaultEmbedder();
     this.matcher = getDefaultMatcher();
@@ -3411,19 +3602,27 @@ var MemoryService = class {
     await this.eventStore.initialize();
     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.eventStore,
+        this.vectorStore,
+        this.embedder
+      );
+      this.vectorWorker.start();
+      this.retriever.setGraduationPipeline(this.graduation);
+      this.graduationWorker = createGraduationWorker(
+        this.eventStore,
+        this.graduation
+      );
+      this.graduationWorker.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();
+      }
     }
     this.initialized = true;
   }
@@ -3604,6 +3803,20 @@ var MemoryService = class {
     }
     return 0;
   }
+  /**
+   * Get events by memory level
+   */
+  async getEventsByLevel(level, options) {
+    await this.initialize();
+    return this.eventStore.getEventsByLevel(level, options);
+  }
+  /**
+   * Get memory level for a specific event
+   */
+  async getEventLevel(eventId) {
+    await this.initialize();
+    return this.eventStore.getEventLevel(eventId);
+  }
   /**
    * Format retrieval results as context for Claude
    */
@@ -3786,6 +3999,22 @@ var MemoryService = class {
       return [];
     return this.consolidatedStore.getAll({ limit });
   }
+  /**
+   * Get most accessed consolidated memories
+   */
+  async getMostAccessedMemories(limit = 10) {
+    if (!this.consolidatedStore)
+      return [];
+    return this.consolidatedStore.getMostAccessed(limit);
+  }
+  /**
+   * Mark a consolidated memory as accessed
+   */
+  async markMemoryAccessed(memoryId) {
+    if (!this.consolidatedStore)
+      return;
+    await this.consolidatedStore.markAccessed(memoryId);
+  }
   /**
    * Calculate continuity score for current context
    */
@@ -3873,10 +4102,28 @@ 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();
     }
@@ -3908,6 +4155,12 @@ function getDefaultMemoryService() {
   }
   return serviceCache.get(GLOBAL_KEY);
 }
+function getReadOnlyMemoryService() {
+  return new MemoryService({
+    storagePath: "~/.claude-code/memory",
+    readOnly: true
+  });
+}
 function getMemoryServiceForProject(projectPath, sharedStoreConfig) {
   const hash = hashProjectPath(projectPath);
   if (!serviceCache.has(hash)) {
@@ -4163,7 +4416,8 @@ function createSessionHistoryImporter(memoryService) {
 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 path3 from "path";
 import * as fs3 from "fs";
 
@@ -4176,8 +4430,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();
@@ -4214,12 +4468,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) {
@@ -4248,6 +4504,8 @@ sessionsRouter.get("/:id", async (c) => {
     });
   } catch (error) {
     return c.json({ error: error.message }, 500);
+  } finally {
+    await memoryService.shutdown();
   }
 });
 
@@ -4259,8 +4517,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) {
@@ -4287,12 +4545,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);
@@ -4322,6 +4582,8 @@ eventsRouter.get("/:id", async (c) => {
     });
   } catch (error) {
     return c.json({ error: error.message }, 500);
+  } finally {
+    await memoryService.shutdown();
   }
 });
 
@@ -4329,12 +4591,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, {
@@ -4363,6 +4625,8 @@ searchRouter.post("/", async (c) => {
     });
   } catch (error) {
     return c.json({ error: error.message }, 500);
+  } finally {
+    await memoryService.shutdown();
   }
 });
 searchRouter.get("/", async (c) => {
@@ -4371,8 +4635,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({
@@ -4390,6 +4654,8 @@ searchRouter.get("/", async (c) => {
     });
   } catch (error) {
     return c.json({ error: error.message }, 500);
+  } finally {
+    await memoryService.shutdown();
   }
 });
 
@@ -4397,8 +4663,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({
@@ -4416,12 +4682,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({
@@ -4439,11 +4707,48 @@ 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 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();
+    const events = await memoryService.getEventsByLevel(level, { limit, offset });
+    const stats = await memoryService.getStats();
+    const levelStat = stats.levelStats.find((s) => s.level === level);
+    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
+      })),
+      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);
@@ -4480,12 +4785,43 @@ 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 projectPath = c.req.query("project") || process.cwd();
+  const memoryService = getMemoryServiceForProject(projectPath);
+  try {
+    await memoryService.initialize();
+    const memories = await memoryService.getMostAccessedMemories(limit);
+    return c.json({
+      memories: memories.map((m) => ({
+        memoryId: m.memoryId,
+        summary: m.summary,
+        topics: m.topics,
+        accessCount: m.accessCount,
+        lastAccessed: m.accessedAt?.toISOString() || null,
+        confidence: m.confidence,
+        createdAt: m.createdAt.toISOString()
+      })),
+      total: memories.length
+    });
+  } catch (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);
@@ -4510,8 +4846,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";
@@ -4538,8 +4912,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) => {
@@ -4565,13 +4939,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) => {
@@ -4601,6 +4977,8 @@ citationsRouter.get("/:id/related", async (c) => {
     });
   } catch (error) {
     return c.json({ error: error.message }, 500);
+  } finally {
+    await memoryService.shutdown();
   }
 });
 
@@ -4613,7 +4991,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 = path3.join(import.meta.dir, "../../dist/ui");
+var uiPath = path3.join(__dirname, "../../dist/ui");
 if (fs3.existsSync(uiPath)) {
   app.use("/*", serveStatic({ root: uiPath }));
 }
@@ -4629,17 +5007,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;
   }
 }
@@ -4651,14 +5029,166 @@ 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);
 }
 
 // src/cli/index.ts
+var CLAUDE_SETTINGS_PATH = path4.join(os3.homedir(), ".claude", "settings.json");
+function getPluginPath() {
+  const possiblePaths = [
+    path4.join(__dirname, ".."),
+    // When running from dist/cli
+    path4.join(__dirname, "../..", "dist"),
+    // When running from src
+    path4.join(process.cwd(), "dist")
+    // Current working directory
+  ];
+  for (const p of possiblePaths) {
+    const hooksPath = path4.join(p, "hooks", "user-prompt-submit.js");
+    if (fs4.existsSync(hooksPath)) {
+      return p;
+    }
+  }
+  return path4.join(os3.homedir(), ".npm-global", "lib", "node_modules", "claude-memory-layer", "dist");
+}
+function loadClaudeSettings() {
+  try {
+    if (fs4.existsSync(CLAUDE_SETTINGS_PATH)) {
+      const content = fs4.readFileSync(CLAUDE_SETTINGS_PATH, "utf-8");
+      return JSON.parse(content);
+    }
+  } catch (error) {
+    console.error("Warning: Could not read existing settings:", error);
+  }
+  return {};
+}
+function saveClaudeSettings(settings) {
+  const dir = path4.dirname(CLAUDE_SETTINGS_PATH);
+  if (!fs4.existsSync(dir)) {
+    fs4.mkdirSync(dir, { recursive: true });
+  }
+  const tempPath = CLAUDE_SETTINGS_PATH + ".tmp";
+  fs4.writeFileSync(tempPath, JSON.stringify(settings, null, 2));
+  fs4.renameSync(tempPath, CLAUDE_SETTINGS_PATH);
+}
+function getHooksConfig(pluginPath) {
+  return {
+    UserPromptSubmit: [
+      {
+        matcher: "",
+        hooks: [
+          {
+            type: "command",
+            command: `node ${path4.join(pluginPath, "hooks", "user-prompt-submit.js")}`
+          }
+        ]
+      }
+    ],
+    PostToolUse: [
+      {
+        matcher: "",
+        hooks: [
+          {
+            type: "command",
+            command: `node ${path4.join(pluginPath, "hooks", "post-tool-use.js")}`
+          }
+        ]
+      }
+    ]
+  };
+}
 var program = new Command();
 program.name("claude-memory-layer").description("Claude Code Memory Plugin CLI").version("1.0.0");
+program.command("install").description("Install hooks into Claude Code settings").option("--path <path>", "Custom plugin path (defaults to auto-detect)").action(async (options) => {
+  try {
+    const pluginPath = options.path || getPluginPath();
+    const userPromptHook = path4.join(pluginPath, "hooks", "user-prompt-submit.js");
+    if (!fs4.existsSync(userPromptHook)) {
+      console.error(`
+\u274C Hook files not found at: ${pluginPath}`);
+      console.error('   Make sure you have built the plugin with "npm run build"');
+      process.exit(1);
+    }
+    const settings = loadClaudeSettings();
+    const newHooks = getHooksConfig(pluginPath);
+    settings.hooks = {
+      ...settings.hooks,
+      ...newHooks
+    };
+    saveClaudeSettings(settings);
+    console.log("\n\u2705 Claude Memory Layer installed!\n");
+    console.log("Hooks registered:");
+    console.log("  - UserPromptSubmit: Memory retrieval on user input");
+    console.log("  - PostToolUse: Store tool observations\n");
+    console.log("Plugin path:", pluginPath);
+    console.log("\n\u26A0\uFE0F  Restart Claude Code for changes to take effect.\n");
+    console.log("Commands:");
+    console.log("  claude-memory-layer dashboard  - Open web dashboard");
+    console.log("  claude-memory-layer search     - Search memories");
+    console.log("  claude-memory-layer stats      - View statistics");
+    console.log("  claude-memory-layer uninstall  - Remove hooks\n");
+  } catch (error) {
+    console.error("Install failed:", error);
+    process.exit(1);
+  }
+});
+program.command("uninstall").description("Remove hooks from Claude Code settings").action(async () => {
+  try {
+    const settings = loadClaudeSettings();
+    if (!settings.hooks) {
+      console.log("\n\u{1F4CB} No hooks installed.\n");
+      return;
+    }
+    delete settings.hooks.UserPromptSubmit;
+    delete settings.hooks.PostToolUse;
+    if (Object.keys(settings.hooks).length === 0) {
+      delete settings.hooks;
+    }
+    saveClaudeSettings(settings);
+    console.log("\n\u2705 Claude Memory Layer uninstalled!\n");
+    console.log("Hooks removed from Claude Code settings.");
+    console.log("Your memory data is preserved and can be accessed with:");
+    console.log("  claude-memory-layer dashboard\n");
+    console.log("\u26A0\uFE0F  Restart Claude Code for changes to take effect.\n");
+  } catch (error) {
+    console.error("Uninstall failed:", error);
+    process.exit(1);
+  }
+});
+program.command("status").description("Check plugin installation status").action(async () => {
+  try {
+    const settings = loadClaudeSettings();
+    const pluginPath = getPluginPath();
+    console.log("\n\u{1F9E0} Claude Memory Layer Status\n");
+    const hasUserPromptHook = settings.hooks?.UserPromptSubmit?.some(
+      (h) => h.hooks?.some((hook) => hook.command?.includes("user-prompt-submit"))
+    );
+    const hasPostToolHook = settings.hooks?.PostToolUse?.some(
+      (h) => h.hooks?.some((hook) => hook.command?.includes("post-tool-use"))
+    );
+    console.log("Hooks:");
+    console.log(`  UserPromptSubmit: ${hasUserPromptHook ? "\u2705 Installed" : "\u274C Not installed"}`);
+    console.log(`  PostToolUse: ${hasPostToolHook ? "\u2705 Installed" : "\u274C Not installed"}`);
+    const hooksExist = fs4.existsSync(path4.join(pluginPath, "hooks", "user-prompt-submit.js"));
+    console.log(`
+Plugin files: ${hooksExist ? "\u2705 Found" : "\u274C Not found"}`);
+    console.log(`  Path: ${pluginPath}`);
+    const dashboardRunning = await isServerRunning(37777);
+    console.log(`
+Dashboard: ${dashboardRunning ? "\u2705 Running at http://localhost:37777" : "\u23F9\uFE0F  Not running"}`);
+    if (!hasUserPromptHook || !hasPostToolHook) {
+      console.log('\n\u{1F4A1} Run "claude-memory-layer install" to set up hooks.\n');
+    } else {
+      console.log("\n\u2705 Plugin is fully installed and configured.\n");
+    }
+  } catch (error) {
+    console.error("Status check failed:", error);
+    process.exit(1);
+  }
+});
 program.command("search <query>").description("Search memories using semantic search").option("-k, --top-k <number>", "Number of results", "5").option("-s, --min-score <number>", "Minimum similarity score", "0.7").option("--session <id>", "Filter by session ID").option("-p, --project <path>", "Project path (defaults to cwd)").action(async (query, options) => {
   const projectPath = options.project || process.cwd();
   const service = getMemoryServiceForProject(projectPath);