Génération d'une session d'exercices.

Le pipeline.

Une génération de session, de bout en bout. Le planificateur est pur (ni base de données, ni lecture d'horloge), donc le plan est reproductible à partir de l'instantané d'état et de la graine de session.

Les six étapes de grid().

Signature : grid(skind, &[LpState], base_lambda, n0, salt) -> Vec<Slot>. Renvoie vide pour les types de session que la grille ne possède pas (Recalibrate, Project, Freeform, Placement), qui retombent sur le chemin de prompt libre.

Structures de données.

Instantané d'entrée et créneau de sortie. Les deux dans sessions/grid.rs.

LpState, assemblé par build_lp_states()

Slot, un exercice que l'IA doit rédiger

Groupes, planchers et mélange de base.

Six paliers cognitifs forment l'unité de proportion. true_false est délibérément absent de toutes les listes de membres, car il est injecté orthogonalement et n'est jamais un type de quota.

base_mix(bloom) donne le pourcentage par palier, palier de maîtrise neutre, λ = 0. floor_group_tier(bloom) est le palier le plus bas portant de la masse pour « appliquer » et au-dessus ; en dessous, le mélange est mis à zéro puis renormalisé.

Le plancher ne s'applique que pour bloom.tier() >= 3 ; pour remember et understand les paliers bas restent légaux. Un plancher par type distinct, bloom::kind_violates_floor, retire des types individuels de l'ensemble proposé (par exemple mcq et writing sont tous deux illégaux sur une notion Apply : l'un trop bas, l'autre trop haut).

Constantes de calibration.

Toutes réglables ; ce sont les valeurs v1 réellement compilées.

target_exercise_count(kind, duration_min) = base × clamp(durée/30 ; 0,5 ; 2,0), arrondi, minimum 1.

depth_tilt(learning_depth) associe la chaîne de profondeur du brief à λ par correspondance de sous-chaîne :

Un palier solide avec une difficulté sous STRUGGLE_LOW ajoute +0,5 à λ (un cran d'étirement), jamais en examen.

Assemblage du prompt.

Deux couches. Le prompt système (SESSION_EXERCISES_SYSTEM_PROMPT, surchargeable en base via le registre de prompts) porte l'enveloppe JSON, les formes de data par type, les règles d'alignement, les règles strictes de correction des QCM et la règle de texte autosuffisant. Le prompt utilisateur est construit par appel par build_user_prompt() puis étendu par append_grid_plan().

Paramètres de requête : json_mode = true, temperature = 0.7, max_tokens = 8192, plus un schéma JSON (exercises_response_schema()) sauf en mode libre.

Validation et persistance.

Jusqu'à MAX_ATTEMPTS = 3 cycles. Tous les problèmes d'une réponse sont collectés et renvoyés ensemble, pour qu'une seule régénération les corrige tous ; une erreur de fournisseur ou de réseau ne consomme pas d'essai.

• Nombre. La réponse doit contenir exactement un exercice par élément du plan.
• Type. slot.allowed_kinds.contains(ex.kind), sinon l'élément est rejeté avec son index. C'est la frontière dure : l'IA ne peut pas échapper à la décision de palier de la grille.
• Forme. schema::validate_data(kind, data) rejette un contenu valide au schéma mais vide, par exemple un fill_blank dont expected est vide. Un élément fautif n'est jamais silencieusement écarté, car cela laisserait une session pédagogiquement incomplète.
• Persistance. write_exercises() supprime les exercices fraîchement rédigés de cette session puis réinsère, donc la régénération est idempotente. Les références réutilisées (session_exercise_refs.reused = 1) sont exclues de la cascade pour qu'un exercice partagé d'une session antérieure survive.
• Tableaux parallèles. scaffolds et transfer_probes sont alignés par index sur la liste fusionnée et écrits dans exercises.scaffold_level et questions.transfer_probe. Le drapeau de sonde est un fait de rédaction intrinsèque, lu identiquement par la soumission en direct et par le rejeu, donc une nouvelle correction ne peut pas diverger de la correction initiale.
• Ce que cette boucle ne vérifie pas. Tout ce qui précède vérifie la structure : combien d'items sont revenus, de quel type est chacun, et si ses champs sont remplis et cohérents entre eux. Aucun de ces contrôles ne lit l'exercice. Rien ici ne décide si un énoncé est vrai, si une clé de correction est juste, si la question teste réellement la notion à laquelle elle est rattachée, ni même si la formulation permet de répondre. Ces règles existent — elles sont écrites dans le prompt de génération ci-dessus — mais un prompt énonce une règle, il ne l'applique pas, et c'est ici le seul endroit où l'application pourrait avoir lieu. C'est une vraie lacune, elle est nommée ici volontairement, et c'est pour cette raison qu'un exercice qui vous paraît faux ou absurde vaut la peine d'être signalé.

Composition de session (quelles notions).

En amont de la grille, compose.rs sélectionne quelles notions une session vise. Pur également. Les types de récupération recomposent à l'échelle de la compétence au lieu de faire confiance à la liste épinglée du plan.

1. File des dues. Candidates dues triées par récupérabilité croissante, départagées par effet de levier sur le but plus élevé, puis stabilité plus faible, puis identifiant. Les plus en retard d'abord.
2. Partage du budget. budget_split(debt, k, mandate, nu). Un mandat Review est de la pure consolidation. Un mandat Course réserve un plancher de nouveau de round(k · 0,3 · (0,5 + nu)), borné à au moins 1 et au plus le plafond nominal, sauf si l'arriéré atteint 2·k, auquel cas le contenu neuf est entièrement abandonné et la session devient du rattrapage.
3. Complément. Si la file des dues ne remplit pas le pool de révision, des éléments encodés mais non dus sont ajoutés, les plus proches de l'échéance d'abord. Les éléments jamais commencés sont exclus, car ce sont du contenu neuf et non de la révision.
4. Entrelacement. Révision et nouveau sont alternés plutôt que regroupés, pour un espacement discriminatif.
5. Ordre de présentation. L'étape ci-dessus ordonne les notions ; la grille émet ensuite tous les items d'une notion avant de passer à la suivante, si bien qu'une session composée en alternance pouvait malgré tout être servie par blocs. Une passe finale les espace, et elle dépend de ce que vous connaissez déjà : une notion que vous avez déjà travaillée voit ses items distribués en alternance avec les autres, tandis qu'une notion rencontrée pour la première fois garde ses items groupés. L'entrelacement sert à distinguer les méthodes entre elles, ce qui ne vaut son coût de commutation qu'une fois la méthode exécutable — la consolidation d'abord, la discrimination ensuite. Les deux groupes sont ensuite servis dans cet ordre : le contenu dû d'abord, le contenu neuf ensuite. Qui interrompt une session tôt perd ce qui venait en dernier, et une révision manquée coûte de la rétention sur du contenu déjà appris là où une première rencontre reportée ne coûte que de l'avancement.

Invariants imposés.

Ces propriétés tiennent par construction dans grid() et sont couvertes par des tests unitaires. Ce sont des propriétés de l'ensemble proposé : aucun choix de l'IA ne peut les violer.