Add the math path, photographed problems, math classes, backups and the mathly Space

.gitignore

@@ -13,3 +13,5 @@ book/
 # local Minerva clips cut by scripts/minerva_dataset.py (copyrighted videos; never committed)
 data/minerva/
 checkpoints/
+.env.*
+!.env.example

README.md

@@ -49,7 +49,7 @@ sudo apt install ffmpeg
 python3 -m venv .venv && source .venv/bin/activate
 pip install torch --index-url https://download.pytorch.org/whl/cpu
 pip install -r requirements.txt
-uvicorn app.main:app --port 7860
+uvicorn app.main:app --host 0.0.0.0 --port 7860
 ```
 
 Open http://localhost:7860. The first start downloads the model (~1.2 GB). CPU inference on a 3 s clip takes about a second.
@@ -253,7 +253,7 @@ alter table public.user_access add constraint valid_entitlements check (
 
 ### Flags: a score that is wrong
 
-Sometimes a sentence is said right and the system scores it wrong. The teachers (`TEACHER_EMAILS`) report such cases, and `TUTORS_EMAIL` names more accounts that do (several are separated by commas or spaces; they may sign in without being in a class, and get no management panel). The teacher also gives a student this tutor's rank in the panel: at the top of **תלמידים**, the part "🚩 מדווחים על ציונים שגויים" opens a list of every student of every class, each with a box to tick. The rank is the student's, whatever classes they are in, and by itself lets nobody sign in; the panel marks such a student with 🚩 in every class (`PUT /api/tutors`, teachers only: `{"email", "tutor": true|false}`). It is kept by email in the table `tutors`; create it once (until then the panel shows this command):
+Sometimes a sentence is said right and the system scores it wrong. The teachers (`TEACHER_EMAILS`) report such cases, and `TUTORS_EMAIL` names more accounts that do (several are separated by commas or spaces; they may sign in without being in a class, and get no management panel). The rank is kept by email in the table `tutors`:
 
 ```sql
 create table public.tutors (
@@ -600,6 +600,12 @@ alter table public.classes add column if not exists nicknames jsonb not null def
 update public.classes set subject = 'ערבית' where subject = '';
 ```
 
+A subject is one of a fixed list, `SUBJECT_LABELS` in `app/main.py`: ערבית (served at `/`, and `/arabic`) and מתמטיקה (`/math`). It is kept in Hebrew, as the panel shows it, and the developer picks an admin's subject from that list in Monitoring; any other text is refused. `/api/me` names the subject of the account (an admin's own, or their class's), and the page moves an account that opened another subject's address to its own. A developer stays where they are. Each subject has its own title, colour and opening screen (`SUBJECTS`), and the installed app of a subject other than Arabic has its own manifest, `/math/manifest.webmanifest`, so its home-screen icon is named for it and opens `/math`.
+
+**The math path.** On `/math`, the start button opens the math path (`static/math.js`, `static/math.css`) in place of the Arabic one. Its skill graph is `app/math_algebra9.json`, served at `/api/math/skills`: 9th-grade algebra for the 5-unit track, by the Ministry's 2026/27 teaching schedule, in six units (foundations, algebraic technique, function properties, the quadratic function and equation, powers and roots, word problems). Each skill names the skills it needs, and has a sample question whose wrong choices are each a known mistake; a mistake sends the student back to the skill it comes from. `app/math_skills.py` refuses a graph with a cycle, an unknown skill, a redundant link, a question without exactly one right answer, or a mistake that sends a student forward. A skill is open once every skill it needs is done, and the path goes on from the first open one; a locked skill can still be opened, with the skills to do first named on it. For now a right answer to the sample question marks the skill done, and progress is kept on the device (`ihki.math.v1:<email>`). The questions were written for the app and still need a 5-unit teacher's review.
+
+**A photographed problem.** "צילום תרגיל" on the math path lets a student photograph a problem (camera or gallery). The page shrinks the photo to about 1600 px and sends it to `POST /api/math/photo`, where Claude (`app/math_photo.py`) reads it and solves it in a fixed JSON shape: the problem as read, the solution as steps (each a hint and the step itself), the answer, and the path's skill it practises. The sheet shows the reading and one hint; further hints, each step and the full solution with its answer come only when the student asks, and the skill links into the path. It runs on the tutor's Anthropic key (`ANTHROPIC_API_KEY`, or the panel's) and on `MATH_MODEL` (default `claude-opus-5-5`, with the API's default fallback model when it declines). A signed-in student has `DAILY_PHOTOS` (20) a day, counted in memory; a photo it could not read does not count, and developers are exempt. The photo is sent to Anthropic's API and not kept by the app; say so on the privacy page before students use it.
+
 The server keeps the list for a minute, so a change in the SQL editor (rather than the panel) applies within that time.
 
 ### Live lessons
@@ -645,7 +651,7 @@ A few hundred utterances are enough to move the needle with the feature encoder
 ```bash
 pip install -r requirements-train.txt
 python -m train.finetune --train data/train.csv --eval data/eval.csv --out checkpoints/ihki-ft
-MODEL_ID=checkpoints/ihki-ft uvicorn app.main:app --port 7860
+MODEL_ID=checkpoints/ihki-ft uvicorn app.main:app --host 0.0.0.0 --port 7860
 ```
 
 The script reports phoneme error rate (PER) before and after training. A GPU is advisable. A free Colab T4 handles a few hundred clips in minutes.

app/auth.py

@@ -79,6 +79,15 @@ MAX_ATTEMPTS = 20_000  # of one student, read for their progress
 MAX_CLASS_ATTEMPTS = 200_000  # of all students, read for the teacher's panel
 CLASSES_TTL = 60  # seconds the class list is trusted without reading it again (each sign-in check uses it)
 
+# Application-owned data. Supabase's auth users and managed schemas are deliberately not copied.
+BACKUP_TABLES = (
+    "dailies", "library", "videos", "texts", "classes", "writings", "tutors", "flags",
+    "lab_samples", "calibrations", "scoring_rules", "user_access", "access_audit", "app_secrets",
+    "system_events", "tutor_chats",
+)
+BACKUP_NATURAL_KEYS = {"writings": "user_id,topic", "tutors": "email", "scoring_rules": "id",
+                       "user_access": "user_id", "app_secrets": "name", "tutor_chats": "id"}
+
 
 class AuthUnavailable(RuntimeError):
     pass
@@ -218,7 +227,8 @@ class SupabaseAuth:
         with urllib.request.urlopen(req, timeout=TIMEOUT) as res:
             return json.load(res)
 
-    def _admin(self, path: str, method: str = "GET", body: dict | None = None, prefer: str = "return=representation"):
+    def _admin(self, path: str, method: str = "GET", body: dict | None = None, prefer: str = "return=representation",
+               timeout: int = TIMEOUT):
         """A call with the secret key, for the teacher's panel. Unlike a student's own progress, a failure is raised."""
         if not self.secret:
             raise AuthUnavailable("SUPABASE_SECRET_KEY is not set")
@@ -227,7 +237,7 @@ class SupabaseAuth:
             headers={"Authorization": f"Bearer {self.secret}", "apikey": self.secret, "Content-Type": "application/json",
                      "Prefer": prefer, "User-Agent": "ihki/1.0"})
         try:
-            with urllib.request.urlopen(req, timeout=TIMEOUT) as res:
+            with urllib.request.urlopen(req, timeout=timeout) as res:
                 return json.loads(res.read() or b"null")
         except urllib.error.HTTPError as e:
             detail = e.read().decode(errors="replace")[:300]
@@ -237,6 +247,119 @@ class SupabaseAuth:
         except (urllib.error.URLError, TimeoutError, ValueError) as e:
             raise AuthUnavailable(str(e)) from e
 
+    def backup_rows(self) -> dict[str, list[dict]]:
+        """All application-owned table rows. Tables not installed in an older deployment are omitted."""
+        result: dict[str, list[dict]] = {}
+        for table in BACKUP_TABLES:
+            rows = []
+            try:
+                for offset in range(0, 10_000_000, PAGE):
+                    path = f"/rest/v1/{table}?select=*&limit={PAGE}&offset={offset}"
+                    for attempt in range(3):
+                        try:
+                            batch = self._admin(path, timeout=60) or []
+                            break
+                        except AuthUnavailable as e:
+                            if attempt == 2 or not any(x in str(e).lower() for x in ("timed out", "timeout")):
+                                raise
+                    rows.extend(batch)
+                    if len(batch) < PAGE:
+                        break
+                result[table] = rows
+            except AuthUnavailable as e:
+                if "answered 404" not in str(e):
+                    raise
+        return result
+
+    def final_scores(self) -> list[dict]:
+        """One compact row per student and exercise: the highest score that drives the panel's final grades."""
+        best: dict[tuple[str, str, str], dict] = {}
+        for offset in range(0, MAX_CLASS_ATTEMPTS, PAGE):
+            query = urllib.parse.urlencode({"select": "user_id,cat,phrase,score,created_at",
+                                            "order": "id.asc", "limit": PAGE, "offset": offset})
+            path = f"/rest/v1/attempts?{query}"
+            for attempt in range(3):
+                try:
+                    batch = self._admin(path, timeout=60) or []
+                    break
+                except AuthUnavailable as e:
+                    if attempt == 2 or not any(x in str(e).lower() for x in ("timed out", "timeout")):
+                        raise
+            for row in batch:
+                key = (str(row["user_id"]), str(row["cat"]), str(row["phrase"]))
+                if key not in best or int(row["score"]) > int(best[key]["score"]):
+                    best[key] = row
+            if len(batch) < PAGE:
+                break
+        return list(best.values())
+
+    def restore_final_scores(self, rows: list[dict]) -> int:
+        """Restore only grades that improve the currently stored best score, without restoring attempt history."""
+        current = {(r["user_id"], r["cat"], r["phrase"]): int(r["score"]) for r in self.final_scores()}
+        add = [{**r, "unrelated": False} for r in rows
+               if int(r.get("score", -1)) > current.get((r.get("user_id"), r.get("cat"), r.get("phrase")), -1)]
+        for start in range(0, len(add), 200):
+            self._admin("/rest/v1/attempts", "POST", add[start:start + 200], prefer="return=minimal", timeout=60)
+        return len(add)
+
+    def restore_rows(self, tables: dict[str, list[dict]]) -> dict[str, int]:
+        """Merge a validated application backup. Existing rows are updated; unrelated current rows remain."""
+        restored: dict[str, int] = {}
+        text_ids: dict[int, int] = {}
+        daily_ids: dict[int, int] = {}
+        for table in BACKUP_TABLES:
+            rows = [dict(r) for r in tables.get(table, [])]
+            if not rows:
+                continue
+            if table == "classes":
+                for row in rows:
+                    row["dailies"] = [{**d, "video": daily_ids.get(d.get("video"), d.get("video"))}
+                                      for d in (row.get("dailies") or [])]
+                    for field in ("homework",):
+                        value = row.get(field, "")
+                        if isinstance(value, str) and value.startswith("t") and value[1:].isdigit():
+                            row[field] = "t" + str(text_ids.get(int(value[1:]), int(value[1:])))
+                    row["homeworks"] = [{**h, "topic": "t" + str(text_ids.get(int(h["topic"][1:]), int(h["topic"][1:])))
+                                          if isinstance(h.get("topic"), str) and h["topic"].startswith("t") and h["topic"][1:].isdigit()
+                                          else h.get("topic")} for h in (row.get("homeworks") or [])]
+            if table == "writings":
+                field = "topic"
+                for row in rows:
+                    value = row.get(field, "")
+                    if isinstance(value, str) and value.startswith("t") and value[1:].isdigit():
+                        row[field] = "t" + str(text_ids.get(int(value[1:]), int(value[1:])))
+            if table in BACKUP_NATURAL_KEYS:
+                key = BACKUP_NATURAL_KEYS[table]
+                for start in range(0, len(rows), 200):
+                    self._admin(f"/rest/v1/{table}?on_conflict={key}", "POST", rows[start:start + 200],
+                                prefer="resolution=merge-duplicates,return=minimal")
+                restored[table] = len(rows)
+                continue
+            for original in rows:
+                row = dict(original)
+                old_id = row.get("id")
+                if old_id is not None:
+                    patch = dict(row)
+                    patch.pop("id", None)
+                    existing = self._admin(f"/rest/v1/{table}?id=eq.{urllib.parse.quote(str(old_id))}", "PATCH", patch)
+                    if existing:
+                        new_id = old_id
+                    else:
+                        row.pop("id", None)  # identity columns reject explicitly supplied values
+                        made = self._admin(f"/rest/v1/{table}", "POST", row)
+                        new_id = made[0].get("id") if made else None
+                    if table == "texts" and new_id is not None:
+                        text_ids[int(old_id)] = int(new_id)
+                    if table == "dailies" and new_id is not None:
+                        daily_ids[int(old_id)] = int(new_id)
+                else:
+                    self._admin(f"/rest/v1/{table}", "POST", row, prefer="return=minimal")
+            restored[table] = len(rows)
+        self._classes = self._videos = self._texts = self._ranked = None
+        self._level_videos.clear()
+        self._access.clear()
+        return restored
+
     def classes(self, fresh: bool = False) -> list[dict]:
         """Every class, newest first: id, name, emails (lower-case), nicknames ({email: nickname}), lessons (lesson ids;
         empty in a class saved before classes had lessons), homeworks ([{"topic": a topic id, "due": its ISO date or
@@ -497,6 +620,36 @@ class SupabaseAuth:
             media_type = mimetypes.guess_type(name)[0] or media_type
         return data, media_type
 
+    def ensure_backup_bucket(self) -> None:
+        """Create the private application-backup bucket on first use."""
+        try:
+            self._admin("/storage/v1/bucket/backups")
+        except AuthUnavailable as e:
+            detail = str(e).lower()
+            if not any(mark in detail for mark in ("answered 404", '"statuscode":"404"', "nosuchbucket", "bucket not found")):
+                raise
+            self._admin("/storage/v1/bucket", "POST", {"id": "backups", "name": "backups", "public": False},
+                        prefer="return=minimal")
+
+    def save_backup(self, name: str, data: bytes) -> None:
+        self.ensure_backup_bucket()
+        req = urllib.request.Request(
+            f"{self.url}/storage/v1/object/backups/{urllib.parse.quote(name)}", data=data, method="POST",
+            headers={"Authorization": f"Bearer {self.secret}", "apikey": self.secret,
+                     "Content-Type": "application/zip", "User-Agent": "ihki/1.0"})
+        try:
+            urllib.request.urlopen(req, timeout=max(TIMEOUT, 60)).close()
+        except urllib.error.HTTPError as e:
+            raise AuthUnavailable(f"supabase storage answered {e.code}: {e.read().decode(errors='replace')[:300]}") from e
+        except (urllib.error.URLError, TimeoutError) as e:
+            raise AuthUnavailable(str(e)) from e
+
+    def list_backups(self) -> list[dict]:
+        self.ensure_backup_bucket()
+        rows = self._admin("/storage/v1/object/list/backups", "POST",
+                           {"prefix": "", "limit": 100, "offset": 0, "sortBy": {"column": "name", "order": "desc"}})
+        return [r for r in (rows or []) if str(r.get("name", "")).endswith(".zip")]
+
     def add_flag(self, row: dict, audio: bytes, mime: str, name: str) -> bool:
         """Keeps a flagged score and its recording in the private `flags` bucket."""
         kept = self._put_object("flags", name, audio, mime)

app/live.py

@@ -105,9 +105,11 @@ class LiveStore:
             session = self._sessions.get(code)
             if not session:
                 raise KeyError(code)
+            variants = phrase.get("variants") or []
+            arabic = phrase.get("ar") or (variants[0][0] if variants else "")
             session["question_no"] += 1
             session["question"] = {"no": session["question_no"], "phrase_id": phrase["id"],
-                                   "he": phrase["he"], "ar": phrase["ar"], "tr": phrase["tr"],
+                                   "he": phrase["he"], "ar": arabic, "tr": phrase["tr"],
                                    "started_at": _now_iso()}
             session["answers"] = {}
             session["teacher_seen"] = now

app/main.py

@@ -13,6 +13,8 @@ A local .env file is loaded if present; real environment variables win over it.
 from __future__ import annotations
 
 import hashlib
+import io
+import json
 import logging
 import os
 import re
@@ -20,6 +22,7 @@ import subprocess
 import time
 import urllib.parse
 import uuid
+import zipfile
 from contextlib import asynccontextmanager
 from datetime import date, datetime, timedelta, timezone
 from pathlib import Path
@@ -36,6 +39,9 @@ from .auth import AuthUnavailable, ClassConflict, SupabaseAuth, load_auth
 from .keystore import (CREATE_APP_SECRETS, MAX_LEN as MAX_KEY_LEN, MIGRATE_APP_SECRETS, NAMES as KEY_NAMES, KeyRefused,
                        check as check_key, load_keys)
 from .live import LiveConflict, LiveStore
+from .math_photo import (DAILY_PHOTOS, MAX_PHOTO, MEDIA_TYPES as PHOTO_TYPES, PhotoSolver, PhotoUnavailable, math_model,
+                         photo_client)
+from .math_skills import algebra9
 from .phrases import CATEGORIES, GAMES, LESSONS, LEVELS, PHRASES, public_phrases
 from .prompt_tts import ENGINES, PromptTTSUnavailable, hebrew_mp3
 from .reference import References
@@ -55,13 +61,28 @@ load_dotenv(STATIC.parent / ".env")
 # A class topic's opening screen, by the path it is served at; "/" is Arabic.
 SUBJECTS = {
     "arabic": {"__TITLE__": "אהלא וסהלא", "__SPLASH_LOGO__": "/static/logo-intro.svg",
-               "__SPLASH_ALT__": "אהלא וסהלא, בית הספר ללימוד השפה הערבית", "__START_LABEL__": "יאללה נבלש"},
+               "__SPLASH_ALT__": "אהלא וסהלא, בית הספר ללימוד השפה הערבית", "__START_LABEL__": "יאללה נבלש",
+               "__APP_NAME__": "אהלא  וסהלא", "__THEME_COLOR__": "#4B6A2C", "__MANIFEST__": "/static/manifest.webmanifest"},
     "math": {"__TITLE__": "מתמטיקה בכיף", "__SPLASH_LOGO__": "/static/logo-math.svg",
-             "__SPLASH_ALT__": "מתמטיקה בכיף, המורה הפרטי למתמטיקה", "__START_LABEL__": "יאללה נתחיל"},
+             "__SPLASH_ALT__": "מתמטיקה בכיף, המורה הפרטי למתמטיקה", "__START_LABEL__": "יאללה נתחיל",
+             "__APP_NAME__": "מתמטיקה בכיף", "__THEME_COLOR__": "#000000", "__MANIFEST__": "/math/manifest.webmanifest"},
 }
+# A subject as an admin and a class keep it (in Hebrew, as the panel shows it), by the path its pages are served at.
+SUBJECT_LABELS = {"arabic": "ערבית", "math": "מתמטיקה"}
+# What the installed app of a subject other than Arabic changes in /static/manifest.webmanifest: its own name and
+# start page, so a math student's home-screen icon opens /math. The scope stays "/", the service worker's.
+MANIFESTS = {"math": {"id": "/math", "name": "מתמטיקה בכיף", "short_name": "מתמטיקה בכיף", "description": "תרגול מתמטיקה",
+                      "start_url": "/math", "theme_color": "#000000", "background_color": "#000000"}}
+
+
+def subject_code(label: object) -> str:
+    """The path of a stored subject ("ערבית" -> "arabic"); "" for none, and for one that is not in SUBJECT_LABELS."""
+    label = " ".join(str(label or "").split())
+    return next((code for code, name in SUBJECT_LABELS.items() if name == label), "")
 MODEL_ID = os.environ.get("MODEL_ID", "facebook/wav2vec2-xlsr-53-espeak-cv-ft")
 LOCAL_TZ = ZoneInfo("Asia/Jerusalem")  # a day of practice is the students' calendar day
 MAX_UPLOAD = 2_000_000  # bytes; 15 s of opus is ~100 KB
+MAX_BACKUP_UPLOAD = 250_000_000
 EMAIL = re.compile(r"[^@\s,;<>]+@[^@\s,;<>]+\.[^@\s,;<>]+")
 MAX_NICKNAME = 40
 ALL_LESSONS = [l["id"] for l in LESSONS]   # with the lessons still to come: a class may take them ahead
@@ -237,11 +258,29 @@ MIGRATE_CLASSES = ("alter table public.classes add column if not exists nickname
 MAX_HOMEWORKS = 30
 
 
+def is_math(c: dict) -> bool:
+    return subject_code(c.get("subject")) == "math"
+
+
 def lessons_of(c: dict) -> list[str]:
-    """A class's lessons in the course's order; a class saved before classes had lessons has every one."""
+    """A class's Arabic lessons in the course's order; a class saved before classes had lessons has every one.
+    A math class has none: its `lessons` column holds the math units it studies (see `units_of`)."""
+    if is_math(c):
+        return []
     return [l for l in ALL_LESSONS if l in c["lessons"]] or ALL_LESSONS
 
 
+def units_of(c: dict) -> list[str]:
+    """A math class's units of the path (app/math_algebra9.json), in the path's order; none chosen means every one."""
+    ids = [u["id"] for u in algebra9()["units"]]
+    return [u for u in ids if u in (c.get("lessons") or [])] or ids
+
+
+def class_lessons(c: dict) -> list[str]:
+    """What a class studies, as the page gets it: math units for a math class, Arabic lessons for any other."""
+    return units_of(c) if is_math(c) else lessons_of(c)
+
+
 def homework_of(c: dict, topics: dict[str, str] = TOPIC_LESSON) -> dict:
     """A class's homework: the topic it practises now (a category id, e.g. the conversation "l2-talk"; "" when none
     is set) and the day it is due (ISO date, or None). A topic of a lesson the class no longer studies, or one the
@@ -318,8 +357,10 @@ def class_members(text: str) -> tuple[list[str], dict[str, str]]:
 
 
 def build_version() -> str:
-    """Debug build stamp: short content hash of the served code + newest file time (UTC)."""
-    files = sorted(Path(__file__).resolve().parent.glob("*.py")) + [STATIC / "index.html"]
+    """Debug build stamp: short content hash of the served code + newest file time (UTC). The hash also stamps the
+    page's own scripts and styles (?v=), so a change to one of them reaches the service worker's cache-first copy."""
+    files = (sorted(Path(__file__).resolve().parent.glob("*.py")) + [STATIC / "index.html"]
+             + sorted(STATIC.glob("*.js")) + sorted(STATIC.glob("*.css")))
     h = hashlib.sha1()
     for f in files:
         h.update(f.read_bytes())
@@ -569,19 +610,33 @@ def create_app(scorer: Scorer | None = None, tts: SawtakTTS | None = None,
     def page(subject: str) -> HTMLResponse:
         html = (STATIC / "index.html").read_text(encoding="utf-8")
         a: SupabaseAuth | None = app.state.auth
-        marks = {"__VERSION__": build_version(), "__SUPABASE_URL__": a.url if a else "",
-                 "__SUPABASE_KEY__": a.key if a else "", "__SUBJECT__": subject, **SUBJECTS[subject]}
+        version = build_version()
+        marks = {"__VERSION__": version, "__ASSET_V__": version.split(" ")[0], "__SUPABASE_URL__": a.url if a else "",
+                 "__SUPABASE_KEY__": a.key if a else "", "__SUBJECT__": subject, "__HOME__": home, **SUBJECTS[subject]}
         for mark, value in marks.items():
             html = html.replace(mark, value)
         return HTMLResponse(html, headers={"Cache-Control": "no-cache"})
 
+    # the subject "/" opens: Arabic, or on a Space of its own another one (HOME_SUBJECT=math on mathly); each also has its own path
+    home = os.environ.get("HOME_SUBJECT", "").strip() or "arabic"
+    if home not in SUBJECTS:
+        raise RuntimeError(f"HOME_SUBJECT must be one of: {', '.join(SUBJECTS)}")
+
     @app.get("/")
     def index():
-        return page("arabic")
+        return page(home)
 
     for subject in SUBJECTS:   # the same app under a class topic's own opening screen: /arabic, /math
         app.get(f"/{subject}", include_in_schema=False)(lambda subject=subject: page(subject))
 
+    def manifest(subject: str) -> Response:
+        base = json.loads((STATIC / "manifest.webmanifest").read_text(encoding="utf-8"))
+        return Response(json.dumps({**base, **MANIFESTS[subject]}, ensure_ascii=False), media_type="application/manifest+json",
+                        headers={"Cache-Control": "no-cache"})
+
+    for subject in MANIFESTS:
+        app.get(f"/{subject}/manifest.webmanifest", include_in_schema=False)(lambda subject=subject: manifest(subject))
+
     @app.get("/service-worker.js", include_in_schema=False)
     def service_worker():
         return Response(
@@ -606,14 +661,19 @@ def create_app(scorer: Scorer | None = None, tts: SawtakTTS | None = None,
         for d in [d for c in app.state.auth.classes() for d in dailies_of(c, daily_rows())] if can_manage else []:
             if d["id"] not in every or d["date"] < every[d["id"]]["date"]:
                 every[d["id"]] = d
+        # the subject whose pages the account belongs on: an admin's own, else their class's (a student has one)
+        subject = subject_code(user.get("subject")) if user else ""
+        subject = subject or next((s for c in mine if (s := subject_code(c.get("subject")))), "")
         return {"email": user["email"] if user else "", "teacher": bool(user and user["teacher"]),
+                **({"subject": subject} if subject else {}),
                 **({"tutor": True} if user and user["tutor"] else {}),   # the page shows them the flag under a score
                 "roles": user.get("roles", []) if user else [], "entitlements": user.get("entitlements", []) if user else [],
                 "permissions": user.get("permissions", []) if user else ["*"],
                 **({"dailies": sorted(every.values(), key=lambda d: (d["date"], d["id"]))} if can_all else {}),
-                "classes": [{"name": c["name"], "lessons": lessons_of(c), **homework_of(c, topics()),
-                             "dailies": dailies_of(c, daily_rows())} for c in mine],
-                **({"teaches": [{"id": c["id"], "name": c["name"], "lessons": lessons_of(c)}
+                "classes": [{"name": c["name"], "lessons": class_lessons(c), **homework_of(c, topics()),
+                             "dailies": dailies_of(c, daily_rows()),
+                             **({"subject": s} if (s := subject_code(c.get("subject"))) else {})} for c in mine],
+                **({"teaches": [{"id": c["id"], "name": c["name"], "lessons": class_lessons(c)}
                                   for c in user.get("teaches", [])]} if user and user.get("teaches") else {}),
                 "lessons": lessons}
 
@@ -628,14 +688,15 @@ def create_app(scorer: Scorer | None = None, tts: SawtakTTS | None = None,
             raise HTTPException(403, "רק מורה של הכיתה יכול/ה לנהל את המפגש")
 
     @app.get("/api/live")
-    def live_list(user: dict | None = Depends(signed_in)):
+    def live_list(response: Response, user: dict | None = Depends(signed_in)):
+        response.headers["Cache-Control"] = "no-store"
         if not user:
             return {"sessions": [], "teaches": []}
         mine = {c["id"] for c in user.get("classes", [])}
         teaches = {c["id"] for c in user.get("teaches", [])}
         sessions = app.state.live.list_for(mine | teaches, user["id"])
         return {"sessions": [{**s, "teacher": s["class_id"] in teaches} for s in sessions],
-                "teaches": [{"id": c["id"], "name": c["name"], "lessons": lessons_of(c)}
+                "teaches": [{"id": c["id"], "name": c["name"], "lessons": class_lessons(c)}
                             for c in user.get("teaches", [])]}
 
     @app.post("/api/live")
@@ -674,7 +735,8 @@ def create_app(scorer: Scorer | None = None, tts: SawtakTTS | None = None,
         return session, course
 
     @app.get("/api/live/{code}")
-    def live_status(code: str, user: dict | None = Depends(signed_in)):
+    def live_status(code: str, response: Response, user: dict | None = Depends(signed_in)):
+        response.headers["Cache-Control"] = "no-store"
         session = app.state.live.get(code)
         if not session:
             raise HTTPException(404, "המפגש הסתיים")
@@ -829,7 +891,7 @@ def create_app(scorer: Scorer | None = None, tts: SawtakTTS | None = None,
         if ranked is None:
             setup.append({"what": "הטבלה tutors לא קיימת ב-Supabase, ולכן אי אפשר לתת לתלמיד דרגת מדווח/ת (דגל 🚩 מתחת לציון).",
                           "sql": CREATE_TUTORS})
-        return {"classes": [{**c, "lessons": lessons_of(c), **homework_of(c, lesson_of)} for c in classes], "students": students,
+        return {"classes": [{**c, "lessons": class_lessons(c), **homework_of(c, lesson_of)} for c in classes], "students": students,
                 "setup": setup}
 
     @app.get("/api/activity")
@@ -992,8 +1054,9 @@ def create_app(scorer: Scorer | None = None, tts: SawtakTTS | None = None,
             users, rows = a.users(), a.access_rows()
         except AuthUnavailable as e:
             raise HTTPException(503, f"Supabase לא זמין: {e}")
+        subjects = [{"code": code, "label": label} for code, label in SUBJECT_LABELS.items()]
         if rows is None:
-            return {"admins": [], "setup": CREATE_USER_ACCESS, "migration": MIGRATE_USER_ACCESS}
+            return {"admins": [], "subjects": subjects, "setup": CREATE_USER_ACCESS, "migration": MIGRATE_USER_ACCESS}
         assigned = {r["user_id"]: r for r in rows}
         out = []
         for account in users:
@@ -1004,7 +1067,7 @@ def create_app(scorer: Scorer | None = None, tts: SawtakTTS | None = None,
             if "admin" in roles:
                 out.append({"id": account["id"], "email": account["email"], "name": account.get("name", ""),
                             "subject": str(row.get("subject") or "")})
-        return {"admins": out, "setup": "", "migration": ""}
+        return {"admins": out, "subjects": subjects, "setup": "", "migration": ""}
 
     @app.put("/api/admin-subjects/{target_id}")
     def update_admin_subject(target_id: str, body: dict = Body(...),
@@ -1012,8 +1075,8 @@ def create_app(scorer: Scorer | None = None, tts: SawtakTTS | None = None,
         if not actor or "*" not in actor.get("permissions", ()):
             raise HTTPException(403, "developers only")
         subject = " ".join(str(body.get("subject", "")).split())
-        if not subject or len(subject) > 80:
-            raise HTTPException(400, "subject must contain 1–80 characters")
+        if not subject_code(subject):   # a fixed list: a class matches its admin's subject only when both are spelled the same
+            raise HTTPException(400, "subject must be one of: " + ", ".join(SUBJECT_LABELS.values()))
         try:
             target = next((u for u in a.users() if u["id"] == target_id), None)
             if not target:
@@ -1033,6 +1096,114 @@ def create_app(scorer: Scorer | None = None, tts: SawtakTTS | None = None,
             raise HTTPException(503, f"Supabase לא זמין: {e}")
         return {"ok": True, "subject": subject}
 
+    def make_backup_archive(a: SupabaseAuth) -> tuple[str, bytes]:
+        tables, archive = a.backup_rows(), io.BytesIO()
+        tables["final_scores"] = a.final_scores()
+        with zipfile.ZipFile(archive, "w", compression=zipfile.ZIP_DEFLATED, compresslevel=6) as out:
+            manifest = {"format": "ihki-backup", "version": 1,
+                        "created_at": datetime.now(timezone.utc).isoformat(), "tables": tables, "files": []}
+            out.writestr("backup.json", json.dumps(manifest, ensure_ascii=False, separators=(",", ":")))
+        stamp = datetime.now(LOCAL_TZ).strftime("%Y-%m-%d_%H-%M-%S")
+        return f"ihki-backup-{stamp}.zip", archive.getvalue()
+
+    def apply_backup_archive(raw: bytes, a: SupabaseAuth) -> dict[str, int]:
+        with zipfile.ZipFile(io.BytesIO(raw)) as src:
+            if sum(x.file_size for x in src.infolist()) > MAX_BACKUP_UPLOAD * 2:
+                raise ValueError("הארכיון גדול מדי לאחר פתיחה")
+            manifest = json.loads(src.read("backup.json"))
+            if manifest.get("format") != "ihki-backup" or manifest.get("version") != 1:
+                raise ValueError("זה אינו קובץ גיבוי נתמך של המערכת")
+            tables, files = manifest.get("tables"), manifest.get("files")
+            if not isinstance(tables, dict) or not isinstance(files, list) or \
+                    any(not isinstance(rows, list) or any(not isinstance(row, dict) for row in rows)
+                        for rows in tables.values()):
+                raise ValueError("מבנה הנתונים בגיבוי אינו תקין")
+            restored = a.restore_rows(tables)
+            if "final_scores" in tables:
+                restored["final_scores"] = a.restore_final_scores(tables["final_scores"])
+            return restored
+
+    @app.post("/api/admin/backups")
+    def create_saved_backup(a: SupabaseAuth = Depends(require("*")), actor: dict | None = Depends(signed_in)):
+        """Create a timestamped database-only archive in the private backups bucket."""
+        if not actor or "*" not in actor.get("permissions", ()):
+            raise HTTPException(403, "developers only")
+        try:
+            name, data = make_backup_archive(a)
+            a.save_backup(name, data)
+            return {"ok": True, "name": name}
+        except AuthUnavailable as e:
+            raise HTTPException(503, f"הגיבוי נכשל: {e}")
+
+    @app.get("/api/admin/backups")
+    def saved_backups(a: SupabaseAuth = Depends(require("*")), actor: dict | None = Depends(signed_in)):
+        if not actor or "*" not in actor.get("permissions", ()):
+            raise HTTPException(403, "developers only")
+        try:
+            return {"backups": a.list_backups()}
+        except AuthUnavailable as e:
+            raise HTTPException(503, f"טעינת הגיבויים נכשלה: {e}")
+
+    @app.get("/api/admin/backups/file")
+    def download_saved_backup(name: str = Query(...), a: SupabaseAuth = Depends(require("*")),
+                              actor: dict | None = Depends(signed_in)):
+        if not actor or "*" not in actor.get("permissions", ()):
+            raise HTTPException(403, "developers only")
+        if not re.fullmatch(r"ihki-backup-\d{4}-\d{2}-\d{2}_\d{2}-\d{2}-\d{2}\.zip", name):
+            raise HTTPException(400, "שם גיבוי לא תקין")
+        try:
+            data, _ = a._get_object("backups", name)
+            return Response(data, media_type="application/zip", headers={
+                "Content-Disposition": f'attachment; filename="{name}"', "Cache-Control": "no-store"})
+        except AuthUnavailable as e:
+            raise HTTPException(503, f"הורדת הגיבוי נכשלה: {e}")
+
+    @app.get("/api/admin/backup")
+    def download_backup(a: SupabaseAuth = Depends(require("*")), actor: dict | None = Depends(signed_in)):
+        """Download a fresh archive directly; retained for manual off-site copies."""
+        if not actor or "*" not in actor.get("permissions", ()):
+            raise HTTPException(403, "developers only")
+        try:
+            name, data = make_backup_archive(a)
+            return Response(data, media_type="application/zip", headers={
+                "Content-Disposition": f'attachment; filename="{name}"', "Cache-Control": "no-store"})
+        except AuthUnavailable as e:
+            raise HTTPException(503, f"הגיבוי נכשל: {e}")
+
+    @app.post("/api/admin/backups/restore")
+    def restore_saved_backup(body: dict = Body(...), a: SupabaseAuth = Depends(require("*")),
+                             actor: dict | None = Depends(signed_in)):
+        if not actor or "*" not in actor.get("permissions", ()):
+            raise HTTPException(403, "developers only")
+        name = str(body.get("name", ""))
+        if not re.fullmatch(r"ihki-backup-\d{4}-\d{2}-\d{2}_\d{2}-\d{2}-\d{2}\.zip", name):
+            raise HTTPException(400, "שם גיבוי לא תקין")
+        try:
+            raw, _ = a._get_object("backups", name)
+            restored = apply_backup_archive(raw, a)
+            return {"ok": True, "tables": restored, "name": name}
+        except (ValueError, KeyError, json.JSONDecodeError, zipfile.BadZipFile) as e:
+            raise HTTPException(400, f"קובץ הגיבוי אינו תקין: {e}")
+        except AuthUnavailable as e:
+            raise HTTPException(503, f"השחזור נעצר: {e}")
+
+    @app.post("/api/admin/restore")
+    async def restore_backup(backup: UploadFile = File(...), a: SupabaseAuth = Depends(require("*")),
+                             actor: dict | None = Depends(signed_in)):
+        """Merge a portable app backup. It updates matching rows but never deletes unrelated current data."""
+        if not actor or "*" not in actor.get("permissions", ()):
+            raise HTTPException(403, "developers only")
+        raw = await backup.read(MAX_BACKUP_UPLOAD + 1)
+        if len(raw) > MAX_BACKUP_UPLOAD:
+            raise HTTPException(413, "קובץ הגיבוי גדול מדי (עד 250 MB)")
+        try:
+            restored = apply_backup_archive(raw, a)
+            return {"ok": True, "tables": restored}
+        except (ValueError, KeyError, json.JSONDecodeError, zipfile.BadZipFile) as e:
+            raise HTTPException(400, f"קובץ הגיבוי אינו תקין: {e}")
+        except AuthUnavailable as e:
+            raise HTTPException(503, f"השחזור נעצר: {e}")
+
     @app.get("/api/flags")
     def flags(status: str = Query("pending"), a: SupabaseAuth = Depends(teacher_only)):
         """The score reports awaiting a teacher's decision (or one reviewed state)."""
@@ -1686,6 +1857,19 @@ def create_app(scorer: Scorer | None = None, tts: SawtakTTS | None = None,
             return f"לטבלה classes חסרות עמודות. הריצו ב-SQL Editor של Supabase: {MIGRATE_CLASSES}"
         return f"Supabase לא זמין: {e}"
 
+    def class_subject(a: SupabaseAuth, id: int | None, body: dict, actor: dict | None) -> str:
+        """The subject of a class being saved: a stored class keeps its own; a new one takes its admin's, and one
+        opened by a developer (who has none) the subject the page asks for ("subject", as SUBJECT_LABELS spells it)."""
+        if id is not None:
+            try:
+                stored = next((c for c in managed_classes(a, actor, fresh=True) if c["id"] == id), None)
+            except AuthUnavailable as e:
+                raise HTTPException(503, class_store_error(e))
+            return str((stored or {}).get("subject") or "").strip()
+        own = str((actor or {}).get("subject") or "").strip()
+        asked = " ".join(str(body.get("subject") or "").split())
+        return own or (asked if subject_code(asked) else "")
+
     def save_class(a: SupabaseAuth, id: int | None, body: dict, actor: dict | None = None) -> dict:
         """Checks a class from the panel ({"name", "emails": the student list, see `class_members`, "lessons": lesson
         ids, "homeworks": [{"topic": a topic of one of them, "due": its ISO date, or ""}], each topic once; or, as
@@ -1699,10 +1883,13 @@ def create_app(scorer: Scorer | None = None, tts: SawtakTTS | None = None,
             emails, nicks = class_members(str(body.get("emails", "")))
         except ValueError as e:
             raise HTTPException(400, f"בשורה הזו אין כתובת מייל: {e}")
+        subject = class_subject(a, id, body, actor)
+        math = subject_code(subject) == "math"   # a math class studies units of the math path, and has no homework or daily videos yet
+        known = [u["id"] for u in algebra9()["units"]] if math else ALL_LESSONS
         lessons = body.get("lessons")
-        if not isinstance(lessons, list) or not lessons or not set(map(str, lessons)) <= set(ALL_LESSONS):
-            raise HTTPException(400, "בחרו לפחות שיעור אחד לכיתה")
-        lessons = [l for l in ALL_LESSONS if l in map(str, lessons)]
+        if not isinstance(lessons, list) or not lessons or not set(map(str, lessons)) <= set(known):
+            raise HTTPException(400, "בחרו לפחות יחידה אחת לכיתה" if math else "בחרו לפחות שיעור אחד לכיתה")
+        lessons = [l for l in known if l in map(str, lessons)]
         teachers = body.get("teachers")
         if teachers is not None:
             if not isinstance(teachers, list) or not all(isinstance(e, str) for e in teachers):
@@ -1710,7 +1897,7 @@ def create_app(scorer: Scorer | None = None, tts: SawtakTTS | None = None,
             teachers = list(dict.fromkeys(e.strip().lower() for e in teachers if e.strip()))
             if not set(teachers) <= set(emails):
                 raise HTTPException(400, "מורה של הכיתה צריך להיות אחד מהתלמידים הרשומים בה")
-        listed = body.get("homeworks")
+        listed = [] if math else body.get("homeworks")
         if listed is None:
             listed = [{"topic": body.get("homework"), "due": body.get("due")}]
         if not isinstance(listed, list) or len(listed) > MAX_HOMEWORKS or not all(isinstance(h, dict) for h in listed):
@@ -1728,7 +1915,7 @@ def create_app(scorer: Scorer | None = None, tts: SawtakTTS | None = None,
                 homeworks.append({"topic": topic, "due": date.fromisoformat(due).isoformat() if due else None})
             except ValueError:
                 raise HTTPException(400, "התאריך של שיעורי הבית לא תקין")
-        dailies = body.get("dailies")
+        dailies = None if math else body.get("dailies")
         if dailies is not None:
             if not isinstance(dailies, list) or len(dailies) > MAX_DAILIES or not all(isinstance(d, dict) for d in dailies):
                 raise HTTPException(400, "הסרטונים היומיים לא תקינים")
@@ -1754,7 +1941,6 @@ def create_app(scorer: Scorer | None = None, tts: SawtakTTS | None = None,
                 raise HTTPException(409, f"כבר יש כיתה בשם {taken}")
             # a class that has no daily videos, and had none, is saved without them: a table made before them takes it
             had = any(c["id"] == id and c.get("dailies") for c in visible)
-            subject = str((actor or {}).get("subject") or "").strip()
             if (id is None and hasattr(a, "access_for") and actor and "admin" in actor.get("roles", ())
                     and "developer" not in actor.get("roles", ()) and not subject):
                 raise HTTPException(409, "לא הוגדר מקצוע למנהל/ת. מפתח/ת צריך להגדיר אותו בניטור.")
@@ -2067,6 +2253,47 @@ def create_app(scorer: Scorer | None = None, tts: SawtakTTS | None = None,
             out.append({"name": c["name"], "students": students, "unnamed": len(named) - len(students)})
         return {"classes": out}
 
+    @app.get("/api/math/skills")
+    def math_skills():
+        """The math path's skill graph (see app/math_skills.py). Public, as the phrase list is."""
+        return algebra9()
+
+    photo_counts: dict[tuple[str, str], int] = {}   # (account, day) -> photos solved; in memory, so a restart resets it
+
+    def photo_solver() -> PhotoSolver:
+        """The solver on the key in use now (the panel's, else the environment's): a key changed in the panel applies."""
+        key = (app.state.keys.get("ANTHROPIC_API_KEY") or "").strip()
+        if not key:
+            raise HTTPException(503, "פתרון מתמונה לא מוגדר בשרת (חסר ANTHROPIC_API_KEY)")
+        if getattr(app.state, "photo_key", None) != key:
+            app.state.photo, app.state.photo_key = PhotoSolver(photo_client(key), math_model(), algebra9()["skills"]), key
+        return app.state.photo
+
+    @app.post("/api/math/photo")
+    def math_photo(photo: UploadFile = File(...), user: dict | None = Depends(signed_in)):
+        """A photographed problem, solved by Claude (see app/math_photo.py): {readable, problem, steps: [{hint, work}],
+        answer, skill, note, left}. `left` is how many photos the account has left today (None: no limit). 429 past
+        DAILY_PHOTOS a day (developers and an open service are exempt), 502 when the model did not solve it."""
+        solver = photo_solver()
+        day = datetime.now(LOCAL_TZ).date().isoformat()
+        who = (user["id"], day) if user and "developer" not in user.get("roles", ()) else None
+        if who and photo_counts.get(who, 0) >= DAILY_PHOTOS:
+            raise HTTPException(429, f"צילמתם {DAILY_PHOTOS} תרגילים היום. נתראה מחר!")
+        if photo.content_type not in PHOTO_TYPES:
+            raise HTTPException(415, "אפשר לשלוח תמונה מסוג JPEG,‏ PNG או WebP.")
+        image = photo.file.read(MAX_PHOTO + 1)
+        if not image:
+            raise HTTPException(400, "התמונה ריקה.")
+        if len(image) > MAX_PHOTO:
+            raise HTTPException(413, "התמונה גדולה מדי.")
+        try:
+            out = solver.solve(image, photo.content_type)
+        except PhotoUnavailable as e:
+            raise HTTPException(502, str(e))
+        if who and out.get("readable"):   # an unreadable photo does not count against the day
+            photo_counts[who] = photo_counts.get(who, 0) + 1
+        return {**out, "left": DAILY_PHOTOS - photo_counts.get(who, 0) if who else None}
+
     @app.get("/api/phrases")
     def phrases():
         return {"levels": LEVELS, "lessons": LESSONS, "categories": CATEGORIES, "games": GAMES, "phrases": public_phrases(),

app/math_algebra9.json

@@ -0,0 +1,2380 @@
+{
+ "source": {
+  "schedule": "https://meyda.education.gov.il/files/Pop/0files/matmatika/Chativat-Beynayim/tashpaz/prisa_9A.pdf",
+  "summer": "https://pop.education.gov.il/maagal_hashana/summer-preparatory/mathematics-9-5/"
+ },
+ "mastery": "5 תשובות נכונות מתוך 6 האחרונות, מהן 2 לפחות ברמה 2",
+ "units": [
+  {
+   "id": "f",
+   "name": "יסודות",
+   "source": "חזרה מכיתות ז׳–ח׳",
+   "when": ""
+  },
+  {
+   "id": "t",
+   "name": "טכניקה אלגברית",
+   "source": "פריסת ט׳",
+   "when": "ספטמבר–אוקטובר, ינואר"
+  },
+  {
+   "id": "n",
+   "name": "תכונות של פונקציה",
+   "source": "פריסת ט׳",
+   "when": "מרץ"
+  },
+  {
+   "id": "q",
+   "name": "פונקציה ומשוואה ריבועית",
+   "source": "פריסת ט׳",
+   "when": "נובמבר–פברואר"
+  },
+  {
+   "id": "p",
+   "name": "חזקות ושורשים",
+   "source": "פריסת ט׳",
+   "when": "מאי"
+  },
+  {
+   "id": "w",
+   "name": "שאלות מילוליות",
+   "source": "פריסת ט׳",
+   "when": "מאי"
+  }
+ ],
+ "skills": [
+  {
+   "id": "f_neg",
+   "unit": "f",
+   "name": "מספרים מכוונים",
+   "short": "מספרים מכוונים",
+   "prereqs": [],
+   "description": "ארבע פעולות עם מספרים שליליים, כולל חיסור של מספר שלילי.",
+   "sample": {
+    "question": "$−3 − (−5)·2 = ?$",
+    "choices": [
+     {
+      "text": "$7$",
+      "correct": true
+     },
+     {
+      "text": "$−13$",
+      "mistake": "minus_minus"
+     },
+     {
+      "text": "$4$",
+      "mistake": "order_ops"
+     },
+     {
+      "text": "$−7$",
+      "mistake": "result_sign"
+     }
+    ]
+   }
+  },
+  {
+   "id": "f_frac",
+   "unit": "f",
+   "name": "פעולות בשברים",
+   "short": "שברים",
+   "prereqs": [],
+   "description": "חיבור, חיסור, כפל וחילוק של שברים, כולל מכנה משותף.",
+   "sample": {
+    "question": "$2/3 + 1/4 = ?$",
+    "choices": [
+     {
+      "text": "$11/12$",
+      "correct": true
+     },
+     {
+      "text": "$3/7$",
+      "mistake": "add_denoms"
+     },
+     {
+      "text": "$3/12$",
+      "mistake": "scale_numerators"
+     },
+     {
+      "text": "$1/6$",
+      "mistake": "mult_not_add"
+     }
+    ]
+   }
+  },
+  {
+   "id": "f_ops",
+   "unit": "f",
+   "name": "סדר פעולות והצבה",
+   "short": "סדר פעולות",
+   "prereqs": [
+    "f_neg",
+    "f_frac"
+   ],
+   "description": "הצבת מספרים, גם שליליים, בביטוי אלגברי לפי סדר הפעולות.",
+   "sample": {
+    "question": "הציבו $x = −2$:  $3x² − x = ?$",
+    "choices": [
+     {
+      "text": "$14$",
+      "correct": true
+     },
+     {
+      "text": "$−10$",
+      "mistake": "neg_square"
+     },
+     {
+      "text": "$38$",
+      "mistake": "coef_in_power"
+     },
+     {
+      "text": "$10$",
+      "mistake": "minus_minus"
+     }
+    ]
+   }
+  },
+  {
+   "id": "f_like",
+   "unit": "f",
+   "name": "כינוס איברים דומים",
+   "short": "כינוס איברים",
+   "prereqs": [
+    "f_ops"
+   ],
+   "description": "פישוט ביטוי בחיבור וחיסור של איברים דומים.",
+   "sample": {
+    "question": "$5a − 2b − 3a + 4b = ?$",
+    "choices": [
+     {
+      "text": "$2a + 2b$",
+      "correct": true
+     },
+     {
+      "text": "$4ab$",
+      "mistake": "join_unlike"
+     },
+     {
+      "text": "$8a + 2b$",
+      "mistake": "sign_of_term"
+     },
+     {
+      "text": "$2a − 6b$",
+      "mistake": "sign_of_term"
+     }
+    ]
+   }
+  },
+  {
+   "id": "f_power",
+   "unit": "f",
+   "name": "חזקה כמכפלה חוזרת",
+   "short": "חזקה בסיסית",
+   "prereqs": [
+    "f_ops"
+   ],
+   "description": "$x² = x·x$, וגם המקדם עולה בחזקה. הפריסה דורשת רק את זה לפני הטכניקה האלגברית.",
+   "sample": {
+    "question": "$(−3x)² = ?$",
+    "choices": [
+     {
+      "text": "$9x²$",
+      "correct": true
+     },
+     {
+      "text": "$−9x²$",
+      "mistake": "neg_square"
+     },
+     {
+      "text": "$−3x²$",
+      "mistake": "coef_not_raised"
+     },
+     {
+      "text": "$−6x²$",
+      "mistake": "power_as_mult"
+     }
+    ]
+   }
+  },
+  {
+   "id": "f_dist",
+   "unit": "f",
+   "name": "חוק הפילוג",
+   "short": "חוק הפילוג",
+   "prereqs": [
+    "f_like"
+   ],
+   "description": "מספר כפול סוגריים: $a(b + c) = ab + ac$.",
+   "sample": {
+    "question": "$−2(3x − 4) + 5x = ?$",
+    "choices": [
+     {
+      "text": "$−x + 8$",
+      "correct": true
+     },
+     {
+      "text": "$−x − 8$",
+      "mistake": "sign_product"
+     },
+     {
+      "text": "$−x − 4$",
+      "mistake": "partial_dist"
+     }
+    ]
+   }
+  },
+  {
+   "id": "f_lin",
+   "unit": "f",
+   "name": "משוואה ממעלה ראשונה",
+   "short": "משוואה קווית",
+   "prereqs": [
+    "f_dist"
+   ],
+   "description": "פתרון משוואה עם סוגריים, כולל משוואה בלי פתרון או עם אינסוף פתרונות.",
+   "sample": {
+    "question": "$3(x − 2) = x + 8$.  $x = ?$",
+    "choices": [
+     {
+      "text": "$7$",
+      "correct": true
+     },
+     {
+      "text": "$5$",
+      "mistake": "partial_dist"
+     },
+     {
+      "text": "$1$",
+      "mistake": "move_sign"
+     }
+    ]
+   }
+  },
+  {
+   "id": "f_linfun",
+   "unit": "f",
+   "name": "פונקציה קווית",
+   "short": "פונקציה קווית",
+   "prereqs": [
+    "f_lin"
+   ],
+   "description": "שיפוע, נקודת חיתוך עם ציר y, וישר דרך שתי נקודות.",
+   "sample": {
+    "question": "מהו השיפוע של הישר העובר דרך $(1, 2)$ ו־$(3, 8)$?",
+    "choices": [
+     {
+      "text": "$3$",
+      "correct": true
+     },
+     {
+      "text": "$1/3$",
+      "mistake": "slope_inverted"
+     },
+     {
+      "text": "$6$",
+      "mistake": "slope_dy_only"
+     }
+    ]
+   }
+  },
+  {
+   "id": "f_sys",
+   "unit": "f",
+   "name": "מערכת משוואות קוויות",
+   "short": "מערכת קווית",
+   "prereqs": [
+    "f_linfun"
+   ],
+   "description": "פתרון מערכת של שתי משוואות בהצבה או בהשוואת מקדמים.",
+   "sample": {
+    "question": "$x + y = 10$ ,  $x − y = 4$.  $(x, y) = ?$",
+    "choices": [
+     {
+      "text": "$(7, 3)$",
+      "correct": true
+     },
+     {
+      "text": "$(3, 7)$",
+      "mistake": "swapped_pair"
+     },
+     {
+      "text": "$(14, −4)$",
+      "mistake": "forgot_divide"
+     }
+    ]
+   }
+  },
+  {
+   "id": "f_sqrt",
+   "unit": "f",
+   "name": "שורש ריבועי",
+   "short": "שורש ריבועי",
+   "prereqs": [
+    "f_neg"
+   ],
+   "description": "שורש ריבועי של מספר, וההבדל בין שורש של סכום לסכום שורשים.",
+   "sample": {
+    "question": "$√(9 + 16) = ?$",
+    "choices": [
+     {
+      "text": "$5$",
+      "correct": true
+     },
+     {
+      "text": "$7$",
+      "mistake": "sqrt_split"
+     },
+     {
+      "text": "$12.5$",
+      "mistake": "sqrt_half"
+     }
+    ]
+   }
+  },
+  {
+   "id": "t_ext",
+   "unit": "t",
+   "name": "חוק הפילוג המורחב",
+   "short": "פילוג מורחב",
+   "prereqs": [
+    "f_dist"
+   ],
+   "description": "סוגריים כפול סוגריים, ופישוט ביטויים בעזרתו.",
+   "month": "ספטמבר",
+   "core": true,
+   "sample": {
+    "question": "$(x + 3)(x − 5) = ?$",
+    "choices": [
+     {
+      "text": "$x² − 2x − 15$",
+      "correct": true
+     },
+     {
+      "text": "$x² − 15$",
+      "mistake": "first_last_only"
+     },
+     {
+      "text": "$x² − 8x − 15$",
+      "mistake": "sign_of_term"
+     },
+     {
+      "text": "$x² − 2x + 15$",
+      "mistake": "sign_product"
+     }
+    ]
+   }
+  },
+  {
+   "id": "t_ext_eq",
+   "unit": "t",
+   "name": "משוואות בעזרת הפילוג המורחב",
+   "short": "משוואה בפילוג",
+   "prereqs": [
+    "t_ext",
+    "f_lin"
+   ],
+   "description": "פתיחת סוגריים בשני האגפים, ולעתים קרובות $x²$ מצטמצם.",
+   "month": "ספטמבר",
+   "sample": {
+    "question": "$(x + 2)(x − 3) = x² + 4$.  $x = ?$",
+    "choices": [
+     {
+      "text": "$−10$",
+      "correct": true
+     },
+     {
+      "text": "$10$",
+      "mistake": "div_neg"
+     },
+     {
+      "text": "אין פתרון",
+      "mistake": "first_last_only"
+     }
+    ]
+   }
+  },
+  {
+   "id": "t_square",
+   "unit": "t",
+   "name": "ריבוע של סכום והפרש",
+   "short": "ריבוע סכום",
+   "prereqs": [
+    "t_ext",
+    "f_power"
+   ],
+   "description": "$(a ± b)² = a² ± 2ab + b²$, בפיתוח אלגברי ובהמחשה גיאומטרית.",
+   "month": "ספטמבר",
+   "core": true,
+   "sample": {
+    "question": "$(2x − 3)² = ?$",
+    "choices": [
+     {
+      "text": "$4x² − 12x + 9$",
+      "correct": true
+     },
+     {
+      "text": "$4x² − 9$",
+      "mistake": "forgot_middle"
+     },
+     {
+      "text": "$2x² − 12x + 9$",
+      "mistake": "coef_not_raised"
+     },
+     {
+      "text": "$4x² − 6x + 9$",
+      "mistake": "middle_no_2"
+     }
+    ]
+   }
+  },
+  {
+   "id": "t_diffsq",
+   "unit": "t",
+   "name": "הפרש ריבועים",
+   "short": "הפרש ריבועים",
+   "prereqs": [
+    "t_ext"
+   ],
+   "description": "$(a − b)(a + b) = a² − b²$, גם לחישוב בעל־פה.",
+   "month": "ספטמבר",
+   "core": true,
+   "sample": {
+    "question": "חשבו בעל־פה: $51 · 49 = ?$",
+    "choices": [
+     {
+      "text": "$2499$",
+      "correct": true
+     },
+     {
+      "text": "$2501$",
+      "mistake": "diff_sign"
+     },
+     {
+      "text": "$2500$",
+      "mistake": "forgot_b2"
+     }
+    ]
+   }
+  },
+  {
+   "id": "t_gcf",
+   "unit": "t",
+   "name": "הוצאת גורם משותף",
+   "short": "גורם משותף",
+   "prereqs": [
+    "f_dist"
+   ],
+   "description": "פירוק לגורמים בהוצאת הגורם המשותף הגדול ביותר.",
+   "month": "אוקטובר",
+   "core": true,
+   "sample": {
+    "question": "פרקו: $6x² − 9x$",
+    "choices": [
+     {
+      "text": "$3x(2x − 3)$",
+      "correct": true
+     },
+     {
+      "text": "$3(2x² − 3x)$",
+      "mistake": "partial_gcf"
+     },
+     {
+      "text": "$x(6x − 9)$",
+      "mistake": "partial_gcf"
+     },
+     {
+      "text": "$3x(2x − 3x)$",
+      "mistake": "divide_each"
+     }
+    ]
+   }
+  },
+  {
+   "id": "t_factor_formula",
+   "unit": "t",
+   "name": "פירוק בנוסחאות הכפל המקוצר",
+   "short": "פירוק בנוסחאות",
+   "prereqs": [
+    "t_square",
+    "t_diffsq",
+    "t_gcf",
+    "f_sqrt"
+   ],
+   "description": "זיהוי הפרש ריבועים וריבוע של סכום בביטוי, ופירוקו.",
+   "month": "אוקטובר",
+   "sample": {
+    "question": "פרקו: $4x² − 25$",
+    "choices": [
+     {
+      "text": "$(2x − 5)(2x + 5)$",
+      "correct": true
+     },
+     {
+      "text": "$(2x − 5)²$",
+      "mistake": "diff_vs_square"
+     },
+     {
+      "text": "$(4x − 5)(4x + 5)$",
+      "mistake": "root_of_coef"
+     }
+    ]
+   }
+  },
+  {
+   "id": "t_trinomial",
+   "unit": "t",
+   "name": "פירוק טרינום $x² + bx + c$",
+   "short": "פירוק טרינום",
+   "prereqs": [
+    "t_ext"
+   ],
+   "description": "שני מספרים שמכפלתם c וסכומם b. לפי הפריסה רק כשהמקדם של $x²$ הוא 1.",
+   "month": "אוקטובר",
+   "sample": {
+    "question": "פרקו: $x² − x − 12$",
+    "choices": [
+     {
+      "text": "$(x − 4)(x + 3)$",
+      "correct": true
+     },
+     {
+      "text": "$(x + 4)(x − 3)$",
+      "mistake": "signs_swapped"
+     },
+     {
+      "text": "$(x − 6)(x + 2)$",
+      "mistake": "product_only"
+     },
+     {
+      "text": "$(x − 12)(x + 1)$",
+      "mistake": "product_only"
+     }
+    ]
+   }
+  },
+  {
+   "id": "t_domain",
+   "unit": "t",
+   "name": "תחום הצבה",
+   "short": "תחום הצבה",
+   "prereqs": [
+    "f_lin"
+   ],
+   "description": "אילו ערכים אסור להציב כי הם מאפסים את המכנה.",
+   "month": "ינואר",
+   "sample": {
+    "question": "מהו תחום ההצבה של $(x + 1)/(x(x + 4))$?",
+    "choices": [
+     {
+      "text": "$x ≠ 0$ ,  $x ≠ −4$",
+      "correct": true
+     },
+     {
+      "text": "$x ≠ 0$ ,  $x ≠ 4$",
+      "mistake": "zero_root_sign"
+     },
+     {
+      "text": "$x ≠ 0$ בלבד",
+      "mistake": "one_factor_only"
+     },
+     {
+      "text": "$x ≠ 0$ ,  $x ≠ −4$ ,  $x ≠ −1$",
+      "mistake": "numerator_domain"
+     }
+    ]
+   }
+  },
+  {
+   "id": "t_reduce",
+   "unit": "t",
+   "name": "צמצום שברים אלגבריים",
+   "short": "צמצום שברים",
+   "prereqs": [
+    "t_factor_formula",
+    "t_trinomial",
+    "t_domain"
+   ],
+   "description": "פירוק המונה והמכנה לגורמים וצמצום גורמים משותפים.",
+   "month": "אוקטובר",
+   "sample": {
+    "question": "צמצמו: $(x² − 9)/(x² + 5x + 6)$",
+    "choices": [
+     {
+      "text": "$(x − 3)/(x + 2)$",
+      "correct": true
+     },
+     {
+      "text": "$−9/(5x + 6)$",
+      "mistake": "cancel_terms"
+     },
+     {
+      "text": "$−3/2$",
+      "mistake": "cancel_terms"
+     },
+     {
+      "text": "$(x + 3)/(x + 2)$",
+      "mistake": "factor_sign"
+     }
+    ]
+   }
+  },
+  {
+   "id": "t_muldiv",
+   "unit": "t",
+   "name": "כפל וחילוק שברים אלגבריים",
+   "short": "כפל וחילוק שברים",
+   "prereqs": [
+    "t_reduce"
+   ],
+   "description": "כפל מונים ומכנים, חילוק ככפל בהופכי, ופירוק לפני צמצום.",
+   "month": "אוקטובר",
+   "sample": {
+    "question": "$2x/(x + 1)  :  4x²/(x² − 1) = ?$",
+    "choices": [
+     {
+      "text": "$(x − 1)/(2x)$",
+      "correct": true
+     },
+     {
+      "text": "$8x³/((x + 1)²(x − 1))$",
+      "mistake": "div_not_flipped"
+     },
+     {
+      "text": "$(x − 1)/2$",
+      "mistake": "cancel_power"
+     },
+     {
+      "text": "$(x + 1)/(2x)$",
+      "mistake": "factor_sign"
+     }
+    ]
+   }
+  },
+  {
+   "id": "t_fraceq",
+   "unit": "t",
+   "name": "משוואות רציונליות",
+   "short": "משוואה רציונלית",
+   "prereqs": [
+    "t_reduce",
+    "q_eq_simple"
+   ],
+   "description": "פירוק המכנים, תחום הצבה, ופסילת פתרון שאינו קביל.",
+   "month": "ינואר",
+   "sample": {
+    "question": "$x²/(x − 3) = 9/(x − 3)$.  $x = ?$",
+    "choices": [
+     {
+      "text": "$x = −3$",
+      "correct": true
+     },
+     {
+      "text": "$x = 3$ או $x = −3$",
+      "mistake": "excluded_root"
+     },
+     {
+      "text": "$x = 3$",
+      "mistake": "excluded_root"
+     }
+    ]
+   }
+  },
+  {
+   "id": "n_intercepts",
+   "unit": "n",
+   "name": "נקודות חיתוך עם הצירים",
+   "short": "חיתוך עם הצירים",
+   "prereqs": [
+    "f_linfun"
+   ],
+   "description": "חיתוך עם ציר x: $y = 0$. חיתוך עם ציר y: $x = 0$. כל נקודה היא זוג סדור.",
+   "month": "מרץ",
+   "core": true,
+   "sample": {
+    "question": "מהן נקודות החיתוך של $f(x) = 2x − 6$ עם הצירים?",
+    "choices": [
+     {
+      "text": "$(3, 0)$ ,  $(0, −6)$",
+      "correct": true
+     },
+     {
+      "text": "$(−6, 0)$ ,  $(0, 3)$",
+      "mistake": "axes_mixed"
+     },
+     {
+      "text": "$(3, 0)$ ,  $(0, 6)$",
+      "mistake": "sign_product"
+     }
+    ]
+   }
+  },
+  {
+   "id": "n_sign",
+   "unit": "n",
+   "name": "תחומי חיוביות ושליליות",
+   "short": "חיוביות ושליליות",
+   "prereqs": [
+    "n_intercepts"
+   ],
+   "description": "איפה הגרף מעל ציר x ואיפה מתחתיו.",
+   "month": "מרץ",
+   "core": true,
+   "sample": {
+    "question": "באיזה תחום הפונקציה שבגרף שלילית?",
+    "graph": {
+     "points": [
+      [
+       -3,
+       -3
+      ],
+      [
+       -2,
+       0
+      ],
+      [
+       -0.5,
+       2
+      ],
+      [
+       1,
+       0
+      ],
+      [
+       2.5,
+       -2
+      ],
+      [
+       4,
+       0
+      ],
+      [
+       5,
+       2
+      ]
+     ],
+     "x": [
+      -3.5,
+      5.5
+     ],
+     "y": [
+      -3.5,
+      3.5
+     ]
+    },
+    "choices": [
+     {
+      "text": "$x < −2$ או $1 < x < 4$",
+      "correct": true
+     },
+     {
+      "text": "$−2 < x < 1$ או $x > 4$",
+      "mistake": "pos_neg_swap"
+     },
+     {
+      "text": "$x < 0$",
+      "mistake": "neg_x"
+     },
+     {
+      "text": "$1 < x < 4$ בלבד",
+      "mistake": "partial_intervals"
+     }
+    ]
+   }
+  },
+  {
+   "id": "n_extremum",
+   "unit": "n",
+   "name": "נקודות קיצון ותחומי עלייה וירידה",
+   "short": "קיצון, עלייה וירידה",
+   "prereqs": [
+    "n_sign"
+   ],
+   "description": "קריאה מהגרף: איפה הפונקציה עולה, איפה יורדת, ואיפה היא מחליפה כיוון.",
+   "month": "מרץ",
+   "core": true,
+   "sample": {
+    "question": "באילו תחומים הפונקציה שבגרף יורדת? (התחום המוצג: $−4 ≤ x ≤ 5$)",
+    "graph": {
+     "points": [
+      [
+       -4,
+       1
+      ],
+      [
+       -2,
+       4
+      ],
+      [
+       1,
+       -2
+      ],
+      [
+       3,
+       1
+      ],
+      [
+       5,
+       -1
+      ]
+     ],
+     "x": [
+      -4.5,
+      5.5
+     ],
+     "y": [
+      -3,
+      5
+     ]
+    },
+    "choices": [
+     {
+      "text": "$−2 < x < 1$ או $3 < x < 5$",
+      "correct": true
+     },
+     {
+      "text": "$−2 < x < 1$ בלבד",
+      "mistake": "partial_intervals"
+     },
+     {
+      "text": "$−2 < y < 4$",
+      "mistake": "x_vs_y_interval"
+     },
+     {
+      "text": "$−4 < x < −2$ או $1 < x < 3$",
+      "mistake": "dir_confusion"
+     }
+    ]
+   }
+  },
+  {
+   "id": "n_local_abs",
+   "unit": "n",
+   "name": "קיצון מקומי וקיצון מוחלט",
+   "short": "מקומי ומוחלט",
+   "prereqs": [
+    "n_extremum"
+   ],
+   "description": "ערך הקיצון הוא שיעור ה־y של הנקודה. מקסימום מקומי אינו בהכרח הגבוה ביותר. יש פונקציות בלי קיצון.",
+   "month": "מרץ",
+   "core": true,
+   "sample": {
+    "question": "מהו ערך המקסימום המוחלט של הפונקציה בתחום המוצג?",
+    "graph": {
+     "points": [
+      [
+       -3,
+       -1
+      ],
+      [
+       -1,
+       3
+      ],
+      [
+       1,
+       0
+      ],
+      [
+       3,
+       5
+      ],
+      [
+       4,
+       4
+      ]
+     ],
+     "x": [
+      -3.5,
+      4.5
+     ],
+     "y": [
+      -2,
+      6
+     ]
+    },
+    "choices": [
+     {
+      "text": "$5$",
+      "correct": true
+     },
+     {
+      "text": "$3$",
+      "mistake": "local_as_abs"
+     },
+     {
+      "text": "$(3, 5)$",
+      "mistake": "value_vs_point"
+     },
+     {
+      "text": "$x = 3$",
+      "mistake": "value_vs_point"
+     }
+    ]
+   }
+  },
+  {
+   "id": "n_eq_graph",
+   "unit": "n",
+   "name": "משוואה וגרף: $f(x) = m$",
+   "short": "f(x) = m",
+   "prereqs": [
+    "n_intercepts"
+   ],
+   "description": "מספר הפתרונות של $f(x) = m$ הוא מספר הפעמים שהגרף ��וגש את הישר $y = m$.",
+   "month": "מרץ",
+   "core": true,
+   "sample": {
+    "question": "לכמה פתרונות יש המשוואה $f(x) = 1$ בתחום המוצג?",
+    "graph": {
+     "points": [
+      [
+       -4,
+       3
+      ],
+      [
+       -2,
+       -1
+      ],
+      [
+       0,
+       2
+      ],
+      [
+       2,
+       -2
+      ],
+      [
+       4,
+       0
+      ]
+     ],
+     "x": [
+      -4.5,
+      4.5
+     ],
+     "y": [
+      -3,
+      4
+     ]
+    },
+    "choices": [
+     {
+      "text": "$3$",
+      "correct": true
+     },
+     {
+      "text": "$1$",
+      "mistake": "x_equals_m"
+     },
+     {
+      "text": "$2$",
+      "mistake": "count_all"
+     }
+    ]
+   }
+  },
+  {
+   "id": "n_vshift",
+   "unit": "n",
+   "name": "הזזה אנכית של פונקציה",
+   "short": "הזזה אנכית",
+   "prereqs": [
+    "n_extremum"
+   ],
+   "description": "$f(x) + k$ מזיז את הגרף למעלה או למטה. נקודות הקיצון זזות, תחומי העלייה והירידה נשמרים.",
+   "month": "מרץ",
+   "core": true,
+   "sample": {
+    "question": "ל־f מקסימום ב־$(2, 5)$. מהו המקסימום של $g(x) = f(x) − 3$?",
+    "choices": [
+     {
+      "text": "$(2, 2)$",
+      "correct": true
+     },
+     {
+      "text": "$(2, 8)$",
+      "mistake": "vshift_dir"
+     },
+     {
+      "text": "$(−1, 5)$",
+      "mistake": "vshift_as_h"
+     }
+    ]
+   }
+  },
+  {
+   "id": "n_hshift",
+   "unit": "n",
+   "name": "הזזה אופקית של פונקציה",
+   "short": "הזזה אופקית",
+   "prereqs": [
+    "n_extremum"
+   ],
+   "description": "$f(x − b)$ מזיז את הגרף ימינה כש־$b > 0$. הפריסה מציינת שתלמידים נוטים להזיז לכיוון הלא נכון.",
+   "month": "מרץ",
+   "core": true,
+   "sample": {
+    "question": "ל־f מינימום ב־$(1, −4)$. מהו המינימום של $g(x) = f(x − 3)$?",
+    "choices": [
+     {
+      "text": "$(4, −4)$",
+      "correct": true
+     },
+     {
+      "text": "$(−2, −4)$",
+      "mistake": "hshift_sign"
+     },
+     {
+      "text": "$(1, −7)$",
+      "mistake": "h_as_v"
+     }
+    ]
+   }
+  },
+  {
+   "id": "n_reflect",
+   "unit": "n",
+   "name": "שיקוף ביחס לציר x",
+   "short": "שיקוף",
+   "prereqs": [
+    "n_extremum"
+   ],
+   "description": "$−f(x)$ הופך את הגרף: מקסימום הופך למינימום, וחיוביות לשליליות.",
+   "month": "מרץ",
+   "core": true,
+   "sample": {
+    "question": "ל־f מקסימום ב־$(−2, 3)$. מה יש ל־$g(x) = −f(x)$?",
+    "choices": [
+     {
+      "text": "מינימום ב־$(−2, −3)$",
+      "correct": true
+     },
+     {
+      "text": "מקסימום ב־$(−2, −3)$",
+      "mistake": "reflect_type"
+     },
+     {
+      "text": "מקסימום ב־$(2, 3)$",
+      "mistake": "reflect_axis"
+     }
+    ]
+   }
+  },
+  {
+   "id": "n_props_graph",
+   "unit": "n",
+   "name": "מתכונות לגרף",
+   "short": "מתכונות לגרף",
+   "prereqs": [
+    "n_local_abs"
+   ],
+   "description": "סרטוט גרף שמתאים לתכונות נתונות, והסקת תכונות נוספות מהן.",
+   "month": "מרץ",
+   "core": true,
+   "sample": {
+    "question": "f עולה ב־$x < 2$, יורדת ב־$x > 2$, ו־$f(2) = −1$. כמה נקודות חיתוך עם ציר x יש לה?",
+    "choices": [
+     {
+      "text": "אף אחת",
+      "correct": true
+     },
+     {
+      "text": "שתיים",
+      "mistake": "max_below"
+     },
+     {
+      "text": "אחת",
+      "mistake": "max_below"
+     }
+    ]
+   }
+  },
+  {
+   "id": "q_parabola",
+   "unit": "q",
+   "name": "הפרבולה $f(x) = ax²$",
+   "short": "הפרבולה ax²",
+   "prereqs": [
+    "n_extremum",
+    "f_power"
+   ],
+   "description": "לפי הפריסה, a קובע רק את סוג הקיצון: $a > 0$ מינימום, $a < 0$ מקסימום. בלי מתיחה וכיווץ.",
+   "month": "נובמבר",
+   "core": true,
+   "sample": {
+    "question": "מהי נקודת הקיצון של $f(x) = −2x²$, ומה סוגה?",
+    "choices": [
+     {
+      "text": "מקסימום $(0, 0)$",
+      "correct": true
+     },
+     {
+      "text": "מינימום $(0, 0)$",
+      "mistake": "opening_sign"
+     },
+     {
+      "text": "מקסימום $(0, −2)$",
+      "mistake": "a_as_vertex"
+     }
+    ]
+   }
+  },
+  {
+   "id": "q_vshift",
+   "unit": "q",
+   "name": "הזזה אנכית $ax² + k$",
+   "short": "ax² + k",
+   "prereqs": [
+    "q_parabola",
+    "n_vshift",
+    "f_sqrt"
+   ],
+   "description": "קודקוד $(0, k)$, נקודות חיתוך עם הצירים, ותחומי חיוביות ושליליות.",
+   "month": "נובמבר",
+   "core": true,
+   "sample": {
+    "question": "מהן נקודות החיתוך של $y = x² − 4$ עם ציר x?",
+    "choices": [
+     {
+      "text": "$(2, 0)$ ,  $(−2, 0)$",
+      "correct": true
+     },
+     {
+      "text": "$(0, −4)$",
+      "mistake": "axes_mixed"
+     },
+     {
+      "text": "$(2, 0)$ בלבד",
+      "mistake": "missing_neg_root"
+     },
+     {
+      "text": "$(4, 0)$ ,  $(−4, 0)$",
+      "mistake": "forgot_root"
+     }
+    ]
+   }
+  },
+  {
+   "id": "q_hshift",
+   "unit": "q",
+   "name": "הזזה אופקית $a(x − b)²$",
+   "short": "a(x − b)²",
+   "prereqs": [
+    "q_parabola",
+    "n_hshift"
+   ],
+   "description": "קודקוד $(b, 0)$ וציר סימטריה $x = b$.",
+   "month": "נובמבר",
+   "core": true,
+   "sample": {
+    "question": "מהו הקודקוד של $y = (x + 3)²$?",
+    "choices": [
+     {
+      "text": "$(−3, 0)$",
+      "correct": true
+     },
+     {
+      "text": "$(3, 0)$",
+      "mistake": "hshift_sign"
+     },
+     {
+      "text": "$(0, 3)$",
+      "mistake": "h_as_v"
+     },
+     {
+      "text": "$(0, 9)$",
+      "mistake": "plug_zero"
+     }
+    ]
+   }
+  },
+  {
+   "id": "q_vertex",
+   "unit": "q",
+   "name": "הצגה קודקודית $a(x − b)² + k$",
+   "short": "הצגה קודקודית",
+   "prereqs": [
+    "q_vshift",
+    "q_hshift"
+   ],
+   "description": "שילוב שתי ההזזות: קודקוד $(b, k)$, וסוג הקיצון לפי הסימן של a.",
+   "month": "נובמבר",
+   "core": true,
+   "sample": {
+    "question": "מהי נקודת הקיצון של $f(x) = −2(x − 3)² + 8$?",
+    "choices": [
+     {
+      "text": "מקסימום $(3, 8)$",
+      "correct": true
+     },
+     {
+      "text": "מינימום $(3, 8)$",
+      "mistake": "opening_sign"
+     },
+     {
+      "text": "מקסימום $(−3, 8)$",
+      "mistake": "hshift_sign"
+     },
+     {
+      "text": "מקסימום $(3, −8)$",
+      "mistake": "k_sign"
+     }
+    ]
+   }
+  },
+  {
+   "id": "q_zero_prod",
+   "unit": "q",
+   "name": "מכפלה שווה לאפס",
+   "short": "מכפלה = 0",
+   "prereqs": [
+    "f_lin"
+   ],
+   "description": "$a(x − m)(x − n) = 0$: כל גורם שמתאפס נותן פתרון.",
+   "month": "אוקטובר",
+   "sample": {
+    "question": "$(x − 3)(2x + 1) = 0$.  $x = ?$",
+    "choices": [
+     {
+      "text": "$x = 3$ ,  $x = −½$",
+      "correct": true
+     },
+     {
+      "text": "$x = −3$ ,  $x = ½$",
+      "mistake": "zero_sign"
+     },
+     {
+      "text": "$x = 3$ ,  $x = −2$",
+      "mistake": "divide_wrong"
+     }
+    ]
+   }
+  },
+  {
+   "id": "q_fform",
+   "unit": "q",
+   "name": "הצגה כמכפלה",
+   "short": "הצגה כמכפלה",
+   "prereqs": [
+    "q_parabola",
+    "q_zero_prod"
+   ],
+   "description": "$f(x) = a(x − m)(x − n)$: נקודות אפס, וציר סימטריה באמצע ביניהן.",
+   "month": "נובמבר",
+   "core": true,
+   "sample": {
+    "question": "ל־$h(x) = 2(x − 1)(x − 5)$: מהן נקודות האפס ומהו ציר הסימטריה?",
+    "choices": [
+     {
+      "text": "אפסים $1, 5$ · ציר $x = 3$",
+      "correct": true
+     },
+     {
+      "text": "אפסים $−1, −5$ · ציר $x = −3$",
+      "mistake": "zero_sign"
+     },
+     {
+      "text": "אפסים $1, 5$ · ציר $x = 2$",
+      "mistake": "axis_middle"
+     },
+     {
+      "text": "אפסים $2, 1, 5$ · ציר $x = 3$",
+      "mistake": "a_as_zero"
+     }
+    ]
+   }
+  },
+  {
+   "id": "q_sform",
+   "unit": "q",
+   "name": "הצגה סטנדרטית וקודקוד אלגברי",
+   "short": "הצגה סטנדרטית",
+   "prereqs": [
+    "q_fform",
+    "q_vertex"
+   ],
+   "description": "$ax² + bx + c$: ציר סימטריה $x = −b/(2a)$, קודקוד, וחיתוך עם ציר y ב־$(0, c)$.",
+   "month": "נובמבר",
+   "core": true,
+   "sample": {
+    "question": "מהו הקודקוד של $y = x² − 6x + 5$?",
+    "choices": [
+     {
+      "text": "$(3, −4)$",
+      "correct": true
+     },
+     {
+      "text": "$(−3, 32)$",
+      "mistake": "axis_sign"
+     },
+     {
+      "text": "$(6, 5)$",
+      "mistake": "forgot_2a_axis"
+     },
+     {
+      "text": "$(0, 5)$",
+      "mistake": "c_as_vertex"
+     }
+    ]
+   }
+  },
+  {
+   "id": "q_from_points",
+   "unit": "q",
+   "name": "מציאת הפונקציה מנקודות",
+   "short": "פונקציה מנקודות",
+   "prereqs": [
+    "q_vertex",
+    "q_fform"
+   ],
+   "description": "בונים את הביטוי האלגברי מקודקוד ונקודה, או מנקודות האפס ונקודה. המכינה ל־5 יח״ל דורשת זאת, הפריסה לא.",
+   "core": true,
+   "sample": {
+    "question": "לפרבולה קודקוד $(2, −1)$, והיא עוברת דרך $(0, 3)$. מהי הפונקציה?",
+    "choices": [
+     {
+      "text": "$y = (x − 2)² − 1$",
+      "correct": true
+     },
+     {
+      "text": "$y = (x + 2)² − 1$",
+      "mistake": "hshift_sign"
+     },
+     {
+      "text": "$y = 3(x − 2)² − 1$",
+      "mistake": "a_from_point"
+     },
+     {
+      "text": "$y = (x − 2)² + 3$",
+      "mistake": "a_from_point"
+     }
+    ]
+   }
+  },
+  {
+   "id": "q_eq_simple",
+   "unit": "q",
+   "name": "משוואה $ax² = b$",
+   "short": "ax² = b",
+   "prereqs": [
+    "f_sqrt",
+    "f_lin"
+   ],
+   "description": "פתרון בבידוד $x²$ והוצאת שורש, בלי נוסחה.",
+   "month": "אוקטובר",
+   "sample": {
+    "question": "$3x² = 48$.  $x = ?$",
+    "choices": [
+     {
+      "text": "$x = 4$ או $x = −4$",
+      "correct": true
+     },
+     {
+      "text": "$x = 4$",
+      "mistake": "missing_neg_root"
+     },
+     {
+      "text": "$x = ±√45$",
+      "mistake": "sub_vs_div"
+     },
+     {
+      "text": "$x = 8$",
+      "mistake": "sqrt_half"
+     }
+    ]
+   }
+  },
+  {
+   "id": "q_eq_gcf",
+   "unit": "q",
+   "name": "משוואה $ax² + bx = 0$",
+   "short": "ax² + bx = 0",
+   "prereqs": [
+    "q_zero_prod",
+    "t_gcf"
+   ],
+   "description": "פתרון בהוצאת גורם משותף, בלי לחלק ב־x.",
+   "month": "אוקטובר",
+   "sample": {
+    "question": "$5x² = 20x$.  $x = ?$",
+    "choices": [
+     {
+      "text": "$x = 0$ או $x = 4$",
+      "correct": true
+     },
+     {
+      "text": "$x = 4$",
+      "mistake": "divide_by_x"
+     },
+     {
+      "text": "$x = 0$ או $x = −4$",
+      "mistake": "lost_sign_move"
+     }
+    ]
+   }
+  },
+  {
+   "id": "q_eq_factor",
+   "unit": "q",
+   "name": "פתרון משוואה בפירוק לגורמים",
+   "short": "משוואה בפירוק",
+   "prereqs": [
+    "q_zero_prod",
+    "t_trinomial"
+   ],
+   "description": "העברה לצורה $x² + bx + c = 0$, פירוק, ושימוש בכלל מכפלה שווה 0.",
+   "month": "אוקטובר",
+   "core": true,
+   "sample": {
+    "question": "$x² + 2x = 15$.  $x = ?$",
+    "choices": [
+     {
+      "text": "$x = −5$ ,  $x = 3$",
+      "correct": true
+     },
+     {
+      "text": "$x = 5$ ,  $x = −3$",
+      "mistake": "signs_swapped"
+     },
+     {
+      "text": "$x = 15$ ,  $x = 13$",
+      "mistake": "product_not_zero"
+     }
+    ]
+   }
+  },
+  {
+   "id": "q_formula",
+   "unit": "q",
+   "name": "נוסחת השורשים",
+   "short": "נוסחת השורשים",
+   "prereqs": [
+    "q_eq_simple",
+    "q_eq_factor",
+    "t_square"
+   ],
+   "description": "$ax² + bx + c = 0$ עם כל $a ≠ 0$. בוחרים את הדרך היעילה לפי צורת המשוואה.",
+   "month": "נובמבר",
+   "core": true,
+   "sample": {
+    "question": "$2x² − 3x − 2 = 0$.  $x = ?$",
+    "choices": [
+     {
+      "text": "$x = 2$ ,  $x = −½$",
+      "correct": true
+     },
+     {
+      "text": "$x = −2$ ,  $x = ½$",
+      "mistake": "minus_b"
+     },
+     {
+      "text": "$x = 4$ ,  $x = −1$",
+      "mistake": "forgot_2a"
+     },
+     {
+      "text": "אין פתרון",
+      "mistake": "disc_sign"
+     }
+    ]
+   }
+  },
+  {
+   "id": "q_disc",
+   "unit": "q",
+   "name": "מספר הפתרונות של משוואה ריבועית",
+   "short": "מספר פתרונות",
+   "prereqs": [
+    "q_formula"
+   ],
+   "description": "הביטוי שבתוך השורש, $b² − 4ac$, קובע אם יש שני פתרונות, אחד או אף אחד.",
+   "month": "נובמבר",
+   "sample": {
+    "question": "כמה פתרונות יש למשוואה $x² − 6x + 9 = 0$?",
+    "choices": [
+     {
+      "text": "פתרון אחד",
+      "correct": true
+     },
+     {
+      "text": "שני פתרונות",
+      "mistake": "disc_meaning"
+     },
+     {
+      "text": "אין פתרון",
+      "mistake": "disc_meaning"
+     }
+    ]
+   }
+  },
+  {
+   "id": "q_sketch",
+   "unit": "q",
+   "name": "סרטוט פרבולה מהצגה סטנדרטית",
+   "short": "סרטוט פרבולה",
+   "prereqs": [
+    "q_sform",
+    "q_formula"
+   ],
+   "description": "כיוון, קודקוד, נקודות אפס וחיתוך עם ציר y, ומהם הסקיצה.",
+   "month": "נובמבר",
+   "sample": {
+    "question": "מה נכון לגבי $y = x² − 2x − 3$?",
+    "choices": [
+     {
+      "text": "פתוחה למעלה, קודקוד $(1, −4)$, אפסים $−1$ ו־$3$",
+      "correct": true
+     },
+     {
+      "text": "פתוחה למטה, קודקוד $(1, −4)$, אפסים $−1$ ו־$3$",
+      "mistake": "opening_sign"
+     },
+     {
+      "text": "פתוחה למעלה, קודקוד $(1, −4)$, אפסים $1$ ו־$−3$",
+      "mistake": "zero_sign"
+     },
+     {
+      "text": "פתוחה למעלה, קודקוד $(0, −3)$, אפסים $−1$ ו־$3$",
+      "mistake": "c_as_vertex"
+     }
+    ]
+   }
+  },
+  {
+   "id": "q_ineq",
+   "unit": "q",
+   "name": "אי־שוויון ריבועי",
+   "short": "אי־שוויון ריבועי",
+   "prereqs": [
+    "q_fform"
+   ],
+   "description": "פתרון בעזרת הפונקציה: נקודות האפס, כיוון הפתיחה, ותחומי החיוביות והשליליות.",
+   "month": "דצמבר",
+   "sample": {
+    "question": "$(x − 1)(x − 5) < 0$.  $x = ?$",
+    "choices": [
+     {
+      "text": "$1 < x < 5$",
+      "correct": true
+     },
+     {
+      "text": "$x < 1$ או $x > 5$",
+      "mistake": "sign_regions"
+     },
+     {
+      "text": "$x < 0$",
+      "mistake": "neg_x"
+     },
+     {
+      "text": "$−5 < x < −1$",
+      "mistake": "zero_sign"
+     }
+    ]
+   }
+  },
+  {
+   "id": "q_sys",
+   "unit": "q",
+   "name": "מערכת: ישר ופרבולה",
+   "short": "ישר ופרבולה",
+   "prereqs": [
+    "f_sys",
+    "q_formula"
+   ],
+   "description": "פתרון מערכת ממעלה שנייה, והקשר לנקודות החיתוך של הגרפים.",
+   "month": "פברואר",
+   "sample": {
+    "question": "מהן נקודות החיתוך של $y = x²$ ו־$y = x + 2$?",
+    "choices": [
+     {
+      "text": "$(2, 4)$ ,  $(−1, 1)$",
+      "correct": true
+     },
+     {
+      "text": "$(2, 0)$ ,  $(−1, 0)$",
+      "mistake": "forgot_y"
+     },
+     {
+      "text": "$(−2, 4)$ ,  $(1, 1)$",
+      "mistake": "signs_swapped"
+     }
+    ]
+   }
+  },
+  {
+   "id": "q_sys2",
+   "unit": "q",
+   "name": "מערכת: שתי פרבולות",
+   "short": "שתי פרבולות",
+   "prereqs": [
+    "q_sys"
+   ],
+   "description": "השוואת שני ביטויים ריבועיים. $x²$ לא תמיד מצטמצם.",
+   "month": "פברואר",
+   "sample": {
+    "question": "מהן נקודות החיתוך של $y = x² − 3$ ו־$y = −x² + 5$?",
+    "choices": [
+     {
+      "text": "$(2, 1)$ ,  $(−2, 1)$",
+      "correct": true
+     },
+     {
+      "text": "$(2, 1)$ בלבד",
+      "mistake": "missing_neg_root"
+     },
+     {
+      "text": "$(2, 0)$ ,  $(−2, 0)$",
+      "mistake": "forgot_y"
+     }
+    ]
+   }
+  },
+  {
+   "id": "q_tri",
+   "unit": "q",
+   "name": "פרבולה ומשולשים",
+   "short": "פרבולה ומשולשים",
+   "prereqs": [
+    "q_sform"
+   ],
+   "description": "שטח משולש שקודקודיו על הפרבולה ועל הצירים. דורש גם גיאומטריה אנליטית מפס הגיאומטריה.",
+   "core": true,
+   "geometry": true,
+   "sample": {
+    "question": "$y = x² − 4x$ חותכת את ציר x ב־O וב־A, וקודקודה B. מהו שטח המשולש OAB?",
+    "choices": [
+     {
+      "text": "$8$",
+      "correct": true
+     },
+     {
+      "text": "$16$",
+      "mistake": "forgot_half"
+     },
+     {
+      "text": "$−8$",
+      "mistake": "neg_height"
+     }
+    ]
+   }
+  },
+  {
+   "id": "p_laws1",
+   "unit": "p",
+   "name": "כפל וחילוק חזקות עם אותו בסיס",
+   "short": "כפל וחילוק חזקות",
+   "prereqs": [
+    "f_power"
+   ],
+   "description": "$aⁿ·aᵐ = aⁿ⁺ᵐ$, $aⁿ : aᵐ = aⁿ⁻ᵐ$ ו־$a⁰ = 1$. לפי הפריסה רק מעריך טבעי או אפס.",
+   "month": "מאי",
+   "sample": {
+    "question": "$a⁵ · a³ : a² = ?$",
+    "choices": [
+     {
+      "text": "$a⁶$",
+      "correct": true
+     },
+     {
+      "text": "$a¹³$",
+      "mistake": "mult_exponents"
+     },
+     {
+      "text": "$a⁴$",
+      "mistake": "div_exponents"
+     }
+    ]
+   }
+  },
+  {
+   "id": "p_laws2",
+   "unit": "p",
+   "name": "חזקה של מכפלה, של מנה ושל חזקה",
+   "short": "חזקה של חזקה",
+   "prereqs": [
+    "p_laws1"
+   ],
+   "description": "$(ab)ⁿ = aⁿbⁿ$, $(a:b)ⁿ = aⁿ:bⁿ$, $(aⁿ)ᵐ = aⁿᵐ$.",
+   "month": "מאי",
+   "sample": {
+    "question": "$(2x³)² = ?$",
+    "choices": [
+     {
+      "text": "$4x⁶$",
+      "correct": true
+     },
+     {
+      "text": "$2x⁶$",
+      "mistake": "coef_not_raised"
+     },
+     {
+      "text": "$4x⁵$",
+      "mistake": "pow_pow_add"
+     },
+     {
+      "text": "$2x⁵$",
+      "mistake": "coef_not_raised"
+     }
+    ]
+   }
+  },
+  {
+   "id": "p_compare",
+   "unit": "p",
+   "name": "השוואת חזקות",
+   "short": "השוואת חזקות",
+   "prereqs": [
+    "p_laws2"
+   ],
+   "description": "השוואה בין חזקות בעזרת חוקי החזקה, בלי מחשבון.",
+   "month": "מאי",
+   "sample": {
+    "question": "מה גדול יותר: $2³⁰⁰$ או $3²⁰⁰$?",
+    "choices": [
+     {
+      "text": "$3²⁰⁰$",
+      "correct": true
+     },
+     {
+      "text": "$2³⁰⁰$",
+      "mistake": "bigger_exp"
+     },
+     {
+      "text": "הם שווים",
+      "mistake": "bigger_exp"
+     }
+    ]
+   }
+  },
+  {
+   "id": "p_sqrt_laws",
+   "unit": "p",
+   "name": "חוקי שורש ריבועי",
+   "short": "חוקי שורש",
+   "prereqs": [
+    "f_sqrt",
+    "p_laws2"
+   ],
+   "description": "$√a·√b = √(ab)$ ו־$√a : √b = √(a:b)$, ופישוט שורשים.",
+   "month": "מאי",
+   "sample": {
+    "question": "$√12 · √3 = ?$",
+    "choices": [
+     {
+      "text": "$6$",
+      "correct": true
+     },
+     {
+      "text": "$√15$",
+      "mistake": "sqrt_add"
+     },
+     {
+      "text": "$36$",
+      "mistake": "sqrt_forgot"
+     }
+    ]
+   }
+  },
+  {
+   "id": "w_area",
+   "unit": "w",
+   "name": "שאלות הנדסיות",
+   "short": "שאלות הנדסיות",
+   "prereqs": [
+    "q_formula"
+   ],
+   "description": "בניית משוואה ריבועית משטח או מאורך, ובדיקה שהפתרון מתאים לבעיה.",
+   "month": "מאי",
+   "sample": {
+    "question": "שטח מלבן הוא 48 סמ״ר, ואורכו גדול מרוחבו ב־2 ס״מ. מה רוחבו?",
+    "choices": [
+     {
+      "text": "6 ס״מ",
+      "correct": true
+     },
+     {
+      "text": "6 ס״מ או −8 ס״מ",
+      "mistake": "inadmissible"
+     },
+     {
+      "text": "8 ס״מ",
+      "mistake": "other_quantity"
+     },
+     {
+      "text": "23 ס״מ",
+      "mistake": "area_perimeter"
+     }
+    ]
+   }
+  },
+  {
+   "id": "w_motion",
+   "unit": "w",
+   "name": "שאלות תנועה",
+   "short": "שאלות תנועה",
+   "prereqs": [
+    "q_formula",
+    "t_fraceq"
+   ],
+   "description": "דרך, מהירות וזמן, כשהמשתנה במכנה מוביל למשוואה ריבועית.",
+   "month": "מאי",
+   "sample": {
+    "question": "רוכב נוסע 120 ק״מ. אילו נסע מהר יותר ב־10 קמ״ש, היה מגיע שעה אחת מוקדם יותר. מה מהירותו?",
+    "choices": [
+     {
+      "text": "30 קמ״ש",
+      "correct": true
+     },
+     {
+      "text": "30 או −40 קמ״ש",
+      "mistake": "inadmissible"
+     },
+     {
+      "text": "40 קמ״ש",
+      "mistake": "other_quantity"
+     }
+    ]
+   }
+  },
+  {
+   "id": "w_percent",
+   "unit": "w",
+   "name": "שאלות עם אחוזים",
+   "short": "שאלות אחוזים",
+   "prereqs": [
+    "q_eq_simple"
+   ],
+   "description": "שינוי חוזר באחוזים מוביל לביטוי בריבוע.",
+   "month": "מאי",
+   "sample": {
+    "question": "מחיר עלה ב־p אחוזים, ואחר כך שוב ב־p אחוזים, מ־200 ₪ ל־242 ₪. מהו p?",
+    "choices": [
+     {
+      "text": "$10$",
+      "correct": true
+     },
+     {
+      "text": "$10.5$",
+      "mistake": "percent_add"
+     },
+     {
+      "text": "$21$",
+      "mistake": "other_quantity"
+     }
+    ]
+   }
+  },
+  {
+   "id": "w_extremum",
+   "unit": "w",
+   "name": "בעיות קיצון",
+   "short": "בעיות קיצון",
+   "prereqs": [
+    "w_area",
+    "q_vertex"
+   ],
+   "description": "מקסימום ומינימום בבעיה, בעזרת קודקוד הפרבולה.",
+   "month": "מאי",
+   "sample": {
+    "question": "סכום שני מספרים הוא 10. מהי המכפלה הגדולה ביותר שלהם?",
+    "choices": [
+     {
+      "text": "$25$",
+      "correct": true
+     },
+     {
+      "text": "$5$",
+      "mistake": "other_quantity"
+     },
+     {
+      "text": "$100$",
+      "mistake": "square_total"
+     },
+     {
+      "text": "$24$",
+      "mistake": "guess_cases"
+     }
+    ]
+   }
+  }
+ ],
+ "mistakes": {
+  "minus_minus": {
+   "name": "חיסור של מספר שלילי",
+   "tip": "חיסור של מספר שלילי הוא חיבור: $−3 − (−10) = −3 + 10$.",
+   "back": "f_neg"
+  },
+  "order_ops": {
+   "name": "סדר פעולות",
+   "tip": "כפל לפני חיסור: קודם $(−5)·2 = −10$, ואחר כך החיסור.",
+   "back": null
+  },
+  "result_sign": {
+   "name": "סימן התוצאה",
+   "tip": "$−3 + 10 = 7$: המספר החיובי גדול יותר בערכו המוחלט.",
+   "back": null
+  },
+  "add_denoms": {
+   "name": "חיבור מונים ומכנים",
+   "tip": "מחברים שברים רק אחרי מכנה משותף: $2/3 = 8/12$, $1/4 = 3/12$.",
+   "back": "f_frac"
+  },
+  "scale_numerators": {
+   "name": "מכנה משותף בלי להרחיב את המונים",
+   "tip": "כשמרחיבים למכנה 12 מכפילים גם את המונה: $2/3 = 8/12$.",
+   "back": "f_frac"
+  },
+  "mult_not_add": {
+   "name": "כפל במקום חיבור",
+   "tip": "$2/3 · 1/4 = 1/6$, אבל כאן התבקש חיבור.",
+   "back": "f_frac"
+  },
+  "neg_square": {
+   "name": "ריבוע של מספר שלילי",
+   "tip": "מספר שלילי בריבוע הוא חיובי: $(−2)² = 4$ ו־$(−3x)² = 9x²$.",
+   "back": "f_neg"
+  },
+  "coef_in_power": {
+   "name": "החזקה הוחלה על המקדם",
+   "tip": "ב־$3x²$ רק x בריבוע: $3·(−2)² = 12$.",
+   "back": "f_ops"
+  },
+  "join_unlike": {
+   "name": "חיבור איברים שאינם דומים",
+   "tip": "מכנסים רק איברים עם אותה אות: a עם a, ו־b עם b.",
+   "back": "f_like"
+  },
+  "sign_of_term": {
+   "name": "הסימן שלפ��י האיבר",
+   "tip": "הסימן שלפני איבר שייך לו: $−3a$ ו־$−2b$ הם איברים שליליים.",
+   "back": "f_like"
+  },
+  "coef_not_raised": {
+   "name": "המקדם לא הועלה בחזקה",
+   "tip": "גם המקדם עולה בחזקה: $(2x³)² = 2²·(x³)² = 4x⁶$.",
+   "back": "f_power"
+  },
+  "power_as_mult": {
+   "name": "חזקה ככפל במעריך",
+   "tip": "חזקה היא כפל חוזר: $x² = x·x$, ולא $2·x$.",
+   "back": "f_power"
+  },
+  "sign_product": {
+   "name": "סימן של מכפלה",
+   "tip": "שלילי כפול שלילי הוא חיובי, וחיובי כפול שלילי הוא שלילי.",
+   "back": "f_neg"
+  },
+  "partial_dist": {
+   "name": "פילוג רק לאיבר הראשון",
+   "tip": "המספר שלפני הסוגריים כופל כל איבר בתוכם.",
+   "back": "f_dist"
+  },
+  "move_sign": {
+   "name": "העברת אגף בלי החלפת סימן",
+   "tip": "איבר שעובר לאגף השני מחליף את סימנו.",
+   "back": "f_lin"
+  },
+  "slope_inverted": {
+   "name": "שיפוע הפוך",
+   "tip": "שיפוע הוא השינוי ב־y חלקי השינוי ב־x: $(8 − 2)/(3 − 1) = 3$.",
+   "back": "f_linfun"
+  },
+  "slope_dy_only": {
+   "name": "שיפוע בלי חלוקה",
+   "tip": "מחלקים את השינוי ב־y בשינוי ב־x.",
+   "back": "f_linfun"
+  },
+  "swapped_pair": {
+   "name": "סדר בזוג הסדור",
+   "tip": "בזוג סדור x ראשון ו־y שני.",
+   "back": "f_sys"
+  },
+  "forgot_divide": {
+   "name": "שכחת לחלק",
+   "tip": "חיבור המשוואות נותן $2x = 14$, ועוד צריך לחלק ב־2.",
+   "back": "f_lin"
+  },
+  "sqrt_split": {
+   "name": "שורש של סכום",
+   "tip": "$√(a + b) ≠ √a + √b$. קודם מחברים: $√25 = 5$.",
+   "back": "f_sqrt"
+  },
+  "sqrt_half": {
+   "name": "שורש כחצי",
+   "tip": "שורש ריבועי אינו חצי: $√16 = 4$ כי $4² = 16$.",
+   "back": "f_sqrt"
+  },
+  "first_last_only": {
+   "name": "פילוג חלקי",
+   "tip": "בפילוג מורחב כל איבר בסוגריים הראשונים כופל כל איבר בשניים: ארבע מכפלות.",
+   "back": "t_ext"
+  },
+  "div_neg": {
+   "name": "חילוק במספר שלילי",
+   "tip": "$−x = 10$, ולכן $x = −10$: מחלקים את שני האגפים ב־$−1$.",
+   "back": "f_lin"
+  },
+  "forgot_middle": {
+   "name": "שכחת את האיבר האמצעי",
+   "tip": "$(a − b)² = a² − 2ab + b²$, ולא $a² − b²$.",
+   "back": "t_square"
+  },
+  "middle_no_2": {
+   "name": "האיבר האמצעי בלי 2",
+   "tip": "האיבר האמצעי הוא $2ab = 2·2x·3 = 12x$.",
+   "back": "t_square"
+  },
+  "diff_sign": {
+   "name": "סימן בהפרש ריבועים",
+   "tip": "$(a + b)(a − b) = a² − b²$, ולכן $50² − 1² = 2499$.",
+   "back": "t_diffsq"
+  },
+  "forgot_b2": {
+   "name": "שכחת את $b²$",
+   "tip": "$51·49 = (50 + 1)(50 − 1) = 50² − 1²$.",
+   "back": "t_diffsq"
+  },
+  "partial_gcf": {
+   "name": "לא הגורם המשותף הגדול ביותר",
+   "tip": "גם 3 וגם x משותפים לשני האיברים, ולכן מוציאים $3x$.",
+   "back": "t_gcf"
+  },
+  "divide_each": {
+   "name": "לא חילקת כל איבר",
+   "tip": "בתוך הסוגריים נשאר כל איבר חלקי הגורם: $9x : 3x = 3$.",
+   "back": "t_gcf"
+  },
+  "diff_vs_square": {
+   "name": "הפרש ריבועים מול ריבוע של הפרש",
+   "tip": "$a² − b² = (a − b)(a + b)$. ב־$(a − b)²$ יש גם איבר אמצעי.",
+   "back": "t_diffsq"
+  },
+  "root_of_coef": {
+   "name": "שורש של המקדם",
+   "tip": "$4x² = (2x)²$, ולכן $a = 2x$.",
+   "back": "f_sqrt"
+  },
+  "signs_swapped": {
+   "name": "סימנים הפוכים בפירוק",
+   "tip": "פתחו סוגריים לבדיקה: האיבר האמצעי צריך לצאת עם הסימן של המקור.",
+   "back": "t_trinomial"
+  },
+  "product_only": {
+   "name": "המכפלה נכונה, הסכום לא",
+   "tip": "מחפשים שני מספרים שמכפלתם $−12$ וסכומם $−1$: $−4$ ו־$3$.",
+   "back": "t_trinomial"
+  },
+  "zero_root_sign": {
+   "name": "סימן הערך האסור",
+   "tip": "$x + 4 = 0$ כאשר $x = −4$.",
+   "back": "f_lin"
+  },
+  "one_factor_only": {
+   "name": "בדקת רק גורם אחד",
+   "tip": "מכפלה היא 0 כשאחד הגורמים הוא 0, ולכן בודקים כל גורם במכנה.",
+   "back": "t_domain"
+  },
+  "numerator_domain": {
+   "name": "תחום הצבה לפי המונה",
+   "tip": "תחום ההצבה נקבע לפי המכנה בלבד: אסור לחלק ב־0. מונה 0 מותר.",
+   "back": "t_domain"
+  },
+  "cancel_terms": {
+   "name": "צמצום של מחוברים",
+   "tip": "מצמצמים רק גורמים בכפל. קודם מפרקים את המונה ואת המכנה.",
+   "back": "t_reduce"
+  },
+  "factor_sign": {
+   "name": "טעות בפירוק",
+   "tip": "$x² − 9 = (x − 3)(x + 3)$ ו־$x² − 1 = (x − 1)(x + 1)$. בדקו איזה גורם מצטמצם ואיזה נשאר.",
+   "back": "t_factor_formula"
+  },
+  "div_not_flipped": {
+   "name": "חילוק בלי הופכי",
+   "tip": "חילוק בשבר הוא כפל בהופכי שלו: $: 4x²/(x² − 1)$ הופך ל־$· (x² − 1)/(4x²)$.",
+   "back": "f_frac"
+  },
+  "cancel_power": {
+   "name": "צמצום חזקות",
+   "tip": "$2x / 4x² = 1/(2x)$: נשאר x אחד במכנה.",
+   "back": "t_reduce"
+  },
+  "excluded_root": {
+   "name": "פתרון שאינו קביל",
+   "tip": "$x = 3$ מאפס את המכנה, ולכן הוא לא פתרון. בודקים כל פתרון מול תחום ההצבה.",
+   "back": "t_domain"
+  },
+  "axes_mixed": {
+   "name": "חיתוך עם הציר הלא נכון",
+   "tip": "חיתוך עם ציר x: מציבים $y = 0$. חיתוך עם ציר y: מציבים $x = 0$.",
+   "back": "n_intercepts"
+  },
+  "pos_neg_swap": {
+   "name": "חיוביות ושליליות הפוכות",
+   "tip": "הפונקציה שלילית איפה שהגרף מתחת לציר x.",
+   "back": "n_sign"
+  },
+  "neg_x": {
+   "name": "'שלילית' בערכי x",
+   "tip": "פונקציה שלילית פירושו ערכי y שליליים, לא x שלילי.",
+   "back": "n_sign"
+  },
+  "partial_intervals": {
+   "name": "תחום אחד מתוך כמה",
+   "tip": "עוברים על כל הגרף משמאל לימין: יכולים להיות כמה תחומים כאלה.",
+   "back": "n_sign"
+  },
+  "dir_confusion": {
+   "name": "עלייה במקום ירידה",
+   "tip": "קוראים את הגרף משמאל לימין. יורדת: ככל ש־x גדל, y קטן.",
+   "back": "n_extremum"
+  },
+  "x_vs_y_interval": {
+   "name": "תחום בערכי y",
+   "tip": "תחומי עלייה וירידה נכתבים בערכי x.",
+   "back": "n_extremum"
+  },
+  "local_as_abs": {
+   "name": "מקסימום מקומי כמוחלט",
+   "tip": "ב־$(−1, 3)$ יש מקסימום מקומי. המוחלט הוא הערך הגבוה ביותר בכל התחום: 5.",
+   "back": "n_local_abs"
+  },
+  "value_vs_point": {
+   "name": "ערך הקיצון מול נקודת הקיצון",
+   "tip": "ערך המקסימום הוא שיעור ה־y בלבד: 5. הנקודה היא $(3, 5)$.",
+   "back": "n_local_abs"
+  },
+  "x_equals_m": {
+   "name": "$f(x) = 1$ כ־$x = 1$",
+   "tip": "$f(x) = 1$ שואלת איפה הגרף בגובה 1. מעבירים את הישר $y = 1$ וסופרים מפגשים.",
+   "back": "n_eq_graph"
+  },
+  "count_all": {
+   "name": "לא נספרו כל המפגשים",
+   "tip": "עוברים על כל הגרף: הישר $y = 1$ פוגש אותו שלוש פעמים.",
+   "back": "n_eq_graph"
+  },
+  "vshift_dir": {
+   "name": "כיוון ההזזה האנכית",
+   "tip": "$f(x) − 3$ מוריד את הגרף ב־3: $(2, 5)$ עובר ל־$(2, 2)$.",
+   "back": "n_vshift"
+  },
+  "vshift_as_h": {
+   "name": "הזזה אנכית כאופקית",
+   "tip": "מספר מחוץ ל־f מזיז למעלה או למטה. x לא משתנה.",
+   "back": "n_vshift"
+  },
+  "hshift_sign": {
+   "name": "כיוון ההזזה האופקית",
+   "tip": "$f(x − b)$ זז ימינה ב־b. ב־$(x + 3)²$ מתקיים $b = −3$, ולכן הקודקוד ב־$x = −3$.",
+   "back": "n_hshift"
+  },
+  "h_as_v": {
+   "name": "הזזה אופקית כאנכית",
+   "tip": "מספר בתוך הסוגריים מזיז ימינה או שמאלה. y של הקיצון לא משתנה.",
+   "back": "n_hshift"
+  },
+  "reflect_type": {
+   "name": "סוג הקיצון בשיקוף",
+   "tip": "שיקוף ביחס לציר x הופך מקסימום למינימום.",
+   "back": "n_reflect"
+  },
+  "reflect_axis": {
+   "name": "שיקוף ביחס לציר הלא נכון",
+   "tip": "שיקוף ביחס לציר x משנה את הסימן של y. ה־x נשאר.",
+   "back": "n_reflect"
+  },
+  "max_below": {
+   "name": "מקסימום שלילי",
+   "tip": "ערך המקסימום הוא $−1$, ולכן כל הגרף מתחת לציר x ואין נקודות חיתוך איתו.",
+   "back": "n_props_graph"
+  },
+  "opening_sign": {
+   "name": "סוג הקיצון לפי a",
+   "tip": "כש־$a < 0$ יש מקסימום, וכש־$a > 0$ יש מינימום.",
+   "back": "q_parabola"
+  },
+  "a_as_vertex": {
+   "name": "a כשיעור הקודקוד",
+   "tip": "a קובע רק את סוג הקיצון. הקודקוד של $ax²$ תמיד ב־$(0, 0)$.",
+   "back": "q_parabola"
+  },
+  "missing_neg_root": {
+   "name": "פתרון שלילי חסר",
+   "tip": "גם המספר השלילי מקיים: $(−2)² = 4$. ל־$x² = 4$ יש שני פתרונות.",
+   "back": "f_sqrt"
+  },
+  "forgot_root": {
+   "name": "שכחת להוציא שורש",
+   "tip": "$x² = 4$, ולכן $x = ±√4 = ±2$.",
+   "back": "f_sqrt"
+  },
+  "plug_zero": {
+   "name": "הצבת $x = 0$",
+   "tip": "הצבת $x = 0$ נותנת את החיתוך עם ציר y, לא את הקודקוד.",
+   "back": "n_intercepts"
+  },
+  "k_sign": {
+   "name": "סימן ההזזה האנכית",
+   "tip": "ב־$a(x − b)² + k$ הקודקוד הוא $(b, k)$, וכאן $k = 8$.",
+   "back": "q_vshift"
+  },
+  "zero_sign": {
+   "name": "סימן נקודות האפס",
+   "tip": "$x − 1 = 0$ כאשר $x = 1$: נקודת האפס היא המספר בסוגריים עם סימן הפוך.",
+   "back": "q_zero_prod"
+  },
+  "divide_wrong": {
+   "name": "חילוק הפוך",
+   "tip": "$2x = −1$, ולכן $x = −1/2$.",
+   "back": "f_lin"
+  },
+  "axis_middle": {
+   "name": "מיקום ציר הסימטריה",
+   "tip": "ציר הסימטריה באמצע בין נקודות האפס: $(1 + 5)/2 = 3$.",
+   "back": "q_fform"
+  },
+  "a_as_zero": {
+   "name": "המקדם כנקודת אפס",
+   "tip": "המקדם a אינו נקודת אפס. רק הגורמים עם x מתאפסים.",
+   "back": "q_fform"
+  },
+  "axis_sign": {
+   "name": "סימן ציר הסימטריה",
+   "tip": "$x = −b/(2a)$. כאן $b = −6$, ולכן $x = 6/2 = 3$.",
+   "back": "q_sform"
+  },
+  "forgot_2a_axis": {
+   "name": "המכנה $2a$ בציר הסימטריה",
+   "tip": "מחלקים ב־$2a$: $x = 6/2 = 3$, לא 6.",
+   "back": "q_sform"
+  },
+  "c_as_vertex": {
+   "name": "c כקודקוד",
+   "tip": "c נותן את החיתוך עם ציר y. הקודקוד הוא על ציר הסימטריה $x = −b/(2a)$.",
+   "back": "q_sform"
+  },
+  "a_from_point": {
+   "name": "הנקודה במקום המקדם",
+   "tip": "מציבים את הנקודה ופותרים את a: $a(0 − 2)² − 1 = 3$, ולכן $a = 1$.",
+   "back": "q_from_points"
+  },
+  "sub_vs_div": {
+   "name": "חיסור במקום חילוק",
+   "tip": "מבודדים את $x²$ בחילוק ב־3: $x² = 16$.",
+   "back": "f_lin"
+  },
+  "divide_by_x": {
+   "name": "חילוק ב־x",
+   "tip": "חילוק ב־x מאבד את הפתרון $x = 0$. מעבירים לאגף אחד ומוציאים גורם משותף: $5x(x − 4) = 0$.",
+   "back": "q_eq_gcf"
+  },
+  "lost_sign_move": {
+   "name": "סימן בהעברת אגף",
+   "tip": "$5x² − 20x = 0$, ולכן $5x(x − 4) = 0$ ו־$x = 4$.",
+   "back": "f_lin"
+  },
+  "product_not_zero": {
+   "name": "מכפלה ששווה למספר שאינו 0",
+   "tip": "הכלל 'מכפלה שווה 0' עובד רק כשבאגף השני 0. קודם מעבירים: $x² + 2x − 15 = 0$.",
+   "back": "q_zero_prod"
+  },
+  "minus_b": {
+   "name": "הסימן של $−b$",
+   "tip": "בנוסחה מופיע $−b$. כאן $b = −3$, ולכן $−b = 3$.",
+   "back": "q_formula"
+  },
+  "forgot_2a": {
+   "name": "המכנה $2a$",
+   "tip": "בנוסחת השורשים מחלקים ב־$2a = 4$, לא ב־2.",
+   "back": "q_formula"
+  },
+  "disc_sign": {
+   "name": "החישוב בתוך השורש",
+   "tip": "$b² − 4ac$: כאן $c = −2$, ולכן $−4ac = +16$ והתוצאה $9 + 16 = 25$.",
+   "back": "q_formula"
+  },
+  "disc_meaning": {
+   "name": "משמעות הביטוי בתוך השורש",
+   "tip": "חיובי: שני פתרונות. אפס: פתרון אחד. שלילי: אין פתרון. כאן $36 − 36 = 0$.",
+   "back": "q_disc"
+  },
+  "sign_regions": {
+   "name": "שלילית בין האפסים",
+   "tip": "פרבולה עם מינימום שלילית בין נקודות האפס וחיובית מחוץ להן.",
+   "back": "q_ineq"
+  },
+  "forgot_y": {
+   "name": "שכחת את y",
+   "tip": "אחרי שמוצאים x מציבים באחת המשוואות כדי למצוא y.",
+   "back": "f_sys"
+  },
+  "forgot_half": {
+   "name": "שכחת לחלק ב־2",
+   "tip": "שטח משולש הוא בסיס כפול גובה חלקי 2: $4·4/2 = 8$.",
+   "back": "q_tri"
+  },
+  "neg_height": {
+   "name": "גובה שלילי",
+   "tip": "הגובה הוא מרחק, ולכן חיובי: הקודקוד $(2, −4)$ נמצא 4 יחידות מתחת לציר x.",
+   "back": "q_tri"
+  },
+  "mult_exponents": {
+   "name": "כפל מעריכים",
+   "tip": "בכפל חזקות עם אותו בסיס מחברים את המעריכים: $a⁵·a³ = a⁸$.",
+   "back": "p_laws1"
+  },
+  "div_exponents": {
+   "name": "חילוק מעריכים",
+   "tip": "בחילוק חזקות עם אותו בסיס מחסרים את המעריכים: $a⁸ : a² = a⁶$.",
+   "back": "p_laws1"
+  },
+  "pow_pow_add": {
+   "name": "חיבור מעריכים בחזקה של חזקה",
+   "tip": "בחזקה של חזקה כופלים מעריכים: $(x³)² = x⁶$.",
+   "back": "p_laws2"
+  },
+  "bigger_exp": {
+   "name": "מעריך גדול יותר, מספר גדול יותר",
+   "tip": "כתבו את שניהם עם אותו מעריך: $2³⁰⁰ = 8¹⁰⁰$ ו־$3²⁰⁰ = 9¹⁰⁰$.",
+   "back": "p_laws2"
+  },
+  "sqrt_add": {
+   "name": "שורש של מכפלה כשורש של סכום",
+   "tip": "$√a·√b = √(ab)$: $√12·√3 = √36$.",
+   "back": "p_sqrt_laws"
+  },
+  "sqrt_forgot": {
+   "name": "שכחת להוציא שורש",
+   "tip": "$√36 = 6$, לא 36.",
+   "back": "f_sqrt"
+  },
+  "inadmissible": {
+   "name": "פתרון שלא מתאים לבעיה",
+   "tip": "אורך ומהירות אינם שליליים. פוסלים פתרון שאינו מתאים לבעיה.",
+   "back": null
+  },
+  "other_quantity": {
+   "name": "ענית על גודל אחר",
+   "tip": "קראו שוב מה נשאל. פתרתם נכון, אבל המספר שבחרתם מתאר גודל אחר בבעיה.",
+   "back": null
+  },
+  "area_perimeter": {
+   "name": "שטח מול היקף",
+   "tip": "שטח הוא אורך כפול רוחב: $w(w + 2) = 48$.",
+   "back": "w_area"
+  },
+  "percent_add": {
+   "name": "חיבור אחוזים",
+   "tip": "שתי עליות של p% הן כפל: $200·(1 + p/100)² = 242$, ולכן $1 + p/100 = 1.1$.",
+   "back": "w_percent"
+  },
+  "square_total": {
+   "name": "ריבוע הסכום",
+   "tip": "$10² = 100$ הוא ריבוע הסכום, לא מכפלת המספרים.",
+   "back": null
+  },
+  "guess_cases": {
+   "name": "ניחוש ערכים",
+   "tip": "ניסוי של כמה ערכים לא מוכיח מקסימום. מוצאים את הקודקוד של $y = x(10 − x)$.",
+   "back": "q_vertex"
+  }
+ }
+}

app/math_photo.py

@@ -0,0 +1,115 @@
+"""A photographed math problem, solved for the math path: hints first, the full solution on request.
+
+The student photographs a problem; Claude reads it, solves it, and answers in a fixed JSON shape (PHOTO_SCHEMA):
+the problem as it read it (so the student can check the reading), the solution as steps, each a hint that does
+not give the step away and the step itself, the final answer, and the path's skill the problem practises. The page
+shows the hints one by one, and the steps and the answer only when the student asks for them.
+
+Runs on the server's Anthropic key (the tutor's, ANTHROPIC_API_KEY or the panel's), on MATH_MODEL (default
+DEFAULT_MODEL). The photo is sent to the API and not kept.
+"""
+from __future__ import annotations
+
+import base64
+import json
+import logging
+import os
+
+log = logging.getLogger("ihki.math_photo")
+
+DEFAULT_MODEL = "claude-opus-5-5"
+DAILY_PHOTOS = 20   # photos per signed-in account per day; developers are exempt in main.py
+MAX_PHOTO = 5_000_000   # bytes; the page sends a resized JPEG of a few hundred KB
+MEDIA_TYPES = ("image/jpeg", "image/png", "image/webp")
+
+
+class PhotoUnavailable(Exception):
+    """The photo could not be solved; the message is for the student (Hebrew)."""
+
+
+def photo_schema(skill_ids: list[str]) -> dict:
+    return {"type": "object", "additionalProperties": False,
+            "required": ["readable", "problem", "steps", "answer", "skill", "note"],
+            "properties": {
+                "readable": {"type": "boolean"},
+                "problem": {"type": "string"},
+                "steps": {"type": "array", "items": {"type": "object", "additionalProperties": False,
+                                                     "required": ["hint", "work"],
+                                                     "properties": {"hint": {"type": "string"}, "work": {"type": "string"}}}},
+                "answer": {"type": "string"},
+                "skill": {"type": "string", "enum": [*skill_ids, ""]},
+                "note": {"type": "string"}}}
+
+
+def system_prompt(skills: list[dict]) -> str:
+    listed = "\n".join(f"- {s['id']}: {s['name'].replace('$', '')}" for s in skills)
+    return f"""אתה מורה פרטי למתמטיקה לתלמידי כיתה ט׳ בהקבצה של 5 יחידות, בישראל. תלמיד צילם תרגיל ושלח לך את התמונה.
+
+1. קרא את התרגיל מהתמונה בדיוק כפי שהוא כתוב, ורשום אותו ב־problem. אם בתמונה כמה תרגילים, פתור את הראשון וכתוב זאת ב־note.
+2. פתור את התרגיל נכון, ובדוק את הפתרון (למשל בהצבה) לפני שאתה עונה.
+3. חלק את הפתרון לצעדים קצרים, בסדר שבו תלמיד היה כותב אותם, 2 עד 6 צעדים. לכל צעד:
+   - hint: רמז או שאלה מכוונת שעוזרים לתלמיד לעשות את הצעד בעצמו, בלי לגלות את התוצאה שלו.
+   - work: הצעד עצמו, עם התוצאה.
+4. answer: התשובה הסופית בלבד, קצרה. אם יש פתרון שאינו קביל (למשל מאפס מכנה, או אורך שלילי), כתוב רק את הקבילים.
+5. skill: המזהה של המיומנות מהרשימה שהתרגיל מתרגל יותר מכל אחת אחרת, או מחרוזת ריקה אם אף אחת לא מתאימה.
+6. אם התמונה לא קריאה, או שאין בה תרגיל מתמטי, readable יהיה false, ו־note יסביר בקצרה לתלמיד מה לצלם מחדש. השאר את שאר השדות ריקים.
+
+כתוב בעברית פשוטה, כמו מורה שמדבר עם תלמיד, ופנה בלשון רבים כמו שאר האפליקציה (למשל "העבירו", "חפשו", "הציבו"). כל ביטוי מתמטי עטוף בסימני דולר, למשל $x² − 4 = 0$, וגם כל מספר בודד בתוך משפט, בעיקר מספר שלילי: "שמכפלתם $−15$". בתוך הדולרים כתוב בתווי יוניקוד: ² ³ √ · − ≤ ≥ ≠ ±, שברים כ־a/b, ובלי פקודות LaTeX.
+
+המיומנויות במסלול:
+{listed}"""
+
+
+class PhotoSolver:
+    def __init__(self, client, model: str = DEFAULT_MODEL, skills: list[dict] | None = None):
+        self.client, self.model, self.skills = client, model, skills or []
+
+    def solve(self, image: bytes, media_type: str) -> dict:
+        import anthropic
+        if media_type not in MEDIA_TYPES:
+            raise PhotoUnavailable("אפשר לשלוח תמונה מסוג JPEG,‏ PNG או WebP.")
+        data = base64.standard_b64encode(image).decode("ascii")
+        try:
+            res = self.client.beta.messages.create(
+                model=self.model, max_tokens=16000, betas=["server-side-fallback-2026-07-01"], fallbacks="default",
+                system=system_prompt(self.skills), cache_control={"type": "ephemeral"},
+                output_config={"effort": "medium",
+                               "format": {"type": "json_schema", "schema": photo_schema([s["id"] for s in self.skills])}},
+                messages=[{"role": "user", "content": [
+                    {"type": "image", "source": {"type": "base64", "media_type": media_type, "data": data}},
+                    {"type": "text", "text": "זה התרגיל שצילמתי."}]}],
+            )
+        except anthropic.RateLimitError as e:
+            log.warning("math photo rate limited: %s", e)
+            raise PhotoUnavailable("עמוס כרגע. נסו שוב בעוד דקה.") from e
+        except anthropic.AuthenticationError as e:
+            log.error("math photo: the API key was refused: %s", e)
+            raise PhotoUnavailable("פתרון מתמונה לא זמין כרגע (מפתח ה-API לא תקין).") from e
+        except anthropic.APIStatusError as e:
+            log.warning("math photo: the API answered %s: %s", e.status_code, e.message)
+            raise PhotoUnavailable("פתרון מתמונה לא זמין כרגע. נסו שוב.") from e
+        except anthropic.APIConnectionError as e:
+            log.warning("math photo: no connection: %s", e)
+            raise PhotoUnavailable("אין חיבור כרגע. נסו שוב.") from e
+        if res.stop_reason == "refusal":
+            log.warning("math photo: the model declined (%s)", res.stop_details)
+            raise PhotoUnavailable("לא הצלחנו לפתור את התמונה הזו. נסו לצלם תרגיל אחר.")
+        if res.stop_reason == "max_tokens":
+            raise PhotoUnavailable("הפתרון נקטע. נסו שוב.")
+        text = next((b.text for b in res.content if b.type == "text"), "")
+        try:
+            out = json.loads(text)
+        except ValueError as e:
+            log.warning("math photo: an answer that is not JSON: %r", text[:300])
+            raise PhotoUnavailable("לא הצלחנו לפתור את התרגיל. נסו שוב.") from e
+        log.info("math photo: %s, %d+%d tokens", res.model, res.usage.input_tokens, res.usage.output_tokens)
+        return out
+
+
+def photo_client(key: str):
+    import anthropic
+    return anthropic.Anthropic(api_key=key, timeout=120.0, max_retries=1)
+
+
+def math_model() -> str:
+    return os.environ.get("MATH_MODEL", "").strip() or DEFAULT_MODEL

app/math_skills.py

@@ -0,0 +1,68 @@
+"""The 9th-grade algebra skill graph for the math path (`math_algebra9.json`).
+
+Each skill names the skills it needs first, a sample question, and for each wrong choice the mistake it shows.
+A mistake sends the student back to the skill it comes from (`back`), or keeps them on the same skill (`null`).
+The graph follows the Ministry of Education's 9th-grade teaching schedule (2026/27) and the summer review for
+students placed in 5 units; `core` marks what that review stresses. The questions are written for the app, and
+every skill, link and mistake still needs a 5-unit teacher's review.
+
+`problems` is run by the tests and on loading: a broken graph is refused before a student meets it.
+"""
+from __future__ import annotations
+
+import json
+from functools import cache
+from pathlib import Path
+
+GRAPH = Path(__file__).with_name("math_algebra9.json")
+
+
+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."""
+    units = {u["id"] for u in graph["units"]}
+    skills = {s["id"]: s for s in graph["skills"]}
+    mistakes = graph["mistakes"]
+    out = [f"{s['id']}: unknown unit {s['unit']}" for s in skills.values() if s["unit"] not in units]
+    out += [f"{s['id']}: unknown prerequisite {p}" for s in skills.values() for p in s["prereqs"] if p not in skills]
+    if out:
+        return out
+    below: dict[str, set[str]] = {}
+
+    def ancestors(sid: str, path: tuple[str, ...] = ()) -> set[str]:
+        if sid in path:
+            raise ValueError(" -> ".join(path + (sid,)))
+        if sid not in below:
+            below[sid] = {a for p in skills[sid]["prereqs"] for a in (p, *ancestors(p, path + (sid,)))}
+        return below[sid]
+
+    try:
+        for sid in skills:
+            ancestors(sid)
+    except ValueError as cycle:
+        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]]
+        choices = s["sample"]["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")
+    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
+
+
+@cache
+def algebra9() -> dict:
+    graph = json.loads(GRAPH.read_text(encoding="utf-8"))
+    if found := problems(graph):
+        raise ValueError(f"{GRAPH.name}: " + "; ".join(found))
+    return graph

docs/mathly-supabase.sql

@@ -0,0 +1,313 @@
+-- The whole database of a new Supabase project for the app, in one go: paste it into the SQL Editor and run it.
+-- Gathered from the README's sections (each is explained there); made for mathly, the math Space, whose classes
+-- are math classes by default (the last lines).
+create table public.attempts (
+  id         bigint generated always as identity primary key,
+  user_id    uuid not null default auth.uid() references auth.users (id) on delete cascade,
+  cat        text not null,      -- the topic id, e.g. l1-verbs
+  phrase     text not null,      -- the Hebrew prompt
+  score      int  not null,      -- 0-100
+  unrelated  boolean not null default false,   -- "different sentence?"
+  issues     jsonb not null default '[]'::jsonb, -- compact [{word, expected, heard, score}], never audio
+  model      text not null default '',
+  version    text not null default '',
+  created_at timestamptz not null default now()
+);
+create index attempts_user_time on public.attempts (user_id, created_at desc);
+create index attempts_created_at_idx on public.attempts (created_at desc);
+
+alter table public.attempts enable row level security;
+grant select, insert on public.attempts to authenticated;
+create policy "students add their own attempts"  on public.attempts
+  for insert to authenticated with check (user_id = auth.uid());
+create policy "students read their own attempts" on public.attempts
+  for select to authenticated using (user_id = auth.uid());
+
+-- Anonymous aggregate buckets for the teacher's Monitoring graph. Only the backend service role may call it.
+create or replace function public.activity_buckets(p_hours integer default 24, p_bucket_minutes integer default 15)
+returns table (bucket timestamptz, attempts bigint, active_students bigint)
+language sql stable security invoker set search_path = '' as $$
+  select date_bin(make_interval(mins => greatest(1, least(p_bucket_minutes, 60))), a.created_at,
+                  timestamptz '2000-01-01 00:00:00+00'),
+         count(*)::bigint, count(distinct a.user_id)::bigint
+  from public.attempts a
+  where a.created_at >= now() - make_interval(hours => greatest(1, least(p_hours, 168)))
+  group by 1 order by 1
+$$;
+revoke execute on function public.activity_buckets(integer, integer) from public, anon, authenticated;
+grant execute on function public.activity_buckets(integer, integer) to service_role;
+
+-- Totals for the full selected window. This is separate from the buckets so a student who practised in several
+-- buckets is counted only once.
+drop function if exists public.activity_summary(integer);
+create or replace function public.activity_summary(p_hours integer default 24)
+returns table (attempts bigint, active_students bigint, returning_students bigint, active_days bigint)
+language sql stable security invoker set search_path = '' as $$
+  with windowed as (
+    select a.user_id, (a.created_at at time zone 'Asia/Jerusalem')::date as practice_day
+    from public.attempts a
+    where a.created_at >= now() - make_interval(hours => greatest(1, least(p_hours, 168)))
+  ), per_user as (
+    select user_id, count(distinct practice_day) as days from windowed group by user_id
+  )
+  select (select count(*) from windowed)::bigint,
+         (select count(*) from per_user)::bigint,
+         (select count(*) from per_user where days >= 2)::bigint,
+         (select count(distinct practice_day) from windowed)::bigint
+$$;
+revoke execute on function public.activity_summary(integer) from public, anon, authenticated;
+grant execute on function public.activity_summary(integer) to service_role;
+
+-- Recent system activity shown only in the management panel. The backend writes with the service-role key;
+-- no browser role gets direct table access.
+create table public.system_events (
+  id          bigint generated always as identity primary key,
+  kind        text not null check (kind in ('exercise','game','permission','content')),
+  actor_id    uuid references auth.users(id) on delete set null,
+  actor_email text not null default '',
+  label       text not null default '',
+  details     jsonb not null default '{}'::jsonb,
+  created_at  timestamptz not null default now()
+);
+create index system_events_created_at_idx on public.system_events (created_at desc);
+alter table public.system_events enable row level security;
+
+create table public.app_secrets (
+  name        text primary key check (name in ('SAWTAK_API_KEY','ANTHROPIC_API_KEY','TUTOR_MODEL')),
+  ciphertext  text not null,
+  last4       text not null default '',
+  updated_by  text not null default '',
+  updated_at  timestamptz not null default now()
+);
+alter table public.app_secrets enable row level security;
+revoke all on public.app_secrets from anon, authenticated;
+
+alter table public.app_secrets drop constraint if exists app_secrets_name_check;
+alter table public.app_secrets add constraint app_secrets_name_check
+  check (name in ('SAWTAK_API_KEY','ANTHROPIC_API_KEY','TUTOR_MODEL'));
+
+alter table public.attempts
+  add column if not exists issues jsonb not null default '[]'::jsonb,
+  add column if not exists model text not null default '',
+  add column if not exists version text not null default '';
+
+create table public.user_access (
+  user_id uuid primary key references auth.users(id) on delete cascade,
+  email text not null,
+  roles text[] not null default array['student']::text[],
+  entitlements text[] not null default '{}'::text[],
+  subject text not null default '',                 -- developer-set subject for admin-created classes
+  updated_at timestamptz not null default now(),
+  updated_by uuid references auth.users(id),
+  constraint valid_roles check (roles <@ array['student','teacher','flagger','admin','developer']::text[]),
+  constraint valid_entitlements check (entitlements <@ array['practice','games','tutor','path','library']::text[])
+);
+create unique index user_access_email_idx on public.user_access (lower(email));
+alter table public.user_access enable row level security;
+create table public.access_audit (
+  id bigint generated always as identity primary key,
+  target_user_id uuid not null,
+  changed_by uuid not null,
+  old_access jsonb not null,
+  new_access jsonb not null,
+  created_at timestamptz not null default now()
+);
+alter table public.access_audit enable row level security;
+
+alter table public.user_access add column if not exists subject text not null default '';
+alter table public.user_access drop constraint if exists valid_entitlements;
+update public.user_access
+set entitlements = array_append(entitlements, 'practice')
+where 'path' = any(entitlements) and not ('practice' = any(entitlements));
+alter table public.user_access add constraint valid_entitlements check (
+  entitlements <@ array['practice','games','tutor','path','library']::text[]
+);
+
+create table public.tutors (
+  email      text primary key,
+  granted_by text not null default '',   -- the teacher who gave the rank
+  created_at timestamptz not null default now()
+);
+alter table public.tutors enable row level security;   -- no policy: only the secret key reads and writes it
+
+create table public.flags (
+  id         bigint generated always as identity primary key,
+  email      text not null,      -- the tutor
+  cat        text not null,      -- the topic id
+  phrase     text not null,
+  he         text not null,      -- the Hebrew prompt
+  ar         text not null,      -- the accepted answer the scorer matched
+  ipa        text not null,      -- its phonemes: what the tutor says was said
+  heard_ipa  text not null,      -- the model's free decode
+  score      int  not null,
+  unrelated  boolean not null default false,
+  note       text not null default '',
+  result     jsonb not null,     -- the whole score response
+  model      text not null,
+  version    text not null default '',
+  audio      text,               -- object name in the private flags Storage bucket
+  status     text not null default 'pending', -- pending, confirmed, rejected, or fixed
+  category   text,
+  reviewed_by text,
+  reviewed_at timestamptz,
+  review_note text not null default '',
+  false_issues jsonb not null default '[]'::jsonb, -- [{word, expected, heard}]
+  created_at timestamptz not null default now()
+);
+alter table public.flags enable row level security;   -- no policy: only the secret key reads and writes it
+
+insert into storage.buckets (id, name, public, file_size_limit, allowed_mime_types)
+values (
+  'flags',
+  'flags',
+  false,
+  2000000,
+  array['audio/webm','audio/ogg','audio/mp4','audio/mpeg','audio/wav','audio/x-wav']
+)
+on conflict (id) do update set
+  public = excluded.public,
+  file_size_limit = excluded.file_size_limit,
+  allowed_mime_types = excluded.allowed_mime_types;
+
+alter table public.flags
+  add column if not exists status text not null default 'pending',
+  add column if not exists category text,
+  add column if not exists reviewed_by text,
+  add column if not exists reviewed_at timestamptz,
+  add column if not exists review_note text not null default '',
+  add column if not exists false_issues jsonb not null default '[]'::jsonb;
+
+create table public.lab_samples (
+  id bigint generated always as identity primary key, email text not null,
+  item text not null, ar text not null, ipa text not null, speaker text not null default '',
+  label text not null,             -- 'correct' or 'mistake'
+  mistake jsonb,                   -- {"index", "expected"}: the sound said wrong on purpose
+  device text not null default '', score int not null, heard_ipa text not null,
+  flagged jsonb not null default '[]'::jsonb,   -- the sounds the scorer marked down, "expected>heard"
+  result jsonb not null, model text not null, version text not null default '',
+  audio text,                      -- the recording's name in the storage bucket lab
+  created_at timestamptz not null default now());
+alter table public.lab_samples enable row level security;
+insert into storage.buckets (id, name) values ('lab', 'lab') on conflict (id) do nothing;
+
+create table public.calibrations (
+  id          bigint generated always as identity primary key,
+  expected    text not null,
+  heard       text not null,
+  floor       numeric not null default 70,
+  scope       text not null default 'global', -- global or phrase
+  phrase      text not null default '',
+  evidence    jsonb not null default '{}',    -- report/reporter counts and supporting phrase keys
+  model       text not null default '',
+  status      text not null default 'draft',  -- draft, applied, or rejected
+  proposed_by text not null,
+  reviewed_by text,
+  reviewed_at timestamptz,
+  created_at  timestamptz not null default now()
+);
+alter table public.calibrations enable row level security;
+
+create table public.scoring_rules (
+  id         text primary key,                 -- a rule of rules.TOGGLES, e.g. dialect_Q, margins, rule_pharyngeal_h
+  active     boolean not null default true,
+  updated_by text not null default '',
+  updated_at timestamptz not null default now()
+);
+alter table public.scoring_rules enable row level security;
+
+create table public.writings (
+  user_id    uuid not null default auth.uid() references auth.users (id) on delete cascade,
+  topic      text not null,      -- the topic id, e.g. l1-hw
+  lines      jsonb not null,     -- the sentences as written, "" for one not written yet
+  updated_at timestamptz not null default now(),
+  primary key (user_id, topic)
+);
+
+alter table public.writings enable row level security;
+grant select, insert, update on public.writings to authenticated;
+create policy "students read their own writings"   on public.writings
+  for select to authenticated using (user_id = auth.uid());
+create policy "students add their own writings"    on public.writings
+  for insert to authenticated with check (user_id = auth.uid());
+create policy "students change their own writings" on public.writings
+  for update to authenticated using (user_id = auth.uid()) with check (user_id = auth.uid());
+
+create table public.videos (
+  id         bigint generated always as identity primary key,
+  lesson     text not null,                        -- the lesson id, e.g. 2 or 2.1
+  title      text not null,                        -- the topic's name on the path
+  url        text not null,                        -- https://vimeo.com/<number>[/<hash>] or https://www.youtube.com/watch?v=<id>
+  pos        int,                                  -- how many of the lesson's own topics stand before it; null = after them all
+  ord        int  not null default 0,              -- its turn among the videos of one place
+  created_at timestamptz not null default now()
+);
+alter table public.videos enable row level security;
+
+alter table public.videos add column if not exists pos int, add column if not exists ord int not null default 0;
+
+create table public.dailies (
+  id         bigint generated always as identity primary key,
+  level      text not null,                        -- a level id, e.g. 1
+  title      text not null,
+  url        text not null,                        -- https://vimeo.com/<number>[/<hash>] or a YouTube link
+  created_at timestamptz not null default now()
+);
+alter table public.dailies enable row level security;
+
+create table public.library (
+  id         bigint generated always as identity primary key,
+  level      text not null,                        -- a level id, e.g. 1
+  title      text not null,
+  url        text not null,
+  ord        int,                                  -- its turn in the list; none until the teacher moves a video
+  created_at timestamptz not null default now()
+);
+alter table public.library enable row level security;
+
+alter table public.library add column if not exists ord int;
+notify pgrst, 'reload schema';
+
+create table public.texts (
+  id         bigint generated always as identity primary key,
+  lesson     text not null,                        -- the lesson id, e.g. 2 or 2.1
+  title      text not null,                        -- the topic's name on the path
+  voices     text[] not null default '{}',         -- a dialogue's two voices by name (odd lines, even lines); empty = a story
+  lines      jsonb not null,                       -- [[Hebrew, Arabic in Hebrew letters], ...]
+  pos        int,                                  -- as in videos
+  ord        int  not null default 0,
+  created_at timestamptz not null default now()
+);
+alter table public.texts enable row level security;
+
+create table public.classes (
+  id         bigint generated always as identity primary key,
+  name       text not null unique,                 -- e.g. אוקטובר 2026
+  emails     text[] not null default '{}',         -- the students' Google emails, lower-case
+  nicknames  jsonb  not null default '{}',         -- {email: nickname}, for the students who have one
+  lessons    text[] not null default '{}',         -- the lesson ids the class studies; empty = every lesson
+  subject    text   not null default 'ערבית',      -- existing classes; new ones copy the creating admin
+  teachers   text[] not null default '{}',         -- class-scoped teachers; each address is also in emails
+  homework   text   not null default '',           -- the topic id the class practises now, e.g. l2-talk; '' = none
+  due        date,                                 -- the day the homework is due, if it has one
+  homeworks  jsonb  not null default '[]',         -- every homework of the class: [{"topic": ..., "due": ...}]
+  dailies    jsonb  not null default '[]',         -- the days of its daily videos: [{"video": id, "date": ...}]
+  created_at timestamptz not null default now()
+);
+alter table public.classes enable row level security;
+
+alter table public.classes add column if not exists nicknames jsonb not null default '{}',
+                           add column if not exists lessons text[] not null default '{}',
+                           add column if not exists homework text not null default '',
+                           add column if not exists due date,
+                           add column if not exists homeworks jsonb not null default '[]',
+                           add column if not exists teachers text[] not null default '{}',
+                           add column if not exists dailies jsonb not null default '[]',
+                           add column if not exists subject text not null default 'ערבית';
+update public.classes set subject = 'ערבית' where subject = '';
+
+-- the tutor's conversations (app/tutor.py)
+create table public.tutor_chats (id uuid primary key, user_id uuid, email text not null default '', scenario text not null, gender text not null default '', messages jsonb not null default '[]'::jsonb, turns int not null default 0, finished boolean not null default false, model text not null default '', input_tokens int not null default 0, output_tokens int not null default 0, created_at timestamptz not null default now(), updated_at timestamptz not null default now()); alter table public.tutor_chats enable row level security;
+
+-- mathly: a class is a math class unless it says otherwise
+alter table public.classes alter column subject set default 'מתמטיקה';
+notify pgrst, 'reload schema';

static/index.html

@@ -1,14 +1,14 @@
 <!doctype html>
-<html lang="he" dir="rtl" data-subject="__SUBJECT__">
+<html lang="he" dir="rtl" data-subject="__SUBJECT__" data-home="__HOME__">
 <head>
 <meta charset="utf-8">
 <meta name="viewport" content="width=device-width,initial-scale=1,viewport-fit=cover">
-<meta name="theme-color" content="#4B6A2C">
+<meta name="theme-color" content="__THEME_COLOR__">
 <meta name="mobile-web-app-capable" content="yes">
 <meta name="apple-mobile-web-app-capable" content="yes">
 <meta name="apple-mobile-web-app-status-bar-style" content="default">
-<meta name="apple-mobile-web-app-title" content="אהלא  וסהלא">
-<link rel="manifest" href="/static/manifest.webmanifest">
+<meta name="apple-mobile-web-app-title" content="__APP_NAME__">
+<link rel="manifest" href="__MANIFEST__">
 <link rel="icon" href="/static/icons/icon-192.png?v=2" sizes="192x192">
 <link rel="apple-touch-icon" href="/static/icons/icon-192.png?v=2">
 <title>__TITLE__</title>
@@ -740,10 +740,10 @@ body.manage #manage{width:100%;max-width:none}
 .modes button{display:flex;flex-direction:column;align-items:center;gap:2px;padding:8px 6px;border:0;border-radius:10px;background:transparent;color:var(--ink);font:700 16px/1.2 var(--f-body);cursor:pointer}
 .modes button small{font:600 12px/1.2 var(--f-body);color:var(--muted)}
 .modes button[aria-selected=true]{background:var(--surface);box-shadow:0 1px 2px rgba(0,0,0,.15)}
-#manage.classes :is(#mTutors,#mTabs,#mHead,#mLessons,#mRoster,#mStudent),#manage:not(.classes) #mClasses{display:none}
-#manage.content :is(#mTutors,#mTabs,#mHead,#mLessons,#mRoster,#mStudent),#manage:not(.content) #mContent{display:none}
-#manage.flags :is(#mClasses,#mContent,#mTutors,#mTabs,#mHead,#mLessons,#mRoster,#mStudent),#manage:not(.flags) #mFlags{display:none}
-#manage.access :is(#mClasses,#mContent,#mFlags,#mTutors,#mTabs,#mHead,#mLessons,#mRoster,#mStudent),#manage:not(.access) #mAccess{display:none}
+#manage.classes :is(#mTabs,#mHead,#mLessons,#mRoster,#mStudent),#manage:not(.classes) #mClasses{display:none}
+#manage.content :is(#mTabs,#mHead,#mLessons,#mRoster,#mStudent),#manage:not(.content) #mContent{display:none}
+#manage.flags :is(#mClasses,#mContent,#mTabs,#mHead,#mLessons,#mRoster,#mStudent),#manage:not(.flags) #mFlags{display:none}
+#manage.access :is(#mClasses,#mContent,#mFlags,#mTabs,#mHead,#mLessons,#mRoster,#mStudent),#manage:not(.access) #mAccess{display:none}
 .access-actions{display:flex;justify-content:flex-end;margin:8px 0}.access-scroll{overflow:auto}.access-table{width:100%;border-collapse:collapse;min-width:1180px}.access-table :is(th,td){padding:9px 10px;border-bottom:1px solid var(--line);text-align:center}.access-table th{position:sticky;top:0;background:var(--surface);font-size:13px;white-space:nowrap;z-index:1}.access-table th>span{display:block;margin-bottom:4px}.access-table .access-all{display:inline-flex;align-items:center;gap:4px;color:var(--muted);font-weight:600;cursor:pointer}.access-table .access-all small{font-size:11px}.access-table :is(th,td):first-child{text-align:start;position:sticky;right:0;background:var(--surface);z-index:2;min-width:260px}.access-table td:first-child{font-weight:700}.access-table td:first-child small{display:block;color:var(--muted);font-weight:400;direction:ltr;overflow:hidden;text-overflow:ellipsis}.access-table input{width:18px;height:18px}.access-table .save-cell{min-width:96px}
 @media(max-width:700px){.modes{grid-template-columns:repeat(2,1fr)}}
 .flag-review{gap:10px}.flag-review h2{margin:0}.flag-review .meta{color:var(--muted);font-size:13px}.flag-review fieldset{border:0;margin:0;padding:0;display:flex;flex-wrap:wrap;gap:7px}
@@ -875,17 +875,12 @@ body.manage #manage{width:100%;max-width:none}
 #mClasses>.btn{align-self:flex-start}
 #mClasses .card>.btn{align-self:flex-start}
 /* a student's own screen takes the class's place in the panel: the way back, their figures, their lessons, their sentences */
-#manage.student :is(#mTutors,#mTabs,#mHead,#mLessons,#mRoster),#manage:not(.student) #mStudent{display:none}
+#manage.student :is(#mTabs,#mHead,#mLessons,#mRoster),#manage:not(.student) #mStudent{display:none}
 #mStudent{display:flex;flex-direction:column;gap:inherit}
 #mStudent .back{align-self:flex-start}
 .student-classes{display:flex;align-items:center;gap:6px;flex-wrap:wrap;margin-top:10px}
 .student-classes>span{color:var(--muted);font-size:13px}
 .student-classes .tab{padding:7px 11px;font-size:13px}
-#mTutors .note{margin:0;padding:8px 16px}
-#mTutors label{display:flex;align-items:center;gap:10px;padding:7px 16px;border-top:1px solid var(--line);cursor:pointer}
-#mTutors label span{display:flex;flex-direction:column;min-width:0}
-#mTutors label b{overflow:hidden;text-overflow:ellipsis;white-space:nowrap}
-#mTutors label small{color:var(--muted);font-size:12px;overflow:hidden;text-overflow:ellipsis;white-space:nowrap}
 .cform{display:flex;flex-direction:column;gap:10px}
 .cform label{display:flex;flex-direction:column;gap:4px;font:700 14px/1.3 var(--f-body)}
 .cform label small{font-weight:500;color:var(--muted)}
@@ -1226,10 +1221,16 @@ html[data-subject="arabic"] #mailForm{animation-delay:6.55s}
 .install-actions{display:flex;gap:8px;justify-content:flex-end}
 .install-actions button{padding:9px 16px;border-radius:10px;border:1px solid var(--olive);background:var(--surface);color:var(--olive);font:700 15px/1.2 var(--f-body);cursor:pointer}
 .install-actions .primary{background:var(--olive);color:var(--on-olive)}
-/* The math class (/math) opens on its own logo, with the buttons in its blue. */
+/* The math class (/math) opens on its own logo, on black (the logo's ink is light for it), with the buttons in its blue. */
+html[data-subject="math"] #logo-splash{background:#000}
+html[data-subject="math"] #libraryBtn{display:none}   /* the digital library is Arabic videos */
 html[data-subject="math"] :is(#startBtn,#loginBtn,#roles button){background:#2F5597}
-html[data-subject="math"] #roles :is(#libraryBtn,#manageBtn,#labBtn){background:#fff;color:#2F5597;box-shadow:inset 0 0 0 2px #2F5597}
-html[data-subject="math"] #mailForm button{border-color:#2F5597;color:#2F5597}
+html[data-subject="math"] #roles :is(#libraryBtn,#manageBtn,#labBtn){background:#000;color:#7FA6F0;box-shadow:inset 0 0 0 2px #7FA6F0}
+html[data-subject="math"] #mailForm span{color:#9EA7A0}
+html[data-subject="math"] #mailForm input{background:#111;border-color:#3A403C;color:#F4F2EC}
+html[data-subject="math"] #mailForm button,html[data-subject="math"] #denied button{background:#000;border-color:#7FA6F0;color:#7FA6F0}
+html[data-subject="math"] :is(#mailMsg,#denied){color:#F4F2EC}
+html[data-subject="math"] #bootErr{color:#F08A8A}
 @keyframes start-in{from{opacity:0;transform:translateY(8px)}to{opacity:1;transform:none}}
 @media (prefers-reduced-motion:reduce){#startBtn,#loginBtn,#roles button,#mailForm{animation:none;opacity:1}#logo-splash{transition:none}}
 #wrap{opacity:1;transition:opacity .65s ease .1s}
@@ -1284,7 +1285,7 @@ html[data-subject="math"] #mailForm button{border-color:#2F5597;color:#2F5597}
     <span class="reward-totals"><span class="reward-week" id="rewardWeek">0/4 השבוע</span><span class="reward-total" id="rewardTotal">0 ★</span></span>
   </button>
   <section id="vids" aria-live="polite"></section>
-  <nav id="nav" aria-label="ניווט"><button data-view="">מסלול</button><button data-view="live" hidden>שיעור חי</button><button data-view="verbs">פעלים</button><button data-view="games" hidden>משחקים</button><button data-view="refer">חבר מביא חבר</button></nav>
+  <nav id="nav" aria-label="ניווט"><button data-view="">מסלול</button><button data-view="live">שיעור חי</button><button data-view="verbs">פעלים</button><button data-view="games" hidden>משחקים</button><button data-view="refer">חבר מביא חבר</button></nav>
   <nav class="path" id="path" aria-label="מסלול הלימוד"></nav>
   <section class="live-page" id="liveView" aria-live="polite"></section>
   <button id="toNow" hidden></button>
@@ -1368,7 +1369,6 @@ html[data-subject="math"] #mailForm button{border-color:#2F5597;color:#2F5597}
     <div id="mContent"></div>
     <div id="mFlags"></div>
     <div class="card" id="mAccess"></div>
-    <div class="card hard" id="mTutors" hidden></div>
     <div class="tabs" id="mTabs" role="tablist" aria-label="סינון תלמידים לפי כיתה" hidden></div>
     <div class="card" id="mHead" hidden></div>
     <div class="card hard" id="mLessons" hidden></div>
@@ -1469,7 +1469,7 @@ html[data-subject="math"] #mailForm button{border-color:#2F5597;color:#2F5597}
     <fieldset class="lpick"><legend>סרטונים יומיים<small>הסרטונים של הרמות שהכיתה לומדת, מהספרייה שתחת „תוכן”. קבעו תאריך לסרטון, ומאותו יום התלמידים רואים אותו בכפתור „סרטון יומי” שמעל המסלול, והוא מסומן עד שצופים בו. סרטון בלי תאריך לא מוצג לכיתה.</small></legend><div class="dailies" id="editDailies"></div></fieldset>
     <label>התלמידים<small>שורה לכל תלמיד: כתובת הדוא"ל שבה הוא נכנס, ואחריה כינוי אם רוצים. בכיתה רואים את הכינוי, או את השם מ-Google. תלמיד יכול להיות בכמה כיתות.</small>
       <textarea id="editEmails" spellcheck="false" placeholder="dana@gmail.com דנה&#10;avi@gmail.com"></textarea></label>
-    <fieldset class="lpick"><legend>מורי הכיתה<small>בחרו אחד או יותר מתלמידי הכיתה. ההרשאה היא לכיתה הזו בלבד.</small></legend><div class="teacher-picks" id="editTeachers"></div></fieldset>
+    <fieldset class="lpick" id="editTeachersField" hidden><legend>מורי הכיתה<small>בחרו אחד או יותר מתלמידי הכיתה. ההרשאה היא לכיתה הזו בלבד.</small></legend><div class="teacher-picks" id="editTeachers"></div></fieldset>
     <div class="row"><button class="btn primary" id="editSave"></button><span class="sub" id="editCount"></span><span class="sep"></span><button class="btn danger" type="button" id="editDelete">מחיקת הכיתה</button><span class="msg" id="editMsg" role="alert"></span></div>
   </form>
 </dialog>
@@ -1739,7 +1739,7 @@ const store={get(k,d){try{const v=localStorage.getItem(k);return v?JSON.parse(v)
 let driving=false;
 /* LESSONS and CATS are the student's: the lessons of their classes (all of them for a teacher, or before the first class) */
 let TEACHER_DAILIES=[];   // for a teacher: the daily videos of every class, {id, title, embed, date}
-let ME_EMAIL="";   // the signed-in account: in the lab, who records
+let ME_EMAIL="", ME_SUBJECT="";   // ME_SUBJECT: the account's subject as /api/me gives it ("math"), "" for none   // the signed-in account: in the lab, who records
 let MY_CLASSES=[], MY_CLASS=null;   // a student's classes ({name, lessons, homeworks, dailies}), and the one they practise in now
 let daily=null, dailySaid=new Set(), dailyWas={};   // the daily session on the card: its sentence ids, those said in it, and their best scores before it
 let ALL_LEVELS=[], ALL_LESSONS=[], ALL_CATS=[], GAMES=[], MY_LESSONS=null, LESSONS=[], CATS=[], PHRASES=[], cat=store.get("ihki.cat",""), best=store.get("ihki.best2",{}), order=[], pos=0, cur=null;
@@ -2440,14 +2440,14 @@ function showView(view){   // "" is the path, which is laid out again: it was no
   if(view) document.body.dataset.view=view; else delete document.body.dataset.view;
   scrollTo(0,0); drawPath(true); if(view==="live") loadLive();
 }
-const LIVE_TAB_ENABLED=false; // Keep the finished live-class flow hidden until it is ready for release.
+const LIVE_TAB_ENABLED=true;
 let LIVE={sessions:[],teaches:[],code:"",timer:null,rec:null,busy:false};
 const liveEsc=s=>String(s??"").replace(/[&<>"']/g,c=>({"&":"&amp;","<":"&lt;",">":"&gt;",'"':"&quot;","'":"&#39;"}[c]));
 const livePhrase=p=>`${liveEsc(p.he)} · ${liveEsc((ALL_CATS.find(c=>c.id===p.cat)||{}).name||"")}`;
 function liveSchedule(){ clearTimeout(LIVE.timer); if(document.body.dataset.view==="live"&&LIVE.code) LIVE.timer=setTimeout(()=>loadLiveSession(),3000); }
 async function loadLive(silent=false){
   try{
-    const res=await api("/api/live"), data=await res.json(); if(!res.ok) throw new Error(data.detail||res.status);
+    const res=await api("/api/live",{cache:"no-store"}), data=await res.json(); if(!res.ok) throw new Error(data.detail||res.status);
     LIVE.sessions=data.sessions||[]; LIVE.teaches=data.teaches||[];
     const tab=$("nav").querySelector('[data-view="live"]'); tab.hidden=!LIVE_TAB_ENABLED; tab.classList.toggle("live-on",LIVE_TAB_ENABLED&&LIVE.sessions.length>0);
     if(!silent&&document.body.dataset.view==="live"&&!LIVE.code) drawLiveHome();
@@ -2480,7 +2480,7 @@ function openLive(code,teacher){ LIVE.code=code; LIVE.teacher=teacher; loadLiveS
 async function loadLiveSession(){
   if(!LIVE.code||LIVE.busy) return liveSchedule();
   try{
-    const res=await api(`/api/live/${LIVE.code}`), data=await res.json().catch(()=>({}));
+    const res=await api(`/api/live/${LIVE.code}`,{cache:"no-store"}), data=await res.json().catch(()=>({}));
     if(res.status===404){ LIVE.code=""; await loadLive(); return; }
     if(!res.ok) throw new Error(data.detail||res.status);
     if(LIVE.teacher) drawLiveTeacher(data.session); else drawLiveStudent(data.session);
@@ -4415,7 +4415,7 @@ async function loadManage(){
       const detail=(await res.json().catch(()=>({}))).detail||res.status;
       state.textContent=res.status===403?"הפאנל פתוח למורים בלבד.":`נתוני התלמידים לא זמינים כרגע (${detail}).`; return;
     }
-    CLASS=await res.json(); await loadContent();
+    CLASS=await res.json(); await Promise.all([loadContent(),loadMathUnits()]);
     if(mMode==="flags") await loadFlags();
     if(mMode==="access") await loadAccess();
     TEACHER_DAILIES=CLASS.classes.flatMap(classDailies).map(d=>({...d.v,date:d.date})).sort((a,b)=>a.date.localeCompare(b.date));   // as just saved; the earliest day of each comes first
@@ -4531,7 +4531,7 @@ function drawManage(){
   if(!["classes","students","content","flags","access"].includes(mMode)) mMode=classes.length?"students":"classes";
   $("mModes").hidden=false; for(const mode of ["classes","content","flags","access"]) $("manage").classList.toggle(mode,mMode===mode);
   for(const b of $("mModes").children) b.setAttribute("aria-selected",b.dataset.mode===mMode);
-  drawClasses(classes); drawContent(); drawFlags(); drawAccess(); drawTutors(); drawTabs(classes); drawHead(klass,students);
+  drawClasses(classes); drawContent(); drawFlags(); drawAccess(); drawTabs(classes); drawHead(klass,students);
   if(klass||!classes.length) drawLessons(students,listed); else{ $("mLessons").innerHTML=""; $("mLessons").hidden=true; }
   drawRoster(klass,students,listed);
   const one=students.find(s=>s.email===shownStudent);   // a student who left the class has no screen in it
@@ -4639,6 +4639,7 @@ function drawFlags(){
   const box=$("mFlags"); box.innerHTML=""; for(const url of flagAudioUrls) URL.revokeObjectURL(url); flagAudioUrls=[];
   drawActivity(box);
   drawAdminSubjects(box);
+  drawBackupControls(box);
   drawApiKeys(box);
   drawSystemActivity(box);
   drawTtsCacheControls(box);
@@ -4754,6 +4755,54 @@ function drawFlags(){
   }
 }
 
+let SAVED_BACKUPS=null, backupsLoading=false;
+/* Developer-only database archives kept in a private Supabase Storage bucket. */
+function drawBackupControls(box){
+  if(!can("*")) return;
+  const card=mark("card",""), actions=mark("row",""), create=mark("btn primary","יצירת גיבוי","button"),
+    select=document.createElement("select"), restore=mark("btn","שחזור הגיבוי הנבחר","button"), download=mark("btn","הורדת עותק","button"), msg=mark("msg","");
+  const fill=()=>{
+    select.replaceChildren();
+    if(!SAVED_BACKUPS||!SAVED_BACKUPS.length){ const o=document.createElement("option"); o.textContent=backupsLoading?"טוען גיבויים…":"אין גיבויים שמורים"; o.value=""; select.append(o); }
+    else for(const b of SAVED_BACKUPS){ const o=document.createElement("option"), match=b.name.match(/(\d{4}-\d{2}-\d{2})_(\d{2})-(\d{2})-(\d{2})/), stamp=match?`${match[1]} · ${match[2]}:${match[3]}:${match[4]}`:b.name; o.value=b.name; o.textContent=stamp+(b.metadata&&b.metadata.size?` · ${Math.ceil(b.metadata.size/1024)} KB`:""); select.append(o); }
+    restore.disabled=!select.value; download.disabled=!select.value;
+  };
+  if(SAVED_BACKUPS===null&&!backupsLoading){
+    backupsLoading=true; api("/api/admin/backups").then(async res=>{ const data=await res.json().catch(()=>({})); if(!res.ok) throw new Error(data.detail||res.status); SAVED_BACKUPS=data.backups||[]; })
+      .catch(err=>msg.textContent="טעינת הגיבויים נכשלה: "+err.message).finally(()=>{ backupsLoading=false; fill(); });
+  }
+  fill();
+  create.onclick=async()=>{
+    create.disabled=restore.disabled=download.disabled=true; msg.textContent="יוצר גיבוי…";
+    try{ const res=await api("/api/admin/backups",{method:"POST"}), data=await res.json().catch(()=>({})); if(!res.ok) throw new Error(data.detail||res.status); const list=await api("/api/admin/backups"), listed=await list.json(); if(!list.ok) throw new Error(listed.detail||list.status); SAVED_BACKUPS=listed.backups||[]; fill(); select.value=data.name; msg.textContent="הגיבוי נשמר."; }
+    catch(err){ msg.textContent=err.message.startsWith("הגיבוי נכשל")?err.message:"הגיבוי נכשל: "+err.message; }
+    create.disabled=false; fill();
+  };
+  download.onclick=async()=>{
+    download.disabled=restore.disabled=create.disabled=true; msg.textContent="מכין הורדה…";
+    try{
+      const res=await api(`/api/admin/backups/file?name=${encodeURIComponent(select.value)}`); if(!res.ok) throw new Error((await res.json().catch(()=>({}))).detail||res.status);
+      const url=URL.createObjectURL(await res.blob()), a=document.createElement("a"); a.href=url; a.download=select.value; a.click(); setTimeout(()=>URL.revokeObjectURL(url),30000); msg.textContent="העותק הורד.";
+    }catch(err){ msg.textContent="הגיבוי נכשל: "+err.message; }
+    create.disabled=false; fill();
+  };
+  restore.onclick=async()=>{
+    const name=select.value; if(!name||!confirm(`לשחזר מהגיבוי ${name}? נתונים בעלי אותו מזהה יעודכנו. נתונים חדשים שאינם בגיבוי לא יימחקו.`)) return;
+    restore.disabled=download.disabled=create.disabled=true; msg.textContent="משחזר… אין לסגור את החלון.";
+    try{
+      const res=await api("/api/admin/backups/restore",{method:"POST",headers:{"Content-Type":"application/json"},body:JSON.stringify({name})}), data=await res.json().catch(()=>({}));
+      if(!res.ok) throw new Error(data.detail||res.status);
+      const rows=Object.values(data.tables||{}).reduce((a,b)=>a+b,0);
+      msg.textContent=`השחזור הושלם: ${rows} רשומות.`;
+      CLASS=null; flagsLoaded=false; ADMIN_SUBJECTS=null; await loadManage();
+    }catch(err){ msg.textContent="השחזור נכשל: "+err.message; }
+    create.disabled=false; fill();
+  };
+  actions.append(create,select,restore,download,msg);
+  card.append(mark("","גיבוי ושחזור","h2"),mark("sub","הגיבויים נשמרים לפי חותמת זמן וכוללים את נתוני האפליקציה ואת הציון הטוב ביותר של כל תלמיד בכל משפט. היסטוריית הניסיונות וההקלטות אינן נשמרות. השחזור ממזג את הגיבוי ואינו מוחק נתונים חדשים. משתמשי ההתחברות עצמם וגיבויי התשתית של Supabase אינם כלולים.","p"),actions);
+  box.append(card);
+}
+
 /* Developer-only: the subject stamped onto every class an admin creates. The API enforces the same boundary. */
 function drawAdminSubjects(box){
   if(!can("*")) return;
@@ -4764,8 +4813,11 @@ function drawAdminSubjects(box){
     if(data.setup){ const code=mark("",data.setup,"code"); code.dir="ltr"; list.append(mark("setup","יש ליצור את טבלת ההרשא��ת:","p"),code); return; }
     if(!(data.admins||[]).length){ list.append(mark("sub","אין כרגע מנהלים.","p")); return; }
     for(const admin of data.admins){
-      const row=mark("key-row",""), who=document.createElement("div"), form=document.createElement("form"), input=document.createElement("input"), save=mark("btn primary","שמירה","button"), msg=mark("msg","");
-      who.append(mark("",admin.name||admin.email,"b"),mark("",admin.email,"small")); input.value=admin.subject||""; input.maxLength=80; input.required=true; input.placeholder="למשל: מתמטיקה או ערבית"; input.setAttribute("aria-label",`המקצוע של ${admin.name||admin.email}`); save.type="submit";
+      const row=mark("key-row",""), who=document.createElement("div"), form=document.createElement("form"), input=document.createElement("select"), save=mark("btn primary","שמירה","button"), msg=mark("msg","");
+      who.append(mark("",admin.name||admin.email,"b"),mark("",admin.email,"small")); const labels=(data.subjects||[]).map(s=>s.label), option=(value,text,off)=>{ const o=document.createElement("option"); o.value=value; o.textContent=text; o.disabled=!!off; input.append(o); };
+      if(!admin.subject) option("","בחירת מקצוע",true);
+      else if(!labels.includes(admin.subject)) option(admin.subject,`${admin.subject} (לא ברשימה, יש לבחור מחדש)`,true);   // typed before the list: no class can match it
+      labels.forEach(l=>option(l,l)); input.value=admin.subject||""; input.required=true; input.setAttribute("aria-label",`המקצוע של ${admin.name||admin.email}`); save.type="submit";
       form.onsubmit=async e=>{ e.preventDefault(); save.disabled=true; msg.textContent="שומר…"; try{ const res=await api(`/api/admin-subjects/${admin.id}`,{method:"PUT",headers:{"Content-Type":"application/json"},body:JSON.stringify({subject:input.value})}), data=await res.json().catch(()=>({})); if(!res.ok) throw new Error(data.detail||res.status); admin.subject=data.subject; input.value=data.subject; msg.textContent="נשמר"; }catch(err){ msg.textContent="השמירה נכשלה: "+err.message; } save.disabled=false; };
       form.append(input,save,msg); row.append(who,form); list.append(row);
     }
@@ -4983,6 +5035,16 @@ function drawActivityOnly(){
 }
 const lessonsLine=ls=>byLevel(ls).map(g=>`${g.level.name}: ${lessonsWord(g.lessons)} (${g.lessons.filter(l=>!l.soon).length} מוכנים)`).join(" · ");   // "שלב א: שיעורים 1–10 (2 מוכנים)"
 /* The classes' part: a card per class with what it is made of, and its buttons: edit, delete, and on to its students' progress. */
+/* A math class (subject "מתמטיקה") studies units of the math path, kept as its lessons; it has no homework or daily
+   videos yet. A new class is a math one when its admin's subject is, or, for a developer, when it is opened on /math. */
+const MATH_LABEL="מתמטיקה";
+let MATH_UNITS=null;   // [{id, name, count}]: the math path's units, loaded with the panel
+const isMathClass=c=>c?c.subject===MATH_LABEL:(ME_SUBJECT||document.documentElement.dataset.subject)==="math";
+async function loadMathUnits(){
+  if(MATH_UNITS) return;
+  try{ const r=await fetch("/api/math/skills"); if(r.ok){ const g=await r.json(); MATH_UNITS=g.units.map(u=>({id:u.id,name:u.name,count:g.skills.filter(s=>s.unit===u.id).length})); } }catch{}
+}
+const unitsLine=ids=>{ const all=MATH_UNITS||[], mine=all.filter(u=>ids.includes(u.id)); return mine.length===all.length?`כל היחידות (${all.length})`:mine.map(u=>u.name).join(" · "); };
 function drawClasses(classes){
   const box=$("mClasses"); box.innerHTML="";
   if(!classes.length){
@@ -4995,15 +5057,17 @@ function drawClasses(classes){
     const card=mark("card",""), top=mark("chead",""), name=mark("","","h2"), n=document.createElement("bdi"), edit=mark("btn","עריכה","button"), del=mark("btn danger","מחיקה","button");
     n.textContent=c.name; name.append(n); edit.onclick=()=>editClass(c); del.onclick=()=>deleteClass(c); top.append(name,edit,del);
     const facts=mark("facts","","dl"), fact=(what,...value)=>{ const dd=document.createElement("dd"); dd.append(...value); facts.append(mark("",what,"dt"),dd); };
+    const math=isMathClass(c);
     fact("מקצוע",c.subject||"לא הוגדר");
-    fact("שיעורים",lessonsLine(ALL_LESSONS.filter(l=>c.lessons.includes(l.id))));
+    if(math) fact("יחידות",unitsLine(c.lessons));
+    else fact("שיעורים",lessonsLine(ALL_LESSONS.filter(l=>c.lessons.includes(l.id))));
     const mine=CLASS.students.filter(s=>c.name in s.classes);
     fact("תלמידים",...(mine.length?[`${mine.length}: `,...mine.flatMap((s,k)=>{ const b=document.createElement("bdi"); b.textContent=s.classes[c.name]||s.name||s.email; return k?[", ",b]:[b]; })]:["עוד אין"]));
     const teachers=(c.teachers||[]).map(e=>{ const s=mine.find(x=>x.email.toLowerCase()===e); return s&&(s.classes[c.name]||s.name)||e; });
     fact("מורים",teachers.length?teachers.join(" · "):"עוד לא נבחרו");
     const hws=hwOf(c,ALL_CATS).map(h=>mark("",[h.c.name,lessonName(ALL_LESSONS.find(l=>l.id===h.c.lesson)),dueText(h.due).text].filter(Boolean).join(" · "),"div"));
-    fact("שיעורי בית",...(hws.length?hws:["אין"]));
-    const days=classDailies(c);
+    if(!math) fact("שיעורי בית",...(hws.length?hws:["אין"]));
+    const days=math?[]:classDailies(c);
     if(days.length) fact("סרטונים יומיים",...days.map(d=>mark("",`${d.v.title} · ${dayWord(d.date)}`,"div")));
     const go=mark("btn","התקדמות התלמידים ‹","button"); go.onclick=()=>{ shownClass=c.name; store.set("ihki.mstudentClass",c.name); shownStudent=""; showMode("students"); scrollTo(0,0); };
     card.append(top,facts,go); box.append(card);
@@ -5200,33 +5264,6 @@ addEventListener("popstate",e=>{
   const to=e.state&&e.state.student||""; if(to===shownStudent||!CLASS) return;
   shownStudent=to; drawManage(); scrollTo(0,to?0:classScroll);
 });
-/* Above the classes' tabs: every student of every class, each with the tutor's rank to tick. The rank is the student's
-   whatever class they are in: one who has it gets the flag under each score, and 🚩 beside their name in the lists. */
-let tutorsOpen=false;
-function drawTutors(){
-  const box=$("mTutors"), all=[...CLASS.students].sort((a,b)=>(a.name||a.email).localeCompare(b.name||b.email,"he"));
-  box.innerHTML=""; box.hidden=!all.length; if(!all.length) return;
-  const sec=part(box), said=mark("note","מי שמסומן רואה דגל 🚩 מתחת לכל ציון, ומדווח כשאמר נכון והמערכת טעתה. הדרגה חלה בכל הכיתות של התלמיד/ה.","p");
-  sec.open=tutorsOpen; sec.ontoggle=()=>{ tutorsOpen=sec.open; };
-  sec.firstChild.append(mark("","🚩 מדווחים על ציונים שגויים"),mark("",`${all.filter(s=>s.tutor).length} מתוך ${all.length} תלמידים`,"small"));
-  sec.append(said);
-  for(const s of all){
-    const row=document.createElement("label"), tick=document.createElement("input"), who=mark("",""), name=mark("",Object.values(s.classes).find(Boolean)||s.name||s.email,"b"), mail=document.createElement("bdi");
-    name.dir="auto"; mail.dir="ltr"; mail.textContent=s.email;
-    const more=mark("","","small"); more.append(mail,[...Object.keys(s.classes).map(c=>" · "+c),s.tutor_fixed?" · נקבע בהגדרות השרת":""].join(""));
-    who.append(name,more);
-    tick.type="checkbox"; tick.checked=!!s.tutor; tick.disabled=!!s.tutor_fixed;
-    tick.onchange=async()=>{
-      const on=tick.checked; tick.disabled=true;
-      try{
-        const res=await api("/api/tutors",{method:"PUT",headers:{"Content-Type":"application/json"},body:JSON.stringify({email:s.email,tutor:on})});
-        if(!res.ok) throw new Error((await res.json().catch(()=>({}))).detail||res.status);
-        s.tutor=on; drawManage();
-      }catch(err){ tick.checked=!on; tick.disabled=false; said.textContent="הדרגה לא נשמרה: "+err.message; }
-    };
-    row.append(tick,who); sec.append(row);
-  }
-}
 function drawTabs(classes){
   const tabs=$("mTabs"); tabs.innerHTML=""; tabs.hidden=!classes.length;
   const all=mark("tab","כל התלמידים","button"); all.setAttribute("role","tab"); all.setAttribute("aria-selected",shownClass==="*");
@@ -5263,7 +5300,7 @@ function drawHead(klass,students){   // the class's name and its figures; before
     }
     top.append(mark("","כל התלמידים","h2"),mark("","כל תלמיד מופיע פעם אחת. לבדיקת שיעורי בית והתקדמות מאז פתיחת כיתה, בחרו כיתה במסנן.","p"));
   }else{
-    top.append(mark("",klass.name,"h2"),mark("",lessonsLine(ALL_LESSONS.filter(l=>klass.lessons.includes(l.id))),"p"));
+    top.append(mark("",klass.name,"h2"),mark("",isMathClass(klass)?`מתמטיקה: ${unitsLine(klass.lessons)}. ההתקדמות במסלול המתמטיקה נשמרת בינתיים במכשיר של התלמיד, ולכן לא מופיעה כאן.`:lessonsLine(ALL_LESSONS.filter(l=>klass.lessons.includes(l.id))),"p"));
   }
   head.append(top);
   const tiles=mark("tiles",""), tile=(n,what)=>{ const t=mark("tile",""), b=mark("",n,"b"); b.dir="ltr"; t.append(b,mark("",what,"small")); tiles.append(t); };
@@ -5437,26 +5474,36 @@ function editTeacherChoices(){
 }
 function editClass(c){
   editing=c;
+  $("editTeachersField").hidden=!LIVE_TAB_ENABLED;
   editTeacherSet=new Set(c&&c.teachers||[]);
   $("editTitle").textContent=c?`עריכת ${c.name}`:"כיתה חדשה";
   $("editName").value=c?c.name:"";
+  // a math class picks units of the math path, and has no homework or daily videos; any other picks Arabic lessons
+  const math=isMathClass(c), lessonsBox=$("editLessons").closest("fieldset"), legend=lessonsBox.querySelector("legend"), note=legend.querySelector("small");
+  note.dataset.text??=note.textContent; legend.firstChild.textContent=math?"היחידות":"השיעורים";
+  note.textContent=math?"התלמידים של הכיתה רואים במסלול רק את המיומנויות של היחידות האלה.":note.dataset.text;
+  for(const box of [$("editHws").closest("fieldset"),$("editDailies").closest("fieldset")]) box.hidden=math;
   // the lessons by level: a level's box ticks all of it, its chips one lesson each; a new class starts with the first level
-  const pick=$("editLessons"), chosen=c?c.lessons:ALL_LESSONS.filter(l=>l.level===(ALL_LEVELS[0]||{}).id).map(l=>l.id);
+  const units=MATH_UNITS||[], groups=math?[{name:"מתמטיקה כיתה ט׳ · 5 יח״ל",items:units.map(u=>({id:u.id,label:u.name,title:`${u.count} מיומנויות`}))}]
+    :ALL_LEVELS.map(v=>({name:v.name,items:ALL_LESSONS.filter(l=>l.level===v.id).map(l=>({id:l.id,label:String(l.n),soon:l.soon,title:l.soon?`${l.name}: עוד לא מוכן, ייפתח לכיתה כשיהיה`:l.name}))}));
+  const pick=$("editLessons"), chosen=c?c.lessons:math?units.map(u=>u.id):ALL_LESSONS.filter(l=>l.level===(ALL_LEVELS[0]||{}).id).map(l=>l.id);
   pick.innerHTML="";
-  for(const v of ALL_LEVELS){
+  if(math&&!units.length) pick.append(mark("note","לא הצלחנו לטעון את יחידות המתמטיקה. לחצו „רענון” ונסו שוב.","p"));
+  const days=()=>{ if(!math) dailyRows($("editDailies"),editLevels(),editDays); };
+  for(const g of groups){
     const row=mark("lvl",""), head=mark("lvlhead","","label"), all=document.createElement("input"), chips=mark("chips",""), boxes=[];
-    all.type="checkbox"; head.append(all,v.name); row.append(head,chips); pick.append(row);
-    for(const l of ALL_LESSONS.filter(l=>l.level===v.id)){
-      const box=document.createElement("input"), lab=mark(l.soon?"soon":"","","label");
-      box.type="checkbox"; box.value=l.id; box.checked=chosen.includes(l.id); boxes.push(box);
-      lab.append(box,String(l.n)); lab.title=l.soon?`${l.name}: עוד לא מוכן, ייפתח לכיתה כשיהיה`:l.name; chips.append(lab);
+    all.type="checkbox"; head.append(all,g.name); row.append(head,chips); pick.append(row);
+    for(const it of g.items){
+      const box=document.createElement("input"), lab=mark(it.soon?"soon":"","","label");
+      box.type="checkbox"; box.value=it.id; box.checked=chosen.includes(it.id); boxes.push(box);
+      lab.append(box,it.label); lab.title=it.title; chips.append(lab);
     }
     const sync=()=>{ const n=boxes.filter(b=>b.checked).length; all.checked=n===boxes.length; all.indeterminate=n>0&&n<boxes.length; };
-    all.onchange=()=>{ boxes.forEach(b=>b.checked=all.checked); sync(); dailyRows($("editDailies"),editLevels(),editDays); };
-    boxes.forEach(b=>b.onchange=()=>{ sync(); dailyRows($("editDailies"),editLevels(),editDays); }); sync();
+    all.onchange=()=>{ boxes.forEach(b=>b.checked=all.checked); sync(); days(); };
+    boxes.forEach(b=>b.onchange=()=>{ sync(); days(); }); sync();
   }
-  editDays=Object.fromEntries((c&&c.dailies||[]).map(d=>[d.video,d.date])); dailyRows($("editDailies"),editLevels(),editDays);
-  $("editHws").replaceChildren(); for(const h of hwOf(c,ALL_CATS)) hwRow(h.c.id,h.due);
+  editDays=Object.fromEntries((c&&c.dailies||[]).map(d=>[d.video,d.date])); days();
+  $("editHws").replaceChildren(); if(!math) for(const h of hwOf(c,ALL_CATS)) hwRow(h.c.id,h.due);
   $("editEmails").value=c?c.emails.map(e=>[e,c.nicknames&&c.nicknames[e]].filter(Boolean).join(" ")).join("\n"):"";
   $("editSave").textContent=c?"שמירה":"פתיחת הכיתה"; $("editDelete").hidden=!c; $("editMsg").textContent="";
   countStudents(); editTeacherChoices(); $("editDlg").showModal(); (c?$("editEmails"):$("editName")).focus();
@@ -5498,12 +5545,14 @@ async function sendClass(method,body){
 }
 $("editForm").onsubmit=e=>{
   e.preventDefault();
-  const lessons=[...$("editLessons").querySelectorAll(".chips :checked")].map(b=>b.value);
-  if(!lessons.length){ $("editMsg").textContent="בחרו לפחות שיעור אחד."; return; }
+  const lessons=[...$("editLessons").querySelectorAll(".chips :checked")].map(b=>b.value), math=isMathClass(editing);
+  if(!lessons.length){ $("editMsg").textContent=math?"בחרו לפחות יחידה אחת.":"בחרו לפחות שיעור אחד."; return; }
+  const who={name:$("editName").value,emails:$("editEmails").value,...(LIVE_TAB_ENABLED?{teachers:[...editTeacherSet]}:{})};
+  if(math){ sendClass(editing?"PUT":"POST",{...who,lessons,...(editing?{}:{subject:MATH_LABEL})}); return; }
   const homeworks=hwRows();
   if(homeworks.some(h=>!lessons.includes((ALL_CATS.find(c=>c.id===h.topic)||{}).lesson))){ $("editMsg").textContent="שיעורי הבית הם נושאים משיעורי הכיתה: סמנו את השיעור שלהם למעלה, או הסירו אותם."; return; }
   if(new Set(homeworks.map(h=>h.topic)).size<homeworks.length){ $("editMsg").textContent="אותו נושא מופיע פעמיים בשיעורי הבית."; return; }
-  sendClass(editing?"PUT":"POST",{name:$("editName").value,emails:$("editEmails").value,teachers:[...editTeacherSet],lessons,homeworks,dailies:daysOf(editDays,editLevels())});
+  sendClass(editing?"PUT":"POST",{name:$("editName").value,emails:$("editEmails").value,...(LIVE_TAB_ENABLED?{teachers:[...editTeacherSet]}:{}),lessons,homeworks,dailies:daysOf(editDays,editLevels())});
 };
 $("editDelete").onclick=()=>{
   if(confirm(`למחוק את הכיתה ${editing.name}? התלמידים שלה לא יוכלו להיכנס עוד. ההקלטות וההתקדמות שלהם נשמרות.`)) sendClass("DELETE");
@@ -5511,17 +5560,25 @@ $("editDelete").onclick=()=>{
 
 /* A new class is opened in steps, a question each: its name, its level (the class studies the level's lessons), its
    students with their nicknames, its homework, and a summary to confirm, which says where all of it is changed later. */
-const WIZ=["שם הכיתה","רמה","תלמידים","שיעורי בית וסרטונים","אישור"], ADDRESS=/[^\s@,;<>]+@[^\s@,;<>]+\.[^\s@,;<>]+/g;
+const WIZ=["שם הכיתה","רמה","תלמידים","שיעורי בית וסרטונים","אישור"], WIZ_MATH=["שם הכיתה","יחידות","תלמידים","","אישור"], ADDRESS=/[^\s@,;<>]+@[^\s@,;<>]+\.[^\s@,;<>]+/g;
 let wiz=null;   // {step, students: [{email, name, on, nick}]}: the accounts the panel knows, and those added here
 const wizName=()=>$("newName").value.trim().replace(/\s+/g," ");
 const wizLevel=()=>ALL_LEVELS.find(v=>v.id===($("newLevels").querySelector(":checked")||{}).value)||ALL_LEVELS[0];
 const wizLessons=()=>ALL_LESSONS.filter(l=>l.level===wizLevel().id);
 const wizWho=s=>s.nick.trim()||s.name||s.email;
+const wizSteps=()=>wiz.math?[0,1,2,4]:[0,1,2,3,4];   // a math class has no homework or daily videos to set
+const wizUnits=()=>[...$("newLevels").querySelectorAll(":checked")].map(b=>b.value);
 function newClass(){
-  wiz={step:0,days:{},students:CLASS.students.map(s=>({email:s.email.toLowerCase(),name:s.name,on:false,nick:""}))};
+  wiz={step:0,days:{},math:isMathClass(null),students:CLASS.students.map(s=>({email:s.email.toLowerCase(),name:s.name,on:false,nick:""}))};
   $("newName").value=$("newEmail").value=$("newDue").value=""; $("newHw").innerHTML="";
-  const levels=$("newLevels"); levels.innerHTML="";
-  ALL_LEVELS.forEach((v,k)=>{
+  const levels=$("newLevels"), legend=levels.closest("fieldset").querySelector("legend"), note=legend.querySelector("small"); levels.innerHTML="";
+  note.dataset.text??=note.textContent; legend.firstChild.textContent=wiz.math?"אילו יחידות הכיתה לומדת?":"באיזו רמה הכיתה לומדת?";
+  note.textContent=wiz.math?"התלמידים יראו במסלול את המיומנויות של היחידות שסימנתם. אפשר לשנות אחר כך בעריכת הכיתה.":note.dataset.text;
+  if(wiz.math) for(const u of MATH_UNITS||[]){
+    const lab=document.createElement("label"), box=document.createElement("input"), text=document.createElement("span");
+    box.type="checkbox"; box.value=u.id; box.checked=true; text.append(u.name,mark("",`${u.count} מיומנויות`,"small")); lab.append(box,text); levels.append(lab);
+  }
+  else ALL_LEVELS.forEach((v,k)=>{
     const lab=document.createElement("label"), box=document.createElement("input"), text=document.createElement("span"), ls=ALL_LESSONS.filter(l=>l.level===v.id);
     box.type="radio"; box.name="newLevel"; box.value=v.id; box.checked=!k;
     text.append(v.name,mark("",`${lessonsWord(ls)} · ${ls.filter(l=>!l.soon).length} מוכנים`,"small")); lab.append(box,text); levels.append(lab);
@@ -5531,9 +5588,10 @@ function newClass(){
 function wizStep(n){
   wiz.step=n; $("newMsg").textContent="";
   [...$("newForm").querySelectorAll("section")].forEach((s,k)=>s.hidden=k!==n);
-  $("newStep").textContent=`שלב ${n+1} מתוך ${WIZ.length}: ${WIZ[n]}`;
-  $("newDots").replaceChildren(...WIZ.map((_,k)=>mark(k<=n?"on":"","","i")));
-  $("newBack").hidden=!n; $("newNext").textContent=n===WIZ.length-1?"פתיחת הכיתה":"המשך";
+  const order=wizSteps(), at=order.indexOf(n);
+  $("newStep").textContent=`שלב ${at+1} מתוך ${order.length}: ${(wiz.math?WIZ_MATH:WIZ)[n]}`;
+  $("newDots").replaceChildren(...order.map((_,k)=>mark(k<=at?"on":"","","i")));
+  $("newBack").hidden=!at; $("newNext").textContent=at===order.length-1?"פתיחת הכיתה":"המשך";
   if(n===3) wizHomework();
   if(n===4) wizSummary();
 }
@@ -5583,15 +5641,16 @@ function wizSummary(){
   const line=(what,...value)=>{ const dd=document.createElement("dd"); dd.append(...value); sum.append(mark("",what,"dt"),dd); };
   sum.innerHTML="";
   const name=document.createElement("bdi"); name.textContent=wizName(); line("שם",name);
-  line("רמה",`${level.name}, ${lessonsWord(wizLessons())}`);
+  if(wiz.math) line("יחידות",unitsLine(wizUnits()));
+  else line("רמה",`${level.name}, ${lessonsWord(wizLessons())}`);
   line("תלמידים",...(picked.length?[`${picked.length}: `,...picked.flatMap((s,k)=>{ const b=document.createElement("bdi"); b.textContent=wizWho(s); return k?[", ",b]:[b]; })]:["עוד אין. אפשר להוסיף אחר כך."]));
-  line("שיעורי בית",topic?[topic.name,ALL_LESSONS.find(l=>l.id===topic.lesson).name,dueText($("newDue").value).text].filter(Boolean).join(" · "):"אין בינתיים");
-  const days=daysOf(wiz.days,[level.id]); if(days.length) line("סרטונים יומיים",`${days.length} עם תאריך`);
+  if(!wiz.math) line("שיעורי בית",topic?[topic.name,ALL_LESSONS.find(l=>l.id===topic.lesson).name,dueText($("newDue").value).text].filter(Boolean).join(" · "):"אין בינתיים");
+  const days=wiz.math?[]:daysOf(wiz.days,[level.id]); if(days.length) line("סרטונים יומיים",`${days.length} עם תאריך`);
   const after=$("newAfter"); after.innerHTML="";
   after.append(mark("","מה קורה אחרי הפתיחה?","b"),"הכיתה מופיעה ברשימה תחת „כיתות”, והתלמידים שלה רואים את השיעורים במסלול. את ההתקדמות שלהם רואים תחת „תלמידים”. שום דבר כאן לא סופי: ליד כל כיתה ברשימה יש כפתור „עריכה”, שבו משנים את השם, השיעורים, התלמידים והכינויים ושיעורי הבית והתאריכים של הסרטונים היומיים, וכפתור „מחיקה”.");
   if(!CLASS.classes.length) after.append(mark("","שימו לב: זו הכיתה הראשונה. מרגע שהיא נפתחת, נכנסים לאפליקציה רק התלמידים שבכיתות והמורים.","b"));
 }
-$("newBack").onclick=()=>wizStep(wiz.step-1);
+$("newBack").onclick=()=>{ const order=wizSteps(); wizStep(order[order.indexOf(wiz.step)-1]); };
 $("newClose").onclick=()=>$("newDlg").close();
 $("newForm").onsubmit=async e=>{   // "next" checks the step on show; on the last one the class is opened
   e.preventDefault();
@@ -5600,14 +5659,16 @@ $("newForm").onsubmit=async e=>{   // "next" checks the step on show; on the las
     const taken=CLASS.classes.find(c=>c.name.replace(/\s+/g," ").trim().toLowerCase()===name.toLowerCase());
     if(!name||taken){ msg.textContent=name?`כבר יש כיתה בשם ${taken.name}. בחרו שם אחר.`:"כתבו שם לכיתה."; $("newName").focus(); return; }
   }
+  if(n===1&&wiz.math&&!wizUnits().length){ msg.textContent=MATH_UNITS?"סמנו לפחות יחידה אחת.":"לא הצלחנו לטעון את יחידות המתמטיקה. סגרו, לחצו „רענון” ונסו שוב."; return; }
   if(n===2&&!wizAdd()) return;   // an address still in the field joins too
-  if(n<WIZ.length-1){ wizStep(n+1); return; }
+  const order=wizSteps(); if(n!==order[order.length-1]){ wizStep(order[order.indexOf(n)+1]); return; }
   const homework=$("newHw").value, buttons=$("newForm").querySelectorAll("button");
   const emails=wiz.students.filter(s=>s.on).map(s=>`${s.email} ${s.nick.replace(/[\s@]+/g," ").trim()}`.trim()).join("\n");
   msg.textContent=""; buttons.forEach(b=>b.disabled=true);
   try{
     const res=await api("/api/classes",{method:"POST",headers:{"Content-Type":"application/json"},
-      body:JSON.stringify({name,emails,lessons:wizLessons().map(l=>l.id),homework,due:homework?$("newDue").value:"",dailies:daysOf(wiz.days,[wizLevel().id])})});
+      body:JSON.stringify(wiz.math?{name,emails,lessons:wizUnits(),subject:MATH_LABEL}
+        :{name,emails,lessons:wizLessons().map(l=>l.id),homework,due:homework?$("newDue").value:"",dailies:daysOf(wiz.days,[wizLevel().id])})});
     if(res.ok){ shownClass=name; store.set("ihki.mstudentClass",name); $("newDlg").close(); loadManage(); }
     else{
       const detail=(await res.json().catch(()=>({}))).detail||`הפתיחה נכשלה (${res.status})`;
@@ -6698,6 +6759,9 @@ if(AUTH_URL){
         const res=await Promise.race([api("/api/me").catch(()=>null),new Promise(r=>setTimeout(()=>r(null),10000))]);   // a session or server that hangs leaves the logo alone on the screen
         const ok=!res||res.status!==403;   // a server that cannot be reached is not a refusal
         const me=res&&res.ok?await res.json().catch(()=>({})):{}, teacher=!!me.teacher;
+        // an account belongs on its subject's pages (its class's, or an admin's own): a math student who opens "/" goes to /math
+        if(me.subject&&me.subject!==document.documentElement.dataset.subject){ location.replace(me.subject===document.documentElement.dataset.home?"/":"/"+me.subject); return; }
+        ME_SUBJECT=me.subject||"";
         ME_PERMISSIONS=new Set(me.permissions||[]); ME_ROLES=me.roles||[]; ME_ENTITLEMENTS=me.entitlements||[];
         $("nav").querySelector('[data-view=""]').hidden=!can("path.use");
         $("nav").querySelector('[data-view="verbs"]').hidden=!can("games.use");
@@ -6744,5 +6808,6 @@ if("serviceWorker" in navigator){
   addEventListener("load",()=>navigator.serviceWorker.register("/service-worker.js").catch(()=>{}));
 }
 </script>
+<script src="/static/math.js?v=__ASSET_V__" defer></script>
 </body>
 </html>

static/math.css

@@ -0,0 +1,139 @@
+/* The math path (static/math.js). Layout: one narrow column like the Arabic path: progress, "go on here", then each
+   unit's skills as a winding trail of circles; a skill opens in a bottom sheet. It sits over the Arabic page, which
+   stays loaded underneath. The math class is black in either system theme, as its opening screen is: the path sets
+   the app's colour tokens itself, with a blue accent and a colour per unit. */
+@import url("https://fonts.googleapis.com/css2?family=STIX+Two+Text:wght@400;600&display=swap");
+#mathView{
+  color-scheme:dark;
+  --bg:#000000; --surface:#121413; --ink:#F4F2EC; --muted:#9EA7A0; --line:#2C312E;
+  --ok:#6CC08A; --ok-bg:#12291B; --sumac:#F08A96; --sumac-bg:#33161B; --amber:#E0B45A; --amber-bg:#2E2512;
+  --olive:#A6C77A; --olive-soft:#1E2618;
+  --mx-accent:#7FA6F0; --mx-accent-soft:#18243A; --mx-on-accent:#06101F;
+  --u-f:#A3AD9F; --u-t:#93B85F; --u-n:#5CC2B2; --u-q:#6FB3D2; --u-p:#E0B45A; --u-w:#D98AAE;
+  --mx-scrim:rgb(0 0 0 / .7);
+  --f-math:"STIX Two Text","Cambria Math","Times New Roman",serif;
+}
+html.math-on, html.math-on body{overflow:hidden}
+#mathView{position:fixed;inset:0;z-index:60;overflow:auto;overscroll-behavior:contain;background:var(--bg);color:var(--ink);
+  padding-block:max(12px, env(safe-area-inset-top, 0px)) calc(32px + env(safe-area-inset-bottom, 0px));
+  padding-left:max(16px, env(safe-area-inset-left, 0px));padding-right:max(16px, env(safe-area-inset-right, 0px))}
+#mathView[hidden]{display:none}
+#mathView .u-f{--uc:var(--u-f)} #mathView .u-t{--uc:var(--u-t)} #mathView .u-n{--uc:var(--u-n)}
+#mathView .u-q{--uc:var(--u-q)} #mathView .u-p{--uc:var(--u-p)} #mathView .u-w{--uc:var(--u-w)}
+#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}
+#mathView .m{font-family:var(--f-math);direction:ltr;unicode-bidi:isolate;white-space:nowrap;font-size:1.05em}
+.mx-wrap{max-width:680px;margin:0 auto;display:flex;flex-direction:column;gap:16px}
+.mx-top{display:flex;justify-content:space-between;align-items:flex-start;gap:12px}
+.mx-top h1{font-size:28px;line-height:1.15;color:var(--mx-accent)}
+.mx-sub{margin:2px 0 0;color:var(--muted);font-size:15px}
+.mx-acts{display:flex;gap:6px;flex-wrap:wrap;justify-content:flex-end}
+.mx-btn{border:1px solid var(--mx-accent);background:transparent;color:var(--mx-accent);font:700 14px/1 var(--f-body);padding:9px 14px;border-radius:999px;cursor:pointer}
+.mx-btn.solid{background:var(--mx-accent);color:var(--mx-on-accent)}
+.mx-note{margin:0;color:var(--muted);font-size:14px}
+
+/* progress: a ring for the whole path, a bar per unit */
+.mx-progress{display:flex;gap:16px;align-items:center;background:var(--surface);border:1px solid var(--line);border-radius:16px;padding:14px}
+.mx-ring{flex:none;width:92px;height:92px;border-radius:50%;display:grid;place-content:center;text-align:center;
+  background:radial-gradient(closest-side,var(--surface) 78%,transparent 80%),conic-gradient(var(--mx-accent) calc(var(--p)*1%),var(--line) 0)}
+.mx-ring b{font:400 28px/1 var(--f-display);color:var(--mx-accent);font-variant-numeric:tabular-nums}
+.mx-ring small{font-size:12px;color:var(--muted)}
+.mx-units{flex:1;min-width:0;display:grid;grid-template-columns:repeat(3,minmax(0,1fr));gap:8px 12px}
+.mx-su{display:flex;flex-direction:column;gap:4px;min-width:0}
+.mx-su b{font-size:13px;white-space:nowrap;overflow:hidden;text-overflow:ellipsis}
+.mx-su small{font-size:12px;color:var(--muted);font-variant-numeric:tabular-nums}
+.mx-bar{height:6px;border-radius:3px;background:var(--line);overflow:hidden}
+.mx-bar i{display:block;height:100%;background:var(--uc)}
+@media (max-width:480px){.mx-progress{flex-direction:column;align-items:stretch}.mx-ring{align-self:center}.mx-units{grid-template-columns:repeat(2,minmax(0,1fr))}}
+
+.mx-next{display:flex;flex-direction:column;gap:2px;align-items:flex-start;text-align:start;border:0;border-radius:16px;padding:14px 16px;cursor:pointer;
+  background:var(--mx-accent);color:var(--mx-on-accent)}
+.mx-next small{font-size:13px;opacity:.85}
+.mx-next b{font-size:19px}
+
+/* the trail */
+.mx-unit{display:flex;flex-direction:column;gap:4px}
+.mx-uhead{display:flex;align-items:baseline;gap:4px 10px;flex-wrap:wrap;border-bottom:2px solid var(--uc);padding-bottom:6px}
+.mx-uhead h2{font-size:21px;color:var(--uc)}
+.mx-uhead span{font-size:13px;color:var(--muted)}
+.mx-trail{display:flex;flex-direction:column;gap:4px;padding-top:8px}
+.mx-node{display:flex;align-items:center;gap:12px;width:min(76%,330px);padding:6px 8px;border:0;border-radius:14px;background:none;color:inherit;text-align:start;cursor:pointer}
+.mx-node:hover{background:var(--surface)}
+.mx-trail .mx-node:nth-child(4n+2){margin-inline-start:12%}
+.mx-trail .mx-node:nth-child(4n+3){margin-inline-start:24%}
+.mx-trail .mx-node:nth-child(4n+4){margin-inline-start:12%}
+.mx-dot{flex:none;width:54px;height:54px;border-radius:50%;display:grid;place-items:center;background:var(--surface);border:3px solid var(--uc);color:var(--uc);font:400 20px/1 var(--f-display)}
+.mx-lbl{display:flex;flex-direction:column;gap:3px;min-width:0}
+.mx-lbl b{font-size:16px;line-height:1.25}
+.mx-lbl small{display:flex;gap:6px;flex-wrap:wrap}
+.st-done .mx-dot{background:var(--uc);color:var(--surface)}
+.st-locked .mx-dot{border-style:dashed;border-color:var(--line);color:var(--muted)}
+.st-locked .mx-lbl b{color:var(--muted)}
+.mx-node.here .mx-dot{box-shadow:0 0 0 5px var(--mx-accent-soft)}
+.mx-core,.mx-go{font:700 11px/1 var(--f-body);padding:4px 7px;border-radius:999px;white-space:nowrap}
+.mx-core{background:var(--olive-soft);color:var(--olive)}
+.mx-go{background:var(--mx-accent);color:var(--mx-on-accent)}
+
+/* a skill's sheet */
+.mx-layer[hidden]{display:none}
+.mx-scrim{position:fixed;inset:0;z-index:61;background:var(--mx-scrim)}
+.mx-sheet{position:fixed;inset:auto 0 0 0;z-index:62;max-height:88vh;overflow:auto;background:var(--surface);border-radius:20px 20px 0 0;
+  box-shadow:0 -6px 30px rgb(0 0 0/.2);display:flex;flex-direction:column;gap:14px;
+  padding-block:16px calc(24px + env(safe-area-inset-bottom, 0px));
+  padding-left:max(18px, env(safe-area-inset-left, 0px));padding-right:max(18px, env(safe-area-inset-right, 0px))}
+@media (min-width:720px){.mx-sheet{inset:auto calc(50% - 330px) 0 calc(50% - 330px)}}
+.mx-sheet>p{margin:0}
+.mx-shtop{display:flex;justify-content:space-between;gap:12px;align-items:flex-start}
+.mx-shtop h3{font-size:24px;line-height:1.2;margin-top:8px}
+.mx-uchip{display:inline-block;font:700 13px/1 var(--f-body);color:var(--uc);border:1px solid var(--uc);padding:5px 10px;border-radius:999px}
+.mx-src{display:block;color:var(--muted);font-size:13px;margin-top:4px}
+.mx-x{border:0;background:none;color:var(--muted);font-size:22px;line-height:1;padding:6px 10px;border-radius:8px;cursor:pointer}
+.mx-hint{background:var(--amber-bg);color:var(--ink);border-radius:12px;padding:10px 12px;font-size:15px;display:flex;flex-direction:column;gap:6px}
+.mx-q{background:var(--bg);border-radius:14px;padding:14px;display:flex;flex-direction:column;gap:10px}
+.mx-q>p{margin:0;font-size:19px}
+.mx-choices{display:grid;grid-template-columns:1fr 1fr;gap:8px}
+@media (max-width:420px){.mx-choices{grid-template-columns:1fr}}
+.mx-choices button{padding:12px;border-radius:12px;border:1px solid var(--line);background:var(--surface);color:var(--ink);font:600 17px/1.3 var(--f-body);cursor:pointer}
+.mx-choices button:hover{border-color:var(--mx-accent)}
+.mx-choices button.right{background:var(--ok-bg);border-color:var(--ok)}
+.mx-choices button.wrong{background:var(--sumac-bg);border-color:var(--sumac)}
+.mx-ok,.mx-bad{border-radius:12px;padding:12px;display:flex;flex-direction:column;gap:6px;align-items:flex-start}
+.mx-ok{background:var(--ok-bg);color:var(--ok)}
+.mx-bad{background:var(--sumac-bg)}
+.mx-bad b{color:var(--sumac)}
+.mx-small{font-size:13px;color:var(--muted)}
+.mx-sec h4{margin:0 0 6px;font:700 12px/1 var(--f-body);letter-spacing:.06em;color:var(--muted)}
+.mx-chips{display:flex;gap:6px;flex-wrap:wrap}
+.mx-chips em{font-style:normal;color:var(--muted);font-size:14px}
+.mx-chip{border:1px solid var(--uc);background:var(--bg);color:var(--ink);font:600 14px/1 var(--f-body);padding:7px 10px;border-radius:999px;cursor:pointer}
+.mx-chip.is-done{background:var(--uc);color:var(--surface)}
+.mx-plot{direction:ltr;align-self:center;width:100%;max-width:340px}
+.mx-plot svg{display:block;width:100%;height:auto}
+.mx-plot .g{stroke:var(--line);stroke-width:1}
+.mx-plot .a{stroke:var(--muted);stroke-width:1.5}
+.mx-plot .c{fill:none;stroke:var(--uc);stroke-width:2.5}
+.mx-plot circle{fill:var(--uc)}
+.mx-plot text{font:11px var(--f-body);fill:var(--muted)}
+/* a photographed problem */
+.mx-photo{display:flex;flex-direction:column;gap:3px;align-items:flex-start;text-align:start;border:1.5px dashed var(--mx-accent);border-radius:16px;
+  padding:14px 16px;background:transparent;color:var(--ink);cursor:pointer}
+.mx-photo b{font-size:18px;color:var(--mx-accent)}
+.mx-photo small{font-size:14px;color:var(--muted)}
+.mx-thumb{display:block;max-width:100%;max-height:180px;object-fit:contain;align-self:center;border-radius:10px;border:1px solid var(--line)}
+.mx-pbody{display:flex;flex-direction:column;gap:12px}
+.mx-wait{display:flex;flex-direction:column;align-items:center;gap:6px;padding:16px;text-align:center}
+.mx-wait small{color:var(--muted)}
+.mx-spin{width:26px;height:26px;border-radius:50%;border:3px solid var(--line);border-top-color:var(--mx-accent);animation:mx-spin 1s linear infinite}
+@keyframes mx-spin{to{transform:rotate(360deg)}}
+@media (prefers-reduced-motion:reduce){.mx-spin{animation:none}}
+.mx-read{background:var(--bg);border-radius:12px;padding:10px 12px;display:flex;flex-direction:column;gap:2px;align-items:flex-start}
+.mx-read small{color:var(--muted);font-size:13px}
+.mx-read p{margin:0;font-size:20px}
+.mx-link{border:0;background:none;padding:2px 0;color:var(--mx-accent);font:600 14px/1.3 var(--f-body);text-decoration:underline;text-underline-offset:3px;cursor:pointer}
+.mx-steps{margin:0;padding-inline-start:22px;display:flex;flex-direction:column;gap:10px}
+.mx-steps li{padding-inline-start:4px;line-height:1.5}
+.mx-steps li::marker{color:var(--mx-accent);font-weight:700}
+.mx-work{margin-top:6px;padding:8px 10px;border-radius:10px;background:var(--mx-accent-soft)}
+.mx-row{display:flex;gap:8px;flex-wrap:wrap}
+@media (prefers-reduced-motion:no-preference){.mx-sheet{animation:mx-up .22s ease-out}@keyframes mx-up{from{transform:translateY(30px);opacity:.4}}}

static/math.js

@@ -0,0 +1,265 @@
+/* The math path, on /math only: after the opening screen it takes the whole screen in place of the Arabic path.
+   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.
+   For now each skill has one sample question, and answering it right marks the skill done. Progress is kept on
+   this device, per account (ihki.math.v1:<email>), until the server keeps attempts. */
+(()=>{
+if(document.documentElement.dataset.subject!=="math") return;
+const css=document.createElement("link"); css.rel="stylesheet"; css.href=document.currentScript.src.replace("math.js","math.css");
+document.head.append(css);
+
+const esc=s=>String(s??"").replace(/[&<>"']/g,c=>({"&":"&amp;","<":"&lt;",">":"&gt;",'"':"&quot;","'":"&#39;"}[c]));
+const fmt=s=>esc(s).replace(/\$([^$]+)\$/g,'<span class="m">$1</span>');   // $…$ is math: set left to right
+const plain=s=>String(s).replace(/\$/g,"");
+// the model's text: as fmt, and a signed number it left outside $…$ is set left to right too, or its minus lands after it
+const fmtLoose=s=>String(s??"").split("$").map((part,i)=>i%2?`<span class="m">${esc(part)}</span>`
+  :esc(part).replace(/(^|[\s(־])([−-]\d+(?:[.,]\d+)?)/g,'$1<span class="m">$2</span>')).join("");
+const key=()=>"ihki.math.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;
+let picker=null, PH=null;   // the photo file picker, and the photographed problem on the sheet (see photo())
+
+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 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.
+const shownUnits=()=>{
+  const mine=typeof MY_CLASSES==="undefined"?[]:MY_CLASS?[MY_CLASS]:MY_CLASSES, ids=new Set(mine.flatMap(c=>c.lessons||[]));
+  const units=G.units.filter(u=>ids.has(u.id)); return units.length?units:G.units;
+};
+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;
+
+async function show(){
+  document.documentElement.classList.add("math-on");
+  if(!root){
+    root=document.createElement("section"); root.id="mathView"; root.setAttribute("aria-label","מסלול המתמטיקה");
+    path=document.createElement("div"); path.className="mx-wrap";
+    sheet=document.createElement("div"); sheet.className="mx-layer"; sheet.hidden=true;
+    // no capture attribute: the phone offers the camera and the gallery both
+    picker=document.createElement("input"); picker.type="file"; picker.accept="image/*"; picker.hidden=true;
+    picker.onchange=()=>{ const f=picker.files[0]; picker.value=""; if(f) photo(f); };
+    root.append(path,sheet,picker); document.body.append(root);
+    root.addEventListener("click",onClick);
+    document.addEventListener("keydown",e=>{ if(e.key==="Escape"&&cur) closeSheet(); });
+  }
+  root.hidden=false;
+  if(!G){
+    path.innerHTML='<p class="mx-note">טוענים את המסלול…</p>';
+    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)); draw();
+}
+function hide(){ if(root) root.hidden=true; document.documentElement.classList.remove("math-on"); }
+
+function draw(){
+  const UNITS=G.units.filter(u=>SHOWN.has(u.id)), mine=G.skills.filter(s=>SHOWN.has(s.unit));
+  const total=mine.length, doneN=mine.filter(s=>P.done[s.id]).length, nxt=next();
+  const cls=typeof MY_CLASS!=="undefined"&&MY_CLASS?` · כיתת ${esc(MY_CLASS.name)}`:"";
+  const manage=AUTH_URL&&can("management.access"), pct=Math.round(100*doneN/total);
+  const units=UNITS.map(u=>{
+    const ids=ORDER.filter(id=>BY[id].unit===u.id), d=ids.filter(id=>P.done[id]).length;
+    return `<div class="mx-su u-${u.id}"><b>${esc(u.name)}</b><span class="mx-bar"><i style="width:${Math.round(100*d/ids.length)}%"></i></span><small>${d} מתוך ${ids.length}</small></div>`;
+  }).join("");
+  const trail=UNITS.map(u=>{
+    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;
+        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>`;
+      }).join("")}</div></section>`;
+  }).join("");
+  path.innerHTML=`<header class="mx-top"><div><h1>המסלול שלי</h1><p class="mx-sub">אלגברה כיתה ט׳ · 5 יח״ל${cls}</p></div>
+      <div class="mx-acts">${manage?'<button class="mx-btn" data-act="manage">ניהול</button>':""}${AUTH_URL?'<button class="mx-btn" data-act="out">יציאה</button>':""}</div></header>
+    <section class="mx-progress" aria-label="ההתקדמות שלי">
+      <div class="mx-ring" style="--p:${pct}"><b>${doneN}</b><small>מתוך ${total}</small></div>
+      <div class="mx-units">${units}</div></section>
+    ${nxt?`<button class="mx-next" data-id="${nxt}"><small>ממשיכים מכאן</small><b>${fmt(BY[nxt].name)}</b></button>`:'<p class="mx-note">סיימתם את כל המסלול. כל הכבוד!</p>'}
+    <button class="mx-photo" data-act="photo"><b>צילום תרגיל</b><small>צלמו תרגיל מהמחברת או מהדף, ונעזור לכם לפתור אותו צעד אחר צעד</small></button>
+    ${trail}
+    <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>';
+}
+function open(id){
+  const s=BY[id], st=status(id), unit=G.units.find(u=>u.id===s.unit), rot=ORDER.indexOf(id)%s.sample.choices.length;
+  const choices=s.sample.choices.slice(rot).concat(s.sample.choices.slice(0,rot)), missing=s.prereqs.filter(p=>!P.done[p]&&SHOWN.has(BY[p].unit));
+  if(!cur) back=document.activeElement;
+  cur=id;
+  sheet.innerHTML=`<div class="mx-scrim" data-act="close"></div>
+    <div class="mx-sheet u-${s.unit}" role="dialog" aria-modal="true" aria-labelledby="mxTitle">
+      <div class="mx-shtop"><div><span class="mx-uchip">${esc(unit.name)}</span>${s.core?' <span class="mx-core">ליבה 5 יח״ל</span>':""}
+        <h3 id="mxTitle">${fmt(s.name)}</h3><small class="mx-src">${s.month?`בפריסה: ${esc(s.month)}`:esc(unit.source)}${st==="done"?" · הושלמה ✓":""}</small></div>
+        <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):""}
+        <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-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>
+    </div>`;
+  sheet.hidden=false; sheet.querySelector(".mx-sheet").scrollTop=0;
+  sheet.querySelector(".mx-x").focus({preventScroll:true});
+}
+function closeSheet(){ sheet.hidden=true; cur=null; back?.focus?.({preventScroll:true}); back=null; }
+
+function answer(btn){
+  const id=cur, m=btn.dataset.m, fb=sheet.querySelector(".mx-fb");
+  sheet.querySelectorAll("[data-choice]").forEach(b=>b.classList.remove("right","wrong"));
+  btn.classList.add(m?"wrong":"right");
+  P.tries[id]=(P.tries[id]||0)+1;
+  if(!m){
+    const first=!P.done[id]; P.done[id]=P.done[id]||new Date().toISOString(); save(); draw();
+    const nxt=next();
+    fb.innerHTML=`<div class="mx-ok"><b>נכון!</b>${first?"<span>המיומנות סומנה כהושלמה.</span>":""}
+      ${nxt&&nxt!==id?`<button class="mx-btn solid" data-id="${nxt}">למיומנות הבאה: ${esc(BY[nxt].short)}</button>`:""}</div>`;
+    return;
+  }
+  save();
+  const M=G.mistakes[m], to=M.back&&M.back!==id?M.back:null;
+  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>`;
+}
+
+function onClick(e){
+  const t=e.target.closest("button,[data-act]"); if(!t||!root.contains(t)) return;
+  if(t.dataset.choice!=null) return answer(t);
+  if(t.dataset.id) return open(t.dataset.id);
+  switch(t.dataset.act){
+    case "photo": case "retake": return picker.click();
+    case "hint": PH.shown++; return drawPhoto();
+    case "work": PH.works.add(+t.dataset.i); return drawPhoto();
+    case "all": PH.all=true; return drawPhoto();
+    case "close": return closeSheet();
+    case "manage": hide(); return showManage();
+    case "out": return document.getElementById("logoutBtn").click();
+  }
+}
+
+/* A photographed problem (/api/math/photo, app/math_photo.py): hints first. The sheet shows the problem as it was
+   read (a wrong reading is the student's cue to photograph again), then one hint; each further hint, each step and
+   the whole solution with its answer come only when the student asks for them. */
+async function shrink(file){   // a phone photo is several MB: about 1600 px on its long side is enough to read it
+  const bmp=await createImageBitmap(file,{imageOrientation:"from-image"}), k=Math.min(1,1600/Math.max(bmp.width,bmp.height));
+  const c=document.createElement("canvas"); c.width=Math.round(bmp.width*k); c.height=Math.round(bmp.height*k);
+  c.getContext("2d").drawImage(bmp,0,0,c.width,c.height); bmp.close?.();
+  return new Promise((ok,no)=>c.toBlob(b=>b?ok(b):no(new Error("toBlob")),"image/jpeg",.85));
+}
+async function photo(file){
+  let blob; try{ blob=await shrink(file); }catch{ blob=file; }   // a format the browser cannot draw goes as it is
+  if(PH?.url) URL.revokeObjectURL(PH.url);
+  if(cur!=="photo"){ if(!cur) back=document.activeElement; cur="photo"; }
+  const mine=PH={url:URL.createObjectURL(blob),data:null,error:"",busy:true,shown:1,works:new Set(),all:false,fresh:true};
+  drawPhoto();
+  try{
+    const form=new FormData(); form.append("photo",blob,"problem.jpg");
+    const res=await api("/api/math/photo",{method:"POST",body:form}), data=await res.json().catch(()=>({}));
+    if(!res.ok) throw new Error(typeof data.detail==="string"?data.detail:`השרת ענה ${res.status}`);
+    mine.data=data;
+  }catch(e){ mine.error=e.message; }
+  mine.busy=false;
+  if(PH===mine&&cur==="photo") drawPhoto();   // a newer photo, or a closed sheet, keeps its own
+}
+function drawPhoto(){
+  const d=PH.data;
+  let body;
+  if(PH.busy) body='<div class="mx-wait"><span class="mx-spin" aria-hidden="true"></span><b>קוראים את התרגיל ופותרים…</b><small>זה לוקח כמה שניות.</small></div>';
+  else if(PH.error) body=`<div class="mx-bad"><b>לא הצלחנו</b><span>${esc(PH.error)}</span><button class="mx-btn" data-act="retake">צילום מחדש</button></div>`;
+  else if(!d.readable) body=`<div class="mx-bad"><b>לא הצלחנו לקרוא את התרגיל</b><span>${fmtLoose(d.note||"צלמו שוב, קרוב יותר ובאור טוב.")}</span><button class="mx-btn" data-act="retake">צילום מחדש</button></div>`;
+  else{
+    const n=d.steps.length, shown=PH.all?n:Math.min(PH.shown,n);
+    body=`<div class="mx-read"><small>זה התרגיל שקראנו:</small><p>${fmtLoose(d.problem)}</p><button class="mx-link" data-act="retake">לא נכון? צלמו שוב</button></div>
+      ${d.note?`<p class="mx-small">${fmtLoose(d.note)}</p>`:""}
+      <ol class="mx-steps">${d.steps.slice(0,shown).map((s,i)=>`<li><span>${fmtLoose(s.hint)}</span>
+        ${PH.all||PH.works.has(i)?`<div class="mx-work">${fmtLoose(s.work)}</div>`:`<button class="mx-link" data-act="work" data-i="${i}">הראו את הצעד</button>`}</li>`).join("")}</ol>
+      ${PH.all?`<div class="mx-ok"><b>התשובה</b><span>${fmtLoose(d.answer)}</span></div>`:`<div class="mx-row">
+        ${shown<n?'<button class="mx-btn solid" data-act="hint">רמז הבא</button>':""}<button class="mx-btn" data-act="all">הפתרון המלא</button></div>`}
+      ${d.skill&&BY[d.skill]?`<div class="mx-sec"><h4>המיומנות שהתרגיל מתרגל</h4><div class="mx-chips">${chips([d.skill])}</div></div>`:""}
+      ${d.left!=null?`<p class="mx-small">נשארו לכם היום ${d.left} צילומים.</p>`:""}`;
+  }
+  sheet.innerHTML=`<div class="mx-scrim" data-act="close"></div>
+    <div class="mx-sheet" role="dialog" aria-modal="true" aria-labelledby="mxTitle">
+      <div class="mx-shtop"><div><h3 id="mxTitle">פתרון מתמונה</h3><small class="mx-src">קודם רמזים, והפתרון המלא כשתבקשו.</small></div>
+        <button class="mx-x" data-act="close" aria-label="סגירה">✕</button></div>
+      <img class="mx-thumb" src="${PH.url}" alt="התמונה ששלחתם">
+      <div class="mx-pbody" aria-live="polite">${body}</div></div>`;
+  sheet.hidden=false;
+  if(PH.fresh){ PH.fresh=false; sheet.querySelector(".mx-x").focus({preventScroll:true}); }
+}
+
+// a function's graph through the given points: monotone cubic (Fritsch-Carlson), so it never passes the marked extrema
+function plot(g){
+  const W=320, H=210, PAD=24, [x0,x1]=g.x, [y0,y1]=g.y;
+  const sx=x=>PAD+(x-x0)/(x1-x0)*(W-2*PAD), sy=y=>H-PAD-(y-y0)/(y1-y0)*(H-2*PAD);
+  const xs=g.points.map(p=>p[0]), ys=g.points.map(p=>p[1]), k=xs.length;
+  const d=xs.slice(0,-1).map((x,i)=>(ys[i+1]-ys[i])/(xs[i+1]-x));
+  const m=xs.map((_,i)=>i===0?d[0]:i===k-1?d[k-2]:d[i-1]*d[i]<=0?0:(d[i-1]+d[i])/2);
+  d.forEach((di,i)=>{ if(di===0){ m[i]=m[i+1]=0; return; } const a=m[i]/di, b=m[i+1]/di, s=a*a+b*b;
+    if(s>9){ const t=3/Math.sqrt(s); m[i]=t*a*di; m[i+1]=t*b*di; } });
+  let line="";
+  for(let i=0;i<k-1;i++){ const h=xs[i+1]-xs[i];
+    for(let j=0;j<=20;j++){ const t=j/20, t2=t*t, t3=t2*t;
+      const y=(2*t3-3*t2+1)*ys[i]+(t3-2*t2+t)*h*m[i]+(-2*t3+3*t2)*ys[i+1]+(t3-t2)*h*m[i+1];
+      line+=`${line?"L":"M"}${sx(xs[i]+t*h).toFixed(1)},${sy(y).toFixed(1)}`; } }
+  let grid="", ticks="";
+  for(let x=Math.ceil(x0);x<=x1;x++){ grid+=`<line class="g" x1="${sx(x)}" x2="${sx(x)}" y1="${sy(y0)}" y2="${sy(y1)}"/>`;
+    if(x) ticks+=`<text x="${sx(x)}" y="${Math.min(sy(0)+13,H-4)}" text-anchor="middle">${x}</text>`; }
+  for(let y=Math.ceil(y0);y<=y1;y++){ grid+=`<line class="g" x1="${sx(x0)}" x2="${sx(x1)}" y1="${sy(y)}" y2="${sy(y)}"/>`;
+    if(y) ticks+=`<text x="${Math.max(sx(0)-5,10)}" y="${sy(y)+4}" text-anchor="end">${y}</text>`; }
+  const dots=g.points.map(([x,y])=>`<circle cx="${sx(x)}" cy="${sy(y)}" r="3.5"/>`).join("");
+  return `<div class="mx-plot"><svg viewBox="0 0 ${W} ${H}" role="img" aria-label="גרף הפונקציה">${grid}
+    <line class="a" x1="${sx(x0)}" x2="${sx(x1)}" y1="${sy(0)}" y2="${sy(0)}"/><line class="a" x1="${sx(0)}" x2="${sx(0)}" y1="${sy(y0)}" y2="${sy(y1)}"/>
+    ${ticks}<path class="c" d="${line}"/>${dots}</svg></div>`;
+}
+
+// the start button (and a teacher's "תרגול") opens the math path once the opening screen is gone
+const arabicEnter=enter;
+const enterMath=()=>{ arabicEnter(); if(!AUTH_URL||can("path.use")) show(); };
+document.getElementById("startBtn").onclick=document.getElementById("practiceBtn").onclick=enterMath;
+
+// the manage panel: "לתרגול" goes to the math path, and "תוכן" lists the math path (units and their skills) in
+// place of the Arabic levels. The graph is a file in the repo (app/math_algebra9.json), so here it is only shown.
+const toPractice=document.getElementById("mPractice"), arabicPractice=toPractice.onclick;
+const practice=async id=>{ arabicPractice(); await show(); if(id&&G) open(id); };
+toPractice.onclick=()=>practice();
+const contentTab=document.querySelector('#mModes [data-mode="content"] small'); if(contentTab) contentTab.textContent="יחידות ומיומנויות";
+async function drawContent(){
+  const box=document.getElementById("mContent");
+  if(!G){
+    box.innerHTML='<p class="mx-note">טוענים את המסלול…</p>';
+    try{ const r=await fetch("/api/math/skills"); if(!r.ok) throw new Error(`השרת ענה ${r.status}`); index(await r.json()); }
+    catch(e){ box.innerHTML=`<p>לא הצלחנו לטעון את המסלול: ${esc(e.message)}. לחצו „רענון” ונסו שוב.</p>`; return; }
+  }
+  const wide=(()=>{ try{ return JSON.parse(localStorage.getItem("ihki.math.copen")||"{}"); }catch{ return {}; } })();
+  box.innerHTML=`<p class="sub">המסלול של כיתה ט׳, 5 יח״ל: ${G.skills.length} מיומנויות ב־${G.units.length} יחידות, לפי סדר המסלול. לכל מיומנות שאלה לדוגמה, וכל תשובה שגויה בה היא טעות מוכרת עם הסבר. ב„תרגול” רואים את השאלה כמו שהתלמידים רואים אותה.</p>`+
+    G.units.map(u=>{
+      const mine=ORDER.filter(id=>BY[id].unit===u.id).map(id=>BY[id]);
+      const rows=mine.map((s,k)=>{
+        const needs=s.prereqs.map(p=>plain(BY[p].short)).join(", "), wrong=s.sample.choices.filter(c=>!c.correct).length;
+        const meta=[needs?`דורשת: ${esc(needs)}`:"בלי דרישות קודמות",s.month?`בפריסה: ${esc(s.month)}`:"",s.core?"ליבה 5 יח״ל":"",`${wrong} טעויות מוכרות`].filter(Boolean).join(" · ");
+        return `<li class="crow"><i>${k+1}</i><div class="two"><b>${fmt(s.name)}</b><small>${meta}</small></div><div class="acts"><button class="btn" data-mxpractice="${s.id}">תרגול</button></div></li>`;
+      }).join("");
+      return `<details class="csec" data-unit="${u.id}"${wide[u.id]?" open":""}><summary class="clevel">${esc(u.name)}<small>${mine.length} מיומנויות${u.when?` · ${esc(u.when)}`:""}</small></summary>
+        <div class="card"><div class="chead"><h2>${esc(u.name)}<small>${esc(u.source||"")}</small></h2></div><ol class="clist">${rows}</ol></div></details>`;
+    }).join("");
+  box.querySelectorAll("details.csec").forEach(d=>d.ontoggle=()=>{ wide[d.dataset.unit]=d.open?1:0; try{ localStorage.setItem("ihki.math.copen",JSON.stringify(wide)); }catch{} });
+  box.querySelectorAll("[data-mxpractice]").forEach(b=>b.onclick=()=>practice(b.dataset.mxpractice));
+}
+window.drawContent=drawContent;
+})();

static/service-worker.js

@@ -1,4 +1,4 @@
-const CACHE = "ihki-shell-v17";
+const CACHE = "ihki-shell-v18";
 const SHELL = [
   "/static/manifest.webmanifest",
   "/static/icons/icon-192.png?v=2",

tests/test_live.py

@@ -43,3 +43,11 @@ def test_failed_recording_can_be_retried_and_end_erases_session():
     live.begin_answer(code, STUDENT["id"])
     live.end(code)
     assert live.get(code) is None
+
+
+def test_question_accepts_the_server_phrase_shape():
+    live = LiveStore()
+    code = live.start(COURSE, TEACHER)["code"]
+    question = live.ask(code, {"id": 13, "he": "מה שלומך?", "tr": "כִּיף חַאלַכּ?",
+                               "variants": [("كيف حالك؟", "kiːf ħaːlak")]})["question"]
+    assert question["ar"] == "كيف حالك؟"

tests/test_math_skills.py

@@ -0,0 +1,156 @@
+import copy
+
+from app.math_skills import algebra9, problems
+
+
+def test_the_algebra_graph_is_whole():
+    graph = algebra9()
+    assert problems(graph) == []
+    assert len(graph["skills"]) == 56 and {u["id"] for u in graph["units"]} == {"f", "t", "n", "q", "p", "w"}
+    # every unit opens somewhere a student can start: foundations need nothing
+    assert all(s["prereqs"] == [] for s in graph["skills"] if s["id"] in ("f_neg", "f_frac"))
+
+
+def test_a_broken_graph_is_named():
+    graph = algebra9()
+    skill = lambda g, sid: next(s for s in g["skills"] if s["id"] == sid)
+
+    g = copy.deepcopy(graph)
+    skill(g, "f_neg")["prereqs"] = ["f_ops"]   # f_ops needs f_neg
+    assert problems(g)[0].startswith("cycle:")
+
+    g = copy.deepcopy(graph)
+    skill(g, "f_ops")["prereqs"].append("f_neg_typo")
+    assert problems(g) == ["f_ops: unknown prerequisite f_neg_typo"]
+
+    g = copy.deepcopy(graph)
+    skill(g, "f_like")["prereqs"].append("f_neg")   # f_ops already brings it
+    assert problems(g) == ["f_like: f_neg is implied by f_ops"]
+
+    g = copy.deepcopy(graph)
+    skill(g, "f_neg")["sample"]["choices"][1] = {"text": "$−13$", "correct": True}
+    assert problems(g) == ["f_neg: needs exactly one correct choice"]
+
+    g = copy.deepcopy(graph)
+    g["mistakes"]["minus_minus"]["back"] = "t_ext"   # f_ops's mistake may not send it forward
+    assert "f_ops: mistake minus_minus sends back to t_ext, which is not before it" in problems(g)
+
+
+class FakeSolver:
+    def __init__(self, readable=True):
+        self.seen, self.readable = [], readable
+
+    def solve(self, image, media_type):
+        self.seen.append((image, media_type))
+        return {"readable": self.readable, "problem": "$x² = 9$", "steps": [{"hint": "h", "work": "w"}],
+                "answer": "$x = ±3$", "skill": "q_eq_simple", "note": ""}
+
+
+def photo_app(monkeypatch, auth=None):
+    from fastapi.testclient import TestClient
+    from app.main import create_app
+    from tests.test_scoring import emissions, scorer_for
+
+    monkeypatch.setenv("ANTHROPIC_API_KEY", "sk-test")
+    c = TestClient(create_app(scorer_for(emissions(["w"])), auth=auth))
+    c.__enter__()
+    c.app.state.photo, c.app.state.photo_key = FakeSolver(), "sk-test"
+    return c
+
+
+def test_a_photographed_problem_is_solved(monkeypatch):
+    c = photo_app(monkeypatch)
+    send = lambda data=b"jpeg", kind="image/jpeg": c.post("/api/math/photo", files={"photo": ("p.jpg", data, kind)})
+    r = send()
+    assert r.status_code == 200 and r.json()["answer"] == "$x = ±3$" and r.json()["left"] is None   # open service: no limit
+    assert c.app.state.photo.seen == [(b"jpeg", "image/jpeg")]
+    assert send(kind="application/pdf").status_code == 415 and send(data=b"").status_code == 400
+    assert send(data=b"x" * 5_000_001).status_code == 413 and len(c.app.state.photo.seen) == 1
+    monkeypatch.setenv("ANTHROPIC_API_KEY", "")   # no key: the feature says it is off
+    monkeypatch.delenv("CLAUDE_API_KEY", raising=False)
+    assert send().status_code == 503
+    c.__exit__(None, None, None)
+
+
+def test_a_student_has_a_daily_number_of_photos(monkeypatch):
+    import app.main as main
+
+    class Auth:
+        url, key, teachers, tutors, developers = "https://p.supabase.co", "k", frozenset(), frozenset(), frozenset()
+        def user(self, token): return {"id": "u1", "email": "s@b.c"} if token == "s" else None
+        def classes(self, fresh=False): return [{"id": 1, "name": "ט", "emails": ["s@b.c"], "nicknames": {}, "lessons": []}]
+        def ranked(self, fresh=False): return frozenset()
+        def __getattr__(self, name): return lambda *a, **k: []
+
+    monkeypatch.setattr(main, "DAILY_PHOTOS", 2)
+    c = photo_app(monkeypatch, Auth())
+    send = lambda: c.post("/api/math/photo", files={"photo": ("p.jpg", b"jpeg", "image/jpeg")}, headers={"Authorization": "Bearer s"})
+    assert c.post("/api/math/photo", files={"photo": ("p.jpg", b"jpeg", "image/jpeg")}).status_code == 401
+    c.app.state.photo.readable = False   # a photo it could not read does not count
+    assert send().json()["left"] == 2
+    c.app.state.photo.readable = True
+    assert [send().json()["left"], send().json()["left"]] == [1, 0] and send().status_code == 429
+    c.__exit__(None, None, None)
+
+
+def test_the_path_reads_the_graph():
+    from fastapi.testclient import TestClient
+    from app.main import create_app
+    from tests.test_scoring import emissions, scorer_for
+
+    with TestClient(create_app(scorer_for(emissions(["w"])))) as c:
+        r = c.get("/api/math/skills")
+        assert r.status_code == 200 and r.json() == algebra9()
+
+
+def test_a_math_class_studies_math_units():
+    from fastapi.testclient import TestClient
+    from app.main import create_app, ALL_LESSONS
+    from tests.test_scoring import emissions, scorer_for
+
+    class Auth:
+        url, key, teachers, tutors, developers = "https://p.supabase.co", "k", frozenset(), frozenset(), {"d@b.c"}
+        users_ = {t: {"id": i, "email": f"{t}@b.c", "name": t} for t, i in (("s", "u1"), ("m", "u2"), ("d", "u3"))}
+        def __init__(self): self.cls, self.saved = [], []
+        def user(self, token): return self.users_.get(token)
+        def users(self): return list(self.users_.values())
+        def classes(self, fresh=False): return self.cls
+        def access_for(self, user_id): return {"user_id": "u2", "roles": ["admin"], "subject": "מתמטיקה"} if user_id == "u2" else None
+        def access_rows(self): return [self.access_for("u2")]
+        def ranked(self, fresh=False): return frozenset()
+        def save_class(self, *args, **kw): self.saved.append(args)
+        def __getattr__(self, name): return lambda *a, **k: []
+
+    tok = lambda t: {"Authorization": f"Bearer {t}"}
+    with TestClient(create_app(scorer_for(emissions(["w"])), auth=Auth())) as c:
+        auth = c.app.state.auth
+        auth.cls = [{"id": 1, "name": "ט1", "emails": ["s@b.c"], "nicknames": {}, "lessons": ["q", "f"], "subject": "מתמטיקה"},
+                    {"id": 2, "name": "ערבית", "emails": [], "nicknames": {}, "lessons": [], "subject": "ערבית"}]
+        me = c.get("/api/me", headers=tok("s")).json()   # the student's path shows the class's units, in the path's order
+        assert me["classes"][0]["lessons"] == ["f", "q"] and me["lessons"] == []
+        listed = {k["name"]: k["lessons"] for k in c.get("/api/class", headers=tok("d")).json()["classes"]}
+        assert listed == {"ט1": ["f", "q"], "ערבית": ALL_LESSONS}
+        # the math admin opens a math class: units only, and no homework or daily videos even when sent
+        new = lambda body, who="m": c.post("/api/classes", json={"name": "ט2", "emails": "", **body}, headers=tok(who))
+        assert new({"lessons": [ALL_LESSONS[0]]}).status_code == 400
+        assert new({"lessons": ["t", "f"], "homeworks": [{"topic": "x", "due": ""}], "dailies": [{"video": 9, "date": "2026-01-01"}]}).status_code == 200
+        assert auth.saved[-1][4:] == (["f", "t"], [], None, "מתמטיקה")
+        # a developer has no subject: the page says which; an edit keeps the class's own
+        assert new({"lessons": ["n"], "subject": "מתמטיקה"}, "d").status_code == 200 and auth.saved[-1][4:] == (["n"], [], None, "מתמטיקה")
+        assert new({"lessons": ["n"], "subject": "חשבון"}, "d").status_code == 400   # no subject: Arabic lessons
+        assert c.put("/api/classes/1", json={"name": "ט1", "emails": "s@b.c", "lessons": ["w"]}, headers=tok("d")).status_code == 200
+        assert auth.saved[-1][4] == ["w"]
+
+
+def test_a_space_of_its_own_opens_on_its_subject(monkeypatch):
+    from fastapi.testclient import TestClient
+    from app.main import create_app
+    from tests.test_scoring import emissions, scorer_for
+
+    monkeypatch.setenv("HOME_SUBJECT", "math")   # mathly: "/" is the math app, and Arabic still has its own path
+    with TestClient(create_app(scorer_for(emissions(["w"])))) as c:
+        assert 'data-subject="math" data-home="math"' in c.get("/").text
+        assert 'data-subject="arabic" data-home="math"' in c.get("/arabic").text
+    monkeypatch.delenv("HOME_SUBJECT")
+    with TestClient(create_app(scorer_for(emissions(["w"])))) as c:
+        assert 'data-subject="arabic" data-home="arabic"' in c.get("/").text

tests/test_scoring.py

@@ -2113,3 +2113,72 @@ def test_each_class_topic_opens_on_its_own_screen():
         assert "__SUBJECT__" not in math and "__START_LABEL__" not in math
         assert c.get("/history").status_code == 404
         assert c.get("/static/logo-math.svg").status_code == 200
+        # its installed app has its own name, colour and start page; Arabic keeps the static manifest
+        assert '<meta name="theme-color" content="#000000">' in math and 'href="/math/manifest.webmanifest"' in math
+        assert '"__' not in math and '<meta name="theme-color" content="#4B6A2C">' in c.get("/").text
+        assert re.search(r'<script src="/static/math\.js\?v=[0-9a-f]{7}" defer>', math)   # the path's script, stamped
+        assert 'href="/static/manifest.webmanifest"' in c.get("/").text
+        installed = c.get("/math/manifest.webmanifest")
+        assert installed.headers["content-type"].startswith("application/manifest+json")
+        assert {k: installed.json()[k] for k in ("id", "name", "start_url", "scope")} == {
+            "id": "/math", "name": "מתמטיקה בכיף", "start_url": "/math", "scope": "/"}
+        assert c.get("/arabic/manifest.webmanifest").status_code == 404
+
+
+def test_an_account_is_sent_to_its_subjects_pages():
+    from fastapi.testclient import TestClient
+    from app.main import create_app, subject_code
+
+    assert subject_code("מתמטיקה") == "math" and subject_code(" ערבית ") == "arabic"
+    assert subject_code("חשבון") == subject_code("") == subject_code(None) == ""
+
+    class FakeAuth:
+        url, key, teachers, tutors, developers = "https://proj.supabase.co", "sb_publishable_x", frozenset(), frozenset(), {"d@b.c"}
+        users_ = {"s": {"id": "u1", "email": "s@b.c"}, "t": {"id": "u2", "email": "t@b.c", "name": "T"},
+                  "d": {"id": "u3", "email": "d@b.c"}}
+
+        def __init__(self):
+            self.cls, self.access = [], {"u2": {"user_id": "u2", "roles": ["admin"], "subject": "מתמטיקה"}}
+
+        def user(self, token):
+            return self.users_.get(token)
+
+        def users(self):
+            return list(self.users_.values())
+
+        def classes(self, fresh=False):
+            return self.cls
+
+        def access_for(self, user_id):
+            return self.access.get(user_id)
+
+        def access_rows(self):
+            return list(self.access.values())
+
+        def set_admin_subject(self, target, subject, actor):
+            self.access[target["id"]]["subject"] = subject
+
+        def ranked(self, fresh=False):
+            return frozenset()
+
+        def __getattr__(self, name):   # the content tables /api/me reads: empty
+            return lambda *a, **k: []
+
+    tok = lambda t: {"Authorization": f"Bearer {t}"}
+    with TestClient(create_app(scorer_for(emissions(["w"])), auth=FakeAuth())) as c:
+        auth = c.app.state.auth
+        auth.cls = [{"id": 1, "name": "ט1", "emails": ["s@b.c"], "nicknames": {}, "lessons": [], "subject": "מתמטיקה"}]
+        me = c.get("/api/me", headers=tok("s")).json()   # a student goes where their class is
+        assert me["subject"] == "math" and me["classes"][0]["subject"] == "math"
+        assert c.get("/api/me", headers=tok("t")).json()["subject"] == "math"   # an admin, where their own subject is
+        assert "subject" not in c.get("/api/me", headers=tok("d")).json()   # a developer stays on the page they opened
+        auth.cls[0]["subject"] = "חשבון"   # a subject outside the list sends nowhere
+        assert "subject" not in c.get("/api/me", headers=tok("s")).json()
+        # the developer picks an admin's subject from the list; free text is refused
+        listed = c.get("/api/admin-subjects", headers=tok("d")).json()
+        assert listed["subjects"] == [{"code": "arabic", "label": "ערבית"}, {"code": "math", "label": "מתמטיקה"}]
+        assert listed["admins"] == [{"id": "u2", "email": "t@b.c", "name": "T", "subject": "מתמטיקה"}]
+        put = lambda subject: c.put("/api/admin-subjects/u2", json={"subject": subject}, headers=tok("d"))
+        assert put("חשבון").status_code == 400 and auth.access["u2"]["subject"] == "מתמטיקה"
+        assert put(" ערבית ").json() == {"ok": True, "subject": "ערבית"} and auth.access["u2"]["subject"] == "ערבית"
+        assert c.get("/api/me", headers=tok("t")).json()["subject"] == "arabic"