claude-recall 0.28.1 → 0.28.2

package/README.md

@@ -105,6 +105,10 @@ claude-recall kiro setup --merge-into <agent-name>
 
 This finds the agent config (workspace `.kiro/agents/` first, then `~/.kiro/agents/`; `--global` to target the global one directly), writes a timestamped backup, and appends the claude-recall pieces — MCP server, pre-approved read-only tools, and the four hooks — without touching anything the agent already had. Idempotent: re-running changes nothing. If the agent restricts tools with an explicit list, `@claude-recall` is added to it.
 
+> **⚠️ Restart Kiro after `kiro setup` or `--merge-into`.** Hooks bind when an agent *activates* — a Kiro session that was already running keeps its old wiring and will behave as if it has no memory. Exit Kiro and start it again (or `/agent swap` away and back). Verify hooks are firing with `tail ~/.claude-recall/hook-logs/kiro.log`.
+
+> **Tip:** export `ANTHROPIC_API_KEY` in the shell you launch Kiro from. Hooks then use Claude Haiku to classify what's worth remembering; without it a conservative regex fallback runs, which catches explicit phrasings ("remember ...", "always ...", "never ...", "I prefer ...") but misses subtler ones.
+
 **Option B — MCP tools only (no hooks, works in Kiro's default agent).**
 
 If you don't want a custom agent, register just the MCP server in Kiro's config instead. Create or merge into `.kiro/settings/mcp.json` (project) or `~/.kiro/settings/mcp.json` (all projects):

package/dist/hooks/kiro-hooks.js

@@ -90,17 +90,37 @@ function formatRulesForContext() {
         + rules.failures.length + rules.devops.length;
     return { body: sections.join('\n\n'), total };
 }
+/**
+ * Standing instruction so the agent KNOWS it has persistent memory. Without
+ * this, a session with no stored rules yet answers "I have no memory between
+ * conversations" and never calls store_memory when the user says
+ * "remember ..." — the exact failure observed on first use.
+ */
+const KIRO_MEMORY_DIRECTIVE = 'You have PERSISTENT MEMORY across sessions via Claude Recall (MCP server "claude-recall": ' +
+    'load_rules, store_memory, search_memory, delete_memory, save_checkpoint, load_checkpoint). ' +
+    'When the user says "remember ...", "store this", "recall ...", states a preference, or corrects you, ' +
+    'call store_memory (tell them what you will store). Use search_memory before decisions when past ' +
+    'context might apply. Memories are scoped per project and shared with the user\'s other coding agents.';
 /**
  * agentSpawn — runs once when a Kiro agent activates. Whatever we print is
  * added to the agent's context, so this IS the load_rules call: rules are in
- * context from turn one without any tool call or enforcement.
+ * context from turn one without any tool call or enforcement. The memory
+ * directive is always emitted, even with an empty database — capability
+ * awareness must not depend on having memories already.
  */
 async function handleKiroAgentSpawn(_input) {
     try {
-        const { body, total } = formatRulesForContext();
-        const parts = [];
-        if (body) {
-            parts.push(directives_1.LOAD_RULES_DIRECTIVE, '---', body);
+        const parts = [KIRO_MEMORY_DIRECTIVE];
+        let total = 0;
+        try {
+            const rules = formatRulesForContext();
+            total = rules.total;
+            if (rules.body) {
+                parts.push(directives_1.LOAD_RULES_DIRECTIVE, '---', rules.body);
+            }
+        }
+        catch (err) {
+            (0, shared_1.hookLog)(HOOK_NAME, `agentSpawn rule load failed (directive still emitted): ${(0, shared_1.safeErrorMessage)(err)}`);
         }
         // Surface a pending task checkpoint the same way load_rules hints at one
         try {
@@ -112,12 +132,8 @@ async function handleKiroAgentSpawn(_input) {
             }
         }
         catch { /* checkpoint hint is best-effort */ }
-        if (parts.length === 0) {
-            (0, shared_1.hookLog)(HOOK_NAME, 'agentSpawn: no active rules or checkpoint — nothing injected');
-            return;
-        }
         process.stdout.write(parts.join('\n\n') + '\n');
-        (0, shared_1.hookLog)(HOOK_NAME, `agentSpawn: injected ${total} rule(s) into Kiro context`);
+        (0, shared_1.hookLog)(HOOK_NAME, `agentSpawn: injected memory directive + ${total} rule(s) into Kiro context`);
     }
     catch (err) {
         // Never block agent startup

package/dist/hooks/shared.js

@@ -73,7 +73,11 @@ const CORRECTION_PATTERNS = [
     { regex: /\bstop\s+(doing|using|adding)\s+(.+)/i, confidence: 0.75 },
 ];
 const PREFERENCE_PATTERNS = [
-    { regex: /\bremember\s+(?:that|this|to)\s+(.+)/i, confidence: 0.8 },
+    // "remember ..." is an explicit store request in any phrasing — "remember
+    // that X", "remember to X", but also "remember my favourite color is green".
+    // The interrogative/question-mark guards below keep "do you remember that
+    // config file?" out.
+    { regex: /\bremember\s+(?:that\s+|this\s+|to\s+)?(.+)/i, confidence: 0.8 },
     { regex: /\bfrom\s+now\s+on[,.]?\s+(.+)/i, confidence: 0.8 },
     { regex: /\bgoing\s+forward[,.]?\s+(.+)/i, confidence: 0.8 },
     { regex: /\balways\s+(.+)/i, confidence: 0.75 },

package/package.json

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