claude-recall 0.15.36 → 0.16.0

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

@@ -8,7 +8,7 @@ source: claude-recall
 
 # Corrections
 
-Auto-generated from 17 memories. Last updated: 2026-03-13.
+Auto-generated from 19 memories. Last updated: 2026-03-16.
 
 ## Rules
 
@@ -22,6 +22,8 @@ Auto-generated from 17 memories. Last updated: 2026-03-13.
 - CORRECTION: Memory with complex metadata
 - 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,11 @@
 {
   "topicId": "corrections",
-  "sourceHash": "220924ba60fc47a579461ace78f314aff6c7fccd9f2fbb759d4773afaec9628b",
-  "memoryCount": 17,
-  "generatedAt": "2026-03-13T14:06:22.452Z",
+  "sourceHash": "a0d5ebfdc3b3ad70a29a38511679290d1e2918e5c7c3a4b856c0da65595c81ed",
+  "memoryCount": 19,
+  "generatedAt": "2026-03-16T10:21:29.906Z",
   "memoryKeys": [
+    "memory_1773656489899_l75d50pxo",
+    "memory_1773654956776_7mffm1tp2",
     "memory_1773410782442_mnfvdml5n",
     "memory_1773409168373_t4lqoqpiv",
     "memory_1773220863163_q8k0ewti8",

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

@@ -8,12 +8,17 @@ source: claude-recall
 
 # Failure Lessons
 
-Auto-generated from 18 memories. Last updated: 2026-03-13.
+Auto-generated from 23 memories. Last updated: 2026-03-16.
 
 ## Rules
 
 - SQLite query syntax error: LIKE clause requires single quotes around string literal, not double quotes
 - 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)
+- npm install failed: claude-recall@0.15.36 version not found in registry
+- npm package claude-recall@0.15.36 does not exist - version not found in registry
+- npm package claude-recall@0.15.36 not found - version does not exist in registry
 - Claude-recall MCP Server failed to start with npx claude-recall@latest mcp start
 - Claude-recall MCP Server failed to start with command: npx -y claude-recall@latest mcp start
 - Avoid: Command failed: npm run build 2>&1 | tail -3 && npm test 2>&1 → Instead: Check command syntax, file paths, and prerequisites before running

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

@@ -1,11 +1,16 @@
 {
   "topicId": "failure-lessons",
-  "sourceHash": "eb6e007a4ce3b2b87da9fc0f7affcabd89cf0ac1e90742f1408511b68e947e11",
-  "memoryCount": 18,
-  "generatedAt": "2026-03-13T14:06:22.419Z",
+  "sourceHash": "6c18a22368601e246196934bc675b7cc11619a20758e5a8067886375b499dd00",
+  "memoryCount": 23,
+  "generatedAt": "2026-03-16T09:55:56.753Z",
   "memoryKeys": [
     "hook_failure_1772637584921_0tj4rrxnt",
     "hook_failure_non-zero-exit_1773409269877_ful451241",
+    "hook_failure_1773410916808_5k1r6zo4u",
+    "hook_failure_1773410916789_xtrb8j9nw",
+    "hook_failure_1773410910825_rd25wy0tf",
+    "hook_failure_1773410885720_u05tuf2dk",
+    "hook_failure_1773410874391_kbnfssg62",
     "hook_failure_1773409616313_gmsfcbuzh",
     "hook_failure_1773409607268_83ie5yunz",
     "hook_failure_non-zero-exit_1773068793859_0z0ah0743",

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

@@ -8,10 +8,20 @@ source: claude-recall
 
 # Preferences
 
-Auto-generated from 71 memories. Last updated: 2026-03-13.
+Auto-generated from 81 memories. Last updated: 2026-03-16.
 
 ## Rules
 
+- Session test preference 1773656489963
+- Test preference 1773656489911-2
+- Test preference 1773656489911-1
+- Test preference 1773656489911-0
+- Test memory content
+- Session test preference 1773654956838
+- Test preference 1773654956788-2
+- Test preference 1773654956788-1
+- Test preference 1773654956788-0
+- Test memory content
 - Session test preference 1773410782522
 - Test preference 1773410782456-2
 - Test preference 1773410782456-1

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

@@ -1,9 +1,19 @@
 {
   "topicId": "preferences",
-  "sourceHash": "d9c68970596d6f78d891d1f51711a823b1a38cf1decf9c0171477649baa3560b",
-  "memoryCount": 71,
-  "generatedAt": "2026-03-13T14:06:22.540Z",
+  "sourceHash": "3dce40a1ad092880b2f8005a2c3f9982e37775ef0886a74f329ef1b167c409ce",
+  "memoryCount": 81,
+  "generatedAt": "2026-03-16T10:21:29.975Z",
   "memoryKeys": [
+    "memory_1773656489964_tpm4ycfc1",
+    "memory_1773656489936_29pvxu7ni",
+    "memory_1773656489924_ick7951wj",
+    "memory_1773656489912_w54afewzm",
+    "memory_1773656489839_ij3r3sg2s",
+    "memory_1773654956839_pluovrk77",
+    "memory_1773654956815_ofh9by5rb",
+    "memory_1773654956802_24y27xjux",
+    "memory_1773654956790_pnrio2ihb",
+    "memory_1773654956712_hnjabccni",
     "memory_1773410782523_k5hjje6pt",
     "memory_1773410782491_zbm4dcqvl",
     "memory_1773410782472_t0nrgizx2",

package/README.md

@@ -55,6 +55,7 @@ Once installed, Claude Recall works automatically in the background:
 2. **As you work** — the `correction-detector` hook classifies every prompt you type. Natural statements like *"we use tabs here"* or *"no, put tests in `__tests__/`"* are detected and stored automatically
 3. **End of turn** — the `memory-stop` hook scans recent transcript entries for corrections, preferences, failures, and devops patterns
 4. **Before context compression** — the `precompact-preserve` hook sweeps up to 50 entries so nothing important is lost when the context window shrinks
+5. **Rules sync to auto-memory** — the `memory-sync` hook exports active rules to `~/.claude/projects/{project}/memory/recall-rules.md` so they're available even when the MCP server is down
 
 All classification uses Claude Haiku (via `ANTHROPIC_API_KEY` from your Claude Code session) with silent regex fallback. No configuration needed.
 
@@ -147,6 +148,7 @@ claude-recall project clean              # Remove stale registry entries
 claude-recall hook run correction-detector   # UserPromptSubmit hook
 claude-recall hook run memory-stop           # Stop hook
 claude-recall hook run precompact-preserve   # PreCompact hook
+claude-recall hook run memory-sync           # Stop + PreCompact hook (syncs rules to auto-memory)
 ```
 
 </details>

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

@@ -608,7 +608,7 @@ 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 = '6.0.0'; // v6 = local node path instead of npx for hooks
+        settings.hooksVersion = '7.0.0'; // v7 = add memory-sync hook for auto-memory export
         settings.hooks = {
             PreToolUse: [
                 {
@@ -638,6 +638,11 @@ async function main() {
                             type: "command",
                             command: `${hookCmd} memory-stop`,
                             timeout: 30
+                        },
+                        {
+                            type: "command",
+                            command: `${hookCmd} memory-sync`,
+                            timeout: 10
                         }
                     ]
                 }
@@ -649,6 +654,11 @@ async function main() {
                             type: "command",
                             command: `${hookCmd} precompact-preserve`,
                             timeout: 60
+                        },
+                        {
+                            type: "command",
+                            command: `${hookCmd} memory-sync`,
+                            timeout: 10
                         }
                     ]
                 }

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

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

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

@@ -0,0 +1,189 @@
+"use strict";
+/**
+ * memory-sync-hook — fires on Stop and PreCompact events.
+ *
+ * Exports active rules from Claude Recall's SQLite database to a topic file
+ * in Claude Code's auto-memory directory, so rules are available even when
+ * the MCP server is down.
+ *
+ * Input: { session_id, cwd, hook_event_name }
+ */
+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.deriveAutoMemoryPath = deriveAutoMemoryPath;
+exports.handleMemorySync = handleMemorySync;
+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 config_1 = require("../services/config");
+/** Keys that look like test data */
+const TEST_KEY_PATTERNS = [/^Test /i, /^Session test /i, /^test_/i];
+/** Values that may contain secrets */
+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/
+ */
+function deriveAutoMemoryPath(cwd, homedir) {
+    const home = homedir || os.homedir();
+    const sanitized = cwd.replace(/\//g, '-');
+    return path.join(home, '.claude', 'projects', sanitized, 'memory');
+}
+/**
+ * Extract display value from a memory record, matching memory-tools.ts formatting.
+ */
+function extractValue(m) {
+    const val = typeof m.value === 'object'
+        ? (m.value.content || m.value.value || JSON.stringify(m.value))
+        : m.value;
+    return String(val);
+}
+/**
+ * Check if a memory key matches test data patterns.
+ */
+function isTestData(key) {
+    return TEST_KEY_PATTERNS.some(p => p.test(key));
+}
+/**
+ * Check if a value contains secret-like content.
+ */
+function containsSecret(value) {
+    return SECRET_PATTERNS.some(p => p.test(value));
+}
+/**
+ * Format rules into markdown sections.
+ */
+function formatRulesMarkdown(rules) {
+    const sections = [];
+    sections.push('<!-- Auto-generated by Claude Recall — overwritten each session -->');
+    sections.push('# Claude Recall Rules');
+    if (rules.preferences.length > 0) {
+        sections.push('\n## Preferences');
+        for (const m of rules.preferences) {
+            const val = extractValue(m);
+            const key = m.preference_key || m.key || '';
+            const isAutoKey = key.startsWith('memory_') || key.startsWith('auto_') || key.startsWith('pref_') || key.startsWith('hook_');
+            sections.push(isAutoKey ? `- ${val}` : `- ${key}: ${val}`);
+        }
+    }
+    if (rules.corrections.length > 0) {
+        sections.push('\n## Corrections');
+        for (const m of rules.corrections) {
+            sections.push(`- ${extractValue(m)}`);
+        }
+    }
+    if (rules.failures.length > 0) {
+        sections.push('\n## Failures');
+        for (const m of rules.failures) {
+            sections.push(`- ${extractValue(m)}`);
+        }
+    }
+    if (rules.devops.length > 0) {
+        sections.push('\n## DevOps Rules');
+        for (const m of rules.devops) {
+            sections.push(`- ${extractValue(m)}`);
+        }
+    }
+    sections.push(`\n---\n*Last synced: ${new Date().toISOString()}*`);
+    return sections.join('\n') + '\n';
+}
+const MEMORY_MD_POINTER = `\n## Claude Recall\n- See [recall-rules.md](recall-rules.md) for learned preferences, corrections, and failure lessons\n`;
+/**
+ * Ensure MEMORY.md contains a pointer to recall-rules.md.
+ * Appends the pointer only if absent. Never overwrites existing content.
+ */
+function ensureMemoryMdPointer(memoryDir) {
+    const memoryMdPath = path.join(memoryDir, 'MEMORY.md');
+    let existing = '';
+    if (fs.existsSync(memoryMdPath)) {
+        existing = fs.readFileSync(memoryMdPath, 'utf-8');
+    }
+    if (existing.includes('recall-rules.md')) {
+        return; // Pointer already present
+    }
+    fs.appendFileSync(memoryMdPath, MEMORY_MD_POINTER);
+}
+/**
+ * Filter out test data and secrets from rules.
+ */
+function filterRules(memories) {
+    return memories.filter(m => {
+        const key = m.preference_key || m.key || '';
+        if (isTestData(key))
+            return false;
+        const val = extractValue(m);
+        if (containsSecret(val))
+            return false;
+        return true;
+    });
+}
+async function handleMemorySync(input) {
+    const cwd = input?.cwd ?? '';
+    if (!cwd) {
+        (0, shared_1.hookLog)('memory-sync', 'No cwd provided — skipping sync');
+        return;
+    }
+    try {
+        const projectId = config_1.ConfigService.getInstance().getProjectId();
+        const memoryService = memory_1.MemoryService.getInstance();
+        const rules = memoryService.loadActiveRules(projectId);
+        // Filter each category
+        const filtered = {
+            preferences: filterRules(rules.preferences),
+            corrections: filterRules(rules.corrections),
+            failures: filterRules(rules.failures),
+            devops: filterRules(rules.devops),
+        };
+        const totalRules = filtered.preferences.length + filtered.corrections.length +
+            filtered.failures.length + filtered.devops.length;
+        // Derive auto-memory path and ensure directory exists
+        const memoryDir = deriveAutoMemoryPath(cwd);
+        if (!fs.existsSync(memoryDir)) {
+            fs.mkdirSync(memoryDir, { recursive: true });
+        }
+        // Write recall-rules.md (full overwrite)
+        const markdown = formatRulesMarkdown(filtered);
+        const rulesPath = path.join(memoryDir, 'recall-rules.md');
+        fs.writeFileSync(rulesPath, markdown);
+        // Ensure MEMORY.md has pointer
+        ensureMemoryMdPointer(memoryDir);
+        (0, shared_1.hookLog)('memory-sync', `Synced ${totalRules} rules to ${rulesPath}`);
+    }
+    catch (error) {
+        (0, shared_1.hookLog)('memory-sync', `Error: ${error.message}`);
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-recall",
-  "version": "0.15.36",
+  "version": "0.16.0",
   "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": {