claude-recall 0.29.0 → 0.29.2

package/README.md

@@ -103,7 +103,7 @@ You get: active rules injected into context automatically at agent start (no too
 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.
+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 — while leaving your own config untouched. It only rewrites claude-recall's own entries: superseded ones from an older version are swapped for the current wiring (any unrelated hook you have on the same event is preserved). Idempotent: on an already-current agent, re-running changes nothing. If the agent restricts tools with an explicit list, `@claude-recall` is added to it.
 
 > **⚠️ After `kiro setup` or `--merge-into`: start ONE fresh conversation per project (no `--resume`).** Kiro snapshots the agent config into each conversation **at creation** — `--resume` restores that snapshot and ignores agent-config changes made since. So conversations created *before* you wired claude-recall will **never** run its hooks, no matter how often you resume them or restart Kiro. Start one fresh conversation after wiring; every conversation created from then on carries the hooks, **including when resumed** (`--resume` works normally afterwards — this is a one-time rollover per project).
 
@@ -175,7 +175,7 @@ Per-runtime notes:
 
 - **Claude Code** — nothing else needed; registrations point at the `claude-recall` command, not a pinned path. If the release notes mention new or changed hooks (a `hooksVersion` bump), also re-run `claude-recall setup --install` in each active project — safe any time; a no-op when hooks are already current.
 - **Pi** — run `pi update npm:claude-recall` and restart Pi.
-- **Kiro CLI** — nothing else needed; the agent config points at the `claude-recall` command. If the release notes mention changes to the Kiro agent template, re-run `claude-recall kiro setup --force` in each project that uses it.
+- **Kiro CLI** — the agent config points at the `claude-recall` command, so the binary upgrade alone applies to hook *behaviour*. But when the release notes change the agent *template* (new hooks, the classifier agent, revised wiring — e.g. the **0.29.x** Kiro-LLM capture), re-run setup once so the agent picks it up: `claude-recall kiro setup --force` for the standalone `recall` agent, or `claude-recall kiro setup --merge-into <agent>` for an agent you merged into. That also writes the `claude-recall-classifier` agent and strips any superseded hooks. Then start one fresh conversation per project (the snapshot rollover above). `claude-recall kiro doctor` confirms the result.
 
 > **Claude Code registered before v0.27.x?** Older versions auto-registered the MCP server with an `npx`-based command, which re-resolves the package on every server start and can be shadowed by stale project-local installs. Switch to the direct binary form (run in each affected project):
 >

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

@@ -165,11 +165,33 @@ class KiroCommands {
             preToolUse: 'kiro-rule-injector',
             postToolUse: 'kiro-tool-outcome',
         };
+        // Superseded claude-recall hooks to strip from an event before wiring the
+        // current one — prevents stacking when the handler for an event changes
+        // across versions. Pre-0.29 wired userPromptSubmit to `correction-detector`
+        // directly; 0.29 replaced it with `kiro-capture`. Leaving the old entry
+        // makes BOTH fire, double-capturing (often as near-duplicate memories).
+        // Only our own commands (containing 'claude-recall' / 'hook run') are
+        // touched — a user's unrelated hook on the same event is preserved.
+        const supersededMarkers = {
+            userPromptSubmit: ['correction-detector'],
+        };
+        const isOurCommand = (cmd) => cmd.includes('claude-recall') || cmd.includes('hook run');
         for (const [event, entries] of Object.entries(KiroCommands.buildHookEntries(hookCmd))) {
             if (!Array.isArray(config.hooks[event])) {
                 config.hooks[event] = [];
             }
             const marker = handlerMarkers[event];
+            // Strip superseded entries first (but never the current marker).
+            for (const stale of supersededMarkers[event] ?? []) {
+                if (stale === marker)
+                    continue;
+                const before = config.hooks[event].length;
+                config.hooks[event] = config.hooks[event].filter((h) => !(typeof h?.command === 'string' && h.command.includes(stale) && isOurCommand(h.command)));
+                const removed = before - config.hooks[event].length;
+                if (removed > 0) {
+                    changes.push(`hooks.${event}: removed ${removed} superseded ${stale} entr${removed === 1 ? 'y' : 'ies'}`);
+                }
+            }
             const alreadyWired = config.hooks[event].some((h) => typeof h?.command === 'string' && h.command.includes(marker));
             if (alreadyWired) {
                 changes.push(`hooks.${event}: ${marker} already wired — skipped`);

package/dist/hooks/shared.js

@@ -33,6 +33,7 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.isConversationalNotRule = isConversationalNotRule;
 exports.readStdin = readStdin;
 exports.classifyContentRegex = classifyContentRegex;
 exports.classifyContent = classifyContent;
@@ -90,6 +91,17 @@ const PREFERENCE_PATTERNS = [
 // corrections ("no worries, that looks good").
 const INTERROGATIVE_START = /^(do|does|did|can|could|would|should|shall|is|are|was|were|will|have|has|what|why|how|when|where|who|which)\b/i;
 const PLEASANTRY_NO = /^no\s+(worries|problem|problems|prob|thanks|thank|rush|need|biggie|sweat|pressure)\b/i;
+/**
+ * True when a prompt reads as conversation rather than a storable rule: it ends
+ * with a question mark, opens with an interrogative, or is a "no worries"-style
+ * pleasantry. Applied to EVERY classifier path (regex, Haiku, Kiro) — the LLMs
+ * otherwise trust their own judgement and have stored questions like "what
+ * memories do you have?" as preferences.
+ */
+function isConversationalNotRule(text) {
+    const trimmed = text.trim();
+    return trimmed.endsWith('?') || INTERROGATIVE_START.test(trimmed) || PLEASANTRY_NO.test(trimmed);
+}
 // Failure, devops, and project-knowledge patterns removed — single-keyword
 // matches ("error", "git", "build") are too broad for regex. These types
 // require context that only the LLM classifier can assess. When the LLM is
@@ -108,9 +120,8 @@ function readStdin() {
  * Returns the highest-confidence match, prioritizing corrections > preferences.
  */
 function classifyContentRegex(text) {
-    const trimmed = text.trim();
     // Interrogatives and pleasantries are conversation, not rules
-    if (trimmed.endsWith('?') || INTERROGATIVE_START.test(trimmed) || PLEASANTRY_NO.test(trimmed)) {
+    if (isConversationalNotRule(text)) {
         return null;
     }
     // Priority order: correction > preference > failure > devops > project-knowledge
@@ -142,6 +153,20 @@ function classifyContentRegex(text) {
  *   3. Regex patterns, if neither LLM path yields a result.
  */
 async function classifyContent(text) {
+    // Guard the LLM paths the same way the regex path is guarded: a question or
+    // pleasantry is conversation, never a rule. Haiku/Kiro don't apply this on
+    // their own and have stored prompts like "what memories do you have?".
+    if (isConversationalNotRule(text))
+        return null;
+    const result = await classifyContentInner(text);
+    // Reject if the classifier echoed a question instead of distilling a rule:
+    // a stored directive is declarative, so a '?' in the extract signals a
+    // conversational false positive (e.g. an LLM regurgitating the prompt).
+    if (result && result.extract.includes('?'))
+        return null;
+    return result;
+}
+async function classifyContentInner(text) {
     const llmResult = await (0, llm_classifier_1.classifyWithLLM)(text);
     if (llmResult)
         return llmResult;

package/package.json

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