@soleri/core 2.0.2 → 2.1.0

package/src/__tests__/core-ops.test.ts

@@ -34,8 +34,8 @@ describe('createCoreOps', () => {
     return op;
   }
 
-  it('should return 26 ops', () => {
-    expect(ops.length).toBe(26);
+  it('should return 37 ops', () => {
+    expect(ops.length).toBe(37);
   });
 
   it('should have all expected op names', () => {
@@ -63,6 +63,18 @@ describe('createCoreOps', () => {
     expect(names).toContain('rebuild_vocabulary');
     expect(names).toContain('brain_stats');
     expect(names).toContain('llm_status');
+    // Brain Intelligence
+    expect(names).toContain('brain_session_context');
+    expect(names).toContain('brain_strengths');
+    expect(names).toContain('brain_global_patterns');
+    expect(names).toContain('brain_recommend');
+    expect(names).toContain('brain_build_intelligence');
+    expect(names).toContain('brain_export');
+    expect(names).toContain('brain_import');
+    expect(names).toContain('brain_extract_knowledge');
+    expect(names).toContain('brain_archive_sessions');
+    expect(names).toContain('brain_promote_proposals');
+    expect(names).toContain('brain_lifecycle');
     // Curator
     expect(names).toContain('curator_status');
     expect(names).toContain('curator_detect_duplicates');
@@ -75,58 +87,65 @@ describe('createCoreOps', () => {
   });
 
   it('search should query vault via brain', async () => {
-    runtime.vault.seed([{
-      id: 'co-1',
-      type: 'pattern',
-      domain: 'testing',
-      title: 'Test pattern for core ops',
-      severity: 'warning',
-      description: 'Core ops test.',
-      tags: ['test'],
-    }]);
+    runtime.vault.seed([
+      {
+        id: 'co-1',
+        type: 'pattern',
+        domain: 'testing',
+        title: 'Test pattern for core ops',
+        severity: 'warning',
+        description: 'Core ops test.',
+        tags: ['test'],
+      },
+    ]);
     runtime.brain.rebuildVocabulary();
 
     // Re-create ops since brain state changed
     ops = createCoreOps(runtime);
-    const results = await findOp('search').handler({ query: 'core ops test' }) as unknown[];
+    const results = (await findOp('search').handler({ query: 'core ops test' })) as unknown[];
     expect(results.length).toBeGreaterThan(0);
   });
 
   it('vault_stats should return counts', async () => {
-    runtime.vault.seed([{
-      id: 'vs-1',
-      type: 'pattern',
-      domain: 'd1',
-      title: 'T',
-      severity: 'warning',
-      description: 'D',
-      tags: ['t'],
-    }]);
-    const stats = await findOp('vault_stats').handler({}) as { totalEntries: number };
+    runtime.vault.seed([
+      {
+        id: 'vs-1',
+        type: 'pattern',
+        domain: 'd1',
+        title: 'T',
+        severity: 'warning',
+        description: 'D',
+        tags: ['t'],
+      },
+    ]);
+    const stats = (await findOp('vault_stats').handler({})) as { totalEntries: number };
     expect(stats.totalEntries).toBe(1);
   });
 
   it('create_plan + get_plan should work', async () => {
-    const created = await findOp('create_plan').handler({
+    const created = (await findOp('create_plan').handler({
       objective: 'Test plan',
       scope: 'core-ops test',
       tasks: [{ title: 'Task 1', description: 'Do something' }],
-    }) as { created: boolean; plan: { id: string; status: string } };
+    })) as { created: boolean; plan: { id: string; status: string } };
     expect(created.created).toBe(true);
     expect(created.plan.status).toBe('draft');
 
-    const plan = await findOp('get_plan').handler({ planId: created.plan.id }) as { id: string };
+    const plan = (await findOp('get_plan').handler({ planId: created.plan.id })) as { id: string };
     expect(plan.id).toBe(created.plan.id);
   });
 
   it('brain_stats should return stats', async () => {
-    const stats = await findOp('brain_stats').handler({}) as { vocabularySize: number; feedbackCount: number };
+    const stats = (await findOp('brain_stats').handler({})) as {
+      vocabularySize: number;
+      feedbackCount: number;
+    };
     expect(stats.vocabularySize).toBe(0);
     expect(stats.feedbackCount).toBe(0);
   });
 
   it('llm_status should return provider info', async () => {
-    const status = await findOp('llm_status').handler({}) as {
+    const status = (await findOp('llm_status').handler({})) as {
       providers: {
         openai: { available: boolean };
         anthropic: { available: boolean };
@@ -139,22 +158,24 @@ describe('createCoreOps', () => {
   });
 
   it('curator_status should return initialized', async () => {
-    const status = await findOp('curator_status').handler({}) as { initialized: boolean };
+    const status = (await findOp('curator_status').handler({})) as { initialized: boolean };
     expect(status.initialized).toBe(true);
   });
 
   it('curator_health_audit should return score', async () => {
-    runtime.vault.seed([{
-      id: 'ha-1',
-      type: 'pattern',
-      domain: 'testing',
-      title: 'Health pattern',
-      severity: 'warning',
-      description: 'Testing health.',
-      tags: ['health'],
-    }]);
+    runtime.vault.seed([
+      {
+        id: 'ha-1',
+        type: 'pattern',
+        domain: 'testing',
+        title: 'Health pattern',
+        severity: 'warning',
+        description: 'Testing health.',
+        tags: ['health'],
+      },
+    ]);
     runtime.curator.groomAll();
-    const result = await findOp('curator_health_audit').handler({}) as { score: number };
+    const result = (await findOp('curator_health_audit').handler({})) as { score: number };
     expect(result.score).toBeGreaterThan(0);
   });
 
@@ -169,21 +190,28 @@ describe('createCoreOps', () => {
       toolsUsed: [],
     });
 
-    const results = await findOp('memory_search').handler({ query: 'core ops memory' }) as unknown[];
+    const results = (await findOp('memory_search').handler({
+      query: 'core ops memory',
+    })) as unknown[];
     expect(results.length).toBeGreaterThan(0);
   });
 
   it('export should return bundles', async () => {
-    runtime.vault.seed([{
-      id: 'exp-1',
-      type: 'pattern',
-      domain: 'security',
-      title: 'Export test',
-      severity: 'warning',
-      description: 'Testing export.',
-      tags: ['export'],
-    }]);
-    const result = await findOp('export').handler({}) as { exported: boolean; totalEntries: number };
+    runtime.vault.seed([
+      {
+        id: 'exp-1',
+        type: 'pattern',
+        domain: 'security',
+        title: 'Export test',
+        severity: 'warning',
+        description: 'Testing export.',
+        tags: ['export'],
+      },
+    ]);
+    const result = (await findOp('export').handler({})) as {
+      exported: boolean;
+      totalEntries: number;
+    };
     expect(result.exported).toBe(true);
     expect(result.totalEntries).toBe(1);
   });

package/src/__tests__/curator.test.ts

@@ -121,8 +121,16 @@ describe('Curator', () => {
   describe('Duplicate Detection', () => {
     it('should detect duplicates above threshold', () => {
       vault.seed([
-        makeEntry({ id: 'dup-1', title: 'Use semantic tokens for colors', description: 'Always use semantic tokens instead of raw hex values for color styling.' }),
-        makeEntry({ id: 'dup-2', title: 'Use semantic tokens for color values', description: 'Prefer semantic color tokens over raw hex or rgb values in styling.' }),
+        makeEntry({
+          id: 'dup-1',
+          title: 'Use semantic tokens for colors',
+          description: 'Always use semantic tokens instead of raw hex values for color styling.',
+        }),
+        makeEntry({
+          id: 'dup-2',
+          title: 'Use semantic tokens for color values',
+          description: 'Prefer semantic color tokens over raw hex or rgb values in styling.',
+        }),
       ]);
       const results = curator.detectDuplicates(undefined, 0.3);
       expect(results.length).toBeGreaterThan(0);
@@ -134,8 +142,16 @@ describe('Curator', () => {
 
     it('should not detect duplicates below threshold', () => {
       vault.seed([
-        makeEntry({ id: 'uniq-1', title: 'Database indexing strategies', description: 'Create indices on frequently queried columns.' }),
-        makeEntry({ id: 'uniq-2', title: 'React component lifecycle', description: 'Use useEffect for side effects in functional components.' }),
+        makeEntry({
+          id: 'uniq-1',
+          title: 'Database indexing strategies',
+          description: 'Create indices on frequently queried columns.',
+        }),
+        makeEntry({
+          id: 'uniq-2',
+          title: 'React component lifecycle',
+          description: 'Use useEffect for side effects in functional components.',
+        }),
       ]);
       const results = curator.detectDuplicates(undefined, 0.8);
       expect(results.length).toBe(0);
@@ -143,9 +159,21 @@ describe('Curator', () => {
 
     it('should detect duplicates for a specific entry', () => {
       vault.seed([
-        makeEntry({ id: 'spec-1', title: 'Authentication with JWT tokens', description: 'Use JSON Web Tokens for stateless authentication.' }),
-        makeEntry({ id: 'spec-2', title: 'JWT token authentication pattern', description: 'Implement JWT-based authentication for API endpoints.' }),
-        makeEntry({ id: 'spec-3', title: 'Database connection pooling', description: 'Use connection pools for efficient database access.' }),
+        makeEntry({
+          id: 'spec-1',
+          title: 'Authentication with JWT tokens',
+          description: 'Use JSON Web Tokens for stateless authentication.',
+        }),
+        makeEntry({
+          id: 'spec-2',
+          title: 'JWT token authentication pattern',
+          description: 'Implement JWT-based authentication for API endpoints.',
+        }),
+        makeEntry({
+          id: 'spec-3',
+          title: 'Database connection pooling',
+          description: 'Use connection pools for efficient database access.',
+        }),
       ]);
       const results = curator.detectDuplicates('spec-1', 0.3);
       expect(results.length).toBe(1);
@@ -154,8 +182,16 @@ describe('Curator', () => {
 
     it('should suggest merge for high similarity', () => {
       vault.seed([
-        makeEntry({ id: 'merge-1', title: 'Validate user input', description: 'Always validate and sanitize user input before processing.' }),
-        makeEntry({ id: 'merge-2', title: 'Validate user input', description: 'Always validate and sanitize user input before processing.' }),
+        makeEntry({
+          id: 'merge-1',
+          title: 'Validate user input',
+          description: 'Always validate and sanitize user input before processing.',
+        }),
+        makeEntry({
+          id: 'merge-2',
+          title: 'Validate user input',
+          description: 'Always validate and sanitize user input before processing.',
+        }),
       ]);
       const results = curator.detectDuplicates(undefined, 0.3);
       if (results.length > 0 && results[0].matches.length > 0) {
@@ -185,7 +221,8 @@ describe('Curator', () => {
           id: 'ap-inline',
           type: 'anti-pattern',
           title: 'Avoid inline styles for styling',
-          description: 'Never use inline styles — prefer CSS classes or Tailwind utilities for styling.',
+          description:
+            'Never use inline styles — prefer CSS classes or Tailwind utilities for styling.',
           tags: ['styling'],
         }),
       ]);
@@ -219,8 +256,18 @@ describe('Curator', () => {
 
     it('should respect UNIQUE constraint — no duplicate contradictions', () => {
       vault.seed([
-        makeEntry({ id: 'p-dup', type: 'pattern', title: 'Use inline styles', description: 'Apply inline styles for dynamic values.' }),
-        makeEntry({ id: 'ap-dup', type: 'anti-pattern', title: 'Avoid inline styles', description: 'Do not use inline styles.' }),
+        makeEntry({
+          id: 'p-dup',
+          type: 'pattern',
+          title: 'Use inline styles',
+          description: 'Apply inline styles for dynamic values.',
+        }),
+        makeEntry({
+          id: 'ap-dup',
+          type: 'anti-pattern',
+          title: 'Avoid inline styles',
+          description: 'Do not use inline styles.',
+        }),
       ]);
       curator.detectContradictions(0.2);
       const first = curator.getContradictions();
@@ -231,8 +278,18 @@ describe('Curator', () => {
 
     it('should resolve a contradiction', () => {
       vault.seed([
-        makeEntry({ id: 'p-res', type: 'pattern', title: 'Use inline styles', description: 'Apply inline styles.' }),
-        makeEntry({ id: 'ap-res', type: 'anti-pattern', title: 'Avoid inline styles', description: 'Do not use inline styles.' }),
+        makeEntry({
+          id: 'p-res',
+          type: 'pattern',
+          title: 'Use inline styles',
+          description: 'Apply inline styles.',
+        }),
+        makeEntry({
+          id: 'ap-res',
+          type: 'anti-pattern',
+          title: 'Avoid inline styles',
+          description: 'Do not use inline styles.',
+        }),
       ]);
       curator.detectContradictions(0.2);
       const all = curator.getContradictions();
@@ -245,8 +302,18 @@ describe('Curator', () => {
 
     it('should dismiss a contradiction', () => {
       vault.seed([
-        makeEntry({ id: 'p-dis', type: 'pattern', title: 'Use inline styles', description: 'Apply inline styles.' }),
-        makeEntry({ id: 'ap-dis', type: 'anti-pattern', title: 'Avoid inline styles', description: 'Do not use inline styles.' }),
+        makeEntry({
+          id: 'p-dis',
+          type: 'pattern',
+          title: 'Use inline styles',
+          description: 'Apply inline styles.',
+        }),
+        makeEntry({
+          id: 'ap-dis',
+          type: 'anti-pattern',
+          title: 'Avoid inline styles',
+          description: 'Do not use inline styles.',
+        }),
       ]);
       curator.detectContradictions(0.2);
       const all = curator.getContradictions();
@@ -256,8 +323,18 @@ describe('Curator', () => {
 
     it('should list by status', () => {
       vault.seed([
-        makeEntry({ id: 'p-ls', type: 'pattern', title: 'Use inline styles', description: 'Apply inline styles.' }),
-        makeEntry({ id: 'ap-ls', type: 'anti-pattern', title: 'Avoid inline styles', description: 'Do not use inline styles.' }),
+        makeEntry({
+          id: 'p-ls',
+          type: 'pattern',
+          title: 'Use inline styles',
+          description: 'Apply inline styles.',
+        }),
+        makeEntry({
+          id: 'ap-ls',
+          type: 'anti-pattern',
+          title: 'Avoid inline styles',
+          description: 'Do not use inline styles.',
+        }),
       ]);
       curator.detectContradictions(0.2);
       const open = curator.getContradictions('open');
@@ -295,7 +372,9 @@ describe('Curator', () => {
       curator.groomEntry('groom-state');
 
       const db = vault.getDb();
-      const row = db.prepare('SELECT * FROM curator_entry_state WHERE entry_id = ?').get('groom-state') as Record<string, unknown>;
+      const row = db
+        .prepare('SELECT * FROM curator_entry_state WHERE entry_id = ?')
+        .get('groom-state') as Record<string, unknown>;
       expect(row).toBeDefined();
       expect(row.status).toBe('active');
       expect(row.last_groomed_at).not.toBeNull();
@@ -336,8 +415,16 @@ describe('Curator', () => {
 
     it('should find issues in dry-run', () => {
       vault.seed([
-        makeEntry({ id: 'con-1', title: 'Validate user input thoroughly', description: 'Always validate and sanitize all user input before processing.' }),
-        makeEntry({ id: 'con-2', title: 'Validate user input thoroughly', description: 'Always validate and sanitize all user input before processing.' }),
+        makeEntry({
+          id: 'con-1',
+          title: 'Validate user input thoroughly',
+          description: 'Always validate and sanitize all user input before processing.',
+        }),
+        makeEntry({
+          id: 'con-2',
+          title: 'Validate user input thoroughly',
+          description: 'Always validate and sanitize all user input before processing.',
+        }),
       ]);
       const result = curator.consolidate({ dryRun: true, duplicateThreshold: 0.3 });
       expect(result.dryRun).toBe(true);
@@ -369,14 +456,24 @@ describe('Curator', () => {
       expect(result.mutations).toBeGreaterThan(0);
 
       // Check that entry state was archived
-      const row = db.prepare('SELECT status FROM curator_entry_state WHERE entry_id = ?').get('stale-con') as { status: string };
+      const row = db
+        .prepare('SELECT status FROM curator_entry_state WHERE entry_id = ?')
+        .get('stale-con') as { status: string };
       expect(row.status).toBe('archived');
     });
 
     it('should remove duplicates when not dry-run', () => {
       vault.seed([
-        makeEntry({ id: 'rem-1', title: 'Duplicate pattern for removal', description: 'This is a duplicate pattern that should be removed during consolidation.' }),
-        makeEntry({ id: 'rem-2', title: 'Duplicate pattern for removal', description: 'This is a duplicate pattern that should be removed during consolidation.' }),
+        makeEntry({
+          id: 'rem-1',
+          title: 'Duplicate pattern for removal',
+          description: 'This is a duplicate pattern that should be removed during consolidation.',
+        }),
+        makeEntry({
+          id: 'rem-2',
+          title: 'Duplicate pattern for removal',
+          description: 'This is a duplicate pattern that should be removed during consolidation.',
+        }),
       ]);
       const result = curator.consolidate({ dryRun: false, duplicateThreshold: 0.3 });
       expect(result.mutations).toBeGreaterThan(0);
@@ -440,9 +537,7 @@ describe('Curator', () => {
     });
 
     it('should penalize for missing entry types', () => {
-      vault.seed([
-        makeEntry({ id: 'h-p1', type: 'pattern', tags: ['x'] }),
-      ]);
+      vault.seed([makeEntry({ id: 'h-p1', type: 'pattern', tags: ['x'] })]);
       curator.groomAll();
       const result = curator.healthAudit();
       expect(result.score).toBeLessThan(100);
@@ -451,9 +546,7 @@ describe('Curator', () => {
     });
 
     it('should recommend actions for issues', () => {
-      vault.seed([
-        makeEntry({ id: 'h-rec', type: 'pattern', tags: [] }),
-      ]);
+      vault.seed([makeEntry({ id: 'h-rec', type: 'pattern', tags: [] })]);
       const result = curator.healthAudit();
       expect(result.recommendations.length).toBeGreaterThan(0);
     });
@@ -461,7 +554,9 @@ describe('Curator', () => {
     it('should handle empty vault gracefully', () => {
       const result = curator.healthAudit();
       expect(result.score).toBe(100);
-      expect(result.recommendations).toContain('Vault is empty — add knowledge entries to get started.');
+      expect(result.recommendations).toContain(
+        'Vault is empty — add knowledge entries to get started.',
+      );
     });
 
     it('should include tag health metrics', () => {

package/src/__tests__/domain-ops.test.ts

@@ -41,12 +41,28 @@ describe('createDomainFacade', () => {
 
   it('get_patterns should scope to domain', async () => {
     runtime.vault.seed([
-      { id: 'sec-1', type: 'pattern', domain: 'security', title: 'Auth', severity: 'warning', description: 'Auth.', tags: ['auth'] },
-      { id: 'api-1', type: 'pattern', domain: 'api-design', title: 'REST', severity: 'warning', description: 'REST.', tags: ['rest'] },
+      {
+        id: 'sec-1',
+        type: 'pattern',
+        domain: 'security',
+        title: 'Auth',
+        severity: 'warning',
+        description: 'Auth.',
+        tags: ['auth'],
+      },
+      {
+        id: 'api-1',
+        type: 'pattern',
+        domain: 'api-design',
+        title: 'REST',
+        severity: 'warning',
+        description: 'REST.',
+        tags: ['rest'],
+      },
     ]);
     const facade = createDomainFacade(runtime, 'test-domain', 'security');
     const op = facade.ops.find((o) => o.name === 'get_patterns')!;
-    const results = await op.handler({}) as IntelligenceEntry[];
+    const results = (await op.handler({})) as IntelligenceEntry[];
     expect(results.every((e) => e.domain === 'security')).toBe(true);
   });
 
@@ -68,29 +84,45 @@ describe('createDomainFacade', () => {
 
   it('remove should delete entry', async () => {
     runtime.vault.seed([
-      { id: 'rm-1', type: 'pattern', domain: 'security', title: 'Remove me', severity: 'warning', description: 'Remove.', tags: ['test'] },
+      {
+        id: 'rm-1',
+        type: 'pattern',
+        domain: 'security',
+        title: 'Remove me',
+        severity: 'warning',
+        description: 'Remove.',
+        tags: ['test'],
+      },
     ]);
     const facade = createDomainFacade(runtime, 'test-domain', 'security');
     const removeOp = facade.ops.find((o) => o.name === 'remove')!;
-    const result = await removeOp.handler({ id: 'rm-1' }) as { removed: boolean };
+    const result = (await removeOp.handler({ id: 'rm-1' })) as { removed: boolean };
     expect(result.removed).toBe(true);
     expect(runtime.vault.get('rm-1')).toBeNull();
   });
 
   it('get_entry should return specific entry', async () => {
     runtime.vault.seed([
-      { id: 'ge-1', type: 'pattern', domain: 'security', title: 'Get me', severity: 'warning', description: 'Get.', tags: ['test'] },
+      {
+        id: 'ge-1',
+        type: 'pattern',
+        domain: 'security',
+        title: 'Get me',
+        severity: 'warning',
+        description: 'Get.',
+        tags: ['test'],
+      },
     ]);
     const facade = createDomainFacade(runtime, 'test-domain', 'security');
     const getOp = facade.ops.find((o) => o.name === 'get_entry')!;
-    const result = await getOp.handler({ id: 'ge-1' }) as IntelligenceEntry;
+    const result = (await getOp.handler({ id: 'ge-1' })) as IntelligenceEntry;
     expect(result.id).toBe('ge-1');
   });
 
   it('get_entry should return error for missing entry', async () => {
     const facade = createDomainFacade(runtime, 'test-domain', 'security');
     const getOp = facade.ops.find((o) => o.name === 'get_entry')!;
-    const result = await getOp.handler({ id: 'nope' }) as { error: string };
+    const result = (await getOp.handler({ id: 'nope' })) as { error: string };
     expect(result.error).toBeDefined();
   });
 });
@@ -110,7 +142,11 @@ describe('createDomainFacades', () => {
   });
 
   it('should create one facade per domain', () => {
-    const facades = createDomainFacades(runtime, 'test-multi', ['security', 'api-design', 'testing']);
+    const facades = createDomainFacades(runtime, 'test-multi', [
+      'security',
+      'api-design',
+      'testing',
+    ]);
     expect(facades.length).toBe(3);
     expect(facades[0].name).toBe('test-multi_security');
     expect(facades[1].name).toBe('test-multi_api_design');

package/src/__tests__/runtime.test.ts

@@ -58,26 +58,28 @@ describe('createAgentRuntime', () => {
     runtime = null; // already closed
   });
 
-  it('brain should be wired to vault', () => {
+  it('brain should be wired to vault', async () => {
     runtime = createAgentRuntime({
       agentId: 'test-brain-wire',
       vaultPath: ':memory:',
     });
 
     // Seed some data through vault
-    runtime.vault.seed([{
-      id: 'rt-1',
-      type: 'pattern',
-      domain: 'testing',
-      title: 'Runtime test pattern',
-      severity: 'warning',
-      description: 'A test.',
-      tags: ['test'],
-    }]);
+    runtime.vault.seed([
+      {
+        id: 'rt-1',
+        type: 'pattern',
+        domain: 'testing',
+        title: 'Runtime test pattern',
+        severity: 'warning',
+        description: 'A test.',
+        tags: ['test'],
+      },
+    ]);
 
     // Brain should find it
     runtime.brain.rebuildVocabulary();
-    const results = runtime.brain.intelligentSearch('runtime test', { limit: 5 });
+    const results = await runtime.brain.intelligentSearch('runtime test', { limit: 5 });
     expect(results.length).toBeGreaterThan(0);
   });