@@ -434,6 +434,7 @@ The below describes the user-facing surfaces built on top of the framework.
 - Surfaces targets, scenarios, and health/version endpoints; served via `uvicorn` with Swagger/ReDoc docs.
 - Wherever possible it should reuse other components rather than reimplementing them (e.g. the registry to build components, `pyrit.models` for its model layer), while adding presentation-specific information on top as needed.
 - Organized into `routes/`, `services/`, `models/`, `mappers/`, and `middleware/`, and launched through the `pyrit_backend` command (configurable via `PYRIT_API_HOST` / `PYRIT_API_PORT` / `PYRIT_API_RELOAD`).
+- Saved-result analytics routes consume the cached SDK directly and serialize shared models. The shared runtime owns admission, busy checks, SDK draining and cache invalidation before memory replacement/disposal, including work still cleaning up after an HTTP timeout. It does not calculate statistics or add an SDK authorization scope.
 
 ## [CLI](../scanner/0_scanner)
 
 
@@ -103,9 +103,11 @@ The query grain is a distinct stored `AttackResultEntry.id`. Different result ID
 sharing a conversation remain different results. For callers that need full result
 objects, `MemoryInterface.get_attack_results_async` accepts the opt-in
 `result_selection=AttackResultSelection.ALL_RESULTS` mode. The deprecated sync
-method also accepts this mode. Both default to
-`LATEST_PER_CONVERSATION`, including existing History callers. Turn bounds apply
-after selection, and neither mode deletes or rewrites stored duplicates.
+method also accepts this mode. Both still default to `LATEST_PER_CONVERSATION`.
+The backend's Attack History listing explicitly requests `ALL_RESULTS` and
+fingerprints that mode in its cursor; unrelated SDK and scenario callers keep
+their existing selection. Turn bounds apply after selection, and neither mode
+deletes or rewrites stored duplicates.
 
 Revision `901e6c7bf9d4` follows the published `main` head `34a18645c7e9`. It
 bounds `outcome` to 16 characters and adds the computed
 
@@ -404,6 +404,12 @@ Human score changes do not require a registered objective target. The original o
 
 The History view lists all past attacks with filtering and pagination.
 
+Each saved result ID is a separate row, even when several results share one
+conversation. Failed attempts followed by successful retries are not collapsed.
+Existing filters and recency ordering are unchanged. A pagination cursor from
+before this selection change restarts at the first page. Scenario run statistics
+still count their latest execution units, not these raw result rows.
+
 <img width="1664" alt="Attack history view" src="images/history.png" />
 
 #### Filters
@@ -578,6 +584,10 @@ runtime operation is active. Wait for the work to finish, or cancel it with its
 When the runtime is idle, PyRIT closes admission and checks again before it changes runtime state. This second check
 prevents newly admitted work from overlapping replacement.
 
+Analytics also remains busy while a query's native database/session cleanup is
+running after an HTTP timeout. Live apply waits for the user to retry once that
+work has drained; receiving a timeout response does not make memory safe to replace.
+
 Operation status survives a browser disconnect or navigation; other connected clients detect runtime generation
 changes and refresh catalogs without discarding chat or configuration drafts.
 
@@ -588,6 +598,10 @@ a single request or cleanup failure is re-raised unchanged, while multiple failu
 Shutdown can therefore wait for an outstanding operation. Runtime readiness reports `ready: false` and
 `state: stopping` as soon as shutdown closes admission, including while an accepted live apply finishes.
 
+Analytics shutdown closes its shared SDK lifetime on the owning event loop and
+clears the cached dependency before memory disposal. If that drain fails, the
+backend retains the owner and memory rather than disposing resources still in use.
+
 If validation fails, PyRIT does not change the live runtime. Repair the saved source and retry. If startup fails, or
 if live initialization fails after replacement starts, runtime operations stay unavailable until you restart the
 backend. The administration UI stays available for configuration repair. Authentication and authorization retain
 
@@ -115,6 +115,11 @@ def is_closed(self) -> bool:
         """Whether shutdown has drained all started operations, not just their callers."""
         return self._closed
 
+    @property
+    def has_active_work(self) -> bool:
+        """Whether admission, operations, or shutdown cleanup still occupy this lifetime."""
+        return (self._closing and not self._closed) or any(lane.active or lane.queued for lane in self._lanes.values())
+
     async def run_async(self, *, report: bool, task: Callable[[QueryControl], Awaitable[T]]) -> T:
         """
         Admit one operation and await its response without blocking the owning loop.
 
@@ -75,6 +75,21 @@ def __init__(self, *, memory: MemoryInterface | None = None) -> None:
         self._controller: AnalyticsExecution | None = None
         self._closed = False
 
+    @property
+    def has_active_work(self) -> bool:
+        """
+        Whether this facade's shared controller still owns admitted work or cleanup.
+
+        This includes work whose caller timed out or was cancelled. Reading the
+        status never creates a controller or opens a session.
+        """
+        return self._controller is not None and self._controller.has_active_work
+
+    @property
+    def is_closed(self) -> bool:
+        """Whether this facade is terminal and its attached controller has finished draining."""
+        return self._closed or (self._controller is not None and self._controller.is_closed)
+
     async def __aenter__(self) -> Self:
         """
         Acquire the shared execution lifetime without opening a database session.
 
