updated ui, docs, tests

.gitignore

@@ -24,3 +24,4 @@ Thumbs.db
 .idea/
 .vscode/
 *.swp
+.claude

CLAUDE.md

@@ -1,736 +1,105 @@
-# AI InterviewMentor — Claude Code Architecture Document
+# CLAUDE.md
 
-> This document is the single source of truth for Claude Code.
-> Read this fully before writing any code.
-> If architecture decisions conflict with the original docs, this document takes precedence.
+This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.
 
----
+## Implementation Status (as of 2026-03-28)
 
-## Project Overview
+| Phase | Status | Description |
+|-------|--------|-------------|
+| 1 — Scaffolding | ✅ Done | Vite+React, FastAPI, Docker, NeonDB schema |
+| 2 — Auth | ✅ Done | JWT, bcrypt, signup/login/refresh/logout |
+| 3 — Instructor Batch/Topics | ✅ Done | Batch creation, class code, topic CRUD, lock/unlock |
+| 4 — Question Bank Upload | ✅ Done | CSV parse + bulk insert, UploadZone UI |
+| 5 — LangGraph Interview Engine | ✅ Done | State machine, nodes, prompts, `/interview` router, checkpointer |
+| 6 — Student Interview UI | ✅ Done | Chat UI, interviewStore, interview API |
+| 7 — Reports & Feedback | ✅ Done | ScoreRing, FeedbackCard, SummaryBlock, Report page |
+| 8 — Student Dashboard | ✅ Done | TopicChip, AttemptRow, StudentDashboard page |
+| 9 — Instructor Analytics | ✅ Done | StudentRow, GapReport, StudentDetail page, InstructorDashboard extended |
+| 10 — Deploy | ⏳ Pending | Docker wiring, static mount, HF Spaces |
 
-AI InterviewMentor is a full-stack web platform that simulates real-world technical interviews for fresher IT students at training institutes. Instructors upload topic-wise question banks. Students take AI-powered mock interviews. The AI asks questions, fires counter-questions when answers are shallow, and generates scored feedback reports. Instructors see class-wide readiness data.
+**Active area (other dev)**: `backend/graph/`, `backend/prompts.py`, `backend/checkpointer.py`, `backend/routers/interview.py`
 
 ---
 
-## Deployment Target
-
-**Single Docker container on Hugging Face Spaces.**
+## Collaboration Notes (Two Developers)
 
-Everything — React frontend, FastAPI backend, LangGraph engine — runs in one container on port 7860. There is no Vercel, no separate backend server, no split deployment.
+Both developers are working on Phase 5 simultaneously. Each stub file has a header comment defining the **owner**, **interface contract**, and **dependencies** to prevent conflicts. Follow these rules:
 
-```
-HF Spaces (Docker, port 7860)
-├── React (Vite, served as static files by FastAPI)
-└── FastAPI + LangGraph
-      └── NeonDB (external PostgreSQL)
-            └── OpenRouter → MiniMax 2.7
-```
+- **Do not change function signatures** defined in stub headers without coordinating first
+- `InterviewState` in `backend/graph/state.py` is the shared contract — both sides depend on it; define it first before touching nodes or prompts
+- `backend/prompts.py` owns all LLM prompt strings — nodes import from here, never inline prompts in nodes
+- `backend/routers/interview.py` depends on `graph.py` being importable — implement `graph.py` before wiring the router
 
 ---
 
-## Tech Stack
-
-| Layer | Technology | Notes |
-|-------|-----------|-------|
-| Frontend | React 18 + Vite + TypeScript | Served as static build by FastAPI |
-| Styling | Tailwind CSS v3 | Dark theme only |
-| Backend | FastAPI (Python 3.11) | All API routes |
-| AI Orchestration | LangGraph | Interview state machine |
-| Database | NeonDB (PostgreSQL) | App data + LangGraph checkpoints |
-| AI Gateway | OpenRouter | MiniMax 2.7 model |
-| Auth | Custom JWT | jose (Python) + bcrypt, no Supabase, no Firebase |
-| Container | Docker (multi-stage build) | Node build stage + Python runtime stage |
-| Hosting | Hugging Face Spaces | Free tier, CPU Basic |
-
-### Explicitly Banned
-- Supabase (not allowed by hackathon rules)
-- Firebase (not allowed by hackathon rules)
-- Vercel (not needed, everything on HF Spaces)
-- Next.js (replaced by React + Vite)
-- Any third-party auth service
+## Project Overview
 
----
+AI InterviewMentor is a full-stack AI-powered mock interview platform. Monorepo with a React frontend and Python FastAPI backend, deployed as a single Docker container to Hugging Face Spaces (port 7860).
 
-## Folder Structure
+Two user roles: **Instructor** (creates batches, manages topics/questions) and **Student** (joins via class code, takes AI interviews). The AI interview engine uses LangGraph with PostgreSQL-backed checkpointing.
 
-```
-ai-interviewmentor/
-├── frontend/                        # React + Vite
-│   ├── src/
-│   │   ├── pages/
-│   │   │   ├── Login.tsx
-│   │   │   ├── Signup.tsx
-│   │   │   ├── StudentDashboard.tsx
-│   │   │   ├── Interview.tsx
-│   │   │   ├── Report.tsx
-│   │   │   ├── InstructorDashboard.tsx
-│   │   │   ├── Upload.tsx
-│   │   │   └── StudentDetail.tsx
-│   │   ├── components/
-│   │   │   ├── auth/
-│   ��   │   │   └── RoleSelector.tsx
-│   │   │   ├── interview/
-│   │   │   │   ├── ChatWindow.tsx
-│   │   │   │   ├── MessageBubble.tsx
-│   │   │   │   ├── ProgressBar.tsx
-│   │   │   │   └── TypeInput.tsx
-│   │   │   ├── report/
-│   │   │   │   ├── ScoreRing.tsx
-│   │   │   │   ├── FeedbackCard.tsx
-│   │   │   │   └── SummaryBlock.tsx
-│   │   │   ├── student/
-│   │   │   │   ├── TopicChip.tsx
-│   │   │   │   └── AttemptRow.tsx
-│   │   │   ├── instructor/
-│   │   │   │   ├── StudentRow.tsx
-│   │   │   │   ├── GapReport.tsx
-│   │   │   │   ├── StatCard.tsx
-│   │   │   │   └── UploadZone.tsx
-│   │   │   └── shared/
-│   │   │       ├── Navbar.tsx
-│   │   │       └── ProtectedRoute.tsx
-│   │   ├── api/                     # All fetch calls to FastAPI
-│   │   │   ├── auth.ts
-│   │   │   ├── topics.ts
-│   │   │   ├── sessions.ts
-│   │   │   ├── upload.ts
-│   │   │   └── interview.ts
-│   │   ├── store/                   # Zustand stores
-│   │   │   ├── authStore.ts         # JWT token + user context
-│   │   │   └── interviewStore.ts    # Active session state
-│   │   ├── types/
-│   │   │   └── index.ts
-│   │   ├── App.tsx                  # React Router setup
-│   │   └── main.tsx
-│   ├── index.html
-│   ├── vite.config.ts
-│   ├── tailwind.config.ts
-│   └── package.json
-│
-├── backend/
-│   ├── main.py                      # FastAPI app entry point
-│   ├── routers/
-│   │   ├── auth.py                  # /api/auth/*
-│   │   ├── batches.py               # /api/batches/*
-│   │   ├── topics.py                # /api/topics/*
-│   │   ├── sessions.py              # /api/sessions/*
-│   │   ├── upload.py                # /api/upload
-│   │   └── interview.py             # /interview/*
-│   ├── graph/
-│   │   ├── state.py                 # InterviewState TypedDict
-│   │   ├── nodes.py                 # All LangGraph nodes
-│   │   └── graph.py                 # Graph builder + compiler
-│   ├── db/
-│   │   ├── connection.py            # NeonDB async connection pool
-│   │   └── queries.py               # All SQL queries
-│   ├── auth/
-│   │   ├── jwt.py                   # JWT sign + verify
-│   │   └── password.py              # bcrypt hash + verify
-│   ├── checkpointer.py              # LangGraph AsyncPostgresSaver setup
-│   ├── prompts.py                   # System prompt builder
-│   └── requirements.txt
-│
-├── Dockerfile                       # Multi-stage build
-├── .env.example
-└── CLAUDE.md                        # This file
-```
+**Hackathon constraint**: No third-party auth (Supabase/Firebase banned) — custom JWT only.
 
----
-
-## Environment Variables
+## Commands
 
+### Backend
 ```bash
-# NeonDB
-NEON_DB_URL=postgresql://user:pass@ep-xxx.neon.tech/neondb?sslmode=require
-
-# JWT
-JWT_SECRET=your-secret-key-min-32-chars
-JWT_ACCESS_EXPIRE_MINUTES=15
-JWT_REFRESH_EXPIRE_DAYS=7
-
-# OpenRouter
-OPENROUTER_API_KEY=your-openrouter-key
-
-# App
-APP_URL=https://your-space.hf.space
+uv run uvicorn backend.main:app --host 0.0.0.0 --port 7860 --reload   # Dev server
+uv run pytest                                                           # All tests
+uv run pytest tests/test_jwt.py                                         # Single test file
+uv run pytest tests/test_jwt.py::test_create_access_token -v            # Single test
+uv sync                                                                 # Install/sync deps
 ```
 
----
-
-## Database Schema
-
-Two schemas in one NeonDB instance.
-
-### Schema: public (App Data)
-
-```sql
-CREATE TABLE users (
-  id            UUID PRIMARY KEY DEFAULT gen_random_uuid(),
-  full_name     TEXT NOT NULL,
-  email         TEXT NOT NULL UNIQUE,
-  password_hash TEXT NOT NULL,
-  role          TEXT NOT NULL CHECK (role IN ('student', 'instructor')),
-  batch_id      UUID REFERENCES batches(id) ON DELETE SET NULL,
-  created_at    TIMESTAMPTZ DEFAULT NOW()
-);
-
-CREATE TABLE refresh_tokens (
-  id         UUID PRIMARY KEY DEFAULT gen_random_uuid(),
-  user_id    UUID NOT NULL REFERENCES users(id) ON DELETE CASCADE,
-  token_hash TEXT NOT NULL,
-  expires_at TIMESTAMPTZ NOT NULL,
-  created_at TIMESTAMPTZ DEFAULT NOW()
-);
-
-CREATE TABLE batches (
-  id            UUID PRIMARY KEY DEFAULT gen_random_uuid(),
-  name          TEXT NOT NULL,
-  instructor_id UUID NOT NULL REFERENCES users(id) ON DELETE CASCADE,
-  class_code    TEXT NOT NULL UNIQUE DEFAULT upper(substring(gen_random_uuid()::text, 1, 8)),
-  created_at    TIMESTAMPTZ DEFAULT NOW()
-);
-
-CREATE TABLE topics (
-  id          UUID PRIMARY KEY DEFAULT gen_random_uuid(),
-  batch_id    UUID NOT NULL REFERENCES batches(id) ON DELETE CASCADE,
-  name        TEXT NOT NULL,
-  is_unlocked BOOLEAN NOT NULL DEFAULT FALSE,
-  order_index INTEGER NOT NULL DEFAULT 0,
-  created_at  TIMESTAMPTZ DEFAULT NOW()
-);
-
-CREATE TABLE questions (
-  id            UUID PRIMARY KEY DEFAULT gen_random_uuid(),
-  topic_id      UUID NOT NULL REFERENCES topics(id) ON DELETE CASCADE,
-  question_text TEXT NOT NULL,
-  difficulty    TEXT NOT NULL CHECK (difficulty IN ('easy', 'medium', 'hard')) DEFAULT 'medium',
-  created_at    TIMESTAMPTZ DEFAULT NOW()
-);
-
-CREATE TABLE interview_sessions (
-  id           UUID PRIMARY KEY DEFAULT gen_random_uuid(),
-  student_id   UUID NOT NULL REFERENCES users(id) ON DELETE CASCADE,
-  topic_id     UUID NOT NULL REFERENCES topics(id) ON DELETE CASCADE,
-  status       TEXT NOT NULL CHECK (status IN ('active', 'completed')) DEFAULT 'active',
-  score        INTEGER CHECK (score >= 0 AND score <= 100),
-  feedback     JSONB,
-  started_at   TIMESTAMPTZ DEFAULT NOW(),
-  completed_at TIMESTAMPTZ
-);
+### Frontend
+```bash
+cd frontend
+npm install          # Install deps
+npm run dev          # Dev server (port 5173, proxies /api to :7860)
+npm run build        # Production build (TypeScript check + Vite)
+npm run lint         # ESLint
+npm run preview      # Preview production build
 ```
 
-### Schema: checkpointer (LangGraph State)
-
-```sql
--- Created automatically by LangGraph AsyncPostgresSaver
--- Do not manually create or modify these tables
--- Run: await checkpointer.setup() on app startup
-CREATE SCHEMA IF NOT EXISTS checkpointer;
+### Docker
+```bash
+docker build -t ai-interviewmentor .
+docker run -p 7860:7860 --env-file .env ai-interviewmentor
 ```
 
----
-
-## Auth Design
-
-### Token Strategy
-
-```
-Access Token
-  - Algorithm: HS256
-  - Expiry: 15 minutes
-  - Payload: { user_id, role, batch_id, email, exp }
-  - Sent in: Authorization: Bearer <token> header
+## Architecture
 
-Refresh Token
-  - Expiry: 7 days
-  - Stored: hashed in refresh_tokens table
-  - Sent in: httpOnly cookie (refresh_token)
-  - Used only at: POST /api/auth/refresh
-```
+### Same-Origin Design
+FastAPI serves both the API (`/api/*`) and the built React SPA (catch-all `/`). No CORS needed. In development, Vite proxies `/api` and `/interview` to `localhost:7860`.
 
 ### Auth Flow
+- Access token: HS256 JWT, 15min expiry, in `Authorization: Bearer` header
+- Refresh token: 7-day, bcrypt-hashed in DB, httpOnly cookie
+- Frontend `apiFetch()` wrapper (`frontend/src/api/client.ts`) auto-refreshes on 401
+- Backend dependencies: `get_current_user`, `require_instructor`, `require_student` in `backend/auth/deps.py`
+
+### Database (NeonDB/PostgreSQL)
+- `public` schema: app tables (users, refresh_tokens, batches, topics, questions, interview_sessions)
+- `checkpointer` schema: LangGraph state (auto-managed)
+- Connection via asyncpg pool (`backend/db/connection.py`)
+- Raw SQL queries in `backend/db/queries.py`
+
+### LangGraph Interview Engine
+State machine: `ask_question → evaluate_answer → (counter_question | ask_question | generate_report)`. Summarizes every 4 turns. Max 8 turns. `session_id = thread_id` maps DB sessions to LangGraph state. Target ~700 tokens per LLM call via OpenRouter (MiniMax 2.7).
+
+### Frontend Patterns
+- **State**: Zustand stores (`authStore` with localStorage persist, `interviewStore`)
+- **Routing**: React Router 7 with role-based `ProtectedRoute` wrapper
+- **Styling**: Tailwind CSS v3, dark theme only (class-based), no component library
+- **API calls**: Domain-organized modules in `frontend/src/api/` using shared `apiFetch` wrapper
 
