fix(interview-coach): end-during-connect race, model gate, grade timing

Three findings from review on #391, plus one same-class gap found while
checking:

- endInterview cleared clientRef but never touched connectAbortRef, so
  ownsSession() still reported the in-flight startInterview as the owner.
  Since onConnected/onBotReady flip the UI to "active" before connect()
  resolves, End could be pressed mid-connect and the resumed call would then
  run setSession("active") and attach audio after the user had ended the
  session. endInterview now aborts and clears the controller, and the success
  path additionally requires clientRef.current === client. Replayed the
  interleaving: previously ended {session:"active", audioAttached:true};
  now {session:"idle", audioAttached:false}.

  Same class, unflagged: component unmount disconnected the client but did
  not abort an in-flight connect, so it ran to completion against an already
  disconnected client. The unmount cleanup now aborts first.

- /health only proved the Ollama daemon answered. An unpulled OLLAMA_MODEL or
  OLLAMA_GRADE_MODEL still reported ready, so the failure surfaced later
  inside the background pipeline once WebRTC was already negotiated. It now
  parses /api/tags and reports the missing model(s) with the pull command,
  tolerating the usual `:latest` omission. Covered by 7 cases including
  untagged config, explicit tags, a wrong explicit tag, and an empty daemon.

- _wait_until_coach_quiet treated the pre-speech gap as silence. Grading is
  launched right after the tool ack, before the follow-up has been generated,
  so bot_speaking was still False and the wait returned in ~450ms — putting
  the grader's Ollama request in competition with the coach's own response.
  Added a bot_speech_turns counter so a waiter can tell "not started yet"
  from "already finished", and the wait now requires speech to start (bounded
  by start_timeout_secs, since the coach may not speak) before waiting it out.
  Measured with a follow-up starting at 0.8s and lasting 1.5s: previously
  returned at 0.36s mid-speech, now 2.78s after it finished; with no speech at
  all it still returns, at 4.36s.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>

Author: samanyugoyal2010

apps/moss-interview-coach/backend/server.py

@@ -125,6 +125,9 @@ def __init__(self) -> None:
         self.last_question: str | None = None
         self.bot_buf: list[str] = []
         self.bot_speaking: bool = False
+        # Incremented each time the coach starts speaking. Lets a waiter tell
+        # "has not started yet" apart from "already finished".
+        self.bot_speech_turns: int = 0
         self._grade_generation: int = 0
         self._grade_tasks: set[asyncio.Task[None]] = set()
         self._grade_lock = asyncio.Lock()
@@ -303,6 +306,7 @@ async def process_frame(self, frame: Frame, direction: FrameDirection) -> None:
 
         if isinstance(frame, BotStartedSpeakingFrame):
             self._assist.bot_speaking = True
+            self._assist.bot_speech_turns += 1
 
         if isinstance(frame, BotStoppedSpeakingFrame):
             self._assist.bot_speaking = False
@@ -457,12 +461,33 @@ async def _wait_until_coach_quiet(
     assist: InterviewAssistState,
     *,
     timeout_secs: float,
+    start_timeout_secs: float = 4.0,
 ) -> None:
+    """Block until the coach's spoken follow-up is done.
+
+    Grading is launched straight after the tool ack, while the follow-up is
+    still being generated — so `bot_speaking` is False and the gap before
+    speech starts looks identical to silence. Waiting on silence alone
+    therefore returned after ~450ms and put the grader's Ollama request in
+    competition with the coach's own response, which hurts on a single local
+    GPU. Wait for speech to actually begin first, then for it to finish.
+    """
     deadline = time.perf_counter() + timeout_secs
-    # First wait out any active TTS / speaking window.
-    while assist.bot_speaking and time.perf_counter() < deadline:
+    start_deadline = min(deadline, time.perf_counter() + start_timeout_secs)
+    turns_before = assist.bot_speech_turns
+
+    # Wait for the follow-up to start. Bounded, because the coach may not speak
+    # at all for this turn; the turn counter also covers an utterance that began
+    # and ended between polls.
+    while (
+        not assist.bot_speaking
+        and assist.bot_speech_turns == turns_before
+        and time.perf_counter() < start_deadline
+    ):
         await asyncio.sleep(0.12)
