@vue-skuilder/db 0.1.31-a → 0.1.31

package/dist/impl/static/index.mjs

@@ -504,8 +504,12 @@ __export(PipelineDebugger_exports, {
   buildRunReport: () => buildRunReport,
   captureRun: () => captureRun,
   mountPipelineDebugger: () => mountPipelineDebugger,
-  pipelineDebugAPI: () => pipelineDebugAPI
+  pipelineDebugAPI: () => pipelineDebugAPI,
+  registerPipelineForDebug: () => registerPipelineForDebug
 });
+function registerPipelineForDebug(pipeline) {
+  _activePipeline = pipeline;
+}
 function getOrigin(card) {
   const firstEntry = card.provenance[0];
   if (!firstEntry) return "unknown";
@@ -533,6 +537,7 @@ function buildRunReport(courseId, courseName, generatorName, generators, generat
     origin: getOrigin(card),
     finalScore: card.score,
     provenance: card.provenance,
+    tags: card.tags,
     selected: selectedIds.has(card.cardId)
   }));
   const reviewsSelected = selectedCards.filter((c) => getOrigin(c) === "review").length;
@@ -588,11 +593,13 @@ function mountPipelineDebugger() {
   win.skuilder = win.skuilder || {};
   win.skuilder.pipeline = pipelineDebugAPI;
 }
