WP-0001-T014: minimal HTTP app and CLI

src/artifactstore/app.py (new): composition root. build_registry(settings)
wires AsyncEngine + LocalBackend + InProcessDataPlane + RegistryViewWriter
into a Registry. Used by both the HTTP app and the CLI.

src/artifactstore/registry/__init__.py: adds db_health() (SELECT 1 probe),
backend_health() (pass-through to dataplane), and dispose() (engine
shutdown) helpers so the HTTP /health endpoint and CLI commands can talk
to the registry without reaching for private state.

src/artifactstore/api/http/__init__.py:
- create_app(settings=None) factory; lifespan owns the registry instance
  and disposes it on shutdown.
- GET / returns the scaffold banner.
- GET /health reports overall status + db {healthy, detail} + backend
  {backend_id, healthy, detail, free_bytes, total_bytes}. Uses
  FastAPI Depends() with a request->state.registry helper rather than
  reaching app.state directly.
- Module-level `app = create_app()` so `uvicorn artifactstore.api.http:app`
  keeps working.

src/artifactstore/cli/__init__.py:
- migrate: `alembic upgrade head` via the alembic command API.
- replay: drops + rebuilds materialised views from the event log; prints
  the highest applied sequence.
- health: prints the same payload as the HTTP /health endpoint, as JSON.
- version unchanged.

Tests:
- tests/integration/test_http_health.py (TestClient-based): /
  scaffold banner; /health reports ok with db.healthy + backend.healthy
  + free_bytes populated.
- tests/integration/test_cli_commands.py (typer CliRunner): version
  prints; migrate creates the schema (events + retention_classes +
  alembic_version); replay against an empty log exits ok with
  "replayed up to sequence 0"; health prints a status=ok JSON payload.

Gates: ruff clean, mypy --strict clean on 48 files, 83 tests pass.

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

src/artifactstore/api/http/__init__.py

@@ -1,24 +1,80 @@
-"""FastAPI application entry point.
+"""FastAPI application — HTTP surface for the registry.
 
-The full registry-aware ``/health`` endpoint lands in
-ARTIFACT-STORE-WP-0001-T014. This scaffold exposes a minimal root route so
-``make dev`` has something to serve while the registry layer is being built.
+T014 ships a minimal app with two routes:
+
+* ``GET /`` — service banner.
+* ``GET /health`` — registry liveness + DB connectivity + storage backend.
+
+Richer endpoints (package CRUD, file upload, manifest retrieval, event
+stream) land in workplan WP-0002. The app is built through
+:func:`create_app` so tests can inject their own settings.
 """
 
 from __future__ import annotations
 
-from fastapi import FastAPI
+from contextlib import asynccontextmanager
+from typing import Any
+
+from fastapi import Depends, FastAPI, Request
 
 from artifactstore import __version__
+from artifactstore.app import build_registry
+from artifactstore.config import Settings
+from artifactstore.registry import Registry
 
-app = FastAPI(title="artifact-store", version=__version__)
+__all__ = ["app", "create_app"]
 
 
-@app.get("/")
-def root() -> dict[str, str]:
-    """Return a service banner indicating the scaffold is up."""
-    return {
-        "service": "artifact-store",
-        "version": __version__,
-        "status": "scaffold",
-    }
+def get_registry(request: Request) -> Registry:
+    return request.app.state.registry  # type: ignore[no-any-return]
+
+
+def create_app(settings: Settings | None = None) -> FastAPI:
+    """Build the FastAPI app. Lifespan owns the registry instance."""
+
+    @asynccontextmanager
+    async def lifespan(application: FastAPI) -> Any:
+        registry = build_registry(settings)
+        application.state.registry = registry
+        try:
+            yield
+        finally:
+            await registry.dispose()
+
+    application = FastAPI(
+        title="artifact-store",
+        version=__version__,
+        lifespan=lifespan,
+    )
+
+    @application.get("/")
+    def root() -> dict[str, str]:
+        return {
+            "service": "artifact-store",
+            "version": __version__,
+            "status": "scaffold",
+        }
+
+    @application.get("/health")
+    async def health(registry: Registry = Depends(get_registry)) -> dict[str, Any]:
+        db_ok, db_detail = await registry.db_health()
+        backend_status = await registry.backend_health()
+        overall = "ok" if db_ok and backend_status.healthy else "degraded"
+        return {
+            "service": "artifact-store",
+            "version": __version__,
+            "status": overall,
+            "db": {"healthy": db_ok, "detail": db_detail},
+            "backend": {
+                "backend_id": backend_status.backend_id,
+                "healthy": backend_status.healthy,
+                "detail": backend_status.detail,
+                "free_bytes": backend_status.free_bytes,
+                "total_bytes": backend_status.total_bytes,
+            },
+        }
+
+    return application
+
+
+app = create_app()