claude-recall 0.20.6 → 0.20.8

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

@@ -8,7 +8,7 @@ source: claude-recall
 
 # Corrections
 
-Auto-generated from 14 memories. Last updated: 2026-04-06.
+Auto-generated from 16 memories. Last updated: 2026-04-06.
 
 ## Rules
 
@@ -24,6 +24,8 @@ Auto-generated from 14 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: 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,11 @@
 {
   "topicId": "corrections",
-  "sourceHash": "c77b49a2f99b869465aeb4705a4c3de1f922381d5b49ed8d78c661477f8668fa",
-  "memoryCount": 14,
-  "generatedAt": "2026-04-06T16:14:29.343Z",
+  "sourceHash": "1313608fb812bd1bed85d9854e8958179f7584619e0160604c56bd40ec8cc5b0",
+  "memoryCount": 16,
+  "generatedAt": "2026-04-06T17:24:01.505Z",
   "memoryKeys": [
+    "memory_1775496241485_1yyc5ht88",
+    "memory_1775494279035_j6uj5lzxo",
     "memory_1775492069326_vksvzmt3f",
     "memory_1775491767369_sepsjmg8y",
     "memory_1775169786543_43p8to1hu",

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

@@ -8,10 +8,20 @@ source: claude-recall
 
 # Preferences
 
-Auto-generated from 69 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
+- Test preference 1775494279061-0
+- Test memory content
 - Session test preference 1775492069465
 - Test preference 1775492069353-2
 - Test preference 1775492069353-1

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

@@ -1,9 +1,19 @@
 {
   "topicId": "preferences",
-  "sourceHash": "84b3e678b896e5e6761dcfc6d49ee47c0027d4c7808f6ef6f8f3e00aa39ee76c",
-  "memoryCount": 69,
-  "generatedAt": "2026-04-06T16:14:29.485Z",
+  "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",
+    "memory_1775494279062_jx4wrwn6s",
+    "memory_1775494278982_fsc491z41",
     "memory_1775492069467_5cturlg0a",
     "memory_1775492069400_icg4tjivf",
     "memory_1775492069377_goix7nu9v",

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/cli/claude-recall-cli.js

@@ -693,8 +693,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 = '10.0.0'; // v10 = add PostToolUseFailure for explicit error capture
+        settings.hooksVersion = '11.0.0'; // v11 = add SessionStart(compact) for post-compaction rule reload
         settings.hooks = {
+            SessionStart: [
+                {
+                    matcher: "compact",
+                    hooks: [
+                        {
+                            type: "command",
+                            command: `${hookCmd} post-compact-reload`,
+                            timeout: 10
+                        }
+                    ]
+                }
+            ],
             PostToolUse: [
                 {
                     hooks: [

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

@@ -85,6 +85,11 @@ class HookCommands {
                         await handleToolFailure(input);
                         break;
                     }
+                    case 'post-compact-reload': {
+                        const { handlePostCompactReload } = await Promise.resolve().then(() => __importStar(require('../../hooks/post-compact-reload')));
+                        await handlePostCompactReload(input);
+                        break;
+                    }
                     case 'bash-failure-watcher': {
                         // Backward compat alias — routes to tool-outcome-watcher
                         const { handleBashFailureWatcher } = await Promise.resolve().then(() => __importStar(require('../../hooks/tool-outcome-watcher')));

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 {
@@ -114,8 +117,24 @@ async function handleMemoryStop(input) {
         const sessionEntries = (0, shared_1.readTranscriptTail)(transcriptPath, 50);
         if (sessionEntries.length >= 10) {
             const conversationEntries = buildConversationEntries(sessionEntries);
+            // Record failed subagent outcomes
+            for (const entry of conversationEntries) {
+                if (entry.toolName === 'Agent' && entry.isError) {
+                    try {
+                        outcomeStorage.createOutcomeEvent({
+                            event_type: 'agent_failure',
+                            actor: 'tool',
+                            action_summary: entry.text,
+                            next_state_summary: entry.text,
+                            tags: ['agent', 'subagent'],
+                        });
+                    }
+                    catch { /* non-critical */ }
+                }
+            }
             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;
             }
@@ -143,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`);
         }
     }
@@ -417,7 +439,21 @@ function buildConversationEntries(entries) {
         else {
             const text = (0, shared_1.extractTextFromEntry)(entry);
             if (text && text.length > 5) {
-                result.push({ role: 'assistant', text: text.substring(0, 300) });
+                // Detect subagent task notifications
+                const notifMatch = text.match(/<task-notification>[\s\S]*?<\/task-notification>/);
+                if (notifMatch) {
+                    const status = notifMatch[0].match(/<status>(.*?)<\/status>/)?.[1] ?? 'unknown';
+                    const summary = notifMatch[0].match(/<summary>(.*?)<\/summary>/)?.[1] ?? '';
+                    result.push({
+                        role: 'tool_result',
+                        text: `Agent ${status}: ${summary}`.substring(0, 300),
+                        toolName: 'Agent',
+                        isError: status === 'failed' || status === 'killed',
+                    });
+                }
+                else {
+                    result.push({ role: 'assistant', text: text.substring(0, 300) });
+                }
             }
         }
     }

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

@@ -0,0 +1,57 @@
+"use strict";
+/**
+ * post-compact-reload hook — fires on SessionStart with source "compact".
+ *
+ * After context compaction, recall rules loaded earlier in the session are
+ * gone from the model's context. This hook re-injects them by outputting
+ * the active rules to stdout, which CC injects as a system message.
+ *
+ * Input: { session_id, hook_event_name: "SessionStart", source: "compact" }
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handlePostCompactReload = handlePostCompactReload;
+const shared_1 = require("./shared");
+const memory_1 = require("../services/memory");
+const config_1 = require("../services/config");
+const DIRECTIVE = 'These rules were re-loaded after context compaction.\n' +
+    'Continue applying them. Cite at the point of application: (applied from memory: <rule>)';
+function extractVal(value) {
+    if (typeof value === 'string')
+        return value;
+    if (typeof value === 'object' && value !== null) {
+        return value.content || value.value || JSON.stringify(value);
+    }
+    return String(value ?? '');
+}
+function formatRules(rules) {
+    const sections = [];
+    if (rules.preferences.length > 0) {
+        sections.push('## Preferences\n' + rules.preferences.map(m => `- ${extractVal(m.value)}`).join('\n'));
+    }
+    if (rules.corrections.length > 0) {
+        sections.push('## Corrections\n' + rules.corrections.map(m => `- ${extractVal(m.value)}`).join('\n'));
+    }
+    if (rules.failures.length > 0) {
+        sections.push('## Failures\n' + rules.failures.map(m => `- ${extractVal(m.value)}`).join('\n'));
+    }
+    if (rules.devops.length > 0) {
+        sections.push('## DevOps Rules\n' + rules.devops.map(m => `- ${extractVal(m.value)}`).join('\n'));
+    }
+    return sections.join('\n\n');
+}
+async function handlePostCompactReload(input) {
+    try {
+        const projectId = config_1.ConfigService.getInstance().getProjectId();
+        const rules = memory_1.MemoryService.getInstance().loadActiveRules(projectId);
+        const totalRules = rules.preferences.length + rules.corrections.length +
+            rules.failures.length + rules.devops.length;
+        if (totalRules === 0)
+            return;
+        const body = formatRules(rules);
+        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) {
+        (0, shared_1.hookLog)('post-compact-reload', `Error: ${err.message}`);
+    }
+}

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/docs/cc-agent-harness.md

@@ -0,0 +1,114 @@
+# Claude Code Agent Harness — Architecture Reference
+
+Reference notes on Claude Code's internal agent harness architecture, based on source code analysis (v1.0.x, March 2026). Useful for understanding integration points and designing Claude Recall features.
+
+## Core Orchestration
+
+**Query loop** — main while-loop that calls the API, executes tools, handles continuations, retries, and abort. Key behaviors:
+- Infinite loop with explicit terminal conditions (end_turn, max_tokens, budget exceeded, turn limit)
+- Pre-API hooks, post-sampling hooks, stop hooks at each stage
+- Memory prefetch started non-blocking before API call
+- Skill discovery prefetch in parallel with streaming
+
+**Tool execution pipeline** — partitions tool calls into batches:
+- Read-only tools (Read, Grep, Glob) run concurrently (max 10)
+- Write tools (Bash, Edit, Write) run serially
+- Each tool goes through: permission check → execute → yield result → apply context modifiers
+- Tool result size budget enforced per turn
+
+## Permission System
+
+Three modes: `default` (interactive), `auto` (ML classifier), `bypass`.
+
+Pipeline per tool call:
+1. Rules-based check (always-allow/deny/ask lists)
+2. Bash classifier (ML, 2s timeout for speculative decisions)
+3. Hook execution (PreToolUse hooks)
+4. Interactive UI prompt (if needed)
+5. Decision persisted to ToolPermissionContext
+
+Risk classification: LOW/MEDIUM/HIGH per tool action. Denial tracking state for threshold-based fallback.
+
+## Multi-Agent
+
+**Coordinator mode** — multi-agent orchestration with parallel worker phases and shared scratchpad.
+
+**Agent tool** — forks subagents with inherited context:
+- Child shares parent's prompt cache (byte-identical prefix = free context)
+- Hard turn limit per agent
+- Task notifications via XML: `<task-notification><status>completed</status>...</task-notification>`
+- Agent types: worker (async), teammate (in-process, visible UI), fork (implicit context inheritance)
+
+**Worker constraints:**
+- SIMPLE mode: Bash, Read, Edit only
+- Normal mode: full tool list including MCP
+
+## State Management
+
+**AppState** (Zustand store, 200+ fields):
+- messages, tasks, agents, permissions, MCP clients, models, plugins, settings
+- Observable via selectors
+- Task registry: `{ [taskId]: TaskState }` with status tracking
+
+**Task types:** local_bash, local_agent, remote_agent, in_process_teammate, local_workflow, monitor_mcp, dream
+
+**Session persistence:** transcript JSONL written per session, resumable.
+
+## Context Management / Compaction
+
+Four compaction strategies (in order of aggressiveness):
+1. **Microcompact** — cache-editing on every turn (efficient, preserves cache)
+2. **Snip compact** — truncate oldest history (feature-gated)
+3. **Context collapse** — deduplicate/compress (feature-gated)
+4. **Autocompact** — full summarization when token threshold crossed
+
+Token tracking: per-message estimates, cache creation/read tokens, danger zone threshold, cumulative budget.
+
+Pre/post compact hooks fire at each stage.
+
+## Safety & Guardrails
+
+- Cyber risk instruction (defensive security, CTF rules)
+- Secret scanner (gitleaks patterns, credential redaction)
+- Path traversal prevention
+- Command injection protection (fixed in security audit)
+- Crypto: `crypto.randomUUID()` / `crypto.randomBytes()` throughout (no weak RNG)
+
+## Memory System
+
+**extractMemories** — forked sub-agent after each query loop:
+- Reads last ~N messages, decides what to extract
+- 5-turn budget, read-then-write strategy
+- Mutual exclusivity: skips if main agent already wrote to memory
+- Shares parent's prompt cache
+
+**autoDream** — background consolidation:
+- Three-gate trigger: 24h since last + 5 sessions + no parallel consolidation
+- Four phases: orient → gather → consolidate → prune
+- PID-based locking, 1h stale window
+
+**Memory retrieval** — Sonnet sidequery selects up to 5 relevant memories per query from the memory directory.
+
+## Integration Points for Claude Recall
+
+### Currently Used
+- PostToolUse / PostToolUseFailure hooks (tool outcome capture)
+- UserPromptSubmit hook (correction detection)
+- Stop hook (session-end processing)
+- PreCompact hook (pre-compaction capture)
+- MCP server (tool registration)
+- Skills directory (behavioral guidance)
+
+### Available but Unused
+- Permission decision hooks (observe denied tools as learning signals)
+- Task notification parsing (multi-agent session outcomes)
+- Agent fork interception (inject memory context into subagents)
+- Compaction triggers (pre-compact hooks with message access)
+- Memory prefetch integration (inject recall results alongside native memory)
+
+### Architectural Constraints
+- Hooks run as external processes (no shared memory, no prompt cache)
+- MCP tools are request-response (no streaming, no multi-turn)
+- Cannot fork sub-agents from hooks
+- Cannot modify the query loop or tool pipeline directly
+- Feature flags (GrowthBook `tengu_*`) control many code paths — not accessible externally

package/package.json

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