-var MAX_RUNS, runHistory, pipelineDebugAPI;
+var _activePipeline, MAX_RUNS, runHistory, pipelineDebugAPI;
 var init_PipelineDebugger = __esm({
   "src/core/navigators/PipelineDebugger.ts"() {
     "use strict";
+    init_navigators();
     init_logger();
+    _activePipeline = null;
     MAX_RUNS = 10;
     runHistory = [];
     pipelineDebugAPI = {
@@ -734,6 +741,81 @@ var init_PipelineDebugger = __esm({
         runHistory.length = 0;
         logger.info("[Pipeline Debug] Run history cleared.");
       },
+      /**
+       * Show the navigator registry: all registered classes and their roles.
+       *
+       * Useful for verifying that consumer-defined navigators were registered
+       * before pipeline assembly.
+       */
+      showRegistry() {
+        const names = getRegisteredNavigatorNames();
+        if (names.length === 0) {
+          logger.info("[Pipeline Debug] Navigator registry is empty.");
+          return;
+        }
+        console.group("\u{1F4E6} Navigator Registry");
+        console.table(
+          names.map((name) => {
+            const registryRole = getRegisteredNavigatorRole(name);
+            const builtinRole = NavigatorRoles[name];
+            const effectiveRole = builtinRole || registryRole || "\u26A0\uFE0F NONE";
+            const source = builtinRole ? "built-in" : registryRole ? "consumer" : "unclassified";
+            return {
+              name,
+              role: effectiveRole,
+              source,
+              isGenerator: isGenerator(name),
+              isFilter: isFilter(name)
+            };
+          })
+        );
+        console.groupEnd();
+      },
+      /**
+       * Show strategy documents from the last pipeline run and how they mapped
+       * to the registry.
+       *
+       * If no runs are captured yet, falls back to showing just the registry.
+       */
+      showStrategies() {
+        this.showRegistry();
+        if (runHistory.length === 0) {
+          logger.info("[Pipeline Debug] No pipeline runs captured yet \u2014 cannot show strategy doc mapping.");
+          return;
+        }
+        const run = runHistory[0];
+        console.group("\u{1F50C} Pipeline Strategy Mapping (last run)");
+        logger.info(`Generator: ${run.generatorName}`);
+        if (run.generators && run.generators.length > 0) {
+          for (const g of run.generators) {
+            logger.info(`  \u{1F4E5} ${g.name}: ${g.cardCount} cards (${g.newCount} new, ${g.reviewCount} reviews)`);
+          }
+        }
+        if (run.filters.length > 0) {
+          logger.info("Filters:");
+          for (const f of run.filters) {
+            logger.info(`  \u{1F538} ${f.name}: \u2191${f.boosted} \u2193${f.penalized} =${f.passed} \u2715${f.removed}`);
+          }
+        } else {
+          logger.info("Filters: (none)");
+        }
+        console.groupEnd();
+      },
+      /**
+       * Scan the full card space through the filter chain for the current user.
+       *
+       * Reports how many cards are well-indicated and how many are new.
+       * Use this to understand how the search space grows during onboarding.
+       *
+       * @param threshold - Score threshold for "well indicated" (default 0.10)
+       */
+      async diagnoseCardSpace(threshold) {
+        if (!_activePipeline) {
+          logger.info("[Pipeline Debug] No active pipeline. Run a session first.");
+          return null;
+        }
+        return _activePipeline.diagnoseCardSpace({ threshold });
+      },
       /**
        * Show help.
        */
@@ -746,6 +828,9 @@ Commands:
   .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
+  .diagnoseCardSpace()   Scan full card space through filters (async)
+  .showRegistry()        Show navigator registry (classes + roles)
+  .showStrategies()      Show registry + strategy mapping from last run
   .listRuns()            List all captured runs in table format
   .export()              Export run history as JSON for bug reports
   .clear()               Clear run history
@@ -755,7 +840,7 @@ Commands:
 Example:
   window.skuilder.pipeline.showLastRun()
   window.skuilder.pipeline.showRun(1)
-  window.skuilder.pipeline.showCard('abc123')
+  await window.skuilder.pipeline.diagnoseCardSpace()
 `);
       }
     };
@@ -1050,6 +1135,69 @@ var init_generators = __esm({
   }
 });
 
+// src/core/navigators/generators/prescribed.ts
+var prescribed_exports = {};
+__export(prescribed_exports, {
+  default: () => PrescribedCardsGenerator
+});
+var PrescribedCardsGenerator;
+var init_prescribed = __esm({
+  "src/core/navigators/generators/prescribed.ts"() {
+    "use strict";
+    init_navigators();
+    init_logger();
+    PrescribedCardsGenerator = class extends ContentNavigator {
+      name;
+      config;
+      constructor(user, course, strategyData) {
+        super(user, course, strategyData);
+        this.name = strategyData.name || "Prescribed Cards";
+        try {
+          const parsed = JSON.parse(strategyData.serializedData);
+          this.config = { cardIds: parsed.cardIds || [] };
+        } catch {
+          this.config = { cardIds: [] };
+        }
+        logger.debug(
+          `[Prescribed] Initialized with ${this.config.cardIds.length} prescribed cards`
+        );
+      }
+      async getWeightedCards(limit, _context) {
+        if (this.config.cardIds.length === 0) {
+          return [];
+        }
+        const courseId = this.course.getCourseID();
+        const activeCards = await this.user.getActiveCards();
+        const activeIds = new Set(activeCards.map((ac) => ac.cardID));
+        const eligibleIds = this.config.cardIds.filter((id) => !activeIds.has(id));
+        if (eligibleIds.length === 0) {
+          logger.debug("[Prescribed] All prescribed cards already active, returning empty");
+          return [];
+        }
+        const cards = eligibleIds.slice(0, limit).map((cardId) => ({
+          cardId,
+          courseId,
+          score: 1,
+          provenance: [
+            {
+              strategy: "prescribed",
+              strategyName: this.strategyName || this.name,
+              strategyId: this.strategyId || "NAVIGATION_STRATEGY-prescribed",
+              action: "generated",
+              score: 1,
+              reason: `Prescribed card (${eligibleIds.length} eligible of ${this.config.cardIds.length} configured)`
+            }
+          ]
+        }));
+        logger.info(
+          `[Prescribed] Emitting ${cards.length} cards (${eligibleIds.length} eligible, ${activeIds.size} already active)`
+        );
+        return cards;
+      }
+    };
+  }
+});
+
 // src/core/navigators/generators/srs.ts
 var srs_exports = {};
 __export(srs_exports, {
@@ -1244,6 +1392,7 @@ var init_ = __esm({
       "./generators/CompositeGenerator.ts": () => Promise.resolve().then(() => (init_CompositeGenerator(), CompositeGenerator_exports)),
       "./generators/elo.ts": () => Promise.resolve().then(() => (init_elo(), elo_exports)),
       "./generators/index.ts": () => Promise.resolve().then(() => (init_generators(), generators_exports)),
+      "./generators/prescribed.ts": () => Promise.resolve().then(() => (init_prescribed(), prescribed_exports)),
       "./generators/srs.ts": () => Promise.resolve().then(() => (init_srs(), srs_exports)),
       "./generators/types.ts": () => Promise.resolve().then(() => (init_types(), types_exports))
     });
@@ -1444,6 +1593,8 @@ var init_hierarchyDefinition = __esm({
         if (userTagElo.count < minCount) return false;
         if (prereq.masteryThreshold?.minElo !== void 0) {
           return userTagElo.score >= prereq.masteryThreshold.minElo;
+        } else if (prereq.masteryThreshold?.minCount !== void 0) {
+          return true;
         } else {
           return userTagElo.score >= userGlobalElo;
         }
@@ -1519,14 +1670,38 @@ var init_hierarchyDefinition = __esm({
           };
         }
       }
+      /**
+       * Build a map of prereq tag → max configured boost for all *closed* gates.
+       *
+       * When a gate is closed (prereqs unmet), cards carrying that gate's prereq
+       * tags get boosted — steering the pipeline toward content that helps unlock
+       * the gated material. Once the gate opens, the boost disappears.
+       */
+      getPreReqBoosts(unlockedTags, masteredTags) {
+        const boosts = /* @__PURE__ */ new Map();
+        for (const [tagId, prereqs] of Object.entries(this.config.prerequisites)) {
+          if (unlockedTags.has(tagId)) continue;
+          for (const prereq of prereqs) {
+            if (!prereq.preReqBoost || prereq.preReqBoost <= 1) continue;
+            if (masteredTags.has(prereq.tag)) continue;
+            const existing = boosts.get(prereq.tag) ?? 1;
+            boosts.set(prereq.tag, Math.max(existing, prereq.preReqBoost));
+          }
+        }
+        return boosts;
+      }
       /**
        * CardFilter.transform implementation.
        *
-       * Apply prerequisite gating to cards. Cards with locked tags receive score * 0.01.
+       * Two effects:
+       * 1. Cards with locked tags receive score * 0.05 (gating penalty)
+       * 2. Cards carrying prereq tags of closed gates receive a configured
+       *    boost (preReqBoost), steering toward content that unlocks gates
        */
       async transform(cards, context) {
         const masteredTags = await this.getMasteredTags(context);
         const unlockedTags = this.getUnlockedTags(masteredTags);
+        const preReqBoosts = this.getPreReqBoosts(unlockedTags, masteredTags);
         const gated = [];
         for (const card of cards) {
           const { isUnlocked, reason } = await this.checkCardUnlock(
@@ -1535,9 +1710,27 @@ var init_hierarchyDefinition = __esm({
             unlockedTags,
             masteredTags
           );
-          const LOCKED_PENALTY = 0.01;
-          const finalScore = isUnlocked ? card.score : card.score * LOCKED_PENALTY;
-          const action = isUnlocked ? "passed" : "penalized";
+          const LOCKED_PENALTY = 0.02;
+          let finalScore = isUnlocked ? card.score : card.score * LOCKED_PENALTY;
+          let action = isUnlocked ? "passed" : "penalized";
+          let finalReason = reason;
+          if (isUnlocked && preReqBoosts.size > 0) {
+            const cardTags = card.tags ?? [];
+            let maxBoost = 1;
+            const boostedPrereqs = [];
+            for (const tag of cardTags) {
+              const boost = preReqBoosts.get(tag);
+              if (boost && boost > maxBoost) {
+                maxBoost = boost;
+                boostedPrereqs.push(tag);
+              }
+            }
+            if (maxBoost > 1) {
+              finalScore *= maxBoost;
+              action = "boosted";
+              finalReason = `${reason} | preReqBoost \xD7${maxBoost.toFixed(2)} for ${boostedPrereqs.join(", ")}`;
+            }
+          }
           gated.push({
             ...card,
             score: finalScore,
@@ -1549,7 +1742,7 @@ var init_hierarchyDefinition = __esm({
                 strategyId: this.strategyId || "NAVIGATION_STRATEGY-hierarchy",
                 action,
                 score: finalScore,
-                reason
+                reason: finalReason
               }
             ]
           });
@@ -2238,6 +2431,18 @@ __export(Pipeline_exports, {
   Pipeline: () => Pipeline
 });
 import { toCourseElo as toCourseElo5 } from "@vue-skuilder/common";
+function globToRegex(pattern) {
+  const escaped = pattern.replace(/[.+?^${}()|[\]\\]/g, "\\$&");
+  const withWildcards = escaped.replace(/\*/g, ".*");
+  return new RegExp(`^${withWildcards}$`);
+}
+function globMatch(value, pattern) {
+  if (!pattern.includes("*")) return value === pattern;
+  return globToRegex(pattern).test(value);
+}
+function cardMatchesTagPattern(card, pattern) {
+  return (card.tags ?? []).some((tag) => globMatch(tag, pattern));
+}
 function logPipelineConfig(generator, filters) {
   const filterList = filters.length > 0 ? "\n    - " + filters.map((f) => f.name).join("\n    - ") : " none";
   logger.info(
@@ -2272,6 +2477,21 @@ function logExecutionSummary(generatorName, generatedCount, filterCount, finalCo
   \u{1F4A1} Inspect: window.skuilder.pipeline`
   );
 }
+function logResultCards(cards) {
+  if (!VERBOSE_RESULTS || cards.length === 0) return;
+  logger.info(`[Pipeline] Results (${cards.length} cards):`);
+  for (let i = 0; i < cards.length; i++) {
+    const c = cards[i];
+    const tags = c.tags?.slice(0, 3).join(", ") || "";
+    const filters = c.provenance.filter((p) => p.strategy === "hierarchyDefinition" || p.strategy === "priorityDefinition" || p.strategy === "interferenceFilter" || p.strategy === "letterGating" || p.strategy === "ephemeralHint").map((p) => {
+      const arrow = p.action === "boosted" ? "\u2191" : p.action === "penalized" ? "\u2193" : "=";
+      return `${p.strategyName}${arrow}${p.score.toFixed(2)}`;
+    }).join(" | ");
+    logger.info(
+      `[Pipeline]   ${String(i + 1).padStart(2)}. ${c.score.toFixed(4)}  ${c.cardId}  [${tags}]${filters ? `  {${filters}}` : ""}`
+    );
+  }
+}
 function logCardProvenance(cards, maxCards = 3) {
   const cardsToLog = cards.slice(0, maxCards);
   logger.debug(`[Pipeline] Provenance for top ${cardsToLog.length} cards:`);
@@ -2286,7 +2506,7 @@ function logCardProvenance(cards, maxCards = 3) {
     }
   }
 }
-var Pipeline;
+var VERBOSE_RESULTS, Pipeline;
 var init_Pipeline = __esm({
   "src/core/navigators/Pipeline.ts"() {
     "use strict";
@@ -2294,9 +2514,31 @@ var init_Pipeline = __esm({
     init_logger();
     init_orchestration();
     init_PipelineDebugger();
+    VERBOSE_RESULTS = true;
     Pipeline = class extends ContentNavigator {
       generator;
       filters;
+      /**
+       * Cached orchestration context. Course config and salt don't change within
+       * a page load, so we build the orchestration context once and reuse it on
+       * subsequent getWeightedCards() calls (e.g. mid-session replans).
+       *
+       * This eliminates a remote getCourseConfig() round trip per pipeline run.
+       */
+      _cachedOrchestration = null;
+      /**
+       * Persistent tag cache. Maps cardId → tag names.
+       *
+       * Tags are static within a session (they're set at card generation time),
+       * so we cache them across pipeline runs. On replans, many of the same cards
+       * reappear — cache hits avoid redundant remote getAppliedTagsBatch() queries.
+       */
+      _tagCache = /* @__PURE__ */ new Map();
+      /**
+       * One-shot replan hints. Applied after the filter chain on the next
+       * getWeightedCards() call, then cleared.
+       */
+      _ephemeralHints = null;
       /**
        * Create a new pipeline.
        *
@@ -2317,6 +2559,17 @@ var init_Pipeline = __esm({
           logger.error(`[pipeline] Failed to lookup courseCfg: ${e}`);
         });
         logPipelineConfig(generator, filters);
+        registerPipelineForDebug(this);
+      }
+      /**
+       * Set one-shot hints for the next pipeline run.
+       * Consumed after one getWeightedCards() call, then cleared.
+       *
+       * Overrides ContentNavigator.setEphemeralHints() no-op.
+       */
+      setEphemeralHints(hints) {
+        this._ephemeralHints = hints;
+        logger.info(`[Pipeline] Ephemeral hints set: ${JSON.stringify(hints)}`);
       }
       /**
        * Get weighted cards by running generator and applying filters.
@@ -2333,13 +2586,15 @@ var init_Pipeline = __esm({
        * @returns Cards sorted by score descending
        */
       async getWeightedCards(limit) {
+        const t0 = performance.now();
         const context = await this.buildContext();
-        const overFetchMultiplier = 2 + this.filters.length * 0.5;
-        const fetchLimit = Math.ceil(limit * overFetchMultiplier);
+        const tContext = performance.now();
+        const fetchLimit = 500;
         logger.debug(
           `[Pipeline] Fetching ${fetchLimit} candidates from generator '${this.generator.name}'`
         );
         let cards = await this.generator.getWeightedCards(fetchLimit, context);
+        const tGenerate = performance.now();
         const generatedCount = cards.length;
         let generatorSummaries;
         if (this.generator.generators) {
@@ -2368,6 +2623,7 @@ var init_Pipeline = __esm({
         }
         logger.debug(`[Pipeline] Generator returned ${generatedCount} candidates`);
         cards = await this.hydrateTags(cards);
+        const tHydrate = performance.now();
         const allCardsBeforeFiltering = [...cards];
         const filterImpacts = [];
         for (const filter of this.filters) {
@@ -2386,8 +2642,17 @@ var init_Pipeline = __esm({
           logger.debug(`[Pipeline] Filter '${filter.name}': ${beforeScores.size} \u2192 ${cards.length} cards (\u2191${boosted} \u2193${penalized} =${passed})`);
         }
         cards = cards.filter((c) => c.score > 0);
+        const hints = this._ephemeralHints;
+        if (hints) {
+          this._ephemeralHints = null;
+          cards = this.applyHints(cards, hints, allCardsBeforeFiltering);
+        }
         cards.sort((a, b) => b.score - a.score);
+        const tFilter = performance.now();
         const result = cards.slice(0, limit);
+        logger.info(
+          `[Pipeline:timing] total=${(tFilter - t0).toFixed(0)}ms (context=${(tContext - t0).toFixed(0)} generate=${(tGenerate - tContext).toFixed(0)} hydrate=${(tHydrate - tGenerate).toFixed(0)} filter=${(tFilter - tHydrate).toFixed(0)})`
+        );
         const topScores = result.slice(0, 3).map((c) => c.score);
         logExecutionSummary(
           this.generator.name,
@@ -2397,6 +2662,7 @@ var init_Pipeline = __esm({
           topScores,
           filterImpacts
         );
+        logResultCards(result);
         logCardProvenance(result, 3);
         try {
           const courseName = await this.course?.getCourseConfig().then((c) => c.name).catch(() => void 0);
@@ -2423,6 +2689,10 @@ var init_Pipeline = __esm({
        * to the WeightedCard objects. Filters can then use card.tags instead of
        * making individual getAppliedTags() calls.
        *
+       * Uses a persistent tag cache across pipeline runs — tags are static within
+       * a session, so cards seen in a prior run (e.g. before a replan) don't
+       * require a second DB query.
+       *
        * @param cards - Cards to hydrate
        * @returns Cards with tags populated
        */
@@ -2430,14 +2700,128 @@ var init_Pipeline = __esm({
         if (cards.length === 0) {
           return cards;
         }
-        const cardIds = cards.map((c) => c.cardId);
-        const tagsByCard = await this.course.getAppliedTagsBatch(cardIds);
+        const uncachedIds = [];
+        for (const card of cards) {
+          if (!this._tagCache.has(card.cardId)) {
+            uncachedIds.push(card.cardId);
+          }
+        }
+        if (uncachedIds.length > 0) {
+          const freshTags = await this.course.getAppliedTagsBatch(uncachedIds);
+          for (const [cardId, tags] of freshTags) {
+            this._tagCache.set(cardId, tags);
+          }
+        }
+        const tagsByCard = /* @__PURE__ */ new Map();
+        for (const card of cards) {
+          tagsByCard.set(card.cardId, this._tagCache.get(card.cardId) ?? []);
+        }
         logTagHydration(cards, tagsByCard);
         return cards.map((card) => ({
           ...card,
-          tags: tagsByCard.get(card.cardId) ?? []
+          tags: this._tagCache.get(card.cardId) ?? []
         }));
       }
+      // ---------------------------------------------------------------------------
+      // Ephemeral hints application
+      // ---------------------------------------------------------------------------
+      /**
+       * Apply one-shot replan hints to the post-filter card set.
+       *
+       * Order of operations:
+       *   1. Exclude (remove unwanted cards)
+       *   2. Boost (multiply scores)
+       *   3. Require (inject must-have cards from the full pre-filter pool)
+       *
+       * @param cards - Post-filter cards (score > 0)
+       * @param hints - The ephemeral hints to apply
+       * @param allCards - Full pre-filter card pool (for require injection)
+       */
+      applyHints(cards, hints, allCards) {
+        const beforeCount = cards.length;
+        if (hints.excludeCards?.length) {
+          cards = cards.filter(
+            (c) => !hints.excludeCards.some((pat) => globMatch(c.cardId, pat))
+          );
+        }
+        if (hints.excludeTags?.length) {
+          cards = cards.filter(
+            (c) => !hints.excludeTags.some((pat) => cardMatchesTagPattern(c, pat))
+          );
+        }
+        if (hints.boostTags) {
+          for (const [pattern, factor] of Object.entries(hints.boostTags)) {
+            for (const card of cards) {
+              if (cardMatchesTagPattern(card, pattern)) {
+                card.score *= factor;
+                card.provenance.push({
+                  strategy: "ephemeralHint",
+                  strategyId: "ephemeral-hint",
+                  strategyName: "Replan Hint",
+                  action: "boosted",
+                  score: card.score,
+                  reason: `boostTag ${pattern} \xD7${factor}`
+                });
+              }
+            }
+          }
+        }
+        if (hints.boostCards) {
+          for (const [pattern, factor] of Object.entries(hints.boostCards)) {
+            for (const card of cards) {
+              if (globMatch(card.cardId, pattern)) {
+                card.score *= factor;
+                card.provenance.push({
+                  strategy: "ephemeralHint",
+                  strategyId: "ephemeral-hint",
+                  strategyName: "Replan Hint",
+                  action: "boosted",
+                  score: card.score,
+                  reason: `boostCard ${pattern} \xD7${factor}`
+                });
+              }
+            }
+          }
+        }
+        const cardIds = new Set(cards.map((c) => c.cardId));
+        const inject = (card, reason) => {
+          if (!cardIds.has(card.cardId)) {
+            const floorScore = Math.max(card.score, 1);
+            cards.push({
+              ...card,
+              score: floorScore,
+              provenance: [
+                ...card.provenance,
+                {
+                  strategy: "ephemeralHint",
+                  strategyId: "ephemeral-hint",
+                  strategyName: "Replan Hint",
+                  action: "boosted",
+                  score: floorScore,
+                  reason
+                }
+              ]
+            });
+            cardIds.add(card.cardId);
+          }
+        };
+        if (hints.requireCards?.length) {
+          for (const pattern of hints.requireCards) {
+            for (const card of allCards) {
+              if (globMatch(card.cardId, pattern)) inject(card, `requireCard ${pattern}`);
+            }
+          }
+        }
+        if (hints.requireTags?.length) {
+          for (const pattern of hints.requireTags) {
+            for (const card of allCards) {
+              if (cardMatchesTagPattern(card, pattern)) inject(card, `requireTag ${pattern}`);
+            }
+          }
+        }
+        logger.info(`[Pipeline] Hints applied: ${beforeCount} \u2192 ${cards.length} cards`);
+        return cards;
+      }
       /**
        * Build shared context for generator and filters.
        *
@@ -2455,7 +2839,10 @@ var init_Pipeline = __esm({
         } catch (e) {
           logger.debug(`[Pipeline] Could not get user ELO, using default: ${e}`);
         }
-        const orchestration = await createOrchestrationContext(this.user, this.course);
+        if (!this._cachedOrchestration) {
+          this._cachedOrchestration = await createOrchestrationContext(this.user, this.course);
+        }
+        const orchestration = this._cachedOrchestration;
         return {
           user: this.user,
           course: this.course,
@@ -2499,6 +2886,87 @@ var init_Pipeline = __esm({
         }
         return [...new Set(ids)];
       }
+      // ---------------------------------------------------------------------------
+      // Card-space diagnostic
+      // ---------------------------------------------------------------------------
+      /**
+       * Scan every card in the course through the filter chain and report
+       * how many are "well indicated" (score >= threshold) for the current user.
+       *
+       * Also reports how many well-indicated cards the user has NOT yet encountered.
+       *
+       * Exposed via `window.skuilder.pipeline.diagnoseCardSpace()`.
+       */
+      async diagnoseCardSpace(opts) {
+        const THRESHOLD = opts?.threshold ?? 0.1;
+        const t0 = performance.now();
+        const allCardIds = await this.course.getAllCardIds();
+        let cards = allCardIds.map((cardId) => ({
+          cardId,
+          courseId: this.course.getCourseID(),
+          score: 1,
+          provenance: []
+        }));
+        cards = await this.hydrateTags(cards);
+        const context = await this.buildContext();
+        const filterBreakdown = [];
+        for (const filter of this.filters) {
+          cards = await filter.transform(cards, context);
+          const wi = cards.filter((c) => c.score >= THRESHOLD).length;
+          filterBreakdown.push({ name: filter.name, wellIndicated: wi });
+        }
+        const wellIndicated = cards.filter((c) => c.score >= THRESHOLD);
+        const wellIndicatedIds = new Set(wellIndicated.map((c) => c.cardId));
+        let encounteredIds;
+        try {
+          const courseId = this.course.getCourseID();
+          const seenCards = await this.user.getSeenCards(courseId);
+          encounteredIds = new Set(seenCards);
+        } catch {
+          encounteredIds = /* @__PURE__ */ new Set();
+        }
+        const wellIndicatedNew = wellIndicated.filter((c) => !encounteredIds.has(c.cardId));
+        const byType = /* @__PURE__ */ new Map();
+        for (const card of cards) {
+          const type = card.cardId.split("-")[1] || "unknown";
+          if (!byType.has(type)) {
+            byType.set(type, { total: 0, wellIndicated: 0, new: 0 });
+          }
+          const entry = byType.get(type);
+          entry.total++;
+          if (card.score >= THRESHOLD) {
+            entry.wellIndicated++;
+            if (!encounteredIds.has(card.cardId)) entry.new++;
+          }
+        }
+        const elapsed = performance.now() - t0;
+        const result = {
+          totalCards: allCardIds.length,
+          threshold: THRESHOLD,
+          wellIndicated: wellIndicatedIds.size,
+          encountered: encounteredIds.size,
+          wellIndicatedNew: wellIndicatedNew.length,
+          byType: Object.fromEntries(byType),
+          filterBreakdown,
+          elapsedMs: Math.round(elapsed)
+        };
+        logger.info(`[Pipeline:diagnose] Card space scan (${result.elapsedMs}ms):`);
+        logger.info(`[Pipeline:diagnose]   Total cards: ${result.totalCards}`);
+        logger.info(`[Pipeline:diagnose]   Well-indicated (score >= ${THRESHOLD}): ${result.wellIndicated}`);
+        logger.info(`[Pipeline:diagnose]   Encountered: ${result.encountered}`);
+        logger.info(`[Pipeline:diagnose]   Well-indicated & new: ${result.wellIndicatedNew}`);
+        logger.info(`[Pipeline:diagnose]   By type:`);
+        for (const [type, counts] of byType) {
+          logger.info(
+            `[Pipeline:diagnose]     ${type}: ${counts.wellIndicated}/${counts.total} well-indicated, ${counts.new} new`
+          );
+        }
+        logger.info(`[Pipeline:diagnose]   After each filter:`);
+        for (const fb of filterBreakdown) {
+          logger.info(`[Pipeline:diagnose]     ${fb.name}: ${fb.wellIndicated} well-indicated`);
+        }
+        return result;
+      }
     };
   }
 });
@@ -2603,23 +3071,25 @@ var init_PipelineAssembler = __esm({
             warnings.push(`Unknown strategy type '${s.implementingClass}', skipping: ${s.name}`);
           }
         }
+        const courseId = course.getCourseID();
+        const hasElo = generatorStrategies.some((s) => s.implementingClass === "elo" /* ELO */);
+        const hasSrs = generatorStrategies.some((s) => s.implementingClass === "srs" /* SRS */);
+        if (!hasElo) {
+          logger.debug("[PipelineAssembler] No ELO generator configured, adding default");
+          generatorStrategies.push(createDefaultEloStrategy(courseId));
+        }
+        if (!hasSrs) {
+          logger.debug("[PipelineAssembler] No SRS generator configured, adding default");
+          generatorStrategies.push(createDefaultSrsStrategy(courseId));
+        }
         if (generatorStrategies.length === 0) {
-          if (filterStrategies.length > 0) {
-            logger.debug(
-              "[PipelineAssembler] No generator found, using default ELO and SRS with configured filters"
-            );
-            const courseId = course.getCourseID();
-            generatorStrategies.push(createDefaultEloStrategy(courseId));
-            generatorStrategies.push(createDefaultSrsStrategy(courseId));
-          } else {
-            warnings.push("No generator strategy found");
-            return {
-              pipeline: null,
-              generatorStrategies: [],
-              filterStrategies: [],
-              warnings
-            };
-          }
+          warnings.push("No generator strategy found");
+          return {
+            pipeline: null,
+            generatorStrategies: [],
+            filterStrategies: [],
+            warnings
+          };
         }
         let generator;
         if (generatorStrategies.length === 1) {
@@ -2697,6 +3167,7 @@ var init_3 = __esm({
       "./generators/CompositeGenerator.ts": () => Promise.resolve().then(() => (init_CompositeGenerator(), CompositeGenerator_exports)),
       "./generators/elo.ts": () => Promise.resolve().then(() => (init_elo(), elo_exports)),
       "./generators/index.ts": () => Promise.resolve().then(() => (init_generators(), generators_exports)),
+      "./generators/prescribed.ts": () => Promise.resolve().then(() => (init_prescribed(), prescribed_exports)),
       "./generators/srs.ts": () => Promise.resolve().then(() => (init_srs(), srs_exports)),
       "./generators/types.ts": () => Promise.resolve().then(() => (init_types(), types_exports)),
       "./index.ts": () => Promise.resolve().then(() => (init_navigators(), navigators_exports))
@@ -2714,6 +3185,7 @@ __export(navigators_exports, {
   getCardOrigin: () => getCardOrigin,
   getRegisteredNavigator: () => getRegisteredNavigator,
   getRegisteredNavigatorNames: () => getRegisteredNavigatorNames,
+  getRegisteredNavigatorRole: () => getRegisteredNavigatorRole,
   hasRegisteredNavigator: () => hasRegisteredNavigator,
   initializeNavigatorRegistry: () => initializeNavigatorRegistry,
   isFilter: () => isFilter,
@@ -2722,16 +3194,19 @@ __export(navigators_exports, {
   pipelineDebugAPI: () => pipelineDebugAPI,
   registerNavigator: () => registerNavigator
 });
-function registerNavigator(implementingClass, constructor) {
-  navigatorRegistry.set(implementingClass, constructor);
-  logger.debug(`[NavigatorRegistry] Registered: ${implementingClass}`);
+function registerNavigator(implementingClass, constructor, role) {
+  navigatorRegistry.set(implementingClass, { constructor, role });
+  logger.debug(`[NavigatorRegistry] Registered: ${implementingClass}${role ? ` (${role})` : ""}`);
 }
 function getRegisteredNavigator(implementingClass) {
-  return navigatorRegistry.get(implementingClass);
+  return navigatorRegistry.get(implementingClass)?.constructor;
 }
 function hasRegisteredNavigator(implementingClass) {
   return navigatorRegistry.has(implementingClass);
 }
+function getRegisteredNavigatorRole(implementingClass) {
+  return navigatorRegistry.get(implementingClass)?.role;
+}
 function getRegisteredNavigatorNames() {
   return Array.from(navigatorRegistry.keys());
 }
@@ -2741,8 +3216,10 @@ async function initializeNavigatorRegistry() {
     Promise.resolve().then(() => (init_elo(), elo_exports)),
     Promise.resolve().then(() => (init_srs(), srs_exports))
   ]);
+  const prescribedModule = await Promise.resolve().then(() => (init_prescribed(), prescribed_exports));
   registerNavigator("elo", eloModule.default);
   registerNavigator("srs", srsModule.default);
+  registerNavigator("prescribed", prescribedModule.default);
   const [
     hierarchyModule,
     interferenceModule,
@@ -2777,10 +3254,12 @@ function getCardOrigin(card) {
   return "new";
 }
 function isGenerator(impl) {
-  return NavigatorRoles[impl] === "generator" /* GENERATOR */;
+  if (NavigatorRoles[impl] === "generator" /* GENERATOR */) return true;
+  return getRegisteredNavigatorRole(impl) === "generator" /* GENERATOR */;
 }
 function isFilter(impl) {
-  return NavigatorRoles[impl] === "filter" /* FILTER */;
+  if (NavigatorRoles[impl] === "filter" /* FILTER */) return true;
+  return getRegisteredNavigatorRole(impl) === "filter" /* FILTER */;
 }
 var navigatorRegistry, Navigators, NavigatorRole, NavigatorRoles, ContentNavigator;
 var init_navigators = __esm({
@@ -2795,6 +3274,7 @@ var init_navigators = __esm({
     Navigators = /* @__PURE__ */ ((Navigators2) => {
       Navigators2["ELO"] = "elo";
       Navigators2["SRS"] = "srs";
+      Navigators2["PRESCRIBED"] = "prescribed";
       Navigators2["HIERARCHY"] = "hierarchyDefinition";
       Navigators2["INTERFERENCE"] = "interferenceMitigator";
       Navigators2["RELATIVE_PRIORITY"] = "relativePriority";
@@ -2809,6 +3289,7 @@ var init_navigators = __esm({
     NavigatorRoles = {
       ["elo" /* ELO */]: "generator" /* GENERATOR */,
       ["srs" /* SRS */]: "generator" /* GENERATOR */,
+      ["prescribed" /* PRESCRIBED */]: "generator" /* GENERATOR */,
       ["hierarchyDefinition" /* HIERARCHY */]: "filter" /* FILTER */,
       ["interferenceMitigator" /* INTERFERENCE */]: "filter" /* FILTER */,
       ["relativePriority" /* RELATIVE_PRIORITY */]: "filter" /* FILTER */,
@@ -2973,6 +3454,12 @@ var init_navigators = __esm({
       async getWeightedCards(_limit) {
         throw new Error(`${this.constructor.name} must implement getWeightedCards(). `);
       }
+      /**
+       * Set ephemeral hints for the next pipeline run.
+       * No-op for non-Pipeline navigators. Pipeline overrides this.
+       */
+      setEphemeralHints(_hints) {
+      }
     };
   }
 });
@@ -3026,6 +3513,16 @@ var init_adminDB2 = __esm({
   }
 });
 
+// src/impl/couch/CourseSyncService.ts
+var init_CourseSyncService = __esm({
+  "src/impl/couch/CourseSyncService.ts"() {
+    "use strict";
+    init_pouchdb_setup();
+    init_couch();
+    init_logger();
+  }
+});
+
 // src/impl/couch/auth.ts
 import fetch2 from "cross-fetch";
 var init_auth = __esm({
@@ -3087,6 +3584,7 @@ var init_couch = __esm({
     init_classroomDB2();
     init_courseAPI();
     init_courseDB();
+    init_CourseSyncService();
     init_CouchDBSyncStrategy();
     isBrowser = typeof window !== "undefined";
     if (isBrowser) {
@@ -3386,6 +3884,9 @@ Currently logged-in as ${this._username}.`
             const id = row.id;
             return id.startsWith(DocTypePrefixes["CARDRECORD" /* CARDRECORD */]) || // Card interaction history
             id.startsWith(DocTypePrefixes["SCHEDULED_CARD" /* SCHEDULED_CARD */]) || // Scheduled reviews
+            id.startsWith(DocTypePrefixes["STRATEGY_STATE" /* STRATEGY_STATE */]) || // Strategy state (user prefs, progression)
+            id.startsWith(DocTypePrefixes["USER_OUTCOME" /* USER_OUTCOME */]) || // Evolutionary orchestration outcomes
+            id.startsWith(DocTypePrefixes["STRATEGY_LEARNING_STATE" /* STRATEGY_LEARNING_STATE */]) || // Strategy learning state
             id === _BaseUser.DOC_IDS.COURSE_REGISTRATIONS || // Course registrations
             id === _BaseUser.DOC_IDS.CLASSROOM_REGISTRATIONS || // Classroom registrations
             id === _BaseUser.DOC_IDS.CONFIG;
@@ -5238,6 +5739,10 @@ var init_courseDB3 = __esm({
         }
         return tagsByCard;
       }
+      async getAllCardIds() {
+        const tagsIndex = await this.unpacker.getTagsIndex();
+        return Object.keys(tagsIndex.byCard);
+      }
       async addTagToCard(_cardId, _tagId) {
         throw new Error("Cannot modify tags in static mode");
       }