claude-recall 0.7.6 → 0.7.9

package/.claude/hooks/pre_tool_search_enforcer.py

@@ -0,0 +1,177 @@
+#!/usr/bin/env python3
+"""
+Pre-tool hook to enforce memory search before file operations.
+Ensures Phase 1 (Pre-Action) of the learning loop always happens.
+
+This hook intercepts tool calls and blocks execution if memory search
+wasn't performed first. It's part of Claude Recall's learning loop:
+
+Phase 1: Search memories BEFORE task (enforced by this hook)
+Phase 2: Execute with found context
+Phase 3: Capture outcome after task
+
+Exit codes:
+- 0: Allow execution (search was performed)
+- 2: Block execution (search required)
+"""
+import json
+import sys
+import subprocess
+from typing import Dict, Any, List
+
+# Tools that require memory search before execution
+SEARCH_REQUIRED_TOOLS = ['Write', 'Edit']
+
+# Tools that benefit from search but aren't strictly required
+SEARCH_RECOMMENDED_TOOLS = ['Read', 'Bash']
+
+# Keywords that indicate dangerous/important operations
+CRITICAL_BASH_KEYWORDS = ['rm', 'git', 'npm', 'build', 'test', 'deploy', 'publish']
+
+
+def should_require_search(tool_name: str, tool_input: Dict[str, Any]) -> bool:
+    """Determine if this tool call requires a memory search first."""
+    # Always require search for file creation/modification
+    if tool_name in SEARCH_REQUIRED_TOOLS:
+        return True
+
+    # Require search for critical bash commands
+    if tool_name == 'Bash':
+        command = tool_input.get('command', '')
+        if any(keyword in command.lower() for keyword in CRITICAL_BASH_KEYWORDS):
+            return True
+
+    return False
+
+
+def check_recent_search(session_id: str) -> bool:
+    """Check if memory search was performed recently in this session."""
+    if not session_id:
+        # No session ID, be permissive
+        return True
+
+    try:
+        # Call claude-recall CLI to check recent tool usage
+        result = subprocess.run(
+            ['claude-recall', 'recent-tools', '--session', session_id, '--limit', '5'],
+            capture_output=True,
+            text=True,
+            timeout=2
+        )
+
+        if result.returncode != 0:
+            # Command failed, be permissive (don't block)
+            return True
+
+        # Check if mcp__claude-recall__search was called recently
+        return 'mcp__claude-recall__search' in result.stdout
+
+    except (subprocess.TimeoutExpired, FileNotFoundError, Exception):
+        # If check fails, be permissive (don't block)
+        return True
+
+
+def generate_search_query(tool_name: str, tool_input: Dict[str, Any]) -> str:
+    """Generate suggested search query based on tool and input."""
+    queries: List[str] = []
+
+    # Extract file path if present
+    file_path = tool_input.get('file_path', '')
+    if file_path:
+        # Extract relevant keywords from path
+        parts = file_path.split('/')
+        filename = parts[-1].split('.')[0] if parts else ''
+        if filename and filename not in ['.', '..']:
+            queries.append(filename)
+
+        # Add file extension for language-specific preferences
+        if '.' in file_path:
+            ext = file_path.split('.')[-1]
+            queries.append(ext)
+
+    # Add tool-specific keywords
+    if tool_name == 'Write':
+        queries.extend(['create', 'new file'])
+    elif tool_name == 'Edit':
+        queries.extend(['update', 'modify'])
+    elif tool_name == 'Bash':
+        command = tool_input.get('command', '')
+        if 'git' in command:
+            queries.append('git')
+        if 'npm' in command or 'yarn' in command:
+            queries.append('build')
+        if 'test' in command:
+            queries.append('testing')
+
+    # Always include learning loop keywords
+    queries.extend(['preferences', 'success', 'failure', 'correction'])
+
+    # Deduplicate and limit to 8 keywords
+    seen = set()
+    unique_queries = []
+    for q in queries:
+        if q.lower() not in seen:
+            seen.add(q.lower())
+            unique_queries.append(q)
+
+    return ' '.join(unique_queries[:8])
+
+
+def main():
+    # Read JSON from stdin
+    try:
+        hook_data = json.load(sys.stdin)
+    except json.JSONDecodeError as e:
+        # If we can't parse input, be permissive
+        print(f"Warning: Failed to parse hook input: {e}", file=sys.stderr)
+        sys.exit(0)
+
+    tool_name = hook_data.get('tool_name', '')
+    tool_input = hook_data.get('tool_input', {})
+    session_id = hook_data.get('session_id', '')
+
+    # Check if this tool requires a memory search
+    if not should_require_search(tool_name, tool_input):
+        sys.exit(0)  # Allow execution
+
+    # Check if search was performed recently
+    if check_recent_search(session_id):
+        sys.exit(0)  # Search was done, allow execution
+
+    # BLOCK: Search not performed
+    search_query = generate_search_query(tool_name, tool_input)
+
+    error_msg = f"""
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+🔍 MEMORY SEARCH REQUIRED (Phase 1 - Pre-Action)
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+Before executing {tool_name}, please search memories first:
+
+  mcp__claude-recall__search("{search_query}")
+
+WHY THIS MATTERS:
+  ✓ User preferences (coding style, tools, conventions)
+  ✓ Past successes (what worked before)
+  ✓ Past failures (what to avoid)
+  ✓ Recent corrections (highest priority!)
+
+THE LEARNING LOOP:
+  1. Search memories BEFORE task  ← YOU ARE HERE (Phase 1)
+  2. Execute with found context   (Phase 2)
+  3. Capture outcome after task   (Phase 3)
+
+This ensures you never repeat yourself and apply learned patterns automatically.
+
+Suggested search query: "{search_query}"
+
+To disable this check, remove the PreToolUse hook from .claude/settings.json
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+"""
+
+    print(error_msg.strip(), file=sys.stderr)
+    sys.exit(2)  # Block tool execution
+
+
+if __name__ == '__main__':
+    main()

