feat(logic): dostawcy LLM i pisanie horoskopu (LOG-31)

Domyslnie model LOKALNY — prompt niesie oryginalne opisy z baz, wiec
domyslnie NIC nie opuszcza sieci. Chmura wlaczana swiadomie (LOG-32).

- app/llm/: LLMProvider (jak EphemerisEngine z LOG-24) + dwie implementacje.
  Lokalny serwer modelu (Ollama/vLLM/llama.cpp) i OpenAI mowia TYM SAMYM
  protokolem /chat/completions, wiec obsluguje je jedna klasa; Anthropic ma
  wlasny /v1/messages. Napisane na samym httpx — bez SDK openai/anthropic:
  mniej zaleznosci i pelna kontrola nad tym, co wychodzi z sieci.
- Kazdy dostawca deklaruje `leaves_lan` — interfejs MUSI jawnie mowic, czy
  tresc baz opuszcza siec; UI na tej podstawie ostrzega.
- Ponawianie z backoffem (429/5xx), timeouty, czytelne bledy zamiast stacktrace.
- Klucz wylacznie z LLM_API_KEY (sekret), nigdy w repo ani w UI.
- POST /chart/horoscope + GET /llm/health.

WAZNE: prompt jest zwracany ZAWSZE — takze gdy model padnie lub brakuje
klucza. Dzieki temu awaria dostawcy nie blokuje pracy: prompt mozna
skopiowac i uzyc recznie.

Prezentacja: wybor modelu (lokalny/Anthropic/OpenAI), przycisk „Napisz
horoskop (AI)", wynik z informacja kto go napisal, czy dane opuscily siec,
ile wskazan weszlo, oraz zastrzezenie ze to nie porada medyczna (PRE-15).

Testy: 13 nowych (transport podstawiony — zaden prawdziwy model nie wolany),
calosc 131 passed / 1 skipped. Zweryfikowane e2e na atrapie serwera modelu:
horoskop napisany, leaves_lan=false, tokeny zliczone; a przy padnietym
modelu / braku klucza / zlym dostawcy — czytelny blad i zachowany prompt.

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

.gitea/workflows/tests.yml

@@ -51,26 +51,6 @@ jobs:
           EPHEMERIS_DIR: ${{ github.workspace }}/services/logic/.ephemeris
         run: pytest tests -q -rs
 
-  presentation-tests:
-    name: Testy warstwy prezentacji (dostęp do baz)
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v4
-      - uses: actions/setup-python@v5
-        with:
-          python-version: "3.12"
-          cache: pip
-          cache-dependency-path: services/presentation/requirements-dev.txt
-      - name: Instalacja zależności
-        run: pip install -r services/presentation/requirements-dev.txt
-      # Bramka chroniąca oryginalne bazy — nietestowany kod ochronny jest gorszy
-      # niż jego brak, bo daje złudzenie zabezpieczenia.
-      - name: Testy (pytest)
-        working-directory: services/presentation
-        env:
-          PYTHONPATH: .
-        run: pytest tests -q -rs
-
   swisseph-image:
     name: Build obrazu silnika B (swisseph)
     runs-on: ubuntu-latest

services/data/app/main.py

@@ -10,7 +10,6 @@ from contextlib import asynccontextmanager
 
 from fastapi import FastAPI
 
-from app import security
 from app.config import settings
 from app.models import HealthInfo, SearchQuery, SearchResult
 from app.providers.factory import build_provider
@@ -25,7 +24,6 @@ async def lifespan(app: FastAPI):
 
 
 app = FastAPI(title="astrololo · warstwa bazodanowa", lifespan=lifespan)
-security.install(app, "danych")       # token międzywarstwowy (LOG-32)
 
 
 @app.post("/search", response_model=SearchResult)

services/data/app/models.py

@@ -18,10 +18,7 @@ class SearchQuery(BaseModel):
     key: str = Field(..., description="Pole/kolumna kanoniczna, po której szukamy, np. 'name'.")
     value: str = Field(..., description="Szukana wartość.")
     exact: bool = Field(False, description="Dopasowanie dokładne vs. zawieranie (contains).")
