Add unit tests for pronunciation rules parsing and detection

- Implement tests to ensure all YAML blocks in pronunciation-rules.md are parsed correctly into rules.
- Verify that every heard symbol has a corresponding Hebrew label.
- Check correct realizations per letter and dialect associations.
- Report undetectable rules and validate their detection status.

app/align.py

@@ -71,8 +71,12 @@ class TokenScore:
     score: float      # 0..100
     gop: float        # log ratio target vs strongest competitor, <= 0
     peak: float       # max log-posterior of the target inside its window
-    competitor: int | None  # strongest non-target, non-blank token in the window
+    competitor: int | None  # strongest non-target, non-blank token in the window (None: nothing, or a sound we do not name)
     deleted: bool     # target barely present and nothing else either
+    realised: int | None = None  # a class target (several correct realisations): the one said
+    other: bool = False          # the strongest competitor is a sound outside the named set
+    comp_peak: float = NEG       # max log-posterior of the strongest competitor (named or not) in the window
+    window: tuple[int, int] = (0, 0)  # [start, end) frames the target and its competitors were read from
 
 
 @dataclass
@@ -86,14 +90,20 @@ class GopConfig:
 
 
 def score_tokens(logp: np.ndarray, align: Alignment, tokens: list[int], blank: int,
-                 cfg: GopConfig = GopConfig()) -> list[TokenScore]:
+                 cfg: GopConfig = GopConfig(), accept: list[set[int] | None] | None = None,
+                 n_real: int | None = None, named: set[int] | None = None) -> list[TokenScore]:
     """Per-token GOP.
 
     The window of token i runs from the end of token i-1 to the start of token i+1, so it covers
     the blank frames around the emission where a substituted phoneme typically peaks.
     The neighbours' own labels are excluded from the competitor set (coarticulation is not an error).
+
+    A class token (a virtual column pooling its correct realisations, `accept[i]` their ids) is scored on the
+    pooled column; its members are not competitors. Competitors come from the first `n_real` columns only, and
+    one outside `named` is reported as `other` rather than by name.
     """
     T = logp.shape[0]
+    accept = accept or [None] * len(tokens)
     out: list[TokenScore] = []
     for i, tok in enumerate(tokens):
         a = align.spans[i - 1][1] if i > 0 else 0
@@ -101,13 +111,16 @@ def score_tokens(logp: np.ndarray, align: Alignment, tokens: list[int], blank: i
         a, b = min(a, align.spans[i][0]), max(b, align.spans[i][1])
         seg = logp[a:b]
         peak = float(seg[:, tok].max())
+        members = accept[i] or set()
+        realised = max(members, key=lambda m: seg[:, m].max()) if members else None
 
-        masked = seg.max(0).copy()
+        masked = (seg[:, :n_real] if n_real else seg).max(0).copy()
         masked[blank] = NEG
-        masked[tok] = NEG
-        for j in (i - 1, i + 1):
+        for j in (i - 1, i, i + 1):
             if 0 <= j < len(tokens):
-                masked[tokens[j]] = NEG
+                for x in {tokens[j], *(accept[j] or ())}:
+                    if x < len(masked):
+                        masked[x] = NEG
         comp = int(masked.argmax())
         comp_peak = float(masked[comp])
 
@@ -115,8 +128,11 @@ def score_tokens(logp: np.ndarray, align: Alignment, tokens: list[int], blank: i
         deleted = bool(peak < cfg.deleted_peak and comp_peak < cfg.deleted_comp)
         confidence = min(1.0, float(np.exp(peak)) / cfg.confident_peak)
         score = 100.0 * float(np.exp(gop * cfg.leniency)) * float(np.sqrt(confidence))
+        present = comp_peak > NEG / 2
+        other = bool(present and named is not None and comp not in named)
         out.append(TokenScore(round(score, 1), round(gop, 3), round(peak, 3),
-                              comp if comp_peak > NEG / 2 else None, deleted))
+                              comp if present and not other else None, deleted, realised, other,
+                              round(comp_peak, 3), (int(a), int(b))))
     return out
 
 
@@ -131,10 +147,11 @@ def greedy_decode(logp: np.ndarray, blank: int) -> list[int]:
     return out
 
 
-def edit_distance(a: list, b: list) -> int:
+def edit_distance(a: list, b: list, same=None) -> int:
+    same = same or (lambda x, y: x == y)
     d = list(range(len(b) + 1))
     for i, x in enumerate(a, 1):
         prev, d[0] = d[0], i
         for j, y in enumerate(b, 1):
-            prev, d[j] = d[j], min(d[j] + 1, d[j - 1] + 1, prev + (x != y))
+            prev, d[j] = d[j], min(d[j] + 1, d[j - 1] + 1, prev + (not same(x, y)))
     return d[len(b)]

app/archi.py

@@ -0,0 +1,181 @@
+"""Abstract symbols for letters with more than one correct pronunciation (section 5 of pronunciation-rules.md).
+
+phrases.py writes the realisation its author chose (ق as ʔ in قديش, q in القدس). The scorer must accept
+the others too (kaddeesh is rural Palestinian), so before tokenising, archify() rewrites each phoneme that
+comes from such a letter as "SYMBOL:written" (Q:ʔ), and tokenize() scores it against every correct
+realisation at once. The written phoneme is kept for display, tips and calibration keys.
+
+The letter behind a phoneme is found by aligning the Arabic letters of the word with its IPA consonants.
+A phrase can also write a symbol itself: "Q", "Q:k", or with its own set of realisations, "TH{t,s}".
+"""
+from __future__ import annotations
+
+import re
+from functools import lru_cache
+
+from .phones import base
+
+# letter -> the symbol its phoneme is rewritten to
+LETTER_SYMBOL = {"ق": "Q", "ك": "K", "ث": "TH", "ذ": "DH", "ظ": "ZH", "ج": "J"}
+
+# letter -> base() names of the phonemes it is said as in the phrase bank (dialects, MSA, careless spelling)
+_LETTERS = {
+    "ب": {"b"}, "ت": {"t"}, "ث": {"t", "s", "θ"}, "ج": {"dʒ", "g"}, "ح": {"ħ"}, "خ": {"x"}, "د": {"d"},
+    "ذ": {"d", "z", "ð"}, "ر": {"r"}, "ز": {"z"}, "س": {"s"}, "ش": {"ʃ"}, "ص": {"sˤ", "s"}, "ض": {"dˤ", "d"},
+    "ط": {"tˤ", "t"}, "ظ": {"ðˤ", "dˤ", "zˤ", "z", "ð"}, "ع": {"ʕ"}, "غ": {"ɣ"}, "ف": {"f"}, "ق": {"ʔ", "q", "k", "g"},
+    "ك": {"k", "tʃ"}, "ل": {"l"}, "م": {"m"}, "ن": {"n"}, "ه": {"h"}, "و": {"w"}, "ي": {"j"}, "ى": set(),
+    "ء": {"ʔ"}, "أ": {"ʔ"}, "إ": {"ʔ"}, "آ": {"ʔ"}, "ؤ": {"ʔ"}, "ئ": {"ʔ"}, "ا": {"ʔ"}, "ة": {"t"},
+}
+# letters that are often not said as a consonant at all (vowel letters, hamza seats, the article's ل): cheap to skip
+_WEAK = set("اوىيةهءأإآؤئل")
+_VOWELS = {"a", "i", "u", "e", "o", "ə"}
+
+_TOKEN = re.compile(r"^([A-Z]+)(?:\{([^}]*)\})?(?::(.+))?$")
+
+
+def split_token(tok: str) -> tuple[str | None, list[str] | None, str]:
+    """"Q:ʔ" -> ("Q", None, "ʔ"); "TH{t,s}" -> ("TH", ["t", "s"], "t"); "ʕ" -> (None, None, "ʕ").
+
+    The phoneme of a symbol written without one is its first listed realisation, or "" (the caller picks)."""
+    m = _TOKEN.match(tok)
+    if not m:
+        return None, None, tok
+    sym, members, written = m.group(1), m.group(2), m.group(3)
+    members = [p.strip() for p in members.split(",") if p.strip()] if members else None
+    return sym, members, written or (members[0] if members else "")
+
+
+def written(tok: str) -> str:
+    """The phoneme a token is written as in the phrase (Q:ʔ -> ʔ)."""
+    return split_token(tok)[2] or tok
+
+
+def _letters(ar_word: str) -> list[str]:
+    return [c for c in ar_word if c in _LETTERS]
+
+
+def _units(phs: list[str]) -> list[tuple[str, list[int]]]:
+    """The consonants of an IPA word, a geminate run as one unit: (base name, its positions)."""
+    out: list[tuple[str, list[int]]] = []
+    for i, ph in enumerate(phs):
+        b = base(ph)
+        if b in _VOWELS:
+            continue
+        if out and out[-1][0] == b and out[-1][1][-1] == i - 1:
+            out[-1][1].append(i)
+        else:
+            out.append((b, [i]))
+    return out
+
+
+_SKIP_LETTER, _SKIP_WEAK, _SKIP_UNIT, _MISMATCH = 1.0, 0.3, 1.0, 1.6
+
+
+def _align(letters: list[str], units: list[str]) -> tuple[dict[int, set[int]], float]:
+    """For each letter, the units it matches on some cheapest alignment of letters to consonants.
+
+    A letter matched to different units on two cheapest alignments (or matched on one and skipped on
+    another) is ambiguous; the caller leaves it alone."""
+    n, m = len(letters), len(units)
+    inf = float("inf")
+
+    def cost(i, j):
+        return 0.0 if units[j] in _LETTERS[letters[i]] else _MISMATCH
+
+    def skip(i):
+        return _SKIP_WEAK if letters[i] in _WEAK else _SKIP_LETTER
+
+    f = [[inf] * (m + 1) for _ in range(n + 1)]
+    f[0][0] = 0.0
+    for i in range(n + 1):
+        for j in range(m + 1):
+            if i < n:
+                f[i + 1][j] = min(f[i + 1][j], f[i][j] + skip(i))
+            if j < m:
+                f[i][j + 1] = min(f[i][j + 1], f[i][j] + _SKIP_UNIT)
+            if i < n and j < m:
+                f[i + 1][j + 1] = min(f[i + 1][j + 1], f[i][j] + cost(i, j))
+    b = [[inf] * (m + 1) for _ in range(n + 1)]
+    b[n][m] = 0.0
+    for i in range(n, -1, -1):
+        for j in range(m, -1, -1):
+            if i < n:
+                b[i][j] = min(b[i][j], b[i + 1][j] + skip(i))
+            if j < m:
+                b[i][j] = min(b[i][j], b[i][j + 1] + _SKIP_UNIT)
+            if i < n and j < m:
+                b[i][j] = min(b[i][j], b[i + 1][j + 1] + cost(i, j))
+    best, eps = f[n][m], 1e-9
+    matched: dict[int, set[int]] = {}
+    for i in range(n):
+        for j in range(m):
+            if cost(i, j) == 0.0 and abs(f[i][j] + b[i + 1][j + 1] - best) < eps:
+                matched.setdefault(i, set()).add(j)
+        # skipping letter i on a cheapest alignment
+        if any(abs(f[i][j] + skip(i) + b[i + 1][j] - best) < eps for j in range(m + 1)):
+            matched.setdefault(i, set()).add(-1)
+    return matched, best
+
+
+def archify_word(ipa_word: str, ar_word: str) -> tuple[str, list[str]]:
+    """One word: its IPA with symbol tokens, and the letters that could not be placed (ambiguous)."""
+    phs = ipa_word.split()
+    if any(split_token(p)[0] for p in phs):
+        return ipa_word, []      # the phrase writes its symbols itself
+    letters, units = _letters(ar_word), _units(phs)
+    matched, _ = _align(letters, [u for u, _ in units])
+    out, unresolved = list(phs), []
+    for i, letter in enumerate(letters):
+        sym = LETTER_SYMBOL.get(letter)
+        if sym is None:
+            continue
+        hits = matched.get(i, {-1})
+        if len(hits) != 1:
+            unresolved.append(letter)
+            continue
+        j = next(iter(hits))
+        if j < 0:
+            continue              # not said at all (a dropped ق): nothing to rewrite
+        for k in units[j][1]:
+            out[k] = f"{sym}:{phs[k]}"
+    # the vowel of a final ة (and ه written for it): a, e and i are all correct (section 6.3 #5)
+    if (out and ar_word.endswith(("ة", "ه")) and "لله" not in ar_word
+            and base(out[-1]) in {"a", "e", "i"} and len(out) > 1):
+        out[-1] = f"E:{out[-1]}"
+    return " ".join(out), unresolved
+
+
+@lru_cache(maxsize=32768)  # the whole phrase bank (~12k variants) and the verb game's forms
+def archify(ar: str, ipa: str) -> str:
+    """The variant's IPA with each phoneme of a many-ways letter rewritten as its symbol (see the module doc).
+
+    A variant whose Arabic and IPA word counts differ is returned as it is."""
+    ipa_words, ar_words = ipa.split("|"), ar.split()
+    if len(ipa_words) != len(ar_words):
+        return ipa
+    return " | ".join(archify_word(w.strip(), a)[0] for w, a in zip(ipa_words, ar_words))
+
+
+def unresolved(ar: str, ipa: str) -> list[tuple[str, str]]:
+    """(Arabic word, letter) for every many-ways letter archify() could not place: the phrase must mark it."""
+    ipa_words, ar_words = ipa.split("|"), ar.split()
+    if len(ipa_words) != len(ar_words):
+        return []
+    return [(a, letter) for w, a in zip(ipa_words, ar_words) for letter in archify_word(w.strip(), a)[1]]
+
+
+def diphthong_variants(ar: str, ipa: str) -> list[str]:
+    """The same variant with eː said as a j and oː as a w where the Arabic writes ي / و (section 6.3 #8).
+
+    A diphthong is two tokens against one, so it is a variant of its own rather than a class."""
+    ipa_words, ar_words = ipa.split("|"), ar.split()
+    if len(ipa_words) != len(ar_words):
+        return []
+    out = []
+    for long, glide, letter in (("eː", "j", "ي"), ("oː", "w", "و")):
+        words = [" ".join(f"a {glide}" if ph == long and letter in a else ph for ph in w.split())
+                 for w, a in zip(ipa_words, ar_words)]
+        new = " | ".join(words)
+        if new != " | ".join(w.strip() for w in ipa_words):
+            out.append(new)
+    return out

app/main.py

@@ -32,6 +32,7 @@ from .auth import AuthUnavailable, ClassConflict, SupabaseAuth, load_auth
 from .phrases import CATEGORIES, GAMES, LESSONS, LEVELS, PHRASES, public_phrases
 from .prompt_tts import ENGINES, PromptTTSUnavailable, hebrew_mp3
 from .reference import References
+from .rules import check_detectable
 from .scorer import Scorer, decode_audio, load_scorer
 from .speech_evaluation import SpeechEvaluationService
 from .texts import read_line, text_phrases
@@ -1169,7 +1170,10 @@ def create_app(scorer: Scorer | None = None, tts: SawtakTTS | None = None,
         s: Scorer = app.state.scorer
         return {"version": build_version(), "build": build_metadata(), "model": MODEL_ID, "tts": app.state.tts is not None,
                 "references": app.state.refs is not None, "sign_in": app.state.auth is not None,
-                "phoneme_fallbacks": s.vocab.downgraded}
+                "phoneme_fallbacks": s.vocab.downgraded,
+                # per rule of pronunciation-rules.md: can this model catch it at all (and if not, why)
+                "rules": check_detectable(s.rules, lambda ph: s.vocab.sound_id(ph) is not None, s.vocab.model_id),
+                "dialect_realisations_missing": {k: sorted(v) for k, v in s.vocab.class_missing.items()}}
 
     @app.get("/api/tts/{phrase_id}", dependencies=members)
     def tts_phrase(phrase_id: int, voice: str = Query("", max_length=64)):

app/phones.py

@@ -0,0 +1,17 @@
+"""The sound a model symbol stands for.
+
+The model's vocab is multilingual (392 symbols) and spells one sound several ways: t / t̪ / tʰ / tː,
+r / ɾ, a / æ / ɐ, x / χ. Left alone, a correctly said t loses to its own spelling variant t̪.
+base() names the sound a symbol stands for; Vocab.merge() (scorer.py) pools the posteriors of each sound,
+and rules.py writes its rules in the same names.
+"""
+_STRIP = set("ːʰʲ.^[:\"̪̩̝̞̊̃")  # length, aspiration, palatalisation, dental, syllabic, nasal ...
+_SAME = {"æ": "a", "ɐ": "a", "ɑ": "a", "ä": "a", "ʌ": "a", "ɪ": "i", "ʊ": "u", "ɛ": "e", "ɔ": "o",
+         "ɾ": "r", "ɫ": "l", "ɡ": "g", "χ": "x", "ʁ": "ɣ", "ʒ": "dʒ", "dZ": "dʒ", "tS": "tʃ", "S": "ʃ",
+         "d͡ʒ": "dʒ", "t͡ʃ": "tʃ", "t͡s": "ts"}
+
+
+def base(symbol: str) -> str:
+    """The sound a model symbol stands for, ignoring length and spelling variants. Emphatics stay distinct."""
+    s = "".join(c for c in symbol if c not in _STRIP)
+    return _SAME.get(s, s) or symbol

app/rules.py

@@ -0,0 +1,237 @@
+"""Pronunciation rules for Hebrew-speaking learners, read from the yaml blocks of pronunciation-rules.md.
+
+The document is written for two audiences: its student sections are served as a guide, and its scorer
+sections (the ```yaml blocks) say what the scorer accepts and how it judges errors:
+
+  archiphonemes   letters said differently in the urban and the rural dialect, and their correct realisations
+  checks          per rule: (target, heard) -> severity and the Hebrew feedback
+  scoring         margins per (target, heard) pair, max_tips, ...
+  heard_labels    the Hebrew name of every heard symbol
+
+Every symbol is stored by its base() name (phones.py), the names the scorer compares in, so a rule written
+with ʁ matches a model that heard ɣ. check_detectable() tells which rules a model can catch at all.
+"""
+from __future__ import annotations
+
+import re
+from dataclasses import dataclass, field
+from functools import lru_cache
+from pathlib import Path
+from typing import Callable
+
+import yaml
+
+from .phones import base
+
+RULES_PATH = Path(__file__).resolve().parent.parent / "static" / "assets" / "pronunciation-rules.md"
+
+# Realisations correct only in learned words (ثقافة as saqaafe): accepted where the phrase writes them, not elsewhere.
+LEARNED_ONLY = {"TH": {"s"}, "DH": {"z"}}
+# Classes set by position, not by letter (section 6.3 #5 and #6): the vowel of a final ة, the vowel of a pronoun ending.
+POSITIONAL = {"E": ["a", "e", "i"], "O": ["o", "u"]}
+
+
+def norm(symbol: str) -> str:
+    """A rule symbol in the scorer's names. "_" (nothing heard) and the abstract symbols stay as they are."""
+    return symbol if symbol == "_" or symbol.isupper() else base(symbol)
+
+
+@dataclass(frozen=True)
+class Check:
+    rule: str
+    target: str
+    heard: str
+    severity: int
+    feedback: str
+
+
+@dataclass
+class Rules:
+    archiphonemes: dict[str, dict[str, list[str]]]
+    dialects: list[str]
+    optional: bool
+    scoring: dict
+    checks: dict[tuple[str, str], Check]
+    titles: dict[str, str]                       # rule id -> title
+    heard_labels: dict[str, str]
+    margins: dict[tuple[str, str], float] = field(default_factory=dict)
+
+    def members(self, symbol: str, written: str | None = None) -> list[str]:
+        """The correct realisations of an abstract symbol, in base() names, first the dialects' own.
+
+        A learned-only realisation (TH as s) counts only when the phrase writes it (`written`)."""
+        if symbol in POSITIONAL:
+            return list(POSITIONAL[symbol])
+        spec = self.archiphonemes.get(symbol)
+        if spec is None:
+            return []
+        out: list[str] = []
+        keys = [*self.dialects, "also_ok", *(["optional"] if self.optional else [])]
+        for key in keys:
+            for ph in spec.get(key, []):
+                ph = base(ph)
+                if ph not in out and (ph not in LEARNED_ONLY.get(symbol, ()) or ph == written):
+                    out.append(ph)
+        return out
+
+    def dialects_of(self, symbol: str, phone: str) -> set[str]:
+        """The dialects in which `phone` is a correct realisation of `symbol` (empty: in none, or not dialectal)."""
+        spec = self.archiphonemes.get(symbol, {})
+        return {d for d in ("urban", "rural") if phone in {base(p) for p in spec.get(d, [])}}
+
+    def check(self, targets: str | list[str], heard: str | None) -> Check | None:
+        """The rule for hearing `heard` instead of the target: the first of `targets` that has one."""
+        if not heard:
+            return None
+        for t in [targets] if isinstance(targets, str) else targets:
+            c = self.checks.get((norm(t), norm(heard)))
+            if c is not None:
+                return c
+        return None
+
+    def margin(self, targets: str | list[str], heard: str | None) -> float:
+        """How much likelier than the target `heard` must be before it is a mistake (natural log). The first
+        of `targets` (the abstract symbol, then the written phoneme) with a margin of its own decides."""
+        default = float(self.scoring.get("margin_default", 0.0))
+        for t in [targets] if isinstance(targets, str) else targets:
+            m = self.margins.get((norm(t), norm(heard or "_")))
+            if m is not None:
+                return m
+        return default
+
+    def label(self, heard: str | None) -> str | None:
+        """The Hebrew name of a heard symbol, as section 8 gives it."""
+        if heard is None:
+            return None
+        return self.heard_labels.get(heard) or self.heard_labels.get(norm(heard))
+
+    def interference(self) -> set[str]:
+        """Every symbol some rule expects to hear instead of the target: the Hebrew sounds worth naming."""
+        return {h for (_, h) in self.checks if h != "_"}
+
+
+def _blocks(text: str) -> list[dict]:
+    out = []
+    for block in re.findall(r"```yaml\n(.*?)```", text, re.S):
+        for doc in re.split(r"^---$", block, flags=re.M):
+            if doc.strip():
+                out.append(yaml.safe_load(doc))
+    return out
+
+
+def parse(text: str) -> Rules:
+    archi, dialects, optional, scoring, labels = {}, ["urban", "rural"], False, {}, {}
+    checks: dict[tuple[str, str], Check] = {}
+    titles: dict[str, str] = {}
+    for doc in _blocks(text):
+        if "archiphonemes" in doc:
+            archi = {k: {d: list(v.get(d, [])) for d in ("urban", "rural", "also_ok", "optional")}
+                     for k, v in doc["archiphonemes"].items()}
+            dialects = list(doc.get("dialects_enabled", dialects))
+            optional = bool(doc.get("optional_realisations_enabled", False))
+        if "scoring" in doc:
+            scoring = dict(doc["scoring"])
+        if "heard_labels" in doc:
+            labels = {str(k): str(v) for k, v in doc["heard_labels"].items()}
+        if "checks" in doc:
+            titles[doc["id"]] = doc.get("title", doc["id"])
+            for c in doc["checks"]:
+                for heard in c["heard"]:
+                    key = (norm(str(c["target"])), norm(str(heard)))
+                    # two spellings of one sound (ʁ and ɣ) meet here: the first rule written wins
+                    checks.setdefault(key, Check(doc["id"], key[0], key[1], int(c["severity"]), str(c["feedback"])))
+    rules = Rules(archi, dialects, optional, scoring, checks, titles, labels)
+    for m in scoring.get("margins", []):
+        # base() drops vowel length, so a margin for long vowels would land on quality pairs (a / i) it was not meant for
+        for t in (t for t in m["target"] if "ː" not in str(t)):
+            for h in m["heard"]:
+                rules.margins[(norm(str(t)), norm(str(h)))] = float(m["margin"])
+    return rules
+
+
+@lru_cache(maxsize=1)
+def load(path: str = str(RULES_PATH)) -> Rules:
+    return parse(Path(path).read_text(encoding="utf-8"))
+
+
+def undetectable(check: Check, rules: Rules, in_model: Callable[[str], bool],
+                 heard_as: Callable[[str], object] | None = None) -> str | None:
+    """Why the model cannot catch this mistake, or None if it can.
+
+    `heard_as` names the model symbol a sound is heard as (stand-ins included: ðˤ as z); two sounds heard
+    as the same symbol cannot be told apart."""
+    same = (lambda a, b: a == b or (heard_as(a) is not None and heard_as(a) == heard_as(b))) if heard_as \
+        else (lambda a, b: a == b)
+    if same(check.target, check.heard):
+        return "same_sound"                 # the two collapse to one sound (aː / a: length is not modelled)
+    accepted = rules.members(check.target) if check.target.isupper() else [check.target]
+    if any(same(check.heard, p) for p in accepted):
+        return "accepted"                   # the 'mistake' is a correct realisation of the target
+    if not any(in_model(p) for p in accepted):
+        return "target_not_in_model"
+    if check.heard != "_" and not in_model(check.heard):
+        return "heard_not_in_model"
+    return None
+
+
+def check_detectable(rules: Rules, in_model: Callable[[str], bool],
+                     heard_as: Callable[[str], object] | None = None) -> dict[str, dict]:
+    """Per rule: whether at least one of its checks can fire, and why each of the others cannot."""
+    out: dict[str, dict] = {}
+    for c in rules.checks.values():
+        r = out.setdefault(c.rule, {"title": rules.titles.get(c.rule, c.rule), "detectable": False, "missing": []})
+        why = undetectable(c, rules, in_model, heard_as)
+        if why is None:
+            r["detectable"] = True
+        else:
+            r["missing"].append({"target": c.target, "heard": c.heard, "why": why})
+    return out
+
+
+# ---------- exemptions (section 6.3): what the model hears as a mistake but is ordinary speech ----------
+
+VOWELS = {"a", "i", "u", "e", "o", "aː", "iː", "uː", "eː", "oː"}
+_VOWEL_GROUPS = [set("iɪeɛ"), set("uʊoɔ"), set("aæɐɑəɛe")]  # a raised towards e is ordinary Palestinian speech
+
+
+def near_vowels(expected: str, heard: str | None) -> bool:
+    """Same vowel with another length, or the neighbouring quality (i/e, u/o, a/ə, a/e)."""
+    if expected not in VOWELS or not heard:
+        return False
+    e, h = expected.rstrip("ː"), heard.rstrip("ː")
+    return any(e in g and h in g for g in _VOWEL_GROUPS)
+
+
+def elided_article(toks, i: int, ar_words: list[str]) -> bool:
+    """Is token i the vowel of the article ال right after a word that ends in a vowel?
+
+    There it is not said (على الطّاولة is ʕ a l a | tˤ tˤ aː w l e), so its absence is not an error.
+    """
+    t = toks[i]
+    return (i > 0 and t.phoneme in VOWELS and toks[i - 1].word == t.word - 1 and toks[i - 1].phoneme in VOWELS
+            and t.word < len(ar_words) and ar_words[t.word].startswith("ال"))
+
+
+# A glottal stop that is simply not there is how natives say it too (انا, اهلا; ق between vowels): #1, #2.
+# A glottal stop replaced by another consonant still counts, unless the class accepts it (ق said as k).
+def _glottal_dropped(toks, i, sc, heard, ar_words):
+    return sc.deleted and toks[i].sound in ("ʔ", "Q")
+
+
+def _article_vowel_elided(toks, i, sc, heard, ar_words):     # #3
+    return sc.deleted and elided_article(toks, i, ar_words)
+
+
+# Neighbouring vowel qualities and vowel length vary between speakers and towns (il / el),
+# and the model confuses them on its own: not worth marking a word down for (#7).
+def _near_vowel(toks, i, sc, heard, ar_words):
+    return near_vowels(toks[i].phoneme, heard)
+
+
+# (name, applies(tokens, index, TokenScore, heard symbol, Arabic words), score it gets: None = full marks,
+# else the name of the ScorerConfig floor). The first that applies wins.
+EXEMPTIONS = [
+    ("glottal_dropped", _glottal_dropped, None),
+    ("article_vowel_elided", _article_vowel_elided, None),
+    ("near_vowel", _near_vowel, "near_vowel_floor"),
+]

