feat: add misconception patterns tracking and UI enhancements

- Introduced a new log for tracking misconceptions across multiple-choice answers, capturing details such as skill, question, and activity type.
- Implemented a "patterns that come back" card on the math home screen to display recurring misconceptions, enhancing student feedback.
- Developed a patterns sheet that shows detailed information about misconceptions, including tips and practice links.
- Updated the UI to reflect these changes, ensuring a consistent user experience.
- Added tests to validate the new functionality and ensure existing features remain unaffected.
- Modified database schema to accommodate new scan states for answer submissions.

app/answer_routes.py

@@ -12,7 +12,7 @@ from starlette.concurrency import run_in_threadpool
 from .answer_scans import AnswerScans, MAX_IMAGE, ScanError, clean_image, public_result, uuid_text
 from .answer_grading import AnswerGrader
 from .math_photo import PhotoUnavailable
-from .math_skills import algebra9, question_version
+from .math_skills import algebra9, question_version, quiz_snapshot
 
 log = logging.getLogger("mathly.answer_routes")
 VERDICTS = {"correct": "נכונה", "partial": "נכונה חלקית", "incorrect": "שגויה",
@@ -88,6 +88,22 @@ def install_answer_routes(app, signed_in):
         return reply(call(user, "resume", question_id=question["id"], question_version=version,
                           snapshot={"name": question["name"], **sample}, new=body.get("new") is True))
 
+    @app.post("/api/math/quiz-attempts")
+    def quiz_attempt(body: dict, user=Depends(student)):
+        """An answer to a question of a unit's summarizing quiz: `new` starts the attempt of a new sitting."""
+        if open_ended_locked():
+            raise ScanError(403, "open_ended_locked")
+        unit = next((u for u in algebra9()["units"] if u["id"] == body.get("unit") and "quiz" in u), None)
+        index = body.get("index")
+        if not unit or type(index) is not int or not 0 <= index < len(unit["quiz"]["questions"]):
+            raise ScanError(404, "not_found")
+        snapshot = quiz_snapshot(unit, index)
+        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))
+
     @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)))
@@ -157,6 +173,11 @@ def install_answer_routes(app, signed_in):
     def confirm(scan_id: str, user=Depends(student)):
         return reply(usable(call(user, "confirm", scan_id=uuid_text(scan_id))))
 
+    @app.post("/api/math/answer-scans/{scan_id}/decline")
+    def decline(scan_id: str, user=Depends(student)):
+        """The phone refuses the request, or the computer withdraws it."""
+        return reply(call(user, "decline", scan_id=uuid_text(scan_id)))
+
     @app.post("/api/math/answer-scans/{scan_id}/uploads")
     def begin(scan_id: str, body: dict, user=Depends(student)):
         result = usable(call(user, "begin", scan_id=uuid_text(scan_id), key=uuid_text(body.get("key"))))
@@ -172,7 +193,9 @@ def install_answer_routes(app, signed_in):
         data = await photo.read(MAX_IMAGE + 1)
         result = await run_in_threadpool(submit, user, sid, lease, data, photo.content_type)
         note(user, "answer_upload", result)
-        if result.get("grading_available") and not result.get("grading"):
+        # a quiz answer is graded only once the quiz is handed in (the page asks for it then)
+        quiz = str(result.get("attempt", {}).get("question_id", "")).startswith("quiz:")
+        if result.get("grading_available") and not result.get("grading") and not quiz:
             background_tasks.add_task(automatic_grade, user, result["attempt"]["id"])
         return reply(result)
 

app/answer_scans.py

@@ -130,6 +130,7 @@ def public_result(result):
     if result.get("scan"):
         for key in ("idempotency_key", "lease_id", "lease_until"):
             result["scan"].pop(key, None)
+        result["scan"]["code"] = scan_code(result["scan"].get("id"))
     if result.get("attachment"):
         result["attachment"].pop("object_key", None)
     if result.get("grading"):
@@ -138,6 +139,14 @@ def public_result(result):
     return result
 
 
+def scan_code(scan_id):
+    """The 4 digits shown on both the computer and the phone, so the student can match the request."""
+    try:
+        return f"{uuid.UUID(str(scan_id)).int % 10000:04d}"
+    except (ValueError, TypeError, AttributeError):
+        return ""
+
+
 def uuid_text(value):
     try:
         return str(uuid.UUID(str(value)))

app/math_algebra9.json

@@ -9,7 +9,28 @@
    "subject": "מתמטיקה",
    "name": "טכניקה אלגברית 1",
    "source": "פריסת ט׳ תשפ״ז",
