feat(ui): in-card determinate progress bar via gr.Timer (Option T)

The native gr.Progress bar does not render in this loading-card layout
(smoke-test: the sink fires every clip but Gradio's status-tracker stays
empty), so drive the card's OWN HTML instead. The encode sink writes per-clip
counters into a module-global state dict; a gr.Timer(0.3) reads it and
re-renders the loading card with a determinate amber bar + live
"clip k/N · window p/P" label.

Live-verified: the Timer ticks in parallel with the concurrency_limit=1 Score
(per-concurrency-id queue) — card showed "Encoding video · clip 4/30" at 13%
advancing per clip; after the Score the card hides, no stuck bar, timeline +
summary render cleanly (Timer -> gr.skip when idle).

- progress.py: rewrite to a dict-based live state (begin/sink/snapshot/end +
encode_frac); the 0.3s Timer is the throttle (no separate per-clip throttle).
- ui.py: loading_card_html renderer + addressable loading_body gr.HTML.
- theme.py: .co-prog-track/fill/pct amber bar styles (drop dead native CSS).
- app.py: gr.Timer + _progress_tick (own concurrency lane, gr.skip when idle,
updates only loading_body value); sink set/clear in finally; gate active
local-only so the Space keeps the coarse stage-progress fallback.
- tests/test_progress.py: dict-state tests (monotonic across windows, pass
detection, active flag, never-raise sink).

tribe-brain-reviewed (Option T over the worker-thread generator: no manual MPS
thread, no generator into the Gradio-6.11 visibility chain). Known cosmetic
wart: with the dedup cache OFF the encode double-extracts, so a 1-window clip
pins the bar at 100% during the 2nd pass; the parity-gated dedup-cache fix
makes it single-pass.

app.py

@@ -112,9 +112,9 @@ from tribescore.inference import (
 )
 from tribescore.metrics import build_roi_masks, summary, to_metrics
 from tribescore.plotting import seek_js, timeline_figure
-from tribescore.progress import make_clip_sink
 from tribescore.windowing import plan_windows, stitch
 from tribescore import fast_encode
+from tribescore import progress as progress_state
 
 logger = logging.getLogger("tribescore.app")
 logging.basicConfig(level=logging.INFO)
@@ -374,6 +374,18 @@ def _reveal_result(ok: bool):
     return gr.update(visible=bool(ok))
 
 
