claude-memory-layer 1.0.24 → 1.0.26

package/src/core/db-wrapper.ts

@@ -1,34 +1,14 @@
 /**
- * DuckDB Promise Wrapper
- * Wraps the callback-based DuckDB API with Promise-based async/await interface
+ * SQLite Database Wrapper
+ * Provides Promise-based interface over better-sqlite3 synchronous API
  */
 
-import duckdb from 'duckdb';
+import BetterSqlite3 from 'better-sqlite3';
 
-export type Database = duckdb.Database;
-
-/**
- * Converts BigInt values to Number in an object
- * DuckDB returns BigInt for COUNT(*) and other aggregate functions
- */
-function convertBigInts<T>(obj: T): T {
-  if (obj === null || obj === undefined) return obj;
-  if (typeof obj === 'bigint') return Number(obj) as unknown as T;
-  if (obj instanceof Date) return obj; // Preserve Date objects
-  if (Array.isArray(obj)) return obj.map(convertBigInts) as unknown as T;
-  if (typeof obj === 'object') {
-    const result: Record<string, unknown> = {};
-    for (const [key, value] of Object.entries(obj as Record<string, unknown>)) {
-      result[key] = convertBigInts(value);
-    }
-    return result as T;
-  }
-  return obj;
-}
+export type Database = BetterSqlite3.Database;
 
 /**
  * Safely converts a value to a Date object
- * Handles both Date objects and string timestamps from DuckDB
  */
 export function toDate(value: unknown): Date {
   if (value instanceof Date) return value;
@@ -42,78 +22,43 @@ export interface DatabaseOptions {
 }
 
 /**
- * Creates a new DuckDB database with Promise-based API
+ * Creates a new SQLite database connection
  */
-export function createDatabase(path: string, options?: DatabaseOptions): Database {
-  if (options?.readOnly) {
-    return new duckdb.Database(path, { access_mode: 'READ_ONLY' });
-  }
-  return new duckdb.Database(path);
+export function createDatabase(dbPath: string, options?: DatabaseOptions): Database {
+  return new BetterSqlite3(dbPath, { readonly: options?.readOnly });
 }
 
 /**
- * Promisified db.run() - executes a statement that doesn't return rows
+ * Executes a statement that doesn't return rows
  */
 export function dbRun(db: Database, sql: string, params: unknown[] = []): Promise<void> {
-  return new Promise((resolve, reject) => {
-    if (params.length === 0) {
-      db.run(sql, (err: Error | null) => {
-        if (err) reject(err);
-        else resolve();
-      });
-    } else {
-      db.run(sql, ...params, (err: Error | null) => {
-        if (err) reject(err);
-        else resolve();
-      });
-    }
-  });
+  db.prepare(sql).run(...(params as never[]));
+  return Promise.resolve();
 }
 
 /**
- * Promisified db.all() - executes a query and returns all rows
- * Automatically converts BigInt values to Number
+ * Executes a query and returns all rows
  */
 export function dbAll<T = Record<string, unknown>>(
   db: Database,
   sql: string,
   params: unknown[] = []
 ): Promise<T[]> {
-  return new Promise((resolve, reject) => {
-    if (params.length === 0) {
-      db.all(sql, (err: Error | null, rows: T[]) => {
-        if (err) reject(err);
-        else resolve(convertBigInts(rows || []));
-      });
-    } else {
-      db.all(sql, ...params, (err: Error | null, rows: T[]) => {
-        if (err) reject(err);
-        else resolve(convertBigInts(rows || []));
-      });
-    }
-  });
+  return Promise.resolve(db.prepare(sql).all(...(params as never[])) as T[]);
 }
 
 /**
- * Promisified db.close() - closes the database connection
+ * Closes the database connection
  */
 export function dbClose(db: Database): Promise<void> {
-  return new Promise((resolve, reject) => {
-    db.close((err: Error | null) => {
-      if (err) reject(err);
-      else resolve();
-    });
-  });
+  db.close();
+  return Promise.resolve();
 }
 
 /**
- * Promisified db.exec() - executes multiple statements
+ * Executes multiple statements
  */
 export function dbExec(db: Database, sql: string): Promise<void> {
-  return new Promise((resolve, reject) => {
-    db.exec(sql, (err: Error | null) => {
-      if (err) reject(err);
-      else resolve();
-    });
-  });
+  db.exec(sql);
+  return Promise.resolve();
 }

package/src/core/sqlite-event-store.ts

@@ -531,6 +531,30 @@ export class SQLiteEventStore {
     }
   }
 
+  /**
+   * Get session IDs that have events but no session_summary event.
+   * Used to backfill summaries for sessions that ended without Stop hook.
+   */
+  async getSessionsWithoutSummary(currentSessionId: string, limit = 5): Promise<string[]> {
+    await this.initialize();
+    const rows = sqliteAll<{ session_id: string }>(
+      this.db,
+      `SELECT DISTINCT e.session_id
+       FROM events e
+       WHERE e.session_id != ?
+         AND e.event_type != 'session_summary'
+         AND e.session_id NOT IN (
+           SELECT DISTINCT session_id FROM events WHERE event_type = 'session_summary'
+         )
+       GROUP BY e.session_id
+       HAVING COUNT(*) >= 3
+       ORDER BY MAX(e.timestamp) DESC
+       LIMIT ?`,
+      [currentSessionId, limit]
+    );
+    return rows.map((r) => r.session_id);
+  }
+
   /**
    * Get events by session ID
    */
@@ -1228,12 +1252,16 @@ export class SQLiteEventStore {
       }
 
       // Calculate helpfulness score
+      // Weights tuned for shopping-assistant-like corpora where sessions
+      // continue on the same topic (was_reasked was over-penalising normal conversation flow)
       const retrievalScore = retrieval.retrieval_score as number || 0;
+      // More prompts after retrieval = memory was actually useful to the conversation
+      const promptNorm = Math.min(promptCountAfter / 2, 1.0);
       const helpfulnessScore = (
-        0.30 * Math.min(retrievalScore, 1.0) +
-        0.25 * (sessionContinued ? 1.0 : 0.0) +
-        0.25 * toolSuccessRatio +
-        0.20 * (wasReasked ? 0.0 : 1.0)
+        0.40 * Math.min(retrievalScore, 1.0) +
+        0.30 * promptNorm +
+        0.20 * toolSuccessRatio +
+        0.10 * (sessionContinued ? 1.0 : 0.0)
       );
 
       sqliteRun(

package/src/hooks/post-tool-use.ts

@@ -40,9 +40,33 @@ const ALWAYS_STORE_TOOLS = new Set([
   'Write', 'Edit', 'MultiEdit', 'Agent', 'Task', 'ExitPlanMode'
 ]);
 
+// Keywords that indicate a Bash output is worth storing
+const IMPORTANT_BASH_KEYWORDS = [
+  'error', 'failed', 'exception', 'traceback', 'panic',
+  'warning', 'deprecated',
+  'test passed', 'test failed', 'tests passed', 'tests failed',
+  'coverage', 'assert',
+  'published', 'deployed', 'built successfully', 'build complete',
+  'successfully installed', 'successfully created',
+];
+
+/**
+ * For Bash commands, only store output that is significant:
+ * - Has stderr content
+ * - Contains important keywords (errors, test results, deploy events)
+ * - Output is very long (> 2000 chars), indicating meaningful work
+ */
+function isBashSignificant(output: string, response: PostToolUseInput['tool_response']): boolean {
+  if (response?.stderr && response.stderr.trim().length > 20) return true;
+  const lower = output.toLowerCase();
+  if (IMPORTANT_BASH_KEYWORDS.some((kw) => lower.includes(kw))) return true;
+  return output.trim().length > 2000;
+}
+
 /**
  * Determine if a tool output is significant enough to store.
  * Always-store tools bypass the length check.
+ * Bash uses keyword-based significance detection.
  * Other tools require non-empty stderr or output length >= minLen.
  */
 function hasSignificantOutput(
@@ -52,6 +76,7 @@ function hasSignificantOutput(
   minLen: number
 ): boolean {
   if (ALWAYS_STORE_TOOLS.has(toolName)) return true;
+  if (toolName === 'Bash') return isBashSignificant(output, response);
   if (response?.stderr && response.stderr.trim().length > 0) return true;
   return output.trim().length >= minLen;
 }

package/src/hooks/session-start.ts

@@ -32,6 +32,10 @@ async function main(): Promise<void> {
     // Start session in memory service
     await memoryService.startSession(input.session_id, input.cwd);
 
+    // Backfill session summaries for recent sessions that ended without Stop hook
+    // (crash, force-close, etc.). Run in background - non-blocking.
+    memoryService.backfillMissingSummaries(input.session_id, 5).catch(() => {});
+
     // Get recent context for this project (now automatically scoped)
     const recentEvents = await memoryService.getRecentEvents(10);
 

package/src/hooks/stop.ts

@@ -136,6 +136,20 @@ async function main(): Promise<void> {
     // Clean up turn state file after processing
     clearTurnState(input.session_id);
 
+    // Evaluate helpfulness of retrieved memories for this session
+    try {
+      await memoryService.evaluateSessionHelpfulness(input.session_id);
+    } catch {
+      // non-critical
+    }
+
+    // Generate session summary from recent events (rule-based, no LLM needed)
+    try {
+      await memoryService.generateSessionSummary(input.session_id);
+    } catch {
+      // non-critical
+    }
+
     // Embeddings enqueued in SQLite - will be processed by vector worker when server runs
     await memoryService.processPendingEmbeddings();
 

package/src/server/api/utils.ts

@@ -19,7 +19,7 @@ import { MemoryService } from '../../services/memory-service.js';
  * VectorWorker lifecycle issues with per-request services.
  */
 export function getServiceFromQuery(c: Context): MemoryService {
-  const project = c.req.query('project');
+  const project = c.req.query('project') || c.req.query('projectId');
   if (project) {
     // Check if it's a hash (8 hex chars) or a path
     const isHash = /^[a-f0-9]{8}$/.test(project);

package/src/services/memory-service.ts

@@ -10,7 +10,6 @@ import * as crypto from 'crypto';
 
 import { EventStore } from '../core/event-store.js';
 import { SQLiteEventStore } from '../core/sqlite-event-store.js';
-import { SyncWorker } from '../core/sync-worker.js';
 import { VectorStore } from '../core/vector-store.js';
 import { Embedder, getDefaultEmbedder } from '../core/embedder.js';
 import { VectorWorker, createVectorWorker } from '../core/vector-worker.js';
@@ -182,9 +181,6 @@ export function getSessionProject(sessionId: string): SessionRegistryEntry | nul
 export class MemoryService {
   // Primary store: SQLite (WAL mode) - for hooks, always available
   private readonly sqliteStore: SQLiteEventStore;
-  // Analytics store: DuckDB - for server reads (optional, synced from SQLite)
-  private readonly analyticsStore: EventStore | null;
-  private syncWorker: SyncWorker | null = null;
 
   private readonly vectorStore: VectorStore;
   private readonly embedder: Embedder;
@@ -247,32 +243,6 @@ export class MemoryService {
       }
     );
 
-    // Initialize ANALYTICS store: DuckDB (optional, for server reads)
-    // Hooks set analyticsEnabled=false to avoid DuckDB lock conflicts
-    const analyticsEnabled = config.analyticsEnabled ?? this.readOnly; // Default: enabled only for read-only (server)
-
-    if (!analyticsEnabled) {
-      // Hook mode: skip DuckDB entirely to avoid lock conflicts
-      this.analyticsStore = null;
-    } else if (this.readOnly) {
-      // Server mode: try to use DuckDB for analytics, will fallback to SQLite
-      try {
-        this.analyticsStore = new EventStore(
-          path.join(storagePath, 'analytics.duckdb'),
-          { readOnly: true }
-        );
-      } catch {
-        // DuckDB not available, will use SQLite for reads
-        this.analyticsStore = null;
-      }
-    } else {
-      // Writer mode with analytics: create DuckDB for sync target
-      this.analyticsStore = new EventStore(
-        path.join(storagePath, 'analytics.duckdb'),
-        { readOnly: false }
-      );
-    }
-
     this.vectorStore = new VectorStore(path.join(storagePath, 'vectors'));
     const embeddingModel = config.embeddingModel || process.env.CLAUDE_MEMORY_EMBEDDING_MODEL;
     this.embedder = embeddingModel
@@ -306,16 +276,6 @@ export class MemoryService {
       return;
     }
 
-    // Initialize analytics store if available (DuckDB)
-    if (this.analyticsStore) {
-      try {
-        await this.analyticsStore.initialize();
-      } catch (error) {
-        console.warn('[MemoryService] Analytics store (DuckDB) initialization failed, using SQLite for reads:', error);
-        // Continue without analytics - SQLite will be used for reads
-      }
-    }
-
     await this.vectorStore.initialize();
     await this.embedder.initialize();
 
@@ -340,15 +300,6 @@ export class MemoryService {
         );
         this.graduationWorker.start();
 
-        // Start sync worker (SQLite -> DuckDB) if analytics store is available
-        if (this.analyticsStore) {
-          this.syncWorker = new SyncWorker(
-            this.sqliteStore,
-            this.analyticsStore,
-            { intervalMs: 30000, batchSize: 500 }
-          );
-          this.syncWorker.start();
-        }
       }
 
       // Load endless mode setting
@@ -602,6 +553,67 @@ export class MemoryService {
     );
   }
 
+  /**
+   * Backfill session summaries for recent sessions that are missing them.
+   * Called from session-start hook to catch sessions that ended without Stop hook.
+   */
+  async backfillMissingSummaries(currentSessionId: string, limit = 5): Promise<void> {
+    await this.initialize();
+
+    // Get recent sessions that don't have a summary event
+    const recentSessionIds = await this.sqliteStore.getSessionsWithoutSummary(currentSessionId, limit);
+    for (const sid of recentSessionIds) {
+      try {
+        await this.generateSessionSummary(sid);
+      } catch {
+        // non-critical
+      }
+    }
+  }
+
+  /**
+   * Generate a rule-based session summary from stored events.
+   * Called at session end (Stop hook) when no LLM-generated summary exists.
+   * Skips if a summary already exists for this session.
+   */
+  async generateSessionSummary(sessionId: string): Promise<void> {
+    await this.initialize();
+
+    const events = await this.sqliteStore.getSessionEvents(sessionId);
+    if (events.length < 3) return; // Too short to summarize
+
+    // Skip if summary already exists
+    const hasSummary = events.some((e) => e.eventType === 'session_summary');
+    if (hasSummary) return;
+
+    const prompts = events.filter((e) => e.eventType === 'user_prompt');
+    const toolObs = events.filter((e) => e.eventType === 'tool_observation');
+    const toolNames = [...new Set(
+      toolObs.map((e) => (e.metadata as Record<string, unknown>)?.toolName as string).filter(Boolean)
+    )];
+    const errorObs = toolObs.filter((e) => {
+      const meta = e.metadata as Record<string, unknown>;
+      return meta?.exitCode !== undefined && meta.exitCode !== 0;
+    });
+
+    const datePart = events[0].timestamp.toISOString().split('T')[0];
+    const parts: string[] = [`[${datePart}] ${prompts.length}턴 세션.`];
+
+    if (prompts.length > 0) {
+      const firstPrompt = prompts[0].content.slice(0, 120).replace(/\n/g, ' ');
+      parts.push(`주요 작업: ${firstPrompt}`);
+    }
+    if (toolNames.length > 0) {
+      parts.push(`사용 툴: ${toolNames.slice(0, 6).join(', ')}`);
+    }
+    if (errorObs.length > 0) {
+      parts.push(`오류 ${errorObs.length}건 발생`);
+    }
+
+    const summary = parts.join('. ');
+    await this.storeSessionSummary(sessionId, summary, { generated: 'rule-based', eventCount: events.length });
+  }
+
   /**
    * Store a tool observation
    */
@@ -1275,6 +1287,7 @@ export class MemoryService {
     await this.initialize();
     await this.sqliteStore.recordRetrievalTrace({
       ...input,
+      projectHash: this.projectHash || undefined,
       candidateDetails: [],
       selectedDetails: [],
       fallbackTrace: [],
@@ -1652,11 +1665,6 @@ export class MemoryService {
       this.vectorWorker.stop();
     }
 
-    // Stop sync worker
-    if (this.syncWorker) {
-      this.syncWorker.stop();
-    }
-
     // Close shared store
     if (this.sharedEventStore) {
       await this.sharedEventStore.close();
@@ -1665,10 +1673,6 @@ export class MemoryService {
     // Close primary store (SQLite)
     await this.sqliteStore.close();
 
-    // Close analytics store (DuckDB)
-    if (this.analyticsStore) {
-      await this.analyticsStore.close();
-    }
   }
 
   /**