@@ -27,6 +27,7 @@
 from pyrit.backend.middleware.request_size import RequestSizeLimitMiddleware
 from pyrit.backend.middleware.runtime import RuntimeAdmissionMiddleware
 from pyrit.backend.routes import (
+    analytics,
     attacks,
     auth,
     configuration,
@@ -121,6 +122,7 @@ async def lifespan(app: FastAPI) -> AsyncGenerator[None, None]:
 
 
 # Include API routes
+app.include_router(analytics.router, prefix="/api", tags=["analytics"])
 app.include_router(attacks.router, prefix="/api", tags=["attacks"])
 app.include_router(message_sends.router, prefix="/api", tags=["attacks"])
 app.include_router(configuration.router, prefix="/api", tags=["config"])
 
@@ -13,13 +13,41 @@
 
 from pyrit.backend.middleware.request_size import RequestTooLargeError, request_too_large_response
 from pyrit.backend.models.common import FieldError, ProblemDetail
+from pyrit.exceptions.analytics_exception import AnalyticsException
 
 logger = logging.getLogger(__name__)
 
 
 def register_error_handlers(app: FastAPI) -> None:
     """Register all error handlers with the FastAPI app."""
 
+    @app.exception_handler(AnalyticsException)
+    async def analytics_exception_handler_async(request: Request, exc: AnalyticsException) -> JSONResponse:
+        """
+        Surface overload, deadlines, and stored-data failures without empty-report fallbacks.
+
+        Returns:
+            JSONResponse: The shared error contract, with retry guidance for overload.
+        """
+        logger.warning(
+            "Analytics request failed on %s request_id=%s: %s",
+            request.url.path,
+            getattr(request.state, "request_id", None),
+            exc.message,
+        )
+        problem = ProblemDetail(
+            type="/errors/analytics",
+            title="Analytics unavailable",
+            status=exc.status_code,
+            detail=exc.message,
+            instance=str(request.url.path),
+        )
+        return JSONResponse(
+            status_code=exc.status_code,
+            content=problem.model_dump(exclude_none=True),
+            headers={"Retry-After": "1"} if exc.status_code == status.HTTP_503_SERVICE_UNAVAILABLE else None,
+        )
+
     @app.exception_handler(RequestValidationError)
     async def validation_exception_handler(  # pyrit-async-suffix-exempt
         request: Request,
 
@@ -0,0 +1,60 @@
+# Copyright (c) Microsoft Corporation.
+# Licensed under the MIT license.
+
+"""Read-only saved-result analytics through the shared SDK."""
+
+from typing import Annotated
+
+from fastapi import APIRouter, Depends
+
+from pyrit.analytics import AttackResultAnalytics
+from pyrit.backend.models.common import ProblemDetail
+from pyrit.backend.services.analytics_service import get_analytics_service_async
+from pyrit.models import (
+    AttackAnalyticsFacetQuery,
+    AttackAnalyticsFacets,
+    AttackAnalyticsQuery,
+    AttackAnalyticsReport,
+    AttackAnalyticsResults,
+    AttackAnalyticsResultsQuery,
+)
+
+router = APIRouter(
+    prefix="/analytics/attacks",
+    tags=["analytics"],
+    responses={
+        400: {"model": ProblemDetail, "description": "Invalid or mismatched result cursor"},
+        422: {"model": ProblemDetail, "description": "Invalid analytics query"},
+        500: {"model": ProblemDetail, "description": "Stored data or unexpected query failure"},
+        503: {"model": ProblemDetail, "description": "Analytics capacity is busy; retry after one second"},
+        504: {"model": ProblemDetail, "description": "The analytics query exceeded its deadline"},
+    },
+)
+
+
+@router.post("/query", response_model=AttackAnalyticsReport)
+async def query_analytics_async(
+    *, query: AttackAnalyticsQuery, analytics: Annotated[AttackResultAnalytics, Depends(get_analytics_service_async)]
+) -> AttackAnalyticsReport:
+    """Return SDK statistics and a coherent first result page."""
+    return await analytics.query_async(query=query)
+
+
+@router.post("/results", response_model=AttackAnalyticsResults)
+async def query_results_async(
+    *,
+    query: AttackAnalyticsResultsQuery,
+    analytics: Annotated[AttackResultAnalytics, Depends(get_analytics_service_async)],
+) -> AttackAnalyticsResults:
+    """Return a fresh lightweight page without recalculating reports."""
+    return await analytics.results_async(query=query)
+
+
+@router.post("/facets", response_model=AttackAnalyticsFacets)
+async def query_facets_async(
+    *,
+    query: AttackAnalyticsFacetQuery,
+    analytics: Annotated[AttackResultAnalytics, Depends(get_analytics_service_async)],
+) -> AttackAnalyticsFacets:
+    """Return options for one dimension without recalculating reports."""
+    return await analytics.facets_async(query=query)
@@ -0,0 +1,41 @@
+# Copyright (c) Microsoft Corporation.
+# Licensed under the MIT license.
+
+"""Backend ownership of the direct SDK dependency, not a forwarding service."""
+
+from functools import lru_cache
+
+from pyrit.analytics import AttackResultAnalytics
+
+
+@lru_cache(maxsize=1)
+def get_analytics_service() -> AttackResultAnalytics:
+    """
+    Resolve one long-lived SDK facade after startup has configured CentralMemory.
+
+    Returns:
+        AttackResultAnalytics: The direct SDK dependency for this runtime.
+    """
+    return AttackResultAnalytics()
+
+
+async def get_analytics_service_async() -> AttackResultAnalytics:
+    """
+    Resolve the cached SDK on the runtime loop, avoiding concurrent threadpool cache misses.
+
+    Returns:
+        AttackResultAnalytics: The same SDK owner for concurrent HTTP dependencies.
+    """
+    return get_analytics_service()
+
+
+async def close_analytics_service_async() -> None:
+    """Drain on the owning loop before releasing the cached memory reference."""
+    if get_analytics_service.cache_info().currsize:
+        analytics = get_analytics_service()
+        try:
+            await analytics.close_async()
+        finally:
+            # Cancellation may propagate after draining; a failed drain must retain its owner.
+            if analytics.is_closed:
+                get_analytics_service.cache_clear()