Add tests for GOP pooling and windowing functionality

- Implemented tests for GOP frame pooling in `test_gop_pooling.py` to validate the scoring of synthetic CTC emissions, including various scenarios for vowel and consonant recognition.
- Created tests for class-based GOP windows in `test_gop_window.py`, ensuring proper handling of vowel and consonant transitions, substitutions, and deletions.
- Added a test for the Minerva import functionality in `test_minerva_import.py` to verify the integrity of the pilot manifest and associated phrases.

.env.example

@@ -5,8 +5,25 @@
 # Without it the page falls back to the device's Arabic voice.
 SAWTAK_API_KEY=
 
-# Optional: a specific voice id from the Sawtak catalog.
-# Empty = the most liked ready Palestinian voice.
+# Optional: the edge-tts voice of the spoken Hebrew prompts. Empty = he-IL-HilaNeural.
+HEBREW_VOICE=
+
+# Optional: where the generated speech (Arabic answers, Hebrew prompts) is cached. Empty = ~/.cache/ihki-tts.
+TTS_CACHE_DIR=
+
+# Optional: the Hugging Face CTC phoneme model the scorer runs. Unset = facebook/wav2vec2-xlsr-53-espeak-cv-ft.
+# Leave the line commented out rather than empty: an empty value is used as is and fails to load.
+# scripts/bench.py and scripts/rescore.py read it too, so a benchmark runs on the same model as the server.
+# MODEL_ID=facebook/wav2vec2-xlsr-53-espeak-cv-ft
+
+# Optional: how a vowel's GOP pools its frames (docs/gop-pooling.md): max | mean | topk | lse | energy | gated.
+# Empty = gated. "max" is the scoring before pooling. The lab's results show it beside the version, to compare runs.
+GOP_RATIO_POOL=
+
+# Optional: which frames a vowel's competitors are read from. Empty = wide (from the sound before to the one after,
+# as consonants). "narrow" = its aligned frames +- 1, or a number for another margin. Narrow drops spikes in the
+# transitions, but also misses a substitution held just outside it; see scripts/gop_window_bench.py.
+GOP_VOWEL_WINDOW=
 
 # Google sign-in through Supabase (Project Settings -> API Keys). Both values are public: the page gets them too.
 # Empty = no sign-in, the service is open. On Hugging Face these can be plain Space *variables*.
@@ -20,6 +37,7 @@ TEACHER_EMAILS=
 
 # Needed by the management panel and the classes: the project's secret key (Project Settings -> API Keys -> secret, or the
 # legacy service_role key). It reads every student's rows, so it is NOT public: on Hugging Face set it as a *secret*.
+# scripts/bench.py needs it (with the two values above) to read the lab's recordings.
 SUPABASE_SECRET_KEY=
 
 # Optional: accounts (separated by commas or spaces) that, like the teachers, get a flag under each score, for a recording they said

app/align.py

@@ -5,11 +5,46 @@ Nothing here depends on torch, so it is unit-testable with synthetic emissions.
 """
 from __future__ import annotations
 
-from dataclasses import dataclass
+import logging
+import os
+from dataclasses import dataclass, field
 
 import numpy as np
 
+log = logging.getLogger("ihki.align")
+
 NEG = -1e30
+POOLS = ("max", "mean", "topk", "lse", "energy", "gated")
+DEFAULT_POOL = "gated"
+
+
+def env_pool() -> str:
+    """The ratio pool GOP_RATIO_POOL names (read when a GopConfig is made, so after main.py loads .env).
+    Empty or unset: DEFAULT_POOL. An unknown name is logged and DEFAULT_POOL is used."""
+    pool = os.environ.get("GOP_RATIO_POOL", "").strip().lower() or DEFAULT_POOL
+    if pool not in POOLS:
+        log.warning("GOP_RATIO_POOL=%r is not one of %s: using %s", pool, ", ".join(POOLS), DEFAULT_POOL)
+        return DEFAULT_POOL
+    return pool
+
+
+NARROW_PAD = 1
+
+
+def env_vowel_window() -> int | None:
+    """GOP_VOWEL_WINDOW: empty, unset or "wide" (None: a vowel reads the consonants' wide window), "narrow" (its
+    aligned span +- NARROW_PAD frames), or that pad as a frame count. Anything else is logged and "wide" used.
+    Wide is the default: with a pooled ratio it absorbs a transition spike without the narrow window's blind spot
+    (docs/gop-pooling.md, scripts/gop_window_bench.py)."""
+    raw = os.environ.get("GOP_VOWEL_WINDOW", "").strip().lower()
+    if raw in ("", "wide"):
+        return None
+    if raw == "narrow":
+        return NARROW_PAD
+    if raw.isdigit():
+        return int(raw)
+    log.warning("GOP_VOWEL_WINDOW=%r is not wide, narrow or a frame count: using wide", raw)
+    return None
 
 
 @dataclass
@@ -87,53 +122,155 @@ class GopConfig:
     # Softens the target/competitor ratio: at 0.5 a competitor twice as likely still scores 71, not 50.
     # The zero-shot model is noisy on accented speech, so a linear ratio punishes its own uncertainty.
     leniency: float = 0.5
+    # How the target/competitor ratio pools the window's frames (docs/gop-pooling.md). The peak behind
+    # `confidence` and `deleted` stays the max, so a peaky CTC emission is never diluted by its blanks.
+    ratio_pool: str = field(default_factory=env_pool)  # max | mean | topk | lse | energy | gated (GOP_RATIO_POOL)
+    pool_k: int = 2              # topk: frames averaged per column
+    pool_tau: float = 0.5        # lse: temperature (0 -> max, 1 -> mean)
+    energy_gamma: float = 1.0    # energy: frame weight = (RMS / loudest in the window) ** gamma
+    energy_gate: float = 0.3     # gated: frames quieter than this fraction of the window's loudest are dropped
+    energy_spread: int = 1       # frames the energy is max-filtered over (CTC peaks lead/lag the acoustics)
+    pool_vowels_only: bool = True  # consonants keep the max (bursts and voiceless sounds are short and quiet)
+    # A vowel's competitors are read from its aligned span +- this many frames (None: the wide window consonants
+    # use). Its presence (`peak`, `deleted`) is still read from the wide window. GOP_VOWEL_WINDOW sets it.
+    vowel_window: int | None = field(default_factory=env_vowel_window)
+
+
+def pool_frames(seg: np.ndarray, how: str = "max", k: int = 2, tau: float = 0.5,
+                weight: np.ndarray | None = None) -> np.ndarray:
+    """Pool a window's (n, V) log-posteriors over time into one log-score per column.
+
+    max: the single best frame. topk: log of the mean of each column's k best frames. lse: the power mean
+    tau * log(mean(p ** (1/tau))), between the max (tau -> 0) and the mean (tau = 1). mean / energy / gated:
+    log of the weighted mean posterior, `weight` (uniform when None) normalised over the window.
+    """
+    n = len(seg)
+    if how == "max" or n == 1:
+        return seg.max(0)
+    if how == "topk":
+        k = max(1, min(k, n))
+        return np.logaddexp.reduce(np.partition(seg, n - k, axis=0)[n - k:], axis=0) - np.log(k)
+    if how == "lse":
+        return tau * (np.logaddexp.reduce(seg / tau, axis=0) - np.log(n))
+    w = np.ones(n) if weight is None else np.asarray(weight, dtype=np.float64)
+    w = w / w.sum() if w.sum() > 0 else np.full(n, 1.0 / n)
+    return np.logaddexp.reduce(seg + np.log(np.maximum(w, 1e-300))[:, None], axis=0)
+
+
+def energy_weights(energy: np.ndarray, how: str, gamma: float = 1.0, gate: float = 0.3) -> np.ndarray:
+    """Frame weights of one window from its (already smoothed) RMS: soft (`energy`) or a 0/1 voice gate (`gated`)."""
+    e = energy / max(float(energy.max()), 1e-12)
+    return (e >= gate).astype(np.float64) if how == "gated" else e ** gamma
+
+
+def spread_energy(energy: np.ndarray, spread: int) -> np.ndarray:
+    """Max-filter over +-spread frames: a CTC emission a frame off the loud nucleus still gets its weight."""
+    out = energy.astype(np.float64).copy()
+    for s in range(1, spread + 1):
+        out[s:] = np.maximum(out[s:], energy[:-s])
+        out[:-s] = np.maximum(out[:-s], energy[s:])
+    return out
+
+
+def token_window(spans: list[tuple[int, int]], i: int, T: int, pad: int | None = None) -> tuple[int, int]:
+    """[start, end) frames token i is read from. Wide (pad None): from the end of token i-1 to the start of token i+1,
+    the blanks around the emission where a substituted consonant peaks. Narrow: its own span +- `pad` frames, inside
+    the wide window (a vowel is its syllable's loud nucleus, not a sound hiding in the blanks)."""
+    a = spans[i - 1][1] if i > 0 else 0
+    b = spans[i + 1][0] if i + 1 < len(spans) else T
+    a, b = min(a, spans[i][0]), max(b, spans[i][1])
+    if pad is None:
+        return a, b
+    return max(a, spans[i][0] - pad), min(b, spans[i][1] + pad)
+
+
+def compute_token_gop(logp: np.ndarray, spans: list[tuple[int, int]], i: int, tokens: list[int], blank: int,
+                      cfg: GopConfig, vowel: bool = False, accept: list[set[int] | None] | None = None,
+                      n_real: int | None = None, named: set[int] | None = None, energy: np.ndarray | None = None,
+                      edge: tuple[set[int], set[int]] | None = None, pooled: bool | None = None) -> TokenScore:
+    """GOP of token i (see score_tokens), its window and pooling chosen by its class.
+
+    Presence is read from the wide window for every token: `peak` (behind the confidence) and `deleted` (target under
+    deleted_peak and no competitor over deleted_comp), so a vowel aligned to a single frame is still found deleted.
+    The competitor ratio of a vowel is read from its narrow window (cfg.vowel_window) and pooled with cfg.ratio_pool;
+    a consonant keeps the wide window, and the max unless cfg.pool_vowels_only is off. `pooled` overrides the latter.
+    `edge`: ids that are no competitor on the frames between the token's span and its left / right neighbour (a vowel
+    gliding into j or w passes through i or u: coarticulation, not a substitution). `energy` is already spread.
+    """
+    T = logp.shape[0]
+    accept = accept or [None] * len(tokens)
+    a, b = token_window(spans, i, T)
+    ra, rb = token_window(spans, i, T, cfg.vowel_window) if vowel and cfg.vowel_window is not None else (a, b)
+    tok, (s0, s1) = tokens[i], spans[i]
+    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
+
+    cols = (seg[:, :n_real] if n_real else seg).copy()
+    if edge:
+        for ids, lo, hi in ((edge[0], a, s0), (edge[1], s1, b)):
+            ids = [x for x in ids if x < cols.shape[1]]
+            if ids and hi > lo:
+                cols[lo - a:hi - a, ids] = NEG
+    mask = np.zeros(cols.shape[1], dtype=bool)
+    mask[blank] = True
+    for j in (i - 1, i, i + 1):
+        if 0 <= j < len(tokens):
+            for x in {tokens[j], *(accept[j] or ())}:
+                if x < len(mask):
+                    mask[x] = True
+    deleted = bool(peak < cfg.deleted_peak and float(np.where(mask, NEG, cols.max(0)).max()) < cfg.deleted_comp)
+
+    how = cfg.ratio_pool if (pooled if pooled is not None else vowel or not cfg.pool_vowels_only) else "max"
+    weight = None
+    if how in ("energy", "gated"):
+        if energy is not None:
+            weight = energy_weights(energy[ra:rb], how, cfg.energy_gamma, cfg.energy_gate)
+            weight[max(0, s0 - ra):max(0, s1 - ra)] = 1.0   # the frames the token was emitted on count in full
+        how = "mean"
+    rcols = cols[ra - a:rb - a]
+    maxed = rcols.max(0)
+    ratio = maxed.copy() if how == "max" else pool_frames(rcols, how, cfg.pool_k, cfg.pool_tau, weight)
+    ratio[mask] = NEG
+    comp = int(ratio.argmax())
+    comp_peak = float(maxed[comp]) if ratio[comp] > NEG / 2 else NEG
+    tseg = logp[ra:rb, [tok]]
+    target = float(tseg.max()) if how == "max" else float(pool_frames(tseg, how, cfg.pool_k, cfg.pool_tau, weight)[0])
+
+    gop = target - max(target, float(ratio[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)
+    return TokenScore(round(score, 1), round(gop, 3), round(peak, 3), comp if present and not other else None,
+                      deleted, realised, other, round(comp_peak, 3), (int(ra), int(rb)))
 
 
 def score_tokens(logp: np.ndarray, align: Alignment, tokens: list[int], blank: int,
-                 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.
+                 cfg: GopConfig | None = None, accept: list[set[int] | None] | None = None,
+                 n_real: int | None = None, named: set[int] | None = None,
+                 energy: np.ndarray | None = None, pooled: list[bool] | None = None,
+                 vowels: list[bool] | None = None,
+                 edges: list[tuple[set[int], set[int]] | None] | None = None) -> list[TokenScore]:
+    """Per-token GOP (compute_token_gop for each token).
 
-    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.
+
+    `vowels` marks the tokens that are vowels (narrow window, pooled ratio). Without it every token is read from the
+    wide window and pooled, unless `pooled` marks which are. `energy` is the per-frame RMS the energy pools need;
+    without it they fall back to the plain mean. `edges[i]`: see compute_token_gop.
     """
-    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
-        b = align.spans[i + 1][0] if i + 1 < len(tokens) else T
-        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[:, :n_real] if n_real else seg).max(0).copy()
-        masked[blank] = NEG
-        for j in (i - 1, i, i + 1):
-            if 0 <= j < len(tokens):
-                for x in {tokens[j], *(accept[j] or ())}:
-                    if x < len(masked):
-                        masked[x] = NEG
-        comp = int(masked.argmax())
-        comp_peak = float(masked[comp])
-
-        gop = peak - max(peak, comp_peak)
-        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 present and not other else None, deleted, realised, other,
-                              round(comp_peak, 3), (int(a), int(b))))
-    return out
+    cfg = cfg or GopConfig()
+    if energy is not None:
+        energy = spread_energy(np.asarray(energy)[:logp.shape[0]], cfg.energy_spread)
+    return [compute_token_gop(logp, align.spans, i, tokens, blank, cfg, bool(vowels and vowels[i]), accept, n_real,
+                              named, energy, edges[i] if edges else None,
+                              (pooled[i] if pooled is not None else None if vowels is not None else True))
+            for i in range(len(tokens))]
 
 
 def greedy_decode(logp: np.ndarray, blank: int) -> list[int]:

app/auth.py

@@ -455,6 +455,22 @@ class SupabaseAuth:
             log.warning("a recording not stored (is there a storage bucket `%s`? see the README): %s", bucket, e)
             return False
 
