@soleri/core 8.0.0 → 9.0.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@soleri/core",
-  "version": "8.0.0",
+  "version": "9.0.0",
   "description": "Shared engine for Soleri agents — vault, brain, planner, LLM utilities, and facade infrastructure.",
   "keywords": [
     "agent",
@@ -31,6 +31,10 @@
     ".": {
       "types": "./dist/index.d.ts",
       "import": "./dist/index.js"
+    },
+    "./module-manifest": {
+      "types": "./dist/engine/module-manifest.d.ts",
+      "import": "./dist/engine/module-manifest.js"
     }
   },
   "publishConfig": {
@@ -50,7 +54,6 @@
   "devDependencies": {
     "@types/better-sqlite3": "^7.6.13",
     "@types/pdf-parse": "^1.1.5",
-    "@types/pg": "^8.11.0",
     "@vitest/coverage-v8": "^4.0.18"
   },
   "peerDependencies": {
@@ -69,7 +72,6 @@
     "node": ">=18.0.0"
   },
   "optionalDependencies": {
-    "pdf-parse": "^1.1.4",
-    "pg": "^8.13.0"
+    "pdf-parse": "^1.1.4"
   }
 }

package/src/__tests__/curator-pipeline-e2e.test.ts

@@ -94,6 +94,56 @@ beforeAll(() => {
     if (!entry) return { skipped: true, reason: 'entry not found' };
     return classifyEntry(entry, null); // No LLM in tests
   });
+
+  // ─── 9 additional handlers for full Salvador parity (#216) ────
+  runner.registerHandler('enrich-frontmatter', async (job) => {
+    const entry = vault.get(job.entryId ?? '');
+    if (!entry) return { skipped: true, reason: 'entry not found' };
+    return curator.enrichMetadata(entry.id);
+  });
+  runner.registerHandler('detect-staleness', async (job) => {
+    const entry = vault.get(job.entryId ?? '');
+    if (!entry) return { skipped: true, reason: 'entry not found' };
+    const entryTimestamp = (entry.validFrom ?? 0) * 1000 || Date.now();
+    const ageMs = Date.now() - entryTimestamp;
+    const isStale = ageMs > 90 * 86400000;
+    return { stale: isStale, ageDays: Math.floor(ageMs / 86400000), entryId: entry.id };
+  });
+  runner.registerHandler('detect-duplicate', async (job) => {
+    const entry = vault.get(job.entryId ?? '');
+    if (!entry) return { skipped: true, reason: 'entry not found' };
+    return curator.detectDuplicates(entry.id);
+  });
+  runner.registerHandler('detect-contradiction', async (job) => {
+    const entry = vault.get(job.entryId ?? '');
+    if (!entry) return { skipped: true, reason: 'entry not found' };
+    const contradictions = curator.detectContradictions(0.4);
+    const relevant = contradictions.filter(
+      (c) => c.patternId === job.entryId || c.antipatternId === job.entryId,
+    );
+    return { found: relevant.length, contradictions: relevant };
+  });
+  runner.registerHandler('consolidate-duplicates', async () => {
+    return curator.consolidate({ dryRun: false, staleDaysThreshold: 90 });
+  });
+  runner.registerHandler('archive-stale', async () => {
+    const result = curator.consolidate({ dryRun: false, staleDaysThreshold: 90 });
+    return { archived: result.staleEntries.length, result };
+  });
+  runner.registerHandler('cognee-ingest', async (job) => {
+    // No Cognee in tests — graceful degradation
+    return { skipped: true, reason: 'cognee not available' };
+  });
+  runner.registerHandler('cognee-cognify', async () => {
+    return { skipped: true, reason: 'cognee not available' };
+  });
+  runner.registerHandler('verify-searchable', async (job) => {
+    const entry = vault.get(job.entryId ?? '');
+    if (!entry) return { skipped: true, reason: 'entry not found' };
+    const searchResults = vault.search(entry.title, { limit: 1 });
+    const found = searchResults.some((r) => r.entry.id === entry.id);
+    return { searchable: found, entryId: entry.id };
+  });
 });
 
 afterAll(() => {
@@ -266,6 +316,143 @@ describe('Classifier — graceful degradation', () => {
   });
 });
 
