claude-recall 0.21.1 → 0.22.0

package/.claude/settings.json

@@ -108,7 +108,18 @@
           }
         ]
       }
+    ],
+    "SessionEnd": [
+      {
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node /home/ebiarao/.nvm/versions/node/v20.19.3/lib/node_modules/claude-recall/dist/cli/claude-recall-cli.js hook run session-end-checkpoint",
+            "timeout": 5
+          }
+        ]
+      }
     ]
   },
-  "hooksVersion": "12.0.0"
+  "hooksVersion": "13.0.0"
 }

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

@@ -12,10 +12,10 @@ Auto-generated from 5 memories. Last updated: 2026-04-11.
 
 ## Rules
 
-- Session test preference 1775896807164
-- Test preference 1775896807117-2
-- Test preference 1775896807117-1
-- Test preference 1775896807117-0
+- Session test preference 1775902182248
+- Test preference 1775902182184-2
+- Test preference 1775902182184-1
+- Test preference 1775902182184-0
 - Test memory content
 
 ---

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

@@ -1,13 +1,13 @@
 {
   "topicId": "preferences",
-  "sourceHash": "47589a75902fabe04a4aab7d8c89e3cdd26c4c1cf7b6e3086a7ea3186413abe4",
+  "sourceHash": "a383c0d6502023d06954eb49fcab8886dc5181d5e59666f6c74a381221e44f87",
   "memoryCount": 5,
-  "generatedAt": "2026-04-11T08:40:07.182Z",
+  "generatedAt": "2026-04-11T10:09:42.271Z",
   "memoryKeys": [
-    "memory_1775896807165_8gx2muuz6",
-    "memory_1775896807142_2zmd3oc2x",
-    "memory_1775896807130_nsc3d9wky",
-    "memory_1775896807118_3qvm34ozn",
-    "memory_1775896807081_saak1fkqp"
+    "memory_1775902182249_x5rzzep7s",
+    "memory_1775902182226_9uo2kaw57",
+    "memory_1775902182211_pl5fzrb85",
+    "memory_1775902182185_q6f9widp3",
+    "memory_1775902182147_olowsptz3"
   ]
 }

package/.claude/skills/memory-management/SKILL.md

@@ -137,13 +137,16 @@ a SKILL.md file that Claude Code loads automatically.
 
 ## Automatic Capture Hooks
 
-Claude Recall registers hooks on three Claude Code events to capture memories automatically — no MCP tool call needed:
+Claude Recall registers hooks on six Claude Code events for automatic capture, just-in-time rule injection, and outcome tracking — no MCP tool call needed:
 
-| Hook | Event | What it captures |
+| Hook | Event | What it does |
 |------|-------|-----------------|
-| `correction-detector` | UserPromptSubmit | User corrections, preferences, and project knowledge from natural language |
-| `memory-stop` | Stop | Corrections, preferences, failures, and devops patterns from the last 6 transcript entries |
+| `correction-detector` | UserPromptSubmit | Captures user corrections, preferences, and project knowledge from natural language |
+| `memory-stop` | Stop | Captures corrections, preferences, failures, and devops patterns from the last 6 transcript entries |
 | `precompact-preserve` | PreCompact | Broader sweep of up to 50 transcript entries before context compression |
+| `session-end-checkpoint` | SessionEnd | Auto-saves a `{completed, remaining, blockers}` task checkpoint when the session ends voluntarily (`clear`, `prompt_input_exit`, `logout`). Spawns a detached worker so it stays within Claude Code's 1.5s SessionEnd timeout. Pi has the equivalent via the `session_shutdown` event handler. |
+| `rule-injector` | PreToolUse | **Just-in-time rule injection.** Before each tool call, searches active rules for matches against `tool_name + tool_input` and injects the top 3 (excluding raw failures) as a `<system-reminder>` block adjacent to the action. Closes the rule-loading gap: rules are surfaced at the moment of decision, not 50,000 tokens upstream from where attention has moved on. Each injection is logged to `rule_injection_events` for outcome correlation. Pi has the equivalent via per-turn injection in the `before_agent_start` handler. |
+| `rule-injection-resolver` | PostToolUse / PostToolUseFailure | Resolves recorded `rule_injection_events` with the tool outcome (success/failure). Together with the injector, this becomes the new "is this rule actually helpful" signal — replacing the broken `(applied from memory: ...)` citation regex. |
 
 **Key behaviors:**
 - **LLM-first classification** via Claude Haiku — detects natural statements like "we use tabs here" or "tests go in \_\_tests\_\_/" that regex would miss