+    def _delete_objects(self, bucket: str, names: list[str]) -> bool:
+        """Removes recordings of a private storage bucket; False (logged) when some could not be removed."""
+        ok = True
+        for k in range(0, len(names), 1000):   # the storage API takes up to 1000 names a call
+            req = urllib.request.Request(
+                f"{self.url}/storage/v1/object/{bucket}", method="DELETE",
+                data=json.dumps({"prefixes": names[k:k + 1000]}).encode(),
+                headers={"Authorization": f"Bearer {self.secret}", "apikey": self.secret,
+                         "Content-Type": "application/json", "User-Agent": "ihki/1.0"})
+            try:
+                urllib.request.urlopen(req, timeout=TIMEOUT).close()
+            except (urllib.error.URLError, TimeoutError) as e:
+                log.warning("recordings of the storage bucket `%s` not removed: %s", bucket, e)
+                ok = False
+        return ok
+
     def _get_object(self, bucket: str, name: str) -> tuple[bytes, str]:
         """A recording of a private storage bucket and its media type."""
         req = urllib.request.Request(
@@ -513,7 +529,7 @@ class SupabaseAuth:
 
     def lab_sample(self, sample_id: int) -> dict | None:
         """One lab recording's row, without the scorer's result, or None."""
-        query = urllib.parse.urlencode({"select": "id,item,speaker,label,mistake,audio", "id": f"eq.{int(sample_id)}",
+        query = urllib.parse.urlencode({"select": "id,item,ar,ipa,speaker,label,mistake,audio", "id": f"eq.{int(sample_id)}",
                                         "limit": 1})
         rows = self._admin(f"/rest/v1/lab_samples?{query}")
         return rows[0] if rows else None
@@ -523,6 +539,17 @@ class SupabaseAuth:
         row = self.lab_sample(sample_id)
         return self._get_object("lab", row["audio"]) if row and row.get("audio") else None
 
+    def delete_lab_samples(self, speaker: str | None = None) -> int:
+        """Deletes the lab's recordings of one speaker ("": the unnamed), or of every speaker when None: the rows,
+        then their files in the bucket `lab` (a file that cannot be removed is logged and left). Returns how many rows."""
+        where = {"speaker": f"eq.{speaker}"} if speaker is not None else {"id": "gt.0"}  # a DELETE needs a filter
+        rows = self._admin(f"/rest/v1/lab_samples?{urllib.parse.urlencode({**where, 'select': 'id,audio'})}",
+                           "DELETE") or []
+        names = [r["audio"] for r in rows if r.get("audio")]
+        if names:
+            self._delete_objects("lab", names)
+        return len(rows)
+
     def calibrations(self, status: str | None = None) -> list[dict]:
         """Calibration proposals, optionally filtered by their workflow status."""
         params = {"select": "*", "order": "created_at.desc"}

app/lab.py

@@ -7,6 +7,10 @@ Three groups:
   - pairs:     minimal pairs (or a three) that differ in that sound only (حال / هال / خال, صيف / سيف ...): can the
                model tell them apart
   - positions: the sound at the start, the middle and the end of a word
+  - vowels:    a short vowel beside a glide (ولد, يلّا, شويّ: the glide's colour on the transition frames, GLIDE_KIN),
+               between consonants (كلب, بنت, كلّ: a spike from a neighbour's release), and short / long (من / مين).
+               Planting a↔i or u↔a on these measures whether the GOP pooling and windows (docs/gop-pooling.md)
+               still catch a real vowel substitution
 
 The recordings are kept in the Supabase table `lab_samples` and the storage bucket `lab` (see CREATE_LAB in main.py),
 the material for a per-sound benchmark: how often a sound said right is flagged, and how often a planted mistake is not.
@@ -14,9 +18,12 @@ The IPA follows the bank's (phrases.py), and a word the bank has keeps the bank'
 """
 from __future__ import annotations
 
+from .align import POOLS
+from .scorer import LETTER_GOOD
+from .tips import VOWELS
 from .translit import to_hebrew
 
-GROUPS = {"syllables": "הברות", "pairs": "זוגות מינימליים", "positions": "מיקום במילה"}
+GROUPS = {"syllables": "הברות", "pairs": "זוגות מינימליים", "positions": "מיקום במילה", "vowels": "תנועות"}
 
 
 def _item(id: str, group: str, focus: str, he: str, *variants: tuple[str, str], pair: str = "") -> dict:
@@ -73,6 +80,20 @@ ITEMS = [
     _item("pos-dˤ-3", "positions", "dˤ", "לבן", ("ابيض", "ʔ a b j a dˤ")),
     _item("pos-ʔ-2", "positions", "ʔ", "שאלה", ("سؤال", "s u ʔ aː l")),
     _item("pos-h-2", "positions", "h", "חודש", ("شهر", "ʃ a h r"), ("شهر", "ʃ a h i r")),
+    # vowels: the short vowel is the focus. Beside a glide: its i / u colour must not count against the vowel
+    _item("vow-walad", "vowels", "a", "ילד", ("ولد", "w a l a d")),
+    _item("vow-jalla", "vowels", "a", "יאללה", ("يلّا", "j a l l a")),
+    _item("vow-ʃwajj", "vowels", "a", "קצת", ("شويّ", "ʃ w a j j")),
+    _item("vow-majj", "vowels", "a", "מים", ("ميّ", "m a j j"), ("ميّ", "m a j j e")),
+    # between consonants: a release or a burst beside the vowel must not count against it
+    _item("vow-kalb", "vowels", "a", "כלב", ("كلب", "k a l b")),
+    _item("vow-bint", "vowels", "i", "בת", ("بنت", "b i n t")),
+    _item("vow-kull", "vowels", "u", "הכל", ("كلّ", "k u l l")),
+    _item("vow-sukkar", "vowels", "u", "סוכר", ("سكّر", "s u k k a r")),
+    _item("vow-bass", "vowels", "a", "רק / די", ("بسّ", "b a s s")),
+    # short / long: the same consonants, the vowel's length only
+    _item("vow-min", "vowels", "i", "מ־ (מן)", ("من", "m i n"), pair="i / iː"),
+    _item("vow-miin", "vowels", "iː", "מי", ("مين", "m iː n"), pair="i / iː"),
 ]
 BY_ID = {item["id"]: item for item in ITEMS}
 
@@ -82,6 +103,22 @@ def phrase(item: dict) -> dict:
     return {"cat": "lab", "key": f"lab:{item['id']}", "he": item["he"], "variants": item["variants"]}
 
 
+def sample_phrase(sample: dict) -> dict | None:
+    """The phrase of a saved recording, including imported lines outside the fixed diagnostic list.
+
+    Fixed items keep their current variants.  An importer stores the exact Arabic/IPA pair that was used for
+    scoring, so later rescores, sweeps and traces do not depend on the importer's manifest still being present.
+    """
+    item = BY_ID.get(sample.get("item"))
+    if item is not None:
+        return phrase(item)
+    ar, ipa = sample.get("ar"), sample.get("ipa")
+    if not ar or not ipa:
+        return None
+    key = str(sample.get("item") or f"sample:{sample.get('id', '')}")
+    return {"cat": "lab", "key": key, "he": sample.get("speaker") or key, "variants": [(ar, ipa)]}
+
+
 def public_items() -> list[dict]:
     """The list for the lab's page (teachers only): each item with its first reading's sounds, which a planted
     mistake is marked on, and that reading in Hebrew letters."""
@@ -194,7 +231,8 @@ def benchmark(samples: list[dict], results: dict | None = None, reports: list[di
 def compact(result: dict) -> dict:
     """What the benchmark reads of a result (the sounds, their scores and flags), for the page to send back."""
     keep = ("ipa", "sound", "score", "flagged", "heard")
-    return {"score": result.get("score"), "unrelated": bool(result.get("unrelated")),
+    return {"score": result.get("score"), "heard_ipa": result.get("heard_ipa", ""),
+            "unrelated": bool(result.get("unrelated")),
             "words": [{"phonemes": [{k: p[k] for k in keep if k in p} for p in w.get("phonemes", [])]}
                       for w in result.get("words", [])]}
 
@@ -206,3 +244,56 @@ def still_flagged(result: dict, issue: dict) -> bool:
     if not 0 <= issue.get("word", -1) < len(words):
         return False
     return any(p.get("flagged") and p["ipa"] == issue.get("expected") for p in words[issue["word"]].get("phonemes", []))
+
+
+# ---------- the sweep over the GOP settings ----------
+# Every GOP_RATIO_POOL with every GOP_VOWEL_WINDOW that differs in practice (a larger pad reaches the wide window).
+WINDOWS = (None, 0, 1, 2)
+SWEEP = [(pool, window) for pool in POOLS for window in WINDOWS]
+
+
+def sweep_key(pool: str, window: int | None) -> str:
+    """The name of a setting, as the env writes it: "gated|wide", "max|1"."""
+    return f"{pool}|{'wide' if window is None else window}"
+
+
+SWEEP_KEYS = {sweep_key(p, w): (p, w) for p, w in SWEEP}
+
+
+def quality(totals: dict) -> float | None:
+    """The pipeline's one number, 0..100: balanced accuracy over the judged sounds, the mean of
+    (1 - false rejection rate) and the detection rate. Each half is a rate, so the many sounds said right do not
+    drown the few planted mistakes, and a setting cannot win by flagging nothing (detection 0) or everything
+    (false rejections 1). Without planted mistakes it is 1 - frr alone (see `quality_partial`). None: no sound judged."""
+    frr, det = totals.get("frr"), totals.get("detection")
+    if frr is None:
+        return None
+    return round(100 * ((1 - frr) + det) / 2, 1) if det is not None else round(100 * (1 - frr), 1)
+
+
+def quality_partial(totals: dict) -> bool:
+    """True when `quality` could not weigh the detection (no planted mistake was judged)."""
+    return totals.get("detection") is None
+
+
+def vowel_stats(samples: list[dict], results: dict | None = None) -> dict:
+    """The vowels of the recordings, by score rather than flag: the scorer flags no vowel but the u of rule 3.11, so the
+    flag counts of `benchmark` cannot see a GOP change on vowels. Over recordings of the item's sentence (not
+    "unrelated"): {"right": vowels said right, "mean": their mean score, "weak": the share of them under LETTER_GOOD
+    (shown to the learner as weak), "planted": planted vowel mistakes, "auc": the chance that a vowel said right
+    scores above a planted wrong one (ties count half; None without planted vowels)}."""
+    results = results or {}
+    right, wrong = [], []
+    for s in samples:
+        result = results.get(s.get("id")) or s.get("result") or {}
+        if not result.get("words") or result.get("unrelated"):
+            continue
+        for x in judged(s, result):
+            if x["sound"] in VOWELS:
+                (wrong if x["planted"] else right).append(x["score"])
+    auc = None
+    if right and wrong:
+        auc = round(sum(1.0 if r > w else 0.5 if r == w else 0.0 for r in right for w in wrong) / (len(right) * len(wrong)), 3)
+    return {"right": len(right), "mean": round(sum(right) / len(right), 1) if right else None,
+            "weak": round(sum(x < LETTER_GOOD for x in right) / len(right), 3) if right else None,
+            "planted": len(wrong), "auc": auc}

app/main.py

@@ -35,7 +35,7 @@ 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 TOGGLES, check_detectable
-from .scorer import Scorer, decode_audio, load_scorer
+from .scorer import SAMPLE_RATE, Scorer, decode_audio, frame_energy, load_scorer
 from .speech_evaluation import SpeechEvaluationService
 from .texts import read_line, text_phrases
 from .tts import LINE_VOICES, RAEF_VOICE_ID, VOICES, SawtakTTS, TTSUnavailable, load_tts
@@ -778,20 +778,82 @@ def create_app(scorer: Scorer | None = None, tts: SawtakTTS | None = None,
         speakers = sorted({s.get("speaker") or "" for s in samples})
         if speaker:
             samples = [s for s in samples if (s.get("speaker") or "") == speaker]
+        # the recordings themselves, newest first, for the trace dashboard's picker
+        recordings = [{"id": s["id"], "item": s["item"], "speaker": s.get("speaker") or "", "label": s.get("label"),
+                       "mistake": s.get("mistake"), "score": s.get("score"), "flagged": s.get("flagged") or [],
+                       "unrelated": bool((s.get("result") or {}).get("unrelated")), "created_at": s.get("created_at")}
+                      for s in reversed(samples) if s.get("audio")]
         return {**lab.benchmark(samples, reports=reports), "speakers": speakers, "model": MODEL_ID,
-                "version": build_version(), "samples": [s["id"] for s in samples if s.get("audio")]}
+                "version": build_version(), "samples": [s["id"] for s in samples if s.get("audio")],
+                "recordings": recordings}
+
+    @app.get("/api/lab/minerva")
+    def lab_minerva(a: SupabaseAuth = Depends(teacher_only)):
+        """The imported Minerva pilot, grouped into videos for the lab's native-speech runner."""
+        titles = {"U8aBRd3-wlM": "במכולת", "OuAwxXUZBU4": "אסיפת הורים", "V2y6LqnoXTo": "הקדרה"}
+        files = {"U8aBRd3-wlM": "במכולת ＊ פִי א-דֻכַּאן ＊  في الدّكّان ＊ קטע שיחה בערבית מדוברת [U8aBRd3-wlM].webm",
+                 "OuAwxXUZBU4": "אסיפת הורים ＊ אִגתִמַאע אַהַאלִי ＊ إجتماع أهالي ＊ קטע שיחה בערבית מדוברת [OuAwxXUZBU4].webm",
+                 "V2y6LqnoXTo": "הקְדֵרָה הולידה קְדֵרָה ＊ אִ-טֻנגָ'רָה וִלדַת טֻנגָ'רָה ＊ الطّنجرة ولدت طنجرة ＊ סיפור בערבית מדוברת [V2y6LqnoXTo].mkv"}
+        try:
+            samples = a.lab_samples(full=True)
+        except AuthUnavailable as e:
+            raise lab_error(e)
+        videos: dict[str, dict] = {}
+        for s in samples:
+            match = re.fullmatch(r"minerva:([\w-]{11}):(\d+)", s.get("item") or "")
+            if (s.get("speaker") or "") != "מינרווה" or not match:
+                continue
+            video_id, line = match.group(1), int(match.group(2))
+            timing = re.fullmatch(rf"minerva:{re.escape(video_id)}:([0-9.]+)-([0-9.]+)", s.get("device") or "")
+            stored = s.get("result") or {}
+            video = videos.setdefault(video_id, {"id": video_id, "title": titles.get(video_id, video_id),
+                                                  "filename": files.get(video_id, ""), "samples": []})
+            video["samples"].append({"id": s["id"], "item": s["item"], "line": line,
+                                     "start": float(timing.group(1)) if timing else None,
+                                     "end": float(timing.group(2)) if timing else None,
+                                     "ar": s.get("ar") or "", "ipa": s.get("ipa") or "",
+                                     "score": s.get("score"), "heard_ipa": s.get("heard_ipa") or "",
+                                     "flagged": s.get("flagged") or [],
+                                     "unrelated": bool(stored.get("unrelated")), "audio": bool(s.get("audio"))})
+        order = list(titles)
+        out = list(videos.values())
+        out.sort(key=lambda v: order.index(v["id"]) if v["id"] in order else len(order))
+        for video in out:
+            video["samples"].sort(key=lambda s: s["line"])
+        return {"videos": out, "model": MODEL_ID, "version": build_version()}
+
+    @app.delete("/api/lab/samples")
+    def lab_delete_samples(speaker: str | None = Query(None), everyone: bool = Query(False),
+                           a: SupabaseAuth = Depends(teacher_only)):
+        """Deletes the lab's recordings, rows and files, to record the list afresh: one `speaker`'s ("" the unnamed),
+        or with `everyone` every speaker's. One of the two is required, so a missing parameter never deletes all.
+        {"deleted": how many recordings}."""
+        if (speaker is None) == (not everyone):
+            raise HTTPException(400, "give a speaker, or everyone=true")
+        try:
+            n = a.delete_lab_samples(None if everyone else " ".join(speaker.split())[:MAX_SPEAKER])
+        except AuthUnavailable as e:
+            raise lab_error(e)
+        log.info("lab: %d recordings deleted (%s)", n, "every speaker" if everyone else f"speaker {speaker!r}")
+        return {"deleted": n}
 
     @app.post("/api/lab/samples/{sample_id}/rescore")
-    def lab_rescore_sample(sample_id: int, a: SupabaseAuth = Depends(teacher_only)):
+    def lab_rescore_sample(sample_id: int, trace: bool = Query(False), setting: str = Query(""),
+                           a: SupabaseAuth = Depends(teacher_only)):
         """A lab recording scored again by the current scorer (as practice scores, with the native baseline), nothing
         kept: {"id", "result": what the benchmark reads of it (lab.compact)}. The page rescores the recordings one by
-        one and sends the results to POST /api/lab/results."""
+        one and sends the results to POST /api/lab/results.
+        `trace`: the whole result with the teacher's stage-by-stage trace instead, for the trace dashboard. `setting`
+        (a lab.SWEEP key, "gated|wide"): scored under that GOP setting, its native baseline rebuilt under it too."""
+        if setting and setting not in lab.SWEEP_KEYS:
+            raise HTTPException(400, "unknown setting")
         try:
             row = a.lab_sample(sample_id)
             found = a.lab_audio(sample_id) if row else None
         except AuthUnavailable as e:
             raise lab_error(e)
-        if row is None or row["item"] not in lab.BY_ID:
+        phrase = lab.sample_phrase(row) if row else None
+        if phrase is None:
             raise HTTPException(404, "no such lab recording")
         if found is None:
             raise HTTPException(404, "להקלטה הזו אין קובץ שמור")
@@ -799,9 +861,124 @@ def create_app(scorer: Scorer | None = None, tts: SawtakTTS | None = None,
             wav = decode_audio(found[0])
         except ValueError:
             raise HTTPException(400, "could not decode audio")
-        phrase = lab.phrase(lab.BY_ID[row["item"]])
-        refs = app.state.refs.get(phrase["key"], phrase) if app.state.refs else []
-        return {"id": sample_id, "result": lab.compact(app.state.scorer.score(wav, phrase, refs))}
+        scorer = app.state.scorer
+        if setting:
+            pool, window = lab.SWEEP_KEYS[setting]
+            scorer = scorer.with_gop(ratio_pool=pool, vowel_window=window)
+            refs = sweep_references(scorer, phrase, setting)
+        else:
+            refs = app.state.refs.get(phrase["key"], phrase) if app.state.refs else []
+        result = scorer.score(wav, phrase, refs, diagnostics=trace)
+        if not trace:
+            return {"id": sample_id, "result": lab.compact(result)}
+        g = scorer.cfg.gop
+        return {"id": sample_id, "result": result, "setting": lab.sweep_key(g.ratio_pool, g.vowel_window),
+                "sample": {k: row.get(k) for k in ("id", "item", "speaker", "label", "mistake")}}
+
+    # The sweep (POST /api/lab/samples/{id}/sweep) rebuilds each native baseline under every setting: the voices'
+    # posteriors are kept by (voice, wav hash), their References by setting too, for the life of the server.
+    sweep_emits: dict[tuple[str, str], tuple] = {}
+    sweep_refs: dict[tuple, object] = {}
+
+    def sweep_references(scorer: Scorer, phrase: dict, setting: str) -> list:
+        """The native baseline of `phrase` under `scorer`'s setting, from the TTS voices whose WAV is cached (the first
+        voice's is made on the way, as a rescore makes it). Empty without TTS."""
+        refs = app.state.refs
+        if refs is None:
+            return []
+        refs.get(phrase["key"], phrase)
+        text, out = point_arabic(*phrase["variants"][0]), []
+        for voice in refs.voices:
+            try:
+                if not refs.tts.cached(text, voice):
+                    continue
+                data, _ = refs.tts.wav(text, voice)
+            except Exception as e:   # provider down: score without this voice, as References does
+                log.warning("sweep: no %s voice for %r: %s", voice, text, e)
+                continue
+            emitted = (voice, hashlib.sha1(data).hexdigest())
+            if emitted not in sweep_emits:
+                if len(sweep_emits) > 400:
+                    sweep_emits.clear(); sweep_refs.clear()
+                wav = decode_audio(data)
+                logp = app.state.scorer.emit(wav)
+                sweep_emits[emitted] = (logp, frame_energy(wav, len(logp)))
+            key = (*emitted, phrase["key"], setting, scorer.disabled)
+            if key not in sweep_refs:
+                logp, energy = sweep_emits[emitted]
+                sweep_refs[key] = scorer.reference_logp(logp, phrase, energy)
+            if sweep_refs[key] is not None:
+                out.append(sweep_refs[key])
+        return out
+
+    @app.post("/api/lab/samples/{sample_id}/sweep")
+    def lab_sweep_sample(sample_id: int, a: SupabaseAuth = Depends(teacher_only)):
+        """A lab recording scored under each GOP setting of lab.SWEEP (GOP_RATIO_POOL x GOP_VOWEL_WINDOW), nothing kept.
+        The model runs once; each setting scores its posteriors against the native baseline rebuilt under it.
+        {"id", "results": {setting: what the benchmark reads (lab.compact)}}; the page sends them to POST /api/lab/sweep."""
+        try:
+            row = a.lab_sample(sample_id)
+            found = a.lab_audio(sample_id) if row else None
+        except AuthUnavailable as e:
+            raise lab_error(e)
+        phrase = lab.sample_phrase(row) if row else None
+        if phrase is None:
+            raise HTTPException(404, "no such lab recording")
+        if found is None:
+            raise HTTPException(404, "להקלטה הזו אין קובץ שמור")
+        try:
+            wav = decode_audio(found[0])
+        except ValueError:
+            raise HTTPException(400, "could not decode audio")
+        base = app.state.scorer
+        logp = base.emit(wav)
+        energy, duration = frame_energy(wav, len(logp)), len(wav) / SAMPLE_RATE
+        results = {}
+        for setting, (pool, window) in lab.SWEEP_KEYS.items():
+            scorer = base.with_gop(ratio_pool=pool, vowel_window=window)
+            refs = sweep_references(scorer, phrase, setting)
+            results[setting] = lab.compact(scorer.score_logp(logp, phrase, refs, False, duration, energy))
+        return {"id": sample_id, "results": results}
+
+    @app.post("/api/lab/sweep")
+    def lab_sweep_results(body: dict = Body(...), a: SupabaseAuth = Depends(teacher_only)):
+        """The benchmark of every setting from the sweeps of the recordings ({"results": {sample id: {setting: result}}}):
+        {"settings": [{"key", "pool", "window", "quality", "partial", "totals", "vowels" (lab.vowel_stats),
+        "changed": how many sound scores differ from max|wide's, "sounds"}] best first, "current": the server's own
+        setting, "recordings", "model", "version"}. `quality` is lab.quality (balanced accuracy)."""
+        given = body.get("results")
+        if not isinstance(given, dict) or len(given) > 5000:
+            raise HTTPException(400, "invalid results")
+        try:
+            results = {int(k): v for k, v in given.items() if isinstance(v, dict)}
+        except ValueError:
+            raise HTTPException(400, "invalid results")
+        try:
+            samples = [s for s in a.lab_samples(full=True) if s["id"] in results]
+        except AuthUnavailable as e:
+            raise lab_error(e)
+        keep = ("recordings", "unrelated", "right", "false_flags", "planted", "caught", "frr", "detection", "good_share")
+        ref = lab.sweep_key("max", None)   # the scoring before pooling and windows: what each setting changed of it
+        scores = lambda r: [p.get("score") for w in r.get("words", []) for p in w.get("phonemes", [])]
+        settings = []
+        for setting, (pool, window) in lab.SWEEP_KEYS.items():
+            per = {i: r[setting] for i, r in results.items() if isinstance(r.get(setting), dict)}
+            mine = [s for s in samples if s["id"] in per]
+            totals = lab.benchmark(mine, per)["totals"]
+            settings.append({"key": setting, "pool": pool, "window": "wide" if window is None else window,
+                             "quality": lab.quality(totals), "partial": lab.quality_partial(totals),
+                             "totals": {k: totals[k] for k in keep}, "vowels": lab.vowel_stats(mine, per),
+                             # the sounds this setting scored otherwise than `ref`, of the sounds both scored
+                             "changed": sum(a != b for i, r in results.items() if isinstance(r.get(ref), dict)
+                                            and i in per for a, b in zip(scores(per[i]), scores(r[ref]))),
+                             "sounds": sum(len(scores(per[i])) for i in per)})
+        # by quality; its ties (the flags rarely see a vowel) by how well the vowels separate, then how few are weak
+        settings.sort(key=lambda r: (r["quality"] is None, -(r["quality"] or 0), -(r["vowels"]["auc"] or 0),
+                                     r["vowels"]["weak"] if r["vowels"]["weak"] is not None else 1,
+                                     -(r["vowels"]["mean"] or 0)))
+        g = app.state.scorer.cfg.gop
+        return {"settings": settings, "current": lab.sweep_key(g.ratio_pool, g.vowel_window), "recordings": len(samples),
+                "model": MODEL_ID, "version": build_version()}
 
     @app.post("/api/lab/results")
     def lab_rescored_results(body: dict = Body(...), a: SupabaseAuth = Depends(teacher_only)):
@@ -823,8 +1000,11 @@ def create_app(scorer: Scorer | None = None, tts: SawtakTTS | None = None,
         except AuthUnavailable as e:
             log.warning("confirmed flags not read for the lab: %s", e)
             reports = []
+        cfg = getattr(app.state.scorer, "cfg", None)   # the env, not the code, picks the pool: the version cannot tell
         return {"now": lab.benchmark(samples, results, reports), "stored": lab.benchmark(samples, reports=reports),
-                "model": MODEL_ID, "version": build_version()}
+                "model": MODEL_ID, "version": build_version(),
+                "pool": cfg.gop.ratio_pool if cfg else None,
+                "vowel_window": ("wide" if cfg.gop.vowel_window is None else f"±{cfg.gop.vowel_window}") if cfg else None}
 
     @app.post("/api/lab/flags/{flag_id}/rescore")
     def lab_rescore_flag(flag_id: int, a: SupabaseAuth = Depends(teacher_only)):

app/scorer.py

@@ -1,6 +1,7 @@
 """Pronunciation scorer: phoneme CTC model + forced alignment against the expected phonemes."""
 from __future__ import annotations
 
+import copy
 import json
 import logging
 import os
@@ -19,6 +20,8 @@ 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) | set(_HEB_HEARD)
+# a vowel gliding into (or out of) j or w passes through these: on the frames between the two, coarticulation
+GLIDE_KIN = {"j": ("i", "iː", "e", "eː"), "w": ("u", "uː", "o", "oː")}
 
 log = logging.getLogger("ihki.scorer")
 
@@ -250,6 +253,13 @@ class Scorer:
         self.named = {i for i in (vocab.sound_id(n) for n in names) if i is not None}
         self.disabled: frozenset[str] = frozenset()  # rules.TOGGLES the teacher switched off (ניטור)
 
+    def with_gop(self, **changes) -> "Scorer":
+        """This scorer with some GopConfig fields changed (ratio_pool, vowel_window ...), sharing its model, vocab and
+        rules: for the lab's sweep over the settings. Nothing of this scorer changes."""
+        other = copy.copy(self)
+        other.cfg = replace(self.cfg, gop=replace(self.cfg.gop, **changes))
+        return other
+
     def set_disabled(self, ids) -> None:
         """Atomically replaces the switched-off rules; unknown ids are ignored."""
         self.disabled = frozenset(ids) & TOGGLE_IDS
@@ -279,6 +289,13 @@ class Scorer:
 
     _GLIDES = {"w", "j"}  # the way into or out of a glide sounds like a vowel in anyone's speech
 
+    def _glide_edges(self, toks: list[TargetToken]) -> list[tuple[set[int], set[int]] | None]:
+        """For a vowel beside j or w: the vowels that glide is made of (GLIDE_KIN), no competitor on the frames
+        between the vowel and that glide."""
+        kin = lambda k: {x for p in GLIDE_KIN.get(toks[k].phoneme, ()) if (x := self.vocab.sound_id(p)) is not None}
+        return [(kin(i - 1) if i else set(), kin(i + 1) if i + 1 < len(toks) else set())
+                if t.phoneme in VOWELS else None for i, t in enumerate(toks)]
+
     def _insertions(self, logp: np.ndarray, toks: list[TargetToken], al: Alignment) -> dict[int, str]:
         """Rules 3.10: token -> the vowel the model clearly heard between it and the consonant before it, in one word
         (katiir for ktiir). The cluster that opens the sentence is spared (6.3 #16), and so are pairs with w or j."""
@@ -321,7 +338,11 @@ class Scorer:
         """The baseline from a native recording of the phrase, or None when the model does not
         recognise the phrase in it (then it says nothing about single sounds)."""
         logp = self.emit(wav)
-        fit = self._fit(self.vocab.merge(logp), phrase, frame_energy(wav, len(logp)))
+        return self.reference_logp(logp, phrase, frame_energy(wav, len(logp)))
+
+    def reference_logp(self, logp: np.ndarray, phrase: dict, energy: np.ndarray | None = None) -> Reference | None:
+        """Scorer.reference from the model's posteriors of the native recording (`emit`), and its frame energy."""
+        fit = self._fit(self.vocab.merge(logp), phrase, energy)
         if fit is None:
             return None
         if fit.unrelated or float(np.mean([sc.score for sc in fit.scores])) < self.cfg.ref_min_mean:
@@ -457,7 +478,8 @@ class Scorer:
         ids = [t.id for t in toks]
         ar_words = ar.split()
         scores = score_tokens(ext, al, ids, blank, self.cfg.gop, [vocab.members.get(i) for i in ids],
-                              vocab.n_real, self.named if self._on("unnamed_sounds") else None)
+                              vocab.n_real, self.named if self._on("unnamed_sounds") else None, energy,
+                              vowels=[t.phoneme in VOWELS for t in toks], edges=self._glide_edges(toks))
         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

data/minerva_metadata.json

@@ -0,0 +1,114 @@
+[
+  {
+    "file_name": "במכולת ＊ פִי א-דֻכַּאן ＊  في الدّكّان ＊ קטע שיחה בערבית מדוברת [U8aBRd3-wlM].webm",
+    "youtube_id": "U8aBRd3-wlM",
+    "title_hebrew": "במכולת",
+    "segments": [
+      {
+        "voice_time_seconds": {"start": 9.0, "end": 10.8},
+        "arabic": "فيه عندك حليب طازة؟",
+        "hebrew_transliteration": "פִיה עִנְדַכּ חַלִיב טַאזֶה?",
+        "hebrew": "יש לך חלב טרי?",
+        "expected_phonemes": "f iː h | ʕ i n d a k | ħ a l iː b | tˤ aː z e"
+      },
+      {
+        "voice_time_seconds": {"start": 10.8, "end": 12.8},
+        "arabic": "آه، جوّا في التلّاجة، على إيدك اليمين.",
+        "hebrew_transliteration": "אַה, גֻ'וַּא פִי ת-תַּלַּאגֶ'ה, עַלַא אִידֶכּ לְ-יַמִין.",
+        "hebrew": "כן, בפנים במקרר, מימינך.",
+        "expected_phonemes": "ʔ aː | dʒ u w a | f i | t t a l aː dʒ e | ʕ a l a | ʔ iː d e k | l j a m iː n"
+      },
+      {
+        "voice_time_seconds": {"start": 12.8, "end": 14.2},
+        "arabic": "ممتاز.",
+        "hebrew_transliteration": "מֻמְתַאז.",
+        "hebrew": "מצוין.",
+        "expected_phonemes": "m u m t aː z"
+      },
+      {
+        "voice_time_seconds": {"start": 14.2, "end": 17.6},
+        "arabic": "ممكن تحطّلي كمان وقيّة جبنة صفرا؟",
+        "hebrew_transliteration": "מֻמְכּן תְחֻטְלִי כַּמַאן וַקִיַּת גֻ'בְּנֶה צַפְרַא?",
+        "hebrew": "אפשר לשים לי גם חבילת גבינה צהובה?",
+        "expected_phonemes": "m u m k n | t ħ u tˤ l i | k a m aː n | w a ʔ i j a t | dʒ u b n e | sˤ a f r a"
+      },
+      {
+        "voice_time_seconds": {"start": 17.6, "end": 21.8},
+        "arabic": "آه طبعًا، بس ثواني أخلّص معاه الحساب...",
+        "hebrew_transliteration": "אַה טַבְּעַן, בַּס תְוַאנִי אַחְ'לַצ מַעַאה לְ-חִסַאב.",
+        "hebrew": "כן, כמובן, רק רגע שאסיים איתו את החשבון.",
+        "expected_phonemes": "ʔ aː | tˤ a b ʕ a n | b a s | t w aː n i | ʔ a x l a sˤ | m a ʕ aː h | l ħ i s aː b"
+      },
+      {
+        "voice_time_seconds": {"start": 21.8, "end": 24.6},
+        "arabic": "تفضّلي. شكرًا!",
+        "hebrew_transliteration": "תְפַדַّל. שֻכְּרַן!",
+        "hebrew": "בבקשה. תודה!",
+        "expected_phonemes": "t f a dˤ dˤ a l | ʃ u k r a n"
+      },
+      {
+        "voice_time_seconds": {"start": 24.6, "end": 27.6},
+        "arabic": "هذا هو؟ أيوة، قديش الحساب؟",
+        "hebrew_transliteration": "הַאדַא הֻוֶּ? אַיוַה, קַדֵּיש לְ-חִסַאב?",
+        "hebrew": "זהו? כן, כמה החשבון?",
+        "expected_phonemes": "h aː d a | h u w e | ʔ a j w a | ʔ a d eː ʃ | l ħ i s aː b"
+      },
+      {
+        "voice_time_seconds": {"start": 27.6, "end": 30.4},
+        "arabic": "٢٥ شيكل. تفضّل.",
+        "hebrew_transliteration": "חַ'מְסֶה וְעִשְרִין שֵיקֶל. תְפַדַّל.",
+        "hebrew": "עשרים וחמישה שקל. בבקשה.",
+        "expected_phonemes": "x a m s e | u ʕ i ʃ r iː n | ʃ eː ʔ e l | t f a dˤ dˤ a l"
+      },
+      {
+        "voice_time_seconds": {"start": 30.4, "end": 33.0},
+        "arabic": "معكيش أصغر؟ معيش صرافة ميّة...",
+        "hebrew_transliteration": "מַעְכִּיש אַצְעַ'ר? מַעִיש צַרַאפֶת מִיֶּה.",
+        "hebrew": "אין לך קטן יותר? אין לי עודף ממאה.",
+        "expected_phonemes": "m a ʕ k iː ʃ | ʔ a z ɣ a r | m a ʕ iː ʃ | sˤ a r aː f e t | m i j e"
+      },
+      {
+        "voice_time_seconds": {"start": 33.0, "end": 35.4},
+        "arabic": "لحظة أفحص...",
+        "hebrew_transliteration": "לַחְטַ'ה אַפְחַצ.",
+        "hebrew": "רגע, אבדוק.",
+        "expected_phonemes": "l a ħ ðˤ a | ʔ a f ħ a sˤ"
+      },
+      {
+        "voice_time_seconds": {"start": 35.4, "end": 39.2},
+        "arabic": "لا والله معيش، فيه بس ٢٠ إذا بفيدوك.",
+        "hebrew_transliteration": "לַא וַאללַה מַעִיש, פִיה בַּס עִשְרִין אִדַ'א בִּפִידַכּ.",
+        "hebrew": "לא, בחיי, אין לי; יש רק עשרים, אם זה עוזר לך.",
+        "expected_phonemes": "l aː | w aː l l a | m a ʕ iː ʃ | f iː h | b a s | ʕ i ʃ r iː n | ʔ i dˤ a | b i f iː d a k"
+      },
+      {
+        "voice_time_seconds": {"start": 39.2, "end": 42.8},
+        "arabic": "لا معلش، مش مهم، بدبّرها.",
+        "hebrew_transliteration": "לַא מַעְלֵיש, מֻש מֻהִם, בַּדַבֶּרְהַא.",
+        "hebrew": "לא נורא, לא חשוב, אסתדר.",
+        "expected_phonemes": "l aː | m a ʕ l eː ʃ | m u ʃ | m u h i m | b a d a b e r h a"
+      },
+      {
+        "voice_time_seconds": {"start": 42.8, "end": 44.6},
+        "arabic": "تفضّلي الباقي، معوّضين.",
+        "hebrew_transliteration": "תְפַדַّלִי אִלְ-בַּאקִי, מְעַוַّדִין.",
+        "hebrew": "הנה העודף, תבואי שוב.",
+        "expected_phonemes": "t f a d d a l i | i l b aː ʔ i | m ʕ a w w a d iː n"
+      },
+      {
+        "voice_time_seconds": {"start": 44.6, "end": 46.4},
+        "arabic": "تسلم، يعطيك العافية!",
+        "hebrew_transliteration": "תִסְלַם, יַעְטִיכּ אִלְ-עַאפְיֶה!",
+        "hebrew": "תודה, שיהיה לך כוח ובריאות!",
+        "expected_phonemes": "t i s l a m | j a ʕ tˤ iː k | i l ʕ aː f j e"
+      },
+      {
+        "voice_time_seconds": {"start": 46.4, "end": 48.4},
+        "arabic": "الله يعافيك، مع السلامة!",
+        "hebrew_transliteration": "אַללַה יְעַאפִיכּ, מַע אִלְ-סַלַאמֶה!",
+        "hebrew": "שאלוהים ייתן לך בריאות, להתראות!",
+        "expected_phonemes": "i l l a | j ʕ aː f iː k | m a ʕ | i l s a l aː m e"
+      }
+    ]
+  }
+]

docs/gop-pooling.md

@@ -0,0 +1,158 @@
+# GOP frame pooling
+
+How `score_tokens` ([app/align.py](../app/align.py)) turns a token window's frames into one target score and one
+competitor score, and why short vowels need something other than the max. Benchmark:
+`python scripts/gop_pooling_bench.py`. Tests: [tests/test_gop_pooling.py](../tests/test_gop_pooling.py).
+
+## Notation
+
+- Window of token *i*: `W = [a, b)`, from the end of token *i−1* to the start of token *i+1*. `n = |W|`.
+- `p_t(k)` is the posterior of column *k* at frame *t*, and `ℓ_t(k) = log p_t(k)`. *y* is the target.
+- *C* is the set of competitors: every column except blank, the target, its two neighbours, and their accepted realisations.
+- A pool `P(k)` maps the window to one posterior-like value per column. The score is:
+
+```
+GOP   = log P(y) − max(log P(y), max_{c∈C} log P(c))          ≤ 0
+p̂     = max_t p_t(y)                                           (always the max, whatever P is)
+score = 100 · exp(λ · GOP) · sqrt(min(1, p̂ / κ))               λ = 0.5, κ = 0.30
+```
+
+The change is the split between the two terms. **`ratio_pool` changes only `P`, the relative evidence. The
+presence term `p̂` and the deletion test stay max-pooled.** The reason is below (result 1).
+
+## The pools
+
+| `ratio_pool` | `P(k)` | Limits |
+|---|---|---|
+| `max` (old behaviour) | `max_t p_t(k)` | — |
+| `mean` | `(1/n) Σ_t p_t(k)` | — |
+| `topk` | `(1/K) Σ_{t ∈ top-K of k} p_t(k)` (each column uses its own best K frames) | K=1 → max, K=n → mean |
+| `lse` | `(1/n Σ_t p_t(k)^{1/τ})^τ`, which is `τ·(LSE_t(ℓ_t(k)/τ) − log n)` | τ→0 → max, τ=1 → mean |
+| `energy` | `Σ_t w_t p_t(k)`, with `w_t ∝ ẽ_t^γ` | γ=0 → mean |
+| `gated` | mean over `{t : ẽ_t ≥ θ}` | θ=0 → mean |
+
+`ẽ_t` is the frame's RMS, max-filtered over ±`energy_spread` frames and divided by the loudest frame in the
+window. The token's own aligned span always gets `w = 1`: if the gate dropped the frame where the token was
+emitted, the target would fall to ≈0 (3.7/100 in the benchmark without this guard).
+
+All pools work in the **probability** domain. The literal alternative, a weighted mean of frame log-ratios
+`Σ w_t (ℓ_t(y) − ℓ_t(c))`, breaks on CTC output. On blank frames both posteriors are ~1e-4, so their log-ratio
+is noise of order ±5. A single frame where the target is at its floor adds −9 to the sum. Mixing in the
+probability domain caps what any one frame can contribute at `w_t`.
+
+## Results
+
+**1. A symmetric pool cannot tell two single-frame spikes apart.** If the target and the competitor each occupy
+one frame, with heights `h_y` and `h_c`, every pool above gives `P(y)/P(c) = h_y/h_c`: the dilution factor
+(`1/n`, `1/K`, `n^{−τ}`) is the same for both. A pool only helps when the two differ in **support** (how many
+frames they cover) or in **location** (loud or quiet frames). A correct CTC vowel is itself a 1–2 frame spike,
+so its *presence* has to be read with the max. That is why `p̂` is never pooled.
+
+**2. The mass ratio does not depend on window length; the presence term does.** For `mean`:
+`P(y)/P(c) = Σ p_t(y) / Σ p_t(c)`, so the `1/n` cancels. Unweighted averaging hurts only when the averaged
+value also feeds the confidence. A 0.92 one-frame emission in a 10-frame window gives `P = 0.092`, so
+`sqrt(0.092/0.30) = 0.55`: score 55, which is the "naive" column in the benchmark.
+
+**3. Mass pooling accumulates haze.** A faint competitor at ε per frame adds up to `n·ε`, while the target stays one
+peak. When a hesitation stretches the window, `mean` loses (a 0.05 schwa haze: 100 at 20 frames, 83 at 30, 63
+at 50). `gated` and `energy` drop the silent frames. `topk` caps the competitor at its K best frames.
+
+**4. Spike sensitivity.** For a correct /a/ with frames .2/.4/.35 and a one-frame /i/ spike of height *h* inside the window:
+
+| h | max | mean / energy / gated | top2 | top3 | lse τ=.5 | lse τ=.25 |
+|---|---|---|---|---|---|---|
+| .5 | 89 | 100 | 100 | 100 | 100 | 95 |
+| .9 | 67 | 100 | 91 | 100 | 79 | 71 |
+| .98 | 64 | 98 | 88 | 98 | 76 | 68 |
+
+LSE moves smoothly between max and mean. With r = 1/τ = 2 it still prefers one 0.9 frame to three moderate
+ones, so it absorbs a tall spike only partly.
+
+**5. Substitutions still fail.** Every pool scores the sustained /i/-for-/a/ case at about 20, and the one-frame
+substitution at about 6. The one-frame substitution is also a single spike, but there the target is *absent*
+(`p̂` ≈ .03), so both the ratio and the presence term are low. A pool only rescues a target that is clearly present.
+
+**6. Separation.** Margin between the worst correct vowel and the best substitution in the synthetic set: max 46,
+lse 59, top2 70, mean / energy / gated / top3 80. These are synthetic numbers. Use them to rank the pools, not to set thresholds.
+
+## Class-based windows
+
+`compute_token_gop` reads each token from a window chosen by its class (`token_window`):
+
+- **Consonants: wide**, `[end(i−1), start(i+1))`. When the alignment forces a path through a consonant that was
+  substituted, the sound actually said peaks in the blanks around the forced frame
+  (`consonant: competitor in blanks`: wide 15.8, competitor q; read narrow, q is lost).
+- **Vowels: `GOP_VOWEL_WINDOW`** (`GopConfig.vowel_window`). `wide` (the default), or the aligned span ± pad
+  (`narrow` = ±1), clamped to the wide window. Only the **competitor ratio** uses the narrow window. Presence
+  (`peak`) and `deleted` are always read from the wide window, so a vowel aligned to a single frame is still found
+  deleted, and a strong competitor anywhere in the wide window still blocks a deletion (it is a substitution, not a
+  deletion).
+- **Glides**: for a vowel next to j or w, the vowels that glide is made of (j: i iː e eː; w: u uː o oː;
+  `GLIDE_KIN` in scorer.py) do not count as competitors **on the frames between the vowel's span and the glide**,
+  for the ratio and for the deletion test. Inside the vowel's own span they still count, so /ji/ said for /ja/ fails.
+  This is always on and does not depend on the window setting.
+
+CTC Viterbi gives every token at least one frame, so a span of 0 frames cannot happen; a deleted vowel gets one.
+
+### Why the vowel window defaults to wide
+
+From `python scripts/gop_window_bench.py` (spans from `ctc_viterbi`, no audio):
+
+| case | want | wide max | pad 1 max | wide mean |
+|---|---|---|---|---|
+| spike in transition | pass | 74.5 | 100 | 100 |
+| displaced substitution (/a/ .35, /i/ .85 held 2 frames later) | fail | 64.2 | **100** | 46.1 |
+| margin (worst pass − best fail) | | 10.3 | **0.0** | 53.9 |
+
+The narrow window drops the transition spike by not looking at those frames, so it also stops seeing a real
+vowel held outside span ± pad. Each pad goes blind beyond its reach: pad 0 at 1 frame away, pad 1 at 2, pad 2 at 3.
+A pooled ratio over the wide window drops the same spike by its support (one frame against several), and still
+sees the held substitution. A pooled ratio over a narrow window inherits the blind spot (pad1 mean: 100).
+So the default is wide plus a pooled ratio. Use `narrow` when the lab shows vowel false flags whose competitor
+sits in the transitions and pooling does not clear them.
+
+The displaced case needs the target to be weakly present elsewhere. In a plain substitution the aligner usually
+puts the target on the substituted frames, where every pad sees the competitor (`sustained substitution`: 21
+everywhere).
+
+## Failure modes
+
+- **Voiceless neighbours.** RMS measures loudness, not voicing. A vowel next to /s ʃ f/ shares its window
+  with sibilant frication, which can be as loud as the vowel. `energy` then puts weight on the fricative frames,
+  and a competitor spike there counts in full. A vowel before /t k q ʔ/ ends in a quiet devoiced tail; the gate
+  drops it, which is usually the intent. A voicing feature (low-band energy, or autocorrelation periodicity) would
+  be a better weight than RMS.
+- **Pharyngeals and emphatics.** Next to ʕ ħ sˤ tˤ, /a/ backs to [ɑ], which is a *sustained* competitor across the
+  whole nucleus. That is coarticulation, but it looks like a real substitution to every pool. Pooling cannot fix it;
+  the near-vowel floor and the exemptions in `rules.py` handle it.
+- **Fast speech.** Windows of 1–3 frames: `n == 1` returns the max; with small *n*, `topk` and `mean` agree, and
+  the energy nucleus may be a single frame that the ±1 spread blends with the consonants. All pools converge to
+  roughly the max, which is fine: there are no frames for a spike to hide in.
+- **The spread cuts both ways.** `energy_spread` forgives a CTC emission one frame off the nucleus, but it also
+  lifts a competitor spike one frame off the nucleus over the gate. The span guard already protects the target,
+  so `energy_spread=0` rejects spikes better; keep 1 until real data shows CTC peaks landing outside the alignment.
+- **Short-vowel deletion** (colloquial elision of unstressed /i/, /u/). `deleted` still reads the max peaks, so it
+  does not change. The ratio of a deleted vowel is target floor vs. whatever the consonants leak into the window. The gate keeps the
+  consonant frames because they are loud, so a deleted vowel should score about the same as before (not covered
+  by the synthetic set yet).
+- **A real one-frame vowel that is in between** (target 0.4, competitor 0.9, both one frame) gives the same
+  ratio under every pool (result 1). It is irreducible: the model is unsure which vowel it heard.
+- **Quiet consonants** (ʔ h ʕ). Energy pools would discard exactly the frames these live in, so
+  `pool_vowels_only` (default on) keeps the max for every consonant.
+- **No audio.** `energy` and `gated` fall back to `mean` when `score_logp` gets no `energy` (for example a rescore
+  from cached posteriors), and inherit its haze problem. Use `topk` there, or pass the energy along.
+
+## Rollout
+
+The pool comes from the env var `GOP_RATIO_POOL` (empty: `gated`; see `.env.example`). `max` reproduces the old
+scores exactly (`test_max_pool_is_the_previous_scorer`). The lab shows the pool beside the version, since the version
+hashes only the code.
+Switching changes the GOP distribution for vowels, which moves toward 0, so everything tuned on it has to be refreshed:
+
+1. the margins in `rules` (`Scorer._margin`) and the native-reference baselines (`_baseline`): re-record the references;
+2. the calibration floors (`set_calibrations`): rerun `scripts/rescore.py` on the labelled set;
+3. the teacher trace still reports `p_target` and `p_competitor` as maxima, so with a pooled ratio a competitor
+   can show a higher peak than the target while the GOP is 0.
+
+Suggested setting: `ratio_pool="gated"` (θ = 0.3, about −10 dB), `pool_vowels_only=True`, with `topk` K=3 as the
+setting when there is no audio.

scripts/bench.py

@@ -74,13 +74,12 @@ def main() -> int:
         return scorer.score(decode_audio(audio), phrase, refs.get(key, phrase) if refs else [])
     new: dict[int, dict] = {}
     for k, s in enumerate(samples, 1):
-        item = lab.BY_ID.get(s["item"])
-        if item is None:   # an item since dropped from the list
+        phrase = lab.sample_phrase(s)
+        if phrase is None:   # a legacy row without enough information to reconstruct its phrase
             continue
         try:
             found = auth.lab_audio(s["id"])
             if found:
-                phrase = lab.phrase(item)
                 new[s["id"]] = score(found[0], phrase, phrase["key"])
         except (AuthUnavailable, ValueError) as e:
             print(f"sample {s['id']}: skipped ({e})", file=sys.stderr)

scripts/gop_pooling_bench.py

@@ -0,0 +1,68 @@
+"""Compare the GOP frame pools (GopConfig.ratio_pool) on the synthetic CTC scenarios of tests/test_gop_pooling.py.
+
+    python scripts/gop_pooling_bench.py
+
+Prints the /a/ score per scenario and pool, the margin between the worst correct vowel and the best
+substitution (higher separates better), then two sweeps: a spurious spike's height, and a faint
+competitor haze over a growing silent window.
+"""
+from __future__ import annotations
+
+import sys
+from dataclasses import replace
+from pathlib import Path
+
+import numpy as np
+
+sys.path.insert(0, str(Path(__file__).resolve().parents[1]))
+
+from app.align import Alignment, GopConfig, score_tokens  # noqa: E402
+from tests.test_gop_pooling import A, BLANK, CONFIGS, I, K, SCENARIOS, SCHWA, T_, TOKENS, V, emissions, \
+    naive_mean_score, score_a  # noqa: E402
+
+CONFIGS = {**CONFIGS, "lse.25": GopConfig(ratio_pool="lse", pool_tau=0.25),
+           "gated0": GopConfig(ratio_pool="gated", energy_spread=0)}
+
+
+def table() -> None:
+    names = list(CONFIGS)
+    print(f"{'scenario':24}{'want':>6}" + "".join(f"{n:>8}" for n in names) + f"{'naive':>8}")
+    for sc in SCENARIOS:
+        row = [score_a(sc, cfg).score for cfg in CONFIGS.values()]
+        print(f"{sc.name:24}{'pass' if sc.good else 'fail':>6}" + "".join(f"{x:8.1f}" for x in row)
+              + f"{naive_mean_score(sc):8.1f}")
+    margin = []
+    for cfg in CONFIGS.values():
+        good = [score_a(s, cfg).score for s in SCENARIOS if s.good]
+        bad = [score_a(s, cfg).score for s in SCENARIOS if not s.good]
+        margin.append(min(good) - max(bad))
+    print(f"{'margin (min ok - max bad)':30}" + "".join(f"{x:8.1f}" for x in margin))
+
+
+def spike_sweep() -> None:
+    print("\nspurious /i/ spike in the nucleus vs a correct /a/ of .2/.4/.35")
+    print(f"{'spike':>6}" + "".join(f"{n:>8}" for n in CONFIGS))
+    for h in (.3, .5, .7, .9, .98):
+        sc = replace(SCENARIOS[1], logp=emissions({4: {A: .2}, 5: {A: .4}, 6: {A: .35}, 8: {I: h}}))
+        print(f"{h:6.2f}" + "".join(f"{score_a(sc, cfg).score:8.1f}" for cfg in CONFIGS.values()))
+
+
+def haze_sweep() -> None:
+    print("\none-frame /a/ at .9, a .05 schwa haze, a silent pause growing the window")
+    print(f"{'frames':>6}" + "".join(f"{n:>8}" for n in CONFIGS))
+    for n in (10, 15, 20, 30, 50):
+        p = np.full((n, V), 1e-4)
+        p[:, SCHWA] = .05
+        p[1, K], p[5, A], p[n - 2, T_] = .9, .9, .9
+        p[:, BLANK] = 0
+        p[:, BLANK] = 1 - p.sum(1)
+        energy = np.r_[[.3, .6, .5], np.ones(4), np.full(n - 9, .02), [.5, .1]]
+        al = Alignment(0.0, [(1, 2), (5, 6), (n - 2, n - 1)])
+        row = [score_tokens(np.log(p), al, TOKENS, BLANK, cfg, energy=energy)[1].score for cfg in CONFIGS.values()]
+        print(f"{n:6d}" + "".join(f"{x:8.1f}" for x in row))
+
+
+if __name__ == "__main__":
+    table()
+    spike_sweep()
+    haze_sweep()

scripts/gop_window_bench.py

@@ -0,0 +1,53 @@
+"""Compare GOP windows (GopConfig.vowel_window) and pools on the synthetic cases of tests/test_gop_window.py.
+
+    python scripts/gop_window_bench.py
+
+The spans come from ctc_viterbi. The cases have no audio, so "gated" falls back to the plain mean here
+(scripts/gop_pooling_bench.py measures the energy pools). Prints the score of the token under test per case and
+setting, and the margin between the worst token said right and the best one said wrong (higher separates better);
+then how far a substituted vowel can sit from the aligned span before each pad stops seeing it.
+"""
+from __future__ import annotations
+
+import sys
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).resolve().parents[1]))
+
+from app.align import GopConfig  # noqa: E402
+from tests.test_gop_window import A, CASES, I, K, T_, Case, score  # noqa: E402
+
+SETTINGS = {
+    "wide max": GopConfig(ratio_pool="max", vowel_window=None),
+    "pad0 max": GopConfig(ratio_pool="max", vowel_window=0),
+    "pad1 max": GopConfig(ratio_pool="max", vowel_window=1),
+    "pad2 max": GopConfig(ratio_pool="max", vowel_window=2),
+    "wide mean": GopConfig(ratio_pool="mean", vowel_window=None),
+    "pad1 mean": GopConfig(ratio_pool="mean", vowel_window=1),
+}
+
+
+def table() -> None:
+    print(f"{'case':34}{'want':>6}" + "".join(f"{n:>11}" for n in SETTINGS))
+    for c in CASES:
+        print(f"{c.name:34}{'pass' if c.good else 'fail':>6}"
+              + "".join(f"{score(c, cfg).score:11.1f}" for cfg in SETTINGS.values()))
+    margins = []
+    for cfg in SETTINGS.values():
+        good = [score(c, cfg).score for c in CASES if c.good]
+        bad = [score(c, cfg).score for c in CASES if not c.good]
+        margins.append(min(good) - max(bad))
+    print(f"{'margin (min ok - max bad)':40}" + "".join(f"{m:11.1f}" for m in margins))
+
+
+def distance_sweep() -> None:
+    print("\n/a/ at .35 on frame 4, /i/ held two frames at .85, d frames after the /a/")
+    print(f"{'d':>4}" + "".join(f"{n:>11}" for n in SETTINGS))
+    for d in range(1, 7):
+        c = Case("", [K, A, T_], {1: {K: .9}, 4: {A: .35}, 4 + d: {I: .85}, 5 + d: {I: .85}, 13: {T_: .9}}, 1, False, n=15)
+        print(f"{d:4d}" + "".join(f"{score(c, cfg).score:11.1f}" for cfg in SETTINGS.values()))
+
+
+if __name__ == "__main__":
+    table()
+    distance_sweep()

