feat: implement server-side grading for unit quizzes

- Added `math_quiz_sittings` table to store quiz sittings on the server.
- Introduced functions `math_quiz_sitting_json` and `math_quiz_action` for handling quiz data.
- Updated `sitting_view` to compute grades based on stored attempts and checks.
- Enhanced tests to validate the new grading logic and ensure correct behavior of quiz sittings.
- Modified existing tests to reflect changes in quiz grading and reporting.

README.md

@@ -78,7 +78,9 @@ For rollback, turn `MATHLY_ANSWER_SCANS_ENABLED` off and restart; preserve the n
 
 ### Class teacher
 
-Each class has one teacher, chosen from its students in the class editor (**ניהול → כיתות → עריכה → מורה הכיתה**). That account gets a **הכיתה שלי** button that opens the class report: for every other student, the skills finished in the class's units, the mistakes that keep coming back, the **בוחן מסכם** grade per unit, and the **מבחני תרגול** results, plus the mistakes most common across the class. Managers open the same report from a class's card (**מעקב**). The report reads the students' saved progress (`math_progress`) and Supabase's user list with the server's secret key; it needs no new migration. A student's numbers show up once they have signed in and practised on the current version of the app.
+Each class has one teacher, chosen from its students in the class editor (**ניהול → כיתות → עריכה → מורה הכיתה**). That account gets a **הכיתה שלי** button that opens the class report: for every other student, the skills finished in the class's units, the mistakes that keep coming back, the **בוחן מסכם** grade per unit, and the **מבחני תרגול** results, plus the mistakes most common across the class. Managers open the same report from a class's card (**מעקב**). The report reads the students' saved progress (`math_progress`) and Supabase's user list with the server's secret key. A student's numbers show up once they have signed in and practised on the current version of the app.
+
+**What the report can be trusted for.** Progress is kept by the student's device, so skills finished, gold stars and practice-exam results are only what the device reports; the report labels them **נתוני תרגול מהמכשיר**. The **בוחן מסכם** grade is different: when a student hands a quiz in, the server stores the sitting (`math_quiz_sittings`) and works the grade out itself from the stored checks and the quiz's points (`app/quiz_grades.py`), so a score edited in the browser changes nothing. A sitting has no grade while any photographed answer still waits for its check (the report says **ממתין לבדיקה**); a question without a photo earns 0. Submissions from before this was deployed exist only on the student's device and show as **לא מאומת**, with no grade. Apply [the sittings migration](supabase/migrations/20261104120000_math_quiz_sittings.sql) (after the answer-scan and grading migrations) before deploying this code. Without it, handing a quiz in fails with "quiz sittings unavailable" and the report shows no quiz grades.
 
 ### The teacher's AI queue
 

app/answer_routes.py

@@ -14,6 +14,7 @@ from .ai_queue import AiQueue, for_student, may_send
 from .answer_scans import AnswerScans, MAX_IMAGE, ScanError, clean_image, public_result, uuid_text
 from .answer_grading import AnswerGrader
 from .math_photo import PhotoUnavailable
+from .quiz_grades import sitting_view
 from .math_skills import algebra9, question_version, quiz_snapshot
 
 log = logging.getLogger("mathly.answer_routes")
@@ -117,6 +118,27 @@ def install_answer_routes(app, signed_in):
         return reply(call(user, "resume", question_id=f"quiz:{unit['id']}:{index}", question_version=version,
                           snapshot=snapshot, new=body.get("new") is True))
 
+    @app.post("/api/math/quiz-sittings")
+    def submit_sitting(body: dict, user=Depends(student)):
+        """Hands a unit quiz in: the sitting is kept on the server and its grade is worked out there from the checks
+        (app/quiz_grades.py). Sending the same `client_key` again returns the same sitting."""
+        if open_ended_locked():
+            raise ScanError(403, "open_ended_locked")
+        unit = next((u for u in algebra9()["units"] if u["id"] == body.get("unit_id") and "quiz" in u), None)
+        attempts = body.get("attempts")
+        if not unit or not isinstance(attempts, list) or len(attempts) != len(unit["quiz"]["questions"]):
+            raise ScanError(404, "not_found")
+        sitting = app.state.answers.quiz(user, "submit", unit_id=unit["id"], attempt_ids=[uuid_text(a) for a in attempts],
+                                         time_up=body.get("time_up") is True, client_key=uuid_text(body.get("client_key")))
+        return JSONResponse(sitting_view(sitting), headers={"Cache-Control": "no-store"})
+
+    @app.get("/api/math/quiz-sittings")
+    def my_sittings(unit_id: str | None = None, user=Depends(student)):
+        """The student's own sittings (newest first), each with the grade the server worked out."""
+        data = {"unit_id": unit_id} if unit_id else {}
+        views = [sitting_view(s) for s in app.state.answers.quiz(user, "list", **data)]
+        return JSONResponse({"sittings": [v for v in views if v]}, headers={"Cache-Control": "no-store"})
+
     @app.get("/api/math/answer-attempts/{attempt_id}")
     def get_attempt(attempt_id: str, user=Depends(student)):
         return reply(call(user, "get", attempt_id=uuid_text(attempt_id)))

app/answer_scans.py

@@ -146,6 +146,19 @@ class AnswerScans:
         raw = self._request("/rest/v1/rpc/math_grade_action", "POST", json.dumps(body).encode(), "application/json")
         return json.loads(raw)
 
+    def quiz(self, user_id: str | None, action: str, **data):
+        """Unit-quiz sittings (app/quiz_grades.py): submit, list a student's own, or `report` for a set of accounts."""
+        if not self.configured:
+            raise ScanError(503, "answer_storage_unavailable")
+        body = {"p_user": user_id, "p_action": action, "p_data": data}
+        try:
+            raw = self._request("/rest/v1/rpc/math_quiz_action", "POST", json.dumps(body).encode(), "application/json")
+        except ScanError as exc:
+            if exc.code == "answer_storage_unavailable":
+                raise ScanError(503, "quiz_sittings_unavailable") from exc
+            raise
+        return json.loads(raw)
+
     def _request(self, path, method="GET", data=None, content_type=None):
         headers = {"Authorization": "Bearer " + self.auth.secret, "apikey": self.auth.secret,
                    "User-Agent": "mathly/1.0"}
@@ -167,7 +180,7 @@ class AnswerScans:
             if code == "P0001" and message == "grading_limit":
                 raise ScanError(429, message) from exc
             if code == "P0001" and message in {"superseded", "invalid_upload", "upload_in_progress", "confirmation_required",
-                                               "answer_required", "grading_busy", "grading_interrupted"}:
+                                               "answer_required", "grading_busy", "grading_interrupted", "invalid_sitting"}:
                 raise ScanError(409, message) from exc
             raise ScanError(503, "answer_storage_unavailable") from exc
         except (urllib.error.URLError, TimeoutError, OSError) as exc:

app/class_report.py

@@ -4,6 +4,10 @@ A class has one teacher, chosen from its students (`classes.teachers`). That acc
 GET /api/classes/{id}/report: for each other student of the class, the parts of their saved progress
 (app/progress.py) the teacher's page shows. The page works out the rest (stars, mistake patterns) the same way the
 student's own page does.
+
+Progress is kept by the student's device, so everything in it is only what the device reports. The unit quizzes'
+grades are the exception: they come from the server's own record of each sitting (app/quiz_grades.py), and a score
+in the uploaded progress is never passed on.
 """
 from __future__ import annotations
 
@@ -13,7 +17,9 @@ from fastapi import Depends, HTTPException
 from fastapi.responses import JSONResponse
 
 from .access import has_permission
+from .answer_scans import ScanError
 from .auth import AuthUnavailable
+from .quiz_grades import sitting_view
 
 log = logging.getLogger("mathly.class_report")
 TABLE = "/rest/v1/math_progress"
@@ -36,13 +42,31 @@ def report_part(data: dict) -> dict:
         history = state.get("history") if isinstance(state, dict) else None
         sitting = state.get("sitting") if isinstance(state, dict) else None
         unit_quizzes[unit] = {
-            "history": [{k: h.get(k) for k in ("at", "score", "timeUp")} for h in history or [] if isinstance(h, dict)],
+            # no score: the device's copy of a grade is not evidence. `sid` ties a submission to the server's sitting.
+            "history": [{k: h.get(k) for k in ("at", "timeUp", "sid")} for h in history or [] if isinstance(h, dict)],
             "going": bool(isinstance(sitting, dict) and sitting.get("started") and not sitting.get("submitted"))}
     return {"done": obj("done"), "gold": obj("gold"), "days": obj("days"), "missed": obj("missed"),
             "slips": items("slips")[-SLIPS_SENT:], "quizzes": quizzes, "uq": unit_quizzes,
             "updated": data.get("updated")}
 
 
+def server_sittings(app, ids: dict[str, str]):
+    """The students' unit-quiz sittings with the server's grades, by email. None when they cannot be read: the report
+    then shows no quiz grades, rather than the device's."""
+    try:
+        raw = app.state.answers.quiz(None, "report", users=list(ids.values())) if ids else []
+    except ScanError as exc:
+        log.warning("quiz sittings not read: %s", exc.code)
+        return None
+    email_of = {user_id: email for email, user_id in ids.items()}
+    out: dict[str, list] = {email: [] for email in ids}
+    for sitting in raw:
+        view = sitting_view(sitting)
+        if view and sitting.get("user_id") in email_of:
+            out[email_of[sitting["user_id"]]].append(view)
+    return out
+
+
 def install_class_report_routes(app, signed_in, units_of):
     def class_of(class_id: int, user) -> dict:
         try:
