claude-memory-layer 1.0.15 → 1.0.17

package/src/cli/index.ts

@@ -32,6 +32,7 @@ interface ClaudeSettings {
     PostToolUse?: Array<{ matcher: string; hooks: Array<{ type: string; command: string }> }>;
     SessionStart?: Array<{ matcher: string; hooks: Array<{ type: string; command: string }> }>;
     Stop?: Array<{ matcher: string; hooks: Array<{ type: string; command: string }> }>;
+    SessionEnd?: Array<{ matcher: string; hooks: Array<{ type: string; command: string }> }>;
   };
   [key: string]: unknown;
 }
@@ -79,30 +80,39 @@ function saveClaudeSettings(settings: ClaudeSettings): void {
   fs.renameSync(tempPath, CLAUDE_SETTINGS_PATH);
 }
 
+const REQUIRED_HOOK_FILES = [
+  'user-prompt-submit.js',
+  'post-tool-use.js',
+  'session-start.js',
+  'stop.js',
+  'session-end.js'
+] as const;
+
+function hasHook(settings: ClaudeSettings, hookName: keyof NonNullable<ClaudeSettings['hooks']>, commandFragment: string): boolean {
+  const hookEntries = settings.hooks?.[hookName];
+  if (!hookEntries) return false;
+  return hookEntries.some((entry) => entry.hooks?.some((hook) => hook.command?.includes(commandFragment)));
+}
+
 function getHooksConfig(pluginPath: string): ClaudeSettings['hooks'] {
+  const makeHook = (fileName: string) => [
+    {
+      matcher: '',
+      hooks: [
+        {
+          type: 'command',
+          command: `node ${path.join(pluginPath, 'hooks', fileName)}`
+        }
+      ]
+    }
+  ];
+
   return {
-    UserPromptSubmit: [
-      {
-        matcher: '',
-        hooks: [
-          {
-            type: 'command',
-            command: `node ${path.join(pluginPath, 'hooks', 'user-prompt-submit.js')}`
-          }
-        ]
-      }
-    ],
-    PostToolUse: [
-      {
-        matcher: '',
-        hooks: [
-          {
-            type: 'command',
-            command: `node ${path.join(pluginPath, 'hooks', 'post-tool-use.js')}`
-          }
-        ]
-      }
-    ]
+    SessionStart: makeHook('session-start.js'),
+    UserPromptSubmit: makeHook('user-prompt-submit.js'),
+    PostToolUse: makeHook('post-tool-use.js'),
+    Stop: makeHook('stop.js'),
+    SessionEnd: makeHook('session-end.js')
   };
 }
 
@@ -129,9 +139,12 @@ program
       const pluginPath = options.path || getPluginPath();
 
       // Verify hooks exist
-      const userPromptHook = path.join(pluginPath, 'hooks', 'user-prompt-submit.js');
-      if (!fs.existsSync(userPromptHook)) {
+      const missingHooks = REQUIRED_HOOK_FILES.filter((file) =>
+        !fs.existsSync(path.join(pluginPath, 'hooks', file))
+      );
+      if (missingHooks.length > 0) {
         console.error(`\n❌ Hook files not found at: ${pluginPath}`);
+        console.error(`   Missing: ${missingHooks.join(', ')}`);
         console.error('   Make sure you have built the plugin with "npm run build"');
         process.exit(1);
       }
@@ -151,8 +164,11 @@ program
 
       console.log('\n✅ Claude Memory Layer installed!\n');
       console.log('Hooks registered:');
+      console.log('  - SessionStart: Register session -> project mapping');
       console.log('  - UserPromptSubmit: Memory retrieval on user input');
-      console.log('  - PostToolUse: Store tool observations\n');
+      console.log('  - PostToolUse: Store tool observations');
+      console.log('  - Stop: Store assistant responses');
+      console.log('  - SessionEnd: Persist session summary\n');
       console.log('Plugin path:', pluginPath);
       console.log('\n⚠️  Restart Claude Code for changes to take effect.\n');
       console.log('Commands:');
@@ -183,8 +199,11 @@ program
       }
 
       // Remove our hooks
+      delete settings.hooks.SessionStart;
       delete settings.hooks.UserPromptSubmit;
       delete settings.hooks.PostToolUse;
+      delete settings.hooks.Stop;
+      delete settings.hooks.SessionEnd;
 
       // Clean up empty hooks object
       if (Object.keys(settings.hooks).length === 0) {
@@ -219,19 +238,22 @@ program
       console.log('\n🧠 Claude Memory Layer Status\n');
 
       // Check hooks
-      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'))
-      );
+      const hasSessionStartHook = hasHook(settings, 'SessionStart', 'session-start');
+      const hasUserPromptHook = hasHook(settings, 'UserPromptSubmit', 'user-prompt-submit');
+      const hasPostToolHook = hasHook(settings, 'PostToolUse', 'post-tool-use');
+      const hasStopHook = hasHook(settings, 'Stop', 'stop');
+      const hasSessionEndHook = hasHook(settings, 'SessionEnd', 'session-end');
 
       console.log('Hooks:');
