@soleri/core 9.2.0 → 9.3.0

package/src/chat/agent-loop.test.ts

@@ -73,9 +73,7 @@ describe('runAgentLoop', () => {
 
   describe('basic flow', () => {
     test('returns text on end_turn', async () => {
-      fetchMock.mockResolvedValueOnce(
-        anthropicResponse([{ type: 'text', text: 'Hello!' }]),
-      );
+      fetchMock.mockResolvedValueOnce(anthropicResponse([{ type: 'text', text: 'Hello!' }]));
 
       const result = await runAgentLoop(makeMessages('hi'), makeConfig());
       expect(result.text).toBe('Hello!');
@@ -87,9 +85,7 @@ describe('runAgentLoop', () => {
     });
 
     test('accumulates newMessages', async () => {
-      fetchMock.mockResolvedValueOnce(
-        anthropicResponse([{ type: 'text', text: 'reply' }]),
-      );
+      fetchMock.mockResolvedValueOnce(anthropicResponse([{ type: 'text', text: 'reply' }]));
 
       const result = await runAgentLoop(makeMessages('q'), makeConfig());
       expect(result.newMessages.length).toBeGreaterThanOrEqual(1);
@@ -111,20 +107,24 @@ describe('runAgentLoop', () => {
         ),
       );
       // Second call: LLM returns final text
-      fetchMock.mockResolvedValueOnce(
-        anthropicResponse([{ type: 'text', text: 'Found it!' }]),
-      );
+      fetchMock.mockResolvedValueOnce(anthropicResponse([{ type: 'text', text: 'Found it!' }]));
 
       const executorResults: string[] = [];
-      const executor = async (name: string, _input: Record<string, unknown>): Promise<ToolResult> => {
+      const executor = async (
+        name: string,
+        _input: Record<string, unknown>,
+      ): Promise<ToolResult> => {
         executorResults.push(name);
         return { output: `result for ${name}`, isError: false };
       };
 
-      const result = await runAgentLoop(makeMessages('search'), makeConfig({
-        tools: [{ name: 'search', description: 'Search', inputSchema: { type: 'object' } }],
-        executor,
-      }));
+      const result = await runAgentLoop(
+        makeMessages('search'),
+        makeConfig({
+          tools: [{ name: 'search', description: 'Search', inputSchema: { type: 'object' } }],
+          executor,
+        }),
+      );
 
       expect(result.iterations).toBe(2);
       expect(result.toolCalls).toBe(1);
@@ -139,16 +139,16 @@ describe('runAgentLoop', () => {
           'tool_use',
         ),
       );
-      fetchMock.mockResolvedValueOnce(
-        anthropicResponse([{ type: 'text', text: 'Done' }]),
-      );
+      fetchMock.mockResolvedValueOnce(anthropicResponse([{ type: 'text', text: 'Done' }]));
 
       const errors: string[] = [];
       const result = await runAgentLoop(
         makeMessages('go'),
         makeConfig({
           tools: [{ name: 'broken', description: 'Broken', inputSchema: { type: 'object' } }],
-          executor: async () => { throw new Error('tool failed'); },
+          executor: async () => {
+            throw new Error('tool failed');
+          },
         }),
         {
           onError: (err, ctx) => errors.push(`${ctx}: ${err.message}`),
@@ -254,9 +254,7 @@ describe('runAgentLoop', () => {
 
   describe('callbacks', () => {
     test('fires onIteration for each loop', async () => {
-      fetchMock.mockResolvedValueOnce(
-        anthropicResponse([{ type: 'text', text: 'ok' }]),
-      );
+      fetchMock.mockResolvedValueOnce(anthropicResponse([{ type: 'text', text: 'ok' }]));
 
       const iterations: number[] = [];
       await runAgentLoop(makeMessages('hi'), makeConfig(), {
@@ -273,9 +271,7 @@ describe('runAgentLoop', () => {
           'tool_use',
         ),
       );
-      fetchMock.mockResolvedValueOnce(
-        anthropicResponse([{ type: 'text', text: 'done' }]),
-      );
+      fetchMock.mockResolvedValueOnce(anthropicResponse([{ type: 'text', text: 'done' }]));
 
       const toolUses: string[] = [];
       const toolResults: string[] = [];
@@ -304,9 +300,9 @@ describe('runAgentLoop', () => {
     test('throws on non-retryable API error', async () => {
       fetchMock.mockResolvedValueOnce(anthropicError(400, 'bad request'));
 
-      await expect(
-        runAgentLoop(makeMessages('hi'), makeConfig()),
-      ).rejects.toThrow('Anthropic API error 400');
+      await expect(runAgentLoop(makeMessages('hi'), makeConfig())).rejects.toThrow(
+        'Anthropic API error 400',
+      );
     });
 
     test('fires onError callback before throwing', async () => {
@@ -326,9 +322,7 @@ describe('runAgentLoop', () => {
 
   describe('message sanitization', () => {
     test('strips leading assistant messages', async () => {
-      fetchMock.mockResolvedValueOnce(
-        anthropicResponse([{ type: 'text', text: 'ok' }]),
-      );
+      fetchMock.mockResolvedValueOnce(anthropicResponse([{ type: 'text', text: 'ok' }]));
 
       const messages: ChatMessage[] = [
         { role: 'assistant', content: 'orphan', timestamp: Date.now() },
@@ -344,9 +338,7 @@ describe('runAgentLoop', () => {
     });
 
     test('skips standalone tool messages', async () => {
-      fetchMock.mockResolvedValueOnce(
-        anthropicResponse([{ type: 'text', text: 'ok' }]),
-      );
+      fetchMock.mockResolvedValueOnce(anthropicResponse([{ type: 'text', text: 'ok' }]));
 
       const messages: ChatMessage[] = [
         { role: 'user', content: 'hello', timestamp: Date.now() },
@@ -365,18 +357,16 @@ describe('runAgentLoop', () => {
   describe('usage accumulation', () => {
     test('sums usage across iterations', async () => {
       fetchMock.mockResolvedValueOnce(
-        anthropicResponse(
-          [{ type: 'tool_use', id: 'tu_1', name: 'x', input: {} }],
-          'tool_use',
-          { input_tokens: 100, output_tokens: 50 },
-        ),
+        anthropicResponse([{ type: 'tool_use', id: 'tu_1', name: 'x', input: {} }], 'tool_use', {
+          input_tokens: 100,
+          output_tokens: 50,
+        }),
       );
       fetchMock.mockResolvedValueOnce(
-        anthropicResponse(
-          [{ type: 'text', text: 'done' }],
-          'end_turn',
-          { input_tokens: 150, output_tokens: 30 },
-        ),
+        anthropicResponse([{ type: 'text', text: 'done' }], 'end_turn', {
+          input_tokens: 150,
+          output_tokens: 30,
+        }),
       );
 
       const result = await runAgentLoop(

package/src/chat/mcp-bridge.test.ts

@@ -108,7 +108,9 @@ describe('McpToolBridge', () => {
     test('catches handler errors', async () => {
       bridge.register({
         ...makeTool('broken'),
-        handler: async () => { throw new Error('kaboom'); },
+        handler: async () => {
+          throw new Error('kaboom');
+        },
       });
       const result = await bridge.execute('broken', {});
       expect(result.isError).toBe(true);
@@ -119,7 +121,10 @@ describe('McpToolBridge', () => {
       let received: Record<string, unknown> = {};
       bridge.register({
         ...makeTool('capture'),
-        handler: async (input) => { received = input; return 'ok'; },
+        handler: async (input) => {
+          received = input;
+          return 'ok';
+        },
       });
       await bridge.execute('capture', { foo: 'bar' });
       expect(received).toEqual({ foo: 'bar' });

package/src/claudemd/inject.test.ts

@@ -2,18 +2,8 @@ import { describe, it, expect, beforeEach, afterEach } from 'vitest';
 import { join } from 'node:path';
 import { mkdtempSync, rmSync, readFileSync, writeFileSync } from 'node:fs';
 import { tmpdir } from 'node:os';
-import {
-  injectCLAUDEmd,
-  removeCLAUDEmd,
-  hasCLAUDEmdBlock,
-  extractUserZone,
-} from './inject.js';
-import {
-  OPEN_MARKER,
-  CLOSE_MARKER,
-  USER_ZONE_OPEN,
-  USER_ZONE_CLOSE,
-} from './compose.js';
+import { injectCLAUDEmd, removeCLAUDEmd, hasCLAUDEmdBlock, extractUserZone } from './inject.js';
+import { OPEN_MARKER, CLOSE_MARKER, USER_ZONE_OPEN, USER_ZONE_CLOSE } from './compose.js';
 
 function block(content: string): string {
   return `${OPEN_MARKER}\n${content}\n${CLOSE_MARKER}`;

package/src/context/context-engine.test.ts

@@ -31,7 +31,13 @@ function createMockIntelligence(overrides?: Partial<BrainIntelligence>): BrainIn
   } as unknown as BrainIntelligence;
 }
 
-function makeVaultResult(id: string, title: string, score: number, domain: string, tags: string[] = []) {
+function makeVaultResult(
+  id: string,
+  title: string,
+  score: number,
+  domain: string,
+  tags: string[] = [],
+) {
   return {
     entry: { id, title, domain, tags, type: 'pattern', severity: 'suggestion', description: '' },
     score,
@@ -120,7 +126,9 @@ describe('ContextEngine', () => {
     });
 
     it('extracts kebab-case patterns but filters stop words', () => {
-      const result = engine.extractEntities('Use the token-migration pattern, not built-in or real-time');
+      const result = engine.extractEntities(
+        'Use the token-migration pattern, not built-in or real-time',
+      );
       const patterns = result.byType.pattern ?? [];
       expect(patterns.some((p) => p.value === 'token-migration')).toBe(true);
       expect(patterns.some((p) => p.value === 'real-time')).toBe(false);
@@ -170,9 +178,11 @@ describe('ContextEngine', () => {
 
   describe('retrieveKnowledge', () => {
     it('returns vault results with enriched scores', async () => {
-      const mockSearch = vi.fn().mockReturnValue([
-        makeVaultResult('v1', 'Button pattern', 10, 'design', ['button', 'component']),
-      ]);
+      const mockSearch = vi
+        .fn()
+        .mockReturnValue([
+          makeVaultResult('v1', 'Button pattern', 10, 'design', ['button', 'component']),
+        ]);
       vault = createMockVault({ search: mockSearch } as unknown as Partial<Vault>);
       engine = new ContextEngine(vault, brain, intelligence);
 
@@ -186,10 +196,12 @@ describe('ContextEngine', () => {
     });
 
     it('returns brain recommendations normalized to 0-1', async () => {
-      const mockRecommend = vi.fn().mockReturnValue([
-        makeBrainRecommendation('semantic-tokens', 'design', 80),
-      ]);
-      intelligence = createMockIntelligence({ recommend: mockRecommend } as unknown as Partial<BrainIntelligence>);
+      const mockRecommend = vi
+        .fn()
+        .mockReturnValue([makeBrainRecommendation('semantic-tokens', 'design', 80)]);
+      intelligence = createMockIntelligence({
+        recommend: mockRecommend,
+      } as unknown as Partial<BrainIntelligence>);
       engine = new ContextEngine(vault, brain, intelligence);
 
       const result = await engine.retrieveKnowledge('design tokens');
@@ -200,14 +212,16 @@ describe('ContextEngine', () => {
     });
 
     it('combines vault and brain results sorted by score descending', async () => {
-      const mockSearch = vi.fn().mockReturnValue([
-        makeVaultResult('v1', 'Low relevance', 2, 'general'),
-      ]);
-      const mockRecommend = vi.fn().mockReturnValue([
-        makeBrainRecommendation('high-relevance', 'design', 95),
-      ]);
+      const mockSearch = vi
+        .fn()
+        .mockReturnValue([makeVaultResult('v1', 'Low relevance', 2, 'general')]);
+      const mockRecommend = vi
+        .fn()
+        .mockReturnValue([makeBrainRecommendation('high-relevance', 'design', 95)]);
       vault = createMockVault({ search: mockSearch } as unknown as Partial<Vault>);
-      intelligence = createMockIntelligence({ recommend: mockRecommend } as unknown as Partial<BrainIntelligence>);
+      intelligence = createMockIntelligence({
+        recommend: mockRecommend,
+      } as unknown as Partial<BrainIntelligence>);
       engine = new ContextEngine(vault, brain, intelligence);
 
       const result = await engine.retrieveKnowledge('test query');
@@ -216,9 +230,9 @@ describe('ContextEngine', () => {
     });
 
     it('filters items below minScoreThreshold', async () => {
-      const mockSearch = vi.fn().mockReturnValue([
-        makeVaultResult('v1', 'Irrelevant entry', 1, 'misc'),
-      ]);
+      const mockSearch = vi
+        .fn()
+        .mockReturnValue([makeVaultResult('v1', 'Irrelevant entry', 1, 'misc')]);
       vault = createMockVault({ search: mockSearch } as unknown as Partial<Vault>);
       engine = new ContextEngine(vault, brain, intelligence, { minScoreThreshold: 0.99 });
 
@@ -241,12 +255,17 @@ describe('ContextEngine', () => {
       engine = new ContextEngine(vault, brain, intelligence);
 
       await engine.retrieveKnowledge('test', 'security');
-      expect(mockSearch).toHaveBeenCalledWith('test', expect.objectContaining({ domain: 'security' }));
+      expect(mockSearch).toHaveBeenCalledWith(
+        'test',
+        expect.objectContaining({ domain: 'security' }),
+      );
     });
 
     it('passes domain to brain recommendations', async () => {
       const mockRecommend = vi.fn().mockReturnValue([]);
-      intelligence = createMockIntelligence({ recommend: mockRecommend } as unknown as Partial<BrainIntelligence>);
+      intelligence = createMockIntelligence({
+        recommend: mockRecommend,
+      } as unknown as Partial<BrainIntelligence>);
       engine = new ContextEngine(vault, brain, intelligence);
 
       await engine.retrieveKnowledge('test', 'design');
@@ -254,7 +273,9 @@ describe('ContextEngine', () => {
     });
 
     it('gracefully handles vault search throwing', async () => {
-      const mockSearch = vi.fn().mockImplementation(() => { throw new Error('DB error'); });
+      const mockSearch = vi.fn().mockImplementation(() => {
+        throw new Error('DB error');
+      });
       vault = createMockVault({ search: mockSearch } as unknown as Partial<Vault>);
       engine = new ContextEngine(vault, brain, intelligence);
 
@@ -264,8 +285,12 @@ describe('ContextEngine', () => {
     });
 
     it('gracefully handles brain recommend throwing', async () => {
-      const mockRecommend = vi.fn().mockImplementation(() => { throw new Error('Brain error'); });
-      intelligence = createMockIntelligence({ recommend: mockRecommend } as unknown as Partial<BrainIntelligence>);
+      const mockRecommend = vi.fn().mockImplementation(() => {
+        throw new Error('Brain error');
+      });
+      intelligence = createMockIntelligence({
+        recommend: mockRecommend,
+      } as unknown as Partial<BrainIntelligence>);
       engine = new ContextEngine(vault, brain, intelligence);
 
       const result = await engine.retrieveKnowledge('test');
@@ -283,7 +308,9 @@ describe('ContextEngine', () => {
 
     it('respects brainRecommendLimit config', async () => {
       const mockRecommend = vi.fn().mockReturnValue([]);
-      intelligence = createMockIntelligence({ recommend: mockRecommend } as unknown as Partial<BrainIntelligence>);
+      intelligence = createMockIntelligence({
+        recommend: mockRecommend,
+      } as unknown as Partial<BrainIntelligence>);
       engine = new ContextEngine(vault, brain, intelligence, { brainRecommendLimit: 2 });
 
       await engine.retrieveKnowledge('test');
@@ -312,7 +339,9 @@ describe('ContextEngine', () => {
     });
 
     it('confidence is between 0 and 1', async () => {
-      const result = await engine.analyze('Create React TypeScript component in src/app.tsx for security');
+      const result = await engine.analyze(
+        'Create React TypeScript component in src/app.tsx for security',
+      );
       expect(result.confidence).toBeGreaterThanOrEqual(0);
       expect(result.confidence).toBeLessThanOrEqual(1);
     });
@@ -324,13 +353,17 @@ describe('ContextEngine', () => {
     });
 
     it('assigns higher confidence when entities and knowledge are present', async () => {
-      const mockSearch = vi.fn().mockReturnValue([
-        makeVaultResult('v1', 'Unit test best practices', 10, 'testing', ['testing']),
-      ]);
+      const mockSearch = vi
+        .fn()
+        .mockReturnValue([
+          makeVaultResult('v1', 'Unit test best practices', 10, 'testing', ['testing']),
+        ]);
       vault = createMockVault({ search: mockSearch } as unknown as Partial<Vault>);
       engine = new ContextEngine(vault, brain, intelligence);
 
-      const result = await engine.analyze('Create unit tests for the search() function in src/vault.ts with TypeScript');
+      const result = await engine.analyze(
+        'Create unit tests for the search() function in src/vault.ts with TypeScript',
+      );
       expect(result.confidence).toBeGreaterThan(0.4);
     });
 
@@ -341,9 +374,9 @@ describe('ContextEngine', () => {
     });
 
     it('detects domains from knowledge items', async () => {
-      const mockSearch = vi.fn().mockReturnValue([
-        makeVaultResult('v1', 'Perf guide', 10, 'performance', ['performance']),
-      ]);
+      const mockSearch = vi
+        .fn()
+        .mockReturnValue([makeVaultResult('v1', 'Perf guide', 10, 'performance', ['performance'])]);
       vault = createMockVault({ search: mockSearch } as unknown as Partial<Vault>);
       engine = new ContextEngine(vault, brain, intelligence);
 
@@ -352,9 +385,9 @@ describe('ContextEngine', () => {
     });
 
     it('deduplicates domains from entities and knowledge', async () => {
-      const mockSearch = vi.fn().mockReturnValue([
-        makeVaultResult('v1', 'A11y rules', 10, 'accessibility', ['a11y']),
-      ]);
+      const mockSearch = vi
+        .fn()
+        .mockReturnValue([makeVaultResult('v1', 'A11y rules', 10, 'accessibility', ['a11y'])]);
       vault = createMockVault({ search: mockSearch } as unknown as Partial<Vault>);
       engine = new ContextEngine(vault, brain, intelligence);
 
@@ -393,27 +426,35 @@ describe('ContextEngine', () => {
 
     it('more entities increase confidence up to a cap', async () => {
       const few = await engine.analyze('fix it');
-      const many = await engine.analyze('fix the React TypeScript component in src/app.tsx for accessibility and deploy');
+      const many = await engine.analyze(
+        'fix the React TypeScript component in src/app.tsx for accessibility and deploy',
+      );
       expect(many.confidence).toBeGreaterThan(few.confidence);
     });
 
     it('source diversity bonus applies when multiple sources return results', async () => {
-      const mockSearch = vi.fn().mockReturnValue([
-        makeVaultResult('v1', 'Pattern one', 10, 'design', ['design']),
-      ]);
-      const mockRecommend = vi.fn().mockReturnValue([
-        makeBrainRecommendation('some-pattern', 'design', 70),
-      ]);
+      const mockSearch = vi
+        .fn()
+        .mockReturnValue([makeVaultResult('v1', 'Pattern one', 10, 'design', ['design'])]);
+      const mockRecommend = vi
+        .fn()
+        .mockReturnValue([makeBrainRecommendation('some-pattern', 'design', 70)]);
       vault = createMockVault({ search: mockSearch } as unknown as Partial<Vault>);
-      intelligence = createMockIntelligence({ recommend: mockRecommend } as unknown as Partial<BrainIntelligence>);
+      intelligence = createMockIntelligence({
+        recommend: mockRecommend,
+      } as unknown as Partial<BrainIntelligence>);
       const multiEngine = new ContextEngine(vault, brain, intelligence);
 
-      const vaultOnlySearch = vi.fn().mockReturnValue([
-        makeVaultResult('v1', 'Pattern one', 10, 'design', ['design']),
-      ]);
+      const vaultOnlySearch = vi
+        .fn()
+        .mockReturnValue([makeVaultResult('v1', 'Pattern one', 10, 'design', ['design'])]);
       const emptyRecommend = vi.fn().mockReturnValue([]);
-      const vaultOnlyVault = createMockVault({ search: vaultOnlySearch } as unknown as Partial<Vault>);
-      const emptyIntel = createMockIntelligence({ recommend: emptyRecommend } as unknown as Partial<BrainIntelligence>);
+      const vaultOnlyVault = createMockVault({
+        search: vaultOnlySearch,
+      } as unknown as Partial<Vault>);
+      const emptyIntel = createMockIntelligence({
+        recommend: emptyRecommend,
+      } as unknown as Partial<BrainIntelligence>);
       const singleEngine = new ContextEngine(vaultOnlyVault, brain, emptyIntel);
 
       const multi = await multiEngine.analyze('design patterns');
@@ -428,7 +469,9 @@ describe('ContextEngine', () => {
       expect(low.confidence).toBeLessThan(0.45);
 
       // Construct a scenario with enough signals for medium (action + 6 entities = 0.2 + 0.4 cap = 0.6)
-      const medium = await engine.analyze('create a React TypeScript component in src/app.tsx for security');
+      const medium = await engine.analyze(
+        'create a React TypeScript component in src/app.tsx for security',
+      );
       expect(medium.confidence).toBeGreaterThanOrEqual(0.45);
       expect(['medium', 'high']).toContain(medium.confidenceLevel);
     });
@@ -450,7 +493,9 @@ describe('ContextEngine', () => {
       const mockSearch = vi.fn().mockReturnValue([]);
       const mockRecommend = vi.fn().mockReturnValue([]);
       vault = createMockVault({ search: mockSearch } as unknown as Partial<Vault>);
-      intelligence = createMockIntelligence({ recommend: mockRecommend } as unknown as Partial<BrainIntelligence>);
+      intelligence = createMockIntelligence({
+        recommend: mockRecommend,
+      } as unknown as Partial<BrainIntelligence>);
       engine = new ContextEngine(vault, brain, intelligence, { vaultSearchLimit: 5 });
 
       await engine.retrieveKnowledge('test');

package/src/control/intent-router.test.ts

@@ -230,9 +230,9 @@ describe('IntentRouter', () => {
     });
 
     it('throws for unknown mode', () => {
-      expect(() =>
-        router.updateModeRules('NOPE-MODE' as OperationalMode, ['x']),
-      ).toThrow(/Unknown mode/);
+      expect(() => router.updateModeRules('NOPE-MODE' as OperationalMode, ['x'])).toThrow(
+        /Unknown mode/,
+      );
     });
   });
 

package/src/curator/classifier.test.ts

@@ -32,12 +32,14 @@ describe('classifyEntry', () => {
   });
 
   it('classifies entry with valid LLM response', async () => {
-    const llm = mockLLM(JSON.stringify({
-      domain: 'security',
-      severity: 'critical',
-      tags: ['auth', 'jwt', 'security'],
-      confidence: 0.9,
-    }));
+    const llm = mockLLM(
+      JSON.stringify({
+        domain: 'security',
+        severity: 'critical',
+        tags: ['auth', 'jwt', 'security'],
+        confidence: 0.9,
+      }),
+    );
 
     const result = await classifyEntry(makeEntry({ title: 'Use JWT securely' }), llm);
     expect(result.classified).toBe(true);
@@ -75,7 +77,9 @@ describe('classifyEntry', () => {
   });
 
   it('passes entry fields to LLM prompt', async () => {
-    const llm = mockLLM(JSON.stringify({ domain: 'test', severity: 'warning', tags: [], confidence: 0.5 }));
+    const llm = mockLLM(
+      JSON.stringify({ domain: 'test', severity: 'warning', tags: [], confidence: 0.5 }),
+    );
     const entry = makeEntry({
       title: 'Specific Title',
       type: 'anti-pattern',
@@ -93,7 +97,9 @@ describe('classifyEntry', () => {
   });
 
   it('uses empty tags placeholder when entry has no tags', async () => {
-    const llm = mockLLM(JSON.stringify({ domain: 'test', severity: 'warning', tags: [], confidence: 0.5 }));
+    const llm = mockLLM(
+      JSON.stringify({ domain: 'test', severity: 'warning', tags: [], confidence: 0.5 }),
+    );
     const entry = makeEntry({ tags: [] });
 
     await classifyEntry(entry, llm);

package/src/curator/contradiction-detector.test.ts

@@ -111,8 +111,18 @@ describe('contradiction-detector', () => {
 
     it('falls back to all patterns when searchFn returns empty', () => {
       const entries = [
-        makeEntry({ id: 'p1', type: 'pattern', title: 'Use inline styles', description: 'Inline.' }),
-        makeEntry({ id: 'ap1', type: 'anti-pattern', title: 'Avoid inline styles', description: 'No inline.' }),
+        makeEntry({
+          id: 'p1',
+          type: 'pattern',
+          title: 'Use inline styles',
+          description: 'Inline.',
+        }),
+        makeEntry({
+          id: 'ap1',
+          type: 'anti-pattern',
+          title: 'Avoid inline styles',
+          description: 'No inline.',
+        }),
       ];
 
       const searchFn = vi.fn().mockReturnValue([]);
@@ -125,8 +135,18 @@ describe('contradiction-detector', () => {
 
     it('falls back to all patterns when searchFn throws', () => {
       const entries = [
-        makeEntry({ id: 'p1', type: 'pattern', title: 'Use inline styles', description: 'Inline.' }),
-        makeEntry({ id: 'ap1', type: 'anti-pattern', title: 'Avoid inline styles', description: 'No inline.' }),
+        makeEntry({
+          id: 'p1',
+          type: 'pattern',
+          title: 'Use inline styles',
+          description: 'Inline.',
+        }),
+        makeEntry({
+          id: 'ap1',
+          type: 'anti-pattern',
+          title: 'Avoid inline styles',
+          description: 'No inline.',
+        }),
       ];
 
       const searchFn = vi.fn().mockImplementation(() => {
@@ -170,7 +190,12 @@ describe('contradiction-detector', () => {
     it('ignores entries that are neither pattern nor anti-pattern', () => {
       const entries = [
         makeEntry({ id: 'r1', type: 'rule', title: 'Use inline styles', description: 'Inline.' }),
-        makeEntry({ id: 'ap1', type: 'anti-pattern', title: 'Avoid inline styles', description: 'No inline.' }),
+        makeEntry({
+          id: 'ap1',
+          type: 'anti-pattern',
+          title: 'Avoid inline styles',
+          description: 'No inline.',
+        }),
       ];
       // Rules should not be compared against anti-patterns
       const results = findContradictions(entries, 0.1);