scripts/import_minerva.py

@@ -0,0 +1,243 @@
+#!/usr/bin/env python3
+"""Import the three-video Minerva pilot into the lab as native, correctly spoken samples.
+
+The videos have no subtitle stream.  PIL/Tesseract are deliberately not dependencies: the reviewed, pointed-Hebrew
+captions and the detected time spans are the pilot manifest below.  ``app.texts.text_phrases`` remains the single
+source of Arabic spelling and IPA, exactly as it is for teacher-authored texts.
+
+Usage:
+    python scripts/import_minerva.py --dry-run
+    python scripts/import_minerva.py --email teacher@example.com
+
+Existing ``minerva:<video-id>:<line>`` rows are skipped, making an interrupted import safe to resume.
+"""
+from __future__ import annotations
+
+import argparse
+import os
+import subprocess
+import sys
+import uuid
+from dataclasses import dataclass
+from datetime import date
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).resolve().parent.parent))
+
+from dotenv import load_dotenv  # noqa: E402
+
+from app import lab  # noqa: E402
+from app.auth import AuthUnavailable, load_auth  # noqa: E402
+from app.main import MODEL_ID, build_version  # noqa: E402
+from app.reference import References  # noqa: E402
+from app.scorer import decode_audio, load_scorer  # noqa: E402
+from app.texts import text_phrases  # noqa: E402
+from app.tts import VOICES, load_tts  # noqa: E402
+
+SPEAKER = "מינרווה"
+
+
+@dataclass(frozen=True)
+class Video:
+    youtube_id: str
+    title: str
+    lines: tuple[tuple[float, float, str], ...]
+
+
+# Caption changes were measured at 5 fps.  The first story line is its spoken title, before the first full caption.
+PILOT = (
+    Video("U8aBRd3-wlM", "במכולת", (
+        (9.0, 10.8, "פִיה עִנְדַכּ חַלִיב טַאזֶה?"),
+        (10.8, 12.8, "אַה, גֻ'וַּא פִי ת-תַּלַּאגֶ'ה, עַלַא אִידֶכּ לְ-יַמִין."),
+        (12.8, 14.2, "מֻמְתַאז."),
+        (14.2, 17.6, "מֻמְכּן תְחֻטְלִי כַּמַאן וַקִיַּת גֻ'בְּנֶה צַפְרַא?"),
+        (17.6, 21.8, "אַה טַבְּעַן, בַּס תְוַאנִי אַחְ'לַצ מַעַאה לְ-חִסַאב."),
+        (21.8, 24.6, "תְפַדַّל. שֻכְּרַן!"),
+        (24.6, 27.6, "הַאדַא הֻוֶּ? אַיוַה, קַדֵּיש לְ-חִסַאב?"),
+        (27.6, 30.4, "חַ'מְסֶה וְעִשְרִין שֵיקֶל. תְפַדַّל."),
+        (30.4, 33.0, "מַעְכִּיש אַצְעַ'ר? מַעִיש צַרַאפֶת מִיֶּה."),
+        (33.0, 35.4, "לַחְטַ'ה אַפְחַצ."),
+        (35.4, 39.2, "לַא וַאללַה מַעִיש, פִיה בַּס עִשְרִין אִדַ'א בִּפִידַכּ."),
+        (39.2, 42.8, "לַא מַעְלֵיש, מֻש מֻהִם, בַּדַבֶּרְהַא."),
+        (42.8, 44.6, "תְפַדַّלִי אִלְ-בַּאקִי, מְעַוַّדִין."),
+        (44.6, 46.4, "תִסְלַם, יַעְטִיכּ אִלְ-עַאפְיֶה!"),
+        (46.4, 48.4, "אַללַה יְעַאפִיכּ, מַע אִלְ-סַלַאמֶה!"),
+    )),
+    Video("OuAwxXUZBU4", "אסיפת הורים", (
+        (8.8, 11.8, "תַמַאם, כִּיפֶכּ? שוּ צַאר מַעֶכּ?"),
+        (11.8, 14.2, "בְּסֵידֶר, אִסַּא טִלְעֵת מִן אִלְ-מַדְרַסֶה."),
+        (14.2, 17.4, "קַעַדֶת מַע אִלְ-מֻרַבִּיֶה וּבַּאקִי לְ-מֻעַלִּמַאת."),
+        (17.4, 21.2, "מִיס נַוַאל בְּתְקוּל אִנּוּ רַבִּיע וַלַד בִּגַ'נֵּן וְעַקְלוֹ כְּבִּיר."),
+        (21.2, 24.4, "מֻאַדַّבּ, בְּחִבּ יְסַאעֶד עֵ'ירוֹ, שַאטֶר וּפַתֶח."),
+        (24.4, 25.8, "בַּס מִתְל אִלְ-עַאדֶה."),
+        (25.8, 29.4, "לַאזֶם יִשְתַעֵ'ל אַכְּתַר עַלַא מַוְדוּע אִלְ-תַרְכִּיז."),
+        (29.4, 31.0, "כְּתִיר בִּשַתּ וּבִּסְרַח."),
+        (31.0, 35.8, "וְהַאדַא בִּחַלִּיה יַעְמַל אַעְ'לַאט זְעִ'ירֶה פִי דִּרַאסֶה."),
+        (35.8, 37.4, "הֵי וּבַּאקִי לְ-מֻעַלִּמַאת מִנְתַבְּהַאת."),
+        (37.4, 39.2, "אִנּוּ מֻשְכִּלְתוֹ מֻש עַדַם פַהֶם."),
+        (39.2, 41.0, "בִּלְ-עַכֶּס, עַרְבִּיהֶן שַאטֶר כְּתִיר."),
+        (41.0, 46.0, "בַּס מֻשְכִּלְתוֹ קִלֶּת תַרְכִּיז."),
+        (46.0, 49.4, "אִדַ'א הֵיכּ אִלְ-וַדְע פִש עַלַא שוּ נִקְלַק."),
+        (49.4, 52.6, "הֻוֶּ מְתַחַסֵּן כְּתִיר וּמֻש לַאזֶם נְדַקֵּק עַלַא כֻּל אִשִי."),
+        (52.6, 56.4, "רַאח יִתְעַ'יַּר מַע אִלְ-וַקְת וִלְ-גִ'יל אִלוֹ חַקּוֹ."),
+        (56.4, 59.8, "מַדְבּוּט. אַנַא בַּקוּל לַאזֶם נְגִ'יבְלוֹ הַדִיֶּה זְעִ'ירֶה."),
+        (59.8, 61.6, "מִתְל מַא וַעַדְנַאה."),
+        (61.6, 64.2, "אַה אַכִּיד, אִלְ-יוֹם מִנְטַלַע כֻּלְנַא מִשְוַאר."),
+        (64.2, 65.2, "וּמְנְגִ'יבְלוֹ שַעְ'לֶה."),
+        (65.2, 69.2, "חַ'לִּיה יְחִס אִנּוּ אִחְנַא מְקַדְּרִין תַעַבּוֹ וְגִ'דִּיֶּתוֹ."),
+        (69.2, 74.2, "טַיֵּב מֻמְתַאז, בְּלַא מַנְחַכִּי, בַּאי."),
+    )),
+    Video("V2y6LqnoXTo", "הקדרה", (
+        # The title is spoken over the intro card; 5.6-6.4 is the silent transition into the first story caption.
+        (0.4, 5.6, "אִלְ-טֻנְגַ'רַה וִלְדַת טֻנְגַ'רַה."),
+        (6.4, 10.2, "מַרַּה טַלַבּ גַ'מַא מִן גַ'ארוֹ יַעְטִיה טֻנְגַ'רַה כְּבִּירֶה."),
+        (10.2, 14.2, "עַשַאן יִקְדַר יִטְבַּח וְיִטְעַמִּי מַעַאזִימוֹ לְ-כֻּתַאר."),
+        (14.2, 17.2, "אִלִּי גַ'איִין עִנְדוֹ עַלַא אִלְ-עַ'דַא."),
+        (17.2, 21.0, "אִלְ-גַ'אר וַאפַק וְאַעְטַאה טֻנְגַ'רַה לְגַ'מַא."),
+        (21.0, 25.0, "בַּעְד אַכַּם יוֹם רַגַ'ע גַ'מַא אִלְ-טֻנְגַ'רַה לְ-כְּבִּירֶה."),
+        (25.0, 28.6, "וּבְּקַלְבְּהַא טֻנְגַ'רַה זְעִ'ירוֹנֶה."),
+        (28.6, 31.8, "סַאַל אִלְ-גַ'אר עַן הַאי טֻנְגַ'רַה לְ-זְעִ'ירֶה."),
+        (31.8, 36.2, "וְגַ'מַא פַסַּרְלוֹ אִנְהַא אִנְוַלַדַת מִן אִלְ-טֻנְגַ'רַה לְ-כְּבִּירֶה."),
+        (36.2, 40.4, "פִי לְ-פַתְרַה אִלִּי כַּאנֶת אִלְ-טֻנְגַ'רַה לְ-כְּבִּירֶה עִנְדוֹ."),
+        (40.4, 42.2, "קִבֵּל אִלְ-גַ'אר מִן גַ'מַא לְ-עַ'בִּי."),
+        (42.2, 45.8, "הַאי לְ-בִּנְת לְ-זְעִ'ירֶה בְּכֻל פַרַח וּסֻרוּר."),
+        (45.8, 48.4, "וּפִי קַלְבּוֹ תְחַוַּת עַלַא גַ'מַא."),
+        (48.4, 51.2, "אִנּוּ וַאחַד אַהְבַּל מַעְתוֹה."),
+        (51.2, 54.2, "בַּעְד אַכַּם יוֹם אַגַ'א גַ'מַא עִנְד גַ'ארוֹ."),
+        (54.2, 58.4, "יִטְלֻבּ מִנּוֹ יִמְסִכּוֹ אִלְ-טֻנְגַ'רַה כַּמַאן מַרַּה."),
+        (58.4, 61.0, "פְרִח אִלְ-גַ'אר וְקַאל פִי קַלְבּוֹ."),
+        (61.0, 64.0, "הַלַק בְּתוּלַד אִלְ-טֻנְגַ'רַה כַּמַאן בִּנְת."),
+        (64.0, 68.0, "וּמִין בִּעְרַף, בַּלְכִּי הַאי לְ-מַרַּה וַלַדַת תוֹאַם."),
+        (68.0, 72.6, "וְהֵיכּ מַסַכּ אִלְ-גַ'אר טֻנְגַ'רְתוֹ לְגַ'מַא."),
+        (72.6, 76.4, "מַרְקַת עִדֶּת אַיַּאם וְגַ'מַא מַא רַגַ'עְש אִלְ-טֻנְגַ'רַה."),
+        (76.4, 79.4, "עַשַאן הֵיכּ רַאח אִלְ-גַ'אר לְעִנְד גַ'מַא."),
+        (79.4, 81.8, "וְטַלַבּ מִנּוֹ יִרַגְ'עְהַא."),
+        (81.8, 85.6, "בַּס גַ'מַא קַאלְלוֹ אִנּוּ אִלְ-טֻנְגַ'רַה מַאתַת."),
+        (85.6, 88.0, "אִלְ-גַ'אר תְעַצַּב כְּתִיר וְקַאל."),
+        (88.0, 90.6, "כִּיף בְּתִסְמַח לְנַפְסַכּ תִתְחַוַּת עַלַיّ?"),
+        (90.6, 93.6, "שוּ? אִלְ-טֻנְגַ'רַה כַּאיְנֶה כַּאִן חַיّ?"),
+        (93.6, 95.8, "בְּתְעִיש וּבְּתְמוּת?"),
+        (95.8, 97.8, "גַ'מַא רַד עַלֵיה וְקַאל."),
+        (97.8, 101.0, "לַא סַמַח אַללַה, אִתְחַוַּת עַלַא שַחְ'צ מִתְלַכּ."),
+        (101.0, 104.4, "בַּס אִדַ'א מֻמְכִּן אִלְ-טֻנְגַ'רַה תוּלַד."),
+        (104.4, 106.4, "מַעְנַאה מֻמְכִּן אִנְהַא תְמוּת."),
+        (106.4, 113.8, "וְהַאדִי נִהַאיַת אִלְ-קִצַּה."),
+    )),
+)
+
+
+def source_file(folder: Path, youtube_id: str) -> Path:
+    found = sorted(folder.glob(f"*{youtube_id}*"))
+    if len(found) != 1:
+        raise ValueError(f"expected one video containing {youtube_id}, found {len(found)}")
+    return found[0]
+
+
+def wav_segment(video: Path, start: float, end: float) -> bytes:
+    command = ["ffmpeg", "-v", "error", "-ss", str(start), "-to", str(end), "-i", str(video),
+               "-vn", "-ac", "1", "-ar", "16000", "-c:a", "pcm_s16le", "-f", "wav", "-"]
+    done = subprocess.run(command, stdout=subprocess.PIPE, check=False)
+    if done.returncode or not done.stdout:
+        raise RuntimeError(f"ffmpeg could not extract {video.name} at {start:.1f}-{end:.1f}")
+    return done.stdout
+
+
+def phrases() -> tuple[list[tuple[Video, int, float, float, dict]], list[str]]:
+    out, guessed = [], []
+    for video in PILOT:
+        for number, (start, end, tr) in enumerate(video.lines, 1):
+            made, new = text_phrases(f"minerva:{video.youtube_id}", [[f"{video.title} {number}", tr]])
+            phrase = made[0]
+            phrase["key"] = f"minerva:{video.youtube_id}:{number:02d}"
+            out.append((video, number, start, end, phrase))
+            guessed.extend(x for x in new if x not in guessed)
+    return out, guessed
+
+
+def default_email() -> str:
+    raw = os.environ.get("MINERVA_IMPORT_EMAIL") or os.environ.get("TEACHER_EMAILS", "")
+    return raw.replace(",", " ").split()[0].lower() if raw.split() else ""
+
+
+def main() -> int:
+    ap = argparse.ArgumentParser(description=__doc__.splitlines()[0])
+    ap.add_argument("--videos-dir", type=Path, default=Path("/home/eyalshw/Videos/minerva"))
+    ap.add_argument("--email", default="", help="teacher email recorded as the importer (or MINERVA_IMPORT_EMAIL)")
+    ap.add_argument("--dry-run", action="store_true", help="validate videos, segments and transcripts; do not score/upload")
+    ap.add_argument("--verify", action="store_true", help="verify the 70 remote rows and audio names; do not score/upload")
+    ap.add_argument("--no-baseline", action="store_true", help="score without the native TTS baseline")
+    args = ap.parse_args()
+    load_dotenv()
+
+    entries, guessed = phrases()
+    if [len(v.lines) for v in PILOT] != [15, 22, 33] or len(entries) != 70:
+        raise RuntimeError("the Minerva pilot must stay exactly 15 + 22 + 33 = 70 lines")
+    files = {v.youtube_id: source_file(args.videos_dir, v.youtube_id) for v in PILOT}
+    for video, number, start, end, phrase in entries:
+        if end <= start or not phrase["variants"]:
+            raise ValueError(f"invalid line {video.youtube_id}:{number}")
+    print(f"validated {len(entries)} lines in {len(files)} videos")
+    if guessed and args.dry_run:
+        print(f"words read by rule ({len(guessed)}): {' '.join(guessed)}")
+    if args.dry_run:
+        return 0
+
+    email = (args.email or default_email()).strip().lower()
+    if not email:
+        print("give --email or set MINERVA_IMPORT_EMAIL/TEACHER_EMAILS", file=sys.stderr)
+        return 2
+    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
+    try:
+        remote = [s for s in auth.lab_samples() if (s.get("speaker") or "") == SPEAKER]
+        existing = {s["item"] for s in remote}
+    except AuthUnavailable as e:
+        print(f"lab is unavailable: {e}", file=sys.stderr)
+        return 2
+    if args.verify:
+        expected = {phrase["key"] for _, _, _, _, phrase in entries}
+        audio = sum(bool(s.get("audio")) for s in remote if s.get("item") in expected)
+        missing = sorted(expected - existing)
+        extra = sorted(existing - expected)
+        print(f"remote Minerva pilot: {len(expected & existing)}/70 rows, {audio}/70 audio files named")
+        if missing:
+            print(f"missing: {' '.join(missing)}")
+        if extra:
+            print(f"other Minerva rows: {' '.join(extra)}")
+        return 0 if not missing and audio == 70 else 1
+
+    model = os.environ.get("MODEL_ID", MODEL_ID)
+    scorer = load_scorer(model)
+    tts = None if args.no_baseline else load_tts()
+    refs = References(scorer, tts, list(VOICES.values())) if tts else None
+    saved = skipped = 0
+    for n, (video, number, start, end, phrase) in enumerate(entries, 1):
+        item = phrase["key"]
+        if item in existing:
+            skipped += 1
+            print(f"[{n:02d}/70] skip {item}")
+            continue
+        data = wav_segment(files[video.youtube_id], start, end)
+        wav = decode_audio(data)
+        baseline = refs.get(item, phrase) if refs else []
+        result = scorer.score(wav, phrase, baseline, diagnostics=True)
+        if result.get("error"):
+            raise RuntimeError(f"{item}: scoring failed: {result['error']}")
+        row = {"email": email, "item": item, "ar": result["variant"]["ar"], "ipa": result["variant"]["ipa"],
+               "speaker": SPEAKER, "label": "correct", "mistake": None,
+               "device": f"minerva:{video.youtube_id}:{start:.1f}-{end:.1f}", "score": result["score"],
+               "heard_ipa": result["heard_ipa"], "flagged": lab.flagged_sounds(result), "result": result,
+               "model": model, "version": build_version()}
+        name = f"{date.today():%Y-%m}/minerva-{video.youtube_id}-{number:02d}-{uuid.uuid4().hex}.wav"
+        if not auth.add_lab_sample(row, data, "audio/wav", name):
+            raise RuntimeError(f"{item}: row saved but audio upload failed; stop before creating more incomplete rows")
+        saved += 1
+        print(f"[{n:02d}/70] saved {item}: {result['score']}")
+    print(f"Minerva pilot complete: {saved} saved, {skipped} already present")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

