@soleri/core 2.1.0 → 2.5.0

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

@@ -0,0 +1,271 @@
+import { describe, it, expect, afterEach } from 'vitest';
+import { createAgentRuntime } from '../runtime/runtime.js';
+import { createAdminOps } from '../runtime/admin-ops.js';
+import type { AgentRuntime } from '../runtime/types.js';
+import type { OpDefinition } from '../facades/types.js';
+
+describe('createAdminOps', () => {
+  let runtime: AgentRuntime;
+  let ops: OpDefinition[];
+
+  function findOp(name: string): OpDefinition {
+    const op = ops.find((o) => o.name === name);
+    if (!op) throw new Error(`Op "${name}" not found`);
+    return op;
+  }
+
+  afterEach(() => {
+    runtime?.close();
+  });
+
+  function setup() {
+    runtime = createAgentRuntime({
+      agentId: 'test-admin',
+      vaultPath: ':memory:',
+    });
+    ops = createAdminOps(runtime);
+  }
+
+  it('should return 8 ops', () => {
+    setup();
+    expect(ops).toHaveLength(8);
+    const names = ops.map((o) => o.name);
+    expect(names).toEqual([
+      'admin_health',
+      'admin_tool_list',
+      'admin_config',
+      'admin_vault_size',
+      'admin_uptime',
+      'admin_version',
+      'admin_reset_cache',
+      'admin_diagnostic',
+    ]);
+  });
+
+  // ─── admin_health ──────────────────────────────────────────────
+
+  describe('admin_health', () => {
+    it('should return comprehensive health status', async () => {
+      setup();
+      const result = (await findOp('admin_health').handler({})) as Record<string, unknown>;
+
+      expect(result.status).toBe('ok');
+      expect(result.vault).toEqual({ entries: 0, domains: [] });
+      expect(result.cognee).toEqual({ available: false });
+      expect(result.llm).toHaveProperty('openai');
+      expect(result.llm).toHaveProperty('anthropic');
+      expect(result.brain).toHaveProperty('vocabularySize');
+      expect(result.brain).toHaveProperty('feedbackCount');
+      expect(result.curator).toEqual({ initialized: true });
+    });
+
+    it('should reflect vault entries after seed', async () => {
+      setup();
+      runtime.vault.seed([
+        {
+          id: 'ah-1',
+          type: 'pattern',
+          domain: 'testing',
+          title: 'Health Test',
+          severity: 'warning',
+          description: 'Test entry.',
+          tags: ['test'],
+        },
+      ]);
+      const result = (await findOp('admin_health').handler({})) as Record<string, unknown>;
+      const vault = result.vault as { entries: number; domains: string[] };
+      expect(vault.entries).toBe(1);
+      expect(vault.domains).toContain('testing');
+    });
+  });
+
+  // ─── admin_tool_list ───────────────────────────────────────────
+
+  describe('admin_tool_list', () => {
+    it('should return fallback list without _allOps', async () => {
+      setup();
+      const result = (await findOp('admin_tool_list').handler({})) as {
+        count: number;
+        ops: Array<{ name: string }>;
+      };
+
+      expect(result.count).toBe(8);
+      expect(result.ops.map((o) => o.name)).toContain('admin_health');
+      expect(result.ops.map((o) => o.name)).toContain('admin_diagnostic');
+    });
+
+    it('should return injected ops when _allOps is provided', async () => {
+      setup();
+      const allOps = [
+        { name: 'search', description: 'Search vault', auth: 'read' },
+        { name: 'admin_health', description: 'Health check', auth: 'read' },
+      ];
+      const result = (await findOp('admin_tool_list').handler({ _allOps: allOps })) as {
+        count: number;
+        ops: Array<{ name: string; description: string; auth: string }>;
+      };
+
+      expect(result.count).toBe(2);
+      expect(result.ops[0].name).toBe('search');
+      expect(result.ops[1].name).toBe('admin_health');
+    });
+  });
+
+  // ─── admin_config ──────────────────────────────────────────────
+
+  describe('admin_config', () => {
+    it('should return runtime config', async () => {
+      setup();
+      const result = (await findOp('admin_config').handler({})) as Record<string, unknown>;
+
+      expect(result.agentId).toBe('test-admin');
+      expect(result.vaultPath).toBe(':memory:');
+      expect(result.logLevel).toBe('info');
+    });
+  });
+
+  // ─── admin_vault_size ──────────────────────────────────────────
+
+  describe('admin_vault_size', () => {
+    it('should return null size for in-memory vault', async () => {
+      setup();
+      const result = (await findOp('admin_vault_size').handler({})) as Record<string, unknown>;
+
+      expect(result.path).toBe(':memory:');
+      expect(result.sizeBytes).toBeNull();
+      expect(result.sizeHuman).toBe('in-memory');
+    });
+  });
+
+  // ─── admin_uptime ──────────────────────────────────────────────
+
+  describe('admin_uptime', () => {
+    it('should return uptime since creation', async () => {
+      setup();
+      const result = (await findOp('admin_uptime').handler({})) as Record<string, unknown>;
+
+      expect(result.createdAt).toBeDefined();
+      expect(typeof result.uptimeMs).toBe('number');
+      expect(typeof result.uptimeSec).toBe('number');
+      expect(typeof result.uptimeHuman).toBe('string');
+      expect(result.uptimeMs as number).toBeGreaterThanOrEqual(0);
+      expect(result.uptimeMs as number).toBeLessThan(5000); // should be nearly instant
+    });
+
+    it('should have valid ISO date in createdAt', async () => {
+      setup();
+      const result = (await findOp('admin_uptime').handler({})) as { createdAt: string };
+      const parsed = new Date(result.createdAt);
+      expect(parsed.getTime()).toBeGreaterThan(0);
+    });
+  });
+
+  // ─── admin_version ─────────────────────────────────────────────
+
+  describe('admin_version', () => {
+    it('should return version information', async () => {
+      setup();
+      const result = (await findOp('admin_version').handler({})) as Record<string, unknown>;
+
+      expect(typeof result.core).toBe('string');
+      expect(result.node).toMatch(/^v\d+/);
+      expect(typeof result.platform).toBe('string');
+      expect(typeof result.arch).toBe('string');
+    });
+  });
+
+  // ─── admin_reset_cache ─────────────────────────────────────────
+
+  describe('admin_reset_cache', () => {
+    it('should clear caches and return status', async () => {
+      setup();
+      const result = (await findOp('admin_reset_cache').handler({})) as Record<string, unknown>;
+
+      expect(result.cleared).toEqual(['brain_vocabulary', 'cognee_health_cache']);
+      expect(typeof (result as { brainVocabularySize: number }).brainVocabularySize).toBe('number');
+      expect(typeof (result as { cogneeAvailable: boolean }).cogneeAvailable).toBe('boolean');
+    });
+
+    it('should have write auth', () => {
+      setup();
+      const op = findOp('admin_reset_cache');
+      expect(op.auth).toBe('write');
+    });
+  });
+
+  // ─── admin_diagnostic ──────────────────────────────────────────
+
+  describe('admin_diagnostic', () => {
+    it('should return diagnostic report with all checks', async () => {
+      setup();
+      const result = (await findOp('admin_diagnostic').handler({})) as {
+        overall: string;
+        checks: Array<{ name: string; status: string; detail: string }>;
+        summary: string;
+      };
+
+      expect(['healthy', 'degraded', 'unhealthy']).toContain(result.overall);
+      expect(result.checks.length).toBeGreaterThanOrEqual(7);
+
+      const checkNames = result.checks.map((c) => c.name);
+      expect(checkNames).toContain('vault');
+      expect(checkNames).toContain('brain_vocabulary');
+      expect(checkNames).toContain('brain_intelligence');
+      expect(checkNames).toContain('cognee');
+      expect(checkNames).toContain('llm_openai');
+      expect(checkNames).toContain('llm_anthropic');
+      expect(checkNames).toContain('curator');
+    });
+
+    it('should report vault as ok for empty vault', async () => {
+      setup();
+      const result = (await findOp('admin_diagnostic').handler({})) as {
+        checks: Array<{ name: string; status: string }>;
+      };
+
+      const vaultCheck = result.checks.find((c) => c.name === 'vault');
+      expect(vaultCheck?.status).toBe('ok');
+    });
+
+    it('should report curator as ok', async () => {
+      setup();
+      const result = (await findOp('admin_diagnostic').handler({})) as {
+        checks: Array<{ name: string; status: string }>;
+      };
+
+      const curatorCheck = result.checks.find((c) => c.name === 'curator');
+      expect(curatorCheck?.status).toBe('ok');
+    });
+
+    it('should include summary string', async () => {
+      setup();
+      const result = (await findOp('admin_diagnostic').handler({})) as { summary: string };
+      expect(result.summary).toMatch(/\d+ checks:/);
+    });
+  });
+
+  // ─── Auth levels ───────────────────────────────────────────────
+
+  describe('auth levels', () => {
+    it('should use read auth for status ops', () => {
+      setup();
+      const readOps = [
+        'admin_health',
+        'admin_tool_list',
+        'admin_config',
+        'admin_vault_size',
+        'admin_uptime',
+        'admin_version',
+        'admin_diagnostic',
+      ];
+      for (const name of readOps) {
+        expect(findOp(name).auth).toBe('read');
+      }
+    });
+
+    it('should use write auth for mutation ops', () => {
+      setup();
+      expect(findOp('admin_reset_cache').auth).toBe('write');
+    });
+  });
+});

