wzender commited on
Commit
6d82d3f
·
unverified ·
1 Parent(s): 423224a

Readiness counts deepening: the mastered share sets where it starts (#15)

Browse files

The share of the test's skills mastered closes 20% of the gap from 0; tests then pull the number up from there.

docs/tasks/prd-mathly.md CHANGED
@@ -335,13 +335,13 @@ The exercise screen is where a student practices one skill.
335
  - **GRD-2 When time ends.** Only the simulation is timed. When its timer ends it is submitted as it stands, and unanswered questions count as wrong.
336
  Leaving the screen does not stop the timer.
337
  - **RDY-1 Readiness meter.** For each upcoming test, the system shows the student (and the teacher) one **readiness number from 0 to 100**, with its level and a bar. Levels: 0–39 "מתחילים", 40–69 "בדרך", 70–84 "כמעט שם", 85–100 "מוכנים". Beside it, the app shows the points to the next level.
338
- - **RDY-2 Only tests move it.** The number changes only when a practice test or a simulation is handed in, never from the path, deepening or mastery. For each test, oldest first, when its grade is above the number:
339
 
340
  `number = number + GAIN × (grade − number)`
341
 
342
  GAIN is 0.6 for a simulation, 0.3 for a practice test and 0.15 for a manual practice test.
343
  - **RDY-3 Never down, never above the grades.** A grade at or below the number changes nothing, so the number never drops, and it can only approach the grades actually earned.
344
- - **RDY-4 The number explains itself.** The test's page says how to raise it: a practice test closes 30% of the gap, a simulation 60%, a manual one 15%; a lower grade does not lower it; only tests count.
345
  - **RDY-5 Make raising it rewarding.**
346
  - The number counts up from the last visit with a "+N" badge.
347
  - Every button to a test shows the most it can add now.
 
335
  - **GRD-2 When time ends.** Only the simulation is timed. When its timer ends it is submitted as it stands, and unanswered questions count as wrong.
336
  Leaving the screen does not stop the timer.
337
  - **RDY-1 Readiness meter.** For each upcoming test, the system shows the student (and the teacher) one **readiness number from 0 to 100**, with its level and a bar. Levels: 0–39 "מתחילים", 40–69 "בדרך", 70–84 "כמעט שם", 85–100 "מוכנים". Beside it, the app shows the points to the next level.
338
+ - **RDY-2 Deepening, then tests.** Deepening sets where the number starts: the share of the test's skills mastered (0–100) closes 20% of the gap from 0, so all of the material mastered starts it at 20. Then each handed-in practice test or simulation, oldest first, when its grade is above the number:
339
 
340
  `number = number + GAIN × (grade − number)`
341
 
342
  GAIN is 0.6 for a simulation, 0.3 for a practice test and 0.15 for a manual practice test.
343
  - **RDY-3 Never down, never above the grades.** A grade at or below the number changes nothing, so the number never drops, and it can only approach the grades actually earned.
344
+ - **RDY-4 The number explains itself.** The test's page says how to raise it: mastering the test's skills in deepening raises the start (up to 20, with how much it gives now); a practice test closes 30% of the gap, a simulation 60%, a manual one 15%; a lower grade does not lower it.
345
  - **RDY-5 Make raising it rewarding.**
346
  - The number counts up from the last visit with a "+N" badge.
347
  - Every button to a test shows the most it can add now.
mathly2/readiness.py CHANGED
@@ -1,14 +1,17 @@
1
- """The readiness number for a real test: one 0-100 number that only tests move (practice tests and simulations), never the path.
 
2
 
3
- Every handed-in test pulls the number toward its grade, and only up: a grade above the number closes part of the gap, a grade at or below
4
- it changes nothing. A simulation closes more of the gap than a practice test; a practice test on skills the student picked closes less
5
- (it can skip the hard ones). So the number is never above the best grades, and the way up is more good tests, best of all a simulation.
 
6
 
7
  number' = number + GAIN[kind] * (grade - number) when grade > number
8
  """
9
  from __future__ import annotations
10
 
11
  GAIN = {"simulation": 0.6, "practice": 0.3, "manual": 0.15}
 
12
  LEVELS = [(0, "מתחילים"), (40, "בדרך"), (70, "כמעט שם"), (85, "מוכנים")]
13
 
14
 
@@ -26,21 +29,29 @@ def step(value: float, kind: str, grade: float) -> float:
26
  return value + GAIN[kind] * (grade - value) if grade > value else value
27
 
28
 
29
- def compute(results: list[tuple[str, int]]) -> dict:
30
- """`results`: the handed-in tests of one real test, oldest first, as (kind, grade) with kind simulation, practice or manual."""
31
- value = 0.0
 
 
 
 
 
 
 
32
  for kind, grade in results:
33
  value = step(value, kind, grade)
34
  number = max(0, min(100, int(value + 0.5)))
35
  best = lambda kinds: max((g for k, g in results if k in kinds), default=None)
36
- return {"number": number, "label": label(number), "next": next_level(number),
 
37
  "practices": sum(1 for k, _ in results if k != "simulation"), "simulations": sum(1 for k, _ in results if k == "simulation"),
38
  "practice_best": best(("practice", "manual")), "simulation_best": best(("simulation",)),
39
  "can_add": {k: max(0, int(GAIN[k] * (100 - value) + 0.5)) for k in GAIN}} # what a perfect test of each kind would add now
40
 
41
 
42
- def change(before: list[tuple[str, int]], result: tuple[str, int]) -> dict:
43
  """What one handed-in test did to the number: before, after, the gain, and whether it reached a new level."""
44
- old, new = compute(before), compute([*before, result])
45
  return {"before": old["number"], "after": new["number"], "gain": new["number"] - old["number"], "label": new["label"],
46
  "level_up": new["label"] != old["label"], "next": new["next"]}
 
1
+ """The readiness number for a real test: one 0-100 number moved by deepening (the test's skills mastered in the path) and by tests
2
+ (practice tests and simulations).
3
 
4
+ Deepening comes first, as the starting point: the share of the test's skills mastered (0-100) closes 20% of the gap from 0. Then every
5
+ handed-in test, oldest first, pulls the number toward its grade, and only up: a grade above the number closes part of the gap, a grade at
6
+ or below it changes nothing. A simulation closes more of the gap than a practice test; a practice test on skills the student picked closes
7
+ less (it can skip the hard ones). Mastering more skills raises the start, and so the number, whatever tests came after.
8
 
9
  number' = number + GAIN[kind] * (grade - number) when grade > number
10
  """
11
  from __future__ import annotations
12
 
13
  GAIN = {"simulation": 0.6, "practice": 0.3, "manual": 0.15}
14
+ DEEPENING_GAIN = 0.2 # the share of the test's skills mastered pulls the start this much
15
  LEVELS = [(0, "מתחילים"), (40, "בדרך"), (70, "כמעט שם"), (85, "מוכנים")]
16
 
17
 
 
29
  return value + GAIN[kind] * (grade - value) if grade > value else value
30
 
31
 
32
+ def start(mastered_share: float | None) -> float:
33
+ """The number before any test: 20% of the share of the test's skills mastered (0-1)."""
34
+ return DEEPENING_GAIN * 100 * max(0.0, min(1.0, mastered_share or 0.0))
35
+
36
+
37
+ def compute(results: list[tuple[str, int]], mastered_share: float | None = None) -> dict:
38
+ """`results`: the handed-in tests of one real test, oldest first, as (kind, grade) with kind simulation, practice or manual.
39
+ `mastered_share`: the share (0-1) of the test's skills mastered in deepening."""
40
+ value = start(mastered_share)
41
+ deepening = int(value + 0.5)
42
  for kind, grade in results:
43
  value = step(value, kind, grade)
44
  number = max(0, min(100, int(value + 0.5)))
45
  best = lambda kinds: max((g for k, g in results if k in kinds), default=None)
46
+ return {"number": number, "label": label(number), "next": next_level(number), "deepening": deepening,
47
+ "mastered_share": round(max(0.0, min(1.0, mastered_share or 0.0)), 3),
48
  "practices": sum(1 for k, _ in results if k != "simulation"), "simulations": sum(1 for k, _ in results if k == "simulation"),
49
  "practice_best": best(("practice", "manual")), "simulation_best": best(("simulation",)),
50
  "can_add": {k: max(0, int(GAIN[k] * (100 - value) + 0.5)) for k in GAIN}} # what a perfect test of each kind would add now
51
 
52
 
53
+ def change(before: list[tuple[str, int]], result: tuple[str, int], mastered_share: float | None = None) -> dict:
54
  """What one handed-in test did to the number: before, after, the gain, and whether it reached a new level."""
55
+ old, new = compute(before, mastered_share), compute([*before, result], mastered_share)
56
  return {"before": old["number"], "after": new["number"], "gain": new["number"] - old["number"], "label": new["label"],
57
  "level_up": new["label"] != old["label"], "next": new["next"]}
mathly2/realtests.py CHANGED
@@ -109,8 +109,13 @@ def _result(request: Request, row: dict) -> dict:
109
  return attempts.result(request.app.state.bank, row)
110
 
111
 
 
 
 
 
 
112
  def readiness_for(facts: dict) -> dict:
113
- return readiness.compute(facts["results"])
114
 
115
 
116
  def readiness_change(request: Request, row: dict) -> dict | None:
@@ -123,7 +128,7 @@ def readiness_change(request: Request, row: dict) -> dict | None:
123
  return None
124
  facts = facts_for(request, row["user_id"], test, clock.school_day())
125
  before = [(_kind_of(r), r["grade"]) for r in facts["graded"] if r["submitted_at"] < row["submitted_at"]]
126
- return readiness.change(before, (_kind_of(row), row["grade"]))
127
 
128
 
129
  def _title(row: dict) -> str:
@@ -145,7 +150,7 @@ def card(request: Request, user_id: str | None, test: dict, today: date) -> dict
145
  trail.append({"attempt": row["id"], "kind": row["kind"], "title": _title(row), "grade": None, "checking": True, "gain": 0,
146
  "number": None, "after": None, "at": row["submitted_at"].isoformat()})
147
  continue
148
- moved = readiness.change(before, (_kind_of(row), row["grade"]))
149
  before.append((_kind_of(row), row["grade"]))
150
  trail.append({"attempt": row["id"], "kind": row["kind"], "title": _title(row), "grade": row["grade"], "gain": moved["gain"],
151
  "number": int(row["scope"].split(":")[1]) if row["kind"] == "exercise_test" else None,
 
109
  return attempts.result(request.app.state.bank, row)
110
 
111
 
112
+ def mastered_share(facts: dict) -> float:
113
+ """The share of the test's skills mastered (deepening counts toward readiness)."""
114
+ return facts["mastered"] / len(facts["covered"]) if facts["covered"] else 0.0
115
+
116
+
117
  def readiness_for(facts: dict) -> dict:
118
+ return readiness.compute(facts["results"], mastered_share(facts))
119
 
120
 
121
  def readiness_change(request: Request, row: dict) -> dict | None:
 
128
  return None
129
  facts = facts_for(request, row["user_id"], test, clock.school_day())
130
  before = [(_kind_of(r), r["grade"]) for r in facts["graded"] if r["submitted_at"] < row["submitted_at"]]
131
+ return readiness.change(before, (_kind_of(row), row["grade"]), mastered_share(facts))
132
 
133
 
134
  def _title(row: dict) -> str:
 
150
  trail.append({"attempt": row["id"], "kind": row["kind"], "title": _title(row), "grade": None, "checking": True, "gain": 0,
151
  "number": None, "after": None, "at": row["submitted_at"].isoformat()})
152
  continue
153
+ moved = readiness.change(before, (_kind_of(row), row["grade"]), mastered_share(facts))
154
  before.append((_kind_of(row), row["grade"]))
155
  trail.append({"attempt": row["id"], "kind": row["kind"], "title": _title(row), "grade": row["grade"], "gain": moved["gain"],
156
  "number": int(row["scope"].split(":")[1]) if row["kind"] == "exercise_test" else None,
mathly2/static/testcard.js CHANGED
@@ -13,11 +13,12 @@ const MODES = [
13
  ];
14
  const STATE = { mastered: "👑", learning: "◐", not_started: "○" };
15
 
16
- /** How the number moves, in plain words. */
17
- const HOW = `<details class="rd-how" id="rd-how"><summary>איך מעלים את המוכנות?</summary><ul>
 
 
18
  <li>כל מבחן שהציון בו גבוה מהמוכנות מעלה אותה: מבחן תרגול סוגר 30% מהפער, <b>מבחן סימולציה סוגר 60%</b>, ומבחן בבחירה ידנית 15%.</li>
19
- <li>ציון נמוך מהמוכנות לא מוריד אותה.</li>
20
- <li>רק מבחנים נספרים. תרגול במסלול ובהעמקה עוזר להצליח בהם, אבל לא משנה את המספר.</li></ul></details>`;
21
 
22
  function simulationCard(test) {
23
  const s = test.simulation, gain = test.readiness.can_add.simulation;
@@ -95,7 +96,7 @@ export async function show(view, id, focus = "") {
95
  view(`${tabs("home")}<p><a class="back" href="${homeHref()}">‹ הבית</a></p>
96
  <section class="card" id="test-card" data-test="${test.id}"><h2>מבחן ב־${shortDate(test.date)} <span class="muted">(${daysText(test.days_left)})</span></h2>
97
  <p class="muted">${test.lessons.map(l => fmt(l.name)).join(", ")}${test.note ? ` · ${esc(test.note)}` : ""}</p>
98
- ${readinessMeter(test)}${HOW}</section>
99
  ${simulationCard(test)}
100
  ${practiceCard(test)}
101
  ${trailCard(test)}
 
13
  ];
14
  const STATE = { mastered: "👑", learning: "◐", not_started: "○" };
15
 
16
+ /** How the number moves, in plain words, with what deepening gives now. */
17
+ const how = r => `<details class="rd-how" id="rd-how"><summary>איך מעלים את המוכנות?</summary><ul>
18
+ <li id="rd-deepening">העמקה נספרת: כל מיומנות מהחומר של המבחן שמגיעים בה לשליטה (👑) מעלה את נקודת ההתחלה, עד 20 נקודות כשכל החומר בשליטה.
19
+ ${r.mastered_share ? `<b>עכשיו: ${Math.round(r.mastered_share * 100)}% מהמיומנויות בשליטה, ${r.deepening} נקודות.</b>` : ""}</li>
20
  <li>כל מבחן שהציון בו גבוה מהמוכנות מעלה אותה: מבחן תרגול סוגר 30% מהפער, <b>מבחן סימולציה סוגר 60%</b>, ומבחן בבחירה ידנית 15%.</li>
21
+ <li>ציון נמוך מהמוכנות לא מוריד אותה.</li></ul></details>`;
 
22
 
23
  function simulationCard(test) {
24
  const s = test.simulation, gain = test.readiness.can_add.simulation;
 
96
  view(`${tabs("home")}<p><a class="back" href="${homeHref()}">‹ הבית</a></p>
97
  <section class="card" id="test-card" data-test="${test.id}"><h2>מבחן ב־${shortDate(test.date)} <span class="muted">(${daysText(test.days_left)})</span></h2>
98
  <p class="muted">${test.lessons.map(l => fmt(l.name)).join(", ")}${test.note ? ` · ${esc(test.note)}` : ""}</p>
99
+ ${readinessMeter(test)}${how(test.readiness)}</section>
100
  ${simulationCard(test)}
101
  ${practiceCard(test)}
102
  ${trailCard(test)}
mathly2/tests/test_home_browser.py CHANGED
@@ -489,7 +489,7 @@ def test_the_tests_page_has_three_practice_modes_and_the_trail_of_gains(browser,
489
  page.click(".mx-x")
490
  page.wait_for_selector("#practice")
491
  page.click("#rd-how summary")
492
- assert "סימולציה סוגר 60%" in page.inner_text("#rd-how") and page.errors == []
493
  no_sideways_scroll(page)
494
 
495
 
 
489
  page.click(".mx-x")
490
  page.wait_for_selector("#practice")
491
  page.click("#rd-how summary")
492
+ assert "סימולציה סוגר 60%" in page.inner_text("#rd-how") and "העמקה נספרת" in page.inner_text("#rd-deepening") and page.errors == []
493
  no_sideways_scroll(page)
494
 
495
 
mathly2/tests/test_readiness.py CHANGED
@@ -1,4 +1,4 @@
1
- """The readiness number: only tests move it, only up, a simulation more than a practice test, a picked one less."""
2
  from mathly2 import readiness
3
 
4
 
@@ -28,3 +28,13 @@ def test_change_says_the_gain_and_a_new_level():
28
  moved = readiness.change([("practice", 100)], ("simulation", 90))
29
  assert moved == {**moved, "before": 30, "after": 66, "gain": 36, "label": "בדרך", "level_up": True}
30
  assert readiness.change([("simulation", 90)], ("practice", 20))["gain"] == 0
 
 
 
 
 
 
 
 
 
 
 
1
+ """The readiness number: deepening sets where it starts; tests move it only up, a simulation more than a practice test, a picked one less."""
2
  from mathly2 import readiness
3
 
4
 
 
28
  moved = readiness.change([("practice", 100)], ("simulation", 90))
29
  assert moved == {**moved, "before": 30, "after": 66, "gain": 36, "label": "בדרך", "level_up": True}
30
  assert readiness.change([("simulation", 90)], ("practice", 20))["gain"] == 0
31
+
32
+
33
+ def test_deepening_is_the_start_and_tests_pull_from_there():
34
+ assert readiness.compute([], 0.5)["number"] == 10 # half the skills mastered: 20% of 50
35
+ assert readiness.compute([], 1.0)["number"] == 20 and readiness.compute([], 1.0)["deepening"] == 20
36
+ assert readiness.compute([("simulation", 80)], 0.5)["number"] == 52 # 10, then 60% of the way to 80
37
+ assert readiness.compute([("simulation", 80)], 1.0)["can_add"]["simulation"] == 26 # at 56, a perfect simulation adds 60% of 44
38
+ more = [readiness.compute([("practice", 70)], share)["number"] for share in (0, 0.25, 0.5, 1)]
39
+ assert more == sorted(more) and more[0] < more[-1] # more mastery never lowers it
40
+ assert readiness.change([], ("practice", 80), 1.0) == {**readiness.change([], ("practice", 80), 1.0), "before": 20, "after": 38, "gain": 18}
mathly2/tests/test_realtests_api.py CHANGED
@@ -364,17 +364,31 @@ def card_of(client, test_id, who=KID):
364
  return client.get(f"/api/tests/{test_id}", headers=auth(who)).json()
365
 
366
 
367
- def test_readiness_moves_only_with_tests_never_with_the_path(world):
368
  client, store, lessons = world
369
  test = set_test(client, lessons, days=14).json()
370
- master(store, covered(client.app.state.bank, lessons[:2])) # the whole material mastered on the path
 
 
 
 
 
371
  ready = card_of(client, test["id"])["readiness"]
372
- assert ready["number"] == 0 and ready["label"] == "מתחילים" and ready["can_add"]["simulation"] == 60
373
  finished(store, test["id"], "exercise_test", f"{test['id']}:1", 80)
374
- assert card_of(client, test["id"])["readiness"]["number"] == 24
375
  finished(store, test["id"], "simulation", str(test["id"]), 90)
376
  ready = card_of(client, test["id"])["readiness"]
377
- assert ready["number"] == 64 and ready["practice_best"] == 80 and ready["simulation_best"] == 90 and ready["simulations"] == 1
 
 
 
 
 
 
 
 
 
378
 
379
 
380
  def test_the_card_offers_three_practice_modes_simulations_and_the_trail_of_gains(world):
 
364
  return client.get(f"/api/tests/{test_id}", headers=auth(who)).json()
365
 
366
 
367
+ def test_readiness_starts_from_deepening_and_tests_pull_it_up(world):
368
  client, store, lessons = world
369
  test = set_test(client, lessons, days=14).json()
370
+ skills = covered(client.app.state.bank, lessons[:2])
371
+ assert card_of(client, test["id"])["readiness"]["number"] == 0 # nothing mastered, no test
372
+ master(store, skills[:len(skills) // 2]) # half the material mastered in deepening
373
+ half = card_of(client, test["id"])["readiness"]
374
+ assert half["number"] == round(20 * (len(skills) // 2) / len(skills)) and half["deepening"] == half["number"]
375
+ master(store, skills) # all of it: 20% of the way from 0
376
  ready = card_of(client, test["id"])["readiness"]
377
+ assert ready["number"] == 20 and ready["deepening"] == 20 and ready["label"] == "מתחילים" and ready["can_add"]["simulation"] == 48
378
  finished(store, test["id"], "exercise_test", f"{test['id']}:1", 80)
379
+ assert card_of(client, test["id"])["readiness"]["number"] == 38 # 20 + 30% of (80 - 20)
380
  finished(store, test["id"], "simulation", str(test["id"]), 90)
381
  ready = card_of(client, test["id"])["readiness"]
382
+ assert ready["number"] == 69 and ready["practice_best"] == 80 and ready["simulation_best"] == 90 and ready["simulations"] == 1
383
+
384
+
385
+ def test_mastering_more_after_the_tests_still_raises_the_number(world):
386
+ client, store, lessons = world
387
+ test = set_test(client, lessons, days=14).json()
388
+ finished(store, test["id"], "exercise_test", f"{test['id']}:1", 60)
389
+ assert card_of(client, test["id"])["readiness"]["number"] == 18 # 30% of 60
390
+ master(store, covered(client.app.state.bank, lessons[:2]))
391
+ assert card_of(client, test["id"])["readiness"]["number"] == 32 # 20, then 20 + 30% of (60 - 20)
392
 
393
 
394
  def test_the_card_offers_three_practice_modes_simulations_and_the_trail_of_gains(world):
mathly2/tests/test_writtentest_api.py CHANGED
@@ -93,7 +93,7 @@ def test_after_handing_in_it_waits_for_the_check_and_the_ai_sets_the_grade():
93
  assert got["checking"] is False and got["grade"] == attempts.percent(3, 2 * n) # 1 + ½ points of n
94
  assert got["right"] == 1 and len(got["missed"]) == n - 1
95
  assert got["missed"][0]["points"] == 0.5 and got["missed"][-1]["no_work"] is True
96
- assert '"right"' not in json.dumps(got["missed"]) and first["right"] not in json.dumps(got, ensure_ascii=False)
97
 
98
 
99
  def test_without_the_ai_it_waits_for_the_teacher_whose_points_are_final():
 
93
  assert got["checking"] is False and got["grade"] == attempts.percent(3, 2 * n) # 1 + ½ points of n
94
  assert got["right"] == 1 and len(got["missed"]) == n - 1
95
  assert got["missed"][0]["points"] == 0.5 and got["missed"][-1]["no_work"] is True
96
+ assert all(set(m) == {"skill_id", "skill_name", "question", "picked", "points", "no_work", "mistake"} for m in got["missed"]) # never the right answer
97
 
98
 
99
  def test_without_the_ai_it_waits_for_the_teacher_whose_points_are_final():
openspec/changes/readiness-counts-deepening/proposal.md ADDED
@@ -0,0 +1,24 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ # Proposal
2
+
3
+ ## Why
4
+
5
+ A student who masters the test's material in deepening is more ready, but the readiness number ignored it: only tests moved it. The teacher
6
+ wants deepening to count too, while tests stay the main way up.
7
+
8
+ ## What Changes
9
+
10
+ - The share of the test's skills mastered sets where the number starts: it closes 20% of the gap from 0 (all of the material mastered starts it at 20).
11
+ - Tests then pull it up as before (a practice test 30% of the gap, a simulation 60%, a manual one 15%), and a lower grade never lowers it.
12
+ - Mastering more skills after the tests still raises the number.
13
+ - The test's page explains it, with what deepening gives now.
14
+
15
+ ## Capabilities
16
+
17
+ ### New Capabilities
18
+
19
+ ### Modified Capabilities
20
+ - `readiness-meter`: deepening counts as the starting point.
21
+
22
+ ## Impact
23
+
24
+ - `readiness.py` (the start and its share), `realtests.py` (the share of the test's skills mastered), `static/testcard.js` (the explanation). PRD RDY-2, RDY-4.
openspec/changes/readiness-counts-deepening/specs/readiness-meter/spec.md ADDED
@@ -0,0 +1,12 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ ## ADDED Requirements
2
+
3
+ ### Requirement: Deepening counts
4
+ The readiness number SHALL start from deepening: the share of the test's skills the student has mastered, from 0 to 100, closes 20% of the gap from 0. The handed-in tests SHALL then move it from there, oldest first, as before, so mastering more skills raises the number whatever tests came after, and the test's page SHALL say how much deepening gives now.
5
+
6
+ #### Scenario: Half the material
7
+ - **WHEN** a student has mastered half of the test's skills and taken no test
8
+ - **THEN** the readiness number is 10
9
+
10
+ #### Scenario: Then a simulation
11
+ - **WHEN** that student hands in a simulation with 80
12
+ - **THEN** the number is 52 (10, then 60% of the way to 80)
openspec/changes/readiness-counts-deepening/tasks.md ADDED
@@ -0,0 +1,5 @@
 
 
 
 
 
 
1
+ # Tasks
2
+
3
+ - [x] 1.1 Start the number from the share of the test's skills mastered (`readiness.py`, `realtests.py`). Verify with `test_readiness.py` and `test_realtests_api.py`.
4
+ - [x] 1.2 Explain it on the test's page with what deepening gives now (`testcard.js`). Verify with the browser test of the explanation.
5
+ - [x] 1.3 Update the PRD (RDY-2, RDY-4). Verify that `openspec validate readiness-counts-deepening --strict` passes.