@vue-skuilder/db 0.1.17 → 0.1.20

package/src/core/navigators/relativePriority.ts

@@ -0,0 +1,255 @@
+import type { ScheduledCard } from '../types/user';
+import type { CourseDBInterface } from '../interfaces/courseDB';
+import type { UserDBInterface } from '../interfaces/userDB';
+import { ContentNavigator } from './index';
+import type { WeightedCard } from './index';
+import type { ContentNavigationStrategyData } from '../types/contentNavigationStrategy';
+import type { StudySessionReviewItem, StudySessionNewItem } from '..';
+import type { CardFilter, FilterContext } from './filters/types';
+
+/**
+ * Configuration for the RelativePriority strategy.
+ *
+ * Course authors define priority weights for tags, allowing the system
+ * to prefer high-utility content (common, well-behaved patterns) over
+ * lower-utility content (rare, irregular patterns).
+ *
+ * Example use case: In phonics, prefer teaching 's' (common, consistent)
+ * before 'x' or 'z' (rare, sometimes irregular).
+ */
+export interface RelativePriorityConfig {
+  /**
+   * Map of tag ID to priority weight (0-1).
+   *
+   * 1.0 = highest priority (present first)
+   * 0.5 = neutral
+   * 0.0 = lowest priority (defer until later)
+   *
+   * Example:
+   * {
+   *   "letter-s": 0.95,
+   *   "letter-t": 0.90,
+   *   "letter-x": 0.10,
+   *   "letter-z": 0.05
+   * }
+   */
+  tagPriorities: { [tagId: string]: number };
+
+  /**
+   * Priority for tags not explicitly listed (default: 0.5).
+   * 0.5 means unlisted tags have neutral effect on scoring.
+   */
+  defaultPriority?: number;
+
+  /**
+   * How to combine priorities when a card has multiple tags.
+   *
+   * - 'max': Use the highest priority among the card's tags (default)
+   * - 'average': Average all tag priorities
+   * - 'min': Use the lowest priority (conservative)
+   */
+  combineMode?: 'max' | 'average' | 'min';
+
+  /**
+   * How strongly priority influences the final score (0-1, default: 0.5).
+   *
+   * At 0.0: Priority has no effect (pure delegate scoring)
+   * At 0.5: Priority can boost/reduce scores by up to 25%
+   * At 1.0: Priority can boost/reduce scores by up to 50%
+   *
+   * The boost factor formula: 1 + (priority - 0.5) * priorityInfluence
+   * - Priority 1.0 with influence 0.5 → boost of 1.25
+   * - Priority 0.5 with influence 0.5 → boost of 1.00 (neutral)
+   * - Priority 0.0 with influence 0.5 → boost of 0.75
+   */
+  priorityInfluence?: number;
+}
+
+const DEFAULT_PRIORITY = 0.5;
+const DEFAULT_PRIORITY_INFLUENCE = 0.5;
+const DEFAULT_COMBINE_MODE: 'max' | 'average' | 'min' = 'max';
+
+/**
+ * A filter strategy that boosts scores for high-utility content.
+ *
+ * Course authors assign priority weights to tags. Cards with high-priority
+ * tags get boosted scores, making them more likely to be presented first.
+ * This allows teaching the most useful, well-behaved concepts before
+ * moving on to rarer or more irregular ones.
+ *
+ * Example: When teaching phonics, prioritize common letters (s, t, a) over
+ * rare ones (x, z, q) by assigning higher priority weights to common letters.
+ *
+ * Implements CardFilter for use in Pipeline architecture.
+ * Also extends ContentNavigator for backward compatibility.
+ */
+export default class RelativePriorityNavigator extends ContentNavigator implements CardFilter {
+  private config: RelativePriorityConfig;
+  private _strategyData: ContentNavigationStrategyData;
+
+  /** Human-readable name for CardFilter interface */
+  name: string;
+
+  constructor(
+    user: UserDBInterface,
+    course: CourseDBInterface,
+    _strategyData: ContentNavigationStrategyData
+  ) {
+    super(user, course, _strategyData);
+    this._strategyData = _strategyData;
+    this.config = this.parseConfig(_strategyData.serializedData);
+    this.name = _strategyData.name || 'Relative Priority';
+  }
+
+  private parseConfig(serializedData: string): RelativePriorityConfig {
+    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 safe defaults if parsing fails
+      return {
+        tagPriorities: {},
+        defaultPriority: DEFAULT_PRIORITY,
+        combineMode: DEFAULT_COMBINE_MODE,
+        priorityInfluence: DEFAULT_PRIORITY_INFLUENCE,
+      };
+    }
+  }
+
+  /**
+   * Look up the priority for a tag.
+   */
+  private getTagPriority(tagId: string): number {
+    return this.config.tagPriorities[tagId] ?? this.config.defaultPriority ?? DEFAULT_PRIORITY;
+  }
+
+  /**
+   * Compute combined priority for a card based on its tags.
+   */
+  private computeCardPriority(cardTags: string[]): number {
+    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)
+   */
+  private computeBoostFactor(priority: number): number {
+    const influence = this.config.priorityInfluence ?? DEFAULT_PRIORITY_INFLUENCE;
+    return 1 + (priority - 0.5) * influence;
+  }
+
+  /**
+   * Build human-readable reason for priority adjustment.
+   */
+  private buildPriorityReason(
+    cardTags: string[],
+    priority: number,
+    boostFactor: number,
+    finalScore: number
+  ): string {
+    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.0) {
+      return `Neutral priority (${priority.toFixed(2)}) for tags: ${tagList}${more}`;
+    } else if (boostFactor > 1.0) {
+      return `High-priority tags: ${tagList}${more} (priority ${priority.toFixed(2)} → boost ${boostFactor.toFixed(2)}x → ${finalScore.toFixed(2)})`;
+    } else {
+      return `Low-priority tags: ${tagList}${more} (priority ${priority.toFixed(2)} → reduce ${boostFactor.toFixed(2)}x → ${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: WeightedCard[], _context: FilterContext): Promise<WeightedCard[]> {
+    const adjusted: WeightedCard[] = 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));
+
+        // Determine action based on boost factor
+        const action = boostFactor > 1.0 ? 'boosted' : boostFactor < 1.0 ? 'penalized' : 'passed';
+
+        // Build reason explaining priority adjustment
+        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: number): Promise<WeightedCard[]> {
+    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().'
+    );
+  }
+
+  // Legacy methods - stub implementations since filters don't generate cards
+
+  async getNewCards(_n?: number): Promise<StudySessionNewItem[]> {
+    return [];
+  }
+
+  async getPendingReviews(): Promise<(StudySessionReviewItem & ScheduledCard)[]> {
+    return [];
+  }
+}

package/src/core/navigators/srs.ts

@@ -0,0 +1,195 @@
+import moment from 'moment';
+import type { ScheduledCard } from '../types/user';
+import type { CourseDBInterface } from '../interfaces/courseDB';
+import type { UserDBInterface } from '../interfaces/userDB';
+import { ContentNavigator } from './index';
+import type { WeightedCard } from './index';
+import type { ContentNavigationStrategyData } from '../types/contentNavigationStrategy';
+import type { StudySessionReviewItem, StudySessionNewItem } from '../interfaces/contentSource';
+import type { CardGenerator, GeneratorContext } from './generators/types';
+
+// ============================================================================
+// SRS NAVIGATOR
+// ============================================================================
+//
+// A generator strategy that scores review cards by urgency.
+//
+// Urgency is determined by two factors:
+// 1. Overdueness - how far past the scheduled review time
+// 2. Interval recency - shorter scheduled intervals indicate "novel content in progress"
+//
+// A card with a 3-day interval that's 2 days overdue is more urgent than a card
+// with a 6-month interval that's 2 days overdue. The shorter interval represents
+// active learning at higher resolution.
+//
+// This navigator only handles reviews - it does not generate new cards.
+// For new cards, use ELONavigator or another generator via CompositeGenerator.
+//
+// ============================================================================
+
+/**
+ * Configuration for the SRS strategy.
+ * Currently minimal - the algorithm is not parameterized.
+ */
+// eslint-disable-next-line @typescript-eslint/no-empty-object-type
+export interface SRSConfig {
+  // Future: configurable urgency curves, thresholds, etc.
+}
+
+/**
+ * A navigation strategy that scores review cards by urgency.
+ *
+ * Implements CardGenerator for use in Pipeline architecture.
+ * Also extends ContentNavigator for backward compatibility with legacy code.
+ *
+ * Higher scores indicate more urgent reviews:
+ * - Cards that are more overdue (relative to their interval) score higher
+ * - Cards with shorter intervals (recent learning) score higher
+ *
+ * Only returns cards that are actually due (reviewTime has passed).
+ * Does not generate new cards - use with CompositeGenerator for mixed content.
+ */
+export default class SRSNavigator extends ContentNavigator implements CardGenerator {
+  /** Human-readable name for CardGenerator interface */
+  name: string;
+
+  constructor(
+    user: UserDBInterface,
+    course: CourseDBInterface,
+    strategyData?: ContentNavigationStrategyData
+  ) {
+    super(user, course, strategyData as ContentNavigationStrategyData);
+    this.name = strategyData?.name || 'SRS';
+  }
+
+  /**
+   * Get review cards scored by urgency.
+   *
+   * Score formula combines:
+   * - Relative overdueness: hoursOverdue / intervalHours
+   * - Interval recency: exponential decay favoring shorter intervals
+   *
+   * 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 - Optional GeneratorContext (currently unused, but required for interface)
+   */
+  async getWeightedCards(limit: number, _context?: GeneratorContext): Promise<WeightedCard[]> {
+    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 = moment.utc();
+
+    // Filter to only cards that are actually due
+    const dueReviews = reviews.filter((r) => now.isAfter(moment.utc(r.reviewTime)));
+
+    const scored = dueReviews.map((review) => {
+      const { score, reason } = this.computeUrgencyScore(review, now);
+
+      return {
+        cardId: review.cardId,
+        courseId: review.courseId,
+        score,
+        provenance: [
+          {
+            strategy: 'srs',
+            strategyName: this.strategyName || this.name,
+            strategyId: this.strategyId || 'NAVIGATION_STRATEGY-SRS-default',
+            action: 'generated' as const,
+            score,
+            reason,
+          },
+        ],
+      };
+    });
+
+    // Sort by score descending and limit
+    return scored.sort((a, b) => b.score - a.score).slice(0, limit);
+  }
+
+  /**
+   * 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
+   */
+  private computeUrgencyScore(
+    review: ScheduledCard,
+    now: moment.Moment
+  ): { score: number; reason: string } {
+    const scheduledAt = moment.utc(review.scheduledAt);
+    const due = moment.utc(review.reviewTime);
+
+    // Interval = time between scheduling and due date (minimum 1 hour to avoid division issues)
+    const intervalHours = Math.max(1, due.diff(scheduledAt, 'hours'));
+    const hoursOverdue = now.diff(due, 'hours');
+
+    // Relative overdueness: how late relative to the interval
+    const relativeOverdue = hoursOverdue / intervalHours;
+
+    // Interval recency factor: shorter intervals = more urgent
+    // Exponential decay with 720h (30 days) as the characteristic time
+    const recencyFactor = 0.3 + 0.7 * Math.exp(-intervalHours / 720);
+
+    // Combined urgency: weighted average of relative overdue and recency
+    // Clamp relative overdue contribution to [0, 1] to avoid runaway scores
+    const overdueContribution = Math.min(1.0, Math.max(0, relativeOverdue));
+    const urgency = overdueContribution * 0.5 + recencyFactor * 0.5;
+
+    // Final score: base 0.5 + urgency contribution, capped at 0.95
+    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 };
+  }
+
+  /**
+   * Get pending reviews in legacy format.
+   *
+   * Returns all pending reviews for the course, enriched with session item fields.
+   */
+  async getPendingReviews(): Promise<(StudySessionReviewItem & ScheduledCard)[]> {
+    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());
+
+    return reviews.map((r) => ({
+      ...r,
+      contentSourceType: 'course' as const,
+      contentSourceID: this.course!.getCourseID(),
+      cardID: r.cardId,
+      courseID: r.courseId,
+      qualifiedID: `${r.courseId}-${r.cardId}`,
+      reviewID: r._id,
+      status: 'review' as const,
+    }));
+  }
+
+  /**
+   * SRS does not generate new cards.
+   * Use ELONavigator or another generator for new cards.
+   */
+  async getNewCards(_n?: number): Promise<StudySessionNewItem[]> {
+    return [];
+  }
+}

package/src/core/navigators/userGoal.ts

@@ -0,0 +1,136 @@
+// ============================================================================
+// USER GOAL NAVIGATOR — STUB
+// ============================================================================
+//
+// STATUS: NOT IMPLEMENTED — This file documents architectural intent only.
+//
+// ============================================================================
+//
+// ## Purpose
+//
+// Goals define WHAT the user wants to learn, as opposed to preferences which
+// define HOW they want to learn. Goals affect:
+//
+// 1. **Content scoping**: Which tags/content are relevant to this user
+// 2. **Progress tracking**: ELO is measured against goal-relevant content
+// 3. **Completion criteria**: User is "done" when goal mastery is achieved
+// 4. **Curriculum composition**: Goals enable cross-curriculum dependencies
+//
+// ## Goals vs Preferences
+//
+// | Aspect        | Goal                          | Preference                    |
+// |---------------|-------------------------------|-------------------------------|
+// | Defines       | Destination (what to learn)   | Path (how to learn)           |
+// | Example       | "Master ear-training"         | "Skip text-heavy cards"       |
+// | Affects ELO   | Yes — scopes what's tracked   | No — just filters cards       |
+// | Completion    | Yes — defines "done"          | No — persists indefinitely    |
+// | Filter impl   | UserGoalNavigator             | UserTagPreferenceFilter       |
+//
+// ## Curriculum Composition
+//
+// Goals enable software-style composition for curricula. A physics course
+// can teach classical mechanics without owning the calculus prerequisites.
+//
+// Instead, it declares a dependency:
+//
+// ```typescript
+// interface CurriculumDependency {
+//   // NPM-style package resolution
+//   curriculumId: string;        // e.g., "@skuilder/calculus"
+//   version: string;             // e.g., "^2.0.0" (semver)
+//
+//   // Goal within that curriculum
+//   goal: string;                // e.g., "differential-calculus"
+//
+//   // How this maps to local prerequisites
+//   satisfiesLocalTags: string[]; // e.g., ["calculus-prereq"]
+// }
+// ```
+//
+// When a physics card requires "calculus-prereq", the system:
+// 1. Checks if user has achieved the "differential-calculus" goal in @skuilder/calculus
+// 2. If not, defers to that curriculum to teach the prerequisite
+// 3. Returns to physics once the goal is satisfied
+//
+// This allows:
+// - Specialized curricula (calculus experts author calculus content)
+// - Reusable prerequisites across multiple courses
+// - User can bring their own "calculus credential" from prior learning
+//
+// ## User Goal State (Proposed)
+//
+// ```typescript
+// interface UserGoalState {
+//   // Primary goals — what the user wants to achieve
+//   targetTags: string[];
+//
+//   // Excluded goals — content the user explicitly doesn't care about
+//   excludedTags: string[];
+//
+//   // Cross-curriculum goals (for composition)
+//   externalGoals?: {
+//     curriculumId: string;
+//     goal: string;
+//     status: 'not-started' | 'in-progress' | 'achieved';
+//   }[];
+//
+//   // When this goal configuration was set
+//   updatedAt: string;
+// }
+// ```
+//
+// ## Implementation Considerations
+//
+// 1. **ELO Scoping**: When goals are set, user ELO tracking should focus on
+//    goal-relevant tags. This may require changes to ELO update logic.
+//
+// 2. **Progress Reporting**: UI should show progress toward goals, not just
+//    overall course completion.
+//
+// 3. **Goal Achievement**: Need to define when a goal is "achieved" —
+//    probably ELO threshold + mastery percentage on goal-tagged content.
+//
+// 4. **Curriculum Registry**: For cross-curriculum composition, need a
+//    registry/resolver for curriculum packages (similar to npm registry).
+//
+// 5. **Interaction with HierarchyDefinition**: Goals should work with
+//    prerequisite chains — user can't skip prerequisites just because
+//    they're not part of their goal.
+//
+// ## Related Files
+//
+// - `filters/userTagPreference.ts` — Preferences (path constraints)
+// - `hierarchyDefinition.ts` — Prerequisites (enforced regardless of goals)
+// - `../types/strategyState.ts` — Storage mechanism for user state
+//
+// ## Next Steps
+//
+// 1. Design goal state schema in detail
+// 2. Define goal achievement criteria
+// 3. Implement goal-scoped ELO tracking
+// 4. Build UI for goal configuration
+// 5. Design curriculum dependency resolution
+//
+// ============================================================================
+
+// Placeholder export to make this a valid module
+export const USER_GOAL_NAVIGATOR_STUB = true;
+
+/**
+ * @stub UserGoalNavigator
+ *
+ * A navigator that scopes learning to user-defined goals.
+ * See module-level documentation for architectural intent.
+ *
+ * NOT IMPLEMENTED — This is a design placeholder.
+ */
+export interface UserGoalState {
+  /** Tags the user wants to master (defines "success") */
+  targetTags: string[];
+
+  /** Tags the user explicitly doesn't care about */
+  excludedTags: string[];
+
+  /** ISO timestamp of last update */
+  updatedAt: string;
+}

package/src/core/types/strategyState.ts

@@ -0,0 +1,84 @@
+import { DocType, DocTypePrefixes } from './types-legacy';
+
+/**
+ * Template literal type for strategy state document IDs.
+ *
+ * Format: `STRATEGY_STATE-{courseId}-{strategyKey}`
+ */
+export type StrategyStateId =
+  `${(typeof DocTypePrefixes)[DocType.STRATEGY_STATE]}::${string}::${string}`;
+
+/**
+ * Document storing strategy-specific state in the user database.
+ *
+ * Each strategy can persist its own state (user preferences, learned patterns,
+ * temporal tracking, etc.) using this document type. The state is scoped to
+ * a (user, course, strategy) tuple.
+ *
+ * ## Use Cases
+ *
+ * 1. **Explicit user preferences**: User configures tag filters, difficulty
+ *    preferences, or learning goals. UI writes to strategy state.
+ *
+ * 2. **Learned/temporal state**: Strategy tracks patterns over time, e.g.,
+ *    "when did I last introduce confusable concepts together?"
+ *
+ * 3. **Adaptive personalization**: Strategy infers user preferences from
+ *    behavior and stores them for future sessions.
+ *
+ * ## Storage Location
+ *
+ * These documents live in the **user database**, not the course database.
+ * They sync with the user's data across devices.
+ *
+ * ## Document ID Format
+ *
+ * `STRATEGY_STATE::{courseId}::{strategyKey}`
+ *
+ * Example: `STRATEGY_STATE::piano-basics::UserTagPreferenceFilter`
+ *
+ * @template T - The shape of the strategy-specific data payload
+ */
+export interface StrategyStateDoc<T = unknown> {
+  _id: StrategyStateId;
+  _rev?: string;
+  docType: DocType.STRATEGY_STATE;
+
+  /**
+   * The course this state applies to.
+   */
+  courseId: string;
+
+  /**
+   * Unique key identifying the strategy instance.
+   * Typically the strategy class name (e.g., "UserTagPreferenceFilter",
+   * "InterferenceMitigatorNavigator").
+   *
+   * If a course has multiple instances of the same strategy type with
+   * different configurations, use a more specific key.
+   */
+  strategyKey: string;
+
+  /**
+   * Strategy-specific data payload.
+   * Each strategy defines its own schema for this field.
+   */
+  data: T;
+
+  /**
+   * ISO timestamp of last update.
+   * Use `moment.utc(updatedAt)` to parse into a Moment object.
+   */
+  updatedAt: string;
+}
+
+/**
+ * Build the document ID for a strategy state document.
+ *
+ * @param courseId - The course ID
+ * @param strategyKey - The strategy key (typically class name)
+ * @returns The document ID in format `STRATEGY_STATE::{courseId}::{strategyKey}`
+ */
+export function buildStrategyStateId(courseId: string, strategyKey: string): StrategyStateId {
+  return `STRATEGY_STATE::${courseId}::${strategyKey}`;
+}

package/src/core/types/types-legacy.ts

@@ -19,6 +19,7 @@ export enum DocType {
   SCHEDULED_CARD = 'SCHEDULED_CARD',
   TAG = 'TAG',
   NAVIGATION_STRATEGY = 'NAVIGATION_STRATEGY',
+  STRATEGY_STATE = 'STRATEGY_STATE',
 }
 
 export interface QualifiedCardID {
@@ -103,6 +104,7 @@ export const DocTypePrefixes = {
   [DocType.VIEW]: 'VIEW',
   [DocType.PEDAGOGY]: 'PEDAGOGY',
   [DocType.NAVIGATION_STRATEGY]: 'NAVIGATION_STRATEGY',
+  [DocType.STRATEGY_STATE]: 'STRATEGY_STATE',
 } as const;
 
 export interface CardHistory<T extends CardRecord> {