@@ -72,12 +96,14 @@ def install_class_report_routes(app, signed_in, units_of):
             log.error("class report failed: %s", exc)
             raise HTTPException(503, "report_unavailable") from exc
         by_id = {r["user_id"]: r for r in rows or []}
+        sittings = server_sittings(app, ids)
         out = []
         for email in students:
             saved = by_id.get(ids.get(email, ""))
             data = saved.get("data") if saved else None
             out.append({"email": email, "signed_in": email in ids,
                         "progress": report_part(data) if isinstance(data, dict) else None,
-                        "saved_at": saved.get("updated_at") if saved else None})
+                        "saved_at": saved.get("updated_at") if saved else None,
+                        "quiz_sittings": None if sittings is None else sittings.get(email, [])})
         return JSONResponse({"class": {"id": row["id"], "name": row["name"], "lessons": units_of(row)},
                              "students": out}, headers={"Cache-Control": "no-store"})

app/quiz_grades.py

@@ -0,0 +1,40 @@
+"""Unit-quiz grades, worked out on the server from the stored checks.
+
+A sitting (Supabase `math_quiz_sittings`, written when the student hands the quiz in) lists its attempts in question
+order. The database says, for each, whether it has a saved photo and what its latest check is; the quiz's points per
+question are in app/math_algebra9.json. The grade is computed here every time it is read, so it follows a check that
+finishes later (for example one the teacher sends from the AI queue), and nothing the student's device uploads can
+change it. Both the student's result screen and the class report use `sitting_view`.
+"""
+from __future__ import annotations
+
+from .math_skills import algebra9
+
+
+def question_result(points: int, attempt: dict | None) -> dict:
+    """One question of a sitting: its points, what it earned (None while its check is open) and why."""
+    if not attempt or not attempt.get("has_photo"):
+        return {"points": points, "earned": 0, "state": "missing"}
+    score = attempt.get("score")
+    if attempt.get("grade_state") == "completed" and type(score) is int and 0 <= score <= 100:
+        return {"points": points, "earned": int(points * score / 100 + 0.5), "state": "checked",
+                "verdict": attempt.get("verdict")}
+    if attempt.get("grade_state") == "completed":   # a check without a score: unreadable, or needs a teacher's look
+        return {"points": points, "earned": None, "state": attempt.get("verdict") or "waiting"}
+    return {"points": points, "earned": None, "state": "waiting"}
+
+
+def sitting_view(sitting: dict, units: list[dict] | None = None) -> dict | None:
+    """A stored sitting as the page reads it: when, the grade (None while an answer is open), the open count and
+    each question's points. None for a unit that has no quiz."""
+    unit = next((u for u in units or algebra9()["units"] if u["id"] == sitting.get("unit_id")), None)
+    if not unit or "quiz" not in unit:
+        return None
+    attempts = sitting.get("attempts") or []
+    questions = [question_result(q["points"], attempts[i] if i < len(attempts) else None)
+                 for i, q in enumerate(unit["quiz"]["questions"])]
+    open_count = sum(1 for q in questions if q["earned"] is None)
+    return {"id": sitting["id"], "unit_id": unit["id"], "submitted_at": sitting.get("submitted_at"),
+            "time_up": bool(sitting.get("time_up")), "attempts": [a.get("attempt_id") for a in attempts],
+            "questions": questions, "open": open_count,
+            "grade": None if open_count else sum(q["earned"] for q in questions)}

openspec/changes/add-server-quiz-grades/tasks.md

@@ -2,20 +2,20 @@
 
 ## 1. Sitting storage
 
-- [ ] 1.1 Add migration `supabase/migrations/<ts>_math_quiz_sittings.sql`: table `math_quiz_sittings` (id, user_id → auth.users on delete cascade, unit_id, attempt_ids uuid[], submitted_at, time_up, client_key, unique(user_id, client_key)), RLS on, service_role only. Verify it applies cleanly to the disposable test PostgreSQL used by `tests/scan_support.py`.
-- [ ] 1.2 Add the grade function (points × check score, 0 for a missing photo, open while any photographed answer lacks a scored completed check). Verify with unit tests covering all-checked, waiting, unreadable, needs_review and missing-photo cases.
+- [x] 1.1 Add migration `supabase/migrations/<ts>_math_quiz_sittings.sql`: table `math_quiz_sittings` (id, user_id → auth.users on delete cascade, unit_id, attempt_ids uuid[], submitted_at, time_up, client_key, unique(user_id, client_key)), RLS on, service_role only. Verify it applies cleanly to the disposable test PostgreSQL used by `tests/scan_support.py`.
+- [x] 1.2 Add the grade function (points × check score, 0 for a missing photo, open while any photographed answer lacks a scored completed check). Verify with unit tests covering all-checked, waiting, unreadable, needs_review and missing-photo cases.
 
 ## 2. Student routes
 
-- [ ] 2.1 Add `POST /api/math/quiz-sittings` with ownership, question-position checks and an idempotent `client_key`. Verify with tests in `tests/test_unit_quiz.py`: success, another student's attempt, wrong question order, repeated submit returning the same id.
-- [ ] 2.2 Add `GET /api/math/quiz-sittings?unit_id=` returning the grade, open count and per-question points. Verify with a test where one check completes after submission and the grade appears.
-- [ ] 2.3 In `static/math.js`, make `uqSubmit` post the sitting (with retry on next open when it failed) and make `uqResult` show the server grade. Verify with a browser test where the device progress has a forged score and the screen shows the server's.
+- [x] 2.1 Add `POST /api/math/quiz-sittings` with ownership, question-position checks and an idempotent `client_key`. Verify with tests in `tests/test_unit_quiz.py`: success, another student's attempt, wrong question order, repeated submit returning the same id.
+- [x] 2.2 Add `GET /api/math/quiz-sittings?unit_id=` returning the grade, open count and per-question points. Verify with a test where one check completes after submission and the grade appears.
+- [x] 2.3 In `static/math.js`, make `uqSubmit` post the sitting (with retry on next open when it failed) and make `uqResult` show the server grade. Verify with a browser test where the device progress has a forged score and the screen shows the server's.
 
 ## 3. Class report
 
-- [ ] 3.1 In `app/class_report.py`, load sittings and their grades for the class's students and stop sending `uq` scores from the progress object. Verify in `tests/test_class_report.py` that a forged progress score does not appear and the server grade does.
-- [ ] 3.2 In the report UI, show server grades, "ממתין לבדיקה" for open sittings, "לא מאומת" for old device-only sittings, and the device-data label on the skills and practice-exam sections. Verify with a browser test of the report.
-- [ ] 3.3 Update the teacher tab in `static/guide.js` and the class-teacher and migration sections of `README.md`. Verify `tests/test_guide_browser.py` still passes.
+- [x] 3.1 In `app/class_report.py`, load sittings and their grades for the class's students and stop sending `uq` scores from the progress object. Verify in `tests/test_class_report.py` that a forged progress score does not appear and the server grade does.
+- [x] 3.2 In the report UI, show server grades, "ממתין לבדיקה" for open sittings, "לא מאומת" for old device-only sittings, and the device-data label on the skills and practice-exam sections. Verify with a browser test of the report.
+- [x] 3.3 Update the teacher tab in `static/guide.js` and the class-teacher and migration sections of `README.md`. Verify `tests/test_guide_browser.py` still passes.
 
 ## 4. Integration
 

static/guide.js

