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

package/dist/impl/static/index.mjs

@@ -514,8 +514,9 @@ function getOrigin(card) {
   const firstEntry = card.provenance[0];
   if (!firstEntry) return "unknown";
   const reason = firstEntry.reason?.toLowerCase() || "";
-  if (reason.includes("new card")) return "new";
-  if (reason.includes("review")) return "review";
+  const strategy = firstEntry.strategy?.toLowerCase() || "";
+  if (reason.includes("new card") || strategy.includes("elo")) return "new";
+  if (reason.includes("review") || strategy.includes("srs")) return "review";
   return "unknown";
 }
 function captureRun(report) {
@@ -535,12 +536,13 @@ function parseCardElo(provenance) {
   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) {
+function buildRunReport(courseId, courseName, generatorName, generators, generatedCount, filters, allCards, selectedCards, userElo, hints) {
   const selectedIds = new Set(selectedCards.map((c) => c.cardId));
   const cards = allCards.map((card) => ({
     cardId: card.cardId,
     courseId: card.courseId,
     origin: getOrigin(card),
+    generator: card.provenance[0]?.strategyName || card.provenance[0]?.strategy,
     finalScore: card.score,
     cardElo: parseCardElo(card.provenance),
     provenance: card.provenance,
@@ -557,6 +559,7 @@ function buildRunReport(courseId, courseName, generatorName, generators, generat
     generators,
     generatedCount,
     filters,
+    hints,
     finalCount: selectedCards.length,
     reviewsSelected,
     newSelected,
@@ -596,13 +599,169 @@ function printRunSummary(run) {
   );
   console.groupEnd();
 }
+function renderUI() {
+  if (!_uiContainer) return;
+  const runs = runHistory;
+  const selectedRun = _selectedRunIndex !== null ? runs[_selectedRunIndex] : null;
+  const styles = `
+    #sk-pipeline-debugger {
+      position: fixed;
+      top: 0;
+      left: 0;
+      width: 100vw;
+      height: 100vh;
+      background: #f8f9fa;
+      color: #212529;
+      z-index: 999999;
+      display: flex;
+      flex-direction: column;
+      font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, Helvetica, Arial, sans-serif;
+      font-size: 14px;
+    }
+    #sk-pipeline-debugger header {
+      padding: 1rem;
+      background: #343a40;
+      color: white;
+      display: flex;
+      justify-content: space-between;
+      align-items: center;
+    }
+    #sk-pipeline-debugger .container {
+      display: flex;
+      flex: 1;
+      overflow: hidden;
+    }
+    #sk-pipeline-debugger .sidebar {
+      width: 300px;
+      border-right: 1px solid #dee2e6;
+      overflow-y: auto;
+      background: white;
+    }
+    #sk-pipeline-debugger .main-content {
+      flex: 1;
+      overflow-y: auto;
+      padding: 1.5rem;
+    }
+    #sk-pipeline-debugger .run-item {
+      padding: 0.75rem 1rem;
+      border-bottom: 1px solid #eee;
+      cursor: pointer;
+    }
+    #sk-pipeline-debugger .run-item:hover { background: #f1f3f5; }
+    #sk-pipeline-debugger .run-item.active { background: #e9ecef; border-left: 4px solid #007bff; }
+    #sk-pipeline-debugger h2, #sk-pipeline-debugger h3 { margin-top: 0; }
+    #sk-pipeline-debugger table { width: 100%; border-collapse: collapse; margin-bottom: 1rem; background: white; }
+    #sk-pipeline-debugger th, #sk-pipeline-debugger td { border: 1px solid #dee2e6; padding: 0.5rem; text-align: left; }
+    #sk-pipeline-debugger th { background: #f1f3f5; }
+    #sk-pipeline-debugger code { background: #f1f3f5; padding: 0.1rem 0.3rem; border-radius: 3px; font-family: monospace; }
+    #sk-pipeline-debugger .close-btn { background: #dc3545; color: white; border: none; padding: 0.5rem 1rem; border-radius: 4px; cursor: pointer; }
+    #sk-pipeline-debugger .search-box { margin-bottom: 1rem; width: 100%; padding: 0.5rem; border: 1px solid #ced4da; border-radius: 4px; }
+    #sk-pipeline-debugger .provenance { font-size: 12px; color: #666; margin-top: 0.25rem; white-space: pre-wrap; font-family: monospace; background: #f8f9fa; padding: 0.5rem; border-radius: 4px; }
+  `;
+  const runListHtml = runs.length === 0 ? '<div style="padding: 1rem;">No runs captured yet.</div>' : runs.map(
+    (r, i) => `
+        <div class="run-item ${i === _selectedRunIndex ? "active" : ""}" onclick="window.skuilder.pipeline._selectRun(${i})">
+          <strong>${r.timestamp.toLocaleTimeString()}</strong><br/>
+          <small>${r.courseName || r.courseId.slice(0, 8)}</small><br/>
+          <small>${r.finalCount} cards selected</small>
+        </div>
+      `
+  ).join("");
+  let detailsHtml = '<div style="color: #6c757d; text-align: center; margin-top: 5rem;">Select a run to see details</div>';
+  if (selectedRun) {
+    const filteredCards = selectedRun.cards.filter(
+      (c) => !_cardSearchQuery || c.cardId.toLowerCase().includes(_cardSearchQuery.toLowerCase())
+    );
+    detailsHtml = `
+      <h2>Run: ${selectedRun.runId}</h2>
+      <p>
+        <strong>Time:</strong> ${selectedRun.timestamp.toLocaleString()} | 
+        <strong>Course:</strong> ${selectedRun.courseName || selectedRun.courseId} | 
+        <strong>User ELO:</strong> ${selectedRun.userElo ?? "unknown"}
+      </p>
+
+      <h3>Pipeline Config</h3>
+      <table>
+        <tr><th>Generator</th><td>${selectedRun.generatorName} (${selectedRun.generatedCount} candidates)</td></tr>
+        ${(selectedRun.generators || []).map(
+      (g) => `
+          <tr><td style="padding-left: 2rem;">\u21B3 ${g.name}</td><td>${g.cardCount} cards (${g.newCount} new, ${g.reviewCount} review, top: ${g.topScore.toFixed(2)})</td></tr>
+        `
+    ).join("")}
+      </table>
+
+      ${selectedRun.hints ? `
+        <h3>Ephemeral Hints</h3>
+        <table>
+          ${selectedRun.hints._label ? `<tr><th>Label</th><td>${selectedRun.hints._label}</td></tr>` : ""}
+          ${selectedRun.hints.boostTags ? `<tr><th>Boost Tags</th><td><pre style="margin:0">${JSON.stringify(selectedRun.hints.boostTags, null, 2)}</pre></td></tr>` : ""}
+          ${selectedRun.hints.boostCards ? `<tr><th>Boost Cards</th><td><pre style="margin:0">${JSON.stringify(selectedRun.hints.boostCards, null, 2)}</pre></td></tr>` : ""}
+          ${selectedRun.hints.requireTags ? `<tr><th>Require Tags</th><td>${selectedRun.hints.requireTags.join(", ")}</td></tr>` : ""}
+          ${selectedRun.hints.requireCards ? `<tr><th>Require Cards</th><td>${selectedRun.hints.requireCards.join(", ")}</td></tr>` : ""}
+          ${selectedRun.hints.excludeTags ? `<tr><th>Exclude Tags</th><td>${selectedRun.hints.excludeTags.join(", ")}</td></tr>` : ""}
+          ${selectedRun.hints.excludeCards ? `<tr><th>Exclude Cards</th><td>${selectedRun.hints.excludeCards.join(", ")}</td></tr>` : ""}
+        </table>
+      ` : ""}
+
+      <h3>Filter Impact</h3>
+      <table>
+        <thead><tr><th>Filter</th><th>Boosted</th><th>Penalized</th><th>Passed</th><th>Removed</th></tr></thead>
+        <tbody>
+          ${selectedRun.filters.map(
+      (f) => `
+            <tr><td>${f.name}</td><td>\u2191${f.boosted}</td><td>\u2193${f.penalized}</td><td>=${f.passed}</td><td>\u2715${f.removed}</td></tr>
+          `
+    ).join("")}
+        </tbody>
+      </table>
+
+      <h3>Cards (${selectedRun.finalCount} selected / ${selectedRun.cards.length} total)</h3>
+      <input type="text" class="search-box" placeholder="Search Card ID..." value="${_cardSearchQuery}" oninput="window.skuilder.pipeline._setSearch(this.value)">
+      
+      <table>
+        <thead><tr><th>ID</th><th>Generator</th><th>Origin</th><th>Score</th><th>Selected</th></tr></thead>
+        <tbody>
+          ${filteredCards.map(
+      (c) => `
+            <tr>
+              <td><code>${c.cardId}</code></td>
+              <td>${c.generator || "unknown"}</td>
+              <td>${c.origin}</td>
+              <td>${c.finalScore.toFixed(3)}</td>
+              <td>${c.selected ? "\u2705" : "\u274C"}</td>
+            </tr>
+            ${c.selected || _cardSearchQuery ? `
+              <tr>
+                <td colspan="5">
+                  <div class="provenance">${formatProvenance(c.provenance)}</div>
+                </td>
+              </tr>
+            ` : ""}
+          `
+    ).join("")}
+        </tbody>
+      </table>
+    `;
+  }
+  _uiContainer.innerHTML = `
+    <style>${styles}</style>
+    <header>
+      <strong>Pipeline Debugger</strong>
+      <button class="close-btn" onclick="window.skuilder.pipeline.ui()">Close</button>
+    </header>
+    <div class="container">
+      <div class="sidebar">${runListHtml}</div>
+      <div class="main-content">${detailsHtml}</div>
+    </div>
+  `;
+}
 function mountPipelineDebugger() {
   if (typeof window === "undefined") return;
   const win = window;
   win.skuilder = win.skuilder || {};
   win.skuilder.pipeline = pipelineDebugAPI;
 }
-var _activePipeline, MAX_RUNS, runHistory, pipelineDebugAPI;
+var _activePipeline, MAX_RUNS, runHistory, _uiContainer, _selectedRunIndex, _cardSearchQuery, pipelineDebugAPI;
 var init_PipelineDebugger = __esm({
   "src/core/navigators/PipelineDebugger.ts"() {
     "use strict";
@@ -611,6 +770,9 @@ var init_PipelineDebugger = __esm({
     _activePipeline = null;
     MAX_RUNS = 10;
     runHistory = [];
+    _uiContainer = null;
+    _selectedRunIndex = null;
+    _cardSearchQuery = "";
     pipelineDebugAPI = {
       /**
        * Get raw run history for programmatic access.
@@ -750,16 +912,20 @@ var init_PipelineDebugger = __esm({
           const mode = reason.match(/mode=([^;]+)/)?.[1] ?? "unknown";
           const blocked = reason.match(/blocked=([^;]+)/)?.[1] ?? "unknown";
           const blockedTargets = reason.match(/blockedTargets=([^;]+)/)?.[1] ?? "none";
+          const supportCard = reason.match(/supportCard=([^;]+)/)?.[1] ?? "none";
           const supportTags = reason.match(/supportTags=([^;]+)/)?.[1] ?? "none";
           const multiplier = reason.match(/multiplier=([^;]+)/)?.[1] ?? "unknown";
+          const supportSource = mode === "discovered-support" ? "discovered" : mode === "support" ? "authored" : "n/a";
           return {
             group: parsedGroup,
             mode,
+            supportSource,
             cardId: card.cardId,
             selected: card.selected ? "yes" : "no",
             finalScore: card.finalScore.toFixed(3),
             blocked,
             blockedTargets,
+            supportCard,
             supportTags,
             multiplier
           };
@@ -775,6 +941,8 @@ var init_PipelineDebugger = __esm({
         const selectedRows = rows.filter((r) => r.selected === "yes");
         const blockedTargetSet = /* @__PURE__ */ new Set();
         const supportTagSet = /* @__PURE__ */ new Set();
+        const authoredSupportSet = /* @__PURE__ */ new Set();
+        const discoveredSupportSet = /* @__PURE__ */ new Set();
         for (const row of rows) {
           if (row.blockedTargets && row.blockedTargets !== "none") {
             row.blockedTargets.split("|").filter(Boolean).forEach((t) => blockedTargetSet.add(t));
@@ -782,6 +950,13 @@ var init_PipelineDebugger = __esm({
           if (row.supportTags && row.supportTags !== "none") {
             row.supportTags.split("|").filter(Boolean).forEach((t) => supportTagSet.add(t));
           }
+          if (row.supportCard && row.supportCard !== "none") {
+            if (row.supportSource === "discovered") {
+              discoveredSupportSet.add(row.supportCard);
+            } else if (row.supportSource === "authored") {
+              authoredSupportSet.add(row.supportCard);
+            }
+          }
         }
         logger.info(`Prescribed cards in run: ${rows.length}`);
         logger.info(`Selected prescribed cards: ${selectedRows.length}`);
@@ -791,6 +966,12 @@ var init_PipelineDebugger = __esm({
         logger.info(
           `Resolved support tags referenced: ${supportTagSet.size > 0 ? [...supportTagSet].join(", ") : "none"}`
         );
+        logger.info(
+          `Authored support cards emitted: ${authoredSupportSet.size > 0 ? [...authoredSupportSet].join(", ") : "none"}`
+        );
+        logger.info(
+          `Discovered support cards emitted: ${discoveredSupportSet.size > 0 ? [...discoveredSupportSet].join(", ") : "none"}`
+        );
         console.groupEnd();
       },
       /**
@@ -925,6 +1106,39 @@ var init_PipelineDebugger = __esm({
           Object.fromEntries(entries.map(([tag, data]) => [tag, { score: Math.round(data.score), count: data.count }]))
         );
       },
+      /**
+       * Toggle the full-screen UI debugger.
+       */
+      ui() {
+        if (_uiContainer) {
+          document.body.removeChild(_uiContainer);
+          _uiContainer = null;
+          return;
+        }
+        _uiContainer = document.createElement("div");
+        _uiContainer.id = "sk-pipeline-debugger";
+        document.body.appendChild(_uiContainer);
+        if (_selectedRunIndex === null && runHistory.length > 0) {
+          _selectedRunIndex = 0;
+        }
+        renderUI();
+      },
+      /**
+       * Internal UI helpers
+       * @internal
+       */
+      _selectRun(index) {
+        _selectedRunIndex = index;
+        renderUI();
+      },
+      /**
+       * Internal UI helpers
+       * @internal
+       */
+      _setSearch(query) {
+        _cardSearchQuery = query;
+        renderUI();
+      },
       /**
        * Show help.
        */
@@ -933,6 +1147,7 @@ var init_PipelineDebugger = __esm({
 \u{1F527} Pipeline Debug API
 
 Commands:
+  .ui()                  Toggle full-screen UI debugger
   .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
@@ -949,6 +1164,7 @@ Commands:
   .help()                Show this help message
 
 Example:
+  window.skuilder.pipeline.ui()
   window.skuilder.pipeline.showLastRun()
   window.skuilder.pipeline.showRun(1)
   await window.skuilder.pipeline.diagnoseCardSpace()
@@ -1111,7 +1327,7 @@ var init_CompositeGenerator = __esm({
         for (const [, items] of byCardId) {
           const cards2 = items.map((i) => i.card);
           const aggregatedScore = this.aggregateScores(items);
-          const finalScore = Math.min(1, aggregatedScore);
+          const finalScore = Math.max(0, aggregatedScore);
           const mergedProvenance = cards2.flatMap((c) => c.provenance);
           const initialScore = cards2[0].score;
           const action = finalScore > initialScore ? "boosted" : finalScore < initialScore ? "penalized" : "passed";
@@ -1308,10 +1524,26 @@ function matchesTagPattern(tag, pattern) {
   const re = new RegExp(`^${escaped}$`);
   return re.test(tag);
 }
+function extractWordStem(cardId) {
+  for (const prefix of ["c-ml-", "c-ws-", "c-spelling-"]) {
+    if (cardId.startsWith(prefix)) {
+      const rest = cardId.slice(prefix.length);
+      const lastDash = rest.lastIndexOf("-");
+      return lastDash > 0 ? rest.slice(0, lastDash) : rest;
+    }
+  }
+  return cardId;
+}
+function shuffleInPlace(arr) {
+  for (let i = arr.length - 1; i > 0; i--) {
+    const j = Math.floor(Math.random() * (i + 1));
+    [arr[i], arr[j]] = [arr[j], arr[i]];
+  }
+}
 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 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, DISCOVERED_SUPPORT_SCORE, MAX_TARGET_MULTIPLIER, MAX_SUPPORT_MULTIPLIER, PRESCRIBED_DEBUG_VERSION, PrescribedCardsGenerator;
 var init_prescribed = __esm({
   "src/core/navigators/generators/prescribed.ts"() {
     "use strict";
@@ -1324,11 +1556,10 @@ var init_prescribed = __esm({
     DEFAULT_MIN_COUNT = 3;
     BASE_TARGET_SCORE = 1;
     BASE_SUPPORT_SCORE = 0.8;
+    DISCOVERED_SUPPORT_SCORE = 12;
     MAX_TARGET_MULTIPLIER = 8;
     MAX_SUPPORT_MULTIPLIER = 4;
-    LOCKED_TAG_PREFIXES = ["concept:"];
-    LESSON_GATE_PENALTY_TAG_HINT = "concept:";
-    PRESCRIBED_DEBUG_VERSION = "testversion-prescribed-v2";
+    PRESCRIBED_DEBUG_VERSION = "testversion-prescribed-v3";
     PrescribedCardsGenerator = class extends ContentNavigator {
       name;
       config;
@@ -1364,6 +1595,20 @@ var init_prescribed = __esm({
         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 courseTagDocs = await this.course.getCourseTagStubs().catch(
+          () => ({
+            rows: [],
+            offset: 0,
+            total_rows: 0
+          })
+        );
+        const cardsByTag = /* @__PURE__ */ new Map();
+        for (const row of courseTagDocs.rows ?? []) {
+          const tagDoc = row.doc;
+          if (tagDoc?.name && Array.isArray(tagDoc.taggedCards)) {
+            cardsByTag.set(tagDoc.name, [...tagDoc.taggedCards]);
+          }
+        }
         const nextState = {
           updatedAt: isoNow(),
           groups: {}
@@ -1378,11 +1623,31 @@ var init_prescribed = __esm({
             activeIds,
             seenIds,
             tagsByCard,
+            cardsByTag,
             hierarchyConfigs,
             userTagElo,
             userGlobalElo
           });
           groupRuntimes.push(runtime);
+          logger.info(
+            `[Prescribed] Group '${group.id}': ${group.targetCardIds.length} targets total, ${runtime.encounteredTargets.size} encountered, ${runtime.pendingTargets.length} pending (${runtime.surfaceableTargets.length} surfaceable, ${runtime.blockedTargets.length} blocked), ${runtime.supportCandidates.length} authored support candidates, ${runtime.discoveredSupportCandidates.length} discovered support candidates, pressure=${runtime.pressureMultiplier.toFixed(2)}`
+          );
+          if (runtime.blockedTargets.length > 0) {
+            logger.info(
+              `[Prescribed] Group '${group.id}' blocked targets: ${runtime.blockedTargets.join(", ")}`
+            );
+            logger.info(
+              `[Prescribed] Group '${group.id}' support tags needed: ${runtime.supportTags.join(", ") || "(none)"}`
+            );
+            logger.info(
+              `[Prescribed] Group '${group.id}' escalation mode: ` + (runtime.supportCandidates.length > 0 ? "direct-support" : runtime.discoveredSupportCandidates.length > 0 ? "inserted-support-candidates" : "boost-only")
+            );
+            if (runtime.discoveredSupportCandidates.length > 0) {
+              logger.info(
+                `[Prescribed] Group '${group.id}' discovered support candidates: ${runtime.discoveredSupportCandidates.join(", ")}`
+              );
+            }
+          }
           nextState.groups[group.id] = this.buildNextGroupState(runtime, progress.groups[group.id]);
           const directCards = this.buildDirectTargetCards(
             runtime,
@@ -1394,15 +1659,30 @@ var init_prescribed = __esm({
             courseId,
             emittedIds
           );
-          emitted.push(...directCards, ...supportCards);
+          const discoveredSupportCards = this.buildDiscoveredSupportCards(
+            runtime,
+            courseId,
+            emittedIds
+          );
+          emitted.push(...directCards, ...supportCards, ...discoveredSupportCards);
         }
         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 (hints) {
+          const tagEntries = Object.entries(hints.boostTags ?? {});
+          logger.info(
+            `[Prescribed] Emitting ${tagEntries.length} boost hint(s): ` + tagEntries.map(([tag, mult]) => `${tag}\xD7${mult.toFixed(1)}`).join(", ")
+          );
+        } else {
+          logger.info("[Prescribed] No hints to emit (no blocked targets or no support tags)");
+        }
         if (emitted.length === 0) {
-          logger.debug("[Prescribed] No prescribed targets/support emitted this run");
+          logger.info(
+            "[Prescribed] 0 cards emitted (all targets blocked, authored/discovered support candidates exhausted)" + (hints ? " \u2014 boost hints emitted but may not survive filters" : "")
+          );
           await this.putStrategyState(nextState).catch((e) => {
             logger.debug(`[Prescribed] Failed to persist empty-state update: ${e}`);
           });
@@ -1435,7 +1715,7 @@ var init_prescribed = __esm({
           logger.debug(`[Prescribed] Failed to persist prescribed progress: ${e}`);
         });
         logger.info(
-          `[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)`
+          `[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, ${finalCards.filter((c) => c.provenance[0]?.reason.includes("mode=discovered-support")).length} discovered support)`
         );
         return hints ? { cards: finalCards, hints } : { cards: finalCards };
       }
@@ -1465,9 +1745,15 @@ var init_prescribed = __esm({
           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") : []),
+            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,
@@ -1484,7 +1770,7 @@ var init_prescribed = __esm({
       }
       async loadHierarchyConfigs() {
         try {
-          const strategies = await this.course.getNavigationStrategies();
+          const strategies = await this.course.getAllNavigationStrategies();
           return strategies.filter((s) => s.implementingClass === "hierarchyDefinition").map((s) => {
             try {
               const parsed = JSON.parse(s.serializedData);
@@ -1507,6 +1793,7 @@ var init_prescribed = __esm({
           activeIds,
           seenIds,
           tagsByCard,
+          cardsByTag,
           hierarchyConfigs,
           userTagElo,
           userGlobalElo
@@ -1570,6 +1857,22 @@ var init_prescribed = __esm({
             [...supportTags]
           )
         ]).filter((id) => !activeIds.has(id) && !seenIds.has(id));
+        const discoveredSupportCandidates = blockedTargets.length > 0 && supportTags.size > 0 && supportCandidates.length === 0 ? this.findDiscoveredSupportCards({
+          supportTags: [...supportTags],
+          cardsByTag,
+          activeIds,
+          seenIds,
+          excludedIds: /* @__PURE__ */ new Set([
+            ...group.targetCardIds,
+            ...group.supportCardIds ?? []
+          ]),
+          limit: group.maxSupportCardsPerRun ?? DEFAULT_MAX_SUPPORT_PER_RUN
+        }) : [];
+        if (blockedTargets.length > 0 && supportTags.size > 0 && discoveredSupportCandidates.length === 0) {
+          logger.info(
+            `[Prescribed] Group '${group.id}' discovered 0 broader support candidates (blocked=${blockedTargets.length}; authoredSupport=${supportCandidates.length})`
+          );
+        }
         const sessionsSinceSurfaced = priorState?.sessionsSinceSurfaced ?? 0;
         const freshnessWindow = group.freshnessWindowSessions ?? DEFAULT_FRESHNESS_WINDOW;
         const staleSessions = Math.max(0, sessionsSinceSurfaced - freshnessWindow);
@@ -1583,6 +1886,7 @@ var init_prescribed = __esm({
           surfaceableTargets,
           targetTags,
           supportCandidates,
+          discoveredSupportCandidates,
           supportTags: [...supportTags],
           pressureMultiplier,
           supportMultiplier,
@@ -1653,6 +1957,33 @@ var init_prescribed = __esm({
         }
         return cards;
       }
+      buildDiscoveredSupportCards(runtime, courseId, emittedIds) {
+        if (runtime.blockedTargets.length === 0 || runtime.discoveredSupportCandidates.length === 0) {
+          return [];
+        }
+        const maxSupport = runtime.group.maxSupportCardsPerRun ?? DEFAULT_MAX_SUPPORT_PER_RUN;
+        const supportIds = runtime.discoveredSupportCandidates.filter((id) => !emittedIds.has(id)).slice(0, maxSupport);
+        const cards = [];
+        for (const cardId of supportIds) {
+          emittedIds.add(cardId);
+          cards.push({
+            cardId,
+            courseId,
+            score: DISCOVERED_SUPPORT_SCORE * runtime.supportMultiplier,
+            provenance: [
+              {
+                strategy: "prescribed",
+                strategyName: this.strategyName || this.name,
+                strategyId: this.strategyId || "NAVIGATION_STRATEGY-prescribed",
+                action: "generated",
+                score: DISCOVERED_SUPPORT_SCORE * runtime.supportMultiplier,
+                reason: `mode=discovered-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 [];
@@ -1675,6 +2006,40 @@ var init_prescribed = __esm({
         }
         return [...candidates];
       }
+      findDiscoveredSupportCards(args) {
+        const { supportTags, cardsByTag, activeIds, seenIds, excludedIds, limit } = args;
+        const byCardId = /* @__PURE__ */ new Map();
+        for (const supportTag of supportTags) {
+          const taggedCards = cardsByTag.get(supportTag) ?? [];
+          for (const cardId of taggedCards) {
+            if (activeIds.has(cardId) || seenIds.has(cardId) || excludedIds.has(cardId)) {
+              continue;
+            }
+            const existing = byCardId.get(cardId);
+            if (existing) {
+              existing.matches += 1;
+            } else {
+              byCardId.set(cardId, { cardId, matches: 1 });
+            }
+          }
+        }
+        const candidates = [...byCardId.values()].sort((a, b) => b.matches - a.matches || a.cardId.localeCompare(b.cardId));
+        const usedStems = /* @__PURE__ */ new Set();
+        const diverse = [];
+        const deferred = [];
+        for (const entry of candidates) {
+          const stem = extractWordStem(entry.cardId);
+          if (!usedStems.has(stem)) {
+            usedStems.add(stem);
+            diverse.push(entry);
+          } else {
+            deferred.push(entry);
+          }
+        }
+        shuffleInPlace(diverse);
+        shuffleInPlace(deferred);
+        return [...diverse, ...deferred].slice(0, limit).map((entry) => entry.cardId);
+      }
       resolveBlockedSupportTags(targetTags, hierarchyConfigs, userTagElo, userGlobalElo, hierarchyWalkEnabled, maxDepth) {
         const supportTags = /* @__PURE__ */ new Set();
         let blocked = false;
@@ -1720,7 +2085,6 @@ var init_prescribed = __esm({
       }
       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) {
@@ -1748,9 +2112,6 @@ var init_prescribed = __esm({
           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;
@@ -3296,6 +3657,32 @@ var init_Pipeline = __esm({
         cards = await this.hydrateTags(cards);
         const tHydrate = performance.now();
         const allCardsBeforeFiltering = [...cards];
+        const pendingHints = this._ephemeralHints;
+        if (pendingHints?.requireCards?.length) {
+          const poolIds = new Set(allCardsBeforeFiltering.map((c) => c.cardId));
+          const missingIds = pendingHints.requireCards.filter(
+            (p) => !p.includes("*") && !poolIds.has(p)
+          );
+          if (missingIds.length > 0) {
+            const fetchedTags = await this.course.getAppliedTagsBatch(missingIds);
+            const courseId = this.course.getCourseID();
+            for (const cardId of missingIds) {
+              allCardsBeforeFiltering.push({
+                cardId,
+                courseId,
+                score: 1,
+                tags: fetchedTags.get(cardId) ?? [],
+                provenance: []
+              });
+            }
+            logger.info(
+              `[Pipeline] Pre-fetched ${missingIds.length} required card(s) into pool: ${missingIds.join(", ")}`
+            );
+          }
+        }
+        const prescribedIds = new Set(
+          cards.filter((c) => c.provenance.some((p) => p.strategy === "prescribed")).map((c) => c.cardId)
+        );
         const filterImpacts = [];
         for (const filter of this.filters) {
           const beforeCount = cards.length;
@@ -3310,6 +3697,17 @@ var init_Pipeline = __esm({
             else passed++;
           }
           filterImpacts.push({ name: filter.name, boosted, penalized, passed, removed });
+          if (prescribedIds.size > 0) {
+            const survivingIds = new Set(cards.map((c) => c.cardId));
+            const killedPrescribed = [...prescribedIds].filter((id) => !survivingIds.has(id));
+            const zeroedPrescribed = cards.filter((c) => prescribedIds.has(c.cardId) && c.score === 0).map((c) => c.cardId);
+            if (killedPrescribed.length > 0 || zeroedPrescribed.length > 0) {
+              logger.info(
+                `[Pipeline] Filter '${filter.name}' impact on prescribed cards: ` + (killedPrescribed.length > 0 ? `removed=[${killedPrescribed.join(", ")}] ` : "") + (zeroedPrescribed.length > 0 ? `zeroed=[${zeroedPrescribed.join(", ")}]` : "")
+              );
+              killedPrescribed.forEach((id) => prescribedIds.delete(id));
+            }
+          }
           logger.debug(`[Pipeline] Filter '${filter.name}': ${beforeScores.size} \u2192 ${cards.length} cards (\u2191${boosted} \u2193${penalized} =${passed})`);
         }
         cards = cards.filter((c) => c.score > 0);
@@ -3346,7 +3744,8 @@ var init_Pipeline = __esm({
             filterImpacts,
             cards,
             result,
-            context.userElo
+            context.userElo,
+            hints ?? void 0
           );
           captureRun(report);
         } catch (e) {
@@ -3456,13 +3855,27 @@ var init_Pipeline = __esm({
           }
         }
         const cardIds = new Set(cards.map((c) => c.cardId));
+        const cardMap = new Map(cards.map((c) => [c.cardId, c]));
         const hintLabel = hints._label ? `Replan Hint (${hints._label})` : "Replan Hint";
-        const inject = (card, reason) => {
-          if (!cardIds.has(card.cardId)) {
-            const floorScore = Math.max(card.score, 1);
+        const applyRequirement = (card, reason) => {
+          const mandatoryScore = Number.POSITIVE_INFINITY;
+          const existing = cardMap.get(card.cardId);
+          if (existing) {
+            if (existing.score < mandatoryScore) {
+              existing.score = mandatoryScore;
+              existing.provenance.push({
+                strategy: "ephemeralHint",
+                strategyId: "ephemeral-hint",
+                strategyName: hintLabel,
+                action: "boosted",
+                score: mandatoryScore,
+                reason: `${reason} (upgrade to mandatory score)`
+              });
+            }
+          } else {
             cards.push({
               ...card,
-              score: floorScore,
+              score: mandatoryScore,
               provenance: [
                 ...card.provenance,
                 {
@@ -3470,25 +3883,41 @@ var init_Pipeline = __esm({
                   strategyId: "ephemeral-hint",
                   strategyName: hintLabel,
                   action: "boosted",
-                  score: floorScore,
+                  score: mandatoryScore,
                   reason
                 }
               ]
             });
             cardIds.add(card.cardId);
+            cardMap.set(card.cardId, cards[cards.length - 1]);
           }
         };
         if (hints.requireCards?.length) {
           for (const pattern of hints.requireCards) {
+            for (const cardId of cardIds) {
+              if (globMatch(cardId, pattern)) {
+                applyRequirement(cardMap.get(cardId), `requireCard ${pattern}`);
+              }
+            }
             for (const card of allCards) {
-              if (globMatch(card.cardId, pattern)) inject(card, `requireCard ${pattern}`);
+              if (globMatch(card.cardId, pattern)) {
+                applyRequirement(card, `requireCard ${pattern}`);
+              }
             }
           }
         }
         if (hints.requireTags?.length) {
           for (const pattern of hints.requireTags) {
+            for (const cardId of cardIds) {
+              const card = cardMap.get(cardId);
+              if (cardMatchesTagPattern(card, pattern)) {
+                applyRequirement(card, `requireTag ${pattern}`);
+              }
+            }
             for (const card of allCards) {
-              if (cardMatchesTagPattern(card, pattern)) inject(card, `requireTag ${pattern}`);
+              if (cardMatchesTagPattern(card, pattern)) {
+                applyRequirement(card, `requireTag ${pattern}`);
+              }
             }
           }
         }