app/scorer.py

@@ -11,11 +11,14 @@ from typing import Callable, Protocol
 
 import numpy as np
 
-from .align import GopConfig, ctc_viterbi, edit_distance, greedy_decode, score_tokens
-from .tips import NO_DELETION_TIP, VOWELS, letter_reason, sound_name, tip_for
-from .translit import CONSONANTS as _HEB_C, VOWELS as _HEB_V, to_hebrew, word_letters, word_to_hebrew
+from .align import Alignment, GopConfig, TokenScore, ctc_viterbi, edit_distance, greedy_decode, score_tokens
+from .archi import archify, diphthong_variants, split_token, written
+from .phones import base
+from .rules import EXEMPTIONS, Rules, elided_article, near_vowels, load as load_rules  # noqa: F401 (re-exported)
+from .tips import VOWELS, letter_reason, sound_name, tip_for
+from .translit import CONSONANTS as _HEB_C, HEARD_ONLY as _HEB_HEARD, VOWELS as _HEB_V, to_hebrew, word_letters, word_to_hebrew
 
-HEBREW_SOUNDS = set(_HEB_C) | set(_HEB_V)
+HEBREW_SOUNDS = set(_HEB_C) | set(_HEB_V) | set(_HEB_HEARD)
 
 log = logging.getLogger("ihki.scorer")
 
@@ -24,37 +27,24 @@ MAX_SECONDS = 32  # the recording includes the time to read the sentence and thi
 
 # Fallbacks when the model vocab lacks a phoneme. The first symbol found in the vocab wins.
 FALLBACKS = {
-    "sˤ": ["sˤ", "sˠ", "s"], "tˤ": ["tˤ", "tˠ", "t"], "dˤ": ["dˤ", "dˠ", "d"],
+    "sˤ": ["sˤ", "sˠ", "s"], "tˤ": ["tˤ", "tˠ", "t"], "dˤ": ["dˤ", "dˠ", "d"], "zˤ": ["zˤ", "zˠ", "z"],
     "ðˤ": ["ðˤ", "ðˠ", "zˤ", "z"], "dʒ": ["dʒ", "d͡ʒ", "ʒ"],
     "aː": ["aː", "a"], "iː": ["iː", "i"], "uː": ["uː", "u"], "eː": ["eː", "e"], "oː": ["oː", "o"],
     "x": ["x", "χ"], "ɣ": ["ɣ", "ʁ"], "q": ["q", "k"], "r": ["r", "ɾ"], "g": ["ɡ", "g"],
 }
 
 
-# The model's vocab is multilingual (392 symbols) and spells one sound several ways: t / t̪ / tʰ / tː,
-# r / ɾ, a / æ / ɐ, x / χ. Left alone, a correctly said t loses to its own spelling variant t̪.
-# base() names the sound a symbol stands for; Vocab.merge() pools the posteriors of each sound.
-_STRIP = set("ːʰʲ.^[:\"\u032a\u0329\u031d\u031e\u030a\u0303")  # length, aspiration, palatalisation, dental, syllabic, nasal ...
-_SAME = {"æ": "a", "ɐ": "a", "ɑ": "a", "ä": "a", "ʌ": "a", "ɪ": "i", "ʊ": "u", "ɛ": "e", "ɔ": "o",
-         "ɾ": "r", "ɫ": "l", "ɡ": "g", "χ": "x", "ʁ": "ɣ", "ʒ": "dʒ", "dZ": "dʒ", "tS": "tʃ", "S": "ʃ"}
-
-
-def base(symbol: str) -> str:
-    """The sound a model symbol stands for, ignoring length and spelling variants. Emphatics stay distinct."""
-    s = "".join(c for c in symbol if c not in _STRIP)
-    return _SAME.get(s, s) or symbol
-
-
 class Emitter(Protocol):
     """Anything that turns 16 kHz mono float32 audio into (T, V) log-posteriors."""
     def __call__(self, wav: np.ndarray) -> np.ndarray: ...
 
 
 class Vocab:
-    def __init__(self, token_to_id: dict[str, int], blank_token: str = "<pad>"):
+    def __init__(self, token_to_id: dict[str, int], blank_token: str = "<pad>", rules: Rules | None = None):
         self.t2i = token_to_id
         self.i2t = {i: t for t, i in token_to_id.items()}
         self.blank = token_to_id[blank_token]
+        self.rules = rules or load_rules()
         self.downgraded: dict[str, str] = {}
         # sound classes: every id points at one representative id (the plain symbol when the vocab has it)
         groups: dict[str, list[int]] = {}
@@ -63,12 +53,20 @@ class Vocab:
                 groups.setdefault(base(t), []).append(i)
         self.canon = {i: i for i in self.i2t}
         self._groups: list[tuple[int, list[int]]] = []
+        self.rep_of: dict[str, int] = {}  # base() name -> representative id
         for name, ids in groups.items():
             rep = token_to_id.get(name, ids[0]) if token_to_id.get(name) in ids else ids[0]
+            self.rep_of[name] = rep
             for i in ids:
                 self.canon[i] = rep
             if len(ids) > 1:
                 self._groups.append((rep, ids))
+        # Letters with several correct realisations (archi.py): one virtual id per (symbol, realisations),
+        # numbered after the real vocab, whose column extend() fills with the pooled posterior of its members.
+        self.n_real = max(self.i2t) + 1
+        self.members: dict[int, set[int]] = {}
+        self._classes: dict[tuple[str, frozenset[int]], int] = {}
+        self.class_missing: dict[str, set[str]] = {}  # symbol -> realisations the model has no symbol for
 
     def merge(self, logp: np.ndarray) -> np.ndarray:
         """Pool each sound's spelling variants into its representative column; the other columns go silent."""
@@ -78,6 +76,53 @@ class Vocab:
             out[:, rep] = np.logaddexp.reduce(logp[:, ids], axis=1)
         return out
 
+    def sound_id(self, phone: str) -> int | None:
+        """The representative id of a sound (any spelling of it), or None if the model has no symbol for it."""
+        return self.rep_of.get(base(phone))
+
+    def model_id(self, phone: str) -> int | None:
+        """The id the model hears `phone` as: its own, else its first FALLBACKS stand-in (ðˤ -> z), else None."""
+        for cand in [phone, *FALLBACKS.get(phone, [])]:
+            i = self.sound_id(cand)
+            if i is not None:
+                return i
+        return None
+
+    def add_class(self, symbol: str, phones: list[str]) -> int:
+        """The id that stands for 'any of `phones`': a virtual id, or the real one when only one is in the model.
+        A realisation the model lacks is heard as its stand-in, as a plain phoneme would be (zˤ as z)."""
+        ids: list[int] = []
+        for ph in phones:
+            i = self.model_id(ph)
+            if i is None:
+                self.class_missing.setdefault(symbol, set()).add(ph)
+                continue
+            if i != self.sound_id(ph):
+                self.downgraded[ph] = self.i2t[i]
+            if i not in ids:
+                ids.append(i)
+        if not ids:
+            raise KeyError(f"no realisation of {symbol} ({phones}) is in the model vocab")
+        if len(ids) == 1:
+            return ids[0]
+        key = (symbol, frozenset(ids))
+        if key not in self._classes:
+            vid = self.n_real + len(self._classes)
+            self._classes[key], self.members[vid] = vid, set(ids)
+            self.i2t[vid], self.canon[vid] = symbol, vid
+        return self._classes[key]
+
+    def extend(self, logp: np.ndarray) -> np.ndarray:
+        """Merged posteriors with one more column per class: the pooled posterior of its realisations."""
+        logp = logp[:, :self.n_real]
+        if not self.members:
+            return logp
+        out = np.full((logp.shape[0], self.n_real + len(self.members)), -1e9, dtype=logp.dtype)
+        out[:, :logp.shape[1]] = logp
+        for vid, ids in self.members.items():
+            out[:, vid] = np.logaddexp.reduce(logp[:, sorted(ids)], axis=1)
+        return out
+
     def resolve(self, phoneme: str) -> list[int]:
         for cand in FALLBACKS.get(phoneme, [phoneme]):
             if cand in self.t2i:
@@ -97,54 +142,52 @@ class Vocab:
         self.downgraded[phoneme] = " ".join(self.i2t[i] for i in ids)
         return ids
 
+    def token(self, tok: str) -> tuple[list[int], str, str]:
+        """A token of an IPA string (a phoneme, or an archi.py symbol "Q:ʔ") -> (model ids, phoneme as written, sound).
+
+        The sound is the symbol for a many-ways letter, the phoneme otherwise."""
+        sym, members, ph = split_token(tok)
+        if sym is None:
+            return self.resolve(tok), tok, tok
+        phones = members or self.rules.members(sym, written=base(ph) if ph else None)
+        ph = ph or (phones[0] if phones else sym)
+        try:
+            return [self.add_class(sym, phones)], ph, sym
+        except KeyError:
+            return self.resolve(ph), ph, sym
+
 
 LETTER_GOOD = 75  # a letter scoring under this is coloured on the page (`band` in static/index.html)
 
 
 @dataclass
 class TargetToken:
-    phoneme: str  # phoneme as written in phrases.py
-    id: int       # model token id
-    word: int     # word index in the variant
+    phoneme: str    # phoneme as written in phrases.py
+    id: int         # model token id (a virtual id for a letter with several correct realisations)
+    word: int       # word index in the variant
+    sound: str = ""  # what the token stands for: the archi.py symbol (Q) or the phoneme itself
+
+    def __post_init__(self):
+        self.sound = self.sound or self.phoneme
 
 
 def tokenize(ipa: str, vocab: Vocab) -> list[TargetToken]:
     """IPA string -> model tokens. Geminates (and any repeated id) collapse to one CTC token."""
     out: list[TargetToken] = []
     for w, word in enumerate(ipa.split("|")):
-        for ph in word.split():
-            for tid in vocab.resolve(ph):
+        for tok in word.split():
+            ids, ph, sound = vocab.token(tok)
+            for tid in ids:
                 if out and out[-1].id == tid:
                     continue
-                out.append(TargetToken(ph, tid, w))
+                out.append(TargetToken(ph, tid, w, sound))
     return out
 
 
-_VOWEL_GROUPS = [set("iɪeɛ"), set("uʊoɔ"), set("aæɐɑəɛe")]  # a raised towards e is ordinary Palestinian speech
-
-
-def near_vowels(expected: str, heard: str | None) -> bool:
-    """Same vowel with another length, or the neighbouring quality (i/e, u/o, a/ə, a/e)."""
-    if expected not in VOWELS or not heard:
-        return False
-    e, h = expected.rstrip("ː"), heard.rstrip("ː")
-    return any(e in g and h in g for g in _VOWEL_GROUPS)
-
-
-def elided_article(toks: list[TargetToken], i: int, ar_words: list[str]) -> bool:
-    """Is token i the vowel of the article ال right after a word that ends in a vowel?
-
-    There it is not said (على الطّاولة is ʕ a l a | tˤ tˤ aː w l e), so its absence is not an error.
-    """
-    t = toks[i]
-    return (i > 0 and t.phoneme in VOWELS and toks[i - 1].word == t.word - 1 and toks[i - 1].phoneme in VOWELS
-            and t.word < len(ar_words) and ar_words[t.word].startswith("ال"))
-
-
 @dataclass
 class Reference:
     """How the model scored a native voice saying a phrase: the baseline a learner is measured against."""
-    sounds: list[tuple[int, str]]  # (word, phoneme) of each sound of the variant the voice said
+    sounds: list[tuple[int, str]]  # (word, sound) of each sound of the variant the voice said (Q, not ʔ / k)
     scores: list[float]            # their scores, same order
 
 
@@ -154,16 +197,42 @@ class ScorerConfig:
     unrelated_ratio: float = 0.65   # normalised edit distance above which we say "different sentence"
     issue_below: float = 90.0       # phoneme score under which it is listed as imprecise
     max_issues: int = 8
+    max_tips: int | None = None     # None: as many as the rules document says (scoring.max_tips)
     near_vowel_floor: float = 90.0  # a vowel heard as its neighbour (i/e, u/o, a/ə, short/long) scores at least this
     word_min_weight: float = 0.5    # word score = this much weakest phoneme, the rest the mean of its phonemes
     ref_min_mean: float = 60.0      # a native reference whose mean phoneme score is under this is not trusted
     gop: GopConfig = field(default_factory=GopConfig)
 
 
+@dataclass
+class Fit:
+    """The accepted variant the audio fits best, and how each of its sounds scored."""
+    ar: str
+    ipa: str                 # as written in the phrase bank (display, transliteration)
+    aipa: str                # the same with archi.py symbols, one token per phoneme of `ipa`
+    toks: list[TargetToken]
+    al: Alignment
+    scores: list[TokenScore]
+    heard_ids: list[int]     # greedy decode, real symbols only
+    unrelated: bool
+    logp: np.ndarray         # merged posteriors with the class columns (Vocab.extend)
+    # for the teacher's stage-by-stage view (Scorer._trace)
+    candidates: list[tuple[str, str, float | None]] = field(default_factory=list)  # (ar, ipa, path log-prob)
+    gop_scores: list[TokenScore] = field(default_factory=list)   # before the exemptions
+    exempted: list[str | None] = field(default_factory=list)     # per token, the exemption that applied
+    distance: int = 0        # edit distance of the greedy decode from the chosen variant
+
+
 class Scorer:
     def __init__(self, emit: Emitter, vocab: Vocab, cfg: ScorerConfig | None = None):
         self.emit, self.vocab, self.cfg = emit, vocab, cfg or ScorerConfig()
+        self.rules = vocab.rules
         self.calibrations: dict[tuple[str, str, str], float] = {}
+        # the sounds a competitor is named by: Arabic, the Hebrew sounds the rules expect instead, and their labels;
+        # anything else the multilingual model offers (clicks, retroflexes) is reported as "not clear"
+        names = (set(HEBREW_SOUNDS) | self.rules.interference() | set(self.rules.heard_labels)
+                 | {p for s in self.rules.archiphonemes for p in self.rules.members(s)})
+        self.named = {i for i in (vocab.sound_id(n) for n in names) if i is not None}
 
     def set_calibrations(self, rows: list[dict]) -> None:
         """Atomically replaces applied score floors. A blank phrase is a global rule."""
@@ -186,18 +255,18 @@ class Scorer:
         fit = self._fit(self.vocab.merge(self.emit(wav)), phrase)
         if fit is None:
             return None
-        _, _, toks, _, scores, _, unrelated = fit
-        if unrelated or float(np.mean([sc.score for sc in scores])) < self.cfg.ref_min_mean:
+        if fit.unrelated or float(np.mean([sc.score for sc in fit.scores])) < self.cfg.ref_min_mean:
             return None
-        return Reference([(t.word, t.phoneme) for t in toks], [sc.score for sc in scores])
+        return Reference([(t.word, t.sound) for t in fit.toks], [sc.score for sc in fit.scores])
 
     @staticmethod
     def _baseline(toks: list[TargetToken], refs: list[Reference]) -> list[float | None]:
         """Per target token, the lowest score a native reference got on the same sound (None: no reference has it).
 
         References may have said another accepted variant: only the sounds the two variants share are matched.
+        Sounds are compared by symbol, so a voice that said ق as q is a baseline for a learner who says ʔ.
         """
-        sounds = [(t.word, t.phoneme) for t in toks]
+        sounds = [(t.word, t.sound) for t in toks]
         out: list[float | None] = [None] * len(toks)
         for ref in refs:
             for a, b, n in SequenceMatcher(None, ref.sounds, sounds, autojunk=False).get_matching_blocks():
@@ -213,7 +282,7 @@ class Scorer:
             row = []
             for ph in word.split():
                 idx = []
-                for tid in self.vocab.resolve(ph):
+                for tid in self.vocab.token(ph)[0]:
                     tid = self.vocab.canon[tid]
                     if tid != last:
                         n, last = n + 1, tid
@@ -236,7 +305,7 @@ class Scorer:
         """How each target token is written in the phrase bank, geminates included ("m m")."""
         runs: list[tuple[int, str, int]] = []  # (word, phoneme, repeat)
         for w, word in enumerate(ipa.split("|")):
-            for ph in word.split():
+            for ph in map(written, word.split()):
                 if runs and runs[-1][:2] == (w, ph):
                     runs[-1] = (w, ph, runs[-1][2] + 1)
                 else:
@@ -250,6 +319,7 @@ class Scorer:
 
         A sound heard as expected is written the way the answer writes it (length, gemination, emphasis:
         things the scorer does not tell apart), so the two lines differ only where the scorer heard a difference.
+        A letter with several correct realisations is written as the one said (כּ for a rural ق), not coloured.
         """
         n_words = len(ipa.split("|"))
         starts = [None] * n_words  # first frame of each expected word
@@ -261,57 +331,81 @@ class Scorer:
                 expected[t] = (tok.id, spell)
         heard: list[list[str]] = [[] for _ in range(n_words)]
         prev, w = None, 0
-        for t, i in enumerate(logp.argmax(1)):
+        for t, i in enumerate(logp[:, :self.vocab.n_real].argmax(1)):
             i = int(i)
             if i != prev and i != self.vocab.blank:
                 while w + 1 < n_words and starts[w + 1] is not None and t >= starts[w + 1]:
                     w += 1
                 ph = base(self.vocab.i2t[i])
-                if expected.get(t, (None,))[0] == i:
-                    heard[w].append(expected[t][1])
+                tid, spell = expected.get(t, (None, ""))
+                if tid == i:
+                    heard[w].append(spell)
+                elif i in self.vocab.members.get(tid, ()):
+                    heard[w].append(spell if base(spell.split()[0]) == ph else ph)
                 elif ph in HEBREW_SOUNDS:
                     heard[w].append(ph)
             prev = i
         # the Arabic spelling is passed so the heard line follows the answer's conventions (ק for ق, silent ל)
         return [word_to_hebrew(" ".join(phs), ar_words[w] if w < len(ar_words) else "") for w, phs in enumerate(heard)]
 
-    def _fit(self, logp: np.ndarray, phrase: dict):
-        """The accepted variant the audio fits best and the score of each of its sounds, from merged
-        posteriors: (arabic, ipa, tokens, alignment, scores, greedy decode, unrelated), or None if too short."""
-        blank = self.vocab.blank
-        heard_ids = greedy_decode(logp, blank)
-        best = None
+    def _variants(self, phrase: dict) -> list[tuple[str, str, str, list[TargetToken]]]:
+        """(arabic, ipa, ipa with symbols, tokens) for each accepted variant and its diphthong forms. Variants
+        that differ only in how a many-ways letter is said (ʔ / q / k for ق) become one: the first written.
+        A diphthong form the model has no symbols for is left out."""
+        out, seen = [], set()
         for ar, ipa in phrase["variants"]:
-            toks = self._targets(ipa)
-            al = ctc_viterbi(logp, [t.id for t in toks], blank)
-            if al and (best is None or al.total_logp > best[3].total_logp):
-                best = (ar, ipa, toks, al)
+            for n, form in enumerate((ipa, *diphthong_variants(ar, ipa))):
+                aipa = archify(ar, form)
+                if aipa in seen:
+                    continue
+                seen.add(aipa)
+                try:
+                    out.append((ar, form, aipa, self._targets(aipa)))
+                except KeyError:
+                    if n == 0:
+                        raise
+        return out
+
+    def _fit(self, logp: np.ndarray, phrase: dict) -> Fit | None:
+        """The accepted variant the audio fits best and the score of each of its sounds, from merged
+        posteriors, or None if the recording is too short for every variant."""
+        blank, vocab = self.vocab.blank, self.vocab
+        heard_ids = greedy_decode(logp[:, :vocab.n_real], blank)
+        cands = self._variants(phrase)
+        ext = vocab.extend(logp)  # after tokenising: a variant may have brought a new class
+        best, tried = None, []
+        for ar, ipa, aipa, toks in cands:
+            al = ctc_viterbi(ext, [t.id for t in toks], blank)
+            tried.append((ar, ipa, round(al.total_logp, 2) if al else None))
+            if al and (best is None or al.total_logp > best[4].total_logp):
+                best = (ar, ipa, aipa, toks, al)
         if best is None:
             return None
 
-        ar, ipa, toks, al = best
+        ar, ipa, aipa, toks, al = best
         ids = [t.id for t in toks]
         ar_words = ar.split()
-        scores = score_tokens(logp, al, ids, blank, self.cfg.gop)
-        # A glottal stop that is simply not there is how natives say it too (انا, اهلا): not an error.
-        # The same goes for the article's vowel after a vowel (على الطّاولة).
-        # A glottal stop replaced by another consonant (ق said as k) still counts.
-        scores = [replace(sc, score=100.0)
-                  if sc.deleted and (t.phoneme in NO_DELETION_TIP or elided_article(toks, i, ar_words)) else sc
-                  for i, (t, sc) in enumerate(zip(toks, scores))]
-        # Neighbouring vowel qualities and vowel length vary between speakers and towns (il / el),
-        # and the model confuses them on its own: not worth marking a word down for.
-        scores = [replace(sc, score=max(sc.score, self.cfg.near_vowel_floor))
-                  if sc.competitor is not None and near_vowels(t.phoneme, self.vocab.i2t.get(sc.competitor)) else sc
-                  for t, sc in zip(toks, scores)]
-        unrelated = bool(edit_distance(heard_ids, ids) / max(1, len(ids)) > self.cfg.unrelated_ratio)
-        return ar, ipa, toks, al, scores, heard_ids, unrelated
+        scores = score_tokens(ext, al, ids, blank, self.cfg.gop, [vocab.members.get(i) for i in ids],
+                              vocab.n_real, self.named)
+        gop_scores, exempted = list(scores), [None] * len(scores)
+        for i, (t, sc) in enumerate(zip(toks, scores)):
+            heard = vocab.i2t.get(sc.competitor) if sc.competitor is not None else None
+            for name, applies, floor in EXEMPTIONS:
+                if applies(toks, i, sc, heard, ar_words):
+                    scores[i] = replace(sc, score=max(sc.score, 100.0 if floor is None else getattr(self.cfg, floor)))
+                    exempted[i] = name
+                    break
+        same = lambda h, t: h == t or h in vocab.members.get(t, ())
+        distance = edit_distance(heard_ids, ids, same)
+        unrelated = bool(distance / max(1, len(ids)) > self.cfg.unrelated_ratio)
+        return Fit(ar, ipa, aipa, toks, al, scores, heard_ids, unrelated, ext, tried, gop_scores, exempted, distance)
 
     def _heatmap(self, logp: np.ndarray, toks: list[TargetToken], alignment, scores,
                  duration_s: float | None) -> dict:
         """A compact posterior heatmap for teacher diagnostics: expected sounds, strongest competitors and blank.
 
         Max-pooling preserves short phoneme peaks while capping the response at 180 time columns.
