claude-recall 0.9.2 → 0.10.0

package/.claude/hooks/search_enforcer.py

@@ -0,0 +1,153 @@
+#!/usr/bin/env python3
+"""
+Minimal Search Enforcer for Claude Recall v0.9.3+
+
+Ensures memory search is performed before Write/Edit/Bash/Task operations.
+Works alongside native Claude Skills - skill teaches, hook enforces.
+
+State file: ~/.claude-recall/hook-state/{session_id}.json
+Exit codes: 0 = allow, 2 = block
+"""
+import json
+import sys
+import os
+from pathlib import Path
+from datetime import datetime
+
+STATE_DIR = Path.home() / '.claude-recall' / 'hook-state'
+SEARCH_TTL_MS = int(os.environ.get('CLAUDE_RECALL_SEARCH_TTL', 5 * 60 * 1000))  # 5 min default
+ENFORCE_MODE = os.environ.get('CLAUDE_RECALL_ENFORCE_MODE', 'block')  # block, warn, off
+
+# Tools that count as "search performed"
+SEARCH_TOOLS = [
+    'mcp__claude-recall__load_rules',
+    'mcp__claude-recall__mcp__claude-recall__load_rules',
+    'mcp__claude-recall__search',
+    'mcp__claude-recall__mcp__claude-recall__search',
+    'mcp__claude-recall__retrieve_memory',
+    'mcp__claude-recall__mcp__claude-recall__retrieve_memory',
+]
+
+# Tools that require search first
+ENFORCE_TOOLS = ['Write', 'Edit', 'Bash', 'Task']
+
+# Read-only bash commands that don't need memory search
+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',
+    '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',
+    'pytest', 'jest', 'cargo test', 'go test', 'tsc --noEmit',
+    'grep', 'rg', 'ag', 'awk', 'sed', 'sort', 'uniq', 'diff',
+    'tree', 'realpath', 'dirname', 'basename', 'date', 'env', 'echo',
+    'ps', 'top', 'df', 'du', 'free', 'uptime', 'hostname',
+]
+
+
+def get_state_file(session_id: str) -> Path:
+    safe_id = "".join(c if c.isalnum() or c in '-_' else '_' for c in session_id) or 'default'
+    return STATE_DIR / f'{safe_id}.json'
+
+
+def load_state(session_id: str) -> dict:
+    STATE_DIR.mkdir(parents=True, exist_ok=True)
+    state_file = get_state_file(session_id)
+    if state_file.exists():
+        try:
+            return json.load(open(state_file))
+        except:
+            pass
+    return {'lastSearchAt': None, 'searchQuery': None}
+
+
+def save_state(session_id: str, state: dict):
+    STATE_DIR.mkdir(parents=True, exist_ok=True)
+    try:
+        json.dump(state, open(get_state_file(session_id), 'w'), indent=2)
+    except:
+        pass
+
+
+def is_search_tool(tool_name: str) -> bool:
+    return any(s in tool_name for s in SEARCH_TOOLS)
+
+
+def is_read_only_bash(command: str) -> bool:
+    if not command:
+        return False
+    cmd = command.strip().lower()
+    # Check direct match or pipe starting with read-only
+    for ro in READ_ONLY_BASH:
+        if cmd.startswith(ro):
+            return True
+    if '|' in cmd:
+        first = cmd.split('|')[0].strip()
+        for ro in READ_ONLY_BASH:
+            if first.startswith(ro):
+                return True
+    return False
+
+
+def main():
+    if ENFORCE_MODE == 'off':
+        sys.exit(0)
+
+    try:
+        data = json.load(sys.stdin)
+    except:
+        sys.exit(0)
+
+    tool_name = data.get('tool_name', '')
+    tool_input = data.get('tool_input', {})
+    session_id = data.get('session_id', '') or 'default'
+
+    # Track search calls
+    if is_search_tool(tool_name):
+        state = load_state(session_id)
+        state['lastSearchAt'] = int(datetime.now().timestamp() * 1000)
+        state['searchQuery'] = tool_input.get('query', '')
+        save_state(session_id, state)
+        sys.exit(0)
+
+    # Only enforce on specific tools
+    if tool_name not in ENFORCE_TOOLS:
+        sys.exit(0)
+
+    # Skip read-only bash
+    if tool_name == 'Bash' and is_read_only_bash(tool_input.get('command', '')):
+        sys.exit(0)
+
+    # Check if search was recent
+    state = load_state(session_id)
+    last_search = state.get('lastSearchAt')
+
+    if last_search:
+        now = int(datetime.now().timestamp() * 1000)
+        if (now - last_search) <= SEARCH_TTL_MS:
+            sys.exit(0)
+
+    # Block or warn
+    msg = f"""
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+🔍 LOAD RULES REQUIRED before {tool_name}
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+Run: mcp__claude-recall__load_rules({{}})
+
+Or for a specific lookup:
+  mcp__claude-recall__search({{"query": "relevant keywords"}})
+
+This ensures you apply user preferences and avoid past mistakes.
+
+To disable: CLAUDE_RECALL_ENFORCE_MODE=off
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+"""
+    print(msg.strip(), file=sys.stderr)
+    sys.exit(0 if ENFORCE_MODE == 'warn' else 2)
+
+
+if __name__ == '__main__':
+    main()

