claude-recall 0.21.0 → 0.21.1

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

@@ -8,14 +8,14 @@ source: claude-recall
 
 # Preferences
 
-Auto-generated from 5 memories. Last updated: 2026-04-10.
+Auto-generated from 5 memories. Last updated: 2026-04-11.
 
 ## Rules
 
-- Session test preference 1775856590823
-- Test preference 1775856590766-2
-- Test preference 1775856590766-1
-- Test preference 1775856590766-0
+- Session test preference 1775896807164
+- Test preference 1775896807117-2
+- Test preference 1775896807117-1
+- Test preference 1775896807117-0
 - Test memory content
 
 ---

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

@@ -1,13 +1,13 @@
 {
   "topicId": "preferences",
-  "sourceHash": "bc008faff7f86df3f887d5949481aad102da2261a2872bb1b030bc4279eee9fd",
+  "sourceHash": "47589a75902fabe04a4aab7d8c89e3cdd26c4c1cf7b6e3086a7ea3186413abe4",
   "memoryCount": 5,
-  "generatedAt": "2026-04-10T21:29:50.846Z",
+  "generatedAt": "2026-04-11T08:40:07.182Z",
   "memoryKeys": [
-    "memory_1775856590824_6gpdsqsh0",
-    "memory_1775856590800_fv6xg43wx",
-    "memory_1775856590782_kwl352n83",
-    "memory_1775856590768_crx4xtq3i",
-    "memory_1775856590726_t9ap1te0i"
+    "memory_1775896807165_8gx2muuz6",
+    "memory_1775896807142_2zmd3oc2x",
+    "memory_1775896807130_nsc3d9wky",
+    "memory_1775896807118_3qvm34ozn",
+    "memory_1775896807081_saak1fkqp"
   ]
 }

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

@@ -1,10 +1,67 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MemoryTools = void 0;
+exports.formatRuleValue = formatRuleValue;
 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");
+/**
+ * Render any memory.value shape as a readable string for load_rules output.
+ *
+ * Memory values land in the DB in several historical shapes. The previous
+ * rendering used `m.value.content || m.value.value || JSON.stringify(m.value)`
+ * which short-circuited on truthy non-string objects, producing "[object Object]"
+ * when string interpolation eventually called toString() on the returned object.
+ *
+ * Rules:
+ *   1. strings/numbers pass through (or coerce)
+ *   2. null/undefined → empty string
+ *   3. objects: prefer the first STRING field in order: content, value, title, description
+ *      (only string — non-string `content` falls through to title)
+ *   4. nested failure shapes: extract `what_failed` (top-level or under `content`)
+ *   5. last resort: truncated JSON.stringify (never raw object)
+ *
+ * Exported for direct unit testing in tests/unit/format-rule-value.test.ts.
+ */
+function formatRuleValue(value) {
+    if (value == null)
+        return '';
+    if (typeof value === 'string')
+        return value;
+    if (typeof value !== 'object')
+        return String(value);
+    const v = value;
+    // Prefer the first non-empty string field. Order matters:
+    // - `content` covers legacy hook failures and promoted lessons (lesson text)
+    // - `value` covers preference shape
+    // - `title` covers tool-outcome-watcher failures whose `content` is a nested object
+    // - `description` is a last-ditch human label
+    for (const field of ['content', 'value', 'title', 'description']) {
+        const candidate = v[field];
+        if (typeof candidate === 'string' && candidate.trim()) {
+            return candidate;
+        }
+    }
+    // Nested failure object — extract what_failed if present
+    if (typeof v.what_failed === 'string' && v.what_failed.trim()) {
+        return v.what_failed;
+    }
+    if (v.content && typeof v.content === 'object') {
+        const inner = v.content;
+        if (typeof inner.what_failed === 'string' && inner.what_failed.trim()) {
+            return inner.what_failed;
+        }
+    }
+    // Last resort: truncated JSON. Never return a raw object.
+    try {
+        const json = JSON.stringify(value);
+        return json.length > 200 ? json.substring(0, 200) + '…' : json;
+    }
+    catch {
+        return String(value);
+    }
+}
 class MemoryTools {
     constructor(memoryService, logger, onMemoryChanged) {
         this.memoryService = memoryService;
@@ -287,7 +344,7 @@ class MemoryTools {
             const sections = [];
             if (rules.preferences.length > 0) {
                 sections.push('## Preferences\n' + rules.preferences.map(m => {
-                    const val = typeof m.value === 'object' ? (m.value.content || m.value.value || JSON.stringify(m.value)) : m.value;
+                    const val = formatRuleValue(m.value);
                     // Only show key prefix if it's a meaningful name (not auto-generated)
                     const key = m.preference_key || m.key || '';
                     const isAutoKey = key.startsWith('memory_') || key.startsWith('auto_') || key.startsWith('pref_');
@@ -296,7 +353,7 @@ class MemoryTools {
             }
             if (rules.corrections.length > 0) {
                 sections.push('## Corrections\n' + rules.corrections.map(m => {
-                    const val = typeof m.value === 'object' ? (m.value.content || m.value.value || JSON.stringify(m.value)) : m.value;
+                    const val = formatRuleValue(m.value);
                     const isPromoted = m.key.startsWith('promoted_') || m.value?.source === 'promotion-engine';
                     const evidence = isPromoted && m.value?.evidence_count ? ` (learned from ${m.value.evidence_count} observations)` : '';
                     return isPromoted ? `- [promoted lesson] ${val}${evidence}` : `- ${val}`;
@@ -308,21 +365,21 @@ class MemoryTools {
                 const regularFailures = rules.failures.filter(m => !m.key.startsWith('promoted_') && m.value?.source !== 'promotion-engine');
                 if (promotedLessons.length > 0) {
                     sections.push('## Promoted Lessons (learned from repeated outcomes)\n' + promotedLessons.map(m => {
-                        const val = typeof m.value === 'object' ? (m.value.content || m.value.value || JSON.stringify(m.value)) : m.value;
+                        const val = formatRuleValue(m.value);
                         const evidence = m.value?.evidence_count ? ` (seen ${m.value.evidence_count}x)` : '';
                         return `- ${val}${evidence}`;
                     }).join('\n'));
                 }
                 if (regularFailures.length > 0) {
                     sections.push('## Failures\n' + regularFailures.map(m => {
-                        const val = typeof m.value === 'object' ? (m.value.content || m.value.value || JSON.stringify(m.value)) : m.value;
+                        const val = formatRuleValue(m.value);
                         return `- ${val}`;
                     }).join('\n'));
                 }
             }
             if (rules.devops.length > 0) {
                 sections.push('## DevOps Rules\n' + rules.devops.map(m => {
-                    const val = typeof m.value === 'object' ? (m.value.content || m.value.value || JSON.stringify(m.value)) : m.value;
+                    const val = formatRuleValue(m.value);
                     return `- ${val}`;
                 }).join('\n'));
             }

package/package.json

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