@soleri/core 9.0.3 → 9.2.0

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

@@ -0,0 +1,183 @@
+import { describe, it, expect } from 'vitest';
+import type { IntelligenceEntry } from '../intelligence/types.js';
+import {
+  detectDuplicates,
+  buildVocabulary,
+  entryToText,
+  DEFAULT_DUPLICATE_THRESHOLD,
+  MERGE_SUGGESTION_THRESHOLD,
+} from './duplicate-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('duplicate-detector', () => {
+  describe('buildVocabulary', () => {
+    it('returns IDF scores for all unique tokens across entries', () => {
+      const entries = [
+        makeEntry({ id: '1', title: 'Use semantic tokens', description: 'Tokens for colors' }),
+        makeEntry({ id: '2', title: 'Avoid raw colors', description: 'Never use hex values' }),
+      ];
+      const vocab = buildVocabulary(entries);
+      expect(vocab.size).toBeGreaterThan(0);
+      // Common terms should have lower IDF than unique terms
+      for (const [, idf] of vocab) {
+        expect(idf).toBeGreaterThan(0);
+      }
+    });
+
+    it('returns empty map for empty entries', () => {
+      const vocab = buildVocabulary([]);
+      expect(vocab.size).toBe(0);
+    });
+
+    it('gives higher IDF to rare terms', () => {
+      const entries = [
+        makeEntry({ id: '1', title: 'authentication jwt tokens', description: 'auth' }),
+        makeEntry({ id: '2', title: 'database connection pooling', description: 'db' }),
+        makeEntry({ id: '3', title: 'authentication session cookies', description: 'auth' }),
+      ];
+      const vocab = buildVocabulary(entries);
+      // "authentication" appears in 2/3 docs, "pooling" in 1/3 — pooling should have higher IDF
+      const authIdf = vocab.get('authentication') ?? 0;
+      const poolingIdf = vocab.get('pooling') ?? 0;
+      expect(poolingIdf).toBeGreaterThan(authIdf);
+    });
+  });
+
+  describe('entryToText', () => {
+    it('concatenates title, description, context, and tags', () => {
+      const entry = makeEntry({
+        title: 'My Title',
+        description: 'My Desc',
+        tags: ['tag1', 'tag2'],
+      });
+      entry.context = 'Some context';
+      const text = entryToText(entry);
+      expect(text).toContain('My Title');
+      expect(text).toContain('My Desc');
+      expect(text).toContain('Some context');
+      expect(text).toContain('tag1');
+      expect(text).toContain('tag2');
+    });
+
+    it('handles missing context', () => {
+      const entry = makeEntry({ title: 'Title', description: 'Desc' });
+      const text = entryToText(entry);
+      expect(text).toContain('Title');
+      expect(text).toContain('Desc');
+    });
+  });
+
+  describe('constants', () => {
+    it('exports expected threshold values', () => {
+      expect(DEFAULT_DUPLICATE_THRESHOLD).toBe(0.45);
+      expect(MERGE_SUGGESTION_THRESHOLD).toBe(0.65);
+    });
+  });
+
+  describe('detectDuplicates', () => {
+    it('returns empty array for empty entries', () => {
+      expect(detectDuplicates([])).toEqual([]);
+    });
+
+    it('returns empty array for single entry', () => {
+      const entries = [makeEntry({ id: '1' })];
+      expect(detectDuplicates(entries)).toEqual([]);
+    });
+
+    it('detects duplicates with identical content', () => {
+      const entries = [
+        makeEntry({ id: 'dup-1', title: 'Validate user input', description: 'Always validate user input before processing.' }),
+        makeEntry({ id: 'dup-2', title: 'Validate user input', description: 'Always validate user input before processing.' }),
+      ];
+      const results = detectDuplicates(entries, undefined, 0.3);
+      expect(results.length).toBeGreaterThan(0);
+      expect(results[0].matches[0].suggestMerge).toBe(true);
+    });
+
+    it('does not flag unrelated entries', () => {
+      const entries = [
+        makeEntry({ id: 'a', title: 'Database indexing strategies', description: 'Create indices on columns.' }),
+        makeEntry({ id: 'b', title: 'React component lifecycle', description: 'Use useEffect for side effects.' }),
+      ];
+      const results = detectDuplicates(entries, undefined, 0.8);
+      expect(results.length).toBe(0);
+    });
+
+    it('filters by entryId when provided', () => {
+      const entries = [
+        makeEntry({ id: 'x', title: 'Authentication with JWT', description: 'Use JWT for auth.' }),
+        makeEntry({ id: 'y', title: 'JWT authentication pattern', description: 'Implement JWT auth.' }),
+        makeEntry({ id: 'z', title: 'Database pooling', description: 'Connection pools.' }),
+      ];
+      const results = detectDuplicates(entries, 'x', 0.3);
+      expect(results.length).toBeLessThanOrEqual(1);
+      if (results.length > 0) {
+        expect(results[0].entryId).toBe('x');
+      }
+    });
+
+    it('skips cross-domain pairs', () => {
+      const entries = [
+        makeEntry({ id: '1', domain: 'design', title: 'Use semantic tokens', description: 'Always use semantic tokens.' }),
+        makeEntry({ id: '2', domain: 'architecture', title: 'Use semantic tokens', description: 'Always use semantic tokens.' }),
+      ];
+      const results = detectDuplicates(entries, undefined, 0.3);
+      expect(results.length).toBe(0);
+    });
+
+    it('flags same-domain similar entries', () => {
+      const entries = [
+        makeEntry({ id: '1', domain: 'design', title: 'Use semantic tokens for colors', description: 'Always use semantic tokens.' }),
+        makeEntry({ id: '2', domain: 'design', title: 'Use semantic tokens for color values', description: 'Prefer semantic color tokens.' }),
+      ];
+      const results = detectDuplicates(entries, undefined, 0.3);
+      expect(results.length).toBeGreaterThan(0);
+    });
+
+    it('sets suggestMerge based on MERGE_SUGGESTION_THRESHOLD', () => {
+      const entries = [
+        makeEntry({ id: 'a', title: 'Exact same title', description: 'Exact same description for merge test.' }),
+        makeEntry({ id: 'b', title: 'Exact same title', description: 'Exact same description for merge test.' }),
+      ];
+      const results = detectDuplicates(entries, undefined, 0.3);
+      expect(results.length).toBeGreaterThan(0);
+      // Identical entries should have very high similarity
+      expect(results[0].matches[0].suggestMerge).toBe(true);
+    });
+
+    it('sorts matches by descending similarity', () => {
+      const entries = [
+        makeEntry({ id: 'base', title: 'Use semantic tokens for colors', description: 'Tokens for styling.' }),
+        makeEntry({ id: 'close', title: 'Use semantic tokens for color values', description: 'Tokens for styling values.' }),
+        makeEntry({ id: 'far', title: 'Semantic approach to colors', description: 'Use semantic color approach.' }),
+      ];
+      const results = detectDuplicates(entries, 'base', 0.1);
+      if (results.length > 0 && results[0].matches.length > 1) {
+        expect(results[0].matches[0].similarity).toBeGreaterThanOrEqual(results[0].matches[1].similarity);
+      }
+    });
+
+    it('includes scannedCount in results', () => {
+      const entries = [
+        makeEntry({ id: '1', title: 'Same thing', description: 'Same desc.' }),
+        makeEntry({ id: '2', title: 'Same thing', description: 'Same desc.' }),
+        makeEntry({ id: '3', title: 'Different thing', description: 'Different desc.' }),
+      ];
+      const results = detectDuplicates(entries, '1', 0.3);
+      if (results.length > 0) {
+        expect(results[0].scannedCount).toBe(2); // 3 entries minus self
+      }
+    });
+  });
+});