@@ -152,9 +155,10 @@ Claude Recall registers hooks on three Claude Code events to capture memories au
 - Batch classification: Stop and PreCompact hooks send all texts in a single API call
 - Near-duplicate detection via Jaccard similarity (55% threshold) prevents redundant storage
 - Per-event limits: 3 (Stop), 5 (PreCompact) to prevent DB flooding
+- Auto-checkpoint quality gate: refuses to save when the LLM detects the task was already complete — manual checkpoints stay sticky
 - Always exits 0 — hooks never block Claude
 
-**Setup:** Run `npx claude-recall setup --install` to register hooks in `.claude/settings.json`.
+**Setup:** Run `npx claude-recall setup --install` to register hooks in `.claude/settings.json`. After any upgrade, re-run `setup --install` in each project so newly-added hook events get registered (claude-recall uses a `hooksVersion` field to signal when registration has changed).
 
 ## Example Workflows
 

package/README.md

@@ -69,8 +69,8 @@ Both agents use the same database (`~/.claude-recall/claude-recall.db`). Memorie
 npm install -g claude-recall
 claude-recall setup --install    # run from each project directory
 
-# Pi
-pi update claude-recall
+# Pi — must include the npm: prefix (matches the install command)
+pi update npm:claude-recall
 ```
 
 The MCP server picks up the new version automatically. `setup --install` is needed to update hooks in `.claude/settings.json` (new hook events may have been added).
@@ -90,6 +90,8 @@ Once installed, Claude Recall works automatically in the background:
 7. **After context compression** (Claude Code only) — rules are automatically re-injected into context so they're not lost when the window shrinks
 8. **Sub-agent recall** (Claude Code only) — when sub-agents are spawned, active rules are injected into their context automatically. Sub-agent outcomes (completed/failed/killed) are captured as events
 9. **Rules sync** (Claude Code only) — top 30 rules are exported as typed `.md` files to Claude Code's native memory directory
+10. **Auto-checkpoint on session exit** — when a session ends (Pi shutdown or Claude Code's `SessionEnd` for `clear`/`prompt_input_exit`/`logout`), the most recent task is extracted via Haiku into a structured `{completed, remaining, blockers}` checkpoint and saved for the next session. Critical for Pi (which has no `--resume` flag); a useful safety net for Claude Code users who exit without resuming. Conservative quality gate refuses to save when the LLM detects the task was already complete — manual checkpoints are never clobbered with garbage
+11. **Just-in-time rule injection (JITRI)** — before each tool call (Claude Code) or each agent turn (Pi), the most relevant active rules are searched against `tool_name + tool_input + recent prompt` and injected as a `<system-reminder>` block immediately adjacent to the action. This closes the rule-loading gap: rules are no longer just loaded once at session start (where attention decays as context grows) — they're surfaced at the moment of decision. Each injection is recorded in `rule_injection_events` and resolved with the tool outcome via PostToolUse, replacing the broken citation-detection regex with direct measurement of "was the relevant rule present when the action happened?"
 
 Classification uses Claude Haiku (via `ANTHROPIC_API_KEY`) with silent regex fallback. No configuration needed.
 
@@ -198,6 +200,22 @@ claude-recall checkpoint clear             # Delete the checkpoint
 
 Agents can also save/load checkpoints via MCP tools (`mcp__claude-recall__save_checkpoint` / `mcp__claude-recall__load_checkpoint`) or Pi tools (`recall_save_checkpoint` / `recall_load_checkpoint`).
 
+#### Auto-checkpoint on session exit (v0.21.2+)
+
+Manual `checkpoint save` is the explicit path. **Auto-checkpoint** is the safety net: when a session ends, the most recent task is extracted into a checkpoint automatically so the next session can resume.
+
+- **Pi** — fires from the `session_shutdown` event handler. In-process synchronous call, runs as part of the existing session-end pipeline. **Critical for Pi: there is no `pi --resume` equivalent, so without this, restarting Pi loses all session context.**
+- **Claude Code** — fires from the `SessionEnd` hook for voluntary exit reasons (`clear`, `prompt_input_exit`, `logout`). Spawns a detached background worker (fork+unref) so it stays well within Claude Code's tight 1.5s `SessionEnd` timeout. Skips `bypass_permissions_disabled` and `other` reasons (those are system-driven, not user intent). Useful for users who exit and start fresh instead of using `claude --resume`.
+
+Both runtimes share the same Haiku-backed extraction (`extractCheckpointWithLLM`) and the same quality gate:
+
+- **Quality gate**: refuses to save if the LLM returns an empty or trivially-short `remaining` field. The model is prompted to detect completion signals (assistant said "Done.", user said "thanks", no follow-up question) and return empty `remaining` when the task is finished. **An empty checkpoint is far better than a fabricated one** — manual checkpoints are never overwritten with garbage.
+- **Notes tag**: auto-saved checkpoints include `[auto-saved on <pi|cc> session exit at <iso-timestamp>]` in the notes field, so you can tell auto from manual via `checkpoint load`.
+- **Requires `ANTHROPIC_API_KEY`**. Without it, `extractCheckpointWithLLM` returns `null` (graceful fallback) and no auto-checkpoint is saved. Manual `checkpoint save` still works.
+- **Disable**: remove the `SessionEnd` block from `.claude/settings.json` (Claude Code) or, for Pi, no per-project disable flag exists yet — open an issue if you need one.
+
+The auto-checkpoint never clobbers a useful manual checkpoint because of the quality gate. If the LLM doesn't see clear unfinished work, it returns empty and the gate refuses the save. Manual checkpoints stay sticky until you explicitly save over them.
+
 ### Troubleshooting
 
 ```bash

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

