@vue-skuilder/db 0.2.4 → 0.2.7

package/dist/impl/couch/index.mjs

@@ -621,6 +621,95 @@ var init_courseLookupDB = __esm({
   }
 });
 
+// src/core/navigators/diversityRerank.ts
+var diversityRerank_exports = {};
+__export(diversityRerank_exports, {
+  DIVERSITY_FLOOR: () => DIVERSITY_FLOOR,
+  DIVERSITY_STRENGTH: () => DIVERSITY_STRENGTH,
+  diversityRerank: () => diversityRerank
+});
+function diversityRerank(cards, opts = {}) {
+  const strength = opts.strength ?? DIVERSITY_STRENGTH;
+  const floor = opts.floor ?? DIVERSITY_FLOOR;
+  const n = cards.length;
+  if (n <= 1) return cards;
+  const df = /* @__PURE__ */ new Map();
+  for (const card of cards) {
+    for (const tag of card.tags ?? []) {
+      df.set(tag, (df.get(tag) ?? 0) + 1);
+    }
+  }
+  const idf = /* @__PURE__ */ new Map();
+  for (const [tag, freq] of df) {
+    idf.set(tag, Math.log(n / freq));
+  }
+  const remaining = [...cards];
+  const emittedCount = /* @__PURE__ */ new Map();
+  const out = [];
+  const repetitionLoad = (card) => {
+    let load = 0;
+    for (const tag of card.tags ?? []) {
+      const seen = emittedCount.get(tag);
+      if (seen) load += (idf.get(tag) ?? 0) * seen;
+    }
+    return load;
+  };
+  while (remaining.length > 0) {
+    let bestIdx = 0;
+    let bestValue = -Infinity;
+    let bestPenalty = 1;
+    let bestLoad = 0;
+    for (let i = 0; i < remaining.length; i++) {
+      const card = remaining[i];
+      const load = repetitionLoad(card);
+      const penalty = load > 0 ? Math.max(floor, 1 / (1 + strength * load)) : 1;
+      const value = card.score * penalty;
+      if (value > bestValue) {
+        bestValue = value;
+        bestIdx = i;
+        bestPenalty = penalty;
+        bestLoad = load;
+      }
+    }
+    const [picked] = remaining.splice(bestIdx, 1);
+    if (Number.isFinite(picked.score) && bestPenalty < 1) {
+      const newScore = picked.score * bestPenalty;
+      out.push({
+        ...picked,
+        score: newScore,
+        provenance: [
+          ...picked.provenance,
+          {
+            strategy: STRATEGY,
+            strategyId: STRATEGY_ID,
+            strategyName: STRATEGY_NAME,
+            action: "penalized",
+            score: newScore,
+            reason: `repeated tags (load ${bestLoad.toFixed(2)}) \u2192 \xD7${bestPenalty.toFixed(2)}`
+          }
+        ]
+      });
+    } else {
+      out.push(picked);
+    }
+    for (const tag of picked.tags ?? []) {
+      emittedCount.set(tag, (emittedCount.get(tag) ?? 0) + 1);
+    }
+  }
+  return out;
+}
+var DIVERSITY_STRENGTH, DIVERSITY_FLOOR, STRATEGY, STRATEGY_ID, STRATEGY_NAME;
+var init_diversityRerank = __esm({
+  "src/core/navigators/diversityRerank.ts"() {
+    "use strict";
+    DIVERSITY_STRENGTH = 0.6;
+    DIVERSITY_FLOOR = 0.3;
+    STRATEGY = "diversityRerank";
+    STRATEGY_ID = "DIVERSITY_RERANK";
+    STRATEGY_NAME = "Diversity Re-rank";
+  }
+});
+
 // src/core/navigators/PipelineDebugger.ts
 var PipelineDebugger_exports = {};
 __export(PipelineDebugger_exports, {
@@ -1689,12 +1778,13 @@ __export(elo_exports, {
   default: () => ELONavigator
 });
 import { toCourseElo as toCourseElo2 } from "@vue-skuilder/common";
-var ELONavigator;
+var ELO_RELEVANCE_SIGMA, ELONavigator;
 var init_elo = __esm({
   "src/core/navigators/generators/elo.ts"() {
     "use strict";
     init_navigators();
     init_logger();
+    ELO_RELEVANCE_SIGMA = 300;
     ELONavigator = class extends ContentNavigator {
       /** Human-readable name for CardGenerator interface */
       name;
@@ -1734,8 +1824,8 @@ var init_elo = __esm({
         const scored = newCards.map((c) => {
           const cardElo = c.elo ?? 1e3;
           const distance = Math.abs(cardElo - userGlobalElo);
-          const rawScore = Math.max(0, 1 - distance / 500);
-          const samplingKey = rawScore > 0 ? Math.random() ** (1 / rawScore) : 0;
+          const relevance = Math.exp(-((distance / ELO_RELEVANCE_SIGMA) ** 2));
+          const samplingKey = relevance * (0.5 + 0.5 * Math.random());
           return {
             cardId: c.cardID,
             courseId: c.courseID,
@@ -1747,7 +1837,7 @@ var init_elo = __esm({
                 strategyId: this.strategyId || "NAVIGATION_STRATEGY-ELO-default",
                 action: "generated",
                 score: samplingKey,
-                reason: `ELO distance ${Math.round(distance)} (card: ${Math.round(cardElo)}, user: ${Math.round(userGlobalElo)}), raw ${rawScore.toFixed(3)}, key ${samplingKey.toFixed(3)}`
+                reason: `ELO distance ${Math.round(distance)} (card: ${Math.round(cardElo)}, user: ${Math.round(userGlobalElo)}), relevance ${relevance.toFixed(3)}, key ${samplingKey.toFixed(3)}`
               }
             ]
           };
@@ -1815,7 +1905,7 @@ function shuffleInPlace(arr) {
 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, DISCOVERED_SUPPORT_SCORE, MAX_TARGET_MULTIPLIER, MAX_SUPPORT_MULTIPLIER, PRESCRIBED_DEBUG_VERSION, PrescribedCardsGenerator;
+var DEFAULT_FRESHNESS_WINDOW, DEFAULT_MAX_DIRECT_PER_RUN, DEFAULT_MAX_SUPPORT_PER_RUN, DEFAULT_HIERARCHY_DEPTH, DEFAULT_MIN_COUNT, DEFAULT_PRACTICE_MIN_COUNT, DEFAULT_MAX_PRACTICE_PER_RUN, BASE_TARGET_SCORE, BASE_SUPPORT_SCORE, DISCOVERED_SUPPORT_SCORE, BASE_PRACTICE_SCORE, MAX_TARGET_MULTIPLIER, MAX_SUPPORT_MULTIPLIER, PRESCRIBED_DEBUG_VERSION, PrescribedCardsGenerator;
 var init_prescribed = __esm({
   "src/core/navigators/generators/prescribed.ts"() {
     "use strict";
@@ -1826,9 +1916,12 @@ var init_prescribed = __esm({
     DEFAULT_MAX_SUPPORT_PER_RUN = 3;
     DEFAULT_HIERARCHY_DEPTH = 2;
     DEFAULT_MIN_COUNT = 3;
+    DEFAULT_PRACTICE_MIN_COUNT = 3;
+    DEFAULT_MAX_PRACTICE_PER_RUN = 4;
     BASE_TARGET_SCORE = 1;
     BASE_SUPPORT_SCORE = 0.8;
     DISCOVERED_SUPPORT_SCORE = 12;
+    BASE_PRACTICE_SCORE = 1;
     MAX_TARGET_MULTIPLIER = 8;
     MAX_SUPPORT_MULTIPLIER = 4;
     PRESCRIBED_DEBUG_VERSION = "testversion-prescribed-v3";
@@ -1936,7 +2029,18 @@ var init_prescribed = __esm({
             courseId,
             emittedIds
           );
-          emitted.push(...directCards, ...supportCards, ...discoveredSupportCards);
+          const practiceCards = this.buildPracticeCards({
+            group,
+            courseId,
+            emittedIds,
+            cardsByTag,
+            hierarchyConfigs,
+            userTagElo,
+            userGlobalElo,
+            activeIds,
+            seenIds
+          });
+          emitted.push(...directCards, ...supportCards, ...discoveredSupportCards, ...practiceCards);
         }
         const hintSummary = this.buildSupportHintSummary(groupRuntimes);
         const hints = Object.keys(hintSummary.boostTags).length > 0 ? {
@@ -1964,6 +2068,7 @@ var init_prescribed = __esm({
         const surfacedByGroup = /* @__PURE__ */ new Map();
         for (const card of finalCards) {
           const prov = card.provenance[0];
+          if (prov?.reason.includes("mode=practice")) continue;
           const groupId = prov?.reason.match(/group=([^;]+)/)?.[1];
           const mode = prov?.reason.includes("mode=support") ? "supportIds" : "targetIds";
           if (!groupId) continue;
@@ -2033,7 +2138,12 @@ var init_prescribed = __esm({
               enabled: raw.hierarchyWalk?.enabled !== false,
               maxDepth: typeof raw.hierarchyWalk?.maxDepth === "number" ? raw.hierarchyWalk.maxDepth : DEFAULT_HIERARCHY_DEPTH
             },
-            retireOnEncounter: raw.retireOnEncounter !== false
+            retireOnEncounter: raw.retireOnEncounter !== false,
+            practiceTagPatterns: dedupe(
+              Array.isArray(raw.practiceTagPatterns) ? raw.practiceTagPatterns.filter((v) => typeof v === "string") : []
+            ),
+            practiceMinCount: typeof raw.practiceMinCount === "number" ? raw.practiceMinCount : DEFAULT_PRACTICE_MIN_COUNT,
+            maxPracticeCardsPerRun: typeof raw.maxPracticeCardsPerRun === "number" ? raw.maxPracticeCardsPerRun : DEFAULT_MAX_PRACTICE_PER_RUN
           })).filter((g) => g.targetCardIds.length > 0);
           return { groups };
         } catch {
@@ -2256,6 +2366,92 @@ var init_prescribed = __esm({
         }
         return cards;
       }
+      /**
+       * Emit drill cards for *unlocked-but-under-practiced* skills.
+       *
+       * For each course tag matching the group's `practiceTagPatterns` that is both
+       * unlocked (all hierarchy prerequisites met — i.e. the learner has been
+       * introduced to it) and under-practiced (per-tag attempt count below
+       * `practiceMinCount`), this resolves cards carrying that tag and emits them
+       * into the candidate pool. It exists because global-ELO retrieval
+       * systematically fails to fetch the (low-ELO) drill cards for a
+       * freshly-introduced skill — putting them in the pool here lets the pipeline's
+       * scoring + the durable per-skill boost order them. Ordering/emphasis is NOT
+       * this method's job; it only guarantees presence.
+       *
+       * Fully data-driven: the unlock relation comes from the hierarchy config and
+       * practice-status from per-tag ELO. No card-id or tag-namespace hard-coding.
+       */
+      buildPracticeCards(args) {
+        const {
+          group,
+          courseId,
+          emittedIds,
+          cardsByTag,
+          hierarchyConfigs,
+          userTagElo,
+          userGlobalElo,
+          activeIds,
+          seenIds
+        } = args;
+        const patterns = group.practiceTagPatterns ?? [];
+        if (patterns.length === 0) return [];
+        const practiceMinCount = group.practiceMinCount ?? DEFAULT_PRACTICE_MIN_COUNT;
+        const maxPractice = group.maxPracticeCardsPerRun ?? DEFAULT_MAX_PRACTICE_PER_RUN;
+        const practiceTags = [...cardsByTag.keys()].filter(
+          (tag) => patterns.some((p) => matchesTagPattern(tag, p)) && this.isUnlockedGatedSkill(tag, hierarchyConfigs, userTagElo, userGlobalElo) && (userTagElo[tag]?.count ?? 0) < practiceMinCount
+        );
+        if (practiceTags.length === 0) return [];
+        const practiceCardIds = this.findDiscoveredSupportCards({
+          supportTags: practiceTags,
+          cardsByTag,
+          activeIds,
+          seenIds,
+          excludedIds: emittedIds,
+          limit: maxPractice
+        });
+        if (practiceCardIds.length === 0) return [];
+        logger.info(
+          `[Prescribed] Group '${group.id}' practice: ${practiceTags.length} unlocked under-practiced skill(s), emitting ${practiceCardIds.length} drill card(s)`
+        );
+        const cards = [];
+        for (const cardId of practiceCardIds) {
+          emittedIds.add(cardId);
+          cards.push({
+            cardId,
+            courseId,
+            score: BASE_PRACTICE_SCORE,
+            provenance: [
+              {
+                strategy: "prescribed",
+                strategyName: this.strategyName || this.name,
+                strategyId: this.strategyId || "NAVIGATION_STRATEGY-prescribed",
+                action: "generated",
+                score: BASE_PRACTICE_SCORE,
+                reason: `mode=practice;group=${group.id};underPracticedSkills=${practiceTags.length};practiceTags=${practiceTags.slice(0, 8).join("|")}${practiceTags.length > 8 ? "|\u2026" : ""};testversion=${PRESCRIBED_DEBUG_VERSION}`
+              }
+            ]
+          });
+        }
+        return cards;
+      }
+      /**
+       * True for a skill that was *gated and is now reached*: it has at least one
+       * declared hierarchy prerequisite set, and every set is fully satisfied by the
+       * learner's per-tag ELO. This deliberately EXCLUDES tags with no prerequisites
+       * — an ungated tag was never "introduced" in the curricular sense, so it isn't
+       * a post-intro drill target (e.g. whole-word spelling tags that share the
+       * `gpc:exercise:*` prefix but have no intro gate). Those are left to normal
+       * ELO retrieval. This is the precise population the retrieval gap strands:
+       * just-unlocked, low-ELO skills.
+       */
+      isUnlockedGatedSkill(tag, hierarchyConfigs, userTagElo, userGlobalElo) {
+        const prereqSets = hierarchyConfigs.map((hierarchy) => hierarchy.prerequisites[tag]).filter((prereqs) => Array.isArray(prereqs) && prereqs.length > 0);
+        if (prereqSets.length === 0) return false;
+        return prereqSets.every(
+          (prereqs) => prereqs.every((pr) => this.isPrerequisiteMet(pr, userTagElo[pr.tag], userGlobalElo))
+        );
+      }
       findSupportCardsByTags(group, tagsByCard, supportTags) {
         if (supportTags.length === 0) {
           return [];
@@ -3804,7 +4000,7 @@ function logResultCards(cards) {
   for (let i = 0; i < cards.length; i++) {
     const c = cards[i];
     const tags = c.tags?.slice(0, 3).join(", ") || "";
-    const filters = c.provenance.filter((p) => p.strategy === "hierarchyDefinition" || p.strategy === "priorityDefinition" || p.strategy === "interferenceFilter" || p.strategy === "letterGating" || p.strategy === "ephemeralHint").map((p) => {
+    const filters = c.provenance.filter((p) => p.strategy === "hierarchyDefinition" || p.strategy === "priorityDefinition" || p.strategy === "interferenceFilter" || p.strategy === "letterGating" || p.strategy === "ephemeralHint" || p.strategy === "diversityRerank").map((p) => {
       const arrow = p.action === "boosted" ? "\u2191" : p.action === "penalized" ? "\u2193" : "=";
       return `${p.strategyName}${arrow}${p.score.toFixed(2)}`;
     }).join(" | ");
@@ -3835,6 +4031,7 @@ var init_Pipeline = __esm({
     init_logger();
     init_orchestration();
     init_PipelineDebugger();
+    init_diversityRerank();
     VERBOSE_RESULTS = true;
     Pipeline = class extends ContentNavigator {
       generator;
@@ -4008,6 +4205,7 @@ var init_Pipeline = __esm({
           this._ephemeralHints = null;
           cards = this.applyHints(cards, hints, allCardsBeforeFiltering);
         }
+        cards = diversityRerank(cards);
         cards.sort((a, b) => b.score - a.score);
         const tFilter = performance.now();
         const result = cards.slice(0, limit);
@@ -4576,6 +4774,7 @@ var init_3 = __esm({
       "./PipelineAssembler.ts": () => Promise.resolve().then(() => (init_PipelineAssembler(), PipelineAssembler_exports)),
       "./PipelineDebugger.ts": () => Promise.resolve().then(() => (init_PipelineDebugger(), PipelineDebugger_exports)),
       "./defaults.ts": () => Promise.resolve().then(() => (init_defaults(), defaults_exports)),
+      "./diversityRerank.ts": () => Promise.resolve().then(() => (init_diversityRerank(), diversityRerank_exports)),
       "./filters/WeightedFilter.ts": () => Promise.resolve().then(() => (init_WeightedFilter(), WeightedFilter_exports)),
       "./filters/eloDistance.ts": () => Promise.resolve().then(() => (init_eloDistance(), eloDistance_exports)),
       "./filters/hierarchyDefinition.ts": () => Promise.resolve().then(() => (init_hierarchyDefinition(), hierarchyDefinition_exports)),
@@ -4601,9 +4800,12 @@ var init_3 = __esm({
 var navigators_exports = {};
 __export(navigators_exports, {
   ContentNavigator: () => ContentNavigator,
+  DIVERSITY_FLOOR: () => DIVERSITY_FLOOR,
+  DIVERSITY_STRENGTH: () => DIVERSITY_STRENGTH,
   NavigatorRole: () => NavigatorRole,
   NavigatorRoles: () => NavigatorRoles,
   Navigators: () => Navigators,
+  diversityRerank: () => diversityRerank,
   getCardOrigin: () => getCardOrigin,
   getRegisteredNavigator: () => getRegisteredNavigator,
   getRegisteredNavigatorNames: () => getRegisteredNavigatorNames,
@@ -4687,6 +4889,7 @@ var navigatorRegistry, Navigators, NavigatorRole, NavigatorRoles, ContentNavigat
 var init_navigators = __esm({
   "src/core/navigators/index.ts"() {
     "use strict";
+    init_diversityRerank();
     init_PipelineDebugger();
     init_logger();
     init_();