fix: interview turn limits, LLM fallback, and completion UI

- Fix graph resume: use aupdate_state + ainvoke(None) so evaluate_answer
and routing actually execute after interrupt
- Switch LLM to Gemini primary with Groq fallback
- Randomize question order per interview session
- Show score inline on interview completion instead of broken report page
- Add hard turn-limit safety checks in backend and frontend
- Register asyncpg JSON codecs so feedback JSONB is parsed correctly
- Navbar logo links to role-appropriate dashboard
- Set max turns to 5

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

backend/db/connection.py

@@ -1,15 +1,24 @@
+import json
 import os
+
 import asyncpg
 
 _pool: asyncpg.Pool | None = None
 
 
+async def _init_connection(conn: asyncpg.Connection) -> None:
+    """Register JSON/JSONB codecs so asyncpg auto-parses those columns."""
+    await conn.set_type_codec("json", encoder=json.dumps, decoder=json.loads, schema="pg_catalog")
+    await conn.set_type_codec("jsonb", encoder=json.dumps, decoder=json.loads, schema="pg_catalog")
+
+
 async def init_db_pool() -> None:
     global _pool
     _pool = await asyncpg.create_pool(
         os.getenv("NEON_DB_URL"),
         min_size=1,
         max_size=10,
+        init=_init_connection,
     )
 
 

backend/graph/nodes.py

@@ -25,10 +25,13 @@ def _msg_role(msg) -> str:
     return "assistant"
 
 
+MAX_TURNS = 5
+
+
 async def ask_question(state: InterviewState) -> dict:
     remaining = list(state["questions_remaining"])