package/src/__tests__/brain-intelligence.test.ts

@@ -431,6 +431,41 @@ describe('BrainIntelligence', () => {
     expect(result.failed).toContain('non-existent');
   });
 
+  it('should gate promote through governance when strict preset', () => {
+    // Create a brain session and extract proposals
+    runtime.brainIntelligence.lifecycle({
+      action: 'start',
+      sessionId: 'gov-promo-1',
+      toolsUsed: ['w', 'w', 'w'],
+    });
+    runtime.brainIntelligence.lifecycle({ action: 'end', sessionId: 'gov-promo-1' });
+    runtime.brainIntelligence.extractKnowledge('gov-promo-1');
+
+    const proposals = runtime.brainIntelligence.getProposals({ sessionId: 'gov-promo-1' });
+    expect(proposals.length).toBeGreaterThan(0);
+
+    // Apply strict preset — requireReview: true
+    runtime.governance.applyPreset('.', 'strict', 'test');
+
+    const result = runtime.brainIntelligence.promoteProposals(
+      [proposals[0].id],
+      runtime.governance,
+      '.',
+    );
+
+    // Should be gated, not promoted
+    expect(result.promoted).toBe(0);
+    expect(result.gated.length).toBe(1);
+    expect(result.gated[0].action).toBe('propose');
+
+    // Entry should NOT be in vault
+    expect(runtime.vault.get(`proposal-${proposals[0].id}`)).toBeNull();
+
+    // But should be in governance proposals
+    const pending = runtime.governance.listPendingProposals('.');
+    expect(pending.some((p) => p.source === 'brain-promote')).toBe(true);
+  });
+
   // ─── Build Intelligence ────────────────────────────────────────
 
   it('should build intelligence pipeline', () => {
@@ -557,6 +592,7 @@ describe('BrainIntelligence', () => {
           filesModified: [],
           planId: null,
           planOutcome: null,
+          extractedAt: null,
         },
       ],
       proposals: [],
@@ -609,6 +645,7 @@ describe('BrainIntelligence', () => {
           filesModified: [],
           planId: null,
           planOutcome: null,
+          extractedAt: null,
         },
       ],
       proposals: [],
@@ -620,4 +657,172 @@ describe('BrainIntelligence', () => {
     const result = runtime.brainIntelligence.importData(data);
     expect(result.imported.sessions).toBe(0); // Duplicate ignored
   });
+
+  // ─── Auto-extraction on session end ─────────────────────────
+
+  it('should auto-extract when session ends with tools used', () => {
+    runtime.brainIntelligence.lifecycle({
+      action: 'start',
+      sessionId: 'auto-1',
+      domain: 'testing',
+      toolsUsed: ['search', 'search', 'search'],
+    });
+    const session = runtime.brainIntelligence.lifecycle({
+      action: 'end',
+      sessionId: 'auto-1',
+    });
+    // extractedAt should be set automatically
+    expect(session.extractedAt).not.toBeNull();
+  });
+
+  it('should not auto-extract when session has no signal', () => {
+    runtime.brainIntelligence.lifecycle({
+      action: 'start',
+      sessionId: 'auto-2',
+    });
+    const session = runtime.brainIntelligence.lifecycle({
+      action: 'end',
+      sessionId: 'auto-2',
+    });
+    // No tools, no files, no plan — should not extract
+    expect(session.extractedAt).toBeNull();
+  });
+
+  it('should auto-extract when session has a plan', () => {
+    runtime.brainIntelligence.lifecycle({
+      action: 'start',
+      sessionId: 'auto-3',
+      planId: 'plan-123',
+    });
+    const session = runtime.brainIntelligence.lifecycle({
+      action: 'end',
+      sessionId: 'auto-3',
+      planOutcome: 'completed',
+    });
+    expect(session.extractedAt).not.toBeNull();
+  });
+
+  // ─── extractedAt Tracking ──────────────────────────────────
+
+  it('should set extractedAt when extractKnowledge is called manually', () => {
+    // Use a session with no tools/files/plan so auto-extraction doesn't fire
+    runtime.brainIntelligence.lifecycle({
+      action: 'start',
+      sessionId: 'ext-1',
+      domain: 'testing',
+    });
+    runtime.brainIntelligence.lifecycle({
+      action: 'end',
+      sessionId: 'ext-1',
+    });
+
+    // Before manual extraction, extractedAt should be null (no auto-extract — no signal)
+    const ctx = runtime.brainIntelligence.getSessionContext(10);
+    const before = ctx.recentSessions.find((s) => s.id === 'ext-1');
+    expect(before?.extractedAt).toBeNull();
+
+    // Manual extract
+    runtime.brainIntelligence.extractKnowledge('ext-1');
+
+    // After extraction, extractedAt should be set
+    const ctx2 = runtime.brainIntelligence.getSessionContext(10);
+    const after = ctx2.recentSessions.find((s) => s.id === 'ext-1');
+    expect(after?.extractedAt).not.toBeNull();
+  });
+
+  // ─── resetExtracted ────────────────────────────────────────
+
+  it('should reset extractedAt for a specific session', () => {
+    runtime.brainIntelligence.lifecycle({
+      action: 'start',
+      sessionId: 'reset-1',
+      toolsUsed: ['a', 'a', 'a'],
+    });
+    runtime.brainIntelligence.lifecycle({ action: 'end', sessionId: 'reset-1' });
+    runtime.brainIntelligence.extractKnowledge('reset-1');
+
+    const result = runtime.brainIntelligence.resetExtracted({ sessionId: 'reset-1' });
+    expect(result.reset).toBe(1);
+
+    const ctx = runtime.brainIntelligence.getSessionContext(10);
+    const session = ctx.recentSessions.find((s) => s.id === 'reset-1');
+    expect(session?.extractedAt).toBeNull();
+  });
+
+  it('should reset all extracted sessions', () => {
+    runtime.brainIntelligence.lifecycle({
+      action: 'start',
+      sessionId: 'reset-a',
+      toolsUsed: ['a', 'a', 'a'],
+    });
+    runtime.brainIntelligence.lifecycle({ action: 'end', sessionId: 'reset-a' });
+    runtime.brainIntelligence.extractKnowledge('reset-a');
+
+    runtime.brainIntelligence.lifecycle({
+      action: 'start',
+      sessionId: 'reset-b',
+      toolsUsed: ['b', 'b', 'b'],
+    });
+    runtime.brainIntelligence.lifecycle({ action: 'end', sessionId: 'reset-b' });
+    runtime.brainIntelligence.extractKnowledge('reset-b');
+
+    const result = runtime.brainIntelligence.resetExtracted({ all: true });
+    expect(result.reset).toBe(2);
+  });
+
+  it('should return 0 when nothing to reset', () => {
+    const result = runtime.brainIntelligence.resetExtracted({ all: true });
+    expect(result.reset).toBe(0);
+  });
+
+  it('should return 0 when no filter is provided', () => {
+    const result = runtime.brainIntelligence.resetExtracted();
+    expect(result.reset).toBe(0);
+  });
+
+  it('should allow re-extraction after reset', () => {
+    runtime.brainIntelligence.lifecycle({
+      action: 'start',
+      sessionId: 'reext-1',
+      toolsUsed: ['search', 'search', 'search'],
+    });
+    runtime.brainIntelligence.lifecycle({ action: 'end', sessionId: 'reext-1' });
+
+    const first = runtime.brainIntelligence.extractKnowledge('reext-1');
+    expect(first.proposals.length).toBeGreaterThan(0);
+
+    runtime.brainIntelligence.resetExtracted({ sessionId: 'reext-1' });
+
+    const second = runtime.brainIntelligence.extractKnowledge('reext-1');
+    expect(second.proposals.length).toBeGreaterThan(0);
+  });
+
+  // ─── computeStrengths with modified feedback ───────────────
+
+  it('should weight modified feedback at 0.5 in computeStrengths', () => {
+    // Seed an entry for feedback to reference
+    runtime.vault.seed([
+      {
+        id: 'str-1',
+        type: 'pattern',
+        domain: 'testing',
+        title: 'Strength test pattern',
+        severity: 'warning',
+        description: 'Testing strength computation with modified feedback.',
+        tags: ['test'],
+      },
+    ]);
+
+    // Record feedback: 1 accepted, 1 modified, 1 failed
+    runtime.brain.recordFeedback({ query: 'q1', entryId: 'str-1', action: 'accepted' });
+    runtime.brain.recordFeedback({ query: 'q2', entryId: 'str-1', action: 'modified' });
+    runtime.brain.recordFeedback({ query: 'q3', entryId: 'str-1', action: 'failed' });
+
+    const strengths = runtime.brainIntelligence.computeStrengths();
+    const s = strengths.find((p) => p.pattern === 'Strength test pattern');
+    expect(s).toBeDefined();
+
+    // successRate = (1 + 0.5) / (3 - 1) = 1.5/2 = 0.75
+    expect(s!.successRate).toBeCloseTo(0.75, 2);
+  });
 });