package/src/curator/duplicate-detector.ts

@@ -0,0 +1,103 @@
+/**
+ * Duplicate Detector — pure-logic module for finding duplicate vault entries.
+ *
+ * Uses TF-IDF cosine similarity to score entry pairs.
+ * Database access is NOT performed here — callers supply entry lists.
+ */
+
+import type { IntelligenceEntry } from '../intelligence/types.js';
+import {
+  tokenize,
+  calculateTfIdf,
+  cosineSimilarity,
+  type SparseVector,
+} from '../text/similarity.js';
+import type { DuplicateCandidate, DuplicateDetectionResult } from './types.js';
+
+// ─── Constants ──────────────────────────────────────────────────────
+
+export const DEFAULT_DUPLICATE_THRESHOLD = 0.45;
+export const MERGE_SUGGESTION_THRESHOLD = 0.65;
+
+// ─── Vocabulary Builder ─────────────────────────────────────────────
+
+export function buildVocabulary(entries: IntelligenceEntry[]): Map<string, number> {
+  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 tokens = new Set(tokenize(text));
+    for (const token of tokens) {
+      termDocFreq.set(token, (termDocFreq.get(token) ?? 0) + 1);
+    }
+  }
+  const vocabulary = new Map<string, number>();
+  for (const [term, df] of termDocFreq) {
+    const idf = Math.log((docCount + 1) / (df + 1)) + 1;
+    vocabulary.set(term, idf);
+  }
+  return vocabulary;
+}
+
+// ─── Entry → Text ───────────────────────────────────────────────────
+
+export function entryToText(entry: IntelligenceEntry): string {
+  return [entry.title, entry.description, entry.context ?? '', entry.tags.join(' ')].join(' ');
+}
+
+// ─── Detect Duplicates ──────────────────────────────────────────────
+
+export function detectDuplicates(
+  entries: IntelligenceEntry[],
+  entryId?: string,
+  threshold?: number,
+): DuplicateDetectionResult[] {
+  const effectiveThreshold = threshold ?? DEFAULT_DUPLICATE_THRESHOLD;
+  if (entries.length === 0) return [];
+
+  const vocabulary = buildVocabulary(entries);
+
+  // Build vectors for all entries
+  const vectors = new Map<string, SparseVector>();
+  for (const entry of entries) {
+    vectors.set(entry.id, calculateTfIdf(tokenize(entryToText(entry)), vocabulary));
+  }
+
+  const targetEntries = entryId ? entries.filter((e) => e.id === entryId) : entries;
+
+  const results: DuplicateDetectionResult[] = [];
+
+  for (const entry of targetEntries) {
+    const entryVec = vectors.get(entry.id)!;
+    const matches: DuplicateCandidate[] = [];
+
+    for (const other of entries) {
+      if (other.id === entry.id) continue;
+      // Skip cross-domain pairs — shared vocabulary across domains causes false positives
+      if (entry.domain !== other.domain) continue;
+      const otherVec = vectors.get(other.id)!;
+      const similarity = cosineSimilarity(entryVec, otherVec);
+      if (similarity >= effectiveThreshold) {
+        matches.push({
+          entryId: other.id,
+          title: other.title,
+          similarity,
+          suggestMerge: similarity >= MERGE_SUGGESTION_THRESHOLD,
+        });
+      }
+    }
+
+    if (matches.length > 0) {
+      matches.sort((a, b) => b.similarity - a.similarity);
+      results.push({
+        entryId: entry.id,
+        matches,
+        scannedCount: entries.length - 1,
+      });
+    }
+  }
+
+  return results;
+}