+        A letter with several correct realisations is one row, the pooled posterior, labelled "ʔ/k/q".
         """
         expected_ids = list(dict.fromkeys(t.id for t in toks))
         competitor_ids = list(dict.fromkeys(sc.competitor for sc in scores
@@ -319,7 +413,8 @@ class Scorer:
         ids = expected_ids + competitor_ids + ([self.vocab.blank] if self.vocab.blank not in expected_ids else [])
         frames, bins = len(logp), min(len(logp), 180)
         edges = np.linspace(0, frames, bins + 1, dtype=int)
-        labels = {t.id: t.phoneme for t in toks}
+        labels = {t.id: ("/".join(self.vocab.i2t[m] for m in sorted(self.vocab.members[t.id]))
+                         if t.id in self.vocab.members else t.phoneme) for t in toks}
         rows = []
         for token_id in ids:
             probability = np.exp(logp[:, token_id])
@@ -327,7 +422,7 @@ class Scorer:
             rows.append({"phoneme": labels.get(token_id, "blank" if token_id == self.vocab.blank
                                                 else self.vocab.i2t.get(token_id, "?")),
                          "expected": token_id in expected_ids, "values": values})
-        greedy = logp.argmax(1)
+        greedy = logp[:, :self.vocab.n_real].argmax(1)
         heard = []
         start = 0
         for end in range(1, frames + 1):
@@ -343,26 +438,55 @@ class Scorer:
                 "frames": frames, "frame_bins": bins, "rows": rows,
                 "tracks": {"expected": expected, "heard": heard}}
 
+    def _beyond_margin(self, tok: TargetToken, sc: TokenScore, heard: str | None) -> bool:
+        """Is the competitor likelier than the target by more than the pair's margin? Pairs the model confuses
+        on natives too (emphatics, a dropped h) need a clearer win before they count as a mistake."""
+        targets = [tok.sound, tok.phoneme]
+        if sc.deleted:
+            return sc.peak <= self.cfg.gop.deleted_peak - self.rules.margin(targets, "_")
+        if heard is None:
+            return True
+        return -sc.gop >= self.rules.margin(targets, heard)
+
+    def _dialect(self, toks: list[TargetToken], scores: list[TokenScore]) -> dict:
+        """Which dialect the accepted realisations point to: {"dialect": urban | rural} when they agree,
+        {"mixed_dialect": True} when one is urban-only and another rural-only. Never part of the score."""
+        seen: set[str] = set()
+        for t, sc in zip(toks, scores):
+            if sc.realised is None or sc.score < self.cfg.issue_below:
+                continue
+            ds = self.rules.dialects_of(t.sound, base(self.vocab.i2t[sc.realised]))
+            if len(ds) == 1:
+                seen |= ds
+        if len(seen) > 1:
+            return {"mixed_dialect": True}
+        return {"dialect": next(iter(seen))} if seen else {}
+
     def score_logp(self, logp: np.ndarray, phrase: dict, refs: list[Reference] = (), diagnostics: bool = False,
                    duration_s: float | None = None) -> dict:
         logp = self.vocab.merge(logp)
         fit = self._fit(logp, phrase)
         if fit is None:
             return {"error": "too_short", "message": "ההקלטה קצרה מדי. החזיקו את הכפתור ואמרו את כל המשפט."}
-        ar, ipa, toks, al, scores, heard_ids, unrelated = fit
-        heard = " ".join(self.vocab.i2t[i] for i in heard_ids)
+        ar, ipa, toks, al, scores, unrelated = fit.ar, fit.ipa, fit.toks, fit.al, fit.scores, fit.unrelated
+        i2t = self.vocab.i2t
+        heard = " ".join(i2t[i] for i in fit.heard_ids)
         # Measure against what the model gives a native on the same sound: a sound it misses in the
         # reference voice too (ʕ in على heard as dropped) is the model's weakness, not the learner's.
-        heatmap = self._heatmap(logp, toks, al, scores, duration_s) if diagnostics else None
-        raw = scores
+        heatmap = self._heatmap(fit.logp, toks, al, scores, duration_s) if diagnostics else None
+        raw, bases = scores, self._baseline(toks, refs)
         scores = [sc if b is None or b >= 100 else replace(sc, score=round(min(100.0, 100.0 * sc.score / max(b, 1.0)), 1))
-                  for sc, b in zip(raw, self._baseline(toks, refs))]
+                  for sc, b in zip(raw, bases)]
+        after_baseline = scores
+        # teacher floors, by symbol first (Q), then by the phoneme written (rows made before symbols existed)
         phrase_key, calibrated = str(phrase.get("key", phrase.get("he", ""))), []
-        adjusted = []
+        adjusted, floors = [], []
         for tok, sc in zip(toks, scores):
-            heard_ph = "_" if sc.deleted else (self.vocab.i2t.get(sc.competitor) if sc.competitor is not None else "")
-            floor = self.calibrations.get((tok.phoneme, heard_ph, phrase_key),
-                                          self.calibrations.get((tok.phoneme, heard_ph, "")))
+            heard_ph = "_" if sc.deleted else (i2t.get(sc.competitor) if sc.competitor is not None else "")
+            floor = next((self.calibrations[k] for k in ((tok.sound, heard_ph, phrase_key), (tok.sound, heard_ph, ""),
+                                                         (tok.phoneme, heard_ph, phrase_key), (tok.phoneme, heard_ph, ""))
+                          if k in self.calibrations), None)
+            floors.append(floor)
             if floor is not None and sc.score < floor:
                 calibrated.append({"expected": tok.phoneme, "heard": heard_ph, "from": round(sc.score), "to": round(floor)})
                 sc = replace(sc, score=floor)
@@ -372,16 +496,26 @@ class Scorer:
 
         phonemes, tips, seen = [], [], set()
         heard_as = []   # per phoneme, what took its place ("_": nothing), flagged or not: the reason a letter gives
+        checks = []     # per phoneme, the rule for what took its place (None: no rule)
+        beyond = []     # per phoneme, whether what took its place won by the pair's margin
         ar_words = ar.split()
         tr_words = to_hebrew(ipa, ar)
         for idx, (tok, sc) in enumerate(zip(toks, scores)):
-            heard_ph = "_" if sc.deleted else (self.vocab.i2t.get(sc.competitor) if sc.competitor is not None else None)
-            flagged = bool(sc.score < self.cfg.flag_below) and tok.phoneme not in VOWELS
+            heard_ph = "_" if sc.deleted else (i2t.get(sc.competitor) if sc.competitor is not None else None)
+            check = self.rules.check([tok.sound, tok.phoneme], heard_ph)
+            beyond.append(self._beyond_margin(tok, sc, heard_ph))
+            flagged = bool(sc.score < self.cfg.flag_below) and tok.phoneme not in VOWELS and beyond[-1]
             heard_as.append(heard_ph)
-            phonemes.append({"ipa": tok.phoneme, "word": tok.word, "score": sc.score,
-                             "flagged": flagged, "heard": heard_ph if flagged else None})
+            checks.append(check)
+            p = {"ipa": tok.phoneme, "word": tok.word, "score": sc.score,
+                 "flagged": flagged, "heard": heard_ph if flagged else None}
+            if tok.sound != tok.phoneme:
+                p["sound"] = tok.sound
+            if sc.realised is not None:
+                p["realised"] = base(i2t[sc.realised])
+            phonemes.append(p)
             if flagged and not unrelated:
-                tip = tip_for(tok.phoneme, heard_ph)
+                tip = tip_for(tok.sound, heard_ph, check)
                 if tip and tip["key"] not in seen:
                     seen.add(tip["key"])
                     tip["word"] = ar_words[tok.word] if tok.word < len(ar_words) else ""
@@ -391,9 +525,9 @@ class Scorer:
                     tips.append(tip)
 
         n_words = len(ipa.split("|"))
-        heard_words = self._heard_hebrew(logp, toks, al, ipa, ar_words)
+        heard_words = self._heard_hebrew(logp, toks, al, fit.aipa, ar_words)
         words, k = [], self.cfg.word_min_weight
-        carriers, ipa_words = self._carriers(ipa), ipa.split("|")
+        carriers, ipa_words = self._carriers(fit.aipa), ipa.split("|")
         for w in range(n_words):
             ws = [p["score"] for p in phonemes if p["word"] == w]
             # the transliteration letter by letter, each with the weakest score among its sounds; a letter the
@@ -404,7 +538,7 @@ class Scorer:
                 worst = min(got, key=lambda i: phonemes[i]["score"]) if got else None
                 letter = {"t": text, "score": phonemes[worst]["score"] if got else None}
                 if got and letter["score"] < LETTER_GOOD and not unrelated:
-                    letter.update(letter_reason(phonemes[worst]["ipa"], heard_as[worst]))
+                    letter.update(letter_reason(toks[worst].sound, heard_as[worst], checks[worst]))
                 letters.append(letter)
             if w in forgiven and min(ws) >= self.cfg.issue_below:
                 heard_words[w] = tr_words[w]  # what differs from the answer here is what a native voice gets too
@@ -418,7 +552,10 @@ class Scorer:
         overall = 0.5 * phone_mean + 0.5 * word_mean  # one wrong consonant must pull the sentence down
         if unrelated:
             overall = min(overall, 30.0)
-        tips = sorted(tips, key=lambda t: t["score"])[:4]  # most crucial first: the worst-scoring sounds
+        # most crucial first: the mistakes that change meaning (severity 3), then the worst-scoring sounds
+        max_tips = self.cfg.max_tips or int(self.rules.scoring.get("max_tips", 4))
+        tips = sorted(tips, key=lambda t: (-t["severity"], t["score"]))[:max_tips]
+        tip_idx, issue_idx = {t["idx"] for t in tips}, []
 
         # Anything short of 100 must say why: every imprecise sound that did not get a full tip,
         # weakest first. If nothing is clearly off, name the weakest few.
@@ -427,25 +564,105 @@ class Scorer:
             tipped = {t.pop("idx") for t in tips}
             rest = sorted((i for i in range(len(toks)) if i not in tipped and scores[i].score < 100),
                           key=lambda i: scores[i].score)
-            picked = [i for i in rest if scores[i].score < self.cfg.issue_below]
+            picked = [i for i in rest if scores[i].score < self.cfg.issue_below and beyond[i]]
             if not picked and not tips:
                 picked = rest[:3]
-            for i in picked[:self.cfg.max_issues]:
+            issue_idx = picked[:self.cfg.max_issues]
+            for i in issue_idx:
                 tok, sc = toks[i], scores[i]
-                comp = self.vocab.i2t.get(sc.competitor) if sc.competitor is not None else None
-                issues.append({"sound": sound_name(tok.phoneme) or tok.phoneme, "word_tr": tr_words[tok.word],
-                               "score": round(sc.score), "missing": bool(sc.deleted),
+                comp = i2t.get(sc.competitor) if sc.competitor is not None else None
+                issues.append({"sound": sound_name(tok.sound) or sound_name(tok.phoneme) or tok.phoneme,
+                               "word_tr": tr_words[tok.word], "score": round(sc.score), "missing": bool(sc.deleted),
                                "heard": None if sc.deleted else sound_name(comp)})
         for t in tips:
             t.pop("idx", None)
         result = {"score": round(overall), "variant": {"ar": ar, "tr": " ".join(tr_words), "ipa": ipa}, "heard_ipa": heard, "heard_tr": " ".join(h for h in heard_words if h),
-                  "unrelated": unrelated, "words": words, "tips": tips, "issues": issues, "references": len(refs)}
+                  "unrelated": unrelated, "words": words, "tips": tips, "issues": issues, "references": len(refs),
+                  **self._dialect(toks, scores)}
         if calibrated:
             result["calibrated"] = calibrated
         if heatmap is not None:
             result["phoneme_heatmap"] = heatmap
+        if diagnostics:
+            result["trace"] = self._trace(fit, refs, bases, after_baseline, floors, scores, phonemes, checks, beyond,
+                                          words, tips, tip_idx, set(issue_idx), phone_mean, word_mean, overall, heard)
         return result
 
+    def _trace(self, fit: Fit, refs, bases, after_baseline, floors, scores, phonemes, checks, beyond,
+               words, tips, tip_idx, issue_idx, phone_mean, word_mean, overall, heard) -> dict:
+        """Every stage of the classification with its numbers, weights and thresholds, for the teacher's view
+        (the 'stages' part of the phoneme analysis). Nothing here changes the result."""
+        cfg, g, i2t = self.cfg, self.cfg.gop, self.vocab.i2t
+        p = lambda lp: round(float(np.exp(lp)), 4) if lp > -1e20 else 0.0
+        max_tips = cfg.max_tips or int(self.rules.scoring.get("max_tips", 4))
+        n = len(fit.toks)
+        tokens = []
+        for i, (tok, gsc, sc) in enumerate(zip(fit.toks, fit.gop_scores, scores)):
+            heard_ph = "_" if gsc.deleted else (i2t.get(gsc.competitor) if gsc.competitor is not None else None)
+            members = self.vocab.members.get(tok.id)
+            targets = [tok.sound, tok.phoneme]
+            confidence = min(1.0, p(gsc.peak) / g.confident_peak)
+            check = checks[i]
+            b = bases[i]
+            stages = [
+                {"stage": "gop", "score": gsc.score},
+                {"stage": "exemption", "score": fit.scores[i].score, "applied": fit.exempted[i]},
+                {"stage": "baseline", "score": after_baseline[i].score, "ref": b,
+                 "applied": b is not None and b < 100},
+                {"stage": "calibration", "score": sc.score, "floor": floors[i],
+                 "applied": floors[i] is not None and after_baseline[i].score < floors[i]},
+            ]
+            tokens.append({
+                "i": i, "word": tok.word, "ipa": tok.phoneme, "sound": tok.sound,
+                "class": sorted(base(i2t[m]) for m in members) if members else None,
+                "realised": base(i2t[gsc.realised]) if gsc.realised is not None else None,
+                "span": list(fit.al.spans[i]), "window": list(gsc.window),
+                "p_target": p(gsc.peak), "competitor": heard_ph if not gsc.deleted else None,
+                "competitor_other": gsc.other, "p_competitor": p(gsc.comp_peak),
+                "gop": gsc.gop, "confidence": round(confidence, 3),
+                "gop_factor": round(float(np.exp(gsc.gop * g.leniency)), 3),
+                "confidence_factor": round(float(np.sqrt(confidence)), 3),
+                "deleted": gsc.deleted, "stages": stages, "final": sc.score,
+                "margin": {"needed": self.rules.margin(targets, "_" if gsc.deleted else heard_ph),
+                           "got": (round(g.deleted_peak - gsc.peak, 3) if gsc.deleted else round(-gsc.gop, 3)),
+                           "beyond": beyond[i]},
+                "vowel": tok.phoneme in VOWELS, "weight": 0.5 if tok.phoneme in VOWELS else 1.0,
+                "flagged": phonemes[i]["flagged"],
+                "rule": {"id": check.rule, "title": self.rules.titles.get(check.rule, check.rule),
+                         "severity": check.severity} if check else None,
+                "tip": i in tip_idx, "issue": i in issue_idx,
+            })
+        return {
+            "config": {
+                "leniency": g.leniency, "confident_peak": g.confident_peak,
+                "deleted_peak": round(float(np.exp(g.deleted_peak)), 3),
+                "deleted_comp": round(float(np.exp(g.deleted_comp)), 3),
+                "flag_below": cfg.flag_below, "issue_below": cfg.issue_below, "near_vowel_floor": cfg.near_vowel_floor,
+                "word_min_weight": cfg.word_min_weight, "vowel_weight": 0.5, "unrelated_ratio": cfg.unrelated_ratio,
+                "unrelated_cap": 30.0, "letter_good": LETTER_GOOD, "max_tips": max_tips, "max_issues": cfg.max_issues,
+                "ref_min_mean": cfg.ref_min_mean, "margin_default": float(self.rules.scoring.get("margin_default", 0.0)),
+                "margins": [{"target": t, "heard": h, "margin": m} for (t, h), m in sorted(self.rules.margins.items())],
+                "exemptions": [name for name, _, _ in EXEMPTIONS],
+            },
+            "variants": [{"ar": ar, "ipa": ipa, "logp": lp, "chosen": ar == fit.ar and ipa == fit.ipa}
+                         for ar, ipa, lp in fit.candidates],
+            "aipa": fit.aipa,
+            "unrelated": {"heard": heard, "distance": fit.distance, "tokens": n,
+                          "ratio": round(fit.distance / max(1, n), 3), "threshold": cfg.unrelated_ratio,
+                          "unrelated": fit.unrelated},
+            "references": [{"mean": round(float(np.mean(r.scores)), 1), "sounds": len(r.sounds)} for r in refs],
+            "tokens": tokens,
+            "words": [{"tr": w["tr"], "scores": [ph["score"] for ph in w["phonemes"]],
+                       "min": min((ph["score"] for ph in w["phonemes"]), default=0.0),
+                       "mean": round(float(np.mean([ph["score"] for ph in w["phonemes"]])), 1) if w["phonemes"] else 0.0,
+                       "score": w["score"]} for w in words],
+            "sentence": {"phone_mean": round(phone_mean, 1), "word_mean": round(word_mean, 1),
+                         "phone_weight": 0.5, "word_weight": 0.5,
+                         "before_cap": round(0.5 * phone_mean + 0.5 * word_mean, 1), "final": round(overall),
+                         "capped": fit.unrelated},
+            "tips": [{"key": t["key"], "severity": t["severity"], "score": t["score"]} for t in tips],
+        }
+
 
 # ---------- real model ----------
 
@@ -500,8 +717,10 @@ def load_scorer(model_id: str) -> Scorer:
     # resolve every phoneme once at startup so missing symbols show up in the logs and /api/health
     from .phrases import PHRASES
     for p in PHRASES:
-        for _, ipa in p["variants"]:
-            tokenize(ipa, vocab)
+        for ar, ipa in p["variants"]:
+            tokenize(archify(ar, ipa), vocab)
     if vocab.downgraded:
         log.warning("phonemes mapped to fallbacks: %s", vocab.downgraded)
+    if vocab.class_missing:
+        log.warning("realisations the model cannot hear, left out of their letter's class: %s", vocab.class_missing)
     return scorer

app/tips.py

@@ -5,6 +5,8 @@ Phonemes are in the IPA used by phrases.py; HEARD_ALIASES maps model outputs ont
 """
 import re
 
