@vue-skuilder/db 0.1.24 → 0.1.25

package/dist/index.mjs

@@ -490,6 +490,15 @@ var init_user_course_relDB = __esm({
           void this.user.updateCourseSettings(this._courseId, updates);
         }
       }
+      async getStrategyState(strategyKey) {
+        return this.user.getStrategyState(this._courseId, strategyKey);
+      }
+      async putStrategyState(strategyKey, data) {
+        return this.user.putStrategyState(this._courseId, strategyKey, data);
+      }
+      async deleteStrategyState(strategyKey) {
+        return this.user.deleteStrategyState(this._courseId, strategyKey);
+      }
       async getReviewstoDate(targetDate) {
         const allReviews = await this.user.getPendingReviews(this._courseId);
         logger.debug(
@@ -840,6 +849,271 @@ var init_courseLookupDB = __esm({
   }
 });
 
+// src/core/navigators/PipelineDebugger.ts
+var PipelineDebugger_exports = {};
+__export(PipelineDebugger_exports, {
+  buildRunReport: () => buildRunReport,
+  captureRun: () => captureRun,
+  mountPipelineDebugger: () => mountPipelineDebugger,
+  pipelineDebugAPI: () => pipelineDebugAPI
+});
+function getOrigin(card) {
+  const firstEntry = card.provenance[0];
+  if (!firstEntry) return "unknown";
+  const reason = firstEntry.reason?.toLowerCase() || "";
+  if (reason.includes("new card")) return "new";
+  if (reason.includes("review")) return "review";
+  return "unknown";
+}
+function captureRun(report) {
+  const fullReport = {
+    ...report,
+    runId: `run-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`,
+    timestamp: /* @__PURE__ */ new Date()
+  };
+  runHistory.unshift(fullReport);
+  if (runHistory.length > MAX_RUNS) {
+    runHistory.pop();
+  }
+}
+function buildRunReport(courseId, courseName, generatorName, generators, generatedCount, filters, allCards, selectedCards) {
+  const selectedIds = new Set(selectedCards.map((c) => c.cardId));
+  const cards = allCards.map((card) => ({
+    cardId: card.cardId,
+    courseId: card.courseId,
+    origin: getOrigin(card),
+    finalScore: card.score,
+    provenance: card.provenance,
+    selected: selectedIds.has(card.cardId)
+  }));
+  const reviewsSelected = selectedCards.filter((c) => getOrigin(c) === "review").length;
+  const newSelected = selectedCards.filter((c) => getOrigin(c) === "new").length;
+  return {
+    courseId,
+    courseName,
+    generatorName,
+    generators,
+    generatedCount,
+    filters,
+    finalCount: selectedCards.length,
+    reviewsSelected,
+    newSelected,
+    cards
+  };
+}
+function formatProvenance(provenance) {
+  return provenance.map((p) => {
+    const actionSymbol = p.action === "generated" ? "\u{1F3B2}" : p.action === "boosted" ? "\u2B06\uFE0F" : p.action === "penalized" ? "\u2B07\uFE0F" : "\u27A1\uFE0F";
+    return `  ${actionSymbol} ${p.strategyName}: ${p.score.toFixed(3)} - ${p.reason}`;
+  }).join("\n");
+}
+function printRunSummary(run) {
+  console.group(`\u{1F50D} Pipeline Run: ${run.courseId} (${run.courseName || "unnamed"})`);
+  logger.info(`Run ID: ${run.runId}`);
+  logger.info(`Time: ${run.timestamp.toISOString()}`);
+  logger.info(`Generator: ${run.generatorName} \u2192 ${run.generatedCount} candidates`);
+  if (run.generators && run.generators.length > 0) {
+    console.group("Generator breakdown:");
+    for (const g of run.generators) {
+      logger.info(
+        `  ${g.name}: ${g.cardCount} cards (${g.newCount} new, ${g.reviewCount} reviews, top: ${g.topScore.toFixed(2)})`
+      );
+    }
+    console.groupEnd();
+  }
+  if (run.filters.length > 0) {
+    console.group("Filter impact:");
+    for (const f of run.filters) {
+      logger.info(`  ${f.name}: \u2191${f.boosted} \u2193${f.penalized} =${f.passed} \u2715${f.removed}`);
+    }
+    console.groupEnd();
+  }
+  logger.info(
+    `Result: ${run.finalCount} cards selected (${run.newSelected} new, ${run.reviewsSelected} reviews)`
+  );
+  console.groupEnd();
+}
+function mountPipelineDebugger() {
+  if (typeof window === "undefined") return;
+  const win = window;
+  win.skuilder = win.skuilder || {};
+  win.skuilder.pipeline = pipelineDebugAPI;
+}
+var MAX_RUNS, runHistory, pipelineDebugAPI;
+var init_PipelineDebugger = __esm({
+  "src/core/navigators/PipelineDebugger.ts"() {
+    "use strict";
+    init_logger();
+    MAX_RUNS = 10;
+    runHistory = [];
+    pipelineDebugAPI = {
+      /**
+       * Get raw run history for programmatic access.
+       */
+      get runs() {
+        return [...runHistory];
+      },
+      /**
+       * Show summary of a specific pipeline run.
+       */
+      showRun(idOrIndex = 0) {
+        if (runHistory.length === 0) {
+          logger.info("[Pipeline Debug] No runs captured yet.");
+          return;
+        }
+        let run;
+        if (typeof idOrIndex === "number") {
+          run = runHistory[idOrIndex];
+          if (!run) {
+            logger.info(
+              `[Pipeline Debug] No run found at index ${idOrIndex}. History length: ${runHistory.length}`
+            );
+            return;
+          }
+        } else {
+          run = runHistory.find((r) => r.runId.endsWith(idOrIndex));
+          if (!run) {
+            logger.info(`[Pipeline Debug] No run found matching ID '${idOrIndex}'.`);
+            return;
+          }
+        }
+        printRunSummary(run);
+      },
+      /**
+       * Show summary of the last pipeline run.
+       */
+      showLastRun() {
+        this.showRun(0);
+      },
+      /**
+       * Show detailed provenance for a specific card.
+       */
+      showCard(cardId) {
+        for (const run of runHistory) {
+          const card = run.cards.find((c) => c.cardId === cardId);
+          if (card) {
+            console.group(`\u{1F3B4} Card: ${cardId}`);
+            logger.info(`Course: ${card.courseId}`);
+            logger.info(`Origin: ${card.origin}`);
+            logger.info(`Final score: ${card.finalScore.toFixed(3)}`);
+            logger.info(`Selected: ${card.selected ? "Yes \u2705" : "No \u274C"}`);
+            logger.info("Provenance:");
+            logger.info(formatProvenance(card.provenance));
+            console.groupEnd();
+            return;
+          }
+        }
+        logger.info(`[Pipeline Debug] Card '${cardId}' not found in recent runs.`);
+      },
+      /**
+       * Explain why reviews may or may not have been selected.
+       */
+      explainReviews() {
+        if (runHistory.length === 0) {
+          logger.info("[Pipeline Debug] No runs captured yet.");
+          return;
+        }
+        console.group("\u{1F4CB} Review Selection Analysis");
+        for (const run of runHistory) {
+          console.group(`Run: ${run.courseId} @ ${run.timestamp.toLocaleTimeString()}`);
+          const allReviews = run.cards.filter((c) => c.origin === "review");
+          const selectedReviews = allReviews.filter((c) => c.selected);
+          if (allReviews.length === 0) {
+            logger.info("\u274C No reviews were generated. Check SRS logs for why.");
+          } else if (selectedReviews.length === 0) {
+            logger.info(`\u26A0\uFE0F ${allReviews.length} reviews generated but none selected.`);
+            logger.info("Possible reasons:");
+            const topNewScore = Math.max(
+              ...run.cards.filter((c) => c.origin === "new" && c.selected).map((c) => c.finalScore),
+              0
+            );
+            const topReviewScore = Math.max(...allReviews.map((c) => c.finalScore), 0);
+            if (topReviewScore < topNewScore) {
+              logger.info(
+                `  - New cards scored higher (top new: ${topNewScore.toFixed(2)}, top review: ${topReviewScore.toFixed(2)})`
+              );
+            }
+            const topReview = allReviews.sort((a, b) => b.finalScore - a.finalScore)[0];
+            if (topReview) {
+              logger.info(`  - Top review score: ${topReview.finalScore.toFixed(3)}`);
+              logger.info("  - Its provenance:");
+              logger.info(formatProvenance(topReview.provenance));
+            }
+          } else {
+            logger.info(`\u2705 ${selectedReviews.length}/${allReviews.length} reviews selected.`);
+            logger.info("Top selected review:");
+            const topSelected = selectedReviews.sort((a, b) => b.finalScore - a.finalScore)[0];
+            logger.info(formatProvenance(topSelected.provenance));
+          }
+          console.groupEnd();
+        }
+        console.groupEnd();
+      },
+      /**
+       * Show all runs in compact format.
+       */
+      listRuns() {
+        if (runHistory.length === 0) {
+          logger.info("[Pipeline Debug] No runs captured yet.");
+          return;
+        }
+        console.table(
+          runHistory.map((r) => ({
+            id: r.runId.slice(-8),
+            time: r.timestamp.toLocaleTimeString(),
+            course: r.courseName || r.courseId.slice(0, 8),
+            generated: r.generatedCount,
+            selected: r.finalCount,
+            new: r.newSelected,
+            reviews: r.reviewsSelected
+          }))
+        );
+      },
+      /**
+       * Export run history as JSON for bug reports.
+       */
+      export() {
+        const json = JSON.stringify(runHistory, null, 2);
+        logger.info("[Pipeline Debug] Run history exported. Copy the returned string or use:");
+        logger.info("  copy(window.skuilder.pipeline.export())");
+        return json;
+      },
+      /**
+       * Clear run history.
+       */
+      clear() {
+        runHistory.length = 0;
+        logger.info("[Pipeline Debug] Run history cleared.");
+      },
+      /**
+       * Show help.
+       */
+      help() {
+        logger.info(`
+\u{1F527} Pipeline Debug API
+
+Commands:
+  .showLastRun()         Show summary of most recent pipeline run
+  .showRun(id|index)     Show summary of a specific run (by index or ID suffix)
+  .showCard(cardId)      Show provenance trail for a specific card
+  .explainReviews()      Analyze why reviews were/weren't selected
+  .listRuns()            List all captured runs in table format
+  .export()              Export run history as JSON for bug reports
+  .clear()               Clear run history
+  .runs                  Access raw run history array
+  .help()                Show this help message
+
+Example:
+  window.skuilder.pipeline.showLastRun()
+  window.skuilder.pipeline.showRun(1)
+  window.skuilder.pipeline.showCard('abc123')
+`);
+      }
+    };
+    mountPipelineDebugger();
+  }
+});
+
 // src/core/navigators/generators/CompositeGenerator.ts
 var CompositeGenerator_exports = {};
 __export(CompositeGenerator_exports, {
@@ -908,6 +1182,24 @@ var init_CompositeGenerator = __esm({
         const results = await Promise.all(
           this.generators.map((g) => g.getWeightedCards(limit, context))
         );
+        const generatorSummaries = [];
+        results.forEach((cards, index) => {
+          const gen = this.generators[index];
+          const genName = gen.name || `Generator ${index}`;
+          const newCards = cards.filter((c) => c.provenance[0]?.reason?.includes("new card"));
+          const reviewCards = cards.filter((c) => c.provenance[0]?.reason?.includes("review"));
+          if (cards.length > 0) {
+            const topScore = Math.max(...cards.map((c) => c.score)).toFixed(2);
+            const parts = [];
+            if (newCards.length > 0) parts.push(`${newCards.length} new`);
+            if (reviewCards.length > 0) parts.push(`${reviewCards.length} reviews`);
+            const breakdown = parts.length > 0 ? parts.join(", ") : `${cards.length} cards`;
+            generatorSummaries.push(`${genName}: ${breakdown} (top: ${topScore})`);
+          } else {
+            generatorSummaries.push(`${genName}: 0 cards`);
+          }
+        });
+        logger.info(`[Composite] Generator breakdown: ${generatorSummaries.join(" | ")}`);
         const byCardId = /* @__PURE__ */ new Map();
         results.forEach((cards, index) => {
           const gen = this.generators[index];
@@ -1025,6 +1317,7 @@ var init_elo = __esm({
   "src/core/navigators/generators/elo.ts"() {
     "use strict";
     init_navigators();
+    init_logger();
     ELONavigator = class extends ContentNavigator {
       /** Human-readable name for CardGenerator interface */
       name;
@@ -1084,7 +1377,16 @@ var init_elo = __esm({
           };
         });
         scored.sort((a, b) => b.score - a.score);
-        return scored.slice(0, limit);
+        const result = scored.slice(0, limit);
+        if (result.length > 0) {
+          const topScores = result.slice(0, 3).map((c) => c.score.toFixed(2)).join(", ");
+          logger.info(
+            `[ELO] Course ${this.course.getCourseID()}: ${result.length} new cards (top scores: ${topScores})`
+          );
+        } else {
+          logger.info(`[ELO] Course ${this.course.getCourseID()}: No new cards available`);
+        }
+        return result;
       }
     };
   }
@@ -1104,18 +1406,36 @@ __export(srs_exports, {
   default: () => SRSNavigator
 });
 import moment3 from "moment";
-var SRSNavigator;
+var DEFAULT_HEALTHY_BACKLOG, MAX_BACKLOG_PRESSURE, SRSNavigator;
 var init_srs = __esm({
   "src/core/navigators/generators/srs.ts"() {
     "use strict";
     init_navigators();
     init_logger();
+    DEFAULT_HEALTHY_BACKLOG = 20;
+    MAX_BACKLOG_PRESSURE = 0.5;
     SRSNavigator = class extends ContentNavigator {
       /** Human-readable name for CardGenerator interface */
       name;
+      /** Healthy backlog threshold - when exceeded, backlog pressure kicks in */
+      healthyBacklog;
       constructor(user, course, strategyData) {
         super(user, course, strategyData);
         this.name = strategyData?.name || "SRS";
+        const config = this.parseConfig(strategyData?.serializedData);
+        this.healthyBacklog = config.healthyBacklog ?? DEFAULT_HEALTHY_BACKLOG;
+      }
+      /**
+       * Parse configuration from serialized JSON.
+       */
+      parseConfig(serializedData) {
+        if (!serializedData) return {};
+        try {
+          return JSON.parse(serializedData);
+        } catch {
+          logger.warn("[SRS] Failed to parse strategy config, using defaults");
+          return {};
+        }
       }
       /**
        * Get review cards scored by urgency.
@@ -1123,6 +1443,7 @@ var init_srs = __esm({
        * Score formula combines:
        * - Relative overdueness: hoursOverdue / intervalHours
        * - Interval recency: exponential decay favoring shorter intervals
+       * - Backlog pressure: boost when due reviews exceed healthy threshold
        *
        * Cards not yet due are excluded (not scored as 0).
        *
@@ -1136,11 +1457,32 @@ var init_srs = __esm({
         if (!this.user || !this.course) {
           throw new Error("SRSNavigator requires user and course to be set");
         }
-        const reviews = await this.user.getPendingReviews(this.course.getCourseID());
+        const courseId = this.course.getCourseID();
+        const reviews = await this.user.getPendingReviews(courseId);
         const now = moment3.utc();
         const dueReviews = reviews.filter((r) => now.isAfter(moment3.utc(r.reviewTime)));
+        const backlogPressure = this.computeBacklogPressure(dueReviews.length);
+        if (dueReviews.length > 0) {
+          const pressureNote = backlogPressure > 0 ? ` [backlog pressure: +${backlogPressure.toFixed(2)}]` : ` [healthy backlog]`;
+          logger.info(
+            `[SRS] Course ${courseId}: ${dueReviews.length} reviews due now (of ${reviews.length} scheduled)${pressureNote}`
+          );
+        } else if (reviews.length > 0) {
+          const sortedByDue = [...reviews].sort(
+            (a, b) => moment3.utc(a.reviewTime).diff(moment3.utc(b.reviewTime))
+          );
+          const nextDue = sortedByDue[0];
+          const nextDueTime = moment3.utc(nextDue.reviewTime);
+          const untilDue = moment3.duration(nextDueTime.diff(now));
+          const untilDueStr = untilDue.asHours() < 1 ? `${Math.round(untilDue.asMinutes())}m` : untilDue.asHours() < 24 ? `${Math.round(untilDue.asHours())}h` : `${Math.round(untilDue.asDays())}d`;
+          logger.info(
+            `[SRS] Course ${courseId}: 0 reviews due now (${reviews.length} scheduled, next in ${untilDueStr})`
+          );
+        } else {
+          logger.info(`[SRS] Course ${courseId}: No reviews scheduled`);
+        }
         const scored = dueReviews.map((review) => {
-          const { score, reason } = this.computeUrgencyScore(review, now);
+          const { score, reason } = this.computeUrgencyScore(review, now, backlogPressure);
           return {
             cardId: review.cardId,
             courseId: review.courseId,
@@ -1158,13 +1500,35 @@ var init_srs = __esm({
             ]
           };
         });
-        logger.debug(`[srsNav] got ${scored.length} weighted cards`);
         return scored.sort((a, b) => b.score - a.score).slice(0, limit);
       }
+      /**
+       * Compute backlog pressure based on number of due reviews.
+       *
+       * Backlog pressure is 0 when at or below healthy threshold,
+       * and increases linearly above it, maxing out at MAX_BACKLOG_PRESSURE.
+       *
+       * Examples (with default healthyBacklog=20):
+       * - 10 due reviews → 0.00 (healthy)
+       * - 20 due reviews → 0.00 (at threshold)
+       * - 40 due reviews → 0.25 (2x threshold)
+       * - 60 due reviews → 0.50 (3x threshold, maxed)
+       *
+       * @param dueCount - Number of reviews currently due
+       * @returns Backlog pressure score to add to urgency (0 to MAX_BACKLOG_PRESSURE)
+       */
+      computeBacklogPressure(dueCount) {
+        if (dueCount <= this.healthyBacklog) {
+          return 0;
+        }
+        const excess = dueCount - this.healthyBacklog;
+        const pressure = excess / this.healthyBacklog * (MAX_BACKLOG_PRESSURE / 2);
+        return Math.min(MAX_BACKLOG_PRESSURE, pressure);
+      }
       /**
        * Compute urgency score for a review card.
        *
-       * Two factors:
+       * Three factors:
        * 1. Relative overdueness = hoursOverdue / intervalHours
        *    - 2 days overdue on 3-day interval = 0.67 (urgent)
        *    - 2 days overdue on 180-day interval = 0.01 (not urgent)
@@ -1174,10 +1538,19 @@ var init_srs = __esm({
        *    - 30 days (720h) → ~0.56
        *    - 180 days → ~0.30
        *
-       * Combined: base 0.5 + weighted average of factors * 0.45
-       * Result range: approximately 0.5 to 0.95
+       * 3. Backlog pressure = global boost when review backlog exceeds healthy threshold
+       *    - At healthy backlog: 0
+       *    - At 2x healthy: +0.25
+       *    - At 3x+ healthy: +0.50 (max)
+       *
+       * Combined: base 0.5 + (urgency factors * 0.45) + backlog pressure
+       * Result range: 0.5 to 1.0 (uncapped to allow high-urgency reviews to compete with new cards)
+       *
+       * @param review - The scheduled card to score
+       * @param now - Current time
+       * @param backlogPressure - Pre-computed backlog pressure (0 to 0.5)
        */
-      computeUrgencyScore(review, now) {
+      computeUrgencyScore(review, now, backlogPressure) {
         const scheduledAt = moment3.utc(review.scheduledAt);
         const due = moment3.utc(review.reviewTime);
         const intervalHours = Math.max(1, due.diff(scheduledAt, "hours"));
@@ -1186,8 +1559,19 @@ var init_srs = __esm({
         const recencyFactor = 0.3 + 0.7 * Math.exp(-intervalHours / 720);
         const overdueContribution = Math.min(1, Math.max(0, relativeOverdue));
         const urgency = overdueContribution * 0.5 + recencyFactor * 0.5;
-        const score = Math.min(0.95, 0.5 + urgency * 0.45);
-        const reason = `${Math.round(hoursOverdue)}h overdue (interval: ${Math.round(intervalHours)}h, relative: ${relativeOverdue.toFixed(2)}), recency: ${recencyFactor.toFixed(2)}, review`;
+        const baseScore = 0.5 + urgency * 0.45;
+        const score = Math.min(1, baseScore + backlogPressure);
+        const reasonParts = [
+          `${Math.round(hoursOverdue)}h overdue`,
+          `interval: ${Math.round(intervalHours)}h`,
+          `relative: ${relativeOverdue.toFixed(2)}`,
+          `recency: ${recencyFactor.toFixed(2)}`
+        ];
+        if (backlogPressure > 0) {
+          reasonParts.push(`backlog: +${backlogPressure.toFixed(2)}`);
+        }
+        reasonParts.push("review");
+        const reason = reasonParts.join(", ");
         return { score, reason };
       }
     };
@@ -2464,10 +2848,23 @@ function logTagHydration(cards, tagsByCard) {
     `[Pipeline] Tag hydration: ${cards.length} cards, ${cardsWithTags} have tags (${totalTags} total tags) - single batch query`
   );
 }
-function logExecutionSummary(generatorName, generatedCount, filterCount, finalCount, topScores) {
+function logExecutionSummary(generatorName, generatedCount, filterCount, finalCount, topScores, filterImpacts) {
   const scoreDisplay = topScores.length > 0 ? topScores.map((s) => s.toFixed(2)).join(", ") : "none";
+  let filterSummary = "";
+  if (filterImpacts.length > 0) {
+    const impacts = filterImpacts.map((f) => {
+      const parts = [];
+      if (f.boosted > 0) parts.push(`+${f.boosted}`);
+      if (f.penalized > 0) parts.push(`-${f.penalized}`);
+      if (f.passed > 0) parts.push(`=${f.passed}`);
+      return `${f.name}: ${parts.join("/")}`;
+    });
+    filterSummary = `
+  Filter impact: ${impacts.join(", ")}`;
+  }
   logger.info(
-    `[Pipeline] Execution: ${generatorName} produced ${generatedCount} \u2192 ${filterCount} filters \u2192 ${finalCount} results (top scores: ${scoreDisplay})`
+    `[Pipeline] Execution: ${generatorName} produced ${generatedCount} \u2192 ${filterCount} filters \u2192 ${finalCount} results (top scores: ${scoreDisplay})` + filterSummary + `
+  \u{1F4A1} Inspect: window.skuilder.pipeline`
   );
 }
 function logCardProvenance(cards, maxCards = 3) {
@@ -2491,6 +2888,7 @@ var init_Pipeline = __esm({
     init_navigators();
     init_logger();
     init_orchestration();
+    init_PipelineDebugger();
     Pipeline = class extends ContentNavigator {
       generator;
       filters;
@@ -2538,12 +2936,49 @@ var init_Pipeline = __esm({
         );
         let cards = await this.generator.getWeightedCards(fetchLimit, context);
         const generatedCount = cards.length;
+        let generatorSummaries;
+        if (this.generator.generators) {
+          const genMap = /* @__PURE__ */ new Map();
+          for (const card of cards) {
+            const firstProv = card.provenance[0];
+            if (firstProv) {
+              const genName = firstProv.strategyName;
+              if (!genMap.has(genName)) {
+                genMap.set(genName, { cards: [] });
+              }
+              genMap.get(genName).cards.push(card);
+            }
+          }
+          generatorSummaries = Array.from(genMap.entries()).map(([name, data]) => {
+            const newCards = data.cards.filter((c) => c.provenance[0]?.reason?.includes("new card"));
+            const reviewCards = data.cards.filter((c) => c.provenance[0]?.reason?.includes("review"));
+            return {
+              name,
+              cardCount: data.cards.length,
+              newCount: newCards.length,
+              reviewCount: reviewCards.length,
+              topScore: Math.max(...data.cards.map((c) => c.score), 0)
+            };
+          });
+        }
         logger.debug(`[Pipeline] Generator returned ${generatedCount} candidates`);
         cards = await this.hydrateTags(cards);
+        const allCardsBeforeFiltering = [...cards];
+        const filterImpacts = [];
         for (const filter of this.filters) {
           const beforeCount = cards.length;
+          const beforeScores = new Map(cards.map((c) => [c.cardId, c.score]));
           cards = await filter.transform(cards, context);
-          logger.debug(`[Pipeline] Filter '${filter.name}': ${beforeCount} \u2192 ${cards.length} cards`);
+          let boosted = 0, penalized = 0, passed = 0;
+          const removed = beforeCount - cards.length;
+          for (const card of cards) {
+            const before = beforeScores.get(card.cardId) ?? 0;
+            if (card.score > before) boosted++;
+            else if (card.score < before) penalized++;
+            else passed++;
+          }
+          filterImpacts.push({ name: filter.name, boosted, penalized, passed, removed });
+          logger.debug(`[Pipeline] Filter '${filter.name}': ${beforeScores.size} \u2192 ${cards.length} cards (\u2191${boosted} \u2193${penalized} =${passed})`);
         }
         cards = cards.filter((c) => c.score > 0);
         cards.sort((a, b) => b.score - a.score);
@@ -2554,9 +2989,26 @@ var init_Pipeline = __esm({
           generatedCount,
           this.filters.length,
           result.length,
-          topScores
+          topScores,
+          filterImpacts
         );
         logCardProvenance(result, 3);
+        try {
+          const courseName = await this.course?.getCourseConfig().then((c) => c.name).catch(() => void 0);
+          const report = buildRunReport(
+            this.course?.getCourseID() || "unknown",
+            courseName,
+            this.generator.name,
+            generatorSummaries,
+            generatedCount,
+            filterImpacts,
+            allCardsBeforeFiltering,
+            result
+          );
+          captureRun(report);
+        } catch (e) {
+          logger.debug(`[Pipeline] Failed to capture debug run: ${e}`);
+        }
         return result;
       }
       /**
@@ -2646,6 +3098,56 @@ var init_Pipeline = __esm({
   }
 });
 
+// src/core/navigators/defaults.ts
+var defaults_exports = {};
+__export(defaults_exports, {
+  createDefaultEloStrategy: () => createDefaultEloStrategy,
+  createDefaultPipeline: () => createDefaultPipeline,
+  createDefaultSrsStrategy: () => createDefaultSrsStrategy
+});
+function createDefaultEloStrategy(courseId) {
+  return {
+    _id: "NAVIGATION_STRATEGY-ELO-default",
+    docType: "NAVIGATION_STRATEGY" /* NAVIGATION_STRATEGY */,
+    name: "ELO (default)",
+    description: "Default ELO-based navigation strategy for new cards",
+    implementingClass: "elo" /* ELO */,
+    course: courseId,
+    serializedData: ""
+  };
+}
+function createDefaultSrsStrategy(courseId) {
+  return {
+    _id: "NAVIGATION_STRATEGY-SRS-default",
+    docType: "NAVIGATION_STRATEGY" /* NAVIGATION_STRATEGY */,
+    name: "SRS (default)",
+    description: "Default SRS-based navigation strategy for reviews",
+    implementingClass: "srs" /* SRS */,
+    course: courseId,
+    serializedData: ""
+  };
+}
+function createDefaultPipeline(user, course) {
+  const courseId = course.getCourseID();
+  const eloNavigator = new ELONavigator(user, course, createDefaultEloStrategy(courseId));
+  const srsNavigator = new SRSNavigator(user, course, createDefaultSrsStrategy(courseId));
+  const compositeGenerator = new CompositeGenerator([eloNavigator, srsNavigator]);
+  const eloDistanceFilter = createEloDistanceFilter();
+  return new Pipeline(compositeGenerator, [eloDistanceFilter], user, course);
+}
+var init_defaults = __esm({
+  "src/core/navigators/defaults.ts"() {
+    "use strict";
+    init_navigators();
+    init_Pipeline();
+    init_CompositeGenerator();
+    init_elo();
+    init_srs();
+    init_eloDistance();
+    init_types_legacy();
+  }
+});
+
 // src/core/navigators/PipelineAssembler.ts
 var PipelineAssembler_exports = {};
 __export(PipelineAssembler_exports, {
@@ -2658,9 +3160,9 @@ var init_PipelineAssembler = __esm({
     init_navigators();
     init_WeightedFilter();
     init_Pipeline();
-    init_types_legacy();
     init_logger();
     init_CompositeGenerator();
+    init_defaults();
     PipelineAssembler = class {
       /**
        * Assembles a navigation pipeline from strategy documents.
@@ -2699,9 +3201,11 @@ var init_PipelineAssembler = __esm({
         if (generatorStrategies.length === 0) {
           if (filterStrategies.length > 0) {
             logger.debug(
-              "[PipelineAssembler] No generator found, using default ELO with configured filters"
+              "[PipelineAssembler] No generator found, using default ELO and SRS with configured filters"
             );
-            generatorStrategies.push(this.makeDefaultEloStrategy(course.getCourseID()));
+            const courseId = course.getCourseID();
+            generatorStrategies.push(createDefaultEloStrategy(courseId));
+            generatorStrategies.push(createDefaultSrsStrategy(courseId));
           } else {
             warnings.push("No generator strategy found");
             return {
@@ -2762,75 +3266,10 @@ var init_PipelineAssembler = __esm({
           warnings
         };
       }
-      /**
-       * Creates a default ELO generator strategy.
-       * Used when filters are configured but no generator is specified.
-       */
-      makeDefaultEloStrategy(courseId) {
-        return {
-          _id: "NAVIGATION_STRATEGY-ELO-default",
-          course: courseId,
-          docType: "NAVIGATION_STRATEGY" /* NAVIGATION_STRATEGY */,
-          name: "ELO (default)",
-          description: "Default ELO-based generator",
-          implementingClass: "elo" /* ELO */,
-          serializedData: ""
-        };
-      }
     };
   }
 });
 
-// src/core/navigators/defaults.ts
-var defaults_exports = {};
-__export(defaults_exports, {
-  createDefaultEloStrategy: () => createDefaultEloStrategy,
-  createDefaultPipeline: () => createDefaultPipeline,
-  createDefaultSrsStrategy: () => createDefaultSrsStrategy
-});
-function createDefaultEloStrategy(courseId) {
-  return {
-    _id: "NAVIGATION_STRATEGY-ELO-default",
-    docType: "NAVIGATION_STRATEGY" /* NAVIGATION_STRATEGY */,
-    name: "ELO (default)",
-    description: "Default ELO-based navigation strategy for new cards",
-    implementingClass: "elo" /* ELO */,
-    course: courseId,
-    serializedData: ""
-  };
-}
-function createDefaultSrsStrategy(courseId) {
-  return {
-    _id: "NAVIGATION_STRATEGY-SRS-default",
-    docType: "NAVIGATION_STRATEGY" /* NAVIGATION_STRATEGY */,
-    name: "SRS (default)",
-    description: "Default SRS-based navigation strategy for reviews",
-    implementingClass: "srs" /* SRS */,
-    course: courseId,
-    serializedData: ""
-  };
-}
-function createDefaultPipeline(user, course) {
-  const courseId = course.getCourseID();
-  const eloNavigator = new ELONavigator(user, course, createDefaultEloStrategy(courseId));
-  const srsNavigator = new SRSNavigator(user, course, createDefaultSrsStrategy(courseId));
-  const compositeGenerator = new CompositeGenerator([eloNavigator, srsNavigator]);
-  const eloDistanceFilter = createEloDistanceFilter();
-  return new Pipeline(compositeGenerator, [eloDistanceFilter], user, course);
-}
-var init_defaults = __esm({
-  "src/core/navigators/defaults.ts"() {
-    "use strict";
-    init_navigators();
-    init_Pipeline();
-    init_CompositeGenerator();
-    init_elo();
-    init_srs();
-    init_eloDistance();
-    init_types_legacy();
-  }
-});
-
 // import("./**/*") in src/core/navigators/index.ts
 var globImport;
 var init_3 = __esm({
@@ -2838,6 +3277,7 @@ var init_3 = __esm({
     globImport = __glob({
       "./Pipeline.ts": () => Promise.resolve().then(() => (init_Pipeline(), Pipeline_exports)),
       "./PipelineAssembler.ts": () => Promise.resolve().then(() => (init_PipelineAssembler(), PipelineAssembler_exports)),
+      "./PipelineDebugger.ts": () => Promise.resolve().then(() => (init_PipelineDebugger(), PipelineDebugger_exports)),
       "./defaults.ts": () => Promise.resolve().then(() => (init_defaults(), defaults_exports)),
       "./filters/WeightedFilter.ts": () => Promise.resolve().then(() => (init_WeightedFilter(), WeightedFilter_exports)),
       "./filters/eloDistance.ts": () => Promise.resolve().then(() => (init_eloDistance(), eloDistance_exports)),
@@ -2873,6 +3313,8 @@ __export(navigators_exports, {
   initializeNavigatorRegistry: () => initializeNavigatorRegistry,
   isFilter: () => isFilter,
   isGenerator: () => isGenerator,
+  mountPipelineDebugger: () => mountPipelineDebugger,
+  pipelineDebugAPI: () => pipelineDebugAPI,
   registerNavigator: () => registerNavigator
 });
 function registerNavigator(implementingClass, constructor) {
@@ -2939,6 +3381,7 @@ var navigatorRegistry, Navigators, NavigatorRole, NavigatorRoles, ContentNavigat
 var init_navigators = __esm({
   "src/core/navigators/index.ts"() {
     "use strict";
+    init_PipelineDebugger();
     init_logger();
     init_();
     init_2();
@@ -7555,6 +7998,14 @@ var SrsService = class {
   constructor(user) {
     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) {
+    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.
@@ -7581,7 +8032,11 @@ var SrsService = class {
 
 // src/study/services/EloService.ts
 init_logger();
-import { adjustCourseScores, toCourseElo as toCourseElo7 } from "@vue-skuilder/common";
+import {
+  adjustCourseScores,
+  adjustCourseScoresPerTag,
+  toCourseElo as toCourseElo7
+} from "@vue-skuilder/common";
 var EloService = class {
   dataLayer;
   user;
@@ -7593,7 +8048,7 @@ var EloService = class {
    * 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
@@ -7603,7 +8058,9 @@ var EloService = class {
       logger.warn(`k value interpretation not currently implemented`);
     }
     const courseDB = this.dataLayer.getCourseDB(currentCard.card.course_id);
-    const userElo = toCourseElo7(userCourseRegDoc.courses.find((c) => c.courseID === course_id).elo);
+    const userElo = toCourseElo7(
+      userCourseRegDoc.courses.find((c) => c.courseID === course_id).elo
+    );
     const cardElo = (await courseDB.getCardEloData([currentCard.card.card_id]))[0];
     if (cardElo && userElo) {
       const eloUpdate = adjustCourseScores(userElo, cardElo, userScore);
@@ -7640,11 +8097,64 @@ var EloService = class {
       }
     }
   }
+  /**
+   * 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
+   */
+  async updateUserAndCardEloPerTag(taggedPerformance, course_id, card_id, userCourseRegDoc, currentCard) {
+    const courseDB = this.dataLayer.getCourseDB(currentCard.card.course_id);
+    const userElo = toCourseElo7(
+      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)
+      ]);
+      const userEloStatus = results[0].status === "fulfilled";
+      const cardEloStatus = results[1].status === "fulfilled";
+      if (userEloStatus && cardEloStatus) {
+        const user = results[0].value;
+        const card = results[1].value;
+        if (user.ok && card && card.ok) {
+          const tagCount = Object.keys(taggedPerformance).length - 1;
+          logger.info(
+            `[EloService] Updated ELOS (per-tag, ${tagCount} tags):
+            	User: ${JSON.stringify(eloUpdate.userElo)})
+            	Card: ${JSON.stringify(eloUpdate.cardElo)})
+            `
+          );
+        }
+      } else {
+        logger.warn(
+          `[EloService] Partial ELO update (per-tag):
+          	User ELO update: ${userEloStatus ? "SUCCESS" : "FAILED"}
+          	Card 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);
+        }
+      }
+    }
+  }
 };
 
 // src/study/services/ResponseProcessor.ts
 init_core();
 init_logger();
+import { isTaggedPerformance } from "@vue-skuilder/common";
 var ResponseProcessor = class {
   srsService;
   eloService;
@@ -7652,6 +8162,33 @@ var ResponseProcessor = class {
     this.srsService = srsService;
     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
+   */
+  parsePerformance(performance2) {
+    if (typeof performance2 === "number") {
+      return {
+        globalScore: performance2,
+        taggedPerformance: null
+      };
+    }
+    if (isTaggedPerformance(performance2)) {
+      return {
+        globalScore: performance2._global,
+        taggedPerformance: performance2
+      };
+    }
+    logger.warn("[ResponseProcessor] Unexpected performance structure, using neutral score", {
+      performance: performance2
+    });
+    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
@@ -7712,46 +8249,60 @@ var ResponseProcessor = class {
   processCorrectResponse(cardRecord, history, studySessionItem, courseRegistrationDoc, currentCard, courseId, cardId) {
     if (cardRecord.priorAttemps === 0) {
       void this.srsService.scheduleReview(history, studySessionItem);
-      if (history.records.length === 1) {
-        const userScore = 0.5 + cardRecord.performance / 2;
-        void this.eloService.updateUserAndCardElo(
-          userScore,
+      const { globalScore, taggedPerformance } = this.parsePerformance(cardRecord.performance);
+      if (taggedPerformance) {
+        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 {
-        const k = Math.ceil(32 / history.records.length);
-        const userScore = 0.5 + cardRecord.performance / 2;
-        void this.eloService.updateUserAndCardElo(
-          userScore,
-          courseId,
-          cardId,
-          courseRegistrationDoc,
-          currentCard,
-          k
+        const userScore = 0.5 + globalScore / 2;
+        if (history.records.length === 1) {
+          void this.eloService.updateUserAndCardElo(
+            userScore,
+            courseId,
+            cardId,
+            courseRegistrationDoc,
+            currentCard
+          );
+        } else {
+          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,
+        performanceScore: globalScore,
         shouldClearFeedbackShadow: true
       };
     } else {
       logger.info(
         "[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,
+        performanceScore: globalScore,
         shouldClearFeedbackShadow: true
       };
     }
@@ -7760,28 +8311,52 @@ var ResponseProcessor = class {
    * Handles processing for incorrect responses: ELO updates only.
    */
   processIncorrectResponse(cardRecord, history, courseRegistrationDoc, currentCard, courseId, cardId, maxAttemptsPerView, maxSessionViews, sessionViews) {
+    const { taggedPerformance } = this.parsePerformance(cardRecord.performance);
     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");
-    } else {
-      logger.info("[ResponseProcessor] Processed incorrect response (no ELO update needed)");
-    }
-    if (currentCard.records.length >= maxAttemptsPerView) {
-      if (sessionViews >= maxSessionViews) {
+      if (taggedPerformance) {
+        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 {
         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)");
+    }
+    if (currentCard.records.length >= maxAttemptsPerView) {
+      if (sessionViews >= maxSessionViews) {
+        if (taggedPerformance) {
+          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,
@@ -9467,16 +10042,645 @@ var QuotaRoundRobinMixer = class {
       return [];
     }
     const quotaPerSource = Math.ceil(limit / batches.length);
-    const mixed = [];
-    for (const batch of batches) {
-      const sortedBatch = [...batch.weighted].sort((a, b) => b.score - a.score);
-      const topFromSource = sortedBatch.slice(0, quotaPerSource);
-      mixed.push(...topFromSource);
+    const sourceStacks = batches.map((batch) => {
+      return [...batch.weighted].sort((a, b) => b.score - a.score).slice(0, quotaPerSource);
+    });
+    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]];
+    }
+    const result = [];
+    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 mixed.sort((a, b) => b.score - a.score).slice(0, limit);
+    return result;
   }
 };
 
+// src/study/MixerDebugger.ts
+init_logger();
+init_navigators();
+var MAX_RUNS2 = 10;
+var runHistory2 = [];
+function buildSourceSummary(batch, sourceId, sourceName) {
+  const scores = batch.weighted.map((c) => c.score);
+  const reviewCount = batch.weighted.filter((c) => getCardOrigin(c) === "review").length;
+  const newCount = batch.weighted.filter((c) => getCardOrigin(c) === "new").length;
+  return {
+    sourceIndex: batch.sourceIndex,
+    sourceId,
+    sourceName,
+    totalCards: batch.weighted.length,
+    reviewCount,
+    newCount,
+    topScore: scores.length > 0 ? Math.max(...scores) : 0,
+    bottomScore: scores.length > 0 ? Math.min(...scores) : 0,
+    scoreRange: scores.length > 0 ? [Math.min(...scores), Math.max(...scores)] : [0, 0],
+    avgScore: scores.length > 0 ? scores.reduce((a, b) => a + b, 0) / scores.length : 0
+  };
+}
+function buildSourceBreakdown(sourceId, sourceName, allCards) {
+  const sourceCards = allCards.filter((c) => c.courseId === sourceId);
+  const selectedCards = sourceCards.filter((c) => c.selected);
+  const reviewsProvided = sourceCards.filter((c) => c.origin === "review").length;
+  const newProvided = sourceCards.filter((c) => c.origin === "new").length;
+  const reviewsSelected = selectedCards.filter((c) => c.origin === "review").length;
+  const newSelected = selectedCards.filter((c) => c.origin === "new").length;
+  return {
+    sourceId,
+    sourceName,
+    reviewsProvided,
+    newProvided,
+    reviewsSelected,
+    newSelected,
+    totalSelected: selectedCards.length,
+    selectionRate: sourceCards.length > 0 ? selectedCards.length / sourceCards.length * 100 : 0
+  };
+}
+function captureMixerRun(mixerType, batches, sourceIds, sourceNames, requestedLimit, quotaPerSource, mixedResult) {
+  const sourceSummaries = batches.map(
+    (batch, idx) => buildSourceSummary(batch, sourceIds[idx] || `source-${idx}`, sourceNames[idx])
+  );
+  const selectedIds = new Set(mixedResult.map((c) => c.cardId));
+  const sourceRankings = /* @__PURE__ */ new Map();
+  batches.forEach((batch) => {
+    const sorted = [...batch.weighted].sort((a, b) => b.score - a.score);
+    const rankings = /* @__PURE__ */ new Map();
+    sorted.forEach((card, idx) => {
+      rankings.set(card.cardId, idx + 1);
+    });
+    sourceRankings.set(sourceIds[batch.sourceIndex] || `source-${batch.sourceIndex}`, rankings);
+  });
+  const mixRankings = /* @__PURE__ */ new Map();
+  mixedResult.forEach((card, idx) => {
+    mixRankings.set(card.cardId, idx + 1);
+  });
+  const allCardsMap = /* @__PURE__ */ new Map();
+  batches.forEach((batch) => {
+    batch.weighted.forEach((card) => {
+      allCardsMap.set(card.cardId, card);
+    });
+  });
+  const cards = Array.from(allCardsMap.values()).map((card) => ({
+    cardId: card.cardId,
+    courseId: card.courseId,
+    origin: getCardOrigin(card),
+    score: card.score,
+    sourceIndex: batches.findIndex((b) => b.weighted.some((c) => c.cardId === card.cardId)),
+    selected: selectedIds.has(card.cardId),
+    rankInSource: sourceRankings.get(card.courseId)?.get(card.cardId),
+    rankInMix: mixRankings.get(card.cardId)
+  }));
+  const uniqueSourceIds = Array.from(new Set(sourceIds.filter((id) => id)));
+  const sourceBreakdowns = uniqueSourceIds.map(
+    (sourceId, idx) => buildSourceBreakdown(sourceId, sourceNames[idx], cards)
+  );
+  const report = {
+    runId: `mix-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`,
+    timestamp: /* @__PURE__ */ new Date(),
+    mixerType,
+    requestedLimit,
+    quotaPerSource,
+    sourceSummaries,
+    cards,
+    finalCount: mixedResult.length,
+    reviewsSelected: mixedResult.filter((c) => getCardOrigin(c) === "review").length,
+    newSelected: mixedResult.filter((c) => getCardOrigin(c) === "new").length,
+    sourceBreakdowns
+  };
+  runHistory2.unshift(report);
+  if (runHistory2.length > MAX_RUNS2) {
+    runHistory2.pop();
+  }
+}
+function printMixerSummary(run) {
+  console.group(`\u{1F3A8} Mixer Run: ${run.mixerType}`);
+  logger.info(`Run ID: ${run.runId}`);
+  logger.info(`Time: ${run.timestamp.toISOString()}`);
+  logger.info(
+    `Config: limit=${run.requestedLimit}${run.quotaPerSource ? `, quota/source=${run.quotaPerSource}` : ""}`
+  );
+  console.group(`\u{1F4E5} Input: ${run.sourceSummaries.length} sources`);
+  for (const src of run.sourceSummaries) {
+    logger.info(
+      `  ${src.sourceName || src.sourceId}: ${src.totalCards} cards (${src.reviewCount} reviews, ${src.newCount} new)`
+    );
+    logger.info(`    Score range: [${src.scoreRange[0].toFixed(2)}, ${src.scoreRange[1].toFixed(2)}], avg: ${src.avgScore.toFixed(2)}`);
+  }
+  console.groupEnd();
+  console.group(`\u{1F4E4} Output: ${run.finalCount} cards selected (${run.reviewsSelected} reviews, ${run.newSelected} new)`);
+  for (const breakdown of run.sourceBreakdowns) {
+    const name = breakdown.sourceName || breakdown.sourceId;
+    logger.info(
+      `  ${name}: ${breakdown.totalSelected} selected (${breakdown.reviewsSelected} reviews, ${breakdown.newSelected} new) - ${breakdown.selectionRate.toFixed(1)}% selection rate`
+    );
+  }
+  console.groupEnd();
+  console.groupEnd();
+}
+var mixerDebugAPI = {
+  /**
+   * Get raw run history for programmatic access.
+   */
+  get runs() {
+    return [...runHistory2];
+  },
+  /**
+   * Show summary of a specific mixer run.
+   */
+  showRun(idOrIndex = 0) {
+    if (runHistory2.length === 0) {
+      logger.info("[Mixer Debug] No runs captured yet.");
+      return;
+    }
+    let run;
+    if (typeof idOrIndex === "number") {
+      run = runHistory2[idOrIndex];
+      if (!run) {
+        logger.info(`[Mixer Debug] No run found at index ${idOrIndex}. History length: ${runHistory2.length}`);
+        return;
+      }
+    } else {
+      run = runHistory2.find((r) => r.runId.endsWith(idOrIndex));
+      if (!run) {
+        logger.info(`[Mixer Debug] No run found matching ID '${idOrIndex}'.`);
+        return;
+      }
+    }
+    printMixerSummary(run);
+  },
+  /**
+   * Show summary of the last mixer run.
+   */
+  showLastMix() {
+    this.showRun(0);
+  },
+  /**
+   * Explain source balance in the last run.
+   */
+  explainSourceBalance() {
+    if (runHistory2.length === 0) {
+      logger.info("[Mixer Debug] No runs captured yet.");
+      return;
+    }
+    const run = runHistory2[0];
+    console.group("\u2696\uFE0F Source Balance Analysis");
+    logger.info(`Mixer: ${run.mixerType}`);
+    logger.info(`Requested limit: ${run.requestedLimit}`);
+    if (run.quotaPerSource) {
+      logger.info(`Quota per source: ${run.quotaPerSource}`);
+    }
+    console.group("Input Distribution:");
+    for (const src of run.sourceSummaries) {
+      const name = src.sourceName || src.sourceId;
+      logger.info(`${name}:`);
+      logger.info(`  Provided: ${src.totalCards} cards (${src.reviewCount} reviews, ${src.newCount} new)`);
+      logger.info(`  Score range: [${src.scoreRange[0].toFixed(2)}, ${src.scoreRange[1].toFixed(2)}]`);
+    }
+    console.groupEnd();
+    console.group("Selection Results:");
+    for (const breakdown of run.sourceBreakdowns) {
+      const name = breakdown.sourceName || breakdown.sourceId;
+      logger.info(`${name}:`);
+      logger.info(
+        `  Selected: ${breakdown.totalSelected}/${breakdown.reviewsProvided + breakdown.newProvided} (${breakdown.selectionRate.toFixed(1)}%)`
+      );
+      logger.info(`  Reviews: ${breakdown.reviewsSelected}/${breakdown.reviewsProvided}`);
+      logger.info(`  New: ${breakdown.newSelected}/${breakdown.newProvided}`);
+      if (breakdown.reviewsProvided > 0 && breakdown.reviewsSelected === 0) {
+        logger.info(`  \u26A0\uFE0F Had reviews but none selected!`);
+      }
+      if (breakdown.totalSelected === 0 && breakdown.reviewsProvided + breakdown.newProvided > 0) {
+        logger.info(`  \u26A0\uFE0F Had cards but none selected!`);
+      }
+    }
+    console.groupEnd();
+    const selectionRates = run.sourceBreakdowns.map((b) => b.selectionRate);
+    const avgRate = selectionRates.reduce((a, b) => a + b, 0) / selectionRates.length;
+    const maxDeviation = Math.max(...selectionRates.map((r) => Math.abs(r - avgRate)));
+    if (maxDeviation > 20) {
+      logger.info(`
+\u26A0\uFE0F Significant imbalance detected (max deviation: ${maxDeviation.toFixed(1)}%)`);
+      logger.info("Possible causes:");
+      logger.info("  - Score range differences between sources");
+      logger.info("  - One source has much better quality cards");
+      logger.info("  - Different card availability (reviews vs new)");
+    }
+    console.groupEnd();
+  },
+  /**
+   * Compare score distributions across sources.
+   */
+  compareScores() {
+    if (runHistory2.length === 0) {
+      logger.info("[Mixer Debug] No runs captured yet.");
+      return;
+    }
+    const run = runHistory2[0];
+    console.group("\u{1F4CA} Score Distribution Comparison");
+    console.table(
+      run.sourceSummaries.map((src) => ({
+        source: src.sourceName || src.sourceId,
+        cards: src.totalCards,
+        min: src.bottomScore.toFixed(3),
+        max: src.topScore.toFixed(3),
+        avg: src.avgScore.toFixed(3),
+        range: (src.topScore - src.bottomScore).toFixed(3)
+      }))
+    );
+    const ranges = run.sourceSummaries.map((s) => s.topScore - s.bottomScore);
+    const avgScores = run.sourceSummaries.map((s) => s.avgScore);
+    const rangeDiff = Math.max(...ranges) - Math.min(...ranges);
+    const avgDiff = Math.max(...avgScores) - Math.min(...avgScores);
+    if (rangeDiff > 0.3 || avgDiff > 0.2) {
+      logger.info("\n\u26A0\uFE0F Significant score distribution differences detected");
+      logger.info(
+        "This may cause one source to dominate selection if using global sorting (not quota-based)"
+      );
+    }
+    console.groupEnd();
+  },
+  /**
+   * Show detailed information for a specific card.
+   */
+  showCard(cardId) {
+    for (const run of runHistory2) {
+      const card = run.cards.find((c) => c.cardId === cardId);
+      if (card) {
+        const source = run.sourceSummaries.find((s) => s.sourceIndex === card.sourceIndex);
+        console.group(`\u{1F3B4} Card: ${cardId}`);
+        logger.info(`Course: ${card.courseId}`);
+        logger.info(`Source: ${source?.sourceName || source?.sourceId || "unknown"}`);
+        logger.info(`Origin: ${card.origin}`);
+        logger.info(`Score: ${card.score.toFixed(3)}`);
+        if (card.rankInSource) {
+          logger.info(`Rank in source: #${card.rankInSource}`);
+        }
+        if (card.rankInMix) {
+          logger.info(`Rank in mixed results: #${card.rankInMix}`);
+        }
+        logger.info(`Selected: ${card.selected ? "Yes \u2705" : "No \u274C"}`);
+        if (!card.selected && card.rankInSource) {
+          logger.info("\nWhy not selected:");
+          if (run.quotaPerSource && card.rankInSource > run.quotaPerSource) {
+            logger.info(`  - Ranked #${card.rankInSource} in source, but quota was ${run.quotaPerSource}`);
+          }
+          logger.info("  - Check score compared to selected cards using .showRun()");
+        }
+        console.groupEnd();
+        return;
+      }
+    }
+    logger.info(`[Mixer Debug] Card '${cardId}' not found in recent runs.`);
+  },
+  /**
+   * Show all runs in compact format.
+   */
+  listRuns() {
+    if (runHistory2.length === 0) {
+      logger.info("[Mixer Debug] No runs captured yet.");
+      return;
+    }
+    console.table(
+      runHistory2.map((r) => ({
+        id: r.runId.slice(-8),
+        time: r.timestamp.toLocaleTimeString(),
+        mixer: r.mixerType,
+        sources: r.sourceSummaries.length,
+        selected: r.finalCount,
+        reviews: r.reviewsSelected,
+        new: r.newSelected
+      }))
+    );
+  },
+  /**
+   * Export run history as JSON for bug reports.
+   */
+  export() {
+    const json = JSON.stringify(runHistory2, null, 2);
+    logger.info("[Mixer Debug] Run history exported. Copy the returned string or use:");
+    logger.info("  copy(window.skuilder.mixer.export())");
+    return json;
+  },
+  /**
+   * Clear run history.
+   */
+  clear() {
+    runHistory2.length = 0;
+    logger.info("[Mixer Debug] Run history cleared.");
+  },
+  /**
+   * Show help.
+   */
+  help() {
+    logger.info(`
+\u{1F3A8} Mixer Debug API
+
+Commands:
+  .showLastMix()           Show summary of most recent mixer run
+  .showRun(id|index)       Show summary of a specific run (by index or ID suffix)
+  .explainSourceBalance()  Analyze source balance and selection patterns
+  .compareScores()         Compare score distributions across sources
+  .showCard(cardId)        Show mixer decisions for a specific card
+  .listRuns()              List all captured runs in table format
+  .export()                Export run history as JSON for bug reports
+  .clear()                 Clear run history
+  .runs                    Access raw run history array
+  .help()                  Show this help message
+
+Example:
+  window.skuilder.mixer.showLastMix()
+  window.skuilder.mixer.explainSourceBalance()
+  window.skuilder.mixer.compareScores()
+`);
+  }
+};
+function mountMixerDebugger() {
+  if (typeof window === "undefined") return;
+  const win = window;
+  win.skuilder = win.skuilder || {};
+  win.skuilder.mixer = mixerDebugAPI;
+}
+mountMixerDebugger();
+
+// src/study/SessionDebugger.ts
+init_logger();
+var activeSession = null;
+var sessionHistory = [];
+var MAX_HISTORY = 5;
+function startSessionTracking(reviewQLength, newQLength, failedQLength) {
+  const sessionId = `session-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+  activeSession = {
+    sessionId,
+    startTime: /* @__PURE__ */ new Date(),
+    initialQueues: {
+      timestamp: /* @__PURE__ */ new Date(),
+      reviewQLength,
+      newQLength,
+      failedQLength
+    },
+    presentations: [],
+    queueSnapshots: []
+  };
+  logger.debug(`[SessionDebugger] Started tracking session: ${sessionId}`);
+}
+function recordCardPresentation(cardId, courseId, courseName, origin, queueSource, score) {
+  if (!activeSession) {
+    logger.warn("[SessionDebugger] No active session to record presentation");
+    return;
+  }
+  activeSession.presentations.push({
+    timestamp: /* @__PURE__ */ new Date(),
+    sequenceNumber: activeSession.presentations.length + 1,
+    cardId,
+    courseId,
+    courseName,
+    origin,
+    queueSource,
+    score
+  });
+}
+function snapshotQueues(reviewQLength, newQLength, failedQLength, reviewQNext3, newQNext3) {
+  if (!activeSession) {
+    return;
+  }
+  activeSession.queueSnapshots.push({
+    timestamp: /* @__PURE__ */ new Date(),
+    reviewQLength,
+    newQLength,
+    failedQLength,
+    reviewQNext3,
+    newQNext3
+  });
+}
+function endSessionTracking() {
+  if (!activeSession) {
+    return;
+  }
+  activeSession.endTime = /* @__PURE__ */ new Date();
+  sessionHistory.unshift(activeSession);
+  if (sessionHistory.length > MAX_HISTORY) {
+    sessionHistory.pop();
+  }
+  logger.debug(`[SessionDebugger] Ended session: ${activeSession.sessionId}`);
+  activeSession = null;
+}
+function showCurrentQueue() {
+  if (!activeSession) {
+    logger.info("[Session Debug] No active session.");
+    return;
+  }
+  const latest = activeSession.queueSnapshots[activeSession.queueSnapshots.length - 1] || activeSession.initialQueues;
+  console.group("\u{1F4CA} Current Queue State");
+  logger.info(`Review Queue: ${latest.reviewQLength} cards`);
+  if (latest.reviewQNext3 && latest.reviewQNext3.length > 0) {
+    logger.info(`  Next: ${latest.reviewQNext3.join(", ")}`);
+  }
+  logger.info(`New Queue: ${latest.newQLength} cards`);
+  if (latest.newQNext3 && latest.newQNext3.length > 0) {
+    logger.info(`  Next: ${latest.newQNext3.join(", ")}`);
+  }
+  logger.info(`Failed Queue: ${latest.failedQLength} cards`);
+  console.groupEnd();
+}
+function showPresentationHistory(sessionIndex = 0) {
+  const session = sessionIndex === 0 && activeSession ? activeSession : sessionHistory[sessionIndex];
+  if (!session) {
+    logger.info(`[Session Debug] No session found at index ${sessionIndex}`);
+    return;
+  }
+  console.group(`\u{1F4DC} Session History: ${session.sessionId}`);
+  logger.info(`Started: ${session.startTime.toLocaleTimeString()}`);
+  if (session.endTime) {
+    logger.info(`Ended: ${session.endTime.toLocaleTimeString()}`);
+  }
+  logger.info(`Cards presented: ${session.presentations.length}`);
+  if (session.presentations.length > 0) {
+    console.table(
+      session.presentations.map((p) => ({
+        "#": p.sequenceNumber,
+        course: p.courseName || p.courseId.slice(0, 8),
+        origin: p.origin,
+        queue: p.queueSource,
+        score: p.score?.toFixed(3) || "-",
+        time: p.timestamp.toLocaleTimeString()
+      }))
+    );
+  }
+  console.groupEnd();
+}
+function showInterleaving(sessionIndex = 0) {
+  const session = sessionIndex === 0 && activeSession ? activeSession : sessionHistory[sessionIndex];
+  if (!session) {
+    logger.info(`[Session Debug] No session found at index ${sessionIndex}`);
+    return;
+  }
+  console.group("\u{1F500} Interleaving Analysis");
+  const courseCounts = /* @__PURE__ */ new Map();
+  const courseOrigins = /* @__PURE__ */ new Map();
+  session.presentations.forEach((p) => {
+    const name = p.courseName || p.courseId;
+    courseCounts.set(name, (courseCounts.get(name) || 0) + 1);
+    if (!courseOrigins.has(name)) {
+      courseOrigins.set(name, { review: 0, new: 0, failed: 0 });
+    }
+    const origins = courseOrigins.get(name);
+    origins[p.origin]++;
+  });
+  logger.info("Course distribution:");
+  console.table(
+    Array.from(courseCounts.entries()).map(([course, count]) => {
+      const origins = courseOrigins.get(course);
+      return {
+        course,
+        total: count,
+        reviews: origins.review,
+        new: origins.new,
+        failed: origins.failed,
+        percentage: (count / session.presentations.length * 100).toFixed(1) + "%"
+      };
+    })
+  );
+  if (session.presentations.length > 0) {
+    logger.info("\nPresentation sequence (first 20):");
+    const sequence = session.presentations.slice(0, 20).map((p, idx) => `${idx + 1}. ${p.courseName || p.courseId.slice(0, 8)} (${p.origin})`).join("\n");
+    logger.info(sequence);
+  }
+  let maxCluster = 0;
+  let currentCluster = 1;
+  let currentCourse = session.presentations[0]?.courseId;
+  for (let i = 1; i < session.presentations.length; i++) {
+    if (session.presentations[i].courseId === currentCourse) {
+      currentCluster++;
+      maxCluster = Math.max(maxCluster, currentCluster);
+    } else {
+      currentCourse = session.presentations[i].courseId;
+      currentCluster = 1;
+    }
+  }
+  if (maxCluster > 3) {
+    logger.info(`
+\u26A0\uFE0F Detected clustering: max ${maxCluster} cards from same course in a row`);
+    logger.info("This suggests cards are sorted by score rather than round-robin by course.");
+  }
+  console.groupEnd();
+}
+var sessionDebugAPI = {
+  /**
+   * Get raw session history for programmatic access.
+   */
+  get sessions() {
+    return [...sessionHistory];
+  },
+  /**
+   * Get active session if any.
+   */
+  get active() {
+    return activeSession;
+  },
+  /**
+   * Show current queue state.
+   */
+  showQueue() {
+    showCurrentQueue();
+  },
+  /**
+   * Show presentation history for current or past session.
+   */
+  showHistory(sessionIndex = 0) {
+    showPresentationHistory(sessionIndex);
+  },
+  /**
+   * Analyze course interleaving pattern.
+   */
+  showInterleaving(sessionIndex = 0) {
+    showInterleaving(sessionIndex);
+  },
+  /**
+   * List all tracked sessions.
+   */
+  listSessions() {
+    if (activeSession) {
+      logger.info(`Active session: ${activeSession.sessionId} (${activeSession.presentations.length} cards presented)`);
+    }
+    if (sessionHistory.length === 0) {
+      logger.info("[Session Debug] No completed sessions in history.");
+      return;
+    }
+    console.table(
+      sessionHistory.map((s, idx) => ({
+        index: idx,
+        id: s.sessionId.slice(-8),
+        started: s.startTime.toLocaleTimeString(),
+        ended: s.endTime?.toLocaleTimeString() || "incomplete",
+        cards: s.presentations.length
+      }))
+    );
+  },
+  /**
+   * Export session history as JSON for bug reports.
+   */
+  export() {
+    const data = {
+      active: activeSession,
+      history: sessionHistory
+    };
+    const json = JSON.stringify(data, null, 2);
+    logger.info("[Session Debug] Session data exported. Copy the returned string or use:");
+    logger.info("  copy(window.skuilder.session.export())");
+    return json;
+  },
+  /**
+   * Clear session history.
+   */
+  clear() {
+    sessionHistory.length = 0;
+    logger.info("[Session Debug] Session history cleared.");
+  },
+  /**
+   * Show help.
+   */
+  help() {
+    logger.info(`
+\u{1F3AF} Session Debug API
+
+Commands:
+  .showQueue()              Show current queue state (active session only)
+  .showHistory(index?)      Show presentation history (0=current/last, 1=previous, etc)
+  .showInterleaving(index?) Analyze course interleaving pattern
+  .listSessions()           List all tracked sessions
+  .export()                 Export session data as JSON for bug reports
+  .clear()                  Clear session history
+  .sessions                 Access raw session history array
+  .active                   Access active session (if any)
+  .help()                   Show this help message
+
+Example:
+  window.skuilder.session.showHistory()
+  window.skuilder.session.showInterleaving()
+  window.skuilder.session.showQueue()
+`);
+  }
+};
+function mountSessionDebugger() {
+  if (typeof window === "undefined") return;
+  const win = window;
+  win.skuilder = win.skuilder || {};
+  win.skuilder.session = sessionDebugAPI;
+}
+mountSessionDebugger();
+
 // src/study/SessionController.ts
 init_logger();
 var SessionController = class extends Loggable {
@@ -9486,6 +10690,8 @@ var SessionController = class extends Loggable {
   eloService;
   hydrationService;
   mixer;
+  dataLayer;
+  courseNameCache = /* @__PURE__ */ new Map();
   sources;
   // dataLayer and getViewComponent now injected into CardHydrationService
   _sessionRecord = [];
@@ -9505,7 +10711,11 @@ var SessionController = class extends Loggable {
     return this._secondsRemaining;
   }
   get report() {
-    return `${this.reviewQ.dequeueCount} reviews, ${this.newQ.dequeueCount} new cards`;
+    const reviewCount = this.reviewQ.dequeueCount;
+    const newCount = this.newQ.dequeueCount;
+    const reviewWord = reviewCount === 1 ? "review" : "reviews";
+    const newCardWord = newCount === 1 ? "new card" : "new cards";
+    return `${reviewCount} ${reviewWord}, ${newCount} ${newCardWord}`;
   }
   get detailedReport() {
     return this.newQ.toString + "\n" + this.reviewQ.toString + "\n" + this.failedQ.toString;
@@ -9521,6 +10731,7 @@ var SessionController = class extends Loggable {
    */
   constructor(sources, time, dataLayer, getViewComponent, mixer) {
     super();
+    this.dataLayer = dataLayer;
     this.mixer = mixer || new QuotaRoundRobinMixer();
     this.srsService = new SrsService(dataLayer.getUserDB());
     this.eloService = new EloService(dataLayer, dataLayer.getUserDB());
@@ -9588,6 +10799,7 @@ var SessionController = class extends Loggable {
     }
     await this.getWeightedContent();
     await this.hydrationService.ensureHydratedCards();
+    startSessionTracking(this.reviewQ.length, this.newQ.length, this.failedQ.length);
     this._intervalHandle = setInterval(() => {
       this.tick();
     }, 1e3);
@@ -9683,6 +10895,30 @@ var SessionController = class extends Loggable {
       );
     }
     const mixedWeighted = this.mixer.mix(batches, limit * this.sources.length);
+    const sourceIds = batches.map((b) => {
+      const firstCard = b.weighted[0];
+      return firstCard?.courseId || `source-${b.sourceIndex}`;
+    });
+    await Promise.all(
+      sourceIds.map(async (id) => {
+        try {
+          const config = await this.dataLayer.getCoursesDB().getCourseConfig(id);
+          this.courseNameCache.set(id, config.name);
+        } catch {
+        }
+      })
+    );
+    const sourceNames = sourceIds.map((id) => this.courseNameCache.get(id));
+    const quotaPerSource = this.mixer instanceof QuotaRoundRobinMixer ? Math.ceil(limit * this.sources.length / batches.length) : void 0;
+    captureMixerRun(
+      this.mixer.constructor.name,
+      batches,
+      sourceIds,
+      sourceNames,
+      limit * this.sources.length,
+      quotaPerSource,
+      mixedWeighted
+    );
     const reviewWeighted = mixedWeighted.filter((w) => getCardOrigin(w) === "review");
     const newWeighted = mixedWeighted.filter((w) => getCardOrigin(w) === "new");
     logger.debug(`[reviews] got ${reviewWeighted.length} reviews from mixer`);
@@ -9791,21 +11027,46 @@ var SessionController = class extends Loggable {
     this.dismissCurrentCard(action);
     if (this._secondsRemaining <= 0 && this.failedQ.length === 0) {
       this._currentCard = null;
+      endSessionTracking();
       return null;
     }
-    const nextItem = this._selectNextItemToHydrate();
-    if (!nextItem) {
-      this._currentCard = null;
-      return null;
-    }
-    let card = this.hydrationService.getHydratedCard(nextItem.cardID);
-    if (!card) {
-      card = await this.hydrationService.waitForCard(nextItem.cardID);
+    const MAX_SKIP = 20;
+    for (let attempt = 0; attempt < MAX_SKIP; attempt++) {
+      const nextItem = this._selectNextItemToHydrate();
+      if (!nextItem) {
+        this._currentCard = null;
+        endSessionTracking();
+        return null;
+      }
+      let card = this.hydrationService.getHydratedCard(nextItem.cardID);
+      if (!card) {
+        card = await this.hydrationService.waitForCard(nextItem.cardID);
+      }
+      this.removeItemFromQueue(nextItem);
+      if (card) {
+        await this.hydrationService.ensureHydratedCards();
+        this._currentCard = card;
+        const origin = nextItem.status === "review" || nextItem.status === "failed-review" ? "review" : nextItem.status === "new" || nextItem.status === "failed-new" ? "new" : "failed";
+        const queueSource = nextItem.status.startsWith("failed") ? "failedQ" : nextItem.status === "review" ? "reviewQ" : "newQ";
+        recordCardPresentation(
+          nextItem.cardID,
+          nextItem.courseID,
+          this.courseNameCache.get(nextItem.courseID),
+          origin,
+          queueSource
+        );
+        snapshotQueues(this.reviewQ.length, this.newQ.length, this.failedQ.length);
+        return card;
+      }
+      this.log(`Skipping card ${nextItem.cardID}: hydration failed, trying next`);
+      if (isReview(nextItem)) {
+        this.srsService.removeReview(nextItem.reviewID);
+      }
     }
-    this.removeItemFromQueue(nextItem);
-    await this.hydrationService.ensureHydratedCards();
-    this._currentCard = card;
-    return card;
+    this.log(`Exhausted ${MAX_SKIP} skip attempts finding a hydratable card`);
+    this._currentCard = null;
+    endSessionTracking();
+    return null;
   }
   /**
    * Public API for processing user responses to cards.
@@ -9953,6 +11214,7 @@ export {
   aggregateOutcomesForGradient,
   areQuestionRecords,
   buildStrategyStateId,
+  captureMixerRun,
   computeDeviation,
   computeEffectiveWeight,
   computeOutcomeSignal,
@@ -9960,6 +11222,7 @@ export {
   computeStrategyGradient,
   createOrchestrationContext,
   docIsDeleted,
+  endSessionTracking,
   ensureAppDataDirectory,
   getAppDataDirectory,
   getCardHistoryID,
@@ -9983,9 +11246,15 @@ export {
   isQuestionTypeRegistered,
   isReview,
   log,
+  mixerDebugAPI,
+  mountMixerDebugger,
+  mountPipelineDebugger,
+  mountSessionDebugger,
   newInterval,
   parseCardHistoryID,
+  pipelineDebugAPI,
   processCustomQuestionsData,
+  recordCardPresentation,
   recordUserOutcome,
   registerBlanksCard,
   registerCustomQuestionTypes,
@@ -9998,6 +11267,9 @@ export {
   removeQuestionType,
   runPeriodUpdate,
   scoreAccuracyInZone,
+  sessionDebugAPI,
+  snapshotQueues,
+  startSessionTracking,
   updateLearningState,
   updateStrategyWeight,
   validateMigration,