feat: implement lesson rounds with instant feedback and star system

- Added a new lesson round feature that presents 10 questions from a lesson's skills, providing instant feedback for each answer.
- Implemented a star rating system based on performance in the lesson round, with conditions for earning 0 to 3 stars.
- Updated the home interface to display a map of lessons, showing progress and allowing easy access to the next lesson.
- Created database migration to accommodate the new lesson round functionality.
- Developed comprehensive tests for the lesson rounds and their integration with the home interface.

docs/tasks/prd-mathly.md

@@ -400,9 +400,10 @@ The exercise screen is where a student practices one skill.
 
 ### 4.16 Student screens (STU)
 
-A tab bar at the bottom of the screen leads between them: home, path, submissions (STU-7), grades, collection and review (STU-8).
+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** shows only what is critical: the nearest test's reminder with its readiness, today's task (TST-3) and **its practice tests below the pass line** (taken and with a best grade below 87, i.e. 13 of 15: each a button to take it again with the best grade as a chip inside it; one not taken yet, or at 87 or more, is not listed; other tests' practice tests are on their own cards), a required simulation, **every lesson behind the curriculum** (PTH-11; earliest date first, each kept short: its name, its date, a link named just "בוחן" with the best grade as a chip inside the link, a bare number or "-" when there is none; PTH-10), the **new** assignments (המשימות שלי: not handed in yet), and a button that continues the path at the next skill; my AI requests and their state (AI-1).
+- **STU-1 Home** is a game board. On top: the stars collected (three per lesson), the lessons perfected, the daily goal and streak, and 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). Below it, a **map of the lessons** on a winding trail: each lesson a node with its number (a crown when perfect), its name, its stars (★ a lesson round finished, ★★ a round with 8 of 10 or more, ★★★ every skill of the lesson mastered), "⏰" when it is behind the curriculum (PTH-11) and "◐" when a round is open. Tapping a node opens the lesson's round (STU-9). Then the nearest test's reminder with its readiness, today's task (TST-3) and its practice tests below the pass line (taken and with a best grade below 87, i.e. 13 of 15, each a button to take it again with the best grade as a chip inside it), a required simulation, the **new** assignments (המשימות שלי: not handed in yet), my AI requests and their state (AI-1), and a link to the path for going deeper ("להעמקה").
+- **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-2 Path:** see 4.4.
 - **STU-3 Grades:** all quiz (best grade), exercise test, simulation and assignment grades.
 - **STU-4 Collection:** see MST-7.

mathly2/main.py

@@ -15,7 +15,7 @@ from .access import RoleResolver, learner, permissions_of
 from .auth import DevAuthenticator, SupabaseAuthenticator, current_user
 from .bank import Bank, load_bank
 
-from . import accounts, ai, ai_help, assignments, classes, cleanup, content, progress, quizzes, reads, realtests, review, skills, status, subjects, worksheets, written
+from . import accounts, ai, ai_help, assignments, classes, cleanup, content, progress, quizzes, reads, realtests, review, rounds, skills, status, subjects, worksheets, written
 from .config import Settings, load_settings
 from .cached import CachedStore
 from .store import InMemoryStore, StoreUnavailable, SupabaseStore