-    # Small quiet period so a multi-segment utterance can finish.
+
+    # Then wait it out, plus a short quiet period so a multi-segment utterance
+    # can finish before grading starts.
     quiet_for = 0.0
     while time.perf_counter() < deadline:
         if assist.bot_speaking:
@@ -857,17 +882,44 @@ async def lifespan(app: FastAPI):
 )
 
 
+def _ollama_model_available(available: set[str], wanted: str) -> bool:
+    """Ollama lists fully-qualified tags (`llama3.1:latest`); config omits `:latest`."""
+    return wanted in available or (":" not in wanted and f"{wanted}:latest" in available)
+
+
 @app.get("/health")
 async def health() -> dict[str, Any]:
     ollama_ok = False
     ollama_error: str | None = None
+    missing_models: list[str] = []
     try:
         base = OLLAMA_BASE_URL.removesuffix("/v1")
         async with httpx.AsyncClient(timeout=2.0) as client:
             resp = await client.get(f"{base}/api/tags")
-            ollama_ok = resp.status_code == 200
-            if not ollama_ok:
-                ollama_error = f"status={resp.status_code}"
+        if resp.status_code != 200:
+            ollama_error = f"status={resp.status_code}"
+        else:
+            payload = resp.json()
+            entries = payload.get("models") or []
+            available = {
+                str(entry.get("name") or entry.get("model") or "")
+                for entry in entries
+                if isinstance(entry, dict)
+            }
+            available.discard("")
+            # A responding daemon is not enough. An unpulled model would only
+            # fail later, inside the background pipeline, after WebRTC is
+            # already negotiated — so refuse the interview here instead.
+            missing_models = sorted(
+                {OLLAMA_MODEL, OLLAMA_GRADE_MODEL}
+                - {m for m in {OLLAMA_MODEL, OLLAMA_GRADE_MODEL} if _ollama_model_available(available, m)}
+            )
+            if missing_models:
+                ollama_error = "missing Ollama model(s): " + ", ".join(
+                    f"{m} (ollama pull {m})" for m in missing_models
+                )
+            else:
+                ollama_ok = True
     except Exception as exc:  # noqa: BLE001
         ollama_error = str(exc)
 
@@ -884,6 +936,7 @@ async def health() -> dict[str, Any]:
         "moss_index_names": all_index_names(),
         "ollama_ok": ollama_ok,
         "ollama_error": ollama_error,
+        "ollama_missing_models": missing_models,
         "ollama_model": OLLAMA_MODEL,
         "ollama_grade_model": OLLAMA_GRADE_MODEL,
         "whisper_model": WHISPER_MODEL,

apps/moss-interview-coach/frontend/app/page.tsx

@@ -282,6 +282,12 @@ export default function HomePage() {
   }, []);
 
   const endInterview = useCallback(async () => {
+    // onConnected / onBotReady can flip the UI to "active" while connect() is
+    // still awaiting, so End can be pressed with a startInterview still in
+    // flight. Retire its controller too, or that call would still own the
+    // session and resurrect it when it resumes.
+    connectAbortRef.current?.abort();
+    connectAbortRef.current = null;
     const client = clientRef.current;
     clientRef.current = null;
     setSession("idle");
@@ -505,9 +511,11 @@ export default function HomePage() {
           abort.signal,
         );
         if (abort.signal.aborted) throw abortReason(abort.signal);
-        // A newer interview may have taken over while we were connecting.
-        // Retire quietly rather than presenting this one as the live session.
-        if (!ownsSession()) {
+        // A newer interview may have taken over, or the user may have ended the
+        // session, while we were connecting. Both are checked: the controller
+        // covers a newer start, and clientRef covers endInterview clearing the
+        // live client. Retire quietly rather than presenting this as live.
+        if (!ownsSession() || clientRef.current !== client) {
           if (clientRef.current === client) clientRef.current = null;
           try {
             await client.disconnect();
@@ -561,7 +569,12 @@ export default function HomePage() {
 
   useEffect(() => {
     return () => {
+      // Abort first: an in-flight startInterview would otherwise run to
+      // completion against a client we are about to disconnect.
+      connectAbortRef.current?.abort();
+      connectAbortRef.current = null;
       void clientRef.current?.disconnect();
+      clientRef.current = null;
     };
   }, []);