+      console.log(`  SessionStart: ${hasSessionStartHook ? '✅ Installed' : '❌ Not installed'}`);
       console.log(`  UserPromptSubmit: ${hasUserPromptHook ? '✅ Installed' : '❌ Not installed'}`);
       console.log(`  PostToolUse: ${hasPostToolHook ? '✅ Installed' : '❌ Not installed'}`);
+      console.log(`  Stop: ${hasStopHook ? '✅ Installed' : '❌ Not installed'}`);
+      console.log(`  SessionEnd: ${hasSessionEndHook ? '✅ Installed' : '❌ Not installed'}`);
 
       // Check plugin files
-      const hooksExist = fs.existsSync(path.join(pluginPath, 'hooks', 'user-prompt-submit.js'));
+      const hooksExist = REQUIRED_HOOK_FILES
+        .every((file) => fs.existsSync(path.join(pluginPath, 'hooks', file)));
       console.log(`\nPlugin files: ${hooksExist ? '✅ Found' : '❌ Not found'}`);
       console.log(`  Path: ${pluginPath}`);
 
@@ -239,7 +261,7 @@ program
       const dashboardRunning = await isServerRunning(37777);
       console.log(`\nDashboard: ${dashboardRunning ? '✅ Running at http://localhost:37777' : '⏹️  Not running'}`);
 
