Tests on request and a readiness number that only tests raise

- Practice tests on request in three modes (balanced, focused on the hard skills, manual pick) and simulations on request
(all the material, timed, no choice, repeatable). No plan, no window, no one-time rule. Old exercise tests 1-2 count as balanced, 3 as focused.
- Readiness moves only with handed-in tests, only up: number += GAIN x (grade - number), GAIN 0.6 simulation, 0.3 practice,
0.15 manual. Mastery and deepening no longer count. Levels, points to the next level, what a perfect test adds.
- Home: one compact block (number, level, days left; practice and simulation buttons with +N), still one screen.
The test page: how it goes up, simulation, practice modes, the trail of gains. A result opens with its gain and a level up.
- Teacher tabs show readiness, test counts and bests. countdown.py removed. OpenSpec change tests-on-demand; PRD updated.

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

docs/tasks/prd-mathly.md

@@ -298,50 +298,34 @@ The exercise screen is where a student practices one skill.
 - **TST-1 Setting a test.** The teacher sets a test: date + the lessons it covers (+ an optional note), plus the real test's **number of questions** and **time limit**.
   A test covers lessons of **one subject** the class studies (SUB-4): a class with several subjects picks the subject first, and the test shows only on that subject's home.
   These start with defaults (12 questions, 45 minutes) that the teacher can change.
-- **TST-2 The countdown plan.** From the moment a test is set, the system shows the student a plan that depends on the days left:
-
-  | Days before the test | What the app asks the student to do |
-  |---|---|
-  | until 9 | Finish the path for every covered lesson (bring every covered skill to "mastered") |
-  | ~9 | Exercise test 1 |
-  | ~7 | Exercise test 2 |
-  | ~5 | Simulation test (required) |
-  | 4 → 1 | Review the skills that failed in the simulation; light mixed review the day before |
-
-  The day numbers are **recommendations**: the student can start each step earlier or later.
-  If the test is set less than 9 days ahead, the system keeps the same order and shortens the gaps evenly.
-- **TST-3 Home screen reminder.** The home screen shows, for the nearest test: days left, the readiness meter (RDY-1), and **one task for today** taken from the plan.
-  When several tests are coming up, "today's task" comes from the **closest** one.
+- **TST-2 Tests on request.** From the moment a test is set, the student can ask, at any time until the test, for a **practice test** (EXT) or a **simulation test** (SIM), as many as they like. There is no fixed plan and no window: the readiness number (RDY-1) is what the student works to raise.
+- **TST-3 Home screen.** The home screen shows the nearest test in one compact block. It has the readiness number with its level and the days left (a link to the test's page), a thin bar, and two buttons, **📝 מבחן תרגול** and **⏱ מבחן סימולציה**. Each button shows the most it can add to the number now ("+30", "+60").
+  When several tests are coming up, the block is the **closest** one; the others are on its page.
 
 ### 4.11 Exercise tests (מבחן תרגול) (EXT)
 
-- **EXT-1 Created by the app.** When the teacher sets a test, the system creates 2 exercise tests for every student in the class and places them on the student's countdown.
+- **EXT-1 On request, in three modes.** The student asks for a practice test on the test's page and picks a mode:
+  - **balanced (מאוזן)**: all the covered material evenly;
+  - **focused (ממוקד)**: 15 questions only from the "weak" skills;
+  - **manual (בחירה ידנית)**: the skills the student checks.
+
+  An open practice test of the same mode resumes; a manual one is always new.
 - **EXT-2 Teacher can assign one.** The teacher can send an exercise test to the whole class as an assignment (built with the assignments, stage 6): it shows in "המשימות שלי", opens the exercise test and counts as done when the student has taken it; it is not handed in as a picture.
-- **EXT-3 Retakes.** The student can start or retake an exercise test at any time. Each retake draws new questions; the best grade counts.
+- **EXT-3 Retakes.** The student can take as many practice tests as they like. Each draws the least-used questions first.
 - **EXT-4 Like the simulation.** Exercise tests have the same number of questions as the simulation (that is, as the real test, TST-1) but no time limit,
   mix questions from all covered lessons, and do not show the skill name. Feedback comes **only at the end**, not after each question.
-- **EXT-5 Question mix.** The system picks questions in these proportions:
-
-  | Exercise test | Weak skills | Other covered skills |
-  |---|---|---|
-  | 1 | 60% | 40% |
-  | 2 | 30% | 70% |
-
-  "Weak skill" = a skill in the "learning" state, or one the student answered wrong in a previous exercise test.
-  Skills in the "not started" state do not appear; instead, the card lists them as "practice these first".
-  If the student has fewer weak skills than needed, the rest comes from the other covered skills.
+- **EXT-5 Question mix.** A balanced test spreads its questions over all covered skills, not-started ones included. A focused test takes them only from the "weak" skills, one per skill round after round. A "weak" skill is one that lost points in this test's practice tests or simulations, or one in the "learning" state.
+  A manual test takes them only from the skills the student picked.
 - **EXT-6 Result links back.** After an exercise test, the system shows the weak skills it found and links each one to its star on the path.
 - **EXT-7 Grades on the server.** Exercise test grades are computed and kept on the server.
 
 ### 4.12 Simulation test (מבחן סימולציה) (SIM)
 
-- **SIM-1 Required, one attempt.** Every student takes one simulation test per real test. It can be taken only once.
+- **SIM-1 On request, no choice.** The student can ask for a simulation at any time, as many times as they like (an open one resumes). The student has no control over its material.
 - **SIM-2 Like the real test.** The simulation covers all the lessons of the real test, with the number of questions and the time limit the teacher set for it (TST-1),
   no skill names, and no feedback until the end.
-- **SIM-3 Window.** The simulation becomes available ~5 days before the test and stays available until the test day.
-  It is shown as **required** on the student's home screen until it is taken.
 - **SIM-4 Server timer.** The timer is kept on the server, so refreshing or closing the app does not reset it. The grade is stored on the server.
-- **SIM-5 After the simulation,** the system lists the skills that failed and turns them into the review tasks of the last days (TST-2).
+- **SIM-5 After the simulation,** the result lists the skills that lost points (they feed the focused practice test, EXT-5), offers to answer the wrong questions again, and shows what the simulation added to the readiness number (RDY-5).
 
 ### 4.13 Grades and readiness meter (GRD, RDY)
 
@@ -349,14 +333,19 @@ The exercise screen is where a student practices one skill.
   Teachers' grades for assignments are on the same scale.
 - **GRD-2 When time ends.** Only the simulation is timed. When its timer ends it is submitted as it stands, and unanswered questions count as wrong.
   Leaving the screen does not stop the timer.
-- **RDY-1 Readiness meter.** For each upcoming test, the system shows the student (and the teacher) one **readiness number from 0 to 100**, drawn as a level bar, with its three parts under it:
-  - **mastery (שליטה)**: the % of the covered skills that are mastered;
-  - **practice tests (מבחני תרגול)**: the average of the best grade of each exercise test taken;
-  - **the simulation (סימולציה)**: the simulation test grade (once taken).
-  Each part is a row in plain Hebrew with a short line saying what its number is and its value ("—" when none yet); the letters M, E, S are internal and not shown.
-- **RDY-2 How the number is made.** It is the weighted average of the parts that exist, with weights M 50, E 20, S 30; a part that does not exist yet (no exercise test taken, no simulation) is left out and the others are scaled up.
-- **RDY-3 No false confidence.** Until the simulation is taken the number is capped at 80, and the bar says so. The bar's label by number is: 0–39 "מתחילים", 40–69 "בדרך", 70–84 "כמעט שם", 85–100 "מוכנים". "מוכנים" can only show after the simulation.
-- **RDY-4 The number explains itself.** An info button "ⓘ" beside the number opens a short tooltip (hover, focus or tap; closes on a second tap, a tap elsewhere or Escape): the number is made of mastery (50%), practice tests (20%) and the simulation (30%); a part with no grade yet is left out; without the simulation it cannot pass 80.
+- **RDY-1 Readiness meter.** For each upcoming test, the system shows the student (and the teacher) one **readiness number from 0 to 100**, with its level and a bar. Levels: 0–39 "מתחילים", 40–69 "בדרך", 70–84 "כמעט שם", 85–100 "מוכנים". Beside it, the app shows the points to the next level.
+- **RDY-2 Only tests move it.** The number changes only when a practice test or a simulation is handed in, never from the path, deepening or mastery. For each test, oldest first, when its grade is above the number:
+
+  `number = number + GAIN × (grade − number)`
+
+  GAIN is 0.6 for a simulation, 0.3 for a practice test and 0.15 for a manual practice test.
+- **RDY-3 Never down, never above the grades.** A grade at or below the number changes nothing, so the number never drops, and it can only approach the grades actually earned.
+- **RDY-4 The number explains itself.** The test's page says how to raise it: a practice test closes 30% of the gap, a simulation 60%, a manual one 15%; a lower grade does not lower it; only tests count.
+- **RDY-5 Make raising it rewarding.**
+  - The number counts up from the last visit with a "+N" badge.
+  - Every button to a test shows the most it can add now.
+  - A test's result opens with its gain (a big "+N" and the bar growing), "🎉 רמה חדשה" when the level changed, the points to the next level, and buttons to another simulation or practice test.
+  - The test's page lists every test handed in with its grade and what it added.
 
 ### 4.14 Handwritten answers and phone photos (ANS, PSH)
 
@@ -402,7 +391,7 @@ The exercise screen is where a student practices one skill.
 
 A tab bar at the bottom of the screen leads between them: home, path (named "העמקה": going deeper, skill by skill), submissions (STU-7), grades, collection and review (STU-8).
 
-- **STU-1 Home** is one screen (it fits 360×800 with every lesson), like a game's level select: the stars collected (three per lesson), the lessons perfected, the streak and the daily goal; one big **play** button for the next lesson (the one with a round in progress, else the earliest behind the curriculum, else the first with fewer than three stars); the nearest test in one strip (the days left and the readiness number, which open the test's card with the readiness bar, the plan and the practice tests, and today's task, TST-3, as a button); small buttons for a required simulation, the new assignments (their number, opening "הגשות") and photo help with the latest request's state (AI-1); and every lesson as a small tile: its number (a crown when perfect), its stars (★ a lesson round finished, ★★ a round with 8 of 10 or more, ★★★ every skill of the lesson mastered), "⏰" when behind the curriculum (PTH-11) and "◐" when a round is open. Tapping a tile opens the lesson's round (STU-9). The path is reached from its tab ("העמקה").
+- **STU-1 Home** is one screen (it fits 360×800 with every lesson), like a game's level select: the stars collected (three per lesson), the lessons perfected, the streak and the daily goal; one big **play** button for the next lesson (the one with a round in progress, else the earliest behind the curriculum, else the first with fewer than three stars); the nearest test in one compact block (TST-3: the readiness number, its level and the days left, which open the test's page; the practice test and simulation buttons); small buttons beside the stats for the new assignments (their number, opening "הגשות") and photo help with the latest request's state (AI-1); and every lesson as a small tile: its number (a crown when perfect), its stars (★ a lesson round finished, ★★ a round with 8 of 10 or more, ★★★ every skill of the lesson mastered), "⏰" when behind the curriculum (PTH-11) and "◐" when a round is open. Tapping a tile opens the lesson's round (STU-9). The path is reached from its tab ("העמקה").
   When the curriculum gives the lessons dates, the current lesson (the first whose date is today or later) is shown on its own with its date, and the lessons whose date has passed (with how many are behind) and the coming ones are folded under it, each with its count.
 - **STU-9 Lesson round (סבב שיעור).** At most 10 questions from the lesson's skills that are not mastered, at most 3 from each (a lesson with one skill left is a round of 3); a lesson with every skill mastered draws 10 from all of them. Instant feedback as on the exercise screen (EX); every answer is a practice answer of its skill (mastery, daily goal, review list). The result shows the score, the lesson's stars, the skills mastered in the round and those one good day away, and each mistake's name and tip; never the right answers.
 - **STU-10 The way on the board (הדרך).** Every answer (practice, lesson rounds, lesson quizzes, exercise tests, the simulation) keeps a picture of the question's board when something is written on it; in quizzes and tests a choice needs the way on the board first. The teacher's "בדיקת דרך" tab lists the handed-in quizzes and tests of their students; each question shows the choices (the right one marked), the student's choice and board, and points for the way (automatic, 0, ½, full) that recompute the grade. Work pictures are private to the student and their teachers and follow the answer pictures' retention. After a practice test or the simulation, an AI (Gemini, one request per test, no names) reviews the way per question and the result shows "משוב על הדרך" (a verdict, a feedback line and a tip, never the right answer); the teacher sees it as a suggestion.
