claude-recall 0.28.3 → 0.28.5

package/README.md

@@ -129,6 +129,18 @@ With Option B the agent has the memory tools (`load_rules`, `store_memory`, `sea
 
 **Not available under Kiro** with either option (Kiro's hooks expose no transcript): transcript-based failure detection and session-end auto-checkpoints.
 
+> **Project scoping & `--resume`.** Memories scope to the **working directory Kiro reports for the session**. `kiro --resume` (with no conversation id) continues your *most-recent conversation* and restores **its** directory — which may be a different project than the one your shell is in. So a resumed session captures into the project of the conversation you're continuing, not wherever you launched Kiro. That's usually what you want (memories follow the conversation), but if you bounce between projects it can surprise you.
+>
+> To force a fixed project regardless of what `--resume` restores, pin it with `CLAUDE_RECALL_PROJECT_ID`. A per-project shell alias makes it seamless:
+>
+> ```bash
+> alias kiro-epic='CLAUDE_RECALL_PROJECT_ID=epic-workflow-cicd kiro-cli chat --agent mcp-agent-env --resume'
+> ```
+>
+> `claude-recall kiro doctor` always prints the resolved project (and whether it's pinned) so you can confirm where memories are landing before trusting it.
+>
+> **Capture works even when the MCP tools are blocked.** Under enterprise governance that restricts MCP to a trusted registry, Kiro drops the claude-recall MCP server — so the agent may say it "has no memory tools." Ignore that: the hooks capture and inject against the local DB regardless. The agent is told this at session start and will confirm it's remembering; only the on-demand tools (the agent calling `search_memory` itself) need an admin to allowlist claude-recall.
+
 ### Shared Database
 
 All runtimes (Claude Code, Pi, Kiro CLI) use the same database at `~/.claude-recall/claude-recall.db`, scoped per project by working directory. A correction learned in one agent is available in the others.
@@ -425,6 +437,7 @@ claude-recall store "content" -t <type>  # Store with type (preference, correcti
 claude-recall export backup.json         # Export current project's memories to JSON
 claude-recall export backup.json --global # Export all projects
 claude-recall import backup.json         # Import memories from JSON
+claude-recall delete <key>               # Delete one memory by key (get keys from `search`)
 claude-recall clear --force              # Clear current project (auto-backup written first)
 claude-recall clear --force --global     # Clear all projects
 claude-recall failures                   # View failure memories
@@ -542,6 +555,7 @@ Runtime behavior can be tuned via environment variables. Defaults are chosen so
 | `CLAUDE_RECALL_ENFORCE_MODE`             | `on`    | Set to `off` to bypass the search-enforcer hook.                                                         |
 | `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). Citations still scan every turn. `0` disables. |
+| `CLAUDE_RECALL_PROJECT_ID`               | *(cwd)*  | Pin the project scope to a fixed id, overriding working-directory detection. Useful when `kiro --resume` restores a different project's directory than you intend. |
 
 ---
 

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

@@ -1961,6 +1961,26 @@ async function main() {
         await cli.import(input, options);
         process.exit(0);
     });
+    // Delete a single memory by key
+    program
+        .command('delete <key>')
+        .description('Delete a single memory by its key (find keys with `search`)')
+        .action((key) => {
+        try {
+            const deleted = memory_1.MemoryService.getInstance().delete(key);
+            if (deleted) {
+                console.log(`✅ Deleted memory: ${key}`);
+            }
+            else {
+                console.log(`⚠️  No memory found with key: ${key}`);
+            }
+            process.exit(deleted ? 0 : 1);
+        }
+        catch (error) {
+            console.error(`❌ Delete failed: ${error.message}`);
+            process.exit(1);
+        }
+    });
     // Clear command
     program
         .command('clear')

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

@@ -180,6 +180,24 @@ class HookCommands {
                 (0, shared_1.hookLog)('hook-dispatcher', `stdin read failed (continuing with empty payload): ${(0, shared_1.safeErrorMessage)(err)}`);
                 input = {};
             }