static/index.html

@@ -456,6 +456,7 @@ body.driving .mic::before{display:none} body.driving .mic-zone.two{display:flex}
 #denied button{display:block;margin:12px auto 0;font:600 16px/1 var(--f-body);padding:10px 22px;border-radius:10px;border:1px solid #4B6A2C;background:#fff;color:#4B6A2C;cursor:pointer}
 /* The teacher's panel (its parts are styled further down: the class tabs, the figures, the lessons, the students). */
 body:not(.manage) #manage,body.lab #manage,body:not(.lab) #lab,body.manage #wrap>header,body.manage #path,body.manage #today,body.manage #toNow,body.manage #practice,body:not(.home) #toManage{display:none}
+body.lab #wrap{max-width:none}
 .mtitle{font:400 24px/1 var(--f-display);margin:0}
 #mState.setup{padding:10px 12px;border:1px solid var(--sumac);border-radius:10px;color:var(--ink)}
 #mState.setup code{display:block;margin-top:6px;font-size:12px;overflow-wrap:anywhere;user-select:all}
@@ -469,7 +470,7 @@ body:not(.manage) #manage,body.lab #manage,body:not(.lab) #lab,body.manage #wrap
 .build-info code{direction:ltr;unicode-bidi:isolate;user-select:all}
 #manage:not(.flags) #mBuild{display:none}
 /* The lab (מעבדה): the diagnostic list by group, each item a button with its count of recordings, and the item on show. */
