AI review per question; the mistakes round shows where each question came from; a 15-question practice test on the weak topics

- Board review: one Gemini request per question (paced for the free tier), each result saved and shown as it comes, then a short
text-only summary. A stopping failure (quota, key) keeps what was checked; the teacher can check or re-check one question alone.
- Mistakes round: each question shows its number in the test and what was chosen there.
- Exercise test 3 (מבחן תרגול: נושאים לחיזוק): 15 questions from the skills that lost points in the test's exercise tests or simulation,
or are still being learned. Not part of the readiness score. On the test card and on a result.

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

mathly2/boardreview.py

@@ -32,26 +32,23 @@ RETRIES = 3                                       # tries after "too many reques
 SIDE = 1280                                       # a board is shrunk to this longest side before it is sent
 VERDICTS = ("correct", "partial", "wrong", "unclear")
 
-INSTRUCTIONS = """אתם מורים למתמטיקה בכיתה ט בישראל. תלמיד פתר מבחן אמריקאי, ולכל שאלה כתב את הדרך על לוח. קיבלתם את השאלות, התשובות האפשריות, \
-התשובה הנכונה (רק בשבילכם), התשובה שהתלמיד בחר, ותמונה של הלוח שלו לכל שאלה.
-לכל שאלה עם לוח, הַעריכו את הדרך (לא רק את התשובה הסופית):
+INSTRUCTIONS = """אתם מורים למתמטיקה בכיתה ט בישראל. תלמיד פתר שאלה אמריקאית במבחן, וכתב את הדרך על לוח. קיבלתם את השאלה, התשובות האפשריות, \
+התשובה הנכונה (רק בשבילכם), התשובה שהתלמיד בחר, ותמונה של הלוח שלו.
+הַעריכו את הדרך (לא רק את התשובה הסופית):
 - verdict: "correct" אם הדרך נכונה ומובילה לתשובה; "partial" אם יש התחלה נכונה או רעיון נכון אבל טעות או חוסר; "wrong" אם השיטה שגויה; "unclear" אם אי אפשר לקרוא או שאין בלוח דרך של ממש.
 - feedback: משפט או שניים לתלמיד, בעברית, בפנייה ברבים (אתם), חם וענייני: מה טוב בדרך, ואם יש טעות, איפה היא הטעות הראשונה ומה סוגה.
 - tip: טיפ אחד קצר ומעשי לפעם הבאה.
 אסור לכתוב את התשובה הסופית הנכונה, את המספר שלה או איזו אפשרות נכונה. אם התלמיד טעה, כוונו אותו לשלב, אל תפתרו בשבילו.
