claude-recall 0.20.7 → 0.20.8

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

@@ -8,7 +8,7 @@ source: claude-recall
 
 # Corrections
 
-Auto-generated from 15 memories. Last updated: 2026-04-06.
+Auto-generated from 16 memories. Last updated: 2026-04-06.
 
 ## Rules
 
@@ -25,6 +25,7 @@ Auto-generated from 15 memories. Last updated: 2026-04-06.
 - CORRECTION: Memory with complex metadata
 - CORRECTION: Memory with complex metadata
 - CORRECTION: Memory with complex metadata
+- CORRECTION: Memory with complex metadata
 - CORRECTION: License copyright should include user's name instead of 'Claude Recall Contributors'
 - CORRECTION: License copyright should list your name instead of 'Claude Recall Contributors'
 

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

@@ -1,9 +1,10 @@
 {
   "topicId": "corrections",
-  "sourceHash": "6bede026828253771f48ae5c05e80878ab69beb584dfc06f416814840016ad6c",
-  "memoryCount": 15,
-  "generatedAt": "2026-04-06T16:51:19.054Z",
+  "sourceHash": "1313608fb812bd1bed85d9854e8958179f7584619e0160604c56bd40ec8cc5b0",
+  "memoryCount": 16,
+  "generatedAt": "2026-04-06T17:24:01.505Z",
   "memoryKeys": [
+    "memory_1775496241485_1yyc5ht88",
     "memory_1775494279035_j6uj5lzxo",
     "memory_1775492069326_vksvzmt3f",
     "memory_1775491767369_sepsjmg8y",

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

@@ -8,10 +8,15 @@ source: claude-recall
 
 # Preferences
 
-Auto-generated from 74 memories. Last updated: 2026-04-06.
+Auto-generated from 79 memories. Last updated: 2026-04-06.
 
 ## Rules
 
+- Session test preference 1775496241643
+- Test preference 1775496241514-2
+- Test preference 1775496241514-1
+- Test preference 1775496241514-0
+- Test memory content
 - Session test preference 1775494279149
 - Test preference 1775494279061-2
 - Test preference 1775494279061-1

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

@@ -1,9 +1,14 @@
 {
   "topicId": "preferences",
-  "sourceHash": "77d6964d46ea058e3de341d9d43c79901bc596a18b5a03fa8e402368ba20b412",
-  "memoryCount": 74,
-  "generatedAt": "2026-04-06T16:51:19.174Z",
+  "sourceHash": "1cad20b547cd1594370facfdae6b4ae8700516e9be712d8b28459462398c9276",
+  "memoryCount": 79,
+  "generatedAt": "2026-04-06T17:24:01.663Z",
   "memoryKeys": [
+    "memory_1775496241645_xtz7cwan4",
+    "memory_1775496241576_j7sxxuge3",
+    "memory_1775496241542_rg3hj24ud",
+    "memory_1775496241516_y3inz8rlf",
+    "memory_1775496241411_vwdz6igrm",
     "memory_1775494279150_n4pq7zy11",
     "memory_1775494279108_6hbe8qoit",
     "memory_1775494279088_nv8hjdm7s",

package/README.md

@@ -81,10 +81,12 @@ Once installed, Claude Recall works automatically in the background:
 1. **Session start** — active rules are loaded before the first action. In Claude Code, this happens via the `search_enforcer` hook; in Pi, rules are injected into the system prompt automatically
 2. **As you work** — every prompt is classified for corrections and preferences. Natural statements like *"we use tabs here"* or *"no, put tests in `__tests__/`"* are detected and stored
 3. **Tool outcomes** — results from all tools (Bash, Edit, Write, and more) are captured. Failures are stored as memories; Bash failures are paired with successful fixes
-4. **End of session** — session episodes are created, candidate lessons extracted from failures, and a promotion cycle graduates validated patterns into active rules
+4. **End of session** — session episodes are created, candidate lessons extracted from failures, and a promotion cycle graduates validated patterns into active rules. A session extraction pass sends the last 50 transcript entries to Haiku to extract durable project knowledge from long coding sessions
 5. **Reask detection** — frustration signals ("still broken", "that didn't work") are recorded as outcome events
 6. **Before context compression** — aggressive memory sweep captures important context before the window shrinks
-7. **Rules sync** (Claude Code only) — top 30 rules are exported as typed `.md` files to Claude Code's native memory directory
+7. **After context compression** (Claude Code only) — rules are automatically re-injected into context so they're not lost when the window shrinks
+8. **Multi-agent outcomes** — subagent completions (completed/failed/killed) are captured from task notifications and recorded as outcome events
+9. **Rules sync** (Claude Code only) — top 30 rules are exported as typed `.md` files to Claude Code's native memory directory
 
 Classification uses Claude Haiku (via `ANTHROPIC_API_KEY`) with silent regex fallback. No configuration needed.
 

package/dist/hooks/correction-detector.js

@@ -64,6 +64,6 @@ async function handleCorrectionDetector(input) {
         ? result.extract.substring(0, 60) + '...'
         : result.extract;
     // Output hook message that Claude sees
-    console.log(`<user-prompt-submit-hook>[Memory] Auto-captured ${result.type}: ${summary}</user-prompt-submit-hook>`);
+    console.log(`<user-prompt-submit-hook>📌 Recall: auto-captured ${result.type} — ${summary}</user-prompt-submit-hook>`);
     (0, shared_1.hookLog)('correction-detector', `Captured ${result.type}: ${result.extract.substring(0, 80)}`);
 }

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

@@ -107,6 +107,9 @@ async function handleMemoryStop(input) {
         stored++;
         (0, shared_1.hookLog)('memory-stop', `Captured ${result.type}: ${result.extract.substring(0, 80)}`);
     }
+    if (stored > 0) {
+        console.log(`📝 Recall: captured ${stored} memories from this session`);
+    }
     (0, shared_1.hookLog)('memory-stop', `Session end: stored ${stored} memories from ${entries.length} entries`);
     // Session extraction: learn from long coding sessions (reads wider window)
     try {
@@ -131,6 +134,7 @@ async function handleMemoryStop(input) {
             }
             const extracted = await (0, event_processors_1.extractSessionLearnings)(conversationEntries, input?.session_id ?? '', projectId, 5);
             if (extracted > 0) {
+                console.log(`🔍 Recall: extracted ${extracted} learnings from session analysis`);
                 (0, shared_1.hookLog)('memory-stop', `Session extraction: stored ${extracted} learnings`);
                 stored += extracted;
             }
@@ -158,6 +162,9 @@ async function handleMemoryStop(input) {
         const { PromotionEngine } = await Promise.resolve().then(() => __importStar(require('../services/promotion-engine')));
         const result = PromotionEngine.getInstance().runCycle(projectId);
         if (result.promoted > 0 || result.archived > 0) {
+            if (result.promoted > 0) {
+                console.log(`⬆️ Recall: ${result.promoted} lesson(s) promoted to active rules`);
+            }
             (0, shared_1.hookLog)('memory-stop', `Promotion: ${result.promoted} promoted, ${result.archived} archived`);
         }
     }

package/dist/hooks/post-compact-reload.js

@@ -48,7 +48,7 @@ async function handlePostCompactReload(input) {
         if (totalRules === 0)
             return;
         const body = formatRules(rules);
-        console.log(`${DIRECTIVE}\n\n---\n\n${body}`);
+        console.log(`🔄 Recall: ${totalRules} rules re-loaded after context compaction\n\n${DIRECTIVE}\n\n---\n\n${body}`);
         (0, shared_1.hookLog)('post-compact-reload', `Re-injected ${totalRules} rules after compaction`);
     }
     catch (err) {

package/dist/hooks/precompact-preserve.js

@@ -93,6 +93,9 @@ async function handlePrecompactPreserve(input) {
         stored++;
         (0, shared_1.hookLog)('precompact', `Captured ${result.type}: ${result.extract.substring(0, 80)}`);
     }
+    if (stored > 0) {
+        console.log(`💾 Recall: preserved ${stored} memories before context compression`);
+    }
     (0, shared_1.hookLog)('precompact', `PreCompact sweep: stored ${stored} memories from ${entries.length} entries`);
     // Reset search enforcer hook-state so Claude is forced to re-load rules
     // after context compression. Without this, the enforcer thinks rules are

package/dist/pi/extension.js

@@ -137,21 +137,47 @@ function default_1(pi) {
         }
     });
     // --- Event: detect corrections from user input ---
-    pi.on('input', (event, _ctx) => {
+    pi.on('input', (event, ctx) => {
         collectedUserTexts.push(event.text);
-        (0, event_processors_1.processUserInput)(event.text, sessionId).catch(() => { });
+        (0, event_processors_1.processUserInput)(event.text, sessionId).then(msg => {
+            if (msg && ctx.hasUI) {
+                try {
+                    ctx.ui.notify(`📌 ${msg}`, 'info');
+                }
+                catch { /* non-critical */ }
+            }
+        }).catch(() => { });
         return { action: 'continue' };
     });
     // --- Event: session end — episode + promotion + session extraction ---
-    pi.on('session_shutdown', (_event, _ctx) => {
-        (0, event_processors_1.processSessionEnd)(collectedUserTexts, sessionId, projectId).catch(() => { });
+    pi.on('session_shutdown', (_event, ctx) => {
+        (0, event_processors_1.processSessionEnd)(collectedUserTexts, sessionId, projectId).then(result => {
+            if (ctx.hasUI) {
+                try {
+                    if (result.stored > 0) {
+                        ctx.ui.notify(`📝 Recall: captured ${result.stored} memories from this session`, 'info');
+                    }
+                    if (result.promoted > 0) {
+                        ctx.ui.notify(`⬆️ Recall: ${result.promoted} lesson(s) promoted to active rules`, 'info');
+                    }
+                }
+                catch { /* non-critical */ }
+            }
+        }).catch(() => { });
         // Session extraction: learn from long coding sessions
         const allEntries = [
             ...collectedUserTexts.map(t => ({ role: 'user', text: t })),
             ...collectedToolResults,
         ];
         if (allEntries.length >= 10) {
-            (0, event_processors_1.extractSessionLearnings)(allEntries, sessionId, projectId, 5).catch(() => { });
+            (0, event_processors_1.extractSessionLearnings)(allEntries, sessionId, projectId, 5).then(extracted => {
+                if (extracted > 0 && ctx.hasUI) {
+                    try {
+                        ctx.ui.notify(`🔍 Recall: extracted ${extracted} learnings from session`, 'info');
+                    }
+                    catch { /* non-critical */ }
+                }
+            }).catch(() => { });
         }
     });
     // --- Event: pre-compaction — aggressive capture ---

package/package.json

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