@dot-ai/core 0.8.0 → 0.10.0

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

@@ -7,7 +7,10 @@ function createMockExtension(overrides?: Partial<LoadedExtension>): LoadedExtens
     path: '/mock/ext.ts',
     handlers: new Map(),
     tools: new Map(),
-    tiers: new Set(),
+    commands: new Map(),
+    skills: new Map(),
+    identities: new Map(),
+    labels: new Set(),
     ...overrides,
   };
 }
@@ -15,26 +18,26 @@ function createMockExtension(overrides?: Partial<LoadedExtension>): LoadedExtens
 describe('ExtensionRunner', () => {
   describe('fire', () => {
     it('fires events to registered handlers', async () => {
-      const handler = vi.fn().mockResolvedValue({ inject: 'hello' });
+      const handler = vi.fn().mockResolvedValue({ data: 'hello' });
       const ext = createMockExtension({
-        handlers: new Map([['context_inject', [handler]]]),
+        handlers: new Map([['agent_end', [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' }]);
+      const results = await runner.fire('agent_end', { response: 'test' });
+      expect(handler).toHaveBeenCalledWith({ response: 'test' }, undefined);
+      expect(results).toEqual([{ data: 'hello' }]);
     });
 
     it('collects results from multiple extensions', async () => {
       const ext1 = createMockExtension({
-        handlers: new Map([['context_inject', [vi.fn().mockResolvedValue({ inject: 'a' })]]]),
+        handlers: new Map([['agent_end', [vi.fn().mockResolvedValue({ data: 'a' })]]]),
       });
       const ext2 = createMockExtension({
-        handlers: new Map([['context_inject', [vi.fn().mockResolvedValue({ inject: 'b' })]]]),
+        handlers: new Map([['agent_end', [vi.fn().mockResolvedValue({ data: 'b' })]]]),
       });
       const runner = new ExtensionRunner([ext1, ext2]);
-      const results = await runner.fire('context_inject', {});
-      expect(results).toEqual([{ inject: 'a' }, { inject: 'b' }]);
+      const results = await runner.fire('agent_end', {});
+      expect(results).toEqual([{ data: 'a' }, { data: 'b' }]);
     });
 
     it('skips void results', async () => {
@@ -48,25 +51,25 @@ describe('ExtensionRunner', () => {
     });
 
     it('handles errors in handlers (log and continue)', async () => {
-      const goodHandler = vi.fn().mockResolvedValue({ inject: 'ok' });
+      const goodHandler = vi.fn().mockResolvedValue({ data: 'ok' });
       const badHandler = vi.fn().mockRejectedValue(new Error('boom'));
       const ext = createMockExtension({
-        handlers: new Map([['context_inject', [badHandler, goodHandler]]]),
+        handlers: new Map([['agent_end', [badHandler, goodHandler]]]),
       });
       const runner = new ExtensionRunner([ext]);
-      const results = await runner.fire('context_inject', {});
-      expect(results).toEqual([{ inject: 'ok' }]);
+      const results = await runner.fire('agent_end', {});
+      expect(results).toEqual([{ data: 'ok' }]);
     });
 
     it('passes ctx as second argument to handlers', async () => {
-      const handler = vi.fn().mockResolvedValue({ inject: 'with-ctx' });
+      const handler = vi.fn().mockResolvedValue({ data: 'with-ctx' });
       const ext = createMockExtension({
-        handlers: new Map([['context_inject', [handler]]]),
+        handlers: new Map([['agent_end', [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);
+      await runner.fire('agent_end', { response: 'test' }, ctx);
+      expect(handler).toHaveBeenCalledWith({ response: 'test' }, ctx);
     });
 
     it('returns empty array for events with no handlers', async () => {
@@ -158,33 +161,243 @@ describe('ExtensionRunner', () => {
     });
   });
 
+  describe('skills', () => {
+    it('merges skills across extensions', () => {
+      const skill1 = { name: 'deploy', description: 'Deploy', labels: ['deploy'], content: '...' };
+      const skill2 = { name: 'security', description: 'Security', labels: ['security'], content: '...' };
+      const ext1 = createMockExtension({ skills: new Map([['deploy', skill1]]) });
+      const ext2 = createMockExtension({ skills: new Map([['security', skill2]]) });
+      const runner = new ExtensionRunner([ext1, ext2]);
+      expect(runner.skills).toHaveLength(2);
+      expect(runner.skills.map(s => s.name)).toEqual(['deploy', 'security']);
+    });
+  });
+
+  describe('identities', () => {
+    it('merges identities across extensions', () => {
+      const id1 = { type: 'agents', content: '# AGENTS', source: 'ext-file-identity', priority: 100 };
+      const ext1 = createMockExtension({ identities: new Map([['agents:root', id1]]) });
+      const runner = new ExtensionRunner([ext1]);
+      expect(runner.identities).toHaveLength(1);
+      expect(runner.identities[0].type).toBe('agents');
+    });
+  });
+
+  describe('vocabularyLabels', () => {
+    it('collects labels from all extensions', () => {
+      const ext1 = createMockExtension({ labels: new Set(['deploy', 'security']) });
+      const ext2 = createMockExtension({ labels: new Set(['question', 'deploy']) });
+      const runner = new ExtensionRunner([ext1, ext2]);
+      const labels = runner.vocabularyLabels;
+      expect(labels).toContain('deploy');
+      expect(labels).toContain('security');
+      expect(labels).toContain('question');
+      // No duplicates
+      expect(labels.filter(l => l === 'deploy')).toHaveLength(1);
+    });
+  });
+
+  describe('fireCollectSections', () => {
+    it('collects sections from multiple handlers', async () => {
+      const handler1 = vi.fn().mockResolvedValue({
+        sections: [{ id: 'sec-a', content: 'A' }],
+      });
+      const handler2 = vi.fn().mockResolvedValue({
+        sections: [{ id: 'sec-b', content: 'B' }],
+      });
+      const ext1 = createMockExtension({ handlers: new Map([['context_enrich', [handler1]]]) });
+      const ext2 = createMockExtension({ handlers: new Map([['context_enrich', [handler2]]]) });
+      const runner = new ExtensionRunner([ext1, ext2]);
+      const result = await runner.fireCollectSections('context_enrich');
+      expect(result.sections).toHaveLength(2);
+      const ids = result.sections.map((s: { id?: string }) => s.id);
+      expect(ids).toContain('sec-a');
+      expect(ids).toContain('sec-b');
+    });
+
+    it('deduplicates sections by id (last-wins)', async () => {
+      const handler1 = vi.fn().mockResolvedValue({
+        sections: [{ id: 'shared', content: 'first' }],
+      });
+      const handler2 = vi.fn().mockResolvedValue({
+        sections: [{ id: 'shared', content: 'last' }],
+      });
+      const ext1 = createMockExtension({ handlers: new Map([['context_enrich', [handler1]]]) });
+      const ext2 = createMockExtension({ handlers: new Map([['context_enrich', [handler2]]]) });
+      const runner = new ExtensionRunner([ext1, ext2]);
+      const result = await runner.fireCollectSections('context_enrich');
+      expect(result.sections).toHaveLength(1);
+      expect(result.sections[0].content).toBe('last');
+    });
+
+    it('keeps anonymous sections (no id)', async () => {
+      const handler1 = vi.fn().mockResolvedValue({
+        sections: [{ content: 'anon-1' }],
+      });
+      const handler2 = vi.fn().mockResolvedValue({
+        sections: [{ content: 'anon-2' }],
+      });
+      const ext1 = createMockExtension({ handlers: new Map([['context_enrich', [handler1]]]) });
+      const ext2 = createMockExtension({ handlers: new Map([['context_enrich', [handler2]]]) });
+      const runner = new ExtensionRunner([ext1, ext2]);
+      const result = await runner.fireCollectSections('context_enrich');
+      expect(result.sections).toHaveLength(2);
+      const contents = result.sections.map((s: { content: string }) => s.content);
+      expect(contents).toContain('anon-1');
+      expect(contents).toContain('anon-2');
+    });
+
+    it('concatenates systemPrompt strings', async () => {
+      const handler1 = vi.fn().mockResolvedValue({ systemPrompt: 'You are helpful.' });
+      const handler2 = vi.fn().mockResolvedValue({ systemPrompt: 'Be concise.' });
+      const ext1 = createMockExtension({ handlers: new Map([['context_enrich', [handler1]]]) });
+      const ext2 = createMockExtension({ handlers: new Map([['context_enrich', [handler2]]]) });
+      const runner = new ExtensionRunner([ext1, ext2]);
+      const result = await runner.fireCollectSections('context_enrich');
+      expect(result.systemPrompt).toBe('You are helpful.\nBe concise.');
+    });
+
+    it('returns empty sections array and empty systemPrompt when no handlers', async () => {
+      const runner = new ExtensionRunner([createMockExtension()]);
+      const result = await runner.fireCollectSections('context_enrich');
+      expect(result.sections).toEqual([]);
+      expect(result.systemPrompt).toBe('');
+    });
+
+    it('handles handler errors gracefully', async () => {
+      const badHandler = vi.fn().mockRejectedValue(new Error('boom'));
+      const goodHandler = vi.fn().mockResolvedValue({
+        sections: [{ id: 'ok', content: 'good' }],
+      });
+      const ext = createMockExtension({
+        handlers: new Map([['context_enrich', [badHandler, goodHandler]]]),
+      });
+      const runner = new ExtensionRunner([ext]);
+      const result = await runner.fireCollectSections('context_enrich');
+      expect(result.sections).toHaveLength(1);
+      expect(result.sections[0].id).toBe('ok');
+    });
+  });
+
+  describe('fireFirstResult', () => {
+    it('returns first non-null result', async () => {
+      const handler = vi.fn().mockResolvedValue({ route: 'chat' });
+      const ext = createMockExtension({ handlers: new Map([['route', [handler]]]) });
+      const runner = new ExtensionRunner([ext]);
+      const result = await runner.fireFirstResult('route', { message: 'hi' });
+      expect(result).toEqual({ route: 'chat' });
+    });
+
+    it('stops after first result (second handler not called)', async () => {
+      const handler1 = vi.fn().mockResolvedValue({ route: 'first' });
+      const handler2 = vi.fn().mockResolvedValue({ route: 'second' });
+      const ext1 = createMockExtension({ handlers: new Map([['route', [handler1]]]) });
+      const ext2 = createMockExtension({ handlers: new Map([['route', [handler2]]]) });
+      const runner = new ExtensionRunner([ext1, ext2]);
+      const result = await runner.fireFirstResult('route', {});
+      expect(result).toEqual({ route: 'first' });
+      expect(handler2).not.toHaveBeenCalled();
+    });
+
+    it('returns null when no handler returns a value', async () => {
+      const handler = vi.fn().mockResolvedValue(undefined);
+      const ext = createMockExtension({ handlers: new Map([['route', [handler]]]) });
+      const runner = new ExtensionRunner([ext]);
+      const result = await runner.fireFirstResult('route', {});
+      expect(result).toBeNull();
+    });
+
+    it('skips null/undefined results and returns next non-null', async () => {
+      const handler1 = vi.fn().mockResolvedValue(null);
+      const handler2 = vi.fn().mockResolvedValue(undefined);
+      const handler3 = vi.fn().mockResolvedValue({ route: 'found' });
+      const ext = createMockExtension({
+        handlers: new Map([['route', [handler1, handler2, handler3]]]),
+      });
+      const runner = new ExtensionRunner([ext]);
+      const result = await runner.fireFirstResult('route', {});
+      expect(result).toEqual({ route: 'found' });
+    });
+  });
+
+  describe('fireChainTransform', () => {
+    it('chains transform through handlers', async () => {
+      const handler1 = vi.fn().mockImplementation(async (data: { value: number }) => ({
+        value: data.value + 1,
+      }));
+      const handler2 = vi.fn().mockImplementation(async (data: { value: number }) => ({
+        value: data.value * 2,
+      }));
+      const ext = createMockExtension({
+        handlers: new Map([['label_extract', [handler1, handler2]]]),
+      });
+      const runner = new ExtensionRunner([ext]);
+      const result = await runner.fireChainTransform('label_extract', { value: 3 });
+      // (3 + 1) * 2 = 8
+      expect(result).toEqual({ value: 8 });
+    });
+
+    it('keeps previous value when handler returns undefined', async () => {
+      const handler1 = vi.fn().mockResolvedValue({ value: 42 });
+      const handler2 = vi.fn().mockResolvedValue(undefined);
+      const ext = createMockExtension({
+        handlers: new Map([['label_extract', [handler1, handler2]]]),
+      });
+      const runner = new ExtensionRunner([ext]);
+      const result = await runner.fireChainTransform('label_extract', { value: 0 });
+      expect(result).toEqual({ value: 42 });
+    });
+
+    it('short-circuits on input event with consumed: true', async () => {
+      const handler1 = vi.fn().mockResolvedValue({ text: 'consumed', consumed: true });
+      const handler2 = vi.fn().mockResolvedValue({ text: 'never' });
+      const ext = createMockExtension({
+        handlers: new Map([['input', [handler1, handler2]]]),
+      });
+      const runner = new ExtensionRunner([ext]);
+      const result = await runner.fireChainTransform('input', { text: 'original' });
+      expect(result).toEqual({ text: 'consumed', consumed: true });
+      expect(handler2).not.toHaveBeenCalled();
+    });
+
+    it('handles single handler', async () => {
+      const handler = vi.fn().mockResolvedValue({ label: 'question' });
+      const ext = createMockExtension({
+        handlers: new Map([['label_extract', [handler]]]),
+      });
+      const runner = new ExtensionRunner([ext]);
+      const result = await runner.fireChainTransform('label_extract', { label: 'unknown' });
+      expect(result).toEqual({ label: 'question' });
+    });
+
+    it('returns initial data when no handlers', async () => {
+      const runner = new ExtensionRunner([createMockExtension()]);
+      const initial = { value: 99 };
+      const result = await runner.fireChainTransform('label_extract', initial);
+      expect(result).toEqual({ value: 99 });
+    });
+  });
+
   describe('diagnostics', () => {
-    it('reports correct counts and tiers', () => {
+    it('reports correct counts', () => {
       const ext = createMockExtension({
         path: '/ext/test.ts',
         handlers: new Map([
-          ['context_inject', [vi.fn(), vi.fn()]],
+          ['context_enrich', [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),
+        skills: new Map([['deploy', { name: 'deploy', description: '', labels: [] }]]),
+        identities: new Map([['agents:root', { type: 'agents', content: '', source: '', priority: 100 }]]),
       });
       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].handlerCounts).toEqual({ context_enrich: 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']));
+      expect(diag[0].skillNames).toEqual(['deploy']);
+      expect(diag[0].identityNames).toEqual(['agents:root']);
     });
   });
 });

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

@@ -10,10 +10,19 @@ export default function(api) {
     }
   });
 
-  api.on('context_inject', async (event, ctx) => {
-    // Use ctx.workspaceRoot in injected context
+  api.on('context_enrich', async (_event, ctx) => {
+    // Use ctx.workspaceRoot in enriched context
     if (ctx?.workspaceRoot) {
-      return { inject: `Workspace: ${ctx.workspaceRoot}` };
+      return {
+        sections: [{
+          id: 'ctx-aware:workspace',
+          title: 'Workspace',
+          content: `Workspace: ${ctx.workspaceRoot}`,
+          priority: 30,
+          source: 'ctx-aware',
+          trimStrategy: 'drop',
+        }],
+      };
     }
   });
 

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

@@ -1,10 +1,19 @@
-/** Smart context extension — injects extra context via context_inject */
+/** Smart context extension — enriches context via context_enrich */
 export default function(api) {
-  api.on('context_inject', async (event) => {
+  api.on('context_enrich', 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.' };
+      return {
+        sections: [{
+          id: 'smart-context:memory',
+          title: 'Memory',
+          content: '> Note: This workspace uses dot-ai memory system. Use memory_recall/memory_store tools.',
+          priority: 50,
+          source: 'smart-context',
+          trimStrategy: 'drop',
+        }],
+      };
     }
   });
 }

package/src/__tests__/format.test.ts

@@ -1,7 +1,8 @@
 import { describe, it, expect, vi } from 'vitest';
-import { formatContext, formatToolHints } from '../format.js';
+import { formatContext, formatToolHints, formatSections, assembleSections, trimSections } from '../format.js';
 import type { EnrichedContext, Identity, MemoryEntry, Skill, Tool } from '../types.js';
 import type { Capability } from '../capabilities.js';
+import type { Section } from '../extension-types.js';
 
 function makeContext(overrides?: Partial<EnrichedContext>): EnrichedContext {
   return {
@@ -429,6 +430,182 @@ describe('formatToolHints', () => {
   });
 });
 
+function makeSection(overrides?: Partial<Section>): Section {
+  return {
+    id: 'test:section',
+    title: 'Test',
+    content: 'test content',
+    priority: 50,
+    source: 'test',
+    ...overrides,
+  };
+}
+
+describe('assembleSections', () => {
+  it('returns empty string for empty array', () => {
+    expect(assembleSections([])).toBe('');
+  });
+
+  it('formats single section with title as ## Title\\n\\ncontent', () => {
+    const section = makeSection({ title: 'My Title', content: 'my content' });
+    const result = assembleSections([section]);
+    expect(result).toBe('## My Title\n\nmy content');
+  });
+
+  it('joins multiple sections with \\n\\n---\\n\\n', () => {
+    const sections = [
+      makeSection({ title: 'First', content: 'first content' }),
+      makeSection({ title: 'Second', content: 'second content' }),
+    ];
+    const result = assembleSections(sections);
+    expect(result).toBe('## First\n\nfirst content\n\n---\n\n## Second\n\nsecond content');
+  });
+
+  it('handles sections without title (just content)', () => {
+    const section = makeSection({ title: '', content: 'bare content' });
+    const result = assembleSections([section]);
+    expect(result).toBe('bare content');
+  });
+
+  it('mixes titled and untitled sections', () => {
+    const sections = [
+      makeSection({ title: 'With Title', content: 'titled content' }),
+      makeSection({ title: '', content: 'untitled content' }),
+    ];
+    const result = assembleSections(sections);
+    expect(result).toBe('## With Title\n\ntitled content\n\n---\n\nuntitled content');
+  });
+});
+
+describe('formatSections', () => {
+  it('sorts sections by priority DESC', () => {
+    const sections = [
+      makeSection({ id: 'low', title: 'Low', content: 'low priority', priority: 10 }),
+      makeSection({ id: 'high', title: 'High', content: 'high priority', priority: 100 }),
+      makeSection({ id: 'mid', title: 'Mid', content: 'mid priority', priority: 50 }),
+    ];
+    const result = formatSections(sections);
+    const highPos = result.indexOf('high priority');
+    const midPos = result.indexOf('mid priority');
+    const lowPos = result.indexOf('low priority');
+    expect(highPos).toBeLessThan(midPos);
+    expect(midPos).toBeLessThan(lowPos);
+  });
+
+  it('returns assembleSections output (no trimming when no budget)', () => {
+    const sections = [
+      makeSection({ title: 'A', content: 'content a', priority: 10 }),
+      makeSection({ title: 'B', content: 'content b', priority: 20 }),
+    ];
+    // formatSections sorts by priority DESC, so B first
+    const result = formatSections(sections);
+    expect(result).toBe('## B\n\ncontent b\n\n---\n\n## A\n\ncontent a');
+  });
+
+  it('applies trimming when tokenBudget is set', () => {
+    // Create a protected section (never drop) with large content that will exceed the budget
+    // and a smaller section that can be dropped. The protected one gets truncated but not dropped.
+    const bigContent = 'X'.repeat(10000);
+    const sections = [
+      makeSection({ id: 'protected', title: 'Protected', content: bigContent, priority: 50, trimStrategy: 'never' }),
+    ];
+    // Budget well below the content size — trimming will be attempted but 'never' prevents drop
+    // The result is the original content since truncate strategy isn't set
+    const result = formatSections(sections, { tokenBudget: 10 });
+    // The section is preserved (never dropped)
+    expect(result).toContain('## Protected');
+    // Content is shorter than original since no truncate strategy, section cannot be dropped either
+    // so the function returns it as-is
+    expect(result).toContain('X');
+  });
+
+  it('returns empty string for empty sections array', () => {
+    expect(formatSections([])).toBe('');
+  });
+});
+
+describe('trimSections', () => {
+  it('returns sections unchanged when under budget', () => {
+    const sections = [makeSection({ content: 'short content' })];
+    // Large budget so no trimming needed
+    const result = trimSections(sections, 100000);
+    expect(result).toEqual(sections);
+  });
+
+  it('truncates sections with trimStrategy truncate when content > 2000 chars', () => {
+    const longContent = 'A'.repeat(3000);
+    // Use a budget that is exceeded by the long content but satisfied after truncation to 2000 chars.
+    // Truncated content: 2000 chars + '\n\n[...truncated]' = ~2016 chars ≈ 504 tokens.
+    // With title '## Test\n\n' overhead (~12 chars) ≈ 504 tokens total.
+    // Use budget=600 so truncation satisfies it but not dropping.
+    const sections = [
+      makeSection({ id: 'big', content: longContent, trimStrategy: 'truncate' }),
+    ];
+    const result = trimSections(sections, 600);
+    expect(result).toHaveLength(1);
+    expect(result[0].content).toContain('[...truncated]');
+    expect(result[0].content).toContain('A'.repeat(2000));
+    expect(result[0].content).not.toContain('A'.repeat(2001));
+  });
+
+  it('does not truncate sections with content <= 2000 chars even with truncate strategy', () => {
+    const shortContent = 'A'.repeat(500);
+    const sections = [
+      makeSection({ id: 'small', content: shortContent, trimStrategy: 'truncate' }),
+      makeSection({ id: 'other', content: 'other content', priority: 10 }),
+    ];
+    // Force a tight budget but the truncate candidate is too short to truncate
+    // so the other (droppable) section will be dropped instead
+    const result = trimSections(sections, 1);
+    const truncatedSection = result.find(s => s.id === 'small');
+    if (truncatedSection) {
+      expect(truncatedSection.content).not.toContain('[...truncated]');
+    }
+  });
+
+  it('drops sections with trimStrategy drop (lowest priority first)', () => {
+    const sections = [
+      makeSection({ id: 'high', title: 'High', content: 'high priority content', priority: 100 }),
+      makeSection({ id: 'low', title: 'Low', content: 'low priority content', priority: 1, trimStrategy: 'drop' }),
+    ];
+    // Budget that requires dropping sections — very tight
+    const result = trimSections(sections, 1);
+    const ids = result.map(s => s.id);
+    expect(ids).not.toContain('low');
+  });
+
+  it('never drops sections with trimStrategy never', () => {
+    const sections = [
+      makeSection({ id: 'protected', title: 'Protected', content: 'protected content', priority: 1, trimStrategy: 'never' }),
+      makeSection({ id: 'droppable', title: 'Droppable', content: 'droppable content', priority: 50 }),
+    ];
+    // Very tight budget forces drops but 'never' section must survive
+    const result = trimSections(sections, 1);
+    const ids = result.map(s => s.id);
+    expect(ids).toContain('protected');
+  });
+
+  it('logs budget warning when trimming occurs', () => {
+    const bigContent = 'A'.repeat(10000);
+    const sections = [
+      makeSection({ id: 'big', content: bigContent, trimStrategy: 'truncate' }),
+    ];
+    const logger = { log: vi.fn() };
+    trimSections(sections, 1, logger);
+    expect(logger.log).toHaveBeenCalled();
+    const logCall = logger.log.mock.calls[0][0];
+    expect(logCall.event).toBe('budget_trimmed');
+    expect(logCall.phase).toBe('format');
+  });
+
+  it('does not log when no trimming occurs', () => {
+    const sections = [makeSection({ content: 'short' })];
+    const logger = { log: vi.fn() };
+    trimSections(sections, 100000, logger);
+    expect(logger.log).not.toHaveBeenCalled();
+  });
+});
+
 describe('skillDisclosure: progressive', () => {
   it('shows only description, not content, in progressive mode', () => {
     const ctx = makeEmptyContext();

package/src/__tests__/runtime.test.ts

@@ -26,23 +26,24 @@ describe('DotAiRuntime', () => {
   });
 
   describe('processPrompt', () => {
-    it('returns sections, labels, formatted, enriched, capabilities', async () => {
+    it('returns sections, labels, routing', async () => {
       const runtime = new DotAiRuntime({ workspaceRoot: '/tmp/nonexistent' });
       await runtime.boot();
       const result = await runtime.processPrompt('hello world');
-      expect(result.formatted).toBeDefined();
-      expect(result.enriched).toBeDefined();
-      expect(result.capabilities).toBeDefined();
       expect(result.labels).toBeDefined();
       expect(result.sections).toBeDefined();
+      expect(Array.isArray(result.sections)).toBe(true);
+      expect(result.routing).toBeDefined();
     });
-  });
 
-  describe('learn', () => {
-    it('fires agent_end without throwing', async () => {
+    it('includes core system section', async () => {
       const runtime = new DotAiRuntime({ workspaceRoot: '/tmp/nonexistent' });
       await runtime.boot();
-      await runtime.learn('test response');
+      const result = await runtime.processPrompt('hello');
+      const systemSection = result.sections.find(s => s.id === 'dot-ai:system');
+      expect(systemSection).toBeDefined();
+      expect(systemSection!.priority).toBe(95);
+      expect(systemSection!.source).toBe('core');
     });
   });
 
@@ -74,6 +75,19 @@ describe('DotAiRuntime', () => {
     });
   });
 
+  describe('executeTool', () => {
+    it('throws when not booted', async () => {
+      const runtime = new DotAiRuntime({ workspaceRoot: '/tmp/nonexistent' });
+      await expect(runtime.executeTool('test', {})).rejects.toThrow('Runtime not booted');
+    });
+
+    it('throws for unknown tool', async () => {
+      const runtime = new DotAiRuntime({ workspaceRoot: '/tmp/nonexistent' });
+      await runtime.boot();
+      await expect(runtime.executeTool('nonexistent', {})).rejects.toThrow('Tool not found');
+    });
+  });
+
   describe('shutdown', () => {
     it('fires session_end and flushes', async () => {
       const flushFn = vi.fn().mockResolvedValue(undefined);
@@ -122,12 +136,26 @@ describe('DotAiRuntime', () => {
       expect(runtime.commands).toEqual([]);
     });
 
-    it('diagnostics include vocabulary size', async () => {
+    it('skills returns empty array when no extensions', async () => {
+      const runtime = new DotAiRuntime({ workspaceRoot: '/tmp/nonexistent' });
+      await runtime.boot();
+      expect(runtime.skills).toEqual([]);
+    });
+
+    it('identities returns empty array when no extensions', async () => {
+      const runtime = new DotAiRuntime({ workspaceRoot: '/tmp/nonexistent' });
+      await runtime.boot();
+      expect(runtime.identities).toEqual([]);
+    });
+
+    it('diagnostics include vocabulary size and counts', async () => {
       const runtime = new DotAiRuntime({ workspaceRoot: '/tmp/nonexistent' });
       await runtime.boot();
       const diag = runtime.diagnostics;
       expect(diag.vocabularySize).toBeDefined();
-      expect(diag.capabilityCount).toBe(0); // no extensions = no tools
+      expect(diag.capabilityCount).toBe(0);
+      expect(diag.skillCount).toBe(0);
+      expect(diag.identityCount).toBe(0);
       expect(diag.extensions).toEqual([]);
     });
 

package/src/boot-cache.ts

@@ -11,7 +11,7 @@ export interface BootCacheData {
   version: 1;
   /** Checksum of inputs that produced this cache */
   checksum: string;
-  /** Label vocabulary from resources_discover */
+  /** Label vocabulary from registered resources */
   vocabulary: string[];
   /** Extension paths that were loaded */
   extensionPaths: string[];