-summary: משפט או שניים על הדרך במבחן כולו: חוזקה אחת ודבר אחד לשפר.
 נוסחאות כתבו בתוך $...$."""
 
-SCHEMA = {
-    "type": "OBJECT",
-    "properties": {
-        "summary": {"type": "STRING"},
-        "questions": {"type": "ARRAY", "items": {"type": "OBJECT", "properties": {
-            "n": {"type": "INTEGER"}, "verdict": {"type": "STRING", "enum": list(VERDICTS)},
-            "feedback": {"type": "STRING"}, "tip": {"type": "STRING"}}, "required": ["n", "verdict", "feedback", "tip"]}},
-    },
-    "required": ["summary", "questions"],
-}
+SUMMARY_INSTRUCTIONS = """אתם מורים למתמטיקה בכיתה ט. לפניכם הערכות של הדרך של תלמיד בשאלות של מבחן אחד (לכל שאלה: הנושא, הערכה ומשוב).
+כתבו summary: משפט או שניים לתלמיד, בעברית, בפנייה ברבים (אתם): חוזקה אחת בדרך ודבר אחד לשפר. בלי תשובות נכונות ובלי מספרים של תשובות."""
+
+SCHEMA = {"type": "OBJECT", "properties": {"verdict": {"type": "STRING", "enum": list(VERDICTS)}, "feedback": {"type": "STRING"}, "tip": {"type": "STRING"}},
+          "required": ["verdict", "feedback", "tip"]}
+SUMMARY_SCHEMA = {"type": "OBJECT", "properties": {"summary": {"type": "STRING"}}, "required": ["summary"]}
+STOPPING = ("rate_limited", "api_key_invalid", "permission", "model_not_found", "no_connection")   # no point in asking about the next question
+MIN_GAP = 5.0                                   # seconds between requests: the free tier counts requests a minute
 
 
 class ReviewFailure(Exception):
@@ -76,19 +73,18 @@ def _letter(i: int) -> str:
 class GeminiReviewer:
     """Gemini over its REST API (no SDK). `review(items)` -> {"summary", "questions": [{n, verdict, feedback, tip}]}."""
 
-    def __init__(self, key: str, model: str = "", sleep=time.sleep) -> None:
-        self.key, self.model, self.sleep = key, clean_model(model) or DEFAULT_MODEL, sleep
+    def __init__(self, key: str, model: str = "", sleep=time.sleep, gap: float = MIN_GAP, now=time.monotonic) -> None:
+        self.key, self.model, self.sleep, self.gap, self.now = key, clean_model(model) or DEFAULT_MODEL, sleep, gap, now
+        self._last = None
         self._lock = threading.Lock()                   # one request at a time: the free tier counts requests a minute
 
-    def _parts(self, items: list[dict]) -> list[dict]:
-        parts = [{"text": INSTRUCTIONS}]
-        for it in items:
-            choices = "\n".join(f"  {_letter(i)}. {c}" for i, c in enumerate(it["choices"]))
-            picked = _letter(it["picked"]) if it["picked"] is not None else "לא ענה"
-            parts.append({"text": f"\n\nשאלה {it['n']}:\n{it['question']}\nאפשרויות:\n{choices}\nהתשובה הנכונה (לא לגלות): {_letter(it['correct'])}\n"
-                                  f"התלמיד בחר: {picked}\nהלוח של התלמיד לשאלה {it['n']}:"})
-            parts.append({"inline_data": {"mime_type": "image/jpeg", "data": base64.b64encode(_small(it["image"])).decode()}})
-        return parts
+    def _parts(self, item: dict) -> list[dict]:
+        choices = "\n".join(f"  {_letter(i)}. {c}" for i, c in enumerate(item["choices"]))
+        picked = _letter(item["picked"]) if item["picked"] is not None else "לא ענה"
+        return [{"text": INSTRUCTIONS},
+                {"text": f"\n\nהשאלה:\n{item['question']}\nאפשרויות:\n{choices}\nהתשובה הנכונה (לא לגלות): {_letter(item['correct'])}\n"
+                         f"התלמיד בחר: {picked}\nהלוח של התלמיד:"},
+                {"inline_data": {"mime_type": "image/jpeg", "data": base64.b64encode(_small(item["image"])).decode()}}]
 
     def _call(self, body: bytes) -> dict:
         request = urllib.request.Request(ENDPOINT.format(model=self.model), data=body, method="POST",
@@ -111,11 +107,24 @@ class GeminiReviewer:
             return None
         return pick_model(names, self.model)
 
-    def review(self, items: list[dict], on_event=lambda step, **info: None) -> dict:
-        body = json.dumps({"contents": [{"role": "user", "parts": self._parts(items)}],
-                           "generationConfig": {"temperature": 0.2, "responseMimeType": "application/json", "responseSchema": SCHEMA}}).encode()
+    def review_one(self, item: dict, on_event=lambda step, **info: None) -> dict:
+        """One question with its board -> {verdict, feedback, tip}."""
+        return self._ask(self._parts(item), SCHEMA, on_event)
+
+    def summarize(self, reviewed: list[dict], on_event=lambda step, **info: None) -> str:
+        """A line about the way in the whole test, from the per-question reviews (text only, no pictures)."""
+        lines = "\n".join(f"שאלה {r['n']} ({r.get('skill', '')}): {r['verdict']}. {r['feedback']}" for r in reviewed)
+        return str(self._ask([{"text": SUMMARY_INSTRUCTIONS}, {"text": "\n\n" + lines}], SUMMARY_SCHEMA, on_event).get("summary") or "")
+
+    def _ask(self, parts: list[dict], schema: dict, on_event) -> dict:
+        body = json.dumps({"contents": [{"role": "user", "parts": parts}],
+                           "generationConfig": {"temperature": 0.2, "responseMimeType": "application/json", "responseSchema": schema}}).encode()
         with self._lock:
             for attempt in range(RETRIES + 1):
+                if self._last is not None and self.gap:                     # keep under the free tier's requests a minute
+                    left = self.gap - (self.now() - self._last)
+                    if left > 0:
+                        self.sleep(left)
                 try:
                     data = self._call(body)
                     break
@@ -125,7 +134,7 @@ class GeminiReviewer:
                         wait = _retry_after(detail, 20 * (attempt + 1))
                         on_event("busy", seconds=round(wait))
                         self.sleep(wait)
-                        on_event("sent")
+                        on_event("resumed")
                         continue
                     if exc.code == 404 and not getattr(self, "_switched", False):
                         other = self._another_model()
@@ -137,12 +146,16 @@ class GeminiReviewer:
                                          429: "rate_limited"}.get(exc.code, "provider_error"), f"HTTP {exc.code} ({self.model}): {detail}") from None
                 except (urllib.error.URLError, TimeoutError) as exc:
                     raise ReviewFailure("no_connection", str(exc)[:300]) from None
+                finally:
+                    self._last = self.now()
         try:
             candidate = data["candidates"][0]
             if candidate.get("finishReason") not in (None, "STOP"):
                 raise ReviewFailure("incomplete", str(candidate.get("finishReason")))
             text = "".join(p.get("text", "") for p in candidate["content"]["parts"] if not p.get("thought"))
             out = json.loads(text)
+            if not isinstance(out, dict):
+                raise ValueError("not an object")
         except ReviewFailure:
             raise
         except (KeyError, IndexError, ValueError, TypeError) as exc:
@@ -202,48 +215,79 @@ def _items(app, row: dict) -> tuple[list[dict], dict]:
             continue
         correct = next((c["index"] for c in served["choices"] if (bank.grade(q["skill_id"], q["key"], c["index"]) or {}).get("correct")), 0)
         picked = row["answers"].get(q["key"])
-        items.append({"n": n, "question": served["question"], "choices": [c["text"] for c in served["choices"]], "correct": correct,
+        items.append({"n": n, "skill": (bank.skill(q["skill_id"]) or {}).get("name", ""),
+                      "question": served["question"], "choices": [c["text"] for c in served["choices"]], "correct": correct,
                       "picked": picked if isinstance(picked, int) else None, "image": app.state.pictures.get(picture["path"])})
         keys[n] = q["key"]
     return items, keys
 
 
-def run(app, attempt_id: str) -> None:
-    """Review one handed-in attempt and store the result on it. Never raises: a failure is stored as {"state": "failed"}.
-    While it runs, its steps are stored on the pending review (`events`: boards found, sent, the AI busy and waiting), for the screens."""
-    store = app.state.store
+def _clean(got: dict) -> dict | None:
+    if not isinstance(got, dict) or got.get("verdict") not in VERDICTS:
+        return None
+    return {"verdict": got["verdict"], "feedback": str(got.get("feedback", ""))[:600], "tip": str(got.get("tip", ""))[:300]}
+
+
+def run(app, attempt_id: str, keys: list[str] | None = None) -> None:
+    """Review a handed-in attempt question by question (`keys`: only these, kept with the earlier review of the rest), then a summary line.
+    Never raises: a review with no question checked is stored as {"state": "failed", "reason"}. While it runs, the pending review carries
+    its steps (`events`) and the questions checked so far, for the screens."""
+    store, reviewer = app.state.store, app.state.reviewer
     started = clock.now().isoformat()
     events: list[dict] = []
+    row = store.get_attempt(attempt_id)
+    earlier = (row.get("review") or {}) if row and keys else {}          # one question: the rest of the review (kept on the pending one) stays
+    questions: dict = dict(earlier.get("questions") or {})
 
-    def event(step: str, **info) -> None:
-        events.append({"step": step, "at": clock.now().isoformat(), **info})
+    def save(review: dict) -> None:
         try:
-            store.save_attempt(attempt_id, review={"state": "pending", "at": started, "events": list(events)})
+            store.save_attempt(attempt_id, review=review)
         except Exception:                                  # the steps are a courtesy: never fail the review for them
             log.warning("could not save a review step")
+
+    def event(step: str, **info) -> None:
+        events.append({"step": step, "at": clock.now().isoformat(), **info})
+        save({"state": "pending", "at": started, "events": list(events), "questions": dict(questions), "summary": earlier.get("summary")})
+
+    reason, checked = None, 0
     try:
-        row = store.get_attempt(attempt_id)
-        items, keys = _items(app, row)
+        items, by_n = _items(app, row)
+        if keys:
+            items = [it for it in items if by_n[it["n"]] in keys]
         event("boards", count=len(items), total=len(row["questions"]))
-        if not items:
-            result = {"state": "done", "summary": None, "questions": {}}
+        reviewed = []
+        for i, item in enumerate(items):
+            key = by_n[item["n"]]
+            event("question", n=item["n"], i=i + 1, of=len(items))
+            try:
+                got = _clean(reviewer.review_one(item, on_event=event))
+            except ReviewFailure as exc:
+                log.warning("board review of a question failed: %s %s", exc.reason, exc.detail)
+                reason = exc.reason
+                if exc.reason in STOPPING:
+                    break
+                continue
+            if got is None:
+                reason = "bad_output"
+                continue
+            questions[key], checked = got, checked + 1
+            reviewed.append({"n": item["n"], "skill": item["skill"], **got})
+        summary = earlier.get("summary")
+        if reviewed and not keys:
+            event("summary")
+            try:
+                summary = reviewer.summarize(reviewed, on_event=event)[:800] or None
+            except ReviewFailure as exc:
+                log.warning("board review summary failed: %s", exc.reason)
+        if items and not checked:
+            result = {"state": "failed", "reason": reason or "provider_error", "model": getattr(reviewer, "model", None)}
         else:
-            event("sent")
-            got = app.state.reviewer.review(items, on_event=event)
-            questions = {}
-            for q in got.get("questions", []):
-                key = keys.get(q.get("n"))
-                if key and q.get("verdict") in VERDICTS:
-                    questions[key] = {"verdict": q["verdict"], "feedback": str(q.get("feedback", ""))[:600], "tip": str(q.get("tip", ""))[:300]}
-            result = {"state": "done", "summary": str(got.get("summary") or "")[:800] or None, "questions": questions}
-        result["at"] = clock.now().isoformat()
-    except ReviewFailure as exc:
-        log.warning("board review failed: %s %s", exc.reason, exc.detail)
-        result = {"state": "failed", "reason": exc.reason, "at": clock.now().isoformat(),
-                  "model": getattr(app.state.reviewer, "model", None)}
+            result = {"state": "done", "summary": summary, "questions": questions, "missing": len(items) - checked,
+                      **({"reason": reason} if reason and checked < len(items) else {})}
     except Exception:
         log.exception("board review failed")
-        result = {"state": "failed", "reason": "provider_error", "at": clock.now().isoformat()}
+        result = {"state": "failed", "reason": "provider_error"}
+    result["at"] = clock.now().isoformat()
     try:
         store.save_attempt(attempt_id, review=result)
     finally:
@@ -251,11 +295,11 @@ def run(app, attempt_id: str) -> None:
             _running.discard(attempt_id)
 
 
-def start_in_thread(app, attempt_id: str) -> None:
-    threading.Thread(target=run, args=(app, attempt_id), name="board-review", daemon=True).start()
+def start_in_thread(app, attempt_id: str, keys: list[str] | None = None) -> None:
+    threading.Thread(target=run, args=(app, attempt_id, keys), name="board-review", daemon=True).start()
 
 
-def ensure(app, row: dict, force: bool = False) -> dict:
+def ensure(app, row: dict, force: bool = False, keys: list[str] | None = None) -> dict:
     """For a handed-in practice test or simulation: start its review if it has none yet (or a lost one). Returns the row as it is now.
     `force` (the teacher asked): any graded attempt, and again after a failed or a finished review."""
     if row["submitted_at"] is None or getattr(app.state, "reviewer", None) is None:
@@ -271,13 +315,18 @@ def ensure(app, row: dict, force: bool = False) -> dict:
             return row
         _running.add(row["id"])
     try:
-        row = app.state.store.save_attempt(row["id"], review={"state": "pending", "at": clock.now().isoformat()})
+        earlier = row.get("review") or {}
+        row = app.state.store.save_attempt(row["id"], review={"state": "pending", "at": clock.now().isoformat(),
+                                                              **({"questions": earlier.get("questions", {}), "summary": earlier.get("summary")} if keys else {})})
     except Exception:                                   # e.g. the review column's migration was not run: the result still shows
         log.exception("board review could not be saved")
         with _running_lock:
             _running.discard(row["id"])
         return {**row, "review": {"state": "failed", "reason": "database"}}
-    app.state.run_review(app, row["id"])
+    if keys:
+        app.state.run_review(app, row["id"], keys)
+    else:
+        app.state.run_review(app, row["id"])
     return app.state.store.get_attempt(row["id"]) or row
 
 
@@ -287,7 +336,7 @@ def student_view(row: dict) -> dict | None:
     if not review:
         return None
     if review["state"] == "pending":
-        return {"state": "pending", "at": review.get("at"), "events": review.get("events", [])}
+        return {"state": "pending", "at": review.get("at"), "events": review.get("events", []), "questions": review.get("questions", {})}
     if review["state"] != "done":
         return {"state": review["state"]}
     return {"state": "done", "summary": review.get("summary"), "questions": review.get("questions", {})}

mathly2/boardwork.py

@@ -89,7 +89,9 @@ def _title(request: Request, row: dict) -> str:
     test_id, _, number = row["scope"].partition(":")
     test = store.get_test(int(test_id)) if test_id.isdigit() else None
     when = f" ({test['date'].day}.{test['date'].month})" if test else ""
-    return (f"מבחן תרגול {number}" if row["kind"] == "exercise_test" else "מבחן סימולציה") + when
+    from .exam import FOCUS
+    name = ("מבחן תרגול: נושאים לחיזוק" if number == str(FOCUS) else f"מבחן תרגול {number}") if row["kind"] == "exercise_test" else "מבחן סימולציה"
+    return name + when
 
 
 def _iso(value):
@@ -151,7 +153,7 @@ def _ai_state(request: Request, row: dict) -> dict:
     review = row.get("review") or {}
     return {"available": getattr(request.app.state, "reviewer", None) is not None, "state": review.get("state"),
             "reason": review.get("reason"), "summary": review.get("summary"), "model": review.get("model"),
-            "at": review.get("at"), "events": review.get("events", [])}
+            "at": review.get("at"), "events": review.get("events", []), "missing": review.get("missing", 0)}
 
 
 @router.get("/teaching/work/{attempt_id}")
@@ -161,12 +163,18 @@ def work_open(attempt_id: str, request: Request, user: dict = Depends(need("clas
 
 
 @router.post("/teaching/work/{attempt_id}/review")
-def work_review(attempt_id: str, request: Request, user: dict = Depends(need("class.teach"))) -> dict:
-    """The teacher asks for the AI review (again): after a failure, for a lesson quiz, or for a fresh look."""
+def work_review(attempt_id: str, request: Request, key: str | None = Query(None, max_length=200),
+                user: dict = Depends(need("class.teach"))) -> dict:
+    """The teacher asks for the AI review (again): of the whole attempt, or of one question (`key`)."""
     from . import boardreview
     if getattr(request.app.state, "reviewer", None) is None:
         raise HTTPException(409, "בדיקה עם AI לא מוגדרת בשרת: חסר GEMINI_API_KEY")
-    return teacher_view(request, boardreview.ensure(request.app, _graded_attempt(request, user, attempt_id), force=True))
+    row = _graded_attempt(request, user, attempt_id)
+    if key is not None and key not in {q["key"] for q in row["questions"]}:
+        raise HTTPException(404, "השאלה לא נמצאה")
+    if key is not None and key not in request.app.state.store.work_of(row["user_id"], row["id"]):
+        raise HTTPException(409, "אין לוח לשאלה הזו")
+    return teacher_view(request, boardreview.ensure(request.app, row, force=True, keys=[key] if key else None))
 
 
 class Credit(BaseModel):

mathly2/exam.py

@@ -5,6 +5,8 @@ from __future__ import annotations
 import random
 
 EXERCISE_SHARE = {1: 0.6, 2: 0.3}      # the share of questions that come from weak skills in exercise test 1 and 2; the simulation has none
+FOCUS = 3                               # the exercise test on the weak topics: only the skills that lost points or are still being learned
+FOCUS_SIZE = 15
 
 
 def _round(x: float) -> int:
@@ -55,3 +57,21 @@ def draw(bank, lessons: list[str], states: dict[str, str], n: int, *, share: flo
                     progress = True
     rng.shuffle(taken)
     return {"questions": taken[:n], "weak": weak, "practice_first": practice_first}
+
+
+def draw_focus(bank, weak: list[str], n: int = FOCUS_SIZE, used: dict[str, int] | None = None, rng: random.Random | None = None) -> list[dict]:
+    """`n` questions from the weak skills only, one per skill round after round (least-used questions first)."""
+    used, rng = used or {}, rng or random.Random()
+    pools = {i: sorted(bank.question_keys(i), key=lambda key: (used.get(key, 0), rng.random())) for i in weak if bank.question_keys(i)}
+    order, taken, seen = rng.sample(list(pools), len(pools)), [], set()
+    progress = True
+    while len(taken) < n and progress:
+        progress = False
+        for skill_id in order:
+            key = next((k for k in pools[skill_id] if k not in seen), None)
+            if key and len(taken) < n:
+                seen.add(key)
+                taken.append({"skill_id": skill_id, "key": key})
+                progress = True
+    rng.shuffle(taken)
+    return taken

mathly2/realtests.py

@@ -82,9 +82,10 @@ def facts_for(request: Request, user_id: str | None, test: dict, today: date) ->
         rows = here.attempts_of(user_id, kind) if user_id else []
         return [attempts.settle(store, bank, r, now) for r in rows if r["scope"] == tid or r["scope"].startswith(tid + ":")]
 
-    exercise = {1: [], 2: []}
+    exercise, focus = {1: [], 2: []}, []
     for row in mine("exercise_test"):
-        exercise[int(row["scope"].split(":")[1])].append(row)
+        number = int(row["scope"].split(":")[1])
+        (focus if number == exam.FOCUS else exercise[number]).append(row)
     simulation = next(iter(mine("simulation")), None)
     submitted = lambda rows: [r for r in rows if not attempts.is_open(r)]
     best = {n: max((r["grade"] for r in submitted(rows)), default=None) for n, rows in exercise.items()}
@@ -100,14 +101,20 @@ def facts_for(request: Request, user_id: str | None, test: dict, today: date) ->
     sim_taken = bool(simulation and not attempts.is_open(simulation))
     stale = sorted(covered, key=lambda i: (last.get(i) is not None, last.get(i) or date.min))
     used: dict[str, int] = {}
-    for rows in list(exercise.values()) + [[simulation] if simulation else []]:
+    for rows in list(exercise.values()) + [focus, [simulation] if simulation else []]:
         for r in rows:
             for q in r["questions"]:
                 used[q["key"]] = used.get(q["key"], 0) + 1
     return {"covered": covered, "states": states, "mastered": len(mastered), "path_done": bool(covered) and not unmastered,
             "next_path_skill": unmastered[0] if unmastered else None, "exercise": exercise, "best": best, "simulation": simulation,
             "sim_taken": sim_taken, "ex1_done": bool(submitted(exercise[1])), "ex2_done": bool(submitted(exercise[2])),
-            "weak_before": weak_before, "failed": failed, "review_left": review_left, "stale": stale, "used": used}
+            "weak_before": weak_before, "failed": failed, "review_left": review_left, "stale": stale, "used": used, "focus": focus,
+            "focus_skills": _focus_skills(bank, covered, states, weak_before | set(failed) | {s["id"] for r in submitted(focus) for s in attempts.result(bank, r)["lost_skills"]})}
+
+
+def _focus_skills(bank, covered: list[str], states: dict[str, str], lost: set[str]) -> list[str]:
+    """The weak topics of a test: covered skills that lost points in its exercise tests or simulation, or are still being learned."""
+    return [i for i in covered if (i in lost or states.get(i) == "learning") and bank.question_keys(i)]
 
 
 def readiness_for(facts: dict) -> dict:
@@ -135,11 +142,15 @@ def card(request: Request, user_id: str | None, test: dict, today: date) -> dict
                           "open": bool(open_), "due_at": open_["due_at"].isoformat() if open_ and attempts.is_timed(open_) else None})
     sim = facts["simulation"]
     opens_in = max(0, days_left - p["sim"])
+    focus_open = next((r for r in facts["focus"] if attempts.is_open(r)), None)
+    focus_done = [r for r in facts["focus"] if not attempts.is_open(r)]
+    focus = {"number": exam.FOCUS, "size": exam.FOCUS_SIZE, "skills": [{"id": i, "name": bank.skill(i)["name"]} for i in facts["focus_skills"]],
+             "best": max((r["grade"] for r in focus_done), default=None), "attempts": len(focus_done), "open": bool(focus_open)}
     return {"id": test["id"], "date": test["date"].isoformat(), "days_left": days_left, "note": test["note"], "subject_id": test.get("subject_id", "math"),
             "lessons": [{"id": i, "name": n} for i, n in zip(test["lessons"], lesson_names(request, test["lessons"]))],
             "questions": test["questions"], "minutes": test["minutes"],
             "plan": countdown.outline(p, facts), "task": countdown.task(days_left, p, facts), "readiness": readiness_for(facts),
-            "exercise_tests": exercises,
+            "exercise_tests": exercises, "focus": focus,
             "practice_first": [{"id": i, "name": bank.skill(i)["name"]} for i in facts["covered"] if facts["states"].get(i, "not_started") == "not_started"],
             "simulation": {"open_now": countdown.sim_open(days_left, p), "opens_in_days": opens_in,
                            "opens_on": (test["date"] - timedelta(days=p["sim"])).isoformat(), "required": countdown.sim_open(days_left, p) and not facts["sim_taken"],
@@ -313,10 +324,16 @@ def _start(request: Request, user: dict, test: dict, kind: str, scope: str, shar
     from .quizzes import view
     store, bank, now = request.app.state.store, request.app.state.bank, clock.now()
     facts = facts_for(request, user["id"], test, clock.school_day())
-    mine = [r for r in (facts["exercise"][int(scope.split(":")[1])] if kind == "exercise_test" else [facts["simulation"]] if facts["simulation"] else [])]
+    number = int(scope.split(":")[1]) if kind == "exercise_test" else None
+    mine = facts["focus"] if number == exam.FOCUS else facts["exercise"][number] if kind == "exercise_test" else [facts["simulation"]] if facts["simulation"] else []
     for row in mine:
         if attempts.is_open(row) or kind == "simulation":           # open: resume; the simulation is taken once, so its result comes back
             return view(request, row)
+    if number == exam.FOCUS:                                        # the weak topics only, FOCUS_SIZE questions, untimed like the others
+        if not facts["focus_skills"]:
+            raise HTTPException(409, "אין כרגע נושאים לחיזוק במבחן הזה. כל הכבוד!")
+        drawn = exam.draw_focus(bank, facts["focus_skills"], used=facts["used"], rng=getattr(request.app.state, "quiz_rng", None))
+        return view(request, store.create_attempt(user["id"], kind, scope, now, now + timedelta(minutes=test["minutes"]), drawn))
     drawn = exam.draw(bank, test["lessons"], facts["states"], test["questions"], share=share, weak_before=facts["weak_before"], used=facts["used"],
                       include_unstarted=include_unstarted)
     if not drawn["questions"] and kind == "exercise_test" and not include_unstarted:     # nothing started yet: all the material, like the simulation
@@ -331,9 +348,11 @@ def _start(request: Request, user: dict, test: dict, kind: str, scope: str, shar
 @router.post("/tests/{test_id}/exercise/{number}/start")
 def start_exercise(test_id: int, number: int, request: Request, user: dict = Depends(learner),
                    all_skills: bool = Query(False, description="the simulation's material: every skill of the test's lessons, started or not, evenly")) -> dict:
-    if number not in exam.EXERCISE_SHARE:
+    if number not in exam.EXERCISE_SHARE and number != exam.FOCUS:
         raise HTTPException(404, "מבחן התרגול לא נמצא")
     test = _student_test(request, user, test_id)
+    if number == exam.FOCUS:
+        return _start(request, user, test, "exercise_test", f"{test_id}:{number}", 1.0)
     share = 0.0 if all_skills else exam.EXERCISE_SHARE[number]        # all_skills: drawn like the simulation (an even spread, no weak share)
     return _start(request, user, test, "exercise_test", f"{test_id}:{number}", share, all_skills)
 

mathly2/rounds.py

@@ -117,11 +117,14 @@ def view(request: Request, row: dict) -> dict:
         lesson = next((l for l in bank.lessons if l["id"] == row["scope"]), {"id": row["scope"], "name": row["scope"]})
     done = _graded(bank, row)
     base = {"id": row["id"], "kind": row["kind"], "lesson": {"id": lesson["id"], "name": lesson["name"]}, "subject_id": lesson.get("subject_id", "math"),
-            "total": len(row["questions"]), "results": [right for _, right, _ in done], "source": source}
+            "total": len(row["questions"]), "results": [right for _, right, _ in done], "source": _public(source)}
     if attempts.is_open(row):
         nxt = row["questions"][len(done)] if len(done) < len(row["questions"]) else None
         served = bank.practice_question(nxt["skill_id"], nxt["key"]) if nxt else None
-        return {**base, "state": "open", "question": {**served, "skill_name": bank.skill(nxt["skill_id"])["name"]} if served else None}
+        question = {**served, "skill_name": bank.skill(nxt["skill_id"])["name"]} if served else None
+        if question and source:
+            question["context"] = _context(bank, source, nxt["key"], nxt["skill_id"])
+        return {**base, "state": "open", "question": question, "source": _public(source)}
     uid = row["user_id"]
     progress = {p["skill_id"]: p for p in store.progress_of(uid)}
     started = _when(row["started_at"])
@@ -145,9 +148,10 @@ def view(request: Request, row: dict) -> dict:
             continue
         served = bank.practice_question(q["skill_id"], q["key"])
         missed.append({"question": served["question"] if served else "", "skill_name": (bank.skill(q["skill_id"]) or {}).get("name", ""),
+                       "n": source["_order"].get(q["key"]) if source else None,
                        "mistake": {"name": mistake["name"], "tip": mistake["tip"]} if mistake else None})
     stars_now = None if source else _lesson_stars(request, uid, row["scope"], store.attempts_of(uid, KIND, row["scope"]))
-    return {**base, "state": "done", "question": None,
+    return {**base, "state": "done", "question": None, "source": _public(source),
             "result": {"right": sum(base["results"]), "total": base["total"], "grade": row["grade"], "stars": stars_now,
                        "mastered": mastered, "almost": almost, "missed": missed}}
 
@@ -164,9 +168,24 @@ def _source_info(request: Request, row: dict) -> dict:
     source = request.app.state.store.get_attempt(row["scope"])
     kind = source["kind"] if source else "quiz"
     test_id = int(source["scope"].split(":")[0]) if source and kind != "quiz" and source["scope"].split(":")[0].isdigit() else None
-    name = {"quiz": "הבוחן", "exercise_test": "מבחן התרגול", "simulation": "מבחן הסימולציה"}[kind]
+    from .boardwork import _title
+    name = _title(request, source) if source else "הבוחן"
     return {"id": row["scope"], "kind": kind, "test_id": test_id, "lesson_id": source["scope"] if source and kind == "quiz" else None,
-            "title": f"חזרה על הטעויות ב{name}"}
+            "title": name, "total": len(source["questions"]) if source else None,
+            "_order": {q["key"]: i + 1 for i, q in enumerate(source["questions"])} if source else {},
+            "_answers": source["answers"] if source else {}}
+
+
+def _public(source: dict | None) -> dict | None:
+    return {k: v for k, v in source.items() if not k.startswith("_")} if source else None
+
+
+def _context(bank, source: dict, key: str, skill_id: str) -> dict:
+    """Where a question of a mistakes round came from: its number in the test, and what was chosen there (never whether it was right)."""
+    served = bank.practice_question(skill_id, key) or {"choices": []}
+    choice = source["_answers"].get(key)
+    picked = next((c["text"] for c in served["choices"] if c["index"] == choice), None) if isinstance(choice, int) else None
+    return {"title": source["title"], "n": source["_order"].get(key), "of": source["total"], "picked": picked}
 
 
 @router.post("/attempts/{attempt_id}/retry/start")

mathly2/static/app.css

@@ -705,3 +705,9 @@ body:has(#lesson-map) p:has(> #to-subjects) { margin-block: 0 4px; }
 .rv-steps li.rv-now { font-weight: 600; }
 .rv-steps .rv-ok { color: var(--ok, #15803d); }
 .rv-time { margin: 2px 0 0; font-size: .9em; }
+.rd-context { margin-bottom: 6px; }
+.rd-context p { margin: 4px 0 0; }
+.focus-skills { display: flex; flex-wrap: wrap; gap: 6px; }
+.rv-bar { height: 6px; border-radius: 3px; background: var(--line); overflow: hidden; margin: 6px 0; }
+.rv-bar i { display: block; height: 100%; background: var(--accent); transition: width .4s; }
+.work-ai-run { font-size: .9em; padding: 4px 10px; }

mathly2/static/grades.js

@@ -25,7 +25,7 @@ function draw(view, { quizzes, exercise_tests: exercises = [], simulations = [],
     ${quizzes.length ? `<h3>בחנים</h3><ul class="plain grades" id="quiz-grades">${quizzes.map(g => row({ attrs: `data-lesson="${esc(g.lesson.id)}"`, href: `#/quiz/${esc(g.lesson.id)}`,
       title: fmt(g.lesson.name), best: g.best, attempts: g.attempts, last: g.last })).join("")}</ul>` : ""}
     ${exercises.length ? `<h3>מבחני תרגול</h3><ul class="plain grades" id="exercise-grades">${exercises.map(g => row({ attrs: `data-test="${g.test.id}" data-number="${g.number}"`,
-      href: `#/test/${g.test.id}`, title: testTitle(g.test, `מבחן תרגול ${g.number}`), best: g.best, attempts: g.attempts, last: g.last })).join("")}</ul>` : ""}
+      href: `#/test/${g.test.id}`, title: testTitle(g.test, g.number === 3 ? "מבחן תרגול: נושאים לחיזוק" : `מבחן תרגול ${g.number}`), best: g.best, attempts: g.attempts, last: g.last })).join("")}</ul>` : ""}
     ${assignments.length ? `<h3>משימות</h3><ul class="plain grades" id="assignment-grades">${assignments.map(g => `<li data-assignment="${g.assignment.id}">
         <a href="#/assignment/${g.assignment.id}"><b>${fmt(g.assignment.title)}</b>${g.assignment.removed ? " (הוסרה)" : ""}</a>
         <span class="gr-num" aria-label="הציון ${g.grade}">${g.grade}</span>

mathly2/static/quiz.js

@@ -46,7 +46,8 @@ export async function startSimulation(testId, allSkills = false) {
 }
 
 /** What the sheet is called, who it is about and where closing it leads, by kind. */
-const names = a => a.kind === "exercise_test" ? { title: `מבחן תרגול ${a.test.number}`, again: "מבחן חוזר" }
+const FOCUS = 3;                                     // the exercise test on the weak topics
+const names = a => a.kind === "exercise_test" ? (a.test.number === FOCUS ? { title: "מבחן תרגול: נושאים לחיזוק", again: "עוד מבחן על הנושאים" } : { title: `מבחן תרגול ${a.test.number}`, again: "מבחן חוזר" })
   : a.kind === "simulation" ? { title: "מבחן סימולציה", again: "" } : { title: "בוחן", again: "בוחן חוזר" };
 const chip = a => a.kind === "quiz" ? fmt(a.lesson.name) : a.test.lessons.map(fmt).join(", ");
 const leaveTo = () => !attempt || attempt.kind === "quiz" ? pathHref() : `#/test/${attempt.test.id}`;
@@ -199,19 +200,24 @@ function submit() {
 const VERDICT = { correct: ["✓", "דרך נכונה"], partial: ["◐", "חלק מהדרך נכון"], wrong: ["✗", "הדרך לא נכונה"], unclear: ["?", "לא הצלחנו לקרוא"] };
 
 /** The AI's review of the way (a practice test, the simulation): waiting, failed, or per question with a board its verdict, feedback and tip. */
+function reviewRows(r, questions) {
+  const rows = (r.keys || []).map((key, i) => [i + 1, questions?.[key]]).filter(([, q]) => q);
+  return rows.length ? `<ol class="plain qz-review-list">${rows.map(([n, q]) => `<li class="v-${esc(q.verdict)}" data-n="${n}"><p><b>שאלה ${n}</b>
+      <span class="tag"><span aria-hidden="true">${VERDICT[q.verdict][0]}</span> ${VERDICT[q.verdict][1]}</span></p>
+      <p>${fmt(q.feedback)}</p>${q.tip ? `<p class="muted">💡 ${fmt(q.tip)}</p>` : ""}</li>`).join("")}</ol>` : "";
+}
+
 function reviewHtml(r) {
   const review = r.review;
   if (!review) return "";
   if (review.state === "pending") return `<section class="qz-review" id="qz-review" data-state="pending"><h4>משוב על הדרך</h4>
-    <p class="muted">ה־AI עובר על הדרך שכתבתם בלוח. אפשר להמשיך לקרוא את התוצאה, המשוב יופיע כאן.</p>${stepsHtml(review)}</section>`;
+    <p class="muted">ה־AI עובר על הדרך שכתבתם בלוח, שאלה אחרי שאלה. אפשר להמשיך לקרוא את התוצאה, המשוב יופיע כאן.</p>${stepsHtml(review)}
+    ${reviewRows(r, review.questions)}</section>`;
   if (review.state === "failed") return `<section class="qz-review" id="qz-review" data-state="failed"><h4>משוב על הדרך</h4><p class="muted">לא הצלחנו לבדוק את הדרך הפעם. המורה יראו את הלוחות.</p></section>`;
-  const rows = (r.keys || []).map((key, i) => [i + 1, review.questions[key]]).filter(([, q]) => q);
+  const rows = reviewRows(r, review.questions);
   return `<section class="qz-review" id="qz-review" data-state="done"><h4>משוב על הדרך</h4>
     ${review.summary ? `<p class="qz-review-sum">${fmt(review.summary)}</p>` : ""}
-    ${rows.length ? `<ol class="plain qz-review-list">${rows.map(([n, q]) => `<li class="v-${esc(q.verdict)}" data-n="${n}"><p><b>שאלה ${n}</b>
-      <span class="tag"><span aria-hidden="true">${VERDICT[q.verdict][0]}</span> ${VERDICT[q.verdict][1]}</span></p>
-      <p>${fmt(q.feedback)}</p>${q.tip ? `<p class="muted">💡 ${fmt(q.tip)}</p>` : ""}</li>`).join("")}</ol>`
-      : `<p class="muted">לא נשמרה דרך בלוח באף שאלה.</p>`}
+    ${rows || `<p class="muted">לא נשמרה דרך בלוח באף שאלה.</p>`}
     <p class="muted qz-review-note">משוב אוטומטי. המורה בודקים את הדרך ונותנים את הנקודות.</p></section>`;
 }
 
@@ -238,7 +244,8 @@ function renderResult() {
       <p class="muted" id="qz-best"></p>${r.kind === "simulation" ? `<p class="muted">מבחן סימולציה אפשר לעשות פעם אחת.</p>` : ""}</div>
     ${r.lost_skills.length ? `<h4>איפה אפשר להשתפר</h4><ul class="plain" id="qz-lost">${r.lost_skills.map(s =>
       `<li><a href="#/skill/${esc(s.id)}">${fmt(s.name)}</a><span class="muted">${s.missed} ${s.missed === 1 ? "שאלה שגויה" : "שאלות שגויות"}</span></li>`).join("")}</ul>
-      <p class="muted">אפשר לתרגל את המיומנות ואז לנסות שוב.</p>` : `<p id="qz-perfect">כל התשובות נכונות. כל הכבוד!</p>`}
+      <p class="muted">אפשר לתרגל את המיומנות ואז לנסות שוב.</p>
+      ${r.kind !== "quiz" && r.test.number !== FOCUS ? `<p><a class="button" id="qz-focus" href="#/exam/${esc(r.test.id)}/${FOCUS}">🎯 מבחן תרגול על הנושאים לחיזוק (15 שאלות)</a></p>` : ""}` : `<p id="qz-perfect">כל התשובות נכונות. כל הכבוד!</p>`}
     ${r.missed.length ? `<h4>הטעויות</h4><ol class="qz-missed" id="qz-missed">${r.missed.map(m => `<li><p class="ex-text" dir="auto">${fmt(m.question)}</p>
       ${m.picked ? `<p class="muted">בחרתם: <span dir="auto">${fmt(m.picked)}</span></p>` : `<p class="muted">לא ענו על השאלה.</p>`}
       ${m.mistake ? `<p><b>${esc(m.mistake.name)}</b>${m.mistake.tip ? `<br>${fmt(m.mistake.tip)}` : ""}</p>` : ""}</li>`).join("")}</ol>` : ""}

mathly2/static/reviewsteps.js

@@ -4,17 +4,35 @@ import { esc } from "./math.js";
 
 const boards = n => n === 1 ? "לוח אחד" : `${n} לוחות`;
 
-/** One line per step; the last one is the one happening now. */
+/** The lines: the boards found, how many questions are checked, the one being checked now (or the AI busy), the summary. */
 function lines(review) {
-  const events = review.events || [];
+  const events = (review.events || []).filter(e => e.step !== "resumed");
   if (!events.length) return [["now", "⏳", "מתחילים…"]];
-  return events.map((e, i) => {
-    const last = i === events.length - 1;
-    if (e.step === "boards") return ["done", "📋", `נמצאו ${boards(e.count)} עם דרך (מתוך ${e.total} שאלות)`];
-    if (e.step === "busy") return [last ? "now" : "done", "☕", last ? `ה־AI עמוס כרגע. מנסים שוב בעוד ${e.seconds} שניות` : "ה־AI היה עמוס, ניסינו שוב"];
-    if (e.step === "sent") return [last ? "now" : "done", last ? "🔍" : "📤", last ? "ה־AI קורא את הלוחות ובודק את הדרך, שאלה אחרי שאלה…" : "נשלח ל־AI"];
-    return ["done", "•", esc(e.step)];
-  });
+  const out = [], last = events[events.length - 1];
+  const boardsEv = events.find(e => e.step === "boards");
+  if (boardsEv) out.push(["done", "📋", `נמצאו ${boards(boardsEv.count)} עם דרך (מתוך ${boardsEv.total} שאלות)`]);
+  const current = [...events].reverse().find(e => e.step === "question");
+  if (current) {
+    const done = current.i - 1, all = current.of;
+    if (done) out.push(["done", "🔍", `נבדקו ${done} מתוך ${all}`]);
+    const writing = events.some(e => e.step === "summary");
+    if (!writing) out.push(["now", "🔍", `בודקים את שאלה ${current.n} (${current.i} מתוך ${all})…`]);
+    else out.push(["done", "🔍", `נבדקו כל ${all} השאלות`]);
+  }
+  if (last.step === "busy") out.push(["now", "☕", `ה־AI עמוס כרגע. ממשיכים בעוד ${last.seconds} שניות`]);
+  if (events.some(e => e.step === "summary")) out.push([last.step === "busy" ? "done" : "now", "✍️", "כותבים סיכום קצר…"]);
+  if (last.step === "busy" && out.length > 1) {                                       // while waiting, the step before it is not "now"
+    const prev = out[out.length - 2];
+    if (prev[0] === "now") prev[0] = "wait";
+  }
+  return out;
+}
+
+/** How far along: the questions checked out of all of them (0..1), or null before the first. */
+function share(review) {
+  const current = [...(review.events || [])].reverse().find(e => e.step === "question");
+  if (!current) return null;
+  return (review.events.some(e => e.step === "summary") ? current.of : current.i - 1) / current.of;
 }
 
 const since = at => Math.max(0, Math.round((Date.now() - new Date(at)) / 1000));
@@ -22,9 +40,10 @@ const elapsed = secs => secs < 60 ? `${secs} שניות` : `${Math.floor(secs /
 
 /** The steps as HTML: a list, then "running for … (usually under a minute)". */
 export function stepsHtml(review) {
-  const at = review.at;
-  return `<ol class="plain rv-steps" aria-live="polite">${lines(review).map(([state, icon, text]) =>
-    `<li class="rv-${state}"><span aria-hidden="true">${state === "now" ? `<span class="spin"></span>` : icon}</span> ${text}${state === "done" ? ' <span class="rv-ok" aria-hidden="true">✓</span>' : ""}</li>`).join("")}</ol>
+  const at = review.at, part = share(review);
+  return `${part === null ? "" : `<div class="rv-bar" role="progressbar" aria-valuemin="0" aria-valuemax="100" aria-valuenow="${Math.round(part * 100)}"><i style="width:${Math.round(part * 100)}%"></i></div>`}
+    <ol class="plain rv-steps" aria-live="polite">${lines(review).map(([state, icon, text]) =>
+    `<li class="rv-${state}"><span aria-hidden="true">${state === "now" ? `<span class="spin"></span>` : state === "wait" ? "⏸" : icon}</span> ${text}${state === "done" ? ' <span class="rv-ok" aria-hidden="true">✓</span>' : ""}</li>`).join("")}</ol>
     ${at ? `<p class="muted rv-time">כבר <span class="rv-elapsed" data-since="${esc(at)}">${elapsed(since(at))}</span> · בדרך כלל פחות מדקה</p>` : ""}`;
 }
 

mathly2/static/round.js

@@ -66,7 +66,10 @@ const progress = () => `<div class="ex-progress"><span id="rd-count">${countText
 
 function questionHtml() {
   const question = round.question;
-  return `<div class="mx-q" id="ex-q" data-key="${esc(question.key)}"><p class="muted rd-skill">${fmt(question.skill_name)}</p>
+  const ctx = question.context;
+  const from = ctx ? `<div class="rd-context" id="rd-context"><span class="ex-chip">📝 ${ctx.n ? `שאלה ${ctx.n}${ctx.of ? ` מתוך ${ctx.of}` : ""} ב${fmt(ctx.title)}` : fmt(ctx.title)}</span>
+    <p class="muted">${ctx.picked ? `במבחן בחרתם: <span dir="auto">${fmt(ctx.picked)}</span>` : "במבחן לא עניתם על השאלה הזו."} נסו שוב.</p></div>` : "";
+  return `<div class="mx-q" id="ex-q" data-key="${esc(question.key)}">${from}<p class="muted rd-skill">${fmt(question.skill_name)}</p>
     <p class="ex-text" dir="auto">${fmt(question.question)}</p>${figures(question)}
     <div class="ex-choices" id="ex-choices">${shuffled(question.choices).map(c =>
       `<button type="button" class="ex-choice" data-i="${c.index}" dir="auto">${fmt(c.text)}</button>`).join("")}</div>
@@ -81,7 +84,7 @@ function retryResultHtml() {
     <h4 class="rd-title">${all ? "כל הטעויות תוקנו!" : "סיימתם לחזור על הטעויות"}</h4>
     <p class="ex-score" id="rd-score"><b>${r.right}</b> מתוך ${r.total} נכונות הפעם</p>
     ${r.mastered.length ? `<p class="rd-mastered" id="rd-mastered">🎉 נשלטו: ${r.mastered.map(s => fmt(s.name)).join(", ")}</p>` : ""}
-    ${r.missed.length ? `<h4>עדיין כדאי לחזק</h4><ol class="ex-missed" id="rd-missed">${r.missed.map(m => `<li><p class="muted">${fmt(m.skill_name)}</p><p class="ex-text" dir="auto">${fmt(m.question)}</p>
+    ${r.missed.length ? `<h4>עדיין כדאי לחזק</h4><ol class="ex-missed" id="rd-missed">${r.missed.map(m => `<li><p class="muted">${m.n ? `שאלה ${m.n} · ` : ""}${fmt(m.skill_name)}</p><p class="ex-text" dir="auto">${fmt(m.question)}</p>
       ${m.mistake ? `<p><b>${esc(m.mistake.name)}</b>${m.mistake.tip ? `<br>${fmt(m.mistake.tip)}` : ""}</p>` : ""}</li>`).join("")}</ol>` : ""}
     <p class="muted">הציון במבחן לא משתנה. התרגול נספר לשליטה במיומנויות.</p>
     <p class="ex-actions">${all ? "" : `<button type="button" class="primary" id="rd-again">שוב על הטעויות</button> `}<button type="button" data-close>${round.source.test_id ? "חזרה למבחן" : "חזרה למסלול"}</button></p></section>`;

mathly2/static/teacher_boardwork.js

@@ -27,8 +27,10 @@ function aiPanel(data) {
   const button = label => `<button type="button" id="work-ai-run">${label}</button>`;
   const body = ai.state === "pending" ? `<p><b>🤖 בדיקה עם AI</b></p>${stepsHtml(ai)}`
     : ai.state === "failed" ? `<p class="error" role="alert">🤖 הבדיקה עם AI נכשלה. ${esc(REASONS[ai.reason] || "")}${ai.model ? ` <span dir="ltr">(${esc(ai.model)})</span>` : ""}</p>${button("לנסות שוב")}`
-    : ai.state === "done" ? `<p>🤖 <b>סיכום ה־AI:</b> ${ai.summary ? fmt(ai.summary) : "לא היו לוחות לבדוק."}</p><p class="muted">הצעה בלבד: הנקודות שלכם קובעות.</p>${button("לבדוק שוב עם AI")}`
-    : `<p class="muted">🤖 עוד לא נבדק עם AI.</p>${button("בדיקה עם AI")}`;
+    : ai.state === "done" ? `<p>🤖 <b>סיכום ה־AI:</b> ${ai.summary ? fmt(ai.summary) : "אין סיכום."}</p>
+      ${ai.missing ? `<p class="error">${ai.missing === 1 ? "שאלה אחת לא נבדקה" : `${ai.missing} שאלות לא נבדקו`}. ${esc(REASONS[ai.reason] || "")} אפשר לבדוק כל שאלה בכפתור שלה.</p>` : ""}
+      <p class="muted">הצעה בלבד: הנקודות שלכם קובעות.</p>${button("לבדוק שוב את כל המבחן")}`
+    : `<p class="muted">🤖 עוד לא נבדק עם AI. ה־AI בודק כל שאלה בנפרד.</p>${button("בדיקה עם AI של כל השאלות")}`;
   return `<div class="card work-ai-panel" id="work-ai" data-state="${esc(ai.state || "none")}">${body}</div>`;
 }
 
@@ -48,6 +50,16 @@ export async function show(context) {
 }
 
 const pointsOf = q => q.credit ?? q.auto;
+const VERDICT = { correct: "✓ נכונה", partial: "◐ חלקית", wrong: "✗ שגויה", unclear: "? לא ברורה" };
+let aiNow = {};                                            // the attempt's AI state, for the per-question buttons
+
+/** One question's AI line, and its own button (check it alone, or again). */
+function aiSlot(q) {
+  const line = q.ai ? `<p class="work-ai"><span class="tag">AI: ${VERDICT[q.ai.verdict] || ""}</span> ${fmt(q.ai.feedback)}${q.ai.tip ? `<br><span class="muted">💡 ${fmt(q.ai.tip)}</span>` : ""}</p>` : "";
+  const busy = aiNow.state === "pending";
+  const button = aiNow.available && q.work ? `<button type="button" class="work-ai-run" data-ai-key="${esc(q.key)}"${busy ? " disabled" : ""}>🤖 ${q.ai ? "לבדוק שוב את השאלה" : "בדיקה עם AI של השאלה"}</button>` : "";
+  return `<div class="work-ai-slot">${line}${button}</div>`;
+}
 
 function questionCard(q, i) {
   const picked = q.choices.find(c => c.index === q.picked);
@@ -57,7 +69,7 @@ function questionCard(q, i) {
     <ul class="plain work-choices">${q.choices.map(c => `<li class="${c.correct ? "right" : ""}${c.index === q.picked ? " picked" : ""}"><span dir="auto">${fmt(c.text)}</span>
       <span>${c.correct ? "✓ נכונה" : ""}${c.index === q.picked ? " ← בחר/ה" : ""}</span></li>`).join("")}</ul>
     ${picked ? "" : `<p class="muted">לא ענה/תה על השאלה.</p>`}
-    <h4>הדרך</h4>${q.ai ? `<p class="work-ai"><span class="tag">AI: ${({ correct: "✓ נכונה", partial: "◐ חלקית", wrong: "✗ שגויה", unclear: "? לא ברורה" })[q.ai.verdict] || ""}</span> ${fmt(q.ai.feedback)}</p>` : ""}${q.work ? `<img class="work-pic" data-picture="${esc(q.work)}" alt="הלוח של התלמיד בשאלה ${i + 1}" hidden>` : `<p class="muted no-work">אין לוח לשאלה הזו.</p>`}
+    <h4>הדרך</h4>${aiSlot(q)}${q.work ? `<img class="work-pic" data-picture="${esc(q.work)}" alt="הלוח של התלמיד בשאלה ${i + 1}" hidden>` : `<p class="muted no-work">אין לוח לשאלה הזו.</p>`}
     <div class="work-points" role="group" aria-label="נקודות לשאלה ${i + 1}"><span class="muted">נקודות:</span>${POINTS.map(([v, label]) =>
       `<button type="button" data-points="${v === null ? "auto" : v}" aria-pressed="${(q.credit ?? null) === v}">${label}${v === null ? ` (${q.auto})` : ""}</button>`).join("")}
       <b class="work-now">${pointsOf(q)}</b></div></article>`;
@@ -69,6 +81,7 @@ async function open(id, note = "", given = null, keep = null) {
   const data = given || await api(`/api/teaching/work/${encodeURIComponent(id)}`);
   if (keep) data.questions.forEach(q => { if (q.key in keep) q.credit = keep[q.key]; });       // points picked but not saved yet stay picked
   const chosen = Object.fromEntries(data.questions.map(q => [q.key, q.credit ?? null]));
+  aiNow = data.ai || {};
   ctx.draw(`${ctx.tabs("work")}<section id="work-check" data-attempt="${esc(data.id)}"><p><button type="button" id="work-back">‹ לרשימה</button></p>
     <h2>${fmt(data.title)}</h2><p class="muted" dir="ltr">${esc(data.student)}</p>
     <p>ציון: <b id="work-grade">${data.grade}</b>${data.checked_at ? ` <span class="muted">· נבדק</span>` : ""}</p>
@@ -79,19 +92,26 @@ async function open(id, note = "", given = null, keep = null) {
   ctx.wire();
   document.querySelectorAll("#work-check img[data-picture]").forEach(async img => { try { img.src = await pictureUrl(img.dataset.picture); img.hidden = false; } catch { img.replaceWith(Object.assign(document.createElement("p"), { className: "muted", textContent: "התמונה לא זמינה" })); } });
   document.getElementById("work-back").addEventListener("click", () => { clearTimeout(poll); show(ctx); });
-  document.getElementById("work-ai-run")?.addEventListener("click", async event => {
-    event.target.disabled = true;
-    try { await open(id, "", await api(`/api/teaching/work/${encodeURIComponent(id)}/review`, { method: "POST" }), chosen); }
-    catch (error) { event.target.disabled = false; event.target.insertAdjacentHTML("afterend", `<p class="error" role="alert">${esc(error.message || "משהו השתבש")}</p>`); }
-  });
+  const runAi = async (button, key) => {
+    button.disabled = true;
+    try { await open(id, "", await api(`/api/teaching/work/${encodeURIComponent(id)}/review${key ? `?key=${encodeURIComponent(key)}` : ""}`, { method: "POST" }), chosen); }
+    catch (error) { button.disabled = false; button.insertAdjacentHTML("afterend", `<p class="error" role="alert">${esc(error.message || "משהו השתבש")}</p>`); }
+  };
+  document.getElementById("work-ai-run")?.addEventListener("click", event => runAi(event.target, null));
+  document.querySelectorAll("[data-ai-key]").forEach(b => b.addEventListener("click", event => { event.stopPropagation(); runAi(b, b.dataset.aiKey); }));
   if (data.ai?.state === "pending") {                                   // ask again until the AI is done, then redraw with the picks kept
     const wait = () => { poll = setTimeout(async () => {
       if (document.getElementById("work-check")?.dataset.attempt !== data.id) return;
       let now;
       try { now = await api(`/api/teaching/work/${encodeURIComponent(id)}`); } catch { return wait(); }
       if (document.getElementById("work-check")?.dataset.attempt !== data.id) return;
-      if (now.ai?.state === "pending") {                                 // the new steps, in the box only
+      if (now.ai?.state === "pending") {                                 // the new steps in the box, and each question's line as it is checked
         document.getElementById("work-ai")?.replaceWith(Object.assign(document.createElement("div"), { innerHTML: aiPanel(now) }).firstElementChild);
+        aiNow = now.ai;
+        now.questions.forEach(q => {
+          const slot = document.querySelector(`.work-q[data-key="${CSS.escape(q.key)}"] .work-ai-slot`);
+          if (slot && q.ai) slot.outerHTML = aiSlot(q);
+        });
         return wait();
       }
       open(id, "", now, chosen);

mathly2/static/testcard.js

@@ -20,6 +20,17 @@ function exercises(test) {
     <a class="button" href="#/exam/${test.id}/${e.number}">${e.open ? "להמשיך" : e.attempts ? "שוב" : "התחלה"}</a></li>`).join("")}</ul>`;
 }
 
+/** The practice test on the weak topics: 15 questions from the skills that lost points (or are still being learned). */
+function focus(test) {
+  const f = test.focus;
+  if (!f) return "";
+  if (!f.skills.length) return `<div id="focus" data-ready="false"><p class="muted">🎯 ${f.attempts ? "אין כרגע נושאים לחיזוק. כל הכבוד!" : "אחרי מבחן תרגול או סימולציה יופיע כאן מבחן על הנושאים שצריך לחזק."}</p></div>`;
+  return `<div id="focus" data-ready="true"><p><b>🎯 מבחן תרגול על הנושאים לחיזוק</b> <span class="muted">· ${f.size} שאלות</span></p>
+    <p class="focus-skills">${f.skills.map(s => `<a class="ex-chip link" href="#/skill/${esc(s.id)}">${fmt(s.name)}</a>`).join(" ")}</p>
+    ${f.best === null ? "" : `<p class="muted">הציון הטוב: ${f.best} · ${f.attempts} ${f.attempts === 1 ? "ניסיון" : "ניסיונות"}</p>`}
+    <p><a class="button primary" id="focus-start" href="#/exam/${test.id}/${f.number}">${f.open ? "להמשיך" : f.attempts ? "עוד מבחן על הנושאים" : "התחלה"}</a></p></div>`;
+}
+
 function simulation(test) {
   const s = test.simulation;
   const lead = s.taken ? `<p>הציון: <b id="sim-grade">${s.grade}</b></p>${s.review.length ? `<p>מיומנויות לחזרה:</p><ul class="plain" id="sim-review">${s.review.map(r =>
@@ -41,7 +52,7 @@ export async function show(view, id) {
       <p class="muted">${test.lessons.map(l => fmt(l.name)).join(", ")}${test.note ? ` · ${esc(test.note)}` : ""}<br>${test.questions} שאלות · ${test.minutes} דקות</p>
       ${readinessBar(test.readiness)}</section>
     <section class="card"><h3>התוכנית</h3>${planList(test)}</section>
-    <section class="card"><h3>מבחני תרגול</h3>${exercises(test)}
+    <section class="card"><h3>מבחני תרגול</h3>${exercises(test)}${focus(test)}
       ${test.practice_first.length ? `<p id="practice-first"><b>כדאי לתרגל קודם:</b> ${test.practice_first.map(s => `<a class="ex-chip link" href="#/skill/${esc(s.id)}">${fmt(s.name)}</a>`).join(" ")}</p>
         <p class="muted">אלה מיומנויות שעוד לא התחלתם, ולכן אין להן שאלות במבחני התרגול.</p>
         <p id="all-skills">${test.exercise_tests.map(e => `<a class="button" href="#/exam/${test.id}/${e.number}/all">מבחן תרגול ${e.number} על כל החומר</a>`).join(" ")}</p>

mathly2/tests/test_boardreview_api.py

@@ -19,14 +19,17 @@ from mathly2.tests.test_quizzes_api import right_index, skill_of
 
 class FakeReviewer:
     def __init__(self, fail=None):
-        self.calls, self.fail = [], fail
+        self.calls, self.fail, self.summaries = [], fail, []          # calls: the questions asked about, one request each
 
-    def review(self, items, on_event=lambda step, **info: None):
-        self.calls.append(items)
+    def review_one(self, item, on_event=lambda step, **info: None):
+        self.calls.append(item)
         if self.fail:
             raise boardreview.ReviewFailure(self.fail)
-        return {"summary": "דרך מסודרת. כדאי לבדוק סימנים.",
-                "questions": [{"n": it["n"], "verdict": "partial", "feedback": f"בשאלה {it['n']} הטעות בשלב השני", "tip": "בדקו סימן"} for it in items]}
+        return {"verdict": "partial", "feedback": f"בשאלה {item['n']} הטעות בשלב השני", "tip": "בדקו סימן"}
+
+    def summarize(self, reviewed, on_event=lambda step, **info: None):
+        self.summaries.append(reviewed)
+        return "דרך מסודרת. כדאי לבדוק סימנים."
 
 
 def make(reviewer):
@@ -58,8 +61,8 @@ def test_handing_in_a_practice_test_sends_its_boards_once_and_the_student_gets_t
     fake = FakeReviewer()
     client, store, bank, test, _ = make(fake)
     attempt, result = hand_in(client, bank, test)
-    assert len(fake.calls) == 1 and [it["n"] for it in fake.calls[0]] == [1, 2]                  # one request, only the questions with a board
-    item = fake.calls[0][0]
+    assert [it["n"] for it in fake.calls] == [1, 2] and len(fake.summaries) == 1               # a request per question with a board, then a summary
+    item = fake.calls[0]
     assert item["image"] and item["choices"] and isinstance(item["correct"], int) and KID not in json.dumps({k: v for k, v in item.items() if k != "image"})
     review = result["review"]
     assert review["state"] == "done" and review["summary"].startswith("דרך")
@@ -67,7 +70,7 @@ def test_handing_in_a_practice_test_sends_its_boards_once_and_the_student_gets_t
     assert set(review["questions"]) == {first, attempt["questions"][1]["key"]} and review["questions"][first]["verdict"] == "partial"
     assert result["keys"][0] == first
     again = client.get(f"/api/attempts/{attempt['id']}", headers=auth(KID)).json()
-    assert again["review"] == review and len(fake.calls) == 1                                     # read again: not reviewed again
+    assert again["review"] == review and len(fake.calls) == 2                                     # read again: not reviewed again
     teacher = client.get(f"/api/teaching/work/{attempt['id']}", headers=auth(TEACHER)).json()
     assert teacher["questions"][0]["ai"]["feedback"].startswith("בשאלה 1") and teacher["ai_summary"]
 
@@ -99,7 +102,7 @@ def test_a_review_lost_by_a_restart_is_started_again():
     client, store, bank, test, _ = make(fake)
     attempt, _ = hand_in(client, bank, test)
     store.save_attempt(attempt["id"], review={"state": "pending", "at": (clock.now() - timedelta(minutes=30)).isoformat()})
-    assert client.get(f"/api/attempts/{attempt['id']}", headers=auth(KID)).json()["review"]["state"] == "done" and len(fake.calls) == 2
+    assert client.get(f"/api/attempts/{attempt['id']}", headers=auth(KID)).json()["review"]["state"] == "done" and len(fake.calls) == 4
 
 
 # ---- the Gemini client itself ----
@@ -118,9 +121,9 @@ def http_error(code, body=b"{}"):
 
 def test_gemini_reviewer_sends_one_request_with_the_picture_and_retries_when_told_to_wait():
     waits, sent = [], []
-    reviewer = boardreview.GeminiReviewer("key", sleep=waits.append)
+    reviewer = boardreview.GeminiReviewer("key", sleep=waits.append, gap=0)
     replies = [http_error(429, json.dumps({"error": {"details": [{"retryDelay": "7s"}]}}).encode()),
-               answer({"summary": "s", "questions": [{"n": 3, "verdict": "wrong", "feedback": "f", "tip": "t"}]})]
+               answer({"verdict": "wrong", "feedback": "f", "tip": "t"})]
 
     def call(body):
         sent.append(json.loads(body))
@@ -129,8 +132,8 @@ def test_gemini_reviewer_sends_one_request_with_the_picture_and_retries_when_tol
             raise reply
         return reply
     reviewer._call = call
-    got = reviewer.review(items())
-    assert got["questions"][0]["verdict"] == "wrong" and waits == [8.0] and len(sent) == 2
+    got = reviewer.review_one(items()[0])
+    assert got["verdict"] == "wrong" and waits == [8.0] and len(sent) == 2
     parts = sent[0]["contents"][0]["parts"]
     assert any("inline_data" in p for p in parts) and "לא לגלות" in json.dumps(parts, ensure_ascii=False)
     assert sent[0]["generationConfig"]["responseMimeType"] == "application/json"
@@ -138,11 +141,11 @@ def test_gemini_reviewer_sends_one_request_with_the_picture_and_retries_when_tol
 
 @pytest.mark.parametrize("code,reason", [(400, "bad_request"), (403, "permission"), (404, "model_not_found")])
 def test_gemini_errors_have_reasons(code, reason):
-    reviewer = boardreview.GeminiReviewer("key", sleep=lambda s: None)
+    reviewer = boardreview.GeminiReviewer("key", sleep=lambda s: None, gap=0)
     reviewer._call = lambda body: (_ for _ in ()).throw(http_error(code))
     reviewer._models = lambda: []                                                  # no other model to fall back to
     with pytest.raises(boardreview.ReviewFailure) as caught:
-        reviewer.review(items())
+        reviewer.review_one(items()[0])
     assert caught.value.reason == reason
 
 
@@ -150,11 +153,11 @@ def test_gemini_bad_or_cut_output_is_a_failure():
     reviewer = boardreview.GeminiReviewer("key")
     reviewer._call = lambda body: {"candidates": [{"finishReason": "MAX_TOKENS", "content": {"parts": [{"text": "{"}]}}]}
     with pytest.raises(boardreview.ReviewFailure) as caught:
-        reviewer.review(items())
+        reviewer.review_one(items()[0])
     assert caught.value.reason == "incomplete"
     reviewer._call = lambda body: {"candidates": [{"finishReason": "STOP", "content": {"parts": [{"text": "not json"}]}}]}
     with pytest.raises(boardreview.ReviewFailure) as caught:
-        reviewer.review(items())
+        reviewer.review_one(items()[0])
     assert caught.value.reason == "bad_output"
 
 
@@ -166,7 +169,7 @@ def test_a_test_handed_in_before_the_key_was_set_is_reviewed_when_the_teacher_op
     assert store.get_attempt(attempt["id"]).get("review") is None
     client.app.state.reviewer = fake                                              # the key is set now
     got = client.get(f"/api/teaching/work/{attempt['id']}", headers=auth(TEACHER)).json()
-    assert len(fake.calls) == 1 and got["ai_summary"] and any(q["ai"] for q in got["questions"])
+    assert len(fake.calls) == 2 and got["ai_summary"] and any(q["ai"] for q in got["questions"])
 
 
 def test_the_teacher_sees_the_ai_state_and_can_run_it_again_or_on_a_quiz():
@@ -178,7 +181,7 @@ def test_the_teacher_sees_the_ai_state_and_can_run_it_again_or_on_a_quiz():
     assert client.get(f"/api/teaching/work/{attempt['id']}", headers=auth(TEACHER)).json()["ai"]["state"] == "failed"   # opening does not retry
     fake.fail = None
     again = client.post(f"/api/teaching/work/{attempt['id']}/review", headers=auth(TEACHER)).json()
-    assert again["ai"]["state"] == "done" and again["ai"]["summary"] and len(fake.calls) == 2
+    assert again["ai"]["state"] == "done" and again["ai"]["summary"] and len(fake.calls) == 3      # the first stopped at "rate limited"
     lesson = test["lessons"][0]
     quiz = client.post(f"/api/lessons/{lesson}/quiz/start", headers=auth(KID)).json()
     for q in quiz["questions"]:
@@ -204,7 +207,7 @@ def test_no_key_says_so_and_a_missing_column_does_not_break_the_result():
 
 
 def test_a_model_not_found_falls_back_to_a_flash_model_the_key_has():
-    reviewer = boardreview.GeminiReviewer("key", " models/gemini-9-flash ")
+    reviewer = boardreview.GeminiReviewer("key", " models/gemini-9-flash ", gap=0)
     assert reviewer.model == "gemini-9-flash"                                      # a pasted name is cleaned
     reviewer._models = lambda: ["gemini-2.0-flash-lite", "gemini-3-flash-preview", "gemini-2.5-pro", "gemini-2.5-flash", "gemini-2.5-flash-image",
                                 "gemini-3.8-flash", "text-embedding-004"]
@@ -214,9 +217,9 @@ def test_a_model_not_found_falls_back_to_a_flash_model_the_key_has():
         used.append(reviewer.model)
         if reviewer.model == "gemini-9-flash":
             raise http_error(404)
-        return answer({"summary": "s", "questions": []})
+        return answer({"verdict": "correct", "feedback": "f", "tip": "t"})
     reviewer._call = call
-    assert reviewer.review(items())["summary"] == "s"
+    assert reviewer.review_one(items()[0])["verdict"] == "correct"
     assert used == ["gemini-9-flash", "gemini-3.8-flash"] and reviewer.model == "gemini-3.8-flash"
 
 
@@ -229,19 +232,20 @@ def test_while_it_runs_the_review_stores_its_steps_for_the_screens():
     seen = []
 
     class Watching(FakeReviewer):
-        def review(self, items, on_event=lambda step, **info: None):
+        def review_one(self, item, on_event=lambda step, **info: None):
             seen.append(boardreview.student_view(store.get_attempt(attempt_id)))
             on_event("busy", seconds=8)
             seen.append(boardreview.student_view(store.get_attempt(attempt_id)))
-            on_event("sent")
-            return super().review(items, on_event)
+            return super().review_one(item, on_event)
     fake = Watching()
     client, store, bank, test, _ = make(None)
     attempt, _ = hand_in(client, bank, test, boards=2)
     attempt_id = attempt["id"]
     client.app.state.reviewer = fake
     client.get(f"/api/attempts/{attempt_id}", headers=auth(KID))
-    assert [e["step"] for e in seen[0]["events"]] == ["boards", "sent"] and seen[0]["events"][0]["count"] == 2
+    assert [e["step"] for e in seen[0]["events"]] == ["boards", "question"] and seen[0]["events"][0]["count"] == 2
+    assert seen[0]["events"][1] == {**seen[0]["events"][1], "n": 1, "i": 1, "of": 2} and seen[0]["questions"] == {}
+    assert len(seen[2]["questions"]) == 1                                                  # the first question's review shows before the second
     assert seen[0]["state"] == "pending" and seen[0]["at"]
     assert seen[1]["events"][-1] == {**seen[1]["events"][-1], "step": "busy", "seconds": 8}
     assert store.get_attempt(attempt_id)["review"]["state"] == "done"
@@ -249,8 +253,51 @@ def test_while_it_runs_the_review_stores_its_steps_for_the_screens():
 
 def test_gemini_says_when_it_waits_for_the_free_tier():
     steps = []
-    reviewer = boardreview.GeminiReviewer("key", sleep=lambda s: None)
-    replies = [http_error(429, json.dumps({"error": {"details": [{"retryDelay": "7s"}]}}).encode()), answer({"summary": "s", "questions": []})]
+    reviewer = boardreview.GeminiReviewer("key", sleep=lambda s: None, gap=0)
+    replies = [http_error(429, json.dumps({"error": {"details": [{"retryDelay": "7s"}]}}).encode()), answer({"verdict": "correct", "feedback": "f", "tip": "t"})]
     reviewer._call = lambda body: (lambda r: (_ for _ in ()).throw(r) if isinstance(r, Exception) else r)(replies.pop(0))
-    reviewer.review(items(), on_event=lambda step, **info: steps.append((step, info)))
-    assert steps == [("busy", {"seconds": 8}), ("sent", {})]
+    reviewer.review_one(items()[0], on_event=lambda step, **info: steps.append((step, info)))
+    assert steps == [("busy", {"seconds": 8}), ("resumed", {})]
+
+
+def test_requests_keep_a_gap_for_the_free_tier_and_the_summary_has_no_picture():
+    waits, sent, t = [], [], [100.0]
+    reviewer = boardreview.GeminiReviewer("key", sleep=lambda s: (waits.append(round(s, 1)), t.__setitem__(0, t[0] + s)), gap=5.0, now=lambda: t[0])
+    reviewer._call = lambda body: (sent.append(json.loads(body)), answer({"verdict": "correct", "feedback": "f", "tip": "t", "summary": "סיכום"}))[1]
+    reviewer.review_one(items()[0])
+    t[0] += 1.0
+    reviewer.review_one(items()[0])
+    assert reviewer.summarize([{"n": 1, "skill": "s", "verdict": "correct", "feedback": "f"}]) == "סיכום"
+    assert waits == [4.0, 5.0] and not any("inline_data" in p for p in sent[2]["contents"][0]["parts"])
+
+
+class QuotaAfterFirst(FakeReviewer):
+    """The first question works, the second hits the quota (a stopping failure); with `fail` cleared everything works."""
+    def __init__(self):
+        super().__init__()
+        self.quota = True
+
+    def review_one(self, item, on_event=None):
+        if self.quota and len(self.calls) == 1:
+            self.calls.append(item)
+            raise boardreview.ReviewFailure("rate_limited")
+        return super().review_one(item)
+
+
+def test_a_stopping_failure_keeps_what_was_checked_and_one_question_can_be_checked_alone():
+    fake = QuotaAfterFirst()
+    client, store, bank, test, _ = make(None)
+    attempt, _ = hand_in(client, bank, test, boards=3)
+    client.app.state.reviewer = fake
+    view = client.get(f"/api/teaching/work/{attempt['id']}", headers=auth(TEACHER)).json()
+    review = store.get_attempt(attempt["id"])["review"]
+    assert review["state"] == "done" and len(review["questions"]) == 1 and review["missing"] == 2 and review["reason"] == "rate_limited"
+    assert len(fake.calls) == 2 and view["ai"]["missing"] == 2                       # stopped: the third was never asked
+    fake.quota = False
+    third = attempt["questions"][2]["key"]
+    got = client.post(f"/api/teaching/work/{attempt['id']}/review?key={third}", headers=auth(TEACHER)).json()
+    review = store.get_attempt(attempt["id"])["review"]
+    assert fake.calls[-1]["n"] == 3 and len(fake.calls) == 3 and set(review["questions"]) == {attempt["questions"][0]["key"], third}
+    assert review["summary"] == got["ai"]["summary"] and next(q for q in got["questions"] if q["key"] == third)["ai"]
+    no_board = attempt["questions"][5]["key"]
+    assert client.post(f"/api/teaching/work/{attempt['id']}/review?key={no_board}", headers=auth(TEACHER)).status_code == 409

mathly2/tests/test_boardwork_browser.py

@@ -183,6 +183,11 @@ def test_the_teacher_sees_why_the_ai_failed_and_runs_it_again(browser, bank):
         teacher.wait_for_selector("#work-ai[data-state='done']", timeout=15000)
         assert "סיכום ה־AI" in teacher.inner_text("#work-ai") and teacher.locator(".work-q .work-ai").count() == 1
         assert teacher.get_attribute(f".work-q[data-key='{second}'] [data-points='0.5']", "aria-pressed") == "true"   # the pick stayed
+        first = attempt["questions"][0]["key"]
+        asked = len(fake.calls)
+        teacher.click(f".work-q[data-key='{first}'] [data-ai-key]")                                  # one question alone
+        teacher.wait_for_selector("#work-ai[data-state='done']", timeout=15000)
+        assert len(fake.calls) == asked + 1 and fake.calls[-1]["n"] == 1
         assert teacher.errors == []
 
 
@@ -194,10 +199,10 @@ def test_while_the_ai_works_the_student_and_the_teacher_see_its_steps(browser, b
     release = threading.Event()
 
     class Slow(FakeReviewer):
-        def review(self, items, on_event=lambda step, **info: None):
+        def review_one(self, item, on_event=lambda step, **info: None):
             on_event("busy", seconds=30)
             release.wait(30)
-            return super().review(items, on_event)
+            return super().review_one(item, on_event)
     lessons = [l["id"] for l in bank.lessons][:2]
     store = InMemoryStore()
     klass = store.create_class("setup", "A", lessons=lessons, teacher_email=TEACHER)

mathly2/tests/test_home_browser.py

@@ -388,6 +388,8 @@ def test_after_the_simulation_the_wrong_questions_are_answered_again_in_a_round(
         page.click("#qz-retry")
         page.wait_for_selector(".round-layer #ex-q")
         assert "חזרה על הטעויות" in page.inner_text(".round-layer .ex-chip") and "מתוך 6" in page.inner_text("#rd-count")
+        context = page.inner_text("#rd-context")
+        assert "מבחן סימולציה" in context and "שאלה 1 מתוך 6" in context and "לא עניתם" in context      # where the question came from
         for n in range(6):
             page.locator(".round-layer .ex-choice").first.click()
             page.wait_for_selector(".round-layer .ex-ok, .round-layer .ex-bad")
@@ -400,6 +402,13 @@ def test_after_the_simulation_the_wrong_questions_are_answered_again_in_a_round(
         page.click("#rd-result [data-close]")
         page.wait_for_selector("#test-card")
         assert page.locator(".round-layer").count() == 0 and page.errors == []
+        page.wait_for_selector("#focus[data-ready='true']")                                             # the weak topics now have their own test
+        page.click("#focus-start")
+        page.wait_for_selector("#qz-q")
+        assert "נושאים לחיזוק" in page.inner_text(".mx-sheet h3") and 0 < page.locator(".qz-dot").count() <= 15
+        focus = store.attempts_of(KID_ID, "exercise_test")[0]
+        lost = {q["skill_id"] for q in store.attempts_of(KID_ID, "simulation")[0]["questions"]}
+        assert focus["scope"].endswith(":3") and {q["skill_id"] for q in focus["questions"]} <= lost and page.errors == []
 
 
 # --- 3.5 the grades screen has exercise tests and simulations ---

mathly2/tests/test_realtests_api.py

@@ -341,7 +341,7 @@ def test_an_exercise_test_with_nothing_started_draws_all_the_material_and_a_weak
     test = set_test(client, lessons, days=14, questions=6).json()
     got = start_ex(client, test["id"])
     assert got.status_code == 200 and len(got.json()["questions"]) == 6             # not refused: drawn like the simulation
-    assert start_ex(client, test["id"], 3).status_code == 404
+    assert start_ex(client, test["id"], 4).status_code == 404
 
 
 def test_an_exercise_test_with_all_skills_starts_even_when_nothing_is_started(world):
@@ -467,6 +467,8 @@ def test_after_the_simulation_its_wrong_questions_can_be_answered_again_without_
     assert rnd["kind"] == "mistakes_round" and rnd["total"] == 4 and rnd["source"]["test_id"] == test["id"]
     assert [q["key"] for q in store.get_attempt(rnd["id"])["questions"]] == [q["key"] for q in sim["questions"][8:]]
     assert '"correct"' not in json.dumps(rnd)
+    ctx = rnd["question"]["context"]
+    assert ctx["n"] == 9 and ctx["of"] == 12 and ctx["title"].startswith("מבחן סימולציה") and ctx["picked"]   # where it came from, and the old pick
     assert client.post(f"/api/attempts/{sim['id']}/retry/start", headers=auth(KID)).json()["id"] == rnd["id"]    # an open one resumes
     for ok in [True, False, True, True]:
         key = rnd["question"]["key"]
@@ -474,6 +476,7 @@ def test_after_the_simulation_its_wrong_questions_can_be_answered_again_without_
         assert got.status_code == 200 and got.json()["correct"] is ok
         rnd = got.json()["round"]
     assert rnd["state"] == "done" and rnd["result"]["right"] == 3 and rnd["result"]["stars"] is None and len(rnd["result"]["missed"]) == 1
+    assert rnd["result"]["missed"][0]["n"] == 10
     assert store.get_attempt(sim["id"])["grade"] == 67                                    # the simulation's grade stays
     assert client.post(f"/api/attempts/{sim['id']}/retry/start", headers=auth(KID)).json()["id"] != rnd["id"]    # again: a new round
     assert client.post(f"/api/attempts/{sim['id']}/retry/start", headers=auth(TEACHER)).status_code == 404       # only the student's own
@@ -485,3 +488,26 @@ def test_a_test_with_no_mistakes_has_nothing_to_retry(world):
     started(client, store, lessons)
     done = answer_all(client, client.app.state.bank, start_ex(client, test["id"]).json(), [True] * 6)
     assert client.post(f"/api/attempts/{done['id']}/retry/start", headers=auth(KID)).status_code == 409
+
+
+def test_the_weak_topics_test_has_15_questions_only_from_the_skills_that_lost_points(world):
+    client, store, lessons = world
+    bank = client.app.state.bank
+    test = set_test(client, lessons, days=14).json()
+    client.set_time(MON + 12 * DAY)
+    assert client.get(f"/api/tests/{test['id']}", headers=auth(KID)).json()["focus"]["skills"] == []
+    assert start_ex(client, test["id"], 3).status_code == 409                          # nothing weak yet
+    sim = client.post(f"/api/tests/{test['id']}/simulation/start?all_skills=true", headers=auth(KID)).json()
+    done = answer_all(client, bank, sim, [True] * 8 + [False] * 4)
+    lost = {s["id"] for s in done["lost_skills"]}
+    card = client.get(f"/api/tests/{test['id']}", headers=auth(KID)).json()
+    assert {s["id"] for s in card["focus"]["skills"]} == lost and card["focus"]["size"] == 15 and card["focus"]["best"] is None
+    focus = start_ex(client, test["id"], 3).json()
+    assert focus["kind"] == "exercise_test" and focus["test"]["number"] == 3 and len(focus["questions"]) == 15
+    assert {q["skill_id"] for q in store.get_attempt(focus["id"])["questions"]} <= lost
+    assert len({q["key"] for q in store.get_attempt(focus["id"])["questions"]}) == 15                    # no question twice
+    assert start_ex(client, test["id"], 3).json()["id"] == focus["id"]                                   # open: it resumes
+    answer_all(client, bank, focus, [True] * 15)
+    card = client.get(f"/api/tests/{test['id']}", headers=auth(KID)).json()
+    assert card["focus"]["best"] == 100 and card["focus"]["attempts"] == 1
+    assert [e["number"] for e in card["exercise_tests"]] == [1, 2] and all(e["best"] is None for e in card["exercise_tests"])   # not exercise test 1 or 2