claude-recall 0.36.2 → 0.37.1

package/.claude/hooks/search_enforcer.py

@@ -16,7 +16,29 @@ from datetime import datetime
 
 STATE_DIR = Path.home() / '.claude-recall' / 'hook-state'
 SEARCH_TTL_MS = int(os.environ.get('CLAUDE_RECALL_SEARCH_TTL', 60 * 1000))  # 1 min default (once per task)
-ENFORCE_MODE = os.environ.get('CLAUDE_RECALL_ENFORCE_MODE', 'block')  # block, warn, off
+
+
+def _resolve_enforce_mode() -> str:
+    """Enforcement mode: env var wins, then ~/.claude-recall/config.json
+    ("enforceMode"), else default 'warn'. A file-based switch is reachable
+    from inside a running session (an agent can edit config.json to escape a
+    stuck gate); an env var set before launch is not. Default is 'warn' — this
+    gate is an advisory nudge (see module docstring), so it should never
+    hard-block a session by default."""
+    env = os.environ.get('CLAUDE_RECALL_ENFORCE_MODE')
+    if env:
+        return env.strip().lower()
+    try:
+        cfg = json.load(open(Path.home() / '.claude-recall' / 'config.json'))
+        mode = cfg.get('enforceMode')
+        if mode:
+            return str(mode).strip().lower()
+    except Exception:
+        pass
+    return 'warn'
+
+
+ENFORCE_MODE = _resolve_enforce_mode()  # block, warn, off
 MAX_BLOCKS = int(os.environ.get('CLAUDE_RECALL_MAX_BLOCKS', 3))  # degrade to warn after N blocks
 
 # Tools that count as "search performed"
@@ -182,6 +204,7 @@ STALE RULES — consider reloading before {tool_name}
 
 Rules were loaded earlier but TTL expired.
 Run: mcp__claude-recall__load_rules({{}})
+(If not directly callable, ToolSearch it first — see below.)
 ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
 """
         print(msg.strip(), file=sys.stderr)
@@ -214,10 +237,14 @@ LOAD RULES REQUIRED before {tool_name} (attempt {block_count}/{MAX_BLOCKS})
 ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
 
 Run: mcp__claude-recall__load_rules({{}})
+(If that tool is not directly callable, first run
+ ToolSearch({{query:"select:mcp__claude-recall__load_rules"}}) —
+ some harnesses defer MCP tool schemas until discovered.)
 
 This ensures you apply user preferences and avoid past mistakes.
 
-To disable: CLAUDE_RECALL_ENFORCE_MODE=off
+To disable this gate: set "enforceMode":"off" in ~/.claude-recall/config.json
+(or export CLAUDE_RECALL_ENFORCE_MODE=off before launching Claude Code).
 ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
 """
     print(msg.strip(), file=sys.stderr)

package/README.md

@@ -191,6 +191,7 @@ Once installed, Claude Recall works in the background (CC = Claude Code):
 | **Sub-agent spawned** | Rules are injected into the sub-agent; its outcome is captured | ✓ |  |  |
 | **Session exit** | An auto-checkpoint (`{completed, remaining, blockers}`) is saved for next time | ✓ | ✓ |  |
 | **End of session** | Failure patterns become candidate lessons; validated ones are promoted to rules | ✓ | ✓ |  |
