claude-recall 0.37.0 → 0.37.1

package/.claude/hooks/search_enforcer.py

@@ -16,7 +16,29 @@ from datetime import datetime
 
 STATE_DIR = Path.home() / '.claude-recall' / 'hook-state'
 SEARCH_TTL_MS = int(os.environ.get('CLAUDE_RECALL_SEARCH_TTL', 60 * 1000))  # 1 min default (once per task)
-ENFORCE_MODE = os.environ.get('CLAUDE_RECALL_ENFORCE_MODE', 'block')  # block, warn, off
+
+
+def _resolve_enforce_mode() -> str:
+    """Enforcement mode: env var wins, then ~/.claude-recall/config.json
+    ("enforceMode"), else default 'warn'. A file-based switch is reachable
+    from inside a running session (an agent can edit config.json to escape a
+    stuck gate); an env var set before launch is not. Default is 'warn' — this
+    gate is an advisory nudge (see module docstring), so it should never
+    hard-block a session by default."""
+    env = os.environ.get('CLAUDE_RECALL_ENFORCE_MODE')
+    if env:
+        return env.strip().lower()
+    try:
+        cfg = json.load(open(Path.home() / '.claude-recall' / 'config.json'))
+        mode = cfg.get('enforceMode')
+        if mode:
+            return str(mode).strip().lower()
+    except Exception:
+        pass
+    return 'warn'
+
+
+ENFORCE_MODE = _resolve_enforce_mode()  # block, warn, off
 MAX_BLOCKS = int(os.environ.get('CLAUDE_RECALL_MAX_BLOCKS', 3))  # degrade to warn after N blocks
 
 # Tools that count as "search performed"
@@ -182,6 +204,7 @@ STALE RULES — consider reloading before {tool_name}
 
 Rules were loaded earlier but TTL expired.
 Run: mcp__claude-recall__load_rules({{}})
+(If not directly callable, ToolSearch it first — see below.)
 ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
 """
         print(msg.strip(), file=sys.stderr)
@@ -214,10 +237,14 @@ LOAD RULES REQUIRED before {tool_name} (attempt {block_count}/{MAX_BLOCKS})
 ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
 
 Run: mcp__claude-recall__load_rules({{}})
+(If that tool is not directly callable, first run
+ ToolSearch({{query:"select:mcp__claude-recall__load_rules"}}) —
+ some harnesses defer MCP tool schemas until discovered.)
 
 This ensures you apply user preferences and avoid past mistakes.
 
-To disable: CLAUDE_RECALL_ENFORCE_MODE=off
+To disable this gate: set "enforceMode":"off" in ~/.claude-recall/config.json
+(or export CLAUDE_RECALL_ENFORCE_MODE=off before launching Claude Code).
 ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
 """
     print(msg.strip(), file=sys.stderr)

package/README.md

@@ -460,7 +460,7 @@ Defaults work out of the box; tune via environment variables as needed.
 | `CLAUDE_RECALL_AUTO_CLEANUP`             | `false` | Auto-kill stale MCP processes on start (otherwise reports and exits).                                    |
 | `CLAUDE_RECALL_COMPACT_THRESHOLD`        | `10MB`  | DB size at which automatic compaction kicks in.                                                          |
 | `CLAUDE_RECALL_MAX_MEMORIES`             | `10000` | Memory-row soft cap.                                                                                     |
-| `CLAUDE_RECALL_ENFORCE_MODE`             | `on`    | Set to `off` to bypass the search-enforcer hook.                                                         |
+| `CLAUDE_RECALL_ENFORCE_MODE`             | `warn`  | `block` / `warn` / `off` for the search-enforcer hook. Env wins, else `~/.claude-recall/config.json` `"enforceMode"`, else `warn`. |
 | `CLAUDE_RECALL_LLM_TIMEOUT_MS`           | `5000`  | Timeout for hook-context LLM calls (classification, hindsight hints). Hooks fall back to regex when it fires. |
 | `CLAUDE_RECALL_STOP_DEBOUNCE_MS`         | `300000` | Debounce for the heavy Stop-hook pipeline (episodes, session extraction, promotion). `0` disables. |
 | `CLAUDE_RECALL_PROJECT_ID`               | *(cwd)*  | Pin the project scope to a fixed id, overriding working-directory detection. |

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

@@ -51,9 +51,10 @@ const hook_commands_1 = require("./commands/hook-commands");
 const kiro_commands_1 = require("./commands/kiro-commands");
 const repair_1 = require("./commands/repair");
 // v14 = add PreToolUse rule-injector + Post resolver for JITRI.
