Add tests for drafting and reviewing student answers

- Implement tests for the drafting of worked examples in `test_draft_examples.py`, ensuring well-formed drafts are generated for skills without examples, and that the model's responses are validated.
- Create tests in `test_teacher_review.py` to cover the teacher's review process of student answers, including handling review requests, score validation, and ensuring proper access control for teachers and students.
- Ensure that the tests cover various scenarios, including error handling and edge cases, to maintain robustness in the review and drafting functionalities.

README.md

@@ -80,8 +80,24 @@ For rollback, turn `MATHLY_ANSWER_SCANS_ENABLED` off and restart; preserve the n
 
 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.
 
+The report opens with **דורשים תשומת לב**: the students who have not practised for 7 days, are stuck on a skill (3 or more wrong answers in 14 days without finishing it), practised less than half as much this week as last (from Sunday, and only when last week had at least 10 right answers), have a unit-quiz grade below 55, or have not started. Each is listed with the reasons. The **טבלת מיומנויות** view is a grid of students by skill for a chosen unit (or by unit), with how many finished each skill and a ⚠ on skills where at least a third of the students are practising without having finished. The list can be sorted by attention, name, progress or last activity; the choices are kept on the teacher's device. Students are shown by the class nickname, else their Google name, else the start of their email. The thresholds are constants at the top of the teacher's signals in `static/math-sky.js`. These signals come from the device-reported practice data below, so they tell the teacher where to look; they are not grades.
+
 **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.
 
+### Assignments
+
+The class teacher (or a manager) gives the class an **assignment** from the class report's **משימות** tab (`app/assignments.py`, table `math_assignments`): a title, a note, a due date and 1 to 20 items, each a skill to finish, a unit quiz to hand in, or a practice exam over chosen units. Every item must belong to the units open to the class; the same item twice is kept once. Students see their classes' assignments in a **משימות מהמורה** card on the home screen (`GET /api/math/assignments`, without the teacher's email), a continue button that opens the first item not done (a practice exam opens with its units chosen), and a 📌 on the path's stars of skills in unfinished assignments. Finished ones stay in a **הושלמו** list for two weeks after the due date.
+
+Nothing about completion is stored: the page works it out (`assignmentState` in `static/math-sky.js`), the same way for the student and for the teacher's report. A skill is done when it is finished, whenever that was; a unit quiz when the server has a sitting of it handed in after the assignment was made (`app/quiz_grades.py`); a practice exam when one covering all the item's units was taken after that. Dates are Jerusalem days, so an item done on the due date is on time. The report's tab shows how many students finished each assignment and, per student, which items are done, late (✓ באיחור) or missing; a student with an unfinished assignment past its due date is added to **דורשים תשומת לב**. The completion of skills and practice exams is what the student's device reports, like the rest of the practice data.
+
+Apply [the assignments migration](supabase/migrations/20261104210000_math_assignments.sql) before deploying: it adds the service-only table, which is deleted with its class. Without it the routes answer 503, students see no card, and the report's tab says assignments are unavailable.
+
+### Reviewing answers (teacher score and comment)
+
+The class teacher (or a manager) can open any open answer of their students that has a saved photo: from the **פתיחה** button in the class report's unit-quiz table (it lists the latest sitting's answers), or from a handled answer in the AI queue. The page shows the question, the photo, the automatic check and a form for a **score** (0 to 100), a **comment**, or both (`app/teacher_review.py`, table `math_teacher_reviews`). The automatic check is never edited: the review is kept next to it, the newest review of an answer counts and older ones stay as history. Wherever an answer's score is used, the teacher's wins (`effective_score`): the unit-quiz grade (`app/quiz_grades.py`) and the skill itself, which a teacher score of 100 completes on the student's device the next time they open the answer. A teacher can also score an answer the AI could not read or has not yet checked. The student sees **הערת המורה** and its score above the automatic check, which stays visible and labelled, and a notice on the home screen until they open the answer. A student can press **לבקש מהמורה לבדוק שוב** on a checked answer with a short message: one open request per answer and five per student (`math_review_requests`). Requests appear in the AI queue's **בקשות לבדיקה חוזרת** tab (counted on the queue button) and on the student's report card, and saving a review closes the request. Only the teacher of the student's class, or a manager, can open or review the answer; anyone else gets a 403 and no image or check.
+
+Apply [the reviews migration](supabase/migrations/20261104150000_math_teacher_reviews.sql) after the quiz-sittings migration and before deploying this code. It adds the two tables and two service-only functions, and replaces `math_quiz_sitting_json` so a sitting's grade can use the teacher's score. Without it the teacher's review routes answer 503, and students see their answers and grades as before, with no teacher section.
+
 ### The teacher's AI queue
 
 Students never call the AI themselves. When a student saves an open answer (or hands in a **בוחן מסכם**, or sends a photographed problem), the request goes to their class teacher's **תור AI** instead of to Claude. The teacher sees each waiting request with the student's photo and the question, then presses **שליחה ל-AI** or **דחייה** (with an optional note for the student). The student's page shows the answer as waiting for the teacher, then the grade and feedback once it is sent, or the teacher's note if it was declined (the student can ask again). A failed send stays in the queue for the teacher to retry. Managers see every class's requests.
@@ -90,9 +106,17 @@ Accounts with the teacher, admin or developer role, and every class teacher, sti
 
 Apply [the additive queue migration](supabase/migrations/20261104090000_math_ai_requests.sql) before deploying this code: it adds the service-only `math_ai_requests` table. Without it, students cannot have answers checked (they see that checking is unavailable); teachers are not affected.
 
+### Worked examples (help when stuck)
+
+A skill in `app/math_algebra9.json` may have an `example`: a question of its own (never one of the skill's practice questions), `steps` of `{do, why}`, and the `answer`. The **?** button in a skill's sheet opens it over the question, one step at a time; it is also offered after the second wrong answer in a round. Opening it is kept in the student's progress (`examples`: count and last time, merged across devices), changes nothing about finishing or gold, and shows on the student's report card for two weeks. Students never call the AI, so examples are written in advance and **a math teacher must review every one before it reaches students**. `app/math_skills.py` refuses data whose examples are malformed or copy a practice question, and `skills_without_example(graph)` lists what is still to write.
+
+`scripts/draft_examples.py` helps write them: `draft --unit t` asks Claude for one example per skill of a unit that has none (one request per skill, using `ANTHROPIC_API_KEY` and `MATH_MODEL`; `--dry-run` shows what it would send) and writes a review file under `docs/example-drafts/` without touching the data. The teacher edits the file, sets `approved` and `reviewed_by` on the good ones, and `merge docs/example-drafts/t.json` adds only those to the data file after the app's own checks.
+
 ### Lesson resources (teachers)
 
-A teacher taps a unit's title on the path (for example **טכניקה אלגברית 1**), photographs an exercise or an explanation, and saves it to that lesson's resources. Each photo is marked as **תרגיל חדש**, **הסבר תיאורטי**, or **אחר** (with a short free-text description), and can optionally name the topic it belongs to (for example **פילוג מורחב**). Apply [the additive resources migration](supabase/migrations/20261101090000_math_unit_resources.sql); it adds the `math_unit_resources` table and the private `mathly-resources` bucket. Only accounts with the teacher role see, add, or open resources, and only the teacher who added a photo (or a manager) can delete it. Students do not see resources yet.
+A teacher taps a unit's title on the path (for example **טכניקה אלגברית 1**), photographs an exercise or an explanation, and saves it to that lesson's resources. Each photo is marked as **תרגיל חדש**, **הסבר תיאורטי**, or **אחר** (with a short free-text description), and can optionally name the topic it belongs to (for example **פילוג מורחב**). Apply [the additive resources migration](supabase/migrations/20261101090000_math_unit_resources.sql); it adds the `math_unit_resources` table and the private `mathly-resources` bucket. Only accounts with the teacher role see, add, or open all resources, and only the teacher who added a photo (or a manager) can delete it or change who sees it.
+
+**Showing resources to students.** Each resource has a **גלוי לתלמידים** box: checked by default for a theory explanation, unchecked for an exercise or a note, and changeable later by its teacher or a manager (`PATCH /api/math/resources/{id}`). Students see the visible resources of the units open to their class (`/api/math/units/{unit}/student-resources`, with no teacher email and no storage path; hidden ones and other classes' units answer 404). A resource tied to a skill shows in that skill's sheet and its **?** help panel under **הסברים מהמורה**; the unit's other visible resources are on a list opened from a button under the unit. Apply [the visibility migration](supabase/migrations/20261104180000_math_resources_visible.sql); it adds the `visible` column, and every resource added before it starts hidden. Without it, uploads still work (the box is ignored) and students see none.
 
 Integration tests use bundled disposable PostgreSQL and local private test blobs, without project credentials or Docker:
 

app/access.py

@@ -36,3 +36,16 @@ def resolve_access(store: SupabaseAuth, token: str, *, fresh_permissions: bool =
 def has_permission(user: dict | None, permission: str) -> bool:
     permissions = set((user or {}).get("permissions", ()))
     return "*" in permissions or permission in permissions
+
+
+def students_of(user: dict, classes) -> set[str] | None:
+    """The students (emails) this account reviews: those of the classes it is the teacher of, and None, meaning every
+    student, for a manager. Shared by the AI queue and the teacher's review of answers."""
+    if has_permission(user, "management.access"):
+        return None
+    email = str(user.get("email", "")).lower()
+    out: set[str] = set()
+    for row in classes:
+        if email in row.get("teachers", ()):
+            out |= set(row.get("emails", ())) - set(row.get("teachers", ()))
+    return out

app/ai_queue.py

@@ -19,7 +19,7 @@ from datetime import datetime, timedelta, timezone
 from fastapi import Depends
 from fastapi.responses import JSONResponse, Response
 
-from .access import has_permission
+from .access import has_permission, students_of
 from .answer_scans import ScanError, uuid_text
 from .auth import AuthUnavailable, ClassConflict
 from .math_photo import PhotoUnavailable
@@ -176,18 +176,10 @@ def install_ai_queue_routes(app, signed_in):
 
     def watched(user: dict) -> set[str] | None:
         """The students whose requests this account reviews; None: everyone's (a manager)."""
-        if has_permission(user, "management.access"):
-            return None
-        email = str(user.get("email", "")).lower()
         try:
-            classes = app.state.auth.classes()
+            return students_of(user, app.state.auth.classes())
         except AuthUnavailable as exc:
             raise ScanError(503, "queue_unavailable") from exc
-        out: set[str] = set()
-        for row in classes:
-            if email in row.get("teachers", ()):
-                out |= set(row.get("emails", ())) - set(row.get("teachers", ()))
-        return out
 
     def reviewer(user=Depends(account)) -> dict:
         if not may_send(user) or watched(user) == set():   # a teacher with no class has no one to review

app/answer_routes.py

@@ -15,6 +15,7 @@ from .answer_scans import AnswerScans, MAX_IMAGE, ScanError, clean_image, public
 from .answer_grading import AnswerGrader
 from .math_photo import PhotoUnavailable
 from .quiz_grades import sitting_view
+from .teacher_review import MAX_MESSAGE, effective_score, for_student as review_for_student, request_for_student
 from .math_skills import algebra9, question_version, quiz_snapshot
 
 log = logging.getLogger("mathly.answer_routes")
@@ -55,7 +56,8 @@ def install_answer_routes(app, signed_in):
             raise ScanError(503, "answer_storage_unavailable")
         return user["id"]
 
-    def call(user, action, **data):
+    def call(user, action, *, student_view=False, **data):
+        """`student_view`: the student is opening the answer, so a teacher's review of it counts as seen."""
         result = app.state.answers.action(user, action, **data)
         if isinstance(result, dict) and result.get("attachment"):
             result["grading_available"] = bool(grading_key())
@@ -65,6 +67,17 @@ def install_answer_routes(app, signed_in):
                 # A staged deployment must not block saved images or upload receipt.
                 result["grading"] = None
                 result["grading_available"] = False
+            marks = {"review": None, "request": None}   # the teacher's review of the answer, and the student's request
+            try:
+                marks = app.state.answers.review(user, "get", attempt_id=result["attempt"]["id"])
+                if student_view and marks["review"] and not marks["review"].get("seen_at"):
+                    app.state.answers.review(user, "seen", attempt_id=result["attempt"]["id"])
+            except ScanError:
+                pass   # the reviews are not set up yet: the answer still shows
+            result["teacher_review"] = review_for_student(marks["review"])
+            result["review_request"] = request_for_student(marks["request"])
+            check = (result.get("grading") or {}).get("result") if (result.get("grading") or {}).get("state") == "completed" else None
+            result["effective_score"] = effective_score((check or {}).get("score"), (marks["review"] or {}).get("score"))
             result["ai_request"] = None   # the teacher's queue (ai_queue.py): this answer's latest request
             if app.state.ai_queue.configured and (result.get("grading") or {}).get("state") != "completed":
                 try:
@@ -99,7 +112,7 @@ def install_answer_routes(app, signed_in):
         version = question_version(sample)
         if body.get("question_version") != version:
             raise ScanError(409, "question_changed")
-        return reply(call(user, "resume", question_id=question["id"], question_version=version,
+        return reply(call(user, "resume", student_view=True, question_id=question["id"], question_version=version,
                           snapshot={"name": question["name"], **sample}, new=body.get("new") is True))
 
     @app.post("/api/math/quiz-attempts")
@@ -115,13 +128,14 @@ def install_answer_routes(app, signed_in):
         version = question_version(snapshot)
         if body.get("question_version") != version:
             raise ScanError(409, "question_changed")
-        return reply(call(user, "resume", question_id=f"quiz:{unit['id']}:{index}", question_version=version,
-                          snapshot=snapshot, new=body.get("new") is True))
+        return reply(call(user, "resume", student_view=True, 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)):
+    def submit_sitting(body: dict, user=Depends(student), account=Depends(signed_in)):
         """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."""
+        (app/quiz_grades.py). Sending the same `client_key` again returns the same sitting. A student's answers all go
+        to their teacher's queue right here, so none depends on the page staying open to ask for each one."""
         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)
@@ -130,6 +144,14 @@ def install_answer_routes(app, signed_in):
             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")))
+        if account is not None and not may_send(account) and grading_key():
+            for aid in [a["attempt_id"] for a in sitting.get("attempts") or []]:
+                try:
+                    found = app.state.answers.action(user, "get", attempt_id=aid)
+                    if found.get("attachment") and not app.state.answers.grade(user, "get", attempt_id=aid):
+                        ask_teacher(user, account, aid, found, True)   # automatic: an answer the teacher declined stays declined
+                except ScanError as exc:   # one answer that cannot be queued now must not lose the hand-in
+                    log.warning("quiz answer not queued for the teacher: %s", exc.code)
         return JSONResponse(sitting_view(sitting), headers={"Cache-Control": "no-store"})
 
     @app.get("/api/math/quiz-sittings")
@@ -141,7 +163,28 @@ def install_answer_routes(app, signed_in):
 
     @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)))
+        return reply(call(user, "get", student_view=True, attempt_id=uuid_text(attempt_id)))
+
+    @app.post("/api/math/answer-attempts/{attempt_id}/review-request")
+    def ask_review(attempt_id: str, body: dict | None = None, user=Depends(student)):
+        """The student asks their teacher to look again at a checked answer (at most one open request per answer)."""
+        message = (body or {}).get("message")
+        if message is not None and not isinstance(message, str):
+            raise ScanError(400, "invalid_message")
+        message = (message or "").strip()
+        if len(message) > MAX_MESSAGE:
+            raise ScanError(400, "message_too_long")
+        marks = app.state.answers.review(user, "request", attempt_id=uuid_text(attempt_id), message=message)
+        return JSONResponse({"review_request": request_for_student(marks["request"])}, headers={"Cache-Control": "no-store"})
+
+    @app.get("/api/math/teacher-comments")
+    def teacher_comments(user=Depends(student)):
+        """Answers the teacher reviewed that the student has not opened since."""
+        try:
+            rows = app.state.answers.review(user, "unseen")
+        except ScanError:
+            rows = []   # not set up yet: nothing to tell
+        return JSONResponse({"comments": rows}, headers={"Cache-Control": "no-store"})
 
     @app.post("/api/math/answer-attempts/{attempt_id}/grade")
     def grade_answer(attempt_id: str, body: dict | None = None, user=Depends(student), account=Depends(signed_in)):

app/answer_scans.py

@@ -159,6 +159,20 @@ class AnswerScans:
             raise
         return json.loads(raw)
 
+    def review(self, user_id: str | None, action: str, **data):
+        """The teacher's reviews of answers and the students' requests to look again (app/teacher_review.py). The
+        student's id is `user_id` (a teacher's route finds it first with the `owner` action)."""
+        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_review_action", "POST", json.dumps(body).encode(), "application/json")
+        except ScanError as exc:
+            if exc.code == "answer_storage_unavailable":
+                raise ScanError(503, "review_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"}
@@ -177,7 +191,7 @@ class AnswerScans:
             code, message = error.get("code"), error.get("message", "")
             if code == "P0002":
                 raise ScanError(404, "not_found") from exc
-            if code == "P0001" and message == "grading_limit":
+            if code == "P0001" and message in {"grading_limit", "review_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", "invalid_sitting"}:

app/assignments.py

@@ -0,0 +1,248 @@
+"""Assignments: what a class teacher asks their class to do in the app, by a date.
+
+An assignment (Supabase `math_assignments`) has a title, a note, a due date and 1 to 20 items, each one of
+  {"kind": "skill", "id"}                     finish this skill,
+  {"kind": "unit_quiz", "unit"}               hand in this unit's summarizing quiz,
+  {"kind": "exam", "units": [...]}            take a practice exam over these units.
+Every item must belong to the units open to the class. Whether an item is done is not stored: the page works it out from
+the student's progress and the server's quiz sittings (`assignmentState` in static/math-sky.js), the same way for the
+student's home screen and for the teacher's report. The class's teacher (or a manager) writes them; the class reads them.
+"""
+from __future__ import annotations
+
+import logging
+import urllib.parse
+from datetime import date, datetime, timedelta, timezone
+from zoneinfo import ZoneInfo
+
+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 .math_skills import algebra9
+
+log = logging.getLogger("mathly.assignments")
+MIGRATION = "supabase/migrations/20261104210000_math_assignments.sql"
+TABLE = "/rest/v1/math_assignments"
+FIELDS = "id,class_id,title,note,due_on,items,created_by_email,created_at,updated_at"
+MAX_ITEMS, MAX_TITLE, MAX_NOTE, PER_CLASS = 20, 80, 500, 50
+JERUSALEM = ZoneInfo("Asia/Jerusalem")
+
+
+class AssignmentsUnavailable(RuntimeError):
+    pass
+
+
+class Assignments:
+    """The table, through the server's secret key."""
+
+    def __init__(self, auth):
+        self.auth = auth
+        self._warned = False
+
+    @property
+    def configured(self) -> bool:
+        return bool(self.auth is not None and getattr(self.auth, "secret", None))
+
+    def _rest(self, query: str = "", method: str = "GET", body=None):
+        if not self.configured:
+            raise AssignmentsUnavailable("assignments_unavailable")
+        try:
+            return self.auth._admin(TABLE + query, method, body) or []
+        except AuthUnavailable as exc:
+            if "answered 404" in str(exc) and not self._warned:
+                log.warning("the math_assignments table is missing; apply %s", MIGRATION)
+                self._warned = True
+            raise AssignmentsUnavailable("assignments_unavailable") from exc
+
+    def for_classes(self, class_ids: list[int]) -> list[dict]:
+        """The newest-due assignments of these classes (at most PER_CLASS each)."""
+        if not class_ids:
+            return []
+        out = []
+        for class_id in class_ids:
+            out += self._rest(f"?select={FIELDS}&class_id=eq.{int(class_id)}&order=due_on.desc&limit={PER_CLASS}")
+        return out
+
+    def get(self, assignment_id: str) -> dict | None:
+        rows = self._rest(f"?select={FIELDS}&id=eq.{urllib.parse.quote(assignment_id)}")
+        return rows[0] if rows else None
+
+    def add(self, row: dict) -> dict:
+        return self._rest(f"?select={FIELDS}", "POST", row)[0]
+
+    def update(self, assignment_id: str, fields: dict) -> dict | None:
+        rows = self._rest(f"?id=eq.{urllib.parse.quote(assignment_id)}&select={FIELDS}", "PATCH", fields)
+        return rows[0] if rows else None
+
+    def remove(self, assignment_id: str) -> None:
+        self._rest(f"?id=eq.{urllib.parse.quote(assignment_id)}", "DELETE")
+
+
+def clean_assignment(body, class_units: list[str]) -> dict:
+    """The fields of an assignment as sent, checked against the class's units; HTTPException 400 when something is off."""
+    if not isinstance(body, dict):
+        raise HTTPException(400, "send the assignment as an object")
+    title = " ".join(str(body.get("title") or "").split())
+    if not title or len(title) > MAX_TITLE:
+        raise HTTPException(400, f"the title is required (up to {MAX_TITLE} characters)")
+    note = str(body.get("note") or "").strip()
+    if len(note) > MAX_NOTE:
+        raise HTTPException(400, f"the note is longer than {MAX_NOTE} characters")
+    try:
+        due = date.fromisoformat(str(body.get("due_on") or ""))
+        if not 2020 <= due.year <= 2100 or len(str(body.get("due_on"))) != 10:
+            raise ValueError
+    except ValueError as exc:
+        raise HTTPException(400, "the due date must be a date (YYYY-MM-DD)") from exc
+    raw = body.get("items")
+    if not isinstance(raw, list) or not 1 <= len(raw) <= MAX_ITEMS:
+        raise HTTPException(400, f"an assignment has 1 to {MAX_ITEMS} items")
+    graph = algebra9()
+    skills = {s["id"]: s["unit"] for s in graph["skills"]}
+    quiz_units = {u["id"] for u in graph["units"] if "quiz" in u}
+    allowed, items, seen = set(class_units), [], set()
+    for item in raw:
+        kind = item.get("kind") if isinstance(item, dict) else None
+        if kind == "skill":
+            ok = skills.get(item.get("id")) in allowed
+            clean = {"kind": "skill", "id": item.get("id")}
+        elif kind == "unit_quiz":
+            ok = item.get("unit") in allowed and item.get("unit") in quiz_units
+            clean = {"kind": "unit_quiz", "unit": item.get("unit")}
+        elif kind == "exam":
+            units = item.get("units")
+            ok = isinstance(units, list) and bool(units) and len(set(units)) == len(units) and all(u in allowed for u in units)
+            clean = {"kind": "exam", "units": sorted(units) if ok else []}
+        else:
+            ok, clean = False, None
+        if not ok:
+            raise HTTPException(400, "an item is not part of this class's units")
+        key = repr(clean)
+        if key not in seen:   # the same item twice is one item
+            seen.add(key)
+            items.append(clean)
+    return {"title": title, "note": note, "due_on": due.isoformat(), "items": items}
+
+
+def public(row: dict, teacher: bool = False) -> dict:
+    out = {k: row.get(k) for k in ("id", "class_id", "title", "note", "due_on", "items", "created_at", "updated_at")}
+    if teacher:
+        out["created_by_email"] = row.get("created_by_email", "")
+    return out
+
+
+def today_in_jerusalem() -> date:
+    return datetime.now(JERUSALEM).date()
+
+
+def install_assignment_routes(app, signed_in, units_of):
+    if not hasattr(app.state, "assignments"):
+        app.state.assignments = Assignments(app.state.auth)
+
+    def store() -> Assignments:
+        return app.state.assignments
+
+    def class_row(class_id: int, user: dict) -> dict:
+        """The class, if this account is its teacher or a manager."""
+        if not user or not user.get("id"):
+            raise HTTPException(401, "sign in required")
+        try:
+            row = next((r for r in app.state.auth.classes() if r.get("id") == class_id), None)
+        except AuthUnavailable as exc:
+            raise HTTPException(503, str(exc)) from exc
+        if row is None:
+            raise HTTPException(404, "class not found")
+        if str(user.get("email", "")).lower() not in row.get("teachers", ()) and not has_permission(user, "management.access"):
+            raise HTTPException(403, "only the class's teacher can give it assignments")
+        return row
+
+    def unavailable(exc: AssignmentsUnavailable) -> HTTPException:
+        return HTTPException(503, "assignments_unavailable")
+
+    def reply(value, status=200):
+        return JSONResponse(value, status_code=status, headers={"Cache-Control": "no-store"})
+
+    def note(user, kind, row, label):
+        actions = getattr(app.state, "actions", None)
+        if actions is not None:
+            actions.record(user, kind, f"{label}: {row.get('title', '')}")
+
+    # ---- the class teacher
+    @app.get("/api/classes/{class_id}/assignments")
+    def list_assignments(class_id: int, user=Depends(signed_in)):
+        class_row(class_id, user)
+        try:
+            return reply({"assignments": [public(r, True) for r in store().for_classes([class_id])]})
+        except AssignmentsUnavailable as exc:
+            raise unavailable(exc) from exc
+
+    @app.post("/api/classes/{class_id}/assignments")
+    def create_assignment(class_id: int, body: dict, user=Depends(signed_in)):
+        row = class_row(class_id, user)
+        fields = clean_assignment(body, units_of(row))
+        try:
+            saved = store().add({**fields, "class_id": class_id, "created_by_email": str(user.get("email", "")).lower()})
+        except AssignmentsUnavailable as exc:
+            raise unavailable(exc) from exc
+        note(user, "assignment_saved", saved, row["name"])
+        return reply(public(saved, True), 201)
+
+    def owned(class_id: int, assignment_id: str):
+        try:
+            found = store().get(assignment_id)
+        except AssignmentsUnavailable as exc:
+            raise unavailable(exc) from exc
+        if not found or found.get("class_id") != class_id:
+            raise HTTPException(404, "assignment not found")
+        return found
+
+    @app.put("/api/classes/{class_id}/assignments/{assignment_id}")
+    def update_assignment(class_id: int, assignment_id: str, body: dict, user=Depends(signed_in)):
+        row = class_row(class_id, user)
+        owned(class_id, assignment_id)
+        fields = clean_assignment(body, units_of(row))
+        try:
+            saved = store().update(assignment_id, {**fields, "updated_at": datetime.now(timezone.utc).isoformat()})
+        except AssignmentsUnavailable as exc:
+            raise unavailable(exc) from exc
+        if not saved:
+            raise HTTPException(404, "assignment not found")
+        note(user, "assignment_saved", saved, row["name"])
+        return reply(public(saved, True))
+
+    @app.delete("/api/classes/{class_id}/assignments/{assignment_id}")
+    def delete_assignment(class_id: int, assignment_id: str, user=Depends(signed_in)):
+        row = class_row(class_id, user)
+        found = owned(class_id, assignment_id)
+        try:
+            store().remove(assignment_id)
+        except AssignmentsUnavailable as exc:
+            raise unavailable(exc) from exc
+        note(user, "assignment_deleted", found, row["name"])
+        return reply({"ok": True})
+
+    # ---- the students: their classes' assignments, and when they handed in each unit quiz
+    @app.get("/api/math/assignments")
+    def my_assignments(user=Depends(signed_in)):
+        if not user or not user.get("id"):
+            raise HTTPException(401, "sign in required")
+        classes = [c for c in user.get("classes") or [] if c.get("id") is not None]
+        try:
+            rows = store().for_classes([c["id"] for c in classes])
+        except AssignmentsUnavailable as exc:
+            raise unavailable(exc) from exc
+        names = {c["id"]: c.get("name", "") for c in classes}
+        quiz_units = sorted({i["unit"] for r in rows for i in r["items"] if i.get("kind") == "unit_quiz"})
+        sittings = []
+        if quiz_units:
+            try:
+                for unit in quiz_units:
+                    sittings += [{"unit_id": s["unit_id"], "submitted_at": s["submitted_at"]}
+                                 for s in app.state.answers.quiz(user["id"], "list", unit_id=unit)]
+            except ScanError:
+                sittings = None   # the server's record could not be read: unit-quiz items cannot be told done
+        return reply({"assignments": [{**public(r), "class_name": names.get(r["class_id"], "")} for r in rows],
+                      "sittings": sittings, "today": today_in_jerusalem().isoformat()})

app/auth.py

@@ -160,8 +160,9 @@ class SupabaseAuth:
             grades = []
         return {"attempts": attempts, "grades": grades}
 
-    def user_ids(self, emails: list[str]) -> dict[str, str]:
-        """The account id of each email that has signed in at least once (Supabase's admin user list), by email."""
+    def user_accounts(self, emails: list[str]) -> dict[str, dict]:
+        """The id and Google name of each email that has signed in at least once (Supabase's admin user list), by email.
+        The name is "" when the account has none."""
         wanted, found = {email.lower() for email in emails}, {}
         page = 1
         while wanted - found.keys():
@@ -170,12 +171,23 @@ class SupabaseAuth:
             for user in users or []:
                 email = str(user.get("email") or "").lower()
                 if email in wanted and user.get("id"):
-                    found[email] = user["id"]
+                    meta = user.get("user_metadata") if isinstance(user.get("user_metadata"), dict) else {}
+                    name = " ".join(str(meta.get("full_name") or meta.get("name") or "").split())
+                    found[email] = {"id": user["id"], "name": name}
             if len(users or []) < 1000 or page >= 50:
                 break
             page += 1
         return found
 
+    def user_email(self, user_id: str) -> str:
+        """The email of one account (Supabase's admin API), "" when it has none."""
+        data = self._admin(f"/auth/v1/admin/users/{user_id}") or {}
+        return str(data.get("email") or "").lower() if isinstance(data, dict) else ""
+
+    def user_ids(self, emails: list[str]) -> dict[str, str]:
+        """The account id of each email that has signed in at least once, by email."""
+        return {email: account["id"] for email, account in self.user_accounts(emails).items()}
+
     def access_for(self, user_id: str, fresh: bool = False) -> dict | None:
         if not self.secret:
             return None

app/class_report.py

@@ -17,6 +17,7 @@ from fastapi import Depends, HTTPException
 from fastapi.responses import JSONResponse
 
 from .access import has_permission
+from .assignments import AssignmentsUnavailable, public as assignment_public
 from .answer_scans import ScanError
 from .auth import AuthUnavailable
 from .quiz_grades import sitting_view
@@ -46,7 +47,7 @@ def report_part(data: dict) -> dict:
             "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,
+            "seen": obj("seen"), "tries": obj("tries"), "examples": obj("examples"), "slips": items("slips")[-SLIPS_SENT:], "quizzes": quizzes, "uq": unit_quizzes,
             "updated": data.get("updated")}
 
 
@@ -67,6 +68,33 @@ def server_sittings(app, ids: dict[str, str]):
     return out
 
 
+def server_requests(app, ids: dict[str, str]):
+    """The students' open requests to look again at a checked answer (app/teacher_review.py), by email. None when
+    they cannot be read."""
+    try:
+        raw = app.state.answers.review(None, "requests", users=list(ids.values())) if ids else []
+    except ScanError as exc:
+        log.warning("review requests 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 row in raw:
+        if row.get("user_id") in email_of:
+            out[email_of[row["user_id"]]].append({k: row.get(k) for k in ("attempt_id", "message", "question", "created_at")})
+    return out
+
+
+def server_assignments(app, class_id: int):
+    """The class's assignments (the teacher's view of them), or None when they cannot be read."""
+    store = getattr(app.state, "assignments", None)
+    if store is None:
+        return None
+    try:
+        return [assignment_public(r, True) for r in store.for_classes([class_id])]
+    except AssignmentsUnavailable:
+        return None
+
+
 def install_class_report_routes(app, signed_in, units_of):
     def class_of(class_id: int, user) -> dict:
         try:
@@ -89,7 +117,8 @@ def install_class_report_routes(app, signed_in, units_of):
         students = [email for email in row.get("emails", ()) if email not in teachers]
         auth = app.state.auth
         try:
-            ids = auth.user_ids(students) if students else {}
+            accounts = auth.user_accounts(students) if students else {}
+            ids = {email: account["id"] for email, account in accounts.items()}
             rows = auth._admin(f"{TABLE}?select=user_id,data,updated_at&user_id=in.({','.join(ids.values())})") \
                 if ids else []
         except AuthUnavailable as exc:
@@ -97,13 +126,18 @@ def install_class_report_routes(app, signed_in, units_of):
             raise HTTPException(503, "report_unavailable") from exc
         by_id = {r["user_id"]: r for r in rows or []}
         sittings = server_sittings(app, ids)
+        requests = server_requests(app, ids)
+        nicknames = {str(k).lower(): str(v).strip() for k, v in (row.get("nicknames") or {}).items()}
         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,
+            name = nicknames.get(email) or accounts.get(email, {}).get("name") or None
+            out.append({"email": email, "name": name, "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,
-                        "quiz_sittings": None if sittings is None else sittings.get(email, [])})
+                        "quiz_sittings": None if sittings is None else sittings.get(email, []),
+                        "review_requests": [] if requests is None else requests.get(email, [])})
         return JSONResponse({"class": {"id": row["id"], "name": row["name"], "lessons": units_of(row)},
-                             "students": out}, headers={"Cache-Control": "no-store"})
+                             "students": out, "assignments": server_assignments(app, row["id"])},
+                            headers={"Cache-Control": "no-store"})

app/main.py

@@ -25,6 +25,8 @@ from .math_photo import (DAILY_PHOTOS, MAX_PHOTO, MEDIA_TYPES as PHOTO_TYPES,
                          PhotoSolver, PhotoUnavailable, math_model, photo_client)
 from .math_skills import algebra9, practice_graph
 from .class_report import install_class_report_routes
+from .teacher_review import install_teacher_review_routes
+from .assignments import install_assignment_routes
 from .progress import install_progress_routes
 from .push import install_push_routes
 from .monitoring import ActionLog, RETURN_GAP, install_monitoring_routes
@@ -297,7 +299,9 @@ def create_app(auth: SupabaseAuth | None = None) -> FastAPI:
     install_push_routes(app, signed_in)
     install_answer_routes(app, signed_in)
     install_ai_queue_routes(app, signed_in)
-    install_resource_routes(app, signed_in)
+    install_teacher_review_routes(app, signed_in)
+    install_assignment_routes(app, signed_in, units_of)
+    install_resource_routes(app, signed_in, units_of)
     install_science_routes(app)
     install_monitoring_routes(app, manager)
     return app

app/math_skills.py

@@ -10,6 +10,9 @@ The questions are written for the app, and every skill, link and mistake still n
 
 `problems` is run by the tests and on loading: a broken graph is refused before a student meets it.
 
+A skill may have a worked example (`example`: a question of its own, `steps` of {do, why}, and the `answer`) that the
+student can open when stuck. The examples are written in advance and reviewed by a teacher: students never call the AI.
+
 A unit may end with a summarizing quiz (`quiz`): open-ended questions answered on paper and photographed, a time limit
 in minutes, and points per question that add up to 100. Its questions are graded only after the quiz is handed in.
 """
@@ -110,6 +113,39 @@ def sample_problems(where: str, sid: str, sample: dict, listed: bool, mistakes:
     return out
 
 
+def example_problems(skill: dict) -> list[str]:
+    """A skill's worked example, if it has one: a question of its own solved in steps (what to do, and why), and the
+    answer. It must not be one of the skill's practice questions, or it would hand the student that question's answer."""
+    example = skill.get("example")
+    if example is None:
+        return []
+    where = f"{skill['id']} example"
+    if not isinstance(example, dict):
+        return [f"{where}: must be an object"]
+    text = lambda value: isinstance(value, str) and bool(value.strip())
+    out = []
+    if not text(example.get("question")):
+        out.append(f"{where}: question text is required")
+    if not text(example.get("answer")):
+        out.append(f"{where}: an answer is required")
+    steps = example.get("steps")
+    if not isinstance(steps, list) or not steps:
+        out.append(f"{where}: needs at least one step")
+    else:
+        out += [f"{where} step {n}: needs what to do (do) and why (why)" for n, step in enumerate(steps, 1)
+                if not isinstance(step, dict) or not text(step.get("do")) or not text(step.get("why"))]
+    squash = lambda value: " ".join(str(value).split())
+    if text(example.get("question")) and squash(example["question"]) in {squash(q.get("question", "")) for q in questions(skill)}:
+        out.append(f"{where}: repeats one of the skill's practice questions")
+    return out
+
+
+def skills_without_example(graph: dict) -> list[str]:
+    """The skills with multiple-choice questions that have no worked example yet (the coverage still to write)."""
+    return [s["id"] for s in graph["skills"]
+            if "example" not in s and all(q.get("type", "multiple-choice") == "multiple-choice" for q in questions(s))]
+
+
 def quiz_problems(unit: dict) -> list[str]:
     """A unit's summarizing quiz: a time limit, and open-ended questions whose points add up to 100."""
     quiz, where = unit["quiz"], f"{unit['id']} quiz"
@@ -181,6 +217,7 @@ def problems(graph: dict) -> list[str]:
         for n, sample in enumerate(questions(s), 1):
             out += sample_problems(f"{s['id']} question {n}" if listed else s["id"], s["id"], sample, listed,
                                    mistakes, below)
+        out += example_problems(s)
     out += [f"mistake {k}: unknown skill {m['back']}" for k, m in mistakes.items() if m["back"] and m["back"] not in skills]
     return out
 

app/quiz_grades.py

@@ -9,17 +9,21 @@ change it. Both the student's result screen and the class report use `sitting_vi
 from __future__ import annotations
 
 from .math_skills import algebra9
+from .teacher_review import effective_score
 
 
 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."""
+    """One question of a sitting: its points, what it earned (None while its check is open) and why. The teacher's
+    score, when they gave one, counts instead of the automatic check's (see app/teacher_review.py)."""
     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
+    done = attempt.get("grade_state") == "completed"
+    teacher = attempt.get("teacher_score")
+    score = effective_score(attempt.get("score") if done else None, teacher)
+    if score is not None and 0 <= score <= 100:
+        return {"points": points, "earned": int(points * score / 100 + 0.5),
+                "state": "teacher" if type(teacher) is int else "checked", "verdict": attempt.get("verdict")}
+    if done:   # 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"}
 

app/teacher_review.py

@@ -0,0 +1,147 @@
+"""The class teacher's review of a student's open answer, and the student's request to look again.
+
+An open answer (a photographed solution) is checked by the AI; this lets the class's teacher (or a manager) open any
+such answer of their students, give it a score of their own and write a comment. Where an answer's score is used, the
+teacher's score wins over the AI's (`effective_score`). The AI's check is never edited: the review is kept next to it
+(Supabase `math_teacher_reviews`), the latest review of an answer counts and the older ones stay as history.
+
+A student who disagrees with a check asks the teacher to look again (`math_review_requests`, at most one open per
+answer and five per student); saving a review closes the request.
+"""
+from __future__ import annotations
+
+import logging
+
+from fastapi import Depends
+from fastapi.responses import JSONResponse, Response
+
+from .access import students_of
+from .answer_scans import ScanError, public_result, uuid_text
+from .auth import AuthUnavailable
+
+log = logging.getLogger("mathly.teacher_review")
+MAX_COMMENT = 1000
+MAX_MESSAGE = 300
+
+
+def effective_score(check_score, teacher_score):
+    """The score an answer counts with: the teacher's when they gave one, else the automatic check's (or None)."""
+    return teacher_score if type(teacher_score) is int else check_score if type(check_score) is int else None
+
+
+def clean_review(body) -> tuple[int | None, str]:
+    """The score and comment of a review as sent; ScanError when neither is given or either is out of range."""
+    body = body if isinstance(body, dict) else {}
+    score, comment = body.get("score"), body.get("comment")
+    if score is not None and (type(score) is not int or not 0 <= score <= 100):
+        raise ScanError(400, "invalid_score")
+    if comment is not None and not isinstance(comment, str):
+        raise ScanError(400, "invalid_comment")
+    comment = (comment or "").strip()
+    if len(comment) > MAX_COMMENT:
+        raise ScanError(400, "comment_too_long")
+    if score is None and not comment:
+        raise ScanError(400, "empty_review")
+    return score, comment
+
+
+def for_student(review: dict | None) -> dict | None:
+    """A review as the student's page reads it: no teacher email."""
+    if not review:
+        return None
+    return {k: review.get(k) for k in ("score", "comment", "created_at")}
+
+
+def request_for_student(request: dict | None) -> dict | None:
+    if not request:
+        return None
+    return {k: request.get(k) for k in ("id", "message", "state", "created_at", "closed_at")}
+
+
+def install_teacher_review_routes(app, signed_in):
+    def students(user: dict) -> set[str] | None:
+        try:
+            return students_of(user, app.state.auth.classes())
+        except AuthUnavailable as exc:
+            raise ScanError(503, "review_unavailable") from exc
+
+    def teacher(user=Depends(signed_in)) -> dict:
+        """A class teacher, or a manager."""
+        if not user or not user.get("id"):
+            raise ScanError(401, "sign_in_required")
+        if not app.state.answers.configured:
+            raise ScanError(503, "answer_storage_unavailable")
+        if students(user) == set():   # a teacher with no class has no one to review
+            raise ScanError(403, "teacher_required")
+        return user
+
+    def email_of(user_id: str) -> str:
+        try:
+            return app.state.auth.user_email(user_id)
+        except AuthUnavailable as exc:
+            raise ScanError(503, "review_unavailable") from exc
+
+    def owned(user: dict, attempt_id: str) -> tuple[str, str, str]:
+        """(attempt id, the student's account id, their email) of an answer this teacher may review."""
+        aid = uuid_text(attempt_id)
+        owner = app.state.answers.review(None, "owner", attempt_id=aid)
+        email = email_of(owner)
+        allowed = students(user)
+        if allowed is not None and email not in allowed:
+            raise ScanError(403, "forbidden")
+        return aid, owner, email
+
+    def reply(value, status=200):
+        return JSONResponse(value, status_code=status, headers={"Cache-Control": "no-store"})
+
+    @app.get("/api/teacher/answers/{attempt_id}")
+    def open_answer(attempt_id: str, user=Depends(teacher)):
+        aid, owner, email = owned(user, attempt_id)
+        found = app.state.answers.action(owner, "get", attempt_id=aid)
+        if not found.get("attachment"):
+            raise ScanError(409, "answer_required")
+        grading = app.state.answers.grade(owner, "get", attempt_id=aid)
+        marks = app.state.answers.review(owner, "get", attempt_id=aid)
+        shown = public_result({"attempt": found["attempt"], "attachment": found["attachment"], "grading": grading})
+        check = (grading or {}).get("result") if (grading or {}).get("state") == "completed" else None
+        return reply({**shown, "student": {"email": email}, "review": marks["review"], "request": marks["request"],
+                      "effective_score": effective_score((check or {}).get("score"), (marks["review"] or {}).get("score"))})
+
+    @app.get("/api/teacher/answers/{attempt_id}/image")
+    def answer_image(attempt_id: str, user=Depends(teacher)):
+        aid, owner, _email = owned(user, attempt_id)
+        found = app.state.answers.action(owner, "get", attempt_id=aid)
+        if not found.get("attachment"):
+            raise ScanError(404, "not_found")
+        data = app.state.answers.read(found["attachment"]["object_key"])
+        return Response(data, media_type="image/jpeg",
+                        headers={"Cache-Control": "no-store", "X-Content-Type-Options": "nosniff"})
+
+    @app.put("/api/teacher/answers/{attempt_id}/review")
+    def save_review(attempt_id: str, body: dict, user=Depends(teacher)):
+        score, comment = clean_review(body)
+        aid, owner, email = owned(user, attempt_id)
+        marks = app.state.answers.review(owner, "review", attempt_id=aid, reviewer=user.get("email", ""),
+                                         score=score, comment=comment)
+        actions = getattr(app.state, "actions", None)
+        if actions is not None:
+            actions.record(user, "answer_reviewed", email)
+        return reply(marks)
+
+    @app.get("/api/teacher/review-requests")
+    def review_requests(user=Depends(teacher)):
+        """Open requests to look again from this teacher's students (a manager: everyone's)."""
+        allowed = students(user)
+        try:
+            if allowed is None:
+                rows, emails = app.state.answers.review(None, "requests"), {}
+            else:
+                accounts = app.state.auth.user_accounts(sorted(allowed))
+                emails = {account["id"]: email for email, account in accounts.items()}
+                rows = app.state.answers.review(None, "requests", users=list(emails))
+        except AuthUnavailable as exc:
+            raise ScanError(503, "review_unavailable") from exc
+        for row in rows:
+            row["student"] = emails.get(row["user_id"]) or email_of(row["user_id"])
+            del row["user_id"]
+        return reply({"requests": rows})

app/unit_resources.py

@@ -2,6 +2,10 @@
 
 Rows live in `math_unit_resources`, images in the private `mathly-resources` bucket. Only the backend, with the
 service key, reads or writes either; teachers reach them through `/api/math/units/.../resources`.
+
+A resource is hidden from students until its teacher marks it visible (`visible`; a theory explanation starts visible,
+an exercise or a note starts hidden). Students see the visible resources of the units open to their class, through
+`/api/math/units/.../student-resources`, and never the teacher's email.
 """
 from __future__ import annotations
 
@@ -27,7 +31,8 @@ MAX_NOTE = 200
 
 
 class ResourceUnavailable(RuntimeError):
-    pass
+    """The storage did not answer. `no_visible_column`: the answer was that the visible column is not there yet."""
+    no_visible_column = False
 
 
 class UnitResources:
@@ -51,6 +56,14 @@ class UnitResources:
         try:
             with urllib.request.urlopen(req, timeout=30) as response:
                 return response.read()
+        except urllib.error.HTTPError as exc:
+            log.warning("resource storage failed: %s", exc.code)
+            failure = ResourceUnavailable("resource storage unavailable")
+            try:
+                failure.no_visible_column = exc.code == 400 and b"visible" in exc.read()   # the migration is not applied
+            except OSError:
+                pass
+            raise failure from exc
         except (urllib.error.URLError, TimeoutError, OSError) as exc:
             # Never pass SQL, keys or storage paths on to the browser.
             log.warning("resource storage failed: %s", getattr(exc, "code", type(exc).__name__))
@@ -70,7 +83,17 @@ class UnitResources:
         return rows[0] if rows else None
 
     def add(self, row: dict) -> dict:
-        return self._rows("/rest/v1/math_unit_resources", "POST", row)[0]
+        try:
+            return self._rows("/rest/v1/math_unit_resources", "POST", row)[0]
+        except ResourceUnavailable as exc:
+            if not exc.no_visible_column:
+                raise
+            log.warning("the visible column is missing; apply supabase/migrations/20261104180000_math_resources_visible.sql")
+            return self._rows("/rest/v1/math_unit_resources", "POST", {k: v for k, v in row.items() if k != "visible"})[0]
+
+    def set_visible(self, resource_id: str, visible: bool) -> dict | None:
+        rows = self._rows(f"/rest/v1/math_unit_resources?id=eq.{resource_id}", "PATCH", {"visible": visible})
+        return rows[0] if rows else None
 
     def remove(self, resource_id: str) -> None:
         self._rows(f"/rest/v1/math_unit_resources?id=eq.{resource_id}", "DELETE")
@@ -88,9 +111,21 @@ class UnitResources:
 
 
 def public(row: dict) -> dict:
-    """A resource as the browser sees it: no storage path."""
-    return {key: row.get(key) for key in ("id", "unit_id", "kind", "note", "skill_id", "created_email", "created_at",
-                                          "created_by")}
+    """A resource as a teacher's browser sees it: no storage path."""
+    return {**{key: row.get(key) for key in ("id", "unit_id", "kind", "note", "skill_id", "created_email", "created_at",
+                                             "created_by")}, "visible": bool(row.get("visible"))}
+
+
+def for_student(row: dict) -> dict:
+    """A resource as a student's browser sees it: no storage path and no teacher."""
+    return {key: row.get(key) for key in ("id", "unit_id", "kind", "note", "skill_id", "created_at")}
+
+
+def wants_visible(value: str | None, kind: str) -> bool:
+    """The upload form's visibility: what it says, else a theory explanation shows and anything else stays hidden."""
+    if value is None or not value.strip():
+        return kind == "theory"
+    return value.strip().lower() in ("1", "true", "on", "yes")
 
 
 def resource_id(value: str) -> str:
@@ -100,7 +135,7 @@ def resource_id(value: str) -> str:
         raise HTTPException(404, "resource not found") from exc
 
 
-def install_resource_routes(app, signed_in):
+def install_resource_routes(app, signed_in, units_of=None):
     if not hasattr(app.state, "resources"):
         app.state.resources = UnitResources(app.state.auth)
 
@@ -133,7 +168,8 @@ def install_resource_routes(app, signed_in):
 
     @app.post("/api/math/units/{unit_id}/resources")
     async def add_resource(unit_id: str, photo: UploadFile = File(...), kind: str = Form(...),
-                           note: str = Form(""), skill: str = Form(""), user: dict = Depends(teacher)):
+                           note: str = Form(""), skill: str = Form(""), visible: str | None = Form(None),
+                           user: dict = Depends(teacher)):
         unit = unit_of(unit_id)
         if kind not in KINDS:
             raise HTTPException(400, "choose what the photo shows")
@@ -155,7 +191,8 @@ def install_resource_routes(app, signed_in):
         try:
             row = await storage(app.state.resources.add, {
                 "unit_id": unit_id, "kind": kind, "note": note, "skill_id": skill or None, "object_key": key,
-                "byte_size": len(image), "created_by": user["id"], "created_email": user.get("email", "")})
+                "byte_size": len(image), "created_by": user["id"], "created_email": user.get("email", ""),
+                "visible": wants_visible(visible, kind)})
         except HTTPException:
             try:
                 await run_in_threadpool(app.state.resources.delete, key)
@@ -174,6 +211,49 @@ def install_resource_routes(app, signed_in):
         return Response(await storage(app.state.resources.read, row["object_key"]), media_type="image/jpeg",
                         headers={"Cache-Control": "private, max-age=3600", "X-Content-Type-Options": "nosniff"})
 
+    @app.patch("/api/math/resources/{rid}")
+    async def change_resource(rid: str, body: dict, user: dict = Depends(teacher)):
+        """Shows a resource to students or hides it again: its teacher, or a manager."""
+        if type(body.get("visible")) is not bool:
+            raise HTTPException(400, "send {\"visible\": true or false}")
+        row = await storage(app.state.resources.get, resource_id(rid))
+        if not row:
+            raise HTTPException(404, "resource not found")
+        if row.get("created_by") != user["id"] and not has_permission(user, "management.access"):
+            raise HTTPException(403, "only the teacher who added it can change it")
+        changed = await storage(app.state.resources.set_visible, row["id"], body["visible"])
+        return JSONResponse(public(changed or {**row, "visible": body["visible"]}), headers={"Cache-Control": "no-store"})
+
+    # ---- the students: the visible resources of the units open to their class
+    def student(user=Depends(signed_in)) -> dict:
+        if not user or not user.get("id"):
+            raise HTTPException(401, "sign in required")
+        if not app.state.resources.configured:
+            raise HTTPException(503, "resource storage is not configured")
+        return user
+
+    def open_to(user: dict, unit_id: str) -> bool:
+        """Whether the unit is one of the account's class units; with no class (none configured), every unit."""
+        classes = user.get("classes") or []
+        return not classes or not units_of or unit_id in {u for row in classes for u in units_of(row)}
+
+    @app.get("/api/math/units/{unit_id}/student-resources")
+    async def student_resources(unit_id: str, user: dict = Depends(student)):
+        unit_of(unit_id)
+        if not open_to(user, unit_id):
+            raise HTTPException(404, "unit not found")
+        rows = await storage(app.state.resources.list, unit_id)
+        return JSONResponse({"resources": [for_student(r) for r in rows if r.get("visible")]},
+                            headers={"Cache-Control": "no-store"})
+
+    @app.get("/api/math/student-resources/{rid}/image")
+    async def student_resource_image(rid: str, user: dict = Depends(student)):
+        row = await storage(app.state.resources.get, resource_id(rid))
+        if not row or not row.get("visible") or not open_to(user, row["unit_id"]):
+            raise HTTPException(404, "resource not found")   # hidden, or of another class: as if it did not exist
+        return Response(await storage(app.state.resources.read, row["object_key"]), media_type="image/jpeg",
+                        headers={"Cache-Control": "private, max-age=300", "X-Content-Type-Options": "nosniff"})
+
     @app.delete("/api/math/resources/{rid}")
     async def delete_resource(rid: str, user: dict = Depends(teacher)):
         row = await storage(app.state.resources.get, resource_id(rid))

openspec/changes/add-class-assignments/tasks.md

@@ -2,26 +2,26 @@
 
 ## 1. Storage and routes
 
-- [ ] 1.1 Add migration `<ts>_math_assignments.sql` (`math_assignments`, cascade on class delete, service-only). Verify it applies on the test database and deleting a class removes its assignments.
-- [ ] 1.2 Add `app/assignments.py` with teacher CRUD routes, item validation against the skills data and the class's units, and the class-teacher-or-manager rule. Verify in `tests/test_assignments.py`: create, foreign unit rejected, empty items rejected, other teacher 403, student 403, edit, delete.
-- [ ] 1.3 Add `GET /api/math/assignments` for students (their classes' assignments in range, plus their unit-quiz sitting times). Verify a student in two classes gets both classes' assignments and none from other classes.
+- [x] 1.1 Add migration `<ts>_math_assignments.sql` (`math_assignments`, cascade on class delete, service-only). Verify it applies on the test database and deleting a class removes its assignments.
+- [x] 1.2 Add `app/assignments.py` with teacher CRUD routes, item validation against the skills data and the class's units, and the class-teacher-or-manager rule. Verify in `tests/test_assignments.py`: create, foreign unit rejected, empty items rejected, other teacher 403, student 403, edit, delete.
+- [x] 1.3 Add `GET /api/math/assignments` for students (their classes' assignments in range, plus their unit-quiz sitting times). Verify a student in two classes gets both classes' assignments and none from other classes.
 
 ## 2. Completion
 
-- [ ] 2.1 Add `assignmentState` in `static/math.js` implementing the completion rules (skill any time, unit quiz after creation, exam covering all units after creation, late after the Jerusalem end of the due date). Verify with a browser unit test on fixed fixtures for each scenario in the spec.
+- [x] 2.1 Add `assignmentState` in `static/math.js` implementing the completion rules (skill any time, unit quiz after creation, exam covering all units after creation, late after the Jerusalem end of the due date). Verify with a browser unit test on fixed fixtures for each scenario in the spec.
 
 ## 3. Student UI
 
-- [ ] 3.1 Add the "משימות מהמורה" home card (open, late, done list for 14 days, continue button to the next item). Verify with a browser test for open, late and next-item navigation.
-- [ ] 3.2 Mark assigned skills on the path with an accessible label. Verify in the browser test.
+- [x] 3.1 Add the "משימות מהמורה" home card (open, late, done list for 14 days, continue button to the next item). Verify with a browser test for open, late and next-item navigation.
+- [x] 3.2 Mark assigned skills on the path with an accessible label. Verify in the browser test.
 
 ## 4. Teacher UI
 
-- [ ] 4.1 Add the create/edit form (title, note, due date, item pickers limited to class units) and delete with a confirmation that names how many students started. Verify with a browser test that creates and edits an assignment.
-- [ ] 4.2 Add the report's "משימות" tab with per-assignment counts and per-student item states. Verify with a browser test on a 3-student fixture.
-- [ ] 4.3 Add the overdue-assignment signal to the "needs attention" list (if `add-class-attention-view` is in place). Verify in the report browser test.
-- [ ] 4.4 Update `static/guide.js` (student: "משימות מהמורה"; teacher: creating and following assignments) and `README.md` (feature and migration). Verify `tests/test_guide_browser.py` passes.
+- [x] 4.1 Add the create/edit form (title, note, due date, item pickers limited to class units) and delete with a confirmation that names how many students started. Verify with a browser test that creates and edits an assignment.
+- [x] 4.2 Add the report's "משימות" tab with per-assignment counts and per-student item states. Verify with a browser test on a 3-student fixture.
+- [x] 4.3 Add the overdue-assignment signal to the "needs attention" list (if `add-class-attention-view` is in place). Verify in the report browser test.
+- [x] 4.4 Update `static/guide.js` (student: "משימות מהמורה"; teacher: creating and following assignments) and `README.md` (feature and migration). Verify `tests/test_guide_browser.py` passes.
 
 ## 5. Integration
 
-- [ ] 5.1 Run the full `pytest` suite and check locally end to end: the teacher assigns two skills and a unit quiz, a student completes them, and the report shows the student as done.
+- [x] 5.1 Run the full `pytest` suite and check locally end to end: the teacher assigns two skills and a unit quiz, a student completes them, and the report shows the student as done.

openspec/changes/add-class-attention-view/tasks.md

@@ -2,24 +2,24 @@
 
 ## 1. Report data
 
-- [ ] 1.1 In `app/class_report.py`, add `seen` and `tries` to `report_part`. Verify in `tests/test_class_report.py` that both are returned and non-object values are dropped.
-- [ ] 1.2 Return each student's display name (class nickname, else Google full name, else null) from the report, extending `app/auth.py` `user_ids` to collect `user_metadata` names. Verify with a test using a fake admin user list with and without names.
+- [x] 1.1 In `app/class_report.py`, add `seen` and `tries` to `report_part`. Verify in `tests/test_class_report.py` that both are returned and non-object values are dropped.
+- [x] 1.2 Return each student's display name (class nickname, else Google full name, else null) from the report, extending `app/auth.py` `user_ids` to collect `user_metadata` names. Verify with a test using a fake admin user list with and without names.
 
 ## 2. Needs-attention section
 
-- [ ] 2.1 Add the attention constants and a pure `attentionOf(student, units, now)` in `static/math.js` returning a list of reasons. Verify with a browser test (pattern of `tests/test_sky_browser.py`) feeding fixed progress objects for each signal, including the "small numbers are not a drop" case.
-- [ ] 2.2 Render the "דורשים תשומת לב" section at the top of the report, with the empty-state text, and each student's reasons linking to their card. Verify with a browser test of the report sheet.
-- [ ] 2.3 Show weekly activity (this week / last week) on each card. Verify in the same browser test with known `days`.
+- [x] 2.1 Add the attention constants and a pure `attentionOf(student, units, now)` in `static/math.js` returning a list of reasons. Verify with a browser test (pattern of `tests/test_sky_browser.py`) feeding fixed progress objects for each signal, including the "small numbers are not a drop" case.
+- [x] 2.2 Render the "דורשים תשומת לב" section at the top of the report, with the empty-state text, and each student's reasons linking to their card. Verify with a browser test of the report sheet.
+- [x] 2.3 Show weekly activity (this week / last week) on each card. Verify in the same browser test with known `days`.
 
 ## 3. Grid and sorting
 
-- [ ] 3.1 Add list/grid tabs, the unit picker, the per-skill grid using `MathlySky.star` states, the column counts and the class-difficulty mark. Verify with a browser test on a 3-student fixture, checking cell states and the marked column.
-- [ ] 3.2 Add the units overview. Verify finished/total per unit in the browser test.
-- [ ] 3.3 Add the sort control (attention, name, progress, last activity), saved in `localStorage` with try/catch. Verify order changes in the browser test.
-- [ ] 3.4 Use display names everywhere in the report, with the full email kept in the card. Verify in the browser test.
-- [ ] 3.5 Add CSS for the grid with a sticky name column and sideways scrolling inside its box. Verify at 375 px width in Playwright that the page itself has no horizontal scroll.
+- [x] 3.1 Add list/grid tabs, the unit picker, the per-skill grid using `MathlySky.star` states, the column counts and the class-difficulty mark. Verify with a browser test on a 3-student fixture, checking cell states and the marked column.
+- [x] 3.2 Add the units overview. Verify finished/total per unit in the browser test.
+- [x] 3.3 Add the sort control (attention, name, progress, last activity), saved in `localStorage` with try/catch. Verify order changes in the browser test.
+- [x] 3.4 Use display names everywhere in the report, with the full email kept in the card. Verify in the browser test.
+- [x] 3.5 Add CSS for the grid with a sticky name column and sideways scrolling inside its box. Verify at 375 px width in Playwright that the page itself has no horizontal scroll.
 
 ## 4. Docs and integration
 
-- [ ] 4.1 Update the "דוח הכיתה" section of the teacher tab in `static/guide.js` and the class-teacher section of `README.md`. Verify `tests/test_guide_browser.py` passes.
+- [x] 4.1 Update the "דוח הכיתה" section of the teacher tab in `static/guide.js` and the class-teacher section of `README.md`. Verify `tests/test_guide_browser.py` passes.
 - [ ] 4.2 Run the full `pytest` suite and open the report for a real class locally to check the attention list against the cards.

openspec/changes/add-student-hints-and-resources/tasks.md

@@ -2,28 +2,28 @@
 
 ## 1. Worked example content
 
-- [ ] 1.1 Add `example` validation to `app/math_skills.py` (own question, at least one step with `do`/`why`, `answer`) and send it in the skills API. Verify in `tests/test_math_skills.py` with a valid example and one that copies a practice question.
-- [ ] 1.2 Write a one-off drafting script under `scripts/` that proposes examples for skills without one, writing to a review file, not to the data file. Verify it runs on one unit and produces well-formed drafts.
+- [x] 1.1 Add `example` validation to `app/math_skills.py` (own question, at least one step with `do`/`why`, `answer`) and send it in the skills API. Verify in `tests/test_math_skills.py` with a valid example and one that copies a practice question.
+- [x] 1.2 Write a one-off drafting script under `scripts/` that proposes examples for skills without one, writing to a review file, not to the data file. Verify it runs on one unit and produces well-formed drafts.
 - [ ] 1.3 Add reviewed examples to `app/math_algebra9.json`, unit by unit, each one approved by a math teacher. Verify the validation test passes and the coverage test lists the skills still missing one.
 
 ## 2. Help in practice
 
-- [ ] 2.1 In `static/math.js`, offer "איך פותרים? דוגמה פתורה" from the second wrong answer in the round, and show the example inside the sheet with a return to the same question. Verify with a browser test: no offer after one mistake, offer after two, same question after closing.
-- [ ] 2.2 Add the "?" help panel in the skill sheet (description, example, teacher explanations for the skill). Verify in the browser test.
-- [ ] 2.3 Record `P.examples[id]` (count and last) and merge it across devices in `mergeProgress`. Add it to `ensure` in `static/math-sky.js`. Verify with a browser test that finishing and gold are unchanged by opening the example, and with a merge test.
+- [x] 2.1 In `static/math.js`, offer "איך פותרים? דוגמה פתורה" from the second wrong answer in the round, and show the example inside the sheet with a return to the same question. Verify with a browser test: no offer after one mistake, offer after two, same question after closing.
+- [x] 2.2 Add the "?" help panel in the skill sheet (description, example, teacher explanations for the skill). Verify in the browser test.
+- [x] 2.3 Record `P.examples[id]` (count and last) and merge it across devices in `mergeProgress`. Add it to `ensure` in `static/math-sky.js`. Verify with a browser test that finishing and gold are unchanged by opening the example, and with a merge test.
 
 ## 3. Resource visibility
 
-- [ ] 3.1 Add migration `<ts>_math_resources_visible.sql` (column `visible` default false). Verify it applies on the test database.
-- [ ] 3.2 In `app/unit_resources.py`, accept `visible` on upload and add `PATCH /api/math/resources/{rid}` with the owner-or-manager rule. Verify in `tests/test_unit_resources.py`: defaults by kind, owner can toggle, another teacher gets 403.
-- [ ] 3.3 Add the student routes (list and image) limited to visible resources of the student's open units, answering 404 otherwise. Verify the tests: hidden resource 404, unit not open 404 or empty, no `object_key` in the response.
-- [ ] 3.4 In the UI, add the visibility checkbox to the upload form, a toggle and a "visible" mark on each resource for teachers, and the "הסברים מהמורה" lists for students in the skill sheet and unit. Verify with browser tests for both roles.
+- [x] 3.1 Add migration `<ts>_math_resources_visible.sql` (column `visible` default false). Verify it applies on the test database.
+- [x] 3.2 In `app/unit_resources.py`, accept `visible` on upload and add `PATCH /api/math/resources/{rid}` with the owner-or-manager rule. Verify in `tests/test_unit_resources.py`: defaults by kind, owner can toggle, another teacher gets 403.
+- [x] 3.3 Add the student routes (list and image) limited to visible resources of the student's open units, answering 404 otherwise. Verify the tests: hidden resource 404, unit not open 404 or empty, no `object_key` in the response.
+- [x] 3.4 In the UI, add the visibility checkbox to the upload form, a toggle and a "visible" mark on each resource for teachers, and the "הסברים מהמורה" lists for students in the skill sheet and unit. Verify with browser tests for both roles.
 
 ## 4. Report and docs
 
-- [ ] 4.1 Add `examples` to `report_part` and show on the student's card the skills where an example was opened in the last 14 days. Verify in `tests/test_class_report.py` and the report browser test.
-- [ ] 4.2 Update `static/guide.js` (student: the help and teacher explanations; teacher: visibility of resources, replacing "בשלב זה המשאבים גלויים למורים בלבד") and `README.md`. Verify `tests/test_guide_browser.py` passes.
+- [x] 4.1 Add `examples` to `report_part` and show on the student's card the skills where an example was opened in the last 14 days. Verify in `tests/test_class_report.py` and the report browser test.
+- [x] 4.2 Update `static/guide.js` (student: the help and teacher explanations; teacher: visibility of resources, replacing "בשלב זה המשאבים גלויים למורים בלבד") and `README.md`. Verify `tests/test_guide_browser.py` passes.
 
 ## 5. Integration
 
-- [ ] 5.1 Run the full `pytest` suite and check locally, as a teacher and a student in the same class, that a theory photo uploaded by the teacher appears in the student's skill sheet.
+- [x] 5.1 Run the full `pytest` suite and check locally, as a teacher and a student in the same class, that a theory photo uploaded by the teacher appears in the student's skill sheet.

openspec/changes/add-teacher-grade-review/tasks.md

@@ -2,32 +2,32 @@
 
 ## 1. Storage and access rule
 
-- [ ] 1.1 Add migration `<ts>_math_teacher_reviews.sql`: `math_teacher_reviews`, `math_review_requests` (unique open request per attempt), and a service-only RPC that saves a review and closes the open request in one transaction. Verify it applies to the disposable test PostgreSQL and that a second open request on one attempt fails.
-- [ ] 1.2 Move the teacher→students rule (`watched`) out of `app/ai_queue.py` into a shared helper used by both modules. Verify `tests/test_ai_queue.py` still passes unchanged.
+- [x] 1.1 Add migration `<ts>_math_teacher_reviews.sql`: `math_teacher_reviews`, `math_review_requests` (unique open request per attempt), and a service-only RPC that saves a review and closes the open request in one transaction. Verify it applies to the disposable test PostgreSQL and that a second open request on one attempt fails.
+- [x] 1.2 Move the teacher→students rule (`watched`) out of `app/ai_queue.py` into a shared helper used by both modules. Verify `tests/test_ai_queue.py` still passes unchanged.
 
 ## 2. Teacher routes
 
-- [ ] 2.1 Add `app/teacher_review.py` with `GET /api/teacher/answers/{id}` and `/image`, checking the class-teacher rule. Verify in `tests/test_teacher_review.py`: class teacher allowed, other teacher 403, manager allowed, no image bytes on 403.
-- [ ] 2.2 Add `PUT /api/teacher/answers/{id}/review` with validation (score 0–100, comment ≤ 1000, not both empty). Verify the tests for correcting a score, grading an unreadable answer, the empty review and out-of-range values.
-- [ ] 2.3 Add `GET /api/teacher/review-requests`. Verify a request appears for its class teacher only and disappears after a review is saved.
+- [x] 2.1 Add `app/teacher_review.py` with `GET /api/teacher/answers/{id}` and `/image`, checking the class-teacher rule. Verify in `tests/test_teacher_review.py`: class teacher allowed, other teacher 403, manager allowed, no image bytes on 403.
+- [x] 2.2 Add `PUT /api/teacher/answers/{id}/review` with validation (score 0–100, comment ≤ 1000, not both empty). Verify the tests for correcting a score, grading an unreadable answer, the empty review and out-of-range values.
+- [x] 2.3 Add `GET /api/teacher/review-requests`. Verify a request appears for its class teacher only and disappears after a review is saved.
 
 ## 3. Grades use the teacher score
 
-- [ ] 3.1 Add `effective_score` and use it in the unit-quiz grade function from `add-server-quiz-grades` and in the attempt payload. Verify with a test where a 25-point question's AI 40 / teacher 80 contributes 20 points.
-- [ ] 3.2 In `static/math.js`, complete an open skill when the teacher score is 100. Verify with a browser test.
+- [x] 3.1 Add `effective_score` and use it in the unit-quiz grade function from `add-server-quiz-grades` and in the attempt payload. Verify with a test where a 25-point question's AI 40 / teacher 80 contributes 20 points.
+- [x] 3.2 In `static/math.js`, complete an open skill when the teacher score is 100. Verify with a browser test.
 
 ## 4. Student side
 
-- [ ] 4.1 Include `teacher_review` and `review_request` in the student's attempt read, and set `seen_at` when opened. Verify with tests.
-- [ ] 4.2 Add `POST /api/math/answer-attempts/{id}/review-request` (one open per answer, at most 5 open per student) and `GET /api/math/teacher-comments`. Verify tests for the duplicate and limit cases.
-- [ ] 4.3 Show "הערת המורה" with the teacher score above the AI feedback on quiz results and open skill answers, the "לבקש מהמורה לבדוק שוב" button with its message field, and the home notice. Verify with browser tests in `tests/test_answer_browser.py`.
+- [x] 4.1 Include `teacher_review` and `review_request` in the student's attempt read, and set `seen_at` when opened. Verify with tests.
+- [x] 4.2 Add `POST /api/math/answer-attempts/{id}/review-request` (one open per answer, at most 5 open per student) and `GET /api/math/teacher-comments`. Verify tests for the duplicate and limit cases.
+- [x] 4.3 Show "הערת המורה" with the teacher score above the AI feedback on quiz results and open skill answers, the "לבקש מהמורה לבדוק שוב" button with its message field, and the home notice. Verify with browser tests in `tests/test_answer_browser.py`.
 
 ## 5. Teacher UI
 
-- [ ] 5.1 Add the teacher's answer view (photo, question, AI check, review form, "100 completes the skill" hint), opened from the report's unit-quiz rows and from handled AI-queue rows. Verify with a browser test that saves a review and sees it in the report.
-- [ ] 5.2 Add the "בקשות לבדיקה חוזרת" tab in the AI queue sheet with a count on the header button. Verify with a browser test.
-- [ ] 5.3 Update both tabs of `static/guide.js` (the student "בדיקה דרך המורה" section and the teacher "תור AI"/"דוח הכיתה" sections) and `README.md`. Verify `tests/test_guide_browser.py` passes.
+- [x] 5.1 Add the teacher's answer view (photo, question, AI check, review form, "100 completes the skill" hint), opened from the report's unit-quiz rows and from handled AI-queue rows. Verify with a browser test that saves a review and sees it in the report.
+- [x] 5.2 Add the "בקשות לבדיקה חוזרת" tab in the AI queue sheet with a count on the header button. Verify with a browser test.
+- [x] 5.3 Update both tabs of `static/guide.js` (the student "בדיקה דרך המורה" section and the teacher "תור AI"/"דוח הכיתה" sections) and `README.md`. Verify `tests/test_guide_browser.py` passes.
 
 ## 6. Integration
 
-- [ ] 6.1 Run the full `pytest` suite and check end to end locally: student submits a quiz, the teacher sends it to the AI, the student disputes one answer, the teacher corrects it, and the student sees the new grade and comment.
+- [x] 6.1 Run the full `pytest` suite and check end to end locally: student submits a quiz, the teacher sends it to the AI, the student disputes one answer, the teacher corrects it, and the student sees the new grade and comment.

scripts/draft_examples.py

@@ -0,0 +1,190 @@
+#!/usr/bin/env python3
+"""Draft worked examples for the skills of a unit, for a math teacher to review, and merge the approved ones.
+
+The path shows a student who is stuck a worked example (`example` in app/math_algebra9.json): a question of its own,
+solved in steps (what to do, and why), and the answer. Students never call the AI, so the examples are written in
+advance. This script helps write them:
+
+  draft  asks Claude for one example per skill of a unit that has none, checks each against the same rules the app
+         loads the data with, and writes them to a REVIEW FILE. It never touches app/math_algebra9.json, and it
+         spends API money (one request per skill: use --dry-run to see what it would send).
+  merge  puts the drafts a teacher approved into app/math_algebra9.json. A draft is approved when its entry in the
+         review file has "approved": true and the teacher's name in "reviewed_by". The teacher may edit an example in
+         the review file first: what is merged is what the file says, after the app's own checks.
+
+    python scripts/draft_examples.py draft --unit t --dry-run
+    python scripts/draft_examples.py draft --unit t            # writes docs/example-drafts/t.json
+    (the teacher reads docs/example-drafts/t.json, fixes what is wrong, and marks the good ones approved)
+    python scripts/draft_examples.py merge docs/example-drafts/t.json
+
+Needs ANTHROPIC_API_KEY (or CLAUDE_API_KEY) for `draft`; MATH_MODEL picks the model, as for the rest of the app.
+"""
+from __future__ import annotations
+
+import argparse
+import json
+import os
+import sys
+from datetime import date
+from pathlib import Path
+
+ROOT = Path(__file__).resolve().parent.parent
+sys.path.insert(0, str(ROOT))
+
+from app.math_photo import PhotoUnavailable, failure_reason, math_model, photo_client   # noqa: E402
+from app.math_skills import GRAPH, algebra9, example_problems, problems, questions, skills_without_example   # noqa: E402
+
+DRAFTS_DIR = ROOT / "docs" / "example-drafts"
+STATUS = "טיוטה: עוד לא נבדקה על ידי מורה. סמנו approved ושם ב־reviewed_by רק אחרי שבדקתם את הדוגמה."
+EXAMPLE_SCHEMA = {   # Anthropic rejects numerical constraints in output schemas (minItems...): app.math_skills checks them
+    "type": "object", "additionalProperties": False, "required": ["question", "steps", "answer"],
+    "properties": {
+        "question": {"type": "string"},
+        "steps": {"type": "array", "items": {
+            "type": "object", "additionalProperties": False, "required": ["do", "why"],
+            "properties": {"do": {"type": "string"}, "why": {"type": "string"}}}},
+        "answer": {"type": "string"}}}
+SYSTEM = """אתם מורים למתמטיקה לכיתה ט׳ וכותבים דוגמה פתורה למיומנות אחת במסלול תרגול.
+תלמיד שנתקע יפתח את הדוגמה, ילמד ממנה את השיטה ויחזור לשאלות התרגול של המיומנות.
+כתבו שאלה חדשה משלכם באותה רמה ובאותו סגנון של שאלות התרגול. היא לא יכולה להיות אחת מהן, וגם לא אחת מהן עם שינוי קל של המספרים.
+פתרו אותה בשלבים קצרים (בין שלושה לשישה). בכל שלב: do הוא מה עושים ומה יוצא, ו־why הוא הסיבה, הרעיון שמאחורי הצעד,
+ולא חזרה על ה־do במילים אחרות. אם הטעויות הנפוצות שבהמשך רלוונטיות, הראו בשלב המתאים איך נמנעים מהן.
+בסוף כתבו את התשובה בקצרה, ובדקו אותה: חשבו כל שלב פעם נוספת לפני שאתם כותבים אותו.
+כתבו בעברית. נוסחאות בין סימני דולר, כמו בשאלות התרגול: $(x + 3)(x − 5)$. השתמשו במינוס ״−״ ובחזקה ״²״ כמו בהן.
+החזירו רק את הדוגמה במבנה שנדרש."""
+
+
+def skill_brief(skill: dict, mistakes: dict) -> dict:
+    """What the model sees of a skill: its description and practice questions with the right answer and the mistakes."""
+    out = []
+    for q in questions(skill):
+        right = next((c["text"] for c in q.get("choices", []) if c.get("correct")), "")
+        slips = [{"answer": c["text"], "mistake": mistakes[c["mistake"]]["name"], "tip": mistakes[c["mistake"]]["tip"]}
+                 for c in q.get("choices", []) if c.get("mistake") in mistakes]
+        out.append({"question": q.get("question", ""), "right_answer": right, "common_mistakes": slips})
+    return {"skill": skill["name"], "description": skill.get("description", ""), "practice_questions": out}
+
+
+def draft_one(client, model: str, skill: dict, mistakes: dict) -> dict:
+    """One example for a skill; raises PhotoUnavailable if the model could not give one."""
+    import anthropic
+    try:
+        response = client.messages.create(
+            model=model, max_tokens=8000, system=SYSTEM,
+            output_config={"effort": "high", "format": {"type": "json_schema", "schema": EXAMPLE_SCHEMA}},
+            messages=[{"role": "user", "content": json.dumps(skill_brief(skill, mistakes), ensure_ascii=False)}])
+    except anthropic.APIError as exc:
+        reason, detail = failure_reason(exc)
+        raise PhotoUnavailable(f"{reason}: {detail}", reason, detail) from exc
+    if response.stop_reason != "end_turn":
+        raise PhotoUnavailable(f"stop_reason={response.stop_reason}", "refused" if response.stop_reason == "refusal" else "incomplete")
+    try:
+        return json.loads(next(b.text for b in response.content if b.type == "text"))
+    except (ValueError, StopIteration) as exc:
+        raise PhotoUnavailable("the answer was not JSON", "bad_output") from exc
+
+
+def draft_unit(client, model: str, graph: dict, unit_id: str, only: list[str] | None = None, limit: int | None = None) -> dict:
+    """The review file's content for a unit: a draft (and what is wrong with it, if anything) per skill without one."""
+    wanted = [s for s in graph["skills"] if s["unit"] == unit_id and s["id"] in skills_without_example(graph)
+              and (not only or s["id"] in only)]
+    drafts = {}
+    for skill in wanted[:limit]:
+        entry = {"approved": False, "reviewed_by": "", "example": None, "problems": []}
+        try:
+            entry["example"] = draft_one(client, model, skill, graph["mistakes"])
+            entry["problems"] = example_problems({**skill, "example": entry["example"]})
+        except PhotoUnavailable as exc:
+            entry["problems"] = [f"no draft: {exc}"]
+        drafts[skill["id"]] = entry
+    return {"status": STATUS, "model": model, "unit": unit_id, "drafted": date.today().isoformat(), "drafts": drafts}
+
+
+def merge_approved(review: dict, graph: dict) -> tuple[dict, list[str], list[str]]:
+    """The graph with the approved drafts added, the ids merged, and why any others were left out."""
+    merged, skipped = [], []
+    skills = {s["id"]: s for s in graph["skills"]}
+    for sid, entry in review.get("drafts", {}).items():
+        if not entry.get("approved"):
+            skipped.append(f"{sid}: not approved")
+        elif not str(entry.get("reviewed_by") or "").strip():
+            skipped.append(f"{sid}: approved without the reviewer's name (reviewed_by)")
+        elif sid not in skills:
+            skipped.append(f"{sid}: no such skill")
+        elif "example" in skills[sid]:
+            skipped.append(f"{sid}: already has an example")
+        elif found := example_problems({**skills[sid], "example": entry.get("example")}):
+            skipped.append(f"{sid}: {'; '.join(found)}")
+        else:
+            skills[sid]["example"] = entry["example"]
+            merged.append(sid)
+    return graph, merged, skipped
+
+
+def cmd_draft(args) -> int:
+    graph = algebra9()
+    if not any(u["id"] == args.unit for u in graph["units"]):
+        print(f"no unit {args.unit}: " + ", ".join(u["id"] for u in graph["units"]), file=sys.stderr)
+        return 2
+    todo = [s for s in graph["skills"] if s["unit"] == args.unit and s["id"] in skills_without_example(graph)
+            and (not args.skill or s["id"] in args.skill)][:args.limit]
+    print(f"unit {args.unit}: {len(todo)} skills without an example: {', '.join(s['id'] for s in todo) or '-'}")
+    if args.dry_run or not todo:
+        if todo:
+            print("\nsystem prompt:\n" + SYSTEM + "\n\nfirst request:\n" +
+                  json.dumps(skill_brief(todo[0], graph["mistakes"]), ensure_ascii=False, indent=1))
+            print(f"\n(dry run: {len(todo)} requests would be sent to {math_model()})")
+        return 0
+    key = os.environ.get("ANTHROPIC_API_KEY", "").strip() or os.environ.get("CLAUDE_API_KEY", "").strip()
+    if not key:
+        print("set ANTHROPIC_API_KEY (or CLAUDE_API_KEY)", file=sys.stderr)
+        return 2
+    out = Path(args.out) if args.out else DRAFTS_DIR / f"{args.unit}.json"
+    if out.exists() and not args.force:
+        print(f"{out} exists: it may hold a teacher's review. Use --force to overwrite, or --out for another file.", file=sys.stderr)
+        return 2
+    review = draft_unit(photo_client(key), math_model(), graph, args.unit, args.skill, args.limit)
+    out.parent.mkdir(parents=True, exist_ok=True)
+    out.write_text(json.dumps(review, ensure_ascii=False, indent=1) + "\n", encoding="utf-8")
+    bad = [sid for sid, e in review["drafts"].items() if e["problems"]]
+    print(f"wrote {out}: {len(review['drafts'])} drafts, {len(bad)} with problems{': ' + ', '.join(bad) if bad else ''}")
+    return 0
+
+
+def cmd_merge(args) -> int:
+    review = json.loads(Path(args.review).read_text(encoding="utf-8"))
+    graph = json.loads(GRAPH.read_text(encoding="utf-8"))
+    graph, merged, skipped = merge_approved(review, graph)
+    for line in skipped:
+        print("left out: " + line)
+    if not merged:
+        print("nothing to merge")
+        return 1
+    if found := problems(graph):   # the app loads the file with this check: never write what it would refuse
+        print("refusing to write, the data would not load: " + "; ".join(found), file=sys.stderr)
+        return 2
+    GRAPH.write_text(json.dumps(graph, ensure_ascii=False, indent=1) + "\n", encoding="utf-8")
+    print(f"added examples to {GRAPH.name}: {', '.join(merged)}")
+    return 0
+
+
+def main(argv=None) -> int:
+    parser = argparse.ArgumentParser(description=__doc__.split("\n\n")[0])
+    sub = parser.add_subparsers(dest="command", required=True)
+    d = sub.add_parser("draft", help="ask Claude for drafts and write a review file")
+    d.add_argument("--unit", required=True)
+    d.add_argument("--skill", action="append", help="only this skill (repeat for several)")
+    d.add_argument("--limit", type=int, help="at most this many skills")
+    d.add_argument("--out", help="the review file (default docs/example-drafts/<unit>.json)")
+    d.add_argument("--force", action="store_true", help="overwrite an existing review file")
+    d.add_argument("--dry-run", action="store_true", help="show what would be sent; call nothing")
+    d.set_defaults(run=cmd_draft)
+    m = sub.add_parser("merge", help="add the approved drafts of a review file to app/math_algebra9.json")
+    m.add_argument("review")
+    m.set_defaults(run=cmd_merge)
+    args = parser.parse_args(argv)
+    return args.run(args)
+
+
+if __name__ == "__main__":
+    sys.exit(main())

static/answer-scans.js

@@ -4,7 +4,7 @@
 const esc=s=>String(s??"").replace(/[&<>"']/g,c=>({"&":"&amp;","<":"&lt;",">":"&gt;",'"':"&quot;","'":"&#39;"}[c]));
 const fmt=s=>esc(s).replace(/\$([^$]+)\$/g,'<span class="m">$1</span>');
 const states={waiting:"ממתינים לטלפון",confirmed:"ממתינים לטלפון",uploading:"מעלים את התשובה…",received:"התשובה התקבלה",failed:"ההעלאה נכשלה",expired:"בקשת הצילום פגה",superseded:"הבקשה הוחלפה",declined:"הבקשה נדחתה בטלפון"};
-const errors={expired:"בקשת הצילום פגה. צרו בקשה חדשה ונסו שוב.",superseded:"הבקשה הוחלפה. בחרו את הבקשה העדכנית.",upload_in_progress:"העלאה כבר מתבצעת. ממתינים לעדכון…",confirmation_required:"יש לאשר את בקשת הצילום תחילה.",invalid_upload:"ההעלאה הופסקה. נסו שוב.",question_changed:"השאלה השתנתה. רעננו את העמוד ופתחו אותה מחדש.",invalid_image:"לא ניתן לקרוא את התמונה. צלמו שוב.",image_too_large:"התמונה גדולה מדי. צלמו שוב.",unsupported_image:"בחרו תמונת JPEG, PNG או WebP.",answer_storage_unavailable:"שמירת תשובות אינה זמינה כרגע. נסו שוב מאוחר יותר.",sign_in_required:"יש להיכנס לאותו חשבון בשני המכשירים."};
+const errors={expired:"בקשת הצילום פגה. צרו בקשה חדשה ונסו שוב.",superseded:"הבקשה הוחלפה. בחרו את הבקשה העדכנית.",upload_in_progress:"העלאה כבר מתבצעת. ממתינים לעדכון…",confirmation_required:"יש לאשר את בקשת הצילום תחילה.",invalid_upload:"ההעלאה הופסקה. נסו שוב.",question_changed:"השאלה השתנתה. רעננו את העמוד ופתחו אותה מחדש.",invalid_image:"לא ניתן לקרוא את התמונה. צלמו שוב.",image_too_large:"התמונה גדולה מדי. צלמו שוב.",unsupported_image:"בחרו תמונת JPEG, PNG או WebP.",answer_storage_unavailable:"שמירת תשובות אינה זמינה כרגע. נסו שוב מאוחר יותר.",sign_in_required:"יש להיכנס לאותו חשבון בשני המכשירים.",review_limit:"יש כבר 5 בקשות פתוחות למורה. אפשר לבקש שוב אחרי שהמורה יענה.",message_too_long:"ההודעה ארוכה מדי (עד 300 תווים).",invalid_message:"ההודעה אינה תקינה.",answer_required:"צריך לצלם את התשובה קודם.",review_unavailable:"הבקשה למורה אינה זמינה כרגע. נסו שוב מאוחר יותר."};
 Object.assign(errors,{grading_unavailable:"בדיקת תשובות אינה זמינה כרגע באתר.",grading_failed:"הבדיקה נכשלה. התמונה נשמרה; אפשר לנסות שוב.",grading_interrupted:"הבדיקה הופסקה. אפשר לנסות שוב.",grading_limit:"הגעתם למכסת 20 הבדיקות היומית. נסו שוב מחר.",grading_busy:"כבר מתבצעות בדיקות בחשבון. נסו שוב בעוד רגע.",answer_required:"יש לצלם ולשלוח תשובה לפני הבדיקה.",queue_unavailable:"שליחת תשובות לבדיקת המורה אינה זמינה כרגע.",request_taken:"המורה כבר טיפל בבקשה. רעננו את העמוד."});
 /* Why an AI check failed (the server's `reason`, app/math_photo.py: failure_reason), for the people who can fix it:
    a teacher sending from the AI queue, or checking their own answer. Each is what happened and what to do. */
@@ -254,11 +254,11 @@ async function renderQuestion(q){
   // while the phone has the request, its code and progress are in the phone box itself (phoneLive)
   const statusText=checking?(q.grading&&queued?"שולחים למורה…":"בודקים את התשובה…"):waiting?"התשובה מחכה למורה":g?.state==="completed"?verdicts[g.result.verdict]:g?.state==="failed"?errors[g.error]||errors.grading_failed:!received&&phonePending(state)?"":states[state]||"כתבו את הפתרון על דף וצלמו אותו בטלפון.";
   // Rebuilding controls on every poll would steal focus and race a button click.
-  const signature=[state,s?.id,r.attachment?.id,g?.id,g?.state,r.grading_available,req?.id,req?.state].join(":");
+  const signature=[state,s?.id,r.attachment?.id,g?.id,g?.state,r.grading_available,req?.id,req?.state,r.teacher_review?.created_at,r.review_request?.id,r.review_request?.state].join(":");
   if(q.signature!==signature){
     q.signature=signature;
     q.node.innerHTML=`<small>ניסיון ${esc(r.attempt.id.slice(0,8))}</small><p role="status" aria-live="polite">${esc(statusText)}</p>
-      ${received?`<img class="mx-answer-image" alt="התשובה המצולמת שלכם" hidden>${gradingPanel(r,checking)}
+      ${received?`<img class="mx-answer-image" alt="התשובה המצולמת שלכם" hidden>${teacherNote(r)}${gradingPanel(r,checking)}${reviewBox(r.attempt.id,r)}
         <button class="mx-btn" data-new-attempt ${checking?"disabled":""}>ניסיון חדש וצילום מחדש</button>`:phoneLive(s,`data-request`,`data-cancel-scan`,!s?"צילום התשובה בטלפון":"בקשת צילום חדשה לטלפון")}`;
     if(!received){
       const say=t=>{const el=q.node.querySelector("[role=status]");if(el)el.textContent=t;};
@@ -283,9 +283,13 @@ async function renderQuestion(q){
       const gradeButton=q.node.querySelector("[data-grade]");
       if(gradeButton)gradeButton.onclick=()=>checkAnswer(q);
       q.node.querySelector("[data-new-attempt]").onclick=()=>mountQuestion(q.node,q.id,q.version,true);
+      const ask=q.node.querySelector("[data-ask-review]");
+      if(ask)ask.onclick=async()=>{const sent=await askReview(ask);if(sent&&current(q)){q.result={...q.result,review_request:sent};q.signature=[q.signature,"asked"].join(":");}};
     }
   }else q.node.querySelector("[role=status]").textContent=statusText;
   if(g?.state==="completed"&&q.notified!==g.id){q.notified=g.id;onGraded?.({questionId:q.id,grading:g});}
+  const t=r.teacher_review;   // the teacher's 100 counts like a correct check
+  if(t?.score===100&&q.notifiedTeacher!==t.created_at){q.notifiedTeacher=t.created_at;onGraded?.({questionId:q.id,grading:{id:"teacher:"+t.created_at,finished_at:t.created_at,result:{verdict:"correct",score:100}}});}
   if(received&&!q.image&&!q.loadingImage){
     q.loadingImage=true;
     try{
@@ -304,12 +308,38 @@ async function renderQuestion(q){
     q.autoStarted=true;checkAnswer(q,true);
   }
 }
+/* The teacher's review of the answer (its own score and comment), shown above the automatic check, and the student's
+   request to look again. Used by the answer panel here and by the unit quiz's result in math.js. */
+function teacherNote(r){
+  const t=r.teacher_review; if(!t)return "";
+  return `<section class="mx-teacher-note" aria-label="הערת המורה"><h4>הערת המורה${t.score==null?"":` · <span class="m">${esc(t.score)}/100</span>`}</h4>${t.comment?`<p>${esc(t.comment).replace(/\n/g,"<br>")}</p>`:""}</section>`;
+}
+function reviewBox(attemptId,r){
+  if(r.review_request?.state==="open")return '<p class="mx-small mx-ask-wait">ביקשתם מהמורה לבדוק שוב. הבקשה ממתינה.</p>';
+  if(r.grading?.state!=="completed")return "";   // only a checked answer can be questioned
+  return `<details class="mx-ask"><summary>לבקש מהמורה לבדוק שוב</summary>
+    <textarea maxlength="300" rows="2" data-ask-msg aria-label="הודעה למורה (לא חובה)" placeholder="מה לא נראה לכם בבדיקה? (לא חובה)"></textarea>
+    <button type="button" class="mx-btn" data-ask-review="${esc(attemptId)}">שליחה למורה</button></details>`;
+}
+// sends the request in the box the button is in; the box then says it waits
+async function askReview(button){
+  const box=button.closest(".mx-ask"),message=box.querySelector("[data-ask-msg]").value;
+  button.disabled=true;box.querySelector(".mx-ask-error")?.remove();
+  try{
+    const sent=await post(`/api/math/answer-attempts/${button.dataset.askReview}/review-request`,{message});
+    box.outerHTML='<p class="mx-small mx-ask-wait" role="status">ביקשתם מהמורה לבדוק שוב. הבקשה ממתינה.</p>';
+    return sent.review_request;
+  }catch(error){
+    button.disabled=false;box.insertAdjacentHTML("beforeend",`<p class="mx-small mx-ask-error" role="alert">${esc(error.message)}</p>`);
+    return null;
+  }
+}
 function gradingPanel(r,checking){
   const g=r.grading;
   if(g?.state==="completed"){
     const a=g.result;
     return `<section class="mx-grade ${a.verdict==="correct"?"mx-grade-correct":""}" aria-label="תוצאות בדיקת התשובה">
-      <h4>${esc(verdicts[a.verdict])}${a.score==null?"":` · <span class="m">${esc(a.score)}/100</span>`}</h4>
+      <h4>${r.teacher_review?"בדיקה אוטומטית: ":""}${esc(verdicts[a.verdict])}${a.score==null?"":` · <span class="m">${esc(a.score)}/100</span>`}</h4>
       <p>${fmt(a.feedback)}</p>${a.next_step?`<p><b>הצעד הבא: </b>${fmt(a.next_step)}</p>`:""}
       ${a.transcription?`<details><summary>מה קראנו בתמונה</summary><p>${fmt(a.transcription)}</p></details>`:""}
       ${a.solution?`<details><summary>הפתרון המלא</summary><p class="mx-grade-solution">${fmt(a.solution)}</p></details>`:""}
@@ -490,5 +520,5 @@ document.addEventListener("visibilitychange",()=>{
   if(question?.result)pollQuestion(question);
 });
 window.addEventListener("online",()=>{if(account&&inbox)pollInbox(epoch);if(question?.result)pollQuestion(question);});
-window.MathlyAnswers={errorDetails,configure,mountQuestion,closeQuestion,reset,phoneLive,forgetPush,pushButton,paintPush,togglePush};
+window.MathlyAnswers={errorDetails,teacherNote,reviewBox,askReview,configure,mountQuestion,closeQuestion,reset,phoneLive,forgetPush,pushButton,paintPush,togglePush};
 })();

static/guide.js

@@ -11,6 +11,17 @@ const STUDENT=[
     <li>הכוכב נדלק כשעונים נכון על כל השאלות, והופך ל<b>זהב</b> אחרי כמה תשובות נכונות ברצף בניסיון הראשון.</li>
     <li>כוכב שלא תרגלו שבועיים <b>דועך</b>. תשובה נכונה אחת מחזירה לו את האור.</li>
     <li>תשובה שגויה לא מגלה את התשובה הנכונה. השאלה תחזור אחרי האחרות, ואפשר לנסות שוב.</li></ul>`],
+  ["🆘","כשנתקעים: עזרה ודוגמה פתורה",`<p>הכפתור <b>?</b> בראש כל מיומנות פותח חלון עזרה מעל השאלה: ההסבר של המיומנות, <b>דוגמה פתורה</b> והסברים שהמורה שמר לה. הדוגמה היא שאלה אחרת מהשאלות שלכם, פתורה צעד אחרי צעד, עם הסבר למה עושים כל צעד. מחזירים <b>עוד צעד</b> בכל לחיצה, והתשובה מגיעה בסוף.</p>
+    <ul><li>אחרי <b>הטעות השנייה</b> בסבב של מיומנות מופיע גם הכפתור <b>איך פותרים? דוגמה פתורה</b>.</li>
+    <li>סוגרים את החלון וחוזרים לאותה שאלה בדיוק. הדוגמה לא מגלה את התשובה לשאלה שלכם.</li>
+    <li>פתיחת הדוגמה לא משנה את התנאים להשלמת המיומנות או לכוכב זהב: צריך עדיין תשובות נכונות ברצף בניסיון הראשון. המורה רואה אצלכם באילו מיומנויות פתחתם דוגמה, כדי לדעת איפה לעזור.</li>
+    <li>כשהמורה שמר תמונות של הסברים לשיעור, הן מופיעות תחת <b>הסברים מהמורה</b> במיומנות, בחלון העזרה ומתחת ליחידה במסלול.</li></ul>`],
+  ["📌","משימות מהמורה",`<p>המורה יכול לתת לכיתה <b>משימה</b>: מיומנויות לסיים, בוחן מסכם להגיש או מבחן תרגול, עד תאריך. בבית מופיע הכרטיס <b>משימות מהמורה</b> עם הכותרת, ההערה, התאריך, כמה פריטים הושלמו ורשימת הפריטים.</p>
+    <ul><li>הכפתור <b>להתחיל</b> או <b>להמשיך</b> פותח את הפריט הראשון שעוד לא הושלם: המיומנות, הבוחן המסכם או מבחן התרגול (עם היחידות שהמורה ביקש כבר מסומנות).</li>
+    <li>מיומנות נחשבת גם אם סיימתם אותה לפני שהמשימה נוצרה. בוחן מסכם ומבחן תרגול נחשבים רק אם הוגשו אחרי שהמשימה נוצרה, ומבחן התרגול צריך לכלול את כל היחידות שהמורה ביקש.</li>
+    <li>אחרי התאריך משימה שלא הושלמה מסומנת <b>באיחור</b>. עד סוף יום התאריך (לפי שעון ישראל) עדיין בזמן.</li>
+    <li>משימה שהושלמה עוברת לרשימה <b>הושלמו</b> ונשארת בה שבועיים אחרי התאריך.</li>
+    <li>מיומנויות שבמשימה פתוחה מסומנות במסלול בסיכה 📌.</li></ul>`],
   ["🔥","היעד היומי והרצף",`<p>היעד היומי הוא 5 תשובות נכונות. מי שמגיע אליו כל יום בונה <b>רצף</b>. לוחצים על הלהבה כדי לראות את לוח הרצף של החודש.</p>`],
   ["🔁","חזרה מעורבת ודפוסים שחוזרים",`<p><b>חזרה מעורבת</b> מופיעה בבית כשמיומנויות שכבר סיימתם צריכות חזרה: כמה שאלות מנושאים שונים, כדי שמה שלמדתם יישאר.</p>
     <p><b>דפוסים שחוזרים</b> מראה טעות שחוזרת אצלכם בכמה נושאים, ואיזו מיומנות כדאי לחזק כדי שהיא תיעלם.</p>`],
@@ -25,8 +36,9 @@ const STUDENT=[
     <li>אם המורה לא אישר, מופיעה ההערה שלו. אפשר לתקן ולשלוח שוב (<b>שליחה מחדש למורה</b>).</li>
     <li>בקשה לעזרה בתרגיל מצולם אפשר לבטל ב<b>ביטול הבקשה</b>.</li>
     <li>אפשר לחכות לכל היותר ל־5 בקשות בבת אחת.</li>
-    <li>הבדיקה האוטומטית יכולה לטעות: בדקו שהתמלול שמוצג תואם למה שכתבתם, ואם לא, הראו למורה.</li></ul>`],
-  ["✏️","לוח טיוטה",`<p>הכפתור <b>לוח</b> בכל שאלה פותח דף לכתיבה: עט, קו ישר, עיגול, נוסחה מוקלדת ומחק. בטלפון הלוח נפתח במסך מלא, ו<b>חזרה לשאלה</b> מחזיר. גוללים עם שתי אצבעות או עם כלי ההזזה (כף היד). כפתור הלוח עם הדף (<b>השאלה</b>) מעתיק את השאלה לראש הדף.</p>`],
+    <li>הבדיקה האוטומטית יכולה לטעות: בדקו שהתמלול שמוצג תואם למה שכתבתם. אם לא מסכימים עם הבדיקה, לוחצים על <b>לבקש מהמורה לבדוק שוב</b> בתשובה שנבדקה, ואפשר לכתוב למורה מה לא נראה נכון. אפשר לחכות לעד 5 תשובות בבת אחת.</li>
+    <li>המורה יכול לתת לתשובה <b>ציון משלו והערה</b>. הם מופיעים מעל הבדיקה האוטומטית, והציון של המורה הוא שנחשב בציון הבוחן. הציון האוטומטי נשאר מוצג לידו. כשהמורה הגיב, בבית מופיעה ההודעה <b>המורה הגיב על תשובה שלכם</b>.</li></ul>`],
+  ["✏️","לוח טיוטה",`<p>הכפתור <b>לוח</b> בכל שאלה פותח דף לכתיבה: עט, קו ישר, עיגול, זווית, נוסחה מוקלדת ומחק. עם כלי הזווית מצביעים על פינה שבה שני קווים נפגשים, לוחצים, וכותבים מה שבזווית: מספר, אות כמו α, β או γ (בכפתורים שליד, או כותבים alpha, beta, gamma), או ביטוי כמו β+90. מספר מקבל סימן מעלות. בכפתורי הקשתות מסמנים זווית בקשת כפולה או משולשת, כדי להראות זוויות שוות, או זווית ישרה בריבוע קטן. בטלפון הלוח נפתח במסך מלא, ו<b>חזרה לשאלה</b> מחזיר. גוללים עם שתי אצבעות או עם כלי ההזזה (כף היד). כפתור הלוח עם הדף (<b>השאלה</b>) מעתיק את השאלה לראש הדף.</p>`],
   ["🔔","התראות בטלפון",`<p>כשהמחשב מבקש צילום של תשובה, הטלפון יכול לקבל התראה גם כשהאפליקציה סגורה. מפעילים אותה בכפתור הפעמון. באייפון זה עובד רק מהאפליקציה שהוספה למסך הבית.</p>`],
   ["☄️","האוסף ושביטים",`<p>בלשונית <b>האוסף</b> רואים את כל הכוכבים וקבוצות הכוכבים שאספתם. לפעמים חולף על המסך שביט בזמן תרגול: מי שלוחץ עליו בזמן תופס אותו.</p>`],
   ["🚀","מדעים: חידות בהצבעה",`<p>המורה פותח הצבעה ומציג על הלוח <b>קוד בן 4 ספרות</b>. נכנסים לחידה, מקלידים את הקוד ב<b>הצטרפות להצבעה</b> ומצביעים. אפשר לשנות הצבעה עד שהמורה בודק.</p>`],
@@ -38,23 +50,36 @@ const TEACHER=[
     <li><b>שליחה ל-AI</b> מעביר את הבקשה לבדיקה, והתלמיד רואה את הציון והמשוב בעמוד שלו.</li>
     <li><b>דחייה</b> סוגרת את הבקשה, ואפשר לצרף הערה לתלמיד (למשל "התמונה מטושטשת, צלמו שוב").</li>
     <li>כשממתינות כמה בקשות, <b>שליחת כל הממתינות</b> שולח את כולן יחד. שליחה שנכשלה אפשר לנסות שוב.</li>
+    <li>בקשה שטופלה ושהיא בדיקת תשובה אפשר לפתוח שוב עם <b>פתיחת התשובה</b>, כדי לראות את התמונה והבדיקה ולתת ציון והערה.</li>
+    <li>בלשונית <b>בקשות לבדיקה חוזרת</b> מופיעים תלמידים שלא הסכימו עם בדיקה וביקשו שתסתכלו שוב, עם ההודעה שלהם. המספר על הכפתור כולל אותן.</li>
     <li>בקשות שטופלו נשארות ברשימה יממה. <b>רענון</b> טוען בקשות חדשות.</li></ul>
     <p>מורים ומנהלים שולחים את התשובות שלהם ישר ל-AI, בלי תור. מנהל רואה את הבקשות של כל הכיתות.</p>`],
-  ["📊","דוח הכיתה",`<p><b>הכיתה שלי</b> פותח דוח על כל תלמיד:</p>
+  ["📊","דוח הכיתה",`<p><b>הכיתה שלי</b> פותח את הדוח. בראשו מופיע <b>דורשים תשומת לב</b>: התלמידים שלא תרגלו 7 ימים או יותר, שנתקעו במיומנות (3 טעויות או יותר בשבועיים בלי לסיים אותה), שהתרגול שלהם ירד לפחות מחצי משבוע שעבר, שקיבלו ציון נמוך מ־55 בבוחן מסכם, או שעוד לא התחילו. ליד כל שם כתוב למה. לחיצה על שם פותחת את כרטיס התלמיד. התרגול של השבוע נספר מיום ראשון.</p>
+    <p>הכפתורים <b>רשימה</b> ו<b>טבלת מיומנויות</b> מחליפים תצוגה. בטבלה שורה לכל תלמיד ועמודה לכל מיומנות של יחידה שבוחרים (או לכל יחידה, ב"כל היחידות"): זהב, הושלמה, דועכת, מתרגל ועוד לא סיים, או לא התחיל. מתחת לכל עמודה כתוב כמה סיימו, וסימן ⚠ מציין מיומנות שלפחות שליש מהתלמידים מתרגלים ועוד לא סיימו, כדי לדעת מה לחזור עליו בכיתה. <b>מיון</b> מסדר את התלמידים לפי תשומת לב, שם, התקדמות או פעילות אחרונה, והבחירה נשמרת במכשיר. תלמידים מופיעים בשם שנקבע להם בכיתה, אחרת בשם חשבון Google, אחרת בתחילת כתובת הדוא״ל.</p>
+    <p><b>לתת ציון והערה לתשובה:</b> בכרטיס התלמיד, בטבלת הבוחן המסכם, <b>פתיחה</b> מציגה את תשובות הבוחן האחרון. בוחרים תשובה ורואים את השאלה, את התמונה ואת הבדיקה האוטומטית, וכותבים <b>ציון</b> (0 עד 100), <b>הערה</b> לתלמיד, או את שניהם. הציון שלכם מחליף את הציון האוטומטי בחישוב ציון הבוחן, ובתשובה פתוחה במסלול ציון 100 מסמן את המיומנות כהושלמה. אפשר לתת ציון גם לתשובה שה-AI לא הצליח לקרוא. הבדיקה האוטומטית עצמה לא משתנה ונשארת מוצגת לתלמיד. שמירה חדשה מחליפה את הקודמת. תלמיד שביקש שתסתכלו שוב מסומן בכרטיס, ושמירת בדיקה סוגרת את הבקשה.</p>
+    <p>בכרטיס של כל תלמיד:</p>
     <ul><li>המיומנויות שסיים ביחידות של הכיתה.</li>
     <li>הטעויות שחוזרות אצלו.</li>
-    <li>הציון ב<b>בוחן המסכם</b> של כל יחידה, ותוצאות <b>מבחני התרגול</b>.</li></ul>
+    <li>הציון ב<b>בוחן המסכם</b> של כל יחידה, ותוצאות <b>מבחני התרגול</b>.</li>
+    <li>כמה תשובות נכונות היו השבוע וכמה בשבוע שעבר.</li>
+    <li>באילו מיומנויות פתח דוגמה פתורה בשבועיים האחרונים: סימן שהוא נתקע שם.</li></ul>
     <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>
     <li>רק מי שהוסיף תמונה (או מנהל) יכול למחוק אותה.</li></ul>
-    <p>בשלב זה המשאבים גלויים למורים בלבד.</p>`],
+    <p><b>מה התלמידים רואים:</b> לכל תמונה יש תיבה <b>גלוי לתלמידים</b>. הסבר תיאורטי מסומן כגלוי כברירת מחדל, ותרגיל חדש או תמונה אחרת נשארים מוסתרים עד שתסמנו. אפשר לשנות בכל רגע עם <b>הצגה לתלמידים</b> או <b>הסתרה מהתלמידים</b> (רק מי שהוסיף את התמונה, או מנהל). תמונות שנוספו לפני העדכון מוסתרות. תלמידי הכיתה רואים את התמונות הגלויות של היחידות שנפתחו להם: תמונה שקשורה לנושא מופיעה במיומנות ובחלון העזרה שלה, והשאר ברשימה מתחת ליחידה. תרגיל שיהיה במבחן עדיף להשאיר מוסתר.</p>`],
   ["🚀","הצבעה כיתתית במדעים",`<p>במקצוע <b>מדעים</b> בוחרים חידה ולוחצים <b>פתיחת הצבעה לכיתה</b>. על המסך מופיע קוד בן 4 ספרות: מציגים אותו על הלוח והתלמידים מצטרפים איתו מהמכשירים שלהם.</p>
     <ul><li>ההצבעות מוסתרות עד שלוחצים <b>בדיקה</b>. הטיל משוגר עם התשובה שרוב הכיתה בחרה.</li>
     <li>בתיקו הטיל לא משוגר: התלמידים יכולים לשנות הצבעה, ובודקים שוב.</li>
     <li><b>לחידה הבאה</b> ממשיך באותה הצבעה.</li></ul>`],
+  ["📌","משימות לכיתה",`<p>בדוח הכיתה, בלשונית <b>משימות</b>, נותנים לכיתה משימה עם <b>משימה חדשה</b>: כותרת, הערה לתלמידים, תאריך להגשה ופריט אחד או יותר (עד 20): מיומנויות לסיים, בוחנים מסכמים להגשה ומבחן תרגול על יחידות שבוחרים. אפשר לבחור רק מהיחידות שנפתחו לכיתה.</p>
+    <ul><li>התלמידים רואים את המשימה בבית, והכפתור שבה מוביל לפריט הבא שלהם.</li>
+    <li>בכל משימה רואים כמה תלמידים סיימו, ו<b>מי עשה מה</b> פותח טבלה: לכל תלמיד ולכל פריט ✓, ✓ באיחור או –. סימן ? אומר שאי אפשר לבדוק כרגע בוחן מסכם.</li>
+    <li>תלמיד שלא סיים משימה אחרי התאריך מופיע ב<b>דורשים תשומת לב</b>.</li>
+    <li><b>עריכה</b> משנה כל דבר במשימה, וגם את התאריך. <b>מחיקה</b> שואלת קודם וכותבת כמה תלמידים כבר השלימו ממנה פריט.</li>
+    <li>מיומנות נחשבת גם אם התלמיד סיים אותה לפני שנתתם את המשימה. בוחן ומבחן תרגול נחשבים רק מהרגע שהמשימה נוצרה. נתוני המיומנויות והמבחנים מהמכשיר של התלמיד, והבוחן המסכם מהשרת.</li></ul>`],
   ["🗓️","מבחנים ותרגול לקראתם",`<p>לוח המבחנים של הכיתה מופיע לתלמידים במסך המקצועות ובמסלול. כשמבחן מתקרב, <b>מבחן התרגול</b> מכוון אליו ומציע את היחידות שנלמדו עד אז. כדאי להזכיר לתלמידים לעשות אותו בשבוע שלפני המבחן.</p>`],
   ["⚙️","ניהול (למנהלים)",`<p>הכפתור <b>ניהול</b> מופיע למי שיש לו הרשאה. שם יוצרים כיתות, מוסיפים תלמידים לפי כתובת דוא״ל (שורה לכל תלמיד), בוחרים יחידות ומקצועות, מגדירים לוח מבחנים ובוחרים את מורה הכיתה. כל כיתה פותחת לתלמידים שלה רק את היחידות שנבחרו לה. בלשונית המעקב רואים פעילות ושימוש.</p>`],
 ];

static/math-board.js

@@ -5,7 +5,9 @@
    as long as the page is open. Nothing is sent anywhere unless the student hands it in.
 
    Everything on the board is an element that can be moved or erased: a pen stroke (with a pen's pressure),
-   a straight line, a circle (dragged from the center), typed math (the math keyboard, static/board-math.js), and a
+   a straight line, a circle (dragged from the center), an angle's arc with its words (the angle tool: pointing at a
+   corner where two lines meet shows the arc; a click adds it and asks for its words, and a number gets a degree
+   sign), typed math (the math keyboard, static/board-math.js), and a
    copy of the question (its text and figures).
    Line ends and circle centers snap to the ends and centers already drawn, so a triangle closes neatly;
    lines that meet that way move together. The eraser removes the lines and circles it touches and cuts pen strokes;
@@ -21,7 +23,7 @@ const setOn=on=>{ try{ localStorage.setItem(PREF,on?"on":"off"); }catch{} };
 
 const INKS=[["#1B2140","שחור"],["#2563D9","כחול"],["#D3455B","אדום"]];
 const ERASERS=[[16,"קטן"],[40,"בינוני"],[90,"גדול"]];
-const TOOLS=[["move","הזזה"],["pen","עט"],["line","קו ישר"],["circle","עיגול"],["math","נוסחה"],["eraser","מחק"]];
+const TOOLS=[["move","הזזה"],["pen","עט"],["line","קו ישר"],["circle","עיגול"],["angle","זווית"],["math","נוסחה"],["eraser","מחק"]];
 /* one line-drawn icon set (24×24, the button's text colour), so every button looks alike on every device and
    follows the button's hover and pressed colours; "flip" icons point the other way in a right-to-left page */
 const DOT='fill="currentColor" stroke="none"';
@@ -30,6 +32,7 @@ const ICONS={
   pen:'<path d="M4 20l1.2-4.2L16.5 4.5a2.1 2.1 0 0 1 3 3L8.2 18.8z"/><path d="M14.5 6.5l3 3"/>',
   line:`<path d="M6 18L18 6"/><circle cx="6" cy="18" r="2" ${DOT}/><circle cx="18" cy="6" r="2" ${DOT}/>`,
   circle:`<circle cx="12" cy="12" r="8"/><circle cx="12" cy="12" r="1.6" ${DOT}/>`,
+  angle:'<path d="M20 19H4l11-14"/><path d="M10.5 19a6.5 6.5 0 0 0-2.5-5.1"/>',
   math:'<path d="M17.5 5.5V4H6.5l6 8-6 8h11v-1.5"/>',
   eraser:'<path d="M20 20H9.5M4.6 15.4l9.8-9.8a2 2 0 0 1 2.8 0l2.2 2.2a2 2 0 0 1 0 2.8L11 19H8.2l-3.6-3.6"/><path d="M9.5 10.5l5 5"/>',
   question:'<rect x="5.5" y="5" width="13" height="16" rx="2"/><path d="M9 5V4a1 1 0 0 1 1-1h4a1 1 0 0 1 1 1v1M9 11h6M9 15h4"/>',
@@ -43,8 +46,15 @@ const ICONS={
 const FLIP=new Set(["undo","back"]);
 const ic=n=>`<svg class="mx-ic${FLIP.has(n)?" mx-ic-flip":""}" viewBox="0 0 24 24" aria-hidden="true">${ICONS[n]}</svg>`;
 const MATH_SIZE=26;
+const GREEK=["α","β","γ"], ARC_GAP=4;   // the angle box's letters; how far apart a double or triple arc's arcs are
+const ARCS=[[1,"קשת אחת"],[2,"קשת כפולה"],[3,"קשת משולשת"],["right","זווית ישרה (ריבוע)"]];
+// a corner with one, two or three arcs: equal angles are marked alike
+const arcsIcon=n=>n==="right"?'<svg class="mx-ic" viewBox="0 0 24 24" aria-hidden="true"><path d="M3 20h18M3 20V4M3 12.5h7.5V20"/></svg>'
+  :`<svg class="mx-ic" viewBox="0 0 24 24" aria-hidden="true"><path d="M3 20h18M3 20l12-14"/>${[7,10.5,14].slice(0,n).map(r=>`<path d="M${3+r} 20A${r} ${r} 0 0 0 ${(3+r*.65).toFixed(2)} ${(20-r*.76).toFixed(2)}"/>`).join("")}</svg>`;
+const ANGLE_FONT='500 18px "STIX Two Text","Cambria Math","Times New Roman",serif', CORNER=32, CORNER_TOUCH=40;   // how near a corner the angle tool reaches: about as far as an arc
+const ON=3;   // how close a point is to count as on a line: where an angle's corner is, and what moves with what
 const PEN=2.6, SHAPE=2.4, SNAP=12, GRAB=9, STEP=2, HISTORY=100;
-const PAPER_INK="#1B2140", PAPER_FAINT="#C5CBDF", SELECT="#2563D9";
+const PAPER="#F8F7F2", PAPER_INK="#1B2140", PAPER_FAINT="#C5CBDF", SELECT="#2563D9";
 const FONT='500 17px Rubik, system-ui, "Segoe UI", sans-serif', LINE_H=27, CARD_PAD=14;
 
 /* sketch key -> {marks, past}: marks are drawn in order; past holds copies of marks for undo */
@@ -52,6 +62,8 @@ const sketches=new Map(), images=new Map();
 let el=null, canvas=null, ctx=null, key="", base="", pages=0, page=0, layer=null, source=null, hand=null, onPage=null;
 let tool="pen", ink=INKS[0][0], eraser=ERASERS[1][0], sendLabel="";
 let draft=null, drag=null, rub=null, slide=null, selection=[];   // slide: the move tool dragging empty paper, which scrolls it
+let paper=PAPER;   // the paper's colour: the board's, or white in the picture handed in
+let naming=null, hover=null;   // naming: an angle's words being typed {mark, node, input, fresh, was, key}; hover: the corner the angle tool points at
 let editing=null;   // the formula being typed: {mark (null for a new one), at, node, field, key}
 let full=null;   // the board open full screen: {saved: the context to go back to, done: called when it closes}
 const touches=new Map(); let pan=null, penSeen=false;
@@ -105,7 +117,8 @@ function build(){
   canvas.addEventListener("pointerup",up);
   canvas.addEventListener("pointercancel",up);
   canvas.addEventListener("contextmenu",e=>e.preventDefault());
-  canvas.addEventListener("dblclick",e=>{ const m=hit(at(e)); if(m?.kind==="math") editMath(m,at(e)); });   // typed math is edited where it is   // the pen's side button: no browser menu over the board
+  canvas.addEventListener("dblclick",e=>{ const m=hit(at(e)); if(m?.kind==="math") editMath(m,at(e)); else if(m?.kind==="angle") startAngle(at(e),0); });
+  canvas.addEventListener("pointerleave",()=>{ if(hover){ hover=null; paint(); } });   // typed math is edited where it is   // the pen's side button: no browser menu over the board
   canvas.addEventListener("wheel",e=>{   // endless paper: scrolls down as far as needed, never above the top
     if(e.ctrlKey) return;   // the browser's zoom
     e.preventDefault(); const s=sketch(), dy=e.deltaMode===1?e.deltaY*24:e.deltaMode===2?e.deltaY*canvas.clientHeight:e.deltaY;
@@ -115,16 +128,16 @@ function build(){
   setTool(tool);
 }
 function pressed(sel,b){ el.querySelectorAll(sel).forEach(x=>x.setAttribute("aria-pressed",x===b)); }
-function reset(){ draft=drag=rub=slide=null; select([]); if(editing) finishMath(false); }
+function reset(){ draft=drag=rub=slide=null; hover=null; select([]); if(editing) finishMath(false); if(naming) finishAngle(true); }
 function setTool(t){
-  tool=t; el.querySelectorAll("[data-tool]").forEach(x=>x.setAttribute("aria-pressed",x.dataset.tool===t));
+  tool=t; if(hover){ hover=null; paint(); } el.querySelectorAll("[data-tool]").forEach(x=>x.setAttribute("aria-pressed",x.dataset.tool===t));
   el.dataset.tool=t; if(t!=="move"&&selection.length){ select([]); paint(); }
   // the eraser's cursor is a ring its own size, so the student sees what it will wipe
   const r=eraser/2, svg=`<svg xmlns='http://www.w3.org/2000/svg' width='${eraser+2}' height='${eraser+2}'><circle cx='${r+1}' cy='${r+1}' r='${r}' fill='rgba(255,255,255,.35)' stroke='%231B2140' stroke-width='1.2'/></svg>`;
   canvas.style.cursor=t==="eraser"?`url("data:image/svg+xml,${svg.replace(/</g,"%3C").replace(/>/g,"%3E")}") ${r+1} ${r+1}, cell`:t==="move"?"grab":"";
 }
 function select(list){ selection=list; }
-function turn(p){ if(editing) finishMath(true); page=p; key=`${base}:${page}`; reset(); drawPages(); drawSend(); paint(); }
+function turn(p){ if(editing) finishMath(true); if(naming) finishAngle(true); page=p; key=`${base}:${page}`; reset(); drawPages(); drawSend(); paint(); }
 function drawSend(){
   const b=el.querySelector(".mx-board-send"); b.hidden=!hand; el.querySelector(".mx-board-row").hidden=pages<2&&!hand; if(!hand) return;
   b.disabled=false; b.innerHTML=`${ic("send")}<span>${sendLabel||`הגשה לשאלה ${page+1}`}</span>`; b.title=sendLabel||`הגשת הלוח כתשובה לשאלה ${page+1}`;
@@ -150,6 +163,7 @@ function paint(){
   el.querySelector(".mx-board-top").hidden=y<1;
   marks().forEach(draw);
   if(draft?.kind==="circle") guide(draft);
+  if(hover&&!naming) aimed(hover);
   if(selection.length) outline(selection);
   const del=el.querySelector(".mx-board-del"); del.hidden=!selection.length||!!drag?.before;
   if(selection.length){ const [x0,y0]=edges(selection); del.style.left=`${Math.max(4,x0)}px`; const top=y0-y; del.style.top=`${top>40?top-36:Math.max(4,top+4)}px`; }
@@ -158,6 +172,7 @@ function draw(m){
   ctx.save(); ctx.strokeStyle=m.color; ctx.lineCap="round"; ctx.lineJoin="round";
   if(m.kind==="line"){ ctx.lineWidth=SHAPE; ctx.beginPath(); ctx.moveTo(...m.a); ctx.lineTo(...m.b); ctx.stroke(); }
   else if(m.kind==="circle"){ ctx.lineWidth=SHAPE; ctx.beginPath(); ctx.arc(m.a[0],m.a[1],dist(m.a,m.b),0,Math.PI*2); ctx.stroke(); }
+  else if(m.kind==="angle") angleMark(m);
   else if(m.kind==="card") card(m);
   else if(m.kind==="math"){ const L=mathBox(m); if(L){ ctx.fillStyle=m.color; ctx.direction="ltr"; ctx.textAlign="left"; ctx.textBaseline="alphabetic"; L.paint(ctx,m.x,m.y+L.a); } }
   else{ for(let i=1;i<m.pts.length;i++) segment(m,i); if(m.pts.length===1) segment(m,0); }
@@ -175,6 +190,30 @@ function guide(m){
   ctx.beginPath(); ctx.moveTo(...m.a); ctx.lineTo(...m.b); ctx.stroke();
   ctx.setLineDash([]); ctx.beginPath(); ctx.arc(m.a[0],m.a[1],2.5,0,Math.PI*2); ctx.fill(); ctx.restore();
 }
+// an angle: the arc between its two edges, and its words just outside the arc (hidden while they are typed)
+const arcsOf=m=>naming?.mark===m?naming.arcs:m.arcs||1;   // while its box is open: the arcs picked there
+// a right angle is marked with a little square in its corner: its sides along the edges, its far corner on the line splitting the angle
+const square=m=>{
+  const k=Math.max(8,Math.min(14,arcR(m)*.5)), u=[Math.cos(m.s),Math.sin(m.s)], w=[Math.cos(m.s+m.w),Math.sin(m.s+m.w)];
+  return [[m.v[0]+k*u[0],m.v[1]+k*u[1]],[m.v[0]+k*(u[0]+w[0]),m.v[1]+k*(u[1]+w[1])],[m.v[0]+k*w[0],m.v[1]+k*w[1]]];
+};
+const rim=m=>arcsOf(m)==="right"?dist(square(m)[1],m.v):arcR(m)+ARC_GAP*(arcsOf(m)-1);   // how far out the mark reaches
+const colorOf=m=>naming?.mark===m?naming.color:m.color;   // while its box is open: the colour picked there
+function angleMark(m){
+  ctx.lineWidth=1.8; ctx.strokeStyle=colorOf(m);
+  if(arcsOf(m)==="right"){ const [a,b,c]=square(m); ctx.beginPath(); ctx.moveTo(...a); ctx.lineTo(...b); ctx.lineTo(...c); ctx.stroke(); }
+  else for(let k=0;k<arcsOf(m);k++){ ctx.beginPath(); ctx.arc(m.v[0],m.v[1],arcR(m)+k*ARC_GAP,m.s,m.s+m.w); ctx.stroke(); }
+  if(!m.text||naming?.mark===m) return;
+  const [x,y]=labelAt(m); ctx.font=ANGLE_FONT; ctx.direction="ltr"; ctx.textAlign="center"; ctx.textBaseline="middle";
+  ctx.strokeStyle=paper; ctx.lineWidth=5; ctx.strokeText(m.text,x,y);   // a rim of paper, where the words cross a line
+  ctx.fillStyle=m.color; ctx.fillText(m.text,x,y);
+}
+// the corner the angle tool points at: the arc it would add (or the angle it would retype), dashed
+function aimed(c){
+  ctx.save(); ctx.strokeStyle=ctx.fillStyle=SELECT; ctx.lineWidth=2; ctx.setLineDash([4,3]);
+  ctx.beginPath(); ctx.arc(c.v[0],c.v[1],c.r,c.s,c.s+c.w); ctx.stroke();
+  ctx.setLineDash([]); ctx.beginPath(); ctx.arc(c.v[0],c.v[1],3.5,0,TAU); ctx.fill(); ctx.restore();
+}
 function card(m){
   ctx.fillStyle="#EEF1FB"; ctx.strokeStyle=PAPER_FAINT; ctx.lineWidth=1;
   ctx.beginPath(); ctx.roundRect(m.x,m.y,m.w,m.h,12); ctx.fill(); ctx.stroke();
@@ -190,6 +229,7 @@ const mathBox=m=>window.MathlyBoardMath?.layout(m.latex,m.size||MATH_SIZE);
 function box(m){
   if(m.kind==="card") return [m.x,m.y,m.x+m.w,m.y+m.h];
   if(m.kind==="math"){ const L=mathBox(m)||{w:0,a:0,d:0}; return [m.x,m.y,m.x+L.w,m.y+L.a+L.d]; }
+  if(m.kind==="angle"){ const [x,y,w]=labelAt(m), r=rim(m); return [Math.min(m.v[0]-r,x-w/2),Math.min(m.v[1]-r,y-10),Math.max(m.v[0]+r,x+w/2),Math.max(m.v[1]+r,y+10)]; }
   if(m.kind==="circle"){ const r=dist(m.a,m.b); return [m.a[0]-r,m.a[1]-r,m.a[0]+r,m.a[1]+r]; }
   const pts=m.kind==="line"?[m.a,m.b]:m.pts, xs=pts.map(p=>p[0]), ys=pts.map(p=>p[1]);
   return [Math.min(...xs),Math.min(...ys),Math.max(...xs),Math.max(...ys)];
@@ -202,43 +242,50 @@ function outline(list){
 }
 
 /* ---------- geometry ---------- */
-function toSegment(p,a,b){
+function nearestOn(p,a,b){
   const dx=b[0]-a[0], dy=b[1]-a[1], l=dx*dx+dy*dy, t=l?Math.max(0,Math.min(1,((p[0]-a[0])*dx+(p[1]-a[1])*dy)/l)):0;
-  return Math.hypot(p[0]-a[0]-t*dx,p[1]-a[1]-t*dy);
+  return [a[0]+t*dx,a[1]+t*dy];
 }
+const toSegment=(p,a,b)=>dist(p,nearestOn(p,a,b));
 // how far p is from the element's ink
 function reach(m,p){
   if(m.kind==="line") return toSegment(p,m.a,m.b);
   if(m.kind==="circle") return Math.min(Math.abs(dist(p,m.a)-dist(m.a,m.b)),dist(p,m.a));
+  if(m.kind==="angle"&&arcsOf(m)==="right"){ const [a,b,c]=square(m); return Math.min(toSegment(p,a,b),toSegment(p,b,c),toWords(m,p)); }
+  if(m.kind==="angle") return Math.min(inWedge(Math.atan2(p[1]-m.v[1],p[0]-m.v[0]),m.s,m.w)?Math.max(0,Math.abs(dist(p,m.v)-(arcR(m)+rim(m))/2)-(rim(m)-arcR(m))/2):Infinity,toWords(m,p));
   if(m.kind==="card"||m.kind==="math"){ const [x0,y0,x1,y1]=box(m), dx=Math.max(x0-p[0],0,p[0]-x1), dy=Math.max(y0-p[1],0,p[1]-y1);
     return m.kind==="card"?(dx||dy?Infinity:0):Math.hypot(dx,dy); }
   if(m.pts.length===1) return dist(p,m.pts[0]);
   let d=Infinity; for(let i=1;i<m.pts.length;i++) d=Math.min(d,toSegment(p,m.pts[i-1],m.pts[i])); return d;
 }
 const hit=p=>{ const all=marks(); for(let i=all.length-1;i>=0;i--) if(reach(all[i],p)<=GRAB) return all[i]; return null; };
-const joints=m=>m.kind==="line"?[m.a,m.b]:m.kind==="circle"?[m.a]:[];
+const joints=m=>m.kind==="line"?[m.a,m.b]:m.kind==="circle"?[m.a]:m.kind==="angle"?[m.v]:[];   // an angle moves with its corner
 // an element and everything joined to it by a shared end or center: a triangle moves as one
 function group(m){
   const out=new Set([m]), todo=[m];
   while(todo.length){ const cur=todo.pop();
-    for(const o of marks()) if(!out.has(o)&&joints(cur).some(p=>joints(o).some(q=>same(p,q)))){ out.add(o); todo.push(o); } }
+    for(const o of marks()) if(!out.has(o)&&linked(cur,o)){ out.add(o); todo.push(o); } }
   return [...out];
 }
-// a line's ends and a circle's center pull to the ends and centers already on the board
+// joined: a shared end or center, a line's end on another line (drawn from a side), or an angle on a line through it
+const lies=(m,o)=>o.kind==="line"&&(m.kind==="line"||m.kind==="angle")&&joints(m).some(p=>toSegment(p,o.a,o.b)<=ON);
+const linked=(m,o)=>joints(m).some(p=>joints(o).some(q=>same(p,q)))||lies(m,o)||lies(o,m);
+// a line's ends and a circle's center pull to the ends and centers already on the board, or else onto a line
 function snap(p,skip){
   let best=null, d=SNAP;
   for(const m of marks()){ if(m===skip) continue; for(const q of joints(m)){ const k=dist(p,q); if(k<d){ d=k; best=q; } } }
+  if(!best) for(const m of marks()) if(m!==skip&&m.kind==="line"){ const q=nearestOn(p,m.a,m.b), k=dist(p,q); if(k<d){ d=k; best=q; } }
   return best?[best[0],best[1]]:[p[0],p[1]];
 }
 function shift(m,dx,dy){
   const by=p=>{ p[0]+=dx; p[1]+=dy; };
-  if(m.kind==="card"||m.kind==="math"){ m.x+=dx; m.y+=dy; } else if(m.kind==="free") m.pts.forEach(by); else { by(m.a); by(m.b); }
+  if(m.kind==="card"||m.kind==="math"){ m.x+=dx; m.y+=dy; } else if(m.kind==="free") m.pts.forEach(by); else if(m.kind==="angle") by(m.v); else { by(m.a); by(m.b); }
 }
 // the eraser at p: lines, circles and typed math it touches go; pen strokes are cut; the question's copy stays
 function rubOut(p){
   const r=eraser/2, all=marks(); let changed=false;
   for(let i=all.length-1;i>=0;i--){ const m=all[i];
-    if(m.kind==="line"||m.kind==="circle"||m.kind==="math"){ if(reach(m,p)<=r+SHAPE/2){ all.splice(i,1); changed=true; } continue; }
+    if(m.kind==="line"||m.kind==="circle"||m.kind==="math"||m.kind==="angle"){ if(reach(m,p)<=r+SHAPE/2){ all.splice(i,1); changed=true; } continue; }
     if(m.kind!=="free") continue;
     const gone=m.pts.map(q=>dist(p,q)<=r+PEN); if(!gone.some(Boolean)) continue;
     const runs=[]; let run=[]; m.pts.forEach((q,k)=>{ if(gone[k]){ if(run.length) runs.push(run); run=[]; } else run.push(q); }); if(run.length) runs.push(run);
@@ -246,6 +293,150 @@ function rubOut(p){
   }
   return changed;
 }
+/* ---------- angles at corners ---------- */
+const TAU=Math.PI*2, turnOf=a=>(a%TAU+TAU)%TAU, inWedge=(t,s,w)=>turnOf(t-s)<=w;
+const gap=(a,b)=>Math.abs(turnOf(a-b+Math.PI)-Math.PI);
+// where two lines cross, or null (an end on the other line counts)
+function cross(m,o){
+  const r=[m.b[0]-m.a[0],m.b[1]-m.a[1]], q=[o.b[0]-o.a[0],o.b[1]-o.a[1]], den=r[0]*q[1]-r[1]*q[0];
+  if(Math.abs(den)<1e-9) return null;
+  const ex=o.a[0]-m.a[0], ey=o.a[1]-m.a[1], t=(ex*q[1]-ey*q[0])/den, u=(ex*r[1]-ey*r[0])/den, k=.01;
+  return t>=-k&&t<=1+k&&u>=-k&&u<=1+k?[m.a[0]+t*r[0],m.a[1]+t*r[1]]:null;
+}
+// the points where lines meet: shared ends, an end partway along another line, and crossings
+function meets(){
+  const lines=marks().filter(m=>m.kind==="line"), out=lines.flatMap(m=>[m.a,m.b]);
+  lines.forEach((m,i)=>lines.slice(i+1).forEach(o=>{ const c=cross(m,o); if(c) out.push(c); }));
+  return out;
+}
+// every line through v, as rays going out of v: one for a line ending there, two for a line passing through
+function raysAt(v){
+  const rays=[], add=b=>{
+    if(dist(b,v)<=ON) return;
+    const t=turnOf(Math.atan2(b[1]-v[1],b[0]-v[0])), len=dist(v,b), twin=rays.find(r=>gap(r.t,t)<.02);
+    if(twin) twin.len=Math.min(twin.len,len); else rays.push({t,len});
+  };
+  for(const m of marks()) if(m.kind==="line"){
+    if(dist(m.a,v)<=ON) add(m.b); else if(dist(m.b,v)<=ON) add(m.a); else if(toSegment(v,m.a,m.b)<=ON){ add(m.a); add(m.b); }
+  }
+  return rays.sort((a,b)=>a.t-b.t);
+}
+/* A corner near p where lines meet, and the angle (under half a turn) between two of its rays that p points into:
+   the inside of a triangle's corner, either side of a line drawn from a side, or the smallest one when p is on the
+   corner itself. Pointing along a line that splits an angle picks the whole angle, its arc a little wider, and
+   its words go in the widest gap the inner lines leave. */
+function corner(p,near){
+  let v=null, d=near;
+  for(const q of meets()){ const k=dist(p,q); if(k<d){ d=k; v=q; } }
+  if(!v) return null;
+  const rays=raysAt(v); if(rays.length<2) return null;
+  const wedges=[];
+  rays.forEach(r=>rays.forEach(n=>{
+    const w=turnOf(n.t-r.t); if(r===n||w<.02||w>Math.PI-.01) return;
+    wedges.push({s:r.t,w,len:Math.min(r.len,n.len),inner:rays.filter(x=>x!==r&&x!==n&&turnOf(x.t-r.t)<w)});
+  }));
+  if(!wedges.length) return null;
+  wedges.sort((a,b)=>a.w-b.w);
+  const t=Math.atan2(p[1]-v[1],p[0]-v[0]), far=dist(p,v)>6, along=far&&rays.find(r=>gap(r.t,t)<.1);
+  const off=x=>inWedge(t,x.s,x.w)?0:Math.min(gap(t,x.s),gap(t,x.s+x.w))+(x.inner.length?1:0);   // outside them all: the nearest
+  const w=(along&&wedges.find(x=>x.inner.includes(along)))||(far&&wedges.reduce((a,b)=>off(b)<off(a)?b:a))||wedges[0];
+  const cuts=[0,...w.inner.map(x=>turnOf(x.t-w.s)).sort((a,b)=>a-b),w.w];
+  let f=w.w/2, g=w.w;
+  if(w.inner.length){ g=0; for(let k=1;k<cuts.length;k++) if(cuts[k]-cuts[k-1]>g){ g=cuts[k]-cuts[k-1]; f=(cuts[k]+cuts[k-1])/2; } }
+  return {v:[v[0],v[1]],s:w.s,w:w.w,r:Math.max(12,Math.min(30,w.len*.3))+10*w.inner.length,f:w.s+f};
+}
+// what the angle tool would act on at p: an angle already there (to retype its words), or a corner to add one to
+// (an angle's words come first; then the corner decides, so pointing along a middle line over a half's arc still
+// gives the whole angle; an arc whose corner is gone is still there to retype)
+function aim(p,near){
+  const all=marks().filter(m=>m.kind==="angle").reverse(), as=m=>({mark:m,v:m.v,s:m.s,w:m.w,r:arcR(m)});
+  const named=all.find(m=>toWords(m,p)<=4); if(named) return as(named);
+  const c=corner(p,near);
+  if(c){ c.mark=all.find(m=>dist(m.v,c.v)<=ON&&gap(m.s,c.s)<.05&&Math.abs(m.w-c.w)<.05)||null; if(c.mark) c.r=arcR(c.mark); return c; }
+  const old=all.find(m=>reach(m,p)<=GRAB); return old?as(old):null;
+}
+// how far p is from an angle's words
+function toWords(m,p){
+  if(!m.text) return Infinity;
+  const [x,y,w]=labelAt(m); return Math.hypot(Math.max(Math.abs(p[0]-x)-w/2,0),Math.max(Math.abs(p[1]-y)-10,0));
+}
+// where an angle's words sit: on the line splitting the angle, just past the arc, and far enough out to clear the edges
+// (right by the arc, even in a narrow angle: they are drawn over a line's ink with a rim of paper)
+function labelAt(m,text=m.text){
+  ctx.save(); ctx.font=ANGLE_FONT; const w=text?ctx.measureText(text).width:0; ctx.restore();
+  const f=m.f??m.s+m.w/2, out=Math.abs(w/2*Math.cos(f))+Math.abs(10*Math.sin(f)), c=Math.cos(f), s=Math.sin(f);   // f: the words' way
+  // words of an angle beside it at the same corner, added before it: these move out until they are clear of them
+  const all=marks(), i=all.indexOf(m), mine=inside(m);
+  const near=i<0?[]:all.slice(0,i).filter(o=>o.kind==="angle"&&o.text&&dist(o.v,m.v)<=ON&&!mine.includes(o)&&!inside(o).includes(m)).map(o=>labelAt(o));
+  let d=rim(m)+5+out;
+  for(let k=0;k<30&&near.some(([x,y,ow])=>Math.abs(m.v[0]+d*c-x)<(w+ow)/2+4&&Math.abs(m.v[1]+d*s-y)<20);k++) d+=3;
+  return [m.v[0]+d*c,m.v[1]+d*s,w,out];
+}
+// the angles inside m at its corner (the halves of an angle a line splits)
+const inside=m=>marks().filter(o=>o!==m&&o.kind==="angle"&&dist(o.v,m.v)<=ON&&o.w<m.w-.01&&turnOf(o.s-m.s)<=m.w-o.w+.01);
+// an angle's arc goes around the arcs and words of the angles inside it, so each angle's words sit by its own arc
+function arcR(m){
+  let r=m.r;
+  for(const o of inside(m)){ r=Math.max(r,rim(o)+8); if(o.text){ const [x,y,,out]=labelAt(o); r=Math.max(r,dist([x,y],m.v)+out+4); } }
+  return r;
+}
+// a number on its own or added to the rest ("60", "β+90", "180-α-β") is a size in degrees; a factor ("2β") is not
+const TERM=/(^|[+\-−=]\s*)(\d+(?:[.,]\d+)?)°?(?=\s*(?:$|[+\-−=]))/g;
+const NAMES={alpha:"α",beta:"β",gamma:"γ"};
+const degrees=v=>v.trim().replace(/(?<![a-z])(alpha|beta|gamma)(?![a-z])/gi,w=>NAMES[w.toLowerCase()]).replace(TERM,"$1$2°");
+const bare=t=>t.replace(TERM,"$1$2");   // for retyping: the signs degrees() puts back by itself
+// adds the angle at p (or opens one already there), with a box over its words
+function startAngle(p,near){
+  const c=aim(p,near); if(!c) return;
+  hover=null;
+  let m=c.mark; const fresh=!m;
+  if(fresh){ remember(); m={kind:"angle",color:ink,v:c.v,s:c.s,w:c.w,r:c.r,f:c.f,text:""}; marks().push(m); }
+  // the box for the words, with the usual names of a triangle's angles a tap away
+  const node=document.createElement("div"); node.className="mx-board-angleedit";
+  // two rows, to fit a phone: the words and the letters; the arcs and the colour
+  node.innerHTML=`<div class="mx-board-anglerow"><input type="text" class="mx-board-anglein" dir="auto" maxlength="16" placeholder="°" enterkeyhint="done"
+      aria-label="מה כתוב בזווית (מספר מקבל סימן מעלות)">${GREEK.map(g=>`<button type="button" tabindex="-1" data-letter title="${g}">${g}</button>`).join("")}</div>
+    <div class="mx-board-anglerow"><span class="mx-board-arcs">${ARCS.map(([n,name])=>`<button type="button" tabindex="-1" data-arcs="${n}" aria-pressed="${n===(m.arcs||1)}" title="${name}" aria-label="${name}">${arcsIcon(n)}</button>`).join("")}</span>
+    <span class="mx-board-colors">${INKS.map(([c,name])=>`<button type="button" tabindex="-1" data-color="${c}" aria-pressed="${c===m.color}" title="${name}" aria-label="${name}" style="--dot:${c}"></button>`).join("")}</span></div>`;
+  const input=node.querySelector("input"); input.value=bare(m.text);
+  naming={mark:m,node,input,fresh,was:m.text,arcs:m.arcs||1,color:m.color,key};
+  input.addEventListener("keydown",ev=>{
+    if(ev.key==="Enter"){ ev.preventDefault(); finishAngle(true); }
+    else if(ev.key==="Escape"){ ev.preventDefault(); ev.stopPropagation(); finishAngle(false); }
+  });
+  input.addEventListener("blur",()=>naming?.node===node&&finishAngle(true));
+  // a letter's button types it where the cursor is ("β+90" takes a tap and a few keys); the box keeps its focus
+  node.querySelectorAll("[data-letter]").forEach(b=>b.addEventListener("pointerdown",ev=>{
+    ev.preventDefault(); input.setRangeText(b.textContent,input.selectionStart??input.value.length,input.selectionEnd??input.value.length,"end");
+  }));
+  // one, two or three arcs: shown at once, kept with the words
+  node.querySelectorAll("[data-arcs]").forEach(b=>b.addEventListener("pointerdown",ev=>{
+    ev.preventDefault(); naming.arcs=b.dataset.arcs==="right"?"right":+b.dataset.arcs; node.querySelectorAll("[data-arcs]").forEach(x=>x.setAttribute("aria-pressed",x===b)); paint();
+  }));
+  // the angle's colour, its arcs and words together: shown at once on the arcs and in the box, kept with the words
+  const tint=()=>{ input.style.color=naming.color; paint(); };
+  node.querySelectorAll("[data-color]").forEach(b=>b.addEventListener("pointerdown",ev=>{
+    ev.preventDefault(); naming.color=b.dataset.color; node.querySelectorAll("[data-color]").forEach(x=>x.setAttribute("aria-pressed",x===b)); tint();
+  }));
+  input.style.color=m.color;
+  el.querySelector(".mx-board-stage").append(node);
+  const [x,y]=labelAt(m,"000°"), W=canvas.clientWidth, bw=node.offsetWidth;
+  node.style.left=`${Math.max(4,Math.min(W-4-bw,x-bw/2))}px`; node.style.top=`${Math.max(4,y-sketch().y-21)}px`;
+  paint(); input.focus({preventScroll:true});
+  if(pages>1) drawPages();
+}
+// keep: the words go in (a new angle with none keeps just its arc); otherwise a new angle is taken back
+function finishAngle(keep){
+  const n=naming; if(!n) return; naming=null; n.node.remove();
+  const s=sketches.get(n.key), m=n.mark; if(!s) return;
+  if(keep){
+    const t=degrees(n.input.value); if(!n.fresh&&(t!==n.was||n.arcs!==(m.arcs||1)||n.color!==m.color)) remember();
+    m.text=t; m.color=n.color; if(n.arcs!==1) m.arcs=n.arcs; else delete m.arcs;   // 2, 3, or "right"
+  }
+  else if(n.fresh){ const i=s.marks.indexOf(m); if(i>=0){ s.marks.splice(i,1); s.past.pop(); } }
+  paint(); if(pages>1) drawPages();
+}
+
 // points along a to b, close enough that nothing between two of them is skipped
 function along(a,b,step){ const n=Math.max(1,Math.ceil(dist(a,b)/step)), out=[]; for(let k=1;k<=n;k++) out.push([a[0]+(b[0]-a[0])*k/n,a[1]+(b[1]-a[1])*k/n,a[2]+((b[2]??a[2])-a[2])*k/n]); return out; }
 
@@ -271,6 +462,8 @@ function down(e){
   if(e.button!==0&&e.button!==5) return;   // 5: the pen's eraser end
   const p=at(e), use=e.button===5||(e.buttons&32)>0?"eraser":tool;
   if(editing){ e.preventDefault(); return finishMath(true); }   // a tap beside the formula being typed: it is done
+  if(naming){ e.preventDefault(); return finishAngle(true); }   // the same for an angle's words
+  if(use==="angle"){ e.preventDefault(); return startAngle(p,e.pointerType==="mouse"?CORNER:CORNER_TOUCH); }
   if(use==="math"){ e.preventDefault(); const m=hit(p); return editMath(m?.kind==="math"?m:null,p); }
   capture(e.pointerId); e.preventDefault();
   if(use==="move"){
@@ -292,6 +485,11 @@ function move(e){
   }
   if(slide&&e.pointerId===slide.id){ sketch().y=Math.max(0,slide.s-(e.clientY-slide.y)); return paint(); }
   if(tool==="move"&&!drag&&!e.buttons) canvas.style.cursor=hit(at(e))?"move":"grab";
+  if(tool==="angle"&&!e.buttons&&e.pointerType!=="touch"){   // a mouse or a pen over a corner: its arc, dashed
+    const c=naming?null:aim(at(e),CORNER), was=hover; hover=c; canvas.style.cursor=c?"pointer":"";
+    if(c?.v[0]!==was?.v[0]||c?.v[1]!==was?.v[1]||c?.s!==was?.s) paint();
+    return;
+  }
   if(drag&&e.pointerId===drag.id){
     const p=at(e), dx=p[0]-drag.last[0], dy=p[1]-drag.last[1]; if(!dx&&!dy) return;
     if(!drag.before){ drag.before=true; remember(); }
@@ -436,9 +634,9 @@ function snapshot(){
   const all=marks(); if(!all.some(m=>m.kind!=="card")) return null;
   const [,y0,,y1]=edges(all), top=Math.max(0,y0-24), W=canvas.clientWidth, H=Math.min(y1+24-top,8000), k=2;
   const out=document.createElement("canvas"); out.width=W*k; out.height=Math.round(H*k);
-  const keep=ctx; ctx=out.getContext("2d");
+  const keep=ctx; ctx=out.getContext("2d"); paper="#fff";
   try{ ctx.fillStyle="#fff"; ctx.fillRect(0,0,out.width,out.height); ctx.setTransform(k,0,0,k,0,-top*k); all.forEach(draw); }
-  finally{ ctx=keep; }
+  finally{ ctx=keep; paper=PAPER; }
   return new Promise(ok=>out.toBlob(ok,"image/png"));
 }
 async function send(){
@@ -504,7 +702,7 @@ function openFull({host,key:k,pages:n=1,page:p=0,question=null,submit=null,turne
   el.querySelector(".mx-board-back").focus({preventScroll:true,focusVisible:false});   // reachable by keyboard, without a ring on a tap
 }
 function closeFull(){
-  if(!full) return; if(editing) finishMath(true); const f=full; full=null;
+  if(!full) return; if(editing) finishMath(true); if(naming) finishAngle(true); const f=full; full=null;
   el.classList.remove("full"); el.removeAttribute("role"); el.removeAttribute("aria-modal"); el.remove();
   restore(f.saved); f.done?.();
   if(layer?.isConnected&&desk()) again();

static/math-sky.js

@@ -20,7 +20,7 @@ const esc=s=>String(s??"").replace(/[&<>"']/g,c=>({"&":"&amp;","<":"&lt;",">":"&
 /* ---------- rules ---------- */
 const dayKey=(d=new Date())=>`${d.getFullYear()}-${String(d.getMonth()+1).padStart(2,"0")}-${String(d.getDate()).padStart(2,"0")}`;
 const daysBack=(n,from)=>{const d=new Date(from);d.setDate(d.getDate()-n);return d};
-function ensure(P){ for(const k of ["run","gold","seen","days","review","missed"]) if(!P[k]||typeof P[k]!=="object") P[k]={}; for(const k of ["comets","slips"]) if(!Array.isArray(P[k])) P[k]=[]; return P; }
+function ensure(P){ for(const k of ["run","gold","seen","days","review","missed","examples"]) if(!P[k]||typeof P[k]!=="object") P[k]={}; for(const k of ["comets","slips"]) if(!Array.isArray(P[k])) P[k]=[]; return P; }
 function fading(P,id,now=new Date()){
   if(!P.done?.[id]) return false;
   const t=Date.parse(P.seen?.[id]||P.done[id]);
@@ -88,6 +88,82 @@ function patterns(P,mistakes={},now=new Date()){
   return {recurring:recurring.sort(rank).slice(0,PATTERNS_SHOWN),stopped:stopped.sort(rank).slice(0,PATTERNS_SHOWN)};
 }
 
+/* ---------- the class teacher's signals ----------
+   Who needs the teacher's attention, worked out from what the report loads for a student: the saved progress, and the
+   server's quiz sittings (see class_report.py). The progress is what the student's device reports, so these are prompts
+   to look, not grades. A week runs from Sunday. */
+const INACTIVE_DAYS=7, STUCK_SLIPS=3, STUCK_WINDOW_DAYS=14, DROP_RATIO=.5, DROP_MIN_LAST_WEEK=10, LOW_GRADE=55;
+const midnight=d=>new Date(d.getFullYear(),d.getMonth(),d.getDate());
+const keyDate=k=>{ const m=/^(\d{4})-(\d\d)-(\d\d)$/.exec(k); return m?new Date(+m[1],m[2]-1,+m[3]):null; };
+const daysBetween=(a,b)=>Math.round((midnight(b)-midnight(a))/DAY);
+// the latest day the student answered right: from the per-day counts and from when each skill was last practised
+function lastPractice(P){
+  const times=[];
+  for(const [k,n] of Object.entries(P.days||{})){ const d=keyDate(k); if(d&&n>0) times.push(d.getTime()); }
+  for(const v of Object.values(P.seen||{})){ const t=Date.parse(v); if(!isNaN(t)) times.push(t); }
+  return times.length?new Date(Math.max(...times)):null;
+}
+// right answers this week (from Sunday) and in the week before
+function weekly(P,now=new Date()){
+  const start=midnight(now); start.setDate(start.getDate()-start.getDay());
+  const prev=new Date(start); prev.setDate(prev.getDate()-7);
+  let thisWeek=0, lastWeek=0;
+  for(const [k,n] of Object.entries(P.days||{})){
+    const d=keyDate(k); if(!d||!(n>0)) continue;
+    if(d>=start) thisWeek+=n; else if(d>=prev) lastWeek+=n;
+  }
+  return {thisWeek,lastWeek};
+}
+/* The reasons a student needs attention (empty: none). `student`: {signed_in, progress, quiz_sittings}.
+   `ctx`: {skills: name by skill id (the class's skills), units: [{id, name}] (the class units with a quiz)}. */
+function attention(student,{skills={},units=[],assignments=[]}={},now=new Date()){
+  const P=student.progress, out=[];
+  if(!P) return student.signed_in?[{kind:"new",text:"עוד לא התחיל לתרגל"}]:[];
+  const last=lastPractice(P);
+  if(last){ const n=daysBetween(last,now); if(n>=INACTIVE_DAYS) out.push({kind:"inactive",text:`לא תרגל ${n} ימים`}); }
+  const cut=now-STUCK_WINDOW_DAYS*DAY, count={};
+  for(const x of P.slips||[]){ const t=Date.parse(x?.at); if(x?.id&&!isNaN(t)&&t>=cut&&t<=now) count[x.id]=(count[x.id]||0)+1; }
+  const stuck=Object.keys(count).filter(id=>count[id]>=STUCK_SLIPS&&!P.done?.[id]&&skills[id]).sort((a,b)=>count[b]-count[a]);
+  if(stuck.length) out.push({kind:"stuck",skills:stuck,text:`${stuck.length===1?"תקוע במיומנות":"תקוע במיומנויות"}: ${stuck.map(id=>skills[id]).join(", ")}`});
+  const w=weekly(P,now);
+  if(w.lastWeek>=DROP_MIN_LAST_WEEK&&w.thisWeek<w.lastWeek*DROP_RATIO)
+    out.push({kind:"drop",text:`התרגול ירד: ${w.thisWeek} תשובות נכונות השבוע, ${w.lastWeek} בשבוע שעבר`});
+  for(const u of units){   // the server's grades only; without them (null) the signal is left out
+    const g=(student.quiz_sittings||[]).filter(x=>x.unit_id===u.id&&x.grade!=null).sort((a,b)=>String(a.submitted_at).localeCompare(String(b.submitted_at))).at(-1);
+    if(g&&g.grade<LOW_GRADE) out.push({kind:"grade",unit:u.id,text:`ציון נמוך בבוחן ${u.name}: ${g.grade}`});
+  }
+  for(const a of assignments){   // an assignment past its due date and not finished (left out when a unit quiz cannot be told)
+    const st=assignmentState(a,P,student.quiz_sittings,now);
+    if(st.overdue&&st.items.every(x=>x.known)) out.push({kind:"assignment",assignment:a.id,text:`משימה באיחור: ${a.title}`});
+  }
+  return out;
+}
+
+/* ---------- assignments (app/assignments.py) ----------
+   Whether an assignment's items are done is worked out from what already exists, the same way on the student's home
+   screen and in the teacher's report. A skill is done when it is finished, whenever that was. A unit quiz is done when
+   the server has a sitting of it handed in after the assignment was made (`sittings`: [{unit_id, submitted_at}], null
+   when the server's record could not be read), and a practice exam when one covering all the item's units was taken
+   after that (P.quizzes). Dates are Jerusalem days: an item done on the due date is on time. */
+const jerusalemDay=t=>new Date(t).toLocaleDateString("en-CA",{timeZone:"Asia/Jerusalem"});   // YYYY-MM-DD
+function assignmentState(a,P,sittings,now=new Date()){
+  const created=Date.parse(a.created_at)||0, due=String(a.due_on);
+  const earliest=list=>list.filter(Boolean).sort()[0]||null;
+  const items=(a.items||[]).map(item=>{
+    let at=null, known=true;
+    if(item.kind==="skill") at=P?.done?.[item.id]||null;
+    else if(item.kind==="unit_quiz"){
+      known=Array.isArray(sittings);
+      at=earliest((sittings||[]).filter(x=>x.unit_id===item.unit&&Date.parse(x.submitted_at)>created).map(x=>x.submitted_at));
+    }else if(item.kind==="exam")
+      at=earliest((P?.quizzes||[]).filter(x=>Date.parse(x.at)>created&&(item.units||[]).every(u=>(x.units||[]).includes(u))).map(x=>x.at));
+    return {item,done:!!at,at,known,late:!!at&&jerusalemDay(at)>due};
+  });
+  const doneCount=items.filter(x=>x.done).length, finished=items.length>0&&doneCount===items.length;
+  return {items,doneCount,total:items.length,finished,overdue:!finished&&jerusalemDay(now)>due,
+    late:finished&&items.some(x=>x.late),next:items.findIndex(x=>!x.done)};
+}
+
 /* a star's look: gold, lit, fading (finished), next, open, locked, off */
 function star(P,id,status,isNext){
   if(status==="done") return P.gold?.[id]?"gold":fading(P,id)?"fading":"lit";
@@ -350,6 +426,6 @@ function comet(onCatch){
 }
 const cometCard=c=>`<div class="sky-card"><span class="sym">${esc(c.sym)}</span><b>${esc(c.name)}</b></div>`;
 
-window.MathlySky={GOAL,slip,patterns,FADE_DAYS,MASTER_RUN,GOLD_RUN,masterNeed,goldNeed,mastered,reviewed,due,COMETS,SPARK,spark,FLAME,owl,praise,dayKey,ensure,correct,wrong,fading,star,today,streak,dayState,month,best,
+window.MathlySky={GOAL,slip,patterns,assignmentState,jerusalemDay,attention,weekly,lastPractice,FADE_DAYS,MASTER_RUN,GOLD_RUN,masterNeed,goldNeed,mastered,reviewed,due,COMETS,SPARK,spark,FLAME,owl,praise,dayKey,ensure,correct,wrong,fading,star,today,streak,dayState,month,best,
   cometDue,catchComet,shape,labels,mount,burst,burstAt,sound,buzz,soundOn,setSound,toast,celebrate,comet,cometCard};
 })();

static/math.css

@@ -751,6 +751,26 @@ body{--keyboard-zindex:3000}
 .mx-board-mathedit math-field::part(virtual-keyboard-toggle),.mx-board-mathedit math-field::part(menu-toggle){display:none}
 .mx-board-mathedit button{flex:none;width:40px;height:40px;border-radius:10px;border:1px solid #C5CBDF;background:#F4F6FC;color:#1B2140;font:700 18px/1 var(--f-body);cursor:pointer}
 .mx-board-mathedit button[data-math="ok"]{background:var(--mx-accent);border-color:var(--mx-accent);color:var(--mx-on-accent)}
+/* an angle's words, typed in a box where they will sit */
+.mx-board-angleedit{position:absolute;z-index:2;display:flex;flex-direction:column;gap:4px;padding:4px;background:#fff;border:1px solid #C5CBDF;border-radius:12px;
+  box-shadow:0 2px 10px rgb(27 33 64/.2)}
+.mx-board-anglein{width:80px;height:34px;box-sizing:border-box;padding:0 6px;border:1.5px solid #2563D9;border-radius:9px;
+  background:#fff;color:#1B2140;font:500 17px/1 "STIX Two Text","Cambria Math","Times New Roman",serif;text-align:center;outline:none}
+.mx-board-angleedit button{width:34px;height:34px;border:1px solid #C5CBDF;border-radius:9px;background:#F4F6FC;color:#1B2140;
+  font:500 18px/1 "STIX Two Text","Cambria Math","Times New Roman",serif;cursor:pointer}
+.mx-board-angleedit button:hover{background:#DCE6FF;border-color:#2563D9}
+.mx-board-arcs{display:flex;gap:4px;padding-inline-start:4px;border-inline-start:1px solid #C5CBDF}
+.mx-board-arcs button{display:inline-flex;align-items:center;justify-content:center;padding:0}
+.mx-board-arcs button[aria-pressed="true"]{background:#DCE6FF;border-color:#2563D9}
+.mx-board-anglerow{display:flex;align-items:center;gap:4px}
+.mx-board-anglerow .mx-board-anglein{flex:1}
+.mx-board-anglerow > .mx-board-arcs{border:0;padding:0}   /* first in its row: no line before it */
+.mx-board-colors{display:flex;gap:4px;padding-inline-start:4px;border-inline-start:1px solid #C5CBDF}
+.mx-board-colors button{display:inline-flex;align-items:center;justify-content:center;padding:0;background:none}
+.mx-board-colors button::before{content:"";width:18px;height:18px;border-radius:50%;background:var(--dot)}
+.mx-board-colors button[aria-pressed="true"]{background:none;border-color:transparent}
+.mx-board-colors button[aria-pressed="true"]::before{box-shadow:0 0 0 2px #fff,0 0 0 4px var(--dot)}
+.mx-board-anglein::placeholder{color:#8A93B8}
 .mx-board-mathwait{flex:1;color:#5B6694;font:500 14px/1.3 var(--f-body);padding:8px}
 
 /* the class teacher's report (math.js: classReport) */
@@ -810,3 +830,96 @@ body{--keyboard-zindex:3000}
 .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)}
+.mx-report-attn{border:1px solid var(--sumac);border-radius:14px;background:var(--sumac-bg);padding:14px 16px}
+.mx-report-attn h4{margin:0 0 6px;color:var(--sumac)}
+.mx-report-open{background:none;border:0;padding:0;margin:0;color:inherit;font:inherit;cursor:pointer;text-decoration:underline}
+.mx-report-week{color:var(--muted);font-size:14px}
+.mx-report-bar{display:flex;flex-wrap:wrap;align-items:center;gap:8px 14px}
+.mx-report-views{display:flex;gap:6px}
+.mx-report-views [aria-pressed="true"]{border-color:var(--mx-accent);color:var(--mx-accent)}
+.mx-report-bar select{font:inherit;color:inherit;background:var(--surface-2);border:1px solid var(--line);border-radius:8px;padding:6px 8px;max-width:100%}
+.mx-report,.mx-grid-wrap{min-width:0;max-width:100%}
+.mx-grid-wrap{overflow-x:auto;border:1px solid var(--line);border-radius:14px;background:var(--surface)}
+.mx-grid{border-collapse:separate;border-spacing:0;font-size:13px;min-width:max-content}
+.mx-grid th,.mx-grid td{padding:6px;text-align:center;border-bottom:1px solid var(--line);font-weight:400}
+.mx-grid .mx-grid-name{position:sticky;inset-inline-start:0;z-index:1;background:var(--surface);text-align:start;white-space:nowrap;border-inline-end:1px solid var(--line)}
+.mx-grid thead th{vertical-align:bottom}
+.mx-grid-unit{min-width:72px;white-space:normal}
+.mx-grid-skill{width:34px;padding-inline:3px}
+.mx-grid-skill span{display:inline-block;writing-mode:vertical-rl;transform:rotate(180deg);max-height:130px;white-space:nowrap;overflow:hidden;text-overflow:ellipsis}
+.mx-grid-skill.hard,.mx-grid-sum.hard{color:var(--sumac);font-weight:700}
+.mx-grid-num{font-weight:700}
+.mx-grid-num.good{color:var(--ok)}.mx-grid-num.mid{color:var(--amber)}.mx-grid-num.low{color:var(--sumac)}
+.mx-grid-sum{color:var(--muted)}
+.mx-grid tfoot th,.mx-grid tfoot td{border-bottom:0}
+.mx-cell{display:block;width:22px;height:22px;margin:0 auto;border-radius:50%;border:2px solid var(--line)}
+.mx-cell.trying{border-color:var(--amber);background:var(--amber-bg)}
+.mx-cell.lit{border-color:var(--ok);background:var(--ok)}
+.mx-cell.fading{border:2px dashed var(--ok);background:var(--ok-bg)}
+.mx-cell.gold{border-color:var(--gold-deep);background:var(--gold)}
+.mx-teacher-note{border:1px solid var(--aurora);border-radius:12px;background:var(--surface-2);padding:10px 14px;margin:8px 0}
+.mx-teacher-note h4{margin:0 0 4px;color:var(--aurora)}
+.mx-teacher-note p{margin:0}
+.mx-ask{margin:8px 0}
+.mx-ask summary{cursor:pointer;color:var(--muted)}
+.mx-ask textarea{display:block;width:100%;margin:8px 0;font:inherit;color:inherit;background:var(--surface-2);border:1px solid var(--line);border-radius:8px;padding:8px;box-sizing:border-box}
+.mx-ask-wait{color:var(--muted)}
+.mx-ask-error{color:var(--sumac)}
+.mx-teacher-comment{display:flex;flex-direction:column;gap:4px;width:100%;margin-top:10px;padding:12px 14px;border:1px solid var(--aurora);border-inline-start:4px solid var(--aurora);border-radius:18px;background:var(--surface);color:var(--ink);font:inherit;text-align:start;cursor:pointer}
+.mx-teacher-comment b{color:var(--aurora)}
+.mx-teacher-comment span{color:var(--muted);font-size:13px;overflow-wrap:anywhere}
+.mx-tr{display:flex;flex-direction:column;gap:12px}
+.mx-tr h5{margin:0 0 6px;font-size:15px;color:var(--mx-accent)}
+.mx-tr p{margin:0}
+.mx-tr-img{max-width:100%;border-radius:12px;border:1px solid var(--line)}
+.mx-tr-request{border:1px solid var(--amber);border-radius:12px;background:var(--amber-bg);padding:10px 14px}
+.mx-tr-request p{margin:4px 0}
+.mx-tr-form{display:flex;flex-direction:column;gap:10px;border-top:1px solid var(--line);padding-top:12px}
+.mx-tr-form label{display:flex;flex-direction:column;gap:4px;font-size:14px;color:var(--muted)}
+.mx-tr-form input,.mx-tr-form textarea{font:inherit;color:var(--ink);background:var(--surface-2);border:1px solid var(--line);border-radius:8px;padding:8px;box-sizing:border-box;width:100%}
+.mx-tr-form input[type=number]{max-width:9ch}
+.mx-helpbtn{border:1px solid var(--line);background:none;color:var(--muted);font-weight:700;font-size:18px;line-height:1;font-family:inherit;border-radius:50%;width:34px;height:34px;padding:0;cursor:pointer}
+.mx-help-wrap{position:static}
+.mx-help-wrap .mx-scrim{z-index:63}
+.mx-help{z-index:64}
+.mx-example{border:1px solid var(--aurora);border-radius:14px;background:var(--surface-2);padding:12px 14px;margin:10px 0}
+.mx-example h4{margin:0 0 6px;color:var(--aurora)}
+.mx-example-q{font-weight:700}
+.mx-example-steps{margin:8px 0;padding-inline-start:22px;display:flex;flex-direction:column;gap:10px}
+.mx-example-steps li span{display:block;color:var(--muted);font-size:14px}
+.mx-example-answer{margin:8px 0}
+.mx-res-visible{flex-direction:row!important;align-items:center;gap:8px}
+.mx-res-vis{font-size:12px;color:var(--muted)}.mx-res-vis.on{color:var(--ok)}
+.mx-res-acts{display:flex;flex-direction:column;gap:6px;align-items:flex-end}
+.mx-skill-res h4{margin:0 0 8px}
+.mx-sres{display:flex;flex-wrap:wrap;gap:12px}
+.mx-sres-item{margin:0;width:calc(50% - 6px);display:flex;flex-direction:column;gap:4px}
+.mx-sres-img{border:1px solid var(--line);border-radius:10px;background:var(--surface-2);padding:0;cursor:zoom-in;overflow:hidden}
+.mx-sres-img img{display:block;width:100%;height:110px;object-fit:cover}
+.mx-sres-item figcaption{font-size:13px;color:var(--muted)}
+.mx-sres-item.zoom{width:100%}.mx-sres-item.zoom .mx-sres-img{cursor:zoom-out}.mx-sres-item.zoom img{height:auto;max-height:70vh;object-fit:contain}
+.mx-sres-open{display:block;margin:6px auto 0;border:1px solid var(--line);border-radius:999px;background:transparent;color:var(--muted);font:inherit;font-size:13px;padding:6px 14px;cursor:pointer}
+.mx-asgs{margin-top:10px;display:flex;flex-direction:column;gap:10px}
+.mx-asgs h2{margin:0;font-size:18px}
+.mx-asg{border:1px solid var(--line);border-inline-start:4px solid var(--aurora);border-radius:18px;background:var(--surface);padding:12px 14px;display:flex;flex-direction:column;gap:6px}
+.mx-asg.late{border-inline-start-color:var(--sumac)}
+.mx-asg-head{display:flex;justify-content:space-between;gap:10px;align-items:baseline}
+.mx-asg-due{color:var(--muted);font-size:13px;white-space:nowrap}.mx-asg.late .mx-asg-due{color:var(--sumac);font-weight:700}
+.mx-asg-note,.mx-asg-count{margin:0;color:var(--muted);font-size:14px}.mx-asg-count b{color:var(--ink)}
+.mx-asg-items{margin:0;padding:0;list-style:none;display:flex;flex-direction:column;gap:4px;font-size:14px}
+.mx-asg-items li.done{color:var(--muted)}.mx-asg-items li.done span:first-child{color:var(--ok)}
+.mx-asg-done summary{cursor:pointer;color:var(--muted)}.mx-asg-done ul{margin:6px 0 0;padding-inline-start:18px}
+.mx-asg-pin{position:absolute;top:-6px;inset-inline-end:-6px;font-size:14px;line-height:1;pointer-events:none}
+.mx-asg-t{border:1px solid var(--line);border-radius:14px;background:var(--surface);padding:12px 14px;display:flex;flex-direction:column;gap:6px}
+.mx-asg-t.past{border-color:var(--amber)}
+.mx-asg-who summary{cursor:pointer;color:var(--mx-accent)}
+.mx-asg-cell.ok{color:var(--ok)}.mx-asg-cell.late{color:var(--amber)}.mx-asg-cell.none,.mx-asg-cell.unknown{color:var(--muted)}
+.mx-asg-form{display:flex;flex-direction:column;gap:10px;border:1px solid var(--line);border-radius:14px;background:var(--surface);padding:14px}
+.mx-asg-form h4{margin:0}
+.mx-asg-form label{display:flex;flex-direction:column;gap:4px;font-size:14px;color:var(--muted)}
+.mx-asg-form input[type=text],.mx-asg-form input:not([type]),.mx-asg-form input[type=date],.mx-asg-form textarea{font:inherit;color:var(--ink);background:var(--surface-2);border:1px solid var(--line);border-radius:8px;padding:8px;box-sizing:border-box;width:100%}
+.mx-asg-form fieldset{border:1px solid var(--line);border-radius:10px;padding:8px 12px;display:flex;flex-direction:column;gap:6px}
+.mx-asg-form legend{color:var(--mx-accent);font-size:14px;padding:0 6px}
+.mx-asg-form details>summary{cursor:pointer}
+.mx-asg-checks{display:flex;flex-direction:column;gap:4px;padding:6px 0}
+.mx-asg-checks label{flex-direction:row;align-items:center;gap:8px;color:var(--ink)}

static/math.js

@@ -47,6 +47,7 @@ function mergeProgress(a,b){
   const joined=(k,id)=>{ const by=new Map(); for(const x of list(k)) by.set(id(x),x); return [...by.values()]; };
   for(const k of new Set([...Object.keys(old),...Object.keys(neu)])) if(isObj(old[k])&&isObj(neu[k])) each(k);   // newer per key
   each("done",earliest); each("gold",earliest); each("seen",latest); each("tries",most); each("days",most);
+  each("examples",(x,y)=>({n:most(x?.n,y?.n),last:latest(x?.last||"",y?.last||"")}));   // worked examples opened, per skill
   each("solved",(x,y)=>[...new Set([...(Array.isArray(x)?x:[]),...(Array.isArray(y)?y:[])])].sort((p,q)=>p-q));
   out.comets=[...new Set(list("comets"))];
   out.slips=joined("slips",s=>JSON.stringify([s?.at,s?.id,s?.q,s?.m])).sort((x,y)=>String(x?.at).localeCompare(String(y?.at))).slice(-500);
@@ -72,12 +73,15 @@ document.addEventListener("visibilitychange",async()=>{
   if(!synced()||!G) return;
   if(document.visibilityState==="hidden"){ if(pushTimer) pushProgress(); return; }
   if(cur) return;   // a question or exam is open: take the other device's work next time
+  loadComments();   // the teacher may have reviewed an answer meanwhile
+  loadAssignments();
   const remote=await pullProgress(); if(!remote||cur) return;
   P=Sky.ensure(mergeProgress(P,remote)); try{ localStorage.setItem(key(),JSON.stringify(P)); }catch{}
   if(ACTIVE_SUBJECT==="מתמטיקה"&&!root?.hidden) draw();
 });
 
 let G=null, BY={}, POST={}, ORDER=[], P={done:{},tries:{},solved:{},at:{}}, root=null, curQ=0, path=null, sheet=null, cur=null, back=null, ACTIVE_SUBJECT="";
+const ROUND_WRONG={};   // wrong answers per skill in its current round: from the second the worked example is offered
 let nav=null, FIRST=true, COMBO=0, REV=null, QZ=null, UQ=null;   // UQ: the unit quiz on the sheet (see unit quiz below)   // QZ: the practice exam in progress (see quiz below)   // the tab bar; whether the shown question is still at its first try; first-try answers in a row
 let picker=null, PH=null, resPicker=null, RES=null;   // RES: the open lesson-resources sheet (see openResources())   // the photo file picker, and the photographed problem on the sheet (see photo())
 let advanceTimer=null;
@@ -151,7 +155,12 @@ async function show(){
     nav=document.createElement("nav"); nav.className="mx-nav"; nav.setAttribute("aria-label","ניווט"); nav.hidden=true;
     root.append(path,sheet,picker,resPicker,nav); document.body.append(root); window.MathlySky.mount(root);
     root.addEventListener("click",onClick);
-    document.addEventListener("keydown",e=>{ if(e.key==="Escape"&&cur) QZ?.items?quizQuit():closeSheet(); });   // an exam asks before it is left
+    root.addEventListener("submit",e=>{
+      if(e.target.matches?.("[data-review-form]")){ e.preventDefault(); reviewSave(e.target); }
+      else if(e.target.matches?.("[data-asg-form]")){ e.preventDefault(); asgSave(e.target); }
+    });
+    root.addEventListener("change",e=>{ if(e.target.matches?.("[data-report-sort],[data-report-unit]")) reportControl(e.target); });
+    document.addEventListener("keydown",e=>{ if(e.key==="Escape"&&helpOpen()) return helpClose(); if(e.key==="Escape"&&cur) QZ?.items?quizQuit():closeSheet(); });   // an exam asks before it is left
   }
   root.hidden=false;
   if(!G){
@@ -165,6 +174,8 @@ async function show(){
   if(!P.set||typeof P.set!=="object") P.set={}; SHOWN=new Set(shownUnits().map(u=>u.id));
   hasExams()?drawSubjectPicker():selectSubject("מתמטיקה");   // no exams yet: straight to math, science is a tap away
   if(CFG.aiReview) aqCount();
+  loadComments();
+  loadAssignments();
   window.MathlyAnswers?.configure({api,account:CFG.userId,enabled:CFG.answerScans,root,queued:CFG.aiDirect===false,onGraded:({questionId,grading})=>{
     if(grading.result.verdict!=="correct"||P.done[questionId])return;
     const unitWas=unitDone(unitOf(questionId));
@@ -349,15 +360,15 @@ function orbitRing(sts){
   return `<svg class="mx-ring" viewBox="0 0 100 100" aria-hidden="true">${back}${arcs}</svg>`;
 }
 function pathView(){
-  const nxt=next(), cls=MY_CLASS?` · כיתת ${esc(MY_CLASS.name)}`:"", teach=can("students.view");
+  const nxt=next(), cls=MY_CLASS?` · כיתת ${esc(MY_CLASS.name)}`:"", teach=can("students.view"), marks=asgMarks();
   const fix=new Set(myPatterns().recurring.map(x=>x.practise));   // skills that a recurring mistake sends back to
   const units=mineUnits().map(u=>{
     const ids=unitIds(u), act=ids.filter(live), lit=act.filter(id=>P.done[id]).length, n=ids.length, full=unitDone(u);
     const sts=ids.map(id=>Sky.star(P,id,status(id),id===nxt));
-    const steps=ids.map((id,i)=>{ const st=sts[i], tag=st==="next"?"ממשיכים כאן":fix.has(id)?"לחזק":st==="fading"?"דועך":"";
+    const steps=ids.map((id,i)=>{ const st=sts[i], tag=st==="next"?"ממשיכים כאן":fix.has(id)?"לחזק":st==="fading"?"דועך":"", given=marks.get(id);
       const t=(-90+360*i/n)*Math.PI/180, dx=Math.cos(t), dy=Math.sin(t), up=dy<-.3;
       return `<div class="mx-step mx-orb u-${u.id}${up?" up":""}" style="--dx:${dx.toFixed(3)};--dy:${dy.toFixed(3)}">
-        <button class="mx-node mx-star st-${st}${fix.has(id)?" fix":""}" data-id="${id}" aria-label="${i+1}. ${esc(plain(BY[id].name))}: ${STATE_NAME[st]}${fix.has(id)?", כדאי לחזק":""}">${Sky.spark()}<span class="mx-num" aria-hidden="true">${i+1}</span>${st==="next"?`<span class="mx-perch">${Sky.owl(34)}</span>`:""}</button>
+        <button class="mx-node mx-star st-${st}${fix.has(id)?" fix":""}" data-id="${id}" aria-label="${i+1}. ${esc(plain(BY[id].name))}: ${STATE_NAME[st]}${fix.has(id)?", כדאי לחזק":""}${given?`, משימה מהמורה: ${esc(given.join(", "))}`:""}">${Sky.spark()}<span class="mx-num" aria-hidden="true">${i+1}</span>${given?'<span class="mx-asg-pin" aria-hidden="true">📌</span>':""}${st==="next"?`<span class="mx-perch">${Sky.owl(34)}</span>`:""}</button>
         <span class="mx-lbl l-${st}${fix.has(id)?" l-fix":""}">${fmt(BY[id].short)}${tag?`<em>${tag}</em>`:""}</span></div>`; }).join("");
     const res=teach?` data-act="resources" data-unit="${u.id}"`:"";   // a teacher opens the lesson's resources from its title
     const pct=act.length?Math.round(100*lit/act.length):0;
@@ -368,7 +379,7 @@ function pathView(){
         ${steps}</div>
       ${teach?`<button class="mx-res-open"${res} aria-label="משאבי השיעור ${esc(u.name)}">📷 משאבים</button>`:""}</section>${quizStep(u)}`;
   }).join("");
-  return `${topBar()}${daily()}${reviewCard()}${patternsCard()}${examSoon()}${quizCard()}<div class="mx-pghead"><h2>המסלול שלי</h2><p class="mx-sub">אלגברה וגאומטריה כיתה ט׳ · 5 יח״ל${cls}</p></div>
+  return `${topBar()}${commentsCard()}${assignmentsCard()}${daily()}${reviewCard()}${patternsCard()}${examSoon()}${quizCard()}<div class="mx-pghead"><h2>המסלול שלי</h2><p class="mx-sub">אלגברה וגאומטריה כיתה ט׳ · 5 יח״ל${cls}</p></div>
     <div class="mx-trail">
       <div class="mx-start"><span class="mx-flag">${Sky.owl(40)}</span><b>התחלה</b></div>${units}
       <div class="mx-finish" aria-hidden="true">${Sky.spark()}<b>סוף המסלול</b></div></div>
@@ -395,6 +406,7 @@ function draw(){
   path.innerHTML=VIEW==="sky"?collectionView():pathView();
   nav.hidden=false;
   nav.innerHTML=`<div>${TABS.map(([v,label,icon])=>`<button data-view="${v}"${VIEW===v?' aria-current="page"':""}>${icon}<span>${label}</span></button>`).join("")}</div>`;
+  decorateUnits();
 }
 function setView(view,unit){
   VIEW=view; draw(); root.scrollTop=0;
@@ -437,7 +449,121 @@ function rewards(id,{r,lit,unitWas}){
 function chips(ids){
   return ids.length?ids.map(id=>`<button class="mx-chip u-${BY[id].unit}${P.done[id]?" is-done":""}" data-id="${id}">${P.done[id]?"✓ ":""}${fmt(BY[id].short)}</button>`).join(""):'<em>אין</em>';
 }
+/* ---------- the teacher's assignments (app/assignments.py) ----------
+   GET /api/math/assignments gives the student's classes' assignments and when they handed in each unit quiz. Whether an
+   item is done is worked out on the page (Sky.assignmentState) from the progress and those sittings, so the card and the
+   teacher's report always agree. A card on the home screen lists the open ones, and the done ones for two weeks. */
+let ASG=null;
+async function loadAssignments(){
+  if(!CFG.userId||!MY_CLASSES.length) return;
+  try{ const r=await api("/api/math/assignments",{cache:"no-store"}); ASG=r.ok?await r.json():null; }catch{ ASG=null; }
+  if(ACTIVE_SUBJECT==="מתמטיקה"&&root&&!root.hidden&&!cur) draw();   // not over the subject picker
+}
+function asgView(){
+  if(!ASG?.assignments?.length) return null;
+  const now=new Date(), cutoff=Sky.jerusalemDay(now-14*864e5);
+  const rows=ASG.assignments.map(a=>({a,s:Sky.assignmentState(a,P,ASG.sittings,now)}));
+  return {open:rows.filter(x=>!x.s.finished).sort((p,q)=>p.a.due_on.localeCompare(q.a.due_on)),
+    done:rows.filter(x=>x.s.finished&&x.a.due_on>=cutoff).sort((p,q)=>q.a.due_on.localeCompare(p.a.due_on))};
+}
+const asgDate=due=>new Date(due+"T12:00:00").toLocaleDateString("he-IL",{day:"numeric",month:"numeric"});
+const asgUnit=id=>esc(G.units.find(u=>u.id===id)?.name||id);
+function asgItemLabel(item){
+  if(item.kind==="skill") return BY[item.id]?fmt(BY[item.id].name):esc(item.id);
+  if(item.kind==="unit_quiz") return `בוחן מסכם: ${asgUnit(item.unit)}`;
+  return `מבחן תרגול: ${(item.units||[]).map(asgUnit).join(", ")}`;
+}
+// the skills of unfinished assignments, with the titles, for the marker on the path
+function asgMarks(){
+  const marks=new Map();
+  for(const {a} of asgView()?.open||[]) for(const item of a.items) if(item.kind==="skill") marks.set(item.id,[...(marks.get(item.id)||[]),a.title]);
+  return marks;
+}
+function assignmentsCard(){
+  const v=asgView(); if(!v||(!v.open.length&&!v.done.length)) return "";
+  const several=new Set(ASG.assignments.map(a=>a.class_id)).size>1;
+  const open=v.open.map(({a,s})=>`<article class="mx-asg${s.overdue?" late":""}">
+      <div class="mx-asg-head"><b>${esc(a.title)}</b><span class="mx-asg-due">${s.overdue?"באיחור · ":""}עד ${asgDate(a.due_on)}</span></div>
+      ${several?`<small class="mx-small">${esc(a.class_name)}</small>`:""}${a.note?`<p class="mx-asg-note">${esc(a.note)}</p>`:""}
+      <p class="mx-asg-count"><b>${s.doneCount}</b> מתוך ${s.total} הושלמו</p>
+      <ul class="mx-asg-items">${s.items.map(x=>`<li class="${x.done?"done":""}"><span aria-hidden="true">${x.done?"✓":"○"}</span> ${asgItemLabel(x.item)}${x.done?'<span class="mx-sr"> (הושלם)</span>':""}${x.known?"":" <small>(לא ניתן לבדוק כרגע)</small>"}</li>`).join("")}</ul>
+      <button type="button" class="mx-btn solid" data-asg-go="${esc(a.id)}">${s.doneCount?"להמשיך":"להתחיל"}: ${asgItemLabel(s.items[s.next].item)}</button></article>`).join("");
+  const done=v.done.length?`<details class="mx-asg-done"><summary>הושלמו (${v.done.length})</summary><ul>${v.done.map(({a,s})=>
+    `<li>✓ ${esc(a.title)} <small>עד ${asgDate(a.due_on)}${s.late?" · הוגשה באיחור":""}</small></li>`).join("")}</ul></details>`:"";
+  return `<section class="mx-asgs" aria-label="משימות מהמורה"><h2>משימות מהמורה</h2>${open}${done}</section>`;
+}
+// opens the first item of the assignment that is not done
+function asgGo(id){
+  const a=ASG?.assignments.find(x=>x.id===id); if(!a) return;
+  const s=Sky.assignmentState(a,P,ASG.sittings), item=s.items[s.next]?.item; if(!item) return;
+  if(item.kind==="skill") return BY[item.id]&&open(item.id);
+  if(item.kind==="unit_quiz") return uqIntro(item.unit);
+  stopQuizClock(); QZ=null; return quizSetup(item.units);
+}
+
+/* Answers the teacher has reviewed that the student has not opened since (GET /api/math/teacher-comments): a card on
+   the home screen opens the first one. Opening an answer tells the server it was seen, and drops it from the list. */
+let TC=[];
+async function loadComments(){
+  if(!CFG.userId||!CFG.answerScans) return;
+  try{ const r=await api("/api/math/teacher-comments",{cache:"no-store"}); TC=r.ok?(await r.json()).comments||[]:[]; }catch{ TC=[]; }
+  if(ACTIVE_SUBJECT==="מתמטיקה"&&root&&!root.hidden&&!cur) draw();   // not over the subject picker
+}
+const commentSeen=pred=>{ const n=TC.length; TC=TC.filter(c=>!pred(c)); return TC.length!==n; };
+function commentsCard(){
+  if(!TC.length) return "";
+  const c=TC[0], more=TC.length-1;
+  return `<button type="button" class="mx-teacher-comment" data-comment="${esc(c.attempt_id)}"><b>המורה הגיב על תשובה שלכם</b>
+    <span>${fmt(c.question||"")}${c.score==null?"":` · ${c.score}/100`}${more?` · ועוד ${more}`:""}</span></button>`;
+}
+function openComment(attemptId){
+  const c=TC.find(x=>x.attempt_id===attemptId); if(!c) return;
+  const [kind,uid]=String(c.question_id).split(":");
+  if(kind==="quiz"){
+    const h=(uqState(uid).history||[]).findIndex(e=>(e.attempts||[]).includes(attemptId));
+    return h>=0?uqResult(uid,h):uqIntro(uid);   // this device does not have that sitting: the quiz page lists the past ones
+  }
+  if(BY[c.question_id]) open(c.question_id);
+}
+/* ---------- help while practising a skill ----------
+   The "?" in a skill's sheet opens a panel on top of the question: the skill's description, its worked example (a
+   question of its own, solved one step at a time with the reason for each) and the teacher's explanations of it. The
+   question underneath is not touched, so closing the panel returns to it as it was. The worked example is also offered
+   after the second mistake in a round. Opening the example is kept (P.examples) for the teacher's report; it changes
+   nothing about finishing or gold, which still need clean first-try answers. */
+let helpBack=null;
+const helpOpen=()=>!!sheet?.querySelector(".mx-help-wrap");
+function helpClose(){ const el=sheet?.querySelector(".mx-help-wrap"); if(!el) return; el.remove(); helpBack?.focus?.({preventScroll:true}); helpBack=null; }
+function exampleCard(ex){
+  return `<section class="mx-example"><h4>דוגמה פתורה</h4><p class="mx-example-q">${fmt(ex.question)}</p>
+    <ol class="mx-example-steps">${ex.steps.map((st,i)=>`<li${i?" hidden":""}><b>${fmt(st.do)}</b><span>${fmt(st.why)}</span></li>`).join("")}</ol>
+    <p class="mx-example-answer" hidden><b>התשובה: </b>${fmt(ex.answer)}</p>
+    <button type="button" class="mx-btn" data-example-next>${ex.steps.length>1?"הצעד הבא":"הצגת התשובה"}</button></section>`;
+}
+// one more step, then the answer
+function exampleNext(btn){
+  const box=btn.closest(".mx-example"), next=box.querySelector(".mx-example-steps li[hidden]");
+  if(next){ next.hidden=false; if(!box.querySelector(".mx-example-steps li[hidden]")) btn.textContent="הצגת התשובה"; next.scrollIntoView({block:"nearest"}); return; }
+  box.querySelector(".mx-example-answer").hidden=false; btn.hidden=true;
+}
+function showHelp(id){
+  const s=BY[id]; if(!s||!sheet||sheet.hidden) return;
+  if(s.example){ const e=((P.examples||={})[id]||={n:0,last:""}); e.n++; e.last=new Date().toISOString(); save(); }
+  if(!helpOpen()) helpBack=document.activeElement;
+  sheet.querySelector(".mx-help-wrap")?.remove();
+  const el=document.createElement("div"); el.className="mx-help-wrap";
+  el.innerHTML=`<div class="mx-scrim" data-act="help-close"></div>
+    <div class="mx-sheet mx-help u-${s.unit}" role="dialog" aria-modal="true" aria-labelledby="mxHelpTitle">
+      <div class="mx-shtop"><h3 id="mxHelpTitle">עזרה: ${fmt(s.name)}</h3><div class="mx-shacts"><button class="mx-x" data-act="help-close" aria-label="חזרה לשאלה">✕</button></div></div>
+      <p>${fmt(s.description)}</p>
+      ${s.example?exampleCard(s.example):'<p class="mx-note">לכישור הזה עוד אין דוגמה פתורה.</p>'}
+      <div class="mx-help-resources" data-help-resources="${esc(id)}"></div>
+      <button type="button" class="mx-btn solid" data-act="help-close">חזרה לשאלה</button></div>`;
+  sheet.append(el); el.querySelector(".mx-x").focus({preventScroll:true});
+  fillExplanations(el.querySelector("[data-help-resources]"),s.unit,r=>r.skill_id===id);
+}
 function open(id){
+  commentSeen(c=>c.question_id===id);
   stopPhone();
   cancelAdvance();
   const s=BY[id], st=status(id), unit=G.units.find(u=>u.id===s.unit), all=QS(s);
@@ -451,12 +577,13 @@ function open(id){
     <div class="mx-sheet u-${s.unit}" role="dialog" aria-modal="true" aria-labelledby="mxTitle">
       <div class="mx-shtop"><div><span class="mx-uchip">${esc(unit.name)}</span>${s.core?' <span class="mx-core">ליבה 5 יח״ל</span>':""}
         <h3 id="mxTitle">${fmt(s.name)}</h3><small class="mx-src">${s.month?`בפריסה: ${esc(s.month)}`:esc(unit.source)}${st==="done"?" · הושלמה ✓":""}</small></div>
-        <div class="mx-shacts">${window.MathlyBoard?.button()||""}<button class="mx-x" data-act="close" aria-label="סגירה">✕</button></div></div>
+        <div class="mx-shacts">${window.MathlyBoard?.button()||""}<button class="mx-helpbtn" data-help="${id}" aria-label="עזרה: ההסבר והדוגמה הפתורה" title="עזרה">?</button><button class="mx-x" data-act="close" aria-label="סגירה">✕</button></div></div>
       <p>${fmt(s.description)}</p>
       <div class="mx-q">${n>1?`<div class="mx-qprog"><span>שאלה ${r.indexOf(curQ)+1} מתוך ${n}</span><span class="mx-qdots" aria-label="נפתרו ${gotN} מתוך ${n}">${r.map(i=>`<i class="${got.has(i)?"ok":""}${i===curQ?" now":""}"></i>`).join("")}</span></div>`:""}
         <p>${fmt(q.question)}</p>${figures(q)}
         ${st==="off"?'<p class="mx-note mx-off">השאלה הזו סגורה כרגע לתשובות. היא לא נדרשת כדי להתקדם במסלול.</p>':openEnded?'<div class="mx-answer"></div>':choiceButtons(q)}
         <div class="mx-fb" aria-live="polite"></div></div>
+      <div class="mx-sec mx-skill-res" data-skill-res hidden></div>
       <div class="mx-sec"><h4>דורשת</h4><div class="mx-chips">${chips(s.prereqs)}</div></div>
       <div class="mx-sec"><h4>פותחת</h4><div class="mx-chips">${chips(POST[id])}</div></div>
     </div>`;
@@ -464,8 +591,9 @@ function open(id){
   window.MathlyBoard?.mount(sheet,`${id}:${curQ}`,{question:()=>sheet.querySelector(".mx-q")});   // the sketch board beside the exercise, when the student has it on
   sheet.querySelector(".mx-x").focus({preventScroll:true});
   if(openEnded&&st!=="off")window.MathlyAnswers?.mountQuestion(sheet.querySelector(".mx-answer"),id,s.question_version);
+  fillExplanations(sheet.querySelector("[data-skill-res]"),s.unit,r=>r.skill_id===id);
 }
-function closeSheet(){ stopPhone(); dropResources(); dropQueue(); cancelAdvance(); REV=null; stopQuizClock(); QZ=null; stopUnitQuiz(); if(sheet)sheet.hidden=true; cur=null; back?.focus?.({preventScroll:true}); back=null; }
+function closeSheet(){ stopPhone(); dropResources(); dropQueue(); dropReview(); cancelAdvance(); REV=null; stopQuizClock(); QZ=null; stopUnitQuiz(); if(sheet)sheet.hidden=true; cur=null; back?.focus?.({preventScroll:true}); back=null; }
 
 // counts down, then opens `target` (a skill id); stops if the student moved on in the meantime
 function autoAdvance(id,target){
@@ -498,7 +626,7 @@ function answer(btn){
     // done once every question is solved and the last answers were right at the first try
     const run=FIRST?(P.run[id]||0)+1:0, need=Sky.masterNeed(n);
     const first=!P.done[id]&&gotN>=n&&run>=need, unitWas=unitDone(unitOf(id));
-    if(first){ P.done[id]=new Date().toISOString(); Sky.mastered(P,id); }
+    if(first){ P.done[id]=new Date().toISOString(); Sky.mastered(P,id); delete ROUND_WRONG[id]; }
     COMBO=FIRST?COMBO+1:0;
     const persisted=!FIRST;
     const r=Sky.correct(P,id,{first:FIRST,n,finished:!!P.done[id]}); FIRST=false;
@@ -531,7 +659,11 @@ function answer(btn){
   // with a list of questions, a missed question comes back later, shuffled; the right answer is not shown,
   // so solving it then shows understanding, not memory
   if(n>1) buttons.forEach(b=>b.disabled=true); else btn.disabled=true;
+  // from the second mistake in the round the worked example is offered (the first is often a slip, and the tip covers it)
+  ROUND_WRONG[id]=(ROUND_WRONG[id]||0)+1;
+  const offer=ROUND_WRONG[id]>=2&&BY[id].example?`<button type="button" class="mx-btn" data-example="${id}">איך פותרים? דוגמה פתורה</button>`:"";
   fb.innerHTML=`<div class="mx-bad"><small class="mx-small">טעות נפוצה, וטוב שהיא עולה עכשיו</small><b>${fmt(M.name)}</b><span>${fmt(M.tip)}</span>
+    ${offer}
     ${n>1?`<span class="mx-small">השאלה תחזור אחרי שאר השאלות, ותוכלו לנסות אותה שוב.</span><button class="mx-btn solid" data-id="${id}">לשאלה הבאה</button>`:""}
     ${to?`<button class="mx-btn" data-id="${to}">לחזק קודם את: ${fmt(BY[to].short)}</button>`:n>1?"":"<span class=\"mx-small\">אפשר לבחור תשובה אחרת.</span>"}
     ${patternNote(m,[id,to])}</div>`;
@@ -675,8 +807,13 @@ function quizCard(){
     <span>${QUIZ_SIZE} שאלות מ־${on.size} יחידות, מעורבבות, כמו במבחן. המשוב מגיע בסוף, עם תוכנית: מה לחזק עד המבחן.</span>
     ${last?`<span>בפעם הקודמת: ${last.right} מתוך ${last.n}</span>`:""}<span class="mx-dgo">להתחיל ‹</span></button>`;
 }
-function quizSetup(){
-  const {exam,offered,on}=quizUnits();
+function quizSetup(preset){
+  let {exam,offered,on}=quizUnits();
+  if(Array.isArray(preset)){   // an assignment asks for these units: they are offered whatever the schedule says, and chosen
+    const all=mineUnits().map(u=>({u,ids:unitIds(u).filter(id=>live(id)&&choiceSkill(id))})).filter(x=>x.ids.length);
+    offered=[...offered,...all.filter(x=>preset.includes(x.u.id)&&!offered.some(o=>o.u.id===x.u.id))];
+    on=new Set(preset.filter(id=>offered.some(o=>o.u.id===id)));
+  }
   if(!cur) back=document.activeElement;
   cur="quiz"; QZ={setup:true,on,offered};
   sheet.innerHTML=`<div class="mx-scrim" data-act="close"></div>
@@ -684,7 +821,7 @@ function quizSetup(){
       <div class="mx-shtop"><div><span class="mx-uchip">מבחן תרגול</span><h3 id="mxTitle">${exam?`לקראת המבחן ב${esc(exam.subject)} ${inDays(exam.days)}`:"מבחן תרגול"}</h3>
         <small class="mx-src">${QUIZ_SIZE} שאלות · זמן מומלץ: כ־${Math.round(QUIZ_SIZE*QUIZ_MIN_PER_Q/5)*5} דקות, בלי לחץ: השעון רק מראה.</small></div>
         <button class="mx-x" data-act="close" aria-label="סגירה">✕</button></div>
-      <p>אילו יחידות במבחן? סימנו את מה שנלמד עד ${exam?"המבחן":"עכשיו"}. אפשר לשנות.</p>
+      <p>${Array.isArray(preset)?"המורה ביקש מבחן תרגול על היחידות המסומנות. כדי שהמשימה תיחשב, השאירו את כולן מסומנות.":`אילו יחידות במבחן? סימנו את מה שנלמד עד ${exam?"המבחן":"עכשיו"}. אפשר לשנות.`}</p>
       <div class="mx-quiz-units">${offered.map(({u})=>`<button class="mx-btn" data-quiz-unit="${u.id}" aria-pressed="${on.has(u.id)}">${esc(u.name)}</button>`).join("")}</div>
       <p class="mx-small">השאלות מעורבבות ושם הנושא לא מופיע: לזהות איזו דרך מתאימה זה חלק מהמבחן. אין משוב באמצע, כמו במבחן אמיתי.</p>
       <button class="mx-btn solid" data-act="quiz-start"${on.size?"":" disabled"}>להתחיל</button></div>`;
@@ -1000,6 +1137,7 @@ async function uqResult(uid,h,check=false){
         <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="";
+  commentSeen(c=>entry.attempts.includes(c.attempt_id));
   try{ await uqSend(uid,entry); }catch(e){ sendError=e.message; }
   if(UQ?.uid!==uid) return;
   const results=[];
@@ -1025,6 +1163,7 @@ async function uqResult(uid,h,check=false){
     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(sitting?.questions[i]?.state==="teacher") 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?"הבדיקה האוטומטית אינה זמינה כרגע":"עוד לא נבדקה"); }
@@ -1032,8 +1171,10 @@ async function uqResult(uid,h,check=false){
       <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]}">`:""}
       <p class="mx-uq-verdict ${a?.verdict||"none"}">${esc(say)}</p>
-      ${a?.feedback?`<p>${fmtLoose(a.feedback)}</p>`:""}${a?.next_step?`<p><b>הצעד הבא: </b>${fmtLoose(a.next_step)}</p>`:""}
+      ${window.MathlyAnswers?.teacherNote?.(r||{})||""}
+      ${a?.feedback?`<p>${r.teacher_review?"<b>בדיקה אוטומטית: </b>":""}${fmtLoose(a.feedback)}</p>`:""}${a?.next_step?`<p><b>הצעד הבא: </b>${fmtLoose(a.next_step)}</p>`:""}
       ${a?.solution?`<details><summary>הפתרון המלא</summary><p class="mx-grade-solution">${fmtLoose(a.solution)}</p></details>`:""}
+      ${r?.attachment?window.MathlyAnswers?.reviewBox?.(entry.attempts[i],r)||"":""}
       ${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>`;
   });
   const earned=sitting?sitting.questions.reduce((sum,x)=>sum+(x.earned||0),0):0, open=sitting?sitting.open:n;
@@ -1056,6 +1197,21 @@ function onClick(e){
   if(t.dataset.quizUnit) return quizToggle(t.dataset.quizUnit);
   if(t.dataset.quizGo!=null) return quizGo(+t.dataset.quizGo);
   if(t.dataset.uquiz) return uqIntro(t.dataset.uquiz);   // a sitting in progress opens straight on its paper
+  if(t.dataset.sres) return t.closest(".mx-sres-item").classList.toggle("zoom");
+  if(t.dataset.help) return showHelp(t.dataset.help);
+  if(t.dataset.example) return showHelp(t.dataset.example);
+  if(t.dataset.exampleNext!=null) return exampleNext(t);
+  if(t.dataset.aqTab) return aqTab(t.dataset.aqTab);
+  if(t.dataset.reviewAnswer) return trOpenAnswer(t.dataset.reviewAnswer,t.dataset.reviewFrom);
+  if(t.dataset.reviewBack!=null) return TR?.back?.();
+  if(t.dataset.answers) return reviewSitting(...t.dataset.answers.split(":"));
+  if(t.dataset.askReview!=null) return window.MathlyAnswers.askReview(t);
+  if(t.dataset.comment) return openComment(t.dataset.comment);
+  if(t.dataset.asgGo) return asgGo(t.dataset.asgGo);
+  if(t.dataset.asgNew!=null){ REPORT.form={id:null}; drawReport(); return sheet.querySelector(".mx-asg-form input[name=title]")?.focus(); }
+  if(t.dataset.asgEdit){ REPORT.form={id:t.dataset.asgEdit}; drawReport(); return sheet.querySelector(".mx-asg-form input[name=title]")?.focus(); }
+  if(t.dataset.asgCancel!=null){ REPORT.form=null; return drawReport(); }
+  if(t.dataset.asgDel) return asgDelete(t.dataset.asgDel);
   if(t.dataset.uqResult){ const [uid,h,check]=t.dataset.uqResult.split(":"); return uqResult(uid,+h,check==="check"); }
   if(t.dataset.uqPhoto!=null){ UQ.pick=+t.dataset.uqPhoto; return sheet.querySelector("[data-uq-file]").click(); }
   if(t.dataset.uqPhone!=null) return uqPhone(+t.dataset.uqPhone);
@@ -1068,9 +1224,12 @@ function onClick(e){
   if(t.dataset.manageMode) return showManageMode(t.dataset.manageMode);
   if(t.dataset.classAction) return manageClassAction(t.dataset.classAction,t.dataset.classId);
   if(t.dataset.reportClass!=null) return classReport(t.dataset.reportClass);
+  if(t.dataset.reportStudent!=null) return reportOpenStudent(t.dataset.reportStudent);
+  if(t.dataset.reportTab) return reportControl(t);
   if(t.dataset.aqSend) return aqSend(t.dataset.aqSend);
   if(t.dataset.aqDecline) return aqDecline(t.dataset.aqDecline);
   switch(t.dataset.act){
+    case "help-close": return helpClose();
     case "manage": return manageClasses();
     case "class-report": return classReport();
     case "ai-queue": return aiQueue();
@@ -1099,6 +1258,8 @@ function onClick(e){
     case "resources": return openResources(t.dataset.unit);
     case "res-take": case "res-retake": return resPicker.click();
     case "res-cancel": RES.photo=null; RES.msg=""; return drawResources();
+    case "res-visible": return setResourceVisible(t.dataset.res,t.dataset.visible==="1");
+    case "unit-explanations": return openExplanations(t.dataset.unit);
     case "res-delete": return deleteResource(t.dataset.res);
     case "photo": case "retake": return picker.click();
     case "hint": PH.shown++; return drawPhoto();
@@ -1469,12 +1630,16 @@ function reportOf(student,units){
   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,quizzesKnown:sittings!=null,quizAvg:scores.length?Math.round(scores.reduce((a,b)=>a+b,0)/scores.length):null,exams,last};
+  // worked examples the student opened in the last two weeks, in the class's skills (the device reports them)
+  const classSkills=new Set(units.flatMap(u=>unitIds(u).filter(live))), since=Date.now()-14*864e5;
+  const helped=Object.entries(p.examples||{}).filter(([id,e])=>classSkills.has(id)&&BY[id]&&Date.parse(e?.last)>=since)
+    .map(([id,e])=>({id,n:+e.n||1,last:e.last})).sort((a,b)=>b.last.localeCompare(a.last));
+  return {perUnit,n,done,helped,week:Sky.weekly(p),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;
   if(!cur) back=document.activeElement;
-  closeSheetQuietly(); cur="report"; REPORT={id:classId,data:null};
+  closeSheetQuietly(); cur="report"; REPORT={id:classId,data:null,form:null,tab:repGet("tab","list"),sort:repGet("sort","attention"),unit:repGet("unit","overview")};
   const tabs=mine.length>1?`<div class="mx-report-tabs">${mine.map(row=>`<button class="mx-btn" data-report-class="${esc(row.id)}" aria-pressed="${String(row.id)===String(classId)}">${esc(row.name)}</button>`).join("")}</div>`:"";
   sheet.innerHTML=`<div class="mx-scrim"></div>
     <div class="mx-sheet mx-manage-sheet mx-report-sheet" role="dialog" aria-modal="true" aria-labelledby="mxTitle">
@@ -1489,51 +1654,290 @@ async function classReport(id){
     REPORT.data=data; drawReport();
   }catch(e){ if(cur==="report") sheet.querySelector(".mx-manage-state").textContent=e.message; }
 }
+// a student named in the attention list: their card opens and scrolls into view
+function reportOpenStudent(i){
+  const card=sheet.querySelector(`#rs-${+i}`); if(!card) return;
+  card.open=true; card.scrollIntoView({block:"nearest"}); card.querySelector("summary").focus({preventScroll:true});
+}
 function closeSheetQuietly(){ const b=back; closeSheet(); back=b; }
+// the teacher's choices in the report (list or grid, which unit, the order) are kept on this device
+const repGet=(k,def)=>{ try{ return localStorage.getItem("mathly.report."+k)||def; }catch{ return def; } };
+const repSet=(k,v)=>{ try{ localStorage.setItem("mathly.report."+k,v); }catch{} };
+const REPORT_SORTS={attention:"דורשים תשומת לב קודם",name:"שם",progress:"התקדמות",activity:"פעילות אחרונה (הישנה קודם)"};
+// how a skill stands for a student, as on their own path: gold, lit, fading (finished), trying (practised, not finished), none
+function cellState(p,id){
+  if(!p) return "none";
+  if(p.done?.[id]) return Sky.star(p,id,"done",false);
+  return p.tries?.[id]>0||(p.missed?.[id]||[]).length?"trying":"none";
+}
+const CELL_TEXT={gold:"כוכב זהב",lit:"הושלמה",fading:"הושלמה, הכוכב דועך",trying:"מתרגל, עוד לא סיים",none:"לא התחיל"};
+const HARD_SHARE=1/3;   // a skill is a class-wide difficulty when this share of the students are on it without finishing
 function drawReport(){
   const {class:row,students}=REPORT.data, ids=new Set(row.lessons||[]);
   const units=G.units.filter(u=>ids.has(u.id)&&unitIds(u).some(live));
-  const all=students.map(s=>({s,r:reportOf(s,units)}));
+  const skillNames={}; units.forEach(u=>unitIds(u).filter(live).forEach(id=>{ skillNames[id]=BY[id].name; }));
+  const ctx={skills:skillNames,units:units.filter(u=>u.quiz).map(u=>({id:u.id,name:u.name})),assignments:REPORT.data.assignments||[]};
+  const all=students.map(s=>({s,r:reportOf(s,units),att:Sky.attention(s,ctx)}));
   sheet.querySelector("#mxTitle").textContent=`הכיתה שלי: ${row.name}`;
   sheet.querySelector(".mx-manage-state").textContent=`${students.length} תלמידים · ${all.filter(x=>x.r).length} התחילו לתרגל`;
   // the mistakes that keep coming back for the most students
   const common={}; all.forEach(({s,r})=>r?.recurring.forEach(x=>(common[x.m]||=[]).push(s.email)));
   const top=Object.entries(common).sort((a,b)=>b[1].length-a[1].length).slice(0,5);
-  const name=email=>email.split("@")[0];
+  // a student is shown by the class's nickname, else their Google name, else the start of their email
+  const name=email=>students.find(x=>x.email===email)?.name||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})=>{
-    if(!r) return `<details class="mx-report-student"><summary><b dir="ltr">${esc(name(s.email))}</b><span class="mx-small">${s.signed_in?"עוד לא התחיל לתרגל":"עוד לא נכנס לחשבון"}</span></summary><p class="mx-small" dir="ltr">${esc(s.email)}</p></details>`;
+  const card=({s,r},i)=>{
+    if(!r) return `<details class="mx-report-student" id="rs-${i}"><summary><b dir="ltr">${esc(name(s.email))}</b><span class="mx-small">${s.signed_in?"עוד לא התחיל לתרגל":"עוד לא נכנס לחשבון"}</span></summary><p class="mx-small" dir="ltr">${esc(s.email)}</p></details>`;
     const exam=r.exams[0];
-    return `<details class="mx-report-student"><summary><b dir="ltr">${esc(name(s.email))}</b>
+    return `<details class="mx-report-student" id="rs-${i}"><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>
-        ${r.recurring.length?`<span class="mx-report-chip low">${r.recurring.length} קשיים</span>`:""}</summary>
+        ${r.recurring.length?`<span class="mx-report-chip low">${r.recurring.length} קשיים</span>`:""}
+        ${(s.review_requests||[]).length?`<span class="mx-report-chip low">ביקש בדיקה חוזרת</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>
+        ${(s.review_requests||[]).length?`<section class="mx-tr-request"><h5>ביקש שתסתכלו שוב</h5>${s.review_requests.map(q=>`<p>${fmt(q.question||"")}${q.message?`: ${esc(q.message)}`:""}
+          <button type="button" class="mx-btn" data-review-answer="${esc(q.attempt_id)}" data-review-from="report">פתיחת התשובה</button></p>`).join("")}</section>`:""}
+        ${r.helped.length?`<section><h5>דוגמאות פתורות שנפתחו בשבועיים האחרונים${DEVICE_NOTE}</h5><ul class="mx-report-list">${r.helped.map(x=>
+          `<li><b>${fmt(BY[x.id].name)}</b> <small>${x.n===1?"פעם אחת":`${x.n} פעמים`}, לאחרונה ${shortDate(x.last)}</small></li>`).join("")}</ul></section>`:""}
+        <p class="mx-report-week"><b>${r.week.thisWeek}</b> תשובות נכונות השבוע · <b>${r.week.lastWeek}</b> בשבוע שעבר</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,last,count,unverified})=>{
+        <section><h5>בוחן מסכם</h5>${quizUnits.length?`<table class="mx-report-table"><thead><tr><th>יחידה</th><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>
+            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><td>${last?`<button type="button" class="mx-btn" data-answers="${i}:${esc(u.id)}">פתיחה</button>`:""}</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=`
+  // the order the teacher chose; ties keep the class list's order. `i` is the student's place in the class list (their card's id)
+  const rank={attention:(a,b)=>b.att.length-a.att.length,
+    name:(a,b)=>name(a.s.email).localeCompare(name(b.s.email),"he"),
+    progress:(a,b)=>(b.r?b.r.done:-1)-(a.r?a.r.done:-1),
+    activity:(a,b)=>(a.r?.last?.getTime()??0)-(b.r?.last?.getTime()??0)};
+  const sort=rank[REPORT.sort]?REPORT.sort:"attention";
+  const order=all.map((x,i)=>({...x,i})).sort(rank[sort]);
+  const needy=order.filter(x=>x.att.length);
+  const attn=`<section class="mx-report-attn"><h4>דורשים תשומת לב</h4>${needy.length?`<ul class="mx-report-list">${needy.map(({s,att,i})=>
+    `<li><button type="button" class="mx-report-open" data-report-student="${i}"><b dir="ltr">${esc(name(s.email))}</b></button><small>${att.map(x=>fmt(x.text)).join(" · ")}</small></li>`).join("")}</ul>`
+    :'<p class="mx-note">אף תלמיד לא דורש תשומת לב כרגע.</p>'}</section>`;
+  const list=`${attn}
     ${top.length?`<section class="mx-report-common"><h4>קשיים נפוצים בכיתה</h4><ul class="mx-report-list">${top.map(([m,who])=>`<li><b>${fmt(G.mistakes[m].name)}</b> <small>${who.length} תלמידים: ${who.map(e=>esc(name(e))).join(", ")}</small></li>`).join("")}</ul></section>`:""}
-    <h4>תלמידים</h4>${students.length?all.map(card).join(""):'<p class="mx-note">אין עדיין תלמידים בכיתה.</p>'}`;
+    <h4>תלמידים</h4>${students.length?order.map(x=>card(x,x.i)).join(""):'<p class="mx-note">אין עדיין תלמידים בכיתה.</p>'}`;
+
+  // the grid: a row per student; a column per skill of one unit, or per unit in the overview
+  const started=all.filter(x=>x.r).length;
+  const gridUnit=units.find(u=>u.id===REPORT.unit);
+  let grid;
+  if(!students.length) grid='<p class="mx-note">אין עדיין תלמידים בכיתה.</p>';
+  else if(!gridUnit){
+    grid=`<table class="mx-grid"><thead><tr><th class="mx-grid-name" scope="col">תלמיד</th>${units.map(u=>`<th scope="col" class="mx-grid-unit">${esc(u.name)}</th>`).join("")}</tr></thead><tbody>${
+      order.map(({s,r})=>`<tr><th scope="row" class="mx-grid-name" dir="ltr">${esc(name(s.email))}</th>${units.map((u,k)=>{ const x=r?.perUnit[k];
+        return x?`<td class="mx-grid-num${tone(pct(x.done,x.n))}">${x.done}/${x.n}</td>`:'<td class="mx-grid-num">–</td>'; }).join("")}</tr>`).join("")}</tbody></table>`;
+  }else{
+    const skills=unitIds(gridUnit).filter(live);
+    const count=skills.map(id=>{ const st=all.map(x=>cellState(x.s.progress,id));
+      const trying=st.filter(t=>t==="trying").length; return {id,done:st.filter(t=>["gold","lit","fading"].includes(t)).length,trying,hard:trying>0&&trying>=started*HARD_SHARE}; });
+    grid=`<table class="mx-grid"><thead><tr><th class="mx-grid-name" scope="col">תלמיד</th>${count.map(c=>
+      `<th scope="col" class="mx-grid-skill${c.hard?" hard":""}"${c.hard?' aria-label="קושי כיתתי"':""}><span title="${esc(BY[c.id].name)}">${c.hard?"⚠ ":""}${fmt(BY[c.id].short)}</span></th>`).join("")}</tr></thead><tbody>${
+      order.map(({s})=>`<tr><th scope="row" class="mx-grid-name" dir="ltr">${esc(name(s.email))}</th>${skills.map(id=>{ const st=cellState(s.progress,id);
+        return `<td><span class="mx-cell ${st}" role="img" aria-label="${CELL_TEXT[st]}" title="${CELL_TEXT[st]}"></span></td>`; }).join("")}</tr>`).join("")}</tbody><tfoot>
+      <tr><th scope="row" class="mx-grid-name">סיימו</th>${count.map(c=>`<td class="mx-grid-sum">${c.done}/${started}</td>`).join("")}</tr>
+      <tr><th scope="row" class="mx-grid-name">מתקשים</th>${count.map(c=>`<td class="mx-grid-sum${c.hard?" hard":""}">${c.trying||""}</td>`).join("")}</tr></tfoot></table>
+      <p class="mx-small">⚠ מיומנות שלפחות שליש מהתלמידים מתרגלים ועוד לא סיימו.</p>`;
+  }
+  const view=["grid","tasks"].includes(REPORT.tab)?REPORT.tab:"list";
+  const bar=`<div class="mx-report-bar"><div class="mx-report-views" role="group" aria-label="תצוגה">
+      <button type="button" class="mx-btn" data-report-tab="list" aria-pressed="${view==="list"}">רשימה</button>
+      <button type="button" class="mx-btn" data-report-tab="grid" aria-pressed="${view==="grid"}">טבלת מיומנויות</button>
+      <button type="button" class="mx-btn" data-report-tab="tasks" aria-pressed="${view==="tasks"}">משימות</button></div>
+    <label class="mx-small">מיון <select data-report-sort>${Object.entries(REPORT_SORTS).map(([k,v])=>`<option value="${k}"${k===sort?" selected":""}>${v}</option>`).join("")}</select></label>
+    ${view==="grid"?`<label class="mx-small">יחידה <select data-report-unit><option value="overview">כל היחידות</option>${units.map(u=>`<option value="${esc(u.id)}"${u.id===REPORT.unit?" selected":""}>${esc(u.name)}</option>`).join("")}</select></label>`:""}</div>`;
+  sheet.querySelector(".mx-report").innerHTML=bar+(view==="grid"?`<div class="mx-grid-wrap" tabindex="0" role="region" aria-label="טבלת מיומנויות של הכיתה">${grid}</div>`
+    :view==="tasks"?(REPORT.form?asgFormHtml(units):asgTasksHtml(order,name)):list);
+}
+
+/* ---------- the class's assignments, in the report (app/assignments.py) ----------
+   The tab lists the class's assignments, how many students finished each and, for each student, which items are done
+   (worked out by Sky.assignmentState from the progress and the server's quiz sittings, as on the student's own screen),
+   and gives the teacher the form to make, change or delete one. */
+const ASG_ERR={400:"אחד הפריטים אינו שייך ליחידות של הכיתה, או שהתאריך אינו תקין.",403:"רק מורה הכיתה יכול לתת לה משימות.",404:"הכיתה או המשימה לא נמצאו.",
+  503:"המשימות אינן זמינות כרגע. נסו שוב מאוחר יותר."};
+const asgStates=(a,order)=>order.map(({s})=>({s,st:Sky.assignmentState(a,s.progress,s.quiz_sittings)}));
+function asgTasksHtml(order,name){
+  const list=REPORT.data.assignments;
+  if(list===null) return '<p class="mx-note">המשימות אינן זמינות כרגע באתר.</p>';
+  const today=Sky.jerusalemDay(new Date());
+  const cards=list.slice().sort((p,q)=>q.due_on.localeCompare(p.due_on)).map(a=>{
+    const rows=asgStates(a,order), finished=rows.filter(x=>x.st.finished).length, past=today>a.due_on;
+    return `<article class="mx-asg-t${past?" past":""}"><div class="mx-asg-head"><b>${esc(a.title)}</b><span class="mx-asg-due">${past?"המועד עבר · ":""}עד ${asgDate(a.due_on)}</span></div>
+      ${a.note?`<p class="mx-asg-note">${esc(a.note)}</p>`:""}
+      <p class="mx-asg-count"><b>${finished}</b> מתוך ${rows.length} תלמידים סיימו</p>
+      <ul class="mx-asg-items">${a.items.map(i=>`<li>${asgItemLabel(i)}</li>`).join("")}</ul>
+      ${rows.length?`<details class="mx-asg-who"><summary>מי עשה מה</summary><div class="mx-grid-wrap" tabindex="0" role="region" aria-label="מצב התלמידים במשימה"><table class="mx-grid">
+        <thead><tr><th class="mx-grid-name" scope="col">תלמיד</th>${a.items.map(i=>`<th scope="col" class="mx-grid-unit">${asgItemLabel(i)}</th>`).join("")}</tr></thead><tbody>
+        ${rows.map(({s,st})=>`<tr><th scope="row" class="mx-grid-name" dir="ltr">${esc(name(s.email))}</th>${st.items.map(x=>
+          `<td class="mx-asg-cell ${x.done?(x.late?"late":"ok"):x.known?"none":"unknown"}">${x.done?(x.late?"✓ באיחור":"✓"):x.known?"–":"?"}</td>`).join("")}</tr>`).join("")}
+        </tbody></table></div></details>`:""}
+      <div class="mx-row"><button type="button" class="mx-btn" data-asg-edit="${esc(a.id)}">עריכה</button>
+        <button type="button" class="mx-btn" data-asg-del="${esc(a.id)}">מחיקה</button></div></article>`;
+  }).join("");
+  return `<div class="mx-row"><button type="button" class="mx-btn solid" data-asg-new>משימה חדשה</button></div>
+    ${cards||'<p class="mx-note">עוד לא נתתם משימות לכיתה. משימה היא מיומנויות לסיים, בוחן מסכם להגיש או מבחן תרגול, עד תאריך.</p>'}`;
+}
+function asgFormHtml(units){
+  const old=REPORT.data.assignments.find(x=>x.id===REPORT.form.id);
+  const a=old||{title:"",note:"",due_on:new Date(Date.now()+7*864e5).toLocaleDateString("en-CA",{timeZone:"Asia/Jerusalem"}),items:[]};
+  const skills=new Set(a.items.filter(i=>i.kind==="skill").map(i=>i.id)), quizzes=new Set(a.items.filter(i=>i.kind==="unit_quiz").map(i=>i.unit));
+  const exam=new Set(a.items.find(i=>i.kind==="exam")?.units||[]);
+  const box=(name,value,on,label)=>`<label><input type="checkbox" name="${name}" value="${esc(value)}"${on?" checked":""}> ${label}</label>`;
+  return `<form class="mx-asg-form" data-asg-form="${esc(old?.id||"")}" novalidate><h4>${old?"עריכת משימה":"משימה חדשה"}</h4>
+    <label>כותרת<input name="title" maxlength="80" value="${esc(a.title)}" required></label>
+    <label>הערה לתלמידים <small>(לא חובה)</small><textarea name="note" rows="2" maxlength="500">${esc(a.note)}</textarea></label>
+    <label>להגיש עד<input type="date" name="due_on" value="${esc(a.due_on)}" required></label>
+    <fieldset><legend>מיומנויות לסיים</legend>${units.map(u=>{ const ids=unitIds(u).filter(live);
+      return `<details${ids.some(id=>skills.has(id))?" open":""}><summary>${esc(u.name)}</summary><div class="mx-asg-checks">${ids.map(id=>box("skill",id,skills.has(id),fmt(BY[id].short||BY[id].name))).join("")}</div></details>`; }).join("")}</fieldset>
+    <fieldset><legend>בוחן מסכם להגשה</legend><div class="mx-asg-checks">${units.filter(u=>u.quiz).map(u=>box("quiz",u.id,quizzes.has(u.id),esc(u.name))).join("")||"<small>ליחידות של הכיתה אין בוחן מסכם.</small>"}</div></fieldset>
+    <fieldset><legend>מבחן תרגול על היחידות</legend><div class="mx-asg-checks">${units.map(u=>box("exam",u.id,exam.has(u.id),esc(u.name))).join("")}</div>
+      <small>מי שיסמן כמה יחידות יבקש מבחן תרגול שכולל את כולן.</small></fieldset>
+    <div class="mx-row"><button type="submit" class="mx-btn solid">שמירה</button><button type="button" class="mx-btn" data-asg-cancel>ביטול</button>
+      <span class="mx-small" role="status" aria-live="polite"></span></div></form>`;
+}
+async function asgSave(form){
+  const id=form.dataset.asgForm, status=form.querySelector("[role=status]"), button=form.querySelector("[type=submit]"), classId=REPORT.id;
+  const picked=name=>[...form.querySelectorAll(`[name=${name}]:checked`)].map(c=>c.value);
+  const items=[...picked("skill").map(v=>({kind:"skill",id:v})),...picked("quiz").map(v=>({kind:"unit_quiz",unit:v}))];
+  if(picked("exam").length) items.push({kind:"exam",units:picked("exam")});
+  const body={title:form.elements.title.value,note:form.elements.note.value,due_on:form.elements.due_on.value,items};
+  if(!body.title.trim()){ status.textContent="כתבו כותרת למשימה."; form.elements.title.focus(); return; }
+  if(!body.due_on){ status.textContent="בחרו תאריך להגשה."; return; }
+  if(!items.length){ status.textContent="בחרו לפחות פריט אחד: מיומנות, בוחן מסכם או מבחן תרגול."; return; }
+  button.disabled=true; status.textContent="שומרים…";
+  try{
+    const r=await api(`/api/classes/${encodeURIComponent(classId)}/assignments${id?`/${encodeURIComponent(id)}`:""}`,
+      {method:id?"PUT":"POST",headers:{"Content-Type":"application/json"},body:JSON.stringify(body)});
+    const d=await r.json().catch(()=>({}));
+    if(!r.ok) throw Error(ASG_ERR[r.status]||"השמירה נכשלה. נסו שוב.");
+    if(cur!=="report"||REPORT?.id!==classId) return;
+    const list=REPORT.data.assignments||[];
+    REPORT.data.assignments=id?list.map(x=>x.id===id?d:x):[d,...list];
+    REPORT.form=null; drawReport();
+    sheet.querySelector(".mx-report").insertAdjacentHTML("afterbegin",`<p class="mx-small" role="status">${id?"המשימה עודכנה.":"המשימה נשמרה. התלמידים רואים אותה בבית."}</p>`);
+  }catch(e){ if(cur==="report"){ button.disabled=false; status.textContent=e.message; } }
+}
+async function asgDelete(id){
+  const a=REPORT.data.assignments.find(x=>x.id===id); if(!a) return;
+  const started=REPORT.data.students.filter(s=>Sky.assignmentState(a,s.progress,s.quiz_sittings).doneCount>0).length;
+  if(!confirm(`למחוק את המשימה "${a.title}"? התלמידים לא יראו אותה יותר.${started?` ${started} תלמידים כבר השלימו לפחות פריט אחד ממנה.`:""}`)) return;
+  const classId=REPORT.id;
+  try{
+    const r=await api(`/api/classes/${encodeURIComponent(classId)}/assignments/${encodeURIComponent(id)}`,{method:"DELETE"});
+    if(!r.ok) throw Error(ASG_ERR[r.status]||"המחיקה נכשלה. נסו שוב.");
+    if(cur!=="report"||REPORT?.id!==classId) return;
+    REPORT.data.assignments=REPORT.data.assignments.filter(x=>x.id!==id); drawReport();
+  }catch(e){ if(cur==="report") sheet.querySelector(".mx-manage-state").textContent=e.message; }
+}
+// the report's own controls: the view, the order and the unit of the grid
+function reportControl(t){
+  if(t.dataset.reportTab){ REPORT.tab=t.dataset.reportTab; repSet("tab",REPORT.tab); drawReport(); sheet.querySelector(`[data-report-tab="${REPORT.tab}"]`)?.focus(); }
+  else if(t.matches("[data-report-sort]")){ REPORT.sort=t.value; repSet("sort",t.value); drawReport(); sheet.querySelector("[data-report-sort]")?.focus(); }
+  else if(t.matches("[data-report-unit]")){ REPORT.unit=t.value; repSet("unit",t.value); drawReport(); sheet.querySelector("[data-report-unit]")?.focus(); }
+}
+
+/* ---------- the teacher's review of a student's answer (app/teacher_review.py) ----------
+   The class teacher opens an open answer of one of their students (from a unit-quiz row of the report, or a handled
+   request of the AI queue): the question, the photo, the automatic check, and a form for a score of their own and a
+   comment. The teacher's score counts instead of the AI's wherever the answer is graded. */
+let TR=null;   // the answer on the sheet: {attemptId, back (how to return), data, url}
+const TR_ERR={invalid_score:"הציון חייב להיות מספר שלם בין 0 ל־100.",comment_too_long:"ההערה ארוכה מדי (עד 1000 תווים).",empty_review:"כתבו ציון או הערה.",
+  invalid_comment:"ההערה אינה תקינה.",forbidden:"אין לכם הרשאה לתשובה הזו.",teacher_required:"אין לכם הרשאה לתשובה הזו.",not_found:"התשובה לא נמצאה.",
+  answer_required:"לתשובה הזו אין תמונה שמורה.",review_unavailable:"הבדיקה אינה זמינה כרגע. נסו שוב מאוחר יותר.",answer_storage_unavailable:"שמירת תשובות אינה זמינה כרגע."};
+function dropReview(){ if(TR?.url) URL.revokeObjectURL(TR.url); TR=null; }
+const trName=email=>String(email||"").split("@")[0];
+function trShell(title,backLabel){
+  if(cur!=="review"){ if(!cur) back=document.activeElement; closeSheetQuietly(); cur="review"; }
+  sheet.innerHTML=`<div class="mx-scrim"></div>
+    <div class="mx-sheet mx-manage-sheet mx-tr-sheet" role="dialog" aria-modal="true" aria-labelledby="mxTitle">
+      <div class="mx-manage-head"><h3 id="mxTitle">${esc(title)}</h3><span class="mx-manage-spacer"></span>
+        <button class="mx-btn" data-review-back>${esc(backLabel)}</button><button class="mx-x" data-act="close" aria-label="סגירה">✕</button></div>
+      <p class="mx-manage-state" aria-live="polite"></p><div class="mx-tr"></div></div>`;
+  sheet.hidden=false; sheet.querySelector(".mx-x").focus({preventScroll:true});
+}
+// the answers of one unit-quiz sitting of a student, to open one of them
+function reviewSitting(index,unitId){
+  const student=REPORT?.data?.students[index], unit=G.units.find(u=>u.id===unitId);
+  const sitting=(student?.quiz_sittings||[]).filter(x=>x.unit_id===unitId).at(-1);
+  if(!sitting) return;
+  trShell(`תשובות בבוחן: ${unit.name}`,"חזרה לדוח");   // opening the sheet closes the one before it, and its answer
+  dropReview(); TR={back:()=>classReport(REPORT.id)};
+  const STATE={missing:"לא צולמה תשובה",waiting:"ממתינה לבדיקה",unreadable:"לא קריאה",needs_review:"דורשת בדיקה שלכם",teacher:"נבדקה על ידכם",checked:"נבדקה"};
+  sheet.querySelector(".mx-manage-state").textContent=`${trName(student.email)} · ${sitting.grade==null?"עוד אין ציון":`ציון ${sitting.grade}/100`}`;
+  sheet.querySelector(".mx-tr").innerHTML=`<ol class="mx-uq-qs">${sitting.questions.map((q,k)=>`<li class="mx-uq-q"><div class="mx-uq-qhead"><b>שאלה ${k+1}</b>
+      <span>${q.earned==null?"–":q.earned}/${q.points} נק׳</span></div><p class="mx-small">${STATE[q.state]||esc(q.state)}</p>
+      ${q.state==="missing"?"":`<button class="mx-btn" data-review-answer="${esc(sitting.attempts[k])}" data-review-from="sitting:${index}:${esc(unitId)}">פתיחת התשובה</button>`}</li>`).join("")}</ol>`;
+}
+async function trOpenAnswer(attemptId,from){
+  const [kind,a,b]=String(from||"").split(":");
+  const backTo=kind==="sitting"?()=>reviewSitting(+a,b):kind==="queue"?()=>aiQueue():kind==="report"?()=>classReport(REPORT?.id):()=>closeSheet();
+  trShell("תשובה של תלמיד",kind==="queue"?"חזרה לתור":"חזרה");
+  dropReview(); const mine=TR={attemptId,back:backTo,data:null,url:null};
+  sheet.querySelector(".mx-manage-state").textContent="טוענים את התשובה…";
+  try{
+    const r=await api(`/api/teacher/answers/${encodeURIComponent(attemptId)}`,{cache:"no-store"});
+    const d=await r.json().catch(()=>({}));
+    if(!r.ok) throw Error(TR_ERR[d.detail]||"לא הצלחנו לטעון את התשובה. נסו שוב.");
+    if(TR!==mine) return;
+    mine.data=d; drawReview();
+    const img=await api(`/api/teacher/answers/${encodeURIComponent(attemptId)}/image`,{cache:"no-store"});
+    if(img.ok){ const url=URL.createObjectURL(await img.blob()); if(TR!==mine) return URL.revokeObjectURL(url); mine.url=url; const el=sheet.querySelector(".mx-tr-img"); if(el){ el.src=url; el.hidden=false; } }
+  }catch(e){ if(TR===mine) sheet.querySelector(".mx-manage-state").textContent=e.message; }
+}
+function drawReview(note=""){
+  const d=TR.data, a=d.grading?.state==="completed"?d.grading.result:null, rv=d.review, rq=d.request;
+  const isQuiz=String(d.attempt.question_id).startsWith("quiz:"), when=at=>new Date(at).toLocaleString("he-IL",{dateStyle:"short",timeStyle:"short"});
+  sheet.querySelector(".mx-manage-state").textContent=`${trName(d.student.email)} · ${d.student.email}`;
+  sheet.querySelector(".mx-tr").innerHTML=`
+    <p class="mx-small">${fmt(d.attempt.snapshot.name||"")}</p>
+    <p class="mx-aq-q">${fmtLoose(d.attempt.snapshot.question||"").replace(/\n/g,"<br>")}</p>
+    <img class="mx-aq-img mx-tr-img" alt="התשובה שצילם התלמיד" ${TR.url?`src="${TR.url}"`:"hidden"}>
+    ${rq?.state==="open"?`<div class="mx-tr-request" role="note"><b>התלמיד ביקש שתסתכלו שוב</b>${rq.message?`<p>${esc(rq.message)}</p>`:""}<small>${when(rq.created_at)}</small></div>`:""}
+    <section class="mx-tr-ai"><h5>בדיקה אוטומטית (AI)</h5>${a?`<p><b>${esc(AQ_VERDICT[a.verdict]||"")}</b>${a.score==null?"":` · ${esc(a.score)}/100`}</p>
+      ${a.feedback?`<p>${fmtLoose(a.feedback)}</p>`:""}
+      ${a.transcription?`<details><summary>מה ה-AI קרא בתמונה</summary><p>${fmtLoose(a.transcription)}</p></details>`:""}
+      ${a.solution?`<details><summary>הפתרון המלא</summary><p class="mx-grade-solution">${fmtLoose(a.solution)}</p></details>`:""}`:'<p class="mx-small">התשובה עוד לא נבדקה בבדיקה אוטומטית.</p>'}</section>
+    ${rv?`<section><h5>הבדיקה שלכם</h5><p>${rv.score==null?"בלי ציון":`${esc(rv.score)}/100`} · <small>${when(rv.created_at)}</small></p>${rv.comment?`<p>${esc(rv.comment).replace(/\n/g,"<br>")}</p>`:""}</section>`:""}
+    <form class="mx-tr-form" data-review-form>
+      <h5>${rv?"עדכון הבדיקה שלכם":"הבדיקה שלכם"}</h5>
+      <label>ציון (0 עד 100)<input type="number" name="score" min="0" max="100" step="1" inputmode="numeric" value="${rv?.score??""}"></label>
+      <label>הערה לתלמיד<textarea name="comment" rows="3" maxlength="1000">${esc(rv?.comment||"")}</textarea></label>
+      <p class="mx-small">${isQuiz?"הציון שלכם מחליף את הציון האוטומטי בחישוב ציון הבוחן.":"הציון שלכם מחליף את הציון האוטומטי. ציון 100 מסמן את המיומנות כהושלמה אצל התלמיד."}</p>
+      <div class="mx-row"><button type="submit" class="mx-btn solid">שמירה</button><span class="mx-small" role="status" aria-live="polite">${esc(note)}</span></div></form>`;
+}
+async function reviewSave(form){
+  const mine=TR, status=form.querySelector("[role=status]"), button=form.querySelector("[type=submit]");
+  const raw=form.elements.score.value.trim(), body={comment:form.elements.comment.value};
+  if(raw!=="") body.score=Number(raw);
+  button.disabled=true; status.textContent="שומרים…";
+  try{
+    const r=await api(`/api/teacher/answers/${encodeURIComponent(mine.attemptId)}/review`,{method:"PUT",headers:{"Content-Type":"application/json"},body:JSON.stringify(body)});
+    const d=await r.json().catch(()=>({}));
+    if(!r.ok) throw Error(TR_ERR[d.detail]||"השמירה נכשלה. נסו שוב.");
+    if(TR!==mine) return;
+    mine.data.review=d.review; mine.data.request=d.request; mine.data.effective_score=d.review?.score??mine.data.effective_score;
+    mine.changed=true; drawReview("נשמר. התלמיד יראה את הבדיקה שלכם.");
+  }catch(e){ if(TR===mine){ button.disabled=false; status.textContent=e.message; } }
 }
 
 /* ---------- the teacher's AI queue (app/ai_queue.py) ----------
    A student does not call the AI. Their answer to check (or a photographed problem) waits here for their class's
    teacher, who looks at the photo and sends it to the AI or declines it with a note. The student's page shows the
    result. A manager sees every class's requests. */
-let AQ=null, AQ_OPEN=null;   // AQ: the queue on the sheet; AQ_OPEN: how many requests wait (for the header button)
+let AQ=null, AQ_OPEN=null, RQ_OPEN=0, AQ_TAB="queue";   // AQ: the queue on the sheet; AQ_OPEN: how many requests wait (for the header button)
 const AQ_KIND={photo:"📷 תרגיל לעזרה",grading:"📝 בדיקת תשובה"};
 const AQ_STATE={pending:"ממתינה",sending:"נשלחת…",done:"נשלחה ל-AI",failed:"השליחה נכשלה",declined:"נדחתה",cancelled:"בוטלה"};
 const AQ_ERR={grading_failed:"הבדיקה נכשלה. אפשר לנסות שוב.",grading_unavailable:"בדיקה אוטומטית אינה זמינה כרגע באתר.",open_ended_locked:"שאלות פתוחות נעולות כרגע.",
@@ -1547,23 +1951,24 @@ function aqError(error){
 }
 const AQ_VERDICT={correct:"נכונה",partial:"נכונה חלקית",incorrect:"שגויה",unreadable:"לא קריאה",needs_review:"דורשת בדיקה שלכם"};
 const aqWaiting=r=>["pending","sending","failed"].includes(r.state);
-const aqLabel=()=>`תור AI${AQ_OPEN?` <span class="mx-aq-badge">${AQ_OPEN}</span>`:""}`;
-function aqBadge(rows){
-  AQ_OPEN=rows.filter(r=>r.state==="pending").length;
-  document.querySelectorAll('[data-act="ai-queue"]').forEach(b=>{ if(!b.closest(".mx-sheet")) b.innerHTML=aqLabel(); });
-}
+const aqLabel=()=>`תור AI${(AQ_OPEN||0)+RQ_OPEN?` <span class="mx-aq-badge">${(AQ_OPEN||0)+RQ_OPEN}</span>`:""}`;   // waiting requests, and students asking to look again
+function aqPaintBadge(){ document.querySelectorAll('[data-act="ai-queue"]').forEach(b=>{ if(!b.closest(".mx-sheet")) b.innerHTML=aqLabel(); }); }
+function aqBadge(rows){ AQ_OPEN=rows.filter(r=>r.state==="pending").length; aqPaintBadge(); }
+function rqBadge(rows){ RQ_OPEN=rows.length; aqPaintBadge(); }
 async function aqCount(){
   try{ const r=await api("/api/ai-queue",{cache:"no-store"}); if(r.ok) aqBadge((await r.json()).requests||[]); }catch{}
+  try{ const r=await api("/api/teacher/review-requests",{cache:"no-store"}); if(r.ok) rqBadge((await r.json()).requests||[]); }catch{}
 }
 function dropQueue(){ if(AQ) Object.values(AQ.urls).forEach(u=>u&&URL.revokeObjectURL(u)); AQ=null; }
 async function aiQueue(){
-  if(cur!=="aiqueue"){ if(!cur) back=document.activeElement; closeSheetQuietly(); cur="aiqueue"; AQ={rows:null,urls:{},busy:new Set()}; }
+  if(cur!=="aiqueue"){ if(!cur) back=document.activeElement; closeSheetQuietly(); cur="aiqueue"; AQ={rows:null,reqs:null,tab:AQ_TAB,urls:{},busy:new Set()}; }
   const mine=AQ;
   sheet.innerHTML=`<div class="mx-scrim"></div>
     <div class="mx-sheet mx-manage-sheet mx-aq-sheet" role="dialog" aria-modal="true" aria-labelledby="mxTitle">
       <div class="mx-manage-head"><h3 id="mxTitle">תור AI</h3><span class="mx-manage-spacer"></span>
         <button class="mx-btn" data-act="aq-all" hidden>שליחת כל הממתינות</button><button class="mx-btn" data-act="ai-queue">רענון</button><button class="mx-x" data-act="close" aria-label="סגירה">✕</button></div>
-      <p class="mx-small">בקשות התלמידים מחכות כאן. הסתכלו בתמונה, ואז שלחו אותה ל-AI או דחו אותה. התלמיד רואה את התוצאה בעמוד שלו.</p>
+      <div class="mx-report-views" data-aq-tabs role="group" aria-label="תצוגה"></div>
+      <p class="mx-small" data-aq-help>בקשות התלמידים מחכות כאן. הסתכלו בתמונה, ואז שלחו אותה ל-AI או דחו אותה. התלמיד רואה את התוצאה בעמוד שלו.</p>
       <p class="mx-manage-state" aria-live="polite">טוענים את הבקשות…</p><div class="mx-aq"></div></div>`;
   sheet.hidden=false; sheet.querySelector(".mx-x").focus({preventScroll:true});
   try{
@@ -1572,14 +1977,27 @@ async function aiQueue(){
     const d=await r.json(); if(AQ!==mine) return;
     mine.rows=d.requests||[]; drawQueue();
   }catch(e){ if(AQ===mine) sheet.querySelector(".mx-manage-state").textContent=e.message; }
+  try{   // the students asking the teacher to look again at a checked answer
+    const r=await api("/api/teacher/review-requests",{cache:"no-store"});
+    mine.reqs=r.ok?(await r.json()).requests||[]:[];
+  }catch{ mine.reqs=[]; }
+  if(AQ===mine){ rqBadge(mine.reqs); drawQueue(); }
 }
+function aqTab(tab){ if(!AQ) return; AQ.tab=AQ_TAB=tab; drawQueue(); sheet.querySelector(`[data-aq-tab="${tab}"]`)?.focus(); }
 function aqResult(r){
   const x=r.result||{};
   if(r.kind==="photo") return x.readable===false?"ה-AI לא הצליח לקרוא את התרגיל.":`התשובה שה-AI מצא: ${fmtLoose(x.answer||"")}`;
   return `תוצאה: ${esc(AQ_VERDICT[x.verdict]||"")}${x.score==null?"":` · ${esc(x.score)}/100`}`;
 }
 function drawQueue(){
-  const box=sheet.querySelector(".mx-aq"); if(!box||!AQ?.rows) return;
+  const box=sheet.querySelector(".mx-aq"); if(!box) return;
+  const tabs=sheet.querySelector("[data-aq-tabs]"), asks=AQ?.reqs;
+  if(tabs) tabs.innerHTML=`<button type="button" class="mx-btn" data-aq-tab="queue" aria-pressed="${AQ.tab!=="requests"}">בקשות לבדיקה</button>
+    <button type="button" class="mx-btn" data-aq-tab="requests" aria-pressed="${AQ.tab==="requests"}">בקשות לבדיקה חוזרת${asks?.length?` <span class="mx-aq-badge">${asks.length}</span>`:""}</button>`;
+  if(AQ?.tab==="requests") return drawRequests();
+  sheet.querySelector('[data-act="aq-all"]').hidden=true;
+  sheet.querySelector("[data-aq-help]").hidden=false;
+  if(!AQ?.rows) return;
   const open=AQ.rows.filter(aqWaiting), rest=AQ.rows.filter(r=>!aqWaiting(r));
   aqBadge(AQ.rows);
   sheet.querySelector(".mx-manage-state").textContent=open.length?(open.length===1?"בקשה אחת ממתינה":`${open.length} בקשות ממתינות`):"אין בקשות ממתינות.";
@@ -1594,12 +2012,27 @@ function drawQueue(){
       ${r.state==="failed"&&r.error?aqError(r.error):""}
       ${r.state==="declined"&&r.note?`<p class="mx-small">ההערה שלכם: ${esc(r.note)}</p>`:""}
       ${r.state==="done"?`<p class="mx-small">${aqResult(r)}</p>`:""}
+      ${r.kind==="grading"&&r.attempt_id&&!aqWaiting(r)?`<button type="button" class="mx-btn" data-review-answer="${esc(r.attempt_id)}" data-review-from="queue">פתיחת התשובה</button>`:""}
       ${act?`<div class="mx-row"><button class="mx-btn solid" data-aq-send="${esc(r.id)}"${busy?" disabled":""}>${r.state==="failed"?"שליחה חוזרת ל-AI":"שליחה ל-AI"}</button>
         <button class="mx-btn" data-aq-decline="${esc(r.id)}"${busy?" disabled":""}>דחייה</button></div>`:""}</article>`;
   };
   box.innerHTML=`${open.map(card).join("")}${rest.length?`<h4 class="mx-aq-done">טופלו ביממה האחרונה</h4>${rest.map(card).join("")}`:""}`;
   open.forEach(r=>aqImage(r.id));
 }
+// students who asked the teacher to look again at a checked answer
+function drawRequests(){
+  const box=sheet.querySelector(".mx-aq"), rows=AQ.reqs;
+  sheet.querySelector('[data-act="aq-all"]').hidden=true;
+  sheet.querySelector("[data-aq-help]").hidden=true;
+  const state=sheet.querySelector(".mx-manage-state");
+  if(!rows){ state.textContent="טוענים את הבקשות…"; box.innerHTML=""; return; }
+  state.textContent=rows.length?(rows.length===1?"בקשה אחת לבדיקה חוזרת":`${rows.length} בקשות לבדיקה חוזרת`):"אין בקשות לבדיקה חוזרת.";
+  const when=at=>new Date(at).toLocaleString("he-IL",{dateStyle:"short",timeStyle:"short"});
+  box.innerHTML=rows.map(r=>`<article class="mx-aq-card pending"><div class="mx-aq-head"><b dir="ltr">${esc(String(r.student).split("@")[0])}</b><span>🔁 בקשה לבדיקה חוזרת</span><small>${when(r.created_at)}</small></div>
+    ${r.question?`<p class="mx-aq-label">${fmt(r.question)}</p>`:""}
+    ${r.message?`<p class="mx-aq-q">${esc(r.message)}</p>`:'<p class="mx-small">בלי הודעה.</p>'}
+    <div class="mx-row"><button type="button" class="mx-btn solid" data-review-answer="${esc(r.attempt_id)}" data-review-from="queue">פתיחת התשובה</button></div></article>`).join("");
+}
 async function aqImage(id){
   const mine=AQ, show=url=>{ const img=sheet.querySelector(`[data-aq-img="${CSS.escape(id)}"]`); if(img){ img.src=url; img.hidden=false; } };
   if(mine.urls[id]) return show(mine.urls[id]);
@@ -1703,6 +2136,64 @@ function drawPhoto(){
   if(PH.fresh){ PH.fresh=false; sheet.querySelector(".mx-x").focus({preventScroll:true}); }
 }
 
+/* The teacher's explanations, for students (GET /api/math/units/.../student-resources): the resources a teacher marked
+   visible. Those tagged with a skill appear in that skill's sheet and in its help panel; the rest of the unit's are
+   on a list opened from the unit on the path. Images come with the student's sign-in, so each is a blob URL. */
+const SRES={};   // unit id → {rows, p (the request), at, urls}
+const SRES_TTL=300000;
+function sresLoad(unitId){
+  const c=SRES[unitId]||=({rows:null,p:null,at:0,urls:{}});
+  if(!c.p||Date.now()-c.at>SRES_TTL){
+    c.at=Date.now();
+    c.p=(async()=>{ try{ const r=await api(`/api/math/units/${encodeURIComponent(unitId)}/student-resources`,{cache:"no-store"}); c.rows=r.ok?(await r.json()).resources||[]:[]; }catch{ c.rows=c.rows||[]; } return c.rows; })();
+  }
+  return c.p;
+}
+async function sresImage(unitId,id){
+  const c=SRES[unitId]; if(c.urls[id]) return c.urls[id];
+  try{ const r=await api(`/api/math/student-resources/${encodeURIComponent(id)}/image`); if(r.ok) return c.urls[id]=URL.createObjectURL(await r.blob()); }catch{}
+  return "";
+}
+const sresList=rows=>`<div class="mx-sres">${rows.map(r=>`<figure class="mx-sres-item"><button type="button" class="mx-sres-img" data-sres="${esc(r.id)}" aria-label="הגדלה או הקטנה של התמונה">
+  <img data-sres-img="${esc(r.id)}" alt="${esc(r.kind==="other"?r.note:RES_KINDS[r.kind]||"")}"></button>
+  <figcaption><b>${esc(RES_KINDS[r.kind]||"")}</b>${r.note?` · ${esc(r.note)}`:""}</figcaption></figure>`).join("")}</div>`;
+function sresPaint(node,unitId,rows){
+  node.insertAdjacentHTML("beforeend",sresList(rows));
+  for(const r of rows) sresImage(unitId,r.id).then(url=>{ const img=node.querySelector(`[data-sres-img="${CSS.escape(r.id)}"]`); if(img&&url) img.src=url; });
+}
+// fills a box with the unit's explanations that `pick` chooses (a skill's own); the box stays hidden when there are none
+async function fillExplanations(node,unitId,pick){
+  if(!node||!CFG.userId) return;
+  const rows=(await sresLoad(unitId)).filter(pick);
+  if(!rows.length||!node.isConnected) return;
+  node.innerHTML="<h4>הסברים מהמורה</h4>"; node.hidden=false; sresPaint(node,unitId,rows);
+}
+// the unit's explanations that belong to no skill: a button under the unit, once they are known to exist
+function decorateUnits(){
+  if(!CFG.userId||can("students.view")||VIEW==="sky"||!path) return;
+  for(const u of mineUnits()){
+    const c=SRES[u.id];
+    if(!c?.rows){ if(!c?.p) sresLoad(u.id).then(()=>{ if(root&&!root.hidden&&!cur) decorateUnits(); }); continue; }
+    const general=c.rows.filter(r=>!r.skill_id), section=path.querySelector(`#mx-unit-${u.id}`);
+    if(general.length&&section&&!section.querySelector(".mx-sres-open"))
+      section.insertAdjacentHTML("beforeend",`<button type="button" class="mx-sres-open" data-act="unit-explanations" data-unit="${esc(u.id)}">📷 הסברים מהמורה (${general.length})</button>`);
+  }
+}
+async function openExplanations(unitId){
+  const unit=G.units.find(u=>u.id===unitId); if(!unit) return;
+  stopPhone(); cancelAdvance(); if(!cur) back=document.activeElement; closeSheetQuietly(); cur="explanations";
+  sheet.innerHTML=`<div class="mx-scrim" data-act="close"></div>
+    <div class="mx-sheet mx-res u-${unit.id}" role="dialog" aria-modal="true" aria-labelledby="mxTitle">
+      <div class="mx-shtop"><div><span class="mx-uchip">${esc(unit.name)}</span><h3 id="mxTitle">הסברים מהמורה</h3>
+        <small class="mx-src">תמונות שהמורה שמר לשיעור הזה</small></div><button class="mx-x" data-act="close" aria-label="סגירה">✕</button></div>
+      <div class="mx-skill-res" data-unit-res><p class="mx-note">טוענים…</p></div></div>`;
+  sheet.hidden=false; sheet.querySelector(".mx-x").focus({preventScroll:true});
+  const rows=(await sresLoad(unitId)).filter(r=>!r.skill_id), node=sheet.querySelector("[data-unit-res]");
+  if(!node||cur!=="explanations") return;
+  node.innerHTML=rows.length?"":'<p class="mx-note">אין כרגע הסברים לשיעור הזה.</p>';
+  if(rows.length) sresPaint(node,unitId,rows);
+}
+
 /* Lesson resources (app/unit_resources.py). A teacher taps a unit's title on the path, photographs an exercise or an
    explanation, says what it shows (a new exercise, a theory explanation, or other words) and, if they like, which of
    the unit's topics it belongs to. Images come through the API with the teacher's sign-in, so each is a blob URL. */
@@ -1743,6 +2234,8 @@ function resourceForm(){
       <input name="note" maxlength="200" autocomplete="off" placeholder="כתבו מה יש בתמונה" aria-label="תיאור חופשי של התמונה" hidden></fieldset>
     <label>נושא <small>(לא חובה)</small><select name="skill"><option value="">ללא נושא מסוים</option>
       ${skills.map(s=>`<option value="${esc(s.id)}">${esc(plain(s.name))}</option>`).join("")}</select></label>
+    <label class="mx-res-visible"><input type="checkbox" name="visible"><span>גלוי לתלמידים</span></label>
+    <small class="mx-small">הסבר תיאורטי מוצג לתלמידים כברירת מחדל. תרגיל והערה נשארים מוסתרים עד שתסמנו.</small>
     <div class="mx-row"><button type="submit" class="mx-btn solid"${RES.busy?" disabled":""}>${RES.busy?"שומרים…":"שמירה במשאבים"}</button>
       <button type="button" class="mx-btn" data-act="res-retake"${RES.busy?" disabled":""}>צילום מחדש</button>
       <button type="button" class="mx-btn" data-act="res-cancel"${RES.busy?" disabled":""}>ביטול</button></div></form>`;
@@ -1753,12 +2246,15 @@ function resourceItem(r){
   return `<article class="mx-res-item"><a class="mx-res-img" data-res-link="${esc(r.id)}" target="_blank" rel="noopener" aria-label="פתיחת התמונה בגודל מלא">
       <img data-res-img="${esc(r.id)}" alt="${esc(r.kind==="other"?r.note:RES_KINDS[r.kind]||"")}"${RES.urls[r.id]?` src="${RES.urls[r.id]}"`:""}></a>
     <div><b>${esc(RES_KINDS[r.kind]||r.kind)}</b>${r.kind==="other"&&r.note?`<p>${esc(r.note)}</p>`:""}
-      <small>${skill?`${fmt(skill.short||skill.name)} · `:""}${esc(date)}${r.created_email?` · <span dir="ltr">${esc(r.created_email)}</span>`:""}</small></div>
-    ${mine?`<button class="mx-link" data-act="res-delete" data-res="${esc(r.id)}">מחיקה</button>`:""}</article>`;
+      <small>${skill?`${fmt(skill.short||skill.name)} · `:""}${esc(date)}${r.created_email?` · <span dir="ltr">${esc(r.created_email)}</span>`:""}</small>
+      <span class="mx-res-vis${r.visible?" on":""}">${r.visible?"👁 גלוי לתלמידים":"🔒 מוסתר מהתלמידים"}</span></div>
+    ${mine?`<div class="mx-res-acts"><button class="mx-link" data-act="res-visible" data-res="${esc(r.id)}" data-visible="${r.visible?0:1}">${r.visible?"הסתרה מהתלמידים":"הצגה לתלמידים"}</button>
+      <button class="mx-link" data-act="res-delete" data-res="${esc(r.id)}">מחיקה</button></div>`:""}</article>`;
 }
 function drawResources(){
   const items=RES.items, was=sheet.querySelector(".mx-res-form");   // a redraw keeps what was filled in
-  const filled=was&&{kind:was.elements.kind.value,note:was.elements.note.value,skill:was.elements.skill.value};
+  const filled=was&&{kind:was.elements.kind.value,note:was.elements.note.value,skill:was.elements.skill.value,
+    visible:was.elements.visible.checked,touched:!!was.elements.visible.dataset.touched};
   const list=items===null?'<p class="mx-note">טוענים את המשאבים…</p>':items.length?`<div class="mx-res-list">${items.map(resourceItem).join("")}</div>`
     :'<p class="mx-note">עוד אין משאבים לשיעור הזה. צלמו תרגיל או הסבר כדי להוסיף.</p>';
   sheet.innerHTML=`<div class="mx-scrim" data-act="close"></div>
@@ -1775,8 +2271,14 @@ function drawResources(){
   const form=sheet.querySelector(".mx-res-form");
   if(form){
     const note=form.elements.note;
-    if(filled){ form.querySelectorAll('[name="kind"]').forEach(r=>r.checked=r.value===filled.kind); note.value=filled.note; form.elements.skill.value=filled.skill; note.hidden=filled.kind!=="other"; }
-    form.addEventListener("change",()=>{ note.hidden=form.elements.kind.value!=="other"; if(!note.hidden) note.focus(); });
+    const visible=form.elements.visible;   // shown to students: a theory explanation by default, until the teacher decides
+    if(filled){ form.querySelectorAll('[name="kind"]').forEach(r=>r.checked=r.value===filled.kind); note.value=filled.note; form.elements.skill.value=filled.skill; note.hidden=filled.kind!=="other";
+      visible.checked=filled.visible; if(filled.touched) visible.dataset.touched="1"; }
+    form.addEventListener("change",event=>{
+      if(event.target===visible){ visible.dataset.touched="1"; return; }
+      note.hidden=form.elements.kind.value!=="other"; if(!note.hidden) note.focus();
+      if(!visible.dataset.touched) visible.checked=form.elements.kind.value==="theory";
+    });
     form.onsubmit=event=>{ event.preventDefault(); saveResource(form); };
   }
   (items||[]).forEach(r=>{ if(r.id in RES.urls) showResourceImage(r.id); else loadResourceImage(RES,r.id); });
@@ -1818,7 +2320,7 @@ async function saveResource(form){
   if(kind==="other"&&!note){ status.textContent="כתבו בכמה מילים מה יש בתמונה."; form.elements.note.focus(); return; }
   mine.busy=true; form.querySelectorAll("button").forEach(b=>b.disabled=true); status.textContent="שומרים…";
   try{
-    const body=new FormData(); body.append("photo",mine.photo,"resource.jpg"); body.append("kind",kind); body.append("note",kind==="other"?note:""); body.append("skill",skill);
+    const body=new FormData(); body.append("photo",mine.photo,"resource.jpg"); body.append("kind",kind); body.append("note",kind==="other"?note:""); body.append("skill",skill); body.append("visible",form.elements.visible.checked?"1":"0");
     const res=await api(`/api/math/units/${encodeURIComponent(mine.unit.id)}/resources`,{method:"POST",body}), data=await res.json().catch(()=>({}));
     if(!res.ok) throw new Error(resError(res.status,"לא הצלחנו לשמור. נסו שוב."));
     mine.urls[data.id]=URL.createObjectURL(mine.photo);   // the saved photo, without downloading it again
@@ -1828,6 +2330,16 @@ async function saveResource(form){
   mine.busy=false;
   if(RES===mine&&cur==="resources") drawResources();
 }
+async function setResourceVisible(id,visible){
+  const mine=RES; if(!mine) return;
+  try{
+    const res=await api(`/api/math/resources/${encodeURIComponent(id)}`,{method:"PATCH",headers:{"Content-Type":"application/json"},body:JSON.stringify({visible})}), data=await res.json().catch(()=>({}));
+    if(!res.ok) throw new Error(resError(res.status,"לא הצלחנו לשנות. נסו שוב."));
+    const i=mine.items.findIndex(r=>r.id===id); if(i>=0) mine.items[i]={...mine.items[i],visible:data.visible};
+    mine.msg=data.visible?"התמונה גלויה עכשיו לתלמידים.":"התמונה מוסתרת מהתלמידים.";
+  }catch(e){ mine.msg=e.message; }
+  if(RES===mine&&cur==="resources") drawResources();
+}
 async function deleteResource(id){
   const mine=RES; if(!mine||!confirm("למחוק את התמונה ממשאבי השיעור?")) return;
   try{

supabase/migrations/20261104150000_math_teacher_reviews.sql

@@ -0,0 +1,131 @@
+-- The class teacher's review of a student's checked open answer (app/teacher_review.py): a score of their own and a
+-- comment, and the student's request to look again. Additive: two tables and two functions, and the quiz-sitting
+-- function now also reads the teacher's score. Apply after the quiz-sittings migration.
+begin;
+create table public.math_teacher_reviews (
+  id uuid primary key default gen_random_uuid(),
+  user_id uuid not null references auth.users(id) on delete cascade,      -- the student
+  attempt_id uuid not null,
+  reviewer_email text not null,
+  score integer check (score between 0 and 100),
+  comment text not null default '' check (char_length(comment) <= 1000),
+  created_at timestamptz not null default clock_timestamp(),
+  seen_at timestamptz,                                                    -- when the student opened the answer after it
+  foreign key (attempt_id, user_id) references public.math_question_attempts(id, user_id) on delete cascade,
+  check (score is not null or comment <> '')
+);
+-- a newer review replaces the older one: the latest of an attempt counts, the rest is history
+create index math_teacher_reviews_attempt on public.math_teacher_reviews(attempt_id, created_at desc, id desc);
+create index math_teacher_reviews_unseen on public.math_teacher_reviews(user_id) where seen_at is null;
+
+create table public.math_review_requests (
+  id uuid primary key default gen_random_uuid(),
+  user_id uuid not null references auth.users(id) on delete cascade,
+  attempt_id uuid not null,
+  message text not null default '' check (char_length(message) <= 300),
+  state text not null default 'open' check (state in ('open', 'closed')),
+  created_at timestamptz not null default clock_timestamp(),
+  closed_at timestamptz,
+  foreign key (attempt_id, user_id) references public.math_question_attempts(id, user_id) on delete cascade
+);
+create unique index math_review_one_open on public.math_review_requests(attempt_id) where state = 'open';
+create index math_review_requests_open on public.math_review_requests(user_id) where state = 'open';
+alter table public.math_teacher_reviews enable row level security;
+alter table public.math_review_requests enable row level security;
+revoke all on public.math_teacher_reviews, public.math_review_requests from public, anon, authenticated;
+grant all on public.math_teacher_reviews, public.math_review_requests to service_role;
+
+-- an attempt's latest review and latest request
+create function public.math_review_json(p_attempt uuid) returns jsonb
+language sql stable security invoker set search_path='' as $$
+  select jsonb_build_object(
+    'review', (select to_jsonb(r) from (select id, reviewer_email, score, comment, created_at, seen_at
+      from public.math_teacher_reviews where attempt_id = p_attempt order by created_at desc, id desc limit 1) r),
+    'request', (select to_jsonb(q) from (select id, message, state, created_at, closed_at
+      from public.math_review_requests where attempt_id = p_attempt order by created_at desc, id desc limit 1) q))
+$$;
+
+create function public.math_review_action(p_user uuid, p_action text, p_data jsonb default '{}')
+returns jsonb language plpgsql security invoker set search_path='' as $$
+declare
+  a public.math_question_attempts;
+  q public.math_review_requests;
+begin
+  if p_action = 'owner' then   -- whose answer this is (the teacher's routes then act as the student)
+    select * into a from public.math_question_attempts where id = (p_data->>'attempt_id')::uuid;
+    if a.id is null then raise exception 'not_found' using errcode = 'P0002'; end if;
+    return to_jsonb(a.user_id);
+  elsif p_action = 'requests' then   -- open requests to look again; `users` null: everyone's
+    return coalesce((select jsonb_agg(jsonb_build_object('id', r.id, 'attempt_id', r.attempt_id, 'user_id', r.user_id,
+        'message', r.message, 'created_at', r.created_at, 'question', coalesce(t.snapshot->>'name', left(t.snapshot->>'question', 80)), 'question_id', t.question_id)
+        order by r.created_at)
+      from public.math_review_requests r
+      join public.math_question_attempts t on t.id = r.attempt_id and t.user_id = r.user_id
+      where r.state = 'open' and (p_data->'users' is null
+        or r.user_id in (select u.x::uuid from jsonb_array_elements_text(p_data->'users') as u(x)))), '[]'::jsonb);
+  end if;
+  if p_user is null then raise exception 'not_found' using errcode = 'P0002'; end if;
+  if p_action = 'unseen' then   -- reviews the student has not opened since
+    return coalesce((select jsonb_agg(jsonb_build_object('attempt_id', r.attempt_id, 'question', coalesce(t.snapshot->>'name', left(t.snapshot->>'question', 80)),
+        'question_id', t.question_id, 'score', r.score, 'comment', r.comment, 'created_at', r.created_at)
+        order by r.created_at desc)
+      from (select distinct on (attempt_id) * from public.math_teacher_reviews where user_id = p_user
+            order by attempt_id, created_at desc, id desc) r
+      join public.math_question_attempts t on t.id = r.attempt_id and t.user_id = r.user_id
+      where r.seen_at is null), '[]'::jsonb);
+  end if;
+  select * into a from public.math_question_attempts where id = (p_data->>'attempt_id')::uuid and user_id = p_user;
+  if a.id is null then raise exception 'not_found' using errcode = 'P0002'; end if;
+  if p_action = 'get' then
+    return public.math_review_json(a.id);
+  elsif p_action = 'seen' then
+    update public.math_teacher_reviews set seen_at = clock_timestamp() where attempt_id = a.id and seen_at is null;
+    return public.math_review_json(a.id);
+  elsif p_action in ('review', 'request') then
+    if not exists(select 1 from public.math_answer_attachments where attempt_id = a.id) then
+      raise exception 'answer_required' using errcode = 'P0001';
+    end if;
+    if p_action = 'review' then
+      insert into public.math_teacher_reviews(user_id, attempt_id, reviewer_email, score, comment)
+        values (p_user, a.id, p_data->>'reviewer', (p_data->>'score')::int, coalesce(p_data->>'comment', ''));
+      update public.math_review_requests set state = 'closed', closed_at = clock_timestamp()
+        where attempt_id = a.id and state = 'open';
+    else
+      select * into q from public.math_review_requests where attempt_id = a.id and state = 'open';
+      if q.id is null then
+        -- serialize this student's requests, so the limit holds across workers
+        perform pg_catalog.pg_advisory_xact_lock(pg_catalog.hashtextextended('review:' || p_user::text, 0));
+        if (select count(*) from public.math_review_requests where user_id = p_user and state = 'open') >= 5 then
+          raise exception 'review_limit' using errcode = 'P0001';
+        end if;
+        insert into public.math_review_requests(user_id, attempt_id, message)
+          values (p_user, a.id, coalesce(p_data->>'message', ''));
+      end if;
+    end if;
+    return public.math_review_json(a.id);
+  end if;
+  raise exception 'invalid_action';
+end $$;
+revoke all on function public.math_review_json(uuid) from public, anon, authenticated;
+revoke all on function public.math_review_action(uuid, text, jsonb) from public, anon, authenticated;
+grant execute on function public.math_review_json(uuid) to service_role;
+grant execute on function public.math_review_action(uuid, text, jsonb) to service_role;
+
+-- the quiz sitting also carries each answer's teacher score, so its grade can use it (app/quiz_grades.py)
+create or replace 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',
+        'teacher_score', (select r.score from public.math_teacher_reviews r where r.attempt_id = x.aid
+                          order by r.created_at desc, r.id desc limit 1)) 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
+$$;
+commit;

supabase/migrations/20261104180000_math_resources_visible.sql

@@ -0,0 +1,6 @@
+-- Lesson resources a teacher chooses to show students (app/unit_resources.py). Additive: one column. Every resource
+-- added before this starts hidden, so nothing a teacher photographed for themselves reaches a student by surprise.
+begin;
+alter table public.math_unit_resources add column visible boolean not null default false;
+create index math_unit_resources_visible on public.math_unit_resources(unit_id, created_at desc) where visible;
+commit;

supabase/migrations/20261104210000_math_assignments.sql

@@ -0,0 +1,19 @@
+-- Assignments a class teacher gives a class (app/assignments.py): skills to finish, a unit quiz, a practice exam, by a
+-- date. Additive: one new table, read and written only with the server's secret key.
+begin;
+create table public.math_assignments (
+  id uuid primary key default gen_random_uuid(),
+  class_id bigint not null references public.classes(id) on delete cascade,
+  title text not null check (char_length(title) between 1 and 80),
+  note text not null default '' check (char_length(note) <= 500),
+  due_on date not null,
+  items jsonb not null check (jsonb_typeof(items) = 'array' and jsonb_array_length(items) between 1 and 20),
+  created_by_email text not null default '',
+  created_at timestamptz not null default now(),
+  updated_at timestamptz not null default now()
+);
+create index math_assignments_class on public.math_assignments(class_id, due_on desc);
+alter table public.math_assignments enable row level security;
+revoke all on public.math_assignments from public, anon, authenticated;
+grant all on public.math_assignments to service_role;
+commit;

tests/scan_support.py

@@ -48,6 +48,9 @@ class ScanAuth:
     def classes(self):
         return []
 
+    def user_email(self, user_id):
+        return user_id + '@test.invalid'
+
     def access_for(self, _id, **kwargs):
         return None
 
@@ -71,6 +74,9 @@ class DatabaseAnswers(AnswerScans):
     def quiz(self, user_id, action, **data):
         return self.rpc('math_quiz_action', user_id, action, data)
 
+    def review(self, user_id, action, **data):
+        return self.rpc('math_review_action', user_id, action, data)
+
     def rpc(self, name, user_id, action, data):
         import psycopg
         if self.fail_finalize and action == 'finalize':
@@ -84,7 +90,7 @@ class DatabaseAnswers(AnswerScans):
                 raise ScanError(404, 'not_found') from exc
             except psycopg.errors.RaiseException as exc:
                 message = str(exc).splitlines()[0]
-                raise ScanError(429 if message == 'grading_limit' else 409, message) from exc
+                raise ScanError(429 if message in ('grading_limit', 'review_limit') else 409, message) from exc
 
     def put(self, key, data):
         if self.fail_put:
@@ -129,8 +135,9 @@ 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())
+        for name in ('quiz_sittings', 'teacher_reviews'):   # in this order: the second rewrites a function of the first
+            for migration in sorted(Path('supabase/migrations').glob(f'*_math_{name}.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

@@ -353,8 +353,11 @@ def test_api_errors_are_named(status, message, reason):
 
 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 user_accounts(self, emails):
+        return {mail(uid): {'id': uid, 'name': ''} for uid in (OWNER, OTHER) if mail(uid) in emails}
+
+    def user_email(self, user_id):
+        return mail(user_id)
 
     def _admin(self, path, *args, **kwargs):
         if path.startswith('/rest/v1/math_progress'):
@@ -362,10 +365,35 @@ class ReportAuth(ClassAuth):
         return super()._admin(path, *args, **kwargs)
 
 
+async def hand_in_quiz(student, unit):
+    """The student photographs the four answers of a unit quiz, hands it in and asks each answer to be checked (as the
+    page does). Returns the attempt ids, the queue request ids and the sitting."""
+    from app.math_skills import question_version, quiz_snapshot
+    attempts, requests = [], []
+    for index in range(4):
+        version = question_version(quiz_snapshot(unit, index))
+        made = (await student.post('/api/math/quiz-attempts',
+                                   json={'unit': unit['id'], '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': unit['id'], 'attempts': attempts,
+                                                                'client_key': str(uuid.uuid4())})).json()
+    for aid in attempts:
+        asked = (await student.post(f'/api/math/answer-attempts/{aid}/grade', json={})).json()
+        requests.append(asked['ai_request']['id'])
+    return attempts, requests, handed
+
+
 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
+    from app.math_skills import algebra9
 
     store = answer_store
     app = create_app(auth=ReportAuth())
@@ -380,24 +408,7 @@ def test_a_quiz_checked_through_the_teachers_queue_has_one_grade_for_student_and
 
     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'])
+            attempts, requests, handed = await hand_in_quiz(student, unit)
             assert handed['grade'] is None and handed['open'] == 4          # every answer waits for the teacher
 
             def seen_by_teacher():
@@ -413,3 +424,104 @@ def test_a_quiz_checked_through_the_teachers_queue_has_one_grade_for_student_and
             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())
+
+
+def test_a_student_disputes_a_check_and_the_teachers_correction_reaches_both_screens(answer_store):
+    """The whole path: the student hands in a quiz, the teacher sends every answer to the AI, the student asks the
+    teacher to look again at one, the teacher corrects it with a comment, and the new grade, the comment and the closed
+    request show on the student's screen and in the teacher's class report."""
+    from app.math_skills import algebra9
+
+    app = create_app(auth=ReportAuth())
+    app.state.answers, app.state.ai_queue = answer_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 run():
+        async with as_user(app, OWNER) as student, as_user(app, OTHER) as teacher:
+            attempts, requests, handed = await hand_in_quiz(student, unit)
+            for rid in requests:
+                assert (await teacher.post(f'/api/ai-queue/{rid}/send')).status_code == 200
+            sittings = lambda: student.get('/api/math/quiz-sittings', params={'unit_id': 't'})
+            card = lambda: teacher.get('/api/classes/1/report')
+            assert (await sittings()).json()['sittings'][0]['grade'] == 25 + 15 + 25 + 10      # the AI's: 75
+            # the student disagrees with the second check
+            asked = await student.post(f'/api/math/answer-attempts/{attempts[1]}/review-request', json={'message': 'כתבתי x=4'})
+            assert asked.status_code == 200
+            waiting = (await teacher.get('/api/teacher/review-requests')).json()['requests']
+            assert [(x['attempt_id'], x['student'], x['message']) for x in waiting] == [(attempts[1], mail(OWNER), 'כתבתי x=4')]
+            assert (await card()).json()['students'][0]['review_requests'][0]['attempt_id'] == attempts[1]
+            opened = (await teacher.get(f'/api/teacher/answers/{attempts[1]}')).json()
+            assert opened['grading']['result']['score'] == 60 and opened['request']['state'] == 'open'
+            assert (await teacher.get(f'/api/teacher/answers/{attempts[1]}/image')).status_code == 200
+            # the teacher agrees with the student
+            saved = await teacher.put(f'/api/teacher/answers/{attempts[1]}/review', json={'score': 100, 'comment': 'צדקתם, הפתרון נכון'})
+            assert saved.status_code == 200 and saved.json()['request']['state'] == 'closed'
+            # the student's screen: the new grade, the teacher's words, the AI's check unchanged, the request closed
+            mine = (await sittings()).json()['sittings'][0]
+            assert mine['grade'] == 25 + 25 + 25 + 10 and mine['questions'][1]['state'] == 'teacher'
+            assert [c['comment'] for c in (await student.get('/api/math/teacher-comments')).json()['comments']] == ['צדקתם, הפתרון נכון']
+            answer = (await student.get(f'/api/math/answer-attempts/{attempts[1]}')).json()
+            assert answer['teacher_review']['score'] == 100 and answer['grading']['result']['score'] == 60
+            assert answer['review_request']['state'] == 'closed' and answer['effective_score'] == 100
+            assert (await student.get('/api/math/teacher-comments')).json() == {'comments': []}
+            # the teacher's report: the same grade, and nobody waiting
+            report = (await card()).json()['students'][0]
+            assert report['quiz_sittings'][0]['grade'] == mine['grade'] == 85 and report['quiz_sittings'][0]['id'] == handed['id']
+            assert report['review_requests'] == []
+            assert (await teacher.get('/api/teacher/review-requests')).json() == {'requests': []}
+    asyncio.run(run())
+
+
+def test_handing_a_quiz_in_queues_every_photographed_answer_for_the_teacher_without_the_page_asking(answer_store):
+    """A student's answers all reach their teacher at hand-in, even if the page never asks for the checks one by one."""
+    from app.math_skills import algebra9, question_version, quiz_snapshot
+    from test_unit_quiz import quiz_answer
+
+    app = make_app(answer_store)
+    app.state.auth = ReportAuth()
+    unit = next(u for u in algebra9()['units'] if u['id'] == 't')
+    ids = [quiz_answer(answer_store, i, photo=i != 2) for i in range(4)]   # the third question has no photo
+    key = str(uuid.uuid4())
+
+    async def run():
+        async with as_user(app, OWNER) as student, as_user(app, OTHER) as teacher:
+            r = await student.post('/api/math/quiz-sittings', json={'unit_id': 't', 'attempts': ids, 'client_key': key})
+            assert r.status_code == 200
+            rows = (await teacher.get('/api/ai-queue')).json()['requests']
+            assert sorted(x['label'][-1] for x in rows) == ['1', '2', '4'] and {x['state'] for x in rows} == {'pending'}
+            assert {x['attempt_id'] for x in rows} == {ids[0], ids[1], ids[3]} and all(x['kind'] == 'grading' for x in rows)
+            # handing the same quiz in again changes nothing, and the page's own checks find the requests waiting
+            assert (await student.post('/api/math/quiz-sittings', json={'unit_id': 't', 'attempts': ids, 'client_key': key})).status_code == 200
+            assert len((await teacher.get('/api/ai-queue')).json()['requests']) == 3
+            asked = (await student.post(f'/api/math/answer-attempts/{ids[0]}/grade', json={})).json()
+            assert asked['ai_request']['state'] == 'pending' and len((await teacher.get('/api/ai-queue')).json()['requests']) == 3
+            # an answer the teacher declined stays declined when the hand-in is repeated
+            declined = rows[0]['id']
+            await teacher.post(f'/api/ai-queue/{declined}/decline', json={'note': 'צלמו שוב'})
+            await student.post('/api/math/quiz-sittings', json={'unit_id': 't', 'attempts': ids, 'client_key': key})
+            states = {x['id']: x['state'] for x in (await teacher.get('/api/ai-queue')).json()['requests']}
+            assert states[declined] == 'declined' and len(states) == 3
+    asyncio.run(run())
+    assert len(app.state.ai_queue.rows) == 3
+
+
+def test_a_teachers_own_hand_in_does_not_go_through_the_queue(answer_store):
+    """Accounts that send straight to the AI keep doing so: the hand-in queues nothing for them."""
+    from test_unit_quiz import quiz_answer
+
+    app = make_app(answer_store)
+    app.state.auth = ReportAuth()
+    app.state.auth.teachers = frozenset({mail(OWNER)})   # OWNER has the teacher role now
+    ids = [quiz_answer(answer_store, i) for i in range(4)]
+
+    async def run():
+        async with as_user(app, OWNER) as me:
+            assert (await me.post('/api/math/quiz-sittings', json={'unit_id': 't', 'attempts': ids, 'client_key': str(uuid.uuid4())})).status_code == 200
+    asyncio.run(run())
+    assert app.state.ai_queue.rows == []

tests/test_answer_browser.py

@@ -451,3 +451,55 @@ def test_the_phone_answers_a_photo_request_by_drawing_on_the_board(scan_server):
             assert not errors
         finally:
             browser.close()
+
+
+@pytest.mark.parametrize('teacher_score,completes', [(100, True), (85, False)])
+def test_the_teachers_review_shows_above_the_ai_check_and_a_100_completes_the_skill(scan_server, teacher_score, completes):
+    import uuid
+    url, store = scan_server
+    from test_answer_scans import begin, finish
+    from app.math_skills import algebra9, question_version
+    skill = next(s for s in algebra9()['skills'] if s['id'] == 'a_30_side')
+    made = store.action(OWNER, 'resume', question_id=skill['id'],
+                        question_version=question_version(skill['sample']), snapshot=skill['sample'])
+    aid = finish(store, begin(store, store.action(OWNER, 'create_scan', attempt_id=made['attempt']['id'])))['attempt']['id']
+    lease = str(uuid.uuid4())   # the AI called it partial: 60
+    store.grade(OWNER, 'start', attempt_id=aid, lease_id=lease)
+    store.grade(OWNER, 'complete', attempt_id=aid, lease_id=lease, result=validate_assessment(
+        assessment(complete=False, score=60, feedback='חסר פירוט בשלב האחרון')))
+    store.review(OWNER, 'review', attempt_id=aid, reviewer='teacher@test.invalid', score=teacher_score,
+                 comment='הדרך נכונה <b>מאוד</b>')
+    key = 'mathly.progress.v1:' + OWNER + '@test.invalid'
+    with playwright.sync_playwright() as p:
+        browser = p.chromium.launch()
+        try:
+            page = session(browser).new_page(); errors = []
+            page.on('pageerror', lambda error: errors.append(str(error)))
+            page.goto(url); open_question(page)
+            note = page.locator('.mx-teacher-note')
+            playwright.expect(note).to_contain_text('הערת המורה')
+            playwright.expect(note).to_contain_text(f'{teacher_score}/100')
+            playwright.expect(note).to_contain_text('הדרך נכונה <b>מאוד</b>')       # shown as text, never as markup
+            assert note.locator('b').count() == 0
+            grade = page.locator('.mx-grade')
+            playwright.expect(grade.locator('h4')).to_contain_text('בדיקה אוטומטית: ')
+            playwright.expect(grade.locator('h4')).to_contain_text('60/100')       # the AI's own score stays visible
+            assert page.locator('.mx-teacher-note, .mx-grade').first.get_attribute('class').startswith('mx-teacher-note')   # above it
+            page.wait_for_timeout(500)
+            assert page.evaluate("key=>!!JSON.parse(localStorage.getItem(key)||'{}').done?.a_30_side", key) == completes
+            for _ in range(6):   # a finished skill is celebrated: dismiss it
+                if not page.locator('.sky-cele [data-sky=go]').count():
+                    break
+                page.locator('.sky-cele [data-sky=go]').first.click(); page.wait_for_timeout(200)
+            # the student asks the teacher to look again
+            page.locator('.mx-ask summary').click()
+            page.locator('[data-ask-msg]').fill('כתבתי את כל השלבים')
+            page.locator('[data-ask-review]').click()
+            playwright.expect(page.locator('.mx-ask-wait')).to_contain_text('הבקשה ממתינה')
+            asked = store.review(OWNER, 'get', attempt_id=aid)['request']
+            assert asked['state'] == 'open' and asked['message'] == 'כתבתי את כל השלבים'
+            page.reload(); open_question(page)
+            playwright.expect(page.locator('.mx-ask-wait')).to_contain_text('הבקשה ממתינה')   # and it is remembered
+            assert page.locator('[data-ask-review]').count() == 0 and not errors
+        finally:
+            browser.close()

tests/test_assignments.py

@@ -0,0 +1,400 @@
+"""Assignments: what a class teacher asks their class to do. Storage is in memory; the migration runs on real PostgreSQL."""
+import asyncio
+import uuid
+from pathlib import Path
+
+import httpx
+import pytest
+
+from app.answer_scans import ScanError
+from app.assignments import Assignments, AssignmentsUnavailable
+from app.main import create_app
+from app.math_skills import algebra9
+from scan_support import BOOTSTRAP, answer_store, postgres_server
+
+TEACHER, STUDENT, OTHER_TEACHER, OUTSIDER, MANAGER, PUPIL4 = "t-id", "s-id", "o-id", "x-id", "m-id", "p-id"
+EMAILS = {TEACHER: "teacher@x.test", STUDENT: "student@x.test", OTHER_TEACHER: "other@x.test",
+          OUTSIDER: "out@x.test", MANAGER: "boss@x.test", PUPIL4: "pupil4@x.test"}
+UNITS = algebra9()["units"]
+NO_QUIZ = next(u["id"] for u in UNITS if "quiz" not in u)
+
+
+class ClassAuth:
+    url, key, secret = "https://test.invalid", "public-test", "server-test"
+    developers = frozenset()
+    teachers = frozenset({"boss@x.test"})   # a manager
+
+    def __init__(self):
+        self.rows = [
+            {"id": 3, "name": "ט׳1", "lessons": ["t", "k", NO_QUIZ], "teachers": ["teacher@x.test"],
+             "emails": ["student@x.test", "teacher@x.test"], "nicknames": {}, "exams": []},
+            {"id": 4, "name": "ט׳2", "lessons": ["t"], "teachers": ["other@x.test"],
+             "emails": ["pupil4@x.test", "other@x.test"], "nicknames": {}, "exams": []}]
+
+    def user(self, token):
+        return {"id": token, "email": EMAILS[token]} if token in EMAILS else None
+
+    def classes(self, fresh=False):
+        return self.rows
+
+    def access_for(self, _id, **kwargs):
+        return None
+
+
+class MemoryAssignments(Assignments):
+    configured = True
+
+    def __init__(self, fail=False):
+        self.rows, self.fail = {}, fail
+
+    def _check(self):
+        if self.fail:
+            raise AssignmentsUnavailable("assignments_unavailable")
+
+    def for_classes(self, class_ids):
+        self._check()
+        return sorted((r for r in self.rows.values() if r["class_id"] in class_ids), key=lambda r: r["due_on"], reverse=True)
+
+    def get(self, assignment_id):
+        self._check()
+        return self.rows.get(assignment_id)
+
+    def add(self, row):
+        self._check()
+        row = {**row, "id": str(uuid.uuid4()), "created_at": "2026-11-04T08:00:00+00:00", "updated_at": "2026-11-04T08:00:00+00:00"}
+        self.rows[row["id"]] = row
+        return row
+
+    def update(self, assignment_id, fields):
+        self._check()
+        self.rows[assignment_id] = {**self.rows[assignment_id], **fields}
+        return self.rows[assignment_id]
+
+    def remove(self, assignment_id):
+        self._check()
+        self.rows.pop(assignment_id, None)
+
+
+class Sittings:
+    """The server's unit-quiz sittings (app/quiz_grades.py): quiz(user, "list", unit_id=...)."""
+    configured = True
+
+    def __init__(self, by_user=None, fail=False):
+        self.by_user, self.fail = by_user or {}, fail
+
+    def quiz(self, user_id, action, **data):
+        if self.fail:
+            raise ScanError(503, "quiz_sittings_unavailable")
+        return [s for s in self.by_user.get(user_id, []) if s["unit_id"] == data["unit_id"]]
+
+
+def make_app(store=None, sittings=None):
+    app = create_app(auth=ClassAuth())
+    app.state.assignments = store or MemoryAssignments()
+    app.state.answers = sittings or Sittings()
+    return app
+
+
+def client(app, user):
+    return httpx.AsyncClient(transport=httpx.ASGITransport(app=app), base_url="http://test",
+                             headers={"Authorization": f"Bearer {user}"})
+
+
+GOOD = {"title": "חזרה לפני המבחן", "note": "בהצלחה", "due_on": "2026-11-12",
+        "items": [{"kind": "skill", "id": "t_ext"}, {"kind": "unit_quiz", "unit": "k"},
+                  {"kind": "exam", "units": ["k", "t"]}]}   # exam units are kept sorted
+
+
+def test_the_class_teacher_creates_lists_edits_and_deletes_assignments():
+    store = MemoryAssignments()
+    app = make_app(store)
+
+    async def check():
+        async with client(app, TEACHER) as teacher:
+            made = await teacher.post("/api/classes/3/assignments", json=GOOD)
+            assert made.status_code == 201
+            row = made.json()
+            assert (row["title"], row["note"], row["due_on"], row["class_id"]) == ("חזרה לפני המבחן", "בהצלחה", "2026-11-12", 3)
+            assert row["items"] == GOOD["items"] and row["created_by_email"] == "teacher@x.test"
+            assert [r["id"] for r in store.rows.values()] == [row["id"]] and store.rows[row["id"]]["class_id"] == 3
+            listed = (await teacher.get("/api/classes/3/assignments")).json()["assignments"]
+            assert [r["id"] for r in listed] == [row["id"]]
+            edited = await teacher.put(f"/api/classes/3/assignments/{row['id']}",
+                                       json={**GOOD, "title": "  חזרה   מורחבת ", "due_on": "2026-11-14",
+                                             "items": [{"kind": "skill", "id": "t_ext"}, {"kind": "skill", "id": "t_ext"}]})
+            assert edited.status_code == 200
+            assert (edited.json()["title"], edited.json()["due_on"], edited.json()["items"]) == (
+                "חזרה מורחבת", "2026-11-14", [{"kind": "skill", "id": "t_ext"}])   # spacing tidied, a repeated item once
+            gone = await teacher.delete(f"/api/classes/3/assignments/{row['id']}")
+            assert gone.json() == {"ok": True} and not store.rows
+            assert (await teacher.delete(f"/api/classes/3/assignments/{row['id']}")).status_code == 404
+    asyncio.run(check())
+    assert [a["kind"] for a in app.state.actions.recent()].count("assignment_saved") == 2
+
+
+def test_an_assignment_is_checked_against_the_classs_units():
+    app = make_app()
+    skills = algebra9()["skills"]
+    class_skills = [s["id"] for s in skills if s["unit"] in ("t", "t2", "k", "i", NO_QUIZ)]
+    with_items = lambda *items: {**GOOD, "items": list(items)}
+    bad = [
+        with_items({"kind": "skill", "id": "no_such_skill"}),
+        with_items({"kind": "unit_quiz", "unit": NO_QUIZ}),                  # a unit without a quiz
+        with_items({"kind": "exam", "units": []}),
+        with_items({"kind": "exam", "units": ["t", "t"]}),
+        with_items({"kind": "homework"}), with_items("t_ext"), with_items(),
+        {**GOOD, "items": [{"kind": "skill", "id": sid} for sid in class_skills[:21]]},       # one too many
+        {**GOOD, "title": ""}, {**GOOD, "title": "   "}, {**GOOD, "title": "א" * 81}, {**GOOD, "note": "א" * 501},
+        {**GOOD, "due_on": "2026-13-45"}, {**GOOD, "due_on": "12/11/2026"}, {**GOOD, "due_on": "2026-11-12T10:00:00"},
+        {**GOOD, "due_on": ""}, {**GOOD, "due_on": 20261112}, {k: v for k, v in GOOD.items() if k != "due_on"},
+        {**GOOD, "items": "t_ext"}]
+
+    async def check():
+        async with client(app, TEACHER) as teacher:
+            for body in bad:
+                assert (await teacher.post("/api/classes/3/assignments", json=body)).status_code == 400, body
+            assert (await teacher.post("/api/classes/3/assignments", json=GOOD)).status_code == 201
+            twenty = [{"kind": "skill", "id": sid} for sid in class_skills[:20]]
+            assert (await teacher.post("/api/classes/3/assignments", json={**GOOD, "items": twenty})).status_code == 201
+            assert len(app.state.assignments.rows) == 2   # nothing else was stored
+        async with client(app, OTHER_TEACHER) as other:   # class 4 has unit t (and t2, split off from it), not k
+            ok = {"kind": "skill", "id": "t_ext"}
+            for foreign in ({"kind": "skill", "id": next(s["id"] for s in skills if s["unit"] == "k")},
+                            {"kind": "unit_quiz", "unit": "k"}, {"kind": "exam", "units": ["t", "k"]}):
+                assert (await other.post("/api/classes/4/assignments", json=with_items(ok, foreign))).status_code == 400, foreign
+            assert (await other.post("/api/classes/4/assignments", json=with_items(ok, {"kind": "unit_quiz", "unit": "t"}))).status_code == 201
+    asyncio.run(check())
+
+
+def test_only_the_classs_teacher_or_a_manager_may_manage_its_assignments():
+    store = MemoryAssignments()
+    app = make_app(store)
+
+    async def check():
+        async with client(app, TEACHER) as teacher:
+            row = (await teacher.post("/api/classes/3/assignments", json=GOOD)).json()
+        for who in (STUDENT, OTHER_TEACHER, OUTSIDER):
+            async with client(app, who) as c:
+                assert (await c.get("/api/classes/3/assignments")).status_code == 403, who
+                assert (await c.post("/api/classes/3/assignments", json=GOOD)).status_code == 403, who
+                assert (await c.put(f"/api/classes/3/assignments/{row['id']}", json=GOOD)).status_code == 403
+                assert (await c.delete(f"/api/classes/3/assignments/{row['id']}")).status_code == 403
+        assert len(store.rows) == 1
+        async with client(app, MANAGER) as manager:
+            assert (await manager.post("/api/classes/3/assignments", json=GOOD)).status_code == 201
+            assert (await manager.post("/api/classes/99/assignments", json=GOOD)).status_code == 404
+        async with client(app, OTHER_TEACHER) as other:   # their own class, but not another class's assignment
+            assert (await other.delete(f"/api/classes/4/assignments/{row['id']}")).status_code == 404
+            assert (await other.put(f"/api/classes/4/assignments/{row['id']}", json=GOOD)).status_code == 404
+            assert (await other.get("/api/classes/4/assignments")).json() == {"assignments": []}
+        async with httpx.AsyncClient(transport=httpx.ASGITransport(app=app), base_url="http://test") as guest:
+            assert (await guest.get("/api/classes/3/assignments")).status_code == 401
+    asyncio.run(check())
+
+
+def test_students_get_only_their_classs_assignments_and_when_they_handed_in_each_unit_quiz():
+    store = MemoryAssignments()
+    app = make_app(store, Sittings({STUDENT: [
+        {"id": "s1", "unit_id": "k", "submitted_at": "2026-11-05T10:00:00Z", "grade": 80},
+        {"id": "s2", "unit_id": "t", "submitted_at": "2026-11-01T10:00:00Z", "grade": 90}]}))
+
+    async def check():
+        async with client(app, TEACHER) as teacher, client(app, OTHER_TEACHER) as other:
+            mine = (await teacher.post("/api/classes/3/assignments", json=GOOD)).json()
+            await other.post("/api/classes/4/assignments", json={**GOOD, "title": "של כיתה אחרת", "items": [{"kind": "skill", "id": "t_ext"}]})
+        async with client(app, STUDENT) as student:
+            r = await student.get("/api/math/assignments")
+            assert r.status_code == 200
+            data = r.json()
+            assert [a["id"] for a in data["assignments"]] == [mine["id"]] and data["assignments"][0]["class_name"] == "ט׳1"
+            assert "created_by_email" not in data["assignments"][0] and "teacher@x.test" not in r.text   # no teacher email
+            assert data["sittings"] == [{"unit_id": "k", "submitted_at": "2026-11-05T10:00:00Z"}]      # only the assigned unit's
+            assert len(data["today"]) == 10
+        async with client(app, OUTSIDER) as outsider:   # in no class while classes exist: not let in at all
+            assert (await outsider.get("/api/math/assignments")).status_code == 403
+        async with httpx.AsyncClient(transport=httpx.ASGITransport(app=app), base_url="http://test") as guest:
+            assert (await guest.get("/api/math/assignments")).status_code == 401
+    asyncio.run(check())
+
+
+def test_without_the_servers_sittings_or_table_the_answers_say_so():
+    store = MemoryAssignments()
+    app = make_app(store, Sittings(fail=True))
+
+    async def check():
+        async with client(app, TEACHER) as teacher:
+            await teacher.post("/api/classes/3/assignments", json=GOOD)
+        async with client(app, STUDENT) as student:
+            data = (await student.get("/api/math/assignments")).json()
+            assert len(data["assignments"]) == 1 and data["sittings"] is None   # unit-quiz items cannot be told done
+        store.fail = True
+        async with client(app, STUDENT) as student, client(app, TEACHER) as teacher:
+            r = await student.get("/api/math/assignments")
+            assert (r.status_code, r.json()["detail"]) == (503, "assignments_unavailable")
+            assert (await teacher.post("/api/classes/3/assignments", json=GOOD)).status_code == 503
+    asyncio.run(check())
+
+
+def test_the_migration_is_additive_service_only_and_follows_its_class(postgres_server):
+    psycopg = pytest.importorskip("psycopg")
+    database = "asg_" + uuid.uuid4().hex
+    with psycopg.connect(postgres_server.get_uri(), autocommit=True) as c:
+        c.execute("create database " + database)
+    try:
+        with psycopg.connect(postgres_server.get_uri(database=database), autocommit=True) as c:
+            c.execute(BOOTSTRAP)
+            c.execute("insert into classes values (2, 'other class')")
+            c.execute(Path("supabase/migrations/20261104210000_math_assignments.sql").read_text())
+            assert c.execute("select name from classes order by id").fetchall() == [("existing math class",), ("other class",)]
+            c.execute("set role service_role")
+            add = lambda cls, items='[{"kind":"skill","id":"t_ext"}]', title="חזרה", due="2026-11-12": c.execute(
+                "insert into math_assignments(class_id,title,due_on,items) values(%s,%s,%s,%s::jsonb)", (cls, title, due, items))
+            add(1)
+            add(1, title="שני")
+            add(2)
+            for bad in (dict(cls=1, title=""), dict(cls=1, title="א" * 81), dict(cls=1, items="[]"), dict(cls=1, items="{}"),
+                        dict(cls=1, items="[" + ",".join(['{"kind":"skill","id":"x"}'] * 21) + "]"), dict(cls=99)):
+                with pytest.raises(psycopg.errors.Error):
+                    add(**bad)
+            c.execute("reset role")
+            c.execute("delete from classes where id = 1")   # a deleted class takes its assignments with it
+            assert c.execute("select count(*) from math_assignments").fetchone()[0] == 1
+            c.execute("set role authenticated")
+            with pytest.raises(psycopg.errors.InsufficientPrivilege):
+                c.execute("select * from math_assignments")
+    finally:
+        with psycopg.connect(postgres_server.get_uri(), autocommit=True) as c:
+            c.execute("drop database " + database + " with (force)")
+
+
+def test_a_student_in_two_classes_gets_the_assignments_of_both_and_none_of_a_third():
+    app = make_app()
+    app.state.auth.rows[1]["emails"].append("student@x.test")   # the student is in class 4 as well
+    app.state.auth.rows.append({"id": 5, "name": "ט׳3", "lessons": ["t"], "teachers": ["other@x.test"],
+                                "emails": ["pupil4@x.test"], "nicknames": {}, "exams": []})
+
+    async def check():
+        async with client(app, TEACHER) as teacher, client(app, OTHER_TEACHER) as other:
+            await teacher.post("/api/classes/3/assignments", json={**GOOD, "title": "כיתה 3"})
+            await other.post("/api/classes/4/assignments", json={**GOOD, "title": "כיתה 4", "items": [{"kind": "skill", "id": "t_ext"}]})
+            await other.post("/api/classes/5/assignments", json={**GOOD, "title": "כיתה 5", "items": [{"kind": "skill", "id": "t_ext"}]})
+        async with client(app, STUDENT) as student:
+            got = (await student.get("/api/math/assignments")).json()["assignments"]
+            assert sorted((a["title"], a["class_name"]) for a in got) == [("כיתה 3", "ט׳1"), ("כיתה 4", "ט׳2")]
+    asyncio.run(check())
+
+
+# ---- the whole path: a real server and database, a real browser for the student
+def test_an_assignment_given_by_the_teacher_is_completed_by_the_student_and_shows_done_in_the_report(answer_store, monkeypatch):
+    """The teacher gives a class two skills and a unit quiz. The student's home card follows them as the student finishes
+    the skills in the browser and hands the quiz in; the teacher's report then carries what is needed to show the student
+    as done, and the rules of the page agree."""
+    import socket
+    import threading
+    import time
+    import urllib.parse
+
+    import uvicorn
+    from scan_support import OTHER, OWNER, ScanAuth
+    from test_answer_browser import session
+    from test_sky_browser import answer_skill_right
+    from test_unit_quiz import check, quiz_answer
+    playwright = pytest.importorskip("playwright.sync_api")
+    monkeypatch.setenv("MATHLY_OPEN_ENDED_LOCKED", "0")
+    mail = lambda uid: uid + "@test.invalid"
+
+    class SchoolAuth(ScanAuth):
+        teachers = frozenset()   # nobody is a manager: OTHER is the class teacher, OWNER a student
+
+        def __init__(self):
+            self.progress = {}
+
+        def user(self, token):
+            return {"id": token, "email": mail(token)} if token in (OWNER, OTHER) else None
+
+        def classes(self, fresh=False):
+            return [{"id": 3, "name": "ט׳1", "lessons": ["t", "k"], "teachers": [mail(OTHER)],
+                     "emails": [mail(OWNER), mail(OTHER)], "nicknames": {}, "exams": []}]
+
+        def user_accounts(self, emails):
+            return {mail(uid): {"id": uid, "name": ""} for uid in (OWNER, OTHER) if mail(uid) in emails}
+
+        def _admin(self, path, method="GET", body=None, prefer=""):
+            from app.auth import AuthUnavailable
+            table, _, query = path.partition("?")
+            if table != "/rest/v1/math_progress":
+                raise AuthUnavailable("supabase answered 404: no other tables here")
+            if method == "POST":
+                self.progress[body["user_id"]] = {"data": body["data"], "updated_at": body["updated_at"]}
+                return None
+            wanted = dict(urllib.parse.parse_qsl(query))["user_id"]
+            ids = wanted.removeprefix("in.(").removesuffix(")").split(",") if wanted.startswith("in.") else [wanted.removeprefix("eq.")]
+            return [{"user_id": i, **self.progress[i]} for i in ids if i in self.progress]
+
+    auth = SchoolAuth()
+    app = create_app(auth=auth)
+    app.state.answers, app.state.assignments = answer_store, MemoryAssignments()
+    plan = {"title": "חזרה על הפילוג", "note": "", "due_on": "2099-01-01",
+            "items": [{"kind": "skill", "id": "t_ext"}, {"kind": "skill", "id": "t_simplify"}, {"kind": "unit_quiz", "unit": "t"}]}
+    with socket.socket() as sock:
+        sock.bind(("127.0.0.1", 0))
+        server = uvicorn.Server(uvicorn.Config(app, log_level="error"))
+        thread = threading.Thread(target=server.run, kwargs={"sockets": [sock]}, daemon=True)
+        thread.start()
+        try:
+            while not server.started:
+                time.sleep(.01)
+            url = f"http://127.0.0.1:{sock.getsockname()[1]}"
+            as_ = lambda uid: {"Authorization": f"Bearer {uid}"}
+            made = httpx.post(url + "/api/classes/3/assignments", json=plan, headers=as_(OTHER))
+            assert made.status_code == 201
+            with playwright.sync_playwright() as p:
+                browser = p.chromium.launch()
+                try:
+                    page = session(browser, mobile=True).new_page()
+                    errors = []
+                    page.on("pageerror", lambda e: errors.append(str(e)))
+                    page.goto(url)
+                    page.locator('.mx-nav [data-view="path"]').click()
+                    card = page.locator(".mx-asgs .mx-asg")
+                    playwright.expect(card).to_contain_text("חזרה על הפילוג")
+                    playwright.expect(card).to_contain_text("0 מתוך 3 הושלמו")
+                    playwright.expect(page.locator('.mx-star[data-id="t_ext"] .mx-asg-pin')).to_have_count(1)
+                    for skill, count in (("t_ext", 1), ("t_simplify", 2)):          # the student finishes the skills
+                        page.locator(f'.mx-star[data-id="{skill}"]').click()
+                        answer_skill_right(page)
+                        while page.locator(".sky-cele [data-sky=go]").count():
+                            page.locator(".sky-cele [data-sky=go]").first.click()
+                        page.locator(".mx-x").last.click()
+                        playwright.expect(card).to_contain_text(f"{count} מתוך 3 הושלמו")
+                    playwright.expect(card.locator("[data-asg-go]")).to_contain_text("בוחן מסכם")    # what is left
+                    # the unit quiz: photographed, checked and handed in
+                    ids = [quiz_answer(answer_store, i) for i in range(4)]
+                    for aid in ids:
+                        check(answer_store, aid, 100)
+                    handed = httpx.post(url + "/api/math/quiz-sittings", headers=as_(OWNER), json={
+                        "unit_id": "t", "attempts": ids, "client_key": str(uuid.uuid4())})
+                    assert handed.status_code == 200 and handed.json()["grade"] == 100
+                    page.reload()
+                    page.locator('.mx-nav [data-view="path"]').click()
+                    playwright.expect(page.locator(".mx-asgs .mx-asg")).to_have_count(0)           # nothing open is left
+                    playwright.expect(page.locator(".mx-asg-done summary")).to_have_text("הושלמו (1)")
+                    assert page.locator(".mx-asg-pin").count() == 0                                # and no markers
+                    # what the student's device saved reaches the server; then the teacher's report
+                    deadline = time.monotonic() + 10
+                    while time.monotonic() < deadline and not {"t_ext", "t_simplify"} <= set(auth.progress.get(OWNER, {}).get("data", {}).get("done", {})):
+                        time.sleep(.2)
+                    report = httpx.get(url + "/api/classes/3/report", headers=as_(OTHER)).json()
+                    (student,) = report["students"]
+                    (assignment,) = report["assignments"]
+                    assert assignment["id"] == made.json()["id"] and student["email"] == mail(OWNER)
+                    assert {"t_ext", "t_simplify"} <= set(student["progress"]["done"])
+                    assert [s["grade"] for s in student["quiz_sittings"]] == [100]
+                    seen = page.evaluate("([a, s]) => MathlySky.assignmentState(a, s.progress, s.quiz_sittings)", [assignment, student])
+                    assert seen["finished"] and seen["doneCount"] == 3 and not seen["overdue"] and not seen["late"]
+                    assert not errors
+                finally:
+                    browser.close()
+        finally:
+            server.should_exit = True
+            thread.join(timeout=5)

tests/test_board_browser.py

@@ -372,3 +372,163 @@ def test_the_move_tool_scrolls_when_it_drags_empty_paper(browser, server):
     touch(page, [("pointerdown", 4, 300, 200), *[("pointermove", 4, 300, 200 + k * 60) for k in range(1, 11)], ("pointerup", 4, 300, 800)])
     playwright.expect(page.locator(".mx-board-top")).to_be_hidden()
     assert errors == []
+
+
+def test_an_angle_gets_an_arc_and_its_words_at_a_triangles_corner(browser, server):
+    page, errors = open_skill(browser, server, 1440, 900)
+    board_on(page)
+    page.locator(".mx-board [data-tool=line]").click()
+    drag(page, (100, 300), (300, 300))
+    drag(page, (302, 302), (200, 150))
+    drag(page, (198, 148), (102, 298))
+    page.locator(".mx-board [data-tool=angle]").click()
+    box = page.locator(".mx-board canvas").bounding_box()
+    at = lambda x, y: (box["x"] + x, box["y"] + y)
+
+    # the bottom-left corner: its edges go right (0°) and up to the top (-56°), so the arc is at radius 30, around -28°
+    arc, words = (126, 286), (138, 280)
+    ink_by = lambda x, y: max(alpha_near(page, x + dx, y + dy) for dx in (-6, -3, 0, 3, 6) for dy in (-4, 0, 4))
+    assert alpha_near(page, *arc) == 0
+    page.mouse.move(*at(112, 294))   # pointing into the corner: its arc shows, dashed, before anything is added
+    assert alpha_near(page, *arc) > 0
+    page.mouse.move(*at(400, 500))   # away from every corner: nothing
+    assert alpha_near(page, *arc) == 0
+
+    page.mouse.click(*at(112, 294))
+    field = page.locator(".mx-board-anglein")
+    playwright.expect(field).to_be_focused()
+    field.fill("60")
+    field.press("Enter")
+    playwright.expect(field).to_have_count(0)
+    assert alpha_near(page, *arc) > 0 and ink_by(*words) > 0
+
+    # the words open again for a change; a number is shown without its degree sign, which comes back by itself
+    page.mouse.click(*at(*words))
+    playwright.expect(field).to_have_value("60")
+    field.press("Escape")   # leaves it as it was, and the board open
+    playwright.expect(field).to_have_count(0)
+    playwright.expect(page.locator(".mx-board")).to_be_visible()
+    assert ink_by(*words) > 0
+
+    # the angle belongs to its corner: it moves with the triangle and goes with an undo
+    page.locator(".mx-board [data-tool=move]").click()
+    drag(page, (200, 300), (200, 400))
+    assert alpha_near(page, *arc) == 0 and alpha_near(page, arc[0], arc[1] + 100) > 0
+    page.keyboard.press("Control+z")   # the move
+    page.keyboard.press("Control+z")   # the angle
+    assert alpha_near(page, *arc) == 0 and alpha_near(page, 200, 300) > 0
+
+    # a corner where nothing meets is no angle; Escape on a new one takes it back
+    page.locator(".mx-board [data-tool=angle]").click()
+    page.mouse.click(*at(500, 500))
+    playwright.expect(field).to_have_count(0)
+    page.mouse.click(*at(112, 294))
+    field.press("Escape")
+    assert alpha_near(page, *arc) == 0
+
+    # α, β and γ are a tap away, typed where the cursor is; a number added to them is in degrees too
+    page.mouse.click(*at(112, 294))
+    page.locator(".mx-board-angleedit button", has_text="β").click()
+    playwright.expect(field).to_have_value("β")
+    playwright.expect(field).to_be_focused()
+    page.keyboard.type("+90")
+    page.keyboard.press("Enter")
+    playwright.expect(field).to_have_count(0)
+    assert alpha_near(page, *arc) > 0 and ink_by(*words) > 0
+    page.mouse.click(*at(*words))
+    playwright.expect(field).to_have_value("β+90")   # its degree sign comes back by itself
+    field.fill("180-alpha")   # the letters' names become the letters
+    field.press("Enter")
+    page.mouse.click(*at(*words))
+    playwright.expect(field).to_have_value("180-α")
+
+    # a double arc (equal angles are marked alike): a second arc 4 px outside the first, kept, and undone like the rest
+    outer = (100 + 34 * 0.883, 300 - 34 * 0.469)
+    assert alpha_near(page, *outer) == 0
+    page.locator(".mx-board-arcs [data-arcs='2']").click()
+    assert alpha_near(page, *outer) > 0   # shown at once
+    field.press("Enter")
+    assert alpha_near(page, *arc) > 0 and alpha_near(page, *outer) > 0
+    page.mouse.click(*at(112, 294))
+    playwright.expect(page.locator(".mx-board-arcs [data-arcs='2']")).to_have_attribute("aria-pressed", "true")
+    field.press("Escape")
+    page.keyboard.press("Control+z")
+    assert alpha_near(page, *arc) > 0 and alpha_near(page, *outer) == 0
+
+    # its colour, arcs and words together, picked in the same box
+    red = lambda: page.evaluate("""([x,y])=>{ const c=document.querySelector('.mx-board canvas'), d=devicePixelRatio||1;
+      const px=c.getContext('2d').getImageData(Math.round(x*d)-1,Math.round(y*d)-1,3,3).data; let n=0;
+      for(let i=0;i<px.length;i+=4) if(px[i+3]>128&&px[i]>150&&px[i+2]<130) n++; return n; }""", list(arc))
+    assert red() == 0
+    page.mouse.click(*at(112, 294))
+    page.locator(".mx-board-colors [data-color='#D3455B']").click()
+    assert red() > 0   # shown at once
+    field.press("Enter")
+    assert red() > 0
+    page.keyboard.press("Control+z")
+    assert red() == 0
+    assert errors == []
+
+
+def test_angles_where_a_line_meets_a_side_or_crosses_another(browser, server):
+    page, errors = open_skill(browser, server, 1440, 900)
+    board_on(page)
+    page.locator(".mx-board [data-tool=line]").click()
+    drag(page, (90, 438), (420, 438))
+    drag(page, (92, 436), (200, 80))
+    drag(page, (202, 82), (418, 436))
+    drag(page, (200, 82), (262, 433))   # from the top down to the base, ending a little short: it snaps onto the base
+    drag(page, (120, 300), (380, 300))   # across the triangle
+    page.locator(".mx-board [data-tool=angle]").click()
+    box = page.locator(".mx-board canvas").bounding_box()
+    field = page.locator(".mx-board-anglein")
+
+    def add(x, y, text):
+        page.mouse.click(box["x"] + x, box["y"] + y)
+        playwright.expect(field).to_be_focused()
+        field.fill(text)
+        field.press("Enter")
+
+    foot = 262 + (438 - 433) * 62 / 353   # where the middle line meets the base
+    assert alpha_near(page, foot, 437) > 0 and alpha_near(page, foot, 441) == 0   # it reached the base, not past it
+    add(250, 430, "α")   # either side of the line drawn from the base
+    add(275, 430, "β")
+    assert alpha_near(page, foot - 30, 438 - 3) > 0 and alpha_near(page, foot + 30, 438 - 3) > 0
+    add(191, 106, "x")   # the two halves of the top corner
+    add(211, 104, "y")
+    add(205, 105, "2α+β")   # pointing along the middle line: the whole top angle, a wider arc
+    assert page.locator(".mx-board-anglein").count() == 0
+    # a narrow half's words sit right by its arc (radius 30), not far down between the lines; the whole angle's arc
+    # goes around them
+    x_words = (200 + 45 * -0.07, 80 + 45 * 1.0)
+    assert max(alpha_near(page, x_words[0] + dx, x_words[1] + dy) for dx in (-4, 0, 4) for dy in (-4, 0, 4)) > 0
+    add(250, 306, "60")   # where two lines cross
+    # it all moves as one: the line from the base and the crossing line come with the triangle, their angles too
+    page.locator(".mx-board [data-tool=move]").click()
+    drag(page, (150, 438), (150, 538))
+    assert alpha_near(page, foot - 30, 535) > 0 and alpha_near(page, foot - 30, 435) == 0
+    assert alpha_near(page, 300, 400) > 0   # the crossing line, 100 lower
+    assert errors == []
+
+
+def test_a_right_angle_is_marked_with_a_square(browser, server):
+    page, errors = open_skill(browser, server, 1440, 900)
+    board_on(page)
+    page.locator(".mx-board [data-tool=line]").click()
+    drag(page, (100, 400), (340, 400))
+    drag(page, (102, 398), (100, 160))
+    drag(page, (100, 162), (338, 398))
+    page.locator(".mx-board [data-tool=angle]").click()
+    box = page.locator(".mx-board canvas").bounding_box()
+    page.mouse.click(box["x"] + 112, box["y"] + 388)
+    page.locator(".mx-board-arcs [data-arcs='right']").click()
+    page.locator(".mx-board-anglein").press("Enter")
+    # a square of side 14 in the corner: its far corner at (114, 386), and no arc at radius 30
+    assert alpha_near(page, 114, 386) > 0 and alpha_near(page, 107, 386) > 0 and alpha_near(page, 114, 393) > 0
+    assert alpha_near(page, 100 + 30 * 0.707, 400 - 30 * 0.707) == 0
+    page.mouse.click(box["x"] + 112, box["y"] + 388)   # the square opens it again, as an arc does
+    playwright.expect(page.locator(".mx-board-arcs [data-arcs='right']")).to_have_attribute("aria-pressed", "true")
+    page.locator(".mx-board-arcs [data-arcs='1']").click()
+    page.locator(".mx-board-anglein").press("Enter")
+    assert alpha_near(page, 114, 386) == 0 and alpha_near(page, 100 + 30 * 0.707, 400 - 30 * 0.707) > 0
+    assert errors == []

tests/test_class_report.py

@@ -5,6 +5,7 @@ import urllib.parse
 import httpx
 
 from app.answer_scans import ScanError
+from app.auth import AuthUnavailable
 from app.main import create_app
 
 TEACHER, STUDENT, NEWBIE, OUTSIDER = "t-id", "s-id", "n-id", "o-id"
@@ -17,9 +18,12 @@ class ReportAuth:
 
     def __init__(self):
         self.row = {"id": 3, "name": "ט׳1", "lessons": [], "teachers": ["teacher@x.test"],
-                    "emails": ["newbie@x.test", "student@x.test", "teacher@x.test", "ghost@x.test"]}
+                    "emails": ["newbie@x.test", "student@x.test", "teacher@x.test", "ghost@x.test"],
+                    "nicknames": {"newbie@x.test": "נועה ל."}}
         self.saved = []
         self.progress = {STUDENT: {"done": {"t1": "2026-11-01"}, "updated": 5, "comets": ["c1"],
+                                   "seen": {"t1": "2026-11-01T10:00:00Z"}, "tries": {"t1": 4, "t2": 1}, "secret_extra": 1,
+                                   "examples": {"t1": {"n": 3, "last": "2026-11-02T10:00:00Z"}},
                                    "slips": [{"at": "2026-11-01T10:00:00Z", "id": "t1", "q": 0, "m": "sign"}],
                                    "quizzes": [{"at": "2026-11-02", "n": 12, "right": 9, "ms": 600000, "units": ["t"],
                                                 "weak": ["t1"]}],
@@ -36,16 +40,18 @@ class ReportAuth:
     def access_for(self, _id, **kwargs):
         return None
 
-    def user_ids(self, emails):
-        return {e: i for i, e in EMAILS.items() if e in emails and i != NEWBIE} | (
-            {"newbie@x.test": NEWBIE} if "newbie@x.test" in emails else {})
+    NAMES = {STUDENT: "Sam Student"}   # Google names; the others have none
+
+    def user_accounts(self, emails):
+        return {e: {"id": i, "name": self.NAMES.get(i, "")} for i, e in EMAILS.items() if e in emails}
 
     def save_class(self, class_id, name, emails, nicknames, lessons, *, teachers=None):
         self.saved.append({"emails": emails, "teachers": teachers})
 
     def _admin(self, path, method="GET", body=None, prefer=""):
         table, _, query = path.partition("?")
-        assert table == "/rest/v1/math_progress"
+        if table != "/rest/v1/math_progress":
+            raise AuthUnavailable("supabase answered 404: no other tables here")   # e.g. the assignments table: not set up
         ids = dict(urllib.parse.parse_qsl(query))["user_id"].removeprefix("in.(").removesuffix(")").split(",")
         return [{"user_id": i, "data": self.progress[i], "updated_at": "2026-11-03T00:00:00Z"}
                 for i in ids if i in self.progress]
@@ -64,6 +70,12 @@ class Sittings:
             raise ScanError(503, "quiz_sittings_unavailable")
         return [s for s in self.sittings if s["user_id"] in data["users"]]
 
+    def review(self, user_id, action, **data):   # the students' open requests to look again
+        assert action == "requests"
+        if self.fail:
+            raise ScanError(503, "review_unavailable")
+        return [r for r in getattr(self, "requests", []) if r["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}
@@ -91,13 +103,15 @@ 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, "quiz_sittings": []}
+                                                "saved_at": None, "quiz_sittings": [], "name": None, "review_requests": []}
             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", "timeUp": None, "sid": None}], "going": False}}
-            assert "comets" not in p
+            assert p["seen"] == {"t1": "2026-11-01T10:00:00Z"} and p["tries"] == {"t1": 4, "t2": 1}
+            assert p["examples"] == {"t1": {"n": 3, "last": "2026-11-02T10:00:00Z"}}   # the worked examples the student opened
+            assert "comets" not in p and "secret_extra" not in p
             assert (await c.get("/api/classes/99/report")).status_code == 404
             me = (await c.get("/api/me")).json()
             assert me["classes"][0]["teacher"] is True
@@ -108,6 +122,32 @@ def test_teacher_sees_the_other_students():
     asyncio.run(check())
 
 
+def test_students_are_named_by_nickname_then_google_name_then_nothing():
+    app = create_app(auth=ReportAuth())
+    app.state.answers = Sittings()
+
+    async def check():
+        async with client(app, TEACHER) as c:
+            students = {s["email"]: s for s in (await c.get("/api/classes/3/report")).json()["students"]}
+            assert students["newbie@x.test"]["name"] == "נועה ל."      # the class's nickname
+            assert students["student@x.test"]["name"] == "Sam Student"  # else the Google name
+            assert students["ghost@x.test"]["name"] is None             # else the page uses the email's start
+    asyncio.run(check())
+
+
+def test_google_names_come_from_the_admin_user_list():
+    from app.auth import SupabaseAuth
+    auth = SupabaseAuth("https://x.invalid", "key", secret="secret")
+    users = [{"id": "u1", "email": "A@x.test", "user_metadata": {"full_name": " Noa   Levi "}},
+             {"id": "u2", "email": "b@x.test", "user_metadata": {"name": "Ben"}},
+             {"id": "u3", "email": "c@x.test"}, {"id": "u4", "email": "other@x.test"}]
+    auth._admin = lambda path, *a, **k: {"users": users}
+    got = auth.user_accounts(["a@x.test", "B@x.test", "c@x.test", "nobody@x.test"])
+    assert got == {"a@x.test": {"id": "u1", "name": "Noa Levi"}, "b@x.test": {"id": "u2", "name": "Ben"},
+                   "c@x.test": {"id": "u3", "name": ""}}
+    assert auth.user_ids(["a@x.test"]) == {"a@x.test": "u1"}
+
+
 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)
@@ -163,3 +203,49 @@ def test_the_teacher_is_one_of_the_students():
             assert (await c.get("/api/classes/3/report")).status_code == 200
 
     asyncio.run(check())
+
+
+def test_progress_parts_that_are_not_objects_are_dropped():
+    from app.class_report import report_part
+    part = report_part({"seen": "yesterday", "tries": [1, 2], "days": None, "examples": "many", "done": {"a": 1}})
+    assert part["seen"] == {} and part["tries"] == {} and part["days"] == {} and part["examples"] == {} and part["done"] == {"a": 1}
+
+
+def test_the_report_lists_each_students_open_requests_to_look_again():
+    app = create_app(auth=ReportAuth())
+    app.state.answers = answers = Sittings()
+    answers.requests = [
+        {"attempt_id": "a1", "user_id": STUDENT, "message": "כתבתי x=4", "question": "בוחן: שאלה 2", "created_at": "2026-11-04T10:00:00Z"},
+        {"attempt_id": "a2", "user_id": OUTSIDER, "message": "של כיתה אחרת", "question": "q", "created_at": "2026-11-04T10:00:00Z"}]
+
+    async def check():
+        async with client(app, TEACHER) as c:
+            students = {s["email"]: s for s in (await c.get("/api/classes/3/report")).json()["students"]}
+            assert students["student@x.test"]["review_requests"] == [
+                {"attempt_id": "a1", "message": "כתבתי x=4", "question": "בוחן: שאלה 2", "created_at": "2026-11-04T10:00:00Z"}]
+            assert students["newbie@x.test"]["review_requests"] == [] and "של כיתה אחרת" not in str(students)
+        answers.fail = True   # unreadable: the report still opens, without them
+        async with client(app, TEACHER) as c:
+            r = await c.get("/api/classes/3/report")
+            assert r.status_code == 200 and all(s["review_requests"] == [] for s in r.json()["students"])
+    asyncio.run(check())
+
+
+def test_the_report_carries_the_classs_assignments_for_its_teacher():
+    from test_assignments import GOOD, MemoryAssignments
+    store = MemoryAssignments()
+    app = create_app(auth=ReportAuth())
+    app.state.answers, app.state.assignments = Sittings(), store
+    store.add({**GOOD, "class_id": 3, "created_by_email": "teacher@x.test"})
+    store.add({**GOOD, "class_id": 99, "title": "של כיתה אחרת", "created_by_email": "x@x.test"})
+
+    async def check():
+        async with client(app, TEACHER) as c:
+            data = (await c.get("/api/classes/3/report")).json()
+            assert [(a["title"], a["class_id"], a["created_by_email"]) for a in data["assignments"]] == [(GOOD["title"], 3, "teacher@x.test")]
+            assert data["assignments"][0]["items"] == GOOD["items"]
+        store.fail = True
+        async with client(app, TEACHER) as c:   # the table is not there: the report opens, without assignments
+            r = await c.get("/api/classes/3/report")
+            assert r.status_code == 200 and r.json()["assignments"] is None
+    asyncio.run(check())

tests/test_draft_examples.py

@@ -0,0 +1,162 @@
+"""scripts/draft_examples.py: drafting worked examples for a teacher to review, and merging the approved ones.
+The model is a stand-in: nothing here calls the API."""
+import copy
+import importlib.util
+import json
+from pathlib import Path
+from types import SimpleNamespace
+
+import pytest
+
+from app.math_skills import algebra9, problems, skills_without_example
+
+SCRIPT = Path(__file__).resolve().parent.parent / "scripts" / "draft_examples.py"
+spec = importlib.util.spec_from_file_location("draft_examples", SCRIPT)
+script = importlib.util.module_from_spec(spec)
+spec.loader.exec_module(script)
+
+EXAMPLE = {"question": "$(x + 5)(x − 2) = ?$",
+           "steps": [{"do": "כופלים כל איבר בכל איבר: $x² − 2x + 5x − 10$", "why": "כך לא שוכחים אף מכפלה."},
+                     {"do": "מחברים איברים דומים: $−2x + 5x = 3x$", "why": "רק איברים עם אותה חזקה של $x$ מתחברים."}],
+           "answer": "$x² + 3x − 10$"}
+
+
+class FakeClaude:
+    """messages.create answers with `reply` (a dict, or a function of the request's skill name) and keeps the calls."""
+    def __init__(self, reply=EXAMPLE, stop_reason="end_turn", text=None):
+        self.calls, self.reply, self.stop_reason, self.text = [], reply, stop_reason, text
+        self.messages = SimpleNamespace(create=self.create)
+
+    def create(self, **kwargs):
+        self.calls.append(kwargs)
+        skill = json.loads(kwargs["messages"][0]["content"])["skill"]
+        body = self.text if self.text is not None else json.dumps(self.reply(skill) if callable(self.reply) else self.reply)
+        return SimpleNamespace(stop_reason=self.stop_reason, model=kwargs["model"],
+                               content=[SimpleNamespace(type="text", text=body)])
+
+
+def test_a_unit_gets_a_well_formed_draft_for_each_skill_without_an_example():
+    graph = copy.deepcopy(algebra9())
+    graph["skills"][0]["example"] = copy.deepcopy(EXAMPLE)   # t_ext already has one: it is not drafted again
+    client = FakeClaude()
+    review = script.draft_unit(client, "test-model", graph, "t")
+    wanted = [s["id"] for s in graph["skills"] if s["unit"] == "t" and "example" not in s]
+    assert list(review["drafts"]) == wanted and "t_ext" not in review["drafts"] and len(client.calls) == len(wanted)
+    assert all(d["problems"] == [] and d["example"] == EXAMPLE and d["approved"] is False and d["reviewed_by"] == ""
+               for d in review["drafts"].values())
+    assert review["unit"] == "t" and review["model"] == "test-model" and "לא נבדקה" in review["status"]
+
+
+def test_the_request_gives_the_model_the_skill_and_asks_for_the_examples_structure():
+    graph = algebra9()
+    client = FakeClaude()
+    script.draft_unit(client, "test-model", graph, "t", only=["t_ext"])
+    (call,) = client.calls
+    assert call["model"] == "test-model" and call["system"] == script.SYSTEM and call["max_tokens"] == 8000
+    assert call["output_config"]["format"] == {"type": "json_schema", "schema": script.EXAMPLE_SCHEMA}
+    assert call["output_config"]["effort"] == "high"
+    assert not {"thinking", "temperature", "top_p", "top_k", "tool_choice"} & set(call)   # removed or rejected on current models
+    brief = json.loads(call["messages"][0]["content"])
+    skill = next(s for s in graph["skills"] if s["id"] == "t_ext")
+    assert brief["skill"] == skill["name"] and len(brief["practice_questions"]) == len(skill["questions"])
+    first = brief["practice_questions"][0]
+    assert first["right_answer"] == "$x² − 2x − 15$" and first["common_mistakes"][0]["tip"]
+
+
+def test_a_draft_that_breaks_the_rules_says_what_is_wrong():
+    graph = algebra9()
+    skill = next(s for s in graph["skills"] if s["id"] == "t_ext")
+    copied = {**EXAMPLE, "question": skill["questions"][1]["question"]}
+    review = script.draft_unit(FakeClaude(copied), "m", graph, "t", only=["t_ext"])
+    assert review["drafts"]["t_ext"]["problems"] == ["t_ext example: repeats one of the skill's practice questions"]
+    review = script.draft_unit(FakeClaude({**EXAMPLE, "steps": []}), "m", graph, "t", only=["t_ext"])
+    assert review["drafts"]["t_ext"]["problems"] == ["t_ext example: needs at least one step"]
+
+
+@pytest.mark.parametrize("client,expected", [
+    (FakeClaude(stop_reason="refusal"), "stop_reason=refusal"),
+    (FakeClaude(stop_reason="max_tokens"), "stop_reason=max_tokens"),
+    (FakeClaude(text="not json"), "the answer was not JSON")])
+def test_a_skill_the_model_cannot_draft_is_reported_and_the_others_go_on(client, expected):
+    review = script.draft_unit(client, "m", algebra9(), "t", limit=2)
+    drafts = review["drafts"]
+    assert len(drafts) == 2 and all(d["example"] is None and expected in d["problems"][0] for d in drafts.values())
+
+
+def test_the_command_writes_a_review_file_and_never_the_data_file(tmp_path, monkeypatch, capsys):
+    data = script.GRAPH.read_bytes()
+    client = FakeClaude()
+    monkeypatch.setattr(script, "photo_client", lambda key: client)
+    monkeypatch.setattr(script, "math_model", lambda: "test-model")
+    monkeypatch.setenv("ANTHROPIC_API_KEY", "test-key")
+    out = tmp_path / "t.json"
+    assert script.main(["draft", "--unit", "t", "--out", str(out)]) == 0
+    review = json.loads(out.read_text(encoding="utf-8"))
+    assert set(review["drafts"]) == {s["id"] for s in algebra9()["skills"] if s["unit"] == "t"}
+    assert script.GRAPH.read_bytes() == data                      # the data file is for the merge step alone
+    calls = len(client.calls)
+    assert script.main(["draft", "--unit", "t", "--out", str(out)]) == 2   # it may hold a teacher's review
+    assert len(client.calls) == calls and "--force" in capsys.readouterr().err
+    assert script.main(["draft", "--unit", "t", "--out", str(out), "--force", "--limit", "1"]) == 0
+    assert len(json.loads(out.read_text(encoding="utf-8"))["drafts"]) == 1
+
+
+def test_a_dry_run_and_a_missing_key_call_nothing(tmp_path, monkeypatch, capsys):
+    def no_client(key):
+        raise AssertionError("the API must not be called")
+    monkeypatch.setattr(script, "photo_client", no_client)
+    monkeypatch.delenv("ANTHROPIC_API_KEY", raising=False)
+    monkeypatch.delenv("CLAUDE_API_KEY", raising=False)
+    assert script.main(["draft", "--unit", "t", "--dry-run"]) == 0
+    assert "dry run: 5 requests" in capsys.readouterr().out
+    assert script.main(["draft", "--unit", "t", "--out", str(tmp_path / "x.json")]) == 2
+    assert script.main(["draft", "--unit", "nope"]) == 2
+    assert not (tmp_path / "x.json").exists()
+
+
+# ---- merging what a teacher approved
+def review_with(**entries):
+    return {"drafts": {sid: {"approved": False, "reviewed_by": "", "example": copy.deepcopy(EXAMPLE), "problems": [], **entry}
+                       for sid, entry in entries.items()}}
+
+
+def test_only_approved_and_named_and_valid_drafts_are_merged():
+    graph = copy.deepcopy(algebra9())
+    practice = next(s for s in graph["skills"] if s["id"] == "t_simplify")["questions"][0]["question"]
+    review = review_with(
+        t_ext={"approved": True, "reviewed_by": "מורה כהן"},
+        t_simplify={"approved": True, "reviewed_by": "מורה כהן", "example": {**EXAMPLE, "question": practice}},   # copies a question
+        t_ext_eq={"approved": True},                                  # no reviewer's name
+        t_area={},                                                    # not approved
+        nope={"approved": True, "reviewed_by": "x"})
+    merged_graph, merged, skipped = script.merge_approved(review, graph)
+    assert merged == ["t_ext"] and next(s for s in merged_graph["skills"] if s["id"] == "t_ext")["example"] == EXAMPLE
+    reasons = dict(line.split(": ", 1) for line in skipped)
+    assert "repeats one of the skill's practice questions" in reasons["t_simplify"]
+    assert "reviewer's name" in reasons["t_ext_eq"] and reasons["t_area"] == "not approved" and reasons["nope"] == "no such skill"
+    assert problems(merged_graph) == []
+
+
+def test_an_example_already_in_the_data_is_not_overwritten():
+    graph = copy.deepcopy(algebra9())
+    graph["skills"][0]["example"] = {**EXAMPLE, "answer": "קיים"}
+    _, merged, skipped = script.merge_approved(review_with(t_ext={"approved": True, "reviewed_by": "מורה"}), graph)
+    assert merged == [] and skipped == ["t_ext: already has an example"]
+
+
+def test_the_merge_command_changes_only_the_approved_skills_in_the_data_file(tmp_path, monkeypatch, capsys):
+    data = tmp_path / "math_algebra9.json"
+    original = script.GRAPH.read_text(encoding="utf-8")
+    data.write_text(original, encoding="utf-8")
+    monkeypatch.setattr(script, "GRAPH", data)
+    review = tmp_path / "t.json"
+    review.write_text(json.dumps(review_with(t_ext={"approved": True, "reviewed_by": "מורה כהן"}, t_area={})), encoding="utf-8")
+    assert script.main(["merge", str(review)]) == 0
+    after = json.loads(data.read_text(encoding="utf-8"))
+    skill = next(s for s in after["skills"] if s["id"] == "t_ext")
+    assert skill["example"] == EXAMPLE and problems(after) == []
+    assert "t_area" in skills_without_example(after) and "t_ext" not in skills_without_example(after)
+    skill.pop("example")   # nothing else moved: the file is the old one plus that example, in the same format
+    assert json.dumps(after, ensure_ascii=False, indent=1) + "\n" == original
+    assert script.main(["merge", str(review)]) == 1                # a second time there is nothing to add
+    assert "already has an example" in capsys.readouterr().out

tests/test_math_skills.py

@@ -212,3 +212,58 @@ def test_unit_t_answers_are_right_and_no_wrong_choice_is_equivalent():
                 assert same(c) == bool(c.get("correct")), (skill["id"], q["question"], c["text"])
             checked += 1
     assert checked >= 90
+
+
+# ---- worked examples
+EXAMPLE = {"question": "$(x + 5)(x − 2) = ?$",
+           "steps": [{"do": "כופלים כל איבר בסוגריים הראשונים בכל איבר בשניים: $x·x + x·(−2) + 5·x + 5·(−2)$",
+                      "why": "כך לא שוכחים אף מכפלה."},
+                     {"do": "מחברים את האיברים הדומים: $−2x + 5x = 3x$", "why": "אותו חזקה של $x$ אפשר לחבר."}],
+           "answer": "$x² + 3x − 10$"}
+
+
+def with_example(example):
+    graph = copy.deepcopy(algebra9())
+    graph["skills"][0]["example"] = example
+    return graph
+
+
+def test_a_well_formed_worked_example_loads_and_reaches_the_page():
+    graph = with_example(copy.deepcopy(EXAMPLE))
+    assert problems(graph) == []
+
+
+def test_the_skills_api_sends_a_skills_example(monkeypatch):
+    graph = with_example(copy.deepcopy(EXAMPLE))
+    monkeypatch.setattr("app.math_skills.algebra9", lambda: graph)
+    sent = practice_graph(False)
+    assert sent["skills"][0]["example"] == EXAMPLE and "example" not in sent["skills"][1]
+
+
+def test_a_broken_worked_example_is_named():
+    skill_id = algebra9()["skills"][0]["id"]
+    broken = lambda **changes: problems(with_example({**copy.deepcopy(EXAMPLE), **changes}))
+    assert f"{skill_id} example: needs at least one step" in broken(steps=[])
+    assert f"{skill_id} example: needs at least one step" in broken(steps="x")
+    assert any("step 2: needs what to do" in item for item in broken(steps=[EXAMPLE["steps"][0], {"do": "מחברים", "why": " "}]))
+    assert any("step 1: needs what to do" in item for item in broken(steps=["not an object"]))
+    assert f"{skill_id} example: an answer is required" in broken(answer="")
+    assert f"{skill_id} example: question text is required" in broken(question=" ")
+    assert problems(with_example("text")) == [f"{skill_id} example: must be an object"]
+
+
+def test_an_example_may_not_be_one_of_the_skills_practice_questions():
+    skill = algebra9()["skills"][0]
+    practice = skill["questions"][2]["question"]
+    spaced = "  " + practice.replace(" ", "   ") + "\n"   # the same question, spaced differently
+    for copied in (practice, spaced):
+        found = problems(with_example({**copy.deepcopy(EXAMPLE), "question": copied}))
+        assert f"{skill['id']} example: repeats one of the skill's practice questions" in found
+
+
+def test_the_skills_still_missing_a_worked_example_are_listed():
+    from app.math_skills import skills_without_example
+    graph = with_example(copy.deepcopy(EXAMPLE))
+    missing = skills_without_example(graph)
+    assert graph["skills"][0]["id"] not in missing and graph["skills"][1]["id"] in missing
+    assert set(missing) <= {s["id"] for s in graph["skills"]}

tests/test_phone_browser.py

@@ -201,6 +201,678 @@ def test_class_teacher_report(phone_server):
             browser.close()
 
 
+def open_report(p, server, students, now=None, lessons=("t",), me=None, routes=None, assignments=None):
+    """The class teacher's report for class 4 (lessons: unit t) with these students; returns (browser, page, sheet)."""
+    from datetime import datetime
+    row = {"id": 4, "name": "ט׳2", "lessons": list(lessons), "teacher": True, "exams": []}
+    report = {"class": {"id": 4, "name": "ט׳2", "lessons": list(lessons)}, "students": students, "assignments": assignments}
+    browser = p.chromium.launch()
+    page = browser.new_page()
+    page.clock.set_fixed_time(now or datetime(2026, 11, 4, 12))   # a Wednesday: this week began on Sunday 1 November
+    page.route("https://cdn.jsdelivr.net/**", lambda route: route.abort())
+    page.add_init_script('''window.supabase={createClient:()=>({auth:{
+        getSession:async()=>({data:{session:{access_token:"test",user:{id:"test"}}}}),
+        onAuthStateChange:()=>{},signOut:async()=>{}
+    }})};''')
+
+    def index(route):
+        response = route.fetch()
+        route.fulfill(response=response, body=response.text().replace('supabaseUrl:""', 'supabaseUrl:"https://auth.invalid"'))
+
+    page.route(server + "/", index)
+    page.route("**/api/me", lambda route: route.fulfill(json={
+        "email": "teacher@example.com", "user_id": "test", "answer_scans": False,
+        "permissions": ["path.use"], "classes": [row], **(me or {})}))
+    page.route("**/api/math/progress", lambda route: route.fulfill(json={"progress": {}}))
+    page.route("**/api/classes/4/report", lambda route: route.fulfill(json=report))
+    if routes:
+        routes(page)
+    page.goto(server)
+    page.locator('[data-act="class-report"]').click()
+    return browser, page, page.locator(".mx-report-sheet")
+
+
+def pupil(email, days=None, slips=(), signed_in=True, progress=True, **extra):
+    base = {"done": {}, "gold": {}, "days": days or {}, "missed": {}, "slips": list(slips), "updated": 1, "quizzes": [], "uq": {}}
+    return {"email": email, "signed_in": signed_in, "saved_at": None, "quiz_sittings": [],
+            "progress": {**base, **extra} if progress else None}
+
+
+def test_a_students_card_lists_the_skills_where_they_opened_the_worked_example(phone_server):
+    students = [pupil("dana@example.com", {"2026-11-03": 5}, examples={
+                    "t_ext": {"n": 3, "last": "2026-11-02T10:00:00Z"},       # this week
+                    "t_simplify": {"n": 1, "last": "2026-10-25T10:00:00Z"},   # within two weeks
+                    "t_area": {"n": 4, "last": "2026-10-01T10:00:00Z"},       # too long ago
+                    "g_pyth": {"n": 2, "last": "2026-11-03T10:00:00Z"}}),     # not a skill of this class
+                pupil("omer@example.com", {"2026-11-03": 5})]
+    with playwright.sync_playwright() as p:
+        browser, page, sheet = open_report(p, phone_server, students)
+        try:
+            dana = sheet.locator("#rs-0")
+            dana.locator("summary").click()
+            helped = dana.locator("section", has_text="דוגמאות פתורות")
+            playwright.expect(helped.locator("li")).to_have_count(2)
+            playwright.expect(helped.locator("li").nth(0)).to_contain_text("3 פעמים")        # the newest first
+            playwright.expect(helped.locator("li").nth(1)).to_contain_text("פעם אחת")
+            playwright.expect(helped.locator("h5")).to_contain_text("נתוני תרגול מהמכשיר")
+            omer = sheet.locator("#rs-1")
+            omer.locator("summary").click()
+            assert omer.locator("section", has_text="דוגמאות פתורות").count() == 0
+        finally:
+            browser.close()
+
+
+def test_the_report_opens_with_the_students_who_need_attention(phone_server):
+    stuck = [{"at": f"2026-11-0{d}T09:00:00Z", "id": "t_ext", "q": 0, "m": "ext_partial"} for d in (1, 2, 3)]
+    students = [pupil("ben@example.com", {"2026-11-03": 5, "2026-10-27": 7}),
+                pupil("dana@example.com", {"2026-10-27": 6}),
+                pupil("eli@example.com", {"2026-11-03": 5}, slips=stuck),
+                pupil("noa@example.com", progress=False),
+                pupil("omer@example.com", signed_in=False, progress=False)]
+    with playwright.sync_playwright() as p:
+        browser, page, sheet = open_report(p, phone_server, students)
+        try:
+            attn = sheet.locator(".mx-report-attn")
+            playwright.expect(attn.locator("h4")).to_have_text("דורשים תשומת לב")
+            items = attn.locator("li")
+            playwright.expect(items).to_have_count(3)   # ben is fine; omer has not signed in yet
+            playwright.expect(items.nth(0)).to_contain_text("dana")
+            playwright.expect(items.nth(0)).to_contain_text("לא תרגל 8 ימים")
+            playwright.expect(items.nth(1)).to_contain_text("eli")
+            playwright.expect(items.nth(1)).to_contain_text("תקוע במיומנות")
+            playwright.expect(items.nth(2)).to_contain_text("noa")
+            playwright.expect(items.nth(2)).to_contain_text("עוד לא התחיל לתרגל")
+            assert "ben" not in attn.inner_text()
+            # a name in the list opens that student's card
+            eli = sheet.locator("#rs-2")   # the card's id is the student's place in the class list
+            assert eli.get_attribute("open") is None
+            items.nth(1).locator("button").click()
+            assert eli.get_attribute("open") is not None
+            # this week and last week on a card
+            ben = sheet.locator("#rs-0")
+            ben.locator("summary").click()
+            playwright.expect(ben.locator(".mx-report-week")).to_have_text("5 תשובות נכונות השבוע · 7 בשבוע שעבר")
+        finally:
+            browser.close()
+
+
+def test_the_report_says_when_nobody_needs_attention(phone_server):
+    with playwright.sync_playwright() as p:
+        browser, page, sheet = open_report(p, phone_server, [pupil("ben@example.com", {"2026-11-03": 5})])
+        try:
+            playwright.expect(sheet.locator(".mx-report-attn")).to_contain_text("אף תלמיד לא דורש תשומת לב כרגע")
+            playwright.expect(sheet.locator(".mx-report-attn li")).to_have_count(0)
+        finally:
+            browser.close()
+
+
+def test_the_report_grid_shows_every_students_skills_and_where_the_class_is_stuck(phone_server):
+    from app.math_skills import algebra9
+    skills = [x["id"] for x in algebra9()["skills"] if x["unit"] == "t"]
+    first, second = skills[0], skills[1]
+    fresh, old = "2026-10-30T10:00:00Z", "2026-09-01T10:00:00Z"
+    students = [
+        pupil("cy@example.com", {"2026-10-20": 5}, tries={second: 2}),
+        pupil("ana@example.com", {"2026-11-03": 5}, done={first: fresh}, gold={first: fresh}, seen={first: fresh}, tries={first: 6, second: 3}),
+        {**pupil("eve@example.com", progress=False), "name": "נועה ל."},
+        pupil("bo@example.com", {"2026-09-01": 5}, done={first: old}, seen={first: old}, tries={second: 1}),
+        pupil("dov@example.com")]
+    with playwright.sync_playwright() as p:
+        browser, page, sheet = open_report(p, phone_server, students, lessons=[u["id"] for u in algebra9()["units"][:6]])
+        try:
+            sheet.locator("[data-report-tab=grid]").click()
+            sheet.locator("[data-report-sort]").select_option("name")
+            names = sheet.locator("tbody th")
+            playwright.expect(names).to_have_text(["נועה ל.", "ana", "bo", "cy", "dov"])   # by name (Hebrew first); a class name wins over the email
+            sheet.locator("[data-report-unit]").select_option("t")
+            playwright.expect(sheet.locator("thead th")).to_have_count(1 + len(skills))
+            row = lambda who: sheet.locator("tbody tr", has=page.locator(f"th:text-is('{who}')"))
+            cell = lambda who, skill_no: row(who).locator("td").nth(skill_no).locator(".mx-cell")
+            playwright.expect(cell("ana", 0)).to_have_attribute("aria-label", "כוכב זהב")
+            playwright.expect(cell("bo", 0)).to_have_attribute("aria-label", "הושלמה, הכוכב דועך")   # not practised for two weeks
+            playwright.expect(cell("cy", 0)).to_have_attribute("aria-label", "לא התחיל")
+            playwright.expect(cell("ana", 1)).to_have_attribute("aria-label", "מתרגל, עוד לא סיים")
+            playwright.expect(cell("נועה ל.", 1)).to_have_attribute("aria-label", "לא התחיל")
+            # four students have progress: two finished the first skill; three are on the second without finishing it
+            foot = sheet.locator("tfoot tr")
+            playwright.expect(foot.nth(0).locator("td").nth(0)).to_have_text("2/4")
+            playwright.expect(foot.nth(1).locator("td").nth(1)).to_have_text("3")
+            playwright.expect(sheet.locator("thead th.hard")).to_have_count(1)   # only the second skill is a class-wide difficulty
+            assert "hard" in sheet.locator("thead th").nth(2).get_attribute("class")
+            # the unit overview
+            sheet.locator("[data-report-unit]").select_option("overview")
+            playwright.expect(row("ana").locator("td").first).to_have_text(f"1/{len(skills)}")
+            playwright.expect(row("dov").locator("td").first).to_have_text(f"0/{len(skills)}")
+            playwright.expect(row("נועה ל.").locator("td").first).to_have_text("–")
+            # six units are wider than a phone: the table scrolls inside its own box, never the page or the sheet
+            page.set_viewport_size({"width": 375, "height": 700})
+            assert page.evaluate("document.documentElement.scrollWidth <= window.innerWidth")
+            assert sheet.evaluate("el => el.scrollWidth <= el.clientWidth")
+            assert sheet.locator(".mx-grid-wrap").evaluate("el => el.scrollWidth > el.clientWidth")
+        finally:
+            browser.close()
+
+
+def test_the_reports_order_and_view_are_kept_and_names_come_from_the_class(phone_server):
+    students = [pupil("cy@example.com", {"2026-10-31": 5}),   # all practised within the week: nobody has a signal
+                {**pupil("ana@example.com", {"2026-11-03": 5}), "name": "אנה כהן"},
+                pupil("bo@example.com", {"2026-10-29": 5}),
+                pupil("dov@example.com", {"2026-11-02": 5})]
+    with playwright.sync_playwright() as p:
+        browser, page, sheet = open_report(p, phone_server, students)
+        try:
+            order = lambda: sheet.locator(".mx-report-student > summary > b").all_inner_texts()
+            sort = sheet.locator("[data-report-sort]")
+            assert order() == ["cy", "אנה כהן", "bo", "dov"]                    # nobody has a signal: the class's order
+            sort.select_option("name")
+            assert order() == ["אנה כהן", "bo", "cy", "dov"]
+            sort.select_option("activity")
+            assert order() == ["bo", "cy", "dov", "אנה כהן"] and order() != ["cy", "אנה כהן", "bo", "dov"]   # longest ago first
+            sheet.locator("#rs-1 summary").click()
+            playwright.expect(sheet.locator("#rs-1")).to_contain_text("ana@example.com")   # the full email stays in the card
+            sort.select_option("progress")
+            sheet.locator("[data-report-tab=grid]").click()
+            # the choices stay when the report is opened again
+            sheet.locator(".mx-x").click()
+            page.locator('[data-act="class-report"]').click()
+            playwright.expect(sheet.locator("[data-report-sort]")).to_have_value("progress")
+            playwright.expect(sheet.locator("[data-report-tab=grid]")).to_have_attribute("aria-pressed", "true")
+            playwright.expect(sheet.locator(".mx-grid")).to_be_visible()
+        finally:
+            browser.close()
+
+
+def sitting_of(*attempts, unit="t", grade=None):
+    return {"id": "sit-1", "unit_id": unit, "submitted_at": "2026-11-04T09:00:00Z", "grade": grade, "open": 0,
+            "attempts": list(attempts), "questions": [{"points": 25, "earned": 25, "state": "checked"} for _ in attempts]}
+
+
+def answer_of(attempt_id, review=None, request=None):
+    return {"attempt": {"id": attempt_id, "question_id": "quiz:t:1", "snapshot": {"name": "בוחן מסכם: שאלה 2", "question": "פתרו: $x + 1 = 3$"}},
+            "attachment": {"id": "att"}, "student": {"email": "dana@example.com"},
+            "grading": {"state": "completed", "result": {"verdict": "partial", "score": 40, "feedback": "חסר פירוט",
+                                                         "transcription": "x = 2", "solution": "$x = 2$"}},
+            "review": review, "request": request, "effective_score": 40}
+
+
+PNG = bytes.fromhex("89504e470d0a1a0a0000000d49484452000000010000000108060000001f15c4890000000d49444154789c6360000002000001e221bc330000000049454e44ae426082")
+
+
+def test_the_teacher_opens_a_quiz_answer_and_saves_a_score_and_a_comment(phone_server):
+    import json
+    students = [{**pupil("dana@example.com"), "quiz_sittings": [sitting_of("a1", "a2", "a3", "a4", grade=100)]}]
+    puts, state = [], {"review": None}
+
+    def routes(page):
+        def answer(route):
+            route.fulfill(json=answer_of("a2", state["review"], {"id": "r1", "state": "open", "message": "כתבתי x=2", "created_at": "2026-11-04T10:00:00Z"}))
+
+        def save(route):
+            puts.append(json.loads(route.request.post_data))
+            state["review"] = {"id": "v1", "score": puts[-1].get("score"), "comment": puts[-1].get("comment", ""),
+                               "created_at": "2026-11-04T11:00:00Z", "reviewer_email": "t@x"}
+            route.fulfill(json={"review": state["review"], "request": {"id": "r1", "state": "closed", "message": "כתבתי x=2"}})
+
+        page.route("**/api/teacher/answers/a2", lambda route: save(route) if route.request.method == "GET" and False else answer(route))
+        page.route("**/api/teacher/answers/a2/review", save)
+        page.route("**/api/teacher/answers/a2/image", lambda route: route.fulfill(body=PNG, content_type="image/jpeg"))
+
+    with playwright.sync_playwright() as p:
+        browser, page, sheet = open_report(p, phone_server, students, routes=routes)
+        try:
+            sheet.locator("#rs-0 summary").click()
+            sheet.locator("[data-answers]").click()                                   # the answers of the latest sitting
+            sheet = page.locator(".mx-tr-sheet")
+            playwright.expect(sheet.locator("#mxTitle")).to_contain_text("תשובות בבוחן")
+            playwright.expect(sheet.locator("[data-review-answer]")).to_have_count(4)
+            sheet.locator("[data-review-answer]").nth(1).click()
+            playwright.expect(sheet.locator(".mx-tr-request")).to_contain_text("כתבתי x=2")   # the student's request
+            playwright.expect(sheet.locator(".mx-tr-ai")).to_contain_text("40/100")
+            playwright.expect(sheet.locator(".mx-tr-ai")).to_contain_text("חסר פירוט")
+            playwright.expect(sheet.locator(".mx-tr-img")).to_be_visible()
+            form = sheet.locator("[data-review-form]")
+            form.locator("[name=score]").fill("150")                                  # out of range: the page's own limit
+            assert form.locator("[name=score]").evaluate("el => el.validity.rangeOverflow")
+            form.locator("[name=score]").fill("90")
+            form.locator("[name=comment]").fill("הדרך נכונה, טעות חישוב")
+            form.locator("[type=submit]").click()
+            playwright.expect(form.locator("[role=status]")).to_contain_text("נשמר")
+            assert puts == [{"score": 90, "comment": "הדרך נכונה, טעות חישוב"}]
+            playwright.expect(sheet.locator("section", has_text="הבדיקה שלכם")).to_contain_text("90/100")
+            playwright.expect(sheet.locator(".mx-tr-request")).to_have_count(0)   # answered: the request is closed
+            sheet.locator("[data-review-back]").click()                               # back to the sitting's answers
+            playwright.expect(sheet.locator("#mxTitle")).to_contain_text("תשובות בבוחן")
+            sheet.locator("[data-review-back]").click()                               # and to the report
+            playwright.expect(page.locator(".mx-report-sheet #mxTitle")).to_contain_text("הכיתה שלי")
+        finally:
+            browser.close()
+
+
+def test_a_comment_alone_is_saved_without_a_score_and_a_teacher_without_access_is_told(phone_server):
+    import json
+    students = [{**pupil("dana@example.com"), "quiz_sittings": [sitting_of("a1", "a2", "a3", "a4", grade=100)]}]
+    puts = []
+
+    def routes(page):
+        page.route("**/api/teacher/answers/a1", lambda route: route.fulfill(json=answer_of("a1")))
+        page.route("**/api/teacher/answers/a1/image", lambda route: route.fulfill(body=PNG, content_type="image/jpeg"))
+        page.route("**/api/teacher/answers/a1/review", lambda route: (puts.append(json.loads(route.request.post_data)),
+                   route.fulfill(json={"review": {"score": None, "comment": "יפה", "created_at": "2026-11-04T11:00:00Z"}, "request": None}))[1])
+        page.route("**/api/teacher/answers/a3", lambda route: route.fulfill(status=403, json={"detail": "forbidden"}))
+        page.route("**/api/teacher/answers/a3/image", lambda route: route.fulfill(status=403, json={"detail": "forbidden"}))
+
+    with playwright.sync_playwright() as p:
+        browser, page, sheet = open_report(p, phone_server, students, routes=routes)
+        try:
+            sheet.locator("#rs-0 summary").click()
+            sheet.locator("[data-answers]").click()
+            sheet = page.locator(".mx-tr-sheet")
+            sheet.locator("[data-review-answer]").nth(2).click()
+            playwright.expect(sheet.locator(".mx-manage-state")).to_have_text("אין לכם הרשאה לתשובה הזו.")
+            sheet.locator("[data-review-back]").click()
+            sheet.locator("[data-review-answer]").nth(0).click()
+            form = sheet.locator("[data-review-form]")
+            form.locator("[name=comment]").fill("יפה")
+            form.locator("[type=submit]").click()
+            playwright.expect(form.locator("[role=status]")).to_contain_text("נשמר")
+            assert puts == [{"comment": "יפה"}]                                       # no score key: the AI's score stays
+        finally:
+            browser.close()
+
+
+def test_a_handled_request_in_the_queue_opens_the_answer(phone_server):
+    rows = [{"id": "q1", "state": "done", "kind": "grading", "email": "dana@example.com", "attempt_id": "a2", "label": "בוחן: שאלה 2",
+             "question": "פתרו", "created_at": "2026-11-04T08:00:00Z", "result": {"verdict": "partial", "score": 40}},
+            {"id": "q2", "state": "done", "kind": "photo", "email": "dana@example.com", "attempt_id": None, "label": "תרגיל",
+             "created_at": "2026-11-04T08:00:00Z", "result": {"readable": True, "answer": "3"}}]
+
+    def routes(page):
+        page.route("**/api/ai-queue", lambda route: route.fulfill(json={"requests": rows, "all": False}))
+        page.route("**/api/teacher/answers/a2", lambda route: route.fulfill(json=answer_of("a2")))
+        page.route("**/api/teacher/answers/a2/image", lambda route: route.fulfill(body=PNG, content_type="image/jpeg"))
+
+    with playwright.sync_playwright() as p:
+        browser, page, sheet = open_report(p, phone_server, [pupil("dana@example.com")], me={"ai_review": True}, routes=routes)
+        try:
+            sheet.locator(".mx-x").click()
+            page.locator('[data-act="ai-queue"]').first.click()
+            queue = page.locator(".mx-aq-sheet")
+            playwright.expect(queue.locator("[data-review-answer]")).to_have_count(1)   # only an answer, not a photographed problem
+            queue.locator("[data-review-answer]").click()
+            playwright.expect(page.locator(".mx-tr-sheet .mx-tr-ai")).to_contain_text("40/100")
+            page.locator("[data-review-back]").click()
+            playwright.expect(page.locator(".mx-aq-sheet")).to_be_visible()
+        finally:
+            browser.close()
+
+
+def test_requests_to_look_again_have_their_own_tab_and_count_in_the_queue_button(phone_server):
+    asking = [{"id": "r1", "attempt_id": "a2", "student": "dana@example.com", "message": "כתבתי x=2", "question": "בוחן: שאלה 2",
+               "created_at": "2026-11-04T10:00:00Z"}]
+    waiting = [{"id": "q1", "state": "pending", "kind": "grading", "email": "omer@example.com", "attempt_id": "a9", "label": "תרגיל",
+                "question": "פתרו", "created_at": "2026-11-04T08:00:00Z"}]
+    students = [{**pupil("dana@example.com"), "review_requests": [
+        {"attempt_id": "a2", "message": "כתבתי x=2", "question": "בוחן: שאלה 2", "created_at": "2026-11-04T10:00:00Z"}]}]
+
+    def routes(page):
+        page.route("**/api/ai-queue", lambda route: route.fulfill(json={"requests": waiting, "all": False}))
+        page.route("**/api/ai-queue/q1/image", lambda route: route.fulfill(body=PNG, content_type="image/jpeg"))
+        page.route("**/api/teacher/review-requests", lambda route: route.fulfill(json={"requests": asking}))
+        page.route("**/api/teacher/answers/a2", lambda route: route.fulfill(json=answer_of(
+            "a2", None, {"id": "r1", "state": "open", "message": "כתבתי x=2", "created_at": "2026-11-04T10:00:00Z"})))
+        page.route("**/api/teacher/answers/a2/image", lambda route: route.fulfill(body=PNG, content_type="image/jpeg"))
+
+    with playwright.sync_playwright() as p:
+        browser, page, sheet = open_report(p, phone_server, students, me={"ai_review": True}, routes=routes)
+        try:
+            # the report names the student who asked, and opens the answer; back leads to the report
+            playwright.expect(sheet.locator("#rs-0 summary")).to_contain_text("ביקש בדיקה חוזרת")
+            sheet.locator("#rs-0 summary").click()
+            sheet.locator("#rs-0 [data-review-answer]").click()
+            playwright.expect(page.locator(".mx-tr-request")).to_contain_text("כתבתי x=2")
+            page.locator("[data-review-back]").click()
+            playwright.expect(page.locator(".mx-report-sheet #mxTitle")).to_contain_text("הכיתה שלי")
+            page.locator(".mx-report-sheet .mx-x").click()
+            # one waiting request and one student asking to look again: the button says 2
+            button = page.locator('[data-act="ai-queue"]').first
+            playwright.expect(button).to_contain_text("2")
+            button.click()
+            queue = page.locator(".mx-aq-sheet")
+            playwright.expect(queue.locator("[data-aq-tab=queue]")).to_have_attribute("aria-pressed", "true")
+            playwright.expect(queue.locator(".mx-aq-card")).to_have_count(1)           # the waiting request
+            queue.locator("[data-aq-tab=requests]").click()
+            playwright.expect(queue.locator("[data-aq-tab=requests]")).to_contain_text("1")
+            card = queue.locator(".mx-aq-card")
+            playwright.expect(card).to_have_count(1)
+            playwright.expect(card).to_contain_text("dana")
+            playwright.expect(card).to_contain_text("כתבתי x=2")
+            card.locator("[data-review-answer]").click()
+            playwright.expect(page.locator(".mx-tr-sheet .mx-tr-ai")).to_contain_text("40/100")
+            page.locator("[data-review-back]").click()
+            playwright.expect(page.locator(".mx-aq-sheet [data-aq-tab=requests]")).to_have_attribute("aria-pressed", "true")   # the tab is kept
+        finally:
+            browser.close()
+
+
+def open_student_app(p, server, assignments, sittings=(), progress=None, now=None):
+    """A student of class 4 (units t and k) on the path, with these assignments from the server; returns (browser, page)."""
+    from datetime import datetime
+    row = {"id": 4, "name": "ט׳2", "lessons": ["t", "k"], "teacher": False, "exams": []}
+    browser = p.chromium.launch()
+    page = browser.new_page()
+    page.clock.set_fixed_time(now or datetime(2026, 11, 4, 12))
+    page.route("https://cdn.jsdelivr.net/**", lambda route: route.abort())
+    page.add_init_script('''window.supabase={createClient:()=>({auth:{
+        getSession:async()=>({data:{session:{access_token:"test",user:{id:"test"}}}}),
+        onAuthStateChange:()=>{},signOut:async()=>{}
+    }})};''')
+
+    def index(route):
+        response = route.fetch()
+        route.fulfill(response=response, body=response.text().replace('supabaseUrl:""', 'supabaseUrl:"https://auth.invalid"'))
+
+    page.route(server + "/", index)
+    page.route("**/api/me", lambda route: route.fulfill(json={
+        "email": "student@example.com", "user_id": "test", "answer_scans": False, "permissions": ["path.use"], "classes": [row]}))
+    page.route("**/api/math/progress", lambda route: route.fulfill(json={"progress": progress or {}}))
+    page.route("**/api/math/assignments", lambda route: route.fulfill(json={
+        "assignments": assignments, "sittings": list(sittings), "today": "2026-11-04"}))
+    page.goto(server)
+    page.locator('.mx-nav [data-view="path"]').click()
+    return browser, page
+
+
+def given(title, due, items, id=None, created="2026-11-01T10:00:00Z"):
+    return {"id": id or title, "class_id": 4, "class_name": "ט׳2", "title": title, "note": "", "due_on": due,
+            "items": items, "created_at": created, "updated_at": created}
+
+
+SKILL, QUIZ, EXAM = {"kind": "skill", "id": "t_ext"}, {"kind": "unit_quiz", "unit": "k"}, {"kind": "exam", "units": ["k", "t"]}
+
+
+def test_the_home_screen_lists_the_open_assignments_late_ones_and_the_recently_done(phone_server):
+    assignments = [
+        given("חזרה לפני המבחן", "2026-11-12", [SKILL, QUIZ, EXAM], "open"),
+        given("משימה שאיחרה", "2026-11-02", [{"kind": "skill", "id": "t_simplify"}], "late"),
+        given("משימה שהסתיימה", "2026-11-01", [SKILL], "done"),
+        given("משימה ישנה שהסתיימה", "2026-10-01", [SKILL], "old")]
+    progress = {"done": {"t_ext": "2026-09-01T10:00:00Z"}}
+    with playwright.sync_playwright() as p:
+        browser, page = open_student_app(p, phone_server, assignments, progress=progress)
+        try:
+            cards = page.locator(".mx-asgs .mx-asg")
+            playwright.expect(cards).to_have_count(2)                                   # the finished ones are not cards
+            playwright.expect(cards.nth(0)).to_contain_text("משימה שאיחרה")              # the earliest due date first
+            playwright.expect(cards.nth(0)).to_contain_text("באיחור")
+            assert "late" in cards.nth(0).get_attribute("class")
+            open_ = cards.nth(1)
+            playwright.expect(open_).to_contain_text("חזרה לפני המבחן")
+            playwright.expect(open_).to_contain_text("1 מתוך 3 הושלמו")
+            items = open_.locator(".mx-asg-items li")
+            assert [items.nth(i).get_attribute("class") for i in range(3)] == ["done", "", ""]
+            playwright.expect(items.nth(1)).to_contain_text("בוחן מסכם")
+            playwright.expect(items.nth(2)).to_contain_text("מבחן תרגול")
+            playwright.expect(open_.locator("[data-asg-go]")).to_contain_text("להמשיך: בוחן מסכם")   # the next one to do
+            done = page.locator(".mx-asg-done")
+            playwright.expect(done.locator("summary")).to_have_text("הושלמו (1)")
+            done.locator("summary").click()
+            playwright.expect(done).to_contain_text("משימה שהסתיימה")
+            assert "משימה ישנה שהסתיימה" not in page.locator(".mx-asgs").inner_text()
+        finally:
+            browser.close()
+
+
+def test_continue_opens_the_first_item_that_is_not_done(phone_server):
+    first = [given("ראשון", "2026-11-12", [SKILL, QUIZ, EXAM], "a")]
+    with playwright.sync_playwright() as p:
+        browser, page = open_student_app(p, phone_server, first)                         # nothing done: the skill
+        try:
+            playwright.expect(page.locator("[data-asg-go]")).to_contain_text("להתחיל")
+            page.locator("[data-asg-go]").click()
+            playwright.expect(page.locator(".mx-sheet h3").first).to_contain_text("חוק הפילוג המורחב")
+        finally:
+            browser.close()
+    with playwright.sync_playwright() as p:
+        browser, page = open_student_app(p, phone_server, first, progress={"done": {"t_ext": "2026-09-01T10:00:00Z"}})
+        try:                                                                              # the skill done: the unit quiz
+            page.locator("[data-asg-go]").click()
+            playwright.expect(page.locator(".mx-uq-sheet")).to_be_visible()
+        finally:
+            browser.close()
+    sitting = [{"unit_id": "k", "submitted_at": "2026-11-03T09:00:00Z"}]
+    with playwright.sync_playwright() as p:
+        browser, page = open_student_app(p, phone_server, first, sitting, {"done": {"t_ext": "2026-09-01T10:00:00Z"}})
+        try:                                                                              # then the practice exam, with its units chosen
+            playwright.expect(page.locator("[data-asg-go]")).to_contain_text("להמשיך: מבחן תרגול")
+            page.locator("[data-asg-go]").click()
+            units = page.locator(".mx-quiz-sheet [data-quiz-unit]")
+            playwright.expect(page.locator(".mx-quiz-sheet")).to_contain_text("המורה ביקש מבחן תרגול")
+            assert units.count() >= 2 and all(units.nth(i).get_attribute("aria-pressed") == "true" for i in range(units.count()))
+        finally:
+            browser.close()
+
+
+def test_a_finished_assignment_leaves_the_card_and_the_skills_of_open_ones_wear_a_marker(phone_server):
+    assignments = [given("חזרה", "2026-11-12", [SKILL, {"kind": "skill", "id": "t_simplify"}], "a"),
+                   given("עוד אחת", "2026-11-12", [SKILL], "b")]
+    with playwright.sync_playwright() as p:
+        browser, page = open_student_app(p, phone_server, assignments)
+        try:
+            star = page.locator('.mx-star[data-id="t_ext"]')
+            playwright.expect(star.locator(".mx-asg-pin")).to_have_count(1)
+            label = star.get_attribute("aria-label")
+            assert "משימה מהמורה: חזרה, עוד אחת" in label                                  # both assignments name it
+            playwright.expect(page.locator('.mx-star[data-id="t_simplify"] .mx-asg-pin')).to_have_count(1)
+            assert "משימה מהמורה: חזרה" in page.locator('.mx-star[data-id="t_simplify"]').get_attribute("aria-label")
+            assert page.locator('.mx-star[data-id="t_ext_eq"] .mx-asg-pin').count() == 0   # not assigned: no marker
+            assert "משימה" not in page.locator('.mx-star[data-id="t_ext_eq"]').get_attribute("aria-label")
+        finally:
+            browser.close()
+    done = {"done": {"t_ext": "2026-09-01T10:00:00Z", "t_simplify": "2026-09-02T10:00:00Z"}}
+    with playwright.sync_playwright() as p:
+        browser, page = open_student_app(p, phone_server, assignments, progress=done)
+        try:
+            playwright.expect(page.locator(".mx-asgs")).to_contain_text("הושלמו (2)")
+            assert page.locator(".mx-asg-pin").count() == 0 and page.locator(".mx-asg").count() == 0
+        finally:
+            browser.close()
+
+
+def test_the_home_screen_is_quiet_without_assignments(phone_server):
+    with playwright.sync_playwright() as p:
+        browser, page = open_student_app(p, phone_server, [])
+        try:
+            playwright.expect(page.locator(".mx-star").first).to_be_visible()
+            assert page.locator(".mx-asgs").count() == 0 and page.locator(".mx-asg-pin").count() == 0
+        finally:
+            browser.close()
+
+
+def taught(title, due, items, id=None, created="2026-11-01T10:00:00Z"):
+    return {"id": id or title, "class_id": 4, "title": title, "note": "", "due_on": due, "items": items,
+            "created_by_email": "teacher@example.com", "created_at": created, "updated_at": created}
+
+
+ASG_STUDENTS = [
+    # all three items done: the skill long ago, the unit quiz and the practice exam after the assignment was made
+    {**pupil("dana@example.com", {"2026-11-03": 5}, done={"t_ext": "2026-09-01T10:00:00Z"},
+             quizzes=[{"at": "2026-11-03T09:00:00Z", "n": 12, "right": 9, "units": ["k", "t"]}]),
+     "quiz_sittings": [{"id": "s1", "unit_id": "k", "submitted_at": "2026-11-03T09:00:00Z", "grade": 90, "open": 0}]},
+    {**pupil("noa@example.com", {"2026-11-03": 5}, done={"t_ext": "2026-09-01T10:00:00Z"}), "quiz_sittings": []},
+    {**pupil("omer@example.com", {"2026-11-03": 5}), "quiz_sittings": []}]
+
+
+def test_the_assignments_tab_shows_how_many_finished_and_who_did_what(phone_server):
+    assignments = [taught("חזרה לפני המבחן", "2026-11-12", [SKILL, QUIZ, EXAM], "a"),
+                   taught("משימה ישנה", "2026-11-02", [SKILL], "b")]
+    with playwright.sync_playwright() as p:
+        browser, page, sheet = open_report(p, phone_server, ASG_STUDENTS, lessons=["t", "k"], assignments=assignments)
+        try:
+            sheet.locator("[data-report-tab=tasks]").click()
+            cards = sheet.locator(".mx-asg-t")
+            playwright.expect(cards).to_have_count(2)
+            playwright.expect(cards.nth(0)).to_contain_text("חזרה לפני המבחן")             # the latest due date first
+            playwright.expect(cards.nth(0)).to_contain_text("1 מתוך 3 תלמידים סיימו")
+            playwright.expect(cards.nth(1)).to_contain_text("המועד עבר")
+            playwright.expect(cards.nth(1)).to_contain_text("2 מתוך 3 תלמידים סיימו")      # the skill alone: dana and noa
+            first = cards.nth(0)
+            first.locator("summary").click()
+            row = lambda who: first.locator("tbody tr", has=page.locator(f"th:text-is('{who}')")).locator("td")
+            playwright.expect(row("dana")).to_have_text(["✓", "✓", "✓"])
+            playwright.expect(row("noa")).to_have_text(["✓", "–", "–"])
+            playwright.expect(row("omer")).to_have_text(["–", "–", "–"])
+        finally:
+            browser.close()
+
+
+def test_a_student_who_is_late_with_an_assignment_needs_attention(phone_server):
+    assignments = [taught("משימה ישנה", "2026-11-02", [SKILL], "b")]
+    with playwright.sync_playwright() as p:
+        browser, page, sheet = open_report(p, phone_server, ASG_STUDENTS, assignments=assignments)
+        try:
+            attn = sheet.locator(".mx-report-attn li")
+            playwright.expect(attn).to_have_count(1)                                       # omer: dana and noa finished it
+            playwright.expect(attn).to_contain_text("omer")
+            playwright.expect(attn).to_contain_text("משימה באיחור: משימה ישנה")
+        finally:
+            browser.close()
+
+
+def test_the_assignments_tab_says_when_assignments_cannot_be_read(phone_server):
+    with playwright.sync_playwright() as p:
+        browser, page, sheet = open_report(p, phone_server, ASG_STUDENTS, assignments=None)
+        try:
+            sheet.locator("[data-report-tab=tasks]").click()
+            playwright.expect(sheet).to_contain_text("המשימות אינן זמינות כרגע")
+            assert sheet.locator("[data-asg-new]").count() == 0
+        finally:
+            browser.close()
+
+
+def asg_routes(sent, saved):
+    """POST/PUT/DELETE of class 4's assignments, kept in `sent`; `saved(body, id)` makes the answer."""
+    import json
+
+    def handle(route):
+        request = route.request
+        body = json.loads(request.post_data) if request.post_data else None
+        sent.append((request.method, request.url.rsplit("/assignments", 1)[1], body))
+        if request.method == "DELETE":
+            return route.fulfill(json={"ok": True})
+        route.fulfill(status=201 if request.method == "POST" else 200, json=saved(body, request.url.rsplit("/", 1)[1]))
+
+    return lambda page: page.route("**/api/classes/4/assignments**", handle)
+
+
+def test_the_teacher_makes_an_assignment_with_the_form(phone_server):
+    sent = []
+    made = lambda body, _id: {**taught(body["title"], body["due_on"], body["items"], "new"), "note": body["note"]}
+    with playwright.sync_playwright() as p:
+        browser, page, sheet = open_report(p, phone_server, ASG_STUDENTS, lessons=["t", "k"], assignments=[],
+                                           routes=asg_routes(sent, made))
+        try:
+            sheet.locator("[data-report-tab=tasks]").click()
+            playwright.expect(sheet).to_contain_text("עוד לא נתתם משימות")
+            sheet.locator("[data-asg-new]").click()
+            form = sheet.locator("[data-asg-form]")
+            status = form.locator("[role=status]")
+            form.locator("button[type=submit]").click()
+            playwright.expect(status).to_have_text("כתבו כותרת למשימה.")
+            form.locator("[name=title]").fill("חזרה לפני המבחן")
+            form.locator("button[type=submit]").click()
+            playwright.expect(status).to_contain_text("בחרו לפחות פריט אחד")
+            form.locator("[name=note]").fill("בהצלחה")
+            form.locator("[name=due_on]").fill("2026-11-14")
+            form.locator("details", has_text="טכניקה אלגברית 1").first.locator("summary").click()
+            form.locator("[name=skill][value=t_ext]").check()
+            form.locator("[name=skill][value=t_simplify]").check()
+            form.locator("[name=quiz][value=k]").check()
+            form.locator("[name=exam][value=t]").check()
+            form.locator("[name=exam][value=k]").check()
+            form.locator("button[type=submit]").click()
+            playwright.expect(sheet.locator(".mx-asg-t")).to_have_count(1)
+            playwright.expect(sheet.locator(".mx-asg-t")).to_contain_text("חזרה לפני המבחן")
+            playwright.expect(sheet).to_contain_text("המשימה נשמרה")
+            assert sent == [("POST", "", {"title": "חזרה לפני המבחן", "note": "בהצלחה", "due_on": "2026-11-14", "items": [
+                {"kind": "skill", "id": "t_ext"}, {"kind": "skill", "id": "t_simplify"}, {"kind": "unit_quiz", "unit": "k"},
+                {"kind": "exam", "units": ["t", "k"]}]})]
+            assert sheet.locator("[data-asg-form]").count() == 0
+        finally:
+            browser.close()
+
+
+def test_the_teacher_edits_an_assignment_and_a_refusal_is_explained(phone_server):
+    sent = []
+    changed = lambda body, id_: {**taught(body["title"], body["due_on"], body["items"], id_), "note": body["note"]}
+    assignments = [taught("חזרה", "2026-11-12", [SKILL, QUIZ, EXAM], "a")]
+    with playwright.sync_playwright() as p:
+        browser, page, sheet = open_report(p, phone_server, ASG_STUDENTS, lessons=["t", "k"], assignments=assignments,
+                                           routes=asg_routes(sent, changed))
+        try:
+            sheet.locator("[data-report-tab=tasks]").click()
+            sheet.locator("[data-asg-edit=a]").click()
+            form = sheet.locator("[data-asg-form]")
+            playwright.expect(form.locator("[name=title]")).to_have_value("חזרה")
+            playwright.expect(form.locator("[name=due_on]")).to_have_value("2026-11-12")
+            playwright.expect(form.locator("[name=skill][value=t_ext]")).to_be_checked()
+            playwright.expect(form.locator("[name=quiz][value=k]")).to_be_checked()
+            assert form.locator("[name=exam]:checked").count() == 2
+            form.locator("[name=title]").fill("חזרה מורחבת")
+            form.locator("[name=due_on]").fill("2026-11-15")
+            form.locator("button[type=submit]").click()
+            playwright.expect(sheet.locator(".mx-asg-t")).to_contain_text("חזרה מורחבת")
+            assert sent[0][0] == "PUT" and sent[0][1] == "/a" and sent[0][2]["due_on"] == "2026-11-15"
+            assert sent[0][2]["items"] == [SKILL, QUIZ, {"kind": "exam", "units": ["t", "k"]}]   # the form's items, in unit order
+            sheet.locator("[data-asg-edit=a]").click()
+            sheet.locator("[data-asg-cancel]").click()                                    # cancelling changes nothing
+            assert len(sent) == 1 and sheet.locator("[data-asg-form]").count() == 0
+        finally:
+            browser.close()
+    with playwright.sync_playwright() as p:
+        browser, page, sheet = open_report(p, phone_server, ASG_STUDENTS, assignments=[], routes=lambda pg: pg.route(
+            "**/api/classes/4/assignments**", lambda route: route.fulfill(status=403, json={"detail": "x"})))
+        try:
+            sheet.locator("[data-report-tab=tasks]").click()
+            sheet.locator("[data-asg-new]").click()
+            form = sheet.locator("[data-asg-form]")
+            form.locator("[name=title]").fill("x")
+            form.locator("details").first.locator("summary").click()
+            form.locator("[name=skill]").first.check()
+            form.locator("button[type=submit]").click()
+            playwright.expect(form.locator("[role=status]")).to_have_text("רק מורה הכיתה יכול לתת לה משימות.")
+            playwright.expect(form.locator("button[type=submit]")).to_be_enabled()
+        finally:
+            browser.close()
+
+
+def test_deleting_an_assignment_asks_first_and_says_how_many_already_did_part_of_it(phone_server):
+    sent, messages = [], []
+    assignments = [taught("חזרה", "2026-11-12", [SKILL, QUIZ], "a")]
+    with playwright.sync_playwright() as p:
+        browser, page, sheet = open_report(p, phone_server, ASG_STUDENTS, lessons=["t", "k"], assignments=assignments,
+                                           routes=asg_routes(sent, lambda body, id_: body))
+        try:
+            def answer(accept):
+                def on_dialog(dialog):
+                    messages.append(dialog.message)
+                    dialog.accept() if accept else dialog.dismiss()
+                page.once("dialog", on_dialog)
+
+            sheet.locator("[data-report-tab=tasks]").click()
+            answer(False)
+            sheet.locator("[data-asg-del=a]").click()
+            page.wait_for_timeout(200)
+            assert sent == [] and sheet.locator(".mx-asg-t").count() == 1                 # dismissed: nothing is deleted
+            answer(True)
+            sheet.locator("[data-asg-del=a]").click()
+            playwright.expect(sheet.locator(".mx-asg-t")).to_have_count(0)
+            assert sent == [("DELETE", "/a", None)]
+            assert 'למחוק את המשימה "חזרה"' in messages[0] and "2 תלמידים כבר השלימו" in messages[0]   # dana and noa did the skill
+            assert messages[1] == messages[0]
+        finally:
+            browser.close()
+
+
 def test_class_editor_picks_the_teacher_from_the_students(phone_server):
     import json
 

tests/test_progress.py

@@ -107,3 +107,12 @@ def test_merge_keeps_the_work_of_both_devices():
         assert out["quizzes"] == [{"at": "2026-11-01T08:00", "n": 5}] and out["updated"] == 200
     alone = merge({}, phone)   # a device with nothing yet takes the server's copy as it is
     assert alone == merge(phone, {}) and {k: alone[k] for k in phone} == phone
+
+
+@pytest.mark.skipif(not shutil.which("node"), reason="needs node")
+def test_merge_keeps_the_most_worked_example_openings_and_the_latest_time():
+    phone = {"updated": 200, "examples": {"a": {"n": 2, "last": "2026-11-02T10:00:00Z"}}}
+    laptop = {"updated": 100, "examples": {"a": {"n": 3, "last": "2026-11-01T10:00:00Z"}, "b": {"n": 1, "last": "2026-11-01T11:00:00Z"}}}
+    for out in (merge(phone, laptop), merge(laptop, phone)):
+        assert out["examples"] == {"a": {"n": 3, "last": "2026-11-02T10:00:00Z"}, "b": {"n": 1, "last": "2026-11-01T11:00:00Z"}}
+    assert merge({}, phone)["examples"] == phone["examples"]

tests/test_quiz_grades.py

@@ -46,3 +46,29 @@ def test_points_are_rounded_per_question():
 
 def test_a_sitting_of_a_unit_without_a_quiz_has_no_view():
     assert sitting_view(sitting(attempt(100), unit="nope")) is None
+
+
+def test_the_teachers_score_counts_instead_of_the_automatic_one():
+    ai_40_teacher_80 = {**attempt(40, verdict="partial"), "teacher_score": 80}
+    view = sitting_view(sitting(attempt(100), ai_40_teacher_80, attempt(100), attempt(100)))
+    assert view["questions"][1]["earned"] == 20 and view["questions"][1]["state"] == "teacher"
+    assert view["grade"] == 25 + 20 + 25 + 25
+
+
+def test_a_teacher_score_grades_what_the_check_could_not_or_has_not_yet():
+    for unreadable in ({**attempt(None, verdict="unreadable"), "teacher_score": 70},
+                       {**attempt(None, state="grading", verdict=None), "teacher_score": 70},
+                       {**attempt(None, state=None, verdict=None), "teacher_score": 70}):
+        view = sitting_view(sitting(attempt(100), unreadable, attempt(100), attempt(100)))
+        assert view["open"] == 0 and view["questions"][1]["earned"] == 18 and view["grade"] == 25 + 18 + 25 + 25
+
+
+def test_a_teacher_score_of_zero_is_a_score_and_a_comment_alone_changes_nothing():
+    zero = {**attempt(100), "teacher_score": 0}
+    assert question_result(25, zero)["earned"] == 0
+    assert question_result(25, {**attempt(100), "teacher_score": None})["earned"] == 25   # the latest review had no score
+
+
+def test_a_missing_photo_stays_zero_whatever_the_teacher_says():
+    assert question_result(25, {**attempt(photo=False, state=None, verdict=None), "teacher_score": 100}) == \
+        {"points": 25, "earned": 0, "state": "missing"}

tests/test_sky_browser.py

@@ -496,3 +496,251 @@ def test_a_first_mistake_has_no_pattern_note(browser, server):
     playwright.expect(page.locator(".mx-bad")).to_be_visible()
     playwright.expect(page.locator(".mx-pattern-note")).to_have_count(0)
     assert not errors
+
+
+# ---- the class teacher's signals (MathlySky.attention): who needs attention, on Wednesday 4 November 2026
+CLASS = {"skills": {"t_ext": "פילוג מורחב", "g_pyth": "פיתגורס"}, "units": [{"id": "t", "name": "טכניקה אלגברית 1"}]}
+
+
+def attention(page, student, ctx=CLASS):
+    return page.evaluate("([s, c]) => MathlySky.attention(s, c, new Date(2026, 10, 4, 12))", [student, ctx])
+
+
+def kinds(found):
+    return [x["kind"] for x in found]
+
+
+def student(**progress):
+    return {"signed_in": True, "progress": {"done": {}, "days": {}, "slips": [], **progress}, "quiz_sittings": []}
+
+
+def slips(skill, *days_ago):
+    return [{"at": (datetime(2026, 11, 4, 9) - timedelta(days=d)).isoformat() + "Z", "id": skill, "q": 0, "m": "x"}
+            for d in days_ago]
+
+
+def test_a_student_who_stopped_practising_needs_attention(browser, server):
+    page, errors = page_with(browser, server)
+    found = attention(page, student(days={"2026-10-27": 6}))
+    assert [(x["kind"], x["text"]) for x in found] == [("inactive", "לא תרגל 8 ימים")]
+    assert attention(page, student(days={"2026-10-28": 6})) != [] and attention(page, student(days={"2026-10-29": 6})) == []   # 7 days: yes; 6: no
+    assert attention(page, student(days={"2026-11-02": 5})) == []
+    assert attention(page, student(seen={"t_ext": "2026-11-03T10:00:00Z"}, days={"2026-10-01": 9})) == []   # the last practice counts
+    assert not errors
+
+
+def test_a_student_stuck_on_a_skill_is_named_with_it(browser, server):
+    page, errors = page_with(browser, server)
+    found = attention(page, student(days={"2026-11-03": 5}, slips=slips("t_ext", 1, 2, 3)))
+    assert [(x["kind"], x["skills"]) for x in found] == [("stuck", ["t_ext"])] and "פילוג מורחב" in found[0]["text"]
+    assert attention(page, student(days={"2026-11-03": 5}, slips=slips("t_ext", 1, 2))) == []        # two slips are not stuck
+    assert attention(page, student(days={"2026-11-03": 5}, slips=slips("t_ext", 1, 20, 30))) == []   # old ones do not count
+    assert attention(page, student(days={"2026-11-03": 5}, done={"t_ext": "2026-11-04"}, slips=slips("t_ext", 1, 2, 3))) == []
+    assert attention(page, student(days={"2026-11-03": 5}, slips=slips("other", 1, 2, 3))) == []     # not a skill of the class
+    assert not errors
+
+
+def test_a_drop_in_practice_needs_enough_practice_to_drop_from(browser, server):
+    page, errors = page_with(browser, server)
+    week = lambda this, last: {"2026-11-02": this, "2026-10-27": last // 2, "2026-10-29": last - last // 2}
+    assert page.evaluate("p => MathlySky.weekly(p, new Date(2026, 10, 4, 12))", {"days": week(14, 22)}) == {"thisWeek": 14, "lastWeek": 22}
+    found = attention(page, student(days=week(6, 20)))
+    assert kinds(found) == ["drop"] and "6" in found[0]["text"] and "20" in found[0]["text"]
+    assert attention(page, student(days=week(2, 8))) == []      # 8 last week is too little to call a drop
+    assert attention(page, student(days=week(10, 20))) == []    # exactly half is not less than half
+    assert not errors
+
+
+def test_a_low_server_grade_needs_attention_but_the_devices_does_not(browser, server):
+    page, errors = page_with(browser, server)
+    sit = lambda grade, at: {"id": at, "unit_id": "t", "grade": grade, "open": 0 if grade is not None else 1, "submitted_at": at}
+    base = student(days={"2026-11-03": 5})
+    found = attention(page, {**base, "quiz_sittings": [sit(40, "2026-11-03T10:00:00Z")]})
+    assert [(x["kind"], x["unit"]) for x in found] == [("grade", "t")] and "40" in found[0]["text"]
+    assert attention(page, {**base, "quiz_sittings": [sit(40, "2026-10-01T10:00:00Z"), sit(70, "2026-11-03T10:00:00Z")]}) == []   # the latest counts
+    assert attention(page, {**base, "quiz_sittings": [sit(40, "2026-10-01T10:00:00Z"), sit(None, "2026-11-03T10:00:00Z")]}) != []   # an open one is no grade
+    assert attention(page, {**base, "quiz_sittings": None}) == []
+    assert attention(page, {**base, "progress": {**base["progress"], "uq": {"t": {"history": [{"score": 10}]}}}}) == []
+    assert attention(page, {**base, "quiz_sittings": [sit(55, "2026-11-03T10:00:00Z")]}) == []   # 55 is not below 55
+    assert not errors
+
+
+def test_a_student_who_never_started_is_listed_only_once_signed_in(browser, server):
+    page, errors = page_with(browser, server)
+    assert [x["text"] for x in attention(page, {"signed_in": True, "progress": None, "quiz_sittings": []})] == ["עוד לא התחיל לתרגל"]
+    assert attention(page, {"signed_in": False, "progress": None, "quiz_sittings": []}) == []
+    assert not errors
+
+
+# ---- the worked example and the help panel. The page is given an example for every skill, as the data will have.
+HELP_EXAMPLE = {"question": "$(x + 5)(x − 2) = ?$",
+                "steps": [{"do": "כופלים כל איבר בכל איבר: $x² − 2x + 5x − 10$", "why": "כך לא שוכחים אף מכפלה."},
+                          {"do": "מחברים איברים דומים: $−2x + 5x = 3x$", "why": "רק איברים עם אותה חזקה מתחברים."},
+                          {"do": "התוצאה: $x² + 3x − 10$", "why": "סידרנו מהחזקה הגבוהה לנמוכה."}],
+                "answer": "$x² + 3x − 10$"}
+
+
+def page_with_examples(browser, server, progress=None):
+    """Like page_with, with a worked example added to every skill in the skills the server sends."""
+    ctx = browser.new_context(viewport={"width": 390, "height": 844})
+    ctx.add_init_script("Math.random=()=>0.99")
+    ctx.route("https://cdn.jsdelivr.net/**", lambda route: route.abort())
+    ctx.route("https://fonts.googleapis.com/**", lambda route: route.abort())
+    ctx.add_init_script("try{localStorage.setItem('mathly.sound','off')}catch{}")
+    if progress is not None:
+        ctx.add_init_script(f"localStorage.setItem({json.dumps(KEY)},{json.dumps(json.dumps(progress))})")
+
+    def skills(route):
+        graph = route.fetch().json()
+        for skill in graph["skills"]:
+            skill["example"] = HELP_EXAMPLE
+        route.fulfill(json=graph)
+
+    ctx.route("**/api/math/skills", skills)
+    page = ctx.new_page()
+    errors = []
+    page.on("pageerror", lambda e: errors.append(str(e)))
+    page.goto(server)
+    playwright.expect(page.locator(".mx-trail")).to_be_visible()
+    return page, errors
+
+
+def wrong_answer(page):
+    page.locator(".mx-choices button:not([data-right])").first.click()
+    playwright.expect(page.locator(".mx-bad")).to_be_visible()
+
+
+def test_the_worked_example_is_offered_from_the_second_mistake_in_a_round(browser, server):
+    page, errors = page_with_examples(browser, server)
+    skill = page.locator(".mx-star.st-next").get_attribute("data-id")
+    page.locator(".mx-star.st-next").click()
+    wrong_answer(page)
+    assert page.locator("[data-example]").count() == 0                       # the first mistake: only the tip
+    page.locator(".mx-bad button.solid").click()                             # on to the next question
+    asked = page.locator(".mx-q p").first.inner_text()
+    wrong_answer(page)
+    offer = page.locator(".mx-bad [data-example]")
+    playwright.expect(offer).to_have_text("איך פותרים? דוגמה פתורה")
+    # open it: a panel over the question, one step at a time, and the answer only at the end
+    offer.click()
+    help_ = page.locator(".mx-help")
+    playwright.expect(help_.locator(".mx-example")).to_be_visible()
+    playwright.expect(help_.locator(".mx-example-q")).to_contain_text("(x + 5)(x − 2)")
+    steps = help_.locator(".mx-example-steps li")
+    assert [steps.nth(i).is_visible() for i in range(3)] == [True, False, False]
+    assert not help_.locator(".mx-example-answer").is_visible()
+    help_.locator("[data-example-next]").click()
+    assert [steps.nth(i).is_visible() for i in range(3)] == [True, True, False]
+    help_.locator("[data-example-next]").click()
+    playwright.expect(help_.locator("[data-example-next]")).to_have_text("הצגת התשובה")
+    help_.locator("[data-example-next]").click()
+    playwright.expect(help_.locator(".mx-example-answer")).to_be_visible()
+    playwright.expect(help_.locator("[data-example-next]")).to_be_hidden()
+    # closing returns to the same question, with the same feedback
+    help_.locator("button.solid").click()
+    playwright.expect(page.locator(".mx-help-wrap")).to_have_count(0)
+    assert page.locator(".mx-q p").first.inner_text() == asked
+    playwright.expect(page.locator(".mx-bad")).to_be_visible()
+    # a third mistake offers it again; Escape closes the panel before the sheet
+    page.locator(".mx-bad button.solid").click()
+    wrong_answer(page)
+    page.locator(".mx-bad [data-example]").click()
+    playwright.expect(page.locator(".mx-help")).to_be_visible()
+    page.keyboard.press("Escape")
+    playwright.expect(page.locator(".mx-help-wrap")).to_have_count(0)
+    playwright.expect(page.locator(".mx-sheet").first).to_be_visible()
+    assert progress_of(page)["examples"][skill]["n"] == 2                    # both openings are kept
+    assert not errors
+
+
+def test_a_skill_without_an_example_offers_none(browser, server):
+    page, errors = page_with(browser, server)               # the data has no examples yet
+    page.locator(".mx-star.st-next").click()
+    wrong_answer(page)
+    page.locator(".mx-bad button.solid").click()
+    wrong_answer(page)
+    assert page.locator("[data-example]").count() == 0
+    page.locator(".mx-helpbtn").click()                     # the help is there all the same
+    playwright.expect(page.locator(".mx-help")).to_contain_text("לכישור הזה עוד אין דוגמה פתורה")
+    assert "examples" not in progress_of(page) or progress_of(page)["examples"] == {}
+    assert not errors
+
+
+def test_opening_the_example_is_recorded_and_changes_neither_finishing_nor_gold(browser, server):
+    page, errors = page_with_examples(browser, server)
+    nxt = page.locator(".mx-star.st-next").get_attribute("data-id")
+    page.locator(".mx-star.st-next").click()
+    page.locator(".mx-helpbtn").click()                     # the "?" shows the example before any answer
+    playwright.expect(page.locator(".mx-help .mx-example")).to_be_visible()
+    from app.math_skills import algebra9
+    description = next(x["description"] for x in algebra9()["skills"] if x["id"] == nxt)
+    playwright.expect(page.locator(".mx-help")).to_contain_text(description.split("$")[0].strip()[:20])   # and the skill's description
+    page.locator(".mx-help button.solid").click()
+    p = progress_of(page)
+    assert p["examples"][nxt]["n"] == 1 and p["examples"][nxt]["last"] and not p["done"].get(nxt)
+    answer_skill_right(page)                                # clean first-try answers still make it gold
+    playwright.expect(page.locator(".sky-cele h2").first).to_have_text("כוכב זהב!")
+    while page.locator(".sky-cele [data-sky=go]").count():
+        page.locator(".sky-cele [data-sky=go]").first.click()
+    p = progress_of(page)
+    assert p["done"][nxt] and p["gold"][nxt] and p["examples"][nxt]["n"] == 1
+    assert not errors
+
+
+# ---- assignments (MathlySky.assignmentState): created on 1 November 2026 (10:00 UTC), due 12 November, now Wednesday 4 November
+ASSIGNMENT = {"id": "a1", "created_at": "2026-11-01T10:00:00Z", "due_on": "2026-11-12", "title": "חזרה",
+              "items": [{"kind": "skill", "id": "g_pyth"}, {"kind": "unit_quiz", "unit": "g"}, {"kind": "exam", "units": ["g", "t"]}]}
+
+
+def state(page, progress=None, sittings=(), now="2026-11-04T12:00:00", assignment=ASSIGNMENT):
+    return page.evaluate("([a, p, s, n]) => MathlySky.assignmentState(a, p, s, new Date(n))",
+                         [assignment, progress or {}, None if sittings is None else list(sittings), now])
+
+
+def test_a_skill_finished_before_the_assignment_is_already_done_and_on_time(browser, server):
+    page, errors = page_with(browser, server)
+    got = state(page, {"done": {"g_pyth": "2026-09-20T08:00:00Z"}})
+    first = got["items"][0]
+    assert (first["done"], first["late"]) == (True, False) and got["doneCount"] == 1 and got["total"] == 3
+    assert got["next"] == 1 and not got["finished"] and not got["overdue"]        # the next one to do is the unit quiz
+    assert state(page, {})["items"][0]["done"] is False
+    assert not errors
+
+
+def test_a_unit_quiz_counts_only_when_handed_in_after_the_assignment_was_made(browser, server):
+    page, errors = page_with(browser, server)
+    before = [{"unit_id": "g", "submitted_at": "2026-10-30T09:00:00Z"}]
+    after = [{"unit_id": "g", "submitted_at": "2026-11-03T09:00:00Z"}]
+    other = [{"unit_id": "t", "submitted_at": "2026-11-03T09:00:00Z"}]
+    assert state(page, sittings=before)["items"][1]["done"] is False
+    assert state(page, sittings=other)["items"][1]["done"] is False
+    assert state(page, sittings=before + after)["items"][1]["done"] is True
+    assert state(page, sittings=after)["items"][1]["at"] == "2026-11-03T09:00:00Z"
+    unknown = state(page, sittings=None)["items"][1]                              # the server's record could not be read
+    assert (unknown["done"], unknown["known"]) == (False, False)
+    assert not errors
+
+
+def test_a_practice_exam_must_cover_every_unit_of_the_item_and_come_after_the_assignment(browser, server):
+    page, errors = page_with(browser, server)
+    exam = lambda at, *units: {"quizzes": [{"at": at, "n": 12, "right": 9, "units": list(units)}]}
+    assert state(page, exam("2026-11-03T09:00:00Z", "g"))["items"][2]["done"] is False            # missing a unit
+    assert state(page, exam("2026-10-30T09:00:00Z", "g", "t"))["items"][2]["done"] is False       # before the assignment
+    assert state(page, exam("2026-11-03T09:00:00Z", "g", "t"))["items"][2]["done"] is True
+    assert state(page, exam("2026-11-03T09:00:00Z", "t", "g", "k"))["items"][2]["done"] is True   # more units than asked is fine
+    assert not errors
+
+
+def test_late_means_after_the_due_day_in_jerusalem_and_overdue_means_unfinished_after_it(browser, server):
+    page, errors = page_with(browser, server)
+    all_done = lambda skill_at: {"done": {"g_pyth": skill_at}, "quizzes": [{"at": "2026-11-03T09:00:00Z", "units": ["g", "t"]}]}
+    sit = [{"unit_id": "g", "submitted_at": "2026-11-03T09:00:00Z"}]
+    on_time = state(page, all_done("2026-11-12T21:30:00Z"), sit)             # 23:30 on the 12th in Jerusalem (UTC+2)
+    assert on_time["finished"] and not on_time["late"] and not on_time["overdue"]
+    late = state(page, all_done("2026-11-12T22:30:00Z"), sit)                # 00:30 on the 13th
+    assert late["finished"] and late["late"] and late["items"][0]["late"] and not late["items"][1]["late"]
+    assert not state(page, {}, [], now="2026-11-12T20:00:00")["overdue"]      # the evening of the due day: not yet
+    assert state(page, {}, [], now="2026-11-13T09:00:00")["overdue"]           # the day after, unfinished
+    done_late = state(page, all_done("2026-11-02T09:00:00Z"), sit, now="2026-11-20T09:00:00")
+    assert done_late["finished"] and not done_late["overdue"]                  # finished: never overdue
+    assert not errors

tests/test_teacher_review.py

@@ -0,0 +1,336 @@
+"""The class teacher's review of an open answer, and the student's request to look again.
+Answers are kept in real PostgreSQL (scan_support); the AI check is a stand-in."""
+import asyncio
+import uuid
+
+import httpx
+import psycopg
+import pytest
+
+from app.answer_grading import validate_assessment
+from app.answer_scans import ScanError, clean_image
+from app.main import create_app
+from scan_support import OWNER, OTHER, ScanAuth, answer_store, postgres_server
+from test_answer_grading import assessment
+from test_ai_queue import ClassAuth, STRANGER, as_user, mail
+from test_answer_scans import png, request
+
+
+def photographed(store, owner=OWNER, question='geometry'):
+    """An attempt of `owner` with a saved photo; returns its id."""
+    sid = request(store, owner, question=question)['scan']['id']
+    store.action(owner, 'confirm', scan_id=sid)
+    scan = store.action(owner, 'begin', scan_id=sid, key=str(uuid.uuid4()))['scan']
+    key = f"{owner}/{scan['id']}/{scan['lease_id']}/{uuid.uuid4()}.jpg"
+    store.put(key, clean_image(png(), 'image/png'))
+    done = store.action(owner, 'finalize', scan_id=scan['id'], lease_id=scan['lease_id'], object_key=key, byte_size=500)
+    return done['attempt']['id']
+
+
+def test_the_reviews_migration_is_additive_and_service_only(answer_store):
+    with answer_store.connect() as c:
+        assert c.execute("select name from classes").fetchone()[0] == "existing math class"
+        for table in ("math_teacher_reviews", "math_review_requests"):
+            assert c.execute("select relrowsecurity from pg_class where relname=%s", (table,)).fetchone()[0]
+            c.execute("set role authenticated")
+            with pytest.raises(psycopg.errors.InsufficientPrivilege):
+                c.execute(f"select * from {table}")
+            c.execute("reset role")
+        c.execute("set role anon")
+        with pytest.raises(psycopg.errors.InsufficientPrivilege):
+            c.execute("select math_review_action(null,'requests','{}')")
+
+
+def test_a_review_replaces_the_one_before_and_closes_the_students_request(answer_store):
+    store = answer_store
+    aid = photographed(store)
+    assert store.review(OWNER, 'get', attempt_id=aid) == {'review': None, 'request': None}
+    asked = store.review(OWNER, 'request', attempt_id=aid, message='כתבתי x=4')
+    assert asked['request']['state'] == 'open' and asked['request']['message'] == 'כתבתי x=4'
+    assert store.review(OWNER, 'request', attempt_id=aid)['request']['id'] == asked['request']['id']   # one open request
+    with answer_store.connect() as c:   # the database itself keeps a second open request out
+        with pytest.raises(psycopg.errors.UniqueViolation):
+            c.execute("insert into math_review_requests(user_id, attempt_id) select user_id, attempt_id from math_review_requests")
+    first = store.review(OWNER, 'review', attempt_id=aid, reviewer='t@x', score=85, comment='הדרך נכונה')
+    assert first['review']['score'] == 85 and first['review']['reviewer_email'] == 't@x'
+    assert first['request']['state'] == 'closed'
+    second = store.review(OWNER, 'review', attempt_id=aid, reviewer='t@x', score=None, comment='רק הערה')
+    assert second['review']['score'] is None and second['review']['comment'] == 'רק הערה'   # replaces, not merges
+    assert store.review(OWNER, 'owner', attempt_id=aid) == OWNER
+    with answer_store.connect() as c:
+        assert c.execute("select count(*) from math_teacher_reviews").fetchone()[0] == 2   # the first is history
+
+
+def test_only_an_answer_with_a_photo_can_be_reviewed_or_questioned(answer_store):
+    store = answer_store
+    bare = store.action(OWNER, 'resume', question_id='geometry', question_version='v1',
+                        snapshot={'question': 'q', 'type': 'open-ended'})['attempt']['id']
+    for action, data in (('review', {'score': 50, 'reviewer': 't@x'}), ('request', {})):
+        with pytest.raises(ScanError, match='answer_required'):
+            store.review(OWNER, action, attempt_id=bare, **data)
+    with pytest.raises(ScanError) as exc:
+        store.review(OTHER, 'get', attempt_id=photographed(store))   # another student's answer
+    assert exc.value.status == 404
+
+
+def test_a_review_needs_a_score_or_a_comment_and_a_sane_score(answer_store):
+    store = answer_store
+    aid = photographed(store)
+    with pytest.raises(Exception):
+        store.review(OWNER, 'review', attempt_id=aid, reviewer='t@x', score=None, comment='')
+    with pytest.raises(Exception):
+        store.review(OWNER, 'review', attempt_id=aid, reviewer='t@x', score=120, comment='')
+    assert store.review(OWNER, 'get', attempt_id=aid)['review'] is None
+
+
+def test_a_student_has_at_most_five_open_requests(answer_store):
+    store = answer_store
+    ids = [photographed(store, question=f'q{i}') for i in range(6)]
+    for aid in ids[:5]:
+        store.review(OWNER, 'request', attempt_id=aid)
+    with pytest.raises(ScanError) as exc:
+        store.review(OWNER, 'request', attempt_id=ids[5])
+    assert (exc.value.status, exc.value.code) == (429, 'review_limit')
+    store.review(OWNER, 'review', attempt_id=ids[0], reviewer='t@x', score=70, comment='')   # one closes: room again
+    assert store.review(OWNER, 'request', attempt_id=ids[5])['request']['state'] == 'open'
+
+
+def test_unseen_reviews_are_listed_until_the_student_opens_the_answer(answer_store):
+    store = answer_store
+    aid = photographed(store)
+    assert store.review(OWNER, 'unseen') == []
+    store.review(OWNER, 'review', attempt_id=aid, reviewer='t@x', score=60, comment='נסו שוב')
+    unseen = store.review(OWNER, 'unseen')
+    assert [(x['attempt_id'], x['score'], x['comment']) for x in unseen] == [(aid, 60, 'נסו שוב')]
+    assert store.review(OTHER, 'unseen') == []
+    store.review(OWNER, 'seen', attempt_id=aid)
+    assert store.review(OWNER, 'unseen') == []
+    store.review(OWNER, 'review', attempt_id=aid, reviewer='t@x', score=90, comment='תוקן')   # a newer review: unseen again
+    assert len(store.review(OWNER, 'unseen')) == 1
+
+
+def test_open_requests_are_listed_for_chosen_students(answer_store):
+    store = answer_store
+    mine, theirs = photographed(store), photographed(store, OTHER)
+    store.review(OWNER, 'request', attempt_id=mine, message='א')
+    store.review(OTHER, 'request', attempt_id=theirs, message='ב')
+    both = store.review(None, 'requests')
+    assert {x['attempt_id'] for x in both} == {mine, theirs}
+    only = store.review(None, 'requests', users=[OWNER])
+    assert [(x['attempt_id'], x['user_id'], x['message']) for x in only] == [(mine, OWNER, 'א')]
+    assert store.review(None, 'requests', users=[]) == []
+
+
+# ---- the teacher's routes. OWNER is a student of class 1, whose teacher is OTHER; STRANGER teaches class 2.
+class ReviewAuth(ClassAuth):
+    def user_email(self, user_id):
+        return mail(user_id)
+
+    def user_accounts(self, emails):
+        return {mail(uid): {'id': uid, 'name': ''} for uid in (OWNER, OTHER, STRANGER) if mail(uid) in emails}
+
+
+def checked(store, aid, score=40, verdict='partial'):
+    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={'verdict': verdict, 'score': score})
+
+
+def review_app(store, manager=False):
+    auth = ReviewAuth()
+    if manager:
+        auth.teachers = frozenset({mail(STRANGER)})   # STRANGER is a manager here
+    app = create_app(auth=auth)
+    app.state.answers = store
+    return app
+
+
+def test_the_class_teacher_opens_an_answer_with_its_photo_and_check(answer_store):
+    store = answer_store
+    aid = photographed(store)
+    checked(store, aid, 40)
+    app = review_app(store)
+
+    async def run():
+        async with as_user(app, OTHER) as teacher:
+            r = await teacher.get(f'/api/teacher/answers/{aid}')
+            assert r.status_code == 200
+            data = r.json()
+            assert data['student'] == {'email': mail(OWNER)} and data['grading']['result']['score'] == 40
+            assert 'object_key' not in str(data) and data['effective_score'] == 40
+            assert data['attempt']['snapshot']['question'] and data['review'] is None and data['request'] is None
+            image = await teacher.get(f'/api/teacher/answers/{aid}/image')
+            assert image.status_code == 200 and image.headers['content-type'] == 'image/jpeg' and image.content
+            assert image.headers['cache-control'] == 'no-store'
+    asyncio.run(run())
+
+
+def test_other_accounts_are_refused_and_get_neither_the_check_nor_the_image(answer_store):
+    store = answer_store
+    aid = photographed(store)
+    checked(store, aid)
+    app = review_app(store)
+
+    async def run():
+        async with as_user(app, STRANGER) as other, as_user(app, OWNER) as student:
+            for client, status in ((other, 403), (student, 403)):   # another class's teacher; the student themself
+                for path in (f'/api/teacher/answers/{aid}', f'/api/teacher/answers/{aid}/image'):
+                    r = await client.get(path)
+                    assert r.status_code == status and r.headers['content-type'].startswith('application/json')
+                    assert 'score' not in r.text and 'attachment' not in r.text
+            assert (await other.put(f'/api/teacher/answers/{aid}/review', json={'score': 100})).status_code == 403
+            assert (await other.get(f'/api/teacher/answers/{uuid.uuid4()}')).status_code == 404
+    asyncio.run(run())
+    with answer_store.connect() as c:
+        assert c.execute('select count(*) from math_teacher_reviews').fetchone()[0] == 0
+
+
+def test_a_manager_may_open_any_answer(answer_store):
+    store = answer_store
+    aid = photographed(store)
+    app = review_app(store, manager=True)
+
+    async def run():
+        async with as_user(app, STRANGER) as manager:
+            assert (await manager.get(f'/api/teacher/answers/{aid}')).status_code == 200
+            assert (await manager.get(f'/api/teacher/answers/{aid}/image')).status_code == 200
+    asyncio.run(run())
+
+
+def test_the_teacher_corrects_a_score_and_grades_what_the_ai_could_not_read(answer_store):
+    store = answer_store
+    first, unreadable = photographed(store, question='a'), photographed(store, question='b')
+    checked(store, first, 40)
+    checked(store, unreadable, None, verdict='unreadable')
+    app = review_app(store)
+
+    async def run():
+        async with as_user(app, OTHER) as teacher:
+            put = lambda aid, **body: teacher.put(f'/api/teacher/answers/{aid}/review', json=body)
+            r = await put(first, score=85, comment='הדרך נכונה, טעות חישוב בשורה 3')
+            assert r.status_code == 200 and r.json()['review']['score'] == 85
+            assert r.json()['review']['reviewer_email'] == mail(OTHER)
+            seen = (await teacher.get(f'/api/teacher/answers/{first}')).json()
+            assert seen['grading']['result']['score'] == 40 and seen['effective_score'] == 85   # the AI's check is kept
+            assert (await put(unreadable, score=70)).status_code == 200
+            assert (await teacher.get(f'/api/teacher/answers/{unreadable}')).json()['effective_score'] == 70
+            assert (await put(first, comment='רק הערה')).json()['review']['score'] is None   # a newer review replaces
+            for bad in ({}, {'comment': '   '}, {'score': 120}, {'score': -1}, {'score': 7.5}, {'score': True},
+                        {'score': '80'}, {'comment': 'א' * 1001}, {'comment': 5}):
+                assert (await put(first, **bad)).status_code == 400, bad
+            assert (await put(first, score=0, comment='')).status_code == 200      # zero is a score
+            assert (await put(first, comment='א' * 1000)).status_code == 200
+    asyncio.run(run())
+
+
+def test_requests_to_look_again_are_listed_for_the_class_teacher_until_answered(answer_store):
+    store = answer_store
+    aid = photographed(store)
+    store.review(OWNER, 'request', attempt_id=aid, message='כתבתי x=4')
+    app = review_app(store)
+    app_manager = review_app(store, manager=True)
+
+    async def run():
+        async with as_user(app, OTHER) as teacher, as_user(app, STRANGER) as other:
+            listed = (await teacher.get('/api/teacher/review-requests')).json()['requests']
+            assert [(x['attempt_id'], x['student'], x['message']) for x in listed] == [(aid, mail(OWNER), 'כתבתי x=4')]
+            assert 'user_id' not in listed[0] and listed[0]['question']
+            assert (await other.get('/api/teacher/review-requests')).json() == {'requests': []}   # another class's teacher
+            async with as_user(app_manager, STRANGER) as manager:
+                assert len((await manager.get('/api/teacher/review-requests')).json()['requests']) == 1
+            assert (await teacher.put(f'/api/teacher/answers/{aid}/review', json={'comment': 'בדקתי שוב'})).status_code == 200
+            assert (await teacher.get('/api/teacher/review-requests')).json() == {'requests': []}
+    asyncio.run(run())
+
+
+# ---- what the student sees and can do
+@pytest.fixture(autouse=True)
+def open_ended_unlocked(monkeypatch):
+    monkeypatch.setenv('MATHLY_OPEN_ENDED_LOCKED', '0')
+    monkeypatch.setenv('ANTHROPIC_API_KEY', 'test-key')
+
+
+def test_the_student_sees_the_teachers_review_apart_from_the_ai_check(answer_store):
+    store = answer_store
+    aid = photographed(store)
+    checked(store, aid, 40)
+    app = review_app(store)
+
+    async def run():
+        async with as_user(app, OWNER) as student, as_user(app, OTHER) as teacher:
+            got = (await student.get(f'/api/math/answer-attempts/{aid}')).json()
+            assert got['teacher_review'] is None and got['review_request'] is None and got['effective_score'] == 40
+            assert (await student.get('/api/math/teacher-comments')).json() == {'comments': []}
+            await teacher.put(f'/api/teacher/answers/{aid}/review', json={'score': 85, 'comment': 'הדרך נכונה'})
+            comments = (await student.get('/api/math/teacher-comments')).json()['comments']
+            assert [(x['attempt_id'], x['score'], x['comment']) for x in comments] == [(aid, 85, 'הדרך נכונה')]
+            got = await student.get(f'/api/math/answer-attempts/{aid}')
+            data = got.json()
+            assert data['teacher_review']['score'] == 85 and data['teacher_review']['comment'] == 'הדרך נכונה'
+            assert data['grading']['result']['score'] == 40 and data['effective_score'] == 85   # both, labelled apart
+            assert mail(OTHER) not in got.text and 'reviewer' not in got.text                   # no teacher email
+            assert (await student.get('/api/math/teacher-comments')).json() == {'comments': []}   # opened: seen
+            await teacher.put(f'/api/teacher/answers/{aid}/review', json={'comment': 'תוקן'})
+            assert len((await student.get('/api/math/teacher-comments')).json()['comments']) == 1   # a newer one
+            assert (await student.get('/api/math/answer-attempts/' + aid)).json()['teacher_review']['comment'] == 'תוקן'
+    asyncio.run(run())
+
+
+def test_the_teacher_checking_on_the_students_behalf_does_not_mark_a_review_seen(answer_store):
+    store = answer_store
+    aid = photographed(store)
+    app = review_app(store)
+
+    async def run():
+        async with as_user(app, OTHER) as teacher, as_user(app, OWNER) as student:
+            await teacher.put(f'/api/teacher/answers/{aid}/review', json={'score': 50})
+            await teacher.get(f'/api/teacher/answers/{aid}')
+            assert len((await student.get('/api/math/teacher-comments')).json()['comments']) == 1
+    asyncio.run(run())
+
+
+def test_a_student_asks_the_teacher_to_look_again(answer_store):
+    store = answer_store
+    ids = [photographed(store, question=f'q{i}') for i in range(6)]
+    app = review_app(store)
+
+    async def run():
+        async with as_user(app, OWNER) as student, as_user(app, OTHER) as teacher:
+            ask = lambda aid, **body: student.post(f'/api/math/answer-attempts/{aid}/review-request', json=body)
+            r = await ask(ids[0], message='כתבתי x=4, לא x=1')
+            assert r.status_code == 200 and r.json()['review_request']['state'] == 'open'
+            again = await ask(ids[0], message='שוב')
+            assert again.json()['review_request']['id'] == r.json()['review_request']['id']   # one open request
+            assert (await student.get(f'/api/math/answer-attempts/{ids[0]}')).json()['review_request']['state'] == 'open'
+            assert (await ask(ids[1], message='א' * 301)).status_code == 400
+            assert (await ask(ids[1], message=7)).status_code == 400
+            for aid in ids[1:5]:
+                assert (await ask(aid)).status_code == 200                                      # five open
+            assert (await ask(ids[5])).status_code == 429
+            await teacher.put(f'/api/teacher/answers/{ids[0]}/review', json={'score': 100})
+            closed = (await student.get(f'/api/math/answer-attempts/{ids[0]}')).json()['review_request']
+            assert closed['state'] == 'closed'
+            assert (await ask(ids[5])).status_code == 200                                       # room again
+            other = as_user(app, OTHER)
+            async with other as stranger:   # a request is for the student's own answers only
+                assert (await stranger.post(f'/api/math/answer-attempts/{ids[0]}/review-request', json={})).status_code == 404
+    asyncio.run(run())
+
+
+def test_a_teacher_score_changes_the_grade_of_a_handed_in_quiz(answer_store):
+    from test_unit_quiz import check, quiz_answer
+    store = answer_store
+    ids = [quiz_answer(store, i) for i in range(4)]
+    for aid in ids:
+        check(store, aid, 100)
+    app = review_app(store)
+
+    async def run():
+        async with as_user(app, OWNER) as student:
+            made = (await student.post('/api/math/quiz-sittings', json={
+                'unit_id': 't', 'attempts': ids, 'client_key': str(uuid.uuid4())})).json()
+            assert made['grade'] == 100
+            store.review(OWNER, 'review', attempt_id=ids[1], reviewer=mail(OTHER), score=40, comment='')
+            mine = (await student.get('/api/math/quiz-sittings', params={'unit_id': 't'})).json()['sittings'][0]
+            assert mine['grade'] == 25 + 10 + 25 + 25 and mine['questions'][1]['state'] == 'teacher'
+    asyncio.run(run())

tests/test_unit_quiz.py

@@ -423,3 +423,65 @@ def test_a_check_that_finishes_after_handing_in_gives_the_sitting_its_grade(answ
             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())
+
+
+def test_a_quiz_result_shows_the_teachers_words_and_the_home_screen_tells_about_them(quiz_server, answer_store):
+    """A sitting handed in and checked, then the teacher (OWNER is a manager in these tests) reviews one answer: the
+    student's home screen says so, the result shows the teacher above the AI's check, and the student can ask again."""
+    import uuid
+    url, calls = quiz_server
+    store = answer_store
+    ids = [quiz_answer(store, i) for i in range(4)]
+    for aid, score in zip(ids, (100, 60, 100, 40)):
+        check(store, aid, score)
+    headers = {"Authorization": f"Bearer {OWNER}"}
+    sitting = httpx.post(url + "/api/math/quiz-sittings", headers=headers, json={
+        "unit_id": "t", "attempts": ids, "client_key": str(uuid.uuid4())}).json()
+    review = httpx.put(url + f"/api/teacher/answers/{ids[1]}/review", headers=headers,
+                       json={"score": 90, "comment": "הדרך נכונה, שימו לב לסימן"})
+    assert review.status_code == 200
+    entry = {"at": "2026-11-04T09:00:00.000Z", "attempts": ids, "score": None, "timeUp": False,
+             "ck": str(uuid.uuid4()), "sid": sitting["id"]}
+    seed = json.dumps(json.dumps({"uq": {"t": {"history": [entry]}}}))
+    key = json.dumps("mathly.progress.v1:" + OWNER + "@test.invalid")
+    from test_answer_browser import session
+    with playwright.sync_playwright() as p:
+        browser = p.chromium.launch()
+        try:
+            context = session(browser, mobile=True)
+            context.add_init_script(f"if(!localStorage.getItem({key})) localStorage.setItem({key},{seed})")
+            page = context.new_page(); errors = []
+            page.on("pageerror", lambda e: errors.append(str(e)))
+            page.goto(url)
+            page.locator('.mx-nav [data-view="path"]').click()
+            notice = page.locator(".mx-teacher-comment")
+            playwright.expect(notice).to_contain_text("המורה הגיב על תשובה שלכם")
+            playwright.expect(notice).to_contain_text("90/100")
+            notice.click()
+            sheet = page.locator(".mx-uq-sheet")
+            playwright.expect(sheet.locator("h3")).to_have_text("בוחן מסכם: 83/100", timeout=15000)   # 25 + 23 + 25 + 10
+            second = sheet.locator(".mx-uq-q").nth(1)
+            playwright.expect(second.locator(".mx-teacher-note")).to_contain_text("הערת המורה")
+            playwright.expect(second.locator(".mx-teacher-note")).to_contain_text("90/100")
+            playwright.expect(second.locator(".mx-teacher-note")).to_contain_text("שימו לב לסימן")
+            playwright.expect(second.locator(".mx-uq-verdict")).to_have_text("נבדק על ידי המורה")
+            playwright.expect(second.locator(".mx-uq-qhead span")).to_have_text("23/25 נק׳")
+            playwright.expect(second).to_contain_text("בדיקה אוטומטית:")
+            assert sheet.locator(".mx-teacher-note").count() == 1           # only the reviewed answer has one
+            # the student asks the teacher to look again at the third answer
+            third = sheet.locator(".mx-uq-q").nth(2)
+            third.locator(".mx-ask summary").click()
+            third.locator("[data-ask-msg]").fill("כתבתי את כל השלבים")
+            third.locator("[data-ask-review]").click()
+            playwright.expect(third.locator(".mx-ask-wait")).to_contain_text("הבקשה ממתינה")
+            listed = httpx.get(url + "/api/teacher/review-requests", headers=headers).json()["requests"]
+            assert [(x["attempt_id"], x["message"]) for x in listed] == [(ids[2], "כתבתי את כל השלבים")]
+            # the answer was opened: the notice is gone, and stays gone after a reload
+            page.locator(".mx-uq-sheet .mx-x, .mx-uq-sheet [data-act=close]").first.click()
+            playwright.expect(page.locator(".mx-teacher-comment")).to_have_count(0)
+            page.reload(); page.locator('.mx-nav [data-view="path"]').click()
+            playwright.expect(page.locator(".mx-trail")).to_be_visible()
+            playwright.expect(page.locator(".mx-teacher-comment")).to_have_count(0)
+            assert not errors
+        finally:
+            browser.close()

tests/test_unit_resources.py

@@ -62,6 +62,11 @@ class MemoryResources(UnitResources):
     def remove(self, resource_id):
         self.rows.pop(resource_id, None)
 
+    def set_visible(self, resource_id, visible):
+        if resource_id in self.rows:
+            self.rows[resource_id]['visible'] = visible
+        return self.rows.get(resource_id)
+
     def put(self, key, data):
         self.files[key] = data
 
@@ -289,3 +294,352 @@ def test_teacher_photographs_a_lesson_resource_on_a_phone(resource_server, tmp_p
             expect(student.locator('.mx-res')).to_have_count(0)
         finally:
             browser.close()
+
+
+# ---- what students see
+def classed(*students_in_class_t):
+    """An Auth with one class that has unit t, for the students listed; the others are in no class."""
+    class ClassedAuth(Auth):
+        def classes(self):
+            return [{'id': 1, 'name': 'ט1', 'lessons': ['t'], 'emails': [s[:4] + '@test.invalid' for s in students_in_class_t],
+                     'teachers': [], 'nicknames': {}, 'exams': []}]
+    return ClassedAuth()
+
+
+def test_the_migration_adds_a_visible_column_that_starts_false(postgres_server):
+    psycopg = pytest.importorskip('psycopg')
+    database = 'resvis_' + uuid.uuid4().hex
+    with psycopg.connect(postgres_server.get_uri(), autocommit=True) as c:
+        c.execute('create database ' + database)
+    try:
+        with psycopg.connect(postgres_server.get_uri(database=database), autocommit=True) as c:
+            c.execute(BOOTSTRAP)
+            c.execute(Path('supabase/migrations/20261101090000_math_unit_resources.sql').read_text())
+            c.execute('insert into auth.users values(%s)', (TEACHER,))
+            c.execute("insert into math_unit_resources(unit_id,kind,object_key,byte_size) values('t','theory','t/old.jpg',10)")
+            c.execute(Path('supabase/migrations/20261104180000_math_resources_visible.sql').read_text())
+            c.execute("insert into math_unit_resources(unit_id,kind,object_key,byte_size) values('t','exercise','t/new.jpg',10)")
+            c.execute("insert into math_unit_resources(unit_id,kind,object_key,byte_size,visible) values('t','theory','t/shown.jpg',10,true)")
+            rows = dict(c.execute('select object_key, visible from math_unit_resources').fetchall())
+            assert rows == {'t/old.jpg': False, 't/new.jpg': False, 't/shown.jpg': True}   # what existed stays hidden
+            assert c.execute("select is_nullable from information_schema.columns where table_name='math_unit_resources' "
+                             "and column_name='visible'").fetchone()[0] == 'NO'
+            c.execute('set role authenticated')
+            with pytest.raises(psycopg.errors.InsufficientPrivilege):
+                c.execute('select visible from math_unit_resources')
+    finally:
+        with psycopg.connect(postgres_server.get_uri(), autocommit=True) as c:
+            c.execute('drop database ' + database + ' with (force)')
+
+
+def test_a_resource_is_visible_by_default_only_when_it_is_a_theory_explanation():
+    store = MemoryResources()
+    app = app_with(store)
+
+    async def check():
+        async with client(app, TEACHER) as teacher:
+            made = {k: (await add(teacher, kind=k, note='הערה')).json() for k in ('exercise', 'theory', 'other')}
+            assert [made[k]['visible'] for k in ('exercise', 'theory', 'other')] == [False, True, False]
+            on = (await teacher.post('/api/math/units/t/resources', data={'kind': 'exercise', 'visible': '1'},
+                                     files={'photo': ('p.png', png(), 'image/png')})).json()
+            off = (await teacher.post('/api/math/units/t/resources', data={'kind': 'theory', 'visible': '0'},
+                                      files={'photo': ('p.png', png(), 'image/png')})).json()
+            assert (on['visible'], off['visible']) == (True, False)               # the form's box wins over the default
+            listed = (await teacher.get('/api/math/units/t/resources')).json()['resources']
+            assert {r['id']: r['visible'] for r in listed} == {made['exercise']['id']: False, made['theory']['id']: True,
+                                                              made['other']['id']: False, on['id']: True, off['id']: False}
+    asyncio.run(check())
+
+
+def test_only_the_teacher_who_added_a_resource_or_a_manager_changes_who_sees_it():
+    store = MemoryResources()
+    app = app_with(store)
+
+    async def check():
+        async with client(app, TEACHER) as teacher, client(app, COLLEAGUE) as colleague, \
+                client(app, STUDENT) as student, client(app, ADMIN) as admin:
+            rid = (await add(teacher)).json()['id']
+            patch = lambda c, **body: c.patch(f'/api/math/resources/{rid}', json=body)
+            assert (await patch(colleague, visible=True)).status_code == 403
+            assert (await patch(student, visible=True)).status_code == 403
+            assert store.rows[rid]['visible'] is False                         # still hidden
+            shown = await patch(teacher, visible=True)
+            assert shown.status_code == 200 and shown.json()['visible'] is True and 'object_key' not in shown.json()
+            assert (await patch(admin, visible=False)).json()['visible'] is False
+            for bad in ({}, {'visible': 'yes'}, {'visible': 1}, {'visible': None}):
+                assert (await patch(teacher, **bad)).status_code == 400
+            assert (await teacher.patch(f'/api/math/resources/{uuid.uuid4()}', json={'visible': True})).status_code == 404
+            assert (await teacher.patch('/api/math/resources/not-a-uuid', json={'visible': True})).status_code == 404
+    asyncio.run(check())
+
+
+def test_students_see_only_the_visible_resources_of_their_classs_units():
+    store = MemoryResources()
+    app = create_app(auth=classed(STUDENT))
+    app.state.resources = store
+
+    async def check():
+        async with client(app, TEACHER) as teacher, client(app, STUDENT) as student, client(app, COLLEAGUE) as colleague:
+            shown = (await add(teacher, kind='theory', skill='t_ext')).json()
+            hidden = (await add(teacher, kind='exercise')).json()
+            other_unit = (await add(teacher, unit='k', kind='theory')).json()   # t2 would come with t: it was split off from it
+            assert shown['visible'] and not hidden['visible']
+            listed = await student.get('/api/math/units/t/student-resources')
+            assert listed.status_code == 200
+            rows = listed.json()['resources']
+            assert [r['id'] for r in rows] == [shown['id']] and rows[0]['skill_id'] == 't_ext'
+            assert set(rows[0]) == {'id', 'unit_id', 'kind', 'note', 'skill_id', 'created_at'}   # no teacher, no storage path
+            assert 'test.invalid' not in listed.text and 'object_key' not in listed.text
+            image = await student.get(f"/api/math/student-resources/{shown['id']}/image")
+            assert image.status_code == 200 and image.headers['content-type'] == 'image/jpeg'
+            assert image.headers['cache-control'].startswith('private')
+            # a hidden resource, asked for by its id, is not found
+            assert (await student.get(f"/api/math/student-resources/{hidden['id']}/image")).status_code == 404
+            # a unit their class does not have
+            assert (await student.get('/api/math/units/k/student-resources')).status_code == 404
+            assert (await student.get(f"/api/math/student-resources/{other_unit['id']}/image")).status_code == 404
+            assert (await student.get('/api/math/units/nope/student-resources')).status_code == 404
+            assert (await student.get('/api/math/student-resources/not-a-uuid/image')).status_code == 404
+            # the teacher's own list still has all of them, each marked
+            assert len((await teacher.get('/api/math/units/t/resources')).json()['resources']) == 2
+            # hiding it again takes it away from the student at once
+            await teacher.patch(f"/api/math/resources/{shown['id']}", json={'visible': False})
+            assert (await student.get('/api/math/units/t/student-resources')).json() == {'resources': []}
+            assert (await student.get(f"/api/math/student-resources/{shown['id']}/image")).status_code == 404
+        async with httpx.AsyncClient(transport=httpx.ASGITransport(app=app), base_url='http://test') as guest:
+            assert (await guest.get('/api/math/units/t/student-resources')).status_code == 401
+    asyncio.run(check())
+
+
+def test_without_any_class_every_unit_is_open_to_students():
+    store = MemoryResources()
+    app = app_with(store)   # no classes configured: the whole path is open
+
+    async def check():
+        async with client(app, TEACHER) as teacher, client(app, STUDENT) as student:
+            await add(teacher, unit='t2', kind='theory')
+            assert len((await student.get('/api/math/units/t2/student-resources')).json()['resources']) == 1
+    asyncio.run(check())
+
+
+def jpeg(color='white'):
+    out = io.BytesIO()
+    Image.new('RGB', (200, 120), color).save(out, 'JPEG')
+    return out.getvalue()
+
+
+def seed(store, kind='theory', skill=None, note='', visible=True, unit='t', owner=TEACHER):
+    key = f'{unit}/{uuid.uuid4()}.jpg'
+    store.put(key, jpeg())
+    return store.add({'unit_id': unit, 'kind': kind, 'note': note, 'skill_id': skill, 'object_key': key, 'byte_size': 10,
+                      'created_by': owner, 'created_email': 'aaaa@test.invalid', 'visible': visible})
+
+
+def test_the_teacher_decides_what_students_see_with_a_box_and_a_toggle(resource_server, tmp_path):
+    playwright = pytest.importorskip('playwright.sync_api')
+    url, store = resource_server
+    photo = tmp_path / 'board.png'
+    photo.write_bytes(png('lightyellow'))
+    expect = playwright.expect
+    with playwright.sync_playwright() as p:
+        browser = p.chromium.launch()
+        try:
+            page = phone(browser, TEACHER)
+            errors = []
+            page.on('pageerror', lambda error: errors.append(str(error)))
+            page.goto(url)
+            page.locator('.mx-nav [data-view="path"]').click()
+            page.locator('#mx-unit-t .mx-uhead h2').click()
+            sheet = page.locator('.mx-res')
+
+            def take(kind):
+                with page.expect_file_chooser() as chooser:
+                    sheet.locator('[data-act="res-take"]').click()
+                chooser.value.set_files(str(photo))
+                form = sheet.locator('.mx-res-form')
+                form.locator('label', has_text=kind).click()
+                return form
+
+            # the box follows the kind until the teacher decides
+            form = take('הסבר תיאורטי')
+            box = form.locator('input[name=visible]')
+            expect(box).to_be_checked()
+            form.locator('label', has_text='תרגיל חדש').click()
+            expect(box).not_to_be_checked()
+            form.locator('label', has_text='הסבר תיאורטי').click()
+            expect(box).to_be_checked()
+            form.locator('label', has_text='תרגיל חדש').click()
+            box.check()                                                           # an exercise the teacher wants shown
+            form.locator('label', has_text='הסבר תיאורטי').click()
+            expect(box).to_be_checked()                                           # a decision is not overridden
+            form.locator('label', has_text='תרגיל חדש').click()
+            expect(box).to_be_checked()
+            form.locator('button[type=submit]').click()
+            expect(sheet.locator('.mx-res-item')).to_have_count(1)
+            expect(sheet.locator('.mx-res-vis')).to_have_text('👁 גלוי לתלמידים')
+            # a theory explanation is shown without touching the box; an exercise left alone stays hidden
+            form = take('הסבר תיאורטי')
+            form.locator('button[type=submit]').click()
+            form = take('תרגיל חדש')
+            expect(form.locator('input[name=visible]')).not_to_be_checked()
+            form.locator('button[type=submit]').click()
+            expect(sheet.locator('.mx-res-item')).to_have_count(3)
+            assert sorted(r['visible'] for r in store.rows.values()) == [False, True, True]
+            hidden = sheet.locator('.mx-res-item', has=page.locator('.mx-res-vis:not(.on)'))
+            expect(hidden).to_have_count(1)
+            hidden.locator('[data-act=res-visible]').click()
+            expect(sheet.locator('.mx-res-msg')).to_have_text('התמונה גלויה עכשיו לתלמידים.')
+            assert [r['visible'] for r in store.rows.values()].count(True) == 3
+            expect(sheet.locator('.mx-res-vis.on')).to_have_count(3)
+            sheet.locator('.mx-res-item').first.locator('[data-act=res-visible]').click()
+            expect(sheet.locator('.mx-res-msg')).to_have_text('התמונה מוסתרת מהתלמידים.')
+            expect(sheet.locator('.mx-res-vis.on')).to_have_count(2)
+            # a colleague sees which are shown, but cannot change them
+            colleague = phone(browser, COLLEAGUE)
+            colleague.goto(url)
+            colleague.locator('.mx-nav [data-view="path"]').click()
+            colleague.locator('#mx-unit-t .mx-uhead h2').click()
+            other = colleague.locator('.mx-res')
+            expect(other.locator('.mx-res-item')).to_have_count(3)
+            expect(other.locator('.mx-res-vis')).to_have_count(3)
+            expect(other.locator('[data-act=res-visible]')).to_have_count(0)
+            assert errors == []
+        finally:
+            browser.close()
+
+
+def test_a_student_finds_the_teachers_explanations_in_the_skill_its_help_and_the_unit(resource_server):
+    playwright = pytest.importorskip('playwright.sync_api')
+    url, store = resource_server
+    expect = playwright.expect
+    seed(store, kind='theory', skill='t_ext', note='')                  # for the skill
+    seed(store, kind='other', note='סיכום היחידה', visible=True)         # for the whole unit
+    seed(store, kind='exercise', skill='t_ext', visible=False)          # hidden
+    seed(store, kind='theory', skill='t_simplify', visible=False)
+    with playwright.sync_playwright() as p:
+        browser = p.chromium.launch()
+        try:
+            page = phone(browser, STUDENT)
+            errors = []
+            page.on('pageerror', lambda error: errors.append(str(error)))
+            page.goto(url)
+            page.locator('.mx-nav [data-view="path"]').click()
+            # the skill's sheet: the explanation tagged with it, and only that one
+            page.locator('.mx-star[data-id="t_ext"]').click()
+            box = page.locator('.mx-sheet [data-skill-res]')
+            expect(box).to_be_visible()
+            expect(box.locator('h4')).to_have_text('הסברים מהמורה')
+            expect(box.locator('figure')).to_have_count(1)
+            expect(box.locator('figure img')).to_have_attribute('src', re.compile('^blob:'))
+            expect(box.locator('figcaption')).to_contain_text('הסבר תיאורטי')
+            # its help panel shows it too
+            page.locator('.mx-helpbtn').click()
+            expect(page.locator('.mx-help [data-help-resources] figure')).to_have_count(1)
+            expect(page.locator('.mx-help [data-help-resources] img')).to_have_attribute('src', re.compile('^blob:'))
+            page.locator('.mx-help button.solid').click()
+            page.locator('.mx-sheet .mx-x').last.click()
+            # a skill with none visible shows no such box
+            page.locator('.mx-star[data-id="t_simplify"]').click()
+            expect(page.locator('.mx-sheet [data-skill-res]')).to_be_hidden()
+            page.locator('.mx-sheet .mx-x').last.click()
+            # the unit's own: a button under the unit, then the list
+            button = page.locator('#mx-unit-t .mx-sres-open')
+            expect(button).to_have_text('📷 הסברים מהמורה (1)')
+            button.click()
+            listed = page.locator('.mx-res [data-unit-res]')
+            expect(listed.locator('figure')).to_have_count(1)
+            expect(listed.locator('figcaption')).to_contain_text('סיכום היחידה')
+            listed.locator('.mx-sres-img').click()                                # tap to enlarge
+            expect(listed.locator('.mx-sres-item.zoom')).to_have_count(1)
+            assert errors == []
+        finally:
+            browser.close()
+
+
+def test_a_unit_without_explanations_for_the_unit_has_no_button(resource_server):
+    playwright = pytest.importorskip('playwright.sync_api')
+    url, store = resource_server
+    seed(store, kind='theory', skill='t_ext')                           # tied to a skill only
+    seed(store, kind='other', note='מוסתר', visible=False)
+    with playwright.sync_playwright() as p:
+        browser = p.chromium.launch()
+        try:
+            page = phone(browser, STUDENT)
+            page.goto(url)
+            page.locator('.mx-nav [data-view="path"]').click()
+            playwright.expect(page.locator('#mx-unit-t')).to_be_visible()
+            page.wait_for_timeout(800)
+            assert page.locator('.mx-sres-open').count() == 0
+        finally:
+            browser.close()
+
+
+@pytest.fixture
+def class_server():
+    """The app with one class (unit t) that the student is in, and the resources kept in memory."""
+    store = MemoryResources()
+    app = create_app(auth=classed(STUDENT))
+    app.state.resources = store
+    with socket.socket() as sock:
+        sock.bind(('127.0.0.1', 0))
+        server = uvicorn.Server(uvicorn.Config(app, log_level='error'))
+        thread = threading.Thread(target=server.run, kwargs={'sockets': [sock]}, daemon=True)
+        thread.start()
+        try:
+            deadline = time.monotonic() + 5
+            while not server.started:
+                assert thread.is_alive() and time.monotonic() < deadline
+                time.sleep(.01)
+            yield f'http://127.0.0.1:{sock.getsockname()[1]}', store
+        finally:
+            server.should_exit = True
+            thread.join(timeout=5)
+
+
+def test_a_theory_photo_a_teacher_uploads_appears_in_their_students_skill_sheet(class_server, tmp_path):
+    """The whole path in two browsers: the teacher photographs a theory explanation of a skill, and the student of the
+    class, opening that skill, finds it under the teacher's explanations."""
+    playwright = pytest.importorskip('playwright.sync_api')
+    url, store = class_server
+    photo = tmp_path / 'board.png'
+    photo.write_bytes(png('lightyellow'))
+    expect = playwright.expect
+    with playwright.sync_playwright() as p:
+        browser = p.chromium.launch()
+        try:
+            teacher = phone(browser, TEACHER)
+            teacher.goto(url)
+            teacher.locator('.mx-nav [data-view="path"]').click()
+            teacher.locator('#mx-unit-t .mx-uhead h2').click()
+            sheet = teacher.locator('.mx-res')
+            with teacher.expect_file_chooser() as chooser:
+                sheet.locator('[data-act="res-take"]').click()
+            chooser.value.set_files(str(photo))
+            form = sheet.locator('.mx-res-form')
+            form.locator('label', has_text='הסבר תיאורטי').click()
+            form.locator('select[name=skill]').select_option('t_ext')
+            form.locator('button[type=submit]').click()
+            expect(sheet.locator('.mx-res-vis')).to_have_text('👁 גלוי לתלמידים')
+            (row,) = store.rows.values()
+            assert (row['kind'], row['skill_id'], row['visible']) == ('theory', 't_ext', True)
+
+            student = phone(browser, STUDENT)
+            errors = []
+            student.on('pageerror', lambda error: errors.append(str(error)))
+            student.goto(url)
+            student.locator('.mx-nav [data-view="path"]').click()
+            student.locator('.mx-star[data-id="t_ext"]').click()
+            box = student.locator('.mx-sheet [data-skill-res]')
+            expect(box).to_be_visible()
+            expect(box.locator('figure')).to_have_count(1)
+            expect(box.locator('figure img')).to_have_attribute('src', re.compile('^blob:'))
+            assert errors == []
+            # the teacher hides it: the student no longer finds it (after the page asks again)
+            teacher.locator('.mx-res [data-act=res-visible]').click()
+            expect(teacher.locator('.mx-res-vis')).to_have_text('🔒 מוסתר מהתלמידים')
+            student.reload()
+            student.locator('.mx-nav [data-view="path"]').click()
+            student.locator('.mx-star[data-id="t_ext"]').click()
+            expect(student.locator('.mx-sheet [data-skill-res]')).to_be_hidden()
+        finally:
+            browser.close()