fix math

app/answer_routes.py

@@ -63,7 +63,7 @@ def install_answer_routes(app, signed_in):
     @app.post("/api/math/answer-attempts")
     def resume_attempt(body: dict, user=Depends(student)):
         question = next((s for s in algebra9()["skills"] if s["id"] == body.get("question_id")), None)
-        if not question or question["sample"].get("type") != "open-ended":
+        if not question or question.get("sample", {}).get("type") != "open-ended":
             raise ScanError(404, "not_found")
         sample = question["sample"]
         version = question_version(sample)

app/main.py

@@ -33,8 +33,11 @@ load_dotenv(ROOT / ".env")
 
 
 def units_of(row: dict) -> list[str]:
-    known = [unit["id"] for unit in algebra9()["units"]]
+    """A class's units. A unit split off an older one (its `from`) comes with it, so saved classes keep their content."""
+    units = algebra9()["units"]
+    known = [unit["id"] for unit in units]
     selected = set(row.get("lessons") or known)
+    selected |= {unit["id"] for unit in units if selected & set(unit.get("from", []))}
     return [unit for unit in known if unit in selected]
 
 

app/math_skills.py

@@ -1,11 +1,12 @@
 """The 9th-grade algebra skill graph for the math path (`math_algebra9.json`).
 
-Each skill names its prerequisites and a sample question. Choice samples identify mistakes;
-open-ended samples name their type and revision and accept a photographed answer.
+Each skill names its prerequisites and either one `sample` question or a list of multiple-choice `questions`.
+Choice samples identify mistakes; open-ended samples name their type and revision and accept a photographed answer.
 A mistake sends the student back to the skill it comes from (`back`), or keeps them on the same skill (`null`).
-The units follow the Ministry of Education's 9th-grade teaching schedule for 2026/27 (`docs/prisa_9A.md`), with
-ten skills in each; `month` is when the schedule teaches a skill. The questions are written for the app, and
-every skill, link and mistake still needs a teacher's review.
+The units follow the Ministry of Education's 9th-grade teaching schedule for 2026/27 (`docs/prisa_9A.md`).
+Units already split by the schedule's topics (טכניקה אלגברית, פונקציה ריבועית) have ten questions per skill;
+the other units still have ten skills with one question each. `month` is when the schedule teaches a skill.
+The questions are written for the app, and every skill, link and mistake still needs a teacher's review.
 
 `problems` is run by the tests and on loading: a broken graph is refused before a student meets it.
 """
@@ -26,6 +27,43 @@ def question_version(sample: dict) -> str:
                                     separators=(",", ":")).encode()).hexdigest()
 
 
+def questions(skill: dict) -> list[dict]:
+    """A skill's questions: its list of questions, or its one sample."""
+    return skill["questions"] if "questions" in skill else [skill["sample"]]
+
+
+def sample_problems(where: str, sid: str, sample: dict, listed: bool, mistakes: dict, below: dict) -> list[str]:
+    kind = sample.get("type", "multiple-choice")
+    if kind not in ("open-ended", "multiple-choice"):
+        return [f"{where}: unknown question type {kind}"]
+    if kind == "open-ended":
+        if listed:
+            return [f"{where}: a question list holds multiple-choice questions only"]
+        out = []
+        if "choices" in sample:
+            out.append(f"{where}: open-ended questions cannot have choices")
+        if not isinstance(sample.get("question"), str) or not sample["question"].strip():
+            out.append(f"{where}: question text is required")
+        if type(sample.get("version")) is not int or sample["version"] < 1:
+            out.append(f"{where}: positive question version is required")
+        return out
+    out = []
+    choices = sample.get("choices", [])
+    if sum(bool(c.get("correct")) for c in choices) != 1:
+        out.append(f"{where}: needs exactly one correct choice")
+    if len({c["text"] for c in choices}) != len(choices):
+        out.append(f"{where}: two choices read the same")
+    for c in choices:
+        m = c.get("mistake")
+        if c.get("correct"):
+            continue
+        if m not in mistakes:
+            out.append(f"{where}: unknown mistake {m}")
+        elif (back := mistakes[m]["back"]) and back != sid and back not in below[sid]:
+            out.append(f"{where}: mistake {m} sends back to {back}, which is not before it")
+    return out
+
+
 def problems(graph: dict) -> list[str]:
     """What is wrong with a graph: unknown units, skills or mistakes, a cycle, a link implied by another,
     a question without exactly one right answer, or a mistake that sends the student to a skill that is not before it."""
@@ -53,32 +91,16 @@ def problems(graph: dict) -> list[str]:
         return [f"cycle: {cycle}"]
     for s in skills.values():
         out += [f"{s['id']}: {p} is implied by {q}" for p in s["prereqs"] for q in s["prereqs"] if p != q and p in below[q]]
-        sample = s["sample"]
-        kind = sample.get("type", "multiple-choice")
-        if kind not in ("open-ended", "multiple-choice"):
-            out.append(f"{s['id']}: unknown question type {kind}")
+        if ("questions" in s) == ("sample" in s):
+            out.append(f"{s['id']}: needs a sample or a list of questions, not both")
             continue