-      if (!hasUserPromptHook || !hasPostToolHook) {
+      if (!hasSessionStartHook || !hasUserPromptHook || !hasPostToolHook || !hasStopHook || !hasSessionEndHook) {
         console.log('\n💡 Run "claude-memory-layer install" to set up hooks.\n');
       } else {
         console.log('\n✅ Plugin is fully installed and configured.\n');

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

@@ -1446,28 +1446,33 @@ export class SQLiteEventStore {
   }>> {
     await this.initialize();
 
-    const rows = sqliteAll<Record<string, unknown>>(
-      this.db,
-      `SELECT * FROM retrieval_traces ORDER BY created_at DESC LIMIT ?`,
-      [limit]
-    );
+    try {
+      const rows = sqliteAll<Record<string, unknown>>(
+        this.db,
+        `SELECT * FROM retrieval_traces ORDER BY created_at DESC LIMIT ?`,
+        [limit]
+      );
 
-    return rows.map((row) => ({
-      traceId: row.trace_id as string,
-      sessionId: (row.session_id as string) || undefined,
-      projectHash: (row.project_hash as string) || undefined,
-      queryText: row.query_text as string,
-      strategy: (row.strategy as string) || undefined,
-      candidateEventIds: row.candidate_event_ids ? JSON.parse(row.candidate_event_ids as string) : [],
-      selectedEventIds: row.selected_event_ids ? JSON.parse(row.selected_event_ids as string) : [],
-      candidateDetails: row.candidate_details_json ? JSON.parse(row.candidate_details_json as string) : [],
-      selectedDetails: row.selected_details_json ? JSON.parse(row.selected_details_json as string) : [],
-      candidateCount: Number(row.candidate_count || 0),
-      selectedCount: Number(row.selected_count || 0),
-      confidence: (row.confidence as string) || undefined,
-      fallbackTrace: row.fallback_trace ? JSON.parse(row.fallback_trace as string) : [],
-      createdAt: toDateFromSQLite(row.created_at),
-    }));
+      return rows.map((row) => ({
+        traceId: row.trace_id as string,
+        sessionId: (row.session_id as string) || undefined,
+        projectHash: (row.project_hash as string) || undefined,
+        queryText: row.query_text as string,
+        strategy: (row.strategy as string) || undefined,
+        candidateEventIds: row.candidate_event_ids ? JSON.parse(row.candidate_event_ids as string) : [],
+        selectedEventIds: row.selected_event_ids ? JSON.parse(row.selected_event_ids as string) : [],
+        candidateDetails: row.candidate_details_json ? JSON.parse(row.candidate_details_json as string) : [],
+        selectedDetails: row.selected_details_json ? JSON.parse(row.selected_details_json as string) : [],
+        candidateCount: Number(row.candidate_count || 0),
+        selectedCount: Number(row.selected_count || 0),
+        confidence: (row.confidence as string) || undefined,
+        fallbackTrace: row.fallback_trace ? JSON.parse(row.fallback_trace as string) : [],
+        createdAt: toDateFromSQLite(row.created_at),
+      }));
+    } catch (err: any) {
+      if (err?.message?.includes('no such table')) return [];
+      throw err;
+    }
   }
 
   async getRetrievalTraceStats(): Promise<{
@@ -1478,26 +1483,33 @@ export class SQLiteEventStore {
   }> {
     await this.initialize();
 
-    const row = sqliteGet<Record<string, unknown>>(
-      this.db,
-      `SELECT
-        COUNT(*) as total_queries,
-        AVG(candidate_count) as avg_candidate_count,
-        AVG(selected_count) as avg_selected_count,
-        CASE
-          WHEN SUM(candidate_count) > 0 THEN (SUM(selected_count) * 1.0 / SUM(candidate_count))
-          ELSE 0
-        END as selection_rate
-       FROM retrieval_traces`,
-      []
-    );
+    try {
+      const row = sqliteGet<Record<string, unknown>>(
+        this.db,
+        `SELECT
+          COUNT(*) as total_queries,
+          AVG(candidate_count) as avg_candidate_count,
+          AVG(selected_count) as avg_selected_count,
+          CASE
+            WHEN SUM(candidate_count) > 0 THEN (SUM(selected_count) * 1.0 / SUM(candidate_count))
+            ELSE 0
+          END as selection_rate
+         FROM retrieval_traces`,
+        []
+      );
 
-    return {
-      totalQueries: Number(row?.total_queries || 0),
-      avgCandidateCount: Number(row?.avg_candidate_count || 0),
-      avgSelectedCount: Number(row?.avg_selected_count || 0),
-      selectionRate: Number(row?.selection_rate || 0),
-    };
+      return {
+        totalQueries: Number(row?.total_queries || 0),
+        avgCandidateCount: Number(row?.avg_candidate_count || 0),
+        avgSelectedCount: Number(row?.avg_selected_count || 0),
+        selectionRate: Number(row?.selection_rate || 0),
+      };
+    } catch (err: any) {
+      if (err?.message?.includes('no such table')) {
+        return { totalQueries: 0, avgCandidateCount: 0, avgSelectedCount: 0, selectionRate: 0 };
+      }
+      throw err;
+    }
   }
 
   /**

package/src/hooks/user-prompt-submit.ts

@@ -17,7 +17,9 @@ import type { UserPromptSubmitInput, UserPromptSubmitOutput } from '../core/type
 
 // Configuration
 const MAX_MEMORIES = parseInt(process.env.CLAUDE_MEMORY_MAX_COUNT || '5');
-const MIN_SCORE = parseFloat(process.env.CLAUDE_MEMORY_MIN_SCORE || '0.3');
+// Tuned default for noise/recall balance on shopping_assistant-like corpus
+const BASE_MIN_SCORE = parseFloat(process.env.CLAUDE_MEMORY_MIN_SCORE || '0.4');
+const FALLBACK_MIN_SCORE = parseFloat(process.env.CLAUDE_MEMORY_FALLBACK_MIN_SCORE || '0.3');
 const ENABLE_SEARCH = process.env.CLAUDE_MEMORY_SEARCH !== 'false';
 
 /**
@@ -32,6 +34,14 @@ function shouldStorePrompt(prompt: string): boolean {
   return true;
 }
 
+
+function getDynamicMinScore(prompt: string): number {
+  const len = prompt.trim().length;
+  if (len <= 20) return Math.min(0.55, BASE_MIN_SCORE + 0.1);   // short query → stricter
+  if (len >= 80) return Math.max(0.3, BASE_MIN_SCORE - 0.05);    // long query → slightly looser
+  return BASE_MIN_SCORE;
+}
+
 async function main(): Promise<void> {
   // Read input from stdin
   const inputData = await readStdin();
@@ -61,11 +71,20 @@ async function main(): Promise<void> {
 
     // Fast keyword search if enabled
     if (ENABLE_SEARCH && input.prompt.length > 10) {
-      const results = await memoryService.keywordSearch(input.prompt, {
+      const minScore = getDynamicMinScore(input.prompt);
+      let results = await memoryService.keywordSearch(input.prompt, {
         topK: MAX_MEMORIES,
-        minScore: MIN_SCORE
+        minScore
       });
 
+      // recall rescue: if nothing found at tuned threshold, retry with fallback floor
+      if (results.length === 0 && FALLBACK_MIN_SCORE < minScore) {
+        results = await memoryService.keywordSearch(input.prompt, {
+          topK: MAX_MEMORIES,
+          minScore: FALLBACK_MIN_SCORE
+        });
+      }
+
       if (results.length > 0) {
         // Increment access count for found memories
         const eventIds = results.map(r => r.event.id);