@soleri/core 9.0.4 → 9.3.0

package/src/control/intent-router.ts

@@ -268,17 +268,26 @@ export class IntentRouter {
   // ─── Mode Management ───────────────────────────────────────────────
 
   morph(mode: OperationalMode): MorphResult {
-    const row = this.provider.get<ModeRow>('SELECT * FROM agent_modes WHERE mode = ?', [mode]);
+    // Handle "reset" as a built-in alias for GENERAL-MODE
+    const resolvedMode: OperationalMode = (mode as string) === 'reset' ? 'GENERAL-MODE' : mode;
+
+    const row = this.provider.get<ModeRow>('SELECT * FROM agent_modes WHERE mode = ?', [
+      resolvedMode,
+    ]);
 
     if (!row) {
-      throw new Error(`Unknown mode: ${mode}`);
+      const available = this.provider
+        .all<{ mode: string }>('SELECT mode FROM agent_modes ORDER BY mode')
+        .map((r) => r.mode)
+        .join(', ');
+      throw new Error(`Unknown mode: ${mode}. Available: ${available}`);
     }
 
     const previousMode = this.currentMode;
-    this.currentMode = mode;
+    this.currentMode = resolvedMode;
     const behaviorRules = JSON.parse(row.behavior_rules) as string[];
 
-    return { previousMode, currentMode: mode, behaviorRules };
+    return { previousMode, currentMode: resolvedMode, behaviorRules };
   }
 
   getCurrentMode(): OperationalMode {

package/src/curator/classifier.test.ts

@@ -0,0 +1,110 @@
+import { describe, it, expect, vi } from 'vitest';
+import { classifyEntry } from './classifier.js';
+import type { IntelligenceEntry } from '../intelligence/types.js';
+import type { LLMClient } from '../llm/llm-client.js';
+
+function makeEntry(overrides: Partial<IntelligenceEntry> = {}): IntelligenceEntry {
+  return {
+    id: overrides.id ?? 'test-1',
+    type: overrides.type ?? 'pattern',
+    domain: overrides.domain ?? 'testing',
+    title: overrides.title ?? 'Test Pattern',
+    severity: overrides.severity ?? 'warning',
+    description: overrides.description ?? 'A test pattern.',
+    tags: overrides.tags ?? ['testing'],
+  };
+}
+
+function mockLLM(response: string): LLMClient {
+  return {
+    complete: vi.fn().mockResolvedValue({ text: response }),
+  } as unknown as LLMClient;
+}
+
+describe('classifyEntry', () => {
+  it('returns fallback when llm is null', async () => {
+    const result = await classifyEntry(makeEntry(), null);
+    expect(result.classified).toBe(false);
+    expect(result.suggestedDomain).toBeNull();
+    expect(result.suggestedSeverity).toBeNull();
+    expect(result.suggestedTags).toEqual([]);
+    expect(result.confidence).toBe(0);
+  });
+
+  it('classifies entry with valid LLM response', async () => {
+    const llm = mockLLM(
+      JSON.stringify({
+        domain: 'security',
+        severity: 'critical',
+        tags: ['auth', 'jwt', 'security'],
+        confidence: 0.9,
+      }),
+    );
+
+    const result = await classifyEntry(makeEntry({ title: 'Use JWT securely' }), llm);
+    expect(result.classified).toBe(true);
+    expect(result.suggestedDomain).toBe('security');
+    expect(result.suggestedSeverity).toBe('critical');
+    expect(result.suggestedTags).toEqual(['auth', 'jwt', 'security']);
+    expect(result.confidence).toBe(0.9);
+  });
+
+  it('returns fallback with error on LLM failure', async () => {
+    const llm = {
+      complete: vi.fn().mockRejectedValue(new Error('LLM unavailable')),
+    } as unknown as LLMClient;
+
+    const result = await classifyEntry(makeEntry(), llm);
+    expect(result.classified).toBe(false);
+    expect(result.error).toBe('LLM unavailable');
+  });
+
+  it('returns fallback with error on invalid JSON response', async () => {
+    const llm = mockLLM('not valid json');
+    const result = await classifyEntry(makeEntry(), llm);
+    expect(result.classified).toBe(false);
+    expect(result.error).toBeDefined();
+  });
+
+  it('handles missing fields in LLM response gracefully', async () => {
+    const llm = mockLLM(JSON.stringify({}));
+    const result = await classifyEntry(makeEntry(), llm);
+    expect(result.classified).toBe(true);
+    expect(result.suggestedDomain).toBeNull();
+    expect(result.suggestedSeverity).toBeNull();
+    expect(result.suggestedTags).toEqual([]);
+    expect(result.confidence).toBe(0.5);
+  });
+
+  it('passes entry fields to LLM prompt', async () => {
+    const llm = mockLLM(
+      JSON.stringify({ domain: 'test', severity: 'warning', tags: [], confidence: 0.5 }),
+    );
+    const entry = makeEntry({
+      title: 'Specific Title',
+      type: 'anti-pattern',
+      tags: ['tag-a', 'tag-b'],
+      description: 'Specific description.',
+    });
+
+    await classifyEntry(entry, llm);
+
+    const call = (llm.complete as ReturnType<typeof vi.fn>).mock.calls[0][0];
+    expect(call.userPrompt).toContain('Specific Title');
+    expect(call.userPrompt).toContain('anti-pattern');
+    expect(call.userPrompt).toContain('tag-a, tag-b');
+    expect(call.userPrompt).toContain('Specific description.');
+  });
+
+  it('uses empty tags placeholder when entry has no tags', async () => {
+    const llm = mockLLM(
+      JSON.stringify({ domain: 'test', severity: 'warning', tags: [], confidence: 0.5 }),
+    );
+    const entry = makeEntry({ tags: [] });
+
+    await classifyEntry(entry, llm);
+
+    const call = (llm.complete as ReturnType<typeof vi.fn>).mock.calls[0][0];
+    expect(call.userPrompt).toContain('none');
+  });
+});

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

@@ -0,0 +1,205 @@
+import { describe, it, expect, vi } from 'vitest';
+import type { IntelligenceEntry } from '../intelligence/types.js';
+import { findContradictions, DEFAULT_CONTRADICTION_THRESHOLD } from './contradiction-detector.js';
+
+function makeEntry(overrides: Partial<IntelligenceEntry> = {}): IntelligenceEntry {
+  return {
+    id: overrides.id ?? 'test-1',
+    type: overrides.type ?? 'pattern',
+    domain: overrides.domain ?? 'testing',
+    title: overrides.title ?? 'Test Pattern',
+    severity: overrides.severity ?? 'warning',
+    description: overrides.description ?? 'A test pattern for testing.',
+    tags: overrides.tags ?? ['testing'],
+  };
+}
+
+describe('contradiction-detector', () => {
+  describe('constants', () => {
+    it('exports DEFAULT_CONTRADICTION_THRESHOLD', () => {
+      expect(DEFAULT_CONTRADICTION_THRESHOLD).toBe(0.4);
+    });
+  });
+
+  describe('findContradictions', () => {
+    it('returns empty array when no entries', () => {
+      expect(findContradictions([])).toEqual([]);
+    });
+
+    it('returns empty array when no anti-patterns', () => {
+      const entries = [
+        makeEntry({ id: 'p1', type: 'pattern' }),
+        makeEntry({ id: 'p2', type: 'pattern' }),
+      ];
+      expect(findContradictions(entries)).toEqual([]);
+    });
+
+    it('returns empty array when no patterns', () => {
+      const entries = [
+        makeEntry({ id: 'ap1', type: 'anti-pattern' }),
+        makeEntry({ id: 'ap2', type: 'anti-pattern' }),
+      ];
+      expect(findContradictions(entries)).toEqual([]);
+    });
+
+    it('detects contradictions between similar pattern and anti-pattern', () => {
+      const entries = [
+        makeEntry({
+          id: 'p-inline',
+          type: 'pattern',
+          title: 'Use inline styles for dynamic values',
+          description: 'Apply inline styles when values are computed at runtime.',
+          tags: ['styling'],
+        }),
+        makeEntry({
+          id: 'ap-inline',
+          type: 'anti-pattern',
+          title: 'Avoid inline styles for styling',
+          description: 'Never use inline styles — prefer CSS classes.',
+          tags: ['styling'],
+        }),
+      ];
+      const results = findContradictions(entries, 0.2);
+      expect(results.length).toBeGreaterThan(0);
+      expect(results[0].patternId).toBe('p-inline');
+      expect(results[0].antipatternId).toBe('ap-inline');
+      expect(results[0].similarity).toBeGreaterThanOrEqual(0.2);
+    });
+
+    it('skips unrelated pattern/anti-pattern pairs', () => {
+      const entries = [
+        makeEntry({
+          id: 'p-auth',
+          type: 'pattern',
+          title: 'Use JWT for authentication',
+          description: 'JSON Web Tokens for stateless auth.',
+          tags: ['auth'],
+        }),
+        makeEntry({
+          id: 'ap-css',
+          type: 'anti-pattern',
+          title: 'Avoid CSS important',
+          description: 'Never use important in CSS declarations.',
+          tags: ['styling'],
+        }),
+      ];
+      const results = findContradictions(entries, 0.8);
+      expect(results.length).toBe(0);
+    });
+
+    it('uses searchFn when provided', () => {
+      const pattern = makeEntry({
+        id: 'p1',
+        type: 'pattern',
+        title: 'Use inline styles',
+        description: 'Apply inline styles.',
+      });
+      const antipattern = makeEntry({
+        id: 'ap1',
+        type: 'anti-pattern',
+        title: 'Avoid inline styles',
+        description: 'Do not use inline styles.',
+      });
+      const entries = [pattern, antipattern];
+
+      const searchFn = vi.fn().mockReturnValue([pattern]);
+      const results = findContradictions(entries, 0.2, searchFn);
+
+      expect(searchFn).toHaveBeenCalledWith('Avoid inline styles');
+      expect(results.length).toBeGreaterThan(0);
+    });
+
+    it('falls back to all patterns when searchFn returns empty', () => {
+      const entries = [
+        makeEntry({
+          id: 'p1',
+          type: 'pattern',
+          title: 'Use inline styles',
+          description: 'Inline.',
+        }),
+        makeEntry({
+          id: 'ap1',
+          type: 'anti-pattern',
+          title: 'Avoid inline styles',
+          description: 'No inline.',
+        }),
+      ];
+
+      const searchFn = vi.fn().mockReturnValue([]);
+      const results = findContradictions(entries, 0.2, searchFn);
+
+      expect(searchFn).toHaveBeenCalled();
+      // Should still detect — falls back to full scan
+      expect(results.length).toBeGreaterThan(0);
+    });
+
+    it('falls back to all patterns when searchFn throws', () => {
+      const entries = [
+        makeEntry({
+          id: 'p1',
+          type: 'pattern',
+          title: 'Use inline styles',
+          description: 'Inline.',
+        }),
+        makeEntry({
+          id: 'ap1',
+          type: 'anti-pattern',
+          title: 'Avoid inline styles',
+          description: 'No inline.',
+        }),
+      ];
+
+      const searchFn = vi.fn().mockImplementation(() => {
+        throw new Error('FTS5 unavailable');
+      });
+      const results = findContradictions(entries, 0.2, searchFn);
+
+      expect(results.length).toBeGreaterThan(0);
+    });
+
+    it('respects threshold — high threshold reduces detections', () => {
+      const entries = [
+        makeEntry({
+          id: 'p1',
+          type: 'pattern',
+          title: 'Prefer inline styles for dynamic',
+          description: 'Use inline for dynamic values.',
+        }),
+        makeEntry({
+          id: 'ap1',
+          type: 'anti-pattern',
+          title: 'Avoid inline styles completely',
+          description: 'Never use inline styles at all.',
+        }),
+      ];
+      const lowThreshold = findContradictions(entries, 0.1);
+      const highThreshold = findContradictions(entries, 0.99);
+      expect(highThreshold.length).toBeLessThanOrEqual(lowThreshold.length);
+    });
+
+    it('uses default threshold when none provided', () => {
+      const entries = [
+        makeEntry({ id: 'p1', type: 'pattern', title: 'A', description: 'B' }),
+        makeEntry({ id: 'ap1', type: 'anti-pattern', title: 'C', description: 'D' }),
+      ];
+      // Should not throw
+      const results = findContradictions(entries);
+      expect(Array.isArray(results)).toBe(true);
+    });
+
+    it('ignores entries that are neither pattern nor anti-pattern', () => {
+      const entries = [
+        makeEntry({ id: 'r1', type: 'rule', title: 'Use inline styles', description: 'Inline.' }),
+        makeEntry({
+          id: 'ap1',
+          type: 'anti-pattern',
+          title: 'Avoid inline styles',
+          description: 'No inline.',
+        }),
+      ];
+      // Rules should not be compared against anti-patterns
+      const results = findContradictions(entries, 0.1);
+      expect(results.length).toBe(0);
+    });
+  });
+});

package/src/curator/contradiction-detector.ts

@@ -0,0 +1,87 @@
+/**
+ * Contradiction Detector — pure-logic module for finding contradictions
+ * between pattern and anti-pattern vault entries.
+ *
+ * Uses TF-IDF cosine similarity with optional FTS5 pre-filtering.
+ * Database persistence of detected contradictions is handled by the caller (Curator facade).
+ */
+
+import type { IntelligenceEntry } from '../intelligence/types.js';
+import { tokenize, calculateTfIdf, cosineSimilarity } from '../text/similarity.js';
+import { buildVocabulary, entryToText } from './duplicate-detector.js';
+
+// ─── Constants ──────────────────────────────────────────────────────
+
+export const DEFAULT_CONTRADICTION_THRESHOLD = 0.4;
+
+// ─── Types ──────────────────────────────────────────────────────────
+
+export interface ContradictionCandidate {
+  patternId: string;
+  antipatternId: string;
+  similarity: number;
+}
+
+export interface SearchFn {
+  (title: string): IntelligenceEntry[];
+}
+
+// ─── Detect Contradictions ──────────────────────────────────────────
+
+/**
+ * Find pattern/anti-pattern pairs with high textual similarity.
+ *
+ * @param entries - All vault entries
+ * @param threshold - Minimum cosine similarity to flag as contradiction
+ * @param searchFn - Optional FTS5-backed candidate retrieval (falls back to all patterns)
+ * @returns Array of contradiction candidates (not yet persisted)
+ */
+export function findContradictions(
+  entries: IntelligenceEntry[],
+  threshold?: number,
+  searchFn?: SearchFn,
+): ContradictionCandidate[] {
+  const effectiveThreshold = threshold ?? DEFAULT_CONTRADICTION_THRESHOLD;
+  const antipatterns = entries.filter((e) => e.type === 'anti-pattern');
+  const patterns = entries.filter((e) => e.type === 'pattern');
+
+  if (antipatterns.length === 0 || patterns.length === 0) return [];
+
+  const vocabulary = buildVocabulary(entries);
+  const detected: ContradictionCandidate[] = [];
+
+  for (const ap of antipatterns) {
+    // Stage 1: FTS5 candidate retrieval (fall back to all patterns if FTS returns empty)
+    let candidates: IntelligenceEntry[];
+    if (searchFn) {
+      try {
+        const searchResults = searchFn(ap.title);
+        candidates = searchResults.length > 0 ? searchResults : patterns;
+      } catch {
+        candidates = patterns;
+      }
+    } else {
+      candidates = patterns;
+    }
+
+    // Stage 2: TF-IDF cosine similarity
+    const apText = entryToText(ap);
+    const apVec = calculateTfIdf(tokenize(apText), vocabulary);
+
+    for (const pattern of candidates) {
+      const pText = entryToText(pattern);
+      const pVec = calculateTfIdf(tokenize(pText), vocabulary);
+      const similarity = cosineSimilarity(apVec, pVec);
+
+      if (similarity >= effectiveThreshold) {
+        detected.push({
+          patternId: pattern.id,
+          antipatternId: ap.id,
+          similarity,
+        });
+      }
+    }
+  }
+
+  return detected;
+}

package/src/{__tests__ → curator}/curator-pipeline-e2e.test.ts

@@ -8,19 +8,19 @@
 import { describe, it, expect, beforeAll, afterAll } from 'vitest';
 import { Vault } from '../vault/vault.js';
 import { Brain } from '../brain/brain.js';
-import { Curator } from '../curator/curator.js';
+import { Curator } from './curator.js';
 import { JobQueue } from '../queue/job-queue.js';
 import { PipelineRunner } from '../queue/pipeline-runner.js';
 import { TypedEventBus } from '../events/event-bus.js';
 import { LinkManager } from '../vault/linking.js';
-import { evaluateQuality } from '../curator/quality-gate.js';
-import { classifyEntry } from '../curator/classifier.js';
+import { evaluateQuality } from './quality-gate.js';
+import { classifyEntry } from './classifier.js';
 import type { IntelligenceEntry } from '../intelligence/types.js';
 
 // ─── Shared Setup ────────────────────────────────────────────────────
 
 let vault: Vault;
-let brain: Brain;
+let _brain: Brain;
 let curator: Curator;
 let queue: JobQueue;
 let runner: PipelineRunner;
@@ -60,7 +60,7 @@ const SEED: IntelligenceEntry[] = [
 beforeAll(() => {
   vault = new Vault(':memory:');
   vault.seed(SEED);
-  brain = new Brain(vault);
+  _brain = new Brain(vault);
   curator = new Curator(vault);
   queue = new JobQueue(vault.getProvider());
   linkManager = new LinkManager(vault.getProvider());
@@ -153,7 +153,7 @@ describe('Job Queue — curator pipeline', () => {
 
     const step1 = queue.enqueue('tag-normalize', { entryId, pipelineId });
     const step2 = queue.enqueue('dedup-check', { entryId, pipelineId, dependsOn: [step1] });
-    const step3 = queue.enqueue('auto-link', { entryId, pipelineId, dependsOn: [step2] });
+    queue.enqueue('auto-link', { entryId, pipelineId, dependsOn: [step2] });
 
     const jobs = queue.getByPipeline(pipelineId);
     expect(jobs.length).toBe(3);
@@ -400,13 +400,13 @@ describe('Full Salvador DAG — 7-step curator pipeline', () => {
     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', {
+    const step5Id = queue.enqueue('detect-contradiction', {
       entryId,
       pipelineId,
       dependsOn: [step4],
     });
-    const step6 = queue.enqueue('auto-link', { entryId, pipelineId, dependsOn: [step5] });
-    const step7 = queue.enqueue('verify-searchable', { entryId, pipelineId, dependsOn: [step6] });
+    const step6Id = queue.enqueue('auto-link', { entryId, pipelineId, dependsOn: [step5Id] });
+    queue.enqueue('verify-searchable', { entryId, pipelineId, dependsOn: [step6Id] });
 
     // Drain the DAG
     for (let i = 0; i < 15; i++) {
@@ -492,7 +492,7 @@ describe('Full pipeline E2E — capture to completion', () => {
     const step2 = queue.enqueue('tag-normalize', { entryId, pipelineId, dependsOn: [step1] });
     const step3 = queue.enqueue('dedup-check', { entryId, pipelineId, dependsOn: [step2] });
     const step4 = queue.enqueue('classify', { entryId, pipelineId, dependsOn: [step3] });
-    const step5 = queue.enqueue('auto-link', { entryId, pipelineId, dependsOn: [step4] });
+    queue.enqueue('auto-link', { entryId, pipelineId, dependsOn: [step4] });
 
     // Process all steps — run enough batches to drain DAG
     // (earlier tests may have left pending jobs, so process generously)

package/src/{__tests__ → curator}/curator.test.ts

@@ -1,6 +1,6 @@
 import { describe, it, expect, beforeEach, afterEach } from 'vitest';
 import { Vault } from '../vault/vault.js';
-import { Curator } from '../curator/curator.js';
+import { Curator } from './curator.js';
 import type { IntelligenceEntry } from '../intelligence/types.js';
 
 function makeEntry(overrides: Partial<IntelligenceEntry> = {}): IntelligenceEntry {
@@ -203,6 +203,82 @@ describe('Curator', () => {
       const results = curator.detectDuplicates();
       expect(results).toEqual([]);
     });
+
+    it('should NOT flag cross-domain entries as duplicates', () => {
+      vault.seed([
+        makeEntry({
+          id: 'cross-1',
+          domain: 'design',
+          title: 'Use semantic tokens for colors',
+          description: 'Always use semantic tokens instead of raw hex values for color styling.',
+          tags: ['tokens', 'colors'],
+        }),
+        makeEntry({
+          id: 'cross-2',
+          domain: 'architecture',
+          title: 'Use semantic tokens for colors',
+          description: 'Always use semantic tokens instead of raw hex values for color styling.',
+          tags: ['tokens', 'colors'],
+        }),
+      ]);
+      const results = curator.detectDuplicates(undefined, 0.3);
+      expect(results.length).toBe(0);
+    });
+
+    it('should still flag same-domain entries as duplicates', () => {
+      vault.seed([
+        makeEntry({
+          id: 'same-1',
+          domain: 'design',
+          title: 'Use semantic tokens for colors',
+          description: 'Always use semantic tokens instead of raw hex values for color styling.',
+          tags: ['tokens', 'colors'],
+        }),
+        makeEntry({
+          id: 'same-2',
+          domain: 'design',
+          title: 'Use semantic tokens for color values',
+          description: 'Prefer semantic color tokens over raw hex or rgb values in styling.',
+          tags: ['tokens', 'colors'],
+        }),
+      ]);
+      const results = curator.detectDuplicates(undefined, 0.3);
+      expect(results.length).toBeGreaterThan(0);
+    });
+
+    it('should improve health audit score for cross-domain vaults', () => {
+      // Seed entries across different domains with similar vocabulary
+      vault.seed([
+        makeEntry({
+          id: 'ha-1',
+          domain: 'design',
+          type: 'pattern',
+          title: 'Use semantic tokens for colors',
+          description: 'Always use semantic tokens instead of raw hex values.',
+          tags: ['tokens', 'colors'],
+        }),
+        makeEntry({
+          id: 'ha-2',
+          domain: 'architecture',
+          type: 'anti-pattern',
+          title: 'Use semantic tokens for API responses',
+          description: 'Always use semantic tokens instead of raw values in API.',
+          tags: ['tokens', 'api'],
+        }),
+        makeEntry({
+          id: 'ha-3',
+          domain: 'testing',
+          type: 'rule',
+          title: 'Use semantic assertions',
+          description: 'Always use semantic assertions for test clarity.',
+          tags: ['tokens', 'testing'],
+        }),
+      ]);
+      curator.groomAll();
+      const result = curator.healthAudit();
+      // Cross-domain entries should not be penalized as duplicates
+      expect(result.score).toBeGreaterThanOrEqual(90);
+    });
   });
 
   // ─── Contradictions ───────────────────────────────────────────