claude-recall 0.22.1 → 0.22.2

package/.claude/skills/auto-preferences/SKILL.md

@@ -8,14 +8,14 @@ source: claude-recall
 
 # Preferences
 
-Auto-generated from 5 memories. Last updated: 2026-04-11.
+Auto-generated from 5 memories. Last updated: 2026-04-14.
 
 ## Rules
 
-- Session test preference 1775902182248
-- Test preference 1775902182184-2
-- Test preference 1775902182184-1
-- Test preference 1775902182184-0
+- Session test preference 1776172131422
+- Test preference 1776172131359-2
+- Test preference 1776172131359-1
+- Test preference 1776172131359-0
 - Test memory content
 
 ---

package/.claude/skills/auto-preferences/manifest.json

@@ -1,13 +1,13 @@
 {
   "topicId": "preferences",
-  "sourceHash": "a383c0d6502023d06954eb49fcab8886dc5181d5e59666f6c74a381221e44f87",
+  "sourceHash": "37e19c67668ff4fdd21019d4837a36dc368138b8e4299bcff235fdaf84b5f028",
   "memoryCount": 5,
-  "generatedAt": "2026-04-11T10:09:42.271Z",
+  "generatedAt": "2026-04-14T13:08:51.442Z",
   "memoryKeys": [
-    "memory_1775902182249_x5rzzep7s",
-    "memory_1775902182226_9uo2kaw57",
-    "memory_1775902182211_pl5fzrb85",
-    "memory_1775902182185_q6f9widp3",
-    "memory_1775902182147_olowsptz3"
+    "memory_1776172131423_zdtbhf2vw",
+    "memory_1776172131396_d2s4cuyls",
+    "memory_1776172131378_1r9w9r7lq",
+    "memory_1776172131363_gqgkc4o6s",
+    "memory_1776172131318_dbwsryce8"
   ]
 }

package/dist/mcp/tools/memory-tools.js