+| **Hard-won success** | A goal that failed repeatedly then finally worked is captured as a reusable `solution` ([details](#success-capture)) | ✓ | ✓ |  |
 | **Once a day** | The memory janitor reviews stored rules with the runtime's LLM: demotes noise, merges duplicates, rewrites vague rules ([details](#memory-janitor)) | ✓ |  | ✓ |
 
 Classification runs on each runtime's **own** LLM — Claude Code via headless `claude -p` on your subscription; Kiro via `kiro-cli chat --no-interactive` on Kiro credits — with regex as the fallback. **An exported `ANTHROPIC_API_KEY` is never touched** unless you explicitly opt in with `CLAUDE_RECALL_PREFER_API_KEY=1`. No API key is ever required; no configuration needed.
@@ -277,7 +278,7 @@ claude-recall stats                      # Memory statistics (--global for all p
 claude-recall list                       # List memories, newest first (-t <type>, --all, --json, --global)
 claude-recall search "query"             # Search memories (--global, --json, --project <id>)
 claude-recall store "content"            # Store memory directly
-claude-recall store "content" -t <type>  # Type: preference, correction, failure, devops, project-knowledge
+claude-recall store "content" -t <type>  # Type: preference, correction, failure, devops, project-knowledge, solution
 claude-recall export backup.json         # Export current project (--global for all)
 claude-recall import backup.json         # Import memories from JSON
 claude-recall delete <key>               # Delete one memory by key (get keys from `search`)
@@ -353,6 +354,15 @@ action → outcome event → episode → candidate lesson → promotion → acti
 
 Failures become candidate lessons (deduplicated by similarity); lessons seen 2+ times (or once, if severe) are promoted to active rules; every just-in-time injection (Claude Code, Pi) is recorded and resolved against the tool's outcome, building per-rule effectiveness data over time.
 
+### Success capture
+
+Auto-capture is failure-biased by design — it learns from what breaks. But a hard-won *success* is just as reusable: the command, flag, or sequence you finally landed after several dead ends. Claude Recall captures those as a first-class `solution` memory, two ways:
+
+- **Automatically**, when a session shows a goal that failed **repeatedly** (≥2 distinct failed attempts) and then finally worked — it stores the reusable technique, generalized away from the one-off task. The multi-failure gate is deliberate: a first-try success or an unresolved struggle captures nothing, so routine wins don't become noise.
+- **Deliberately**, when you (or the agent) call `store_memory` with `type: "solution"` — the intended home for "I cracked this, don't make me re-derive it."
+
+A solution is active immediately (no wait for a second occurrence — you rarely crack the same hard thing twice), injected at every surface alongside your other rules, and ranked just below explicit corrections. List them with `claude-recall list --type solution`. Unlike other rules, solutions are exempt from the never-cited auto-demote sweep, so a rarely-needed-but-valuable win isn't retired.
+
 ### Memory janitor
 
 Automatic capture inevitably stores some noise — a conversational fragment misfiled as a preference, the same lesson in five wordings, a rule too vague to act on. Counters can flag *unused* rules (`CLAUDE_RECALL_AUTO_DEMOTE`), but they can't tell a rarely-cited gem from junk. Once a day, the **memory janitor** has the runtime's own LLM (same backend policy as capture — your Claude subscription or Kiro credits, never an API key unless you opted in) review the stored rules and:
@@ -450,7 +460,7 @@ Defaults work out of the box; tune via environment variables as needed.
 | `CLAUDE_RECALL_AUTO_CLEANUP`             | `false` | Auto-kill stale MCP processes on start (otherwise reports and exits).                                    |
 | `CLAUDE_RECALL_COMPACT_THRESHOLD`        | `10MB`  | DB size at which automatic compaction kicks in.                                                          |
 | `CLAUDE_RECALL_MAX_MEMORIES`             | `10000` | Memory-row soft cap.                                                                                     |
-| `CLAUDE_RECALL_ENFORCE_MODE`             | `on`    | Set to `off` to bypass the search-enforcer hook.                                                         |
+| `CLAUDE_RECALL_ENFORCE_MODE`             | `warn`  | `block` / `warn` / `off` for the search-enforcer hook. Env wins, else `~/.claude-recall/config.json` `"enforceMode"`, else `warn`. |
 | `CLAUDE_RECALL_LLM_TIMEOUT_MS`           | `5000`  | Timeout for hook-context LLM calls (classification, hindsight hints). Hooks fall back to regex when it fires. |
 | `CLAUDE_RECALL_STOP_DEBOUNCE_MS`         | `300000` | Debounce for the heavy Stop-hook pipeline (episodes, session extraction, promotion). `0` disables. |
 | `CLAUDE_RECALL_PROJECT_ID`               | *(cwd)*  | Pin the project scope to a fixed id, overriding working-directory detection. |

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

@@ -51,9 +51,10 @@ const hook_commands_1 = require("./commands/hook-commands");
 const kiro_commands_1 = require("./commands/kiro-commands");
 const repair_1 = require("./commands/repair");
 // v14 = add PreToolUse rule-injector + Post resolver for JITRI.
+// v15 = bound the search_enforcer PreToolUse entry with timeout: 5.
 // Bump when the hook block template changes — setup skips the settings
 // rewrite when the installed hooksVersion already matches.
-const HOOKS_VERSION = '14.0.0';
+const HOOKS_VERSION = '15.0.0';
 const parse_utils_1 = require("./parse-utils");
 const program = new commander_1.Command();
 class ClaudeRecallCLI {
@@ -1375,7 +1376,11 @@ async function main() {
                     hooks: [
                         {
                             type: "command",
-                            command: `python3 ${hookDest}`
+                            command: `python3 ${hookDest}`,
+                            // Runs before EVERY tool call (matcher .*). Bound the python3
+                            // cold start so it can't become a per-call latency tax or an
+                            // unbounded failure mode.
+                            timeout: 5
                         },
                         {
                             type: "command",

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

@@ -450,7 +450,7 @@ class KiroCommands {
                 : `project: ${projectId} (from working directory)`);
             line('•', `total memories (all projects): ${stats.total}`);
             const rules = ms.loadActiveRules(projectId);
-            const ruleCount = rules.preferences.length + rules.corrections.length + rules.failures.length + rules.devops.length;
+            const ruleCount = rules.preferences.length + rules.corrections.length + rules.failures.length + rules.devops.length + (rules.solutions ?? []).length;
             line(ruleCount > 0 ? '✓' : '•', `active rules for this project: ${ruleCount}`);
         }
         catch (err) {

package/dist/core/retrieval.js

@@ -270,6 +270,7 @@ class MemoryRetrieval {
 exports.MemoryRetrieval = MemoryRetrieval;
 MemoryRetrieval.TYPE_PRIORITY = {
     'correction': 6,
+    'solution': 5.5, // hard-won reusable solutions — high signal, rank just below corrections
     'project-knowledge': 5,
     'preference': 4,
     'devops': 3,

package/dist/hooks/kiro-hooks.js

@@ -125,11 +125,12 @@ function formatRulesForContext() {
     const sections = [
         section('Preferences', rules.preferences),
         section('Corrections', rules.corrections),
+        section('Solutions (hard-won — reuse these)', rules.solutions ?? []),
         section('Failures', rules.failures),
         section('DevOps Rules', rules.devops),
     ].filter((s) => s !== null);
     const total = rules.preferences.length + rules.corrections.length
-        + rules.failures.length + rules.devops.length;
+        + rules.failures.length + rules.devops.length + (rules.solutions ?? []).length;
     return { body: sections.join('\n\n'), total };
 }
 /**

package/dist/hooks/llm-classifier.js

@@ -257,6 +257,11 @@ const SESSION_EXTRACTION_PROMPT = `You are analyzing a coding session transcript
 
 The transcript shows tool calls (Bash, Edit, Read, Grep, etc.) and their results, plus user and assistant messages. Your primary job is to identify CAUSE-AND-EFFECT patterns — what failed, why, and what fixed it.
 
+PRIORITY 0 — Hard-won solutions (type "solution"):
+The MOST valuable thing to capture. Look for a goal the agent attempted, FAILED at REPEATEDLY (two or more distinct failed attempts, errors, wrong approaches, or retries on the same objective), and then FINALLY got working. Capture the reusable technique that cracked it — the command, config, flag, sequence, or approach that worked — phrased so a FUTURE session facing the same goal can apply it directly.
+STRICT gate: only emit a "solution" when there is clear evidence of (a) multiple failed attempts AND (b) an eventual success on that same goal. A task that worked first try, or that never resolved, is NOT a solution — skip it.
+Generalize away the one-off specifics (this repo's file names, this task's data) but KEEP the reusable mechanism. Example: after several failed attempts, "To submit to a Kaggle competition programmatically, use \`kaggle competitions submit -c <slug> -f <file> -m <msg>\` after \`kaggle config set -n competition -v <slug>\` — the web-form flow can't be scripted."
+
 PRIORITY 1 — Failure → Fix sequences:
 Look for tool calls that failed (errors, timeouts, non-zero exits) followed by a different approach that succeeded. Extract the lesson as an imperative rule.
 Examples:
@@ -280,7 +285,7 @@ Do NOT extract:
 - Anything in the EXISTING MEMORIES list below
 
 Respond with ONLY valid JSON (no markdown fences):
-[{"type":"project-knowledge|preference|devops|failure","content":"<imperative statement>","confidence":0.0-1.0}]
+[{"type":"solution|project-knowledge|preference|devops|failure","content":"<imperative statement>","confidence":0.0-1.0}]
 
 Return [] if nothing durable was learned. Max 10 items. Each content should be a concise, actionable rule (e.g. "Pipe 'y' to scripts/upgrade-sandbox.sh — it has an interactive confirmation prompt").`;
 /**
@@ -299,7 +304,7 @@ async function extractSessionLearningsWithLLM(summary, existingMemories) {
         const results = parseJSON(text);
         if (!Array.isArray(results))
             return null;
-        const validTypes = ['project-knowledge', 'preference', 'devops', 'failure'];
+        const validTypes = ['project-knowledge', 'preference', 'devops', 'failure', 'solution'];
         return results
             .filter((r) => r && validTypes.includes(r.type) && typeof r.content === 'string' && r.content.length > 5)
             .map((r) => ({

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

@@ -31,6 +31,9 @@ function formatRules(rules) {
     if (rules.corrections.length > 0) {
         sections.push('## Corrections\n' + rules.corrections.map(m => `- ${extractVal(m.value)}`).join('\n'));
     }
+    if ((rules.solutions ?? []).length > 0) {
+        sections.push('## Solutions (hard-won — reuse these)\n' + rules.solutions.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'));
     }
@@ -44,7 +47,7 @@ async function handlePostCompactReload(_input) {
         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;
+            rules.failures.length + rules.devops.length + (rules.solutions ?? []).length;
         if (totalRules === 0)
             return;
         const body = formatRules(rules);

package/dist/hooks/rule-injector.js

@@ -108,6 +108,7 @@ async function computeInjection(toolName, toolInput, toolUseId) {
         ...activeRules.corrections,
         ...activeRules.failures,
         ...activeRules.devops,
+        ...(activeRules.solutions ?? []),
     ].map(m => ({
         key: m.key,
         type: m.type,

package/dist/hooks/subagent-hooks.js

@@ -34,6 +34,9 @@ function formatRulesCompact(rules) {
     if (rules.corrections.length > 0) {
         sections.push('Corrections:\n' + rules.corrections.map(m => `- ${extractVal(m.value)}`).join('\n'));
     }
+    if ((rules.solutions ?? []).length > 0) {
+        sections.push('Solutions (hard-won — reuse these):\n' + rules.solutions.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'));
     }
@@ -52,7 +55,7 @@ async function handleSubagentStart(input) {
         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;
+            rules.failures.length + rules.devops.length + (rules.solutions ?? []).length;
         if (totalRules === 0)
             return;
         const body = formatRulesCompact(rules);

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

@@ -108,7 +108,7 @@ class MemoryTools {
             },
             {
                 name: 'store_memory',
-                description: 'Store a rule or learning. Use for: corrections, preferences, devops rules, failures. The stored rule is immediately active in this conversation.',
+                description: 'Store a rule or learning. Use for: corrections, preferences, devops rules, failures, and solutions. IMPORTANT: when you crack a hard problem after real trial-and-error (a working command, config, or sequence you had to discover), store it with type "solution" — auto-capture only learns from failures, never from your wins, so a hard-won success is lost unless you save it here. The stored rule is immediately active in this conversation.',
                 inputSchema: {
                     type: 'object',
                     properties: {
@@ -118,7 +118,7 @@ class MemoryTools {
                         },
                         metadata: {
                             type: 'object',
-                            description: 'Optional metadata. Set "type" to one of: preference, correction, devops, failure'
+                            description: 'Optional metadata. Set "type" to one of: preference, correction, devops, failure, solution (use "solution" for a hard-won working fix you discovered through trial-and-error)'
                         },
                         scope: {
                             type: 'string',
@@ -146,7 +146,7 @@ class MemoryTools {
                         },
                         type: {
                             type: 'string',
-                            description: 'Filter by memory type: preference, correction, devops, failure, project-knowledge'
+                            description: 'Filter by memory type: preference, correction, devops, failure, project-knowledge, solution'
                         },
                         projectId: {
                             type: 'string',
@@ -221,7 +221,7 @@ class MemoryTools {
                 throw new Error('Content is required and must be a string');
             }
             // Use metadata.type as the memory type so it appears in future load_rules calls
-            const validTypes = ['preference', 'correction', 'devops', 'failure', 'project-knowledge', 'tool-use'];
+            const validTypes = ['preference', 'correction', 'devops', 'failure', 'project-knowledge', 'solution', 'tool-use'];
             const detectedType = (metadata?.type && validTypes.includes(metadata.type))
                 ? metadata.type
                 : 'preference';
@@ -336,8 +336,9 @@ class MemoryTools {
                 }
                 return kept;
             };
-            // Allocate in priority order (corrections first to protect high-signal items).
+            // Allocate in priority order (corrections + solutions first to protect high-signal items).
             const keptCorrections = takeBounded(rules.corrections);
+            const keptSolutions = takeBounded([...(rules.solutions ?? [])].sort(byCiteThenFresh));
             const keptPreferences = takeBounded([...rules.preferences].sort(byCiteThenFresh));
             const keptDevops = takeBounded([...rules.devops].sort(byCiteThenFresh));
             const keptFailures = takeBounded(rules.failures, 3);
@@ -376,6 +377,12 @@ class MemoryTools {
                     }).join('\n'));
                 }
             }
+            if (keptSolutions.length > 0) {
+                sections.push('## Solutions (hard-won — reuse these before re-deriving)\n' + keptSolutions.map(m => {
+                    const val = formatRuleValue(m.value) + precisionNudge(m.value);
+                    return `- ${val}`;
+                }).join('\n'));
+            }
             if (keptDevops.length > 0) {
                 sections.push('## DevOps Rules\n' + keptDevops.map(m => {
                     const val = formatRuleValue(m.value) + precisionNudge(m.value);
@@ -388,8 +395,8 @@ class MemoryTools {
                 sections.push(`*${droppedCount} more rules available via \`search_memory\`. Run \`npx claude-recall outcomes\` for full stats.*`);
             }
             const totalRules = keptPreferences.length + keptCorrections.length +
-                keptFailures.length + keptDevops.length;
-            const keptAll = [...keptPreferences, ...keptCorrections, ...keptFailures, ...keptDevops];
+                keptFailures.length + keptDevops.length + keptSolutions.length;
+            const keptAll = [...keptPreferences, ...keptCorrections, ...keptFailures, ...keptDevops, ...keptSolutions];
             const resultTokens = this.estimateTokens(keptAll);
             // 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 } });
@@ -436,6 +443,7 @@ class MemoryTools {
                     corrections: keptCorrections.length,
                     failures: keptFailures.length,
                     devops: keptDevops.length,
+                    solutions: keptSolutions.length,
                     total: totalRules,
                     dropped: droppedCount,
                 },

package/dist/memory/storage.js

@@ -1060,7 +1060,7 @@ class MemoryStorage {
 }
 exports.MemoryStorage = MemoryStorage;
 /** Rule-type memories: the only types subject to fuzzy dedup and retro-dedup. */
-MemoryStorage.RULE_TYPES = ['preference', 'correction', 'failure', 'devops', 'project-knowledge'];
+MemoryStorage.RULE_TYPES = ['preference', 'correction', 'failure', 'devops', 'project-knowledge', 'solution'];
 /**
  * Supersession sentinels written by automatic hygiene passes (as opposed to
  * a USER preference override, where superseded_by names the winning key).

package/dist/pi/extension.js

@@ -71,6 +71,9 @@ function formatRules(rules) {
     if (rules.corrections.length > 0) {
         sections.push('## Corrections\n' + rules.corrections.map(m => `- ${extractVal(m.value)}`).join('\n'));
     }
+    if ((rules.solutions ?? []).length > 0) {
+        sections.push('## Solutions (hard-won — reuse these)\n' + rules.solutions.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'));
     }

package/dist/services/memory.js

@@ -456,11 +456,18 @@ class MemoryService {
                 .slice(0, 5);
             // DevOps: all active rules
             const devops = this.storage.searchByContext({ ...searchContext, type: 'devops' }).filter(isActive);
+            // Solutions: hard-won reusable resolutions, top 5 by timestamp
+            const allSolutions = this.storage.searchByContext({ ...searchContext, type: 'solution' });
+            const solutions = allSolutions
+                .filter(isActive)
+                .sort((a, b) => (b.timestamp || 0) - (a.timestamp || 0))
+                .slice(0, 5);
             const counts = [
                 preferences.length && `${preferences.length} preferences`,
                 corrections.length && `${corrections.length} corrections`,
                 failures.length && `${failures.length} failures`,
                 devops.length && `${devops.length} devops rules`,
+                solutions.length && `${solutions.length} solutions`,
             ].filter(Boolean);
             const summary = counts.length > 0
                 ? `Loaded ${counts.join(', ')}`
@@ -468,16 +475,16 @@ class MemoryService {
             this.logger.info('MemoryService', summary, { projectId: pid });
             // Increment load_count for all returned rules
             const allIds = [
-                ...preferences, ...corrections, ...failures, ...devops
+                ...preferences, ...corrections, ...failures, ...devops, ...solutions
             ].map(m => m.id).filter((id) => id !== undefined);
             if (allIds.length > 0) {
                 this.storage.incrementLoadCounts(allIds);
             }
-            return { preferences, corrections, failures, devops, summary };
+            return { preferences, corrections, failures, devops, solutions, summary };
         }
         catch (error) {
             this.logger.logServiceError('MemoryService', 'loadActiveRules', error);
-            return { preferences: [], corrections: [], failures: [], devops: [], summary: 'Error loading rules' };
+            return { preferences: [], corrections: [], failures: [], devops: [], solutions: [], summary: 'Error loading rules' };
         }
     }
     /**

package/dist/shared/event-processors.js

@@ -440,7 +440,7 @@ async function extractSessionLearnings(entries, sessionId, projectId, maxStore =
         try {
             const ms = memory_1.MemoryService.getInstance();
             const rules = ms.loadActiveRules(projectId);
-            const all = [...rules.preferences, ...rules.corrections, ...rules.failures, ...rules.devops];
+            const all = [...rules.preferences, ...rules.corrections, ...rules.failures, ...rules.devops, ...(rules.solutions ?? [])];
             for (const m of all.slice(0, 20)) {
                 const val = typeof m.value === 'object' ? (m.value?.content || JSON.stringify(m.value)) : String(m.value);
                 existingMemories.push(truncate(val, 80));

package/docs/hooks.md

@@ -58,7 +58,7 @@ Common read-only commands are exempt from enforcement:
 | Environment Variable | Default | Description |
 |---|---|---|
 | `CLAUDE_RECALL_SEARCH_TTL` | `300000` (5 min) | Milliseconds a search remains valid |
-| `CLAUDE_RECALL_ENFORCE_MODE` | `block` | `block` (exit 2), `warn` (exit 0 + stderr message), or `off` (disabled) |
+| `CLAUDE_RECALL_ENFORCE_MODE` | `warn` | `block` (exit 2), `warn` (exit 0 + stderr message), or `off` (disabled). Env wins; otherwise read from `~/.claude-recall/config.json` → `"enforceMode"`; else `warn`. The file switch is reachable from inside a running session — an env var set before launch is not. |
 
 ### Exit Codes
 

package/package.json

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