Skip to content

DeepTutor: Lifelong Personalized Tutoring. https://deeptutor.info/.

fix(learning): prevent compounding SRS lapses during multi-turn qualitative repairs (#1781) (#1794)

OrdoAbChaoa067db1116e0
diff --git a/deeptutor/learning/scheduler.py b/deeptutor/learning/scheduler.py
index 595b5e73f..0f295ec6f 100644
--- a/deeptutor/learning/scheduler.py
+++ b/deeptutor/learning/scheduler.py
@@ -264,18 +264,24 @@ class SpacedRepetitionScheduler:
_SAME_SESSION_DAYS,
self._interval_from_stability(previous_stability, DEFAULT_DESIRED_RETENTION) * 0.5,
)
- if (
- quality >= _FAIL_QUALITY
- and state.last_review_at is not None
- and elapsed_days < same_session_days
- ):
- # Repeated practice refreshes recall, but must not repeatedly
- # multiply stability or postpone the original review deadline.
- state.review_count += 1
- state.last_review_at = moment
- state.retrievability = 1.0
- state.consecutive_wrong = 0
- return state
+ if state.last_review_at is not None and elapsed_days < same_session_days:
+ if quality >= _FAIL_QUALITY:
+ # Repeated practice refreshes recall, but must not repeatedly
+ # multiply stability or postpone the original review deadline.
+ state.review_count += 1
+ state.last_review_at = moment
+ state.retrievability = 1.0
+ state.consecutive_wrong = 0
+ return state
+ if state.scheduled_after_failure and (
+ evidence.result == "partial" or evidence.assessment_type == "qualitative"
+ ):
+ # Formative follow-ups within an active repair episode do not count
+ # as repeated independent lapses or compound stability loss (#1781).
+ state.review_count += 1
+ state.last_review_at = moment
+ state.retrievability = max(quality, 0.2)
+ return state
spacing_ratio = min(elapsed_days / previous_stability, 4.0)
# Difficulty is an item/learner estimate, not the knowledge-type
diff --git a/deeptutor/learning/tests/test_guided_mastery_updates.py b/deeptutor/learning/tests/test_guided_mastery_updates.py
index cdd3c1b3e..31d75da70 100644
--- a/deeptutor/learning/tests/test_guided_mastery_updates.py
+++ b/deeptutor/learning/tests/test_guided_mastery_updates.py
@@ -397,6 +397,53 @@ def test_qualitative_live_state_matches_evidence_replay(tmp_path, monkeypatch):
assert live.model_dump() == pytest.approx(replayed.model_dump())
+def test_record_qualitative_multi_turn_repair_does_not_compound_lapses(tmp_path, monkeypatch):
+ """Regression test for #1781 through LearningService.record_qualitative_in_memory."""
+ store = LearningStore(root=tmp_path)
+ service = LearningService(store)
+ scheduler = SpacedRepetitionScheduler()
+ progress = _make_progress()
+ moment = [1_700_000_000.0]
+ monkeypatch.setattr("deeptutor.learning.service.time.time", lambda: moment[0])
+
+ # Turn 1: initial incomplete explanation
+ service.record_qualitative_in_memory(
+ progress, "kp1", passed=False, evidence="incomplete concept", scheduler=scheduler
+ )
+ state = progress.repetition_states["kp1"]
+ assert state.lapse_count == 1
+ assert state.review_count == 1
+ stability_after_fail = state.stability
+ due_after_fail = state.next_review_at
+
+ # Turn 2: 3 minutes later, formative clarification still incomplete
+ moment[0] += 3 * 60
+ service.record_qualitative_in_memory(
+ progress, "kp1", passed=False, evidence="partial clarification", scheduler=scheduler
+ )
+ assert state.lapse_count == 1
+ assert state.review_count == 2
+ assert state.stability == stability_after_fail
+ assert state.next_review_at == due_after_fail
+
+ # Turn 3: 7 minutes from start, completed explanation
+ moment[0] += 4 * 60
+ service.record_qualitative_in_memory(
+ progress, "kp1", passed=True, evidence="complete explanation", scheduler=scheduler
+ )
+ assert progress.qualitative_mastery["kp1"] is True
+ assert progress.mastery_levels["kp1"] == 1.0
+ assert state.lapse_count == 1
+ assert state.review_count == 3
+ assert state.stability == stability_after_fail
+ assert state.next_review_at == due_after_fail
+ assert state.retrievability == 1.0
+
+ # Ensure replay produces the exact same state
+ replayed = scheduler.replay(KnowledgeType.CONCEPT, progress.learning_evidence)
+ assert state.model_dump() == pytest.approx(replayed.model_dump())
+
+
def test_grade_and_record_retry_correct_uses_weaker_quality(tmp_path):
store = LearningStore(root=tmp_path)
service = LearningService(store)
diff --git a/deeptutor/learning/tests/test_scheduler.py b/deeptutor/learning/tests/test_scheduler.py
index 93b8edf80..fe51d408c 100644
--- a/deeptutor/learning/tests/test_scheduler.py
+++ b/deeptutor/learning/tests/test_scheduler.py
@@ -561,3 +561,180 @@ class TestRetentionBaseline:
assert [task.knowledge_point_id for task in tasks] == ["kp_risk", "kp_safe"]
assert tasks[0].forgetting_risk > tasks[1].forgetting_risk
assert "retrievability" in tasks[0].reason
+
+
+# ── qualitative repair follow-ups (#1781) ───────────────────────────────────
+
+
+class TestQualitativeRepairFollowups:
+ def test_formative_partial_followups_do_not_compound_lapses_or_stability_loss(self, scheduler):
+ """Regression test for #1781: multiple partial clarifications during one
+ short qualitative repair episode must not repeatedly increment lapse_count
+ or compound stability loss.
+ """
+ start = 1_700_000_000.0
+ # Start with an already-due concept objective matching the issue:
+ # stability 2.0 days, difficulty 0.4, desired retention 0.7, retrievability 0.7.
+ state = RepetitionState(
+ interval_index=0,
+ consecutive_correct=0,
+ consecutive_wrong=0,
+ next_review_at=start,
+ difficulty=0.4,
+ stability=2.0,
+ retrievability=0.7,
+ desired_retention=0.7,
+ review_count=1,
+ lapse_count=0,
+ last_review_at=start - (-2.0 * math.log(0.7)) * 86400,
+ last_scheduled_at=start,
+ scheduled_after_failure=False,
+ )
+ assert scheduler.retrievability(state, now=start) == pytest.approx(0.7)
+
+ # +0 min: first partial explanation -> records lapse and reschedules
+ ev1 = LearningEvidence(
+ knowledge_point_id="kp1",
+ timestamp=start,
+ quality=0.2,
+ result="partial",
+ assessment_type="qualitative",
+ )
+ scheduler.schedule_review(state, KnowledgeType.CONCEPT, ev1, now=start)
+ assert state.lapse_count == 1
+ assert state.review_count == 2
+ assert state.stability == pytest.approx(0.6585, rel=1e-3)
+ assert state.scheduled_after_failure is True
+ initial_due = state.next_review_at
+ assert (initial_due - start) / 60 == pytest.approx(169.107, rel=1e-3)
+
+ # +4 min: second partial explanation during repair -> must NOT compound lapse or stability
+ ev2 = LearningEvidence(
+ knowledge_point_id="kp1",
+ timestamp=start + 4 * 60,
+ quality=0.2,
+ result="partial",
+ assessment_type="qualitative",
+ )
+ scheduler.schedule_review(state, KnowledgeType.CONCEPT, ev2, now=ev2.timestamp)
+ assert state.lapse_count == 1
+ assert state.review_count == 3
+ assert state.stability == pytest.approx(0.6585, rel=1e-3)
+ assert state.next_review_at == initial_due
+ assert state.retrievability == pytest.approx(0.2)
+
+ # +8 min: completed explanation -> same-session success refreshes recall without inflating interval
+ ev3 = LearningEvidence(
+ knowledge_point_id="kp1",
+ timestamp=start + 8 * 60,
+ quality=1.0,
+ result="correct",
+ assessment_type="qualitative",
+ )
+ scheduler.schedule_review(state, KnowledgeType.CONCEPT, ev3, now=ev3.timestamp)
+ assert state.lapse_count == 1
+ assert state.review_count == 4
+ assert state.stability == pytest.approx(0.6585, rel=1e-3)
+ assert state.next_review_at == initial_due
+ assert state.retrievability == 1.0
+ assert state.consecutive_wrong == 0
+
+ def test_qualitative_repair_replays_consistently(self, scheduler):
+ start = 1_700_000_000.0
+ events = [
+ LearningEvidence(
+ knowledge_point_id="kp1",
+ timestamp=start,
+ quality=0.2,
+ result="partial",
+ assessment_type="qualitative",
+ ),
+ LearningEvidence(
+ knowledge_point_id="kp1",
+ timestamp=start + 3 * 60,
+ quality=0.2,
+ result="partial",
+ assessment_type="qualitative",
+ ),
+ LearningEvidence(
+ knowledge_point_id="kp1",
+ timestamp=start + 7 * 60,
+ quality=1.0,
+ result="correct",
+ assessment_type="qualitative",
+ ),
+ ]
+ live = scheduler.get_initial_state(KnowledgeType.CONCEPT, now=start, desired_retention=0.7)
+ for ev in events:
+ scheduler.schedule_review(live, KnowledgeType.CONCEPT, ev, now=ev.timestamp)
+
+ replayed = scheduler.replay(KnowledgeType.CONCEPT, events, desired_retention=0.7)
+ assert replayed.stability == pytest.approx(live.stability)
+ assert replayed.lapse_count == live.lapse_count == 1
+ assert replayed.review_count == live.review_count == 3
+ assert replayed.next_review_at == pytest.approx(live.next_review_at)
+ assert replayed.scheduled_after_failure == live.scheduled_after_failure
+
+ def test_delayed_retrieval_after_qualitative_repair_succeeds_or_fails_independently(
+ self, scheduler
+ ):
+ start = 1_700_000_000.0
+ state = scheduler.get_initial_state(KnowledgeType.CONCEPT, now=start, desired_retention=0.7)
+ ev1 = LearningEvidence(
+ knowledge_point_id="kp1",
+ timestamp=start,
+ quality=0.2,
+ result="partial",
+ assessment_type="qualitative",
+ )
+ scheduler.schedule_review(state, KnowledgeType.CONCEPT, ev1, now=start)
+ ev2 = LearningEvidence(
+ knowledge_point_id="kp1",
+ timestamp=start + 4 * 60,
+ quality=0.2,
+ result="partial",
+ assessment_type="qualitative",
+ )
+ scheduler.schedule_review(state, KnowledgeType.CONCEPT, ev2, now=ev2.timestamp)
+ ev3 = LearningEvidence(
+ knowledge_point_id="kp1",
+ timestamp=start + 8 * 60,
+ quality=1.0,
+ result="correct",
+ assessment_type="qualitative",
+ )
+ scheduler.schedule_review(state, KnowledgeType.CONCEPT, ev3, now=ev3.timestamp)
+ assert state.lapse_count == 1
+ post_repair_stability = state.stability
+ due_time = state.next_review_at
+
+ # Test A: Successful delayed retrieval at due time (e.g. 3 hours later)
+ success_state = state.model_copy(deep=True)
+ ev_success = LearningEvidence(
+ knowledge_point_id="kp1",
+ timestamp=due_time + 60,
+ quality=1.0,
+ result="correct",
+ assessment_type="qualitative",
+ )
+ scheduler.schedule_review(
+ success_state, KnowledgeType.CONCEPT, ev_success, now=ev_success.timestamp
+ )
+ assert success_state.lapse_count == 1
+ assert success_state.stability > post_repair_stability
+ assert success_state.scheduled_after_failure is False
+ assert success_state.next_review_at > due_time + 60
+
+ # Test B: Independent failure at due time counts as a genuine new lapse
+ fail_state = state.model_copy(deep=True)
+ ev_fail = LearningEvidence(
+ knowledge_point_id="kp1",
+ timestamp=due_time + 60,
+ quality=0.2,
+ result="partial",
+ assessment_type="qualitative",
+ )
+ scheduler.schedule_review(fail_state, KnowledgeType.CONCEPT, ev_fail, now=ev_fail.timestamp)
+ assert fail_state.lapse_count == 2
+ assert fail_state.stability < post_repair_stability
+ assert fail_state.scheduled_after_failure is True