+// v15 = bound the search_enforcer PreToolUse entry with timeout: 5.
 // Bump when the hook block template changes — setup skips the settings
 // rewrite when the installed hooksVersion already matches.
-const HOOKS_VERSION = '14.0.0';
+const HOOKS_VERSION = '15.0.0';
 const parse_utils_1 = require("./parse-utils");
 const program = new commander_1.Command();
 class ClaudeRecallCLI {
@@ -1375,7 +1376,11 @@ async function main() {
                     hooks: [
                         {
                             type: "command",
-                            command: `python3 ${hookDest}`
+                            command: `python3 ${hookDest}`,
+                            // Runs before EVERY tool call (matcher .*). Bound the python3
+                            // cold start so it can't become a per-call latency tax or an
+                            // unbounded failure mode.
+                            timeout: 5
                         },
                         {
                             type: "command",

package/docs/hooks.md

@@ -58,7 +58,7 @@ Common read-only commands are exempt from enforcement:
 | Environment Variable | Default | Description |
 |---|---|---|
 | `CLAUDE_RECALL_SEARCH_TTL` | `300000` (5 min) | Milliseconds a search remains valid |
-| `CLAUDE_RECALL_ENFORCE_MODE` | `block` | `block` (exit 2), `warn` (exit 0 + stderr message), or `off` (disabled) |
+| `CLAUDE_RECALL_ENFORCE_MODE` | `warn` | `block` (exit 2), `warn` (exit 0 + stderr message), or `off` (disabled). Env wins; otherwise read from `~/.claude-recall/config.json` → `"enforceMode"`; else `warn`. The file switch is reachable from inside a running session — an env var set before launch is not. |
 
 ### Exit Codes
 

package/package.json

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

package/dist/cli/commands/live-test.js

@@ -1,245 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.LiveTestCommand = void 0;
-const live_testing_manager_1 = require("../../testing/live-testing-manager");
-const restart_continuity_1 = require("../../services/restart-continuity");
-const logging_1 = require("../../services/logging");
-class LiveTestCommand {
-    constructor() {
-        this.liveTestManager = live_testing_manager_1.LiveTestingManager.getInstance();
-        this.continuityManager = restart_continuity_1.RestartContinuityManager.getInstance();
-        this.logger = logging_1.LoggingService.getInstance();
-    }
-    register(program) {
-        const liveTestCmd = program
-            .command('live-test')
-            .description('Manage live testing with automatic restart capability');
-        // Start live testing
-        liveTestCmd
-            .command('start')
-            .description('Start a live testing session')
-            .option('-s, --scenario <scenarios...>', 'Test scenarios to run', ['memory_persistence', 'search_compliance'])
-            .option('-a, --auto-restart', 'Enable automatic restart on changes', true)
-            .option('-r, --restart-on-failure', 'Restart on test failures', true)
-            .option('-m, --max-restarts <number>', 'Maximum restart attempts', '3')
-            .option('-i, --inject-results', 'Inject test results as memories', true)
-            .action(async (options) => {
-            await this.startLiveTest(options);
-        });
-        // Check status
-        liveTestCmd
-            .command('status')
-            .description('Check live testing and continuity status')
-            .action(() => {
-            this.showStatus();
-        });
-        // Stop testing
-        liveTestCmd
-            .command('stop')
-            .description('Stop the current live testing session')
-            .action(async () => {
-            await this.stopLiveTest();
-        });
-        // Check continuity
-        liveTestCmd
-            .command('continuity')
-            .description('Show continuity state and restart information')
-            .action(() => {
-            this.showContinuity();
-        });
-        // Add checkpoint
-        liveTestCmd
-            .command('checkpoint <name>')
-            .description('Add a checkpoint for restart recovery')
-            .action((name) => {
-            this.addCheckpoint(name);
-        });
-        // Simulate restart
-        liveTestCmd
-            .command('restart')
-            .description('Simulate a restart for testing')
-            .option('-r, --reason <reason>', 'Reason for restart', 'manual_test')
-            .action((options) => {
-            this.simulateRestart(options.reason);
-        });
-    }
-    async startLiveTest(options) {
-        console.log('🚀 Starting Live Testing Session');
-        console.log('━'.repeat(50));
-        try {
-            // Parse scenarios
-            const scenarios = options.scenario.map((name) => ({
-                name,
-                params: {},
-                sessionId: `cli_${Date.now()}`
-            }));
-            // Configure live testing
-            this.liveTestManager.updateConfig({
-                autoRestart: options.autoRestart,
-                restartOnFailure: options.restartOnFailure,
-                maxRestartAttempts: parseInt(options.maxRestarts),
-                restartDelay: 2000,
-                watchFiles: [
-                    'src/hooks/**/*.sh',
-                    'src/cli/claude-recall-cli.ts',
-                    'src/services/**/*.ts'
-                ],
-                injectResults: options.injectResults
-            });
-            // Start session
-            const sessionId = await this.liveTestManager.startLiveTestSession(scenarios);
-            console.log('✅ Live testing session started');
-            console.log(`Session ID: ${sessionId}`);
-            console.log(`Scenarios: ${scenarios.map(s => s.name).join(', ')}`);
-            console.log();
-            console.log('Configuration:');
-            console.log(`  • Auto-restart: ${options.autoRestart ? 'enabled' : 'disabled'}`);
-            console.log(`  • Restart on failure: ${options.restartOnFailure ? 'enabled' : 'disabled'}`);
-            console.log(`  • Max restarts: ${options.maxRestarts}`);
-            console.log(`  • Inject results: ${options.injectResults ? 'enabled' : 'disabled'}`);
-            console.log();
-            console.log('Watching for file changes...');
-            console.log('Use "claude-recall live-test status" to check progress');
-        }
-        catch (error) {
-            console.error('❌ Failed to start live testing:', error.message);
-            process.exit(1);
-        }
-    }
-    showStatus() {
-        console.log('📊 Live Testing Status');
-        console.log('━'.repeat(50));
-        // Get live test status
-        const liveStatus = this.liveTestManager.getSessionStatus();
-        if (liveStatus.status === 'no_active_session') {
-            console.log('No active live testing session');
-        }
-        else {
-            console.log(`Session ID: ${liveStatus.sessionId}`);
-            console.log(`Status: ${this.getStatusEmoji(liveStatus.status)} ${liveStatus.status}`);
-            console.log(`Progress: ${liveStatus.testsRun}/${liveStatus.totalTests} tests`);
-            console.log(`Restart attempts: ${liveStatus.restartAttempts}`);
-            if (liveStatus.results && liveStatus.results.length > 0) {
-                console.log();
-                console.log('Test Results:');
-                liveStatus.results.forEach((result) => {
-                    const emoji = result.status === 'passed' ? '✅' : result.status === 'failed' ? '❌' : '⚠️';
-                    console.log(`  ${emoji} ${result.test}: ${result.status}`);
-                });
-            }
-        }
-        // Get continuity status
-        const continuityState = this.continuityManager.getCurrentState();
-        if (continuityState) {
-            console.log();
-            console.log('🔄 Continuity State');
-            console.log('━'.repeat(50));
-            console.log(`Session: ${continuityState.sessionId}`);
-            console.log(`Restarts: ${continuityState.restartCount}`);
-            console.log(`Test in progress: ${continuityState.testInProgress ? 'yes' : 'no'}`);
-            if (continuityState.currentTest) {
-                console.log(`Current test: ${continuityState.currentTest.name}`);
-                console.log(`Checkpoints: ${continuityState.currentTest.checkpoints.length}`);
-            }
-            if (continuityState.pendingActions.length > 0) {
-                console.log();
-                console.log(`Pending actions: ${continuityState.pendingActions.length}`);
-            }
-        }
-        // Stop monitoring to allow process to exit
-        this.continuityManager.stopMonitoring();
-    }
-    async stopLiveTest() {
-        console.log('🛑 Stopping Live Testing');
-        try {
-            await this.liveTestManager.stopLiveTestSession();
-            console.log('✅ Live testing session stopped');
-        }
-        catch (error) {
-            console.error('❌ Failed to stop live testing:', error.message);
-        }
-    }
-    showContinuity() {
-        console.log('🔄 Continuity Information');
-        console.log('━'.repeat(50));
-        const state = this.continuityManager.getCurrentState();
-        if (!state) {
-            console.log('No continuity state available');
-            return;
-        }
-        console.log('Session Information:');
-        console.log(`  • ID: ${state.sessionId}`);
-        console.log(`  • Restart count: ${state.restartCount}`);
-        console.log(`  • Last activity: ${new Date(state.lastActivity).toLocaleString()}`);
-        console.log();
-        if (state.testInProgress && state.currentTest) {
-            console.log('Current Test:');
-            console.log(`  • Name: ${state.currentTest.name}`);
-            console.log(`  • Started: ${new Date(state.currentTest.startTime).toLocaleString()}`);
-            console.log(`  • Checkpoints: ${state.currentTest.checkpoints.length}`);
-            if (state.currentTest.checkpoints.length > 0) {
-                console.log('  • Recent checkpoints:');
-                state.currentTest.checkpoints.slice(-3).forEach(cp => {
-                    console.log(`    - ${cp}`);
-                });
-            }
-        }
-        else {
-            console.log('No test currently in progress');
-        }
-        if (state.pendingActions.length > 0) {
-            console.log();
-            console.log(`Pending Actions (${state.pendingActions.length}):`);
-            state.pendingActions.forEach(action => {
-                console.log(`  • ${action.type} - ${new Date(action.timestamp).toLocaleString()}`);
-            });
-        }
-        // Stop monitoring to allow process to exit
-        this.continuityManager.stopMonitoring();
-    }
-    addCheckpoint(name) {
-        console.log('➕ Adding Checkpoint');
-        try {
-            this.continuityManager.addCheckpoint(name);
-            console.log(`✅ Checkpoint added: ${name}`);
-            const state = this.continuityManager.getCurrentState();
-            if (state?.currentTest) {
-                console.log(`Total checkpoints: ${state.currentTest.checkpoints.length}`);
-            }
-        }
-        catch (error) {
-            console.error('❌ Failed to add checkpoint:', error.message);
-        }
-        finally {
-            // Stop monitoring to allow process to exit
-            this.continuityManager.stopMonitoring();
-        }
-    }
-    simulateRestart(reason) {
-        console.log('🔄 Simulating Restart');
-        console.log('━'.repeat(50));
-        console.log(`Reason: ${reason}`);
-        console.log('Note: This simulates a restart for testing purposes');
-        console.log('In production, Claude Code would actually restart');
-        // Add restart action to continuity
-        this.continuityManager.addPendingAction('simulated_restart', {
-            reason,
-            timestamp: Date.now()
-        });
-        console.log();
-        console.log('✅ Restart simulation recorded');
-        console.log('The restart will be detected on next actual restart');
-        // Stop monitoring to allow process to exit
-        this.continuityManager.stopMonitoring();
-    }
-    getStatusEmoji(status) {
-        switch (status) {
-            case 'running': return '🏃';
-            case 'completed': return '✅';
-            case 'failed': return '❌';
-            case 'restarting': return '🔄';
-            default: return '❓';
-        }
-    }
-}
-exports.LiveTestCommand = LiveTestCommand;

package/dist/cli/commands/migrate.js

@@ -1,317 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.MigrateCommand = void 0;
-const memory_1 = require("../../services/memory");
-const fs = __importStar(require("fs"));
-const path = __importStar(require("path"));
-const os = __importStar(require("os"));
-class MigrateCommand {
-    static register(program) {
-        const migrateCmd = program
-            .command('migrate')
-            .description('Migrate from file-watcher to MCP architecture');
-        migrateCmd
-            .command('check')
-            .description('Check for existing file-watcher installation')
-            .action(async () => {
-            const migrator = new MigrateCommand();
-            await migrator.checkInstallation();
-        });
-        migrateCmd
-            .command('export')
-            .description('Export memories from current installation')
-            .option('-o, --output <path>', 'Output file path', 'claude-recall-export.json')
-            .action(async (options) => {
-            const migrator = new MigrateCommand();
-            await migrator.exportMemories(options.output);
-        });
-        migrateCmd
-            .command('import')
-            .description('Import memories from export file')
-            .argument('<file>', 'Export file to import')
-            .action(async (file) => {
-            const migrator = new MigrateCommand();
-            await migrator.importMemories(file);
-        });
-        migrateCmd
-            .command('complete')
-            .description('Complete migration process')
-            .action(async () => {
-            const migrator = new MigrateCommand();
-            await migrator.completeMigration();
-        });
-        migrateCmd
-            .command('schema')
-            .description('Migrate database schema to latest version (adds missing columns)')
-            .option('--backup', 'Create backup before migration')
-            .action(async (options) => {
-            const migrator = new MigrateCommand();
-            await migrator.migrateSchema(options.backup);
-        });
-    }
-    async checkInstallation() {
-        console.log('🔍 Checking for existing Claude Recall installation...\n');
-        const checks = {
-            database: this.checkDatabase(),
-            hooks: this.checkHooks(),
-            config: this.checkConfig()
-        };
-        if (checks.database) {
-            console.log('✅ Found existing database');
-            try {
-                const memoryService = memory_1.MemoryService.getInstance();
-                const stats = memoryService.getStats();
-                console.log(`   Contains ${stats.total} memories`);
-            }
-            catch (error) {
-                console.log('   (Unable to read memory count)');
-            }
-        }
-        else {
-            console.log('❌ No existing database found');
-        }
-        if (checks.hooks) {
-            console.log('✅ Found hook configuration in settings.json');
-        }
-        else {
-            console.log('ℹ️  No hooks configured (or using MCP already)');
-        }
-        if (checks.database || checks.hooks) {
-            console.log('\n📋 Next steps:');
-            console.log('1. Run: claude-recall migrate export');
-            console.log('2. Install MCP server: claude mcp add claude-recall claude-recall mcp start');
-            console.log('3. Run: claude-recall migrate import claude-recall-export.json');
-            console.log('4. Run: claude-recall migrate complete');
-        }
-        else {
-            console.log('\n✨ No migration needed! Set up MCP directly:');
-            console.log('   claude mcp add claude-recall claude-recall mcp start');
-        }
-    }
-    async exportMemories(outputPath) {
-        console.log('📦 Exporting memories...\n');
-        try {
-            // Access database directly for export
-            const dbPath = path.join(os.homedir(), '.claude-recall', 'claude-recall.db');
-            const { MemoryStorage } = require('../../memory/storage');
-            const storage = new MemoryStorage(dbPath);
-            const db = storage.getDatabase();
-            // Get all memories from database
-            const allMemories = db.prepare('SELECT * FROM memories').all();
-            const stats = storage.getStats();
-            const exportData = {
-                version: '0.2.0',
-                exportDate: new Date().toISOString(),
-                memories: allMemories,
-                stats: stats
-            };
-            fs.writeFileSync(outputPath, JSON.stringify(exportData, null, 2));
-            console.log(`✅ Exported ${allMemories.length} memories to ${outputPath}`);
-        }
-        catch (error) {
-            console.error('❌ Export failed:', error);
-            process.exit(1);
-        }
-    }
-    async importMemories(filePath) {
-        console.log('📥 Importing memories...\n');
-        try {
-            if (!fs.existsSync(filePath)) {
-                throw new Error(`File not found: ${filePath}`);
-            }
-            const exportData = JSON.parse(fs.readFileSync(filePath, 'utf-8'));
-            const memoryService = memory_1.MemoryService.getInstance();
-            let imported = 0;
-            for (const memory of exportData.memories) {
-                try {
-                    memoryService.store({
-                        key: memory.key || `imported_${Date.now()}_${Math.random()}`,
-                        value: memory.value,
-                        type: memory.type || 'imported',
-                        context: memory.context || {}
-                    });
-                    imported++;
-                }
-                catch (err) {
-                    console.warn(`⚠️  Failed to import memory: ${err}`);
-                }
-            }
-            console.log(`✅ Imported ${imported}/${exportData.memories.length} memories`);
-        }
-        catch (error) {
-            console.error('❌ Import failed:', error);
-            process.exit(1);
-        }
-    }
-    async completeMigration() {
-        console.log('🎯 Completing migration to MCP architecture...\n');
-        // Remove old hooks from settings.json
-        console.log('1. Cleaning up old hooks...');
-        const removed = await this.removeOldHooks();
-        if (removed) {
-            console.log('   ✅ Removed file-watcher hooks');
-        }
-        else {
-            console.log('   ℹ️  No hooks to remove');
-        }
-        // Verify MCP is working
-        console.log('\n2. Verifying MCP server...');
-        try {
-            const { execSync } = require('child_process');
-            const result = execSync('echo \'{"jsonrpc":"2.0","id":1,"method":"initialize","params":{}}\' | claude-recall mcp start', { timeout: 5000 }).toString();
-            if (result.includes('claude-recall')) {
-                console.log('   ✅ MCP server is working');
-            }
-            else {
-                throw new Error('MCP server not responding correctly');
-            }
-        }
-        catch (error) {
-            console.log('   ❌ MCP server test failed');
-            console.log('   Please ensure: claude mcp add claude-recall claude-recall mcp start');
-        }
-        console.log('\n✨ Migration complete!');
-        console.log('Claude Recall is now using the MCP architecture.');
-    }
-    checkDatabase() {
-        const dbPath = path.join(os.homedir(), '.claude-recall', 'claude-recall.db');
-        return fs.existsSync(dbPath);
-    }
-    checkHooks() {
-        // Check if settings.json has our hooks
-        const settingsPath = path.join(os.homedir(), '.claude-code', 'settings.json');
-        if (fs.existsSync(settingsPath)) {
-            const settings = JSON.parse(fs.readFileSync(settingsPath, 'utf-8'));
-            return settings.hooks && Object.keys(settings.hooks).some(k => settings.hooks[k] && settings.hooks[k].includes('claude-recall'));
-        }
-        return false;
-    }
-    checkConfig() {
-        const configPath = path.join(os.homedir(), '.claude-recall', 'config.json');
-        return fs.existsSync(configPath);
-    }
-    async removeOldHooks() {
-        const settingsPath = path.join(os.homedir(), '.claude-code', 'settings.json');
-        if (!fs.existsSync(settingsPath)) {
-            return false;
-        }
-        try {
-            const settings = JSON.parse(fs.readFileSync(settingsPath, 'utf-8'));
-            let modified = false;
-            if (settings.hooks) {
-                for (const hookName of Object.keys(settings.hooks)) {
-                    if (settings.hooks[hookName] && settings.hooks[hookName].includes('claude-recall')) {
-                        delete settings.hooks[hookName];
-                        modified = true;
-                    }
-                }
-            }
-            if (modified) {
-                fs.writeFileSync(settingsPath, JSON.stringify(settings, null, 2));
-                return true;
-            }
-        }
-        catch (error) {
-            console.error('Failed to modify settings.json:', error);
-        }
-        return false;
-    }
-    async migrateSchema(createBackup = false) {
-        console.log('📋 Migrating database schema...\n');
-        try {
-            const dbPath = path.join(os.homedir(), '.claude-recall', 'claude-recall.db');
-            if (!fs.existsSync(dbPath)) {
-                console.log('❌ Database not found. Nothing to migrate.');
-                return;
-            }
-            // Create backup if requested
-            if (createBackup) {
-                const backupPath = `${dbPath}.backup.${Date.now()}`;
-                console.log(`📦 Creating backup: ${backupPath}`);
-                fs.copyFileSync(dbPath, backupPath);
-                console.log('✅ Backup created\n');
-            }
-            // Access storage to trigger migration
-            const { MemoryStorage } = require('../../memory/storage');
-            const storage = new MemoryStorage(dbPath);
-            // Check what columns exist
-            const db = storage.getDatabase();
-            const columns = db.prepare("PRAGMA table_info(memories)").all();
-            const columnNames = columns.map((c) => c.name);
-            console.log('Current schema columns:');
-            console.log('  ' + columnNames.join(', '));
-            const hasSophistication = columnNames.includes('sophistication_level');
-            const hasScope = columnNames.includes('scope');
-            if (hasSophistication && hasScope) {
-                console.log('\n✅ Schema is already up to date!');
-                console.log('   All required columns are present.');
-            }
-            else {
-                console.log('\n📋 Schema update needed:');
-                if (!hasSophistication) {
-                    console.log('   - Missing: sophistication_level (added in v0.7.0)');
-                }
-                if (!hasScope) {
-                    console.log('   - Missing: scope (added in v0.7.2)');
-                }
-                console.log('\n⚙️  Running migration...');
-                // The migration happens automatically when MemoryStorage initializes
-                // Just force a re-init by creating a new instance
-                const { MemoryStorage: Storage2 } = require('../../memory/storage');
-                new Storage2(dbPath);
-                console.log('\n✅ Migration complete!');
-                console.log('   Database schema is now up to date.');
-            }
-            // Display stats
-            console.log('\n📊 Database stats:');
-            const stats = storage.getStats();
-            console.log(`   Total memories: ${stats.total}`);
-            if (stats.byType) {
-                console.log('   By type:');
-                for (const [type, count] of Object.entries(stats.byType)) {
-                    console.log(`     ${type}: ${count}`);
-                }
-            }
-        }
-        catch (error) {
-            console.error('\n❌ Migration failed:', error);
-            console.log('\nIf you created a backup, you can restore it manually:');
-            console.log(`  cp ~/.claude-recall/claude-recall.db.backup.* ~/.claude-recall/claude-recall.db`);
-            process.exit(1);
-        }
-    }
-}
-exports.MigrateCommand = MigrateCommand;