claude-recall 0.28.2 → 0.28.4

package/README.md

@@ -129,6 +129,8 @@ 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.
+
 ### 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 +427,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

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

@@ -265,10 +265,165 @@ class KiroCommands {
         console.log('session-end checkpoints (Kiro exposes no transcript to hooks).');
         process.exit(0);
     }
+    /**
+     * Read a Kiro agent config and report whether claude-recall is wired
+     * (MCP server + which lifecycle hooks). Returns null if the file is missing
+     * or unparseable.
+     */
+    static inspectAgent(agentPath) {
+        let config;
+        try {
+            config = JSON.parse(fs.readFileSync(agentPath, 'utf8'));
+        }
+        catch {
+            return null;
+        }
+        const mcp = !!(config.mcpServers && config.mcpServers['claude-recall']);
+        const hooks = [];
+        if (config.hooks && typeof config.hooks === 'object') {
+            for (const [event, entries] of Object.entries(config.hooks)) {
+                if (Array.isArray(entries) && entries.some((h) => typeof h?.command === 'string' && h.command.includes('claude-recall'))) {
+                    hooks.push(event);
+                }
+            }
+        }
+        return { name: config.name || path.basename(agentPath, '.json'), mcp, hooks };
+    }
+    /** Last non-empty line of a hook log + how long ago, or null if none. */
+    static lastLogLine(logPath) {
+        try {
+            const lines = fs.readFileSync(logPath, 'utf8').split('\n').filter(l => l.trim());
+            if (lines.length === 0)
+                return null;
+            const line = lines[lines.length - 1];
+            const m = line.match(/^\[([^\]]+)\]/);
+            let ageMs = null;
+            if (m) {
+                const t = Date.parse(m[1]);
+                if (!Number.isNaN(t))
+                    ageMs = Date.now() - t;
+            }
+            return { line, ageMs };
+        }
+        catch {
+            return null;
+        }
+    }
+    static fmtAge(ageMs) {
+        if (ageMs === null)
+            return '';
+        const min = Math.round(ageMs / 60000);
+        if (min < 1)
+            return ' (just now)';
+        if (min < 60)
+            return ` (${min}m ago)`;
+        const h = Math.round(min / 60);
+        if (h < 48)
+            return ` (${h}h ago)`;
+        return ` (${Math.round(h / 24)}d ago)`;
+    }
+    /**
+     * `claude-recall kiro doctor` — read-only diagnostic. Answers the questions
+     * that otherwise take a support round-trip: is the binary current and on
+     * PATH, is a key available for LLM capture, does the DB have memories, which
+     * Kiro agents have claude-recall wired, and are the hooks actually firing.
+     */
+    static runDoctor() {
+        const line = (marker, text) => console.log(`  ${marker} ${text}`);
+        console.log('\n🩺 Claude Recall — Kiro diagnostic\n');
+        // --- Install ---
+        console.log('Install');
+        let version = 'unknown';
+        try {
+            version = JSON.parse(fs.readFileSync(path.resolve(__dirname, '..', '..', '..', 'package.json'), 'utf8')).version;
+        }
+        catch { /* leave unknown */ }
+        line('•', `version: ${version}`);
+        const onPath = (0, repair_1.resolveOnPath)('claude-recall');
+        line(onPath ? '✓' : '⚠', onPath
+            ? `on PATH: ${onPath}`
+            : 'not on PATH — hooks/agent commands will use absolute paths (break if the install moves)');
+        line(process.env.ANTHROPIC_API_KEY ? '✓' : '•', process.env.ANTHROPIC_API_KEY
+            ? 'ANTHROPIC_API_KEY set — hooks use Claude Haiku for classification'
+            : 'ANTHROPIC_API_KEY not set — hooks use the regex fallback (explicit "remember/recall/always/never/I prefer …" still captured)');
+        // --- Database ---
+        console.log('\nDatabase (this project)');
+        try {
+            // Lazy require so a broken DB can't stop the earlier sections printing
+            const { MemoryService } = require('../../services/memory');
+            const { ConfigService } = require('../../services/config');
+            const ms = MemoryService.getInstance();
+            const projectId = ConfigService.getInstance().getProjectId();
+            const stats = ms.getStats();
+            line('✓', `project: ${projectId}`);
+            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;
+            line(ruleCount > 0 ? '✓' : '•', `active rules for this project: ${ruleCount}`);
+        }
+        catch (err) {
+            line('⚠', `could not open database: ${err.message}`);
+        }
+        // --- Kiro agents ---
+        console.log('\nKiro agents with Claude Recall wired');
+        const agentDirs = [
+            { label: 'workspace', dir: path.join(process.cwd(), '.kiro', 'agents') },
+            { label: 'global', dir: path.join(os.homedir(), '.kiro', 'agents') },
+        ];
+        let anyWired = false;
+        for (const { label, dir } of agentDirs) {
+            if (!fs.existsSync(dir))
+                continue;
+            const files = fs.readdirSync(dir).filter(f => f.endsWith('.json'));
+            for (const f of files) {
+                const info = KiroCommands.inspectAgent(path.join(dir, f));
+                if (!info || (!info.mcp && info.hooks.length === 0))
+                    continue;
+                anyWired = true;
+                const bits = [
+                    info.mcp ? 'MCP' : null,
+                    info.hooks.length ? `hooks: ${info.hooks.join(', ')}` : null,
+                ].filter(Boolean).join(' | ');
+                line('✓', `${info.name} (${label}) — ${bits}`);
+            }
+        }
+        if (!anyWired) {
+            line('⚠', 'none found. Run `claude-recall kiro setup` (new agent) or');
+            line(' ', '        `claude-recall kiro setup --merge-into <agent>` (existing agent).');
+        }
+        // --- Hook activity ---
+        console.log('\nRecent hook activity');
+        const dir = process.env.CLAUDE_RECALL_DB_PATH || path.join(os.homedir(), '.claude-recall');
+        const logDir = path.join(dir, 'hook-logs');
+        const kiro = KiroCommands.lastLogLine(path.join(logDir, 'kiro.log'));
+        const cd = KiroCommands.lastLogLine(path.join(logDir, 'correction-detector.log'));
+        if (kiro) {
+            line('✓', `kiro hooks last ran${KiroCommands.fmtAge(kiro.ageMs)}: ${kiro.line.replace(/^\[[^\]]+\]\s*/, '')}`);
+        }
+        else {
+            line('⚠', 'no kiro.log — Kiro hooks have never fired. After `kiro setup`/`--merge-into`, RESTART Kiro (hooks bind at agent activation).');
+        }
+        if (cd) {
+            line('✓', `capture hook last ran${KiroCommands.fmtAge(cd.ageMs)}: ${cd.line.replace(/^\[[^\]]+\]\s*/, '')}`);
+        }
+        // --- Governance note ---
+        console.log('\nNotes');
+        line('•', 'If Kiro\'s startup banner omits "claude-recall" from loaded servers, your org likely');
+        line(' ', '  restricts MCP to a trusted registry. Hooks still work (capture + injection go straight');
+        line(' ', '  to the local DB) — only the interactive MCP tools need an admin to allowlist claude-recall.');
+        console.log('');
+        process.exit(0);
+    }
     static register(program) {
         const kiroCmd = program
             .command('kiro')
             .description('Kiro CLI integration');
+        kiroCmd
+            .command('doctor')
+            .description('Diagnose the Kiro integration: install, database, wired agents, and whether hooks are firing')
+            .action(() => {
+            KiroCommands.runDoctor();
+        });
         kiroCmd
             .command('setup')
             .description('Write a Kiro custom agent (.kiro/agents/recall.json) with Claude Recall memory wired in, or merge into an existing agent')

package/dist/hooks/correction-detector.js

@@ -43,8 +43,14 @@ async function handleCorrectionDetector(input) {
         (0, shared_1.hookLog)('correction-detector', `Reask signal detection error: ${(0, shared_1.safeErrorMessage)(err)}`);
     }
     const result = await (0, shared_1.classifyContent)(prompt);
-    if (!result)
+    if (!result) {
+        // Terse trace so "did the hook fire?" is answerable from the log alone:
+        // absence of any line = hook never ran; "no rule detected" = ran but the
+        // prompt wasn't a storable rule; "Captured X" = ran and stored. Prompt
+        // text is NOT logged (privacy) — only its length.
+        (0, shared_1.hookLog)('correction-detector', `no rule detected in prompt (len=${prompt.length})`);
         return;
+    }
     // Reject short/garbage extracts and raw dumps (not clean rules)
     if (result.extract.length < 10 || result.extract.length > 200)
         return;

package/dist/hooks/shared.js

@@ -73,11 +73,13 @@ const CORRECTION_PATTERNS = [
     { regex: /\bstop\s+(doing|using|adding)\s+(.+)/i, confidence: 0.75 },
 ];
 const PREFERENCE_PATTERNS = [
-    // "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 },
+    // "remember ..." / "recall ..." are explicit store requests in any phrasing —
+    // "remember that X", "remember to X", "remember my favourite color is green",
+    // "recall my favourite color is green". This is the resilient (no-LLM,
+    // no-MCP) capture path, which matters under enterprise Kiro governance that
+    // blocks the MCP tools. The interrogative/question-mark guards below keep
+    // "do you remember that config file?" / "do you recall X?" out.
+    { regex: /\b(?:remember|recall)\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.2",
+  "version": "0.28.4",
   "description": "Persistent memory for Claude Code and Pi with native Skills integration, automatic capture, failure learning, and project scoping",
   "main": "dist/index.js",
   "bin": {
@@ -105,6 +105,6 @@
     "@anthropic-ai/sdk": "^0.110.0",
     "better-sqlite3": "^12.2.0",
     "chalk": "^5.5.0",
-    "commander": "^15.0.0"
+    "commander": "^14.0.3"
   }
 }