package/.claude/hooks/user_prompt_capture.py

@@ -0,0 +1,71 @@
+#!/usr/bin/env python3
+"""
+User prompt capture hook for Claude Recall.
+Captures user prompts and passes them to the MCP server for processing.
+
+This hook is part of Phase 3 (Post-Action) of the learning loop:
+- Captures user prompts for preference extraction
+- Logs prompt submission events
+- Enables pattern detection and learning
+
+Exit codes:
+- 0: Always allow (this hook is non-blocking)
+"""
+import json
+import sys
+import subprocess
+from typing import Dict, Any
+
+
+def capture_prompt(hook_data: Dict[str, Any]) -> None:
+    """Send prompt data to Claude Recall for processing."""
+    try:
+        # Extract prompt content
+        # The structure varies based on Claude Code version
+        prompt_content = (
+            hook_data.get('prompt', '') or
+            hook_data.get('content', '') or
+            hook_data.get('message', '')
+        )
+
+        if not prompt_content:
+            return
+
+        session_id = hook_data.get('session_id', '')
+
+        # Store prompt metadata via CLI
+        # This will be picked up by the MCP server's hook event processor
+        subprocess.run(
+            [
+                'claude-recall',
+                'capture-prompt',
+                '--session', session_id,
+                '--content', prompt_content
+            ],
+            capture_output=True,
+            text=True,
+            timeout=2
+        )
+
+    except Exception as e:
+        # Don't block on errors - this is best-effort capture
+        print(f"Warning: Prompt capture failed: {e}", file=sys.stderr)
+
+
+def main():
+    # Read JSON from stdin
+    try:
+        hook_data = json.load(sys.stdin)
+    except json.JSONDecodeError as e:
+        print(f"Warning: Failed to parse hook input: {e}", file=sys.stderr)
+        sys.exit(0)  # Always allow
+
+    # Capture the prompt (non-blocking)
+    capture_prompt(hook_data)
+
+    # Always allow prompt to proceed
+    sys.exit(0)
+
+
+if __name__ == '__main__':
+    main()

package/.claude/settings.local.json

