claude-memory-layer 1.0.18 → 1.0.19

package/dist/cli/index.js

@@ -16,8 +16,8 @@ var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require
 // src/cli/index.ts
 import { Command } from "commander";
 import { exec } from "child_process";
-import * as fs9 from "fs";
-import * as path9 from "path";
+import * as fs10 from "fs";
+import * as path10 from "path";
 import * as os6 from "os";
 
 // src/services/memory-service.ts
@@ -81,57 +81,57 @@ function toDate(value) {
     return new Date(value);
   return new Date(String(value));
 }
-function createDatabase(path10, options) {
+function createDatabase(path11, options) {
   if (options?.readOnly) {
-    return new duckdb.Database(path10, { access_mode: "READ_ONLY" });
+    return new duckdb.Database(path11, { access_mode: "READ_ONLY" });
   }
-  return new duckdb.Database(path10);
+  return new duckdb.Database(path11);
 }
 function dbRun(db, sql, params = []) {
-  return new Promise((resolve4, reject) => {
+  return new Promise((resolve5, reject) => {
     if (params.length === 0) {
       db.run(sql, (err) => {
         if (err)
           reject(err);
         else
-          resolve4();
+          resolve5();
       });
     } else {
       db.run(sql, ...params, (err) => {
         if (err)
           reject(err);
         else
-          resolve4();
+          resolve5();
       });
     }
   });
 }
 function dbAll(db, sql, params = []) {
-  return new Promise((resolve4, reject) => {
+  return new Promise((resolve5, reject) => {
     if (params.length === 0) {
       db.all(sql, (err, rows) => {
         if (err)
           reject(err);
         else
-          resolve4(convertBigInts(rows || []));
+          resolve5(convertBigInts(rows || []));
       });
     } else {
       db.all(sql, ...params, (err, rows) => {
         if (err)
           reject(err);
         else
-          resolve4(convertBigInts(rows || []));
+          resolve5(convertBigInts(rows || []));
       });
     }
   });
 }
 function dbClose(db) {
-  return new Promise((resolve4, reject) => {
+  return new Promise((resolve5, reject) => {
     db.close((err) => {
       if (err)
         reject(err);
       else
-        resolve4();
+        resolve5();
     });
   });
 }
@@ -769,12 +769,12 @@ import { randomUUID as randomUUID2 } from "crypto";
 import Database from "better-sqlite3";
 import * as fs from "fs";
 import * as nodePath from "path";
-function createSQLiteDatabase(path10, options) {
-  const dir = nodePath.dirname(path10);
+function createSQLiteDatabase(path11, options) {
+  const dir = nodePath.dirname(path11);
   if (!fs.existsSync(dir)) {
     fs.mkdirSync(dir, { recursive: true });
   }
-  const db = new Database(path10, {
+  const db = new Database(path11, {
     readonly: options?.readonly ?? false
   });
   if (!options?.readonly && (options?.walMode ?? true)) {
@@ -2420,7 +2420,7 @@ var SyncWorker = class {
    * Sleep utility
    */
   sleep(ms) {
-    return new Promise((resolve4) => setTimeout(resolve4, ms));
+    return new Promise((resolve5) => setTimeout(resolve5, ms));
   }
   /**
    * Get sync statistics
@@ -3450,8 +3450,8 @@ _Context:_ ${sessionContext}`;
   matchesMetadataScope(metadata, expected) {
     if (!metadata)
       return false;
-    return Object.entries(expected).every(([path10, value]) => {
-      const actual = path10.split(".").reduce((acc, key) => {
+    return Object.entries(expected).every(([path11, value]) => {
+      const actual = path11.split(".").reduce((acc, key) => {
         if (typeof acc !== "object" || acc === null)
           return void 0;
         return acc[key];
@@ -6913,6 +6913,12 @@ var MemoryService = class {
   recordMemoryAccess(eventId, sessionId, confidence = 1) {
     this.graduation.recordAccess(eventId, sessionId, confidence);
   }
+  /**
+   * Backward-compatible alias used by some hooks
+   */
+  async close() {
+    await this.shutdown();
+  }
   /**
    * Shutdown service
    */
@@ -7766,8 +7772,8 @@ import { cors } from "hono/cors";
 import { logger } from "hono/logger";
 import { serve } from "@hono/node-server";
 import { serveStatic } from "@hono/node-server/serve-static";
-import * as path8 from "path";
-import * as fs8 from "fs";
+import * as path9 from "path";
+import * as fs9 from "fs";
 
 // src/server/api/index.ts
 import { Hono as Hono10 } from "hono";
@@ -7931,6 +7937,7 @@ eventsRouter.get("/", async (c) => {
         sessionId: e.sessionId,
         preview: e.content.slice(0, 200) + (e.content.length > 200 ? "..." : ""),
         contentLength: e.content.length,
+        metadata: e.metadata,
         accessCount: e.access_count || 0,
         lastAccessedAt: e.last_accessed_at || null
       })),
@@ -8057,7 +8064,175 @@ searchRouter.get("/", async (c) => {
 
 // src/server/api/stats.ts
 import { Hono as Hono4 } from "hono";
+import * as fs7 from "fs";
+import * as path7 from "path";
 var statsRouter = new Hono4();
+var DEFAULT_KPI_THRESHOLDS = {
+  usefulRecallRateMin: 0.45,
+  reworkRateMax: 0.25,
+  postChangeFailureRateMax: 0.2,
+  avgCompletionTurnsMax: 12,
+  memoryHitRateMin: 0.35
+};
+function loadKpiThresholds() {
+  try {
+    const filePath = path7.resolve(process.cwd(), "config", "kpi-thresholds.json");
+    if (!fs7.existsSync(filePath))
+      return DEFAULT_KPI_THRESHOLDS;
+    const parsed = JSON.parse(fs7.readFileSync(filePath, "utf-8"));
+    return {
+      usefulRecallRateMin: Number(parsed.usefulRecallRateMin ?? DEFAULT_KPI_THRESHOLDS.usefulRecallRateMin),
+      reworkRateMax: Number(parsed.reworkRateMax ?? DEFAULT_KPI_THRESHOLDS.reworkRateMax),
+      postChangeFailureRateMax: Number(parsed.postChangeFailureRateMax ?? DEFAULT_KPI_THRESHOLDS.postChangeFailureRateMax),
+      avgCompletionTurnsMax: Number(parsed.avgCompletionTurnsMax ?? DEFAULT_KPI_THRESHOLDS.avgCompletionTurnsMax),
+      memoryHitRateMin: Number(parsed.memoryHitRateMin ?? DEFAULT_KPI_THRESHOLDS.memoryHitRateMin)
+    };
+  } catch {
+    return DEFAULT_KPI_THRESHOLDS;
+  }
+}
+function windowToMs(window) {
+  if (window === "24h")
+    return 24 * 60 * 60 * 1e3;
+  if (window === "7d")
+    return 7 * 24 * 60 * 60 * 1e3;
+  return 30 * 24 * 60 * 60 * 1e3;
+}
+function inWindow(e, now, window) {
+  return now - e.timestamp.getTime() <= windowToMs(window);
+}
+function isEditToolName(name) {
+  return ["Write", "Edit", "MultiEdit", "NotebookEdit"].includes(name);
+}
+function parseToolPayload(e) {
+  if (e.eventType !== "tool_observation")
+    return null;
+  try {
+    const payload = JSON.parse(e.content);
+    return {
+      toolName: payload?.toolName,
+      success: payload?.success,
+      filePath: payload?.metadata?.filePath,
+      command: payload?.metadata?.command
+    };
+  } catch {
+    return {
+      toolName: e.metadata?.toolName,
+      success: e.metadata?.success,
+      filePath: e.metadata?.filePath,
+      command: e.metadata?.command
+    };
+  }
+}
+function isTestLikeCommand(command) {
+  if (!command)
+    return false;
+  return /(test|jest|vitest|pytest|go test|cargo test|lint|eslint|build|tsc)/i.test(command);
+}
+function safeRatio(num, den) {
+  if (!Number.isFinite(num) || !Number.isFinite(den) || den <= 0)
+    return 0;
+  return num / den;
+}
+function round(value, digits = 4) {
+  const factor = 10 ** digits;
+  return Math.round(value * factor) / factor;
+}
+function computeSessionTurnCount(sessionEvents) {
+  const turnIds = /* @__PURE__ */ new Set();
+  for (const e of sessionEvents) {
+    const turnId = e.metadata?.turnId;
+    if (typeof turnId === "string" && turnId.length > 0)
+      turnIds.add(turnId);
+  }
+  if (turnIds.size > 0)
+    return turnIds.size;
+  return sessionEvents.filter((e) => e.eventType === "user_prompt").length;
+}
+function computeKpiMetrics(events, usefulRecallRate) {
+  const prompts = events.filter((e) => e.eventType === "user_prompt");
+  const promptCount = prompts.length;
+  const memoryHitPrompts = prompts.filter((p) => p.metadata?.adherence?.checked).length;
+  const memoryHitRate = round(safeRatio(memoryHitPrompts, promptCount));
+  const sessions = /* @__PURE__ */ new Map();
+  for (const e of events) {
+    const arr = sessions.get(e.sessionId) || [];
+    arr.push(e);
+    sessions.set(e.sessionId, arr);
+  }
+  let sessionTurnTotal = 0;
+  let sessionTurnSamples = 0;
+  let firstValidEditMinutesTotal = 0;
+  let firstValidEditSamples = 0;
+  for (const sessionEvents of sessions.values()) {
+    sessionEvents.sort((a, b) => a.timestamp.getTime() - b.timestamp.getTime());
+    const turns = computeSessionTurnCount(sessionEvents);
+    if (turns > 0) {
+      sessionTurnTotal += turns;
+      sessionTurnSamples++;
+    }
+    const firstPrompt = sessionEvents.find((e) => e.eventType === "user_prompt");
+    const firstEdit = sessionEvents.find((e) => {
+      const payload = parseToolPayload(e);
+      return payload?.toolName && isEditToolName(payload.toolName) && payload.success === true;
+    });
+    if (firstPrompt && firstEdit) {
+      const minutes = (firstEdit.timestamp.getTime() - firstPrompt.timestamp.getTime()) / 6e4;
+      if (minutes >= 0) {
+        firstValidEditMinutesTotal += minutes;
+        firstValidEditSamples++;
+      }
+    }
+  }
+  const avgCompletionTurns = round(safeRatio(sessionTurnTotal, sessionTurnSamples), 2);
+  const timeToFirstValidEditMinutes = round(safeRatio(firstValidEditMinutesTotal, firstValidEditSamples), 2);
+  const editActions = [];
+  let testRunsAfterEdit = 0;
+  let failedTestRunsAfterEdit = 0;
+  for (const [sessionId, sessionEvents] of sessions.entries()) {
+    const sorted = [...sessionEvents].sort((a, b) => a.timestamp.getTime() - b.timestamp.getTime());
+    let seenEdit = false;
+    for (const e of sorted) {
+      const payload = parseToolPayload(e);
+      if (!payload?.toolName)
+        continue;
+      if (isEditToolName(payload.toolName) && payload.success === true) {
+        editActions.push({ sessionId, timestamp: e.timestamp.getTime(), filePath: payload.filePath });
+        seenEdit = true;
+        continue;
+      }
+      if (seenEdit && isTestLikeCommand(payload.command)) {
+        testRunsAfterEdit++;
+        if (payload.success === false)
+          failedTestRunsAfterEdit++;
+      }
+    }
+  }
+  const THIRTY_MIN_MS = 30 * 60 * 1e3;
+  let reworkCount = 0;
+  const bySessionFile = /* @__PURE__ */ new Map();
+  const sortedEdits = [...editActions].sort((a, b) => a.timestamp - b.timestamp);
+  for (const edit of sortedEdits) {
+    if (!edit.filePath)
+      continue;
+    const key = `${edit.sessionId}::${edit.filePath}`;
+    const prev = bySessionFile.get(key);
+    if (typeof prev === "number" && edit.timestamp - prev <= THIRTY_MIN_MS) {
+      reworkCount++;
+    }
+    bySessionFile.set(key, edit.timestamp);
+  }
+  const reworkRate = round(safeRatio(reworkCount, editActions.length));
+  const postChangeFailureRate = round(safeRatio(failedTestRunsAfterEdit, testRunsAfterEdit));
+  return {
+    memoryHitRate,
+    usefulRecallRate,
+    avgCompletionTurns,
+    timeToFirstValidEditMinutes,
+    reworkRate,
+    postChangeFailureRate
+  };
+}
 statsRouter.get("/shared", async (c) => {
   const memoryService = getServiceFromQuery(c);
   try {
@@ -8337,6 +8512,129 @@ statsRouter.get("/retrieval-traces", async (c) => {
     await memoryService.shutdown();
   }
 });
+statsRouter.get("/kpi", async (c) => {
+  const rawWindow = c.req.query("window") || "7d";
+  const window = rawWindow === "24h" || rawWindow === "30d" ? rawWindow : "7d";
+  const memoryService = getServiceFromQuery(c);
+  try {
+    await memoryService.initialize();
+    const now = Date.now();
+    const thresholds = loadKpiThresholds();
+    const allEvents = await memoryService.getRecentEvents(2e4);
+    const events = allEvents.filter((e) => inWindow(e, now, window));
+    const helpfulness = await memoryService.getHelpfulnessStats();
+    const usefulRecallRate = helpfulness.totalEvaluated > 0 ? round(safeRatio(helpfulness.helpful, helpfulness.totalEvaluated)) : 0;
+    const metrics = computeKpiMetrics(events, usefulRecallRate);
+    const windowMs = windowToMs(window);
+    const prevEvents = allEvents.filter((e) => {
+      const age = now - e.timestamp.getTime();
+      return age > windowMs && age <= windowMs * 2;
+    });
+    const previousMetrics = computeKpiMetrics(prevEvents, usefulRecallRate);
+    const deltas = {
+      memoryHitRate: round(metrics.memoryHitRate - previousMetrics.memoryHitRate),
+      usefulRecallRate: round(metrics.usefulRecallRate - previousMetrics.usefulRecallRate),
+      avgCompletionTurns: round(metrics.avgCompletionTurns - previousMetrics.avgCompletionTurns, 2),
+      timeToFirstValidEditMinutes: round(metrics.timeToFirstValidEditMinutes - previousMetrics.timeToFirstValidEditMinutes, 2),
+      reworkRate: round(metrics.reworkRate - previousMetrics.reworkRate),
+      postChangeFailureRate: round(metrics.postChangeFailureRate - previousMetrics.postChangeFailureRate)
+    };
+    const THIRTY_MIN_MS = 30 * 60 * 1e3;
+    const trendWindowMs = 30 * 24 * 60 * 60 * 1e3;
+    const trendEvents = allEvents.filter((e) => now - e.timestamp.getTime() <= trendWindowMs);
+    const buckets = /* @__PURE__ */ new Map();
+    for (const e of trendEvents) {
+      const day = e.timestamp.toISOString().split("T")[0];
+      const arr = buckets.get(day) || [];
+      arr.push(e);
+      buckets.set(day, arr);
+    }
+    const trendDaily = Array.from(buckets.entries()).sort((a, b) => a[0].localeCompare(b[0])).map(([date, dayEvents]) => {
+      const dayPrompts = dayEvents.filter((e) => e.eventType === "user_prompt");
+      const dayPromptCount = dayPrompts.length;
+      const dayMemoryHit = dayPrompts.filter((p) => p.metadata?.adherence?.checked).length;
+      const dayEdits = dayEvents.filter((e) => {
+        const p = parseToolPayload(e);
+        return Boolean(p?.toolName && isEditToolName(p.toolName) && p.success === true);
+      });
+      const dayEditActions = dayEdits.map((e) => {
+        const p = parseToolPayload(e);
+        return { sessionId: e.sessionId, timestamp: e.timestamp.getTime(), filePath: p?.filePath };
+      }).filter((x) => Boolean(x.filePath));
+      let dayReworkCount = 0;
+      const dayBySessionFile = /* @__PURE__ */ new Map();
+      for (const edit of dayEditActions) {
+        const key = `${edit.sessionId}::${edit.filePath}`;
+        const prev = dayBySessionFile.get(key);
+        if (typeof prev === "number" && edit.timestamp - prev <= THIRTY_MIN_MS)
+          dayReworkCount++;
+        dayBySessionFile.set(key, edit.timestamp);
+      }
+      const dayTests = dayEvents.filter((e) => {
+        const p = parseToolPayload(e);
+        return Boolean(p?.toolName && isTestLikeCommand(p.command));
+      });
+      const dayFailedTests = dayEvents.filter((e) => {
+        const p = parseToolPayload(e);
+        return Boolean(p?.toolName && isTestLikeCommand(p.command) && p.success === false);
+      });
+      const turnsBySession = /* @__PURE__ */ new Map();
+      for (const e of dayEvents) {
+        const arr = turnsBySession.get(e.sessionId) || [];
+        arr.push(e);
+        turnsBySession.set(e.sessionId, arr);
+      }
+      let dayTurnsTotal = 0;
+      let dayTurnsSamples = 0;
+      for (const sessionEvents of turnsBySession.values()) {
+        const turns = computeSessionTurnCount(sessionEvents);
+        if (turns > 0) {
+          dayTurnsTotal += turns;
+          dayTurnsSamples++;
+        }
+      }
+      return {
+        date,
+        memoryHitRate: round(safeRatio(dayMemoryHit, dayPromptCount)),
+        usefulRecallRate,
+        reworkRate: round(safeRatio(dayReworkCount, dayEditActions.length)),
+        postChangeFailureRate: round(safeRatio(dayFailedTests.length, dayTests.length)),
+        avgCompletionTurns: round(safeRatio(dayTurnsTotal, dayTurnsSamples), 2)
+      };
+    });
+    const alerts = [];
+    if (metrics.usefulRecallRate < thresholds.usefulRecallRateMin) {
+      alerts.push({ metric: "usefulRecallRate", level: "warn", message: "Useful recall rate is below threshold", value: metrics.usefulRecallRate, threshold: thresholds.usefulRecallRateMin });
+    }
+    if (metrics.reworkRate > thresholds.reworkRateMax) {
+      alerts.push({ metric: "reworkRate", level: "warn", message: "Rework rate is above threshold", value: metrics.reworkRate, threshold: thresholds.reworkRateMax });
+    }
+    if (metrics.postChangeFailureRate > thresholds.postChangeFailureRateMax) {
+      alerts.push({ metric: "postChangeFailureRate", level: "warn", message: "Post-change failure rate is above threshold", value: metrics.postChangeFailureRate, threshold: thresholds.postChangeFailureRateMax });
+    }
+    if (metrics.avgCompletionTurns > thresholds.avgCompletionTurnsMax) {
+      alerts.push({ metric: "avgCompletionTurns", level: "warn", message: "Average completion turns is above threshold", value: metrics.avgCompletionTurns, threshold: thresholds.avgCompletionTurnsMax });
+    }
+    if (metrics.memoryHitRate < thresholds.memoryHitRateMin) {
+      alerts.push({ metric: "memoryHitRate", level: "warn", message: "Memory hit rate is below threshold", value: metrics.memoryHitRate, threshold: thresholds.memoryHitRateMin });
+    }
+    return c.json({
+      window,
+      metrics,
+      previousMetrics,
+      deltas,
+      trend: {
+        daily: trendDaily
+      },
+      thresholds,
+      alerts
+    });
+  } catch (error) {
+    return c.json({ error: error.message }, 500);
+  } finally {
+    await memoryService.shutdown();
+  }
+});
 statsRouter.post("/graduation/run", async (c) => {
   const memoryService = getServiceFromQuery(c);
   try {
@@ -8584,19 +8882,19 @@ turnsRouter.post("/backfill", async (c) => {
 
 // src/server/api/projects.ts
 import { Hono as Hono7 } from "hono";
-import * as fs7 from "fs";
-import * as path7 from "path";
+import * as fs8 from "fs";
+import * as path8 from "path";
 import * as os4 from "os";
 var projectsRouter = new Hono7();
 projectsRouter.get("/", async (c) => {
   try {
-    const projectsDir = path7.join(os4.homedir(), ".claude-code", "memory", "projects");
-    if (!fs7.existsSync(projectsDir)) {
+    const projectsDir = path8.join(os4.homedir(), ".claude-code", "memory", "projects");
+    if (!fs8.existsSync(projectsDir)) {
       return c.json({ projects: [] });
     }
-    const projectHashes = fs7.readdirSync(projectsDir).filter((name) => {
-      const fullPath = path7.join(projectsDir, name);
-      return fs7.statSync(fullPath).isDirectory();
+    const projectHashes = fs8.readdirSync(projectsDir).filter((name) => {
+      const fullPath = path8.join(projectsDir, name);
+      return fs8.statSync(fullPath).isDirectory();
     });
     const registry = loadSessionRegistry();
     const hashToPath = /* @__PURE__ */ new Map();
@@ -8606,17 +8904,17 @@ projectsRouter.get("/", async (c) => {
       }
     }
     const projects = projectHashes.map((hash) => {
-      const dirPath = path7.join(projectsDir, hash);
-      const dbPath = path7.join(dirPath, "events.sqlite");
+      const dirPath = path8.join(projectsDir, hash);
+      const dbPath = path8.join(dirPath, "events.sqlite");
       let dbSize = 0;
-      if (fs7.existsSync(dbPath)) {
-        dbSize = fs7.statSync(dbPath).size;
+      if (fs8.existsSync(dbPath)) {
+        dbSize = fs8.statSync(dbPath).size;
       }
       const projectPath = hashToPath.get(hash) || `unknown (${hash})`;
       return {
         hash,
         projectPath,
-        projectName: path7.basename(projectPath),
+        projectName: path8.basename(projectPath),
         dbSize,
         dbSizeHuman: formatBytes(dbSize)
       };
@@ -8741,7 +9039,7 @@ function buildPrompt(statsContext, memoryContext, history, currentMessage) {
   return parts.join("\n");
 }
 function streamClaudeResponse(prompt, stream) {
-  return new Promise((resolve4, reject) => {
+  return new Promise((resolve5, reject) => {
     const proc = spawn("claude", [
       "-p",
       "--output-format",
@@ -8813,7 +9111,7 @@ function streamClaudeResponse(prompt, stream) {
       if (code !== 0 && code !== null) {
         reject(new Error(`Claude CLI exited with code ${code}`));
       } else {
-        resolve4();
+        resolve5();
       }
     });
   });
@@ -8870,14 +9168,14 @@ 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 = path8.join(__dirname, "../../dist/ui");
-if (fs8.existsSync(uiPath)) {
+var uiPath = path9.join(__dirname, "../../dist/ui");
+if (fs9.existsSync(uiPath)) {
   app.use("/*", serveStatic({ root: uiPath }));
 }
 app.get("*", (c) => {
-  const indexPath = path8.join(uiPath, "index.html");
-  if (fs8.existsSync(indexPath)) {
-    return c.html(fs8.readFileSync(indexPath, "utf-8"));
+  const indexPath = path9.join(uiPath, "index.html");
+  if (fs9.existsSync(indexPath)) {
+    return c.html(fs9.readFileSync(indexPath, "utf-8"));
   }
   return c.text('UI not built. Run "npm run build:ui" first.', 404);
 });
@@ -9189,28 +9487,28 @@ var MongoSyncWorker = class {
 };
 
 // src/cli/index.ts
-var CLAUDE_SETTINGS_PATH = path9.join(os6.homedir(), ".claude", "settings.json");
+var CLAUDE_SETTINGS_PATH = path10.join(os6.homedir(), ".claude", "settings.json");
 function getPluginPath() {
   const possiblePaths = [
-    path9.join(__dirname, ".."),
+    path10.join(__dirname, ".."),
     // When running from dist/cli
-    path9.join(__dirname, "../..", "dist"),
+    path10.join(__dirname, "../..", "dist"),
     // When running from src
-    path9.join(process.cwd(), "dist")
+    path10.join(process.cwd(), "dist")
     // Current working directory
   ];
   for (const p of possiblePaths) {
-    const hooksPath = path9.join(p, "hooks", "user-prompt-submit.js");
-    if (fs9.existsSync(hooksPath)) {
+    const hooksPath = path10.join(p, "hooks", "user-prompt-submit.js");
+    if (fs10.existsSync(hooksPath)) {
       return p;
     }
   }
-  return path9.join(os6.homedir(), ".npm-global", "lib", "node_modules", "claude-memory-layer", "dist");
+  return path10.join(os6.homedir(), ".npm-global", "lib", "node_modules", "claude-memory-layer", "dist");
 }
 function loadClaudeSettings() {
   try {
-    if (fs9.existsSync(CLAUDE_SETTINGS_PATH)) {
-      const content = fs9.readFileSync(CLAUDE_SETTINGS_PATH, "utf-8");
+    if (fs10.existsSync(CLAUDE_SETTINGS_PATH)) {
+      const content = fs10.readFileSync(CLAUDE_SETTINGS_PATH, "utf-8");
       return JSON.parse(content);
     }
   } catch (error) {
@@ -9219,13 +9517,13 @@ function loadClaudeSettings() {
   return {};
 }
 function saveClaudeSettings(settings) {
-  const dir = path9.dirname(CLAUDE_SETTINGS_PATH);
-  if (!fs9.existsSync(dir)) {
-    fs9.mkdirSync(dir, { recursive: true });
+  const dir = path10.dirname(CLAUDE_SETTINGS_PATH);
+  if (!fs10.existsSync(dir)) {
+    fs10.mkdirSync(dir, { recursive: true });
   }
   const tempPath = CLAUDE_SETTINGS_PATH + ".tmp";
-  fs9.writeFileSync(tempPath, JSON.stringify(settings, null, 2));
-  fs9.renameSync(tempPath, CLAUDE_SETTINGS_PATH);
+  fs10.writeFileSync(tempPath, JSON.stringify(settings, null, 2));
+  fs10.renameSync(tempPath, CLAUDE_SETTINGS_PATH);
 }
 var REQUIRED_HOOK_FILES = [
   "user-prompt-submit.js",
@@ -9247,7 +9545,7 @@ function getHooksConfig(pluginPath) {
       hooks: [
         {
           type: "command",
-          command: `node ${path9.join(pluginPath, "hooks", fileName)}`
+          command: `node ${path10.join(pluginPath, "hooks", fileName)}`
         }
       ]
     }
@@ -9261,12 +9559,12 @@ function getHooksConfig(pluginPath) {
   };
 }
 var program = new Command();
-program.name("claude-memory-layer").description("Claude Code Memory Plugin CLI").version("1.0.18");
+program.name("claude-memory-layer").description("Claude Code Memory Plugin CLI").version("1.0.19");
 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 missingHooks = REQUIRED_HOOK_FILES.filter(
-      (file) => !fs9.existsSync(path9.join(pluginPath, "hooks", file))
+      (file) => !fs10.existsSync(path10.join(pluginPath, "hooks", file))
     );
     if (missingHooks.length > 0) {
       console.error(`
@@ -9343,7 +9641,7 @@ program.command("status").description("Check plugin installation status").action
     console.log(`  PostToolUse: ${hasPostToolHook ? "\u2705 Installed" : "\u274C Not installed"}`);
     console.log(`  Stop: ${hasStopHook ? "\u2705 Installed" : "\u274C Not installed"}`);
     console.log(`  SessionEnd: ${hasSessionEndHook ? "\u2705 Installed" : "\u274C Not installed"}`);
-    const hooksExist = REQUIRED_HOOK_FILES.every((file) => fs9.existsSync(path9.join(pluginPath, "hooks", file)));
+    const hooksExist = REQUIRED_HOOK_FILES.every((file) => fs10.existsSync(path10.join(pluginPath, "hooks", file)));
     console.log(`
 Plugin files: ${hooksExist ? "\u2705 Found" : "\u274C Not found"}`);
     console.log(`  Path: ${pluginPath}`);
@@ -9475,7 +9773,7 @@ program.command("mongo-sync").description("Sync events with MongoDB for multi-se
   const projectPath = options.project || process.cwd();
   const mongoUri = options.mongoUri || process.env.CLAUDE_MEMORY_MONGO_URI;
   const mongoDb = options.mongoDb || process.env.CLAUDE_MEMORY_MONGO_DB;
-  const projectKey = options.mongoProject || process.env.CLAUDE_MEMORY_MONGO_PROJECT || path9.basename(projectPath);
+  const projectKey = options.mongoProject || process.env.CLAUDE_MEMORY_MONGO_PROJECT || path10.basename(projectPath);
   const direction = String(options.direction || "both").toLowerCase();
   if (!mongoUri || !mongoDb) {
     console.error("\n\u274C MongoDB sync is not configured.");
@@ -9487,14 +9785,14 @@ program.command("mongo-sync").description("Sync events with MongoDB for multi-se
     process.exit(1);
   }
   const storagePath = getProjectStoragePath(projectPath);
-  if (!fs9.existsSync(storagePath)) {
-    fs9.mkdirSync(storagePath, { recursive: true });
+  if (!fs10.existsSync(storagePath)) {
+    fs10.mkdirSync(storagePath, { recursive: true });
   }
   const batchSizeParsed = parseInt(options.batchSize, 10);
   const intervalParsed = parseInt(options.interval, 10);
   const batchSize = Number.isFinite(batchSizeParsed) && batchSizeParsed > 0 ? batchSizeParsed : 500;
   const intervalMs = Number.isFinite(intervalParsed) && intervalParsed > 0 ? intervalParsed : 3e4;
-  const sqliteStore = new SQLiteEventStore(path9.join(storagePath, "events.sqlite"));
+  const sqliteStore = new SQLiteEventStore(path10.join(storagePath, "events.sqlite"));
   const worker = new MongoSyncWorker(sqliteStore, {
     uri: mongoUri,
     dbName: mongoDb,
@@ -9553,7 +9851,7 @@ function renderProgress(event) {
       break;
     case "session-start": {
       const pct = Math.round(event.sessionIndex / event.totalSessions * 100);
-      const sessionName = path9.basename(event.filePath, ".jsonl").slice(0, 8);
+      const sessionName = path10.basename(event.filePath, ".jsonl").slice(0, 8);
       process.stdout.write(
         `\r  \u{1F4C4} [${event.sessionIndex + 1}/${event.totalSessions}] ${pct}% | Session ${sessionName}... `
       );
@@ -9628,9 +9926,9 @@ async function listMarkdownFiles(root) {
   const stack = [root];
   while (stack.length > 0) {
     const dir = stack.pop();
-    const entries = await fs9.promises.readdir(dir, { withFileTypes: true });
+    const entries = await fs10.promises.readdir(dir, { withFileTypes: true });
     for (const e of entries) {
-      const full = path9.join(dir, e.name);
+      const full = path10.join(dir, e.name);
       if (e.isDirectory())
         stack.push(full);
       else if (e.isFile() && e.name.endsWith(".md") && e.name !== "_index.md")
@@ -9640,8 +9938,8 @@ async function listMarkdownFiles(root) {
   return out.sort();
 }
 function deriveNamespaceCategory(sourceRoot, filePath) {
-  const rel = path9.relative(sourceRoot, filePath);
-  const dirSeg = path9.dirname(rel).split(path9.sep).filter(Boolean);
+  const rel = path10.relative(sourceRoot, filePath);
+  const dirSeg = path10.dirname(rel).split(path10.sep).filter(Boolean);
   if (dirSeg.length >= 2) {
     const namespace = sanitizeSegment3(dirSeg[0], "default");
     const categoryPath = dirSeg.slice(1).map((s) => sanitizeSegment3(s, "uncategorized"));
@@ -9660,10 +9958,10 @@ function extractImportEvidence(markdown) {
 program.command("organize-import [sourceDir]").description("Import existing markdown memory files, or bootstrap knowledge docs from codebase/git when markdown is missing").option("-p, --project <path>", "Project path (defaults to cwd)").option("--session <id>", "Session id for imported events (default: import:organized)").option("--limit <n>", "Limit number of files to import").option("--dry-run", "Preview mapping without writing").option("--bootstrap", "Force-generate structured markdown from codebase + git history before import").option("--bootstrap-if-empty", "Auto-bootstrap when source has no markdown files (default: true)", true).option("--no-bootstrap-if-empty", "Disable auto-bootstrap when source has no markdown files").option("--force-bootstrap", "Run bootstrap even when markdown files exist").option("--repo <path>", "Repository root for bootstrap analysis (default: project path)").option("--out <path>", "Output directory for generated bootstrap markdown (default: <sourceDir>/bootstrap-kb)").option("--since <range>", 'Git history range for bootstrap (default: "180 days ago")').option("--max-commits <n>", "Max commits to analyze for bootstrap (default: 1000)").option("--incremental", "Use previous bootstrap manifest as baseline for incremental updates (default: true)", true).option("--no-incremental", "Disable incremental bootstrap; regenerate full snapshot").action(async (sourceDir, options) => {
   const projectPath = options.project || process.cwd();
   const sessionId = options.session || "import:organized";
-  const sourceRoot = path9.resolve(sourceDir || options.out || projectPath);
-  const repoPath = path9.resolve(options.repo || projectPath);
-  if (!fs9.existsSync(sourceRoot)) {
-    fs9.mkdirSync(sourceRoot, { recursive: true });
+  const sourceRoot = path10.resolve(sourceDir || options.out || projectPath);
+  const repoPath = path10.resolve(options.repo || projectPath);
+  if (!fs10.existsSync(sourceRoot)) {
+    fs10.mkdirSync(sourceRoot, { recursive: true });
   }
   const service = getMemoryServiceForProject(projectPath);
   try {
@@ -9673,7 +9971,7 @@ program.command("organize-import [sourceDir]").description("Import existing mark
     const hasMarkdown = files.length > 0;
     const shouldBootstrap = Boolean(options.forceBootstrap || options.bootstrap || !hasMarkdown && options.bootstrapIfEmpty);
     if (shouldBootstrap) {
-      const outDir = path9.resolve(options.out || path9.join(sourceRoot, "bootstrap-kb"));
+      const outDir = path10.resolve(options.out || path10.join(sourceRoot, "bootstrap-kb"));
       const since = options.since || "180 days ago";
       const maxCommits = options.maxCommits ? Math.max(1, parseInt(options.maxCommits, 10)) : 1e3;
       console.log("\n\u{1F9E0} Bootstrapping markdown knowledge base...");
@@ -9712,13 +10010,13 @@ program.command("organize-import [sourceDir]").description("Import existing mark
     let imported = 0;
     let skipped = 0;
     for (const file of targets) {
-      const text = await fs9.promises.readFile(file, "utf8");
+      const text = await fs10.promises.readFile(file, "utf8");
       if (!text.trim()) {
         skipped += 1;
         continue;
       }
       const { namespace, categoryPath } = deriveNamespaceCategory(activeSourceRoot, file);
-      const rel = path9.relative(activeSourceRoot, file);
+      const rel = path10.relative(activeSourceRoot, file);
       const evidence = extractImportEvidence(text);
       if (options.dryRun) {
         console.log(`- ${rel} -> namespace=${namespace} category=${categoryPath.join("/")} confidence=${evidence.confidence || "n/a"} sources=${evidence.sources.length}`);