package/src/curator/health-audit.ts

@@ -0,0 +1,126 @@
+/**
+ * Health Audit — pure-logic module for computing vault health scores.
+ *
+ * Receives data through a provider interface; no direct DB access.
+ */
+
+import type { IntelligenceEntry } from '../intelligence/types.js';
+import type { DuplicateDetectionResult, Contradiction, HealthAuditResult } from './types.js';
+
+// ─── Data Provider Interface ────────────────────────────────────────
+
+export interface HealthDataProvider {
+  getStaleCount(threshold: number): number;
+  getGroomedCount(): number;
+  getDuplicates(): DuplicateDetectionResult[];
+  getOpenContradictions(): Contradiction[];
+}
+
+// ─── Compute ────────────────────────────────────────────────────────
+
+export function computeHealthAudit(
+  entries: IntelligenceEntry[],
+  data: HealthDataProvider,
+  staleDays: number,
+): HealthAuditResult {
+  const recommendations: string[] = [];
+
+  if (entries.length === 0) {
+    return {
+      score: 100,
+      metrics: { coverage: 1, freshness: 1, quality: 1, tagHealth: 1 },
+      recommendations: ['Vault is empty — add knowledge entries to get started.'],
+    };
+  }
+
+  let score = 100;
+
+  // ── Coverage ──────────────────────────────────────────────────
+  const typeCount: Record<string, number> = { pattern: 0, 'anti-pattern': 0, rule: 0 };
+  for (const e of entries) typeCount[e.type] = (typeCount[e.type] ?? 0) + 1;
+
+  let coverageScore = 1;
+  if (!typeCount.pattern) {
+    score -= 10;
+    coverageScore -= 0.33;
+    recommendations.push('No patterns found — add patterns to improve coverage.');
+  }
+  if (!typeCount['anti-pattern']) {
+    score -= 5;
+    coverageScore -= 0.17;
+    recommendations.push('No anti-patterns found — add anti-patterns to detect contradictions.');
+  }
+  if (!typeCount.rule) {
+    score -= 5;
+    coverageScore -= 0.17;
+    recommendations.push('No rules found — add rules for completeness.');
+  }
+  coverageScore = Math.max(0, coverageScore);
+
+  // ── Freshness ─────────────────────────────────────────────────
+  const now = Math.floor(Date.now() / 1000);
+  const staleThreshold = now - staleDays * 86400;
+  const staleCount = data.getStaleCount(staleThreshold);
+  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.`,
+    );
+  }
+
+  // ── Quality ───────────────────────────────────────────────────
+  const duplicates = data.getDuplicates();
+  const contradictions = data.getOpenContradictions();
+  let qualityScore = 1;
+  if (duplicates.length > 0) {
+    const penalty = Math.min(15, duplicates.length * 3);
+    score -= penalty;
+    qualityScore -= penalty / 30;
+    recommendations.push(`${duplicates.length} entries have duplicates — run consolidation.`);
+  }
+  if (contradictions.length > 0) {
+    const penalty = Math.min(15, contradictions.length * 5);
+    score -= penalty;
+    qualityScore -= penalty / 30;
+    recommendations.push(`${contradictions.length} open contradictions — resolve or dismiss.`);
+  }
+  qualityScore = Math.max(0, qualityScore);
+
+  // ── Tag Health ────────────────────────────────────────────────
+  const lowTagEntries = entries.filter((e) => e.tags.length < 2);
+  const lowTagRatio = lowTagEntries.length / entries.length;
+  const tagHealthScore = 1 - lowTagRatio;
+  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.`,
+    );
+  }
+
+  // ── Grooming ──────────────────────────────────────────────────
+  const groomedCount = data.getGroomedCount();
+  if (groomedCount < entries.length) {
+    const ungroomed = entries.length - groomedCount;
+    const penalty = Math.min(10, Math.round((ungroomed / entries.length) * 10));
+    score -= penalty;
+    recommendations.push(`${ungroomed} entries never groomed — run groomAll().`);
+  }
+
+  score = Math.max(0, score);
+  if (recommendations.length === 0) recommendations.push('Vault is healthy — no issues detected.');
+
+  return {
+    score,
+    metrics: {
+      coverage: coverageScore,
+      freshness: freshnessScore,
+      quality: qualityScore,
+      tagHealth: tagHealthScore,
+    },
+    recommendations,
+  };
+}