-    # Górny limit celowo niski: to zapytanie oddaje SUROWE wiersze baz, więc wysoki
+    limit: int = Field(50, ge=1, le=50000)
-    # pułap zamienia je w narzędzie do masowego pobrania (LOG-32). 5000 = tyle, ile
-    # realnie potrzebuje build_report na jeden obiekt.
-    limit: int = Field(50, ge=1, le=5000)
     fields: list[str] | None = Field(
         None, description="Lista pól kanonicznych do zwrócenia; None = wszystkie."
     )

services/data/app/security.py

@@ -1,50 +0,0 @@
-"""Uwierzytelnianie międzywarstwowe (LOG-32).
-
-Warstwa danych oddaje SUROWE wiersze baz — to najbardziej wrażliwy punkt całego
-systemu. Bez tego kontrolera wystarczyłoby uderzyć w nią bezpośrednio, z pominięciem
-i logiki, i logowania w UI. Gdy ustawiono INTERNAL_TOKEN, każde żądanie (poza /health)
-musi go przynieść w nagłówku X-Astrololo-Token.
-
-Bez INTERNAL_TOKEN kontrola jest wyłączona (dev / zgodność wstecz) — wtedy przy
-starcie leci ostrzeżenie.
-"""
-from __future__ import annotations
-
-import logging
-import os
-import secrets
-
-from fastapi import Request
-from fastapi.responses import JSONResponse
-
-log = logging.getLogger("astrololo.security")
-
-HEADER = "X-Astrololo-Token"
-PUBLIC_PATHS = frozenset({"/health"})
-
-
-def token() -> str:
-    """Czytany leniwie — konfiguracja może się zmienić bez importu modułu."""
-    return os.getenv("INTERNAL_TOKEN", "")
-
-
-def enabled() -> bool:
-    return bool(token())
-
-
-def install(app, layer: str) -> None:
-    if not enabled():
-        log.warning(
-            "UWAGA: INTERNAL_TOKEN nie ustawiony — warstwa %s przyjmuje żądania od "
-            "kogokolwiek, kto ma do niej dostęp sieciowy.", layer,
-        )
-
-    @app.middleware("http")
-    async def _guard(request: Request, call_next):
-        if request.url.path in PUBLIC_PATHS or not enabled():
-            return await call_next(request)
-        got = request.headers.get(HEADER, "")
-        if not secrets.compare_digest(got, token()):
-            return JSONResponse({"detail": "Brak lub błędny token międzywarstwowy."},
-                                status_code=401)
-        return await call_next(request)

services/logic/app/clients/data_client.py

@@ -5,7 +5,6 @@ Jedyny punkt styku w dół. Gdyby warstwa bazodanowa zmieniła implementację
 """
 from __future__ import annotations
 
-import os
 from typing import Any
 
 import httpx
@@ -13,12 +12,6 @@ import httpx
 from app.config import settings
 
 
-def _auth_headers() -> dict[str, str]:
-    """Token międzywarstwowy (LOG-32) — pusty, gdy ochrona wyłączona."""
-    token = os.getenv("INTERNAL_TOKEN", "")
-    return {"X-Astrololo-Token": token} if token else {}
-
-
 class DataClient:
     def __init__(self, base_url: str | None = None) -> None:
         self.base_url = (base_url or settings.data_url).rstrip("/")
@@ -33,12 +26,12 @@ class DataClient:
     ) -> dict[str, Any]:
         payload = {"key": key, "value": value, "exact": exact, "limit": limit, "fields": fields}
         with httpx.Client(timeout=max(settings.http_timeout, 30.0)) as client:
-            r = client.post(f"{self.base_url}/search", json=payload, headers=_auth_headers())
+            r = client.post(f"{self.base_url}/search", json=payload)
             r.raise_for_status()
             return r.json()
 
     def health(self) -> dict[str, Any]:
         with httpx.Client(timeout=settings.http_timeout) as client:
-            r = client.get(f"{self.base_url}/health", headers=_auth_headers())
+            r = client.get(f"{self.base_url}/health")
             r.raise_for_status()
             return r.json()

services/logic/app/engine/aspects.py

@@ -27,18 +27,6 @@ LUMINARIES = {"Sun", "Moon"}
 DEFAULT_ORB = 8.0
 LUMINARY_BONUS = 2.0
 
-# Pary sztywno powiązane definicyjnie — kąt między nimi wynika z samej definicji
-# punktu, nie z układu nieba (SN = NN + 180°). Aspekt taki zawsze wychodzi
-# dokładny (orb 0,00°) i nie niesie żadnej informacji astrologicznej, więc
-# wycinamy go z wyników: zaśmieca listę w UI i zjada budżet promptu do LLM.
-RIGID_PAIRS = frozenset({
-    frozenset({"North Node", "South Node"}),
-})
-
-
-def _is_rigid(name_a: str, name_b: str) -> bool:
-    return frozenset({name_a, name_b}) in RIGID_PAIRS
-
 
 def separation(a: float, b: float) -> float:
     """Najmniejsza separacja kątowa [0,180]."""
@@ -68,16 +56,12 @@ def find_aspects(
 
     Zwraca listę aspektów głównych; gdy znane są prędkości, każdy aspekt ma
     applying (bool) i skrót 'as': 'A'/'S' (aplikacyjny/separacyjny).
-
-    Pary z RIGID_PAIRS (np. NN/SN) są pomijane — ich kąt jest definicyjny.
     """
     out: list[dict] = []
     n = len(positions)
     for i in range(n):
         for j in range(i + 1, n):
             a, b = positions[i], positions[j]
