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

package/dist/impl/static/index.mjs

@@ -529,13 +529,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)
@@ -545,6 +552,7 @@ function buildRunReport(courseId, courseName, generatorName, generators, generat
   return {
     courseId,
     courseName,
+    userElo,
     generatorName,
     generators,
     generatedCount,
@@ -565,6 +573,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:");
@@ -651,8 +660,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();
@@ -705,6 +718,81 @@ var init_PipelineDebugger = __esm({
         }
         console.groupEnd();
       },
+      /**
+       * Show prescribed-related cards from the most recent run.
+       *
+       * Highlights:
+       * - cards directly generated by the prescribed strategy
+       * - blocked prescribed targets mentioned in provenance
+       * - support tags resolved for blocked targets
+       *
+       * @param groupId - Optional prescribed group ID filter (e.g. 'intro-core')
+       */
+      showPrescribed(groupId) {
+        if (runHistory.length === 0) {
+          logger.info("[Pipeline Debug] No runs captured yet.");
+          return;
+        }
+        const run = runHistory[0];
+        const prescribedCards = run.cards.filter(
+          (c) => c.provenance.some((p) => p.strategy === "prescribed")
+        );
+        console.group(`\u{1F9ED} Prescribed Debug (${run.courseId})`);
+        if (prescribedCards.length === 0) {
+          logger.info("No prescribed-generated cards were present in the most recent run.");
+          console.groupEnd();
+          return;
+        }
+        const rows = prescribedCards.map((card) => {
+          const prescribedProv = card.provenance.find((p) => p.strategy === "prescribed");
+          const reason = prescribedProv?.reason ?? "";
+          const parsedGroup = reason.match(/group=([^;]+)/)?.[1] ?? "unknown";
+          const mode = reason.match(/mode=([^;]+)/)?.[1] ?? "unknown";
+          const blocked = reason.match(/blocked=([^;]+)/)?.[1] ?? "unknown";
+          const blockedTargets = reason.match(/blockedTargets=([^;]+)/)?.[1] ?? "none";
+          const supportTags = reason.match(/supportTags=([^;]+)/)?.[1] ?? "none";
+          const multiplier = reason.match(/multiplier=([^;]+)/)?.[1] ?? "unknown";
+          return {
+            group: parsedGroup,
+            mode,
+            cardId: card.cardId,
+            selected: card.selected ? "yes" : "no",
+            finalScore: card.finalScore.toFixed(3),
+            blocked,
+            blockedTargets,
+            supportTags,
+            multiplier
+          };
+        }).filter((row) => !groupId || row.group === groupId).sort((a, b) => Number(b.finalScore) - Number(a.finalScore));
+        if (rows.length === 0) {
+          logger.info(
+            `[Pipeline Debug] No prescribed cards matched group '${groupId}' in the most recent run.`
+          );
+          console.groupEnd();
+          return;
+        }
+        console.table(rows);
+        const selectedRows = rows.filter((r) => r.selected === "yes");
+        const blockedTargetSet = /* @__PURE__ */ new Set();
+        const supportTagSet = /* @__PURE__ */ new Set();
+        for (const row of rows) {
+          if (row.blockedTargets && row.blockedTargets !== "none") {
+            row.blockedTargets.split("|").filter(Boolean).forEach((t) => blockedTargetSet.add(t));
+          }
+          if (row.supportTags && row.supportTags !== "none") {
+            row.supportTags.split("|").filter(Boolean).forEach((t) => supportTagSet.add(t));
+          }
+        }
+        logger.info(`Prescribed cards in run: ${rows.length}`);
+        logger.info(`Selected prescribed cards: ${selectedRows.length}`);
+        logger.info(
+          `Blocked prescribed targets referenced: ${blockedTargetSet.size > 0 ? [...blockedTargetSet].join(", ") : "none"}`
+        );
+        logger.info(
+          `Resolved support tags referenced: ${supportTagSet.size > 0 ? [...supportTagSet].join(", ") : "none"}`
+        );
+        console.groupEnd();
+      },
       /**
        * Show all runs in compact format.
        */
@@ -816,6 +904,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.
        */
@@ -827,10 +936,12 @@ 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)
   .showStrategies()      Show registry + strategy mapping from last run
+  .showPrescribed(id?)   Show prescribed-generated cards and blocked/support details from last run
   .listRuns()            List all captured runs in table format
   .export()              Export run history as JSON for bug reports
   .clear()               Clear run history
@@ -854,6 +965,44 @@ __export(CompositeGenerator_exports, {
   AggregationMode: () => AggregationMode,
   default: () => CompositeGenerator
 });
+function mergeHints(allHints) {
+  const defined = allHints.filter((h) => h !== void 0);
+  if (defined.length === 0) return void 0;
+  const merged = {};
+  const boostTags = {};
+  for (const hints of defined) {
+    for (const [pattern, factor] of Object.entries(hints.boostTags ?? {})) {
+      boostTags[pattern] = (boostTags[pattern] ?? 1) * factor;
+    }
+  }
+  if (Object.keys(boostTags).length > 0) {
+    merged.boostTags = boostTags;
+  }
+  const boostCards = {};
+  for (const hints of defined) {
+    for (const [pattern, factor] of Object.entries(hints.boostCards ?? {})) {
+      boostCards[pattern] = (boostCards[pattern] ?? 1) * factor;
+    }
+  }
+  if (Object.keys(boostCards).length > 0) {
+    merged.boostCards = boostCards;
+  }
+  const concatUnique = (field) => {
+    const values = defined.flatMap((h) => h[field] ?? []);
+    if (values.length > 0) {
+      merged[field] = [...new Set(values)];
+    }
+  };
+  concatUnique("requireTags");
+  concatUnique("requireCards");
+  concatUnique("excludeTags");
+  concatUnique("excludeCards");
+  const labels = defined.map((h) => h._label).filter(Boolean);
+  if (labels.length > 0) {
+    merged._label = labels.join("; ");
+  }
+  return Object.keys(merged).length > 0 ? merged : void 0;
+}
 var AggregationMode, DEFAULT_AGGREGATION_MODE, FREQUENCY_BOOST_FACTOR, CompositeGenerator;
 var init_CompositeGenerator = __esm({
   "src/core/navigators/generators/CompositeGenerator.ts"() {
@@ -917,17 +1066,18 @@ var init_CompositeGenerator = __esm({
           this.generators.map((g) => g.getWeightedCards(limit, context))
         );
         const generatorSummaries = [];
-        results.forEach((cards, index) => {
+        results.forEach((result, index) => {
+          const cards2 = result.cards;
           const gen = this.generators[index];
           const genName = gen.name || `Generator ${index}`;
-          const newCards = cards.filter((c) => c.provenance[0]?.reason?.includes("new card"));
-          const reviewCards = cards.filter((c) => c.provenance[0]?.reason?.includes("review"));
-          if (cards.length > 0) {
-            const topScore = Math.max(...cards.map((c) => c.score)).toFixed(2);
+          const newCards = cards2.filter((c) => c.provenance[0]?.reason?.includes("new card"));
+          const reviewCards = cards2.filter((c) => c.provenance[0]?.reason?.includes("review"));
+          if (cards2.length > 0) {
+            const topScore = Math.max(...cards2.map((c) => c.score)).toFixed(2);
             const parts = [];
             if (newCards.length > 0) parts.push(`${newCards.length} new`);
             if (reviewCards.length > 0) parts.push(`${reviewCards.length} reviews`);
-            const breakdown = parts.length > 0 ? parts.join(", ") : `${cards.length} cards`;
+            const breakdown = parts.length > 0 ? parts.join(", ") : `${cards2.length} cards`;
             generatorSummaries.push(`${genName}: ${breakdown} (top: ${topScore})`);
           } else {
             generatorSummaries.push(`${genName}: 0 cards`);
@@ -935,7 +1085,8 @@ var init_CompositeGenerator = __esm({
         });
         logger.info(`[Composite] Generator breakdown: ${generatorSummaries.join(" | ")}`);
         const byCardId = /* @__PURE__ */ new Map();
-        results.forEach((cards, index) => {
+        results.forEach((result, index) => {
+          const cards2 = result.cards;
           const gen = this.generators[index];
           let weight = gen.learnable?.weight ?? 1;
           let deviation;
@@ -946,7 +1097,7 @@ var init_CompositeGenerator = __esm({
               deviation = context.orchestration.getDeviation(strategyId);
             }
           }
-          for (const card of cards) {
+          for (const card of cards2) {
             if (card.provenance.length > 0) {
               card.provenance[0].effectiveWeight = weight;
               card.provenance[0].deviation = deviation;
@@ -958,15 +1109,15 @@ var init_CompositeGenerator = __esm({
         });
         const merged = [];
         for (const [, items] of byCardId) {
-          const cards = items.map((i) => i.card);
+          const cards2 = items.map((i) => i.card);
           const aggregatedScore = this.aggregateScores(items);
           const finalScore = Math.min(1, aggregatedScore);
-          const mergedProvenance = cards.flatMap((c) => c.provenance);
-          const initialScore = cards[0].score;
+          const mergedProvenance = cards2.flatMap((c) => c.provenance);
+          const initialScore = cards2[0].score;
           const action = finalScore > initialScore ? "boosted" : finalScore < initialScore ? "penalized" : "passed";
           const reason = this.buildAggregationReason(items, finalScore);
           merged.push({
-            ...cards[0],
+            ...cards2[0],
             score: finalScore,
             provenance: [
               ...mergedProvenance,
@@ -981,7 +1132,9 @@ var init_CompositeGenerator = __esm({
             ]
           });
         }
-        return merged.sort((a, b) => b.score - a.score).slice(0, limit);
+        const cards = merged.sort((a, b) => b.score - a.score).slice(0, limit);
+        const hints = mergeHints(results.map((result) => result.hints));
+        return { cards, hints };
       }
       /**
        * Build human-readable reason for score aggregation.
@@ -1112,16 +1265,16 @@ var init_elo = __esm({
           };
         });
         scored.sort((a, b) => b.score - a.score);
-        const result = scored.slice(0, limit);
-        if (result.length > 0) {
-          const topScores = result.slice(0, 3).map((c) => c.score.toFixed(2)).join(", ");
+        const cards = scored.slice(0, limit);
+        if (cards.length > 0) {
+          const topScores = cards.slice(0, 3).map((c) => c.score.toFixed(2)).join(", ");
           logger.info(
-            `[ELO] Course ${this.course.getCourseID()}: ${result.length} new cards (top scores: ${topScores})`
+            `[ELO] Course ${this.course.getCourseID()}: ${cards.length} new cards (top scores: ${topScores})`
           );
         } else {
           logger.info(`[ELO] Course ${this.course.getCourseID()}: No new cards available`);
         }
-        return result;
+        return { cards };
       }
     };
   }
@@ -1140,60 +1293,476 @@ 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, PRESCRIBED_DEBUG_VERSION, 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:";
+    PRESCRIBED_DEBUG_VERSION = "testversion-prescribed-v2";
     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) {
-          return [];
+      get strategyKey() {
+        return "PrescribedProgress";
+      }
+      async getWeightedCards(limit, context) {
+        if (this.config.groups.length === 0 || limit <= 0) {
+          return { cards: [] };
         }
         const courseId = this.course.getCourseID();
         const activeCards = await this.user.getActiveCards();
         const activeIds = new Set(activeCards.map((ac) => ac.cardID));
-        const eligibleIds = this.config.cardIds.filter((id) => !activeIds.has(id));
-        if (eligibleIds.length === 0) {
-          logger.debug("[Prescribed] All prescribed cards already active, returning empty");
-          return [];
-        }
-        const cards = eligibleIds.slice(0, limit).map((cardId) => ({
-          cardId,
-          courseId,
-          score: 1,
-          provenance: [
-            {
-              strategy: "prescribed",
-              strategyName: this.strategyName || this.name,
-              strategyId: this.strategyId || "NAVIGATION_STRATEGY-prescribed",
-              action: "generated",
-              score: 1,
-              reason: `Prescribed card (${eligibleIds.length} eligible of ${this.config.cardIds.length} configured)`
+        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();
+        const groupRuntimes = [];
+        for (const group of this.config.groups) {
+          const runtime = this.buildGroupRuntimeState({
+            group,
+            priorState: progress.groups[group.id],
+            activeIds,
+            seenIds,
+            tagsByCard,
+            hierarchyConfigs,
+            userTagElo,
+            userGlobalElo
+          });
+          groupRuntimes.push(runtime);
+          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);
+        }
+        const hintSummary = this.buildSupportHintSummary(groupRuntimes);
+        const hints = Object.keys(hintSummary.boostTags).length > 0 ? {
+          boostTags: hintSummary.boostTags,
+          _label: `prescribed-support (${hintSummary.supportTags.length} tags; blocked=${hintSummary.blockedTargetIds.length}; testversion=${PRESCRIBED_DEBUG_VERSION})`
+        } : void 0;
+        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 hints ? { cards: [], hints } : { cards: [] };
+        }
+        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 hints ? { cards: finalCards, hints } : { cards: finalCards };
+      }
+      buildSupportHintSummary(groupRuntimes) {
+        const boostTags = {};
+        const blockedTargetIds = /* @__PURE__ */ new Set();
+        const supportTags = /* @__PURE__ */ new Set();
+        for (const runtime of groupRuntimes) {
+          if (runtime.blockedTargets.length === 0 || runtime.supportTags.length === 0) {
+            continue;
+          }
+          runtime.blockedTargets.forEach((cardId) => blockedTargetIds.add(cardId));
+          for (const tag of runtime.supportTags) {
+            supportTags.add(tag);
+            boostTags[tag] = (boostTags[tag] ?? 1) * runtime.supportMultiplier;
+          }
+        }
+        return {
+          boostTags,
+          blockedTargetIds: [...blockedTargetIds].sort(),
+          supportTags: [...supportTags].sort()
+        };
+      }
+      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
+          );
+          const introTags = tags.filter((tag) => tag.startsWith("gpc:intro:"));
+          const exposeTags = new Set(tags.filter((tag) => tag.startsWith("gpc:expose:")));
+          for (const introTag of introTags) {
+            const suffix = introTag.slice("gpc:intro:".length);
+            if (suffix) {
+              exposeTags.add(`gpc:expose:${suffix}`);
+            }
+          }
+          const unmetExposeTags = [...exposeTags].filter((tag) => {
+            const tagElo = userTagElo[tag];
+            return !tagElo || tagElo.count < DEFAULT_MIN_COUNT;
+          });
+          if (unmetExposeTags.length > 0) {
+            unmetExposeTags.forEach((tag) => supportTags.add(tag));
+          }
+          if (resolution.blocked || unmetExposeTags.length > 0) {
+            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,
+          debugVersion: PRESCRIBED_DEBUG_VERSION
+        };
+      }
+      buildNextGroupState(runtime, prior) {
+        const carriedSessions = prior?.sessionsSinceSurfaced ?? 0;
+        const surfacedThisRun = false;
+        return {
+          encounteredCardIds: [...runtime.encounteredTargets].sort(),
+          pendingTargetIds: [...runtime.pendingTargets].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};blockedTargets=${runtime.blockedTargets.join("|") || "none"};supportTags=${runtime.supportTags.join("|") || "none"};multiplier=${runtime.pressureMultiplier.toFixed(2)};testversion=${runtime.debugVersion}`
+              }
+            ]
+          });
+        }
         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};pending=${runtime.pendingTargets.length};blocked=${runtime.blockedTargets.length};blockedTargets=${runtime.blockedTargets.join("|") || "none"};supportCard=${cardId};supportTags=${runtime.supportTags.join("|") || "none"};multiplier=${runtime.supportMultiplier.toFixed(2)};testversion=${runtime.debugVersion}`
+              }
+            ]
+          });
+        }
+        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) {
+        const supportTags = /* @__PURE__ */ new Set();
+        let blocked = false;
+        for (const targetTag of targetTags) {
+          const prereqSets = hierarchyConfigs.map((hierarchy) => hierarchy.prerequisites[targetTag]).filter((prereqs) => Array.isArray(prereqs) && prereqs.length > 0);
+          if (prereqSets.length === 0) {
+            continue;
+          }
+          const tagBlocked = prereqSets.some(
+            (prereqs) => prereqs.some((pr) => !this.isPrerequisiteMet(pr, userTagElo[pr.tag], userGlobalElo))
+          );
+          if (!tagBlocked) {
+            continue;
+          }
+          blocked = true;
+          if (!hierarchyWalkEnabled) {
+            for (const prereqs of prereqSets) {
+              for (const prereq of prereqs) {
+                if (!this.isPrerequisiteMet(prereq, userTagElo[prereq.tag], userGlobalElo)) {
+                  supportTags.add(prereq.tag);
+                }
+              }
+            }
+            continue;
+          }
+          for (const prereqs of prereqSets) {
+            for (const prereq of prereqs) {
+              if (!this.isPrerequisiteMet(prereq, userTagElo[prereq.tag], userGlobalElo)) {
+                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;
+      }
     };
   }
 });
@@ -1298,7 +1867,7 @@ var init_srs = __esm({
             ]
           };
         });
-        return scored.sort((a, b) => b.score - a.score).slice(0, limit);
+        return { cards: scored.sort((a, b) => b.score - a.score).slice(0, limit) };
       }
       /**
        * Compute backlog pressure based on number of due reviews.
@@ -1557,13 +2126,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 */
@@ -1590,7 +2159,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;
@@ -1691,18 +2260,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(
@@ -1735,6 +2341,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,
@@ -1920,12 +2546,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 {
@@ -1950,7 +2576,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
             },
@@ -1960,7 +2586,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
@@ -2007,7 +2633,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;
@@ -2447,6 +3073,44 @@ function globMatch(value, pattern) {
 function cardMatchesTagPattern(card, pattern) {
   return (card.tags ?? []).some((tag) => globMatch(tag, pattern));
 }
+function mergeHints2(allHints) {
+  const defined = allHints.filter((h) => h !== null && h !== void 0);
+  if (defined.length === 0) return void 0;
+  const merged = {};
+  const boostTags = {};
+  for (const hints of defined) {
+    for (const [pattern, factor] of Object.entries(hints.boostTags ?? {})) {
+      boostTags[pattern] = (boostTags[pattern] ?? 1) * factor;
+    }
+  }
+  if (Object.keys(boostTags).length > 0) {
+    merged.boostTags = boostTags;
+  }
+  const boostCards = {};
+  for (const hints of defined) {
+    for (const [pattern, factor] of Object.entries(hints.boostCards ?? {})) {
+      boostCards[pattern] = (boostCards[pattern] ?? 1) * factor;
+    }
+  }
+  if (Object.keys(boostCards).length > 0) {
+    merged.boostCards = boostCards;
+  }
+  const concatUnique = (field) => {
+    const values = defined.flatMap((h) => h[field] ?? []);
+    if (values.length > 0) {
+      merged[field] = [...new Set(values)];
+    }
+  };
+  concatUnique("requireTags");
+  concatUnique("requireCards");
+  concatUnique("excludeTags");
+  concatUnique("excludeCards");
+  const labels = defined.map((h) => h._label).filter(Boolean);
+  if (labels.length > 0) {
+    merged._label = labels.join("; ");
+  }
+  return Object.keys(merged).length > 0 ? merged : void 0;
+}
 function logPipelineConfig(generator, filters) {
   const filterList = filters.length > 0 ? "\n    - " + filters.map((f) => f.name).join("\n    - ") : " none";
   logger.info(
@@ -2597,9 +3261,12 @@ var init_Pipeline = __esm({
         logger.debug(
           `[Pipeline] Fetching ${fetchLimit} candidates from generator '${this.generator.name}'`
         );
-        let cards = await this.generator.getWeightedCards(fetchLimit, context);
+        const generatorResult = await this.generator.getWeightedCards(fetchLimit, context);
+        let cards = generatorResult.cards;
         const tGenerate = performance.now();
         const generatedCount = cards.length;
+        const mergedHints = mergeHints2([this._ephemeralHints, generatorResult.hints]);
+        this._ephemeralHints = mergedHints ?? null;
         let generatorSummaries;
         if (this.generator.generators) {
           const genMap = /* @__PURE__ */ new Map();
@@ -2677,14 +3344,15 @@ var init_Pipeline = __esm({
             generatorSummaries,
             generatedCount,
             filterImpacts,
-            allCardsBeforeFiltering,
-            result
+            cards,
+            result,
+            context.userElo
           );
           captureRun(report);
         } catch (e) {
           logger.debug(`[Pipeline] Failed to capture debug run: ${e}`);
         }
-        return result;
+        return { cards: result };
       }
       /**
        * Batch hydrate tags for all cards.
@@ -2892,6 +3560,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 = toCourseElo5(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
       // ---------------------------------------------------------------------------
       /**