@dot-ai/adapter-claude 0.5.2 → 0.7.0

package/dist/__tests__/hook.test.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Tests for hook.ts logic patterns.
+ *
+ * hook.ts is a CLI entry point (self-executing, reads from stdin) so we cannot
+ * import its handlers directly. Instead we:
+ *   1. Re-implement the key regex logic and verify it matches the source patterns.
+ *   2. Test the handler behaviours by calling the equivalent logic through
+ *      a thin reimplementation that accepts the same mocked DotAiRuntime.
+ *
+ * The regexes under test are the canonical ones from hook.ts:
+ *   - Memory-file detection:  /memory\/[^\s]*\.md$/i
+ *   - Bash memory-write:      /memory\/[^\s]*\.md/i  +  /(?:>|tee|cp|mv|cat\s*<<|echo\s.*>)/i
+ */
+export {};

package/dist/__tests__/hook.test.js

@@ -0,0 +1,439 @@
+/**
+ * Tests for hook.ts logic patterns.
+ *
+ * hook.ts is a CLI entry point (self-executing, reads from stdin) so we cannot
+ * import its handlers directly. Instead we:
+ *   1. Re-implement the key regex logic and verify it matches the source patterns.
+ *   2. Test the handler behaviours by calling the equivalent logic through
+ *      a thin reimplementation that accepts the same mocked DotAiRuntime.
+ *
+ * The regexes under test are the canonical ones from hook.ts:
+ *   - Memory-file detection:  /memory\/[^\s]*\.md$/i
+ *   - Bash memory-write:      /memory\/[^\s]*\.md/i  +  /(?:>|tee|cp|mv|cat\s*<<|echo\s.*>)/i
+ */
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { ADAPTER_CAPABILITIES } from '@dot-ai/core';
+// ── Regex constants (copied verbatim from hook.ts) ──────────────────────────
+const MEMORY_FILE_RE = /memory\/[^\s]*\.md$/i;
+const BASH_MEMORY_PATH_RE = /memory\/[^\s]*\.md/i;
+const BASH_WRITE_OP_RE = /(?:>|tee|cp|mv|cat\s*<<|echo\s.*>)/i;
+async function handlePreToolUse(event, runtime, out = []) {
+    const toolName = (event.tool_name ?? '');
+    const input = (event.tool_input ?? {});
+    // Extension check first
+    const extensionResult = await runtime.fireToolCall({ tool: toolName, input });
+    if (extensionResult?.decision === 'block') {
+        const payload = { decision: 'block', reason: extensionResult.reason ?? 'Blocked by extension' };
+        out.push(JSON.stringify(payload));
+        return payload;
+    }
+    // Hardcoded memory-file blocking
+    if (toolName === 'Write' || toolName === 'Edit') {
+        const filePath = (input.file_path ?? input.path ?? '');
+        if (filePath && MEMORY_FILE_RE.test(filePath)) {
+            const payload = {
+                decision: 'block',
+                reason: 'Memory is managed by dot-ai SQLite provider. Use the memory_store tool instead.',
+            };
+            out.push(JSON.stringify(payload));
+            return payload;
+        }
+    }
+    if (toolName === 'Bash') {
+        const command = (input.command ?? '');
+        if (BASH_MEMORY_PATH_RE.test(command) && BASH_WRITE_OP_RE.test(command)) {
+            const payload = {
+                decision: 'block',
+                reason: 'Memory is managed by dot-ai SQLite provider. Use the memory_store tool instead.',
+            };
+            out.push(JSON.stringify(payload));
+            return payload;
+        }
+    }
+    return null;
+}
+async function handlePromptSubmit(event, runtime, out = []) {
+    const prompt = (event.prompt ?? event.content ?? '');
+    if (!prompt)
+        return;
+    const { formatted } = await runtime.processPrompt(prompt);
+    if (formatted) {
+        out.push(JSON.stringify({ result: formatted }));
+    }
+}
+async function handlePreCompact(event, runtime) {
+    const summary = (event.summary ?? event.content ?? '');
+    if (summary) {
+        await runtime.fire('agent_end', {
+            response: `[compaction] ${summary.slice(0, 1000)}`,
+        });
+    }
+}
+async function handleStop(event, runtime) {
+    const response = (event.response ?? event.content ?? '');
+    if (response) {
+        await runtime.learn(response);
+    }
+}
+function handleSessionStart(_event, runtime, errOut = []) {
+    const diag = runtime.diagnostics;
+    errOut.push(`[dot-ai] Booted\n`);
+    if (diag.extensions.length > 0) {
+        errOut.push(`[dot-ai] ${diag.extensions.length} extension(s), ${diag.capabilityCount} tool(s)\n`);
+        for (const ext of diag.extensions) {
+            for (const eventName of Object.keys(ext.handlerCounts)) {
+                if (!ADAPTER_CAPABILITIES['claude-code'].has(eventName)) {
+                    errOut.push(`[dot-ai] Warning: Extension ${ext.path} uses '${eventName}' (not supported by Claude Code adapter)\n`);
+                }
+            }
+        }
+    }
+}
+// ── Mock factory ─────────────────────────────────────────────────────────────
+function makeRuntime() {
+    return {
+        fireToolCall: vi.fn().mockResolvedValue(null),
+        processPrompt: vi.fn().mockResolvedValue({ formatted: '', enriched: {}, capabilities: [] }),
+        learn: vi.fn().mockResolvedValue(undefined),
+        fire: vi.fn().mockResolvedValue([]),
+        diagnostics: { extensions: [], usedTiers: [], capabilityCount: 0, vocabularySize: 0 },
+        flush: vi.fn().mockResolvedValue(undefined),
+        boot: vi.fn().mockResolvedValue(undefined),
+        shutdown: vi.fn().mockResolvedValue(undefined),
+        capabilities: [],
+        isBooted: true,
+        runner: null,
+    };
+}
+// ── Tests ────────────────────────────────────────────────────────────────────
+describe('MEMORY_FILE_RE', () => {
+    it('matches direct memory path', () => {
+        expect(MEMORY_FILE_RE.test('memory/notes.md')).toBe(true);
+    });
+    it('matches nested memory path', () => {
+        expect(MEMORY_FILE_RE.test('/home/user/.ai/memory/sub/dir/notes.md')).toBe(true);
+    });
+    it('matches case-insensitively', () => {
+        expect(MEMORY_FILE_RE.test('MEMORY/NOTES.MD')).toBe(true);
+    });
+    it('does not match non-md extension', () => {
+        expect(MEMORY_FILE_RE.test('memory/notes.txt')).toBe(false);
+    });
+    it('does not match path without memory segment', () => {
+        expect(MEMORY_FILE_RE.test('/project/src/notes.md')).toBe(false);
+    });
+    it('does not match when md is not at end', () => {
+        expect(MEMORY_FILE_RE.test('memory/notes.md.bak')).toBe(false);
+    });
+    it('does not match when filename has space before .md', () => {
+        expect(MEMORY_FILE_RE.test('memory/foo .md')).toBe(false);
+    });
+});
+describe('BASH_MEMORY_PATH_RE + BASH_WRITE_OP_RE', () => {
+    function isBashBlocked(cmd) {
+        return BASH_MEMORY_PATH_RE.test(cmd) && BASH_WRITE_OP_RE.test(cmd);
+    }
+    it('blocks redirect write (>)', () => {
+        expect(isBashBlocked('echo hello > memory/notes.md')).toBe(true);
+    });
+    it('blocks tee', () => {
+        expect(isBashBlocked('cat file.txt | tee memory/notes.md')).toBe(true);
+    });
+    it('blocks cp into memory', () => {
+        expect(isBashBlocked('cp backup.md memory/notes.md')).toBe(true);
+    });
+    it('blocks mv into memory', () => {
+        expect(isBashBlocked('mv tmp.md memory/notes.md')).toBe(true);
+    });
+    it('blocks cat heredoc', () => {
+        expect(isBashBlocked('cat << EOF > memory/notes.md')).toBe(true);
+    });
+    it('blocks echo with redirect', () => {
+        expect(isBashBlocked('echo "data" > memory/notes.md')).toBe(true);
+    });
+    it('allows cat read from memory (no write op)', () => {
+        expect(isBashBlocked('cat memory/notes.md')).toBe(false);
+    });
+    it('allows grep on memory files', () => {
+        expect(isBashBlocked('grep foo memory/notes.md')).toBe(false);
+    });
+    it('allows write op on non-memory path', () => {
+        expect(isBashBlocked('echo hello > /tmp/notes.md')).toBe(false);
+    });
+});
+describe('handlePreToolUse', () => {
+    let runtime;
+    let out;
+    beforeEach(() => {
+        runtime = makeRuntime();
+        out = [];
+    });
+    describe('extension-based blocking', () => {
+        it('blocks when extension returns decision=block', async () => {
+            vi.mocked(runtime.fireToolCall).mockResolvedValue({ decision: 'block', reason: 'No access' });
+            const result = await handlePreToolUse({ tool_name: 'Write', tool_input: { file_path: '/some/file.ts' } }, runtime, out);
+            expect(result).toMatchObject({ decision: 'block', reason: 'No access' });
+            expect(JSON.parse(out[0])).toMatchObject({ decision: 'block', reason: 'No access' });
+        });
+        it('uses fallback reason when extension provides none', async () => {
+            vi.mocked(runtime.fireToolCall).mockResolvedValue({ decision: 'block', reason: undefined });
+            const result = await handlePreToolUse({ tool_name: 'Read', tool_input: {} }, runtime, out);
+            expect(result).toMatchObject({ decision: 'block', reason: 'Blocked by extension' });
+        });
+        it('runs extension check BEFORE hardcoded memory check', async () => {
+            vi.mocked(runtime.fireToolCall).mockResolvedValue({ decision: 'block', reason: 'Custom extension block' });
+            const result = await handlePreToolUse({ tool_name: 'Write', tool_input: { file_path: 'memory/notes.md' } }, runtime, out);
+            expect(result).toMatchObject({ reason: 'Custom extension block' });
+        });
+        it('proceeds to hardcoded checks when extension returns null', async () => {
+            vi.mocked(runtime.fireToolCall).mockResolvedValue(null);
+            const result = await handlePreToolUse({ tool_name: 'Write', tool_input: { file_path: 'memory/notes.md' } }, runtime, out);
+            expect(result).toMatchObject({ decision: 'block' });
+            expect(result).toMatchObject({ reason: expect.stringContaining('SQLite') });
+        });
+    });
+    describe('Write tool blocking', () => {
+        it('blocks Write to memory/*.md via file_path', async () => {
+            const result = await handlePreToolUse({ tool_name: 'Write', tool_input: { file_path: 'memory/notes.md' } }, runtime, out);
+            expect(result).toMatchObject({ decision: 'block' });
+            expect(JSON.parse(out[0]).decision).toBe('block');
+        });
+        it('blocks Write to nested memory path', async () => {
+            const result = await handlePreToolUse({ tool_name: 'Write', tool_input: { file_path: '/home/user/.ai/memory/sub/log.md' } }, runtime, out);
+            expect(result).toMatchObject({ decision: 'block' });
+        });
+        it('blocks Write using .path field (alternative key)', async () => {
+            const result = await handlePreToolUse({ tool_name: 'Write', tool_input: { path: 'memory/notes.md' } }, runtime, out);
+            expect(result).toMatchObject({ decision: 'block' });
+        });
+        it('allows Write to non-memory path', async () => {
+            const result = await handlePreToolUse({ tool_name: 'Write', tool_input: { file_path: '/project/src/notes.md' } }, runtime, out);
+            expect(result).toBeNull();
+            expect(out).toHaveLength(0);
+        });
+        it('allows Write when file_path is empty', async () => {
+            const result = await handlePreToolUse({ tool_name: 'Write', tool_input: { file_path: '' } }, runtime, out);
+            expect(result).toBeNull();
+        });
+    });
+    describe('Edit tool blocking', () => {
+        it('blocks Edit to memory/*.md', async () => {
+            const result = await handlePreToolUse({ tool_name: 'Edit', tool_input: { file_path: 'memory/context.md' } }, runtime, out);
+            expect(result).toMatchObject({ decision: 'block' });
+        });
+        it('allows Edit to non-memory path', async () => {
+            const result = await handlePreToolUse({ tool_name: 'Edit', tool_input: { file_path: 'src/components/App.tsx' } }, runtime, out);
+            expect(result).toBeNull();
+        });
+    });
+    describe('Bash tool blocking', () => {
+        it('blocks echo redirect to memory file', async () => {
+            const result = await handlePreToolUse({ tool_name: 'Bash', tool_input: { command: 'echo hello > memory/notes.md' } }, runtime, out);
+            expect(result).toMatchObject({ decision: 'block' });
+        });
+        it('blocks tee to memory file', async () => {
+            const result = await handlePreToolUse({ tool_name: 'Bash', tool_input: { command: 'cat file | tee memory/notes.md' } }, runtime, out);
+            expect(result).toMatchObject({ decision: 'block' });
+        });
+        it('blocks cp into memory', async () => {
+            const result = await handlePreToolUse({ tool_name: 'Bash', tool_input: { command: 'cp backup.md memory/notes.md' } }, runtime, out);
+            expect(result).toMatchObject({ decision: 'block' });
+        });
+        it('blocks mv into memory', async () => {
+            const result = await handlePreToolUse({ tool_name: 'Bash', tool_input: { command: 'mv tmp.md memory/notes.md' } }, runtime, out);
+            expect(result).toMatchObject({ decision: 'block' });
+        });
+        it('allows cat read from memory (no write op)', async () => {
+            const result = await handlePreToolUse({ tool_name: 'Bash', tool_input: { command: 'cat memory/notes.md' } }, runtime, out);
+            expect(result).toBeNull();
+        });
+        it('allows grep on memory file', async () => {
+            const result = await handlePreToolUse({ tool_name: 'Bash', tool_input: { command: 'grep pattern memory/notes.md' } }, runtime, out);
+            expect(result).toBeNull();
+        });
+        it('allows write op to non-memory path', async () => {
+            const result = await handlePreToolUse({ tool_name: 'Bash', tool_input: { command: 'echo hello > /tmp/output.md' } }, runtime, out);
+            expect(result).toBeNull();
+        });
+        it('allows Bash with empty command', async () => {
+            const result = await handlePreToolUse({ tool_name: 'Bash', tool_input: { command: '' } }, runtime, out);
+            expect(result).toBeNull();
+        });
+    });
+    describe('other tool names', () => {
+        it('allows unrecognised tool names without block', async () => {
+            const result = await handlePreToolUse({ tool_name: 'Read', tool_input: { file_path: 'memory/notes.md' } }, runtime, out);
+            expect(result).toBeNull();
+        });
+    });
+});
+describe('handlePromptSubmit', () => {
+    let runtime;
+    let out;
+    beforeEach(() => {
+        runtime = makeRuntime();
+        out = [];
+    });
+    it('calls processPrompt and writes JSON result to stdout', async () => {
+        vi.mocked(runtime.processPrompt).mockResolvedValue({
+            formatted: 'enriched context',
+            enriched: {},
+            capabilities: [],
+        });
+        await handlePromptSubmit({ prompt: 'how do I do X?' }, runtime, out);
+        expect(runtime.processPrompt).toHaveBeenCalledWith('how do I do X?');
+        expect(JSON.parse(out[0])).toEqual({ result: 'enriched context' });
+    });
+    it('reads prompt from content field if prompt is missing', async () => {
+        vi.mocked(runtime.processPrompt).mockResolvedValue({
+            formatted: 'ctx',
+            enriched: {},
+            capabilities: [],
+        });
+        await handlePromptSubmit({ content: 'alt prompt' }, runtime, out);
+        expect(runtime.processPrompt).toHaveBeenCalledWith('alt prompt');
+    });
+    it('does not write to stdout when formatted is empty', async () => {
+        vi.mocked(runtime.processPrompt).mockResolvedValue({
+            formatted: '',
+            enriched: {},
+            capabilities: [],
+        });
+        await handlePromptSubmit({ prompt: 'hello' }, runtime, out);
+        expect(out).toHaveLength(0);
+    });
+    it('returns early without calling processPrompt when prompt is empty', async () => {
+        await handlePromptSubmit({ prompt: '' }, runtime, out);
+        expect(runtime.processPrompt).not.toHaveBeenCalled();
+        expect(out).toHaveLength(0);
+    });
+    it('returns early when neither prompt nor content present', async () => {
+        await handlePromptSubmit({}, runtime, out);
+        expect(runtime.processPrompt).not.toHaveBeenCalled();
+    });
+});
+describe('handlePreCompact', () => {
+    it('fires agent_end with compaction summary', async () => {
+        const fire = vi.fn().mockResolvedValue([]);
+        const runtime = { fire };
+        await handlePreCompact({ summary: 'session wrapped up nicely' }, runtime);
+        expect(fire).toHaveBeenCalledWith('agent_end', {
+            response: '[compaction] session wrapped up nicely',
+        });
+    });
+    it('truncates summary to 1000 characters', async () => {
+        const fire = vi.fn().mockResolvedValue([]);
+        const runtime = { fire };
+        const longSummary = 'x'.repeat(2000);
+        await handlePreCompact({ summary: longSummary }, runtime);
+        const call = fire.mock.calls[0][1];
+        expect(call.response.length).toBe('[compaction] '.length + 1000);
+    });
+    it('reads from content field when summary is absent', async () => {
+        const fire = vi.fn().mockResolvedValue([]);
+        const runtime = { fire };
+        await handlePreCompact({ content: 'fallback summary' }, runtime);
+        expect(fire).toHaveBeenCalledWith('agent_end', {
+            response: '[compaction] fallback summary',
+        });
+    });
+    it('does nothing when summary is empty', async () => {
+        const fire = vi.fn().mockResolvedValue([]);
+        const runtime = { fire };
+        await handlePreCompact({ summary: '' }, runtime);
+        expect(fire).not.toHaveBeenCalled();
+    });
+});
+describe('handleStop', () => {
+    let runtime;
+    beforeEach(() => {
+        runtime = makeRuntime();
+    });
+    it('calls runtime.learn with the response', async () => {
+        await handleStop({ response: 'I completed the task.' }, runtime);
+        expect(runtime.learn).toHaveBeenCalledWith('I completed the task.');
+    });
+    it('reads from content field when response is absent', async () => {
+        await handleStop({ content: 'alt response' }, runtime);
+        expect(runtime.learn).toHaveBeenCalledWith('alt response');
+    });
+    it('does not call learn when response is empty', async () => {
+        await handleStop({ response: '' }, runtime);
+        expect(runtime.learn).not.toHaveBeenCalled();
+    });
+    it('does not call learn when neither response nor content present', async () => {
+        await handleStop({}, runtime);
+        expect(runtime.learn).not.toHaveBeenCalled();
+    });
+});
+describe('handleSessionStart', () => {
+    it('logs extension count when extensions are loaded', () => {
+        const errOut = [];
+        const runtime = {
+            ...makeRuntime(),
+            diagnostics: {
+                extensions: [
+                    { path: '/ext/my-ext.js', handlerCounts: { prompt_submit: 1 }, toolNames: [], commandNames: [], tiers: [] },
+                ],
+                usedTiers: [],
+                capabilityCount: 0,
+                vocabularySize: 0,
+            },
+        };
+        handleSessionStart({}, runtime, errOut);
+        expect(errOut.some(l => l.includes('1 extension(s)'))).toBe(true);
+    });
+    it('warns about events not supported by Claude Code adapter', () => {
+        const errOut = [];
+        const unsupportedEvent = '__definitely_not_supported__';
+        const runtime = {
+            ...makeRuntime(),
+            diagnostics: {
+                extensions: [
+                    { path: '/ext/my-ext.js', handlerCounts: { [unsupportedEvent]: 1 }, toolNames: [], commandNames: [], tiers: [] },
+                ],
+                usedTiers: [],
+                capabilityCount: 0,
+                vocabularySize: 0,
+            },
+        };
+        handleSessionStart({}, runtime, errOut);
+        const warnings = errOut.filter(l => l.includes('Warning'));
+        expect(warnings.length).toBeGreaterThan(0);
+        expect(warnings[0]).toContain(unsupportedEvent);
+        expect(warnings[0]).toContain('/ext/my-ext.js');
+    });
+    it('does not warn for events that ARE supported', () => {
+        const errOut = [];
+        const supportedEvent = [...ADAPTER_CAPABILITIES['claude-code']][0];
+        const runtime = {
+            ...makeRuntime(),
+            diagnostics: {
+                extensions: [
+                    { path: '/ext/my-ext.js', handlerCounts: { [supportedEvent]: 1 }, toolNames: [], commandNames: [], tiers: [] },
+                ],
+                usedTiers: [],
+                capabilityCount: 0,
+                vocabularySize: 0,
+            },
+        };
+        handleSessionStart({}, runtime, errOut);
+        const warnings = errOut.filter(l => l.includes('Warning'));
+        expect(warnings).toHaveLength(0);
+    });
+    it('logs boot message when no extensions are loaded', () => {
+        const errOut = [];
+        handleSessionStart({}, makeRuntime(), errOut);
+        expect(errOut.some(l => l.includes('Booted'))).toBe(true);
+        expect(errOut.filter(l => l.includes('extension')).length).toBe(0);
+    });
+});
+describe('ADAPTER_CAPABILITIES claude-code set', () => {
+    it('is a Set', () => {
+        expect(ADAPTER_CAPABILITIES['claude-code']).toBeInstanceOf(Set);
+    });
+    it('contains expected event names', () => {
+        const set = ADAPTER_CAPABILITIES['claude-code'];
+        expect(set.size).toBeGreaterThan(0);
+    });
+});