+            // Deterministic project scoping. Resolve the project from the cwd the
+            // RUNTIME declares in the hook payload — NOT the cwd this subprocess
+            // happened to inherit. Both Claude Code and Kiro include `cwd`; for CC
+            // it equals process.cwd() so this is a no-op, but for Kiro it pins
+            // scoping to the session's working directory. Without this a memory
+            // captured while working on project A could land in project B (e.g. a
+            // `kiro --resume`d session whose cwd differs from the shell's), and
+            // capture (userPromptSubmit) and injection (agentSpawn) could even
+            // disagree. Project memories must scope to ONE deterministic project.
+            if (input && typeof input.cwd === 'string' && input.cwd.trim()) {
+                try {
+                    const { ConfigService } = await Promise.resolve().then(() => __importStar(require('../../services/config')));
+                    ConfigService.getInstance().updateConfig({ project: { rootDir: input.cwd } });
+                }
+                catch (err) {
+                    (0, shared_1.hookLog)('hook-dispatcher', `cwd scoping failed (using inherited cwd): ${(0, shared_1.safeErrorMessage)(err)}`);
+                }
+            }
             for (const name of names) {
                 try {
                     await HookCommands.runOne(name, input);

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

@@ -355,7 +355,10 @@ class KiroCommands {
             const ms = MemoryService.getInstance();
             const projectId = ConfigService.getInstance().getProjectId();
             const stats = ms.getStats();
-            line('✓', `project: ${projectId}`);
+            const pin = process.env.CLAUDE_RECALL_PROJECT_ID || process.env.CLAUDE_PROJECT_ID;
+            line('✓', pin
+                ? `project: ${projectId} (PINNED via ${process.env.CLAUDE_RECALL_PROJECT_ID ? 'CLAUDE_RECALL_PROJECT_ID' : 'CLAUDE_PROJECT_ID'})`
+                : `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;

package/dist/hooks/kiro-hooks.js

@@ -91,16 +91,26 @@ function formatRulesForContext() {
     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.
+ * Standing instruction so the agent KNOWS it has persistent memory — and,
+ * critically, that capture happens via BACKGROUND HOOKS independent of the MCP
+ * tools. Under enterprise Kiro governance the claude-recall MCP server is
+ * dropped from the toolset, but the userPromptSubmit/preToolUse/postToolUse
+ * hooks still write to and read from the local DB. Without the "even without
+ * the tools" clause the agent answers "I can't store that, I have no memory
+ * tools" — technically true of the TOOL, but false of the system, since the
+ * hook already captured it. This is the exact confusion observed in a
+ * governance-locked session.
  */
-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.';
+const KIRO_MEMORY_DIRECTIVE = 'You have PERSISTENT MEMORY across sessions via Claude Recall. Your preferences, corrections, and the ' +
+    'rules shown below are captured AUTOMATICALLY by background hooks and injected into your context at the ' +
+    'start of every session — this works even if the claude-recall MCP tools (store_memory, search_memory, …) ' +
+    'are NOT in your current toolset (e.g. restricted by your organization\'s policy). ' +
+    'So when the user says "remember …", "recall …", "store this", states a preference, or corrects you: ' +
+    'if the store_memory tool is available, call it and say what you stored; if it is NOT available, simply ' +
+    'confirm the point will be remembered — it is already being captured automatically by the hook. ' +
+    'NEVER tell the user you have no memory between sessions or cannot persist anything. ' +
+    'When the MCP tools ARE available, also use search_memory before decisions where past context may 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

package/dist/services/config.js

@@ -97,7 +97,13 @@ class ConfigService {
             project: {
                 rootDir: process.env.CLAUDE_PROJECT_DIR || process.cwd(),
                 name: process.env.CLAUDE_PROJECT_NAME,
-                id: process.env.CLAUDE_PROJECT_ID
+                // Explicit project pin. Overrides cwd-based scoping entirely — set it
+                // to force every memory into one project regardless of which directory
+                // the runtime reports (e.g. `kiro --resume` restores the resumed
+                // conversation's directory, which may not be the project you mean to
+                // work in). CLAUDE_RECALL_PROJECT_ID is the documented name;
+                // CLAUDE_PROJECT_ID is honored for backward compatibility.
+                id: process.env.CLAUDE_RECALL_PROJECT_ID || process.env.CLAUDE_PROJECT_ID
             },
             hooks: {
                 timeout: parseInt(process.env.CLAUDE_RECALL_HOOK_TIMEOUT || '5000'),

package/package.json

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