package/src/curator/metadata-enricher.ts

@@ -0,0 +1,84 @@
+/**
+ * Metadata Enricher — pure-logic module for rule-based entry metadata enrichment.
+ *
+ * No DB access. Returns changes and updates to be applied by the caller.
+ */
+
+import type { IntelligenceEntry } from '../intelligence/types.js';
+
+// ─── Types ──────────────────────────────────────────────────────────
+
+export interface MetadataChange {
+  field: string;
+  before: string;
+  after: string;
+}
+
+export interface EnrichResult {
+  changes: MetadataChange[];
+  updates: Partial<Pick<IntelligenceEntry, 'title' | 'description' | 'tags' | 'severity' | 'type'>>;
+}
+
+// ─── Constants ──────────────────────────────────────────────────────
+
+const CRITICAL_KEYWORDS = ['never', 'must not', 'critical', 'security', 'vulnerability'];
+const WARNING_KEYWORDS = ['avoid', 'should not', 'deprecated', 'careful', 'warning'];
+const ANTI_PATTERN_PREFIXES = ['avoid', 'never', "don't", 'do not'];
+
+// ─── Enrich ─────────────────────────────────────────────────────────
+
+export function enrichEntryMetadata(entry: IntelligenceEntry): EnrichResult {
+  const changes: MetadataChange[] = [];
+  const updates: EnrichResult['updates'] = {};
+
+  // Auto-capitalize title
+  if (entry.title.length > 0 && entry.title[0] !== entry.title[0].toUpperCase()) {
+    const capitalized = entry.title[0].toUpperCase() + entry.title.slice(1);
+    changes.push({ field: 'title', before: entry.title, after: capitalized });
+    updates.title = capitalized;
+  }
+
+  // Normalize tags: lowercase, trim, dedup
+  const normalizedTags = [...new Set(entry.tags.map((t) => t.toLowerCase().trim()))];
+  const tagsChanged =
+    normalizedTags.length !== entry.tags.length ||
+    normalizedTags.some((t, i) => t !== entry.tags[i]);
+  if (tagsChanged) {
+    changes.push({
+      field: 'tags',
+      before: JSON.stringify(entry.tags),
+      after: JSON.stringify(normalizedTags),
+    });
+    updates.tags = normalizedTags;
+  }
+
+  // Infer severity from keywords if currently 'suggestion'
+  if (entry.severity === 'suggestion') {
+    const text = (entry.title + ' ' + entry.description).toLowerCase();
+    if (CRITICAL_KEYWORDS.some((k) => text.includes(k))) {
+      changes.push({ field: 'severity', before: entry.severity, after: 'critical' });
+      updates.severity = 'critical';
+    } else if (WARNING_KEYWORDS.some((k) => text.includes(k))) {
+      changes.push({ field: 'severity', before: entry.severity, after: 'warning' });
+      updates.severity = 'warning';
+    }
+  }
+
+  // Infer type from title patterns
+  if (entry.type === 'pattern') {
+    const titleLower = entry.title.toLowerCase();
+    if (ANTI_PATTERN_PREFIXES.some((p) => titleLower.startsWith(p))) {
+      changes.push({ field: 'type', before: entry.type, after: 'anti-pattern' });
+      updates.type = 'anti-pattern';
+    }
+  }
+
+  // Trim whitespace from description
+  const trimmed = entry.description.trim();
+  if (trimmed !== entry.description) {
+    changes.push({ field: 'description', before: entry.description, after: trimmed });
+    updates.description = trimmed;
+  }
+
+  return { changes, updates };
+}