-#lab{display:flex;flex-direction:column;gap:12px;width:100%;min-width:0;box-sizing:border-box}
+#lab{display:flex;flex-direction:column;gap:12px;width:100%;max-width:none;min-width:0;box-sizing:border-box}
 #lab>*,.lab-item>*{min-width:0}
 #labResult .stage-table-wrap{overflow-x:auto}
 .lab-who{flex-direction:row;flex-wrap:wrap;align-items:center;gap:10px 18px}
@@ -501,13 +502,43 @@ body:not(.manage) #manage,body.lab #manage,body:not(.lab) #lab,body.manage #wrap
 .lab-table th,.lab-table td{padding:5px 8px;border-bottom:1px solid var(--line);text-align:right;white-space:nowrap}
 .lab-table th{color:var(--muted);font-weight:600;font-size:12px}
 .lab-table .ipa{direction:ltr;unicode-bidi:isolate;font-family:ui-monospace,monospace}
+#labTraceRec{max-width:100%;min-width:0;flex:1 1 220px}
+.pc-wrap{position:relative;min-width:680px}
+.pc-wrap svg{display:block;width:100%;height:auto;direction:ltr;font:12px var(--f-body);overflow:visible}
+.pc-wrap .pc-axis{stroke:var(--muted);stroke-width:1}
+.pc-wrap .pc-name{fill:var(--ink);font-weight:600;text-anchor:middle}
+.pc-wrap .pc-hint,.pc-wrap .pc-tick{fill:var(--muted)}
+.pc-wrap .pc-plate{fill:var(--surface);pointer-events:none}
+.pc-wrap .pc-label{paint-order:stroke;stroke:var(--surface);stroke-width:4px;stroke-linejoin:round;pointer-events:none}
+.pc-wrap .pc-line{fill:none;stroke-width:2;stroke-linejoin:round;stroke-linecap:round;transition:opacity .12s}
+.pc-wrap .pc-hit{fill:none;stroke:transparent;stroke-width:12;cursor:pointer}
+.pc-wrap.hl .pc-line{opacity:.12}.pc-wrap.hl .pc-line.on{opacity:1;stroke-width:3.5}
+.pc-tip{position:absolute;pointer-events:none;background:var(--surface);color:var(--ink);border:1px solid var(--line);border-radius:8px;
+  padding:6px 9px;font-size:13px;line-height:1.45;box-shadow:0 2px 8px rgba(0,0,0,.15);white-space:nowrap;z-index:2}
+.pc-tip b{font-weight:700}
+.pc-legend{display:flex;flex-wrap:wrap;align-items:center;gap:6px 12px;font-size:13px;color:var(--muted);margin:6px 0 10px}
+.pc-legend .ramp{display:inline-flex;gap:2px;vertical-align:middle}.pc-legend .ramp i{width:18px;height:10px;border-radius:2px;display:inline-block}
+.pc-legend .dash{display:inline-block;width:26px;border-top:2px dashed var(--muted);vertical-align:middle}
+#labSweepTable tr.on td{background:var(--olive-soft)}
+#labSweepTable tr{cursor:default}
 .lab-table tr.focus td:first-child{font-weight:700}
 .lab-table td.ok{color:var(--ok)} .lab-table td.mid{color:var(--amber)} .lab-table td.bad{color:var(--sumac);font-weight:700}
 .lab-table td.hit{background:var(--ok-bg)} .lab-table td.miss{background:var(--sumac-bg)}
+#minervaTable{table-layout:fixed}
+#minervaTable th:nth-child(1){width:120px}
+#minervaTable th:nth-child(2){width:18%}
+#minervaTable th:nth-child(3){width:auto}
+#minervaTable th:nth-child(4){width:90px}
+#minervaTable th:nth-child(5){width:18%}
+#minervaTable th:nth-child(6){width:112px}
+#minervaTable td{white-space:normal;vertical-align:top;overflow-wrap:anywhere}
+#minervaTable .minerva-phones{direction:ltr;unicode-bidi:isolate;font:13px/1.55 var(--f-ipa)}
+#minervaTable .minerva-phones div+div{margin-top:5px;padding-top:5px;border-top:1px dashed var(--line)}
+#minervaTable .minerva-phones small{display:inline-block;min-width:48px;color:var(--muted);font:11px/1.4 var(--f-body);direction:rtl}
 .lab-actions{display:flex;flex-wrap:wrap;align-items:center;gap:8px}
-#labModes{grid-template-columns:repeat(4,1fr)}
-#lab:not(.test) #labTest,#lab:not(.record) #labRecord,#lab:not(.flags) #labFlags,#lab:not(.results) #labResults{display:none}
-#labTest,#labRecord,#labFlags,#labResults{display:flex;flex-direction:column;gap:12px;min-width:0}
+#labModes{grid-template-columns:repeat(5,1fr)}
+#lab:not(.test) #labTest,#lab:not(.record) #labRecord,#lab:not(.flags) #labFlags,#lab:not(.minerva) #labMinerva,#lab:not(.results) #labResults{display:none}
+#labTest,#labRecord,#labFlags,#labMinerva,#labResults{display:flex;flex-direction:column;gap:12px;min-width:0}
 #labList,#labFlagList,#wzList{display:flex;flex-direction:column;gap:10px}
 #wzSpeaker{min-width:0;width:12em;padding:6px 10px;border:1px solid var(--line);border-radius:10px;font:inherit;background:var(--surface);color:inherit}
 .wz-bar{flex-basis:100%;height:6px;border-radius:3px;background:var(--line);overflow:hidden}
