@vue-skuilder/db 0.1.23 → 0.1.24

package/dist/index.js

@@ -5,6 +5,11 @@ var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __glob = (map) => (path2) => {
+  var fn = map[path2];
+  if (fn) return fn();
+  throw new Error("Module not found in bundle: " + path2);
+};
 var __esm = (fn, res) => function __init() {
   return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
 };
@@ -118,6 +123,8 @@ var init_types_legacy = __esm({
       DocType3["TAG"] = "TAG";
       DocType3["NAVIGATION_STRATEGY"] = "NAVIGATION_STRATEGY";
       DocType3["STRATEGY_STATE"] = "STRATEGY_STATE";
+      DocType3["USER_OUTCOME"] = "USER_OUTCOME";
+      DocType3["STRATEGY_LEARNING_STATE"] = "STRATEGY_LEARNING_STATE";
       return DocType3;
     })(DocType || {});
     DocTypePrefixes = {
@@ -132,7 +139,9 @@ var init_types_legacy = __esm({
       ["VIEW" /* VIEW */]: "VIEW",
       ["PEDAGOGY" /* PEDAGOGY */]: "PEDAGOGY",
       ["NAVIGATION_STRATEGY" /* NAVIGATION_STRATEGY */]: "NAVIGATION_STRATEGY",
-      ["STRATEGY_STATE" /* STRATEGY_STATE */]: "STRATEGY_STATE"
+      ["STRATEGY_STATE" /* STRATEGY_STATE */]: "STRATEGY_STATE",
+      ["USER_OUTCOME" /* USER_OUTCOME */]: "USER_OUTCOME",
+      ["STRATEGY_LEARNING_STATE" /* STRATEGY_LEARNING_STATE */]: "STRATEGY_LEARNING_STATE"
     };
   }
 });
@@ -854,870 +863,2295 @@ var init_courseLookupDB = __esm({
   }
 });
 