-   "when": "ספטמבר"
+   "when": "ספטמבר",
+   "quiz": {
+    "minutes": 45,
+    "questions": [
+     {
+      "points": 25,
+      "question": "פתחו סוגריים ופשטו. הראו את דרך הפתרון.\nא. $(x + 4)(x − 3)$\nב. $(2x − 5)²$\nג. $(3x + 2)(3x − 2) − 9x²$"
+     },
+     {
+      "points": 25,
+      "question": "פתרו את המשוואה ובדקו את הפתרון שמצאתם: $(x + 3)(x − 2) = (x − 1)(x + 4) + 4$"
+     },
+     {
+      "points": 25,
+      "question": "אורך מלבן גדול ב־$5$ ס״מ מצלע של ריבוע, ורוחבו קטן ב־$3$ ס״מ מצלע הריבוע. נסמן את צלע הריבוע ב־$x$.\nא. בטאו בעזרת $x$ את שטח המלבן ופשטו.\nב. שטח המלבן גדול ב־$1$ סמ״ר משטח הריבוע. מצאו את צלע הריבוע ואת מידות המלבן."
+     },
+     {
+      "points": 25,
+      "question": "א. חשבו בלי מחשבון, בעזרת נוסחאות הכפל המקוצר, והראו כיצד: $49²$ ו־$102 · 98$.\nב. הוכיחו שלכל $x$ מתקיים: $(x + 3)² − (x − 3)² = 12x$."
+     }
+    ]
+   }
   },
   {
    "id": "t2",
@@ -19,14 +40,60 @@
    "when": "אוקטובר",
    "from": [
     "t"
-   ]
+   ],
+   "quiz": {
+    "minutes": 45,
+    "questions": [
+     {
+      "points": 30,
+      "question": "פרקו לגורמים:\nא. $6x² − 9x$\nב. $x² − 7x + 12$\nג. $4x² − 25$"
+     },
+     {
+      "points": 25,
+      "question": "פתרו בעזרת פירוק לגורמים:\nא. $x² − 5x = 0$\nב. $x² + 2x − 15 = 0$"
+     },
+     {
+      "points": 20,
+      "question": "מצאו את תחום ההצבה וצמצמו: $(x² − 16) / (x² − 4x)$"
+     },
+     {
+      "points": 25,
+      "question": "מצאו את תחום ההצבה, חשבו ופשטו: $(x² − 4) / (3x) · (6x) / (x + 2)$"
+     }
+    ]
+   }
   },
   {
    "id": "k",
    "subject": "מתמטיקה",
    "name": "דלתון",
    "source": "פריסת ט׳ תשפ״ז",
-   "when": "ספטמבר"
+   "when": "ספטמבר",
+   "quiz": {
+    "minutes": 45,
+    "questions": [
+     {
+      "points": 20,
+      "question": "בדלתון $ABCD$: $AB = AD$ ו־$CB = CD$. נתון: $∢BAD = 70°$ ו־$∢BCD = 50°$. חשבו את $∢ABC$ ונמקו.",
+      "figure": "A=0,3.71; B=-2.6,0; C=0,-5.58; D=2.6,0; poly A B C D; tick A B 1; tick A D 1; tick C B 2; tick C D 2; ang B A D 70°; ang D C B 50°"
+     },
+     {
+      "points": 30,
+      "question": "בדלתון $ABCD$: $AB = AD$ ו־$CB = CD$, ו־$AC$ הוא האלכסון הראשי.\nא. הוכיחו: $△ABC ≅ △ADC$.\nב. הוכיחו ש־$AC$ חוצה את $∢BAD$ ואת $∢BCD$.",
+      "figure": "A=0,3.71; B=-2.6,0; C=0,-5.58; D=2.6,0; poly A B C D; tick A B 1; tick A D 1; tick C B 2; tick C D 2; line A C"
+     },
+     {
+      "points": 25,
+      "question": "בדלתון $ABCD$ ($AB = AD$, $CB = CD$) האלכסונים נחתכים בנקודה $E$. נתון: $AB = 10$ ס״מ, $BD = 12$ ס״מ, $CE = 15$ ס״מ.\nא. מהו אורך $BE$? נמקו לפי תכונות האלכסונים בדלתון.\nב. חשבו את $AE$.\nג. חשבו את שטח הדלתון.",
+      "figure": "A=0,8; B=-6,0; C=0,-15; D=6,0; E=0,0@ne; poly A B C D; line A C; line B D; right A E D; len A B 10; len E C 15; tick A B 1; tick A D 1; tick C B 2; tick C D 2"
+     },
+     {
+      "points": 25,
+      "question": "במערכת צירים נתונות הנקודות $A(0, 6)$, $B(3, 2)$, $C(0, −4)$, $D(−3, 2)$.\nא. חשבו את אורכי הצלעות והראו ש־$ABCD$ הוא דלתון.\nב. חשבו את שטח הדלתון.",
+      "figure": "grid; A=0,6@ne; B=3,2@e; C=0,-4@se; D=-3,2@w; poly A B C D"
+     }
+    ]
+   }
   },
   {
    "id": "i",
@@ -36,7 +103,32 @@
    "when": "אוקטובר",
    "from": [
     "k"
-   ]
+   ],
+   "quiz": {
+    "minutes": 45,
+    "questions": [
+     {
+      "points": 25,
+      "question": "במשולש $ABC$, הקטע $AD$ הוא גם גובה לצלע $BC$ וגם תיכון לצלע $BC$. הוכיחו ש־$△ABC$ שווה שוקיים.",
+      "figure": "A=0,4; B=-3,0; C=3,0; D=0,0@s; poly A B C; line A D; right A D C; tick B D 1; tick D C 1"
+     },
+     {
+      "points": 25,
+      "question": "במשולש $ABC$: $AB = AC$ ו־$∢A = 36°$. הקטע $BD$ חוצה את $∢B$ (הנקודה $D$ על $AC$).\nא. חשבו את זוויות המשולש $BDC$.\nב. הוכיחו שהמשולשים $ABD$ ו־$BDC$ שווי שוקיים.",
+      "figure": "A=0,3.08; B=-1,0; C=1,0; D=0.62,1.18@e; poly A B C; line B D; tick A B 1; tick A C 1; ang B A C 36°; ang A B D; ang D B C"
+     },
+     {
+      "points": 25,
+      "question": "במשולש $ABC$, הקטע $BD$ חוצה את $∢ABC$ (הנקודה $D$ על $AC$). דרך $D$ העבירו ישר המקביל ל־$BC$, וה��א חותך את $AB$ בנקודה $E$. הוכיחו ש־$△EBD$ שווה שוקיים.",
+      "figure": "A=-1,4; B=-3,0; C=3,0; D=0.71,2.29@e; E=-1.85,2.29@w; poly A B C; line B D; line E D; par E D 1; par B C 1; ang E B D; ang D B C"
+     },
+     {
+      "points": 25,
+      "question": "במערכת צירים נתונות הנקודות $A(−3, 0)$, $B(3, 0)$, $C(0, 5)$.\nא. הראו ש־$△ABC$ שווה שוקיים.\nב. $M$ היא אמצע $AB$. מצאו את שיעורי $M$ והראו ש־$CM ⊥ AB$.\nג. חשבו את שטח המשולש.",
+      "figure": "grid; A=-3,0@sw; B=3,0@se; C=0,5@ne; poly A B C"
+     }
+    ]
+   }
   },
   {
    "id": "q",

app/math_skills.py

@@ -9,6 +9,9 @@ the one it came from (`from`) so classes that chose it keep their content. `mont
 The questions are written for the app, and every skill, link and mistake still needs a teacher's review.
 
 `problems` is run by the tests and on loading: a broken graph is refused before a student meets it.
+
+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.
 """
 from __future__ import annotations
 
@@ -107,6 +110,39 @@ def sample_problems(where: str, sid: str, sample: dict, listed: bool, mistakes:
     return out
 
 
+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"
+    if not isinstance(quiz, dict):
+        return [f"{where}: must be an object"]
+    out = []
+    if type(quiz.get("minutes")) is not int or not 5 <= quiz["minutes"] <= 120:
+        out.append(f"{where}: minutes must be a whole number from 5 to 120")
+    qs = quiz.get("questions")
+    if not isinstance(qs, list) or not qs:
+        return out + [f"{where}: needs questions"]
+    for n, q in enumerate(qs, 1):
+        at = f"{where} question {n}"
+        if not isinstance(q, dict) or not isinstance(q.get("question"), str) or not q["question"].strip():
+            out.append(f"{at}: question text is required")
+            continue
+        if type(q.get("points")) is not int or q["points"] <= 0:
+            out.append(f"{at}: points must be a positive whole number")
+        if "choices" in q:
+            out.append(f"{at}: a quiz question is open-ended")
+        if "figure" in q:
+            out += figure_problems(at, q["figure"])
+    if not out and sum(q["points"] for q in qs) != 100:
+        out.append(f"{where}: points add up to {sum(q['points'] for q in qs)}, not 100")
+    return out
+
+
+def quiz_snapshot(unit: dict, index: int) -> dict:
+    """What an answer to quiz question `index` is graded against, and what its version is computed from."""
+    q = unit["quiz"]["questions"][index]
+    return {"name": f"בוחן מסכם: {unit['name']} · שאלה {index + 1}", **q, "type": "open-ended"}
+
+
 def problems(graph: dict) -> list[str]:
     """What is wrong with a graph: unknown units, skills or mistakes, a cycle, a link implied by another,
     a question without exactly one right answer, or a mistake that sends the student to a skill that is not before it."""
@@ -114,6 +150,7 @@ def problems(graph: dict) -> list[str]:
     skills = {s["id"]: s for s in graph["skills"]}
     mistakes = graph["mistakes"]
     out = [f"{u['id']}: subject is required" for u in graph["units"] if not str(u.get("subject") or "").strip()]
+    out += [p for u in graph["units"] if "quiz" in u for p in quiz_problems(u)]
     out += [f"{s['id']}: unknown unit {s['unit']}" for s in skills.values() if s["unit"] not in units]
     out += [f"{s['id']}: unknown prerequisite {p}" for s in skills.values() for p in s["prereqs"] if p not in skills]
     if out:
@@ -156,6 +193,10 @@ def algebra9() -> dict:
     return graph
 
 
+def algebra9_unit(unit_id: str) -> dict:
+    return next(u for u in algebra9()["units"] if u["id"] == unit_id)
+
+
 def practice_graph(answer_scans_enabled: bool, open_ended_locked: bool = False) -> dict:
     """Keep practice usable during a scan rollout or rollback.
 
@@ -165,6 +206,11 @@ def practice_graph(answer_scans_enabled: bool, open_ended_locked: bool = False)
     """
     graph = copy.deepcopy(algebra9())
     subject = {unit["id"]: unit["subject"] for unit in graph["units"]}
+    for unit in graph["units"]:
+        if "quiz" in unit:   # photographed and graded: only with answer storage and open-ended grading on
+            unit["quiz"]["locked"] = not answer_scans_enabled or open_ended_locked
+            for i, q in enumerate(unit["quiz"]["questions"]):
+                q["question_version"] = question_version(quiz_snapshot(algebra9_unit(unit["id"]), i))
     for skill in graph["skills"]:
         skill["subject"] = subject[skill["unit"]]   # a subunit belongs to its unit's subject
         fallback = skill.pop("fallback_sample", None)

openspec/changes/add-misconception-patterns/.openspec.yaml

@@ -0,0 +1,2 @@
+schema: spec-driven
+created: 2026-11-03

openspec/changes/add-misconception-patterns/design.md

@@ -0,0 +1,51 @@
+# Design
+
+## Context
+
+Progress lives in one object `P` in localStorage (`mathly.progress.v1:<email>`), saved by `save()` in `static/math.js`. The scoring rules live in `static/math-sky.js` (`window.MathlySky`), whose `ensure(P)` fills missing fields so older saved progress keeps loading. Wrong answers reach three places, each of which already knows the choice's mistake tag (`data-m` on the button, or `choice.mistake`):
+
+- `answer()`: skill practice. Calls `Sky.wrong(P,id)` and shows `G.mistakes[m]`.
+- `reviewAnswer()`: mixed review. Calls `Sky.reviewed` and `Sky.wrong`.
+- `quizSubmit()`: practice exam. Already builds a per-exam mistake tally, but doesn't keep it.
+
+`G.mistakes[tag]` has `name`, `tip` and `back` (a skill id or `null`). The home screen is assembled in the path view as `topBar() + daily() + reviewCard() + examSoon() + quizCard() + …`.
+
+## Goals / Non-Goals
+
+**Goals:**
+- One place that writes a log entry, called from the three answer paths.
+- Pure summary logic in `math-sky.js`, testable through the page without UI.
+- The data shape is ready for a later personal path to read.
+
+**Non-Goals:**
+- Syncing the log to the server or a teacher view.
+- Changing what any activity shows or scores today.
+- Open-ended or photographed answers (they have no tags).
+
+## Decisions
+
+**Log shape: an array `P.slips` of `{at, id, q, m, via}`.** `at` is an ISO time, `id` the skill, `q` the question index, `m` the tag, and `via` is `"practice" | "review" | "exam"`. The newest are kept last and the array is capped at 500. A flat append-only log is chosen over pre-aggregated counters per tag because the 30/14/60-day windows and the later personal path need the time of each event. 500 short entries are about 40 KB, well inside localStorage. `ensure()` creates `slips` as an array, as it already does for `comets`.
+
+**`Sky.slip(P, id, q, m, via, now)` writes; `Sky.patterns(P, mistakes, now)` reads.** `patterns` returns `{recurring:[…], stopped:[…]}`. Each item is `{m, n, skills:[ids by count], last, practise}`. `practise` is `mistakes[m].back`, or else the skill where `m` came up most, with ties going to the most recent. Ranking: number of distinct skills, then count, then most recent. Both lists are cut to 3. For "stopped", a sliding pass over the tag's sorted times checks whether any two entries are 30 days or less apart. Keeping this in `math-sky.js` next to `due`/`streak` follows the existing split: rules there, screens in `math.js`.
+
+**Practice exam logs on hand-in, in `quizSubmit`**, from the final `res` list, not when picks are made, because picks can change and a left exam is discarded. All entries share the hand-in time.
+
+**Questions are logged by index (`q`).** This matches `P.solved`/`P.missed`. If question lists change, an old index may point at a different question. The summary only uses `m` and `id`, so that doesn't matter.
+
+**UI: `patternsCard()` after `reviewCard()` on the home screen, and a `showPatterns()` sheet opened by `data-act="patterns"`.** These reuse the existing sheet markup (`mx-sheet`, `mx-shtop`, `mx-x`) and buttons with `data-id` that already open a skill's practice. Copy, in Hebrew and plural like the rest of the app:
+- Card title: "דפוסים שחוזרים". Body: "‎<name> הופיעה ב־N מיומנויות לאחרונה. כדאי לחזק." With only stopped patterns: "‎<name> כבר לא חוזרת. כל הכבוד על התיקון."
+- Each sheet entry: name, tip, "N פעמים ב־K מיומנויות · לאחרונה <relative day>", and a "לחזק: <short>" button.
+- The stopped section is headed "דפוסים שנעלמו".
+
+The card sits after review so that today's due review stays first: retrieval comes before targeted work.
+
+## Risks / Trade-offs
+
+- [A guess or a slip is counted as a misconception] → It needs two occurrences within 30 days before it shows, and only the top three are shown.
+- [Showing mistakes may discourage some students] → The words are about the mistake, the card links straight to an action, and patterns that stopped are shown as a win.
+- [The log exists on one device only] → Accepted for now, as with all progress; moving it to the server is a later change.
+- [Tag names reused across topics with different meanings] → Tags are global in `math_algebra9.json` by design. Only the skill list reveals the spread.
+
+## Migration Plan
+
+No migration is needed. `ensure()` adds an empty `slips` to old progress. Rolling back leaves an unused `slips` array in storage, which is harmless.

openspec/changes/add-misconception-patterns/proposal.md

@@ -0,0 +1,34 @@
+# Proposal
+
+## Why
+
+Every wrong choice in the math path is already tagged with a named misconception (244 of them, e.g. `sign_mid`, `ext_partial`), but the tag is used only for the immediate tip and then forgotten: a wrong answer records nothing but a reset run. So the app cannot see that a student keeps making the same mistake across different skills, which is the weakness that actually blocks understanding. Remembering these tags is also the foundation for a later personal path that mixes weak and strong skills.
+
+## What Changes
+
+- Record every wrong answer's misconception, with its skill, question, date and where it happened (skill practice, mixed review, practice exam), in the student's progress on the device.
+- Add a "patterns that come back" (דפוסים שחוזרים) card on the math home screen when a misconception has come up at least twice recently, naming the misconception and in how many skills it appears.
+- Opening the card shows up to three recurring misconceptions, each with its tip, how often and how recently it came up, and buttons to practise the skill to strengthen.
+- The patterns also show where the student already looks: the skill to strengthen is marked "לחזק" on the path, and a mistake that is now a pattern says so in its feedback, with the skill to strengthen.
+- A pattern that has not come up again for a while leaves the list, and the card says when a pattern used to recur and has stopped ("נעלם"), so improvement is visible.
+- Wording stays about the mistake, never about the student, matching the existing quiet-mistake tone.
+- Unit-quiz (photographed, open-ended) answers have no misconception tags and are not included.
+- Nothing is sent to the server; progress stays in localStorage as today. Existing progress without the new log keeps working.
+
+## Capabilities
+
+### New Capabilities
+
+- `misconception-patterns`: recording a student's tagged mistakes across all multiple-choice practice and showing them the misconceptions that recur across skills, with what to practise.
+
+### Modified Capabilities
+
+(none: there are no main specs yet; skill practice, review and the practice exam keep their current behaviour and only also record the mistake)
+
+## Impact
+
+- `static/math-sky.js`: progress shape gains a mistake log, and functions to add to it and to summarise it.
+- `static/math.js`: wrong answers in practice (`answer`), review (`reviewAnswer`) and the practice exam (`quizSubmit`) log the mistake; new home card and sheet.
+- `static/math.css`: styles for the card and sheet.
+- `tests/test_sky_browser.py`: browser tests for logging and the card.
+- No server, API or data-file changes.

openspec/changes/add-misconception-patterns/specs/misconception-patterns/spec.md

@@ -0,0 +1,111 @@
+# Spec Delta
+
+## Purpose
+
+Remembers which named misconceptions a student's wrong answers show, across all multiple-choice practice, and shows the student the misconceptions that keep coming back across skills, with what to practise, so they work on the cause and not only on one skill.
+
+## ADDED Requirements
+
+### Requirement: Every tagged wrong answer is recorded
+The system SHALL record each wrong multiple-choice answer whose choice names a misconception, with the misconception, the skill, the question, the time and the activity (skill practice, mixed review or practice exam). Practice-exam answers SHALL be recorded once, when the exam is handed in. Recording SHALL NOT change the feedback, scoring, mastery or review of the answer.
+
+#### Scenario: A wrong answer in skill practice is recorded
+- **WHEN** a student picks a wrong choice tagged `sign_mid` in skill `t_ext`
+- **THEN** the student's progress holds one record with misconception `sign_mid`, skill `t_ext`, that question, the time and activity "practice"
+
+#### Scenario: A wrong answer in mixed review is recorded
+- **WHEN** a student picks a wrong choice in a mixed review
+- **THEN** a record with activity "review" is added, and the skill's next review is scheduled exactly as before
+
+#### Scenario: A practice exam is recorded when handed in
+- **WHEN** a student changes a wrong pick before handing in a practice exam, then hands it in with two wrong answers
+- **THEN** exactly two records with activity "exam" are added, for the final picks only
+
+#### Scenario: A left practice exam records nothing
+- **WHEN** a student leaves a practice exam without handing it in
+- **THEN** no records are added
+
+#### Scenario: A right answer records nothing
+- **WHEN** a student picks the right choice
+- **THEN** no record is added
+
+### Requirement: The mistake log stays on the device and is bounded
+The mistake log SHALL be kept with the rest of the student's progress on the device, per account, and SHALL keep only the newest 500 records. Progress saved before this change SHALL load and work with an empty log.
+
+#### Scenario: Old progress without a log
+- **WHEN** a student whose saved progress has no mistake log opens the math path
+- **THEN** the path works as before and the first wrong answer starts the log
+
+#### Scenario: The log is capped
+- **WHEN** a 501st record is added
+- **THEN** the oldest record is dropped and 500 remain
+
+### Requirement: Recurring misconceptions are identified
+A misconception SHALL count as recurring when it was recorded at least twice in the last 30 days and at least once in the last 14 days. Recurring misconceptions SHALL be ordered by how many different skills they appeared in, then by count, then by most recent, and at most three SHALL be shown.
+
+#### Scenario: Two occurrences make a pattern
+- **WHEN** `sign_mid` was recorded twice in the last 30 days, once of them in the last 14 days, and `ext_partial` once
+- **THEN** `sign_mid` is a recurring misconception and `ext_partial` is not
+
+#### Scenario: Spread across skills comes first
+- **WHEN** `sign_mid` was recorded 3 times in 3 different skills and `move_sign` 4 times in 1 skill
+- **THEN** `sign_mid` is listed before `move_sign`
+
+#### Scenario: Old records do not count
+- **WHEN** a misconception's only records are older than 30 days
+- **THEN** it is not a recurring misconception
+
+### Requirement: The home screen shows a patterns card
+The math home screen SHALL show a "patterns that come back" card when there is at least one recurring misconception, naming the top one and in how many skills it appeared. Without recurring or stopped patterns the card SHALL NOT be shown. The card's words SHALL describe the mistake, not the student.
+
+#### Scenario: Card appears
+- **WHEN** a student has a recurring misconception
+- **THEN** the home screen shows the card with that misconception's name and its number of skills
+
+#### Scenario: No card without a pattern
+- **WHEN** a student has no recurring misconception and no pattern that has stopped
+- **THEN** no patterns card is shown
+
+### Requirement: The patterns sheet says what to practise
+Opening the card SHALL show each recurring misconception (at most three) with its name, its tip, how many times and in how many skills it came up in the last 30 days, and when it last came up. Each SHALL offer a button to practise the skill to strengthen: the misconception's own back-skill when it names one, otherwise the skill where it came up most. Each button SHALL open that skill's practice.
+
+#### Scenario: A misconception with a back-skill
+- **WHEN** the recurring misconception `ext_partial` names `t_ext` as its back-skill
+- **THEN** its entry offers a button that opens practice of `t_ext`
+
+#### Scenario: A misconception without a back-skill
+- **WHEN** the recurring misconception `sign_mid` has no back-skill and came up most in `t_simplify`
+- **THEN** its entry offers a button that opens practice of `t_simplify`
+
+### Requirement: Improvement is shown
+The patterns sheet SHALL list, separately and at most three, misconceptions that were recorded at least twice within some 30-day span, last recorded between 14 and 60 days ago, as patterns that have stopped. When no misconception is recurring but one has stopped, the card SHALL be shown and say so.
+
+#### Scenario: A pattern stops
+- **WHEN** `sign_mid` was recorded 3 times 20 days ago and not since
+- **THEN** the sheet lists `sign_mid` among the patterns that have stopped, and not among the recurring ones
+
+#### Scenario: A long-stopped pattern is no longer listed
+- **WHEN** a misconception was last recorded more than 60 days ago
+- **THEN** it is listed neither as recurring nor as stopped
+
+### Requirement: The path marks the skills to strengthen
+On the math path, every skill that a recurring misconception names as its skill to practise SHALL be marked as a skill to strengthen ("לחזק") on its star, so a student following the path meets it there. The "continue here" mark of the next skill SHALL take precedence over this tag.
+
+#### Scenario: A finished skill to strengthen is marked
+- **WHEN** `ext_partial` is recurring, names `t_ext` as its back-skill, and `t_ext` is finished
+- **THEN** the star of `t_ext` on the path is marked and tagged "לחזק"
+
+#### Scenario: No pattern, no mark
+- **WHEN** the student has no recurring misconception
+- **THEN** no star on the path is marked to strengthen
+
+### Requirement: A recurring mistake is named where it happens
+When a wrong answer in skill practice or mixed review shows a misconception that is recurring (counting this answer), its feedback SHALL add a short note saying how many times and in how many skills it came up in the last 30 days, with a button to practise its skill to strengthen unless that skill is already offered in the same feedback.
+
+#### Scenario: The second time the same mistake comes up
+- **WHEN** `ext_partial` was recorded once in `t_ext_eq` and the student now picks an `ext_partial` choice in `t_simplify`
+- **THEN** the feedback says it came up 2 times in 2 skills and offers practice of `t_ext` once
+
+#### Scenario: A first mistake has no note
+- **WHEN** a misconception is recorded for the first time
+- **THEN** the feedback shows no pattern note

openspec/changes/add-misconception-patterns/tasks.md

@@ -0,0 +1,29 @@
+# Tasks
+
+## 1. Mistake log and summary rules (static/math-sky.js)
+
+- [x] 1.1 Make `ensure(P)` create `P.slips` as an array when missing or invalid; verify with a browser test that progress saved without `slips` loads the path without errors
+- [x] 1.2 Add `Sky.slip(P,id,q,m,via,now)` that appends `{at,id,q,m,via}` and keeps the newest 500; export it on `window.MathlySky`; verify with a page-evaluated test that 501 calls leave 500 entries with the oldest dropped
+- [x] 1.3 Add `Sky.patterns(P,mistakes,now)` returning `{recurring,stopped}` per the spec (2+ in 30 days with 1 in the last 14 → recurring; 2 within some 30-day span, last seen 14–60 days ago → stopped; ranked by skills, count, recency; 3 each; `practise` = back-skill or most frequent skill); verify with page-evaluated tests covering each spec scenario under "Recurring misconceptions are identified" and "Improvement is shown"
+
+## 2. Logging wrong answers (static/math.js)
+
+- [x] 2.1 In `answer()` call `Sky.slip(...,"practice")` on a wrong tagged choice before `save()`; verify a browser test picks a wrong choice in `t_ext` and finds one entry with that tag and `via:"practice"`, and that the existing quiet-mistake test still passes
+- [x] 2.2 In `reviewAnswer()` log wrong answers with `"review"`; verify the existing review test still passes and a wrong review answer adds one `review` entry
+- [x] 2.3 In `quizSubmit()` log each final wrong pick with `"exam"`; verify a test that changes a pick and hands in logs only final picks, and that quitting an exam logs nothing
+
+## 3. Patterns card and sheet (static/math.js, static/math.css)
+
+- [x] 3.1 Add `patternsCard()` after `reviewCard()` in the home screen, shown only when `Sky.patterns` has a recurring or stopped pattern, with the copy from design.md; verify browser tests with seeded progress: no card when empty, card naming the top misconception and its skill count, card wording for stopped-only
+- [x] 3.2 Add the `patterns` sheet (`data-act="patterns"`): up to three recurring entries with name, tip, count, skill count, last-seen day and a "לחזק" button opening the practise skill, then a "דפוסים שנעלמו" section; verify a browser test that the button for a tag with `back` opens that skill and for a tag without `back` opens its most frequent skill
+- [x] 3.3 Style the card and sheet to match `mx-review`/`mx-quiz-card` in light and dark, at phone width; verify by screenshot at 375px and that no horizontal scroll appears
+- [x] 3.4 Update the header comment of `static/math.js` (progress fields) to describe `slips`; verify by reading the comment
+
+## 4. Patterns where the student looks (path and feedback)
+
+- [x] 4.1 Mark the skills to strengthen on the path (gold ring and "לחזק" tag, "ממשיכים כאן" wins); verify `test_the_path_marks_the_skill_to_strengthen` and a 375px screenshot
+- [x] 4.2 Add the pattern note to practice and review feedback, without repeating a button already offered; verify `test_a_mistake_that_is_a_pattern_says_so_where_it_happens` and `test_a_first_mistake_has_no_pattern_note`
+
+## 5. Integration check
+
+- [x] 5.1 Run `pytest tests/test_sky_browser.py tests/test_math_skills.py` and confirm all pass, including the existing practice, review and exam tests unchanged

static/answer-scans.js

@@ -3,11 +3,12 @@
 (()=>{
 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:"הבקשה הוחלפה"};
+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:"יש להיכנס לאותו חשבון בשני המכשירים."};
 Object.assign(errors,{grading_unavailable:"בדיקת תשובות אינה זמינה כרגע באתר.",grading_failed:"הבדיקה נכשלה. התמונה נשמרה; אפשר לנסות שוב.",grading_interrupted:"הבדיקה הופסקה. אפשר לנסות שוב.",grading_limit:"הגעתם למכסת 20 הבדיקות היומית. נסו שוב מחר.",grading_busy:"כבר מתבצעות בדיקות בחשבון. נסו שוב בעוד רגע.",answer_required:"יש לצלם ולשלוח תשובה לפני הבדיקה."});
 const verdicts={correct:"נכון! הפתרון מלא",partial:"פתרון נכון בחלקו",incorrect:"יש לתקן את הפתרון",unreadable:"לא ניתן לקרוא את התשובה",needs_review:"נדרשת הבהרה לפני מתן ציון"};
-let api=null,account=null,epoch=0,question=null,inbox=null,inboxTimer=null,inboxPoll=null,capture=null,visibleRoot=null,onGraded=null;
+let api=null,account=null,epoch=0,question=null,inbox=false,inboxTimer=null,inboxPoll=null,capture=null,visibleRoot=null,onGraded=null,waiting=null;
+const handled=new Set();   // requests this phone already answered (photographed or declined): not shown again
 const live=(e)=>e===epoch&&!!account;
 async function json(url,options={}){
   const r=await api(url,{cache:"no-store",...options});
@@ -23,35 +24,35 @@ function closeCapture(){
   if(capture){if(capture.url)URL.revokeObjectURL(capture.url);capture.node.remove();capture.returnFocus?.focus?.();capture=null;}
 }
 function reset(){
-  epoch++;if(question)question.node.replaceChildren();closeQuestion();closeCapture();clearTimeout(inboxTimer);inboxTimer=null;
-  inbox?.remove();inbox=null;account=null;onGraded=null;
+  epoch++;if(question)question.node.replaceChildren();closeQuestion();closeCapture();closeWait();clearTimeout(inboxTimer);inboxTimer=null;
+  inbox=false;account=null;onGraded=null;
 }
 function configure(options){
   reset();api=options.api;account=options.enabled?options.account:null;visibleRoot=options.root;onGraded=options.onGraded;
   if(!account)return;
-  // Foreground discovery is available in the responsive phone app/PWA.
-  if(matchMedia("(max-width: 700px)").matches||navigator.maxTouchPoints){
-    inbox=document.createElement("section");inbox.className="mx-scan-inbox mx-wrap";
-    inbox.setAttribute("aria-label","בקשות לצילום תשובה");visibleRoot.prepend(inbox);pollInbox(epoch);
-  }
+  // The phone (the responsive app/PWA) watches for requests from the computer and pops them up.
+  if(matchMedia("(max-width: 700px)").matches||navigator.maxTouchPoints){inbox=true;pollInbox(epoch);}
 }
+/* The phone looks for requests every few seconds while the app is open. A new request pops up as a window with its
+   4-digit code (the same code the computer shows); the student photographs the answer or declines. */
 async function pollInbox(e){
   clearTimeout(inboxTimer);if(!live(e)||!inbox||inboxPoll===e)return;
   if(document.hidden){inboxTimer=setTimeout(()=>pollInbox(e),5000);return;}
   inboxPoll=e;
-  let delay=5000;
+  let delay=3000;
   try{
     const list=await json("/api/math/answer-scans");if(!live(e)||!inbox)return;
-    const signature=JSON.stringify(list.map(r=>[r.scan.id,r.scan.state]));
-    if(inbox.dataset.signature!==signature){
-      inbox.dataset.signature=signature;
-      inbox.innerHTML=list.length?`<h2>בקשות לצילום תשובה</h2>${list.map((r,i)=>`<button class="mx-btn" data-scan-index="${i}"><b>${fmt(r.attempt.snapshot.question)}</b><small>ניסיון ${esc(r.attempt.id.slice(0,8))} · ${esc(states[r.scan.state])}</small></button>`).join("")}`:"";
-      inbox.querySelectorAll("[data-scan-index]").forEach(button=>button.onclick=()=>openCapture(list[Number(button.dataset.scanIndex)]));
+    if(capture&&!capture.ended){
+      const mine=list.find(r=>r.attempt.id===capture.result.attempt.id);
+      // withdrawn on the computer (or replaced there by a new request): this window has nothing left to answer
+      if(!mine||mine.scan.id!==capture.result.scan.id&&!capture.busy)capture.withdrawn?.(mine);
     }
+    const ask=list.find(r=>["waiting","confirmed","failed"].includes(r.scan.state)&&!handled.has(r.scan.id));
+    if(ask&&!capture)openCapture(ask);
   }catch(error){
     if(!live(e))return;
     if(error.status===401){reset();return;}
-    if(inbox){inbox.textContent="לא ניתן לבדוק בקשות צילום כרגע. מנסים שוב…";delete inbox.dataset.signature;}delay=15000;
+    delay=15000;
   }finally{if(inboxPoll===e)inboxPoll=null;}
   if(live(e))inboxTimer=setTimeout(()=>pollInbox(e),delay);
 }
@@ -86,13 +87,19 @@ async function renderQuestion(q){
     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)}
-        <button class="mx-btn" data-new-attempt ${checking?"disabled":""}>ניסיון חדש וצילום מחדש</button>`:`<button class="mx-btn solid" data-request>${s?["expired","superseded"].includes(state)?"יצירת בקשת צילום חדשה":state==="failed"?"ניסיון נוסף":"פתחו את Mathly בטלפון באותו חשבון":"סריקת התשובה שלי בטלפון"}</button>`}`;
+        <button class="mx-btn" data-new-attempt ${checking?"disabled":""}>ניסיון חדש וצילום מחדש</button>`:`<button class="mx-btn solid mx-phone-cta" data-request><span aria-hidden="true">📱</span> ${s?["expired","superseded","declined"].includes(state)?"בקשת צילום חדשה לטלפון":waitingState(state)?"הצגת המספר לטלפון":"ניסיון נוסף בטלפון":"צילום התשובה בטלפון"}</button>`}`;
     if(!received){
-      const b=q.node.querySelector("[data-request]");b.disabled=["uploading","waiting","confirmed"].includes(state);
+      const b=q.node.querySelector("[data-request]");b.disabled=state==="uploading";
       b.onclick=async()=>{
         b.disabled=true;
-        try{const result=await post(`/api/math/answer-attempts/${r.attempt.id}/scans`,{question_id:q.id,renew:["expired","superseded","failed"].includes(state)});
-          if(!current(q))return;q.result=result;q.signature=null;await renderQuestion(q);schedule(q);}
+        try{
+          const result=waitingState(q.result.scan?.state)?q.result:await post(`/api/math/answer-attempts/${r.attempt.id}/scans`,
+            {question_id:q.id,renew:["expired","superseded","failed","declined"].includes(q.result.scan?.state)});
+          if(!current(q))return;q.result=result;q.signature=null;await renderQuestion(q);
+          const end=await waitForPhone(result,{question_id:q.id});
+          if(end&&current(q)){q.result=end;q.signature=null;await renderQuestion(q);}
+          schedule(q,0);
+        }
         catch(error){if(current(q)){q.node.querySelector("[role=status]").textContent=error.message;b.disabled=false;}}
       };
     }
@@ -151,44 +158,59 @@ async function checkAnswer(q,automatic=false){
     }
   }
 }
+const waitingState=st=>st==="waiting"||st==="confirmed";
+const codeHTML=code=>`<div class="mx-scan-code" dir="ltr" aria-label="מספר מזהה ${esc([...String(code||"")].join(" "))}">${[...String(code||"----")].map(d=>`<span>${esc(d)}</span>`).join("")}</div>`;
+// keeps Tab inside a window
+function trapTab(node,event){
+  if(event.key!=="Tab")return;
+  const buttons=[...node.querySelectorAll("button")].filter(b=>!b.hidden&&!b.disabled&&b.offsetParent);
+  if(event.shiftKey&&document.activeElement===buttons[0]){event.preventDefault();buttons.at(-1)?.focus();}
+  else if(!event.shiftKey&&document.activeElement===buttons.at(-1)){event.preventDefault();buttons[0]?.focus();}
+}
+
+/* ---------- the phone: a window for a request from the computer ---------- */
 function openCapture(result){
   closeCapture();const e=epoch;
   if(!live(e))return;
-  const node=document.createElement("div");node.className="mx-scan-overlay";node.setAttribute("role","dialog");node.setAttribute("aria-modal","true");node.setAttribute("aria-labelledby","scanTitle");
-  node.innerHTML=`<div class="mx-scan-card"><button class="mx-btn" data-close>סגירה</button><h2 id="scanTitle">צילום תשובה</h2>
-    <p>${fmt(result.attempt.snapshot.question)}</p><small>ניסיון ${esc(result.attempt.id.slice(0,8))}</small>
-    <p data-status role="status" aria-live="polite">האם לצלם תשובה לשאלה הזו?</p>
-    <button class="mx-btn solid" data-confirm>כן, אני רוצה לצלם תשובה</button>
-    <button class="mx-btn" data-renew hidden>יצירת בקשת צילום חדשה</button>
-    <input data-camera type="file" accept="image/*" capture="environment" hidden>
-    <button class="mx-btn" data-take hidden>צילום התשובה</button>
+  const node=document.createElement("div");node.className="mx-scan-overlay";node.setAttribute("role","alertdialog");node.setAttribute("aria-modal","true");node.setAttribute("aria-labelledby","scanTitle");
+  node.innerHTML=`<div class="mx-scan-card mx-scan-ask">
+    <h2 id="scanTitle"><span aria-hidden="true">📷</span> בקשת צילום מהמחשב</h2>
+    <p>בדקו שזה אותו מספר שמופיע במחשב:</p>${codeHTML(result.scan.code)}
+    <div class="mx-scan-q"><small>השאלה</small><p>${fmt(result.attempt.snapshot.question)}</p></div>
     <img class="mx-answer-image" data-preview alt="תצוגה מקדימה של התשובה" hidden>
-    <p>כשהבדיקה האוטומטית זמינה, צילום התשובה יישלח לבדיקה באמצעות AI. המשוב והציון יופיעו בשאלה במחשב.</p>
-    <button class="mx-btn solid" data-submit hidden>שליחת התשובה למחשב</button></div>`;
-  const c=capture={node,e,result,photo:null,url:null,key:null,busy:false,returnFocus:document.activeElement};visibleRoot.append(node);
-  const status=node.querySelector("[data-status]"),camera=node.querySelector("[data-camera]"),take=node.querySelector("[data-take]"),send=node.querySelector("[data-submit]"),preview=node.querySelector("[data-preview]"),confirm=node.querySelector("[data-confirm]"),renew=node.querySelector("[data-renew]");
+    <p data-status role="status" aria-live="polite">כתבו את הפתרון על דף וצלמו אותו.</p>
+    <input data-camera type="file" accept="image/*" capture="environment" hidden>
+    <div class="mx-scan-actions">
+      <button class="mx-btn solid" data-take>📷 צילום התשובה</button>
+      <button class="mx-btn solid" data-submit hidden>שליחה למחשב</button>
+      <button class="mx-btn" data-renew hidden>בקשה חדשה</button>
+      <button class="mx-btn mx-btn-quiet" data-decline>סירוב</button>
+      <button class="mx-btn" data-close hidden>סגירה</button>
+    </div>
+    <small>כשהבדיקה האוטומטית זמינה, צילום התשובה יישלח לבדיקה באמצעות AI. המשוב יופיע בשאלה במחשב.</small></div>`;
+  const c=capture={node,e,result,photo:null,url:null,key:null,busy:false,ended:false,confirming:null,returnFocus:document.activeElement};visibleRoot.append(node);
+  const $=sel=>node.querySelector(sel);
+  const status=$("[data-status]"),camera=$("[data-camera]"),take=$("[data-take]"),send=$("[data-submit]"),preview=$("[data-preview]"),renew=$("[data-renew]"),decline=$("[data-decline]"),close=$("[data-close]");
   const valid=()=>capture===c&&live(e),say=message=>{if(valid())status.textContent=message;};
-  const controls=busy=>{c.busy=busy;take.disabled=send.disabled=confirm.disabled=renew.disabled=busy;};
-  const expired=()=>{confirm.hidden=true;take.hidden=true;send.hidden=true;renew.hidden=false;say(errors.expired);};
-  node.querySelector("[data-close]").onclick=closeCapture;
+  const controls=busy=>{c.busy=busy;take.disabled=send.disabled=renew.disabled=decline.disabled=busy;};
+  // the request is over: only closing is left
+  const finish=message=>{c.ended=true;handled.add(c.result.scan.id);take.hidden=send.hidden=renew.hidden=decline.hidden=true;close.hidden=false;say(message);close.focus();};
+  const expired=()=>{take.hidden=send.hidden=true;renew.hidden=false;say(errors.expired);};
+  c.withdrawn=mine=>{ if(c.photo&&mine&&waitingState(mine.scan.state)){c.result=mine;return;} finish("הבקשה בוטלה במחשב."); };
+  close.onclick=()=>{closeCapture();if(valid())pollInbox(e);};
   node.onkeydown=event=>{
-    if(event.key==="Escape"&&!c.busy){event.preventDefault();event.stopPropagation();closeCapture();}
-    if(event.key==="Tab"){
-      const buttons=[...node.querySelectorAll("button")].filter(b=>!b.hidden&&!b.disabled);
-      if(event.shiftKey&&document.activeElement===buttons[0]){event.preventDefault();buttons.at(-1)?.focus();}
-      else if(!event.shiftKey&&document.activeElement===buttons.at(-1)){event.preventDefault();buttons[0]?.focus();}
-    }
+    if(event.key==="Escape"){event.preventDefault();event.stopPropagation();if(c.ended)close.click();}
+    trapTab(node,event);
   };
-  confirm.onclick=async()=>{
-    controls(true);
-    try{const r=await post(`/api/math/answer-scans/${c.result.scan.id}/confirm`);if(!valid())return;c.result=r;
-      if(r.attachment){success();return;}
-      confirm.hidden=true;take.hidden=false;say("בחרו צילום. אם תתבקשו, אפשרו גישה למצלמה.");take.focus();}
-    catch(error){if(valid()){say(error.message);if(error.status===410)expired();}}
-    finally{if(valid())controls(false);}
+  // confirming happens in the background, so the camera opens right from the tap
+  const confirmed=()=>c.confirming||=(async()=>{
+    const r=await post(`/api/math/answer-scans/${c.result.scan.id}/confirm`);if(valid())c.result=r;return r;
+  })().catch(error=>{c.confirming=null;throw error;});
+  take.onclick=()=>{
+    say("צלמו את הפתרון. אם המצלמה חסומה, אפשרו אותה בהגדרות האתר ונסו שוב.");camera.click();
+    confirmed().then(r=>{if(r.attachment&&valid())success();}).catch(error=>{if(valid()){say(error.message);if(error.status===410)expired();}});
   };
-  take.onclick=()=>{say("צלמו את הפתרון. אם המצלמה חסומה, אפשרו אותה בהגדרות האתר ונסו שוב.");camera.click();};
-  camera.addEventListener("cancel",()=>say("הצילום בוטל או שלא ניתנה הרשאה. אפשר לנסות שוב בכפתור הצילום."));
+  camera.addEventListener("cancel",()=>say("הצילום בוטל או שלא ניתנה הרשאה. אפשר לצלם שוב או לסרב."));
   camera.onchange=async()=>{
     const file=camera.files[0];camera.value="";if(!file||!valid())return;
     controls(true);say("מכינים את התמונה…");
@@ -197,15 +219,16 @@ function openCapture(result){
       if(photo.size>5000000)throw Error(errors.image_too_large);
       if(c.url)URL.revokeObjectURL(c.url);
       c.photo=photo;c.key=null;preview.src=c.url=URL.createObjectURL(photo);preview.hidden=false;
-      take.textContent="צילום מחדש";send.hidden=false;say("בדקו שכל הפתרון ברור, ואז שלחו את התשובה.");
+      take.textContent="צילום מחדש";take.classList.remove("solid");send.hidden=false;say("בדקו שכל הפתרון ברור, ואז שלחו למחשב.");send.focus();
     }catch(error){say("לא ניתן להכין את התמונה. נסו לצלם שוב.");}
     finally{if(valid())controls(false);}
   };
-  const success=()=>{say("התשובה הועלתה בהצלחה ומצורפת לשאלה במחשב.");take.hidden=send.hidden=confirm.hidden=renew.hidden=true;c.photo=null;if(valid())pollInbox(e);};
+  const success=()=>{c.photo=null;finish("✓ התשובה נשלחה למחשב.");};
   send.onclick=async()=>{
     if(!c.photo||c.busy)return;
     controls(true);say(states.uploading);
     try{
+      await confirmed();if(!valid())return;
       c.key=c.key||crypto.randomUUID();
       let b=await post(`/api/math/answer-scans/${c.result.scan.id}/uploads`,{key:c.key});if(!valid())return;
       if(b.attachment){success();return;}
@@ -216,17 +239,86 @@ function openCapture(result){
       if(!valid())return;say(error.message+" התמונה נשמרה לתצוגה מקדימה. אפשר לנסות שוב.");
       if(error.status===410||error.code==="superseded")expired();
       // Reuse the key after an uncertain response; the server returns prior success.
-    }finally{if(valid())controls(false);}
+    }finally{if(valid()&&!c.ended)controls(false);}
+  };
+  decline.onclick=async()=>{
+    controls(true);
+    try{await post(`/api/math/answer-scans/${c.result.scan.id}/decline`);if(!valid())return;finish("סירבתם לבקשה. המחשב קיבל הודעה.");}
+    catch(error){if(!valid())return;if(error.code==="superseded"||error.status===404)finish("הבקשה כבר לא פעילה.");else say(error.message);}
+    finally{if(valid()&&!c.ended)controls(false);}
   };
   renew.onclick=async()=>{
     controls(true);
     try{const r=await post(`/api/math/answer-attempts/${c.result.attempt.id}/scans`,{renew:true});if(!valid())return;
-      c.result=r;c.key=null;renew.hidden=true;confirm.hidden=false;say("נוצרה בקשה חדשה. האם לצלם תשובה לשאלה הזו?");}
+      c.result=r;c.key=null;c.confirming=null;renew.hidden=true;take.hidden=false;node.querySelector(".mx-scan-code").outerHTML=codeHTML(r.scan.code);
+      say("נוצרה בקשה חדשה עם מספר חדש. אפשר לצלם.");}
     catch(error){say(error.message);}
     finally{if(valid())controls(false);}
   };
   if(result.scan.state==="expired")expired();
-  node.querySelector("[data-close]").focus();
+  if(navigator.vibrate)try{navigator.vibrate([60,40,60]);}catch{}
+  take.focus();
+}
+
+/* ---------- the computer: waiting for the phone ---------- */
+/* A window with the request's 4-digit code until the phone answers. Resolves with the attempt's last result (photo
+   received, declined, expired or withdrawn here), or null when the account changed. `scanTo`: the body for a new
+   request ({question_id} when it belongs to a question). */
+function closeWait(){ if(waiting){clearTimeout(waiting.timer);waiting.node.remove();waiting.returnFocus?.focus?.({preventScroll:true});const done=waiting.done;waiting=null;done(null);} }
+function waitForPhone(result,scanTo={}){
+  closeWait();const e=epoch;
+  if(!live(e))return Promise.resolve(null);
+  return new Promise(done=>{
+    const node=document.createElement("div");node.className="mx-scan-overlay mx-scan-wait";node.setAttribute("role","dialog");node.setAttribute("aria-modal","true");node.setAttribute("aria-labelledby","waitTitle");
+    node.innerHTML=`<div class="mx-scan-card">
+      <h2 id="waitTitle"><span aria-hidden="true">📱</span> צילום בטלפון</h2>
+      <p data-say>פתחו את Mathly בטלפון, באותו חשבון. יקפוץ שם חלון עם המספר הזה:</p>
+      <div data-code></div>
+      <p class="mx-scan-live" data-status role="status" aria-live="polite"><span class="mx-scan-dot" aria-hidden="true"></span><span data-text>ממתינים לטלפון…</span></p>
+      <div class="mx-scan-actions">
+        <button class="mx-btn solid" data-again hidden>בקשה חדשה</button>
+        <button class="mx-btn" data-cancel>ביטול הבקשה</button>
+        <button class="mx-btn" data-done hidden>סגירה</button>
+      </div></div>`;
+    const w=waiting={node,timer:null,result,returnFocus:document.activeElement,done:r=>done(r)};(visibleRoot||document.body).append(node);
+    const $=sel=>node.querySelector(sel);
+    const valid=()=>waiting===w&&live(e);
+    const end=r=>{ if(waiting!==w)return; clearTimeout(w.timer);node.remove();waiting=null;w.returnFocus?.focus?.({preventScroll:true});done(r); };
+    let shown=null;
+    const paint=()=>{
+      const r=w.result,st=r.scan?.state,got=!!r.attachment;
+      if(got){ end(r); return; }
+      if(shown!==r.scan?.id){ shown=r.scan?.id; $("[data-code]").innerHTML=codeHTML(r.scan?.code); }
+      const over=["declined","expired","superseded"].includes(st);
+      const text={waiting:"ממתינים לטלפון…",confirmed:"הטלפון אישר. ממתינים לצילום…",uploading:"מקבלים את התמונה מהטלפון…",failed:"ההעלאה מהטלפון נכשלה. אפשר לנסות שוב בטלפון.",
+        declined:"הבקשה נדחתה בטלפון.",expired:"הבקשה פגה. אפשר ליצור בקשה חדשה.",superseded:"הבקשה הוחלפה."}[st]||"ממתינים לטלפון…";
+      $("[data-text]").textContent=text;
+      node.classList.toggle("is-over",over);node.classList.toggle("is-declined",st==="declined");
+      $("[data-say]").hidden=over;$("[data-code]").hidden=over;
+      $("[data-again]").hidden=$("[data-done]").hidden=!over;$("[data-cancel]").hidden=over||st==="uploading";
+    };
+    const poll=async()=>{
+      clearTimeout(w.timer);if(!valid())return;
+      try{ const r=await json(`/api/math/answer-attempts/${w.result.attempt.id}`);if(!valid())return;w.result=r;paint(); }
+      catch(error){ if(!valid())return;$("[data-text]").textContent=error.message; }
+      if(valid()&&!["declined","expired","superseded"].includes(w.result.scan?.state))w.timer=setTimeout(poll,document.hidden?5000:2000);
+    };
+    $("[data-cancel]").onclick=async()=>{
+      const b=$("[data-cancel]");b.disabled=true;
+      try{ w.result=await post(`/api/math/answer-scans/${w.result.scan.id}/decline`,{});if(!valid())return; }
+      catch(error){ if(!valid())return; }
+      end(w.result);
+    };
+    $("[data-done]").onclick=()=>end(w.result);
+    $("[data-again]").onclick=async()=>{
+      const b=$("[data-again]");b.disabled=true;
+      try{ w.result=await post(`/api/math/answer-attempts/${w.result.attempt.id}/scans`,{...scanTo,renew:true});if(!valid())return;paint();poll(); }
+      catch(error){ if(valid())$("[data-text]").textContent=error.message; }
+      finally{ b.disabled=false; }
+    };
+    node.onkeydown=event=>{ if(event.key==="Escape"){event.preventDefault();event.stopPropagation();} trapTab(node,event); };
+    paint(); if(waiting===w){ $("[data-cancel]").focus(); w.timer=setTimeout(poll,1500); }
+  });
 }
 document.addEventListener("visibilitychange",()=>{
   if(document.hidden)return;
@@ -234,5 +326,5 @@ document.addEventListener("visibilitychange",()=>{
   if(question?.result)pollQuestion(question);
 });
 window.addEventListener("online",()=>{if(account&&inbox)pollInbox(epoch);if(question?.result)pollQuestion(question);});
-window.MathlyAnswers={configure,mountQuestion,closeQuestion,reset};
+window.MathlyAnswers={configure,mountQuestion,closeQuestion,reset,waitForPhone};
 })();

static/math-sky.js

@@ -5,7 +5,8 @@
    comes back for spaced review (`review`, after 1, 3, 7, 14, 30 and 60 days; a miss starts over). A finished skill not practised for
    FADE_DAYS fades until one correct answer brightens it again. GOAL correct answers make a day; days in a row make the
    streak, and one missed day does not break it. Now and then a comet crosses the screen and can be caught for the
-   collection. All of it lives in the student's progress (P, see math.js): run, gold, seen, days, comets, cometDay.
+   collection. All of it lives in the student's progress (P, see math.js): run, gold, seen, days, comets, cometDay, and the
+   misconceptions met along the way (slips, see "misconception patterns").
    Pure rules first, then the drawings (owl, constellations), then the effects (sound, sparkles, overlays). */
 (function(){
 "use strict";
@@ -19,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]={}; if(!Array.isArray(P.comets)) P.comets=[]; return P; }
+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 fading(P,id,now=new Date()){
   if(!P.done?.[id]) return false;
   const t=Date.parse(P.seen?.[id]||P.done[id]);
@@ -53,6 +54,40 @@ function due(P,id,now=new Date()){
   const r=P.review?.[id]; if(r?.due) return r.due<=dayKey(now);
   const t=Date.parse(P.seen?.[id]||P.done[id]); return !isNaN(t)&&now-t>=DAY;
 }
+/* ---------- misconception patterns ----------
+   Every tagged wrong answer is kept in P.slips ({at, id: skill, q: question index, m: mistake tag, via: practice |
+   review | exam}), newest last, at most SLIP_MAX. patterns() reads it: a tag is recurring when it came up at least
+   twice in RECUR_DAYS and once in the last QUIET_DAYS; it has stopped when it once came up twice within RECUR_DAYS,
+   but not in the last QUIET_DAYS, and less than GONE_DAYS ago. */
+const SLIP_MAX=500, RECUR_DAYS=30, QUIET_DAYS=14, GONE_DAYS=60, PATTERNS_SHOWN=3;
+function slip(P,id,q,m,via,now=new Date()){
+  ensure(P); if(!m) return;
+  P.slips.push({at:now.toISOString(),id,q,m,via});
+  if(P.slips.length>SLIP_MAX) P.slips.splice(0,P.slips.length-SLIP_MAX);
+}
+// `mistakes`: the graph's mistakes by tag (for the skill each one sends back to)
+function patterns(P,mistakes={},now=new Date()){
+  const by={};
+  for(const s of P.slips||[]){ const t=Date.parse(s?.at); if(s?.m&&!isNaN(t)&&t<=now) (by[s.m]||=[]).push({t,id:s.id}); }
+  const recurring=[], stopped=[], age=t=>(now-t)/DAY;
+  for(const [m,all] of Object.entries(by)){
+    all.sort((a,b)=>a.t-b.t);
+    const last=all.at(-1).t;
+    if(age(last)>=GONE_DAYS) continue;
+    const recent=all.filter(x=>age(x.t)<RECUR_DAYS);
+    const item=list=>{
+      const count={}, seen={};
+      for(const x of list){ count[x.id]=(count[x.id]||0)+1; seen[x.id]=x.t; }
+      const skills=Object.keys(count).sort((a,b)=>count[b]-count[a]||seen[b]-seen[a]);
+      return {m,n:list.length,skills,last:new Date(last).toISOString(),practise:mistakes[m]?.back||skills[0]};
+    };
+    if(age(last)<QUIET_DAYS){ if(recent.length>=2) recurring.push(item(recent)); }
+    else if(all.some((x,i)=>i>0&&(x.t-all[i-1].t)/DAY<=RECUR_DAYS)) stopped.push(item(all));
+  }
+  const rank=(a,b)=>b.skills.length-a.skills.length||b.n-a.n||b.last.localeCompare(a.last);
+  return {recurring:recurring.sort(rank).slice(0,PATTERNS_SHOWN),stopped:stopped.sort(rank).slice(0,PATTERNS_SHOWN)};
+}
+
 /* 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";
@@ -315,6 +350,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,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,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

@@ -136,9 +136,25 @@ html.math-on, html.math-on body{overflow:hidden}
 .mx-answer{display:flex;flex-direction:column;gap:12px}
 .mx-answer [hidden]{display:none}
 .mx-answer-image{display:block;max-width:100%;max-height:420px;object-fit:contain;border-radius:12px;background:#fff}
-.mx-scan-inbox:empty{display:none}.mx-scan-inbox{display:flex;flex-direction:column;gap:12px;padding-top:24px}
-.mx-scan-inbox .mx-btn{display:flex;flex-direction:column;align-items:flex-start;text-align:start;white-space:normal;gap:8px}
-.mx-scan-overlay{position:fixed;inset:0;z-index:1000;background:#000c;overflow:auto;padding:20px;display:flex;align-items:flex-start;justify-content:center}
+/* photo by phone (static/answer-scans.js): a window on the phone with the request, and one on the computer while it waits;
+   both show the same 4-digit code */
+.mx-scan-overlay{position:fixed;inset:0;z-index:1000;background:#000c;overflow:auto;padding:20px;display:flex;align-items:center;justify-content:center;animation:mx-scan-in .2s ease-out}
+@keyframes mx-scan-in{from{opacity:0;transform:scale(.97)}}
+.mx-scan-card h2{margin:0;font-size:22px}
+.mx-scan-code{display:flex;justify-content:center;gap:10px;margin:2px 0}
+.mx-scan-code span{display:grid;place-items:center;width:58px;height:72px;border-radius:14px;background:#0b0d0e;border:2px solid var(--mx-accent);
+  color:#fff;font:800 40px/1 var(--f-body,system-ui);font-variant-numeric:tabular-nums;box-shadow:0 0 18px color-mix(in srgb,var(--mx-accent) 30%,transparent)}
+.mx-scan-q{padding:10px 12px;border-radius:12px;background:#0b0d0e;border:1px solid #2c3333}
+.mx-scan-actions{display:flex;flex-direction:column;gap:10px}
+.mx-scan-actions .mx-btn{min-height:50px;font-size:17px}
+.mx-btn-quiet{border-color:#485050;color:#d7dcd8}
+.mx-scan-live{display:flex;align-items:center;justify-content:center;gap:10px;font-weight:700}
+.mx-scan-dot{width:10px;height:10px;border-radius:50%;background:var(--mx-accent);animation:sky-pulse 1.4s ease-out infinite}
+.mx-scan-wait.is-over .mx-scan-dot{display:none}
+.mx-scan-wait.is-declined .mx-scan-live{color:var(--amber,#f0b35a)}
+.mx-scan-wait .mx-scan-card{text-align:center}
+.mx-phone-cta{font-size:15px;padding:12px 18px}
+@media (prefers-reduced-motion:reduce){.mx-scan-overlay,.mx-scan-dot{animation:none}}
 .mx-scan-card{background:#141719;color:#f4f2ec;border:1px solid #485050;border-radius:18px;padding:24px;width:min(520px,100%);display:flex;flex-direction:column;gap:14px;line-height:1.6}
 .mx-scan-card p{margin:0}.mx-scan-card [hidden]{display:none}.mx-scan-card small{color:#adb7b1}
 .mx-management,.mx-class-editor form{display:flex;flex-direction:column;gap:16px}
@@ -353,10 +369,10 @@ line.draw{stroke-dasharray:500;stroke-dashoffset:500;animation:sky-draw 1.1s eas
 /* today's goal, above the path; opens the streak calendar */
 .mx-daily{display:flex;flex-direction:column;gap:8px;width:100%;padding:12px 14px;border:1px solid var(--line);border-radius:18px;background:var(--surface);color:var(--ink);font:inherit;text-align:start;cursor:pointer;transition:border-color .15s}
 .mx-daily:hover{border-color:var(--ember)}
-.mx-review{display:flex;flex-direction:column;gap:4px;width:100%;margin-top:10px;padding:12px 14px;border:1px solid var(--line);border-inline-start:4px solid var(--gold);border-radius:18px;background:var(--surface);color:var(--ink);font:inherit;text-align:start;cursor:pointer;transition:border-color .15s}
-.mx-review:hover{border-color:var(--gold)}
+.mx-review,.mx-quiz-card{display:flex;flex-direction:column;gap:4px;width:100%;margin-top:10px;padding:12px 14px;border:1px solid var(--line);border-inline-start:4px solid var(--gold);border-radius:18px;background:var(--surface);color:var(--ink);font:inherit;text-align:start;cursor:pointer;transition:border-color .15s}
+.mx-review:hover,.mx-quiz-card:hover{border-color:var(--gold)}
 #mathView .mx-review-sheet{--uc:var(--starlight)}   /* neutral: a unit colour would give the topic away */
-.mx-review span{color:var(--muted);font-size:13px}.mx-review .mx-dgo{color:var(--gold)}
+.mx-review span,.mx-quiz-card span{color:var(--muted);font-size:13px}.mx-review .mx-dgo,.mx-quiz-card .mx-dgo{color:var(--gold)}
 .mx-daily small{color:var(--muted);font-size:13px}
 .mx-dline{display:flex;align-items:center;gap:8px;font-size:15px}
 .mx-dline b{flex:1;min-width:0}
@@ -402,19 +418,34 @@ button.sky-chip.flame{padding:6px 11px;color:var(--ink)}
 .k-met{background:var(--ember)}.k-saved{background:var(--ice-bg);box-shadow:inset 0 0 0 2px var(--ice)}.k-some{width:6px!important;height:6px!important;background:var(--ember)}
 .mx-examsoon{display:flex;justify-content:space-between;align-items:center;gap:10px;padding:11px 14px;border:1px solid color-mix(in srgb,var(--ember) 50%,var(--line));border-radius:14px;background:var(--ember-bg);color:var(--ink);font-size:15px;text-align:start;cursor:pointer}
 .mx-examsoon span{color:var(--muted);font-size:13px;white-space:nowrap}
-/* one winding trail: start, then each unit's banner and its skills, then the finish; the line is drawn behind */
-.mx-trail{position:relative;display:flex;flex-direction:column;align-items:center;gap:22px;padding-block:6px 10px;--amp:min(90px,22vw)}
-.mx-line{position:absolute;inset:0;width:100%;height:100%;pointer-events:none;overflow:visible}
-.mx-line path{fill:none;stroke:var(--line);stroke-width:7;stroke-linecap:round;stroke-dasharray:1 13}
-.mx-line path.on{stroke:var(--uc,var(--aurora));stroke-dasharray:none;stroke-opacity:.85}
+/* the path: start, then each unit's orbit (and its quiz), then the finish; a dotted line joins them top to bottom */
+.mx-trail{position:relative;display:flex;flex-direction:column;align-items:center;gap:30px;padding-block:6px 10px;container-type:inline-size}
+.mx-trail>:not(:first-child)::before{content:"";position:absolute;bottom:100%;left:50%;width:6px;height:30px;margin-left:-3px;
+  background:radial-gradient(circle,var(--line) 2.6px,transparent 3px) center top/6px 10px repeat-y;pointer-events:none}
 .mx-start,.mx-finish{position:relative;display:flex;flex-direction:column;align-items:center;gap:4px;font:400 15px/1.2 var(--f-display);color:var(--muted)}
 .mx-flag{display:grid;place-items:center;width:64px;height:64px;border-radius:50%;background:var(--surface-2);border:3px solid var(--aurora)}
 .mx-start b{color:var(--aurora)}
 .mx-finish>svg{width:30px;height:30px;fill:var(--dim)}
-.mx-unit{position:relative;width:100%;padding:12px 16px;border-radius:16px;background:var(--surface);border:1px solid color-mix(in srgb,var(--uc) 45%,var(--line));scroll-margin-top:72px}
+/* a unit's orbit: the unit in the middle, its skills around it in order (math.js, pathView) */
+.mx-unit{position:relative;display:flex;flex-direction:column;align-items:center;gap:8px;width:100%;scroll-margin-top:72px}
+.mx-stage{--s:min(400px,100cqw);position:relative;width:var(--s);height:var(--s);margin-block:34px 30px}
+.mx-ring{position:absolute;inset:0;width:100%;height:100%;overflow:visible;pointer-events:none}
+.mx-ring path{fill:none;stroke:var(--line);stroke-width:1.6;stroke-linecap:round;stroke-dasharray:.1 3.2}
+.mx-ring path.on{stroke:var(--uc);stroke-dasharray:none;stroke-opacity:.9}
+.mx-ring .mx-arrow{stroke-width:1.1;stroke-dasharray:none;stroke-linejoin:round;stroke:var(--dim)}
+.mx-ring .mx-arrow.on{stroke:var(--uc)}
+.mx-ring .mx-back{stroke-opacity:.35}
 .mx-uhead{display:flex;align-items:center;gap:4px 10px;flex-wrap:wrap}
-.mx-uhead h2{font-size:20px;color:var(--uc);flex:1;min-width:0}
-.mx-unit.full .mx-uhead h2::after{content:" ✦";color:var(--gold)}
+.mx-hub{position:absolute;left:50%;top:50%;width:calc(var(--s) * .36);aspect-ratio:1;transform:translate(-50%,-50%);border-radius:50%;
+  flex-direction:column;justify-content:center;flex-wrap:nowrap;gap:4px;padding:12px;box-sizing:border-box;text-align:center;
+  background:radial-gradient(circle,color-mix(in srgb,var(--uc) 22%,var(--surface)) 0 calc(100% - 7px),transparent calc(100% - 6px)),
+    conic-gradient(var(--uc) calc(var(--p) * 1%),var(--surface-2) 0);
+  box-shadow:0 6px 0 var(--night-2),0 0 26px color-mix(in srgb,var(--uc) 30%,transparent)}
+.mx-hub h2{font-size:clamp(14px,4.2cqw,18px);line-height:1.15;color:var(--ink);margin:0;overflow-wrap:anywhere}
+.mx-hub .mx-pill{background:color-mix(in srgb,var(--uc) 35%,var(--bg));color:var(--ink)}
+.mx-hub .mx-usub{width:auto;font-size:11.5px}
+.mx-unit.full .mx-hub{box-shadow:0 6px 0 var(--night-2),0 0 30px color-mix(in srgb,var(--gold) 55%,transparent)}
+.mx-unit.full .mx-hub h2::after{content:" ✦";color:var(--gold)}
 /* lesson resources: a teacher opens them from a unit's title (static/math.js, openResources) */
 .mx-uhead.is-teach{cursor:pointer}
 .mx-res-open{border:1px solid color-mix(in srgb,var(--uc) 55%,var(--line));background:var(--bg);color:var(--ink);border-radius:999px;padding:6px 12px;font:600 13px/1 var(--f-body);cursor:pointer;min-height:32px}
@@ -440,7 +471,21 @@ button.sky-chip.flame{padding:6px 11px;color:var(--ink)}
 @media (max-width:380px){.mx-res-kinds{grid-template-columns:1fr}}
 .mx-pill{padding:3px 10px;border-radius:999px;font:700 12px/1.4 var(--f-body);background:color-mix(in srgb,var(--uc) 18%,transparent);color:var(--uc);font-variant-numeric:tabular-nums}
 .mx-usub{width:100%;color:var(--muted);font-size:13px}
-.mx-step{position:relative;display:flex;flex-direction:column;align-items:center;gap:6px;width:150px;transform:translateX(calc(var(--x) * var(--amp)))}
+.mx-step{position:relative;display:flex;flex-direction:column;align-items:center;gap:6px;width:150px}
+/* a skill on the orbit: its centre sits on the ring; the name goes above it in the top part, below it elsewhere */
+.mx-orb{position:absolute;width:0;height:0;gap:0;left:calc(50% + var(--dx) * var(--s) * .34);top:calc(50% + var(--dy) * var(--s) * .34)}
+.mx-orb>.mx-star{position:absolute;left:0;top:0;width:54px;height:54px;transform:translate(-50%,-50%)}
+.mx-orb>.mx-star:active{transform:translate(-50%,calc(-50% + 3px))}
+.mx-orb>.mx-star.st-next{width:64px;height:64px}
+.mx-orb>.mx-lbl{position:absolute;left:0;top:32px;transform:translateX(-50%);width:max-content;max-width:min(112px,28cqw);padding:2px 7px;font-size:12px}
+.mx-orb .mx-perch{top:20px;left:-30px}
+.mx-orb.up>.mx-lbl{top:auto;bottom:32px}
+.mx-orb>.st-next+.mx-lbl{top:38px}.mx-orb.up>.st-next+.mx-lbl{top:auto;bottom:38px}
+.mx-num{position:absolute;top:-6px;right:-6px;min-width:20px;height:20px;padding:0 4px;box-sizing:border-box;border-radius:999px;display:grid;place-items:center;
+  font:700 11.5px/1 var(--f-body);font-variant-numeric:tabular-nums;background:var(--bg);color:var(--muted);border:2px solid var(--line)}
+.mx-star.st-lit .mx-num,.mx-star.st-fading .mx-num{border-color:var(--uc);color:var(--ink)}
+.mx-star.st-gold .mx-num{border-color:var(--gold);color:var(--gold)}
+.mx-star.st-next .mx-num{border-color:var(--aurora);background:var(--aurora);color:var(--on-aurora)}
 .mx-star{position:relative;width:62px;height:62px;padding:0;border-radius:50%;display:grid;place-items:center;cursor:pointer;
   background:var(--surface-2);border:3px solid var(--line);box-shadow:0 5px 0 var(--night-2);transition:transform .15s}
 .mx-star:active{transform:translateY(3px);box-shadow:0 2px 0 var(--night-2)}
@@ -545,3 +590,63 @@ button.sky-chip.flame{padding:6px 11px;color:var(--ink)}
   line.draw{stroke-dashoffset:0}
   .sky-comet{animation:none;left:auto;right:24px;top:30%}
 }
+
+/* the practice exam (math.js, "practice exam"); its card looks like the review's */
+.mx-quiz-card{border-inline-start-color:var(--aurora)}.mx-quiz-card .mx-dgo{color:var(--aurora)}
+.mx-quiz-units{display:flex;flex-wrap:wrap;gap:8px}
+.mx-quiz-units button[aria-pressed="true"]{background:var(--mx-accent);color:var(--mx-on-accent)}
+.mx-quiz-units button[aria-pressed="false"]{opacity:.7}
+.mx-quiz-dots{display:flex;flex-wrap:wrap;gap:6px}
+.mx-quiz-dots button{width:30px;height:30px;border-radius:50%;border:1px solid var(--line);background:var(--surface);color:var(--muted);font:600 13px/1 var(--f-body);cursor:pointer}
+.mx-quiz-dots button.done{border-color:var(--mx-accent);color:var(--ink)}
+.mx-quiz-dots button.now{outline:2px solid var(--gold);outline-offset:2px}
+.mx-quiz-sheet .mx-choices button[aria-pressed="true"]{border-color:var(--gold);background:var(--surface-2);box-shadow:inset 0 0 0 1px var(--gold)}
+.mx-quiz-nav{display:flex;justify-content:space-between;gap:8px;margin-top:4px}
+.mx-quiz-warn{color:var(--amber)}
+.mx-quiz-units-score{display:grid;gap:10px}
+.mx-quiz-units-score div{display:grid;grid-template-columns:1fr auto;gap:4px 8px;align-items:center}
+.mx-quiz-units-score .mx-meter{grid-column:1/-1;height:8px;background:var(--surface-2)}
+.mx-quiz-units-score .mx-meter i{background:var(--aurora)}
+.mx-quiz-plan{display:flex;flex-direction:column;gap:10px;padding-inline-start:20px;margin:0}
+.mx-quiz-plan li{display:flex;flex-direction:column;gap:4px;background:var(--amber-bg);border-radius:12px;padding:10px 12px}
+.mx-quiz-plan li b{color:var(--amber)}
+.mx-quiz-review summary{cursor:pointer;color:var(--muted)}
+.mx-quiz-review ol{display:flex;flex-direction:column;gap:8px;padding-inline-start:20px}
+.mx-quiz-review li{display:flex;flex-direction:column;gap:2px}
+.mx-quiz-review li small{color:var(--dim)}
+.mx-quiz-review li.ok>span:last-child{color:var(--ok)}
+.mx-quiz-review li.bad>span:last-child{color:var(--amber)}
+
+/* the unit quiz (math.js, "unit quiz"): a node at the end of the unit, and a sheet that looks like a paper quiz */
+.mx-uquiz{width:60px;height:60px;padding:0;border-radius:18px;font-size:24px;display:grid;place-items:center;border:2px dashed var(--uc,var(--gold));background:var(--surface);cursor:pointer;box-shadow:0 5px 0 var(--night-2)}
+.mx-uquiz.done{border-style:solid}
+.mx-uq-rules{display:flex;flex-direction:column;gap:6px;padding-inline-start:20px;margin:0;color:var(--ink)}
+.mx-uq-history{display:flex;flex-wrap:wrap;gap:6px;align-items:center}.mx-uq-history h4{width:100%;margin:0}
+.mx-uq-head{position:sticky;top:-16px;z-index:2;display:flex;align-items:center;gap:10px;justify-content:space-between;background:var(--surface);padding:16px 0 6px;margin-top:-16px;border-bottom:1px solid var(--line)}   /* covers the sheet's top padding too */
+.mx-uq-head h3{margin:2px 0 0}
+.mx-uq-clock{font:700 22px/1 var(--f-body);font-variant-numeric:tabular-nums;color:var(--ink);padding:6px 12px;border-radius:999px;background:var(--surface-2);margin-inline-start:auto}
+.mx-uq-clock.low{color:var(--amber)}.mx-uq-clock.over{color:var(--amber);background:var(--amber-bg)}
+.mx-uq-banner{margin:0;color:var(--amber);font-size:14px}.mx-uq-banner:empty{display:none}
+.mx-uq-qs{list-style:none;padding:0;margin:0;display:flex;flex-direction:column;gap:14px}
+.mx-uq-q{background:var(--bg);border-radius:14px;padding:14px;display:flex;flex-direction:column;gap:8px}
+.mx-uq-qhead{display:flex;justify-content:space-between;align-items:baseline}.mx-uq-qhead span{color:var(--muted);font-size:14px}
+.mx-uq-text{margin:0;line-height:1.7}
+.mx-uq-answer{display:flex;flex-direction:column;gap:6px;border-top:1px dashed var(--line);padding-top:8px}
+.mx-uq-img{max-width:100%;max-height:320px;object-fit:contain;border-radius:10px;border:1px solid var(--line);align-self:flex-start}
+.mx-uq-verdict{margin:0;font-weight:700}.mx-uq-verdict.correct{color:var(--ok)}.mx-uq-verdict.partial,.mx-uq-verdict.incorrect,.mx-uq-verdict.none,.mx-uq-verdict.unreadable,.mx-uq-verdict.needs_review{color:var(--amber)}
+
+
+/* misconception patterns: a card on home (after the review) and its sheet */
+.mx-patterns{display:flex;flex-direction:column;gap:4px;width:100%;margin-top:10px;padding:12px 14px;border:1px solid var(--line);border-inline-start:4px solid var(--starlight);border-radius:18px;background:var(--surface);color:var(--ink);font:inherit;text-align:start;cursor:pointer;transition:border-color .15s}
+.mx-patterns:hover{border-color:var(--starlight)}
+.mx-patterns span{color:var(--muted);font-size:13px;overflow-wrap:anywhere}.mx-patterns .mx-dgo{color:var(--starlight)}
+#mathView .mx-patterns-sheet{--uc:var(--starlight)}
+.mx-pattern-list{display:flex;flex-direction:column;gap:10px;margin:12px 0;padding:0;list-style:none}
+.mx-pattern-list li{display:flex;flex-direction:column;align-items:flex-start;gap:6px;padding:12px;border:1px solid var(--line);border-radius:14px;overflow-wrap:anywhere}
+.mx-pattern-list li>span{color:var(--muted);font-size:14px}
+.mx-pattern-list.gone li{opacity:.85;border-style:dashed}
+.mx-patterns-sheet h4{margin:18px 0 0}.mx-pattern-list.gone{margin-top:8px}
+/* a skill that a recurring mistake sends back to: a gold ring on its star and its tag in gold, so it shows on the path */
+.mx-star.fix{box-shadow:0 0 0 3px var(--gold),0 0 14px color-mix(in srgb,var(--gold) 55%,transparent)}
+.mx-lbl.l-fix em{background:var(--gold);color:#2A1B00}
+.mx-pattern-note{display:block;margin-top:6px;padding:8px 10px;border-inline-start:3px solid var(--gold);border-radius:8px;background:color-mix(in srgb,var(--gold) 10%,transparent);color:var(--ink);font-size:13.5px}

static/math.js

@@ -7,9 +7,11 @@
    shuffled each time a question is shown, and a wrong answer does not reveal the right one, so a question that comes
    back is solved again, not remembered. Finished skills come back in a mixed review (see "spaced review" below). Progress is kept on this device, per account (mathly.progress.v1:<email>): `done` per
    skill, and `solved` (indexes answered correctly), `at` (the question to show) and `set` (the round's questions, see round())
-   for skills with a list. */
+   for skills with a list. Every tagged wrong answer is also kept in `slips` (see "misconception patterns" and math-sky.js),
+   so the mistakes that keep coming back across skills can be shown with what to practise. */
 (()=>{
 const css=document.createElement("link"); css.rel="stylesheet"; css.href=document.currentScript.src.replace("math.js","math.css");
+const cssReady=new Promise(done=>{ css.onload=css.onerror=done; });   // until then #mathView is not yet the scrolling box
 document.head.append(css);
 
 const CFG=window.MATHLY||{}, AUTH_URL=CFG.supabaseUrl||"";
@@ -28,7 +30,7 @@ const load=()=>{ try{ return JSON.parse(localStorage.getItem(key())||"{}"); }cat
 const save=()=>{ try{ localStorage.setItem(key(),JSON.stringify(P)); }catch{} };
 
 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="";
-let nav=null, FIRST=true, COMBO=0, REV=null;   // the tab bar; whether the shown question is still at its first try; first-try answers in a row
+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;
 let phonePair=null;
@@ -103,7 +105,7 @@ 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) closeSheet(); });
+    document.addEventListener("keydown",e=>{ if(e.key==="Escape"&&cur) QZ?.items?quizQuit():closeSheet(); });   // an exam asks before it is left
   }
   root.hidden=false;
   if(!G){
@@ -153,7 +155,7 @@ function selectSubject(subject){
 /* The math screens: home (what you gathered and your streak on top, the path below it) and the collection.
    The rules of the stars, the streak and the comets, and their pictures, are in math-sky.js. */
 const Sky=window.MathlySky;
-let VIEW="path", TRAIL=null;   // TRAIL: watches the path's size to redraw its line
+let VIEW="path";
 const SOUND_ON='<svg viewBox="0 0 24 24" aria-hidden="true"><path d="M3 9h4l5-4v14l-5-4H3z"/><path d="M15.5 8.5a5 5 0 0 1 0 7M18 6a8.5 8.5 0 0 1 0 12" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round"/></svg>';
 const SOUND_OFF='<svg viewBox="0 0 24 24" aria-hidden="true"><path d="M3 9h4l5-4v14l-5-4H3z"/><path d="M16 9l5 6M21 9l-5 6" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round"/></svg>';
 const TABS=[["path","בית",'<svg viewBox="0 0 24 24" aria-hidden="true"><path d="M12 3 2.5 11h2.7v9.5h5.3v-6h3v6h5.3V11h2.7Z"/></svg>'],
@@ -260,40 +262,47 @@ function examSoon(){
   return exam&&exam.days<=14?`<button class="mx-examsoon" data-view="sky"><b>המבחן ב${esc(exam.subject)} ${inDays(exam.days)}</b><span>ללוח המבחנים ‹</span></button>`:"";
 }
 
-/* The path: one winding trail from the start through every skill, unit after unit (a banner opens each unit).
-   The nodes sway left and right; trail() then draws the line through their centres, lit up to the last skill done. */
-const SWAY=[0,.55,.9,.55,0,-.55,-.9,-.55];
+/* The path: unit after unit, top to bottom. Each unit is a hub in the middle with its skills orbiting it in order:
+   skill 1 sits at the top and the rest follow clockwise, each numbered, with arrows on the ring between them. A stretch
+   of the ring is lit once the skill it leaves from is done, so the lit ring leads to where to go next. The unit quiz follows the orbit. */
+const ORBIT_R=34;   // the ring's radius, in % of the orbit's width
+const isOn=st=>st==="lit"||st==="gold"||st==="fading";
+function orbitRing(sts){
+  const n=sts.length, a=i=>(-90+360*i/n)*Math.PI/180, pt=(t,r=ORBIT_R)=>[50+r*Math.cos(t),50+r*Math.sin(t)], f=v=>v.toFixed(2);
+  const gap=n>1?Math.min(.32,Math.PI/n*.55):0;   // room left around each node (radians)
+  const arcs=sts.slice(0,-1).map((st,k)=>{
+    const t0=a(k)+gap, t1=a(k+1)-gap, [x0,y0]=pt(t0), [x1,y1]=pt(t1), tm=(a(k)+a(k+1))/2, [mx,my]=pt(tm), deg=tm*180/Math.PI+90;
+    return `<path class="${isOn(st)?"on":""}" d="M${f(x0)} ${f(y0)}A${ORBIT_R} ${ORBIT_R} 0 0 1 ${f(x1)} ${f(y1)}"/>
+      <path class="mx-arrow${isOn(st)?" on":""}" d="M-1.6 -1.9 1.6 0 -1.6 1.9" transform="translate(${f(mx)} ${f(my)}) rotate(${f(deg)})"/>`; }).join("");
+  // the closing stretch, from the last skill back to the first, stays faint: the orbit has a start and an end
+  const back=n>2?(()=>{ const [x0,y0]=pt(a(n-1)+gap), [x1,y1]=pt(a(n)-gap); return `<path class="mx-back" d="M${f(x0)} ${f(y0)}A${ORBIT_R} ${ORBIT_R} 0 0 1 ${f(x1)} ${f(y1)}"/>`; })():"";
+  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");
-  let k=0;
+  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;
-    const steps=ids.map(id=>{ const st=Sky.star(P,id,status(id),id===nxt), tag=st==="next"?"ממשיכים כאן":st==="fading"?"דועך":"";
-      return `<div class="mx-step u-${u.id}" style="--x:${SWAY[k++%SWAY.length]}">
-        <button class="mx-node mx-star st-${st}" data-id="${id}" aria-label="${esc(plain(BY[id].name))}: ${STATE_NAME[st]}">${Sky.spark()}${st==="next"?`<span class="mx-perch">${Sky.owl(34)}</span>`:""}</button>
-        <span class="mx-lbl l-${st}">${fmt(BY[id].short)}${tag?`<em>${tag}</em>`:""}</span></div>`; }).join("");
+    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 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>
+        <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
-    return `<section class="mx-unit u-${u.id}${unitDone(u)?" full":""}" id="mx-unit-${u.id}"><div class="mx-uhead${teach?" is-teach":""}"${res}>
-      <h2>${esc(u.name)}</h2><span class="mx-pill">${lit}/${act.length}</span>${u.when?`<span class="mx-usub">${esc(u.when)}</span>`:""}
-      ${teach?`<button class="mx-res-open"${res} aria-label="משאבי השיעור ${esc(u.name)}">📷 משאבים</button>`:""}</div></section>${steps}`;
+    const pct=act.length?Math.round(100*lit/act.length):0;
+    return `<section class="mx-unit mx-orbit u-${u.id}${full?" full":""}" id="mx-unit-${u.id}">
+      <div class="mx-stage">${orbitRing(sts)}
+        <div class="mx-uhead mx-hub${teach?" is-teach":""}"${res} style="--p:${pct}">
+          <h2>${esc(u.name)}</h2><span class="mx-pill">${lit}/${act.length}</span>${u.when?`<span class="mx-usub">${esc(u.when)}</span>`:""}</div>
+        ${steps}</div>
+      ${teach?`<button class="mx-res-open"${res} aria-label="משאבי השיעור ${esc(u.name)}">📷 משאבים</button>`:""}</section>${quizStep(u)}`;
   }).join("");
-  return `${topBar()}${daily()}${reviewCard()}${examSoon()}<div class="mx-pghead"><h2>המסלול שלי</h2><p class="mx-sub">אלגברה וגאומטריה כיתה ט׳ · 5 יח״ל${cls}</p></div>
-    <div class="mx-trail"><svg class="mx-line" aria-hidden="true"></svg>
+  return `${topBar()}${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>
-    <p class="mx-note">כל השיעורים פתוחים. כוכב נדלק כשעונים נכון על כל השאלות של המיומנות, והופך לזהב אחרי ${3} תשובות נכונות ברצף (או כל השאלות, כשיש פחות). כוכב שלא תרגלו ${Sky.FADE_DAYS} יום דועך, ותשובה נכונה אחת מחזירה לו את האור. ההתקדמות נשמרת במכשיר הזה.</p>`;
-}
-// the trail's line: a smooth curve from the start through each node to the finish; a stretch is lit once the skill it reaches is done
-function trail(box){
-  if(!box?.isConnected) return;
-  const svg=box.querySelector(".mx-line"), at=box.getBoundingClientRect(), W=box.clientWidth, H=box.scrollHeight;
-  const mid=el=>{ const r=el.getBoundingClientRect(); return [r.left+r.width/2-at.left,r.top+r.height/2-at.top]; };
-  const pts=[box.querySelector(".mx-start .mx-flag"),...box.querySelectorAll(".mx-star"),box.querySelector(".mx-finish svg")].map(el=>({p:mid(el),el}));
-  const f=n=>n.toFixed(1);
-  svg.setAttribute("viewBox",`0 0 ${W} ${H}`);
-  svg.innerHTML=pts.slice(1).map(({p:[x1,y1],el},i)=>{ const [x0,y0]=pts[i].p, my=(y0+y1)/2, st=el.classList;
-    const on=st.contains("st-lit")||st.contains("st-gold")||st.contains("st-fading"), u=el.closest(".mx-step")?.className.match(/u-\w+/)?.[0]||"";
-    return `<path class="${u}${on?" on":""}" d="M${f(x0)} ${f(y0)}C${f(x0)} ${f(my)} ${f(x1)} ${f(my)} ${f(x1)} ${f(y1)}"/>`; }).join("");
+    <p class="mx-note">כל השיעורים פתוחים. בכל יחידה המיומנויות מסודרות סביבה לפי הסדר, מ־1 למעלה ועם כיוון השעון. כוכב נדלק כשעונים נכון על כל השאלות של המיומנות, והופך לזהב אחרי ${3} תשובות נכונות ברצף (או כל השאלות, כשיש פחות). כוכב שלא תרגלו ${Sky.FADE_DAYS} יום דועך, ותשובה נכונה אחת מחזירה לו את האור. ההתקדמות נשמרת במכשיר הזה.</p>`;
 }
 
 function collectionView(){
@@ -314,15 +323,15 @@ function collectionView(){
 function draw(){
   Sky.ensure(P);
   path.innerHTML=VIEW==="sky"?collectionView():pathView();
-  TRAIL?.disconnect(); TRAIL=null;
-  if(VIEW==="path"){ const box=path.querySelector(".mx-trail"); TRAIL=new ResizeObserver(()=>trail(box)); TRAIL.observe(box); }
   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>`;
 }
 function setView(view,unit){
   VIEW=view; draw(); root.scrollTop=0;
   const target=view!=="path"?null:unit?root.querySelector(`#mx-unit-${CSS.escape(unit)}`):root.querySelector(".mx-star.st-next")||root.querySelector(".mx-star.st-open");
-  if(target) target.scrollIntoView({block:unit?"start":"center"});
+  if(!target) return;
+  target.scrollIntoView({block:unit?"start":"center"});
+  cssReady.then(()=>{ if(VIEW===view&&target.isConnected) target.scrollIntoView({block:unit?"start":"center"}); });
 }
 function showComet(cid){
   const c=Sky.COMETS.find(x=>x.id===cid), have=P.comets.includes(cid);
@@ -367,7 +376,7 @@ function open(id){
   curQ=r.includes(P.at[id])?P.at[id]:r[0];
   const q=all[curQ], openEnded=q.type==="open-ended", got=solvedOf(id), gotN=r.filter(i=>got.has(i)).length;
   if(!cur) back=document.activeElement;
-  cur=id; FIRST=true; REV=null;
+  cur=id; FIRST=true; REV=null; stopQuizClock(); QZ=null; stopUnitQuiz();
   sheet.innerHTML=`<div class="mx-scrim" data-act="close"></div>
     <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>':""}
@@ -385,7 +394,7 @@ function open(id){
   sheet.querySelector(".mx-x").focus({preventScroll:true});
   if(openEnded&&st!=="off")window.MathlyAnswers?.mountQuestion(sheet.querySelector(".mx-answer"),id,s.question_version);
 }
-function closeSheet(){ stopPhone(); dropResources(); cancelAdvance(); REV=null; if(sheet)sheet.hidden=true; cur=null; back?.focus?.({preventScroll:true}); back=null; }
+function closeSheet(){ stopPhone(); dropResources(); 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){
@@ -403,6 +412,7 @@ function autoAdvance(id,target){
 
 function answer(btn){
   if(btn.disabled) return;
+  if(QZ) return quizPick(btn);
   if(REV) return reviewAnswer(btn);
   const id=cur, m=btn.dataset.m, fb=sheet.querySelector(".mx-fb"), n=round(id).length, qi=curQ;
   const buttons=sheet.querySelectorAll("[data-choice]");
@@ -443,7 +453,7 @@ function answer(btn){
     return;
   }
   // a mistake is quiet: no sound, no vibration, and words about the mistake, not about the student
-  Sky.wrong(P,id); FIRST=false; COMBO=0;
+  Sky.wrong(P,id); Sky.slip(P,id,qi,m,"practice"); FIRST=false; COMBO=0;
   const missed=new Set(P.missed[id]||[]); missed.add(qi); P.missed[id]=[...missed];
   save();
   const M=G.mistakes[m], to=M.back&&M.back!==id?M.back:null;
@@ -452,7 +462,8 @@ function answer(btn){
   if(n>1) buttons.forEach(b=>b.disabled=true); else btn.disabled=true;
   fb.innerHTML=`<div class="mx-bad"><small class="mx-small">טעות נפוצה, וטוב שהיא עולה עכשיו</small><b>${fmt(M.name)}</b><span>${fmt(M.tip)}</span>
     ${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>"}</div>`;
+    ${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>`;
 }
 
 /* ---------- spaced review ----------
@@ -468,6 +479,49 @@ function reviewCard(){
     <span>${n===1?"מיומנות אחת מחכה":`${n} מיומנויות מחכות`} לחזרה. ${Math.min(n,REVIEW_SIZE)} שאלות מנושאים שונים, מעורבבות, כדי שמה שלמדתם יישאר.</span>
     <span class="mx-dgo">להתחיל ‹</span></button>`;
 }
+/* ---------- misconception patterns ----------
+   The mistakes that keep coming back, across skills (Sky.patterns over P.slips): a card on home, and a sheet with what
+   to practise for each. The words are about the mistake, never about the student; a pattern that stopped is a win. */
+function myPatterns(){
+  const known=x=>G.mistakes[x.m]&&BY[x.practise], {recurring,stopped}=Sky.patterns(P,G.mistakes);
+  return {recurring:recurring.filter(known),stopped:stopped.filter(known)};
+}
+// after a mistake: a line when this mistake is now a recurring one, with its skill to strengthen (unless offered already)
+function patternNote(m,offered=[]){
+  const x=myPatterns().recurring.find(x=>x.m===m); if(!x) return "";
+  return `<span class="mx-pattern-note">הטעות הזו חזרה ${timesWord(x.n)} ${inSkills(x.skills.length)} בחודש האחרון. כדאי לחזק את הבסיס שלה, והיא תיעלם גם בשאר הנושאים.</span>
+    ${offered.includes(x.practise)?"":`<button class="mx-btn" data-id="${x.practise}">לחזק: ${fmt(BY[x.practise].short)}</button>`}`;
+}
+const inSkills=k=>k===1?"במיומנות אחת":`ב־${k} מיומנויות`;
+const timesWord=n=>n===1?"פעם אחת":`${n} פעמים`;
+const daysAgo=iso=>{ const d=Math.round((Date.parse(Sky.dayKey())-Date.parse(Sky.dayKey(new Date(iso))))/86400000); return d<=0?"היום":d===1?"אתמול":`לפני ${d} ימים`; };
+function patternsCard(){
+  const {recurring,stopped}=myPatterns(), top=recurring[0];
+  if(!top&&!stopped.length) return "";
+  const say=top?`${fmt(G.mistakes[top.m].name)}: חזר ${timesWord(top.n)} ${inSkills(top.skills.length)} לאחרונה. כדאי לחזק.`
+    :`${fmt(G.mistakes[stopped[0].m].name)}: הדפוס הזה כבר לא חוזר. התיקון עבד!`;
+  return `<button class="mx-patterns" data-act="patterns"><b>דפוסים שחוזרים</b><span>${say}</span>
+    <span class="mx-dgo">${top?"מה לחזק ‹":"לראות ‹"}</span></button>`;
+}
+function showPatterns(){
+  const {recurring,stopped}=myPatterns();
+  const row=x=>{ const M=G.mistakes[x.m];
+    return `<li><b>${fmt(M.name)}</b><span>${fmt(M.tip)}</span>
+      <small class="mx-small">${timesWord(x.n)} ${inSkills(x.skills.length)} · לאחרונה ${daysAgo(x.last)}</small>
+      <button class="mx-btn solid" data-id="${x.practise}">לחזק: ${fmt(BY[x.practise].short)}</button></li>`; };
+  if(!cur) back=document.activeElement;
+  cur="patterns";
+  sheet.innerHTML=`<div class="mx-scrim" data-act="close"></div><div class="mx-sheet mx-patterns-sheet" role="dialog" aria-modal="true" aria-labelledby="mxTitle">
+    <div class="mx-shtop"><div><h3 id="mxTitle">דפוסים שחוזרים</h3><small class="mx-src">טעויות שחזרו בחודש האחרון, גם בנושאים שונים.</small></div>
+      <button class="mx-x" data-act="close" aria-label="סגירה">✕</button></div>
+    ${recurring.length?`<ol class="mx-pattern-list">${recurring.map(row).join("")}</ol>
+      <p class="mx-small">טעות שחוזרת היא רמז למה שכדאי לחזק. כשמתרגלים את הבסיס שלה, היא נעלמת גם בשאר הנושאים.</p>`
+      :"<p>כרגע אין טעות שחוזרת. כל הכבוד!</p>"}
+    ${stopped.length?`<h4>דפוסים שנעלמו</h4><ul class="mx-pattern-list gone">${stopped.map(x=>`<li><b>${fmt(G.mistakes[x.m].name)}</b>
+      <small class="mx-small">לא חזר כבר ${daysAgo(x.last).replace("לפני ","")}. התיקון עבד!</small></li>`).join("")}</ul>`:""}</div>`;
+  sheet.hidden=false; sheet.querySelector(".mx-sheet").scrollTop=0;
+  sheet.querySelector(".mx-x").focus({preventScroll:true});
+}
 // the oldest due skills, one per unit first, in a mixed order; a random multiple-choice question of each
 function startReview(){
   const due=dueReviews(), pick=[], units=new Set();
@@ -476,7 +530,7 @@ function startReview(){
   if(!pick.length) return;
   const items=shuffled(pick).map(id=>{ const qs=QS(BY[id]).map((q,i)=>i).filter(i=>QS(BY[id])[i].choices); return {id,qi:qs[Math.floor(Math.random()*qs.length)]}; });
   if(!cur) back=document.activeElement;
-  REV={items,i:0,right:0}; openReview();
+  stopQuizClock(); QZ=null; REV={items,i:0,right:0}; openReview();
 }
 function openReview(){
   cancelAdvance();
@@ -508,11 +562,11 @@ function reviewAnswer(btn){
     rewards(id,{r,lit:false,unitWas:true});
     return;
   }
-  Sky.wrong(P,id); save(); draw();
+  Sky.wrong(P,id); Sky.slip(P,id,it.qi,m,"review"); save(); draw();
   const M=G.mistakes[m];
   fb.innerHTML=`<div class="mx-bad"><small class="mx-small">הנושא: ${fmt(s.name)}</small><b>${fmt(M.name)}</b><span>${fmt(M.tip)}</span>
     <span class="mx-small">שכחה היא חלק מהלמידה. הנושא יחזור מחר.</span>${go}
-    <button class="mx-btn" data-id="${id}">לתרגל את ${fmt(s.short)}</button></div>`;
+    <button class="mx-btn" data-id="${id}">לתרגל את ${fmt(s.short)}</button>${patternNote(m,[id])}</div>`;
 }
 function reviewNext(){
   if(REV.i+1<REV.items.length){ REV.i++; return openReview(); }
@@ -523,9 +577,390 @@ function reviewNext(){
   REV=null;
 }
 
+/* ---------- practice exam ----------
+   Like the real thing: questions from several units, mixed, the skill's name hidden, no feedback until it is handed in.
+   It covers what the schedule taught before the class's next exam (or before this month, without one); the student can
+   change the units. The report counts the answers per unit, names the three mistakes to work on with their skills, and
+   brings the finished skills that went wrong back to today's review. Nothing on the path is locked by it.
+   The results are kept in P.quizzes (newest last). */
+const QUIZ_SIZE=12, QUIZ_MIN_PER_Q=3.5;   // a relaxed pace: minutes per question, shown, never enforced
+const SCHOOL_MONTHS=["ספטמבר","אוקטובר","נובמבר","דצמבר","ינואר","פברואר","מרץ","אפריל","מאי","יוני","יולי","אוגוסט"];
+const schoolMonth=d=>(d.getMonth()+4)%12;   // September is 0
+const skillMonth=id=>{ const m=String(BY[id].month||"").split("–")[0].trim(); const i=SCHOOL_MONTHS.indexOf(m); return i<0?99:i; };
+// the exam the practice prepares for: the class's next one within a month, if any
+const quizExam=()=>{ const e=typeof nextExam==="function"?nextExam():null; return e&&e.days<=30?e:null; };
+function quizUnits(){
+  const exam=quizExam(), until=exam?schoolMonth(examDate(exam.date)):schoolMonth(new Date());
+  const units=mineUnits().map(u=>({u,ids:unitIds(u).filter(id=>live(id)&&choiceSkill(id))})).filter(x=>x.ids.length);
+  let on=units.filter(x=>x.ids.some(id=>skillMonth(id)<until));
+  if(!on.length) on=units.filter(x=>x.ids.some(id=>skillMonth(id)<=until));   // the first month of the year
+  const offered=units.filter(x=>x.ids.some(id=>skillMonth(id)<=until));   // taught by then; the exam's own month may be added
+  return {exam,offered,on:new Set(on.map(x=>x.u.id))};
+}
+function quizCard(){
+  const {exam,on}=quizUnits(); if(!on.size) return "";
+  const last=(P.quizzes||[]).at(-1);
+  return `<button class="mx-quiz-card" data-act="quiz"><b>מבחן תרגול${exam?` לקראת המבחן ${inDays(exam.days)}`:""}</b>
+    <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();
+  if(!cur) back=document.activeElement;
+  cur="quiz"; QZ={setup:true,on,offered};
+  sheet.innerHTML=`<div class="mx-scrim" data-act="close"></div>
+    <div class="mx-sheet mx-quiz-sheet" role="dialog" aria-modal="true" aria-labelledby="mxTitle">
+      <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>
+      <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>`;
+  sheet.hidden=false; sheet.querySelector(".mx-x").focus({preventScroll:true});
+}
+function quizToggle(uid){
+  if(!QZ?.setup) return;
+  QZ.on.has(uid)?QZ.on.delete(uid):QZ.on.add(uid);
+  sheet.querySelector(`[data-quiz-unit="${CSS.escape(uid)}"]`).setAttribute("aria-pressed",QZ.on.has(uid));
+  sheet.querySelector("[data-act=quiz-start]").disabled=!QZ.on.size;
+}
+// questions from the chosen units in proportion to their skills: the units take turns, each turn a skill not used yet
+function quizStart(){
+  const units=QZ.offered.filter(x=>QZ.on.has(x.u.id)).map(x=>({u:x.u,ids:shuffled(x.ids)}));
+  const total=units.reduce((n,x)=>n+x.ids.length,0), items=[], used=new Set();
+  const share=units.map(x=>({...x,want:Math.max(1,Math.round(QUIZ_SIZE*x.ids.length/total)),k:0}));
+  for(let turn=0;items.length<QUIZ_SIZE&&turn<QUIZ_SIZE*4;turn++){
+    for(const x of share){
+      if(items.length>=QUIZ_SIZE||x.k>=x.want) continue;
+      const id=x.ids[x.k%x.ids.length], qs=QS(BY[id]).map((q,i)=>i).filter(i=>QS(BY[id])[i].choices&&!used.has(`${id}:${i}`));
+      if(!qs.length){ x.k++; continue; }
+      const qi=qs[Math.floor(Math.random()*qs.length)]; used.add(`${id}:${qi}`); items.push({id,qi,pick:null}); x.k++;
+    }
+    if(share.every(x=>x.k>=x.want)) share.forEach(x=>x.want++);   // rounding left room: one more for each, in turn
+  }
+  QZ={items:shuffled(items),i:0,started:Date.now(),units:units.map(x=>x.u.id)};
+  quizShow();
+  QZ.clock=setInterval(quizTick,1000);
+}
+function stopQuizClock(){ if(QZ?.clock) clearInterval(QZ.clock); }
+const mmss=ms=>{ const s=Math.floor(ms/1000); return `${Math.floor(s/60)}:${String(s%60).padStart(2,"0")}`; };
+function quizTick(){ const el=sheet.querySelector(".mx-quiz-clock"); if(el&&QZ?.started) el.textContent=mmss(Date.now()-QZ.started); }
+function quizShow(){
+  const {items,i}=QZ, it=items[i], q=QS(BY[it.id])[it.qi], last=i===items.length-1;
+  if(!it.order) it.order=shuffled(q.choices.map((_,k)=>k));   // the same order when coming back to a question
+  sheet.innerHTML=`<div class="mx-scrim"></div>
+    <div class="mx-sheet mx-quiz-sheet" role="dialog" aria-modal="true" aria-labelledby="mxTitle">
+      <div class="mx-shtop"><div><span class="mx-uchip">מבחן תרגול</span><h3 id="mxTitle">שאלה ${i+1} מתוך ${items.length}</h3>
+        <small class="mx-src">⏱ <span class="mx-quiz-clock">${mmss(Date.now()-QZ.started)}</span></small></div>
+        <button class="mx-x" data-act="quiz-quit" aria-label="יציאה מהמבחן">✕</button></div>
+      <div class="mx-quiz-dots">${items.map((x,k)=>`<button data-quiz-go="${k}" class="${x.pick!=null?"done":""}${k===i?" now":""}" aria-label="שאלה ${k+1}${x.pick!=null?", נענתה":""}">${k+1}</button>`).join("")}</div>
+      <div class="mx-q"><p>${fmt(q.question)}</p>${figures(q)}
+        <div class="mx-choices">${it.order.map(k=>{ const c=q.choices[k]; return `<button data-choice="${k}" data-m="${c.correct?"":esc(c.mistake)}"${c.correct?" data-right":""} aria-pressed="${it.pick===k}">${fmt(c.text)}</button>`; }).join("")}</div></div>
+      <div class="mx-quiz-nav"><button class="mx-btn" data-act="quiz-prev"${i?"":" disabled"}>הקודמת</button>
+        ${last?`<button class="mx-btn solid" data-act="quiz-submit">הגשה</button>`:`<button class="mx-btn solid" data-act="quiz-next">הבאה</button>`}</div></div>`;
+  sheet.hidden=false; sheet.querySelector(".mx-sheet").scrollTop=0;
+}
+// a choice is only marked; it can be changed until the exam is handed in
+function quizPick(btn){
+  if(!QZ?.items) return;
+  const it=QZ.items[QZ.i]; it.pick=+btn.dataset.choice;
+  sheet.querySelectorAll("[data-choice]").forEach(b=>b.setAttribute("aria-pressed",b===btn));
+  sheet.querySelector(`[data-quiz-go="${QZ.i}"]`).classList.add("done");
+  Sky.sound.tap();
+}
+function quizGo(k){ if(!QZ?.items) return; QZ.i=Math.max(0,Math.min(QZ.items.length-1,k)); quizShow(); }
+function quizSubmit(){
+  const left=QZ.items.filter(x=>x.pick==null).length;
+  if(left&&!QZ.sure){
+    QZ.sure=true;
+    const nav=sheet.querySelector(".mx-quiz-nav");
+    nav.insertAdjacentHTML("beforebegin",`<p class="mx-small mx-quiz-warn">${left===1?"שאלה אחת לא נענתה":`${left} שאלות לא נענו`}. אפשר לחזור אליהן במספרים למעלה, או ללחוץ שוב על הגשה.</p>`);
+    return;
+  }
+  stopQuizClock();
+  const items=QZ.items, ms=Date.now()-QZ.started, now=new Date().toISOString();
+  const res=items.map(x=>{ const q=QS(BY[x.id])[x.qi], c=x.pick==null?null:q.choices[x.pick]; return {...x,q,ok:!!c?.correct,mistake:c&&!c.correct?c.mistake:null}; });
+  const right=res.filter(r=>r.ok).length;
+  // answering counts like practice: right answers go to today's goal, and a finished skill that went wrong is reviewed today
+  for(const r of res){
+    if(r.ok){ Sky.ensure(P); const k=Sky.dayKey(); P.days[k]=(P.days[k]||0)+1; }
+    else if(P.done[r.id]){ Sky.ensure(P); P.review[r.id]={box:0,due:Sky.dayKey()}; }
+    if(r.mistake) Sky.slip(P,r.id,r.qi,r.mistake,"exam",new Date(now));
+  }
+  const mistakes={}; res.filter(r=>r.mistake).forEach(r=>{ (mistakes[r.mistake]??={n:0,ids:new Set()}).n++; mistakes[r.mistake].ids.add(r.id); });
+  const skipped=res.filter(r=>r.pick==null).map(r=>r.id);
+  const top=Object.entries(mistakes).sort((a,b)=>b[1].n-a[1].n).slice(0,3);
+  const weak=[...new Set([...top.flatMap(([,m])=>[...m.ids]),...skipped])];
+  (P.quizzes=P.quizzes||[]).push({at:now,n:items.length,right,ms,units:QZ.units,weak}); P.quizzes=P.quizzes.slice(-20);
+  save(); draw();
+  const perUnit=QZ.units.map(uid=>{ const u=G.units.find(x=>x.id===uid), rs=res.filter(r=>BY[r.id].unit===uid); return {u,n:rs.length,ok:rs.filter(r=>r.ok).length}; }).filter(x=>x.n);
+  const plan=top.length?top.map(([k,m])=>{ const M=G.mistakes[k]; return `<li><b>${fmt(M.name)}</b>${m.n>1?` <small>(${m.n} פעמים)</small>`:""}<span>${fmt(M.tip)}</span>
+      <span class="mx-chips">${[...m.ids].map(id=>`<button class="mx-btn" data-id="${id}">לתרגל: ${fmt(BY[id].short)}</button>`).join("")}</span></li>`; }).join(""):"";
+  QZ={done:true};
+  sheet.innerHTML=`<div class="mx-scrim" data-act="close"></div>
+    <div class="mx-sheet mx-quiz-sheet" role="dialog" aria-modal="true" aria-labelledby="mxTitle">
+      <div class="mx-shtop"><div><span class="mx-uchip">מבחן תרגול</span><h3 id="mxTitle">${right} מתוך ${items.length} נכונות</h3>
+        <small class="mx-src">⏱ ${mmss(ms)}${skipped.length?` · ${skipped.length} בלי תשובה`:""}</small></div>
+        <button class="mx-x" data-act="close" aria-label="סגירה">✕</button></div>
+      <div class="mx-quiz-units-score">${perUnit.map(x=>`<div><span>${esc(x.u.name)}</span><b>${x.ok}/${x.n}</b><span class="mx-meter" aria-hidden="true"><i style="width:${Math.round(100*x.ok/x.n)}%"></i></span></div>`).join("")}</div>
+      ${plan?`<h4>${top.length===1?"דבר אחד":top.length===2?"שני דברים":"שלושה דברים"} לחזק עד המבחן</h4><ol class="mx-quiz-plan">${plan}</ol>
+        <p class="mx-small">מיומנויות שכבר סיימתם וטעיתם בהן חוזרות היום לחזרה המעורבת.</p>`
+        :right===items.length?"<p>הכול נכון. ממשיכים לתרגל קצת כל יום, וזה יישאר.</p>":""}
+      <details class="mx-quiz-review"><summary>כל השאלות והתשובות</summary><ol>${res.map(r=>{ const c=r.q.choices.find(c=>c.correct), mine=r.pick==null?null:r.q.choices[r.pick];
+        return `<li class="${r.ok?"ok":"bad"}"><span>${fmt(r.q.question)}</span><small>${esc(plain(BY[r.id].short))}</small>
+          ${r.ok?`<span>✓ ${fmt(c.text)}</span>`:`<span>${mine?`ענית: ${fmt(mine.text)}`:"בלי תשובה"} · נכון: ${fmt(c.text)}</span>`}</li>`; }).join("")}</ol></details>
+      <div class="mx-quiz-nav"><button class="mx-btn" data-act="quiz">מבחן תרגול חדש</button><button class="mx-btn solid" data-act="close">חזרה למסלול</button></div></div>`;
+  sheet.querySelector(".mx-x").focus({preventScroll:true});
+  if(right/items.length>=.8) Sky.sound.goal();
+}
+function quizQuit(){
+  if(!QZ?.items) return closeSheet();
+  if(QZ.items.every(x=>x.pick==null)||QZ.quitting) return closeSheet();
+  QZ.quitting=true;
+  sheet.querySelector(".mx-quiz-nav").insertAdjacentHTML("beforebegin",'<p class="mx-small mx-quiz-warn">לצאת? התשובות במבחן הזה לא יישמרו. לחצו שוב על ✕ כדי לצאת.</p>');
+}
+
+/* ---------- unit quiz ----------
+   A unit can end with a summarizing quiz (unit.quiz, app/math_skills.py): open-ended questions with points, and a time
+   limit. It is shown like a paper quiz: all the questions at once, a clock counting down, nothing checked until it is
+   handed in. The student writes on paper and photographs each answer (on this device, or from the phone on the same
+   account); when the time is up there are UQ_PHOTO_MIN more minutes to photograph, then it is handed in by itself.
+   After handing in, each answer is checked (the server does not check quiz answers on upload), and the report shows
+   the points per question with feedback and a solution. The sitting is kept in P.uq[unit]: {sitting:{started,
+   attempts, submitted}, history:[{at, score, graded}]} so a reload continues it with the clock still running.
+   The time limit is kept by this page; the server keeps the answers and their checks. */
+const UQ_PHOTO_MIN=10, UQ_BASE="/api/math/answer-attempts";
+const uqState=uid=>((P.uq||={})[uid]||={history:[]});
+const uqReady=u=>!!(u.quiz&&!u.quiz.locked&&CFG.answerScans&&CFG.userId);
+const uqEnds=(u,sit)=>sit.started+u.quiz.minutes*60000;
+function quizStep(u){
+  if(!u.quiz) return "";
+  const st=uqState(u.id), last=st.history.at(-1), going=st.sitting&&!st.sitting.submitted;
+  const tag=going?"בתהליך":last?.score!=null?`${last.score}/100`:last?"הוגש":"";
+  return `<div class="mx-step mx-uquiz-step u-${u.id}"><button class="mx-node mx-uquiz${last?" done":""}" data-uquiz="${u.id}" aria-label="בוחן מסכם: ${esc(u.name)}${tag?`, ${tag}`:""}">📝</button>
+    <span class="mx-lbl">בוחן מסכם${tag?`<em>${tag}</em>`:""}</span></div>`;
+}
+async function uqJson(url,options={}){
+  const r=await api(url,{cache:"no-store",...options}), d=await r.json().catch(()=>({}));
+  if(!r.ok){ const e=Error(UQ_ERRORS[d.detail]||"החיבור נקטע. נסו שוב."); e.code=d.detail; e.status=r.status; throw e; }
+  return d;
+}
+const uqPost=(url,body={})=>uqJson(url,{method:"POST",headers:{"Content-Type":"application/json"},body:JSON.stringify(body)});
+const UQ_ERRORS={question_changed:"הבוחן עודכן. רעננו את העמוד והתחילו מחדש.",image_too_large:"התמונה גדולה מדי. צלמו שוב.",invalid_image:"לא ניתן לקרוא את התמונה. צלמו שוב.",
+  unsupported_image:"בחרו תמונת JPEG, PNG או WebP.",answer_storage_unavailable:"שמירת תשובות אינה זמינה כרגע.",grading_unavailable:"הבדיקה האוטומטית אינה זמינה כרגע.",
+  grading_failed:"הבדיקה נכשלה. התמונה נשמרה; אפשר לנסות שוב.",grading_limit:"הגעתם למכסת הבדיקות היומית. נסו שוב מחר.",grading_busy:"כבר מתבצעות בדיקות. נסו שוב בעוד רגע.",
+  upload_in_progress:"העלאה כבר מתבצעת. רגע…",open_ended_locked:"בוחנים פתוחים סגורים כרגע באתר.",sign_in_required:"יש להיכנס לחשבון."};
+function stopUnitQuiz(){ if(UQ){ clearInterval(UQ.clock); clearTimeout(UQ.poll); Object.values(UQ.images||{}).forEach(URL.revokeObjectURL); } UQ=null; }
+// the intro: what the quiz is and how it works, the last results, and start / continue
+function uqIntro(uid){
+  const u=G.units.find(x=>x.id===uid), q=u.quiz, st=uqState(uid), sit=st.sitting, going=sit&&!sit.submitted;
+  if(going) return uqOpen(uid);
+  if(!cur) back=document.activeElement;
+  stopUnitQuiz(); cur="uquiz"; UQ={uid};
+  const ready=uqReady(u), n=q.questions.length;
+  sheet.innerHTML=`<div class="mx-scrim" data-act="close"></div>
+    <div class="mx-sheet mx-uq-sheet u-${uid}" role="dialog" aria-modal="true" aria-labelledby="mxTitle">
+      <div class="mx-shtop"><div><span class="mx-uchip">${esc(u.name)}</span><h3 id="mxTitle">בוחן מסכם</h3>
+        <small class="mx-src">${n} שאלות פתוחות · ${q.minutes} דקות · 100 נקודות</small></div>
+        <button class="mx-x" data-act="close" aria-label="סגירה">✕</button></div>
+      <ul class="mx-uq-rules">
+        <li>כמו בוחן בכיתה: כל השאלות מופיעות יחד, והשעון סופר לאחור מרגע ההתחלה.</li>
+        <li>כתבו את הפתרונות על דף, כל שאלה בנפרד, עם דרך פתרון מלאה ונימוקים.</li>
+        <li>צלמו את התשובה לכל שאלה. כשהזמן נגמר יש עוד ${UQ_PHOTO_MIN} דקות לצלם ולהגיש.</li>
+        <li>הבדיקה, הציון והפתרונות מגיעים רק אחרי ההגשה.</li>
+        <li>אפשר לסגור ולחזור, אבל השעון ממשיך לרוץ.</li></ul>
+      ${st.history.length?`<div class="mx-uq-history"><h4>הגשות קודמות</h4>${st.history.slice().reverse().map((h,k)=>{ const i=st.history.length-1-k;
+        return `<button class="mx-btn" data-uq-result="${uid}:${i}">${new Date(h.at).toLocaleDateString("he-IL")} · ${h.score==null?"ממתין לבדיקה":`${h.score}/100`}</button>`; }).join("")}</div>`:""}
+      ${ready?`<button class="mx-btn solid" data-act="uq-start">התחלת הבוחן</button>`
+        :`<p class="mx-note">${!CFG.userId?"הבוחן זמין אחרי כניסה לחשבון.":"בוחנים עם תשובה מצולמת ובדיקה אוטומטית אינם זמינים כרגע באתר."}</p>`}</div>`;
+  sheet.hidden=false; sheet.querySelector(".mx-x").focus({preventScroll:true});
+}
+// a new sitting: one fresh answer attempt per question
+async function uqStart(){
+  const uid=UQ.uid, u=G.units.find(x=>x.id===uid), btn=sheet.querySelector("[data-act=uq-start]");
+  btn.disabled=true; btn.textContent="מכינים את הבוחן…";
+  try{
+    const attempts=[];
+    for(const [index,q] of u.quiz.questions.entries())
+      attempts.push((await uqPost("/api/math/quiz-attempts",{unit:uid,index,question_version:q.question_version,new:true})).attempt.id);
+    uqState(uid).sitting={started:Date.now(),attempts,submitted:null}; save(); draw();
+    uqOpen(uid);
+  }catch(e){ btn.disabled=false; btn.textContent="התחלת הבוחן"; btn.insertAdjacentHTML("afterend",`<p class="mx-small mx-quiz-warn">${esc(e.message)}</p>`); }
+}
+// the quiz paper
+function uqOpen(uid){
+  const u=G.units.find(x=>x.id===uid), sit=uqState(uid).sitting;
+  if(!cur) back=document.activeElement;
+  stopUnitQuiz(); cur="uquiz"; UQ={uid,res:{},images:{},busy:{},msg:{}};
+  sheet.innerHTML=`<div class="mx-scrim"></div>
+    <div class="mx-sheet mx-uq-sheet mx-uq-paper u-${uid}" role="dialog" aria-modal="true" aria-labelledby="mxTitle">
+      <div class="mx-uq-head"><div><span class="mx-uchip">${esc(u.name)}</span><h3 id="mxTitle">בוחן מסכם</h3></div>
+        <div class="mx-uq-clock" role="timer" aria-live="off"></div>
+        <button class="mx-x" data-act="close" aria-label="יציאה (השעון ממשיך)">✕</button></div>
+      <p class="mx-uq-banner" aria-live="polite"></p>
+      <ol class="mx-uq-qs">${u.quiz.questions.map((q,i)=>`<li class="mx-uq-q" id="uq-q${i}">
+        <div class="mx-uq-qhead"><b>שאלה ${i+1}</b><span>${q.points} נק׳</span></div>
+        <p class="mx-uq-text">${fmt(q.question).replace(/\n/g,"<br>")}</p>${figures(q)}
+        <div class="mx-uq-answer" data-uq-i="${i}"></div></li>`).join("")}</ol>
+      <div class="mx-quiz-nav"><span class="mx-small" data-uq-count></span><button class="mx-btn solid" data-act="uq-submit">הגשת הבוחן</button></div>
+      <input type="file" accept="image/*" capture="environment" hidden data-uq-file></div>`;
+  sheet.hidden=false; sheet.querySelector(".mx-sheet").scrollTop=0;
+  sheet.querySelector("[data-uq-file]").onchange=e=>{ const f=e.target.files[0]; e.target.value=""; if(f&&UQ?.pick!=null) uqUpload(UQ.pick,f); };
+  uqTick(); UQ.clock=setInterval(uqTick,1000);
+  sit.attempts.forEach((_,i)=>uqRefresh(i));
+}
+function uqTick(){
+  if(!UQ?.uid) return;
+  const u=G.units.find(x=>x.id===UQ.uid), sit=uqState(UQ.uid).sitting; if(!sit||sit.submitted) return;
+  const left=uqEnds(u,sit)-Date.now(), photo=left+UQ_PHOTO_MIN*60000;
+  const clock=sheet.querySelector(".mx-uq-clock"), banner=sheet.querySelector(".mx-uq-banner"); if(!clock) return;
+  if(photo<=0) return uqSubmit(true);
+  clock.textContent=left>0?mmss(left):mmss(photo);
+  clock.classList.toggle("low",left>0&&left<5*60000); clock.classList.toggle("over",left<=0);
+  const say=left>0?(left<5*60000?"נשארו פחות מ־5 דקות. זה זמן טוב לבדוק ולצלם.":""):`הזמן לכתיבה נגמר. נשארו ${mmss(photo)} לצילום ולהגשה, בלי להוסיף לפתרונות.`;
+  if(banner.textContent!==say) banner.textContent=say;
+}
+// one question's answer box: the photo if there is one, and the ways to add or replace it
+async function uqRefresh(i){
+  const sit=uqState(UQ.uid).sitting, aid=sit.attempts[i], uid=UQ.uid;
+  try{
+    const r=await uqJson(`${UQ_BASE}/${aid}`); if(UQ?.uid!==uid) return;
+    UQ.res[i]=r;
+    if(r.attachment&&!UQ.images[i]){ const b=await api(`${UQ_BASE}/${aid}/image`,{cache:"no-store"}); if(b.ok&&UQ?.uid===uid) UQ.images[i]=URL.createObjectURL(await b.blob()); }
+  }catch(e){ if(UQ?.uid===uid) UQ.msg[i]=e.message; }
+  if(UQ?.uid===uid) uqDrawAnswer(i);
+  // waiting for the phone: look again soon
+  if(UQ?.uid===uid&&!UQ.res[i]?.attachment&&["waiting","confirmed","uploading"].includes(UQ.res[i]?.scan?.state)){ clearTimeout(UQ.poll); UQ.poll=setTimeout(()=>sit.attempts.forEach((_,k)=>uqRefresh(k)),4000); }
+}
+function uqDrawAnswer(i){
+  const box=sheet.querySelector(`[data-uq-i="${i}"]`); if(!box) return;
+  const r=UQ.res[i], has=!!r?.attachment, busy=UQ.busy[i], st=r?.scan?.state, phone=["waiting","confirmed"].includes(st)&&!has;
+  const touch=matchMedia("(max-width: 700px)").matches||navigator.maxTouchPoints>0;
+  // on a computer the phone comes first: it is how most answers on paper get here
+  const phoneBtn=touch?"":`<button class="mx-btn${has?"":" solid"} mx-phone-cta" data-uq-phone="${i}"${busy||st==="uploading"?" disabled":""}><span aria-hidden="true">📱</span> ${phone?"הצגת המספר לטלפון":has?"צילום מחדש בטלפון":"צילום בטלפון"}</button>`;
+  box.innerHTML=`${has?`<img class="mx-uq-img" alt="התשובה המצולמת לשאלה ${i+1}" src="${UQ.images[i]||""}">`:""}
+    <p class="mx-small" role="status">${busy?esc(busy):UQ.msg[i]?esc(UQ.msg[i]):has?"✓ התשובה נשמרה":phone?"ממתינים לצילום מהטלפון":st==="declined"?"הבקשה נדחתה בטלפון":"עוד לא צולמה תשובה"}</p>
+    <span class="mx-chips">${phoneBtn}<button class="mx-btn${has||!touch?"":" solid"}" data-uq-photo="${i}"${busy?" disabled":""}>${has&&touch?"צילום מחדש":touch?"צילום התשובה":"העלאת תמונה מהמחשב"}</button></span>`;
+  const done=Object.values(UQ.res).filter(x=>x?.attachment).length, n=uqState(UQ.uid).sitting.attempts.length;
+  const c=sheet.querySelector("[data-uq-count]"); if(c) c.textContent=`צולמו ${done} מתוך ${n} תשובות`;
+}
+// a photo replaces an answer by a fresh attempt for that question (an attempt keeps the one photo it received)
+async function uqFresh(i){
+  const u=G.units.find(x=>x.id===UQ.uid), q=u.quiz.questions[i], sit=uqState(UQ.uid).sitting;
+  if(!UQ.res[i]?.attachment) return sit.attempts[i];
+  const r=await uqPost("/api/math/quiz-attempts",{unit:UQ.uid,index:i,question_version:q.question_version,new:true});
+  sit.attempts[i]=r.attempt.id; save();
+  if(UQ.images[i]){ URL.revokeObjectURL(UQ.images[i]); delete UQ.images[i]; }
+  UQ.res[i]=r; return r.attempt.id;
+}
+// this device: request, confirm, lease and upload in a row (the same steps the phone takes)
+async function uqUpload(i,file){
+  const uid=UQ.uid; UQ.busy[i]="מעלים את התמונה…"; UQ.msg[i]=""; uqDrawAnswer(i);
+  try{
+    const photo=await window.MathlyPhoto.prepare(file);
+    if(photo.size>5000000) throw Error(UQ_ERRORS.image_too_large);
+    const aid=await uqFresh(i);
+    const scan=(await uqPost(`${UQ_BASE}/${aid}/scans`,{renew:true})).scan;
+    await uqPost(`/api/math/answer-scans/${scan.id}/confirm`);
+    const lease=await uqPost(`/api/math/answer-scans/${scan.id}/uploads`,{key:crypto.randomUUID()});
+    if(!lease.attachment){ const form=new FormData(); form.append("photo",photo,"answer.jpg");
+      await uqJson(`/api/math/answer-scans/${scan.id}/uploads/${lease.lease_id}`,{method:"POST",body:form}); }
+  }catch(e){ if(UQ?.uid===uid) UQ.msg[i]=e.message; }
+  if(UQ?.uid!==uid) return;
+  UQ.busy[i]=""; uqRefresh(i);
+}
+// the phone: a request with a 4-digit code, and a window here until the phone sends the photo or declines
+async function uqPhone(i){
+  const uid=UQ.uid, r0=UQ.res[i];
+  let r=r0&&!r0.attachment&&["waiting","confirmed"].includes(r0.scan?.state)?r0:null;   // a request still open: show its code again
+  if(!r){
+    UQ.busy[i]="יוצרים בקשת צילום…"; UQ.msg[i]=""; uqDrawAnswer(i);
+    try{ const aid=await uqFresh(i); r=await uqPost(`${UQ_BASE}/${aid}/scans`,{renew:true}); }
+    catch(e){ if(UQ?.uid===uid) UQ.msg[i]=e.message; }
+    if(UQ?.uid!==uid) return;
+    UQ.busy[i]=""; uqDrawAnswer(i);
+  }
+  if(r) await window.MathlyAnswers.waitForPhone(r);
+  if(UQ?.uid===uid) uqRefresh(i);
+}
+function uqSubmit(timeUp=false){
+  const uid=UQ.uid, sit=uqState(uid).sitting; if(!sit||sit.submitted) return;
+  const missing=sit.attempts.filter((_,i)=>!UQ.res[i]?.attachment).length;
+  if(!timeUp&&missing&&!UQ.sure){
+    UQ.sure=true;
+    sheet.querySelector(".mx-quiz-nav").insertAdjacentHTML("beforebegin",`<p class="mx-small mx-quiz-warn">${missing===1?"לשאלה אחת":`ל־${missing} שאלות`} אין תשובה מצולמת, והן יקבלו 0 נקודות. לחצו שוב על הגשה כדי להגיש בכל זאת.</p>`);
+    return;
+  }
+  sit.submitted=Date.now();
+  const st=uqState(uid); st.history.push({at:new Date().toISOString(),attempts:sit.attempts.slice(),score:null,timeUp}); st.history=st.history.slice(-10);
+  save(); draw();
+  uqResult(uid,st.history.length-1,true);
+}
+// the report: each answer is checked now (once), then points per question, feedback and the solution
+async function uqResult(uid,h,check=false){
+  const u=G.units.find(x=>x.id===uid), st=uqState(uid), entry=st.history[h];
+  if(!cur) back=document.activeElement;
+  stopUnitQuiz(); cur="uquiz"; UQ={uid,res:{},images:{}};
+  const n=entry.attempts.length;
+  sheet.innerHTML=`<div class="mx-scrim" data-act="close"></div>
+    <div class="mx-sheet mx-uq-sheet u-${uid}" role="dialog" aria-modal="true" aria-labelledby="mxTitle">
+      <div class="mx-shtop"><div><span class="mx-uchip">${esc(u.name)}</span><h3 id="mxTitle">בוחן מסכם: בודקים…</h3>
+        <small class="mx-src" aria-live="polite">בודקים את התשובות, זה לוקח כחצי דקה לשאלה</small></div>
+        <button class="mx-x" data-act="close" aria-label="סגירה">✕</button></div><div class="mx-uq-report"></div></div>`;
+  sheet.hidden=false; sheet.querySelector(".mx-x").focus({preventScroll:true});
+  const results=[];
+  for(let i=0;i<n;i++){
+    let r=null;
+    try{
+      r=await uqJson(`${UQ_BASE}/${entry.attempts[i]}`);
+      if(r.attachment&&r.grading_available&&(!r.grading||(check&&r.grading.state==="failed"))){
+        if(UQ?.uid!==uid) return;
+        sheet.querySelector(".mx-src").textContent=`בודקים את שאלה ${i+1} מתוך ${n}…`;
+        try{ r=await uqPost(`${UQ_BASE}/${entry.attempts[i]}/grade`,{automatic:!check}); }catch(e){ r.error=e.message; }
+      }
+      if(r.attachment){ const b=await api(`${UQ_BASE}/${entry.attempts[i]}/image`,{cache:"no-store"}); if(b.ok&&UQ?.uid===uid) UQ.images[i]=URL.createObjectURL(await b.blob()); }
+    }catch(e){ r={error:e.message}; }
+    if(UQ?.uid!==uid) return;
+    results.push(r);
+  }
+  // points: a checked answer earns its share; a missing one 0; one not checked yet leaves the total open
+  let earned=0, open=0;
+  const rows=u.quiz.questions.map((q,i)=>{
+    const r=results[i], g=r?.grading, a=g?.state==="completed"?g.result:null;
+    let pts=null, say="";
+    if(!r?.attachment) { pts=0; say="לא צולמה תשובה"; }
+    else if(a&&a.score!=null){ pts=Math.round(q.points*a.score/100); say={correct:"נכון ומלא",partial:"נכון בחלקו",incorrect:"לא נכון"}[a.verdict]||""; }
+    else { open++; say=a?.verdict==="unreadable"?"לא הצלחנו לקרוא את התמונה":a?.verdict==="needs_review"?"נדרשת בדיקה של מורה":r.error||(!r.grading_available?"הבדיקה האוטומטית אינה זמינה כרגע":"עוד לא נבדקה"); }
+    if(pts!=null) earned+=pts;
+    return `<li class="mx-uq-q"><div class="mx-uq-qhead"><b>שאלה ${i+1}</b><span>${pts==null?"–":pts}/${q.points} נק׳</span></div>
+      <p class="mx-uq-text">${fmt(q.question).replace(/\n/g,"<br>")}</p>
+      ${UQ.images[i]?`<img class="mx-uq-img" alt="התשובה שלכם לשאלה ${i+1}" src="${UQ.images[i]}">`:""}
+      <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>`:""}
+      ${a?.solution?`<details><summary>הפתרון המלא</summary><p class="mx-grade-solution">${fmtLoose(a.solution)}</p></details>`:""}
+      ${r?.attachment&&!a&&r.grading_available?`<button class="mx-btn" data-uq-result="${uid}:${h}:check">בדיקה נוספת</button>`:""}</li>`;
+  });
+  entry.score=open?null:earned; save(); draw();
+  const total=open?`${earned} נקודות עד עכשיו · ${open===1?"שאלה אחת לא נבדקה":`${open} שאלות לא נבדקו`}`:`${earned}/100`;
+  sheet.querySelector("#mxTitle").textContent=`בוחן מסכם: ${total}`;
+  sheet.querySelector(".mx-src").textContent=`הוגש ${new Date(entry.at).toLocaleString("he-IL",{dateStyle:"short",timeStyle:"short"})}${entry.timeUp?" · הוגש כשהזמן נגמר":""}`;
+  const weak=u.quiz.questions.map((q,i)=>i).filter(i=>{ const a=results[i]?.grading?.result; return !results[i]?.attachment||(a&&a.score!=null&&a.score<70); });
+  sheet.querySelector(".mx-uq-report").innerHTML=`<ol class="mx-uq-qs">${rows.join("")}</ol>
+    ${weak.length&&!open?`<p class="mx-note">כדאי לחזור על ${weak.map(i=>`שאלה ${i+1}`).join(", ")} ולתרגל את המיומנויות של היחידה במסלול לפני הבוחן הבא.</p>`:""}
+    <p class="mx-small">הבדיקה אוטומטית באמצעות AI: בדקו שהיא תואמת למה שכתבתם, ואם משהו נראה לא נכון, הראו למורה.</p>
+    <div class="mx-quiz-nav"><button class="mx-btn" data-uquiz="${uid}">לבוחן</button><button class="mx-btn solid" data-act="close">חזרה למסלול</button></div>`;
+}
+
 function onClick(e){
   const t=e.target.closest("button,[data-act]"); if(!t||!root.contains(t)) return;
   if(t.dataset.choice!=null) return answer(t);
+  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.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);
   if(t.dataset.subject) return selectSubject(t.dataset.subject);
   if(t.dataset.view){ closeSheet(); return setView(t.dataset.view,t.dataset.unit); }
   if(t.dataset.comet) return showComet(t.dataset.comet);
@@ -540,6 +975,15 @@ function onClick(e){
     case "subjects": return drawSubjectPicker();
     case "streak": return showStreak();
     case "review": return startReview();
+    case "patterns": return showPatterns();
+    case "quiz": stopQuizClock(); QZ=null; return quizSetup();
+    case "quiz-start": return quizStart();
+    case "quiz-next": return quizGo(QZ.i+1);
+    case "quiz-prev": return quizGo(QZ.i-1);
+    case "quiz-submit": return quizSubmit();
+    case "quiz-quit": return quizQuit();
+    case "uq-start": return uqStart();
+    case "uq-submit": return uqSubmit();
     case "review-next": return REV&&reviewNext();
     case "cal-prev": return showStreak(-1);
     case "cal-next": return showStreak(1);

supabase/migrations/20261103120000_math_answer_scan_decline.sql

@@ -0,0 +1,122 @@
+-- A photo request can be declined: the phone refuses it, or the computer withdraws it while waiting.
+-- Additive: one more scan state and one more action; existing rows and actions are unchanged.
+begin;
+alter table public.math_answer_scans drop constraint math_answer_scans_state_check;
+alter table public.math_answer_scans add constraint math_answer_scans_state_check
+  check (state in ('waiting','confirmed','uploading','received','failed','expired','superseded','declined'));
+create or replace function public.math_answer_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;
+  s public.math_answer_scans;
+  att public.math_answer_attachments;
+  t timestamptz := clock_timestamp();
+  sid uuid;
+  aid uuid;
+  listing jsonb;
+begin
+  if p_action='cleanup_candidates' then
+    return coalesce((select jsonb_agg(o.name) from storage.objects o
+      where o.bucket_id='mathly-answers' and o.created_at < t-interval '24 hours'
+      and not exists(select 1 from public.math_answer_attachments x where x.object_key=o.name)), '[]'::jsonb);
+  end if;
+  if p_user is null then raise exception 'not_found' using errcode='P0002'; end if;
+  if p_action='pending' then
+    -- Expiry and stale lease recovery are also persisted on discovery.
+    update public.math_answer_scans set state='expired',error='expired'
+      where user_id=p_user and expires_at<=t and state in ('waiting','confirmed','uploading','failed');
+    update public.math_answer_scans set state='failed',error='upload_interrupted'
+      where user_id=p_user and state='uploading' and lease_until<=t;
+    select jsonb_agg(jsonb_build_object('scan',to_jsonb(x),'attempt',to_jsonb(q)) order by x.created_at desc)
+      into listing from public.math_answer_scans x join public.math_question_attempts q on q.id=x.attempt_id
+      where x.user_id=p_user and x.state in ('waiting','confirmed','uploading','failed','expired')
+      and not exists(select 1 from public.math_answer_scans newer where newer.attempt_id=x.attempt_id and newer.generation>x.generation);
+    return coalesce(listing,'[]'::jsonb);
+  end if;
+  if p_action='resume' then
+    perform pg_catalog.pg_advisory_xact_lock(pg_catalog.hashtextextended(p_user::text||(p_data->>'question_id')||(p_data->>'question_version'),0));
+    if not coalesce((p_data->>'new')::boolean,false) then
+      select * into a from public.math_question_attempts where user_id=p_user
+        and question_id=p_data->>'question_id' and question_version=p_data->>'question_version'
+        order by created_at desc,id desc limit 1 for update;
+    end if;
+    if a.id is null then
+      insert into public.math_question_attempts(user_id,question_id,question_version,snapshot)
+        values(p_user,p_data->>'question_id',p_data->>'question_version',p_data->'snapshot') returning * into a;
+    end if;
+  else
+    if p_data ? 'scan_id' then
+      select attempt_id into aid from public.math_answer_scans where id=(p_data->>'scan_id')::uuid and user_id=p_user;
+    else aid := (p_data->>'attempt_id')::uuid;
+    end if;
+    select * into a from public.math_question_attempts where id=aid and user_id=p_user for update;
+    if a.id is null then raise exception 'not_found' using errcode='P0002'; end if;
+    if p_data ? 'question_id' and a.question_id<>p_data->>'question_id' then
+      raise exception 'not_found' using errcode='P0002';
+    end if;
+  end if;
+  select * into s from public.math_answer_scans where attempt_id=a.id order by generation desc limit 1 for update;
+  select * into att from public.math_answer_attachments where attempt_id=a.id;
+  t := clock_timestamp();
+  if p_data ? 'scan_id' and s.id is distinct from (p_data->>'scan_id')::uuid then
+    raise exception 'superseded' using errcode='P0001';
+  end if;
+  if s.id is not null then
+    if s.state in ('waiting','confirmed','uploading','failed') and s.expires_at<=t then
+      update public.math_answer_scans set state='expired',error='expired' where id=s.id returning * into s;
+    elsif s.state='uploading' and s.lease_until<=t then
+      update public.math_answer_scans set state='failed',error='upload_interrupted' where id=s.id returning * into s;
+    end if;
+  end if;
+  if p_action='create_scan' then
+    if att.id is not null then null;
+    elsif s.id is null or coalesce((p_data->>'renew')::boolean,false) then
+      if s.state='uploading' then raise exception 'upload_in_progress' using errcode='P0001'; end if;
+      if s.id is not null then update public.math_answer_scans set state='superseded' where id=s.id; end if;
+      insert into public.math_answer_scans(user_id,attempt_id,generation,expires_at,created_at)
+        values(p_user,a.id,coalesce(s.generation,0)+1,t+interval '15 minutes',t) returning * into s;
+    end if;
+  elsif p_action='confirm' then
+    if s.state='waiting' then
+      update public.math_answer_scans set state='confirmed' where id=s.id returning * into s;
+    end if;
+  elsif p_action='begin' then
+    if s.state in ('confirmed','failed') then
+      update public.math_answer_scans set state='uploading',lease_id=gen_random_uuid(),
+        lease_until=least(t+interval '3 minutes',expires_at),idempotency_key=(p_data->>'key')::uuid,error=''
+        where id=s.id returning * into s;
+    elsif s.state='uploading' and s.idempotency_key is distinct from (p_data->>'key')::uuid then
+      raise exception 'upload_in_progress' using errcode='P0001';
+    elsif s.state='waiting' then raise exception 'confirmation_required' using errcode='P0001';
+    end if;
+  elsif p_action='finalize' then
+    if att.id is null then
+      if s.state<>'uploading' or s.lease_id is distinct from (p_data->>'lease_id')::uuid then
+        raise exception 'invalid_upload' using errcode='P0001';
+      end if;
+      if (p_data->>'object_key') not like p_user::text||'/'||s.id::text||'/'||s.lease_id::text||'/%' then
+        raise exception 'invalid_upload' using errcode='P0001';
+      end if;
+      insert into public.math_answer_attachments(user_id,attempt_id,scan_id,object_key,media_type,byte_size)
+        values(p_user,a.id,s.id,p_data->>'object_key','image/jpeg',(p_data->>'byte_size')::integer) returning * into att;
+      update public.math_answer_scans set state='received',error='' where id=s.id returning * into s;
+      update public.math_question_attempts set status='received' where id=a.id returning * into a;
+    end if;
+  elsif p_action='decline' then
+    -- the phone refused the request, or the computer withdrew it; a received answer stays received
+    if att.id is null and s.state in ('waiting','confirmed','failed') then
+      update public.math_answer_scans set state='declined',error='declined' where id=s.id returning * into s;
+    end if;
+  elsif p_action='fail' then
+    if s.state='uploading' and s.lease_id=(p_data->>'lease_id')::uuid then
+      update public.math_answer_scans set state='failed',error='upload_failed' where id=s.id returning * into s;
+    end if;
+  elsif p_action not in ('resume','get') then
+    raise exception 'invalid_action';
+  end if;
+  return jsonb_build_object('attempt',to_jsonb(a),'scan',case when s.id is null then null else to_jsonb(s) end,
+    'attachment',case when att.id is null then null else to_jsonb(att) end);
+end $$;
+revoke all on function public.math_answer_action(uuid,text,jsonb) from public,anon,authenticated;
+grant execute on function public.math_answer_action(uuid,text,jsonb) to service_role;
+commit;

tests/scan_support.py

@@ -117,7 +117,9 @@ def answer_store(postgres_server, tmp_path):
     with store.connect() as c:
         c.execute(BOOTSTRAP)
         c.execute(Path('supabase/migrations/20261031133254_math_answer_scans.sql').read_text())
-        for migration in sorted(Path('supabase/migrations').glob('*_math_answer_grading.sql')):
+        for migration in sorted(Path('supabase/migrations').glob('*_math_answer_*.sql')):
+            if migration.name.endswith('_math_answer_scans.sql'):
+                continue
             c.execute(migration.read_text())
         c.execute('insert into auth.users values(%s),(%s)', (OWNER, OTHER))
     yield store

tests/test_answer_browser.py

@@ -16,6 +16,12 @@ from app.math_photo import PhotoUnavailable
 playwright = pytest.importorskip('playwright.sync_api')
 
 
+@pytest.fixture(autouse=True)
+def unlocked_open_ended(monkeypatch):
+    """These tests answer the open-ended question, which is locked by default."""
+    monkeypatch.setenv('MATHLY_OPEN_ENDED_LOCKED', '0')
+
+
 @pytest.fixture
 def scan_server(answer_store):
     app = create_app(auth=ScanAuth()); app.state.answers = answer_store
@@ -67,26 +73,29 @@ def test_two_device_capture_retake_failure_retry_and_original_attempt(scan_serve
             assert len(resume.value.post_data_json['question_version'])==64
             computer.locator('[data-request]').click()
             playwright.expect(computer.locator('.mx-answer [role=status]')).to_have_text('ממתינים לטלפון')
+            wait = computer.locator('.mx-scan-wait')
+            playwright.expect(wait.locator('.mx-scan-code span')).to_have_count(4)   # the computer waits with a 4-digit code
+            code = wait.locator('.mx-scan-code').inner_text().replace('\n', '')
+            assert len(code) == 4 and code.isdigit()
             with store.connect() as c:
                 attempt_id = str(c.execute('select id from math_question_attempts').fetchone()[0])
             phone = session(browser, mobile=True).new_page()
             phone.on('pageerror', lambda error: errors.append(str(error)))
-            request(store, question='another-question')
+            other = request(store, question='another-question')
             phone.goto(url)
-            playwright.expect(phone.locator('[data-scan-index]')).to_have_count(2)
-            phone.locator('[data-scan-index]').filter(has_text='משולש ישר').click()
-            # Confirmation and cancellation do not invoke capture or upload.
-            assert phone.locator('[data-camera]').input_value() == ''
-            assert phone.locator('[data-take]').is_hidden()
+            # the newest request pops up first, as a window; declining it leaves the other one
+            ask = phone.locator('.mx-scan-overlay')
+            playwright.expect(ask).to_contain_text('Draw your proof')
+            phone.locator('[data-decline]').click()
+            playwright.expect(phone.locator('[data-status]')).to_contain_text('סירבתם')
+            assert store.action(OWNER, 'get', scan_id=other['scan']['id'])['scan']['state'] == 'declined'
             phone.locator('[data-close]').click()
-            phone.locator('[data-scan-index]').filter(has_text='משולש ישר').click()
-            phone.evaluate("window.cameraClicks=0;document.addEventListener('click',e=>{if(e.target.matches('[data-camera]'))window.cameraClicks++},true)")
-            phone.locator('[data-confirm]').click()
-            playwright.expect(phone.locator('[data-take]')).to_be_visible()
+            playwright.expect(ask).to_contain_text('משולש ישר', timeout=10000)
+            # the phone shows the same code as the computer
+            assert ask.locator('.mx-scan-code').inner_text().replace('\n', '') == code
             phone.locator('[data-camera]').dispatch_event('cancel')
             playwright.expect(phone.locator('[data-status]')).to_contain_text('לא ניתנה הרשאה')
             image = {'name': 'answer.png', 'mimeType': 'image/png', 'buffer': png()}
-            assert phone.evaluate('window.cameraClicks')==0
             with phone.expect_file_chooser() as chooser:
                 phone.locator('[data-take]').click()
             chooser.value.set_files(image)
@@ -108,14 +117,11 @@ def test_two_device_capture_retake_failure_retry_and_original_attempt(scan_serve
                 started.set(); assert release.wait(timeout=15); original_put(key, data)
             store.put = slow_put
             phone.locator('[data-submit]').click()
-            playwright.expect(computer.locator('.mx-answer [role=status]')).to_have_text('מעלים את התשובה…', timeout=10000)
+            playwright.expect(wait).to_contain_text('מקבלים את התמונה מהטלפון', timeout=10000)
             assert started.is_set()
-            computer.locator('.mx-x').click();computer.locator('.mx-node[data-id="m_def"]').click()
             release.set()
-            playwright.expect(phone.locator('[data-status]')).to_contain_text('הועלתה בהצלחה', timeout=10000)
-            assert computer.locator('.mx-answer-image').count() == 0
-            assert computer.locator('.mx-choices button').count() > 0
-            computer.locator('.mx-x').click();open_question(computer)
+            playwright.expect(phone.locator('[data-status]')).to_contain_text('נשלחה למחשב', timeout=10000)
+            playwright.expect(wait).to_have_count(0, timeout=10000)   # the computer's window closes with the photo
             playwright.expect(computer.locator('.mx-answer-image')).to_be_visible()
             assert computer.locator('.mx-answer-image').evaluate('img=>img.complete&&img.naturalWidth>0')
             computer.screenshot(path='/tmp/mathly-answer-computer.png', full_page=True, animations='disabled')
@@ -123,7 +129,8 @@ def test_two_device_capture_retake_failure_retry_and_original_attempt(scan_serve
             computer.reload();open_question(computer)
             playwright.expect(computer.locator('.mx-answer-image')).to_be_visible()
             foreign = session(browser, OTHER, mobile=True).new_page();foreign.goto(url)
-            playwright.expect(foreign.locator('.mx-scan-inbox')).to_be_empty()
+            foreign.wait_for_timeout(1500)
+            playwright.expect(foreign.locator('.mx-scan-overlay')).to_have_count(0)
             assert store.action(OWNER, 'get', attempt_id=attempt_id)['attachment']
             assert not errors
         finally:
@@ -143,16 +150,16 @@ def test_expiry_renewal_reconnect_and_account_change(scan_server):
                 c.execute("update math_answer_scans set expires_at=now()-interval '1 second'")
             computer.route('**/api/math/answer-attempts/*', lambda r:r.abort(), times=1)
             playwright.expect(computer.locator('.mx-answer [role=status]')).to_have_text('בקשת הצילום פגה', timeout=15000)
+            playwright.expect(computer.locator('.mx-scan-wait')).to_contain_text('הבקשה פגה')
             phone = session(browser, mobile=True).new_page();phone.goto(url)
-            phone.locator('[data-scan-index]').click()
-            playwright.expect(phone.locator('[data-renew]')).to_be_visible()
-            phone.locator('[data-renew]').click()
-            playwright.expect(phone.locator('[data-confirm]')).to_be_visible()
+            phone.wait_for_timeout(1500)
+            playwright.expect(phone.locator('.mx-scan-overlay')).to_have_count(0)   # an expired request does not pop up
+            computer.locator('[data-again]').click()
+            playwright.expect(phone.locator('.mx-scan-overlay')).to_be_visible(timeout=10000)
             assert store.action(OWNER, 'pending')[0]['scan']['generation'] == 2
-            phone.locator('[data-confirm]').click()
             phone.locator('[data-camera]').set_input_files({'name':'answer.png','mimeType':'image/png','buffer':png()})
             phone.locator('[data-submit]').click()
-            playwright.expect(phone.locator('[data-status]')).to_contain_text('הועלתה בהצלחה')
+            playwright.expect(phone.locator('[data-status]')).to_contain_text('נשלחה למחשב')
             playwright.expect(computer.locator('.mx-answer-image')).to_be_visible(timeout=10000)
             # Account change removes the photograph and all old-account continuations.
             computer.evaluate("localStorage.setItem('test.account','%s');window.testAuthEvent('SIGNED_IN',{access_token:'%s',user:{id:'%s'}})" % (OTHER, OTHER, OTHER))
@@ -174,7 +181,7 @@ def test_success_response_loss_is_safe_to_retry(scan_server):
             computer.locator('[data-request]').click()
             playwright.expect(computer.locator('.mx-answer [role=status]')).to_have_text('ממתינים לטלפון')
             phone=session(browser,mobile=True).new_page();phone.goto(url)
-            phone.locator('[data-scan-index]').click();phone.locator('[data-confirm]').click()
+            playwright.expect(phone.locator('.mx-scan-overlay')).to_be_visible()
             phone.locator('[data-camera]').set_input_files({'name':'answer.png','mimeType':'image/png','buffer':png()})
             def lost_response(route):
                 response=route.fetch()
@@ -185,7 +192,7 @@ def test_success_response_loss_is_safe_to_retry(scan_server):
             playwright.expect(phone.locator('[data-status]')).to_contain_text('אפשר לנסות שוב')
             playwright.expect(computer.locator('.mx-answer-image')).to_be_visible(timeout=10000)
             phone.locator('[data-submit]').click()
-            playwright.expect(phone.locator('[data-status]')).to_contain_text('הועלתה בהצלחה')
+            playwright.expect(phone.locator('[data-status]')).to_contain_text('נשלחה למחשב')
             with store.connect() as c:
                 assert c.execute('select count(*) from math_answer_attachments').fetchone()[0]==1
             computer.locator('.mx-x').click();computer.locator('.mx-node[data-id="m_def"]').click()
@@ -279,11 +286,11 @@ def test_upload_is_acknowledged_before_automatic_grading_finishes(scan_server, m
             computer.locator('[data-request]').click()
             playwright.expect(computer.locator('.mx-answer [role=status]')).to_have_text('ממתינים לטלפון')
             phone=session(browser,mobile=True).new_page();phone.goto(url)
-            phone.locator('[data-scan-index]').click();phone.locator('[data-confirm]').click()
+            playwright.expect(phone.locator('.mx-scan-overlay')).to_be_visible()
             phone.locator('[data-camera]').set_input_files({'name':'answer.png','mimeType':'image/png','buffer':png()})
             playwright.expect(phone.locator('.mx-scan-card')).to_contain_text('יישלח לבדיקה באמצעות AI')
             phone.locator('[data-submit]').click()
-            playwright.expect(phone.locator('[data-status]')).to_contain_text('הועלתה בהצלחה')
+            playwright.expect(phone.locator('[data-status]')).to_contain_text('נשלחה למחשב')
             assert started.wait(timeout=5)
             playwright.expect(computer.locator('.mx-answer [role=status]')).to_have_text('בודקים את התשובה…')
             assert len(calls)==1
@@ -292,3 +299,36 @@ def test_upload_is_acknowledged_before_automatic_grading_finishes(scan_server, m
             assert len(calls)==1
         finally:
             release.set();browser.close()
+
+
+def test_phone_declines_and_computer_withdraws(scan_server):
+    url, store = scan_server
+    with playwright.sync_playwright() as p:
+        browser = p.chromium.launch()
+        try:
+            computer = session(browser).new_page(); errors = []
+            computer.on('pageerror', lambda error: errors.append(str(error)))
+            computer.goto(url); open_question(computer)
+            computer.locator('[data-request]').click()
+            wait = computer.locator('.mx-scan-wait')
+            playwright.expect(wait.locator('.mx-scan-code span')).to_have_count(4)
+            phone = session(browser, mobile=True).new_page()
+            phone.on('pageerror', lambda error: errors.append(str(error)))
+            phone.goto(url)
+            # the phone declines: the computer reports it
+            phone.locator('[data-decline]').click()
+            playwright.expect(wait).to_contain_text('הבקשה נדחתה בטלפון', timeout=10000)
+            computer.locator('[data-done]').click()
+            playwright.expect(wait).to_have_count(0)
+            playwright.expect(computer.locator('.mx-answer [role=status]')).to_have_text('הבקשה נדחתה בטלפון')
+            phone.locator('[data-close]').click()
+            # a new request pops up again; the computer withdraws it and the phone's window says so
+            computer.locator('[data-request]').click()
+            playwright.expect(phone.locator('.mx-scan-overlay [data-take]')).to_be_visible(timeout=10000)
+            computer.locator('[data-cancel]').click()
+            playwright.expect(wait).to_have_count(0)
+            playwright.expect(phone.locator('[data-status]')).to_contain_text('בוטלה במחשב', timeout=10000)
+            assert store.action(OWNER, 'pending') == []
+            assert not errors
+        finally:
+            browser.close()

tests/test_sky_browser.py

@@ -43,7 +43,7 @@ def browser():
         b.close()
 
 
-def page_with(browser, server, progress=None, no_chance=False):
+def page_with(browser, server, progress=None, no_chance=False, now=None):
     ctx = browser.new_context(viewport={"width": 390, "height": 844})
     if no_chance:   # no comet by chance: only the sure ones come
         ctx.add_init_script("Math.random=()=>0.99")
@@ -53,6 +53,8 @@ def page_with(browser, server, progress=None, no_chance=False):
     if progress is not None:
         ctx.add_init_script(f"localStorage.setItem({json.dumps(KEY)},{json.dumps(json.dumps(progress))})")
     page = ctx.new_page()
+    if now:   # the date the page sees; timers run as usual
+        page.clock.set_fixed_time(now)
     errors = []
     page.on("pageerror", lambda e: errors.append(str(e)))
     page.goto(server)
@@ -169,6 +171,8 @@ def test_a_mistake_is_quiet_hides_the_answer_and_needs_a_clean_run_to_finish(bro
     playwright.expect(page.locator(".mx-bad")).to_be_visible()
     assert page.locator(".mx-choices button.right").count() == 0         # the right answer is not revealed
     assert page.locator(".mx-choices button:not([disabled])").count() == 0
+    slips = progress_of(page)["slips"]
+    assert [(s["id"], s["via"]) for s in slips] == [("t_ext", "practice")] and slips[0]["m"]   # the mistake is remembered
     page.locator(".mx-bad button[data-id=t_ext]").first.click()
     page.locator(".mx-choices button[data-right]").first.click()         # it comes back and is solved
     playwright.expect(page.locator(".mx-ok b")).to_have_text(re.compile("תיקנתם|הטעות מקודם"))   # fixing is praised
@@ -253,3 +257,242 @@ def test_answers_saved_by_a_page_from_before_rounds_are_kept(browser, server):
     playwright.expect(page.locator(".mx-qprog span").first).to_have_text("שאלה 5 מתוך 10")
     playwright.expect(page.locator(".mx-qdots i.ok")).to_have_count(4)
     assert not errors
+
+
+
+def test_a_practice_exam_mixes_the_taught_units_and_reports_at_the_end(browser, server):
+    page, errors = page_with(browser, server, {"done": {"t_ext": "2026-10-01T00:00:00+00:00"}}, no_chance=True,
+                             now=datetime(2026, 11, 3, 10))
+    page.locator(".mx-quiz-card").click()
+    sheet = page.locator(".mx-quiz-sheet")
+    on = sheet.locator('[data-quiz-unit][aria-pressed="true"]')
+    playwright.expect(on).to_have_count(4)   # before November: algebra 1-2, the kite, the isosceles triangle
+    assert sorted(on.evaluate_all("els=>els.map(e=>e.dataset.quizUnit)")) == ["i", "k", "t", "t2"]
+    sheet.locator('[data-quiz-unit="k"]').click()
+    playwright.expect(on).to_have_count(3)
+    sheet.locator('[data-quiz-unit="k"]').click()
+    sheet.locator("[data-act=quiz-start]").click()
+    playwright.expect(sheet.locator(".mx-quiz-dots button")).to_have_count(12)
+    playwright.expect(sheet.locator("h3")).to_have_text("שאלה 1 מתוך 12")
+    sheet.locator(".mx-choices button:not([data-right])").first.click()   # the first one wrong
+    assert sheet.locator(".mx-ok, .mx-bad").count() == 0                # no feedback during the exam
+    for _ in range(10):
+        sheet.locator("[data-act=quiz-next]").click()
+        sheet.locator(".mx-choices button[data-right]").first.click()
+    sheet.locator("[data-act=quiz-next]").click()                       # the last one is left empty
+    sheet.locator("[data-act=quiz-submit]").click()
+    playwright.expect(sheet.locator(".mx-quiz-warn")).to_contain_text("שאלה אחת לא נענתה")
+    sheet.locator('[data-quiz-go="0"]').click()                         # back to the first: the choice is kept
+    playwright.expect(sheet.locator('.mx-choices button[aria-pressed="true"]')).to_have_count(1)
+    sheet.locator('[data-quiz-go="11"]').click()
+    sheet.locator("[data-act=quiz-submit]").click()                    # warned once: now it is handed in
+    playwright.expect(sheet.locator("h3")).to_have_text("10 מתוך 12 נכונות")
+    playwright.expect(sheet.locator(".mx-quiz-plan li")).to_have_count(1)  # the one mistake, with its skill to practise
+    playwright.expect(sheet.locator(".mx-quiz-plan button[data-id]").first).to_be_visible()
+    playwright.expect(sheet.locator(".mx-quiz-units-score > div")).to_have_count(4)
+    p = progress_of(page)
+    q = p["quizzes"][-1]
+    assert (q["n"], q["right"], sorted(q["units"])) == (12, 10, ["i", "k", "t", "t2"]) and len(q["weak"]) == 2
+    assert p["days"]["2026-11-03"] == 10                                  # right answers count toward today's goal
+    page.locator(".mx-quiz-sheet .mx-x").click()
+    playwright.expect(page.locator(".mx-quiz-card")).to_contain_text("בפעם הקודמת: 10 מתוך 12")
+    assert not errors
+
+
+def test_leaving_a_practice_exam_asks_first(browser, server):
+    page, errors = page_with(browser, server, now=datetime(2026, 11, 3, 10))
+    page.locator(".mx-quiz-card").click()
+    page.locator("[data-act=quiz-start]").click()
+    page.locator(".mx-choices button").first.click()
+    page.keyboard.press("Escape")
+    playwright.expect(page.locator(".mx-quiz-warn")).to_contain_text("לצאת?")
+    playwright.expect(page.locator(".mx-quiz-sheet")).to_be_visible()
+    page.locator("[data-act=quiz-quit]").click()
+    playwright.expect(page.locator(".mx-quiz-sheet")).to_be_hidden()
+    assert "quizzes" not in progress_of(page)
+    assert not errors
+
+
+# ---------- misconception patterns ----------
+
+def slips_at(now, *rows):
+    """Mistake-log entries: (days ago, skill, tag[, via])."""
+    return [{"at": (now - timedelta(days=d)).isoformat(), "id": sid, "q": 0, "m": m, "via": (via or ["practice"])[0]}
+            for d, sid, m, *via in rows]
+
+
+def patterns_of(page, slips, mistakes=None):
+    return page.evaluate("([slips,mistakes])=>window.MathlySky.patterns({slips},mistakes||{})", [slips, mistakes])
+
+
+def test_old_progress_without_a_mistake_log_loads(browser, server):
+    page, errors = page_with(browser, server, {"done": {}, "comets": []})
+    page.locator('.mx-star[data-id="t_ext"]').click()
+    page.locator(".mx-choices button:not([data-right])").first.click()
+    playwright.expect(page.locator(".mx-bad")).to_be_visible()
+    assert len(progress_of(page)["slips"]) == 1
+    assert not errors
+
+
+def test_the_mistake_log_keeps_the_newest_500(browser, server):
+    page, errors = page_with(browser, server)
+    log = page.evaluate("""()=>{ const P={}; for(let i=0;i<501;i++) window.MathlySky.slip(P,"t_ext",i,"sign_mid","practice");
+      return P.slips.map(s=>s.q); }""")
+    assert len(log) == 500 and log[0] == 1 and log[-1] == 500
+    assert not errors
+
+
+def test_recurring_misconceptions_need_two_recent_and_rank_by_spread(browser, server):
+    page, errors = page_with(browser, server)
+    now = datetime.now(timezone.utc)
+    p = patterns_of(page, slips_at(now, (20, "t_ext", "sign_mid"), (3, "t_ext", "sign_mid"), (2, "t_ext", "ext_partial"),
+                                   (40, "t_ext", "move_sign"), (35, "t_ext", "move_sign")))
+    assert [x["m"] for x in p["recurring"]] == ["sign_mid"]              # one ext_partial is not a pattern; move_sign is old
+    p = patterns_of(page, slips_at(now, *[(1, "t_ext_eq", "move_sign")] * 4,
+                                   (1, "t_ext", "sign_mid"), (2, "t_simplify", "sign_mid"), (3, "t_ext_eq", "sign_mid")))
+    assert [x["m"] for x in p["recurring"]] == ["sign_mid", "move_sign"]  # three skills before four times in one
+    assert p["recurring"][0]["n"] == 3 and len(p["recurring"][0]["skills"]) == 3
+    assert not errors
+
+
+def test_the_skill_to_practise_is_the_back_skill_or_the_most_frequent(browser, server):
+    page, errors = page_with(browser, server)
+    now = datetime.now(timezone.utc)
+    mistakes = {"ext_partial": {"back": "t_ext"}, "sign_mid": {"back": None}}
+    p = patterns_of(page, slips_at(now, (1, "t_simplify", "ext_partial"), (2, "t_simplify", "ext_partial"),
+                                   (1, "t_simplify", "sign_mid"), (2, "t_simplify", "sign_mid"), (3, "t_ext", "sign_mid")), mistakes)
+    practise = {x["m"]: x["practise"] for x in p["recurring"]}
+    assert practise == {"ext_partial": "t_ext", "sign_mid": "t_simplify"}
+    assert not errors
+
+
+def test_a_pattern_that_stopped_is_shown_as_stopped_until_60_days(browser, server):
+    page, errors = page_with(browser, server)
+    now = datetime.now(timezone.utc)
+    p = patterns_of(page, slips_at(now, *[(20, "t_ext", "sign_mid")] * 3, (70, "t_ext", "move_sign"), (75, "t_ext", "move_sign"),
+                                   (20, "t_ext", "ext_partial")))
+    assert p["recurring"] == [] and [x["m"] for x in p["stopped"]] == ["sign_mid"]   # once is not a pattern; 70 days is gone
+    assert not errors
+
+
+def test_a_wrong_review_answer_is_logged(browser, server):
+    old = (datetime.now(timezone.utc) - timedelta(days=5)).isoformat()
+    page, errors = page_with(browser, server, {"done": {"t_ext": old}, "seen": {"t_ext": old}}, no_chance=True)
+    page.locator(".mx-review").click()
+    page.locator(".mx-review-sheet .mx-choices button:not([data-right])").first.click()
+    playwright.expect(page.locator(".mx-review-sheet .mx-bad")).to_be_visible()
+    slips = progress_of(page)["slips"]
+    assert [(s["id"], s["via"]) for s in slips] == [("t_ext", "review")] and slips[0]["m"]
+    assert not errors
+
+
+def test_a_practice_exam_logs_only_its_final_picks_when_handed_in(browser, server):
+    page, errors = page_with(browser, server, now=datetime(2026, 11, 3, 10))
+    page.locator(".mx-quiz-card").click()
+    sheet = page.locator(".mx-quiz-sheet")
+    sheet.locator("[data-act=quiz-start]").click()
+    sheet.locator(".mx-choices button:not([data-right])").first.click()   # wrong, then changed to right
+    sheet.locator(".mx-choices button[data-right]").first.click()
+    for i in range(1, 12):
+        sheet.locator(f'[data-quiz-go="{i}"]').click()
+        sheet.locator(f".mx-choices button{':not([data-right])' if i in (1, 2) else '[data-right]'}").first.click()
+    assert "slips" not in progress_of(page) or not progress_of(page)["slips"]   # nothing while the exam goes on
+    sheet.locator("[data-act=quiz-submit]").click()
+    playwright.expect(sheet.locator("h3")).to_have_text("10 מתוך 12 נכונות")
+    assert [s["via"] for s in progress_of(page)["slips"]] == ["exam", "exam"]
+    assert not errors
+
+
+def test_a_left_practice_exam_logs_nothing(browser, server):
+    page, errors = page_with(browser, server, now=datetime(2026, 11, 3, 10))
+    page.locator(".mx-quiz-card").click()
+    page.locator("[data-act=quiz-start]").click()
+    page.locator(".mx-choices button:not([data-right])").first.click()
+    page.locator("[data-act=quiz-quit]").click()
+    page.locator("[data-act=quiz-quit]").click()
+    playwright.expect(page.locator(".mx-quiz-sheet")).to_be_hidden()
+    assert not progress_of(page).get("slips")
+    assert not errors
+
+
+def test_no_patterns_card_without_a_pattern(browser, server):
+    now = datetime.now(timezone.utc)
+    page, errors = page_with(browser, server, {"slips": slips_at(now, (1, "t_ext", "sign_mid"))})
+    playwright.expect(page.locator(".mx-patterns")).to_have_count(0)    # once is not a pattern
+    assert not errors
+
+
+def test_the_patterns_card_names_the_top_mistake_and_opens_what_to_practise(browser, server):
+    now = datetime.now(timezone.utc)
+    slips = slips_at(now, (1, "t_simplify", "sign_mid"), (2, "t_ext_eq", "sign_mid"), (3, "t_simplify", "sign_mid"),
+                     (1, "t_simplify", "ext_partial"), (4, "t_simplify", "ext_partial"))
+    page, errors = page_with(browser, server, {"slips": slips}, no_chance=True)
+    card = page.locator(".mx-patterns")
+    playwright.expect(card).to_contain_text("טעות סימן באיבר האמצעי")       # in two skills, before one skill
+    playwright.expect(card).to_contain_text("ב־2 מיומנויות")
+    card.click()
+    sheet = page.locator(".mx-patterns-sheet")
+    playwright.expect(sheet.locator(".mx-pattern-list li")).to_have_count(2)
+    playwright.expect(sheet.locator(".mx-pattern-list li").first).to_contain_text("3 פעמים ב־2 מיומנויות · לאחרונה אתמול")
+    assert sheet.locator(".mx-pattern-list button[data-id]").evaluate_all("els=>els.map(e=>e.dataset.id)") == [
+        "t_simplify", "t_ext"]                                           # most frequent skill; then ext_partial's back-skill
+    sheet.locator('.mx-pattern-list button[data-id="t_ext"]').click()
+    playwright.expect(page.locator(".mx-choices")).to_be_visible()         # the practice of t_ext is open
+    playwright.expect(page.locator("#mxTitle")).to_contain_text("פילוג")
+    assert not errors
+
+
+def test_a_stopped_pattern_is_shown_as_a_win(browser, server):
+    now = datetime.now(timezone.utc)
+    page, errors = page_with(browser, server, {"slips": slips_at(now, *[(20, "t_ext", "sign_mid")] * 2)}, no_chance=True)
+    card = page.locator(".mx-patterns")
+    playwright.expect(card).to_contain_text("כבר לא חוזר")
+    card.click()
+    sheet = page.locator(".mx-patterns-sheet")
+    playwright.expect(sheet).to_contain_text("כרגע אין טעות שחוזרת")
+    playwright.expect(sheet.locator(".mx-pattern-list.gone li")).to_contain_text("טעות סימן באיבר האמצעי")
+    assert not errors
+
+
+def test_the_patterns_sheet_fits_a_phone(browser, server):
+    now = datetime.now(timezone.utc)
+    slips = slips_at(now, *[(1, "t_simplify", "sign_mid")] * 2, *[(1, "t_ext", "ext_partial")] * 2,
+                     *[(2, "t_ext_eq", "move_sign")] * 2, *[(20, "t_ext", "sign_product")] * 2)
+    page, errors = page_with(browser, server, {"slips": slips}, no_chance=True)
+    page.set_viewport_size({"width": 375, "height": 812})
+    for target in (".mx-patterns", None):
+        assert page.evaluate("document.documentElement.scrollWidth<=innerWidth")
+        if target:
+            page.locator(target).click()
+            playwright.expect(page.locator(".mx-patterns-sheet .mx-pattern-list li")).to_have_count(4)
+    assert not errors
+
+
+def test_the_path_marks_the_skill_to_strengthen(browser, server):
+    now = datetime.now(timezone.utc)
+    progress = {"slips": slips_at(now, (1, "t_ext", "ext_partial"), (4, "t_simplify", "ext_partial")),
+                "done": {"t_ext": now.isoformat()}, "seen": {"t_ext": now.isoformat()}}
+    page, errors = page_with(browser, server, progress, no_chance=True)
+    assert page.locator(".mx-star.fix").evaluate_all("els=>els.map(e=>e.dataset.id)") == ["t_ext"]   # ext_partial's back-skill
+    playwright.expect(page.locator('.mx-star[data-id="t_ext"] + .mx-lbl em')).to_have_text("לחזק")
+    assert not errors
+
+
+def test_a_mistake_that_is_a_pattern_says_so_where_it_happens(browser, server):
+    now = datetime.now(timezone.utc)
+    page, errors = page_with(browser, server, {"slips": slips_at(now, (3, "t_ext_eq", "ext_partial"))}, no_chance=True)
+    page.locator('.mx-star[data-id="t_simplify"]').click()
+    page.locator(".mx-choices button[data-m=ext_partial]").first.click()   # the second time: now a pattern
+    note = page.locator(".mx-bad .mx-pattern-note")
+    playwright.expect(note).to_contain_text("2 פעמים ב־2 מיומנויות")
+    playwright.expect(page.locator('.mx-bad button[data-id="t_ext"]')).to_have_count(1)   # offered once, not twice
+    assert not errors
+
+
+def test_a_first_mistake_has_no_pattern_note(browser, server):
+    page, errors = page_with(browser, server, no_chance=True)
+    page.locator('.mx-star[data-id="t_simplify"]').click()
+    page.locator(".mx-choices button:not([data-right])").first.click()
+    playwright.expect(page.locator(".mx-bad")).to_be_visible()
+    playwright.expect(page.locator(".mx-pattern-note")).to_have_count(0)
+    assert not errors

tests/test_unit_quiz.py

@@ -0,0 +1,218 @@
+"""The summarizing quiz at the end of a unit: its content, its API, and the paper quiz in a browser.
+Answers are kept in real PostgreSQL (scan_support); the AI check is a stand-in."""
+import asyncio
+import copy
+import json
+import socket
+import threading
+import time
+
+import uvicorn
+
+import httpx
+import pytest
+
+from app.answer_grading import validate_assessment
+from app.main import create_app
+from app.math_skills import algebra9, practice_graph, problems, question_version, quiz_snapshot
+from scan_support import OWNER, OTHER, ScanAuth, answer_store, postgres_server
+from test_answer_grading import assessment
+from test_answer_scans import png
+
+QUIZ_UNITS = ["t", "t2", "k", "i"]
+
+
+@pytest.fixture(autouse=True)
+def unlocked_open_ended(monkeypatch):
+    monkeypatch.setenv("MATHLY_OPEN_ENDED_LOCKED", "0")
+    monkeypatch.setenv("ANTHROPIC_API_KEY", "test-key")
+
+
+def test_the_units_taught_first_end_with_a_quiz_worth_100():
+    units = {u["id"]: u for u in algebra9()["units"]}
+    for uid in QUIZ_UNITS:
+        quiz = units[uid]["quiz"]
+        assert quiz["minutes"] == 45 and sum(q["points"] for q in quiz["questions"]) == 100
+        assert all("choices" not in q for q in quiz["questions"])
+
+
+def test_a_broken_quiz_is_named():
+    graph = copy.deepcopy(algebra9())
+    t = next(u for u in graph["units"] if u["id"] == "t")
+    t["quiz"]["questions"][0]["points"] = 30
+    t["quiz"]["minutes"] = 0
+    k = next(u for u in graph["units"] if u["id"] == "k")
+    k["quiz"]["questions"][0]["figure"] = "A=0,0; B=1,0; poly A B Z"
+    found = problems(graph)
+    assert "t quiz: minutes must be a whole number from 5 to 120" in found
+    assert "k quiz question 1: figure names unknown point Z" in found
+    t["quiz"]["minutes"] = 45
+    assert "t quiz: points add up to 105, not 100" in problems(graph)
+
+
+def test_the_quiz_is_open_only_with_answer_storage_and_grading():
+    units = lambda g: {u["id"]: u for u in g["units"]}
+    assert units(practice_graph(True, False))["t"]["quiz"]["locked"] is False
+    assert units(practice_graph(False, False))["t"]["quiz"]["locked"] is True
+    assert units(practice_graph(True, True))["t"]["quiz"]["locked"] is True
+    q = units(practice_graph(True, False))["k"]["quiz"]["questions"][1]
+    assert q["question_version"] == question_version(quiz_snapshot(units(algebra9())["k"], 1))
+
+
+def test_quiz_answers_are_kept_and_checked_only_when_asked(answer_store, monkeypatch):
+    store = answer_store
+    app = create_app(auth=ScanAuth()); app.state.answers = store
+    calls = []
+
+    class Grader:
+        def grade(self, image, snapshot):
+            calls.append(snapshot)
+            return validate_assessment(assessment(score=100))
+    app.state.answer_grader = Grader()
+    t = next(u for u in algebra9()["units"] if u["id"] == "t")
+    version = question_version(quiz_snapshot(t, 2))
+
+    async def run():
+        async with httpx.AsyncClient(transport=httpx.ASGITransport(app=app), base_url="http://test",
+                                     headers={"Authorization": f"Bearer {OWNER}"}) as c:
+            url = "/api/math/quiz-attempts"
+            assert (await c.post(url, json={"unit": "t", "index": 9, "question_version": version})).status_code == 404
+            assert (await c.post(url, json={"unit": "q", "index": 0, "question_version": version})).status_code == 404
+            changed = await c.post(url, json={"unit": "t", "index": 2, "question_version": "old"})
+            assert (changed.status_code, changed.json()["detail"]) == (409, "question_changed")
+            first = (await c.post(url, json={"unit": "t", "index": 2, "question_version": version, "new": True})).json()
+            aid = first["attempt"]["id"]
+            assert first["attempt"]["question_id"] == "quiz:t:2"
+            assert first["attempt"]["snapshot"]["points"] == 25 and "בוחן מסכם" in first["attempt"]["snapshot"]["name"]
+            again = (await c.post(url, json={"unit": "t", "index": 2, "question_version": version})).json()
+            assert again["attempt"]["id"] == aid                                   # the sitting's attempt continues
+            other = await c.get(f"/api/math/answer-attempts/{aid}", headers={"Authorization": f"Bearer {OTHER}"})
+            assert other.status_code == 404
+            # the same steps as the page: request, confirm, lease, upload
+            scan = (await c.post(f"/api/math/answer-attempts/{aid}/scans", json={"renew": True})).json()["scan"]
+            await c.post(f"/api/math/answer-scans/{scan['id']}/confirm")
+            lease = (await c.post(f"/api/math/answer-scans/{scan['id']}/uploads", json={"key": "9f0d6c3e-8c51-4a51-9c7e-0d5f4b8a1e11"})).json()
+            up = await c.post(f"/api/math/answer-scans/{scan['id']}/uploads/{lease['lease_id']}",
+                              files={"photo": ("a.png", png(), "image/png")})
+            assert up.status_code == 200 and up.json()["attachment"]
+            await asyncio.sleep(.2)
+            assert not calls and up.json()["grading"] is None                      # not checked on upload
+            graded = (await c.post(f"/api/math/answer-attempts/{aid}/grade", json={})).json()
+            assert graded["grading"]["result"]["score"] == 100
+            assert calls == [first["attempt"]["snapshot"]]
+            monkeypatch.setenv("MATHLY_OPEN_ENDED_LOCKED", "1")
+            locked = await c.post(url, json={"unit": "t", "index": 2, "question_version": version})
+            assert (locked.status_code, locked.json()["detail"]) == (403, "open_ended_locked")
+    asyncio.run(run())
+
+
+playwright = pytest.importorskip("playwright.sync_api")
+
+
+@pytest.fixture
+def quiz_server(answer_store):
+    """The app with real answer storage, and an AI check that scores by question: 100, 60, 100, ..."""
+    app = create_app(auth=ScanAuth()); app.state.answers = answer_store
+    calls = []
+
+    class Grader:
+        def grade(self, image, snapshot):
+            calls.append(snapshot["name"])
+            return validate_assessment(assessment(score=60, reasoning_correct=False) if snapshot["name"].endswith("2")
+                                       else assessment(score=100))
+    app.state.answer_grader = Grader()
+    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)
+            yield f"http://127.0.0.1:{sock.getsockname()[1]}", calls
+        finally:
+            server.should_exit = True; thread.join(timeout=5)
+
+
+def signed_in(p, url, mobile=True):
+    from test_answer_browser import session
+    browser = p.chromium.launch()
+    page = session(browser, mobile=mobile).new_page()
+    errors = []
+    page.on("pageerror", lambda e: errors.append(str(e)))
+    page.goto(url)
+    page.locator('.mx-nav [data-view="path"]').click()
+    return browser, page, errors
+
+
+def photograph(page, i, tmp_path):
+    f = tmp_path / f"answer{i}.png"
+    f.write_bytes(png())
+    with page.expect_file_chooser() as chooser:
+        page.locator(f'[data-uq-photo="{i}"]').click()
+    chooser.value.set_files(str(f))
+    playwright.expect(page.locator(f'[data-uq-i="{i}"] [role=status]')).to_have_text("✓ התשובה נשמרה", timeout=10000)
+
+
+def test_a_unit_quiz_is_written_photographed_handed_in_and_then_checked(quiz_server, tmp_path):
+    url, calls = quiz_server
+    with playwright.sync_playwright() as p:
+        browser, page, errors = signed_in(p, url)
+        try:
+            page.locator('.mx-uquiz[data-uquiz="t"]').click()
+            playwright.expect(page.locator(".mx-uq-sheet h3")).to_have_text("בוחן מסכם")
+            page.locator("[data-act=uq-start]").click()
+            paper = page.locator(".mx-uq-paper")
+            playwright.expect(paper.locator(".mx-uq-q")).to_have_count(4)
+            playwright.expect(paper.locator(".mx-uq-clock")).to_have_text(__import__("re").compile(r"^4[45]:\d\d$"))
+            for i in range(3):   # the last question is left without an answer
+                photograph(page, i, tmp_path)
+            photograph(page, 1, tmp_path)   # a retake replaces the answer
+            assert not calls                # nothing is checked before handing in
+            paper.locator("[data-act=uq-submit]").click()
+            playwright.expect(paper.locator(".mx-quiz-warn")).to_contain_text("0 נקודות")
+            paper.locator("[data-act=uq-submit]").click()
+            sheet = page.locator(".mx-uq-sheet")
+            playwright.expect(sheet.locator("h3")).to_have_text("בוחן מסכם: 65/100", timeout=20000)   # 25 + 15 + 25 + 0
+            playwright.expect(sheet.locator(".mx-uq-verdict")).to_have_text(["נכון ומלא", "נכון בחלקו", "נכון ומלא", "לא צולמה תשובה"])
+            playwright.expect(sheet.locator(".mx-uq-qhead span")).to_have_text(["25/25 נק׳", "15/25 נק׳", "25/25 נק׳", "0/25 נק׳"])
+            assert len(calls) == 3
+            page.locator(".mx-uq-sheet .mx-x").click()
+            playwright.expect(page.locator('.mx-uquiz[data-uquiz="t"]')).to_have_attribute("aria-label", "בוחן מסכם: טכניקה אלגברית 1, 65/100")
+            page.reload()   # the result stays, and opening it again does not check again
+            page.locator('.mx-nav [data-view="path"]').click()
+            page.locator('.mx-uquiz[data-uquiz="t"]').click()
+            page.locator("[data-uq-result]").first.click()
+            playwright.expect(page.locator(".mx-uq-sheet h3")).to_have_text("בוחן מסכם: 65/100", timeout=10000)
+            assert len(calls) == 3 and not errors
+        finally:
+            browser.close()
+
+
+def test_when_the_time_and_the_photo_minutes_are_over_the_quiz_is_handed_in(quiz_server, tmp_path):
+    url, calls = quiz_server
+    with playwright.sync_playwright() as p:
+        browser, page, errors = signed_in(p, url)
+        try:
+            page.locator('.mx-uquiz[data-uquiz="k"]').click()
+            page.locator("[data-act=uq-start]").click()
+            photograph(page, 0, tmp_path)
+            page.locator(".mx-uq-paper .mx-x").click()   # leaving does not stop the clock
+            playwright.expect(page.locator('.mx-uquiz[data-uquiz="k"]')).to_have_attribute("aria-label", "בוחן מסכם: דלתון, בתהליך")
+            page.evaluate("""()=>{ const k=Object.keys(localStorage).find(k=>k.startsWith('mathly.progress.v1:'));
+              const P=JSON.parse(localStorage.getItem(k)); P.uq.k.sitting.started-=50*60000; localStorage.setItem(k,JSON.stringify(P)); }""")
+            page.reload()
+            page.locator('.mx-nav [data-view="path"]').click()
+            page.locator('.mx-uquiz[data-uquiz="k"]').click()   # 50 minutes in: the photo minutes are running
+            playwright.expect(page.locator(".mx-uq-banner")).to_contain_text("הזמן לכתיבה נגמר")
+            page.locator(".mx-uq-paper .mx-x").click()
+            page.evaluate("""()=>{ const k=Object.keys(localStorage).find(k=>k.startsWith('mathly.progress.v1:'));
+              const P=JSON.parse(localStorage.getItem(k)); P.uq.k.sitting.started-=10*60000; localStorage.setItem(k,JSON.stringify(P)); }""")
+            page.reload()
+            page.locator('.mx-nav [data-view="path"]').click()
+            page.locator('.mx-uquiz[data-uquiz="k"]').click()   # over: handed in as it is, and checked
+            playwright.expect(page.locator(".mx-uq-sheet h3")).to_have_text("בוחן מסכם: 20/100", timeout=20000)
+            playwright.expect(page.locator(".mx-uq-sheet .mx-src")).to_contain_text("הוגש כשהזמן נגמר")
+            assert len(calls) == 1 and not errors
+        finally:
+            browser.close()