claude-recall 0.20.6 → 0.20.7

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 15 memories. Last updated: 2026-04-06.
 
 ## Rules
 
@@ -24,6 +24,7 @@ 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: 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": "c77b49a2f99b869465aeb4705a4c3de1f922381d5b49ed8d78c661477f8668fa",
-  "memoryCount": 14,
-  "generatedAt": "2026-04-06T16:14:29.343Z",
+  "sourceHash": "6bede026828253771f48ae5c05e80878ab69beb584dfc06f416814840016ad6c",
+  "memoryCount": 15,
+  "generatedAt": "2026-04-06T16:51:19.054Z",
   "memoryKeys": [
+    "memory_1775494279035_j6uj5lzxo",
     "memory_1775492069326_vksvzmt3f",
     "memory_1775491767369_sepsjmg8y",
     "memory_1775169786543_43p8to1hu",

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

@@ -8,10 +8,15 @@ source: claude-recall
 
 # Preferences
 
-Auto-generated from 69 memories. Last updated: 2026-04-06.
+Auto-generated from 74 memories. Last updated: 2026-04-06.
 
 ## Rules
 
+- 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,14 @@
 {
   "topicId": "preferences",
-  "sourceHash": "84b3e678b896e5e6761dcfc6d49ee47c0027d4c7808f6ef6f8f3e00aa39ee76c",
-  "memoryCount": 69,
-  "generatedAt": "2026-04-06T16:14:29.485Z",
+  "sourceHash": "77d6964d46ea058e3de341d9d43c79901bc596a18b5a03fa8e402368ba20b412",
+  "memoryCount": 74,
+  "generatedAt": "2026-04-06T16:51:19.174Z",
   "memoryKeys": [
+    "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/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/memory-stop-hook.js

@@ -114,6 +114,21 @@ 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) {
                 (0, shared_1.hookLog)('memory-stop', `Session extraction: stored ${extracted} learnings`);
@@ -417,7 +432,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(`${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/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.7",
   "description": "Persistent memory for Claude Code and Pi with native Skills integration, automatic capture, failure learning, and project scoping",
   "main": "dist/index.js",
   "bin": {