-// src/core/navigators/index.ts
-function getCardOrigin(card) {
-  if (card.provenance.length === 0) {
-    throw new Error("Card has no provenance - cannot determine origin");
-  }
-  const firstEntry = card.provenance[0];
-  const reason = firstEntry.reason.toLowerCase();
-  if (reason.includes("failed")) {
-    return "failed";
-  }
-  if (reason.includes("review")) {
-    return "review";
-  }
-  return "new";
-}
-function isGenerator(impl) {
-  return NavigatorRoles[impl] === "generator" /* GENERATOR */;
-}
-function isFilter(impl) {
-  return NavigatorRoles[impl] === "filter" /* FILTER */;
-}
-var Navigators, NavigatorRole, NavigatorRoles, ContentNavigator;
-var init_navigators = __esm({
-  "src/core/navigators/index.ts"() {
+// src/core/navigators/generators/CompositeGenerator.ts
+var CompositeGenerator_exports = {};
+__export(CompositeGenerator_exports, {
+  AggregationMode: () => AggregationMode,
+  default: () => CompositeGenerator
+});
+var AggregationMode, DEFAULT_AGGREGATION_MODE, FREQUENCY_BOOST_FACTOR, CompositeGenerator;
+var init_CompositeGenerator = __esm({
+  "src/core/navigators/generators/CompositeGenerator.ts"() {
     "use strict";
+    init_navigators();
     init_logger();
-    Navigators = /* @__PURE__ */ ((Navigators2) => {
-      Navigators2["ELO"] = "elo";
-      Navigators2["SRS"] = "srs";
-      Navigators2["HIERARCHY"] = "hierarchyDefinition";
-      Navigators2["INTERFERENCE"] = "interferenceMitigator";
-      Navigators2["RELATIVE_PRIORITY"] = "relativePriority";
-      Navigators2["USER_TAG_PREFERENCE"] = "userTagPreference";
-      return Navigators2;
-    })(Navigators || {});
-    NavigatorRole = /* @__PURE__ */ ((NavigatorRole2) => {
-      NavigatorRole2["GENERATOR"] = "generator";
-      NavigatorRole2["FILTER"] = "filter";
-      return NavigatorRole2;
-    })(NavigatorRole || {});
-    NavigatorRoles = {
-      ["elo" /* ELO */]: "generator" /* GENERATOR */,
-      ["srs" /* SRS */]: "generator" /* GENERATOR */,
-      ["hierarchyDefinition" /* HIERARCHY */]: "filter" /* FILTER */,
-      ["interferenceMitigator" /* INTERFERENCE */]: "filter" /* FILTER */,
-      ["relativePriority" /* RELATIVE_PRIORITY */]: "filter" /* FILTER */,
-      ["userTagPreference" /* USER_TAG_PREFERENCE */]: "filter" /* FILTER */
-    };
-    ContentNavigator = class {
-      /** User interface for this navigation session */
-      user;
-      /** Course interface for this navigation session */
-      course;
-      /** Human-readable name for this strategy instance (from ContentNavigationStrategyData.name) */
-      strategyName;
-      /** Unique document ID for this strategy instance (from ContentNavigationStrategyData._id) */
-      strategyId;
-      /**
-       * Constructor for standard navigators.
-       * Call this from subclass constructors to initialize common fields.
-       *
-       * Note: CompositeGenerator and Pipeline call super() without args, then set
-       * user/course fields directly if needed.
-       */
-      constructor(user, course, strategyData) {
-        this.user = user;
-        this.course = course;
-        if (strategyData) {
-          this.strategyName = strategyData.name;
-          this.strategyId = strategyData._id;
+    AggregationMode = /* @__PURE__ */ ((AggregationMode2) => {
+      AggregationMode2["MAX"] = "max";
+      AggregationMode2["AVERAGE"] = "average";
+      AggregationMode2["FREQUENCY_BOOST"] = "frequencyBoost";
+      return AggregationMode2;
+    })(AggregationMode || {});
+    DEFAULT_AGGREGATION_MODE = "frequencyBoost" /* FREQUENCY_BOOST */;
+    FREQUENCY_BOOST_FACTOR = 0.1;
+    CompositeGenerator = class _CompositeGenerator extends ContentNavigator {
+      /** Human-readable name for CardGenerator interface */
+      name = "Composite Generator";
+      generators;
+      aggregationMode;
+      constructor(generators, aggregationMode = DEFAULT_AGGREGATION_MODE) {
+        super();
+        this.generators = generators;
+        this.aggregationMode = aggregationMode;
+        if (generators.length === 0) {
+          throw new Error("CompositeGenerator requires at least one generator");
         }
+        logger.debug(
+          `[CompositeGenerator] Created with ${generators.length} generators, mode: ${aggregationMode}`
+        );
       }
-      // ============================================================================
-      // STRATEGY STATE HELPERS
-      // ============================================================================
-      //
-      // These methods allow strategies to persist their own state (user preferences,
-      // learned patterns, temporal tracking) in the user database.
-      //
-      // ============================================================================
       /**
-       * Unique key identifying this strategy for state storage.
+       * Creates a CompositeGenerator from strategy data.
        *
-       * Defaults to the constructor name (e.g., "UserTagPreferenceFilter").
-       * Override in subclasses if multiple instances of the same strategy type
-       * need separate state storage.
+       * This is a convenience factory for use by PipelineAssembler.
        */
-      get strategyKey() {
-        return this.constructor.name;
+      static async fromStrategies(user, course, strategies, aggregationMode = DEFAULT_AGGREGATION_MODE) {
+        const generators = await Promise.all(
+          strategies.map((s) => ContentNavigator.create(user, course, s))
+        );
+        return new _CompositeGenerator(generators, aggregationMode);
       }
       /**
-       * Get this strategy's persisted state for the current course.
+       * Get weighted cards from all generators, merge and deduplicate.
        *
-       * @returns The strategy's data payload, or null if no state exists
-       * @throws Error if user or course is not initialized
+       * Cards appearing in multiple generators receive a score boost.
+       * Provenance tracks which generators produced each card and how scores were aggregated.
+       *
+       * This method supports both the legacy signature (limit only) and the
+       * CardGenerator interface signature (limit, context).
+       *
+       * @param limit - Maximum number of cards to return
+       * @param context - GeneratorContext passed to child generators (required when called via Pipeline)
        */
-      async getStrategyState() {
-        if (!this.user || !this.course) {
+      async getWeightedCards(limit, context) {
+        if (!context) {
           throw new Error(
-            `Cannot get strategy state: navigator not properly initialized. Ensure user and course are provided to constructor.`
+            "CompositeGenerator.getWeightedCards requires a GeneratorContext. It should be called via Pipeline, not directly."
           );
         }
-        return this.user.getStrategyState(this.course.getCourseID(), this.strategyKey);
+        const results = await Promise.all(
+          this.generators.map((g) => g.getWeightedCards(limit, context))
+        );
+        const byCardId = /* @__PURE__ */ new Map();
+        results.forEach((cards, index) => {
+          const gen = this.generators[index];
+          let weight = gen.learnable?.weight ?? 1;
+          let deviation;
+          if (gen.learnable && !gen.staticWeight && context.orchestration) {
+            const strategyId = gen.strategyId;
+            if (strategyId) {
+              weight = context.orchestration.getEffectiveWeight(strategyId, gen.learnable);
+              deviation = context.orchestration.getDeviation(strategyId);
+            }
+          }
+          for (const card of cards) {
+            if (card.provenance.length > 0) {
+              card.provenance[0].effectiveWeight = weight;
+              card.provenance[0].deviation = deviation;
+            }
+            const existing = byCardId.get(card.cardId) || [];
+            existing.push({ card, weight });
+            byCardId.set(card.cardId, existing);
+          }
+        });
+        const merged = [];
+        for (const [, items] of byCardId) {
+          const cards = 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 action = finalScore > initialScore ? "boosted" : finalScore < initialScore ? "penalized" : "passed";
+          const reason = this.buildAggregationReason(items, finalScore);
+          merged.push({
+            ...cards[0],
+            score: finalScore,
+            provenance: [
+              ...mergedProvenance,
+              {
+                strategy: "composite",
+                strategyName: "Composite Generator",
+                strategyId: "COMPOSITE_GENERATOR",
+                action,
+                score: finalScore,
+                reason
+              }
+            ]
+          });
+        }
+        return merged.sort((a, b) => b.score - a.score).slice(0, limit);
       }
       /**
-       * Persist this strategy's state for the current course.
-       *
-       * @param data - The strategy's data payload to store
-       * @throws Error if user or course is not initialized
+       * Build human-readable reason for score aggregation.
        */
-      async putStrategyState(data) {
-        if (!this.user || !this.course) {
-          throw new Error(
-            `Cannot put strategy state: navigator not properly initialized. Ensure user and course are provided to constructor.`
-          );
+      buildAggregationReason(items, finalScore) {
+        const cards = items.map((i) => i.card);
+        const count = cards.length;
+        const scores = cards.map((c) => c.score.toFixed(2)).join(", ");
+        if (count === 1) {
+          const weightMsg = Math.abs(items[0].weight - 1) > 1e-3 ? ` (w=${items[0].weight.toFixed(2)})` : "";
+          return `Single generator, score ${finalScore.toFixed(2)}${weightMsg}`;
+        }
+        const strategies = cards.map((c) => c.provenance[0]?.strategy || "unknown").join(", ");
+        switch (this.aggregationMode) {
+          case "max" /* MAX */:
+            return `Max of ${count} generators (${strategies}): scores [${scores}] \u2192 ${finalScore.toFixed(2)}`;
+          case "average" /* AVERAGE */:
+            return `Weighted Avg of ${count} generators (${strategies}): scores [${scores}] \u2192 ${finalScore.toFixed(2)}`;
+          case "frequencyBoost" /* FREQUENCY_BOOST */: {
+            const totalWeight = items.reduce((sum, i) => sum + i.weight, 0);
+            const weightedSum = items.reduce((sum, i) => sum + i.card.score * i.weight, 0);
+            const avg = totalWeight > 0 ? weightedSum / totalWeight : 0;
+            const boost = 1 + FREQUENCY_BOOST_FACTOR * (count - 1);
+            return `Frequency boost from ${count} generators (${strategies}): w-avg ${avg.toFixed(2)} \xD7 ${boost.toFixed(2)} \u2192 ${finalScore.toFixed(2)}`;
+          }
+          default:
+            return `Aggregated from ${count} generators: ${finalScore.toFixed(2)}`;
         }
-        return this.user.putStrategyState(this.course.getCourseID(), this.strategyKey, data);
       }
       /**
-       * Factory method to create navigator instances dynamically.
-       *
-       * @param user - User interface
-       * @param course - Course interface
-       * @param strategyData - Strategy configuration document
-       * @returns the runtime object used to steer a study session.
+       * Aggregate scores from multiple generators for the same card.
        */
-      static async create(user, course, strategyData) {
-        const implementingClass = strategyData.implementingClass;
-        let NavigatorImpl;
-        const variations = [".ts", ".js", ""];
-        const dirs = ["filters", "generators"];
-        for (const ext of variations) {
-          for (const dir of dirs) {
-            const loadFrom = `./${dir}/${implementingClass}${ext}`;
-            try {
-              const module2 = await import(loadFrom);
-              NavigatorImpl = module2.default;
-              break;
-            } catch (e) {
-              logger.debug(`Failed to load extension from ${loadFrom}:`, e);
-            }
+      aggregateScores(items) {
+        const scores = items.map((i) => i.card.score);
+        switch (this.aggregationMode) {
+          case "max" /* MAX */:
+            return Math.max(...scores);
+          case "average" /* AVERAGE */: {
+            const totalWeight = items.reduce((sum, i) => sum + i.weight, 0);
+            if (totalWeight === 0) return 0;
+            const weightedSum = items.reduce((sum, i) => sum + i.card.score * i.weight, 0);
+            return weightedSum / totalWeight;
           }
+          case "frequencyBoost" /* FREQUENCY_BOOST */: {
+            const totalWeight = items.reduce((sum, i) => sum + i.weight, 0);
+            const weightedSum = items.reduce((sum, i) => sum + i.card.score * i.weight, 0);
+            const avg = totalWeight > 0 ? weightedSum / totalWeight : 0;
+            const frequencyBoost = 1 + FREQUENCY_BOOST_FACTOR * (items.length - 1);
+            return avg * frequencyBoost;
+          }
+          default:
+            return scores[0];
         }
-        if (!NavigatorImpl) {
-          throw new Error(`Could not load navigator implementation for: ${implementingClass}`);
-        }
-        return new NavigatorImpl(user, course, strategyData);
+      }
+    };
+  }
+});
+
+// src/core/navigators/generators/elo.ts
+var elo_exports = {};
+__export(elo_exports, {
+  default: () => ELONavigator
+});
+var import_common5, ELONavigator;
+var init_elo = __esm({
+  "src/core/navigators/generators/elo.ts"() {
+    "use strict";
+    init_navigators();
+    import_common5 = require("@vue-skuilder/common");
+    ELONavigator = class extends ContentNavigator {
+      /** Human-readable name for CardGenerator interface */
+      name;
+      constructor(user, course, strategyData) {
+        super(user, course, strategyData);
+        this.name = strategyData?.name || "ELO";
       }
       /**
-       * Get cards with suitability scores and provenance trails.
-       *
-       * **This is the PRIMARY API for navigation strategies.**
-       *
-       * Returns cards ranked by suitability score (0-1). Higher scores indicate
-       * better candidates for presentation. Each card includes a provenance trail
-       * documenting how strategies contributed to the final score.
+       * Get new cards with suitability scores based on ELO distance.
        *
-       * ## Implementation Required
-       * All navigation strategies MUST override this method. The base class does
-       * not provide a default implementation.
+       * Cards closer to user's ELO get higher scores.
+       * Score formula: max(0, 1 - distance / 500)
        *
-       * ## For Generators
-       * Override this method to generate candidates and compute scores based on
-       * your strategy's logic (e.g., ELO proximity, review urgency). Create the
-       * initial provenance entry with action='generated'.
+       * NOTE: This generator only handles NEW cards. Reviews are handled by
+       * SRSNavigator. Use CompositeGenerator to combine both.
        *
-       * ## For Filters
-       * Filters should implement the CardFilter interface instead and be composed
-       * via Pipeline. Filters do not directly implement getWeightedCards().
+       * This method supports both the legacy signature (limit only) and the
+       * CardGenerator interface signature (limit, context).
        *
-       * @param limit - Maximum cards to return
-       * @returns Cards sorted by score descending, with provenance trails
+       * @param limit - Maximum number of cards to return
+       * @param context - Optional GeneratorContext (used when called via Pipeline)
        */
-      async getWeightedCards(_limit) {
-        throw new Error(`${this.constructor.name} must implement getWeightedCards(). `);
+      async getWeightedCards(limit, context) {
+        let userGlobalElo;
+        if (context?.userElo !== void 0) {
+          userGlobalElo = context.userElo;
+        } else {
+          const courseReg = await this.user.getCourseRegDoc(this.course.getCourseID());
+          const userElo = (0, import_common5.toCourseElo)(courseReg.elo);
+          userGlobalElo = userElo.global.score;
+        }
+        const activeCards = await this.user.getActiveCards();
+        const newCards = (await this.course.getCardsCenteredAtELO(
+          { limit, elo: "user" },
+          (c) => !activeCards.some((ac) => c.cardID === ac.cardID)
+        )).map((c) => ({ ...c, status: "new" }));
+        const cardIds = newCards.map((c) => c.cardID);
+        const cardEloData = await this.course.getCardEloData(cardIds);
+        const scored = newCards.map((c, i) => {
+          const cardElo = cardEloData[i]?.global?.score ?? 1e3;
+          const distance = Math.abs(cardElo - userGlobalElo);
+          const score = Math.max(0, 1 - distance / 500);
+          return {
+            cardId: c.cardID,
+            courseId: c.courseID,
+            score,
+            provenance: [
+              {
+                strategy: "elo",
+                strategyName: this.strategyName || this.name,
+                strategyId: this.strategyId || "NAVIGATION_STRATEGY-ELO-default",
+                action: "generated",
+                score,
+                reason: `ELO distance ${Math.round(distance)} (card: ${Math.round(cardElo)}, user: ${Math.round(userGlobalElo)}), new card`
+              }
+            ]
+          };
+        });
+        scored.sort((a, b) => b.score - a.score);
+        return scored.slice(0, limit);
       }
     };
   }
 });
 
-// src/core/navigators/Pipeline.ts
-function logPipelineConfig(generator, filters) {
-  const filterList = filters.length > 0 ? "\n    - " + filters.map((f) => f.name).join("\n    - ") : " none";
-  logger.info(
-    `[Pipeline] Configuration:
-  Generator: ${generator.name}
-  Filters:${filterList}`
-  );
-}
-function logTagHydration(cards, tagsByCard) {
-  const totalTags = Array.from(tagsByCard.values()).reduce((sum, tags) => sum + tags.length, 0);
-  const cardsWithTags = Array.from(tagsByCard.values()).filter((tags) => tags.length > 0).length;
-  logger.debug(
-    `[Pipeline] Tag hydration: ${cards.length} cards, ${cardsWithTags} have tags (${totalTags} total tags) - single batch query`
-  );
-}
-function logExecutionSummary(generatorName, generatedCount, filterCount, finalCount, topScores) {
-  const scoreDisplay = topScores.length > 0 ? topScores.map((s) => s.toFixed(2)).join(", ") : "none";
-  logger.info(
-    `[Pipeline] Execution: ${generatorName} produced ${generatedCount} \u2192 ${filterCount} filters \u2192 ${finalCount} results (top scores: ${scoreDisplay})`
-  );
-}
-function logCardProvenance(cards, maxCards = 3) {
-  const cardsToLog = cards.slice(0, maxCards);
-  logger.debug(`[Pipeline] Provenance for top ${cardsToLog.length} cards:`);
-  for (const card of cardsToLog) {
-    logger.debug(`[Pipeline]   ${card.cardId} (final score: ${card.score.toFixed(3)}):`);
-    for (const entry of card.provenance) {
-      const scoreChange = entry.score.toFixed(3);
-      const action = entry.action.padEnd(9);
-      logger.debug(
-        `[Pipeline]     ${action} ${scoreChange} - ${entry.strategyName}: ${entry.reason}`
-      );
-    }
-  }
-}
-var import_common5, Pipeline;
-var init_Pipeline = __esm({
-  "src/core/navigators/Pipeline.ts"() {
+// src/core/navigators/generators/index.ts
+var generators_exports = {};
+var init_generators = __esm({
+  "src/core/navigators/generators/index.ts"() {
     "use strict";
-    import_common5 = require("@vue-skuilder/common");
-    init_navigators();
-    init_logger();
-    Pipeline = class extends ContentNavigator {
-      generator;
-      filters;
-      /**
-       * Create a new pipeline.
-       *
-       * @param generator - The generator (or CompositeGenerator) that produces candidates
-       * @param filters - Filters to apply sequentially (order doesn't matter for multipliers)
-       * @param user - User database interface
-       * @param course - Course database interface
-       */
-      constructor(generator, filters, user, course) {
-        super();
-        this.generator = generator;
-        this.filters = filters;
-        this.user = user;
-        this.course = course;
-        course.getCourseConfig().then((cfg) => {
-          logger.debug(`[pipeline] Crated pipeline for ${cfg.name}`);
-        }).catch((e) => {
-          logger.error(`[pipeline] Failed to lookup courseCfg: ${e}`);
-        });
-        logPipelineConfig(generator, filters);
-      }
-      /**
-       * Get weighted cards by running generator and applying filters.
-       *
-       * 1. Build shared context (user ELO, etc.)
-       * 2. Get candidates from generator (passing context)
-       * 3. Batch hydrate tags for all candidates
-       * 4. Apply each filter sequentially
-       * 5. Remove zero-score cards
-       * 6. Sort by score descending
-       * 7. Return top N
-       *
-       * @param limit - Maximum number of cards to return
-       * @returns Cards sorted by score descending
-       */
-      async getWeightedCards(limit) {
-        const context = await this.buildContext();
-        const overFetchMultiplier = 2 + this.filters.length * 0.5;
-        const fetchLimit = Math.ceil(limit * overFetchMultiplier);
-        logger.debug(
-          `[Pipeline] Fetching ${fetchLimit} candidates from generator '${this.generator.name}'`
-        );
-        let cards = await this.generator.getWeightedCards(fetchLimit, context);
-        const generatedCount = cards.length;
-        logger.debug(`[Pipeline] Generator returned ${generatedCount} candidates`);
-        cards = await this.hydrateTags(cards);
-        for (const filter of this.filters) {
-          const beforeCount = cards.length;
-          cards = await filter.transform(cards, context);
-          logger.debug(`[Pipeline] Filter '${filter.name}': ${beforeCount} \u2192 ${cards.length} cards`);
-        }
-        cards = cards.filter((c) => c.score > 0);
-        cards.sort((a, b) => b.score - a.score);
-        const result = cards.slice(0, limit);
-        const topScores = result.slice(0, 3).map((c) => c.score);
-        logExecutionSummary(
-          this.generator.name,
-          generatedCount,
-          this.filters.length,
-          result.length,
-          topScores
-        );
-        logCardProvenance(result, 3);
-        return result;
-      }
-      /**
-       * Batch hydrate tags for all cards.
-       *
-       * Fetches tags for all cards in a single database query and attaches them
-       * to the WeightedCard objects. Filters can then use card.tags instead of
-       * making individual getAppliedTags() calls.
-       *
-       * @param cards - Cards to hydrate
-       * @returns Cards with tags populated
-       */
-      async hydrateTags(cards) {
-        if (cards.length === 0) {
-          return cards;
-        }
-        const cardIds = cards.map((c) => c.cardId);
-        const tagsByCard = await this.course.getAppliedTagsBatch(cardIds);
-        logTagHydration(cards, tagsByCard);
-        return cards.map((card) => ({
-          ...card,
-          tags: tagsByCard.get(card.cardId) ?? []
-        }));
-      }
-      /**
-       * Build shared context for generator and filters.
-       *
-       * Called once per getWeightedCards() invocation.
-       * Contains data that the generator and multiple filters might need.
-       *
-       * The context satisfies both GeneratorContext and FilterContext interfaces.
-       */
-      async buildContext() {
-        let userElo = 1e3;
-        try {
-          const courseReg = await this.user.getCourseRegDoc(this.course.getCourseID());
-          const courseElo = (0, import_common5.toCourseElo)(courseReg.elo);
-          userElo = courseElo.global.score;
-        } catch (e) {
-          logger.debug(`[Pipeline] Could not get user ELO, using default: ${e}`);
-        }
-        return {
-          user: this.user,
-          course: this.course,
-          userElo
-        };
-      }
-      /**
-       * Get the course ID for this pipeline.
-       */
-      getCourseID() {
-        return this.course.getCourseID();
-      }
-    };
   }
 });
 
-// src/core/navigators/generators/CompositeGenerator.ts
-var DEFAULT_AGGREGATION_MODE, FREQUENCY_BOOST_FACTOR, CompositeGenerator;
-var init_CompositeGenerator = __esm({
-  "src/core/navigators/generators/CompositeGenerator.ts"() {
+// src/core/navigators/generators/srs.ts
+var srs_exports = {};
+__export(srs_exports, {
+  default: () => SRSNavigator
+});
+var import_moment3, SRSNavigator;
+var init_srs = __esm({
+  "src/core/navigators/generators/srs.ts"() {
     "use strict";
+    import_moment3 = __toESM(require("moment"), 1);
     init_navigators();
     init_logger();
-    DEFAULT_AGGREGATION_MODE = "frequencyBoost" /* FREQUENCY_BOOST */;
-    FREQUENCY_BOOST_FACTOR = 0.1;
-    CompositeGenerator = class _CompositeGenerator extends ContentNavigator {
+    SRSNavigator = class extends ContentNavigator {
       /** Human-readable name for CardGenerator interface */
-      name = "Composite Generator";
-      generators;
-      aggregationMode;
-      constructor(generators, aggregationMode = DEFAULT_AGGREGATION_MODE) {
-        super();
-        this.generators = generators;
-        this.aggregationMode = aggregationMode;
-        if (generators.length === 0) {
-          throw new Error("CompositeGenerator requires at least one generator");
-        }
-        logger.debug(
-          `[CompositeGenerator] Created with ${generators.length} generators, mode: ${aggregationMode}`
-        );
+      name;
+      constructor(user, course, strategyData) {
+        super(user, course, strategyData);
+        this.name = strategyData?.name || "SRS";
       }
       /**
-       * Creates a CompositeGenerator from strategy data.
+       * Get review cards scored by urgency.
        *
-       * This is a convenience factory for use by PipelineAssembler.
-       */
-      static async fromStrategies(user, course, strategies, aggregationMode = DEFAULT_AGGREGATION_MODE) {
-        const generators = await Promise.all(
-          strategies.map((s) => ContentNavigator.create(user, course, s))
-        );
-        return new _CompositeGenerator(generators, aggregationMode);
-      }
-      /**
-       * Get weighted cards from all generators, merge and deduplicate.
+       * Score formula combines:
+       * - Relative overdueness: hoursOverdue / intervalHours
+       * - Interval recency: exponential decay favoring shorter intervals
        *
-       * Cards appearing in multiple generators receive a score boost.
-       * Provenance tracks which generators produced each card and how scores were aggregated.
+       * Cards not yet due are excluded (not scored as 0).
        *
        * This method supports both the legacy signature (limit only) and the
        * CardGenerator interface signature (limit, context).
        *
        * @param limit - Maximum number of cards to return
-       * @param context - GeneratorContext passed to child generators (required when called via Pipeline)
+       * @param _context - Optional GeneratorContext (currently unused, but required for interface)
        */
-      async getWeightedCards(limit, context) {
-        if (!context) {
-          throw new Error(
-            "CompositeGenerator.getWeightedCards requires a GeneratorContext. It should be called via Pipeline, not directly."
-          );
-        }
-        const results = await Promise.all(
-          this.generators.map((g) => g.getWeightedCards(limit, context))
-        );
-        const byCardId = /* @__PURE__ */ new Map();
-        for (const cards of results) {
-          for (const card of cards) {
-            const existing = byCardId.get(card.cardId) || [];
-            existing.push(card);
-            byCardId.set(card.cardId, existing);
-          }
+      async getWeightedCards(limit, _context) {
+        if (!this.user || !this.course) {
+          throw new Error("SRSNavigator requires user and course to be set");
         }
-        const merged = [];
-        for (const [, cards] of byCardId) {
-          const aggregatedScore = this.aggregateScores(cards);
-          const finalScore = Math.min(1, aggregatedScore);
-          const mergedProvenance = cards.flatMap((c) => c.provenance);
-          const initialScore = cards[0].score;
-          const action = finalScore > initialScore ? "boosted" : finalScore < initialScore ? "penalized" : "passed";
-          const reason = this.buildAggregationReason(cards, finalScore);
-          merged.push({
-            ...cards[0],
-            score: finalScore,
+        const reviews = await this.user.getPendingReviews(this.course.getCourseID());
+        const now = import_moment3.default.utc();
+        const dueReviews = reviews.filter((r) => now.isAfter(import_moment3.default.utc(r.reviewTime)));
+        const scored = dueReviews.map((review) => {
+          const { score, reason } = this.computeUrgencyScore(review, now);
+          return {
+            cardId: review.cardId,
+            courseId: review.courseId,
+            score,
+            reviewID: review._id,
             provenance: [
-              ...mergedProvenance,
               {
-                strategy: "composite",
-                strategyName: "Composite Generator",
-                strategyId: "COMPOSITE_GENERATOR",
-                action,
-                score: finalScore,
+                strategy: "srs",
+                strategyName: this.strategyName || this.name,
+                strategyId: this.strategyId || "NAVIGATION_STRATEGY-SRS-default",
+                action: "generated",
+                score,
                 reason
               }
             ]
-          });
-        }
-        return merged.sort((a, b) => b.score - a.score).slice(0, limit);
-      }
-      /**
-       * Build human-readable reason for score aggregation.
-       */
-      buildAggregationReason(cards, finalScore) {
-        const count = cards.length;
-        const scores = cards.map((c) => c.score.toFixed(2)).join(", ");
-        if (count === 1) {
-          return `Single generator, score ${finalScore.toFixed(2)}`;
-        }
-        const strategies = cards.map((c) => c.provenance[0]?.strategy || "unknown").join(", ");
-        switch (this.aggregationMode) {
-          case "max" /* MAX */:
-            return `Max of ${count} generators (${strategies}): scores [${scores}] \u2192 ${finalScore.toFixed(2)}`;
-          case "average" /* AVERAGE */:
-            return `Average of ${count} generators (${strategies}): scores [${scores}] \u2192 ${finalScore.toFixed(2)}`;
-          case "frequencyBoost" /* FREQUENCY_BOOST */: {
-            const avg = cards.reduce((sum, c) => sum + c.score, 0) / count;
-            const boost = 1 + FREQUENCY_BOOST_FACTOR * (count - 1);
-            return `Frequency boost from ${count} generators (${strategies}): avg ${avg.toFixed(2)} \xD7 ${boost.toFixed(2)} \u2192 ${finalScore.toFixed(2)}`;
-          }
-          default:
-            return `Aggregated from ${count} generators: ${finalScore.toFixed(2)}`;
-        }
+          };
+        });
+        logger.debug(`[srsNav] got ${scored.length} weighted cards`);
+        return scored.sort((a, b) => b.score - a.score).slice(0, limit);
       }
       /**
-       * Aggregate scores from multiple generators for the same card.
+       * Compute urgency score for a review card.
+       *
+       * Two factors:
+       * 1. Relative overdueness = hoursOverdue / intervalHours
+       *    - 2 days overdue on 3-day interval = 0.67 (urgent)
+       *    - 2 days overdue on 180-day interval = 0.01 (not urgent)
+       *
+       * 2. Interval recency factor = 0.3 + 0.7 * exp(-intervalHours / 720)
+       *    - 24h interval → ~1.0 (very recent learning)
+       *    - 30 days (720h) → ~0.56
+       *    - 180 days → ~0.30
+       *
+       * Combined: base 0.5 + weighted average of factors * 0.45
+       * Result range: approximately 0.5 to 0.95
        */
-      aggregateScores(cards) {
-        const scores = cards.map((c) => c.score);
-        switch (this.aggregationMode) {
-          case "max" /* MAX */:
-            return Math.max(...scores);
-          case "average" /* AVERAGE */:
-            return scores.reduce((sum, s) => sum + s, 0) / scores.length;
-          case "frequencyBoost" /* FREQUENCY_BOOST */: {
-            const avg = scores.reduce((sum, s) => sum + s, 0) / scores.length;
-            const frequencyBoost = 1 + FREQUENCY_BOOST_FACTOR * (cards.length - 1);
-            return avg * frequencyBoost;
-          }
-          default:
-            return scores[0];
-        }
+      computeUrgencyScore(review, now) {
+        const scheduledAt = import_moment3.default.utc(review.scheduledAt);
+        const due = import_moment3.default.utc(review.reviewTime);
+        const intervalHours = Math.max(1, due.diff(scheduledAt, "hours"));
+        const hoursOverdue = now.diff(due, "hours");
+        const relativeOverdue = hoursOverdue / intervalHours;
+        const recencyFactor = 0.3 + 0.7 * Math.exp(-intervalHours / 720);
+        const overdueContribution = Math.min(1, Math.max(0, relativeOverdue));
+        const urgency = overdueContribution * 0.5 + recencyFactor * 0.5;
+        const score = Math.min(0.95, 0.5 + urgency * 0.45);
+        const reason = `${Math.round(hoursOverdue)}h overdue (interval: ${Math.round(intervalHours)}h, relative: ${relativeOverdue.toFixed(2)}), recency: ${recencyFactor.toFixed(2)}, review`;
+        return { score, reason };
       }
     };
   }
 });
 
-// src/core/navigators/PipelineAssembler.ts
-var PipelineAssembler;
-var init_PipelineAssembler = __esm({
-  "src/core/navigators/PipelineAssembler.ts"() {
+// src/core/navigators/generators/types.ts
+var types_exports = {};
+var init_types = __esm({
+  "src/core/navigators/generators/types.ts"() {
     "use strict";
-    init_navigators();
-    init_Pipeline();
-    init_types_legacy();
-    init_logger();
-    init_CompositeGenerator();
-    PipelineAssembler = class {
+  }
+});
+
+// import("./generators/**/*") in src/core/navigators/index.ts
+var globImport_generators;
+var init_ = __esm({
+  'import("./generators/**/*") in src/core/navigators/index.ts'() {
+    globImport_generators = __glob({
+      "./generators/CompositeGenerator.ts": () => Promise.resolve().then(() => (init_CompositeGenerator(), CompositeGenerator_exports)),
+      "./generators/elo.ts": () => Promise.resolve().then(() => (init_elo(), elo_exports)),
+      "./generators/index.ts": () => Promise.resolve().then(() => (init_generators(), generators_exports)),
+      "./generators/srs.ts": () => Promise.resolve().then(() => (init_srs(), srs_exports)),
+      "./generators/types.ts": () => Promise.resolve().then(() => (init_types(), types_exports))
+    });
+  }
+});
+
+// src/core/types/contentNavigationStrategy.ts
+var DEFAULT_LEARNABLE_WEIGHT;
+var init_contentNavigationStrategy = __esm({
+  "src/core/types/contentNavigationStrategy.ts"() {
+    "use strict";
+    DEFAULT_LEARNABLE_WEIGHT = {
+      weight: 1,
+      confidence: 0.1,
+      // Low confidence initially = wide exploration
+      sampleSize: 0
+    };
+  }
+});
+
+// src/core/navigators/filters/WeightedFilter.ts
+var WeightedFilter_exports = {};
+__export(WeightedFilter_exports, {
+  WeightedFilter: () => WeightedFilter
+});
+var WeightedFilter;
+var init_WeightedFilter = __esm({
+  "src/core/navigators/filters/WeightedFilter.ts"() {
+    "use strict";
+    init_contentNavigationStrategy();
+    WeightedFilter = class {
+      name;
+      inner;
+      learnable;
+      staticWeight;
+      strategyId;
+      constructor(inner, learnable = DEFAULT_LEARNABLE_WEIGHT, staticWeight = false, strategyId) {
+        this.inner = inner;
+        this.name = inner.name;
+        this.learnable = learnable;
+        this.staticWeight = staticWeight;
+        this.strategyId = strategyId;
+      }
       /**
-       * Assembles a navigation pipeline from strategy documents.
-       *
-       * 1. Separates into generators and filters by role
-       * 2. Validates at least one generator exists (or creates default ELO)
-       * 3. Instantiates generators - wraps multiple in CompositeGenerator
-       * 4. Instantiates filters
-       * 5. Returns Pipeline(generator, filters)
-       *
-       * @param input - Strategy documents plus user/course interfaces
-       * @returns Assembled pipeline and any warnings
+       * Apply the inner filter, then scale its effect by the configured weight.
        */
-      async assemble(input) {
-        const { strategies, user, course } = input;
-        const warnings = [];
-        if (strategies.length === 0) {
-          return {
-            pipeline: null,
-            generatorStrategies: [],
-            filterStrategies: [],
-            warnings
-          };
-        }
-        const generatorStrategies = [];
-        const filterStrategies = [];
-        for (const s of strategies) {
-          if (isGenerator(s.implementingClass)) {
-            generatorStrategies.push(s);
-          } else if (isFilter(s.implementingClass)) {
-            filterStrategies.push(s);
-          } else {
-            warnings.push(`Unknown strategy type '${s.implementingClass}', skipping: ${s.name}`);
+      async transform(cards, context) {
+        let effectiveWeight = this.learnable.weight;
+        let deviation;
+        if (!this.staticWeight && context.orchestration) {
+          const strategyId = this.strategyId || this.inner.strategyId || this.name;
+          effectiveWeight = context.orchestration.getEffectiveWeight(strategyId, this.learnable);
+          deviation = context.orchestration.getDeviation(strategyId);
+        }
+        if (Math.abs(effectiveWeight - 1) < 1e-3) {
+          return this.inner.transform(cards, context);
+        }
+        const originalScores = /* @__PURE__ */ new Map();
+        for (const card of cards) {
+          originalScores.set(card.cardId, card.score);
+        }
+        const transformedCards = await this.inner.transform(cards, context);
+        return transformedCards.map((card) => {
+          const originalScore = originalScores.get(card.cardId);
+          if (originalScore === void 0 || originalScore === 0 || card.score === 0) {
+            return card;
           }
-        }
-        if (generatorStrategies.length === 0) {
-          if (filterStrategies.length > 0) {
-            logger.debug(
-              "[PipelineAssembler] No generator found, using default ELO with configured filters"
-            );
-            generatorStrategies.push(this.makeDefaultEloStrategy(course.getCourseID()));
-          } else {
-            warnings.push("No generator strategy found");
+          const rawEffect = card.score / originalScore;
+          if (Math.abs(rawEffect - 1) < 1e-4) {
+            return card;
+          }
+          const weightedEffect = Math.pow(rawEffect, effectiveWeight);
+          const newScore = originalScore * weightedEffect;
+          const lastProvIndex = card.provenance.length - 1;
+          const lastProv = card.provenance[lastProvIndex];
+          if (lastProv) {
+            const updatedProvenance = [...card.provenance];
+            updatedProvenance[lastProvIndex] = {
+              ...lastProv,
+              score: newScore,
+              effectiveWeight,
+              deviation
+              // We can optionally append to the reason, but the structured field is key
+            };
             return {
-              pipeline: null,
-              generatorStrategies: [],
-              filterStrategies: [],
-              warnings
+              ...card,
+              score: newScore,
+              provenance: updatedProvenance
             };
           }
-        }
-        let generator;
-        if (generatorStrategies.length === 1) {
-          const nav = await ContentNavigator.create(user, course, generatorStrategies[0]);
-          generator = nav;
-          logger.debug(`[PipelineAssembler] Using single generator: ${generatorStrategies[0].name}`);
-        } else {
-          logger.debug(
-            `[PipelineAssembler] Using CompositeGenerator for ${generatorStrategies.length} generators: ${generatorStrategies.map((g) => g.name).join(", ")}`
-          );
-          generator = await CompositeGenerator.fromStrategies(user, course, generatorStrategies);
-        }
-        const filters = [];
-        const sortedFilterStrategies = [...filterStrategies].sort(
-          (a, b) => a.name.localeCompare(b.name)
-        );
-        for (const filterStrategy of sortedFilterStrategies) {
-          try {
-            const nav = await ContentNavigator.create(user, course, filterStrategy);
-            if ("transform" in nav && typeof nav.transform === "function") {
-              filters.push(nav);
-              logger.debug(`[PipelineAssembler] Added filter: ${filterStrategy.name}`);
-            } else {
-              warnings.push(
-                `Filter '${filterStrategy.name}' does not implement CardFilter.transform(), skipping`
-              );
-            }
-          } catch (e) {
-            warnings.push(`Failed to instantiate filter '${filterStrategy.name}': ${e}`);
-          }
-        }
-        const pipeline = new Pipeline(generator, filters, user, course);
-        logger.debug(
-          `[PipelineAssembler] Assembled pipeline with ${generatorStrategies.length} generator(s) and ${filters.length} filter(s)`
-        );
-        return {
-          pipeline,
-          generatorStrategies,
-          filterStrategies: sortedFilterStrategies,
-          warnings
-        };
-      }
-      /**
-       * Creates a default ELO generator strategy.
-       * Used when filters are configured but no generator is specified.
-       */
-      makeDefaultEloStrategy(courseId) {
-        return {
-          _id: "NAVIGATION_STRATEGY-ELO-default",
-          course: courseId,
-          docType: "NAVIGATION_STRATEGY" /* NAVIGATION_STRATEGY */,
-          name: "ELO (default)",
-          description: "Default ELO-based generator",
-          implementingClass: "elo" /* ELO */,
-          serializedData: ""
-        };
+          return {
+            ...card,
+            score: newScore
+          };
+        });
       }
     };
   }
 });
 
-// src/core/navigators/generators/elo.ts
-var import_common6, ELONavigator;
-var init_elo = __esm({
-  "src/core/navigators/generators/elo.ts"() {
-    "use strict";
-    init_navigators();
-    import_common6 = require("@vue-skuilder/common");
-    ELONavigator = class extends ContentNavigator {
-      /** Human-readable name for CardGenerator interface */
-      name;
-      constructor(user, course, strategyData) {
-        super(user, course, strategyData);
-        this.name = strategyData?.name || "ELO";
-      }
-      /**
-       * Get new cards with suitability scores based on ELO distance.
-       *
-       * Cards closer to user's ELO get higher scores.
-       * Score formula: max(0, 1 - distance / 500)
-       *
-       * NOTE: This generator only handles NEW cards. Reviews are handled by
-       * SRSNavigator. Use CompositeGenerator to combine both.
-       *
-       * This method supports both the legacy signature (limit only) and the
-       * CardGenerator interface signature (limit, context).
-       *
-       * @param limit - Maximum number of cards to return
-       * @param context - Optional GeneratorContext (used when called via Pipeline)
+// src/core/navigators/filters/eloDistance.ts
+var eloDistance_exports = {};
+__export(eloDistance_exports, {
+  DEFAULT_HALF_LIFE: () => DEFAULT_HALF_LIFE,
+  DEFAULT_MAX_MULTIPLIER: () => DEFAULT_MAX_MULTIPLIER,
+  DEFAULT_MIN_MULTIPLIER: () => DEFAULT_MIN_MULTIPLIER,
+  createEloDistanceFilter: () => createEloDistanceFilter
+});
+function computeMultiplier(distance, halfLife, minMultiplier, maxMultiplier) {
+  const normalizedDistance = distance / halfLife;
+  const decay = Math.exp(-(normalizedDistance * normalizedDistance));
+  return minMultiplier + (maxMultiplier - minMultiplier) * decay;
+}
+function createEloDistanceFilter(config) {
+  const halfLife = config?.halfLife ?? DEFAULT_HALF_LIFE;
+  const minMultiplier = config?.minMultiplier ?? DEFAULT_MIN_MULTIPLIER;
+  const maxMultiplier = config?.maxMultiplier ?? DEFAULT_MAX_MULTIPLIER;
+  return {
+    name: "ELO Distance Filter",
+    async transform(cards, context) {
+      const { course, userElo } = context;
+      const cardIds = cards.map((c) => c.cardId);
+      const cardElos = await course.getCardEloData(cardIds);
+      return cards.map((card, i) => {
+        const cardElo = cardElos[i]?.global?.score ?? 1e3;
+        const distance = Math.abs(cardElo - userElo);
+        const multiplier = computeMultiplier(distance, halfLife, minMultiplier, maxMultiplier);
+        const newScore = card.score * multiplier;
+        const action = multiplier < maxMultiplier - 0.01 ? "penalized" : "passed";
+        return {
+          ...card,
+          score: newScore,
+          provenance: [
+            ...card.provenance,
+            {
+              strategy: "eloDistance",
+              strategyName: "ELO Distance Filter",
+              strategyId: "ELO_DISTANCE_FILTER",
+              action,
+              score: newScore,
+              reason: `ELO distance ${Math.round(distance)} (card: ${Math.round(cardElo)}, user: ${Math.round(userElo)}) \u2192 ${multiplier.toFixed(2)}x`
+            }
+          ]
+        };
+      });
+    }
+  };
+}
+var DEFAULT_HALF_LIFE, DEFAULT_MIN_MULTIPLIER, DEFAULT_MAX_MULTIPLIER;
+var init_eloDistance = __esm({
+  "src/core/navigators/filters/eloDistance.ts"() {
+    "use strict";
+    DEFAULT_HALF_LIFE = 200;
+    DEFAULT_MIN_MULTIPLIER = 0.3;
+    DEFAULT_MAX_MULTIPLIER = 1;
+  }
+});
+
+// src/core/navigators/filters/hierarchyDefinition.ts
+var hierarchyDefinition_exports = {};
+__export(hierarchyDefinition_exports, {
+  default: () => HierarchyDefinitionNavigator
+});
+var import_common6, DEFAULT_MIN_COUNT, HierarchyDefinitionNavigator;
+var init_hierarchyDefinition = __esm({
+  "src/core/navigators/filters/hierarchyDefinition.ts"() {
+    "use strict";
+    init_navigators();
+    import_common6 = require("@vue-skuilder/common");
+    DEFAULT_MIN_COUNT = 3;
+    HierarchyDefinitionNavigator = class extends ContentNavigator {
+      config;
+      /** Human-readable name for CardFilter interface */
+      name;
+      constructor(user, course, strategyData) {
+        super(user, course, strategyData);
+        this.config = this.parseConfig(strategyData.serializedData);
+        this.name = strategyData.name || "Hierarchy Definition";
+      }
+      parseConfig(serializedData) {
+        try {
+          const parsed = JSON.parse(serializedData);
+          return {
+            prerequisites: parsed.prerequisites || {}
+          };
+        } catch {
+          return {
+            prerequisites: {}
+          };
+        }
+      }
+      /**
+       * Check if a specific prerequisite is satisfied
        */
-      async getWeightedCards(limit, context) {
-        let userGlobalElo;
-        if (context?.userElo !== void 0) {
-          userGlobalElo = context.userElo;
+      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;
         } else {
-          const courseReg = await this.user.getCourseRegDoc(this.course.getCourseID());
+          return userTagElo.score >= userGlobalElo;
+        }
+      }
+      /**
+       * Get the set of tags the user has mastered.
+       * A tag is "mastered" if it appears as a prerequisite somewhere and meets its threshold.
+       */
+      async getMasteredTags(context) {
+        const mastered = /* @__PURE__ */ new Set();
+        try {
+          const courseReg = await context.user.getCourseRegDoc(context.course.getCourseID());
           const userElo = (0, import_common6.toCourseElo)(courseReg.elo);
-          userGlobalElo = userElo.global.score;
+          for (const prereqs of Object.values(this.config.prerequisites)) {
+            for (const prereq of prereqs) {
+              const tagElo = userElo.tags[prereq.tag];
+              if (this.isPrerequisiteMet(prereq, tagElo, userElo.global.score)) {
+                mastered.add(prereq.tag);
+              }
+            }
+          }
+        } catch {
         }
-        const activeCards = await this.user.getActiveCards();
-        const newCards = (await this.course.getCardsCenteredAtELO(
-          { limit, elo: "user" },
-          (c) => !activeCards.some((ac) => c.cardID === ac.cardID)
-        )).map((c) => ({ ...c, status: "new" }));
-        const cardIds = newCards.map((c) => c.cardID);
-        const cardEloData = await this.course.getCardEloData(cardIds);
-        const scored = newCards.map((c, i) => {
-          const cardElo = cardEloData[i]?.global?.score ?? 1e3;
-          const distance = Math.abs(cardElo - userGlobalElo);
-          const score = Math.max(0, 1 - distance / 500);
+        return mastered;
+      }
+      /**
+       * Get the set of tags that are unlocked (prerequisites met)
+       */
+      getUnlockedTags(masteredTags) {
+        const unlocked = /* @__PURE__ */ new Set();
+        for (const [tagId, prereqs] of Object.entries(this.config.prerequisites)) {
+          const allPrereqsMet = prereqs.every((prereq) => masteredTags.has(prereq.tag));
+          if (allPrereqsMet) {
+            unlocked.add(tagId);
+          }
+        }
+        return unlocked;
+      }
+      /**
+       * Check if a tag has prerequisites defined in config
+       */
+      hasPrerequisites(tagId) {
+        return tagId in this.config.prerequisites;
+      }
+      /**
+       * Check if a card is unlocked and generate reason.
+       */
+      async checkCardUnlock(card, _course, unlockedTags, masteredTags) {
+        try {
+          const cardTags = card.tags ?? [];
+          const lockedTags = cardTags.filter(
+            (tag) => this.hasPrerequisites(tag) && !unlockedTags.has(tag)
+          );
+          if (lockedTags.length === 0) {
+            const tagList = cardTags.length > 0 ? cardTags.join(", ") : "none";
+            return {
+              isUnlocked: true,
+              reason: `Prerequisites met, tags: ${tagList}`
+            };
+          }
+          const missingPrereqs = lockedTags.flatMap((tag) => {
+            const prereqs = this.config.prerequisites[tag] || [];
+            return prereqs.filter((p) => !masteredTags.has(p.tag)).map((p) => p.tag);
+          });
           return {
-            cardId: c.cardID,
-            courseId: c.courseID,
-            score,
+            isUnlocked: false,
+            reason: `Blocked: missing prerequisites ${missingPrereqs.join(", ")} for tags ${lockedTags.join(", ")}`
+          };
+        } catch {
+          return {
+            isUnlocked: true,
+            reason: "Prerequisites check skipped (tag lookup failed)"
+          };
+        }
+      }
+      /**
+       * CardFilter.transform implementation.
+       *
+       * Apply prerequisite gating to cards. Cards with locked tags receive score: 0.
+       */
+      async transform(cards, context) {
+        const masteredTags = await this.getMasteredTags(context);
+        const unlockedTags = this.getUnlockedTags(masteredTags);
+        const gated = [];
+        for (const card of cards) {
+          const { isUnlocked, reason } = await this.checkCardUnlock(
+            card,
+            context.course,
+            unlockedTags,
+            masteredTags
+          );
+          const finalScore = isUnlocked ? card.score : 0;
+          const action = isUnlocked ? "passed" : "penalized";
+          gated.push({
+            ...card,
+            score: finalScore,
             provenance: [
+              ...card.provenance,
               {
-                strategy: "elo",
+                strategy: "hierarchyDefinition",
                 strategyName: this.strategyName || this.name,
-                strategyId: this.strategyId || "NAVIGATION_STRATEGY-ELO-default",
-                action: "generated",
-                score,
-                reason: `ELO distance ${Math.round(distance)} (card: ${Math.round(cardElo)}, user: ${Math.round(userGlobalElo)}), new card`
+                strategyId: this.strategyId || "NAVIGATION_STRATEGY-hierarchy",
+                action,
+                score: finalScore,
+                reason
               }
             ]
-          };
-        });
-        scored.sort((a, b) => b.score - a.score);
-        return scored.slice(0, limit);
+          });
+        }
+        return gated;
+      }
+      /**
+       * Legacy getWeightedCards - now throws as filters should not be used as generators.
+       *
+       * Use transform() via Pipeline instead.
+       */
+      async getWeightedCards(_limit) {
+        throw new Error(
+          "HierarchyDefinitionNavigator is a filter and should not be used as a generator. Use Pipeline with a generator and this filter via transform()."
+        );
       }
     };
   }
 });
 
-// src/core/navigators/generators/srs.ts
-var import_moment3, SRSNavigator;
-var init_srs = __esm({
-  "src/core/navigators/generators/srs.ts"() {
+// src/core/navigators/filters/userTagPreference.ts
+var userTagPreference_exports = {};
+__export(userTagPreference_exports, {
+  default: () => UserTagPreferenceFilter
+});
+var UserTagPreferenceFilter;
+var init_userTagPreference = __esm({
+  "src/core/navigators/filters/userTagPreference.ts"() {
     "use strict";
-    import_moment3 = __toESM(require("moment"), 1);
     init_navigators();
-    init_logger();
-    SRSNavigator = class extends ContentNavigator {
-      /** Human-readable name for CardGenerator interface */
+    UserTagPreferenceFilter = class extends ContentNavigator {
+      _strategyData;
+      /** Human-readable name for CardFilter interface */
       name;
       constructor(user, course, strategyData) {
         super(user, course, strategyData);
-        this.name = strategyData?.name || "SRS";
+        this._strategyData = strategyData;
+        this.name = strategyData.name || "User Tag Preferences";
+      }
+      /**
+       * Compute multiplier for a card based on its tags and user preferences.
+       * Returns the maximum multiplier among all matching tags, or 1.0 if no matches.
+       */
+      computeMultiplier(cardTags, boostMap) {
+        const multipliers = cardTags.map((tag) => boostMap[tag]).filter((val) => val !== void 0);
+        if (multipliers.length === 0) {
+          return 1;
+        }
+        return Math.max(...multipliers);
+      }
+      /**
+       * Build human-readable reason for the filter's decision.
+       */
+      buildReason(cardTags, boostMap, multiplier) {
+        const matchingTags = cardTags.filter((tag) => boostMap[tag] === multiplier);
+        if (multiplier === 0) {
+          return `Excluded by user preference: ${matchingTags.join(", ")} (${multiplier}x)`;
+        }
+        if (multiplier < 1) {
+          return `Penalized by user preference: ${matchingTags.join(", ")} (${multiplier.toFixed(2)}x)`;
+        }
+        if (multiplier > 1) {
+          return `Boosted by user preference: ${matchingTags.join(", ")} (${multiplier.toFixed(2)}x)`;
+        }
+        return "No matching user preferences";
+      }
+      /**
+       * CardFilter.transform implementation.
+       *
+       * Apply user tag preferences:
+       * 1. Read preferences from strategy state
+       * 2. If no preferences, pass through unchanged
+       * 3. For each card:
+       *    - Look up tag in boost record
+       *    - If tag found: apply multiplier (0 = exclude, 1 = neutral, >1 = boost)
+       *    - If multiple tags match: use max multiplier
+       *    - Append provenance with clear reason
+       */
+      async transform(cards, _context) {
+        const prefs = await this.getStrategyState();
+        if (!prefs || Object.keys(prefs.boost).length === 0) {
+          return cards.map((card) => ({
+            ...card,
+            provenance: [
+              ...card.provenance,
+              {
+                strategy: "userTagPreference",
+                strategyName: this.strategyName || this.name,
+                strategyId: this.strategyId || this._strategyData._id,
+                action: "passed",
+                score: card.score,
+                reason: "No user tag preferences configured"
+              }
+            ]
+          }));
+        }
+        const adjusted = await Promise.all(
+          cards.map(async (card) => {
+            const cardTags = card.tags ?? [];
+            const multiplier = this.computeMultiplier(cardTags, prefs.boost);
+            const finalScore = Math.min(1, card.score * multiplier);
+            let action;
+            if (multiplier === 0 || multiplier < 1) {
+              action = "penalized";
+            } else if (multiplier > 1) {
+              action = "boosted";
+            } else {
+              action = "passed";
+            }
+            return {
+              ...card,
+              score: finalScore,
+              provenance: [
+                ...card.provenance,
+                {
+                  strategy: "userTagPreference",
+                  strategyName: this.strategyName || this.name,
+                  strategyId: this.strategyId || this._strategyData._id,
+                  action,
+                  score: finalScore,
+                  reason: this.buildReason(cardTags, prefs.boost, multiplier)
+                }
+              ]
+            };
+          })
+        );
+        return adjusted;
+      }
+      /**
+       * Legacy getWeightedCards - throws as filters should not be used as generators.
+       */
+      async getWeightedCards(_limit) {
+        throw new Error(
+          "UserTagPreferenceFilter is a filter and should not be used as a generator. Use Pipeline with a generator and this filter via transform()."
+        );
+      }
+    };
+  }
+});
+
+// src/core/navigators/filters/index.ts
+var filters_exports = {};
+__export(filters_exports, {
+  UserTagPreferenceFilter: () => UserTagPreferenceFilter,
+  createEloDistanceFilter: () => createEloDistanceFilter
+});
+var init_filters = __esm({
+  "src/core/navigators/filters/index.ts"() {
+    "use strict";
+    init_eloDistance();
+    init_userTagPreference();
+  }
+});
+
+// src/core/navigators/filters/inferredPreferenceStub.ts
+var inferredPreferenceStub_exports = {};
+__export(inferredPreferenceStub_exports, {
+  INFERRED_PREFERENCE_NAVIGATOR_STUB: () => INFERRED_PREFERENCE_NAVIGATOR_STUB
+});
+var INFERRED_PREFERENCE_NAVIGATOR_STUB;
+var init_inferredPreferenceStub = __esm({
+  "src/core/navigators/filters/inferredPreferenceStub.ts"() {
+    "use strict";
+    INFERRED_PREFERENCE_NAVIGATOR_STUB = true;
+  }
+});
+
+// src/core/navigators/filters/interferenceMitigator.ts
+var interferenceMitigator_exports = {};
+__export(interferenceMitigator_exports, {
+  default: () => InterferenceMitigatorNavigator
+});
+var import_common7, DEFAULT_MIN_COUNT2, DEFAULT_MIN_ELAPSED_DAYS, DEFAULT_INTERFERENCE_DECAY, InterferenceMitigatorNavigator;
+var init_interferenceMitigator = __esm({
+  "src/core/navigators/filters/interferenceMitigator.ts"() {
+    "use strict";
+    init_navigators();
+    import_common7 = require("@vue-skuilder/common");
+    DEFAULT_MIN_COUNT2 = 10;
+    DEFAULT_MIN_ELAPSED_DAYS = 3;
+    DEFAULT_INTERFERENCE_DECAY = 0.8;
+    InterferenceMitigatorNavigator = class extends ContentNavigator {
+      config;
+      /** Human-readable name for CardFilter interface */
+      name;
+      /** Precomputed map: tag -> set of { partner, decay } it interferes with */
+      interferenceMap;
+      constructor(user, course, strategyData) {
+        super(user, course, strategyData);
+        this.config = this.parseConfig(strategyData.serializedData);
+        this.interferenceMap = this.buildInterferenceMap();
+        this.name = strategyData.name || "Interference Mitigator";
+      }
+      parseConfig(serializedData) {
+        try {
+          const parsed = JSON.parse(serializedData);
+          let sets = parsed.interferenceSets || [];
+          if (sets.length > 0 && Array.isArray(sets[0])) {
+            sets = sets.map((tags) => ({ tags }));
+          }
+          return {
+            interferenceSets: sets,
+            maturityThreshold: {
+              minCount: parsed.maturityThreshold?.minCount ?? DEFAULT_MIN_COUNT2,
+              minElo: parsed.maturityThreshold?.minElo,
+              minElapsedDays: parsed.maturityThreshold?.minElapsedDays ?? DEFAULT_MIN_ELAPSED_DAYS
+            },
+            defaultDecay: parsed.defaultDecay ?? DEFAULT_INTERFERENCE_DECAY
+          };
+        } catch {
+          return {
+            interferenceSets: [],
+            maturityThreshold: {
+              minCount: DEFAULT_MIN_COUNT2,
+              minElapsedDays: DEFAULT_MIN_ELAPSED_DAYS
+            },
+            defaultDecay: DEFAULT_INTERFERENCE_DECAY
+          };
+        }
+      }
+      /**
+       * Build a map from each tag to its interference partners with decay coefficients.
+       * If tags A, B, C are in an interference group with decay 0.8, then:
+       * - A interferes with B (decay 0.8) and C (decay 0.8)
+       * - B interferes with A (decay 0.8) and C (decay 0.8)
+       * - etc.
+       */
+      buildInterferenceMap() {
+        const map = /* @__PURE__ */ new Map();
+        for (const group of this.config.interferenceSets) {
+          const decay = group.decay ?? this.config.defaultDecay ?? DEFAULT_INTERFERENCE_DECAY;
+          for (const tag of group.tags) {
+            if (!map.has(tag)) {
+              map.set(tag, []);
+            }
+            const partners = map.get(tag);
+            for (const other of group.tags) {
+              if (other !== tag) {
+                const existing = partners.find((p) => p.partner === other);
+                if (existing) {
+                  existing.decay = Math.max(existing.decay, decay);
+                } else {
+                  partners.push({ partner: other, decay });
+                }
+              }
+            }
+          }
+        }
+        return map;
+      }
+      /**
+       * Get the set of tags that are currently immature for this user.
+       * A tag is immature if the user has interacted with it but hasn't
+       * reached the maturity threshold.
+       */
+      async getImmatureTags(context) {
+        const immature = /* @__PURE__ */ new Set();
+        try {
+          const courseReg = await context.user.getCourseRegDoc(context.course.getCourseID());
+          const userElo = (0, import_common7.toCourseElo)(courseReg.elo);
+          const minCount = this.config.maturityThreshold?.minCount ?? DEFAULT_MIN_COUNT2;
+          const minElo = this.config.maturityThreshold?.minElo;
+          const minElapsedDays = this.config.maturityThreshold?.minElapsedDays ?? DEFAULT_MIN_ELAPSED_DAYS;
+          const minCountForElapsed = minElapsedDays * 2;
+          for (const [tagId, tagElo] of Object.entries(userElo.tags)) {
+            if (tagElo.count === 0) continue;
+            const belowCount = tagElo.count < minCount;
+            const belowElo = minElo !== void 0 && tagElo.score < minElo;
+            const belowElapsed = tagElo.count < minCountForElapsed;
+            if (belowCount || belowElo || belowElapsed) {
+              immature.add(tagId);
+            }
+          }
+        } catch {
+        }
+        return immature;
+      }
+      /**
+       * Get all tags that interfere with any immature tag, along with their decay coefficients.
+       * These are the tags we want to avoid introducing.
+       */
+      getTagsToAvoid(immatureTags) {
+        const avoid = /* @__PURE__ */ new Map();
+        for (const immatureTag of immatureTags) {
+          const partners = this.interferenceMap.get(immatureTag);
+          if (partners) {
+            for (const { partner, decay } of partners) {
+              if (!immatureTags.has(partner)) {
+                const existing = avoid.get(partner) ?? 0;
+                avoid.set(partner, Math.max(existing, decay));
+              }
+            }
+          }
+        }
+        return avoid;
+      }
+      /**
+       * Compute interference score reduction for a card.
+       * Returns: { multiplier, interfering tags, reason }
+       */
+      computeInterferenceEffect(cardTags, tagsToAvoid, immatureTags) {
+        if (tagsToAvoid.size === 0) {
+          return {
+            multiplier: 1,
+            interferingTags: [],
+            reason: "No interference detected"
+          };
+        }
+        let multiplier = 1;
+        const interferingTags = [];
+        for (const tag of cardTags) {
+          const decay = tagsToAvoid.get(tag);
+          if (decay !== void 0) {
+            interferingTags.push(tag);
+            multiplier *= 1 - decay;
+          }
+        }
+        if (interferingTags.length === 0) {
+          return {
+            multiplier: 1,
+            interferingTags: [],
+            reason: "No interference detected"
+          };
+        }
+        const causingTags = /* @__PURE__ */ new Set();
+        for (const tag of interferingTags) {
+          for (const immatureTag of immatureTags) {
+            const partners = this.interferenceMap.get(immatureTag);
+            if (partners?.some((p) => p.partner === tag)) {
+              causingTags.add(immatureTag);
+            }
+          }
+        }
+        const reason = `Interferes with immature tags ${Array.from(causingTags).join(", ")} (tags: ${interferingTags.join(", ")}, multiplier: ${multiplier.toFixed(2)})`;
+        return { multiplier, interferingTags, reason };
+      }
+      /**
+       * CardFilter.transform implementation.
+       *
+       * Apply interference-aware scoring. Cards with tags that interfere with
+       * immature learnings get reduced scores.
+       */
+      async transform(cards, context) {
+        const immatureTags = await this.getImmatureTags(context);
+        const tagsToAvoid = this.getTagsToAvoid(immatureTags);
+        const adjusted = [];
+        for (const card of cards) {
+          const cardTags = card.tags ?? [];
+          const { multiplier, reason } = this.computeInterferenceEffect(
+            cardTags,
+            tagsToAvoid,
+            immatureTags
+          );
+          const finalScore = card.score * multiplier;
+          const action = multiplier < 1 ? "penalized" : multiplier > 1 ? "boosted" : "passed";
+          adjusted.push({
+            ...card,
+            score: finalScore,
+            provenance: [
+              ...card.provenance,
+              {
+                strategy: "interferenceMitigator",
+                strategyName: this.strategyName || this.name,
+                strategyId: this.strategyId || "NAVIGATION_STRATEGY-interference",
+                action,
+                score: finalScore,
+                reason
+              }
+            ]
+          });
+        }
+        return adjusted;
+      }
+      /**
+       * Legacy getWeightedCards - now throws as filters should not be used as generators.
+       *
+       * Use transform() via Pipeline instead.
+       */
+      async getWeightedCards(_limit) {
+        throw new Error(
+          "InterferenceMitigatorNavigator is a filter and should not be used as a generator. Use Pipeline with a generator and this filter via transform()."
+        );
+      }
+    };
+  }
+});
+
+// src/core/navigators/filters/relativePriority.ts
+var relativePriority_exports = {};
+__export(relativePriority_exports, {
+  default: () => RelativePriorityNavigator
+});
+var DEFAULT_PRIORITY, DEFAULT_PRIORITY_INFLUENCE, DEFAULT_COMBINE_MODE, RelativePriorityNavigator;
+var init_relativePriority = __esm({
+  "src/core/navigators/filters/relativePriority.ts"() {
+    "use strict";
+    init_navigators();
+    DEFAULT_PRIORITY = 0.5;
+    DEFAULT_PRIORITY_INFLUENCE = 0.5;
+    DEFAULT_COMBINE_MODE = "max";
+    RelativePriorityNavigator = class extends ContentNavigator {
+      config;
+      /** Human-readable name for CardFilter interface */
+      name;
+      constructor(user, course, strategyData) {
+        super(user, course, strategyData);
+        this.config = this.parseConfig(strategyData.serializedData);
+        this.name = strategyData.name || "Relative Priority";
+      }
+      parseConfig(serializedData) {
+        try {
+          const parsed = JSON.parse(serializedData);
+          return {
+            tagPriorities: parsed.tagPriorities || {},
+            defaultPriority: parsed.defaultPriority ?? DEFAULT_PRIORITY,
+            combineMode: parsed.combineMode ?? DEFAULT_COMBINE_MODE,
+            priorityInfluence: parsed.priorityInfluence ?? DEFAULT_PRIORITY_INFLUENCE
+          };
+        } catch {
+          return {
+            tagPriorities: {},
+            defaultPriority: DEFAULT_PRIORITY,
+            combineMode: DEFAULT_COMBINE_MODE,
+            priorityInfluence: DEFAULT_PRIORITY_INFLUENCE
+          };
+        }
+      }
+      /**
+       * Look up the priority for a tag.
+       */
+      getTagPriority(tagId) {
+        return this.config.tagPriorities[tagId] ?? this.config.defaultPriority ?? DEFAULT_PRIORITY;
+      }
+      /**
+       * Compute combined priority for a card based on its tags.
+       */
+      computeCardPriority(cardTags) {
+        if (cardTags.length === 0) {
+          return this.config.defaultPriority ?? DEFAULT_PRIORITY;
+        }
+        const priorities = cardTags.map((tag) => this.getTagPriority(tag));
+        switch (this.config.combineMode) {
+          case "max":
+            return Math.max(...priorities);
+          case "min":
+            return Math.min(...priorities);
+          case "average":
+            return priorities.reduce((sum, p) => sum + p, 0) / priorities.length;
+          default:
+            return Math.max(...priorities);
+        }
+      }
+      /**
+       * Compute boost factor based on priority.
+       *
+       * The formula: 1 + (priority - 0.5) * priorityInfluence
+       *
+       * This creates a multiplier centered around 1.0:
+       * - Priority 1.0 with influence 0.5 → 1.25 (25% boost)
+       * - Priority 0.5 with any influence → 1.00 (neutral)
+       * - Priority 0.0 with influence 0.5 → 0.75 (25% reduction)
+       */
+      computeBoostFactor(priority) {
+        const influence = this.config.priorityInfluence ?? DEFAULT_PRIORITY_INFLUENCE;
+        return 1 + (priority - 0.5) * influence;
+      }
+      /**
+       * Build human-readable reason for priority adjustment.
+       */
+      buildPriorityReason(cardTags, priority, boostFactor, finalScore) {
+        if (cardTags.length === 0) {
+          return `No tags, neutral priority (${priority.toFixed(2)})`;
+        }
+        const tagList = cardTags.slice(0, 3).join(", ");
+        const more = cardTags.length > 3 ? ` (+${cardTags.length - 3} more)` : "";
+        if (boostFactor === 1) {
+          return `Neutral priority (${priority.toFixed(2)}) for tags: ${tagList}${more}`;
+        } else if (boostFactor > 1) {
+          return `High-priority tags: ${tagList}${more} (priority ${priority.toFixed(2)} \u2192 boost ${boostFactor.toFixed(2)}x \u2192 ${finalScore.toFixed(2)})`;
+        } else {
+          return `Low-priority tags: ${tagList}${more} (priority ${priority.toFixed(2)} \u2192 reduce ${boostFactor.toFixed(2)}x \u2192 ${finalScore.toFixed(2)})`;
+        }
+      }
+      /**
+       * CardFilter.transform implementation.
+       *
+       * Apply priority-adjusted scoring. Cards with high-priority tags get boosted,
+       * cards with low-priority tags get reduced scores.
+       */
+      async transform(cards, _context) {
+        const adjusted = await Promise.all(
+          cards.map(async (card) => {
+            const cardTags = card.tags ?? [];
+            const priority = this.computeCardPriority(cardTags);
+            const boostFactor = this.computeBoostFactor(priority);
+            const finalScore = Math.max(0, Math.min(1, card.score * boostFactor));
+            const action = boostFactor > 1 ? "boosted" : boostFactor < 1 ? "penalized" : "passed";
+            const reason = this.buildPriorityReason(cardTags, priority, boostFactor, finalScore);
+            return {
+              ...card,
+              score: finalScore,
+              provenance: [
+                ...card.provenance,
+                {
+                  strategy: "relativePriority",
+                  strategyName: this.strategyName || this.name,
+                  strategyId: this.strategyId || "NAVIGATION_STRATEGY-priority",
+                  action,
+                  score: finalScore,
+                  reason
+                }
+              ]
+            };
+          })
+        );
+        return adjusted;
+      }
+      /**
+       * Legacy getWeightedCards - now throws as filters should not be used as generators.
+       *
+       * Use transform() via Pipeline instead.
+       */
+      async getWeightedCards(_limit) {
+        throw new Error(
+          "RelativePriorityNavigator is a filter and should not be used as a generator. Use Pipeline with a generator and this filter via transform()."
+        );
+      }
+    };
+  }
+});
+
+// src/core/navigators/filters/types.ts
+var types_exports2 = {};
+var init_types2 = __esm({
+  "src/core/navigators/filters/types.ts"() {
+    "use strict";
+  }
+});
+
+// src/core/navigators/filters/userGoalStub.ts
+var userGoalStub_exports = {};
+__export(userGoalStub_exports, {
+  USER_GOAL_NAVIGATOR_STUB: () => USER_GOAL_NAVIGATOR_STUB
+});
+var USER_GOAL_NAVIGATOR_STUB;
+var init_userGoalStub = __esm({
+  "src/core/navigators/filters/userGoalStub.ts"() {
+    "use strict";
+    USER_GOAL_NAVIGATOR_STUB = true;
+  }
+});
+
+// import("./filters/**/*") in src/core/navigators/index.ts
+var globImport_filters;
+var init_2 = __esm({
+  'import("./filters/**/*") in src/core/navigators/index.ts'() {
+    globImport_filters = __glob({
+      "./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)),
+      "./filters/index.ts": () => Promise.resolve().then(() => (init_filters(), filters_exports)),
+      "./filters/inferredPreferenceStub.ts": () => Promise.resolve().then(() => (init_inferredPreferenceStub(), inferredPreferenceStub_exports)),
+      "./filters/interferenceMitigator.ts": () => Promise.resolve().then(() => (init_interferenceMitigator(), interferenceMitigator_exports)),
+      "./filters/relativePriority.ts": () => Promise.resolve().then(() => (init_relativePriority(), relativePriority_exports)),
+      "./filters/types.ts": () => Promise.resolve().then(() => (init_types2(), types_exports2)),
+      "./filters/userGoalStub.ts": () => Promise.resolve().then(() => (init_userGoalStub(), userGoalStub_exports)),
+      "./filters/userTagPreference.ts": () => Promise.resolve().then(() => (init_userTagPreference(), userTagPreference_exports))
+    });
+  }
+});
+
+// src/core/orchestration/gradient.ts
+function aggregateOutcomesForGradient(outcomes, strategyId) {
+  const observations = [];
+  for (const outcome of outcomes) {
+    const deviation = outcome.deviations[strategyId];
+    if (deviation === void 0) {
+      continue;
+    }
+    observations.push({
+      deviation,
+      outcomeValue: outcome.outcomeValue,
+      weight: 1
+    });
+  }
+  logger.debug(
+    `[Orchestration] Aggregated ${observations.length} observations for strategy ${strategyId}`
+  );
+  return observations;
+}
+function computeStrategyGradient(observations) {
+  const n = observations.length;
+  if (n < 3) {
+    logger.debug(`[Orchestration] Insufficient observations for gradient (${n} < 3)`);
+    return null;
+  }
+  let sumX = 0;
+  let sumY = 0;
+  let sumW = 0;
+  for (const obs of observations) {
+    const w = obs.weight ?? 1;
+    sumX += obs.deviation * w;
+    sumY += obs.outcomeValue * w;
+    sumW += w;
+  }
+  const meanX = sumX / sumW;
+  const meanY = sumY / sumW;
+  let numerator = 0;
+  let denominator = 0;
+  let ssTotal = 0;
+  for (const obs of observations) {
+    const w = obs.weight ?? 1;
+    const dx = obs.deviation - meanX;
+    const dy = obs.outcomeValue - meanY;
+    numerator += w * dx * dy;
+    denominator += w * dx * dx;
+    ssTotal += w * dy * dy;
+  }
+  if (denominator < 1e-10) {
+    logger.debug(`[Orchestration] No variance in deviations, cannot compute gradient`);
+    return {
+      gradient: 0,
+      intercept: meanY,
+      rSquared: 0,
+      sampleSize: n
+    };
+  }
+  const gradient = numerator / denominator;
+  const intercept = meanY - gradient * meanX;
+  let ssResidual = 0;
+  for (const obs of observations) {
+    const w = obs.weight ?? 1;
+    const predicted = gradient * obs.deviation + intercept;
+    const residual = obs.outcomeValue - predicted;
+    ssResidual += w * residual * residual;
+  }
+  const rSquared = ssTotal > 1e-10 ? 1 - ssResidual / ssTotal : 0;
+  logger.debug(
+    `[Orchestration] Computed gradient: ${gradient.toFixed(4)}, intercept: ${intercept.toFixed(4)}, R\xB2: ${rSquared.toFixed(4)}, n=${n}`
+  );
+  return {
+    gradient,
+    intercept,
+    rSquared: Math.max(0, Math.min(1, rSquared)),
+    // Clamp to [0,1]
+    sampleSize: n
+  };
+}
+var init_gradient = __esm({
+  "src/core/orchestration/gradient.ts"() {
+    "use strict";
+    init_logger();
+  }
+});
+
+// src/core/orchestration/learning.ts
+function updateStrategyWeight(current, gradient) {
+  if (gradient.sampleSize < MIN_OBSERVATIONS_FOR_UPDATE) {
+    logger.debug(
+      `[Orchestration] Insufficient samples (${gradient.sampleSize} < ${MIN_OBSERVATIONS_FOR_UPDATE}), keeping current weight`
+    );
+    return {
+      ...current,
+      sampleSize: current.sampleSize + gradient.sampleSize
+    };
+  }
+  const isReliable = gradient.rSquared >= MIN_R_SQUARED_FOR_GRADIENT;
+  const isFlat = Math.abs(gradient.gradient) < FLAT_GRADIENT_THRESHOLD;
+  let newWeight = current.weight;
+  let newConfidence = current.confidence;
+  if (!isReliable || isFlat) {
+    const confidenceGain = 0.05 * (1 - current.confidence);
+    newConfidence = Math.min(1, current.confidence + confidenceGain);
+    logger.debug(
+      `[Orchestration] Flat/unreliable gradient (|g|=${Math.abs(gradient.gradient).toFixed(4)}, R\xB2=${gradient.rSquared.toFixed(4)}). Increasing confidence: ${current.confidence.toFixed(3)} \u2192 ${newConfidence.toFixed(3)}`
+    );
+  } else {
+    let delta = gradient.gradient * LEARNING_RATE;
+    delta = Math.max(-MAX_WEIGHT_DELTA, Math.min(MAX_WEIGHT_DELTA, delta));
+    newWeight = current.weight + delta;
+    newWeight = Math.max(0.1, Math.min(3, newWeight));
+    const confidenceGain = 0.02 * (1 - current.confidence);
+    newConfidence = Math.min(1, current.confidence + confidenceGain);
+    logger.debug(
+      `[Orchestration] Adjusting weight: ${current.weight.toFixed(3)} \u2192 ${newWeight.toFixed(3)} (gradient=${gradient.gradient.toFixed(4)}, delta=${delta.toFixed(4)})`
+    );
+  }
+  return {
+    weight: newWeight,
+    confidence: newConfidence,
+    sampleSize: current.sampleSize + gradient.sampleSize
+  };
+}
+function updateLearningState(courseId, strategyId, currentWeight, gradient, existing) {
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const id = `STRATEGY_LEARNING_STATE::${courseId}::${strategyId}`;
+  const historyEntry = {
+    timestamp: now,
+    weight: currentWeight.weight,
+    confidence: currentWeight.confidence,
+    gradient: gradient.gradient
+  };
+  let history = existing?.history ?? [];
+  history = [...history, historyEntry];
+  if (history.length > MAX_HISTORY_LENGTH) {
+    history = history.slice(history.length - MAX_HISTORY_LENGTH);
+  }
+  const state = {
+    _id: id,
+    _rev: existing?._rev,
+    docType: "STRATEGY_LEARNING_STATE" /* STRATEGY_LEARNING_STATE */,
+    courseId,
+    strategyId,
+    currentWeight,
+    regression: {
+      gradient: gradient.gradient,
+      intercept: gradient.intercept,
+      rSquared: gradient.rSquared,
+      sampleSize: gradient.sampleSize,
+      computedAt: now
+    },
+    history,
+    updatedAt: now
+  };
+  return state;
+}
+function runPeriodUpdate(input) {
+  const { courseId, strategyId, currentWeight, gradient, existingState } = input;
+  logger.info(
+    `[Orchestration] Running period update for strategy ${strategyId} (${gradient.sampleSize} observations)`
+  );
+  const newWeight = updateStrategyWeight(currentWeight, gradient);
+  const updated = newWeight.weight !== currentWeight.weight;
+  const learningState = updateLearningState(
+    courseId,
+    strategyId,
+    newWeight,
+    gradient,
+    existingState
+  );
+  logger.info(
+    `[Orchestration] Period update complete for ${strategyId}: weight ${currentWeight.weight.toFixed(3)} \u2192 ${newWeight.weight.toFixed(3)}, confidence ${currentWeight.confidence.toFixed(3)} \u2192 ${newWeight.confidence.toFixed(3)}`
+  );
+  return {
+    strategyId,
+    previousWeight: currentWeight,
+    newWeight,
+    gradient,
+    learningState,
+    updated
+  };
+}
+function getDefaultLearnableWeight() {
+  return { ...DEFAULT_LEARNABLE_WEIGHT };
+}
+var MIN_OBSERVATIONS_FOR_UPDATE, LEARNING_RATE, MAX_WEIGHT_DELTA, MIN_R_SQUARED_FOR_GRADIENT, FLAT_GRADIENT_THRESHOLD, MAX_HISTORY_LENGTH;
+var init_learning = __esm({
+  "src/core/orchestration/learning.ts"() {
+    "use strict";
+    init_contentNavigationStrategy();
+    init_types_legacy();
+    init_logger();
+    MIN_OBSERVATIONS_FOR_UPDATE = 10;
+    LEARNING_RATE = 0.1;
+    MAX_WEIGHT_DELTA = 0.3;
+    MIN_R_SQUARED_FOR_GRADIENT = 0.05;
+    FLAT_GRADIENT_THRESHOLD = 0.02;
+    MAX_HISTORY_LENGTH = 100;
+  }
+});
+
+// src/core/orchestration/signal.ts
+function computeOutcomeSignal(records, config = {}) {
+  if (!records || records.length === 0) {
+    return null;
+  }
+  const target = config.targetAccuracy ?? 0.85;
+  const tolerance = config.tolerance ?? 0.05;
+  let correct = 0;
+  for (const r of records) {
+    if (r.isCorrect) correct++;
+  }
+  const accuracy = correct / records.length;
+  return scoreAccuracyInZone(accuracy, target, tolerance);
+}
+function scoreAccuracyInZone(accuracy, target, tolerance) {
+  const dist = Math.abs(accuracy - target);
+  if (dist <= tolerance) {
+    return 1;
+  }
+  const excess = dist - tolerance;
+  const slope = 2.5;
+  return Math.max(0, 1 - excess * slope);
+}
+var init_signal = __esm({
+  "src/core/orchestration/signal.ts"() {
+    "use strict";
+  }
+});
+
+// src/core/orchestration/recording.ts
+async function recordUserOutcome(context, periodStart, periodEnd, records, activeStrategyIds, eloStart = 0, eloEnd = 0, config) {
+  const { user, course, userId } = context;
+  const courseId = course.getCourseID();
+  const outcomeValue = computeOutcomeSignal(records, config);
+  if (outcomeValue === null) {
+    logger.debug(
+      `[Orchestration] No outcome signal computed for ${userId} (insufficient data). Skipping record.`
+    );
+    return;
+  }
+  const deviations = {};
+  for (const strategyId of activeStrategyIds) {
+    deviations[strategyId] = context.getDeviation(strategyId);
+  }
+  const id = `USER_OUTCOME::${courseId}::${userId}::${periodEnd}`;
+  const record = {
+    _id: id,
+    docType: "USER_OUTCOME" /* USER_OUTCOME */,
+    courseId,
+    userId,
+    periodStart,
+    periodEnd,
+    outcomeValue,
+    deviations,
+    metadata: {
+      sessionsCount: 1,
+      // Assumes recording is triggered per-session currently
+      cardsSeen: records.length,
+      eloStart,
+      eloEnd,
+      signalType: "accuracy_in_zone"
+    }
+  };
+  try {
+    await user.putUserOutcome(record);
+    logger.debug(
+      `[Orchestration] Recorded outcome ${outcomeValue.toFixed(3)} for ${userId} (doc: ${id})`
+    );
+  } catch (e) {
+    logger.error(`[Orchestration] Failed to record outcome: ${e}`);
+  }
+}
+var init_recording = __esm({
+  "src/core/orchestration/recording.ts"() {
+    "use strict";
+    init_signal();
+    init_types_legacy();
+    init_logger();
+  }
+});
+
+// src/core/orchestration/index.ts
+function fnv1a(str) {
+  let hash = 2166136261;
+  for (let i = 0; i < str.length; i++) {
+    hash ^= str.charCodeAt(i);
+    hash = Math.imul(hash, 16777619);
+  }
+  return hash >>> 0;
+}
+function computeDeviation(userId, strategyId, salt) {
+  const input = `${userId}:${strategyId}:${salt}`;
+  const hash = fnv1a(input);
+  const normalized = hash / 4294967296;
+  return normalized * 2 - 1;
+}
+function computeSpread(confidence) {
+  const clampedConfidence = Math.max(0, Math.min(1, confidence));
+  return MAX_SPREAD - clampedConfidence * (MAX_SPREAD - MIN_SPREAD);
+}
+function computeEffectiveWeight(learnable, userId, strategyId, salt) {
+  const deviation = computeDeviation(userId, strategyId, salt);
+  const spread = computeSpread(learnable.confidence);
+  const adjustment = deviation * spread * learnable.weight;
+  const effective = learnable.weight + adjustment;
+  return Math.max(MIN_WEIGHT, Math.min(MAX_WEIGHT, effective));
+}
+async function createOrchestrationContext(user, course) {
+  let courseConfig;
+  try {
+    courseConfig = await course.getCourseConfig();
+  } catch (e) {
+    logger.error(`[Orchestration] Failed to load course config: ${e}`);
+    courseConfig = {
+      name: "Unknown",
+      description: "",
+      public: false,
+      deleted: false,
+      creator: "",
+      admins: [],
+      moderators: [],
+      dataShapes: [],
+      questionTypes: [],
+      orchestration: { salt: "default" }
+    };
+  }
+  const userId = user.getUsername();
+  const salt = courseConfig.orchestration?.salt || "default_salt";
+  return {
+    user,
+    course,
+    userId,
+    courseConfig,
+    getEffectiveWeight(strategyId, learnable) {
+      return computeEffectiveWeight(learnable, userId, strategyId, salt);
+    },
+    getDeviation(strategyId) {
+      return computeDeviation(userId, strategyId, salt);
+    }
+  };
+}
+var MIN_SPREAD, MAX_SPREAD, MIN_WEIGHT, MAX_WEIGHT;
+var init_orchestration = __esm({
+  "src/core/orchestration/index.ts"() {
+    "use strict";
+    init_logger();
+    init_gradient();
+    init_learning();
+    init_signal();
+    init_recording();
+    MIN_SPREAD = 0.1;
+    MAX_SPREAD = 0.5;
+    MIN_WEIGHT = 0.1;
+    MAX_WEIGHT = 3;
+  }
+});
+
+// src/core/navigators/Pipeline.ts
+var Pipeline_exports = {};
+__export(Pipeline_exports, {
+  Pipeline: () => Pipeline
+});
+function logPipelineConfig(generator, filters) {
+  const filterList = filters.length > 0 ? "\n    - " + filters.map((f) => f.name).join("\n    - ") : " none";
+  logger.info(
+    `[Pipeline] Configuration:
+  Generator: ${generator.name}
+  Filters:${filterList}`
+  );
+}
+function logTagHydration(cards, tagsByCard) {
+  const totalTags = Array.from(tagsByCard.values()).reduce((sum, tags) => sum + tags.length, 0);
+  const cardsWithTags = Array.from(tagsByCard.values()).filter((tags) => tags.length > 0).length;
+  logger.debug(
+    `[Pipeline] Tag hydration: ${cards.length} cards, ${cardsWithTags} have tags (${totalTags} total tags) - single batch query`
+  );
+}
+function logExecutionSummary(generatorName, generatedCount, filterCount, finalCount, topScores) {
+  const scoreDisplay = topScores.length > 0 ? topScores.map((s) => s.toFixed(2)).join(", ") : "none";
+  logger.info(
+    `[Pipeline] Execution: ${generatorName} produced ${generatedCount} \u2192 ${filterCount} filters \u2192 ${finalCount} results (top scores: ${scoreDisplay})`
+  );
+}
+function logCardProvenance(cards, maxCards = 3) {
+  const cardsToLog = cards.slice(0, maxCards);
+  logger.debug(`[Pipeline] Provenance for top ${cardsToLog.length} cards:`);
+  for (const card of cardsToLog) {
+    logger.debug(`[Pipeline]   ${card.cardId} (final score: ${card.score.toFixed(3)}):`);
+    for (const entry of card.provenance) {
+      const scoreChange = entry.score.toFixed(3);
+      const action = entry.action.padEnd(9);
+      logger.debug(
+        `[Pipeline]     ${action} ${scoreChange} - ${entry.strategyName}: ${entry.reason}`
+      );
+    }
+  }
+}
+var import_common8, Pipeline;
+var init_Pipeline = __esm({
+  "src/core/navigators/Pipeline.ts"() {
+    "use strict";
+    import_common8 = require("@vue-skuilder/common");
+    init_navigators();
+    init_logger();
+    init_orchestration();
+    Pipeline = class extends ContentNavigator {
+      generator;
+      filters;
+      /**
+       * Create a new pipeline.
+       *
+       * @param generator - The generator (or CompositeGenerator) that produces candidates
+       * @param filters - Filters to apply sequentially (order doesn't matter for multipliers)
+       * @param user - User database interface
+       * @param course - Course database interface
+       */
+      constructor(generator, filters, user, course) {
+        super();
+        this.generator = generator;
+        this.filters = filters;
+        this.user = user;
+        this.course = course;
+        course.getCourseConfig().then((cfg) => {
+          logger.debug(`[pipeline] Crated pipeline for ${cfg.name}`);
+        }).catch((e) => {
+          logger.error(`[pipeline] Failed to lookup courseCfg: ${e}`);
+        });
+        logPipelineConfig(generator, filters);
+      }
+      /**
+       * Get weighted cards by running generator and applying filters.
+       *
+       * 1. Build shared context (user ELO, etc.)
+       * 2. Get candidates from generator (passing context)
+       * 3. Batch hydrate tags for all candidates
+       * 4. Apply each filter sequentially
+       * 5. Remove zero-score cards
+       * 6. Sort by score descending
+       * 7. Return top N
+       *
+       * @param limit - Maximum number of cards to return
+       * @returns Cards sorted by score descending
+       */
+      async getWeightedCards(limit) {
+        const context = await this.buildContext();
+        const overFetchMultiplier = 2 + this.filters.length * 0.5;
+        const fetchLimit = Math.ceil(limit * overFetchMultiplier);
+        logger.debug(
+          `[Pipeline] Fetching ${fetchLimit} candidates from generator '${this.generator.name}'`
+        );
+        let cards = await this.generator.getWeightedCards(fetchLimit, context);
+        const generatedCount = cards.length;
+        logger.debug(`[Pipeline] Generator returned ${generatedCount} candidates`);
+        cards = await this.hydrateTags(cards);
+        for (const filter of this.filters) {
+          const beforeCount = cards.length;
+          cards = await filter.transform(cards, context);
+          logger.debug(`[Pipeline] Filter '${filter.name}': ${beforeCount} \u2192 ${cards.length} cards`);
+        }
+        cards = cards.filter((c) => c.score > 0);
+        cards.sort((a, b) => b.score - a.score);
+        const result = cards.slice(0, limit);
+        const topScores = result.slice(0, 3).map((c) => c.score);
+        logExecutionSummary(
+          this.generator.name,
+          generatedCount,
+          this.filters.length,
+          result.length,
+          topScores
+        );
+        logCardProvenance(result, 3);
+        return result;
+      }
+      /**
+       * Batch hydrate tags for all cards.
+       *
+       * Fetches tags for all cards in a single database query and attaches them
+       * to the WeightedCard objects. Filters can then use card.tags instead of
+       * making individual getAppliedTags() calls.
+       *
+       * @param cards - Cards to hydrate
+       * @returns Cards with tags populated
+       */
+      async hydrateTags(cards) {
+        if (cards.length === 0) {
+          return cards;
+        }
+        const cardIds = cards.map((c) => c.cardId);
+        const tagsByCard = await this.course.getAppliedTagsBatch(cardIds);
+        logTagHydration(cards, tagsByCard);
+        return cards.map((card) => ({
+          ...card,
+          tags: tagsByCard.get(card.cardId) ?? []
+        }));
+      }
+      /**
+       * Build shared context for generator and filters.
+       *
+       * Called once per getWeightedCards() invocation.
+       * Contains data that the generator and multiple filters might need.
+       *
+       * The context satisfies both GeneratorContext and FilterContext interfaces.
+       */
+      async buildContext() {
+        let userElo = 1e3;
+        try {
+          const courseReg = await this.user.getCourseRegDoc(this.course.getCourseID());
+          const courseElo = (0, import_common8.toCourseElo)(courseReg.elo);
+          userElo = courseElo.global.score;
+        } catch (e) {
+          logger.debug(`[Pipeline] Could not get user ELO, using default: ${e}`);
+        }
+        const orchestration = await createOrchestrationContext(this.user, this.course);
+        return {
+          user: this.user,
+          course: this.course,
+          userElo,
+          orchestration
+        };
+      }
+      /**
+       * Get the course ID for this pipeline.
+       */
+      getCourseID() {
+        return this.course.getCourseID();
+      }
+      /**
+       * Get orchestration context for outcome recording.
+       */
+      async getOrchestrationContext() {
+        return createOrchestrationContext(this.user, this.course);
+      }
+      /**
+       * Get IDs of all strategies in this pipeline.
+       * Used to record which strategies contributed to an outcome.
+       */
+      getStrategyIds() {
+        const ids = [];
+        const extractId = (obj) => {
+          if (obj.strategyId) return obj.strategyId;
+          return null;
+        };
+        const genId = extractId(this.generator);
+        if (genId) ids.push(genId);
+        if (this.generator.generators && Array.isArray(this.generator.generators)) {
+          this.generator.generators.forEach((g) => {
+            const subId = extractId(g);
+            if (subId) ids.push(subId);
+          });
+        }
+        for (const filter of this.filters) {
+          const fId = extractId(filter);
+          if (fId) ids.push(fId);
+        }
+        return [...new Set(ids)];
+      }
+    };
+  }
+});
+
+// src/core/navigators/PipelineAssembler.ts
+var PipelineAssembler_exports = {};
+__export(PipelineAssembler_exports, {
+  PipelineAssembler: () => PipelineAssembler
+});
+var PipelineAssembler;
+var init_PipelineAssembler = __esm({
+  "src/core/navigators/PipelineAssembler.ts"() {
+    "use strict";
+    init_navigators();
+    init_WeightedFilter();
+    init_Pipeline();
+    init_types_legacy();
+    init_logger();
+    init_CompositeGenerator();
+    PipelineAssembler = class {
+      /**
+       * Assembles a navigation pipeline from strategy documents.
+       *
+       * 1. Separates into generators and filters by role
+       * 2. Validates at least one generator exists (or creates default ELO)
+       * 3. Instantiates generators - wraps multiple in CompositeGenerator
+       * 4. Instantiates filters
+       * 5. Returns Pipeline(generator, filters)
+       *
+       * @param input - Strategy documents plus user/course interfaces
+       * @returns Assembled pipeline and any warnings
+       */
+      async assemble(input) {
+        const { strategies, user, course } = input;
+        const warnings = [];
+        if (strategies.length === 0) {
+          return {
+            pipeline: null,
+            generatorStrategies: [],
+            filterStrategies: [],
+            warnings
+          };
+        }
+        const generatorStrategies = [];
+        const filterStrategies = [];
+        for (const s of strategies) {
+          if (isGenerator(s.implementingClass)) {
+            generatorStrategies.push(s);
+          } else if (isFilter(s.implementingClass)) {
+            filterStrategies.push(s);
+          } else {
+            warnings.push(`Unknown strategy type '${s.implementingClass}', skipping: ${s.name}`);
+          }
+        }
+        if (generatorStrategies.length === 0) {
+          if (filterStrategies.length > 0) {
+            logger.debug(
+              "[PipelineAssembler] No generator found, using default ELO with configured filters"
+            );
+            generatorStrategies.push(this.makeDefaultEloStrategy(course.getCourseID()));
+          } else {
+            warnings.push("No generator strategy found");
+            return {
+              pipeline: null,
+              generatorStrategies: [],
+              filterStrategies: [],
+              warnings
+            };
+          }
+        }
+        let generator;
+        if (generatorStrategies.length === 1) {
+          const nav = await ContentNavigator.create(user, course, generatorStrategies[0]);
+          generator = nav;
+          logger.debug(`[PipelineAssembler] Using single generator: ${generatorStrategies[0].name}`);
+        } else {
+          logger.debug(
+            `[PipelineAssembler] Using CompositeGenerator for ${generatorStrategies.length} generators: ${generatorStrategies.map((g) => g.name).join(", ")}`
+          );
+          generator = await CompositeGenerator.fromStrategies(user, course, generatorStrategies);
+        }
+        const filters = [];
+        const sortedFilterStrategies = [...filterStrategies].sort(
+          (a, b) => a.name.localeCompare(b.name)
+        );
+        for (const filterStrategy of sortedFilterStrategies) {
+          try {
+            const nav = await ContentNavigator.create(user, course, filterStrategy);
+            if ("transform" in nav && typeof nav.transform === "function") {
+              let filter = nav;
+              if (filterStrategy.learnable) {
+                filter = new WeightedFilter(
+                  filter,
+                  filterStrategy.learnable,
+                  filterStrategy.staticWeight,
+                  filterStrategy._id
+                );
+              }
+              filters.push(filter);
+              logger.debug(`[PipelineAssembler] Added filter: ${filterStrategy.name}`);
+            } else {
+              warnings.push(
+                `Filter '${filterStrategy.name}' does not implement CardFilter.transform(), skipping`
+              );
+            }
+          } catch (e) {
+            warnings.push(`Failed to instantiate filter '${filterStrategy.name}': ${e}`);
+          }
+        }
+        const pipeline = new Pipeline(generator, filters, user, course);
+        logger.debug(
+          `[PipelineAssembler] Assembled pipeline with ${generatorStrategies.length} generator(s) and ${filters.length} filter(s)`
+        );
+        return {
+          pipeline,
+          generatorStrategies,
+          filterStrategies: sortedFilterStrategies,
+          warnings
+        };
+      }
+      /**
+       * Creates a default ELO generator strategy.
+       * Used when filters are configured but no generator is specified.
+       */
+      makeDefaultEloStrategy(courseId) {
+        return {
+          _id: "NAVIGATION_STRATEGY-ELO-default",
+          course: courseId,
+          docType: "NAVIGATION_STRATEGY" /* NAVIGATION_STRATEGY */,
+          name: "ELO (default)",
+          description: "Default ELO-based generator",
+          implementingClass: "elo" /* ELO */,
+          serializedData: ""
+        };
+      }
+    };
+  }
+});
+
+// src/core/navigators/defaults.ts
+var defaults_exports = {};
+__export(defaults_exports, {
+  createDefaultEloStrategy: () => createDefaultEloStrategy,
+  createDefaultPipeline: () => createDefaultPipeline,
+  createDefaultSrsStrategy: () => createDefaultSrsStrategy
+});
+function createDefaultEloStrategy(courseId) {
+  return {
+    _id: "NAVIGATION_STRATEGY-ELO-default",
+    docType: "NAVIGATION_STRATEGY" /* NAVIGATION_STRATEGY */,
+    name: "ELO (default)",
+    description: "Default ELO-based navigation strategy for new cards",
+    implementingClass: "elo" /* ELO */,
+    course: courseId,
+    serializedData: ""
+  };
+}
+function createDefaultSrsStrategy(courseId) {
+  return {
+    _id: "NAVIGATION_STRATEGY-SRS-default",
+    docType: "NAVIGATION_STRATEGY" /* NAVIGATION_STRATEGY */,
+    name: "SRS (default)",
+    description: "Default SRS-based navigation strategy for reviews",
+    implementingClass: "srs" /* SRS */,
+    course: courseId,
+    serializedData: ""
+  };
+}
+function createDefaultPipeline(user, course) {
+  const courseId = course.getCourseID();
+  const eloNavigator = new ELONavigator(user, course, createDefaultEloStrategy(courseId));
+  const srsNavigator = new SRSNavigator(user, course, createDefaultSrsStrategy(courseId));
+  const compositeGenerator = new CompositeGenerator([eloNavigator, srsNavigator]);
+  const eloDistanceFilter = createEloDistanceFilter();
+  return new Pipeline(compositeGenerator, [eloDistanceFilter], user, course);
+}
+var init_defaults = __esm({
+  "src/core/navigators/defaults.ts"() {
+    "use strict";
+    init_navigators();
+    init_Pipeline();
+    init_CompositeGenerator();
+    init_elo();
+    init_srs();
+    init_eloDistance();
+    init_types_legacy();
+  }
+});
+
+// import("./**/*") in src/core/navigators/index.ts
+var globImport;
+var init_3 = __esm({
+  'import("./**/*") in src/core/navigators/index.ts'() {
+    globImport = __glob({
+      "./Pipeline.ts": () => Promise.resolve().then(() => (init_Pipeline(), Pipeline_exports)),
+      "./PipelineAssembler.ts": () => Promise.resolve().then(() => (init_PipelineAssembler(), PipelineAssembler_exports)),
+      "./defaults.ts": () => Promise.resolve().then(() => (init_defaults(), defaults_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)),
+      "./filters/index.ts": () => Promise.resolve().then(() => (init_filters(), filters_exports)),
+      "./filters/inferredPreferenceStub.ts": () => Promise.resolve().then(() => (init_inferredPreferenceStub(), inferredPreferenceStub_exports)),
+      "./filters/interferenceMitigator.ts": () => Promise.resolve().then(() => (init_interferenceMitigator(), interferenceMitigator_exports)),
+      "./filters/relativePriority.ts": () => Promise.resolve().then(() => (init_relativePriority(), relativePriority_exports)),
+      "./filters/types.ts": () => Promise.resolve().then(() => (init_types2(), types_exports2)),
+      "./filters/userGoalStub.ts": () => Promise.resolve().then(() => (init_userGoalStub(), userGoalStub_exports)),
+      "./filters/userTagPreference.ts": () => Promise.resolve().then(() => (init_userTagPreference(), userTagPreference_exports)),
+      "./generators/CompositeGenerator.ts": () => Promise.resolve().then(() => (init_CompositeGenerator(), CompositeGenerator_exports)),
+      "./generators/elo.ts": () => Promise.resolve().then(() => (init_elo(), elo_exports)),
+      "./generators/index.ts": () => Promise.resolve().then(() => (init_generators(), generators_exports)),
+      "./generators/srs.ts": () => Promise.resolve().then(() => (init_srs(), srs_exports)),
+      "./generators/types.ts": () => Promise.resolve().then(() => (init_types(), types_exports)),
+      "./index.ts": () => Promise.resolve().then(() => (init_navigators(), navigators_exports))
+    });
+  }
+});
+
+// src/core/navigators/index.ts
+var navigators_exports = {};
+__export(navigators_exports, {
+  ContentNavigator: () => ContentNavigator,
+  NavigatorRole: () => NavigatorRole,
+  NavigatorRoles: () => NavigatorRoles,
+  Navigators: () => Navigators,
+  getCardOrigin: () => getCardOrigin,
+  getRegisteredNavigator: () => getRegisteredNavigator,
+  getRegisteredNavigatorNames: () => getRegisteredNavigatorNames,
+  hasRegisteredNavigator: () => hasRegisteredNavigator,
+  initializeNavigatorRegistry: () => initializeNavigatorRegistry,
+  isFilter: () => isFilter,
+  isGenerator: () => isGenerator,
+  registerNavigator: () => registerNavigator
+});
+function registerNavigator(implementingClass, constructor) {
+  navigatorRegistry.set(implementingClass, constructor);
+  logger.debug(`[NavigatorRegistry] Registered: ${implementingClass}`);
+}
+function getRegisteredNavigator(implementingClass) {
+  return navigatorRegistry.get(implementingClass);
+}
+function hasRegisteredNavigator(implementingClass) {
+  return navigatorRegistry.has(implementingClass);
+}
+function getRegisteredNavigatorNames() {
+  return Array.from(navigatorRegistry.keys());
+}
+async function initializeNavigatorRegistry() {
+  logger.debug("[NavigatorRegistry] Initializing built-in navigators...");
+  const [eloModule, srsModule] = await Promise.all([
+    Promise.resolve().then(() => (init_elo(), elo_exports)),
+    Promise.resolve().then(() => (init_srs(), srs_exports))
+  ]);
+  registerNavigator("elo", eloModule.default);
+  registerNavigator("srs", srsModule.default);
+  const [
+    hierarchyModule,
+    interferenceModule,
+    relativePriorityModule,
+    userTagPreferenceModule
+  ] = await Promise.all([
+    Promise.resolve().then(() => (init_hierarchyDefinition(), hierarchyDefinition_exports)),
+    Promise.resolve().then(() => (init_interferenceMitigator(), interferenceMitigator_exports)),
+    Promise.resolve().then(() => (init_relativePriority(), relativePriority_exports)),
+    Promise.resolve().then(() => (init_userTagPreference(), userTagPreference_exports))
+  ]);
+  registerNavigator("hierarchyDefinition", hierarchyModule.default);
+  registerNavigator("interferenceMitigator", interferenceModule.default);
+  registerNavigator("relativePriority", relativePriorityModule.default);
+  registerNavigator("userTagPreference", userTagPreferenceModule.default);
+  logger.debug(
+    `[NavigatorRegistry] Initialized ${navigatorRegistry.size} navigators: ${getRegisteredNavigatorNames().join(", ")}`
+  );
+}
+function getCardOrigin(card) {
+  if (card.provenance.length === 0) {
+    throw new Error("Card has no provenance - cannot determine origin");
+  }
+  const firstEntry = card.provenance[0];
+  const reason = firstEntry.reason.toLowerCase();
+  if (reason.includes("failed")) {
+    return "failed";
+  }
+  if (reason.includes("review")) {
+    return "review";
+  }
+  return "new";
+}
+function isGenerator(impl) {
+  return NavigatorRoles[impl] === "generator" /* GENERATOR */;
+}
+function isFilter(impl) {
+  return NavigatorRoles[impl] === "filter" /* FILTER */;
+}
+var navigatorRegistry, Navigators, NavigatorRole, NavigatorRoles, ContentNavigator;
+var init_navigators = __esm({
+  "src/core/navigators/index.ts"() {
+    "use strict";
+    init_logger();
+    init_();
+    init_2();
+    init_3();
+    navigatorRegistry = /* @__PURE__ */ new Map();
+    Navigators = /* @__PURE__ */ ((Navigators2) => {
+      Navigators2["ELO"] = "elo";
+      Navigators2["SRS"] = "srs";
+      Navigators2["HIERARCHY"] = "hierarchyDefinition";
+      Navigators2["INTERFERENCE"] = "interferenceMitigator";
+      Navigators2["RELATIVE_PRIORITY"] = "relativePriority";
+      Navigators2["USER_TAG_PREFERENCE"] = "userTagPreference";
+      return Navigators2;
+    })(Navigators || {});
+    NavigatorRole = /* @__PURE__ */ ((NavigatorRole2) => {
+      NavigatorRole2["GENERATOR"] = "generator";
+      NavigatorRole2["FILTER"] = "filter";
+      return NavigatorRole2;
+    })(NavigatorRole || {});
+    NavigatorRoles = {
+      ["elo" /* ELO */]: "generator" /* GENERATOR */,
+      ["srs" /* SRS */]: "generator" /* GENERATOR */,
+      ["hierarchyDefinition" /* HIERARCHY */]: "filter" /* FILTER */,
+      ["interferenceMitigator" /* INTERFERENCE */]: "filter" /* FILTER */,
+      ["relativePriority" /* RELATIVE_PRIORITY */]: "filter" /* FILTER */,
+      ["userTagPreference" /* USER_TAG_PREFERENCE */]: "filter" /* FILTER */
+    };
+    ContentNavigator = class {
+      /** User interface for this navigation session */
+      user;
+      /** Course interface for this navigation session */
+      course;
+      /** Human-readable name for this strategy instance (from ContentNavigationStrategyData.name) */
+      strategyName;
+      /** Unique document ID for this strategy instance (from ContentNavigationStrategyData._id) */
+      strategyId;
+      /** Evolutionary weighting configuration */
+      learnable;
+      /** Whether to bypass deviation (manual/static weighting) */
+      staticWeight;
+      /**
+       * Constructor for standard navigators.
+       * Call this from subclass constructors to initialize common fields.
+       *
+       * Note: CompositeGenerator and Pipeline call super() without args, then set
+       * user/course fields directly if needed.
+       */
+      constructor(user, course, strategyData) {
+        this.user = user;
+        this.course = course;
+        if (strategyData) {
+          this.strategyName = strategyData.name;
+          this.strategyId = strategyData._id;
+          this.learnable = strategyData.learnable;
+          this.staticWeight = strategyData.staticWeight;
+        }
+      }
+      // ============================================================================
+      // STRATEGY STATE HELPERS
+      // ============================================================================
+      //
+      // These methods allow strategies to persist their own state (user preferences,
+      // learned patterns, temporal tracking) in the user database.
+      //
+      // ============================================================================
+      /**
+       * Unique key identifying this strategy for state storage.
+       *
+       * Defaults to the constructor name (e.g., "UserTagPreferenceFilter").
+       * Override in subclasses if multiple instances of the same strategy type
+       * need separate state storage.
+       */
+      get strategyKey() {
+        return this.constructor.name;
+      }
+      /**
+       * Get this strategy's persisted state for the current course.
+       *
+       * @returns The strategy's data payload, or null if no state exists
+       * @throws Error if user or course is not initialized
+       */
+      async getStrategyState() {
+        if (!this.user || !this.course) {
+          throw new Error(
+            `Cannot get strategy state: navigator not properly initialized. Ensure user and course are provided to constructor.`
+          );
+        }
+        return this.user.getStrategyState(this.course.getCourseID(), this.strategyKey);
+      }
+      /**
+       * Persist this strategy's state for the current course.
+       *
+       * @param data - The strategy's data payload to store
+       * @throws Error if user or course is not initialized
+       */
+      async putStrategyState(data) {
+        if (!this.user || !this.course) {
+          throw new Error(
+            `Cannot put strategy state: navigator not properly initialized. Ensure user and course are provided to constructor.`
+          );
+        }
+        return this.user.putStrategyState(this.course.getCourseID(), this.strategyKey, data);
+      }
+      /**
+       * Factory method to create navigator instances.
+       *
+       * First checks the navigator registry for a pre-registered constructor.
+       * If not found, falls back to dynamic import (for custom navigators).
+       *
+       * For reliable operation in test environments, call initializeNavigatorRegistry()
+       * before using this method.
+       *
+       * @param user - User interface
+       * @param course - Course interface
+       * @param strategyData - Strategy configuration document
+       * @returns the runtime object used to steer a study session.
+       */
+      static async create(user, course, strategyData) {
+        const implementingClass = strategyData.implementingClass;
+        const RegisteredImpl = getRegisteredNavigator(implementingClass);
+        if (RegisteredImpl) {
+          logger.debug(`[ContentNavigator.create] Using registered navigator: ${implementingClass}`);
+          return new RegisteredImpl(user, course, strategyData);
+        }
+        logger.debug(
+          `[ContentNavigator.create] Navigator not in registry, attempting dynamic import: ${implementingClass}`
+        );
+        let NavigatorImpl;
+        const variations = [".ts", ".js", ""];
+        for (const ext of variations) {
+          try {
+            const module2 = await globImport_generators(`./generators/${implementingClass}${ext}`);
+            NavigatorImpl = module2.default;
+            if (NavigatorImpl) break;
+          } catch (e) {
+            logger.debug(`Failed to load generator ${implementingClass}${ext}:`, e);
+          }
+          try {
+            const module2 = await globImport_filters(`./filters/${implementingClass}${ext}`);
+            NavigatorImpl = module2.default;
+            if (NavigatorImpl) break;
+          } catch (e) {
+            logger.debug(`Failed to load filter ${implementingClass}${ext}:`, e);
+          }
+          try {
+            const module2 = await globImport(`./${implementingClass}${ext}`);
+            NavigatorImpl = module2.default;
+            if (NavigatorImpl) break;
+          } catch (e) {
+            logger.debug(`Failed to load legacy ${implementingClass}${ext}:`, e);
+          }
+          if (NavigatorImpl) break;
+        }
+        if (!NavigatorImpl) {
+          throw new Error(`Could not load navigator implementation for: ${implementingClass}`);
+        }
+        return new NavigatorImpl(user, course, strategyData);
       }
       /**
-       * Get review cards scored by urgency.
-       *
-       * Score formula combines:
-       * - Relative overdueness: hoursOverdue / intervalHours
-       * - Interval recency: exponential decay favoring shorter intervals
+       * Get cards with suitability scores and provenance trails.
        *
-       * Cards not yet due are excluded (not scored as 0).
+       * **This is the PRIMARY API for navigation strategies.**
        *
-       * This method supports both the legacy signature (limit only) and the
-       * CardGenerator interface signature (limit, context).
+       * Returns cards ranked by suitability score (0-1). Higher scores indicate
+       * better candidates for presentation. Each card includes a provenance trail
+       * documenting how strategies contributed to the final score.
        *
-       * @param limit - Maximum number of cards to return
-       * @param _context - Optional GeneratorContext (currently unused, but required for interface)
-       */
-      async getWeightedCards(limit, _context) {
-        if (!this.user || !this.course) {
-          throw new Error("SRSNavigator requires user and course to be set");
-        }
-        const reviews = await this.user.getPendingReviews(this.course.getCourseID());
-        const now = import_moment3.default.utc();
-        const dueReviews = reviews.filter((r) => now.isAfter(import_moment3.default.utc(r.reviewTime)));
-        const scored = dueReviews.map((review) => {
-          const { score, reason } = this.computeUrgencyScore(review, now);
-          return {
-            cardId: review.cardId,
-            courseId: review.courseId,
-            score,
-            reviewID: review._id,
-            provenance: [
-              {
-                strategy: "srs",
-                strategyName: this.strategyName || this.name,
-                strategyId: this.strategyId || "NAVIGATION_STRATEGY-SRS-default",
-                action: "generated",
-                score,
-                reason
-              }
-            ]
-          };
-        });
-        logger.debug(`[srsNav] got ${scored.length} weighted cards`);
-        return scored.sort((a, b) => b.score - a.score).slice(0, limit);
-      }
-      /**
-       * Compute urgency score for a review card.
+       * ## Implementation Required
+       * All navigation strategies MUST override this method. The base class does
+       * not provide a default implementation.
        *
-       * Two factors:
-       * 1. Relative overdueness = hoursOverdue / intervalHours
-       *    - 2 days overdue on 3-day interval = 0.67 (urgent)
-       *    - 2 days overdue on 180-day interval = 0.01 (not urgent)
+       * ## For Generators
+       * Override this method to generate candidates and compute scores based on
+       * your strategy's logic (e.g., ELO proximity, review urgency). Create the
+       * initial provenance entry with action='generated'.
        *
-       * 2. Interval recency factor = 0.3 + 0.7 * exp(-intervalHours / 720)
-       *    - 24h interval → ~1.0 (very recent learning)
-       *    - 30 days (720h) → ~0.56
-       *    - 180 days → ~0.30
+       * ## For Filters
+       * Filters should implement the CardFilter interface instead and be composed
+       * via Pipeline. Filters do not directly implement getWeightedCards().
        *
-       * Combined: base 0.5 + weighted average of factors * 0.45
-       * Result range: approximately 0.5 to 0.95
+       * @param limit - Maximum cards to return
+       * @returns Cards sorted by score descending, with provenance trails
        */
-      computeUrgencyScore(review, now) {
-        const scheduledAt = import_moment3.default.utc(review.scheduledAt);
-        const due = import_moment3.default.utc(review.reviewTime);
-        const intervalHours = Math.max(1, due.diff(scheduledAt, "hours"));
-        const hoursOverdue = now.diff(due, "hours");
-        const relativeOverdue = hoursOverdue / intervalHours;
-        const recencyFactor = 0.3 + 0.7 * Math.exp(-intervalHours / 720);
-        const overdueContribution = Math.min(1, Math.max(0, relativeOverdue));
-        const urgency = overdueContribution * 0.5 + recencyFactor * 0.5;
-        const score = Math.min(0.95, 0.5 + urgency * 0.45);
-        const reason = `${Math.round(hoursOverdue)}h overdue (interval: ${Math.round(intervalHours)}h, relative: ${relativeOverdue.toFixed(2)}), recency: ${recencyFactor.toFixed(2)}, review`;
-        return { score, reason };
+      async getWeightedCards(_limit) {
+        throw new Error(`${this.constructor.name} must implement getWeightedCards(). `);
       }
     };
   }
 });
 
-// src/core/navigators/filters/eloDistance.ts
-function computeMultiplier(distance, halfLife, minMultiplier, maxMultiplier) {
-  const normalizedDistance = distance / halfLife;
-  const decay = Math.exp(-(normalizedDistance * normalizedDistance));
-  return minMultiplier + (maxMultiplier - minMultiplier) * decay;
-}
-function createEloDistanceFilter(config) {
-  const halfLife = config?.halfLife ?? DEFAULT_HALF_LIFE;
-  const minMultiplier = config?.minMultiplier ?? DEFAULT_MIN_MULTIPLIER;
-  const maxMultiplier = config?.maxMultiplier ?? DEFAULT_MAX_MULTIPLIER;
-  return {
-    name: "ELO Distance Filter",
-    async transform(cards, context) {
-      const { course, userElo } = context;
-      const cardIds = cards.map((c) => c.cardId);
-      const cardElos = await course.getCardEloData(cardIds);
-      return cards.map((card, i) => {
-        const cardElo = cardElos[i]?.global?.score ?? 1e3;
-        const distance = Math.abs(cardElo - userElo);
-        const multiplier = computeMultiplier(distance, halfLife, minMultiplier, maxMultiplier);
-        const newScore = card.score * multiplier;
-        const action = multiplier < maxMultiplier - 0.01 ? "penalized" : "passed";
-        return {
-          ...card,
-          score: newScore,
-          provenance: [
-            ...card.provenance,
-            {
-              strategy: "eloDistance",
-              strategyName: "ELO Distance Filter",
-              strategyId: "ELO_DISTANCE_FILTER",
-              action,
-              score: newScore,
-              reason: `ELO distance ${Math.round(distance)} (card: ${Math.round(cardElo)}, user: ${Math.round(userElo)}) \u2192 ${multiplier.toFixed(2)}x`
-            }
-          ]
-        };
-      });
-    }
-  };
-}
-var DEFAULT_HALF_LIFE, DEFAULT_MIN_MULTIPLIER, DEFAULT_MAX_MULTIPLIER;
-var init_eloDistance = __esm({
-  "src/core/navigators/filters/eloDistance.ts"() {
-    "use strict";
-    DEFAULT_HALF_LIFE = 200;
-    DEFAULT_MIN_MULTIPLIER = 0.3;
-    DEFAULT_MAX_MULTIPLIER = 1;
-  }
-});
-
-// src/core/navigators/defaults.ts
-function createDefaultEloStrategy(courseId) {
-  return {
-    _id: "NAVIGATION_STRATEGY-ELO-default",
-    docType: "NAVIGATION_STRATEGY" /* NAVIGATION_STRATEGY */,
-    name: "ELO (default)",
-    description: "Default ELO-based navigation strategy for new cards",
-    implementingClass: "elo" /* ELO */,
-    course: courseId,
-    serializedData: ""
-  };
-}
-function createDefaultSrsStrategy(courseId) {
-  return {
-    _id: "NAVIGATION_STRATEGY-SRS-default",
-    docType: "NAVIGATION_STRATEGY" /* NAVIGATION_STRATEGY */,
-    name: "SRS (default)",
-    description: "Default SRS-based navigation strategy for reviews",
-    implementingClass: "srs" /* SRS */,
-    course: courseId,
-    serializedData: ""
-  };
-}
-function createDefaultPipeline(user, course) {
-  const courseId = course.getCourseID();
-  const eloNavigator = new ELONavigator(user, course, createDefaultEloStrategy(courseId));
-  const srsNavigator = new SRSNavigator(user, course, createDefaultSrsStrategy(courseId));
-  const compositeGenerator = new CompositeGenerator([eloNavigator, srsNavigator]);
-  const eloDistanceFilter = createEloDistanceFilter();
-  return new Pipeline(compositeGenerator, [eloDistanceFilter], user, course);
-}
-var init_defaults = __esm({
-  "src/core/navigators/defaults.ts"() {
-    "use strict";
-    init_navigators();
-    init_Pipeline();
-    init_CompositeGenerator();
-    init_elo();
-    init_srs();
-    init_eloDistance();
-    init_types_legacy();
-  }
-});
-
 // src/impl/couch/courseDB.ts
 function randIntWeightedTowardZero(n) {
   return Math.floor(Math.random() * Math.random() * Math.random() * n);
@@ -1794,11 +3228,11 @@ ${JSON.stringify(config)}
 function isSuccessRow(row) {
   return "doc" in row && row.doc !== null && row.doc !== void 0;
 }
-var import_common7, CoursesDB, CourseDB;
+var import_common9, CoursesDB, CourseDB;
 var init_courseDB = __esm({
   "src/impl/couch/courseDB.ts"() {
     "use strict";
-    import_common7 = require("@vue-skuilder/common");
+    import_common9 = require("@vue-skuilder/common");
     init_couch();
     init_updateQueue();
     init_types_legacy();
@@ -1920,14 +3354,14 @@ var init_courseDB = __esm({
         docs.rows.forEach((r) => {
           if (isSuccessRow(r)) {
             if (r.doc && r.doc.elo) {
-              ret.push((0, import_common7.toCourseElo)(r.doc.elo));
+              ret.push((0, import_common9.toCourseElo)(r.doc.elo));
             } else {
               logger.warn("no elo data for card: " + r.id);
-              ret.push((0, import_common7.blankCourseElo)());
+              ret.push((0, import_common9.blankCourseElo)());
             }
           } else {
             logger.warn("no elo data for card: " + JSON.stringify(r));
-            ret.push((0, import_common7.blankCourseElo)());
+            ret.push((0, import_common9.blankCourseElo)());
           }
         });
         return ret;
@@ -2122,7 +3556,7 @@ ${above.rows.map((r) => `	${r.id}-${r.key}
       async getCourseTagStubs() {
         return getCourseTagStubs(this.id);
       }
-      async addNote(codeCourse, shape, data, author, tags, uploads, elo = (0, import_common7.blankCourseElo)()) {
+      async addNote(codeCourse, shape, data, author, tags, uploads, elo = (0, import_common9.blankCourseElo)()) {
         try {
           const resp = await addNote55(this.id, codeCourse, shape, data, author, tags, uploads, elo);
           if (resp.ok) {
@@ -2131,19 +3565,19 @@ ${above.rows.map((r) => `	${r.id}-${r.key}
                 `[courseDB.addNote] Note added but card creation failed: ${resp.cardCreationError}`
               );
               return {
-                status: import_common7.Status.error,
+                status: import_common9.Status.error,
                 message: `Note was added but no cards were created: ${resp.cardCreationError}`,
                 id: resp.id
               };
             }
             return {
-              status: import_common7.Status.ok,
+              status: import_common9.Status.ok,
               message: "",
               id: resp.id
             };
           } else {
             return {
-              status: import_common7.Status.error,
+              status: import_common9.Status.error,
               message: "Unexpected error adding note"
             };
           }
@@ -2155,7 +3589,7 @@ ${above.rows.map((r) => `	${r.id}-${r.key}
 	message: ${err.message}`
           );
           return {
-            status: import_common7.Status.error,
+            status: import_common9.Status.error,
             message: `Error adding note to course. ${e.reason || err.message}`
           };
         }
@@ -2283,7 +3717,7 @@ ${above.rows.map((r) => `	${r.id}-${r.key}
             const courseDoc = (await u.getCourseRegistrationsDoc()).courses.find((c) => {
               return c.courseID === this.id;
             });
-            targetElo = (0, import_common7.EloToNumber)(courseDoc.elo);
+            targetElo = (0, import_common9.EloToNumber)(courseDoc.elo);
           } catch {
             targetElo = 1e3;
           }
@@ -2802,14 +4236,14 @@ var CouchDBSyncStrategy_exports = {};
 __export(CouchDBSyncStrategy_exports, {
   CouchDBSyncStrategy: () => CouchDBSyncStrategy
 });
-var import_common8, log3, CouchDBSyncStrategy;
+var import_common10, log3, CouchDBSyncStrategy;
 var init_CouchDBSyncStrategy = __esm({
   "src/impl/couch/CouchDBSyncStrategy.ts"() {
     "use strict";
     init_factory();
     init_types_legacy();
     init_logger();
-    import_common8 = require("@vue-skuilder/common");
+    import_common10 = require("@vue-skuilder/common");
     init_common();
     init_pouchdb_setup();
     init_couch();
@@ -2880,32 +4314,32 @@ var init_CouchDBSyncStrategy = __esm({
                 }
               }
               return {
-                status: import_common8.Status.ok,
+                status: import_common10.Status.ok,
                 error: void 0
               };
             } else {
               return {
-                status: import_common8.Status.error,
+                status: import_common10.Status.error,
                 error: "Failed to log in after account creation"
               };
             }
           } else {
             logger.warn(`Signup not OK: ${JSON.stringify(signupRequest)}`);
             return {
-              status: import_common8.Status.error,
+              status: import_common10.Status.error,
               error: "Account creation failed"
             };
           }
         } catch (e) {
           if (e.reason === "Document update conflict.") {
             return {
-              status: import_common8.Status.error,
+              status: import_common10.Status.error,
               error: "This username is taken!"
             };
           }
           logger.error(`Error on signup: ${JSON.stringify(e)}`);
           return {
-            status: import_common8.Status.error,
+            status: import_common10.Status.error,
             error: e.message || "Unknown error during account creation"
           };
         }
@@ -3286,13 +4720,13 @@ async function dropUserFromClassroom(user, classID) {
 async function getUserClassrooms(user) {
   return getOrCreateClassroomRegistrationsDoc(user);
 }
-var import_common10, import_moment6, log4, BaseUser, userCoursesDoc, userClassroomsDoc;
+var import_common12, import_moment6, log4, BaseUser, userCoursesDoc, userClassroomsDoc;
 var init_BaseUserDB = __esm({
   "src/impl/common/BaseUserDB.ts"() {
     "use strict";
     init_core();
     init_util();
-    import_common10 = require("@vue-skuilder/common");
+    import_common12 = require("@vue-skuilder/common");
     import_moment6 = __toESM(require("moment"), 1);
     init_types_legacy();
     init_logger();
@@ -3342,7 +4776,7 @@ Currently logged-in as ${this._username}.`
           );
         }
         const result = await this.syncStrategy.createAccount(username, password);
-        if (result.status === import_common10.Status.ok) {
+        if (result.status === import_common12.Status.ok) {
           log4(`Account created successfully, updating username to ${username}`);
           this._username = username;
           try {
@@ -3384,7 +4818,7 @@ Currently logged-in as ${this._username}.`
       async resetUserData() {
         if (this.syncStrategy.canAuthenticate()) {
           return {
-            status: import_common10.Status.error,
+            status: import_common12.Status.error,
             error: "Reset user data is only available for local-only mode. Use logout instead for remote sync."
           };
         }
@@ -3403,11 +4837,11 @@ Currently logged-in as ${this._username}.`
             await localDB.bulkDocs(docsToDelete);
           }
           await this.init();
-          return { status: import_common10.Status.ok };
+          return { status: import_common12.Status.ok };
         } catch (error) {
           logger.error("Failed to reset user data:", error);
           return {
-            status: import_common10.Status.error,
+            status: import_common12.Status.error,
             error: error instanceof Error ? error.message : "Unknown error during reset"
           };
         }
@@ -4134,6 +5568,19 @@ Currently logged-in as ${this._username}.`
         };
         await this.localDB.put(doc);
       }
+      async putUserOutcome(record) {
+        try {
+          await this.localDB.put(record);
+        } catch (err) {
+          if (err.status === 409) {
+            const existing = await this.localDB.get(record._id);
+            record._rev = existing._rev;
+            await this.localDB.put(record);
+          } else {
+            throw err;
+          }
+        }
+      }
       async deleteStrategyState(courseId, strategyKey) {
         const docId = buildStrategyStateId(courseId, strategyKey);
         try {
@@ -4666,11 +6113,11 @@ var init_StaticDataUnpacker = __esm({
 });
 
 // src/impl/static/courseDB.ts
-var import_common12, StaticCourseDB;
+var import_common14, StaticCourseDB;
 var init_courseDB2 = __esm({
   "src/impl/static/courseDB.ts"() {
     "use strict";
-    import_common12 = require("@vue-skuilder/common");
+    import_common14 = require("@vue-skuilder/common");
     init_types_legacy();
     init_logger();
     init_defaults();
@@ -4927,7 +6374,7 @@ var init_courseDB2 = __esm({
       }
       async addNote(_codeCourse, _shape, _data, _author, _tags, _uploads, _elo) {
         return {
-          status: import_common12.Status.error,
+          status: import_common14.Status.error,
           message: "Cannot add notes in static mode"
         };
       }
@@ -5261,6 +6708,7 @@ async function initializeDataLayer(config) {
     logger.warn("Data layer already initialized. Returning existing instance.");
     return dataLayerInstance;
   }
+  await initializeNavigatorRegistry();
   if (config.options.localStoragePrefix) {
     ENV.LOCAL_STORAGE_PREFIX = config.options.localStoragePrefix;
   }
@@ -5315,6 +6763,7 @@ var init_factory = __esm({
     "use strict";
     init_common();
     init_logger();
+    init_navigators();
     NOT_SET = "NOT_SET";
     ENV = {
       COUCHDB_SERVER_PROTOCOL: NOT_SET,
@@ -5326,11 +6775,11 @@ var init_factory = __esm({
 });
 
 // src/study/TagFilteredContentSource.ts
-var import_common16, TagFilteredContentSource;
+var import_common18, TagFilteredContentSource;
 var init_TagFilteredContentSource = __esm({
   "src/study/TagFilteredContentSource.ts"() {
     "use strict";
-    import_common16 = require("@vue-skuilder/common");
+    import_common18 = require("@vue-skuilder/common");
     init_courseDB();
     init_logger();
     TagFilteredContentSource = class {
@@ -5416,7 +6865,7 @@ var init_TagFilteredContentSource = __esm({
        * @returns Cards sorted by score descending (all scores = 1.0)
        */
       async getWeightedCards(limit) {
-        if (!(0, import_common16.hasActiveFilter)(this.filter)) {
+        if (!(0, import_common18.hasActiveFilter)(this.filter)) {
           logger.warn("[TagFilteredContentSource] getWeightedCards called with no active filter");
           return [];
         }
@@ -5504,19 +6953,19 @@ async function getStudySource(source, user) {
   if (source.type === "classroom") {
     return await StudentClassroomDB.factory(source.id, user);
   } else {
-    if ((0, import_common17.hasActiveFilter)(source.tagFilter)) {
+    if ((0, import_common19.hasActiveFilter)(source.tagFilter)) {
       return new TagFilteredContentSource(source.id, source.tagFilter, user);
     }
     return getDataLayer().getCourseDB(source.id);
   }
 }
-var import_common17;
+var import_common19;
 var init_contentSource = __esm({
   "src/core/interfaces/contentSource.ts"() {
     "use strict";
     init_factory();
     init_classroomDB2();
-    import_common17 = require("@vue-skuilder/common");
+    import_common19 = require("@vue-skuilder/common");
     init_TagFilteredContentSource();
   }
 });
@@ -5572,6 +7021,13 @@ var init_strategyState = __esm({
   }
 });
 
+// src/core/types/userOutcome.ts
+var init_userOutcome = __esm({
+  "src/core/types/userOutcome.ts"() {
+    "use strict";
+  }
+});
+
 // src/core/bulkImport/cardProcessor.ts
 async function importParsedCards(parsedCards, courseDB, config) {
   const results = [];
@@ -5640,7 +7096,7 @@ elo: ${elo}`;
         misc: {}
       } : void 0
     );
-    if (result.status === import_common18.Status.ok) {
+    if (result.status === import_common20.Status.ok) {
       return {
         originalText,
         status: "success",
@@ -5684,17 +7140,17 @@ function validateProcessorConfig(config) {
   }
   return { isValid: true };
 }
-var import_common18;
+var import_common20;
 var init_cardProcessor = __esm({
   "src/core/bulkImport/cardProcessor.ts"() {
     "use strict";
-    import_common18 = require("@vue-skuilder/common");
+    import_common20 = require("@vue-skuilder/common");
     init_logger();
   }
 });
 
 // src/core/bulkImport/types.ts
-var init_types = __esm({
+var init_types3 = __esm({
   "src/core/bulkImport/types.ts"() {
     "use strict";
   }
@@ -5705,7 +7161,7 @@ var init_bulkImport = __esm({
   "src/core/bulkImport/index.ts"() {
     "use strict";
     init_cardProcessor();
-    init_types();
+    init_types3();
   }
 });
 
@@ -5717,10 +7173,12 @@ var init_core = __esm({
     init_types_legacy();
     init_user();
     init_strategyState();
+    init_userOutcome();
     init_Loggable();
     init_util();
     init_navigators();
     init_bulkImport();
+    init_orchestration();
   }
 });
 
@@ -5745,8 +7203,15 @@ __export(index_exports, {
   StaticToCouchDBMigrator: () => StaticToCouchDBMigrator,
   TagFilteredContentSource: () => TagFilteredContentSource,
   _resetDataLayer: () => _resetDataLayer,
+  aggregateOutcomesForGradient: () => aggregateOutcomesForGradient,
   areQuestionRecords: () => areQuestionRecords,
   buildStrategyStateId: () => buildStrategyStateId,
+  computeDeviation: () => computeDeviation,
+  computeEffectiveWeight: () => computeEffectiveWeight,
+  computeOutcomeSignal: () => computeOutcomeSignal,
+  computeSpread: () => computeSpread,
+  computeStrategyGradient: () => computeStrategyGradient,
+  createOrchestrationContext: () => createOrchestrationContext,
   docIsDeleted: () => docIsDeleted,
   ensureAppDataDirectory: () => ensureAppDataDirectory,
   getAppDataDirectory: () => getAppDataDirectory,
@@ -5754,10 +7219,15 @@ __export(index_exports, {
   getCardOrigin: () => getCardOrigin,
   getDataLayer: () => getDataLayer,
   getDbPath: () => getDbPath,
+  getDefaultLearnableWeight: () => getDefaultLearnableWeight,
+  getRegisteredNavigator: () => getRegisteredNavigator,
+  getRegisteredNavigatorNames: () => getRegisteredNavigatorNames,
   getStudySource: () => getStudySource,
+  hasRegisteredNavigator: () => hasRegisteredNavigator,
   importParsedCards: () => importParsedCards,
   initializeDataDirectory: () => initializeDataDirectory,
   initializeDataLayer: () => initializeDataLayer,
+  initializeNavigatorRegistry: () => initializeNavigatorRegistry,
   isDataShapeRegistered: () => isDataShapeRegistered,
   isDataShapeSchemaAvailable: () => isDataShapeSchemaAvailable,
   isFilter: () => isFilter,
@@ -5769,11 +7239,20 @@ __export(index_exports, {
   newInterval: () => newInterval,
   parseCardHistoryID: () => parseCardHistoryID,
   processCustomQuestionsData: () => processCustomQuestionsData,
+  recordUserOutcome: () => recordUserOutcome,
   registerBlanksCard: () => registerBlanksCard,
   registerCustomQuestionTypes: () => registerCustomQuestionTypes,
   registerDataShape: () => registerDataShape,
+  registerNavigator: () => registerNavigator,
   registerQuestionType: () => registerQuestionType,
   registerSeedData: () => registerSeedData,
+  removeCustomQuestionTypes: () => removeCustomQuestionTypes,
+  removeDataShape: () => removeDataShape,
+  removeQuestionType: () => removeQuestionType,
+  runPeriodUpdate: () => runPeriodUpdate,
+  scoreAccuracyInZone: () => scoreAccuracyInZone,
+  updateLearningState: () => updateLearningState,
+  updateStrategyWeight: () => updateStrategyWeight,
   validateMigration: () => validateMigration,
   validateProcessorConfig: () => validateProcessorConfig,
   validateStaticCourse: () => validateStaticCourse
@@ -5783,10 +7262,10 @@ init_core();
 init_courseLookupDB();
 
 // src/courseConfigRegistration.ts
-var import_common19 = require("@vue-skuilder/common");
+var import_common21 = require("@vue-skuilder/common");
 init_logger();
 function isDataShapeRegistered(dataShape, courseConfig) {
-  const namespacedName = import_common19.NameSpacer.getDataShapeString({
+  const namespacedName = import_common21.NameSpacer.getDataShapeString({
     dataShape: dataShape.name,
     course: dataShape.course
   });
@@ -5794,7 +7273,7 @@ function isDataShapeRegistered(dataShape, courseConfig) {
   return existingDataShape !== void 0;
 }
 function isDataShapeSchemaAvailable(dataShape, courseConfig) {
-  const namespacedName = import_common19.NameSpacer.getDataShapeString({
+  const namespacedName = import_common21.NameSpacer.getDataShapeString({
     dataShape: dataShape.name,
     course: dataShape.course
   });
@@ -5802,7 +7281,7 @@ function isDataShapeSchemaAvailable(dataShape, courseConfig) {
   return existingDataShape !== void 0 && existingDataShape.serializedZodSchema !== void 0;
 }
 function isQuestionTypeRegistered(question, courseConfig) {
-  const namespacedName = import_common19.NameSpacer.getQuestionString({
+  const namespacedName = import_common21.NameSpacer.getQuestionString({
     course: question.course,
     questionType: question.name
   });
@@ -5834,13 +7313,13 @@ function processCustomQuestionsData(customQuestions) {
   return { dataShapes: processedDataShapes, questions: processedQuestions };
 }
 function registerDataShape(dataShape, courseConfig) {
-  const namespacedName = import_common19.NameSpacer.getDataShapeString({
+  const namespacedName = import_common21.NameSpacer.getDataShapeString({
     dataShape: dataShape.name,
     course: dataShape.course
   });
   let serializedZodSchema;
   try {
-    serializedZodSchema = (0, import_common19.toZodJSON)(dataShape.dataShape);
+    serializedZodSchema = (0, import_common21.toZodJSON)(dataShape.dataShape);
   } catch (error) {
     logger.warn(`Failed to generate schema for ${namespacedName}:`, error);
     serializedZodSchema = void 0;
@@ -5885,7 +7364,7 @@ function registerQuestionType(question, courseConfig) {
     logger.info(`QuestionType '${question.name}' from '${question.course}' already registered`);
     return false;
   }
-  const namespacedQuestionName = import_common19.NameSpacer.getQuestionString({
+  const namespacedQuestionName = import_common21.NameSpacer.getQuestionString({
     course: question.course,
     questionType: question.name
   });
@@ -5897,7 +7376,7 @@ function registerQuestionType(question, courseConfig) {
     }
   });
   const dataShapeList = question.dataShapes.map(
-    (dataShape) => import_common19.NameSpacer.getDataShapeString({
+    (dataShape) => import_common21.NameSpacer.getDataShapeString({
       course: question.course,
       dataShape: dataShape.name
     })
@@ -5908,7 +7387,7 @@ function registerQuestionType(question, courseConfig) {
     dataShapeList
   });
   question.dataShapes.forEach((dataShape) => {
-    const namespacedDataShapeName = import_common19.NameSpacer.getDataShapeString({
+    const namespacedDataShapeName = import_common21.NameSpacer.getDataShapeString({
       course: question.course,
       dataShape: dataShape.name
     });
@@ -5921,6 +7400,66 @@ function registerQuestionType(question, courseConfig) {
   logger.info(`Registered QuestionType: ${namespacedQuestionName}`);
   return true;
 }
+function removeDataShape(dataShapeName, courseConfig) {
+  const index = courseConfig.dataShapes.findIndex((ds) => ds.name === dataShapeName);
+  if (index === -1) {
+    logger.info(`DataShape '${dataShapeName}' not found in course config`);
+    return false;
+  }
+  courseConfig.dataShapes.splice(index, 1);
+  courseConfig.questionTypes.forEach((qt) => {
+    const dsIndex = qt.dataShapeList.indexOf(dataShapeName);
+    if (dsIndex !== -1) {
+      qt.dataShapeList.splice(dsIndex, 1);
+    }
+  });
+  logger.info(`Removed DataShape: ${dataShapeName}`);
+  return true;
+}
+function removeQuestionType(questionTypeName, courseConfig) {
+  const index = courseConfig.questionTypes.findIndex((qt) => qt.name === questionTypeName);
+  if (index === -1) {
+    logger.info(`QuestionType '${questionTypeName}' not found in course config`);
+    return false;
+  }
+  courseConfig.questionTypes.splice(index, 1);
+  courseConfig.dataShapes.forEach((ds) => {
+    const qtIndex = ds.questionTypes.indexOf(questionTypeName);
+    if (qtIndex !== -1) {
+      ds.questionTypes.splice(qtIndex, 1);
+    }
+  });
+  logger.info(`Removed QuestionType: ${questionTypeName}`);
+  return true;
+}
+async function removeCustomQuestionTypes(dataShapeNames, questionTypeNames, courseConfig, courseDB) {
+  try {
+    logger.info("Beginning custom question removal");
+    logger.info(`Removing ${dataShapeNames.length} data shapes and ${questionTypeNames.length} question types`);
+    let removedCount = 0;
+    for (const qtName of questionTypeNames) {
+      if (removeQuestionType(qtName, courseConfig)) {
+        removedCount++;
+      }
+    }
+    for (const dsName of dataShapeNames) {
+      if (removeDataShape(dsName, courseConfig)) {
+        removedCount++;
+      }
+    }
+    logger.info("Updating course configuration...");
+    const updateResult = await courseDB.updateCourseConfig(courseConfig);
+    if (!updateResult.ok) {
+      throw new Error(`Failed to update course config: ${JSON.stringify(updateResult)}`);
+    }
+    logger.info(`Custom question removal complete: ${removedCount} items removed`);
+    return { success: true, removedCount };
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    logger.error(`Custom question removal failed: ${errorMessage}`);
+    return { success: false, removedCount: 0, errorMessage };
+  }
+}
 async function registerSeedData(question, courseDB, username) {
   if (question.questionClass.seedData && Array.isArray(question.questionClass.seedData)) {
     logger.info(`Registering seed data for question: ${question.name}`);
@@ -6137,7 +7676,7 @@ var SrsService = class {
 };
 
 // src/study/services/EloService.ts
-var import_common20 = require("@vue-skuilder/common");
+var import_common22 = require("@vue-skuilder/common");
 init_logger();
 var EloService = class {
   dataLayer;
@@ -6160,10 +7699,10 @@ var EloService = class {
       logger.warn(`k value interpretation not currently implemented`);
     }
     const courseDB = this.dataLayer.getCourseDB(currentCard.card.course_id);
-    const userElo = (0, import_common20.toCourseElo)(userCourseRegDoc.courses.find((c) => c.courseID === course_id).elo);
+    const userElo = (0, import_common22.toCourseElo)(userCourseRegDoc.courses.find((c) => c.courseID === course_id).elo);
     const cardElo = (await courseDB.getCardEloData([currentCard.card.card_id]))[0];
     if (cardElo && userElo) {
-      const eloUpdate = (0, import_common20.adjustCourseScores)(userElo, cardElo, userScore);
+      const eloUpdate = (0, import_common22.adjustCourseScores)(userElo, cardElo, userScore);
       userCourseRegDoc.courses.find((c) => c.courseID === course_id).elo = eloUpdate.userElo;
       const results = await Promise.allSettled([
         this.user.updateUserElo(course_id, eloUpdate.userElo),
@@ -6365,7 +7904,7 @@ var ResponseProcessor = class {
 };
 
 // src/study/services/CardHydrationService.ts
-var import_common21 = require("@vue-skuilder/common");
+var import_common23 = require("@vue-skuilder/common");
 init_logger();
 function parseAudioURIs(data) {
   if (typeof data !== "string") return [];
@@ -6500,8 +8039,8 @@ var CardHydrationService = class {
     try {
       const courseDB = this.getCourseDB(item.courseID);
       const cardData = await courseDB.getCourseDoc(item.cardID);
-      if (!(0, import_common21.isCourseElo)(cardData.elo)) {
-        cardData.elo = (0, import_common21.toCourseElo)(cardData.elo);
+      if (!(0, import_common23.isCourseElo)(cardData.elo)) {
+        cardData.elo = (0, import_common23.toCourseElo)(cardData.elo);
       }
       const view = this.getViewComponent(cardData.id_view);
       const dataDocs = await Promise.all(
@@ -6525,7 +8064,7 @@ var CardHydrationService = class {
         );
         await Promise.allSettled(uniqueAudioUrls.map(prefetchAudio));
       }
-      const data = dataDocs.map(import_common21.displayableDataToViewData).reverse();
+      const data = dataDocs.map(import_common23.displayableDataToViewData).reverse();
       this.hydratedCards.set(item.cardID, {
         item,
         view,
@@ -6586,6 +8125,7 @@ var ItemQueue = class {
 
 // src/study/SessionController.ts
 init_couch();
+init_recording();
 
 // src/util/index.ts
 init_Loggable();
@@ -8433,6 +9973,49 @@ var SessionController = class extends Loggable {
       this.failedQ.dequeue((queueItem) => queueItem.cardID);
     }
   }
+  /**
+   * End the session and record learning outcomes.
+   *
+   * This method aggregates all responses from the session and records a
+   * UserOutcomeRecord if evolutionary orchestration is enabled.
+   */
+  async endSession() {
+    if (!this._sessionRecord || this._sessionRecord.length === 0) {
+      return;
+    }
+    const questionRecords = this._sessionRecord.flatMap((r) => r.records).filter((r) => r.userAnswer !== void 0);
+    if (questionRecords.length === 0) {
+      return;
+    }
+    let orchestrationContext = null;
+    const strategies = [];
+    for (const source of this.sources) {
+      if (source.getOrchestrationContext) {
+        try {
+          orchestrationContext = await source.getOrchestrationContext();
+          if (source.getStrategyIds) {
+            strategies.push(...source.getStrategyIds());
+          }
+        } catch (e) {
+          logger.warn(`[SessionController] Failed to get orchestration context: ${e}`);
+        }
+        if (orchestrationContext) break;
+      }
+    }
+    if (!orchestrationContext) {
+      logger.debug("[SessionController] No orchestration context available, skipping outcome recording");
+      return;
+    }
+    const periodEnd = (/* @__PURE__ */ new Date()).toISOString();
+    const periodStart = new Date(this.startTime).toISOString();
+    await recordUserOutcome(
+      orchestrationContext,
+      periodStart,
+      periodEnd,
+      questionRecords,
+      strategies
+    );
+  }
 };
 
 // src/study/index.ts
@@ -8460,8 +10043,15 @@ init_factory();
   StaticToCouchDBMigrator,
   TagFilteredContentSource,
   _resetDataLayer,
+  aggregateOutcomesForGradient,
   areQuestionRecords,
   buildStrategyStateId,
+  computeDeviation,
+  computeEffectiveWeight,
+  computeOutcomeSignal,
+  computeSpread,
+  computeStrategyGradient,
+  createOrchestrationContext,
   docIsDeleted,
   ensureAppDataDirectory,
   getAppDataDirectory,
@@ -8469,10 +10059,15 @@ init_factory();
   getCardOrigin,
   getDataLayer,
   getDbPath,
+  getDefaultLearnableWeight,
+  getRegisteredNavigator,
+  getRegisteredNavigatorNames,
   getStudySource,
+  hasRegisteredNavigator,
   importParsedCards,
   initializeDataDirectory,
   initializeDataLayer,
+  initializeNavigatorRegistry,
   isDataShapeRegistered,
   isDataShapeSchemaAvailable,
   isFilter,
@@ -8484,11 +10079,20 @@ init_factory();
   newInterval,
   parseCardHistoryID,
   processCustomQuestionsData,
+  recordUserOutcome,
   registerBlanksCard,
   registerCustomQuestionTypes,
   registerDataShape,
+  registerNavigator,
   registerQuestionType,
   registerSeedData,
+  removeCustomQuestionTypes,
+  removeDataShape,
+  removeQuestionType,
+  runPeriodUpdate,
+  scoreAccuracyInZone,
+  updateLearningState,
+  updateStrategyWeight,
   validateMigration,
   validateProcessorConfig,
   validateStaticCourse