+from .rules import load as load_rules
+
 NAMES = {
     "ħ": "ח (ح)", "ʕ": "ע (ع)", "x": "ח' (خ)", "ɣ": "ע' (غ)", "r": "ר (ر)",
     "q": "ק (ق)", "ʔ": "עצירה סותמית (ء / ق)", "h": "ה (ه)",
@@ -12,6 +14,9 @@ NAMES = {
     "k": "כ (ك)", "s": "ס (س)", "t": "ת (ت)", "d": "ד (د)", "z": "ז (ز)",
     "ʃ": "ש (ش)", "dʒ": "ג' (ج)", "b": "ב (ب)", "f": "פ (ف)", "m": "מ (م)",
     "n": "נ (ن)", "l": "ל (ل)", "w": "ו (و)", "j": "י (ي)",
+    "tʃ": "צ' (tʃ)", "θ": "ת' (th)", "ð": "ד״ (th)",
+    # letters with several correct realisations (archi.py): named by the letter, not by one way of saying it
+    "Q": "ק (ق)", "K": "כ (ك)", "TH": "ת' (ث)", "DH": "ד״ (ذ)", "ZH": "ט' (ظ)", "J": "ג' (ج)",
 }
 
 # model output symbol -> symbol used in TIPS keys
@@ -49,6 +54,7 @@ TIPS = {
 
 # bare Arabic letter in a tip text -> "Hebrew (Arabic)", so Arabic never appears without a Hebrew reading
 _PAIRED = {name[name.index("(") + 1]: name for name in NAMES.values() if "/" not in name}
+DEFAULT_SEVERITY = 2  # a tip no rule in pronunciation-rules.md grades
 _BARE_AR = re.compile(r"(?<!\()[\u0621-\u064a](?![\u0621-\u064a])")
 
 
@@ -64,14 +70,17 @@ VOWEL_NAMES = {
 
 
 def sound_name(phoneme: str | None) -> str | None:
-    """Hebrew name of a phoneme (expected or heard), or None if we have no name for it."""
+    """Hebrew name of a phoneme (expected or heard), or None if we have no name for it.
+    Sounds Arabic does not have (p, v, ts) are named by the labels of pronunciation-rules.md."""
+    if phoneme is None:
+        return None
     phoneme = HEARD_ALIASES.get(phoneme, phoneme)
-    return NAMES.get(phoneme) or VOWEL_NAMES.get(phoneme)
+    return NAMES.get(phoneme) or VOWEL_NAMES.get(phoneme) or load_rules().label(phoneme)
 
 
-def letter_reason(expected: str, heard: str | None) -> dict:
+def letter_reason(expected: str, heard: str | None, check=None) -> dict:
     """Why a letter of the answer is coloured: {"why": the sound and what was heard in its place ("_": nothing was),
-    "tip": how to say it, for the substitutions TIPS covers}."""
+    "tip": how to say it, from the rule for that substitution (`check`, rules.Check) or TIPS}."""
     name = sound_name(expected) or expected
     heard = HEARD_ALIASES.get(heard, heard)
     other = sound_name(heard)
@@ -81,27 +90,34 @@ def letter_reason(expected: str, heard: str | None) -> dict:
         why = f"{name} נשמעה כמו {other}"
     else:
         why = f"{name} לא נשמעה בבירור"
-    text = TIPS.get((expected, heard))
+    text = check.feedback if check else TIPS.get((expected, heard))
     return {"why": why, **({"tip": with_hebrew(text)} if text else {})}
 
 
 VOWELS = {"a", "i", "u", "e", "o", "aː", "iː", "uː", "eː", "oː"}
-# the urban glottal stop is often dropped by natives too; don't nag about it
-NO_DELETION_TIP = {"ʔ"}
+# the glottal stop (ء, and ق said the urban way) is often dropped by natives too; don't nag about it
+NO_DELETION_TIP = {"ʔ", "Q"}
 
 
-def tip_for(expected: str, heard: str | None) -> dict | None:
-    """Feedback for one flagged phoneme, or None if there is nothing useful to say."""
+def tip_for(expected: str, heard: str | None, check=None) -> dict | None:
+    """Feedback for one flagged phoneme, or None if there is nothing useful to say.
+
+    `check` (rules.Check) is the rule of pronunciation-rules.md for this substitution: its feedback and
+    severity win over TIPS. The key stays "expected>heard" either way."""
     if expected in VOWELS:
         return None
     heard = HEARD_ALIASES.get(heard, heard) if heard else "_"
     if heard == "_" and expected in NO_DELETION_TIP:
         return None
     name = NAMES.get(expected, expected)
+    key = f"{expected}>{heard}"
+    if check:
+        return {"title": name, "text": with_hebrew(check.feedback), "key": key, "severity": check.severity}
     text = TIPS.get((expected, heard))
     if text:
-        return {"title": name, "text": with_hebrew(text), "key": f"{expected}>{heard}"}
+        return {"title": name, "text": with_hebrew(text), "key": key, "severity": DEFAULT_SEVERITY}
     if heard == "_":
-        return {"title": name, "text": "לא נשמעה בבירור.", "key": f"{expected}>_"}
-    text = f"נשמעה כמו {NAMES[heard]}." if heard in NAMES else "נשמעה אחרת מהצפוי."
-    return {"title": name, "text": text, "key": f"{expected}>{heard}"}
+        return {"title": name, "text": "לא נשמעה בבירור.", "key": key, "severity": DEFAULT_SEVERITY}
+    other = sound_name(heard)
+    text = f"נשמעה כמו {other}." if other else "נשמעה אחרת מהצפוי."
+    return {"title": name, "text": text, "key": key, "severity": DEFAULT_SEVERITY}

app/translit.py

@@ -10,7 +10,12 @@ CONSONANTS = {
     "ʔ": "א", "b": "בּ", "t": "ת", "dʒ": "ג'", "ħ": "ח", "x": "ח'", "d": "ד", "r": "ר", "z": "ז",
     "s": "ס", "ʃ": "ש", "sˤ": "צ", "dˤ": "ד'", "tˤ": "ט", "ðˤ": "ט'", "ʕ": "ע", "ɣ": "ע'", "f": "פ",
     "q": "ק", "k": "כּ", "g": "ג", "l": "ל", "m": "מ", "n": "נ", "h": "ה", "w": "ו", "j": "י",
+    # rural realisations (pronunciation-rules.md, section 1)
+    "tʃ": "צ'", "θ": "ת'", "ð": "ד״",
 }
+# Sounds Arabic does not have, written only in the line of what was heard, never in an answer: a Hebrew
+# speaker's p for ف, v for و / ب, and Hebrew צ (ts) for ص. Without them the heard line would drop the letter.
+HEARD_ONLY = {"p": "פּ", "v": "ב", "β": "ב", "ʋ": "ב", "ts": "טס"}
 # vowel -> ((mark on the consonant, letter after it) mid-word, (same) word-finally)
 VOWELS = {
     "a": (("ַ", ""), ("ַ", "א")), "i": (("ִ", ""), ("ִ", "י")), "u": (("ֻ", ""), ("", "וּ")),
@@ -23,8 +28,8 @@ SHADDA, SHVA = "\u0651", "\u05b0"
 
 
 def _letter(base: str, marks: str) -> str:
-    """Points go on the letter itself, before a geresh."""
-    return base[0] + marks + base[1:] if base.endswith("'") else base + marks
+    """Points go on the letter itself, before a geresh (or gershayim), and on the first letter of טס."""
+    return base[0] + marks + base[1:] if len(base) > 1 and base[1] != "\u05bc" else base + marks
 
 
 def word_letters(ipa_word: str, ar_word: str = "") -> list[tuple[str, list[int]]]:
@@ -51,7 +56,7 @@ def word_letters(ipa_word: str, ar_word: str = "") -> list[tuple[str, list[int]]
         if ph in VOWELS:  # vowel with no consonant before it (word-initial): carry it on an alef
             base, shadda = "א", ""
         else:
-            base, shadda = CONSONANTS.get(ph, ph), ""
+            base, shadda = CONSONANTS.get(ph) or HEARD_ONLY.get(ph, ph), ""
             i += 1
             if i < len(phs) and phs[i] == ph:  # geminate
                 shadda = SHADDA

docs/scoring-dialects-plan.md

@@ -0,0 +1,172 @@
+# Plan: dialect acceptance and Hebrew-speaker rules in the scorer
+
+Status: implemented 2026-10-15, except where "Implementation notes" at the end says otherwise. Source rules: [pronunciation-rules.md](../static/assets/pronunciation-rules.md).
+
+Two layers on top of today's scoring path:
+
+- **Layer A, dialect acceptance:** decides what counts as *correct*. Runs inside GOP: every correct realisation of a letter is pooled into one class, and members of the class never count as competitors.
+- **Layer B, Hebrew-speaker rules:** decides how strictly to judge *real errors*. Runs after GOP: per-pair margins, severity, feedback, exemptions.
+
+The native baseline and the teacher calibration floors stay where they are, but are keyed on the abstract symbol instead of the sound actually said.
+
+Final order of the pipeline:
+
+1. `Vocab.merge` pools spelling variants (exists)
+2. Layer A: class columns → alignment → GOP against the class
+3. Layer B exemptions (6.3)
+4. Native baseline normalisation (exists, keyed on the abstract symbol)
+5. Layer B margins, severity, feedback
+6. Teacher DB floors (exists, last, manual override)
+
+## Phase 0: Rule loader (`app/rules.py`, new)
+
+- Pull the YAML blocks out of `pronunciation-rules.md` (fenced ` ```yaml `, split on `---`). Load them into:
+  - `archiphonemes`, `dialects_enabled`, `optional_realisations_enabled`
+  - `scoring` (margins, floors)
+  - `checks` (target, heard, severity, feedback), collected from every rule block
+  - `heard_labels`
+- Pass every symbol through `base()` when loading, so `ʁ` is stored as `ɣ`, `χ` as `x`, and so on. Warn about rules that become **undetectable**:
+  - target and heard end up the same sound after `base()`;
+  - a heard symbol is in the same accepted set as its target;
+  - a symbol is missing from the model vocab.
+- Add `pyyaml` to `requirements.txt`. It's already installed through `huggingface_hub`, but it should be listed explicitly.
+- Consider moving the rules file to `docs/` as the doc itself suggests. The student sections are served from `static/assets/`, so either keep it there or copy it at build time.
+- **Tests:** every block parses; every `heard:` symbol has a label in section 8; the undetectable-rule check fires on a deliberately bad rule.
+
+## Phase 1: Layer A core, with `Q` only
+
+### 1a. Converting the phrases at load time, not in the source files
+
+`app/workbook.py` has ~930 ق and `app/grammar.py` has more, so rewriting the IPA by hand isn't realistic.
+
+- Add `archify(ar, ipa)` in a new `app/archi.py`. For each word whose Arabic contains ق, replace the matching `ʔ`/`q`/`k` with `Q`.
+  - Match by consonant order. `word_letters` in `app/translit.py` already lines up ق with its phoneme, so reuse that logic.
+- **Ambiguous words** (both ء and ق, or ك next to ق) need an explicit marker written in the phrase. Add a test that fails on any ق word it can't resolve.
+- After conversion, merge duplicate variants. Today's separate `q` and `k` variants (e.g. `i l q u d s`) become the same as the `ʔ` one.
+- Run it inside `PHRASES` / `workbook_phrases()` so every consumer sees `Q`, including references and tokenisation at startup in `load_scorer`.
+
+### 1b. `Vocab` classes (`app/scorer.py`, `Vocab`)
+
+- `Vocab(token_to_id, classes=rules.archiphonemes)` creates one **virtual id** per abstract symbol, numbered after the real vocabulary (V, V+1, …). It also keeps `members[vid]`, the real representative ids of the accepted realisations.
+- `merge()` returns `logp` with extra columns: column `vid` = `logaddexp` over its members.
+- `resolve("Q")` returns `[vid]`. `i2t[vid] = "Q"`.
+- Anything that ranges over "real" symbols has to ignore virtual columns: `greedy_decode`, `_heard_hebrew`, the heatmap's "heard" track, and `edit_distance` for the unrelated check. Easiest is a `vocab.real(logp)` view of `logp[:, :V]`.
+
+### 1c. GOP (`app/align.py`, `score_tokens`)
+
+- `score_tokens(..., accept: list[set[int]] | None)`. For a class token, mask all its members from the competitor search, and always mask every virtual column.
+- Add `TokenScore.realised`: the member with the highest peak inside the window (`None` for plain tokens).
+- The alignment itself doesn't change. It already runs on the virtual column.
+
+### 1d. Results and display
+
+- Each phoneme entry gets `realised`. `heard` comes from the competitor as before, so an accepted realisation never shows up as "heard".
+- `_heard_hebrew`: when the frame is inside a class token's span and the greedy symbol is one of its members, write the **realised** letter (כּ, א or ק) uncoloured.
+- `to_hebrew` / `word_letters`: `Q` is written ק in the answer (today's ق rule already does this).
+- `app/tips.py`: add `Q` to `NO_DELETION_TIP` (6.3 #2). Remove the `ʔ>k` qaf tip.
+
+### 1e. Baseline and calibrations
+
+- References need no change. `Reference.sounds` now holds `(w, "Q")`, so the baseline is the same whatever realisation the TTS voice used. The cache is in memory and rebuilds on restart.
+- Calibration lookup in `score_logp`: try `(archi, heard)` first, then fall back to `(realised target, heard)` so existing DB rows still apply. Add a teacher-panel note or a one-off SQL to re-key `ʔ` rows that came from ق phrases.
+
+### 1f. Tests (`tests/test_scoring.py`)
+
+- Rewrite `test_k_for_urban_qaf_picks_closest_variant_and_tips`: `k` for `Q` scores ≥ 90, has no tip, and `realised == "k"`.
+- New tests:
+  - `q` for `Q` is accepted;
+  - `Q` dropped between vowels is not flagged;
+  - `ʔ` from ء said as `k` **is** flagged (e.g. اهلا → kahla);
+  - a reference voiced with `q` doesn't penalise a learner who says `ʔ`;
+  - `archify` on a sample of workbook phrases, plus the ambiguity test.
+
+## Phase 2: The other five abstract symbols
+
+- Extend `archify`: ك→`K`, ث→`TH`, ذ→`DH`, ظ→`ZH`, ج→`J`.
+- **Per-word override syntax** for learned words, e.g. `TH{t,s}` (ثقافة) or a plain `t` to lock it. Parse it in `tokenize`, which creates a one-off class for that position.
+- **Vocab gaps:** if `θ`, `ð`, `ðˤ` or `tʃ` aren't in the model, the class quietly shrinks. Log it, and expose it in `/api/health` under `rules` (section 7 of the rules doc).
+- Add `tʃ` (צ'), `θ` (ת'), `ð` (ד״) to `CONSONANTS` in `app/translit.py` so rural realisations can be written in the heard line.
+- Add `θ`, `ð`, `tʃ`, `ðˤ`, `dʒ` to the test vocab `SYMS`. Tests for each class, plus one mixed-dialect sentence that isn't penalised.
+
+## Phase 3: Positional classes and diphthongs
+
+- **`E`** for a final ة/ه vowel → {a, e, i}. Derived automatically from the Arabic ending (`word_letters` already detects it).
+- **`O`** for the vowel of a pronoun ending → {o, u}. This one needs an explicit marker in the phrase, because it can't be told reliably from the Arabic.
+- **`EY` / `OW`**: expand into extra **variants** (`eː` | `a j`, `oː` | `a w`) inside `archify`, before variants are merged. `_fit` already picks the best variant. These can't be a per-token class, because one token stands against two.
+- `near_vowels` stays for other positions until the vowel-length decision is made (see "Open decisions").
+- Sounds that natives also drop (ʔ at the start or between vowels, il- after a vowel) are **not** Layer A: an optional token would need a separate alignment with and without it. They stay as Layer B exemptions.
+
+## Phase 4: Layer B, the rule engine
+
+### 4a. Competitor set
+
+- Limit competitors to the Arabic sounds plus the Hebrew-interference sounds (every `heard:` symbol in `checks`). Report any other winner as `competitor=None, other=True` ("not clear").
+- **Watch out:** this lowers `comp_peak` in the deletion test (`deleted_comp`). Re-check the deletion tests.
+
+### 4b. Flagging by margin
+
+- In `score_logp`, flag a sound when `score < flag_below` **and** the competitor is outside the target's accepted set **and** `−gop ≥ margin(target, heard)`. `gop` is already `log P(target) − log P(competitor)`.
+- The issues list keeps its threshold (`issue_below`) but also respects the margin.
+
+### 4c. Feedback
+
+- `tip_for` looks up `checks[(target, heard)]` first, then falls back to `TIPS`. Keep the key format `expected>heard` so the front end doesn't change.
+- Sort tips by severity, then by score. `max_tips` comes from the rules file.
+
+### 4d. Exemptions (6.3)
+
+- Move `NO_DELETION_TIP`, `elided_article` and `near_vowels` into a predicate registry in `rules.py`: `(name, applies(toks, i, ar_words, sc) -> bool, action)`.
+- Add the doc's cases 1–3, 4 (il- not assimilated) and 12 (`mixed_dialect` as info only).
+
+### 4e. Letters that can only be heard, never expected
+
+- A `HEARD_ONLY` table in `translit.py`: `p`→פּ, `v`→ב/ו, `ts`→צ. Include it in `HEBREW_SOUNDS` so `_heard_hebrew` stops dropping these sounds. Today a student who says *pinjaan* sees the first letter missing instead of פּ.
+- `sound_name` / `letter_reason` labels come from `heard_labels`.
+- **Tests:** `f→p` (פִנְג'אן), `w→v`, `b→v`, `sˤ→ts`, `r→ʁ`. Emphatic just under the margin is not flagged, just over it is.
+
+## Phase 5: Teacher-facing parts
+
+- `dialects_enabled` / `optional_realisations_enabled` as teacher settings, stored wherever teacher settings live today. Pass them into `Scorer.score` per request, so different classes can differ.
+- The taught dialect only changes hints and info, never what's accepted.
+- Teacher panel: show `realised` and `mixed_dialect` in the diagnostics view. Show abstract symbols by their Hebrew letter, never as "Q".
+- `/api/health`: a `rules` field listing each rule and whether it can be detected.
+
+## Phase 6: Rollout check
+
+- If recordings are stored, add a `scripts/rescore.py` that compares old and new scores per phrase. Review the biggest changes before switching over, especially ק phrases and emphatics.
+- Ship Phase 1 on its own: it fixes ק/א and tests the class mechanism end to end.
+
+## Open decisions (outside this plan)
+
+1. **Vowel length:** the doc's `vowel_length` checks (severity 1, margin 1.1) vs. today's `near_vowel_floor`, which forgives length completely.
+2. **Sentence formula:** the doc's `mean(word_min)` and severity weights vs. today's 0.5/0.5 blend. Keep it behind a config flag until decided.
+3. **Bedouin `g` for `Q`:** on or off by default.
+4. **Extra sounds:** inserted sounds aren't detected, since forced alignment only scores expected sounds.
+
+## Main risks
+
+- The virtual columns change the `logp` width. Anything that indexes `logp` by a real id is fine, but anything that iterates over all columns (heatmap, greedy) must use the real-only view.
+- `archify` mismatches in the workbook. That's why the ambiguity test fails the build instead of guessing.
+- Old calibration rows keyed on `ʔ` until they're re-keyed. That's why the lookup falls back to the old key.
+
+## Implementation notes
+
+Code: `app/rules.py` (loader, detectability, exemptions), `app/archi.py` (symbols, letter alignment, diphthong variants), `app/phones.py` (`base()`, moved out of the scorer), `app/scorer.py` / `app/align.py` (classes, GOP, margins, tips), `scripts/rescore.py`. Tests: `tests/test_rules.py` and the "dialects and Hebrew-speaker rules" section of `tests/test_scoring.py`.
+
+Where it differs from the plan above:
+
+- **`archify` runs inside the scorer, not on `PHRASES`.** `Scorer._variants` converts each variant when scoring (cached). Display, TTS, transliteration and the verb game keep the plain IPA. Symbols replace phonemes one for one, so positions in the IPA still line up.
+- **Token format** is `SYMBOL:written` (`Q:ʔ`), or `SYMBOL{a,b}` for a hand-written set. A phrase that writes a symbol itself is left alone.
+- **Ambiguity:** across the bank (~11.6k variants) no ق is unresolved. 5 × ث merged with ت into one geminate (بعثت) and 1 × ج (جوز) stay plain phonemes; only an unresolved ق fails the test.
+- **Learned-only realisations** (`TH` as s, `DH` as z) are accepted where the phrase writes them, with no override syntax needed.
+- **Missing model symbols:** a class member the model lacks uses the same `FALLBACKS` stand-in as a plain phoneme. With the base model, `ZH` is `{dˤ, z}`, so "ظ heard as z" shows as `accepted` (undetectable) in `/api/health` → `rules`.
+- **Competitor naming (4a)** keeps the GOP against the strongest symbol of any kind, so scores and deletions don't change. Only the *name* is withheld (`other`) when that symbol isn't Arabic or a Hebrew-interference sound.
+- **Tips:** `max_tips` is now 3 (from the rules file), sorted by severity then score. Every tip carries `severity`.
+- **Results** gain `phonemes[].sound` (`Q`), `phonemes[].realised` (`k`), and `dialect: urban|rural` or `mixed_dialect: true`. None of them affect the score.
+- **Teacher view:** the expected/heard phone rows compare an accepted realisation with what was said, and show the dialect.
+
+Not done:
+
+- **Per-teacher dialect settings (Phase 5).** The accepted set comes from the rules file for everyone (`dialects_enabled`, `optional_realisations_enabled`). Since the taught dialect was only meant to change hints, nothing in scoring depends on it yet.
+- **Re-keying old calibration rows.** The lookup falls back to the written phoneme, so old rows keep working. Rows proposed from the page are still keyed on `phonemes[].ipa`.
+- **The open decisions** above (vowel length, sentence formula, Bedouin g, insertions) are unchanged. Vowel-length rules show as undetectable in `/api/health`.

requirements.txt

@@ -2,6 +2,7 @@ fastapi>=0.110
 uvicorn[standard]>=0.29
 python-multipart>=0.0.9
 numpy>=1.26
+pyyaml>=6.0  # the scorer reads its rules from the yaml blocks of static/assets/pronunciation-rules.md
 transformers>=4.41
 huggingface_hub>=0.23
 # torch: CPU build installed separately in the Dockerfile (see README for local installs)

scripts/rescore.py

@@ -0,0 +1,95 @@
+#!/usr/bin/env python3
+"""Rescore the flagged recordings with the current scorer and list the biggest changes against the stored score.
+
+Usage:  python scripts/rescore.py                          # every flag that kept its recording
+        python scripts/rescore.py --status pending,fixed   # only these review states
+        python scripts/rescore.py --limit 50 --top 20
+        python scripts/rescore.py --json out.json          # every row, with the old and new sound-level results
+
+Reads SUPABASE_URL, SUPABASE_PUBLISHABLE_KEY and SUPABASE_SECRET_KEY (as the server does) and MODEL_ID.
+A flag stores the phrase it was said for, its old result and the recording, so the comparison needs no
+other data. Run it before shipping a scoring change: the rows that moved most are the ones to listen to.
+"""
+from __future__ import annotations
+
+import argparse
+import json
+import os
+import sys
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).resolve().parent.parent))
+
+from dotenv import load_dotenv  # noqa: E402
+
+from app.auth import load_auth  # noqa: E402
+from app.phrases import PHRASES  # noqa: E402
+from app.scorer import decode_audio, load_scorer  # noqa: E402
+
+
+def phrase_for(row: dict) -> dict:
+    """The bank phrase a flag was said for, or (a verb-game or text line) the variant it was scored on."""
+    key = row.get("phrase")
+    for p in PHRASES:
+        if p.get("key", p["he"]) == key:
+            return p
+    return {"variants": [(row["ar"], row["ipa"])], "key": key, "he": row.get("he", ""), "cat": row.get("cat", "")}
+
+
+def sounds(result: dict) -> list[str]:
+    """The flagged sounds of a result, as 'ipa>heard'."""
+    return [f"{p.get('sound', p['ipa'])}>{p['heard']}" for w in result.get("words", []) for p in w.get("phonemes", [])
+            if p.get("flagged")]
+
+
+def main() -> int:
+    ap = argparse.ArgumentParser(description=__doc__.splitlines()[0])
+    ap.add_argument("--status", default="pending,confirmed,rejected,fixed")
+    ap.add_argument("--limit", type=int, default=0, help="at most this many flags (0: all)")
+    ap.add_argument("--top", type=int, default=30, help="rows to print, biggest change first")
+    ap.add_argument("--json", type=Path, help="write every row here")
+    args = ap.parse_args()
+
+    load_dotenv()
+    auth = load_auth()
+    if auth is None or not auth.secret:
+        print("needs SUPABASE_URL, SUPABASE_PUBLISHABLE_KEY and SUPABASE_SECRET_KEY", file=sys.stderr)
+        return 2
+    scorer = load_scorer(os.environ.get("MODEL_ID", "facebook/wav2vec2-xlsr-53-espeak-cv-ft"))
+    flags = [f for s in args.status.split(",") for f in auth.list_flags(s.strip()) if f.get("audio")]
+    if args.limit:
+        flags = flags[:args.limit]
+
+    rows = []
+    for f in flags:
+        audio = auth.flag_audio(f["id"])
+        if audio is None:
+            continue
+        try:
+            new = scorer.score(decode_audio(audio[0]), phrase_for(f))
+        except (ValueError, KeyError) as e:
+            print(f"flag {f['id']}: skipped ({e})", file=sys.stderr)
+            continue
+        if new.get("error"):
+            continue
+        old = f.get("result") or {}
+        rows.append({"id": f["id"], "status": f.get("status"), "phrase": f.get("he") or f.get("phrase"),
+                     "old": f.get("score"), "new": new["score"], "delta": new["score"] - (f.get("score") or 0),
+                     "old_flagged": sounds(old), "new_flagged": sounds(new),
+                     "dialect": "mixed" if new.get("mixed_dialect") else new.get("dialect", ""),
+                     "old_result": old, "new_result": new})
+
+    rows.sort(key=lambda r: -abs(r["delta"]))
+    print(f"{len(rows)} flags rescored; mean change {sum(r['delta'] for r in rows) / max(1, len(rows)):+.1f}")
+    for r in rows[:args.top]:
+        print(f"{r['id']:>6}  {r['status'] or '':<9} {r['old']!s:>4} -> {r['new']:>3} ({r['delta']:+4})  "
+              f"{r['dialect']:<6} {r['phrase']}")
+        if r["old_flagged"] != r["new_flagged"]:
+            print(f"        flagged: {' '.join(r['old_flagged']) or '-'}  ->  {' '.join(r['new_flagged']) or '-'}")
+    if args.json:
+        args.json.write_text(json.dumps(rows, ensure_ascii=False, indent=1), encoding="utf-8")
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

static/assets/arabic_verbs.json

@@ -0,0 +1,451 @@
+{
+  "alif": {
+    "source": {
+    "title": "פעלים בערבית מדוברת המתחילים באליף",
+    "url": "https://www.youtube.com/watch?v=c95B23kxOws",
+    "dialect": "Palestinian spoken Arabic",
+    "notes": "One entry per unique verb, in video order. The video repeats أبطل and أخذ. Phonemes use the scorer alphabet and are space-separated."
+    },
+    "verbs": [
+    {"hebrew": "בא", "timestamp": "01:03", "past": {"arabic": "اجا", "phonemes": "ʔ a dʒ a"}, "future": {"arabic": "يجي", "phonemes": "j i dʒ i"}},
+    {"hebrew": "לקח", "timestamp": "01:12", "past": {"arabic": "اخد", "phonemes": "ʔ a x a d"}, "future": {"arabic": "ياخد", "phonemes": "j oː x i d", "accepted_phonemes": ["j aː x u d", "j oː x u d"]}},
+    {"hebrew": "חייך", "timestamp": "01:21", "past": {"arabic": "ابتسم", "phonemes": "ʔ i b t a s a m"}, "future": {"arabic": "يبتسم", "phonemes": "j i b t a s i m"}},
+    {"hebrew": "דחה", "timestamp": "01:29", "past": {"arabic": "أجّل", "phonemes": "ʔ a dʒ dʒ a l"}, "future": {"arabic": "يأجّل", "phonemes": "j ʔ a dʒ dʒ i l"}},
+    {"hebrew": "השכיר", "timestamp": "01:39", "past": {"arabic": "أجّر", "phonemes": "ʔ a dʒ dʒ a r"}, "future": {"arabic": "يأجّر", "phonemes": "j ʔ a dʒ dʒ i r"}},
+    {"hebrew": "הדהים", "timestamp": "01:55", "past": {"arabic": "أدهش", "phonemes": "ʔ a d h a ʃ"}, "future": {"arabic": "يدهش", "phonemes": "j i d h a ʃ"}},
+    {"hebrew": "ירד", "timestamp": "02:03", "past": {"arabic": "انخفض", "phonemes": "ʔ i n x a f a dˤ"}, "future": {"arabic": "ينخفض", "phonemes": "j i n x a f i dˤ"}},
+    {"hebrew": "הדגיש", "timestamp": "02:13", "past": {"arabic": "أبرز", "phonemes": "ʔ a b r a z"}, "future": {"arabic": "يبرز", "phonemes": "j i b r u z"}},
+    {"hebrew": "נטרל, פירק", "timestamp": "02:21", "past": {"arabic": "أبطل", "phonemes": "ʔ a b tˤ a l"}, "future": {"arabic": "يبطل", "phonemes": "j i b tˤ a l"}},
+    {"hebrew": "אירח לחברה, ישב עם אורח כדי שלא יישאר לבד", "timestamp": "02:30", "past": {"arabic": "آنس", "phonemes": "ʔ aː n a s"}, "future": {"arabic": "يآنس", "phonemes": "j ʔ aː n i s"}},
+    {"hebrew": "התעניין, החשיב", "timestamp": "02:46", "past": {"arabic": "اهتمّ", "phonemes": "ʔ i h t a m m"}, "future": {"arabic": "يهتمّ", "phonemes": "j i h t a m m"}},
+    {"hebrew": "היה חלוק בדעתו", "timestamp": "02:52", "past": {"arabic": "اختلف", "phonemes": "ʔ i x t a l a f"}, "future": {"arabic": "يختلف", "phonemes": "j i x t a l i f"}},
+    {"hebrew": "בחר", "timestamp": "03:19", "past": {"arabic": "اختار", "phonemes": "ʔ i x t aː r"}, "future": {"arabic": "يختار", "phonemes": "j i x t aː r"}},
+    {"hebrew": "המציא", "timestamp": "03:28", "past": {"arabic": "اخترع", "phonemes": "ʔ i x t a r a ʕ"}, "future": {"arabic": "يخترع", "phonemes": "j i x t a r i ʕ"}},
+    {"hebrew": "גילה", "timestamp": "03:39", "past": {"arabic": "اكتشف", "phonemes": "ʔ i k t a ʃ a f"}, "future": {"arabic": "يكتشف", "phonemes": "j i k t a ʃ i f"}},
+    {"hebrew": "התחזה", "timestamp": "03:51", "past": {"arabic": "انتحل", "phonemes": "ʔ i n t a ħ a l"}, "future": {"arabic": "ينتحل", "phonemes": "j i n t a ħ i l"}},
+    {"hebrew": "נפצע", "timestamp": "04:00", "past": {"arabic": "انجرح", "phonemes": "ʔ i n dʒ a r a ħ"}, "future": {"arabic": "ينجرح", "phonemes": "j i n dʒ a r i ħ"}},
+    {"hebrew": "נדרס", "timestamp": "04:09", "past": {"arabic": "اندهس", "phonemes": "ʔ i n d a h a s"}, "future": {"arabic": "يندهس", "phonemes": "j i n d a h i s"}},
+    {"hebrew": "התהפך", "timestamp": "04:27", "past": {"arabic": "انقلب", "phonemes": "ʔ i n Q a l a b"}, "future": {"arabic": "ينقلب", "phonemes": "j i n Q a l i b"}},
+    {"hebrew": "עבר ממקום למקום", "timestamp": "04:35", "past": {"arabic": "انتقل", "phonemes": "ʔ i n t a Q a l"}, "future": {"arabic": "ينتقل", "phonemes": "j i n t a Q i l"}},
+    {"hebrew": "הבשיל", "timestamp": "04:45", "past": {"arabic": "استوى", "phonemes": "ʔ i s t a w a"}, "future": {"arabic": "يستوي", "phonemes": "j i s t a w i"}},
+    {"hebrew": "ייבא", "timestamp": "04:54", "past": {"arabic": "استورد", "phonemes": "ʔ i s t a w r a d"}, "future": {"arabic": "يستورد", "phonemes": "j i s t a w r i d"}},
+    {"hebrew": "חשב", "timestamp": "05:04", "past": {"arabic": "افتكر", "phonemes": "ʔ i f t a k a r"}, "future": {"arabic": "يفتكر", "phonemes": "j i f t a k i r"}},
+    {"hebrew": "עבד", "timestamp": "05:14", "past": {"arabic": "اشتغل", "phonemes": "ʔ i ʃ t a ɣ a l", "accepted_phonemes": ["ʔ a ʃ t ɣ i l", "ʔ a ʃ t i ɣ i l"]}, "future": {"arabic": "يشتغل", "phonemes": "j i ʃ t a ɣ i l"}},
+    {"hebrew": "ניצת, נדלק", "timestamp": "05:23", "past": {"arabic": "اشتعل", "phonemes": "ʔ i ʃ t a ʕ a l"}, "future": {"arabic": "يشتعل", "phonemes": "j i ʃ t a ʕ i l"}},
+    {"hebrew": "השתתף", "timestamp": "05:33", "past": {"arabic": "اشترك", "phonemes": "ʔ i ʃ t a r a k"}, "future": {"arabic": "يشترك", "phonemes": "j i ʃ t a r i k"}},
+    {"hebrew": "אימץ פתרון או קיבל החלטה", "timestamp": "05:42", "past": {"arabic": "اتّخذ", "phonemes": "ʔ i t t a x a d"}, "future": {"arabic": "يتّخذ", "phonemes": "j i t t a x i d"}},
+    {"hebrew": "נשען על חפץ", "timestamp": "05:54", "past": {"arabic": "اتّكأ", "phonemes": "ʔ i t t a k a ʔ"}, "future": {"arabic": "يتّكئ", "phonemes": "j i t t a k i ʔ"}},
+    {"hebrew": "הסכים", "timestamp": "06:07", "past": {"arabic": "اتّفق", "phonemes": "ʔ i t t a f a Q"}, "future": {"arabic": "يتّفق", "phonemes": "j i t t a f i Q"}},
+    {"hebrew": "התקשר", "timestamp": "06:15", "past": {"arabic": "اتّصل", "phonemes": "ʔ i t t a sˤ a l"}, "future": {"arabic": "يتّصل", "phonemes": "j i t t a sˤ i l"}},
+    {"hebrew": "התעייף", "timestamp": "06:24", "past": {"arabic": "اتعب", "phonemes": "ʔ i t ʕ a b"}, "future": {"arabic": "يتعب", "phonemes": "j i t ʕ a b"}},
+    {"hebrew": "עלה", "timestamp": "06:34", "past": {"arabic": "ارتفع", "phonemes": "ʔ i r t a f a ʕ"}, "future": {"arabic": "يرتفع", "phonemes": "j i r t a f i ʕ"}},
+    {"hebrew": "שיתף", "timestamp": "06:43", "past": {"arabic": "أشرك", "phonemes": "ʔ a ʃ r a k"}, "future": {"arabic": "يشرك", "phonemes": "j i ʃ r i k"}},
+    {"hebrew": "אלתר", "timestamp": "06:51", "past": {"arabic": "ارتجل", "phonemes": "ʔ i r t a dʒ a l"}, "future": {"arabic": "يرتجل", "phonemes": "j i r t a dʒ i l"}},
+    {"hebrew": "הרחיק", "timestamp": "07:08", "past": {"arabic": "أبعد", "phonemes": "ʔ a b ʕ a d"}, "future": {"arabic": "يبعد", "phonemes": "j i b ʕ i d"}},
+    {"hebrew": "הזניח", "timestamp": "07:19", "past": {"arabic": "أهمل", "phonemes": "ʔ a h m a l"}, "future": {"arabic": "يهمل", "phonemes": "j i h m i l"}},
+    {"hebrew": "איחר", "timestamp": "07:53", "past": {"arabic": "اتأخّر", "phonemes": "ʔ i t ʔ a x x a r"}, "future": {"arabic": "يتأخّر", "phonemes": "j i t ʔ a x x a r"}},
+    {"hebrew": "תמך ב־, אישר", "timestamp": "08:02", "past": {"arabic": "أكّد", "phonemes": "ʔ a k k a d"}, "future": {"arabic": "يأكّد", "phonemes": "j ʔ a k k i d"}},
+    {"hebrew": "אכל", "timestamp": "08:08", "past": {"arabic": "اكل", "phonemes": "ʔ a k a l"}, "future": {"arabic": "ياكل", "phonemes": "j oː k u l", "accepted_phonemes": ["j oː k i l", "j aː k u l"]}},
+    {"hebrew": "ציווה", "timestamp": "08:36", "past": {"arabic": "أمر", "phonemes": "ʔ a m a r"}, "future": {"arabic": "يأمر", "phonemes": "j ʔ a m u r"}},
+    {"hebrew": "נתן שהות", "timestamp": "08:40", "past": {"arabic": "أمهل", "phonemes": "ʔ a m h a l"}, "future": {"arabic": "يمهل", "phonemes": "j i m h i l"}},
+    {"hebrew": "סיים", "timestamp": "08:54", "past": {"arabic": "أنهى", "phonemes": "ʔ a n h a"}, "future": {"arabic": "ينهي", "phonemes": "j i n h i"}},
+    {"hebrew": "ייסד", "timestamp": "09:01", "past": {"arabic": "أسّس", "phonemes": "ʔ a s s a s"}, "future": {"arabic": "يأسّس", "phonemes": "j ʔ a s s i s"}},
+    {"hebrew": "שיכר", "timestamp": "09:10", "past": {"arabic": "أسكر", "phonemes": "ʔ a s k a r"}, "future": {"arabic": "يسكر", "phonemes": "j i s k i r"}},
+    {"hebrew": "מיהר", "timestamp": "09:24", "past": {"arabic": "أسرع", "phonemes": "ʔ a s r a ʕ"}, "future": {"arabic": "يسرع", "phonemes": "j i s r a ʕ"}},
+    {"hebrew": "נתן", "timestamp": "09:33", "past": {"arabic": "أعطى", "phonemes": "ʔ a ʕ tˤ a"}, "future": {"arabic": "يعطي", "phonemes": "j i ʕ tˤ i"}},
+    {"hebrew": "הדביק במחלה", "timestamp": "09:40", "past": {"arabic": "أعدى", "phonemes": "ʔ a ʕ d a"}, "future": {"arabic": "يعدي", "phonemes": "j i ʕ d i"}},
+    {"hebrew": "הכריז", "timestamp": "09:48", "past": {"arabic": "أعلن", "phonemes": "ʔ a ʕ l a n"}, "future": {"arabic": "يعلن", "phonemes": "j i ʕ l i n"}},
+    {"hebrew": "פטר", "timestamp": "09:56", "past": {"arabic": "أعفى", "phonemes": "ʔ a ʕ f a"}, "future": {"arabic": "يعفي", "phonemes": "j i ʕ f i"}},
+    {"hebrew": "עיוור, סינוור", "timestamp": "10:05", "past": {"arabic": "أعمى", "phonemes": "ʔ a ʕ m a"}, "future": {"arabic": "يعمي", "phonemes": "j i ʕ m i"}},
+    {"hebrew": "השביע את רצונו של", "timestamp": "10:12", "past": {"arabic": "أرضى", "phonemes": "ʔ a r dˤ a"}, "future": {"arabic": "يرضي", "phonemes": "j i r dˤ i"}},
+    {"hebrew": "סימן, אותת", "timestamp": "10:23", "past": {"arabic": "أشّر", "phonemes": "ʔ a ʃ ʃ a r"}, "future": {"arabic": "يأشّر", "phonemes": "j ʔ a ʃ ʃ i r"}},
+    {"hebrew": "השפיע", "timestamp": "10:32", "past": {"arabic": "أثّر", "phonemes": "ʔ a TH TH a r"}, "future": {"arabic": "يأثّر", "phonemes": "j ʔ a TH TH i r"}},
+    {"hebrew": "השלים בין, תיקן", "timestamp": "10:41", "past": {"arabic": "أصلح", "phonemes": "ʔ a sˤ l a ħ"}, "future": {"arabic": "يصلح", "phonemes": "j i sˤ l i ħ"}}
+    ]
+  },
+  "ba": {
+    "source": {
+      "title": "פעלים שימושיים בערבית מדוברת — אות בא",
+      "url": "https://www.youtube.com/watch?v=w19b7mJ-j4U",
+      "dialect": "Palestinian spoken Arabic",
+      "notes": "One entry per verb, in video order. Phonemes use the scorer alphabet and are space-separated."
+    },
+    "verbs": [
+      {"hebrew": "התחיל", "timestamp": "01:39", "past": {"arabic": "بدأ", "phonemes": "b a d a ʔ"}, "future": {"arabic": "يبدأ", "phonemes": "j i b d a ʔ"}},
+      {"hebrew": "בכה", "timestamp": "01:48", "past": {"arabic": "بكى", "phonemes": "b a k a"}, "future": {"arabic": "يبكي", "phonemes": "j i b k i"}},
+      {"hebrew": "נשאר", "timestamp": "01:57", "past": {"arabic": "بقي", "phonemes": "b a Q i"}, "future": {"arabic": "يبقى", "phonemes": "j i b Q a"}},
+      {"hebrew": "מכר", "timestamp": "02:06", "past": {"arabic": "باع", "phonemes": "b aː ʕ"}, "future": {"arabic": "يبيع", "phonemes": "j i b iː ʕ"}},
+      {"hebrew": "אירח מישהו כל הלילה", "timestamp": "02:17", "past": {"arabic": "بات", "phonemes": "b aː t"}, "future": {"arabic": "يبيت", "phonemes": "j i b iː t"}},
+      {"hebrew": "נזף, דיבר בצורה קשה", "timestamp": "02:26", "past": {"arabic": "بهدل", "phonemes": "b a h d a l"}, "future": {"arabic": "يبهدل", "phonemes": "j i b a h d i l"}},
+      {"hebrew": "החליף, שינה", "timestamp": "02:36", "past": {"arabic": "بدّل", "phonemes": "b a d d a l"}, "future": {"arabic": "يبدّل", "phonemes": "j i b a d d i l"}},
+      {"hebrew": "חפר באדמה", "timestamp": "02:46", "past": {"arabic": "بحش", "phonemes": "b a ħ a ʃ"}, "future": {"arabic": "يبحش", "phonemes": "j i b ħ a ʃ"}},
+      {"hebrew": "סיווג", "timestamp": "02:56", "past": {"arabic": "بوّب", "phonemes": "b a w w a b"}, "future": {"arabic": "يبوّب", "phonemes": "j i b a w w i b"}},
+      {"hebrew": "הפסיק, חזר בו", "timestamp": "03:06", "past": {"arabic": "بطّل", "phonemes": "b a tˤ tˤ a l"}, "future": {"arabic": "يبطّل", "phonemes": "j i b a tˤ tˤ i l"}},
+      {"hebrew": "הופיע, נמצא", "timestamp": "03:15", "past": {"arabic": "بيّن", "phonemes": "b a j j a n"}, "future": {"arabic": "يبيّن", "phonemes": "j i b a j j i n"}},
+      {"hebrew": "הודיע", "timestamp": "03:25", "past": {"arabic": "بلّغ", "phonemes": "b a l l a ɣ"}, "future": {"arabic": "يبلّغ", "phonemes": "j i b a l l i ɣ"}},
+      {"hebrew": "בלע", "timestamp": "03:38", "past": {"arabic": "بلع", "phonemes": "b a l a ʕ"}, "future": {"arabic": "يبلع", "phonemes": "j i b l a ʕ"}},
+      {"hebrew": "התחיל", "timestamp": "03:44", "past": {"arabic": "بلّش", "phonemes": "b a l l a ʃ"}, "future": {"arabic": "يبلّش", "phonemes": "j i b a l l i ʃ"}},
+      {"hebrew": "בכה בקול, יילל", "timestamp": "04:05", "past": {"arabic": "بعق", "phonemes": "b a ʕ a Q"}, "future": {"arabic": "يبعق", "phonemes": "j i b ʕ a Q"}},
+      {"hebrew": "פיזר וגם בזבז", "timestamp": "04:14", "past": {"arabic": "بعتر", "phonemes": "b a ʕ t a r"}, "future": {"arabic": "يبعتر", "phonemes": "j i b a ʕ t i r"}},
+      {"hebrew": "בנה", "timestamp": "04:23", "past": {"arabic": "بنى", "phonemes": "b a n a"}, "future": {"arabic": "يبني", "phonemes": "j i b n i"}},
+      {"hebrew": "הצדיק", "timestamp": "04:30", "past": {"arabic": "برّر", "phonemes": "b a r r a r"}, "future": {"arabic": "يبرّر", "phonemes": "j i b a r r i r"}},
+      {"hebrew": "כיער", "timestamp": "04:37", "past": {"arabic": "بشّع", "phonemes": "b a ʃ ʃ a ʕ"}, "future": {"arabic": "يبشّع", "phonemes": "j i b a ʃ ʃ i ʕ"}},
+      {"hebrew": "תכנת", "timestamp": "04:47", "past": {"arabic": "برمج", "phonemes": "b a r m a dʒ"}, "future": {"arabic": "يبرمج", "phonemes": "j i b a r m i dʒ"}},
+      {"hebrew": "שיחד", "timestamp": "05:11", "past": {"arabic": "برطل", "phonemes": "b a r tˤ a l"}, "future": {"arabic": "يبرطل", "phonemes": "j i b a r tˤ i l"}}
+    ]
+  },
+  "jim": {
+    "source": {"title": "פעלים שימושיים בערבית מדוברת — אות ג'ים", "url": "https://www.youtube.com/watch?v=A90bTU8w3BY", "dialect": "Palestinian spoken Arabic"},
+    "verbs": [
+      {"hebrew":"הביא","past":{"arabic":"جاب","phonemes":"J aː b"},"future":{"arabic":"يجيب","phonemes":"j i J iː b"}},
+      {"hebrew":"ענה","past":{"arabic":"جاوب","phonemes":"J aː w a b"},"future":{"arabic":"يجاوب","phonemes":"j i J aː w i b"}},
+      {"hebrew":"גרר, סחב","past":{"arabic":"جرجر","phonemes":"J a r J a r"},"future":{"arabic":"يجرجر","phonemes":"j i J a r J i r"}},
+      {"hebrew":"ניסה","past":{"arabic":"جرّب","phonemes":"J a r r a b"},"future":{"arabic":"يجرّب","phonemes":"j i J a r r i b"}},
+      {"hebrew":"הקפיא","past":{"arabic":"جمّد","phonemes":"J a m m a d"},"future":{"arabic":"يجمّد","phonemes":"j i J a m m i d"}},
+      {"hebrew":"ייבש","past":{"arabic":"جفّف","phonemes":"J a f f a f"},"future":{"arabic":"يجفّف","phonemes":"j i J a f f i f"}},
+      {"hebrew":"חידש","past":{"arabic":"جدّد","phonemes":"J a d d a d"},"future":{"arabic":"يجدّد","phonemes":"j i J a d d i d"}},
+      {"hebrew":"רץ, קרה, זרם","past":{"arabic":"جرى","phonemes":"J a r a"},"future":{"arabic":"يجري","phonemes":"j i J r i"}},
+      {"hebrew":"גמל, העניש","past":{"arabic":"جازى","phonemes":"J aː z a"},"future":{"arabic":"يجازي","phonemes":"j i J aː z i"}},
+      {"hebrew":"גרר, סחב","past":{"arabic":"جرّ","phonemes":"J a r r"},"future":{"arabic":"يجرّ","phonemes":"j i J u r r"}}
+    ]
+  },
+  "dal": {
+    "source": {"title":"פעלים שימושיים בערבית מדוברת — אות דאל","url":"https://www.youtube.com/watch?v=Wu2oeHyKujo","dialect":"Palestinian spoken Arabic"},
+    "verbs": [
+      {"hebrew":"אבד","past":{"arabic":"ضاع","phonemes":"dˤ aː ʕ"},"future":{"arabic":"يضيع","phonemes":"j i dˤ iː ʕ"}},
+      {"hebrew":"סידר, הסדיר","past":{"arabic":"دبّر","phonemes":"d a b b a r"},"future":{"arabic":"يدبّر","phonemes":"j i d a b b i r"}},
+      {"hebrew":"צבע","past":{"arabic":"دهن","phonemes":"d a h a n"},"future":{"arabic":"يدهن","phonemes":"j i d h a n"}},
+      {"hebrew":"דרס","past":{"arabic":"دهس","phonemes":"d a h a s"},"future":{"arabic":"يدهس","phonemes":"j i d h a s"}},
+      {"hebrew":"חיפש","past":{"arabic":"دوّر على","phonemes":"d a w w a r ʕ a l a"},"future":{"arabic":"يدوّر على","phonemes":"j i d a w w i r ʕ a l a"}},
+      {"hebrew":"עישן","past":{"arabic":"دخّن","phonemes":"d a x x a n"},"future":{"arabic":"يدخّن","phonemes":"j i d a x x i n"}},
+      {"hebrew":"הצביע על, הראה","past":{"arabic":"دلّ على","phonemes":"d a l l ʕ a l a"},"future":{"arabic":"يدلّ على","phonemes":"j i d u l l ʕ a l a"}},
+      {"hebrew":"שילם, דחף","past":{"arabic":"دفع","phonemes":"d a f a ʕ"},"future":{"arabic":"يدفع","phonemes":"j i d f a ʕ"}},
+      {"hebrew":"דפק","past":{"arabic":"دقّ","phonemes":"d a Q Q"},"future":{"arabic":"يدقّ","phonemes":"j i d u Q Q"}},
+      {"hebrew":"עזב, נטש","past":{"arabic":"دشّر","phonemes":"d a ʃ ʃ a r"},"future":{"arabic":"يدشّر","phonemes":"j i d a ʃ ʃ i r"}},
+      {"hebrew":"סובב, הפנה","past":{"arabic":"دار","phonemes":"d aː r"},"future":{"arabic":"يدير","phonemes":"j i d iː r"}}
+    ]
+  },
+  "ha": {
+    "source": {"title":"פעלים שימושיים בערבית מדוברת — אות ה","url":"https://www.youtube.com/watch?v=le--lfAYjgE","dialect":"Palestinian spoken Arabic"},
+    "verbs": [
+      {"hebrew":"ברח","past":{"arabic":"هرب","phonemes":"h a r a b"},"future":{"arabic":"يهرب","phonemes":"j i h r a b"}},
+      {"hebrew":"היגר","past":{"arabic":"هاجر","phonemes":"h aː J a r"},"future":{"arabic":"يهاجر","phonemes":"j i h aː J i r"}},
+      {"hebrew":"הגלה, גרם להגר","past":{"arabic":"هجّر","phonemes":"h a J J a r"},"future":{"arabic":"يهجّر","phonemes":"j i h a J J i r"}},
+      {"hebrew":"נפל, ירד","past":{"arabic":"هبط","phonemes":"h a b a tˤ"},"future":{"arabic":"يهبط","phonemes":"j i h b a tˤ"}},
+      {"hebrew":"הוריד, החליש","past":{"arabic":"هبّط","phonemes":"h a b b a tˤ"},"future":{"arabic":"يهبّط","phonemes":"j i h a b b i tˤ"}},
+      {"hebrew":"התכוון, שאף","past":{"arabic":"هدف","phonemes":"h a d a f"},"future":{"arabic":"يهدف","phonemes":"j i h d a f"}},
+      {"hebrew":"בירך","past":{"arabic":"هنّى","phonemes":"h a n n a"},"future":{"arabic":"يهنّي","phonemes":"j i h a n n i"}},
+      {"hebrew":"הריע, קרא","past":{"arabic":"هتف","phonemes":"h a t a f"},"future":{"arabic":"يهتف","phonemes":"j i h t i f"}}
+    ]
+  },
+  "waw": {
+    "source": {"title":"פעלים שימושיים בערבית מדוברת — אות ואו","url":"https://www.youtube.com/watch?v=r5nOxemdyMI","dialect":"Palestinian spoken Arabic"},
+    "verbs": [
+      {"hebrew":"מצא","past":{"arabic":"وجد","phonemes":"w a J a d"},"future":{"arabic":"يجد","phonemes":"j i J i d"}},
+      {"hebrew":"הביא למקום","past":{"arabic":"ودّى","phonemes":"w a d d a"},"future":{"arabic":"يودّي","phonemes":"j i w a d d i"}},
+      {"hebrew":"נפרד","past":{"arabic":"ودّع","phonemes":"w a d d a ʕ"},"future":{"arabic":"يودّع","phonemes":"j i w a d d i ʕ"}},
+      {"hebrew":"מינה, הסמיך","past":{"arabic":"وكّل","phonemes":"w a k k a l"},"future":{"arabic":"يوكّل","phonemes":"j i w a k k i l"}},
+      {"hebrew":"עצר, עמד","past":{"arabic":"وقف","phonemes":"w a Q a f"},"future":{"arabic":"يوقف","phonemes":"j i w Q a f"}},
+      {"hebrew":"ייבא","past":{"arabic":"ورّد","phonemes":"w a r r a d"},"future":{"arabic":"يورّد","phonemes":"j i w a r r i d"}},
+      {"hebrew":"הנמיך","past":{"arabic":"وطّى","phonemes":"w a tˤ tˤ a"},"future":{"arabic":"يوطّي","phonemes":"j i w a tˤ tˤ i"}},
+      {"hebrew":"חיבר, הוביל, הביא","past":{"arabic":"وصّل","phonemes":"w a sˤ sˤ a l"},"future":{"arabic":"يوصّل","phonemes":"j i w a sˤ sˤ i l"}}
+    ]
+  },
+  "zay": {
+    "source": {"title":"פעלים שימושיים בערבית מדוברת — אות זאי","url":"https://www.youtube.com/watch?v=Qgal8RB1N00","dialect":"Palestinian spoken Arabic"},
+    "verbs": [
+      {"hebrew":"כעס, התרגז","past":{"arabic":"زعل","phonemes":"z a ʕ a l"},"future":{"arabic":"يزعل","phonemes":"j i z ʕ a l"}},
+      {"hebrew":"זז, הסיר","past":{"arabic":"زاح","phonemes":"z aː ħ"},"future":{"arabic":"يزيح","phonemes":"j i z iː ħ"}},
+      {"hebrew":"סיפק, צייד","past":{"arabic":"زوّد","phonemes":"z a w w a d"},"future":{"arabic":"يزوّد","phonemes":"j i z a w w i d"}},
+      {"hebrew":"צפר","past":{"arabic":"زمّر","phonemes":"z a m m a r"},"future":{"arabic":"يزمّر","phonemes":"j i z a m m i r"}},
+      {"hebrew":"הוסיף, גדל","past":{"arabic":"زاد","phonemes":"z aː d"},"future":{"arabic":"يزيد","phonemes":"j i z iː d"}},
+      {"hebrew":"ביקר","past":{"arabic":"زار","phonemes":"z aː r"},"future":{"arabic":"يزور","phonemes":"j i z uː r"}},
+      {"hebrew":"הזכיר, ציטט","past":{"arabic":"ذكر","phonemes":"DH a k a r"},"future":{"arabic":"يذكر","phonemes":"j i DH k u r"}},
+      {"hebrew":"הזכיר למישהו","past":{"arabic":"ذكّر","phonemes":"DH a k k a r"},"future":{"arabic":"يذكّر","phonemes":"j i DH a k k i r"}},
+      {"hebrew":"דחף","past":{"arabic":"زقّ","phonemes":"z a Q Q"},"future":{"arabic":"يزقّ","phonemes":"j i z u Q Q"}},
+      {"hebrew":"זייף","past":{"arabic":"زيّف","phonemes":"z a j j a f"},"future":{"arabic":"يزيّف","phonemes":"j i z a j j i f"}},
+      {"hebrew":"שחט","past":{"arabic":"ذبح","phonemes":"DH a b a ħ"},"future":{"arabic":"يذبح","phonemes":"j i DH b a ħ"}},
+      {"hebrew":"נמאס לו","past":{"arabic":"زهق","phonemes":"z a h a Q"},"future":{"arabic":"يزهق","phonemes":"j i z h a Q"}},
+      {"hebrew":"החליק, גרם להחליק","past":{"arabic":"زحلق","phonemes":"z a ħ l a Q"},"future":{"arabic":"يزحلق","phonemes":"j i z a ħ l i Q"}}
+    ]
+  },
+  "kha": {
+    "source": {"title":"פעלים שימושיים בערבית מדוברת — אות ח'א","url":"https://www.youtube.com/watch?v=RJnw8Bjtvlg","dialect":"Palestinian spoken Arabic"},
+    "verbs": [
+      {"hebrew":"בגד","past":{"arabic":"خان","phonemes":"x aː n"},"future":{"arabic":"يخون","phonemes":"j i x uː n"}},
+      {"hebrew":"נגמר, הסתיים","past":{"arabic":"خلص","phonemes":"x a l a sˤ"},"future":{"arabic":"يخلص","phonemes":"j i x l a sˤ"}},
+      {"hebrew":"הפסיד","past":{"arabic":"خسر","phonemes":"x a s a r"},"future":{"arabic":"يخسر","phonemes":"j i x s a r"}},
+      {"hebrew":"התקלקל","past":{"arabic":"خرب","phonemes":"x a r a b"},"future":{"arabic":"يخرب","phonemes":"j i x r a b"}},
+      {"hebrew":"פחד","past":{"arabic":"خاف","phonemes":"x aː f"},"future":{"arabic":"يخاف","phonemes":"j i x aː f"}},
+      {"hebrew":"הודיע, סיפר","past":{"arabic":"خبّر","phonemes":"x a b b a r"},"future":{"arabic":"يخبّر","phonemes":"j i x a b b i r"}},
+      {"hebrew":"אחסן","past":{"arabic":"خزّن","phonemes":"x a z z a n"},"future":{"arabic":"يخزّن","phonemes":"j i x a z z i n"}},
+      {"hebrew":"התבייש","past":{"arabic":"خجل","phonemes":"x a J a l"},"future":{"arabic":"يخجل","phonemes":"j i x J a l"}},
+      {"hebrew":"השאיר, נטש","past":{"arabic":"خلّى","phonemes":"x a l l a"},"future":{"arabic":"يخلّي","phonemes":"j i x a l l i"}},
+      {"hebrew":"השאיר אחריו, הוליד","past":{"arabic":"خلّف","phonemes":"x a l l a f"},"future":{"arabic":"يخلّف","phonemes":"j i x a l l i f"}},
+      {"hebrew":"יצר, ברא","past":{"arabic":"خلق","phonemes":"x a l a Q"},"future":{"arabic":"يخلق","phonemes":"j i x l a Q"}},
+      {"hebrew":"הפחית","past":{"arabic":"خفّف","phonemes":"x a f f a f"},"future":{"arabic":"يخفّف","phonemes":"j i x a f f i f"}},
+      {"hebrew":"התערבב, התחבר","past":{"arabic":"خالط","phonemes":"x aː l a tˤ"},"future":{"arabic":"يخالط","phonemes":"j i x aː l i tˤ"}},
+      {"hebrew":"אכזב","past":{"arabic":"خيّب","phonemes":"x a j j a b"},"future":{"arabic":"يخيّب","phonemes":"j i x a j j i b"}},
+      {"hebrew":"חתם","past":{"arabic":"ختم","phonemes":"x a t a m"},"future":{"arabic":"يختم","phonemes":"j i x t i m"}},
+      {"hebrew":"קלקל","past":{"arabic":"خرّب","phonemes":"x a r r a b"},"future":{"arabic":"يخرّب","phonemes":"j i x a r r i b"}},
+      {"hebrew":"יצא","past":{"arabic":"خرج","phonemes":"x a r a J"},"future":{"arabic":"يخرج","phonemes":"j i x r a J"}},
+      {"hebrew":"נשא נאום","past":{"arabic":"خطب","phonemes":"x a tˤ a b"},"future":{"arabic":"يخطب","phonemes":"j i x tˤ a b"}}
+    ]
+  },
+  "ta_emphatic": {
+    "source":{"title":"פעלים שימושיים בערבית מדוברת — אות טא","url":"https://www.youtube.com/watch?v=qYeEWydByZU","dialect":"Palestinian spoken Arabic"},
+    "verbs":[
+      {"hebrew":"נרפא, היה טוב","past":{"arabic":"طاب","phonemes":"tˤ aː b"},"future":{"arabic":"يطيب","phonemes":"j i tˤ iː b"}},
+      {"hebrew":"הדפיס","past":{"arabic":"طبع","phonemes":"tˤ a b a ʕ"},"future":{"arabic":"يطبع","phonemes":"j i tˤ b a ʕ"}},
+      {"hebrew":"האריך, התעכב","past":{"arabic":"طوّل","phonemes":"tˤ a w w a l"},"future":{"arabic":"يطوّل","phonemes":"j i tˤ a w w i l"}},
+      {"hebrew":"דרש, ביקש","past":{"arabic":"طلب","phonemes":"tˤ a l a b"},"future":{"arabic":"يطلب","phonemes":"j i tˤ l a b"}},
+      {"hebrew":"האכיל","past":{"arabic":"طعّم","phonemes":"tˤ a ʕ ʕ a m"},"future":{"arabic":"يطعّم","phonemes":"j i tˤ a ʕ ʕ i m"}},
+      {"hebrew":"היה מסוגל לסבול","past":{"arabic":"طاق","phonemes":"tˤ aː Q"},"future":{"arabic":"يطيق","phonemes":"j i tˤ iː Q"}},
+      {"hebrew":"הרגיע","past":{"arabic":"طمّن","phonemes":"tˤ a m m a n"},"future":{"arabic":"يطمّن","phonemes":"j i tˤ a m m i n"}},
+      {"hebrew":"פיצח","past":{"arabic":"طقش","phonemes":"tˤ a Q a ʃ"},"future":{"arabic":"يطقش","phonemes":"j i tˤ Q a ʃ"}},
+      {"hebrew":"התעלם","past":{"arabic":"طنّش","phonemes":"tˤ a n n a ʃ"},"future":{"arabic":"يطنّش","phonemes":"j i tˤ a n n i ʃ"}},
+      {"hebrew":"עף","past":{"arabic":"طار","phonemes":"tˤ aː r"},"future":{"arabic":"يطير","phonemes":"j i tˤ iː r"}},
+      {"hebrew":"רדף","past":{"arabic":"طارد","phonemes":"tˤ aː r a d"},"future":{"arabic":"يطارد","phonemes":"j i tˤ aː r i d"}},
+      {"hebrew":"כיבה","past":{"arabic":"طفّى","phonemes":"tˤ a f f a"},"future":{"arabic":"يطفّي","phonemes":"j i tˤ a f f i"}},
+      {"hebrew":"יישם","past":{"arabic":"طبّق","phonemes":"tˤ a b b a Q"},"future":{"arabic":"يطبّق","phonemes":"j i tˤ a b b i Q"}},
+      {"hebrew":"הציץ, ביקר","past":{"arabic":"طلّ","phonemes":"tˤ a l l"},"future":{"arabic":"يطلّ","phonemes":"j i tˤ u l l"}},
+      {"hebrew":"שאף","past":{"arabic":"طمح","phonemes":"tˤ a m a ħ"},"future":{"arabic":"يطمح","phonemes":"j i tˤ m a ħ"}},
+      {"hebrew":"התיז","past":{"arabic":"طرّش","phonemes":"tˤ a r r a ʃ"},"future":{"arabic":"يطرّش","phonemes":"j i tˤ a r r i ʃ"}}
+    ]
+  },
+  "kaf": {
+    "source":{"title":"פעלים שימושיים בערבית מדוברת — אות כאף","url":"https://www.youtube.com/watch?v=wSoGsCXTyig","dialect":"Palestinian spoken Arabic"},
+    "verbs":[
+      {"hebrew":"יצר, הרכיב","past":{"arabic":"كوّن","phonemes":"k a w w a n"},"future":{"arabic":"يكوّن","phonemes":"j i k a w w i n"}},
+      {"hebrew":"המשיך, השלים","past":{"arabic":"كمّل","phonemes":"k a m m a l"},"future":{"arabic":"يكمّل","phonemes":"j i k a m m i l"}},
+      {"hebrew":"טאטא","past":{"arabic":"كنس","phonemes":"k a n a s"},"future":{"arabic":"يكنس","phonemes":"j i k n u s"}},
+      {"hebrew":"שפך","past":{"arabic":"كبّ","phonemes":"k a b b"},"future":{"arabic":"يكبّ","phonemes":"j i k u b b"}},
+      {"hebrew":"חרק שיניים","past":{"arabic":"كدّ","phonemes":"k a d d"},"future":{"arabic":"يكدّ","phonemes":"j i k u d d"}},
+      {"hebrew":"עלה במחיר","past":{"arabic":"كلّف","phonemes":"k a l l a f"},"future":{"arabic":"يكلّف","phonemes":"j i k a l l i f"}},
+      {"hebrew":"גדל","past":{"arabic":"كبر","phonemes":"k a b a r"},"future":{"arabic":"يكبر","phonemes":"j i k b a r"}},
+      {"hebrew":"קימט את המצח","past":{"arabic":"كشّر","phonemes":"k a ʃ ʃ a r"},"future":{"arabic":"يكشّر","phonemes":"j i k a ʃ ʃ i r"}},
+      {"hebrew":"שבר","past":{"arabic":"كسر","phonemes":"k a s a r"},"future":{"arabic":"يكسر","phonemes":"j i k s a r"}},
+      {"hebrew":"כתב","past":{"arabic":"كتب","phonemes":"k a t a b"},"future":{"arabic":"يكتب","phonemes":"j i k t u b"}},
+      {"hebrew":"צבר","past":{"arabic":"كدّس","phonemes":"k a d d a s"},"future":{"arabic":"يكدّس","phonemes":"j i k a d d i s"}},
+      {"hebrew":"עשה בלגן","past":{"arabic":"كركب","phonemes":"k a r k a b"},"future":{"arabic":"يكركب","phonemes":"j i k a r k i b"}},
+      {"hebrew":"חזר על","past":{"arabic":"كرّر","phonemes":"k a r r a r"},"future":{"arabic":"يكرّر","phonemes":"j i k a r r i r"}},
+      {"hebrew":"גירש","past":{"arabic":"كشّ","phonemes":"k a ʃ ʃ"},"future":{"arabic":"يكشّ","phonemes":"j i k u ʃ ʃ"}}
+    ]
+  },
+  "lam": {
+    "source":{"title":"פעלים שימושיים בערבית מדוברת — אות לאם","url":"https://www.youtube.com/watch?v=-Jd2w7EEs90","dialect":"Palestinian spoken Arabic"},
+    "verbs":[
+      {"hebrew":"צופף","past":{"arabic":"لزّ","phonemes":"l a z z"},"future":{"arabic":"يلزّ","phonemes":"j i l u z z"}},
+      {"hebrew":"עקץ, הכיש, צרב","past":{"arabic":"لسع","phonemes":"l a s a ʕ"},"future":{"arabic":"يلسع","phonemes":"j i l s a ʕ"}},
+      {"hebrew":"הפציר","past":{"arabic":"لحّ","phonemes":"l a ħ ħ"},"future":{"arabic":"يلحّ","phonemes":"j i l i ħ ħ"}},
+      {"hebrew":"אסף","past":{"arabic":"لمّ","phonemes":"l a m m"},"future":{"arabic":"يلمّ","phonemes":"j i l u m m"}},
+      {"hebrew":"האשים, גינה","past":{"arabic":"لام","phonemes":"l aː m"},"future":{"arabic":"يلوم","phonemes":"j i l uː m"}},
+      {"hebrew":"לימד בשינון","past":{"arabic":"لقّن","phonemes":"l a Q Q a n"},"future":{"arabic":"يلقّن","phonemes":"j i l a Q Q i n"}},
+      {"hebrew":"מילא בקשה","past":{"arabic":"لبّى","phonemes":"l a b b a"},"future":{"arabic":"يلبّي","phonemes":"j i l a b b i"}},
+      {"hebrew":"לבש","past":{"arabic":"لبس","phonemes":"l a b a s"},"future":{"arabic":"يلبس","phonemes":"j i l b a s"}},
+      {"hebrew":"הלביש","past":{"arabic":"لبّس","phonemes":"l a b b a s"},"future":{"arabic":"يلبّس","phonemes":"j i l a b b i s"}},
+      {"hebrew":"טייח, העלים","past":{"arabic":"لفلف","phonemes":"l a f l a f"},"future":{"arabic":"يلفلف","phonemes":"j i l a f l i f"}},
+      {"hebrew":"סטר","past":{"arabic":"لطش","phonemes":"l a tˤ a ʃ"},"future":{"arabic":"يلطش","phonemes":"j i l tˤ a ʃ"}},
+      {"hebrew":"רמז","past":{"arabic":"لمّح","phonemes":"l a m m a ħ"},"future":{"arabic":"يلمّح","phonemes":"j i l a m m i ħ"}}
+    ]
+  },
+  "mim": {
+    "source":{"title":"פעלים שימושיים בערבית מדוברת — אות מים","url":"https://www.youtube.com/watch?v=yKUcU45Ngpg","dialect":"Palestinian spoken Arabic"},
+    "verbs":[
+      {"hebrew":"דחה ועיכב","past":{"arabic":"ماطل","phonemes":"m aː tˤ a l"},"future":{"arabic":"يماطل","phonemes":"j i m aː tˤ i l"}},
+      {"hebrew":"עסק ב־, הפעיל","past":{"arabic":"مارس","phonemes":"m aː r a s"},"future":{"arabic":"يمارس","phonemes":"j i m aː r i s"}},
+      {"hebrew":"מת","past":{"arabic":"مات","phonemes":"m aː t"},"future":{"arabic":"يموت","phonemes":"j i m uː t"}},
+      {"hebrew":"מימן","past":{"arabic":"موّل","phonemes":"m a w w a l"},"future":{"arabic":"يموّل","phonemes":"j i m a w w i l"}},
+      {"hebrew":"קרע לגזרים","past":{"arabic":"مزّع","phonemes":"m a z z a ʕ"},"future":{"arabic":"يمزّع","phonemes":"j i m a z z i ʕ"}},
+      {"hebrew":"הבחין בין","past":{"arabic":"ميّز","phonemes":"m a j j a z"},"future":{"arabic":"يميّز","phonemes":"j i m a j j i z"}},
+      {"hebrew":"מילא","past":{"arabic":"ملا","phonemes":"m a l a"},"future":{"arabic":"يملي","phonemes":"j i m l i"}},
+      {"hebrew":"שיבח","past":{"arabic":"مدح","phonemes":"m a d a ħ"},"future":{"arabic":"يمدح","phonemes":"j i m d a ħ"}},
+      {"hebrew":"סיפק","past":{"arabic":"موّن","phonemes":"m a w w a n"},"future":{"arabic":"يموّن","phonemes":"j i m a w w i n"}},
+      {"hebrew":"שטף, היה בעלים","past":{"arabic":"ملك","phonemes":"m a l a k"},"future":{"arabic":"يملك","phonemes":"j i m l u k"}},
+      {"hebrew":"ליטף, החליק","past":{"arabic":"ملّس","phonemes":"m a l l a s"},"future":{"arabic":"يملّس","phonemes":"j i m a l l i s"}},
+      {"hebrew":"העניק","past":{"arabic":"منح","phonemes":"m a n a ħ"},"future":{"arabic":"يمنح","phonemes":"j i m n a ħ"}},
+      {"hebrew":"מנע, אסר","past":{"arabic":"منع","phonemes":"m a n a ʕ"},"future":{"arabic":"يمنع","phonemes":"j i m n a ʕ"}},
+      {"hebrew":"מצץ","past":{"arabic":"مصّ","phonemes":"m a sˤ sˤ"},"future":{"arabic":"يمصّ","phonemes":"j i m u sˤ sˤ"}},
+      {"hebrew":"העמיד פנים","past":{"arabic":"مثّل","phonemes":"m a TH TH a l"},"future":{"arabic":"يمثّل","phonemes":"j i m a TH TH i l"}},
+      {"hebrew":"ערבב","past":{"arabic":"مزج","phonemes":"m a z a J"},"future":{"arabic":"يمزج","phonemes":"j i m z a J"}},
+      {"hebrew":"התנדנד","past":{"arabic":"مرجح","phonemes":"m a r J a ħ"},"future":{"arabic":"يمرجح","phonemes":"j i m a r J i ħ"}},
+      {"hebrew":"הוליך, הפעיל","past":{"arabic":"مشّ��","phonemes":"m a ʃ ʃ a"},"future":{"arabic":"يمشّي","phonemes":"j i m a ʃ ʃ i"}},
+      {"hebrew":"עבר","past":{"arabic":"مرق","phonemes":"m a r a Q"},"future":{"arabic":"يمرق","phonemes":"j i m r u Q"}}
+    ]
+  },
+  "nun": {
+    "source":{"title":"פעלים שימושיים בערבית מדוברת — אות נון","url":"https://www.youtube.com/watch?v=KdipB6ik22Y","dialect":"Palestinian spoken Arabic"},
+    "verbs":[
+      {"hebrew":"ישן, שכב","past":{"arabic":"نام","phonemes":"n aː m"},"future":{"arabic":"ينام","phonemes":"j i n aː m"}},
+      {"hebrew":"הרדים","past":{"arabic":"نوّم","phonemes":"n a w w a m"},"future":{"arabic":"ينوّم","phonemes":"j i n a w w i m"}},
+      {"hebrew":"שכח","past":{"arabic":"نسي","phonemes":"n a s i"},"future":{"arabic":"ينسى","phonemes":"j i n s a"}},
+      {"hebrew":"השכיח","past":{"arabic":"نسّى","phonemes":"n a s s a"},"future":{"arabic":"ينسّي","phonemes":"j i n a s s i"}},
+      {"hebrew":"התנמנם","past":{"arabic":"نعس","phonemes":"n i ʕ i s"},"future":{"arabic":"ينعس","phonemes":"j i n ʕ a s"}},
+      {"hebrew":"נשף, נשם","past":{"arabic":"نفش","phonemes":"n a f a ʃ"},"future":{"arabic":"ينفش","phonemes":"j i n f u ʃ"}},
+      {"hebrew":"ניתר","past":{"arabic":"نطّ","phonemes":"n a tˤ tˤ"},"future":{"arabic":"ينطّ","phonemes":"j i n u tˤ tˤ"}},
+      {"hebrew":"העביר, העתיק","past":{"arabic":"نقل","phonemes":"n a Q a l"},"future":{"arabic":"ينقل","phonemes":"j i n Q u l"}},
+      {"hebrew":"התחרה","past":{"arabic":"نافس","phonemes":"n aː f a s"},"future":{"arabic":"ينافس","phonemes":"j i n aː f i s"}},
+      {"hebrew":"ניקה","past":{"arabic":"نضّف","phonemes":"n a dˤ dˤ a f"},"future":{"arabic":"ينضّف","phonemes":"j i n a dˤ dˤ i f"}},
+      {"hebrew":"בחר","past":{"arabic":"نقّى","phonemes":"n a Q Q a"},"future":{"arabic":"ينقّي","phonemes":"j i n a Q Q i"}},
+      {"hebrew":"סגר","past":{"arabic":"نتّ","phonemes":"n a t t"},"future":{"arabic":"ينتّ","phonemes":"j i n u t t"}}
+    ]
+  },
+  "sin": {
+    "source":{"title":"פעלים שימושיים בערבית מדוברת — אות סין","url":"https://www.youtube.com/watch?v=DlM_AscrScY","dialect":"Palestinian spoken Arabic"},
+    "verbs":[
+      {"hebrew":"החביא, שמר","past":{"arabic":"ستر","phonemes":"s a t a r"},"future":{"arabic":"يستر","phonemes":"j i s t u r"}},
+      {"hebrew":"שמע","past":{"arabic":"سمع","phonemes":"s a m i ʕ"},"future":{"arabic":"يسمع","phonemes":"j i s m a ʕ"}},
+      {"hebrew":"עזר","past":{"arabic":"ساعد","phonemes":"s aː ʕ a d"},"future":{"arabic":"يساعد","phonemes":"j i s aː ʕ i d"}},
+      {"hebrew":"כישף","past":{"arabic":"سحر","phonemes":"s a ħ a r"},"future":{"arabic":"يسحر","phonemes":"j i s ħ a r"}},
+      {"hebrew":"שאל","past":{"arabic":"سأل","phonemes":"s a ʔ a l"},"future":{"arabic":"يسأل","phonemes":"j i s ʔ a l"}},
+      {"hebrew":"גר, שכן","past":{"arabic":"سكن","phonemes":"s a k a n"},"future":{"arabic":"يسكن","phonemes":"j i s k u n"}},
+      {"hebrew":"השתלט","past":{"arabic":"سيطر","phonemes":"s a j tˤ a r"},"future":{"arabic":"يسيطر","phonemes":"j i s a j tˤ i r"}},
+      {"hebrew":"נסע","past":{"arabic":"سافر","phonemes":"s aː f a r"},"future":{"arabic":"يسافر","phonemes":"j i s aː f i r"}},
+      {"hebrew":"הרגיז","past":{"arabic":"سفّن","phonemes":"s a f f a n"},"future":{"arabic":"يسفّن","phonemes":"j i s a f f i n"}},
+      {"hebrew":"סלח","past":{"arabic":"سامح","phonemes":"s aː m a ħ"},"future":{"arabic":"يسامح","phonemes":"j i s aː m i ħ"}},
+      {"hebrew":"גנב","past":{"arabic":"سرق","phonemes":"s a r a Q"},"future":{"arabic":"يسرق","phonemes":"j i s r u Q"}},
+      {"hebrew":"שתק","past":{"arabic":"سكت","phonemes":"s a k a t"},"future":{"arabic":"يسكت","phonemes":"j i s k u t"}},
+      {"hebrew":"צחק","past":{"arabic":"سخف","phonemes":"s a x a f"},"future":{"arabic":"يسخف","phonemes":"j i s x a f"}},
+      {"hebrew":"קילל","past":{"arabic":"سبّ","phonemes":"s a b b"},"future":{"arabic":"يسبّ","phonemes":"j i s u b b"}},
+      {"hebrew":"עזב","past":{"arabic":"ساب","phonemes":"s aː b"},"future":{"arabic":"يسيب","phonemes":"j i s iː b"}},
+      {"hebrew":"שיבח, עזר לשחות","past":{"arabic":"سبّح","phonemes":"s a b b a ħ"},"future":{"arabic":"يسبّح","phonemes":"j i s a b b i ħ"}},
+      {"hebrew":"הקל","past":{"arabic":"سهّل","phonemes":"s a h h a l"},"future":{"arabic":"يسهّل","phonemes":"j i s a h h i l"}},
+      {"hebrew":"סידר, עשה","past":{"arabic":"سوّى","phonemes":"s a w w a"},"future":{"arabic":"يسوّي","phonemes":"j i s a w w i"}}
+    ]
+  },
+  "ayn": {
+    "source":{"title":"פעלים שימושיים בערבית מדוברת — אות עין","url":"https://www.youtube.com/watch?v=BZU4jitxcuU","dialect":"Palestinian spoken Arabic"},
+    "verbs":[
+      {"hebrew":"גילה עירנות","past":{"arabic":"وعى","phonemes":"w a ʕ a"},"future":{"arabic":"يوعى","phonemes":"j i w ʕ a"}},
+      {"hebrew":"לימד","past":{"arabic":"علّم","phonemes":"ʕ a l l a m"},"future":{"arabic":"يعلّم","phonemes":"j i ʕ a l l i m"}},
+      {"hebrew":"כעס","past":{"arabic":"عكّر","phonemes":"ʕ a k k a r"},"future":{"arabic":"يعكّر","phonemes":"j i ʕ a k k i r"}},
+      {"hebrew":"הזיע","past":{"arabic":"عرق","phonemes":"ʕ a r i Q"},"future":{"arabic":"يعرق","phonemes":"j i ʕ r a Q"}},
+      {"hebrew":"איפס, כיוון","past":{"arabic":"عيّر","phonemes":"ʕ a j j a r"},"future":{"arabic":"يعيّر","phonemes":"j i ʕ a j j i r"}},
+      {"hebrew":"הכיר, ידע","past":{"arabic":"عرف","phonemes":"ʕ i r i f"},"future":{"arabic":"يعرف","phonemes":"j i ʕ r a f"}},
+      {"hebrew":"בירך לכבוד חג","past":{"arabic":"عايد","phonemes":"ʕ aː j a d"},"future":{"arabic":"يعايد","phonemes":"j i ʕ aː j i d"}},
+      {"hebrew":"ספר","past":{"arabic":"عدّ","phonemes":"ʕ a d d"},"future":{"arabic":"يعدّ","phonemes":"j i ʕ u d d"}},
+      {"hebrew":"חזר על","past":{"arabic":"عاد","phonemes":"ʕ aː d"},"future":{"arabic":"يعيد","phonemes":"j i ʕ iː d"}},
+      {"hebrew":"שם מכשול","past":{"arabic":"عرقل","phonemes":"ʕ a r Q a l"},"future":{"arabic":"يعرقل","phonemes":"j i ʕ a r Q i l"}},
+      {"hebrew":"חי","past":{"arabic":"عاش","phonemes":"ʕ aː ʃ"},"future":{"arabic":"يعيش","phonemes":"j i ʕ iː ʃ"}},
+      {"hebrew":"עבר, נכנס","past":{"arabic":"عبر","phonemes":"ʕ a b a r"},"future":{"arabic":"يعبر","phonemes":"j i ʕ b u r"}},
+      {"hebrew":"התעקש","past":{"arabic":"عاند","phonemes":"ʕ aː n a d"},"future":{"arabic":"يعاند","phonemes":"j i ʕ aː n i d"}},
+      {"hebrew":"נתן פיצוי","past":{"arabic":"عوّض","phonemes":"ʕ a w w a dˤ"},"future":{"arabic":"يعوّض","phonemes":"j i ʕ a w w i dˤ"}},
+      {"hebrew":"אהב, חיבב","past":{"arabic":"عزّ","phonemes":"ʕ a z z"},"future":{"arabic":"يعزّ","phonemes":"j i ʕ i z z"}},
+      {"hebrew":"הדיח, מיהר","past":{"arabic":"عجّل","phonemes":"ʕ a J J a l"},"future":{"arabic":"يعجّل","phonemes":"j i ʕ a J J i l"}},
+      {"hebrew":"בנה","past":{"arabic":"عمّر","phonemes":"ʕ a m m a r"},"future":{"arabic":"يعمّر","phonemes":"j i ʕ a m m i r"}}
+    ]
+  },
+  "ghayn": {
+    "source":{"title":"פעלים שימושיים בערבית מדוברת — אות ע'ין","url":"https://www.youtube.com/watch?v=kqtBFuKjx8o","dialect":"Palestinian spoken Arabic"},
+    "verbs":[
+      {"hebrew":"עזב, נעלם","past":{"arabic":"غاب","phonemes":"ɣ aː b"},"future":{"arabic":"يغيب","phonemes":"j i ɣ iː b"}},
+      {"hebrew":"שקע","past":{"arabic":"غرق","phonemes":"ɣ i r i Q"},"future":{"arabic":"يغرق","phonemes":"j i ɣ r a Q"}},
+      {"hebrew":"שטף","past":{"arabic":"غسل","phonemes":"ɣ a s a l"},"future":{"arabic":"يغسل","phonemes":"j i ɣ s i l"}},
+      {"hebrew":"כיסה","past":{"arabic":"غطّى","phonemes":"ɣ a tˤ tˤ a"},"future":{"arabic":"يغطّي","phonemes":"j i ɣ a tˤ tˤ i"}},
+      {"hebrew":"שינה","past":{"arabic":"غيّر","phonemes":"ɣ a j j a r"},"future":{"arabic":"يغيّر","phonemes":"j i ɣ a j j i r"}},
+      {"hebrew":"רתח","past":{"arabic":"غلى","phonemes":"ɣ a l a"},"future":{"arabic":"يغلي","phonemes":"j i ɣ l i"}},
+      {"hebrew":"ניצח","past":{"arabic":"غلب","phonemes":"ɣ a l a b"},"future":{"arabic":"يغلب","phonemes":"j i ɣ l a b"}},
+      {"hebrew":"סלח","past":{"arabic":"غفر","phonemes":"ɣ a f a r"},"future":{"arabic":"يغفر","phonemes":"j i ɣ f i r"}}
+    ]
+  },
+  "fa": {
+    "source":{"title":"פעלים שימושיים בערבית מדוברת — אות פא","url":"https://www.youtube.com/watch?v=pCn0vhBVR5Q","dialect":"Palestinian spoken Arabic"},
+    "verbs":[
+      {"hebrew":"נכשל","past":{"arabic":"فشل","phonemes":"f a ʃ a l"},"future":{"arabic":"يفشل","phonemes":"j i f ʃ a l"}},
+      {"hebrew":"הבין","past":{"arabic":"فهم","phonemes":"f i h i m"},"future":{"arabic":"يفهم","phonemes":"j i f h a m"}},
+      {"hebrew":"פתח","past":{"arabic":"فتح","phonemes":"f a t a ħ"},"future":{"arabic":"يفتح","phonemes":"j i f t a ħ"}},
+      {"hebrew":"נכנס, עבר","past":{"arabic":"فات","phonemes":"f aː t"},"future":{"arabic":"يفوت","phonemes":"j i f uː t"}},
+      {"hebrew":"הפריד","past":{"arabic":"فرّق","phonemes":"f a r r a Q"},"future":{"arabic":"يفرّق","phonemes":"j i f a r r i Q"}},
+      {"hebrew":"ברח","past":{"arabic":"فلّ","phonemes":"f a l l"},"future":{"arabic":"يفلّ","phonemes":"j i f u l l"}},
+      {"hebrew":"חשב, הניח","past":{"arabic":"فكّر","phonemes":"f a k k a r"},"future":{"arabic":"يفكّر","phonemes":"j i f a k k i r"}},
+      {"hebrew":"שחרר, התיר","past":{"arabic":"فكّ","phonemes":"f a k k"},"future":{"arabic":"يفكّ","phonemes":"j i f u k k"}},
+      {"hebrew":"התעורר","past":{"arabic":"فاق","phonemes":"f aː Q"},"future":{"arabic":"يفيق","phonemes":"j i f iː Q"}},
+      {"hebrew":"הפסיק, ניתק","past":{"arabic":"فصل","phonemes":"f a sˤ a l"},"future":{"arabic":"يفصل","phonemes":"j i f sˤ a l"}}
+    ]
+  },
+  "dad": {
+    "source":{"title":"פעלים שימושיים בערבית מדוברת — אות דאד","url":"https://www.youtube.com/watch?v=ULZkU-MoU6w","dialect":"Palestinian spoken Arabic"},
+    "verbs":[
+      {"hebrew":"היכה","past":{"arabic":"ضرب","phonemes":"dˤ a r a b"},"future":{"arabic":"يضرب","phonemes":"j i dˤ r u b"}},
+      {"hebrew":"צחק","past":{"arabic":"ضحك","phonemes":"dˤ i ħ i k"},"future":{"arabic":"يضحك","phonemes":"j i dˤ ħ a k"}},
+      {"hebrew":"נשאר","past":{"arabic":"ضلّ","phonemes":"dˤ a l l"},"future":{"arabic":"يضلّ","phonemes":"j i dˤ a l l"}},
+      {"hebrew":"הלך לאיבוד","past":{"arabic":"ضاع","phonemes":"dˤ aː ʕ"},"future":{"arabic":"يضيع","phonemes":"j i dˤ iː ʕ"}},
+      {"hebrew":"הבטיח","past":{"arabic":"ضمن","phonemes":"dˤ a m a n"},"future":{"arabic":"يضمن","phonemes":"j i dˤ m a n"}},
+      {"hebrew":"לחץ","past":{"arabic":"ضغط","phonemes":"dˤ a ɣ a tˤ"},"future":{"arabic":"يضغط","phonemes":"j i dˤ ɣ a tˤ"}}
+    ]
+  },
+  "sad": {
+    "source":{"title":"פעלים שימושיים בערבית מדוברת — אות צאד","url":"https://www.youtube.com/watch?v=jCpab4z3dXY","dialect":"Palestinian spoken Arabic"},
+    "verbs":[
+      {"hebrew":"קרה","past":{"arabic":"صار","phonemes":"sˤ aː r"},"future":{"arabic":"يصير","phonemes":"j i sˤ iː r"}},
+      {"hebrew":"צעק","past":{"arabic":"صرخ","phonemes":"sˤ a r a x"},"future":{"arabic":"يصرخ","phonemes":"j i sˤ r a x"}},
+      {"hebrew":"תיקן","past":{"arabic":"صلّح","phonemes":"sˤ a l l a ħ"},"future":{"arabic":"يصلّح","phonemes":"j i sˤ a l l i ħ"}},
+      {"hebrew":"צם","past":{"arabic":"صام","phonemes":"sˤ aː m"},"future":{"arabic":"يصوم","phonemes":"j i sˤ uː m"}},
+      {"hebrew":"צילם","past":{"arabic":"صوّر","phonemes":"sˤ a w w a r"},"future":{"arabic":"يصوّر","phonemes":"j i sˤ a w w i r"}},
+      {"hebrew":"סגר","past":{"arabic":"سكّر","phonemes":"s a k k a r"},"future":{"arabic":"يسكّر","phonemes":"j i s a k k i r"}},
+      {"hebrew":"התעורר","past":{"arabic":"صحي","phonemes":"sˤ i ħ i"},"future":{"arabic":"يصحى","phonemes":"j i sˤ ħ a"}}
+    ]
+  },
+  "qaf": {
+    "source":{"title":"פעלים שימושיים בערבית מדוברת — אות קאף","url":"https://www.youtube.com/watch?v=zx4scJYgYAM","dialect":"Palestinian spoken Arabic"},
+    "verbs":[
+      {"hebrew":"אמר","past":{"arabic":"قال","phonemes":"Q aː l"},"future":{"arabic":"يقول","phonemes":"j i Q uː l"}},
+      {"hebrew":"קרא","past":{"arabic":"قرأ","phonemes":"Q a r a ʔ"},"future":{"arabic":"يقرأ","phonemes":"j i Q r a ʔ"}},
+      {"hebrew":"ישב","past":{"arabic":"قعد","phonemes":"Q a ʕ a d"},"future":{"arabic":"يقعد","phonemes":"j i Q ʕ a d"}},
+      {"hebrew":"קם","past":{"arabic":"قام","phonemes":"Q aː m"},"future":{"arabic":"يقوم","phonemes":"j i Q uː m"}},
+      {"hebrew":"החליט","past":{"arabic":"قرّر","phonemes":"Q a r r a r"},"future":{"arabic":"يقرّر","phonemes":"j i Q a r r i r"}},
+      {"hebrew":"חתך","past":{"arabic":"قطع","phonemes":"Q a tˤ a ʕ"},"future":{"arabic":"يقطع","phonemes":"j i Q tˤ a ʕ"}},
+      {"hebrew":"סגר","past":{"arabic":"قفل","phonemes":"Q a f a l"},"future":{"arabic":"يقفل","phonemes":"j i Q f u l"}},
+      {"hebrew":"הסכים","past":{"arabic":"قبل","phonemes":"Q i b i l"},"future":{"arabic":"يقبل","phonemes":"j i Q b a l"}},
+      {"hebrew":"מדד","past":{"arabic":"قاس","phonemes":"Q aː s"},"future":{"arabic":"يقيس","phonemes":"j i Q iː s"}},
+      {"hebrew":"פגש","past":{"arabic":"قابل","phonemes":"Q aː b a l"},"future":{"arabic":"يقابل","phonemes":"j i Q aː b i l"}}
+    ]
+  },
+  "ra": {
+    "source":{"title":"פעלים שימושיים בערבית מדוברת — אות רא","url":"https://www.youtube.com/watch?v=fMIJT4HowVg","dialect":"Palestinian spoken Arabic"},
+    "verbs":[
+      {"hebrew":"הלך","past":{"arabic":"راح","phonemes":"r aː ħ"},"future":{"arabic":"يروح","phonemes":"j i r uː ħ"}},
+      {"hebrew":"ראה","past":{"arabic":"رأى","phonemes":"r a ʔ a"},"future":{"arabic":"يرى","phonemes":"j i r a"}},
+      {"hebrew":"חזר","past":{"arabic":"رجع","phonemes":"r a J a ʕ"},"future":{"arabic":"يرجع","phonemes":"j i r J a ʕ"}},
+      {"hebrew":"ענה","past":{"arabic":"ردّ","phonemes":"r a d d"},"future":{"arabic":"يردّ","phonemes":"j i r u d d"}},
+      {"hebrew":"רכב","past":{"arabic":"ركب","phonemes":"r i k i b"},"future":{"arabic":"يركب","phonemes":"j i r k a b"}},
+      {"hebrew":"רץ","past":{"arabic":"ركض","phonemes":"r a k a dˤ"},"future":{"arabic":"يركض","phonemes":"j i r k u dˤ"}},
+      {"hebrew":"סידר","past":{"arabic":"رتّب","phonemes":"r a t t a b"},"future":{"arabic":"يرتّب","phonemes":"j i r a t t i b"}},
+      {"hebrew":"זרק","past":{"arabic":"رمى","phonemes":"r a m a"},"future":{"arabic":"يرمي","phonemes":"j i r m i"}},
+      {"hebrew":"ניצח","past":{"arabic":"ربح","phonemes":"r i b i ħ"},"future":{"arabic":"يربح","phonemes":"j i r b a ħ"}},
+      {"hebrew":"גידל","past":{"arabic":"ربّى","phonemes":"r a b b a"},"future":{"arabic":"يربّي","phonemes":"j i r a b b i"}}
+    ]
+  },
+  "shin": {
+    "source":{"title":"פעלים שימושיים בערבית מדוברת — אות שין","url":"https://www.youtube.com/watch?v=yrL4wM1-jH8","dialect":"Palestinian spoken Arabic"},
+    "verbs":[
+      {"hebrew":"ראה","past":{"arabic":"شاف","phonemes":"ʃ aː f"},"future":{"arabic":"يشوف","phonemes":"j i ʃ uː f"}},
+      {"hebrew":"שתה","past":{"arabic":"شرب","phonemes":"ʃ i r i b"},"future":{"arabic":"يشرب","phonemes":"j i ʃ r a b"}},
+      {"hebrew":"עבד","past":{"arabic":"اشتغل","phonemes":"ʔ i ʃ t a ɣ a l"},"future":{"arabic":"يشتغل","phonemes":"j i ʃ t a ɣ i l"}},
+      {"hebrew":"קנה","past":{"arabic":"شرى","phonemes":"ʃ a r a"},"future":{"arabic":"يشري","phonemes":"j i ʃ r i"}},
+      {"hebrew":"הסביר","past":{"arabic":"شرح","phonemes":"ʃ a r a ħ"},"future":{"arabic":"يشرح","phonemes":"j i ʃ r a ħ"}},
+      {"hebrew":"הדליק","past":{"arabic":"شغّل","phonemes":"ʃ a ɣ ɣ a l"},"future":{"arabic":"يشغّل","phonemes":"j i ʃ a ɣ ɣ i l"}},
+      {"hebrew":"סחב","past":{"arabic":"شال","phonemes":"ʃ aː l"},"future":{"arabic":"يشيل","phonemes":"j i ʃ iː l"}},
+      {"hebrew":"השתתף","past":{"arabic":"شارك","phonemes":"ʃ aː r a k"},"future":{"arabic":"يشارك","phonemes":"j i ʃ aː r i k"}},
+      {"hebrew":"קילל","past":{"arabic":"شتم","phonemes":"ʃ a t a m"},"future":{"arabic":"يشتم","phonemes":"j i ʃ t u m"}},
+      {"hebrew":"משך","past":{"arabic":"شدّ","phonemes":"ʃ a d d"},"future":{"arabic":"يشدّ","phonemes":"j i ʃ u d d"}}
+    ]
+  },
+  "ta": {
+    "source":{"title":"פעלים שימושיים בערבית מדוברת — אות תא, חלק 1","url":"https://www.youtube.com/watch?v=z41lWU0o54M","dialect":"Palestinian spoken Arabic"},
+    "verbs":[
+      {"hebrew":"עזב","past":{"arabic":"ترك","phonemes":"t a r a k"},"future":{"arabic":"يترك","phonemes":"j i t r u k"}},
+      {"hebrew":"עייף","past":{"arabic":"تعب","phonemes":"t i ʕ i b"},"future":{"arabic":"يتعب","phonemes":"j i t ʕ a b"}},
+      {"hebrew":"למד","past":{"arabic":"تعلّم","phonemes":"t a ʕ a l l a m"},"future":{"arabic":"يتعلّم","phonemes":"j i t a ʕ a l l a m"}},
+      {"hebrew":"דיבר","past":{"arabic":"تكلّم","phonemes":"t k a l l a m"},"future":{"arabic":"يتكلّم","phonemes":"j i t k a l l a m"}},
+      {"hebrew":"התחתן","past":{"arabic":"تجوّز","phonemes":"t J a w w a z"},"future":{"arabic":"يتجوّز","phonemes":"j i t J a w w a z"}},
+      {"hebrew":"איחר","past":{"arabic":"تأخّر","phonemes":"t ʔ a x x a r"},"future":{"arabic":"يتأخّر","phonemes":"j i t ʔ a x x a r"}},
+      {"hebrew":"התקשר","past":{"arabic":"اتّصل","phonemes":"ʔ i t t a sˤ a l"},"future":{"arabic":"يتّصل","phonemes":"j i t t a sˤ i l"}},
+      {"hebrew":"השתנה","past":{"arabic":"تغيّر","phonemes":"t ɣ a j j a r"},"future":{"arabic":"يتغيّر","phonemes":"j i t ɣ a j j a r"}},
+      {"hebrew":"הסכים","past":{"arabic":"اتّفق","phonemes":"ʔ i t t a f a Q"},"future":{"arabic":"يتّفق","phonemes":"j i t t a f i Q"}},
+      {"hebrew":"התקדם","past":{"arabic":"تقدّم","phonemes":"t Q a d d a m"},"future":{"arabic":"يتقدّم","phonemes":"j i t Q a d d a m"}},
+      {"hebrew":"תרגם","past":{"arabic":"ترجم","phonemes":"t a r J a m"},"future":{"arabic":"يترجم","phonemes":"j i t a r J i m"}},
+      {"hebrew":"נזכר","past":{"arabic":"تذكّر","phonemes":"t DH a k k a r"},"future":{"arabic":"يتذكّر","phonemes":"j i t DH a k k a r"}}
+    ]
+  }
+}

static/index.html

@@ -310,6 +310,7 @@ body.driving .mic::before{display:none} body.driving .mic-zone.two{display:flex}
 .flag-facts{display:grid;grid-template-columns:auto 1fr;gap:6px 12px;margin:8px 0 0}
 .flag-facts dt{color:var(--muted);font-size:13px;white-space:nowrap}
 .flag-facts dd{margin:0;min-width:0;overflow-wrap:anywhere}
+.phone-dialect{direction:rtl;text-align:right;margin-top:6px;font-size:13px;color:var(--muted)}
 .flag-facts .ipa{direction:ltr;text-align:right;font:13px/1.5 ui-monospace,monospace;unicode-bidi:isolate}
 .flag-facts ul{margin:0;padding:0;list-style:none;display:flex;flex-direction:column;gap:3px}
 .flag-facts b.good{color:var(--olive)} .flag-facts b.mid{color:#a86a00} .flag-facts b.bad{color:#9f2f27}
@@ -571,6 +572,55 @@ dialog::backdrop{background:rgba(0,0,0,.45)}
 .dlg-head h2{font:400 22px/1 var(--f-display);margin:0}
 .dlg-head h2 small{display:block;margin-top:4px;font:600 13px/1.3 var(--f-body);color:var(--muted)}
 .phone-note{margin:4px 0 12px;color:var(--muted);font-size:13px}
+/* the phoneme analysis is a teacher's desktop tool: it takes the whole screen */
+#phoneDlg{width:min(98vw,1880px);max-height:95vh}
+.stage-flow{display:grid;grid-template-columns:repeat(10,minmax(0,1fr));gap:10px;margin-bottom:14px}
+.stage-card{position:relative;display:flex;flex-direction:column;gap:6px;padding:10px 10px 9px;border:1px solid var(--line);border-radius:12px;background:var(--bg);font-size:12px;line-height:1.35;cursor:default}
+.stage-card:not(:last-child)::after{content:"←";position:absolute;left:-10px;top:14px;color:var(--muted);font-size:13px}
+.stage-card:hover,.stage-card.on{border-color:var(--olive);box-shadow:0 0 0 2px var(--olive-soft)}
+.stage-card h4{margin:0;font:700 13px/1.25 var(--f-body)}
+.stage-card h4 b{display:inline-grid;place-items:center;width:19px;height:19px;margin-inline-end:5px;border-radius:50%;background:var(--olive);color:#fff;font-size:11px}
+.stage-card .what{color:var(--muted)}
+.stage-card dl{display:grid;grid-template-columns:1fr auto;gap:2px 6px;margin:0}
+.stage-card dt{color:var(--muted)}
+.stage-card dd{margin:0;font-weight:700;font-variant-numeric:tabular-nums;direction:ltr;text-align:left}
+.stage-card .formula{direction:ltr;text-align:left;overflow-wrap:anywhere;padding:4px 6px;border-radius:6px;background:var(--surface);font:12px/1.4 ui-monospace,monospace}
+.stage-card .got{margin-top:auto;padding-top:6px;border-top:1px dashed var(--line);font-weight:700}
+.stage-grid{display:grid;grid-template-columns:1fr 1fr;gap:12px}
+.stage-panel{border:1px solid var(--line);border-radius:12px;padding:10px 12px;font-size:13px}
+.stage-panel h4{margin:0 0 6px;font:700 13px/1.3 var(--f-body)}
+.stage-panel table{width:100%;border-collapse:collapse}
+.stage-panel td,.stage-panel th{padding:3px 6px;border-bottom:1px solid var(--line);text-align:start;font-variant-numeric:tabular-nums}
+.stage-panel tr.chosen{background:var(--ok-bg)}
+.stage-panel .eq{direction:ltr;text-align:left;font:13px/1.7 ui-monospace,monospace}
+.ltr{direction:ltr;unicode-bidi:isolate;font-family:ui-monospace,monospace}
+.stage-bar{position:relative;height:10px;margin:6px 0 2px;border-radius:999px;background:var(--line);direction:ltr}
+.stage-bar i{position:absolute;inset:0 auto 0 0;border-radius:999px;background:var(--olive)}
+.stage-bar b{position:absolute;top:-3px;bottom:-3px;width:2px;background:var(--sumac)}
+.stage-table-wrap{overflow:auto;max-height:62vh;border:1px solid var(--line);border-radius:10px}
+.stage-table{width:100%;border-collapse:separate;border-spacing:0;font-size:13px;font-variant-numeric:tabular-nums}
+.stage-table th{position:sticky;top:0;z-index:1;background:var(--surface);padding:6px 7px;border-bottom:1px solid var(--line);font:700 12px/1.25 var(--f-body);text-align:center;vertical-align:bottom}
+.stage-table th small{display:block;font-weight:500;color:var(--muted)}
+.stage-table td{padding:5px 7px;border-bottom:1px solid var(--line);text-align:center;white-space:nowrap}
+.stage-table tr.stage-word td{background:var(--olive-soft);font-weight:700;text-align:start}
+.stage-table tr.stage-word td .eq{display:inline-block;font:12px ui-monospace,monospace;direction:ltr;unicode-bidi:isolate;margin-inline-start:28px;font-weight:500;color:var(--muted)}
+.stage-table td.ok{background:var(--ok-bg);color:var(--ok)}
+.stage-table td.mid{background:var(--amber-bg);color:var(--amber)}
+.stage-table td.bad{background:var(--sumac-bg);color:var(--sumac)}
+.stage-table td.chg{box-shadow:inset 0 0 0 2px var(--olive)}
+.stage-table td.skip{color:var(--muted)}
+.stage-table td small{display:block;font-size:11px;color:var(--muted);font-weight:500}
+.stage-table .dec-flag{color:var(--sumac);font-weight:700}
+.stage-table .dec-issue{color:var(--amber);font-weight:700}
+.stage-table .dec-ok{color:var(--ok)}
+#stagesBox[data-hl="gop"] .st-gop,#stagesBox[data-hl="exemption"] .st-exemption,#stagesBox[data-hl="baseline"] .st-baseline,
+#stagesBox[data-hl="calibration"] .st-calibration,#stagesBox[data-hl="decision"] .st-decision,#stagesBox[data-hl="variant"] .st-variant,
+#stagesBox[data-hl="tips"] .st-tips{outline:2px solid var(--olive);outline-offset:-2px}
+#stagesBox[data-hl="word"] tr.stage-word td,#stagesBox[data-hl="sentence"] #stageSentence,#stagesBox[data-hl="unrelated"] #stageVariants{outline:2px solid var(--olive);outline-offset:-2px}
+.stage-legend{display:flex;gap:8px 16px;flex-wrap:wrap;margin-top:6px;font-size:12px;color:var(--muted)}
+.stage-legend i{display:inline-block;width:10px;height:10px;border-radius:3px;margin-inline-end:4px}
+.stage-legend .ok{background:var(--ok-bg)}.stage-legend .mid{background:var(--amber-bg)}.stage-legend .bad{background:var(--sumac-bg)}
+.stage-legend .chg{box-shadow:inset 0 0 0 2px var(--olive)}
 .phone-rows{direction:ltr;overflow-x:auto;padding:3px 0 8px}
 .phone-row{display:grid;grid-template-columns:72px repeat(var(--phones),minmax(34px,1fr));gap:4px;min-width:max-content;margin-bottom:5px;align-items:stretch}
 .phone-row>span{display:grid;place-items:center;min-height:34px;padding:3px 5px;border-radius:7px;background:var(--bg);font:600 16px/1.2 sans-serif}
@@ -976,6 +1026,15 @@ body.quiet :is(#mic,#playMine,#driveBtn,.phone-btn),body.driving :is(#quietBtn,#
   <p class="phone-note">זהו פירוש המודל להקלטה, ולא תעתיק פונטי מוסמך. תנועות קרובות ואורך תנועה מסומנים כהתאמה מקורבת.</p>
   <div class="phone-rows" id="phoneRows"></div>
   <div class="phone-legend"><span><i class="good"></i>התאמה</span><span><i style="background:var(--olive-soft)"></i>התאמה מקורבת</span><span><i class="bad"></i>החלפה או השמטה</span><span><i class="mid"></i>תוספת</span></div>
+  <section id="stagesBox" hidden>
+    <h3 class="heatmap-title">שלבי הסיווג</h3>
+    <p class="phone-note">כל הגה עובר את השלבים לפי הסדר. הכרטיסים מציגים את הספים והמשקלים של כל שלב ומה קרה בהקלטה הזו. מעבר עם העכבר על כרטיס מדגיש את העמודות שלו בטבלה.</p>
+    <div class="stage-flow" id="stageFlow"></div>
+    <div class="stage-grid"><div class="stage-panel" id="stageVariants"></div><div class="stage-panel" id="stageSentence"></div></div>
+    <h3 class="heatmap-title">הגה אחר הגה</h3>
+    <div class="stage-table-wrap"><table class="stage-table" id="stageTable"></table></div>
+    <div class="stage-legend"><span><i class="ok"></i>מעל סף הרשימה</span><span><i class="mid"></i>בין סף הסימון לסף הרשימה</span><span><i class="bad"></i>מתחת לסף הסימון</span><span><i class="chg"></i>השלב שינה את הציון</span></div>
+  </section>
   <section id="trackBox"><h3 class="heatmap-title">מיקום הפונמות בזמן</h3><div class="phone-track-wrap"><canvas id="phoneTrack" role="img" aria-label="רצף הפונמות הצפוי והמזוהה לאורך זמן"></canvas></div></section>
   <section id="heatmapBox"><h3 class="heatmap-title">הסתברות פונמות לאורך ההקלטה</h3><div class="heatmap-wrap"><canvas id="phoneHeatmap" role="img" aria-label="מפת חום של הסתברויות הפונמות לאורך ההקלטה"></canvas></div><div class="heatmap-scale"><span>0%</span><i></i><span>100%</span><span>· ★ פונמה צפויה</span></div></section>
 </dialog>
@@ -2170,7 +2229,8 @@ function alignPhones(expected,heard){
   return out.reverse();
 }
 function drawPhones(r){
-  const expected=r.words.flatMap(w=>(w.phonemes||[]).map(p=>p.ipa)), heard=(r.heard_ipa||"").trim().split(/\s+/).filter(Boolean);
+  // a letter with several correct realisations (ق: ʔ / k / q) is compared with the one said, so an accepted one is not a mismatch
+  const expected=r.words.flatMap(w=>(w.phonemes||[]).map(p=>p.realised&&!p.flagged?p.realised:p.ipa)), heard=(r.heard_ipa||"").trim().split(/\s+/).filter(Boolean);
   const aligned=alignPhones(expected,heard), rows=$("phoneRows"); rows.innerHTML=""; rows.style.setProperty("--phones",aligned.length);
   const make=(name,which)=>{
     const row=mark("phone-row","","div"); row.append(mark("phone-label",name));
@@ -2182,8 +2242,144 @@ function drawPhones(r){
     rows.append(row);
   };
   make("צפוי",0); make("המודל שמע",1);
+  const dialect=r.mixed_dialect?"ניב: מעורב (עירוני וכפרי באותו משפט, לא הוריד ציון)":r.dialect==="urban"?"ניב: עירוני":r.dialect==="rural"?"ניב: כפרי":"";
+  if(dialect) rows.append(mark("phone-dialect",dialect,"div"));
   drawPhoneTrack(r.phoneme_heatmap);
   drawHeatmap(r.phoneme_heatmap);
+  drawStages(r);
+}
+// The classification stage by stage (r.trace, teachers only): the flow with each stage's thresholds and weights,
+// then every sound through the stages. Scores are 0..100; probabilities are the model's posteriors in the sound's window.
+const EXEMPTION_NAMES={glottal_dropped:"עצירה סותמית שהושמטה (ء / ق)",article_vowel_elided:"תנועת ה־ال אחרי תנועה",near_vowel:"תנועה קרובה"};
+function drawStages(r){
+  const box=$("stagesBox"), t=r.trace;
+  if(!t){ box.hidden=true; return; }
+  box.hidden=false;
+  const c=t.config, toks=t.tokens;
+  const E=(tag,cls,...kids)=>{ const e=document.createElement(tag); if(cls) e.className=cls; for(const k of kids) if(k!=null&&k!=="") e.append(k); return e; };
+  const num=(x,d=1)=>x==null?"—":String(Math.round(x*10**d)/10**d);
+  const pct=x=>x==null?"—":x>0&&x<0.001?"<0.1%":num(100*x,1)+"%";
+  const ltr=x=>E("span","ltr",String(x));
+  const band=s=>s>=c.issue_below?"ok":s>=c.flag_below?"mid":"bad";
+  const count=f=>toks.filter(f).length;
+  const stageOf=(x,name)=>x.stages.find(s=>s.stage===name);
+
+  // the flow: one card per stage, in order
+  const flow=$("stageFlow"); flow.innerHTML="";
+  const card=(id,n,title,what,params,formula,got)=>{
+    const el=E("div","stage-card",E("h4","",E("b","",String(n)),title),E("div","what",what));
+    el.dataset.stage=id;
+    if(params.length){ const dl=E("dl"); for(const [k,v] of params) dl.append(E("dt","",k),E("dd","",String(v))); el.append(dl); }
+    if(formula) el.append(E("div","formula",formula));
+    el.append(E("div","got",got));
+    el.onmouseenter=()=>{ box.dataset.hl=id; };
+    el.onmouseleave=()=>{ delete box.dataset.hl; };
+    flow.append(el);
+  };
+  const chosen=t.variants.find(v=>v.chosen)||{};
+  const u=t.unrelated, sen=t.sentence;
+  const flaggedN=count(x=>x.flagged), issueN=count(x=>x.issue), underFlag=count(x=>x.final<c.flag_below&&!x.flagged);
+  card("variant",1,"בחירת וריאנט","יישור כפוי (Viterbi) של כל וריאנט מקובל, כולל צורות דיפתונג; הסימנים המופשטים (Q, K, TH...) מאחדים מימושים.",
+    [["וריאנטים שנבדקו",t.variants.length],["קריטריון","log P מסלול מרבי"]],null,
+    `נבחר: log P ${num(chosen.logp,2)}`);
+  card("unrelated",2,"משפט אחר?","מרחק עריכה בין הפענוח החופשי לווריאנט, יחסית למספר ההגאים.",
+    [["סף יחסי",c.unrelated_ratio],["תקרת ציון",c.unrelated_cap]],`${u.distance} / ${u.tokens} = ${u.ratio}`,
+    u.unrelated?"משפט אחר: הציון מוגבל, בלי טיפים":"אותו משפט");
+  card("gop",3,"GOP לכל הגה","יחס בין ההגה הצפוי למתחרה החזק בחלון שלו, מוכפל בביטחון.",
+    [["λ סלחנות",c.leniency],["p לביטחון מלא",c.confident_peak],["השמטה: p צפוי <",c.deleted_peak],["… וגם p מתחרה <",c.deleted_comp]],
+    `100·e^(GOP·${c.leniency})·√min(1,p/${c.confident_peak})`,
+    `${count(x=>stageOf(x,"gop").score<c.flag_below)} הגאים מתחת ל־${c.flag_below} · ${count(x=>x.deleted)} הושמטו`);
+  card("exemption",4,"פטורים (6.3)","מה שהמודל שומע כטעות אבל הוא דיבור רגיל.",
+    c.exemptions.map(e=>[EXEMPTION_NAMES[e]||e,e==="near_vowel"?"≥ "+c.near_vowel_floor:"100"]),null,
+    `${count(x=>stageOf(x,"exemption").applied)} פטורים הוחלו`);
+  card("baseline",5,"קו בסיס ילידי","ציון ההגה מחולק בציון שהמודל נותן לקול הילידי על אותו הגה.",
+    [["הקלטות ילידיות",t.references.length],["ממוצע מינימלי לאמון",c.ref_min_mean]],"min(100, 100·score / ref)",
+    `${count(x=>stageOf(x,"baseline").applied)} הגאים הותאמו`);
+  card("calibration",6,"כיול מורה","רצפות שהמורה אישר לבלבול מסוים (צפוי → נשמע).",
+    [["מפתח","סמל, ואז הגה כתוב"]],"max(score, floor)",
+    `${count(x=>stageOf(x,"calibration").applied)} רצפות הוחלו`);
+  card("decision",7,"החלטת סימון","עיצור מסומן אם הציון נמוך והמתחרה ניצח במרווח של הזוג.",
+    [["סימון: ציון <",c.flag_below],["מרווח ברירת מחדל",c.margin_default],["זוגות עם מרווח",c.margins.length],["רשימת אי־דיוק: ציון <",c.issue_below]],
+    "−GOP ≥ margin(target, heard)",
+    `${flaggedN} מסומנים · ${issueN} ברשימה${underFlag?` · ${underFlag} נמוכים אך לא סומנו`:""}`);
+  card("word",8,"ציון מילה","שילוב של ההגה החלש במילה וממוצע ההגאים שלה.",
+    [["k משקל החלש",c.word_min_weight]],`k·min + (1−k)·mean`,
+    t.words.map(w=>Math.round(w.score)).join(" · "));
+  card("sentence",9,"ציון משפט","ממוצע הגאים משוקלל (תנועה במשקל נמוך) וממוצע המילים.",
+    [["משקל תנועה",c.vowel_weight],["ממוצע הגאים",sen.phone_weight],["ממוצע מילים",sen.word_weight]],
+    `${sen.phone_weight}·${sen.phone_mean} + ${sen.word_weight}·${sen.word_mean}`,
+    `${sen.before_cap} → ${sen.final}${sen.capped?" (מוגבל)":""}`);
+  card("tips",10,"טיפים","מהמסומנים: חומרה גבוהה קודם, ואז הציון הנמוך.",
+    [["מקסימום",c.max_tips],["מקסימום ברשימה",c.max_issues]],null,
+    t.tips.length?t.tips.map(x=>`${x.key} (${x.severity})`).join(" · "):"אין טיפים");
+
+  // variants and the "different sentence" check
+  const vp=$("stageVariants"); vp.innerHTML="";
+  vp.append(E("h4","","1–2 · הווריאנטים והבדיקה למשפט אחר"));
+  const vt=E("table"); vt.append(E("tr","",E("th","","ערבית"),E("th","","IPA"),E("th","","log P")));
+  for(const v of [...t.variants].sort((a,b)=>(b.logp??-1e9)-(a.logp??-1e9))){
+    const row=E("tr",v.chosen?"chosen":"",E("td","",v.ar),E("td","",ltr(v.ipa)),E("td","",ltr(v.logp==null?"קצר מדי":num(v.logp,2))));
+    vt.append(row);
+  }
+  vp.append(vt,E("div","",E("small","","עם סמלים: "),ltr(t.aipa)),E("div","",E("small","","הפענוח החופשי: "),ltr(u.heard||"—")));
+  const bar=E("div","stage-bar"), fill=E("i"), mk=E("b");
+  fill.style.width=Math.min(100,100*u.ratio)+"%"; mk.style.left=100*u.threshold+"%"; bar.append(fill,mk);
+  vp.append(bar,E("small","",`מרחק יחסי ${u.ratio} · הסף ${u.threshold} (הקו האדום)`));
+
+  // word and sentence formulas with this attempt's numbers
+  const sp=$("stageSentence"); sp.innerHTML="";
+  sp.append(E("h4","","8–9 · מילים ומשפט"));
+  const wt=E("table"); wt.append(E("tr","",E("th","","מילה"),E("th","","min"),E("th","","mean"),E("th","","k·min+(1−k)·mean")));
+  for(const w of t.words) wt.append(E("tr","",E("td","",w.tr),E("td","",ltr(num(w.min))),E("td","",ltr(num(w.mean))),
+    E("td","",ltr(`${c.word_min_weight}·${num(w.min)} + ${num(1-c.word_min_weight,2)}·${num(w.mean)} = ${num(w.score)}`))));
+  const vowels=toks.filter(x=>x.vowel).length;
+  sp.append(wt,E("div","eq",`phone_mean = Σ(w·score)/Σw  (w=${c.vowel_weight} ×${vowels} vowels, 1 ×${toks.length-vowels} consonants) = ${sen.phone_mean}`),
+    E("div","eq",`word_mean = ${sen.word_mean}`),
+    E("div","eq",`score = ${sen.phone_weight}·${sen.phone_mean} + ${sen.word_weight}·${sen.word_mean} = ${sen.before_cap}${sen.capped?` → min(·, ${c.unrelated_cap})`:""} → ${sen.final}`));
+
+  // every sound through the stages
+  const tb=$("stageTable"); tb.innerHTML="";
+  const head=[["#",""],["הגה","כתוב · סמל · מחלקה"],["חלון","פריימים",""],["P צפוי","","gop"],["מתחרה","P","gop"],["GOP","log יחס","gop"],
+    ["e^(GOP·λ)",`λ=${c.leniency}`,"gop"],["√ביטחון",`p/${c.confident_peak}`,"gop"],["ציון GOP","","gop"],["פטור","","exemption"],
+    ["קו בסיס","ref","baseline"],["כיול","floor","calibration"],["סופי","",""],["מרווח","בפועל / נדרש","decision"],
+    ["החלטה",`סימון <${c.flag_below} · רשימה <${c.issue_below}`,"decision"],["כלל","חומרה","tips"],["משקל","","sentence"]];
+  const hr=E("tr"); for(const [a,b,st] of head){ const th=E("th",st?"st-"+st:"",a,b?E("small","",b):null); hr.append(th); } tb.append(E("thead","",hr));
+  const body=E("tbody");
+  t.words.forEach((w,wi)=>{
+    body.append(E("tr","stage-word",(()=>{ const td=E("td","",`מילה ${wi+1}: ${w.tr} · ${num(w.score)}`,E("span","eq",`k·min + (1−k)·mean = ${c.word_min_weight}·${num(w.min)} + ${num(1-c.word_min_weight,2)}·${num(w.mean)} = ${num(w.score)}`)); td.colSpan=head.length; return td; })()));
+    for(const x of toks.filter(x=>x.word===wi)){
+      const gop=stageOf(x,"gop"), ex=stageOf(x,"exemption"), bl=stageOf(x,"baseline"), cal=stageOf(x,"calibration");
+      const who=E("td","",ltr(x.ipa));
+      if(x.sound!==x.ipa) who.append(E("small","",ltr(x.sound+(x.class?" {"+x.class.join(",")+"}":"")+(x.realised?" → "+x.realised:""))));
+      const comp=E("td","st-gop",x.deleted?"הושמט":x.competitor_other?"צליל לא מוכר":x.competitor?ltr(x.competitor):"—",E("small","",pct(x.p_competitor)));
+      const step=(st,stage,label)=>{ const td=E("td","st-"+stage+(st.applied?" chg "+band(st.score):" skip"),st.applied?num(st.score):"·");
+        if(label) td.append(E("small","",label)); return td; };
+      const m=x.margin, beyondTxt=m.beyond?"✓":"✗";
+      let dec, decCls;
+      if(x.flagged){ dec="מסומן"; decCls="dec-flag"; }
+      else if(x.issue){ dec="ברשימה"; decCls="dec-issue"; }
+      else if(x.final<c.flag_below&&x.vowel){ dec="תנועה: לא מסומנת"; decCls="dec-issue"; }
+      else if(x.final<c.flag_below&&!m.beyond){ dec="מרווח לא הושג"; decCls="dec-issue"; }
+      else if(x.final<c.issue_below){ dec="נמוך, לא ברשימה"; decCls="dec-issue"; }
+      else { dec="תקין"; decCls="dec-ok"; }
+      const decTd=E("td","st-decision",E("span",decCls,dec)); if(x.tip) decTd.append(E("small","","+ טיפ"));
+      body.append(E("tr","",
+        E("td","",String(x.i+1)), who,
+        E("td","",ltr(`${x.window[0]}–${x.window[1]}`),E("small","",ltr(`span ${x.span[0]}–${x.span[1]}`))),
+        E("td","st-gop",pct(x.p_target)), comp,
+        E("td","st-gop",ltr(num(x.gop,3))), E("td","st-gop",ltr(num(x.gop_factor,3))), E("td","st-gop",ltr(num(x.confidence_factor,3))),
+        E("td","st-gop "+band(gop.score),num(gop.score)),
+        step(ex,"exemption",ex.applied?(EXEMPTION_NAMES[ex.applied]||ex.applied):""),
+        step(bl,"baseline",bl.ref!=null?"ref "+num(bl.ref):""),
+        step(cal,"calibration",cal.floor!=null?"floor "+num(cal.floor):""),
+        E("td",band(x.final),num(x.final)),
+        E("td","st-decision",ltr(`${num(m.got,2)} / ${num(m.needed,2)} ${beyondTxt}`)),
+        decTd,
+        E("td","st-tips",x.rule?x.rule.title:"—",x.rule?E("small","","חומרה "+x.rule.severity):null),
+        E("td","st-sentence",String(x.weight))));
+    }
+  });
+  tb.append(body);
 }
 function heatColor(value){
   const stops=[[245,247,245],[159,196,172],[40,116,93],[240,180,60],[159,47,39]], x=Math.max(0,Math.min(100,value))/25;

tests/test_rules.py

@@ -0,0 +1,43 @@
+"""The yaml blocks of pronunciation-rules.md, as the scorer reads them."""
+import re
+
+import yaml
+
+from app.rules import RULES_PATH, Check, check_detectable, load, parse, undetectable
+
+
+def test_every_block_parses_into_rules():
+    r = load()
+    assert {"Q", "K", "TH", "DH", "ZH", "J"} <= set(r.archiphonemes)
+    assert r.dialects == ["urban", "rural"] and len(r.checks) >= 30
+    assert r.check("ħ", "χ").severity == 3            # written χ, stored by its base() name x
+    assert r.margin(["ZH", "ðˤ"], "z") == 0.7         # ZH has no margin of its own: the written phoneme's applies
+
+
+def test_every_heard_symbol_has_a_hebrew_label():
+    text = RULES_PATH.read_text(encoding="utf-8")
+    heard = {str(h) for block in re.findall(r"```yaml\n(.*?)```", text, re.S)
+             for doc in re.split(r"^---$", block, flags=re.M) if doc.strip()
+             for c in (yaml.safe_load(doc) or {}).get("checks", []) for h in c["heard"]}
+    assert heard - set(load().heard_labels) == set()
+
+
+def test_correct_realisations_per_letter():
+    r = load()
+    assert r.members("Q") == ["ʔ", "k", "q"]                       # Bedouin g is off by default
+    assert r.members("TH") == ["t", "θ"] and "s" in r.members("TH", written="s")   # s only in learned words
+    assert r.dialects_of("Q", "k") == {"rural"} and r.dialects_of("K", "k") == {"urban", "rural"}
+
+
+def test_undetectable_rules_are_reported():
+    r = load()
+    everything = lambda p: True
+    assert undetectable(Check("x", "ħ", "ħ", 1, ""), r, everything) == "same_sound"
+    assert undetectable(Check("x", "Q", "k", 1, ""), r, everything) == "accepted"
+    assert undetectable(Check("x", "ħ", "ǀ", 1, ""), r, lambda p: p != "ǀ") == "heard_not_in_model"
+    report = check_detectable(r, everything)
+    assert report["pharyngeal_h"]["detectable"]
+    # vowel length is not modelled (base() drops ː): the long/short checks are listed as undetectable
+    assert {m["why"] for m in report["vowel_length"]["missing"]} == {"same_sound"}
+    bad = parse("```yaml\nid: bad\ntitle: bad\nchecks:\n  - {target: aː, heard: [a], severity: 1, feedback: x}\n```\n")
+    assert not check_detectable(bad, everything)["bad"]["detectable"]

tests/test_scoring.py

@@ -120,13 +120,172 @@ def test_h_instead_of_pharyngeal():
     assert r["tips"][0]["key"] == "ħ>h"
 
 
-def test_k_for_urban_qaf_picks_closest_variant_and_tips():
-    # learner says "kaddeesh" for قديش: closest variant is the glottal-stop one, ʔ flagged as k
+def test_k_for_qaf_is_rural_and_correct():
+    # learner says "kaddeesh" for قديش: rural Palestinian, so ق is accepted as k; the answer stays the urban one
     logp = emissions(["k", "a", "d", "eː", "ʃ", "i", "s", "aː", "ʕ", "a"])
     r = scorer_for(logp).score(None, TIME)
-    keys = [t["key"] for t in r["tips"]]
-    assert r["variant"]["ipa"].startswith("ʔ")
-    assert "ʔ>k" in keys
+    q = r["words"][0]["phonemes"][0]
+    assert r["variant"]["ipa"].startswith("ʔ") and q["sound"] == "Q" and q["realised"] == "k"
+    assert q["score"] >= 90 and not q["flagged"] and not r["tips"] and r["score"] >= 90
+    assert r["words"][0]["heard_tr"].startswith("כּ")      # written as said, not coloured as a mistake
+
+
+# ---------- dialects and Hebrew-speaker rules (docs/scoring-dialects-plan.md) ----------
+
+def custom_scorer(extra, phones, frames=3, gap=2, peak=0.9):
+    """A scorer over SYMS plus `extra`, hearing `phones` cleanly."""
+    syms = SYMS + [s for s in extra if s not in SYMS]
+    vocab = {s: i for i, s in enumerate(syms)}
+
+    def row(sym, p):
+        r = np.full(len(syms), (1 - p) / (len(syms) - 1))
+        r[vocab[sym]] = p
+        return r
+
+    rows = [row("<pad>", 0.95)] * gap
+    for ph in phones:
+        rows += [row(ph, peak)] * frames + [row("<pad>", 0.95)] * gap
+    return Scorer(lambda wav: np.log(np.array(rows)), Vocab(vocab))
+
+
+COFFEE = {"variants": [("قهوة", "ʔ a h w e")]}
+
+
+def test_q_for_qaf_is_accepted():
+    r = scorer_for(emissions(["q", "a", "d", "eː", "ʃ", "i", "s", "aː", "ʕ", "a"])).score(None, TIME)
+    assert r["words"][0]["phonemes"][0]["realised"] == "q" and not r["tips"] and r["score"] >= 90
+
+
+def test_dropped_qaf_between_vowels_is_not_an_error():
+    r = scorer_for(emissions(["a", "h", "w", "e"])).score(None, COFFEE)
+    assert r["score"] >= 90 and not r["tips"] and not any(i["missing"] for i in r["issues"])
+
+
+def test_hamza_is_not_a_qaf():
+    # اهلا is written with ء: kahla is not a dialect form, it is a mistake
+    phrase = {"variants": [("اهلا", "ʔ a h l a")]}
+    r = scorer_for(emissions(["k", "a", "h", "l", "a"])).score(None, phrase)
+    p = r["words"][0]["phonemes"][0]
+    assert "sound" not in p and p["flagged"] and p["heard"] == "k"
+    assert [t["key"] for t in r["tips"]] == ["ʔ>k"]
+
+
+def test_reference_is_matched_by_letter_not_by_realisation():
+    ref = scorer_for(emissions(["q", "a", "h", "w", "e"])).reference(None, COFFEE)   # the voice says ق as q
+    assert ref.sounds[0] == (0, "Q")
+    r = scorer_for(emissions(["ʔ", "a", "h", "w", "e"])).score(None, COFFEE, [ref])
+    assert r["score"] >= 95 and not r["tips"] and r["references"] == 1
+
+
+def test_mixed_dialect_is_noted_but_not_marked_down():
+    phrase = {"variants": [("قديش قهوة", "ʔ a d d eː ʃ | ʔ a h w e")]}
+    mixed = scorer_for(emissions(["ʔ", "a", "d", "eː", "ʃ", "k", "a", "h", "w", "e"])).score(None, phrase)
+    assert mixed["mixed_dialect"] and mixed["score"] >= 90 and not mixed["tips"]
+    rural = scorer_for(emissions(["k", "a", "d", "eː", "ʃ", "k", "a", "h", "w", "e"])).score(None, phrase)
+    assert rural["dialect"] == "rural" and "mixed_dialect" not in rural
+
+
+def test_rural_kaf_and_tha():
+    phrase = {"variants": [("كثير", "k t iː r")]}
+    r = custom_scorer(["tʃ", "θ", "r", "iː", "t"], ["tʃ", "θ", "iː", "r"]).score(None, phrase)
+    assert [p.get("realised") for p in r["words"][0]["phonemes"][:2]] == ["tʃ", "θ"]
+    assert r["score"] >= 90 and not r["tips"] and r["dialect"] == "rural"
+    r = custom_scorer(["tʃ", "θ", "r", "iː", "t"], ["tʃ", "t", "iː", "r"]).score(None, phrase)
+    assert r["mixed_dialect"] and r["score"] >= 90          # rural ك with urban ث
+
+
+def test_final_ta_marbuta_vowel_may_be_a_e_or_i():
+    for vowel in ("a", "e", "i"):
+        r = scorer_for(emissions(["ʔ", "a", "h", "w", vowel])).score(None, COFFEE)
+        assert r["words"][0]["phonemes"][-1]["score"] >= 95, vowel
+
+
+def test_diphthong_for_long_vowel():
+    # بيت said as bayt (rural / older speech) for beet
+    phrase = {"variants": [("بيت", "b eː t")]}
+    r = custom_scorer(["b", "t", "j"], ["b", "a", "j", "t"]).score(None, phrase)
+    assert r["score"] >= 90 and not r["tips"] and r["variant"]["ipa"] == "b a j t"
+
+
+def test_archify_places_each_letter():
+    from app.archi import archify, unresolved
+    assert archify("قديش الساعة", "ʔ a d d eː ʃ | i s s aː ʕ a") == "Q:ʔ a d d eː ʃ | i s s aː ʕ E:a"
+    assert archify("انا من القدس", "ʔ a n a | m i n | i l q u d s") == "ʔ a n a | m i n | i l Q:q u d s"
+    assert archify("شكرا كثير", "ʃ u k r a n | k t iː r") == "ʃ u K:k r a n | K:k TH:t iː r"
+    assert archify("قهوة", "Q:k a h w e") == "Q:k a h w e"                  # written by hand: left alone
+    assert unresolved("بعثت", "b a ʕ a t t") == [("بعثت", "ث")]             # ث and ت said as one geminate
+
+
+def test_every_qaf_in_the_bank_is_placed():
+    from app.archi import unresolved
+    bad = {(w, ipa) for p in PHRASES for ar, ipa in p["variants"] for w, letter in unresolved(ar, ipa) if letter == "ق"}
+    assert not bad, f"mark these ق by hand in the phrase (Q:ʔ): {sorted(bad)[:10]}"
+
+
+def test_emphatic_heard_plain_is_a_mistake_with_the_rules_feedback():
+    from app.rules import load
+    phrase = {"variants": [("ظهر", "ðˤ u h r")]}
+    r = custom_scorer(["ðˤ", "dˤ", "zˤ", "z", "u", "r"], ["z", "u", "h", "r"]).score(None, phrase)
+    assert [t["key"] for t in r["tips"]] == ["ZH>z"]
+    assert r["tips"][0]["text"] == load().check("ZH", "z").feedback and r["tips"][0]["severity"] == 2
+
+
+def margin_scorer(competitor_ratio):
+    """طين where tˤ is weak (p 0.07) and plain t is `competitor_ratio` times likelier in the same frames."""
+    syms = SYMS + ["tˤ", "t"]
+    vocab = {s: i for i, s in enumerate(syms)}
+    V = len(syms)
+
+    def row(probs):
+        r = np.full(V, 1e-4)
+        for sym, p in probs.items():
+            r[vocab[sym]] = p
+        return r / r.sum()
+
+    rows = [row({"<pad>": 0.95})] * 2
+    rows += [row({"tˤ": 0.07, "t": 0.07 * competitor_ratio, "<pad>": 0.8})] * 3 + [row({"<pad>": 0.95})] * 2
+    for ph in ("i", "n"):
+        rows += [row({ph: 0.9})] * 3 + [row({"<pad>": 0.95})] * 2
+    return Scorer(lambda wav: np.log(np.array(rows)), Vocab(vocab))
+
+
+def test_emphatic_needs_a_clear_win_before_it_is_flagged():
+    phrase = {"variants": [("طين", "tˤ i n")]}
+    under = margin_scorer(1.8).score(None, phrase)        # plain t under twice as likely: the model's doubt
+    p = under["words"][0]["phonemes"][0]
+    assert p["score"] < 50 and not p["flagged"] and not under["tips"]
+    over = margin_scorer(2.5).score(None, phrase)
+    assert over["words"][0]["phonemes"][0]["flagged"] and [t["key"] for t in over["tips"]] == ["tˤ>t"]
+
+
+@pytest.mark.parametrize("ar,ipa,extra,said,key,heard_letter", [
+    ("فنجان", "f i n dʒ aː n", ["f", "p", "dʒ"], ["p", "i", "n", "dʒ", "aː", "n"], "f>p", "פּ"),
+    ("وين", "w eː n", ["v"], ["v", "eː", "n"], "w>v", "ב"),
+    ("بس", "b a s", ["b", "v"], ["v", "a", "s"], "b>v", "ב"),
+    ("صباح", "sˤ a b aː ħ", ["sˤ", "ts", "b"], ["ts", "a", "b", "aː", "ħ"], "sˤ>ts", "טס"),
+    ("مرة", "m a r r a", ["r", "ʁ"], ["m", "a", "ʁ", "a"], "r>ʁ", None),
+])
+def test_hebrew_speaker_substitutions(ar, ipa, extra, said, key, heard_letter):
+    from app.rules import load
+    r = custom_scorer(extra, said).score(None, {"variants": [(ar, ipa)]})
+    tip = next(t for t in r["tips"] if t["key"] == key)
+    expected, heard = key.split(">")
+    assert tip["text"] == load().check(expected, heard).feedback
+    if heard_letter:                    # a sound Arabic does not have is still written in the heard line
+        assert heard_letter in r["heard_tr"].replace("\u05b0", "").replace("\u05b7", "").replace("\u05b4", "")
+
+
+def test_a_sound_outside_arabic_and_hebrew_is_not_named():
+    # the multilingual model offers a click for ħ: reported as unclear, not as "heard as ǀ"
+    r = custom_scorer(["ǀ"], ["w", "eː", "n", "i", "l", "ǀ", "a", "m", "aː", "m"]).score(None, TOILET)
+    h = next(p for p in r["words"][1]["phonemes"] if p["ipa"] == "ħ")
+    assert h["flagged"] and h["heard"] is None
+
+
+def test_meaning_changing_mistakes_lead_the_tips():
+    # w said as v (severity 2) and ħ as Hebrew ח (severity 3): ħ leads even though v scored lower
+    r = custom_scorer(["v"], ["v", "eː", "n", "i", "l", "χ", "a", "m", "aː", "m"]).score(None, TOILET)
+    assert [t["key"] for t in r["tips"]][:2] == ["ħ>x", "w>v"]
 
 
 def test_unrelated_sentence():
@@ -210,7 +369,8 @@ def test_tts_endpoint_serves_phrase_audio_and_503_without_key():
         assert r.headers["x-tts-voice-id"] == voices[1]["id"] and unquote(r.headers["x-tts-voice-name"]) == voices[1]["name"]
         assert c.get("/api/tts/0?voice=not-in-the-list").status_code == 400
         assert c.get("/api/tts/9999").status_code == 404
-        assert c.get("/api/health").json()["tts"] is True
+        health = c.get("/api/health").json()
+        assert health["tts"] is True and health["rules"]["pharyngeal_h"]["detectable"]
 
 
 def test_spelling_variants_of_a_sound_are_not_errors():
@@ -1546,3 +1706,18 @@ def test_a_tutor_flags_a_recording_scored_wrong(monkeypatch):
         assert "create table public.tutors" in c.get("/api/class", headers=tok("t")).json()["setup"][-1]["sql"]
         r = rank("t", email="s@b.c", tutor=True)
         assert r.status_code == 503 and "create table public.tutors" in r.json()["detail"]
+
+
+def test_teacher_trace_follows_every_stage():
+    # ħ said as χ, then forgiven by a teacher floor: each stage of the trace shows where the score came from
+    logp = emissions(["w", "eː", "n", "i", "l", "χ", "a", "m", "aː", "m"])
+    scorer = scorer_for(logp)
+    assert "trace" not in scorer.score(None, TOILET)                     # students do not get it
+    scorer.set_calibrations([{"expected": "ħ", "heard": "χ", "floor": 60}])
+    t = scorer.score_logp(logp, TOILET, diagnostics=True)["trace"]
+    assert t["config"]["flag_below"] == 50 and t["config"]["leniency"] == 0.5 and t["variants"][0]["chosen"]
+    h = next(x for x in t["tokens"] if x["ipa"] == "ħ")
+    assert [s["stage"] for s in h["stages"]] == ["gop", "exemption", "baseline", "calibration"]
+    assert h["stages"][0]["score"] < 50 and h["stages"][3]["applied"] and h["final"] == 60
+    assert h["competitor"] == "χ" and h["rule"]["severity"] == 3 and not h["flagged"]
+    assert t["sentence"]["final"] == round(0.5 * t["sentence"]["phone_mean"] + 0.5 * t["sentence"]["word_mean"])