Standalone Shonar Desktop: vendor portable sources + local engine; decouple from ~/Projects/Shonar

- shared/ = portable Android-origin sources vendored from deferred/desktop-server
  (app/build.gradle.kts srcDir repointed; PlaybackController.kt excluded as Android-only)
- backend/ = bundled-lite engine (SQLite + inline queue); .venv symlinked from the
  old checkout, PYTHONPATH pins THIS backend's code over any editable install
- repoRoot() resolves this project dir (env SHONAR_REPO still wins); desktop-dev.sh
  watches shared/ + backend/
- Verified: :app:compileKotlin + :app:test green (23 tests); engine boots on :8010,
  self-migrates, /healthz ok

backend/shonar/services/ai/openai_compat.py

@@ -0,0 +1,82 @@
+"""Summaries via any OpenAI-compatible chat endpoint (self-hosted
+vLLM/llama.cpp server, commercial API, …) with JSON mode.
+"""
+
+from __future__ import annotations
+
+from collections.abc import AsyncIterator
+from contextlib import asynccontextmanager
+
+import httpx
+
+from shonar.services.ai import ProviderConfigError, ProviderTransientError, SummaryResult
+from shonar.services.ai._llm import SYSTEM_PROMPT, build_user_message, parse_summary
+
+
+class OpenAICompatProvider:
+    name = "openai_compat"
+
+    def __init__(
+        self,
+        base_url: str,
+        model: str = "",
+        api_key: str = "",
+        timeout_s: float = 180.0,
+        http_client: httpx.AsyncClient | None = None,
+    ) -> None:
+        if not base_url.strip():
+            raise ProviderConfigError("openai_compat needs SHONAR_LLM_BASE_URL.")
+        if not model.strip():
+            raise ProviderConfigError("openai_compat needs SHONAR_LLM_MODEL.")
+        self.base_url = base_url.rstrip("/")
+        self.model = model
+        self.api_key = api_key
+        self.timeout_s = timeout_s
+        self.http_client = http_client
+
+    @asynccontextmanager
+    async def _client(self) -> AsyncIterator[httpx.AsyncClient]:
+        if self.http_client is not None:
+            yield self.http_client
+        else:
+            async with httpx.AsyncClient(timeout=self.timeout_s) as client:
+                yield client
+
+    async def summarize(self, transcript: str, *, title: str | None = None) -> SummaryResult:
+        headers = (
+            {"Authorization": f"Bearer {self.api_key}"} if self.api_key else {}
+        )
+        payload = {
+            "model": self.model,
+            "temperature": 0.2,
+            "response_format": {"type": "json_object"},
+            "messages": [
+                {"role": "system", "content": SYSTEM_PROMPT},
+                {"role": "user", "content": build_user_message(transcript, title)},
+            ],
+        }
+        try:
+            async with self._client() as client:
+                resp = await client.post(
+                    f"{self.base_url}/v1/chat/completions", headers=headers, json=payload
+                )
+        except (httpx.TimeoutException, httpx.TransportError) as e:
+            raise ProviderTransientError(f"LLM unreachable: {type(e).__name__}") from e
+        if resp.status_code in (401, 403, 404):
+            raise ProviderConfigError(f"LLM refused the request (HTTP {resp.status_code}).")
+        if resp.status_code == 429 or resp.status_code >= 500:
+            raise ProviderTransientError(f"LLM busy (HTTP {resp.status_code}).")
+        if resp.status_code != 200:
+            raise ProviderTransientError(f"Summarization failed (HTTP {resp.status_code}).")
+        try:
+            body = resp.json()
+            content = body["choices"][0]["message"]["content"]
+        except (ValueError, KeyError, IndexError, TypeError) as e:
+            raise ProviderTransientError("LLM sent an unreadable reply.") from e
+        import json as _json
+
+        try:
+            data = _json.loads(content)
+        except ValueError as e:
+            raise ProviderTransientError("LLM reply was not JSON.") from e
+        return parse_summary(data, self.model)