feat: complete phase 5 -- error hardening, frontend, Docker, demo, docs

Backend:
- ConversationTracker: Protocol + PostgresConversationTracker for lifecycle tracking
- Error handler: ErrorCategory enum, classify_error(), with_retry() exponential backoff
- Wire PostgresAnalyticsRecorder + ConversationTracker into ws_handler
- Rate limiting (10 msg/10s per thread), edge case hardening
- Health endpoint GET /api/health, version 0.5.0
- Demo seed data script + sample OpenAPI spec

Frontend (all new):
- React Router with NavBar (Chat / Replay / Dashboard / Review)
- ReplayListPage + ReplayPage with ReplayTimeline component
- DashboardPage with MetricCard, range selector, zero-state
- ReviewPage for OpenAPI classification review
- ErrorBanner for WebSocket disconnect handling
- API client (api.ts) with typed fetch wrappers

Infrastructure:
- Frontend Dockerfile (multi-stage node -> nginx)
- nginx.conf with SPA routing + API/WS proxy
- docker-compose.yml with frontend service + healthchecks
- .env.example files (root + backend)

Documentation:
- README.md with quick start and architecture
- Agent configuration guide
- OpenAPI import guide
- Deployment guide
- Demo script

48 new tests, 449 total passing, 92.87% coverage

backend/app/main.py

@@ -11,9 +11,10 @@ from fastapi import FastAPI, WebSocket, WebSocketDisconnect
 from fastapi.staticfiles import StaticFiles
 
 from app.analytics.api import router as analytics_router
-from app.analytics.event_recorder import NoOpAnalyticsRecorder
+from app.analytics.event_recorder import PostgresAnalyticsRecorder
 from app.callbacks import TokenUsageCallbackHandler
 from app.config import Settings
+from app.conversation_tracker import PostgresConversationTracker
 from app.db import create_checkpointer, create_pool, setup_app_tables
 from app.escalation import NoOpEscalator, WebhookEscalator
 from app.graph import build_graph
@@ -76,7 +77,8 @@ async def lifespan(app: FastAPI) -> AsyncGenerator[None, None]:
     app.state.escalator = escalator
     app.state.settings = settings
     app.state.pool = pool
-    app.state.analytics_recorder = NoOpAnalyticsRecorder()
+    app.state.analytics_recorder = PostgresAnalyticsRecorder(pool=pool)
+    app.state.conversation_tracker = PostgresConversationTracker()
 
     logger.info(
         "Smart Support started: %d agents loaded, LLM=%s/%s, template=%s",
@@ -91,13 +93,19 @@ async def lifespan(app: FastAPI) -> AsyncGenerator[None, None]:
     await pool.close()
 
 
-app = FastAPI(title="Smart Support", version="0.4.0", lifespan=lifespan)
+app = FastAPI(title="Smart Support", version="0.5.0", lifespan=lifespan)
 
 app.include_router(openapi_router)
 app.include_router(replay_router)
 app.include_router(analytics_router)
 
 
+@app.get("/api/health")
+def health_check() -> dict:
+    """Health check endpoint for load balancers and monitoring."""
+    return {"status": "ok", "version": "0.5.0"}
+
+
 @app.websocket("/ws")
 async def websocket_endpoint(ws: WebSocket) -> None:
     await ws.accept()
@@ -107,12 +115,19 @@ async def websocket_endpoint(ws: WebSocket) -> None:
     settings = app.state.settings
     callback_handler = TokenUsageCallbackHandler(model_name=settings.llm_model)
 
+    analytics_recorder = app.state.analytics_recorder
+    conversation_tracker = app.state.conversation_tracker
+    pool = app.state.pool
+
     try:
         while True:
             raw_data = await ws.receive_text()
             await dispatch_message(
                 ws, graph, session_manager, callback_handler, raw_data,
                 interrupt_manager=interrupt_manager,
+                analytics_recorder=analytics_recorder,
+                conversation_tracker=conversation_tracker,
+                pool=pool,
             )
     except WebSocketDisconnect:
         logger.info("WebSocket client disconnected")