-    if not remaining:
-        return {}
+    if not remaining or state["turn_count"] >= MAX_TURNS:
+        return {"messages": []}
 
     question = remaining.pop(0)
     prompt = build_ask_question_prompt(
@@ -98,7 +101,6 @@ async def counter_question(state: InterviewState) -> dict:
     return {
         "messages": [{"role": "assistant", "content": response}],
         "awaiting_counter_response": True,
-        "turn_count": state["turn_count"] + 1,
         "counter_questions_asked": state["counter_questions_asked"] + 1,
     }
 
@@ -156,16 +158,22 @@ def route_after_evaluation(state: InterviewState) -> str:
     questions_remaining = state["questions_remaining"]
     awaiting_counter = state["awaiting_counter_response"]
 
+    decision = "unknown"
+
     # End conditions always win — no extra turns after the limit
-    if turn_count >= 2 or not questions_remaining:
-        return "end"
+    if turn_count >= MAX_TURNS or not questions_remaining:
+        decision = "end"
+    elif verdict == "shallow" and not awaiting_counter and state.get("counter_questions_asked", 0) < 2:
+        decision = "counter"
+    elif turn_count % 4 == 0 and turn_count > 0:
+        decision = "summarize"
+    else:
+        decision = "next_question"
+
+    print(f"[ROUTE] turn_count={turn_count}, verdict={verdict}, "
+          f"remaining={len(questions_remaining)}, awaiting_counter={awaiting_counter}, "
+          f"counter_asked={state.get('counter_questions_asked', 0)}, decision={decision}")
 
-    # Shallow + not already in counter loop + under cap (max 2 per interview)
-    if verdict == "shallow" and not awaiting_counter and state.get("counter_questions_asked", 0) < 2:
-        return "counter"
+    return decision
 
-    # Compress memory every 4 turns
-    if turn_count % 4 == 0 and turn_count > 0:
-        return "summarize"
 
-    return "next_question"

backend/llm.py

@@ -2,25 +2,59 @@ import os
 
 import httpx
 
-_OPENROUTER_URL = "https://openrouter.ai/api/v1/chat/completions"
-_MODEL = "nvidia/nemotron-3-super-120b-a12b:free"
+_GEMINI_URL = "https://generativelanguage.googleapis.com/v1beta/chat/completions"
+_GEMINI_MODEL = "gemini-3.1-flash-lite-preview"
 
+_GROQ_URL = "https://api.groq.com/openai/v1/chat/completions"
+_GROQ_MODEL = "llama-3.3-70b-versatile"
 
-async def call_llm(messages: list[dict], max_tokens: int = 512) -> str:
-    """Call OpenRouter API. Returns the assistant message content string."""
-    api_key = os.getenv("OPENROUTER_API_KEY", "")
+
+async def _call_gemini(messages: list[dict], max_tokens: int) -> str:
+    api_key = os.getenv("GEMINI_API_KEY", "")
     async with httpx.AsyncClient(timeout=60.0) as client:
         response = await client.post(
-            _OPENROUTER_URL,
+            _GEMINI_URL,
             headers={
                 "Authorization": f"Bearer {api_key}",
                 "Content-Type": "application/json",
             },
             json={
-                "model": _MODEL,
+                "model": _GEMINI_MODEL,
                 "messages": messages,
                 "max_tokens": max_tokens,
             },
         )
         response.raise_for_status()
         return response.json()["choices"][0]["message"]["content"] or ""
+
+
+async def _call_groq(messages: list[dict], max_tokens: int) -> str:
+    api_key = os.getenv("GROQ_API_KEY", "")
+    async with httpx.AsyncClient(timeout=60.0) as client:
+        response = await client.post(
+            _GROQ_URL,
+            headers={
+                "Authorization": f"Bearer {api_key}",
+                "Content-Type": "application/json",
+            },
+            json={
+                "model": _GROQ_MODEL,
+                "messages": messages,
+                "max_tokens": max_tokens,
+            },
+        )
+        response.raise_for_status()
+        return response.json()["choices"][0]["message"]["content"] or ""
+
+
+async def call_llm(messages: list[dict], max_tokens: int = 512) -> str:
+    """Call Gemini (primary) with Groq fallback. Returns assistant message content."""
+    try:
+        result = await _call_gemini(messages, max_tokens)
+        if result:
+            return result
+        print("[LLM] Gemini returned empty, falling back to Groq")
+    except Exception as e:
+        print(f"[LLM] Gemini failed: {e}, falling back to Groq")
+
+    return await _call_groq(messages, max_tokens)

backend/routers/interview.py

@@ -1,4 +1,5 @@
 import json
+import random
 
 from fastapi import APIRouter, Depends, HTTPException, Request
 from pydantic import BaseModel
@@ -54,14 +55,17 @@ async def start_interview(
     session = await queries.create_interview_session(user["user_id"], body.topic_id)
     session_id = str(session["id"])
 
+    shuffled_questions = [
+        {"question_text": q["question_text"], "difficulty": q["difficulty"]}
+        for q in questions
+    ]
+    random.shuffle(shuffled_questions)
+
     initial_state = {
         "topic_name": topic["name"],
         "session_id": session_id,
         "student_id": user["user_id"],
-        "questions_remaining": [
-            {"question_text": q["question_text"], "difficulty": q["difficulty"]}
-            for q in questions
-        ],
+        "questions_remaining": shuffled_questions,
         "past_best_score": past_best_score,
         "past_weak_areas": past_weak_areas,
         "messages": [],
@@ -84,6 +88,7 @@ async def start_interview(
     return {
         "session_id": session_id,
         "message": _last_ai_message(result["messages"]),
+        "turn_count": result.get("turn_count", 0),
     }
 
 
@@ -102,10 +107,33 @@ async def interview_turn(
     graph = request.app.state.graph
     config = {"configurable": {"thread_id": body.session_id}}
 
-    result = await graph.ainvoke(
-        {"messages": [{"role": "human", "content": body.student_message}]},
+    # Hard safety check — refuse turns beyond the limit regardless of graph state
+    MAX_TURNS = 5
+    checkpoint = await graph.checkpointer.aget(config)
+    if checkpoint:
+        current_turns = checkpoint.get("channel_values", {}).get("turn_count", 0)
+        print(f"[TURN GUARD] session={body.session_id}, current_turns={current_turns}, max={MAX_TURNS}")
+        if current_turns > MAX_TURNS:
+            guard_feedback = {
+                "score": 0, "summary": "Interview ended — turn limit reached.",
+                "concept_score": 0, "depth_score": 0, "mistakes": [], "tips": [],
+            }
+            await queries.update_session_complete(body.session_id, 0, guard_feedback)
+            return {
+                "message": "Interview complete — turn limit reached.",
+                "turn_count": current_turns,
+                "is_complete": True,
+                "is_counter_q": False,
+                "feedback": guard_feedback,
+            }
+
+    # Update state with the student's message, then resume from the interrupt
+    await graph.aupdate_state(
         config,
+        {"messages": [{"role": "human", "content": body.student_message}]},
+        as_node="ask_question",
     )
+    result = await graph.ainvoke(None, config)
 
     is_complete = result.get("status") == "complete"
     response: dict = {

frontend/src/components/interview/ProgressBar.tsx

@@ -10,7 +10,7 @@ export default function ProgressBar({ current, max }: Props) {
     <div className="px-4 py-2 border-b border-gray-800">
       <div className="flex items-center justify-between text-xs text-gray-400 mb-1">
         <span>Progress</span>
-        <span>Turn {current} of {max}</span>
+        <span>Question {current} of {max}</span>
       </div>
       <div className="h-1.5 bg-gray-800 rounded-full overflow-hidden">
         <div

frontend/src/components/shared/Navbar.tsx

@@ -14,7 +14,12 @@ export default function Navbar() {
 
   return (
     <nav className="bg-gray-900 border-b border-gray-800 px-6 py-3 flex items-center justify-between">
-      <span className="text-white font-semibold text-lg tracking-tight">InterviewMentor</span>
+      <button
+        onClick={() => navigate(user?.role === 'instructor' ? '/instructor/dashboard' : '/student/dashboard')}
+        className="text-white font-semibold text-lg tracking-tight hover:text-indigo-400 transition-colors"
+      >
+        InterviewMentor
+      </button>
       {user && (
         <div className="flex items-center gap-4">
           <span className="text-gray-400 text-sm">{user.full_name}</span>

frontend/src/pages/Interview.tsx

@@ -16,6 +16,7 @@ export default function Interview() {
     useInterviewStore()
 
   const [error, setError] = useState('')
+  const [feedback, setFeedback] = useState<Record<string, unknown> | null>(null)
 
   // On mount: resume existing session or start new one
   useEffect(() => {
@@ -53,6 +54,7 @@ export default function Interview() {
     try {
       const data = await startInterview(topicId)
       startSession(data.session_id, topicId, data.message)
+      if (data.turn_count != null) setTurnCount(data.turn_count)
       // Update URL to include session id without triggering re-mount
       navigate(`/student/interview/${data.session_id}`, { replace: true, state: location.state })
     } catch {
@@ -63,6 +65,14 @@ export default function Interview() {
 
   async function handleSend(answer: string) {
     if (!useInterviewStore.getState().sessionId) return
+
+    // Frontend safety: don't send if already at max turns
+    const { turnCount: currentTurn, maxTurns: limit } = useInterviewStore.getState()
+    if (currentTurn > limit) {
+      setStatus('finished')
+      return
+    }
+
     const currentSessionId = useInterviewStore.getState().sessionId!
 
     addMessage({ role: 'student', content: answer })
@@ -71,12 +81,15 @@ export default function Interview() {
 
     try {
       const data = await sendTurn(currentSessionId, answer)
-      addMessage({ role: 'ai', content: data.message })
       if (data.turn_count != null) setTurnCount(data.turn_count)
 
       if (data.is_complete) {
+        if (data.feedback) {
+          setFeedback(data.feedback)
+        }
         setStatus('finished')
       } else {
+        addMessage({ role: 'ai', content: data.message })
         setStatus('waiting')
       }
     } catch {
@@ -112,14 +125,37 @@ export default function Interview() {
         )}
 
         {isFinished ? (
-          <div className="border-t border-gray-800 px-4 py-4 text-center">
-            <p className="text-gray-400 text-sm mb-3">Interview complete!</p>
-            <button
-              onClick={() => navigate(`/student/report/${currentSessionId}`)}
-              className="bg-indigo-600 hover:bg-indigo-500 text-white rounded-xl px-6 py-2 text-sm font-medium transition-colors"
-            >
-              View Report
-            </button>
+          <div className="border-t border-gray-800 px-4 py-6 space-y-4">
+            <p className="text-center text-white font-semibold text-lg">Interview Complete!</p>
+
+            {feedback && (
+              <div className="bg-gray-900 border border-gray-800 rounded-xl p-5 space-y-3 mx-4">
+                <div className="flex items-center justify-between">
+                  <span className="text-gray-400 text-sm">Score</span>
+                  <span className={`text-2xl font-bold ${
+                    Number(feedback.score) >= 70 ? 'text-green-400' :
+                    Number(feedback.score) >= 40 ? 'text-yellow-400' : 'text-red-400'
+                  }`}>
+                    {feedback.score ?? 0}/100
+                  </span>
+                </div>
+                {feedback.summary && (
+                  <p className="text-gray-300 text-sm">{String(feedback.summary)}</p>
+                )}
+              </div>
+            )}
+
+            <div className="text-center">
+              <button
+                onClick={() => {
+                  useInterviewStore.getState().reset()
+                  navigate('/student/dashboard')
+                }}
+                className="bg-indigo-600 hover:bg-indigo-500 text-white rounded-xl px-6 py-2 text-sm font-medium transition-colors"
+              >
+                Back to Dashboard
+              </button>
+            </div>
           </div>
         ) : (
           status !== 'idle' && (

frontend/src/pages/Report.tsx

@@ -42,7 +42,7 @@ export default function Report() {
           </div>
         )}
 
-        {report && (
+        {report && report.feedback && (
           <>
             {/* Header */}
             <div className="bg-gray-900 border border-gray-800 rounded-xl p-6 flex items-center justify-between">

frontend/src/store/interviewStore.ts

@@ -23,7 +23,7 @@ const initialState: InterviewState = {
   topicId: null,
   messages: [],
   turnCount: 0,
-  maxTurns: 2,
+  maxTurns: 5,
   status: 'idle',
 }