claude-recall 0.26.0 → 0.27.0

package/.claude/hooks/search_enforcer.py

@@ -36,8 +36,13 @@ PASSTHROUGH_TOOLS = [
     'AskUserQuestion',                        # User interaction
 ]
 
-# Read-only bash commands that don't need memory search
-READ_ONLY_BASH = [
+# Bash command prefixes exempt from the load-rules gate. NOT all read-only:
+# alongside inspection commands, routine dev-workflow commands (git commit,
+# npm test, ...) are deliberately exempt — the gate exists to get rules loaded
+# before Claude starts shaping code, and blocking mid-workflow git/npm calls
+# adds friction without a safety benefit. This is an advisory nudge, not a
+# security boundary.
+EXEMPT_BASH_PREFIXES = [
     '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',
@@ -67,7 +72,7 @@ def load_state(session_id: str) -> dict:
     if state_file.exists():
         try:
             return json.load(open(state_file))
-        except:
+        except Exception:
             pass
     return {'lastSearchAt': None, 'searchQuery': None}
 
@@ -76,7 +81,7 @@ 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:
+    except Exception:
         pass
 
 
@@ -84,18 +89,26 @@ 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:
+def _has_command_prefix(cmd: str, prefix: str) -> bool:
+    """Word-boundary prefix match: 'cat foo' matches 'cat', but
+    'catastrophic-script.sh' and 'envsubst' do not match 'cat'/'env'."""
+    if not cmd.startswith(prefix):
+        return False
+    rest = cmd[len(prefix):]
+    return rest == '' or rest[0] in ' \t;|&'
+
+
+def is_exempt_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
+    # Check direct match, or the first segment of a pipeline
+    candidates = [cmd]
     if '|' in cmd:
-        first = cmd.split('|')[0].strip()
-        for ro in READ_ONLY_BASH:
-            if first.startswith(ro):
+        candidates.append(cmd.split('|')[0].strip())
+    for candidate in candidates:
+        for prefix in EXEMPT_BASH_PREFIXES:
+            if _has_command_prefix(candidate, prefix):
                 return True
     return False
 
@@ -106,7 +119,7 @@ def main():
 
     try:
         data = json.load(sys.stdin)
-    except:
+    except Exception:
         sys.exit(0)
 
     tool_name = data.get('tool_name', '')
@@ -139,14 +152,20 @@ def main():
     if not last_search:
         if tool_name not in ENFORCE_TOOLS:
             sys.exit(0)
-        # Mutation tool on first call — fall through to blocking logic below.
+        # Exempt bash passes even before rules are loaded — previously this
+        # exemption only existed on the post-load branch, so the very first
+        # `git status`/`ls` of a session was hard-blocked up to MAX_BLOCKS
+        # times, contradicting the "read-only exploration passes freely" rule.
+        if tool_name == 'Bash' and is_exempt_bash(tool_input.get('command', '')):
+            sys.exit(0)
+        # Other mutation tool on first call — fall through to blocking logic below.
     else:
         # Rules loaded at least once — only enforce on mutation 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', '')):
+        # Skip exempt bash
+        if tool_name == 'Bash' and is_exempt_bash(tool_input.get('command', '')):
             sys.exit(0)
 
     if last_search:

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

@@ -49,6 +49,11 @@ 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 repair_1 = require("./commands/repair");
+// v14 = add PreToolUse rule-injector + Post resolver for JITRI.
+// 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 parse_utils_1 = require("./parse-utils");
 const program = new commander_1.Command();
 class ClaudeRecallCLI {
     constructor(options) {
@@ -232,7 +237,7 @@ class ClaudeRecallCLI {
         // Sort by timestamp (newest first)
         failures.sort((a, b) => (b.timestamp || 0) - (a.timestamp || 0));
         // Limit results
-        const limit = options.limit || 10;
+        const limit = (0, parse_utils_1.parsePositiveInt)(options.limit, 'limit', 10);
         const displayFailures = failures.slice(0, limit);
         console.log('\n❌ Failure Memories (Counterfactual Learning)\n');
         console.log(`Found ${failures.length} failures (showing ${displayFailures.length})\n`);
@@ -241,9 +246,20 @@ class ClaudeRecallCLI {
             return;
         }
         displayFailures.forEach((failure, index) => {
-            const value = typeof failure.value === 'string'
-                ? JSON.parse(failure.value)
-                : failure.value;
+            // One malformed row must not crash the whole listing — fall back to the
+            // raw string as content
+            let value;
+            if (typeof failure.value === 'string') {
+                try {
+                    value = JSON.parse(failure.value);
+                }
+                catch {
+                    value = { content: failure.value };
+                }
+            }
+            else {
+                value = failure.value;
+            }
             const content = value.content || value;
             console.log(`${index + 1}. ${value.title || 'Untitled Failure'}`);
             console.log(`   What Failed: ${content.what_failed || 'Unknown'}`);
@@ -394,10 +410,21 @@ class ClaudeRecallCLI {
         const needsInstall = current !== latest;
         if (needsInstall) {
             console.log(`\n📦 Upgrading ${current} → ${latest}...\n`);
-            // Run npm install -g, streaming output so the user sees progress / errors live
+            // Run npm install -g, streaming output so the user sees progress / errors live.
+            // shell: true on Windows — npm is npm.cmd there and a bare spawnSync ENOENTs.
             const install = spawnSync('npm', ['install', '-g', 'claude-recall@latest'], {
                 stdio: 'inherit',
+                shell: process.platform === 'win32',
             });
+            if (install.error && install.error.code === 'ENOENT') {
+                // spawn failed before npm ever ran — the EACCES advice below would be
+                // misleading here (previous behavior: status === null !== 0 fell
+                // through to the "sudo npm install" remediation for a missing npm)
+                console.error('\n❌ npm not found on PATH.');
+                console.error('\nInstall Node.js (which includes npm) ≥ 20.19, or fix your PATH, then re-run:');
+                console.error('  claude-recall upgrade');
+                process.exit(1);
+            }
             if (install.status !== 0) {
                 // npm prints its own error — add the practical remediation on top
                 console.error('\n❌ Install failed.');
@@ -534,7 +561,7 @@ class ClaudeRecallCLI {
      * Show outcome-aware learning status: episodes, outcome events, candidate lessons, memory stats
      */
     showOutcomes(options) {
-        const limit = options.limit || 10;
+        const limit = (0, parse_utils_1.parsePositiveInt)(options.limit, 'limit', 10);
         const section = options.section;
         const db = this.memoryService.getDatabase();
         // Check if outcome tables exist
@@ -619,7 +646,7 @@ class ClaudeRecallCLI {
      * Search memories by query
      */
     search(query, options) {
-        const limit = options.limit || 10;
+        const limit = (0, parse_utils_1.parsePositiveInt)(options.limit, 'limit', 10);
         // Determine search scope
         let results;
         if (options.global) {
@@ -709,7 +736,7 @@ class ClaudeRecallCLI {
     /**
      * Import memories from a file
      */
-    async import(inputPath) {
+    async import(inputPath, options = {}) {
         try {
             if (!fs.existsSync(inputPath)) {
                 console.error(`❌ File not found: ${inputPath}`);
@@ -724,11 +751,19 @@ class ClaudeRecallCLI {
             let imported = 0;
             for (const memory of data.memories) {
                 try {
+                    // Preserve each memory's original scoping. Exported rows carry
+                    // project_id/scope as columns (not inside context) — the previous
+                    // `context: memory.context || {}` dropped them, silently rescoping
+                    // every imported memory to the CURRENT project. --project overrides.
                     this.memoryService.store({
                         key: memory.key || `imported_${Date.now()}_${Math.random()}`,
                         value: memory.value,
                         type: memory.type || 'imported',
-                        context: memory.context || {}
+                        context: {
+                            ...(memory.context || {}),
+                            projectId: options.project ?? memory.project_id ?? memory.context?.projectId,
+                            scope: memory.scope ?? memory.context?.scope ?? null,
+                        }
                     });
                     imported++;
                 }
@@ -736,8 +771,8 @@ class ClaudeRecallCLI {
                     console.warn(`⚠️  Failed to import memory: ${error}`);
                 }
             }
-            console.log(`✅ Imported ${imported}/${data.memories.length} memories`);
-            this.logger.info('CLI', 'Import completed', { imported, total: data.memories.length });
+            console.log(`✅ Imported ${imported}/${data.memories.length} memories${options.project ? ` (rescoped to project: ${options.project})` : ' (original project scoping preserved)'}`);
+            this.logger.info('CLI', 'Import completed', { imported, total: data.memories.length, project: options.project });
         }
         catch (error) {
             console.error('❌ Import failed:', error);
@@ -948,7 +983,7 @@ class ClaudeRecallCLI {
     async store(content, options) {
         try {
             const type = options.type || 'preference';
-            const confidence = options.confidence || 0.8;
+            const confidence = (0, parse_utils_1.parseUnitFloat)(options.confidence, 'confidence', 0.8);
             // Parse metadata if provided
             let metadata = {};
             if (options.metadata) {
@@ -1034,8 +1069,7 @@ async function main() {
         }
     }
     // Install skills + minimal enforcement hook
-    // TODO: honor force — currently `repair --reinstall-hooks` behaves identically to `setup --install`
-    function installSkillsAndHook(_force = false) {
+    function installSkillsAndHook(force = false) {
         const cwd = process.cwd();
         const projectName = path.basename(cwd);
         console.log('\n📦 Claude Recall Setup\n');
@@ -1103,6 +1137,18 @@ async function main() {
             catch (e) {
                 settings = {};
             }
+            // Idempotent re-run: hook block already at the current version → leave
+            // settings.json untouched (no rewrite, no backup churn) but still
+            // refresh skills below. `force` (repair --reinstall-hooks) rewrites
+            // unconditionally — the recovery path for a corrupted or hand-edited
+            // block. Previously force was accepted and ignored, so the two
+            // commands behaved identically.
+            if (!force && settings.hooksVersion === HOOKS_VERSION) {
+                console.log(`✅ Hooks already at v${HOOKS_VERSION} — settings.json untouched (use \`repair --reinstall-hooks\` to force a rewrite)`);
+                installSkills(claudeDir, packageSkillsDir);
+                console.log('\n✅ Setup complete!\n');
+                return;
+            }
             const existingHooks = settings.hooks;
             const hasExistingHooks = existingHooks
                 && typeof existingHooks === 'object'
@@ -1116,11 +1162,18 @@ async function main() {
                 console.log('   from other tools that need to coexist.');
             }
         }
-        // Resolve the CLI script path so hooks use the local install instead of npx.
-        // This avoids registry lookups on every hook invocation.
+        // Prefer the portable `claude-recall` form when the binary is on PATH —
+        // absolute dist paths break on every nvm switch or prefix move, the exact
+        // failure class `repair` exists to fix (repair already treats the PATH
+        // form as canonical). Absolute path only as fallback.
+        const onPath = (0, repair_1.resolveOnPath)('claude-recall');
         const cliScript = path.join(packageDir, 'dist', 'cli', 'claude-recall-cli.js');
-        const hookCmd = `node ${cliScript} hook run`;
-        settings.hooksVersion = '14.0.0'; // v14 = add PreToolUse rule-injector + Post resolver for JITRI
+        const hookCmd = onPath ? 'claude-recall hook run' : `node ${cliScript} hook run`;
+        if (!onPath) {
+            console.log('⚠️  claude-recall not on PATH — hooks will use an absolute path (breaks if the install moves).');
+            console.log('   `npm install -g claude-recall` gives move-proof hooks; `claude-recall repair` can convert later.');
+        }
+        settings.hooksVersion = HOOKS_VERSION;
         settings.hooks = {
             SubagentStart: [
                 {
@@ -1259,7 +1312,13 @@ async function main() {
         }
         fs.writeFileSync(settingsPath, JSON.stringify(settings, null, 2));
         console.log('✅ Configured search enforcement hook');
-        // === INSTALL: Copy skills directory ===
+        installSkills(claudeDir, packageSkillsDir);
+        console.log('\n✅ Setup complete!\n');
+        console.log('ℹ️  Uses Skills (guidance) + hooks (auto-capture with LLM classification).');
+        console.log('Restart Claude Code to activate.\n');
+    }
+    // === INSTALL: Copy skills directory (idempotent overwrite) ===
+    function installSkills(claudeDir, packageSkillsDir) {
         if (fs.existsSync(packageSkillsDir)) {
             const skillsDir = path.join(claudeDir, 'skills');
             copyDirRecursive(packageSkillsDir, skillsDir);
@@ -1268,9 +1327,6 @@ async function main() {
         else {
             console.log(`⚠️  Skills not found at: ${packageSkillsDir}`);
         }
-        console.log('\n✅ Setup complete!\n');
-        console.log('ℹ️  Uses Skills (guidance) + hooks (auto-capture with LLM classification).');
-        console.log('Restart Claude Code to activate.\n');
     }
     // Setup command - shows activation instructions or installs skills
     program
@@ -1761,7 +1817,7 @@ async function main() {
         .action((query, options) => {
         const cli = new ClaudeRecallCLI(program.opts());
         cli.search(query, {
-            limit: parseInt(options.limit),
+            limit: (0, parse_utils_1.parsePositiveInt)(options.limit, 'limit', 10),
             json: options.json,
             project: options.project,
             global: options.global
@@ -1791,7 +1847,7 @@ async function main() {
         .action((options) => {
         const cli = new ClaudeRecallCLI(program.opts());
         cli.showFailures({
-            limit: parseInt(options.limit),
+            limit: (0, parse_utils_1.parsePositiveInt)(options.limit, 'limit', 10),
             project: options.project
         });
         process.exit(0);
@@ -1805,7 +1861,7 @@ async function main() {
         .action((options) => {
         const cli = new ClaudeRecallCLI(program.opts());
         cli.showOutcomes({
-            limit: parseInt(options.limit),
+            limit: (0, parse_utils_1.parsePositiveInt)(options.limit, 'limit', 10),
             section: options.section
         });
         process.exit(0);
@@ -1824,8 +1880,8 @@ async function main() {
         const cli = new ClaudeRecallCLI(program.opts());
         cli.demoteRules({
             dryRun: options.dryRun,
-            minLoads: parseInt(options.minLoads),
-            minAgeDays: parseInt(options.minAgeDays),
+            minLoads: (0, parse_utils_1.parsePositiveInt)(options.minLoads, 'min-loads', 20),
+            minAgeDays: (0, parse_utils_1.parsePositiveInt)(options.minAgeDays, 'min-age-days', 7),
         });
         process.exit(0);
     });
@@ -1846,7 +1902,7 @@ async function main() {
         const cli = new ClaudeRecallCLI(program.opts());
         cli.dedupSimilarRules({
             dryRun: options.dryRun,
-            threshold: parseFloat(options.threshold),
+            threshold: (0, parse_utils_1.parseUnitFloat)(options.threshold, 'threshold', 0.65),
         });
         process.exit(0);
     });
@@ -1887,10 +1943,11 @@ async function main() {
     // Import command
     program
         .command('import <input>')
-        .description('Import memories from file')
-        .action(async (input) => {
+        .description('Import memories from file (original project scoping preserved)')
+        .option('--project <id>', 'Rescope all imported memories to this project ID')
+        .action(async (input, options) => {
         const cli = new ClaudeRecallCLI(program.opts());
-        await cli.import(input);
+        await cli.import(input, options);
         process.exit(0);
     });
     // Clear command
@@ -1993,7 +2050,7 @@ async function main() {
         const cli = new ClaudeRecallCLI(program.opts());
         await cli.store(content, {
             type: options.type,
-            confidence: parseFloat(options.confidence),
+            confidence: (0, parse_utils_1.parseUnitFloat)(options.confidence, 'confidence', 0.8),
             metadata: options.metadata
         });
         process.exit(0);

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

@@ -173,19 +173,25 @@ class MCPCommands {
             return;
         }
         const signal = options.force ? 'SIGKILL' : 'SIGTERM';
-        console.log(`Sending ${signal} to PID ${chalk_1.default.yellow(status.pid)}...`);
+        const pid = status.pid;
+        console.log(`Sending ${signal} to PID ${chalk_1.default.yellow(pid)}...`);
         try {
-            this.processManager.killProcess(status.pid, options.force || false);
-            this.processManager.removePidFile(projectId);
-            // Give it a moment to shut down
-            await new Promise(resolve => setTimeout(resolve, 1000));
-            // Verify it stopped
-            const newStatus = this.processManager.getServerStatus(projectId);
-            if (!newStatus.isRunning) {
+            this.processManager.killProcess(pid, options.force || false);
+            // Verify death against the SAVED pid, polling up to 5s. The previous
+            // code removed the PID file first and then "verified" by re-reading it,
+            // so isRunning was always false and "stopped successfully" printed even
+            // if the process ignored SIGTERM.
+            const deadline = Date.now() + 5000;
+            while (this.processManager.isProcessRunning(pid) && Date.now() < deadline) {
+                await new Promise(resolve => setTimeout(resolve, 100));
+            }
+            if (!this.processManager.isProcessRunning(pid)) {
+                this.processManager.removePidFile(projectId);
                 console.log(chalk_1.default.green('✓ Server stopped successfully'));
             }
             else {
-                console.log(chalk_1.default.yellow('⚠ Server may still be running. Try --force flag.'));
+                // Keep the PID file — the server is still alive and tracked
+                console.log(chalk_1.default.yellow(`⚠ PID ${pid} is still running after ${signal}. Try --force flag.`));
             }
         }
         catch (error) {

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

@@ -40,6 +40,7 @@ exports.ProjectCommands = void 0;
 const project_registry_1 = require("../../services/project-registry");
 const config_1 = require("../../services/config");
 const process_manager_1 = require("../../services/process-manager");
+const parse_utils_1 = require("../parse-utils");
 const chalk_1 = __importDefault(require("chalk"));
 const path = __importStar(require("path"));
 const fs = __importStar(require("fs"));
@@ -207,6 +208,9 @@ class ProjectCommands {
             console.log(`  Version:   ${chalk_1.default.gray(entry.version)}`);
             console.log(`  Last seen: ${chalk_1.default.gray(lastSeenTime)}`);
             console.log(`  Status:    ${isRunning ? chalk_1.default.green('✓ Active (MCP running)') : chalk_1.default.gray('✗ Inactive')}`);
+            if (entry.previousPaths && entry.previousPaths.length > 0) {
+                console.log(`  ${chalk_1.default.yellow('⚠ Id collision:')} also seen at ${chalk_1.default.gray(entry.previousPaths.join(', '))} — these directories share one memory scope`);
+            }
             console.log();
         }
         console.log(chalk_1.default.gray(`Total: ${projects.length} project(s)`));
@@ -235,6 +239,13 @@ class ProjectCommands {
         console.log(`  Version:      ${chalk_1.default.gray(entry.version)}`);
         console.log(`  Registered:   ${chalk_1.default.gray(new Date(entry.registeredAt).toLocaleString())}`);
         console.log(`  Last Seen:    ${chalk_1.default.gray(new Date(entry.lastSeen).toLocaleString())} (${this.formatRelativeTime(entry.lastSeen)})`);
+        if (entry.previousPaths && entry.previousPaths.length > 0) {
+            console.log(`  ${chalk_1.default.yellow('⚠ Id collision:')} this id was also registered at:`);
+            for (const p of entry.previousPaths) {
+                console.log(`      ${chalk_1.default.gray(p)}`);
+            }
+            console.log(chalk_1.default.yellow('    Project ids are directory basenames — these directories share ONE memory scope. Rename a directory to isolate them.'));
+        }
         console.log();
         console.log(chalk_1.default.bold('MCP Server Status:'));
         console.log(`  Running:      ${status.isRunning ? chalk_1.default.green('✓ Yes') : chalk_1.default.gray('✗ No')}`);
@@ -248,7 +259,7 @@ class ProjectCommands {
      * Clean stale registry entries
      */
     async cleanRegistry(options) {
-        const daysOld = parseInt(options.days || '30', 10);
+        const daysOld = (0, parse_utils_1.parsePositiveInt)(options.days, 'days', 30);
         console.log(chalk_1.default.cyan('\n🧹 Cleaning Registry\n'));
         if (options.dryRun) {
             console.log(chalk_1.default.yellow('DRY RUN MODE - No changes will be made\n'));

package/dist/cli/parse-utils.js

@@ -0,0 +1,32 @@
+"use strict";
+/**
+ * Numeric CLI option parsing with loud failures.
+ *
+ * Bare parseInt/parseFloat on user flags produced silent nonsense:
+ * `--limit abc` → NaN → `slice(0, NaN)` → zero results with no hint why;
+ * `--confidence abc` stored NaN into the database. Invalid input now exits 2
+ * with a message naming the flag.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parsePositiveInt = parsePositiveInt;
+exports.parseUnitFloat = parseUnitFloat;
+function parsePositiveInt(value, flagName, fallback) {
+    if (value === undefined || value === null || value === '')
+        return fallback;
+    const n = Number(value);
+    if (!Number.isInteger(n) || n <= 0) {
+        console.error(`❌ Invalid --${flagName}: "${value}" (expected a positive integer)`);
+        process.exit(2);
+    }
+    return n;
+}
+function parseUnitFloat(value, flagName, fallback) {
+    if (value === undefined || value === null || value === '')
+        return fallback;
+    const n = Number(value);
+    if (!Number.isFinite(n) || n < 0 || n > 1) {
+        console.error(`❌ Invalid --${flagName}: "${value}" (expected a number between 0 and 1)`);
+        process.exit(2);
+    }
+    return n;
+}

package/dist/core/retrieval.js

@@ -72,17 +72,25 @@ class MemoryRetrieval {
             return sorted;
         }
         // Default: relevance sorting
+        // Batch-fetch usage stats and evidence counts for ALL candidates up
+        // front — the previous per-memory lookups ran 2 extra queries per
+        // candidate over an unbounded set before slicing to the top 5.
+        const statsMap = this.getMemoryStatsBatch(candidates.map(c => c.key));
+        const evidenceMap = this.getEvidenceCountBatch(candidates.map(c => c.key));
         // Score and prioritize by memory type
         const scored = candidates
             .map(memory => ({
             ...memory,
-            score: this.calculateRelevance(memory, context)
+            score: this.calculateRelevance(memory, context, statsMap.get(memory.key) ?? null, evidenceMap.get(memory.key) ?? 0)
         }))
             .sort((a, b) => {
-            // First priority: memory type (project-knowledge > preference > tool-use)
-            const typeOrder = { 'project-knowledge': 3, 'preference': 2, 'tool-use': 1 };
-            const aTypeScore = typeOrder[a.type] || 0;
-            const bTypeScore = typeOrder[b.type] || 0;
+            // First priority: memory type. Every RULE type must outrank
+            // tool-use — the previous map listed only project-knowledge and
+            // preference, so a perfectly keyword-matched correction or failure
+            // (default 0) sorted BELOW tool-use history noise and the top-5
+            // window could be entirely tool-use.
+            const aTypeScore = MemoryRetrieval.TYPE_PRIORITY[a.type] ?? 0;
+            const bTypeScore = MemoryRetrieval.TYPE_PRIORITY[b.type] ?? 0;
             if (aTypeScore !== bTypeScore) {
                 return bTypeScore - aTypeScore;
             }
@@ -92,7 +100,7 @@ class MemoryRetrieval {
         // Return top 5 most relevant memories
         return scored.slice(0, 5);
     }
-    calculateRelevance(memory, context) {
+    calculateRelevance(memory, context, stats, evidenceCount) {
         let score = memory.relevance_score || 1.0;
         // Boost for keyword matches in memory value
         if (context.keywords && context.keywords.length > 0) {
@@ -135,12 +143,10 @@ class MemoryRetrieval {
         const strength = MemoryRetrieval.computeStrength(memory);
         score *= 1 + strength * 2.0; // Up to 3x boost for max-strength memories
         // Evidence boost: promoted lessons seen multiple times
-        const evidenceCount = this.getEvidenceCount(memory);
         if (evidenceCount > 1) {
             score *= 1 + Math.min(evidenceCount, 5) * 0.15; // up to 1.75x
         }
         // Helpfulness prior: retrieved + confirmed helpful
-        const stats = this.getMemoryStats(memory.key);
         if (stats && stats.times_retrieved > 0) {
             const helpRatio = stats.times_helpful / stats.times_retrieved;
             score *= 0.8 + helpRatio * 0.4; // 0.8x to 1.2x
@@ -207,33 +213,67 @@ class MemoryRetrieval {
         const timeDecay = Math.pow(0.5, daysSinceTouch / classConfig.halfLife);
         return Math.min(signalScore * timeDecay, 1.0);
     }
-    getMemoryStats(key) {
+    /** Batch lookup — one query per 500 keys instead of one per memory. */
+    getMemoryStatsBatch(keys) {
+        const map = new Map();
+        if (keys.length === 0)
+            return map;
         try {
-            const row = this.storage.getDatabase().prepare('SELECT times_retrieved, times_helpful, last_confirmed_at FROM memory_stats WHERE memory_key = ?').get(key);
-            return row || null;
+            // Chunk to stay under SQLite's bound-variable limit
+            for (let i = 0; i < keys.length; i += 500) {
+                const chunk = keys.slice(i, i + 500);
+                const placeholders = chunk.map(() => '?').join(',');
+                const rows = this.storage.getDatabase().prepare(`SELECT memory_key, times_retrieved, times_helpful, last_confirmed_at FROM memory_stats WHERE memory_key IN (${placeholders})`).all(...chunk);
+                for (const row of rows) {
+                    map.set(row.memory_key, row);
+                }
+            }
         }
         catch {
-            return null;
+            // Outcome tables may not exist yet — stats are an optional boost
         }
+        return map;
     }
-    getEvidenceCount(memory) {
+    /** Batch lookup — one query per 500 keys instead of one per memory. */
+    getEvidenceCountBatch(keys) {
+        const map = new Map();
+        if (keys.length === 0)
+            return map;
         try {
-            const row = this.storage.getDatabase().prepare("SELECT evidence_count FROM candidate_lessons WHERE promoted_memory_key = ? AND status = 'promoted' LIMIT 1").get(memory.key);
-            return row?.evidence_count || 0;
+            for (let i = 0; i < keys.length; i += 500) {
+                const chunk = keys.slice(i, i + 500);
+                const placeholders = chunk.map(() => '?').join(',');
+                const rows = this.storage.getDatabase().prepare(`SELECT promoted_memory_key, evidence_count FROM candidate_lessons WHERE promoted_memory_key IN (${placeholders}) AND status = 'promoted'`).all(...chunk);
+                for (const row of rows) {
+                    map.set(row.promoted_memory_key, row.evidence_count || 0);
+                }
+            }
         }
         catch {
-            return 0;
+            // Outcome tables may not exist yet — evidence is an optional boost
         }
+        return map;
     }
     searchByKeyword(keyword) {
         const results = this.storage.search(keyword);
         const context = { timestamp: Date.now() };
+        const statsMap = this.getMemoryStatsBatch(results.map(r => r.key));
+        const evidenceMap = this.getEvidenceCountBatch(results.map(r => r.key));
         return results
             .map(memory => ({
             ...memory,
-            score: this.calculateRelevance(memory, context)
+            score: this.calculateRelevance(memory, context, statsMap.get(memory.key) ?? null, evidenceMap.get(memory.key) ?? 0)
         }))
             .sort((a, b) => b.score - a.score);
     }
 }
 exports.MemoryRetrieval = MemoryRetrieval;
+MemoryRetrieval.TYPE_PRIORITY = {
+    'correction': 6,
+    'project-knowledge': 5,
+    'preference': 4,
+    'devops': 3,
+    'failure': 2,
+    'tool-use': 1,
+    // unknown/imported types: 0
+};

package/dist/hooks/failure-detectors.js

@@ -17,6 +17,10 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.detectTranscriptFailures = detectTranscriptFailures;
 const shared_1 = require("./shared");
 const MAX_FAILURES = 3;
+// Tools that read but never mutate — transparent to cycle/loop detection.
+const READ_ONLY_TOOLS = new Set([
+    'Read', 'Grep', 'Glob', 'LS', 'NotebookRead', 'WebFetch', 'WebSearch', 'TodoWrite', 'TodoRead',
+]);
 // --- Detector 1: Non-zero exit codes ---
 function detectNonZeroExits(interactions, consumed) {
     const failures = [];
@@ -129,6 +133,12 @@ function detectEditTestCycles(interactions, consumed) {
             const file = ix.call.input?.file_path ?? ix.call.input?.path ?? '';
             seq.push({ type: 'edit', failed: false, file, idx: ix.call.entryIndex });
         }
+        else if (READ_ONLY_TOOLS.has(name)) {
+            // Transparent: reading/searching between an edit and a test run is how
+            // agents always work. Treating these as 'other' reset the cycle counter
+            // on every Read/Grep, so this detector could effectively never fire.
+            continue;
+        }
         else {
             seq.push({ type: 'other', failed: false, idx: ix.call.entryIndex });
         }
@@ -283,8 +293,18 @@ function detectRetryLoops(interactions, consumed) {
         const window = interactions.slice(start, start + WINDOW);
         const hashes = [];
         for (const ix of window) {
-            // Exclude Read calls — normal to read files repeatedly
-            if (ix.call.name === 'Read')
+            // Exclude read-only tools — reading/searching repeatedly is normal
+            if (READ_ONLY_TOOLS.has(ix.call.name))
+                continue;
+            // Exclude test commands — running `npm test` three times in a window is
+            // ordinary TDD, not a retry loop. A repeated call only signals a loop
+            // when the repeats FAIL, which the check below enforces for everything.
+            if (ix.call.name === 'Bash' && isTestCommand(ix.call.input?.command ?? ''))
+                continue;
+            // Only failed repeats indicate "retrying the same thing expecting a
+            // different result" — repeating a SUCCESSFUL idempotent command (git
+            // status, ls) is routine.
+            if (!ix.result?.isError)
                 continue;
             if (consumed.has(ix.call.entryIndex))
                 continue;

package/dist/hooks/llm-classifier.js

@@ -35,7 +35,7 @@ Rules:
 - "none" type should have confidence 0.0
 - extract should be a clean, imperative statement of the rule/fact (e.g. "Use tabs for indentation")
 - If the text is a question, greeting, or code block, classify as "none"`;
-const BATCH_SYSTEM_PROMPT = `You are a memory classifier for a developer tool. You will receive multiple texts separated by "---ITEM---" markers. Classify each into one of these types:
+const BATCH_SYSTEM_PROMPT = `You are a memory classifier for a developer tool. You will receive a JSON array of texts. Classify each into one of these types:
 
 - correction: User correcting a mistake ("no, use X not Y", "wrong, it should be...")
 - preference: User stating a clear, reusable directive about how they want things done going forward ("we use tabs", "always use TypeScript", "I prefer X"). Must be a rule that applies beyond this conversation. NOT observations, complaints, questions, debugging statements, or one-off instructions like "fix this" or "tell me about X"
@@ -315,7 +315,11 @@ async function classifyBatchWithLLM(texts) {
     if (!client)
         return null;
     try {
-        const joined = texts.join('\n---ITEM---\n');
+        // JSON array, not delimiter-joined text: a user message that happened to
+        // contain the old "---ITEM---" marker desynced item counts and silently
+        // dropped the entire batch to the regex fallback. JSON boundaries can't
+        // be forged by content.
+        const joined = JSON.stringify(texts);
         const response = await client.messages.create({
             model: MODEL,
             max_tokens: texts.length * 200,

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

@@ -194,8 +194,10 @@ async function handleMemoryStop(input) {
     scanForCitations(transcriptPath);
     // Scan transcript for failure signals (non-zero exits, test cycles, backtracking, etc.)
     const failures = detectAndStoreFailures(transcriptPath, episodeId);
-    // Incorporate structured tool_failure events captured by PostToolUseFailure hook
-    const toolFailures = getToolFailureEvents(outcomeStorage);
+    // Incorporate structured tool_failure events captured by PostToolUseFailure
+    // hook — scoped to THIS session so concurrent sessions (or another
+    // project's session within the hour) don't contaminate this episode
+    const toolFailures = getToolFailureEvents(outcomeStorage, input?.session_id);
     const allFailures = [...failures, ...toolFailures];
     outcomeStorage.updateEpisode(episodeId, {
         outcome_type: allFailures.length > 0 ? 'failure' : 'success',
@@ -405,9 +407,11 @@ function detectAndStoreFailures(transcriptPath, _episodeId) {
  * Convert structured tool_failure outcome events into DetectedFailure format
  * so they feed into the candidate lessons pipeline.
  */
-function getToolFailureEvents(outcomeStorage) {
+function getToolFailureEvents(outcomeStorage, sessionId) {
     try {
-        const events = outcomeStorage.getEventsByType('tool_failure', 1); // last 1 hour
+        // Session-scoped when the Stop payload carries a session_id (it always
+        // does in practice); an undefined id falls back to the raw time window.
+        const events = outcomeStorage.getEventsByType('tool_failure', 1, sessionId); // last 1 hour
         return events.slice(0, 5).map(e => ({
             signal: 'tool_failure',
             confidence: 0.8,

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

@@ -60,11 +60,15 @@ const TEST_KEY_PATTERNS = [/^Test /i, /^Session test /i, /^test_/i];
 const SECRET_PATTERNS = [/api_key/i, /token/i, /password/i, /secret/i, /credential/i, /private_key/i];
 /**
  * Derive the auto-memory directory path from a cwd.
- * Matches Claude Code's convention: ~/.claude/projects/{cwd with / replaced by -}/memory/
+ * Matches Claude Code's convention: ~/.claude/projects/{sanitized cwd}/memory/
+ * where the sanitizer replaces EVERY non-alphanumeric with '-', not just '/'.
+ * Replacing only slashes wrote to ".../projects/-home-u-my_app.v2/memory"
+ * while Claude Code reads "-home-u-my-app-v2" — the entire sync output was
+ * silently invisible for any project path containing a dot or underscore.
  */
 function deriveAutoMemoryPath(cwd, homedir) {
     const home = homedir || os.homedir();
-    const sanitized = cwd.replace(/\//g, '-');
+    const sanitized = cwd.replace(/[^a-zA-Z0-9]/g, '-');
     return path.join(home, '.claude', 'projects', sanitized, 'memory');
 }
 /**

package/dist/hooks/session-end-checkpoint-worker.js

@@ -18,7 +18,18 @@ const shared_1 = require("./shared");
 const event_processors_1 = require("../shared/event-processors");
 const config_1 = require("../services/config");
 const TRANSCRIPT_TAIL_SIZE = 30;
+// Hard deadline for the whole worker. It's a DETACHED process nothing
+// supervises — without this, a hung network connection left an orphan node
+// process (holding a DB handle) alive for as long as the LLM call dangled,
+// one per session exit. The in-process LLM timeout usually fires first; this
+// is the backstop. unref() so the timer never keeps a finished worker alive.
+const WORKER_DEADLINE_MS = 30000;
 async function handleSessionEndCheckpointWorker(input) {
+    const deadline = setTimeout(() => {
+        (0, shared_1.hookLog)('session-end-checkpoint-worker', `Deadline (${WORKER_DEADLINE_MS}ms) exceeded — exiting`);
+        process.exit(0);
+    }, WORKER_DEADLINE_MS);
+    deadline.unref();
     // Wire event-processor logs through hookLog so extractCheckpoint diagnostics
     // (LLM null, quality gate filter, save failure) end up in
     // ~/.claude-recall/hook-logs/session-end-checkpoint-worker.log instead of

package/dist/hooks/session-end-checkpoint.js

@@ -48,7 +48,16 @@ async function handleSessionEndCheckpoint(input) {
             stdio: ['pipe', 'ignore', 'ignore'],
             // Inherit cwd so getProjectId() resolves correctly in the worker
         });
+        // Async spawn failures and EPIPE (worker exits before reading stdin)
+        // surface as 'error' events — without handlers they'd be UNCAUGHT
+        // exceptions in the hook process, the one thing a hook must never throw.
+        child.on('error', (err) => {
+            (0, shared_1.hookLog)('session-end-checkpoint', `Worker spawn error: ${err?.message ?? err}`);
+        });
         if (child.stdin) {
+            child.stdin.on('error', (err) => {
+                (0, shared_1.hookLog)('session-end-checkpoint', `Worker stdin error: ${err?.message ?? err}`);
+            });
             child.stdin.write(JSON.stringify(input));
             child.stdin.end();
         }

package/dist/hooks/shared.js

@@ -58,24 +58,32 @@ const os = __importStar(require("os"));
 const memory_1 = require("../services/memory");
 const config_1 = require("../services/config");
 const llm_classifier_1 = require("./llm-classifier");
+// NOTE on confidence calibration: consumers (correction-detector, memory-stop,
+// event-processors) gate corrections/preferences/devops at >= 0.75. Any
+// pattern below that threshold can never store anything — don't add one.
+// (The previous list carried eight 0.7-confidence patterns that were silently
+// dead for exactly this reason; the weak ones — "actually", "I like",
+// "I want", "I use" — were deleted rather than promoted because they match
+// ordinary conversation far too often.)
 const CORRECTION_PATTERNS = [
     { regex: /^no[,.]?\s+(.+)/i, confidence: 0.8 },
     { regex: /^wrong[,.]?\s+(.+)/i, confidence: 0.8 },
-    { regex: /^actually[,.]?\s+(.+)/i, confidence: 0.7 },
-    { regex: /\bnever\s+(.+)/i, confidence: 0.7 },
+    { regex: /\bnever\s+(.+)/i, confidence: 0.75 },
     { regex: /\bdon'?t\s+ever\s+(.+)/i, confidence: 0.8 },
-    { regex: /\bstop\s+(doing|using|adding)\s+(.+)/i, confidence: 0.7 },
+    { regex: /\bstop\s+(doing|using|adding)\s+(.+)/i, confidence: 0.75 },
 ];
 const PREFERENCE_PATTERNS = [
     { regex: /\bremember\s+(?:that|this|to)\s+(.+)/i, confidence: 0.8 },
     { regex: /\bfrom\s+now\s+on[,.]?\s+(.+)/i, confidence: 0.8 },
     { regex: /\bgoing\s+forward[,.]?\s+(.+)/i, confidence: 0.8 },
-    { regex: /\balways\s+(.+)/i, confidence: 0.7 },
-    { regex: /\bI\s+prefer\s+(.+)/i, confidence: 0.7 },
-    { regex: /\bI\s+like\s+(.+)/i, confidence: 0.7 },
-    { regex: /\bI\s+want\s+(.+)/i, confidence: 0.7 },
-    { regex: /\bI\s+use\s+(.+)/i, confidence: 0.7 },
+    { regex: /\balways\s+(.+)/i, confidence: 0.75 },
+    { regex: /\bI\s+prefer\s+(.+)/i, confidence: 0.75 },
 ];
+// Questions are never rules ("do you remember that config file we used?" must
+// not become a stored preference), and "no ..." pleasantries are not
+// corrections ("no worries, that looks good").
+const INTERROGATIVE_START = /^(do|does|did|can|could|would|should|shall|is|are|was|were|will|have|has|what|why|how|when|where|who|which)\b/i;
+const PLEASANTRY_NO = /^no\s+(worries|problem|problems|prob|thanks|thank|rush|need|biggie|sweat|pressure)\b/i;
 // Failure, devops, and project-knowledge patterns removed — single-keyword
 // matches ("error", "git", "build") are too broad for regex. These types
 // require context that only the LLM classifier can assess. When the LLM is
@@ -94,6 +102,11 @@ function readStdin() {
  * Returns the highest-confidence match, prioritizing corrections > preferences.
  */
 function classifyContentRegex(text) {
+    const trimmed = text.trim();
+    // Interrogatives and pleasantries are conversation, not rules
+    if (trimmed.endsWith('?') || INTERROGATIVE_START.test(trimmed) || PLEASANTRY_NO.test(trimmed)) {
+        return null;
+    }
     // Priority order: correction > preference > failure > devops > project-knowledge
     for (const p of CORRECTION_PATTERNS) {
         const m = text.match(p.regex);

package/dist/hooks/tool-outcome-watcher.js

@@ -61,26 +61,6 @@ const EXIT_CODE_REGEX = /Exit code (\d+)/;
 const MAX_PENDING = 5;
 const FIX_WINDOW_MS = 5 * 60 * 1000; // 5 minutes
 const FIX_JACCARD_THRESHOLD = 0.3;
-// Error patterns for Edit/Write tools
-const WRITE_ERROR_PATTERNS = [
-    /permission denied/i,
-    /EACCES/i,
-    /ENOENT/i,
-    /file not found/i,
-    /no such file/i,
-    /is a directory/i,
-    /read-?only file/i,
-    /conflict/i,
-    /old_string.*not found/i,
-    /not unique in the file/i,
-];
-// Error patterns for MCP tools
-const MCP_ERROR_PATTERNS = [
-    /error/i,
-    /failed/i,
-    /exception/i,
-    /timeout/i,
-];
 // --- State management (Bash fix pairing only) ---
 function getStateDir() {
     return (0, shared_1.hookStateDir)();
@@ -331,35 +311,12 @@ async function handleWriteToolOutcome(input) {
     const output = input.tool_output ?? '';
     const toolName = input.tool_name;
     const filePath = input.tool_input?.file_path ?? '';
-    // Check for error patterns
-    const errorMatch = WRITE_ERROR_PATTERNS.find(p => p.test(output));
-    if (errorMatch) {
-        // Dedup check
-        const summary = `${toolName} failed on ${filePath}: ${truncate(firstLine(output), 100)}`;
-        const existing = (0, shared_1.searchExisting)(summary);
-        if ((0, shared_1.isDuplicate)(summary, existing, 0.7)) {
-            (0, shared_1.hookLog)(HOOK_NAME, `Skipped duplicate ${toolName} failure`);
-            return;
-        }
-        const failureContent = {
-            what_failed: `${toolName} failed on ${truncate(filePath, 80)}`,
-            why_failed: truncate(firstLine(output), 200),
-            what_should_do: `Verify file path exists and is writable before using ${toolName}`,
-            context: `${toolName} tool error on ${filePath}`,
-            preventative_checks: [
-                'Check file path exists',
-                'Check file permissions',
-                'Verify old_string is unique (for Edit)',
-            ],
-        };
-        (0, shared_1.storeMemory)(JSON.stringify(failureContent), 'failure', undefined, 0.75);
-        (0, shared_1.hookLog)(HOOK_NAME, `Stored ${toolName} failure: ${truncate(filePath, 60)}`);
-    }
-    // Always record outcome event
-    const eventSummary = errorMatch
-        ? `${toolName} error on ${filePath}: ${truncate(firstLine(output), 100)}`
-        : `${toolName} success on ${truncate(filePath, 100)}`;
-    recordOutcomeEvent(toolName, input.tool_input, eventSummary);
+    // No failure sniffing here: this handler runs on the PostToolUse SUCCESS
+    // path (real failures arrive via PostToolUseFailure → handleToolFailure
+    // with a structured error field). Pattern-matching successful output
+    // stored bogus permanent failures whenever the edited file merely
+    // MENTIONED strings like "ENOENT" or "permission denied".
+    recordOutcomeEvent(toolName, input.tool_input, `${toolName} success on ${truncate(filePath || firstLine(output), 100)}`);
 }
 // --- MCP tool handler ---
 async function handleMcpToolOutcome(input) {
@@ -369,21 +326,9 @@ async function handleMcpToolOutcome(input) {
     if (toolName.includes('claude-recall') || toolName.includes('claude_recall'))
         return;
     const outputStr = typeof output === 'string' ? output : JSON.stringify(output);
-    const hasError = MCP_ERROR_PATTERNS.some(p => p.test(outputStr)) && outputStr.length < 500;
-    if (hasError) {
-        const summary = `${toolName}: ${truncate(firstLine(outputStr), 100)}`;
-        const existing = (0, shared_1.searchExisting)(summary);
-        if (!(0, shared_1.isDuplicate)(summary, existing, 0.7)) {
-            (0, shared_1.storeMemory)(JSON.stringify({
-                what_failed: `MCP tool ${toolName} returned error`,
-                why_failed: truncate(firstLine(outputStr), 200),
-                what_should_do: 'Check tool input parameters and server availability',
-                context: `MCP tool error from ${toolName}`,
-            }), 'failure', undefined, 0.7);
-            (0, shared_1.hookLog)(HOOK_NAME, `Stored MCP failure: ${truncate(toolName, 40)}`);
-        }
-    }
-    // Record outcome event for all MCP tool calls
+    // No failure sniffing here either — /error/i against successful MCP output
+    // turned responses like "0 errors found" into stored failure memories.
+    // PostToolUseFailure carries the real signal.
     recordOutcomeEvent(toolName, input.tool_input, truncate(firstLine(outputStr), 200));
 }
 // --- Generic handler (all other tools) ---
@@ -448,12 +393,14 @@ async function handleToolFailure(input) {
             preventative_checks: ['Verify tool inputs are correct', 'Check preconditions'],
         };
         (0, shared_1.storeMemory)(JSON.stringify(failureContent), 'failure', undefined, 0.8);
-        // Record structured outcome event
+        // Record structured outcome event, attributed to the emitting session so
+        // memory-stop only folds THIS session's failures into its episode
         try {
             const outcomeStorage = outcome_storage_1.OutcomeStorage.getInstance();
             outcomeStorage.createOutcomeEvent({
                 event_type: 'tool_failure',
                 actor: 'tool',
+                session_id: typeof input.session_id === 'string' ? input.session_id : undefined,
                 action_summary: whatFailed,
                 next_state_summary: truncate(error, 200),
                 tags: extractToolTags(toolName, input.tool_input),

package/dist/memory/schema.sql

@@ -15,7 +15,7 @@ CREATE TABLE IF NOT EXISTS memories (
   superseded_at INTEGER,
   confidence_score REAL,
   sophistication_level INTEGER DEFAULT 1,
-  scope TEXT CHECK(scope IN ('universal', 'project', NULL)),
+  scope TEXT CHECK(scope IS NULL OR scope IN ('universal', 'project')),
   content_hash TEXT
 );
 

package/dist/memory/storage.js

@@ -102,7 +102,7 @@ class MemoryStorage {
             // Add scope if missing (v0.7.2+)
             if (!columnNames.includes('scope')) {
                 console.error('📋 Migrating database schema: Adding scope column...');
-                this.db.exec("ALTER TABLE memories ADD COLUMN scope TEXT CHECK(scope IN ('universal', 'project', NULL))");
+                this.db.exec("ALTER TABLE memories ADD COLUMN scope TEXT CHECK(scope IS NULL OR scope IN ('universal', 'project'))");
                 this.db.exec('CREATE INDEX IF NOT EXISTS idx_memories_scope_project ON memories(scope, project_id)');
                 console.error('✅ Added scope column');
             }
@@ -164,6 +164,7 @@ class MemoryStorage {
                 this.db.exec(`CREATE TABLE outcome_events (
           id TEXT PRIMARY KEY,
           episode_id TEXT,
+          session_id TEXT,
           event_type TEXT NOT NULL,
           actor TEXT NOT NULL,
           action_summary TEXT,
@@ -175,6 +176,15 @@ class MemoryStorage {
                 this.db.exec('CREATE INDEX idx_outcome_events_episode ON outcome_events(episode_id)');
                 this.db.exec('CREATE INDEX idx_outcome_events_type ON outcome_events(event_type)');
             }
+            else {
+                // v0.26.2: session_id column so events can be attributed to the session
+                // that produced them — without it, one session's tool failures leak
+                // into another concurrent session's episode and candidate lessons.
+                const eventCols = this.db.prepare("PRAGMA table_info(outcome_events)").all();
+                if (!eventCols.some(c => c.name === 'session_id')) {
+                    this.db.exec('ALTER TABLE outcome_events ADD COLUMN session_id TEXT');
+                }
+            }
             if (!existingOutcomeTables.has('candidate_lessons')) {
                 this.db.exec(`CREATE TABLE candidate_lessons (
           id TEXT PRIMARY KEY,
@@ -695,7 +705,12 @@ class MemoryStorage {
         let query = 'SELECT * FROM memories WHERE preference_key = ? AND type = ?';
         const params = [preferenceKey, 'preference'];
         if (projectId) {
-            query += ' AND project_id = ?';
+            // NULL-inclusive, matching getActiveByPreferenceKeyAnyType and what
+            // loadActiveRules returns. With a strict project_id filter, an override
+            // stored in a project failed to supersede the same preference_key
+            // stored unscoped/universal — leaving two active conflicting
+            // preferences both visible to loadActiveRules.
+            query += ' AND (project_id = ? OR project_id IS NULL)';
             params.push(projectId);
         }
         query += ' ORDER BY timestamp DESC';

package/dist/services/logging.js

@@ -48,7 +48,9 @@ class LoggingService {
     constructor() {
         this.config = config_1.ConfigService.getInstance();
         const configLevel = this.config.getConfig().logging.level;
-        this.logLevel = LogLevel[configLevel.toUpperCase()] || LogLevel.INFO;
+        // ?? not ||: LogLevel.DEBUG === 0 is falsy, so || silently coerced
+        // CLAUDE_RECALL_LOG_LEVEL=debug into INFO and debug() never wrote
+        this.logLevel = LogLevel[configLevel.toUpperCase()] ?? LogLevel.INFO;
     }
     static getInstance() {
         if (!LoggingService.instance) {
@@ -65,6 +67,38 @@ class LoggingService {
             metadata
         };
     }
+    /**
+     * Size-based rotation honoring logging.maxSize / logging.maxFiles. These
+     * config fields existed since the beginning but nothing implemented them —
+     * with hooks logging on every tool call, info.log grew without bound.
+     * On overflow: log → log.1 → log.2 … up to maxFiles, oldest deleted.
+     */
+    rotateIfNeeded(logPath) {
+        try {
+            const loggingConfig = this.config.getConfig().logging;
+            const maxBytes = config_1.ConfigService.parseByteSize(loggingConfig.maxSize, 10 * 1024 * 1024);
+            const maxFiles = Math.max(1, loggingConfig.maxFiles || 5);
+            const stats = fs.statSync(logPath);
+            if (stats.size < maxBytes)
+                return;
+            // Shift older rotations up, dropping the oldest
+            for (let i = maxFiles - 1; i >= 1; i--) {
+                const from = `${logPath}.${i}`;
+                if (!fs.existsSync(from))
+                    continue;
+                if (i === maxFiles - 1) {
+                    fs.unlinkSync(from);
+                }
+                else {
+                    fs.renameSync(from, `${logPath}.${i + 1}`);
+                }
+            }
+            fs.renameSync(logPath, `${logPath}.1`);
+        }
+        catch {
+            // Rotation is best-effort — never let it break logging or the app
+        }
+    }
     writeLog(logName, entry) {
         const logPath = this.config.getLogPath(logName);
         const logDir = path.dirname(logPath);
@@ -78,6 +112,7 @@ class LoggingService {
                 return;
             }
         }
+        this.rotateIfNeeded(logPath);
         const logMessage = `[${entry.timestamp}] ${entry.level} [${entry.service}] ${entry.message}`;
         const fullMessage = entry.metadata
             ? `${logMessage}\n  Metadata: ${JSON.stringify(entry.metadata)}\n`

package/dist/services/memory.js

@@ -681,6 +681,15 @@ class MemoryService {
             ? request.value
             : JSON.stringify(request.value);
         const lowerContent = content.toLowerCase();
+        // Project indicators FIRST: they are the more specific signal. Checking
+        // universal first meant "always use --no-verify in this project" matched
+        // "always use" and leaked the rule to every project.
+        if (lowerContent.includes('for this project') ||
+            lowerContent.includes('project-specific') ||
+            lowerContent.includes('only here') ||
+            lowerContent.includes('in this project')) {
+            return 'project';
+        }
         // Explicit user indicators for universal scope
         if (lowerContent.includes('remember everywhere') ||
             lowerContent.includes('for all projects') ||
@@ -688,13 +697,6 @@ class MemoryService {
             lowerContent.includes('always use')) {
             return 'universal';
         }
-        // Explicit user indicators for project scope
-        if (lowerContent.includes('for this project') ||
-            lowerContent.includes('project-specific') ||
-            lowerContent.includes('only here') ||
-            lowerContent.includes('in this project')) {
-            return 'project';
-        }
         // Default: unscoped (null) for backward compatibility
         return null;
     }

package/dist/services/outcome-storage.js

@@ -111,10 +111,10 @@ class OutcomeStorage {
     createOutcomeEvent(data) {
         const id = this.generateId();
         this.db.prepare(`
-      INSERT INTO outcome_events (id, episode_id, event_type, actor, action_summary,
+      INSERT INTO outcome_events (id, episode_id, session_id, event_type, actor, action_summary,
         next_state_summary, exit_code, tags_json, created_at)
-      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
-    `).run(id, data.episode_id || null, data.event_type, data.actor, data.action_summary || null, data.next_state_summary, data.exit_code ?? null, data.tags ? JSON.stringify(data.tags) : null, this.now());
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    `).run(id, data.episode_id || null, data.session_id || null, data.event_type, data.actor, data.action_summary || null, data.next_state_summary, data.exit_code ?? null, data.tags ? JSON.stringify(data.tags) : null, this.now());
         return id;
     }
     // --- Candidate Lessons ---
@@ -165,8 +165,17 @@ class OutcomeStorage {
      * Get outcome events filtered by event_type, ordered by most recent.
      * Optionally filter by time window (defaults to last 24 hours).
      */
-    getEventsByType(eventType, hoursBack = 24) {
+    /**
+     * @param sessionId When provided, only events recorded by that session are
+     *   returned. Without it, a time-window query mixes events from concurrent
+     *   sessions and other projects' sessions within the window — which is how
+     *   session A's tool failures used to end up in session B's episode.
+     */
+    getEventsByType(eventType, hoursBack = 24, sessionId) {
         const cutoff = new Date(Date.now() - hoursBack * 60 * 60 * 1000).toISOString();
+        if (sessionId) {
+            return this.db.prepare('SELECT * FROM outcome_events WHERE event_type = ? AND created_at > ? AND session_id = ? ORDER BY created_at DESC').all(eventType, cutoff, sessionId);
+        }
         return this.db.prepare('SELECT * FROM outcome_events WHERE event_type = ? AND created_at > ? ORDER BY created_at DESC').all(eventType, cutoff);
     }
     // --- Memory Stats ---

package/dist/services/project-registry.js

@@ -124,6 +124,21 @@ class ProjectRegistry {
                 registry.projects[projectId].lastSeen = now;
                 this.logger.debug('ProjectRegistry', `Updated existing project: ${projectId}`);
             }
+            else if (existing) {
+                // Same basename, DIFFERENT path — an id collision, not a new project.
+                // Latest path wins (matches memory scoping, which is also keyed by
+                // basename), but keep the prior paths and say so instead of silently
+                // overwriting the other project's entry.
+                this.logger.warn('ProjectRegistry', `Project id collision: "${projectId}" already registered at ${existing.path}, now also at ${projectPath}. ` +
+                    `Both directories share ONE memory scope (project ids are directory basenames) — rename one directory to isolate them.`);
+                registry.projects[projectId] = {
+                    path: projectPath,
+                    registeredAt: existing.registeredAt, // preserve original registration
+                    version: version,
+                    lastSeen: now,
+                    previousPaths: [...(existing.previousPaths ?? []), existing.path].slice(-5),
+                };
+            }
             else {
                 // New registration
                 registry.projects[projectId] = {

package/dist/shared/event-processors.js

@@ -114,25 +114,6 @@ function tryPairFix(toolName, toolInput, _output) {
     return matched;
 }
 // --- Tool Outcome Processing ---
-/** Error patterns for Edit/Write tools */
-const WRITE_ERROR_PATTERNS = [
-    /permission denied/i,
-    /EACCES/i,
-    /ENOENT/i,
-    /file not found/i,
-    /no such file/i,
-    /read-?only file/i,
-    /conflict/i,
-    /old_string.*not found/i,
-    /not unique in the file/i,
-];
-/** Error patterns for MCP/custom tools */
-const TOOL_ERROR_PATTERNS = [
-    /error/i,
-    /failed/i,
-    /exception/i,
-    /timeout/i,
-];
 function truncate(s, maxLen) {
     return s.length <= maxLen ? s : s.substring(0, maxLen - 3) + '...';
 }
@@ -170,16 +151,14 @@ function processToolOutcome(toolName, toolInput, toolOutput, isError, sessionId)
     return result;
 }
 function isToolFailureOutput(toolName, output) {
+    // Bash embeds a structured exit-code marker in output — reliable signal.
     if (toolName === 'Bash' || toolName === 'bash') {
         return /Exit code (\d+)/.test(output) && !/Exit code 0/.test(output);
     }
-    if (toolName === 'Edit' || toolName === 'Write' || toolName === 'edit' || toolName === 'write') {
-        return WRITE_ERROR_PATTERNS.some(p => p.test(output));
-    }
-    // For other tools, only flag short error outputs (avoid false positives on long results)
-    if (output.length < 500) {
-        return TOOL_ERROR_PATTERNS.some(p => p.test(output));
-    }
+    // Everything else: trust the caller's isError flag only. Content sniffing
+    // successful output stored bogus failures whenever a result merely
+    // MENTIONED words like "error" or "ENOENT" (e.g. "0 errors found", or an
+    // edit to a file containing error-handling code).
     return false;
 }
 function storeToolFailure(toolName, toolInput, output, _sessionId) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-recall",
-  "version": "0.26.0",
+  "version": "0.27.0",
   "description": "Persistent memory for Claude Code and Pi with native Skills integration, automatic capture, failure learning, and project scoping",
   "main": "dist/index.js",
   "bin": {
@@ -77,7 +77,7 @@
     "registry": "https://registry.npmjs.org/"
   },
   "author": "Claude Recall Team",
-  "license": "ISC",
+  "license": "MIT",
   "engines": {
     "node": ">=20.19.0"
   },
@@ -105,6 +105,6 @@
     "@anthropic-ai/sdk": "^0.110.0",
     "better-sqlite3": "^12.2.0",
     "chalk": "^5.5.0",
-    "commander": "^12.1.0"
+    "commander": "^15.0.0"
   }
 }