-```
-SIGNUP
-  POST /api/auth/signup
-  Body: { full_name, email, password, role, class_code? }
-  → Validate class_code if role=student → get batch_id
-  → Hash password (bcrypt, cost=12)
-  → Insert user
-  → Issue access token + refresh token
-  → Return: { access_token, user: { id, role, full_name, batch_id } }
-  → Set: httpOnly cookie refresh_token
-
-LOGIN
-  POST /api/auth/login
-  Body: { email, password }
-  → Verify password hash
-  → Issue access token + refresh token
-  → Return: { access_token, user: { id, role, full_name, batch_id } }
-  → Set: httpOnly cookie refresh_token
-
-REFRESH
-  POST /api/auth/refresh
-  → Read refresh_token cookie
-  → Verify hash against refresh_tokens table
-  → Issue new access token
-  → Return: { access_token }
-
-LOGOUT
-  POST /api/auth/logout
-  → Delete refresh_token from DB
-  → Clear cookie
-```
-
-### Route Protection (FastAPI dependency)
-
-```python
-# Applied to every protected route via Depends(get_current_user)
-# Returns the decoded JWT payload
-# Raises 401 if token missing, expired, or invalid
-async def get_current_user(token: str = Depends(oauth2_scheme)) -> dict:
-    ...
-
-# Role guard
-async def require_instructor(user = Depends(get_current_user)) -> dict:
-    if user["role"] != "instructor":
-        raise HTTPException(status_code=403)
-    return user
-
-async def require_student(user = Depends(get_current_user)) -> dict:
-    if user["role"] != "student":
-        raise HTTPException(status_code=403)
-    return user
-```
-
----
-
-## API Routes
-
-### Auth Routes
-
-```
-POST   /api/auth/signup
-POST   /api/auth/login
-POST   /api/auth/refresh
-POST   /api/auth/logout
-```
-
-### Instructor Routes (require_instructor)
-
-```
-POST   /api/batches                  → create batch
-GET    /api/batches/{batch_id}       → get batch info + class code
-POST   /api/topics                   → add topic to batch
-PATCH  /api/topics/{topic_id}        → unlock/lock topic
-GET    /api/topics/{batch_id}        → list all topics
-POST   /api/upload                   → parse CSV → insert questions
-GET    /api/instructor/dashboard     → class stats + student scores
-GET    /api/instructor/students/{student_id} → individual student detail
-```
-
-### Student Routes (require_student)
-
-```
-GET    /api/student/dashboard        → unlocked topics + past attempts
-GET    /api/sessions/{session_id}    → session detail + report
-```
-
-### Interview Routes (require_student)
-
-```
-POST   /interview/start              → create session + init LangGraph
-POST   /interview/turn               → send student message + get AI response
-GET    /interview/state/{session_id} → turn count + status (for progress bar)
-```
-
----
-
-## LangGraph Architecture
-
-### InterviewState
-
-```python
-from typing import TypedDict, Literal, Annotated
-from langgraph.graph.message import add_messages
-
-class InterviewState(TypedDict):
-    # Static — set once at session start
-    topic_name: str
-    session_id: str
-    student_id: str
-    questions_remaining: list[dict]    # { question_text, difficulty }
-    past_best_score: int | None        # from previous attempts on same topic
-    past_weak_areas: list[str]         # from previous attempt feedback
-
-    # Dynamic — mutates during session
-    messages: Annotated[list, add_messages]   # last 2-3 turns only
-    conversation_summary: str                  # compressed older turns
-    questions_asked: list[str]                 # prevents repeats
-    student_weak_areas: list[str]             # grows during session
-    turn_count: int
-    awaiting_counter_response: bool           # true after counter-question
-
-    # Terminal — set once at end
-    status: Literal["active", "complete"]
-    score: int | None
-    feedback: dict | None
-```
-
-### Graph Nodes
-
-```
-ask_question
-  Input:  questions_remaining, questions_asked, conversation_summary
-  Action: Pick one question (bias toward difficulty mix)
-          Move to questions_asked
-          Remove from questions_remaining
-  Output: AI message with question
-
-evaluate_answer
-  Input:  last student message, conversation_summary, current question context
-  Action: Silently score: strong | shallow | wrong
-          If shallow → add topic to student_weak_areas
-  Routes:
-    shallow AND awaiting_counter_response=false → counter_question
-    strong OR wrong → check turn count
-    turn_count >= 8 OR questions_remaining empty → generate_report
-    else → ask_question
-    turn_count % 4 == 0 → summarize (then ask_question)
-
-counter_question
-  Input:  last student message + question context
-  Action: Generate ONE probing follow-up (no question bank used)
-          Set awaiting_counter_response=true
-  Output: AI counter-question message
-
-summarize
-  Input:  full messages[]
-  Action: LLM call to compress messages into conversation_summary string
-          Clear messages[] to empty
-          Reset awaiting_counter_response=false
-  Output: Updated summary, empty messages
-
-generate_report
-  Input:  questions_asked, student_weak_areas, conversation_summary, past_best_score
-  Action: LLM call → structured JSON report
-          Write score + feedback to NeonDB interview_sessions
-          Set status: complete
-  Output: { score, summary, concept_score, depth_score, mistakes[], tips[] }
-```
-
-### Graph Flow
-
-```python
-graph.set_entry_point("ask_question")
-
-graph.add_edge("ask_question", "evaluate_answer")
-
-graph.add_conditional_edges("evaluate_answer", route_after_evaluation, {
-    "counter":        "counter_question",
-    "next_question":  "ask_question",
-    "summarize":      "summarize",
-    "end":            "generate_report"
-})
-
-graph.add_edge("counter_question", "evaluate_answer")
-graph.add_edge("summarize", "ask_question")
-graph.add_edge("generate_report", END)
-```
-
-### Checkpointer
-
-```python
-# checkpointer.py
-from langgraph.checkpoint.postgres.aio import AsyncPostgresSaver
-
-async def get_checkpointer():
-    return await AsyncPostgresSaver.from_conn_string(
-        os.getenv("NEON_DB_URL"),
-        schema_name="checkpointer"
-    )
-
-# Called once on app startup
-await checkpointer.setup()
-```
-
-### Thread ID Convention
-
-```python
-# LangGraph uses thread_id to scope checkpointed state
-# Always use session_id (UUID from interview_sessions table) as thread_id
-config = {"configurable": {"thread_id": session_id}}
-```
-
----
-
-## Token Budget Per LLM Call
-
-```
-Node              Tokens sent          Notes
-────────────────────────────────────────────────────────
-ask_question      ~300 fixed           summary + last 2 msgs + topic
-evaluate_answer   ~350 fixed           summary + last 2 msgs + question
-counter_question  ~250 fixed           last exchange only
-summarize         ~600 variable        full messages[] (triggered every 4 turns)
-generate_report   ~400 fixed           summary + weak_areas + questions_asked
-────────────────────────────────────────────────────────
-Max per session   ~700 fixed ceiling   (except summarize turns)
-vs current doc    ~1600+ growing       unbounded
-```
-
----
-
-## System Prompt Structure
-
-```python
-# prompts.py
-
-def build_ask_question_prompt(topic: str, summary: str, asked: list[str]) -> str:
-    # Topic context + summary + which questions asked
-    # Instructs AI to pick next question and ask it naturally
-
-def build_evaluate_prompt(question: str, answer: str, summary: str) -> str:
-    # Evaluates student answer: strong | shallow | wrong
-    # Returns structured JSON: { verdict, weak_area? }
-
-def build_counter_prompt(question: str, answer: str) -> str:
-    # Generates one probing follow-up question
-
-def build_summarize_prompt(messages: list) -> str:
-    # Compresses conversation into 150-word summary
-
-def build_report_prompt(topic: str, asked: list, weak_areas: list,
-                        summary: str, past_score: int | None) -> str:
-    # Generates final structured feedback JSON
-    # Injects past_score for context-aware assessment
-```
-
----
-
-## Session Flow (Complete)
-
-```
-Student clicks topic
-  → POST /interview/start
-  → Create interview_sessions row (status: active)
-  → Fetch questions for topic from NeonDB
-  → Fetch past attempts for this student+topic (for past_best_score)
-  → LangGraph: graph.ainvoke(initial_state, config={thread_id: session_id})
-  → ask_question node runs → returns first question
-  → Response: { session_id, message: "Hi! Let's begin. [First question]" }
-
-Student types answer
-  → POST /interview/turn { session_id, student_message }
-  → FastAPI loads graph state from NeonDB checkpoint via thread_id
-  → Appends student message to state
-  → evaluate_answer node runs → routes to next node
-  → Response: { message, is_counter_q, is_complete, feedback? }
-
-Session ends
-  → generate_report node writes to NeonDB interview_sessions
-  → Response: { is_complete: true, feedback: { score, summary, ... } }
-  → Frontend redirects to /report/{session_id}
-
-Session recovery (tab closed and reopened)
-  → GET /interview/state/{session_id}
-  → LangGraph loads checkpoint from NeonDB
-  → Returns: { status, turn_count, last_message }
-  → Frontend resumes from last state
-```
-
----
-
-## Frontend API Layer
-
-All API calls use the same origin (no CORS needed). Access token sent in every request header.
-
-```typescript
-// api/client.ts — base fetch wrapper
-const API_BASE = ''  // same origin
-
-async function apiFetch(path: string, options?: RequestInit) {
-  const token = useAuthStore.getState().accessToken
-  
-  const res = await fetch(`${API_BASE}${path}`, {
-    ...options,
-    headers: {
-      'Content-Type': 'application/json',
-      'Authorization': `Bearer ${token}`,
-      ...options?.headers,
-    },
-    credentials: 'include',  // for refresh token cookie
-  })
-
-  if (res.status === 401) {
-    // Attempt token refresh
-    await refreshToken()
-    // Retry original request once
-  }
-
-  return res.json()
-}
-```
-
----
-
-## Frontend State Management (Zustand)
-
-```typescript
-// store/authStore.ts
-interface AuthStore {
-  accessToken: string | null
-  user: { id: string, role: string, full_name: string, batch_id: string | null } | null
-  setAuth: (token: string, user: User) => void
-  clearAuth: () => void
-}
-
-// store/interviewStore.ts
-interface InterviewStore {
-  sessionId: string | null
-  messages: Message[]
-  isLoading: boolean
-  isComplete: boolean
-  turnCount: number
-  addMessage: (message: Message) => void
-  setLoading: (v: boolean) => void
-  setComplete: (feedback: Feedback) => void
-  reset: () => void
-}
-```
-
----
-
-## Dockerfile
-
-```dockerfile
-# Stage 1: Build React frontend
-FROM node:20-slim AS frontend-build
-WORKDIR /app/frontend
-COPY frontend/package*.json ./
-RUN npm install
-COPY frontend/ ./
-RUN npm run build
-# Output: /app/frontend/dist
-
-# Stage 2: Python runtime
-FROM python:3.11-slim
-WORKDIR /app
-
-# Install Python dependencies
-COPY backend/requirements.txt .
-RUN pip install --no-cache-dir -r requirements.txt
-
-# Copy FastAPI backend
-COPY backend/ ./backend/
-
-# Copy React static build from Stage 1
-COPY --from=frontend-build /app/frontend/dist ./frontend/dist
-
-# HF Spaces requires port 7860
-EXPOSE 7860
-
-CMD ["uvicorn", "backend.main:app", "--host", "0.0.0.0", "--port", "7860"]
-```
-
----
-
-## FastAPI Entry Point
-
-```python
-# backend/main.py
-from fastapi import FastAPI
-from fastapi.staticfiles import StaticFiles
-from fastapi.middleware.cors import CORSMiddleware
-from contextlib import asynccontextmanager
-
-from routers import auth, batches, topics, sessions, upload, interview
-from checkpointer import get_checkpointer
-from db.connection import init_db_pool
-
-@asynccontextmanager
-async def lifespan(app: FastAPI):
-    # Startup
-    await init_db_pool()
-    checkpointer = await get_checkpointer()
-    await checkpointer.setup()          # creates checkpointer schema + tables
-    app.state.checkpointer = checkpointer
-    yield
-    # Shutdown — cleanup if needed
-
-app = FastAPI(lifespan=lifespan)
-
-# Routers (API routes registered BEFORE static mount)
-app.include_router(auth.router,     prefix="/api/auth")
-app.include_router(batches.router,  prefix="/api/batches")
-app.include_router(topics.router,   prefix="/api/topics")
-app.include_router(sessions.router, prefix="/api/sessions")
-app.include_router(upload.router,   prefix="/api/upload")
-app.include_router(interview.router, prefix="/interview")
-
-# Instructor + student combined dashboard routes
-app.include_router(instructor.router, prefix="/api/instructor")
-app.include_router(student.router,    prefix="/api/student")
-
-# React static build — MUST be last
-app.mount("/", StaticFiles(directory="frontend/dist", html=True), name="static")
-```
-
----
-
-## requirements.txt
-
-```
-fastapi==0.115.0
-uvicorn==0.30.6
-langgraph==0.2.50
-langgraph-checkpoint-postgres==2.0.8
-asyncpg==0.29.0
-python-jose[cryptography]==3.3.0
-bcrypt==4.1.3
-python-multipart==0.0.9
-httpx==0.27.2
-pydantic==2.8.2
-python-dotenv==1.0.1
-```
-
----
-
-## Known Constraints & Decisions
-
-| Decision | Reason |
-|----------|--------|
-| No Supabase/Firebase | Hackathon rules |
-| Custom JWT only | Hackathon rules |
-| React + Vite not Next.js | Single container deployment, no Vercel needed |
-| NeonDB for everything | One DB service, connection pooler handles LangGraph checkpoint writes |
-| Two NeonDB schemas | Clean separation — app data vs graph state |
-| CSV parsed to DB, no file storage | Eliminates need for S3/R2/Cloudinary |
-| Browser calls same origin | No CORS, no latency overhead from proxy hops |
-| LangGraph summarize every 4 turns | Fixed token ceiling ~700/turn regardless of session length |
-| session_id as LangGraph thread_id | Natural scoping, ties graph state to DB session row |
-| Static files mounted last in FastAPI | API routes must be registered before the static catch-all |
-
----
-
-## What Is Not Built (Scope Boundary)
-
-- Voice input (V2)
-- Email notifications (V2)
-- Leaderboard (V2)
-- Certificate generation (V2)
-- Question bank editor UI — use CSV upload only (V2)
-- Dark/light toggle — dark only (V2)
-- Multiple instructors per batch (V3)
-
----
-
-## Architecture Status
+## Environment Variables
 
-> 70% confirmed. Subject to modification during build if constraints change.
-> Update this document if architecture decisions change during the hackathon.
-> Do not rely on the original `ai-interviewmentor-docs.md` for stack or deployment decisions — use this file.
+See `.env.example`. Required: `NEON_DB_URL`, `JWT_SECRET`, `OPENROUTER_API_KEY`, `APP_URL`.
 
----
+## Development Notes
 
-*AI InterviewMentor — Claude Code Reference — Hackathon 2026*
+- Backend package manager is `uv` (not pip). Always use `uv run` or `uv sync`.
+- Frontend uses React 19, TypeScript strict mode (ES2023 target).
+- Many backend routers and frontend components are stubs awaiting implementation — check `docs/tasks.md` for the phase breakdown.
+- Detailed architecture diagrams and DB schema are in `docs/architecture.md`.

README.md

@@ -1,2 +0,0 @@
-# ai-interviewmentor
-Problem It Solves: Training institutes struggle with 1-to-1 instructor-student follow-up at scale. Students learn syllabus topics but can't gauge their actual interview readiness. AI InterviewMentor bridges this gap by letting students take AI-powered mock interviews topic-by-topic — with dynamic counter-questions that simulate real interviews — an

backend/checkpointer.py

@@ -1 +1,53 @@
-# LangGraph AsyncPostgresSaver setup — implemented in Phase 5
+import os
+from urllib.parse import urlparse, urlencode, parse_qs, urlunparse
+
+from psycopg.rows import dict_row
+from psycopg_pool import AsyncConnectionPool
+from langgraph.checkpoint.postgres.aio import AsyncPostgresSaver
+
+_checkpointer: AsyncPostgresSaver | None = None
+_pool: AsyncConnectionPool | None = None
+
+
+def _psycopg_conn_string(url: str) -> str:
+    """
+    Strip parameters psycopg doesn't support (e.g. channel_binding)
+    and ensure sslmode is set to require.
+    """
+    parsed = urlparse(url)
+    params = parse_qs(parsed.query)
+    # Remove unsupported params
+    params.pop("channel_binding", None)
+    # Ensure SSL
+    if "sslmode" not in params:
+        params["sslmode"] = ["require"]
+    new_query = urlencode({k: v[0] for k, v in params.items()})
+    clean = urlunparse(parsed._replace(query=new_query))
+    return clean
+
+
+async def init_checkpointer() -> AsyncPostgresSaver:
+    """
+    Initialize AsyncPostgresSaver backed by a psycopg connection pool.
+    Call once at app startup. The pool stays open for the process lifetime.
+    """
+    global _checkpointer, _pool
+    conn_string = _psycopg_conn_string(os.getenv("NEON_DB_URL", ""))
+
+    _pool = AsyncConnectionPool(
+        conn_string,
+        max_size=5,
+        kwargs={"autocommit": True, "prepare_threshold": 0, "row_factory": dict_row},
+        open=False,
+    )
+    await _pool.open()
+
+    _checkpointer = AsyncPostgresSaver(_pool)
+    await _checkpointer.setup()
+    return _checkpointer
+
+
+def get_checkpointer() -> AsyncPostgresSaver:
+    if _checkpointer is None:
+        raise RuntimeError("Checkpointer not initialized — call init_checkpointer() first")
+    return _checkpointer

backend/db/queries.py

@@ -165,3 +165,119 @@ async def get_question_count_by_topic(topic_id: str) -> int:
             topic_id,
         )
         return result["count"]
