fix(ui): browser-playable overlay video (H.264) + light all dropdown option lists

formscout/agents/report.py

@@ -10,9 +10,7 @@ Gated: no.
 """
 from __future__ import annotations
 
-from formscout.types import (
-    MovementResult, BiomechFeatures, ScoreResult, JudgeResult, ReportResult,
-)
+from formscout.types import ReportResult
 from formscout import config
 
 # Bilateral tests that need L/R scoring
@@ -50,7 +48,10 @@ class ReportAgent:
             else:
                 unilateral.append(entry)
 
-        # Process bilateral tests — take the lower score, emit asymmetry
+        # Process bilateral tests — report the lower side and emit an asymmetry
+        # when both sides exist; otherwise fall back to whatever was scored (e.g.
+        # a single clip submitted with side="na", the UI default) so the test
+        # still counts toward the composite instead of being dropped as unscored.
         for test_name, entries in bilateral_groups.items():
             scores = []
             for entry in entries:
@@ -59,33 +60,34 @@ class ReportAgent:
                 score = judge.score if judge.score is not None else None
                 scores.append({"side": side, "score": score, "entry": entry})
 
-            # Find best entry per side
             left = next((s for s in scores if s["side"] == "left"), None)
             right = next((s for s in scores if s["side"] == "right"), None)
-
             left_score = left["score"] if left else None
             right_score = right["score"] if right else None
 
-            # Report lower
             if left_score is not None and right_score is not None:
+                # Both sides present — report the lower and record the asymmetry.
                 final_score = min(left_score, right_score)
-                delta = abs(left_score - right_score)
                 asymmetries.append({
                     "test": test_name,
                     "left_score": left_score,
                     "right_score": right_score,
-                    "delta": delta,
+                    "delta": abs(left_score - right_score),
                 })
+                primary = left["entry"] if left_score <= right_score else right["entry"]
             elif left_score is not None:
-                final_score = left_score
+                final_score, primary = left_score, left["entry"]
             elif right_score is not None:
-                final_score = right_score
+                final_score, primary = right_score, right["entry"]
             else:
-                final_score = None
-
-            # Use the entry with the lower score for details
-            primary = (left["entry"] if left and (right is None or (left_score or 4) <= (right_score or 4))
-                      else right["entry"] if right else entries[0])
+                # No explicit L/R side: use the lowest available score across the
+                # group (covers side="na" and needs_human/unscored entries).
+                scored = [s for s in scores if s["score"] is not None]
+                if scored:
+                    best = min(scored, key=lambda s: s["score"])
+                    final_score, primary = best["score"], best["entry"]
+                else:
+                    final_score, primary = None, entries[0]
 
             per_test.append({
                 "test_name": test_name,

scripts/hackathon_upload.sh

@@ -0,0 +1,84 @@
+#!/usr/bin/env bash
+# Upload the FormScout source tree to the Build Small Hackathon Space, as a PR.
+#
+# Usage:
+#   ./scripts/hackathon_upload.sh                    # message from last git commit
+#   ./scripts/hackathon_upload.sh "feat: my change"  # custom message
+#
+# Pushes (PR) to:
+#   spaces/build-small-hackathon/small-functional-movement-screening
+#
+# The Space already exists, so this script only uploads — it does not create the
+# repo. Like hf_upload.sh, `hf upload` ignores .hfignore, so we parse it into
+# --exclude globs ourselves. Above LARGE_THRESHOLD files it falls back to
+# `hf upload-large-folder` (resumable, but commits to main directly — no PR).
+set -euo pipefail
+
+cd "$(dirname "$0")/.."
+
+HACKATHON_OWNER="${FORMSCOUT_HF_HACKATHON_OWNER:-build-small-hackathon}"
+REPO_NAME="small-functional-movement-screening"
+SPACE_REPO="spaces/$HACKATHON_OWNER/$REPO_NAME"
+MSG="${1:-$(git log -1 --pretty=%s)}"
+LARGE_THRESHOLD="${FORMSCOUT_HF_LARGE_THRESHOLD:-500}"
+
+# Belt-and-suspenders extras on top of .hfignore. `.cache/` is the resume
+# state upload-large-folder writes into the folder being uploaded.
+PATTERNS=(
+    "*.pdf"
+    "**/node_modules/**"
+    ".cache/**"
+)
+
+# Parse .hfignore into fnmatch-style globs. fnmatch's `*` crosses `/`, but a
+# bare name like `.DS_Store` or `dir/` only matches at the root, so emit both
+# the rooted and `**/`-prefixed forms.
+while IFS= read -r line; do
+    line="${line%%#*}"
+    line="${line#"${line%%[![:space:]]*}"}"
+    line="${line%"${line##*[![:space:]]}"}"
+    [[ -z "$line" ]] && continue
+    if [[ "$line" == */ ]]; then
+        PATTERNS+=("${line}**" "**/${line}**")
+    else
+        PATTERNS+=("$line" "**/$line")
+    fi
+done < .hfignore
+
+EXCLUDES=()
+for p in "${PATTERNS[@]}"; do
+    EXCLUDES+=(--exclude="$p")
+done
+
+# Count what would actually be uploaded, using the same filter the hub client
+# applies, so the mode decision matches reality.
+N_FILES=$(python3 - "${PATTERNS[@]}" <<'EOF'
+import sys
+from pathlib import Path
+from huggingface_hub.utils import filter_repo_objects
+
+patterns = sys.argv[1:]
+files = (
+    str(p) for p in Path(".").rglob("*")
+    if p.is_file() and p.parts[0] != ".git"
+)
+print(len(list(filter_repo_objects(files, ignore_patterns=patterns))))
+EOF
+)
+echo "── $N_FILES files to upload after .hfignore filtering"
+
+if (( N_FILES == 0 )); then
+    echo "✗ nothing to upload — check .hfignore" >&2
+    exit 1
+fi
+
+if (( N_FILES > LARGE_THRESHOLD )); then
+    echo "── $SPACE_REPO: $N_FILES files > $LARGE_THRESHOLD, using upload-large-folder"
+    echo "   (resumable; commits directly to main — no PR, no custom message)"
+    hf upload-large-folder "$SPACE_REPO" . "${EXCLUDES[@]}"
+else
+    echo "── uploading (PR) to: $SPACE_REPO"
+    hf upload "$SPACE_REPO" . . "${EXCLUDES[@]}" --create-pr --commit-message="$MSG"
+fi
+
+echo "✓ done — PR opened on $SPACE_REPO (review & merge in the HF UI)"

tests/test_phase2.py

@@ -338,6 +338,26 @@ class TestReportAgent:
         assert len(result.asymmetries) == 1
         assert result.asymmetries[0]["delta"] == 1
 
+    def test_bilateral_na_side_is_scored(self):
+        """A bilateral test run once with side='na' (the UI default) must still
+        count toward the composite, not be dropped as unscored."""
+        agent = ReportAgent()
+        entries = [{
+            "movement": MovementResult(test_name="hurdle_step", side="na", confidence=1.0),
+            "features": _make_features("hurdle_step", side="na"),
+            "rubric_score": ScoreResult(score=2, rationale="", confidence=0.9),
+            "judge": JudgeResult(
+                score=2, rationale="", compensation_tags=[], corrective_hint="",
+                confidence=0.9,
+            ),
+            "side": "na",
+        }]
+        result = agent.run(entries)
+        assert len(result.per_test) == 1
+        assert result.per_test[0]["score"] == 2
+        assert result.composite == 2
+        assert result.asymmetries == []  # no L/R pair → no asymmetry
+
     def test_composite_none_when_unscored(self):
         agent = ReportAgent()
         entries = [{