Sync demo recommendation hardening

.gitignore

@@ -35,6 +35,7 @@ data/*.duckdb.tmp
 
 outputs/
 runs/
+submission_evidence/
 *.log
 
 .DS_Store

PLAN.md

@@ -111,6 +111,7 @@ All times are `America/Los_Angeles` / PDT unless noted.
 - 2026-06-14 01:13: updated this plan with the execution timeline. Current required finish checks are lint, tests, Gradio import smoke, commit/push, Space upload, Space HTTP 200, Modal UI HTTP 200, `modal-smoke`, and `modal-ask`.
 - 2026-06-14 01:21: checked the latest hackathon requirements again and added `SUBMISSION.md` with required links, final checklist, demo video script, social post draft, and verification commands.
 - 2026-06-14 01:27: addressed the submission-readiness review by adding hero-name parsing, making Draft Lab demoable, adding tests, preparing a dataset card, declaring Apache-2.0 licensing, and aligning the Modal dependency version.
+- 2026-06-14 02:36: continued demo-readiness hardening by adding role-aware recommendation filtering, Bayesian win-rate shrinkage for low samples, pre-game item timing labels, and a repeatable public Space API check script.
 
 ## Adapter Eval Notes
 

SUBMISSION.md

@@ -79,6 +79,7 @@ uv run pytest -q
 uv run python -c "from app import demo; print(type(demo).__name__, len(demo.blocks), len(demo.fns))"
 uv run dota2tuned modal-smoke
 uv run dota2tuned modal-ask "Suggest one mid hero against Phantom Assassin and Witch Doctor. Include one caveat." --context "Use only grounded advice. Mention that sample sizes and patch context matter." --max-new-tokens 160
+uv run python scripts/check_public_space.py
 curl -L -sS -o /dev/null -w '%{http_code}\n' https://build-small-hackathon-dota2tuned.hf.space
 curl -sS -o /dev/null -w '%{http_code}\n' https://dracufeuer--dota2tuned-ui.modal.run
 git status --short --branch

scripts/check_public_space.py

@@ -0,0 +1,80 @@
+from __future__ import annotations
+
+import argparse
+import json
+from datetime import UTC, datetime
+from pathlib import Path
+from typing import Any
+
+from gradio_client import Client
+
+DEFAULT_SPACE = "https://build-small-hackathon-dota2tuned.hf.space"
+
+
+CHECKS: list[tuple[str, tuple[Any, ...]]] = [
+    ("/draft_coach", ("", "Phantom Assassin, Witch Doctor", "", "mid", "pro")),
+    ("/hero_meta", ("current pro meta",)),
+    (
+        "/match_predictor",
+        ("Anti-Mage, Axe, Bane, Lina, Crystal Maiden", "Pudge, Invoker, Drow Ranger, Lion, Sven"),
+    ),
+    ("/hero_builds", ("Anti-Mage",)),
+    ("/draft_lab", ("Phantom Assassin, Witch Doctor", "mid", "Tiny scout card")),
+    ("/data_status", ()),
+    (
+        "/tuned_model",
+        (
+            "Suggest one mid hero against Phantom Assassin and Witch Doctor, "
+            "and include one caveat.",
+            "",
+            160,
+        ),
+    ),
+]
+
+
+def run_checks(space_url: str) -> dict[str, Any]:
+    client = Client(space_url)
+    results = []
+    for endpoint, args in CHECKS:
+        try:
+            result = client.predict(*args, api_name=endpoint)
+            status = "ok"
+        except Exception as exc:  # pragma: no cover - network smoke script
+            result = repr(exc)
+            status = "error"
+        results.append(
+            {
+                "endpoint": endpoint,
+                "status": status,
+                "args": args,
+                "result": result,
+            }
+        )
+        print(f"{endpoint}: {status}")
+    return {
+        "generated_at": datetime.now(UTC).isoformat(),
+        "space": space_url,
+        "checks": results,
+    }
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description="Run public DOTA2Tuned Space API checks.")
+    parser.add_argument("--space", default=DEFAULT_SPACE)
+    parser.add_argument(
+        "--output",
+        default="submission_evidence/public_space_api_checks.json",
+        help="Path for JSON evidence output.",
+    )
+    args = parser.parse_args()
+
+    payload = run_checks(args.space)
+    output_path = Path(args.output)
+    output_path.parent.mkdir(parents=True, exist_ok=True)
+    output_path.write_text(json.dumps(payload, indent=2), encoding="utf-8")
+    print(output_path)
+
+
+if __name__ == "__main__":
+    main()

src/dota2tuned/recommend.py

@@ -7,6 +7,14 @@ import polars as pl
 from dota2tuned.schemas import DraftInput, Recommendation
 from dota2tuned.storage import read_parquet
 
+_ROLE_HINTS = {
+    "carry": {"Carry"},
+    "mid": {"Carry", "Escape", "Initiator"},
+    "offlane": {"Initiator", "Durable", "Disabler"},
+    "soft support": {"Support"},
+    "hard support": {"Support"},
+}
+
 
 def _confidence(sample_size: int) -> str:
     if sample_size >= 500:
@@ -16,6 +24,33 @@ def _confidence(sample_size: int) -> str:
     return "low"
 
 
+def _role_tokens(value: object) -> set[str]:
+    if not value:
+        return set()
+    return {part.strip() for part in str(value).split(",") if part.strip()}
+
+
+def _role_match(role: str | None, roles: object) -> bool:
+    if not role:
+        return True
+    tokens = _role_tokens(roles)
+    if not tokens:
+        return True
+    role_key = role.lower()
+    hints = _ROLE_HINTS.get(role_key)
+    if not hints:
+        return True
+    if role_key == "mid" and "Support" in tokens and "Carry" not in tokens:
+        return False
+    return bool(tokens & hints)
+
+
+def _shrunk_win_rate(pro_win: int, pro_pick: int, *, prior_games: int = 50) -> float:
+    if pro_pick <= 0:
+        return 0.5
+    return (pro_win + (prior_games * 0.5)) / (pro_pick + prior_games)
+
+
 class DraftRecommender:
     def __init__(self, parquet_dir: Path) -> None:
         self.parquet_dir = parquet_dir
@@ -36,10 +71,12 @@ class DraftRecommender:
 
         rows = []
         for row in candidates.iter_rows(named=True):
+            if not _role_match(draft.role, row.get("roles")):
+                continue
             hero_id = int(row["hero_id"])
             pro_pick = int(row.get("pro_pick") or 0)
-            pro_win_rate = row.get("pro_win_rate")
-            base_score = float(pro_win_rate or 0.5)
+            pro_win = int(row.get("pro_win") or 0)
+            base_score = _shrunk_win_rate(pro_win, pro_pick)
             synergy_lift = self._pair_lift(hero_id, draft.allied_heroes, "ally")
             counter_lift = self._pair_lift(hero_id, draft.enemy_heroes, "enemy")
             score = base_score + synergy_lift + counter_lift

src/dota2tuned/ui/gradio_app.py

@@ -78,6 +78,13 @@ def _format_hero_ids(hero_ids: list[int], names: dict[int, str]) -> str:
     return ", ".join(f"{names.get(hero_id, f'Hero {hero_id}')} ({hero_id})" for hero_id in hero_ids)
 
 
+def _format_item_time(seconds: object) -> str:
+    value = float(seconds or 0)
+    if value < 0:
+        return "pre-game"
+    return f"{round(value / 60, 1)} min"
+
+
 def _format_recs(recs: list) -> str:
     if not recs:
         return (
@@ -209,10 +216,10 @@ def build_app() -> gr.Blocks:
         )
         lines = []
         for row in rows:
-            minutes = round(float(row.get("median_time") or 0) / 60, 1)
+            median_time = _format_item_time(row.get("median_time"))
             lines.append(
                 f"- **{row.get('item_key')}** in `{row.get('time_bucket')}`: "
-                f"{row.get('purchases')} purchases, median `{minutes}` min"
+                f"{row.get('purchases')} purchases, median `{median_time}`"
             )
         return "\n".join(lines) if lines else "No observed item timings for that hero."
 

tests/test_gradio_app.py

@@ -1,6 +1,6 @@
 import polars as pl
 
-from dota2tuned.ui.gradio_app import _hero_lookup, _parse_heroes
+from dota2tuned.ui.gradio_app import _format_item_time, _hero_lookup, _parse_heroes
 
 
 def test_parse_heroes_accepts_names_and_ids():
@@ -27,3 +27,8 @@ def test_parse_heroes_reports_unknown_names():
 
     assert hero_ids == [1]
     assert unknown == ["Banana King"]
+
+
+def test_format_item_time_labels_pre_game_buys():
+    assert _format_item_time(-90) == "pre-game"
+    assert _format_item_time(180) == "3.0 min"

tests/test_recommend.py

@@ -12,6 +12,7 @@ def test_recommendation_schema_and_exclusions(tmp_path: Path):
             {
                 "hero_id": 1,
                 "hero_name": "Anti-Mage",
+                "roles": "Carry,Escape,Nuker",
                 "pro_pick": 1000,
                 "pro_win": 520,
                 "pro_win_rate": 0.52,
@@ -19,6 +20,7 @@ def test_recommendation_schema_and_exclusions(tmp_path: Path):
             {
                 "hero_id": 2,
                 "hero_name": "Axe",
+                "roles": "Initiator,Durable,Disabler",
                 "pro_pick": 200,
                 "pro_win": 90,
                 "pro_win_rate": 0.45,
@@ -31,3 +33,61 @@ def test_recommendation_schema_and_exclusions(tmp_path: Path):
     assert len(recs) == 1
     assert isinstance(recs[0], Recommendation)
     assert recs[0].hero_id == 2
+
+
+def test_mid_recommendations_filter_support_first_heroes(tmp_path: Path):
+    write_parquet(
+        tmp_path / "dim_hero.parquet",
+        [
+            {
+                "hero_id": 13,
+                "hero_name": "Puck",
+                "roles": "Initiator,Disabler,Escape,Nuker",
+                "pro_pick": 12,
+                "pro_win": 4,
+                "pro_win_rate": 0.3333,
+            },
+            {
+                "hero_id": 91,
+                "hero_name": "Io",
+                "roles": "Support,Escape,Nuker",
+                "pro_pick": 4,
+                "pro_win": 4,
+                "pro_win_rate": 1.0,
+            },
+        ],
+    )
+    write_parquet(tmp_path / "fact_hero_pair_stats.parquet", [])
+
+    recs = DraftRecommender(tmp_path).recommend(DraftInput(role="mid"), limit=5)
+
+    assert [rec.hero_name for rec in recs] == ["Puck"]
+
+
+def test_low_sample_win_rates_are_shrunk(tmp_path: Path):
+    write_parquet(
+        tmp_path / "dim_hero.parquet",
+        [
+            {
+                "hero_id": 1,
+                "hero_name": "Tiny Sample",
+                "roles": "Carry",
+                "pro_pick": 1,
+                "pro_win": 1,
+                "pro_win_rate": 1.0,
+            },
+            {
+                "hero_id": 2,
+                "hero_name": "Large Sample",
+                "roles": "Carry",
+                "pro_pick": 200,
+                "pro_win": 120,
+                "pro_win_rate": 0.6,
+            },
+        ],
+    )
+    write_parquet(tmp_path / "fact_hero_pair_stats.parquet", [])
+
+    recs = DraftRecommender(tmp_path).recommend(DraftInput(role="carry"), limit=2)
+
+    assert recs[0].hero_name == "Large Sample"