+
+
+import json as _json
+
+
+async def get_questions_by_topic(topic_id: str) -> list[asyncpg.Record]:
+    async with get_pool().acquire() as conn:
+        return await conn.fetch(
+            "SELECT * FROM questions WHERE topic_id = $1 ORDER BY created_at ASC",
+            topic_id,
+        )
+
+
+async def get_best_session_by_student_topic(
+    student_id: str, topic_id: str
+) -> Optional[asyncpg.Record]:
+    async with get_pool().acquire() as conn:
+        return await conn.fetchrow(
+            """
+            SELECT * FROM interview_sessions
+            WHERE student_id = $1 AND topic_id = $2 AND status = 'completed'
+            ORDER BY score DESC NULLS LAST
+            LIMIT 1
+            """,
+            student_id, topic_id,
+        )
+
+
+async def create_interview_session(
+    student_id: str, topic_id: str
+) -> asyncpg.Record:
+    async with get_pool().acquire() as conn:
+        return await conn.fetchrow(
+            """
+            INSERT INTO interview_sessions (student_id, topic_id)
+            VALUES ($1, $2)
+            RETURNING *
+            """,
+            student_id, topic_id,
+        )
+
+
+async def update_session_complete(
+    session_id: str, score: int, feedback: dict
+) -> None:
+    async with get_pool().acquire() as conn:
+        await conn.execute(
+            """
+            UPDATE interview_sessions
+            SET status = 'completed', score = $1, feedback = $2::jsonb,
+                completed_at = NOW()
+            WHERE id = $3
+            """,
+            score, _json.dumps(feedback), session_id,
+        )
+
+
+async def get_unlocked_topics_by_batch_id(batch_id: str) -> list[asyncpg.Record]:
+    async with get_pool().acquire() as conn:
+        return await conn.fetch(
+            """
+            SELECT * FROM topics
+            WHERE batch_id = $1 AND is_unlocked = TRUE
+            ORDER BY order_index ASC
+            """,
+            batch_id,
+        )
+
+
+async def get_sessions_by_student_id(student_id: str) -> list[asyncpg.Record]:
+    async with get_pool().acquire() as conn:
+        return await conn.fetch(
+            """
+            SELECT s.*, t.name AS topic_name
+            FROM interview_sessions s
+            JOIN topics t ON s.topic_id = t.id
+            WHERE s.student_id = $1
+            ORDER BY s.started_at DESC
+            """,
+            student_id,
+        )
+
+
+async def get_session_by_id(session_id: str) -> Optional[asyncpg.Record]:
+    async with get_pool().acquire() as conn:
+        return await conn.fetchrow(
+            "SELECT * FROM interview_sessions WHERE id = $1", session_id
+        )
+
+
+async def get_students_by_batch_id(batch_id: str) -> list[asyncpg.Record]:
+    async with get_pool().acquire() as conn:
+        return await conn.fetch(
+            """
+            SELECT id, full_name, email, created_at
+            FROM users
+            WHERE batch_id = $1 AND role = 'student'
+            ORDER BY full_name ASC
+            """,
+            batch_id,
+        )
+
+
+async def get_session_stats_by_student_id(student_id: str) -> asyncpg.Record:
+    async with get_pool().acquire() as conn:
+        return await conn.fetchrow(
+            """
+            SELECT
+                COUNT(*) AS total_sessions,
+                COUNT(*) FILTER (WHERE status = 'completed') AS completed_sessions,
+                ROUND(AVG(score) FILTER (WHERE status = 'completed')) AS avg_score
+            FROM interview_sessions
+            WHERE student_id = $1
+            """,
+            student_id,
+        )

backend/graph/graph.py

@@ -1 +1,46 @@
-# Graph builder and compiler — implemented in Phase 5
+from langgraph.graph import END, StateGraph
+
+from backend.graph.nodes import (
+    ask_question,
+    counter_question,
+    evaluate_answer,
+    generate_report,
+    route_after_evaluation,
+    summarize,
+)
+from backend.graph.state import InterviewState
+
+
+def build_graph(checkpointer):
+    """Compile the interview graph with the given checkpointer. Call once at startup."""
+    builder = StateGraph(InterviewState)
+
+    builder.add_node("ask_question", ask_question)
+    builder.add_node("evaluate_answer", evaluate_answer)
+    builder.add_node("counter_question", counter_question)
+    builder.add_node("summarize", summarize)
+    builder.add_node("generate_report", generate_report)
+
+    builder.set_entry_point("ask_question")
+
+    builder.add_edge("ask_question", "evaluate_answer")
+
+    builder.add_conditional_edges(
+        "evaluate_answer",
+        route_after_evaluation,
+        {
+            "counter": "counter_question",
+            "next_question": "ask_question",
+            "summarize": "summarize",
+            "end": "generate_report",
+        },
+    )
+
+    builder.add_edge("counter_question", "evaluate_answer")
+    builder.add_edge("summarize", "ask_question")
+    builder.add_edge("generate_report", END)
+
+    return builder.compile(
+        checkpointer=checkpointer,
+        interrupt_before=["evaluate_answer"],
+    )

backend/graph/nodes.py

@@ -1 +1,167 @@
-# LangGraph node functions — implemented in Phase 5
+import json
+
+from backend.graph.state import InterviewState
+from backend.llm import call_llm
+from backend.prompts import (
+    build_ask_question_prompt,
+    build_counter_prompt,
+    build_evaluate_prompt,
+    build_report_prompt,
+    build_summarize_prompt,
+)
+from backend.db import queries
+
+
+def _msg_content(msg) -> str:
+    return msg.get("content", "") if isinstance(msg, dict) else getattr(msg, "content", "")
+
+
+def _msg_role(msg) -> str:
+    if isinstance(msg, dict):
+        return msg.get("role", "")
+    name = type(msg).__name__.lower()
+    if "human" in name:
+        return "human"
+    return "assistant"
+
+
+async def ask_question(state: InterviewState) -> dict:
+    remaining = list(state["questions_remaining"])
+    if not remaining:
+        return {}
+
+    question = remaining.pop(0)
+    prompt = build_ask_question_prompt(
+        state["topic_name"],
+        state["conversation_summary"],
+        state["questions_asked"],
+    )
+    response = await call_llm(prompt, max_tokens=200)
+
+    return {
+        "questions_remaining": remaining,
+        "questions_asked": state["questions_asked"] + [question["question_text"]],
+        "messages": [{"role": "assistant", "content": response}],
+        "turn_count": state["turn_count"] + 1,
+        "awaiting_counter_response": False,
+    }
+
+
+async def evaluate_answer(state: InterviewState) -> dict:
+    last_student = next(
+        (m for m in reversed(state["messages"]) if _msg_role(m) == "human"),
+        None,
+    )
+    if not last_student:
+        return {"last_verdict": "wrong"}
+
+    last_question = state["questions_asked"][-1] if state["questions_asked"] else ""
+    prompt = build_evaluate_prompt(
+        last_question,
+        _msg_content(last_student),
+        state["conversation_summary"],
+    )
+    raw = await call_llm(prompt, max_tokens=100)
+
+    try:
+        result = json.loads(raw)
+        verdict = result.get("verdict", "wrong")
+        weak_area = result.get("weak_area")
+    except (json.JSONDecodeError, AttributeError):
+        verdict = "wrong"
+        weak_area = None
+
+    weak_areas = list(state["student_weak_areas"])
+    if verdict == "shallow" and weak_area:
+        weak_areas.append(str(weak_area))
+
+    return {
+        "last_verdict": verdict,
+        "student_weak_areas": weak_areas,
+    }
+
+
+async def counter_question(state: InterviewState) -> dict:
+    last_student = next(
+        (m for m in reversed(state["messages"]) if _msg_role(m) == "human"),
+        None,
+    )
+    last_question = state["questions_asked"][-1] if state["questions_asked"] else ""
+    prompt = build_counter_prompt(
+        last_question,
+        _msg_content(last_student) if last_student else "",
+    )
+    response = await call_llm(prompt, max_tokens=150)
+
+    return {
+        "messages": [{"role": "assistant", "content": response}],
+        "awaiting_counter_response": True,
+        "turn_count": state["turn_count"] + 1,
+    }
+
+
+async def summarize(state: InterviewState) -> dict:
+    prompt = build_summarize_prompt(state["messages"])
+    summary = await call_llm(prompt, max_tokens=200)
+
+    return {
+        "conversation_summary": summary,
+        "messages": [],
+        "awaiting_counter_response": False,
+    }
+
+
+async def generate_report(state: InterviewState) -> dict:
+    prompt = build_report_prompt(
+        state["topic_name"],
+        state["questions_asked"],
+        state["student_weak_areas"],
+        state["conversation_summary"],
+        state["past_best_score"],
+    )
+    raw = await call_llm(prompt, max_tokens=400)
+
+    try:
+        feedback = json.loads(raw)
+        score = int(feedback.get("score", 0))
+    except (json.JSONDecodeError, ValueError, TypeError):
+        feedback = {
+            "score": 0,
+            "summary": raw,
+            "concept_score": 0,
+            "depth_score": 0,
+            "mistakes": [],
+            "tips": [],
+        }
+        score = 0
+
+    await queries.update_session_complete(state["session_id"], score, feedback)
+
+    return {
+        "status": "complete",
+        "score": score,
+        "feedback": feedback,
+        "messages": [{"role": "assistant", "content": feedback.get("summary", "Interview complete.")}],
+    }
+
+
+def route_after_evaluation(state: InterviewState) -> str:
+    """Routing function for conditional edges after evaluate_answer."""
+    verdict = state.get("last_verdict", "wrong")
+    turn_count = state["turn_count"]
+    questions_remaining = state["questions_remaining"]
+    awaiting_counter = state["awaiting_counter_response"]
+
+    # Shallow + not already in counter loop → fire counter question
+    if verdict == "shallow" and not awaiting_counter:
+        return "counter"
+
+    # End conditions (checked before summarize to avoid wasted LLM call)
+    if turn_count >= 8 or not questions_remaining:
+        return "end"
+
+    # Compress memory every 4 turns
+    if turn_count % 4 == 0 and turn_count > 0:
+        return "summarize"
+
+    return "next_question"

backend/graph/state.py

@@ -1 +1,27 @@
-# InterviewState TypedDict — implemented in Phase 5
+from typing import Annotated, Literal, TypedDict
+
+from langgraph.graph.message import add_messages
+
+
+class InterviewState(TypedDict):
+    # Static — set once at session start
+    topic_name: str
+    session_id: str
+    student_id: str
+    questions_remaining: list[dict]        # [{"question_text": str, "difficulty": str}]
+    past_best_score: int | None
+    past_weak_areas: list[str]
+
+    # Dynamic — mutates during session
+    messages: Annotated[list, add_messages]  # appended via reducer
+    conversation_summary: str
+    questions_asked: list[str]
+    student_weak_areas: list[str]
+    turn_count: int
+    awaiting_counter_response: bool
+    last_verdict: str | None               # "strong" | "shallow" | "wrong" | None
+
+    # Terminal — set once at end
+    status: Literal["active", "complete"]
+    score: int | None
+    feedback: dict | None

backend/llm.py

@@ -0,0 +1,26 @@
+import os
+
+import httpx
+
+_OPENROUTER_URL = "https://openrouter.ai/api/v1/chat/completions"
+_MODEL = "google/gemini-2.0-flash-exp:free"
+
+
+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 with httpx.AsyncClient(timeout=60.0) as client:
+        response = await client.post(
+            _OPENROUTER_URL,
+            headers={
+                "Authorization": f"Bearer {api_key}",
+                "Content-Type": "application/json",
+            },
+            json={
+                "model": _MODEL,
+                "messages": messages,
+                "max_tokens": max_tokens,
+            },
+        )
+        response.raise_for_status()
+        return response.json()["choices"][0]["message"]["content"] or ""

backend/main.py

@@ -1,23 +1,41 @@
+import asyncio
+import sys
+
+from dotenv import load_dotenv
+load_dotenv()
+
+# psycopg (used by LangGraph checkpointer) requires SelectorEventLoop on Windows
+if sys.platform == "win32":
+    asyncio.set_event_loop_policy(asyncio.WindowsSelectorEventLoopPolicy())
+
 from contextlib import asynccontextmanager
 
 from fastapi import FastAPI
 
+from backend.checkpointer import init_checkpointer
 from backend.db.connection import init_db_pool
-from backend.routers import auth, batches, topics, upload
+from backend.graph.graph import build_graph
+from backend.routers import auth, batches, instructor, interview, sessions, student, topics, upload
 
 
 @asynccontextmanager
 async def lifespan(app: FastAPI):
     await init_db_pool()
+    checkpointer = await init_checkpointer()
+    app.state.graph = build_graph(checkpointer)
     yield
 
 
 app = FastAPI(lifespan=lifespan)
 
-app.include_router(auth.router, prefix="/api/auth")
-app.include_router(batches.router, prefix="/api/batches")
-app.include_router(topics.router, prefix="/api/topics")
-app.include_router(upload.router, prefix="/api/upload")
+app.include_router(auth.router,        prefix="/api/auth")
+app.include_router(batches.router,     prefix="/api/batches")
+app.include_router(topics.router,      prefix="/api/topics")
+app.include_router(upload.router,      prefix="/api/upload")
+app.include_router(student.router,     prefix="/api/student")
+app.include_router(sessions.router,    prefix="/api/sessions")
+app.include_router(instructor.router,  prefix="/api/instructor")
+app.include_router(interview.router,   prefix="/interview")
 
 # React static build — MUST be last
 # app.mount("/", StaticFiles(directory="frontend/dist", html=True), name="static")

backend/prompts.py

@@ -1 +1,97 @@
-# Prompt builders for all LangGraph nodes — implemented in Phase 5
+def build_ask_question_prompt(
+    topic: str, summary: str, asked: list[str]
+) -> list[dict]:
+    asked_str = "\n".join(f"- {q}" for q in asked) if asked else "None yet."
+    system = (
+        f"You are a technical interview AI conducting a mock interview on: {topic}. "
+        "Ask one clear, focused technical question. "
+        "Do not repeat questions already asked. Be conversational but professional."
+    )
+    user = (
+        f"Conversation summary:\n{summary or 'This is the start of the interview.'}\n\n"
+        f"Questions already asked:\n{asked_str}\n\n"
+        "Ask the next question. Just the question — no numbering, no preamble."
+    )
+    return [{"role": "system", "content": system}, {"role": "user", "content": user}]
+
+
+def build_evaluate_prompt(
+    question: str, answer: str, summary: str
+) -> list[dict]:
+    system = (
+        "You are evaluating a student's answer in a technical interview. "
+        'Respond with ONLY valid JSON: {"verdict": "strong"|"shallow"|"wrong", "weak_area": "topic or null"}\n'
+        "strong = correct and complete. shallow = partially correct, missing depth. "
+        "wrong = incorrect or off-topic."
+    )
+    user = (
+        f"Context: {summary or 'Start of interview.'}\n\n"
+        f"Question: {question}\n"
+        f"Student answer: {answer}\n\n"
+        "Evaluate. Return only the JSON object."
+    )
+    return [{"role": "system", "content": system}, {"role": "user", "content": user}]
+
+
+def build_counter_prompt(question: str, answer: str) -> list[dict]:
+    system = (
+        "You are a technical interviewer. The student gave a shallow answer. "
+        "Ask ONE specific follow-up probing question to dig deeper into what they missed. "
+        "No preamble — just the question."
+    )
+    user = (
+        f"Original question: {question}\n"
+        f"Student's shallow answer: {answer}\n\n"
+        "Ask one targeted follow-up question."
+    )
+    return [{"role": "system", "content": system}, {"role": "user", "content": user}]
+
+
+def build_summarize_prompt(messages: list) -> list[dict]:
+    def _content(m) -> str:
+        return m.get("content", "") if isinstance(m, dict) else getattr(m, "content", "")
+
+    def _role(m) -> str:
+        if isinstance(m, dict):
+            return m.get("role", "unknown")
+        name = type(m).__name__.lower()
+        return "AI" if "ai" in name else "STUDENT"
+
+    transcript = "\n".join(f"{_role(m).upper()}: {_content(m)}" for m in messages)
+    system = (
+        "Summarize this interview transcript in under 150 words. "
+        "Cover: topics discussed, student strengths, weak areas identified."
+    )
+    return [
+        {"role": "system", "content": system},
+        {"role": "user", "content": f"Transcript:\n{transcript}\n\nSummarize:"},
+    ]
+
+
+def build_report_prompt(
+    topic: str,
+    asked: list[str],
+    weak_areas: list[str],
+    summary: str,
+    past_score: int | None,
+) -> list[dict]:
+    past_ctx = (
+        f"Their previous best score on this topic was {past_score}/100."
+        if past_score is not None
+        else "This is their first attempt on this topic."
+    )
+    system = (
+        "Generate a final interview performance report. "
+        "Respond with ONLY valid JSON:\n"
+        '{"score": 0-100, "summary": "string", "concept_score": 0-100, '
+        '"depth_score": 0-100, "mistakes": ["string"], "tips": ["string"]}'
+    )
+    user = (
+        f"Topic: {topic}\n"
+        f"{past_ctx}\n"
+        f"Questions covered: {', '.join(asked) if asked else 'none'}\n"
+        f"Weak areas: {', '.join(weak_areas) if weak_areas else 'none'}\n\n"
+        f"Interview summary:\n{summary or 'No summary available.'}\n\n"
+        "Generate the report JSON."
+    )
+    return [{"role": "system", "content": system}, {"role": "user", "content": user}]

