After a quiz, exercise test or the simulation: answer the wrong questions again

A mistakes round (kind mistakes_round) over the questions the handed-in attempt got wrong, in the lesson round's sheet: instant feedback,
never the right answer, counted as practice, the grade unchanged. Needs migration 20261122090000_m2_mistakes_round.sql.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

mathly2/rounds.py

@@ -6,7 +6,11 @@ ROUND_SIZE from all of them. The questions are answered in order, each once, and
 for mastery and the daily goal; a wrong one goes to the review list). After the last answer the round is graded and closed.
 
 A lesson's stars: 3 when every skill is mastered, else 2 when a finished round had at least TWO_STARS percent right, else 1 when a round was
-finished, else 0. Nothing here ever says which choice was right."""
+finished, else 0. Nothing here ever says which choice was right.
+
+A mistakes round (חזרה על הטעויות, kind `mistakes_round`, scope: the handed-in attempt's id) is the same sheet over the questions a handed-in
+quiz, exercise test or simulation got wrong (or left empty): answered again one by one with instant feedback, as practice. It has no stars and
+never changes the attempt's grade."""
 from __future__ import annotations
 
 import logging
@@ -27,6 +31,8 @@ KIND = "lesson_round"
 ROUND_SIZE = 10
 PER_SKILL = 3          # three right in a row is what mastery needs, so a skill never takes more of a round
 TWO_STARS = 80         # percent right in a finished round for the second star
+RETRY = "mistakes_round"
+RETRY_OF = ("quiz", "exercise_test", "simulation")
 
 
 class RoundAnswer(BaseModel):
@@ -102,10 +108,16 @@ def _lesson_stars(request: Request, uid: str, lesson_id: str, rows: list[dict])
 def view(request: Request, row: dict) -> dict:
     """An open round: its size, a result per answered question and the next question (without the right answer). A finished round: its result."""
     bank, store = request.app.state.bank, request.app.state.store
-    lesson = next((l for l in bank.lessons if l["id"] == row["scope"]), {"id": row["scope"], "name": row["scope"]})
+    source = _source_info(request, row) if row["kind"] == RETRY else None
+    if source:
+        first = bank.skill(row["questions"][0]["skill_id"]) if row["questions"] else None
+        lesson = next((l for l in bank.lessons if first and l["id"] == first["unit"]), {})
+        lesson = {"id": row["scope"], "name": source["title"], "subject_id": lesson.get("subject_id", "math")}
+    else:
+        lesson = next((l for l in bank.lessons if l["id"] == row["scope"]), {"id": row["scope"], "name": row["scope"]})
     done = _graded(bank, row)
-    base = {"id": row["id"], "lesson": {"id": lesson["id"], "name": lesson["name"]}, "subject_id": lesson.get("subject_id", "math"), "total": len(row["questions"]),
-            "results": [right for _, right, _ in done]}
+    base = {"id": row["id"], "kind": row["kind"], "lesson": {"id": lesson["id"], "name": lesson["name"]}, "subject_id": lesson.get("subject_id", "math"),
+            "total": len(row["questions"]), "results": [right for _, right, _ in done], "source": source}
     if attempts.is_open(row):
         nxt = row["questions"][len(done)] if len(done) < len(row["questions"]) else None
         served = bank.practice_question(nxt["skill_id"], nxt["key"]) if nxt else None
@@ -134,19 +146,50 @@ def view(request: Request, row: dict) -> dict:
         served = bank.practice_question(q["skill_id"], q["key"])
         missed.append({"question": served["question"] if served else "", "skill_name": (bank.skill(q["skill_id"]) or {}).get("name", ""),
                        "mistake": {"name": mistake["name"], "tip": mistake["tip"]} if mistake else None})
-    all_rows = store.attempts_of(uid, KIND, row["scope"])
+    stars_now = None if source else _lesson_stars(request, uid, row["scope"], store.attempts_of(uid, KIND, row["scope"]))
     return {**base, "state": "done", "question": None,
-            "result": {"right": sum(base["results"]), "total": base["total"], "grade": row["grade"], "stars": _lesson_stars(request, uid, row["scope"], all_rows),
+            "result": {"right": sum(base["results"]), "total": base["total"], "grade": row["grade"], "stars": stars_now,
                        "mastered": mastered, "almost": almost, "missed": missed}}
 
 
 def _mine(request: Request, user: dict, round_id: str) -> dict:
     row = request.app.state.store.get_attempt(round_id)
-    if row is None or row["user_id"] != user["id"] or row["kind"] != KIND:
+    if row is None or row["user_id"] != user["id"] or row["kind"] not in (KIND, RETRY):
         raise HTTPException(404, "הסבב לא נמצא")
     return row
 
 
+def _source_info(request: Request, row: dict) -> dict:
+    """The handed-in attempt a mistakes round repeats: its kind, its test (if any) and a title."""
+    source = request.app.state.store.get_attempt(row["scope"])
+    kind = source["kind"] if source else "quiz"
+    test_id = int(source["scope"].split(":")[0]) if source and kind != "quiz" and source["scope"].split(":")[0].isdigit() else None
+    name = {"quiz": "הבוחן", "exercise_test": "מבחן התרגול", "simulation": "מבחן הסימולציה"}[kind]
+    return {"id": row["scope"], "kind": kind, "test_id": test_id, "lesson_id": source["scope"] if source and kind == "quiz" else None,
+            "title": f"חזרה על הטעויות ב{name}"}
+
+
+@router.post("/attempts/{attempt_id}/retry/start")
+def start_retry(attempt_id: str, request: Request, user: dict = Depends(learner)) -> dict:
+    """A mistakes round over the questions this handed-in attempt got wrong (or left empty): resume the open one, else a new one."""
+    store, bank, uid = request.app.state.store, request.app.state.bank, user["id"]
+    source = store.get_attempt(attempt_id)
+    if source is None or source["user_id"] != uid or source["kind"] not in RETRY_OF:
+        raise HTTPException(404, "הבוחן לא נמצא")
+    if attempts.is_open(source):
+        raise HTTPException(409, "קודם מגישים, ואז חוזרים על הטעויות")
+    for row in store.attempts_of(uid, RETRY, attempt_id):
+        if attempts.is_open(row):
+            return view(request, row)
+    wrong = [{"skill_id": q["skill_id"], "key": q["key"]} for q in source["questions"]
+             if bank.practice_question(q["skill_id"], q["key"]) and not (bank.grade(q["skill_id"], q["key"], source["answers"].get(q["key"]))
+                                                                      if isinstance(source["answers"].get(q["key"]), int) else {"correct": False}).get("correct")]
+    if not wrong:
+        raise HTTPException(409, "אין שאלות לא נכונות לחזור עליהן")
+    now = clock.now()
+    return view(request, store.create_attempt(uid, RETRY, attempt_id, now, now + timedelta(days=365), wrong))
+
+
 @router.post("/lessons/{lesson_id}/round/start")
 def start(lesson_id: str, request: Request, user: dict = Depends(learner)) -> dict:
     """Resume the lesson's open round, else draw a new one."""

mathly2/static/quiz.js

@@ -242,7 +242,7 @@ function renderResult() {
       ${m.picked ? `<p class="muted">בחרתם: <span dir="auto">${fmt(m.picked)}</span></p>` : `<p class="muted">לא ענו על השאלה.</p>`}
       ${m.mistake ? `<p><b>${esc(m.mistake.name)}</b>${m.mistake.tip ? `<br>${fmt(m.mistake.tip)}` : ""}</p>` : ""}</li>`).join("")}</ol>` : ""}
     ${reviewHtml(r)}
-    <p class="qz-actions">${names(r).again ? `<button type="button" class="primary" id="qz-retake">${names(r).again}</button> ` : ""}<button type="button" data-close>${r.kind === "quiz" ? "חזרה למסלול" : "חזרה למבחן"}</button></p>`;
+    <p class="qz-actions">${r.missed.length ? `<a class="button primary" id="qz-retry" href="#/retry/${esc(r.id)}">🔁 חזרה על השאלות שטעיתי (${r.missed.length})</a> ` : ""}${names(r).again ? `<button type="button" class="${r.missed.length ? "" : "primary"}" id="qz-retake">${names(r).again}</button> ` : ""}<button type="button" data-close>${r.kind === "quiz" ? "חזרה למסלול" : "חזרה למבחן"}</button></p>`;
   if (r.review?.state === "pending") waitForReview(r.id);
   const best = r.kind === "quiz" ? api(`/api/lessons/${encodeURIComponent(r.lesson.id)}/quiz`).then(f => f.best === null ? "" : `הציון של השיעור: ${f.best}`)
     : r.kind === "exercise_test" ? api(`/api/tests/${encodeURIComponent(r.test.id)}`).then(t => `הציון הטוב במבחן התרגול: ${t.exercise_tests[r.test.number - 1].best ?? ""}`) : Promise.resolve("");

mathly2/static/round.js

@@ -1,10 +1,11 @@
 // A lesson round (סבב שיעור), opened from the home's map: a short round of the lesson's skills, one question at a time, with instant feedback
 // like the exercise screen. A wrong answer names the mistake and never marks the right choice. The last answer shows the lesson's stars.
+// The same sheet plays a mistakes round (חזרה על הטעויות): the questions a handed-in quiz, exercise test or simulation got wrong, with no stars.
 import { api, ApiError } from "./api.js";
 import { figures } from "./figures.js";
 import { esc, fmt } from "./math.js";
 import { loadBoard } from "./exercise.js";
-import { homeHref, shuffled } from "./ui.js";
+import { homeHref, pathHref, shuffled } from "./ui.js";
 import { sendWorkQuietly } from "./boardwork.js";
 
 const COUNTDOWN = 2;   // seconds before the next question after a right answer
@@ -20,6 +21,13 @@ export const isOpen = () => !!layer;
 /** Start the lesson's round (or resume the open one). Returns the round, so the router knows its subject. */
 export const start = lesson => api(`/api/lessons/${encodeURIComponent(lesson)}/round/start`, { method: "POST" });
 
+/** Start (or resume) the mistakes round of a handed-in attempt. */
+export const startRetry = attemptId => api(`/api/attempts/${encodeURIComponent(attemptId)}/retry/start`, { method: "POST" });
+
+const isRetry = () => !!round?.source;
+/** Where closing leads: the home's map, or for a mistakes round its test's card (a quiz: the path). */
+const leaveTo = () => round?.source ? (round.source.test_id ? `#/test/${round.source.test_id}` : pathHref()) : homeHref();
+
 /** Show a round from `start` as a sheet over the home. */
 export async function show(data) {
   stop();
@@ -45,7 +53,7 @@ export function close() {
   layer = round = null;
 }
 
-const heading = () => `<div class="mx-shtop"><div><span class="ex-chip">סבב שיעור</span><h3 id="rd-title">${fmt(round.lesson.name)}</h3></div>
+const heading = () => `<div class="mx-shtop"><div><span class="ex-chip">${isRetry() ? "חזרה על הטעויות" : "סבב שיעור"}</span><h3 id="rd-title">${fmt(round.lesson.name)}</h3></div>
   <div class="mx-shacts">${window.MathlyBoard?.button() || ""}<button type="button" class="mx-x" data-close aria-label="סגירה">✕</button></div></div>`;
 
 const dots = () => Array.from({ length: round.total }, (_, i) => {
@@ -66,7 +74,21 @@ function questionHtml() {
 }
 
 /** The round's result: the stars big, the score, what was mastered, what is one good day away, and the mistakes (never the right answers). */
+function retryResultHtml() {
+  const r = round.result, all = r.right === r.total;
+  return `<section class="rd-result" id="rd-result" data-kind="retry">
+    <p class="rd-bigstars" aria-hidden="true">${all ? "🎉" : "💪"}</p>
+    <h4 class="rd-title">${all ? "כל הטעויות תוקנו!" : "סיימתם לחזור על הטעויות"}</h4>
+    <p class="ex-score" id="rd-score"><b>${r.right}</b> מתוך ${r.total} נכונות הפעם</p>
+    ${r.mastered.length ? `<p class="rd-mastered" id="rd-mastered">🎉 נשלטו: ${r.mastered.map(s => fmt(s.name)).join(", ")}</p>` : ""}
+    ${r.missed.length ? `<h4>עדיין כדאי לחזק</h4><ol class="ex-missed" id="rd-missed">${r.missed.map(m => `<li><p class="muted">${fmt(m.skill_name)}</p><p class="ex-text" dir="auto">${fmt(m.question)}</p>
+      ${m.mistake ? `<p><b>${esc(m.mistake.name)}</b>${m.mistake.tip ? `<br>${fmt(m.mistake.tip)}` : ""}</p>` : ""}</li>`).join("")}</ol>` : ""}
+    <p class="muted">הציון במבחן לא משתנה. התרגול נספר לשליטה במיומנויות.</p>
+    <p class="ex-actions">${all ? "" : `<button type="button" class="primary" id="rd-again">שוב על הטעויות</button> `}<button type="button" data-close>${round.source.test_id ? "חזרה למבחן" : "חזרה למסלול"}</button></p></section>`;
+}
+
 function resultHtml() {
+  if (isRetry()) return retryResultHtml();
   const r = round.result;
   const names = list => list.map(s => fmt(s.name)).join(", ");
   const title = r.stars === 3 ? "👑 השיעור מושלם!" : r.right === r.total ? "מושלם! כל התשובות נכונות" : r.right * 10 >= r.total * 8 ? "כל הכבוד!" : "סיימתם סבב!";
@@ -165,7 +187,7 @@ async function again() {
   const button = q("#rd-again");
   button.disabled = true;
   try {
-    round = await start(round.lesson.id);
+    round = await (isRetry() ? startRetry(round.source.id) : start(round.lesson.id));
     streak = 0;
     render();
   } catch (error) {
@@ -176,7 +198,7 @@ async function again() {
 
 function onClick(event) {
   const target = event.target;
-  if (target.closest("[data-close]")) { location.hash = homeHref(); return; }
+  if (target.closest("[data-close]")) { location.hash = leaveTo(); return; }
   if (target.closest("[data-board-toggle]")) { window.MathlyBoard?.toggle(); return; }
   if (target.closest("#rd-again")) { again(); return; }
   const choice = target.closest(".ex-choice");
@@ -186,5 +208,5 @@ function onClick(event) {
 window.addEventListener("mathly:leave", close);
 
 document.addEventListener("keydown", event => {
-  if (event.key === "Escape" && layer && !document.querySelector(".mx-board.full")) location.hash = homeHref();
+  if (event.key === "Escape" && layer && !document.querySelector(".mx-board.full")) location.hash = leaveTo();
 });

mathly2/static/student.js

@@ -24,7 +24,7 @@ export async function show(me, view) {
     phone.stopComputer();                                      // a page that was waiting for the phone's photo is left
     const raw = location.hash.replace(/^#/, "");
     const where = raw.startsWith("/") ? raw : "/";          // no address, or the sign-in service's "#access_token=…": the first screen
-    if (!where.startsWith("/round/")) lessonRound.close();
+    if (!where.startsWith("/round/") && !where.startsWith("/retry/")) lessonRound.close();
     try {
       if (where.startsWith("/round/")) {                                     // a lesson's round over the home (a link or a reload: the home first)
         exercise.close(); quiz.close();
@@ -32,6 +32,13 @@ export async function show(me, view) {
         setSubject(data.subject_id);
         if (!document.getElementById("lesson-map")) await home.show(view);
         await lessonRound.show(data);
+      } else if (where.startsWith("/retry/")) {                              // the mistakes of a handed-in attempt, over its test's card (a quiz: the path)
+        exercise.close(); quiz.close();
+        const data = await lessonRound.startRetry(decodeURIComponent(where.slice(7)));
+        setSubject(data.subject_id);
+        if (data.source.test_id) { if (!document.getElementById("test-card")) await (await import("./testcard.js")).show(view, data.source.test_id); }
+        else if (!document.getElementById("path")) await path.show(view);
+        await lessonRound.show(data);
       } else if (where.startsWith("/skill/")) {
         quiz.close();
         lastSkill = decodeURIComponent(where.slice(7));

mathly2/supabase/migrations/20261122090000_m2_mistakes_round.sql

@@ -0,0 +1,9 @@
+-- Mathly 2: a mistakes round (חזרה על הטעויות) after a quiz, an exercise test or the simulation: the questions it got wrong, answered again
+-- with instant feedback as practice. Kept as m2_attempts rows of kind mistakes_round (scope: the handed-in attempt's id). One widened check.
+-- Rollback: delete from public.m2_attempts where kind = 'mistakes_round';
+--           alter table public.m2_attempts drop constraint m2_attempts_kind_check;
+--           alter table public.m2_attempts add constraint m2_attempts_kind_check check (kind in ('quiz', 'exercise_test', 'simulation', 'lesson_round'));
+begin;
+alter table public.m2_attempts drop constraint m2_attempts_kind_check;
+alter table public.m2_attempts add constraint m2_attempts_kind_check check (kind in ('quiz', 'exercise_test', 'simulation', 'lesson_round', 'mistakes_round'));
+commit;

mathly2/tests/test_home_browser.py

@@ -374,6 +374,34 @@ def test_the_simulation_with_nothing_practiced_offers_a_bypass_on_all_the_materi
         assert len(store.attempts_of(KID_ID, "simulation")) == 1
 
 
+def test_after_the_simulation_the_wrong_questions_are_answered_again_in_a_round(browser, bank):
+    app, store, klass, lessons = world(bank)
+    started_skills(store, bank, lessons)
+    test = add_test(store, klass, lessons, 4, questions=6, minutes=45)
+    with running(app) as url:
+        page = sign_in(browser, url, f"#/sim/{test['id']}")
+        page.wait_for_selector("#qz-q")
+        page.click("#qz-submit")                                                                        # nothing answered: six mistakes
+        page.click("#qz-yes")
+        page.wait_for_selector("#qz-retry")
+        assert "(6)" in page.inner_text("#qz-retry")
+        page.click("#qz-retry")
+        page.wait_for_selector(".round-layer #ex-q")
+        assert "חזרה על הטעויות" in page.inner_text(".round-layer .ex-chip") and "מתוך 6" in page.inner_text("#rd-count")
+        for n in range(6):
+            page.locator(".round-layer .ex-choice").first.click()
+            page.wait_for_selector(".round-layer .ex-ok, .round-layer .ex-bad")
+            page.click("#rd-next")
+            if n < 5:
+                page.wait_for_function(f"document.querySelector('#rd-count').textContent.includes('{n + 2} מתוך')")
+        page.wait_for_selector("#rd-result[data-kind='retry']")
+        assert "הציון במבחן לא משתנה" in page.inner_text("#rd-result") and page.locator(".rd-bigstars span").count() == 0
+        assert store.attempts_of(KID_ID, "simulation")[0]["grade"] == 0
+        page.click("#rd-result [data-close]")
+        page.wait_for_selector("#test-card")
+        assert page.locator(".round-layer").count() == 0 and page.errors == []
+
+
 # --- 3.5 the grades screen has exercise tests and simulations ---
 
 def test_exercise_tests_and_the_simulation_appear_on_the_grades_screen(browser, bank):

mathly2/tests/test_permissions.py

@@ -54,6 +54,7 @@ NEEDS = {   # (method, path) -> permission
     ("POST", "/api/teaching/work/{attempt_id}"): "class.teach",
     ("POST", "/api/teaching/work/{attempt_id}/review"): "class.teach",
     ("POST", "/api/rounds/{round_id}/answer"): "path.use",
+    ("POST", "/api/attempts/{attempt_id}/retry/start"): "path.use",
     ("POST", "/api/tests/{test_id}/exercise/{number}/start"): "path.use",
     ("POST", "/api/tests/{test_id}/simulation/start"): "path.use",
     ("GET", "/api/tests/{test_id}"): "path.use",

mathly2/tests/test_realtests_api.py

@@ -451,3 +451,37 @@ def test_another_students_grades_are_not_mine_and_an_unfinished_attempt_is_not_l
     start_ex(client, test["id"])                                                                              # mine is open, not finished
     assert client.get("/api/grades", headers=auth(KID)).json()["exercise_tests"] == []
     assert len(client.get("/api/grades", headers=auth(KID2)).json()["exercise_tests"]) == 1
+
+
+def test_after_the_simulation_its_wrong_questions_can_be_answered_again_without_changing_the_grade(world):
+    client, store, lessons = world
+    bank = client.app.state.bank
+    test = set_test(client, lessons, days=14).json()
+    client.set_time(MON + 12 * DAY)
+    sim = client.post(f"/api/tests/{test['id']}/simulation/start?all_skills=true", headers=auth(KID)).json()
+    early = client.post(f"/api/attempts/{sim['id']}/retry/start", headers=auth(KID))
+    assert early.status_code == 409                                                       # not handed in yet
+    done = answer_all(client, bank, sim, [True] * 8 + [False] * 4)
+    assert done["grade"] == 67 and len(done["missed"]) == 4
+    rnd = client.post(f"/api/attempts/{sim['id']}/retry/start", headers=auth(KID)).json()
+    assert rnd["kind"] == "mistakes_round" and rnd["total"] == 4 and rnd["source"]["test_id"] == test["id"]
+    assert [q["key"] for q in store.get_attempt(rnd["id"])["questions"]] == [q["key"] for q in sim["questions"][8:]]
+    assert '"correct"' not in json.dumps(rnd)
+    assert client.post(f"/api/attempts/{sim['id']}/retry/start", headers=auth(KID)).json()["id"] == rnd["id"]    # an open one resumes
+    for ok in [True, False, True, True]:
+        key = rnd["question"]["key"]
+        got = client.post(f"/api/rounds/{rnd['id']}/answer", headers=auth(KID), json={"key": key, "choice": right_index(bank, key, ok)})
+        assert got.status_code == 200 and got.json()["correct"] is ok
+        rnd = got.json()["round"]
+    assert rnd["state"] == "done" and rnd["result"]["right"] == 3 and rnd["result"]["stars"] is None and len(rnd["result"]["missed"]) == 1
+    assert store.get_attempt(sim["id"])["grade"] == 67                                    # the simulation's grade stays
+    assert client.post(f"/api/attempts/{sim['id']}/retry/start", headers=auth(KID)).json()["id"] != rnd["id"]    # again: a new round
+    assert client.post(f"/api/attempts/{sim['id']}/retry/start", headers=auth(TEACHER)).status_code == 404       # only the student's own
+
+
+def test_a_test_with_no_mistakes_has_nothing_to_retry(world):
+    client, store, lessons = world
+    test = set_test(client, lessons, days=14, questions=6).json()
+    started(client, store, lessons)
+    done = answer_all(client, client.app.state.bank, start_ex(client, test["id"]).json(), [True] * 6)
+    assert client.post(f"/api/attempts/{done['id']}/retry/start", headers=auth(KID)).status_code == 409