@@ -1223,7 +1254,7 @@ body.quiet :is(#mic,#playMine,#driveBtn,.phone-btn),body.driving :is(#quietBtn,#
     <div class="roundbar"><h1 class="mtitle" id="labTitle">מעבדה</h1><span class="sep"></span><button class="btn" id="labManage">ניהול</button><button class="btn primary" id="labPractice">לתרגול</button></div>
     <p class="sub">רשימה קבועה של הברות ומילים קצרות, שכל אחת בודקת הגה אחד. כל דובר מקריא אותה פעם אחת. אומרים נכון, או בוחרים מראש את ההגה שבו תיעשה טעות מכוונת. כל הקלטה נשמרת עם התווית שלה, ומהן נמדד זיהוי הפונמות: כמה פעמים הגה שנאמר נכון סומן כטעות, וכמה טעויות מכוונות לא נתפסו.</p>
     <div class="sub" id="labState" aria-live="polite"></div>
-    <div class="modes" id="labModes" role="tablist" aria-label="מעבדה"><button role="tab" data-mode="test">מבחן<small>הקלטת כל הרשימה</small></button><button role="tab" data-mode="record">הקלטה<small>פריט בודד, עם טעויות</small></button><button role="tab" data-mode="flags">דיווחים<small>הרצה מחדש של דיווחי ציון</small></button><button role="tab" data-mode="results">תוצאות<small>זיהוי לפי הגה</small></button></div>
+    <div class="modes" id="labModes" role="tablist" aria-label="מעבדה"><button role="tab" data-mode="test">מבחן<small>הקלטת כל הרשימה</small></button><button role="tab" data-mode="record">הקלטה<small>פריט בודד, עם טעויות</small></button><button role="tab" data-mode="flags">דיווחים<small>הרצה מחדש של דיווחי ציון</small></button><button role="tab" data-mode="minerva">מינרווה<small>סרטונים ודיבור ילידי</small></button><button role="tab" data-mode="results">תוצאות<small>זיהוי לפי הגה</small></button></div>
     <div id="labTest">
       <div class="card wz-head">
         <p class="sub">כל שורה היא פריט לומר. השורה המסומנת היא הבאה בתור: לוחצים 🎤, אומרים את הפריט נכון ככל האפשר, וההקלטה מושמעת לבד. אחרי ההשמעה: ✓ שולח אותה ועובר לשורה הבאה, ✗ מוחק אותה ומקליטים שוב. מה שנשלח נשמר כ"נאמר נכון" של הדובר, והוא הבסיס לבדיקת זיהוי הפונמות.</p>
@@ -1263,16 +1294,35 @@ body.quiet :is(#mic,#playMine,#driveBtn,.phone-btn),body.driving :is(#quietBtn,#
       </div>
       <div id="labFlagList"></div>
     </div>
+    <div id="labMinerva">
+      <div class="card">
+        <p class="sub">בחרו סרטון כדי לנתח מחדש את כל קטעי הדיבור שלו. הטבלה משווה בין התוצאה שנשמרה בייבוא לבין ה־pipeline והגדרת ה־GOP הנוכחיים.</p>
+        <div class="lab-actions"><label>סרטון <select id="minervaVideo"></select></label><label>הגדרת GOP <select id="minervaSetting"></select></label><button class="btn primary" id="minervaRun">הרצת הסרטון</button><span class="sub" id="minervaState" aria-live="polite"></span></div>
+        <div class="lab-tiles" id="minervaTiles"></div>
+      </div>
+      <div class="card"><div class="stage-table-wrap"><table class="lab-table" id="minervaTable"></table></div></div>
+    </div>
     <div id="labResults">
       <div class="card">
-        <div class="lab-actions"><label>דובר <select id="labWho"><option value="">כולם</option></select></label><button class="btn primary" id="labRerunAll">הרצה מחדש עם הגרסה הנוכחית</button><button class="btn" id="labSaveBase" hidden>שמירה כנקודת השוואה</button></div>
+        <div class="lab-actions"><label>דובר <select id="labWho"><option value="">כולם</option></select></label><button class="btn primary" id="labRerunAll">הרצה מחדש עם הגרסה הנוכחית</button><button class="btn" id="labSweep" disabled title="כל הקלטה מנותחת בכל 24 השילובים של GOP_RATIO_POOL ו-GOP_VOWEL_WINDOW, בלי לשנות את השרת">השוואת 24 הגדרות</button><button class="btn" id="labSaveBase" hidden>שמירה כנקודת השוואה</button><button class="btn danger" id="labDelete" disabled title="מוחק את ההקלטות ואת קובצי השמע שלהן, כדי להקליט את הרשימה מחדש">מחיקת ההקלטות</button></div>
         <div class="lab-actions"><span class="sub" id="labResState" aria-live="polite"></span></div>
+        <div class="lab-actions" id="labTraceRow" hidden><label>לוח אבחון להקלטה <select id="labTraceShow"><option value="">כל ההקלטות</option><option value="flagged">עם הגה שסומן</option><option value="unrelated">"משפט אחר"</option><option value="mistake">טעות מכוונת</option></select></label><select id="labTraceRec" aria-label="הקלטה"></select><label>בהגדרה <select id="labTraceSet"></select></label><button class="btn" id="labTraceOpen" title="ההקלטה מנותחת מחדש בגרסה הנוכחית, והשלבים נפתחים בלשונית חדשה">לוח אבחון</button></div>
         <div class="lab-actions"><span class="sub" id="labBase"></span><button class="btn" id="labDropBase" hidden>מחיקה</button></div>
         <p class="sub" id="labCmp"></p>
         <div class="lab-tiles" id="labTiles"></div>
         <p class="sub">איך בודקים שינוי במימוש: הריצו מחדש ושמרו כנקודת השוואה, שנו את המימוש, והריצו מחדש. ירוק: השתפר, אדום: הורע. שיפור אמיתי מוריד את "סומנו בטעות" בלי להוריד את "זיהוי". "סומן בטעות": הגה שנאמר נכון וסומן כטעות. "זיהוי": טעות מכוונת שסומנה. "דיווחים": ההגה סומן בטעות בדיווח מאושר מתרגול אמיתי. אותה בדיקה משורת הפקודה: <code>python scripts/bench.py</code></p>
       </div>
       <div class="card"><div class="stage-table-wrap"><table class="lab-table" id="labBench"></table></div></div>
+      <div class="card" id="labSweepBox" hidden>
+        <h3>השוואת הגדרות GOP</h3>
+        <p class="sub" id="labSweepSum"></p>
+        <p class="sub">המדד: <b>איכות</b> = ממוצע של (100% פחות "סומנו בטעות") ושל "זיהוי" (דיוק מאוזן). כל חצי הוא שיעור, ולכן ההגאים הרבים שנאמרו נכון לא מבטלים את הטעויות המכוונות המעטות, והגדרה לא יכולה לנצח בכך שאינה מסמנת דבר או מסמנת הכל. בכל ציר מדד, למעלה = טוב יותר.</p>
+        <p class="sub">תנועות: המערכת לא מסמנת תנועה כטעות (מלבד u אחרי עיצור, כלל 3.11), ולכן הגדרות האיגום והחלון, שמשנות רק תנועות, כמעט לא מזיזות את "סומנו בטעות" ואת "זיהוי". שלושת צירי התנועות מודדים את הציון עצמו: <b>תנועות חלשות</b> = תנועות שנאמרו נכון וקיבלו פחות מ-75 (נצבעות לתלמיד כחלשות), <b>ציון תנועות</b> = הממוצע שלהן, <b>הפרדת תנועות</b> = הסיכוי שתנועה נכונה תקבל ציון גבוה יותר מתנועה שנאמרה בטעות מכוונת (1 = הפרדה מלאה, 0.5 = ניחוש). כשהאיכות שווה, הדירוג נקבע לפי הצירים האלה. <b>ציונים ששונו</b>: כמה ציוני הגאים ההגדרה נתנה אחרת מ-max · חלון רחב (החישוב שלפני השינויים), בדיקה ישירה שההגדרה אכן הופעלה.</p>
+        <p class="sub setup" id="labSweepNote" hidden>אין עדיין טעויות מכוונות בהקלטות האלה, ולכן האיכות כאן היא רק 100% פחות "סומנו בטעות": היא לא יודעת אם הגדרה מפספסת טעויות אמיתיות. הקליטו טעויות מכוונות בטאב הקלטה.</p>
+        <div class="stage-table-wrap"><div class="pc-wrap" id="labSweepPlot"></div></div>
+        <div class="pc-legend" id="labSweepLegend"></div>
+        <div class="stage-table-wrap"><table class="lab-table" id="labSweepTable"></table></div>
+      </div>
     </div>
   </section>
 </div>
@@ -4804,12 +4854,13 @@ async function showLab(){
   labMode(store.get("ihki.labMode","test"));
 }
 function labMode(mode){
-  if(!["test","record","flags","results"].includes(mode)) mode="test";
+  if(!["test","record","flags","minerva","results"].includes(mode)) mode="test";
   store.set("ihki.labMode",mode);
   for(const b of $("labModes").children) b.setAttribute("aria-selected",b.dataset.mode===mode?"true":"false");
-  for(const m of ["test","record","flags","results"]) $("lab").classList.toggle(m,m===mode);
+  for(const m of ["test","record","flags","minerva","results"]) $("lab").classList.toggle(m,m===mode);
   if(mode==="test"){ drawWizard(); loadTtsVoices(); }
   if(mode==="flags"&&!labFlags) loadLabFlags();
+  if(mode==="minerva") loadMinerva();
   if(mode==="results") loadLabResults();
 }
 for(const b of $("labModes").children) b.onclick=()=>labMode(b.dataset.mode);
@@ -5138,12 +5189,80 @@ $("labRerun").onclick=async()=>{
   btn.disabled=false; drawLabFlags();
 };
 
+/* Native Minerva pilot: its imported rows already contain the cut timestamps, expected text and stored result. */
+let minervaData=null, minervaNow={};
+const minervaTime=n=>n==null?"—":`${Math.floor(n/60)}:${String((n%60).toFixed(1)).padStart(4,"0")}`;
+const minervaFlagged=r=>(r.words||[]).flatMap(w=>(w.phonemes||[]).filter(p=>p.flagged).map(p=>`${p.ipa}>${p.heard||"_"}`));
+function fillGopSettings(sel){
+  if(sel.options.length) return;
+  sel.append(new Option("של השרת",""));
+  for(const k of LAB_SETTINGS){ const [p,w]=k.split("|"); sel.append(new Option(`${p} · ${sweepWin(w)}`,k)); }
+}
+async function loadMinerva(){
+  const state=$("minervaState");
+  if(!minervaData){
+    state.textContent="טוען סרטונים…";
+    try{ const res=await api("/api/lab/minerva"), d=await res.json().catch(()=>({})); if(!res.ok) throw new Error(d.detail||res.status); minervaData=d; }
+    catch(e){ state.textContent=`הסרטונים לא זמינים: ${e.message}`; return; }
+    const sel=$("minervaVideo"), was=sel.value; sel.replaceChildren();
+    for(const v of minervaData.videos) sel.append(new Option(`${v.title} · ${v.samples.length} קטעים`,v.id));
+    if([...sel.options].some(o=>o.value===was)) sel.value=was;
+    fillGopSettings($("minervaSetting"));
+  }
+  state.textContent=minervaData.videos.length?`גרסה ${minervaData.version}`:"לא נמצאו הקלטות מיובאות של מינרווה";
+  drawMinerva();
+}
+function drawMinerva(){
+  const video=minervaData&&minervaData.videos.find(v=>v.id===$("minervaVideo").value), table=$("minervaTable"), tiles=$("minervaTiles");
+  table.replaceChildren(); tiles.replaceChildren(); $("minervaRun").disabled=!video;
+  if(!video) return;
+  const results=minervaNow[video.id]||{}, done=Object.keys(results).length;
+  const current=Object.values(results), bad=current.filter(r=>r.unrelated).length;
+  const flags=current.reduce((n,r)=>n+minervaFlagged(r).length,0);
+  for(const [value,label] of [[video.samples.length,"קטעי דיבור"],[done,"נותחו עכשיו"],[flags,"סימוני הגאים"],[bad,'“משפט אחר”']]){
+    const box=mark("lab-tile","","div"); box.append(mark("",String(value),"b"),mark("",label,"small")); tiles.append(box);
+  }
+  const head=document.createElement("thead"); head.innerHTML="<tr><th>קטע וזמן</th><th>ערבית</th><th>פונמות</th><th>ציון</th><th>סימונים</th><th></th></tr>"; table.append(head);
+  const body=document.createElement("tbody");
+  for(const s of video.samples){
+    const now=results[s.id], tr=document.createElement("tr"), flagsNow=now?minervaFlagged(now):null;
+    const storedFlags=s.flagged.join(", ")||"—";
+    const values=[`${s.line} · ${minervaTime(s.start)}–${minervaTime(s.end)}`,s.ar,
+      now?`${s.score??"—"} → ${now.score??"—"}`:s.score??"—",
+      now?`${storedFlags} → ${flagsNow.join(", ")||"—"}`:storedFlags];
+    for(const value of values.slice(0,2)){ const td=document.createElement("td"); td.textContent=value; tr.append(td); }
+    const phones=mark("minerva-phones","","td"), expected=document.createElement("div"), heard=document.createElement("div");
+    expected.append(mark("","צפוי","small"),document.createTextNode(s.ipa));
+    heard.append(mark("","נשמע","small"),document.createTextNode(now?`${s.heard_ipa||"—"} → ${now.heard_ipa||"—"}`:s.heard_ipa||"—"));
+    phones.append(expected,heard); tr.append(phones);
+    for(const value of values.slice(2)){ const td=document.createElement("td"); td.textContent=value; tr.append(td); }
+    if(now){ tr.children[3].className=(now.score??0)>=(s.score??0)?"ok":"bad"; tr.children[4].className=flagsNow.length?"bad":"ok"; }
+    const td=document.createElement("td"), button=mark("btn","לוח אבחון","button"); button.disabled=!s.audio;
+    button.onclick=()=>openLabTrace(s.id,$("minervaSetting").value,$("minervaState"),button); td.append(button); tr.append(td); body.append(tr);
+  }
+  table.append(body);
+}
+$("minervaVideo").onchange=drawMinerva;
+$("minervaRun").onclick=async()=>{
+  const video=minervaData&&minervaData.videos.find(v=>v.id===$("minervaVideo").value); if(!video) return;
+  const setting=$("minervaSetting").value, results={}, btn=$("minervaRun"); let failed=0; btn.disabled=true;
+  for(const [i,s] of video.samples.entries()){
+    $("minervaState").textContent=`מנתח קטע ${i+1} מתוך ${video.samples.length}…`;
+    try{ const res=await api(`/api/lab/samples/${s.id}/rescore`+(setting?`?setting=${encodeURIComponent(setting)}`:""),{method:"POST"}), d=await res.json().catch(()=>({})); if(!res.ok) throw new Error(d.detail||res.status); results[s.id]=d.result; }
+    catch{ failed++; }
+    minervaNow[video.id]=results; drawMinerva();
+  }
+  $("minervaState").textContent=`נותחו ${Object.keys(results).length} מתוך ${video.samples.length} קטעים`+(failed?` · ${failed} נכשלו`:""); btn.disabled=false;
+};
+
 /* The lab's results: per sound, of the recordings as they were scored (see lab.benchmark in app/lab.py). */
 /* The lab's results: per sound (see lab.benchmark in app/lab.py). As loaded, the recordings as they were scored at
    the time; "הרצה מחדש" rescores them all with the version the server runs now, and compares that with a saved run
    (the comparison point, kept on this device) or, without one, with the stored scores of the same recordings. */
 let labRes=null, labNow=null;   // the stored benchmark (with the recordings' ids), and the latest rescore's
 const labBaseKey=()=>"ihki.labBase:"+$("labWho").value;   // a comparison point for each speaker filter
+// a run's version with its GOP pool (GOP_RATIO_POOL): the env picks the pool, so the code's version cannot tell them apart
+const labTag=d=>d.version+(d.pool?` · ${d.pool}`:"")+(d.vowel_window&&d.vowel_window!=="wide"?` · חלון תנועה ${d.vowel_window}`:"");
 async function loadLabResults(){
   const who=$("labWho").value; $("labResState").textContent="טוען…"; labNow=null;
   try{ const res=await api("/api/lab/results"+(who?`?speaker=${encodeURIComponent(who)}`:"")); labRes=await res.json().catch(()=>({}));
@@ -5152,9 +5271,32 @@ async function loadLabResults(){
   const sel=$("labWho"); sel.replaceChildren(new Option("כולם",""));
   for(const s of labRes.speakers) sel.append(new Option(s||"(בלי שם)",s)); sel.value=who;
   $("labResState").textContent=`הציונים שנשמרו בזמן ההקלטה · ${labRes.samples.length} הקלטות עם קובץ`;
-  $("labRerunAll").disabled=!labRes.samples.length;
+  $("labRerunAll").disabled=$("labSweep").disabled=!labRes.samples.length;
+  $("labSweepBox").hidden=true;   // a sweep belongs to the filter it ran on
+  drawLabTracePicker();
+  const del=$("labDelete"); del.disabled=!labRes.totals.recordings;
+  del.textContent=who?`מחיקת ההקלטות של ${who}`:"מחיקת כל ההקלטות";
   drawLabBench(labRes,null,"");
 }
+// Deletes the recordings of the speaker the filter shows, or of every speaker under "כולם", to record afresh. The
+// comparison points saved of them go too: they measured recordings that are gone.
+$("labDelete").onclick=async()=>{
+  if(!labRes) return;
+  const who=$("labWho").value, n=labRes.totals.recordings, word="מחיקה";
+  if(who){ if(!confirm(`למחוק את ${n} ההקלטות של ${who}, עם קובצי השמע שלהן? לא ניתן לבטל את המחיקה.`)) return; }
+  else if((prompt(`פעולה זו מוחקת את כל ${n} ההקלטות של כל הדוברים, עם קובצי השמע שלהן, ולא ניתן לבטל אותה. כדי לאשר, הקלידו: ${word}`)||"").trim()!==word) return;
+  const btn=$("labDelete"); btn.disabled=true; $("labResState").textContent="מוחק…";
+  try{
+    const res=await api("/api/lab/samples?"+(who?`speaker=${encodeURIComponent(who)}`:"everyone=true"),{method:"DELETE"}), d=await res.json().catch(()=>({}));
+    if(!res.ok) throw new Error(d.detail||res.status);
+    try{ localStorage.removeItem(labBaseKey()); localStorage.removeItem("ihki.labBase:"); }catch{}
+    $("labWho").value=""; labNow=null; $("labSaveBase").hidden=true; drawLabBase();
+    await loadLabResults();
+    $("labResState").textContent=`נמחקו ${d.deleted} הקלטות.`;
+    const me=store.get("ihki.labSpeaker",""), items=await api("/api/lab"+(me?`?speaker=${encodeURIComponent(me)}`:""));
+    if(items.ok&&LAB){ const l=await items.json(); LAB.counts=l.counts; LAB.mine=l.mine; drawLabList(); }
+  }catch(e){ $("labResState").textContent=`המחיקה נכשלה: ${e.message}`; btn.disabled=false; }
+};
 $("labRerunAll").onclick=async()=>{
   if(!labRes) return;
   const btn=$("labRerunAll"), ids=labRes.samples, results={}; let failed=0;
@@ -5171,21 +5313,181 @@ $("labRerunAll").onclick=async()=>{
   }catch(e){ labNow=null; $("labResState").textContent=`החישוב נכשל: ${e.message}`; btn.disabled=false; return; }
   labNow.at=new Date().toISOString(); labNow.speaker=$("labWho").value;
   const base=store.get(labBaseKey(),null);
-  if(base) drawLabBench(labNow.now,base.bench,`לעומת נקודת ההשוואה: גרסה ${base.version}, ${new Date(base.at).toLocaleString("he-IL")}`);
+  if(base) drawLabBench(labNow.now,base.bench,`לעומת נקודת ההשוואה: גרסה ${labTag(base)}, ${new Date(base.at).toLocaleString("he-IL")}`);
   else drawLabBench(labNow.now,labNow.stored,"לעומת הציונים שנשמרו בזמן ההקלטה");
-  $("labResState").textContent=`נותחו מחדש ${Object.keys(results).length} הקלטות בגרסה ${labNow.version}`+(failed?` · ${failed} נכשלו`:"");
+  $("labResState").textContent=`נותחו מחדש ${Object.keys(results).length} הקלטות בגרסה ${labTag(labNow)}`+(failed?` · ${failed} נכשלו`:"");
   btn.disabled=false; $("labSaveBase").hidden=false;
 };
 $("labSaveBase").onclick=()=>{
   if(!labNow) return;
-  store.set(labBaseKey(),{bench:labNow.now,version:labNow.version,model:labNow.model,at:labNow.at});
+  store.set(labBaseKey(),{bench:labNow.now,version:labNow.version,pool:labNow.pool,vowel_window:labNow.vowel_window,model:labNow.model,at:labNow.at});
   $("labSaveBase").hidden=true; drawLabBase();
-  $("labResState").textContent=`נשמרה נקודת השוואה: גרסה ${labNow.version}. שנו את המימוש, ואז הריצו מחדש כדי להשוות.`;
+  $("labResState").textContent=`נשמרה נקודת השוואה: גרסה ${labTag(labNow)}. שנו את המימוש, ואז הריצו מחדש כדי להשוות.`;
 };
 $("labDropBase").onclick=()=>{ try{ localStorage.removeItem(labBaseKey()); }catch{} drawLabBase(); };
+/* The trace dashboard for any saved recording: rescored now (the current version, and the server's GOP setting or one
+   of the sweep's), with the teacher's trace, then opened as the phoneme dialog opens it. */
+const LAB_SETTINGS=["max","mean","topk","lse","energy","gated"].flatMap(p=>["wide","0","1","2"].map(w=>`${p}|${w}`));
+function drawLabTracePicker(){
+  const recs=(labRes&&labRes.recordings)||[], show=$("labTraceShow").value, sel=$("labTraceRec"), was=sel.value;
+  $("labTraceRow").hidden=!recs.length;
+  const item=id=>(LAB&&LAB.items.find(x=>x.id===id))||{};
+  const keep=r=>!show||(show==="flagged"?r.flagged.length&&!r.unrelated:show==="unrelated"?r.unrelated:r.label==="mistake");
+  sel.replaceChildren();
+  for(const r of recs.filter(keep)){
+    const it=item(r.item), when=r.created_at?new Date(r.created_at).toLocaleDateString("he-IL"):"";
+    const what=r.unrelated?"משפט אחר":r.flagged.length?`סומן: ${r.flagged.join(", ")}`:"בלי סימון";
+    sel.append(new Option(`${it.ar||r.item} (${it.focus||"?"}) · ${r.speaker||"בלי שם"} · ${r.score??"—"} · ${what}`+
+                          (r.label==="mistake"?" · טעות מכוונת":"")+(when?` · ${when}`:""),String(r.id)));
+  }
+  if([...sel.options].some(o=>o.value===was)) sel.value=was;
+  $("labTraceOpen").disabled=!sel.options.length;
+  const set=$("labTraceSet");
+  if(!set.options.length){ set.append(new Option("של השרת","")); for(const k of LAB_SETTINGS){ const [p,w]=k.split("|"); set.append(new Option(`${p} · ${sweepWin(w)}`,k)); } }
+}
+$("labTraceShow").onchange=drawLabTracePicker;
+async function openLabTrace(id,setting,state,btn){
+  if(!id) return;
+  const tab=window.open("about:blank","_blank");   // opened on the click, so no popup blocker stops it after the wait
+  btn.disabled=true; state.textContent="מנתח את ההקלטה מחדש…";
+  try{
+    const res=await api(`/api/lab/samples/${id}/rescore?trace=true`+(setting?`&setting=${encodeURIComponent(setting)}`:""),{method:"POST"});
+    const d=await res.json().catch(()=>({})); if(!res.ok) throw new Error(d.detail||res.status);
+    localStorage.setItem("ihki.trace",JSON.stringify(d.result));
+    if(tab){ tab.opener=null; tab.location.href="/static/trace.html?src=app"; } else window.open("/static/trace.html?src=app","_blank","noopener");
+    state.textContent=`נפתח לוח האבחון של ההקלטה, בהגדרה ${d.setting}`;
+  }catch(e){ if(tab) tab.close(); state.textContent=`לוח האבחון לא נפתח: ${e.message}`; }
+  btn.disabled=false;
+}
+$("labTraceOpen").onclick=()=>{
+  openLabTrace($("labTraceRec").value,$("labTraceSet").value,$("labResState"),$("labTraceOpen"));
+};
+/* The sweep: every recording the filter shows, scored under each GOP setting (lab.SWEEP: GOP_RATIO_POOL x
+   GOP_VOWEL_WINDOW) without changing the server; then the benchmark of each setting, ranked by its quality
+   (lab.quality, balanced accuracy), and drawn as parallel coordinates: one line per setting through its two settings
+   and its metrics, coloured by the quality on a one-hue ramp (validated: dataviz ordinal check, light and dark). */
+let labSweepRes=null;
+const SWEEP_RAMP={light:["#86b6ef","#5598e7","#2a78d6","#1c5cab","#104281"],dark:["#1c5cab","#2a78d6","#5598e7","#86b6ef","#b7d3f6"]};
+const sweepWin=w=>w==="wide"?"רחב":`±${w}`, sweepPct=x=>x==null?"—":`${(100*x).toFixed(1)}%`, sweepQ=x=>x==null?"—":x.toFixed(1);
+$("labSweep").onclick=async()=>{
+  if(!labRes) return;
+  const btn=$("labSweep"), ids=labRes.samples, results={}; let failed=0;
+  btn.disabled=$("labRerunAll").disabled=true;
+  for(const [k,id] of ids.entries()){
+    $("labResState").textContent=`משווה 24 הגדרות: הקלטה ${k+1} מתוך ${ids.length}…`;
+    try{ const res=await api(`/api/lab/samples/${id}/sweep`,{method:"POST"}), d=await res.json().catch(()=>({}));
+      if(!res.ok) throw new Error(d.detail||res.status); results[id]=d.results; }
+    catch{ failed++; }
+  }
+  try{
+    const res=await api("/api/lab/sweep",{method:"POST",headers:{"Content-Type":"application/json"},body:JSON.stringify({results})});
+    labSweepRes=await res.json().catch(()=>({})); if(!res.ok) throw new Error(labSweepRes.detail||res.status);
+  }catch(e){ labSweepRes=null; $("labResState").textContent=`ההשוואה נכשלה: ${e.message}`; btn.disabled=$("labRerunAll").disabled=false; return; }
+  $("labResState").textContent=`הושוו ${labSweepRes.settings.length} הגדרות על ${labSweepRes.recordings} הקלטות בגרסה ${labSweepRes.version}`+(failed?` · ${failed} נכשלו`:"");
+  btn.disabled=$("labRerunAll").disabled=false; drawSweep(labSweepRes);
+};
+try{ matchMedia("(prefers-color-scheme: dark)").addEventListener("change",()=>{ if(labSweepRes&&!$("labSweepBox").hidden) drawSweep(labSweepRes); }); }catch{}
+function drawSweep(d){
+  $("labSweepBox").hidden=false;
+  const ramp=SWEEP_RAMP[matchMedia("(prefers-color-scheme: dark)").matches?"dark":"light"];
+  const all=d.settings, rows=all.filter(r=>r.quality!=null), best=rows[0], cur=all.find(r=>r.key===d.current);
+  const name=r=>`${r.pool} · חלון ${sweepWin(r.window)}`;
+  const qs=rows.map(r=>r.quality), qlo=Math.min(...qs), qhi=Math.max(...qs);
+  const tie=rows.length>1&&rows.every(r=>r.quality===best.quality&&JSON.stringify([r.totals,r.vowels])===JSON.stringify([best.totals,best.vowels]));
+  // near-tie: the flag metrics and the weak-vowel share equal, the vowel average within half a point
+  const vm=rows.map(r=>r.vowels&&r.vowels.mean).filter(x=>x!=null), vspread=vm.length?Math.max(...vm)-Math.min(...vm):0;
+  const near=!tie&&rows.length>1&&qhi-qlo<1e-9&&rows.every(r=>JSON.stringify(r.totals)===JSON.stringify(best.totals)
+    &&r.vowels&&best.vowels&&r.vowels.weak===best.vowels.weak&&r.vowels.auc===best.vowels.auc)&&vspread<.5;
+  $("labSweepSum").textContent=!best?"אין הקלטות שנותחו בהשוואה.":near?
+    `כל ${rows.length} ההגדרות כמעט זהות: כל המדדים שווים, וההבדל היחיד הוא ${vspread.toFixed(1)} נקודות בממוצע ציון התנועות. על ההקלטות האלה הבחירה לא משנה.`:tie?
+    `כל ${rows.length} ההגדרות יצאו זהות (איכות ${sweepQ(best.quality)}): על ההקלטות האלה הבחירה לא משנה אף מדד.`:
+    `הטובה ביותר: ${name(best)}, איכות ${sweepQ(best.quality)}`+(qhi-qlo<1e-9?" (האיכות שווה בכל ההגדרות, והדירוג נקבע לפי צירי התנועות)":"")+(cur===best?" (זו ההגדרה הנוכחית).":cur?` · ההגדרה הנוכחית (${name(cur)}): ${sweepQ(cur.quality)}.`:".");
+  $("labSweepNote").hidden=!rows.length||!rows.every(r=>r.partial);
+  // the axes: the two settings (categories), then the metrics, each with better up
+  const order=(fixed,f)=>{ const seen=new Set(all.map(f)); return fixed.filter(x=>seen.has(x)).concat([...seen].filter(x=>!fixed.includes(x))); };
+  const axes=[
+    {name:"איגום",hint:"GOP_RATIO_POOL",cat:order(["max","mean","topk","lse","energy","gated"],r=>r.pool),get:r=>r.pool,fmt:x=>x},
+    {name:"חלון תנועה",hint:"GOP_VOWEL_WINDOW",cat:order(["wide","0","1","2"],r=>String(r.window)),get:r=>String(r.window),fmt:sweepWin},
+    {name:"סומנו בטעות",hint:"↑ פחות",get:r=>r.totals.frr,fmt:sweepPct,lower:true},
+    {name:"זיהוי",hint:"↑ יותר",get:r=>r.totals.detection,fmt:sweepPct},
+    {name:"ציון 85+",hint:"↑ יותר",get:r=>r.totals.good_share,fmt:sweepPct},
+    {name:"תנועות חלשות",hint:"נכונות מתחת ל-75 ↑ פחות",get:r=>r.vowels&&r.vowels.weak,fmt:sweepPct,lower:true},
+    {name:"ציון תנועות",hint:"נכונות, ממוצע ↑",get:r=>r.vowels&&r.vowels.mean,fmt:sweepQ},
+    {name:"הפרדת תנועות",hint:"AUC ↑ יותר",get:r=>r.vowels&&r.vowels.auc,fmt:x=>x==null?"—":x.toFixed(2)},
+    {name:"איכות",hint:"↑ טוב יותר",get:r=>r.quality,fmt:sweepQ},
+  ].filter(a=>a.cat||rows.some(r=>a.get(r)!=null));
+  const W=880,H=330,M={t:52,b:26,l:70,r:58},top=M.t,bot=H-M.b,step=(W-M.l-M.r)/(axes.length-1);
+  for(const [i,a] of axes.entries()){
+    a.x=M.l+i*step;
+    if(a.cat){ a.y=v=>{ const k=a.cat.indexOf(v); return a.cat.length<2?(top+bot)/2:top+k*(bot-top)/(a.cat.length-1); }; continue; }
+    const vals=rows.map(a.get).filter(v=>v!=null), lo=Math.min(...vals), hi=Math.max(...vals);
+    a.lo=lo; a.hi=hi; a.flat=hi-lo<1e-9;   // every setting the same: one value mid-axis, no invented range
+    a.y=v=>v==null?bot:a.flat?(top+bot)/2:(a.lower?top+(v-lo)/(hi-lo)*(bot-top):bot-(v-lo)/(hi-lo)*(bot-top));
+  }
+  // colour by rank (the server's order: quality, then the vowel axes), best darkest on light / lightest on dark
+  const rank=new Map(all.map((r,k)=>[r.key,k]));
+  const colour=r=>ramp[r.quality==null?0:4-Math.min(4,Math.floor(rank.get(r.key)/all.length*5))];
+  const NS="http://www.w3.org/2000/svg", el=(tag,attrs,text)=>{ const e=document.createElementNS(NS,tag); for(const k in attrs) e.setAttribute(k,attrs[k]); if(text!=null) e.textContent=text; return e; };
+  const svg=el("svg",{viewBox:`0 0 ${W} ${H}`,role:"img","aria-label":`עקומות מקבילות של ${all.length} הגדרות; הנתונים בטבלה שמתחת`});
+  const labels=[];   // drawn over the lines, with a halo of the surface
+  for(const a of axes){
+    svg.append(el("line",{class:"pc-axis",x1:a.x,x2:a.x,y1:top,y2:bot}));
+    labels.push(el("text",{class:"pc-name",x:a.x,y:16},a.name), el("text",{class:"pc-hint",x:a.x,y:32,"text-anchor":"middle","font-size":11},a.hint));
+    if(a.cat) for(const c of a.cat) labels.push(el("text",{class:"pc-tick",x:a.x-6,y:a.y(c)+4,"text-anchor":"end"},a.fmt(c)));
+    else if(a.flat){ const last=a===axes[axes.length-1];
+      labels.push(el("text",{class:"pc-tick",x:last?a.x-6:a.x+6,y:(top+bot)/2+4,"text-anchor":last?"end":"start"},`${a.fmt(a.lo)} (כולן)`)); }
+    else{
+      const [up,down]=a.lower?[a.lo,a.hi]:[a.hi,a.lo];
+      labels.push(el("text",{class:"pc-tick",x:a.x+6,y:top+4},a.fmt(up)), el("text",{class:"pc-tick",x:a.x+6,y:bot+4},a.fmt(down)));
+    }
+  }
+  const wrap=$("labSweepPlot"), tip=mark("pc-tip",""); tip.hidden=true;
+  const lines={}, trs={};
+  const hl=key=>{ wrap.classList.toggle("hl",!!key); for(const k in lines) lines[k].classList.toggle("on",k===key);
+    for(const k in trs) trs[k].classList.toggle("on",k===key); };
+  // the worst first, so the best are drawn on top
+  for(const r of [...all].sort((x,y)=>(x.quality??-1)-(y.quality??-1))){
+    const pts=axes.map(a=>`${a.x},${a.y(a.get(r)).toFixed(1)}`).join(" ");
+    const line=el("polyline",{class:"pc-line",points:pts,stroke:colour(r)});
+    if(r.key===d.current) line.setAttribute("stroke-dasharray","7 4");
+    const hit=el("polyline",{class:"pc-hit",points:pts});
+    hit.addEventListener("mouseenter",()=>hl(r.key));
+    hit.addEventListener("mousemove",ev=>{
+      tip.replaceChildren(mark("",name(r)+(r.key===d.current?" (נוכחית)":""),"b"));
+      for(const a of axes.slice(2)) tip.append(document.createElement("br"),`${a.name}: ${a.fmt(a.get(r))}`);
+      tip.hidden=false; const box=wrap.getBoundingClientRect(), x=ev.clientX-box.left, y=ev.clientY-box.top;
+      tip.style.left=`${Math.min(x+14,box.width-tip.offsetWidth-4)}px`; tip.style.top=`${Math.max(0,y-tip.offsetHeight-10)}px`; });
+    hit.addEventListener("mouseleave",()=>{ hl(null); tip.hidden=true; });
+    lines[r.key]=line; svg.append(line,hit);
+  }
+  for(const t of labels) t.classList.add("pc-label");
+  svg.append(...labels);
+  wrap.replaceChildren(svg,tip);
+  for(const t of labels) if(t.classList.contains("pc-tick")){   // a plate under each tick, so a line along it does not cross it
+    const b=t.getBBox(); if(b.width) svg.insertBefore(el("rect",{class:"pc-plate",x:b.x-3,y:b.y-1,width:b.width+6,height:b.height+2,rx:3}),t); }
+  // the legend: the ramp, and the current setting's dash
+  const lg=$("labSweepLegend"), sw=mark("ramp","");
+  for(const c of ramp){ const i=document.createElement("i"); i.style.background=c; sw.append(i); }
+  lg.replaceChildren(mark("",`דירוג ${all.length}`),sw,mark("","1"),mark("dash",""),mark("","ההגדרה הנוכחית"));
+  // the table: the same numbers, best first
+  const tb=$("labSweepTable"); tb.replaceChildren();
+  const head=document.createElement("tr");
+  for(const h of ["#","איגום","חלון תנועה","איכות","סומנו בטעות","זיהוי","ציון 85+","תנועות חלשות","ציון תנועות","הפרדת תנועות","ציונים ששונו","משפט אחר"]) head.append(mark("",h,"th"));
+  tb.append(head);
+  for(const [k,r] of all.entries()){
+    const tr=document.createElement("tr"), t=r.totals, v=r.vowels||{};
+    for(const cell of [String(k+1),r.pool+(r.key===d.current?" (נוכחית)":""),sweepWin(r.window),sweepQ(r.quality)+(r.partial&&r.quality!=null?"*":""),
+                    `${sweepPct(t.frr)} (${t.false_flags}/${t.right})`,t.planted?`${sweepPct(t.detection)} (${t.caught}/${t.planted})`:"—",sweepPct(t.good_share),
+                    v.right?`${sweepPct(v.weak)} (${v.right})`:"—",sweepQ(v.mean),v.auc==null?"—":`${v.auc.toFixed(2)} (${v.planted})`,
+                    r.key==="max|wide"?"בסיס":`${r.changed??"—"} מתוך ${r.sounds??"—"}`,String(t.unrelated)])
+      tr.append(mark("",cell,"td"));
+    tr.onmouseenter=()=>hl(r.key); tr.onmouseleave=()=>hl(null);
+    trs[r.key]=tr; tb.append(tr);
+  }
+}
 function drawLabBase(){
   const base=store.get(labBaseKey(),null);
-  $("labBase").textContent=base?`נקודת השוואה: גרסה ${base.version}, ${new Date(base.at).toLocaleString("he-IL")}`:"אין נקודת השוואה שמורה";
+  $("labBase").textContent=base?`נקודת השוואה: גרסה ${labTag(base)}, ${new Date(base.at).toLocaleString("he-IL")}`:"אין נקודת השוואה שמורה";
   $("labDropBase").hidden=!base;
 }
 // `cmp`: the benchmark to compare with (null: none). A false rejection rate is better lower; detection and the share

tests/test_gop_pooling.py

@@ -0,0 +1,239 @@
+"""GOP frame pooling (align.score_tokens with GopConfig.ratio_pool) on synthetic CTC emissions.
+
+The phrase is /k a t/; the vowel /a/ is the token under test. Every frame is a distribution: the named
+sounds get their probability, a 1e-4 floor goes to the rest, blank takes what is left (CTC is peaky).
+"""
+from __future__ import annotations
+
+from dataclasses import dataclass, replace
+
+import numpy as np
+import pytest
+
+from app.align import Alignment, GopConfig, POOLS, energy_weights, pool_frames, score_tokens, spread_energy
+
+BLANK, K, A, I, T_, SCHWA = 0, 1, 2, 3, 4, 5
+V = 6
+TOKENS = [K, A, T_]
+N_FRAMES = 14
+SPANS = [(1, 2), (5, 7), (12, 13)]     # k at 1, a around 5-6, t at 12: the window of /a/ is frames 2..11
+LOUD = np.array([.2, .6, .5, 1, 1, 1, 1, 1, .9, .7, .15, .1, .4, .1])   # vowel nucleus 3..9, quiet release 10..11
+
+
+def emissions(frames: dict[int, dict[int, float]]) -> np.ndarray:
+    out = np.full((N_FRAMES, V), 1e-4)
+    out[1, K], out[12, T_] = .9, .9
+    for t, probs in frames.items():
+        for tok, p in probs.items():
+            out[t, tok] = p
+    for t in range(N_FRAMES):
+        out[t, BLANK] = 0.0
+        out[t, BLANK] = max(1e-4, 1.0 - out[t].sum())
+    return np.log(out / out.sum(1, keepdims=True))
+
+
+@dataclass
+class Scenario:
+    name: str
+    logp: np.ndarray
+    good: bool                     # a correct /a/ (should pass) or a substitution (should fail)
+    energy: np.ndarray = LOUD
+    spans: tuple = tuple(SPANS)
+
+
+SCENARIOS = [
+    # correct /a/ over two frames, a one-frame /i/ spike in the quiet release before /t/
+    Scenario("spike in release", emissions({4: {A: .2}, 5: {A: .4}, 6: {A: .35}, 10: {I: .9}}), True),
+    # the same spike inside the loud nucleus: energy cannot tell it apart, the pooling has to
+    Scenario("spike in nucleus", emissions({4: {A: .2}, 5: {A: .4}, 6: {A: .35}, 8: {I: .9}}), True),
+    # a correct /a/ emitted on one frame, blanks everywhere else: nothing must dilute it
+    Scenario("peaky emission", emissions({5: {A: .92}}), True),
+    # the same with a weak schwa haze across the whole window
+    Scenario("peaky + haze", emissions({**{t: {SCHWA: .04} for t in range(2, 12)}, 5: {A: .92, SCHWA: .04}}), True),
+    # CTC put the emission a frame before the loud nucleus (alignment jitter)
+    Scenario("emission off nucleus", emissions({3: {A: .8}, 9: {I: .5}}), True,
+             energy=np.array([.2, .6, .5, .2, 1, 1, 1, 1, 1, .9, .15, .1, .4, .1]), spans=((1, 2), (3, 4), (12, 13))),
+    # /i/ said instead of /a/, held over three frames
+    Scenario("sustained substitution", emissions({4: {I: .6, A: .08}, 5: {I: .75, A: .1}, 6: {I: .6, A: .05}}), False),
+    # a short /i/ said instead of /a/: also a one-frame spike, but /a/ is absent
+    Scenario("one-frame substitution", emissions({5: {I: .85, A: .03}}), False),
+]
+
+
+def score_a(sc: Scenario, cfg: GopConfig, energy: bool = True):
+    al = Alignment(0.0, list(sc.spans))
+    return score_tokens(sc.logp, al, TOKENS, BLANK, cfg, energy=sc.energy if energy else None)[1]
+
+
+CONFIGS = {
+    "max": GopConfig(ratio_pool="max"),
+    "mean": GopConfig(ratio_pool="mean"),
+    "top2": GopConfig(ratio_pool="topk", pool_k=2),
+    "top3": GopConfig(ratio_pool="topk", pool_k=3),
+    "lse": GopConfig(ratio_pool="lse", pool_tau=0.5),
+    "energy": GopConfig(ratio_pool="energy"),
+    "gated": GopConfig(ratio_pool="gated"),
+}
+
+
+def naive_mean_score(sc: Scenario, cfg: GopConfig = GopConfig()) -> float:
+    """The diluting variant this design avoids: the mean posterior over the window used for the ratio AND the confidence."""
+    a, b = sc.spans[0][1], sc.spans[2][0]
+    p = np.exp(sc.logp[a:b]).mean(0)
+    comp = max(p[I], p[SCHWA])
+    return 100 * np.exp(cfg.leniency * (np.log(p[A]) - np.log(max(p[A], comp)))) * np.sqrt(min(1, p[A] / cfg.confident_peak))
+
+
+# ---- the pooling operator ----
+
+def test_pool_limits():
+    seg = np.log(np.array([[.9, .1], [.05, .1], [.05, .8]]))
+    assert np.allclose(pool_frames(seg, "max"), seg.max(0))
+    assert np.allclose(pool_frames(seg, "mean"), np.log(np.exp(seg).mean(0)))
+    assert np.allclose(pool_frames(seg, "topk", k=1), seg.max(0))
+    assert np.allclose(pool_frames(seg, "topk", k=3), pool_frames(seg, "mean"))
+    assert np.allclose(pool_frames(seg, "lse", tau=1.0), pool_frames(seg, "mean"))
+    assert np.allclose(pool_frames(seg, "lse", tau=0.02), seg.max(0), atol=0.03)
+    # a 0/1 weight is the mean over the kept frames
+    assert np.allclose(pool_frames(seg, "mean", weight=np.array([1, 0, 1])), np.log(np.exp(seg[[0, 2]]).mean(0)))
+
+
+def test_mass_ratio_is_window_length_invariant():
+    """Padding the window with blank frames dilutes each pooled posterior but not their ratio
+    (up to the floor each padded frame adds to both masses)."""
+    seg = np.log(np.array([[.6, .3, .1], [.1, .2, .7]]))
+    pad = np.log(np.tile([[1e-4, 1e-4, 1 - 2e-4]], (20, 1)))
+    r = lambda s: pool_frames(s, "mean")[0] - pool_frames(s, "mean")[1]
+    assert r(np.vstack([seg, pad])) == pytest.approx(r(seg), abs=5e-3)
+
+
+def test_spread_energy():
+    assert spread_energy(np.array([0, 0, 1., 0, 0]), 1).tolist() == [0, 1, 1, 1, 0]
+
+
+# ---- the scenarios ----
+
+def test_max_pool_is_the_previous_scorer():
+    """ratio_pool='max' is bit-for-bit the original formula."""
+    for sc in SCENARIOS:
+        s = score_a(sc, CONFIGS["max"])
+        a, b = s.window
+        comp_peak = sc.logp[a:b, [I, SCHWA]].max()
+        gop = s.peak - max(s.peak, comp_peak)
+        want = 100 * np.exp(0.5 * gop) * np.sqrt(min(1, np.exp(s.peak) / 0.30))
+        assert s.score == pytest.approx(want, abs=0.06), sc.name
+
+
+@pytest.mark.parametrize("pool", ["top2", "mean", "energy", "gated"])
+def test_spike_in_release_passes(pool):
+    sc = SCENARIOS[0]
+    assert score_a(sc, CONFIGS["max"]).score < 70          # the flaw
+    assert score_a(sc, CONFIGS[pool]).score >= 80
+
+
+def test_lse_only_partly_absorbs_a_tall_spike():
+    """A power mean still favours one 0.9 frame over a 0.4/0.35/0.2 target; colder is closer to the max."""
+    sc = SCENARIOS[0]
+    hot, warm, cold = (score_a(sc, GopConfig(ratio_pool="lse", pool_tau=t)).score for t in (1.0, 0.5, 0.25))
+    assert score_a(sc, CONFIGS["max"]).score < cold < warm < hot
+
+
+@pytest.mark.parametrize("pool", ["mean", "energy", "gated"])
+def test_spike_in_nucleus_passes(pool):
+    """Energy cannot hide a spike on a loud frame; the mass ratio (the /a/ has more frames) still does."""
+    assert score_a(SCENARIOS[1], CONFIGS[pool]).score >= 80
+
+
+def test_energy_weights_the_quiet_spike_down():
+    """Compared before the gop clips at 0: the pooled log ratio /a/ over /i/."""
+    sc = SCENARIOS[0]
+    a, b = score_a(sc, CONFIGS["max"]).window
+    seg = sc.logp[a:b]
+    margin = lambda w: float(np.subtract(*pool_frames(seg[:, [A, I]], "mean", weight=w)))
+    e0, e1 = sc.energy[a:b], spread_energy(sc.energy, 1)[a:b]
+    assert margin(energy_weights(e1, "energy")) > margin(None)
+    # the spread that forgives a jittered target emission also lifts a spike next to the nucleus over the gate
+    assert margin(energy_weights(e0, "gated")) > margin(energy_weights(e1, "energy")) > margin(energy_weights(e1, "gated"))
+
+
+def test_long_pause_haze_needs_the_gate():
+    """A faint competitor over a long silent window adds up in a plain mean; the voice gate drops the silence."""
+    n = 30
+    p = np.full((n, V), 1e-4)
+    p[:, SCHWA] = .05
+    p[1, K], p[5, A], p[n - 2, T_] = .9, .9, .9
+    p[:, BLANK] = 0
+    p[:, BLANK] = 1 - p.sum(1)
+    energy = np.r_[[.3, .6, .5], np.ones(4), np.full(n - 9, .02), [.5, .1]]
+    al = Alignment(0.0, [(1, 2), (5, 6), (n - 2, n - 1)])
+    s = lambda cfg: score_tokens(np.log(p), al, TOKENS, BLANK, cfg, energy=energy)[1].score
+    assert s(CONFIGS["mean"]) < 85
+    assert s(CONFIGS["gated"]) >= 95 and s(CONFIGS["top2"]) >= 95
+
+
+@pytest.mark.parametrize("pool", list(CONFIGS))
+@pytest.mark.parametrize("name", ["peaky emission", "peaky + haze"])
+def test_peaky_emission_is_not_diluted(pool, name):
+    sc = next(s for s in SCENARIOS if s.name == name)
+    assert score_a(sc, CONFIGS[pool]).score >= 95
+    assert naive_mean_score(sc) < 70                       # the flaw: averaging the confidence too
+
+
+@pytest.mark.parametrize("pool", list(CONFIGS))
+def test_emission_off_the_nucleus_still_passes(pool):
+    sc = next(s for s in SCENARIOS if s.name == "emission off nucleus")
+    assert score_a(sc, CONFIGS[pool]).score >= 85
+
+
+@pytest.mark.parametrize("pool", ["energy", "gated"])
+def test_the_aligned_emission_is_never_gated_out(pool):
+    """Without the spread the emission frame is quiet, yet the alignment's own span keeps its full weight."""
+    sc = next(s for s in SCENARIOS if s.name == "emission off nucleus")
+    assert score_a(sc, replace(CONFIGS[pool], energy_spread=0, energy_gate=0.9)).score >= 85
+
+
+@pytest.mark.parametrize("pool", list(CONFIGS))
+@pytest.mark.parametrize("name", ["sustained substitution", "one-frame substitution"])
+def test_substitution_fails(pool, name):
+    sc = next(s for s in SCENARIOS if s.name == name)
+    s = score_a(sc, CONFIGS[pool])
+    assert s.score < 40
+    assert s.competitor == I
+
+
+@pytest.mark.parametrize("pool", list(CONFIGS))
+def test_energy_pools_without_audio_fall_back_to_mean(pool):
+    sc = SCENARIOS[0]
+    s = score_a(sc, CONFIGS[pool], energy=False)
+    want = CONFIGS["mean"] if pool in ("energy", "gated") else CONFIGS[pool]
+    assert s.score == score_a(sc, want, energy=False).score
+
+
+def test_unpooled_tokens_keep_the_max():
+    sc = SCENARIOS[0]
+    al = Alignment(0.0, list(sc.spans))
+    on = score_tokens(sc.logp, al, TOKENS, BLANK, CONFIGS["mean"], pooled=[False, True, False])[1]
+    off = score_tokens(sc.logp, al, TOKENS, BLANK, CONFIGS["mean"], pooled=[True, False, True])[1]
+    assert on.score > off.score == score_a(sc, CONFIGS["max"]).score
+
+
+def test_peak_and_deletion_do_not_depend_on_the_pool():
+    for sc in SCENARIOS:
+        ref = score_a(sc, CONFIGS["max"])
+        for pool in POOLS[1:]:
+            s = score_a(sc, GopConfig(ratio_pool=pool))
+            assert (s.peak, s.deleted, s.window) == (ref.peak, ref.deleted, ref.window)
+
+
+# ---- GOP_RATIO_POOL ----
+
+def test_env_picks_the_pool(monkeypatch):
+    monkeypatch.delenv("GOP_RATIO_POOL", raising=False)
+    assert GopConfig().ratio_pool == "gated"
+    monkeypatch.setenv("GOP_RATIO_POOL", "")
+    assert GopConfig().ratio_pool == "gated"
+    monkeypatch.setenv("GOP_RATIO_POOL", " Max ")
+    assert GopConfig().ratio_pool == "max"
+    monkeypatch.setenv("GOP_RATIO_POOL", "maxx")
+    assert GopConfig().ratio_pool == "gated"                   # a typo is logged, not a crash
+    assert GopConfig(ratio_pool="topk").ratio_pool == "topk"   # an explicit config wins over the env

tests/test_gop_window.py

@@ -0,0 +1,191 @@
+"""Class-based GOP windows (align.compute_token_gop): a consonant reads its competitors from the wide window, a vowel
+from its aligned span +- GopConfig.vowel_window frames. The spans come from ctc_viterbi, as in the scorer.
+
+Every frame is a distribution: the named sounds get their probability, a 1e-4 floor the rest, blank what is left.
+"""
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+
+import numpy as np
+import pytest
+
+from app.align import GopConfig, compute_token_gop, ctc_viterbi, score_tokens, token_window
+
+BLANK, K, A, I, T_, Q, J = 0, 1, 2, 3, 4, 5, 6
+V = 7
+NAMES = {BLANK: "_", K: "k", A: "a", I: "i", T_: "t", Q: "q", J: "j"}
+
+
+def emissions(n: int, frames: dict[int, dict[int, float]]) -> np.ndarray:
+    out = np.full((n, V), 1e-4)
+    for t, probs in frames.items():
+        for tok, p in probs.items():
+            out[t, tok] = p
+    out[:, BLANK] = 0.0
+    out[:, BLANK] = np.maximum(1e-4, 1.0 - out.sum(1))
+    return np.log(out / out.sum(1, keepdims=True))
+
+
+@dataclass
+class Case:
+    name: str
+    tokens: list[int]
+    frames: dict[int, dict[int, float]]
+    target: int                    # the index of the token under test
+    good: bool                     # said right (should pass) or not (should fail)
+    n: int = 14
+    edges: list = field(default_factory=list)
+
+    @property
+    def logp(self):
+        return emissions(self.n, self.frames)
+
+    @property
+    def vowels(self):
+        return [t in (A, I) for t in self.tokens]
+
+
+CASES = [
+    # /a/ over frames 4-6, a one-frame /i/ spike in the transition into /t/
+    Case("vowel: spike in transition", [K, A, T_],
+         {1: {K: .9}, 4: {A: .3}, 5: {A: .5}, 6: {A: .4}, 9: {I: .9}, 12: {T_: .9}}, 1, True),
+    # /i/ said for /a/, held across the nucleus
+    Case("vowel: sustained substitution", [K, A, T_],
+         {1: {K: .9}, 4: {I: .6, A: .08}, 5: {I: .75, A: .1}, 6: {I: .6, A: .05}, 12: {T_: .9}}, 1, False),
+    # /a/ present but weak, /i/ held two frames later, outside the narrow window: what the narrow window gives up
+    Case("vowel: displaced substitution", [K, A, T_],
+         {1: {K: .9}, 4: {A: .35}, 7: {I: .8}, 8: {I: .85}, 12: {T_: .9}}, 1, False),
+    # /k/ barely there, the /q/ said instead peaking in the blanks before it
+    Case("consonant: competitor in blanks", [A, K, A],
+         {2: {A: .9}, 4: {Q: .85}, 5: {Q: .5}, 7: {K: .08}, 11: {A: .9}}, 1, False),
+    # /a/ deleted: the alignment gives it one frame it barely has
+    Case("vowel: deleted", [K, A, T_], {1: {K: .9}, 6: {A: .02}, 12: {T_: .9}}, 1, False),
+    # /ja/: the glide's /i/ colour lingers into the frame before the vowel
+    Case("vowel: glide transition", [J, A, T_],
+         {1: {J: .9}, 3: {I: .8}, 4: {I: .8}, 5: {A: .45}, 6: {A: .4}, 12: {T_: .9}}, 1, True,
+         edges=[None, ({I}, set()), None]),
+    # /ji/ said for /ja/: the vowel's own frames are /i/, so the glide does not excuse it
+    Case("vowel: substitution beside glide", [J, A, T_],
+         {1: {J: .9}, 5: {I: .7, A: .05}, 6: {I: .7, A: .05}, 7: {I: .6}, 12: {T_: .9}}, 1, False,
+         edges=[None, ({I}, set()), None]),
+]
+
+WIDE, NARROW = GopConfig(ratio_pool="max", vowel_window=None), GopConfig(ratio_pool="max", vowel_window=1)
+
+
+def case(name: str) -> Case:
+    return next(c for c in CASES if c.name == name)
+
+
+def score(c: Case, cfg: GopConfig, edges: bool = True):
+    al = ctc_viterbi(c.logp, c.tokens, BLANK)
+    return score_tokens(c.logp, al, c.tokens, BLANK, cfg, vowels=c.vowels,
+                        edges=c.edges if edges and c.edges else None)[c.target]
+
+
+def test_windows():
+    spans = [(1, 2), (5, 6), (12, 13)]
+    assert token_window(spans, 1, 14) == (2, 12)
+    assert token_window(spans, 1, 14, 1) == (4, 7)
+    assert token_window(spans, 1, 14, 0) == (5, 6)
+    assert token_window(spans, 1, 14, 9) == (2, 12)       # never past the neighbours
+    assert token_window(spans, 0, 14, 1) == (0, 3)
+
+
+def test_wide_vowel_window_is_the_previous_scorer():
+    """vowel_window None reads a vowel exactly as score_tokens did before it had classes."""
+    for c in CASES:
+        al = ctc_viterbi(c.logp, c.tokens, BLANK)
+        old = score_tokens(c.logp, al, c.tokens, BLANK, WIDE)
+        assert score_tokens(c.logp, al, c.tokens, BLANK, WIDE, vowels=c.vowels) == old, c.name
+
+
+def test_narrow_window_drops_a_transition_spike():
+    c = case("vowel: spike in transition")
+    assert score(c, WIDE).score < 80 and score(c, WIDE).competitor == I
+    assert score(c, NARROW).score >= 95
+
+
+def test_sustained_vowel_substitution_still_fails():
+    s = score(case("vowel: sustained substitution"), NARROW)
+    assert s.score < 30 and s.competitor == I
+
+
+def test_narrow_window_gives_up_a_displaced_substitution():
+    """The cost: a target that is present, with the real vowel held outside span +- pad, now passes."""
+    c = case("vowel: displaced substitution")
+    assert score(c, WIDE).score < 70
+    assert score(c, NARROW).score >= 95
+    assert score(c, GopConfig(ratio_pool="max", vowel_window=3)).score < 70   # a wider pad catches it again
+
+
+def test_wide_pooled_ratio_gets_both():
+    """Why wide is the default: a pooled ratio passes the one-frame spike and still fails the held substitution."""
+    cfg = GopConfig(ratio_pool="mean", vowel_window=None)
+    assert score(case("vowel: spike in transition"), cfg).score >= 95
+    assert score(case("vowel: displaced substitution"), cfg).score < 50
+
+
+def test_consonant_keeps_the_wide_window():
+    c = case("consonant: competitor in blanks")
+    for cfg in (WIDE, NARROW):
+        s = score(c, cfg)
+        assert s.score < 50 and s.competitor == Q
+    # read as a vowel (narrow), the /q/ in the blanks is lost
+    al = ctc_viterbi(c.logp, c.tokens, BLANK)
+    narrow = compute_token_gop(c.logp, al.spans, 1, c.tokens, BLANK, NARROW, vowel=True)
+    assert narrow.competitor != Q
+
+
+@pytest.mark.parametrize("pad", [None, 0, 1, 2])
+def test_deletion_is_read_from_the_wide_window(pad):
+    c = case("vowel: deleted")
+    al = ctc_viterbi(c.logp, c.tokens, BLANK)
+    assert al.spans[1][1] - al.spans[1][0] == 1                 # one frame
+    s = score(c, GopConfig(ratio_pool="max", vowel_window=pad))
+    assert s.deleted and s.score < 30
+
+
+def test_a_competitor_outside_the_narrow_window_still_blocks_deletion():
+    """Not deleted but substituted: the /i/ is strong in the wide window, if out of the narrow one."""
+    c = Case("x", [K, A, T_], {1: {K: .9}, 6: {A: .02}, 9: {I: .9}, 12: {T_: .9}}, 1, False)
+    assert not score(c, NARROW).deleted
+
+
+def test_glide_colour_is_not_a_competitor():
+    c = case("vowel: glide transition")
+    assert score(c, NARROW, edges=False).score < 85
+    assert score(c, NARROW).score >= 95
+    assert score(c, WIDE).score >= 95                          # the mask works in the wide window too
+
+
+def test_glide_does_not_excuse_a_substitution():
+    s = score(case("vowel: substitution beside glide"), NARROW)
+    assert s.score < 30 and s.competitor == I
+
+
+def test_glide_colour_does_not_block_deletion():
+    c = Case("x", [J, A, T_], {1: {J: .9}, 3: {I: .3}, 6: {A: .02}, 12: {T_: .9}}, 1, False,
+             edges=[None, ({I}, set()), None])
+    assert score(c, NARROW, edges=False).deleted is False
+    assert score(c, NARROW).deleted
+
+
+def test_env_picks_the_vowel_window(monkeypatch):
+    for raw, want in (("", None), ("wide", None), (" Wide ", None), ("narrow", 1), ("0", 0), ("3", 3), ("tight", None)):
+        monkeypatch.setenv("GOP_VOWEL_WINDOW", raw)
+        assert GopConfig().vowel_window == want, raw
+    monkeypatch.delenv("GOP_VOWEL_WINDOW")
+    assert GopConfig().vowel_window is None
+
+
+def test_scorer_marks_glides_beside_vowels():
+    from types import SimpleNamespace
+
+    from app.scorer import Scorer, TargetToken
+
+    ids = {"j": 1, "a": 2, "w": 3, "i": 4, "iː": 5, "u": 6}          # no e, eː, uː, o, oː in this model
+    fake = SimpleNamespace(vocab=SimpleNamespace(sound_id=ids.get))
+    toks = [TargetToken(p, ids[p], 0) for p in ("j", "a", "w", "a")]
+    assert Scorer._glide_edges(fake, toks) == [None, ({4, 5}, {6}), None, ({6}, set())]

tests/test_lab.py

@@ -72,6 +72,30 @@ class FakeAuth:
     def lab_audio(self, sample_id):
         return (tone_wav(), "audio/wav") if self.lab_sample(sample_id) else None
 
+    def delete_lab_samples(self, speaker=None):
+        gone = [s for s in self.samples if speaker is None or (s.get("speaker") or "") == speaker]
+        self.samples = [s for s in self.samples if s not in gone]
+        return len(gone)
+
+
+def test_lab_deletes_one_speaker_or_everyone():
+    from fastapi.testclient import TestClient
+
+    from app.main import create_app
+
+    auth, teacher = FakeAuth(), {"Authorization": "Bearer teacher"}
+    audio = {"audio": ("a.wav", tone_wav(), "audio/wav")}
+    with TestClient(create_app(scorer_for(emissions(["ħ", "aː", "l"])), NoTTS(), auth=auth)) as c:
+        for speaker in ("א", "א", "ב"):
+            c.post("/api/lab/score", data={"item": "pair-ħaal", "speaker": speaker}, files=audio, headers=teacher)
+        assert c.delete("/api/lab/samples", headers=teacher).status_code == 400          # never all by omission
+        assert c.delete("/api/lab/samples?speaker=א&everyone=true", headers=teacher).status_code == 400
+        assert c.delete("/api/lab/samples?everyone=true", headers={"Authorization": "Bearer student"}).status_code == 403
+        assert c.delete("/api/lab/samples?speaker=%20א%20", headers=teacher).json() == {"deleted": 2}
+        assert c.get("/api/lab/results", headers=teacher).json()["speakers"] == ["ב"]
+        assert c.delete("/api/lab/samples?everyone=true", headers=teacher).json() == {"deleted": 1}
+        assert c.get("/api/lab/results", headers=teacher).json()["totals"]["recordings"] == 0
+
 
 def test_items_are_well_formed():
     assert len({i["id"] for i in ITEMS}) == len(ITEMS)
@@ -189,6 +213,29 @@ def test_lab_results_and_flag_rescore():
         assert c.post("/api/lab/flags/8/rescore", headers=teacher).status_code == 404
 
 
+def test_minerva_lab_groups_imported_segments_by_video():
+    from fastapi.testclient import TestClient
+
+    from app.main import create_app
+
+    auth, teacher = FakeAuth(), {"Authorization": "Bearer teacher"}
+    auth.samples = [
+        {"id": 2, "item": "minerva:U8aBRd3-wlM:02", "speaker": "מינרווה", "device": "minerva:U8aBRd3-wlM:4.2-7.8",
+         "ar": "مرحبا", "ipa": "m a r ħ a b a", "score": 81, "heard_ipa": "m a r ħ a b a", "flagged": [],
+         "result": {}, "audio": "two.webm"},
+        {"id": 1, "item": "minerva:U8aBRd3-wlM:01", "speaker": "מינרווה", "device": "minerva:U8aBRd3-wlM:1.0-4.0",
+         "ar": "أهلا", "ipa": "ʔ a h l a", "score": 70, "heard_ipa": "ʔ a h l a", "flagged": ["h>x"],
+         "result": {"unrelated": False}, "audio": "one.webm"},
+        {"id": 3, "item": "pair-ħaal", "speaker": "אחר", "device": "", "audio": "other.wav"},
+    ]
+    with TestClient(create_app(scorer_for(emissions(["ħ", "aː", "l"])), NoTTS(), auth=auth)) as c:
+        d = c.get("/api/lab/minerva", headers=teacher).json()
+        assert len(d["videos"]) == 1 and d["videos"][0]["id"] == "U8aBRd3-wlM"
+        assert [s["line"] for s in d["videos"][0]["samples"]] == [1, 2]
+        assert d["videos"][0]["samples"][0]["start"] == 1.0
+        assert c.get("/api/lab/minerva", headers={"Authorization": "Bearer student"}).status_code == 403
+
+
 def test_lab_rescores_its_recordings_and_compares_with_the_stored_scores():
     from fastapi.testclient import TestClient
 
@@ -206,6 +253,7 @@ def test_lab_rescores_its_recordings_and_compares_with_the_stored_scores():
         assert r["id"] == 1 and not any(p["flagged"] for w in r["result"]["words"] for p in w["phonemes"])
         assert "trace" not in r["result"]
         d = c.post("/api/lab/results", json={"results": {"1": r["result"]}}, headers=teacher).json()
+        assert d["pool"] == c.app.state.scorer.cfg.gop.ratio_pool
         before, after = ({x["sound"]: x for x in d[k]["sounds"]}["ħ"] for k in ("stored", "now"))
         assert before["frr"] == 1.0 and after["frr"] == 0.0
         assert c.post("/api/lab/samples/9/rescore", headers=teacher).status_code == 404
@@ -253,3 +301,137 @@ def test_lab_automatic_test_with_tts():
         c.app.state.tts = None
         assert c.get("/api/lab/tts", headers=teacher).json()["voices"] == []
         assert c.post("/api/lab/tts", data={"item": "pair-ħaal", "voice": "ראאף"}, headers=teacher).status_code == 503
+
+
+def test_lab_sweeps_every_gop_setting():
+    from fastapi.testclient import TestClient
+
+    from app import lab
+    from app.main import create_app
+
+    assert len(lab.SWEEP) == 24 and len(lab.SWEEP_KEYS) == 24
+    assert lab.quality({"frr": .1, "detection": .5}) == 70.0 and lab.quality({"frr": .1, "detection": None}) == 90.0
+    assert lab.quality({"frr": None}) is None and lab.quality_partial({"frr": .1, "detection": None})
+
+    auth, teacher = FakeAuth(), {"Authorization": "Bearer teacher"}
+    audio = {"audio": ("a.wav", tone_wav(), "audio/wav")}
+    with TestClient(create_app(scorer_for(emissions(["χ", "aː", "l"])), NoTTS(), auth=auth)) as c:
+        c.post("/api/lab/score", data={"item": "pair-ħaal"}, files=audio, headers=teacher)          # ħ heard as χ
+        c.post("/api/lab/score", data={"item": "pair-ħaal", "mistake": "0"}, files=audio,
+               headers=teacher)
+        before = c.app.state.scorer.cfg.gop
+        r = c.post("/api/lab/samples/1/sweep", headers=teacher).json()
+        assert r["id"] == 1 and set(r["results"]) == set(lab.SWEEP_KEYS)
+        assert c.app.state.scorer.cfg.gop == before                     # the server's own setting is untouched
+        r2 = c.post("/api/lab/samples/2/sweep", headers=teacher).json()
+        d = c.post("/api/lab/sweep", json={"results": {"1": r["results"], "2": r2["results"]}}, headers=teacher).json()
+        assert len(d["settings"]) == 24 and d["recordings"] == 2
+        assert d["current"] == lab.sweep_key(before.ratio_pool, before.vowel_window)
+        s = d["settings"][0]
+        assert {"key", "pool", "window", "quality", "partial", "totals"} <= set(s)
+        qs = [x["quality"] for x in d["settings"]]
+        assert qs == sorted(qs, reverse=True)
+        assert c.post("/api/lab/samples/9/sweep", headers=teacher).status_code == 404
+        assert c.post("/api/lab/sweep", json={"results": []}, headers=teacher).status_code == 400
+        assert c.post("/api/lab/samples/1/sweep", headers={"Authorization": "Bearer student"}).status_code == 403
+
+
+def test_vowel_stats_score_vowels_not_flags():
+    from app.lab import vowel_stats
+
+    def sample(i, phones, mistake=None):
+        return {"id": i, "label": "mistake" if mistake else "correct",
+                "mistake": {"index": 0, "expected": mistake} if mistake else None,
+                "result": {"words": [{"phonemes": [{"ipa": p, "score": sc} for p, sc in phones]}]}}
+
+    rows = [sample(1, [("k", 40), ("a", 95), ("i", 70)]), sample(2, [("a", 30), ("l", 100)], mistake="a"),
+            {**sample(3, [("a", 10)]), "result": {"unrelated": True, "words": [{"phonemes": [{"ipa": "a", "score": 10}]}]}}]
+    v = vowel_stats(rows)
+    assert v == {"right": 2, "mean": 82.5, "weak": 0.5, "planted": 1, "auc": 1.0}   # k is no vowel, #3 is unrelated
+    assert vowel_stats(rows[:1])["auc"] is None
+    assert vowel_stats(rows, {2: {"words": [{"phonemes": [{"ipa": "a", "score": 70}]}]}})["auc"] == 0.75
+
+
+def test_the_sweep_scores_every_setting_whatever_the_env(monkeypatch):
+    """The sweep passes each setting to the scorer itself: the env only picks the server's own one."""
+    from fastapi.testclient import TestClient
+
+    import app.scorer as scorer_module
+    from app import lab
+    from app.main import create_app
+
+    monkeypatch.setenv("GOP_RATIO_POOL", "max")
+    monkeypatch.setenv("GOP_VOWEL_WINDOW", "wide")
+    seen, real = [], scorer_module.score_tokens
+    monkeypatch.setattr(scorer_module, "score_tokens",
+                        lambda logp, al, ids, blank, cfg, *a, **k: seen.append((cfg.ratio_pool, cfg.vowel_window))
+                        or real(logp, al, ids, blank, cfg, *a, **k))
+    auth, teacher = FakeAuth(), {"Authorization": "Bearer teacher"}
+    with TestClient(create_app(scorer_for(emissions(["ħ", "aː", "l"])), NoTTS(), auth=auth)) as c:
+        c.post("/api/lab/score", data={"item": "pair-ħaal"}, files={"audio": ("a.wav", tone_wav(), "audio/wav")},
+               headers=teacher)
+        assert c.app.state.scorer.cfg.gop.ratio_pool == "max"
+        seen.clear()
+        r = c.post("/api/lab/samples/1/sweep", headers=teacher).json()
+        assert sorted(seen, key=str) == sorted(lab.SWEEP, key=str)
+        d = c.post("/api/lab/sweep", json={"results": {"1": r["results"]}}, headers=teacher).json()
+        assert all({"right", "mean", "weak", "planted", "auc"} <= set(s["vowels"]) for s in d["settings"])
+        base = next(s for s in d["settings"] if s["key"] == "max|wide")
+        assert base["changed"] == 0 and base["sounds"] == 3
+        assert d["current"] == "max|wide"
+
+
+def test_the_sweep_shows_which_settings_changed_a_score():
+    """A long vowel with an /i/ spike inside its window: max|wide marks it down, the pooled settings do not."""
+    from fastapi.testclient import TestClient
+
+    from app.main import create_app
+    from test_scoring import SYMS, VOCAB
+
+    lp = emissions(["ħ", "aː", "l"], gap=5)
+    p = np.exp(lp)
+    vowel = [t for t in range(len(p)) if lp[t].argmax() == VOCAB["aː"]]
+    for t in vowel:
+        p[t] = (1 - .45) / (len(SYMS) - 1); p[t, VOCAB["aː"]] = .45
+    p[vowel[-1] + 3] = .1 / (len(SYMS) - 1); p[vowel[-1] + 3, VOCAB["i"]] = .9
+    auth, teacher = FakeAuth(), {"Authorization": "Bearer teacher"}
+    with TestClient(create_app(scorer_for(np.log(p / p.sum(1, keepdims=True))), NoTTS(), auth=auth)) as c:
+        c.post("/api/lab/score", data={"item": "pair-ħaal"}, files={"audio": ("a.wav", tone_wav(), "audio/wav")},
+               headers=teacher)
+        r = c.post("/api/lab/samples/1/sweep", headers=teacher).json()
+        d = {s["key"]: s for s in c.post("/api/lab/sweep", json={"results": {"1": r["results"]}}, headers=teacher).json()["settings"]}
+        assert d["max|wide"]["changed"] == 0 and d["max|wide"]["vowels"]["mean"] < 80
+        for key in ("mean|wide", "gated|wide", "topk|wide", "max|1"):
+            assert d[key]["changed"] == 1 and d[key]["vowels"]["mean"] > 95, key
+
+
+def test_lab_opens_the_trace_of_any_saved_recording():
+    from fastapi.testclient import TestClient
+
+    from app.main import create_app
+
+    auth, teacher = FakeAuth(), {"Authorization": "Bearer teacher"}
+    audio = {"audio": ("a.wav", tone_wav(), "audio/wav")}
+    with TestClient(create_app(scorer_for(emissions(["χ", "aː", "l"])), NoTTS(), auth=auth)) as c:
+        c.post("/api/lab/score", data={"item": "pair-ħaal", "speaker": "א"}, files=audio, headers=teacher)
+        recs = c.get("/api/lab/results", headers=teacher).json()["recordings"]
+        assert [(r["id"], r["item"], r["speaker"], r["flagged"]) for r in recs] == [(1, "pair-ħaal", "א", ["ħ>χ"])]
+        assert recs[0]["unrelated"] is False
+        d = c.post("/api/lab/samples/1/rescore?trace=true", headers=teacher).json()
+        assert "trace" in d["result"] and d["result"]["trace"]["tokens"] and d["sample"]["item"] == "pair-ħaal"
+        g = c.app.state.scorer.cfg.gop
+        assert d["setting"] == f"{g.ratio_pool}|{'wide' if g.vowel_window is None else g.vowel_window}"
+        d = c.post("/api/lab/samples/1/rescore?trace=true&setting=max|1", headers=teacher).json()
+        assert d["setting"] == "max|1" and "trace" in d["result"]
+        assert "trace" not in c.post("/api/lab/samples/1/rescore", headers=teacher).json()["result"]
+        assert c.post("/api/lab/samples/1/rescore?trace=true&setting=nope", headers=teacher).status_code == 400
+
+
+def test_imported_lab_line_reconstructs_its_phrase_outside_the_fixed_list():
+    from app.lab import sample_phrase
+
+    phrase = sample_phrase({"id": 7, "item": "minerva:video:01", "ar": "حال", "ipa": "ħ aː l",
+                            "speaker": "מינרווה"})
+    assert phrase == {"cat": "lab", "key": "minerva:video:01", "he": "מינרווה",
+                      "variants": [("حال", "ħ aː l")]}
+    assert sample_phrase({"id": 8, "item": "removed-item"}) is None

tests/test_minerva_import.py

@@ -0,0 +1,10 @@
+from scripts.import_minerva import PILOT, phrases
+
+
+def test_minerva_pilot_manifest_has_exactly_the_reviewed_three_videos_and_70_lines():
+    assert [v.youtube_id for v in PILOT] == ["U8aBRd3-wlM", "OuAwxXUZBU4", "V2y6LqnoXTo"]
+    assert [len(v.lines) for v in PILOT] == [15, 22, 33]
+    made, _ = phrases()
+    assert len(made) == 70
+    assert len({p[4]["key"] for p in made}) == 70
+    assert all(p[2] < p[3] and p[4]["variants"] for p in made)