@vue-skuilder/db 0.1.17 → 0.1.20

package/tests/core/navigators/PipelineAssembler.test.ts

@@ -0,0 +1,351 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import {
+  PipelineAssembler,
+  PipelineAssemblerInput,
+} from '../../../src/core/navigators/PipelineAssembler';
+import { ContentNavigationStrategyData } from '../../../src/core/types/contentNavigationStrategy';
+import { DocType } from '../../../src/core';
+import { Pipeline } from '../../../src/core/navigators/Pipeline';
+
+// Mock the dynamic import in ContentNavigator.create
+vi.mock('../../../src/core/navigators/elo', () => ({
+  default: class MockELONavigator {
+    name = 'ELO';
+    constructor(
+      public user: any,
+      public course: any,
+      public strategyData: any
+    ) {}
+    async getWeightedCards() {
+      return [];
+    }
+    async getNewCards() {
+      return [];
+    }
+    async getPendingReviews() {
+      return [];
+    }
+  },
+}));
+
+vi.mock('../../../src/core/navigators/srs', () => ({
+  default: class MockSRSNavigator {
+    name = 'SRS';
+    constructor(
+      public user: any,
+      public course: any,
+      public strategyData: any
+    ) {}
+    async getWeightedCards() {
+      return [];
+    }
+    async getNewCards() {
+      return [];
+    }
+    async getPendingReviews() {
+      return [];
+    }
+  },
+}));
+
+vi.mock('../../../src/core/navigators/hardcodedOrder', () => ({
+  default: class MockHardcodedOrderNavigator {
+    name = 'Hardcoded Order';
+    constructor(
+      public user: any,
+      public course: any,
+      public strategyData: any
+    ) {}
+    async getWeightedCards() {
+      return [];
+    }
+    async getNewCards() {
+      return [];
+    }
+    async getPendingReviews() {
+      return [];
+    }
+  },
+}));
+
+vi.mock('../../../src/core/navigators/hierarchyDefinition', () => ({
+  default: class MockHierarchyDefinitionNavigator {
+    name = 'Hierarchy Definition';
+    constructor(
+      public user: any,
+      public course: any,
+      public strategyData: any
+    ) {
+      this.name = strategyData.name || 'Hierarchy Definition';
+    }
+    async transform(cards: any[]) {
+      return cards;
+    }
+    async getWeightedCards() {
+      throw new Error('Filter should not be used as generator');
+    }
+    async getNewCards() {
+      return [];
+    }
+    async getPendingReviews() {
+      return [];
+    }
+  },
+}));
+
+vi.mock('../../../src/core/navigators/interferenceMitigator', () => ({
+  default: class MockInterferenceMitigatorNavigator {
+    name = 'Interference Mitigator';
+    constructor(
+      public user: any,
+      public course: any,
+      public strategyData: any
+    ) {
+      this.name = strategyData.name || 'Interference Mitigator';
+    }
+    async transform(cards: any[]) {
+      return cards;
+    }
+    async getWeightedCards() {
+      throw new Error('Filter should not be used as generator');
+    }
+    async getNewCards() {
+      return [];
+    }
+    async getPendingReviews() {
+      return [];
+    }
+  },
+}));
+
+vi.mock('../../../src/core/navigators/relativePriority', () => ({
+  default: class MockRelativePriorityNavigator {
+    name = 'Relative Priority';
+    constructor(
+      public user: any,
+      public course: any,
+      public strategyData: any
+    ) {
+      this.name = strategyData.name || 'Relative Priority';
+    }
+    async transform(cards: any[]) {
+      return cards;
+    }
+    async getWeightedCards() {
+      throw new Error('Filter should not be used as generator');
+    }
+    async getNewCards() {
+      return [];
+    }
+    async getPendingReviews() {
+      return [];
+    }
+  },
+}));
+
+describe('PipelineAssembler', () => {
+  const assembler = new PipelineAssembler();
+
+  // Mock user and course for instantiation
+  const mockUser = {
+    getCourseRegDoc: vi
+      .fn()
+      .mockResolvedValue({ elo: { global: { score: 1000, count: 0 }, tags: {} } }),
+    getPendingReviews: vi.fn().mockResolvedValue([]),
+    getActiveCards: vi.fn().mockResolvedValue([]),
+  };
+
+  const mockCourse = {
+    getCourseID: vi.fn().mockReturnValue('test-course'),
+    getCardEloData: vi.fn().mockResolvedValue([]),
+    getAppliedTags: vi.fn().mockResolvedValue({ rows: [] }),
+  };
+
+  function createStrategy(
+    name: string,
+    implementingClass: string,
+    serializedData = '{}'
+  ): ContentNavigationStrategyData {
+    return {
+      _id: `NAVIGATION_STRATEGY-${name}`,
+      course: 'test-course',
+      docType: DocType.NAVIGATION_STRATEGY,
+      name,
+      description: `Test strategy: ${name}`,
+      implementingClass,
+      serializedData,
+    };
+  }
+
+  function createInput(strategies: ContentNavigationStrategyData[]): PipelineAssemblerInput {
+    return {
+      strategies,
+      user: mockUser as any,
+      course: mockCourse as any,
+    };
+  }
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  describe('empty input', () => {
+    it('returns null pipeline when no strategy documents exist', async () => {
+      const input = createInput([]);
+      const result = await assembler.assemble(input);
+
+      expect(result.pipeline).toBeNull();
+      expect(result.generatorStrategies).toEqual([]);
+      expect(result.filterStrategies).toEqual([]);
+      expect(result.warnings).toEqual([]);
+    });
+  });
+
+  describe('generator-only scenarios', () => {
+    it('returns pipeline with single generator when no filters exist', async () => {
+      const elo = createStrategy('elo-strategy', 'elo');
+      const input = createInput([elo]);
+      const result = await assembler.assemble(input);
+
+      expect(result.pipeline).toBeInstanceOf(Pipeline);
+      expect(result.generatorStrategies).toEqual([elo]);
+      expect(result.filterStrategies).toEqual([]);
+      expect(result.warnings).toEqual([]);
+    });
+
+    it('creates CompositeGenerator when multiple generators exist', async () => {
+      const elo1 = createStrategy('elo-1', 'elo');
+      const elo2 = createStrategy('elo-2', 'srs');
+      const input = createInput([elo1, elo2]);
+      const result = await assembler.assemble(input);
+
+      expect(result.pipeline).toBeInstanceOf(Pipeline);
+      expect(result.generatorStrategies).toEqual([elo1, elo2]);
+      expect(result.warnings).toEqual([]);
+    });
+
+    it('uses default ELO when filters exist but no generator', async () => {
+      const hierarchy = createStrategy('hierarchy', 'hierarchyDefinition');
+      const input = createInput([hierarchy]);
+      const result = await assembler.assemble(input);
+
+      expect(result.pipeline).toBeInstanceOf(Pipeline);
+      expect(result.generatorStrategies).toHaveLength(1);
+      expect(result.generatorStrategies[0].implementingClass).toBe('elo');
+      expect(result.generatorStrategies[0].name).toBe('ELO (default)');
+      expect(result.filterStrategies).toEqual([hierarchy]);
+      expect(result.warnings).toEqual([]);
+    });
+  });
+
+  describe('filter handling', () => {
+    it('includes single filter in pipeline', async () => {
+      const elo = createStrategy('elo', 'elo');
+      const hierarchy = createStrategy('hierarchy', 'hierarchyDefinition', '{"prerequisites": {}}');
+      const input = createInput([elo, hierarchy]);
+      const result = await assembler.assemble(input);
+
+      expect(result.pipeline).toBeInstanceOf(Pipeline);
+      expect(result.generatorStrategies).toEqual([elo]);
+      expect(result.filterStrategies).toEqual([hierarchy]);
+      expect(result.warnings).toEqual([]);
+    });
+
+    it('sorts filters alphabetically for deterministic ordering', async () => {
+      const elo = createStrategy('elo', 'elo');
+      const relativePriority = createStrategy(
+        'z-relative-priority',
+        'relativePriority',
+        '{"tagPriorities": {}}'
+      );
+      const hierarchy = createStrategy(
+        'a-hierarchy',
+        'hierarchyDefinition',
+        '{"prerequisites": {}}'
+      );
+      const interference = createStrategy(
+        'm-interference',
+        'interferenceMitigator',
+        '{"interferenceSets": []}'
+      );
+
+      const input = createInput([elo, relativePriority, hierarchy, interference]);
+      const result = await assembler.assemble(input);
+
+      expect(result.pipeline).toBeInstanceOf(Pipeline);
+      expect(result.generatorStrategies).toEqual([elo]);
+
+      // Filters should be sorted alphabetically by name
+      expect(result.filterStrategies.map((f) => f.name)).toEqual([
+        'a-hierarchy',
+        'm-interference',
+        'z-relative-priority',
+      ]);
+    });
+  });
+
+  describe('error handling', () => {
+    it('skips unknown strategy types with warning', async () => {
+      const elo = createStrategy('elo', 'elo');
+      const unknown = createStrategy('unknown', 'unknownStrategyType');
+      const hierarchy = createStrategy('hierarchy', 'hierarchyDefinition');
+
+      const input = createInput([elo, unknown, hierarchy]);
+      const result = await assembler.assemble(input);
+
+      expect(result.pipeline).toBeInstanceOf(Pipeline);
+      expect(result.generatorStrategies).toEqual([elo]);
+      expect(result.filterStrategies).toEqual([hierarchy]);
+      expect(result.warnings).toContain(
+        "Unknown strategy type 'unknownStrategyType', skipping: unknown"
+      );
+    });
+  });
+
+  describe('complex scenarios', () => {
+    it('handles multiple generators and multiple filters', async () => {
+      const elo = createStrategy('elo', 'elo');
+      const hardcoded = createStrategy('hardcoded', 'hardcodedOrder');
+      const hierarchy = createStrategy('hierarchy', 'hierarchyDefinition');
+      const relativePriority = createStrategy('priority', 'relativePriority');
+
+      const input = createInput([elo, hardcoded, hierarchy, relativePriority]);
+      const result = await assembler.assemble(input);
+
+      // Should have both generators
+      expect(result.generatorStrategies).toEqual([elo, hardcoded]);
+
+      // Should have both filters (sorted alphabetically)
+      expect(result.filterStrategies.map((f) => f.name)).toEqual(['hierarchy', 'priority']);
+
+      // Should produce a valid pipeline
+      expect(result.pipeline).toBeInstanceOf(Pipeline);
+    });
+
+    it('maintains deterministic ordering regardless of input order', async () => {
+      const elo = createStrategy('elo', 'elo');
+      const filterA = createStrategy('a-filter', 'hierarchyDefinition');
+      const filterB = createStrategy('b-filter', 'relativePriority');
+      const filterC = createStrategy('c-filter', 'interferenceMitigator');
+
+      // Try different input orders
+      const input1 = createInput([filterC, elo, filterA, filterB]);
+      const input2 = createInput([filterB, filterA, filterC, elo]);
+
+      const result1 = await assembler.assemble(input1);
+      const result2 = await assembler.assemble(input2);
+
+      // Both should produce filters in same alphabetical order
+      expect(result1.filterStrategies.map((f) => f.name)).toEqual([
+        'a-filter',
+        'b-filter',
+        'c-filter',
+      ]);
+      expect(result2.filterStrategies.map((f) => f.name)).toEqual([
+        'a-filter',
+        'b-filter',
+        'c-filter',
+      ]);
+    });
+  });
+});

package/tests/core/navigators/SRSNavigator.test.ts

@@ -0,0 +1,344 @@
+import { describe, it, expect } from 'vitest';
+import moment from 'moment';
+import { ScheduledCard } from '../../../src/core/types/user';
+import { getCardOrigin, WeightedCard } from '../../../src/core/navigators/index';
+
+// ============================================================================
+// SRS NAVIGATOR SCORING TESTS
+// ============================================================================
+//
+// Tests for the SRS Navigator's urgency scoring formula.
+// The formula considers:
+// 1. Relative overdueness: hoursOverdue / intervalHours
+// 2. Interval recency: shorter intervals indicate active learning
+//
+// ============================================================================
+
+/**
+ * Compute urgency score for a review card.
+ * This is a standalone implementation of the scoring logic for testing.
+ */
+function computeUrgencyScore(
+  scheduledAt: moment.Moment,
+  reviewTime: moment.Moment,
+  now: moment.Moment
+): { score: number; relativeOverdue: number; recencyFactor: number; intervalHours: number } {
+  // Interval = time between scheduling and due date (minimum 1 hour)
+  const intervalHours = Math.max(1, reviewTime.diff(scheduledAt, 'hours'));
+  const hoursOverdue = now.diff(reviewTime, 'hours');
+
+  // Relative overdueness: how late relative to the interval
+  const relativeOverdue = hoursOverdue / intervalHours;
+
+  // Interval recency factor: shorter intervals = more urgent
+  const recencyFactor = 0.3 + 0.7 * Math.exp(-intervalHours / 720);
+
+  // Combined urgency
+  const overdueContribution = Math.min(1.0, Math.max(0, relativeOverdue));
+  const urgency = overdueContribution * 0.5 + recencyFactor * 0.5;
+
+  // Final score
+  const score = Math.min(0.95, 0.5 + urgency * 0.45);
+
+  return { score, relativeOverdue, recencyFactor, intervalHours };
+}
+
+/**
+ * Helper to create a mock scheduled card for testing
+ */
+function createMockReview(
+  scheduledAt: moment.Moment,
+  reviewTime: moment.Moment,
+  cardId: string = 'card-1'
+): ScheduledCard {
+  return {
+    _id: `SCHEDULED_CARD-${cardId}`,
+    cardId,
+    courseId: 'test-course',
+    scheduledAt: scheduledAt.toISOString(),
+    reviewTime: reviewTime.toISOString(),
+    scheduledFor: 'course',
+    schedulingAgentId: 'test-course',
+  };
+}
+
+describe('SRS urgency scoring formula', () => {
+  const now = moment.utc('2024-01-15T12:00:00Z');
+
+  describe('relative overdueness', () => {
+    it('should compute higher relative overdueness for shorter intervals', () => {
+      // 3-day interval, 2 days overdue
+      const shortInterval = computeUrgencyScore(
+        moment.utc('2024-01-09T12:00:00Z'), // scheduled 6 days ago
+        moment.utc('2024-01-12T12:00:00Z'), // due 3 days ago (3-day interval)
+        now
+      );
+
+      // 30-day interval, 2 days overdue
+      const longInterval = computeUrgencyScore(
+        moment.utc('2023-12-14T12:00:00Z'), // scheduled 32 days ago
+        moment.utc('2024-01-13T12:00:00Z'), // due 2 days ago (30-day interval)
+        now
+      );
+
+      // Short interval should have MUCH higher relative overdueness
+      expect(shortInterval.relativeOverdue).toBeGreaterThan(0.9); // ~1.0 (3 days / 3 days)
+      expect(longInterval.relativeOverdue).toBeLessThan(0.1); // ~0.067 (2 days / 30 days)
+      expect(shortInterval.relativeOverdue).toBeGreaterThan(longInterval.relativeOverdue * 10);
+    });
+
+    it('should clamp relative overdueness at 1.0 for score calculation', () => {
+      // Extremely overdue: 10 days overdue on 3-day interval
+      const extremelyOverdue = computeUrgencyScore(
+        moment.utc('2024-01-02T12:00:00Z'), // scheduled 13 days ago
+        moment.utc('2024-01-05T12:00:00Z'), // due 10 days ago (3-day interval)
+        now
+      );
+
+      // relativeOverdue is unclamped for diagnostics
+      expect(extremelyOverdue.relativeOverdue).toBeGreaterThan(3);
+
+      // But score should still be within bounds
+      expect(extremelyOverdue.score).toBeLessThanOrEqual(0.95);
+      expect(extremelyOverdue.score).toBeGreaterThan(0.5);
+    });
+  });
+
+  describe('interval recency factor', () => {
+    it('should return ~1.0 for very short intervals (24h)', () => {
+      const result = computeUrgencyScore(
+        moment.utc('2024-01-14T12:00:00Z'), // scheduled 1 day ago
+        moment.utc('2024-01-15T11:00:00Z'), // due 1 hour ago (23h interval)
+        now
+      );
+
+      expect(result.recencyFactor).toBeGreaterThan(0.95);
+    });
+
+    it('should return ~0.56 for 30-day intervals', () => {
+      const result = computeUrgencyScore(
+        moment.utc('2023-12-15T12:00:00Z'), // scheduled 31 days ago
+        moment.utc('2024-01-14T12:00:00Z'), // due 1 day ago (30-day interval)
+        now
+      );
+
+      // 0.3 + 0.7 * exp(-720/720) = 0.3 + 0.7 * 0.368 ≈ 0.56
+      expect(result.recencyFactor).toBeCloseTo(0.56, 1);
+    });
+
+    it('should return ~0.30 for very long intervals (180+ days)', () => {
+      const result = computeUrgencyScore(
+        moment.utc('2023-07-10T12:00:00Z'), // scheduled 189 days ago
+        moment.utc('2024-01-14T12:00:00Z'), // due 1 day ago (188-day interval)
+        now
+      );
+
+      // Approaches 0.3 asymptotically
+      expect(result.recencyFactor).toBeLessThan(0.35);
+      expect(result.recencyFactor).toBeGreaterThanOrEqual(0.3);
+    });
+  });
+
+  describe('combined scoring', () => {
+    it('should score 3-day interval 2-days-overdue higher than 180-day interval 2-days-overdue', () => {
+      // The key example from the plan
+      const shortInterval = computeUrgencyScore(
+        moment.utc('2024-01-09T12:00:00Z'), // 3-day interval
+        moment.utc('2024-01-12T12:00:00Z'), // 3 days overdue (72h)
+        now
+      );
+
+      const longInterval = computeUrgencyScore(
+        moment.utc('2023-07-10T12:00:00Z'), // 180-day interval
+        moment.utc('2024-01-13T12:00:00Z'), // 2 days overdue (48h)
+        now
+      );
+
+      expect(shortInterval.score).toBeGreaterThan(longInterval.score);
+      // Short interval should be significantly higher
+      expect(shortInterval.score - longInterval.score).toBeGreaterThan(0.1);
+    });
+
+    it('should produce scores within expected range', () => {
+      // Just due (0h overdue, 24h interval)
+      const justDue = computeUrgencyScore(
+        moment.utc('2024-01-14T12:00:00Z'),
+        moment.utc('2024-01-15T12:00:00Z'),
+        now
+      );
+
+      // Very overdue (7 days on 1 day interval)
+      const veryOverdue = computeUrgencyScore(
+        moment.utc('2024-01-07T12:00:00Z'),
+        moment.utc('2024-01-08T12:00:00Z'),
+        now
+      );
+
+      // All scores should be in [0.5, 0.95] range
+      expect(justDue.score).toBeGreaterThanOrEqual(0.5);
+      expect(justDue.score).toBeLessThanOrEqual(0.95);
+      expect(veryOverdue.score).toBeGreaterThanOrEqual(0.5);
+      expect(veryOverdue.score).toBeLessThanOrEqual(0.95);
+
+      // Very overdue should be higher
+      expect(veryOverdue.score).toBeGreaterThan(justDue.score);
+    });
+
+    it('should match expected scores from plan table', () => {
+      // From the plan:
+      // | Interval | Overdue | Relative | Recency | Score |
+      // | 3 days   | 2 days  | 0.67     | 0.93    | 0.87  |
+      // | 30 days  | 2 days  | 0.07     | 0.65    | 0.68  |
+      // | 180 days | 2 days  | 0.01     | 0.35    | 0.59  |
+      // | 1 day    | 6 hours | 0.25     | 0.99    | 0.78  |
+
+      const case1 = computeUrgencyScore(
+        moment.utc('2024-01-10T12:00:00Z'), // 3-day interval
+        moment.utc('2024-01-13T12:00:00Z'), // 2 days overdue
+        now
+      );
+      expect(case1.score).toBeCloseTo(0.87, 1);
+
+      const case2 = computeUrgencyScore(
+        moment.utc('2023-12-14T12:00:00Z'), // 30-day interval
+        moment.utc('2024-01-13T12:00:00Z'), // 2 days overdue
+        now
+      );
+      expect(case2.score).toBeCloseTo(0.68, 1);
+
+      const case3 = computeUrgencyScore(
+        moment.utc('2023-07-19T12:00:00Z'), // 180-day interval
+        moment.utc('2024-01-13T12:00:00Z'), // 2 days overdue
+        now
+      );
+      expect(case3.score).toBeCloseTo(0.59, 1);
+
+      // 1 day interval, 6 hours overdue
+      const case4 = computeUrgencyScore(
+        moment.utc('2024-01-14T06:00:00Z'), // 1-day interval (24h)
+        moment.utc('2024-01-15T06:00:00Z'), // 6 hours overdue
+        now
+      );
+      expect(case4.score).toBeCloseTo(0.78, 1);
+    });
+  });
+
+  describe('edge cases', () => {
+    it('should handle exactly due cards (0 hours overdue)', () => {
+      const exactlyDue = computeUrgencyScore(
+        moment.utc('2024-01-14T12:00:00Z'),
+        moment.utc('2024-01-15T12:00:00Z'), // exactly now
+        now
+      );
+
+      // Should still get a reasonable score from recency factor
+      expect(exactlyDue.score).toBeGreaterThan(0.5);
+      expect(exactlyDue.relativeOverdue).toBe(0);
+    });
+
+    it('should handle very short intervals (1 hour)', () => {
+      const shortInterval = computeUrgencyScore(
+        moment.utc('2024-01-15T10:00:00Z'),
+        moment.utc('2024-01-15T11:00:00Z'), // 1 hour interval, 1 hour overdue
+        now
+      );
+
+      // Very short interval should have high recency
+      expect(shortInterval.recencyFactor).toBeGreaterThan(0.99);
+    });
+
+    it('should use minimum 1 hour interval to avoid division issues', () => {
+      // Simultaneous schedule and due (edge case)
+      const zeroInterval = computeUrgencyScore(
+        moment.utc('2024-01-15T11:00:00Z'),
+        moment.utc('2024-01-15T11:00:00Z'), // same time
+        now
+      );
+
+      expect(zeroInterval.intervalHours).toBe(1);
+      expect(Number.isFinite(zeroInterval.score)).toBe(true);
+    });
+  });
+});
+
+describe('SRS Navigator card filtering', () => {
+  it('should only include cards that are actually due', () => {
+    const now = moment.utc('2024-01-15T12:00:00Z');
+
+    const dueCard = createMockReview(
+      moment.utc('2024-01-12T12:00:00Z'),
+      moment.utc('2024-01-14T12:00:00Z'), // due yesterday
+      'due-card'
+    );
+
+    const futureCard = createMockReview(
+      moment.utc('2024-01-14T12:00:00Z'),
+      moment.utc('2024-01-16T12:00:00Z'), // due tomorrow
+      'future-card'
+    );
+
+    const reviews = [dueCard, futureCard];
+    const dueReviews = reviews.filter((r) => now.isAfter(moment.utc(r.reviewTime)));
+
+    expect(dueReviews).toHaveLength(1);
+    expect(dueReviews[0].cardId).toBe('due-card');
+  });
+});
+
+describe('SRS Navigator provenance', () => {
+  it('should mark cards as reviews in provenance reason', () => {
+    // The reason string should contain "review" for getCardOrigin to work
+    const reason = `48h overdue (interval: 72h, relative: 0.67), recency: 0.93, review`;
+    expect(reason.toLowerCase()).toContain('review');
+  });
+
+  it('should work with getCardOrigin helper', () => {
+    const card: WeightedCard = {
+      cardId: 'test-card',
+      courseId: 'test-course',
+      score: 0.85,
+      provenance: [
+        {
+          strategy: 'srs',
+          strategyName: 'SRS',
+          strategyId: 'NAVIGATION_STRATEGY-SRS-default',
+          action: 'generated',
+          score: 0.85,
+          reason: '48h overdue (interval: 72h, relative: 0.67), recency: 0.93, review',
+        },
+      ],
+    };
+
+    expect(getCardOrigin(card)).toBe('review');
+  });
+});
+
+describe('SRS Navigator sorting', () => {
+  it('should sort cards by score descending', () => {
+    const now = moment.utc('2024-01-15T12:00:00Z');
+
+    // More urgent (short interval, very overdue)
+    const urgent = computeUrgencyScore(
+      moment.utc('2024-01-11T12:00:00Z'), // 3-day interval
+      moment.utc('2024-01-14T12:00:00Z'), // 1 day overdue
+      now
+    );
+
+    // Less urgent (long interval, slightly overdue)
+    const lessUrgent = computeUrgencyScore(
+      moment.utc('2023-12-15T12:00:00Z'), // 30-day interval
+      moment.utc('2024-01-14T12:00:00Z'), // 1 day overdue
+      now
+    );
+
+    const cards = [
+      { cardId: 'less-urgent', score: lessUrgent.score },
+      { cardId: 'urgent', score: urgent.score },
+    ];
+
+    const sorted = cards.sort((a, b) => b.score - a.score);
+
+    expect(sorted[0].cardId).toBe('urgent');
+    expect(sorted[1].cardId).toBe('less-urgent');
+  });
+});