@dot-ai/core 0.5.2 → 0.7.0

package/src/__tests__/config.test.ts

@@ -2,7 +2,7 @@ import { describe, it, expect, beforeEach } from 'vitest';
 import { mkdtemp, writeFile, mkdir } from 'node:fs/promises';
 import { tmpdir } from 'node:os';
 import { join } from 'node:path';
-import { loadConfig, resolveConfig } from '../config.js';
+import { loadConfig } from '../config.js';
 
 let testDir: string;
 
@@ -17,150 +17,52 @@ describe('loadConfig', () => {
     expect(config).toEqual({});
   });
 
-  it('returns empty config when .ai directory has no dot-ai.yml', async () => {
+  it('returns empty config for nonexistent workspace', async () => {
     const config = await loadConfig('/nonexistent/path/to/workspace');
     expect(config).toEqual({});
   });
 
-  it('parses a simple memory section', async () => {
+  it('loads settings.json with extensions', async () => {
     await writeFile(
-      join(testDir, '.ai', 'dot-ai.yml'),
-      `memory:\n  use: @dot-ai/provider-file-memory\n`,
+      join(testDir, '.ai', 'settings.json'),
+      JSON.stringify({
+        extensions: ['.ai/extensions/custom.ts'],
+        packages: ['npm:@dot-ai/ext-memory@1.0.0'],
+      }),
       'utf-8',
     );
     const config = await loadConfig(testDir);
-    expect(config.memory).toEqual({ use: '@dot-ai/provider-file-memory' });
+    expect(config.extensions?.paths).toEqual(['.ai/extensions/custom.ts']);
+    expect(config.extensions?.packages).toEqual(['npm:@dot-ai/ext-memory@1.0.0']);
   });
 
-  it('parses multiple provider sections', async () => {
+  it('loads settings.json with debug section', async () => {
     await writeFile(
-      join(testDir, '.ai', 'dot-ai.yml'),
-      [
-        'memory:',
-        '  use: @dot-ai/provider-file-memory',
-        'skills:',
-        '  use: @dot-ai/provider-file-skills',
-        'routing:',
-        '  use: @dot-ai/provider-rules-routing',
-      ].join('\n'),
+      join(testDir, '.ai', 'settings.json'),
+      JSON.stringify({ debug: { logPath: '/tmp/log' } }),
       'utf-8',
     );
     const config = await loadConfig(testDir);
-    expect(config.memory?.use).toBe('@dot-ai/provider-file-memory');
-    expect(config.skills?.use).toBe('@dot-ai/provider-file-skills');
-    expect(config.routing?.use).toBe('@dot-ai/provider-rules-routing');
+    expect(config.debug?.logPath).toBe('/tmp/log');
   });
 
-  it('parses nested with block', async () => {
+  it('loads settings.json with workspace section', async () => {
     await writeFile(
-      join(testDir, '.ai', 'dot-ai.yml'),
-      [
-        'memory:',
-        '  use: @dot-ai/cockpit-memory',
-        '    url: http://localhost:3010',
-      ].join('\n'),
+      join(testDir, '.ai', 'settings.json'),
+      JSON.stringify({ workspace: { scanDirs: 'apps,libs' } }),
       'utf-8',
     );
     const config = await loadConfig(testDir);
-    expect(config.memory?.use).toBe('@dot-ai/cockpit-memory');
-    expect(config.memory?.with?.['url']).toBe('http://localhost:3010');
+    expect(config.workspace?.scanDirs).toBe('apps,libs');
   });
 
-  it('resolves ${ENV_VAR} references', async () => {
-    process.env['DOT_AI_TEST_URL'] = 'http://test-server:9999';
+  it('handles empty settings.json', async () => {
     await writeFile(
-      join(testDir, '.ai', 'dot-ai.yml'),
-      [
-        'memory:',
-        '  use: @dot-ai/cockpit-memory',
-        '    url: ${DOT_AI_TEST_URL}',
-      ].join('\n'),
+      join(testDir, '.ai', 'settings.json'),
+      '{}',
       'utf-8',
     );
     const config = await loadConfig(testDir);
-    expect(config.memory?.with?.['url']).toBe('http://test-server:9999');
-    delete process.env['DOT_AI_TEST_URL'];
-  });
-
-  it('replaces undefined ENV_VAR with empty string', async () => {
-    delete process.env['MISSING_ENV_VAR'];
-    await writeFile(
-      join(testDir, '.ai', 'dot-ai.yml'),
-      [
-        'memory:',
-        '  use: @dot-ai/provider-file-memory',
-        '    key: ${MISSING_ENV_VAR}',
-      ].join('\n'),
-      'utf-8',
-    );
-    const config = await loadConfig(testDir);
-    expect(config.memory?.with?.['key']).toBe('');
-  });
-
-  it('skips comment lines (# prefix)', async () => {
-    await writeFile(
-      join(testDir, '.ai', 'dot-ai.yml'),
-      [
-        '# This is a comment',
-        'memory:',
-        '  # nested comment',
-        '  use: @dot-ai/provider-file-memory',
-      ].join('\n'),
-      'utf-8',
-    );
-    const config = await loadConfig(testDir);
-    expect(config.memory?.use).toBe('@dot-ai/provider-file-memory');
-  });
-});
-
-describe('resolveConfig', () => {
-  it('fills all defaults for empty config', () => {
-    const resolved = resolveConfig({});
-    expect(resolved.memory.use).toBe('@dot-ai/provider-file-memory');
-    expect(resolved.skills.use).toBe('@dot-ai/provider-file-skills');
-    expect(resolved.identity.use).toBe('@dot-ai/provider-file-identity');
-    expect(resolved.routing.use).toBe('@dot-ai/provider-rules-routing');
-    expect(resolved.tasks.use).toBe('@dot-ai/provider-file-tasks');
-    expect(resolved.tools.use).toBe('@dot-ai/provider-file-tools');
-  });
-
-  it('preserves existing memory config', () => {
-    const resolved = resolveConfig({ memory: { use: '@dot-ai/cockpit-memory', with: { url: 'http://x' } } });
-    expect(resolved.memory.use).toBe('@dot-ai/cockpit-memory');
-    expect(resolved.memory.with?.['url']).toBe('http://x');
-  });
-
-  it('fills defaults only for missing providers', () => {
-    const resolved = resolveConfig({ memory: { use: '@dot-ai/cockpit-memory' } });
-    expect(resolved.memory.use).toBe('@dot-ai/cockpit-memory');
-    expect(resolved.skills.use).toBe('@dot-ai/provider-file-skills');
-    expect(resolved.routing.use).toBe('@dot-ai/provider-rules-routing');
-  });
-
-  it('returns a Required<DotAiConfig> with all keys present', () => {
-    const resolved = resolveConfig({});
-    const keys = ['memory', 'skills', 'identity', 'routing', 'tasks', 'tools'] as const;
-    for (const key of keys) {
-      expect(resolved[key]).toBeDefined();
-      expect(typeof resolved[key].use).toBe('string');
-    }
-  });
-
-  it('preserves all six provided providers', () => {
-    const full = {
-      memory: { use: 'mem' },
-      skills: { use: 'ski' },
-      identity: { use: 'idn' },
-      routing: { use: 'rte' },
-      tasks: { use: 'tsk' },
-      tools: { use: 'tls' },
-    };
-    const resolved = resolveConfig(full);
-    expect(resolved.memory.use).toBe('mem');
-    expect(resolved.skills.use).toBe('ski');
-    expect(resolved.identity.use).toBe('idn');
-    expect(resolved.routing.use).toBe('rte');
-    expect(resolved.tasks.use).toBe('tsk');
-    expect(resolved.tools.use).toBe('tls');
+    expect(config).toEqual({});
   });
 });

package/src/__tests__/extension-loader.test.ts

@@ -0,0 +1,84 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { mkdir, writeFile, rm } from 'node:fs/promises';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+import { discoverExtensions } from '../extension-loader.js';
+
+// Use temp directory for test fixtures
+const testDir = join(tmpdir(), 'dot-ai-ext-test-' + Date.now());
+
+beforeEach(async () => {
+  await mkdir(join(testDir, '.ai', 'extensions'), { recursive: true });
+});
+
+afterEach(async () => {
+  await rm(testDir, { recursive: true, force: true });
+});
+
+describe('discoverExtensions', () => {
+  it('discovers .ts files in .ai/extensions/', async () => {
+    await writeFile(join(testDir, '.ai', 'extensions', 'my-ext.ts'), 'export default function() {}');
+    const paths = await discoverExtensions(testDir);
+    expect(paths).toContainEqual(expect.stringContaining('my-ext.ts'));
+  });
+
+  it('discovers .js files in .ai/extensions/', async () => {
+    await writeFile(join(testDir, '.ai', 'extensions', 'my-ext.js'), 'export default function() {}');
+    const paths = await discoverExtensions(testDir);
+    expect(paths).toContainEqual(expect.stringContaining('my-ext.js'));
+  });
+
+  it('discovers subdirs with index.ts', async () => {
+    await mkdir(join(testDir, '.ai', 'extensions', 'subext'), { recursive: true });
+    await writeFile(join(testDir, '.ai', 'extensions', 'subext', 'index.ts'), 'export default function() {}');
+    const paths = await discoverExtensions(testDir);
+    expect(paths).toContainEqual(expect.stringContaining('subext/index.ts'));
+  });
+
+  it('discovers subdirs with index.js when no index.ts', async () => {
+    await mkdir(join(testDir, '.ai', 'extensions', 'jsext'), { recursive: true });
+    await writeFile(join(testDir, '.ai', 'extensions', 'jsext', 'index.js'), 'export default function() {}');
+    const paths = await discoverExtensions(testDir);
+    expect(paths).toContainEqual(expect.stringContaining('jsext/index.js'));
+  });
+
+  it('reads dot-ai field from package.json', async () => {
+    const extDir = join(testDir, '.ai', 'extensions', 'pkg-ext');
+    await mkdir(extDir, { recursive: true });
+    await writeFile(join(extDir, 'package.json'), JSON.stringify({
+      name: 'pkg-ext',
+      'dot-ai': { extensions: ['src/index.ts'] },
+    }));
+    await mkdir(join(extDir, 'src'), { recursive: true });
+    await writeFile(join(extDir, 'src', 'index.ts'), 'export default function() {}');
+    const paths = await discoverExtensions(testDir);
+    expect(paths).toContainEqual(expect.stringContaining('src/index.ts'));
+  });
+
+  it('deduplicates paths', async () => {
+    await writeFile(join(testDir, '.ai', 'extensions', 'dedup.ts'), 'export default function() {}');
+    const paths = await discoverExtensions(testDir);
+    const matching = paths.filter(p => p.includes('dedup.ts'));
+    expect(matching).toHaveLength(1);
+  });
+
+  it('returns empty array when directory does not exist', async () => {
+    const paths = await discoverExtensions('/nonexistent/path');
+    expect(paths).toEqual([]);
+  });
+
+  it('discovers from config.paths', async () => {
+    const customDir = join(testDir, 'custom-extensions');
+    await mkdir(customDir, { recursive: true });
+    await writeFile(join(customDir, 'custom.ts'), 'export default function() {}');
+    const paths = await discoverExtensions(testDir, { paths: ['custom-extensions'] });
+    expect(paths).toContainEqual(expect.stringContaining('custom.ts'));
+  });
+
+  it('ignores non .ts/.js files', async () => {
+    await writeFile(join(testDir, '.ai', 'extensions', 'readme.md'), '# Readme');
+    await writeFile(join(testDir, '.ai', 'extensions', 'data.json'), '{}');
+    const paths = await discoverExtensions(testDir);
+    expect(paths).toHaveLength(0);
+  });
+});

package/src/__tests__/extension-runner.test.ts

@@ -0,0 +1,228 @@
+import { describe, it, expect, vi } from 'vitest';
+import { ExtensionRunner, EventBus } from '../extension-runner.js';
+import type { LoadedExtension } from '../extension-types.js';
+
+function createMockExtension(overrides?: Partial<LoadedExtension>): LoadedExtension {
+  return {
+    path: '/mock/ext.ts',
+    handlers: new Map(),
+    tools: new Map(),
+    tiers: new Set(),
+    ...overrides,
+  };
+}
+
+describe('ExtensionRunner', () => {
+  describe('fire', () => {
+    it('fires events to registered handlers', async () => {
+      const handler = vi.fn().mockResolvedValue({ inject: 'hello' });
+      const ext = createMockExtension({
+        handlers: new Map([['context_inject', [handler]]]),
+      });
+      const runner = new ExtensionRunner([ext]);
+      const results = await runner.fire('context_inject', { prompt: 'test', labels: [] });
+      expect(handler).toHaveBeenCalledWith({ prompt: 'test', labels: [] }, undefined);
+      expect(results).toEqual([{ inject: 'hello' }]);
+    });
+
+    it('collects results from multiple extensions', async () => {
+      const ext1 = createMockExtension({
+        handlers: new Map([['context_inject', [vi.fn().mockResolvedValue({ inject: 'a' })]]]),
+      });
+      const ext2 = createMockExtension({
+        handlers: new Map([['context_inject', [vi.fn().mockResolvedValue({ inject: 'b' })]]]),
+      });
+      const runner = new ExtensionRunner([ext1, ext2]);
+      const results = await runner.fire('context_inject', {});
+      expect(results).toEqual([{ inject: 'a' }, { inject: 'b' }]);
+    });
+
+    it('skips void results', async () => {
+      const handler = vi.fn().mockResolvedValue(undefined);
+      const ext = createMockExtension({
+        handlers: new Map([['agent_end', [handler]]]),
+      });
+      const runner = new ExtensionRunner([ext]);
+      const results = await runner.fire('agent_end', { response: 'done' });
+      expect(results).toEqual([]);
+    });
+
+    it('handles errors in handlers (log and continue)', async () => {
+      const goodHandler = vi.fn().mockResolvedValue({ inject: 'ok' });
+      const badHandler = vi.fn().mockRejectedValue(new Error('boom'));
+      const ext = createMockExtension({
+        handlers: new Map([['context_inject', [badHandler, goodHandler]]]),
+      });
+      const runner = new ExtensionRunner([ext]);
+      const results = await runner.fire('context_inject', {});
+      expect(results).toEqual([{ inject: 'ok' }]);
+    });
+
+    it('passes ctx as second argument to handlers', async () => {
+      const handler = vi.fn().mockResolvedValue({ inject: 'with-ctx' });
+      const ext = createMockExtension({
+        handlers: new Map([['context_inject', [handler]]]),
+      });
+      const runner = new ExtensionRunner([ext]);
+      const ctx = { workspaceRoot: '/test', events: { on: vi.fn(), emit: vi.fn() } };
+      await runner.fire('context_inject', { prompt: 'test', labels: [] }, ctx);
+      expect(handler).toHaveBeenCalledWith({ prompt: 'test', labels: [] }, ctx);
+    });
+
+    it('returns empty array for events with no handlers', async () => {
+      const ext = createMockExtension();
+      const runner = new ExtensionRunner([ext]);
+      const results = await runner.fire('nonexistent', {});
+      expect(results).toEqual([]);
+    });
+  });
+
+  describe('fireUntilBlocked', () => {
+    it('stops at first block', async () => {
+      const blockHandler = vi.fn().mockResolvedValue({ decision: 'block', reason: 'not allowed' });
+      const neverCalled = vi.fn().mockResolvedValue({ decision: 'allow' });
+      const ext1 = createMockExtension({
+        handlers: new Map([['tool_call', [blockHandler]]]),
+      });
+      const ext2 = createMockExtension({
+        handlers: new Map([['tool_call', [neverCalled]]]),
+      });
+      const runner = new ExtensionRunner([ext1, ext2]);
+      const result = await runner.fireUntilBlocked('tool_call', { tool: 'Write', input: {} });
+      expect(result).toEqual({ decision: 'block', reason: 'not allowed' });
+      expect(neverCalled).not.toHaveBeenCalled();
+    });
+
+    it('returns null when all allow', async () => {
+      const allowHandler = vi.fn().mockResolvedValue({ decision: 'allow' });
+      const ext = createMockExtension({
+        handlers: new Map([['tool_call', [allowHandler]]]),
+      });
+      const runner = new ExtensionRunner([ext]);
+      const result = await runner.fireUntilBlocked('tool_call', { tool: 'Read', input: {} });
+      expect(result).toBeNull();
+    });
+
+    it('returns null when no handlers', async () => {
+      const runner = new ExtensionRunner([createMockExtension()]);
+      const result = await runner.fireUntilBlocked('tool_call', { tool: 'Read', input: {} });
+      expect(result).toBeNull();
+    });
+
+    it('handles errors in handlers', async () => {
+      const badHandler = vi.fn().mockRejectedValue(new Error('boom'));
+      const ext = createMockExtension({
+        handlers: new Map([['tool_call', [badHandler]]]),
+      });
+      const runner = new ExtensionRunner([ext]);
+      const result = await runner.fireUntilBlocked('tool_call', { tool: 'Read', input: {} });
+      expect(result).toBeNull();
+    });
+
+    it('passes ctx to tool_call handlers', async () => {
+      const handler = vi.fn().mockResolvedValue({ decision: 'allow' });
+      const ext = createMockExtension({
+        handlers: new Map([['tool_call', [handler]]]),
+      });
+      const runner = new ExtensionRunner([ext]);
+      const ctx = { workspaceRoot: '/test', events: { on: vi.fn(), emit: vi.fn() } };
+      await runner.fireUntilBlocked('tool_call', { tool: 'Read', input: {} }, ctx);
+      expect(handler).toHaveBeenCalledWith({ tool: 'Read', input: {} }, ctx);
+    });
+  });
+
+  describe('tools', () => {
+    it('merges tools across extensions', () => {
+      const tool1 = { name: 'tool_a', description: 'A', parameters: {}, execute: vi.fn() };
+      const tool2 = { name: 'tool_b', description: 'B', parameters: {}, execute: vi.fn() };
+      const ext1 = createMockExtension({ tools: new Map([['tool_a', tool1]]) });
+      const ext2 = createMockExtension({ tools: new Map([['tool_b', tool2]]) });
+      const runner = new ExtensionRunner([ext1, ext2]);
+      expect(runner.tools).toHaveLength(2);
+      expect(runner.tools.map(t => t.name)).toEqual(['tool_a', 'tool_b']);
+    });
+
+    it('last-wins for duplicate tool names (override)', () => {
+      const tool1 = { name: 'dup', description: 'A', parameters: {}, execute: vi.fn() };
+      const tool2 = { name: 'dup', description: 'B', parameters: {}, execute: vi.fn() };
+      const ext1 = createMockExtension({ tools: new Map([['dup', tool1]]) });
+      const ext2 = createMockExtension({ tools: new Map([['dup', tool2]]) });
+      const logger = { log: vi.fn(), flush: vi.fn().mockResolvedValue(undefined) };
+      const runner = new ExtensionRunner([ext1, ext2], logger);
+      const tools = runner.tools;
+      expect(tools).toHaveLength(1);
+      expect(tools[0].description).toBe('B'); // last wins
+      expect(logger.log).toHaveBeenCalledWith(
+        expect.objectContaining({ event: 'tool_override' }),
+      );
+    });
+  });
+
+  describe('diagnostics', () => {
+    it('reports correct counts and tiers', () => {
+      const ext = createMockExtension({
+        path: '/ext/test.ts',
+        handlers: new Map([
+          ['context_inject', [vi.fn(), vi.fn()]],
+          ['tool_call', [vi.fn()]],
+        ]),
+        tools: new Map([['my_tool', { name: 'my_tool', description: '', parameters: {}, execute: vi.fn() }]]),
+        tiers: new Set(['universal'] as const),
+      });
+      const runner = new ExtensionRunner([ext]);
+      const diag = runner.diagnostics;
+      expect(diag).toHaveLength(1);
+      expect(diag[0].path).toBe('/ext/test.ts');
+      expect(diag[0].handlerCounts).toEqual({ context_inject: 2, tool_call: 1 });
+      expect(diag[0].toolNames).toEqual(['my_tool']);
+      expect(diag[0].tiers).toEqual(['universal']);
+    });
+  });
+
+  describe('usedTiers', () => {
+    it('aggregates tiers from all extensions', () => {
+      const ext1 = createMockExtension({ tiers: new Set(['universal'] as const) });
+      const ext2 = createMockExtension({ tiers: new Set(['rich'] as const) });
+      const runner = new ExtensionRunner([ext1, ext2]);
+      expect(runner.usedTiers).toEqual(new Set(['universal', 'rich']));
+    });
+  });
+});
+
+describe('EventBus', () => {
+  it('calls registered handlers', () => {
+    const bus = new EventBus();
+    const handler = vi.fn();
+    bus.on('test', handler);
+    bus.emit('test', 'arg1', 'arg2');
+    expect(handler).toHaveBeenCalledWith('arg1', 'arg2');
+  });
+
+  it('handles errors in handlers silently', () => {
+    const bus = new EventBus();
+    bus.on('test', () => { throw new Error('boom'); });
+    const good = vi.fn();
+    bus.on('test', good);
+    bus.emit('test');
+    expect(good).toHaveBeenCalled();
+  });
+
+  it('does nothing for events with no listeners', () => {
+    const bus = new EventBus();
+    expect(() => bus.emit('nonexistent')).not.toThrow();
+  });
+
+  it('removes handler with off()', () => {
+    const bus = new EventBus();
+    const handler = vi.fn();
+    bus.on('test', handler);
+    bus.off('test', handler);
+    bus.emit('test');
+    expect(handler).not.toHaveBeenCalled();
+  });
+
+  it('off() does nothing for non-existent event', () => {
+    const bus = new EventBus();
+    expect(() => bus.off('nope', vi.fn())).not.toThrow();
+  });
+});

package/src/__tests__/fixtures/extensions/ctx-aware.js

@@ -0,0 +1,26 @@
+/** Extension that uses ctx to access providers and workspace at event time */
+export default function(api) {
+  api.on('tool_call', async (event, ctx) => {
+    // Use ctx.providers to check memory before allowing writes
+    if (event.tool === 'Write' && ctx?.providers?.memory) {
+      const memories = await ctx.providers.memory.search('blocked-files');
+      if (memories.some(m => m.content.includes(event.input.file_path))) {
+        return { decision: 'block', reason: `Blocked by memory policy: ${event.input.file_path}` };
+      }
+    }
+  });
+
+  api.on('context_inject', async (event, ctx) => {
+    // Use ctx.workspaceRoot in injected context
+    if (ctx?.workspaceRoot) {
+      return { inject: `Workspace: ${ctx.workspaceRoot}` };
+    }
+  });
+
+  api.on('session_start', async (_event, ctx) => {
+    // Use ctx.events to announce session start
+    if (ctx?.events) {
+      ctx.events.emit('extension:ctx-aware:started', { workspace: ctx.workspaceRoot });
+    }
+  });
+}

package/src/__tests__/fixtures/extensions/security-gate.js

@@ -0,0 +1,20 @@
+/** Security gate extension — blocks writes to sensitive files */
+export default function(api) {
+  api.on('tool_call', async (event) => {
+    const sensitivePatterns = [/\.env$/i, /\.key$/i, /\.pem$/i];
+
+    if (event.tool === 'Write' || event.tool === 'Edit') {
+      const filePath = event.input.file_path ?? event.input.path ?? '';
+      if (typeof filePath === 'string' && sensitivePatterns.some(p => p.test(filePath))) {
+        return { decision: 'block', reason: `Blocked: writing to sensitive file ${filePath}` };
+      }
+    }
+
+    if (event.tool === 'Bash') {
+      const cmd = event.input.command ?? '';
+      if (typeof cmd === 'string' && /rm\s+-rf\s+\//.test(cmd)) {
+        return { decision: 'block', reason: 'Blocked: dangerous rm -rf / command' };
+      }
+    }
+  });
+}

package/src/__tests__/fixtures/extensions/session-analytics.js

@@ -0,0 +1,28 @@
+/** Session analytics extension — tracks tool usage stats */
+export default function(api) {
+  const stats = { toolCalls: 0, toolsUsed: new Map() };
+
+  api.on('tool_call', async (event) => {
+    stats.toolCalls++;
+    stats.toolsUsed.set(event.tool, (stats.toolsUsed.get(event.tool) ?? 0) + 1);
+  });
+
+  api.on('agent_end', async () => {
+    // In a real extension, this would log to a file or API
+    // For testing, we just track the stats
+  });
+
+  // Register a tool to query analytics
+  api.registerTool({
+    name: 'session_stats',
+    description: 'Get session analytics (tool call counts)',
+    parameters: { type: 'object', properties: {}, required: [] },
+    async execute() {
+      const topTools = Array.from(stats.toolsUsed.entries())
+        .sort((a, b) => b[1] - a[1])
+        .map(([name, count]) => `${name}: ${count}`)
+        .join(', ');
+      return { content: `Total calls: ${stats.toolCalls}. Tools: ${topTools || 'none'}` };
+    },
+  });
+}

package/src/__tests__/fixtures/extensions/smart-context.js

@@ -0,0 +1,10 @@
+/** Smart context extension — injects extra context via context_inject */
+export default function(api) {
+  api.on('context_inject', async (event) => {
+    // Simple keyword-based context injection
+    const keywords = event.labels?.map(l => l.name) ?? [];
+    if (keywords.includes('memory')) {
+      return { inject: '> Note: This workspace uses dot-ai memory system. Use memory_recall/memory_store tools.' };
+    }
+  });
+}