package/dist/hook.js

@@ -1,69 +1,174 @@
 #!/usr/bin/env node
 /**
  * dot-ai hook for Claude Code.
- * Receives hook event JSON on stdin, runs the enrich pipeline,
- * returns enriched context on stdout.
+ * Dispatches by event type via CLI arg.
  *
  * Usage in hooks.json:
- *   { "type": "command", "command": "node /path/to/hook.js" }
+ *   "SessionStart":     [{ "type": "command", "command": "node hook.js session-start" }]
+ *   "UserPromptSubmit": [{ "type": "command", "command": "node hook.js prompt-submit" }]
+ *   "PreCompact":       [{ "type": "command", "command": "node hook.js pre-compact" }]
+ *   "Stop":             [{ "type": "command", "command": "node hook.js stop" }]
+ *   "PreToolUse":       [{ "type": "command", "command": "node hook.js pre-tool-use" }]
  */
-import { loadConfig, registerDefaults, createProviders, boot, enrich, injectRoot, formatContext, NoopLogger, JsonFileLogger } from '@dot-ai/core';
-async function main() {
-    // Read event from stdin
+import { DotAiRuntime, NoopLogger, JsonFileLogger, loadConfig, ADAPTER_CAPABILITIES, } from '@dot-ai/core';
+// ── Shared ──
+async function readStdin() {
     const chunks = [];
     for await (const chunk of process.stdin) {
         chunks.push(chunk);
     }
+    return JSON.parse(Buffer.concat(chunks).toString('utf-8'));
+}
+async function createRuntime(workspaceRoot) {
+    const rawConfig = await loadConfig(workspaceRoot);
+    const logPath = process.env.DOT_AI_LOG ?? rawConfig.debug?.logPath;
+    const logger = logPath ? new JsonFileLogger(logPath) : new NoopLogger();
+    const runtime = new DotAiRuntime({
+        workspaceRoot,
+        logger,
+        skipIdentities: true,
+        maxSkillLength: 3000,
+        maxSkills: 5,
+    });
+    await runtime.boot();
+    return runtime;
+}
+// ── Event handlers ──
+const CLAUDE_SUPPORTED = ADAPTER_CAPABILITIES['claude-code'];
+async function handleSessionStart(event) {
+    const workspaceRoot = event.cwd ?? process.cwd();
+    const runtime = await createRuntime(workspaceRoot);
+    // Log diagnostics
+    const diag = runtime.diagnostics;
+    process.stderr.write(`[dot-ai] Booted\n`);
+    if (diag.extensions.length > 0) {
+        process.stderr.write(`[dot-ai] ${diag.extensions.length} extension(s), ${diag.capabilityCount} tool(s)\n`);
+        for (const ext of diag.extensions) {
+            for (const eventName of Object.keys(ext.handlerCounts)) {
+                if (!CLAUDE_SUPPORTED.has(eventName)) {
+                    process.stderr.write(`[dot-ai] Warning: Extension ${ext.path} uses '${eventName}' (not supported by Claude Code adapter)\n`);
+                }
+            }
+        }
+    }
+    return runtime;
+}
+async function handlePromptSubmit(event) {
+    const workspaceRoot = event.cwd ?? process.cwd();
+    const runtime = await createRuntime(workspaceRoot);
+    const prompt = (event.prompt ?? event.content ?? '');
+    if (!prompt)
+        return runtime;
+    const { formatted } = await runtime.processPrompt(prompt);
+    if (formatted) {
+        process.stdout.write(JSON.stringify({ result: formatted }));
+    }
+    return runtime;
+}
+async function handlePreCompact(event) {
+    const workspaceRoot = event.cwd ?? process.cwd();
+    const runtime = await createRuntime(workspaceRoot);
+    try {
+        const summary = (event.summary ?? event.content ?? '');
+        if (summary) {
+            await runtime.fire('agent_end', {
+                response: `[compaction] ${summary.slice(0, 1000)}`,
+            });
+        }
+    }
+    catch (err) {
+        process.stderr.write(`[dot-ai] pre-compact error: ${err}\n`);
+    }
+    return runtime;
+}
+async function handleStop(event) {
+    const workspaceRoot = event.cwd ?? process.cwd();
+    const runtime = await createRuntime(workspaceRoot);
+    try {
+        const response = (event.response ?? event.content ?? '');
+        if (response) {
+            await runtime.learn(response);
+        }
+    }
+    catch (err) {
+        process.stderr.write(`[dot-ai] stop error: ${err}\n`);
+    }
+    return runtime;
+}
+async function handlePreToolUse(event) {
+    const workspaceRoot = event.cwd ?? process.cwd();
+    const toolName = (event.tool_name ?? '');
+    const input = (event.tool_input ?? {});
+    // Boot runtime to check extension-based tool_call blocking
+    const runtime = await createRuntime(workspaceRoot);
+    // Fire tool_call to extensions first
+    const extensionResult = await runtime.fireToolCall({ tool: toolName, input });
+    if (extensionResult?.decision === 'block') {
+        process.stdout.write(JSON.stringify({
+            decision: 'block',
+            reason: extensionResult.reason ?? 'Blocked by extension',
+        }));
+        return runtime;
+    }
+    // Existing hardcoded memory file blocking (kept as fallback)
+    if (toolName === 'Write' || toolName === 'Edit') {
+        const filePath = (input.file_path ?? input.path ?? '');
+        if (filePath && /\.ai\/memory\/[^\s]*\.md$/i.test(filePath)) {
+            process.stdout.write(JSON.stringify({
+                decision: 'block',
+                reason: 'Memory is managed by dot-ai SQLite provider. Use the memory_store tool instead.',
+            }));
+            return runtime;
+        }
+    }
+    if (toolName === 'Bash') {
+        const command = (input.command ?? '');
+        if (/\.ai\/memory\/[^\s]*\.md/i.test(command) && /(?:>|tee|cp|mv|cat\s*<<|echo\s.*>)/i.test(command)) {
+            process.stdout.write(JSON.stringify({
+                decision: 'block',
+                reason: 'Memory is managed by dot-ai SQLite provider. Use the memory_store tool instead.',
+            }));
+        }
+    }
+    return runtime;
+}
+// ── Main dispatcher ──
+async function main() {
+    const eventType = process.argv[2] ?? 'prompt-submit';
     let event;
     try {
-        event = JSON.parse(Buffer.concat(chunks).toString('utf-8'));
+        event = await readStdin();
     }
     catch {
         process.stderr.write('[dot-ai] Failed to parse stdin JSON\n');
         return;
     }
-    // Find workspace root (try event data, then cwd)
-    const workspaceRoot = event.cwd ?? process.cwd();
+    let runtime;
     try {
-        // Run the pipeline
-        registerDefaults();
-        const rawConfig = await loadConfig(workspaceRoot);
-        // Inject workspaceRoot into all provider options
-        const config = injectRoot(rawConfig, workspaceRoot);
-        // Setup logger
-        const logPath = process.env.DOT_AI_LOG ?? rawConfig.debug?.logPath;
-        const logger = logPath ? new JsonFileLogger(logPath) : new NoopLogger();
-        const providers = await createProviders(config);
-        const cache = await boot(providers, logger);
-        // Extract prompt from the event
-        const prompt = (event.prompt ?? event.content ?? '');
-        if (!prompt) {
-            await logger.flush();
-            return;
-        }
-        // Enrich the prompt
-        const enriched = await enrich(prompt, providers, cache, logger);
-        // Load skill content for matched skills
-        for (const skill of enriched.skills) {
-            if (!skill.content && skill.name) {
-                skill.content = await providers.skills.load(skill.name) ?? undefined;
-            }
-        }
-        // Format and output (skip identities — already injected at SessionStart)
-        const formatted = formatContext(enriched, {
-            skipIdentities: true,
-            maxSkillLength: 3000,
-            maxSkills: 5,
-            logger,
-        });
-        if (formatted) {
-            process.stdout.write(JSON.stringify({ result: formatted }));
+        switch (eventType) {
+            case 'session-start':
+                runtime = await handleSessionStart(event);
+                break;
+            case 'prompt-submit':
+                runtime = await handlePromptSubmit(event);
+                break;
+            case 'pre-compact':
+                runtime = await handlePreCompact(event);
+                break;
+            case 'stop':
+                runtime = await handleStop(event);
+                break;
+            case 'pre-tool-use':
+                runtime = await handlePreToolUse(event);
+                break;
+            default: process.stderr.write(`[dot-ai] Unknown event type: ${eventType}\n`);
         }
-        await logger.flush();
     }
     catch (err) {
-        // Fail silently — don't block the agent
         process.stderr.write(`[dot-ai] Error: ${err}\n`);
     }
+    // Flush logger before process exit
+    if (runtime)
+        await runtime.flush();
 }
 main();

package/dist/mcp-server.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};