@@ -809,7 +809,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 = '12.0.0'; // v12 = add SubagentStart/Stop for sub-agent recall integration
+        settings.hooksVersion = '14.0.0'; // v14 = add PreToolUse rule-injector + Post resolver for JITRI
         settings.hooks = {
             SubagentStart: [
                 {
@@ -852,6 +852,11 @@ async function main() {
                             type: "command",
                             command: `${hookCmd} tool-outcome-watcher`,
                             timeout: 3
+                        },
+                        {
+                            type: "command",
+                            command: `${hookCmd} rule-injection-resolver`,
+                            timeout: 3
                         }
                     ]
                 }
@@ -863,6 +868,11 @@ async function main() {
                             type: "command",
                             command: `${hookCmd} tool-failure`,
                             timeout: 3
+                        },
+                        {
+                            type: "command",
+                            command: `${hookCmd} rule-injection-resolver`,
+                            timeout: 3
                         }
                     ]
                 }
@@ -874,6 +884,11 @@ async function main() {
                         {
                             type: "command",
                             command: `python3 ${hookDest}`
+                        },
+                        {
+                            type: "command",
+                            command: `${hookCmd} rule-injector`,
+                            timeout: 5
                         }
                     ]
                 }
@@ -919,6 +934,20 @@ async function main() {
                         }
                     ]
                 }
