Home lists every lesson behind the curriculum with two ways to catch up; archive add-behind-lessons-to-home

docs/tasks/prd-mathly.md

@@ -387,7 +387,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, 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 and today's task (TST-3), a required simulation, 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** shows only what is critical: the nearest test's reminder with its readiness and today's task (TST-3), a required simulation, **every lesson behind the curriculum** (PTH-11; earliest date first, each with its two ways to finish it: all its skills mastered, shown as "N מתוך M מיומנויות" and opening the next skill, or its quiz passed with at least 13 of 15, PTH-10, opening the quiz with the best grade so far), 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-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/realtests.py

@@ -255,8 +255,8 @@ def home(request: Request, user: dict = Depends(learner)) -> dict:
     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
-    here.prefetch(("tests_of_classes", class_ids), ("recent_skills", uid, RECENT), *_student_reads(uid))       # the tests and the student's facts: one wait
+    from .skills import RECENT, behind_lessons
+    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
     tests = [t for t in here.tests_of_classes(class_ids) if t["date"] >= today]
     cards = [card(request, user["id"], t, today) for t in tests]
     nearest = cards[0] if cards else None
@@ -264,7 +264,8 @@ def home(request: Request, user: dict = Depends(learner)) -> dict:
     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"]],
-            "next_skill": {"id": next_id, "name": next_skill_row["name"]} if next_skill_row else None}
+            "next_skill": {"id": next_id, "name": next_skill_row["name"]} if next_skill_row else None,
+            "behind": behind_lessons(request, user)}
 
 
 def _student_test(request: Request, user: dict, test_id: int) -> dict:

mathly2/skills.py

@@ -8,7 +8,7 @@ import logging
 from fastapi import APIRouter, Depends, HTTPException, Request
 from pydantic import BaseModel
 
-from . import clock, comets, quiz, reads
+from . import attempts, clock, comets, quiz, reads
 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)