package/src/__tests__/brain.test.ts

@@ -140,7 +140,7 @@ describe('Brain', () => {
       expect(breakdown).toHaveProperty('semantic');
       expect(breakdown).toHaveProperty('vector');
       expect(breakdown).toHaveProperty('severity');
-      expect(breakdown).toHaveProperty('recency');
+      expect(breakdown).toHaveProperty('temporalDecay');
       expect(breakdown).toHaveProperty('tagOverlap');
       expect(breakdown).toHaveProperty('domainMatch');
       expect(breakdown).toHaveProperty('total');
@@ -584,7 +584,7 @@ describe('Brain', () => {
         stats.weights.semantic +
         stats.weights.vector +
         stats.weights.severity +
-        stats.weights.recency +
+        stats.weights.temporalDecay +
         stats.weights.tagOverlap +
         stats.weights.domainMatch;
       expect(sum).toBeCloseTo(1.0, 5);
@@ -741,6 +741,137 @@ describe('Brain', () => {
     });
   });
 
+  // ─── Enhanced Feedback ─────────────────────────────────────
+
+  describe('enhanced feedback', () => {
+    beforeEach(() => {
+      vault.seed([makeEntry({ id: 'fb-1', title: 'Feedback test pattern', tags: ['feedback'] })]);
+      brain = new Brain(vault);
+    });
+
+    it('should accept legacy 3-arg form (backward compat)', () => {
+      brain.recordFeedback('test query', 'fb-1', 'accepted');
+      const stats = brain.getFeedbackStats();
+      expect(stats.total).toBe(1);
+      expect(stats.byAction['accepted']).toBe(1);
+    });
+
+    it('should accept FeedbackInput and return FeedbackEntry', () => {
+      const entry = brain.recordFeedback({
+        query: 'test query',
+        entryId: 'fb-1',
+        action: 'modified',
+        source: 'recommendation',
+        confidence: 0.85,
+        duration: 1200,
+        reason: 'adjusted wording',
+      });
+      expect(entry).toBeDefined();
+      expect(entry.action).toBe('modified');
+      expect(entry.source).toBe('recommendation');
+      expect(entry.confidence).toBe(0.85);
+      expect(entry.duration).toBe(1200);
+      expect(entry.reason).toBe('adjusted wording');
+      expect(entry.id).toBeGreaterThan(0);
+    });
+
+    it('should accept modified and failed action types', () => {
+      brain.recordFeedback({ query: 'q1', entryId: 'fb-1', action: 'modified' });
+      brain.recordFeedback({ query: 'q2', entryId: 'fb-1', action: 'failed' });
+      const stats = brain.getFeedbackStats();
+      expect(stats.total).toBe(2);
+      expect(stats.byAction['modified']).toBe(1);
+      expect(stats.byAction['failed']).toBe(1);
+    });
+
+    it('should use default source and confidence when not provided', () => {
+      const entry = brain.recordFeedback({ query: 'q1', entryId: 'fb-1', action: 'accepted' });
+      expect(entry.source).toBe('search');
+      expect(entry.confidence).toBe(0.6);
+    });
+  });
+
+  // ─── Feedback Stats ───────────────────────────────────────
+
+  describe('getFeedbackStats', () => {
+    beforeEach(() => {
+      vault.seed([makeEntry({ id: 'fs-1', tags: ['stats'] })]);
+      brain = new Brain(vault);
+    });
+
+    it('should return zero stats on empty feedback', () => {
+      const stats = brain.getFeedbackStats();
+      expect(stats.total).toBe(0);
+      expect(stats.acceptanceRate).toBe(0);
+      expect(stats.averageConfidence).toBe(0);
+    });
+
+    it('should compute acceptance rate correctly', () => {
+      brain.recordFeedback('q1', 'fs-1', 'accepted');
+      brain.recordFeedback('q2', 'fs-1', 'dismissed');
+      brain.recordFeedback('q3', 'fs-1', 'accepted');
+      const stats = brain.getFeedbackStats();
+      expect(stats.total).toBe(3);
+      expect(stats.acceptanceRate).toBeCloseTo(2 / 3, 2);
+    });
+
+    it('should group by action and source', () => {
+      brain.recordFeedback({ query: 'q1', entryId: 'fs-1', action: 'accepted', source: 'search' });
+      brain.recordFeedback({
+        query: 'q2',
+        entryId: 'fs-1',
+        action: 'modified',
+        source: 'recommendation',
+      });
+      brain.recordFeedback({
+        query: 'q3',
+        entryId: 'fs-1',
+        action: 'failed',
+        source: 'tool-execution',
+      });
+      const stats = brain.getFeedbackStats();
+      expect(stats.byAction['accepted']).toBe(1);
+      expect(stats.byAction['modified']).toBe(1);
+      expect(stats.byAction['failed']).toBe(1);
+      expect(stats.bySource['search']).toBe(1);
+      expect(stats.bySource['recommendation']).toBe(1);
+      expect(stats.bySource['tool-execution']).toBe(1);
+    });
+
+    it('should compute average confidence', () => {
+      brain.recordFeedback({ query: 'q1', entryId: 'fs-1', action: 'accepted', confidence: 0.9 });
+      brain.recordFeedback({ query: 'q2', entryId: 'fs-1', action: 'dismissed', confidence: 0.3 });
+      const stats = brain.getFeedbackStats();
+      expect(stats.averageConfidence).toBeCloseTo(0.6, 2);
+    });
+  });
+
+  // ─── Recompute Weights with Modified/Failed ──────────────
+
+  describe('recomputeWeights with modified/failed', () => {
+    beforeEach(() => {
+      vault.seed([makeEntry({ id: 'rw-1', tags: ['weights'] })]);
+      brain = new Brain(vault);
+    });
+
+    it('should exclude failed from weight computation', () => {
+      // Add enough feedback to exceed threshold (30)
+      for (let i = 0; i < 20; i++) {
+        brain.recordFeedback('q', 'rw-1', 'accepted');
+      }
+      for (let i = 0; i < 10; i++) {
+        brain.recordFeedback({ query: 'q', entryId: 'rw-1', action: 'failed' });
+      }
+      // Failed entries should not count toward total for weight adaptation
+      // 20 accepted out of 20 relevant = 100% accept rate
+      const stats = brain.getStats();
+      // Weights should have adapted since we have 30+ total but only 20 non-failed
+      // (threshold is 30, total is 30, but only 20 are non-failed so threshold not met)
+      // The recomputeWeights() counts non-failed, which is 20 < 30, so weights stay default
+      expect(stats.weights.semantic).toBeCloseTo(0.4, 2);
+    });
+  });
+
   // ─── Graceful Degradation ───────────────────────────────────
 
   describe('graceful degradation', () => {
@@ -750,7 +881,7 @@ describe('Brain', () => {
       expect(results).toEqual([]);
     });
 
-    it('should fall back to severity + recency scoring when vocabulary is empty', async () => {
+    it('should fall back to severity + temporalDecay scoring when vocabulary is empty', async () => {
       vault.seed([
         makeEntry({
           id: 'gd-1',