+            ],
+            // Auto-checkpoint on voluntary session exits. Worker is fire-and-forget,
+            // so the synchronous handler returns instantly (well within CC's tight
+            // 1.5s SessionEnd timeout). Symmetric with Pi's session_shutdown handler.
+            SessionEnd: [
+                {
+                    hooks: [
+                        {
+                            type: "command",
+                            command: `${hookCmd} session-end-checkpoint`,
+                            timeout: 5
+                        }
+                    ]
+                }
             ]
         };
         if (!fs.existsSync(claudeDir)) {

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

@@ -106,9 +106,29 @@ class HookCommands {
                         await handleBashFailureWatcher(input);
                         break;
                     }
+                    case 'session-end-checkpoint': {
+                        const { handleSessionEndCheckpoint } = await Promise.resolve().then(() => __importStar(require('../../hooks/session-end-checkpoint')));
+                        await handleSessionEndCheckpoint(input);
+                        break;
+                    }
+                    case 'session-end-checkpoint-worker': {
+                        const { handleSessionEndCheckpointWorker } = await Promise.resolve().then(() => __importStar(require('../../hooks/session-end-checkpoint-worker')));
+                        await handleSessionEndCheckpointWorker(input);
+                        break;
+                    }
+                    case 'rule-injector': {
+                        const { handleRuleInjector } = await Promise.resolve().then(() => __importStar(require('../../hooks/rule-injector')));
+                        await handleRuleInjector(input);
+                        break;
+                    }
+                    case 'rule-injection-resolver': {
+                        const { handleRuleInjectionResolver } = await Promise.resolve().then(() => __importStar(require('../../hooks/rule-injection-resolver')));
+                        await handleRuleInjectionResolver(input);
+                        break;
+                    }
                     default:
                         console.error(`Unknown hook: ${name}`);
-                        console.error('Available: correction-detector, memory-stop, precompact-preserve, memory-sync, tool-outcome-watcher');
+                        console.error('Available: correction-detector, memory-stop, precompact-preserve, memory-sync, tool-outcome-watcher, session-end-checkpoint');
                 }
             }
             catch {

package/dist/hooks/llm-classifier.js

@@ -9,6 +9,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.classifyWithLLM = classifyWithLLM;
 exports.extractHindsightHint = extractHindsightHint;
 exports.extractSessionLearningsWithLLM = extractSessionLearningsWithLLM;
+exports.extractCheckpointWithLLM = extractCheckpointWithLLM;
 exports.classifyBatchWithLLM = classifyBatchWithLLM;
 // Lazy singleton — avoid import cost when API key is absent
 let clientInstance; // undefined = not yet checked
@@ -217,6 +218,86 @@ async function extractSessionLearningsWithLLM(summary, existingMemories) {
         return null;
     }
 }