package/src/curator/quality-gate.test.ts

@@ -0,0 +1,135 @@
+import { describe, it, expect, vi } from 'vitest';
+import { evaluateQuality } from './quality-gate.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('evaluateQuality', () => {
+  it('returns ACCEPT fallback when llm is null', async () => {
+    const result = await evaluateQuality(makeEntry(), null);
+    expect(result.evaluated).toBe(false);
+    expect(result.verdict).toBe('ACCEPT');
+    expect(result.overallScore).toBe(50);
+    expect(result.reasoning).toContain('LLM unavailable');
+  });
+
+  it('returns ACCEPT for high-quality entry', async () => {
+    const llm = mockLLM(JSON.stringify({
+      verdict: 'ACCEPT',
+      overallScore: 85,
+      scores: { novelty: 80, actionability: 90, specificity: 85, relevance: 80, informationDensity: 90 },
+      reasoning: 'High quality entry with specific guidance.',
+    }));
+
+    const result = await evaluateQuality(makeEntry(), llm);
+    expect(result.evaluated).toBe(true);
+    expect(result.verdict).toBe('ACCEPT');
+    expect(result.overallScore).toBe(85);
+  });
+
+  it('returns REJECT for low-quality entry', async () => {
+    const llm = mockLLM(JSON.stringify({
+      verdict: 'REJECT',
+      overallScore: 30,
+      scores: { novelty: 10, actionability: 30, specificity: 40, relevance: 50, informationDensity: 20 },
+      reasoning: 'Too generic.',
+      rejectReasons: ['Low novelty', 'Not actionable'],
+    }));
+
+    const result = await evaluateQuality(makeEntry(), llm);
+    expect(result.evaluated).toBe(true);
+    expect(result.verdict).toBe('REJECT');
+    expect(result.overallScore).toBe(30);
+    expect(result.rejectReasons).toEqual(['Low novelty', 'Not actionable']);
+  });
+
+  it('returns fallback with error on LLM failure', async () => {
+    const llm = {
+      complete: vi.fn().mockRejectedValue(new Error('timeout')),
+    } as unknown as LLMClient;
+
+    const result = await evaluateQuality(makeEntry(), llm);
+    expect(result.evaluated).toBe(false);
+    expect(result.verdict).toBe('ACCEPT');
+    expect(result.error).toBe('timeout');
+  });
+
+  it('returns fallback with error on invalid JSON', async () => {
+    const llm = mockLLM('invalid json response');
+    const result = await evaluateQuality(makeEntry(), llm);
+    expect(result.evaluated).toBe(false);
+    expect(result.error).toBeDefined();
+  });
+
+  it('handles missing fields in LLM response', async () => {
+    const llm = mockLLM(JSON.stringify({ verdict: 'ACCEPT' }));
+    const result = await evaluateQuality(makeEntry(), llm);
+    expect(result.evaluated).toBe(true);
+    expect(result.overallScore).toBe(50);
+    expect(result.reasoning).toBe('');
+  });
+
+  it('normalizes non-REJECT verdict to ACCEPT', async () => {
+    const llm = mockLLM(JSON.stringify({
+      verdict: 'MAYBE',
+      overallScore: 60,
+      scores: { novelty: 60, actionability: 60, specificity: 60, relevance: 60, informationDensity: 60 },
+      reasoning: 'Borderline entry.',
+    }));
+
+    const result = await evaluateQuality(makeEntry(), llm);
+    expect(result.verdict).toBe('ACCEPT');
+  });
+
+  it('includes optional entry fields in prompt', async () => {
+    const llm = mockLLM(JSON.stringify({
+      verdict: 'ACCEPT',
+      overallScore: 70,
+      scores: { novelty: 70, actionability: 70, specificity: 70, relevance: 70, informationDensity: 70 },
+      reasoning: 'OK.',
+    }));
+
+    const entry = makeEntry();
+    entry.why = 'Because security matters';
+    entry.example = 'jwt.verify(token)';
+    entry.context = 'Node.js backend';
+
+    await evaluateQuality(entry, llm);
+
+    const call = (llm.complete as ReturnType<typeof vi.fn>).mock.calls[0][0];
+    expect(call.userPrompt).toContain('Because security matters');
+    expect(call.userPrompt).toContain('jwt.verify(token)');
+    expect(call.userPrompt).toContain('Node.js backend');
+  });
+
+  it('uses low temperature for consistent scoring', async () => {
+    const llm = mockLLM(JSON.stringify({
+      verdict: 'ACCEPT',
+      overallScore: 70,
+      scores: { novelty: 70, actionability: 70, specificity: 70, relevance: 70, informationDensity: 70 },
+      reasoning: 'OK.',
+    }));
+
+    await evaluateQuality(makeEntry(), llm);
+
+    const call = (llm.complete as ReturnType<typeof vi.fn>).mock.calls[0][0];
+    expect(call.temperature).toBe(0.1);
+  });
+});