-        if kind == "open-ended":
-            if "choices" in sample:
-                out.append(f"{s['id']}: open-ended questions cannot have choices")
-            if not isinstance(sample.get("question"), str) or not sample["question"].strip():
-                out.append(f"{s['id']}: question text is required")
-            if type(sample.get("version")) is not int or sample["version"] < 1:
-                out.append(f"{s['id']}: positive question version is required")
+        listed = "questions" in s
+        if listed and (not isinstance(s["questions"], list) or not s["questions"]):
+            out.append(f"{s['id']}: the question list is empty")
             continue
-        choices = sample.get("choices", [])
-        if sum(bool(c.get("correct")) for c in choices) != 1:
-            out.append(f"{s['id']}: needs exactly one correct choice")
-        if len({c["text"] for c in choices}) != len(choices):
-            out.append(f"{s['id']}: two choices read the same")
-        for c in choices:
-            m = c.get("mistake")
-            if c.get("correct"):
-                continue
-            if m not in mistakes:
-                out.append(f"{s['id']}: unknown mistake {m}")
-            elif (back := mistakes[m]["back"]) and back != s["id"] and back not in below[s["id"]]:
-                out.append(f"{s['id']}: mistake {m} sends back to {back}, which is not before it")
+        for n, sample in enumerate(questions(s), 1):
+            out += sample_problems(f"{s['id']} question {n}" if listed else s["id"], s["id"], sample, listed,
+                                   mistakes, below)
     out += [f"mistake {k}: unknown skill {m['back']}" for k, m in mistakes.items() if m["back"] and m["back"] not in skills]
     return out
 
