claude-recall 0.18.8 → 0.19.0

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

@@ -8,10 +8,20 @@ source: claude-recall
 
 # Corrections
 
-Auto-generated from 20 memories. Last updated: 2026-03-22.
+Auto-generated from 30 memories. Last updated: 2026-04-02.
 
 ## Rules
 
+- 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: 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: Memory with complex metadata
 - CORRECTION: Memory with complex metadata
 - CORRECTION: Memory with complex metadata

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

@@ -1,9 +1,19 @@
 {
   "topicId": "corrections",
-  "sourceHash": "be94895a3ad6a5999508be2c149a1a2742178fff9f9adc97b5da6185c9a30398",
-  "memoryCount": 20,
-  "generatedAt": "2026-03-22T15:58:29.733Z",
+  "sourceHash": "e522ab0f108ce0a51b1dab005a2db51518edfdc431927275ba0c623a033d440e",
+  "memoryCount": 30,
+  "generatedAt": "2026-04-02T18:06:30.565Z",
   "memoryKeys": [
+    "memory_1775153190549_s9iwgl8lp",
+    "memory_1775152793092_g9wy80yom",
+    "memory_1775152560585_6yo07v2f4",
+    "memory_1775152548944_95j0vkg8u",
+    "memory_1775152517032_jvetpszkr",
+    "memory_1775152503075_3bncrxz1d",
+    "memory_1775152493186_ecq01e1gx",
+    "memory_1775152395533_qhhh4p5md",
+    "memory_1775152294113_jgwg4rw1q",
+    "memory_1775152031817_1vsksjun4",
     "memory_1774195109722_gij039r4m",
     "memory_1774191618092_vuxyvq3mw",
     "memory_1774106331272_kg5w7ztfj",

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

@@ -8,10 +8,55 @@ source: claude-recall
 
 # Preferences
 
-Auto-generated from 21 memories. Last updated: 2026-03-22.
+Auto-generated from 66 memories. Last updated: 2026-04-02.
 
 ## Rules
 
+- Session test preference 1775153190803
+- Test preference 1775153190591-2
+- Test preference 1775153190591-1
+- Test preference 1775153190591-0
+- Test memory content
+- Session test preference 1775152793337
+- Test preference 1775152793133-2
+- Test preference 1775152793133-1
+- Test preference 1775152793133-0
+- Test memory content
+- Session test preference 1775152560667
+- Test preference 1775152560598-2
+- Test preference 1775152560598-1
+- Test preference 1775152560598-0
+- Test memory content
+- Session test preference 1775152549026
+- Test preference 1775152548959-2
+- Test preference 1775152548959-1
+- Test preference 1775152548959-0
+- Test memory content
+- Test preference 1775152517049-2
+- Test preference 1775152517049-1
+- Test preference 1775152517049-0
+- Test memory content
+- Test preference 1775152503089-2
+- Test preference 1775152503089-1
+- Test preference 1775152503089-0
+- Test memory content
+- Test preference 1775152493202-2
+- Test preference 1775152493202-1
+- Test preference 1775152493202-0
+- Test memory content
+- Test preference 1775152395578-2
+- Test preference 1775152395578-1
+- Test preference 1775152395578-0
+- Test memory content
+- Test preference 1775152294130-2
+- Test preference 1775152294130-1
+- Test preference 1775152294130-0
+- Test memory content
+- Test preference 1775152031832-2
+- Test preference 1775152031832-1
+- Test preference 1775152031832-0
+- Test memory content
+- axios npm package was compromised in a supply chain attack (axios@1.14.1 pulled in malicious plain-crypto-js@4.2.1). Claude Recall is NOT affected — does not use axios. Verified 2026-04-01. If axios is ever added as a dependency, pin the version and audit lockfiles.
 - Test preference 1774195109742-2
 - Test preference 1774195109742-1
 - Test preference 1774195109742-0

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

@@ -1,9 +1,54 @@
 {
   "topicId": "preferences",
-  "sourceHash": "29117b36ff390c0168d551c7f821d92567c91e252995d3786e0f0fd7462fc548",
-  "memoryCount": 21,
-  "generatedAt": "2026-03-22T15:58:29.796Z",
+  "sourceHash": "72956f94499dd1ea22ae6348d86c5bb0199d3eec080cabc3960af1a57ea86dcb",
+  "memoryCount": 66,
+  "generatedAt": "2026-04-02T18:06:30.831Z",
   "memoryKeys": [
+    "memory_1775153190805_cvmwqk3fz",
+    "memory_1775153190715_23rgmq122",
+    "memory_1775153190682_arpcd1klk",
+    "memory_1775153190594_6rf5m5mo4",
+    "memory_1775153190422_owulv4b0l",
+    "memory_1775152793339_z2gjzo21u",
+    "memory_1775152793214_vz5vqxtqt",
+    "memory_1775152793177_m1zrfowu2",
+    "memory_1775152793135_0cxpxnzzt",
+    "memory_1775152792982_kvzpym0nj",
+    "memory_1775152560669_z96m74mo0",
+    "memory_1775152560632_g1m6exf5d",
+    "memory_1775152560615_bzsl0vevj",
+    "memory_1775152560599_j4nxggnvj",
+    "memory_1775152560543_2tlrz7uuw",
+    "memory_1775152549028_vdh5d8l1z",
+    "memory_1775152548991_s796whgbi",
+    "memory_1775152548974_8wu7oxnht",
+    "memory_1775152548960_6xn5qg1ed",
+    "memory_1775152548897_i892zk4er",
+    "memory_1775152517086_h1qtehxg5",
+    "memory_1775152517069_7iyt7gtd2",
+    "memory_1775152517050_jyndlwzm3",
+    "memory_1775152516970_9jsac5vef",
+    "memory_1775152503124_36fasrgv4",
+    "memory_1775152503106_rmjhhcaqy",
+    "memory_1775152503090_1vgaf4xvt",
+    "memory_1775152503030_czylzojcv",
+    "memory_1775152493236_kge25b20q",
+    "memory_1775152493220_1xpmtploo",
+    "memory_1775152493203_cck14tmil",
+    "memory_1775152493142_fdxvwri6p",
+    "memory_1775152395670_69if6leyw",
+    "memory_1775152395636_iatgy1qym",
+    "memory_1775152395579_00j66922k",
+    "memory_1775152395397_c28bq57a0",
+    "memory_1775152294164_6jc19cw4j",
+    "memory_1775152294147_0b50nxbf8",
+    "memory_1775152294131_isvbcko3z",
+    "memory_1775152294061_93dm7kgkv",
+    "memory_1775152031897_3owwqu9z2",
+    "memory_1775152031871_p5fdk67r0",
+    "memory_1775152031833_qtjc1ng2t",
+    "memory_1775152031740_5lnk9fdzg",
+    "memory_1775030829333_64gdk8kql",
     "memory_1774195109780_8ffmflge1",
     "memory_1774195109763_v6olh83ct",
     "memory_1774195109743_i79j9a9rl",

package/README.md

@@ -1,6 +1,6 @@
 # Claude Recall
 
-### Persistent, local memory for Claude Code — powered by native Claude Skills.
+### Persistent, local memory for Claude Code — learn from every session.
 
 Claude Recall is a **local memory engine + MCP server** that gives Claude Code something it's missing by default:
 **the ability to learn from you over time.**
@@ -14,8 +14,8 @@ Your preferences, project structure, workflows, corrections, and coding style ar
 - **Smart Memory Capture** — LLM-powered classification (via Claude Haiku) detects preferences and corrections from natural language, with silent regex fallback
 - **Project-Scoped Knowledge** — each project gets its own memory namespace; switch projects and Claude switches context automatically
 - **Failure Learning** — captures what failed, why, and what to do instead — so Claude doesn't repeat mistakes
-- **Outcome-Aware Learning** — tracks action outcomes (bash results, test cycles, user corrections), synthesizes candidate lessons, and promotes validated patterns into active rules automatically
-- **Skill Crystallization** — when enough memories accumulate, auto-generates `.claude/skills/auto-*/` files that load natively without tool calls
+- **Outcome-Aware Learning** — tracks action outcomes (all tool results, test cycles, user corrections), synthesizes candidate lessons, and promotes validated patterns into active rules automatically
+- **Skill Crystallization** — auto-generates `.claude/skills/auto-*/` files from accumulated memories, using Anthropic's [Agent Skills](https://agentskills.io/) open standard
 - **Local-Only** — SQLite on your machine, no telemetry, no cloud, works fully offline
 
 ---
@@ -93,10 +93,10 @@ Once installed, Claude Recall works automatically in the background:
 1. **First prompt** — the `search_enforcer` hook ensures Claude loads your stored rules before taking any action
 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. It also creates **episodes** summarizing the session outcome, generates **candidate lessons** from detected failures, and runs a **promotion cycle** to graduate validated patterns into active rules
-4. **Bash failures** — the `bash-failure-watcher` hook captures command failures in real-time, pairs successful fixes, and writes **outcome events** for the learning pipeline
+4. **Tool outcomes** — the `tool-outcome-watcher` hook captures outcomes from all tools (Bash, Edit, Write, MCP tools) in real-time. Bash failures are paired with successful fixes. A separate `PostToolUseFailure` hook captures structured error details for any tool failure
 5. **Reask detection** — the `correction-detector` hook detects user frustration signals ("still broken", "that didn't work") and records them as outcome events
 6. **Before context compression** — the `precompact-preserve` hook sweeps up to 50 entries so nothing important is lost when the context window shrinks
-7. **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
+7. **Rules sync to auto-memory** — the `memory-sync` hook exports the top 30 rules as individual typed `.md` files with YAML frontmatter to `~/.claude/projects/{project}/memory/`, matching Claude Code's native memory format. Rules are ranked by citation count, load frequency, and recency
 
 All classification uses Claude Haiku (via `ANTHROPIC_API_KEY` from your Claude Code session) with silent regex fallback. No configuration needed.
 
@@ -113,7 +113,11 @@ claude-recall search "preference"
 
 ## How It Works
 
-Claude Recall runs as an MCP server exposing four tools, backed by a local SQLite database with WAL mode, content-hash deduplication, and automatic compaction. A native Claude Skill (`.claude/skills/memory-management/SKILL.md`) teaches Claude when to load, store, and search memories.
+Claude Recall runs as an MCP server exposing four tools and seven prompts, backed by a local SQLite database with WAL mode, content-hash deduplication, and automatic compaction. The MCP prompts (including `load-rules` and `session-review`) are discoverable by Claude Code's skill system.
+
+### Built on Agent Skills
+
+Claude Recall uses Anthropic's [Agent Skills](https://agentskills.io/) open standard to teach Claude when and how to use its memory tools. A core skill (`.claude/skills/memory-management/SKILL.md`) guides Claude's memory behavior using progressive disclosure — metadata loads at startup, full instructions load only when needed. When enough memories accumulate around a topic, Claude Recall auto-generates additional skills (`.claude/skills/auto-*/`) that load natively without MCP tool calls. See Anthropic's [blog post](https://claude.com/blog/equipping-agents-for-the-real-world-with-agent-skills) for more on the Agent Skills architecture.
 
 | Tool | Purpose |
 | ---- | ------- |
@@ -130,7 +134,7 @@ Claude Recall tracks what happens *after* Claude acts — not just what was said
 action → outcome event → episode → candidate lesson → promotion → active rule
 ```
 
-- **Outcome events** capture bash results, test outcomes, user corrections, and reask signals
+- **Outcome events** capture results from all tool types (Bash, Edit, Write, MCP), test outcomes, user corrections, and reask signals
 - **Episodes** summarize entire sessions with outcome type, severity, and confidence
 - **Candidate lessons** are extracted from failure patterns — deduplicated by Jaccard similarity
 - **Promotion engine** graduates lessons into active rules after 2+ observations (or immediately for high-severity failures), and demotes never-helpful memories

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

@@ -693,15 +693,25 @@ 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 = '8.0.0'; // v8 = add bash-failure-watcher PostToolUse hook
+        settings.hooksVersion = '10.0.0'; // v10 = add PostToolUseFailure for explicit error capture
         settings.hooks = {
             PostToolUse: [
                 {
-                    matcher: "Bash",
                     hooks: [
                         {
                             type: "command",
-                            command: `${hookCmd} bash-failure-watcher`,
+                            command: `${hookCmd} tool-outcome-watcher`,
+                            timeout: 3
+                        }
+                    ]
+                }
+            ],
+            PostToolUseFailure: [
+                {
+                    hooks: [
+                        {
+                            type: "command",
+                            command: `${hookCmd} tool-failure`,
                             timeout: 3
                         }
                     ]

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

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

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

@@ -111,13 +111,16 @@ 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);
+    const allFailures = [...failures, ...toolFailures];
     outcomeStorage.updateEpisode(episodeId, {
-        outcome_type: failures.length > 0 ? 'failure' : 'success',
-        severity: failures.length > 0 ? 'medium' : 'low',
-        outcome_summary: `${stored} memories, ${failures.length} failures`,
+        outcome_type: allFailures.length > 0 ? 'failure' : 'success',
+        severity: allFailures.length > 0 ? 'medium' : 'low',
+        outcome_summary: `${stored} memories, ${allFailures.length} failures (${toolFailures.length} from tool events)`,
     });
     // Generate candidate lessons from high-confidence failures
-    generateCandidateLessons(failures, episodeId, projectId);
+    generateCandidateLessons(allFailures, episodeId, projectId);
     // Run promotion cycle
     try {
         const { PromotionEngine } = await Promise.resolve().then(() => __importStar(require('../services/promotion-engine')));
@@ -312,6 +315,30 @@ function detectAndStoreFailures(transcriptPath, episodeId) {
         return [];
     }
 }
+/**
+ * Convert structured tool_failure outcome events into DetectedFailure format
+ * so they feed into the candidate lessons pipeline.
+ */
+function getToolFailureEvents(outcomeStorage) {
+    try {
+        const events = outcomeStorage.getEventsByType('tool_failure', 1); // last 1 hour
+        return events.slice(0, 5).map(e => ({
+            signal: 'tool_failure',
+            confidence: 0.8,
+            content: {
+                what_failed: e.action_summary || 'Tool failure',
+                why_failed: e.next_state_summary,
+                what_should_do: 'Check inputs and prerequisites before retrying',
+                context: `Captured by PostToolUseFailure hook`,
+                preventative_checks: ['Verify tool inputs are correct'],
+            },
+        }));
+    }
+    catch (err) {
+        (0, shared_1.hookLog)('memory-stop', `Tool failure events error: ${(0, shared_1.safeErrorMessage)(err)}`);
+        return [];
+    }
+}
 /**
  * Generate candidate lessons from high-confidence failures.
  * Deduplicates against existing lessons and increments evidence count for similar ones.

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

@@ -2,9 +2,9 @@
 /**
  * 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.
+ * Exports active rules from Claude Recall's SQLite database to individual
+ * typed .md files in Claude Code's auto-memory directory, using CC's native
+ * YAML frontmatter format so rules participate in CC's memory retrieval.
  *
  * Input: { session_id, cwd, hook_event_name }
  */
@@ -50,6 +50,10 @@ const os = __importStar(require("os"));
 const shared_1 = require("./shared");
 const memory_1 = require("../services/memory");
 const config_1 = require("../services/config");
+/** Max number of recall files to write (leave room for CC's own memory files) */
+const MAX_SYNC_FILES = 30;
+/** Prefix for all recall memory files — prevents namespace collisions */
+const FILE_PREFIX = 'recall_';
 /** Keys that look like test data */
 const TEST_KEY_PATTERNS = [/^Test /i, /^Session test /i, /^test_/i];
 /** Values that may contain secrets */
@@ -64,13 +68,15 @@ function deriveAutoMemoryPath(cwd, homedir) {
     return path.join(home, '.claude', 'projects', sanitized, 'memory');
 }
 /**
- * Extract display value from a memory record, matching memory-tools.ts formatting.
+ * Extract display value from a memory record.
  */
-function extractValue(m) {
-    const val = typeof m.value === 'object'
-        ? (m.value.content || m.value.value || JSON.stringify(m.value))
-        : m.value;
-    return String(val);
+function extractValue(value) {
+    if (typeof value === 'string')
+        return value;
+    if (typeof value === 'object' && value !== null) {
+        return value.content || value.value || JSON.stringify(value);
+    }
+    return String(value ?? '');
 }
 /**
  * Check if a memory key matches test data patterns.
@@ -85,71 +91,130 @@ function containsSecret(value) {
     return SECRET_PATTERNS.some(p => p.test(value));
 }
 /**
- * Format rules into markdown sections.
+ * Sanitize a string for use as a filename slug.
  */
-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)}`);
-        }
+function slugify(s) {
+    return s
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, '-')
+        .replace(/^-+|-+$/g, '')
+        .substring(0, 50);
+}
+/**
+ * Generate a descriptive name from a rule's key and value.
+ */
+function generateName(rule) {
+    const val = extractValue(rule.value);
+    // Use the key if it's human-readable (not auto-generated)
+    const isAutoKey = rule.key.startsWith('memory_') || rule.key.startsWith('auto_') ||
+        rule.key.startsWith('pref_') || rule.key.startsWith('hook_');
+    if (!isAutoKey && rule.key.length > 3 && rule.key.length < 60) {
+        return rule.key.replace(/[-_]/g, ' ').replace(/\b\w/g, c => c.toUpperCase());
     }
-    sections.push(`\n---\n*Last synced: ${new Date().toISOString()}*`);
-    return sections.join('\n') + '\n';
+    // Derive from value content
+    const firstSentence = val.split(/[.\n]/)[0].trim();
+    return firstSentence.length > 60 ? firstSentence.substring(0, 57) + '...' : firstSentence;
+}
+/**
+ * Generate a one-line description for CC's relevance selector.
+ */
+function generateDescription(rule) {
+    const val = extractValue(rule.value);
+    const typeLabel = rule.crType === 'correction' ? 'Correction'
+        : rule.crType === 'failure' ? 'Failure lesson'
+            : rule.crType === 'preference' ? 'User preference'
+                : rule.crType === 'devops' ? 'DevOps convention'
+                    : 'Project knowledge';
+    const snippet = val.length > 80 ? val.substring(0, 77) + '...' : val;
+    return `${typeLabel}: ${snippet}`;
 }
-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.
+ * Generate a unique filename for a rule.
  */
-function ensureMemoryMdPointer(memoryDir) {
+function generateFilename(rule, index) {
+    const slug = slugify(extractValue(rule.value).substring(0, 40)) || `rule-${index}`;
+    return `${FILE_PREFIX}${rule.ccType}_${slug}.md`;
+}
+/**
+ * Render a single memory file with CC-compatible YAML frontmatter.
+ */
+function renderMemoryFile(rule) {
+    const name = generateName(rule);
+    const description = generateDescription(rule);
+    const val = extractValue(rule.value);
+    const lines = [
+        '---',
+        `name: ${name}`,
+        `description: ${description}`,
+        `type: ${rule.ccType}`,
+        '---',
+        '',
+        val,
+        '',
+    ];
+    return lines.join('\n');
+}
+/**
+ * Update MEMORY.md with pointers to recall files.
+ * Replaces any existing "## Claude Recall" section, preserves everything else.
+ */
+function updateMemoryMdIndex(memoryDir, files) {
     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
+    // Remove existing Claude Recall section (everything from ## Claude Recall to next ## or end)
+    const sectionRegex = /\n?## Claude Recall\n[\s\S]*?(?=\n## |\n*$)/;
+    const cleaned = existing.replace(sectionRegex, '').trimEnd();
+    // Build new section
+    const recallLines = ['', '## Claude Recall'];
+    if (files.length === 0) {
+        recallLines.push('- No recall rules synced');
     }
-    fs.appendFileSync(memoryMdPath, MEMORY_MD_POINTER);
+    else {
+        for (const f of files) {
+            const hook = f.description.length > 80 ? f.description.substring(0, 77) + '...' : f.description;
+            recallLines.push(`- [${f.name}](${f.filename}) — ${hook}`);
+        }
+    }
+    recallLines.push('');
+    const newContent = cleaned + recallLines.join('\n');
+    fs.writeFileSync(memoryMdPath, newContent);
 }
 /**
- * Filter out test data and secrets from rules.
+ * Clean up stale recall_* files that are no longer in the current sync set.
  */
-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;
-    });
+function cleanupStaleFiles(memoryDir, currentFilenames) {
+    let removed = 0;
+    try {
+        const files = fs.readdirSync(memoryDir);
+        for (const f of files) {
+            if (f.startsWith(FILE_PREFIX) && f.endsWith('.md') && !currentFilenames.has(f)) {
+                fs.unlinkSync(path.join(memoryDir, f));
+                removed++;
+            }
+        }
+    }
+    catch {
+        // Ignore cleanup errors
+    }
+    return removed;
+}
+/**
+ * Remove old recall-rules.md if it exists (migration from v0.18.x).
+ */
+function removeOldRulesFile(memoryDir) {
+    const oldPath = path.join(memoryDir, 'recall-rules.md');
+    try {
+        if (fs.existsSync(oldPath)) {
+            fs.unlinkSync(oldPath);
+            (0, shared_1.hookLog)('memory-sync', 'Removed old recall-rules.md');
+        }
+    }
+    catch {
+        // Ignore
+    }
 }
 async function handleMemorySync(input) {
     const cwd = input?.cwd ?? '';
@@ -160,28 +225,49 @@ async function handleMemorySync(input) {
     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;
+        // Get top rules ranked for sync
+        const rules = memoryService.getTopRulesForSync(projectId, MAX_SYNC_FILES);
+        // Filter out test data and secrets
+        const filtered = rules.filter(r => {
+            if (isTestData(r.key))
+                return false;
+            const val = extractValue(r.value);
+            if (containsSecret(val))
+                return false;
+            return true;
+        });
         // 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}`);
+        // Remove old flat rules file (v0.18.x migration)
+        removeOldRulesFile(memoryDir);
+        // Write individual files
+        const writtenFiles = [];
+        const currentFilenames = new Set();
+        for (let i = 0; i < filtered.length; i++) {
+            const rule = filtered[i];
+            const filename = generateFilename(rule, i);
+            const content = renderMemoryFile(rule);
+            // Deduplicate filenames (in case two rules produce the same slug)
+            let uniqueFilename = filename;
+            if (currentFilenames.has(uniqueFilename)) {
+                uniqueFilename = uniqueFilename.replace('.md', `-${i}.md`);
+            }
+            fs.writeFileSync(path.join(memoryDir, uniqueFilename), content);
+            currentFilenames.add(uniqueFilename);
+            writtenFiles.push({
+                filename: uniqueFilename,
+                name: generateName(rule),
+                description: generateDescription(rule),
+            });
+        }
+        // Clean up stale recall_* files from previous syncs
+        const removed = cleanupStaleFiles(memoryDir, currentFilenames);
+        // Update MEMORY.md index
+        updateMemoryMdIndex(memoryDir, writtenFiles);
+        (0, shared_1.hookLog)('memory-sync', `Synced ${writtenFiles.length} files to ${memoryDir} (removed ${removed} stale)`);
     }
     catch (error) {
         (0, shared_1.hookLog)('memory-sync', `Error: ${error.message}`);