feat: track SDK/MCP client usage in Logfire spans (#380)

- add request_attributes_mapper to parse User-Agent headers
- enrich spans with client_type (sdk/mcp/browser) and client_version
- enables filtering/clustering traffic by source in Logfire UI
- fix stats positioning on album detail page (move Header outside container)
- fix pre-existing lint warning in test_auth.py

closes #377

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-authored-by: Claude <[e-mail]>

backend/src/backend/main.py

···
 """relay fastapi application."""
 
 import logging
+import re
 import warnings
 from collections.abc import AsyncIterator
 from contextlib import asynccontextmanager
+from typing import Any
 
-from fastapi import FastAPI, Request
+from fastapi import FastAPI, Request, WebSocket
 from fastapi.middleware.cors import CORSMiddleware
 from fastapi.responses import ORJSONResponse
 from slowapi import _rate_limit_exceeded_handler
···
 
 logger = logging.getLogger(__name__)
 
+# pattern to match plyrfm SDK/MCP user-agent headers
+# format: "plyrfm/{version}" or "plyrfm-mcp/{version}"
+_PLYRFM_UA_PATTERN = re.compile(r"^plyrfm(-mcp)?/(\d+\.\d+\.\d+)")
+
+
+def parse_plyrfm_user_agent(user_agent: str | None) -> dict[str, str]:
+    """parse plyrfm SDK/MCP user-agent into span attributes.
+
+    returns dict with:
+        - client_type: "sdk", "mcp", or "browser"
+        - client_version: version string (only for sdk/mcp)
+    """
+    if not user_agent:
+        return {"client_type": "browser"}
+
+    match = _PLYRFM_UA_PATTERN.match(user_agent)
+    if not match:
+        return {"client_type": "browser"}
+
+    is_mcp = match.group(1) is not None  # "-mcp" suffix present
+    version = match.group(2)
+
+    return {
+        "client_type": "mcp" if is_mcp else "sdk",
+        "client_version": version,
+    }
+
+
+def request_attributes_mapper(
+    request: Request | WebSocket, attributes: dict[str, Any], /
+) -> dict[str, Any] | None:
+    """extract client metadata from request headers for span enrichment."""
+    user_agent = request.headers.get("user-agent")
+    return parse_plyrfm_user_agent(user_agent)
+
 
 class SecurityHeadersMiddleware(BaseHTTPMiddleware):
     """middleware to add security headers to all responses."""
···
 
 # instrument fastapi with logfire
 if logfire:
-    logfire.instrument_fastapi(app)
+    logfire.instrument_fastapi(app, request_attributes_mapper=request_attributes_mapper)
 
 # add security headers middleware
 app.add_middleware(SecurityHeadersMiddleware)

backend/tests/test_auth.py

···
     # consume token first time
     result = await consume_exchange_token(token)
     assert result is not None
-    returned_session_id, is_dev_token = result
+    returned_session_id, _is_dev_token = result
     assert returned_session_id == session_id
 
     # try to consume again - should return None

backend/tests/test_user_agent.py

···
+"""tests for user-agent parsing and span enrichment."""
+
+import pytest
+
+from backend.main import parse_plyrfm_user_agent
+
+
+class TestParsePlyrfmUserAgent:
+    """tests for parse_plyrfm_user_agent function."""
+
+    def test_sdk_user_agent(self) -> None:
+        """sdk user-agent returns client_type=sdk with version."""
+        result = parse_plyrfm_user_agent("plyrfm/0.1.0")
+        assert result == {"client_type": "sdk", "client_version": "0.1.0"}
+
+    def test_mcp_user_agent(self) -> None:
+        """mcp user-agent returns client_type=mcp with version."""
+        result = parse_plyrfm_user_agent("plyrfm-mcp/0.2.1")
+        assert result == {"client_type": "mcp", "client_version": "0.2.1"}
+
+    def test_browser_user_agent(self) -> None:
+        """standard browser user-agent returns client_type=browser."""
+        result = parse_plyrfm_user_agent(
+            "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) "
+            "AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36"
+        )
+        assert result == {"client_type": "browser"}
+        assert "client_version" not in result
+
+    def test_none_user_agent(self) -> None:
+        """missing user-agent returns client_type=browser."""
+        result = parse_plyrfm_user_agent(None)
+        assert result == {"client_type": "browser"}
+
+    def test_empty_user_agent(self) -> None:
+        """empty string user-agent returns client_type=browser."""
+        result = parse_plyrfm_user_agent("")
+        assert result == {"client_type": "browser"}
+
+    def test_curl_user_agent(self) -> None:
+        """curl user-agent returns client_type=browser (generic fallback)."""
+        result = parse_plyrfm_user_agent("curl/8.4.0")
+        assert result == {"client_type": "browser"}
+
+    @pytest.mark.parametrize(
+        ("user_agent", "expected_type", "expected_version"),
+        [
+            ("plyrfm/1.0.0", "sdk", "1.0.0"),
+            ("plyrfm/0.0.1", "sdk", "0.0.1"),
+            ("plyrfm/10.20.30", "sdk", "10.20.30"),
+            ("plyrfm-mcp/1.0.0", "mcp", "1.0.0"),
+            ("plyrfm-mcp/0.0.1", "mcp", "0.0.1"),
+        ],
+    )
+    def test_version_variations(
+        self, user_agent: str, expected_type: str, expected_version: str
+    ) -> None:
+        """various version formats are parsed correctly."""
+        result = parse_plyrfm_user_agent(user_agent)
+        assert result["client_type"] == expected_type
+        assert result["client_version"] == expected_version
+
+    def test_plyrfm_prefix_not_at_start(self) -> None:
+        """plyrfm in middle of string is not matched (browser fallback)."""
+        result = parse_plyrfm_user_agent("Mozilla/5.0 plyrfm/1.0.0")
+        assert result == {"client_type": "browser"}
+
+    def test_invalid_version_format(self) -> None:
+        """invalid version format falls back to browser."""
+        result = parse_plyrfm_user_agent("plyrfm/v1.0")
+        assert result == {"client_type": "browser"}

frontend/src/routes/u/[handle]/album/[slug]/+page.svelte

···
 	{/if}
 </svelte:head>
 
+<Header user={auth.user} isAuthenticated={auth.isAuthenticated} onLogout={() => goto('/login')} />
 <div class="container">
-	<Header user={auth.user} isAuthenticated={auth.isAuthenticated} onLogout={() => goto('/login')} />
 	<main>
 		<div class="album-hero">
 			{#if album.metadata.image_url}