@@ -2,7 +2,11 @@
   "permissions": {
     "allow": [
       "Bash(npm view:*)",
-      "mcp__perplexity-mcp__search"
+      "mcp__perplexity-mcp__search",
+      "Bash(npm run build:*)",
+      "Bash(git add:*)",
+      "Bash(git commit:*)",
+      "Bash(claude-recall --version)"
     ],
     "deny": [],
     "ask": []

package/README.md

@@ -20,7 +20,7 @@ Every time you start a new conversation with Claude, you're starting from scratc
 - **Categorized storage** - Organizes memories by type (preferences, project knowledge, corrections)
 - **Priority-based** - More important or frequently used memories are prioritized
 
-### ⚡ Advanced Features (v0.3.2+)
+### ⚡ Advanced Features
 - **Direct MCP calls** - Fast memory search without agent overhead (milliseconds)
 - **Comprehensive search** - Single search finds preferences, successes, failures, and corrections
 - **Outcome capture** - Stores what worked and what didn't for future learning
@@ -28,7 +28,7 @@ Every time you start a new conversation with Claude, you're starting from scratc
 - **Optional agent** - Advanced context-manager agent available for complex workflows
 - **Correction priority** - User corrections given highest priority (never repeat mistakes)
 
-### 🧠 Intelligence & Evolution (v0.7.0+)
+### 🧠 Intelligence & Evolution
 - **Sophistication tracking** - Measures agent progression from basic tool use to compositional reasoning
 - **Failure learning** - Captures what failed, why it failed, and what should be done instead (counterfactual reasoning)
 - **Evolution metrics** - View progression score, confidence trends, and failure rates over time
@@ -61,7 +61,7 @@ npm install claude-recall
 
 **After installation, verify:**
 ```bash
-npx claude-recall --version   # Should show 0.3.3 or later
+npx claude-recall --version   # Should show installed version
 ```
 
 ### Why Local Over Global?
@@ -96,22 +96,38 @@ Claude Recall works on **Windows, Linux, and macOS**. Native binaries (SQLite) c
 
 **WSL Users - Special Case:**
 
-If you use **both Windows and WSL** for the same project (e.g., Electron app runs on Windows, but Claude Code runs in WSL):
+If you use **both Windows and WSL** for the same project (e.g., Electron app runs on Windows, but you use WSL):
 
 **Problem**: Installing locally creates Windows binaries, but WSL needs Linux binaries → "invalid ELF header" errors.
 
-**Solution**: Install globally in WSL only:
+**Solution**: Use WSL-specific local installation:
 ```bash
-# From WSL:
-npm install -g claude-recall
+# From WSL, in your project directory:
+cd /path/to/your-project
+npm install claude-recall
 
-# Verify:
-claude-recall --version
+# This installs Linux binaries AND hook scripts
+# MCP server configured in ~/.claude.json works for all projects
 ```
 
-**Important**: Global installation does NOT affect project-specific memory scoping! See [How Project Scoping Works](#how-project-scoping-works-installation-location) below.
+**Why this works**:
+- WSL gets Linux binaries (no ELF errors)
+- Hooks installed to project's `.claude/hooks/` (automatic memory search enforcement works)
+- MCP server in `~/.claude.json` is global (works everywhere)
+- Memory database `~/.claude-recall/` is global (shared across projects)
+
+**Alternative (NOT recommended)**: If you absolutely need global installation:
+```bash
+npm install -g claude-recall
+
+# ⚠️ WARNING: You MUST manually install hooks to each project:
+cd your-project
+mkdir -p .claude/hooks
+cp $(npm root -g)/claude-recall/.claude/hooks/* .claude/hooks/
+cp $(npm root -g)/claude-recall/.claude/settings.json .claude/settings.json
+```
 
-**Everyone else:** Both local and global work, but local is still recommended for the benefits above.
+This manual approach loses automatic setup and team sharing via `package.json`.
 
 ## Updating Claude Recall
 
@@ -136,50 +152,119 @@ npm install -g claude-recall@latest
 
 **Note:** MCP server configuration in `~/.claude.json` persists across updates. You only need to update the package.
 
-### Schema Migration (v0.7.6+)
+### Database Migration
 
-**Automatic Migration:**
+Claude Recall automatically migrates your database schema when updating. See [CHANGELOG.md](CHANGELOG.md) for version-specific migration notes if upgrading from older versions.
 
-Starting with v0.7.6, Claude Recall automatically migrates your database schema when needed. The first time you run any command after upgrading, missing columns will be added automatically.
+### Automatic Memory Search Enforcement
 
-**What Gets Migrated:**
-- `sophistication_level` column (added in v0.7.0)
-- `scope` column (added in v0.7.2)
+**How It Works:**
+
+Claude Recall uses **Claude Code hooks** to automatically enforce the learning loop workflow. This ensures memories are searched BEFORE executing file operations (Phase 1 - Pre-Action).
 
-You'll see console messages like:
+**The Learning Loop:**
 ```
-📋 Migrating database schema: Adding scope column...
-✅ Added scope column
+Phase 1: Search memories BEFORE task  ← Enforced by PreToolUse hook
+Phase 2: Execute with found context
+Phase 3: Capture outcome after task   ← Handled by UserPromptSubmit hook
 ```
 
-**Manual Migration (Optional):**
+**How It Works:**
 
-If you prefer to run the migration explicitly:
+When you `npm install claude-recall`, the installer automatically:
+1. Creates `.claude/hooks/` directory in your project
+2. Installs two Python hook scripts:
+   - `pre_tool_search_enforcer.py` - Blocks Write/Edit until memory search is performed
+   - `user_prompt_capture.py` - Captures prompts for preference extraction
+3. Configures `.claude/settings.json` with hook bindings
 
-```bash
-# Check current schema and migrate if needed
-npx claude-recall migrate schema
+**Hook Behavior:**
 
-# Create backup before migration
-npx claude-recall migrate schema --backup
+When Claude Code tries to create or edit files without searching memories first:
 ```
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+🔍 MEMORY SEARCH REQUIRED (Phase 1 - Pre-Action)
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
 
-**Troubleshooting Schema Errors:**
+Before executing Write, please search memories first:
 
-If you see errors like:
-- `"no such column: scope"`
-- `"no such column: sophistication_level"`
+  mcp__claude-recall__search("filename create preferences success failure correction")
 
-Run the manual migration:
-```bash
-npx claude-recall migrate schema --backup
+WHY THIS MATTERS:
+  ✓ User preferences (coding style, tools, conventions)
+  ✓ Past successes (what worked before)
+  ✓ Past failures (what to avoid)
+  ✓ Recent corrections (highest priority!)
+
+Suggested search query: "filename create preferences success failure correction"
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+```
+
+The tool execution is **blocked** until Claude Code performs the search.
+
+**Benefits:**
+- ✅ **Enforces Phase 1** - Ensures memories are searched before actions
+- ✅ **Prevents repetition** - User never has to repeat preferences
+- ✅ **Educational** - Teaches Claude Code the learning loop
+- ✅ **Smart blocking** - Only blocks file creation/modification, not reads
+- ✅ **Session-aware** - One search covers multiple subsequent operations
+
+**Configuration:**
+
+Hooks are configured in `.claude/settings.json`:
+
+```json
+{
+  "hooks": {
+    "PreToolUse": [
+      {
+        "matcher": "Write|Edit",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "python3 .claude/hooks/pre_tool_search_enforcer.py"
+          }
+        ]
+      }
+    ],
+    "UserPromptSubmit": [
+      {
+        "hooks": [
+          {
+            "type": "command",
+            "command": "python3 .claude/hooks/user_prompt_capture.py"
+          }
+        ]
+      }
+    ]
+  }
+}
+```
+
+**Disabling Hooks:**
+
+If you want to disable enforcement (not recommended):
+
+```json
+{
+  "hooks": {}
+}
 ```
 
-This will:
-1. Create a backup of your database (if `--backup` flag used)
-2. Add any missing columns
-3. Create necessary indexes
-4. Verify the migration succeeded
+Or remove specific hooks from the `hooks` object.
+
+**Requirements:**
+- Python 3 must be available (pre-installed on most systems)
+- Hook scripts are installed automatically during `npm install`
+- Works with Claude Code CLI hooks system
+
+**Troubleshooting:**
+
+If hooks aren't working:
+1. Check Python is available: `python3 --version`
+2. Verify hooks are installed: `ls .claude/hooks/`
+3. Check configuration: `cat .claude/settings.json`
+4. Reinstall: `npm install claude-recall --force`
 
 ## Verifying Claude Recall is Working
 
@@ -263,7 +348,7 @@ You: "No, put scripts in scripts/ directory not root"
 Next time: Search finds correction and applies automatically
 ```
 
-## Claude Code Skills Integration (v0.5.0+)
+## Claude Code Skills Integration
 
 Claude Recall now integrates with **Claude Code Skills** for better LLM compliance and automatic memory management.
 
@@ -457,7 +542,7 @@ npx claude-recall store "I prefer TypeScript with strict mode"
 npx claude-recall store "Use PostgreSQL" --type project-knowledge
 ```
 
-### Intelligence & Evolution (v0.7.0+)
+### Intelligence & Evolution
 
 **View memory evolution and sophistication metrics:**
 ```bash
@@ -536,7 +621,7 @@ npx claude-recall clear --force                 # Clear everything (requires --f
 **What are MCP commands?**
 The MCP (Model Context Protocol) server is how Claude Code communicates with Claude Recall. When you install claude-recall, it automatically configures `~/.claude.json` to start the MCP server.
 
-**Process Management (v0.7.4+):**
+**Process Management:**
 ```bash
 # Start/stop
 npx claude-recall mcp start              # Start MCP server (auto-started by Claude Code)
@@ -576,7 +661,7 @@ npx claude-recall test-memory-search           # Test if Claude searches before
 
 **Migration:**
 ```bash
-# Database schema migration (v0.7.6+)
+# Database schema migration
 npx claude-recall migrate schema                # Migrate database schema (automatic)
 npx claude-recall migrate schema --backup       # Create backup before migration
 
@@ -591,7 +676,7 @@ All commands support:
 - `--config <path>` - Use custom config file
 - `-h, --help` - Show help for any command
 
-## Project Management (v0.7.5+)
+## Project Management
 
 Claude Recall maintains a **project registry** to track all projects using it, enabling better organization and visibility across multiple projects.
 
@@ -683,7 +768,7 @@ Format:
 
 **Note**: The registry is separate from your memory database. Cleaning the registry does NOT affect your stored memories.
 
-## Project Scoping (v0.7.2+)
+## Project Scoping
 
 Claude Recall now supports **project-specific memory isolation** while keeping universal preferences available everywhere.
 

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

@@ -49,6 +49,7 @@ const queue_integration_1 = require("../services/queue-integration");
 const memory_evolution_1 = require("../services/memory-evolution");
 const mcp_commands_1 = require("./commands/mcp-commands");
 const project_commands_1 = require("./commands/project-commands");
+const hook_commands_1 = require("./commands/hook-commands");
 const program = new commander_1.Command();
 class ClaudeRecallCLI {
     constructor(options) {
@@ -617,6 +618,8 @@ async function main() {
     project_commands_1.ProjectCommands.register(program);
     // Migration commands
     migrate_1.MigrateCommand.register(program);
+    // Hook commands (used by Claude Code hooks)
+    hook_commands_1.HookCommands.register(program);
     // Register live test command
     new live_test_1.LiveTestCommand().register(program);
     // Search command

package/dist/cli/commands/hook-commands.js

@@ -0,0 +1,99 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HookCommands = void 0;
+const memory_1 = require("../../services/memory");
+/**
+ * Hook-related CLI commands for Claude Code integration
+ * These commands are called by hook scripts to interact with Claude Recall
+ */
+class HookCommands {
+    static register(program) {
+        const hookCmd = program
+            .command('recent-tools')
+            .description('Get recent tool usage for session (used by PreToolUse hook)')
+            .option('-s, --session <sessionId>', 'Session ID to check')
+            .option('-l, --limit <number>', 'Maximum number of recent tools to return', '10')
+            .action(async (options) => {
+            await HookCommands.recentTools(options.session, parseInt(options.limit));
+        });
+        program
+            .command('capture-prompt')
+            .description('Capture user prompt for processing (used by UserPromptSubmit hook)')
+            .option('-s, --session <sessionId>', 'Session ID')
+            .option('-c, --content <content>', 'Prompt content')
+            .action(async (options) => {
+            await HookCommands.capturePrompt(options.session, options.content);
+        });
+    }
+    /**
+     * Get recent tool usage for a session
+     * Used by PreToolUse hook to check if memory search was performed
+     */
+    static async recentTools(sessionId, limit) {
+        try {
+            if (!sessionId) {
+                console.log(JSON.stringify({ error: 'Session ID required' }));
+                return;
+            }
+            const memoryService = memory_1.MemoryService.getInstance();
+            // Search for recent tool-use memories in this session
+            const memories = memoryService.search(`session:${sessionId} tool-use`);
+            // Get the most recent entries
+            const recentTools = memories
+                .filter(m => m.type === 'tool-use')
+                .sort((a, b) => (b.timestamp || 0) - (a.timestamp || 0))
+                .slice(0, limit)
+                .map(m => ({
+                tool: m.key,
+                timestamp: m.timestamp,
+                // Include mcp__claude-recall__search in the key for detection
+                toolName: m.key.split(':')[0] || m.key
+            }));
+            // Output as newline-separated tool names (easier for shell scripts to parse)
+            if (recentTools.length > 0) {
+                console.log(recentTools.map(t => t.toolName).join('\n'));
+            }
+        }
+        catch (error) {
+            console.error(`Error retrieving recent tools: ${error}`);
+            process.exit(1);
+        }
+    }
+    /**
+     * Capture user prompt for processing
+     * Used by UserPromptSubmit hook to enable preference extraction
+     */
+    static async capturePrompt(sessionId, content) {
+        try {
+            if (!content) {
+                // No content to capture
+                return;
+            }
+            const memoryService = memory_1.MemoryService.getInstance();
+            // Store prompt as a special memory type for later processing
+            // This will be picked up by the queue system and processed asynchronously
+            memoryService.store({
+                key: `prompt:${sessionId}:${Date.now()}`,
+                value: {
+                    content,
+                    sessionId,
+                    capturedAt: Date.now(),
+                    source: 'hook:UserPromptSubmit'
+                },
+                type: 'prompt-capture',
+                context: {
+                    sessionId,
+                    timestamp: Date.now(),
+                    tool: 'UserPromptSubmit'
+                }
+            });
+            // Note: Preference extraction happens asynchronously via the queue system
+            // The HookEventProcessor will process this prompt
+        }
+        catch (error) {
+            // Don't fail the hook - this is best-effort
+            console.error(`Warning: Prompt capture failed: ${error}`);
+        }
+    }
+}
+exports.HookCommands = HookCommands;

package/dist/services/queue-api.js

@@ -391,18 +391,20 @@ class HookEventProcessor extends queue_system_1.QueueProcessor {
                 });
             }
         }
-        // Also run legacy pattern detection as fallback
-        const { PatternService } = await Promise.resolve().then(() => __importStar(require('./pattern-service')));
-        const patternService = PatternService.getInstance();
-        const patterns = patternService.analyzePrompt(promptContent);
-        if (patterns) {
-            memoryService.store({
-                key: `pattern-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`,
-                value: patterns,
-                type: 'detected-pattern',
-                context: payload.context || {}
-            });
-        }
+        // Pattern detection kept for PreferenceExtractor, but storage disabled (v0.7.7)
+        // These detected-pattern memories were system-generated noise with no retrieval/utility
+        // const { PatternService } = await import('./pattern-service');
+        // const patternService = PatternService.getInstance();
+        // const patterns = patternService.analyzePrompt(promptContent);
+        //
+        // if (patterns) {
+        //   memoryService.store({
+        //     key: `pattern-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`,
+        //     value: patterns,
+        //     type: 'detected-pattern',
+        //     context: payload.context || {}
+        //   });
+        // }
     }
     async processClaudeResponseEvent(payload) {
         // Process Claude's response for pattern detection and learning
@@ -410,17 +412,19 @@ class HookEventProcessor extends queue_system_1.QueueProcessor {
         const patternService = PatternService.getInstance();
         // Analyze the response for patterns
         const patterns = patternService.analyzePrompt(payload.content);
-        // Store the analyzed patterns if they exist
-        if (patterns) {
-            const { MemoryService } = await Promise.resolve().then(() => __importStar(require('./memory')));
-            const memoryService = MemoryService.getInstance();
-            memoryService.store({
-                key: `response-pattern-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`,
-                value: patterns,
-                type: 'response-pattern',
-                context: payload.context || {}
-            });
-        }
+        // Pattern detection kept for PreferenceExtractor, but storage disabled (v0.7.7)
+        // These response-pattern memories were system-generated noise with no retrieval/utility
+        // if (patterns) {
+        //   const { MemoryService } = await import('./memory');
+        //   const memoryService = MemoryService.getInstance();
+        //
+        //   memoryService.store({
+        //     key: `response-pattern-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`,
+        //     value: patterns,
+        //     type: 'response-pattern',
+        //     context: payload.context || {}
+        //   });
+        // }
     }
 }
 /**
@@ -539,16 +543,18 @@ class PatternDetectionProcessor extends queue_system_1.QueueProcessor {
         const patternService = PatternService.getInstance();
         // Analyze the content for patterns
         const patterns = patternService.analyzePrompt(message.payload.content);
-        // Store the analyzed patterns if they exist
-        if (patterns) {
-            const { MemoryService } = await Promise.resolve().then(() => __importStar(require('./memory')));
-            const memoryService = MemoryService.getInstance();
-            memoryService.store({
-                key: `pattern-detection-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`,
-                value: patterns,
-                type: 'pattern-analysis',
-                context: message.payload.context || {}
-            });
-        }
+        // Pattern detection is kept for PreferenceExtractor, but storage disabled (v0.7.7)
+        // These pattern-analysis memories were system-generated noise with no retrieval/utility
+        // if (patterns) {
+        //   const { MemoryService } = await import('./memory');
+        //   const memoryService = MemoryService.getInstance();
+        //
+        //   memoryService.store({
+        //     key: `pattern-detection-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`,
+        //     value: patterns,
+        //     type: 'pattern-analysis',
+        //     context: message.payload.context || {}
+        //   });
+        // }
     }
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "claude-recall",
-  "version": "0.7.6",
-  "description": "Persistent memory for Claude Code with automatic capture, failure learning, sophistication tracking, project scoping, project registry, and automatic schema migration via MCP server",
+  "version": "0.7.9",
+  "description": "Persistent memory for Claude Code with automatic capture, failure learning, sophistication tracking, project scoping, project registry, automatic schema migration, noise reduction, and enforced pre-action memory search via MCP server and hooks",
   "main": "dist/index.js",
   "bin": {
     "claude-recall": "dist/cli/claude-recall-cli.js"

package/scripts/postinstall.js

@@ -103,6 +103,87 @@ try {
     console.log('⚠️  Failed to register project (non-fatal):', error.message);
   }
 
+  // Install hook scripts to .claude/hooks/ directory
+  try {
+    const cwd = process.cwd();
+    const projectName = path.basename(cwd);
+
+    // Only install hooks for actual projects (not in claude-recall itself or node_modules)
+    if (projectName !== 'claude-recall' && !cwd.includes('node_modules/.pnpm') && !cwd.includes('node_modules/claude-recall')) {
+      const claudeDir = path.join(cwd, '.claude');
+      const hooksDir = path.join(claudeDir, 'hooks');
+
+      // Create .claude/hooks directory
+      if (!fs.existsSync(hooksDir)) {
+        fs.mkdirSync(hooksDir, { recursive: true });
+      }
+
+      // Copy hook scripts from package
+      const packageHooksDir = path.join(__dirname, '../.claude/hooks');
+      const hookScripts = [
+        'pre_tool_search_enforcer.py',
+        'user_prompt_capture.py'
+      ];
+
+      for (const script of hookScripts) {
+        const source = path.join(packageHooksDir, script);
+        const dest = path.join(hooksDir, script);
+
+        if (fs.existsSync(source)) {
+          fs.copyFileSync(source, dest);
+          // Make executable
+          fs.chmodSync(dest, 0o755);
+        }
+      }
+
+      console.log('✅ Installed hook scripts to .claude/hooks/');
+
+      // Create or update .claude/settings.json with hook configuration
+      const settingsPath = path.join(claudeDir, 'settings.json');
+      let settings = {};
+
+      if (fs.existsSync(settingsPath)) {
+        const settingsContent = fs.readFileSync(settingsPath, 'utf8');
+        settings = JSON.parse(settingsContent);
+      }
+
+      // Add hook configuration if not already present
+      if (!settings.hooks) {
+        settings.hooks = {
+          PreToolUse: [
+            {
+              matcher: "Write|Edit",
+              hooks: [
+                {
+                  type: "command",
+                  command: "python3 .claude/hooks/pre_tool_search_enforcer.py"
+                }
+              ]
+            }
+          ],
+          UserPromptSubmit: [
+            {
+              hooks: [
+                {
+                  type: "command",
+                  command: "python3 .claude/hooks/user_prompt_capture.py"
+                }
+              ]
+            }
+          ]
+        };
+
+        fs.writeFileSync(settingsPath, JSON.stringify(settings, null, 2));
+        console.log('✅ Configured hooks in .claude/settings.json');
+        console.log('   → PreToolUse: Enforces memory search before file operations');
+        console.log('   → UserPromptSubmit: Captures prompts for preference extraction');
+      }
+    }
+  } catch (error) {
+    // Don't fail installation if hook setup fails
+    console.log('⚠️  Failed to install hooks (non-fatal):', error.message);
+  }
+
   console.log('\n📝 Installation complete!');
   console.log('   Claude Recall MCP server is now configured.');
   console.log('   Restart your terminal to activate the memory system.');