@@ -274,6 +274,10 @@ class MemoryTools {
                 ? metadata.type
                 : 'preference';
             const key = `memory_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+            const preferenceKey = typeof metadata?.preference_key === 'string' && metadata.preference_key.length > 0
+                ? metadata.preference_key
+                : undefined;
+            const isOverride = metadata?.isOverride === true;
             this.memoryService.store({
                 key,
                 value: {
@@ -288,8 +292,17 @@ class MemoryTools {
                     projectId: scope === 'project' ? context.projectId : undefined,
                     timestamp: context.timestamp,
                     scope: scope || null
-                }
+                },
+                preferenceKey,
+                isOverride
             });
+            // If this store overrides an existing rule, mark previous active rules with
+            // the same preference_key as superseded and surface their keys so the agent
+            // knows to ignore the stale text sitting higher up in its context.
+            let supersededKeys = [];
+            if (isOverride && preferenceKey) {
+                supersededKeys = this.memoryService.supersedeByPreferenceKey(preferenceKey, key, { sessionId: context.sessionId, projectId: context.projectId, timestamp: context.timestamp });
+            }
             this.logger.info('MemoryTools', 'Memory stored successfully', {
                 key,
                 type: detectedType,
@@ -320,6 +333,10 @@ class MemoryTools {
                 activeRule: `Stored as active rule:\n- ${content}`,
                 type: detectedType,
                 _directive: 'Apply this rule immediately. No need to call load_rules again.',
+                ...(supersededKeys.length > 0 && {
+                    supersededKeys,
+                    _supersessionNotice: `Superseded ${supersededKeys.length} prior rule(s) for preference_key="${preferenceKey}". Ignore any earlier text from these rules still in your context: ${supersededKeys.join(', ')}`
+                }),
                 ...(skillResults.length > 0 && {
                     _skillsGenerated: skillResults
                         .filter(r => r.action === 'created' || r.action === 'updated')
@@ -383,11 +400,21 @@ class MemoryTools {
                     return `- ${val}`;
                 }).join('\n'));
             }
-            // Add compliance section for rules loaded frequently but never cited
+            // Add compliance section for rules loaded frequently but never cited.
+            // Cap at top 10 by load_count so load_rules stays slim — this diagnostic
+            // list was previously unbounded and could dominate the payload.
+            const RULE_HEALTH_CAP = 10;
             const compliance = this.memoryService.getComplianceReport(projectId || context.projectId);
-            const lowCompliance = compliance.rules.filter(r => r.load_count >= 5 && r.cite_count === 0);
+            const allLowCompliance = compliance.rules.filter(r => r.load_count >= 5 && r.cite_count === 0);
+            const lowCompliance = [...allLowCompliance]
+                .sort((a, b) => (b.load_count || 0) - (a.load_count || 0))
+                .slice(0, RULE_HEALTH_CAP);
+            const hiddenCount = allLowCompliance.length - lowCompliance.length;
             if (lowCompliance.length > 0) {
-                sections.push('## Rule Health\nThese rules are loaded frequently but never cited — consider rewording or removing:\n' +
+                const heading = hiddenCount > 0
+                    ? `## Rule Health (top ${RULE_HEALTH_CAP} of ${allLowCompliance.length})\nThese rules are loaded frequently but never cited — consider rewording or removing. ${hiddenCount} more hidden; run \`npx claude-recall outcomes\` to see all.`
+                    : '## Rule Health\nThese rules are loaded frequently but never cited — consider rewording or removing:';
+                sections.push(heading + '\n' +
                     lowCompliance.map(r => {
                         let val;
                         if (typeof r.value === 'string') {

package/dist/memory/storage.js

@@ -562,6 +562,23 @@ class MemoryStorage {
         const stmt = this.db.prepare(`UPDATE memories SET ${setClause} WHERE key = ?`);
         stmt.run(...values, key);
     }
+    /**
+     * Get active memories (any type) that share the given preference_key.
+     * Used by store_memory's override path — a user can override a rule of any
+     * type (devops, correction, preference) as long as it was stored with a
+     * preference_key.
+     */
+    getActiveByPreferenceKeyAnyType(preferenceKey, projectId) {
+        let query = 'SELECT * FROM memories WHERE preference_key = ? AND is_active = 1';
+        const params = [preferenceKey];
+        if (projectId) {
+            query += ' AND (project_id = ? OR project_id IS NULL)';
+            params.push(projectId);
+        }
+        query += ' ORDER BY timestamp DESC';
+        const rows = this.db.prepare(query).all(...params);
+        return rows.map(row => this.rowToMemory(row));
+    }
     /**
      * Get preferences by preference key
      */

package/dist/services/memory.js

@@ -43,7 +43,9 @@ class MemoryService {
                 file_path: request.context?.filePath,
                 timestamp: request.context?.timestamp || Date.now(),
                 relevance_score: request.relevanceScore || 1.0,
-                scope: scope
+                scope: scope,
+                preference_key: request.preferenceKey,
+                is_active: true
             };
             this.storage.save(memory);
             this.logger.logMemoryOperation('STORE', {
@@ -303,6 +305,30 @@ class MemoryService {
             throw error;
         }
     }
+    /**
+     * Mark all currently-active memories with the given preference_key as superseded by newKey.
+     * Returns the list of superseded keys so callers can surface them to the agent — this
+     * closes the "I stored an override but the old rule is still in my context" gap.
+     */
+    supersedeByPreferenceKey(preferenceKey, newKey, context) {
+        if (!preferenceKey || !newKey)
+            return [];
+        const superseded = [];
+        try {
+            const pid = context.projectId || this.config.getProjectId();
+            const existing = this.storage.getActiveByPreferenceKeyAnyType(preferenceKey, pid);
+            for (const prev of existing) {
+                if (prev.key !== newKey) {
+                    this.storage.markSuperseded(prev.key, newKey);
+                    superseded.push(prev.key);
+                }
+            }
+        }
+        catch (error) {
+            this.logger.logServiceError('MemoryService', 'supersedeByPreferenceKey', error, { preferenceKey, newKey });
+        }
+        return superseded;
+    }
     /**
      * Mark existing preferences as superseded
      */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-recall",
-  "version": "0.22.1",
+  "version": "0.22.2",
   "description": "Persistent memory for Claude Code and Pi with native Skills integration, automatic capture, failure learning, and project scoping",
   "main": "dist/index.js",
   "bin": {