Upload folder using huggingface_hub

app.py

@@ -47,6 +47,7 @@ from matchday.agent_trace import (  # noqa: E402
 )
 from matchday.intent import parse_intent  # noqa: E402
 from matchday.models import TripRequest  # noqa: E402
+from matchday.wc2026 import resolve_match  # noqa: E402
 from matchday.prompts import EXPLANATION_HINT  # noqa: E402
 from matchday.render import render_full  # noqa: E402
 from matchday.trip_tool import build_trip_packages, format_for_nemotron  # noqa: E402
@@ -125,6 +126,78 @@ def _notice_status(result, *keywords: str) -> str:
     return "fallback" if any(k in blob for k in keywords) else "done"
 
 
+def _precheck_unrecognized_match(user_text: str):
+    """Generic pre-agent fixture validator (grounding honesty, option 1).
+
+    Deterministically parse the request and ground the named match against the
+    verified 2026 fixture table BEFORE the agent picks a tool. If the user named
+    a matchup that isn't a real 2026 fixture, return ``(refusal_note, trip)`` so
+    ``plan_trip`` can refuse honestly with the closest real alternatives and stop
+    — without ever invoking the agent loop.
+
+    Why this exists: Nemotron routes its own tools and, for some non-fixture
+    matchups (e.g. "Canada vs Morocco"), can non-deterministically choose
+    ``clarify`` over ``build_trip_packages``. When it does, the grounding-refusal
+    path (the "isn't a 2026 fixture … Canada plays: …" note produced inside the
+    build tool) never runs, so the demo promises a refusal it never delivers.
+    Grounding the match deterministically up front guarantees every non-fixture
+    match is refused honestly, regardless of how the model routes.
+
+    Returns ``(note, trip_request)`` when a match is named AND unrecognized;
+    ``None`` otherwise (no match named, parse failed, or the match IS real —
+    proceed to the normal agent path). Never raises.
+    """
+    try:
+        parsed = parse_intent(user_text)
+    except Exception:  # noqa: BLE001 — must never break the turn
+        return None
+    trip = getattr(parsed, "trip_request", None)
+    match_name = (getattr(trip, "match_name", "") or "") if trip is not None else ""
+    if not match_name or match_name == "the match":  # _find_match's fallback sentinel
+        return None
+    match_name = _clean_match_name(match_name)  # drop trailing month ("Morocco June" -> "Morocco")
+    try:
+        res = resolve_match(match_name)
+    except Exception:  # noqa: BLE001
+        return None
+    if res.recognized or not res.note:
+        return None
+    try:  # carry the CLEANED name onto the trip so the trace drawer matches the note
+        trip = trip.model_copy(update={"match_name": match_name})
+    except Exception:  # noqa: BLE001
+        pass
+    return res.note, trip
+
+
+_MONTH_TOKENS = {
+    "january", "february", "march", "april", "may", "june",
+    "july", "august", "september", "october", "november", "december",
+}
+
+
+def _clean_match_name(name: str) -> str:
+    """Strip a trailing month token from each team in an 'A vs B' match name.
+
+    ``parse_intent``'s ``_find_match`` greedily appends the next capitalized word
+    to a team name, so 'Canada vs Morocco June 18' parses to 'Canada vs Morocco
+    June' — the month leaks into the team and would surface in the refusal note
+    as "Morocco June plays: Brazil". Trimming trailing month tokens restores the
+    real team names for a clean note. Conservative: only strips trailing month
+    tokens, leaves everything else intact (multi-word teams unaffected).
+    """
+    if " vs " not in name:
+        return name
+
+    def _strip(trial: str) -> str:
+        parts = trial.split()
+        while parts and parts[-1].lower().rstrip(".") in _MONTH_TOKENS:
+            parts.pop()
+        return " ".join(parts)
+
+    a, b = name.split(" vs ", 1)
+    return f"{_strip(a)} vs {_strip(b)}"
+
+
 def _finalize_trace(trace: AgentTrace, trip, result, built_by: str) -> None:
     """Populate the final intent/grounding/evidence/ranking/outcome on the trace.
 
@@ -242,6 +315,26 @@ async def plan_trip(user_text: str) -> str:
     yield _ev(type="progress", step="read", status="done", text="Read your request")
     yield _ev(type="progress", step="extract", status="running", text="Understanding your trip")
 
+    # ── Generic pre-agent fixture validator (grounding honesty). Ground the named
+    # match deterministically BEFORE the agent picks a tool: a non-real 2026
+    # fixture is refused with the closest real alternatives and we stop, so the
+    # refusal never depends on Nemotron choosing build_trip_packages over clarify.
+    _pre = _precheck_unrecognized_match(user_text)
+    if _pre is not None:
+        _refusal_note, _pre_trip = _pre
+        trace.set_intent(_pre_trip)
+        trace.set_grounding(recognized=False, note=_refusal_note)
+        trace.set_outcome(
+            mode="deterministic", status="clarify",
+            notes=["Pre-agent fixture check: named match is not a real 2026 fixture."],
+            model=_TRACE_MODEL, rounds=0,
+        )
+        yield _ev(type="trace", data=trace.to_dict())  # grounding-refusal proof
+        yield _ev(type="progress", step="extract", status="done", text="Match checked")
+        yield _ev(type="progress", step="ready", status="fallback", text="Match not found")
+        yield _ev(type="clarify", text=_refusal_note)
+        return
+
     agent = None
     if USE_AGENT:
         try: