@vue-skuilder/db 0.1.23 → 0.1.25

package/src/study/SourceMixer.ts

@@ -30,16 +30,16 @@ export interface SourceMixer {
 }
 
 /**
- * Simple quota-based mixer: allocates equal representation to each source,
- * taking the top-N cards by score from each.
+ * Quota-based mixer with interleaved output.
  *
- * Guarantees balanced representation across sources regardless of absolute
- * score differences. A low-scoring source gets the same quota as a high-scoring
- * source.
+ * Allocates equal representation to each source (top-N by score), then
+ * interleaves the results by dealing from a randomly-shuffled source order.
+ * Within each source, cards are dealt in score-descending order.
  *
- * This is the KISS approach - simple, predictable, and fair in terms of
- * source representation (though not necessarily optimal in terms of absolute
- * card quality).
+ * This ensures that cards from different courses are spread throughout the
+ * queue rather than clustered by score bands, which matters because
+ * SessionController consumes queues front-to-back and sessions often end
+ * before reaching the tail.
  */
 export class QuotaRoundRobinMixer implements SourceMixer {
   mix(batches: SourceBatch[], limit: number): WeightedCard[] {
@@ -48,18 +48,37 @@ export class QuotaRoundRobinMixer implements SourceMixer {
     }
 
     const quotaPerSource = Math.ceil(limit / batches.length);
-    const mixed: WeightedCard[] = [];
 
-    for (const batch of batches) {
-      // Sort this source's cards by score descending
-      const sortedBatch = [...batch.weighted].sort((a, b) => b.score - a.score);
+    // Build per-source stacks sorted by score descending, capped at quota
+    const sourceStacks: WeightedCard[][] = batches.map((batch) => {
+      return [...batch.weighted].sort((a, b) => b.score - a.score).slice(0, quotaPerSource);
+    });
 
-      // Take top quotaPerSource from this source
-      const topFromSource = sortedBatch.slice(0, quotaPerSource);
-      mixed.push(...topFromSource);
+    // Shuffle the source ordering so no course is systematically first
+    for (let i = sourceStacks.length - 1; i > 0; i--) {
+      const j = Math.floor(Math.random() * (i + 1));
+      [sourceStacks[i], sourceStacks[j]] = [sourceStacks[j], sourceStacks[i]];
     }
 
-    // Sort the mixed result by score descending and return up to limit
-    return mixed.sort((a, b) => b.score - a.score).slice(0, limit);
+    // Interleave: deal one card from each source in rotation
+    const result: WeightedCard[] = [];
+    let exhausted = 0;
+    const cursors = new Array(sourceStacks.length).fill(0);
+
+    while (result.length < limit && exhausted < sourceStacks.length) {
+      exhausted = 0;
+      for (let s = 0; s < sourceStacks.length; s++) {
+        if (result.length >= limit) break;
+
+        if (cursors[s] < sourceStacks[s].length) {
+          result.push(sourceStacks[s][cursors[s]]);
+          cursors[s]++;
+        } else {
+          exhausted++;
+        }
+      }
+    }
+
+    return result;
   }
 }

package/src/study/TODO-session-scheduling.md

@@ -0,0 +1,133 @@
+# Session Scheduling: Observed Deficiencies & Future Work
+
+## Context
+
+Observed during debugging of multi-course study sessions (Feb 2026). A 5-minute
+session with 6 courses was scheduling ~101 cards (all available reviews) despite
+only having time for ~20. Cards were globally sorted by score, causing
+lower-scoring courses to be systematically unreached before session timeout.
+
+Debuggers added: `window.skuilder.mixer`, `window.skuilder.session`.
+
+## Completed
+
+- **Mixer interleaving**: `QuotaRoundRobinMixer` now interleaves output by
+  dealing from a randomly-shuffled source order instead of global score sort.
+  This spreads courses throughout the queue so time-cutoff doesn't
+  systematically exclude lower-scoring sources.
+
+- **MixerDebugger**: Captures cross-source mixing decisions. Shows input
+  batches, score distributions, selection rates, source balance analysis.
+
+- **SessionDebugger**: Tracks runtime card presentation order, course
+  interleaving patterns, clustering detection.
+
+## Phase A: Right-Size Initial Load
+
+**Problem**: `limit = 20` per source is hardcoded with no time-budget awareness.
+For 6 sources that's up to 120 candidates for a 5-minute session.
+
+**Approach**: Compute a realistic `targetCards` from session time and per-card
+time estimates:
+
+```
+targetCards = sessionTimeSeconds / avgCardTimeSeconds
+quotaPerSource = ceil(targetCards / numSources)
+```
+
+**Data available**: `CardRecord.timeSpent` (ms) exists on every historical
+record. `CardHistory.records[]` has full per-card history. Could compute:
+- Global user average (blunt but simple)
+- Per-origin averages (reviews typically faster than new cards)
+- Per-course averages (some courses have harder cards)
+
+**Also**: `estimateReviewTime()` currently uses a flat `5 * reviewQ.length`.
+Should use actual per-card time data, at minimum per-origin averages.
+
+**Considerations**:
+- Don't under-schedule — running out of cards mid-session is worse than
+  over-scheduling slightly
+- Historical data may not exist for new users; need a reasonable default
+- New cards take longer than reviews; weight accordingly
+
+## Phase B: Interleaving in _selectNextItemToHydrate
+
+**Problem**: Even with interleaved mixer output, the queue split into
+`reviewQ`/`newQ` can re-cluster by course if one course dominates reviews.
+`_selectNextItemToHydrate` always takes `peek(0)` — course-blind.
+
+**Approach**: After picking which queue, scan forward with small lookahead
+to prefer a different course than the last presented card.
+
+```
+1. Pick queue (existing probability logic)
+2. If peek(0).courseID === lastPresentedCourseID:
+     Scan peek(1)..peek(LOOKAHEAD) for different course
+3. If found: dequeue from that position
+4. If not found within lookahead: take peek(0) anyway
+```
+
+**Requires**: `dequeueAt(index)` method on `ItemQueue` (currently only
+dequeues from front).
+
+**Trade-offs**:
+- Lookahead window size (3-5 is probably right)
+- Don't starve a dominant course forever — bounded lookahead handles this
+- Interacts with hydration: the card at peek(3) may not be pre-hydrated.
+  Hydration window is currently 2 per queue. May need to increase slightly
+  or accept occasional hydration waits.
+
+## Phase C: Rolling Refill (Mid-Session Recalibration)
+
+**Problem**: All scheduling decisions are made at session start. No ability to
+adapt to actual session pace, user performance, or course balance during the
+session.
+
+**Current state**: Queues loaded once in `prepareSession()`. Only mutation
+during session is consumption + failure re-queuing. Hydration pre-caches 2 per
+queue (6 total) — so the vast majority of queued items are just waiting.
+
+**Approach**: Small initial load + async refill when queues run low.
+
+```
+1. Initial load: ~8-10 cards per source (enough for first few minutes)
+2. Monitor queue depth after each card presentation
+3. When queue drops below threshold (3-4 cards):
+   → Trigger async refill from source(s)
+   → Refill decisions factor in:
+     - Actual pace (cards completed / time elapsed)
+     - Course balance (which courses are underrepresented)
+     - User performance (more failures = slower pace)
+4. Refill populates queue; hydration service picks up new items naturally
+```
+
+**Key constraint**: Next card must always be pre-cached and ready without a DB
+lookup. This is satisfied because refills happen at queue level (async,
+background), and the hydration service already runs after each card.
+
+**Architecture considerations**:
+- `StudyContentSource.getWeightedCards()` would need to be callable
+  mid-session (currently only called in `prepareSession`)
+- Need to track which cards were already fetched to avoid duplicates
+  (ItemQueue.seenCardIds partially handles this)
+- Refill trigger should be non-blocking — fire and forget, let hydration
+  service handle the rest
+- Consider whether sources need a "cursor" or "offset" to avoid re-fetching
+  the same top-N cards
+
+## Related Observations
+
+- **Score normalization**: Different courses/navigators produce scores on
+  different effective ranges (e.g., 0.36-0.49 vs 0.70-0.98). The interleaving
+  fix addresses the presentation problem, but a MinMaxNormalizingMixer or
+  similar could address the selection problem for cases where quota-based
+  selection isn't desired.
+
+- **No user-level pace tracking**: The system has per-card `timeSpent` data but
+  no aggregated user pace metric. A lightweight running average (e.g.,
+  exponential moving average of last 20 cards) would be useful for both
+  Phase A (initial load sizing) and Phase C (refill decisions).
+
+- **`estimateCleanupTime` scope**: Currently only uses current-session records
+  for failed cards. Could also use historical `CardHistory` for cards the user
+  has seen before, giving better estimates for review failures.

package/src/study/index.ts

@@ -2,3 +2,5 @@ export * from './SessionController';
 export * from './SourceMixer';
 export * from './SpacedRepetition';
 export * from './TagFilteredContentSource';
+export * from './MixerDebugger';
+export * from './SessionDebugger';

package/src/study/services/EloService.ts

@@ -1,4 +1,9 @@
-import { adjustCourseScores, toCourseElo } from '@vue-skuilder/common';
+import {
+  adjustCourseScores,
+  adjustCourseScoresPerTag,
+  toCourseElo,
+  TaggedPerformance,
+} from '@vue-skuilder/common';
 import { DataLayerProvider, UserDBInterface, CourseRegistrationDoc } from '@db/core';
 import { StudySessionRecord } from '../SessionController';
 import { logger } from '@db/util/logger';
@@ -19,7 +24,7 @@ export class EloService {
    * Updates both user and card ELO ratings based on user performance.
    * @param userScore Score between 0-1 representing user performance
    * @param course_id Course identifier
-   * @param card_id Card identifier  
+   * @param card_id Card identifier
    * @param userCourseRegDoc User's course registration document (will be mutated)
    * @param currentCard Current card session record
    * @param k Optional K-factor for ELO calculation
@@ -36,7 +41,9 @@ export class EloService {
       logger.warn(`k value interpretation not currently implemented`);
     }
     const courseDB = this.dataLayer.getCourseDB(currentCard.card.course_id);
-    const userElo = toCourseElo(userCourseRegDoc.courses.find((c) => c.courseID === course_id)!.elo);
+    const userElo = toCourseElo(
+      userCourseRegDoc.courses.find((c) => c.courseID === course_id)!.elo
+    );
     const cardElo = (await courseDB.getCardEloData([currentCard.card.card_id]))[0];
 
     if (cardElo && userElo) {
@@ -82,4 +89,72 @@ export class EloService {
       }
     }
   }
-}
+
+  /**
+   * Updates both user and card ELO ratings with per-tag granularity.
+   * Tags in taggedPerformance but not on card will be created dynamically.
+   *
+   * @param taggedPerformance Performance object with _global and per-tag scores
+   * @param course_id Course identifier
+   * @param card_id Card identifier
+   * @param userCourseRegDoc User's course registration document (will be mutated)
+   * @param currentCard Current card session record
+   */
+  public async updateUserAndCardEloPerTag(
+    taggedPerformance: TaggedPerformance,
+    course_id: string,
+    card_id: string,
+    userCourseRegDoc: CourseRegistrationDoc,
+    currentCard: StudySessionRecord
+  ): Promise<void> {
+    const courseDB = this.dataLayer.getCourseDB(currentCard.card.course_id);
+    const userElo = toCourseElo(
+      userCourseRegDoc.courses.find((c) => c.courseID === course_id)!.elo
+    );
+    const cardElo = (await courseDB.getCardEloData([currentCard.card.card_id]))[0];
+
+    if (cardElo && userElo) {
+      const eloUpdate = adjustCourseScoresPerTag(userElo, cardElo, taggedPerformance);
+      userCourseRegDoc.courses.find((c) => c.courseID === course_id)!.elo = eloUpdate.userElo;
+
+      const results = await Promise.allSettled([
+        this.user.updateUserElo(course_id, eloUpdate.userElo),
+        courseDB.updateCardElo(card_id, eloUpdate.cardElo),
+      ]);
+
+      // Check the results of each operation
+      const userEloStatus = results[0].status === 'fulfilled';
+      const cardEloStatus = results[1].status === 'fulfilled';
+
+      if (userEloStatus && cardEloStatus) {
+        const user = (results[0] as PromiseFulfilledResult<any>).value;
+        const card = (results[1] as PromiseFulfilledResult<any>).value;
+
+        if (user.ok && card && card.ok) {
+          const tagCount = Object.keys(taggedPerformance).length - 1; // exclude _global
+          logger.info(
+            `[EloService] Updated ELOS (per-tag, ${tagCount} tags):
+            \tUser: ${JSON.stringify(eloUpdate.userElo)})
+            \tCard: ${JSON.stringify(eloUpdate.cardElo)})
+            `
+          );
+        }
+      } else {
+        // Log which operations succeeded and which failed
+        logger.warn(
+          `[EloService] Partial ELO update (per-tag):
+          \tUser ELO update: ${userEloStatus ? 'SUCCESS' : 'FAILED'}
+          \tCard ELO update: ${cardEloStatus ? 'SUCCESS' : 'FAILED'}`
+        );
+
+        if (!userEloStatus && results[0].status === 'rejected') {
+          logger.error('[EloService] User ELO update error:', results[0].reason);
+        }
+
+        if (!cardEloStatus && results[1].status === 'rejected') {
+          logger.error('[EloService] Card ELO update error:', results[1].reason);
+        }
+      }
+    }
+  }
+}

