claude-recall 0.17.1 → 0.18.1

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

@@ -8,7 +8,7 @@ source: claude-recall
 
 # Corrections
 
-Auto-generated from 21 memories. Last updated: 2026-03-17.
+Auto-generated from 22 memories. Last updated: 2026-03-20.
 
 ## Rules
 
@@ -26,6 +26,7 @@ Auto-generated from 21 memories. Last updated: 2026-03-17.
 - CORRECTION: Memory with complex metadata
 - CORRECTION: Memory with complex metadata
 - CORRECTION: Memory with complex metadata
+- CORRECTION: Memory with complex metadata
 - CORRECTION: Replace expired access token with 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
 - CORRECTION: use spaces not tabs for indentation
 - CORRECTION: cited (loaded 5+ times): 19

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

@@ -1,9 +1,10 @@
 {
   "topicId": "corrections",
-  "sourceHash": "b717cebe14486cb8c7d1681f494e3e31136c32b0fe8a51112fe1c1a07bfe47f4",
-  "memoryCount": 21,
-  "generatedAt": "2026-03-17T09:43:28.791Z",
+  "sourceHash": "71d234bd5cea462bcfc192c4b421fc4d28d920f188c8393f0b3621e86092febe",
+  "memoryCount": 22,
+  "generatedAt": "2026-03-20T09:33:07.652Z",
   "memoryKeys": [
+    "memory_1773999187635_v9sxfphej",
     "memory_1773740608781_ae2bn7zos",
     "memory_1773659723317_o738xfbyw",
     "memory_1773656489899_l75d50pxo",

package/.claude/skills/auto-failure-lessons/SKILL.md

@@ -8,11 +8,12 @@ source: claude-recall
 
 # Failure Lessons
 
-Auto-generated from 24 memories. Last updated: 2026-03-17.
+Auto-generated from 25 memories. Last updated: 2026-03-20.
 
 ## Rules
 
 - SQLite query syntax error: LIKE clause requires single quotes around string literal, not double quotes
+- Avoid: Command failed: npx jest tests/unit/bash-failure-watcher.test.ts 2>&1 → Instead: Check command syntax, file paths, and prerequisites before running
 - Avoid: Command failed: npx jest tests/unit/memory-sync-hook.test.ts 2>&1 → Instead: Check command syntax, file paths, and prerequisites before running
 - Avoid: Command failed: npm whoami 2>&1 && npm config get registry 2>&1 → Instead: Check command syntax, file paths, and prerequisites before running
 - npm install -g claude-recall@0.15.36 failed with notarget error

package/.claude/skills/auto-failure-lessons/manifest.json

@@ -1,10 +1,11 @@
 {
   "topicId": "failure-lessons",
-  "sourceHash": "e099bbcfc9aa57afd1fb83ab4082a08ff820dd4f1dc31af6d4fbcfa3ad0af3d5",
-  "memoryCount": 24,
-  "generatedAt": "2026-03-17T09:43:28.755Z",
+  "sourceHash": "81c103e377f0523953c7512cbd3e06f5773ac5d57ddb8ec52e23b1effea1d1fe",
+  "memoryCount": 25,
+  "generatedAt": "2026-03-20T09:33:07.603Z",
   "memoryKeys": [
     "hook_failure_1772637584921_0tj4rrxnt",
+    "hook_failure_non-zero-exit_1773784543398_siidzp55g",
     "hook_failure_non-zero-exit_1773669669860_9mcdbx51y",
     "hook_failure_non-zero-exit_1773409269877_ful451241",
     "hook_failure_1773410916808_5k1r6zo4u",

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

@@ -8,10 +8,15 @@ source: claude-recall
 
 # Preferences
 
-Auto-generated from 91 memories. Last updated: 2026-03-17.
+Auto-generated from 98 memories. Last updated: 2026-03-20.
 
 ## Rules
 
+- Session test preference 1773999187736
+- Test preference 1773999187658-2
+- Test preference 1773999187658-1
+- Test preference 1773999187658-0
+- Test memory content
 - Session test preference 1773740608856
 - Test preference 1773740608797-2
 - Test preference 1773740608797-1
@@ -93,6 +98,7 @@ Auto-generated from 91 memories. Last updated: 2026-03-17.
 - Test memory 1770503266492-2
 - Test memory 1770503266492-1
 - Test memory 1770503266492-0
+- Do not bump version numbers without asking first
 - Use local node_modules/.bin/claude-recall path in setup --install hook commands instead of npx to avoid registry hits
 - Use YYYYMMDD_descriptive_name.md naming convention for markdown files
 - When user says 'jam', it means 'just answer me' — a shorthand directive to provide direct answers without elaboration
@@ -103,6 +109,7 @@ Auto-generated from 91 memories. Last updated: 2026-03-17.
 - always use tabs
 - Do not change TTL settings—current configuration was deliberately chosen for a reason
 - Do not change TTL settings; current configuration is intentional and should be preserved
+- you to replace existing install instructions on project readme with the above
 
 ---
 *Auto-generated by Claude Recall. Regenerate: `npx claude-recall skills generate`*

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

@@ -1,9 +1,14 @@
 {
   "topicId": "preferences",
-  "sourceHash": "e2c0f6c21a82d06422afe3b9bddeca1a865d50a9472e3868459612589dd9f5e9",
-  "memoryCount": 91,
-  "generatedAt": "2026-03-17T09:43:28.867Z",
+  "sourceHash": "e48e55f7de632696ce32c04f23c2e470a590547bb8541501214650efe670496e",
+  "memoryCount": 98,
+  "generatedAt": "2026-03-20T09:33:07.756Z",
   "memoryKeys": [
+    "memory_1773999187737_qrdwbas47",
+    "memory_1773999187696_gymxhasno",
+    "memory_1773999187680_p6rxtp38v",
+    "memory_1773999187660_0at06kilq",
+    "memory_1773999187564_d7j4ivfjo",
     "memory_1773740608857_7954nxhke",
     "memory_1773740608828_pkci7qhtt",
     "memory_1773740608815_k3tj4psf1",
@@ -85,6 +90,7 @@
     "memory_1770503266534_iq6pvjqj6",
     "memory_1770503266513_a1nxjz4j2",
     "memory_1770503266494_f3p8e15xv",
+    "hook_preference_1773743105207_791mk6w14",
     "hook_preference_1772641938714_ucidifq0v",
     "hook_preference_1772633980785_n9bwj39q4",
     "hook_preference_1771934420257_l4pawjgn5",
@@ -94,6 +100,7 @@
     "hook_preference_1771112104493_d3nz1o2ye",
     "hook_preference_1771112075356_3gh724ucm",
     "hook_preference_1773220761159_igi8x4tax",
-    "hook_preference_1773220748369_qpl2lvvpd"
+    "hook_preference_1773220748369_qpl2lvvpd",
+    "hook_preference_1773784604998_geftlce1x"
   ]
 }

package/README.md

@@ -14,6 +14,7 @@ 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
 - **Local-Only** — SQLite on your machine, no telemetry, no cloud, works fully offline
 
@@ -74,9 +75,11 @@ 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
-4. **Before context compression** — the `precompact-preserve` hook sweeps up to 50 entries so nothing important is lost when the context window shrinks
-5. **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
+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
+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
 
 All classification uses Claude Haiku (via `ANTHROPIC_API_KEY` from your Claude Code session) with silent regex fallback. No configuration needed.
 
@@ -102,6 +105,20 @@ Claude Recall runs as an MCP server exposing four tools, backed by a local SQLit
 | `search_memory` | Search memories by keyword, ranked by relevance |
 | `delete_memory` | Delete a specific memory by ID |
 
+### Outcome-Aware Learning (v0.18.0)
+
+Claude Recall tracks what happens *after* Claude acts — not just what was said. The outcome processing pipeline:
+
+```
+action → outcome event → episode → candidate lesson → promotion → active rule
+```
+
+- **Outcome events** capture bash results, 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
+- **Outcome-aware retrieval** boosts memories with evidence, penalizes stale/unhelpful ones
+
 ---
 
 ## CLI Reference

package/dist/core/retrieval.js

@@ -134,6 +134,24 @@ class MemoryRetrieval {
         // Strength-based boost (replaces ad-hoc access_count and last_accessed boosts)
         const strength = MemoryRetrieval.computeStrength(memory);
         score *= 1 + strength * 2.0; // Up to 3x boost for max-strength memories
+        // Evidence boost: promoted lessons seen multiple times
+        const evidenceCount = this.getEvidenceCount(memory);
+        if (evidenceCount > 1) {
+            score *= 1 + Math.min(evidenceCount, 5) * 0.15; // up to 1.75x
+        }
+        // Helpfulness prior: retrieved + confirmed helpful
+        const stats = this.getMemoryStats(memory.key);
+        if (stats && stats.times_retrieved > 0) {
+            const helpRatio = stats.times_helpful / stats.times_retrieved;
+            score *= 0.8 + helpRatio * 0.4; // 0.8x to 1.2x
+        }
+        // Staleness penalty: old with no recent confirmation
+        if (stats?.last_confirmed_at) {
+            const daysSinceConfirmed = (Date.now() - new Date(stats.last_confirmed_at).getTime()) / 86400000;
+            if (daysSinceConfirmed > 30) {
+                score *= Math.max(0.5, 1 - (daysSinceConfirmed - 30) / 180);
+            }
+        }
         return score;
     }
     /**
@@ -189,6 +207,24 @@ class MemoryRetrieval {
         const timeDecay = Math.pow(0.5, daysSinceTouch / classConfig.halfLife);
         return Math.min(signalScore * timeDecay, 1.0);
     }
+    getMemoryStats(key) {
+        try {
+            const row = this.storage.getDatabase().prepare('SELECT times_retrieved, times_helpful, last_confirmed_at FROM memory_stats WHERE memory_key = ?').get(key);
+            return row || null;
+        }
+        catch {
+            return null;
+        }
+    }
+    getEvidenceCount(memory) {
+        try {
+            const row = this.storage.getDatabase().prepare("SELECT evidence_count FROM candidate_lessons WHERE promoted_memory_key = ? AND status = 'promoted' LIMIT 1").get(memory.key);
+            return row?.evidence_count || 0;
+        }
+        catch {
+            return 0;
+        }
+    }
     searchByKeyword(keyword) {
         const results = this.storage.search(keyword);
         const context = { timestamp: Date.now() };

package/dist/hooks/bash-failure-watcher.js

@@ -53,6 +53,7 @@ const path = __importStar(require("path"));
 const os = __importStar(require("os"));
 const shared_1 = require("./shared");
 const memory_1 = require("../services/memory");
+const outcome_storage_1 = require("../services/outcome-storage");
 const HOOK_NAME = 'bash-failure-watcher';
 const EXIT_CODE_REGEX = /Exit code (\d+)/;
 const MAX_PENDING = 5;
@@ -152,6 +153,21 @@ async function handleFailure(command, exitCode, output, sessionId) {
         context: { timestamp: Date.now() },
         relevanceScore: 0.85,
     });
+    // Write outcome event for outcome-aware learning
+    try {
+        const outcomeStorage = outcome_storage_1.OutcomeStorage.getInstance();
+        outcomeStorage.createOutcomeEvent({
+            event_type: 'bash_result',
+            actor: 'tool',
+            action_summary: `Bash: ${truncate(command, 100)}`,
+            next_state_summary: `Exit code ${exitCode}: ${truncate(firstLine(output), 150)}`,
+            exit_code: parseInt(exitCode),
+            tags: extractCommandTags(command),
+        });
+    }
+    catch (err) {
+        (0, shared_1.hookLog)(HOOK_NAME, `Outcome event error: ${err}`);
+    }
     (0, shared_1.hookLog)(HOOK_NAME, `Stored failure: ${truncate(command, 60)} (exit ${exitCode})`);
     // Track pending failure for fix pairing
     const pending = readPendingFailures(sessionId);
@@ -186,6 +202,21 @@ async function handleSuccess(command, sessionId) {
                         what_should_do: `Fix: ${truncate(command, 200)}`,
                     },
                 });
+                // Write positive outcome event for the fix
+                try {
+                    const outcomeStorage = outcome_storage_1.OutcomeStorage.getInstance();
+                    outcomeStorage.createOutcomeEvent({
+                        event_type: 'bash_result',
+                        actor: 'tool',
+                        action_summary: `Fix: ${truncate(command, 100)}`,
+                        next_state_summary: `Success after previous failure: ${truncate(pf.command, 100)}`,
+                        exit_code: 0,
+                        tags: extractCommandTags(command),
+                    });
+                }
+                catch (err) {
+                    (0, shared_1.hookLog)(HOOK_NAME, `Positive outcome event error: ${err}`);
+                }
                 (0, shared_1.hookLog)(HOOK_NAME, `Paired fix: "${truncate(command, 60)}" → ${pf.memoryKey}`);
                 matched = true;
                 // Don't add to remaining — consumed
@@ -201,3 +232,22 @@ async function handleSuccess(command, sessionId) {
     }
     writePendingFailures(sessionId, remaining);
 }
+/**
+ * Extract command tags from a bash command for outcome tagging.
+ * e.g., "npm test -- --coverage" → ["npm", "test"]
+ */
+function extractCommandTags(command) {
+    const parts = command.trim().split(/\s+/).filter(Boolean);
+    // Take first 2 meaningful tokens (skip flags starting with -)
+    const tags = [];
+    for (const part of parts) {
+        if (part.startsWith('-'))
+            continue;
+        if (part.includes('/') && part.length > 20)
+            continue; // Skip long paths
+        tags.push(part.toLowerCase());
+        if (tags.length >= 2)
+            break;
+    }
+    return tags;
+}

package/dist/hooks/correction-detector.js

@@ -9,6 +9,15 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.handleCorrectionDetector = handleCorrectionDetector;
 const shared_1 = require("./shared");
+const outcome_storage_1 = require("../services/outcome-storage");
+const REASK_PATTERNS = [
+    /still broken/i,
+    /that'?s not what I (?:meant|asked|wanted)/i,
+    /wrong file/i,
+    /try again/i,
+    /that didn'?t (?:work|fix|help)/i,
+    /you (?:missed|forgot|ignored)/i,
+];
 async function handleCorrectionDetector(input) {
     const prompt = input?.prompt ?? '';
     // Skip trivial / non-text input
@@ -16,6 +25,23 @@ async function handleCorrectionDetector(input) {
         return;
     if (prompt.startsWith('```') || prompt.startsWith('{'))
         return;
+    // Detect reask signals before classification
+    try {
+        for (const pattern of REASK_PATTERNS) {
+            if (pattern.test(prompt)) {
+                outcome_storage_1.OutcomeStorage.getInstance().createOutcomeEvent({
+                    event_type: 'reask_signal',
+                    actor: 'user',
+                    next_state_summary: `User reask detected: ${prompt.substring(0, 100)}`,
+                    tags: ['reask'],
+                });
+                break;
+            }
+        }
+    }
+    catch (err) {
+        (0, shared_1.hookLog)('correction-detector', `Reask signal detection error: ${err}`);
+    }
     const result = await (0, shared_1.classifyContent)(prompt);
     if (!result)
         return;

package/dist/hooks/llm-classifier.js

@@ -7,6 +7,7 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.classifyWithLLM = classifyWithLLM;
+exports.extractHindsightHint = extractHindsightHint;
 exports.classifyBatchWithLLM = classifyBatchWithLLM;
 // Lazy singleton — avoid import cost when API key is absent
 let clientInstance; // undefined = not yet checked
@@ -120,6 +121,33 @@ async function classifyWithLLM(text) {
  * Returns an array of results (null for unclassifiable items).
  * Falls back to null array on total failure (caller should use regex).
  */
+async function extractHindsightHint(failureDescription, context) {
+    const client = getClient();
+    if (!client)
+        return null;
+    try {
+        const response = await client.messages.create({
+            model: MODEL,
+            max_tokens: 300,
+            system: 'You extract actionable hindsight lessons from failures. Given a failure description and context, produce a JSON object with: hint_text (imperative rule to prevent recurrence), hint_kind (one of: rule, preference, anti_pattern, workflow, debug_fix, failure_preventer), applies_when (array of 1-3 situation tags). Respond with ONLY valid JSON.',
+            messages: [{ role: 'user', content: `Failure: ${failureDescription}\nContext: ${context}` }],
+        });
+        const content = response.content?.[0];
+        if (content?.type !== 'text')
+            return null;
+        const result = parseJSON(content.text);
+        if (!result.hint_text || !result.hint_kind)
+            return null;
+        return {
+            hint_text: result.hint_text,
+            hint_kind: result.hint_kind,
+            applies_when: Array.isArray(result.applies_when) ? result.applies_when : [],
+        };
+    }
+    catch {
+        return null;
+    }
+}
 async function classifyBatchWithLLM(texts) {
     if (texts.length === 0)
         return [];

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

@@ -6,12 +6,46 @@
  * Reads the last 6 transcript entries, classifies them,
  * dedup-checks, and stores up to 3 new memories.
  */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.handleMemoryStop = handleMemoryStop;
 const shared_1 = require("./shared");
 const memory_1 = require("../services/memory");
 const config_1 = require("../services/config");
 const failure_detectors_1 = require("./failure-detectors");
+const outcome_storage_1 = require("../services/outcome-storage");
 const MAX_STORE = 3;
 async function handleMemoryStop(input) {
     const transcriptPath = input?.transcript_path ?? '';
@@ -24,6 +58,14 @@ async function handleMemoryStop(input) {
         (0, shared_1.hookLog)('memory-stop', 'No transcript entries found');
         return;
     }
+    // Create an episode for this session
+    const outcomeStorage = outcome_storage_1.OutcomeStorage.getInstance();
+    const projectId = config_1.ConfigService.getInstance().getProjectId();
+    const episodeId = outcomeStorage.createEpisode({
+        project_id: projectId,
+        session_id: input?.session_id,
+        source: 'memory-stop',
+    });
     // Extract user-only texts, filter, then batch-classify in one API call
     const textsWithIndex = [];
     for (let i = 0; i < entries.length; i++) {
@@ -68,7 +110,25 @@ async function handleMemoryStop(input) {
     // Scan for citations in assistant messages to track compliance
     scanForCitations(transcriptPath);
     // Scan transcript for failure signals (non-zero exits, test cycles, backtracking, etc.)
-    detectAndStoreFailures(transcriptPath);
+    const failures = detectAndStoreFailures(transcriptPath, episodeId);
+    outcomeStorage.updateEpisode(episodeId, {
+        outcome_type: failures.length > 0 ? 'failure' : 'success',
+        severity: failures.length > 0 ? 'medium' : 'low',
+        outcome_summary: `${stored} memories, ${failures.length} failures`,
+    });
+    // Generate candidate lessons from high-confidence failures
+    generateCandidateLessons(failures, episodeId, projectId);
+    // Run promotion cycle
+    try {
+        const { PromotionEngine } = await Promise.resolve().then(() => __importStar(require('../services/promotion-engine')));
+        const result = PromotionEngine.getInstance().runCycle(projectId);
+        if (result.promoted > 0 || result.archived > 0) {
+            (0, shared_1.hookLog)('memory-stop', `Promotion: ${result.promoted} promoted, ${result.archived} archived`);
+        }
+    }
+    catch (err) {
+        (0, shared_1.hookLog)('memory-stop', `Promotion error: ${err}`);
+    }
 }
 /**
  * Scan transcript for (applied from memory: ...) citations and increment cite_count.
@@ -125,6 +185,10 @@ function scanForCitations(transcriptPath) {
             (0, shared_1.hookLog)('memory-stop', `Best match: "${bestContent}" containment=${bestScore.toFixed(3)} key=${bestKey}`);
             if (bestScore >= 0.5) {
                 memoryService.incrementCiteCount(bestKey);
+                try {
+                    outcome_storage_1.OutcomeStorage.getInstance().recordHelpful(bestKey);
+                }
+                catch { }
                 (0, shared_1.hookLog)('memory-stop', `Citation matched: "${cite.substring(0, 50)}" → rule ${bestKey} (containment=${bestScore.toFixed(3)})`);
             }
             else {
@@ -187,17 +251,17 @@ function extractRuleContent(value) {
 /**
  * Scan the last 200 transcript entries for failure signals and store up to 3.
  */
-function detectAndStoreFailures(transcriptPath) {
+function detectAndStoreFailures(transcriptPath, episodeId) {
     try {
         const entries = (0, shared_1.readTranscriptTail)(transcriptPath, 200);
         if (entries.length === 0) {
             (0, shared_1.hookLog)('memory-stop', '[FailureDetector] No entries to scan');
-            return;
+            return [];
         }
         const failures = (0, failure_detectors_1.detectTranscriptFailures)(entries);
         if (failures.length === 0) {
             (0, shared_1.hookLog)('memory-stop', '[FailureDetector] No failure signals detected');
-            return;
+            return [];
         }
         (0, shared_1.hookLog)('memory-stop', `[FailureDetector] Detected ${failures.length} failure signal(s)`);
         const projectId = config_1.ConfigService.getInstance().getProjectId();
@@ -230,8 +294,56 @@ function detectAndStoreFailures(transcriptPath) {
             (0, shared_1.hookLog)('memory-stop', `[FailureDetector] Stored ${failure.signal}: ${failure.content.what_failed.substring(0, 80)}`);
         }
         (0, shared_1.hookLog)('memory-stop', `[FailureDetector] Stored ${stored} failure(s) from ${failures.length} detected`);
+        return failures;
     }
     catch (error) {
         (0, shared_1.hookLog)('memory-stop', `[FailureDetector] Error: ${error}`);
+        return [];
+    }
+}
+/**
+ * Generate candidate lessons from high-confidence failures.
+ * Deduplicates against existing lessons and increments evidence count for similar ones.
+ */
+function generateCandidateLessons(failures, episodeId, projectId) {
+    try {
+        const outcomeStorage = outcome_storage_1.OutcomeStorage.getInstance();
+        for (const f of failures) {
+            if (f.confidence < 0.7)
+                continue;
+            const similar = outcomeStorage.findSimilarLessons(f.content.what_should_do, projectId);
+            if (similar.length > 0) {
+                outcomeStorage.incrementEvidenceCount(similar[0].id);
+            }
+            else {
+                outcomeStorage.createCandidateLesson({
+                    project_id: projectId,
+                    episode_id: episodeId,
+                    lesson_text: f.content.what_should_do,
+                    lesson_kind: 'failure_preventer',
+                    applies_when: extractTagsFromContext(f.content.context),
+                    outcome_type: 'negative',
+                    reward_band: -1,
+                    confidence: f.confidence,
+                    durability: 'project',
+                });
+            }
+        }
+    }
+    catch (err) {
+        (0, shared_1.hookLog)('memory-stop', `Candidate lesson generation error: ${err}`);
+    }
+}
+function extractTagsFromContext(context) {
+    const tags = [];
+    const words = context.toLowerCase().split(/\s+/).filter(w => w.length >= 4);
+    // Take up to 5 significant words as tags
+    for (const w of words) {
+        if (tags.length >= 5)
+            break;
+        if (!['that', 'this', 'with', 'from', 'were', 'been'].includes(w)) {
+            tags.push(w);
+        }
     }
+    return tags;
 }

package/dist/mcp/tools/memory-tools.js

@@ -4,6 +4,7 @@ exports.MemoryTools = void 0;
 const config_1 = require("../../services/config");
 const search_monitor_1 = require("../../services/search-monitor");
 const skill_generator_1 = require("../../services/skill-generator");
+const outcome_storage_1 = require("../../services/outcome-storage");
 class MemoryTools {
     constructor(memoryService, logger) {
         this.memoryService = memoryService;
@@ -294,6 +295,17 @@ class MemoryTools {
             ]);
             // Record to SearchMonitor so monitoring/stats still work
             this.searchMonitor.recordSearch('load_rules', totalRules, context.sessionId, 'mcp', { tool: 'load_rules', tokenMetrics: { resultTokens, tokensSaved: totalRules > 0 ? totalRules * 200 : 0 } });
+            // Track retrievals for outcome-aware scoring
+            try {
+                const outcomeStorage = outcome_storage_1.OutcomeStorage.getInstance();
+                const allMemories = [...rules.preferences, ...rules.corrections, ...rules.failures, ...rules.devops];
+                for (const m of allMemories) {
+                    outcomeStorage.recordRetrieval(m.key);
+                }
+            }
+            catch {
+                // Non-critical
+            }
             let rulesText;
             if (sections.length > 0) {
                 const body = sections.join('\n\n');
@@ -341,6 +353,16 @@ class MemoryTools {
             }
             const results = this.memoryService.findRelevant(searchContext);
             const topResults = results.slice(0, limit);
+            // Track retrievals in memory_stats
+            try {
+                const outcomeStorage = outcome_storage_1.OutcomeStorage.getInstance();
+                for (const r of topResults) {
+                    outcomeStorage.recordRetrieval(r.key);
+                }
+            }
+            catch {
+                // Non-critical — don't fail the search
+            }
             // Record to SearchMonitor
             this.searchMonitor.recordSearch(query, topResults.length, context.sessionId, 'mcp', { tool: 'search_memory', type: type || 'all' });
             const formatted = topResults.map(r => {