Identische Grundlagenwiederholungen im Lernweg gezielt reduzieren

Der thematische Lernweg berücksichtigt bisher gut gelöste Aufgaben nun bei
neuen Schritten. Kürzlich positive Grundlagen führen bevorzugt zu unbekannten,
redaktionell freigegebenen Grammatikbeispielen desselben Satzmusters. Ohne neues
Beispiel können aktuelle oder unabhängig gestützte positive Ergebnisse weitere
identische Grundlagenwiederholungen reduzieren. Ältere, neuere schwache und
unbenotete Ergebnisse werden vorsichtig behandelt; Wortbedeutungen bleiben getrennt.

Berücksichtigte frühere Übung wird separat vom manuellen Überspringen gezählt,
ohne neue Antworten, Noten oder Beherrschungsnachweise zu erzeugen. Gewählte
Transferbeispiele bleiben stabil. Lernwegposition, historische Aufgaben und
Bewertungen sowie Prüfungen bleiben erhalten; unvollständige Prüfungen und
Demoantworten liefern keine positiven Auswahlbelege. Frühere Bewertungen werden
bei einer erneut empfohlenen Aufgabe ausdrücklich eingeklappt gekennzeichnet.

Validierung: Go-Race-Suite mit eigener lokaler PostgreSQL-Testdatenbank, go vet,
Web-Build, Bank-/Varianten-/Sequenzaudit sowie lokale Browser-Smokes für Sprachen,
Kurs und vorherige Bewertungen. Geprüft sind unter anderem Nutzertrennung,
Zeitabstände, neue Fehler, unbenotete Antworten und stabile Transferbeispiele
beim Sprachwechsel. Keine zusätzlichen Modellaufrufe oder Produktionsänderungen.
This commit is contained in:
Eugenius Naumenko
2026-11-11 19:13:08 +00:00
parent 7499491ae8
commit 8d618b7fe6
22 changed files with 1277 additions and 130 deletions
+72 -18
View File
@@ -10,6 +10,7 @@ import (
"errors"
"fmt"
"sync"
"time"
"speech-learning-api/internal/domain"
)
@@ -29,12 +30,15 @@ CREATE TABLE IF NOT EXISTS course_v2_sequence_progress (
reviewed BOOLEAN NOT NULL DEFAULT false,
PRIMARY KEY(user_id,language,version,module_id,revision));
ALTER TABLE course_v2_sequence_progress ADD COLUMN IF NOT EXISTS reviewed BOOLEAN NOT NULL DEFAULT false;
ALTER TABLE course_v2_sequence_progress ADD COLUMN IF NOT EXISTS reused_steps INT NOT NULL DEFAULT 0 CHECK(reused_steps>=0);
ALTER TABLE course_v2_sequence_progress ADD COLUMN IF NOT EXISTS practice_reason TEXT NOT NULL DEFAULT '';
`
type sequencePack struct {
Revision string `json:"revision"`
Review string `json:"editorial_review_sha256"`
Sequences []domain.LearningSequence `json:"sequences"`
SelectionRevision string `json:"selection_revision"`
Revision string `json:"revision"`
Review string `json:"editorial_review_sha256"`
Sequences []domain.LearningSequence `json:"sequences"`
}
var sequencesOnce sync.Once
@@ -67,7 +71,7 @@ func bundledSequences() (sequencePack, error) {
return sequencesPack, sequencesError
}
func validateSequences(pack sequencePack, base []domain.BankEntry) error {
if pack.Revision == "" || len(pack.Review) != 64 || len(pack.Sequences) == 0 {
if pack.Revision == "" || pack.SelectionRevision == "" || len(pack.Review) != 64 || len(pack.Sequences) == 0 {
return errors.New("missing sequence review")
}
entries := map[string]domain.BankEntry{}
@@ -93,6 +97,14 @@ func validateSequences(pack sequencePack, base []domain.BankEntry) error {
if next >= len(phases) || step.Phase != phases[next] || !ok || entry.Task.ModuleID != seq.ModuleID || entry.Task.Kind != kinds[next] || entry.Task.Skill != skills[next] {
return fmt.Errorf("invalid sequence step: %s/%s", seq.ID, step.BankEntryID)
}
alternatives := map[string]bool{step.BankEntryID: true}
for _, id := range step.Alternatives {
alternate, ok := entries[id]
if step.Phase != "grammar" || !ok || alternatives[id] || alternate.Goal != entry.Goal || alternate.Task.ModuleID != seq.ModuleID || alternate.Task.Skill != "grammar" || alternate.Task.Kind != "choice" {
return fmt.Errorf("invalid transfer alternative: %s/%s", seq.ID, id)
}
alternatives[id] = true
}
phase = next
}
if phase != len(phases)-1 {
@@ -136,7 +148,7 @@ func sequencePositions(pack sequencePack, module string) []sequencePosition {
return out
}
func recommendationAt(pack sequencePack, positions []sequencePosition, cursor, skipped int, task, native string) *domain.SequenceRecommendation {
r := &domain.SequenceRecommendation{Revision: pack.Revision, Complete: cursor >= len(positions), SkippedSteps: skipped}
r := &domain.SequenceRecommendation{SelectionRevision: pack.SelectionRevision, Revision: pack.Revision, Complete: cursor >= len(positions), SkippedSteps: skipped}
if r.Complete {
return r
}
@@ -168,13 +180,17 @@ func (s *AdaptiveStore) SequenceRecommendation(ctx context.Context, user, langua
}
var cursor, skipped int
var reviewed bool
var reused int
var reason string
var task string
err = s.db.QueryRowContext(ctx, `SELECT cursor,skipped_steps,COALESCE(active_task_id,''),reviewed FROM course_v2_sequence_progress WHERE user_id=$1 AND language=$2 AND version=$3 AND module_id=$4 AND revision=$5`, user, language, domain.CourseVersion, module, pack.Revision).Scan(&cursor, &skipped, &task, &reviewed)
err = s.db.QueryRowContext(ctx, `SELECT cursor,skipped_steps,COALESCE(active_task_id,''),reviewed,reused_steps,practice_reason FROM course_v2_sequence_progress WHERE user_id=$1 AND language=$2 AND version=$3 AND module_id=$4 AND revision=$5`, user, language, domain.CourseVersion, module, pack.Revision).Scan(&cursor, &skipped, &task, &reviewed, &reused, &reason)
if err != nil && !errors.Is(err, sql.ErrNoRows) {
return nil, err
}
r := recommendationAt(pack, positions, cursor, skipped, task, native)
r.Review = reviewed
r.ReusedSteps = reused
r.PracticeReason = reason
if task != "" && !r.Complete {
answered, err := sequenceAnswered(ctx, s.db, domain.CourseJob{UserID: user, Language: language, ModuleID: module}, pack.Revision)
if err != nil {
@@ -186,6 +202,8 @@ func (s *AdaptiveStore) SequenceRecommendation(ctx context.Context, user, langua
}
type sequenceSelection struct {
Reused int
Reason string
Reset bool
Reviewed bool
Cursor int
@@ -214,9 +232,11 @@ func selectSequence(ctx context.Context, tx *sql.Tx, j domain.CourseJob, candida
}
var cursor, skipped int
var reviewed bool
var reused int
var reason string
reset := false
var active string
err = tx.QueryRowContext(ctx, `SELECT cursor,skipped_steps,COALESCE(active_task_id,''),reviewed FROM course_v2_sequence_progress WHERE user_id=$1 AND language=$2 AND version=$3 AND module_id=$4 AND revision=$5 FOR UPDATE`, j.UserID, j.Language, domain.CourseVersion, j.ModuleID, pack.Revision).Scan(&cursor, &skipped, &active, &reviewed)
err = tx.QueryRowContext(ctx, `SELECT cursor,skipped_steps,COALESCE(active_task_id,''),reviewed,reused_steps,practice_reason FROM course_v2_sequence_progress WHERE user_id=$1 AND language=$2 AND version=$3 AND module_id=$4 AND revision=$5 FOR UPDATE`, j.UserID, j.Language, domain.CourseVersion, j.ModuleID, pack.Revision).Scan(&cursor, &skipped, &active, &reviewed, &reused, &reason)
if err != nil {
return nil, 0, err
}
@@ -252,19 +272,53 @@ func selectSequence(ctx context.Context, tx *sql.Tx, j domain.CourseJob, candida
active = ""
}
}
r := recommendationAt(pack, positions, cursor, skipped, active, j.InstructionLanguage)
r.Review = reviewed
selection := &sequenceSelection{Cursor: cursor, Skipped: skipped, Recommendation: r, Reviewed: reviewed, Reset: reset}
if r.Complete {
return selection, 0, nil
}
for n, candidate := range candidates {
if candidate.bankEntryID == positions[cursor].Step.BankEntryID {
return selection, n, nil
index := 0
if cursor < len(positions) && active != "" {
// Keep a chosen transfer example stable across reload, locale changes,
// retries and fresh Next requests; evidence updates never replace it mid-step.
var bankID string
if err = tx.QueryRowContext(ctx, `SELECT bank_entry_id FROM course_v2_tasks WHERE id=$1 AND owner_id=$2 AND language=$3 AND version=$4 AND exam_id IS NULL`, active, j.UserID, j.Language, domain.CourseVersion).Scan(&bankID); err != nil {
return nil, 0, err
}
index = -1
for n, candidate := range candidates {
if candidate.bankEntryID == bankID {
index = n
break
}
}
if index < 0 {
return nil, 0, ErrCourseVariantUnavailable
}
} else if cursor < len(positions) {
now := time.Now().UTC()
history, err := readFoundationHistory(ctx, tx, j, now)
if err != nil {
return nil, 0, err
}
for cursor < len(positions) {
var reuse bool
index, reuse, reason = chooseFoundation(positions[cursor].Step, candidates, history, now)
if index < 0 {
return nil, 0, ErrCourseVariantUnavailable
}
if !reuse {
break
}
cursor++
reused++
reset = true
reviewed = false
}
}
return nil, 0, ErrCourseVariantUnavailable
r := recommendationAt(pack, positions, cursor, skipped, active, j.InstructionLanguage)
r.Review = reviewed
r.ReusedSteps = reused
r.PracticeReason = reason
selection := &sequenceSelection{Cursor: cursor, Skipped: skipped, Recommendation: r, Reviewed: reviewed, Reset: reset, Reused: reused, Reason: reason}
return selection, index, nil
}
func saveSequenceSelection(ctx context.Context, tx *sql.Tx, j domain.CourseJob, selection *sequenceSelection, taskID string) error {
if selection == nil {
return nil
@@ -275,7 +329,7 @@ func saveSequenceSelection(ctx context.Context, tx *sql.Tx, j domain.CourseJob,
}
r.TaskID = taskID
r.NeedsAnswer = taskID != ""
_, err := tx.ExecContext(ctx, `UPDATE course_v2_sequence_progress SET cursor=$6,skipped_steps=$7,presented_at=CASE WHEN $9 OR active_task_id IS DISTINCT FROM NULLIF($8,'') THEN now() ELSE presented_at END,active_task_id=NULLIF($8,''),reviewed=$10 WHERE user_id=$1 AND language=$2 AND version=$3 AND module_id=$4 AND revision=$5`, j.UserID, j.Language, domain.CourseVersion, j.ModuleID, r.Revision, selection.Cursor, selection.Skipped, taskID, selection.Reset, selection.Reviewed)
_, err := tx.ExecContext(ctx, `UPDATE course_v2_sequence_progress SET cursor=$6,skipped_steps=$7,presented_at=CASE WHEN $9 OR active_task_id IS DISTINCT FROM NULLIF($8,'') THEN now() ELSE presented_at END,active_task_id=NULLIF($8,''),reviewed=$10,reused_steps=$11,practice_reason=$12 WHERE user_id=$1 AND language=$2 AND version=$3 AND module_id=$4 AND revision=$5`, j.UserID, j.Language, domain.CourseVersion, j.ModuleID, r.Revision, selection.Cursor, selection.Skipped, taskID, selection.Reset, selection.Reviewed, selection.Reused, selection.Reason)
return err
}