package/src/study/services/ResponseProcessor.ts

@@ -10,6 +10,17 @@ import { logger } from '@db/util/logger';
 import { ResponseResult, StudySessionRecord } from '../SessionController';
 import { EloService } from './EloService';
 import { SrsService } from './SrsService';
+import { Performance, isTaggedPerformance, TaggedPerformance } from '@vue-skuilder/common';
+
+/**
+ * Parsed performance data for ELO updates.
+ */
+interface ParsedPerformance {
+  /** Global score for SRS and global ELO [0, 1] */
+  globalScore: number;
+  /** Per-tag scores, or null if using simple numeric performance */
+  taggedPerformance: TaggedPerformance | null;
+}
 
 /**
  * Service responsible for orchestrating the complete response processing workflow.
@@ -24,6 +35,39 @@ export class ResponseProcessor {
     this.eloService = eloService;
   }
 
+  /**
+   * Parses performance data into global score and optional per-tag scores.
+   *
+   * @param performance - Numeric or structured performance from QuestionRecord
+   * @returns Parsed performance with global score and optional tag scores
+   */
+  private parsePerformance(performance: Performance): ParsedPerformance {
+    if (typeof performance === 'number') {
+      // Simple numeric performance - backward compatible
+      return {
+        globalScore: performance,
+        taggedPerformance: null,
+      };
+    }
+
+    // Structured TaggedPerformance with _global and per-tag scores
+    if (isTaggedPerformance(performance)) {
+      return {
+        globalScore: performance._global,
+        taggedPerformance: performance,
+      };
+    }
+
+    // Fallback for unexpected structure - treat as neutral
+    logger.warn('[ResponseProcessor] Unexpected performance structure, using neutral score', {
+      performance,
+    });
+    return {
+      globalScore: 0.5,
+      taggedPerformance: null,
+    };
+  }
+
   /**
    * Processes a user's response to a card, handling SRS scheduling and ELO updates.
    * @param cardRecord User's response record
@@ -60,43 +104,9 @@ export class ResponseProcessor {
       };
     }
 
-    // Debug logging for response processing
-    // logger.debug('[ResponseProcessor] Processing response', {
-    //   cardId,
-    //   courseId,
-    //   isCorrect: cardRecord.isCorrect,
-    //   performance: cardRecord.performance,
-    //   priorAttempts: cardRecord.priorAttemps,
-    //   currentSessionViews: sessionViews,
-    //   maxSessionViews,
-    //   maxAttemptsPerView,
-    //   currentCardRecordsLength: currentCard.records.length,
-    //   studySessionSourceType: studySessionItem.contentSourceType,
-    //   studySessionSourceID: studySessionItem.contentSourceID,
-    //   studySessionItemId: studySessionItem.cardID,
-    //   studySessionItemType: studySessionItem.contentSourceType,
-
-    //   cardRecordTimestamp: cardRecord.timeStamp,
-    //   cardRecordResponseTime: cardRecord.timeSpent,
-    // });
-
     try {
       const history = await cardHistory;
 
-      // Debug logging for card history
-      // logger.debug('[ResponseProcessor] History loaded:', {
-      //   cardId,
-      //   historyRecordsCount: history.records.length,
-      //   historyRecords: history.records.map((record) => ({
-      //     timeStamp: record.timeStamp,
-      //     isCorrect: 'isCorrect' in record ? record.isCorrect : 'N/A',
-      //     performance: 'performance' in record ? record.performance : 'N/A',
-      //     priorAttempts: 'priorAttemps' in record ? record.priorAttemps : 'N/A',
-      //   })),
-      //   firstInteraction: history.records.length === 1,
-      //   lastRecord: history.records[history.records.length - 1],
-      // });
-
       // Handle correct responses
       if (cardRecord.isCorrect) {
         return this.processCorrectResponse(
@@ -145,40 +155,57 @@ export class ResponseProcessor {
       // Schedule the card for future review based on performance (async, non-blocking)
       void this.srsService.scheduleReview(history, studySessionItem);
 
+      // Parse performance (may be numeric or structured)
+      const { globalScore, taggedPerformance } = this.parsePerformance(cardRecord.performance);
+
       // Update ELO ratings
-      if (history.records.length === 1) {
-        // First interaction with this card - standard ELO update (async, non-blocking)
-        const userScore = 0.5 + (cardRecord.performance as number) / 2;
-        void this.eloService.updateUserAndCardElo(
-          userScore,
+      if (taggedPerformance) {
+        // Per-tag ELO update
+        void this.eloService.updateUserAndCardEloPerTag(
+          taggedPerformance,
           courseId,
           cardId,
           courseRegistrationDoc,
           currentCard
         );
+        logger.info(
+          `[ResponseProcessor] Processed correct response with per-tag ELO update (${Object.keys(taggedPerformance).length - 1} tags)`
+        );
       } else {
-        // Multiple interactions - reduce K-factor to limit ELO volatility (async, non-blocking)
-        const k = Math.ceil(32 / history.records.length);
-        const userScore = 0.5 + (cardRecord.performance as number) / 2;
-        void this.eloService.updateUserAndCardElo(
-          userScore,
-          courseId,
-          cardId,
-          courseRegistrationDoc,
-          currentCard,
-          k
+        // Standard single-score ELO update (backward compatible)
+        const userScore = 0.5 + globalScore / 2;
+
+        if (history.records.length === 1) {
+          // First interaction with this card - standard ELO update
+          void this.eloService.updateUserAndCardElo(
+            userScore,
+            courseId,
+            cardId,
+            courseRegistrationDoc,
+            currentCard
+          );
+        } else {
+          // Multiple interactions - reduce K-factor to limit ELO volatility
+          const k = Math.ceil(32 / history.records.length);
+          void this.eloService.updateUserAndCardElo(
+            userScore,
+            courseId,
+            cardId,
+            courseRegistrationDoc,
+            currentCard,
+            k
+          );
+        }
+        logger.info(
+          '[ResponseProcessor] Processed correct response with SRS scheduling and ELO update'
         );
       }
 
-      logger.info(
-        '[ResponseProcessor] Processed correct response with SRS scheduling and ELO update'
-      );
-
       return {
         nextCardAction: 'dismiss-success',
         shouldLoadNextCard: true,
         isCorrect: true,
-        performanceScore: cardRecord.performance as number,
+        performanceScore: globalScore,
         shouldClearFeedbackShadow: true,
       };
     } else {
@@ -186,11 +213,13 @@ export class ResponseProcessor {
         '[ResponseProcessor] Processed correct response (retry attempt - no scheduling/ELO)'
       );
 
+      const { globalScore } = this.parsePerformance(cardRecord.performance);
+
       return {
         nextCardAction: 'marked-failed',
         shouldLoadNextCard: true,
         isCorrect: true,
-        performanceScore: cardRecord.performance as number,
+        performanceScore: globalScore,
         shouldClearFeedbackShadow: true,
       };
     }
@@ -210,16 +239,34 @@ export class ResponseProcessor {
     maxSessionViews: number,
     sessionViews: number
   ): ResponseResult {
-    // Update ELO for first-time failures (not subsequent attempts on same card) (async, non-blocking)
+    // Parse performance (may be numeric or structured)
+    const { taggedPerformance } = this.parsePerformance(cardRecord.performance);
+
+    // Update ELO for first-time failures (not subsequent attempts on same card)
     if (history.records.length !== 1 && cardRecord.priorAttemps === 0) {
-      void this.eloService.updateUserAndCardElo(
-        0, // Failed response = 0 score
-        courseId,
-        cardId,
-        courseRegistrationDoc,
-        currentCard
-      );
-      logger.info('[ResponseProcessor] Processed incorrect response with ELO update');
+      if (taggedPerformance) {
+        // Per-tag ELO update for incorrect response
+        void this.eloService.updateUserAndCardEloPerTag(
+          taggedPerformance,
+          courseId,
+          cardId,
+          courseRegistrationDoc,
+          currentCard
+        );
+        logger.info(
+          `[ResponseProcessor] Processed incorrect response with per-tag ELO update (${Object.keys(taggedPerformance).length - 1} tags)`
+        );
+      } else {
+        // Standard single-score ELO update
+        void this.eloService.updateUserAndCardElo(
+          0, // Failed response = 0 score
+          courseId,
+          cardId,
+          courseRegistrationDoc,
+          currentCard
+        );
+        logger.info('[ResponseProcessor] Processed incorrect response with ELO update');
+      }
     } else {
       logger.info('[ResponseProcessor] Processed incorrect response (no ELO update needed)');
     }
@@ -227,14 +274,25 @@ export class ResponseProcessor {
     // Determine navigation based on attempt limits
     if (currentCard.records.length >= maxAttemptsPerView) {
       if (sessionViews >= maxSessionViews) {
-        // Too many session views - dismiss completely with ELO penalty (async, non-blocking)
-        void this.eloService.updateUserAndCardElo(
-          0,
-          courseId,
-          cardId,
-          courseRegistrationDoc,
-          currentCard
-        );
+        // Too many session views - dismiss completely with ELO penalty
+        if (taggedPerformance) {
+          // Use tagged performance for final failure
+          void this.eloService.updateUserAndCardEloPerTag(
+            taggedPerformance,
+            courseId,
+            cardId,
+            courseRegistrationDoc,
+            currentCard
+          );
+        } else {
+          void this.eloService.updateUserAndCardElo(
+            0,
+            courseId,
+            cardId,
+            courseRegistrationDoc,
+            currentCard
+          );
+        }
         return {
           nextCardAction: 'dismiss-failed',
           shouldLoadNextCard: true,

package/src/study/services/SrsService.ts

@@ -14,6 +14,15 @@ export class SrsService {
     this.user = user;
   }
 
+  /**
+   * Remove a scheduled review from the user's database.
+   * Used to clean up orphaned reviews (e.g., card deleted from course DB).
+   */
+  removeReview(reviewID: string): void {
+    logger.info(`[SrsService] Removing orphaned scheduled review: ${reviewID}`);
+    void this.user.removeScheduledCardReview(reviewID);
+  }
+
   /**
    * Calculates the next review time for a card based on its history and
    * schedules it in the user's database.

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

@@ -90,6 +90,7 @@ function createMockContext(): { user: UserDBInterface; course: CourseDBInterface
     getCourseRegDoc: vi.fn().mockResolvedValue({
       elo: { global: { score: 1000, count: 10 }, tags: {} },
     }),
+    getUsername: vi.fn().mockReturnValue('test-user'),
   } as unknown as UserDBInterface;
 
   const mockCourse = {
@@ -294,6 +295,7 @@ describe('Pipeline', () => {
 
       const failingUser = {
         getCourseRegDoc: vi.fn().mockRejectedValue(new Error('Not registered')),
+        getUsername: vi.fn().mockReturnValue('failing-user'),
       } as unknown as UserDBInterface;
 
       let capturedElo = 0;

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

@@ -175,15 +175,15 @@ describe('PipelineAssembler', () => {
       expect(result.warnings).toEqual([]);
     });
 
-    it('uses default ELO when filters exist but no generator', async () => {
+    it('uses default ELO and SRS 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.generatorStrategies).toHaveLength(2);
+      const strategyNames = result.generatorStrategies.map((s) => s.name).sort();
+      expect(strategyNames).toEqual(['ELO (default)', 'SRS (default)']);
       expect(result.filterStrategies).toEqual([hierarchy]);
       expect(result.warnings).toEqual([]);
     });