claude-recall 0.28.4 → 0.28.6

package/README.md

@@ -129,7 +129,17 @@ 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 under Kiro.** Memories scope to the **working directory Kiro reports for the session**, not your shell's current directory. These are usually the same — but `kiro --resume` carries the *original* session's directory, so a resumed session captures into the project it was first started in (even if your shell has since moved). Start Kiro fresh from a project directory to scope there. `claude-recall kiro doctor` prints the resolved project so you can confirm where memories are landing.
+> **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
 
@@ -545,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/commands/hook-commands.js

@@ -189,14 +189,23 @@ class HookCommands {
             // `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)}`);
+            try {
+                const { ConfigService } = await Promise.resolve().then(() => __importStar(require('../../services/config')));
+                const cfg = ConfigService.getInstance();
+                const payloadCwd = (input && typeof input.cwd === 'string' && input.cwd.trim()) ? input.cwd : null;
+                if (payloadCwd) {
+                    cfg.updateConfig({ project: { rootDir: payloadCwd } });
                 }
+                // Diagnostic: record what the runtime declared vs. what this
+                // subprocess inherited, and the project we resolved. Makes "which
+                // project did this scope to, and why" answerable from the log —
+                // the definitive check for `kiro --resume` scoping questions.
+                const pin = process.env.CLAUDE_RECALL_PROJECT_ID || process.env.CLAUDE_PROJECT_ID;
+                (0, shared_1.hookLog)('hook-dispatcher', `scope [${names.join('+')}]: payload.cwd=${payloadCwd ?? '(none)'} ` +
+                    `process.cwd=${process.cwd()} pin=${pin ?? '(none)'} → project=${cfg.getProjectId()}`);
+            }
+            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 {

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.4",
+  "version": "0.28.6",
   "description": "Persistent memory for Claude Code and Pi with native Skills integration, automatic capture, failure learning, and project scoping",
   "main": "dist/index.js",
   "bin": {