@@ -434,7 +423,7 @@ A tab bar at the bottom of the screen leads between them: home, path (named "ה
 - **TCH-4 Inbox and checking.** One inbox lists everything the teacher's students handed in that waits for them, oldest first: assignment submissions not checked yet (a returned one waits for the student)
   and open requests to look again (AI-5). The teacher opens each, sees the AI's suggested score and comment (AI-4) if there is one, gives a grade (0–100) and a note, or sends it back for correction.
 - **TCH-5 AI queue.** The teacher sees their classes' AI requests (AI-1), with the picture, and sends or declines each, or sends a whole batch (AI-7). It is an **"AI" tab** on the teacher's screen with the number of waiting requests, and it also has the teacher's own photo help (AI-2) and what is being worked on, what failed and why (AI-8). A student asking to look again (AI-5) appears in the inbox (TCH-4), not here.
-- **TCH-6 Tests tab.** The teacher sets a test (TST-1) and sees, for each test, which students have taken the simulation test and which have not.
+- **TCH-6 Tests tab.** The teacher sets a test (TST-1) and sees, for each test, which students have taken a simulation and which have not, and each student's readiness with how many practice tests and simulations they took and their best grades.
 - **TCH-7 Class progress, by lesson.** The teacher sees progress **per lesson, never per skill**.
   - Rows: students. Columns: lessons.
   - Each cell is short and shows three things only: a **progress bar** with the percent of the lesson's skills mastered written on it; the student's best quiz (בוחן) grade as a **bare number** (a dash for none, without the word); and, in the current period, a **warning mark** (⚠) when the lesson is behind the curriculum (PTH-11) and not completed. The lesson's state in words (הושלם PTH-10, בלמידה, לא התחילו, בפיגור) is the cell's accessible name, and a completed lesson's bar is gold.

mathly2/boardwork.py

@@ -89,8 +89,8 @@ 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 ""
-    from .exam import FOCUS
-    name = ("מבחן תרגול: נושאים לחיזוק" if number == str(FOCUS) else f"מבחן תרגול {number}") if row["kind"] == "exercise_test" else "מבחן סימולציה"
+    from .exam import TITLES, mode_of_scope
+    name = TITLES[mode_of_scope(row["scope"])] if row["kind"] == "exercise_test" else "מבחן סימולציה"
     return name + when
 
 

mathly2/clock.py

@@ -1,4 +1,4 @@
-"""Server time. Every rule that depends on days (mastery, the countdown, the simulation window) uses this,
+"""Server time. Every rule that depends on days (mastery, the days left to a test) uses this,
 never the device's clock."""
 from __future__ import annotations
 

mathly2/countdown.py

@@ -1,87 +0,0 @@
-"""The countdown plan for a real test, and today's one task (PRD TST-2, TST-3). Pure functions: the server gathers the facts.
-
-The plan, for a test set 9 or more days ahead (days left): until 9 finish the path; ~9 exercise test 1; ~7 exercise test 2; ~5 the
-simulation (open from then until the test day); 4 to 1 review the skills that failed in the simulation, the last day a light mixed
-review. For a test set `n < 9` days ahead the same order is kept and every day is scaled by n/9, rounded half up. The days are
-recommendations: everything but the simulation's window may be started any time."""
-from __future__ import annotations
-
-from datetime import date
-
-FULL = 9                                        # days of the full plan
-BASE = {"ex1": 9, "ex2": 7, "sim": 5, "review_from": 4}
-
-
-def _round(x: float) -> int:
-    return int(x + 0.5)
-
-
-def plan(test_day: date, set_day: date) -> dict:
-    """The recommended days (days left) of each step. `set_day` is the day the teacher set the test, so the plan does not shift as days pass."""
-    n = max(0, (test_day - set_day).days)
-    scale = 1.0 if n >= FULL else n / FULL
-    days = {step: _round(day * scale) if scale < 1 else day for step, day in BASE.items()}
-    days["review_from"] = max(days["review_from"], 1)
-    return {"n": n, **days}
-
-
-def step_for(days_left: int, p: dict) -> str:
-    """The step the plan recommends on a day: path, ex1, ex2, sim or review. It is the step whose recommended day is the nearest one
-    still ahead (days left at or above today's), the earlier step first when days coincide; before all of them, the path."""
-    steps = [("ex1", p["ex1"]), ("ex2", p["ex2"]), ("sim", p["sim"]), ("review", p["review_from"])]
-    ahead = [(day, i, name) for i, (name, day) in enumerate(steps) if day >= days_left]
-    return min(ahead)[2] if ahead else "path"
-
-
-def sim_open(days_left: int, p: dict) -> bool:
-    """The simulation is open from `sim` days before the test until the test day."""
-    return 0 <= days_left <= p["sim"]
-
-
-def outline(p: dict, facts: dict) -> list[dict]:
-    """The plan as steps with their recommended day (days left) and whether they are done, for the test's card."""
-    return [{"id": "path", "day": None, "until": p["ex1"], "done": facts["path_done"]},
-            {"id": "ex1", "day": p["ex1"], "done": facts["ex1_done"]},
-            {"id": "ex2", "day": p["ex2"], "done": facts["ex2_done"]},
-            {"id": "sim", "day": p["sim"], "done": facts["sim_taken"]},
-            {"id": "review", "day": p["review_from"], "done": facts["sim_taken"] and not facts["review_left"]}]
-
-
-def task(days_left: int, p: dict, facts: dict) -> dict:
-    """The one task for today. `facts`: path_done, next_path_skill, ex1_done, ex2_done, sim_taken, review_left (failed skills not
-    practised since), stale (covered skills, the one answered longest ago first). Returns {"kind": ...} with kind one of path, ex1, ex2,
-    sim, review, mixed_review, continue. The recommended step comes first; when it is done, the next later step that can be started."""
-    done = {"path": facts["path_done"], "ex1": facts["ex1_done"], "ex2": facts["ex2_done"], "sim": facts["sim_taken"], "review": False}
-    order = ["path", "ex1", "ex2", "sim", "review"]
-
-    def can(step: str) -> bool:
-        if step == "sim":
-            return sim_open(days_left, p)                           # the simulation cannot start before its window
-        return step != "review" or facts["sim_taken"]               # a review needs the simulation's result
-
-    def make(step: str) -> dict:
-        if step == "path":
-            return {"kind": "path", "skill": facts["next_path_skill"]}
-        if step == "review":
-            if days_left == 1 or not facts["review_left"]:
-                return {"kind": "mixed_review", "skill": facts["stale"][0] if facts["stale"] else None}
-            return {"kind": "review", "skill": facts["review_left"][0]}
-        return {"kind": step}
-
-    if days_left < 0:
-        return {"kind": "continue"}
-    rec = step_for(days_left, p)
-    if rec == "review" and not facts["sim_taken"]:                  # a review needs the simulation first
-        rec = "sim"
-    if days_left == 0 and facts["sim_taken"]:                       # the test day: nothing left to plan
-        return {"kind": "continue"}
-    for step in order[order.index(rec):]:                           # the recommended step, then later ones, early
-        if not done[step] and can(step):
-            return make(step)
-    return {"kind": "continue"}
-
-
-def closest(tests: list[dict], today: date) -> dict | None:
-    """The nearest test that has not passed (its day is today or later)."""
-    coming = [t for t in tests if t["date"] >= today]
-    return min(coming, key=lambda t: (t["date"], t["id"])) if coming else None

mathly2/exam.py

@@ -7,6 +7,15 @@ 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
+BALANCED, MANUAL = 1, 4                 # practice tests by mode (the number in the attempt's scope "<test>:<n>"); 2 is an older balanced one
+MODE_OF = {1: "balanced", 2: "balanced", FOCUS: "focus", MANUAL: "manual"}
+NUMBER_OF = {"balanced": BALANCED, "focus": FOCUS, "manual": MANUAL}
+TITLES = {"balanced": "מבחן תרגול מאוזן", "focus": "מבחן תרגול ממוקד", "manual": "מבחן תרגול בבחירה"}
+
+
+def mode_of_scope(scope: str) -> str:
+    _, _, number = scope.partition(":")
+    return MODE_OF.get(int(number), "balanced") if number.isdigit() else "balanced"
 
 
 def _round(x: float) -> int:
@@ -60,7 +69,7 @@ def draw(bank, lessons: list[str], states: dict[str, str], n: int, *, share: flo
 
 
 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)."""
+    """`n` questions from these skills only (the weak ones, or the ones the student picked), one per skill round after round (least-used 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()

mathly2/progress.py

@@ -115,8 +115,11 @@ def class_progress(class_id: int, request: Request, period: int | None = None, u
         for m in members:
             facts = facts_for(request, m["user_id"], nearest, today)
             ready = readiness_for(facts)
-            rows.append({"email": m["email"], "signed_in": bool(m["user_id"]), "readiness": ready, "mastery": ready["parts"]["M"],
-                         "practice": ready["parts"]["E"], "simulation": ready["parts"]["S"]})
+            covered = len(facts["covered"])
+            rows.append({"email": m["email"], "signed_in": bool(m["user_id"]), "readiness": ready,
+                         "mastery": round(100 * facts["mastered"] / covered) if covered else None,          # shown beside it; not part of it
+                         "practice": ready["practice_best"], "simulation": ready["simulation_best"],
+                         "practices": ready["practices"], "simulations": ready["simulations"]})
         names = {l["id"]: l["name"] for l in bank.lessons}
         test = {"id": nearest["id"], "date": nearest["date"].isoformat(), "days_left": (nearest["date"] - today).days,
                 "lessons": [names.get(i, i) for i in nearest["lessons"]], "students": rows}

mathly2/quizzes.py

@@ -41,7 +41,10 @@ def _test_info(request: Request, row: dict) -> dict:
     test_id, _, number = row["scope"].partition(":")
     test = request.app.state.store.get_test(int(test_id)) if test_id.isdigit() else None
     names = [l["name"] for l in request.app.state.bank.lessons if test and l["id"] in test["lessons"]]
+    from .exam import TITLES, mode_of_scope
+    mode = mode_of_scope(row["scope"]) if row["kind"] == "exercise_test" else None
     return {"id": int(test_id) if test_id.isdigit() else None, "number": int(number) if number.isdigit() else None,
+            "mode": mode, "title": TITLES[mode] if mode else "מבחן סימולציה",
             "date": test["date"].isoformat() if test else None, "lessons": names, "minutes": test["minutes"] if test else None}
 
 
@@ -63,8 +66,9 @@ def view(request: Request, row: dict) -> dict:
     row = boardreview.ensure(request.app, row)                          # a practice test or the simulation: the AI reviews the way
     result = attempts.result(bank, row)
     result.pop("lesson", None)
+    from .realtests import readiness_change
     return {**base, "state": "submitted", **result, "submitted_at": _iso(row["submitted_at"]), "review": boardreview.student_view(row),
-            "keys": [q["key"] for q in row["questions"]]}
+            "keys": [q["key"] for q in row["questions"]], "readiness": readiness_change(request, row)}
 
 
 _view = view
@@ -157,7 +161,9 @@ def grades(request: Request, user: dict = Depends(learner), subject: str = Query
         for row in here.attempts_of(uid, kind):
             row = attempts.settle(store, bank, row, now)
             if not attempts.is_open(row):
-                groups.setdefault((kind, row["scope"]), []).append(row)
+                from .exam import mode_of_scope
+                key = row["scope"] if kind == "simulation" else f"{row['scope'].split(':')[0]}:{mode_of_scope(row['scope'])}"   # by mode
+                groups.setdefault((kind, key), []).append(row)
     exercise, simulations = [], []
     for (kind, scope), rows in groups.items():
         test_id, _, number = scope.partition(":")
@@ -167,7 +173,8 @@ def grades(request: Request, user: dict = Depends(learner), subject: str = Query
         item = {"test": _test_ref(request, test), "best": max(r["grade"] for r in rows), "attempts": len(rows),
                 "last": _iso(max(r["submitted_at"] for r in rows))}
         if kind == "exercise_test":
-            exercise.append({**item, "number": int(number)})
+            from .exam import NUMBER_OF, TITLES
+            exercise.append({**item, "number": NUMBER_OF[number], "mode": number, "title": TITLES[number]})
         else:
             simulations.append(item)
     exercise.sort(key=lambda g: (g["test"]["date"], g["test"]["id"], g["number"]))

mathly2/readiness.py

@@ -1,42 +1,46 @@
-"""The readiness number for a real test (PRD RDY-1 to RDY-3): one 0-100 number from mastery, exercise tests and the simulation."""
+"""The readiness number for a real test: one 0-100 number that only tests move (practice tests and simulations), never the path.
+
+Every handed-in test pulls the number toward its grade, and only up: a grade above the number closes part of the gap, a grade at or below
+it changes nothing. A simulation closes more of the gap than a practice test; a practice test on skills the student picked closes less
+(it can skip the hard ones). So the number is never above the best grades, and the way up is more good tests, best of all a simulation.
+
+    number' = number + GAIN[kind] * (grade - number)   when grade > number
+"""
 from __future__ import annotations
 
-WEIGHTS = {"M": 50, "E": 20, "S": 30}
-CAP = 80                      # the most the number can show before the simulation is taken
+GAIN = {"simulation": 0.6, "practice": 0.3, "manual": 0.15}
+LEVELS = [(0, "מתחילים"), (40, "בדרך"), (70, "כמעט שם"), (85, "מוכנים")]
 
 
 def label(number: int) -> str:
-    if number < 40:
-        return "מתחילים"
-    if number < 70:
-        return "בדרך"
-    if number < 85:
-        return "כמעט שם"
-    return "מוכנים"
-
-
-def compute(m: float | None, e: float | None, s: float | None) -> dict:
-    """M: % of the covered skills mastered. E: average of the best grade of each exercise test taken. S: the simulation grade.
-    A part that does not exist is None and is left out; the others are scaled up. Without S the number is capped at 80."""
-    parts = {"M": m, "E": e, "S": s}
-    have = {k: v for k, v in parts.items() if v is not None}
-    if not have:
-        number = 0
-    else:
-        number = int(sum(WEIGHTS[k] * v for k, v in have.items()) / sum(WEIGHTS[k] for k in have) + 0.5)
-    capped = s is None and number > CAP
-    if s is None:
-        number = min(number, CAP)
-    number = max(0, min(100, number))
-    return {"number": number, "label": label(number), "capped": capped, "waiting_for_simulation": s is None,
-            "parts": {k: (None if v is None else int(v + 0.5)) for k, v in parts.items()}}
-
-
-def mastery_percent(mastered: int, covered: int) -> float | None:
-    """M: None when the test covers no skill with questions."""
-    return None if covered <= 0 else 100 * mastered / covered
-
-
-def exercise_average(best_grades: list[int]) -> float | None:
-    """E: the average of the best grade of each exercise test taken; None when none was taken."""
-    return sum(best_grades) / len(best_grades) if best_grades else None
+    return [name for at, name in LEVELS if number >= at][-1]
+
+
+def next_level(number: int) -> dict | None:
+    """The next level above the number: {"at", "name", "left"} (points left), or None at the top."""
+    above = [(at, name) for at, name in LEVELS if at > number]
+    return {"at": above[0][0], "name": above[0][1], "left": above[0][0] - number} if above else None
+
+
+def step(value: float, kind: str, grade: float) -> float:
+    return value + GAIN[kind] * (grade - value) if grade > value else value
+
+
+def compute(results: list[tuple[str, int]]) -> dict:
+    """`results`: the handed-in tests of one real test, oldest first, as (kind, grade) with kind simulation, practice or manual."""
+    value = 0.0
+    for kind, grade in results:
+        value = step(value, kind, grade)
+    number = max(0, min(100, int(value + 0.5)))
+    best = lambda kinds: max((g for k, g in results if k in kinds), default=None)
+    return {"number": number, "label": label(number), "next": next_level(number),
+            "practices": sum(1 for k, _ in results if k != "simulation"), "simulations": sum(1 for k, _ in results if k == "simulation"),
+            "practice_best": best(("practice", "manual")), "simulation_best": best(("simulation",)),
+            "can_add": {k: max(0, int(GAIN[k] * (100 - value) + 0.5)) for k in GAIN}}          # what a perfect test of each kind would add now
+
+
+def change(before: list[tuple[str, int]], result: tuple[str, int]) -> dict:
+    """What one handed-in test did to the number: before, after, the gain, and whether it reached a new level."""
+    old, new = compute(before), compute([*before, result])
+    return {"before": old["number"], "after": new["number"], "gain": new["number"] - old["number"], "label": new["label"],
+            "level_up": new["label"] != old["label"], "next": new["next"]}

mathly2/realtests.py

@@ -1,5 +1,6 @@
-"""Real tests: a teacher sets one for a class; every student of the class gets a countdown, two exercise tests, one simulation and a
-readiness number from it. Nothing is created per student: it is all derived from the test, the student's skill states and their attempts."""
+"""Real tests: a teacher sets one for a class; every student of the class can ask for practice tests (balanced, focused on the weak skills,
+or on skills they pick) and simulations (all the material, timed, as many as they like), and has a readiness number that only these tests
+move (readiness.py). Nothing is created per student: it is all derived from the test, the student's skill states and their attempts."""
 from __future__ import annotations
 
 from datetime import date, timedelta
@@ -8,7 +9,7 @@ from datetime import date as Day
 from fastapi import APIRouter, Depends, HTTPException, Query, Request
 from pydantic import BaseModel, Field
 
-from . import attempts, clock, countdown, exam, readiness, reads
+from . import attempts, clock, exam, readiness, reads
 from .access import allowed, learner, need
 from .learning import MASTERED, next_skill, skill_state
 
@@ -68,95 +69,89 @@ def _student_reads(user_id: str) -> list[tuple]:
     return [("progress_of", user_id), ("last_answered", user_id), ("attempts_of", user_id, "exercise_test"), ("attempts_of", user_id, "simulation")]
 
 
+def _kind_of(row: dict) -> str:
+    """How a handed-in test moves readiness: simulation, practice, or manual (a practice test on skills the student picked)."""
+    if row["kind"] == "simulation":
+        return "simulation"
+    return "manual" if exam.mode_of_scope(row["scope"]) == "manual" else "practice"
+
+
 def facts_for(request: Request, user_id: str | None, test: dict, today: date) -> dict:
-    """Everything the plan, the readiness meter and the draws need about one student and one test."""
+    """Everything the card, the readiness number and the draws need about one student and one test."""
     store, bank, now, here = request.app.state.store, request.app.state.bank, clock.now(), reads.of(request)
     covered = _covered(bank, test)
     if user_id:
-        here.prefetch(*_student_reads(user_id))                      # the four reads together (done once per request: a second test reuses them)
+        here.prefetch(*_student_reads(user_id))                      # the reads together (done once per request: a second test reuses them)
     states = {p["skill_id"]: skill_state(p) for p in here.progress_of(user_id)} if user_id else {}
-    last = here.last_answered(user_id) if user_id else {}
     tid = str(test["id"])
 
     def mine(kind: str) -> list[dict]:
         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, focus = {1: [], 2: []}, []
-    for row in mine("exercise_test"):
-        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()}
-    weak_before = {s["id"] for rows in exercise.values() for r in submitted(rows) for s in attempts.result(bank, r)["lost_skills"]}
-    failed: list[str] = []
-    review_left: list[str] = []
-    if simulation and not attempts.is_open(simulation):
-        failed = [s["id"] for s in attempts.result(bank, simulation)["lost_skills"]]
-        sim_day = clock.school_day(simulation["submitted_at"])
-        review_left = [i for i in failed if last.get(i) is None or last[i] <= sim_day]       # not practised after the simulation
-    mastered = [i for i in covered if states.get(i) == MASTERED]
-    unmastered = [i for i in covered if states.get(i) != MASTERED]
-    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))
+    practice, simulations = mine("exercise_test"), mine("simulation")
+    done = sorted((r for r in practice + simulations if not attempts.is_open(r)), key=lambda r: r["submitted_at"])
+    lost = {s["id"] for r in done for s in attempts.result(bank, r)["lost_skills"]}
     used: dict[str, int] = {}
-    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, "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"]})}
+    for r in practice + simulations:
+        for q in r["questions"]:
+            used[q["key"]] = used.get(q["key"], 0) + 1
+    return {"covered": covered, "states": states, "mastered": sum(1 for i in covered if states.get(i) == MASTERED),
+            "practice": practice, "simulations": simulations, "done": done, "results": [(_kind_of(r), r["grade"]) for r in done],
+            "sim_taken": any(r["kind"] == "simulation" for r in done), "used": used,
+            "focus_skills": [i for i in covered if (i in lost or states.get(i) == "learning") and bank.question_keys(i)]}
 
 
-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:
+    return readiness.compute(facts["results"])
 
 
-def readiness_for(facts: dict) -> dict:
-    m = readiness.mastery_percent(facts["mastered"], len(facts["covered"]))
-    e = readiness.exercise_average([g for g in facts["best"].values() if g is not None])
-    s = facts["simulation"]["grade"] if facts["sim_taken"] else None
-    return readiness.compute(m, e, s)
+def readiness_change(request: Request, row: dict) -> dict | None:
+    """For a handed-in practice test or simulation: what it did to its test's readiness number (before, after, gain, a new level)."""
+    if row["kind"] not in ("exercise_test", "simulation") or attempts.is_open(row):
+        return None
+    test_id = row["scope"].split(":")[0]
+    test = request.app.state.store.get_test(int(test_id)) if test_id.isdigit() else None
+    if test is None:
+        return None
+    facts = facts_for(request, row["user_id"], test, clock.school_day())
+    before = [(_kind_of(r), r["grade"]) for r in facts["done"] if r["submitted_at"] < row["submitted_at"]]
+    return readiness.change(before, (_kind_of(row), row["grade"]))
 
 
-def plan_for(test: dict) -> dict:
-    return countdown.plan(test["date"], clock.school_day(test["created_at"]))
+def _title(row: dict) -> str:
+    return "מבחן סימולציה" if row["kind"] == "simulation" else exam.TITLES[exam.mode_of_scope(row["scope"])]
 
 
 def card(request: Request, user_id: str | None, test: dict, today: date) -> dict:
-    """A test as its student sees it: the plan, readiness, both exercise tests, the simulation, and today's task."""
+    """A test as its student sees it: the readiness number and what moves it, the practice tests by mode, the simulations, and the trail
+    of handed-in tests with what each added."""
     bank = request.app.state.bank
     facts = facts_for(request, user_id, test, today)
-    p = plan_for(test)
     days_left = (test["date"] - today).days
-    exercises = []
-    for n in (1, 2):
-        rows = facts["exercise"][n]
-        open_ = next((r for r in rows if attempts.is_open(r)), None)
-        exercises.append({"number": n, "best": facts["best"][n], "attempts": len([r for r in rows if not attempts.is_open(r)]),
-                          "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)}
+    skill_row = lambda i: {"id": i, "name": bank.skill(i)["name"]}
+    open_of = lambda rows: next((r["id"] for r in reversed(rows) if attempts.is_open(r)), None)
+    by_mode = {m: [r for r in facts["practice"] if exam.mode_of_scope(r["scope"]) == m] for m in exam.TITLES}
+    trail, before = [], []
+    for row in facts["done"]:
+        moved = readiness.change(before, (_kind_of(row), row["grade"]))
+        before.append((_kind_of(row), row["grade"]))
+        trail.append({"attempt": row["id"], "kind": row["kind"], "title": _title(row), "grade": row["grade"], "gain": moved["gain"],
+                      "number": int(row["scope"].split(":")[1]) if row["kind"] == "exercise_test" else None,
+                      "after": moved["after"], "at": row["submitted_at"].isoformat()})
+    lessons = {l["id"]: l["name"] for l in bank.lessons}
     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, "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"],
-                           "taken": facts["sim_taken"], "grade": sim["grade"] if facts["sim_taken"] else None,
-                           "attempt": sim["id"] if sim else None, "in_progress": bool(sim and attempts.is_open(sim)),
-                           "review": [{"id": i, "name": bank.skill(i)["name"]} for i in facts["failed"] if bank.skill(i)]}}
+            "questions": test["questions"], "minutes": test["minutes"], "readiness": readiness_for(facts),
+            "practice": {"balanced": {"number": exam.BALANCED, "size": test["questions"], "open": open_of(by_mode["balanced"])},
+                         "focus": {"number": exam.FOCUS, "size": exam.FOCUS_SIZE, "open": open_of(by_mode["focus"]),
+                                   "skills": [skill_row(i) for i in facts["focus_skills"]]},
+                         "manual": {"number": exam.MANUAL, "size": test["questions"], "open": open_of(by_mode["manual"]),
+                                    "skills": [{**skill_row(i), "lesson": lessons.get(bank.skill(i)["unit"], ""),
+                                                "state": facts["states"].get(i, "not_started")} for i in facts["covered"]]}},
+            "simulation": {"open": open_of(facts["simulations"]), "taken": sum(1 for r in facts["done"] if r["kind"] == "simulation"),
+                           "best": readiness_for(facts)["simulation_best"]},
+            "trail": trail[::-1]}
 
 
 # ---- the teacher: set, change, remove, and see who took the simulation ----