package/.claude/skills/memory-management/SKILL.md

@@ -1,7 +1,7 @@
 ---
 name: memory-management
 description: Persistent memory for Claude across conversations. Use when starting any task, before writing or editing code, before making decisions, when user mentions preferences or conventions, when user corrects your work, or when completing a task that overcame challenges. Ensures Claude never repeats mistakes and always applies learned patterns.
-version: "1.0.0"
+version: "1.1.0"
 license: "MIT"
 ---
 
@@ -11,9 +11,7 @@ Persistent memory system that ensures Claude never repeats mistakes and always a
 
 ## When to Use This Skill
 
-Invoke memory search in these situations:
-
-- **Starting any task** - Check for existing patterns, preferences, past failures
+- **Starting any task** - Load rules for preferences, corrections, past failures
 - **Before writing/editing code** - Apply learned conventions and avoid past mistakes
 - **Before making architectural decisions** - Check for established patterns
 - **When user mentions preferences** - Store for future sessions
@@ -22,25 +20,30 @@ Invoke memory search in these situations:
 
 ## Key Directives
 
-1. **ALWAYS search before acting** - Call `mcp__claude-recall__search` before Write, Edit, or significant Bash operations
-2. **Apply what you find** - Use retrieved preferences, patterns, and corrections
-3. **Capture corrections immediately** - User fixes are highest priority
-4. **Store learning cycles** - When you fail then succeed, that's valuable knowledge
-5. **Never store secrets** - No API keys, passwords, tokens, or PII
+1. **ALWAYS load rules before acting** - Call `mcp__claude-recall__load_rules` before Write, Edit, or significant Bash operations
+2. **Use `search` for specific lookups** - Mid-task targeted queries ("what did we decide about auth?")
+3. **Apply what you find** - Use retrieved preferences, patterns, and corrections
+4. **Capture corrections immediately** - User fixes are highest priority
+5. **Store learning cycles** - When you fail then succeed, that's valuable knowledge
+6. **Never store secrets** - No API keys, passwords, tokens, or PII
 
 ## Quick Reference
 
-### Search (Before Every Task)
+### Load Rules (Before Every Task)
+
+```
+mcp__claude-recall__load_rules({})
+```
+
+Returns all active preferences, recent corrections, recent failures, and devops rules in one call. No query needed — deterministic and complete.
+
+### Search (For Specific Lookups)
 
 ```
-mcp__claude-recall__search({ "query": "[task] [domain] preferences patterns" })
+mcp__claude-recall__search({ "query": "authentication jwt session" })
 ```
 
-Examples:
-- Before tests: `"testing tdd framework location"`
-- Before git: `"git commit branch workflow"`
-- Before deploy: `"deploy docker build ci/cd"`
-- Before coding: `"[language] style conventions preferences"`
+Use when you need targeted information mid-task, not for task-start enforcement.
 
 ### Store (When Something Important Happens)
 
