@shaxpir/duiduidui-models 1.9.21 → 1.9.25

package/dist/models/Collection.d.ts

@@ -3,7 +3,7 @@ import { CompactDateTime } from "@shaxpir/shaxpir-common";
 import { ShareSync } from '../repo';
 import { Conditions } from './Condition';
 import { Content, ContentBody, ContentId, ContentMeta } from "./Content";
-import { UncertainValue } from './Progress';
+import { SkillLevel } from './SkillLevel';
 /**
  * Display metadata for a Collection, used in the UI.
  */
@@ -23,7 +23,7 @@ export interface CollectionPayload {
     collection_key: string;
     conditions: Conditions;
     display: CollectionDisplay;
-    proficiency: UncertainValue;
+    proficiency: SkillLevel;
     term_scores: {
         [termKey: string]: number;
     };
@@ -77,10 +77,9 @@ export declare class Collection extends Content {
     get description(): string;
     get icon(): string | undefined;
     get sortOrder(): number;
-    get proficiency(): UncertainValue;
-    get proficiencyRating(): number;
-    get proficiencyRatingDeviation(): number;
-    get proficiencyVolatility(): number;
+    get proficiency(): SkillLevel;
+    get proficiencyMu(): number;
+    get proficiencySigma(): number;
     get termScores(): {
         [termKey: string]: number;
     };
@@ -125,9 +124,9 @@ export declare class Collection extends Content {
         F: number;
     };
     /**
-     * Update the Glicko-2 proficiency rating.
+     * Update the IRT proficiency rating.
      */
-    setProficiency(value: UncertainValue): void;
+    setProficiency(value: SkillLevel): void;
     /**
      * Update or add a term score in the collection.
      */

package/dist/models/Collection.js

@@ -7,6 +7,7 @@ const SenseRankEncoder_1 = require("../util/SenseRankEncoder");
 const Content_1 = require("./Content");
 const ContentKind_1 = require("./ContentKind");
 const Operation_1 = require("./Operation");
+const SkillLevel_1 = require("./SkillLevel");
 class Collection extends Content_1.Content {
     /**
      * Generate a deterministic Collection ID from userId and collectionKey.
@@ -50,12 +51,8 @@ class Collection extends Content_1.Content {
                 collection_key: params.collectionKey,
                 conditions: params.conditions,
                 display: params.display,
-                // Initial Glicko-2 proficiency - high uncertainty, no data yet
-                proficiency: {
-                    rating: 0, // Start at zero (no demonstrated skill)
-                    rating_deviation: 50, // High initial uncertainty
-                    volatility: 0.06 // Moderate initial volatility
-                },
+                // Initial IRT proficiency - high uncertainty, no data yet
+                proficiency: SkillLevel_1.SkillLevelModel.createDefault(),
                 // Empty term scores map - populated as user reviews cards
                 term_scores: {},
                 // Progress starts at zero
@@ -118,17 +115,13 @@ class Collection extends Content_1.Content {
         this.checkDisposed("Collection.proficiency");
         return shaxpir_common_1.Struct.clone(this.payload.proficiency);
     }
-    get proficiencyRating() {
-        this.checkDisposed("Collection.proficiencyRating");
-        return this.payload.proficiency.rating;
+    get proficiencyMu() {
+        this.checkDisposed("Collection.proficiencyMu");
+        return this.payload.proficiency.mu;
     }
-    get proficiencyRatingDeviation() {
-        this.checkDisposed("Collection.proficiencyRatingDeviation");
-        return this.payload.proficiency.rating_deviation;
-    }
-    get proficiencyVolatility() {
-        this.checkDisposed("Collection.proficiencyVolatility");
-        return this.payload.proficiency.volatility;
+    get proficiencySigma() {
+        this.checkDisposed("Collection.proficiencySigma");
+        return this.payload.proficiency.sigma;
     }
     // ============================================================
     // Term scores getters
@@ -232,15 +225,14 @@ class Collection extends Content_1.Content {
     // Mutators
     // ============================================================
     /**
-     * Update the Glicko-2 proficiency rating.
+     * Update the IRT proficiency rating.
      */
     setProficiency(value) {
         this.checkDisposed("Collection.setProficiency");
         if (!shaxpir_common_1.Struct.equals(this.payload.proficiency, value)) {
             const batch = new Operation_1.BatchOperation(this);
-            batch.setPathValue(['payload', 'proficiency', 'rating'], value.rating);
-            batch.setPathValue(['payload', 'proficiency', 'rating_deviation'], value.rating_deviation);
-            batch.setPathValue(['payload', 'proficiency', 'volatility'], value.volatility);
+            batch.setPathValue(['payload', 'proficiency', 'mu'], value.mu);
+            batch.setPathValue(['payload', 'proficiency', 'sigma'], value.sigma);
             batch.commit();
         }
     }

package/dist/models/Progress.d.ts

@@ -2,11 +2,7 @@ import { Doc } from '@shaxpir/sharedb/lib/client';
 import { CompactDate } from "@shaxpir/shaxpir-common";
 import { ShareSync } from '../repo';
 import { Content, ContentBody, ContentId, ContentMeta } from "./Content";
-export interface UncertainValue {
-    rating: number;
-    rating_deviation: number;
-    volatility: number;
-}
+import { SkillLevel } from './SkillLevel';
 export interface StreakData {
     daily: {
         current: number;
@@ -26,7 +22,7 @@ export interface StreakData {
     total_days: number;
 }
 export interface ProgressPayload {
-    skill_level: UncertainValue;
+    skill_level: SkillLevel;
     cognitive_load: number;
     streaks?: StreakData;
     total_review_count: number;
@@ -40,18 +36,16 @@ export declare class Progress extends Content {
     static create(userId: ContentId): Progress;
     constructor(doc: Doc, shouldAcquire: boolean, shareSync: ShareSync);
     get payload(): ProgressPayload;
-    getSkillLevel(): UncertainValue;
-    getSkillLevelValue(): number;
-    getSkillLevelRatingDeviation(): number;
-    getSkillLevelVolatility(): number;
+    getSkillLevel(): SkillLevel;
+    getSkillLevelMu(): number;
+    getSkillLevelSigma(): number;
     getSkillLevelLowerBound(): number;
     getSkillLevelUpperBound(): number;
     needsCalibration(): boolean;
     getCognitiveLoad(): number;
-    setSkillLevel(uncertainValue: UncertainValue): void;
-    setSkillLevelValue(value: number): void;
-    setSkillLevelRatingDeviation(ratingDeviation: number): void;
-    setSkillLevelVolatility(volatility: number): void;
+    setSkillLevel(skillLevel: SkillLevel): void;
+    setSkillLevelMu(mu: number): void;
+    setSkillLevelSigma(sigma: number): void;
     setCognitiveLoad(value: number): void;
     getStreaks(): StreakData | undefined;
     setStreaks(streaks: StreakData): void;

package/dist/models/Progress.js

@@ -6,6 +6,7 @@ const repo_1 = require("../repo");
 const Content_1 = require("./Content");
 const ContentKind_1 = require("./ContentKind");
 const Operation_1 = require("./Operation");
+const SkillLevel_1 = require("./SkillLevel");
 class Progress extends Content_1.Content {
     static makeProgressId(userId) {
         return shaxpir_common_1.CachingHasher.makeMd5Base62Hash(userId + "-" + ContentKind_1.ContentKind.PROGRESS);
@@ -23,13 +24,9 @@ class Progress extends Content_1.Content {
                 updated_at: now
             },
             payload: {
-                skill_level: {
-                    rating: 0, // Start at absolute beginner (knows ~0 characters)
-                    rating_deviation: 50, // Initial uncertainty (±100 chars at 95% CI)
-                    volatility: 0.06 // Moderate initial volatility
-                },
+                skill_level: SkillLevel_1.SkillLevelModel.createDefault(),
                 cognitive_load: 0,
-                total_review_count: 0 // Start with zero lifetime reviews
+                total_review_count: 0
             }
         });
     }
@@ -44,71 +41,56 @@ class Progress extends Content_1.Content {
         this.checkDisposed("Progress.getSkillLevel");
         return shaxpir_common_1.Struct.clone(this.payload.skill_level);
     }
-    getSkillLevelValue() {
-        this.checkDisposed("Progress.getSkillLevelValue");
-        return this.payload.skill_level.rating;
+    getSkillLevelMu() {
+        this.checkDisposed("Progress.getSkillLevelMu");
+        return this.payload.skill_level.mu;
     }
-    getSkillLevelRatingDeviation() {
-        this.checkDisposed("Progress.getSkillLevelRatingDeviation");
-        return this.payload.skill_level.rating_deviation;
-    }
-    getSkillLevelVolatility() {
-        this.checkDisposed("Progress.getSkillLevelVolatility");
-        return this.payload.skill_level.volatility;
+    getSkillLevelSigma() {
+        this.checkDisposed("Progress.getSkillLevelSigma");
+        return this.payload.skill_level.sigma;
     }
     getSkillLevelLowerBound() {
         this.checkDisposed("Progress.getSkillLevelLowerBound");
-        const { SkillLevelModel } = require('./SkillLevel');
-        const bounds = SkillLevelModel.calculateBounds(this.payload.skill_level.rating, this.payload.skill_level.rating_deviation);
+        const bounds = SkillLevel_1.SkillLevelModel.calculateBounds(this.payload.skill_level.mu, this.payload.skill_level.sigma);
         return bounds.lower;
     }
     getSkillLevelUpperBound() {
         this.checkDisposed("Progress.getSkillLevelUpperBound");
-        const { SkillLevelModel } = require('./SkillLevel');
-        const bounds = SkillLevelModel.calculateBounds(this.payload.skill_level.rating, this.payload.skill_level.rating_deviation);
+        const bounds = SkillLevel_1.SkillLevelModel.calculateBounds(this.payload.skill_level.mu, this.payload.skill_level.sigma);
         return bounds.upper;
     }
     needsCalibration() {
         this.checkDisposed("Progress.needsCalibration");
-        // High rating deviation means we need more data to calibrate user level
-        // rating_deviation > 30 means confidence bounds are still quite wide (±60 chars at 95% CI)
-        return this.payload.skill_level.rating_deviation > 30;
+        // High sigma means we need more data to calibrate user level
+        // sigma > 30 means confidence bounds are still quite wide (±60 chars at 95% CI)
+        return this.payload.skill_level.sigma > 30;
     }
     getCognitiveLoad() {
         this.checkDisposed("Progress.getCognitiveLoad");
         return this.payload.cognitive_load;
     }
-    setSkillLevel(uncertainValue) {
+    setSkillLevel(skillLevel) {
         this.checkDisposed("Progress.setSkillLevel");
-        if (!shaxpir_common_1.Struct.equals(this.payload.skill_level, uncertainValue)) {
-            const batch = new Operation_1.BatchOperation(this);
-            batch.setPathValue(['payload', 'skill_level', 'rating'], uncertainValue.rating);
-            batch.setPathValue(['payload', 'skill_level', 'rating_deviation'], uncertainValue.rating_deviation);
-            batch.setPathValue(['payload', 'skill_level', 'volatility'], uncertainValue.volatility);
-            batch.commit();
-        }
-    }
-    setSkillLevelValue(value) {
-        this.checkDisposed("Progress.setSkillLevelValue");
-        if (this.payload.skill_level.rating !== value) {
+        if (!shaxpir_common_1.Struct.equals(this.payload.skill_level, skillLevel)) {
             const batch = new Operation_1.BatchOperation(this);
-            batch.setPathValue(['payload', 'skill_level', 'rating'], value);
+            batch.setPathValue(['payload', 'skill_level', 'mu'], skillLevel.mu);
+            batch.setPathValue(['payload', 'skill_level', 'sigma'], skillLevel.sigma);
             batch.commit();
         }
     }
-    setSkillLevelRatingDeviation(ratingDeviation) {
-        this.checkDisposed("Progress.setSkillLevelRatingDeviation");
-        if (this.payload.skill_level.rating_deviation !== ratingDeviation) {
+    setSkillLevelMu(mu) {
+        this.checkDisposed("Progress.setSkillLevelMu");
+        if (this.payload.skill_level.mu !== mu) {
             const batch = new Operation_1.BatchOperation(this);
-            batch.setPathValue(['payload', 'skill_level', 'rating_deviation'], ratingDeviation);
+            batch.setPathValue(['payload', 'skill_level', 'mu'], mu);
             batch.commit();
         }
     }
-    setSkillLevelVolatility(volatility) {
-        this.checkDisposed("Progress.setSkillLevelVolatility");
-        if (this.payload.skill_level.volatility !== volatility) {
+    setSkillLevelSigma(sigma) {
+        this.checkDisposed("Progress.setSkillLevelSigma");
+        if (this.payload.skill_level.sigma !== sigma) {
             const batch = new Operation_1.BatchOperation(this);
-            batch.setPathValue(['payload', 'skill_level', 'volatility'], volatility);
+            batch.setPathValue(['payload', 'skill_level', 'sigma'], sigma);
             batch.commit();
         }
     }

package/dist/models/Session.d.ts

@@ -4,7 +4,7 @@ import { ShareSync } from '../repo';
 import { Conditions } from './Condition';
 import { Content, ContentBody, ContentId, ContentMeta, ContentRef } from "./Content";
 import { Review } from './Review';
-import { UncertainValue } from './Progress';
+import { SkillLevel } from './SkillLevel';
 /**
  * How aggressively the card selection algorithm stretches the user
  * beyond their current skill level.
@@ -29,7 +29,7 @@ export interface SessionConfig {
     };
 }
 export interface SessionStats {
-    skill_level: UncertainValue;
+    skill_level: SkillLevel;
     cognitive_load: number;
     theta_distribution: {
         A: number;

package/dist/models/SkillLevel.d.ts

@@ -15,31 +15,71 @@ export interface SkillLevel {
     sigma: number;
 }
 /**
- * Legacy interface for backwards compatibility during migration.
- * Maps to the new SkillLevel interface.
- * @deprecated Use SkillLevel with mu/sigma instead
+ * Parameters for skill level updates.
+ * All parameters are optional and have sensible defaults.
  */
-export interface LegacySkillLevel {
-    rating: number;
-    rating_deviation: number;
-    volatility: number;
+export interface SkillUpdateParams {
+    /**
+     * Coefficient controlling how quickly skill moves toward evidence.
+     *
+     * When informative evidence is received, skill moves this fraction
+     * of the distance from current mu toward the card's difficulty.
+     *
+     * - 0.5 means move halfway toward the card difficulty each time
+     * - Lower values = more conservative, requires more evidence
+     * - Higher values = more aggressive, trusts individual observations more
+     *
+     * With coefficient 0.5, approaching a difficulty level:
+     * - After 1 review: 50% of the way
+     * - After 2 reviews: 75% of the way
+     * - After 3 reviews: 87.5% of the way
+     * - After 5 reviews: 96.9% of the way
+     *
+     * @default 0.5
+     */
+    updateCoefficient?: number;
+    /**
+     * Coefficient for sigma updates when evidence is informative.
+     * Sigma is multiplied by this value (so 0.9 = 10% decay).
+     *
+     * @default 0.9
+     */
+    sigmaDecay?: number;
+    /**
+     * Minimum sigma value to prevent over-confidence.
+     * Even with many observations, we maintain some uncertainty.
+     *
+     * @default 5
+     */
+    minSigma?: number;
+    /**
+     * Maximum sigma value.
+     *
+     * @default 100
+     */
+    maxSigma?: number;
 }
 /**
- * Model for updating and managing skill levels using Item Response Theory (IRT).
+ * Default parameters for skill updates.
+ */
+export declare const DEFAULT_SKILL_PARAMS: Required<SkillUpdateParams>;
+/**
+ * Model for updating and managing skill levels using Item Response Theory (IRT)
+ * with asymmetric evidence clamping.
  *
- * This model estimates user skill based on a logistic psychometric function:
- *   P(success | difficulty d, skill μ) = 1 / (1 + exp(k * (d - μ)))
+ * This model is based on standard IRT psychometric principles but applies a
+ * clamping constraint that reflects the asymmetric nature of flashcard evidence:
  *
- * Where:
- * - μ (mu) is the skill level we're estimating
- * - k controls the steepness of the transition from "easy" to "hard"
- * - Cards with difficulty < μ are likely to be answered correctly
- * - Cards with difficulty > μ are likely to be answered incorrectly
+ * - Succeeding on a card of difficulty D provides evidence that skill >= D,
+ *   but a single success should NOT push skill estimate above D
+ * - Failing on a card of difficulty D provides evidence that skill <= D,
+ *   but a single failure should NOT push skill estimate below D
+ * - Succeeding on easy cards (difficulty < skill) is uninformative
+ * - Failing on hard cards (difficulty > skill) is uninformative
  *
- * The model uses Bayesian updating with a Gaussian approximation:
- * - Each observation updates μ based on prediction error
- * - Uncertainty (σ) decreases as we accumulate evidence
- * - No full history is needed - just μ and σ are sufficient statistics
+ * The update rule moves skill toward the card difficulty by a fraction (coefficient),
+ * ensuring that skill can only asymptotically approach demonstrated competence
+ * through multiple consistent observations.
  *
  * Scale semantics:
  * - μ = 0: absolute beginner (knows ~0 characters)
@@ -48,48 +88,31 @@ export interface LegacySkillLevel {
  */
 export declare class SkillLevelModel {
     /**
-     * Steepness parameter for the logistic function.
-     *
-     * Controls how sharply success probability drops as difficulty exceeds skill:
-     * - k = 0.05 means the transition zone spans ~40 difficulty points
-     * - At difficulty = μ, P(success) = 50%
-     * - At difficulty = μ + 20, P(success) ≈ 27%
-     * - At difficulty = μ + 40, P(success) ≈ 12%
-     *
-     * Lower k = more gradual transition, higher k = sharper cutoff.
+     * Discrimination parameter for predictSuccess logistic function.
+     * Controls how sharply probability transitions around difficulty = mu.
+     * Higher values = steeper curve. 0.05 gives gradual transition over ~60 difficulty units.
      */
     private static readonly K;
     /**
-     * Minimum sigma value to prevent over-confidence.
-     * Even with many observations, we maintain some uncertainty.
-     */
-    private static readonly MIN_SIGMA;
-    /**
-     * Maximum sigma value for initial state.
-     */
-    private static readonly MAX_SIGMA;
-    /**
-     * Update skill level using IRT after a review.
+     * Update skill level using clamped IRT after a review.
      *
-     * Uses Bayesian updating with a Gaussian approximation to the posterior.
-     * The update is incremental - only requires current μ and σ, not full history.
+     * Applies asymmetric evidence rules:
+     * - Success on harder card (difficulty > mu): informative, move mu up toward difficulty
+     * - Failure on easier card (difficulty < mu): informative, move mu down toward difficulty
+     * - Success on easier card: uninformative, no change
+     * - Failure on harder card: uninformative, no change
+     *
+     * When evidence is informative, sigma also decreases to reflect increased confidence.
+     * When evidence is uninformative, both mu and sigma remain unchanged.
      *
      * @param mu Current skill level estimate
      * @param sigma Current uncertainty (standard deviation)
      * @param cardDifficulty Difficulty of the card reviewed
      * @param outcome Review result (FAIL/HARD/GOOD/EASY)
+     * @param params Optional parameters to customize update behavior
      * @returns Updated skill level with new mu and sigma
      */
-    static update(mu: number, sigma: number, cardDifficulty: number, outcome: ReviewResult): SkillLevel;
-    /**
-     * Update skill level using IRT (Glicko-2 compatible signature).
-     *
-     * This method provides backwards compatibility with the old Glicko-2 API.
-     * The volatility and cardRatingDeviation parameters are ignored.
-     *
-     * @deprecated Use update() instead for cleaner IRT semantics
-     */
-    static updateWithGlicko2(rating: number, ratingDeviation: number, _volatility: number, cardDifficulty: number, _cardRatingDeviation: number, outcome: ReviewResult, _tau?: number): LegacySkillLevel;
+    static update(mu: number, sigma: number, cardDifficulty: number, outcome: ReviewResult, params?: SkillUpdateParams): SkillLevel;
     /**
      * Map a review outcome to a success score for IRT.
      *
@@ -122,19 +145,6 @@ export declare class SkillLevelModel {
      * @returns New SkillLevel object
      */
     static createDefault(initialSigma?: number): SkillLevel;
-    /**
-     * Create a default skill level in legacy format.
-     * @deprecated Use createDefault() instead
-     */
-    static createDefaultLegacy(initialRatingDeviation?: number, initialVolatility?: number): LegacySkillLevel;
-    /**
-     * Convert from legacy Glicko-2 format to IRT format.
-     */
-    static fromLegacy(legacy: LegacySkillLevel): SkillLevel;
-    /**
-     * Convert from IRT format to legacy Glicko-2 format.
-     */
-    static toLegacy(skill: SkillLevel): LegacySkillLevel;
     /**
      * Check if the skill level has high confidence (low uncertainty).
      *

package/dist/models/SkillLevel.js

@@ -1,22 +1,32 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.SkillLevelModel = void 0;
+exports.SkillLevelModel = exports.DEFAULT_SKILL_PARAMS = void 0;
 /**
- * Model for updating and managing skill levels using Item Response Theory (IRT).
+ * Default parameters for skill updates.
+ */
+exports.DEFAULT_SKILL_PARAMS = {
+    updateCoefficient: 0.5,
+    sigmaDecay: 0.9,
+    minSigma: 5,
+    maxSigma: 100
+};
+/**
+ * Model for updating and managing skill levels using Item Response Theory (IRT)
+ * with asymmetric evidence clamping.
  *
- * This model estimates user skill based on a logistic psychometric function:
- *   P(success | difficulty d, skill μ) = 1 / (1 + exp(k * (d - μ)))
+ * This model is based on standard IRT psychometric principles but applies a
+ * clamping constraint that reflects the asymmetric nature of flashcard evidence:
  *
- * Where:
- * - μ (mu) is the skill level we're estimating
- * - k controls the steepness of the transition from "easy" to "hard"
- * - Cards with difficulty < μ are likely to be answered correctly
- * - Cards with difficulty > μ are likely to be answered incorrectly
+ * - Succeeding on a card of difficulty D provides evidence that skill >= D,
+ *   but a single success should NOT push skill estimate above D
+ * - Failing on a card of difficulty D provides evidence that skill <= D,
+ *   but a single failure should NOT push skill estimate below D
+ * - Succeeding on easy cards (difficulty < skill) is uninformative
+ * - Failing on hard cards (difficulty > skill) is uninformative
  *
- * The model uses Bayesian updating with a Gaussian approximation:
- * - Each observation updates μ based on prediction error
- * - Uncertainty (σ) decreases as we accumulate evidence
- * - No full history is needed - just μ and σ are sufficient statistics
+ * The update rule moves skill toward the card difficulty by a fraction (coefficient),
+ * ensuring that skill can only asymptotically approach demonstrated competence
+ * through multiple consistent observations.
  *
  * Scale semantics:
  * - μ = 0: absolute beginner (knows ~0 characters)
@@ -25,53 +35,42 @@ exports.SkillLevelModel = void 0;
  */
 class SkillLevelModel {
     /**
-     * Update skill level using IRT after a review.
+     * Update skill level using clamped IRT after a review.
      *
-     * Uses Bayesian updating with a Gaussian approximation to the posterior.
-     * The update is incremental - only requires current μ and σ, not full history.
+     * Applies asymmetric evidence rules:
+     * - Success on harder card (difficulty > mu): informative, move mu up toward difficulty
+     * - Failure on easier card (difficulty < mu): informative, move mu down toward difficulty
+     * - Success on easier card: uninformative, no change
+     * - Failure on harder card: uninformative, no change
+     *
+     * When evidence is informative, sigma also decreases to reflect increased confidence.
+     * When evidence is uninformative, both mu and sigma remain unchanged.
      *
      * @param mu Current skill level estimate
      * @param sigma Current uncertainty (standard deviation)
      * @param cardDifficulty Difficulty of the card reviewed
      * @param outcome Review result (FAIL/HARD/GOOD/EASY)
+     * @param params Optional parameters to customize update behavior
      * @returns Updated skill level with new mu and sigma
      */
-    static update(mu, sigma, cardDifficulty, outcome) {
-        const k = SkillLevelModel.K;
-        // Map outcome to success value (0 to 1)
-        const y = SkillLevelModel.outcomeToScore(outcome);
-        // Predicted probability of success given current skill estimate
-        const p = 1 / (1 + Math.exp(k * (cardDifficulty - mu)));
-        // Prediction error: positive if did better than expected, negative if worse
-        const error = y - p;
-        // Fisher information for logistic model (highest at p = 0.5)
-        const info = p * (1 - p);
-        // Update variance (precision increases with information)
-        const sigmaSquared = sigma * sigma;
-        const newSigmaSquared = 1 / (1 / sigmaSquared + k * k * info);
-        const newSigma = Math.sqrt(newSigmaSquared);
-        // Update mean (shift toward evidence)
-        const newMu = mu + newSigmaSquared * k * error;
-        return {
-            mu: Math.max(0, newMu), // Skill can't go negative
-            sigma: Math.max(SkillLevelModel.MIN_SIGMA, Math.min(SkillLevelModel.MAX_SIGMA, newSigma))
-        };
-    }
-    /**
-     * Update skill level using IRT (Glicko-2 compatible signature).
-     *
-     * This method provides backwards compatibility with the old Glicko-2 API.
-     * The volatility and cardRatingDeviation parameters are ignored.
-     *
-     * @deprecated Use update() instead for cleaner IRT semantics
-     */
-    static updateWithGlicko2(rating, ratingDeviation, _volatility, cardDifficulty, _cardRatingDeviation, outcome, _tau = 0.5) {
-        const result = SkillLevelModel.update(rating, ratingDeviation, cardDifficulty, outcome);
-        // Return in legacy format
+    static update(mu, sigma, cardDifficulty, outcome, params = {}) {
+        const { updateCoefficient = exports.DEFAULT_SKILL_PARAMS.updateCoefficient, sigmaDecay = exports.DEFAULT_SKILL_PARAMS.sigmaDecay, minSigma = exports.DEFAULT_SKILL_PARAMS.minSigma, maxSigma = exports.DEFAULT_SKILL_PARAMS.maxSigma } = params;
+        const isSuccess = outcome === 'EASY' || outcome === 'GOOD';
+        const isFailure = outcome === 'FAIL' || outcome === 'HARD';
+        // Determine if this observation is informative
+        const isInformative = (isSuccess && cardDifficulty > mu) || // Success on harder card
+            (isFailure && cardDifficulty < mu); // Failure on easier card
+        if (!isInformative) {
+            // Uninformative evidence: no change to skill estimate
+            return { mu, sigma };
+        }
+        // Informative evidence: move mu toward card difficulty
+        const newMu = mu + updateCoefficient * (cardDifficulty - mu);
+        // Decrease sigma since we learned something
+        const newSigma = sigma * sigmaDecay;
         return {
-            rating: result.mu,
-            rating_deviation: result.sigma,
-            volatility: 0.06 // Fixed value, not used in IRT
+            mu: Math.max(0, newMu),
+            sigma: Math.max(minSigma, Math.min(maxSigma, newSigma))
         };
     }
     /**
@@ -127,36 +126,6 @@ class SkillLevelModel {
             sigma: initialSigma
         };
     }
-    /**
-     * Create a default skill level in legacy format.
-     * @deprecated Use createDefault() instead
-     */
-    static createDefaultLegacy(initialRatingDeviation = 50, initialVolatility = 0.06) {
-        return {
-            rating: 0,
-            rating_deviation: initialRatingDeviation,
-            volatility: initialVolatility
-        };
-    }
-    /**
-     * Convert from legacy Glicko-2 format to IRT format.
-     */
-    static fromLegacy(legacy) {
-        return {
-            mu: legacy.rating,
-            sigma: legacy.rating_deviation
-        };
-    }
-    /**
-     * Convert from IRT format to legacy Glicko-2 format.
-     */
-    static toLegacy(skill) {
-        return {
-            rating: skill.mu,
-            rating_deviation: skill.sigma,
-            volatility: 0.06
-        };
-    }
     /**
      * Check if the skill level has high confidence (low uncertainty).
      *
@@ -170,23 +139,8 @@ class SkillLevelModel {
 }
 exports.SkillLevelModel = SkillLevelModel;
 /**
- * Steepness parameter for the logistic function.
- *
- * Controls how sharply success probability drops as difficulty exceeds skill:
- * - k = 0.05 means the transition zone spans ~40 difficulty points
- * - At difficulty = μ, P(success) = 50%
- * - At difficulty = μ + 20, P(success) ≈ 27%
- * - At difficulty = μ + 40, P(success) ≈ 12%
- *
- * Lower k = more gradual transition, higher k = sharper cutoff.
+ * Discrimination parameter for predictSuccess logistic function.
+ * Controls how sharply probability transitions around difficulty = mu.
+ * Higher values = steeper curve. 0.05 gives gradual transition over ~60 difficulty units.
  */
 SkillLevelModel.K = 0.05;
-/**
- * Minimum sigma value to prevent over-confidence.
- * Even with many observations, we maintain some uncertainty.
- */
-SkillLevelModel.MIN_SIGMA = 5;
-/**
- * Maximum sigma value for initial state.
- */
-SkillLevelModel.MAX_SIGMA = 100;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@shaxpir/duiduidui-models",
-  "version": "1.9.21",
+  "version": "1.9.25",
   "repository": {
     "type": "git",
     "url": "https://github.com/shaxpir/duiduidui-models"