+// ─── Salvador Parity Handlers (#216) ─────────────────────────────────
+
+describe('Pipeline Runner — Salvador parity handlers (#216)', () => {
+  it('enrich-frontmatter enriches entry metadata', async () => {
+    const id = queue.enqueue('enrich-frontmatter', { entryId: 'pattern-circuit-breaker' });
+    await runner.processOnce();
+    const job = queue.get(id);
+    expect(job!.status).toBe('completed');
+    expect(job!.result).toBeDefined();
+  });
+
+  it('detect-staleness checks entry age', async () => {
+    const id = queue.enqueue('detect-staleness', { entryId: 'pattern-circuit-breaker' });
+    await runner.processOnce();
+    const job = queue.get(id);
+    expect(job!.status).toBe('completed');
+    const result = job!.result as { stale: boolean; ageDays: number };
+    expect(typeof result.stale).toBe('boolean');
+    expect(typeof result.ageDays).toBe('number');
+  });
+
+  it('detect-duplicate runs dedup on specific entry', async () => {
+    const id = queue.enqueue('detect-duplicate', { entryId: 'pattern-circuit-breaker' });
+    await runner.processOnce();
+    const job = queue.get(id);
+    expect(job!.status).toBe('completed');
+    expect(job!.result).toBeDefined();
+  });
+
+  it('detect-contradiction finds pattern/anti-pattern conflicts', async () => {
+    const id = queue.enqueue('detect-contradiction', { entryId: 'pattern-circuit-breaker' });
+    await runner.processOnce();
+    const job = queue.get(id);
+    expect(job!.status).toBe('completed');
+    const result = job!.result as { found: number };
+    expect(typeof result.found).toBe('number');
+  });
+
+  it('consolidate-duplicates runs consolidation', async () => {
+    const id = queue.enqueue('consolidate-duplicates', {});
+    await runner.processOnce();
+    const job = queue.get(id);
+    expect(job!.status).toBe('completed');
+    expect(job!.result).toBeDefined();
+  });
+
+  it('archive-stale archives old entries', async () => {
+    const id = queue.enqueue('archive-stale', {});
+    await runner.processOnce();
+    const job = queue.get(id);
+    expect(job!.status).toBe('completed');
+    const result = job!.result as { archived: number };
+    expect(typeof result.archived).toBe('number');
+  });
+
+  it('cognee-ingest degrades gracefully without Cognee', async () => {
+    const id = queue.enqueue('cognee-ingest', { entryId: 'pattern-circuit-breaker' });
+    await runner.processOnce();
+    const job = queue.get(id);
+    expect(job!.status).toBe('completed');
+    expect((job!.result as Record<string, unknown>).skipped).toBe(true);
+  });
+
+  it('cognee-cognify degrades gracefully without Cognee', async () => {
+    const id = queue.enqueue('cognee-cognify', {});
+    await runner.processOnce();
+    const job = queue.get(id);
+    expect(job!.status).toBe('completed');
+    expect((job!.result as Record<string, unknown>).skipped).toBe(true);
+  });
+
+  it('verify-searchable confirms entry is FTS-indexed', async () => {
+    const id = queue.enqueue('verify-searchable', { entryId: 'pattern-circuit-breaker' });
+    await runner.processOnce();
+    const job = queue.get(id);
+    expect(job!.status).toBe('completed');
+    const result = job!.result as { searchable: boolean };
+    expect(result.searchable).toBe(true);
+  });
+
+  it('all handlers handle missing entries gracefully', async () => {
+    const types = [
+      'enrich-frontmatter',
+      'detect-staleness',
+      'detect-duplicate',
+      'detect-contradiction',
+      'verify-searchable',
+    ];
+    for (const type of types) {
+      const id = queue.enqueue(type, { entryId: 'nonexistent' });
+      await runner.processOnce();
+      const job = queue.get(id);
+      expect(job!.status).toBe('completed');
+      expect((job!.result as Record<string, unknown>).skipped).toBe(true);
+    }
+  });
+});
+
+describe('Full Salvador DAG — 8-step curator pipeline', () => {
+  it('runs the complete quality pipeline in DAG order', async () => {
+    const entryId = 'pattern-semantic-tokens';
+    const pipelineId = 'full-salvador-dag';
+
+    const step1 = queue.enqueue('quality-gate', { entryId, pipelineId });
+    const step2 = queue.enqueue('enrich-frontmatter', { entryId, pipelineId, dependsOn: [step1] });
+    const step3 = queue.enqueue('tag-normalize', { entryId, pipelineId, dependsOn: [step2] });
+    const step4 = queue.enqueue('dedup-check', { entryId, pipelineId, dependsOn: [step3] });
+    const step5 = queue.enqueue('detect-contradiction', {
+      entryId,
+      pipelineId,
+      dependsOn: [step4],
+    });
+    const step6 = queue.enqueue('cognee-ingest', { entryId, pipelineId, dependsOn: [step5] });
+    const step7 = queue.enqueue('auto-link', { entryId, pipelineId, dependsOn: [step6] });
+    const step8 = queue.enqueue('verify-searchable', { entryId, pipelineId, dependsOn: [step7] });
+
+    // Drain the DAG
+    for (let i = 0; i < 15; i++) {
+      await runner.processOnce(20);
+    }
+
+    const jobs = queue.getByPipeline(pipelineId);
+    const statuses = jobs.map((j) => `${j.type}:${j.status}`);
+
+    expect(statuses).toEqual([
+      'quality-gate:completed',
+      'enrich-frontmatter:completed',
+      'tag-normalize:completed',
+      'dedup-check:completed',
+      'detect-contradiction:completed',
+      'cognee-ingest:completed',
+      'auto-link:completed',
+      'verify-searchable:completed',
+    ]);
+  });
+});
+
 // ─── Event Bus Integration ──────────────────────────────────────────
 
 describe('Event Bus — curator events', () => {

package/src/__tests__/module-manifest-drift.test.ts

@@ -0,0 +1,59 @@
+/**
+ * Contract Drift Detection — Issue #227
+ *
+ * Ensures ENGINE_MODULE_MANIFEST (used by forge for template generation)
+ * stays in sync with ENGINE_MODULES (used by register-engine at runtime).
+ *
+ * If this test fails, someone added/removed/renamed a module in one place
+ * but not the other. Fix by updating both files to match.
+ */
+
+import { describe, it, expect } from 'vitest';
+import { ENGINE_MODULE_MANIFEST } from '../engine/module-manifest.js';
+import { ENGINE_MODULES } from '../engine/register-engine.js';
+
+describe('Module manifest drift detection', () => {
+  const manifestSuffixes = ENGINE_MODULE_MANIFEST.map((m) => m.suffix);
+  const runtimeSuffixes = ENGINE_MODULES.map((m) => m.suffix);
+
+  it('manifest and runtime have the same number of modules', () => {
+    expect(manifestSuffixes).toHaveLength(runtimeSuffixes.length);
+  });
+
+  it('manifest and runtime have identical suffixes in the same order', () => {
+    expect(manifestSuffixes).toEqual(runtimeSuffixes);
+  });
+
+  it('conditional flags match between manifest and runtime', () => {
+    for (const manifest of ENGINE_MODULE_MANIFEST) {
+      const runtime = ENGINE_MODULES.find((m) => m.suffix === manifest.suffix);
+      expect(runtime, `module "${manifest.suffix}" missing from ENGINE_MODULES`).toBeDefined();
+
+      const runtimeConditional = runtime!.condition !== undefined;
+      const manifestConditional = manifest.conditional === true;
+
+      expect(runtimeConditional, `conditional flag mismatch for "${manifest.suffix}"`).toBe(
+        manifestConditional,
+      );
+    }
+  });
+
+  it('no runtime module is missing from manifest', () => {
+    for (const runtime of ENGINE_MODULES) {
+      const manifest = ENGINE_MODULE_MANIFEST.find((m) => m.suffix === runtime.suffix);
+      expect(
+        manifest,
+        `module "${runtime.suffix}" exists in ENGINE_MODULES but missing from ENGINE_MODULE_MANIFEST`,
+      ).toBeDefined();
+    }
+  });
+
+  it('every manifest entry has at least one keyOp', () => {
+    for (const entry of ENGINE_MODULE_MANIFEST) {
+      expect(
+        entry.keyOps.length,
+        `module "${entry.suffix}" has empty keyOps — placeholder tables need at least one op`,
+      ).toBeGreaterThan(0);
+    }
+  });
+});

package/src/brain/brain.ts

@@ -10,7 +10,6 @@ import {
   cosineSimilarity,
   jaccardSimilarity,
 } from '../text/similarity.js';
-import type { CogneeClient } from '../cognee/client.js';
 import type {
   ScoringWeights,
   ScoreBreakdown,
@@ -44,15 +43,6 @@ const DEFAULT_WEIGHTS: ScoringWeights = {
   domainMatch: 0.15,
 };
 
-const COGNEE_WEIGHTS: ScoringWeights = {
-  semantic: 0.25,
-  vector: 0.35,
-  severity: 0.1,
-  temporalDecay: 0.1,
-  tagOverlap: 0.1,
-  domainMatch: 0.1,
-};
-
 const WEIGHT_BOUND = 0.15;
 const FEEDBACK_THRESHOLD = 30;
 const DUPLICATE_BLOCK_THRESHOLD = 0.8;
@@ -62,14 +52,12 @@ const RECENCY_HALF_LIFE_DAYS = 365;
 export class Brain {
   private vault: Vault;
   private vaultManager: VaultManager | undefined;
-  private cognee: CogneeClient | undefined;
   private vocabulary: Map<string, number> = new Map();
   private weights: ScoringWeights = { ...DEFAULT_WEIGHTS };
 
-  constructor(vault: Vault, cognee?: CogneeClient, vaultManager?: VaultManager) {
+  constructor(vault: Vault, vaultManager?: VaultManager) {
     this.vault = vault;
     this.vaultManager = vaultManager;
-    this.cognee = cognee;
     this.rebuildVocabulary();
     this.recomputeWeights();
   }
@@ -102,97 +90,6 @@ export class Brain {
       });
     }
 
-    // Cognee vector search (parallel, with timeout fallback)
-    let cogneeScoreMap: Map<string, number> = new Map();
-    const cogneeAvailable = this.cognee?.isAvailable ?? false;
-    if (cogneeAvailable && this.cognee) {
-      try {
-        const cogneeResults = await this.cognee.search(query, { limit: Math.max(limit * 2, 20) });
-
-        // Build title → entryIds reverse index from FTS results for text-based matching.
-        // Cognee assigns its own UUIDs to chunks and may strip embedded metadata during
-        // chunking, so we need multiple strategies to cross-reference results.
-        // Multiple entries can share a title, so map to arrays of IDs.
-        const titleToIds = new Map<string, string[]>();
-        for (const r of rawResults) {
-          const key = r.entry.title.toLowerCase().trim();
-          const ids = titleToIds.get(key) ?? [];
-          ids.push(r.entry.id);
-          titleToIds.set(key, ids);
-        }
-
-        const vaultIdPattern = /\[vault-id:([^\]]+)\]/;
-        const unmatchedCogneeResults: Array<{ text: string; score: number }> = [];
-
-        for (const cr of cogneeResults) {
-          const text = cr.text ?? '';
-
-          // Strategy 1: Extract vault ID from [vault-id:XXX] prefix (if Cognee preserved it)
-          const vaultIdMatch = text.match(vaultIdPattern);
-          if (vaultIdMatch) {
-            const vaultId = vaultIdMatch[1];
-            cogneeScoreMap.set(vaultId, Math.max(cogneeScoreMap.get(vaultId) ?? 0, cr.score));
-            continue;
-          }
-
-          // Strategy 2: Match first line of chunk text against known entry titles.
-          // serializeEntry() puts the title on the first line after the [vault-id:] prefix,
-          // and Cognee's chunking typically preserves this as the chunk start.
-          const firstLine = text.split('\n')[0]?.trim().toLowerCase() ?? '';
-          const matchedIds = firstLine ? titleToIds.get(firstLine) : undefined;
-          if (matchedIds) {
-            for (const id of matchedIds) {
-              cogneeScoreMap.set(id, Math.max(cogneeScoreMap.get(id) ?? 0, cr.score));
-            }
-            continue;
-          }
-
-          // Strategy 3: Check if any known title appears as a substring in the chunk.
-          // Handles cases where the title isn't on the first line (mid-document chunks).
-          const textLower = text.toLowerCase();
-          let found = false;
-          for (const [title, ids] of titleToIds) {
-            if (title.length >= 8 && textLower.includes(title)) {
-              for (const id of ids) {
-                cogneeScoreMap.set(id, Math.max(cogneeScoreMap.get(id) ?? 0, cr.score));
-              }
-              found = true;
-              break;
-            }
-          }
-          if (!found && text.length > 0) {
-            unmatchedCogneeResults.push({ text, score: cr.score });
-          }
-        }
-
-        // Strategy 4: For Cognee-only semantic matches (not in FTS results),
-        // use the first line as a vault FTS query to find the source entry.
-        // Preserve caller filters (domain/type/severity) to avoid reintroducing
-        // entries the original query excluded.
-        for (const unmatched of unmatchedCogneeResults) {
-          const searchTerm = unmatched.text.split('\n')[0]?.trim();
-          if (!searchTerm || searchTerm.length < 3) continue;
-          const vaultHits = this.vault.search(searchTerm, {
-            domain: options?.domain,
-            type: options?.type,
-            severity: options?.severity,
-            limit: 1,
-          });
-          if (vaultHits.length > 0) {
-            const id = vaultHits[0].entry.id;
-            cogneeScoreMap.set(id, Math.max(cogneeScoreMap.get(id) ?? 0, unmatched.score));
-            // Also add to FTS results pool if not already present
-            if (!rawResults.some((r) => r.entry.id === id)) {
-              rawResults.push(vaultHits[0]);
-            }
-          }
-        }
-      } catch {
-        // Cognee failed — fall back to FTS5 only
-        cogneeScoreMap = new Map();
-      }
-    }
-
     if (rawResults.length === 0) return [];
 
     const seedCount = rawResults.length;
@@ -201,22 +98,9 @@ export class Brain {
     const queryDomain = options?.domain;
     const now = Math.floor(Date.now() / 1000);
 
-    // Use cognee-aware weights only if at least one ranked candidate has a vector score
-    const hasVectorCandidate = rawResults.some((r) => cogneeScoreMap.has(r.entry.id));
-    const activeWeights = hasVectorCandidate ? this.getCogneeWeights() : this.weights;
-
     const ranked = rawResults.map((result) => {
       const entry = result.entry;
-      const vectorScore = cogneeScoreMap.get(entry.id) ?? 0;
-      const breakdown = this.scoreEntry(
-        entry,
-        queryTokens,
-        queryTags,
-        queryDomain,
-        now,
-        vectorScore,
-        activeWeights,
-      );
+      const breakdown = this.scoreEntry(entry, queryTokens, queryTags, queryDomain, now);
       return { entry, score: breakdown.total, breakdown };
     });
 
@@ -335,11 +219,6 @@ export class Brain {
     this.vault.add(fullEntry);
     this.updateVocabularyIncremental(fullEntry);
 
-    // Fire-and-forget Cognee sync
-    if (this.cognee?.isAvailable) {
-      this.cognee.addEntries([fullEntry]).catch(() => {});
-    }
-
     const result: CaptureResult = {
       captured: true,
       id: entry.id,
@@ -465,32 +344,6 @@ export class Brain {
     });
   }
 
-  async syncToCognee(): Promise<{ synced: number; cognified: boolean }> {
-    if (!this.cognee?.isAvailable) return { synced: 0, cognified: false };
-
-    const batchSize = 1000;
-    let offset = 0;
-    let totalSynced = 0;
-
-    while (true) {
-      const batch = this.vault.list({ limit: batchSize, offset });
-      if (batch.length === 0) break;
-
-      const { added } = await this.cognee.addEntries(batch);
-      totalSynced += added;
-      offset += batch.length;
-
-      if (batch.length < batchSize) break;
-    }
-
-    if (totalSynced === 0) return { synced: 0, cognified: false };
-
-    let cognified = false;
-    const cognifyResult = await this.cognee.cognify();
-    cognified = cognifyResult.status === 'ok';
-    return { synced: totalSynced, cognified };
-  }
-
   rebuildVocabulary(): void {
     // Collect entries from all connected sources when VaultManager is available
     let entries: IntelligenceEntry[];
@@ -616,10 +469,8 @@ export class Brain {
     queryTags: string[],
     queryDomain: string | undefined,
     now: number,
-    vectorScore: number = 0,
-    activeWeights?: ScoringWeights,
   ): ScoreBreakdown {
-    const w = activeWeights ?? this.weights;
+    const w = this.weights;
 
     let semantic = 0;
     if (this.vocabulary.size > 0 && queryTokens.length > 0) {
@@ -643,7 +494,7 @@ export class Brain {
 
     const domainMatch = queryDomain && entry.domain === queryDomain ? 1.0 : 0;
 
-    const vector = vectorScore;
+    const vector = 0;
 
     const total =
       w.semantic * semantic +
@@ -747,10 +598,6 @@ export class Brain {
     tx();
   }
 
-  private getCogneeWeights(): ScoringWeights {
-    return { ...COGNEE_WEIGHTS };
-  }
-
   private recomputeWeights(): void {
     const db = this.vault.getDb();
     // Exclude 'failed' from weight computation — system errors don't indicate relevance

package/src/brain/knowledge-synthesizer.ts

@@ -114,8 +114,6 @@ export class KnowledgeSynthesizer {
     let llmOutput: string;
     try {
       const result = await this.llm.complete({
-        provider: 'openai',
-        model: 'gpt-4o-mini',
         systemPrompt,
         userPrompt,
         temperature: 0.3,

package/src/context/context-engine.ts

@@ -3,17 +3,15 @@
  *
  * Orchestrates three signals to enrich intent classification:
  * 1. Entity extraction (regex-based, domain-agnostic)
- * 2. Knowledge retrieval (vault FTS + Cognee vector + brain recommendations)
+ * 2. Knowledge retrieval (vault FTS + brain recommendations)
  * 3. Confidence scoring (combines entity + knowledge signals)
  *
- * Graceful degradation: if Cognee is unavailable, vault-only.
  * If vault is empty, keyword confidence from IntentRouter is unchanged.
  */
 
 import type { Vault } from '../vault/vault.js';
 import type { Brain } from '../brain/brain.js';
 import type { BrainIntelligence } from '../brain/intelligence.js';
-import type { CogneeClient } from '../cognee/client.js';
 import type {
   EntityType,
   ExtractedEntity,
@@ -105,20 +103,17 @@ export class ContextEngine {
   private vault: Vault;
   private brain: Brain;
   private brainIntelligence: BrainIntelligence;
-  private cognee: CogneeClient | null;
   private config: Required<ContextEngineConfig>;
 
   constructor(
     vault: Vault,
     brain: Brain,
     brainIntelligence: BrainIntelligence,
-    cognee: CogneeClient | null,
     config?: ContextEngineConfig,
   ) {
     this.vault = vault;
     this.brain = brain;
     this.brainIntelligence = brainIntelligence;
-    this.cognee = cognee;
     this.config = {
       vaultSearchLimit: config?.vaultSearchLimit ?? 10,
       cogneeSearchLimit: config?.cogneeSearchLimit ?? 10,
@@ -167,7 +162,6 @@ export class ContextEngine {
   async retrieveKnowledge(prompt: string, domain?: string): Promise<KnowledgeRetrievalResult> {
     const items: KnowledgeItem[] = [];
     let vaultHits = 0;
-    let cogneeHits = 0;
     let brainHits = 0;
 
     // 1. Vault FTS search
@@ -208,29 +202,7 @@ export class ContextEngine {
       // Vault search failed — continue with other sources
     }
 
-    // 2. Cognee vector search (async, graceful degradation)
-    if (this.cognee) {
-      try {
-        const cogneeResults = await this.cognee.search(prompt, {
-          limit: this.config.cogneeSearchLimit,
-        });
-        for (const r of cogneeResults) {
-          // Avoid duplicates from vault
-          if (items.some((i) => i.id === r.id)) continue;
-          items.push({
-            id: r.id,
-            title: r.text.slice(0, 100),
-            score: r.score,
-            source: 'cognee',
-          });
-          cogneeHits++;
-        }
-      } catch {
-        // Cognee unavailable — continue without
-      }
-    }
-
-    // 3. Brain recommendations
+    // 2. Brain recommendations
     try {
       const recommendations = this.brainIntelligence.recommend({
         domain,
@@ -255,7 +227,7 @@ export class ContextEngine {
     items.sort((a, b) => b.score - a.score);
     const filtered = items.filter((i) => i.score >= this.config.minScoreThreshold);
 
-    return { items: filtered, vaultHits, cogneeHits, brainHits };
+    return { items: filtered, vaultHits, cogneeHits: 0, brainHits };
   }
 
   // ─── Context Analysis ───────────────────────────────────────────

package/src/curator/classifier.ts

@@ -58,8 +58,6 @@ export async function classifyEntry(
 
   try {
     const result = await llm.complete({
-      provider: 'openai',
-      model: 'gpt-4o-mini',
       systemPrompt: 'You are a knowledge classifier. Respond only with JSON.',
       userPrompt: prompt,
       temperature: 0.1,