@@ -107,16 +110,33 @@ Safe to store:
 ```
 1. User: "Add user authentication"
 
-2. Search first:
-   mcp__claude-recall__search({ "query": "authentication auth jwt session preferences" })
+2. Load rules first:
+   mcp__claude-recall__load_rules({})
 
-3. Found: "We use JWT for auth, store tokens in httpOnly cookies"
+3. Response includes:
+   ## Preferences
+   - auth_method: JWT with httpOnly cookies
+   ## Corrections
+   - Never use localStorage for auth tokens
 
-4. Implement using JWT + httpOnly cookies (not sessions)
+4. Implement using JWT + httpOnly cookies (not sessions, not localStorage)
 
 5. User approves → Done (no need to store, just applied existing knowledge)
 ```
 
+### Mid-Task Specific Lookup
+
+```
+1. Working on auth, need to check a specific decision
+
+2. Search for it:
+   mcp__claude-recall__search({ "query": "oauth provider google azure" })
+
+3. Found: "We use Google OAuth, not Azure AD"
+
+4. Continue implementation with Google OAuth
+```
+
 ### User Corrects Your Work
 
 ```
@@ -150,15 +170,29 @@ Safe to store:
    })
 ```
 
+## Inline Citations
+
+When `load_rules`, `search`, or `retrieve_memory` returns memories, the response includes a `_citationDirective` instructing you to cite any memory you actually apply. When you use a retrieved memory in your work, add a brief inline note:
+
+> (applied from memory: always use httpOnly cookies for auth tokens)
+
+This gives the user visibility into which stored knowledge is influencing your decisions. Only cite memories you actually use — don't cite every memory returned.
+
+To disable citations, set the environment variable `CLAUDE_RECALL_CITE_MEMORIES=false`.
+
 ## Troubleshooting
 
+**Load rules returns nothing:**
+- This may be a new project with no history yet
+- Try `search` with broad keywords to check
+
 **Search returns nothing relevant:**
 - Broaden keywords: include domain + task + "preferences patterns"
 - This may be a new project with no history yet
 
 **Automatic capture missed something:**
 - Store it manually with appropriate type
