claude-recall 0.28.7 → 0.29.0

package/README.md

@@ -107,7 +107,7 @@ This finds the agent config (workspace `.kiro/agents/` first, then `~/.kiro/agen
 
 > **⚠️ 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).
 
-**What you need to do — once per project, no code changes needed.** In each project, start one conversation *without* `--resume` (add your usual flags, e.g. `--classic`, `--trust-all-tools`):
+The rollover, concretely (add your usual flags, e.g. `--classic`, `--trust-all-tools`):
 
 ```bash
 cd ~/path/to/your-project
@@ -121,9 +121,9 @@ claude-recall search "helm"
 tail -5 ~/.claude-recall/hook-logs/hook-dispatcher.log
 ```
 
-You should see a `scope [...] → project=your-project` line. From then on your normal `--resume` command works — every conversation created after wiring carries the hooks permanently, including when resumed. `claude-recall kiro doctor` gives a fuller health report.
+The log should show a `scope [...] → project=your-project` line; `claude-recall kiro doctor` gives a fuller health report.
 
-> **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.
+> **Capture uses Kiro's own LLM — no API key needed.** To decide what's worth remembering, the capture hook classifies each prompt with Kiro's model via a headless `kiro-cli chat --no-interactive` call (through a bundled bare `claude-recall-classifier` agent). So natural statements like "my favourite color is green" are captured without any `ANTHROPIC_API_KEY` and without the `store_memory` MCP tool — which matters under enterprise governance that blocks the MCP server. It runs in a detached background worker, so your turn is never blocked; it spends ~0.06 Kiro credits per prompt. Precedence: `ANTHROPIC_API_KEY` (if you set one) → Kiro's LLM → a regex fallback. Tune with `CLAUDE_RECALL_KIRO_MODEL` (default `claude-haiku-4.5`). Details in [docs/kiro-llm-capture.md](docs/kiro-llm-capture.md).
 
 **Option B — MCP tools only (no hooks, works in Kiro's default agent).**
 
@@ -150,7 +150,7 @@ With Option B the agent has the memory tools (`load_rules`, `store_memory`, `sea
 > To force a fixed project id regardless of directory, 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'
+> alias kiro-myproj='CLAUDE_RECALL_PROJECT_ID=my-project kiro-cli chat --agent <your-agent> --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.
@@ -522,6 +522,8 @@ claude-recall hook run memory-sync           # Stop + PreCompact hook (syncs rul
 
 Each project gets isolated memory based on its working directory. **Project ID** is derived from the `cwd` passed by the agent. Universal memories (no project scope) are available everywhere. Switching projects switches memory automatically.
 
+To pin the project id explicitly — e.g. one logical project spanning several directories (worktrees, subrepos) — set `CLAUDE_RECALL_PROJECT_ID` (see [Environment Variables](#environment-variables)).
+
 Database location: `~/.claude-recall/claude-recall.db` (shared file, scoped by `project_id` column).
 
 ---
@@ -560,7 +562,9 @@ Runtime behavior can be tuned via environment variables. Defaults are chosen so
 | Variable                                 | Default | Effect                                                                                                   |
 | ---------------------------------------- | ------- | -------------------------------------------------------------------------------------------------------- |
 | `CLAUDE_RECALL_DB_PATH`                  | `~/.claude-recall/` | Database directory.                                                                          |
-| `ANTHROPIC_API_KEY`                      | _(unset)_ | Enables LLM-based classification (Haiku). Falls back to regex silently when missing.                   |
+| `ANTHROPIC_API_KEY`                      | _(unset)_ | Enables LLM-based classification (Haiku). Under Kiro, falls back to Kiro's own headless LLM when missing; otherwise falls back to regex.        |
+| `CLAUDE_RECALL_KIRO_MODEL`               | `claude-haiku-4.5` | Model for Kiro-LLM capture classification. Raise to `claude-sonnet-4.6` for steadier judgement at more credits. See [docs/kiro-llm-capture.md](docs/kiro-llm-capture.md). |
+| `CLAUDE_RECALL_KIRO_LLM_TIMEOUT_MS`      | `30000` | Hard cap on the headless `kiro-cli` classify call before the capture worker gives up and falls back to regex. |
 | `CLAUDE_RECALL_LOAD_BUDGET_TOKENS`       | `2000`  | Token budget for the `load_rules` payload. Rules are emitted in priority order (corrections → preferences by citation → devops by citation → failures) and dropped rules surface via `search_memory`. |
 | `CLAUDE_RECALL_AUTO_DEMOTE`              | `false` | When `true`, auto-demote rules on MCP boot where `load_count >= CLAUDE_RECALL_DEMOTE_MIN_LOADS`, `cite_count = 0`, and age `> CLAUDE_RECALL_DEMOTE_MIN_AGE_DAYS`. Still reversible via `rules promote <id>`. |
 | `CLAUDE_RECALL_DEMOTE_MIN_LOADS`         | `20`    | Minimum load count before a rule qualifies for auto-demotion.                                            |

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

@@ -53,6 +53,8 @@ const AVAILABLE_HOOKS = [
     'kiro-agent-spawn',
     'kiro-rule-injector',
     'kiro-tool-outcome',
+    'kiro-capture',
+    'kiro-capture-worker',
 ];
 /**
  * Hook CLI Commands
@@ -155,6 +157,16 @@ class HookCommands {
                 await handleKiroToolOutcome(input);
                 break;
             }
+            case 'kiro-capture': {
+                const { handleKiroCapture } = await Promise.resolve().then(() => __importStar(require('../../hooks/kiro-hooks')));
+                await handleKiroCapture(input);
+                break;
+            }
+            case 'kiro-capture-worker': {
+                const { handleKiroCaptureWorker } = await Promise.resolve().then(() => __importStar(require('../../hooks/kiro-hooks')));
+                await handleKiroCaptureWorker(input);
+                break;
+            }
             default:
                 console.error(`Unknown hook: ${name}`);
                 console.error(`Available: ${AVAILABLE_HOOKS.join(', ')}`);

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

@@ -57,6 +57,30 @@ class KiroCommands {
             timeout: 120000,
         };
     }
+    /** The bare classifier agent config — no MCP, no hooks, no tools. */
+    static buildClassifierAgentConfig() {
+        return {
+            name: KiroCommands.CLASSIFIER_AGENT_NAME,
+            description: 'Headless memory classifier for Claude Recall. No MCP servers, hooks, or tools — invoked by the capture worker to decide what to remember, using Kiro\'s own LLM.',
+            mcpServers: {},
+            includeMcpJson: false,
+            tools: [],
+            allowedTools: [],
+            hooks: {},
+        };
+    }
+    /**
+     * Write the bare classifier agent to ~/.kiro/agents/ (always global, so any
+     * project's capture worker can invoke `--agent claude-recall-classifier`).
+     * Idempotent overwrite — the file is entirely ours. Returns its path.
+     */
+    static writeClassifierAgent() {
+        const dir = path.join(os.homedir(), '.kiro', 'agents');
+        fs.mkdirSync(dir, { recursive: true });
+        const p = path.join(dir, `${KiroCommands.CLASSIFIER_AGENT_NAME}.json`);
+        fs.writeFileSync(p, JSON.stringify(KiroCommands.buildClassifierAgentConfig(), null, 2) + '\n');
+        return p;
+    }
     /** The four lifecycle hook entries (shared by fresh config and merge). */
     static buildHookEntries(hookCmd) {
         return {
@@ -64,9 +88,12 @@ class KiroCommands {
             agentSpawn: [
                 { command: `${hookCmd} kiro-agent-spawn`, timeout_ms: 10000 },
             ],
-            // Kiro's userPromptSubmit payload matches correction-detector exactly
+            // Capture. kiro-capture spawns a detached worker that classifies the
+            // prompt via Kiro's own headless LLM (no ANTHROPIC_API_KEY needed) and
+            // stores in the background — see src/hooks/kiro-classifier.ts. The hook
+            // itself returns in milliseconds, so the short timeout is ample.
             userPromptSubmit: [
-                { command: `${hookCmd} correction-detector`, timeout_ms: 8000 },
+                { command: `${hookCmd} kiro-capture`, timeout_ms: 8000 },
             ],
             preToolUse: [
                 { matcher: '*', command: `${hookCmd} kiro-rule-injector`, timeout_ms: 5000 },
@@ -134,7 +161,7 @@ class KiroCommands {
         }
         const handlerMarkers = {
             agentSpawn: 'kiro-agent-spawn',
-            userPromptSubmit: 'correction-detector',
+            userPromptSubmit: 'kiro-capture',
             preToolUse: 'kiro-rule-injector',
             postToolUse: 'kiro-tool-outcome',
         };
@@ -214,8 +241,11 @@ class KiroCommands {
         const backupPath = `${agentPath}.bak.${new Date().toISOString().replace(/[:.]/g, '-')}`;
         fs.writeFileSync(backupPath, raw);
         fs.writeFileSync(agentPath, JSON.stringify(config, null, 2) + '\n');
+        // Capture uses Kiro's own headless LLM via a bare classifier agent.
+        const classifierPath = KiroCommands.writeClassifierAgent();
         console.log(`✅ Merged Claude Recall into: ${agentPath}`);
         console.log(`   Backup: ${backupPath}`);
+        console.log(`   Classifier agent: ${classifierPath}`);
         console.log('');
         for (const c of changes)
             console.log(`   • ${c}`);
@@ -251,7 +281,10 @@ class KiroCommands {
         fs.mkdirSync(baseDir, { recursive: true });
         const config = KiroCommands.buildAgentConfig(hookCmd, mcpCommand, mcpArgs);
         fs.writeFileSync(agentPath, JSON.stringify(config, null, 2) + '\n');
+        // Capture uses Kiro's own headless LLM via a bare classifier agent.
+        const classifierPath = KiroCommands.writeClassifierAgent();
         console.log(`✅ Wrote Kiro agent config: ${agentPath}`);
+        console.log(`✅ Wrote classifier agent:  ${classifierPath}`);
         console.log('');
         console.log('No mcp.json changes needed — the agent config carries its own claude-recall');
         console.log('MCP server entry (and includeMcpJson keeps your other servers working).');
@@ -266,7 +299,9 @@ class KiroCommands {
         console.log('');
         console.log('Rules load into context automatically at agent start; corrections and');
         console.log('preferences you state are captured; memories are shared with Claude Code');
-        console.log('(same database, same per-project scoping).');
+        console.log('(same database, same per-project scoping). Capture classifies each prompt');
+        console.log('with Kiro\'s own LLM — no ANTHROPIC_API_KEY needed (spends ~0.06 Kiro');
+        console.log('credits/prompt; set CLAUDE_RECALL_KIRO_MODEL to change the model).');
         console.log('');
         console.log('⚠️  Kiro snapshots the agent config into each conversation at creation —');
         console.log('conversations created before this setup never run the hooks, even when');
@@ -406,6 +441,25 @@ class KiroCommands {
             line('⚠', 'none found. Run `claude-recall kiro setup` (new agent) or');
             line(' ', '        `claude-recall kiro setup --merge-into <agent>` (existing agent).');
         }
+        // --- Capture backend (Kiro LLM classifier) ---
+        console.log('\nCapture backend (no ANTHROPIC_API_KEY needed under Kiro)');
+        const classifierPath = path.join(os.homedir(), '.kiro', 'agents', `${KiroCommands.CLASSIFIER_AGENT_NAME}.json`);
+        if (fs.existsSync(classifierPath)) {
+            line('✓', `classifier agent present: ${classifierPath}`);
+        }
+        else {
+            line('⚠', `classifier agent missing (${KiroCommands.CLASSIFIER_AGENT_NAME}.json) — re-run \`claude-recall kiro setup\` or \`--merge-into\`. Capture falls back to regex without it.`);
+        }
+        if ((0, repair_1.resolveOnPath)('kiro-cli')) {
+            const model = process.env.CLAUDE_RECALL_KIRO_MODEL || 'claude-haiku-4.5';
+            line('✓', `kiro-cli on PATH — capture classifies with Kiro's LLM (model: ${model})`);
+        }
+        else {
+            line('⚠', 'kiro-cli not on PATH — capture cannot reach Kiro\'s LLM and falls back to regex.');
+        }
+        if (process.env.ANTHROPIC_API_KEY) {
+            line('•', 'ANTHROPIC_API_KEY is set — it takes precedence over the Kiro LLM for capture.');
+        }
         // --- Hook activity ---
         console.log('\nRecent hook activity');
         const dir = process.env.CLAUDE_RECALL_DB_PATH || path.join(os.homedir(), '.claude-recall');
@@ -462,3 +516,9 @@ KiroCommands.ALLOWED_TOOLS = [
     '@claude-recall/search_memory',
     '@claude-recall/load_checkpoint',
 ];
+/**
+ * Name of the bare agent used for headless memory classification. Kept in
+ * sync with CLASSIFIER_AGENT in src/hooks/kiro-classifier.ts (duplicated as a
+ * plain string so this module doesn't pull the hooks graph into jest).
+ */
+KiroCommands.CLASSIFIER_AGENT_NAME = 'claude-recall-classifier';

package/dist/hooks/kiro-classifier.js

@@ -0,0 +1,160 @@
+"use strict";
+/**
+ * Kiro-LLM memory classifier.
+ *
+ * When Claude Recall runs under Kiro CLI there is no ANTHROPIC_API_KEY, so the
+ * usual Haiku classifier (llm-classifier.ts) is unavailable and capture would
+ * degrade to regex. But Kiro CLI ships its own LLM and exposes it headlessly:
+ * `kiro-cli chat --no-interactive "<prompt>"` runs a one-shot completion on
+ * Kiro's model using Kiro's own auth — no API key, no personal subscription.
+ * See docs/kiro-llm-capture.md for the full findings.
+ *
+ * This module shells out to that headless mode to classify a user prompt into
+ * the same ClassifyResult shape the rest of the pipeline expects. It runs from
+ * a DETACHED worker (kiro-capture-worker), never inline on the user's turn,
+ * because a cold `kiro-cli` boot can take ~15s.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CLASSIFIER_AGENT = void 0;
+exports.extractClassification = extractClassification;
+exports.classifyWithKiro = classifyWithKiro;
+const child_process_1 = require("child_process");
+const shared_1 = require("./shared");
+/** Bare Kiro agent used for classification — no MCP, no hooks, no tools. */
+exports.CLASSIFIER_AGENT = 'claude-recall-classifier';
+const DEFAULT_MODEL = 'claude-haiku-4.5';
+const DEFAULT_TIMEOUT_MS = 30000;
+const VALID_TYPES = new Set([
+    'correction',
+    'preference',
+    'failure',
+    'devops',
+    'project-knowledge',
+]);
+/**
+ * The classify instruction, prepended to the user's message. kiro-cli takes a
+ * single INPUT argument (no separate system prompt), so instruction + payload
+ * are combined. Mirrors the contract of llm-classifier's SYSTEM_PROMPT so
+ * downstream thresholds/dedup behave identically regardless of which LLM ran.
+ */
+function buildPrompt(text) {
+    return ('You are a memory classifier for a developer tool. Classify the USER MESSAGE ' +
+        'into exactly one type and respond with ONLY minified JSON — no markdown, no ' +
+        'prose, no code fence:\n' +
+        '{"type":"correction|preference|failure|devops|project-knowledge|none","confidence":0.0-1.0,"extract":"<concise imperative rule to remember, or empty>"}\n\n' +
+        'Types:\n' +
+        '- correction: user correcting a mistake ("no, use X not Y")\n' +
+        '- preference: a reusable directive about how the user wants things done ("I prefer X", "we use tabs", "my favourite color is green"). Must apply beyond this one message.\n' +
+        '- failure: something broke ("build failed")\n' +
+        '- devops: durable CI/CD, git, deployment, or Docker rules\n' +
+        '- project-knowledge: architecture, stack, database, or API facts\n' +
+        '- none: questions, chitchat, task instructions, observations, or anything not worth remembering across sessions\n\n' +
+        'Be conservative: when in doubt use "none" with confidence 0. Use confidence >= 0.75 for correction/preference/devops. ' +
+        'extract must be a clean standalone rule (e.g. "Favourite colour is green"), or empty when type is none.\n\n' +
+        'USER MESSAGE: ' + text);
+}
+/** Strip ANSI/VT control sequences that kiro-cli writes around its output. */
+function stripAnsi(s) {
+    // Anchor every strip to the ESC byte (\x1b) so ordinary JSON text —
+    // uppercase letters, hyphens, braces — is never touched. First form: CSI
+    // (ESC [ ... final byte); second: two-byte ESC <char>. The control char in
+    // the pattern is deliberate — that's exactly what we're stripping.
+    // eslint-disable-next-line no-control-regex
+    return s.replace(/\x1b\[[0-9;?]*[ -/]*[@-~]/g, '').replace(/\x1b[@-_]/g, '');
+}
+/**
+ * Pull the first balanced JSON object out of kiro-cli's decorated stdout.
+ * The output looks like `> {"type":...}` or `> json\n{...}`, possibly wrapped
+ * in a ```json fence and coloured with ANSI. Returns null if no object parses.
+ */
+function extractClassification(raw) {
+    const cleaned = stripAnsi(raw);
+    const start = cleaned.indexOf('{');
+    const end = cleaned.lastIndexOf('}');
+    if (start === -1 || end === -1 || end <= start)
+        return null;
+    let parsed;
+    try {
+        parsed = JSON.parse(cleaned.slice(start, end + 1));
+    }
+    catch {
+        return null;
+    }
+    if (!parsed || typeof parsed !== 'object')
+        return null;
+    if (parsed.type === 'none' || !VALID_TYPES.has(parsed.type))
+        return null;
+    if (typeof parsed.extract !== 'string' || parsed.extract.trim().length === 0)
+        return null;
+    const confidence = typeof parsed.confidence === 'number' ? parsed.confidence : 0.7;
+    return {
+        type: parsed.type,
+        confidence,
+        extract: parsed.extract.trim(),
+    };
+}
+/**
+ * Classify a prompt by invoking Kiro's headless LLM. Returns null on any
+ * failure (kiro-cli absent, timeout, non-zero exit, unparseable output) so the
+ * caller falls back to regex. Never throws.
+ */
+function classifyWithKiro(text) {
+    const model = process.env.CLAUDE_RECALL_KIRO_MODEL || DEFAULT_MODEL;
+    const timeoutMs = parseInt(process.env.CLAUDE_RECALL_KIRO_LLM_TIMEOUT_MS || '', 10);
+    const timeout = Number.isFinite(timeoutMs) && timeoutMs > 0 ? timeoutMs : DEFAULT_TIMEOUT_MS;
+    return new Promise((resolve) => {
+        let settled = false;
+        const done = (result) => {
+            if (settled)
+                return;
+            settled = true;
+            resolve(result);
+        };
+        let child;
+        try {
+            // args array (no shell) — the user's text is passed as a single argv
+            // entry, so no shell escaping or injection is possible.
+            child = (0, child_process_1.spawn)('kiro-cli', [
+                'chat',
+                '--no-interactive',
+                '--agent', exports.CLASSIFIER_AGENT,
+                '--model', model,
+                buildPrompt(text),
+            ], { stdio: ['ignore', 'pipe', 'ignore'] });
+        }
+        catch (err) {
+            (0, shared_1.hookLog)('kiro-classifier', `spawn threw: ${(0, shared_1.safeErrorMessage)(err)}`);
+            return done(null);
+        }
+        const timer = setTimeout(() => {
+            (0, shared_1.hookLog)('kiro-classifier', `timeout after ${timeout}ms — killing kiro-cli`);
+            try {
+                child.kill('SIGKILL');
+            }
+            catch { /* already gone */ }
+            done(null);
+        }, timeout);
+        let stdout = '';
+        child.stdout?.on('data', (chunk) => { stdout += chunk.toString(); });
+        child.on('error', (err) => {
+            clearTimeout(timer);
+            // ENOENT = kiro-cli not on PATH; anything else = spawn failure
+            (0, shared_1.hookLog)('kiro-classifier', `kiro-cli error: ${err?.code ?? ''} ${err?.message ?? err}`);
+            done(null);
+        });
+        child.on('close', (code) => {
+            clearTimeout(timer);
+            if (settled)
+                return;
+            if (code !== 0) {
+                (0, shared_1.hookLog)('kiro-classifier', `kiro-cli exited ${code}`);
+                return done(null);
+            }
+            const result = extractClassification(stdout);
+            if (!result) {
+                (0, shared_1.hookLog)('kiro-classifier', 'no parseable classification in kiro-cli output');
+            }
+            done(result);
+        });
+    });
+}

package/dist/hooks/kiro-hooks.js

@@ -31,12 +31,16 @@ exports.normalizeKiroInput = normalizeKiroInput;
 exports.handleKiroAgentSpawn = handleKiroAgentSpawn;
 exports.handleKiroRuleInjector = handleKiroRuleInjector;
 exports.handleKiroToolOutcome = handleKiroToolOutcome;
+exports.handleKiroCapture = handleKiroCapture;
+exports.handleKiroCaptureWorker = handleKiroCaptureWorker;
+const child_process_1 = require("child_process");
 const shared_1 = require("./shared");
 const directives_1 = require("../shared/directives");
 const memory_1 = require("../services/memory");
 const config_1 = require("../services/config");
 const rule_injector_1 = require("./rule-injector");
 const tool_outcome_watcher_1 = require("./tool-outcome-watcher");
+const correction_detector_1 = require("./correction-detector");
 const memory_tools_1 = require("../mcp/tools/memory-tools");
 const HOOK_NAME = 'kiro';
 /** Kiro built-in tool names → the Claude Code names our handlers understand. */
@@ -180,3 +184,58 @@ async function handleKiroToolOutcome(input) {
         (0, shared_1.hookLog)(HOOK_NAME, `tool-outcome error: ${(0, shared_1.safeErrorMessage)(err)}`);
     }
 }
+/**
+ * userPromptSubmit — the synchronous gate Kiro waits on. Under Kiro there is no
+ * ANTHROPIC_API_KEY, so classification uses Kiro's own headless LLM
+ * (`kiro-cli chat --no-interactive`), which cold-boots in ~3–15s — too slow to
+ * run inline within Kiro's hook timeout, and a poor UX blocking every turn.
+ *
+ * So this handler does NOT classify. It spawns a DETACHED worker
+ * (kiro-capture-worker) that survives this process, pipes the prompt payload to
+ * it over stdin, and returns in milliseconds. The worker performs the slow Kiro
+ * classify call and stores the memory in the background. Same pattern as
+ * session-end-checkpoint. See docs/kiro-llm-capture.md.
+ */
+async function handleKiroCapture(input) {
+    const prompt = input?.prompt ?? '';
+    // Cheap pre-checks mirror correction-detector so we don't spawn a worker (and
+    // spend Kiro credits) on input that could never be stored.
+    if (prompt.length < 20 || prompt.length > 2000)
+        return;
+    if (prompt.startsWith('```') || prompt.startsWith('{'))
+        return;
+    try {
+        const cliPath = process.argv[1]; // absolute path to claude-recall-cli.js
+        const child = (0, child_process_1.spawn)(process.execPath, [cliPath, 'hook', 'run', 'kiro-capture-worker'], { detached: true, stdio: ['pipe', 'ignore', 'ignore'] });
+        child.on('error', (err) => {
+            (0, shared_1.hookLog)(HOOK_NAME, `capture worker spawn error: ${err?.message ?? err}`);
+        });
+        if (child.stdin) {
+            child.stdin.on('error', (err) => {
+                (0, shared_1.hookLog)(HOOK_NAME, `capture worker stdin error: ${err?.message ?? err}`);
+            });
+            child.stdin.write(JSON.stringify(input));
+            child.stdin.end();
+        }
+        child.unref();
+        (0, shared_1.hookLog)(HOOK_NAME, `capture: spawned detached worker (pid=${child.pid})`);
+    }
+    catch (err) {
+        (0, shared_1.hookLog)(HOOK_NAME, `capture spawn failed: ${(0, shared_1.safeErrorMessage)(err)}`);
+    }
+}
+/**
+ * kiro-capture-worker — the background half of handleKiroCapture. Enables the
+ * Kiro-LLM classifier path (CLAUDE_RECALL_KIRO_CLASSIFIER) and delegates to the
+ * standard correction-detector, which now classifies via Kiro's headless LLM
+ * and stores. Runs detached, so its output goes nowhere and capture is silent.
+ */
+async function handleKiroCaptureWorker(input) {
+    process.env.CLAUDE_RECALL_KIRO_CLASSIFIER = '1';
+    try {
+        await (0, correction_detector_1.handleCorrectionDetector)(input);
+    }
+    catch (err) {
+        (0, shared_1.hookLog)(HOOK_NAME, `capture worker error: ${(0, shared_1.safeErrorMessage)(err)}`);
+    }
+}

package/dist/hooks/shared.js

@@ -133,13 +133,26 @@ function classifyContentRegex(text) {
 }
 /**
  * Classify text content — LLM-first, regex fallback.
- * Tries Claude Haiku via ANTHROPIC_API_KEY (set by Claude Code automatically).
- * Falls back to regex patterns if API is unavailable or call fails.
+ * Precedence:
+ *   1. Claude Haiku via ANTHROPIC_API_KEY (Claude Code sets this automatically).
+ *   2. Kiro's headless LLM (`kiro-cli chat --no-interactive`) when running under
+ *      Kiro — no API key needed. Gated on CLAUDE_RECALL_KIRO_CLASSIFIER, which
+ *      the kiro-capture-worker sets; the classify call is ~3s so it only runs
+ *      from that detached worker, never inline. See docs/kiro-llm-capture.md.
+ *   3. Regex patterns, if neither LLM path yields a result.
  */
 async function classifyContent(text) {
     const llmResult = await (0, llm_classifier_1.classifyWithLLM)(text);
     if (llmResult)
         return llmResult;
+    if (process.env.CLAUDE_RECALL_KIRO_CLASSIFIER) {
+        // Dynamic import keeps kiro-classifier (and child_process) out of the
+        // module graph for every non-Kiro hook invocation.
+        const { classifyWithKiro } = await Promise.resolve().then(() => __importStar(require('./kiro-classifier')));
+        const kiroResult = await classifyWithKiro(text);
+        if (kiroResult)
+            return kiroResult;
+    }
     return classifyContentRegex(text);
 }
 /**

package/docs/kiro-llm-capture.md

@@ -0,0 +1,128 @@
+# Using Kiro's LLM for memory capture (no API key)
+
+## The problem
+
+Claude Recall captures memories with an LLM classifier: it reads each user
+prompt and decides whether it contains a durable preference, correction, or
+project fact worth storing. That classifier normally calls Claude Haiku through
+`ANTHROPIC_API_KEY`, which Claude Code sets automatically for its hook
+subprocesses.
+
+Kiro CLI does **not** set `ANTHROPIC_API_KEY`. So under Kiro the classifier fell
+back to a conservative regex that only fires on explicit phrasings
+("remember …", "always …", "I prefer …"). A natural statement like
+"my favourite color is green" was examined and rejected
+(`no rule detected in prompt` in `correction-detector.log`), and nothing was
+stored. Worse, under enterprise MCP governance the `store_memory` tool is
+dropped from the agent's toolset, so the agent itself can't store on demand
+either — leaving regex as the *only* capture path.
+
+Two non-answers:
+
+- **"Just export `ANTHROPIC_API_KEY`."** Works, but forces the user to bring
+  their own Claude subscription/credits when Kiro already includes an LLM.
+- **"Broaden the regex."** Trades one brittle heuristic for a slightly larger
+  brittle heuristic; still misses anything not phrased as a known trigger.
+
+## The finding
+
+**`kiro-cli chat --no-interactive "<prompt>"` is a headless one-shot completion
+that runs on Kiro's own model and Kiro's own authentication.** It is exactly the
+subprocess-callable LLM I had wrongly assumed didn't exist. A background hook can
+shell out to it to classify text, with no API key and no personal subscription.
+
+Verified on Kiro CLI 2.7.0 (Kiro PRO):
+
+| Property | Result |
+| --- | --- |
+| Auth | Uses the Kiro login. No `ANTHROPIC_API_KEY`. Consumes Kiro credits (~0.06 per call on Haiku). |
+| Model | `--list-models` exposes `claude-haiku-4.5` (rate 0.4 — cheapest Claude), plus Sonnet/Opus tiers. |
+| Classify **and** extract in one call | `{"store": true, "type": "preference", "value": "favourite color is green"}` |
+| Latency (bare agent, warm) | ~2.9–3.4 s |
+| Latency (default agent, cold) | ~16 s — dominated by loading the session's MCP servers and firing that agent's own hooks |
+| Reachable from a minimal `PATH` | Yes — `~/.local/bin/kiro-cli` resolves |
+
+### Why a dedicated "bare" agent matters
+
+Running the classify call through the *default* agent is slow and unsafe:
+
+- It loads all of the session's MCP servers (the enterprise setup loads five),
+  adding ~5 s.
+- It fires that agent's own `agentSpawn`/hook chain — including Claude Recall's
+  own hooks if they're wired — which risks **recursion** (a capture call that
+  triggers another capture call).
+
+So `kiro setup` writes a minimal `claude-recall-classifier` agent to
+`~/.kiro/agents/` with **no MCP servers, no hooks, and no tools**. The classify
+call runs `--agent claude-recall-classifier`, which cold-boots in ~3 s and
+cannot recurse.
+
+### Why capture must run asynchronously
+
+Kiro enforces a per-hook timeout (we wire `userPromptSubmit` at 8 s). A cold
+classify call can exceed that, which would kill the hook on the first — and most
+important — prompt of a session. Even when it fits, blocking every turn on a
+~3 s LLM call is a poor experience for an interactive session.
+
+So the `userPromptSubmit` hook does **not** classify inline. It spawns a
+**detached worker** (the same pattern as `session-end-checkpoint`), pipes the
+prompt to it over stdin, and returns in milliseconds. The worker performs the
+~3 s Kiro classify call and stores the memory in the background. The trade-off:
+no synchronous "captured" echo, and a brief window where a memory stated in one
+turn isn't queryable until the worker finishes (~3 s later) — acceptable for
+capture.
+
+## The design
+
+```
+Kiro userPromptSubmit
+        │
+        ▼
+  hook run kiro-capture          (returns in <100 ms)
+        │  spawn detached, pipe payload via stdin
+        ▼
+  hook run kiro-capture-worker   (background, survives parent exit)
+        │  sets CLAUDE_RECALL_KIRO_CLASSIFIER=1
+        ▼
+  handleCorrectionDetector → classifyContent()
+        │
+        ├─ classifyWithLLM()   → ANTHROPIC_API_KEY (unset under Kiro) → null
+        ├─ classifyWithKiro()  → kiro-cli chat --no-interactive --agent
+        │                         claude-recall-classifier --model claude-haiku-4.5
+        │                         → {"type","confidence","extract"}
+        └─ regex fallback       (only if both above yield nothing)
+```
+
+Capture precedence under Kiro becomes: **your own `ANTHROPIC_API_KEY` if you set
+one → Kiro's headless LLM → regex as a last resort.** In the governance-locked,
+no-key setup the Kiro LLM is the primary path and regex is just a safety net.
+
+### Output parsing
+
+`kiro-cli` decorates stdout with a `> ` prompt marker, occasional ```` ```json ````
+fences, and ANSI control sequences (the spinner and credits footer go to
+stderr). `classifyWithKiro` strips ANSI, removes the marker and fences, extracts
+the first balanced `{ … }` block, and `JSON.parse`s it. Any failure at any step
+returns `null`, degrading to regex — a hook must never throw.
+
+### Configuration
+
+| Variable | Default | Effect |
+| --- | --- | --- |
+| `CLAUDE_RECALL_KIRO_CLASSIFIER` | *(set by the worker)* | Enables the Kiro-LLM path in `classifyContent`. Set automatically by `kiro-capture-worker`; never needed by hand. |
+| `CLAUDE_RECALL_KIRO_MODEL` | `claude-haiku-4.5` | Model for the classify call. Raise to `claude-sonnet-4.6` for steadier judgement at ~3× the credits. |
+| `CLAUDE_RECALL_KIRO_LLM_TIMEOUT_MS` | `30000` | Hard cap on the headless call before the worker gives up and falls back to regex. |
+
+## Caveats
+
+- **Consistency.** Haiku returned YES then NO on near-identical prompt wording
+  during testing. The classify prompt is written to be explicit, and
+  `CLAUDE_RECALL_KIRO_MODEL` lets you trade credits for a steadier model.
+- **Cost.** Each classified prompt spends ~0.06 Kiro credits on Haiku. That is
+  the deliberate trade for using Kiro's LLM instead of a personal subscription.
+- **Concurrency.** The worker opens a second, throwaway headless conversation
+  while the interactive session runs. They use different agents and no
+  `--resume`, so they're independent; SQLite WAL handles concurrent writes.
+- **Requires `kiro-cli` on `PATH`.** If it's absent the classify call errors and
+  the worker falls back to regex — no crash.
+```

package/package.json

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