@vue-skuilder/db 0.1.32-b → 0.1.32-c

package/dist/core/index.mjs

@@ -727,13 +727,20 @@ function captureRun(report) {
     runHistory.pop();
   }
 }
-function buildRunReport(courseId, courseName, generatorName, generators, generatedCount, filters, allCards, selectedCards) {
+function parseCardElo(provenance) {
+  const eloEntry = provenance.find((p) => p.strategy === "elo");
+  if (!eloEntry?.reason) return void 0;
+  const match = eloEntry.reason.match(/card:\s*(\d+)/);
+  return match ? parseInt(match[1], 10) : void 0;
+}
+function buildRunReport(courseId, courseName, generatorName, generators, generatedCount, filters, allCards, selectedCards, userElo) {
   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,
+    cardElo: parseCardElo(card.provenance),
     provenance: card.provenance,
     tags: card.tags,
     selected: selectedIds.has(card.cardId)
@@ -743,6 +750,7 @@ function buildRunReport(courseId, courseName, generatorName, generators, generat
   return {
     courseId,
     courseName,
+    userElo,
     generatorName,
     generators,
     generatedCount,
@@ -763,6 +771,7 @@ 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(`User ELO: ${run.userElo ?? "unknown"}`);
   logger.info(`Generator: ${run.generatorName} \u2192 ${run.generatedCount} candidates`);
   if (run.generators && run.generators.length > 0) {
     console.group("Generator breakdown:");
@@ -849,8 +858,12 @@ var init_PipelineDebugger = __esm({
             console.group(`\u{1F3B4} Card: ${cardId}`);
             logger.info(`Course: ${card.courseId}`);
             logger.info(`Origin: ${card.origin}`);
+            logger.info(`Card ELO: ${card.cardElo ?? "unknown"} | User ELO: ${run.userElo ?? "unknown"}`);
             logger.info(`Final score: ${card.finalScore.toFixed(3)}`);
             logger.info(`Selected: ${card.selected ? "Yes \u2705" : "No \u274C"}`);
+            if (card.tags && card.tags.length > 0) {
+              logger.info(`Tags (${card.tags.length}): ${card.tags.join(", ")}`);
+            }
             logger.info("Provenance:");
             logger.info(formatProvenance(card.provenance));
             console.groupEnd();
@@ -1014,6 +1027,27 @@ var init_PipelineDebugger = __esm({
         }
         return _activePipeline.diagnoseCardSpace({ threshold });
       },
+      /**
+       * Show user's per-tag ELO data. Useful for diagnosing hierarchy gate status.
+       *
+       * @param tagFilter - Optional glob pattern(s) to filter tags.
+       *   Examples: 'gpc:expose:*', 'gpc:intro:t-T', ['gpc:expose:t-*', 'gpc:intro:t-*']
+       */
+      async showTagElo(tagFilter) {
+        if (!_activePipeline) {
+          logger.info("[Pipeline Debug] No active pipeline. Run a session first.");
+          return;
+        }
+        const status = await _activePipeline.getTagEloStatus(tagFilter);
+        const entries = Object.entries(status).sort(([a], [b]) => a.localeCompare(b));
+        if (entries.length === 0) {
+          logger.info(`[Pipeline Debug] No tag ELO data found${tagFilter ? ` for pattern: ${tagFilter}` : ""}.`);
+          return;
+        }
+        console.table(
+          Object.fromEntries(entries.map(([tag, data]) => [tag, { score: Math.round(data.score), count: data.count }]))
+        );
+      },
       /**
        * Show help.
        */
@@ -1025,6 +1059,7 @@ 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
+  .showTagElo(pattern)   Show user's tag ELO data (async). E.g. 'gpc:expose:*'
   .explainReviews()      Analyze why reviews were/weren't selected
   .diagnoseCardSpace()   Scan full card space through filters (async)
   .showRegistry()        Show navigator registry (classes + roles)
@@ -1338,60 +1373,423 @@ var prescribed_exports = {};
 __export(prescribed_exports, {
   default: () => PrescribedCardsGenerator
 });
-var PrescribedCardsGenerator;
+function dedupe(arr) {
+  return [...new Set(arr)];
+}
+function isoNow() {
+  return (/* @__PURE__ */ new Date()).toISOString();
+}
+function clamp(value, min, max) {
+  return Math.max(min, Math.min(max, value));
+}
+function matchesTagPattern(tag, pattern) {
+  if (pattern === "*") return true;
+  const escaped = pattern.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*");
+  const re = new RegExp(`^${escaped}$`);
+  return re.test(tag);
+}
+function pickTopByScore(cards, limit) {
+  return [...cards].sort((a, b) => b.score - a.score || a.cardId.localeCompare(b.cardId)).slice(0, limit);
+}
+var DEFAULT_FRESHNESS_WINDOW, DEFAULT_MAX_DIRECT_PER_RUN, DEFAULT_MAX_SUPPORT_PER_RUN, DEFAULT_HIERARCHY_DEPTH, DEFAULT_MIN_COUNT, BASE_TARGET_SCORE, BASE_SUPPORT_SCORE, MAX_TARGET_MULTIPLIER, MAX_SUPPORT_MULTIPLIER, LOCKED_TAG_PREFIXES, LESSON_GATE_PENALTY_TAG_HINT, PrescribedCardsGenerator;
 var init_prescribed = __esm({
   "src/core/navigators/generators/prescribed.ts"() {
     "use strict";
     init_navigators();
     init_logger();
+    DEFAULT_FRESHNESS_WINDOW = 3;
+    DEFAULT_MAX_DIRECT_PER_RUN = 3;
+    DEFAULT_MAX_SUPPORT_PER_RUN = 3;
+    DEFAULT_HIERARCHY_DEPTH = 2;
+    DEFAULT_MIN_COUNT = 3;
+    BASE_TARGET_SCORE = 1;
+    BASE_SUPPORT_SCORE = 0.8;
+    MAX_TARGET_MULTIPLIER = 8;
+    MAX_SUPPORT_MULTIPLIER = 4;
+    LOCKED_TAG_PREFIXES = ["concept:"];
+    LESSON_GATE_PENALTY_TAG_HINT = "concept:";
     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: [] };
-        }
+        this.config = this.parseConfig(strategyData.serializedData);
         logger.debug(
-          `[Prescribed] Initialized with ${this.config.cardIds.length} prescribed cards`
+          `[Prescribed] Initialized with ${this.config.groups.length} groups and ${this.config.groups.reduce((n, g) => n + g.targetCardIds.length, 0)} targets`
         );
       }
-      async getWeightedCards(limit, _context) {
-        if (this.config.cardIds.length === 0) {
+      get strategyKey() {
+        return "PrescribedProgress";
+      }
+      async getWeightedCards(limit, context) {
+        if (this.config.groups.length === 0 || limit <= 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");
+        const seenCards = await this.user.getSeenCards(courseId).catch(() => []);
+        const seenIds = new Set(seenCards);
+        const progress = await this.getStrategyState() ?? {
+          updatedAt: isoNow(),
+          groups: {}
+        };
+        const hierarchyConfigs = await this.loadHierarchyConfigs();
+        const courseReg = await this.user.getCourseRegDoc(courseId).catch(() => null);
+        const userGlobalElo = typeof courseReg?.elo === "number" ? courseReg.elo : courseReg?.elo?.global?.score ?? context?.userElo ?? 1e3;
+        const userTagElo = typeof courseReg?.elo === "number" ? {} : courseReg?.elo?.tags ?? {};
+        const allTargetIds = dedupe(this.config.groups.flatMap((g) => g.targetCardIds));
+        const allSupportIds = dedupe(this.config.groups.flatMap((g) => g.supportCardIds ?? []));
+        const allRelevantIds = dedupe([...allTargetIds, ...allSupportIds]);
+        const tagsByCard = allRelevantIds.length > 0 ? await this.course.getAppliedTagsBatch(allRelevantIds) : /* @__PURE__ */ new Map();
+        const nextState = {
+          updatedAt: isoNow(),
+          groups: {}
+        };
+        const emitted = [];
+        const emittedIds = /* @__PURE__ */ new Set();
+        for (const group of this.config.groups) {
+          const runtime = this.buildGroupRuntimeState({
+            group,
+            priorState: progress.groups[group.id],
+            activeIds,
+            seenIds,
+            tagsByCard,
+            hierarchyConfigs,
+            userTagElo,
+            userGlobalElo
+          });
+          nextState.groups[group.id] = this.buildNextGroupState(runtime, progress.groups[group.id]);
+          const directCards = this.buildDirectTargetCards(
+            runtime,
+            courseId,
+            emittedIds
+          );
+          const supportCards = this.buildSupportCards(
+            runtime,
+            courseId,
+            emittedIds
+          );
+          emitted.push(...directCards, ...supportCards);
+        }
+        if (emitted.length === 0) {
+          logger.debug("[Prescribed] No prescribed targets/support emitted this run");
+          await this.putStrategyState(nextState).catch((e) => {
+            logger.debug(`[Prescribed] Failed to persist empty-state update: ${e}`);
+          });
           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)`
+        const finalCards = pickTopByScore(emitted, limit);
+        const surfacedByGroup = /* @__PURE__ */ new Map();
+        for (const card of finalCards) {
+          const prov = card.provenance[0];
+          const groupId = prov?.reason.match(/group=([^;]+)/)?.[1];
+          const mode = prov?.reason.includes("mode=support") ? "supportIds" : "targetIds";
+          if (!groupId) continue;
+          if (!surfacedByGroup.has(groupId)) {
+            surfacedByGroup.set(groupId, { targetIds: [], supportIds: [] });
+          }
+          surfacedByGroup.get(groupId)[mode].push(card.cardId);
+        }
+        for (const group of this.config.groups) {
+          const groupState = nextState.groups[group.id];
+          const surfaced = surfacedByGroup.get(group.id);
+          if (surfaced && (surfaced.targetIds.length > 0 || surfaced.supportIds.length > 0)) {
+            groupState.lastSurfacedAt = isoNow();
+            groupState.sessionsSinceSurfaced = 0;
+            if (surfaced.supportIds.length > 0) {
+              groupState.lastSupportAt = isoNow();
             }
-          ]
-        }));
+          }
+        }
+        await this.putStrategyState(nextState).catch((e) => {
+          logger.debug(`[Prescribed] Failed to persist prescribed progress: ${e}`);
+        });
         logger.info(
-          `[Prescribed] Emitting ${cards.length} cards (${eligibleIds.length} eligible, ${activeIds.size} already active)`
+          `[Prescribed] Emitting ${finalCards.length} cards (${finalCards.filter((c) => c.provenance[0]?.reason.includes("mode=target")).length} target, ${finalCards.filter((c) => c.provenance[0]?.reason.includes("mode=support")).length} support)`
         );
+        return finalCards;
+      }
+      parseConfig(serializedData) {
+        try {
+          const parsed = JSON.parse(serializedData);
+          const groupsRaw = Array.isArray(parsed.groups) ? parsed.groups : [];
+          const groups = groupsRaw.map((raw, i) => ({
+            id: typeof raw.id === "string" && raw.id.trim().length > 0 ? raw.id : `group-${i + 1}`,
+            targetCardIds: dedupe(Array.isArray(raw.targetCardIds) ? raw.targetCardIds.filter((v) => typeof v === "string") : []),
+            supportCardIds: dedupe(Array.isArray(raw.supportCardIds) ? raw.supportCardIds.filter((v) => typeof v === "string") : []),
+            supportTagPatterns: dedupe(Array.isArray(raw.supportTagPatterns) ? raw.supportTagPatterns.filter((v) => typeof v === "string") : []),
+            freshnessWindowSessions: typeof raw.freshnessWindowSessions === "number" ? raw.freshnessWindowSessions : DEFAULT_FRESHNESS_WINDOW,
+            maxDirectTargetsPerRun: typeof raw.maxDirectTargetsPerRun === "number" ? raw.maxDirectTargetsPerRun : DEFAULT_MAX_DIRECT_PER_RUN,
+            maxSupportCardsPerRun: typeof raw.maxSupportCardsPerRun === "number" ? raw.maxSupportCardsPerRun : DEFAULT_MAX_SUPPORT_PER_RUN,
+            hierarchyWalk: {
+              enabled: raw.hierarchyWalk?.enabled !== false,
+              maxDepth: typeof raw.hierarchyWalk?.maxDepth === "number" ? raw.hierarchyWalk.maxDepth : DEFAULT_HIERARCHY_DEPTH
+            },
+            retireOnEncounter: raw.retireOnEncounter !== false
+          })).filter((g) => g.targetCardIds.length > 0);
+          return { groups };
+        } catch {
+          return { groups: [] };
+        }
+      }
+      async loadHierarchyConfigs() {
+        try {
+          const strategies = await this.course.getNavigationStrategies();
+          return strategies.filter((s) => s.implementingClass === "hierarchyDefinition").map((s) => {
+            try {
+              const parsed = JSON.parse(s.serializedData);
+              return {
+                prerequisites: parsed.prerequisites || {}
+              };
+            } catch {
+              return { prerequisites: {} };
+            }
+          });
+        } catch (e) {
+          logger.debug(`[Prescribed] Failed to load hierarchy configs: ${e}`);
+          return [];
+        }
+      }
+      buildGroupRuntimeState(args) {
+        const {
+          group,
+          priorState,
+          activeIds,
+          seenIds,
+          tagsByCard,
+          hierarchyConfigs,
+          userTagElo,
+          userGlobalElo
+        } = args;
+        const encounteredTargets = /* @__PURE__ */ new Set();
+        for (const cardId of group.targetCardIds) {
+          if (activeIds.has(cardId) || seenIds.has(cardId)) {
+            encounteredTargets.add(cardId);
+          }
+        }
+        if (priorState?.encounteredCardIds?.length) {
+          for (const cardId of priorState.encounteredCardIds) {
+            encounteredTargets.add(cardId);
+          }
+        }
+        const pendingTargets = group.targetCardIds.filter((id) => !encounteredTargets.has(id));
+        const targetTags = /* @__PURE__ */ new Map();
+        for (const cardId of pendingTargets) {
+          targetTags.set(cardId, tagsByCard.get(cardId) ?? []);
+        }
+        const blockedTargets = [];
+        const surfaceableTargets = [];
+        const supportTags = /* @__PURE__ */ new Set();
+        for (const cardId of pendingTargets) {
+          const tags = targetTags.get(cardId) ?? [];
+          const resolution = this.resolveBlockedSupportTags(
+            tags,
+            hierarchyConfigs,
+            userTagElo,
+            userGlobalElo,
+            group.hierarchyWalk?.enabled !== false,
+            group.hierarchyWalk?.maxDepth ?? DEFAULT_HIERARCHY_DEPTH
+          );
+          if (resolution.blocked) {
+            blockedTargets.push(cardId);
+            resolution.supportTags.forEach((t) => supportTags.add(t));
+          } else {
+            surfaceableTargets.push(cardId);
+          }
+        }
+        const supportCandidates = dedupe([
+          ...group.supportCardIds ?? [],
+          ...this.findSupportCardsByTags(
+            group,
+            tagsByCard,
+            [...supportTags]
+          )
+        ]).filter((id) => !activeIds.has(id) && !seenIds.has(id));
+        const sessionsSinceSurfaced = priorState?.sessionsSinceSurfaced ?? 0;
+        const freshnessWindow = group.freshnessWindowSessions ?? DEFAULT_FRESHNESS_WINDOW;
+        const staleSessions = Math.max(0, sessionsSinceSurfaced - freshnessWindow);
+        const pressureMultiplier = pendingTargets.length === 0 ? 1 : clamp(1 + staleSessions * 0.75 + Math.min(2, pendingTargets.length * 0.1), 1, MAX_TARGET_MULTIPLIER);
+        const supportMultiplier = blockedTargets.length === 0 ? 1 : clamp(1 + staleSessions * 0.5 + Math.min(1.5, blockedTargets.length * 0.15), 1, MAX_SUPPORT_MULTIPLIER);
+        return {
+          group,
+          encounteredTargets,
+          pendingTargets,
+          blockedTargets,
+          surfaceableTargets,
+          targetTags,
+          supportCandidates,
+          supportTags: [...supportTags],
+          pressureMultiplier,
+          supportMultiplier
+        };
+      }
+      buildNextGroupState(runtime, prior) {
+        const carriedSessions = prior?.sessionsSinceSurfaced ?? 0;
+        const surfacedThisRun = false;
+        return {
+          encounteredCardIds: [...runtime.encounteredTargets].sort(),
+          lastSurfacedAt: prior?.lastSurfacedAt ?? null,
+          sessionsSinceSurfaced: surfacedThisRun ? 0 : carriedSessions + 1,
+          lastSupportAt: prior?.lastSupportAt ?? null,
+          blockedTargetIds: [...runtime.blockedTargets].sort(),
+          lastResolvedSupportTags: [...runtime.supportTags].sort()
+        };
+      }
+      buildDirectTargetCards(runtime, courseId, emittedIds) {
+        const maxDirect = runtime.group.maxDirectTargetsPerRun ?? DEFAULT_MAX_DIRECT_PER_RUN;
+        const directIds = runtime.surfaceableTargets.filter((id) => !emittedIds.has(id)).slice(0, maxDirect);
+        const cards = [];
+        for (const cardId of directIds) {
+          emittedIds.add(cardId);
+          cards.push({
+            cardId,
+            courseId,
+            score: BASE_TARGET_SCORE * runtime.pressureMultiplier,
+            provenance: [
+              {
+                strategy: "prescribed",
+                strategyName: this.strategyName || this.name,
+                strategyId: this.strategyId || "NAVIGATION_STRATEGY-prescribed",
+                action: "generated",
+                score: BASE_TARGET_SCORE * runtime.pressureMultiplier,
+                reason: `mode=target;group=${runtime.group.id};pending=${runtime.pendingTargets.length};surfaceable=${runtime.surfaceableTargets.length};blocked=${runtime.blockedTargets.length};multiplier=${runtime.pressureMultiplier.toFixed(2)}`
+              }
+            ]
+          });
+        }
+        return cards;
+      }
+      buildSupportCards(runtime, courseId, emittedIds) {
+        if (runtime.blockedTargets.length === 0 || runtime.supportCandidates.length === 0) {
+          return [];
+        }
+        const maxSupport = runtime.group.maxSupportCardsPerRun ?? DEFAULT_MAX_SUPPORT_PER_RUN;
+        const supportIds = runtime.supportCandidates.filter((id) => !emittedIds.has(id)).slice(0, maxSupport);
+        const cards = [];
+        for (const cardId of supportIds) {
+          emittedIds.add(cardId);
+          cards.push({
+            cardId,
+            courseId,
+            score: BASE_SUPPORT_SCORE * runtime.supportMultiplier,
+            provenance: [
+              {
+                strategy: "prescribed",
+                strategyName: this.strategyName || this.name,
+                strategyId: this.strategyId || "NAVIGATION_STRATEGY-prescribed",
+                action: "generated",
+                score: BASE_SUPPORT_SCORE * runtime.supportMultiplier,
+                reason: `mode=support;group=${runtime.group.id};blocked=${runtime.blockedTargets.length};supportTags=${runtime.supportTags.join("|") || "none"};multiplier=${runtime.supportMultiplier.toFixed(2)}`
+              }
+            ]
+          });
+        }
         return cards;
       }
+      findSupportCardsByTags(group, tagsByCard, supportTags) {
+        if (supportTags.length === 0) {
+          return [];
+        }
+        const explicitSupportIds = group.supportCardIds ?? [];
+        const explicitPatterns = group.supportTagPatterns ?? [];
+        if (explicitSupportIds.length === 0 && explicitPatterns.length === 0) {
+          return [];
+        }
+        const candidates = /* @__PURE__ */ new Set();
+        for (const cardId of explicitSupportIds) {
+          const cardTags = tagsByCard.get(cardId) ?? [];
+          const matchesResolved = supportTags.some((supportTag) => cardTags.includes(supportTag));
+          const matchesPattern = explicitPatterns.some(
+            (pattern) => cardTags.some((tag) => matchesTagPattern(tag, pattern))
+          );
+          if (matchesResolved || matchesPattern) {
+            candidates.add(cardId);
+          }
+        }
+        return [...candidates];
+      }
+      resolveBlockedSupportTags(targetTags, hierarchyConfigs, userTagElo, userGlobalElo, hierarchyWalkEnabled, maxDepth) {
+        if (!hierarchyWalkEnabled || targetTags.length === 0 || hierarchyConfigs.length === 0) {
+          return {
+            blocked: false,
+            supportTags: []
+          };
+        }
+        const supportTags = /* @__PURE__ */ new Set();
+        let blocked = false;
+        for (const targetTag of targetTags) {
+          for (const hierarchy of hierarchyConfigs) {
+            const prereqs = hierarchy.prerequisites[targetTag];
+            if (!prereqs || prereqs.length === 0) continue;
+            const unmet = prereqs.filter(
+              (pr) => !this.isPrerequisiteMet(pr, userTagElo[pr.tag], userGlobalElo)
+            );
+            if (unmet.length === 0) {
+              continue;
+            }
+            blocked = true;
+            for (const prereq of unmet) {
+              this.collectSupportTagsRecursive(
+                prereq.tag,
+                hierarchyConfigs,
+                userTagElo,
+                userGlobalElo,
+                maxDepth,
+                /* @__PURE__ */ new Set(),
+                supportTags
+              );
+            }
+          }
+        }
+        return { blocked, supportTags: [...supportTags] };
+      }
+      collectSupportTagsRecursive(tag, hierarchyConfigs, userTagElo, userGlobalElo, depth, visited, out) {
+        if (depth < 0 || visited.has(tag)) return;
+        if (this.isHardGatedTag(tag)) return;
+        visited.add(tag);
+        let walkedFurther = false;
+        for (const hierarchy of hierarchyConfigs) {
+          const prereqs = hierarchy.prerequisites[tag];
+          if (!prereqs || prereqs.length === 0) continue;
+          const unmet = prereqs.filter(
+            (pr) => !this.isPrerequisiteMet(pr, userTagElo[pr.tag], userGlobalElo)
+          );
+          if (unmet.length > 0 && depth > 0) {
+            walkedFurther = true;
+            for (const prereq of unmet) {
+              this.collectSupportTagsRecursive(
+                prereq.tag,
+                hierarchyConfigs,
+                userTagElo,
+                userGlobalElo,
+                depth - 1,
+                visited,
+                out
+              );
+            }
+          }
+        }
+        if (!walkedFurther) {
+          out.add(tag);
+        }
+      }
+      isHardGatedTag(tag) {
+        return LOCKED_TAG_PREFIXES.some((prefix) => tag.startsWith(prefix)) && tag.startsWith(LESSON_GATE_PENALTY_TAG_HINT);
+      }
+      isPrerequisiteMet(prereq, userTagElo, userGlobalElo) {
+        if (!userTagElo) return false;
+        const minCount = prereq.masteryThreshold?.minCount ?? DEFAULT_MIN_COUNT;
+        if (userTagElo.count < minCount) return false;
+        if (prereq.masteryThreshold?.minElo !== void 0) {
+          return userTagElo.score >= prereq.masteryThreshold.minElo;
+        }
+        if (prereq.masteryThreshold?.minCount !== void 0) {
+          return true;
+        }
+        return userTagElo.score >= userGlobalElo;
+      }
     };
   }
 });
@@ -1755,13 +2153,13 @@ __export(hierarchyDefinition_exports, {
   default: () => HierarchyDefinitionNavigator
 });
 import { toCourseElo as toCourseElo3 } from "@vue-skuilder/common";
-var DEFAULT_MIN_COUNT, HierarchyDefinitionNavigator;
+var DEFAULT_MIN_COUNT2, HierarchyDefinitionNavigator;
 var init_hierarchyDefinition = __esm({
   "src/core/navigators/filters/hierarchyDefinition.ts"() {
     "use strict";
     init_navigators();
     init_logger();
-    DEFAULT_MIN_COUNT = 3;
+    DEFAULT_MIN_COUNT2 = 3;
     HierarchyDefinitionNavigator = class extends ContentNavigator {
       config;
       /** Human-readable name for CardFilter interface */
@@ -1788,7 +2186,7 @@ var init_hierarchyDefinition = __esm({
        */
       isPrerequisiteMet(prereq, userTagElo, userGlobalElo) {
         if (!userTagElo) return false;
-        const minCount = prereq.masteryThreshold?.minCount ?? DEFAULT_MIN_COUNT;
+        const minCount = prereq.masteryThreshold?.minCount ?? DEFAULT_MIN_COUNT2;
         if (userTagElo.count < minCount) return false;
         if (prereq.masteryThreshold?.minElo !== void 0) {
           return userTagElo.score >= prereq.masteryThreshold.minElo;
@@ -1889,18 +2287,55 @@ var init_hierarchyDefinition = __esm({
         }
         return boosts;
       }
+      /**
+       * Build a map of gated tag → max configured targetBoost for all *open* gates.
+       *
+       * When a gate opens (prereqs met), cards carrying the gated tag get boosted —
+       * ensuring newly-unlocked content surfaces promptly. The boost is a static
+       * multiplier; natural ELO/SRS deprioritization after interaction handles decay.
+       */
+      getTargetBoosts(unlockedTags) {
+        const boosts = /* @__PURE__ */ new Map();
+        const configKeys = Object.keys(this.config.prerequisites);
+        const unlockedArr = [...unlockedTags];
+        logger.info(
+          `[HierarchyDefinition:targetBoost:trace] ${this.name} | configKeys=${configKeys.length}, unlocked=${unlockedArr.length} (${unlockedArr.slice(0, 5).join(", ")}${unlockedArr.length > 5 ? "..." : ""})`
+        );
+        for (const [tagId, prereqs] of Object.entries(this.config.prerequisites)) {
+          if (!unlockedTags.has(tagId)) continue;
+          logger.info(
+            `[HierarchyDefinition:targetBoost:trace] UNLOCKED ${tagId}: ${prereqs.length} prereqs, raw=${JSON.stringify(prereqs.map((p) => ({ tag: p.tag, tb: p.targetBoost })))}`
+          );
+          for (const prereq of prereqs) {
+            if (!prereq.targetBoost || prereq.targetBoost <= 1) continue;
+            const existing = boosts.get(tagId) ?? 1;
+            boosts.set(tagId, Math.max(existing, prereq.targetBoost));
+          }
+        }
+        if (boosts.size > 0) {
+          logger.info(
+            `[HierarchyDefinition] targetBoosts active: ${[...boosts.entries()].map(([t, b]) => `${t}=\xD7${b}`).join(", ")}`
+          );
+        } else {
+          logger.info(
+            `[HierarchyDefinition:targetBoost:trace] no targetBoosts found despite ${unlockedArr.length} unlocked tags`
+          );
+        }
+        return boosts;
+      }
       /**
        * CardFilter.transform implementation.
        *
-       * 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
+       * Three effects:
+       * 1. Cards with locked tags receive score * 0.02 (gating penalty)
+       * 2. Cards carrying prereq tags of closed gates receive preReqBoost
+       * 3. Cards carrying gated tags of open gates receive targetBoost
        */
       async transform(cards, context) {
         const masteredTags = await this.getMasteredTags(context);
         const unlockedTags = this.getUnlockedTags(masteredTags);
         const preReqBoosts = this.getPreReqBoosts(unlockedTags, masteredTags);
+        const targetBoosts = this.getTargetBoosts(unlockedTags);
         const gated = [];
         for (const card of cards) {
           const { isUnlocked, reason } = await this.checkCardUnlock(
@@ -1933,6 +2368,26 @@ var init_hierarchyDefinition = __esm({
               );
             }
           }
+          if (isUnlocked && targetBoosts.size > 0) {
+            const cardTags = card.tags ?? [];
+            let maxTargetBoost = 1;
+            const boostedTargets = [];
+            for (const tag of cardTags) {
+              const boost = targetBoosts.get(tag);
+              if (boost && boost > maxTargetBoost) {
+                maxTargetBoost = boost;
+                boostedTargets.push(tag);
+              }
+            }
+            if (maxTargetBoost > 1) {
+              finalScore *= maxTargetBoost;
+              action = "boosted";
+              finalReason = `${finalReason} | targetBoost \xD7${maxTargetBoost.toFixed(2)} for ${boostedTargets.join(", ")}`;
+              logger.info(
+                `[HierarchyDefinition] targetBoost \xD7${maxTargetBoost.toFixed(2)} applied to card ${card.cardId} via tags [${boostedTargets.join(", ")}] (score: ${card.score.toFixed(3)} \u2192 ${finalScore.toFixed(3)})`
+              );
+            }
+          }
           gated.push({
             ...card,
             score: finalScore,
@@ -2118,12 +2573,12 @@ __export(interferenceMitigator_exports, {
   default: () => InterferenceMitigatorNavigator
 });
 import { toCourseElo as toCourseElo4 } from "@vue-skuilder/common";
-var DEFAULT_MIN_COUNT2, DEFAULT_MIN_ELAPSED_DAYS, DEFAULT_INTERFERENCE_DECAY, InterferenceMitigatorNavigator;
+var DEFAULT_MIN_COUNT3, DEFAULT_MIN_ELAPSED_DAYS, DEFAULT_INTERFERENCE_DECAY, InterferenceMitigatorNavigator;
 var init_interferenceMitigator = __esm({
   "src/core/navigators/filters/interferenceMitigator.ts"() {
     "use strict";
     init_navigators();
-    DEFAULT_MIN_COUNT2 = 10;
+    DEFAULT_MIN_COUNT3 = 10;
     DEFAULT_MIN_ELAPSED_DAYS = 3;
     DEFAULT_INTERFERENCE_DECAY = 0.8;
     InterferenceMitigatorNavigator = class extends ContentNavigator {
@@ -2148,7 +2603,7 @@ var init_interferenceMitigator = __esm({
           return {
             interferenceSets: sets,
             maturityThreshold: {
-              minCount: parsed.maturityThreshold?.minCount ?? DEFAULT_MIN_COUNT2,
+              minCount: parsed.maturityThreshold?.minCount ?? DEFAULT_MIN_COUNT3,
               minElo: parsed.maturityThreshold?.minElo,
               minElapsedDays: parsed.maturityThreshold?.minElapsedDays ?? DEFAULT_MIN_ELAPSED_DAYS
             },
@@ -2158,7 +2613,7 @@ var init_interferenceMitigator = __esm({
           return {
             interferenceSets: [],
             maturityThreshold: {
-              minCount: DEFAULT_MIN_COUNT2,
+              minCount: DEFAULT_MIN_COUNT3,
               minElapsedDays: DEFAULT_MIN_ELAPSED_DAYS
             },
             defaultDecay: DEFAULT_INTERFERENCE_DECAY
@@ -2205,7 +2660,7 @@ var init_interferenceMitigator = __esm({
         try {
           const courseReg = await context.user.getCourseRegDoc(context.course.getCourseID());
           const userElo = toCourseElo4(courseReg.elo);
-          const minCount = this.config.maturityThreshold?.minCount ?? DEFAULT_MIN_COUNT2;
+          const minCount = this.config.maturityThreshold?.minCount ?? DEFAULT_MIN_COUNT3;
           const minElo = this.config.maturityThreshold?.minElo;
           const minElapsedDays = this.config.maturityThreshold?.minElapsedDays ?? DEFAULT_MIN_ELAPSED_DAYS;
           const minCountForElapsed = minElapsedDays * 2;
@@ -2716,160 +3171,1718 @@ var init_learning = __esm({
   }
 });
 
-// src/core/orchestration/signal.ts
-function computeOutcomeSignal(records, config = {}) {
-  if (!records || records.length === 0) {
-    return null;
+// src/core/orchestration/signal.ts
+function computeOutcomeSignal(records, config = {}) {
+  if (!records || records.length === 0) {
+    return null;
+  }
+  const target = config.targetAccuracy ?? 0.85;
+  const tolerance = config.tolerance ?? 0.05;
+  let correct = 0;
+  for (const r of records) {
+    if (r.isCorrect) correct++;
+  }
+  const accuracy = correct / records.length;
+  return scoreAccuracyInZone(accuracy, target, tolerance);
+}
+function scoreAccuracyInZone(accuracy, target, tolerance) {
+  const dist = Math.abs(accuracy - target);
+  if (dist <= tolerance) {
+    return 1;
+  }
+  const excess = dist - tolerance;
+  const slope = 2.5;
+  return Math.max(0, 1 - excess * slope);
+}
+var init_signal = __esm({
+  "src/core/orchestration/signal.ts"() {
+    "use strict";
+  }
+});
+
+// src/core/orchestration/recording.ts
+async function recordUserOutcome(context, periodStart, periodEnd, records, activeStrategyIds, eloStart = 0, eloEnd = 0, config) {
+  const { user, course, userId } = context;
+  const courseId = course.getCourseID();
+  const outcomeValue = computeOutcomeSignal(records, config);
+  if (outcomeValue === null) {
+    logger.debug(
+      `[Orchestration] No outcome signal computed for ${userId} (insufficient data). Skipping record.`
+    );
+    return;
+  }
+  const deviations = {};
+  for (const strategyId of activeStrategyIds) {
+    deviations[strategyId] = context.getDeviation(strategyId);
+  }
+  const id = `USER_OUTCOME::${courseId}::${userId}::${periodEnd}`;
+  const record = {
+    _id: id,
+    docType: "USER_OUTCOME" /* USER_OUTCOME */,
+    courseId,
+    userId,
+    periodStart,
+    periodEnd,
+    outcomeValue,
+    deviations,
+    metadata: {
+      sessionsCount: 1,
+      // Assumes recording is triggered per-session currently
+      cardsSeen: records.length,
+      eloStart,
+      eloEnd,
+      signalType: "accuracy_in_zone"
+    }
+  };
+  try {
+    await user.putUserOutcome(record);
+    logger.debug(
+      `[Orchestration] Recorded outcome ${outcomeValue.toFixed(3)} for ${userId} (doc: ${id})`
+    );
+  } catch (e) {
+    logger.error(`[Orchestration] Failed to record outcome: ${e}`);
+  }
+}
+var init_recording = __esm({
+  "src/core/orchestration/recording.ts"() {
+    "use strict";
+    init_signal();
+    init_types_legacy();
+    init_logger();
+  }
+});
+
+// src/core/orchestration/index.ts
+function fnv1a(str) {
+  let hash = 2166136261;
+  for (let i = 0; i < str.length; i++) {
+    hash ^= str.charCodeAt(i);
+    hash = Math.imul(hash, 16777619);
+  }
+  return hash >>> 0;
+}
+function computeDeviation(userId, strategyId, salt) {
+  const input = `${userId}:${strategyId}:${salt}`;
+  const hash = fnv1a(input);
+  const normalized = hash / 4294967296;
+  return normalized * 2 - 1;
+}
+function computeSpread(confidence) {
+  const clampedConfidence = Math.max(0, Math.min(1, confidence));
+  return MAX_SPREAD - clampedConfidence * (MAX_SPREAD - MIN_SPREAD);
+}
+function computeEffectiveWeight(learnable, userId, strategyId, salt) {
+  const deviation = computeDeviation(userId, strategyId, salt);
+  const spread = computeSpread(learnable.confidence);
+  const adjustment = deviation * spread * learnable.weight;
+  const effective = learnable.weight + adjustment;
+  return Math.max(MIN_WEIGHT, Math.min(MAX_WEIGHT, effective));
+}
+async function createOrchestrationContext(user, course) {
+  let courseConfig;
+  try {
+    courseConfig = await course.getCourseConfig();
+  } catch (e) {
+    logger.error(`[Orchestration] Failed to load course config: ${e}`);
+    courseConfig = {
+      name: "Unknown",
+      description: "",
+      public: false,
+      deleted: false,
+      creator: "",
+      admins: [],
+      moderators: [],
+      dataShapes: [],
+      questionTypes: [],
+      orchestration: { salt: "default" }
+    };
+  }
+  const userId = user.getUsername();
+  const salt = courseConfig.orchestration?.salt || "default_salt";
+  return {
+    user,
+    course,
+    userId,
+    courseConfig,
+    getEffectiveWeight(strategyId, learnable) {
+      return computeEffectiveWeight(learnable, userId, strategyId, salt);
+    },
+    getDeviation(strategyId) {
+      return computeDeviation(userId, strategyId, salt);
+    }
+  };
+}
+var MIN_SPREAD, MAX_SPREAD, MIN_WEIGHT, MAX_WEIGHT;
+var init_orchestration = __esm({
+  "src/core/orchestration/index.ts"() {
+    "use strict";
+    init_logger();
+    init_gradient();
+    init_learning();
+    init_signal();
+    init_recording();
+    MIN_SPREAD = 0.1;
+    MAX_SPREAD = 0.5;
+    MIN_WEIGHT = 0.1;
+    MAX_WEIGHT = 3;
+  }
+});
+
+// src/study/SpacedRepetition.ts
+import moment4 from "moment";
+import { isTaggedPerformance } from "@vue-skuilder/common";
+var duration;
+var init_SpacedRepetition = __esm({
+  "src/study/SpacedRepetition.ts"() {
+    "use strict";
+    init_util();
+    init_logger();
+    duration = moment4.duration;
+  }
+});
+
+// src/study/services/SrsService.ts
+import moment5 from "moment";
+var init_SrsService = __esm({
+  "src/study/services/SrsService.ts"() {
+    "use strict";
+    init_couch();
+    init_SpacedRepetition();
+    init_logger();
+  }
+});
+
+// src/study/services/EloService.ts
+import {
+  adjustCourseScores,
+  adjustCourseScoresPerTag,
+  toCourseElo as toCourseElo5
+} from "@vue-skuilder/common";
+var init_EloService = __esm({
+  "src/study/services/EloService.ts"() {
+    "use strict";
+    init_logger();
+  }
+});
+
+// src/study/services/ResponseProcessor.ts
+import { isTaggedPerformance as isTaggedPerformance2 } from "@vue-skuilder/common";
+var init_ResponseProcessor = __esm({
+  "src/study/services/ResponseProcessor.ts"() {
+    "use strict";
+    init_core();
+    init_logger();
+  }
+});
+
+// src/study/services/CardHydrationService.ts
+import {
+  displayableDataToViewData,
+  isCourseElo,
+  toCourseElo as toCourseElo6
+} from "@vue-skuilder/common";
+var init_CardHydrationService = __esm({
+  "src/study/services/CardHydrationService.ts"() {
+    "use strict";
+    init_logger();
+  }
+});
+
+// src/study/ItemQueue.ts
+var init_ItemQueue = __esm({
+  "src/study/ItemQueue.ts"() {
+    "use strict";
+  }
+});
+
+// src/util/packer/types.ts
+var init_types3 = __esm({
+  "src/util/packer/types.ts"() {
+    "use strict";
+  }
+});
+
+// src/util/packer/CouchDBToStaticPacker.ts
+var init_CouchDBToStaticPacker = __esm({
+  "src/util/packer/CouchDBToStaticPacker.ts"() {
+    "use strict";
+    init_types_legacy();
+    init_logger();
+  }
+});
+
+// src/util/packer/index.ts
+var init_packer = __esm({
+  "src/util/packer/index.ts"() {
+    "use strict";
+    init_types3();
+    init_CouchDBToStaticPacker();
+  }
+});
+
+// src/util/migrator/types.ts
+var DEFAULT_MIGRATION_OPTIONS;
+var init_types4 = __esm({
+  "src/util/migrator/types.ts"() {
+    "use strict";
+    DEFAULT_MIGRATION_OPTIONS = {
+      chunkBatchSize: 100,
+      validateRoundTrip: false,
+      cleanupOnFailure: true,
+      timeout: 3e5
+      // 5 minutes
+    };
+  }
+});
+
+// src/util/migrator/FileSystemAdapter.ts
+var FileSystemError;
+var init_FileSystemAdapter = __esm({
+  "src/util/migrator/FileSystemAdapter.ts"() {
+    "use strict";
+    FileSystemError = class extends Error {
+      constructor(message, operation, filePath, cause) {
+        super(message);
+        this.operation = operation;
+        this.filePath = filePath;
+        this.cause = cause;
+        this.name = "FileSystemError";
+      }
+    };
+  }
+});
+
+// src/util/migrator/validation.ts
+async function validateStaticCourse(staticPath, fs) {
+  const validation = {
+    valid: true,
+    manifestExists: false,
+    chunksExist: false,
+    attachmentsExist: false,
+    errors: [],
+    warnings: []
+  };
+  try {
+    if (fs) {
+      const stats = await fs.stat(staticPath);
+      if (!stats.isDirectory()) {
+        validation.errors.push(`Path is not a directory: ${staticPath}`);
+        validation.valid = false;
+        return validation;
+      }
+    } else if (!nodeFS) {
+      validation.errors.push("File system access not available - validation skipped");
+      validation.valid = false;
+      return validation;
+    } else {
+      const stats = await nodeFS.promises.stat(staticPath);
+      if (!stats.isDirectory()) {
+        validation.errors.push(`Path is not a directory: ${staticPath}`);
+        validation.valid = false;
+        return validation;
+      }
+    }
+    let manifestPath = `${staticPath}/manifest.json`;
+    try {
+      if (fs) {
+        manifestPath = fs.joinPath(staticPath, "manifest.json");
+        if (await fs.exists(manifestPath)) {
+          validation.manifestExists = true;
+          const manifestContent = await fs.readFile(manifestPath);
+          const manifest = JSON.parse(manifestContent);
+          validation.courseId = manifest.courseId;
+          validation.courseName = manifest.courseName;
+          if (!manifest.version || !manifest.courseId || !manifest.chunks || !Array.isArray(manifest.chunks)) {
+            validation.errors.push("Invalid manifest structure");
+            validation.valid = false;
+          }
+        } else {
+          validation.errors.push(`Manifest not found: ${manifestPath}`);
+          validation.valid = false;
+        }
+      } else {
+        manifestPath = `${staticPath}/manifest.json`;
+        await nodeFS.promises.access(manifestPath);
+        validation.manifestExists = true;
+        const manifestContent = await nodeFS.promises.readFile(manifestPath, "utf8");
+        const manifest = JSON.parse(manifestContent);
+        validation.courseId = manifest.courseId;
+        validation.courseName = manifest.courseName;
+        if (!manifest.version || !manifest.courseId || !manifest.chunks || !Array.isArray(manifest.chunks)) {
+          validation.errors.push("Invalid manifest structure");
+          validation.valid = false;
+        }
+      }
+    } catch (error) {
+      const errorMessage = error instanceof FileSystemError ? error.message : `Manifest not found or invalid: ${manifestPath}`;
+      validation.errors.push(errorMessage);
+      validation.valid = false;
+    }
+    let chunksPath = `${staticPath}/chunks`;
+    try {
+      if (fs) {
+        chunksPath = fs.joinPath(staticPath, "chunks");
+        if (await fs.exists(chunksPath)) {
+          const chunksStats = await fs.stat(chunksPath);
+          if (chunksStats.isDirectory()) {
+            validation.chunksExist = true;
+          } else {
+            validation.errors.push(`Chunks path is not a directory: ${chunksPath}`);
+            validation.valid = false;
+          }
+        } else {
+          validation.errors.push(`Chunks directory not found: ${chunksPath}`);
+          validation.valid = false;
+        }
+      } else {
+        chunksPath = `${staticPath}/chunks`;
+        const chunksStats = await nodeFS.promises.stat(chunksPath);
+        if (chunksStats.isDirectory()) {
+          validation.chunksExist = true;
+        } else {
+          validation.errors.push(`Chunks path is not a directory: ${chunksPath}`);
+          validation.valid = false;
+        }
+      }
+    } catch (error) {
+      const errorMessage = error instanceof FileSystemError ? error.message : `Chunks directory not found: ${chunksPath}`;
+      validation.errors.push(errorMessage);
+      validation.valid = false;
+    }
+    let attachmentsPath;
+    try {
+      if (fs) {
+        attachmentsPath = fs.joinPath(staticPath, "attachments");
+        if (await fs.exists(attachmentsPath)) {
+          const attachmentsStats = await fs.stat(attachmentsPath);
+          if (attachmentsStats.isDirectory()) {
+            validation.attachmentsExist = true;
+          }
+        } else {
+          validation.warnings.push(
+            `Attachments directory not found: ${attachmentsPath} (this is OK if course has no attachments)`
+          );
+        }
+      } else {
+        attachmentsPath = `${staticPath}/attachments`;
+        const attachmentsStats = await nodeFS.promises.stat(attachmentsPath);
+        if (attachmentsStats.isDirectory()) {
+          validation.attachmentsExist = true;
+        }
+      }
+    } catch (error) {
+      attachmentsPath = attachmentsPath || `${staticPath}/attachments`;
+      const warningMessage = error instanceof FileSystemError ? error.message : `Attachments directory not found: ${attachmentsPath} (this is OK if course has no attachments)`;
+      validation.warnings.push(warningMessage);
+    }
+  } catch (error) {
+    validation.errors.push(
+      `Failed to validate static course: ${error instanceof Error ? error.message : String(error)}`
+    );
+    validation.valid = false;
+  }
+  return validation;
+}
+async function validateMigration(targetDB, expectedCounts, manifest) {
+  const validation = {
+    valid: true,
+    documentCountMatch: false,
+    attachmentIntegrity: false,
+    viewFunctionality: false,
+    issues: []
+  };
+  try {
+    logger.info("Starting migration validation...");
+    const actualCounts = await getActualDocumentCounts(targetDB);
+    validation.documentCountMatch = compareDocumentCounts(
+      expectedCounts,
+      actualCounts,
+      validation.issues
+    );
+    await validateCourseConfig(targetDB, manifest, validation.issues);
+    validation.viewFunctionality = await validateViews(targetDB, manifest, validation.issues);
+    validation.attachmentIntegrity = await validateAttachmentIntegrity(targetDB, validation.issues);
+    validation.valid = validation.documentCountMatch && validation.viewFunctionality && validation.attachmentIntegrity;
+    logger.info(`Migration validation completed. Valid: ${validation.valid}`);
+    if (validation.issues.length > 0) {
+      logger.info(`Validation issues: ${validation.issues.length}`);
+      validation.issues.forEach((issue) => {
+        if (issue.type === "error") {
+          logger.error(`${issue.category}: ${issue.message}`);
+        } else {
+          logger.warn(`${issue.category}: ${issue.message}`);
+        }
+      });
+    }
+  } catch (error) {
+    validation.valid = false;
+    validation.issues.push({
+      type: "error",
+      category: "metadata",
+      message: `Validation failed: ${error instanceof Error ? error.message : String(error)}`
+    });
+  }
+  return validation;
+}
+async function getActualDocumentCounts(db) {
+  const counts = {};
+  try {
+    const allDocs = await db.allDocs({ include_docs: true });
+    for (const row of allDocs.rows) {
+      if (row.id.startsWith("_design/")) {
+        counts["_design"] = (counts["_design"] || 0) + 1;
+        continue;
+      }
+      const doc = row.doc;
+      if (doc && doc.docType) {
+        counts[doc.docType] = (counts[doc.docType] || 0) + 1;
+      } else {
+        counts["unknown"] = (counts["unknown"] || 0) + 1;
+      }
+    }
+  } catch (error) {
+    logger.error("Failed to get actual document counts:", error);
+  }
+  return counts;
+}
+function compareDocumentCounts(expected, actual, issues) {
+  let countsMatch = true;
+  for (const [docType, expectedCount] of Object.entries(expected)) {
+    const actualCount = actual[docType] || 0;
+    if (actualCount !== expectedCount) {
+      countsMatch = false;
+      issues.push({
+        type: "error",
+        category: "documents",
+        message: `Document count mismatch for ${docType}: expected ${expectedCount}, got ${actualCount}`
+      });
+    }
+  }
+  for (const [docType, actualCount] of Object.entries(actual)) {
+    if (!expected[docType] && docType !== "_design") {
+      issues.push({
+        type: "warning",
+        category: "documents",
+        message: `Unexpected document type found: ${docType} (${actualCount} documents)`
+      });
+    }
+  }
+  return countsMatch;
+}
+async function validateCourseConfig(db, manifest, issues) {
+  try {
+    const courseConfig = await db.get("CourseConfig");
+    if (!courseConfig) {
+      issues.push({
+        type: "error",
+        category: "course_config",
+        message: "CourseConfig document not found after migration"
+      });
+      return;
+    }
+    if (!courseConfig.courseID) {
+      issues.push({
+        type: "warning",
+        category: "course_config",
+        message: "CourseConfig document missing courseID field"
+      });
+    }
+    if (courseConfig.courseID !== manifest.courseId) {
+      issues.push({
+        type: "warning",
+        category: "course_config",
+        message: `CourseConfig courseID mismatch: expected ${manifest.courseId}, got ${courseConfig.courseID}`
+      });
+    }
+    logger.debug("CourseConfig document validation passed");
+  } catch (error) {
+    if (error.status === 404) {
+      issues.push({
+        type: "error",
+        category: "course_config",
+        message: "CourseConfig document not found in database"
+      });
+    } else {
+      issues.push({
+        type: "error",
+        category: "course_config",
+        message: `Failed to validate CourseConfig document: ${error instanceof Error ? error.message : String(error)}`
+      });
+    }
+  }
+}
+async function validateViews(db, manifest, issues) {
+  let viewsValid = true;
+  try {
+    for (const designDoc of manifest.designDocs) {
+      try {
+        const doc = await db.get(designDoc._id);
+        if (!doc) {
+          viewsValid = false;
+          issues.push({
+            type: "error",
+            category: "views",
+            message: `Design document not found: ${designDoc._id}`
+          });
+          continue;
+        }
+        for (const viewName of Object.keys(designDoc.views)) {
+          try {
+            const viewPath = `${designDoc._id}/${viewName}`;
+            await db.query(viewPath, { limit: 1 });
+          } catch (viewError) {
+            viewsValid = false;
+            issues.push({
+              type: "error",
+              category: "views",
+              message: `View not accessible: ${designDoc._id}/${viewName} - ${viewError}`
+            });
+          }
+        }
+      } catch (error) {
+        viewsValid = false;
+        issues.push({
+          type: "error",
+          category: "views",
+          message: `Failed to validate design document ${designDoc._id}: ${error}`
+        });
+      }
+    }
+  } catch (error) {
+    viewsValid = false;
+    issues.push({
+      type: "error",
+      category: "views",
+      message: `View validation failed: ${error instanceof Error ? error.message : String(error)}`
+    });
+  }
+  return viewsValid;
+}
+async function validateAttachmentIntegrity(db, issues) {
+  let attachmentsValid = true;
+  try {
+    const allDocs = await db.allDocs({
+      include_docs: true,
+      limit: 10
+      // Sample first 10 documents for performance
+    });
+    let attachmentCount = 0;
+    let validAttachments = 0;
+    for (const row of allDocs.rows) {
+      const doc = row.doc;
+      if (doc && doc._attachments) {
+        for (const [attachmentName, _attachmentMeta] of Object.entries(doc._attachments)) {
+          attachmentCount++;
+          try {
+            const attachment = await db.getAttachment(doc._id, attachmentName);
+            if (attachment) {
+              validAttachments++;
+            }
+          } catch (attachmentError) {
+            attachmentsValid = false;
+            issues.push({
+              type: "error",
+              category: "attachments",
+              message: `Attachment not accessible: ${doc._id}/${attachmentName} - ${attachmentError}`
+            });
+          }
+        }
+      }
+    }
+    if (attachmentCount === 0) {
+      issues.push({
+        type: "warning",
+        category: "attachments",
+        message: "No attachments found in sampled documents"
+      });
+    } else {
+      logger.info(`Validated ${validAttachments}/${attachmentCount} sampled attachments`);
+    }
+  } catch (error) {
+    attachmentsValid = false;
+    issues.push({
+      type: "error",
+      category: "attachments",
+      message: `Attachment validation failed: ${error instanceof Error ? error.message : String(error)}`
+    });
+  }
+  return attachmentsValid;
+}
+var nodeFS;
+var init_validation = __esm({
+  "src/util/migrator/validation.ts"() {
+    "use strict";
+    init_logger();
+    init_FileSystemAdapter();
+    nodeFS = null;
+    try {
+      if (typeof window === "undefined" && typeof process !== "undefined" && process.versions?.node) {
+        nodeFS = eval("require")("fs");
+        nodeFS.promises = nodeFS.promises || eval("require")("fs").promises;
+      }
+    } catch {
+    }
+  }
+});
+
+// src/util/migrator/StaticToCouchDBMigrator.ts
+var nodeFS2, nodePath, StaticToCouchDBMigrator;
+var init_StaticToCouchDBMigrator = __esm({
+  "src/util/migrator/StaticToCouchDBMigrator.ts"() {
+    "use strict";
+    init_logger();
+    init_types4();
+    init_validation();
+    init_FileSystemAdapter();
+    nodeFS2 = null;
+    nodePath = null;
+    try {
+      if (typeof window === "undefined" && typeof process !== "undefined" && process.versions?.node) {
+        nodeFS2 = eval("require")("fs");
+        nodePath = eval("require")("path");
+        nodeFS2.promises = nodeFS2.promises || eval("require")("fs").promises;
+      }
+    } catch {
+    }
+    StaticToCouchDBMigrator = class {
+      options;
+      progressCallback;
+      fs;
+      constructor(options = {}, fileSystemAdapter) {
+        this.options = {
+          ...DEFAULT_MIGRATION_OPTIONS,
+          ...options
+        };
+        this.fs = fileSystemAdapter;
+      }
+      /**
+       * Set a progress callback to receive updates during migration
+       */
+      setProgressCallback(callback) {
+        this.progressCallback = callback;
+      }
+      /**
+       * Migrate a static course to CouchDB
+       */
+      async migrateCourse(staticPath, targetDB) {
+        const startTime = Date.now();
+        const result = {
+          success: false,
+          documentsRestored: 0,
+          attachmentsRestored: 0,
+          designDocsRestored: 0,
+          courseConfigRestored: 0,
+          errors: [],
+          warnings: [],
+          migrationTime: 0
+        };
+        try {
+          logger.info(`Starting migration from ${staticPath} to CouchDB`);
+          this.reportProgress("manifest", 0, 1, "Validating static course...");
+          const validation = await validateStaticCourse(staticPath, this.fs);
+          if (!validation.valid) {
+            result.errors.push(...validation.errors);
+            throw new Error(`Static course validation failed: ${validation.errors.join(", ")}`);
+          }
+          result.warnings.push(...validation.warnings);
+          this.reportProgress("manifest", 1, 1, "Loading course manifest...");
+          const manifest = await this.loadManifest(staticPath);
+          logger.info(`Loaded manifest for course: ${manifest.courseId} (${manifest.courseName})`);
+          this.reportProgress(
+            "design_docs",
+            0,
+            manifest.designDocs.length,
+            "Restoring design documents..."
+          );
+          const designDocResults = await this.restoreDesignDocuments(manifest.designDocs, targetDB);
+          result.designDocsRestored = designDocResults.restored;
+          result.errors.push(...designDocResults.errors);
+          result.warnings.push(...designDocResults.warnings);
+          this.reportProgress("course_config", 0, 1, "Restoring CourseConfig document...");
+          const courseConfigResults = await this.restoreCourseConfig(manifest, targetDB);
+          result.courseConfigRestored = courseConfigResults.restored;
+          result.errors.push(...courseConfigResults.errors);
+          result.warnings.push(...courseConfigResults.warnings);
+          this.reportProgress("course_config", 1, 1, "CourseConfig document restored");
+          const expectedCounts = this.calculateExpectedCounts(manifest);
+          this.reportProgress(
+            "documents",
+            0,
+            manifest.documentCount,
+            "Aggregating documents from chunks..."
+          );
+          const documents = await this.aggregateDocuments(staticPath, manifest);
+          const filteredDocuments = documents.filter((doc) => doc._id !== "CourseConfig");
+          if (documents.length !== filteredDocuments.length) {
+            result.warnings.push(
+              `Filtered out ${documents.length - filteredDocuments.length} CourseConfig document(s) from chunks to prevent conflicts`
+            );
+          }
+          this.reportProgress(
+            "documents",
+            filteredDocuments.length,
+            manifest.documentCount,
+            "Uploading documents to CouchDB..."
+          );
+          const docResults = await this.uploadDocuments(filteredDocuments, targetDB);
+          result.documentsRestored = docResults.restored;
+          result.errors.push(...docResults.errors);
+          result.warnings.push(...docResults.warnings);
+          const docsWithAttachments = documents.filter(
+            (doc) => doc._attachments && Object.keys(doc._attachments).length > 0
+          );
+          this.reportProgress("attachments", 0, docsWithAttachments.length, "Uploading attachments...");
+          const attachmentResults = await this.uploadAttachments(
+            staticPath,
+            docsWithAttachments,
+            targetDB
+          );
+          result.attachmentsRestored = attachmentResults.restored;
+          result.errors.push(...attachmentResults.errors);
+          result.warnings.push(...attachmentResults.warnings);
+          if (this.options.validateRoundTrip) {
+            this.reportProgress("validation", 0, 1, "Validating migration...");
+            const validationResult = await validateMigration(targetDB, expectedCounts, manifest);
+            if (!validationResult.valid) {
+              result.warnings.push("Migration validation found issues");
+              validationResult.issues.forEach((issue) => {
+                if (issue.type === "error") {
+                  result.errors.push(`Validation: ${issue.message}`);
+                } else {
+                  result.warnings.push(`Validation: ${issue.message}`);
+                }
+              });
+            }
+            this.reportProgress("validation", 1, 1, "Migration validation completed");
+          }
+          result.success = result.errors.length === 0;
+          result.migrationTime = Date.now() - startTime;
+          logger.info(`Migration completed in ${result.migrationTime}ms`);
+          logger.info(`Documents restored: ${result.documentsRestored}`);
+          logger.info(`Attachments restored: ${result.attachmentsRestored}`);
+          logger.info(`Design docs restored: ${result.designDocsRestored}`);
+          logger.info(`CourseConfig restored: ${result.courseConfigRestored}`);
+          if (result.errors.length > 0) {
+            logger.error(`Migration completed with ${result.errors.length} errors`);
+          }
+          if (result.warnings.length > 0) {
+            logger.warn(`Migration completed with ${result.warnings.length} warnings`);
+          }
+        } catch (error) {
+          result.success = false;
+          result.migrationTime = Date.now() - startTime;
+          const errorMessage = error instanceof Error ? error.message : String(error);
+          result.errors.push(`Migration failed: ${errorMessage}`);
+          logger.error("Migration failed:", error);
+          if (this.options.cleanupOnFailure) {
+            try {
+              await this.cleanupFailedMigration(targetDB);
+            } catch (cleanupError) {
+              logger.error("Failed to cleanup after migration failure:", cleanupError);
+              result.warnings.push("Failed to cleanup after migration failure");
+            }
+          }
+        }
+        return result;
+      }
+      /**
+       * Load and parse the manifest file
+       */
+      async loadManifest(staticPath) {
+        try {
+          let manifestContent;
+          let manifestPath;
+          if (this.fs) {
+            manifestPath = this.fs.joinPath(staticPath, "manifest.json");
+            manifestContent = await this.fs.readFile(manifestPath);
+          } else {
+            manifestPath = nodeFS2 && nodePath ? nodePath.join(staticPath, "manifest.json") : `${staticPath}/manifest.json`;
+            if (nodeFS2 && this.isLocalPath(staticPath)) {
+              manifestContent = await nodeFS2.promises.readFile(manifestPath, "utf8");
+            } else {
+              const response = await fetch(manifestPath);
+              if (!response.ok) {
+                throw new Error(`Failed to fetch manifest: ${response.status} ${response.statusText}`);
+              }
+              manifestContent = await response.text();
+            }
+          }
+          const manifest = JSON.parse(manifestContent);
+          if (!manifest.version || !manifest.courseId || !manifest.chunks) {
+            throw new Error("Invalid manifest structure");
+          }
+          return manifest;
+        } catch (error) {
+          const errorMessage = error instanceof FileSystemError ? error.message : `Failed to load manifest: ${error instanceof Error ? error.message : String(error)}`;
+          throw new Error(errorMessage);
+        }
+      }
+      /**
+       * Restore design documents to CouchDB
+       */
+      async restoreDesignDocuments(designDocs, db) {
+        const result = { restored: 0, errors: [], warnings: [] };
+        for (let i = 0; i < designDocs.length; i++) {
+          const designDoc = designDocs[i];
+          this.reportProgress("design_docs", i, designDocs.length, `Restoring ${designDoc._id}...`);
+          try {
+            let existingDoc;
+            try {
+              existingDoc = await db.get(designDoc._id);
+            } catch {
+            }
+            const docToInsert = {
+              _id: designDoc._id,
+              views: designDoc.views
+            };
+            if (existingDoc) {
+              docToInsert._rev = existingDoc._rev;
+              logger.debug(`Updating existing design document: ${designDoc._id}`);
+            } else {
+              logger.debug(`Creating new design document: ${designDoc._id}`);
+            }
+            await db.put(docToInsert);
+            result.restored++;
+          } catch (error) {
+            const errorMessage = `Failed to restore design document ${designDoc._id}: ${error instanceof Error ? error.message : String(error)}`;
+            result.errors.push(errorMessage);
+            logger.error(errorMessage);
+          }
+        }
+        this.reportProgress(
+          "design_docs",
+          designDocs.length,
+          designDocs.length,
+          `Restored ${result.restored} design documents`
+        );
+        return result;
+      }
+      /**
+       * Aggregate documents from all chunks
+       */
+      async aggregateDocuments(staticPath, manifest) {
+        const allDocuments = [];
+        const documentMap = /* @__PURE__ */ new Map();
+        for (let i = 0; i < manifest.chunks.length; i++) {
+          const chunk = manifest.chunks[i];
+          this.reportProgress(
+            "documents",
+            allDocuments.length,
+            manifest.documentCount,
+            `Loading chunk ${chunk.id}...`
+          );
+          try {
+            const documents = await this.loadChunk(staticPath, chunk);
+            for (const doc of documents) {
+              if (!doc._id) {
+                logger.warn(`Document without _id found in chunk ${chunk.id}, skipping`);
+                continue;
+              }
+              if (documentMap.has(doc._id)) {
+                logger.warn(`Duplicate document ID found: ${doc._id}, using latest version`);
+              }
+              documentMap.set(doc._id, doc);
+            }
+          } catch (error) {
+            throw new Error(
+              `Failed to load chunk ${chunk.id}: ${error instanceof Error ? error.message : String(error)}`
+            );
+          }
+        }
+        allDocuments.push(...documentMap.values());
+        logger.info(
+          `Aggregated ${allDocuments.length} unique documents from ${manifest.chunks.length} chunks`
+        );
+        return allDocuments;
+      }
+      /**
+       * Load documents from a single chunk file
+       */
+      async loadChunk(staticPath, chunk) {
+        try {
+          let chunkContent;
+          let chunkPath;
+          if (this.fs) {
+            chunkPath = this.fs.joinPath(staticPath, chunk.path);
+            chunkContent = await this.fs.readFile(chunkPath);
+          } else {
+            chunkPath = nodeFS2 && nodePath ? nodePath.join(staticPath, chunk.path) : `${staticPath}/${chunk.path}`;
+            if (nodeFS2 && this.isLocalPath(staticPath)) {
+              chunkContent = await nodeFS2.promises.readFile(chunkPath, "utf8");
+            } else {
+              const response = await fetch(chunkPath);
+              if (!response.ok) {
+                throw new Error(`Failed to fetch chunk: ${response.status} ${response.statusText}`);
+              }
+              chunkContent = await response.text();
+            }
+          }
+          const documents = JSON.parse(chunkContent);
+          if (!Array.isArray(documents)) {
+            throw new Error("Chunk file does not contain an array of documents");
+          }
+          return documents;
+        } catch (error) {
+          const errorMessage = error instanceof FileSystemError ? error.message : `Failed to load chunk: ${error instanceof Error ? error.message : String(error)}`;
+          throw new Error(errorMessage);
+        }
+      }
+      /**
+       * Upload documents to CouchDB in batches
+       */
+      async uploadDocuments(documents, db) {
+        const result = { restored: 0, errors: [], warnings: [] };
+        const batchSize = this.options.chunkBatchSize;
+        for (let i = 0; i < documents.length; i += batchSize) {
+          const batch = documents.slice(i, i + batchSize);
+          this.reportProgress(
+            "documents",
+            i,
+            documents.length,
+            `Uploading batch ${Math.floor(i / batchSize) + 1}...`
+          );
+          try {
+            const docsToInsert = batch.map((doc) => {
+              const cleanDoc = { ...doc };
+              delete cleanDoc._rev;
+              delete cleanDoc._attachments;
+              return cleanDoc;
+            });
+            const bulkResult = await db.bulkDocs(docsToInsert);
+            for (let j = 0; j < bulkResult.length; j++) {
+              const docResult = bulkResult[j];
+              const originalDoc = batch[j];
+              if ("error" in docResult) {
+                const errorMessage = `Failed to upload document ${originalDoc._id}: ${docResult.error} - ${docResult.reason}`;
+                result.errors.push(errorMessage);
+                logger.error(errorMessage);
+              } else {
+                result.restored++;
+              }
+            }
+          } catch (error) {
+            let errorMessage;
+            if (error instanceof Error) {
+              errorMessage = `Failed to upload document batch starting at index ${i}: ${error.message}`;
+            } else if (error && typeof error === "object" && "message" in error) {
+              errorMessage = `Failed to upload document batch starting at index ${i}: ${error.message}`;
+            } else {
+              errorMessage = `Failed to upload document batch starting at index ${i}: ${JSON.stringify(error)}`;
+            }
+            result.errors.push(errorMessage);
+            logger.error(errorMessage);
+          }
+        }
+        this.reportProgress(
+          "documents",
+          documents.length,
+          documents.length,
+          `Uploaded ${result.restored} documents`
+        );
+        return result;
+      }
+      /**
+       * Upload attachments from filesystem to CouchDB
+       */
+      async uploadAttachments(staticPath, documents, db) {
+        const result = { restored: 0, errors: [], warnings: [] };
+        let processedDocs = 0;
+        for (const doc of documents) {
+          this.reportProgress(
+            "attachments",
+            processedDocs,
+            documents.length,
+            `Processing attachments for ${doc._id}...`
+          );
+          processedDocs++;
+          if (!doc._attachments) {
+            continue;
+          }
+          for (const [attachmentName, attachmentMeta] of Object.entries(doc._attachments)) {
+            try {
+              const uploadResult = await this.uploadSingleAttachment(
+                staticPath,
+                doc._id,
+                attachmentName,
+                attachmentMeta,
+                db
+              );
+              if (uploadResult.success) {
+                result.restored++;
+              } else {
+                result.errors.push(uploadResult.error || "Unknown attachment upload error");
+              }
+            } catch (error) {
+              const errorMessage = `Failed to upload attachment ${doc._id}/${attachmentName}: ${error instanceof Error ? error.message : String(error)}`;
+              result.errors.push(errorMessage);
+              logger.error(errorMessage);
+            }
+          }
+        }
+        this.reportProgress(
+          "attachments",
+          documents.length,
+          documents.length,
+          `Uploaded ${result.restored} attachments`
+        );
+        return result;
+      }
+      /**
+       * Upload a single attachment file
+       */
+      async uploadSingleAttachment(staticPath, docId, attachmentName, attachmentMeta, db) {
+        const result = {
+          success: false,
+          attachmentName,
+          docId
+        };
+        try {
+          if (!attachmentMeta.path) {
+            result.error = "Attachment metadata missing file path";
+            return result;
+          }
+          let attachmentData;
+          let attachmentPath;
+          if (this.fs) {
+            attachmentPath = this.fs.joinPath(staticPath, attachmentMeta.path);
+            attachmentData = await this.fs.readBinary(attachmentPath);
+          } else {
+            attachmentPath = nodeFS2 && nodePath ? nodePath.join(staticPath, attachmentMeta.path) : `${staticPath}/${attachmentMeta.path}`;
+            if (nodeFS2 && this.isLocalPath(staticPath)) {
+              attachmentData = await nodeFS2.promises.readFile(attachmentPath);
+            } else {
+              const response = await fetch(attachmentPath);
+              if (!response.ok) {
+                result.error = `Failed to fetch attachment: ${response.status} ${response.statusText}`;
+                return result;
+              }
+              attachmentData = await response.arrayBuffer();
+            }
+          }
+          const doc = await db.get(docId);
+          await db.putAttachment(
+            docId,
+            attachmentName,
+            doc._rev,
+            attachmentData,
+            // PouchDB accepts both ArrayBuffer and Buffer
+            attachmentMeta.content_type
+          );
+          result.success = true;
+        } catch (error) {
+          result.error = error instanceof Error ? error.message : String(error);
+        }
+        return result;
+      }
+      /**
+       * Restore CourseConfig document from manifest
+       */
+      async restoreCourseConfig(manifest, targetDB) {
+        const results = {
+          restored: 0,
+          errors: [],
+          warnings: []
+        };
+        try {
+          if (!manifest.courseConfig) {
+            results.warnings.push(
+              "No courseConfig found in manifest, skipping CourseConfig document creation"
+            );
+            return results;
+          }
+          const courseConfigDoc = {
+            _id: "CourseConfig",
+            ...manifest.courseConfig,
+            courseID: manifest.courseId
+          };
+          delete courseConfigDoc._rev;
+          await targetDB.put(courseConfigDoc);
+          results.restored = 1;
+          logger.info(`CourseConfig document created for course: ${manifest.courseId}`);
+        } catch (error) {
+          const errorMessage = error instanceof Error ? error.message : JSON.stringify(error);
+          results.errors.push(`Failed to restore CourseConfig: ${errorMessage}`);
+          logger.error("CourseConfig restoration failed:", error);
+        }
+        return results;
+      }
+      /**
+       * Calculate expected document counts from manifest
+       */
+      calculateExpectedCounts(manifest) {
+        const counts = {};
+        for (const chunk of manifest.chunks) {
+          counts[chunk.docType] = (counts[chunk.docType] || 0) + chunk.documentCount;
+        }
+        if (manifest.designDocs.length > 0) {
+          counts["_design"] = manifest.designDocs.length;
+        }
+        return counts;
+      }
+      /**
+       * Clean up database after failed migration
+       */
+      async cleanupFailedMigration(db) {
+        logger.info("Cleaning up failed migration...");
+        try {
+          const allDocs = await db.allDocs();
+          const docsToDelete = allDocs.rows.map((row) => ({
+            _id: row.id,
+            _rev: row.value.rev,
+            _deleted: true
+          }));
+          if (docsToDelete.length > 0) {
+            await db.bulkDocs(docsToDelete);
+            logger.info(`Cleaned up ${docsToDelete.length} documents from failed migration`);
+          }
+        } catch (error) {
+          logger.error("Failed to cleanup documents:", error);
+          throw error;
+        }
+      }
+      /**
+       * Report progress to callback if available
+       */
+      reportProgress(phase, current, total, message) {
+        if (this.progressCallback) {
+          this.progressCallback({
+            phase,
+            current,
+            total,
+            message
+          });
+        }
+      }
+      /**
+       * Check if a path is a local file path (vs URL)
+       */
+      isLocalPath(path2) {
+        return !path2.startsWith("http://") && !path2.startsWith("https://");
+      }
+    };
+  }
+});
+
+// src/util/migrator/index.ts
+var init_migrator = __esm({
+  "src/util/migrator/index.ts"() {
+    "use strict";
+    init_StaticToCouchDBMigrator();
+    init_validation();
+    init_FileSystemAdapter();
+  }
+});
+
+// src/util/index.ts
+var init_util2 = __esm({
+  "src/util/index.ts"() {
+    "use strict";
+    init_Loggable();
+    init_packer();
+    init_migrator();
+    init_dataDirectory();
+  }
+});
+
+// src/study/SourceMixer.ts
+var init_SourceMixer = __esm({
+  "src/study/SourceMixer.ts"() {
+    "use strict";
+  }
+});
+
+// src/study/MixerDebugger.ts
+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();
+}
+function mountMixerDebugger() {
+  if (typeof window === "undefined") return;
+  const win = window;
+  win.skuilder = win.skuilder || {};
+  win.skuilder.mixer = mixerDebugAPI;
+}
+var runHistory2, mixerDebugAPI;
+var init_MixerDebugger = __esm({
+  "src/study/MixerDebugger.ts"() {
+    "use strict";
+    init_logger();
+    init_navigators();
+    runHistory2 = [];
+    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()
+`);
+      }
+    };
+    mountMixerDebugger();
+  }
+});
+
+// src/study/SessionDebugger.ts
+function showCurrentQueue() {
+  if (!activeSession) {
+    logger.info("[Session Debug] No active session.");
+    return;
   }
-  const target = config.targetAccuracy ?? 0.85;
-  const tolerance = config.tolerance ?? 0.05;
-  let correct = 0;
-  for (const r of records) {
-    if (r.isCorrect) correct++;
+  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(", ")}`);
   }
-  const accuracy = correct / records.length;
-  return scoreAccuracyInZone(accuracy, target, tolerance);
-}
-function scoreAccuracyInZone(accuracy, target, tolerance) {
-  const dist = Math.abs(accuracy - target);
-  if (dist <= tolerance) {
-    return 1;
+  logger.info(`New Queue: ${latest.newQLength} cards`);
+  if (latest.newQNext3 && latest.newQNext3.length > 0) {
+    logger.info(`  Next: ${latest.newQNext3.join(", ")}`);
   }
-  const excess = dist - tolerance;
-  const slope = 2.5;
-  return Math.max(0, 1 - excess * slope);
+  logger.info(`Failed Queue: ${latest.failedQLength} cards`);
+  console.groupEnd();
 }
-var init_signal = __esm({
-  "src/core/orchestration/signal.ts"() {
-    "use strict";
+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;
   }
-});
-
-// src/core/orchestration/recording.ts
-async function recordUserOutcome(context, periodStart, periodEnd, records, activeStrategyIds, eloStart = 0, eloEnd = 0, config) {
-  const { user, course, userId } = context;
-  const courseId = course.getCourseID();
-  const outcomeValue = computeOutcomeSignal(records, config);
-  if (outcomeValue === null) {
-    logger.debug(
-      `[Orchestration] No outcome signal computed for ${userId} (insufficient data). Skipping record.`
+  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;
   }
-  const deviations = {};
-  for (const strategyId of activeStrategyIds) {
-    deviations[strategyId] = context.getDeviation(strategyId);
+  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);
   }
-  const id = `USER_OUTCOME::${courseId}::${userId}::${periodEnd}`;
-  const record = {
-    _id: id,
-    docType: "USER_OUTCOME" /* USER_OUTCOME */,
-    courseId,
-    userId,
-    periodStart,
-    periodEnd,
-    outcomeValue,
-    deviations,
-    metadata: {
-      sessionsCount: 1,
-      // Assumes recording is triggered per-session currently
-      cardsSeen: records.length,
-      eloStart,
-      eloEnd,
-      signalType: "accuracy_in_zone"
+  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;
     }
-  };
-  try {
-    await user.putUserOutcome(record);
-    logger.debug(
-      `[Orchestration] Recorded outcome ${outcomeValue.toFixed(3)} for ${userId} (doc: ${id})`
-    );
-  } catch (e) {
-    logger.error(`[Orchestration] Failed to record outcome: ${e}`);
   }
+  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 init_recording = __esm({
-  "src/core/orchestration/recording.ts"() {
+function mountSessionDebugger() {
+  if (typeof window === "undefined") return;
+  const win = window;
+  win.skuilder = win.skuilder || {};
+  win.skuilder.session = sessionDebugAPI;
+}
+var activeSession, sessionHistory, sessionDebugAPI;
+var init_SessionDebugger = __esm({
+  "src/study/SessionDebugger.ts"() {
     "use strict";
-    init_signal();
-    init_types_legacy();
     init_logger();
-  }
-});
+    activeSession = null;
+    sessionHistory = [];
+    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
 
-// src/core/orchestration/index.ts
-function fnv1a(str) {
-  let hash = 2166136261;
-  for (let i = 0; i < str.length; i++) {
-    hash ^= str.charCodeAt(i);
-    hash = Math.imul(hash, 16777619);
-  }
-  return hash >>> 0;
-}
-function computeDeviation(userId, strategyId, salt) {
-  const input = `${userId}:${strategyId}:${salt}`;
-  const hash = fnv1a(input);
-  const normalized = hash / 4294967296;
-  return normalized * 2 - 1;
-}
-function computeSpread(confidence) {
-  const clampedConfidence = Math.max(0, Math.min(1, confidence));
-  return MAX_SPREAD - clampedConfidence * (MAX_SPREAD - MIN_SPREAD);
-}
-function computeEffectiveWeight(learnable, userId, strategyId, salt) {
-  const deviation = computeDeviation(userId, strategyId, salt);
-  const spread = computeSpread(learnable.confidence);
-  const adjustment = deviation * spread * learnable.weight;
-  const effective = learnable.weight + adjustment;
-  return Math.max(MIN_WEIGHT, Math.min(MAX_WEIGHT, effective));
-}
-async function createOrchestrationContext(user, course) {
-  let courseConfig;
-  try {
-    courseConfig = await course.getCourseConfig();
-  } catch (e) {
-    logger.error(`[Orchestration] Failed to load course config: ${e}`);
-    courseConfig = {
-      name: "Unknown",
-      description: "",
-      public: false,
-      deleted: false,
-      creator: "",
-      admins: [],
-      moderators: [],
-      dataShapes: [],
-      questionTypes: [],
-      orchestration: { salt: "default" }
+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()
+`);
+      }
     };
+    mountSessionDebugger();
   }
-  const userId = user.getUsername();
-  const salt = courseConfig.orchestration?.salt || "default_salt";
-  return {
-    user,
-    course,
-    userId,
-    courseConfig,
-    getEffectiveWeight(strategyId, learnable) {
-      return computeEffectiveWeight(learnable, userId, strategyId, salt);
-    },
-    getDeviation(strategyId) {
-      return computeDeviation(userId, strategyId, salt);
-    }
-  };
-}
-var MIN_SPREAD, MAX_SPREAD, MIN_WEIGHT, MAX_WEIGHT;
-var init_orchestration = __esm({
-  "src/core/orchestration/index.ts"() {
+});
+
+// src/study/SessionController.ts
+var init_SessionController = __esm({
+  "src/study/SessionController.ts"() {
     "use strict";
-    init_logger();
-    init_gradient();
-    init_learning();
-    init_signal();
+    init_SrsService();
+    init_EloService();
+    init_ResponseProcessor();
+    init_CardHydrationService();
+    init_ItemQueue();
+    init_couch();
     init_recording();
-    MIN_SPREAD = 0.1;
-    MAX_SPREAD = 0.5;
-    MIN_WEIGHT = 0.1;
-    MAX_WEIGHT = 3;
+    init_util2();
+    init_navigators();
+    init_SourceMixer();
+    init_MixerDebugger();
+    init_SessionDebugger();
+    init_logger();
   }
 });
 
@@ -2878,7 +4891,7 @@ var Pipeline_exports = {};
 __export(Pipeline_exports, {
   Pipeline: () => Pipeline
 });
-import { toCourseElo as toCourseElo5 } from "@vue-skuilder/common";
+import { toCourseElo as toCourseElo7 } from "@vue-skuilder/common";
 function globToRegex(pattern) {
   const escaped = pattern.replace(/[.+?^${}()|[\]\\]/g, "\\$&");
   const withWildcards = escaped.replace(/\*/g, ".*");
@@ -2962,6 +4975,7 @@ var init_Pipeline = __esm({
     init_logger();
     init_orchestration();
     init_PipelineDebugger();
+    init_SessionController();
     VERBOSE_RESULTS = true;
     Pipeline = class extends ContentNavigator {
       generator;
@@ -3121,8 +5135,9 @@ var init_Pipeline = __esm({
             generatorSummaries,
             generatedCount,
             filterImpacts,
-            allCardsBeforeFiltering,
-            result
+            cards,
+            result,
+            context.userElo
           );
           captureRun(report);
         } catch (e) {
@@ -3283,7 +5298,7 @@ var init_Pipeline = __esm({
         let userElo = 1e3;
         try {
           const courseReg = await this.user.getCourseRegDoc(this.course.getCourseID());
-          const courseElo = toCourseElo5(courseReg.elo);
+          const courseElo = toCourseElo7(courseReg.elo);
           userElo = courseElo.global.score;
         } catch (e) {
           logger.debug(`[Pipeline] Could not get user ELO, using default: ${e}`);
@@ -3336,6 +5351,34 @@ var init_Pipeline = __esm({
         return [...new Set(ids)];
       }
       // ---------------------------------------------------------------------------
+      // Tag ELO diagnostic
+      // ---------------------------------------------------------------------------
+      /**
+       * Get the user's per-tag ELO data for specified tags (or all tags).
+       * Useful for diagnosing why hierarchy gates are open/closed.
+       */
+      async getTagEloStatus(tagFilter) {
+        const courseReg = await this.user.getCourseRegDoc(this.course.getCourseID());
+        const courseElo = toCourseElo7(courseReg.elo);
+        const result = {};
+        if (!tagFilter) {
+          for (const [tag, data] of Object.entries(courseElo.tags)) {
+            result[tag] = { score: data.score, count: data.count };
+          }
+        } else {
+          const patterns = Array.isArray(tagFilter) ? tagFilter : [tagFilter];
+          for (const pattern of patterns) {
+            const regex = globToRegex(pattern);
+            for (const [tag, data] of Object.entries(courseElo.tags)) {
+              if (regex.test(tag)) {
+                result[tag] = { score: data.score, count: data.count };
+              }
+            }
+          }
+        }
+        return result;
+      }
+      // ---------------------------------------------------------------------------
       // Card-space diagnostic
       // ---------------------------------------------------------------------------
       /**
@@ -3918,7 +5961,7 @@ import {
   EloToNumber,
   Status,
   blankCourseElo as blankCourseElo2,
-  toCourseElo as toCourseElo6
+  toCourseElo as toCourseElo8
 } from "@vue-skuilder/common";
 function randIntWeightedTowardZero(n) {
   return Math.floor(Math.random() * Math.random() * Math.random() * n);
@@ -4102,7 +6145,7 @@ var init_courseDB = __esm({
         docs.rows.forEach((r) => {
           if (isSuccessRow(r)) {
             if (r.doc && r.doc.elo) {
-              ret.push(toCourseElo6(r.doc.elo));
+              ret.push(toCourseElo8(r.doc.elo));
             } else {
               logger.warn("no elo data for card: " + r.id);
               ret.push(blankCourseElo2());
@@ -4607,7 +6650,7 @@ ${above.rows.map((r) => `	${r.id}-${r.key}
 });
 
 // src/impl/couch/classroomDB.ts
-import moment4 from "moment";
+import moment6 from "moment";
 var CLASSROOM_CONFIG, ClassroomDBBase, StudentClassroomDB;
 var init_classroomDB2 = __esm({
   "src/impl/couch/classroomDB.ts"() {
@@ -4725,9 +6768,9 @@ var init_classroomDB2 = __esm({
         }
         const activeCards = await this._user.getActiveCards();
         const activeCardIds = new Set(activeCards.map((ac) => ac.cardID));
-        const now = moment4.utc();
+        const now = moment6.utc();
         const assigned = await this.getAssignedContent();
-        const due = assigned.filter((c) => now.isAfter(moment4.utc(c.activeOn, REVIEW_TIME_FORMAT2)));
+        const due = assigned.filter((c) => now.isAfter(moment6.utc(c.activeOn, REVIEW_TIME_FORMAT2)));
         logger.info(`[StudentClassroomDB] Due content: ${JSON.stringify(due)}`);
         for (const content of due) {
           if (content.type === "course") {
@@ -4825,7 +6868,7 @@ var init_CourseSyncService = __esm({
 });
 
 // src/impl/couch/auth.ts
-import fetch from "cross-fetch";
+import fetch2 from "cross-fetch";
 var init_auth = __esm({
   "src/impl/couch/auth.ts"() {
     "use strict";
@@ -4850,8 +6893,8 @@ var init_CouchDBSyncStrategy = __esm({
 });
 
 // src/impl/couch/index.ts
-import fetch2 from "cross-fetch";
-import moment5 from "moment";
+import fetch3 from "cross-fetch";
+import moment7 from "moment";
 import process2 from "process";
 function createPouchDBConfig() {
   const hasExplicitCredentials = ENV.COUCHDB_USERNAME && ENV.COUCHDB_PASSWORD;
@@ -4928,7 +6971,7 @@ var init_couch = __esm({
 
 // src/impl/common/BaseUserDB.ts
 import { Status as Status3 } from "@vue-skuilder/common";
-import moment6 from "moment";
+import moment8 from "moment";
 async function getOrCreateClassroomRegistrationsDoc(user) {
   let ret;
   try {
@@ -5290,7 +7333,7 @@ Currently logged-in as ${this._username}.`
         );
         return reviews.rows.filter((r) => {
           if (r.id.startsWith(DocTypePrefixes["SCHEDULED_CARD" /* SCHEDULED_CARD */])) {
-            const date = moment6.utc(
+            const date = moment8.utc(
               r.id.substr(DocTypePrefixes["SCHEDULED_CARD" /* SCHEDULED_CARD */].length),
               REVIEW_TIME_FORMAT
             );
@@ -5303,11 +7346,11 @@ Currently logged-in as ${this._username}.`
         }).map((r) => r.doc);
       }
       async getReviewsForcast(daysCount) {
-        const time = moment6.utc().add(daysCount, "days");
+        const time = moment8.utc().add(daysCount, "days");
         return this.getReviewstoDate(time);
       }
       async getPendingReviews(course_id) {
-        const now = moment6.utc();
+        const now = moment8.utc();
         return this.getReviewstoDate(now, course_id);
       }
       async getScheduledReviewCount(course_id) {
@@ -5594,7 +7637,7 @@ Currently logged-in as ${this._username}.`
        */
       async putCardRecord(record) {
         const cardHistoryID = getCardHistoryID(record.courseID, record.cardID);
-        record.timeStamp = moment6.utc(record.timeStamp).toString();
+        record.timeStamp = moment8.utc(record.timeStamp).toString();
         try {
           const cardHistory = await this.update(
             cardHistoryID,
@@ -5610,7 +7653,7 @@ Currently logged-in as ${this._username}.`
             const ret = {
               ...record2
             };
-            ret.timeStamp = moment6.utc(record2.timeStamp);
+            ret.timeStamp = moment8.utc(record2.timeStamp);
             return ret;
           });
           return cardHistory;
@@ -6310,7 +8353,7 @@ var init_cardProcessor = __esm({
 });
 
 // src/core/bulkImport/types.ts
-var init_types3 = __esm({
+var init_types5 = __esm({
   "src/core/bulkImport/types.ts"() {
     "use strict";
   }
@@ -6321,7 +8364,7 @@ var init_bulkImport = __esm({
   "src/core/bulkImport/index.ts"() {
     "use strict";
     init_cardProcessor();
-    init_types3();
+    init_types5();
   }
 });