@@ -98,9 +120,12 @@ def practice_graph(answer_scans_enabled: bool) -> dict:
     The original choice sample is served when authenticated storage is disabled.
     """
     graph = copy.deepcopy(algebra9())
+    subject = {unit["id"]: unit["subject"] for unit in graph["units"]}
     for skill in graph["skills"]:
+        skill["subject"] = subject[skill["unit"]]   # a subunit belongs to its unit's subject
         fallback = skill.pop("fallback_sample", None)
         if not answer_scans_enabled and fallback is not None:
             skill["sample"] = fallback
-        skill["question_version"] = question_version(skill["sample"])
+        if "sample" in skill:   # identifies an open-ended question's uploaded answers
+            skill["question_version"] = question_version(skill["sample"])
     return graph

static/math.css

@@ -20,6 +20,9 @@ html.math-on, html.math-on body{overflow:hidden}
 #mathView .u-a{--uc:var(--u-a)} #mathView .u-z{--uc:var(--u-z)} #mathView .u-r{--uc:var(--u-r)} #mathView .u-h{--uc:var(--u-h)}
 #mathView .u-s{--uc:var(--u-s)} #mathView .u-m{--uc:var(--u-m)} #mathView .u-n{--uc:var(--u-n)} #mathView .u-p{--uc:var(--u-p)}
 #mathView .u-w{--uc:var(--u-w)} #mathView .u-d{--uc:var(--u-d)}
+/* units split off an older unit keep its colour */
+#mathView .u-i{--uc:var(--u-k)} #mathView .u-l,#mathView .u-o{--uc:var(--u-a)} #mathView .u-v{--uc:var(--u-e)}
+#mathView .u-g{--uc:var(--u-z)} #mathView .u-b,#mathView .u-c{--uc:var(--u-m)}
 #mathView h1,#mathView h2,#mathView h3{font-family:var(--f-display);font-weight:400;margin:0;text-wrap:balance}
 #mathView button{font-family:var(--f-body)}
 #mathView button:focus-visible{outline:3px solid var(--mx-accent);outline-offset:2px}
@@ -253,3 +256,18 @@ html.math-on, html.math-on body{overflow:hidden}
 .mx-grade h4,.mx-grade p{margin:0}.mx-grade-correct{border-color:var(--ok);background:var(--ok-bg)}
 .mx-grade summary{cursor:pointer;color:var(--mx-accent)}.mx-grade details p{margin-top:10px}
 .mx-grade-solution{white-space:pre-wrap}.mx-grade small{color:var(--muted)}
+.mx-qprog{display:flex;justify-content:space-between;align-items:center;gap:10px;font-size:13px;color:var(--muted)}
+.mx-qdots{display:flex;gap:4px;flex-wrap:wrap}
+.mx-qdots i{width:9px;height:9px;border-radius:50%;background:var(--line)}
+.mx-qdots i.ok{background:var(--ok)}
+.mx-qdots i.now{outline:2px solid var(--mx-accent);outline-offset:1px}
+.mx-count{font:700 11px/1 var(--f-body);padding:4px 7px;border-radius:999px;background:var(--bg);color:var(--muted)}
+.mx-content-subject{display:flex;flex-direction:column;gap:8px;margin-top:14px}
+.mx-content-subject>h5{display:flex;align-items:baseline;gap:8px;margin:0;font-size:18px;color:var(--exam,var(--mx-accent))}
+.mx-content-subject>h5 small{color:var(--muted);font-size:13px;font-weight:500}
+.mx-content-unit{border:1px solid var(--line);border-radius:12px;background:var(--bg)}
+.mx-content-unit summary{display:flex;flex-direction:column;gap:3px;padding:12px;cursor:pointer}
+.mx-content-unit summary small,.mx-content-unit li small{color:var(--muted);font-size:12px}
+.mx-content-unit ol{margin:0;padding:0 34px 12px 12px;display:flex;flex-direction:column;gap:8px}
+.mx-content-unit li span{display:block}
+.mx-pick-subject{margin:10px 0 6px;font-size:14px;color:var(--mx-accent)}

static/math.js

@@ -2,8 +2,10 @@
    The skill graph comes from /api/math/skills (app/math_skills.py). A skill is open once every skill it needs is
    done, and the first open one is where the student goes on. A student may still open a locked skill: without a
    placement test, one who already knows the foundations should not have to answer them first.
-   Each skill has one sample question, and answering it correctly marks the skill done. Progress is kept on
-   this device, per account (mathly.progress.v1:<email>). */
+   A skill has one sample question or a list of questions. It is done once every one of its questions has been
+   answered correctly; after each answer the student moves to the next unsolved question, so a missed question comes
+   back after the others. Progress is kept on this device, per account (mathly.progress.v1:<email>): `done` per
+   skill, and `solved` (indexes answered correctly) and `at` (the question to show) for skills with a list. */
 (()=>{
 const css=document.createElement("link"); css.rel="stylesheet"; css.href=document.currentScript.src.replace("math.js","math.css");
 document.head.append(css);
@@ -23,7 +25,7 @@ const key=()=>"mathly.progress.v1:"+(ME_EMAIL||"guest");
 const load=()=>{ try{ return JSON.parse(localStorage.getItem(key())||"{}"); }catch{ return {}; } };
 const save=()=>{ try{ localStorage.setItem(key(),JSON.stringify(P)); }catch{} };
 
-let G=null, BY={}, POST={}, DEPTH={}, ORDER=[], P={done:{},tries:{}}, root=null, path=null, sheet=null, cur=null, back=null, ACTIVE_SUBJECT="";
+let G=null, BY={}, POST={}, ORDER=[], P={done:{},tries:{},solved:{},at:{}}, root=null, curQ=0, path=null, sheet=null, cur=null, back=null, ACTIVE_SUBJECT="";
 let picker=null, PH=null;   // the photo file picker, and the photographed problem on the sheet (see photo())
 let advanceTimer=null;
 let phonePair=null;
@@ -36,10 +38,16 @@ function cancelAdvance(){ clearTimeout(advanceTimer); advanceTimer=null; }
 function index(graph){
   G=graph; BY=Object.fromEntries(G.skills.map(s=>[s.id,s])); POST=Object.fromEntries(G.skills.map(s=>[s.id,[]]));
   G.skills.forEach(s=>s.prereqs.forEach(p=>POST[p].push(s.id)));
-  const depth=id=>DEPTH[id]??(DEPTH[id]=BY[id].prereqs.length?1+Math.max(...BY[id].prereqs.map(depth)):0);
-  G.skills.forEach(s=>depth(s.id));
-  // the path's order: unit by unit, and in a unit each skill after the ones it needs
-  ORDER=G.units.flatMap(u=>G.skills.filter(s=>s.unit===u.id).sort((a,b)=>DEPTH[a.id]-DEPTH[b.id]).map(s=>s.id));
+  // the path's order: unit by unit, and in a unit the order of the file (the teaching schedule's),
+  // except that a skill waits until the skills it needs in its unit are placed
+  ORDER=G.units.flatMap(u=>{
+    const left=G.skills.filter(s=>s.unit===u.id), placed=new Set(), out=[];
+    while(left.length){
+      const i=left.findIndex(s=>s.prereqs.every(p=>placed.has(p)||BY[p].unit!==u.id));
+      const [s]=left.splice(i,1); placed.add(s.id); out.push(s.id);
+    }
+    return out;
+  });
 }
 // the units the student's class studies (its "lessons"); a teacher, or an account in no class, has every unit.
 // A skill of a unit the class does not study counts as known: it does not lock the skills that need it.
@@ -50,6 +58,11 @@ const shownUnits=()=>{
 let SHOWN=new Set();
 const status=id=>P.done[id]?"done":BY[id].prereqs.every(p=>P.done[p]||!SHOWN.has(BY[p].unit))?"open":"locked";
 const next=()=>ORDER.find(id=>SHOWN.has(BY[id].unit)&&status(id)==="open")||null;
+const QS=s=>s.questions||[s.sample];
+const solvedOf=id=>new Set(P.solved[id]||[]);
+// the question after `from` that is not solved yet; once all are solved, simply the next one
+const nextQ=(id,from)=>{ const n=QS(BY[id]).length, got=solvedOf(id);
+  for(let k=1;k<=n;k++){ const j=(from+k)%n; if(!got.has(j)) return j; } return (from+1)%n; };
 
 async function show(){
   document.documentElement.classList.add("math-on");
@@ -70,7 +83,7 @@ async function show(){
     try{ const r=await fetch("/api/math/skills"); if(!r.ok) throw new Error(`השרת ענה ${r.status}`); index(await r.json()); }
     catch(e){ path.innerHTML=`<p class="mx-note">לא הצלחנו לטעון את המסלול: ${esc(e.message)}. רעננו את העמוד ונסו שוב.</p>`; return; }
   }
-  P=Object.assign({done:{},tries:{}},load()); SHOWN=new Set(shownUnits().map(u=>u.id));
+  P=Object.assign({done:{},tries:{},solved:{},at:{}},load()); SHOWN=new Set(shownUnits().map(u=>u.id));
   subjectOptions().length?drawSubjectPicker():selectSubject("מתמטיקה");
   window.MathlyAnswers?.configure({api,account:CFG.userId,enabled:CFG.answerScans,root,onGraded:({questionId,grading})=>{
     if(grading.result.verdict!=="correct"||P.done[questionId])return;
@@ -119,10 +132,10 @@ function draw(){
     const ids=ORDER.filter(id=>BY[id].unit===u.id);
     return `<section class="mx-unit u-${u.id}"><div class="mx-uhead"><h2>${esc(u.name)}</h2><span>${esc(u.source)}${u.when?" · "+esc(u.when):""}</span></div>
       <div class="mx-trail">${ids.map((id,i)=>{
-        const s=BY[id], st=status(id), here=id===nxt;
+        const s=BY[id], st=status(id), here=id===nxt, n=QS(s).length, k=solvedOf(id).size;
         return `<button class="mx-node st-${st}${here?" here":""}" data-id="${id}" aria-label="${esc(plain(s.name))}, ${st==="done"?"הושלמה":st==="open"?"פתוחה":"נעולה"}">
           <span class="mx-dot">${st==="done"?"✓":i+1}</span>
-          <span class="mx-lbl"><b>${fmt(s.name)}</b><small>${s.core?'<span class="mx-core">ליבה 5 יח״ל</span>':""}${here?'<span class="mx-go">ממשיכים כאן</span>':""}</small></span></button>`;
+          <span class="mx-lbl"><b>${fmt(s.name)}</b><small>${s.core?'<span class="mx-core">ליבה 5 יח״ל</span>':""}${n>1&&st!=="done"&&k?`<span class="mx-count">${k}/${n}</span>`:""}${here?'<span class="mx-go">ממשיכים כאן</span>':""}</small></span></button>`;
       }).join("")}</div></section>`;
   }).join("");
   path.innerHTML=`<header class="mx-top"><div><h1>המסלול שלי</h1><p class="mx-sub">אלגברה וגאומטריה כיתה ט׳ · 5 יח״ל${cls}</p></div>
@@ -135,17 +148,19 @@ function draw(){
     <button class="mx-photo" data-act="photo"><b>צילום תרגיל</b><small>צלמו תרגיל מהמחברת או מהדף, ונעזור לכם לפתור אותו צעד אחר צעד</small></button>
     <button class="mx-photo" data-act="phone"><b>צילום בטלפון, פתרון במחשב</b><small>סרקו קוד בטלפון, צלמו תרגיל וראו את התשובה כאן אוטומטית</small></button>
     ${trail}
-    <p class="mx-note">בשלב הזה יש שאלה אחת לדוגמה לכל מיומנות. ההתקדמות נשמרת במכשיר הזה.</p>`;
+    <p class="mx-note">מיומנות מסומנת כהושלמה כשעונים נכון על כל השאלות שלה. ההתקדמות נשמרת במכשיר הזה.</p>`;
 }
 
 function chips(ids){
-  return ids.length?ids.map(id=>`<button class="mx-chip u-${BY[id].unit}${P.done[id]?" is-done":""}" data-id="${id}">${P.done[id]?"✓ ":""}${esc(BY[id].short)}</button>`).join(""):'<em>אין</em>';
+  return ids.length?ids.map(id=>`<button class="mx-chip u-${BY[id].unit}${P.done[id]?" is-done":""}" data-id="${id}">${P.done[id]?"✓ ":""}${fmt(BY[id].short)}</button>`).join(""):'<em>אין</em>';
 }
 function open(id){
   stopPhone();
   cancelAdvance();
-  const s=BY[id], st=status(id), unit=G.units.find(u=>u.id===s.unit), openEnded=s.sample.type==="open-ended";
-  const options=s.sample.choices||[],rot=options.length?ORDER.indexOf(id)%options.length:0;
+  const s=BY[id], st=status(id), unit=G.units.find(u=>u.id===s.unit), all=QS(s), n=all.length;
+  curQ=Math.min(P.at[id]||0,n-1);
+  const q=all[curQ], openEnded=q.type==="open-ended", got=solvedOf(id);
+  const options=q.choices||[],rot=options.length?(ORDER.indexOf(id)+curQ)%options.length:0;
   const choices=options.slice(rot).concat(options.slice(0,rot)), missing=s.prereqs.filter(p=>!P.done[p]&&SHOWN.has(BY[p].unit));
   if(!cur) back=document.activeElement;
   cur=id;
@@ -156,8 +171,9 @@ function open(id){
         <button class="mx-x" data-act="close" aria-label="סגירה">✕</button></div>
       <p>${fmt(s.description)}</p>
       ${st==="locked"?`<div class="mx-hint">מומלץ לעבור קודם על: <span class="mx-chips">${chips(missing)}</span></div>`:""}
-      <div class="mx-q"><p>${fmt(s.sample.question)}</p>${s.sample.graph?plot(s.sample.graph):""}${s.sample.diagram?geometryDiagram(s.sample.diagram):""}
-        ${openEnded?'<div class="mx-answer"></div>':`<div class="mx-choices">${choices.map((c,i)=>`<button data-choice="${i}" data-m="${c.correct?"":esc(c.mistake)}">${fmt(c.text)}</button>`).join("")}</div>`}
+      <div class="mx-q">${n>1?`<div class="mx-qprog"><span>שאלה ${curQ+1} מתוך ${n}</span><span class="mx-qdots" aria-label="נפתרו ${got.size} מתוך ${n}">${all.map((_,i)=>`<i class="${got.has(i)?"ok":""}${i===curQ?" now":""}"></i>`).join("")}</span></div>`:""}
+        <p>${fmt(q.question)}</p>${q.graph?plot(q.graph):""}${q.diagram?geometryDiagram(q.diagram):""}
+        ${openEnded?'<div class="mx-answer"></div>':`<div class="mx-choices">${choices.map((c,i)=>`<button data-choice="${i}" data-m="${c.correct?"":esc(c.mistake)}"${c.correct?" data-right":""}>${fmt(c.text)}</button>`).join("")}</div>`}
         <div class="mx-fb" aria-live="polite"></div></div>
       <div class="mx-sec"><h4>דורשת</h4><div class="mx-chips">${chips(s.prereqs)}</div></div>
       <div class="mx-sec"><h4>פותחת</h4><div class="mx-chips">${chips(POST[id])}</div></div>
@@ -168,36 +184,54 @@ function open(id){
 }
 function closeSheet(){ stopPhone(); cancelAdvance(); if(sheet)sheet.hidden=true; cur=null; back?.focus?.({preventScroll:true}); back=null; }
 
+// counts down, then opens `target` (a skill id); stops if the student moved on in the meantime
+function autoAdvance(id,target){
+  let seconds=3;
+  const countdown=sheet.querySelector(".mx-countdown");
+  const tick=()=>{
+    if(cur!==id||sheet.hidden||root.hidden) return cancelAdvance();
+    if(seconds===0) return open(target);
+    countdown.textContent=target===id?`השאלה הבאה בעוד ${seconds}…`:`התרגיל הבא בעוד ${seconds}…`;
+    seconds--;
+    advanceTimer=setTimeout(tick,1000);
+  };
+  tick();
+}
+
 function answer(btn){
   if(btn.disabled) return;
-  const id=cur, m=btn.dataset.m, fb=sheet.querySelector(".mx-fb");
-  sheet.querySelectorAll("[data-choice]").forEach(b=>b.classList.remove("right","wrong"));
+  const id=cur, m=btn.dataset.m, fb=sheet.querySelector(".mx-fb"), n=QS(BY[id]).length, qi=curQ;
+  const buttons=sheet.querySelectorAll("[data-choice]");
+  buttons.forEach(b=>b.classList.remove("right","wrong"));
   btn.classList.add(m?"wrong":"right");
   P.tries[id]=(P.tries[id]||0)+1;
+  if(n>1) P.at[id]=nextQ(id,qi);
   if(!m){
-    const first=!P.done[id]; P.done[id]=P.done[id]||new Date().toISOString(); save(); draw();
-    const nxt=next();
-    sheet.querySelectorAll("[data-choice]").forEach(b=>b.disabled=true);
-    fb.innerHTML=`<div class="mx-ok"><b>נכון!</b>${first?"<span>המיומנות סומנה כהושלמה.</span>":""}
-      ${nxt&&nxt!==id?`<span class="mx-countdown"></span><button class="mx-btn solid" data-id="${nxt}">המשך עכשיו: ${esc(BY[nxt].short)}</button>`:"<span>סיימתם את כל המסלול. כל הכבוד!</span>"}</div>`;
-    if(nxt&&nxt!==id){
-      let seconds=3;
-      const countdown=fb.querySelector(".mx-countdown");
-      const tick=()=>{
-        if(cur!==id||sheet.hidden||root.hidden) return cancelAdvance();
-        if(seconds===0) return open(nxt);
-        countdown.textContent=`התרגיל הבא בעוד ${seconds}…`;
-        seconds--;
-        advanceTimer=setTimeout(tick,1000);
-      };
-      tick();
+    const got=solvedOf(id); got.add(qi); P.solved[id]=[...got].sort((a,b)=>a-b);
+    const finished=got.size>=n, first=finished&&!P.done[id];
+    if(finished) P.done[id]=P.done[id]||new Date().toISOString();
+    save(); draw();
+    buttons.forEach(b=>b.disabled=true);
+    if(!P.done[id]){
+      fb.innerHTML=`<div class="mx-ok"><b>נכון!</b><span>פתרתם ${got.size} מתוך ${n} שאלות במיומנות הזו.</span>
+        <span class="mx-countdown"></span><button class="mx-btn solid" data-id="${id}">לשאלה הבאה</button></div>`;
+      return autoAdvance(id,id);
     }
+    const nxt=next();
+    fb.innerHTML=`<div class="mx-ok"><b>נכון!</b>${first?`<span>${n>1?`פתרתם את כל ${n} השאלות. `:""}המיומנות סומנה כהושלמה.</span>`:""}
+      ${nxt&&nxt!==id?`<span class="mx-countdown"></span><button class="mx-btn solid" data-id="${nxt}">המשך עכשיו: ${fmt(BY[nxt].short)}</button>`
+        :nxt?"":"<span>סיימתם את כל המסלול. כל הכבוד!</span>"}
+      ${n>1?`<button class="mx-btn" data-id="${id}">עוד שאלה במיומנות הזו</button>`:""}</div>`;
+    if(nxt&&nxt!==id) autoAdvance(id,nxt);
     return;
   }
   save();
   const M=G.mistakes[m], to=M.back&&M.back!==id?M.back:null;
+  // with a list of questions, a missed question is shown later again; trying again now would not count
+  if(n>1) buttons.forEach(b=>{ b.disabled=true; if(b.dataset.right!=null) b.classList.add("right"); });
   fb.innerHTML=`<div class="mx-bad"><b>${fmt(M.name)}</b><span>${fmt(M.tip)}</span>
-    ${to?`<button class="mx-btn" data-id="${to}">חזרה אל: ${esc(BY[to].short)}</button>`:"<span class=\"mx-small\">אפשר לבחור תשובה אחרת.</span>"}</div>`;
+    ${n>1?`<span class="mx-small">השאלה הזו תחזור אחרי שאר השאלות.</span><button class="mx-btn solid" data-id="${id}">לשאלה הבאה</button>`:""}
+    ${to?`<button class="mx-btn" data-id="${to}">חזרה אל: ${fmt(BY[to].short)}</button>`:n>1?"":"<span class=\"mx-small\">אפשר לבחור תשובה אחרת.</span>"}</div>`;
 }
 
 function onClick(e){
@@ -228,7 +262,7 @@ let MANAGED_CLASSES=[], MANAGE_MODE="classes", MANAGE_BUSY=false;
 const manageTabs=[
   ["classes","כיתות","פתיחה, עריכה ומחיקה"],
   ["students","תלמידים","רשימה ומסנן כיתות"],
-  ["content","תוכן","נושאים, סרטונים וטקסטים"],
+  ["content","תוכן","מקצועות, יחידות ותת־נושאים"],
   ["flags","ניטור","פעילות ודיווחי ציונים"],
   ["access","הרשאות","תפקידים וגישה"]
 ];
@@ -309,10 +343,7 @@ function showManageMode(mode){
     box.innerHTML=`<div class="mx-manage-title"><h4>תלמידים</h4><span>${students.size} תלמידים · ${MANAGED_CLASSES.length} כיתות</span></div>${students.size?`<div class="mx-manage-list">${[...students].map(([email,classes])=>`<article><b dir="ltr">${esc(email)}</b><small>${esc(classes.join(" · "))}</small></article>`).join("")}</div>`:'<p class="mx-note">עדיין לא נוספו תלמידים לכיתות.</p>'}`;
     return;
   }
-  if(mode==="content"){
-    box.innerHTML=`<div class="mx-manage-title"><h4>תוכן לימודי</h4><span>${G.units.length} נושאים במסלול</span></div><div class="mx-manage-list">${G.units.map(unit=>{const skills=G.skills.filter(skill=>skill.unit===unit.id);const count=MANAGED_CLASSES.filter(row=>(row.lessons||[]).includes(unit.id)).length;return `<article class="u-${unit.id}"><b>${esc(unit.name)}</b><small>${skills.length} מיומנויות · פעיל ב־${count} כיתות</small></article>`}).join("")}</div>`;
-    return;
-  }
+  if(mode==="content") return drawContent(box);
   if(mode==="flags"){
     const done=Object.keys(P.done||{}).length, tries=Object.values(P.tries||{}).reduce((sum,n)=>sum+(+n||0),0);
     box.innerHTML=`<div class="mx-manage-title"><h4>ניטור</h4><span>פעילות ודיווחי ציונים</span></div><div class="mx-manage-stats"><article><b>${MANAGED_CLASSES.length}</b><small>כיתות פעילות</small></article><article><b>${done}</b><small>מיומנויות שהושלמו במכשיר זה</small></article><article><b>${tries}</b><small>ניסיונות במכשיר זה</small></article></div><p class="mx-note">נתוני התקדמות כיתתיים יופיעו כאן כאשר שירות דיווחי הציונים יחובר.</p>`;
@@ -326,6 +357,26 @@ function showManageMode(mode){
   box.innerHTML='<div class="mx-manage-title"><h4>מעבדה</h4><span>כלים לבדיקה ופיתוח</span></div><p class="mx-note">כלי המעבדה למתמטיקה יתווספו כאן. אפשר לחזור לכל אזור ניהול מהכרטיסיות למעלה.</p>';
 }
 
+// every subject a class meets: those with units, then those that so far only have exams
+const contentSubjects=()=>[...new Set([...G.units.map(unit=>unit.subject),
+  ...MANAGED_CLASSES.flatMap(row=>(row.exams||[]).map(exam=>exam.subject))].filter(Boolean))];
+const unitSkills=id=>ORDER.filter(sid=>BY[sid].unit===id).map(sid=>BY[sid]);
+const questionCount=skills=>skills.reduce((sum,skill)=>sum+QS(skill).length,0);
+function drawContent(box){
+  const subjects=contentSubjects();
+  box.innerHTML=`<div class="mx-manage-title"><h4>תוכן לימודי</h4><span>${subjects.length} מקצועות · ${G.units.length} יחידות · ${G.skills.length} תת־נושאים · ${questionCount(G.skills)} שאלות</span></div>
+    ${subjects.map(subject=>{
+      const units=G.units.filter(unit=>unit.subject===subject), [icon,tone]=examLooks[subject]||["●","other"];
+      return `<section class="mx-content-subject exam-${tone}"><h5><span aria-hidden="true">${icon}</span>${esc(subject)}<small>${units.length?`${units.length} יחידות`:"עוד אין יחידות במסלול"}</small></h5>
+        ${units.map(unit=>{
+          const skills=unitSkills(unit.id), classes=MANAGED_CLASSES.filter(row=>(row.lessons||[]).includes(unit.id)).length;
+          return `<details class="mx-content-unit u-${unit.id}"><summary><b>${esc(unit.name)}</b>
+            <small>${unit.when?`${esc(unit.when)} · `:""}${skills.length} תת־נושאים · ${questionCount(skills)} שאלות · פעיל ב־${classes} כיתות</small></summary>
+            <ol>${skills.map(skill=>`<li><span>${fmt(skill.name)}</span><small>${esc(skill.subject||subject)} › ${esc(unit.name)}${skill.month?` · ${esc(skill.month)}`:""} · ${QS(skill).length===1?"שאלה אחת":`${QS(skill).length} שאלות`}</small></li>`).join("")}</ol></details>`;
+        }).join("")}</section>`;
+    }).join("")}`;
+}
+
 function drawManagedClasses(box){
   const classes=MANAGED_CLASSES;
   box.innerHTML=`<div class="mx-manage-title"><h4>כיתות</h4><span>פתיחה, עריכה ומחיקה</span></div>
@@ -354,7 +405,7 @@ function openClassEditor(row){
   const selected=new Set(row?.lessons||G.units.map(unit=>unit.id));
   box.innerHTML=`<div class="mx-manage-title"><h4>${creating?"כיתה חדשה":`עריכת ${esc(row.name)}`}</h4><button class="mx-btn" type="button" data-class-action="cancel">חזרה לכיתות</button></div>
     <form class="mx-class-form"><label>שם הכיתה<input name="name" required maxlength="80" autocomplete="off" placeholder="למשל: ט׳ 1" value="${esc(row?.name||"")}"></label>
-      <fieldset><legend>יחידות הלימוד<small>התלמידים יראו במסלול רק את המיומנויות של היחידות שסומנו. מקצוע היחידה קובע אילו מבחנים יוצגו במסלול.</small></legend><div class="mx-unit-picks">${G.units.map(unit=>`<label class="u-${unit.id}"><input type="checkbox" name="unit" value="${esc(unit.id)}"${selected.has(unit.id)?" checked":""}><span>${esc(unit.name)}<small>${esc(unit.subject)} · ${G.skills.filter(skill=>skill.unit===unit.id).length} מיומנויות</small></span></label>`).join("")}</div></fieldset>
+      <fieldset><legend>יחידות הלימוד<small>התלמידים יראו במסלול רק את המיומנויות של היחידות שסומנו. מקצוע היחידה קובע אילו מבחנים יוצגו במסלול.</small></legend>${[...new Set(G.units.map(unit=>unit.subject))].map(subject=>`<h6 class="mx-pick-subject">${esc(subject)}</h6><div class="mx-unit-picks">${G.units.filter(unit=>unit.subject===subject).map(unit=>{const skills=unitSkills(unit.id);return `<label class="u-${unit.id}"><input type="checkbox" name="unit" value="${esc(unit.id)}"${selected.has(unit.id)?" checked":""}><span>${esc(unit.name)}<small>${skills.length} תת־נושאים · ${questionCount(skills)} שאלות</small></span></label>`}).join("")}</div>`).join("")}</fieldset>
       <label>התלמידים<small>כתובת דוא״ל אחת בכל שורה. תלמיד יכול להשתייך ליותר מכיתה אחת.</small><textarea name="emails" dir="ltr" spellcheck="false" placeholder="student@example.com">${esc((row?.emails||[]).join("\n"))}</textarea></label>
       <label>מורי הכיתה<small>כתובת דוא״ל אחת בכל שורה. למורים תהיה גישה לכיתה הזו.</small><textarea name="teachers" dir="ltr" spellcheck="false" placeholder="teacher@example.com">${esc((row?.teachers||[]).join("\n"))}</textarea></label>
       <div class="mx-class-form-actions"><button class="mx-btn solid" type="submit">${creating?"פתיחת הכיתה":"שמירת השינויים"}</button><button class="mx-btn" type="button" data-class-action="cancel">ביטול</button><span role="status" aria-live="polite"></span></div></form>`;

tests/test_answer_browser.py

@@ -109,7 +109,7 @@ def test_two_device_capture_retake_failure_retry_and_original_attempt(scan_serve
             phone.locator('[data-submit]').click()
             playwright.expect(computer.locator('.mx-answer [role=status]')).to_have_text('מעלים את התשובה…', timeout=10000)
             assert started.is_set()
-            computer.locator('.mx-x').click();computer.locator('.mx-node[data-id="m_rect_area"]').click()
+            computer.locator('.mx-x').click();computer.locator('.mx-node[data-id="m_def"]').click()
             release.set()
             playwright.expect(phone.locator('[data-status]')).to_contain_text('הועלתה בהצלחה', timeout=10000)
             assert computer.locator('.mx-answer-image').count() == 0
@@ -187,9 +187,10 @@ def test_success_response_loss_is_safe_to_retry(scan_server):
             playwright.expect(phone.locator('[data-status]')).to_contain_text('הועלתה בהצלחה')
             with store.connect() as c:
                 assert c.execute('select count(*) from math_answer_attachments').fetchone()[0]==1
-            computer.locator('.mx-x').click();computer.locator('.mx-node[data-id="m_rect_area"]').click()
+            computer.locator('.mx-x').click();computer.locator('.mx-node[data-id="m_def"]').click()
             computer.locator('.mx-choices button[data-m=""]').click()
-            assert computer.evaluate("!!JSON.parse(localStorage.getItem('mathly.progress.v1:'+'%s@test.invalid')).done.m_rect_area" % OWNER)
+            # one right answer of ten is recorded, but does not finish the skill
+            assert computer.evaluate("JSON.parse(localStorage.getItem('mathly.progress.v1:'+'%s@test.invalid')).solved.m_def.length===1" % OWNER)
         finally:
             browser.close()
 

tests/test_answer_scans.py

@@ -158,6 +158,7 @@ def test_scan_api_end_to_end_failure_retry_and_restart(answer_store, monkeypatch
     import copy
     from app.math_skills import algebra9, question_version
     graph = copy.deepcopy(algebra9())
+    graph['skills'][0].pop('questions')
     graph['skills'][0]['sample'] = {'type': 'open-ended', 'question': 'Draw a proof', 'version': 1}
     monkeypatch.setattr('app.answer_routes.algebra9', lambda: graph)
     monkeypatch.delenv('ANTHROPIC_API_KEY', raising=False)

tests/test_math_skills.py

@@ -9,6 +9,7 @@ from app.math_skills import algebra9, practice_graph, problems, question_version
 
 def test_open_ended_samples_and_content_identity():
     graph = copy.deepcopy(algebra9())
+    graph["skills"][0].pop("questions")
     sample = graph["skills"][0]["sample"] = {"type": "open-ended", "version": 1,
                                            "question": "Draw a triangle."}
     assert problems(graph) == []
@@ -26,22 +27,37 @@ def test_open_ended_samples_and_content_identity():
 
 def test_choice_samples_still_require_one_correct_choice():
     graph = copy.deepcopy(algebra9())
-    graph["skills"][0]["sample"]["choices"] = []
-    assert any("exactly one correct choice" in item for item in problems(graph))
+    graph["skills"][0]["questions"][3]["choices"] = []
+    assert "t_ext question 4: needs exactly one correct choice" in problems(graph)
+
+
+def test_question_lists():
+    graph = copy.deepcopy(algebra9())
+    skill = lambda sid: next(item for item in graph["skills"] if item["id"] == sid)
+    listed = [s for s in graph["skills"] if "questions" in s]
+    assert [s["id"] for s in graph["skills"] if "sample" in s] == ["a_30_side"]   # the photographed answer
+    assert len(listed) == 95 and all(len(s["questions"]) == 10 for s in listed)
+    skill("t_ext")["sample"] = skill("t_ext")["questions"][0]
+    skill("t_gcf")["questions"] = []
+    skill("q_props")["questions"][0] = {"type": "open-ended", "version": 1, "question": "Sketch it."}
+    found = problems(graph)
+    assert "t_ext: needs a sample or a list of questions, not both" in found
+    assert "t_gcf: the question list is empty" in found
+    assert "q_props question 1: a question list holds multiple-choice questions only" in found
 
 
 def test_the_algebra_graph_is_whole():
     graph = algebra9()
     assert problems(graph) == []
-    assert len(graph["skills"]) == 140
-    assert {unit["id"] for unit in graph["units"]} == set("tkqearzhsmnpwd")
+    assert len(graph["skills"]) == 96
+    assert {unit["id"] for unit in graph["units"]} == set("tkiqalzevgrmhsnbcopwd")
     assert {unit["subject"] for unit in graph["units"]} == {"מתמטיקה"}
 
 
 def test_a_broken_graph_is_named():
     graph = copy.deepcopy(algebra9())
     skill = lambda sid: next(item for item in graph["skills"] if item["id"] == sid)
-    skill("t_ext")["prereqs"] = ["t_square"]
+    skill("t_ext")["prereqs"] = ["t_formulas"]
     assert problems(graph)[0].startswith("cycle:")
 
 
@@ -58,7 +74,7 @@ def test_math_is_the_only_page_and_api():
 class FakeSolver:
     def solve(self, image, media_type):
         return {"readable": True, "problem": "$x² = 9$", "steps": [{"hint": "h", "work": "w"}],
-                "answer": "$x = ±3$", "skill": "e_simple", "note": ""}
+                "answer": "$x = ±3$", "skill": "e_way", "note": ""}
 
 
 def test_a_photographed_problem_is_solved(monkeypatch):
@@ -83,3 +99,17 @@ def test_rollout_and_rollback_question_variants():
     assert opened['question_version']==question_version(opened['sample'])
     assert len(fallback['sample']['choices']) == 3
     assert all('fallback_sample' not in s for s in enabled['skills'])
+
+
+def test_each_subunit_names_its_units_subject():
+    graph = practice_graph(False)
+    subject = {unit["id"]: unit["subject"] for unit in graph["units"]}
+    assert all(skill["subject"] == subject[skill["unit"]] for skill in graph["skills"])
+
+
+def test_a_class_of_a_split_unit_keeps_its_content():
+    from app.main import units_of
+    assert units_of({"lessons": ["k"]}) == ["k", "i"]                       # דלתון ומשולש שווה שוקיים
+    assert units_of({"lessons": ["m", "t"]}) == ["t", "m", "b", "c"]        # מלבן, מעוין וריבוע
+    assert units_of({"lessons": ["i"]}) == ["i"]
+    assert units_of({}) == [unit["id"] for unit in algebra9()["units"]]