@@ -201,7 +196,7 @@ def teacher_view(request: Request, test: dict, klass: dict, today: date) -> dict
     for m in members:
         facts = facts_for(request, m["user_id"], test, today)
         students.append({"email": m["email"], "signed_in": bool(m["user_id"]), "simulation_taken": facts["sim_taken"],
-                         "readiness": readiness_for(facts)})
+                         "readiness": readiness_for(facts)})          # readiness: the number, and how many practice tests and simulations
     taken = sum(1 for s in students if s["simulation_taken"])
     return {"id": test["id"], "class": {"id": klass["id"], "name": klass["name"]}, "date": test["date"].isoformat(), "note": test["note"],
             "subject_id": test.get("subject_id", "math"),
@@ -263,11 +258,6 @@ def remove_test(test_id: int, request: Request, user: dict = Depends(need("class
 
 # ---- the student: home and a test's card ----
 
-def _with_skill_name(request: Request, task: dict) -> dict:
-    skill = request.app.state.bank.skill(task["skill"]) if task.get("skill") else None
-    return {**task, "skill_name": skill["name"] if skill else None}
-
-
 def _next_path_skill(request: Request, user: dict, subject: str = "math") -> str | None:
     """The suggested next skill of the student's path in this subject (the same rule as the path's owl)."""
     from .skills import RECENT, visible_lesson_ids
@@ -281,8 +271,7 @@ def _next_path_skill(request: Request, user: dict, subject: str = "math") -> str
 
 @router.get("/home")
 def home(request: Request, user: dict = Depends(learner), subject: str = Query("math", max_length=40)) -> dict:
-    """The student's home: the upcoming tests (nearest first) with their readiness, today's one task from the nearest test,
-    the required simulation, and the next skill of the path."""
+    """The student's home: the upcoming tests (nearest first) with their readiness, the lesson map, and the next skill of the path."""
     here, today, uid = reads.of(request), clock.school_day(), user["id"]
     class_ids = [c["id"] for c in here.classes_of_student(user["email"])]
     from . import rounds
@@ -291,15 +280,11 @@ def home(request: Request, user: dict = Depends(learner), subject: str = Query("
     here.prefetch(("tests_of_classes", class_ids), ("recent_skills", uid, RECENT), ("attempts_of", uid, "quiz"), ("attempts_of", uid, rounds.KIND), ("curriculum",), ("daily_correct", uid), *_student_reads(uid))       # the tests and the student's facts: one wait
     tests = [t for t in here.tests_of_classes(class_ids) if t["date"] >= today and t.get("subject_id", "math") == subject]
     cards = [card(request, user["id"], t, today) for t in tests]
-    nearest = cards[0] if cards else None
     next_id = _next_path_skill(request, user, subject)
     next_skill_row = request.app.state.bank.skill(next_id) if next_id else None
-    return {"tests": cards, "task": {"test_id": nearest["id"], **_with_skill_name(request, nearest["task"])} if nearest else None,
-            "required_simulations": [{"test_id": c["id"], "date": c["date"], "days_left": c["days_left"]} for c in cards if c["simulation"]["required"]],
+    return {"tests": cards,
             "next_skill": {"id": next_id, "name": next_skill_row["name"]} if next_skill_row else None,
-            "behind": behind_lessons(request, user, subject), "subject": subject, "map": lesson_map(request, user, subject),
-            "weak_tests": [{"test_id": c["id"], "date": c["date"], "days_left": c["days_left"], "number": e["number"], "best": e["best"], "open": e["open"]}
-                           for c in cards[:1] for e in c["exercise_tests"] if e["best"] is not None and e["best"] < attempts.PASS_GRADE]}   # the nearest test's card only
+            "behind": behind_lessons(request, user, subject), "subject": subject, "map": lesson_map(request, user, subject)}
 
 
 def _student_test(request: Request, user: dict, test_id: int) -> dict:
@@ -317,54 +302,77 @@ def test_card(test_id: int, request: Request, user: dict = Depends(learner)) ->
     return card(request, user["id"], _student_test(request, user, test_id), clock.school_day())
 
 
-# ---- starting an exercise test or the simulation (reading, answering and submitting use the /api/attempts routes) ----
+# ---- starting a practice test or a simulation (reading, answering and submitting use the /api/attempts routes) ----
+
+class PracticeBody(BaseModel):
+    mode: str = Field(pattern="^(balanced|focus|manual)$")
+    skills: list[str] = Field(default_factory=list, max_length=200)    # manual: the skills to practise
+
+
+def _new(request: Request, user: dict, test: dict, kind: str, scope: str, questions: list[dict]) -> dict:
+    from .quizzes import view
+    now = clock.now()
+    return view(request, request.app.state.store.create_attempt(user["id"], kind, scope, now, now + timedelta(minutes=test["minutes"]), questions))
+
 
-def _start(request: Request, user: dict, test: dict, kind: str, scope: str, share: float, include_unstarted: bool = False) -> dict:
-    """Resume the student's open attempt of this scope, else draw a new one (questions weighted toward weak skills when `share`)."""
+def _practice(request: Request, user: dict, test: dict, mode: str, skills: list[str] | None = None, number: int | None = None) -> dict:
+    """Resume this mode's open practice test (not a manual one: a new choice is a new test), else draw a new one."""
     from .quizzes import view
-    store, bank, now = request.app.state.store, request.app.state.bank, clock.now()
+    bank = request.app.state.bank
     facts = facts_for(request, user["id"], test, clock.school_day())
-    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
+    number = number or exam.NUMBER_OF[mode]
+    scope = f"{test['id']}:{number}"
+    if mode != "manual":
+        for row in facts["practice"]:
+            if row["scope"] == scope and attempts.is_open(row):
+                return view(request, row)
+    rng = getattr(request.app.state, "quiz_rng", None)
+    if mode == "focus":
         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
-        drawn = exam.draw(bank, test["lessons"], facts["states"], test["questions"], share=0.0, weak_before=facts["weak_before"],
-                          used=facts["used"], include_unstarted=True)
-    if not drawn["questions"]:
-        raise HTTPException(409, "עוד לא התחלתם מיומנויות בשיעורים של המבחן. קודם מתרגלים במסלול.")
-    row = store.create_attempt(user["id"], kind, scope, now, now + timedelta(minutes=test["minutes"]), drawn["questions"])
-    return view(request, row)
+            raise HTTPException(409, "אין כרגע מיומנויות שהתקשיתם בהן. נסו מבחן מאוזן או סימולציה.")
+        drawn = exam.draw_focus(bank, facts["focus_skills"], used=facts["used"], rng=rng)
+    elif mode == "manual":
+        chosen = [i for i in dict.fromkeys(skills or []) if i in facts["covered"]]
+        if not chosen:
+            raise HTTPException(422, "בחרו לפחות מיומנות אחת מהחומר של המבחן")
+        drawn = exam.draw_focus(bank, chosen, n=test["questions"], used=facts["used"], rng=rng)
+    else:
+        drawn = exam.draw(bank, test["lessons"], facts["states"], test["questions"], used=facts["used"], include_unstarted=True, rng=rng)["questions"]
+    if not drawn:
+        raise HTTPException(409, "אין עדיין שאלות בחומר של המבחן")
+    return _new(request, user, test, "exercise_test", scope, drawn)
+
+
+@router.post("/tests/{test_id}/practice/start")
+def start_practice(test_id: int, body: PracticeBody, request: Request, user: dict = Depends(learner)) -> dict:
+    """A practice test: balanced (all the material, evenly), focus (the skills that lost points or are still being learned, 15 questions),
+    or manual (the skills the student picked)."""
+    return _practice(request, user, _student_test(request, user, test_id), body.mode, body.skills)
 
 
 @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 and number != exam.FOCUS:
+                   all_skills: bool = Query(False, description="kept for old links: every practice test now draws from all the material")) -> dict:
+    """An older address of a practice test by number (1, 2: balanced; 3: focus), as in a teacher's assignment."""
+    mode = exam.MODE_OF.get(number)
+    if mode is None or mode == "manual":
         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)
+    return _practice(request, user, _student_test(request, user, test_id), mode, number=number)
 
 
 @router.post("/tests/{test_id}/simulation/start")
 def start_simulation(test_id: int, request: Request, user: dict = Depends(learner),
-                     all_skills: bool = Query(False, description="a bypass: every skill of the test's lessons, started or not")) -> dict:
+                     all_skills: bool = Query(False, description="kept for old links: a simulation always draws from all the material")) -> dict:
+    """A simulation: all the test's material evenly, the test's length and time, no choice. As many as the student asks for; an open one
+    resumes."""
+    from .quizzes import view
     test = _student_test(request, user, test_id)
-    today = clock.school_day()
-    p = plan_for(test)
-    existing = facts_for(request, user["id"], test, today)["simulation"]
-    if not existing and not countdown.sim_open(( test["date"] - today).days, p):
-        opens = test["date"] - timedelta(days=p["sim"])
-        raise HTTPException(409, f"מבחן הסימולציה ייפתח ב־{opens.day}.{opens.month}" if today < opens else "מבחן הסימולציה נסגר")
-    return _start(request, user, test, "simulation", str(test_id), 0.0, all_skills)
+    facts = facts_for(request, user["id"], test, clock.school_day())
+    for row in facts["simulations"]:
+        if attempts.is_open(row):
+            return view(request, row)
+    drawn = exam.draw(request.app.state.bank, test["lessons"], facts["states"], test["questions"], used=facts["used"], include_unstarted=True,
+                      rng=getattr(request.app.state, "quiz_rng", None))["questions"]
+    if not drawn:
+        raise HTTPException(409, "אין עדיין שאלות בחומר של המבחן")
+    return _new(request, user, test, "simulation", str(test_id), drawn)

mathly2/static/app.css

@@ -633,7 +633,7 @@ body:has(#lesson-map) p:has(> #to-subjects) { margin-block: 0 4px; }
 .today-btn { flex: 0 1 auto; max-width: 58%; min-height: 44px; display: flex; align-items: center; gap: 4px; padding: 6px 12px; border-radius: 12px; text-decoration: none; font-weight: 700; font-size: 14px;
   color: var(--accent-text); background: var(--accent); }
 .today-btn small { font-weight: 600; opacity: .8; }
-.hchips { display: flex; flex-wrap: wrap; gap: 6px; margin-block: 8px; }
+.hchips { display: flex; flex-wrap: wrap; gap: 6px; margin-block: 4px; }
 .hchips-ai { display: contents; }
 .hchip { margin: 0; display: inline-flex; align-items: center; gap: 4px; min-height: 40px; padding: 6px 12px; border-radius: 999px; border: 1px solid var(--line); background: var(--surface);
   color: var(--text); text-decoration: none; font-size: 14px; font-weight: 600; }
@@ -711,3 +711,59 @@ body:has(#lesson-map) p:has(> #to-subjects) { margin-block: 0 4px; }
 .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; }
+
+/* ---------- readiness: the home's test block, the test's page, the gain on a result ---------- */
+.test-strip { flex-direction: column; align-items: stretch; gap: 4px; padding: 6px 10px; margin-block: 4px; }
+.test-strip .strip-main { flex-direction: row; align-items: center; gap: 10px; }
+.test-strip .strip-main .grow { display: flex; flex-direction: column; min-width: 0; line-height: 1.25; }
+.test-strip .strip-main small { font-size: 12px; }
+.strip-more { font-size: 18px; color: var(--accent); }
+.test-strip .readiness { margin: 0; }
+.test-strip .rd-num { font-size: 30px; line-height: 1; min-width: 1.4em; text-align: center; }
+.test-strip .rd-bar { height: 5px; margin: 3px 0 0; }
+.rd-top { align-items: center; }
+.rd-next { font-size: 13px; }
+.rd-up { display: inline-block; margin-inline-start: 6px; padding: 0 6px; border-radius: 999px; background: var(--sky-gold); color: #111; font-weight: 800; font-size: 13px;
+  animation: rd-pop .6s cubic-bezier(.2, 1.6, .4, 1) .9s both; }
+.rd-bar { position: relative; }
+.rd-bar i { transition: width .9s cubic-bezier(.2, .8, .2, 1); }
+.rd-bar s { position: absolute; top: -3px; bottom: -3px; width: 2px; background: var(--text); opacity: .35; text-decoration: none; }
+.readiness.grew .rd-num { animation: rd-pop .5s cubic-bezier(.2, 1.6, .4, 1); }
+.rd-how-line { margin: 0; font-size: 13px; }
+.test-btns { display: grid; grid-template-columns: 1fr 1fr; gap: 8px; }
+.test-btn { display: flex; align-items: center; justify-content: center; gap: 4px; min-height: 44px; padding: 4px 6px; border-radius: 12px; text-decoration: none; white-space: nowrap; font-size: 14px;
+  font-weight: 800; border: 1px solid var(--line); background: var(--surface); color: var(--text); }
+.test-btn.sim { background: var(--accent); border-color: var(--accent); color: var(--on-accent, #fff); }
+.test-btn small { font-weight: 800; font-size: 12px; padding: 0 6px; border-radius: 999px; background: color-mix(in srgb, var(--sky-gold) 30%, transparent); }
+.gain-hint { display: block; font-size: 12px; font-weight: 700; opacity: .85; }
+.big-btn { min-height: 52px; min-width: 220px; display: inline-flex; flex-direction: column; align-items: center; justify-content: center; }
+.rd-how summary { cursor: pointer; color: var(--accent); font-weight: 700; margin-top: 6px; }
+.rd-how ul { margin: 6px 0 0; padding-inline-start: 20px; font-size: 14px; }
+.modes { display: grid; gap: 8px; margin-block: 8px; }
+.mode { display: flex; gap: 10px; align-items: flex-start; padding: 10px; border: 1px solid var(--line); border-radius: 12px; cursor: pointer; }
+.mode.on { border-color: var(--accent); box-shadow: 0 0 0 1px var(--accent); }
+.mode.off { opacity: .55; cursor: default; }
+.mode input { margin-top: 4px; }
+#focus-skills { display: flex; flex-wrap: wrap; gap: 6px; margin-block: 6px; }
+#focus-skills[hidden], #manual-skills[hidden] { display: none; }
+#manual-skills { border: 1px solid var(--line); border-radius: 12px; padding: 8px 10px; margin-block: 6px; }
+.pick-lesson { margin: 8px 0 2px; font-weight: 700; }
+.pick { display: flex; gap: 6px; align-items: center; min-height: 40px; }
+.trail li a { display: flex; gap: 8px; align-items: center; padding: 8px 0; text-decoration: none; color: var(--text); border-bottom: 1px solid var(--line); }
+.trail .grow { flex: 1; min-width: 0; }
+.gain { min-width: 44px; text-align: center; font-weight: 800; color: var(--sky-gold); }
+.gain.zero { color: var(--muted); font-weight: 600; }
+.qz-ready { text-align: center; margin-block: 12px; padding: 12px; border-radius: 14px; border: 1px solid var(--line); background: color-mix(in srgb, var(--sky-gold) 8%, var(--surface)); }
+.qz-ready p { margin: 4px 0; }
+.qz-gain { font-size: 48px; line-height: 1; font-weight: 900; color: var(--sky-gold); text-shadow: 0 0 18px color-mix(in srgb, var(--sky-gold) 60%, transparent);
+  animation: rd-pop .7s cubic-bezier(.2, 1.6, .4, 1) .2s both; }
+.qz-level { font-size: 18px; font-weight: 800; color: var(--sky-gold); animation: rd-pop .6s cubic-bezier(.2, 1.6, .4, 1) .9s both; }
+.qz-more { display: flex; gap: 8px; justify-content: center; flex-wrap: wrap; }
+@media (prefers-reduced-motion: reduce) { .rd-up, .qz-gain, .qz-level, .readiness.grew .rd-num { animation: none; } .rd-bar i { transition: none; } }
+.quest-stats .hchips { display: contents; }
+.quest-stats .hchip, .quest-stats .hchips-ai .hchip { min-height: 30px; padding: 3px 8px; font-size: 14px; font-weight: 700; border-radius: 999px; }
+.quest-stats { gap: 4px; }
+.quest-stats span { padding: 3px 8px; }
+.quest-stats .hchips { padding: 0; border: 0; background: none; }
+.mode > span { flex: 1; min-width: 0; }
+.mode input { flex: none; width: 20px; height: 20px; }

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 === 3 ? "מבחן תרגול: נושאים לחיזוק" : `מבחן תרגול ${g.number}`), best: g.best, attempts: g.attempts, last: g.last })).join("")}</ul>` : ""}
+      href: `#/test/${g.test.id}`, title: testTitle(g.test, g.title || `מבחן תרגול ${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/home.js

@@ -1,66 +1,65 @@
 // The student's home for a subject: one screen, like a game's level select. The stars collected and a big play button for the next lesson,
-// every lesson as a small tile with its stars (a round finished, 8 of 10, every skill mastered), then the nearest test in one strip (the days
-// left, the readiness number, today's task) and small buttons for a required simulation, the new assignments and photo help.
+// every lesson as a small tile with its stars (a round finished, 8 of 10, every skill mastered), the nearest test in one block (the days
+// left, the readiness number and the two buttons that raise it: a practice test and a simulation), and small buttons for the new
+// assignments and photo help.
 import { swr } from "./api.js";
 import * as aiSheet from "./ai_sheet.js";
 import { esc, fmt } from "./math.js";
-import { backToSubjects, daysText, forSubject, pathHref, shortDate, tabs } from "./ui.js";
-
-/** One part of the readiness number as a row in plain Hebrew: its name, what the number is, and its value ("—" when there is none yet). */
-const part = (id, name, what, value, unit = "") => `<li class="rd-part" data-part="${id}"><span class="grow"><b>${name}</b> <span class="muted">${what}</span></span><b class="rd-val">${value === null ? "—" : value + unit}</b></li>`;
-
-/** The readiness number as a level bar with its three parts under it; before the simulation it says the bar is capped. */
-const HOW = ["המדד מורכב משליטה (50%), מבחני תרגול (20%) וסימולציה (30%).", "חלק שעוד אין לו ציון לא נספר.", "בלי סימולציה המדד לא עובר 80."];
-
-/** The info button beside the readiness number and its tooltip: hover, focus or tap opens it; a second tap, a tap elsewhere or Escape closes it. */
-const howTip = () => `<span class="info-tip"><button type="button" class="info" data-info aria-label="איך המדד מחושב" aria-expanded="false">ⓘ</button>
-  <span class="tip" role="tooltip" hidden>${HOW.map(l => `<span>${l}</span>`).join("")}</span></span>`;
-
-const closeTips = except => document.querySelectorAll(".info-tip.open").forEach(t => {
-  if (t === except) return;
-  t.classList.remove("open");
-  t.querySelector("[data-info]").setAttribute("aria-expanded", "false");
-  t.querySelector(".tip").hidden = true;
-});
-document.addEventListener("click", event => {
-  const tip = event.target.closest(".info-tip");
-  closeTips(tip);
-  if (!tip || !event.target.closest("[data-info]")) return;
-  const open = !tip.classList.contains("open");
-  tip.classList.toggle("open", open);
-  tip.querySelector("[data-info]").setAttribute("aria-expanded", String(open));
-  tip.querySelector(".tip").hidden = !open;
-});
-document.addEventListener("keydown", event => { if (event.key === "Escape") { closeTips(null); document.activeElement?.closest?.(".info-tip") && document.activeElement.blur(); } });
-
-export function readinessBar(r) {
-  return `<div class="readiness" data-readiness>
-    <p class="rd-top"><b class="rd-num" aria-hidden="true">${r.number}</b><span class="rd-label">${esc(r.label)}</span>${howTip()}</p>
-    <div class="bar rd-bar" role="progressbar" aria-label="מוכנות למבחן: ${r.number} מתוך 100, ${esc(r.label)}" aria-valuemin="0" aria-valuemax="100" aria-valuenow="${r.number}"><i style="width:${r.number}%"></i></div>
-    <ul class="plain rd-parts">${part("M", "שליטה", "אחוז המיומנויות שנשלטו", r.parts.M, "%")}${part("E", "מבחני תרגול", "ממוצע הציונים הטובים ביותר", r.parts.E)}${part("S", "סימולציה", "הציון במבחן הסימולציה", r.parts.S)}</ul>
-    ${r.waiting_for_simulation ? `<p class="rd-note">עוד לא עשיתם מבחן סימולציה, ולכן המדד לא עובר את ${80}.</p>` : ""}</div>`;
+import { backToSubjects, daysText, forSubject, shortDate, tabs } from "./ui.js";
+
+/* ---------- the nearest test: the readiness number, and the two ways to raise it ---------- */
+
+const SEEN = "mathly2.readiness.";
+/** The number the student saw last time for this test (to count up from it), and remember the new one. */
+function lastSeen(test) {
+  let before = null;
+  try { before = Number(localStorage.getItem(SEEN + test.id)); localStorage.setItem(SEEN + test.id, String(test.readiness.number)); } catch { /* private window */ }
+  return Number.isFinite(before) && before !== null && before < test.readiness.number ? before : null;
 }
 
-/** Today's task as {label, href}. */
-function taskLink(task, test, next) {
-  const skill = id => `#/skill/${encodeURIComponent(id)}`;
-  switch (task.kind) {
-    case "path": return { label: task.skill ? `לסיים את המסלול: ${task.skill_name}` : "לסיים את המסלול", href: task.skill ? skill(task.skill) : pathHref() };
-    case "ex1": case "ex2": return { label: `מבחן תרגול ${task.kind === "ex1" ? 1 : 2}`, href: `#/exam/${test.id}/${task.kind === "ex1" ? 1 : 2}` };
-    case "sim": return { label: "מבחן סימולציה", href: `#/sim/${test.id}` };
-    case "review": return { label: `חזרה על ${task.skill_name}`, href: skill(task.skill) };
-    case "mixed_review": return task.skill ? { label: `חזרה קלה: ${task.skill_name}`, href: skill(task.skill) } : { label: "חזרה קלה במסלול", href: pathHref() };
-    default: return next ? { label: `להמשיך במסלול: ${next.name}`, href: skill(next.id) } : { label: "למסלול", href: pathHref() };
-  }
+/** The readiness number as a level meter: the number (counting up when it grew since the last visit), its level, the bar, and the
+ *  points to the next level. */
+export function readinessMeter(test) {
+  const r = test.readiness, from = lastSeen(test);
+  return `<div class="readiness" data-readiness data-from="${from ?? ""}" data-to="${r.number}">
+    <p class="rd-top"><b class="rd-num" aria-hidden="true">${from ?? r.number}</b><span><span class="rd-label">מוכנות למבחן · <b>${esc(r.label)}</b></span>
+      ${from !== null ? `<span class="rd-up" aria-hidden="true">+${r.number - from}</span>` : ""}
+      <br><span class="muted rd-next">${r.next ? `עוד ${r.next.left} לרמה "${esc(r.next.name)}"` : "הגעתם לרמה הגבוהה ביותר! 🏆"}</span></span></p>
+    <div class="bar rd-bar" role="progressbar" aria-label="מוכנות למבחן: ${r.number} מתוך 100, ${esc(r.label)}" aria-valuemin="0" aria-valuemax="100" aria-valuenow="${r.number}">
+      <i style="width:${from ?? r.number}%"></i>${r.next ? `<s style="inset-inline-start:${r.next.at}%" aria-hidden="true"></s>` : ""}</div></div>`;
+}
+
+/** Count the number up from the last visit's and grow the bar with it. */
+function countUp(root = document) {
+  root.querySelectorAll(".readiness[data-from]:not([data-from=''])").forEach(meter => {
+    const from = Number(meter.dataset.from), to = Number(meter.dataset.to), num = meter.querySelector(".rd-num"), bar = meter.querySelector(".rd-bar i");
+    meter.dataset.from = "";
+    if (matchMedia("(prefers-reduced-motion: reduce)").matches) { num.textContent = to; bar.style.width = `${to}%`; return; }
+    const start = performance.now(), time = 900;
+    const frame = now => {
+      const k = Math.min(1, (now - start) / time), v = Math.round(from + (to - from) * (1 - (1 - k) ** 3));
+      num.textContent = v;
+      bar.style.width = `${v}%`;
+      if (k < 1) requestAnimationFrame(frame); else meter.classList.add("grew");
+    };
+    requestAnimationFrame(frame);
+  });
 }
+export { countUp };
 
-/** The nearest test, in one short strip: the days left and the readiness number (it opens the test's card, which has the bar, the plan and
- *  the practice tests), and today's one task as a button. */
-function testStrip(test, task, next) {
-  const t = taskLink(task, test, next);
+/** The nearest test in one compact block (the home is one screen): the readiness number with its level and the days left (a link to the
+ *  test's page, with all its tests and grades), the bar, and the two buttons that raise it, each with the most it can add now. */
+function testStrip(test) {
+  const r = test.readiness, add = r.can_add, sim = test.simulation.open, from = lastSeen(test);
   return `<section class="strip test-strip" id="nearest-test" data-test="${test.id}">
-    <a class="strip-main" href="#/test/${test.id}"><h2>📅 מבחן ${daysText(test.days_left)}</h2><span class="muted">מוכנות <b>${test.readiness.number}</b> ‹</span></a>
-    <a class="today-btn" id="today-task" href="${esc(t.href)}"><small>היום:</small> ${esc(t.label)}</a></section>`;
+    <div class="readiness" data-readiness data-from="${from ?? ""}" data-to="${r.number}">
+      <a class="strip-main" href="#/test/${test.id}"><b class="rd-num" aria-hidden="true">${from ?? r.number}</b>
+        <span class="grow"><span class="rd-label">מוכנות למבחן · <b>${esc(r.label)}</b>${from !== null ? ` <span class="rd-up" aria-hidden="true">+${r.number - from}</span>` : ""}</span>
+          <small class="muted">📅 <span class="days">מבחן ${daysText(test.days_left)}</span>${r.next ? ` · עוד ${r.next.left} לרמה "${esc(r.next.name)}"` : " · 🏆"}</small></span>
+        <span class="strip-more" aria-hidden="true">‹</span></a>
+      <div class="bar rd-bar" role="progressbar" aria-label="מוכנות למבחן: ${r.number} מתוך 100, ${esc(r.label)}" aria-valuemin="0" aria-valuemax="100" aria-valuenow="${r.number}"><i style="width:${from ?? r.number}%"></i></div></div>
+    <div class="test-btns"><a class="test-btn" id="home-practice" href="#/test/${test.id}/practice">📝 מבחן תרגול${add.practice ? ` <small>+${add.practice}</small>` : ""}</a>
+      <a class="test-btn sim" id="home-sim" href="#/sim/${test.id}${sim ? `/${esc(sim)}` : ""}">⏱ ${sim ? "להמשיך סימולציה" : "מבחן סימולציה"}${add.simulation && !sim ? ` <small>+${add.simulation}</small>` : ""}</a></div></section>`;
 }
 
 /** An assignment's state in a symbol and a word (never colour alone). */
@@ -111,7 +110,7 @@ function tile(l, next) {
 }
 
 /** The top: the stars collected, the lessons perfected, the streak and the daily goal, then the big play button for the next lesson. */
-function quest(map) {
+function quest(map, chips = "") {
   const next = map.lessons.find(l => l.id === map.next);
   const play = next ? `<a class="play" id="play" href="${roundHref(next.id)}"><span class="play-icon" aria-hidden="true">▶</span>
       <span class="grow"><small>${next.round_open ? "להמשיך את הסבב" : next.behind ? "להשלים" : next.stars ? "לעוד כוכב" : "השיעור הבא"}</small><b>${fmt(next.name)}</b></span>
@@ -119,8 +118,9 @@ function quest(map) {
     : `<p class="all-perfect" id="play">👑 כל השיעורים מושלמים! אפשר להעמיק בלשונית העמקה.</p>`;
   const t = map.today;
   return `<section class="quest" id="quest" aria-label="המסע שלי">
-    <p class="quest-stats"><span id="stars-count">⭐ ${map.stars} מתוך ${map.max_stars}</span><span id="perfect-count">👑 ${map.perfect}</span>
-      ${map.streak ? `<span>🔥 ${map.streak}</span>` : ""}<span id="goal" class="goal-chip${t.reached ? " done" : ""}" title="יעד יומי">🎯 ${Math.min(t.done, t.goal)}/${t.goal}${t.reached ? " ✓" : ""}</span></p>
+    <p class="quest-stats"><span id="stars-count" aria-label="${map.stars} כוכבים מתוך ${map.max_stars}">⭐ ${map.stars}/${map.max_stars}</span><span id="perfect-count">👑 ${map.perfect}</span>
+      ${map.streak ? `<span>🔥 ${map.streak}</span>` : ""}<span id="goal" class="goal-chip${t.reached ? " done" : ""}" title="יעד יומי">🎯 ${Math.min(t.done, t.goal)}/${t.goal}${t.reached ? " ✓" : ""}</span>
+      ${chips ? `<span class="hchips" id="home-actions">${chips}</span>` : ""}</p>
     ${play}</section>`;
 }
 
@@ -146,13 +146,12 @@ export const show = view => swr([forSubject("/api/home"), "/api/assignments", "/
 
 function draw(view, data, assignments, ai) {
   const [first] = data.tests;
-  const required = data.tests.filter(t => t.simulation.required);
-  const chips = required.map(t => `<a class="hchip required" href="#/sim/${t.id}" data-required="${t.id}"><b>חובה</b> סימולציה</a>`).join("") + assignmentsChip(assignments) + aiChips(ai);
+  const chips = assignmentsChip(assignments) + aiChips(ai);
   view(`${tabs("home")}${backToSubjects()}
-    ${quest(data.map)}
-    ${first ? testStrip(first, data.task, data.next_skill) : ""}
-    ${chips ? `<div class="hchips" id="home-actions">${chips}</div>` : ""}
+    ${quest(data.map, chips)}
+    ${first ? testStrip(first) : ""}
     ${board(data.map)}`);
+  countUp();
   document.getElementById("ai-new")?.addEventListener("click", () => aiSheet.open());
   document.querySelectorAll("[data-ai-open]").forEach(b => b.addEventListener("click", () => aiSheet.open({ id: b.dataset.aiOpen })));
 }

mathly2/static/quiz.js

@@ -39,16 +39,31 @@ export async function startExam(testId, number, allSkills = false) {
   location.replace(`#/exam/${encodeURIComponent(testId)}/${encodeURIComponent(number)}/${encodeURIComponent(data.id)}`);
 }
 
-/** `allSkills` (address `#/sim/<test>/all`): the bypass when no skill of the test is started yet, drawn from all the material. */
+/** A simulation on request (an open one resumes). `allSkills` is kept for old addresses (`#/sim/<test>/all`). */
 export async function startSimulation(testId, allSkills = false) {
   const data = await api(`/api/tests/${encodeURIComponent(testId)}/simulation/start${allSkills ? "?all_skills=true" : ""}`, { method: "POST" });
   location.replace(`#/sim/${encodeURIComponent(testId)}/${encodeURIComponent(data.id)}`);
 }
 
 /** What the sheet is called, who it is about and where closing it leads, by kind. */
-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: "מבחן חוזר" })
+const FOCUS = 3;                                     // the practice test on the hard skills
+const names = a => a.kind === "exercise_test" ? { title: a.test.title || "מבחן תרגול", again: "" }        // a test: the readiness block offers the next one
   : a.kind === "simulation" ? { title: "מבחן סימולציה", again: "" } : { title: "בוחן", again: "בוחן חוזר" };
+
+/** What the test did to the readiness number: the gain big, the bar growing from before to after, a new level, the next one, and the
+ *  two ways to go on raising it. */
+function readinessHtml(r) {
+  const x = r.readiness;
+  if (!x) return "";
+  const test = r.test.id;
+  return `<section class="qz-ready${x.gain ? " up" : ""}" id="qz-ready" data-gain="${x.gain}">
+    ${x.gain ? `<p class="qz-gain" aria-hidden="true">+${x.gain}</p><p><b>המוכנות למבחן עלתה ל־${x.after}!</b></p>`
+      : `<p><b>המוכנות נשארה ${x.after}.</b> <span class="muted">ציון מעל ${x.after} יעלה אותה.</span></p>`}
+    ${x.level_up ? `<p class="qz-level">🎉 רמה חדשה: ${esc(x.label)}!</p>` : ""}
+    <div class="bar rd-bar" role="progressbar" aria-label="מוכנות ${x.after} מתוך 100" aria-valuemin="0" aria-valuemax="100" aria-valuenow="${x.after}"><i style="width:${x.before}%" data-to="${x.after}"></i></div>
+    <p class="muted">${x.next ? `עוד ${x.next.left} לרמה "${esc(x.next.name)}"` : "הרמה הגבוהה ביותר! 🏆"}</p>
+    <p class="qz-more"><a class="button primary" id="qz-more-sim" href="#/sim/${test}">⏱ עוד סימולציה</a> <a class="button" id="qz-more-practice" href="#/test/${test}/practice">📝 מבחן תרגול</a></p></section>`;
+}
 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}`;
 
@@ -241,11 +256,12 @@ function renderResult() {
   q(".mx-sheet").innerHTML = `${heading(`תוצאת ${names(r).title}`)}
     <div class="qz-result"><p class="qz-grade" id="qz-grade" aria-label="הציון ${r.grade}"><b>${r.grade}</b><span>מתוך 100</span></p>
       <p>${r.right === 1 ? "תשובה נכונה אחת" : `${r.right} תשובות נכונות`} מתוך ${r.total}${r.timed_out ? ". הזמן נגמר והבוחן הוגש כמו שהוא." : ""}</p>
-      <p class="muted" id="qz-best"></p>${r.kind === "simulation" ? `<p class="muted">מבחן סימולציה אפשר לעשות פעם אחת.</p>` : ""}</div>
+      <p class="muted" id="qz-best"></p></div>
+    ${readinessHtml(r)}
     ${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>
-      ${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.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>` : ""}
@@ -253,7 +269,9 @@ function renderResult() {
     <p class="qz-actions">${r.missed.length ? `<a class="button primary" id="qz-retry" href="#/retry/${esc(r.id)}">🔁 חזרה על השאלות שטעיתי (${r.missed.length})</a> ` : ""}${names(r).again ? `<button type="button" class="${r.missed.length ? "" : "primary"}" id="qz-retake">${names(r).again}</button> ` : ""}<button type="button" data-close>${r.kind === "quiz" ? "חזרה למסלול" : "חזרה למבחן"}</button></p>`;
   if (r.review?.state === "pending") waitForReview(r.id);
   const best = r.kind === "quiz" ? api(`/api/lessons/${encodeURIComponent(r.lesson.id)}/quiz`).then(f => f.best === null ? "" : `הציון של השיעור: ${f.best}`)
-    : r.kind === "exercise_test" ? api(`/api/tests/${encodeURIComponent(r.test.id)}`).then(t => `הציון הטוב במבחן התרגול: ${t.exercise_tests[r.test.number - 1].best ?? ""}`) : Promise.resolve("");
+    : Promise.resolve("");
+  const grow = q("#qz-ready .rd-bar i");
+  if (grow) setTimeout(() => { grow.style.width = `${grow.dataset.to}%`; }, 300);
   best.then(text => { if (text && q("#qz-best")) q("#qz-best").textContent = text; }).catch(() => {});
 }
 
@@ -272,7 +290,8 @@ function onClick(event) {
     if (target.closest("#qz-back")) { q("#qz-warn").innerHTML = ""; warned = false; return; }
   } else if (target.closest("#qz-retake")) {
     at = 0;
-    const again = attempt.kind === "quiz" ? start(attempt.lesson.id) : startExam(attempt.test.id, attempt.test.number);
+    const again = attempt.kind === "quiz" ? start(attempt.lesson.id) : attempt.kind === "simulation" ? startSimulation(attempt.test.id)
+      : startExam(attempt.test.id, attempt.test.number);
     again.catch(error => { q(".qz-actions").insertAdjacentHTML("afterend", `<p class="error" role="alert">${esc(error.message)}</p>`); });
   }
 }

mathly2/static/student.js

@@ -69,11 +69,13 @@ export async function show(me, view) {
         const attempt = allSkills ? undefined : kind === "exam" ? third : second;
         if (!document.getElementById("path") && !document.getElementById("test-card")) await (await import("./testcard.js")).show(view, test);   // a link or a reload: the test's card first
         if (attempt) await quiz.open(attempt);
+        else if (kind === "exam" && second === "4") location.replace(`#/test/${encodeURIComponent(test)}/practice`);   // picked skills: choose them first
         else if (kind === "exam") await quiz.startExam(test, second, allSkills);
         else await quiz.startSimulation(test, allSkills);
       } else if (where.startsWith("/test/")) {
         exercise.close(); quiz.close();
-        await (await import("./testcard.js")).show(view, decodeURIComponent(where.slice(6)));
+        const [testId, part] = where.slice(6).split("/").map(decodeURIComponent);      // "/test/<id>/practice": straight to the practice test's choice
+        await (await import("./testcard.js")).show(view, testId, part === "practice" ? "practice" : "");
       } else if (where === "/review") {
         exercise.close(); quiz.close();
         await (await import("./review.js")).show(view);

mathly2/static/teacher.js

@@ -124,9 +124,9 @@ function testCard(c, t) {
     <p class="muted">${t.lessons.map(l => fmt(l.name)).join(", ")}${t.note ? ` · ${esc(t.note)}` : ""} · ${t.questions} שאלות · ${t.minutes} דקות</p>
     ${t.simulation.missing.length ? `<p class="sim-missing"><b>עוד לא עשו סימולציה:</b> ${t.simulation.missing.map(e => `<span dir="ltr">${esc(e)}</span>`).join(", ")}</p>`
       : t.simulation.total ? `<p class="sim-missing">כולם עשו את מבחן הסימולציה.</p>` : ""}
-    ${t.students.length ? `<div class="tablewrap"><table class="data readiness-table"><thead><tr><th>תלמיד</th><th>מוכנות</th><th>שליטה</th><th>תרגול</th><th>סימולציה</th></tr></thead>
+    ${t.students.length ? `<div class="tablewrap"><table class="data readiness-table"><thead><tr><th>תלמיד</th><th>מוכנות</th><th>מבחני תרגול</th><th>סימולציות</th></tr></thead>
       <tbody>${t.students.map(s => `<tr><td dir="ltr">${esc(s.email)}</td><td>${s.readiness.number} · ${esc(s.readiness.label)}</td>
-        <td>${s.readiness.parts.M === null ? "—" : s.readiness.parts.M + "%"}</td><td>${s.readiness.parts.E ?? "—"}</td><td>${s.readiness.parts.S ?? "—"}</td></tr>`).join("")}</tbody></table></div>` : ""}
+        <td>${s.readiness.practices ? `${s.readiness.practices} · הטוב ${s.readiness.practice_best}` : "—"}</td><td>${s.readiness.simulations ? `${s.readiness.simulations} · הטוב ${s.readiness.simulation_best}` : "—"}</td></tr>`).join("")}</tbody></table></div>` : ""}
     <p class="test-actions">${open ? `<button type="button" data-edit="${t.id}">שינוי</button> ` : ""}<button type="button" data-remove-test="${t.id}">הסרה</button></p>
     <div class="edit-slot" data-slot="${t.id}"></div></article>`;
 }

mathly2/static/teacher_progress.js

@@ -27,9 +27,10 @@ function lessonsView(data) {
 function readiness(data) {
   const t = data.test;
   if (!t) return `<p class="muted" id="no-test">עוד לא נקבע מבחן קרוב לכיתה הזו.</p>`;
-  const rows = t.students.map(s => `<tr data-student="${esc(s.email)}">${who(s)}<td><b>${s.readiness.number}</b> · ${esc(s.readiness.label)}</td><td>${dash(s.mastery)}${s.mastery === null ? "" : "%"}</td><td>${dash(s.practice)}</td><td>${dash(s.simulation)}</td></tr>`).join("");
+  const rows = t.students.map(s => `<tr data-student="${esc(s.email)}">${who(s)}<td><b>${s.readiness.number}</b> · ${esc(s.readiness.label)}</td><td>${dash(s.mastery)}${s.mastery === null ? "" : "%"}</td><td>${dash(s.practice)}${s.practices ? ` <span class="muted">(${s.practices})</span>` : ""}</td><td>${dash(s.simulation)}${s.simulations ? ` <span class="muted">(${s.simulations})</span>` : ""}</td></tr>`).join("");
   return `<p>מבחן ב־${shortDate(t.date)} (${t.days_left === 0 ? "היום" : `בעוד ${t.days_left} ימים`}): ${t.lessons.map(esc).join(", ")}</p>
-    <div class="tablewrap" tabindex="0" role="region" aria-label="מוכנות"><table class="hm"><thead><tr><th class="sticky">תלמיד</th><th>מוכנות</th><th>שליטה</th><th>תרגול</th><th>סימולציה</th></tr></thead><tbody>${rows}</tbody></table></div>`;
+    <div class="tablewrap" tabindex="0" role="region" aria-label="מוכנות"><table class="hm"><thead><tr><th class="sticky">תלמיד</th><th>מוכנות</th><th>שליטה</th><th>תרגול: הטוב (כמה)</th><th>סימולציה: הטוב (כמה)</th></tr></thead><tbody>${rows}</tbody></table></div>
+    <p class="muted">המוכנות עולה רק ממבחני תרגול וסימולציות. השליטה במסלול מוצגת לידה ולא נכללת בה.</p>`;
 }
 
 function page(ctx, classes, data) {

mathly2/static/testcard.js

@@ -1,63 +1,107 @@
-// One real test: its plan with the recommended days, the readiness bar, the two exercise tests, the simulation and what to practise first.
+// One real test: the readiness number and what moves it, a simulation on request (all the material, timed, no choice), a practice test on
+// request in one of three modes (balanced, focused on the skills that were hard, or skills picked by hand), and the trail of the tests
+// handed in with what each one added.
 import { api } from "./api.js";
 import { esc, fmt } from "./math.js";
-import { readinessBar } from "./home.js";
+import { countUp, readinessMeter } from "./home.js";
 import { daysText, forSubject, homeHref, setSubject, shortDate, tabs } from "./ui.js";
 
-const STEP_NAMES = { path: "לסיים את המסלול של השיעורים", ex1: "מבחן תרגול 1", ex2: "מבחן תרגול 2", sim: "מבחן סימולציה", review: "חזרה על מה שנפל בסימולציה" };
+const MODES = [
+  ["balanced", "⚖️ מאוזן", "שאלות מכל החומר של המבחן, באופן שווה."],
+  ["focus", "🎯 ממוקד", "15 שאלות רק מהמיומנויות שהתקשיתם בהן במבחנים."],
+  ["manual", "✋ בחירה ידנית", "אתם בוחרים את המיומנויות."],
+];
+const STATE = { mastered: "👑", learning: "◐", not_started: "○" };
 
-function planList(test) {
-  return `<ol class="plan" id="plan">${test.plan.map(step => {
-    const when = step.id === "path" ? `עד ${step.until} ימים לפני` : step.id === "review" ? `${step.day} ימים לפני ועד המבחן` : `בערך ${step.day} ימים לפני`;
-    return `<li class="${step.done ? "done" : ""}" data-step="${step.id}"><span class="mark" aria-hidden="true">${step.done ? "✓" : "○"}</span>
-      <span><b>${STEP_NAMES[step.id]}</b><br><span class="muted">${when} · ${step.done ? "בוצע" : "עוד לא"}</span></span></li>`;
-  }).join("")}</ol><p class="muted">הימים הם המלצה: אפשר להתחיל כל שלב קודם או אחר כך.</p>`;
+/** How the number moves, in plain words. */
+const HOW = `<details class="rd-how" id="rd-how"><summary>איך מעלים את המוכנות?</summary><ul>
+  <li>כל מבחן שהציון בו גבוה מהמוכנות מעלה אותה: מבחן תרגול סוגר 30% מהפער, <b>מבחן סימולציה סוגר 60%</b>, ומבחן בבחירה ידנית 15%.</li>
+  <li>ציון נמוך מהמוכנות לא מוריד אותה.</li>
+  <li>רק מבחנים נספרים. תרגול במסלול ובהעמקה עוזר להצליח בהם, אבל לא משנה את המספר.</li></ul></details>`;
+
+function simulationCard(test) {
+  const s = test.simulation, gain = test.readiness.can_add.simulation;
+  return `<section class="card test-action" id="simulation"><h3>⏱ מבחן סימולציה</h3>
+    <p class="muted">כמו המבחן האמיתי: ${test.questions} שאלות מכל החומר, ${test.minutes} דקות. את השאלות בוחרת האפליקציה.</p>
+    <p><a class="button primary big-btn" id="sim-start" href="#/sim/${test.id}${s.open ? `/${esc(s.open)}` : ""}">${s.open ? "להמשיך את הסימולציה" : "בקשת מבחן סימולציה"}
+      ${s.open || !gain ? "" : `<small class="gain-hint">עד +${gain} מוכנות</small>`}</a></p>
+    ${s.taken ? `<p class="muted" id="sim-done">עשיתם ${s.taken === 1 ? "סימולציה אחת" : `${s.taken} סימולציות`} · הציון הטוב: <b id="sim-best">${s.best}</b></p>` : ""}</section>`;
 }
 
-function exercises(test) {
-  return `<ul class="plain" id="exercises">${test.exercise_tests.map(e => `<li data-exercise="${e.number}">
-    <span><b>מבחן תרגול ${e.number}</b><br><span class="muted">${e.best === null ? "עוד לא נעשה" : `הציון הטוב: ${e.best} · ${e.attempts} ${e.attempts === 1 ? "ניסיון" : "ניסיונות"}`}</span></span>
-    <a class="button" href="#/exam/${test.id}/${e.number}">${e.open ? "להמשיך" : e.attempts ? "שוב" : "התחלה"}</a></li>`).join("")}</ul>`;
+function practiceCard(test) {
+  const p = test.practice, gain = test.readiness.can_add;
+  const lessons = [...new Set(p.manual.skills.map(s => s.lesson))];
+  const radio = ([mode, title, what]) => {
+    const off = mode === "focus" && !p.focus.skills.length;
+    return `<label class="mode${off ? " off" : ""}" data-mode="${mode}"><input type="radio" name="mode" value="${mode}"${mode === "balanced" ? " checked" : ""}${off ? " disabled" : ""}>
+      <span><b>${title}</b>${p[mode].open ? ` <span class="tag">באמצע</span>` : ""}<br><span class="muted">${off ? "יופיע אחרי מבחן שבו היו טעויות." : what}</span></span></label>`;
+  };
+  return `<section class="card test-action" id="practice"><h3>📝 מבחן תרגול</h3>
+    <p class="muted">אתם בוחרים על מה להתאמן. בלי שעון.</p>
+    <div class="modes" role="radiogroup" aria-label="סוג מבחן התרגול">${MODES.map(radio).join("")}</div>
+    <div id="focus-skills" class="chips" hidden>${p.focus.skills.map(s => `<span class="ex-chip">${fmt(s.name)}</span>`).join(" ")}</div>
+    <fieldset id="manual-skills" hidden><legend>בחרו מיומנויות</legend>${lessons.map(lesson => `<p class="muted pick-lesson">${fmt(lesson)}</p>
+      ${p.manual.skills.filter(s => s.lesson === lesson).map(s => `<label class="pick"><input type="checkbox" value="${esc(s.id)}"> <span aria-hidden="true">${STATE[s.state] || ""}</span> ${fmt(s.name)}</label>`).join("")}`).join("")}</fieldset>
+    <p><button type="button" class="primary big-btn" id="practice-start">בקשת מבחן תרגול <small class="gain-hint">עד +${gain.practice} מוכנות</small></button></p>
+    <p class="error" id="practice-error" role="alert" hidden></p></section>`;
 }
 
-/** 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 trailCard(test) {
+  if (!test.trail.length) return "";
+  return `<section class="card" id="trail"><h3>המבחנים שעשיתם</h3><ol class="plain trail">${test.trail.map(t => `<li data-kind="${t.kind}">
+      <a href="${t.kind === "simulation" ? `#/sim/${test.id}/${esc(t.attempt)}` : `#/exam/${test.id}/${t.number}/${esc(t.attempt)}`}"><span class="grow"><b>${esc(t.title)}</b>
+      <span class="muted"> · ${shortDate(t.at.slice(0, 10))}</span></span><span class="tag">ציון ${t.grade}</span>
+      <span class="gain${t.gain ? "" : " zero"}">${t.gain ? `+${t.gain}` : "±0"}</span></a></li>`).join("")}</ol></section>`;
 }
 
-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 =>
-        `<li><a href="#/skill/${esc(r.id)}">${fmt(r.name)}</a></li>`).join("")}</ul>` : `<p class="muted">אין מיומנויות לחזרה. כל הכבוד!</p>`}
-      <p><a class="button" href="#/sim/${test.id}">לתוצאה</a></p>`
-    : s.open_now ? `<p><b class="req">חובה</b> המבחן פתוח עד יום המבחן. אפשר לעשות אותו פעם אחת.</p>
-      <p><a class="button primary" id="sim-start" href="#/sim/${test.id}">${s.in_progress ? "להמשיך" : "התחלה"}</a></p>`
-    : `<p id="sim-closed">מבחן הסימולציה ייפתח ב־${shortDate(s.opens_on)} (בעוד ${s.opens_in_days} ימים). אפשר לעשות אותו פעם אחת.</p>`;
-  return `<div id="simulation" data-taken="${s.taken}">${lead}</div>`;
+/** The mode's extra part (the hard skills, the skills to pick) and what the button says; the button asks for the test. */
+function wire(test) {
+  const card = document.getElementById("practice");
+  const mode = () => card.querySelector("input[name=mode]:checked").value;
+  const sync = () => {
+    const m = mode(), resume = m !== "manual" && test.practice[m].open;
+    card.querySelector("#focus-skills").hidden = m !== "focus";
+    card.querySelector("#manual-skills").hidden = m !== "manual";
+    card.querySelectorAll(".mode").forEach(l => l.classList.toggle("on", l.dataset.mode === m));
+    const gain = test.readiness.can_add[m === "manual" ? "manual" : "practice"];
+    document.getElementById("practice-start").innerHTML = resume ? "להמשיך את המבחן"
+      : `בקשת מבחן תרגול${gain ? ` <small class="gain-hint">עד +${gain} מוכנות</small>` : ""}`;
+  };
+  card.addEventListener("change", sync);
+  sync();
+  document.getElementById("practice-start").addEventListener("click", async event => {
+    const button = event.currentTarget, error = document.getElementById("practice-error"), m = mode();
+    const skills = [...card.querySelectorAll("#manual-skills input:checked")].map(i => i.value);
+    if (m === "manual" && !skills.length) { error.textContent = "בחרו לפחות מיומנות אחת."; error.hidden = false; return; }
+    button.disabled = true;
+    error.hidden = true;
+    try {
+      const data = await api(`/api/tests/${test.id}/practice/start`, { method: "POST", body: { mode: m, skills } });
+      location.hash = `#/exam/${test.id}/${data.test.number}/${encodeURIComponent(data.id)}`;
+    } catch (e) {
+      button.disabled = false;
+      error.textContent = e.message || "משהו השתבש";
+      error.hidden = false;
+    }
+  });
 }
 
-export async function show(view, id) {
+/** `focus`: a section to scroll to ("practice" from the home's button). */
+export async function show(view, id, focus = "") {
   const test = await api(`/api/tests/${encodeURIComponent(id)}`);
   setSubject(test.subject_id);                                         // a test belongs to one subject: its home and tab bar follow it
   const home = await api(forSubject("/api/home"));
   const others = home.tests.filter(t => t.id !== test.id);
   view(`${tabs("home")}<p><a class="back" href="${homeHref()}">‹ הבית</a></p>
     <section class="card" id="test-card" data-test="${test.id}"><h2>מבחן ב־${shortDate(test.date)} <span class="muted">(${daysText(test.days_left)})</span></h2>
-      <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)}${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>
-        <p class="muted">"על כל החומר": שאלות מכל הנושאים של המבחן, כמו במבחן הסימולציה, גם ממיומנויות שעוד לא התחלתם.</p>` : ""}</section>
-    <section class="card"><h3>מבחן סימולציה</h3>${simulation(test)}</section>
+      <p class="muted">${test.lessons.map(l => fmt(l.name)).join(", ")}${test.note ? ` · ${esc(test.note)}` : ""}</p>
+      ${readinessMeter(test)}${HOW}</section>
+    ${simulationCard(test)}
+    ${practiceCard(test)}
+    ${trailCard(test)}
     ${others.length ? `<section class="card"><h3>מבחנים נוספים</h3><ul class="plain" id="other-tests">${others.map(t => `<li><a href="#/test/${t.id}">${shortDate(t.date)} · ${t.lessons.map(l => fmt(l.name)).join(", ")}</a>
       <span class="muted">${daysText(t.days_left)} · מוכנות ${t.readiness.number}</span></li>`).join("")}</ul></section>` : ""}`);
+  wire(test);
+  countUp();
+  if (focus) document.getElementById(focus)?.scrollIntoView({ block: "start" });
 }

mathly2/tests/test_behind_home_api.py

@@ -60,43 +60,3 @@ def test_the_path_and_the_home_agree_on_what_is_behind(world):
     path = client.get("/api/path", headers=auth()).json()
     assert {l["id"] for l in path["lessons"] if l["behind"]} == {r["id"] for r in behind(client)} == {"t", "t2"} and path["behind"] == 2
 
-
-def weak(client):
-    return client.get("/api/home", headers=auth()).json()["weak_tests"]
-
-
-def exercise(store, test, number, grade, when_offset=0):
-    row = store.create_attempt(KID_ID, "exercise_test", f"{test['id']}:{number}", MON, MON + timedelta(minutes=45), [])
-    store.save_attempt(row["id"], submitted_at=MON + timedelta(minutes=10 + when_offset), grade=grade)
-
-
-def test_practice_tests_below_87_are_listed_and_not_taken_or_good_ones_are_not(world):
-    client, store, bank = world
-    test = store.create_test(1, clock.school_day() + timedelta(days=10), ["t"], "t@x.test", created_at=clock.now() - timedelta(days=20))
-    assert weak(client) == []                                                                                    # none taken
-    exercise(store, test, 1, 25)
-    got = weak(client)
-    assert got == [{"test_id": test["id"], "date": test["date"].isoformat(), "days_left": 10, "number": 1, "best": 25, "open": False}]
-    exercise(store, test, 2, 87)                                                                                 # 13 of 15: good enough
-    assert [(w["number"], w["best"]) for w in weak(client)] == [(1, 25)]
-    exercise(store, test, 1, 86, 1)                                                                              # a retake still below: the best of the two
-    assert weak(client)[0]["best"] == 86
-    exercise(store, test, 1, 90, 2)
-    assert weak(client) == []                                                                                    # reached: no longer listed
-
-
-def test_a_past_test_is_not_listed(world):
-    client, store, bank = world
-    old = store.create_test(1, clock.school_day() - timedelta(days=3), ["t"], "t@x.test", created_at=clock.now() - timedelta(days=30))
-    exercise(store, old, 1, 10)
-    assert weak(client) == []
-
-
-def test_only_the_nearest_tests_weak_practice_tests_are_on_home(world):
-    client, store, bank = world
-    near = store.create_test(1, clock.school_day() + timedelta(days=4), ["t"], "t@x.test", created_at=clock.now() - timedelta(days=20))
-    far = store.create_test(1, clock.school_day() + timedelta(days=12), ["t2"], "t@x.test", created_at=clock.now() - timedelta(days=20))
-    exercise(store, far, 1, 10)
-    assert weak(client) == []                                                                                    # only the farther test has one
-    exercise(store, near, 2, 40)
-    assert [(w["test_id"], w["number"]) for w in weak(client)] == [(near["id"], 2)]

mathly2/tests/test_countdown.py

@@ -1,95 +0,0 @@
-"""The countdown plan and today's task (add-test-readiness 1.2)."""
-from datetime import date, timedelta
-
-from mathly2 import countdown as c
-
-TEST = date(2026, 11, 30)
-SET_LONG = TEST - timedelta(days=14)
-
-
-def facts(**kw):
-    base = {"path_done": False, "next_path_skill": "s1", "ex1_done": False, "ex2_done": False, "sim_taken": False,
-            "review_left": [], "stale": ["old", "older"]}
-    return {**base, **kw}
-
-
-def on(days_left, plan_for=SET_LONG, **kw):
-    return c.task(days_left, c.plan(TEST, plan_for), facts(**kw))
-
-
-def test_the_plan_for_two_weeks_has_the_prds_days():
-    assert c.plan(TEST, SET_LONG) == {"n": 14, "ex1": 9, "ex2": 7, "sim": 5, "review_from": 4}
-    assert c.plan(TEST, TEST - timedelta(days=9))["ex1"] == 9
-
-
-def test_twelve_days_ahead_the_plan_asks_to_finish_the_path():
-    assert on(12) == {"kind": "path", "skill": "s1"}
-    assert on(10) == {"kind": "path", "skill": "s1"}
-
-
-def test_nine_seven_and_five_days_ahead_are_exercise_test_1_2_and_the_simulation():
-    assert on(9, path_done=True) == {"kind": "ex1"}
-    assert on(8, path_done=True) == {"kind": "ex1"}
-    assert on(7, path_done=True, ex1_done=True) == {"kind": "ex2"}
-    assert on(5, path_done=True, ex1_done=True, ex2_done=True) == {"kind": "sim"}
-
-
-def test_the_recommended_step_comes_first_even_when_an_earlier_one_was_missed():
-    assert on(5) == {"kind": "sim"}                                  # exercise tests missed: the required simulation still comes first
-    assert on(7) == {"kind": "ex2"}
-
-
-def test_a_done_step_moves_to_the_next_one_early_but_never_to_a_closed_simulation():
-    assert on(12, path_done=True) == {"kind": "ex1"}                 # the path is done: exercise test 1 early
-    assert on(12, path_done=True, ex1_done=True) == {"kind": "ex2"}
-    assert on(10, path_done=True, ex1_done=True, ex2_done=True) == {"kind": "continue"}   # the simulation is not open yet
-    assert on(9, path_done=False, ex1_done=True) == {"kind": "ex2"}
-
-
-def test_after_the_simulation_the_last_days_review_a_failed_skill_and_the_day_before_is_mixed():
-    done = dict(path_done=True, ex1_done=True, ex2_done=True, sim_taken=True)
-    assert on(3, review_left=["f1", "f2"], **done) == {"kind": "review", "skill": "f1"}
-    assert on(2, review_left=["f2"], **done) == {"kind": "review", "skill": "f2"}
-    assert on(4, review_left=[], **done) == {"kind": "mixed_review", "skill": "old"}     # nothing failed is left: mixed review
-    assert on(1, review_left=["f2"], **done) == {"kind": "mixed_review", "skill": "old"}  # the day before is always the light mixed review
-    assert on(0, review_left=["f2"], **done) == {"kind": "continue"}
-
-
-def test_the_simulation_is_asked_for_in_the_last_days_if_it_was_not_taken():
-    assert on(4, path_done=True, ex1_done=True, ex2_done=True) == {"kind": "sim"}
-    assert on(0) == {"kind": "sim"}                                  # open until the test day
-
-
-def test_a_test_set_six_days_ahead_keeps_the_order_within_six_days():
-    p = c.plan(TEST, TEST - timedelta(days=6))
-    assert p == {"n": 6, "ex1": 6, "ex2": 5, "sim": 3, "review_from": 3}
-    days = [p["ex1"], p["ex2"], p["sim"]]
-    assert days == sorted(days, reverse=True) and p["ex1"] <= 6
-    sequence = [c.step_for(d, p) for d in range(6, 0, -1)]
-    assert sequence == ["ex1", "ex2", "ex2", "sim", "sim", "sim"]    # path, then ex1, ex2, simulation, then review (after the simulation)
-    after = {**facts(path_done=True, ex1_done=True, ex2_done=True, sim_taken=True, review_left=["f"])}
-    assert c.task(2, p, after) == {"kind": "review", "skill": "f"}
-
-
-def test_a_very_short_notice_keeps_every_step_startable_in_order():
-    p = c.plan(TEST, TEST - timedelta(days=2))
-    assert p["ex1"] >= p["ex2"] >= p["sim"] >= p["review_from"] >= 1
-    assert c.task(2, p, facts(path_done=True)) == {"kind": "ex1"}
-    assert c.task(2, p, facts(path_done=True, ex1_done=True)) == {"kind": "ex2"}
-
-
-def test_the_closest_test_gives_the_task():
-    soon = {"id": 1, "date": date(2026, 11, 14)}
-    later = {"id": 2, "date": date(2026, 11, 20)}
-    today = date(2026, 11, 10)
-    assert c.closest([later, soon], today)["id"] == 1                # tests in 4 and in 10 days: the one in 4
-    assert c.closest([{"id": 3, "date": date(2026, 11, 9)}], today) is None
-    assert c.closest([{"id": 4, "date": today}], today)["id"] == 4   # the test day itself is still upcoming
-    assert c.closest([], today) is None
-
-
-def test_the_outline_lists_the_steps_with_their_days_and_done_marks():
-    p = c.plan(TEST, SET_LONG)
-    steps = c.outline(p, facts(path_done=True, ex1_done=True, sim_taken=True, review_left=["x"]))
-    assert [(s["id"], s["done"]) for s in steps] == [("path", True), ("ex1", True), ("ex2", False), ("sim", True), ("review", False)]
-    assert [s["day"] for s in steps[1:]] == [9, 7, 5, 4]

mathly2/tests/test_home_browser.py

@@ -131,61 +131,8 @@ def test_with_no_test_home_shows_the_map_and_a_link_to_the_path(browser, bank):
         no_sideways_scroll(page)
 
 
-def test_nine_days_before_the_test_the_button_opens_exercise_test_1_with_the_readiness_bar(browser, bank):
-    app, store, klass, lessons = world(bank)
-    skills = covered(bank, lessons)
-    for i in skills[:6]:
-        store.save_progress(KID_ID, i, started_at="then", mastered_at="then")                            # M = 6 of 8
-    test = add_test(store, klass, lessons, 9)
-    with running(app) as url:
-        page = sign_in(browser, url)
-        to_home(page)
-        assert "בעוד 9 ימים" in page.inner_text("#nearest-test h2") and "מוכנות 75" in page.inner_text("#nearest-test")      # one strip on home
-        assert page.get_attribute("#today-task", "href") == f"#/exam/{test['id']}/1" and "מבחן תרגול 1" in page.inner_text("#today-task")
-        page.click("#nearest-test .strip-main")                                                                       # the bar is on the test's card
-        page.wait_for_selector("#test-card")
-        bar = page.locator("#test-card [role=progressbar]")
-        assert bar.get_attribute("aria-valuenow") == "75" and "75" in bar.get_attribute("aria-label")
-        part = lambda p: page.locator(f".rd-part[data-part={p}]")
-        assert part("M").inner_text().split() == ["שליטה", "אחוז", "המיומנויות", "שנשלטו", "75%"]
-        assert "מבחני תרגול" in part("E").inner_text() and "ממוצע הציונים הטובים ביותר" in part("E").inner_text() and part("E").locator(".rd-val").inner_text() == "—"
-        assert "סימולציה" in part("S").inner_text() and "הציון במבחן הסימולציה" in part("S").inner_text() and part("S").locator(".rd-val").inner_text() == "—"
-        assert not any(f" {letter} " in f" {page.inner_text('.rd-parts')} " for letter in "MES")                 # no letters
-        assert "עוד לא עשיתם מבחן סימולציה" in page.inner_text(".rd-note")
-        no_sideways_scroll(page)
-
-
-def test_four_days_before_the_test_the_simulation_is_required_on_home(browser, bank):
-    app, store, klass, lessons = world(bank)
-    test = add_test(store, klass, lessons, 4)
-    with running(app) as url:
-        page = sign_in(browser, url)
-        to_home(page)
-        required = page.locator(f".required[data-required='{test['id']}']")
-        assert required.count() == 1 and "חובה" in required.inner_text() and required.get_attribute("href") == f"#/sim/{test['id']}"
-        assert page.get_attribute("#today-task", "href") == f"#/sim/{test['id']}"
 
 
-def test_the_readiness_bar_shows_every_part_and_loses_the_cap_after_the_simulation(browser, bank):
-    app, store, klass, lessons = world(bank)
-    for i in covered(bank, lessons):
-        store.save_progress(KID_ID, i, started_at="then", mastered_at="then")
-    test = add_test(store, klass, lessons, 3)
-    now = clock.now()
-    for scope, kind, grade in ((f"{test['id']}:1", "exercise_test", 60), (f"{test['id']}:2", "exercise_test", 80), (str(test["id"]), "simulation", 90)):
-        row = store.create_attempt(KID_ID, kind, scope, now - timedelta(days=1), now - timedelta(days=1) + timedelta(minutes=45), [])
-        store.save_attempt(row["id"], submitted_at=now - timedelta(days=1) + timedelta(minutes=5), grade=grade)
-    with running(app) as url:
-        page = sign_in(browser, url)
-        to_home(page)
-        page.wait_for_selector("#nearest-test")
-        assert page.locator(".required").count() == 0                                                     # the simulation is taken
-        page.click("#nearest-test .strip-main")
-        page.wait_for_selector("#test-card .rd-part")
-        vals = {p: page.locator(f".rd-part[data-part={p}] .rd-val").inner_text() for p in "MES"}
-        assert vals == {"M": "100%", "E": "70", "S": "90"}
-        assert page.locator(".rd-note").count() == 0 and "מוכנים" in page.inner_text(".rd-label")
-
 
 def test_home_shows_only_the_closest_test_and_the_other_tests_are_on_its_card(browser, bank):
     app, store, klass, lessons = world(bank)
@@ -194,7 +141,7 @@ def test_home_shows_only_the_closest_test_and_the_other_tests_are_on_its_card(br
     with running(app) as url:
         page = sign_in(browser, url)
         to_home(page)
-        assert page.get_attribute("#nearest-test", "data-test") == str(near["id"]) and page.get_attribute("#today-task", "href") == f"#/exam/{near['id']}/1"
+        assert page.get_attribute("#nearest-test", "data-test") == str(near["id"]) and page.get_attribute("#home-sim", "href") == f"#/sim/{near['id']}"
         assert page.locator("#other-tests").count() == 0 and page.locator("#notifications").count() == 0                       # only what is critical
         page.click("#nearest-test .strip-main")
         page.wait_for_selector("#other-tests")
@@ -215,55 +162,7 @@ def finished(store, scope, kind, grade, questions=None, answers=None):
     return store.save_attempt(row["id"], submitted_at=now - timedelta(days=1) + timedelta(minutes=9), grade=grade, answers=answers or {})
 
 
-def test_a_fresh_card_shows_the_plan_the_exercise_tests_what_to_practise_first_and_when_the_simulation_opens(browser, bank):
-    app, store, klass, lessons = world(bank)
-    skills = covered(bank, lessons)
-    store.save_progress(KID_ID, skills[0], started_at="then", mastered_at="then")
-    test = add_test(store, klass, lessons, 14, questions=10, minutes=30)
-    with running(app) as url:
-        page = card_page(browser, url, test["id"])
-        assert "10 שאלות · 30 דקות" in page.inner_text("#test-card") and "בעוד 14 ימים" in page.inner_text("#test-card h2")
-        steps = page.locator("#plan li")
-        assert steps.count() == 5 and [steps.nth(i).get_attribute("data-step") for i in range(5)] == ["path", "ex1", "ex2", "sim", "review"]
-        assert "עד 9 ימים לפני" in steps.nth(0).inner_text() and "בערך 9 ימים לפני" in steps.nth(1).inner_text() and "בערך 5 ימים לפני" in steps.nth(3).inner_text()
-        assert page.locator("#plan li.done").count() == 0
-        assert page.locator("#exercises li").count() == 2 and "עוד לא נעשה" in page.inner_text("#exercises li >> nth=0")
-        assert page.get_attribute("#exercises li[data-exercise='2'] a", "href") == f"#/exam/{test['id']}/2" and "התחלה" in page.inner_text("#exercises li >> nth=1")
-        assert page.locator("#practice-first a").count() == 7                                           # eight covered skills, one started
-        assert "ייפתח ב־" in page.inner_text("#sim-closed") and page.locator("#sim-start").count() == 0
-        no_sideways_scroll(page)
-
-
-def test_exercise_tests_show_their_best_grade_and_offer_a_retake_or_to_continue(browser, bank):
-    app, store, klass, lessons = world(bank)
-    test = add_test(store, klass, lessons, 10)
-    finished(store, f"{test['id']}:1", "exercise_test", 55)
-    finished(store, f"{test['id']}:1", "exercise_test", 80)
-    now = clock.now()
-    store.create_attempt(KID_ID, "exercise_test", f"{test['id']}:2", now, now + timedelta(minutes=45), [])        # exercise test 2 is open
-    with running(app) as url:
-        page = card_page(browser, url, test["id"])
-        one, two = page.locator("#exercises li[data-exercise='1']"), page.locator("#exercises li[data-exercise='2']")
-        assert "הציון הטוב: 80" in one.inner_text() and "2 ניסיונות" in one.inner_text() and "שוב" in one.locator("a").inner_text()
-        assert "להמשיך" in two.locator("a").inner_text()
-        assert page.locator("#plan li[data-step='ex1'].done").count() == 1 and page.locator("#plan li[data-step='ex2'].done").count() == 0
-
 
-def test_an_open_simulation_is_required_and_a_taken_one_shows_its_grade_and_review_skills(browser, bank):
-    app, store, klass, lessons = world(bank)
-    skills = covered(bank, lessons)
-    test = add_test(store, klass, lessons, 4)
-    with running(app) as url:
-        page = card_page(browser, url, test["id"])
-        assert page.locator("#simulation .req").count() == 1 and page.get_attribute("#sim-start", "href") == f"#/sim/{test['id']}"
-        assert "התחלה" in page.inner_text("#sim-start")
-        questions = [{"skill_id": skills[0], "key": bank.question_keys(skills[0])[0]}, {"skill_id": skills[1], "key": bank.question_keys(skills[1])[0]}]
-        finished(store, str(test["id"]), "simulation", 0, questions=questions)                          # nothing answered: both skills failed
-        page.reload()
-        page.wait_for_selector("#simulation[data-taken='true']")
-        assert page.inner_text("#sim-grade") == "0" and page.locator("#sim-start").count() == 0
-        assert [a.get_attribute("href") for a in page.locator("#sim-review a").all()] == [f"#/skill/{skills[0]}", f"#/skill/{skills[1]}"]
-        assert page.locator("#plan li[data-step='sim'].done").count() == 1
 
 
 def test_a_test_of_another_class_or_a_missing_one_shows_an_error(browser, bank):
@@ -291,47 +190,22 @@ def test_an_exercise_test_runs_with_the_tests_length_and_no_timer_and_links_its_
         page = sign_in(browser, url, f"#/exam/{test['id']}/1")
         page.wait_for_selector("#qz-q")
         assert page.evaluate("location.hash").startswith(f"#/exam/{test['id']}/1/")                         # the address names the attempt
-        assert "מבחן תרגול 1" in page.inner_text(".mx-sheet") and page.locator(".qz-dot").count() == 6
+        assert "מבחן תרגול מאוזן" in page.inner_text(".mx-sheet") and page.locator(".qz-dot").count() == 6
         assert page.locator("#qz-timer").count() == 0                                                         # only the simulation is timed
         sheet = page.inner_text(".mx-sheet")
         assert not any(bank.skill(i)["name"] in sheet for i in skills)                                       # no skill names, no feedback
         page.click("#qz-submit")
         page.click("#qz-yes")
         page.wait_for_selector("#qz-grade")
-        assert page.inner_text("#qz-grade b") == "0" and "תוצאת מבחן תרגול 1" in page.inner_text(".mx-sheet")
+        assert page.inner_text("#qz-grade b") == "0" and "תוצאת מבחן תרגול מאוזן" in page.inner_text(".mx-sheet")
         links = [a.get_attribute("href") for a in page.locator("#qz-lost a").all()]
         assert links and all(h.startswith("#/skill/") and h[8:] in skills for h in links)                    # weak skills link to their stars
-        assert page.locator("#qz-retake").inner_text() == "מבחן חוזר"
-        page.click("#qz-retake")                                                                             # a retake is a new attempt
-        page.wait_for_selector("#qz-q")
-        assert len(store.attempts_of(KID_ID, "exercise_test", f"{test['id']}:1")) == 2
-        page.click(".mx-x")
+        assert "המוכנות נשארה 0" in page.inner_text("#qz-ready") and page.locator("#qz-retake").count() == 0
+        page.click(".qz-actions [data-close]")
         page.wait_for_selector("#test-card")                                                                 # closing leads back to the test's card
         assert page.evaluate("location.hash") == f"#/test/{test['id']}"
 
 
-def test_the_simulation_can_be_taken_once_and_a_second_visit_shows_the_result(browser, bank):
-    app, store, klass, lessons = world(bank)
-    started_skills(store, bank, lessons)
-    test = add_test(store, klass, lessons, 4, questions=6, minutes=45)
-    with running(app) as url:
-        page = sign_in(browser, url, f"#/sim/{test['id']}")
-        page.wait_for_selector("#qz-q")
-        assert "מבחן סימולציה" in page.inner_text(".mx-sheet") and page.locator(".qz-dot").count() == 6
-        assert page.inner_text("#qz-timer").startswith("44:") or page.inner_text("#qz-timer") == "45:00"        # the test's minutes
-        page.click("#qz-submit")
-        page.click("#qz-yes")
-        page.wait_for_selector("#qz-grade")
-        assert page.locator("#qz-retake").count() == 0 and "פעם אחת" in page.inner_text(".qz-result")
-        page.goto(url + f"#/sim/{test['id']}")                                                               # opening it again
-        page.reload()
-        page.wait_for_selector("#qz-grade")
-        assert page.inner_text("#qz-grade b") == "0" and page.locator("#qz-q").count() == 0
-        assert len(store.attempts_of(KID_ID, "simulation")) == 1
-        page.click(".qz-actions [data-close]")
-        page.wait_for_selector("#test-card")
-        assert page.inner_text("#sim-grade") == "0"
-
 
 def test_when_the_simulations_countdown_reaches_zero_it_is_handed_in_as_it_stands(browser, bank):
     from mathly2 import quiz
@@ -350,28 +224,6 @@ def test_when_the_simulations_countdown_reaches_zero_it_is_handed_in_as_it_stand
         assert page.inner_text("#qz-grade b") == "0" and "הזמן נגמר" in page.inner_text(".qz-result")
 
 
-def test_the_simulation_before_its_window_says_when_it_opens_and_does_not_start(browser, bank):
-    app, store, klass, lessons = world(bank)
-    started_skills(store, bank, lessons)
-    test = add_test(store, klass, lessons, 14)
-    with running(app) as url:
-        page = sign_in(browser, url, f"#/sim/{test['id']}")
-        page.wait_for_selector("[role=alert]")
-        assert "ייפתח" in page.inner_text("[role=alert]") and page.locator("#qz-q").count() == 0
-        assert store.attempts_of(KID_ID, "simulation") == []
-
-
-def test_the_simulation_with_nothing_practiced_offers_a_bypass_on_all_the_material(browser, bank):
-    app, store, klass, lessons = world(bank)
-    test = add_test(store, klass, lessons, 2, questions=6, minutes=45)                                     # two days left, nothing started
-    with running(app) as url:
-        page = sign_in(browser, url, f"#/sim/{test['id']}")
-        page.wait_for_selector("#sim-bypass")
-        assert "עוד לא התחלתם" in page.inner_text("[role=alert]") and store.attempts_of(KID_ID, "simulation") == []
-        page.click("#sim-bypass")
-        page.wait_for_selector("#qz-q")
-        assert "מבחן סימולציה" in page.inner_text(".mx-sheet") and page.locator(".qz-dot").count() == 6
-        assert len(store.attempts_of(KID_ID, "simulation")) == 1
 
 
 def test_after_the_simulation_the_wrong_questions_are_answered_again_in_a_round(browser, bank):
@@ -402,12 +254,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.check("#practice input[value='focus']")                                                     # the hard skills now have their own test
+        assert page.locator("#focus-skills .ex-chip").count() > 0
+        page.click("#practice-start")
         page.wait_for_selector("#qz-q")
-        assert "נושאים לחיזוק" in page.inner_text(".mx-sheet h3") and 0 < page.locator(".qz-dot").count() <= 15
+        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"]}
+        lost = {q["skill_id"] for q in store.attempts_of(KID_ID, "simulation")[0]["questions"]} | set(covered(bank, lessons)[:5])   # or still learning
         assert focus["scope"].endswith(":3") and {q["skill_id"] for q in focus["questions"]} <= lost and page.errors == []
 
 
@@ -427,8 +280,7 @@ def test_exercise_tests_and_the_simulation_appear_on_the_grades_screen(browser,
         page = sign_in(browser, url, "#/grades")
         page.wait_for_selector("#exercise-grades")
         one = page.locator(f"#exercise-grades li[data-test='{test['id']}'][data-number='1']")
-        assert one.locator(".gr-num").inner_text() == "80" and "2 ניסיונות" in one.inner_text() and "מבחן תרגול 1" in one.inner_text()
-        assert page.locator(f"#exercise-grades li[data-test='{test['id']}'][data-number='2'] .gr-num").inner_text() == "70"
+        assert one.locator(".gr-num").inner_text() == "80" and "3 ניסיונות" in one.inner_text() and "מבחן תרגול מאוזן" in one.inner_text()   # 1 and the old 2: balanced
         assert page.locator(f"#simulation-grades li[data-test='{test['id']}'] .gr-num").inner_text() == "65"
         gone = page.locator(f"#exercise-grades li[data-test='{removed['id']}']")
         assert gone.locator(".gr-num").inner_text() == "90" and "הוסר" in gone.inner_text()               # a removed test keeps its grade and name
@@ -505,7 +357,7 @@ def test_the_tab_shows_who_has_not_taken_the_simulation_and_each_students_readin
         assert "a@school.test" in missing and "b@school.test" in missing and KID not in missing
         assert page.locator(".readiness-table tbody tr").count() == 3
         mine = page.locator(f".readiness-table tr:has-text('{KID}')")
-        assert "28" in mine.inner_text() and "75" in mine.inner_text() and "0%" in mine.inner_text()        # M 0 and S 75: (30*75) / 80
+        assert "45 · " in mine.inner_text() and "1 · הטוב 75" in mine.inner_text()                           # one simulation of 75: 60% of the way
 
 
 def test_a_refused_test_shows_why_and_keeps_what_was_typed(browser, bank):
@@ -544,76 +396,71 @@ def answer_in_browser(page, bank, store, kind, scope, rights):
     return refs
 
 
-def test_the_whole_countdown_from_setting_a_test_to_the_review(browser, bank, monkeypatch):
+
+# --- readiness-tooltip: the number explains itself ---
+
+
+
+# --- readiness: the home's block, the test's page, practice tests by mode and simulations on request ---
+
+def test_home_shows_the_readiness_and_two_clear_buttons_that_raise_it(browser, bank):
     app, store, klass, lessons = world(bank)
-    moment = {"now": clock.now()}
-    monkeypatch.setattr(clock, "now", lambda: moment["now"])
-    advance = lambda days: moment.update(now=moment["now"] + timedelta(days=days))
-    skills = covered(bank, lessons)
+    test = add_test(store, klass, lessons, 2)
     with running(app) as url:
-        teacher = teacher_page(browser, url)                                                                   # the teacher sets a test 12 days ahead, 6 questions
-        teacher.click(".set-test summary")
-        teacher.fill("[name=date]", iso(12))
-        teacher.fill("[name=questions]", "6")
-        teacher.click(".set-test button[type=submit]")
-        teacher.wait_for_selector(".test-row")
-        test = store.tests_of_classes([klass["id"]])[0]
-        student = sign_in(browser, url)
-        to_home(student)
-        task = lambda: student.get_attribute("#today-task", "href")
-        reload_home = lambda: (student.goto(url + "#/subject/math"), student.reload(), student.wait_for_selector(".tabs"), student.wait_for_selector("#today-task"))
-
-        def on_card(read):                                                                                      # the readiness is on the test's card
-            student.click("#nearest-test .strip-main")
-            student.wait_for_selector("#test-card .rd-part")
-            got = read()
-            reload_home()
-            return got
-
-        assert task() == f"#/skill/{skills[0]}" and "לסיים את המסלול" in student.inner_text("#today-task")        # 12 days: finish the path
-        assert "סימולציה" in on_card(lambda: student.inner_text(".rd-note"))                                     # the bar says it is capped until the simulation
-        for i in skills:                                                                                        # the path is finished
-            store.save_progress(KID_ID, i, started_at="then", mastered_at="then")
-        reload_home()
-        assert task() == f"#/exam/{test['id']}/1"                                                               # next: exercise test 1, early
-        student.click("#today-task")
-        answer_in_browser(student, bank, store, "exercise_test", f"{test['id']}:1", [True] * 6)
-        assert student.inner_text("#qz-grade b") == "100"
-        advance(3)                                                                                              # 9 days left
-        reload_home()
-        assert task() == f"#/exam/{test['id']}/2"                                                               # exercise test 2
-        student.click("#today-task")
-        answer_in_browser(student, bank, store, "exercise_test", f"{test['id']}:2", [True] * 6)
-        advance(4)                                                                                              # 5 days left: the simulation opens
-        reload_home()
-        assert task() == f"#/sim/{test['id']}" and student.locator(f".required[data-required='{test['id']}']").count() == 1
-        vals = lambda: {p: student.locator(f".rd-part[data-part={p}] .rd-val").inner_text() for p in "MES"}
-        got = on_card(vals)
-        assert got["E"] == "100" and got["S"] == "—"
-        student.click("#today-task")
-        answer_in_browser(student, bank, store, "simulation", str(test["id"]), [True, True, True, True, False, False])
-        assert student.inner_text("#qz-grade b") == "67"
-        failed = [a.get_attribute("href") for a in student.locator("#qz-lost a").all()]
-        assert failed
-        advance(2)                                                                                              # 3 days left: review what failed
-        reload_home()
-        assert task() in failed and student.locator(".required").count() == 0                                   # a failed skill is today's review
-        assert on_card(lambda: (vals()["S"], student.locator(".rd-note").count())) == ("67", 0)          # the cap is gone after the simulation
-        teacher.reload()
-        teacher.click("#teacher-tabs [data-tab='tests']")
-        teacher.wait_for_selector(".test-row")
-        assert "1 מתוך 1 עשו סימולציה" in teacher.inner_text(".sim-count")
+        page = sign_in(browser, url)
+        to_home(page)
+        strip = page.locator("#nearest-test")
+        assert "מבחן בעוד 2 ימים" in strip.inner_text() and "מוכנות למבחן" in strip.inner_text()
+        assert strip.locator(".rd-num").inner_text() == "0" and "מתחילים" in strip.inner_text() and 'עוד 40 לרמה "בדרך"' in strip.inner_text()
+        assert page.get_attribute("#nearest-test .strip-main", "href") == f"#/test/{test['id']}"
+        assert "מבחן תרגול" in page.inner_text("#home-practice") and "+30" in page.inner_text("#home-practice") and "+60" in page.inner_text("#home-sim")
+        assert page.get_attribute("#home-practice", "href") == f"#/test/{test['id']}/practice"
+        page.click("#home-practice")                                                                # straight to choosing a practice test
+        page.wait_for_selector("#practice .modes")
+        assert page.evaluate("document.getElementById('practice').getBoundingClientRect().top") < 200
+        no_sideways_scroll(page)
 
 
-# --- readiness-tooltip: the number explains itself ---
+def test_a_simulation_on_request_raises_readiness_with_a_level_up_and_another_can_follow(browser, bank):
+    app, store, klass, lessons = world(bank)
+    test = add_test(store, klass, lessons, 30, questions=4, minutes=20)                                 # a month ahead: no window
+    with running(app) as url:
+        page = sign_in(browser, url)
+        to_home(page)
+        page.click("#home-sim")
+        page.wait_for_selector("#qz-timer")
+        assert "מבחן סימולציה" in page.inner_text(".mx-sheet") and page.locator(".qz-dot").count() == 4
+        answer_in_browser(page, bank, store, "simulation", str(test["id"]), [True] * 4)
+        page.wait_for_selector("#qz-ready.up")
+        assert page.inner_text(".qz-gain") == "+60" and "עלתה ל־60" in page.inner_text("#qz-ready") and "רמה חדשה: בדרך" in page.inner_text("#qz-ready")
+        page.wait_for_function("document.querySelector('#qz-ready .rd-bar i').style.width === '60%'")   # the bar grows to the new number
+        page.click("#qz-more-sim")                                                                   # another one, on request
+        page.wait_for_selector("#qz-timer")
+        assert len(store.attempts_of(KID_ID, "simulation")) == 2 and page.errors == []
+
 
-def test_the_tooltip_is_on_the_tests_card_too_and_opens_on_hover_with_a_mouse(browser, bank):
+def test_the_tests_page_has_three_practice_modes_and_the_trail_of_gains(browser, bank):
     app, store, klass, lessons = world(bank)
-    test = add_test(store, klass, lessons, 7)
+    skills = covered(bank, lessons)
+    test = add_test(store, klass, lessons, 10, questions=4)
+    finished(store, f"{test['id']}:1", "exercise_test", 50)
     with running(app) as url:
-        page = sign_in(browser, url, f"#/test/{test['id']}")
-        to_home_card = page.wait_for_selector("[data-info]")
-        page.hover("[data-info]")
-        assert page.locator(".tip").first.is_visible() and "50%" in page.locator(".tip").first.inner_text()
-        page.mouse.move(5, 5)
-        assert page.locator(".tip").first.is_hidden()
+        page = card_page(browser, url, test["id"])
+        page.wait_for_function("document.querySelector('#test-card .rd-num').textContent === '15'")
+        assert [m.get_attribute("data-mode") for m in page.locator("#practice .mode").all()] == ["balanced", "focus", "manual"]
+        assert page.locator("#practice input[value='focus']").is_disabled()                          # nothing hard yet (no questions in that one)
+        assert "+15" in page.inner_text("#trail") and "מבחן תרגול מאוזן" in page.inner_text("#trail")
+        page.check("#practice input[value='manual']")
+        assert page.locator("#manual-skills").is_visible() and page.locator("#manual-skills input").count() == len(skills)
+        page.click("#practice-start")
+        assert "בחרו לפחות" in page.inner_text("#practice-error")
+        page.check(f"#manual-skills input[value='{skills[0]}']")
+        page.click("#practice-start")
+        page.wait_for_selector("#qz-q")
+        row = store.attempts_of(KID_ID, "exercise_test", f"{test['id']}:4")[0]
+        assert "מבחן תרגול בבחירה" in page.inner_text(".mx-sheet h3") and {q["skill_id"] for q in row["questions"]} == {skills[0]}
+        page.click(".mx-x")
+        page.wait_for_selector("#practice")
+        page.click("#rd-how summary")
+        assert "סימולציה סוגר 60%" in page.inner_text("#rd-how") and page.errors == []
+        no_sideways_scroll(page)

mathly2/tests/test_lesson_map_browser.py

@@ -67,7 +67,7 @@ def test_home_is_a_map_of_the_lessons_with_stars_and_a_play_button(browser, bank
         first, late = page.locator(f".lnode[data-lesson='{lessons[0]}']"), page.locator(f".lnode[data-lesson='{lessons[2]}']")
         assert first.get_attribute("data-stars") == "3" and "👑" in first.text_content()
         assert "⏰" in late.text_content()
-        assert page.locator("#stars-count").inner_text() == f"⭐ 3 מתוך {3 * len(lessons)}"
+        assert page.locator("#stars-count").inner_text() == f"⭐ 3/{3 * len(lessons)}"
         assert page.locator("#play").get_attribute("href") == f"#/round/{lessons[2]}"            # the behind lesson comes first
         assert page.locator(".lnode.next").get_attribute("data-lesson") == lessons[2]
         assert page.locator(".tabs a").nth(1).inner_text() == "העמקה" and page.locator("#behind-card").count() == 0
@@ -131,7 +131,7 @@ def test_home_is_one_screen_with_every_lesson_a_test_and_an_assignment(browser,
         to_home(page)
         page.wait_for_selector("#lesson-map")
         page.wait_for_selector("#assignments")
-        assert page.locator(".lnode").count() == len(lessons) and page.locator("#nearest-test #today-task").count() == 1
+        assert page.locator(".lnode").count() == len(lessons) and page.locator("#nearest-test #home-sim").count() == 1
         assert page.evaluate("document.documentElement.scrollHeight <= window.innerHeight")                    # nothing to scroll
         no_sideways_scroll(page)
         shot(page, "home-one-screen")

mathly2/tests/test_permissions.py

@@ -57,6 +57,7 @@ NEEDS = {   # (method, path) -> permission
     ("POST", "/api/attempts/{attempt_id}/retry/start"): "path.use",
     ("POST", "/api/tests/{test_id}/exercise/{number}/start"): "path.use",
     ("POST", "/api/tests/{test_id}/simulation/start"): "path.use",
+    ("POST", "/api/tests/{test_id}/practice/start"): "path.use",
     ("GET", "/api/tests/{test_id}"): "path.use",
     ("GET", "/api/lessons/{lesson_id}/quiz"): "path.use",
     ("POST", "/api/lessons/{lesson_id}/quiz/start"): "path.use",

mathly2/tests/test_readiness.py

@@ -1,44 +1,30 @@
-"""The readiness number (add-test-readiness 1.3)."""
-import pytest
-
+"""The readiness number: only tests move it, only up, a simulation more than a practice test, a picked one less."""
 from mathly2 import readiness
 
 
-def test_only_mastery_so_far_gives_that_percent():
-    got = readiness.compute(60, None, None)
-    assert got["number"] == 60 and got["capped"] is False and got["parts"] == {"M": 60, "E": None, "S": None}
-
-
-def test_all_three_parts_are_weighted_50_20_30():
-    assert readiness.compute(80, 70, 90)["number"] == 81
-    assert readiness.compute(100, 100, 100)["number"] == 100 and readiness.compute(0, 0, 0)["number"] == 0
-
-
-def test_a_missing_part_is_left_out_and_the_others_are_scaled_up():
-    assert readiness.compute(80, 60, None)["number"] == 74           # (50*80 + 20*60) / 70, rounded
-    assert readiness.compute(50, None, 70)["number"] == 58           # (50*50 + 30*70) / 80
-    assert readiness.compute(None, None, 40)["number"] == 40
-
-
-def test_before_the_simulation_the_number_is_capped_at_80_and_says_so():
-    got = readiness.compute(100, 95, None)
-    assert got["number"] == 80 and got["capped"] is True and got["waiting_for_simulation"] is True
-    assert readiness.compute(100, 95, 100)["number"] == 99 and readiness.compute(100, 95, 100)["waiting_for_simulation"] is False
-    assert readiness.compute(79, None, None)["capped"] is False
+def test_nothing_taken_is_zero_and_a_good_test_pulls_it_toward_its_grade():
+    assert readiness.compute([])["number"] == 0
+    assert readiness.compute([("practice", 80)])["number"] == 24                     # 30% of the way to 80
+    assert readiness.compute([("simulation", 80)])["number"] == 48                   # 60%: a simulation counts more
+    assert readiness.compute([("manual", 80)])["number"] == 12                       # 15%: the student picked the skills
 
 
-def test_labels_at_their_edges():
-    for number, name in ((0, "מתחילים"), (39, "מתחילים"), (40, "בדרך"), (69, "בדרך"), (70, "כמעט שם"), (84, "כמעט שם"), (85, "מוכנים"), (100, "מוכנים")):
-        assert readiness.label(number) == name
+def test_a_grade_below_the_number_never_lowers_it_and_the_number_never_passes_the_grades():
+    up = readiness.compute([("simulation", 90), ("simulation", 90)])["number"]
+    assert up == 76 and readiness.compute([("simulation", 90), ("simulation", 90), ("practice", 30)])["number"] == up
+    many = readiness.compute([("simulation", 90)] * 20)["number"]
+    assert many == 90
 
 
-@pytest.mark.parametrize("m,e", [(100, 100), (100, 0), (90, 95), (85, 85)])
-def test_ready_never_shows_without_the_simulation(m, e):
-    assert readiness.compute(m, e, None)["label"] != "מוכנים"
-    assert readiness.compute(100, 100, 100)["label"] == "מוכנים"
+def test_levels_next_level_and_what_a_perfect_test_would_add():
+    r = readiness.compute([("practice", 100)])
+    assert r["number"] == 30 and r["label"] == "מתחילים" and r["next"] == {"at": 40, "name": "בדרך", "left": 10}
+    assert r["can_add"] == {"simulation": 42, "practice": 21, "manual": 11}
+    assert readiness.compute([("simulation", 100)] * 5)["next"] is None
+    assert r["practices"] == 1 and r["simulations"] == 0 and r["practice_best"] == 100 and r["simulation_best"] is None
 
 
-def test_nothing_known_is_zero_and_the_parts_helpers():
-    assert readiness.compute(None, None, None)["number"] == 0
-    assert readiness.mastery_percent(3, 4) == 75 and readiness.mastery_percent(0, 0) is None
-    assert readiness.exercise_average([60, 80]) == 70 and readiness.exercise_average([]) is None
+def test_change_says_the_gain_and_a_new_level():
+    moved = readiness.change([("practice", 100)], ("simulation", 90))
+    assert moved == {**moved, "before": 30, "after": 66, "gain": 36, "label": "בדרך", "level_up": True}
+    assert readiness.change([("simulation", 90)], ("practice", 20))["gain"] == 0

mathly2/tests/test_realtests_api.py

@@ -143,7 +143,7 @@ def test_the_tests_tab_shows_who_took_the_simulation_and_names_those_who_did_not
     assert listed["simulation"]["taken"] == 22 and listed["simulation"]["total"] == 25
     assert sorted(listed["simulation"]["missing"]) == sorted([KID, KID2, "s22@school.test"])
     taken = next(s for s in listed["students"] if s["email"] == "s0@school.test")
-    assert taken["simulation_taken"] is True and taken["readiness"]["parts"]["S"] == 70
+    assert taken["simulation_taken"] is True and taken["readiness"]["simulation_best"] == 70 and taken["readiness"]["number"] == 42
     assert [c["class"]["name"] for c in tab] == ["A"] and tab[0]["class"]["lessons"]
 
 
@@ -166,77 +166,10 @@ def finished(store, test_id, kind, scope, grade, who=KID, questions=None):
 def test_with_no_test_home_has_only_the_next_skill(world):
     client, _, _ = world
     home = client.get("/api/home", headers=auth(KID)).json()
-    assert home["tests"] == [] and home["task"] is None and home["required_simulations"] == []
+    assert home["tests"] == [] and "task" not in home
     assert home["next_skill"]["id"] and home["next_skill"]["name"]
 
 
-def test_nine_days_before_the_test_todays_task_is_exercise_test_1(world):
-    client, _, lessons = world
-    test = set_test(client, lessons, days=9).json()
-    home = client.get("/api/home", headers=auth(KID)).json()
-    assert home["task"]["kind"] == "ex1" and home["task"]["test_id"] == test["id"]
-    assert home["tests"][0]["days_left"] == 9 and home["tests"][0]["exercise_tests"][0]["best"] is None
-
-
-def test_twelve_days_ahead_the_task_is_finishing_the_path_with_the_next_covered_skill(world):
-    client, _, lessons = world
-    set_test(client, lessons, days=12)
-    task = client.get("/api/home", headers=auth(KID)).json()["task"]
-    assert task["kind"] == "path" and task["skill"] and task["skill_name"]
-
-
-def test_four_days_before_the_simulation_is_required_until_it_is_taken(world):
-    client, store, lessons = world
-    set_test_ = set_test(client, lessons, days=14).json()
-    client.set_time(MON + 10 * DAY)                                          # four days left
-    home = client.get("/api/home", headers=auth(KID)).json()
-    assert home["task"]["kind"] == "sim" and [r["test_id"] for r in home["required_simulations"]] == [set_test_["id"]]
-    assert home["tests"][0]["simulation"]["required"] is True and home["tests"][0]["simulation"]["open_now"] is True
-    finished(store, set_test_["id"], "simulation", str(set_test_["id"]), 70)
-    home = client.get("/api/home", headers=auth(KID)).json()
-    assert home["required_simulations"] == [] and home["tests"][0]["simulation"]["taken"] is True and home["tests"][0]["simulation"]["grade"] == 70
-
-
-def test_two_tests_give_the_task_of_the_closer_one(world):
-    client, _, lessons = world
-    far = set_test(client, lessons, days=10).json()
-    near = set_test(client, lessons, days=4).json()
-    home = client.get("/api/home", headers=auth(KID)).json()
-    assert [t["id"] for t in home["tests"]] == [near["id"], far["id"]]
-    assert home["task"]["test_id"] == near["id"] and home["task"]["kind"] == "ex1"       # set 4 days ahead: the short plan starts with exercise test 1 today
-
-
-def test_readiness_shows_the_parts_that_exist_and_caps_before_the_simulation(world):
-    client, store, lessons = world
-    test = set_test(client, lessons, days=14).json()
-    skills = covered(client.app.state.bank, lessons[:2])
-    master(store, skills[:6])                                                # M = 6 of 8 = 75
-    home = client.get("/api/home", headers=auth(KID)).json()["tests"][0]["readiness"]
-    assert home["number"] == 75 and home["parts"] == {"M": 75, "E": None, "S": None} and home["waiting_for_simulation"] is True
-    finished(store, test["id"], "exercise_test", f"{test['id']}:1", 60)
-    finished(store, test["id"], "exercise_test", f"{test['id']}:2", 80)
-    ready = client.get("/api/home", headers=auth(KID)).json()["tests"][0]["readiness"]
-    assert ready["parts"] == {"M": 75, "E": 70, "S": None} and ready["number"] == 74       # (50*75 + 20*70) / 70
-    master(store, skills[6:])
-    finished(store, test["id"], "simulation", str(test["id"]), 90)
-    full = client.get("/api/home", headers=auth(KID)).json()["tests"][0]["readiness"]
-    assert full["parts"] == {"M": 100, "E": 70, "S": 90} and full["number"] == 91 and full["capped"] is False and full["label"] == "מוכנים"
-
-
-def test_the_card_has_the_plan_the_exercise_tests_and_what_to_practise_first(world):
-    client, store, lessons = world
-    test = set_test(client, lessons, days=14).json()
-    skills = covered(client.app.state.bank, lessons[:2])
-    master(store, skills[:2])
-    store.save_progress(uid(KID), skills[2], started_at="then")              # learning; the other five are not started
-    card = client.get(f"/api/tests/{test['id']}", headers=auth(KID)).json()
-    assert [s["id"] for s in card["plan"]] == ["path", "ex1", "ex2", "sim", "review"] and card["plan"][1]["day"] == 9
-    assert [e["number"] for e in card["exercise_tests"]] == [1, 2] and card["questions"] == 12 and card["minutes"] == 45
-    assert [s["id"] for s in card["practice_first"]] == skills[3:] and all(s["name"] for s in card["practice_first"])
-    sim = card["simulation"]
-    assert sim["open_now"] is False and sim["opens_in_days"] == 9 and sim["opens_on"] == (clock.now() + 9 * DAY).date().isoformat() and sim["taken"] is False
-
-
 def test_a_student_of_another_class_and_a_missing_test_give_404(world):
     client, store, lessons = world
     test = set_test(client, lessons).json()
@@ -310,24 +243,6 @@ def test_an_exercise_test_can_start_early_and_resumes_while_open(world):
     assert start_ex(client, test["id"], 2).json()["id"] != first["id"]        # exercise test 2 is its own attempt
 
 
-def test_a_retake_draws_new_questions_and_the_best_grade_counts(world):
-    client, store, lessons = world
-    test = set_test(client, lessons, days=14, questions=6).json()
-    started(client, store, lessons)
-    first = start_ex(client, test["id"]).json()
-    keys = {q["key"] for q in first["questions"]}
-    low = answer_all(client, client.app.state.bank, first, [True, True, False, False, False, False])
-    assert low["grade"] == 33 and low["kind"] == "exercise_test"
-    second = start_ex(client, test["id"]).json()
-    assert second["id"] != first["id"] and not keys & {q["key"] for q in second["questions"]}
-    high = answer_all(client, client.app.state.bank, second, [True] * 6)
-    assert high["grade"] == 100
-    card = client.get(f"/api/tests/{test['id']}", headers=auth(KID)).json()
-    assert card["exercise_tests"][0]["best"] == 100 and card["exercise_tests"][0]["attempts"] == 2
-    answer_all(client, client.app.state.bank, start_ex(client, test["id"]).json(), [False] * 6)       # a worse third try
-    assert client.get(f"/api/tests/{test['id']}", headers=auth(KID)).json()["exercise_tests"][0]["best"] == 100
-
-
 def test_the_result_links_the_weak_skills_found_without_right_answers(world):
     client, store, lessons = world
     test = set_test(client, lessons, days=14, questions=6).json()
@@ -344,75 +259,6 @@ def test_an_exercise_test_with_nothing_started_draws_all_the_material_and_a_weak
     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):
-    client, store, lessons = world
-    test = set_test(client, lessons, days=14, questions=6).json()
-    got = client.post(f"/api/tests/{test['id']}/exercise/1/start?all_skills=true", headers=auth(KID))
-    assert got.status_code == 200 and len(got.json()["questions"]) == 6
-    bank, lessons_of_test = client.app.state.bank, set(lessons[:2])
-    assert all(bank.skill(q["skill_id"])["unit"] in lessons_of_test for q in store.get_attempt(got.json()["id"])["questions"])
-
-
-def test_the_simulation_is_refused_8_days_before_with_its_opening_date(world):
-    client, store, lessons = world
-    test = set_test(client, lessons, days=14).json()
-    started(client, store, lessons)
-    client.set_time(MON + 6 * DAY)                                            # 8 days left; it opens 5 days before the test
-    early = start_sim(client, test["id"])
-    assert early.status_code == 409 and "ייפתח" in early.json()["detail"]
-    assert store.attempts_of(uid(KID), "simulation") == []                    # nothing was started
-
-
-def test_the_simulation_with_nothing_started_is_refused_and_all_skills_is_the_bypass(world):
-    client, store, lessons = world
-    test = set_test(client, lessons, days=14).json()
-    client.set_time(MON + 12 * DAY)                                           # two days left: open, and nothing practiced
-    refused = start_sim(client, test["id"])
-    assert refused.status_code == 409 and "עוד לא התחלתם" in refused.json()["detail"]
-    got = client.post(f"/api/tests/{test['id']}/simulation/start?all_skills=true", headers=auth(KID))
-    assert got.status_code == 200 and got.json()["kind"] == "simulation" and len(got.json()["questions"]) == 12
-    assert start_sim(client, test["id"]).json()["id"] == got.json()["id"]     # then it resumes like any simulation
-
-
-def test_the_simulation_has_the_tests_length_can_be_taken_once_and_shows_its_result_again(world):
-    client, store, lessons = world
-    test = set_test(client, lessons, days=14).json()                          # 12 questions, 45 minutes
-    started(client, store, lessons)
-    client.set_time(MON + 10 * DAY)                                           # four days left: open
-    sim = start_sim(client, test["id"]).json()
-    assert sim["kind"] == "simulation" and len(sim["questions"]) == 12
-    assert datetime.fromisoformat(sim["due_at"]) - datetime.fromisoformat(sim["now"]) == timedelta(minutes=45)
-    assert start_sim(client, test["id"]).json()["id"] == sim["id"]            # open: it resumes
-    done = answer_all(client, client.app.state.bank, sim, [True] * 8 + [False] * 4)
-    assert done["grade"] == 67
-    again = start_sim(client, test["id"]).json()
-    assert again["state"] == "submitted" and again["id"] == sim["id"] and again["grade"] == 67      # a second try shows the result
-    assert len(store.attempts_of(uid(KID), "simulation")) == 1
-
-
-def test_the_skills_the_simulation_failed_are_the_review_tasks_of_the_last_days(world):
-    client, store, lessons = world
-    test = set_test(client, lessons, days=14).json()
-    started(client, store, lessons)
-    client.set_time(MON + 10 * DAY)
-    sim = start_sim(client, test["id"]).json()
-    result = answer_all(client, client.app.state.bank, sim, [False] * 12)
-    failed = [s["id"] for s in result["lost_skills"]]
-    assert failed
-    client.set_time(MON + 11 * DAY)                                           # three days left
-    card = client.get(f"/api/tests/{test['id']}", headers=auth(KID)).json()
-    assert [s["id"] for s in card["simulation"]["review"]] == failed and card["simulation"]["taken"] is True
-    task = client.get("/api/home", headers=auth(KID)).json()["task"]
-    assert task["kind"] == "review" and task["skill"] == failed[0] and task["skill_name"]
-    # practising that skill after the simulation takes it off the list: the next failed one is the task
-    store.add_answer(uid(KID), failed[0], "k", True, True, None, clock.school_day())
-    after = client.get("/api/home", headers=auth(KID)).json()["task"]
-    if len(failed) > 1:
-        assert after["kind"] == "review" and after["skill"] == failed[1]
-    else:
-        assert after["kind"] == "mixed_review"
-
-
 # --- 2.4 the grades ---
 
 def test_the_grades_list_each_tests_best_exercise_grades_and_the_simulation(world):
@@ -423,11 +269,11 @@ def test_the_grades_list_each_tests_best_exercise_grades_and_the_simulation(worl
     bank = client.app.state.bank
     answer_all(client, bank, start_ex(client, test["id"]).json(), [True] * 3 + [False] * 3)                  # 50
     answer_all(client, bank, start_ex(client, test["id"]).json(), [True] * 5 + [False])                      # 83
-    answer_all(client, bank, start_ex(client, test["id"], 2).json(), [True] * 6)                             # 100
+    answer_all(client, bank, start_ex(client, test["id"], 3).json(), [True] * 6)                             # 6 of 15: 40, the focus mode
     client.set_time(MON + 10 * DAY)
     answer_all(client, bank, start_sim(client, test["id"]).json(), [True] * 3 + [False] * 3)                  # 50 (6 questions)
     got = client.get("/api/grades", headers=auth(KID)).json()
-    assert [(g["number"], g["best"], g["attempts"]) for g in got["exercise_tests"]] == [(1, 83, 2), (2, 100, 1)]
+    assert [(g["title"], g["best"], g["attempts"]) for g in got["exercise_tests"]] == [("מבחן תרגול מאוזן", 83, 2), ("מבחן תרגול ממוקד", 40, 1)]
     assert [(g["best"], g["attempts"]) for g in got["simulations"]] == [(50, 1)]
     assert got["exercise_tests"][0]["test"]["id"] == test["id"] and got["exercise_tests"][0]["test"]["lessons"] and got["quizzes"] == []
 
@@ -490,24 +336,99 @@ def test_a_test_with_no_mistakes_has_nothing_to_retry(world):
     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):
+
+# --- readiness, practice tests by mode and simulations on demand ---
+
+def practice(client, test_id, mode, skills=None, who=KID):
+    return client.post(f"/api/tests/{test_id}/practice/start", json={"mode": mode, "skills": skills or []}, headers=auth(who))
+
+
+def card_of(client, test_id, who=KID):
+    return client.get(f"/api/tests/{test_id}", headers=auth(who)).json()
+
+
+def test_readiness_moves_only_with_tests_never_with_the_path(world):
+    client, store, lessons = world
+    test = set_test(client, lessons, days=14).json()
+    master(store, covered(client.app.state.bank, lessons[:2]))                       # the whole material mastered on the path
+    ready = card_of(client, test["id"])["readiness"]
+    assert ready["number"] == 0 and ready["label"] == "מתחילים" and ready["can_add"]["simulation"] == 60
+    finished(store, test["id"], "exercise_test", f"{test['id']}:1", 80)
+    assert card_of(client, test["id"])["readiness"]["number"] == 24
+    finished(store, test["id"], "simulation", str(test["id"]), 90)
+    ready = card_of(client, test["id"])["readiness"]
+    assert ready["number"] == 64 and ready["practice_best"] == 80 and ready["simulation_best"] == 90 and ready["simulations"] == 1
+
+
+def test_the_card_offers_three_practice_modes_simulations_and_the_trail_of_gains(world):
+    client, store, lessons = world
+    test = set_test(client, lessons, days=14).json()
+    card = card_of(client, test["id"])
+    assert set(card["practice"]) == {"balanced", "focus", "manual"} and card["practice"]["focus"]["skills"] == []
+    assert len(card["practice"]["manual"]["skills"]) == len(covered(client.app.state.bank, lessons[:2])) and card["simulation"]["taken"] == 0
+    assert "plan" not in card and "task" not in card and card["trail"] == []
+    finished(store, test["id"], "exercise_test", f"{test['id']}:1", 50)
+    finished(store, test["id"], "simulation", str(test["id"]), 10)                  # below the number after the first: no gain
+    trail = card_of(client, test["id"])["trail"]
+    assert [(t["kind"], t["gain"]) for t in trail] == [("simulation", 0), ("exercise_test", 15)] and trail[1]["title"] == "מבחן תרגול מאוזן"
+
+
+def test_a_balanced_practice_test_draws_all_the_material_even_unstarted_and_resumes(world):
+    client, store, lessons = world
+    test = set_test(client, lessons, days=14, questions=6).json()
+    first = practice(client, test["id"], "balanced")
+    assert first.status_code == 200 and len(first.json()["questions"]) == 6 and first.json()["test"]["mode"] == "balanced"
+    assert practice(client, test["id"], "balanced").json()["id"] == first.json()["id"]
+    assert card_of(client, test["id"])["practice"]["balanced"]["open"] == first.json()["id"]
+
+
+def test_a_manual_practice_test_has_only_the_picked_skills_and_moves_readiness_less(world):
+    client, store, lessons = world
+    bank = client.app.state.bank
+    test = set_test(client, lessons, days=14, questions=6).json()
+    picked = covered(bank, lessons[:2])[:2]
+    got = practice(client, test["id"], "manual", picked + ["not-a-skill"])
+    assert got.status_code == 200 and {q["skill_id"] for q in store.get_attempt(got.json()["id"])["questions"]} <= set(picked)
+    assert practice(client, test["id"], "manual", []).status_code == 422
+    done = answer_all(client, bank, got.json(), [True] * 6)
+    assert done["readiness"] == {**done["readiness"], "before": 0, "after": 15, "gain": 15}     # 15% of the gap, a balanced one 30%
+
+
+def test_a_focus_practice_test_is_15_questions_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()
+    assert practice(client, test["id"], "focus").status_code == 409                   # nothing weak yet
+    sim = client.post(f"/api/tests/{test['id']}/simulation/start", 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
+    assert {s["id"] for s in card_of(client, test["id"])["practice"]["focus"]["skills"]} == lost
+    focus = practice(client, test["id"], "focus").json()
+    rows = store.get_attempt(focus["id"])["questions"]
+    assert len(rows) == 15 and {q["skill_id"] for q in rows} <= lost and len({q["key"] for q in rows}) == 15
+    assert focus["test"]["title"] == "מבחן תרגול ממוקד"
+
+
+def test_simulations_are_on_demand_timed_all_the_material_and_count_more(world):
+    client, store, lessons = world
+    bank = client.app.state.bank
+    test = set_test(client, lessons, days=30).json()                                  # a month ahead: still open
+    sim = client.post(f"/api/tests/{test['id']}/simulation/start", headers=auth(KID)).json()
+    assert sim["kind"] == "simulation" and len(sim["questions"]) == 12
+    assert datetime.fromisoformat(sim["due_at"]) - datetime.fromisoformat(sim["now"]) == timedelta(minutes=45)
+    assert client.post(f"/api/tests/{test['id']}/simulation/start", headers=auth(KID)).json()["id"] == sim["id"]    # open: resumes
+    done = answer_all(client, bank, sim, [True] * 12)
+    assert done["readiness"] == {**done["readiness"], "before": 0, "after": 60, "gain": 60, "level_up": True}
+    second = client.post(f"/api/tests/{test['id']}/simulation/start", headers=auth(KID)).json()
+    assert second["id"] != sim["id"] and second["state"] == "open"                   # another one on request
+    assert not {q["key"] for q in sim["questions"]} & {q["key"] for q in second["questions"]} or len(covered(bank, lessons[:2])) < 12
+    card = card_of(client, test["id"])
+    assert card["simulation"]["open"] == second["id"] and card["simulation"]["taken"] == 1 and card["simulation"]["best"] == 100
+
+
+def test_old_practice_addresses_still_start_a_balanced_or_focus_test(world):
+    client, store, lessons = world
+    test = set_test(client, lessons, days=14, questions=6).json()
+    assert start_ex(client, test["id"], 1).json()["test"]["mode"] == "balanced"
+    assert start_ex(client, test["id"], 2).json()["test"]["mode"] == "balanced"
+    assert start_ex(client, test["id"], 4).status_code == 404 and start_ex(client, test["id"], 9).status_code == 404

openspec/changes/board-work/proposal.md

@@ -9,7 +9,7 @@ Multiple-choice answers show only the final answer. The teacher (and the parent)
 - **The board is saved with every answer**: practice, lesson rounds, lesson quizzes, exercise tests and the simulation. A picture of the question's board goes to the server when the student answers (and again before handing in if it changed). An empty board sends nothing. One picture is kept per student, attempt (or practice) and question.
 - **In quizzes and tests the way is required**: a choice is refused until something is written on the board for that question (or a board for it is already saved), with a prompt and a button that opens the board. Practice and lesson rounds stay free.
 - **The teacher grades the way**: a "בדיקת דרך" tab lists the handed-in quizzes and tests of the teacher's students (not checked first). Opening one shows every question with its choices (the right one marked), the student's choice and board, and points buttons: automatic, 0, ½, full. Saving recomputes the grade (in halves), so a lesson quiz can become passed or not. The tab counts the attempts not checked yet.
-- **An AI review of the way in tests**: after a practice test or the simulation is handed in, Gemini (a free-tier model, `GEMINI_MODEL`, default `gemini-2.5-flash`) gets all its boards in one request and writes, per question, a verdict and a short feedback line and tip in Hebrew that never reveal the right answer. The student sees it on the result ("משוב על הדרך"); the teacher sees it beside each board as a suggestion. Without `GEMINI_API_KEY` there is none.
+- **An AI review of the way in tests**: after a practice test or the simulation is handed in, Gemini (a free-tier model, `GEMINI_MODEL`, default `gemini-2.5-flash`) gets each board in its own request (paced for the free tier, a summary at the end) and writes, per question, a verdict and a short feedback line and tip in Hebrew that never reveal the right answer. The student sees it on the result ("משוב על הדרך"); the teacher sees it beside each board as a suggestion. Without `GEMINI_API_KEY` there is none.
 - Work pictures are private: the student and the teachers of the student's classes (and developers) read them. They follow the answer pictures' retention (removed after the school year) and a replaced one is cleaned up as an orphan.
 
 ## Capabilities

openspec/changes/tests-on-demand/proposal.md

@@ -0,0 +1,44 @@
+# Proposal
+
+## Why
+
+A student two days before a real test was blocked. The plan of two numbered exercise tests and one simulation opened on certain days and could be taken once. The readiness number mixed in mastery of the path, so the student could not tell which action would raise it. On the home screen it was not clear that tapping the test strip leads to the tests.
+
+The readiness number should be the one thing the app pushes the student to raise, and the student should always have a test to take.
+
+## What Changes
+
+- **Tests on request.** The student asks for:
+  - a **simulation**: all the test's material, its length and time, no choice, as many as they like (an open one resumes);
+  - a **practice test** in one of three modes:
+    - *balanced*: all the material evenly;
+    - *focused*: 15 questions from the skills that lost points in this test's tests, or are still being learned;
+    - *manual*: the skills the student picks.
+  
+  There are no windows, no one-time rule and no "start the skills first" refusal. Every test draws from the whole material, unstarted skills included.
+- **Readiness moves only with tests, never with the path or deepening.** Each handed-in test pulls the number toward its grade, and only up:
+
+  `number += GAIN × (grade − number)` when the grade is above the number.
+
+  GAIN is 0.6 for a simulation, 0.3 for a practice test and 0.15 for a manual one (picked skills can skip the hard ones). Levels: מתחילים, בדרך (40), כמעט שם (70), מוכנים (85).
+- **Making the number feel like a game:**
+  - The home block and the test page show the level and the points to the next level.
+  - The number counts up from the last visit with a "+N" badge.
+  - Each button shows the most it can add now ("+30", "+60").
+  - A result opens with the gain (big "+N", the bar growing, "🎉 רמה חדשה"), and buttons for another simulation or practice test.
+  - The test page lists every test handed in with what it added.
+- **Home:** one compact block with the number, the level and the days left (a link to the test's page), a thin bar, and two buttons, **📝 מבחן תרגול** and **⏱ מבחן סימולציה**. The countdown plan, today's task, the "required simulation" chip and the weak practice tests list are gone. The home still fits one screen.
+- **Teacher:** the tests tab and the progress tab show readiness, how many practice tests and simulations were taken, and the best grade of each. Mastery is shown beside readiness, not inside it.
+
+## Capabilities
+
+### Modified Capabilities
+- `real-tests`: on-demand practice tests (3 modes) and simulations; readiness from tests only.
+- `student-home`: the test block with two buttons.
+
+## Impact
+
+- `readiness.py` (rewritten), `realtests.py` (facts, card, starting tests; new `POST /api/tests/{id}/practice/start`), `exam.py` (modes), `quizzes.py` (a result's `readiness` change; grades by mode), `progress.py`, `boardwork.py` (titles).
+- `countdown.py` and its tests are removed.
+- Frontend: `home.js`, `testcard.js`, `quiz.js`, `student.js` (`#/test/<id>/practice`), `teacher.js`, `teacher_progress.js`, `grades.js`, `app.css`.
+- No database change. Old attempts keep counting: exercise tests 1 and 2 are balanced practice tests, 3 is focused.

openspec/changes/tests-on-demand/specs/real-tests/spec.md

@@ -0,0 +1,27 @@
+## MODIFIED Requirements
+
+### Requirement: Practice tests and simulations on request
+A student SHALL be able to request, for any coming test of their class, at any time:
+- a simulation with all the test's material, its question count and its time limit;
+- a practice test in a mode they choose: balanced, focused (on skills that lost points or are still being learned) or manual (on skills they pick).
+
+An open test of the same kind and mode SHALL resume. A manual test SHALL always be new.
+
+#### Scenario: A simulation two days before the test with nothing practised
+- **WHEN** a student who has started no skill asks for a simulation
+- **THEN** a timed simulation of the test's length starts, drawn from all the material
+
+#### Scenario: A focused practice test with nothing weak
+- **WHEN** no skill lost points and none is being learned
+- **THEN** the focused mode is offered as unavailable, and asking for it is refused with a message
+
+### Requirement: Readiness from tests only
+The readiness number SHALL change only when a practice test or a simulation is handed in. For each one, oldest first, when its grade is above the number, the number SHALL become `number + GAIN × (grade − number)`, with GAIN 0.6 for a simulation, 0.3 for a practice test and 0.15 for a manual one. Mastery of skills SHALL NOT change it.
+
+#### Scenario: A simulation counts more
+- **WHEN** a student with readiness 0 hands in a simulation with 80
+- **THEN** the readiness is 48, where a practice test with 80 would make it 24
+
+#### Scenario: A bad grade never lowers it
+- **WHEN** a student with readiness 76 hands in a practice test with 30
+- **THEN** the readiness stays 76

openspec/changes/tests-on-demand/tasks.md

@@ -0,0 +1,16 @@
+## 1. Server
+- [x] 1.1 `readiness.py`: tests-only number with GAIN per kind, levels, next level, what a perfect test adds, a test's change
+- [x] 1.2 `realtests.py`: facts from all practice tests and simulations; the card's practice modes, simulations and trail; remove the plan and today's task
+- [x] 1.3 `POST /api/tests/{id}/practice/start` (balanced, focus, manual); simulations on request; old `/exercise/{n}/start` kept
+- [x] 1.4 A result carries its readiness change; grades grouped by mode; teacher tabs show counts and bests
+- [x] 1.5 Remove `countdown.py`
+
+## 2. Screens
+- [x] 2.1 Home: one compact block with the number, the level, the days left and two buttons with "+N"; still one screen
+- [x] 2.2 Test page: the readiness meter and how it goes up, simulation on request, practice test with the three modes, the trail of gains
+- [x] 2.3 Result: the gain, the bar growing, a new level, buttons for the next test
+- [x] 2.4 Teacher tests tab and progress tab
+
+## 3. Tests
+- [x] 3.1 Readiness unit tests; API tests for modes, simulations on demand, readiness change, grades
+- [x] 3.2 Browser tests: home block, simulation with a level up, test page modes and trail; home fits one screen