-            if _is_rigid(a["name"], b["name"]):
-                continue
             la, lb = a.get("decimal"), b.get("decimal")
             if la is None or lb is None:
                 continue

services/logic/app/main.py

@@ -12,14 +12,12 @@ import httpx
 from fastapi import FastAPI, HTTPException
 from pydantic import BaseModel
 
-from app import security
 from app.clients.data_client import DataClient
 from app.models import QueryRequest, QueryResponse
 from app.service import QueryService
 
 app = FastAPI(title="astrololo · warstwa logiczna")
 service = QueryService()
-security.install(app, "logiczna")     # token międzywarstwowy (LOG-32)
 
 # --- silnik efemeryd (LOG-24): budowany leniwie, by nie wymagać Skyfielda do startu ---
 _engine = None

services/logic/app/security.py

@@ -1,50 +0,0 @@
-"""Uwierzytelnianie międzywarstwowe (LOG-32).
-
-Warstwa logiczna oddaje treść baz interpretacyjnych, więc samo zalogowanie w
-prezentacji nie wystarczy — bez tego kontrolera wystarczyłoby uderzyć w logikę
-z pominięciem UI. Gdy ustawiono INTERNAL_TOKEN, każde żądanie (poza /health)
-musi go przynieść w nagłówku X-Astrololo-Token.
-
-Bez INTERNAL_TOKEN kontrola jest wyłączona (dev / zgodność wstecz) — wtedy przy
-starcie leci ostrzeżenie.
-"""
-from __future__ import annotations
-
-import logging
-import os
-import secrets
-
-from fastapi import Request
-from fastapi.responses import JSONResponse
-
-log = logging.getLogger("astrololo.security")
-
-HEADER = "X-Astrololo-Token"
-PUBLIC_PATHS = frozenset({"/health"})
-
-
-def token() -> str:
-    """Czytany leniwie — konfiguracja może się zmienić bez importu modułu."""
-    return os.getenv("INTERNAL_TOKEN", "")
-
-
-def enabled() -> bool:
-    return bool(token())
-
-
-def install(app, layer: str) -> None:
-    if not enabled():
-        log.warning(
-            "UWAGA: INTERNAL_TOKEN nie ustawiony — warstwa %s przyjmuje żądania od "
-            "kogokolwiek, kto ma do niej dostęp sieciowy.", layer,
-        )
-
-    @app.middleware("http")
-    async def _guard(request: Request, call_next):
-        if request.url.path in PUBLIC_PATHS or not enabled():
-            return await call_next(request)
-        got = request.headers.get(HEADER, "")
-        if not secrets.compare_digest(got, token()):
-            return JSONResponse({"detail": "Brak lub błędny token międzywarstwowy."},
-                                status_code=401)
-        return await call_next(request)

services/logic/tests/test_aspects.py

@@ -1,5 +1,5 @@
 """Testy aspektów (LOG-06) — czysta matematyka."""
-from app.engine.aspects import RIGID_PAIRS, find_aspects, separation
+from app.engine.aspects import find_aspects, separation
 
 
 def test_separation_wraparound():
@@ -55,28 +55,6 @@ def test_separating_when_moving_apart():
     assert a["applying"] is False and a["as"] == "S"
 
 
