perf: optimize login transition and dashboard loading performance

- Eliminate N+1 lazy queries in activity, documents, and workflows endpoints using joinedload/selectinload
- Aggregate dashboard KPI counts into a single SQL query to reduce remote DB roundtrips
- Increase DB pool size to 10 with max_overflow of 20 to prevent connection starvation
- Add in-flight GET request deduplication in frontend API client
- Remove blocking /auth/me call on login to enable instant navigation
- Cache workspace data in localStorage to eliminate sequential loading waterfalls
- Implement session caching and skeleton shimmer states in Dashboard UI

backend/app/api/activity.py

@@ -5,12 +5,14 @@ import json
 from uuid import UUID
 
 from fastapi import APIRouter, Depends, HTTPException, Query
-from sqlalchemy.orm import Session
+from sqlalchemy.orm import Session, joinedload
 
 from app.core.dependencies import get_current_user
 from app.database.session import get_db
 from app.models.commit import Commit
+from app.models.document import Document
 from app.models.document_version import DocumentVersion
+from app.models.knowledge_item import KnowledgeItem
 from app.models.proposal import Proposal, ProposalStatus
 from app.models.review import Review
 from app.models.user import User
@@ -86,20 +88,17 @@ def list_activity(
     if cursor:
         cursor_ts, cursor_id = _decode_cursor(cursor)
 
-    # Use a generous per-table fetch limit to ensure enough events
-    # survive the post-merge filter. Each DB row can produce multiple events.
-    # The correctness guarantee comes from the post-merge cursor filter,
-    # not from per-table limiting. Use a high multiplier to ensure all
-    # relevant rows are loaded.
-    fetch_limit = max(limit * 10, 500)
+    # Fetch enough rows per table to satisfy the merged limit without overfetching
+    fetch_limit = min(max(limit * 2, 20), 100)
 
     events: list[dict] = []
 
     # ------------------------------------------------------------------
-    # Workflow events
+    # Workflow events (eagerly load document_version in 1 query)
     # ------------------------------------------------------------------
     workflows = (
         db.query(WorkflowRun)
+        .options(joinedload(WorkflowRun.document_version))
         .filter(WorkflowRun.workspace_id == workspace_id)
         .order_by(WorkflowRun.started_at.desc())
         .limit(fetch_limit)
@@ -144,12 +143,12 @@ def list_activity(
             })
 
     # ------------------------------------------------------------------
-    # Document upload events
+    # Document upload events (direct join on documents)
     # ------------------------------------------------------------------
     versions = (
         db.query(DocumentVersion)
-        .join(DocumentVersion.document)
-        .filter(DocumentVersion.document.has(workspace_id=workspace_id))
+        .join(Document, DocumentVersion.document_id == Document.id)
+        .filter(Document.workspace_id == workspace_id)
         .order_by(DocumentVersion.uploaded_at.desc())
         .limit(fetch_limit)
         .all()
@@ -168,17 +167,19 @@ def list_activity(
         })
 
     # ------------------------------------------------------------------
-    # Proposal events
+    # Proposal events (eagerly load knowledge_item -> document_version)
     # ------------------------------------------------------------------
     proposals = (
         db.query(Proposal)
+        .options(
+            joinedload(Proposal.knowledge_item).joinedload(KnowledgeItem.document_version)
+        )
         .filter(Proposal.workspace_id == workspace_id)
         .order_by(Proposal.created_at.desc())
         .limit(fetch_limit)
         .all()
     )
     for p in proposals:
-        # Walk the lazy-load chain: proposal → knowledge_item → document_version → filename
         p_filename = None
         ki = p.knowledge_item
         if ki and ki.document_version:
@@ -234,22 +235,24 @@ def list_activity(
             })
 
     # ------------------------------------------------------------------
-    # Commit events
+    # Commit events (eagerly load proposal -> knowledge_item -> document_version)
     # ------------------------------------------------------------------
     commits = (
         db.query(Commit)
+        .options(
+            joinedload(Commit.proposal)
+            .joinedload(Proposal.knowledge_item)
+            .joinedload(KnowledgeItem.document_version)
+        )
         .filter(Commit.workspace_id == workspace_id)
         .order_by(Commit.committed_at.desc())
         .limit(fetch_limit)
         .all()
     )
     for c in commits:
-        # Walk the lazy-load chain: commit → proposal → knowledge_item → document_version → filename
         c_filename = None
-        if c.proposal_id:
-            c_proposal = db.query(Proposal).filter(Proposal.id == c.proposal_id).first()
-            if c_proposal and c_proposal.knowledge_item and c_proposal.knowledge_item.document_version:
-                c_filename = c_proposal.knowledge_item.document_version.filename
+        if c.proposal and c.proposal.knowledge_item and c.proposal.knowledge_item.document_version:
+            c_filename = c.proposal.knowledge_item.document_version.filename
 
         events.append({
             "id": f"commit-{c.id}",

backend/app/api/dashboard.py

@@ -42,59 +42,20 @@ def get_dashboard_stats(
             detail="You do not have access to this workspace.",
         )
 
-    total_documents = (
-        db.query(func.count(Document.id))
-        .filter(Document.workspace_id == workspace_id)
-        .scalar()
-    ) or 0
-
-    workflows_running = (
-        db.query(func.count(WorkflowRun.id))
-        .filter(
-            WorkflowRun.workspace_id == workspace_id,
-            WorkflowRun.status == WorkflowStatus.RUNNING,
-        )
-        .scalar()
-    ) or 0
-
-    workflows_waiting = (
-        db.query(func.count(WorkflowRun.id))
-        .filter(
-            WorkflowRun.workspace_id == workspace_id,
-            WorkflowRun.status == WorkflowStatus.WAITING_FOR_REVIEW,
-        )
-        .scalar()
-    ) or 0
-
-    workflows_completed = (
-        db.query(func.count(WorkflowRun.id))
-        .filter(
-            WorkflowRun.workspace_id == workspace_id,
-            WorkflowRun.status == WorkflowStatus.COMPLETED,
-        )
-        .scalar()
-    ) or 0
-
-    pending_proposals = (
-        db.query(func.count(Proposal.id))
-        .filter(
-            Proposal.workspace_id == workspace_id,
-            Proposal.status == ProposalStatus.PENDING,
-        )
-        .scalar()
-    ) or 0
-
-    knowledge_items = (
-        db.query(func.count(KnowledgeItem.id))
-        .filter(KnowledgeItem.workspace_id == workspace_id)
-        .scalar()
-    ) or 0
+    stats = db.query(
+        db.query(func.count(Document.id)).filter(Document.workspace_id == workspace_id).scalar_subquery().label("total_documents"),
+        db.query(func.count(WorkflowRun.id)).filter(WorkflowRun.workspace_id == workspace_id, WorkflowRun.status == WorkflowStatus.RUNNING).scalar_subquery().label("workflows_running"),
+        db.query(func.count(WorkflowRun.id)).filter(WorkflowRun.workspace_id == workspace_id, WorkflowRun.status == WorkflowStatus.WAITING_FOR_REVIEW).scalar_subquery().label("workflows_waiting_for_review"),
+        db.query(func.count(WorkflowRun.id)).filter(WorkflowRun.workspace_id == workspace_id, WorkflowRun.status == WorkflowStatus.COMPLETED).scalar_subquery().label("workflows_completed"),
+        db.query(func.count(Proposal.id)).filter(Proposal.workspace_id == workspace_id, Proposal.status == ProposalStatus.PENDING).scalar_subquery().label("pending_proposals"),
+        db.query(func.count(KnowledgeItem.id)).filter(KnowledgeItem.workspace_id == workspace_id).scalar_subquery().label("knowledge_items"),
+    ).first()
 
     return {
-        "total_documents": total_documents,
-        "workflows_running": workflows_running,
-        "workflows_waiting_for_review": workflows_waiting,
-        "workflows_completed": workflows_completed,
-        "pending_proposals": pending_proposals,
-        "knowledge_items": knowledge_items,
+        "total_documents": (stats.total_documents if stats else 0) or 0,
+        "workflows_running": (stats.workflows_running if stats else 0) or 0,
+        "workflows_waiting_for_review": (stats.workflows_waiting_for_review if stats else 0) or 0,
+        "workflows_completed": (stats.workflows_completed if stats else 0) or 0,
+        "pending_proposals": (stats.pending_proposals if stats else 0) or 0,
+        "knowledge_items": (stats.knowledge_items if stats else 0) or 0,
     }

backend/app/api/documents.py

@@ -3,12 +3,13 @@ import os
 from uuid import UUID
 
 from fastapi import APIRouter, Depends, File, HTTPException, UploadFile
-from sqlalchemy.orm import Session
+from sqlalchemy.orm import Session, selectinload
 
 from app.core.dependencies import get_current_user
 from app.core.file_types import ALLOWED_EXTENSIONS
 from app.database.session import get_db
 from app.models.document import Document
+from app.models.document_version import DocumentVersion
 from app.models.user import User
 from app.models.workflow_run import WorkflowRun, WorkflowStatus
 from app.models.workspace import Workspace
@@ -32,6 +33,9 @@ def list_documents(
 
     documents = (
         db.query(Document)
+        .options(
+            selectinload(Document.versions).selectinload(DocumentVersion.workflow_runs)
+        )
         .filter(Document.workspace_id == workspace_id)
         .order_by(Document.created_at.desc())
         .all()

backend/app/api/workflows.py

@@ -1,9 +1,9 @@
-from __future__ import annotations
+from __future__ import annotations
 
 from uuid import UUID
 
 from fastapi import APIRouter, Depends, HTTPException
-from sqlalchemy.orm import Session
+from sqlalchemy.orm import Session, joinedload, selectinload
 
 from app.core.dependencies import get_current_user
 from app.database.session import get_db
@@ -93,6 +93,10 @@ def list_workflows(
 
     query = (
         db.query(WorkflowRun)
+        .options(
+            joinedload(WorkflowRun.document_version),
+            selectinload(WorkflowRun.checkpoints),
+        )
         .filter(WorkflowRun.workspace_id == workspace_id)
     )
 
@@ -115,6 +119,10 @@ def get_workflow_by_document_version(
 ):
     workflow = (
         db.query(WorkflowRun)
+        .options(
+            joinedload(WorkflowRun.document_version),
+            selectinload(WorkflowRun.checkpoints),
+        )
         .filter(WorkflowRun.document_version_id == document_version_id)
         .order_by(WorkflowRun.started_at.desc())
         .first()
@@ -166,6 +174,10 @@ def get_workflow(
 ):
     workflow = (
         db.query(WorkflowRun)
+        .options(
+            joinedload(WorkflowRun.document_version),
+            selectinload(WorkflowRun.checkpoints),
+        )
         .filter(WorkflowRun.id == workflow_id)
         .first()
     )

backend/app/database/database.py

@@ -6,8 +6,8 @@ from app.core.config import DATABASE_URL
 engine = create_engine(
     DATABASE_URL,
     pool_pre_ping=True,
-    pool_size=5,
-    max_overflow=10,
+    pool_size=10,
+    max_overflow=20,
     pool_recycle=300,
 )
 

docs/one-pager.md

@@ -0,0 +1,40 @@
+# DocWeave — One Page
+
+## What I Built
+
+DocWeave is an agentic document intelligence platform that transforms unstructured documents into a governed knowledge register. It processes PDFs through an AI pipeline (extract, chunk, embed, extract knowledge, reconcile, validate, decide) and either auto-commits verified knowledge or pauses for human review — depending on configurable validation rules.
+
+Think of it as "GitHub for documents": every knowledge change is proposed, validated against rules, reviewed if needed, and committed with full audit trail.
+
+## Who It's For
+
+Teams that manage large document corpora and need structured, searchable, auditable knowledge — compliance officers, research groups, clinical teams, legal departments. Anyone who's ever said "I know we read this somewhere but can't find which document said it."
+
+## Results
+
+- **End-to-end processing**: Upload a PDF, get structured knowledge items (ENTITY, CLAIM, METHOD, METRIC, OBSERVATION) with verbatim evidence quotes and confidence scores in 20-45 seconds.
+- **Zero-loss batch extraction**: Documents of any size are batched and processed sequentially — no data is truncated or lost.
+- **Human-in-the-loop**: 4 configurable validation operators (min_confidence, required_evidence, allowed_proposal_types, topic_relevance) determine auto-commit vs. human review.
+- **Crash resilience**: LangGraph checkpointing means workflows survive server restarts. Graceful shutdown waits for active work; auto-resume picks up orphaned workflows.
+- **MCP integration**: 15-tool Model Context Protocol server lets AI agents drive the full lifecycle programmatically.
+- **Deployed**: Frontend on Vercel, backend on HuggingFace Spaces (Docker), database on Neon PostgreSQL (Singapore).
+
+## Key Trade-Offs
+
+| Decision | Why |
+|----------|-----|
+| **Background threads (not Celery)** | Simpler deployment, no Redis/broker needed. Trade-off: limited to single-server horizontal scaling. Acceptable for a demo/small team tool. |
+| **Groq free tier LLM** | Zero cost, fast inference. Trade-off: strict request size limits on free org tier — knowledge extraction requires small batches. A paid tier or self-hosted model removes this. |
+| **Ephemeral file storage on HF** | Files don't persist across container restarts. Trade-off: retry on old docs fails. Acceptable because production would use S3/GCS. Demo works for freshly uploaded docs. |
+| **sentence-transformers local embeddings** | No external API dependency, runs on CPU. Trade-off: ~300MB memory footprint, can't run on 512MB servers (Render free tier). Works fine on HF Spaces (16GB RAM). |
+| **PostgreSQL for everything (vectors + relational)** | Single database, pgvector handles vector search. Trade-off: not as fast as dedicated vector DBs (Pinecone, Weaviate) at scale. Perfectly adequate for <100K documents. |
+| **Native JSON mode (not tool calling)** | More reliable structured output from Groq/Qwen/Llama models. Trade-off: less strict schema enforcement than OpenAI function calling. Mitigated by robust JSON parsing with fallbacks. |
+
+## What I'd Add With More Time
+
+- Persistent cloud storage (S3) for uploaded documents
+- WebSocket-based real-time progress (currently polls)
+- Multi-user collaboration with role-based access
+- Knowledge graph visualization (entity relationship map)
+- Automatic conflict resolution using LLM reasoning
+- PDF annotation overlay showing where each knowledge item was extracted from

frontend/src/api/client.js

@@ -1,6 +1,28 @@
 const API_BASE = import.meta.env.VITE_API_BASE_URL || (import.meta.env.DEV ? "http://localhost:8000" : "");
 
+const inFlightRequests = new Map();
+
 export const apiRequest = async (endpoint, method = "GET", body = null) => {
+    // Deduplicate concurrent in-flight GET requests
+    if (method === "GET" && !body) {
+        if (inFlightRequests.has(endpoint)) {
+            return inFlightRequests.get(endpoint);
+        }
+        const promise = (async () => {
+            try {
+                return await _performRequest(endpoint, method, body);
+            } finally {
+                inFlightRequests.delete(endpoint);
+            }
+        })();
+        inFlightRequests.set(endpoint, promise);
+        return promise;
+    }
+
+    return _performRequest(endpoint, method, body);
+};
+
+const _performRequest = async (endpoint, method = "GET", body = null) => {
     const token = localStorage.getItem("token");
     const headers = {};
 

frontend/src/context/WorkspaceContext.jsx

@@ -1,87 +1,106 @@
-import { createContext, useContext, useCallback, useEffect, useState } from "react";
-import { listWorkspaces, createWorkspace } from "../api/workspaces";
-
-const WorkspaceContext = createContext();
-
-export function WorkspaceProvider({ children }) {
-    const [workspaces, setWorkspaces] = useState([]);
-    const [currentId, setCurrentId] = useState(() => localStorage.getItem("dw_workspace_id") || null);
-    const [loading, setLoading] = useState(true);
-    const [error, setError] = useState(null);
-
-    const refresh = useCallback(async () => {
-        setLoading(true);
-        setError(null);
-        try {
-            const list = await listWorkspaces();
-
-            if (!Array.isArray(list)) {
-                setError(list?.detail || "Couldn't load workspaces.");
-                return;
-            }
-
-            if (list.length === 0) {
-                const created = await createWorkspace({
-                    name: "Default Workspace",
-                    description: "Created automatically for document uploads.",
-                });
-                if (created?.detail) {
-                    setError(created.detail);
-                    return;
-                }
-                setWorkspaces([created]);
-                setCurrentId(created.id);
-                localStorage.setItem("dw_workspace_id", created.id);
-                return;
-            }
-
-            setWorkspaces(list);
-            setCurrentId((prev) => {
-                const saved = prev || localStorage.getItem("dw_workspace_id");
-                if (saved && list.some((w) => w.id === saved)) return saved;
-                localStorage.setItem("dw_workspace_id", list[0].id);
-                return list[0].id;
-            });
-        } catch (err) {
-            setError("Couldn't load workspaces.");
-        } finally {
-            setLoading(false);
-        }
-    }, []);
-
-    useEffect(() => {
-        refresh();
-    }, [refresh]);
-
-    const selectWorkspace = useCallback((id) => {
-        setCurrentId(id);
-        localStorage.setItem("dw_workspace_id", id);
-    }, []);
-
-    const addWorkspace = useCallback(async (name, description = "") => {
-        const created = await createWorkspace({ name, description });
-        if (created?.detail) {
-            setError(created.detail);
-            return null;
-        }
-        setWorkspaces((prev) => [...prev, created]);
-        setCurrentId(created.id);
-        return created;
-    }, []);
-
-    const currentWorkspace = workspaces.find((w) => w.id === currentId) || null;
-
-    const value = {
-        workspace: currentWorkspace,
-        workspaces,
-        loading,
-        error,
-        selectWorkspace,
-        addWorkspace,
-        refresh,
-    };
-
-    return <WorkspaceContext.Provider value={value}>{children}</WorkspaceContext.Provider>;
-}
-
-export const useWorkspaceContext = () => useContext(WorkspaceContext);
+import { createContext, useContext, useCallback, useEffect, useState } from "react";
+import { listWorkspaces, createWorkspace } from "../api/workspaces";
+
+const WorkspaceContext = createContext();
+
+const getInitialCache = () => {
+    try {
+        const raw = localStorage.getItem("dw_workspaces_cache");
+        return raw ? JSON.parse(raw) : [];
+    } catch {
+        return [];
+    }
+};
+
+export function WorkspaceProvider({ children }) {
+    const [workspaces, setWorkspaces] = useState(getInitialCache);
+    const [currentId, setCurrentId] = useState(() => localStorage.getItem("dw_workspace_id") || null);
+    const [loading, setLoading] = useState(() => {
+        const cached = getInitialCache();
+        const savedId = localStorage.getItem("dw_workspace_id");
+        return !(cached.length > 0 && (savedId ? cached.some((w) => w.id === savedId) : true));
+    });
+    const [error, setError] = useState(null);
+
+    const refresh = useCallback(async () => {
+        setError(null);
+        try {
+            const list = await listWorkspaces();
+
+            if (!Array.isArray(list)) {
+                if (list?.detail) setError(list.detail);
+                return;
+            }
+
+            if (list.length === 0) {
+                const created = await createWorkspace({
+                    name: "Default Workspace",
+                    description: "Created automatically for document uploads.",
+                });
+                if (created?.detail) {
+                    setError(created.detail);
+                    return;
+                }
+                setWorkspaces([created]);
+                setCurrentId(created.id);
+                localStorage.setItem("dw_workspace_id", created.id);
+                localStorage.setItem("dw_workspaces_cache", JSON.stringify([created]));
+                return;
+            }
+
+            setWorkspaces(list);
+            localStorage.setItem("dw_workspaces_cache", JSON.stringify(list));
+            setCurrentId((prev) => {
+                const saved = prev || localStorage.getItem("dw_workspace_id");
+                if (saved && list.some((w) => w.id === saved)) return saved;
+                localStorage.setItem("dw_workspace_id", list[0].id);
+                return list[0].id;
+            });
+        } catch (err) {
+            setError("Couldn't load workspaces.");
+        } finally {
+            setLoading(false);
+        }
+    }, []);
+
+    useEffect(() => {
+        refresh();
+    }, [refresh]);
+
+    const selectWorkspace = useCallback((id) => {
+        setCurrentId(id);
+        localStorage.setItem("dw_workspace_id", id);
+    }, []);
+
+    const addWorkspace = useCallback(async (name, description = "") => {
+        const created = await createWorkspace({ name, description });
+        if (created?.detail) {
+            setError(created.detail);
+            return null;
+        }
+        setWorkspaces((prev) => {
+            const next = [...prev, created];
+            localStorage.setItem("dw_workspaces_cache", JSON.stringify(next));
+            return next;
+        });
+        setCurrentId(created.id);
+        localStorage.setItem("dw_workspace_id", created.id);
+        return created;
+    }, []);
+
+    const currentWorkspace = workspaces.find((w) => w.id === currentId) || (workspaces.length > 0 ? workspaces[0] : null);
+
+    const value = {
+        workspace: currentWorkspace,
+        workspaces,
+        loading,
+        error,
+        selectWorkspace,
+        addWorkspace,
+        refresh,
+    };
+
+    return <WorkspaceContext.Provider value={value}>{children}</WorkspaceContext.Provider>;
+}
+
+export const useWorkspaceContext = () => useContext(WorkspaceContext);

frontend/src/pages/Dashboard.css

@@ -212,6 +212,31 @@
   }
 }
 
+.dw-dashboard__skeleton {
+    animation: dw-shimmer 1.4s ease-in-out infinite;
+    background: var(--color-surface-hover);
+    border-radius: var(--radius-sm);
+    display: inline-block;
+}
+
+.dw-dashboard__skeleton-val {
+    width: 36px;
+    height: 28px;
+    vertical-align: middle;
+}
+
+.dw-dashboard__skeleton-row {
+    height: 38px;
+    margin-bottom: var(--space-2);
+    width: 100%;
+}
+
+@keyframes dw-shimmer {
+    0% { opacity: 0.35; }
+    50% { opacity: 0.75; }
+    100% { opacity: 0.35; }
+}
+
 @media (max-width: 480px) {
   .dw-dashboard__kpis {
     grid-template-columns: repeat(2, 1fr);

frontend/src/pages/Dashboard.jsx

@@ -32,41 +32,76 @@ const EVENT_ICONS = {
 const ACTIVE_STATUSES = new Set(["PENDING", "RUNNING"]);
 const POLL_INTERVAL = 3000;
 
+const getCachedDashboard = (workspaceId) => {
+    if (!workspaceId) return null;
+    try {
+        const raw = sessionStorage.getItem(`dw_dash_cache_${workspaceId}`);
+        return raw ? JSON.parse(raw) : null;
+    } catch {
+        return null;
+    }
+};
+
 export default function Dashboard() {
     const { workspace, loading: wsLoading } = useWorkspace();
     const navigate = useNavigate();
-    const [stats, setStats] = useState(null);
-    const [recentDocs, setRecentDocs] = useState([]);
-    const [activity, setActivity] = useState([]);
-    const [loading, setLoading] = useState(true);
+
+    const cached = getCachedDashboard(workspace?.id);
+    const [stats, setStats] = useState(() => cached?.stats ?? null);
+    const [recentDocs, setRecentDocs] = useState(() => cached?.recentDocs ?? []);
+    const [activity, setActivity] = useState(() => cached?.activity ?? []);
+    const [loading, setLoading] = useState(() => !cached);
 
     const load = useCallback(async () => {
         if (!workspace) return;
-        setLoading(true);
         try {
             const [s, docs, a] = await Promise.all([
                 getDashboardStats(workspace.id),
                 listDocuments(workspace.id),
                 listActivity(workspace.id, 8),
             ]);
-            if (!s?.detail) setStats(s);
-            if (Array.isArray(docs)) setRecentDocs(docs.slice(0, 5));
-            if (Array.isArray(a?.events)) setActivity(a.events);
-            else if (Array.isArray(a)) setActivity(a);
+
+            const newStats = (!s?.detail) ? s : null;
+            const newDocs = Array.isArray(docs) ? docs.slice(0, 5) : [];
+            const newActivity = Array.isArray(a?.events) ? a.events : (Array.isArray(a) ? a : []);
+
+            if (newStats) setStats(newStats);
+            setRecentDocs(newDocs);
+            setActivity(newActivity);
+
+            try {
+                sessionStorage.setItem(
+                    `dw_dash_cache_${workspace.id}`,
+                    JSON.stringify({ stats: newStats || stats, recentDocs: newDocs, activity: newActivity })
+                );
+            } catch {
+                // ignore quota errors
+            }
         } catch {
             // silently handle
         } finally {
             setLoading(false);
         }
-    }, [workspace]);
+    }, [workspace, stats]);
 
-    useEffect(() => { load(); }, [load]);
+    useEffect(() => {
+        if (workspace) {
+            const c = getCachedDashboard(workspace.id);
+            if (c) {
+                setStats(c.stats);
+                setRecentDocs(c.recentDocs);
+                setActivity(c.activity);
+                setLoading(false);
+            }
+            load();
+        }
+    }, [workspace?.id]); // eslint-disable-line react-hooks/exhaustive-deps
 
     // Poll every 3 s while any of the recent docs is actively processing.
     const hasActive = recentDocs.some((d) => ACTIVE_STATUSES.has(d.workflow_status));
     usePolling(load, POLL_INTERVAL, hasActive);
 
-    if (wsLoading || loading) return <LoadingState label="Loading dashboard..." />;
+    if (wsLoading && !workspace) return <LoadingState label="Loading dashboard..." />;
     if (!workspace) return <EmptyState title="No workspace" description="Create a workspace to get started." />;
 
     return (
@@ -84,27 +119,39 @@ export default function Dashboard() {
             {/* KPI Cards */}
             <div className="dw-dashboard__kpis">
                 <div className="dw-dashboard__kpi" onClick={() => navigate("/documents")} role="button">
-                    <span className="dw-dashboard__kpi-value">{stats?.total_documents ?? 0}</span>
+                    <span className="dw-dashboard__kpi-value">
+                        {stats ? (stats.total_documents ?? 0) : <span className="dw-dashboard__skeleton dw-dashboard__skeleton-val" />}
+                    </span>
                     <span className="dw-dashboard__kpi-label">Documents</span>
                 </div>
                 <div className="dw-dashboard__kpi dw-dashboard__kpi--accent" onClick={() => navigate("/workflows?filter=RUNNING")} role="button">
-                    <span className="dw-dashboard__kpi-value">{stats?.workflows_running ?? 0}</span>
+                    <span className="dw-dashboard__kpi-value">
+                        {stats ? (stats.workflows_running ?? 0) : <span className="dw-dashboard__skeleton dw-dashboard__skeleton-val" />}
+                    </span>
                     <span className="dw-dashboard__kpi-label">Running</span>
                 </div>
                 <div className="dw-dashboard__kpi dw-dashboard__kpi--warning" onClick={() => navigate("/workflows?filter=WAITING_FOR_REVIEW")} role="button">
-                    <span className="dw-dashboard__kpi-value">{stats?.workflows_waiting_for_review ?? 0}</span>
+                    <span className="dw-dashboard__kpi-value">
+                        {stats ? (stats.workflows_waiting_for_review ?? 0) : <span className="dw-dashboard__skeleton dw-dashboard__skeleton-val" />}
+                    </span>
                     <span className="dw-dashboard__kpi-label">Needs Review</span>
                 </div>
                 <div className="dw-dashboard__kpi dw-dashboard__kpi--success" onClick={() => navigate("/workflows?filter=COMPLETED")} role="button">
-                    <span className="dw-dashboard__kpi-value">{stats?.workflows_completed ?? 0}</span>
+                    <span className="dw-dashboard__kpi-value">
+                        {stats ? (stats.workflows_completed ?? 0) : <span className="dw-dashboard__skeleton dw-dashboard__skeleton-val" />}
+                    </span>
                     <span className="dw-dashboard__kpi-label">Completed</span>
                 </div>
                 <div className="dw-dashboard__kpi" onClick={() => navigate("/workflows?filter=WAITING_FOR_REVIEW")} role="button">
-                    <span className="dw-dashboard__kpi-value">{stats?.pending_proposals ?? 0}</span>
+                    <span className="dw-dashboard__kpi-value">
+                        {stats ? (stats.pending_proposals ?? 0) : <span className="dw-dashboard__skeleton dw-dashboard__skeleton-val" />}
+                    </span>
                     <span className="dw-dashboard__kpi-label">Pending Proposals</span>
                 </div>
                 <div className="dw-dashboard__kpi" onClick={() => navigate("/knowledge")} role="button">
-                    <span className="dw-dashboard__kpi-value">{stats?.knowledge_items ?? 0}</span>
+                    <span className="dw-dashboard__kpi-value">
+                        {stats ? (stats.knowledge_items ?? 0) : <span className="dw-dashboard__skeleton dw-dashboard__skeleton-val" />}
+                    </span>
                     <span className="dw-dashboard__kpi-label">Knowledge Items</span>
                 </div>
             </div>
@@ -128,7 +175,12 @@ export default function Dashboard() {
                         }
                     />
                     <CardBody>
-                        {recentDocs.length === 0 ? (
+                        {loading && recentDocs.length === 0 ? (
+                            <div className="dw-dashboard__doc-list">
+                                <div className="dw-dashboard__skeleton dw-dashboard__skeleton-row" />
+                                <div className="dw-dashboard__skeleton dw-dashboard__skeleton-row" />
+                            </div>
+                        ) : recentDocs.length === 0 ? (
                             <p className="dw-text-muted">No documents yet.</p>
                         ) : (
                             <div className="dw-dashboard__doc-list">
@@ -187,7 +239,12 @@ export default function Dashboard() {
                     action={<Button size="sm" variant="ghost" onClick={() => navigate("/activity")}>View all</Button>}
                 />
                 <CardBody>
-                    {activity.length === 0 ? (
+                    {loading && activity.length === 0 ? (
+                        <div className="dw-dashboard__activity">
+                            <div className="dw-dashboard__skeleton dw-dashboard__skeleton-row" />
+                            <div className="dw-dashboard__skeleton dw-dashboard__skeleton-row" />
+                        </div>
+                    ) : activity.length === 0 ? (
                         <p className="dw-text-muted">No activity yet.</p>
                     ) : (
                         <div className="dw-dashboard__activity">
@@ -211,3 +268,4 @@ export default function Dashboard() {
         </div>
     );
 }
+

frontend/src/pages/auth/Login.jsx

@@ -46,10 +46,6 @@ export default function Login() {
             }
 
             login(result.access_token);
-
-            const me = await apiRequest("/auth/me");
-            if (me && !me.detail) setUser(me);
-
             navigate(redirectTo, { replace: true });
         } catch (err) {
             setError("Couldn't reach the server. Please try again.");