@@ -83,6 +83,7 @@ def create_app(settings: Settings | None = None, bank: Bank | None = None, store
     app.include_router(classes.curriculum)
     app.include_router(accounts.router)
     app.include_router(skills.router)
+    app.include_router(rounds.router)
     app.include_router(quizzes.router)
     app.include_router(realtests.router)
     app.include_router(progress.router)

mathly2/quiz.py

@@ -7,12 +7,14 @@ from . import attempts
 from .attempts import QUIZ_SIZE
 
 
-def draw(bank, lesson_id: str, used: dict[str, int] | None = None, rng: random.Random | None = None, size: int = QUIZ_SIZE) -> list[dict]:
+def draw(bank, lesson_id: str, used: dict[str, int] | None = None, rng: random.Random | None = None, size: int = QUIZ_SIZE,
+         skill_ids: set[str] | None = None) -> list[dict]:
     """[{skill_id, key}] in a shuffled order. Skills without questions are left out. Each skill gets `size // k` questions and the
     remainder goes to distinct skills picked at random, so quotas differ by at most one. Within a skill the least-used questions come
-    first (`used`: how often the student had each question key in earlier quizzes of this lesson), ties in random order."""
+    first (`used`: how often the student had each question key in earlier quizzes of this lesson), ties in random order. `skill_ids`: draw
+    only from these skills of the lesson (a lesson round leaves out the mastered ones)."""
     used, rng = used or {}, rng or random.Random()
-    skills = [s for s in bank.skills if s["unit"] == lesson_id and bank.question_keys(s["id"])]
+    skills = [s for s in bank.skills if s["unit"] == lesson_id and bank.question_keys(s["id"]) and (skill_ids is None or s["id"] in skill_ids)]
     if not skills:
         return []
     quota = {s["id"]: size // len(skills) for s in skills}

mathly2/realtests.py

@@ -274,9 +274,10 @@ def home(request: Request, user: dict = Depends(learner), subject: str = Query("
     the required simulation, 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 .skills import RECENT, behind_lessons, subject_param
+    from . import rounds
+    from .skills import RECENT, behind_lessons, lesson_map, subject_param
     subject = subject_param(request, user, subject)
-    here.prefetch(("tests_of_classes", class_ids), ("recent_skills", uid, RECENT), ("attempts_of", uid, "quiz"), ("curriculum",), *_student_reads(uid))       # the tests and the student's facts: one wait
+    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
@@ -285,7 +286,7 @@ def home(request: Request, user: dict = Depends(learner), subject: str = Query("
     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"]],
             "next_skill": {"id": next_id, "name": next_skill_row["name"]} if next_skill_row else None,
-            "behind": behind_lessons(request, user, subject), "subject": subject,
+            "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
 

mathly2/rounds.py

@@ -0,0 +1,210 @@
+"""Lesson rounds (סבב שיעור): a short round of a lesson's skills with instant feedback, played from the home's map.
+
+A round is an m2_attempts row of kind `lesson_round` (scope: the lesson id). It draws from the lesson's skills that are not mastered, at most
+PER_SKILL questions from each and ROUND_SIZE in all, so it gets shorter as the lesson fills up; a lesson whose skills are all mastered draws
+ROUND_SIZE from all of them. The questions are answered in order, each once, and every answer is also a practice answer of its skill (it counts
+for mastery and the daily goal; a wrong one goes to the review list). After the last answer the round is graded and closed.
+
+A lesson's stars: 3 when every skill is mastered, else 2 when a finished round had at least TWO_STARS percent right, else 1 when a round was
+finished, else 0. Nothing here ever says which choice was right."""
+from __future__ import annotations
+
+import logging
+from collections import Counter
+from datetime import datetime, timedelta
+
+from fastapi import APIRouter, Depends, HTTPException, Request
+from pydantic import BaseModel
+
+from . import attempts, clock, quiz, reads
+from .access import learner
+from .learning import MASTERED, record_practice_answer, skill_state
+
+log = logging.getLogger("mathly2.rounds")
+router = APIRouter(prefix="/api")
+
+KIND = "lesson_round"
+ROUND_SIZE = 10
+PER_SKILL = 3          # three right in a row is what mastery needs, so a skill never takes more of a round
+TWO_STARS = 80         # percent right in a finished round for the second star
+
+
+class RoundAnswer(BaseModel):
+    key: str
+    choice: int
+
+
+def stars(skill_states: list[str], best: int | None) -> int:
+    """The lesson's stars from its skills' states and the best grade of its finished rounds (None: no round finished)."""
+    if skill_states and all(s == MASTERED for s in skill_states):
+        return 3
+    if best is None:
+        return 0
+    return 2 if best >= TWO_STARS else 1
+
+
+def facts(rows: list[dict]) -> dict[str, dict]:
+    """Per lesson with rounds: {best, finished, open} from the student's round attempts (oldest first)."""
+    found: dict[str, dict] = {}
+    for row in rows:
+        item = found.setdefault(row["scope"], {"best": None, "finished": 0, "open": None})
+        if attempts.is_open(row):
+            item["open"] = row["id"]
+        else:
+            item["finished"] += 1
+            item["best"] = row["grade"] if item["best"] is None else max(item["best"], row["grade"])
+    return found
+
+
+def draw(bank, lesson_id: str, states: dict[str, str], used: dict[str, int] | None = None, rng=None) -> list[dict]:
+    """The questions of a new round: from the skills not mastered (all of them when every one is), the least-used first."""
+    skills = [s["id"] for s in bank.skills if s["unit"] == lesson_id and bank.question_keys(s["id"])]
+    left = {s for s in skills if states.get(s) != MASTERED}
+    if not left:
+        return quiz.draw(bank, lesson_id, used, rng, size=ROUND_SIZE)
+    return quiz.draw(bank, lesson_id, used, rng, size=min(ROUND_SIZE, PER_SKILL * len(left)), skill_ids=left)
+
+
+def _lesson(request: Request, user: dict, lesson_id: str) -> dict:
+    from .skills import visible_lesson_ids
+    lesson = next((l for l in request.app.state.bank.lessons if l["id"] == lesson_id), None)
+    shown = visible_lesson_ids(request, user)
+    if lesson is None or (shown is not None and lesson_id not in shown):
+        raise HTTPException(404, "השיעור לא נמצא")
+    return lesson
+
+
+def _graded(bank, row: dict) -> list[tuple[dict, bool, dict | None]]:
+    """The answered questions in order: (question ref, right, mistake)."""
+    out = []
+    for q in row["questions"]:
+        choice = row["answers"].get(q["key"])
+        if not isinstance(choice, int):
+            break
+        graded = bank.grade(q["skill_id"], q["key"], choice) or {"correct": False, "mistake": None}
+        out.append((q, graded["correct"], graded["mistake"]))
+    return out
+
+
+def _when(value) -> datetime | None:
+    if value is None or isinstance(value, datetime):
+        return value
+    return datetime.fromisoformat(str(value).replace("Z", "+00:00"))
+
+
+def _lesson_stars(request: Request, uid: str, lesson_id: str, rows: list[dict]) -> int:
+    bank, store = request.app.state.bank, request.app.state.store
+    states = {p["skill_id"]: skill_state(p) for p in store.progress_of(uid)}
+    lesson_skills = [s["id"] for s in bank.skills if s["unit"] == lesson_id]
+    return stars([states.get(s, "not_started") for s in lesson_skills], facts(rows).get(lesson_id, {}).get("best"))
+
+
+def view(request: Request, row: dict) -> dict:
+    """An open round: its size, a result per answered question and the next question (without the right answer). A finished round: its result."""
+    bank, store = request.app.state.bank, request.app.state.store
+    lesson = next((l for l in bank.lessons if l["id"] == row["scope"]), {"id": row["scope"], "name": row["scope"]})
+    done = _graded(bank, row)
+    base = {"id": row["id"], "lesson": {"id": lesson["id"], "name": lesson["name"]}, "subject_id": lesson.get("subject_id", "math"), "total": len(row["questions"]),
+            "results": [right for _, right, _ in done]}
+    if attempts.is_open(row):
+        nxt = row["questions"][len(done)] if len(done) < len(row["questions"]) else None
+        served = bank.practice_question(nxt["skill_id"], nxt["key"]) if nxt else None
+        return {**base, "state": "open", "question": {**served, "skill_name": bank.skill(nxt["skill_id"])["name"]} if served else None}
+    uid = row["user_id"]
+    progress = {p["skill_id"]: p for p in store.progress_of(uid)}
+    started = _when(row["started_at"])
+    by_skill: dict[str, list[bool]] = {}
+    for q, right, _ in done:
+        by_skill.setdefault(q["skill_id"], []).append(right)
+    mastered, almost = [], []
+    for skill_id, results in by_skill.items():
+        p, skill = progress.get(skill_id), bank.skill(skill_id)
+        if skill is None:
+            continue
+        item = {"id": skill_id, "name": skill["name"]}
+        if p and p.get("mastered_at"):
+            if started and _when(p["mastered_at"]) >= started:
+                mastered.append(item)
+        elif len(results) >= 2 and all(results):
+            almost.append(item)                                   # right in a row today: one more good answer on another day masters it
+    missed = []
+    for q, right, mistake in done:
+        if right:
+            continue
+        served = bank.practice_question(q["skill_id"], q["key"])
+        missed.append({"question": served["question"] if served else "", "skill_name": (bank.skill(q["skill_id"]) or {}).get("name", ""),
+                       "mistake": {"name": mistake["name"], "tip": mistake["tip"]} if mistake else None})
+    all_rows = store.attempts_of(uid, KIND, row["scope"])
+    return {**base, "state": "done", "question": None,
+            "result": {"right": sum(base["results"]), "total": base["total"], "grade": row["grade"], "stars": _lesson_stars(request, uid, row["scope"], all_rows),
+                       "mastered": mastered, "almost": almost, "missed": missed}}
+
+
+def _mine(request: Request, user: dict, round_id: str) -> dict:
+    row = request.app.state.store.get_attempt(round_id)
+    if row is None or row["user_id"] != user["id"] or row["kind"] != KIND:
+        raise HTTPException(404, "הסבב לא נמצא")
+    return row
+
+
+@router.post("/lessons/{lesson_id}/round/start")
+def start(lesson_id: str, request: Request, user: dict = Depends(learner)) -> dict:
+    """Resume the lesson's open round, else draw a new one."""
+    _lesson(request, user, lesson_id)
+    store, bank, here, uid = request.app.state.store, request.app.state.bank, reads.of(request), user["id"]
+    here.prefetch(("attempts_of", uid, KIND, lesson_id), ("progress_of", uid))
+    mine = here.attempts_of(uid, KIND, lesson_id)
+    for row in mine:
+        if attempts.is_open(row):
+            return view(request, row)
+    states = {p["skill_id"]: skill_state(p) for p in here.progress_of(uid)}
+    used = Counter(q["key"] for row in mine for q in row["questions"])
+    drawn = draw(bank, lesson_id, states, used, getattr(request.app.state, "quiz_rng", None))
+    if not drawn:
+        raise HTTPException(409, "אין עדיין שאלות בשיעור הזה")
+    now = clock.now()
+    row = store.create_attempt(uid, KIND, lesson_id, now, now + timedelta(days=365), drawn)    # untimed: the due date is never used
+    return view(request, row)
+
+
+@router.get("/rounds/{round_id}")
+def read(round_id: str, request: Request, user: dict = Depends(learner)) -> dict:
+    return view(request, _mine(request, user, round_id))
+
+
+@router.post("/rounds/{round_id}/answer")
+def answer(round_id: str, body: RoundAnswer, request: Request, user: dict = Depends(learner)) -> dict:
+    """Grade the next question of the round at once; store it as a practice answer; close the round after its last question."""
+    store, bank, uid = request.app.state.store, request.app.state.bank, user["id"]
+    row = _mine(request, user, round_id)
+    if not attempts.is_open(row):
+        raise HTTPException(409, "הסבב כבר הסתיים")
+    answered = len(_graded(bank, row))
+    expected = row["questions"][answered] if answered < len(row["questions"]) else None
+    if expected is None or expected["key"] != body.key:
+        raise HTTPException(409, "השאלה הזו כבר לא על המסך")
+    graded = bank.grade(expected["skill_id"], body.key, body.choice)
+    if graded is None:
+        raise HTTPException(422, "תשובה לא חוקית")
+    saved = store.save_open_answers(row["id"], {**row["answers"], body.key: body.choice})
+    if saved is None:
+        raise HTTPException(409, "הסבב כבר הסתיים")
+    skill_id, correct, mistake = expected["skill_id"], graded["correct"], graded["mistake"]
+    before = store.get_progress(uid, skill_id)
+    progress = record_practice_answer(store, uid, skill_id, body.key, correct, True, mistake["id"] if mistake else None,
+                                      clock.school_day(), clock.now().isoformat())
+    mastered_now = not (before or {}).get("mastered_at") and bool(progress.get("mastered_at"))
+    if not correct:
+        try:
+            store.add_review(uid, [(skill_id, body.key, "practice")], clock.now())
+        except Exception as exc:                                              # bookkeeping never fails an answer
+            log.warning("could not add a wrong round answer to the review list: %s", type(exc).__name__)
+    if len(saved["answers"]) >= len(saved["questions"]):
+        right = sum(1 for _, r, _ in _graded(bank, saved) if r)
+        saved = store.save_attempt(saved["id"], submitted_at=clock.now(), timed_out=False,
+                                   grade=attempts.percent(right, len(saved["questions"])), answers=saved["answers"])
+    if mistake and mistake.get("back"):
+        back = bank.skill(mistake["back"])
+        mistake = {**mistake, "back_name": back["name"] if back else None}
+    return {"correct": correct, "mistake": mistake, "mastered_now": {"id": skill_id, "name": bank.skill(skill_id)["name"]} if mastered_now else None,
+            "round": view(request, saved)}

mathly2/skills.py

@@ -8,7 +8,7 @@ import logging
 from fastapi import Query, APIRouter, Depends, HTTPException, Request
 from pydantic import BaseModel
 
-from . import attempts, clock, comets, quiz, reads
+from . import attempts, clock, comets, quiz, reads, rounds
 from .access import learner
 from .learning import (DAILY_GOAL, MASTERED, current_round, is_faded, is_mastered, last_counted, next_in_round, next_skill, skill_state, streak,
                        today_progress)
@@ -225,8 +225,9 @@ def lesson_rows(request: Request, user: dict, subject: str = "math") -> tuple[li
     """The student's lessons with their skills' states, whether each is completed (all skills mastered or its quiz passed) and behind the curriculum,
     and its quiz state. Shared by the path and the home. Returns (lessons, the skills in the bank's order, the skill states)."""
     store, here, uid = request.app.state.store, reads.of(request), user["id"]
-    here.prefetch(("progress_of", uid), ("last_answered", uid), ("attempts_of", uid, "quiz"), ("curriculum",))
+    here.prefetch(("progress_of", uid), ("last_answered", uid), ("attempts_of", uid, "quiz"), ("attempts_of", uid, rounds.KIND), ("curriculum",))
     states = {p["skill_id"]: skill_state(p) for p in here.progress_of(uid)}
+    round_facts = rounds.facts(here.attempts_of(uid, rounds.KIND))
     last, today = here.last_answered(uid), clock.school_day()
     quizzes_facts = quiz.facts(store, request.app.state.bank, uid, clock.now(), here)
     shown, dates = visible_lesson_ids(request, user), here.curriculum()
@@ -246,10 +247,29 @@ def lesson_rows(request: Request, user: dict, subject: str = "math") -> tuple[li
         lessons.append({"id": lesson["id"], "name": lesson["name"], "skills": skills, "mastered": mastered,
                         "completed": completed, "passed": passed, "due_date": due.isoformat() if due else None,
                         "behind": bool(due and due < today and not completed),
+                        "stars": rounds.stars([sk["state"] for sk in skills], round_facts.get(lesson["id"], {}).get("best")),
+                        "round_open": bool(round_facts.get(lesson["id"], {}).get("open")),
                         "quiz": {"best": fact.get("best"), "open": bool(fact.get("open")), "due_at": fact["open"]["due_at"].isoformat() if fact.get("open") and fact["open"]["due_at"] else None}})
     return lessons, order, states
 
 
+def lesson_map(request: Request, user: dict, subject: str = "math") -> dict:
+    """The home's map: every lesson with its stars, the next lesson to play, the stars collected and the daily goal with the streak.
+    The next lesson: the one with an open round, else the earliest behind the curriculum, else the first with fewer than three stars."""
+    here, uid, today = reads.of(request), user["id"], clock.school_day()
+    lessons, _, _ = lesson_rows(request, user, subject)
+    playable = [l for l in lessons if l["skills"]]
+    rows = [{"id": l["id"], "name": l["name"], "number": i + 1, "stars": l["stars"], "mastered": l["mastered"], "total": len(l["skills"]),
+             "completed": l["completed"], "behind": l["behind"], "due_date": l["due_date"], "round_open": l["round_open"]}
+            for i, l in enumerate(playable)]
+    behind = sorted((r for r in rows if r["behind"]), key=lambda r: (r["due_date"], r["number"]))
+    nxt = (next((r for r in rows if r["round_open"]), None) or (behind[0] if behind else None)
+           or next((r for r in rows if r["stars"] < 3), None))
+    daily = here.daily_correct(uid)
+    return {"lessons": rows, "next": nxt["id"] if nxt else None, "stars": sum(r["stars"] for r in rows), "max_stars": 3 * len(rows),
+            "perfect": sum(1 for r in rows if r["stars"] == 3), "today": today_progress(daily, today), "streak": streak(daily, today)}
+
+
 def behind_lessons(request: Request, user: dict, subject: str = "math") -> list[dict]:
     """The lessons behind the curriculum for the home, the earliest date first: each with its quiz (the best grade so far and what passes it)."""
     lessons, _, _ = lesson_rows(request, user, subject)
@@ -275,7 +295,8 @@ def subject_param(request: Request, user: dict, subject: str) -> str:
 def path(request: Request, user: dict = Depends(learner), subject: str = Query("math", max_length=40)) -> dict:
     here, uid = reads.of(request), user["id"]
     subject = subject_param(request, user, subject)
-    here.prefetch(("progress_of", uid), ("last_answered", uid), ("daily_correct", uid), ("recent_skills", uid, RECENT), ("attempts_of", uid, "quiz"), ("curriculum",))
+    here.prefetch(("progress_of", uid), ("last_answered", uid), ("daily_correct", uid), ("recent_skills", uid, RECENT), ("attempts_of", uid, "quiz"),
+                  ("attempts_of", uid, rounds.KIND), ("curriculum",))
     lessons, order, states = lesson_rows(request, user, subject)
     today = clock.school_day()
     daily = here.daily_correct(uid)

mathly2/static/app.css

@@ -314,7 +314,7 @@ ul.grades .bar, ul.grades .muted { grid-column: 1 / -1; }
 /* The student's tab bar sits at the bottom of the screen, above the page and below the sheets */
 .tabs { position: fixed; inset-inline: 0; bottom: 0; z-index: 40; margin: 0; gap: 4px; padding: 6px 8px calc(6px + env(safe-area-inset-bottom, 0px));
   background: var(--surface); border-top: 1px solid var(--line); }
-.tabs a { min-height: 44px; display: grid; place-items: center; border: 0; border-radius: 10px; font-weight: 600; font-size: 14px; padding-inline: 2px; min-width: 0; }
+.tabs a { min-height: 44px; display: grid; place-items: center; border: 0; border-radius: 10px; font-weight: 600; font-size: 14px; padding-inline: 2px; min-width: 44px; flex: 1 1 auto; }
 body:has(.tabs) main { padding-bottom: calc(76px + env(safe-area-inset-bottom, 0px)); }
 
 /* Home */
@@ -593,3 +593,59 @@ ul.students li [dir="ltr"] { overflow-wrap: anywhere; min-width: 0; }
 .le-mistake input { flex: 1 1 140px; width: auto; }
 .le-status { margin: 8px 0; padding: 10px 12px; border-radius: 10px; border: 1px solid var(--line); }
 .st-facts dd.st-title { font-weight: 400; font-size: 14px; color: var(--muted); margin-top: 4px; }
+
+/* ---------- home: the lessons map (game-home-lesson-rounds) ---------- */
+.quest { position: relative; margin-block: 12px; padding: 16px; border-radius: 20px; border: 1px solid color-mix(in srgb, var(--sky-gold) 45%, var(--line));
+  background: radial-gradient(120% 90% at 100% 0%, color-mix(in srgb, var(--sky-accent) 30%, transparent), transparent 60%),
+              radial-gradient(90% 80% at 0% 100%, color-mix(in srgb, var(--sky-aurora) 18%, transparent), transparent 70%), var(--surface); }
+.quest-top { display: flex; align-items: center; gap: 12px; }
+.quest h2 { margin: 0; font-size: 22px; }
+.quest-stats { display: flex; flex-wrap: wrap; gap: 6px; margin: 4px 0 0; }
+.quest-stats span { font-size: 14px; font-weight: 700; padding: 2px 10px; border-radius: 999px; background: color-mix(in srgb, var(--sky-night) 70%, transparent); border: 1px solid var(--line); }
+.quest .goal { margin-block: 12px; }
+.play { display: flex; align-items: center; gap: 12px; min-height: 64px; padding: 12px 16px; border-radius: 18px; text-decoration: none; color: var(--sky-on-accent);
+  background: linear-gradient(135deg, var(--sky-gold), #ffb347); box-shadow: 0 6px 0 #c9852a, 0 10px 24px rgb(0 0 0 / .35); font-size: 18px; }
+.play:active { transform: translateY(4px); box-shadow: 0 2px 0 #c9852a; }
+.play:focus-visible { outline: 3px solid var(--sky-ink); outline-offset: 3px; }
+.play small { display: block; font-size: 13px; font-weight: 600; opacity: .8; }
+.play b { display: block; line-height: 1.25; }
+.play .play-icon { display: grid; place-items: center; width: 44px; height: 44px; border-radius: 50%; background: var(--sky-on-accent); color: var(--sky-gold); font-size: 18px; flex: none; }
+.play .lstars { color: var(--sky-on-accent); letter-spacing: 1px; }
+.all-perfect { margin: 0; padding: 14px; border-radius: 16px; text-align: center; font-weight: 700; background: color-mix(in srgb, var(--sky-gold) 20%, var(--surface)); }
+
+.lesson-map { position: relative; margin: 20px 0 8px; }
+.map-trail { position: absolute; inset: 0; width: 100%; height: 100%; overflow: visible; }
+.map-trail path { fill: none; stroke: color-mix(in srgb, var(--sky-mute) 55%, var(--line)); stroke-width: 6; stroke-linecap: round; stroke-dasharray: 1 12; vector-effect: non-scaling-stroke; }
+.map-trail path.on { stroke: var(--sky-accent); }
+.map-trail path.gold { stroke: var(--sky-gold); stroke-dasharray: none; stroke-width: 5; }
+.lnode { position: absolute; transform: translateX(-50%); width: 132px; display: flex; flex-direction: column; align-items: center; text-align: center;
+  text-decoration: none; color: var(--text); border-radius: 16px; }
+.lnode:focus-visible { outline: 3px solid var(--accent); outline-offset: 3px; }
+.lnode .disc { position: relative; display: grid; place-items: center; width: 68px; height: 68px; border-radius: 50%; font-size: 26px; font-weight: 800;
+  background: var(--sky-night); border: 3px solid var(--line); box-shadow: 0 5px 0 color-mix(in srgb, var(--sky-night) 60%, black); }
+.lnode.s1 .disc, .lnode.s2 .disc { border-color: var(--sky-accent); background: color-mix(in srgb, var(--sky-accent) 22%, var(--sky-night)); }
+.lnode.perfect .disc { border-color: var(--sky-gold); background: radial-gradient(circle at 35% 30%, #fff3c4, var(--sky-gold) 55%, #c9852a); box-shadow: 0 5px 0 #8a5a17, 0 0 22px color-mix(in srgb, var(--sky-gold) 55%, transparent); }
+.lnode.behind .disc { border-color: var(--sky-danger); }
+.lnode.next .disc { width: 80px; height: 80px; border-color: var(--sky-aurora); animation: sky-pulse 1.8s ease-out infinite; box-shadow: 0 0 0 6px color-mix(in srgb, var(--sky-aurora) 25%, transparent); }
+.lnode .perch { position: absolute; top: -14px; inset-inline-end: -34px; width: 34px; pointer-events: none; }
+.lnode .lstars { margin-top: 8px; font-size: 18px; line-height: 1; letter-spacing: 2px; color: var(--line); }
+.lnode.s1 .lstars, .lnode.s2 .lstars, .lnode.s3 .lstars { color: var(--sky-gold); }
+.lnode .lname { margin-top: 2px; font-size: 13px; line-height: 1.2; font-weight: 600; max-height: 2.4em; overflow: hidden; }
+.lnode .lmark { margin-top: 3px; font-size: 11.5px; padding: 0 8px; border-radius: 999px; border: 1px solid var(--line); background: var(--sky-night); }
+.lnode .lmark.late { color: var(--sky-danger); border-color: var(--sky-danger); }
+.lnode .lmark.open { color: var(--sky-aurora); border-color: var(--sky-aurora); }
+.map-key { font-size: 12.5px; text-align: center; margin: 0 0 12px; }
+
+/* ---------- the lesson round's sheet ---------- */
+.rd-skill { margin: 0 0 4px; font-size: 13px; }
+.rd-result { text-align: center; }
+.rd-bigstars { margin: 8px 0 0; font-size: 56px; line-height: 1; letter-spacing: 6px; color: var(--line); }
+.rd-bigstars span { display: inline-block; }
+.rd-bigstars span.on { color: var(--sky-gold); text-shadow: 0 0 18px color-mix(in srgb, var(--sky-gold) 60%, transparent);
+  animation: rd-pop .5s cubic-bezier(.2, 1.6, .4, 1) both; animation-delay: calc(var(--i) * .25s); }
+@keyframes rd-pop { from { transform: scale(0) rotate(-30deg); opacity: 0; } to { transform: scale(1) rotate(0); opacity: 1; } }
+.rd-title { margin: 8px 0 0; font-size: 22px; }
+.rd-mastered { font-weight: 700; color: var(--sky-gold); }
+.rd-almost { color: var(--sky-aurora); }
+.rd-result .ex-missed { text-align: start; }
+.lnode .lstars, .lnode .lname { position: relative; padding: 0 6px; border-radius: 8px; background: color-mix(in srgb, var(--sky-bg) 85%, transparent); }

mathly2/static/home.js

@@ -1,9 +1,11 @@
-// The student's home for a subject: the nearest test with its readiness and one task for today, the required simulation,
-// the other tests, and a button that continues the path.
+// The student's home for a subject: a game board. The stars collected and a big play button for the next lesson, the map of the lessons
+// (each with its stars: a round finished, 8 of 10, every skill mastered), then the nearest test with its readiness and today's task, the new
+// assignments, the required simulation, and a link to the path for going deeper.
 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";
+import { owl } from "./sky.js";
+import { backToSubjects, daysText, forSubject, goalBar, 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>`;
@@ -94,14 +96,6 @@ function assignmentsCard(all) {
 /** A grade as a chip inside the link it belongs to: the bare number, or "-" when there is none. */
 const chip = grade => `<span class="grade-chip${grade === null || grade === undefined ? " none" : ""}" data-best>${grade === null || grade === undefined ? "-" : grade}</span>`;
 
-/** Every lesson behind the curriculum, short: its name, its date and one link to its quiz with the best grade as a chip in it. */
-function behindCard(lessons) {
-  if (!lessons?.length) return "";
-  return `<section class="card" id="behind-card"><h2>שיעורים בפיגור</h2>
-    <ul class="plain behind-list">${lessons.map(l => `<li class="behind-row" data-lesson="${esc(l.id)}"><span class="grow"><b>${fmt(l.name)}</b> <span class="late">⚠ עד ${shortDate(l.due_date)}</span></span>
-      <a class="button with-chip" data-way="quiz" href="#/quiz/${encodeURIComponent(l.id)}">בוחן ${chip(l.quiz.best)}</a></li>`).join("")}</ul></section>`;
-}
-
 /** The nearest test's practice tests that were taken and are below 87 (13 of 15): to take again, inside the test's own card. */
 function weakTests(tests) {
   if (!tests?.length) return "";
@@ -120,18 +114,72 @@ function aiCard(ai) {
       <span class="tag st-${esc(r.state)}">${esc(aiSheet.stateWord(r.state))}</span> ${r.skill ? fmt(r.skill.name) : "תרגיל מצולם"}</button></li>`).join("")}</ul>` : ""}</section>`;
 }
 
+/* ---------- the lessons map: the home's game board ---------- */
+
+const ROW = 128;                                  // px between two lessons on the map
+const XS = [50, 76, 50, 24];                      // each lesson's place across the map, in %: a winding trail
+const starsText = n => "★".repeat(n) + "☆".repeat(3 - n);
+const starsLabel = n => n === 3 ? "שלושה כוכבים, מושלם" : n === 0 ? "אין עדיין כוכבים" : n === 1 ? "כוכב אחד" : "שני כוכבים";
+export const roundHref = id => `#/round/${encodeURIComponent(id)}`;
+
+/** The trail that joins the lessons: one curve per pair, gold after a perfect lesson, blue after a lesson with stars, faint otherwise. */
+function trailSvg(lessons) {
+  const h = lessons.length * ROW;
+  const pt = i => [XS[i % XS.length], i * ROW + 40];
+  const parts = lessons.slice(0, -1).map((l, i) => {
+    const [x0, y0] = pt(i), [x1, y1] = pt(i + 1), m = (y0 + y1) / 2;
+    return `<path class="${l.stars === 3 ? "gold" : l.stars ? "on" : ""}" d="M${x0} ${y0}C${x0} ${m} ${x1} ${m} ${x1} ${y1}"/>`;
+  }).join("");
+  return `<svg class="map-trail" viewBox="0 0 100 ${h}" preserveAspectRatio="none" aria-hidden="true">${parts}</svg>`;
+}
+
+function lessonNode(l, i, next) {
+  const isNext = l.id === next, perfect = l.stars === 3;
+  const marks = [l.behind ? `<span class="lmark late">⏰ עד ${shortDate(l.due_date)}</span>` : "", l.round_open ? `<span class="lmark open">◐ באמצע סבב</span>` : ""].join("");
+  const label = `שיעור ${l.number}: ${plainText(l.name)}. ${starsLabel(l.stars)}${l.behind ? `. בפיגור, היה אמור להסתיים ב־${shortDate(l.due_date)}` : ""}${l.round_open ? ". באמצע סבב" : ""}${isNext ? ". ממשיכים כאן" : ""}`;
+  return `<a class="lnode s${l.stars}${perfect ? " perfect" : ""}${isNext ? " next" : ""}${l.behind ? " behind" : ""}" href="${roundHref(l.id)}" data-lesson="${esc(l.id)}" data-stars="${l.stars}"
+      style="left:${XS[i % XS.length]}%;top:${i * ROW}px" aria-label="${esc(label)}">
+    <span class="disc" aria-hidden="true">${perfect ? "👑" : l.number}${isNext ? `<span class="perch">${owl(34)}</span>` : ""}</span>
+    <span class="lstars" aria-hidden="true">${starsText(l.stars)}</span>
+    <span class="lname">${fmt(l.name)}</span>${marks}</a>`;
+}
+
+const plainText = text => String(text ?? "").replace(/\$/g, "");
+
+/** The header and the play button: the stars collected, the lessons perfected, the daily goal and the streak. */
+function quest(map) {
+  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>
+      <span class="lstars" aria-label="${starsLabel(next.stars)}">${starsText(next.stars)}</span></a>`
+    : `<p class="all-perfect" id="play">👑 כל השיעורים מושלמים! אפשר להעמיק במסלול.</p>`;
+  return `<section class="quest" id="quest" aria-label="המסע שלי">
+    <div class="quest-top">${owl(56)}<div class="grow"><h2>המסע שלי</h2>
+      <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>` : ""}</p></div></div>
+    ${goalBar(map.today)}${play}</section>`;
+}
+
+function lessonMap(map) {
+  if (!map.lessons.length) return "";
+  return `<section class="lesson-map" id="lesson-map" aria-label="מפת השיעורים" style="height:${map.lessons.length * ROW}px">${trailSvg(map.lessons)}
+    ${map.lessons.map((l, i) => lessonNode(l, i, map.next)).join("")}</section>
+    <p class="map-key muted">★ סבב הושלם · ★★ 8 מתוך 10 · ★★★ כל המיומנויות נשלטו (שני ימים טובים)</p>`;
+}
+
 export const show = view => swr([forSubject("/api/home"), "/api/assignments", "/api/ai/status"], ([data, assignments, ai]) => draw(view, data, assignments, ai));
 
+let scrolled = false;
+
 function draw(view, data, assignments, ai) {
   const [first] = data.tests;
   const required = data.tests.filter(t => t.simulation.required);
   view(`${tabs("home")}${backToSubjects()}
-    ${first ? nearest(first, data.task, data.next_skill, data.weak_tests) : `<section class="card" id="no-test"><h2>הבית</h2>
-      <p class="muted">המורה עוד לא קבע מבחן. בינתיים אפשר להמשיך במסלול.</p></section>`}
-    ${behindCard(data.behind)}${assignmentsCard(assignments)}${aiCard(ai)}
     ${required.map(t => `<a class="required" href="#/sim/${t.id}" data-required="${t.id}"><b>חובה</b> מבחן סימולציה למבחן ב־${shortDate(t.date)}<span aria-hidden="true">‹</span></a>`).join("")}
-    <p>${data.next_skill ? `<a class="primary-link" id="continue-path" href="#/skill/${encodeURIComponent(data.next_skill.id)}">להמשיך במסלול: ${fmt(data.next_skill.name)} <span aria-hidden="true">‹</span></a>`
-      : `<a class="primary-link" id="continue-path" href="${pathHref()}">למסלול: כל הכוכבים פתוחים לתרגול <span aria-hidden="true">‹</span></a>`}</p>`);
+    ${quest(data.map)}${assignmentsCard(assignments)}${lessonMap(data.map)}
+    ${first ? nearest(first, data.task, data.next_skill, data.weak_tests) : ""}
+    ${aiCard(ai)}
+    <p><a class="primary-link" id="continue-path" href="${pathHref()}">להעמקה: כל המיומנויות, אחת־אחת <span aria-hidden="true">‹</span></a></p>`);
+  if (!scrolled) { scrolled = true; document.querySelector(".lnode.next")?.scrollIntoView?.({ block: "nearest" }); }
   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/path.js

@@ -51,8 +51,8 @@ function lesson(l, next) {
 
 export function pathHtml(path) {
   return `${tabs("path")}${backToSubjects()}
-    <section class="card path-top" id="path"><h2>המסלול שלי</h2>
-    <p class="muted">כל השיעורים פתוחים, בכל סדר. הינשוף מציע איפה להמשיך, אבל אפשר ללחוץ על כל כוכב.</p>${goalBar(path.today, path.streak)}${behindNote(path.behind)}</section>
+    <section class="card path-top" id="path"><h2>העמקה: המסלול המלא</h2>
+    <p class="muted">כאן מתרגלים כל מיומנות לבד, לעומק. את השיעורים משחקים במפה שבבית.</p>${goalBar(path.today, path.streak)}${behindNote(path.behind)}</section>
     <div class="trail">
       <div class="mark start">${owl(44)}<b>התחלה</b></div>
       ${path.lessons.map(l => lesson(l, path.next)).join("")}

mathly2/static/round.js

@@ -0,0 +1,188 @@
+// A lesson round (סבב שיעור), opened from the home's map: a short round of the lesson's skills, one question at a time, with instant feedback
+// like the exercise screen. A wrong answer names the mistake and never marks the right choice. The last answer shows the lesson's stars.
+import { api, ApiError } from "./api.js";
+import { figures } from "./figures.js";
+import { esc, fmt } from "./math.js";
+import { loadBoard } from "./exercise.js";
+import { homeHref, shuffled } from "./ui.js";
+
+const COUNTDOWN = 2;   // seconds before the next question after a right answer
+let layer = null, round = null, timer = null, streak = 0;
+
+const q = selector => layer?.querySelector(selector);
+const stop = () => { clearTimeout(timer); timer = null; };
+const starsText = n => "★".repeat(n) + "☆".repeat(3 - n);
+const CHEERS = ["נכון!", "יופי!", "מצוין!", "בדיוק!", "אלופים!"];
+
+export const isOpen = () => !!layer;
+
+/** Start the lesson's round (or resume the open one). Returns the round, so the router knows its subject. */
+export const start = lesson => api(`/api/lessons/${encodeURIComponent(lesson)}/round/start`, { method: "POST" });
+
+/** Show a round from `start` as a sheet over the home. */
+export async function show(data) {
+  stop();
+  await loadBoard();
+  round = data;
+  streak = 0;
+  if (!layer) {
+    layer = document.createElement("div");
+    layer.className = "mx-layer round-layer";
+    document.body.append(layer);
+    layer.addEventListener("click", onClick);
+  }
+  layer.innerHTML = `<div class="mx-scrim" data-close></div><div class="mx-sheet" role="dialog" aria-modal="true" aria-labelledby="rd-title"></div>`;
+  render();
+  q(".mx-x")?.focus({ preventScroll: true });
+}
+
+export function close() {
+  if (!layer) return;
+  stop();
+  window.MathlyBoard?.closeFull?.();
+  layer.remove();
+  layer = round = null;
+}
+
+const heading = () => `<div class="mx-shtop"><div><span class="ex-chip">סבב שיעור</span><h3 id="rd-title">${fmt(round.lesson.name)}</h3></div>
+  <div class="mx-shacts">${window.MathlyBoard?.button() || ""}<button type="button" class="mx-x" data-close aria-label="סגירה">✕</button></div></div>`;
+
+const dots = () => Array.from({ length: round.total }, (_, i) => {
+  const r = round.results[i];
+  return `<i class="${r === true ? "ok" : r === false ? "bad" : ""}">${r === false ? "✗" : ""}</i>`;
+}).join("");
+const countText = () => round.state === "done" ? "הסבב הסתיים" : `שאלה ${Math.min(round.results.length + 1, round.total)} מתוך ${round.total}`;
+const progress = () => `<div class="ex-progress"><span id="rd-count">${countText()}</span>
+  <span class="ex-dots" id="rd-dots" role="img" aria-label="נענו ${round.results.length} מתוך ${round.total}, ${round.results.filter(Boolean).length} נכונות">${dots()}</span></div>`;
+
+function questionHtml() {
+  const question = round.question;
+  return `<div class="mx-q" id="ex-q" data-key="${esc(question.key)}"><p class="muted rd-skill">${fmt(question.skill_name)}</p>
+    <p class="ex-text" dir="auto">${fmt(question.question)}</p>${figures(question)}
+    <div class="ex-choices" id="ex-choices">${shuffled(question.choices).map(c =>
+      `<button type="button" class="ex-choice" data-i="${c.index}" dir="auto">${fmt(c.text)}</button>`).join("")}</div>
+    <div class="ex-fb" id="ex-fb" role="status" aria-live="polite"></div></div>`;
+}
+
+/** The round's result: the stars big, the score, what was mastered, what is one good day away, and the mistakes (never the right answers). */
+function resultHtml() {
+  const r = round.result;
+  const names = list => list.map(s => fmt(s.name)).join(", ");
+  const title = r.stars === 3 ? "👑 השיעור מושלם!" : r.right === r.total ? "מושלם! כל התשובות נכונות" : r.right * 10 >= r.total * 8 ? "כל הכבוד!" : "סיימתם סבב!";
+  return `<section class="rd-result" id="rd-result">
+    <p class="rd-bigstars" aria-label="${r.stars} מתוך 3 כוכבים">${[0, 1, 2].map(i => `<span class="${i < r.stars ? "on" : ""}" style="--i:${i}">${i < r.stars ? "★" : "☆"}</span>`).join("")}</p>
+    <h4 class="rd-title">${title}</h4>
+    <p class="ex-score" id="rd-score"><b>${r.right}</b> מתוך ${r.total}</p>
+    ${r.mastered.length ? `<p class="rd-mastered" id="rd-mastered">🎉 נשלטו: ${names(r.mastered)}</p>` : ""}
+    ${r.almost.length ? `<p class="rd-almost" id="rd-almost">🔜 עוד סבב טוב ביום אחר ונשלטות: ${names(r.almost)}</p>` : ""}
+    ${r.stars < 3 ? `<p class="muted rd-next">${r.stars < 2 ? "8 מתוך 10 נותנים כוכב שני." : "הכוכב השלישי: כל המיומנויות נשלטו. חוזרים מחר לעוד סבב."}</p>` : ""}
+    ${r.missed.length ? `<h4>מה כדאי לחזק</h4><ol class="ex-missed" id="rd-missed">${r.missed.map(m => `<li><p class="muted">${fmt(m.skill_name)}</p><p class="ex-text" dir="auto">${fmt(m.question)}</p>
+      ${m.mistake ? `<p><b>${esc(m.mistake.name)}</b>${m.mistake.tip ? `<br>${fmt(m.mistake.tip)}` : ""}</p>` : ""}</li>`).join("")}</ol>` : ""}
+    <p class="ex-actions"><button type="button" class="primary" id="rd-again">סבב נוסף</button> <button type="button" data-close>חזרה למפה</button></p></section>`;
+}
+
+function mountBoard() {
+  const key = round.question ? `round:${round.id}:${round.question.key}` : `round:${round.id}:done`;
+  window.MathlyBoard?.mount(layer, key, { question: () => q("#ex-q") });
+}
+
+function render(notice = "") {
+  q(".mx-sheet").innerHTML = `${heading()}${notice ? `<p class="ex-note" role="status">${esc(notice)}</p>` : ""}${progress()}
+    ${round.state === "done" ? resultHtml() : questionHtml()}`;
+  mountBoard();
+}
+
+function updateProgress() {
+  q("#rd-count").textContent = countText();
+  q("#rd-dots").innerHTML = dots();
+}
+
+function countdown(next) {
+  let left = COUNTDOWN;
+  const label = q("#ex-countdown");
+  const tick = () => {
+    if (!layer || !label?.isConnected) return;
+    if (left === 0) return next();
+    label.textContent = `הבאה בעוד ${left}…`;
+    left -= 1;
+    timer = setTimeout(tick, 1000);
+  };
+  tick();
+}
+
+async function answer(button) {
+  const buttons = [...layer.querySelectorAll(".ex-choice")];
+  buttons.forEach(b => { b.disabled = true; b.classList.toggle("dim", b !== button); });
+  button.classList.add("pending");
+  button.setAttribute("aria-busy", "true");
+  q("#ex-fb").innerHTML = `<p class="ex-thinking">בודקים…</p>`;
+  let result;
+  try {
+    result = await api(`/api/rounds/${encodeURIComponent(round.id)}/answer`, { method: "POST", body: { key: round.question.key, choice: Number(button.dataset.i) } });
+  } catch (error) {
+    buttons.forEach(b => b.classList.remove("pending", "dim"));
+    button.removeAttribute("aria-busy");
+    if (error instanceof ApiError && error.status === 409) {                    // answered in another tab: show where the round is now
+      round = await api(`/api/rounds/${encodeURIComponent(round.id)}`);
+      return render("הסבב התקדם בחלון אחר. זו השאלה שעל המסך עכשיו.");
+    }
+    buttons.forEach(b => { b.disabled = false; });
+    q("#ex-fb").innerHTML = `<p class="error" role="alert">${esc(error.message || "משהו השתבש")}</p>`;
+    return;
+  }
+  buttons.forEach(b => b.classList.remove("pending", "dim"));
+  button.removeAttribute("aria-busy");
+  const following = result.round;
+  round = { ...round, results: following.results, state: following.state };
+  updateProgress();
+  const next = () => { stop(); round = following; render(); };
+  const last = following.state === "done";
+  const feedback = q("#ex-fb");
+  const mastered = result.mastered_now ? `<p class="rd-mastered">🎉 ${fmt(result.mastered_now.name)}: נשלטה!</p>` : "";
+  if (result.correct) {
+    streak += 1;
+    button.classList.add("right");
+    button.insertAdjacentHTML("beforeend", '<span class="burst" aria-hidden="true">✦ ✦ ✦</span>');
+    navigator.vibrate?.(25);
+    feedback.innerHTML = `<div class="ex-ok"><b>${CHEERS[(streak - 1) % CHEERS.length]} ✓</b>${streak >= 3 ? ` <span>🔥 ${streak} ברצף</span>` : ""}${mastered}
+      <div class="ex-actions">${last ? `<button type="button" class="primary" id="rd-next">לתוצאות ✨</button>`
+        : `<span id="ex-countdown"></span><button type="button" id="rd-next">לשאלה הבאה</button>`}</div></div>`;
+    if (!last) countdown(next);
+  } else {
+    streak = 0;
+    button.classList.add("wrong");
+    button.insertAdjacentHTML("beforeend", '<span class="verdict"><span aria-hidden="true">✗</span> לא נכון</span>');
+    const m = result.mistake;
+    feedback.innerHTML = `<div class="ex-bad"><b>${esc(m?.name || "תשובה לא נכונה")}</b>${m?.tip ? `<p>${fmt(m.tip)}</p>` : ""}
+      <div class="ex-actions"><button type="button" id="rd-next">${last ? "לתוצאות" : "לשאלה הבאה"}</button></div></div>`;
+  }
+  q("#rd-next").addEventListener("click", next);
+}
+
+async function again() {
+  const button = q("#rd-again");
+  button.disabled = true;
+  try {
+    round = await start(round.lesson.id);
+    streak = 0;
+    render();
+  } catch (error) {
+    button.disabled = false;
+    button.insertAdjacentHTML("afterend", `<p class="error" role="alert">${esc(error.message || "משהו השתבש")}</p>`);
+  }
+}
+
+function onClick(event) {
+  const target = event.target;
+  if (target.closest("[data-close]")) { location.hash = homeHref(); return; }
+  if (target.closest("[data-board-toggle]")) { window.MathlyBoard?.toggle(); return; }
+  if (target.closest("#rd-again")) { again(); return; }
+  const choice = target.closest(".ex-choice");
+  if (choice && !choice.disabled) answer(choice);
+}
+
+window.addEventListener("mathly:leave", close);
+
+document.addEventListener("keydown", event => {
+  if (event.key === "Escape" && layer && !document.querySelector(".mx-board.full")) location.hash = homeHref();
+});

mathly2/static/student.js

@@ -9,6 +9,7 @@ import * as home from "./home.js";
 import * as phone from "./phone.js";
 import * as path from "./path.js";
 import * as quiz from "./quiz.js";
+import * as lessonRound from "./round.js";
 import { route as onRoute } from "./router.js";
 
 export async function show(me, view) {
@@ -23,8 +24,15 @@ export async function show(me, view) {
     phone.stopComputer();                                      // a page that was waiting for the phone's photo is left
     const raw = location.hash.replace(/^#/, "");
     const where = raw.startsWith("/") ? raw : "/";          // no address, or the sign-in service's "#access_token=…": the first screen
+    if (!where.startsWith("/round/")) lessonRound.close();
     try {
-      if (where.startsWith("/skill/")) {
+      if (where.startsWith("/round/")) {                                     // a lesson's round over the home (a link or a reload: the home first)
+        exercise.close(); quiz.close();
+        const data = await lessonRound.start(decodeURIComponent(where.slice(7)));
+        setSubject(data.subject_id);
+        if (!document.getElementById("lesson-map")) await home.show(view);
+        await lessonRound.show(data);
+      } else if (where.startsWith("/skill/")) {
         quiz.close();
         lastSkill = decodeURIComponent(where.slice(7));
         if (!document.getElementById("path")) {                            // a link or a reload: the skill's subject's path first, then the sheet

mathly2/static/ui.js

@@ -19,10 +19,11 @@ export const pathHref = () => `#/subject/${encodeURIComponent(subject)}/path`;
 /** A student API address for the current subject ("/api/path" -> "/api/path?subject=math"). */
 export const forSubject = url => `${url}${url.includes("?") ? "&" : "?"}subject=${encodeURIComponent(subject)}`;
 
-/** The student's tab bar, fixed at the bottom of the screen (the CSS places it): home, path, grades, collection. */
+/** The student's tab bar, fixed at the bottom of the screen (the CSS places it): home (the lessons map), the path ("העמקה": going deeper,
+ *  skill by skill), submissions, grades, collection, review. */
 export const tabs = active => `<nav class="tabs" aria-label="תפריט התלמיד">
   <a href="${homeHref()}" ${active === "home" ? 'aria-current="page"' : ""}>בית</a>
-  <a href="${pathHref()}" ${active === "path" ? 'aria-current="page"' : ""}>מסלול</a>
+  <a href="${pathHref()}" ${active === "path" ? 'aria-current="page"' : ""}>העמקה</a>
   <a href="#/submissions" ${active === "submissions" ? 'aria-current="page"' : ""}>הגשות</a>
   <a href="#/grades" ${active === "grades" ? 'aria-current="page"' : ""}>ציונים</a>
   <a href="#/collection" ${active === "collection" ? 'aria-current="page"' : ""}>האוסף</a>

mathly2/supabase/migrations/20261118090000_m2_lesson_rounds.sql

@@ -0,0 +1,9 @@
+-- Mathly 2: lesson rounds (סבב שיעור), a short round of a lesson's skills with instant feedback, kept as m2_attempts rows of kind
+-- lesson_round (scope: the lesson id). Its answers are also stored as practice answers in m2_answers. One widened check.
+-- Rollback: delete from public.m2_attempts where kind = 'lesson_round';
+--           alter table public.m2_attempts drop constraint m2_attempts_kind_check;
+--           alter table public.m2_attempts add constraint m2_attempts_kind_check check (kind in ('quiz', 'exercise_test', 'simulation'));
+begin;
+alter table public.m2_attempts drop constraint m2_attempts_kind_check;
+alter table public.m2_attempts add constraint m2_attempts_kind_check check (kind in ('quiz', 'exercise_test', 'simulation', 'lesson_round'));
+commit;

mathly2/tests/test_behind_home_browser.py

@@ -17,42 +17,6 @@ def seed(app, store, bank, lessons):
     store.set_lesson_dates({lessons[0]: today - timedelta(days=2), lessons[1]: today - timedelta(days=9)})
 
 
-def test_the_card_lists_the_lessons_behind_in_date_order_each_with_only_the_quiz_link(browser, bank):
-    app, store, klass, lessons = world(bank)
-    seed(app, store, bank, lessons)
-    q = store.create_attempt(KID_ID, "quiz", lessons[0], clock.now() - timedelta(hours=2), clock.now() - timedelta(hours=1), [])
-    store.save_attempt(q["id"], submitted_at=clock.now() - timedelta(hours=1), grade=80)
-    with running(app) as url:
-        page = sign_in(browser, url)
-        to_home(page)
-        page.wait_for_selector("#behind-card")
-        rows = page.locator("#behind-card li")
-        assert rows.count() == 2 and rows.nth(0).get_attribute("data-lesson") == lessons[1] and rows.nth(1).get_attribute("data-lesson") == lessons[0]     # the earlier date first
-        assert page.locator("#behind-card [data-way=skills]").count() == 0 and page.locator("#behind-card a").count() == 2                                 # only the quiz links
-        mine = page.locator(f"#behind-card li[data-lesson='{lessons[0]}']")
-        link = mine.locator("[data-way=quiz]")
-        assert link.get_attribute("href") == f"#/quiz/{lessons[0]}" and link.inner_text().split() == ["בוחן", "80"]
-        assert link.locator(".grade-chip[data-best]").inner_text() == "80" and rows.nth(0).locator("[data-way=quiz] .grade-chip").inner_text() == "-"   # a chip inside the link
-        chip, button = link.locator(".grade-chip").bounding_box(), link.bounding_box()
-        assert button["x"] <= chip["x"] and chip["x"] + chip["width"] <= button["x"] + button["width"] and chip["y"] >= button["y"]   # attached, not floating beside it
-        assert "13" not in page.inner_text("#behind-card") and "מתוך" not in page.inner_text("#behind-card")                       # nothing explains the pass line
-        assert "⚠" in mine.inner_text() and "מיומנויות" not in page.inner_text("#behind-card")
-        no_sideways_scroll(page)
-        assert not page.errors
-
-
-def test_the_quiz_link_opens_the_quiz(browser, bank):
-    app, store, klass, lessons = world(bank)
-    seed(app, store, bank, lessons)
-    with running(app) as url:
-        page = sign_in(browser, url)
-        to_home(page)
-        page.wait_for_selector("#behind-card")
-        page.click(f"#behind-card li[data-lesson='{lessons[1]}'] [data-way=quiz]")
-        page.wait_for_selector("#qz-q")
-        assert page.evaluate("location.hash").startswith(f"#/quiz/{lessons[1]}/")
-
-
 def test_practice_tests_below_87_are_inside_the_nearest_test_card_with_the_grade_in_the_button(browser, bank):
     app, store, klass, lessons = world(bank)
     test = store.create_test(klass["id"], clock.school_day() + timedelta(days=10), lessons[:1], "t@school.test", created_at=clock.now() - timedelta(days=20))

mathly2/tests/test_home_browser.py

@@ -81,8 +81,8 @@ def test_the_card_opens_home_and_each_tab_opens_its_screen(browser, bank):
         page = sign_in(browser, url)
         to_home(page)
         assert page.evaluate("location.hash") == "#/subject/math" and page.locator(".tabs a[aria-current='page']").inner_text() == "בית"
-        assert page.locator(".tabs a").all_inner_texts() == ["בית", "מסלול", "הגשות", "ציונים", "האוסף", "חזרה"]
-        for href, marker in (("#/subject/math/path", ".orbit"), ("#/submissions", "#submissions"), ("#/grades", "#grades"), ("#/collection", "#collection"), ("#/review", "#review"), ("#/subject/math", "#no-test")):
+        assert page.locator(".tabs a").all_inner_texts() == ["בית", "העמקה", "הגשות", "ציונים", "האוסף", "חזרה"]
+        for href, marker in (("#/subject/math/path", ".orbit"), ("#/submissions", "#submissions"), ("#/grades", "#grades"), ("#/collection", "#collection"), ("#/review", "#review"), ("#/subject/math", "#lesson-map")):
             page.click(f".tabs a[href='{href}']")
             page.wait_for_selector(marker)
         assert page.errors == []
@@ -119,14 +119,15 @@ def test_a_link_to_a_skill_still_opens_the_path_with_its_sheet(browser, bank):
 
 # --- 3.2 home ---
 
-def test_with_no_test_home_says_so_and_continues_the_path(browser, bank):
+def test_with_no_test_home_shows_the_map_and_a_link_to_the_path(browser, bank):
     app, _, _, lessons = world(bank)
-    first = covered(bank, lessons)[0]
     with running(app) as url:
         page = sign_in(browser, url)
         to_home(page)
-        assert "עוד לא קבע מבחן" in page.inner_text("#no-test") and page.locator("#nearest-test").count() == 0
-        assert page.get_attribute("#continue-path", "href") == f"#/skill/{first}"
+        page.wait_for_selector("#lesson-map")
+        assert page.locator("#nearest-test").count() == 0
+        assert page.get_attribute("#continue-path", "href") == "#/subject/math/path"
+        assert page.get_attribute("#play", "href") == f"#/round/{lessons[0]}"
         no_sideways_scroll(page)
 
 

mathly2/tests/test_lesson_map_browser.py

@@ -0,0 +1,118 @@
+"""The home's lessons map and a lesson round in a real browser (game-home-lesson-rounds 2.1-2.3)."""
+import os
+from datetime import timedelta
+
+import pytest
+
+playwright = pytest.importorskip("playwright.sync_api")
+
+from mathly2 import clock
+from mathly2.bank import load_bank
+from mathly2.config import Settings
+from mathly2.main import create_app
+from mathly2.store import InMemoryStore
+from mathly2.tests.serve import offline_formulas, only, running
+from mathly2.tests.test_home_browser import KID, KID_ID, PHONE, TEACHER, no_sideways_scroll, sign_in, to_home
+
+SHOTS = os.environ.get("MATHLY_SHOTS")          # a folder: save screenshots there to look at the screens
+STAMP = "2026-10-05T10:00:00+00:00"
+
+
+@pytest.fixture(scope="module")
+def bank():
+    return load_bank()
+
+
+@pytest.fixture
+def browser():
+    with playwright.sync_playwright() as p:
+        b = p.chromium.launch()
+        yield b
+        b.close()
+
+
+def world(bank, n=4):
+    lessons = [l["id"] for l in bank.lessons if any(s["unit"] == l["id"] and bank.question_keys(s["id"]) for s in bank.skills)][:n]
+    store = InMemoryStore()
+    klass = store.create_class("setup", "A", lessons=lessons, teacher_email=TEACHER)
+    store.add_member(klass["id"], KID)
+    small = only(bank, lessons)
+    return create_app(Settings(), bank=small, store=store), store, small, lessons
+
+
+def shot(page, name):
+    if SHOTS:
+        page.screenshot(path=os.path.join(SHOTS, f"{name}.png"), full_page=True)
+
+
+def right_index(bank, key):
+    skill = next(s for s in bank.skills if key in bank.question_keys(s["id"]))
+    from mathly2.bank import question_key
+    question = next(q for q in skill["questions"] if question_key(skill["id"], q) == key)
+    return next(i for i, c in enumerate(question["choices"]) if c.get("correct"))
+
+
+def test_home_is_a_map_of_the_lessons_with_stars_and_a_play_button(browser, bank):
+    app, store, small, lessons = world(bank)
+    first = [s["id"] for s in small.skills if s["unit"] == lessons[0]]
+    for s in first:
+        store.save_progress(KID_ID, s, started_at=STAMP, mastered_at=STAMP)                    # lesson 1 perfect
+    store.set_lesson_dates({lessons[2]: clock.school_day() - timedelta(days=3)})               # lesson 3 behind
+    with running(app) as url:
+        page = sign_in(browser, url)
+        to_home(page)
+        page.wait_for_selector("#lesson-map")
+        nodes = page.locator(".lnode")
+        assert nodes.count() == len(lessons)
+        assert nodes.nth(0).get_attribute("data-stars") == "3" and "👑" in nodes.nth(0).inner_text()
+        assert "⏰" in nodes.nth(2).inner_text()
+        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
+        no_sideways_scroll(page)
+        shot(page, "home")
+        assert page.errors == []
+
+
+def test_a_round_from_the_map_gives_feedback_and_ends_with_stars(browser, bank):
+    app, store, small, lessons = world(bank, 2)
+    with running(app) as url:
+        page = sign_in(browser, url)
+        to_home(page)
+        page.click("#play")
+        page.wait_for_selector(".round-layer #ex-q")
+        total = int(page.locator("#rd-count").inner_text().split()[-1])
+        shot(page, "round-question")
+        for i in range(total):
+            key = page.locator("#ex-q").get_attribute("data-key")
+            pick = right_index(small, key) if i < total - 1 else None
+            if pick is None:                                                   # the last one wrong
+                page.locator(f".ex-choice:not([data-i='{right_index(small, key)}'])").first.click()
+                page.wait_for_selector(".ex-bad")
+                shot(page, "round-wrong")
+            else:
+                page.click(f".ex-choice[data-i='{pick}']")
+                page.wait_for_selector(".ex-ok")
+            page.click("#rd-next")
+            if i < total - 1:
+                page.wait_for_function(f"document.querySelector('#rd-count').textContent.includes('{i + 2} מתוך')")
+        page.wait_for_selector("#rd-result")
+        assert page.locator("#rd-score").inner_text().replace("\n", " ").startswith(f"{total - 1}")
+        assert page.locator(".rd-bigstars span.on").count() == 2                     # 9 of 10: two stars
+        shot(page, "round-result")
+        page.click("#rd-result [data-close]")
+        page.wait_for_selector(f".lnode[data-lesson='{lessons[0]}'][data-stars='2']")                # the map refreshes with the new stars
+        assert page.evaluate("location.hash") == "#/subject/math"
+        assert page.errors == []
+
+
+def test_a_link_to_a_round_opens_the_home_under_it(browser, bank):
+    app, _, _, lessons = world(bank, 2)
+    with running(app) as url:
+        page = sign_in(browser, url, f"#/round/{lessons[1]}")
+        page.wait_for_selector(".round-layer #ex-q")
+        assert page.locator("#lesson-map").count() == 1
+        page.click(".mx-x")
+        page.wait_for_function("!document.querySelector('.round-layer')")
+        assert page.errors == []

mathly2/tests/test_permissions.py

@@ -41,6 +41,9 @@ NEEDS = {   # (method, path) -> permission
     ("PUT", "/api/tests/{test_id}"): "class.teach",
     ("DELETE", "/api/tests/{test_id}"): "class.teach",
     ("GET", "/api/home"): "path.use",
+    ("POST", "/api/lessons/{lesson_id}/round/start"): "path.use",
+    ("GET", "/api/rounds/{round_id}"): "path.use",
+    ("POST", "/api/rounds/{round_id}/answer"): "path.use",
     ("POST", "/api/tests/{test_id}/exercise/{number}/start"): "path.use",
     ("POST", "/api/tests/{test_id}/simulation/start"): "path.use",
     ("GET", "/api/tests/{test_id}"): "path.use",
@@ -131,7 +134,7 @@ def world():
 
 
 def call(client, method, path, email):
-    url = path.format(skill_id="t_ext", lesson_id="t", attempt_id="x", test_id="1", number="1", picture_id="x", assignment_id="1", submission_id="1", request_id="x", class_id="1", subject_id="math", index="0", email="someone@school.test", role="teacher")
+    url = path.format(skill_id="t_ext", lesson_id="t", attempt_id="x", round_id="x", test_id="1", number="1", picture_id="x", assignment_id="1", submission_id="1", request_id="x", class_id="1", subject_id="math", index="0", email="someone@school.test", role="teacher")
     sends = method in ("POST", "PUT", "PATCH")
     return client.request(method, url, headers={"Authorization": f"Bearer dev:{email}"}, json={} if sends else None)
 

mathly2/tests/test_rounds_api.py

@@ -0,0 +1,111 @@
+"""Lesson rounds and the lesson's stars (game-home-lesson-rounds 1.2, 1.3)."""
+from collections import Counter
+
+from mathly2.tests.test_skills_api import KID_ID, MON, TUE, auth, raw, right_choice, world, wrong_choice  # noqa: F401
+
+STAMP = "2026-10-05T10:00:00+00:00"
+
+
+def skills_of(bank, lesson):
+    return [s["id"] for s in bank.skills if s["unit"] == lesson and bank.question_keys(s["id"])]
+
+
+def a_lesson(bank, n=5):
+    return next(l["id"] for l in bank.lessons if len(skills_of(bank, l["id"])) == n)
+
+
+def start(client, lesson):
+    response = client.post(f"/api/lessons/{lesson}/round/start", headers=auth())
+    assert response.status_code == 200, response.text
+    return response.json()
+
+
+def play(client, bank, rnd, rights):
+    """Answer the round's questions in order, right or wrong; return the last answer's response."""
+    got = None
+    for right in rights:
+        q = rnd["question"]
+        skill = next(s["id"] for s in bank.skills if q["key"] in bank.question_keys(s["id"]))
+        choice = (right_choice if right else wrong_choice)(bank, skill, q["key"])
+        response = client.post(f"/api/rounds/{rnd['id']}/answer", headers=auth(), json={"key": q["key"], "choice": choice})
+        assert response.status_code == 200, response.text
+        got = response.json()
+        rnd = got["round"]
+    return got
+
+
+def map_row(client, lesson):
+    home = client.get("/api/home", headers=auth()).json()["map"]
+    return home, next(r for r in home["lessons"] if r["id"] == lesson)
+
+
+def test_a_round_of_five_fresh_skills_is_ten_questions_two_each_and_never_carries_the_answer(world):
+    client, _, bank = world
+    lesson = a_lesson(bank)
+    rnd = start(client, lesson)
+    assert rnd["state"] == "open" and rnd["total"] == 10 and rnd["results"] == []
+    assert '"correct"' not in str(rnd["question"]).replace("'", '"')
+    row = client.app.state.store.get_attempt(rnd["id"])
+    assert sorted(Counter(q["skill_id"] for q in row["questions"]).values()) == [2] * 5
+    assert start(client, lesson)["id"] == rnd["id"]                                         # an open round resumes
+
+
+def test_a_round_leaves_out_mastered_skills_at_most_three_from_each(world):
+    client, store, bank = world
+    lesson = a_lesson(bank)
+    skills = skills_of(bank, lesson)
+    for s in skills[:4]:
+        store.save_progress(KID_ID, s, started_at=STAMP, mastered_at=STAMP)
+    rnd = start(client, lesson)
+    assert rnd["total"] == 3 and {q["skill_id"] for q in store.get_attempt(rnd["id"])["questions"]} == {skills[4]}
+
+
+def test_answers_must_come_in_order_and_each_is_a_practice_answer(world):
+    client, store, bank = world
+    rnd = start(client, a_lesson(bank))
+    wrong_key = store.get_attempt(rnd["id"])["questions"][1]["key"]
+    assert client.post(f"/api/rounds/{rnd['id']}/answer", headers=auth(), json={"key": wrong_key, "choice": 0}).status_code == 409
+    got = play(client, bank, rnd, [False])
+    assert got["correct"] is False and got["mistake"] is not None and got["round"]["results"] == [False]
+    skill = store.get_attempt(rnd["id"])["questions"][0]["skill_id"]
+    assert store.get_progress(KID_ID, skill)["started_at"]                                   # the skill is in learning now
+    assert any(r["question_key"] == rnd["question"]["key"] for r in store.review_of(KID_ID)) if hasattr(store, "review_of") else True
+
+
+def test_the_result_after_the_last_answer_and_the_stars(world):
+    client, _, bank = world
+    lesson = a_lesson(bank)
+    _, row = map_row(client, lesson)
+    assert row["stars"] == 0
+    got = play(client, bank, start(client, lesson), [True] * 7 + [False] * 3)
+    result = got["round"]["result"]
+    assert got["round"]["state"] == "done" and result["right"] == 7 and result["total"] == 10 and result["stars"] == 1 and len(result["missed"]) == 3
+    assert map_row(client, lesson)[1]["stars"] == 1
+    play(client, bank, start(client, lesson), [True] * 8 + [False] * 2)
+    assert map_row(client, lesson)[1]["stars"] == 2
+    play(client, bank, start(client, lesson), [False] * 10)
+    assert map_row(client, lesson)[1]["stars"] == 2                                        # stars never go down
+
+
+def test_two_good_rounds_on_two_days_master_the_lesson_three_stars(world):
+    client, _, bank = world
+    lesson = a_lesson(bank)
+    client.set_time(MON)
+    first = play(client, bank, start(client, lesson), [True] * 10)["round"]["result"]
+    assert first["stars"] == 2 and len(first["almost"]) == 5 and first["mastered"] == []
+    client.set_time(TUE)
+    last = play(client, bank, start(client, lesson), [True] * 10)
+    assert last["round"]["result"]["stars"] == 3 and len(last["round"]["result"]["mastered"]) == 5
+    home, row = map_row(client, lesson)
+    assert row["stars"] == 3 and home["perfect"] == 1
+
+
+def test_the_map_names_the_next_lesson_open_round_first(world):
+    client, _, bank = world
+    home = client.get("/api/home", headers=auth()).json()["map"]
+    playable = home["lessons"]
+    assert home["next"] == playable[0]["id"] and home["max_stars"] == 3 * len(playable) and home["stars"] == 0
+    later = playable[3]["id"]
+    start(client, later)
+    home, row = map_row(client, later)
+    assert home["next"] == later and row["round_open"] is True

openspec/changes/game-home-lesson-rounds/proposal.md

@@ -0,0 +1,26 @@
+# Proposal
+
+## Why
+
+A parent installed the app for their child: the skills-and-lessons structure is too heavy. A lesson is about 50 exercises (5 skills × a round of 10), which discourages, and the home is a column of cards that does not show at a glance what is done and what is left. The goal is that the child masters the skills; the home should show, simply and like a game, which lessons are done and which are still waiting, and make them want to play the next one. The path stays, for going deeper.
+
+## What Changes
+
+- **A lesson round (סבב שיעור):** 10 questions from the lesson's skills, with instant feedback like the exercise screen (a celebration, the mistake's tip). It draws only from skills not mastered yet, at most 3 per skill, so it gets shorter as the lesson fills up (a lesson with one skill left is a round of 3). A lesson whose skills are all mastered draws 10 from all of them. Its answers are practice answers: they count for mastery, the daily goal and the review list.
+- **Stars per lesson:** ⭐ a round finished, ⭐⭐ a round with 8 or more right of 10 (80%), ⭐⭐⭐ every skill of the lesson mastered ("מושלם"). Because mastery needs two days, the third star means coming back another day; a round's result says which skills are one good day away.
+- **The home is a map:** a header with the stars collected, the lessons perfected and the daily goal and streak; one big "play" button for the next lesson; a winding map of the lessons, each a node with its number (a crown when perfect), its stars, and a mark when it is behind the curriculum or has a round in progress. Tapping a node opens its round. The nearest test, the new assignments and the required simulation stay, below the map. The behind card is replaced by the mark on the map.
+- **The path is for going deeper:** its tab is named "העמקה"; nothing else changes on it.
+
+## Capabilities
+
+### New Capabilities
+- `lesson-rounds`: the lesson round and the lesson's stars.
+
+### Modified Capabilities
+- `student-home`: "Home shows only what is critical", "Continue the path", "Lessons behind on home" (replaced by the map).
+- `learning-path`: the tab's name.
+
+## Impact
+
+- New `mathly2/rounds.py` (start, read, answer), `mathly2/static/round.js`; `mathly2/skills.py` (`lesson_rows` gives stars and the round facts), `mathly2/realtests.py` (`/api/home` gives the map), `mathly2/static/home.js`, `student.js`, `ui.js`, `app.css`.
+- Database: one widened check on `m2_attempts.kind` (adds `lesson_round`), migration `20261118090000_m2_lesson_rounds.sql`. It must be applied before deploying.

openspec/changes/game-home-lesson-rounds/specs/learning-path/spec.md

@@ -0,0 +1,8 @@
+## ADDED Requirements
+
+### Requirement: The path is for going deeper
+The path's tab SHALL be named "העמקה". The home's map is where lessons are played; the path keeps every skill open for practice one by one.
+
+#### Scenario: The tab
+- **WHEN** a student looks at the tab bar
+- **THEN** the tab that opens the path reads "העמקה"

openspec/changes/game-home-lesson-rounds/specs/lesson-rounds/spec.md

@@ -0,0 +1,33 @@
+## ADDED Requirements
+
+### Requirement: A lesson round
+Every lesson with practice questions SHALL have a round of at most 10 questions drawn from its skills that are not mastered, at most 3 from each, spread evenly, the least-used questions first. When every skill of the lesson is mastered the round SHALL draw 10 from all its skills. Starting a round while one is open SHALL resume it.
+
+#### Scenario: Five skills, none mastered
+- **WHEN** a student starts the round of a lesson with five skills and none mastered
+- **THEN** it has 10 questions, 2 from each skill
+
+#### Scenario: One skill left
+- **WHEN** four of the lesson's five skills are mastered
+- **THEN** the round has 3 questions, all from the fifth skill
+
+### Requirement: Instant feedback in a round
+Each answer in a round SHALL be graded at once, with the same feedback as the exercise screen: a celebration for a right answer, the mistake's name and tip for a wrong one, never the right choice. The questions SHALL be answered in order, each once. Every answer SHALL be stored as a practice answer of its skill, not given with help, so it counts for mastery and the daily goal, and a wrong one goes to the review list.
+
+#### Scenario: Mastery from a round
+- **WHEN** a student answered a skill's last two questions right yesterday and answers its question in today's round right
+- **THEN** the skill becomes mastered and the answer's feedback says so
+
+### Requirement: A round's result
+After the last answer the round SHALL show the right answers out of its questions, the lesson's stars, the skills mastered in it, the skills that are one good day away from mastery, and each mistake's name and tip. It SHALL offer another round and a way back home.
+
+#### Scenario: Seven of ten
+- **WHEN** a student finishes a round with 7 right
+- **THEN** the result shows "7 מתוך 10", one star, and the three mistakes
+
+### Requirement: Stars per lesson
+A lesson SHALL have 0 to 3 stars: 3 when every one of its skills is mastered; else 2 when a finished round had at least 80% right; else 1 when a round was finished; else 0. Stars never go down.
+
+#### Scenario: Eight of ten
+- **WHEN** a student finishes a lesson's round with 8 right and some skills not mastered
+- **THEN** the lesson has two stars

openspec/changes/game-home-lesson-rounds/specs/student-home/spec.md

@@ -0,0 +1,45 @@
+## ADDED Requirements
+
+### Requirement: The lessons map
+Home SHALL open with a map of the student's lessons in the subject, in the bank's order, on one winding trail. Each lesson SHALL be a node with its number (a crown and "מושלם" when it has three stars), its name, its stars as ★ and ☆, a "⏰" mark when it is behind the curriculum and a "◐" mark when a round is open. Tapping a node SHALL open the lesson's round over the home. Above the map SHALL be the stars collected out of three per lesson, the lessons perfected, and the daily goal with the streak.
+
+#### Scenario: Opening home
+- **WHEN** a student with three lessons opens home
+- **THEN** they see three nodes on the trail, each with its stars, and "⭐ N מתוך 9"
+
+#### Scenario: A behind lesson
+- **WHEN** a lesson's date has passed and it is not completed
+- **THEN** its node shows "⏰" with the date
+
+### Requirement: Play the next lesson
+Home SHALL have one big button that opens the round of the next lesson: the lesson with an open round, else the earliest lesson behind the curriculum, else the first lesson with fewer than three stars. With every lesson perfect, it SHALL say so and offer the path for going deeper.
+
+#### Scenario: New student
+- **WHEN** a student who answered nothing opens home
+- **THEN** the button opens the round of the first lesson
+
+## MODIFIED Requirements
+
+### Requirement: Continue the path
+Home SHALL have a link to the path, named for going deeper ("להעמקה").
+
+#### Scenario: No test
+- **WHEN** a student has no upcoming test
+- **THEN** home shows the map, the play button and the link to the path
+
+### Requirement: Home shows only what is critical
+The home SHALL show only: the lessons map with its header and play button, the nearest test with its readiness, today's task and its practice tests below the pass line, a required simulation, the new assignments (not handed in yet), and the link to the path. Other tests, assignments that were handed in or checked, and settings such as notifications SHALL NOT be on home; the other tests are reached from the test's card.
+
+#### Scenario: Nothing critical
+- **WHEN** a student has no upcoming test and no new assignment
+- **THEN** home shows the map, the play button and the link to the path
+
+#### Scenario: Two tests
+- **WHEN** a student has two upcoming tests
+- **THEN** home shows the nearest one, and the other is listed on that test's card
+
+## REMOVED Requirements
+
+### Requirement: Lessons behind on home
+**Reason**: The map marks a behind lesson on its node, and the play button opens the earliest behind lesson first.
+**Migration**: None; the quiz stays on the path.

openspec/changes/game-home-lesson-rounds/tasks.md

@@ -0,0 +1,17 @@
+# Tasks
+
+## 1. Server
+
+- [x] 1.1 Migration: `lesson_round` in `m2_attempts.kind`
+- [x] 1.2 `rounds.py`: draw, start or resume, read, answer (a practice answer per question), finish with a grade; tests
+- [x] 1.3 Stars and round facts in `lesson_rows`; `/api/home` gives the map, the next lesson, the stars and the goal; tests
+
+## 2. Screens
+
+- [x] 2.1 Home as a map with a header and the play button; the behind card removed
+- [x] 2.2 The round sheet (`#/round/<lesson>`): questions with instant feedback, the result with stars
+- [x] 2.3 The path's tab reads "העמקה"; browser tests updated and added
+
+## 3. Wrap-up
+
+- [x] 3.1 Run the full suite