-def test_rigid_pair_nodes_not_reported():
-    # SN = NN + 180° z definicji — trywialna opozycja, nie aspekt
-    pos = [
-        {"name": "North Node", "decimal": 42.0, "speed": -0.053},
-        {"name": "South Node", "decimal": 222.0, "speed": -0.053},
-        {"name": "Sun", "decimal": 42.5, "speed": 0.96},
-    ]
-    pairs = {frozenset((a["obj1"], a["obj2"])) for a in find_aspects(pos)}
-    assert frozenset({"North Node", "South Node"}) not in pairs
-    # aspekty węzłów do innych obiektów zostają nietknięte
-    assert frozenset({"Sun", "North Node"}) in pairs
-    assert frozenset({"Sun", "South Node"}) in pairs
-
-
-def test_no_rigid_pairs_in_real_chart(own_engine, reference_moment):
-    from app.engine.chart import build_chart
-
-    chart = build_chart(own_engine, reference_moment)
-    found = [a for a in chart["aspects"] if frozenset((a["obj1"], a["obj2"])) in RIGID_PAIRS]
-    assert not found, f"trywialne aspekty par sztywnych w horoskopie: {found}"
-
-
 def test_no_as_flag_without_speeds():
     pos = [{"name": "Sun", "decimal": 0.0}, {"name": "Moon", "decimal": 2.0}]
     assert "as" not in find_aspects(pos)[0]

services/logic/tests/test_security.py

@@ -1,65 +0,0 @@
-"""Token międzywarstwowy (LOG-32).
-
-Warstwa logiczna oddaje treść baz, więc musi odrzucać żądania z pominięciem UI.
-"""
-import pytest
-from fastapi import FastAPI
-from starlette.testclient import TestClient
-
-from app import security
-
-TOKEN = "tajny-token-testowy"
-
-
-def _app() -> FastAPI:
-    app = FastAPI()
-    security.install(app, "testowa")
-
-    @app.get("/health")
-    def health():
-        return {"status": "ok"}
-
-    @app.get("/secret")
-    def secret():
-        return {"rows": ["treść z bazy"]}
-
-    return app
-
-
-@pytest.fixture
-def guarded(monkeypatch):
-    monkeypatch.setenv("INTERNAL_TOKEN", TOKEN)
-    return TestClient(_app())
-
-
-@pytest.fixture
-def open_app(monkeypatch):
-    monkeypatch.delenv("INTERNAL_TOKEN", raising=False)
-    return TestClient(_app())
-
-
-def test_rejects_request_without_token(guarded):
-    assert guarded.get("/secret").status_code == 401
-
-
-def test_rejects_wrong_token(guarded):
-    r = guarded.get("/secret", headers={security.HEADER: "zly"})
-    assert r.status_code == 401
-    assert "treść z bazy" not in r.text
-
-
-def test_accepts_correct_token(guarded):
-    r = guarded.get("/secret", headers={security.HEADER: TOKEN})
-    assert r.status_code == 200
-    assert r.json()["rows"] == ["treść z bazy"]
-
-
-def test_health_stays_public(guarded):
-    """Sonda k8s nie zna tokenu — /health musi działać bez niego."""
-    assert guarded.get("/health").status_code == 200
-
-
-def test_disabled_when_token_unset(open_app):
-    """Brak konfiguracji = zgodność wstecz (dev), nie blokada."""
-    assert not security.enabled()
-    assert open_app.get("/secret").status_code == 200

services/presentation/app/clients/logic_client.py