@@ -211,10 +211,11 @@ def _comet_due(request: Request, user_id: str, today_now: dict, state: dict | No
     return True
 
 
-@router.get("/path")
-def path(request: Request, user: dict = Depends(learner)) -> dict:
+def lesson_rows(request: Request, user: dict) -> tuple[list[dict], list[str], dict]:
+    """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), ("daily_correct", uid), ("recent_skills", uid, RECENT), ("attempts_of", uid, "quiz"), ("curriculum",))
+    here.prefetch(("progress_of", uid), ("last_answered", uid), ("attempts_of", uid, "quiz"), ("curriculum",))
     states = {p["skill_id"]: skill_state(p) for p in here.progress_of(uid)}
     last, today = here.last_answered(uid), clock.school_day()
     quizzes_facts = quiz.facts(store, request.app.state.bank, uid, clock.now(), here)
@@ -236,6 +237,29 @@ def path(request: Request, user: dict = Depends(learner)) -> dict:
                         "completed": completed, "passed": passed, "due_date": due.isoformat() if due else None,
                         "behind": bool(due and due < today and not completed),
                         "quiz": {"best": fact.get("best"), "open": bool(fact.get("open")), "due_at": fact["open"]["due_at"].isoformat() if fact.get("open") else None}})
+    return lessons, order, states
+
+
+def behind_lessons(request: Request, user: dict) -> list[dict]:
+    """The lessons behind the curriculum for the home, the earliest date first: how far the skills are and the next unmastered one, and the quiz."""
+    lessons, _, _ = lesson_rows(request, user)
+    rows = []
+    for l in lessons:
+        if not l["behind"]:
+            continue
+        nxt = next((s for s in l["skills"] if s["state"] != MASTERED), None)
+        rows.append({"id": l["id"], "name": l["name"], "due_date": l["due_date"], "mastered": l["mastered"], "total": len(l["skills"]),
+                     "next_skill": {"id": nxt["id"], "name": nxt["name"]} if nxt else None,
+                     "quiz": {"best": l["quiz"]["best"], "open": l["quiz"]["open"], "pass_right": attempts.PASS_RIGHT, "size": attempts.QUIZ_SIZE}})
+    return sorted(rows, key=lambda r: (r["due_date"], r["id"]))
+
+
+@router.get("/path")
+def path(request: Request, user: dict = Depends(learner)) -> dict:
+    here, uid = reads.of(request), user["id"]
+    here.prefetch(("progress_of", uid), ("last_answered", uid), ("daily_correct", uid), ("recent_skills", uid, RECENT), ("attempts_of", uid, "quiz"), ("curriculum",))
+    lessons, order, states = lesson_rows(request, user)
+    today = clock.school_day()
     daily = here.daily_correct(uid)
     return {"lessons": lessons, "behind": sum(1 for l in lessons if l["behind"]), "next": next_skill(order, states, here.recent_skills(uid, RECENT)),
             "today": today_progress(daily, today), "streak": streak(daily, today)}

mathly2/static/app.css

@@ -478,3 +478,8 @@ ul.students li [dir="ltr"] { overflow-wrap: anywhere; min-width: 0; }
 .review-card.done { opacity: .75; border-color: var(--sky-gold); }
 .review-card .ex-text { margin: 4px 0 8px; }
 .review-group [hidden] { display: none; }        /* the heading's flex layout would otherwise show it */
+/* The lessons behind the curriculum, on the home */
+.behind-list li { border-top: 1px solid var(--line); padding: 8px 0; }
+.behind-list li:first-child { border-top: 0; }
+.behind-list .late { color: var(--sky-danger); font-weight: 600; }
+.behind-list .actions { display: flex; flex-wrap: wrap; gap: 8px; margin: 6px 0; }

mathly2/static/home.js

@@ -66,6 +66,16 @@ function assignmentsCard(all) {
   }).join("")}</ul></section>`;
 }
 
+/** Every lesson behind the curriculum, with the two ways to finish it (PTH-10): all its skills, or its quiz with at least 13 of 15. */
+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 data-lesson="${esc(l.id)}"><p><b>${fmt(l.name)}</b><br><span class="late">⚠ היה אמור להסתיים ב־${shortDate(l.due_date)}</span></p>
+      <p class="actions">${l.next_skill ? `<a class="button" data-way="skills" href="#/skill/${encodeURIComponent(l.next_skill.id)}">לסיים את המיומנויות: ${l.mastered} מתוך ${l.total}</a>` : ""}
+        <a class="button" data-way="quiz" href="#/quiz/${encodeURIComponent(l.id)}">${l.quiz.open ? "להמשיך את הבוחן" : "בוחן"}: לפחות ${l.quiz.pass_right} מתוך ${l.quiz.size}</a></p>
+      <p class="muted" data-best>${l.quiz.best === null ? "עוד לא נעשה בוחן" : `הציון הטוב ביותר בבוחן: ${l.quiz.best}`}</p></li>`).join("")}</ul></section>`;
+}
+
 /** The photo help card (STU-6): only for a class with the AI on; it also lists the student's latest requests with their state. */
 function aiCard(ai) {
   if (!ai?.on) return "";
@@ -84,7 +94,7 @@ function draw(view, data, assignments, ai) {
   view(`${tabs("home")}${backToSubjects()}
     ${first ? nearest(first, data.task, data.next_skill) : `<section class="card" id="no-test"><h2>הבית</h2>
       <p class="muted">המורה עוד לא קבע מבחן. בינתיים אפשר להמשיך במסלול.</p></section>`}
-    ${assignmentsCard(assignments)}${aiCard(ai)}
+    ${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="${PATH}">למסלול: כל הכוכבים פתוחים לתרגול <span aria-hidden="true">‹</span></a>`}</p>`);

mathly2/tests/test_behind_home_api.py

@@ -0,0 +1,66 @@
+"""Lessons behind the curriculum on the home (add-behind-lessons-to-home 1.1)."""
+from datetime import timedelta
+
+from mathly2 import clock
+from mathly2.tests.test_quizzes_api import take
+from mathly2.tests.test_skills_api import KID, KID_ID, MON, auth, raw, world  # noqa: F401
+
+STAMP = "2026-10-05T10:00:00+00:00"
+
+
+def behind(client):
+    return client.get("/api/home", headers=auth()).json()["behind"]
+
+
+def skills_of(bank, lesson):
+    return [s["id"] for s in bank.skills if s["unit"] == lesson]
+
+
+def test_every_lesson_behind_is_listed_earliest_date_first_and_others_are_not(world):
+    client, store, bank = world
+    today = clock.school_day()
+    store.set_lesson_dates({"t": today - timedelta(days=2), "t2": today - timedelta(days=9), "k": today + timedelta(days=5), "i": today})      # t2 and t behind; k ahead; i is due today
+    got = behind(client)
+    assert [r["id"] for r in got] == ["t2", "t"] and got[0]["due_date"] == (today - timedelta(days=9)).isoformat()
+    assert all(r["name"] for r in got)
+    for s in skills_of(bank, "t2"):
+        store.save_progress(KID_ID, s, started_at=STAMP, mastered_at=STAMP)
+    assert [r["id"] for r in behind(client)] == ["t"]                                                          # completed: no longer listed
+
+
+def test_a_lesson_without_a_date_is_never_listed_and_none_behind_means_an_empty_list(world):
+    client, store, bank = world
+    assert behind(client) == []
+    store.set_lesson_dates({"k": clock.school_day() + timedelta(days=3)})
+    assert behind(client) == []
+
+
+def test_the_skills_option_says_how_far_and_opens_the_next_unmastered_skill(world):
+    client, store, bank = world
+    store.set_lesson_dates({"t": clock.school_day() - timedelta(days=1)})
+    skills = skills_of(bank, "t")
+    for s in skills[:3]:
+        store.save_progress(KID_ID, s, started_at=STAMP, mastered_at=STAMP)
+    row = behind(client)[0]
+    assert (row["mastered"], row["total"]) == (3, len(skills)) and row["next_skill"]["id"] == skills[3] and row["next_skill"]["name"]
+    store.save_progress(KID_ID, skills[1], mastered_at=None)                                                    # a skill not mastered in the middle comes first
+    assert behind(client)[0]["next_skill"]["id"] == skills[1]
+
+
+def test_the_quiz_option_shows_the_best_grade_and_what_is_needed_and_a_pass_catches_the_lesson_up(world):
+    client, store, bank = world
+    store.set_lesson_dates({"t": clock.school_day() - timedelta(days=1)})
+    assert behind(client)[0]["quiz"] == {"best": None, "open": False, "pass_right": 13, "size": 15}
+    take(client, bank, "t", [True] * 12 + [False] * 3)                                                         # 80
+    quiz = behind(client)[0]["quiz"]
+    assert quiz["best"] == 80 and quiz["pass_right"] == 13 and quiz["size"] == 15
+    take(client, bank, "t", [True] * 13 + [False] * 2)                                                         # passed
+    assert behind(client) == []
+
+
+def test_the_path_and_the_home_agree_on_what_is_behind(world):
+    client, store, bank = world
+    today = clock.school_day()
+    store.set_lesson_dates({"t": today - timedelta(days=4), "t2": today - timedelta(days=1)})
+    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

mathly2/tests/test_behind_home_browser.py

@@ -0,0 +1,71 @@
+"""The card of lessons behind the curriculum on the home (add-behind-lessons-to-home 2.1), in a real browser."""
+from datetime import datetime, timedelta, timezone
+
+import pytest
+
+playwright = pytest.importorskip("playwright.sync_api")
+
+from mathly2 import clock
+from mathly2.tests.serve import running
+from mathly2.tests.test_home_browser import KID_ID, PHONE, bank, browser, no_sideways_scroll, sign_in, to_home, world  # noqa: F401
+
+STAMP = "2026-10-05T10:00:00+00:00"
+
+
+def seed(app, store, bank, lessons):
+    today = clock.school_day()
+    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_with_both_ways_to_finish(browser, bank):
+    app, store, klass, lessons = world(bank)
+    seed(app, store, bank, lessons)
+    skills = [s["id"] for s in bank.skills if s["unit"] == lessons[0]]
+    store.save_progress(KID_ID, skills[0], started_at=STAMP, mastered_at=STAMP)
+    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 "היה אמור להסתיים ב־" in rows.nth(0).inner_text()
+        mine = page.locator(f"#behind-card li[data-lesson='{lessons[0]}']")
+        assert f"1 מתוך {len(skills)}" in mine.locator("[data-way=skills]").inner_text() and mine.locator("[data-way=skills]").get_attribute("href") == f"#/skill/{skills[1]}"
+        assert "לפחות 13 מתוך 15" in mine.locator("[data-way=quiz]").inner_text() and mine.locator("[data-way=quiz]").get_attribute("href") == f"#/quiz/{lessons[0]}"
+        assert "עוד לא נעשה בוחן" in mine.locator("[data-best]").inner_text()
+        no_sideways_scroll(page)
+        assert not page.errors
+
+
+def test_the_best_quiz_grade_shows_and_the_links_open_the_skill_and_the_quiz(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")
+        assert "הציון הטוב ביותר בבוחן: 80" in page.inner_text(f"#behind-card li[data-lesson='{lessons[0]}'] [data-best]")
+        page.click(f"#behind-card li[data-lesson='{lessons[1]}'] [data-way=skills]")
+        page.wait_for_selector(".mx-sheet")
+        assert page.evaluate("location.hash").startswith("#/skill/")
+
+
+def test_no_card_when_no_lesson_is_behind_or_when_it_was_passed(browser, bank):
+    app, store, klass, lessons = world(bank)
+    store.set_lesson_dates({lessons[0]: clock.school_day() + timedelta(days=5)})
+    with running(app) as url:
+        page = sign_in(browser, url)
+        to_home(page)
+        page.wait_for_selector("#continue-path")
+        assert page.locator("#behind-card").count() == 0
+    app, store, klass, lessons = world(bank)
+    store.set_lesson_dates({lessons[0]: clock.school_day() - timedelta(days=1)})
+    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=87)                   # 13 of 15: passed
+    with running(app) as url:
+        page = sign_in(browser, url)
+        to_home(page)
+        page.wait_for_selector("#continue-path")
+        assert page.locator("#behind-card").count() == 0

openspec/changes/archive/2026-11-09-add-behind-lessons-to-home/.openspec.yaml

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

openspec/changes/archive/2026-11-09-add-behind-lessons-to-home/proposal.md

@@ -0,0 +1,20 @@
+# Proposal
+
+## Why
+
+A student who is behind the curriculum sees it only as a small mark on the path. Being behind is critical, so the home should say which lessons are behind and offer the two ways to catch up.
+
+## What Changes
+
+- **Home lists every lesson that is behind the curriculum** (its date has passed and it is not completed), the earliest date first, in a card "שיעורים בפיגור".
+- **Each lesson offers two ways to finish it** (PTH-10): finish all its skills ("N מתוך M מיומנויות", opening the next unmastered skill), or pass its בוחן with at least 13 right out of 15 (opening the quiz, showing the best grade so far).
+- A lesson that is completed, has no date or whose date is ahead is not listed, and with no lesson behind there is no card.
+
+## Capabilities
+
+### Modified Capabilities
+- `student-home`: "Home shows only what is critical", and a new "Lessons behind on home".
+
+## Impact
+
+- `GET /api/home` gains the behind lessons (the path's lesson facts are shared, not computed twice); `home.js`; PRD STU-1. No database change.

openspec/changes/archive/2026-11-09-add-behind-lessons-to-home/specs/student-home/spec.md

@@ -0,0 +1,40 @@
+## MODIFIED Requirements
+
+### Requirement: Home shows only what is critical
+The home SHALL show only: the nearest test with its readiness and today's task, a required simulation, the lessons behind the curriculum, the new assignments (not handed in yet), and the button that continues 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, no new assignment and no lesson behind
+- **THEN** home shows only the button that continues 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
+
+## ADDED Requirements
+
+### Requirement: Lessons behind on home
+Home SHALL list every lesson behind the curriculum, the earliest date first, with its name and the date it should have been completed by. A completed lesson, a lesson with no date and a lesson whose date is ahead SHALL NOT be listed, and with none behind there SHALL be no such card.
+
+#### Scenario: Two lessons behind
+- **WHEN** two lessons have passed their dates and are not completed
+- **THEN** home lists both, the one with the earlier date first
+
+#### Scenario: Caught up
+- **WHEN** a student passes the בוחן of a lesson that was behind
+- **THEN** the lesson is no longer listed on home
+
+#### Scenario: None behind
+- **WHEN** no lesson is behind
+- **THEN** home has no behind card
+
+### Requirement: Two ways to catch up
+Each lesson listed as behind SHALL offer two ways to finish it: all its skills mastered, shown as "N מתוך M מיומנויות" and opening its next unmastered skill; or its בוחן passed with at least 13 right out of 15, opening the בוחן and showing the best grade so far.
+
+#### Scenario: Skills
+- **WHEN** a student has mastered 3 of 5 skills of a lesson that is behind
+- **THEN** its row says "3 מתוך 5 מיומנויות" and the skills option opens the first skill not mastered
+
+#### Scenario: The בוחן
+- **WHEN** the student's best grade in that lesson's בוחן is 80
+- **THEN** the row shows 80 and says that 13 right out of 15 is needed

openspec/changes/archive/2026-11-09-add-behind-lessons-to-home/tasks.md

@@ -0,0 +1,13 @@
+# Tasks
+
+## 1. The data
+
+- [x] 1.1 Share the path's lesson facts with home and add the behind lessons to `GET /api/home` (name, date, mastered and total skills, the next unmastered skill, the בוחן's best grade and whether one is open), earliest date first; verify API tests for every scenario of "Lessons behind on home", and a timing test that home needs no more waits in a row than before
+
+## 2. The screen
+
+- [x] 2.1 Show the card "שיעורים בפיגור" on home with the two options per lesson; verify Playwright tests: the card lists the lessons in date order with both options and the links open the next skill and the בוחן, the best grade and "13 מתוך 15" show, no card when none is behind, no sideways scrolling at 360px
+
+## 3. Wrap-up
+
+- [x] 3.1 Update the PRD (STU-1); run the full suite and `openspec validate add-behind-lessons-to-home --strict`; verify both pass

openspec/specs/student-home/spec.md

@@ -38,12 +38,38 @@ The student's screens (home, path, submissions "הגשות", grades, collection)
 - **THEN** the submissions screen opens
 
 ### Requirement: Home shows only what is critical
-The home SHALL show only: the nearest test with its readiness and today's task, a required simulation, the new assignments (not handed in yet), and the button that continues 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.
+The home SHALL show only: the nearest test with its readiness and today's task, a required simulation, the lessons behind the curriculum, the new assignments (not handed in yet), and the button that continues 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
+- **WHEN** a student has no upcoming test, no new assignment and no lesson behind
 - **THEN** home shows only the button that continues 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
+
+### Requirement: Lessons behind on home
+Home SHALL list every lesson behind the curriculum, the earliest date first, with its name and the date it should have been completed by. A completed lesson, a lesson with no date and a lesson whose date is ahead SHALL NOT be listed, and with none behind there SHALL be no such card.
+
+#### Scenario: Two lessons behind
+- **WHEN** two lessons have passed their dates and are not completed
+- **THEN** home lists both, the one with the earlier date first
+
+#### Scenario: Caught up
+- **WHEN** a student passes the בוחן of a lesson that was behind
+- **THEN** the lesson is no longer listed on home
+
+#### Scenario: None behind
+- **WHEN** no lesson is behind
+- **THEN** home has no behind card
+
+### Requirement: Two ways to catch up
+Each lesson listed as behind SHALL offer two ways to finish it: all its skills mastered, shown as "N מתוך M מיומנויות" and opening its next unmastered skill; or its בוחן passed with at least 13 right out of 15, opening the בוחן and showing the best grade so far.
+
+#### Scenario: Skills
+- **WHEN** a student has mastered 3 of 5 skills of a lesson that is behind
+- **THEN** its row says "3 מתוך 5 מיומנויות" and the skills option opens the first skill not mastered
+
+#### Scenario: The בוחן
+- **WHEN** the student's best grade in that lesson's בוחן is 80
+- **THEN** the row shows 80 and says that 13 right out of 15 is needed