@vue-skuilder/db 0.1.24 → 0.1.26

package/dist/core/index.mjs

@@ -448,6 +448,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(
@@ -687,6 +696,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, {
@@ -755,6 +1029,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];
@@ -872,6 +1164,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;
@@ -931,7 +1224,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;
       }
     };
   }
@@ -951,18 +1253,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.
@@ -970,6 +1290,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).
        *
@@ -983,11 +1304,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,
@@ -1005,13 +1347,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)
@@ -1021,10 +1385,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"));
@@ -1033,8 +1406,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 };
       }
     };
@@ -2311,10 +2695,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) {
@@ -2338,6 +2735,7 @@ var init_Pipeline = __esm({
     init_navigators();
     init_logger();
     init_orchestration();
+    init_PipelineDebugger();
     Pipeline = class extends ContentNavigator {
       generator;
       filters;
@@ -2385,12 +2783,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);
@@ -2401,9 +2836,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;
       }
       /**
@@ -2493,6 +2945,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, {
@@ -2505,9 +3007,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.
@@ -2546,9 +3048,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 {
@@ -2609,75 +3113,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({
@@ -2685,6 +3124,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)),
@@ -2720,6 +3160,8 @@ __export(navigators_exports, {
   initializeNavigatorRegistry: () => initializeNavigatorRegistry,
   isFilter: () => isFilter,
   isGenerator: () => isGenerator,
+  mountPipelineDebugger: () => mountPipelineDebugger,
+  pipelineDebugAPI: () => pipelineDebugAPI,
   registerNavigator: () => registerNavigator
 });
 function registerNavigator(implementingClass, constructor) {
@@ -2786,6 +3228,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();
@@ -5387,7 +5830,9 @@ export {
   isQuestionRecord,
   isReview,
   log,
+  mountPipelineDebugger,
   parseCardHistoryID,
+  pipelineDebugAPI,
   recordUserOutcome,
   registerNavigator,
   runPeriodUpdate,