backend/routers/instructor.py

@@ -1,3 +1,57 @@
-from fastapi import APIRouter
+from fastapi import APIRouter, Depends, HTTPException
+
+from backend.auth.deps import require_instructor
+from backend.db import queries
 
 router = APIRouter()
+
+
+@router.get("/students")
+async def list_students(user: dict = Depends(require_instructor)):
+    batch = await queries.get_batch_by_instructor_id(user["user_id"])
+    if not batch:
+        raise HTTPException(404, "No batch found")
+    students = await queries.get_students_by_batch_id(str(batch["id"]))
+    result = []
+    for s in students:
+        stats = await queries.get_session_stats_by_student_id(str(s["id"]))
+        result.append({
+            "id": str(s["id"]),
+            "full_name": s["full_name"],
+            "email": s["email"],
+            "total_sessions": stats["total_sessions"] or 0,
+            "completed_sessions": stats["completed_sessions"] or 0,
+            "avg_score": int(stats["avg_score"]) if stats["avg_score"] is not None else None,
+        })
+    return result
+
+
+@router.get("/students/{student_id}")
+async def get_student_detail(
+    student_id: str,
+    user: dict = Depends(require_instructor),
+):
+    batch = await queries.get_batch_by_instructor_id(user["user_id"])
+    if not batch:
+        raise HTTPException(404, "No batch found")
+    student = await queries.get_user_by_id(student_id)
+    if not student or str(student["batch_id"]) != str(batch["id"]):
+        raise HTTPException(404, "Student not found in your batch")
+    sessions = await queries.get_sessions_by_student_id(student_id)
+    return {
+        "id": str(student["id"]),
+        "full_name": student["full_name"],
+        "email": student["email"],
+        "sessions": [
+            {
+                "id": str(s["id"]),
+                "topic_id": str(s["topic_id"]),
+                "topic_name": s["topic_name"],
+                "status": s["status"],
+                "score": s["score"],
+                "started_at": s["started_at"].isoformat() if s["started_at"] else None,
+                "completed_at": s["completed_at"].isoformat() if s["completed_at"] else None,
+            }
+            for s in sessions
+        ],
+    }

backend/routers/interview.py

@@ -1,3 +1,145 @@
-from fastapi import APIRouter
+import json
+
+from fastapi import APIRouter, Depends, HTTPException, Request
+from pydantic import BaseModel
+
+from backend.auth.deps import require_student
+from backend.db import queries
 
 router = APIRouter()
+
+
+class StartRequest(BaseModel):
+    topic_id: str
+
+
+class TurnRequest(BaseModel):
+    session_id: str
+    student_message: str
+
+
+def _last_ai_message(messages: list) -> str:
+    """Extract content of the last assistant message from a list."""
+    for m in reversed(messages):
+        role = m.get("role", "") if isinstance(m, dict) else getattr(type(m), "__name__", "").lower()
+        content = m.get("content", "") if isinstance(m, dict) else getattr(m, "content", "")
+        if role == "assistant" or "ai" in str(role).lower():
+            return content
+    return ""
+
+
+@router.post("/start")
+async def start_interview(
+    body: StartRequest,
+    request: Request,
+    user: dict = Depends(require_student),
+):
+    topic = await queries.get_topic_by_id(body.topic_id)
+    if not topic:
+        raise HTTPException(404, "Topic not found")
+    if not topic["is_unlocked"]:
+        raise HTTPException(403, "Topic is not unlocked for interviews")
+
+    questions = await queries.get_questions_by_topic(body.topic_id)
+    if not questions:
+        raise HTTPException(400, "No questions available for this topic")
+
+    past = await queries.get_best_session_by_student_topic(user["user_id"], body.topic_id)
+    past_best_score = past["score"] if past else None
+    past_weak_areas: list[str] = []
+    if past and past["feedback"]:
+        fb = past["feedback"] if isinstance(past["feedback"], dict) else json.loads(past["feedback"])
+        past_weak_areas = fb.get("tips", [])
+
+    session = await queries.create_interview_session(user["user_id"], body.topic_id)
+    session_id = str(session["id"])
+
+    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
+        ],
+        "past_best_score": past_best_score,
+        "past_weak_areas": past_weak_areas,
+        "messages": [],
+        "conversation_summary": "",
+        "questions_asked": [],
+        "student_weak_areas": [],
+        "turn_count": 0,
+        "awaiting_counter_response": False,
+        "last_verdict": None,
+        "status": "active",
+        "score": None,
+        "feedback": None,
+    }
+
+    graph = request.app.state.graph
+    config = {"configurable": {"thread_id": session_id}}
+    result = await graph.ainvoke(initial_state, config)
+
+    return {
+        "session_id": session_id,
+        "message": _last_ai_message(result["messages"]),
+    }
+
+
+@router.post("/turn")
+async def interview_turn(
+    body: TurnRequest,
+    request: Request,
+    user: dict = Depends(require_student),
+):
+    session = await queries.get_session_by_id(body.session_id)
+    if not session:
+        raise HTTPException(404, "Session not found")
+    if session["status"] == "completed":
+        raise HTTPException(400, "Session is already complete")
+
+    graph = request.app.state.graph
+    config = {"configurable": {"thread_id": body.session_id}}
+
+    result = await graph.ainvoke(
+        {"messages": [{"role": "human", "content": body.student_message}]},
+        config,
+    )
+
+    is_complete = result.get("status") == "complete"
+    response: dict = {
+        "message": _last_ai_message(result["messages"]),
+        "is_counter_q": result.get("awaiting_counter_response", False),
+        "is_complete": is_complete,
+    }
+    if is_complete:
+        response["feedback"] = result.get("feedback")
+
+    return response
+
+
+@router.get("/state/{session_id}")
+async def get_interview_state(
+    session_id: str,
+    request: Request,
+    user: dict = Depends(require_student),
+):
+    from backend.checkpointer import get_checkpointer
+
+    checkpointer = get_checkpointer()
+    config = {"configurable": {"thread_id": session_id}}
+    checkpoint = await checkpointer.aget(config)
+
+    if not checkpoint:
+        raise HTTPException(404, "Session state not found")
+
+    channel_values = checkpoint.get("channel_values", {})
+    messages = channel_values.get("messages", [])
+
+    last_msg = _last_ai_message(messages) if messages else None
+
+    return {
+        "status": channel_values.get("status", "active"),
+        "turn_count": channel_values.get("turn_count", 0),
+        "last_message": last_msg,
+    }

backend/routers/sessions.py

@@ -1,3 +1,26 @@
-from fastapi import APIRouter
+from fastapi import APIRouter, Depends, HTTPException
+
+from backend.auth.deps import get_current_user
+from backend.db import queries
 
 router = APIRouter()
+
+
+@router.get("/{session_id}")
+async def get_session(session_id: str, user: dict = Depends(get_current_user)):
+    session = await queries.get_session_by_id(session_id)
+    if not session:
+        raise HTTPException(404, "Session not found")
+    # Students can only see their own sessions; instructors can see any
+    if user["role"] == "student" and str(session["student_id"]) != user["user_id"]:
+        raise HTTPException(403, "Access denied")
+    return {
+        "id": str(session["id"]),
+        "topic_id": str(session["topic_id"]),
+        "student_id": str(session["student_id"]),
+        "status": session["status"],
+        "score": session["score"],
+        "feedback": session["feedback"],
+        "started_at": session["started_at"].isoformat() if session["started_at"] else None,
+        "completed_at": session["completed_at"].isoformat() if session["completed_at"] else None,
+    }

backend/routers/student.py

@@ -1,3 +1,39 @@
-from fastapi import APIRouter
+from fastapi import APIRouter, Depends, HTTPException
+
+from backend.auth.deps import require_student
+from backend.db import queries
 
 router = APIRouter()
+
+
+@router.get("/topics")
+async def get_student_topics(user: dict = Depends(require_student)):
+    batch_id = user.get("batch_id")
+    if not batch_id:
+        raise HTTPException(400, "You are not enrolled in a batch")
+    topics = await queries.get_unlocked_topics_by_batch_id(batch_id)
+    return [
+        {
+            "id": str(t["id"]),
+            "name": t["name"],
+            "order_index": t["order_index"],
+        }
+        for t in topics
+    ]
+
+
+@router.get("/sessions")
+async def get_student_sessions(user: dict = Depends(require_student)):
+    sessions = await queries.get_sessions_by_student_id(user["user_id"])
+    return [
+        {
+            "id": str(s["id"]),
+            "topic_id": str(s["topic_id"]),
+            "topic_name": s["topic_name"],
+            "status": s["status"],
+            "score": s["score"],
+            "started_at": s["started_at"].isoformat() if s["started_at"] else None,
+            "completed_at": s["completed_at"].isoformat() if s["completed_at"] else None,
+        }
+        for s in sessions
+    ]

docs/collaboration.md

@@ -0,0 +1,163 @@
+# Collaboration Handoff — AI InterviewMentor
+
+> **READ THIS FIRST** before touching any code.
+> Two developers are working on this project simultaneously using Claude Code.
+> This file tracks what has been done, who owns what, and the exact API contracts each side expects.
+
+---
+
+## Who Owns What
+
+| Area | Owner | Status |
+|------|-------|--------|
+| Phases 1–4 (scaffolding, auth, instructor batch/topics, CSV upload) | Done | ✅ |
+| **Phase 5** — LangGraph backend engine | **Other dev** | 🔄 In progress |
+| Phases 6–9 (student UI, reports, dashboards, analytics) | **This dev** | ✅ Done |
+| Phase 10 — Docker + deploy | Shared | ⏳ Pending |
+
+**Rule**: Do not touch files owned by the other dev without coordinating first.
+
+---
+
+## Phase 5 — What the Backend Must Deliver (Other Dev's Contract)
+
+The frontend (Phases 6–7) is already wired to these endpoints. Do not change the request/response shapes.
+
+### `POST /api/interview/start`
+Request: `{ "topic_id": "<uuid>" }`
+Response: `{ "session_id": "<uuid>", "message": "<first AI question>" }`
+
+Behaviour:
+- Creates a row in `interview_sessions` with `status='active'`
+- Initialises LangGraph state with thread_id = session_id
+- Returns the first AI question as `message`
+
+### `POST /api/interview/turn`
+Request: `{ "session_id": "<uuid>", "answer": "<student text>" }`
+Response: `{ "message": "<AI response or next question>", "turn_count": <int>, "status": "ongoing"|"finished" }`
+
+Behaviour:
+- Appends the student answer + AI response to LangGraph state
+- When interview ends: sets `interview_sessions.status='completed'`, writes `score` and `feedback` JSON
+- Returns `"finished"` status when done (max 8 turns or question bank exhausted)
+
+### `GET /api/interview/state/{session_id}`
+Response:
+```json
+{
+  "id": "<uuid>",
+  "topic_id": "<uuid>",
+  "status": "ongoing|finished",
+  "turn_count": 3,
+  "messages": [{"role": "ai|student", "content": "..."}]
+}
+```
+
+Behaviour: used to resume a session after tab close/reload.
+
+### `feedback` JSONB shape (written to `interview_sessions.feedback`)
+The frontend's `Feedback` type expects:
+```json
+{
+  "score": 82,
+  "summary": "Good understanding of concepts...",
+  "concept_score": 80,
+  "depth_score": 85,
+  "mistakes": ["Missed edge case in X", "..."],
+  "tips": ["Strong on Y", "..."]
+}
+```
+
+---
+
+## Routers Already Registered in `backend/main.py`
+
+```
+/api/auth/*       — auth.router      (signup, login, refresh, logout)
+/api/batches/*    — batches.router   (create, get mine, get by id)
+/api/topics/*     — topics.router    (create, list, unlock/lock)
+/api/upload       — upload.router    (CSV parse + bulk insert)
+/api/student/*    — student.router   (topics for student, sessions list)
+/api/sessions/*   — sessions.router  (get session detail/report)
+/api/instructor/* — instructor.router (student list + detail)
+```
+
+**Phase 5 must also register:**
+```python
+from backend.routers import interview
+app.include_router(interview.router, prefix="/api/interview")
+```
+
+---
+
+## Completed Frontend Files (Do Not Overwrite)
+
+### API Layer (`frontend/src/api/`)
+| File | Functions |
+|------|-----------|
+| `auth.ts` | `login`, `signup`, `logout`, `refreshToken` |
+| `client.ts` | `apiFetch` — returns `Promise<Response>`, auto-refreshes on 401 |
+| `topics.ts` | `getMyBatch`, `createBatch`, `getTopics`, `createTopic`, `setTopicUnlock`, `getStudentTopics`, `getStudentSessions` |
+| `interview.ts` | `startInterview(topicId)`, `sendTurn(sessionId, answer)`, `getInterviewState(sessionId)` |
+| `sessions.ts` | `getSession(sessionId)` |
+| `upload.ts` | `uploadCSV(topicId, file)` |
+| `student.ts` | `getStudentDashboard()` |
+| `instructor.ts` | `getInstructorStudents()`, `getStudentDetail(studentId)` |
+
+### Store (`frontend/src/store/`)
+| File | State |
+|------|-------|
+| `authStore.ts` | `accessToken`, `user`, `setAuth`, `clearAuth` — persisted to localStorage |
+| `interviewStore.ts` | `sessionId`, `messages`, `turnCount`, `status`, `startSession`, `addMessage`, `setTurnCount`, `setStatus`, `reset` |
+
+### Pages (`frontend/src/pages/`)
+All pages implemented: `Login`, `Signup`, `StudentDashboard`, `Interview`, `Report`, `InstructorDashboard`, `Upload`, `StudentDetail`
+
+### Types (`frontend/src/types/index.ts`)
+```ts
+User, AuthResponse, Message, Feedback, InterviewSession, SessionReport, StudentSession, StudentTopic, InstructorStudent, StudentAttempt
+```
+
+---
+
+## Key Patterns to Follow
+
+### apiFetch usage (always check `.ok`):
+```ts
+const res = await apiFetch('/api/something')
+if (!res.ok) {
+  const err = await res.json()
+  throw new Error(err.detail ?? 'Request failed')
+}
+return res.json()
+```
+
+### Tailwind dark theme conventions:
+- Page bg: `bg-gray-950`
+- Card: `bg-gray-900 border border-gray-800 rounded-xl`
+- Input: `bg-gray-800 border border-gray-700 rounded-lg focus:border-indigo-500`
+- Primary button: `bg-indigo-600 hover:bg-indigo-500`
+- Muted text: `text-gray-400`, `text-gray-500`
+
+### Backend router pattern:
+```python
+from fastapi import APIRouter, Depends, HTTPException
+from backend.auth.deps import require_student  # or require_instructor
+from backend.db import queries
+
+router = APIRouter()
+# user dict has: user_id, role, batch_id, email
+```
+
+---
+
+## DB Schema Reference
+
+```
+users          — id, full_name, email, password_hash, role, batch_id, created_at
+batches        — id, name, instructor_id, class_code, created_at
+topics         — id, batch_id, name, is_unlocked, order_index, created_at
+questions      — id, topic_id, question_text, difficulty, created_at
+interview_sessions — id, student_id, topic_id, status('active'|'completed'), score, feedback(JSONB), started_at, completed_at
+refresh_tokens — id, user_id, token_hash, expires_at
+```

docs/question_bank/linear_regression.csv

