claude-recall 0.15.13 → 0.15.16

package/.claude/hooks/search_enforcer.py

@@ -32,7 +32,11 @@ READ_ONLY_BASH = [
     'ls', 'cat', 'head', 'tail', 'less', 'more', 'file', 'stat', 'wc',
     'find', 'locate', 'which', 'whereis', 'type', 'pwd', 'whoami',
     'git status', 'git log', 'git diff', 'git show', 'git branch',
-    'git remote', 'git fetch', 'git stash list', 'git tag',
+    'git remote', 'git fetch', 'git stash', 'git tag',
+    'git add', 'git commit', 'git push', 'git pull', 'git merge',
+    'git rebase', 'git checkout', 'git switch', 'git cherry-pick',
+    'npm install', 'npm version', 'npm publish', 'npm pack',
+    'npx',
     'npm list', 'npm ls', 'npm view', 'npm outdated', 'npm audit',
     'npm test', 'npm run test', 'npm run build', 'npm run lint',
     'pip list', 'pip show', 'pip freeze',
@@ -125,7 +129,21 @@ def main():
         if (now - last_search) <= SEARCH_TTL_MS:
             sys.exit(0)
 
-    # Block or warn
+        # TTL expired but rules were loaded earlier — degrade to warn, not block.
+        # This prevents deadlock when MCP server disconnects mid-session.
+        msg = f"""
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+STALE RULES — consider reloading before {tool_name}
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+Rules were loaded earlier but TTL expired.
+Run: mcp__claude-recall__load_rules({{}})
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+"""
+        print(msg.strip(), file=sys.stderr)
+        sys.exit(0)  # Warn only — allow the action
+
+    # Never loaded in this session — block
     msg = f"""
 ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
 LOAD RULES REQUIRED before {tool_name}

package/.claude/settings.json

@@ -1 +1,48 @@
-{"hooks": {}, "hooksVersion": "1.0.0"}
+{
+  "hooks": {
+    "PreToolUse": [
+      {
+        "matcher": "mcp__claude-recall__.*|Write|Edit|Bash|Task",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "python3 /home/ebiarao/repos-wsl/personal-projects/claude-recall/.claude/hooks/search_enforcer.py"
+          }
+        ]
+      }
+    ],
+    "UserPromptSubmit": [
+      {
+        "hooks": [
+          {
+            "type": "command",
+            "command": "npx claude-recall@latest hook run correction-detector"
+          }
+        ]
+      }
+    ],
+    "Stop": [
+      {
+        "hooks": [
+          {
+            "type": "command",
+            "command": "npx claude-recall@latest hook run memory-stop",
+            "timeout": 30
+          }
+        ]
+      }
+    ],
+    "PreCompact": [
+      {
+        "hooks": [
+          {
+            "type": "command",
+            "command": "npx claude-recall@latest hook run precompact-preserve",
+            "timeout": 60
+          }
+        ]
+      }
+    ]
+  },
+  "hooksVersion": "4.0.0"
+}

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

@@ -8,7 +8,7 @@ source: claude-recall
 
 # Corrections
 
-Auto-generated from 22 memories. Last updated: 2026-02-18.
+Auto-generated from 25 memories. Last updated: 2026-02-26.
 
 ## Rules
 
@@ -33,6 +33,9 @@ Auto-generated from 22 memories. Last updated: 2026-02-18.
 - CORRECTION: Memory with complex metadata
 - CORRECTION: Memory with complex metadata
 - CORRECTION: Memory with complex metadata
+- CORRECTION: Memory with complex metadata
+- CORRECTION: Memory with complex metadata
+- CORRECTION: Memory with complex metadata
 - CORRECTION: use spaces not tabs for indentation
 
 ---

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

@@ -1,9 +1,12 @@
 {
   "topicId": "corrections",
-  "sourceHash": "a5771c8eabda87fcc3f6e70078899728da3232155bae5b8c230d476bf8d23935",
-  "memoryCount": 22,
-  "generatedAt": "2026-02-18T19:13:11.271Z",
+  "sourceHash": "9db7378bea9322948eab03d138983fc4e4173aa593ea16e1487f0551b91cecc3",
+  "memoryCount": 25,
+  "generatedAt": "2026-02-26T10:01:12.122Z",
   "memoryKeys": [
+    "memory_1772100072113_a6za43yqy",
+    "memory_1771937053521_wayeeo1gr",
+    "memory_1771936515420_zm9348oh9",
     "memory_1771441991246_26wk2e6q3",
     "memory_1771432628423_6l1fpuu77",
     "memory_1771432266123_aevced1ym",

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

@@ -8,10 +8,25 @@ source: claude-recall
 
 # Preferences
 
-Auto-generated from 123 memories. Last updated: 2026-02-18.
+Auto-generated from 140 memories. Last updated: 2026-02-26.
 
 ## Rules
 
+- Session test preference 1772100072188
+- Test preference 1772100072127-2
+- Test preference 1772100072127-1
+- Test preference 1772100072127-0
+- Test memory content
+- Session test preference 1771937053612
+- Test preference 1771937053539-2
+- Test preference 1771937053539-1
+- Test preference 1771937053539-0
+- Test memory content
+- Session test preference 1771936515500
+- Test preference 1771936515435-2
+- Test preference 1771936515435-1
+- Test preference 1771936515435-0
+- Test memory content
 - Session test preference 1771441991453
 - Test preference 1771441991283-2
 - Test preference 1771441991283-1
@@ -132,6 +147,8 @@ Auto-generated from 123 memories. Last updated: 2026-02-18.
 - Test memory 1770503266492-0
 - Memory with complex metadata
 - Test memory content
+- When user says 'jam', it means 'just answer me' — a shorthand directive to provide direct answers without elaboration
+- When user says 'jam', they mean 'just answer me' — respond directly without explanation
 - always use tabs for indentation
 - always use tabs
 - always use tabs

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

@@ -1,9 +1,24 @@
 {
   "topicId": "preferences",
-  "sourceHash": "8f50f9a19f039ef86bce89ab33afcd2782dc19e536275039f56031ebd22c56a3",
-  "memoryCount": 123,
-  "generatedAt": "2026-02-18T19:13:11.483Z",
+  "sourceHash": "6abccdcd61e745a5953d71937d9d76bc0e63e4fdea57efd12e82ee5364c5cb7e",
+  "memoryCount": 140,
+  "generatedAt": "2026-02-26T10:01:12.200Z",
   "memoryKeys": [
+    "memory_1772100072189_1z5ky8vqz",
+    "memory_1772100072157_1dhc3az8z",
+    "memory_1772100072143_9wwr89ivr",
+    "memory_1772100072128_v5em20s0r",
+    "memory_1772100072057_gpuspbnd5",
+    "memory_1771937053614_p4252awle",
+    "memory_1771937053577_7hkwaug2z",
+    "memory_1771937053557_2tv5gy1kn",
+    "memory_1771937053540_byc4aoei6",
+    "memory_1771937053479_5b1aq5bo4",
+    "memory_1771936515501_7rxf04yr7",
+    "memory_1771936515470_5amfyz2c2",
+    "memory_1771936515454_yuee3hady",
+    "memory_1771936515436_2zas4g86g",
+    "memory_1771936515373_x886pahdp",
     "memory_1771441991455_q068p8n23",
     "memory_1771441991411_dv9e76ojs",
     "memory_1771441991351_8esutde44",
@@ -124,6 +139,8 @@
     "memory_1770503266494_f3p8e15xv",
     "memory_1770503266473_23fy8pzky",
     "memory_1770503266442_289cuenj7",
+    "hook_preference_1771934420257_l4pawjgn5",
+    "hook_preference_1771934405021_mnhek0x7b",
     "hook_preference_1771112119815_z02zal3z6",
     "hook_preference_1771112104493_d3nz1o2ye",
     "hook_preference_1771112075356_3gh724ucm"

package/dist/cli/claude-recall-cli.js

@@ -108,6 +108,8 @@ class ClaudeRecallCLI {
         this.showSkillsEvolution();
         // Token Savings Estimate
         this.showTokenSavings(stats);
+        // Rule Compliance
+        this.showComplianceStats();
         console.log('\n');
         this.logger.info('CLI', 'Stats displayed', stats);
     }
@@ -190,6 +192,34 @@ class ClaudeRecallCLI {
         console.log(`  Total saved: ~${totalSavings.toLocaleString()} tokens`);
         console.log(`  (vs repeating preferences or loading all reference files)`);
     }
+    /**
+     * Show rule compliance statistics
+     */
+    showComplianceStats() {
+        const report = this.memoryService.getComplianceReport();
+        if (report.rules.length === 0)
+            return;
+        console.log('\n📋 Rule Compliance:');
+        const loaded = report.rules.filter(r => r.load_count > 0);
+        const cited = loaded.filter(r => r.cite_count > 0);
+        console.log(`  Rules loaded at least once: ${loaded.length}`);
+        console.log(`  Rules cited at least once: ${cited.length}`);
+        const neverCited = loaded.filter(r => r.load_count >= 5 && r.cite_count === 0);
+        if (neverCited.length > 0) {
+            console.log(`  ⚠️  Never cited (loaded 5+ times): ${neverCited.length}`);
+            neverCited.slice(0, 3).forEach(r => {
+                let val;
+                try {
+                    const parsed = JSON.parse(r.value);
+                    val = parsed?.content || parsed?.value || r.value;
+                }
+                catch {
+                    val = r.value;
+                }
+                console.log(`     - "${String(val).substring(0, 60)}..." (loaded ${r.load_count}x)`);
+            });
+        }
+    }
     /**
      * Show failure memories (v0.7.0)
      */
@@ -529,7 +559,9 @@ async function main() {
         if (fs.existsSync(hooksDir)) {
             const oldHooks = [
                 'memory_enforcer.py', // Old v0.8.x hook
-                'search_enforcer.py',
+                // search_enforcer.py intentionally NOT listed — it's the current hook.
+                // copyFileSync overwrites it during install; deleting first risks leaving
+                // it missing if the copy source doesn't resolve (e.g. in the source project).
                 'mcp_tool_tracker.py',
                 'pubnub_pre_tool_hook.py',
                 'pubnub_prompt_hook.py',

package/dist/hooks/memory-stop-hook.js

@@ -9,6 +9,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.handleMemoryStop = handleMemoryStop;
 const shared_1 = require("./shared");
+const memory_1 = require("../services/memory");
 const MAX_STORE = 3;
 async function handleMemoryStop(input) {
     const transcriptPath = input?.transcript_path ?? '';
@@ -60,4 +61,55 @@ async function handleMemoryStop(input) {
         (0, shared_1.hookLog)('memory-stop', `Captured ${result.type}: ${result.extract.substring(0, 80)}`);
     }
     (0, shared_1.hookLog)('memory-stop', `Session end: stored ${stored} memories from ${entries.length} entries`);
+    // Scan for citations in assistant messages to track compliance
+    scanForCitations(transcriptPath);
+}
+/**
+ * Scan transcript for (applied from memory: ...) citations and increment cite_count.
+ * Uses a wider window (last 50 entries) since citations appear throughout assistant responses.
+ */
+function scanForCitations(transcriptPath) {
+    try {
+        const entries = (0, shared_1.readTranscriptTail)(transcriptPath, 50);
+        if (entries.length === 0)
+            return;
+        const citationRegex = /\(applied from memory:\s*(.+?)\)/g;
+        const citations = [];
+        for (const entry of entries) {
+            // Only scan assistant entries (opposite of isUserEntry)
+            if ((0, shared_1.isUserEntry)(entry))
+                continue;
+            const text = (0, shared_1.extractTextFromEntry)(entry);
+            if (!text)
+                continue;
+            let match;
+            while ((match = citationRegex.exec(text)) !== null) {
+                citations.push(match[1].trim());
+            }
+        }
+        if (citations.length === 0)
+            return;
+        (0, shared_1.hookLog)('memory-stop', `Found ${citations.length} citation(s) in transcript`);
+        const memoryService = memory_1.MemoryService.getInstance();
+        for (const cite of citations) {
+            // Search for rules that match this citation text
+            const existing = (0, shared_1.searchExisting)(cite.substring(0, 100));
+            if (existing.length === 0)
+                continue;
+            // Fuzzy-match: citations are often paraphrased, so use a looser threshold
+            for (const mem of existing) {
+                const memContent = typeof mem.value === 'string'
+                    ? mem.value
+                    : (mem.value?.content || JSON.stringify(mem.value));
+                if ((0, shared_1.jaccardSimilarity)(cite, memContent) >= 0.5) {
+                    memoryService.incrementCiteCount(mem.key);
+                    (0, shared_1.hookLog)('memory-stop', `Citation matched: "${cite.substring(0, 50)}" → rule ${mem.key}`);
+                    break; // One match per citation
+                }
+            }
+        }
+    }
+    catch (error) {
+        (0, shared_1.hookLog)('memory-stop', `Citation scan error: ${error}`);
+    }
 }

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

@@ -276,6 +276,16 @@ class MemoryTools {
                     return `- ${val}`;
                 }).join('\n'));
             }
+            // Add compliance section for rules loaded frequently but never cited
+            const compliance = this.memoryService.getComplianceReport(projectId || context.projectId);
+            const lowCompliance = compliance.rules.filter(r => r.load_count >= 5 && r.cite_count === 0);
+            if (lowCompliance.length > 0) {
+                sections.push('## Rule Health\nThese rules are loaded frequently but never cited — consider rewording or removing:\n' +
+                    lowCompliance.map(r => {
+                        const val = typeof r.value === 'string' ? (JSON.parse(r.value)?.content || r.value) : r.value;
+                        return `- "${String(val).substring(0, 80)}" (loaded ${r.load_count}x, cited 0x)`;
+                    }).join('\n'));
+            }
             const totalRules = rules.preferences.length + rules.corrections.length +
                 rules.failures.length + rules.devops.length;
             const resultTokens = this.estimateTokens([

package/dist/memory/storage.js

@@ -103,6 +103,18 @@ class MemoryStorage {
                 this.db.exec('CREATE INDEX IF NOT EXISTS idx_memories_scope_project ON memories(scope, project_id)');
                 console.log('✅ Added scope column');
             }
+            // Add load_count if missing (compliance tracking v0.15.14)
+            if (!columnNames.includes('load_count')) {
+                console.log('📋 Migrating database schema: Adding load_count column...');
+                this.db.exec('ALTER TABLE memories ADD COLUMN load_count INTEGER DEFAULT 0');
+                console.log('✅ Added load_count column');
+            }
+            // Add cite_count if missing (compliance tracking v0.15.14)
+            if (!columnNames.includes('cite_count')) {
+                console.log('📋 Migrating database schema: Adding cite_count column...');
+                this.db.exec('ALTER TABLE memories ADD COLUMN cite_count INTEGER DEFAULT 0');
+                console.log('✅ Added cite_count column');
+            }
             // Add content_hash if missing (content dedup)
             if (!columnNames.includes('content_hash')) {
                 console.log('📋 Migrating database schema: Adding content_hash column...');
@@ -386,6 +398,45 @@ class MemoryStorage {
         const rows = stmt.all(...params);
         return rows.map(row => this.rowToMemory(row));
     }
+    /**
+     * Bulk-increment load_count for a set of memory IDs.
+     * Called when rules are loaded via load_rules.
+     */
+    incrementLoadCounts(ids) {
+        if (ids.length === 0)
+            return;
+        const placeholders = ids.map(() => '?').join(',');
+        this.db.prepare(`UPDATE memories SET load_count = load_count + 1 WHERE id IN (${placeholders})`).run(...ids);
+    }
+    /**
+     * Increment cite_count for a single memory by ID.
+     * Called when a citation is detected in the transcript.
+     */
+    incrementCiteCount(id) {
+        this.db.prepare('UPDATE memories SET cite_count = cite_count + 1 WHERE id = ?').run(id);
+    }
+    /**
+     * Get rules with their compliance metrics (load_count, cite_count).
+     * Returns rules that have been loaded at least once.
+     */
+    getRulesWithCompliance(projectId) {
+        let query = 'SELECT id, key, type, value, load_count, cite_count FROM memories WHERE load_count > 0';
+        const params = [];
+        if (projectId) {
+            query += ' AND (project_id = ? OR scope = ? OR project_id IS NULL)';
+            params.push(projectId, 'universal');
+        }
+        query += ' ORDER BY load_count DESC';
+        const rows = this.db.prepare(query).all(...params);
+        return rows.map(row => ({
+            id: row.id,
+            key: row.key,
+            type: row.type,
+            value: row.value,
+            load_count: row.load_count,
+            cite_count: row.cite_count
+        }));
+    }
     getDatabase() {
         return this.db;
     }

package/dist/services/memory.js

@@ -369,6 +369,13 @@ class MemoryService {
                 ? `Loaded ${counts.join(', ')}`
                 : 'No active rules found';
             this.logger.info('MemoryService', summary, { projectId: pid });
+            // Increment load_count for all returned rules
+            const allIds = [
+                ...preferences, ...corrections, ...failures, ...devops
+            ].map(m => m.id).filter((id) => id !== undefined);
+            if (allIds.length > 0) {
+                this.storage.incrementLoadCounts(allIds);
+            }
             return { preferences, corrections, failures, devops, summary };
         }
         catch (error) {
@@ -376,6 +383,40 @@ class MemoryService {
             return { preferences: [], corrections: [], failures: [], devops: [], summary: 'Error loading rules' };
         }
     }
+    /**
+     * Increment cite_count for a rule matched by key.
+     * Called by the citation scanner in the stop hook.
+     */
+    incrementCiteCount(key) {
+        const memory = this.storage.retrieve(key);
+        if (memory?.id) {
+            this.storage.incrementCiteCount(memory.id);
+        }
+    }
+    /**
+     * Get compliance report showing load vs cite rates for rules.
+     */
+    getComplianceReport(projectId) {
+        const pid = projectId || this.config.getProjectId();
+        const rules = this.storage.getRulesWithCompliance(pid);
+        const loaded = rules.filter(r => r.load_count > 0);
+        const cited = loaded.filter(r => r.cite_count > 0);
+        const neverCited = loaded.filter(r => r.load_count >= 5 && r.cite_count === 0);
+        return {
+            rules: rules.map(r => ({
+                key: r.key,
+                type: r.type,
+                value: r.value,
+                load_count: r.load_count,
+                cite_count: r.cite_count
+            })),
+            summary: {
+                totalLoaded: loaded.length,
+                totalCited: cited.length,
+                neverCited: neverCited.length
+            }
+        };
+    }
     /**
      * Mark a preference as superseded
      */

package/docs/agentic-reasoning-opportunities.md

@@ -0,0 +1,68 @@
+# Agentic Reasoning Opportunities for Claude Recall
+
+Based on "Agentic Reasoning for Large Language Models" (arXiv:2601.12538) and real-world feedback from consumer projects.
+
+## Core Problem
+
+Claude loads rules, cites them, and then doesn't follow through. The directive says "MUST output Applying memories:" — Claude sometimes does, sometimes doesn't. Even when it does, it may cite a rule and still skip the action the rule requires. This is the gap between passive memory retrieval and active reasoning with memory.
+
+## Key Insight
+
+We're treating memory as **passive context injection** when it should be an **active constraint in the execution loop**. The paper's "self-evolving agentic reasoning" dimension — feedback, memory across interactions, adaptive strategies — points to closing the loop mechanically rather than relying on model reasoning.
+
+## Opportunities
+
+### 1. Executable Pre-Checks on Rules (Highest leverage)
+
+Rules currently: prose text Claude reads and may ignore.
+Rules could be: executable commands the system runs automatically before allowing actions.
+
+Example — current rule:
+```
+BEFORE making any code changes: always check (1) what branch am I on? (2) is everything committed?
+```
+
+Proposed rule with executable pre-check:
+```json
+{
+  "content": "Check git state before code changes",
+  "type": "devops",
+  "pre_check": "git branch --show-current && git status --short",
+  "applies_to": ["Write", "Edit"]
+}
+```
+
+The hook runs `pre_check` before allowing Write/Edit and injects the output into context. Claude doesn't need to "decide" to follow through — it happens mechanically. Removes the model from the compliance path entirely.
+
+### 2. Post-Action Validation Hook
+
+Pre-action enforcement exists (load rules before Write/Edit). Post-action checking does not.
+
+A PostToolUse hook could compare what Claude did against loaded rules and flag violations: "You wrote a file without running `git branch` first — rule #4 says to check." Claude can't retroactively ignore a visible violation notice.
+
+### 3. Compliance Tracking
+
+Track which rules get loaded vs. cited vs. actually followed across sessions. Surface patterns:
+- "This rule was loaded 12 times, followed 3 times"
+- "This rule has low compliance. Rewrite it as a concrete command?"
+
+Persistent non-compliance signal means either the rule is too vague or needs reformulation as an executable check.
+
+### 4. Rule Reformulation Feedback
+
+Rules that are consistently not followed might be too abstract. The system could suggest:
+- "This rule has low compliance. Rewrite it as a concrete command?"
+- Turning prose rules into executable pre-checks closes the reasoning gap
+
+## Priority Order
+
+1. **Executable pre-checks** — Removes model from compliance path. Highest impact, moderate effort.
+2. **Post-action validation** — Catches failures after the fact. Medium impact, medium effort.
+3. **Compliance tracking** — Informs which rules need reformulation. Medium impact, low effort.
+4. **Rule reformulation** — Improves rule quality over time. Lower impact, depends on #3.
+
+## Reference
+
+- Paper: https://arxiv.org/pdf/2601.12538
+- Feedback source: Consumer project testing (v0.15.9–v0.15.13)
+- Core failure mode: "I understood the rule, acknowledged it, and still took the shortcut" — Claude's own assessment

package/docs/expected-behavior.md

@@ -0,0 +1,30 @@
+# Claude Recall — Expected Behavior (v0.15.13)
+
+Use this document to evaluate how well Claude Recall is performing in consumer projects. Paste the assessment prompt below into a conversation and ask Claude to self-evaluate.
+
+## Assessment Prompt
+
+Evaluate how well Claude Recall is performing against these expectations:
+
+**1. Load rules before acting**
+- The `search_enforcer` hook blocks Write/Edit/Bash until `load_rules` is called (1-minute TTL, so it re-fires per task)
+- Expected: Claude calls `load_rules` before its first code action in each task. This should be automatic due to the hook — not something Claude decides to skip.
+
+**2. Visible rule application**
+- The `load_rules` response includes a directive requiring Claude to output an "Applying memories:" section before its first action
+- Expected: Before every Write/Edit/Bash, Claude states which loaded rules apply to the current task. If none apply, it says so. This is visible to the user, not internal reasoning.
+
+**3. Actual compliance with loaded rules**
+- Expected: If a rule says "check git branch before code changes," Claude actually runs `git branch`. Not just citing the rule and skipping the action. Loading + citing without following through is compliance theater.
+
+**4. Inline citations**
+- Expected: When a rule influences an action, Claude adds `(applied from memory: <rule summary>)` inline so the user sees which memories are driving decisions.
+
+**5. Auto-capture quality**
+- Hooks auto-capture corrections, preferences from user messages
+- Expected: Only actionable, reusable rules are stored. Conversational fragments, questions, typo-filled casual messages, and Claude's own responses should NOT be stored. If junk gets through, note the content.
+
+**6. Store with permission**
+- Expected: Before calling `store_memory`, Claude tells the user what it plans to store and asks for confirmation. No silent storing.
+
+**Please assess**: For each of the 6 points above, is it working, partially working, or not working? Provide specific examples from this session.

package/docs/installation.md

@@ -1,7 +1,7 @@
 # Installation
 
 Claude Recall supports macOS, Linux, Windows, and WSL.
-Memory remains fully local (SQLite), while PubNub is used for lightweight realtime event metadata.
+Memory remains fully local (SQLite).
 
 ---
 
@@ -11,7 +11,6 @@ Memory remains fully local (SQLite), while PubNub is used for lightweight realti
 |----------|---------|-------|
 | Node.js | **20+** | Required (`better-sqlite3`) |
 | Python | **3.x** | Required for Claude Code hook scripts |
-| PubNub | Included via npm | Used only for metadata events |
 | Claude Code | Latest | Required for MCP integration |
 | OS | macOS / Linux / Windows | WSL supported |
 
@@ -101,8 +100,6 @@ If using Ubuntu under WSL2:
    ```
 3. Ensure VSCode's terminal is *also* WSL.
 
-PubNub works normally under WSL since it uses outbound-only secure connections.
-
 ---
 
 ## Node 20 Requirement

package/docs/learning-loop.md

@@ -7,10 +7,9 @@ Claude Recall uses a 5-phase learning process that improves over time.
 ## 1. Pre-Action Search
 Before Claude writes or edits a file:
 
-- Hook sends metadata to PubNub
-- Agent receives event
-- Searches SQLite memory
-- Sends relevant memories back
+- Hook enforces `load_rules` call
+- MCP server searches SQLite memory
+- Returns relevant rules to Claude
 
 Claude now knows:
 - your preferences

package/docs/project-scoping.md

@@ -8,7 +8,6 @@ Claude Recall maintains a registry of all projects using it.
 
 Each project gets:
 - a unique ID
-- a PubNub presence channel
 - its own memory namespace
 - its own context directory inside `~/.claude-recall/projects`
 
@@ -30,21 +29,6 @@ No user configuration needed.
 
 ---
 
-## Presence Channel
-
-Memory Agent publishes heartbeats:
-
-```
-claude-presence:<projectId>
-```
-
-Used to ensure:
-- at most one Agent per project
-- consistent event processing
-- clean agent shutdown
-
----
-
 ## Monorepos
 
 Claude Recall:
@@ -57,7 +41,6 @@ Claude Recall:
 ## Multi-Project Workflows
 
 Switching projects inside VSCode triggers:
-- PubNub presence update
 - registry notification
 - memory namespace change
 

package/docs/quickstart.md

@@ -41,8 +41,6 @@ Claude Recall will:
 
 * capture the preference
 * store it locally in SQLite
-* route metadata via PubNub
-* evolve memory asynchronously
 * apply it the next time Claude generates tests
 
 ---

package/docs/security.md

@@ -9,7 +9,7 @@ Claude Recall is designed to be **local-first** and **privacy-safe**.
 All memory is stored in:
 
 ```
-~/.claude-recall/memories.db
+~/.claude-recall/claude-recall.db
 ```
 
 Properties:
@@ -21,42 +21,12 @@ Properties:
 
 ---
 
-# PubNub Security Model
-
-PubNub is used only as a **realtime metadata bus**.
-
-### What PubNub does NOT transmit:
-- code
-- text
-- file contents
-- prompts
-- memory content
-- embeddings
-- project data
-
-### What PubNub DOES transmit:
-- tool names
-- file paths
-- event types
-- token counts
-- memory suggestion IDs
-- agent heartbeat metadata
-
-### Why this is safe:
-- payloads are small
-- no sensitive content ever leaves machine
-- events are ephemeral
-- keys stored locally only
-- no cloud persistence
-
----
-
 # SQLite Security
 
 - file-based permissions
 - no remote access
 - ACID-compliant
-- optional encryption layer (coming soon)
+- WAL mode for concurrency
 
 ---
 
@@ -67,8 +37,8 @@ You can:
 - inspect memory
 - delete memory
 - purge memory
-- view event streams
-- stop the agent
+- view compliance stats
+- stop the MCP server
 
 Claude Recall provides full visibility.
 

package/docs/troubleshooting.md

@@ -26,43 +26,23 @@ nvm install 20
 
 ---
 
-## PubNub connection errors
-
-Symptoms:
-
-* Agent not receiving events
-* No memory suggestions
-* watch mode shows nothing
-
-Solution:
-
-* restart clamps
-* check network firewall
-* ensure project-specific keys exist in `~/.claude-recall/keys.json`
-
-PubNub uses outbound-only connections.
-
----
-
 ## Memory not updating
 
-Ensure the Memory Agent is running:
+Check MCP server status:
 
 ```bash
-npx claude-recall watch
-```
-
-Look for:
-
-```
-[agent] heartbeat ok
+npx claude-recall mcp status
 ```
 
 ---
 
 ## Hooks not firing
 
-Check `.claude/hooks/` directory exists.
+Check `.claude/hooks/` directory exists and `search_enforcer.py` is present:
+
+```bash
+npx claude-recall hooks check
+```
 
 ---
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-recall",
-  "version": "0.15.13",
+  "version": "0.15.16",
   "description": "Persistent memory for Claude Code with native Skills integration, automatic capture, failure learning, and project scoping via MCP server",
   "main": "dist/index.js",
   "bin": {
@@ -88,6 +88,7 @@
     "@anthropic-ai/sdk": "^0.39.0",
     "better-sqlite3": "^12.2.0",
     "chalk": "^5.5.0",
+    "claude-recall": "^0.15.15",
     "commander": "^12.1.0"
   }
 }