-- Future searches will find it
+- Future loads/searches will find it
 
 **Check what's been captured:**
 ```
@@ -167,4 +201,4 @@ mcp__claude-recall__get_recent_captures({ "limit": 10 })
 
 ---
 
-**The Learning Loop**: Search → Apply → Execute → Capture outcomes → Better next time
+**The Learning Loop**: Load rules → Apply → Execute → Capture outcomes → Better next time

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

@@ -49,7 +49,6 @@ 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) {
@@ -565,24 +564,25 @@ async function main() {
             }
         }
     }
-    // Install skills and clean up old hooks (v0.9.0+ uses Skills, not hooks)
-    function installSkillsAndCleanupHooks(force = false) {
+    // Install skills + minimal enforcement hook (v0.9.3+ hybrid approach)
+    function installSkillsAndHook(force = false) {
         const cwd = process.cwd();
         const projectName = path.basename(cwd);
-        console.log('\n📦 Claude Recall v0.9.x Setup\n');
+        console.log('\n📦 Claude Recall v0.9.3+ Setup\n');
         console.log(`📍 Project: ${projectName}`);
         console.log(`📍 Directory: ${cwd}\n`);
         // Find the package directory (where claude-recall is installed)
         const packageDir = path.resolve(__dirname, '../..');
         const packageSkillsDir = path.join(packageDir, '.claude/skills');
+        const packageHooksDir = path.join(packageDir, '.claude/hooks');
         const claudeDir = path.join(cwd, '.claude');
         const hooksDir = path.join(claudeDir, 'hooks');
         const settingsPath = path.join(claudeDir, 'settings.json');
-        // === CLEANUP: Remove old hooks (v0.9.0+ doesn't use hooks) ===
+        // === CLEANUP: Remove OLD hooks (not the new search_enforcer.py) ===
         if (fs.existsSync(hooksDir)) {
             const oldHooks = [
-                'memory_enforcer.py',
-                'pre_tool_search_enforcer.py',
+                'memory_enforcer.py', // Old v0.8.x hook
+                'search_enforcer.py',
                 'mcp_tool_tracker.py',
                 'pubnub_pre_tool_hook.py',
                 'pubnub_prompt_hook.py',
@@ -597,49 +597,53 @@ async function main() {
                     removedCount++;
                 }
             }
-            // Remove hooks directory if empty
-            try {
-                const remaining = fs.readdirSync(hooksDir);
-                if (remaining.length === 0) {
-                    fs.rmdirSync(hooksDir);
-                }
-            }
-            catch (e) {
-                // Ignore
-            }
             if (removedCount > 0) {
-                console.log(`🧹 Removed ${removedCount} old hook file(s) from .claude/hooks/`);
+                console.log(`🧹 Removed ${removedCount} old hook file(s)`);
             }
         }
-        // === CLEANUP: Clear hook configuration from settings.json ===
+        // === INSTALL: New minimal search_enforcer.py ===
+        if (!fs.existsSync(hooksDir)) {
+            fs.mkdirSync(hooksDir, { recursive: true });
+        }
+        const hookSource = path.join(packageHooksDir, 'search_enforcer.py');
+        const hookDest = path.join(hooksDir, 'search_enforcer.py');
+        if (fs.existsSync(hookSource)) {
+            fs.copyFileSync(hookSource, hookDest);
+            fs.chmodSync(hookDest, 0o755);
+            console.log('✅ Installed search_enforcer.py to .claude/hooks/');
+        }
+        else {
+            console.log(`⚠️  Hook not found at: ${hookSource}`);
+        }
+        // === CONFIGURE: Update settings.json with new hook ===
         let settings = {};
         if (fs.existsSync(settingsPath)) {
             try {
                 settings = JSON.parse(fs.readFileSync(settingsPath, 'utf8'));
-                const hadHooks = settings.hooks && Object.keys(settings.hooks).length > 0;
-                // Clear hooks - v0.9.0+ uses Skills instead
-                settings.hooks = {};
-                settings.hooksVersion = '2.0.0';
-                fs.writeFileSync(settingsPath, JSON.stringify(settings, null, 2));
-                if (hadHooks) {
-                    console.log('🧹 Cleared old hook configuration from .claude/settings.json');
-                }
             }
             catch (e) {
-                // If settings.json is invalid, create fresh one
-                if (!fs.existsSync(claudeDir)) {
-                    fs.mkdirSync(claudeDir, { recursive: true });
-                }
-                fs.writeFileSync(settingsPath, JSON.stringify({ hooks: {}, hooksVersion: '2.0.0' }, null, 2));
+                settings = {};
             }
         }
-        else {
-            // Create new settings.json without hooks
-            if (!fs.existsSync(claudeDir)) {
-                fs.mkdirSync(claudeDir, { recursive: true });
-            }
-            fs.writeFileSync(settingsPath, JSON.stringify({ hooks: {}, hooksVersion: '2.0.0' }, null, 2));
+        settings.hooksVersion = '3.0.0'; // v3 = hybrid (skill + minimal hook)
+        settings.hooks = {
+            PreToolUse: [
+                {
+                    matcher: "mcp__claude-recall__.*|Write|Edit|Bash|Task",
+                    hooks: [
+                        {
+                            type: "command",
+                            command: `python3 ${hookDest}`
+                        }
+                    ]
+                }
+            ]
+        };
+        if (!fs.existsSync(claudeDir)) {
+            fs.mkdirSync(claudeDir, { recursive: true });
         }
+        fs.writeFileSync(settingsPath, JSON.stringify(settings, null, 2));
+        console.log('✅ Configured search enforcement hook');
         // === INSTALL: Copy skills directory ===
         if (fs.existsSync(packageSkillsDir)) {
             const skillsDir = path.join(claudeDir, 'skills');
@@ -650,7 +654,7 @@ async function main() {
             console.log(`⚠️  Skills not found at: ${packageSkillsDir}`);
         }
         console.log('\n✅ Setup complete!\n');
-        console.log('ℹ️  v0.9.0+ uses native Claude Skills instead of hooks.');
+        console.log('ℹ️  v0.9.3+ uses Skills (guidance) + minimal hook (enforcement).');
         console.log('Restart Claude Code to activate.\n');
     }
     // Setup command - shows activation instructions or installs skills
@@ -660,8 +664,8 @@ async function main() {
         .option('--install', 'Install skills and clean up old hooks')
         .action((options) => {
         if (options.install) {
-            // Install skills and clean up old hooks
-            installSkillsAndCleanupHooks();
+            // Install skills and enforcement hook
+            installSkillsAndHook();
         }
         else {
             // Show activation instructions
@@ -692,7 +696,7 @@ async function main() {
         .description('Clean up old hooks and install skills (v0.9.0+ migration)')
         .option('--force', 'Force overwrite existing configuration')
         .action((options) => {
-        installSkillsAndCleanupHooks(options.force || false);
+        installSkillsAndHook(options.force || false);
         process.exit(0);
     });
     // Check hooks function
@@ -792,7 +796,7 @@ async function main() {
         let searchDir = process.cwd();
         let enforcerPath = null;
         while (searchDir !== path.dirname(searchDir)) {
-            const candidate = path.join(searchDir, '.claude/hooks/pre_tool_search_enforcer.py');
+            const candidate = path.join(searchDir, '.claude/hooks/search_enforcer.py');
             if (fs.existsSync(candidate)) {
                 enforcerPath = candidate;
                 break;
@@ -800,7 +804,7 @@ async function main() {
             searchDir = path.dirname(searchDir);
         }
         if (!enforcerPath) {
-            console.log('❌ Could not find pre_tool_search_enforcer.py');
+            console.log('❌ Could not find search_enforcer.py');
             console.log('   Run: npx claude-recall repair\n');
             return;
         }
@@ -976,8 +980,6 @@ async function main() {
     project_commands_1.ProjectCommands.register(program);
     // Migration commands
     migrate_1.MigrateCommand.register(program);
-    // Hook commands (legacy, kept for backwards compatibility)
-    hook_commands_1.HookCommands.register(program);
     // Register live test command
     new live_test_1.LiveTestCommand().register(program);
     // Search command

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

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MemoryTools = void 0;
+const config_1 = require("../../services/config");
 const search_monitor_1 = require("../../services/search-monitor");
 class MemoryTools {
     constructor(memoryService, logger) {
@@ -10,6 +11,12 @@ class MemoryTools {
         this.searchMonitor = search_monitor_1.SearchMonitor.getInstance();
         this.registerTools();
     }
+    getCitationDirective() {
+        const config = config_1.ConfigService.getInstance();
+        if (config.getConfig().citations?.enabled === false)
+            return undefined;
+        return MemoryTools.CITATION_DIRECTIVE;
+    }
     // Claude-flow pattern: Validate input against schema
     validateInput(schema, input) {
         if (schema.required) {
@@ -227,6 +234,20 @@ class MemoryTools {
                     }
                 },
                 handler: this.handleGetRecentCaptures.bind(this)
+            },
+            {
+                name: 'mcp__claude-recall__load_rules',
+                description: 'Load all active rules (preferences, corrections, failures, devops) before starting work. No query needed. Use this instead of search at the start of every task.',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        projectId: {
+                            type: 'string',
+                            description: 'Optional project ID override. Defaults to current project.'
+                        }
+                    }
+                },
+                handler: this.handleLoadRules.bind(this)
             }
         ];
     }
@@ -312,6 +333,7 @@ class MemoryTools {
     async handleRetrieveMemory(input, context) {
         try {
             let { query, id, limit = 10, sortBy } = input;
+            const citationDirective = this.getCitationDirective();
             // Smart detection: Auto-detect timestamp sorting from query keywords
             if (!sortBy && query) {
                 const timeKeywords = ['recent', 'latest', 'newest', 'last', 'new'];
@@ -337,7 +359,8 @@ class MemoryTools {
                 }
                 return {
                     memories: [memory],
-                    count: 1
+                    count: 1,
+                    ...(citationDirective && { _citationDirective: citationDirective })
                 };
             }
             if (query) {
@@ -351,7 +374,8 @@ class MemoryTools {
                     })),
                     count: limitedResults.length,
                     totalFound: results.length,
-                    sortBy
+                    sortBy,
+                    ...(citationDirective && { _citationDirective: citationDirective })
                 };
             }
             // Get recent memories from context
@@ -367,7 +391,8 @@ class MemoryTools {
                     relevanceScore: r.score
                 })),
                 count: limitedResults.length,
-                sortBy
+                sortBy,
+                ...(citationDirective && { _citationDirective: citationDirective })
             };
         }
         catch (error) {
@@ -378,6 +403,7 @@ class MemoryTools {
     async handleSearch(input, context) {
         try {
             const { query, filters, limit = 20 } = input;
+            const citationDirective = this.getCitationDirective();
             if (!query) {
                 throw new Error('Query is required');
             }
@@ -431,7 +457,8 @@ class MemoryTools {
                     estimatedTokens: resultTokens,
                     estimatedTokensSaved: tokensSaved,
                     efficiency: tokensSaved > 0 ? `${Math.round((tokensSaved / (tokensSaved + resultTokens)) * 100)}%` : '0%'
-                }
+                },
+                ...(citationDirective && { _citationDirective: citationDirective })
             };
         }
         catch (error) {
@@ -648,8 +675,71 @@ class MemoryTools {
         }
         return 0.5; // Default confidence
     }
+    /**
+     * Load all active rules by category - deterministic, no query needed
+     */
+    async handleLoadRules(input, context) {
+        try {
+            const { projectId } = input;
+            const citationDirective = this.getCitationDirective();
+            const rules = this.memoryService.loadActiveRules(projectId || context.projectId);
+            // Format categorized markdown sections
+            const sections = [];
+            if (rules.preferences.length > 0) {
+                sections.push('## Preferences\n' + rules.preferences.map(m => {
+                    const val = typeof m.value === 'object' ? (m.value.content || m.value.value || JSON.stringify(m.value)) : m.value;
+                    return `- ${m.preference_key || m.key}: ${val}`;
+                }).join('\n'));
+            }
+            if (rules.corrections.length > 0) {
+                sections.push('## Corrections\n' + rules.corrections.map(m => {
+                    const val = typeof m.value === 'object' ? (m.value.content || m.value.value || JSON.stringify(m.value)) : m.value;
+                    return `- ${val}`;
+                }).join('\n'));
+            }
+            if (rules.failures.length > 0) {
+                sections.push('## Failures\n' + rules.failures.map(m => {
+                    const val = typeof m.value === 'object' ? (m.value.content || m.value.value || JSON.stringify(m.value)) : m.value;
+                    return `- ${val}`;
+                }).join('\n'));
+            }
+            if (rules.devops.length > 0) {
+                sections.push('## DevOps Rules\n' + rules.devops.map(m => {
+                    const val = typeof m.value === 'object' ? (m.value.content || m.value.value || JSON.stringify(m.value)) : m.value;
+                    return `- ${val}`;
+                }).join('\n'));
+            }
+            const totalRules = rules.preferences.length + rules.corrections.length +
+                rules.failures.length + rules.devops.length;
+            const resultTokens = this.estimateTokens([
+                ...rules.preferences, ...rules.corrections,
+                ...rules.failures, ...rules.devops
+            ]);
+            // Record to SearchMonitor so monitoring/stats still work
+            this.searchMonitor.recordSearch('load_rules', totalRules, context.sessionId, 'mcp', { tool: 'load_rules', tokenMetrics: { resultTokens, tokensSaved: totalRules > 0 ? totalRules * 200 : 0 } });
+            return {
+                rules: sections.length > 0 ? sections.join('\n\n') : 'No active rules found. This may be a new project.',
+                counts: {
+                    preferences: rules.preferences.length,
+                    corrections: rules.corrections.length,
+                    failures: rules.failures.length,
+                    devops: rules.devops.length,
+                    total: totalRules
+                },
+                summary: rules.summary,
+                ...(citationDirective && { _citationDirective: citationDirective })
+            };
+        }
+        catch (error) {
+            this.logger.error('MemoryTools', 'Failed to load rules', error);
+            throw error;
+        }
+    }
     getTools() {
         return this.tools;
     }
 }
 exports.MemoryTools = MemoryTools;
+MemoryTools.CITATION_DIRECTIVE = 'When you apply any of the above rules or memories to your work, ' +
+    'add a brief inline citation: "(applied from memory: [one-line summary])". ' +
+    'Only cite memories you actually use.';