@soleri/core 7.0.0 → 8.1.0

package/src/__tests__/async-infrastructure.test.ts

@@ -0,0 +1,307 @@
+/**
+ * Tests for async infrastructure — event bus, job queue, pipeline runner.
+ * Phase 1 of #210: generic infrastructure modules.
+ */
+
+import { describe, it, expect, beforeAll, afterAll, vi } from 'vitest';
+import { TypedEventBus } from '../events/event-bus.js';
+import { JobQueue } from '../queue/job-queue.js';
+import { PipelineRunner } from '../queue/pipeline-runner.js';
+import { Vault } from '../vault/vault.js';
+
+// ─── Event Bus ───────────────────────────────────────────────────────
+
+describe('TypedEventBus', () => {
+  type TestEvents = {
+    'item:created': { id: string; title: string };
+    'item:deleted': { id: string };
+    tick: { count: number };
+  };
+
+  it('emits and receives typed events', () => {
+    const bus = new TypedEventBus<TestEvents>();
+    let received: TestEvents['item:created'] | null = null;
+
+    bus.on('item:created', (payload) => {
+      received = payload;
+    });
+    bus.emit('item:created', { id: '1', title: 'Hello' });
+
+    expect(received).toEqual({ id: '1', title: 'Hello' });
+  });
+
+  it('once listener fires only once', () => {
+    const bus = new TypedEventBus<TestEvents>();
+    let count = 0;
+
+    bus.once('tick', () => {
+      count++;
+    });
+    bus.emit('tick', { count: 1 });
+    bus.emit('tick', { count: 2 });
+
+    expect(count).toBe(1);
+  });
+
+  it('off removes a listener', () => {
+    const bus = new TypedEventBus<TestEvents>();
+    let count = 0;
+    const listener = () => {
+      count++;
+    };
+
+    bus.on('tick', listener);
+    bus.emit('tick', { count: 1 });
+    bus.off('tick', listener);
+    bus.emit('tick', { count: 2 });
+
+    expect(count).toBe(1);
+  });
+
+  it('listenerCount tracks total listeners', () => {
+    const bus = new TypedEventBus<TestEvents>();
+    expect(bus.listenerCount()).toBe(0);
+
+    bus.on('item:created', () => {});
+    bus.on('item:deleted', () => {});
+    expect(bus.listenerCount()).toBe(2);
+  });
+
+  it('removeAllListeners clears everything', () => {
+    const bus = new TypedEventBus<TestEvents>();
+    bus.on('item:created', () => {});
+    bus.on('tick', () => {});
+    bus.removeAllListeners();
+    expect(bus.listenerCount()).toBe(0);
+  });
+
+  it('supports multiple listeners on same event', () => {
+    const bus = new TypedEventBus<TestEvents>();
+    const results: string[] = [];
+
+    bus.on('item:created', (p) => results.push('A:' + p.id));
+    bus.on('item:created', (p) => results.push('B:' + p.id));
+    bus.emit('item:created', { id: '1', title: 'Test' });
+
+    expect(results).toEqual(['A:1', 'B:1']);
+  });
+});
+
+// ─── Job Queue ───────────────────────────────────────────────────────
+
+describe('JobQueue', () => {
+  let vault: Vault;
+  let queue: JobQueue;
+
+  beforeAll(() => {
+    vault = new Vault(':memory:');
+    queue = new JobQueue(vault.getProvider());
+  });
+
+  afterAll(() => {
+    vault.close();
+  });
+
+  it('enqueue creates a job and returns ID', () => {
+    const id = queue.enqueue('tag-normalize', { entryId: 'e1' });
+    expect(id).toBeTruthy();
+    expect(id.length).toBeGreaterThan(0);
+  });
+
+  it('dequeue returns oldest pending job', () => {
+    const id = queue.enqueue('dedup-check');
+    const job = queue.dequeue();
+    expect(job).not.toBeNull();
+    expect(job!.type).toBe('tag-normalize'); // First enqueued from previous test
+  });
+
+  it('dequeue marks job as running', () => {
+    const job = queue.get(queue.enqueue('test-job'));
+    expect(job!.status).toBe('pending');
+
+    const dequeued = queue.dequeue();
+    expect(dequeued!.status).toBe('running');
+  });
+
+  it('complete marks job as completed with result', () => {
+    const id = queue.enqueue('test-complete');
+    queue.dequeue(); // Mark running
+    queue.complete(id, { ok: true });
+
+    const job = queue.get(id);
+    expect(job!.status).toBe('completed');
+    expect(job!.result).toEqual({ ok: true });
+  });
+
+  it('fail marks job as failed with error', () => {
+    const id = queue.enqueue('test-fail');
+    queue.dequeue();
+    queue.fail(id, 'something went wrong');
+
+    const job = queue.get(id);
+    expect(job!.status).toBe('failed');
+    expect(job!.error).toBe('something went wrong');
+  });
+
+  it('retry resets failed job to pending', () => {
+    const id = queue.enqueue('test-retry');
+    queue.dequeue();
+    queue.fail(id, 'transient error');
+
+    const retried = queue.retry(id);
+    expect(retried).toBe(true);
+
+    const job = queue.get(id);
+    expect(job!.status).toBe('pending');
+    expect(job!.retryCount).toBe(1);
+  });
+
+  it('retry returns false when max retries exceeded', () => {
+    const id = queue.enqueue('test-max-retry', { maxRetries: 1 });
+    queue.dequeue();
+    queue.fail(id, 'fail 1');
+    queue.retry(id);
+    queue.dequeue();
+    queue.fail(id, 'fail 2');
+
+    const retried = queue.retry(id);
+    expect(retried).toBe(false);
+  });
+
+  it('respects DAG dependencies', () => {
+    const dep1 = queue.enqueue('dep-job-1');
+    const dep2 = queue.enqueue('dep-job-2', { dependsOn: [dep1] });
+
+    // dep2 should not dequeue because dep1 is not completed
+    // Clear running jobs first
+    const ready = queue.dequeueReady(10);
+    const readyIds = ready.map((j) => j.id);
+    expect(readyIds).toContain(dep1);
+    expect(readyIds).not.toContain(dep2);
+
+    // Complete dep1
+    queue.complete(dep1, {});
+
+    // Now dep2 should be ready
+    const ready2 = queue.dequeueReady(10);
+    const readyIds2 = ready2.map((j) => j.id);
+    expect(readyIds2).toContain(dep2);
+  });
+
+  it('groups jobs by pipeline', () => {
+    const pid = 'pipeline-123';
+    queue.enqueue('step-1', { pipelineId: pid });
+    queue.enqueue('step-2', { pipelineId: pid });
+
+    const jobs = queue.getByPipeline(pid);
+    expect(jobs.length).toBe(2);
+    expect(jobs.every((j) => j.pipelineId === pid)).toBe(true);
+  });
+
+  it('getStats returns correct counts', () => {
+    const stats = queue.getStats();
+    expect(stats.total).toBeGreaterThan(0);
+    expect(typeof stats.pending).toBe('number');
+    expect(typeof stats.running).toBe('number');
+    expect(typeof stats.completed).toBe('number');
+    expect(typeof stats.failed).toBe('number');
+  });
+
+  it('purge removes old completed/failed jobs', () => {
+    // purge with 0 days should remove all completed/failed
+    const purged = queue.purge(0);
+    expect(purged).toBeGreaterThanOrEqual(0);
+  });
+});
+
+// ─── Pipeline Runner ─────────────────────────────────────────────────
+
+describe('PipelineRunner', () => {
+  let vault: Vault;
+  let queue: JobQueue;
+  let runner: PipelineRunner;
+
+  beforeAll(() => {
+    vault = new Vault(':memory:');
+    queue = new JobQueue(vault.getProvider());
+    runner = new PipelineRunner(queue, 100); // 100ms poll for tests
+  });
+
+  afterAll(() => {
+    runner.stop();
+    vault.close();
+  });
+
+  it('registerHandler stores a handler for a job type', () => {
+    runner.registerHandler('test-type', async () => ({ done: true }));
+    expect(runner.hasHandler('test-type')).toBe(true);
+    expect(runner.hasHandler('unknown-type')).toBe(false);
+  });
+
+  it('processOnce dequeues and completes jobs', async () => {
+    const handler = vi.fn().mockResolvedValue({ processed: true });
+    runner.registerHandler('process-test', handler);
+
+    queue.enqueue('process-test', { payload: { key: 'value' } });
+
+    const processed = await runner.processOnce();
+    expect(processed).toBe(1);
+    expect(handler).toHaveBeenCalledTimes(1);
+  });
+
+  it('processOnce fails jobs with no handler', async () => {
+    const id = queue.enqueue('no-handler-type');
+    await runner.processOnce();
+
+    const job = queue.get(id);
+    expect(job!.status).toBe('failed');
+    expect(job!.error).toContain('No handler registered');
+  });
+
+  it('processOnce retries on handler error', async () => {
+    const handler = vi.fn().mockRejectedValue(new Error('transient'));
+    runner.registerHandler('flaky-type', handler);
+
+    const id = queue.enqueue('flaky-type');
+    await runner.processOnce();
+
+    const job = queue.get(id);
+    // Should be pending again (retried), not failed
+    expect(job!.status).toBe('pending');
+    expect(job!.retryCount).toBe(1);
+  });
+
+  it('getStatus returns runner state', () => {
+    const status = runner.getStatus();
+    expect(status.running).toBe(false); // Not started yet
+    expect(status.pollIntervalMs).toBe(100);
+    expect(status.jobsProcessed).toBeGreaterThanOrEqual(1);
+  });
+
+  it('start/stop controls background polling', async () => {
+    runner.start();
+    expect(runner.getStatus().running).toBe(true);
+
+    runner.stop();
+    expect(runner.getStatus().running).toBe(false);
+  });
+
+  it('respects DAG in pipeline execution', async () => {
+    const order: string[] = [];
+    runner.registerHandler('dag-step', async (job) => {
+      order.push(job.id);
+      return { step: job.id };
+    });
+
+    const step1 = queue.enqueue('dag-step', { pipelineId: 'dag-test' });
+    const step2 = queue.enqueue('dag-step', { pipelineId: 'dag-test', dependsOn: [step1] });
+
+    // First batch: only step1 should process
+    await runner.processOnce();
+    expect(order).toEqual([step1]);
+
+    // Second batch: step2 should now be ready
+    await runner.processOnce();
+    expect(order).toEqual([step1, step2]);
+  });
+});