@@ -0,0 +1,101 @@
+question_text,difficulty
+What is linear regression?,easy
+What is the primary goal of a linear regression model?,easy
+What is the difference between simple and multiple linear regression?,easy
+How do you define the dependent variable in a regression problem?,easy
+What are independent variables or features?,easy
+What does the slope represent in a simple linear regression equation?,easy
+What does the y-intercept represent in a linear model?,easy
+Can linear regression be used for classification tasks?,easy
+What is a line of best fit?,easy
+What is the difference between a parameter and a hyperparameter in this context?,easy
+What is an error term or residual?,easy
+How do you calculate a residual?,easy
+Why do we square the residuals when calculating the cost function?,easy
+What is the most common cost function used in linear regression?,easy
+What does OLS stand for?,easy
+What is the R-squared metric?,easy
+What is the range of possible values for R-squared?,easy
+Can R-squared ever be negative?,easy
+What does an R-squared of 1.0 indicate?,easy
+What does an R-squared of 0.0 indicate?,easy
+What are the four primary assumptions of linear regression?,medium
+What does the assumption of linearity mean?,medium
+How can you check if the linearity assumption holds true?,medium
+What is homoscedasticity?,medium
+What is heteroscedasticity and why is it a problem?,medium
+How do you test for homoscedasticity?,medium
+What does the assumption of independence of errors mean?,medium
+What is autocorrelation?,medium
+How can you test for autocorrelation in your residuals?,medium
+What does the normality of residuals assumption mean?,medium
+Is it necessary for the independent variables to be normally distributed?,medium
+How can you verify that your residuals are normally distributed?,medium
+What is multicollinearity?,medium
+Why is multicollinearity an issue for linear regression?,medium
+How do you detect multicollinearity?,medium
+What is the Variance Inflation Factor?,medium
+What VIF score indicates severe multicollinearity?,medium
+How do you resolve high multicollinearity in your dataset?,medium
+What is the difference between R-squared and Adjusted R-squared?,medium
+Why is Adjusted R-squared preferred when using multiple features?,medium
+What is Mean Absolute Error?,medium
+What is Mean Squared Error?,medium
+What is Root Mean Squared Error?,medium
+When would you prefer MAE over RMSE?,medium
+When would you prefer RMSE over MAE?,medium
+How do outliers affect a linear regression model?,medium
+How can you identify outliers in your dataset?,medium
+What are leverage points?,medium
+What is Cook's Distance used for?,medium
+How do you handle categorical variables in linear regression?,medium
+What is one-hot encoding?,medium
+What is the dummy variable trap?,medium
+How do you avoid the dummy variable trap?,medium
+Can you use ordinal encoding for linear regression features?,medium
+How does feature scaling affect linear regression?,medium
+Is feature scaling strictly required for Ordinary Least Squares?,medium
+When is feature scaling absolutely necessary for linear regression?,medium
+What is a baseline model in regression?,medium
+How do you interpret a negative coefficient in your model?,medium
+What does a coefficient close to zero imply?,medium
+How do you derive the normal equation?,hard
+What is the mathematical formula for the normal equation?,hard
+What is the computational complexity of the normal equation?,hard
+Why might the normal equation fail?,hard
+What is a singular matrix and how does it relate to OLS?,hard
+How does gradient descent optimize a linear regression model?,hard
+What is the learning rate in gradient descent?,hard
+What happens if your learning rate is too high?,hard
+What happens if your learning rate is too low?,hard
+What is the difference between batch and stochastic gradient descent?,hard
+What is polynomial regression?,hard
+Is polynomial regression a linear or non-linear model?,hard
+How do interaction terms work in a regression model?,hard
+What is the bias-variance tradeoff?,hard
+How does adding more features affect bias and variance?,hard
+What is overfitting in the context of linear regression?,hard
+How do you detect overfitting?,hard
+What is underfitting?,hard
+What is regularization?,hard
+How does Ridge regression differ from standard linear regression?,hard
+What penalty term does Ridge regression use?,hard
+How does Lasso regression differ from Ridge regression?,hard
+What penalty term does Lasso regression use?,hard
+Why does Lasso regression tend to produce sparse models?,hard
+What is Elastic Net regularization?,hard
+When would you choose Elastic Net over Lasso or Ridge?,hard
+How do you tune the regularization hyperparameter?,hard
+What is cross-validation and why is it used?,hard
+What happens to Ridge coefficients as the penalty term approaches infinity?,hard
+What happens to Lasso coefficients as the penalty term approaches infinity?,hard
+Can linear regression handle non-linear relationships without polynomial features?,hard
+How would you implement gradient descent for linear regression from scratch in Python?,hard
+What is the difference between a confidence interval and a prediction interval?,hard
+How do you handle missing data before training a linear model?,hard
+What is the curse of dimensionality?,hard
+How does Principal Component Analysis relate to linear regression?,hard
+What is Principal Component Regression?,hard
+What are generalized linear models?,hard
+How do you interpret the intercept when all features are mean-centered?,hard
+What would you do if you have more features than observations?,hard

frontend/src/api/instructor.ts

@@ -0,0 +1,24 @@
+import { apiFetch } from './client'
+import type { InstructorStudent, StudentAttempt } from '../types'
+
+export interface StudentDetail {
+  id: string
+  full_name: string
+  email: string
+  sessions: StudentAttempt[]
+}
+
+export async function getInstructorStudents(): Promise<InstructorStudent[]> {
+  const res = await apiFetch('/api/instructor/students')
+  if (!res.ok) {
+    const err = await res.json()
+    throw new Error(err.detail ?? 'Failed to load students')
+  }
+  return res.json()
+}
+
+export async function getStudentDetail(studentId: string): Promise<StudentDetail> {
+  const res = await apiFetch(`/api/instructor/students/${studentId}`)
+  if (!res.ok) throw new Error('Failed to load student')
+  return res.json()
+}

frontend/src/api/interview.ts

@@ -1 +1,38 @@
-// Interview API calls — implemented in Phase 6
+import { apiFetch } from './client'
+
+export async function startInterview(
+  topicId: string,
+): Promise<{ session_id: string; message: string }> {
+  const res = await apiFetch('/interview/start', {
+    method: 'POST',
+    body: JSON.stringify({ topic_id: topicId }),
+  })
+  if (!res.ok) {
+    const err = await res.json()
+    throw new Error(err.detail ?? 'Failed to start interview')
+  }
+  return res.json()
+}
+
+export async function sendTurn(
+  sessionId: string,
+  studentMessage: string,
+): Promise<{ message: string; is_counter_q: boolean; is_complete: boolean; feedback?: object }> {
+  const res = await apiFetch('/interview/turn', {
+    method: 'POST',
+    body: JSON.stringify({ session_id: sessionId, student_message: studentMessage }),
+  })
+  if (!res.ok) {
+    const err = await res.json()
+    throw new Error(err.detail ?? 'Failed to send answer')
+  }
+  return res.json()
+}
+
+export async function getInterviewState(
+  sessionId: string,
+): Promise<{ status: string; turn_count: number; last_message: string | null }> {
+  const res = await apiFetch(`/interview/state/${sessionId}`)
+  if (!res.ok) throw new Error('Failed to load session')
+  return res.json()
+}

frontend/src/api/sessions.ts

@@ -1 +1,8 @@
-// Sessions API calls — implemented in Phase 7
+import { apiFetch } from './client'
+import type { SessionReport } from '../types'
+
+export async function getSession(sessionId: string): Promise<SessionReport> {
+  const res = await apiFetch(`/api/sessions/${sessionId}`)
+  if (!res.ok) throw new Error('Failed to load report')
+  return res.json()
+}

frontend/src/api/student.ts

@@ -0,0 +1,17 @@
+import { apiFetch } from './client'
+import type { StudentTopic, StudentSession } from '../types'
+
+export async function getStudentTopics(): Promise<StudentTopic[]> {
+  const res = await apiFetch('/api/student/topics')
+  if (!res.ok) {
+    const err = await res.json()
+    throw new Error(err.detail ?? 'Failed to load topics')
+  }
+  return res.json()
+}
+
+export async function getStudentSessions(): Promise<StudentSession[]> {
+  const res = await apiFetch('/api/student/sessions')
+  if (!res.ok) throw new Error('Failed to load sessions')
+  return res.json()
+}

frontend/src/components/instructor/GapReport.tsx

