claude-recall 0.16.1 → 0.17.1

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

@@ -8,7 +8,7 @@ source: claude-recall
 
 # Corrections
 
-Auto-generated from 20 memories. Last updated: 2026-03-16.
+Auto-generated from 21 memories. Last updated: 2026-03-17.
 
 ## Rules
 
@@ -25,6 +25,7 @@ Auto-generated from 20 memories. Last updated: 2026-03-16.
 - CORRECTION: Memory with complex metadata
 - CORRECTION: Memory with complex metadata
 - CORRECTION: Memory with complex metadata
+- CORRECTION: Memory with complex metadata
 - CORRECTION: Replace expired access token with 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
 - CORRECTION: use spaces not tabs for indentation
 - CORRECTION: cited (loaded 5+ times): 19

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

@@ -1,9 +1,10 @@
 {
   "topicId": "corrections",
-  "sourceHash": "aaf622f0c245a33d23d1c690cd82108fdf2b43e141882838c7b12923bde2aea4",
-  "memoryCount": 20,
-  "generatedAt": "2026-03-16T11:15:23.327Z",
+  "sourceHash": "b717cebe14486cb8c7d1681f494e3e31136c32b0fe8a51112fe1c1a07bfe47f4",
+  "memoryCount": 21,
+  "generatedAt": "2026-03-17T09:43:28.791Z",
   "memoryKeys": [
+    "memory_1773740608781_ae2bn7zos",
     "memory_1773659723317_o738xfbyw",
     "memory_1773656489899_l75d50pxo",
     "memory_1773654956776_7mffm1tp2",

package/.claude/skills/auto-failure-lessons/SKILL.md

@@ -8,11 +8,12 @@ source: claude-recall
 
 # Failure Lessons
 
-Auto-generated from 23 memories. Last updated: 2026-03-16.
+Auto-generated from 24 memories. Last updated: 2026-03-17.
 
 ## Rules
 
 - SQLite query syntax error: LIKE clause requires single quotes around string literal, not double quotes
+- Avoid: Command failed: npx jest tests/unit/memory-sync-hook.test.ts 2>&1 → Instead: Check command syntax, file paths, and prerequisites before running
 - Avoid: Command failed: npm whoami 2>&1 && npm config get registry 2>&1 → Instead: Check command syntax, file paths, and prerequisites before running
 - npm install -g claude-recall@0.15.36 failed with notarget error
 - claude-recall@0.15.36 does not exist on npm registry (ETARGET error)

package/.claude/skills/auto-failure-lessons/manifest.json

@@ -1,10 +1,11 @@
 {
   "topicId": "failure-lessons",
-  "sourceHash": "6c18a22368601e246196934bc675b7cc11619a20758e5a8067886375b499dd00",
-  "memoryCount": 23,
-  "generatedAt": "2026-03-16T09:55:56.753Z",
+  "sourceHash": "e099bbcfc9aa57afd1fb83ab4082a08ff820dd4f1dc31af6d4fbcfa3ad0af3d5",
+  "memoryCount": 24,
+  "generatedAt": "2026-03-17T09:43:28.755Z",
   "memoryKeys": [
     "hook_failure_1772637584921_0tj4rrxnt",
+    "hook_failure_non-zero-exit_1773669669860_9mcdbx51y",
     "hook_failure_non-zero-exit_1773409269877_ful451241",
     "hook_failure_1773410916808_5k1r6zo4u",
     "hook_failure_1773410916789_xtrb8j9nw",

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

@@ -8,10 +8,15 @@ source: claude-recall
 
 # Preferences
 
-Auto-generated from 86 memories. Last updated: 2026-03-16.
+Auto-generated from 91 memories. Last updated: 2026-03-17.
 
 ## Rules
 
+- Session test preference 1773740608856
+- Test preference 1773740608797-2
+- Test preference 1773740608797-1
+- Test preference 1773740608797-0
+- Test memory content
 - Session test preference 1773659723404
 - Test preference 1773659723333-2
 - Test preference 1773659723333-1

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

@@ -1,9 +1,14 @@
 {
   "topicId": "preferences",
-  "sourceHash": "4ae92aa7a2e0c881c89cc72d6645bc7bbe2c9c848db8618031bdf6ba30caecbc",
-  "memoryCount": 86,
-  "generatedAt": "2026-03-16T11:15:23.417Z",
+  "sourceHash": "e2c0f6c21a82d06422afe3b9bddeca1a865d50a9472e3868459612589dd9f5e9",
+  "memoryCount": 91,
+  "generatedAt": "2026-03-17T09:43:28.867Z",
   "memoryKeys": [
+    "memory_1773740608857_7954nxhke",
+    "memory_1773740608828_pkci7qhtt",
+    "memory_1773740608815_k3tj4psf1",
+    "memory_1773740608798_287hs9q7h",
+    "memory_1773740608717_3wy6inv8q",
     "memory_1773659723405_v31rp5h3e",
     "memory_1773659723371_xhh4zlbuh",
     "memory_1773659723354_y2ohkszjc",

package/README.md

@@ -28,29 +28,34 @@ Your preferences, project structure, workflows, corrections, and coding style ar
 | Node.js   | **20+**                 | required for better-sqlite3 |
 | OS        | macOS / Linux / Windows | WSL supported               |
 
-### One-Time Setup
+### Install / Reinstall
 
-Run these once per machine:
+Run these from your project directory:
 
 ```bash
-npm install -g claude-recall
-claude mcp remove claude-recall 2>/dev/null; claude mcp add claude-recall -s user -- claude-recall mcp start
-```
+# 1. Remove MCP server registration (if exists)
+claude mcp remove claude-recall
 
-This installs the global binary and registers the MCP server at user scope — shared across all your projects.
+# 2. Clear npm cache
+npm cache clean --force
 
-### Per-Project Setup
+# 3. Uninstall global claude-recall
+npm uninstall -g claude-recall
 
-Run this in each project directory:
+# 4. Install global claude-recall
+npm install -g claude-recall
 
-```bash
-cd your-project && claude-recall setup --install
-```
+# 5. Install in local project folder
+claude-recall setup --install
 
-This installs hooks and skills into `your-project/.claude/`. Repeat for each project you want Claude Recall active in. Memories are automatically scoped per project in a shared database (`~/.claude-recall/claude-recall.db`).
+# 6. Re-register MCP server
+claude mcp add claude-recall -- claude-recall mcp start
+```
 
 Then restart your Claude Code session.
 
+Repeat step 5 (`claude-recall setup --install`) in each project you want Claude Recall active in. Memories are automatically scoped per project in a shared database (`~/.claude-recall/claude-recall.db`).
+
 ### Verify
 
 In Claude Code, ask: *"Load my rules"*
@@ -59,10 +64,7 @@ Claude should call `mcp__claude-recall__load_rules`. If it works, you're ready.
 
 ### Upgrading
 
-```bash
-npm install -g claude-recall@latest
-cd your-project && claude-recall setup --install   # Re-register hooks in each project
-```
+Follow the same install steps above — they handle both fresh installs and upgrades.
 
 ---
 
@@ -119,11 +121,6 @@ claude-recall --version              # Check version
 <summary>All commands</summary>
 
 ```bash
-# ── Upgrade (global binary, then per-project hooks) ─────────────────
-npm install -g claude-recall@latest
-cd your-project && claude-recall setup --install   # Repeat per project
-claude-recall --version                            # Verify
-
 # ── Setup & Diagnostics ─────────────────────────────────────────────
 claude-recall setup                      # Show activation instructions
 claude-recall setup --install            # Install skills + hooks

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

@@ -608,8 +608,20 @@ async function main() {
         // This avoids registry lookups on every hook invocation.
         const cliScript = path.join(packageDir, 'dist', 'cli', 'claude-recall-cli.js');
         const hookCmd = `node ${cliScript} hook run`;
-        settings.hooksVersion = '7.0.0'; // v7 = add memory-sync hook for auto-memory export
+        settings.hooksVersion = '8.0.0'; // v8 = add bash-failure-watcher PostToolUse hook
         settings.hooks = {
+            PostToolUse: [
+                {
+                    matcher: "Bash",
+                    hooks: [
+                        {
+                            type: "command",
+                            command: `${hookCmd} bash-failure-watcher`,
+                            timeout: 3
+                        }
+                    ]
+                }
+            ],
             PreToolUse: [
                 {
                     matcher: ".*",

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

@@ -75,9 +75,14 @@ class HookCommands {
                         await handleMemorySync(input);
                         break;
                     }
+                    case 'bash-failure-watcher': {
+                        const { handleBashFailureWatcher } = await Promise.resolve().then(() => __importStar(require('../../hooks/bash-failure-watcher')));
+                        await handleBashFailureWatcher(input);
+                        break;
+                    }
                     default:
                         console.error(`Unknown hook: ${name}`);
-                        console.error('Available: correction-detector, memory-stop, precompact-preserve, memory-sync');
+                        console.error('Available: correction-detector, memory-stop, precompact-preserve, memory-sync, bash-failure-watcher');
                 }
             }
             catch {

package/dist/hooks/bash-failure-watcher.js

@@ -0,0 +1,203 @@
+"use strict";
+/**
+ * Bash Failure Watcher — PostToolUse hook (v0.17.0)
+ *
+ * Captures bash command failures immediately after they happen (not at session end).
+ * When a previously failed command succeeds, pairs the fix with the failure record.
+ *
+ * Input (PostToolUse stdin from Claude Code):
+ * {
+ *   "tool_name": "Bash",
+ *   "tool_input": { "command": "npm test" },
+ *   "tool_output": "... Exit code 1 ...",
+ *   "session_id": "abc-123"
+ * }
+ */
+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.handleBashFailureWatcher = handleBashFailureWatcher;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const os = __importStar(require("os"));
+const shared_1 = require("./shared");
+const memory_1 = require("../services/memory");
+const HOOK_NAME = 'bash-failure-watcher';
+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;
+function getStateDir() {
+    return path.join(os.homedir(), '.claude-recall', 'hook-state');
+}
+function getStatePath(sessionId) {
+    return path.join(getStateDir(), `${sessionId}-failures.json`);
+}
+function readPendingFailures(sessionId) {
+    try {
+        const statePath = getStatePath(sessionId);
+        if (!fs.existsSync(statePath))
+            return [];
+        const data = fs.readFileSync(statePath, 'utf-8');
+        return JSON.parse(data);
+    }
+    catch {
+        return [];
+    }
+}
+function writePendingFailures(sessionId, pending) {
+    try {
+        const stateDir = getStateDir();
+        if (!fs.existsSync(stateDir)) {
+            fs.mkdirSync(stateDir, { recursive: true });
+        }
+        fs.writeFileSync(getStatePath(sessionId), JSON.stringify(pending));
+    }
+    catch {
+        // Never fail on state file writes
+    }
+}
+function truncate(s, maxLen) {
+    if (s.length <= maxLen)
+        return s;
+    return s.substring(0, maxLen - 3) + '...';
+}
+function firstLine(s) {
+    const idx = s.indexOf('\n');
+    return idx === -1 ? s : s.substring(0, idx);
+}
+async function handleBashFailureWatcher(input) {
+    try {
+        if (!input || typeof input !== 'object')
+            return;
+        const toolName = input.tool_name;
+        if (toolName !== 'Bash')
+            return;
+        const command = input.tool_input?.command;
+        if (!command || typeof command !== 'string' || command.length < 3)
+            return;
+        const output = input.tool_output ?? '';
+        const sessionId = input.session_id ?? 'unknown';
+        // Skip hook infrastructure errors
+        if (output.includes('PreToolUse') || output.includes('PostToolUse'))
+            return;
+        const exitMatch = output.match(EXIT_CODE_REGEX);
+        const isFailure = exitMatch && exitMatch[1] !== '0';
+        if (isFailure) {
+            await handleFailure(command, exitMatch[1], output, sessionId);
+        }
+        else {
+            await handleSuccess(command, sessionId);
+        }
+    }
+    catch (err) {
+        (0, shared_1.hookLog)(HOOK_NAME, `Error: ${err}`);
+        // Never throw — hooks must not block Claude
+    }
+}
+async function handleFailure(command, exitCode, output, sessionId) {
+    // Dedup check
+    const existing = (0, shared_1.searchExisting)(command);
+    if ((0, shared_1.isDuplicate)(command, existing, 0.7)) {
+        (0, shared_1.hookLog)(HOOK_NAME, `Skipped duplicate: ${truncate(command, 60)}`);
+        return;
+    }
+    const failureContent = {
+        what_failed: `Command failed: ${truncate(command, 100)}`,
+        why_failed: `Exit code ${exitCode}: ${truncate(firstLine(output), 150)}`,
+        what_should_do: 'Check command syntax, file paths, and prerequisites before running',
+        context: `Bash command returned non-zero exit code ${exitCode}`,
+        preventative_checks: [
+            'Verify command arguments and paths exist',
+            'Check required tools are installed',
+        ],
+    };
+    const key = `hook_failure_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+    const memoryService = memory_1.MemoryService.getInstance();
+    memoryService.store({
+        key,
+        value: failureContent,
+        type: 'failure',
+        context: { timestamp: Date.now() },
+        relevanceScore: 0.85,
+    });
+    (0, shared_1.hookLog)(HOOK_NAME, `Stored failure: ${truncate(command, 60)} (exit ${exitCode})`);
+    // Track pending failure for fix pairing
+    const pending = readPendingFailures(sessionId);
+    pending.push({ command, memoryKey: key, timestamp: Date.now() });
+    // Keep max 5, evict oldest
+    while (pending.length > MAX_PENDING) {
+        pending.shift();
+    }
+    writePendingFailures(sessionId, pending);
+    // Notify Claude
+    console.log(`⚠️ Failure stored: "${truncate(command, 60)}" (exit ${exitCode}). Use search_memory for similar past failures.`);
+}
+async function handleSuccess(command, sessionId) {
+    const pending = readPendingFailures(sessionId);
+    if (pending.length === 0)
+        return;
+    const now = Date.now();
+    let matched = false;
+    // Filter expired and find matches
+    const remaining = [];
+    for (const pf of pending) {
+        if (now - pf.timestamp > FIX_WINDOW_MS) {
+            // Expired — evict
+            continue;
+        }
+        if (!matched && (0, shared_1.jaccardSimilarity)(pf.command, command) >= FIX_JACCARD_THRESHOLD) {
+            // Match found — update the failure memory with the fix
+            try {
+                const memoryService = memory_1.MemoryService.getInstance();
+                memoryService.update(pf.memoryKey, {
+                    value: {
+                        what_should_do: `Fix: ${truncate(command, 200)}`,
+                    },
+                });
+                (0, shared_1.hookLog)(HOOK_NAME, `Paired fix: "${truncate(command, 60)}" → ${pf.memoryKey}`);
+                matched = true;
+                // Don't add to remaining — consumed
+            }
+            catch (err) {
+                (0, shared_1.hookLog)(HOOK_NAME, `Fix pairing error: ${err}`);
+                remaining.push(pf);
+            }
+        }
+        else {
+            remaining.push(pf);
+        }
+    }
+    writePendingFailures(sessionId, remaining);
+}

package/dist/services/memory.js

@@ -496,6 +496,12 @@ class MemoryService {
         // Default: unscoped (null) for backward compatibility
         return null;
     }
+    /**
+     * Update a memory record by key (used for fix pairing in hooks)
+     */
+    update(key, updates) {
+        this.storage.update(key, updates);
+    }
     /**
      * Close database connection
      */

package/package.json

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