package/src/__tests__/cognee-client-gaps.test.ts

@@ -357,7 +357,10 @@ describe('CogneeClient — gap coverage', () => {
       mockWithAuth(
         async () =>
           new Response(
-            JSON.stringify([{ id: 'r1', text: 42, score: 0.8 }, { id: 'r2', score: 0.7 }]),
+            JSON.stringify([
+              { id: 'r1', text: 42, score: 0.8 },
+              { id: 'r2', score: 0.7 },
+            ]),
             { status: 200 },
           ),
       );
@@ -440,7 +443,8 @@ describe('CogneeClient — gap coverage', () => {
 
     it('should give single result score 1.0', async () => {
       mockWithAuth(
-        async () => new Response(JSON.stringify([{ id: 'only', text: 'Sole result' }]), { status: 200 }),
+        async () =>
+          new Response(JSON.stringify([{ id: 'only', text: 'Sole result' }]), { status: 200 }),
       );
       const client = new CogneeClient();
       await client.healthCheck();

package/src/__tests__/cognee-hybrid-search.test.ts

@@ -15,9 +15,6 @@
  */
 
 import { describe, it, expect, beforeAll, afterAll, vi } from 'vitest';
-import { mkdirSync, rmSync } from 'node:fs';
-import { join } from 'node:path';
-import { tmpdir } from 'node:os';
 import { Brain } from '../brain/brain.js';
 import { Vault } from '../vault/vault.js';
 import { CogneeClient } from '../cognee/client.js';
@@ -46,16 +43,22 @@ function makeEntry(overrides: Partial<IntelligenceEntry> = {}): IntelligenceEntr
  * Create a mock CogneeClient that returns controlled search results.
  * isAvailable is a getter — can be toggled at runtime.
  */
-function makeMockCognee(opts: {
-  available?: boolean;
-  searchResults?: CogneeSearchResult[];
-} = {}): CogneeClient & { _setAvailable: (v: boolean) => void } {
+function makeMockCognee(
+  opts: {
+    available?: boolean;
+    searchResults?: CogneeSearchResult[];
+  } = {},
+): CogneeClient & { _setAvailable: (v: boolean) => void } {
   let available = opts.available ?? true;
   const searchResults = opts.searchResults ?? [];
 
   return {
-    get isAvailable() { return available; },
-    _setAvailable(v: boolean) { available = v; },
+    get isAvailable() {
+      return available;
+    },
+    _setAvailable(v: boolean) {
+      available = v;
+    },
     healthCheck: vi.fn().mockResolvedValue({ available, url: 'mock', latencyMs: 1 }),
     addEntries: vi.fn().mockResolvedValue({ added: 0 }),
     deleteEntries: vi.fn().mockResolvedValue({ deleted: 0 }),
@@ -74,7 +77,8 @@ const SEED_ENTRIES: IntelligenceEntry[] = [
   makeEntry({
     id: 'pattern-retry-backoff',
     title: 'Retry with Exponential Backoff',
-    description: 'Always use exponential backoff when retrying failed network requests to avoid thundering herd.',
+    description:
+      'Always use exponential backoff when retrying failed network requests to avoid thundering herd.',
     domain: 'architecture',
     severity: 'critical',
     tags: ['networking', 'retry', 'resilience'],
@@ -83,7 +87,8 @@ const SEED_ENTRIES: IntelligenceEntry[] = [
   makeEntry({
     id: 'pattern-circuit-breaker',
     title: 'Circuit Breaker for External Services',
-    description: 'Wrap external service calls in a circuit breaker to prevent cascade failures when downstream is unhealthy.',
+    description:
+      'Wrap external service calls in a circuit breaker to prevent cascade failures when downstream is unhealthy.',
     domain: 'architecture',
     severity: 'critical',
     tags: ['networking', 'resilience', 'microservices'],
@@ -93,7 +98,8 @@ const SEED_ENTRIES: IntelligenceEntry[] = [
     id: 'anti-pattern-polling-no-timeout',
     type: 'anti-pattern',
     title: 'Polling Without Timeout',
-    description: 'Never poll an external service without a maximum timeout or circuit breaker. Leads to resource exhaustion.',
+    description:
+      'Never poll an external service without a maximum timeout or circuit breaker. Leads to resource exhaustion.',
     domain: 'architecture',
     severity: 'critical',
     tags: ['networking', 'polling', 'timeout'],
@@ -101,7 +107,8 @@ const SEED_ENTRIES: IntelligenceEntry[] = [
   makeEntry({
     id: 'pattern-token-semantic',
     title: 'Semantic Token Priority',
-    description: 'Use semantic tokens over primitive tokens. Semantic tokens communicate intent, not just values.',
+    description:
+      'Use semantic tokens over primitive tokens. Semantic tokens communicate intent, not just values.',
     domain: 'design',
     severity: 'warning',
     tags: ['tokens', 'design-system', 'css'],
@@ -109,7 +116,8 @@ const SEED_ENTRIES: IntelligenceEntry[] = [
   makeEntry({
     id: 'pattern-fts5-search',
     title: 'FTS5 Full-Text Search with Porter Stemming',
-    description: 'Use SQLite FTS5 with porter tokenizer for all text search in the vault. BM25 ranking for relevance.',
+    description:
+      'Use SQLite FTS5 with porter tokenizer for all text search in the vault. BM25 ranking for relevance.',
     domain: 'architecture',
     severity: 'suggestion',
     tags: ['search', 'sqlite', 'fts5'],
@@ -129,7 +137,11 @@ describe('Hybrid search: Cognee → FTS5 → Zettelkasten', () => {
 
     // Create Zettelkasten links between related entries
     linkManager.addLink('pattern-retry-backoff', 'pattern-circuit-breaker', 'extends');
-    linkManager.addLink('anti-pattern-polling-no-timeout', 'pattern-circuit-breaker', 'contradicts');
+    linkManager.addLink(
+      'anti-pattern-polling-no-timeout',
+      'pattern-circuit-breaker',
+      'contradicts',
+    );
     linkManager.addLink('pattern-retry-backoff', 'anti-pattern-polling-no-timeout', 'contradicts');
   });
 
@@ -147,14 +159,14 @@ describe('Hybrid search: Cognee → FTS5 → Zettelkasten', () => {
       const results = await brain.intelligentSearch('retry network requests');
       expect(results.length).toBeGreaterThan(0);
       // Vector score should be 0 for all results (no Cognee)
-      expect(results.every(r => r.breakdown.vector === 0)).toBe(true);
+      expect(results.every((r) => r.breakdown.vector === 0)).toBe(true);
     });
 
     it('should match by keyword in FTS5', async () => {
       const brain = new Brain(vault); // No Cognee at all
 
       const results = await brain.intelligentSearch('exponential backoff');
-      const ids = results.map(r => r.entry.id);
+      const ids = results.map((r) => r.entry.id);
       expect(ids).toContain('pattern-retry-backoff');
     });
 
@@ -163,8 +175,8 @@ describe('Hybrid search: Cognee → FTS5 → Zettelkasten', () => {
 
       const results = await brain.intelligentSearch('networking resilience');
       // Critical entries should rank above suggestion entries for same domain
-      const criticalIdx = results.findIndex(r => r.entry.id === 'pattern-retry-backoff');
-      const suggestionIdx = results.findIndex(r => r.entry.id === 'pattern-fts5-search');
+      const criticalIdx = results.findIndex((r) => r.entry.id === 'pattern-retry-backoff');
+      const suggestionIdx = results.findIndex((r) => r.entry.id === 'pattern-fts5-search');
       if (criticalIdx >= 0 && suggestionIdx >= 0) {
         expect(criticalIdx).toBeLessThan(suggestionIdx);
       }
@@ -192,7 +204,7 @@ describe('Hybrid search: Cognee → FTS5 → Zettelkasten', () => {
       const results = await brain.intelligentSearch('how to handle failing external services');
 
       // Circuit breaker should rank high due to Cognee vector boost
-      const cbResult = results.find(r => r.entry.id === 'pattern-circuit-breaker');
+      const cbResult = results.find((r) => r.entry.id === 'pattern-circuit-breaker');
       expect(cbResult).toBeDefined();
       expect(cbResult!.breakdown.vector).toBeGreaterThan(0);
     });
@@ -212,7 +224,7 @@ describe('Hybrid search: Cognee → FTS5 → Zettelkasten', () => {
       const brain = new Brain(vault, mockCognee);
 
       const results = await brain.intelligentSearch('retry strategy');
-      const retryResult = results.find(r => r.entry.id === 'pattern-retry-backoff');
+      const retryResult = results.find((r) => r.entry.id === 'pattern-retry-backoff');
       expect(retryResult).toBeDefined();
       // Should have vector score from Cognee cross-reference
       expect(retryResult!.breakdown.vector).toBeGreaterThan(0);
@@ -234,7 +246,7 @@ describe('Hybrid search: Cognee → FTS5 → Zettelkasten', () => {
       const brain = new Brain(vault, mockCognee);
 
       const results = await brain.intelligentSearch('design tokens priority');
-      const tokenResult = results.find(r => r.entry.id === 'pattern-token-semantic');
+      const tokenResult = results.find((r) => r.entry.id === 'pattern-token-semantic');
       expect(tokenResult).toBeDefined();
       expect(tokenResult!.breakdown.vector).toBeGreaterThan(0);
     });
@@ -254,7 +266,7 @@ describe('Hybrid search: Cognee → FTS5 → Zettelkasten', () => {
       const brain = new Brain(vault, mockCognee);
 
       const results = await brain.intelligentSearch('retry');
-      const retryResult = results.find(r => r.entry.id === 'pattern-retry-backoff');
+      const retryResult = results.find((r) => r.entry.id === 'pattern-retry-backoff');
       expect(retryResult).toBeDefined();
       // With COGNEE_WEIGHTS, vector component is 35% of total
       // So vector score should contribute meaningfully
@@ -271,7 +283,7 @@ describe('Hybrid search: Cognee → FTS5 → Zettelkasten', () => {
 
       const results = await brain.intelligentSearch('exponential backoff');
       // All results should have vector=0 (no Cognee matches)
-      expect(results.every(r => r.breakdown.vector === 0)).toBe(true);
+      expect(results.every((r) => r.breakdown.vector === 0)).toBe(true);
     });
   });
 
@@ -280,14 +292,16 @@ describe('Hybrid search: Cognee → FTS5 → Zettelkasten', () => {
   describe('graceful degradation', () => {
     it('should fall back to FTS5 when Cognee search throws', async () => {
       const mockCognee = makeMockCognee({ available: true });
-      (mockCognee.search as ReturnType<typeof vi.fn>).mockRejectedValue(new Error('Cognee crashed'));
+      (mockCognee.search as ReturnType<typeof vi.fn>).mockRejectedValue(
+        new Error('Cognee crashed'),
+      );
       const brain = new Brain(vault, mockCognee);
 
       const results = await brain.intelligentSearch('retry backoff');
       // Should still return FTS5 results despite Cognee failure
       expect(results.length).toBeGreaterThan(0);
       // All vector scores should be 0 (Cognee failed)
-      expect(results.every(r => r.breakdown.vector === 0)).toBe(true);
+      expect(results.every((r) => r.breakdown.vector === 0)).toBe(true);
     });
 
     it('should handle Cognee becoming unavailable mid-session', async () => {
@@ -306,7 +320,7 @@ describe('Hybrid search: Cognee → FTS5 → Zettelkasten', () => {
 
       // First search — Cognee available
       const results1 = await brain.intelligentSearch('retry');
-      const hasVector1 = results1.some(r => r.breakdown.vector > 0);
+      const hasVector1 = results1.some((r) => r.breakdown.vector > 0);
       expect(hasVector1).toBe(true);
 
       // Cognee goes down
@@ -315,7 +329,7 @@ describe('Hybrid search: Cognee → FTS5 → Zettelkasten', () => {
       // Second search — should fall back gracefully
       const results2 = await brain.intelligentSearch('retry');
       expect(results2.length).toBeGreaterThan(0);
-      expect(results2.every(r => r.breakdown.vector === 0)).toBe(true);
+      expect(results2.every((r) => r.breakdown.vector === 0)).toBe(true);
     });
   });
 
@@ -356,8 +370,8 @@ describe('Hybrid search: Cognee → FTS5 → Zettelkasten', () => {
       const withoutDomain = await brain.intelligentSearch('resilience');
 
       // When domain filter matches, domainMatch should be higher
-      const archResult = withDomain.find(r => r.entry.domain === 'architecture');
-      const noFilterResult = withoutDomain.find(r => r.entry.id === archResult?.entry.id);
+      const archResult = withDomain.find((r) => r.entry.domain === 'architecture');
+      const noFilterResult = withoutDomain.find((r) => r.entry.id === archResult?.entry.id);
 
       if (archResult && noFilterResult) {
         expect(archResult.breakdown.domainMatch).toBeGreaterThanOrEqual(
@@ -373,7 +387,7 @@ describe('Hybrid search: Cognee → FTS5 → Zettelkasten', () => {
     it('should find connected entries via link traversal', () => {
       // Search finds retry-backoff → traverse links → discover circuit-breaker
       const links = linkManager.getLinks('pattern-retry-backoff');
-      const linkedIds = links.map(l =>
+      const linkedIds = links.map((l) =>
         l.sourceId === 'pattern-retry-backoff' ? l.targetId : l.sourceId,
       );
       expect(linkedIds).toContain('pattern-circuit-breaker');
@@ -383,14 +397,14 @@ describe('Hybrid search: Cognee → FTS5 → Zettelkasten', () => {
     it('should traverse 2 hops to discover indirect connections', () => {
       // retry-backoff → circuit-breaker → polling-no-timeout (via contradicts)
       const traversed = linkManager.traverse('pattern-retry-backoff', 2);
-      const ids = traversed.map(e => e.id);
+      const ids = traversed.map((e) => e.id);
       expect(ids).toContain('pattern-circuit-breaker');
       expect(ids).toContain('anti-pattern-polling-no-timeout');
     });
 
     it('should identify contradicting anti-patterns', () => {
       const links = linkManager.getLinks('anti-pattern-polling-no-timeout');
-      const contradictions = links.filter(l => l.linkType === 'contradicts');
+      const contradictions = links.filter((l) => l.linkType === 'contradicts');
       expect(contradictions.length).toBeGreaterThan(0);
     });
   });
@@ -424,7 +438,7 @@ describe('Hybrid search: Cognee → FTS5 → Zettelkasten', () => {
         type: 'anti-pattern',
       });
       if (results.length > 0) {
-        expect(results.every(r => r.entry.type === 'anti-pattern')).toBe(true);
+        expect(results.every((r) => r.entry.type === 'anti-pattern')).toBe(true);
       }
     });
 
@@ -450,7 +464,7 @@ describe('Hybrid search: Cognee → FTS5 → Zettelkasten', () => {
 
       const results = await brain.intelligentSearch('retry');
       // Should not crash and should use the higher score
-      const retryResult = results.find(r => r.entry.id === 'pattern-retry-backoff');
+      const retryResult = results.find((r) => r.entry.id === 'pattern-retry-backoff');
       expect(retryResult).toBeDefined();
       // Should use max score (0.9, not 0.7)
       expect(retryResult!.breakdown.vector).toBeCloseTo(0.9, 1);