@soleri/core 2.0.2 → 2.1.0

package/src/curator/curator.ts

@@ -188,7 +188,13 @@ export class Curator {
         JSON.stringify(dedupedTags),
         entryId,
       );
-      this.logChange('normalize_tags', entryId, JSON.stringify(entry.tags), JSON.stringify(dedupedTags), 'Tag normalization');
+      this.logChange(
+        'normalize_tags',
+        entryId,
+        JSON.stringify(entry.tags),
+        JSON.stringify(dedupedTags),
+        'Tag normalization',
+      );
     }
 
     return results;
@@ -245,13 +251,13 @@ export class Curator {
     // Build vectors for all entries
     const vectors = new Map<string, SparseVector>();
     for (const entry of entries) {
-      const text = [entry.title, entry.description, entry.context ?? '', entry.tags.join(' ')].join(' ');
+      const text = [entry.title, entry.description, entry.context ?? '', entry.tags.join(' ')].join(
+        ' ',
+      );
       vectors.set(entry.id, calculateTfIdf(tokenize(text), vocabulary));
     }
 
-    const targetEntries = entryId
-      ? entries.filter((e) => e.id === entryId)
-      : entries;
+    const targetEntries = entryId ? entries.filter((e) => e.id === entryId) : entries;
 
     const results: DuplicateDetectionResult[] = [];
 
@@ -428,7 +434,8 @@ export class Curator {
     const dryRun = options?.dryRun ?? true;
     const staleDaysThreshold = options?.staleDaysThreshold ?? DEFAULT_STALE_DAYS;
     const duplicateThreshold = options?.duplicateThreshold ?? DEFAULT_DUPLICATE_THRESHOLD;
-    const contradictionThreshold = options?.contradictionThreshold ?? DEFAULT_CONTRADICTION_THRESHOLD;
+    const contradictionThreshold =
+      options?.contradictionThreshold ?? DEFAULT_CONTRADICTION_THRESHOLD;
 
     // Detect duplicates
     const duplicates = this.detectDuplicates(undefined, duplicateThreshold);
@@ -455,7 +462,13 @@ export class Curator {
            VALUES (?, 'archived', unixepoch())
            ON CONFLICT(entry_id) DO UPDATE SET status = 'archived', last_groomed_at = unixepoch()`,
         ).run(entryId);
-        this.logChange('archive', entryId, 'active', 'archived', 'Stale entry archived during consolidation');
+        this.logChange(
+          'archive',
+          entryId,
+          'active',
+          'archived',
+          'Stale entry archived during consolidation',
+        );
         mutations++;
       }
 
@@ -526,9 +539,21 @@ export class Curator {
     const hasAntiPatterns = typeCount['anti-pattern'] > 0;
     const hasRules = typeCount.rule > 0;
     let coverageScore = 1;
-    if (!hasPatterns) { score -= 10; coverageScore -= 0.33; recommendations.push('No patterns found — add patterns to improve coverage.'); }
-    if (!hasAntiPatterns) { score -= 5; coverageScore -= 0.17; recommendations.push('No anti-patterns found — add anti-patterns to detect contradictions.'); }
-    if (!hasRules) { score -= 5; coverageScore -= 0.17; recommendations.push('No rules found — add rules for completeness.'); }
+    if (!hasPatterns) {
+      score -= 10;
+      coverageScore -= 0.33;
+      recommendations.push('No patterns found — add patterns to improve coverage.');
+    }
+    if (!hasAntiPatterns) {
+      score -= 5;
+      coverageScore -= 0.17;
+      recommendations.push('No anti-patterns found — add anti-patterns to detect contradictions.');
+    }
+    if (!hasRules) {
+      score -= 5;
+      coverageScore -= 0.17;
+      recommendations.push('No rules found — add rules for completeness.');
+    }
     coverageScore = Math.max(0, coverageScore);
 
     // Freshness: penalize stale entries
@@ -536,14 +561,18 @@ export class Curator {
     const now = Math.floor(Date.now() / 1000);
     const staleThreshold = now - DEFAULT_STALE_DAYS * 86400;
     const staleCount = (
-      db.prepare('SELECT COUNT(*) as count FROM entries WHERE updated_at < ?').get(staleThreshold) as { count: number }
+      db
+        .prepare('SELECT COUNT(*) as count FROM entries WHERE updated_at < ?')
+        .get(staleThreshold) as { count: number }
     ).count;
     const staleRatio = staleCount / entries.length;
     const freshnessScore = 1 - staleRatio;
     if (staleRatio > 0.3) {
       const penalty = Math.min(20, Math.round(staleRatio * 30));
       score -= penalty;
-      recommendations.push(`${staleCount} stale entries (${Math.round(staleRatio * 100)}%) — run grooming to update.`);
+      recommendations.push(
+        `${staleCount} stale entries (${Math.round(staleRatio * 100)}%) — run grooming to update.`,
+      );
     }
 
     // Quality: penalize duplicates and contradictions
@@ -571,12 +600,18 @@ export class Curator {
     if (lowTagRatio > 0.3) {
       const penalty = Math.min(10, Math.round(lowTagRatio * 15));
       score -= penalty;
-      recommendations.push(`${lowTagEntries.length} entries have fewer than 2 tags — improve tagging.`);
+      recommendations.push(
+        `${lowTagEntries.length} entries have fewer than 2 tags — improve tagging.`,
+      );
     }
 
     // Penalize ungroomed entries
     const groomedCount = (
-      db.prepare('SELECT COUNT(*) as count FROM curator_entry_state WHERE last_groomed_at IS NOT NULL').get() as { count: number }
+      db
+        .prepare(
+          'SELECT COUNT(*) as count FROM curator_entry_state WHERE last_groomed_at IS NOT NULL',
+        )
+        .get() as { count: number }
     ).count;
     if (groomedCount < entries.length) {
       const ungroomed = entries.length - groomedCount;
@@ -609,7 +644,9 @@ export class Curator {
     const docCount = entries.length;
     const termDocFreq = new Map<string, number>();
     for (const entry of entries) {
-      const text = [entry.title, entry.description, entry.context ?? '', entry.tags.join(' ')].join(' ');
+      const text = [entry.title, entry.description, entry.context ?? '', entry.tags.join(' ')].join(
+        ' ',
+      );
       const tokens = new Set(tokenize(text));
       for (const token of tokens) {
         termDocFreq.set(token, (termDocFreq.get(token) ?? 0) + 1);

package/src/index.ts

@@ -39,6 +39,7 @@ export type {
 
 // ─── Brain ───────────────────────────────────────────────────────────
 export { Brain } from './brain/brain.js';
+export { BrainIntelligence } from './brain/intelligence.js';
 export type {
   ScoringWeights,
   ScoreBreakdown,
@@ -47,7 +48,31 @@ export type {
   CaptureResult,
   BrainStats,
   QueryContext,
-} from './brain/brain.js';
+  PatternStrength,
+  StrengthsQuery,
+  BrainSession,
+  SessionLifecycleInput,
+  KnowledgeProposal,
+  ExtractionResult,
+  GlobalPattern,
+  DomainProfile,
+  BuildIntelligenceResult,
+  BrainIntelligenceStats,
+  SessionContext,
+  BrainExportData,
+  BrainImportResult,
+} from './brain/types.js';
+
+// ─── Cognee ─────────────────────────────────────────────────────────
+export { CogneeClient } from './cognee/client.js';
+export type {
+  CogneeConfig,
+  CogneeSearchResult,
+  CogneeSearchType,
+  CogneeStatus,
+  CogneeAddResult,
+  CogneeCognifyResult,
+} from './cognee/types.js';
 
 // ─── Planning ────────────────────────────────────────────────────────
 export { Planner } from './planning/planner.js';

package/src/llm/llm-client.ts

@@ -11,12 +11,7 @@ import * as path from 'node:path';
 import { homedir } from 'node:os';
 import { LLMError } from './types.js';
 import { CircuitBreaker, retry, parseRateLimitHeaders } from './utils.js';
-import type {
-  LLMCallOptions,
-  LLMCallResult,
-  RouteEntry,
-  RoutingConfig,
-} from './types.js';
+import type { LLMCallOptions, LLMCallResult, RouteEntry, RoutingConfig } from './types.js';
 import type { KeyPool } from './key-pool.js';
 
 // =============================================================================
@@ -69,7 +64,11 @@ class ModelRouter {
   private config: RoutingConfig;
 
   constructor(config?: RoutingConfig) {
-    this.config = config ?? { routes: [], defaultOpenAIModel: 'gpt-4o-mini', defaultAnthropicModel: 'claude-sonnet-4-20250514' };
+    this.config = config ?? {
+      routes: [],
+      defaultOpenAIModel: 'gpt-4o-mini',
+      defaultAnthropicModel: 'claude-sonnet-4-20250514',
+    };
   }
 
   resolve(
@@ -78,17 +77,13 @@ class ModelRouter {
     originalModel?: string,
   ): { model: string; provider: 'openai' | 'anthropic' } {
     if (task) {
-      const exactMatch = this.config.routes.find(
-        (r) => r.caller === caller && r.task === task,
-      );
+      const exactMatch = this.config.routes.find((r) => r.caller === caller && r.task === task);
       if (exactMatch) {
         return { model: exactMatch.model, provider: exactMatch.provider };
       }
     }
 
-    const callerMatch = this.config.routes.find(
-      (r) => r.caller === caller && !r.task,
-    );
+    const callerMatch = this.config.routes.find((r) => r.caller === caller && !r.task);
     if (callerMatch) {
       return { model: callerMatch.model, provider: callerMatch.provider };
     }
@@ -148,11 +143,7 @@ export class LLMClient {
   }
 
   async complete(options: LLMCallOptions): Promise<LLMCallResult> {
-    const routed = this.router.resolve(
-      options.caller,
-      options.task,
-      options.model,
-    );
+    const routed = this.router.resolve(options.caller, options.task, options.model);
     const resolvedOptions = { ...options, model: routed.model, provider: routed.provider };
 
     return resolvedOptions.provider === 'anthropic'
@@ -219,10 +210,10 @@ export class LLMClient {
         }
 
         const errorBody = await response.text();
-        throw new LLMError(
-          `OpenAI API error: ${response.status} - ${errorBody}`,
-          { retryable: response.status === 429 || response.status >= 500, statusCode: response.status },
-        );
+        throw new LLMError(`OpenAI API error: ${response.status} - ${errorBody}`, {
+          retryable: response.status === 429 || response.status >= 500,
+          statusCode: response.status,
+        });
       }
 
       const data = (await response.json()) as {
@@ -270,7 +261,8 @@ export class LLMClient {
 
           const text = response.content
             .filter(
-              (block): block is { type: 'text'; text: string } => block.type === 'text' && typeof block.text === 'string',
+              (block): block is { type: 'text'; text: string } =>
+                block.type === 'text' && typeof block.text === 'string',
             )
             .map((block) => block.text)
             .join('\n');
@@ -305,7 +297,9 @@ export class LLMClient {
     try {
       // Dynamic import — @anthropic-ai/sdk is an optional peer dep.
       // eslint-disable-next-line @typescript-eslint/no-require-imports
-      const mod = await (Function('return import("@anthropic-ai/sdk")')() as Promise<{ default: new (opts: { apiKey: string }) => AnthropicClient }>);
+      const mod = await (Function('return import("@anthropic-ai/sdk")')() as Promise<{
+        default: new (opts: { apiKey: string }) => AnthropicClient;
+      }>);
       this.anthropicClient = new mod.default({ apiKey: currentKey });
       return this.anthropicClient;
     } catch {

package/src/runtime/core-ops.ts

@@ -1,5 +1,5 @@
 /**
- * Generic core operations factory — 26 ops that every agent gets.
+ * Generic core operations factory — 37 ops that every agent gets.
  *
  * These ops are agent-agnostic (no persona, no activation).
  * The 5 agent-specific ops (health, identity, activate, inject_claude_md, setup)
@@ -12,19 +12,20 @@ import type { IntelligenceEntry } from '../intelligence/types.js';
 import type { AgentRuntime } from './types.js';
 
 /**
- * Create the 26 generic core operations for an agent runtime.
+ * Create the 37 generic core operations for an agent runtime.
  *
  * Groups: search/vault (4), memory (4), export (1), planning (5),
- *         brain (4), curator (8).
+ *         brain (4), brain intelligence (11), curator (8).
  */
 export function createCoreOps(runtime: AgentRuntime): OpDefinition[] {
-  const { vault, brain, planner, curator, llmClient, keyPool } = runtime;
+  const { vault, brain, brainIntelligence, planner, curator, llmClient, keyPool } = runtime;
 
   return [
     // ─── Search / Vault ──────────────────────────────────────────
     {
       name: 'search',
-      description: 'Search across all knowledge domains. Results ranked by TF-IDF + severity + recency + tag overlap + domain match.',
+      description:
+        'Search across all knowledge domains. Results ranked by TF-IDF + severity + recency + tag overlap + domain match.',
       auth: 'read',
       schema: z.object({
         query: z.string(),
@@ -75,7 +76,8 @@ export function createCoreOps(runtime: AgentRuntime): OpDefinition[] {
     },
     {
       name: 'register',
-      description: 'Register a project for this session. Call on every new session to track usage and get context.',
+      description:
+        'Register a project for this session. Call on every new session to track usage and get context.',
       auth: 'write',
       schema: z.object({
         projectPath: z.string().optional().default('.'),
@@ -167,7 +169,8 @@ export function createCoreOps(runtime: AgentRuntime): OpDefinition[] {
     },
     {
       name: 'session_capture',
-      description: 'Capture a session summary before context compaction. Called automatically by PreCompact hook.',
+      description:
+        'Capture a session summary before context compaction. Called automatically by PreCompact hook.',
       auth: 'write',
       schema: z.object({
         projectPath: z.string().optional().default('.'),
@@ -195,17 +198,17 @@ export function createCoreOps(runtime: AgentRuntime): OpDefinition[] {
     // ─── Export ───────────────────────────────────────────────────
     {
       name: 'export',
-      description: 'Export vault entries as JSON intelligence bundles — one per domain. Enables version control and sharing.',
+      description:
+        'Export vault entries as JSON intelligence bundles — one per domain. Enables version control and sharing.',
       auth: 'read',
       schema: z.object({
         domain: z.string().optional().describe('Export only this domain. Omit to export all.'),
       }),
       handler: async (params) => {
         const stats = vault.stats();
-        const domains = params.domain
-          ? [params.domain as string]
-          : Object.keys(stats.byDomain);
-        const bundles: Array<{ domain: string; version: string; entries: IntelligenceEntry[] }> = [];
+        const domains = params.domain ? [params.domain as string] : Object.keys(stats.byDomain);
+        const bundles: Array<{ domain: string; version: string; entries: IntelligenceEntry[] }> =
+          [];
         for (const d of domains) {
           const entries = vault.list({ domain: d, limit: 10000 });
           bundles.push({ domain: d, version: '1.0.0', entries });
@@ -222,13 +225,17 @@ export function createCoreOps(runtime: AgentRuntime): OpDefinition[] {
     // ─── Planning ────────────────────────────────────────────────
     {
       name: 'create_plan',
-      description: 'Create a new plan in draft status. Plans track multi-step tasks with decisions and sub-tasks.',
+      description:
+        'Create a new plan in draft status. Plans track multi-step tasks with decisions and sub-tasks.',
       auth: 'write',
       schema: z.object({
         objective: z.string().describe('What the plan aims to achieve'),
         scope: z.string().describe('Which parts of the codebase are affected'),
         decisions: z.array(z.string()).optional().default([]),
-        tasks: z.array(z.object({ title: z.string(), description: z.string() })).optional().default([]),
+        tasks: z
+          .array(z.object({ title: z.string(), description: z.string() }))
+          .optional()
+          .default([]),
       }),
       handler: async (params) => {
         const plan = planner.create({
@@ -262,7 +269,11 @@ export function createCoreOps(runtime: AgentRuntime): OpDefinition[] {
       auth: 'write',
       schema: z.object({
         planId: z.string(),
-        startExecution: z.boolean().optional().default(false).describe('If true, immediately start execution after approval'),
+        startExecution: z
+          .boolean()
+          .optional()
+          .default(false)
+          .describe('If true, immediately start execution after approval'),
       }),
       handler: async (params) => {
         let plan = planner.approve(params.planId as string);
@@ -313,7 +324,8 @@ export function createCoreOps(runtime: AgentRuntime): OpDefinition[] {
     // ─── Brain ───────────────────────────────────────────────────
     {
       name: 'record_feedback',
-      description: 'Record feedback on a search result — accepted or dismissed. Used for adaptive weight tuning.',
+      description:
+        'Record feedback on a search result — accepted or dismissed. Used for adaptive weight tuning.',
       auth: 'write',
       schema: z.object({
         query: z.string().describe('The original search query'),
@@ -326,7 +338,12 @@ export function createCoreOps(runtime: AgentRuntime): OpDefinition[] {
           params.entryId as string,
           params.action as 'accepted' | 'dismissed',
         );
-        return { recorded: true, query: params.query, entryId: params.entryId, action: params.action };
+        return {
+          recorded: true,
+          query: params.query,
+          entryId: params.entryId,
+          action: params.action,
+        };
       },
     },
     {
@@ -340,15 +357,19 @@ export function createCoreOps(runtime: AgentRuntime): OpDefinition[] {
     },
     {
       name: 'brain_stats',
-      description: 'Get brain intelligence stats — vocabulary size, feedback count, current scoring weights.',
+      description:
+        'Get brain intelligence stats — vocabulary size, feedback count, current scoring weights, intelligence pipeline stats.',
       auth: 'read',
       handler: async () => {
-        return brain.getStats();
+        const base = brain.getStats();
+        const intelligence = brainIntelligence.getStats();
+        return { ...base, intelligence };
       },
     },
     {
       name: 'llm_status',
-      description: 'LLM client status — provider availability, key pool status, model routing config.',
+      description:
+        'LLM client status — provider availability, key pool status, model routing config.',
       auth: 'read',
       handler: async () => {
         const available = llmClient.isAvailable();
@@ -368,6 +389,165 @@ export function createCoreOps(runtime: AgentRuntime): OpDefinition[] {
       },
     },
 
+    // ─── Brain Intelligence ───────────────────────────────────────
+    {
+      name: 'brain_session_context',
+      description:
+        'Get recent session context — sessions, tool usage frequency, file change frequency.',
+      auth: 'read',
+      schema: z.object({
+        limit: z.number().optional().describe('Number of recent sessions. Default 10.'),
+      }),
+      handler: async (params) => {
+        return brainIntelligence.getSessionContext((params.limit as number) ?? 10);
+      },
+    },
+    {
+      name: 'brain_strengths',
+      description:
+        'Get pattern strength scores. 4-signal scoring: usage (0-25) + spread (0-25) + success (0-25) + recency (0-25).',
+      auth: 'read',
+      schema: z.object({
+        domain: z.string().optional(),
+        minStrength: z.number().optional().describe('Minimum strength score (0-100).'),
+        limit: z.number().optional(),
+      }),
+      handler: async (params) => {
+        return brainIntelligence.getStrengths({
+          domain: params.domain as string | undefined,
+          minStrength: params.minStrength as number | undefined,
+          limit: (params.limit as number) ?? 50,
+        });
+      },
+    },
+    {
+      name: 'brain_global_patterns',
+      description:
+        'Get cross-domain pattern registry — patterns that appear across multiple domains.',
+      auth: 'read',
+      schema: z.object({
+        limit: z.number().optional(),
+      }),
+      handler: async (params) => {
+        return brainIntelligence.getGlobalPatterns((params.limit as number) ?? 20);
+      },
+    },
+    {
+      name: 'brain_recommend',
+      description:
+        'Get pattern recommendations for a task context. Matches domain and task terms against known strengths.',
+      auth: 'read',
+      schema: z.object({
+        domain: z.string().optional(),
+        task: z.string().optional().describe('Task description for contextual matching.'),
+        limit: z.number().optional(),
+      }),
+      handler: async (params) => {
+        return brainIntelligence.recommend({
+          domain: params.domain as string | undefined,
+          task: params.task as string | undefined,
+          limit: (params.limit as number) ?? 5,
+        });
+      },
+    },
+    {
+      name: 'brain_build_intelligence',
+      description:
+        'Run the full intelligence pipeline: compute strengths → build global registry → build domain profiles.',
+      auth: 'write',
+      handler: async () => {
+        return brainIntelligence.buildIntelligence();
+      },
+    },
+    {
+      name: 'brain_export',
+      description:
+        'Export all brain intelligence data — strengths, sessions, proposals, global patterns, domain profiles.',
+      auth: 'read',
+      handler: async () => {
+        return brainIntelligence.exportData();
+      },
+    },
+    {
+      name: 'brain_import',
+      description: 'Import brain intelligence data from a previous export.',
+      auth: 'write',
+      schema: z.object({
+        data: z.any().describe('BrainExportData object from brain_export.'),
+      }),
+      handler: async (params) => {
+        return brainIntelligence.importData(
+          params.data as import('../brain/types.js').BrainExportData,
+        );
+      },
+    },
+    {
+      name: 'brain_extract_knowledge',
+      description:
+        'Extract knowledge proposals from a session using 6 heuristic rules (repeated tools, multi-file edits, long sessions, plan outcomes, feedback ratios).',
+      auth: 'write',
+      schema: z.object({
+        sessionId: z.string().describe('Session ID to extract knowledge from.'),
+      }),
+      handler: async (params) => {
+        return brainIntelligence.extractKnowledge(params.sessionId as string);
+      },
+    },
+    {
+      name: 'brain_archive_sessions',
+      description: 'Archive (delete) completed sessions older than N days.',
+      auth: 'write',
+      schema: z.object({
+        olderThanDays: z.number().optional().describe('Days threshold. Default 30.'),
+      }),
+      handler: async (params) => {
+        return brainIntelligence.archiveSessions((params.olderThanDays as number) ?? 30);
+      },
+    },
+    {
+      name: 'brain_promote_proposals',
+      description:
+        'Promote knowledge proposals to vault entries. Creates intelligence entries from auto-extracted patterns.',
+      auth: 'write',
+      schema: z.object({
+        proposalIds: z.array(z.string()).describe('IDs of proposals to promote.'),
+      }),
+      handler: async (params) => {
+        return brainIntelligence.promoteProposals(params.proposalIds as string[]);
+      },
+    },
+    {
+      name: 'brain_lifecycle',
+      description:
+        'Start or end a brain session. Sessions track tool usage, file changes, and plan context.',
+      auth: 'write',
+      schema: z.object({
+        action: z.enum(['start', 'end']),
+        sessionId: z
+          .string()
+          .optional()
+          .describe('Required for end. Auto-generated for start if omitted.'),
+        domain: z.string().optional(),
+        context: z.string().optional(),
+        toolsUsed: z.array(z.string()).optional(),
+        filesModified: z.array(z.string()).optional(),
+        planId: z.string().optional(),
+        planOutcome: z.string().optional(),
+      }),
+      handler: async (params) => {
+        return brainIntelligence.lifecycle({
+          action: params.action as 'start' | 'end',
+          sessionId: params.sessionId as string | undefined,
+          domain: params.domain as string | undefined,
+          context: params.context as string | undefined,
+          toolsUsed: params.toolsUsed as string[] | undefined,
+          filesModified: params.filesModified as string[] | undefined,
+          planId: params.planId as string | undefined,
+          planOutcome: params.planOutcome as string | undefined,
+        });
+      },
+    },
+
     // ─── Curator ─────────────────────────────────────────────────
     {
       name: 'curator_status',
@@ -404,7 +584,9 @@ export function createCoreOps(runtime: AgentRuntime): OpDefinition[] {
         if (params.detect) {
           curator.detectContradictions();
         }
-        return curator.getContradictions(params.status as 'open' | 'resolved' | 'dismissed' | undefined);
+        return curator.getContradictions(
+          params.status as 'open' | 'resolved' | 'dismissed' | undefined,
+        );
       },
     },
     {
@@ -443,13 +625,23 @@ export function createCoreOps(runtime: AgentRuntime): OpDefinition[] {
     },
     {
       name: 'curator_consolidate',
-      description: 'Consolidate vault — find duplicates, stale entries, contradictions. Dry-run by default.',
+      description:
+        'Consolidate vault — find duplicates, stale entries, contradictions. Dry-run by default.',
       auth: 'write',
       schema: z.object({
         dryRun: z.boolean().optional().describe('Default true. Set false to apply mutations.'),
-        staleDaysThreshold: z.number().optional().describe('Days before entry is stale. Default 90.'),
-        duplicateThreshold: z.number().optional().describe('Cosine similarity threshold. Default 0.45.'),
-        contradictionThreshold: z.number().optional().describe('Contradiction threshold. Default 0.4.'),
+        staleDaysThreshold: z
+          .number()
+          .optional()
+          .describe('Days before entry is stale. Default 90.'),
+        duplicateThreshold: z
+          .number()
+          .optional()
+          .describe('Cosine similarity threshold. Default 0.45.'),
+        contradictionThreshold: z
+          .number()
+          .optional()
+          .describe('Contradiction threshold. Default 0.4.'),
       }),
       handler: async (params) => {
         return curator.consolidate({
@@ -462,7 +654,8 @@ export function createCoreOps(runtime: AgentRuntime): OpDefinition[] {
     },
     {
       name: 'curator_health_audit',
-      description: 'Audit vault health — score (0-100), coverage, freshness, quality, tag health, recommendations.',
+      description:
+        'Audit vault health — score (0-100), coverage, freshness, quality, tag health, recommendations.',
       auth: 'read',
       handler: async () => {
         return curator.healthAudit();

package/src/runtime/runtime.ts

@@ -11,6 +11,7 @@ import { join } from 'node:path';
 import { homedir } from 'node:os';
 import { Vault } from '../vault/vault.js';
 import { Brain } from '../brain/brain.js';
+import { BrainIntelligence } from '../brain/intelligence.js';
 import { Planner } from '../planning/planner.js';
 import { Curator } from '../curator/curator.js';
 import { KeyPool, loadKeyPoolConfig } from '../llm/key-pool.js';
@@ -49,6 +50,9 @@ export function createAgentRuntime(config: AgentRuntimeConfig): AgentRuntime {
   // Brain — intelligence layer (TF-IDF scoring, auto-tagging, dedup)
   const brain = new Brain(vault);
 
+  // Brain Intelligence — pattern strengths, session knowledge, intelligence pipeline
+  const brainIntelligence = new BrainIntelligence(vault, brain);
+
   // Curator — vault self-maintenance (dedup, contradictions, grooming, health)
   const curator = new Curator(vault);
 
@@ -62,6 +66,7 @@ export function createAgentRuntime(config: AgentRuntimeConfig): AgentRuntime {
     config,
     vault,
     brain,
+    brainIntelligence,
     planner,
     curator,
     keyPool: { openai: openaiKeyPool, anthropic: anthropicKeyPool },

package/src/runtime/types.ts

@@ -1,5 +1,6 @@
 import type { Vault } from '../vault/vault.js';
 import type { Brain } from '../brain/brain.js';
+import type { BrainIntelligence } from '../brain/intelligence.js';
 import type { Planner } from '../planning/planner.js';
 import type { Curator } from '../curator/curator.js';
 import type { KeyPool } from '../llm/key-pool.js';
@@ -28,6 +29,7 @@ export interface AgentRuntime {
   config: AgentRuntimeConfig;
   vault: Vault;
   brain: Brain;
+  brainIntelligence: BrainIntelligence;
   planner: Planner;
   curator: Curator;
   keyPool: { openai: KeyPool; anthropic: KeyPool };