feat(tts): add activity logging for Sawtak requests and uploads, including API endpoint for monitoring

app/main.py

@@ -2524,6 +2524,18 @@ def create_app(scorer: Scorer | None = None, tts: SawtakTTS | None = None,
             app.state.refs.invalidate()
         return {"ok": True, "removed": removed}
 
+    @app.get("/api/tts-cache/activity")
+    def tts_cache_activity(_a: SupabaseAuth = Depends(teacher_only)):
+        """What the voice cache is doing: Sawtak requests and bucket uploads in flight and the latest results."""
+        tts = app.state.tts
+        if tts is None or not hasattr(tts, "activity"):
+            return {"now": time.time(), "active": [], "events": [], "pace": None}
+        from .tts import MAX_CONCURRENT, MIN_REQUEST_INTERVAL
+        return {**tts.activity.snapshot(),
+                "pace": {"per_minute": round(60 / MIN_REQUEST_INTERVAL) if MIN_REQUEST_INTERVAL else None,
+                         "max_concurrent": MAX_CONCURRENT,
+                         "sweep_workers": WARM_WORKERS}}
+
     @app.post("/api/tts-cache/import")
     def import_tts_cache(archive: UploadFile = File(...), _a: SupabaseAuth = Depends(teacher_only)):
         """Load an offline copy (a zip from GET /api/tts-cache/download) back into the cache: each WAV that is not
@@ -2571,7 +2583,7 @@ def create_app(scorer: Scorer | None = None, tts: SawtakTTS | None = None,
                 for i in range(0, len(added), 25):
                     batch = added[i:i + 25]
                     try:
-                        mirror.upload([(path, mirror.remote_path(rel)) for path, rel in batch])
+                        mirror.upload([(path, mirror.remote_path(rel)) for path, rel in batch], source="import")
                     except Exception as e:  # the next cache-warm sweep uploads what is still missing
                         log.warning("tts import: bucket upload of %d files failed: %s", len(batch), e)
             threading.Thread(target=upload, name="ihki-tts-import", daemon=True).start()
@@ -2675,7 +2687,7 @@ def create_app(scorer: Scorer | None = None, tts: SawtakTTS | None = None,
             if not batch:
                 return
             try:
-                mirror.upload([(src, dest) for src, dest, _size in batch])
+                mirror.upload([(src, dest) for src, dest, _size in batch], source="sweep")
                 with uploads:
                     remote.update({dest: size for _src, dest, size in batch})
                 with app.state.tts_warm_lock:

app/tts.py

@@ -14,6 +14,8 @@ Env:  SAWTAK_API_KEY   required; without it /api/tts answers 503 and the page fa
 from __future__ import annotations
 
 import hashlib
+import itertools
+from collections import deque
 import http.client
 import io
 import json
@@ -55,6 +57,37 @@ class TTSUnavailable(Exception):
         self.transient = transient or status == 429 or (status is not None and status >= 500)
 
 
+class ActivityLog:
+    """What the voice cache is doing, for the monitoring panel: requests in flight and the latest results.
+
+    Holds phrase-bank text only (no user data), kept in memory for the life of the process."""
+
+    def __init__(self, size: int = 80):
+        self._lock = threading.Lock()
+        self._events: deque[dict] = deque(maxlen=size)
+        self._active: dict[int, dict] = {}
+        self._ids = itertools.count(1)
+
+    def begin(self, **info) -> int:
+        with self._lock:
+            n = next(self._ids)
+            self._active[n] = {**info, "id": n, "started": time.time()}
+            return n
+
+    def end(self, n: int, **result) -> None:
+        with self._lock:
+            event = self._active.pop(n, None) or {"started": time.time()}
+            now = time.time()
+            event.update(result, at=now, ms=round((now - event["started"]) * 1000))
+            self._events.appendleft(event)
+
+    def snapshot(self) -> dict:
+        with self._lock:
+            now = time.time()
+            active = [{**a, "elapsed_ms": round((now - a["started"]) * 1000)} for a in self._active.values()]
+            return {"now": now, "active": sorted(active, key=lambda a: a["started"]), "events": list(self._events)}
+
+
 class BucketMirror:
     """Copies cached WAVs into a Hugging Face Storage Bucket through its API.
 
@@ -63,6 +96,7 @@ class BucketMirror:
 
     def __init__(self, bucket_id: str, prefix: str = "ihki-tts", token: str | None = None):
         self.bucket_id, self.prefix, self.token = bucket_id, prefix.strip("/"), token
+        self.activity: ActivityLog | None = None  # set when attached to a SawtakTTS
 
     def remote_path(self, rel: str) -> str:
         return f"{self.prefix}/{rel}" if self.prefix else rel
@@ -78,11 +112,21 @@ class BucketMirror:
                 out[item.path] = size
         return out
 
-    def upload(self, files: list[tuple[Path | bytes, str]]) -> None:
+    def upload(self, files: list[tuple[Path | bytes, str]], source: str = "") -> None:
         """Upload (local path or bytes, bucket path) pairs in one batch."""
         from huggingface_hub import batch_bucket_files
-        batch_bucket_files(self.bucket_id, add=[(str(src) if isinstance(src, Path) else src, dest)
-                                                for src, dest in files], token=self.token)
+        size = sum(len(src) if isinstance(src, bytes) else src.stat().st_size for src, _dest in files)
+        n = self.activity.begin(kind="upload", source=source, files=len(files), bytes=size,
+                                text=files[0][1].rsplit("/", 1)[-1] if len(files) == 1 else "") if self.activity else 0
+        try:
+            batch_bucket_files(self.bucket_id, add=[(str(src) if isinstance(src, Path) else src, dest)
+                                                    for src, dest in files], token=self.token)
+        except Exception as e:
+            if self.activity:
+                self.activity.end(n, status="error", message=str(e)[:200])
+            raise
+        if self.activity:
+            self.activity.end(n, status="ok")
 
 
 class SawtakTTS:
@@ -96,11 +140,22 @@ class SawtakTTS:
         self._in_flight = threading.Semaphore(MAX_CONCURRENT)
         self._key_locks: dict[str, threading.Lock] = {}  # one generation per recording at a time
         self._cache_hits = self._cache_misses = 0
-        self.mirror: BucketMirror | None = None  # set by load_tts when TTS_BUCKET is configured
+        self.activity = ActivityLog()  # Sawtak requests and bucket uploads, for the monitoring panel
+        self._mirror: BucketMirror | None = None  # set by load_tts when TTS_BUCKET is configured
         # With a mirror, new recordings are written here (local disk) and uploaded through the Bucket API, instead
         # of into cache_dir: a bucket mounted there only flushes a few files every ~30 s, so each write crawled.
         self.staging_dir: Path | None = None
 
+    @property
+    def mirror(self) -> BucketMirror | None:
+        return self._mirror
+
+    @mirror.setter
+    def mirror(self, mirror: BucketMirror | None) -> None:
+        self._mirror = mirror
+        if mirror is not None:
+            mirror.activity = self.activity
+
     def _request(self, path: str, body: dict | None = None):
         req = urllib.request.Request(
             BASE_URL + path,
@@ -190,15 +245,32 @@ class SawtakTTS:
         with self._lock:
             return self._key_locks.setdefault(key, threading.Lock())
 
-    def _generate(self, text: str, voice: str) -> bytes:
+    def _generate(self, text: str, voice: str, source: str = "") -> bytes:
         """Generate one uncached WAV recording: paced, and at most MAX_CONCURRENT at once."""
+        queued = time.monotonic()
         with self._pace:
             start = max(time.monotonic(), self._next_start)
             self._next_start = start + MIN_REQUEST_INTERVAL
         if start > time.monotonic():
             time.sleep(start - time.monotonic())
         with self._in_flight:
-            return self._generate_now(text, voice)
+            n = self.activity.begin(kind="sawtak", source=source, text=text[:80], voice=voice,
+                                    waited_ms=round((time.monotonic() - queued) * 1000))
+            try:
+                data = self._generate_now(text, voice)
+            except TTSUnavailable as e:
+                self.activity.end(n, status=e.status or "error", message=str(e)[:200])
+                raise
+            except Exception as e:
+                self.activity.end(n, status="error", message=f"{type(e).__name__}: {e}"[:200])
+                raise
+            try:
+                with wave.open(io.BytesIO(data)) as w:
+                    audio = round(w.getnframes() / w.getframerate(), 2)
+            except (wave.Error, EOFError):
+                audio = None
+            self.activity.end(n, status=200, bytes=len(data), audio_s=audio)
+            return data
 
     def _generate_now(self, text: str, voice: str) -> bytes:
         # Sawtak currently returns 320 seconds of silence whenever `temperature` is present,
@@ -262,7 +334,7 @@ class SawtakTTS:
                     "misses": self._cache_misses,
                     "hit_rate": round(self._cache_hits / requests, 4) if requests else None}
 
-    def _wav(self, text: str, voice: str, upload: bool = False) -> tuple[bytes, str]:
+    def _wav(self, text: str, voice: str, upload: bool = False, source: str = "") -> tuple[bytes, str]:
         """Generate or read `text` for an already validated voice id. `upload`: send a new recording to the bucket
         in the background (playback); the cache-warm sweep uploads its own in batches. Different recordings can be
         generated at the same time (see _generate); the same one waits for the first request and then reads it."""
@@ -286,7 +358,7 @@ class SawtakTTS:
             self._count(hit=False)
             # The caller supplies the phrase's Palestinian vowel marks. Sawtak preserves existing
             # marks; enhancement fills remaining pronunciation cues using the selected voice's dialect.
-            data = self._generate(text, voice)
+            data = self._generate(text, voice, source)
             if self.staging_dir is not None:
                 path = self.staging_dir / self.cache_key(text, voice)
             try:
@@ -313,7 +385,7 @@ class SawtakTTS:
 
         def go() -> None:
             try:
-                mirror.upload([(data, mirror.remote_path(rel))])
+                mirror.upload([(data, mirror.remote_path(rel))], source="playback")
             except Exception as e:  # the next cache-warm sweep uploads what is still missing
                 log.warning("tts bucket upload of %s failed: %s", rel, e)
         threading.Thread(target=go, name="ihki-tts-upload", daemon=True).start()
@@ -321,11 +393,11 @@ class SawtakTTS:
     def wav(self, text: str, voice: str = "") -> tuple[bytes, str]:
         """(WAV, voice id) in Raef's voice, or a dialogue line's configured voice."""
         voice = voice if voice in LINE_VOICES.values() else RAEF_VOICE_ID
-        return self._wav(text, voice, upload=True)
+        return self._wav(text, voice, upload=True, source="playback")
 
-    def wav_for_voice(self, text: str, voice: str) -> tuple[bytes, str]:
+    def wav_for_voice(self, text: str, voice: str, source: str = "sweep") -> tuple[bytes, str]:
         """(WAV, voice id) for a teacher-selected, validated Sawtak voice."""
-        return self._wav(text, voice)
+        return self._wav(text, voice, source=source)
 
 
 def load_tts(key: str | None = None) -> SawtakTTS | None:

static/index.html

@@ -1235,9 +1235,60 @@ html[data-subject="math"] #bootErr{color:#F08A8A}
 @media (prefers-reduced-motion:reduce){#startBtn,#loginBtn,#roles button,#mailForm{animation:none;opacity:1}#logo-splash{transition:none}}
 #wrap{opacity:1;transition:opacity .65s ease .1s}
 #wrap[inert]{opacity:0}
+/* Accessibility toolbar: available on the splash screen and throughout every app view. */
+.a11y-launch{position:fixed;top:max(12px,env(safe-area-inset-top));left:12px;z-index:100;display:grid;place-items:center;width:46px;height:46px;padding:0;border:2px solid var(--olive);border-radius:50%;background:var(--surface);color:var(--olive);box-shadow:0 3px 12px rgb(0 0 0/.2);font:700 24px/1 var(--f-body);cursor:pointer}
+.a11y-launch:hover,.a11y-launch:focus-visible{background:var(--olive-soft);outline:3px solid var(--surface);outline-offset:2px}
+.a11y-panel{position:fixed;top:max(66px,calc(env(safe-area-inset-top) + 66px));left:12px;z-index:101;width:min(310px,calc(100vw - 24px));padding:14px;border:1px solid var(--line);border-radius:14px;background:var(--surface);color:var(--ink);box-shadow:0 8px 28px rgb(0 0 0/.28)}
+.a11y-head{display:flex;align-items:center;justify-content:space-between;gap:12px;margin-bottom:10px}.a11y-head strong{font-size:19px}.a11y-close{width:36px;height:36px;border:0;border-radius:50%;background:transparent;color:var(--ink);font:700 18px/1 var(--f-body);cursor:pointer}.a11y-close:hover,.a11y-close:focus-visible{background:var(--olive-soft);outline:2px solid var(--olive)}
+.a11y-grid{display:grid;grid-template-columns:repeat(2,minmax(0,1fr));gap:8px}.a11y-grid button{min-height:48px;padding:8px;border:1px solid var(--line);border-radius:10px;background:var(--bg);color:var(--ink);font:700 15px/1.25 var(--f-body);cursor:pointer}.a11y-grid button:hover,.a11y-grid button:focus-visible{border-color:var(--olive);outline:2px solid var(--olive);outline-offset:1px}.a11y-grid button[aria-pressed=true]{border-color:var(--olive);background:var(--olive);color:var(--on-olive)}.a11y-grid .a11y-reset{grid-column:1/-1;color:var(--sumac)}
+html.a11y-font-large{font-size:115%}html.a11y-font-large body{font-size:19px}html.a11y-font-xlarge{font-size:130%}html.a11y-font-xlarge body{font-size:21px}
+html.a11y-contrast{--bg:#000;--surface:#000;--ink:#fff;--muted:#fff;--line:#fff;--olive:#ffeb3b;--olive-deep:#ffeb3b;--on-olive:#000;--olive-soft:#242400;--sumac:#ff8da1;--sumac-bg:#310009;--ok:#70ff9b;--ok-bg:#063d18;--amber:#ffd166;--amber-bg:#3d2b00;--orange:#ffb45b;color-scheme:dark}
+html.a11y-contrast :focus-visible{outline:3px solid #00e5ff!important;outline-offset:3px!important}
+html.a11y-links a{text-decoration:underline!important;text-decoration-thickness:3px!important;text-underline-offset:3px!important}
+html.a11y-reduce-motion *,html.a11y-reduce-motion *::before,html.a11y-reduce-motion *::after{scroll-behavior:auto!important;animation-duration:.001ms!important;animation-iteration-count:1!important;transition-duration:.001ms!important}
+@media(max-width:420px){.a11y-launch{top:max(8px,env(safe-area-inset-top));left:8px}.a11y-panel{left:8px;width:calc(100vw - 16px)}}
 </style>
 </head>
 <body class="home">
+<button class="a11y-launch" id="a11yLaunch" type="button" aria-label="פתיחת סרגל נגישות" aria-controls="a11yPanel" aria-expanded="false" title="נגישות">♿</button>
+<section class="a11y-panel" id="a11yPanel" aria-labelledby="a11yTitle" hidden>
+  <div class="a11y-head"><strong id="a11yTitle">אפשרויות נגישות</strong><button class="a11y-close" id="a11yClose" type="button" aria-label="סגירת סרגל הנגישות">✕</button></div>
+  <div class="a11y-grid">
+    <button type="button" data-a11y="font" aria-pressed="false">טקסט גדול</button>
+    <button type="button" data-a11y="contrast" aria-pressed="false">ניגודיות גבוהה</button>
+    <button type="button" data-a11y="links" aria-pressed="false">הדגשת קישורים</button>
+    <button type="button" data-a11y="motion" aria-pressed="false">הפחתת תנועה</button>
+    <button type="button" class="a11y-reset" id="a11yReset">איפוס הגדרות</button>
+  </div>
+</section>
+<script>
+/* Accessibility preferences are local to this device and are applied before the app opens. */
+(()=>{
+  const root=document.documentElement, launch=document.getElementById("a11yLaunch"), panel=document.getElementById("a11yPanel"), close=document.getElementById("a11yClose");
+  const key="ihki.accessibility.v1", defaults={font:0,contrast:false,links:false,motion:false};
+  let prefs={...defaults};
+  try{ prefs={...prefs,...JSON.parse(localStorage.getItem(key)||"{}")} }catch{}
+  const buttons=()=>Object.fromEntries([...panel.querySelectorAll("[data-a11y]")].map(button=>[button.dataset.a11y,button]));
+  const apply=()=>{
+    root.classList.toggle("a11y-font-large",prefs.font===1); root.classList.toggle("a11y-font-xlarge",prefs.font===2);
+    root.classList.toggle("a11y-contrast",prefs.contrast); root.classList.toggle("a11y-links",prefs.links); root.classList.toggle("a11y-reduce-motion",prefs.motion);
+    const b=buttons(); b.font.textContent=["טקסט גדול","טקסט גדול יותר","גודל טקסט רגיל"][prefs.font]; b.font.setAttribute("aria-pressed",String(prefs.font>0));
+    for(const name of ["contrast","links","motion"]) b[name].setAttribute("aria-pressed",String(prefs[name]));
+    try{ localStorage.setItem(key,JSON.stringify(prefs)) }catch{}
+  };
+  const shut=()=>{ panel.hidden=true; launch.setAttribute("aria-expanded","false"); launch.focus({preventScroll:true}); };
+  launch.addEventListener("click",()=>{ const opening=panel.hidden; panel.hidden=!opening; launch.setAttribute("aria-expanded",String(opening)); if(opening) close.focus({preventScroll:true}); });
+  close.addEventListener("click",shut);
+  panel.addEventListener("click",event=>{
+    const button=event.target.closest("[data-a11y]"); if(!button) return;
+    const name=button.dataset.a11y; if(name==="font") prefs.font=(prefs.font+1)%3; else prefs[name]=!prefs[name]; apply();
+  });
+  document.getElementById("a11yReset").addEventListener("click",()=>{ prefs={...defaults}; apply(); });
+  document.addEventListener("keydown",event=>{ if(event.key==="Escape"&&!panel.hidden) shut(); });
+  document.addEventListener("pointerdown",event=>{ if(!panel.hidden&&!panel.contains(event.target)&&event.target!==launch) shut(); });
+  apply();
+})();
+</script>
 <aside class="install-prompt" id="installPrompt" role="dialog" aria-labelledby="installTitle" aria-describedby="installText" hidden>
   <strong id="installTitle">להתקין את אהלא וסהלא?</strong>
   <p id="installText">כך אפשר לפתוח את האתר כמו אפליקציה ישר ממסך הבית.</p>
@@ -4931,7 +4982,33 @@ function drawTtsCacheControls(box){
     }catch(err){ msg.textContent="המחיקה נכשלה: "+err.message; }
     button.disabled=false;
   };
-  row.append(warm,halt,offline,load,loadFile,button,msg); card.append(title,text,usage,progress,progressLabel,row); box.append(card);
+  row.append(warm,halt,offline,load,loadFile,button,msg); card.append(title,text,usage,progress,progressLabel,row,drawTtsActivity(card)); box.append(card);
+}
+// "what is happening now": Sawtak requests and bucket uploads in flight, and the latest results (GET /api/tts-cache/activity)
+function drawTtsActivity(card){
+  const details=document.createElement("details"), summary=mark("","מה קורה עכשיו","summary"), pace=mark("msg","","div"), stats=mark("msg","","div"), active=mark("","","div"), wrap=mark("","","div"), table=document.createElement("table");
+  wrap.style.cssText="overflow-x:auto;max-height:340px;overflow-y:auto"; table.style.cssText="width:100%;border-collapse:collapse;font-size:.85em";
+  details.style.marginTop="12px"; summary.style.cssText="cursor:pointer;font-weight:600"; wrap.append(table); details.append(summary,pace,stats,active,wrap);
+  const SOURCE={sweep:"הכנה",playback:"השמעה",import:"טעינה"}, secs=ms=>ms==null?"–":ms<1000?`${ms} ms`:`${(ms/1000).toFixed(1)} שנ׳`;
+  const result=e=>e.status===200||e.status==="ok"?"✓":e.status===429?"429 · הגבלת קצב":typeof e.status==="number"&&e.status>=500?`${e.status} · תקלה אצל Sawtak`:typeof e.status==="number"?`${e.status} · נדחה`:"שגיאה";
+  const what=e=>e.kind==="upload"?(e.files>1?`${e.files} קבצים · ${(e.bytes/1048576).toFixed(1)} MB`:(e.text||"קובץ אחד")):(e.text||"");
+  const cell=(tr,text,head)=>{ const c=document.createElement(head?"th":"td"); c.textContent=text; c.dir="auto"; c.style.cssText="padding:4px 6px;border-bottom:1px solid #8884;text-align:start;white-space:nowrap"; tr.append(c); return c; };
+  let timer=0;
+  const render=data=>{
+    const p=data.pace; pace.textContent=p?`קצב מותר לשרת הזה: עד ${p.per_minute} בקשות ל־Sawtak בדקה, עד ${p.max_concurrent} במקביל (ההכנה מריצה ${p.sweep_workers}).`:"";
+    const recent=data.events.filter(e=>e.kind==="sawtak"&&data.now-e.at<=300), ok=recent.filter(e=>e.status===200), bad=recent.length-ok.length;
+    const avg=ok.length?ok.reduce((n,e)=>n+e.ms,0)/ok.length:null, waited=ok.length?ok.reduce((n,e)=>n+(e.waited_ms||0),0)/ok.length:null;
+    stats.textContent=`ב־5 הדקות האחרונות: ${recent.length} בקשות ל־Sawtak (${(recent.length/5).toFixed(1)} לדקה)`+(avg!=null?` · משך ממוצע ${secs(Math.round(avg))} · המתנה ממוצעת לתור ${secs(Math.round(waited))}`:"")+(bad?` · ${bad} נכשלו`:"");
+    active.replaceChildren(); for(const a of data.active){ const line=mark("msg","","div"); line.dir="auto"; line.textContent=`⏳ ${a.kind==="upload"?"מעלה לדלי":"שולח ל־Sawtak"} · ${SOURCE[a.source]||a.source||""} · ${what(a)} · ${secs(a.elapsed_ms)}`; active.append(line); }
+    if(!data.active.length) active.append(mark("msg","אין כרגע בקשות פעילות.","div"));
+    table.replaceChildren(); const head=document.createElement("tr"); for(const h of ["שעה","יעד","מקור","מה נשלח","תוצאה","משך","המתנה בתור","אורך השמע"]) cell(head,h,true); table.append(head);
+    for(const e of data.events){ const tr=document.createElement("tr"); cell(tr,new Date(e.at*1000).toLocaleTimeString("he-IL")); cell(tr,e.kind==="upload"?"דלי":"Sawtak"); cell(tr,SOURCE[e.source]||e.source||""); cell(tr,what(e)); const r=cell(tr,result(e)); if(e.message) r.title=e.message; if(r.textContent!=="✓") r.style.color="#c0392b"; cell(tr,secs(e.ms)); cell(tr,e.kind==="sawtak"?secs(e.waited_ms):""); cell(tr,e.audio_s!=null?`${e.audio_s} שנ׳`:""); table.append(tr); }
+    if(!data.events.length){ const tr=document.createElement("tr"); cell(tr,"עוד לא נשלחו בקשות מאז שהשרת עלה.").colSpan=8; table.append(tr); }
+  };
+  const tick=()=>{ clearTimeout(timer); if(!details.open||!card.isConnected) return;
+    api("/api/tts-cache/activity").then(async res=>{const data=await res.json().catch(()=>({})); if(!res.ok) throw new Error(data.detail||res.status); render(data);}).catch(err=>{stats.textContent="נתוני הפעילות לא זמינים: "+err.message;}).finally(()=>{ if(details.open&&card.isConnected) timer=setTimeout(tick,2000); }); };
+  details.ontoggle=tick; details.open=true;   // open by default; closing it stops the refresh
+  return details;
 }
 // how to get each key, step by step: a step is its parts, text or [text, link]
 const KEY_GUIDES={

tests/test_scoring.py

@@ -547,7 +547,7 @@ def test_warm_sweep_uploads_every_cached_wav_to_the_bucket(monkeypatch, tmp_path
     monkeypatch.setattr(app.main, "load_auth", lambda: None)
 
     tts = SawtakTTS("key", cache_dir=tmp_path)
-    monkeypatch.setattr(tts, "_generate", lambda text, voice: b"RIFF" + text.encode())
+    monkeypatch.setattr(tts, "_generate", lambda text, voice, *_: b"RIFF" + text.encode())
     (tmp_path / "legacy.wav").write_bytes(b"old")            # cached before the per-voice layout
     other = tmp_path / "other-voice"; other.mkdir(); (other / "x.wav").write_bytes(b"xx")
 
@@ -557,7 +557,7 @@ def test_warm_sweep_uploads_every_cached_wav_to_the_bucket(monkeypatch, tmp_path
             self.uploads = []
         def remote_sizes(self):
             return {"ihki-tts/other-voice/x.wav": 2}           # already in the bucket: not sent again
-        def upload(self, files):
+        def upload(self, files, source=""):
             self.uploads += [(src if isinstance(src, bytes) else src.read_bytes(), dest) for src, dest in files]
 
     tts.mirror = mirror = FakeMirror()
@@ -2274,7 +2274,7 @@ def test_the_tts_cache_downloads_as_an_offline_zip_with_a_manifest(monkeypatch,
     monkeypatch.setattr(app.main, "PHRASES", phrases)
     monkeypatch.setattr(app.main, "load_auth", lambda: None)
     tts = SawtakTTS("key", cache_dir=tmp_path)
-    monkeypatch.setattr(tts, "_generate", lambda text, voice: b"RIFF-" + text.encode())
+    monkeypatch.setattr(tts, "_generate", lambda text, voice, *_: b"RIFF-" + text.encode())
     tts.wav(app.main.point_arabic(*phrases[0]["variants"][0]))
     (tmp_path / "stray.wav").write_bytes(b"old")  # a file no phrase names is still included
     with TestClient(create_app(scorer_for(emissions(["w"])), tts, tutor=object())) as c:
@@ -2333,11 +2333,11 @@ def test_with_a_bucket_new_recordings_are_staged_locally_not_written_to_the_moun
     mount, staging = tmp_path / "mount", tmp_path / "staging"
     tts = SawtakTTS("key", cache_dir=mount)
     tts.staging_dir = staging
-    monkeypatch.setattr(tts, "_generate", lambda text, voice: b"RIFF-" + text.encode())
+    monkeypatch.setattr(tts, "_generate", lambda text, voice, *_: b"RIFF-" + text.encode())
     uploaded = []
 
     class Mirror(BucketMirror):
-        def upload(self, files): uploaded.extend(dest for _src, dest in files)
+        def upload(self, files, source=""): uploaded.extend(dest for _src, dest in files)
     tts.mirror = Mirror("user/bucket", "ihki-tts")
 
     data, _ = tts.wav("مرحبا")
@@ -2374,7 +2374,7 @@ def test_an_offline_copy_loads_back_into_the_cache_and_the_bucket(monkeypatch, t
     uploaded = []
 
     class Mirror(BucketMirror):
-        def upload(self, files): uploaded.extend(dest for _src, dest in files)
+        def upload(self, files, source=""): uploaded.extend(dest for _src, dest in files)
     tts.mirror = Mirror("user/bucket", "ihki-tts")
     wav = b"RIFF\0\0\0\0WAVEfmt " + b"\0" * 40
     new, old, legacy = f"{RAEF_VOICE_ID}/{'a' * 40}.wav", f"{RAEF_VOICE_ID}/{'b' * 40}.wav", f"{'c' * 40}.wav"
@@ -2432,3 +2432,48 @@ def test_the_sweep_runs_sawtak_requests_in_parallel_within_the_pace(monkeypatch,
     for t in pair: t.start()
     for t in pair: t.join()
     assert calls == ["مرة"]
+
+
+def test_the_activity_log_shows_each_sawtak_request_and_upload(monkeypatch, tmp_path):
+    import io
+    import wave
+
+    from fastapi.testclient import TestClient
+
+    import app.main
+    import app.tts as tts_module
+    from app.main import create_app
+    from app.tts import RAEF_VOICE_ID, BucketMirror, SawtakTTS, TTSUnavailable
+
+    monkeypatch.setattr(app.main, "load_auth", lambda: None)
+    monkeypatch.setattr(tts_module, "MIN_REQUEST_INTERVAL", 0)
+    buf = io.BytesIO()
+    with wave.open(buf, "wb") as w:
+        w.setnchannels(1); w.setsampwidth(2); w.setframerate(24000); w.writeframes(b"\0" * 48000)
+    tts = SawtakTTS("key", cache_dir=tmp_path)
+
+    def fake(text, voice):
+        if text == "خطأ":
+            raise TTSUnavailable("tts provider error 429: slow down", 429)
+        return buf.getvalue()
+    monkeypatch.setattr(tts, "_generate_now", fake)
+
+    class Mirror(BucketMirror):
+        pass
+    import huggingface_hub
+    monkeypatch.setattr(huggingface_hub, "batch_bucket_files", lambda *a, **k: None)
+    tts.mirror = Mirror("user/bucket")
+    tts.wav_for_voice("مرحبا", RAEF_VOICE_ID)
+    try:
+        tts.wav("خطأ")
+    except TTSUnavailable:
+        pass
+    tts.mirror.upload([(b"RIFF", "ihki-tts/x.wav")], source="sweep")
+    with TestClient(create_app(scorer_for(emissions(["w"])), tts, tutor=object())) as c:
+        data = c.get("/api/tts-cache/activity").json()
+    assert data["active"] == [] and data["pace"]["max_concurrent"] == tts_module.MAX_CONCURRENT
+    upload, failed, ok = data["events"]                         # newest first
+    assert upload["kind"] == "upload" and upload["status"] == "ok" and upload["files"] == 1
+    assert failed["status"] == 429 and failed["source"] == "playback" and "slow down" in failed["message"]
+    assert ok["kind"] == "sawtak" and ok["status"] == 200 and ok["source"] == "sweep" and ok["audio_s"] == 1.0
+    assert ok["text"] == "مرحبا" and ok["ms"] >= 0 and ok["waited_ms"] >= 0