@@ -44,7 +44,8 @@ const TEACHER=[
     <ul><li>המיומנויות שסיים ביחידות של הכיתה.</li>
     <li>הטעויות שחוזרות אצלו.</li>
     <li>הציון ב<b>בוחן המסכם</b> של כל יחידה, ותוצאות <b>מבחני התרגול</b>.</li></ul>
-    <p>בראש הדוח מופיעות הטעויות הנפוצות בכל הכיתה, כדי לדעת מה כדאי לחזור עליו בשיעור. הנתונים של תלמיד מופיעים אחרי שנכנס לחשבון ותרגל.</p>`],
+    <p>בראש הדוח מופיעות הטעויות הנפוצות בכל הכיתה, כדי לדעת מה כדאי לחזור עליו בשיעור. הנתונים של תלמיד מופיעים אחרי שנכנס לחשבון ותרגל.</p>
+    <p><b>אילו נתונים אפשר לסמוך עליהם:</b> ציוני הבוחן המסכם מחושבים בשרת מהבדיקות השמורות, והתלמיד לא יכול לשנות אותם. כשעוד לא כל התשובות נבדקו כתוב <b>ממתין לבדיקה</b> ואין ציון. הגשה מלפני העדכון, שהשרת לא שמר, מסומנת <b>לא מאומת</b> וללא ציון. התקדמות במיומנויות ומבחני התרגול מדווחים מהמכשיר של התלמיד, ומסומנים <b>נתוני תרגול מהמכשיר</b>.</p>`],
   ["📷","משאבי שיעור",`<p>במסלול המתמטיקה, לוחצים על שם יחידה (או על <b>📷 משאבים</b> מתחתיה) כדי לפתוח את המשאבים של השיעור.</p>
     <ul><li><b>📷 צילום תמונה</b>: מצלמים תרגיל או הסבר מהלוח או מהספר.</li>
     <li>מסמנים את הסוג: <b>תרגיל חדש</b>, <b>הסבר תיאורטי</b> או <b>אחר</b>, ואפשר לכתוב לאיזה נושא הוא שייך.</li>

static/math.css

@@ -809,3 +809,4 @@ body{--keyboard-zindex:3000}
 .mx-error-details[open]>summary{border-color:var(--sumac)}
 .mx-error-details p{margin:8px 0 0}
 .mx-error-details code{display:block;margin-top:8px;padding:8px 10px;border-radius:8px;background:var(--surface-2);color:var(--muted);font-size:12px;white-space:pre-wrap;overflow-wrap:anywhere;text-align:left}
+.mx-device{font-weight:400;color:var(--muted)}

static/math.js

@@ -819,7 +819,7 @@ async function uqJson(url,options={}){
   return d;
 }
 const uqPost=(url,body={})=>uqJson(url,{method:"POST",headers:{"Content-Type":"application/json"},body:JSON.stringify(body)});
-const UQ_ERRORS={question_changed:"הבוחן עודכן. רעננו את העמוד והתחילו מחדש.",image_too_large:"התמונה גדולה מדי. צלמו שוב.",invalid_image:"לא ניתן לקרוא את התמונה. צלמו שוב.",
+const UQ_ERRORS={quiz_sittings_unavailable:"שמירת ההגשה אינה זמינה כרגע. נסו שוב מאוחר יותר.",invalid_sitting:"ההגשה לא תואמת לתשובות השמורות. פתחו את הבוחן מחדש.",question_changed:"הבוחן עודכן. רעננו את העמוד והתחילו מחדש.",image_too_large:"התמונה גדולה מדי. צלמו שוב.",invalid_image:"לא ניתן לקרוא את התמונה. צלמו שוב.",
   unsupported_image:"בחרו תמונת JPEG, PNG או WebP.",answer_storage_unavailable:"שמירת תשובות אינה זמינה כרגע.",grading_unavailable:"הבדיקה האוטומטית אינה זמינה כרגע.",
   grading_failed:"הבדיקה נכשלה. התמונה נשמרה; אפשר לנסות שוב.",grading_limit:"הגעתם למכסת הבדיקות היומית. נסו שוב מחר.",grading_busy:"כבר מתבצעות בדיקות. נסו שוב בעוד רגע.",
   upload_in_progress:"העלאה כבר מתבצעת. רגע…",open_ended_locked:"בוחנים פתוחים סגורים כרגע באתר.",sign_in_required:"יש להיכנס לחשבון."};
@@ -973,10 +973,20 @@ function uqSubmit(timeUp=false){
     return;
   }
   sit.submitted=Date.now();
-  const st=uqState(uid); st.history.push({at:new Date().toISOString(),attempts:sit.attempts.slice(),score:null,timeUp}); st.history=st.history.slice(-10);
+  const st=uqState(uid); st.history.push({at:new Date().toISOString(),attempts:sit.attempts.slice(),score:null,timeUp,ck:crypto.randomUUID()}); st.history=st.history.slice(-10);
   save(); draw();
   uqResult(uid,st.history.length-1,true);
 }
+/* The grade of a sitting is worked out by the server from the stored checks (app/quiz_grades.py); the score kept in
+   this device's progress is only a copy of it. A sitting is handed in on the server once (`sid`); the same key makes
+   a retry after a lost response the same sitting. */
+async function uqSend(uid,entry){
+  if(entry.sid) return entry.sid;
+  if(!entry.ck){ entry.ck=crypto.randomUUID(); save(); }
+  entry.sid=(await uqPost("/api/math/quiz-sittings",{unit_id:uid,attempts:entry.attempts,time_up:!!entry.timeUp,client_key:entry.ck})).id;
+  save(); return entry.sid;
+}
+async function uqSitting(uid,sid){ return (await uqJson(`/api/math/quiz-sittings?unit_id=${encodeURIComponent(uid)}`)).sittings.find(x=>x.id===sid)||null; }
 // the report: each answer is checked now (once), then points per question, feedback and the solution
 async function uqResult(uid,h,check=false){
   const u=G.units.find(x=>x.id===uid), st=uqState(uid), entry=st.history[h];
@@ -989,6 +999,9 @@ async function uqResult(uid,h,check=false){
         <small class="mx-src" aria-live="polite">${CFG.aiDirect===false?"שולחים את התשובות לבדיקת המורה":"בודקים את התשובות, זה לוקח כחצי דקה לשאלה"}</small></div>
         <button class="mx-x" data-act="close" aria-label="סגירה">✕</button></div><div class="mx-uq-report"></div></div>`;
   sheet.hidden=false; sheet.querySelector(".mx-x").focus({preventScroll:true});
+  let sendError="";
+  try{ await uqSend(uid,entry); }catch(e){ sendError=e.message; }
+  if(UQ?.uid!==uid) return;
   const results=[];
   for(let i=0;i<n;i++){
     let r=null;
@@ -1004,16 +1017,17 @@ async function uqResult(uid,h,check=false){
     if(UQ?.uid!==uid) return;
     results.push(r);
   }
-  // points: a checked answer earns its share; a missing one 0; one not checked yet leaves the total open
-  let earned=0, open=0;
+  // points: the server's, per question (a checked answer earns its share; a missing one 0; one not checked yet leaves the total open)
+  let sitting=null;
+  if(entry.sid){ try{ sitting=await uqSitting(uid,entry.sid); }catch(e){ sendError||=e.message; } }
+  if(UQ?.uid!==uid) return;
   const rows=u.quiz.questions.map((q,i)=>{
-    const r=results[i], g=r?.grading, a=g?.state==="completed"?g.result:null;
-    let pts=null, say="";
-    if(!r?.attachment) { pts=0; say="לא צולמה תשובה"; }
-    else if(a&&a.score!=null){ pts=Math.round(q.points*a.score/100); say={correct:"נכון ומלא",partial:"נכון בחלקו",incorrect:"לא נכון"}[a.verdict]||""; }
-    else { open++; const req=a?null:r.ai_request;
+    const r=results[i], g=r?.grading, a=g?.state==="completed"?g.result:null, pts=sitting?sitting.questions[i].earned:null;
+    let say="";
+    if(!r?.attachment) say="לא צולמה תשובה";
+    else if(a&&a.score!=null) say={correct:"נכון ומלא",partial:"נכון בחלקו",incorrect:"לא נכון"}[a.verdict]||"";
+    else { const req=a?null:r.ai_request;
       say=req&&["pending","sending","failed"].includes(req.state)?"מחכה למורה שיאשר את הבדיקה":req?.state==="declined"?`המורה לא אישר את הבדיקה${req.note?`: ${req.note}`:""}`:a?.verdict==="unreadable"?"לא הצלחנו לקרוא את התמונה":a?.verdict==="needs_review"?"נדרשת בדיקה של מורה":r.error||(!r.grading_available?"הבדיקה האוטומטית אינה זמינה כרגע":"עוד לא נבדקה"); }
-    if(pts!=null) earned+=pts;
     return `<li class="mx-uq-q"><div class="mx-uq-qhead"><b>שאלה ${i+1}</b><span>${pts==null?"–":pts}/${q.points} נק׳</span></div>
       <p class="mx-uq-text">${fmt(q.question).replace(/\n/g,"<br>")}</p>
       ${UQ.images[i]?`<img class="mx-uq-img" alt="התשובה שלכם לשאלה ${i+1}" src="${UQ.images[i]}">`:""}
@@ -1022,12 +1036,14 @@ async function uqResult(uid,h,check=false){
       ${a?.solution?`<details><summary>הפתרון המלא</summary><p class="mx-grade-solution">${fmtLoose(a.solution)}</p></details>`:""}
       ${r?.attachment&&!a&&r.grading_available&&!["pending","sending","failed"].includes(r.ai_request?.state)?`<button class="mx-btn" data-uq-result="${uid}:${h}:check">${CFG.aiDirect===false?"שליחה מחדש למורה":"בדיקה נוספת"}</button>`:""}</li>`;
   });
-  entry.score=open?null:earned; save(); draw();
-  const total=open?`${earned} נקודות עד עכשיו · ${open===1?"שאלה אחת לא נבדקה":`${open} שאלות לא נבדקו`}`:`${earned}/100`;
+  const earned=sitting?sitting.questions.reduce((sum,x)=>sum+(x.earned||0),0):0, open=sitting?sitting.open:n;
+  entry.score=sitting?.grade??null; save(); draw();
+  const total=!sitting?"ההגשה לא נשמרה בשרת":open?`${earned} נקודות עד עכשיו · ${open===1?"שאלה אחת לא נבדקה":`${open} שאלות לא נבדקו`}`:`${earned}/100`;
   sheet.querySelector("#mxTitle").textContent=`בוחן מסכם: ${total}`;
   sheet.querySelector(".mx-src").textContent=`הוגש ${new Date(entry.at).toLocaleString("he-IL",{dateStyle:"short",timeStyle:"short"})}${entry.timeUp?" · הוגש כשהזמן נגמר":""}`;
   const weak=u.quiz.questions.map((q,i)=>i).filter(i=>{ const a=results[i]?.grading?.result; return !results[i]?.attachment||(a&&a.score!=null&&a.score<70); });
   sheet.querySelector(".mx-uq-report").innerHTML=`<ol class="mx-uq-qs">${rows.join("")}</ol>
+    ${sendError&&!sitting?`<p class="mx-note mx-quiz-warn">${esc(sendError)} <button class="mx-btn" data-uq-result="${uid}:${h}:check">ניסיון נוסף</button></p>`:""}
     ${weak.length&&!open?`<p class="mx-note">כדאי לחזור על ${weak.map(i=>`שאלה ${i+1}`).join(", ")} ולתרגל את המיומנויות של היחידה במסלול לפני הבוחן הבא.</p>`:""}
     <p class="mx-small">הבדיקה אוטומטית באמצעות AI: בדקו שהיא תואמת למה שכתבתם, ואם משהו נראה לא נכון, הראו למורה.</p>
     <div class="mx-quiz-nav"><button class="mx-btn" data-uquiz="${uid}">לבוחן</button><button class="mx-btn solid" data-act="close">חזרה למסלול</button></div>`;
@@ -1443,11 +1459,17 @@ function reportOf(student,units){
     gold:ids.filter(id=>p.gold?.[id]).length,stuck:ids.filter(id=>!p.done?.[id]&&(p.missed?.[id]||[]).length).map(id=>BY[id])}; });
   const n=perUnit.reduce((s,x)=>s+x.n,0), done=perUnit.reduce((s,x)=>s+x.done,0);
   const {recurring}=Sky.patterns(p,G.mistakes);
-  const quizzes=units.filter(u=>u.quiz).map(u=>({u,st:p.uq?.[u.id]||{history:[]}}));
-  const scores=quizzes.map(x=>x.st.history.filter(h=>h.score!=null).at(-1)?.score).filter(s=>s!=null);
+  // the unit quizzes' grades are the server's (student.quiz_sittings, oldest first; null: they could not be read); the
+  // device's own history only says which submissions the server has not seen ("unverified")
+  const sittings=student.quiz_sittings;
+  const quizzes=units.filter(u=>u.quiz).map(u=>{
+    const st=p.uq?.[u.id]||{history:[]}, mine=(sittings||[]).filter(x=>x.unit_id===u.id), known=new Set(mine.map(x=>x.id));
+    return {u,st,last:mine.at(-1)||null,count:mine.length,unverified:st.history.filter(h=>!h.sid||!known.has(h.sid)).length};
+  });
+  const scores=quizzes.map(x=>x.last?.grade).filter(g=>g!=null);
   const exams=(p.quizzes||[]).slice().reverse();
   const days=Object.keys(p.days||{}).sort(), last=[p.updated?new Date(+p.updated):null,days.length?new Date(days.at(-1)):null].filter(d=>d&&!isNaN(d)).sort((a,b)=>b-a)[0];
-  return {perUnit,n,done,recurring:recurring.filter(x=>G.mistakes[x.m]),quizzes,quizAvg:scores.length?Math.round(scores.reduce((a,b)=>a+b,0)/scores.length):null,exams,last};
+  return {perUnit,n,done,recurring:recurring.filter(x=>G.mistakes[x.m]),quizzes,quizzesKnown:sittings!=null,quizAvg:scores.length?Math.round(scores.reduce((a,b)=>a+b,0)/scores.length):null,exams,last};
 }
 async function classReport(id){
   const mine=teachClasses(), classId=id??REPORT?.id??mine[0]?.id; if(classId==null) return;
@@ -1479,6 +1501,7 @@ function drawReport(){
   const top=Object.entries(common).sort((a,b)=>b[1].length-a[1].length).slice(0,5);
   const name=email=>email.split("@")[0];
   const quizUnits=units.filter(u=>u.quiz);
+  const DEVICE_NOTE=' <small class="mx-device" title="המכשיר של התלמיד מדווח את הנתונים האלה, והשרת לא בודק אותם">· נתוני תרגול מהמכשיר</small>';
   const grade=score=>score==null?"–":`${score}`;
   const tone=score=>score==null?"":score>=80?" good":score>=55?" mid":" low";
   const card=({s,r})=>{
@@ -1486,17 +1509,19 @@ function drawReport(){
     const exam=r.exams[0];
     return `<details class="mx-report-student"><summary><b dir="ltr">${esc(name(s.email))}</b>
         <span class="mx-report-prog"><span class="mx-meter" aria-hidden="true"><i style="width:${pct(r.done,r.n)}%"></i></span><small>${r.done}/${r.n} מיומנויות</small></span>
-        <span class="mx-report-chip${tone(r.quizAvg)}" title="ממוצע בחנים מסכמים">בוחן ${grade(r.quizAvg)}</span>
-        <span class="mx-report-chip${tone(exam?pct(exam.right,exam.n):null)}" title="מבחן התרגול האחרון">תרגול ${exam?`${exam.right}/${exam.n}`:"–"}</span>
+        <span class="mx-report-chip${tone(r.quizAvg)}" title="ממוצע בחנים מסכמים שנבדקו">בוחן ${grade(r.quizAvg)}</span>
+        <span class="mx-report-chip${tone(exam?pct(exam.right,exam.n):null)}" title="מבחן התרגול האחרון (נתוני מכשיר)">תרגול ${exam?`${exam.right}/${exam.n}`:"–"}</span>
         ${r.recurring.length?`<span class="mx-report-chip low">${r.recurring.length} קשיים</span>`:""}</summary>
       <div class="mx-report-body">
         <p class="mx-small"><span dir="ltr">${esc(s.email)}</span>${r.last?` · פעילות אחרונה ${r.last.toLocaleDateString("he-IL")}`:""}</p>
-        <section><h5>התקדמות ביחידות</h5><div class="mx-quiz-units-score">${r.perUnit.map(x=>`<div><span>${esc(x.u.name)}${x.gold?` <small>· ${x.gold} זהב</small>`:""}</span><b>${x.done}/${x.n}</b><span class="mx-meter" aria-hidden="true"><i style="width:${pct(x.done,x.n)}%"></i></span></div>`).join("")}</div></section>
-        <section><h5>קשיים</h5>${r.recurring.length?`<ul class="mx-report-list">${r.recurring.map(x=>`<li><b>${fmt(G.mistakes[x.m].name)}</b> <small>${x.n} פעמים ב־${x.skills.length} מיומנויות, לאחרונה ${shortDate(x.last)}</small>${BY[x.practise]?`<small>לחזק: ${fmt(BY[x.practise].name)}</small>`:""}</li>`).join("")}</ul>`:'<p class="mx-small">אין טעויות שחוזרות לאחרונה.</p>'}
+        <section><h5>התקדמות ביחידות${DEVICE_NOTE}</h5><div class="mx-quiz-units-score">${r.perUnit.map(x=>`<div><span>${esc(x.u.name)}${x.gold?` <small>· ${x.gold} זהב</small>`:""}</span><b>${x.done}/${x.n}</b><span class="mx-meter" aria-hidden="true"><i style="width:${pct(x.done,x.n)}%"></i></span></div>`).join("")}</div></section>
+        <section><h5>קשיים${DEVICE_NOTE}</h5>${r.recurring.length?`<ul class="mx-report-list">${r.recurring.map(x=>`<li><b>${fmt(G.mistakes[x.m].name)}</b> <small>${x.n} פעמים ב־${x.skills.length} מיומנויות, לאחרונה ${shortDate(x.last)}</small>${BY[x.practise]?`<small>לחזק: ${fmt(BY[x.practise].name)}</small>`:""}</li>`).join("")}</ul>`:'<p class="mx-small">אין טעויות שחוזרות לאחרונה.</p>'}
           ${r.perUnit.some(x=>x.stuck.length)?`<p class="mx-small">מיומנויות עם שאלות שעוד לא נפתרו: ${r.perUnit.flatMap(x=>x.stuck).slice(0,8).map(sk=>fmt(sk.name)).join(" · ")}</p>`:""}</section>
-        <section><h5>בוחן מסכם</h5>${quizUnits.length?`<table class="mx-report-table"><thead><tr><th>יחידה</th><th>ציון אחרון</th><th>הגשות</th><th>תאריך</th></tr></thead><tbody>${r.quizzes.map(({u,st})=>{ const h=st.history.at(-1);
-            return `<tr><td>${esc(u.name)}</td><td class="mx-report-grade${tone(h?.score)}">${st.going?"בתהליך":h?(h.score==null?"ממתין לבדיקה":`${h.score}/100`):"–"}</td><td>${st.history.length||"–"}</td><td>${h?shortDate(h.at):"–"}</td></tr>`; }).join("")}</tbody></table>`:'<p class="mx-small">ליחידות של הכיתה אין בוחן מסכם.</p>'}</section>
-        <section><h5>מבחני תרגול</h5>${r.exams.length?`<table class="mx-report-table"><thead><tr><th>תאריך</th><th>ציון</th><th>תשובות נכונות</th><th>זמן</th></tr></thead><tbody>${r.exams.slice(0,10).map(q=>`<tr><td>${shortDate(q.at)}</td><td class="mx-report-grade${tone(pct(q.right,q.n))}">${pct(q.right,q.n)}</td><td>${q.right}/${q.n}</td><td>${q.ms?`${Math.round(q.ms/60000)} דק׳`:"–"}</td></tr>`).join("")}</tbody></table>`:'<p class="mx-small">עוד לא נעשו מבחני תרגול.</p>'}</section>
+        <section><h5>בוחן מסכם</h5>${quizUnits.length?`<table class="mx-report-table"><thead><tr><th>יחידה</th><th>ציון אחרון</th><th>הגשות</th><th>תאריך</th></tr></thead><tbody>${r.quizzes.map(({u,st,last,count,unverified})=>{
+            const cell=st.going?"בתהליך":!r.quizzesKnown?"לא זמין":last?(last.grade==null?"ממתין לבדיקה":`${last.grade}/100`):unverified?"לא מאומת":"–";
+            const subs=`${count||(unverified?"":"–")}${unverified&&r.quizzesKnown?`${count?" ":""}<small>(${unverified} לא מאומתות)</small>`:""}`;
+            return `<tr><td>${esc(u.name)}</td><td class="mx-report-grade${tone(last?.grade)}">${cell}</td><td>${subs}</td><td>${last?shortDate(last.submitted_at):"–"}</td></tr>`; }).join("")}</tbody></table>`:'<p class="mx-small">ליחידות של הכיתה אין בוחן מסכם.</p>'}</section>
+        <section><h5>מבחני תרגול${DEVICE_NOTE}</h5>${r.exams.length?`<table class="mx-report-table"><thead><tr><th>תאריך</th><th>ציון</th><th>תשובות נכונות</th><th>זמן</th></tr></thead><tbody>${r.exams.slice(0,10).map(q=>`<tr><td>${shortDate(q.at)}</td><td class="mx-report-grade${tone(pct(q.right,q.n))}">${pct(q.right,q.n)}</td><td>${q.right}/${q.n}</td><td>${q.ms?`${Math.round(q.ms/60000)} דק׳`:"–"}</td></tr>`).join("")}</tbody></table>`:'<p class="mx-small">עוד לא נעשו מבחני תרגול.</p>'}</section>
       </div></details>`;
   };
   sheet.querySelector(".mx-report").innerHTML=`

supabase/migrations/20261104120000_math_quiz_sittings.sql

@@ -0,0 +1,82 @@
+-- Unit-quiz sittings kept on the server (app/quiz_grades.py), so a quiz grade comes from the stored checks and not
+-- from the student's device. Additive: one new table and two functions; nothing existing changes.
+-- Apply after the answer-scan and answer-grading migrations: the functions read their tables.
+begin;
+create table public.math_quiz_sittings (
+  id uuid primary key default gen_random_uuid(),
+  user_id uuid not null references auth.users(id) on delete cascade,
+  unit_id text not null,
+  attempt_ids uuid[] not null check (cardinality(attempt_ids) between 1 and 20),
+  submitted_at timestamptz not null default now(),
+  time_up boolean not null default false,
+  client_key uuid not null,
+  unique (user_id, client_key)
+);
+create index math_quiz_sittings_user on public.math_quiz_sittings(user_id, unit_id, submitted_at desc);
+alter table public.math_quiz_sittings enable row level security;
+revoke all on public.math_quiz_sittings from public, anon, authenticated;
+grant all on public.math_quiz_sittings to service_role;
+
+-- A sitting with what its grade is computed from: for each attempt in question order, whether it has a saved photo
+-- and its latest check (state, score, verdict). The points per question are in the app's data, not here.
+create function public.math_quiz_sitting_json(p_id uuid) returns jsonb
+language sql stable security invoker set search_path='' as $$
+  select jsonb_build_object('id', s.id, 'user_id', s.user_id, 'unit_id', s.unit_id,
+    'submitted_at', s.submitted_at, 'time_up', s.time_up,
+    'attempts', (select coalesce(jsonb_agg(jsonb_build_object(
+        'attempt_id', x.aid, 'question_id', a.question_id, 'has_photo', att.id is not null,
+        'grade_state', g.state, 'score', g.result->'score', 'verdict', g.result->>'verdict') order by x.ord), '[]'::jsonb)
+      from unnest(s.attempt_ids) with ordinality as x(aid, ord)
+      left join public.math_question_attempts a on a.id = x.aid
+      left join public.math_answer_attachments att on att.attempt_id = x.aid
+      left join lateral (select state, result from public.math_answer_grades
+        where attempt_id = x.aid order by created_at desc, id desc limit 1) g on true))
+  from public.math_quiz_sittings s where s.id = p_id
+$$;
+
+create function public.math_quiz_action(p_user uuid, p_action text, p_data jsonb default '{}')
+returns jsonb language plpgsql security invoker set search_path='' as $$
+declare
+  s public.math_quiz_sittings;
+  ids uuid[];
+  bad int;
+begin
+  if p_action = 'report' then   -- the class report: the latest sittings of these accounts
+    return coalesce((select jsonb_agg(public.math_quiz_sitting_json(r.id) order by r.submitted_at) from (
+      select q.id, q.submitted_at, row_number() over (partition by q.user_id, q.unit_id
+                                                      order by q.submitted_at desc, q.id desc) as rn
+      from public.math_quiz_sittings q
+      where q.user_id in (select t.x::uuid from jsonb_array_elements_text(p_data->'users') as t(x))) r
+      where r.rn <= 10), '[]'::jsonb);
+  end if;
+  if p_user is null then raise exception 'not_found' using errcode = 'P0002'; end if;
+  if p_action = 'list' then
+    return coalesce((select jsonb_agg(public.math_quiz_sitting_json(r.id) order by r.submitted_at desc) from (
+      select q.id, q.submitted_at from public.math_quiz_sittings q
+      where q.user_id = p_user and (p_data->>'unit_id' is null or q.unit_id = p_data->>'unit_id')
+      order by q.submitted_at desc, q.id desc limit 10) r), '[]'::jsonb);
+  elsif p_action = 'submit' then
+    -- the same submit again (a lost response) is the same sitting
+    select * into s from public.math_quiz_sittings
+      where user_id = p_user and client_key = (p_data->>'client_key')::uuid;
+    if s.id is not null then return public.math_quiz_sitting_json(s.id); end if;
+    ids := array(select t.x::uuid from jsonb_array_elements_text(p_data->'attempt_ids') with ordinality as t(x, o) order by t.o);
+    -- every attempt is the student's own, for the quiz question at its position
+    select count(*) into bad from unnest(ids) with ordinality as x(aid, o)
+      left join public.math_question_attempts a on a.id = x.aid and a.user_id = p_user
+      where a.id is null or a.question_id <> 'quiz:' || (p_data->>'unit_id') || ':' || (x.o - 1);
+    if bad > 0 or exists(select 1 from public.math_quiz_sittings where user_id = p_user and attempt_ids && ids) then
+      raise exception 'invalid_sitting' using errcode = 'P0001';
+    end if;
+    insert into public.math_quiz_sittings(user_id, unit_id, attempt_ids, time_up, client_key)
+      values (p_user, p_data->>'unit_id', ids, coalesce((p_data->>'time_up')::boolean, false), (p_data->>'client_key')::uuid)
+      returning * into s;
+    return public.math_quiz_sitting_json(s.id);
+  end if;
+  raise exception 'invalid_action';
+end $$;
+revoke all on function public.math_quiz_sitting_json(uuid) from public, anon, authenticated;
+revoke all on function public.math_quiz_action(uuid, text, jsonb) from public, anon, authenticated;
+grant execute on function public.math_quiz_sitting_json(uuid) to service_role;
+grant execute on function public.math_quiz_action(uuid, text, jsonb) to service_role;
+commit;

tests/scan_support.py

@@ -68,6 +68,9 @@ class DatabaseAnswers(AnswerScans):
     def grade(self, user_id, action, **data):
         return self.rpc('math_grade_action', user_id, action, data)
 
+    def quiz(self, user_id, action, **data):
+        return self.rpc('math_quiz_action', user_id, action, data)
+
     def rpc(self, name, user_id, action, data):
         import psycopg
         if self.fail_finalize and action == 'finalize':
@@ -126,6 +129,8 @@ def answer_store(postgres_server, tmp_path):
             if migration.name.endswith('_math_answer_scans.sql'):
                 continue
             c.execute(migration.read_text())
+        for migration in sorted(Path('supabase/migrations').glob('*_math_quiz_sittings.sql')):
+            c.execute(migration.read_text())
         c.execute('insert into auth.users values(%s),(%s)', (OWNER, OTHER))
     yield store
     with psycopg.connect(postgres_server.get_uri(), autocommit=True) as c:

tests/test_ai_queue.py

@@ -349,3 +349,67 @@ def test_api_errors_are_named(status, message, reason):
     got, detail = failure_reason(exc)
     assert got == reason and str(status) in detail and message[:20] in detail
     assert failure_reason(anthropic.APIConnectionError(request=response.request))[0] == 'no_connection'
+
+
+class ReportAuth(ClassAuth):
+    """ClassAuth that can also answer the class report's two lookups: user ids and (empty) saved progress."""
+    def user_ids(self, emails):
+        return {mail(uid): uid for uid in (OWNER, OTHER) if mail(uid) in emails}
+
+    def _admin(self, path, *args, **kwargs):
+        if path.startswith('/rest/v1/math_progress'):
+            return []
+        return super()._admin(path, *args, **kwargs)
+
+
+def test_a_quiz_checked_through_the_teachers_queue_has_one_grade_for_student_and_teacher(answer_store):
+    """The student hands in a unit quiz; each answer waits in the teacher's queue. The sitting has no grade until the
+    teacher has sent them all, and then the student's screen and the teacher's class report show the same grade."""
+    from app.math_skills import algebra9, question_version, quiz_snapshot
+
+    store = answer_store
+    app = create_app(auth=ReportAuth())
+    app.state.answers, app.state.ai_queue = store, MemoryQueue()
+    scores = {0: 100, 1: 60, 2: 100, 3: 40}
+
+    class ByQuestion:
+        def grade(self, image, snapshot):
+            return validate_assessment(assessment(score=scores[int(snapshot['name'][-1]) - 1]))
+    app.state.answer_grader = ByQuestion()
+    unit = next(u for u in algebra9()['units'] if u['id'] == 't')
+
+    async def check():
+        async with as_user(app, OWNER) as student, as_user(app, OTHER) as teacher:
+            attempts, requests = [], []
+            for index in range(4):
+                version = question_version(quiz_snapshot(unit, index))
+                made = (await student.post('/api/math/quiz-attempts',
+                                           json={'unit': 't', 'index': index, 'question_version': version, 'new': True})).json()
+                aid = made['attempt']['id']
+                scan = (await student.post(f'/api/math/answer-attempts/{aid}/scans', json={'renew': True})).json()['scan']
+                await student.post(f"/api/math/answer-scans/{scan['id']}/confirm")
+                lease = (await student.post(f"/api/math/answer-scans/{scan['id']}/uploads", json={'key': str(uuid.uuid4())})).json()
+                up = await student.post(f"/api/math/answer-scans/{scan['id']}/uploads/{lease['lease_id']}",
+                                        files={'photo': ('a.png', png(), 'image/png')})
+                assert up.status_code == 200
+                attempts.append(aid)
+            handed = (await student.post('/api/math/quiz-sittings', json={'unit_id': 't', 'attempts': attempts,
+                                                                        'client_key': str(uuid.uuid4())})).json()
+            for aid in attempts:   # as the page does after handing in: each answer asks the teacher to check it
+                asked = (await student.post(f'/api/math/answer-attempts/{aid}/grade', json={})).json()
+                requests.append(asked['ai_request']['id'])
+            assert handed['grade'] is None and handed['open'] == 4          # every answer waits for the teacher
+
+            def seen_by_teacher():
+                return teacher.get('/api/classes/1/report')
+
+            for rid in requests[:3]:
+                assert (await teacher.post(f'/api/ai-queue/{rid}/send')).status_code == 200
+            mine = (await student.get('/api/math/quiz-sittings', params={'unit_id': 't'})).json()['sittings'][0]
+            report = (await seen_by_teacher()).json()['students'][0]['quiz_sittings'][0]
+            assert mine['grade'] is None and report['grade'] is None and mine['open'] == report['open'] == 1
+            assert (await teacher.post(f'/api/ai-queue/{requests[3]}/send')).status_code == 200
+            mine = (await student.get('/api/math/quiz-sittings', params={'unit_id': 't'})).json()['sittings'][0]
+            report = (await seen_by_teacher()).json()['students'][0]['quiz_sittings'][0]
+            assert mine['grade'] == report['grade'] == 25 + 15 + 25 + 10 and mine['id'] == report['id'] == handed['id']
+    asyncio.run(check())

tests/test_class_report.py

@@ -4,6 +4,7 @@ import urllib.parse
 
 import httpx
 
+from app.answer_scans import ScanError
 from app.main import create_app
 
 TEACHER, STUDENT, NEWBIE, OUTSIDER = "t-id", "s-id", "n-id", "o-id"
@@ -50,6 +51,28 @@ class ReportAuth:
                 for i in ids if i in self.progress]
 
 
+class Sittings:
+    """The server's record of unit-quiz sittings (app/quiz_grades.py), as the database returns it."""
+    configured = True
+
+    def __init__(self, sittings=(), fail=False):
+        self.sittings, self.fail, self.asked = list(sittings), fail, []
+
+    def quiz(self, user_id, action, **data):
+        self.asked.append((user_id, action, data))
+        if self.fail:
+            raise ScanError(503, "quiz_sittings_unavailable")
+        return [s for s in self.sittings if s["user_id"] in data["users"]]
+
+
+def attempt(score, state="completed", photo=True, verdict="correct"):
+    return {"attempt_id": "a", "has_photo": photo, "grade_state": state, "score": score, "verdict": verdict}
+
+
+def sitting(user, *attempts, sid="s1", at="2026-11-04T09:00:00Z"):
+    return {"id": sid, "user_id": user, "unit_id": "t", "submitted_at": at, "time_up": False, "attempts": list(attempts)}
+
+
 def client(app, user):
     return httpx.AsyncClient(transport=httpx.ASGITransport(app=app), base_url="http://test",
                              headers={"Authorization": f"Bearer {user}"})
@@ -57,6 +80,7 @@ def client(app, user):
 
 def test_teacher_sees_the_other_students():
     app = create_app(auth=ReportAuth())
+    app.state.answers = Sittings()
 
     async def check():
         async with client(app, TEACHER) as c:
@@ -67,12 +91,12 @@ def test_teacher_sees_the_other_students():
             students = {s["email"]: s for s in data["students"]}
             assert "teacher@x.test" not in students   # the teacher is not in their own report
             assert students["ghost@x.test"] == {"email": "ghost@x.test", "signed_in": False, "progress": None,
-                                                "saved_at": None}
+                                                "saved_at": None, "quiz_sittings": []}
             assert students["newbie@x.test"]["signed_in"] and students["newbie@x.test"]["progress"] is None
             p = students["student@x.test"]["progress"]
             assert p["done"] == {"t1": "2026-11-01"} and p["slips"][0]["m"] == "sign"
             assert p["quizzes"] == [{"at": "2026-11-02", "n": 12, "right": 9, "ms": 600000, "units": ["t"]}]
-            assert p["uq"] == {"t": {"history": [{"at": "2026-11-03", "score": 85, "timeUp": None}], "going": False}}
+            assert p["uq"] == {"t": {"history": [{"at": "2026-11-03", "timeUp": None, "sid": None}], "going": False}}
             assert "comets" not in p
             assert (await c.get("/api/classes/99/report")).status_code == 404
             me = (await c.get("/api/me")).json()
@@ -84,6 +108,42 @@ def test_teacher_sees_the_other_students():
     asyncio.run(check())
 
 
+def test_unit_quiz_grades_are_the_servers_and_not_the_devices():
+    auth = ReportAuth()   # the student's uploaded progress claims 85 for unit t
+    app = create_app(auth=auth)
+    app.state.answers = answers = Sittings([
+        sitting(STUDENT, attempt(100), attempt(60), attempt(40), attempt(48), sid="s-done"),   # 25 + 15 + 10 + 12
+        sitting(NEWBIE, attempt(100), attempt(None, state="grading", verdict=None), attempt(100), attempt(100),
+                sid="s-open"),
+        sitting(OUTSIDER, attempt(100), attempt(100), attempt(100), attempt(100), sid="s-other-class")])
+
+    async def check():
+        async with client(app, TEACHER) as c:
+            data = (await c.get("/api/classes/3/report")).json()
+            students = {s["email"]: s for s in data["students"]}
+            done = students["student@x.test"]["quiz_sittings"]
+            assert [(x["id"], x["grade"], x["open"]) for x in done] == [("s-done", 62, 0)]   # not 85
+            waiting = students["newbie@x.test"]["quiz_sittings"]
+            assert [(x["id"], x["grade"], x["open"]) for x in waiting] == [("s-open", None, 1)]
+            assert students["ghost@x.test"]["quiz_sittings"] == []
+            assert "score" not in str(students["student@x.test"]["progress"]["uq"])   # the device's number is not passed on
+            assert answers.asked[0][:2] == (None, "report")
+            assert OUTSIDER not in answers.asked[0][2]["users"] and "s-other-class" not in str(students)
+    asyncio.run(check())
+
+
+def test_without_the_servers_record_the_report_shows_no_quiz_grades():
+    app = create_app(auth=ReportAuth())
+    app.state.answers = Sittings(fail=True)
+
+    async def check():
+        async with client(app, TEACHER) as c:
+            r = await c.get("/api/classes/3/report")
+            assert r.status_code == 200
+            assert all(s["quiz_sittings"] is None for s in r.json()["students"])
+    asyncio.run(check())
+
+
 def test_the_teacher_is_one_of_the_students():
     auth = ReportAuth()
     app = create_app(auth=auth)

tests/test_phone_browser.py

@@ -139,8 +139,18 @@ def test_class_teacher_report(phone_server):
         {"email": "dana@example.com", "signed_in": True, "saved_at": None, "progress": {
             "done": {"t_ext": "2026-11-01"}, "gold": {}, "days": {}, "missed": {}, "slips": slips, "updated": 1,
             "quizzes": [{"at": "2026-11-02T10:00:00Z", "n": 12, "right": 9, "ms": 600000, "units": ["t"]}],
-            "uq": {"t": {"history": [{"at": "2026-11-03T10:00:00Z", "score": 85}], "going": False}}}},
-        {"email": "omer@example.com", "signed_in": False, "saved_at": None, "progress": None}]}
+            # the device claims 85; the server's own record of the sitting says 62
+            "uq": {"t": {"history": [{"at": "2026-11-03T10:00:00Z", "score": 85, "sid": "s1"}], "going": False}}},
+         "quiz_sittings": [{"id": "s1", "unit_id": "t", "submitted_at": "2026-11-04T10:00:00Z", "grade": 62, "open": 0}]},
+        {"email": "omer@example.com", "signed_in": False, "saved_at": None, "progress": None, "quiz_sittings": []},
+        {"email": "noa@example.com", "signed_in": True, "saved_at": None, "progress": {   # handed in, a check still waits
+            "done": {}, "gold": {}, "days": {}, "missed": {}, "slips": [], "updated": 1, "quizzes": [],
+            "uq": {"t": {"history": [{"at": "2026-11-04T09:00:00Z", "sid": "s2"}], "going": False}}},
+         "quiz_sittings": [{"id": "s2", "unit_id": "t", "submitted_at": "2026-11-04T09:00:00Z", "grade": None, "open": 1}]},
+        {"email": "ben@example.com", "signed_in": True, "saved_at": None, "progress": {   # from before the server kept sittings
+            "done": {}, "gold": {}, "days": {}, "missed": {}, "slips": [], "updated": 1, "quizzes": [],
+            "uq": {"t": {"history": [{"at": "2026-10-20T09:00:00Z", "score": 100}], "going": False}}},
+         "quiz_sittings": []}]}
     with playwright.sync_playwright() as p:
         browser = p.chromium.launch()
         try:
@@ -168,12 +178,23 @@ def test_class_teacher_report(phone_server):
             playwright.expect(sheet.locator("#mxTitle")).to_have_text("הכיתה שלי: ט׳2")
             playwright.expect(sheet.locator(".mx-report-common")).to_contain_text("1 תלמידים: dana")
             dana, omer = sheet.locator(".mx-report-student").nth(0), sheet.locator(".mx-report-student").nth(1)
-            playwright.expect(dana.locator("summary")).to_contain_text("בוחן 85")
+            playwright.expect(dana.locator("summary")).to_contain_text("בוחן 62")
             playwright.expect(dana.locator("summary")).to_contain_text("תרגול 9/12")
             playwright.expect(omer).to_contain_text("עוד לא נכנס לחשבון")
             dana.locator("summary").click()
-            playwright.expect(dana.locator(".mx-report-table").first).to_contain_text("85/100")
+            quiz = dana.locator("section", has_text="בוחן מסכם").locator(".mx-report-table")
+            playwright.expect(quiz).to_contain_text("62/100")
+            playwright.expect(quiz).not_to_contain_text("85")   # the device's number is never shown
             playwright.expect(dana.locator(".mx-report-table").nth(1)).to_contain_text("75")
+            # the practice data says it comes from the device; the quiz grades do not
+            playwright.expect(dana.locator("section h5", has_text="התקדמות ביחידות")).to_contain_text("נתוני תרגול מהמכשיר")
+            playwright.expect(dana.locator("section h5", has_text="מבחני תרגול")).to_contain_text("נתוני תרגול מהמכשיר")
+            playwright.expect(dana.locator("section h5", has_text="בוחן מסכם")).not_to_contain_text("מהמכשיר")
+            noa, ben = sheet.locator(".mx-report-student").nth(2), sheet.locator(".mx-report-student").nth(3)
+            noa.locator("summary").click(); ben.locator("summary").click()
+            playwright.expect(noa.locator(".mx-report-grade")).to_have_text("ממתין לבדיקה")
+            playwright.expect(ben.locator(".mx-report-grade")).to_have_text("לא מאומת")   # not "100"
+            playwright.expect(ben.locator(".mx-report-student, summary").first).not_to_contain_text("בוחן 100")
             page.locator(".mx-report-sheet .mx-x").click()
             playwright.expect(sheet).to_be_hidden()
         finally:

tests/test_quiz_grades.py

@@ -0,0 +1,48 @@
+"""How a unit-quiz sitting is graded on the server: points x the check's score, 0 for a missing photo, open while a
+photographed answer has no scored check."""
+from app.quiz_grades import question_result, sitting_view
+
+
+def attempt(score=None, state="completed", verdict="correct", photo=True):
+    return {"attempt_id": "a", "has_photo": photo, "grade_state": state, "score": score, "verdict": verdict}
+
+
+def sitting(*attempts, unit="t"):
+    return {"id": "s1", "unit_id": unit, "submitted_at": "2026-11-04T10:00:00Z", "time_up": False,
+            "attempts": list(attempts)}
+
+
+def test_all_answers_checked_give_the_weighted_sum():
+    view = sitting_view(sitting(attempt(100), attempt(60, verdict="partial"), attempt(100), attempt(40, verdict="partial")))
+    assert [q["earned"] for q in view["questions"]] == [25, 15, 25, 10]   # the quiz is four questions of 25
+    assert view["grade"] == 75 and view["open"] == 0
+
+
+def test_a_missing_photo_earns_zero_and_does_not_keep_the_grade_open():
+    view = sitting_view(sitting(attempt(100), attempt(photo=False, state=None, verdict=None), attempt(100),
+                                attempt(photo=False, state=None, verdict=None)))
+    assert [q["state"] for q in view["questions"]] == ["checked", "missing", "checked", "missing"]
+    assert view["grade"] == 50 and view["open"] == 0
+
+
+def test_a_photographed_answer_without_a_finished_check_leaves_the_grade_open():
+    for waiting in (attempt(state=None, verdict=None), attempt(state="grading", verdict=None),
+                    attempt(state="failed", verdict=None)):
+        view = sitting_view(sitting(attempt(100), waiting, attempt(100), attempt(100)))
+        assert view["grade"] is None and view["open"] == 1
+        assert view["questions"][1] == {"points": 25, "earned": None, "state": "waiting"}
+
+
+def test_an_unreadable_or_needs_review_check_has_no_score_and_stays_open():
+    for verdict in ("unreadable", "needs_review"):
+        view = sitting_view(sitting(attempt(100), attempt(None, verdict=verdict), attempt(100), attempt(100)))
+        assert view["grade"] is None and view["open"] == 1 and view["questions"][1]["state"] == verdict
+
+
+def test_points_are_rounded_per_question():
+    assert question_result(25, attempt(70))["earned"] == 18   # 17.5 rounds up, as the page always did
+    assert question_result(25, attempt(0, verdict="incorrect"))["earned"] == 0
+
+
+def test_a_sitting_of_a_unit_without_a_quiz_has_no_view():
+    assert sitting_view(sitting(attempt(100), unit="nope")) is None

tests/test_unit_quiz.py

@@ -185,6 +185,17 @@ def test_a_unit_quiz_is_written_photographed_handed_in_and_then_checked(quiz_ser
             page.locator("[data-uq-result]").first.click()
             playwright.expect(page.locator(".mx-uq-sheet h3")).to_have_text("בוחן מסכם: 65/100", timeout=10000)
             assert len(calls) == 3 and not errors
+            # a score written into this device's progress does not change what the result screen shows
+            page.evaluate("""() => { for (const k of Object.keys(localStorage)) if (k.startsWith('mathly.progress.v1:')) {
+                const p = JSON.parse(localStorage.getItem(k)); p.uq.t.history.at(-1).score = 100;
+                localStorage.setItem(k, JSON.stringify(p)); } }""")
+            page.reload()
+            page.locator('.mx-nav [data-view="path"]').click()
+            page.locator('.mx-uquiz[data-uquiz="t"]').click()
+            page.locator("[data-uq-result]").first.click()
+            playwright.expect(page.locator(".mx-uq-sheet h3")).to_have_text("בוחן מסכם: 65/100", timeout=10000)
+            playwright.expect(page.locator(".mx-uq-qhead span")).to_have_text(["25/25 נק׳", "15/25 נק׳", "25/25 נק׳", "0/25 נק׳"])
+            assert len(calls) == 3 and not errors
         finally:
             browser.close()
 
@@ -295,3 +306,120 @@ def test_on_a_phone_a_unit_quiz_answer_is_handed_in_from_the_full_screen_board(q
             assert errors == []
         finally:
             browser.close()
+
+
+# ---- sittings kept on the server (app/quiz_grades.py)
+def quiz_answer(store, index, *, unit="t", photo=True, owner=OWNER):
+    """A fresh attempt at quiz question `index` of `unit`, with a saved photo when asked."""
+    from test_answer_scans import begin, finish
+    graph_unit = next(u for u in algebra9()["units"] if u["id"] == unit)
+    snapshot = quiz_snapshot(graph_unit, index)
+    made = store.action(owner, "resume", question_id=f"quiz:{unit}:{index}", question_version=question_version(snapshot),
+                        snapshot=snapshot, new=True)
+    aid = made["attempt"]["id"]
+    if photo:
+        scan = store.action(owner, "create_scan", attempt_id=aid)
+        finish(store, begin(store, scan))
+    return aid
+
+
+def check(store, aid, score, owner=OWNER):
+    import uuid
+    lease = str(uuid.uuid4())
+    store.grade(owner, "start", attempt_id=aid, lease_id=lease)
+    store.grade(owner, "complete", attempt_id=aid, lease_id=lease, result=validate_assessment(assessment(score=score)))
+
+
+def test_the_sittings_migration_is_additive_and_service_only(answer_store):
+    import psycopg
+    with answer_store.connect() as c:
+        assert c.execute("select name from classes").fetchone()[0] == "existing math class"
+        assert c.execute("select relrowsecurity from pg_class where relname='math_quiz_sittings'").fetchone()[0]
+        c.execute("set role authenticated")
+        with pytest.raises(psycopg.errors.InsufficientPrivilege):
+            c.execute("select * from math_quiz_sittings")
+        c.execute("reset role")
+        c.execute("set role anon")
+        with pytest.raises(psycopg.errors.InsufficientPrivilege):
+            c.execute("select math_quiz_action(null,'report','{\"users\":[]}')")
+
+
+def sitting_app(store):
+    app = create_app(auth=ScanAuth()); app.state.answers = store
+    return app
+
+
+def api(app, user=OWNER):
+    return httpx.AsyncClient(transport=httpx.ASGITransport(app=app), base_url="http://test",
+                             headers={"Authorization": f"Bearer {user}"})
+
+
+def test_handing_in_keeps_a_sitting_with_a_grade_from_the_stored_checks(answer_store):
+    store = answer_store
+    ids = [quiz_answer(store, i, photo=i < 3) for i in range(4)]   # the last question has no photo
+    for aid, score in zip(ids[:3], (100, 60, 80)):
+        check(store, aid, score)
+    key = "9f0d6c3e-8c51-4a51-9c7e-0d5f4b8a1e11"
+    app = sitting_app(store)
+
+    async def run():
+        async with api(app) as c:
+            r = await c.post("/api/math/quiz-sittings", json={"unit_id": "t", "attempts": ids, "client_key": key})
+            assert r.status_code == 200
+            sitting = r.json()
+            assert sitting["unit_id"] == "t" and sitting["attempts"] == ids
+            assert sitting["grade"] == 25 + 15 + 20 + 0 and sitting["open"] == 0
+            again = (await c.post("/api/math/quiz-sittings", json={"unit_id": "t", "attempts": ids, "client_key": key,
+                                                                   "time_up": True})).json()
+            assert again["id"] == sitting["id"]                                   # a lost response, sent again
+            mine = (await c.get("/api/math/quiz-sittings", params={"unit_id": "t"})).json()["sittings"]
+            assert [s["id"] for s in mine] == [sitting["id"]]
+            assert (await c.get("/api/math/quiz-sittings", params={"unit_id": "k"})).json() == {"sittings": []}
+    asyncio.run(run())
+    with answer_store.connect() as c:
+        assert c.execute("select count(*) from math_quiz_sittings").fetchone()[0] == 1
+
+
+def test_a_sitting_with_the_wrong_attempts_is_refused(answer_store):
+    store = answer_store
+    ids = [quiz_answer(store, i) for i in range(4)]
+    theirs = quiz_answer(store, 0, owner=OTHER, photo=False)
+    other_unit = quiz_answer(store, 0, unit="k")
+    app = sitting_app(store)
+    post = lambda c, attempts, key, unit="t": c.post("/api/math/quiz-sittings",
+                                                      json={"unit_id": unit, "attempts": attempts, "client_key": key})
+    keys = [f"00000000-0000-4000-8000-00000000000{i}" for i in range(6)]
+
+    async def run():
+        async with api(app) as c:
+            assert (await post(c, [theirs] + ids[1:], keys[0])).status_code == 409            # another student's
+            assert (await post(c, [ids[1], ids[0], ids[2], ids[3]], keys[1])).status_code == 409   # wrong order
+            assert (await post(c, [other_unit] + ids[1:], keys[2])).status_code == 409        # another unit's question
+            assert (await post(c, ids[:3], keys[3])).status_code == 404                       # a question short
+            assert (await post(c, ids, keys[4], unit="nope")).status_code == 404
+            assert (await post(c, ["x"] * 4, keys[5])).status_code == 404                     # not attempt ids
+            assert (await post(c, ids, keys[0])).status_code == 200
+            reused = await post(c, ids, keys[1])                                              # the same attempts again
+            assert (reused.status_code, reused.json()["detail"]) == (409, "invalid_sitting")
+    asyncio.run(run())
+    with answer_store.connect() as c:
+        assert c.execute("select count(*) from math_quiz_sittings").fetchone()[0] == 1
+
+
+def test_a_check_that_finishes_after_handing_in_gives_the_sitting_its_grade(answer_store):
+    store = answer_store
+    ids = [quiz_answer(store, i) for i in range(4)]
+    for aid in ids[:3]:
+        check(store, aid, 100)
+    app = sitting_app(store)
+
+    async def run():
+        async with api(app) as c:
+            first = (await c.post("/api/math/quiz-sittings", json={"unit_id": "t", "attempts": ids,
+                                  "client_key": "9f0d6c3e-8c51-4a51-9c7e-0d5f4b8a1e11"})).json()
+            assert first["grade"] is None and first["open"] == 1
+            assert first["questions"][3]["state"] == "waiting"
+            check(store, ids[3], 40)                                  # for example the teacher sends it from the queue
+            mine = (await c.get("/api/math/quiz-sittings", params={"unit_id": "t"})).json()["sittings"]
+            assert mine[0]["grade"] == 85 and mine[0]["open"] == 0
+    asyncio.run(run())