claude-memory-layer 1.0.23 → 1.0.24

package/dist/hooks/user-prompt-submit.js

@@ -8,9 +8,9 @@ const __dirname = dirname(__filename);
 
 // src/hooks/user-prompt-submit.ts
 import { randomUUID as randomUUID9 } from "crypto";
-import * as fs6 from "fs";
-import * as path5 from "path";
-import * as os3 from "os";
+import * as fs7 from "fs";
+import * as path6 from "path";
+import * as os4 from "os";
 
 // src/services/memory-service.ts
 import * as path3 from "path";
@@ -73,11 +73,11 @@ function toDate(value) {
     return new Date(value);
   return new Date(String(value));
 }
-function createDatabase(path6, options) {
+function createDatabase(path7, options) {
   if (options?.readOnly) {
-    return new duckdb.Database(path6, { access_mode: "READ_ONLY" });
+    return new duckdb.Database(path7, { access_mode: "READ_ONLY" });
   }
-  return new duckdb.Database(path6);
+  return new duckdb.Database(path7);
 }
 function dbRun(db, sql, params = []) {
   return new Promise((resolve2, reject) => {
@@ -761,12 +761,12 @@ import { randomUUID as randomUUID2 } from "crypto";
 import Database from "better-sqlite3";
 import * as fs from "fs";
 import * as nodePath from "path";
-function createSQLiteDatabase(path6, options) {
-  const dir = nodePath.dirname(path6);
+function createSQLiteDatabase(path7, options) {
+  const dir = nodePath.dirname(path7);
   if (!fs.existsSync(dir)) {
     fs.mkdirSync(dir, { recursive: true });
   }
-  const db = new Database(path6, {
+  const db = new Database(path7, {
     readonly: options?.readonly ?? false
   });
   if (!options?.readonly && (options?.walMode ?? true)) {
@@ -1840,6 +1840,21 @@ var SQLiteEventStore = class {
       [id, eventId, sessionId, score, query.slice(0, 100)]
     );
   }
+  /**
+   * Get session IDs that have unevaluated retrievals (measured_at IS NULL).
+   * Excludes the current session. Used to backfill sessions that ended without Stop hook.
+   */
+  async getUnevaluatedSessions(currentSessionId, limit = 5) {
+    await this.initialize();
+    const rows = sqliteAll(
+      this.db,
+      `SELECT DISTINCT session_id FROM memory_helpfulness
+       WHERE measured_at IS NULL AND session_id != ?
+       ORDER BY created_at DESC LIMIT ?`,
+      [currentSessionId, limit]
+    );
+    return rows.map((r) => r.session_id);
+  }
   /**
    * Evaluate helpfulness for all retrievals in a session
    * Called at session end - uses behavioral signals to compute score
@@ -2627,7 +2642,7 @@ var VectorStore = class {
 
 // src/core/embedder.ts
 import { pipeline } from "@huggingface/transformers";
-var Embedder = class {
+var Embedder = class _Embedder {
   pipeline = null;
   modelName;
   activeModelName;
@@ -2658,6 +2673,11 @@ var Embedder = class {
       this.initialized = true;
     }
   }
+  // ~4 chars per token; 512 tokens * 4 = 2048, use 2000 to be safe
+  static MAX_CHARS = 2e3;
+  truncate(text) {
+    return text.length > _Embedder.MAX_CHARS ? text.slice(0, _Embedder.MAX_CHARS) : text;
+  }
   /**
    * Generate embedding for a single text
    */
@@ -2666,10 +2686,11 @@ var Embedder = class {
     if (!this.pipeline) {
       throw new Error("Embedding pipeline not initialized");
     }
-    const output = await this.pipeline(text, {
+    const output = await this.pipeline(this.truncate(text), {
       pooling: "mean",
       normalize: true,
-      truncation: true
+      truncation: true,
+      max_length: 512
     });
     const vector = Array.from(output.data);
     return {
@@ -2691,10 +2712,11 @@ var Embedder = class {
     for (let i = 0; i < texts.length; i += batchSize) {
       const batch = texts.slice(i, i + batchSize);
       for (const text of batch) {
-        const output = await this.pipeline(text, {
+        const output = await this.pipeline(this.truncate(text), {
           pooling: "mean",
           normalize: true,
-          truncation: true
+          truncation: true,
+          max_length: 512
         });
         const vector = Array.from(output.data);
         results.push({
@@ -3504,8 +3526,8 @@ _Context:_ ${sessionContext}`;
   matchesMetadataScope(metadata, expected) {
     if (!metadata)
       return false;
-    return Object.entries(expected).every(([path6, value]) => {
-      const actual = path6.split(".").reduce((acc, key) => {
+    return Object.entries(expected).every(([path7, value]) => {
+      const actual = path7.split(".").reduce((acc, key) => {
         if (typeof acc !== "object" || acc === null)
           return void 0;
         return acc[key];
@@ -5964,6 +5986,7 @@ var MemoryService = class {
   projectPath = null;
   readOnly;
   lightweightMode;
+  embeddingOnly;
   mdMirror;
   storagePath;
   constructor(config) {
@@ -5971,6 +5994,7 @@ var MemoryService = class {
     this.storagePath = storagePath;
     this.readOnly = config.readOnly ?? false;
     this.lightweightMode = config.lightweightMode ?? false;
+    this.embeddingOnly = config.embeddingOnly ?? false;
     this.mdMirror = new MarkdownMirror2(process.cwd());
     if (!this.readOnly && !fs4.existsSync(storagePath)) {
       fs4.mkdirSync(storagePath, { recursive: true });
@@ -6044,19 +6068,21 @@ var MemoryService = class {
         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(
+      if (!this.embeddingOnly) {
+        this.retriever.setGraduationPipeline(this.graduation);
+        this.graduationWorker = createGraduationWorker(
           this.sqliteStore,
-          this.analyticsStore,
-          { intervalMs: 3e4, batchSize: 500 }
+          this.graduation
         );
-        this.syncWorker.start();
+        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") {
@@ -6780,6 +6806,19 @@ var MemoryService = class {
     await this.initialize();
     await this.sqliteStore.recordRetrieval(eventId, sessionId, score, query);
   }
+  /**
+   * Record a query-level retrieval trace (used by user-prompt-submit hook).
+   * Feeds the retrieval_traces table that powers dashboard stats.
+   */
+  async recordQueryTrace(input) {
+    await this.initialize();
+    await this.sqliteStore.recordRetrievalTrace({
+      ...input,
+      candidateDetails: [],
+      selectedDetails: [],
+      fallbackTrace: []
+    });
+  }
   /**
    * Evaluate helpfulness of retrievals in a session (called at session end)
    */
@@ -6787,6 +6826,20 @@ var MemoryService = class {
     await this.initialize();
     await this.sqliteStore.evaluateSessionHelpfulness(sessionId);
   }
+  /**
+   * Backfill helpfulness evaluation for sessions that ended without Stop hook.
+   * Call on first turn of a new session to catch missed evaluations.
+   */
+  async evaluatePendingSessions(currentSessionId) {
+    await this.initialize();
+    const sessions = await this.sqliteStore.getUnevaluatedSessions(currentSessionId, 5);
+    for (const sid of sessions) {
+      try {
+        await this.sqliteStore.evaluateSessionHelpfulness(sid);
+      } catch {
+      }
+    }
+  }
   /**
    * Get most helpful memories ranked by helpfulness score
    */
@@ -7073,42 +7126,6 @@ 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",
-      analyticsEnabled: false,
-      // Hooks don't need DuckDB
-      sharedStoreConfig: { enabled: false }
-      // Shared store uses DuckDB too
-    }));
-  }
-  return serviceCache.get(GLOBAL_KEY);
-}
-function getMemoryServiceForProject(projectPath, sharedStoreConfig) {
-  const hash = hashProjectPath(projectPath);
-  if (!serviceCache.has(hash)) {
-    const storagePath = getProjectStoragePath(projectPath);
-    serviceCache.set(hash, new MemoryService({
-      storagePath,
-      projectHash: hash,
-      projectPath,
-      // Override shared store config - hooks don't need DuckDB
-      sharedStoreConfig: sharedStoreConfig ?? { enabled: false },
-      analyticsEnabled: false
-      // Hooks don't need DuckDB
-    }));
-  }
-  return serviceCache.get(hash);
-}
-function getMemoryServiceForSession(sessionId) {
-  const projectInfo = getSessionProject(sessionId);
-  if (projectInfo) {
-    return getMemoryServiceForProject(projectInfo.projectPath);
-  }
-  return getDefaultMemoryService();
-}
 function getLightweightMemoryService(sessionId) {
   const projectInfo = getSessionProject(sessionId);
   const key = projectInfo ? `lightweight_${projectInfo.projectHash}` : "lightweight_global";
@@ -7155,6 +7172,176 @@ function writeTurnState(sessionId, turnId) {
     }
   }
 }
+function getLastResponsePath(sessionId) {
+  return path4.join(TURN_STATE_DIR, `.last-response-${sessionId}.json`);
+}
+function readLastAssistantSnippet(sessionId) {
+  try {
+    const filePath = getLastResponsePath(sessionId);
+    if (!fs5.existsSync(filePath))
+      return null;
+    const state = JSON.parse(fs5.readFileSync(filePath, "utf-8"));
+    if (state.sessionId !== sessionId)
+      return null;
+    if (Date.now() - new Date(state.createdAt).getTime() > 2 * 60 * 60 * 1e3)
+      return null;
+    return state.snippet || null;
+  } catch {
+    return null;
+  }
+}
+
+// src/hooks/semantic-daemon-client.ts
+import { spawn } from "child_process";
+import * as fs6 from "fs";
+import * as net from "net";
+import * as os3 from "os";
+import * as path5 from "path";
+var DEFAULT_SOCKET_PATH = path5.join(
+  os3.homedir(),
+  ".claude-code",
+  "memory",
+  "semantic-daemon.sock"
+);
+var DAEMON_SOCKET_PATH = process.env.CLAUDE_MEMORY_SEMANTIC_SOCKET || DEFAULT_SOCKET_PATH;
+var DAEMON_START_TIMEOUT_MS = parseInt(process.env.CLAUDE_MEMORY_SEMANTIC_DAEMON_START_MS || "1500");
+var daemonStartPromise = null;
+async function retrieveSemanticMemories(request, timeoutMs) {
+  const payload = {
+    type: "retrieve",
+    sessionId: request.sessionId,
+    prompt: request.prompt,
+    topK: request.topK,
+    minScore: request.minScore
+  };
+  try {
+    return await requestFromDaemon(payload, timeoutMs);
+  } catch (error) {
+    if (!isConnectionError(error)) {
+      throw error;
+    }
+    await ensureDaemonRunning();
+    return requestFromDaemon(payload, timeoutMs).catch((retryError) => {
+      if (process.env.CLAUDE_MEMORY_DEBUG) {
+        console.error("[semantic-client] retry failed after daemon start:", retryError);
+      }
+      throw retryError;
+    });
+  }
+}
+function requestFromDaemon(payload, timeoutMs) {
+  return new Promise((resolve2, reject) => {
+    const client = net.createConnection(DAEMON_SOCKET_PATH);
+    client.setEncoding("utf8");
+    let settled = false;
+    let responseRaw = "";
+    const timer = setTimeout(() => {
+      const timeoutError = new Error(`semantic daemon timeout (${timeoutMs}ms)`);
+      timeoutError.code = "ETIMEDOUT";
+      settle(timeoutError);
+      client.destroy();
+    }, timeoutMs);
+    const settle = (error, memories) => {
+      if (settled)
+        return;
+      settled = true;
+      clearTimeout(timer);
+      if (error) {
+        reject(error);
+      } else {
+        resolve2(memories || []);
+      }
+    };
+    client.on("connect", () => {
+      client.end(JSON.stringify(payload));
+    });
+    client.on("data", (chunk) => {
+      responseRaw += chunk;
+      if (responseRaw.length > 4 * 1024 * 1024) {
+        settle(new Error("semantic daemon response too large"));
+        client.destroy();
+      }
+    });
+    client.on("end", () => {
+      try {
+        const parsed = JSON.parse(responseRaw || "{}");
+        if (!parsed.ok) {
+          settle(new Error(parsed.error || "semantic daemon error"));
+          return;
+        }
+        settle(void 0, parsed.memories || []);
+      } catch (error) {
+        settle(error);
+      }
+    });
+    client.on("error", (error) => {
+      settle(error);
+    });
+  });
+}
+async function ensureDaemonRunning() {
+  if (daemonStartPromise) {
+    return daemonStartPromise;
+  }
+  daemonStartPromise = (async () => {
+    if (await canConnect()) {
+      return;
+    }
+    const daemonScriptPath = getDaemonScriptPath();
+    if (!fs6.existsSync(daemonScriptPath)) {
+      throw new Error(`semantic daemon script not found: ${daemonScriptPath}`);
+    }
+    const daemonDir = path5.dirname(DAEMON_SOCKET_PATH);
+    if (!fs6.existsSync(daemonDir)) {
+      fs6.mkdirSync(daemonDir, { recursive: true });
+    }
+    const child = spawn(process.execPath, [daemonScriptPath], {
+      detached: true,
+      stdio: "ignore",
+      env: process.env
+    });
+    child.unref();
+    const startDeadline = Date.now() + DAEMON_START_TIMEOUT_MS;
+    while (Date.now() < startDeadline) {
+      if (await canConnect()) {
+        return;
+      }
+      await sleep(60);
+    }
+    throw new Error(`semantic daemon start timeout (${DAEMON_START_TIMEOUT_MS}ms)`);
+  })();
+  try {
+    await daemonStartPromise;
+  } finally {
+    daemonStartPromise = null;
+  }
+}
+function getDaemonScriptPath() {
+  return path5.join(path5.dirname(new URL(import.meta.url).pathname), "semantic-daemon.js");
+}
+function canConnect() {
+  return new Promise((resolve2) => {
+    let settled = false;
+    const client = net.createConnection(DAEMON_SOCKET_PATH);
+    const finalize = (ok) => {
+      if (settled)
+        return;
+      settled = true;
+      client.destroy();
+      resolve2(ok);
+    };
+    client.on("connect", () => finalize(true));
+    client.on("error", () => finalize(false));
+    setTimeout(() => finalize(false), 120).unref();
+  });
+}
+function isConnectionError(error) {
+  const code = error?.code;
+  return code === "ENOENT" || code === "ECONNREFUSED" || code === "EPIPE" || code === "ECONNRESET";
+}
+function sleep(ms) {
+  return new Promise((resolve2) => setTimeout(resolve2, ms));
+}
 
 // src/hooks/user-prompt-submit.ts
 var MAX_MEMORIES = parseInt(process.env.CLAUDE_MEMORY_MAX_COUNT || "5");
@@ -7162,9 +7349,9 @@ var BASE_MIN_SCORE = parseFloat(process.env.CLAUDE_MEMORY_MIN_SCORE || "0.4");
 var FALLBACK_MIN_SCORE = parseFloat(process.env.CLAUDE_MEMORY_FALLBACK_MIN_SCORE || "0.3");
 var ENABLE_SEARCH = process.env.CLAUDE_MEMORY_SEARCH !== "false";
 var RETRIEVAL_MODE = process.env.CLAUDE_MEMORY_RETRIEVAL_MODE || "hybrid";
-var SEMANTIC_TIMEOUT_MS = parseInt(process.env.CLAUDE_MEMORY_SEMANTIC_TIMEOUT_MS || "1200");
+var SEMANTIC_TIMEOUT_MS = parseInt(process.env.CLAUDE_MEMORY_SEMANTIC_TIMEOUT_MS || "2000");
 var ADHERENCE_INTERVAL_TURNS = parseInt(process.env.CLAUDE_MEMORY_ADHERENCE_INTERVAL_TURNS || "3");
-var ADHERENCE_STATE_DIR = path5.join(os3.homedir(), ".claude-code", "memory");
+var ADHERENCE_STATE_DIR = path6.join(os4.homedir(), ".claude-code", "memory");
 function shouldStorePrompt(prompt) {
   const trimmed = prompt.trim();
   if (trimmed.startsWith("/"))
@@ -7183,18 +7370,6 @@ function getDynamicMinScore(prompt) {
     return Math.max(0.3, BASE_MIN_SCORE - 0.05);
   return BASE_MIN_SCORE;
 }
-function withTimeout(promise, timeoutMs) {
-  return new Promise((resolve2, reject) => {
-    const timer = setTimeout(() => reject(new Error(`semantic retrieval timeout (${timeoutMs}ms)`)), timeoutMs);
-    promise.then((result) => {
-      clearTimeout(timer);
-      resolve2(result);
-    }).catch((error) => {
-      clearTimeout(timer);
-      reject(error);
-    });
-  });
-}
 function formatMemoryContext(items) {
   if (items.length === 0)
     return "";
@@ -7207,12 +7382,12 @@ function formatMemoryContext(items) {
 ${lines.join("\n\n")}`;
 }
 function getAdherenceStatePath(sessionId) {
-  return path5.join(ADHERENCE_STATE_DIR, `.adherence-state-${sessionId}.json`);
+  return path6.join(ADHERENCE_STATE_DIR, `.adherence-state-${sessionId}.json`);
 }
 function readAdherenceState(sessionId) {
   try {
     const filePath = getAdherenceStatePath(sessionId);
-    if (!fs6.existsSync(filePath)) {
+    if (!fs7.existsSync(filePath)) {
       return {
         sessionId,
         turnCount: 0,
@@ -7222,7 +7397,7 @@ function readAdherenceState(sessionId) {
         updatedAt: (/* @__PURE__ */ new Date()).toISOString()
       };
     }
-    const data = fs6.readFileSync(filePath, "utf8");
+    const data = fs7.readFileSync(filePath, "utf8");
     const parsed = JSON.parse(data);
     if (parsed.sessionId !== sessionId)
       throw new Error("session mismatch");
@@ -7240,13 +7415,13 @@ function readAdherenceState(sessionId) {
 }
 function writeAdherenceState(state) {
   try {
-    if (!fs6.existsSync(ADHERENCE_STATE_DIR)) {
-      fs6.mkdirSync(ADHERENCE_STATE_DIR, { recursive: true });
+    if (!fs7.existsSync(ADHERENCE_STATE_DIR)) {
+      fs7.mkdirSync(ADHERENCE_STATE_DIR, { recursive: true });
     }
     const filePath = getAdherenceStatePath(state.sessionId);
     const tempPath = filePath + ".tmp";
-    fs6.writeFileSync(tempPath, JSON.stringify(state));
-    fs6.renameSync(tempPath, filePath);
+    fs7.writeFileSync(tempPath, JSON.stringify(state));
+    fs7.renameSync(tempPath, filePath);
   } catch {
   }
 }
@@ -7302,6 +7477,10 @@ async function main() {
     const currentTurn = adherenceState.turnCount + 1;
     const adherenceDecision = shouldRunAdherenceCheck(currentTurn, input.prompt, adherenceState);
     logAdherenceDecision(input.session_id, currentTurn, adherenceDecision.run, adherenceDecision.reason);
+    if (currentTurn === 1) {
+      memoryService.evaluatePendingSessions(input.session_id).catch(() => {
+      });
+    }
     if (shouldStorePrompt(input.prompt)) {
       await memoryService.storeUserPrompt(
         input.session_id,
@@ -7316,41 +7495,37 @@ async function main() {
         }
       );
     }
-    if (ENABLE_SEARCH && input.prompt.length > 10 && adherenceDecision.run) {
+    const isSlashCommand = input.prompt.trimStart().startsWith("/");
+    if (ENABLE_SEARCH && !isSlashCommand && input.prompt.length > 10 && adherenceDecision.run) {
       const minScore = getDynamicMinScore(input.prompt);
       let mergedMemories = [];
+      const lastSnippet = currentTurn > 1 ? readLastAssistantSnippet(input.session_id) : null;
+      const retrievalQuery = lastSnippet ? `${lastSnippet}
+
+${input.prompt}` : input.prompt;
       const canUseSemantic = RETRIEVAL_MODE === "semantic" || RETRIEVAL_MODE === "hybrid";
       if (canUseSemantic) {
         try {
-          const semanticService = getMemoryServiceForSession(input.session_id);
-          const semantic = await withTimeout(
-            semanticService.retrieveMemories(input.prompt, {
-              topK: MAX_MEMORIES,
-              minScore,
+          mergedMemories = await retrieveSemanticMemories(
+            {
               sessionId: input.session_id,
-              intentRewrite: true,
-              adaptiveRerank: true,
-              projectScopeMode: "strict"
-            }),
+              prompt: retrievalQuery,
+              topK: MAX_MEMORIES,
+              minScore
+            },
             SEMANTIC_TIMEOUT_MS
           );
-          mergedMemories = semantic.memories.map((m) => ({
-            type: m.event.eventType,
-            content: m.event.content,
-            id: m.event.id,
-            score: m.score
-          }));
         } catch {
         }
       }
       const shouldUseKeywordFallback = RETRIEVAL_MODE === "keyword" || RETRIEVAL_MODE === "hybrid" || mergedMemories.length === 0;
       if (shouldUseKeywordFallback && mergedMemories.length < MAX_MEMORIES) {
-        let results = await memoryService.keywordSearch(input.prompt, {
+        let results = await memoryService.keywordSearch(retrievalQuery, {
           topK: MAX_MEMORIES,
           minScore
         });
         if (results.length === 0 && FALLBACK_MIN_SCORE < minScore) {
-          results = await memoryService.keywordSearch(input.prompt, {
+          results = await memoryService.keywordSearch(retrievalQuery, {
             topK: MAX_MEMORIES,
             minScore: FALLBACK_MIN_SCORE
           });
@@ -7389,6 +7564,18 @@ async function main() {
         }
         context = formatMemoryContext(mergedMemories);
       }
+      const allCandidateIds = mergedMemories.map((m) => m.id).filter((v) => Boolean(v));
+      try {
+        await memoryService.recordQueryTrace({
+          sessionId: input.session_id,
+          queryText: retrievalQuery,
+          strategy: RETRIEVAL_MODE,
+          candidateEventIds: allCandidateIds,
+          selectedEventIds: allCandidateIds,
+          confidence: mergedMemories.length > 0 ? "medium" : "none"
+        });
+      } catch {
+      }
     }
     writeAdherenceState({
       sessionId: input.session_id,