@@ -1,3 +1,41 @@
-export default function GapReport() {
-  return <div>GapReport</div>
+import type { StudentAttempt } from '../../types'
+
+interface Props {
+  sessions: StudentAttempt[]
+}
+
+export default function GapReport({ sessions }: Props) {
+  const completed = sessions.filter((s) => s.status === 'completed' && s.score != null)
+
+  if (completed.length === 0) {
+    return null
+  }
+
+  // Find topics with low scores (below 60)
+  const weakTopics = completed
+    .filter((s) => (s.score ?? 100) < 60)
+    .sort((a, b) => (a.score ?? 0) - (b.score ?? 0))
+
+  if (weakTopics.length === 0) {
+    return (
+      <div className="bg-green-950/30 border border-green-800/50 rounded-xl px-5 py-4">
+        <p className="text-green-400 text-sm font-medium">No significant gaps detected.</p>
+        <p className="text-gray-500 text-xs mt-1">All topics scored above 60.</p>
+      </div>
+    )
+  }
+
+  return (
+    <div className="bg-gray-900 border border-gray-800 rounded-xl p-5">
+      <h3 className="text-sm font-semibold text-red-400 mb-3">Knowledge Gaps</h3>
+      <div className="space-y-2">
+        {weakTopics.map((s) => (
+          <div key={s.id} className="flex items-center justify-between">
+            <p className="text-sm text-gray-300">{s.topic_name}</p>
+            <span className="text-sm font-semibold text-red-400">{s.score}/100</span>
+          </div>
+        ))}
+      </div>
+    </div>
+  )
 }

frontend/src/components/instructor/StudentRow.tsx

@@ -1,3 +1,46 @@
-export default function StudentRow() {
-  return <div>StudentRow</div>
+import { useNavigate } from 'react-router-dom'
+import type { InstructorStudent } from '../../types'
+
+interface Props {
+  student: InstructorStudent
+}
+
+export default function StudentRow({ student }: Props) {
+  const navigate = useNavigate()
+
+  const scoreColor =
+    student.avg_score == null
+      ? 'text-gray-500'
+      : student.avg_score >= 70
+        ? 'text-green-400'
+        : student.avg_score >= 40
+          ? 'text-yellow-400'
+          : 'text-red-400'
+
+  return (
+    <div className="flex items-center justify-between px-5 py-4 bg-gray-800/50 rounded-lg">
+      <div>
+        <p className="text-white font-medium">{student.full_name}</p>
+        <p className="text-gray-500 text-xs mt-0.5">{student.email}</p>
+      </div>
+      <div className="flex items-center gap-6">
+        <div className="text-center">
+          <p className="text-white font-semibold">{student.completed_sessions}</p>
+          <p className="text-gray-500 text-xs">Interviews</p>
+        </div>
+        <div className="text-center">
+          <p className={`font-semibold ${scoreColor}`}>
+            {student.avg_score ?? '—'}
+          </p>
+          <p className="text-gray-500 text-xs">Avg score</p>
+        </div>
+        <button
+          onClick={() => navigate(`/instructor/students/${student.id}`)}
+          className="text-sm text-indigo-400 hover:text-indigo-300 transition-colors"
+        >
+          Detail →
+        </button>
+      </div>
+    </div>
+  )
 }

frontend/src/components/interview/ChatWindow.tsx

@@ -1,3 +1,34 @@
-export default function ChatWindow() {
-  return <div>ChatWindow</div>
+import { useEffect, useRef } from 'react'
+import type { Message } from '../../types'
+import MessageBubble from './MessageBubble'
+
+interface Props {
+  messages: Message[]
+  loading: boolean
+}
+
+export default function ChatWindow({ messages, loading }: Props) {
+  const bottomRef = useRef<HTMLDivElement>(null)
+
+  useEffect(() => {
+    bottomRef.current?.scrollIntoView({ behavior: 'smooth' })
+  }, [messages, loading])
+
+  return (
+    <div className="flex-1 overflow-y-auto px-4 py-4 space-y-3">
+      {messages.map((msg, i) => (
+        <MessageBubble key={i} message={msg} />
+      ))}
+      {loading && (
+        <div className="flex justify-start">
+          <div className="bg-gray-800 rounded-2xl rounded-tl-sm px-4 py-3 flex gap-1 items-center">
+            <span className="w-2 h-2 bg-gray-400 rounded-full animate-bounce [animation-delay:0ms]" />
+            <span className="w-2 h-2 bg-gray-400 rounded-full animate-bounce [animation-delay:150ms]" />
+            <span className="w-2 h-2 bg-gray-400 rounded-full animate-bounce [animation-delay:300ms]" />
+          </div>
+        </div>
+      )}
+      <div ref={bottomRef} />
+    </div>
+  )
 }

frontend/src/components/interview/MessageBubble.tsx

@@ -1,3 +1,23 @@
-export default function MessageBubble() {
-  return <div>MessageBubble</div>
+import type { Message } from '../../types'
+
+interface Props {
+  message: Message
+}
+
+export default function MessageBubble({ message }: Props) {
+  const isAI = message.role === 'ai'
+
+  return (
+    <div className={`flex ${isAI ? 'justify-start' : 'justify-end'}`}>
+      <div
+        className={`max-w-[75%] rounded-2xl px-4 py-3 text-sm leading-relaxed whitespace-pre-wrap ${
+          isAI
+            ? 'bg-gray-800 text-white rounded-tl-sm'
+            : 'bg-indigo-600 text-white rounded-tr-sm'
+        }`}
+      >
+        {message.content}
+      </div>
+    </div>
+  )
 }

frontend/src/components/interview/ProgressBar.tsx

@@ -1,3 +1,23 @@
-export default function ProgressBar() {
-  return <div>ProgressBar</div>
+interface Props {
+  current: number
+  max: number
+}
+
+export default function ProgressBar({ current, max }: Props) {
+  const pct = Math.min((current / max) * 100, 100)
+
+  return (
+    <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>
+      </div>
+      <div className="h-1.5 bg-gray-800 rounded-full overflow-hidden">
+        <div
+          className="h-full bg-indigo-500 rounded-full transition-all duration-500"
+          style={{ width: `${pct}%` }}
+        />
+      </div>
+    </div>
+  )
 }

frontend/src/components/interview/TypeInput.tsx

@@ -1,3 +1,58 @@
-export default function TypeInput() {
-  return <div>TypeInput</div>
+import { useState, useRef, type KeyboardEvent } from 'react'
+
+interface Props {
+  onSend: (text: string) => void
+  disabled: boolean
+}
+
+export default function TypeInput({ onSend, disabled }: Props) {
+  const [text, setText] = useState('')
+  const textareaRef = useRef<HTMLTextAreaElement>(null)
+
+  function handleKeyDown(e: KeyboardEvent<HTMLTextAreaElement>) {
+    if (e.key === 'Enter' && !e.shiftKey) {
+      e.preventDefault()
+      submit()
+    }
+  }
+
+  function submit() {
+    const trimmed = text.trim()
+    if (!trimmed || disabled) return
+    onSend(trimmed)
+    setText('')
+    if (textareaRef.current) {
+      textareaRef.current.style.height = 'auto'
+    }
+  }
+
+  function handleInput() {
+    const el = textareaRef.current
+    if (!el) return
+    el.style.height = 'auto'
+    el.style.height = `${Math.min(el.scrollHeight, 120)}px`
+  }
+
+  return (
+    <div className="border-t border-gray-800 px-4 py-3 flex gap-3 items-end">
+      <textarea
+        ref={textareaRef}
+        rows={1}
+        value={text}
+        onChange={(e) => setText(e.target.value)}
+        onKeyDown={handleKeyDown}
+        onInput={handleInput}
+        disabled={disabled}
+        placeholder="Type your answer… (Enter to send, Shift+Enter for newline)"
+        className="flex-1 bg-gray-800 border border-gray-700 rounded-xl px-4 py-2 text-white placeholder-gray-500 text-sm resize-none focus:outline-none focus:border-indigo-500 disabled:opacity-50"
+      />
+      <button
+        onClick={submit}
+        disabled={disabled || !text.trim()}
+        className="bg-indigo-600 hover:bg-indigo-500 disabled:opacity-40 text-white rounded-xl px-4 py-2 text-sm font-medium transition-colors shrink-0"
+      >
+        Send
+      </button>
+    </div>
+  )
 }

frontend/src/components/report/FeedbackCard.tsx

@@ -1,3 +1,30 @@
-export default function FeedbackCard() {
-  return <div>FeedbackCard</div>
+interface Props {
+  title: string
+  items: string[]
+  variant: 'positive' | 'negative'
+}
+
+export default function FeedbackCard({ title, items, variant }: Props) {
+  const borderColor = variant === 'positive' ? 'border-green-500' : 'border-red-500'
+  const titleColor = variant === 'positive' ? 'text-green-400' : 'text-red-400'
+
+  return (
+    <div className={`bg-gray-900 border border-gray-800 border-l-4 ${borderColor} rounded-xl p-4`}>
+      <h3 className={`text-sm font-semibold mb-3 ${titleColor}`}>{title}</h3>
+      {items.length === 0 ? (
+        <p className="text-gray-500 text-sm">None noted.</p>
+      ) : (
+        <ul className="space-y-1.5">
+          {items.map((item, i) => (
+            <li key={i} className="text-sm text-gray-300 flex gap-2">
+              <span className={`mt-0.5 shrink-0 ${variant === 'positive' ? 'text-green-500' : 'text-red-500'}`}>
+                {variant === 'positive' ? '✓' : '✗'}
+              </span>
+              {item}
+            </li>
+          ))}
+        </ul>
+      )}
+    </div>
+  )
 }

frontend/src/components/report/ScoreRing.tsx

@@ -1,3 +1,36 @@
-export default function ScoreRing() {
-  return <div>ScoreRing</div>
+interface Props {
+  score: number
+}
+
+export default function ScoreRing({ score }: Props) {
+  const radius = 54
+  const circumference = 2 * Math.PI * radius
+  const filled = circumference - (score / 100) * circumference
+
+  const color =
+    score >= 70 ? '#22c55e' : score >= 40 ? '#eab308' : '#ef4444'
+
+  return (
+    <div className="relative inline-flex items-center justify-center">
+      <svg width="140" height="140" className="-rotate-90">
+        <circle cx="70" cy="70" r={radius} fill="none" stroke="#1f2937" strokeWidth="10" />
+        <circle
+          cx="70"
+          cy="70"
+          r={radius}
+          fill="none"
+          stroke={color}
+          strokeWidth="10"
+          strokeDasharray={circumference}
+          strokeDashoffset={filled}
+          strokeLinecap="round"
+          className="transition-all duration-700"
+        />
+      </svg>
+      <div className="absolute flex flex-col items-center rotate-0">
+        <span className="text-3xl font-bold text-white">{score}</span>
+        <span className="text-xs text-gray-400">/ 100</span>
+      </div>
+    </div>
+  )
 }

frontend/src/components/report/SummaryBlock.tsx

@@ -1,3 +1,12 @@
-export default function SummaryBlock() {
-  return <div>SummaryBlock</div>
+interface Props {
+  summary: string
+}
+
+export default function SummaryBlock({ summary }: Props) {
+  return (
+    <div className="bg-gray-900 border border-gray-800 rounded-xl p-4">
+      <h3 className="text-sm font-semibold text-gray-400 mb-2">Summary</h3>
+      <p className="text-sm text-gray-200 leading-relaxed">{summary}</p>
+    </div>
+  )
 }

frontend/src/components/student/AttemptRow.tsx

@@ -1,3 +1,51 @@
-export default function AttemptRow() {
-  return <div>AttemptRow</div>
+import { useNavigate } from 'react-router-dom'
+import type { StudentSession } from '../../types'
+
+interface Props {
+  session: StudentSession
+}
+
+function formatDate(iso: string | null): string {
+  if (!iso) return '—'
+  return new Date(iso).toLocaleDateString(undefined, { month: 'short', day: 'numeric', year: 'numeric' })
+}
+
+export default function AttemptRow({ session }: Props) {
+  const navigate = useNavigate()
+  const isCompleted = session.status === 'completed'
+
+  const scoreColor =
+    session.score == null
+      ? 'text-gray-500'
+      : session.score >= 70
+        ? 'text-green-400'
+        : session.score >= 40
+          ? 'text-yellow-400'
+          : 'text-red-400'
+
+  return (
+    <div className="flex items-center justify-between bg-gray-900 border border-gray-800 rounded-xl px-5 py-4">
+      <div>
+        <p className="text-white font-medium">{session.topic_name}</p>
+        <p className="text-gray-500 text-xs mt-0.5">{formatDate(session.started_at)}</p>
+      </div>
+      <div className="flex items-center gap-4">
+        <span className={`text-lg font-semibold ${scoreColor}`}>
+          {isCompleted && session.score != null ? session.score : '—'}
+        </span>
+        {isCompleted ? (
+          <button
+            onClick={() => navigate(`/student/report/${session.id}`)}
+            className="text-sm text-indigo-400 hover:text-indigo-300 transition-colors"
+          >
+            Report
+          </button>
+        ) : (
+          <span className="text-xs text-yellow-500 bg-yellow-900/30 px-2 py-1 rounded-full">
+            In progress
+          </span>
+        )}
+      </div>
+    </div>
+  )
 }

frontend/src/components/student/TopicChip.tsx

@@ -1,3 +1,23 @@
-export default function TopicChip() {
-  return <div>TopicChip</div>
+import type { StudentTopic } from '../../types'
+
+interface Props {
+  topic: StudentTopic
+  onStart: (topic: StudentTopic) => void
+}
+
+export default function TopicChip({ topic, onStart }: Props) {
+  return (
+    <div className="bg-gray-900 border border-gray-800 rounded-xl px-5 py-4 flex items-center justify-between">
+      <div>
+        <p className="text-white font-medium">{topic.name}</p>
+        <p className="text-gray-500 text-xs mt-0.5">Topic {topic.order_index + 1}</p>
+      </div>
+      <button
+        onClick={() => onStart(topic)}
+        className="bg-indigo-600 hover:bg-indigo-500 text-white text-sm font-medium px-4 py-1.5 rounded-lg transition-colors"
+      >
+        Start
+      </button>
+    </div>
+  )
 }

frontend/src/pages/InstructorDashboard.tsx

@@ -2,15 +2,19 @@ import { useState, useEffect, type FormEvent } from 'react'
 import { useNavigate } from 'react-router-dom'
 import Navbar from '../components/shared/Navbar'
 import StatCard from '../components/instructor/StatCard'
+import StudentRow from '../components/instructor/StudentRow'
 import {
   getMyBatch, createBatch, getTopics, createTopic, setTopicUnlock,
   type Batch, type Topic,
 } from '../api/topics'
+import { getInstructorStudents } from '../api/instructor'
+import type { InstructorStudent } from '../types'
 
 export default function InstructorDashboard() {
   const navigate = useNavigate()
   const [batch, setBatch] = useState<Batch | null>(null)
   const [topics, setTopics] = useState<Topic[]>([])
+  const [students, setStudents] = useState<InstructorStudent[]>([])
   const [batchName, setBatchName] = useState('')
   const [newTopicName, setNewTopicName] = useState('')
   const [loading, setLoading] = useState(true)
@@ -20,8 +24,9 @@ export default function InstructorDashboard() {
     getMyBatch()
       .then(async (b) => {
         setBatch(b)
-        const t = await getTopics(b.id)
+        const [t, s] = await Promise.all([getTopics(b.id), getInstructorStudents()])
         setTopics(t)
+        setStudents(s)
       })
       .catch(() => { /* 404 = no batch yet */ })
       .finally(() => setLoading(false))
@@ -114,12 +119,13 @@ export default function InstructorDashboard() {
             </div>
 
             {/* ── Stats row ── */}
-            <div className="grid grid-cols-2 gap-4 mb-6">
+            <div className="grid grid-cols-3 gap-4 mb-6">
               <StatCard label="Topics" value={topics.length} />
               <StatCard
                 label="Questions"
                 value={topics.reduce((sum, t) => sum + t.question_count, 0)}
               />
+              <StatCard label="Students" value={students.length} />
             </div>
 
             {/* ── Topic list ── */}
@@ -184,6 +190,18 @@ export default function InstructorDashboard() {
               </form>
               {error && <p className="text-red-400 text-sm mt-2">{error}</p>}
             </div>
+
+            {/* ── Students analytics ── */}
+            {students.length > 0 && (
+              <div className="bg-gray-900 border border-gray-800 rounded-xl p-6 mt-6">
+                <h2 className="text-lg font-semibold text-white mb-4">Students</h2>
+                <div className="space-y-2">
+                  {students.map((s) => (
+                    <StudentRow key={s.id} student={s} />
+                  ))}
+                </div>
+              </div>
+            )}
           </>
         )}
       </div>

frontend/src/pages/Interview.tsx

@@ -1,3 +1,131 @@
+import { useEffect, useState } from 'react'
+import { useParams, useLocation, useNavigate } from 'react-router-dom'
+import { useInterviewStore } from '../store/interviewStore'
+import { startInterview, sendTurn, getInterviewState } from '../api/interview'
+import ChatWindow from '../components/interview/ChatWindow'
+import TypeInput from '../components/interview/TypeInput'
+import ProgressBar from '../components/interview/ProgressBar'
+import Navbar from '../components/shared/Navbar'
+
 export default function Interview() {
-  return <div>Interview</div>
+  const { sessionId } = useParams<{ sessionId?: string }>()
+  const location = useLocation()
+  const navigate = useNavigate()
+
+  const { messages, turnCount, maxTurns, status, startSession, addMessage, setTurnCount, setStatus } =
+    useInterviewStore()
+
+  const [error, setError] = useState('')
+
+  // On mount: resume existing session or start new one
+  useEffect(() => {
+    if (sessionId && status === 'idle') {
+      resumeSession(sessionId)
+    } else if (!sessionId && status === 'idle') {
+      // topicId must be passed via location.state from StudentDashboard
+      const topicId: string | undefined = (location.state as { topicId?: string })?.topicId
+      if (topicId) {
+        handleStart(topicId)
+      }
+    }
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [])
+
+  async function resumeSession(id: string) {
+    setStatus('loading')
+    try {
+      const state = await getInterviewState(id)
+      // Restore last AI message so the student sees where they left off
+      if (state.last_message) {
+        startSession(id, '', state.last_message)
+      }
+      setTurnCount(state.turn_count)
+      setStatus(state.status === 'complete' ? 'finished' : 'waiting')
+    } catch {
+      setError('Could not resume session.')
+      setStatus('idle')
+    }
+  }
+
+  async function handleStart(topicId: string) {
+    setStatus('loading')
+    setError('')
+    try {
+      const data = await startInterview(topicId)
+      startSession(data.session_id, topicId, data.message)
+      // Update URL to include session id without triggering re-mount
+      navigate(`/student/interview/${data.session_id}`, { replace: true, state: location.state })
+    } catch {
+      setError('Failed to start interview. Please try again.')
+      setStatus('idle')
+    }
+  }
+
+  async function handleSend(answer: string) {
+    if (!useInterviewStore.getState().sessionId) return
+    const currentSessionId = useInterviewStore.getState().sessionId!
+
+    addMessage({ role: 'student', content: answer })
+    setStatus('loading')
+    setError('')
+
+    try {
+      const data = await sendTurn(currentSessionId, answer)
+      addMessage({ role: 'ai', content: data.message })
+
+      if (data.is_complete) {
+        setStatus('finished')
+      } else {
+        setStatus('waiting')
+      }
+    } catch {
+      setError('Failed to send answer. Please try again.')
+      setStatus('waiting')
+    }
+  }
+
+  const isLoading = status === 'loading'
+  const isFinished = status === 'finished'
+  const currentSessionId = useInterviewStore.getState().sessionId
+
+  return (
+    <div className="min-h-screen bg-gray-950 flex flex-col">
+      <Navbar />
+
+      <div className="flex-1 flex flex-col max-w-3xl mx-auto w-full">
+        <ProgressBar current={turnCount} max={maxTurns} />
+
+        {/* No topic selected and no session — prompt user */}
+        {status === 'idle' && !sessionId && (
+          <div className="flex-1 flex items-center justify-center text-gray-500">
+            Select a topic from the dashboard to start.
+          </div>
+        )}
+
+        {status !== 'idle' && (
+          <ChatWindow messages={messages} loading={isLoading} />
+        )}
+
+        {error && (
+          <p className="text-red-400 text-sm text-center py-2">{error}</p>
+        )}
+
+        {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>
+        ) : (
+          status !== 'idle' && (
+            <TypeInput onSend={handleSend} disabled={isLoading} />
+          )
+        )}
+      </div>
+    </div>
+  )
 }

frontend/src/pages/Report.tsx

@@ -1,3 +1,98 @@
+import { useEffect, useState } from 'react'
+import { useParams, useNavigate } from 'react-router-dom'
+import { getSession } from '../api/sessions'
+import type { SessionReport } from '../types'
+import ScoreRing from '../components/report/ScoreRing'
+import FeedbackCard from '../components/report/FeedbackCard'
+import SummaryBlock from '../components/report/SummaryBlock'
+import Navbar from '../components/shared/Navbar'
+
 export default function Report() {
-  return <div>Report</div>
+  const { sessionId } = useParams<{ sessionId: string }>()
+  const navigate = useNavigate()
+
+  const [report, setReport] = useState<SessionReport | null>(null)
+  const [loading, setLoading] = useState(true)
+  const [error, setError] = useState('')
+
+  useEffect(() => {
+    if (!sessionId) return
+    getSession(sessionId)
+      .then(setReport)
+      .catch(() => setError('Could not load report.'))
+      .finally(() => setLoading(false))
+  }, [sessionId])
+
+  return (
+    <div className="min-h-screen bg-gray-950">
+      <Navbar />
+
+      <div className="max-w-2xl mx-auto px-4 py-8 space-y-6">
+        {loading && (
+          <div className="space-y-4">
+            {[...Array(4)].map((_, i) => (
+              <div key={i} className="h-24 bg-gray-900 rounded-xl animate-pulse" />
+            ))}
+          </div>
+        )}
+
+        {error && (
+          <div className="bg-gray-900 border border-gray-800 rounded-xl p-6 text-center text-red-400 text-sm">
+            {error}
+          </div>
+        )}
+
+        {report && (
+          <>
+            {/* Header */}
+            <div className="bg-gray-900 border border-gray-800 rounded-xl p-6 flex items-center justify-between">
+              <div>
+                <p className="text-xs text-gray-500 uppercase tracking-wide mb-1">Interview Report</p>
+                <h1 className="text-xl font-semibold text-white">Topic {report.topic_id}</h1>
+              </div>
+              <ScoreRing score={report.score} />
+            </div>
+
+            {/* Summary */}
+            <SummaryBlock summary={report.feedback.summary} />
+
+            {/* Feedback cards */}
+            <div className="grid grid-cols-1 sm:grid-cols-2 gap-4">
+              <FeedbackCard
+                title="Strengths"
+                items={report.feedback.tips}
+                variant="positive"
+              />
+              <FeedbackCard
+                title="Areas to Improve"
+                items={report.feedback.mistakes}
+                variant="negative"
+              />
+            </div>
+
+            {/* Sub-scores */}
+            <div className="bg-gray-900 border border-gray-800 rounded-xl p-4 flex gap-6">
+              <div className="flex-1 text-center">
+                <p className="text-2xl font-bold text-white">{report.feedback.concept_score}</p>
+                <p className="text-xs text-gray-500 mt-1">Concept Score</p>
+              </div>
+              <div className="w-px bg-gray-800" />
+              <div className="flex-1 text-center">
+                <p className="text-2xl font-bold text-white">{report.feedback.depth_score}</p>
+                <p className="text-xs text-gray-500 mt-1">Depth Score</p>
+              </div>
+            </div>
+
+            {/* Back */}
+            <button
+              onClick={() => navigate('/student/dashboard')}
+              className="w-full bg-gray-800 hover:bg-gray-700 text-white rounded-xl px-4 py-3 text-sm font-medium transition-colors"
+            >
+              Back to Dashboard
+            </button>
+          </>
+        )}
+      </div>
+    </div>
+  )
 }

frontend/src/pages/StudentDashboard.tsx

@@ -1,3 +1,108 @@
+import { useEffect, useState } from 'react'
+import { useNavigate } from 'react-router-dom'
+import { useInterviewStore } from '../store/interviewStore'
+import { getStudentTopics, getStudentSessions } from '../api/student'
+import type { StudentTopic, StudentSession } from '../types'
+import TopicChip from '../components/student/TopicChip'
+import AttemptRow from '../components/student/AttemptRow'
+import Navbar from '../components/shared/Navbar'
+
 export default function StudentDashboard() {
-  return <div>StudentDashboard</div>
+  const navigate = useNavigate()
+  const resetInterview = useInterviewStore((s) => s.reset)
+
+  const [topics, setTopics] = useState<StudentTopic[]>([])
+  const [sessions, setSessions] = useState<StudentSession[]>([])
+  const [loading, setLoading] = useState(true)
+  const [error, setError] = useState('')
+
+  useEffect(() => {
+    Promise.all([getStudentTopics(), getStudentSessions()])
+      .then(([t, s]) => {
+        setTopics(t)
+        setSessions(s)
+      })
+      .catch(() => setError('Failed to load dashboard.'))
+      .finally(() => setLoading(false))
+  }, [])
+
+  function handleStartTopic(topic: StudentTopic) {
+    resetInterview()
+    navigate('/student/interview', { state: { topicId: topic.id } })
+  }
+
+  const completedSessions = sessions.filter((s) => s.status === 'completed')
+  const avgScore =
+    completedSessions.length > 0
+      ? Math.round(
+          completedSessions.reduce((sum, s) => sum + (s.score ?? 0), 0) /
+            completedSessions.length,
+        )
+      : null
+
+  return (
+    <div className="min-h-screen bg-gray-950">
+      <Navbar />
+
+      <div className="max-w-2xl mx-auto px-4 py-8 space-y-8">
+        {/* Stats */}
+        <div className="grid grid-cols-3 gap-4">
+          <div className="bg-gray-900 border border-gray-800 rounded-xl px-4 py-3 text-center">
+            <p className="text-2xl font-bold text-white">{topics.length}</p>
+            <p className="text-xs text-gray-400 mt-1">Available Topics</p>
+          </div>
+          <div className="bg-gray-900 border border-gray-800 rounded-xl px-4 py-3 text-center">
+            <p className="text-2xl font-bold text-white">{completedSessions.length}</p>
+            <p className="text-xs text-gray-400 mt-1">Completed</p>
+          </div>
+          <div className="bg-gray-900 border border-gray-800 rounded-xl px-4 py-3 text-center">
+            <p className="text-2xl font-bold text-white">{avgScore ?? '—'}</p>
+            <p className="text-xs text-gray-400 mt-1">Avg Score</p>
+          </div>
+        </div>
+
+        {error && <p className="text-red-400 text-sm text-center">{error}</p>}
+
+        {loading ? (
+          <div className="space-y-3">
+            {[...Array(3)].map((_, i) => (
+              <div key={i} className="h-16 bg-gray-900 rounded-xl animate-pulse" />
+            ))}
+          </div>
+        ) : (
+          <>
+            {/* Available topics */}
+            <section>
+              <h2 className="text-sm font-semibold text-gray-400 uppercase tracking-wide mb-3">
+                Available Topics
+              </h2>
+              {topics.length === 0 ? (
+                <p className="text-gray-500 text-sm">No topics unlocked yet. Check back later.</p>
+              ) : (
+                <div className="space-y-3">
+                  {topics.map((t) => (
+                    <TopicChip key={t.id} topic={t} onStart={handleStartTopic} />
+                  ))}
+                </div>
+              )}
+            </section>
+
+            {/* Past attempts */}
+            {sessions.length > 0 && (
+              <section>
+                <h2 className="text-sm font-semibold text-gray-400 uppercase tracking-wide mb-3">
+                  Past Attempts
+                </h2>
+                <div className="space-y-3">
+                  {sessions.map((s) => (
+                    <AttemptRow key={s.id} session={s} />
+                  ))}
+                </div>
+              </section>
+            )}
+          </>
+        )}
+      </div>
+    </div>
+  )
 }

frontend/src/pages/StudentDetail.tsx

@@ -1,3 +1,125 @@
+import { useEffect, useState } from 'react'
+import { useParams, useNavigate } from 'react-router-dom'
+import { getStudentDetail, type StudentDetail } from '../api/instructor'
+import GapReport from '../components/instructor/GapReport'
+import Navbar from '../components/shared/Navbar'
+
+function formatDate(iso: string | null): string {
+  if (!iso) return '—'
+  return new Date(iso).toLocaleDateString(undefined, { month: 'short', day: 'numeric', year: 'numeric' })
+}
+
 export default function StudentDetail() {
-  return <div>StudentDetail</div>
+  const { studentId } = useParams<{ studentId: string }>()
+  const navigate = useNavigate()
+
+  const [detail, setDetail] = useState<StudentDetail | null>(null)
+  const [loading, setLoading] = useState(true)
+  const [error, setError] = useState('')
+
+  useEffect(() => {
+    if (!studentId) return
+    getStudentDetail(studentId)
+      .then(setDetail)
+      .catch(() => setError('Could not load student detail.'))
+      .finally(() => setLoading(false))
+  }, [studentId])
+
+  const completedSessions = detail?.sessions.filter((s) => s.status === 'completed') ?? []
+  const avgScore =
+    completedSessions.length > 0
+      ? Math.round(completedSessions.reduce((sum, s) => sum + (s.score ?? 0), 0) / completedSessions.length)
+      : null
+
+  return (
+    <div className="min-h-screen bg-gray-950">
+      <Navbar />
+
+      <div className="max-w-2xl mx-auto px-4 py-8 space-y-6">
+        <button
+          onClick={() => navigate('/instructor/dashboard')}
+          className="text-sm text-gray-400 hover:text-white transition-colors"
+        >
+          ← Back to dashboard
+        </button>
+
+        {loading && (
+          <div className="space-y-3">
+            {[...Array(4)].map((_, i) => (
+              <div key={i} className="h-16 bg-gray-900 rounded-xl animate-pulse" />
+            ))}
+          </div>
+        )}
+
+        {error && (
+          <p className="text-red-400 text-sm text-center">{error}</p>
+        )}
+
+        {detail && (
+          <>
+            {/* Header */}
+            <div className="bg-gray-900 border border-gray-800 rounded-xl p-6 flex items-center justify-between">
+              <div>
+                <h1 className="text-xl font-semibold text-white">{detail.full_name}</h1>
+                <p className="text-gray-500 text-sm mt-0.5">{detail.email}</p>
+              </div>
+              <div className="text-right">
+                <p className="text-2xl font-bold text-white">{avgScore ?? '—'}</p>
+                <p className="text-xs text-gray-500">Avg score</p>
+              </div>
+            </div>
+
+            {/* Gap report */}
+            <GapReport sessions={detail.sessions} />
+
+            {/* Session history */}
+            <div className="bg-gray-900 border border-gray-800 rounded-xl p-6">
+              <h2 className="text-sm font-semibold text-gray-400 uppercase tracking-wide mb-4">
+                Interview History
+              </h2>
+              {detail.sessions.length === 0 ? (
+                <p className="text-gray-500 text-sm">No interviews yet.</p>
+              ) : (
+                <div className="divide-y divide-gray-800">
+                  {detail.sessions.map((s) => {
+                    const scoreColor =
+                      s.score == null
+                        ? 'text-gray-500'
+                        : s.score >= 70
+                          ? 'text-green-400'
+                          : s.score >= 40
+                            ? 'text-yellow-400'
+                            : 'text-red-400'
+                    return (
+                      <div key={s.id} className="flex items-center justify-between py-3">
+                        <div>
+                          <p className="text-white text-sm font-medium">{s.topic_name}</p>
+                          <p className="text-gray-500 text-xs mt-0.5">{formatDate(s.started_at)}</p>
+                        </div>
+                        <div className="flex items-center gap-4">
+                          <span className={`font-semibold ${scoreColor}`}>
+                            {s.status === 'completed' && s.score != null ? s.score : '—'}
+                          </span>
+                          {s.status === 'completed' ? (
+                            <button
+                              onClick={() => navigate(`/student/report/${s.id}`)}
+                              className="text-xs text-indigo-400 hover:text-indigo-300 transition-colors"
+                            >
+                              Report
+                            </button>
+                          ) : (
+                            <span className="text-xs text-yellow-500">Active</span>
+                          )}
+                        </div>
+                      </div>
+                    )
+                  })}
+                </div>
+              )}
+            </div>
+          </>
+        )}
+      </div>
+    </div>
+  )
 }

frontend/src/store/interviewStore.ts

@@ -1 +1,50 @@
-// Zustand interview store — implemented in Phase 6
+import { create } from 'zustand'
+import type { Message } from '../types'
+
+interface InterviewState {
+  sessionId: string | null
+  topicId: string | null
+  messages: Message[]
+  turnCount: number
+  maxTurns: number
+  status: 'idle' | 'loading' | 'waiting' | 'finished'
+}
+
+interface InterviewActions {
+  startSession: (sessionId: string, topicId: string, firstMessage: string) => void
+  addMessage: (message: Message) => void
+  setTurnCount: (count: number) => void
+  setStatus: (status: InterviewState['status']) => void
+  reset: () => void
+}
+
+const initialState: InterviewState = {
+  sessionId: null,
+  topicId: null,
+  messages: [],
+  turnCount: 0,
+  maxTurns: 8,
+  status: 'idle',
+}
+
+export const useInterviewStore = create<InterviewState & InterviewActions>((set) => ({
+  ...initialState,
+
+  startSession: (sessionId, topicId, firstMessage) =>
+    set({
+      sessionId,
+      topicId,
+      messages: [{ role: 'ai', content: firstMessage }],
+      turnCount: 0,
+      status: 'waiting',
+    }),
+
+  addMessage: (message) =>
+    set((state) => ({ messages: [...state.messages, message] })),
+
+  setTurnCount: (count) => set({ turnCount: count }),
+
+  setStatus: (status) => set({ status }),
+
+  reset: () => set(initialState),
+}))

frontend/src/types/index.ts

@@ -23,3 +23,55 @@ export interface Feedback {
   mistakes: string[]
   tips: string[]
 }
+
+export interface InterviewSession {
+  status: string
+  turn_count: number
+  last_message: string | null
+}
+
+export interface SessionReport {
+  id: string
+  topic_id: string
+  status: string
+  score: number
+  feedback: Feedback
+  messages: Message[]
+}
+
+// Student dashboard types
+export interface StudentTopic {
+  id: string
+  name: string
+  order_index: number
+}
+
+export interface StudentSession {
+  id: string
+  topic_id: string
+  topic_name: string
+  status: 'active' | 'completed'
+  score: number | null
+  started_at: string | null
+  completed_at: string | null
+}
+
+// Instructor analytics types
+export interface InstructorStudent {
+  id: string
+  full_name: string
+  email: string
+  total_sessions: number
+  completed_sessions: number
+  avg_score: number | null
+}
+
+export interface StudentAttempt {
+  id: string
+  topic_id: string
+  topic_name: string
+  status: 'active' | 'completed'
+  score: number | null
+  started_at: string | null
+  completed_at: string | null
+}

pyproject.toml

@@ -11,6 +11,7 @@ dependencies = [
     "httpx==0.27.2",
     "langgraph==0.2.50",
     "langgraph-checkpoint-postgres==2.0.8",
+    "psycopg[binary]>=3.3.3",
     "pydantic==2.8.2",
     "python-dotenv==1.0.1",
     "python-jose[cryptography]==3.3.0",

run.py

@@ -0,0 +1,11 @@
+"""Entry point for local development — sets Windows event loop policy before uvicorn."""
+import asyncio
+import sys
+
+if sys.platform == "win32":
+    asyncio.set_event_loop_policy(asyncio.WindowsSelectorEventLoopPolicy())
+
+import uvicorn
+
+if __name__ == "__main__":
+    uvicorn.run("backend.main:app", host="0.0.0.0", port=7860)

tests/test_prompts.py

@@ -0,0 +1,75 @@
+from backend.prompts import (
+    build_ask_question_prompt,
+    build_counter_prompt,
+    build_evaluate_prompt,
+    build_report_prompt,
+    build_summarize_prompt,
+)
+
+
+def _is_message_list(result) -> bool:
+    return (
+        isinstance(result, list)
+        and all(isinstance(m, dict) and "role" in m and "content" in m for m in result)
+    )
+
+
+def test_ask_question_prompt_returns_messages():
+    result = build_ask_question_prompt("Python", "Some summary", ["What is a list?"])
+    assert _is_message_list(result)
+    assert len(result) == 2
+    combined = " ".join(m["content"] for m in result)
+    assert "Python" in combined
+    assert "Some summary" in combined
+    assert "What is a list?" in combined
+
+
+def test_ask_question_prompt_no_prior_questions():
+    result = build_ask_question_prompt("Python", "", [])
+    assert _is_message_list(result)
+    combined = " ".join(m["content"] for m in result)
+    assert "Python" in combined
+
+
+def test_evaluate_prompt_returns_messages():
+    result = build_evaluate_prompt("What is GIL?", "Global Interpreter Lock", "summary")
+    assert _is_message_list(result)
+    combined = " ".join(m["content"] for m in result)
+    assert "What is GIL?" in combined
+    assert "Global Interpreter Lock" in combined
+    # Must instruct JSON output
+    assert "JSON" in combined or "json" in combined
+
+
+def test_counter_prompt_returns_messages():
+    result = build_counter_prompt("What is GIL?", "I don't know")
+    assert _is_message_list(result)
+    assert len(result) == 2
+    combined = " ".join(m["content"] for m in result)
+    assert "What is GIL?" in combined
+
+
+def test_summarize_prompt_returns_messages():
+    messages = [
+        {"role": "assistant", "content": "What is a decorator?"},
+        {"role": "human", "content": "It wraps a function"},
+    ]
+    result = build_summarize_prompt(messages)
+    assert _is_message_list(result)
+    combined = " ".join(m["content"] for m in result)
+    assert "decorator" in combined
+
+
+def test_report_prompt_includes_past_score():
+    result = build_report_prompt("Python", ["Q1", "Q2"], ["decorators"], "summary", 72)
+    assert _is_message_list(result)
+    combined = " ".join(m["content"] for m in result)
+    assert "72" in combined
+    assert "JSON" in combined or "json" in combined
+
+
+def test_report_prompt_no_past_score():
+    result = build_report_prompt("Python", [], [], "", None)
+    assert _is_message_list(result)
+    combined = " ".join(m["content"] for m in result)
+    assert "first attempt" in combined.lower() or "no previous" in combined.lower() or "first" in combined.lower()

tests/test_routing.py

@@ -0,0 +1,55 @@
+"""Unit tests for route_after_evaluation — no LLM, no DB needed."""
+from backend.graph.nodes import route_after_evaluation
+
+
+def _state(**overrides) -> dict:
+    """Build a minimal InterviewState dict for routing tests."""
+    base = {
+        "last_verdict": "strong",
+        "turn_count": 1,
+        "questions_remaining": [{"question_text": "Q2", "difficulty": "easy"}],
+        "awaiting_counter_response": False,
+    }
+    base.update(overrides)
+    return base
+
+
+def test_shallow_not_in_counter_loop_routes_to_counter():
+    state = _state(last_verdict="shallow", awaiting_counter_response=False)
+    assert route_after_evaluation(state) == "counter"
+
+
+def test_shallow_already_in_counter_loop_routes_to_next_question():
+    state = _state(last_verdict="shallow", awaiting_counter_response=True, turn_count=2)
+    assert route_after_evaluation(state) == "next_question"
+
+
+def test_strong_routes_to_next_question():
+    state = _state(last_verdict="strong", turn_count=1)
+    assert route_after_evaluation(state) == "next_question"
+
+
+def test_wrong_routes_to_next_question():
+    state = _state(last_verdict="wrong", turn_count=1)
+    assert route_after_evaluation(state) == "next_question"
+
+
+def test_turn_count_8_routes_to_end():
+    state = _state(last_verdict="strong", turn_count=8)
+    assert route_after_evaluation(state) == "end"
+
+
+def test_no_questions_remaining_routes_to_end():
+    state = _state(last_verdict="strong", turn_count=3, questions_remaining=[])
+    assert route_after_evaluation(state) == "end"
+
+
+def test_every_4_turns_routes_to_summarize():
+    state = _state(last_verdict="strong", turn_count=4)
+    assert route_after_evaluation(state) == "summarize"
+
+
+def test_turn_8_beats_summarize():
+    # turn_count=8 should end, not summarize (end takes priority)
+    state = _state(last_verdict="strong", turn_count=8)
+    assert route_after_evaluation(state) == "end"

uv.lock

@@ -17,6 +17,7 @@ dependencies = [
     { name = "httpx" },
     { name = "langgraph" },
     { name = "langgraph-checkpoint-postgres" },
+    { name = "psycopg", extra = ["binary"] },
     { name = "pydantic" },
     { name = "python-dotenv" },
     { name = "python-jose", extra = ["cryptography"] },
@@ -37,6 +38,7 @@ requires-dist = [
     { name = "httpx", specifier = "==0.27.2" },
     { name = "langgraph", specifier = "==0.2.50" },
     { name = "langgraph-checkpoint-postgres", specifier = "==2.0.8" },
+    { name = "psycopg", extras = ["binary"], specifier = ">=3.3.3" },
     { name = "pydantic", specifier = "==2.8.2" },
     { name = "python-dotenv", specifier = "==1.0.1" },
     { name = "python-jose", extras = ["cryptography"], specifier = "==3.3.0" },
@@ -727,6 +729,62 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/c8/5b/181e2e3becb7672b502f0ed7f16ed7352aca7c109cfb94cf3878a9186db9/psycopg-3.3.3-py3-none-any.whl", hash = "sha256:f96525a72bcfade6584ab17e89de415ff360748c766f0106959144dcbb38c698", size = 212768, upload-time = "2026-02-18T16:46:27.365Z" },
 ]
 
+[package.optional-dependencies]
+binary = [
+    { name = "psycopg-binary", marker = "implementation_name != 'pypy'" },
+]
+
+[[package]]
+name = "psycopg-binary"
+version = "3.3.3"
+source = { registry = "https://pypi.org/simple" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/be/c0/b389119dd754483d316805260f3e73cdcad97925839107cc7a296f6132b1/psycopg_binary-3.3.3-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:a89bb9ee11177b2995d87186b1d9fa892d8ea725e85eab28c6525e4cc14ee048", size = 4609740, upload-time = "2026-02-18T16:47:51.093Z" },
+    { url = "https://files.pythonhosted.org/packages/cf/e3/9976eef20f61840285174d360da4c820a311ab39d6b82fa09fbb545be825/psycopg_binary-3.3.3-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:9f7d0cf072c6fbac3795b08c98ef9ea013f11db609659dcfc6b1f6cc31f9e181", size = 4676837, upload-time = "2026-02-18T16:47:55.523Z" },
+    { url = "https://files.pythonhosted.org/packages/9f/f2/d28ba2f7404fd7f68d41e8a11df86313bd646258244cb12a8dd83b868a97/psycopg_binary-3.3.3-cp311-cp311-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:90eecd93073922f085967f3ed3a98ba8c325cbbc8c1a204e300282abd2369e13", size = 5497070, upload-time = "2026-02-18T16:47:59.929Z" },
+    { url = "https://files.pythonhosted.org/packages/de/2f/6c5c54b815edeb30a281cfcea96dc93b3bb6be939aea022f00cab7aa1420/psycopg_binary-3.3.3-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:dac7ee2f88b4d7bb12837989ca354c38d400eeb21bce3b73dac02622f0a3c8d6", size = 5172410, upload-time = "2026-02-18T16:48:05.665Z" },
+    { url = "https://files.pythonhosted.org/packages/51/75/8206c7008b57de03c1ada46bd3110cc3743f3fd9ed52031c4601401d766d/psycopg_binary-3.3.3-cp311-cp311-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:b62cf8784eb6d35beaee1056d54caf94ec6ecf2b7552395e305518ab61eb8fd2", size = 6763408, upload-time = "2026-02-18T16:48:13.541Z" },
+    { url = "https://files.pythonhosted.org/packages/d4/5a/ea1641a1e6c8c8b3454b0fcb43c3045133a8b703e6e824fae134088e63bd/psycopg_binary-3.3.3-cp311-cp311-manylinux_2_38_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:a39f34c9b18e8f6794cca17bfbcd64572ca2482318db644268049f8c738f35a6", size = 5006255, upload-time = "2026-02-18T16:48:22.176Z" },
+    { url = "https://files.pythonhosted.org/packages/aa/fb/538df099bf55ae1637d52d7ccb6b9620b535a40f4c733897ac2b7bb9e14c/psycopg_binary-3.3.3-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:883d68d48ca9ff3cb3d10c5fdebea02c79b48eecacdddbf7cce6e7cdbdc216b8", size = 4532694, upload-time = "2026-02-18T16:48:27.338Z" },
+    { url = "https://files.pythonhosted.org/packages/a1/d1/00780c0e187ea3c13dfc53bd7060654b2232cd30df562aac91a5f1c545ac/psycopg_binary-3.3.3-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:cab7bc3d288d37a80aa8c0820033250c95e40b1c2b5c57cf59827b19c2a8b69d", size = 4222833, upload-time = "2026-02-18T16:48:31.221Z" },
+    { url = "https://files.pythonhosted.org/packages/7a/34/a07f1ff713c51d64dc9f19f2c32be80299a2055d5d109d5853662b922cb4/psycopg_binary-3.3.3-cp311-cp311-musllinux_1_2_riscv64.whl", hash = "sha256:56c767007ca959ca32f796b42379fc7e1ae2ed085d29f20b05b3fc394f3715cc", size = 3952818, upload-time = "2026-02-18T16:48:35.869Z" },
+    { url = "https://files.pythonhosted.org/packages/d3/67/d33f268a7759b4445f3c9b5a181039b01af8c8263c865c1be7a6444d4749/psycopg_binary-3.3.3-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:da2f331a01af232259a21573a01338530c6016dcfad74626c01330535bcd8628", size = 4258061, upload-time = "2026-02-18T16:48:41.365Z" },
+    { url = "https://files.pythonhosted.org/packages/b4/3b/0d8d2c5e8e29ccc07d28c8af38445d9d9abcd238d590186cac82ee71fc84/psycopg_binary-3.3.3-cp311-cp311-win_amd64.whl", hash = "sha256:19f93235ece6dbfc4036b5e4f6d8b13f0b8f2b3eeb8b0bd2936d406991bcdd40", size = 3558915, upload-time = "2026-02-18T16:48:46.679Z" },
+    { url = "https://files.pythonhosted.org/packages/90/15/021be5c0cbc5b7c1ab46e91cc3434eb42569f79a0592e67b8d25e66d844d/psycopg_binary-3.3.3-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:6698dbab5bcef8fdb570fc9d35fd9ac52041771bfcfe6fd0fc5f5c4e36f1e99d", size = 4591170, upload-time = "2026-02-18T16:48:55.594Z" },
+    { url = "https://files.pythonhosted.org/packages/f1/54/a60211c346c9a2f8c6b272b5f2bbe21f6e11800ce7f61e99ba75cf8b63e1/psycopg_binary-3.3.3-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:329ff393441e75f10b673ae99ab45276887993d49e65f141da20d915c05aafd8", size = 4670009, upload-time = "2026-02-18T16:49:03.608Z" },
+    { url = "https://files.pythonhosted.org/packages/c1/53/ac7c18671347c553362aadbf65f92786eef9540676ca24114cc02f5be405/psycopg_binary-3.3.3-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:eb072949b8ebf4082ae24289a2b0fd724da9adc8f22743409d6fd718ddb379df", size = 5469735, upload-time = "2026-02-18T16:49:10.128Z" },
+    { url = "https://files.pythonhosted.org/packages/7f/c3/4f4e040902b82a344eff1c736cde2f2720f127fe939c7e7565706f96dd44/psycopg_binary-3.3.3-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:263a24f39f26e19ed7fc982d7859a36f17841b05bebad3eb47bb9cd2dd785351", size = 5152919, upload-time = "2026-02-18T16:49:16.335Z" },
+    { url = "https://files.pythonhosted.org/packages/0c/e7/d929679c6a5c212bcf738806c7c89f5b3d0919f2e1685a0e08d6ff877945/psycopg_binary-3.3.3-cp312-cp312-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:5152d50798c2fa5bd9b68ec68eb68a1b71b95126c1d70adaa1a08cd5eefdc23d", size = 6738785, upload-time = "2026-02-18T16:49:22.687Z" },
+    { url = "https://files.pythonhosted.org/packages/69/b0/09703aeb69a9443d232d7b5318d58742e8ca51ff79f90ffe6b88f1db45e7/psycopg_binary-3.3.3-cp312-cp312-manylinux_2_38_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:9d6a1e56dd267848edb824dbeb08cf5bac649e02ee0b03ba883ba3f4f0bd54f2", size = 4979008, upload-time = "2026-02-18T16:49:27.313Z" },
+    { url = "https://files.pythonhosted.org/packages/cc/a6/e662558b793c6e13a7473b970fee327d635270e41eded3090ef14045a6a5/psycopg_binary-3.3.3-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:73eaaf4bb04709f545606c1db2f65f4000e8a04cdbf3e00d165a23004692093e", size = 4508255, upload-time = "2026-02-18T16:49:31.575Z" },
+    { url = "https://files.pythonhosted.org/packages/5f/7f/0f8b2e1d5e0093921b6f324a948a5c740c1447fbb45e97acaf50241d0f39/psycopg_binary-3.3.3-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:162e5675efb4704192411eaf8e00d07f7960b679cd3306e7efb120bb8d9456cc", size = 4189166, upload-time = "2026-02-18T16:49:35.801Z" },
+    { url = "https://files.pythonhosted.org/packages/92/ec/ce2e91c33bc8d10b00c87e2f6b0fb570641a6a60042d6a9ae35658a3a797/psycopg_binary-3.3.3-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:fab6b5e37715885c69f5d091f6ff229be71e235f272ebaa35158d5a46fd548a0", size = 3924544, upload-time = "2026-02-18T16:49:41.129Z" },
+    { url = "https://files.pythonhosted.org/packages/c5/2f/7718141485f73a924205af60041c392938852aa447a94c8cbd222ff389a1/psycopg_binary-3.3.3-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:a4aab31bd6d1057f287c96c0effca3a25584eb9cc702f282ecb96ded7814e830", size = 4235297, upload-time = "2026-02-18T16:49:46.726Z" },
+    { url = "https://files.pythonhosted.org/packages/57/f9/1add717e2643a003bbde31b1b220172e64fbc0cb09f06429820c9173f7fc/psycopg_binary-3.3.3-cp312-cp312-win_amd64.whl", hash = "sha256:59aa31fe11a0e1d1bcc2ce37ed35fe2ac84cd65bb9036d049b1a1c39064d0f14", size = 3547659, upload-time = "2026-02-18T16:49:52.999Z" },
+    { url = "https://files.pythonhosted.org/packages/03/0a/cac9fdf1df16a269ba0e5f0f06cac61f826c94cadb39df028cdfe19d3a33/psycopg_binary-3.3.3-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:05f32239aec25c5fb15f7948cffdc2dc0dac098e48b80a140e4ba32b572a2e7d", size = 4590414, upload-time = "2026-02-18T16:50:01.441Z" },
+    { url = "https://files.pythonhosted.org/packages/9c/c0/d8f8508fbf440edbc0099b1abff33003cd80c9e66eb3a1e78834e3fb4fb9/psycopg_binary-3.3.3-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:7c84f9d214f2d1de2fafebc17fa68ac3f6561a59e291553dfc45ad299f4898c1", size = 4669021, upload-time = "2026-02-18T16:50:08.803Z" },
+    { url = "https://files.pythonhosted.org/packages/04/05/097016b77e343b4568feddf12c72171fc513acef9a4214d21b9478569068/psycopg_binary-3.3.3-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:e77957d2ba17cada11be09a5066d93026cdb61ada7c8893101d7fe1c6e1f3925", size = 5467453, upload-time = "2026-02-18T16:50:14.985Z" },
+    { url = "https://files.pythonhosted.org/packages/91/23/73244e5feb55b5ca109cede6e97f32ef45189f0fdac4c80d75c99862729d/psycopg_binary-3.3.3-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:42961609ac07c232a427da7c87a468d3c82fee6762c220f38e37cfdacb2b178d", size = 5151135, upload-time = "2026-02-18T16:50:24.82Z" },
+    { url = "https://files.pythonhosted.org/packages/11/49/5309473b9803b207682095201d8708bbc7842ddf3f192488a69204e36455/psycopg_binary-3.3.3-cp313-cp313-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:ae07a3114313dd91fce686cab2f4c44af094398519af0e0f854bc707e1aeedf1", size = 6737315, upload-time = "2026-02-18T16:50:35.106Z" },
+    { url = "https://files.pythonhosted.org/packages/d4/5d/03abe74ef34d460b33c4d9662bf6ec1dd38888324323c1a1752133c10377/psycopg_binary-3.3.3-cp313-cp313-manylinux_2_38_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:d257c58d7b36a621dcce1d01476ad8b60f12d80eb1406aee4cf796f88b2ae482", size = 4979783, upload-time = "2026-02-18T16:50:42.067Z" },
+    { url = "https://files.pythonhosted.org/packages/f0/6c/3fbf8e604e15f2f3752900434046c00c90bb8764305a1b81112bff30ba24/psycopg_binary-3.3.3-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:07c7211f9327d522c9c47560cae00a4ecf6687f4e02d779d035dd3177b41cb12", size = 4509023, upload-time = "2026-02-18T16:50:50.116Z" },
+    { url = "https://files.pythonhosted.org/packages/9c/6b/1a06b43b7c7af756c80b67eac8bfaa51d77e68635a8a8d246e4f0bb7604a/psycopg_binary-3.3.3-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:8e7e9eca9b363dbedeceeadd8be97149d2499081f3c52d141d7cd1f395a91f83", size = 4185874, upload-time = "2026-02-18T16:50:55.97Z" },
+    { url = "https://files.pythonhosted.org/packages/2b/d3/bf49e3dcaadba510170c8d111e5e69e5ae3f981c1554c5bb71c75ce354bb/psycopg_binary-3.3.3-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:cb85b1d5702877c16f28d7b92ba030c1f49ebcc9b87d03d8c10bf45a2f1c7508", size = 3925668, upload-time = "2026-02-18T16:51:03.299Z" },
+    { url = "https://files.pythonhosted.org/packages/f8/92/0aac830ed6a944fe334404e1687a074e4215630725753f0e3e9a9a595b62/psycopg_binary-3.3.3-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:4d4606c84d04b80f9138d72f1e28c6c02dc5ae0c7b8f3f8aaf89c681ce1cd1b1", size = 4234973, upload-time = "2026-02-18T16:51:09.097Z" },
+    { url = "https://files.pythonhosted.org/packages/2e/96/102244653ee5a143ece5afe33f00f52fe64e389dfce8dbc87580c6d70d3d/psycopg_binary-3.3.3-cp313-cp313-win_amd64.whl", hash = "sha256:74eae563166ebf74e8d950ff359be037b85723d99ca83f57d9b244a871d6c13b", size = 3551342, upload-time = "2026-02-18T16:51:13.892Z" },
+    { url = "https://files.pythonhosted.org/packages/a2/71/7a57e5b12275fe7e7d84d54113f0226080423a869118419c9106c083a21c/psycopg_binary-3.3.3-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:497852c5eaf1f0c2d88ab74a64a8097c099deac0c71de1cbcf18659a8a04a4b2", size = 4607368, upload-time = "2026-02-18T16:51:19.295Z" },
+    { url = "https://files.pythonhosted.org/packages/c7/04/cb834f120f2b2c10d4003515ef9ca9d688115b9431735e3936ae48549af8/psycopg_binary-3.3.3-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:258d1ea53464d29768bf25930f43291949f4c7becc706f6e220c515a63a24edd", size = 4687047, upload-time = "2026-02-18T16:51:23.84Z" },
+    { url = "https://files.pythonhosted.org/packages/40/e9/47a69692d3da9704468041aa5ed3ad6fc7f6bb1a5ae788d261a26bbca6c7/psycopg_binary-3.3.3-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:111c59897a452196116db12e7f608da472fbff000693a21040e35fc978b23430", size = 5487096, upload-time = "2026-02-18T16:51:29.645Z" },
+    { url = "https://files.pythonhosted.org/packages/0b/b6/0e0dd6a2f802864a4ae3dbadf4ec620f05e3904c7842b326aafc43e5f464/psycopg_binary-3.3.3-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:17bb6600e2455993946385249a3c3d0af52cd70c1c1cdbf712e9d696d0b0bf1b", size = 5168720, upload-time = "2026-02-18T16:51:36.499Z" },
+    { url = "https://files.pythonhosted.org/packages/6f/0d/977af38ac19a6b55d22dff508bd743fd7c1901e1b73657e7937c7cccb0a3/psycopg_binary-3.3.3-cp314-cp314-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:642050398583d61c9856210568eb09a8e4f2fe8224bf3be21b67a370e677eead", size = 6762076, upload-time = "2026-02-18T16:51:43.167Z" },
+    { url = "https://files.pythonhosted.org/packages/34/40/912a39d48322cf86895c0eaf2d5b95cb899402443faefd4b09abbba6b6e1/psycopg_binary-3.3.3-cp314-cp314-manylinux_2_38_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:533efe6dc3a7cba5e2a84e38970786bb966306863e45f3db152007e9f48638a6", size = 4997623, upload-time = "2026-02-18T16:51:47.707Z" },
+    { url = "https://files.pythonhosted.org/packages/98/0c/c14d0e259c65dc7be854d926993f151077887391d5a081118907a9d89603/psycopg_binary-3.3.3-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:5958dbf28b77ce2033482f6cb9ef04d43f5d8f4b7636e6963d5626f000efb23e", size = 4532096, upload-time = "2026-02-18T16:51:51.421Z" },
+    { url = "https://files.pythonhosted.org/packages/39/21/8b7c50a194cfca6ea0fd4d1f276158307785775426e90700ab2eba5cd623/psycopg_binary-3.3.3-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:a6af77b6626ce92b5817bf294b4d45ec1a6161dba80fc2d82cdffdd6814fd023", size = 4208884, upload-time = "2026-02-18T16:51:57.336Z" },
+    { url = "https://files.pythonhosted.org/packages/c7/2c/a4981bf42cf30ebba0424971d7ce70a222ae9b82594c42fc3f2105d7b525/psycopg_binary-3.3.3-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:47f06fcbe8542b4d96d7392c476a74ada521c5aebdb41c3c0155f6595fc14c8d", size = 3944542, upload-time = "2026-02-18T16:52:04.266Z" },
+    { url = "https://files.pythonhosted.org/packages/60/e9/b7c29b56aa0b85a4e0c4d89db691c1ceef08f46a356369144430c155a2f5/psycopg_binary-3.3.3-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:e7800e6c6b5dc4b0ca7cc7370f770f53ac83886b76afda0848065a674231e856", size = 4254339, upload-time = "2026-02-18T16:52:10.444Z" },
+    { url = "https://files.pythonhosted.org/packages/98/5a/291d89f44d3820fffb7a04ebc8f3ef5dda4f542f44a5daea0c55a84abf45/psycopg_binary-3.3.3-cp314-cp314-win_amd64.whl", hash = "sha256:165f22ab5a9513a3d7425ffb7fcc7955ed8ccaeef6d37e369d6cc1dff1582383", size = 3652796, upload-time = "2026-02-18T16:52:14.02Z" },
+]
+
 [[package]]
 name = "psycopg-pool"
 version = "3.3.0"