+const CHECKPOINT_EXTRACTION_PROMPT = `You are extracting a "where I left off" checkpoint from a coding session that just ended. The next session — possibly minutes from now, possibly days later — needs a brief, accurate hint to resume from. Your output will overwrite any existing checkpoint, so it MUST be either accurate or empty. NEVER fabricate.
+
+You will see the FINAL portion of a session transcript. Your job is to extract THREE fields:
+
+- completed: what the user/agent finished in THIS recent task (concrete, brief, max 200 chars). Empty string if nothing was clearly completed.
+- remaining: what was still in flight when the session ended — the actual hand-off (concrete, brief, max 300 chars). MUST be non-empty if there is real unfinished work. EMPTY STRING if the task is done.
+- blockers: anything that was blocking progress (tools failing, decisions pending, dependencies). "none" if no blockers.
+
+THE MOST IMPORTANT RULE — completion detection:
+If the transcript ends with ANY signal that the task is finished, return remaining="". Completion signals include:
+- assistant says "Done.", "All set.", "All done.", "Finished.", "That's it.", "Complete.", or similar terminal acknowledgement
+- last user message is thanks/acknowledgement ("thanks", "perfect", "great") with no follow-up question
+- tool calls succeeded and there is no explicit next step in the user's most recent prompt
+- the conversation has reached a natural stopping point
+
+When in doubt, prefer remaining="". An empty checkpoint is far better than a fabricated one.
+
+THE SECOND MOST IMPORTANT RULE — no fabrication:
+- ONLY use information present in the transcript. Do NOT extrapolate, do NOT invent follow-up work.
+- If the most recent task is clearly complete, do NOT manufacture next steps from your imagination.
+- If you cannot determine what was happening with high confidence, return all-empty: {"completed":"","remaining":"","blockers":""}
+- "remaining" must be a SPECIFIC unfinished item visible in the transcript. Never generic ("continue work", "more testing", "documentation").
+
+Other rules:
+- Focus ONLY on the most recent coherent task. Ignore earlier work in the session.
+- Return JSON: {"completed":"...","remaining":"...","blockers":"..."}
+- Be terse and specific. Each field should help the future session pick up the thread.
+- Do NOT include markdown fences. Respond with raw JSON only.
+
+Examples of GOOD output:
+
+Scenario A — task finished, agent said "Done.":
+{"completed":"Copied cc-source-code into a dedicated dir under claude-recall/cc-source-code/","remaining":"","blockers":"none"}
+
+Scenario B — task in progress, midway through implementation:
+{"completed":"Added saveCheckpoint() to storage and MemoryService","remaining":"Wire CLI checkpoint command and add MCP/Pi tool wrappers","blockers":"none"}
+
+Scenario C — task in progress, blocked on something:
+{"completed":"Diagnosed [object Object] rendering bug in handleLoadRules","remaining":"Write failing test, extract formatRuleValue helper, replace 5 call sites","blockers":"none"}
+
+Scenario D — uncertain, sparse context, can't tell what's happening:
+{"completed":"","remaining":"","blockers":""}
+
+Scenario E — just a question, no work done:
+{"completed":"","remaining":"","blockers":""}
+
+Examples of BAD output (DO NOT DO THIS):
+{"completed":"various changes","remaining":"more work","blockers":"none"}              # too vague
+{"completed":"explored architecture","remaining":"document findings","blockers":"none"} # FABRICATED — there was no documentation task
+{"completed":"finished everything","remaining":"finish everything","blockers":"none"}   # nonsense filler`;
+async function extractCheckpointWithLLM(conversationSummary) {
+    const client = getClient();
+    if (!client)
+        return null;
+    if (!conversationSummary || conversationSummary.trim().length < 30) {
+        return null;
+    }
+    try {
+        const response = await client.messages.create({
+            model: MODEL,
+            max_tokens: 600,
+            system: CHECKPOINT_EXTRACTION_PROMPT,
+            messages: [{ role: 'user', content: conversationSummary }],
+        });
+        const content = response.content?.[0];
+        if (content?.type !== 'text')
+            return null;
+        const result = parseJSON(content.text);
+        if (typeof result !== 'object' || result === null)
+            return null;
+        return {
+            completed: typeof result.completed === 'string' ? result.completed : '',
+            remaining: typeof result.remaining === 'string' ? result.remaining : '',
+            blockers: typeof result.blockers === 'string' ? result.blockers : '',
+        };
+    }
+    catch {
+        return null;
+    }
+}
 async function classifyBatchWithLLM(texts) {
     if (texts.length === 0)
         return [];

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

@@ -174,9 +174,9 @@ async function handleMemoryStop(input) {
     // Prune old outcome data to prevent unbounded table growth
     try {
         const pruned = outcomeStorage.pruneOldData();
-        const total = pruned.episodes + pruned.events + pruned.lessons + pruned.stats;
+        const total = pruned.episodes + pruned.events + pruned.lessons + pruned.stats + pruned.injections;
         if (total > 0) {
-            (0, shared_1.hookLog)('memory-stop', `Pruned: ${pruned.episodes} episodes, ${pruned.events} events, ${pruned.lessons} lessons, ${pruned.stats} orphaned stats`);
+            (0, shared_1.hookLog)('memory-stop', `Pruned: ${pruned.episodes} episodes, ${pruned.events} events, ${pruned.lessons} lessons, ${pruned.stats} orphaned stats, ${pruned.injections} injections`);
         }
     }
     catch (err) {

package/dist/hooks/rule-injection-resolver.js

@@ -0,0 +1,43 @@
+"use strict";
+/**
+ * rule-injection-resolver hook — fires on PostToolUse and PostToolUseFailure.
+ *
+ * Counterpart to rule-injector.ts. After a tool call completes (successfully
+ * or with failure), this hook resolves any rule_injection_events that were
+ * recorded for that tool_use_id with the actual outcome.
+ *
+ * The pair gives us a direct measurement of rule effectiveness:
+ *   - Rule X was injected before Bash call Y
+ *   - Bash call Y succeeded → rule X co-occurs with success
+ *   - Bash call Y failed → rule X was either ignored, wrong, or unrelated
+ *
+ * Aggregated over time, this becomes the new "is this rule helpful" signal,
+ * replacing the broken citation-detection regex (.research/rule-loading-gap.md).
+ *
+ * Always exits cleanly with no stdout — this hook only writes to the DB,
+ * it doesn't influence tool execution.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleRuleInjectionResolver = handleRuleInjectionResolver;
+const shared_1 = require("./shared");
+const outcome_storage_1 = require("../services/outcome-storage");
+async function handleRuleInjectionResolver(input) {
+    const toolUseId = input?.tool_use_id ?? '';
+    const eventName = input?.hook_event_name ?? '';
+    if (!toolUseId) {
+        return;
+    }
+    // Outcome inference: PostToolUseFailure means failure, anything else means success.
+    // (PostToolUse fires on success; PostToolUseFailure on tool errors.)
+    const outcome = eventName === 'PostToolUseFailure' ? 'failure' : 'success';
+    try {
+        const outcomeStorage = outcome_storage_1.OutcomeStorage.getInstance();
+        const resolved = outcomeStorage.resolveRuleInjections(toolUseId, outcome);
+        if (resolved > 0) {
+            (0, shared_1.hookLog)('rule-injection-resolver', `Resolved ${resolved} rule injection(s) for ${toolUseId} as ${outcome}`);
+        }
+    }
+    catch (err) {
+        (0, shared_1.hookLog)('rule-injection-resolver', `Error: ${err.message}`);
+    }
+}

package/dist/hooks/rule-injector.js

@@ -0,0 +1,155 @@
+"use strict";
+/**
+ * rule-injector hook — fires on Claude Code's PreToolUse event.
+ *
+ * Just-in-time rule injection (JITRI). The core fix for the rule-loading gap
+ * documented in .research/rule-loading-gap.md: rules are loaded once at session
+ * start, then ignored when the agent acts because they're 50,000 tokens upstream
+ * by the time of the action. This hook closes that gap by searching active rules
+ * for matches against THIS specific tool call and injecting the top matches as
+ * a system-reminder block immediately adjacent to the tool action.
+ *
+ * Output mechanism (verified against cc-source-code/utils/hooks.ts:621 and
+ * services/tools/toolHooks.ts:565):
+ *   - Hook prints JSON to stdout
+ *   - JSON includes hookSpecificOutput.additionalContext
+ *   - CC wraps that string in a <system-reminder> block via wrapInSystemReminder()
+ *     and creates a meta user message at the moment of the tool call
+ *   - The agent sees the rules adjacent to the action it's about to take
+ *
+ * No LLM call in the hot path — pure keyword-based ranking, ~10-30ms typical.
+ *
+ * Each injection is recorded as a rule_injection_event so we can later
+ * resolve it with the tool outcome (success/failure) and measure rule
+ * effectiveness directly. This is the meter that replaces the broken
+ * citation-detection regex.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleRuleInjector = handleRuleInjector;
+const shared_1 = require("./shared");
+const memory_1 = require("../services/memory");
+const config_1 = require("../services/config");
+const outcome_storage_1 = require("../services/outcome-storage");
+const rule_retrieval_1 = require("../services/rule-retrieval");
+const memory_tools_1 = require("../mcp/tools/memory-tools");
+const TYPE_LABELS = {
+    correction: 'correction',
+    devops: 'devops',
+    preference: 'preference',
+    failure: 'avoid',
+    'project-knowledge': 'project',
+};
+/**
+ * Render a rule's value for injection. Reuses the same formatRuleValue helper
+ * that handleLoadRules uses (memory-tools.ts), so the rule-injector and
+ * load_rules output stay consistent. handles all the historical value shapes
+ * including nested-content failures and stringified-JSON content.
+ */
+function extractRuleSnippet(value) {
+    let snippet = (0, memory_tools_1.formatRuleValue)(value);
+    // formatRuleValue may return a stringified JSON for legacy shapes where
+    // value.content is a JSON string. Try one parse-and-extract pass to pull
+    // out a more readable summary.
+    if (snippet.startsWith('{') && snippet.includes('what_failed')) {
+        try {
+            const parsed = JSON.parse(snippet);
+            if (typeof parsed?.what_failed === 'string') {
+                snippet = parsed.what_failed;
+            }
+        }
+        catch { /* fall through with the stringified JSON */ }
+    }
+    return snippet;
+}
+function formatInjection(matches, toolName) {
+    if (matches.length === 0)
+        return '';
+    const lines = matches.map(m => {
+        const label = TYPE_LABELS[m.rule.type] ?? m.rule.type;
+        const snippet = extractRuleSnippet(m.rule.value).substring(0, 200).replace(/\s+/g, ' ').trim();
+        return `• [${label}] ${snippet}`;
+    });
+    return (`Recall: ${matches.length} rule${matches.length === 1 ? '' : 's'} relevant to this ${toolName} call. ` +
+        `Apply them or explicitly note why they don't fit:\n${lines.join('\n')}`);
+}
+async function handleRuleInjector(input) {
+    const toolName = input?.tool_name ?? '';
+    const toolInput = input?.tool_input ?? {};
+    const toolUseId = input?.tool_use_id ?? '';
+    if (!toolName) {
+        // Nothing to do — print empty JSON so CC parses it cleanly
+        process.stdout.write('{}\n');
+        return;
+    }
+    // Skip the hook for our own tools so we don't recursively inject rules
+    // about claude-recall into claude-recall calls. The agent already has
+    // claude-recall context when calling its own tools.
+    if (toolName.startsWith('mcp__claude-recall__') || toolName.startsWith('mcp__claude_recall')) {
+        process.stdout.write('{}\n');
+        return;
+    }
+    try {
+        const projectId = config_1.ConfigService.getInstance().getProjectId();
+        const memoryService = memory_1.MemoryService.getInstance();
+        // Fetch all active rules for this project. We pass them all to the ranker
+        // because the ranking function is fast and we want sticky rules to surface
+        // even when token overlap is low.
+        const activeRules = memoryService.loadActiveRules(projectId);
+        const allRules = [
+            ...activeRules.preferences,
+            ...activeRules.corrections,
+            ...activeRules.failures,
+            ...activeRules.devops,
+        ].map(m => ({
+            key: m.key,
+            type: m.type,
+            value: m.value,
+            is_active: m.is_active !== false,
+            timestamp: m.timestamp,
+            project_id: m.project_id,
+        }));
+        if (allRules.length === 0) {
+            (0, shared_1.hookLog)('rule-injector', `No active rules for project ${projectId} (tool=${toolName})`);
+            process.stdout.write('{}\n');
+            return;
+        }
+        const matches = (0, rule_retrieval_1.rankRulesForToolCall)(toolName, toolInput, allRules);
+        if (matches.length === 0) {
+            (0, shared_1.hookLog)('rule-injector', `No relevant rules for ${toolName} (scanned ${allRules.length})`);
+            process.stdout.write('{}\n');
+            return;
+        }
+        // Record each injection so PostToolUse can resolve it with the outcome
+        try {
+            const outcomeStorage = outcome_storage_1.OutcomeStorage.getInstance();
+            for (const m of matches) {
+                outcomeStorage.recordRuleInjection({
+                    rule_key: m.rule.key,
+                    tool_name: toolName,
+                    tool_use_id: toolUseId,
+                    project_id: projectId,
+                    match_score: m.score,
+                    matched_tokens: m.matchedTokens,
+                });
+            }
+        }
+        catch (err) {
+            // Non-critical — failure to record shouldn't block the injection itself
+            (0, shared_1.hookLog)('rule-injector', `Failed to record injections: ${err.message}`);
+        }
+        const additionalContext = formatInjection(matches, toolName);
+        const output = {
+            hookSpecificOutput: {
+                hookEventName: 'PreToolUse',
+                additionalContext,
+            },
+        };
+        process.stdout.write(JSON.stringify(output) + '\n');
+        (0, shared_1.hookLog)('rule-injector', `Injected ${matches.length} rule(s) for ${toolName} (top score=${matches[0].score.toFixed(3)})`);
+    }
+    catch (err) {
+        (0, shared_1.hookLog)('rule-injector', `Error: ${err.message}`);
+        // Best-effort — never block the tool call
+        process.stdout.write('{}\n');
+    }
+}