@@ -5,7 +5,6 @@ opracowane wyniki. Prezentacja nie sięga bezpośrednio do bazy ani do silnika.
 """
 from __future__ import annotations
 
-import os
 from typing import Any
 
 import httpx
@@ -13,12 +12,6 @@ import httpx
 from app.config import settings
 
 
-def _auth_headers() -> dict[str, str]:
-    """Token międzywarstwowy (LOG-32) — pusty, gdy ochrona wyłączona."""
-    token = os.getenv("INTERNAL_TOKEN", "")
-    return {"X-Astrololo-Token": token} if token else {}
-
-
 class LogicClient:
     def __init__(self, base_url: str | None = None) -> None:
         self.base_url = (base_url or settings.logic_url).rstrip("/")
@@ -26,7 +19,7 @@ class LogicClient:
     def query(self, query: str, field: str, exact: bool, limit: int) -> dict[str, Any]:
         payload = {"query": query, "field": field, "exact": exact, "limit": limit}
         with httpx.Client(timeout=settings.http_timeout) as client:
-            r = client.post(f"{self.base_url}/api/query", json=payload, headers=_auth_headers())
+            r = client.post(f"{self.base_url}/api/query", json=payload)
             r.raise_for_status()
             return r.json()
 
@@ -52,7 +45,7 @@ class LogicClient:
         }
         # stacje wymagają root-findów — dłuższy timeout
         with httpx.Client(timeout=max(settings.http_timeout, 60.0) if stations else settings.http_timeout) as client:
-            r = client.post(f"{self.base_url}/chart/positions", json=payload, headers=_auth_headers())
+            r = client.post(f"{self.base_url}/chart/positions", json=payload)
             r.raise_for_status()
             return r.json()
 
@@ -62,7 +55,7 @@ class LogicClient:
         """Sygnifikatory z obliczeń szukane w bazie — woła logic /chart/report."""
         payload = {"when_utc": when_utc_iso, "lat": lat, "lon": lon, "limit": limit, "group": group}
         with httpx.Client(timeout=max(settings.http_timeout, 30.0)) as client:
-            r = client.post(f"{self.base_url}/chart/report", json=payload, headers=_auth_headers())
+            r = client.post(f"{self.base_url}/chart/report", json=payload)
             r.raise_for_status()
             return r.json()
 
@@ -114,6 +107,6 @@ class LogicClient:
             "from_date": from_date, "to_date": to_date, "interpret": interpret,
         }
         with httpx.Client(timeout=max(settings.http_timeout, 60.0)) as client:
-            r = client.post(f"{self.base_url}/chart/timeline", json=payload, headers=_auth_headers())
+            r = client.post(f"{self.base_url}/chart/timeline", json=payload)
             r.raise_for_status()
             return r.json()

services/presentation/app/main.py

@@ -17,7 +17,7 @@ from fastapi.responses import HTMLResponse
 from fastapi.staticfiles import StaticFiles
 from fastapi.templating import Jinja2Templates
 
-from app import geocode, security
+from app import geocode
 from app.clients.logic_client import LogicClient
 from app.config import DEFAULT_LOCATION_LABEL, default_form
 
@@ -25,7 +25,6 @@ app = FastAPI(title="astrololo · warstwa prezentacji")
 app.mount("/static", StaticFiles(directory="app/static"), name="static")
 templates = Jinja2Templates(directory="app/templates")
 logic = LogicClient()
-security.install(app)          # logowanie + limit żądań (LOG-32)
 
 
 def _build_utc(date: str, time: str, tz_offset: float) -> tuple[str, str]:

services/presentation/app/security.py

@@ -1,120 +0,0 @@
-"""Ochrona dostępu do aplikacji (LOG-32).
-
-Rdzeniem produktu są oryginalne bazy interpretacyjne. Aplikacja podaje ich treść
-na wielu ścieżkach (`/significators`, `/interpret`, generator promptu), więc BRAK
-uwierzytelnienia oznacza, że każdy w sieci może je wypompować — bez udziału
-jakiegokolwiek modelu językowego. Ten moduł zamyka tę drogę.
-
-Dwa mechanizmy:
-  * **HTTP Basic** — wejście do aplikacji; włącza się, gdy ustawiono APP_PASSWORD.
-  * **limit żądań** — hamuje masowe odpytywanie (eksfiltrację przez pętlę zapytań).
-
-Świadomie NIE logujemy treści żądań ani promptów — logi to kolejny nośnik wycieku.
-
-UWAGA: bez APP_PASSWORD ochrona jest WYŁĄCZONA (zgodność wstecz i wygoda dev).
-Wtedy przy starcie leci głośne ostrzeżenie — żeby nikt nie wdrożył tego w
-przekonaniu, że jest chroniony.
-"""
-from __future__ import annotations
-
-import base64
-import binascii
-import logging
-import os
-import secrets
-import time
-from collections import deque
-
-from fastapi import Request
-from fastapi.responses import HTMLResponse, JSONResponse
-
-log = logging.getLogger("astrololo.security")
-
-MAX_TRACKED_CLIENTS_DEFAULT = 4096
-MAX_TRACKED_CLIENTS = MAX_TRACKED_CLIENTS_DEFAULT   # zabezpieczenie przed puchnięciem pamięci
-
-
-# konfiguracja czytana leniwie — testy i restart mogą ją zmienić bez importu modułu
-def app_user() -> str:
-    return os.getenv("APP_USER", "astrololo")
-
-
-def app_password() -> str:
-    return os.getenv("APP_PASSWORD", "")
-
-
-def rate_limit_per_min() -> int:
-    return int(os.getenv("RATE_LIMIT_PER_MIN", "120"))
-
-PUBLIC_PATHS = frozenset({"/health"})
-PUBLIC_PREFIXES = ("/static/",)
-
-_hits: dict[str, deque[float]] = {}
-
-
-def auth_enabled() -> bool:
-    return bool(app_password())
-
-
-def _is_public(path: str) -> bool:
-    return path in PUBLIC_PATHS or path.startswith(PUBLIC_PREFIXES)
-
-
-def _authorized(header: str | None) -> bool:
-    if not header or not header.lower().startswith("basic "):
-        return False
-    try:
-        raw = base64.b64decode(header.split(" ", 1)[1]).decode("utf-8")
-        user, _, password = raw.partition(":")
-    except (binascii.Error, UnicodeDecodeError, IndexError):
-        return False
-    # porównanie odporne na atak czasowy; oba pola muszą się zgadzać
-    ok_user = secrets.compare_digest(user, app_user())
-    ok_pass = secrets.compare_digest(password, app_password())
-    return ok_user and ok_pass
-
-
-def _rate_limited(client: str) -> bool:
-    cap = rate_limit_per_min()
-    if cap <= 0:
-        return False
-    now = time.monotonic()
-    window = _hits.get(client)
-    if window is None:
-        if len(_hits) >= MAX_TRACKED_CLIENTS:
-            _hits.clear()               # prosty reset zamiast nieograniczonego wzrostu
-        window = _hits[client] = deque()
-    while window and now - window[0] > 60.0:
-        window.popleft()
-    if len(window) >= cap:
-        return True
-    window.append(now)
-    return False
-
-
-def install(app) -> None:
-    """Podpina ochronę pod wszystkie ścieżki poza /health i /static."""
-    if not auth_enabled():
-        log.warning(
-            "UWAGA: APP_PASSWORD nie ustawione — aplikacja jest OTWARTA dla każdego, "
-            "kto ma do niej dostęp sieciowy, wraz z treścią baz interpretacyjnych."
-        )
-
-    @app.middleware("http")
-    async def _guard(request: Request, call_next):
-        if _is_public(request.url.path):
-            return await call_next(request)
-
-        client = request.client.host if request.client else "?"
-        if _rate_limited(client):
-            return JSONResponse(
-                {"detail": "Zbyt wiele żądań — spróbuj za chwilę."},
-                status_code=429, headers={"Retry-After": "60"},
-            )
-
-        if auth_enabled() and not _authorized(request.headers.get("authorization")):
-            return HTMLResponse(
-                "<h1>401 — wymagane logowanie</h1>", status_code=401,
-                headers={"WWW-Authenticate": 'Basic realm="astrololo"'},
-            )
-        return await call_next(request)

services/presentation/requirements-dev.txt

@@ -1,2 +0,0 @@
--r requirements.txt
-pytest>=8.0

services/presentation/tests/test_security.py

@@ -1,133 +0,0 @@
-"""Logowanie do aplikacji i limit żądań (LOG-32).
-
-To jest brama chroniąca oryginalne bazy interpretacyjne — bez niej każdy w sieci
-mógł je wypompować przez `/significators` czy generator promptu. Testy pilnują,
-że brama faktycznie zamyka, a nie tylko wygląda na zamkniętą.
-"""
-import base64
-
-import pytest
-from fastapi import FastAPI
-from fastapi.responses import HTMLResponse
-from starlette.testclient import TestClient
-
-from app import security
-
-USER, PASSWORD = "astrololo", "haslo-testowe"
-
-
-def _basic(user: str, password: str) -> dict[str, str]:
-    raw = base64.b64encode(f"{user}:{password}".encode()).decode()
-    return {"Authorization": f"Basic {raw}"}
-
-
-def _app() -> FastAPI:
-    app = FastAPI()
-    security.install(app)
-
-    @app.get("/health")
-    def health():
-        return {"status": "ok"}
-
-    @app.get("/significators", response_class=HTMLResponse)
-    def significators():
-        return "<p>treść z bazy interpretacyjnej</p>"
-
-    return app
-
-
-@pytest.fixture(autouse=True)
-def _reset_rate_limit():
-    security._hits.clear()
-    yield
-    security._hits.clear()
-
-
-@pytest.fixture
-def guarded(monkeypatch):
-    monkeypatch.setenv("APP_PASSWORD", PASSWORD)
-    monkeypatch.setenv("RATE_LIMIT_PER_MIN", "120")
-    return TestClient(_app())
-
-
-# ------------------------------------------------------------------ logowanie
-
-def test_blocks_anonymous_access(guarded):
-    r = guarded.get("/significators")
-    assert r.status_code == 401
-    assert "treść z bazy" not in r.text
-
-
-def test_challenges_with_basic_realm(guarded):
-    """Bez nagłówka WWW-Authenticate przeglądarka nie pokaże okna logowania."""
-    assert "Basic" in guarded.get("/significators").headers.get("WWW-Authenticate", "")
-
-
-def test_rejects_wrong_password(guarded):
-    assert guarded.get("/significators", headers=_basic(USER, "zle")).status_code == 401
-
-
-def test_rejects_wrong_user(guarded):
-    assert guarded.get("/significators", headers=_basic("obcy", PASSWORD)).status_code == 401
-
-
-def test_rejects_malformed_header(guarded):
-    for bad in ("Basic !!!niebase64!!!", "Bearer cokolwiek", "", "Basic"):
-        assert guarded.get("/significators", headers={"Authorization": bad}).status_code == 401
-
-
-def test_allows_correct_credentials(guarded):
-    r = guarded.get("/significators", headers=_basic(USER, PASSWORD))
-    assert r.status_code == 200
-    assert "treść z bazy" in r.text
-
-
-def test_health_stays_public(guarded):
-    assert guarded.get("/health").status_code == 200
-
-
-def test_open_when_password_unset(monkeypatch):
-    """Brak hasła = zgodność wstecz; ochrona wyłączona (i ostrzegamy przy starcie)."""
-    monkeypatch.delenv("APP_PASSWORD", raising=False)
-    assert not security.auth_enabled()
-    assert TestClient(_app()).get("/significators").status_code == 200
-
-
-# --------------------------------------------------------------- limit żądań
-
-def test_rate_limit_blocks_flood(monkeypatch):
-    """Masowe odpytywanie to droga eksfiltracji nawet po zalogowaniu."""
-    monkeypatch.setenv("APP_PASSWORD", PASSWORD)
-    monkeypatch.setenv("RATE_LIMIT_PER_MIN", "5")
-    client = TestClient(_app())
-    auth = _basic(USER, PASSWORD)
-    codes = [client.get("/significators", headers=auth).status_code for _ in range(8)]
-    assert codes[:5] == [200] * 5
-    assert 429 in codes[5:]
-
-
-def test_rate_limited_response_has_retry_after(monkeypatch):
-    monkeypatch.setenv("APP_PASSWORD", PASSWORD)
-    monkeypatch.setenv("RATE_LIMIT_PER_MIN", "1")
-    client = TestClient(_app())
-    auth = _basic(USER, PASSWORD)
-    client.get("/significators", headers=auth)
-    r = client.get("/significators", headers=auth)
-    assert r.status_code == 429 and r.headers.get("Retry-After") == "60"
-
-
-def test_rate_limit_precedes_auth(monkeypatch):
-    """Limit musi działać także dla niezalogowanych — inaczej zgadywanie hasła
-    i sondowanie API jest darmowe."""
-    monkeypatch.setenv("APP_PASSWORD", PASSWORD)
-    monkeypatch.setenv("RATE_LIMIT_PER_MIN", "3")
-    client = TestClient(_app())
-    codes = [client.get("/significators").status_code for _ in range(6)]
-    assert 429 in codes
-
-
-def test_rate_limit_disabled_when_zero(monkeypatch):
-    monkeypatch.setenv("RATE_LIMIT_PER_MIN", "0")
-    monkeypatch.delenv("APP_PASSWORD", raising=False)
-    client = TestClient(_app())
-    assert all(client.get("/significators").status_code == 200 for _ in range(30))