+def _progress_tick():
+    """gr.Timer handler (Option T): while a video encode is active, re-render the
+    loading card with the live per-clip determinate bar; otherwise ``gr.skip()``
+    (no DOM churn when idle / on the Space). Runs in its own concurrency lane, so
+    it ticks in parallel with the limit-1 Score event (which alone runs the GPU
+    encode — the Timer never encodes, so two encodes can't overlap)."""
+    snap = progress_state.snapshot()
+    if not snap.get("active"):
+        return gr.skip()
+    return ui.loading_card_html(snap)
+
+
 def _fail(message: str):
     """Error update tuple (same 7 outputs + trailing ok=False for _reveal_result)."""
     return (
@@ -430,13 +442,18 @@ def _score_impl(mode, src_path, selected_names, audio_only, progress):
                 n_pass = max(1, len(plan_windows(dur))) if dur and dur > 0 else 1
             except Exception:
                 n_pass = 1
-            fast_encode.set_progress_sink(make_clip_sink(progress, n_pass))
+            # Option T: the encode sink writes per-clip counters into the live
+            # state dict; a gr.Timer reads it and re-renders the loading card.
+            progress_state.begin(n_pass)
+            fast_encode.set_progress_sink(progress_state.sink)
             _sink_set = True
+            logger.info("registered per-clip progress sink (n_pass=%d, on_spaces=%s)", n_pass, on_spaces())
         try:
             preds, abs_times, text_media, no_speech = _gpu_infer(mode, src_path, bool(audio_only))
         finally:
             if _sink_set:
                 fast_encode.clear_progress_sink()
+                progress_state.end()
 
         if preds.shape[0] == 0:
             return _fail(
@@ -548,12 +565,24 @@ def build_demo() -> gr.Blocks:
         score_outputs = result_outputs + [ok_state]
         js_seek = seek_js()
 
+        # Live in-card progress bar (Option T): a Timer reads the per-clip encode
+        # state ~3x/s and re-renders the loading card. Its own concurrency lane →
+        # ticks in parallel with the limit-1 Score; idle/Space → gr.skip().
+        prog_timer = gr.Timer(0.3)
+        prog_timer.tick(_progress_tick, inputs=None, outputs=[r["loading_body"]])
+
         # Sample clip → fill the Video component.
         v["sample_btn"].click(fn=lambda: SAMPLE_VIDEO_URL, inputs=None, outputs=[v["video"]])
 
         # --- Video ---
+        # def (not lambda) keeps gr.Progress injected for the Space's coarse stage
+        # bar (the Space fallback). Locally the native bar doesn't render, so the
+        # in-card determinate bar is driven by the gr.Timer below (Option T).
+        def _run_video(vid, metrics, ao, progress=gr.Progress()):
+            return _score_impl("video", vid, metrics, ao, progress)
+
         v["run_btn"].click(_enter_loading, None, loading_outputs).then(
-            lambda vid, metrics, ao, pr=gr.Progress(): _score_impl("video", vid, metrics, ao, pr),
+            _run_video,
             inputs=[v["video"], v["metrics"], v["audio_only"]],
             outputs=score_outputs,
         ).then(_reveal_result, inputs=[ok_state], outputs=[r["result_grp"]]).then(fn=None, js=js_seek)

docs/superpowers/specs/2026-06-24-progress-bar-design.md

@@ -1,6 +1,61 @@
 # Design: real per-clip progress bar (replace the indeterminate "Scoring…" loader)
 
-**Branch:** `feat/local-mps-quality-video`  ·  **Status:** DECIDED → implemented; pending live smoke-test.
+**Branch:** `feat/local-mps-quality-video`  ·  **Status:** ✅ RESOLVED — Option T (gr.Timer-driven in-card bar) implemented + live-verified.
+
+## ✅ FINAL: Option T (gr.Timer) — implemented + verified (2026-06-24)
+
+Native bar (X) was dead (see below); tribe-brain ruled **Option T** over the worker-thread generator (Y).
+Implemented + live-smoke-tested on the 15 s clip:
+- Encode sink writes per-clip counters into `tribescore.progress._STATE`; a `gr.Timer(0.3)` reads it and
+  re-renders the `loading_body` card HTML (`ui.loading_card_html`).
+- **Timer ticks in parallel with the `concurrency_limit=1` Score** (per-concurrency-id queue) — VERIFIED:
+  card showed `Encoding video · clip 4/30 · window 1/1` at 13%, advancing per clip; bar amber, determinate.
+- After the Score: card hidden, no stuck bar, timeline + summary render cleanly (Timer → `gr.skip()` when idle).
+- Must-fixes applied: own concurrency lane, local-only `active` gate, `gr.skip()` when idle, Timer updates
+  only `loading_body` value (never container visibility → `.then(_reveal_result)`/6.11 workaround untouched),
+  no manual thread, sink reused (throttle is the 0.3 s Timer).
+- **Known cosmetic wart:** with the cache OFF the encode double-extracts, so on a 1-window clip the bar fills
+  0→100% then sits at 100% during the 2nd pass. On ≥2-window clips the 2 extract-passes map onto `n_pass`;
+  the parity-gated dedup-cache fix makes it single-pass regardless. Not blocking.
+
+---
+
+
+## ⚠️ SMOKE-TEST RESULT (2026-06-24): native `gr.Progress` does NOT render here
+
+Live smoke-test (15 s clip, restarted app) — **Option X cannot show a visible bar in this app**:
+- Sink CONFIRMED firing: logs show `registered per-clip progress sink (n_pass=1, on_spaces=False)` and
+  `PROGRESS_SINK fired (clip 1/30)` → `progress(frac, desc)` IS being called every clip.
+- Yet the DOM has **zero** `.progress-bar`/`.progress-level` elements, **zero** "Encoding video · clip k/N"
+  text, and Gradio's `[data-testid="status-tracker"]` stays `class="...hide"` with **empty** innerHTML.
+- Salvage attempt FAILED: converting the handler lambda→`def _run_video(..., progress=gr.Progress())`
+  **and** adding explicit `show_progress="full"` did NOT make the determinate bar render. The custom
+  indeterminate `co-loading-bar` (which Option X removed) was the only thing ever visible.
+
+**Conclusion:** the native determinate bar doesn't render in this loading-card layout regardless of
+lambda/def or show_progress. To get a VISIBLE determinate bar we must drive the **card's own HTML**.
+
+## Architecture fork for the card-driven bar (for tribe-brain)
+
+The encode (`_gpu_infer`) is a single BLOCKING call; the per-clip signal comes from deep inside it (the
+sink). Two ways to push that into the visible card HTML:
+
+- **(Y) generator + worker thread:** `_score_impl` becomes a generator; run `_gpu_infer` in a
+  `threading.Thread`; poll the sink's shared counter; `yield` updated loading-card HTML every ~0.3 s.
+  Risk tribe-brain previously flagged: threading×MPS, and a generator feeding the existing
+  `.then(_reveal_result)` 6.11 visibility-drop chain.
+- **(T) gr.Timer poll:** the sink writes a module-global `{active,done,total,pass,n_pass}`; a
+  `gr.Timer(~0.3s)` handler reads it and returns updated loading-card HTML. No manual thread. BUT
+  `run_local.py` sets `.queue(default_concurrency_limit=1)` → the Timer event can't run while the Score
+  event holds the only worker UNLESS the Timer gets its own concurrency lane; need to confirm a
+  lightweight Timer event can run concurrently with the limit-1 Score without letting two Scores overlap
+  (GPU-memory invariant: never two encodes at once).
+
+Both are pure-app changes (no model/data change). Decision + must-fixes needed to one-shot it.
+
+---
+
+**(superseded) Prior status:** DECIDED → implemented Option X; the live smoke-test then disproved X.
 
 ## DECISION (tribe-brain-reviewed, operator-confirmed)
 

src/tribescore/progress.py

@@ -1,73 +1,62 @@
-"""Pure helpers for the determinate per-clip encode progress bar (Option X).
-
-The Gradio app (``app.py``) builds a per-clip *sink* here and registers it on
-:mod:`tribescore.fast_encode`; the V-JEPA2 encode loop then calls it once per
-clip with ``(done, total)``. The sink maps that into the overall progress bar
-and drives the native ``gr.Progress`` widget.
-
-These helpers are pure (the ``progress`` callback and the clock are injected),
-so they unit-test without importing the heavy Gradio app. Design + rationale:
+"""Live per-clip progress state for the determinate in-card bar (Option T).
+
+The native ``gr.Progress`` bar does NOT render in this app's loading-card layout
+(smoke-test confirmed: the sink fires but Gradio's status-tracker stays empty).
+So we drive the card's OWN HTML instead: the V-JEPA2 encode sink writes the
+per-clip counters into a module-global dict here, and a ``gr.Timer`` in app.py
+reads it ~3x/s and re-renders the loading card. tribe-brain-reviewed (Option T
+over the worker-thread generator: no manual MPS thread, no generator into the
+Gradio-6.11 visibility chain). Design doc:
 ``docs/superpowers/specs/2026-06-24-progress-bar-design.md``.
 
-LOCAL-ONLY: the sink is registered only on the in-process (Apple-silicon MPS)
-path. On the HF Space ``_gpu_infer`` runs in a forked ``@spaces.GPU`` subprocess
-that cannot see a parent-set sink, so the coarse stage progress is the Space
-fallback there (and :func:`fast_encode._emit_progress` no-ops when unset).
+LOCAL-ONLY: ``begin()`` is called only off-Space, so on the HF Space ``active``
+stays False, the Timer reads inactive → ``gr.skip()``, and the coarse stage
+``progress()`` calls remain the Space fallback. Plain int writes are GIL-atomic,
+so no lock is needed for the single-writer (encode) / single-reader (Timer) case.
 """
 from __future__ import annotations
 
-import time as _time
+#: Live state. ``active`` gates the Timer; ``done/total`` are clips within the
+#: current window; ``pass_idx`` is the 0-based window; ``n_pass`` the window
+#: count from ``plan_windows()``; ``_last`` tracks the per-window counter restart.
+_STATE = {"active": False, "done": 0, "total": 0, "pass_idx": 0, "n_pass": 1, "_last": 0}
 
-# The V-JEPA2 encode occupies the 0.15->0.70 slice of the overall progress bar;
-# the stitch/metrics/render stages keep their existing 0.75/0.92/1.0 marks.
-ENCODE_LO: float = 0.15
-ENCODE_HI: float = 0.70
 
+def begin(n_pass: int) -> None:
+    """Mark a video encode as starting and reset counters (call before _gpu_infer)."""
+    _STATE.update(active=True, done=0, total=0, pass_idx=0, n_pass=max(1, int(n_pass)), _last=0)
 
-def encode_frac(pass_idx: int, done: int, total: int, n_pass: int) -> float:
-    """Monotonic map of (window pass, within-window clip) into the encode band.
 
-    With the dedup output-cache OFF, tribev2 re-runs the encode loop once per
-    window, so the bar advances across ``n_pass`` windows without resetting:
-    ``frac = LO + (HI-LO) * (pass_idx + done/total) / n_pass``.
+def end() -> None:
+    """Mark the encode finished (call in a ``finally``)."""
+    _STATE["active"] = False
 
-    ``pass_idx`` is the 0-based window index; ``done``/``total`` are clips within
-    the current window; ``n_pass`` is the window count from ``plan_windows()``.
-    Clamped to ``[ENCODE_LO, ENCODE_HI]`` so an under-/over-estimated ``n_pass``
-    can never overshoot into the stitch band. Degrades cleanly to a single
-    0->100% sweep when ``n_pass == 1`` (e.g. once the output cache lands).
-    """
-    n_pass = max(1, n_pass)
-    within = (done / total) if total else 0.0
-    frac = ENCODE_LO + (ENCODE_HI - ENCODE_LO) * ((pass_idx + within) / n_pass)
-    return min(ENCODE_HI, max(ENCODE_LO, frac))
 
+def sink(done: int, total: int) -> None:
+    """Per-clip sink registered on ``fast_encode``. Detects a new window pass by
+    the per-window counter restart (``done`` returning to <= the last seen), so
+    the bar advances monotonically across windows with no reset. No throttle here
+    — the 0.3 s Timer is the throttle (it just samples whatever the last write was)."""
+    if done <= _STATE["_last"]:
+        _STATE["pass_idx"] += 1
+    _STATE["_last"] = int(done)
+    _STATE["done"] = int(done)
+    _STATE["total"] = int(total)
 
-def make_clip_sink(progress, n_pass: int, *, clock=None, min_interval: float = 0.4):
-    """Build a per-clip ``sink(done, total)`` for ``fast_encode.set_progress_sink``.
 
-    Tracks window passes by the per-window counter restart (``done`` returning to
-    a value <= the last seen), maps monotonically via :func:`encode_frac`, and
-    throttles UI updates to ``min_interval`` seconds — except the final clip of a
-    window (``done == total``), which always emits. ``progress`` is the
-    ``gr.Progress`` callable; ``clock`` is injectable for tests.
-    """
-    clock = clock or _time.monotonic
-    st = {"pass": 0, "last": 0, "t": -1e9}
+def snapshot() -> dict:
+    """Return a shallow copy of the live state (for the Timer handler)."""
+    return dict(_STATE)
+
 
-    def _sink(done: int, total: int) -> None:
-        # New extraction pass (next window) when the per-window counter restarts.
-        if done <= st["last"]:
-            st["pass"] += 1
-        st["last"] = done
-        now = clock()
-        if now - st["t"] < min_interval and done != total:
-            return  # throttle the UI update only; pass tracking already advanced
-        st["t"] = now
-        window = min(st["pass"] + 1, max(1, n_pass))
-        progress(
-            encode_frac(st["pass"], done, total, n_pass),
-            desc=f"Encoding video · clip {done}/{total} · window {window}/{max(1, n_pass)}",
-        )
+def encode_frac(snap: dict | None = None) -> float:
+    """0..1 fraction of the whole multi-window encode from a snapshot.
 
-    return _sink
+    ``frac = (pass_idx + done/total) / n_pass`` — monotonic across windows,
+    clamped to [0, 1]. Degrades to a single 0→1 sweep when ``n_pass == 1``.
+    """
+    s = snap if snap is not None else _STATE
+    n = max(1, int(s.get("n_pass", 1) or 1))
+    total = int(s.get("total", 0) or 0)
+    within = (int(s.get("done", 0) or 0) / total) if total else 0.0
+    return min(1.0, max(0.0, (int(s.get("pass_idx", 0) or 0) + within) / n))

tests/test_progress.py

@@ -1,98 +1,72 @@
-"""Unit tests for the determinate per-clip encode progress bar (Option X).
+"""Unit tests for the in-card determinate progress bar state (Option T).
 
 Covers tribe-brain's must-fixes: monotonic full-band mapping across P windows
-(no reset), throttle (final clip always emits), and the never-raise sink guard.
+(no reset, via the per-window counter-restart detection), the active flag, and
+the never-raise fast_encode sink plumbing.
 """
 import pytest
 
-from tribescore.progress import ENCODE_HI, ENCODE_LO, encode_frac, make_clip_sink
+from tribescore import progress as P
 
 
-def _raise(*_a):
-    raise RuntimeError("boom")
-
-
-def _recorder():
-    calls = []
-
-    def progress(frac, desc=None):
-        calls.append((frac, desc))
-
-    return calls, progress
-
-
-# --- encode_frac ------------------------------------------------------------
 def test_encode_frac_endpoints_and_bounds():
-    assert encode_frac(0, 0, 100, 2) == pytest.approx(ENCODE_LO)      # first clip
-    assert encode_frac(1, 100, 100, 2) == pytest.approx(ENCODE_HI)    # last clip, last window
-    for p in range(4):
-        for d in (0, 1, 50, 100, 250):
-            assert ENCODE_LO <= encode_frac(p, d, 100, 2) <= ENCODE_HI
-
-
-def test_encode_frac_monotonic_across_windows():
-    P = 3
-    seq = [encode_frac(p, d, 100, P) for p in range(P) for d in range(0, 101, 10)]
-    assert seq == sorted(seq)  # non-decreasing across every window seam
-
-
-def test_encode_frac_degrades_to_single_sweep():
-    assert encode_frac(0, 0, 50, 1) == pytest.approx(ENCODE_LO)
-    assert encode_frac(0, 50, 50, 1) == pytest.approx(ENCODE_HI)
-
-
-# --- make_clip_sink ---------------------------------------------------------
-def test_sink_single_window_labels_and_monotonic():
-    calls, progress = _recorder()
-    ticks = iter(range(1000))
-    sink = make_clip_sink(progress, n_pass=1, clock=lambda: next(ticks))
-    for d in range(1, 6):
-        sink(d, 5)
-    fracs = [c[0] for c in calls]
-    assert fracs == sorted(fracs)
-    assert fracs[-1] == pytest.approx(ENCODE_HI)
-    assert "window 1/1" in calls[-1][1] and "clip 5/5" in calls[-1][1]
-
-
-def test_sink_detects_second_window_and_stays_monotonic():
-    calls, progress = _recorder()
-    ticks = iter(range(1000))
-    sink = make_clip_sink(progress, n_pass=2, clock=lambda: next(ticks))
-    for d in range(1, 4):       # window 1
-        sink(d, 3)
-    for d in range(1, 4):       # window 2 — counter restarts
-        sink(d, 3)
-    labels = [c[1] for c in calls]
-    assert any("window 1/2" in s for s in labels)
-    assert any("window 2/2" in s for s in labels)
-    fracs = [c[0] for c in calls]
-    assert fracs == sorted(fracs)               # no reset at the seam
-    assert fracs[-1] == pytest.approx(ENCODE_HI)
-
-
-def test_sink_throttles_but_always_emits_final():
-    calls, progress = _recorder()
-    sink = make_clip_sink(progress, n_pass=1, clock=lambda: 0.0, min_interval=0.4)
-    sink(1, 5)   # first emit always (t seeded far in the past)
-    sink(2, 5)   # throttled (Δ=0 < 0.4, not final)
-    sink(3, 5)   # throttled
-    sink(5, 5)   # final clip of the window -> always emits
-    assert len(calls) == 2
-    assert "clip 1/5" in calls[0][1] and "clip 5/5" in calls[1][1]
-
-
-# --- fast_encode sink plumbing ---------------------------------------------
-def test_fast_encode_sink_set_emit_clear_and_never_raises():
+    P.begin(2)
+    assert P.encode_frac() == pytest.approx(0.0)        # nothing encoded yet
+    P.sink(1, 10)                                        # window 1, clip 1/10
+    assert 0.0 < P.encode_frac() < 0.5
+    P.sink(10, 10)                                       # window 1 complete
+    assert P.encode_frac() == pytest.approx(0.5)         # 1 of 2 windows
+    P.sink(1, 10)                                        # window 2 starts (restart)
+    P.sink(10, 10)                                       # window 2 complete
+    assert P.encode_frac() == pytest.approx(1.0)
+
+
+def test_sink_detects_window_pass_and_stays_monotonic():
+    P.begin(2)
+    fracs = []
+    for d in range(1, 6):        # window 1 of 2
+        P.sink(d, 5)
+        fracs.append(P.encode_frac())
+    assert P.snapshot()["pass_idx"] == 0
+    for d in range(1, 6):        # window 2 — counter restarts
+        P.sink(d, 5)
+        fracs.append(P.encode_frac())
+    assert P.snapshot()["pass_idx"] == 1
+    assert fracs == sorted(fracs)                        # no reset at the seam
+    assert fracs[-1] == pytest.approx(1.0)
+
+
+def test_single_window_degrades_cleanly():
+    P.begin(1)
+    P.sink(1, 4)
+    assert P.encode_frac() == pytest.approx(0.25)
+    P.sink(4, 4)
+    assert P.encode_frac() == pytest.approx(1.0)
+
+
+def test_begin_end_active_flag_and_snapshot_is_copy():
+    P.begin(3)
+    snap = P.snapshot()
+    assert snap["active"] is True and snap["n_pass"] == 3
+    snap["done"] = 999                                   # snapshot is a copy
+    assert P.snapshot()["done"] == 0
+    P.end()
+    assert P.snapshot()["active"] is False
+
+
+def test_fast_encode_sink_plumbing_never_raises():
     from tribescore import fast_encode
 
     seen = []
     fast_encode.set_progress_sink(lambda d, t: seen.append((d, t)))
-    fast_encode._emit_progress(3, 10)
-    assert seen == [(3, 10)]
+    fast_encode._emit_progress(2, 9)
+    assert seen == [(2, 9)]
 
-    fast_encode.set_progress_sink(_raise)        # a raising sink must be swallowed
-    fast_encode._emit_progress(1, 1)             # must NOT raise
+    def _boom(*_a):
+        raise RuntimeError("x")
 
+    fast_encode.set_progress_sink(_boom)
+    fast_encode._emit_progress(1, 1)                     # must NOT raise
     fast_encode.clear_progress_sink()
-    fast_encode._emit_progress(9, 9)             # cleared -> no-op
-    assert seen == [(3, 10)]
+    fast_encode._emit_progress(5, 5)                     # cleared -> no-op
+    assert seen == [(2, 9)]

theme.py

@@ -385,28 +385,30 @@ CSS: str = """
 }
 .co-state.co-state-error .co-state-title { color: var(--co-error); }
 
-/* Loading: theme Gradio's native gr.Progress widget to the amber accent so the
-   real per-clip determinate bar (app.py per-clip sink) matches the card. The
-   old indeterminate .co-loading-bar scan-line is gone — the native bar is the
-   single source of truth. Class names span Gradio's progress markup defensively
-   (the determinate fill + the "clip k/N · window p/P" label). */
-.progress-bar,
-.progress-level .progress-level-inner,
-.progress-level-inner,
-.meta-text + .progress-bar {
-    background: var(--co-amber) !important;
-    color: var(--co-accent-text, #0E1116) !important;
-}
-.progress-text,
-.meta-text,
-.meta-text-center {
-    color: var(--co-amber) !important;
-    font-family: var(--co-mono, ui-monospace, monospace) !important;
-    letter-spacing: 0.01em;
-}
-.progress-level {
-    background: var(--co-border) !important;
-    border-radius: 3px;
+/* Loading: a DETERMINATE in-card progress bar (Option T). Gradio's native
+   gr.Progress bar does not render in this loading-card layout (smoke-test
+   confirmed), so a gr.Timer re-renders the card HTML with this amber fill bar
+   driven by the live per-clip encode state. */
+.co-prog-track {
+    height: 6px;
+    border-radius: 4px;
+    background: var(--co-border);
+    margin: 16px auto 8px;
+    max-width: 460px;
+    overflow: hidden;
+}
+.co-prog-fill {
+    height: 100%;
+    border-radius: 4px;
+    background: linear-gradient(90deg, var(--co-amber), #FFD9A0);
+    box-shadow: 0 0 10px rgba(255,180,84,0.5);
+    transition: width 0.3s linear;
+}
+.co-prog-pct {
+    font-family: var(--co-mono, ui-monospace, monospace);
+    font-size: 12.5px;
+    color: var(--co-amber);
+    letter-spacing: 0.02em;
 }
 
 /* ---- Proxy / honesty caveat (the value-region disclaimer, §5) ----------- */

ui.py

@@ -235,19 +235,11 @@ def build_results() -> dict[str, gr.components.Component]:
         empty = gr.HTML(_EMPTY_HTML, visible=True)
 
         # --- Loading ------------------------------------------------------
+        # A gr.Timer (app.py) re-renders this card ~3x/s with the live per-clip
+        # bar during a video encode (Option T — the native gr.Progress bar does
+        # not render in this layout). ``loading_body`` is the addressable target.
         with gr.Column(visible=False) as loading:
-            gr.HTML(
-                """
-                <div class="co-state">
-                  <div class="co-state-icon">&#128300;</div>
-                  <div class="co-state-title">Scoring&hellip;</div>
-                  <div class="co-state-body" id="co-progress">
-                    Extracting features and predicting cortical activity. This
-                    runs window-by-window over the clip — progress below.
-                  </div>
-                </div>
-                """.strip()
-            )
+            loading_body = gr.HTML(loading_card_html())
 
         # --- Error --------------------------------------------------------
         # app.py sets the inner text via this component's value on failure.
@@ -270,6 +262,7 @@ def build_results() -> dict[str, gr.components.Component]:
     return dict(
         empty=empty,
         loading=loading,
+        loading_body=loading_body,
         error=error,
         result_grp=result_grp,
         media_html=media_html,
@@ -283,6 +276,36 @@ def build_results() -> dict[str, gr.components.Component]:
 # Small HTML helpers app.py can call to render the dynamic states. Pure
 # string builders (no Gradio state) so they stay unit-checkable.
 # ---------------------------------------------------------------------------
+def loading_card_html(snap: dict | None = None) -> str:
+    """Render the 'Scoring…' card with a determinate in-card progress bar from a
+    live progress snapshot (``tribescore.progress.snapshot()``). Pure string
+    builder. The native ``gr.Progress`` bar does NOT render in this layout, so a
+    ``gr.Timer`` (app.py) drives this HTML directly every ~0.3 s (Option T)."""
+    snap = snap or {}
+    n = max(1, int(snap.get("n_pass", 1) or 1))
+    total = int(snap.get("total", 0) or 0)
+    done = int(snap.get("done", 0) or 0)
+    pass_idx = int(snap.get("pass_idx", 0) or 0)
+    within = (done / total) if total else 0.0
+    frac = min(1.0, max(0.0, (pass_idx + within) / n))
+    pct = int(round(frac * 100))
+    window = min(pass_idx + 1, n)
+    if total:
+        label = f"Encoding video &middot; clip {done}/{total} &middot; window {window}/{n}"
+    else:
+        label = "Extracting features and predicting cortical activity&hellip;"
+    return (
+        '<div class="co-state">'
+        '<div class="co-state-icon">&#128300;</div>'
+        '<div class="co-state-title">Scoring&hellip;</div>'
+        f'<div class="co-state-body" id="co-progress">{label}</div>'
+        '<div class="co-prog-track">'
+        f'<div class="co-prog-fill" style="width:{pct}%"></div></div>'
+        f'<div class="co-prog-pct">{pct}%</div>'
+        '</div>'
+    )
+
+
 def error_html(message: str) -> str:
     """Wrap an actionable, plain-voice message in the error-panel markup."""
     return (