docs: rejestr wymagań — zmiany z materiałów klienta (wrzesień 2026)

Naniesione wnioski z TO DO 2026-09-05, specyfikacji 2026-09-13 oraz
dosłanych plików (czasy wznoszenia, kalkulator firdarii). Każda zmiana
z wartością było/jest, powodem i dowodem jest w nowym arkuszu
„Zmiany 2026-10”.

- 56 nowych wymagań (DAN-28…36, LOG-35…51, PRE-30…59), 103 zmiany
  w istniejących, 34 pytania (Q-15…Q-48), 21 haseł słownika.
- Wygląd i interfejs jako opcje do wyboru (język, motyw jasny obok
  ciemnego, kolorowanie, „symbol + skrót”, styl koła) — PRE-30…33, 49–51.
- 17 statusów skorygowanych: wiersze już w pierwotnej treści obiecywały
  funkcje, których nie ma w kodzie (m.in. LOG-15 parser → Do zrobienia,
  LOG-16/19 → W trakcie — przyczyna fałszywych interpretacji z TO DO w.11).
  LOG-08 i LOG-14 spełniają pierwotną treść, więc zostają Zrobione,
  a nowy zakres klienta wydzielono do LOG-50 i LOG-51.
- DAN-28 (lustro baz w SQL): numer używany już w kodzie, brakował w rejestrze.
- Przegląd: liczniki i tabela postępu przeliczone z arkuszy.

Analiza zaktualizowana: dosłane materiały, limit 5000 rekordów przy
wyszukiwaniu, .xlsm odrzucany przez domyślną regułę wgrywania, pliki
pozostawione poza repo.

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

.gitea/workflows/build-render.yaml

@@ -32,3 +32,14 @@ jobs:
           docker push $IMG:$TAG
           docker push $IMG:latest
           echo "Zbudowano i wypchnieto: $IMG:$TAG (+ latest)"
+
+      # Sprzątanie ZAWSZE, także po nieudanym budowaniu. Ten obraz dźwiga TeX Live
+      # i to właśnie na nim runner zatkał się kiedyś na „no space left on device" —
+      # a po nieudanym buildzie zostaje najwięcej śmieci.
+      - name: Sprzątanie po budowaniu
+        if: always()
+        run: |
+          docker system df || true
+          docker system  prune -af --filter "until=168h" || true
+          docker builder prune -f  --filter "until=168h" || true
+          docker system df || true

.gitea/workflows/build.yaml

@@ -1,21 +1,112 @@
 name: build
+
+# Buduje obrazy usług, które dzielą warstwę logiczną i łącze: data, logic,
+# presentation, astrodemo. Render i silnik B mają własne pipeline'y, bo są ciężkie
+# i rzadko się zmieniają (build-render.yaml, build-swisseph.yaml).
 on:
   push:
     branches: [master]
+
 jobs:
   build:
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v4
+        with:
+          # Dwa commity, bo porównujemy z poprzednim. Domyślny płytki klon ma
+          # jeden i `HEAD^` w nim nie istnieje.
+          fetch-depth: 2
+
       - name: Login
         run: echo "${{ secrets.REGISTRY_TOKEN }}" | docker login gitea.czernobog.pl -u gitea --password-stdin
-      # astrodemo dołącza do tej samej pętli: dzieli warstwę logiczną i łącze,
-      # więc jego obraz ma powstawać z tego samego commita co reszta produktu.
-      - name: Build & push (data, logic, presentation, astrodemo)
+
+      - name: Build & push (tylko usługi, które się zmieniły)
         run: |
+          set -eu
           TAG=${GITHUB_SHA::8}
-          for SVC in data logic presentation astrodemo; do
-            docker build -t gitea.czernobog.pl/gitea/astrololo-$SVC:$TAG ./services/$SVC
+          USLUGI="data logic presentation astrodemo astroklient"
+          # Usługi z własnym pipeline'em — celowo poza tą pętlą.
+          OSOBNE="render engine-swisseph"
+
+          # Usługa, której nie ma na żadnej z list, nigdy się nie zbuduje i NIKT
+          # tego nie zauważy: brak obrazu wygląda potem na problem z rejestrem.
+          # Ten sam mechanizm już nas kosztował przy liście obserwowanych obrazów
+          # w image-updaterze. Lepiej zatrzymać budowanie i powiedzieć wprost.
+          for KATALOG in services/*/; do
+            NAZWA=$(basename "$KATALOG")
+            case " $USLUGI $OSOBNE " in
+              *" $NAZWA "*) ;;
+              *) echo "BŁĄD: usługa '$NAZWA' nie jest na żadnej liście budowania."
+                 echo "Dopisz ją do USLUGI w tym pliku albo daj jej własny workflow"
+                 echo "(jak render i engine-swisseph), zależnie od tego, czy ma"
+                 echo "powstawać z każdego commita produktu."
+                 exit 1 ;;
+            esac
+          done
+
+          # Kontekstem budowania każdego obrazu jest WYŁĄCZNIE ./services/<nazwa>,
+          # więc zmiana poza tym katalogiem nie może wpłynąć na jego zawartość.
+          # Dzięki temu porównanie ścieżek jest dokładne, a nie przybliżone.
+          if POPRZEDNI=$(git rev-parse --verify HEAD^ 2>/dev/null); then
+            ZMIENIONE=$(git diff --name-only "$POPRZEDNI" HEAD)
+          else
+            # Pierwszy commit albo przepisana historia — nie ma z czym porównać,
+            # więc budujemy wszystko. Lepiej zbudować za dużo niż wypuścić obraz
+            # ze starym kodem pod nowym tagiem.
+            echo "Brak poprzedniego commita — buduję komplet."
+            ZMIENIONE=""
+          fi
+
+          # Zmiana w samym pliku workflow dotyczy wszystkich obrazów naraz.
+          if [ -z "$ZMIENIONE" ] || echo "$ZMIENIONE" | grep -q '^\.gitea/workflows/build\.yaml$'; then
+            DO_BUDOWY="$USLUGI"
+          else
+            DO_BUDOWY=""
+            for SVC in $USLUGI; do
+              if echo "$ZMIENIONE" | grep -q "^services/$SVC/"; then
+                DO_BUDOWY="$DO_BUDOWY $SVC"
+              fi
+            done
+            # astroklient bierze rdzeń z warstwy prezentacji, więc zmiana TAMTEJ
+            # też go dotyczy. Bez tego jego obraz zostawałby ze starymi ekranami,
+            # a różnicy nie byłoby widać aż do zgłoszenia użytkownika.
+            if echo "$ZMIENIONE" | grep -q "^services/presentation/" \
+               && ! echo "$DO_BUDOWY" | grep -q "astroklient"; then
+              DO_BUDOWY="$DO_BUDOWY astroklient"
+            fi
+          fi
+
+          if [ -z "$(echo "$DO_BUDOWY" | tr -d ' ')" ]; then
+            echo "Żadna z usług się nie zmieniła — nie ma czego budować."
+            echo "Wdrożone tagi zostają na poprzednich wersjach, i tak ma być."
+            exit 0
+          fi
+
+          echo "Buduję:$DO_BUDOWY (tag $TAG)"
+          for SVC in $DO_BUDOWY; do
+            # astroklient buduje się z KORZENIA repozytorium, bo jego Dockerfile
+            # sięga po rdzeń do services/presentation. Pozostałe mają kontekst
+            # ograniczony do własnego katalogu — i tak ma zostać, bo to właśnie
+            # ten kontekst gwarantuje, że nie wciągną niczego spoza siebie.
+            if [ "$SVC" = "astroklient" ]; then
+              docker build -f services/astroklient/Dockerfile \
+                           -t gitea.czernobog.pl/gitea/astrololo-$SVC:$TAG .
+            else
+              docker build -t gitea.czernobog.pl/gitea/astrololo-$SVC:$TAG ./services/$SVC
+            fi
             docker push  gitea.czernobog.pl/gitea/astrololo-$SVC:$TAG
           done
           echo "Tag: $TAG"
+
+      # Sprzątanie ZAWSZE, także po nieudanym budowaniu — to właśnie po awarii
+      # zostaje najwięcej śmieci, a kolejny przebieg zaczyna od mniejszego zapasu
+      # miejsca niż poprzedni. Tak zatkał się dysk przy budowaniu rendera.
+      - name: Sprzątanie po budowaniu
+        if: always()
+        run: |
+          docker system df || true
+          # `until=168h` zostawia tydzień: warstwy bazowe i cache z ostatnich dni
+          # przeżywają, więc kolejny build nie zaczyna od zera, a stare znikają.
+          docker system  prune -af --filter "until=168h" || true
+          docker builder prune -f  --filter "until=168h" || true
+          docker system df || true

.gitea/workflows/tests.yml

@@ -112,6 +112,27 @@ jobs:
           PYTHONPATH: .
         run: pytest tests -q -rs
 
+  astroklient-tests:
+    name: Testy astroklient
+    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/astroklient/requirements-dev.txt
+      - name: Instalacja zależności
+        run: pip install -r services/astroklient/requirements-dev.txt
+      # Testy budują drzewo tak samo, jak robi to Dockerfile: rdzeń z warstwy
+      # prezentacji, minus usun.txt, plus nakładka. Sprawdzają WYNIK złożenia,
+      # bo tylko on trafia do obrazu.
+      - name: Testy (pytest)
+        working-directory: services/astroklient
+        env:
+          PYTHONPATH: .
+        run: pytest tests -q -rs
+
   swisseph-image:
     name: Build obrazu silnika B (swisseph)
     runs-on: ubuntu-latest
@@ -240,3 +261,33 @@ jobs:
       # silnika swisseph, który nie wchodzi do produktu).
       - name: py_compile
         run: python -m compileall -q services
+
+      # Krok bez `run` i bez `uses` jest dla Gitei krokiem PUSTYM: zadanie mija
+      # go i kończy się powodzeniem, nie uruchomiwszy niczego. Tak właśnie
+      # zniknęły na jeden commit testy astrodemo — blok został rozcięty przy
+      # dopisywaniu sąsiedniego, a jego `run` przywędrował do cudzego zadania,
+      # które przez to przechodziło z niewłaściwego powodu.
+      #
+      # Zielone CI, które nic nie uruchomiło, jest gorsze od czerwonego.
+      - name: Kontrola kroków w workflow
+        run: |
+          python - <<'KONTROLA'
+          import pathlib, sys, yaml
+          grzechy = []
+          for f in sorted(pathlib.Path(".gitea/workflows").glob("*.y*ml")):
+              d = yaml.safe_load(f.read_text(encoding="utf-8")) or {}
+              for nazwa, job in (d.get("jobs") or {}).items():
+                  kroki = job.get("steps") or []
+                  if not kroki:
+                      grzechy.append(f"{f.name}: zadanie '{nazwa}' nie ma kroków")
+                  for k in kroki:
+                      if "run" not in k and "uses" not in k:
+                          grzechy.append(
+                              f"{f.name}: '{nazwa}' → krok "
+                              f"'{k.get('name','(bez nazwy)')}' nie ma ani run, ani uses")
+          if grzechy:
+              print("PUSTE KROKI — zadanie przeszłoby nic nie robiąc:")
+              print("\n".join("  " + g for g in grzechy))
+              sys.exit(1)
+          print("Wszystkie kroki mają co uruchomić.")
+          KONTROLA

.gitignore

@@ -20,6 +20,16 @@ services/data/data_files/*.xlsx
 services/data/data_files/.files-state.json
 !services/data/data_files/.gitkeep
 
+# Materiały w docs/, które NIE trafiają do repo:
+# - kupione bazy interpretacji i eksport ich opisów — pułapki (DAN-26) działają
+#   tylko, gdy każda kopia ma inne markery, a kopia w gicie trafia do każdego klona i CI;
+# - dane urodzeniowe prawdziwych osób (kosmogramy).
+docs/astro19 version2026.xlsm
+docs/The Encyclopaedia of Medical Astrology_FILENAMEtymcz-tab6 4parser.xlsx
+docs/astro-excel4_4parser2.xlsm
+docs/interpretacje.xlsx
+docs/kosmogramy z astro2019.xlsx
+
 # Narzędzia
 .env
 .DS_Store

docs/analiza-klient-2026-09.md

@@ -0,0 +1,204 @@
+# Analiza materiałów od klienta — wrzesień 2026
+
+Źródła:
+- `astro parser TO DO LIST 2026-09-05.xlsx` — dalej **TO DO**,
+- `astro parser_2026-09-13.docx` — dalej **specyfikacja**,
+- dosłane 2026-10-04: `wznoszenie znaków ascensional times.xlsx` i `fidaria calculator.xls`.
+
+Architektura (trzy warstwy) zostaje bez zmian. Uwagi klienta o architekturze i stosie technologicznym są tu celowo pominięte.
+
+Wnioski są naniesione do rejestru `astrololo_wymagania.xlsx` w tym samym PR. Każda zmiana — z wartością „było / jest", powodem i dowodem — jest w arkuszu **„Zmiany 2026-10"**.
+
+Legenda pewności: **[kod]** sprawdzone w kodzie · **[hipoteza]** wniosek z objawów, niesprawdzony.
+
+## TL;DR
+
+1. **Interpretacje pokazują sygnifikatory, których w horoskopie nie ma.** Klient ma rację, mechanizm potwierdzony w kodzie, a ten sam błąd zasila prompt do LLM. Dodatkowo wyszukiwanie ucina rekordy limitem 5000, więc część bazy w ogóle nie jest sprawdzana.
+2. **Specyfikacja (docx) to w ~90% wynik AI, którego klient jeszcze nie przejrzał** (znacznik „{DOTĄD SPRAWDZONE}" w części 2 z 21). Służy jako skorowidz, nie jako wymagania.
+3. **Priorytety bierzemy z TO DO.** Astrologia wedyjska, chińska i majańska występuje tylko w specyfikacji — trafiła do pytań (Q-15), nie do wymagań.
+4. **Wygląd i interfejs zapisane jako opcje do wyboru:** język, motyw jasny obok obecnego ciemnego, kolorowanie, „symbol + skrót", styl koła.
+5. **Rejestr:** 56 nowych wymagań, 103 zmiany w istniejących, 34 nowe pytania (Q-15…Q-48), 21 haseł słownika.
+6. **17 statusów skorygowanych w dół.** Te wiersze już w pierwotnej treści obiecywały funkcje, których w kodzie nie ma.
+7. **Pięć plików z `docs/` celowo poza repozytorium** — kupione bazy i dane osobowe (sekcja 7).
+
+## 1. Interpretacje działają źle (potwierdzone w kodzie)
+
+**Zgłoszenie (TO DO, wiersz 11, \*\*\*).** Pod nagłówkiem „Sun w Taurus" pojawia się rekord „Sun in Gemini or Sagittarius, in square or opposition the Moon", choć żaden z warunków nie zachodzi. Fasetka „koniunkcja z Moon — 84 dopasowań" zbiera każdą koniunkcję czegokolwiek z Księżycem. Pokazują się też rekordy o dyrekcjach („by dir."), których nie liczymy, i o godnościach („well-dig. at B."), które w tym horoskopie nie są spełnione.
+
+**Mechanizm [kod].** `_facet_samples` w [significators.py](../services/logic/app/significators.py#L70) przepuszcza rekord, jeśli tekst jego sygnifikatora *zawiera* wszystkie tokeny fasetki ([linia 82](../services/logic/app/significators.py#L82)). Sprawdza więc, czy rekord *wspomina* te tokeny, a nie czy *wszystkie jego warunki* są spełnione w horoskopie. Skutki:
+
+- Nie rozróżnia, **która** planeta jest w aspekcie. Rekord `[Ve [conj [Mo … [Su in 7th H.` trafia do fasetki „Słońce w koniunkcji z Księżycem".
+- Ignoruje **dodatkowe warunki** rekordu: inny znak, inny aspekt, kwalifikatory techniki („by dir.", „tr."), godności („at B.").
+- **Limit 5000 [kod].** Wyszukiwanie po tokenie planety jest ucinane do 5000 rekordów ([main.py](../services/logic/app/main.py#L253), [excel_provider.py](../services/data/app/providers/excel_provider.py#L166)). Licznik „[Su: 5415 rekordów" jest liczony *przed* ucięciem, więc ok. 400 rekordów Słońca nigdy nie trafia do sprawdzania, a liczba w nagłówku nie odpowiada temu, co sprawdzono.
+
+Ta sama funkcja obsługuje Kalendarz ([`interpret_events`](../services/logic/app/significators.py#L265)), a generator promptów (LOG-29/30) bierze dopasowania z tego samego `build_report` ([main.py](../services/logic/app/main.py#L338), [prompt.py](../services/logic/app/prompt.py#L66)). Model z przekonaniem cytuje więc świadectwa, których w horoskopie nie ma.
+
+**W rejestrze:**
+- LOG-15 (parser) → „Do zrobienia";
+- LOG-16 (atomy) i LOG-19 (wypis) → „W trakcie";
+- kryteria odbioru naprawy, z przykładami klienta jako testami, są w LOG-19;
+- ekran opisuje PRE-36;
+- przypadek „rekord nie do oceny" — pytanie Q-35.
+
+## 2. Czym są te dokumenty
+
+**TO DO (xlsx)** to właściwa lista robocza: arkusz „LISTA TO DO" z priorytetami (\*\*\* / \*\* / \* / brak = na tym etapie niekonieczne) oraz 16 arkuszy-wzorców tabel. Arkusz ma też **legendę kolorów [kod — odczyt stylów]**:
+- **pomarańczowy** = „muszę uzupełnić ten opis — lepiej poczekać": wiersze 24, 32–34, 37, 40, 42–45, 73–76, 79, 87, 89, 91, 92, 94, 96, 98, 100;
+- **żółty** = „jeszcze w ogóle nie ugryzione — poczekać": wiersze 27 i 38.
+
+Wymagania z tych wierszy mają w rejestrze dopisek „opis u klienta do uzupełnienia".
+
+**Specyfikacja (docx)** to „Kompletna specyfikacja techniczna" w 21 częściach. Według klienta to efekt ponad 20 godzin pracy z agentem AI, wciąż niedokończony. Ustalenia z formatowania [kod — odczyt XML]:
+
+- Legenda cieniowania akapitów: pomarańczowy = „to jeszcze uzupełnię", żółty = „kompletnie do poprawki", łososiowy = „chyba out".
+- Flagi występują **tylko w częściach 1–2**, a w części 2 — zaraz po „Accidental dignities" — stoi znacznik **„{DOTĄD SPRAWDZONE}"**. Części 3–21 to **nieprzejrzany wynik AI**.
+- Kolor „chyba out" nie występuje ani razu.
+- Czerwona czcionka w częściach 1–2 to specyfikacja kolorów UI (osłabienia, domy kadentne, ujemne punkty), a nie znacznik „bzdura".
+- Dokument jest urwany („TU WYWALIŁ BŁĄD" w części 11, „TU SIĘ SKOŃCZYŁ LIMIT WĄTKU" w części 21).
+- Zawiera błędy merytoryczne, np. „0.5° Vigintile (1/40)" zamiast 18° (1/20). Arkusz „ASPECTS" w TO DO ma to poprawnie. **Przy konflikcie źródłem prawdy jest xlsx.**
+
+## 3. Błędy w działającej aplikacji
+
+| TO DO | Prio | Zgłoszenie | Ocena | Rejestr |
+|---|---|---|---|---|
+| 11 | \*\*\* | Interpretacje pokazują nieobecne sygnifikatory | **[kod]** potwierdzone, sekcja 1 | LOG-15/16/19, PRE-36 |
+| 9 | \*\*\* | Pliki 5 MB i 7,75 MB kończą się „Gateway Timeout" | **[hipoteza]** 504 zwraca proxy/ingress — w aplikacji nie ma limitu rozmiaru. Rozmiary pasują do `astro19 version2026.xlsm` (7,76 MiB) i `Encyclopaedia of Medical Astrology` (4,9 MiB). **[kod]** Nawet po usunięciu przekroczenia czasu domyślna reguła wgrywania przyjmuje tylko `.xlsx` ([files.py](../services/data/app/files.py#L64)), więc `.xlsm` zostanie odrzucony. | DAN-29, DAN-16 (→ Must) |
+| 9 | \*\*\* | Komunikat „nie nadaje się do użycia" dopiero przy ponownym wgraniu | Walidacja od razu po wgraniu + stały opis wymaganego układu | DAN-30, PRE-34 |
+| 10 | \*\*\* | Brak listy wgranych plików | **[hipoteza]** Lista istnieje w astrololo (DAN-27). Klient pracuje najpewniej na astrokliencie, który z założenia jest „bez administracji". | PRE-35, Q-19, Q-21 |
+| 12 | \*\*\* | Ekran „Sygnifikatory" — nie wiadomo, do czego służy | Wymaga wpisywania tokenów w składni bazy | PRE-37 |
+
+## 4. Wygląd i interfejs — jako opcje do wyboru
+
+Zgodnie z decyzją: zmiany wyglądu są **opcjami**, nie zamiennikami — obecny wygląd zostaje dostępny.
+
+| Wymaganie | Opcja |
+|---|---|
+| PRE-30 | język interfejsu: angielski lub polski |
+| PRE-31 | motyw jasny obok obecnego ciemnego |
+| PRE-32 | kolorowanie komórek wg planet, znaków i aspektów |
+| PRE-33 | zapis „symbol + skrót" (`☍ opp`, `☉ Su`, `♐ Sag`) |
+| PRE-49 | zakotwiczenie koła: Asc / whole sign / Baran / Rak / Słońce / Księżyc |
+| PRE-50 | granice terminów i dekanatów na kole |
+| PRE-51 | styl linii aspektów |
+
+Wartości domyślne motywu i języka oraz zasięg przełącznika języka (wszystkie warianty? raporty LLM?) — pytania Q-17 i Q-18.
+
+## 5. Co zostało naniesione do rejestru
+
+| Warstwa | Wymagania przed → po | Zrobione / W trakcie / Do zrobienia — przed | po |
+|---|---|---|---|
+| Dane | 28 → 37 | 14 / 3 / 11 | 13 / 5 / 19 |
+| Logika | 34 → 51 | 29 / 3 / 2 | 18 / 12 / 21 |
+| Prezentacja | 29 → 59 | 27 / 1 / 1 | 23 / 5 / 31 |
+| Pytania otwarte | 14 → 48 | | |
+
+### Korekty statusów (17)
+
+Zasada: status opisuje to, co wiersz obiecuje **w swojej pierwotnej treści**. Lipcowy audyt czytał te wiersze łagodnie („rdzeń działa"). Obecny czyta je ściśle, z dowodem w kodzie dla każdej korekty.
+
+- **LOG-15** → Do zrobienia: parsera nie ma (moduł sam nazywa się zalążkiem).
+- **LOG-17** → Do zrobienia: brak obsługi „asp" / „asp+" / „asp-".
+- **LOG-16, LOG-19** → W trakcie: sekcja 1.
+- **LOG-20** → W trakcie: brak „as-is-in-chart" i liczby trafień.
+- **LOG-02** → W trakcie: brak gwiazd stałych oraz węzła i Lilith w wersji true.
+- **DAN-09** → W trakcie: efemerydy tylko głównych ciał, bez asteroid i gwiazd.
+- **LOG-03** → W trakcie: brak prędkości w % ruchu i konfigurowalnej stacji umownej.
+- **LOG-04, PRE-07** → W trakcie: brak zodiaku RA.
+- **LOG-06, PRE-06** → W trakcie: z aspektów pobocznych tylko 30/45/150°, jedna orba dla wszystkich, brak harmonik, poziomów dokładności i aspektu przez znak.
+- **LOG-07** → W trakcie: orb paraleli stały (1°), niekonfigurowalny.
+- **LOG-10** → W trakcie: tylko profekcje roczne; brak miesięcznych, dziennych, ciągłych i Lord of the Orb.
+- **LOG-12** → W trakcie: brak monthly revolutions.
+- **PRE-01** → W trakcie: brak listy lokalizacji domyślnych i domyślnej daty/godziny.
+- **PRE-04** → W trakcie: z technik relacyjnych tylko synastria; solariusz i lunariusz nie mają ekranu.
+
+**LOG-08 i LOG-14 zostają „Zrobione"** — ich pierwotna treść jest spełniona: By Degree / By Sign, odwracanie i 7 Lots hermetycznych w [lots.py](../services/logic/app/engine/lots.py#L29); tabela technique | significator | start | exact | end w [timeline.py](../services/logic/app/engine/timeline.py#L30). Nowy zakres klienta wydzielony do **LOG-50** (Lots z listy klienta) i **LOG-51** (docelowy format tabeli predykcji).
+
+### Priorytety podniesione (13, nigdy nie obniżane)
+
+- **Dane:** DAN-06 (orby), DAN-07 (czasy wznoszenia), DAN-08 (Lots), DAN-10 (katalog aspektów), DAN-16 (`.xlsm`).
+- **Logika:** LOG-07, LOG-10, LOG-11, LOG-12, LOG-13, LOG-17.
+- **Prezentacja:** PRE-06, PRE-08.
+
+Wszystkie na Must, zgodnie z \*\*\* u klienta albo zależnością od naprawy z w.11.
+
+### Nowe wymagania według tematów
+
+- **Wgrywanie i bazy:** DAN-29 (duże pliki), DAN-30 (walidacja od razu), PRE-34, PRE-35, PRE-37.
+- **Horoskopy i dane wejściowe:**
+  - DAN-31 i PRE-40: kopiuj/wklej;
+  - DAN-32: format Zet;
+  - DAN-33 i PRE-41: lokalizacje domyślne;
+  - LOG-38 i PRE-38: strefa z DST, UT, czas gwiazdowy;
+  - PRE-39: zapisane horoskopy.
+- **Aspekty i orby:** LOG-37 (daty dokładności, tabela ASPECT LIST), PRE-43, PRE-44, PRE-45 i macierz orbów w zmianach DAN-06, LOG-06, PRE-06.
+- **Synastria:** LOG-42 (obliczenia z pełnymi ustawieniami), PRE-46–48 (dane obu osób, tabela A–aspekt–B, koło podwójne, pełny kwadrat aspektów).
+- **Tabele:**
+  - LOG-36: godności i faza;
+  - LOG-39 i PRE-53: dane obiektów;
+  - LOG-40 i PRE-52: tabela stopni;
+  - LOG-41: midpointy;
+  - PRE-59: godziny planetarne, syzygia, żywioły, asteroidy.
+- **Predykcja:**
+  - LOG-35: Firdaria — wariant i pełny cykl, sekcja 6;
+  - LOG-43: tranzyty;
+  - LOG-44: ingresy, okresy cienia, OOB, lunacje;
+  - LOG-45: progresje sekundarne;
+  - LOG-46: Days of the Moon;
+  - LOG-51 i PRE-54: zunifikowana tabela;
+  - PRE-55: tabele technik okresowych.
+- **Poza astrologią zachodnią (niski priorytet):** numerologia (LOG-47, DAN-35, PRE-56), chiromancja i fizjonomika (LOG-48, PRE-57), Astro\*Carto\*Graphy (LOG-49), atlasy medyczny i historyczny (DAN-36, PRE-58).
+- **Luka w rejestrze uzupełniona:** DAN-28 (lustro baz w SQL). Numer był już używany w kodzie (`services/data/requirements.txt`, commit 003deb9) i w repo deploy, ale w rejestrze go brakowało.
+
+## 6. Dosłane materiały
+
+### Czasy wznoszenia znaków (`wznoszenie znaków ascensional times.xlsx`)
+
+- Tabela © 2004 The Golden Hind Press: szerokości 0–66° N, wartości w stopniach i minutach (1° = 1 rok życia), pary znaków o równym czasie.
+- **Sprawdzone wzorem [kod]** (wznoszenie skośne): przy nachyleniu ekliptyki ok. 23,4465° (wartość z ok. 1945 r.) zgadza się do 0,6′ w 305 z 306 komórek.
+- **Jedna literówka:** 40°, Lew/Skorpion — w tabeli 38°20′, powinno być 38°02′ (tylko ten wiersz nie sumuje się do 180°).
+- **Tabela nie wystarcza do algorytmu z TO DO w.57–65:** brak szerokości ułamkowych (dla Warszawy odczyt z wiersza 52° myli się o ok. 7 tygodni), półkuli południowej i pasa 66,6°–78,5°, gdzie część znaków ma czasy ujemne.
+- **Rekomendacja:** liczyć wzorem, a tabelę trzymać jako wyrocznię testów (DAN-07, LOG-13). Decyzja i rozbieżności spec ↔ TO DO — pytania Q-37…Q-41.
+- Gotowe elementy w kodzie: `_ascensional_difference` i `mean_obliquity` w `houses.py`.
+
+### Kalkulator firdarii (`fidaria calculator.xls`)
+
+- Arkusz liczy okresy z samej daty urodzenia, w trzech wariantach obok siebie: dzienny, nocny Zollera (węzły zaraz po Marsie — poleca go autor arkusza) i nocny Abu Ma'shara (węzły na końcu).
+- **Nasz `firdaria.py` zgadza się z arkuszem [kod]** w wariancie dziennym i nocnym Abu Ma'shara: 51/51 władców okresów na przykładzie z arkusza. Daty różnią się w 2 z 51 wierszy — inna długość roku: 365,2422 u nas, 365,2425 w arkuszu.
+- **Braki:**
+  - wariant Zollera — dla przykładowego urodzenia nocnego z 1984 r. daje dziś inny okres (Węzeł Południowy zamiast Słońca);
+  - liczenie po 75. roku życia — arkusz zaczyna cykl od nowa, u nas wynik się kończy;
+  - ręczny wybór sekty.
+- W rejestrze: LOG-35 (wariant do wyboru, pełny cykl, test referencyjny na danych arkusza), Q-42 (wariant domyślny).
+
+## 7. Pliki poza repozytorium
+
+Do repo trafiła cała zawartość `docs/` poza pięcioma plikami, dopisanymi do `.gitignore`:
+
+- **Kupione bazy interpretacji:** `astro19 version2026.xlsm` (ok. 50 tys. rekordów), `The Encyclopaedia of Medical Astrology…xlsx` (ok. 54 tys., na bazie książki Cornella), `astro-excel4_4parser2.xlsm`.
+- **Eksport opisów z baz:** `interpretacje.xlsx` (444 opisy).
+- **Dane osobowe:** `kosmogramy z astro2019.xlsx` — dane urodzeniowe ok. 49 prawdziwych osób.
+
+Powód: pułapki (DAN-26) działają tylko wtedy, gdy każda kopia baz ma inne markery, a kopia w gicie trafiłaby do każdego klona i runnera CI. Historii gita praktycznie nie da się wyczyścić. `lots astroseek.xlsx` i `lots astroseek 2.xlsx` są identyczne — oba w repo, bo leżały w `docs/`.
+
+## 8. Pytania do klienta
+
+Pełna lista w arkuszu „Pytania otwarte" (Q-15…Q-48). Najważniejsze:
+
+- **Q-15** — czy astrologia wedyjska, chińska i majańska to zakres;
+- **Q-16** — kiedy będą przejrzane części 3–21 specyfikacji;
+- **Q-17, Q-18** — domyślny motyw i język, zasięg przełącznika języka;
+- **Q-19** — na którym wariancie i koncie widać problemy z wgrywaniem;
+- **Q-26** — reguły łączenia orbów i bonus świateł;
+- **Q-35** — co pokazywać przy rekordach nie do oceny;
+- **Q-37…Q-41** — czasy wznoszenia: tabela czy wzór, zamiana na datę, skrajne szerokości, małe lata Wenus;
+- **Q-42** — wariant firdarii nocnej;
+- **Q-43…Q-46** — techniki z opisem „do uzupełnienia": ZR, Annual Divisions, Days of the Moon, Solar Monthly Revolutions.
+
+## 9. Proponowana kolejność
+
+1. **Naprawa dopasowania sygnifikatorów** (LOG-15/16/19, PRE-36). Psuje Interpretacje, Kalendarz i prompt do LLM; dopóki działa źle, każda funkcja na nim dziedziczy błąd.
+2. **Wgrywanie plików** (DAN-29/30, DAN-16, PRE-34/35) — klient nie może wgrać własnych baz.
+3. **Horoskopy, kopiuj/wklej, lokalizacje domyślne** (DAN-31–33, PRE-39–41) — codzienna wygoda, \*\*\*.
+4. **Orby i aspekty** (DAN-06, LOG-06, PRE-43/45), potem **synastria** (LOG-42, PRE-46–48) — synastria korzysta z tych samych orbów.
+5. **Opcje wyglądu** (PRE-30–33, 49–51) razem z porządkowaniem wariantów astrololo / astroklient / astrodemo, żeby nie robić tego trzy razy.
+6. Dalej techniki z \*\*\* według TO DO. Wiersze oznaczone u klienta kolorem „do uzupełnienia" — po uzupełnieniu opisu.

services/astrodemo/Dockerfile

@@ -4,7 +4,11 @@ WORKDIR /app
 COPY requirements.txt .
 RUN pip install --no-cache-dir -r requirements.txt
 
-COPY . .
+# Do obrazu wchodzi WYŁĄCZNIE kod aplikacji. `COPY . .` wnosiło też katalog
+# tests/ — a leży w nim lista słów, które w tej usłudze nie mają prawa paść,
+# wypisanych wprost. Obraz tej usługi się KOMUŚ ODDAJE, więc niósłby dokładnie
+# to, co ten test ma pilnować. Przy okazji obraz jest mniejszy.
+COPY app ./app
 
 EXPOSE 8005
 CMD ["uvicorn", "app.main:app", "--host", "0.0.0.0", "--port", "8005"]

services/astrodemo/tests/test_slownik_zakazany.py

@@ -175,3 +175,18 @@ def test_the_protocol_constants_are_the_one_known_exception():
             assert any(z in linia for z in ("x-astrololo", "vnd.astrololo",
                                             "astrololo/link/", 'getlogger("astrololo')), \
                 f"{f.name}: „{linia.strip()[:70]}” to nie jest stała protokołu"
+
+
+def test_only_the_application_code_ships_in_the_image():
+    """Obraz nie może wieźć tego testu.
+
+    Ironia, którą łatwo przeoczyć: plik pilnujący, żeby pewne słowa nie padły,
+    sam je wypisuje — więc gdy trafi do obrazu, staje się tym wyciekiem, przed
+    którym broni. `COPY . .` wnosiło cały katalog usługi, razem z tests/.
+    """
+    # Same instrukcje, bez komentarzy: komentarz obok tej linii CYTUJE dawną
+    # postać, więc szukanie po całym pliku zgłaszałoby własne wyjaśnienie.
+    instrukcje = [l for l in (APP.parent / "Dockerfile").read_text(encoding="utf-8").splitlines()
+                  if l.strip() and not l.lstrip().startswith("#")]
+    assert not any(l.strip() == "COPY . ." for l in instrukcje), "obraz wnosi wszystko, w tym testy"
+    assert any(l.strip() == "COPY app ./app" for l in instrukcje)

services/astroklient/Dockerfile

@@ -0,0 +1,28 @@
+FROM python:3.12-slim
+
+WORKDIR /app
+COPY services/astroklient/requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Rdzeń wspólny z pełną aplikacją: ekrany astrologiczne, szablony, zasoby.
+# Jedno źródło, dwa produkty — inaczej te same 2500 linii szablonów żyłyby
+# w dwóch egzemplarzach i rozjechały się w ciągu tygodni, po cichu.
+COPY services/presentation/app ./app
+
+# …minus wszystko, czego ten produkt nie ma. Lista jest DANYMI, a nie tekstem
+# w tym pliku: czyta ją także test, który pilnuje, żeby zgadzała się ze
+# złożeniem w main.py. Rozjazd między nimi znaczyłby albo martwy kod w obrazie,
+# albo brakujący plik i błąd dopiero przy uruchomieniu.
+COPY services/astroklient/usun.txt .
+RUN while read -r SCIEZKA; do \
+      [ -n "$SCIEZKA" ] || continue; \
+      test -e "app/$SCIEZKA" || { echo "usun.txt wskazuje nieistniejące: $SCIEZKA"; exit 1; }; \
+      rm -rf "app/$SCIEZKA"; \
+    done < usun.txt && rm usun.txt
+
+# Nakładka: własne logowanie, własna pula plików, własny ekran wgrywania,
+# własne złożenie. Nadpisuje pliki o tych samych nazwach.
+COPY services/astroklient/app ./app
+
+EXPOSE 8006
+CMD ["uvicorn", "app.main:app", "--host", "0.0.0.0", "--port", "8006"]

services/astroklient/app/clients/logic_client.py

@@ -0,0 +1,174 @@
+"""Klient warstwy logicznej — z PULĄ KONTA (PRE-29).
+
+Każde konto ma własny, niewidoczny dla pozostałych zbiór plików. Pula jedzie
+w każdym żądaniu w dół i bierze się WYŁĄCZNIE z kontekstu ustawianego przy
+wejściu, nigdy z pola formularza: gdyby przychodziła z żądania, wystarczyłoby
+podstawić cudzy login, żeby czytać cudze pliki.
+
+Kontekst zamiast argumentu, bo ekrany są wspólne z pełną aplikacją i wołają
+klienta jako obiekt modułowy. Przekazywanie puli przez wszystkie wywołania
+znaczyłoby, że pominięcie jednego z nich cicho otwiera dostęp do całego udziału —
+a takiego pominięcia nie widać.
+"""
+from __future__ import annotations
+
+import contextvars
+import os
+from typing import Any
+
+import httpx
+
+# Login zalogowanego konta na czas obsługi żądania. Ustawia go bramka wejścia.
+KONTO: contextvars.ContextVar[str] = contextvars.ContextVar("konto", default="")
+
+
+from app import link_crypto
+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 {}
+
+
+def _link() -> link_crypto.Link | None:
+    """Klucz łącza prezentacja↔logika. Czytany przy każdym wywołaniu, bo
+    konfiguracja może się zmienić bez restartu procesu (testy, podmiana sekretu)."""
+    key = link_crypto.key_from_env(link_crypto.ENV_PRESENTATION_LOGIC)
+    return link_crypto.Link(key) if key else None
+
+
+class LogicClient:
+    def __init__(self, base_url: str | None = None) -> None:
+        self.base_url = (base_url or settings.logic_url).rstrip("/")
+
+    def _post(self, path: str, payload: dict[str, Any], timeout: float) -> dict[str, Any]:
+        # Pula konta dokładana do KAŻDEGO żądania w dół. Bierze się z kontekstu
+        # ustawianego przy wejściu, nigdy z pola formularza — gdyby przychodziła
+        # z żądania, wystarczyłoby podstawić cudzy login, żeby czytać cudze pliki.
+        # Trasy, których pula nie dotyczy, po prostu ignorują nadmiarowe pole.
+        payload = {**payload, "tenant": KONTO.get("")}
+        """Jedyna droga w dół. Celowo JEDNA: dopóki każda metoda składała żądanie
+        sama, dołożenie nowej znaczyło, że łatwo zapomnieć o tokenie albo kluczu
+        łącza — i tak się już raz stało (401 wyszedł dopiero na produkcji)."""
+        with httpx.Client(timeout=timeout) as client:
+            return link_crypto.call_json(client, "POST", f"{self.base_url}{path}",
+                                         payload=payload, headers=_auth_headers(),
+                                         link=_link())
+
+    # ── transport dla modułów opcjonalnych ─────────────────────────────────
+    # Moduł nie może dopisywać sobie metod do tej klasy: jego nazwy siedziałyby
+    # wtedy w pliku, który jedzie do KAŻDEGO obrazu. Dostaje więc samą drogę
+    # w dół, a co nią wysyła, jest jego sprawą. Szyfrowanie łącza i token
+    # międzywarstwowy obowiązują tak samo — to nie jest obejście ochrony.
+    def wywolaj(self, sciezka: str, payload: dict[str, Any], timeout: float) -> dict[str, Any]:
+        return self._post(sciezka, payload, timeout)
+
+    def pobierz(self, sciezka: str, timeout: float | None = None) -> dict[str, Any]:
+        with httpx.Client(timeout=timeout or settings.http_timeout) as client:
+            return link_crypto.call_json(client, "GET", f"{self.base_url}{sciezka}",
+                                         headers=_auth_headers(), link=_link())
+
+    def strumien(self, sciezka: str, payload: dict[str, Any]):
+        """Strumień NDJSON w dół — przekazywany dalej ramka po ramce.
+
+        Idzie przez szyfrowane łącze jak reszta ruchu (PRE-16): bez tego przy
+        włączonym LINK_ENCRYPTION_REQUIRED serwer odrzuciłby żądanie."""
+        with httpx.Client(timeout=httpx.Timeout(None, connect=15.0)) as client:
+            yield from link_crypto.stream_lines(
+                client, f"{self.base_url}{sciezka}",
+                payload=payload, headers=_auth_headers(), link=_link())
+
+    def query(self, query: str, field: str, exact: bool, limit: int) -> dict[str, Any]:
+        payload = {"query": query, "field": field, "exact": exact, "limit": limit}
+        return self._post("/api/query", payload, settings.http_timeout)
+
+    def positions(
+        self,
+        when_utc_iso: str,
+        lat: float,
+        lon: float,
+        objects: list[str] | None = None,
+        house_system: str = "whole_sign",
+        stations: bool = False,
+        zodiac: str = "tropical",
+        tables: bool = False,
+        house_systems: list[str] | None = None,
+        aspect_orb: float = 8.0,
+        aspect_luminary_bonus: float = 2.0,
+        aspect_minor: bool = False,
+    ) -> dict[str, Any]:
+        """Pełny horoskop dla danego momentu — woła logic /chart/positions."""
+        payload = {
+            "when_utc": when_utc_iso,
+            "lat": lat,
+            "lon": lon,
+            "objects": objects,
+            "house_system": house_system,
+            "house_systems": house_systems,
+            "aspect_orb": aspect_orb,
+            "aspect_luminary_bonus": aspect_luminary_bonus,
+            "aspect_minor": aspect_minor,
+            "stations": stations,
+            "zodiac": zodiac,
+            "tables": tables,
+        }
+        # stacje ORAZ tabele wymagają root-findów / szukania numerycznego — dłuższy timeout
+        timeout = max(settings.http_timeout, 60.0) if (stations or tables) else settings.http_timeout
+        return self._post("/chart/positions", payload, timeout)
+
+    def synastry(
+        self, person_a: dict, person_b: dict, zodiac: str = "tropical",
+        aspect_orb: float = 8.0, aspect_luminary_bonus: float = 2.0, aspect_minor: bool = False,
+    ) -> dict[str, Any]:
+        """Synastria dwóch osób (PRE-04) — aspekty między horoskopami."""
+        payload = {
+            "person_a": person_a, "person_b": person_b, "zodiac": zodiac,
+            "aspect_orb": aspect_orb, "aspect_luminary_bonus": aspect_luminary_bonus,
+            "aspect_minor": aspect_minor,
+        }
+        return self._post("/chart/synastry", payload, settings.http_timeout)
+
+    def report(
+        self, when_utc_iso: str, lat: float, lon: float, limit: int = 5000, group: bool = False
+    ) -> dict[str, Any]:
+        """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}
+        return self._post("/chart/report", payload, max(settings.http_timeout, 30.0))
+
+    def bases(self) -> dict[str, Any]:
+        """Bazy dostępne na udziale + metaopis i stan włączenia (DAN-15/PRE-09)."""
+        with httpx.Client(timeout=settings.http_timeout) as client:
+            return link_crypto.call_json(client, "GET", f"{self.base_url}/bases",
+                                         headers=_auth_headers(), link=_link())
+
+
+    # ── zarządzanie plikami baz (DAN-27) ────────────────────────────────
+    # Jedna metoda na trasę, bez sprytnego generyka: te wywołania różnią się
+    # skutkiem (odczyt / zapis / skasowanie), a ujednolicenie ich w jedno
+    # `call(path, payload)` zaciera tę różnicę dokładnie tam, gdzie jest ważna.
+
+    def files_status(self, path: str, status: str, by: str = "") -> dict[str, Any]:
+        return self._files_post("/files/status", {"path": path, "status": status, "by": by})
+
+    def files_upload(self, filename: str, content_b64: str, by: str = "") -> dict[str, Any]:
+        return self._files_post("/files/upload",
+                                {"filename": filename, "content_b64": content_b64, "by": by})
+
+    def _files_post(self, path: str, payload: dict) -> dict[str, Any]:
+        payload = {**payload, "tenant": KONTO.get("")}
+        with httpx.Client(timeout=settings.http_timeout) as client:
+            return link_crypto.call_json(client, "POST", f"{self.base_url}{path}",
+                                         payload=payload, headers=_auth_headers(), link=_link())
+
+    def timeline(
+        self, when_utc_iso: str, lat: float, lon: float,
+        from_date: str, to_date: str, interpret: bool = True,
+    ) -> dict[str, Any]:
+        """Oś czasu z technik (+interpretacje z bazy) — woła logic /chart/timeline."""
+        payload = {
+            "when_utc": when_utc_iso, "lat": lat, "lon": lon,
+            "from_date": from_date, "to_date": to_date, "interpret": interpret,
+        }
+        return self._post("/chart/timeline", payload, max(settings.http_timeout, 60.0))

services/astroklient/app/ekrany/wgrywanie.py

@@ -0,0 +1,75 @@
+"""Wgrywanie plików: jedna czynność, nie dwie.
+
+„Dodać plik" ma tu znaczyć, że od razu bierze udział w wyszukiwaniu — inaczej po
+wgraniu nic by się nie zmieniło i wyglądałoby to na zepsute. Nie ma listy plików
+ani ich stanów: ta usługa ma jeden poziom dostępu, więc nie ma komu ich
+pokazywać ani po co.
+"""
+from __future__ import annotations
+
+import base64
+
+import httpx
+from fastapi import File, Request, UploadFile
+from fastapi.responses import HTMLResponse, RedirectResponse
+
+from app.features import Feature
+from app.podstawa import app, features, logic, templates, _logic_error
+
+# Stan pliku „w użyciu" — ta sama nazwa, co w warstwie danych (DAN-27). Wpisana
+# tutaj wprost, bo ta usługa tamtej warstwy nie importuje; literówka objawiłaby
+# się dopiero na żywo, więc pilnuje jej test.
+W_UZYCIU = "active"
+
+
+@app.get("/pliki", response_class=HTMLResponse)
+def wgrywanie_form(request: Request, error: str = "", done: str = ""):
+    return templates.TemplateResponse(request, "wgrywanie.html",
+                                      {"error": error, "done": done})
+
+
+@app.post("/pliki/wgraj")
+async def wgraj(request: Request, upload: UploadFile = File(...)):
+    """Wgranie ORAZ włączenie do użytku.
+
+    Plik o złym układzie nie wchodzi do użytku, ale NIE JEST tracony — zostaje
+    zapisany i czeka. Komunikat nie mówi, CZYM się nie nadaje: różnica w treści
+    byłaby wyrocznią, z której da się odczytać, czego program oczekuje.
+    """
+    raw = await upload.read()
+    if not raw:
+        return _wroc(error="Pusty plik.")
+
+    kto = getattr(request.state, "user", "") or "?"
+    try:
+        out = logic.files_upload(upload.filename or "dane.xlsx",
+                                 base64.b64encode(raw).decode("ascii"), by=kto)
+    except httpx.HTTPError as e:
+        return _wroc(error=_logic_error(e))
+
+    nazwa = out.get("name") or "plik"
+    if not out.get("accepted"):
+        return _wroc(done=f"Plik „{nazwa}” został przyjęty, ale nie nadaje się "
+                          f"do użycia w tej postaci.")
+    try:
+        logic.files_status(out["path"], W_UZYCIU, by=kto)
+    except httpx.HTTPError as e:
+        return _wroc(error=f"Plik „{nazwa}” wgrany, ale nie udało się go włączyć.")
+    return _wroc(done=f"Dodano „{nazwa}”. Plik jest już używany przy wyszukiwaniu.")
+
+
+def _wroc(error: str = "", done: str = "") -> RedirectResponse:
+    """Po zapisie PRZEKIEROWANIE, nie render — odświeżenie strony nie może
+    wgrać pliku drugi raz."""
+    from urllib.parse import urlencode
+
+    q = urlencode({k: v for k, v in (("error", error), ("done", done)) if v})
+    return RedirectResponse(f"/pliki{'?' + q if q else ''}", status_code=303)
+
+
+features.zarejestruj(
+    ekran=Feature("files", "Pliki", "Dodawanie plików używanych przy wyszukiwaniu.",
+                  "Ekrany", "/pliki", kolejnosc=70),
+    trasy={("GET", "/pliki"): "files", ("POST", "/pliki/wgraj"): "files"},
+    zasoby={"s-wgrywanie.css": "files"},
+)

services/astroklient/app/main.py

@@ -0,0 +1,34 @@
+"""Astroklient — ZŁOŻENIE produktu.
+
+Pełne funkcje astrologiczne, bez generowania tekstu i bez administracji. Ten plik
+nie zawiera żadnej trasy: odpowiada wyłącznie na pytanie, z czego składa się ten
+produkt. Import ekranu rejestruje jego trasy, więc lista poniżej JEST definicją.
+
+Poza tą listą nie ma nic. Nie chodzi o funkcje wyłączone: plików, których tu nie
+widać, nie ma w obrazie (patrz usun.txt), więc nie istnieje uprawnienie, którym
+dałoby się cokolwiek odsłonić — ani nazwa, po której dałoby się zgadnąć, czego
+szukać.
+"""
+from __future__ import annotations
+
+from app import rozszerzenia
+from app.podstawa import (_asset_body, _asset_version, _build_utc, _logic_error, app,
+                          logic, static_url, templates)
+from app.ekrany import (  # noqa: F401 - import rejestruje trasy
+    horoskop,
+    interpretacje,
+    kalendarz,
+    logowanie,
+    lokalizacja,
+    sygnifikatory,
+    synastria,
+    wgrywanie,
+)
+
+__all__ = ["app", "logic", "templates", "static_url", "_asset_body", "_asset_version"]
+
+# Most modułów opcjonalnych zostaje CELOWO. W tym obrazie nie ma katalogu
+# `app/moduly/`, więc odkrywa zero modułów i wszystkie odpowiedzi są puste —
+# aplikacja zachowuje się tak, jakby takiego pojęcia nigdy nie było.
+rozszerzenia.zamontuj(app, logic=logic, templates=templates,
+                      buduj_utc=_build_utc, blad=_logic_error)

services/astroklient/app/produkt.py

@@ -0,0 +1,8 @@
+"""Nazwa produktu — nakładka astroklienta.
+
+Nadpisuje wersję z rdzenia. Test słownikowy pilnuje, żeby po nadpisaniu nazwa
+tamtego produktu nie została nigdzie w szablonach, zasobach ani w odpowiedziach.
+"""
+from __future__ import annotations
+
+NAZWA = "astroklient"

services/astroklient/app/security.py

@@ -0,0 +1,384 @@
+"""Logowanie i bramka uprawnień astroklienta.
+
+Konta pochodzą WYŁĄCZNIE z konfiguracji środowiska (`ASTROKLIENT_USERS`), a każde
+dostaje ten sam zestaw: wszystko, co ta usługa umie. Konta rozdziela się po to,
+żeby każde miało własną, niewidoczną dla pozostałych pulę plików — nie po to, żeby
+dawać im różne poziomy dostępu. Poziom jest jeden i nie ma go z czym porównywać.
+
+Reszta jest wspólna z pozostałymi usługami i celowo nietknięta: hasła jako scrypt,
+sesja w podpisanym ciasteczku, limit żądań, dziennik audytowy, oraz odmowa jako
+404 zamiast 403 — bo 403 samo w sobie mówi, że coś tam jest.
+"""
+from __future__ import annotations
+
+import base64
+import binascii
+import hashlib
+import hmac
+import logging
+import os
+import secrets
+import time
+from collections import deque
+from dataclasses import dataclass
+
+from fastapi import Request
+from fastapi.responses import HTMLResponse, JSONResponse, RedirectResponse
+
+log = logging.getLogger("astrololo.security")
+
+MAX_TRACKED_CLIENTS_DEFAULT = 4096
+MAX_TRACKED_CLIENTS = MAX_TRACKED_CLIENTS_DEFAULT   # zabezpieczenie przed puchnięciem pamięci
+
+
+# ── konta ─────────────────────────────────────────────────────────────────
+# Wyłącznie z konfiguracji środowiska. Konta rozdziela się po to, żeby każde
+# miało własną pulę plików — nie po to, żeby różniły się tym, co widzą.
+# ── konta imienne (PRE-17) ───────────────────────────────────────────────
+# Parametry scrypt: rozsądny kompromis czas/pamięć dla logowania do aplikacji
+# wewnętrznej. Zmiana wymaga przeliczenia haseł (hash niesie tylko sól).
+_SCRYPT_N, _SCRYPT_R, _SCRYPT_P, _SCRYPT_LEN = 2**14, 8, 1, 32
+_HASH_PREFIX = "scrypt$"
+
+
+def hash_password(password: str, salt: bytes | None = None) -> str:
+    """Hasło → wpis do ASTROKLIENT_USERS: `scrypt$<sól_hex>$<hash_hex>`."""
+    salt = salt or secrets.token_bytes(16)
+    dk = hashlib.scrypt(password.encode("utf-8"), salt=salt,
+                        n=_SCRYPT_N, r=_SCRYPT_R, p=_SCRYPT_P, dklen=_SCRYPT_LEN)
+    return f"{_HASH_PREFIX}{salt.hex()}${dk.hex()}"
+
+
+def accounts() -> dict[str, str]:
+    """Konta z `ASTROKLIENT_USERS` — `login:sekret`, po przecinku.
+
+    Sekret to hash scrypt (`scrypt$sól$hash`), ten sam format co w pozostałych
+    usługach — jedna implementacja, więc nie ma czego rozjechać."""
+    out: dict[str, str] = {}
+    for entry in os.getenv("ASTROKLIENT_USERS", "").split(","):
+        entry = entry.strip()
+        if not entry:
+            continue
+        user, sep, secret = entry.partition(":")
+        if sep and user.strip() and secret.strip():
+            out[user.strip()] = secret.strip()
+    return out
+
+
+def _secret_matches(spec: str, password: str) -> bool:
+    """Sekret konta vs podane hasło. Hash scrypt albo (zgodność wstecz) jawne."""
+    if spec.startswith(_HASH_PREFIX):
+        try:
+            _, salt_hex, hash_hex = spec.split("$", 2)
+            salt, expected = bytes.fromhex(salt_hex), bytes.fromhex(hash_hex)
+        except ValueError:
+            return False
+        actual = hashlib.scrypt(password.encode("utf-8"), salt=salt,
+                                n=_SCRYPT_N, r=_SCRYPT_R, p=_SCRYPT_P, dklen=_SCRYPT_LEN)
+        return hmac.compare_digest(actual, expected)
+    # Porównujemy BAJTY, nie tekst: `compare_digest` na stringach rzuca TypeError
+    # przy znakach spoza ASCII, więc hasło z polskimi literami wywracało logowanie
+    # błędem 500 zamiast zwykłej odmowy (błąd zastany, złapany testem).
+    return hmac.compare_digest(spec.encode("utf-8"), password.encode("utf-8"))
+
+
+def rate_limit_per_min() -> int:
+    return int(os.getenv("RATE_LIMIT_PER_MIN", "120"))
+
+
+def cookies_secure() -> bool:
+    """Czy ciasteczko sesji ma być wyłącznie dla https.
+
+    Domyślnie TAK. Wyłączamy jedynie w pracy lokalnej po http — inaczej
+    przeglądarka po prostu nie zapamięta ciasteczka i logowanie „nie działa"
+    bez żadnego komunikatu, co jest wyjątkowo mylącą awarią."""
+    return os.getenv("COOKIES_INSECURE", "").strip().lower() not in {"1", "true", "yes", "on"}
+
+
+def trust_proxy() -> bool:
+    return os.getenv("TRUST_PROXY", "").strip().lower() in {"1", "true", "yes", "on"}
+
+
+# /wyloguj jest „publiczna" tylko technicznie: przechodzi obok bramki, żeby móc
+# odpowiedzieć 401 CELOWO, zamiast dostać 200 od zalogowanej sesji. Bez tego
+# wylogowanie byłoby niemożliwe — przeglądarka dosyła zapamiętane dane przy każdym
+# żądaniu, więc handler i tak widziałby zalogowaną osobę.
+# /logowanie MUSI stać poza bramką — inaczej żeby się zalogować, trzeba by być
+# zalogowanym. /wyloguj też: ma działać także wtedy, gdy sesja już wygasła.
+# Ekran logowania musi się wyświetlić PRZED zalogowaniem, więc jego arkusz jest
+# jedynym publicznym zasobem — i dlatego nie wolno w nim trzymać niczego, co
+# nazywa funkcję (patrz features.STATIC).
+PUBLIC_PATHS = frozenset({"/health", "/logowanie", "/wyloguj", "/static/base.css"})
+# Pusto CELOWO. Dopóki był tu "/static/", cały katalog omijał bramkę: każdy plik
+# JS i arkusz stylów pobierał ktokolwiek, także niezalogowany, pod zgadywalnym
+# adresem — a ich treść wymienia ekrany, dostawców modeli i przeznaczenie baz.
+# Ruch do zasobów nie trafiał przy tym ani do dziennika, ani pod limit żądań,
+# więc wyciek był dla właściciela niewidoczny.
+PUBLIC_PREFIXES: tuple[str, ...] = ()
+
+_hits: dict[str, deque[float]] = {}
+
+
+def auth_enabled() -> bool:
+    return bool(accounts())
+
+
+def _is_public(path: str) -> bool:
+    return path in PUBLIC_PATHS or path.startswith(PUBLIC_PREFIXES)
+
+
+@dataclass(frozen=True)
+class Principal:
+    """Kto się zalogował i co wolno mu zobaczyć."""
+
+    login: str
+    permissions: frozenset[str]
+    is_admin: bool
+
+
+def _uprawnienia() -> frozenset[str]:
+    """Każde konto dostaje wszystko, co ta usługa umie — liczone z KATALOGU.
+
+    Katalog składa się ze zgłoszeń ekranów obecnych w obrazie, więc ten zbiór
+    opisuje dokładnie ten produkt, a nie listę wpisaną kiedyś ręcznie. Dopisanie
+    ekranu nie wymaga pamiętania o niczym; usunięcie go zabiera uprawnienie samo.
+
+    Nie ma tu uprawnienia administracyjnego i nie ma go skąd wziąć: `features.ADMIN`
+    celowo nie należy do GRANTABLE."""
+    from app import features
+
+    return frozenset(features.GRANTABLE)
+
+
+def _sekret(login: str) -> str | None:
+    return accounts().get(login)
+
+
+def verify(login: str, password: str) -> Principal | None:
+    """Sprawdza login i hasło. None = odmowa, bez podawania powodu.
+
+    Nieznany login i złe hasło dają ten sam wynik: rozróżnienie mówiłoby, które
+    konta istnieją, a to informacja warta czegoś dla zgadującego."""
+    spec = _sekret(login)
+    if spec is None or not _secret_matches(spec, password):
+        return None
+    return Principal(login, _uprawnienia(), False)
+
+
+def issue_session(login: str) -> str:
+    """Zawartość ciasteczka dla właśnie zalogowanego konta.
+
+    W ciasteczku ląduje ODCISK poświadczenia, dzięki czemu zmiana hasła albo
+    skasowanie konta unieważnia jego sesje same z siebie — bez pamiętania o tym
+    i bez żadnego magazynu sesji."""
+    from app import session
+
+    # Wersja sesji zawsze 0: nie ma trwałego magazynu, więc nie ma gdzie trzymać
+    # licznika pokolenia. Wylogowanie i zmiana hasła i tak działają — pierwsze
+    # przez skasowanie ciasteczka, drugie przez odcisk, który przestaje pasować.
+    return session.issue(login, session.fingerprint(_sekret(login) or ""), 0)
+
+
+def principal(request: Request) -> Principal | None:
+    """Ciasteczko → kto to jest. None = nie wpuszczać."""
+    from app import session
+
+    dane = session.read(request.cookies.get(session.COOKIE))
+    if dane is None:
+        return None
+    spec = _sekret(dane["login"])
+    if spec is None:
+        return None
+    # Zmiana hasła w konfiguracji ubija sesje tego konta — to jest tutaj jedyny
+    # sposób na „wyloguj mnie ze wszystkich urządzeń", bo bez trwałego magazynu
+    # nie ma gdzie trzymać licznika pokolenia sesji.
+    if session.fingerprint(spec) != dane["odcisk"]:
+        return None
+    return Principal(dane["login"], _uprawnienia(), False)
+
+
+def client_ip(request: Request) -> str:
+    """Adres, po którym rozliczamy limit żądań.
+
+    Za odwrotnym proxy (u nas: Ingress/Traefik po włączeniu TLS — PRE-16)
+    `request.client.host` to adres POD-a proxy, jednakowy dla wszystkich. Bez
+    poprawki cały ruch trafiałby do jednego wiadra i pierwsza osoba, która
+    wyklika limit, odcięłaby pozostałe.
+
+    Nagłówkom wierzymy WYŁĄCZNIE przy TRUST_PROXY — bo inaczej wystarczyłoby
+    dopisać własny `X-Forwarded-For`, żeby przy każdym żądaniu wyglądać na kogoś
+    innego i ominąć limit całkowicie. Z tego samego powodu bierzemy OSTATNI wpis
+    listy: to jedyny, który dopisał nasz proxy. Wcześniejsze mógł podstawić
+    klient, więc nie znaczą nic.
+    """
+    peer = request.client.host if request.client else "?"
+    if not trust_proxy():
+        return peer
+    forwarded = request.headers.get("x-forwarded-for", "")
+    if forwarded:
+        last = forwarded.rsplit(",", 1)[-1].strip()
+        if last:
+            return last
+    return request.headers.get("x-real-ip", "").strip() or peer
+
+
+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
+
+
+# ── dziennik audytowy (PRE-17) ───────────────────────────────────────────
+audit_log = logging.getLogger("astrololo.audit")
+
+
+def _setup_audit_logging() -> None:
+    """Gwarantuje, że wpisy audytowe FAKTYCZNIE wychodzą na stdout.
+
+    Domyślna konfiguracja uvicorna nie obsługuje naszych loggerów, więc wpisy na
+    poziomie INFO ginęły — dziennik istniał w kodzie, ale był pusty (sprawdzone
+    na żywym serwerze). Niewidoczny dziennik jest gorszy niż jego brak: daje
+    złudzenie kontroli. Własny handler na stdout, bo w k8s to stamtąd zbierane
+    są logi. `propagate=False` — żeby wpis nie dublował się przez korzeń.
+    """
+    audit_log.setLevel(os.getenv("AUDIT_LEVEL", "INFO").upper())
+    if not audit_log.handlers:
+        handler = logging.StreamHandler()
+        handler.setFormatter(logging.Formatter("%(asctime)s %(levelname)s %(message)s"))
+        audit_log.addHandler(handler)
+    audit_log.propagate = False
+
+
+def audit_records(request: Request, count: int) -> None:
+    """Handler zgłasza, ILE rekordów baz oddał — trafi do wpisu audytowego.
+
+    Sama liczba, nigdy treść. Bez tego dziennik pokazywałby tylko „ktoś wchodził",
+    a nie „ktoś wyniósł 5000 rekordów" — a to drugie jest sygnałem nadużycia."""
+    try:
+        request.state.audit_records = int(count)
+    except (TypeError, ValueError):
+        pass
+
+
+def audit_login(request: Request, login: str, udane: bool) -> None:
+    """Zdarzenie logowania w dzienniku (PRE-17).
+
+    Nieudane próby są tu ważniejsze od udanych: pojedyncza nic nie znaczy, ale
+    seria pod jednym adresem to jedyny widoczny ślad zgadywania haseł. Logujemy
+    LOGIN, nigdy hasła ani jego fragmentu — dziennik to kolejny nośnik wycieku."""
+    audit_log.info("AUDYT zdarzenie=%s user=%s ip=%s",
+                   "logowanie-ok" if udane else "logowanie-odmowa",
+                   login or "-", client_ip(request))
+
+
+def audit_logout(request: Request) -> None:
+    audit_log.info("AUDYT zdarzenie=wylogowanie user=%s ip=%s",
+                   getattr(request.state, "user", "") or "-", client_ip(request))
+
+
+def _audit(request: Request, user: str, status: int, ms: float) -> None:
+    records = getattr(request.state, "audit_records", None)
+    audit_log.info(
+        "AUDYT user=%s ip=%s method=%s path=%s status=%s records=%s ms=%.0f",
+        user or "-", client_ip(request), request.method, request.url.path,
+        status, "-" if records is None else records, ms,
+    )
+
+
+def install(app) -> None:
+    """Podpina ochronę pod wszystkie ścieżki poza publicznymi."""
+    from app import session
+
+    _setup_audit_logging()
+
+    # FAIL-CLOSED. Usługa z kontami, ale bez klucza podpisu, nie umiałaby odróżnić
+    # ważnej sesji od podrobionej. Lepiej, żeby nie wstała, niż żeby wpuszczała —
+    # i lepiej teraz, przy starcie, niż przy pierwszym logowaniu człowieka.
+    if auth_enabled() and not session.available():
+        raise session.SessionError(
+            "Konta są skonfigurowane, ale brakuje SESSION_SECRET — bez klucza "
+            "podpisu sesje nie działają, a logowanie nie miałoby czym się bronić. "
+            "Wygeneruj: openssl rand -hex 32")
+
+    if not auth_enabled():
+        log.warning(
+            "UWAGA: brak kont (ASTROKLIENT_USERS) — usługa jest OTWARTA dla "
+            "każdego, kto ma do niej dostęp sieciowy, wraz z treścią plików."
+        )
+
+    @app.middleware("http")
+    async def _guard(request: Request, call_next):
+        if _is_public(request.url.path):
+            return await call_next(request)
+
+        started = time.monotonic()
+        if _rate_limited(client_ip(request)):
+            _audit(request, "-", 429, (time.monotonic() - started) * 1000)
+            return JSONResponse(
+                {"detail": "Zbyt wiele żądań — spróbuj za chwilę."},
+                status_code=429, headers={"Retry-After": "60"},
+            )
+
+        from app import features
+
+        user, who, odswiez = "", None, None
+        if auth_enabled():
+            who = principal(request)
+            if who is None:
+                _audit(request, "-", 303, (time.monotonic() - started) * 1000)
+                # Przekierowanie na ekran logowania, nie 401: 401 z Basic otwierało
+                # okienko systemowe, którego nie da się ani opisać, ani z niego wyjść.
+                # Zapamiętujemy, dokąd ktoś zmierzał — po zalogowaniu wraca na miejsce.
+                from urllib.parse import quote
+
+                cel = request.url.path
+                dokad = f"?dokad={quote(cel, safe='/')}" if request.method == "GET" and cel != "/" else ""
+                return RedirectResponse(f"/logowanie{dokad}", status_code=303)
+            user = who.login
+            # Ruch przedłuża sesję, ale ciasteczko odsyłamy tylko wtedy, gdy
+            # znacznik zdążył się zestarzeć — inaczej Set-Cookie leciałby przy
+            # każdym obrazku i arkuszu stylów.
+            from app import session as _s
+
+            dane = _s.read(request.cookies.get(_s.COOKIE))
+            odswiez = _s.refresh(dane) if dane else None
+        else:
+            # Bez kont ochrona jest wyłączona (dev), więc widać wszystko — inaczej
+            # deweloper zobaczyłby pustą aplikację i szukałby błędu tam, gdzie go nie ma.
+            who = Principal("", _uprawnienia(), False)
+
+        request.state.user = user
+        request.state.principal = who
+        # Pula plików na czas obsługi tego żądania. Ustawiana TU, w jednym
+        # miejscu, zaraz po ustaleniu kto to jest — klient czyta ją z kontekstu,
+        # więc żadne wywołanie w dół nie może o niej zapomnieć.
+        from app.clients.logic_client import KONTO
+
+        KONTO.set(user)
+
+        # 404, NIE 403. Odmowa z powodem jest informacją, że coś tam jest —
+        # a konto ograniczone ma widzieć program kompletny, tylko mniejszy.
+        need = features.required(request.method, request.url.path)
+        if not features.can(who.permissions, need):
+            _audit(request, user, 404, (time.monotonic() - started) * 1000)
+            return HTMLResponse("<h1>404 — nie znaleziono</h1>", status_code=404)
+        response = await call_next(request)
+        if odswiez:
+            from app import session as _s
+
+            response.set_cookie(_s.COOKIE, odswiez, max_age=_s.max_age(),
+                                **_s.cookie_params(secure=cookies_secure()))
+        _audit(request, user, response.status_code, (time.monotonic() - started) * 1000)
+        return response

services/astroklient/app/session.py

@@ -0,0 +1,186 @@
+"""Sesje logowania — podpisane ciasteczko (LOG-34).
+
+CO ZASTĘPUJE I DLACZEGO. HTTP Basic nie ma wylogowania: przeglądarka zapamiętuje
+hasło i dosyła je SAMA przy każdym żądaniu, więc serwer nie ma czego zapomnieć.
+Sesja odwraca tę zależność — to serwer decyduje, czy dana przeglądarka jest
+w środku, i może tę decyzję cofnąć.
+
+TRZY POZIOMY UNIEWAŻNIENIA, celowo rozdzielone, bo każdy kosztuje co innego:
+
+  1. WYLOGOWANIE = skasowanie ciasteczka. Natychmiastowe, bez żadnego magazynu,
+     działa wszędzie. To jest to, czego oczekuje człowiek klikający „Wyloguj".
+  2. ZMIANA POŚWIADCZEŃ = odcisk hasła wpisany w ciasteczko przestaje pasować.
+     Zmiana hasła albo skasowanie konta ubija jego sesje SAMO, bez pamiętania
+     o tym — i też nie wymaga magazynu.
+  3. WYLOGOWANIE ZDALNE („wyrzuć ze wszystkich urządzeń") = licznik wersji,
+     który musi gdzieś leżeć. Wymaga zapisu, więc jest opcjonalny: gdy aplikacja
+     nie poda licznika, poziomy 1 i 2 nadal działają.
+
+Poziom 2 jest tu najważniejszy: bez niego odebranie komuś dostępu przez zmianę
+hasła zostawiałoby jego otwartą sesję żywą aż do wygaśnięcia — czyli odebranie
+dostępu nie odbierałoby dostępu.
+
+KLUCZ JEST WYMAGANY i bez niego usługa się nie uruchamia. Losowanie przy starcie
+byłoby wygodne, ale oznaczałoby wylogowanie wszystkich przy każdym restarcie
+poda — co wygląda jak awaria i uczy ludzi ignorować ekran logowania.
+
+Podpis: HMAC-SHA256 ze stdlib. Bez nowych zależności — ta sama linia co scrypt
+w PRE-27 i AES w PRE-16.
+"""
+from __future__ import annotations
+
+import base64
+import hashlib
+import hmac
+import json
+import os
+import time
+
+# Nazwa własna tej usługi. Gdyby dwie aplikacje pod jedną domeną używały
+# ciasteczka o tej samej nazwie, nadpisywałyby się nawzajem i człowiek wypadałby
+# z jednej, logując się do drugiej.
+COOKIE = "astroklient_sesja"
+
+# Twardy kres życia sesji i kres bezczynności. Oba w sekundach, oba z konfiguracji.
+DEFAULT_MAX_AGE = 30 * 24 * 3600      # 30 dni — po tylu i tak każe się zalogować
+DEFAULT_IDLE = 8 * 3600               # 8 godzin bez ruchu = koniec
+
+# Co ile odświeżamy znacznik aktywności w ciasteczku. Bez tego progu każde
+# żądanie odsyłałoby Set-Cookie, także obrazki i arkusze stylów.
+REFRESH_AFTER = 300
+
+
+class SessionError(RuntimeError):
+    """Sesje nie mogą działać — brak klucza albo klucz nie do przyjęcia."""
+
+
+def _env_int(name: str, default: int) -> int:
+    try:
+        return int(os.getenv(name, "") or default)
+    except ValueError:
+        return default
+
+
+def max_age() -> int:
+    return _env_int("SESSION_MAX_AGE", DEFAULT_MAX_AGE)
+
+
+def idle_timeout() -> int:
+    return _env_int("SESSION_IDLE", DEFAULT_IDLE)
+
+
+def secret() -> bytes:
+    """Klucz podpisu. Brak = wyjątek, NIE cichy losowy klucz.
+
+    Fail-closed jest tu celowe: usługa bez klucza nie umie odróżnić ważnej sesji
+    od podrobionej, więc lepiej, żeby nie wstała, niż żeby wpuszczała."""
+    raw = os.getenv("SESSION_SECRET", "").strip()
+    if not raw:
+        raise SessionError(
+            "Brak SESSION_SECRET — bez klucza podpisu sesje nie mogą działać. "
+            "Wygeneruj: openssl rand -hex 32")
+    if len(raw) < 32:
+        raise SessionError(
+            f"SESSION_SECRET ma {len(raw)} znaków — za krótki. Wymagane co najmniej 32; "
+            f"krótki klucz da się odgadnąć, a wtedy podrobienie sesji jest trywialne.")
+    return raw.encode("utf-8")
+
+
+def available() -> bool:
+    """Czy sesje da się w ogóle obsłużyć (do sprawdzenia przy starcie)."""
+    try:
+        secret()
+    except SessionError:
+        return False
+    return True
+
+
+def fingerprint(secret_spec: str) -> str:
+    """Odcisk poświadczenia konta — 16 znaków hasza z hasła (albo jego hasza).
+
+    NIE JEST to hasło ani nic, z czego da się je odtworzyć: bierzemy skrót
+    zapisanego sekretu, a ten dla kont zarządzanych sam jest już haszem scrypt.
+    Do ciasteczka trafia po to, żeby zmiana hasła albo skasowanie konta
+    unieważniły jego sesje same z siebie."""
+    return hashlib.sha256(("odcisk:" + (secret_spec or "")).encode("utf-8")).hexdigest()[:16]
+
+
+def _sign(payload: bytes) -> bytes:
+    return hmac.new(secret(), payload, hashlib.sha256).digest()
+
+
+def _b64(raw: bytes) -> str:
+    return base64.urlsafe_b64encode(raw).decode("ascii").rstrip("=")
+
+
+def _unb64(text: str) -> bytes:
+    return base64.urlsafe_b64decode(text + "=" * (-len(text) % 4))
+
+
+def issue(login: str, odcisk: str, wersja: int = 0, *, now: float | None = None) -> str:
+    """Nowe ciasteczko sesji dla konta."""
+    teraz = int(now if now is not None else time.time())
+    payload = json.dumps(
+        {"u": login, "f": odcisk, "v": int(wersja), "wyd": teraz, "akt": teraz},
+        separators=(",", ":"), sort_keys=True).encode("utf-8")
+    return f"{_b64(payload)}.{_b64(_sign(payload))}"
+
+
+def read(token: str | None, *, now: float | None = None) -> dict | None:
+    """Ciasteczko → zawartość albo None, gdy cokolwiek się nie zgadza.
+
+    None znaczy „nie wpuszczać" i nie mówi dlaczego — powód jest tu bez wartości
+    dla wołającego, a rozróżnianie „zła sygnatura" od „wygasło" tylko pomaga
+    zgadywać. Wygaśnięcie i tak kończy się tym samym ekranem logowania."""
+    if not token or "." not in token:
+        return None
+    surowy, _, podpis = token.rpartition(".")
+    try:
+        payload = _unb64(surowy)
+        oczekiwany = _sign(payload)
+        podany = _unb64(podpis)
+    except (ValueError, SessionError):
+        return None
+    # Porównanie w stałym czasie: zwykłe == przecieka informację o tym, ile
+    # pierwszych bajtów podpisu się zgadza, a to wystarcza do podrobienia.
+    if not hmac.compare_digest(oczekiwany, podany):
+        return None
+    try:
+        dane = json.loads(payload.decode("utf-8"))
+        login, odcisk = str(dane["u"]), str(dane["f"])
+        wersja, wyd, akt = int(dane["v"]), int(dane["wyd"]), int(dane["akt"])
+    except (ValueError, KeyError, TypeError):
+        return None
+
+    teraz = int(now if now is not None else time.time())
+    # Ciasteczko z przyszłości oznacza przestawiony zegar albo podrobienie —
+    # w obu wypadkach nie ma powodu mu ufać.
+    if wyd > teraz + 60:
+        return None
+    if teraz - wyd > max_age() or teraz - akt > idle_timeout():
+        return None
+    return {"login": login, "odcisk": odcisk, "wersja": wersja, "wydano": wyd, "aktywnosc": akt}
+
+
+def refresh(dane: dict, *, now: float | None = None) -> str | None:
+    """Odświeżone ciasteczko, gdy znacznik aktywności zdążył się zestarzeć.
+
+    None = nie ma potrzeby nic odsyłać. Bez tego progu każde żądanie zwracałoby
+    Set-Cookie — także po arkusze stylów i obrazki."""
+    teraz = int(now if now is not None else time.time())
+    if teraz - dane["aktywnosc"] < REFRESH_AFTER:
+        return None
+    payload = json.dumps(
+        {"u": dane["login"], "f": dane["odcisk"], "v": dane["wersja"],
+         "wyd": dane["wydano"], "akt": teraz},
+        separators=(",", ":"), sort_keys=True).encode("utf-8")
+    return f"{_b64(payload)}.{_b64(_sign(payload))}"
+
+
+def cookie_params(secure: bool = True) -> dict:
+    """Parametry ciasteczka wspólne dla ustawiania i kasowania.
+
+    httponly — JavaScript nie ma po co go czytać, a bez tego jeden wstrzyknięty
+    skrypt wynosi sesję. samesite=strict — odcina większość ataków polegających
+    na tym, że obca strona wysyła żądanie w imieniu zalogowanego."""
+    return {"httponly": True, "samesite": "strict", "secure": secure, "path": "/"}

services/astroklient/app/static/s-wgrywanie.css

@@ -0,0 +1,4 @@
+/* Arkusz ekranu „files” — dokładany tylko dla konta z tym uprawnieniem. */
+
+.card { background: var(--panel); border: 1px solid var(--line); border-radius: 12px;
+        padding: 1rem 1.1rem; margin-top: .4rem; }

services/astroklient/app/templates/wgrywanie.html

@@ -0,0 +1,23 @@
+{% extends "base.html" %}
+{% set nav_active = "files" %}
+{% block title %}Pliki{% endblock %}
+
+{% block styles %}<link rel="stylesheet" href="{{ static('s-wgrywanie.css') }}">
+{% endblock %}
+
+{% block content %}
+{# Opis czysto operacyjny: co robi wgranie, i nic o tym, do CZEGO te dane służą
+   ani co się z nimi dzieje dalej. #}
+<p class="muted">Wgrany plik jest od razu używany przy wyszukiwaniu.</p>
+
+{% if error %}<p class="notice-warn">{{ error }}</p>{% endif %}
+{% if done %}<p class="done-note">{{ done }}</p>{% endif %}
+
+<div class="meta">Wgraj plik</div>
+<form method="post" action="/pliki/wgraj" enctype="multipart/form-data" class="card">
+  <div class="grid">
+    <label>Plik <input type="file" name="upload" required></label>
+  </div>
+  <div class="actions"><button type="submit">Wgraj</button></div>
+</form>
+{% endblock %}

services/astroklient/requirements-dev.txt

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

services/astroklient/requirements.txt

@@ -0,0 +1,14 @@
+fastapi>=0.115
+uvicorn[standard]>=0.34
+httpx>=0.28
+jinja2>=3.1
+python-multipart>=0.0.20
+# Szyfrowanie łącza między warstwami (PRE-16): AES-256-GCM + HKDF
+cryptography>=44.0
+# Strefa czasowa z lokalizacji (PRE-03): współrzędne → strefa IANA (offline, lekki
+# wheel Rust), a offset/DST liczy stdlib zoneinfo. tzdata na wypadek slim-obrazu
+# bez systemowej bazy stref.
+tzfpy>=0.15
+tzdata>=2024.1
+# Eksport wyników do Excela — „tabela robocza" (DAN-23/PRE-10)
+openpyxl>=3.1

services/astroklient/tests/conftest.py

@@ -0,0 +1,94 @@
+"""Drzewo astroklienta budowane tak samo, jak buduje je Dockerfile.
+
+Ta usługa nie ma własnego kompletu plików: bierze rdzeń z warstwy prezentacji,
+usuwa z niego to, czego ten produkt nie ma (usun.txt), i nakłada własne. Testy
+muszą patrzeć na WYNIK tego złożenia, a nie na katalog `app/` w repozytorium —
+inaczej sprawdzałyby garść plików, a nie produkt.
+"""
+from __future__ import annotations
+
+import json
+import pathlib
+import re
+import shutil
+import subprocess
+import sys
+
+import pytest
+
+USLUGA = pathlib.Path(__file__).resolve().parents[1]
+RDZEN = USLUGA.parents[0] / "presentation" / "app"
+
+
+def zloz(cel: pathlib.Path) -> pathlib.Path:
+    """Rdzeń minus usun.txt plus nakładka — dokładnie jak w Dockerfile."""
+    app = cel / "app"
+    shutil.copytree(RDZEN, app, ignore=shutil.ignore_patterns("__pycache__", "*.pyc"))
+    for linia in (USLUGA / "usun.txt").read_text(encoding="utf-8").splitlines():
+        sciezka = linia.strip()
+        if not sciezka:
+            continue
+        do_usuniecia = app / sciezka
+        assert do_usuniecia.exists(), f"usun.txt wskazuje nieistniejące: {sciezka}"
+        shutil.rmtree(do_usuniecia) if do_usuniecia.is_dir() else do_usuniecia.unlink()
+    shutil.copytree(USLUGA / "app", app, dirs_exist_ok=True,
+                    ignore=shutil.ignore_patterns("__pycache__", "*.pyc"))
+    return cel
+
+
+@pytest.fixture(scope="session")
+def drzewo(tmp_path_factory) -> pathlib.Path:
+    return zloz(tmp_path_factory.mktemp("astroklient"))
+
+
+SONDA = '''
+import json, os, hashlib, secrets, re
+sol = secrets.token_bytes(16)
+dk = hashlib.scrypt(b"tajne", salt=sol, n=2**14, r=8, p=1, dklen=32)
+os.environ.update(ASTROKLIENT_USERS="klient:scrypt$%s$%s" % (sol.hex(), dk.hex()),
+                  SESSION_SECRET="t"*64, COOKIES_INSECURE="1", RATE_LIMIT_PER_MIN="0")
+from starlette.testclient import TestClient
+from app.main import app
+from app import security, session, features
+from app.clients import logic_client
+c = TestClient(app, follow_redirects=False)
+H = {"Cookie": f"{session.COOKIE}={security.issue_session('klient')}"}
+strona = c.get("/", headers=H).text
+zebrane = []
+logic_client.link_crypto.call_json = lambda *a, **kw: (zebrane.append(kw.get("payload")), {})[1]
+c.post("/interpret", headers=H, data={"date":"1984-04-30","time":"11:20",
+       "tz_offset":"2","lat":"50","lon":"19","tenant":"ktos-inny"})
+print("WYNIK:" + json.dumps({
+    "ekrany": [f.label for f in features.SCREENS],
+    "uprawnienia": sorted(security._uprawnienia()),
+    "dziala": {a: c.get(a, headers=H).status_code
+               for a in ("/", "/interpret", "/timeline", "/synastry",
+                         "/significators", "/pliki")},
+    "nie_ma": {a: c.get(a, headers=H).status_code
+               for a in ("/compile", "/settings", "/accounts", "/files",
+                         "/horoscope/stream", "/compile/pdf")},
+    "nawigacja": re.findall(r"<nav>(.*?)</nav>", strona, re.S)[0].count('<a href="'),
+    "pula": (zebrane[0] or {}).get("tenant"),
+    "nazwa_w_naglowku": (re.search(r"<h1>(.*?)</h1>", strona) or [None, "?"])[1],
+    "nazwa_w_tytule": (re.search(r"<title>(.*?) ·", strona) or [None, "?"])[1],
+    "rdzen_w_tresci": "astrololo" in strona.lower(),
+    "dokumentacja": {a: c.get(a, headers=H).status_code
+                     for a in ("/docs", "/openapi.json", "/redoc")},
+    "logowanie_dziala": bool(security.verify("klient", "tajne")),
+    "zle_haslo_odmowa": security.verify("klient", "inne") is None,
+}))
+'''
+
+
+@pytest.fixture(scope="module")
+def wynik(drzewo):
+    """Aplikacja uruchomiona w OSOBNYM PROCESIE.
+
+    Importy Pythona są zapamiętywane w procesie, więc sprawdzanie „produktu bez
+    modułu" tam, gdzie moduł już się zaimportował, dałoby wynik fałszywie
+    pozytywny."""
+    r = subprocess.run([sys.executable, "-c", SONDA], cwd=drzewo, capture_output=True,
+                       text=True, env={"PYTHONPATH": str(drzewo), "PATH": "/usr/bin:/bin"})
+    linia = next((l for l in r.stdout.splitlines() if l.startswith("WYNIK:")), None)
+    assert linia, f"sonda nie wystartowała:\n{r.stdout[-2000:]}\n{r.stderr[-2000:]}"
+    return json.loads(linia[len("WYNIK:"):])

services/astroklient/tests/test_slownik_zakazany.py

@@ -0,0 +1,137 @@
+"""Po czym astroklienta NIE MA — ani w odpowiedzi, ani w kodzie w obrazie.
+
+Ta usługa dzieli kod z pełną aplikacją, więc granica między produktami nie jest
+oczywista z samego patrzenia: przebiega przez listę importów w `main.py` i przez
+`usun.txt`. Ten test sprawdza jej SKUTEK na złożonym drzewie — bo tylko skutek
+trafia do obrazu, który komuś się oddaje.
+
+„Bez śladu" znaczy tu również bez zaprzeczeń. Zdanie „nie ma tu generowania
+tekstu" mówi wprost, że coś takiego istnieje, więc jest takim samym śladem jak
+przycisk. Pierwsza wersja tego testu wyłapała trzy moje własne docstringi
+wyliczające nieobecne funkcje.
+"""
+from __future__ import annotations
+
+import pathlib
+import re
+
+import pytest
+
+# Funkcje, których ten produkt nie ma — ani ich słownictwo.
+GENEROWANIE = ["prompt", "LLM", "model językow", "generowanie tekstu", "sztuczn",
+               "anthropic", "openai", "gpt", "claude", "horoscope",
+               "x-ai.css", "models.js", "progress.js", "natal.js", "predictions.js"]
+NIEOBECNE_EKRANY = ["Skompiluj", "Ustawienia", "Konta i uprawnien", "Eksport plików"]
+MECHANIZMY = ["administrator", "kwarantann", "walidacj", "reguły przyjmowania"]
+SLOWA = GENEROWANIE + NIEOBECNE_EKRANY + MECHANIZMY
+WZORCE = [(r"(?<![\w-])AI(?![\w-])", "skrót nazwy funkcji")]
+
+
+def _pliki(drzewo: pathlib.Path):
+    for f in sorted((drzewo / "app").rglob("*")):
+        if f.is_file() and f.suffix != ".pyc" and "__pycache__" not in str(f):
+            yield f
+
+
+def test_the_shipped_tree_carries_no_trace(drzewo):
+    grzechy = []
+    for f in _pliki(drzewo):
+        try:
+            tresc = f.read_text(encoding="utf-8")
+        except UnicodeDecodeError:
+            continue
+        gdzie = f.relative_to(drzewo)
+        for slowo in SLOWA:
+            if re.search(rf"(?i)(?<![\w-]){re.escape(slowo)}", tresc):
+                grzechy.append(f"{gdzie}: „{slowo}”")
+        for wzor, powod in WZORCE:
+            m = re.search(wzor, tresc)
+            if m:
+                grzechy.append(f"{gdzie}: „{m.group(0)}” — {powod}")
+    assert not grzechy, (
+        "\nW drzewie astroklienta padły słowa o funkcjach, których nie ma. "
+        "`grep` po kontenerze ma nic nie znaleźć:\n  " + "\n  ".join(grzechy))
+
+
+def test_the_check_would_notice_if_something_slipped_in(drzewo, tmp_path):
+    """Kontrola negatywna: zapora ma coś łapać.
+
+    Bez niej test wyżej przechodziłby także wtedy, gdyby lista słów była pusta
+    albo gdyby przeszukiwanie trafiało w niewłaściwy katalog."""
+    podrzucony = drzewo / "app" / "podrzucony.py"
+    podrzucony.write_text("# generowanie tekstu przez model\n", encoding="utf-8")
+    try:
+        with pytest.raises(AssertionError):
+            test_the_shipped_tree_carries_no_trace(drzewo)
+    finally:
+        podrzucony.unlink()
+
+
+def test_the_removal_list_matches_what_is_actually_composed(drzewo):
+    """usun.txt i main.py muszą mówić to samo.
+
+    Rozjazd między nimi znaczy albo martwy kod w obrazie (moduł usunięty
+    z importów, ale nie z listy), albo błąd dopiero przy uruchomieniu (plik
+    usunięty, a wciąż importowany). Jedno i drugie wychodzi za późno.
+    """
+    main = (drzewo / "app" / "main.py").read_text(encoding="utf-8")
+    zaimportowane = set(re.findall(r"^\s{4}(\w+),$", main, re.M))
+    obecne = {f.stem for f in (drzewo / "app" / "ekrany").glob("*.py")
+              if f.stem != "__init__"}
+    assert zaimportowane == obecne, (
+        f"ekrany w drzewie: {sorted(obecne)}\n"
+        f"ekrany importowane: {sorted(zaimportowane)}")
+
+
+def test_no_optional_module_survived(drzewo):
+    """Katalogu modułów opcjonalnych nie ma wcale — most odkrywa wtedy zero."""
+    assert not (drzewo / "app" / "moduly").exists()
+
+
+# ── nazwa produktu, z którego ten produkt powstał ─────────────────────────
+# Osobno od listy wyżej, bo granica przebiega gdzie indziej: „astrololo" wolno
+# występować w identyfikatorach WEWNĘTRZNYCH (nazwy loggerów, materiał do
+# wyprowadzania kluczy, nagłówki między warstwami), a nie wolno w niczym, co
+# dociera do przeglądarki. Zakaz na wszystko byłby albo obejściem przez zmianę
+# nazw kluczy kryptograficznych, albo martwą regułą wyłączaną przy pierwszej
+# okazji.
+NAZWA_RDZENIA = "astrololo"
+WIDOCZNE_DLA_KLIENTA = ("templates", "static")
+
+
+def test_the_parent_product_is_not_named_in_anything_the_browser_receives(drzewo):
+    """Szablony i zasoby są WSPÓLNE z pełną aplikacją, więc jej nazwa jechała
+    z nimi do tego obrazu — i astroklient przedstawiał się jako astrololo.
+
+    To jest najpoważniejszy z możliwych śladów: mówi klientowi wprost, że trzyma
+    okrojoną wersję czegoś większego, i podaje frazę, po której da się wyszukać,
+    czego mu nie dano."""
+    grzechy = []
+    for katalog in WIDOCZNE_DLA_KLIENTA:
+        for f in sorted((drzewo / "app" / katalog).rglob("*")):
+            if not f.is_file() or "__pycache__" in str(f):
+                continue
+            try:
+                tresc = f.read_text(encoding="utf-8")
+            except UnicodeDecodeError:
+                continue
+            if NAZWA_RDZENIA in tresc.lower():
+                grzechy.append(str(f.relative_to(drzewo)))
+    assert not grzechy, (
+        f"\nNazwa „{NAZWA_RDZENIA}” pada w plikach, które dostaje "
+        f"przeglądarka:\n  " + "\n  ".join(grzechy))
+
+
+def test_the_rendered_pages_carry_this_products_own_name(wynik):
+    """Sprawdzane na ODPOWIEDZI, nie na szablonie: liczy się to, co dociera do
+    człowieka, a nie to, co jest w pliku przed złożeniem."""
+    assert wynik["nazwa_w_naglowku"] == "astroklient"
+    assert wynik["nazwa_w_tytule"] == "astroklient"
+    assert not wynik["rdzen_w_tresci"], (
+        "nazwa pełnej aplikacji pada w treści strony oddawanej klientowi")
+
+
+def test_the_api_documentation_is_not_reachable(wynik):
+    """Tytuł aplikacji FastAPI wciąż niesie nazwę rdzenia, więc dokumentacja
+    OpenAPI byłaby wyciekiem tylnymi drzwiami — nawet gdy szablony są czyste."""
+    assert all(k == 404 for k in wynik["dokumentacja"].values()), wynik["dokumentacja"]

services/astroklient/tests/test_zlozenie.py

@@ -0,0 +1,46 @@
+"""Astroklient jest produktem, a nie pełną aplikacją z wyłączonymi kawałkami.
+
+Sprawdzamy trzy rzeczy, i wszystkie na ZŁOŻONYM drzewie, nie na kodzie w repo:
+czego w nim nie ma, że to, co zostało, działa, i że nie zostało po niczym słowo.
+"""
+from __future__ import annotations
+
+def test_the_build_starts_at_all(wynik):
+    assert wynik["dziala"]["/"] == 200
+
+
+def test_every_astrological_screen_works(wynik):
+    assert all(k == 200 for k in wynik["dziala"].values()), wynik["dziala"]
+
+
+def test_what_it_lacks_does_not_exist_rather_than_being_refused(wynik):
+    """404, nie 403 i nie 500. Odmowa z powodem jest informacją, że coś tam jest."""
+    assert all(k == 404 for k in wynik["nie_ma"].values()), wynik["nie_ma"]
+
+
+def test_the_catalogue_describes_this_product(wynik):
+    assert set(wynik["ekrany"]) == {"Horoskop", "Interpretacje", "Kalendarz",
+                                    "Synastria", "Sygnifikatory", "Pliki"}
+
+
+def test_no_account_can_hold_a_permission_this_product_does_not_have(wynik):
+    """Uprawnienia liczą się z KATALOGU, więc opisują ten obraz. Gdyby była tu
+    lista wpisana ręcznie, zostałaby po usuniętych funkcjach."""
+    assert "ai" not in wynik["uprawnienia"]
+    assert "export" not in wynik["uprawnienia"]
+    assert "admin" not in wynik["uprawnienia"]
+    assert "chart" in wynik["uprawnienia"] and "significators" in wynik["uprawnienia"]
+
+
+def test_navigation_has_no_dead_links(wynik):
+    assert wynik["nawigacja"] == len(wynik["ekrany"])
+
+
+def test_login_still_tells_right_password_from_wrong(wynik):
+    assert wynik["logowanie_dziala"] and wynik["zle_haslo_odmowa"]
+
+
+def test_the_pool_comes_from_the_session_not_from_the_form(wynik):
+    """Pula jedzie z zalogowanego konta. Gdyby brała się z żądania, wystarczyłoby
+    podstawić cudzy login, żeby czytać cudze pliki — sonda właśnie to próbuje."""
+    assert wynik["pula"] == "klient"

services/astroklient/usun.txt

@@ -0,0 +1,16 @@
+moduly
+ekrany/skompiluj.py
+ekrany/ustawienia.py
+ekrany/konta.py
+ekrany/pliki.py
+accounts.py
+files_state.py
+templates/compile.html
+templates/settings.html
+templates/accounts.html
+templates/files.html
+static/s-compile.css
+static/s-settings.css
+static/s-accounts.css
+static/s-files.css
+static/compile.js

services/logic/app/main.py

@@ -599,6 +599,10 @@ class TimelineRequest(BaseModel):
     to_date: str
     techniques: list[str] | None = None   # profection | solar_return | solar_arc
     interpret: bool = False               # dopnij interpretacje z bazy (1B->2B)
+    # Pula konta (PRE-29) — puste = cały udział. Warstwa logiczna niczego tu nie
+    # rozstrzyga, tylko przenosi: kto do jakiej puli ma prawo, wie warstwa
+    # prezentacji, bo to ona zna konta.
+    tenant: str = ""
 
 
 @app.post("/chart/timeline")

services/logic/app/models.py

@@ -8,6 +8,10 @@ from pydantic import BaseModel, Field
 
 class QueryRequest(BaseModel):
     """To, co przychodzi z formularza (przez warstwę prezentacji)."""
+    # Pula konta (PRE-29) — puste = cały udział. Warstwa logiczna niczego tu nie
+    # rozstrzyga, tylko przenosi: kto do jakiej puli ma prawo, wie warstwa
+    # prezentacji, bo to ona zna konta.
+    tenant: str = ""
 
     query: str = Field(..., min_length=1, description="Szukana fraza.")
     field: str = Field("name", description="Po którym polu szukać.")

services/logic/app/service.py

@@ -14,6 +14,7 @@ from app.models import QueryRequest, QueryResponse
 
 class QueryService:
     def __init__(self, data_client: DataClient | None = None) -> None:
+        self._wstrzykniety = data_client is not None
         self.data = data_client or DataClient()
 
     def handle(self, req: QueryRequest) -> QueryResponse:
@@ -21,8 +22,11 @@ class QueryService:
         value = req.query.strip()
         key = req.field.strip().lower()
 
-        # 2) zapytanie w dół do warstwy bazodanowej
-        raw = self.data.search(key=key, value=value, exact=req.exact, limit=req.limit)
+        # 2) zapytanie w dół do warstwy bazodanowej — do PULI KONTA, jeśli podano.
+        # Klient budowany na żądanie, bo pula wynika z tego, kto pyta, a nie ze
+        # stanu procesu. Wstrzyknięty klient (testy) ma pierwszeństwo.
+        dane = self.data if (self._wstrzykniety or not req.tenant) else DataClient(tenant=req.tenant)
+        raw = dane.search(key=key, value=value, exact=req.exact, limit=req.limit)
 
         # 3) opracowanie wyników w górę (tu można liczyć/wzbogacać/sortować)
         results = raw.get("rows", [])

services/presentation/Dockerfile

@@ -4,7 +4,11 @@ WORKDIR /app
 COPY requirements.txt .
 RUN pip install --no-cache-dir -r requirements.txt
 
-COPY . .
+# Do obrazu wchodzi WYŁĄCZNIE kod aplikacji. `COPY . .` wnosiło też testy,
+# README i skrypty pomocnicze — a plik testowy nazywa funkcje wprost, więc
+# w obrazie zbudowanym bez danego modułu byłby dokładnie tym śladem, którego
+# wydzielenie ma się pozbyć. Przy okazji obraz jest mniejszy.
+COPY app ./app
 
 EXPOSE 8000
 CMD ["uvicorn", "app.main:app", "--host", "0.0.0.0", "--port", "8000"]

services/presentation/app/clients/logic_client.py

@@ -40,6 +40,29 @@ class LogicClient:
                                          payload=payload, headers=_auth_headers(),
                                          link=_link())
 
+    # ── transport dla modułów opcjonalnych ─────────────────────────────────
+    # Moduł nie może dopisywać sobie metod do tej klasy: jego nazwy siedziałyby
+    # wtedy w pliku, który jedzie do KAŻDEGO obrazu. Dostaje więc samą drogę
+    # w dół, a co nią wysyła, jest jego sprawą. Szyfrowanie łącza i token
+    # międzywarstwowy obowiązują tak samo — to nie jest obejście ochrony.
+    def wywolaj(self, sciezka: str, payload: dict[str, Any], timeout: float) -> dict[str, Any]:
+        return self._post(sciezka, payload, timeout)
+
+    def pobierz(self, sciezka: str, timeout: float | None = None) -> dict[str, Any]:
+        with httpx.Client(timeout=timeout or settings.http_timeout) as client:
+            return link_crypto.call_json(client, "GET", f"{self.base_url}{sciezka}",
+                                         headers=_auth_headers(), link=_link())
+
+    def strumien(self, sciezka: str, payload: dict[str, Any]):
+        """Strumień NDJSON w dół — przekazywany dalej ramka po ramce.
+
+        Idzie przez szyfrowane łącze jak reszta ruchu (PRE-16): bez tego przy
+        włączonym LINK_ENCRYPTION_REQUIRED serwer odrzuciłby żądanie."""
+        with httpx.Client(timeout=httpx.Timeout(None, connect=15.0)) as client:
+            yield from link_crypto.stream_lines(
+                client, f"{self.base_url}{sciezka}",
+                payload=payload, headers=_auth_headers(), link=_link())
+
     def query(self, query: str, field: str, exact: bool, limit: int) -> dict[str, Any]:
         payload = {"query": query, "field": field, "exact": exact, "limit": limit}
         return self._post("/api/query", payload, settings.http_timeout)
@@ -97,61 +120,6 @@ class LogicClient:
         payload = {"when_utc": when_utc_iso, "lat": lat, "lon": lon, "limit": limit, "group": group}
         return self._post("/chart/report", payload, max(settings.http_timeout, 30.0))
 
-    def prompt(
-        self, profile: str, when_utc_iso: str, lat: float, lon: float,
-        budget: str = "medium", from_date: str | None = None, to_date: str | None = None,
-        provider: str | None = None, model: str | None = None,
-    ) -> dict[str, Any]:
-        """Gotowy prompt do LLM z wyliczeń (LOG-29/30) — woła logic /chart/prompt.
-
-        `provider` jest potrzebny dla budżetu „maksymalny kontekst modelu": limit
-        znaków zależy wtedy od okna kontekstu konkretnego modelu."""
-        payload: dict[str, Any] = {
-            "profile": profile, "when_utc": when_utc_iso,
-            "lat": lat, "lon": lon, "budget": budget, "provider": provider,
-            "model": model,
-        }
-        if from_date and to_date:
-            payload["from_date"], payload["to_date"] = from_date, to_date
-        return self._post("/chart/prompt", payload, max(settings.http_timeout, 60.0))
-
-    def horoscope(
-        self, profile: str, when_utc_iso: str, lat: float, lon: float,
-        budget: str = "medium", provider: str | None = None, model: str | None = None,
-        from_date: str | None = None, to_date: str | None = None,
-    ) -> dict[str, Any]:
-        """Napisany horoskop (LOG-31) — woła logic /chart/horoscope.
-
-        Generowanie tekstu trwa (zwłaszcza na modelu lokalnym), stąd długi timeout.
-        """
-        payload: dict[str, Any] = {
-            "profile": profile, "when_utc": when_utc_iso,
-            "lat": lat, "lon": lon, "budget": budget,
-        }
-        if provider:
-            payload["provider"] = provider
-        if model:
-            payload["model"] = model
-        if from_date and to_date:
-            payload["from_date"], payload["to_date"] = from_date, to_date
-        return self._post("/chart/horoscope", payload, max(settings.http_timeout, 300.0))
-
-    def horoscope_stream(self, payload: dict[str, Any]):
-        """Strumień postępu pisania horoskopu (NDJSON) — przekazywany do przeglądarki.
-
-        Timeout jest długi, bo generowanie trwa; strumień i tak niesie heartbeat,
-        więc cisza na łączu nie zostanie wzięta za zerwanie.
-
-        Idzie przez szyfrowane łącze jak reszta ruchu w dół (PRE-16). Bez tego przy
-        włączonym `LINK_ENCRYPTION_REQUIRED` serwer odrzuciłby nieszyfrowane żądanie
-        i okno postępu przestałoby działać. `stream_lines` pieczętuje żądanie i
-        odszyfrowuje odpowiedź ramka po ramce, zachowując dostarczanie na żywo.
-        """
-        with httpx.Client(timeout=httpx.Timeout(None, connect=15.0)) as client:
-            yield from link_crypto.stream_lines(
-                client, f"{self.base_url}/chart/horoscope/stream",
-                payload=payload, headers=_auth_headers(), link=_link())
-
     def bases(self) -> dict[str, Any]:
         """Bazy dostępne na udziale + metaopis i stan włączenia (DAN-15/PRE-09)."""
         with httpx.Client(timeout=settings.http_timeout) as client:
@@ -185,12 +153,6 @@ class LogicClient:
             return link_crypto.call_json(client, "POST", f"{self.base_url}{path}",
                                          payload=payload, headers=_auth_headers(), link=_link())
 
-    def llm_models(self) -> dict[str, Any]:
-        """Katalog modeli per dostawca (podpowiedzi do pola wyboru w UI)."""
-        with httpx.Client(timeout=settings.http_timeout) as client:
-            return link_crypto.call_json(client, "GET", f"{self.base_url}/llm/models",
-                                         headers=_auth_headers(), link=_link())
-
     def timeline(
         self, when_utc_iso: str, lat: float, lon: float,
         from_date: str, to_date: str, interpret: bool = True,

services/presentation/app/ekrany/__init__.py

@@ -0,0 +1,10 @@
+"""Ekrany aplikacji — jeden moduł na ekran.
+
+Ekran to trasy plus szablon. Import modułu rejestruje jego trasy (dekoratory
+`@app.get`/`@app.post` wykonują się przy imporcie), więc o tym, CO aplikacja
+umie, decyduje lista importów w `main.py` — a nie warunki rozsiane po kodzie.
+
+Dzięki temu produkt buduje się przez ZŁOŻENIE: inny zestaw importów i inny
+zestaw plików w obrazie to inny program, a nie ten sam program z wyłączonymi
+kawałkami. Ekranu, którego moduł nie wszedł do obrazu, nie ma jak włączyć.
+"""

services/presentation/app/ekrany/horoskop.py

@@ -0,0 +1,118 @@
+"""Horoskop: pozycje, osie, domy, aspekty i kosmogram (strona główna)."""
+from __future__ import annotations
+
+from fastapi import Form, Request
+from fastapi.responses import HTMLResponse, RedirectResponse
+import httpx
+
+from app.features import Feature
+from app.podstawa import (features, 
+    app,
+    templates,
+    logic,
+    chartwheel_mod,
+    DEFAULT_LOCATION_LABEL,
+    default_form,
+    rozszerzenia,
+    _perms,
+    _limit_options,
+    _landing,
+    _build_utc,
+    _logic_error,
+)
+
+# ---------------- Horoskop: pozycje (strona główna) ----------------
+@app.get("/", response_class=HTMLResponse)
+def chart_form(request: Request):
+    # Korzeń jest dostępny dla każdego zalogowanego, ale ekran „Horoskop" już nie.
+    # Bez tego konto bez uprawnienia do horoskopu dostawałoby 404 pod adresem
+    # głównym — czyli wyglądałoby to na zepsuty program, a nie na węższy zestaw.
+    if "chart" not in _perms(request):
+        target = _landing(request)
+        if target:
+            return RedirectResponse(target, status_code=303)
+        # Ta sama odpowiedź co bramka dla trasy bez uprawnienia. Poprzednia treść
+        # mówiła o „przypisanych funkcjach" i o „osobie, która zakładała konto",
+        # czyli wprost: funkcje są komuś przydzielane, jest ktoś, kto to robi,
+        # a twoje konto zostało okrojone.
+        return HTMLResponse("<h1>404 — nie znaleziono</h1>", status_code=404)
+    return templates.TemplateResponse(
+        request, "chart.html",
+        {"result": None, "form": default_form(), "location_label": DEFAULT_LOCATION_LABEL,
+         **rozszerzenia.kontekst_szablonu(request)},
+    )
+
+
+@app.post("/", response_class=HTMLResponse)
+def chart_compute(
+    request: Request,
+    person: str = Form(""),          # imie i nazwisko — do naglowka raportu (PRE-21/24)
+    date: str = Form(...),
+    time: str = Form(...),
+    tz_offset: float = Form(0.0),
+    lat: float = Form(0.0),
+    lon: float = Form(0.0),
+    house_system: str = Form("whole_sign"),
+    house_systems: list[str] = Form([]),      # PRE-05: dodatkowe systemy do porównania
+    aspect_orb: float = Form(8.0),            # PRE-06: konfigurowalny orb aspektów
+    aspect_luminary_bonus: float = Form(2.0),
+    aspect_minor: bool = Form(False),
+    stations: bool = Form(False),
+    zodiac: str = Form("tropical"),
+    tables: bool = Form(False),
+    wheel_orientation: str = Form(chartwheel_mod.ASC_LEFT),
+):
+    form = {"person": person, "date": date, "time": time, "tz_offset": tz_offset,
+            "lat": lat, "lon": lon, "house_system": house_system,
+            "house_systems": house_systems, "aspect_orb": aspect_orb,
+            "aspect_luminary_bonus": aspect_luminary_bonus, "aspect_minor": aspect_minor,
+            "stations": stations, "zodiac": zodiac, "tables": tables,
+            "wheel_orientation": wheel_orientation}
+    form = _limit_options(request, form)
+    ctx: dict = {"form": form, "result": None, "error": None, "moment": None}
+    try:
+        iso_utc, label = _build_utc(date, time, tz_offset)
+        ctx["moment"] = label
+        ctx["result"] = logic.positions(
+            when_utc_iso=iso_utc, lat=lat, lon=lon,
+            house_system=form["house_system"], house_systems=form["house_systems"],
+            aspect_orb=aspect_orb, aspect_luminary_bonus=aspect_luminary_bonus,
+            aspect_minor=form["aspect_minor"],
+            stations=form["stations"], zodiac=form["zodiac"], tables=form["tables"],
+        )
+        from app import chartwheel                    # kosmogram (PRE-12), SVG po stronie serwera
+        ctx["wheel_svg"] = chartwheel.render(ctx["result"],
+                                            orientation=form["wheel_orientation"])
+        # Rysunki dodatkowe NIE POWSTAJĄ bez uprawnienia — nie chodzi o ukrycie
+        # ich w szablonie, tylko o to, żeby nie było ich nawet w źródle strony.
+        if "extra_charts" in _perms(request):
+            ctx["aspectarian_svg"] = chartwheel.render_aspectarian(ctx["result"])  # PRE-18
+            ctx["declination_svg"] = chartwheel.render_declination(ctx["result"])  # LOG-07
+            ctx["antiscia_svg"] = chartwheel.render_antiscia(ctx["result"])        # LOG-07
+    except (httpx.HTTPError,) as e:
+        ctx["error"] = _logic_error(e)
+    except ValueError as e:
+        ctx["error"] = f"Niepoprawne dane wejściowe: {e}"
+    return templates.TemplateResponse(request, "chart.html", ctx)
+
+# ── zgłoszenie do katalogu ─────────────────────────────────────────────────
+# Ekran zgłasza siebie, swoje trasy i swoje zasoby. Wszystko o tym ekranie jest
+# w tym pliku — więc obraz bez tego pliku nie wie o nim NIC.
+features.zarejestruj(
+    ekran=Feature("chart", "Horoskop", "Pozycje, osie, domy, aspekty, kosmogram.",
+                  "Ekrany", "/", kolejnosc=10),
+    trasy={("GET", "/"): None,        # korzeń przekierowuje na pierwszy dostępny ekran
+           ("POST", "/"): "chart"},
+    zasoby={"s-chart.css": "chart"},
+)
+features.zarejestruj(rozszerzenie=Feature(
+    "houses_compare", "Porównanie systemów domów",
+    "Wybór systemu innego niż domyślny i zestawienie kilku obok siebie.",
+    "Rozszerzenia", kolejnosc=10))
+features.zarejestruj(rozszerzenie=Feature(
+    "extra_charts", "Wykresy dodatkowe",
+    "Aspektarian, wykres deklinacji, oś antyscji.", "Rozszerzenia", kolejnosc=20))
+features.zarejestruj(rozszerzenie=Feature(
+    "advanced_calc", "Obliczenia zaawansowane",
+    "Stacje planet, tabele żywiołów i faz, aspekty poboczne, zodiaki syderyczne.",
+    "Rozszerzenia", kolejnosc=30))

services/presentation/app/ekrany/interpretacje.py

@@ -0,0 +1,81 @@
+"""Interpretacje: wynik obliczeń szukany w bazach."""
+from __future__ import annotations
+
+from fastapi import Depends, Form, Request
+from fastapi.responses import HTMLResponse, Response
+import httpx
+
+from app.features import Feature
+from app.podstawa import (features, 
+    app,
+    templates,
+    logic,
+    security,
+    DEFAULT_LOCATION_LABEL,
+    default_form,
+    rozszerzenia,
+    _build_utc,
+    _dozwolona_akcja,
+    _report_records,
+    _logic_error,
+)
+
+# ---------------- Interpretacje (wynik obliczeń szukany w bazie) ----------------
+@app.get("/interpret", response_class=HTMLResponse)
+def interpret_form(request: Request):
+    return templates.TemplateResponse(
+        request, "interpret.html",
+        {"result": None, "form": default_form(), "location_label": DEFAULT_LOCATION_LABEL,
+         **rozszerzenia.kontekst_szablonu(request)},
+    )
+
+
+@app.post("/interpret", response_class=HTMLResponse)
+def interpret_run(
+    request: Request,
+    person: str = Form(""),          # imie i nazwisko — do naglowka raportu (PRE-21/24)
+    date: str = Form(...),
+    time: str = Form(...),
+    tz_offset: float = Form(0.0),
+    lat: float = Form(0.0),
+    lon: float = Form(0.0),
+    group: bool = Form(False),
+    action: str = Form("report"),
+    # Pola wnoszone przez moduły opcjonalne. FastAPI czyta pola z sygnatury, a ta
+    # nie może ich wymieniać — w obrazie bez modułu byłyby nazwą nieistniejącej
+    # funkcji wpisaną w kod. Zależność przenosi deklarację do modułu.
+    dodatki: dict = Depends(rozszerzenia.pola_formularza()),
+):
+    form = {"person": person, "date": date, "time": time, "tz_offset": tz_offset,
+            "lat": lat, "lon": lon, "group": group, **dodatki}
+    action = _dozwolona_akcja(request, action, "report")
+    ctx: dict = {"form": form, "result": None, "error": None, "moment": None,
+                 **rozszerzenia.kontekst_szablonu(request)}
+    try:
+        iso_utc, label = _build_utc(date, time, tz_offset)
+        ctx["moment"] = label
+        # Akcja może należeć do modułu opcjonalnego. `None` znaczy „nie jego",
+        # więc ekran robi to, co robi normalnie. Moduł może oddać słownik do
+        # kontekstu albo gotową odpowiedź — na przykład plik do pobrania.
+        wynik = rozszerzenia.obsluz(action, profil="natal", iso_utc=iso_utc,
+                                    lat=lat, lon=lon, dodatki=dodatki,
+                                    request=request, group=group)
+        if isinstance(wynik, Response):
+            return wynik
+        if wynik is not None:
+            ctx["wynik_dodatku"] = wynik
+        else:
+            ctx["result"] = logic.report(when_utc_iso=iso_utc, lat=lat, lon=lon, group=group)
+            security.audit_records(request, _report_records(ctx["result"]))
+    except httpx.HTTPError as e:
+        ctx["error"] = _logic_error(e)
+    except ValueError as e:
+        ctx["error"] = f"Niepoprawne dane wejściowe: {e}"
+    return templates.TemplateResponse(request, "interpret.html", ctx)
+
+features.zarejestruj(
+    ekran=Feature("interpret", "Interpretacje", "Interpretacja natalna z baz.",
+                  "Ekrany", "/interpret", kolejnosc=20),
+    trasy={("GET", "/interpret"): "interpret", ("POST", "/interpret"): "interpret"},
+    zasoby={"s-interpret.css": "interpret"},
+)

services/presentation/app/ekrany/kalendarz.py

@@ -0,0 +1,78 @@
+"""Kalendarz: oś czasu z technik wraz z interpretacjami."""
+from __future__ import annotations
+
+from fastapi import Depends, Form, Request
+from fastapi.responses import HTMLResponse
+import httpx
+
+from app.features import Feature
+from app.podstawa import (features, 
+    app,
+    templates,
+    logic,
+    DEFAULT_LOCATION_LABEL,
+    default_form,
+    rozszerzenia,
+    _build_utc,
+    _dozwolona_akcja,
+    _logic_error,
+)
+
+# ---------------- Kalendarz (oś czasu z technik + interpretacje) ----------------
+@app.get("/timeline", response_class=HTMLResponse)
+def timeline_form(request: Request):
+    return templates.TemplateResponse(
+        request, "timeline.html",
+        {"result": None, "form": default_form(), "location_label": DEFAULT_LOCATION_LABEL,
+         **rozszerzenia.kontekst_szablonu(request)},
+    )
+
+
+@app.post("/timeline", response_class=HTMLResponse)
+def timeline_run(
+    request: Request,
+    person: str = Form(""),          # imie i nazwisko — do naglowka raportu (PRE-21/24)
+    date: str = Form(...),
+    time: str = Form(...),
+    tz_offset: float = Form(0.0),
+    lat: float = Form(0.0),
+    lon: float = Form(0.0),
+    from_date: str = Form(...),
+    to_date: str = Form(...),
+    action: str = Form("timeline"),
+    # Pola wnoszone przez moduły opcjonalne. FastAPI czyta pola z sygnatury, a ta
+    # nie może ich wymieniać — w obrazie bez modułu byłyby nazwą nieistniejącej
+    # funkcji wpisaną w kod. Zależność przenosi deklarację do modułu.
+    dodatki: dict = Depends(rozszerzenia.pola_formularza()),
+):
+    form = {"person": person, "date": date, "time": time, "tz_offset": tz_offset,
+            "lat": lat, "lon": lon, "from_date": from_date, "to_date": to_date,
+            **dodatki}
+    action = _dozwolona_akcja(request, action, "timeline")
+    ctx: dict = {"form": form, "result": None, "error": None, "moment": None,
+                 **rozszerzenia.kontekst_szablonu(request)}
+    try:
+        iso_utc, label = _build_utc(date, time, tz_offset)
+        ctx["moment"] = label
+        wynik = rozszerzenia.obsluz(action, profil="period", iso_utc=iso_utc,
+                                    lat=lat, lon=lon, dodatki=dodatki,
+                                    od=from_date, do=to_date)
+        if wynik is not None:
+            ctx["wynik_dodatku"] = wynik
+        else:
+            ctx["result"] = logic.timeline(
+                when_utc_iso=iso_utc, lat=lat, lon=lon,
+                from_date=from_date, to_date=to_date, interpret=True,
+            )
+    except httpx.HTTPError as e:
+        ctx["error"] = _logic_error(e)
+    except ValueError as e:
+        ctx["error"] = f"Niepoprawne dane wejściowe: {e}"
+    return templates.TemplateResponse(request, "timeline.html", ctx)
+
+features.zarejestruj(
+    ekran=Feature("timeline", "Kalendarz", "Predykcje na wybrany zakres dat.",
+                  "Ekrany", "/timeline", kolejnosc=30),
+    trasy={("GET", "/timeline"): "timeline", ("POST", "/timeline"): "timeline"},
+    zasoby={"s-timeline.css": "timeline"},
+)

services/presentation/app/ekrany/konta.py

@@ -0,0 +1,105 @@
+"""Konta i uprawnienia (PRE-27) — ekran wyłącznie administracyjny."""
+from __future__ import annotations
+
+from fastapi import Form, Request
+from fastapi.responses import HTMLResponse, RedirectResponse
+
+from app import accounts as accounts_store
+from app.features import Feature
+from app.podstawa import (app, templates, security, features)
+
+# ---------------- Konta i uprawnienia (PRE-27) ----------------
+# Ochrona tych tras siedzi w features.ROUTES, nie w dekoratorze — jedna mapa
+# dla całej aplikacji, sprawdzana testem, który przechodzi po WSZYSTKICH trasach.
+
+def _accounts_context(request: Request, error: str = "", done: str = "") -> dict:
+    # Problem z magazynem NIE MOŻE dawać gołego 500: to jedyny ekran, z którego
+    # administrator może go naprawić, więc musi na nim przeczytać, co i gdzie
+    # jest nie tak.
+    try:
+        users = accounts_store.all_users()
+    except accounts_store.AccountsUnavailable as e:
+        users, error = {}, str(e)
+    return {
+        "users": users,
+        "catalog": features.ALL,
+        "screens": features.SCREENS,
+        # Rejestr zawiera już wszystko, co ten obraz umie — łącznie z tym, co
+        # wniosły moduły opcjonalne. Administrator ma nadawać uprawnienia do
+        # funkcji, które REALNIE są, a nie do listy wpisanej kiedyś na sztywno.
+        "extras": features.EXTRAS,
+        "admin_login": security.app_user(),
+        "store_path": accounts_store.store_path(),
+        "error": error, "done": done,
+    }
+
+
+@app.get("/accounts", response_class=HTMLResponse)
+def accounts_view(request: Request, error: str = "", done: str = ""):
+    return templates.TemplateResponse(request, "accounts.html",
+                                      _accounts_context(request, error, done))
+
+
+def _accounts_redirect(error: str = "", done: str = "") -> RedirectResponse:
+    """Po zapisie PRZEKIEROWANIE, nie render — odświeżenie strony nie może
+    powtórzyć zakładania ani kasowania konta."""
+    from urllib.parse import urlencode
+
+    q = urlencode({k: v for k, v in (("error", error), ("done", done)) if v})
+    return RedirectResponse(f"/accounts{'?' + q if q else ''}", status_code=303)
+
+
+@app.post("/accounts/create")
+def accounts_create(request: Request, login: str = Form(""), password: str = Form(""),
+                    note: str = Form(""), granted: list[str] = Form([])):
+    try:
+        accounts_store.create(login, password, granted, note)
+    except (ValueError, accounts_store.AccountsUnavailable) as e:
+        return _accounts_redirect(error=str(e))
+    return _accounts_redirect(done=f"Założono konto „{login.strip()}”.")
+
+
+@app.post("/accounts/update")
+def accounts_update(request: Request, login: str = Form(...), password: str = Form(""),
+                    note: str = Form(""), granted: list[str] = Form([])):
+    try:
+        accounts_store.update(login, granted=granted, password=password, note=note)
+    except (ValueError, accounts_store.AccountsUnavailable) as e:
+        return _accounts_redirect(error=str(e))
+    changed = "uprawnienia i hasło" if password.strip() else "uprawnienia"
+    return _accounts_redirect(done=f"Zapisano {changed} konta „{login}”.")
+
+
+@app.post("/accounts/sesje")
+def accounts_sesje(request: Request, login: str = Form(...)):
+    """Unieważnia WSZYSTKIE otwarte sesje konta, na każdym urządzeniu.
+
+    Zmiana hasła robi to samo przy okazji, więc ta operacja jest na wypadek
+    „wyrzuć zewsząd, ale hasło zostaw" — na przykład gdy ktoś zostawił zalogowany
+    komputer i nie chce wpisywać nowego hasła wszędzie."""
+    try:
+        accounts_store.bump_session(login)
+    except (ValueError, accounts_store.AccountsUnavailable) as e:
+        return _accounts_redirect(error=str(e))
+    return _accounts_redirect(done=f"Zamknięto wszystkie sesje konta „{login}”.")
+
+
+@app.post("/accounts/delete")
+def accounts_delete(request: Request, login: str = Form(...)):
+    try:
+        accounts_store.delete(login)
+    except (ValueError, accounts_store.AccountsUnavailable) as e:
+        return _accounts_redirect(error=str(e))
+    return _accounts_redirect(done=f"Skasowano konto „{login}”.")
+
+# Ekran wyłącznie administracyjny — nie ma pozycji w katalogu funkcji, bo ADMIN
+# nie jest uprawnieniem do nadania (patrz features.GRANTABLE).
+features.zarejestruj(
+    nawigacja=("accounts", "/accounts", "Konta", features.ADMIN),
+    trasy={("GET", "/accounts"): features.ADMIN,
+           ("POST", "/accounts/create"): features.ADMIN,
+           ("POST", "/accounts/update"): features.ADMIN,
+           ("POST", "/accounts/delete"): features.ADMIN,
+           ("POST", "/accounts/sesje"): features.ADMIN},
+    zasoby={"s-accounts.css": features.ADMIN},
+)

services/presentation/app/ekrany/logowanie.py

@@ -0,0 +1,79 @@
+"""Logowanie i wylogowanie (LOG-34)."""
+from __future__ import annotations
+
+from fastapi import Form, Request
+from fastapi.responses import HTMLResponse, RedirectResponse
+
+from app.features import Feature
+from app.podstawa import (features, app, templates, security, session)
+
+# ---------------- Logowanie i wylogowanie (LOG-34) ----------------
+# Zastępuje HTTP Basic, który nie miał wylogowania: przeglądarka zapamiętywała
+# hasło i dosyłała je sama, więc serwer nie miał czego zapomnieć. Teraz to serwer
+# decyduje, czy dana przeglądarka jest w środku — i może to cofnąć.
+
+def _bezpieczne_dokad(dokad: str) -> str:
+    """Adres powrotu po zalogowaniu, przepuszczony przez sito.
+
+    Bez tego `?dokad=https://obcy.pl` zamieniłby nasz ekran logowania w narzędzie
+    do przekierowywania ludzi gdzie indziej — klasyczna droga do wyłudzenia hasła,
+    bo odsyłacz prowadzi z zaufanego adresu. Wpuszczamy wyłącznie ścieżki
+    wewnętrzne: jeden ukośnik na początku i ani jednego znaku, który mógłby
+    zacząć adres obcego serwera."""
+    dokad = (dokad or "").strip()
+    if not dokad.startswith("/") or dokad.startswith("//") or "\\" in dokad:
+        return "/"
+    return dokad.split("?", 1)[0].split("#", 1)[0] or "/"
+
+
+@app.get("/logowanie", response_class=HTMLResponse)
+def logowanie_form(request: Request, dokad: str = "/", blad: str = ""):
+    # Zalogowanego nie ma po co pytać o hasło jeszcze raz.
+    if security.auth_enabled() and security.principal(request) is not None:
+        return RedirectResponse(_bezpieczne_dokad(dokad), status_code=303)
+    return templates.TemplateResponse(request, "logowanie.html",
+                                      {"dokad": _bezpieczne_dokad(dokad), "blad": blad})
+
+
+@app.post("/logowanie")
+def logowanie(request: Request, login: str = Form(""), haslo: str = Form(""),
+              dokad: str = Form("/")):
+    cel = _bezpieczne_dokad(dokad)
+    who = security.verify(login.strip(), haslo)
+    if who is None:
+        # JEDEN komunikat na złe hasło i nieznany login. Rozróżnienie mówiłoby,
+        # które konta istnieją — a to informacja warta czegoś dla zgadującego.
+        security.audit_login(request, login.strip(), udane=False)
+        return templates.TemplateResponse(
+            request, "logowanie.html",
+            {"dokad": cel, "blad": "Nieprawidłowy login lub hasło.", "login": login},
+            status_code=401)
+
+    security.audit_login(request, who.login, udane=True)
+    odpowiedz = RedirectResponse(cel, status_code=303)
+    odpowiedz.set_cookie(session.COOKIE, security.issue_session(who.login),
+                         max_age=session.max_age(),
+                         **session.cookie_params(secure=security.cookies_secure()))
+    return odpowiedz
+
+
+@app.post("/wyloguj")
+def wyloguj(request: Request):
+    """Kasuje ciasteczko sesji. To jest całe wylogowanie — natychmiastowe
+    i bez żadnego magazynu, bo przeglądarka nie ma już czego dosyłać.
+
+    POST, nie GET: pod adresem GET wystarczyłby obrazek na obcej stronie, żeby
+    wylogować kogoś bez jego wiedzy. Uciążliwość, nie włamanie — ale darmowa
+    do uniknięcia."""
+    security.audit_logout(request)
+    odpowiedz = RedirectResponse("/logowanie?wylogowano=1", status_code=303)
+    odpowiedz.delete_cookie(session.COOKIE, **session.cookie_params(
+        secure=security.cookies_secure()))
+    return odpowiedz
+
+# Wyjście musi być dostępne dla każdego zalogowanego, niezależnie od tego, co mu
+# przyznano — konto bez ani jednego ekranu też ma prawo wyjść.
+features.zarejestruj(
+    trasy={("GET", "/logowanie"): None, ("POST", "/logowanie"): None,
+           ("POST", "/wyloguj"): None},
+)

services/presentation/app/ekrany/lokalizacja.py

@@ -0,0 +1,58 @@
+"""Wyszukiwarka miejsca i strefa czasowa (proxy OSM/Nominatim)."""
+from __future__ import annotations
+
+from datetime import timezone
+from fastapi import HTTPException, Query
+import httpx
+
+from app.features import Feature
+from app.podstawa import (features, app, geocode)
+
+# ---------------- Geokoder (proxy OSM/Nominatim dla wyszukiwarki lokalizacji) ----------------
+@app.get("/geocode")
+def geocode_search(q: str = Query("", description="Nazwa / adres / POI do wyszukania")):
+    """Nazwa miejsca → kandydaci ze współrzędnymi (dla pola „Szukaj miejsca")."""
+    try:
+        return {"results": geocode.search(q)}
+    except httpx.HTTPError as e:
+        raise HTTPException(status_code=502, detail=f"Geokoder (OSM) niedostępny: {e}")
+
+
+@app.get("/reverse")
+def geocode_reverse(lat: float, lon: float):
+    """Punkt z mapy → nazwa miejsca (po przeciągnięciu pineski / kliknięciu)."""
+    try:
+        return geocode.reverse(lat, lon)
+    except httpx.HTTPError as e:
+        raise HTTPException(status_code=502, detail=f"Geokoder (OSM) niedostępny: {e}")
+
+
+@app.get("/timezone")
+def timezone_lookup(lat: float, lon: float, date: str = "", time: str = "12:00"):
+    """Współrzędne + data → strefa IANA i DST-świadomy offset GMT (PRE-03).
+
+    Liczone OFFLINE (tzfpy + zoneinfo), więc brak internetu nie przeszkadza. 404,
+    gdy strefy nie da się ustalić — front zostawia wtedy ręczny offset."""
+    from app import timezone as tzmod
+
+    res = tzmod.resolve(lat, lon, date, time)
+    if not res:
+        raise HTTPException(status_code=404, detail="Nie ustalono strefy dla tego punktu.")
+    return res
+
+# Wyszukiwarka miejsca siedzi na kilku ekranach naraz, więc jej zasoby otwiera
+# KTÓREKOLWIEK z nich — wymaganie wszystkich byłoby bez sensu.
+_LOKALIZACJA = frozenset({"chart", "interpret", "timeline"})
+_FORMULARZE = frozenset({"chart", "interpret", "timeline", "compile"})
+_KOLO = frozenset({"chart", "compile"})
+
+features.zarejestruj(
+    trasy={("GET", "/geocode"): None, ("GET", "/reverse"): None,
+           ("GET", "/timezone"): None},
+    zasoby={"geo.js": _LOKALIZACJA, "now.js": _LOKALIZACJA,
+            "vendor/leaflet/leaflet.js": _LOKALIZACJA,
+            "vendor/leaflet/leaflet.css": _LOKALIZACJA,
+            "formsync.js": _FORMULARZE,
+            "wheelzoom.js": _KOLO, "wheeltip.js": _KOLO,
+            "copy.js": frozenset({"interpret", "timeline"})},
+)

services/presentation/app/ekrany/pliki.py

@@ -0,0 +1,170 @@
+"""Pliki baz: wybór, wgrywanie, archiwizacja i reguły przyjmowania (DAN-27)."""
+from __future__ import annotations
+
+from fastapi import File, Form, Request, UploadFile
+from fastapi.responses import HTMLResponse, RedirectResponse
+import base64
+import httpx
+
+from app import files_state
+from app.features import Feature
+from app.podstawa import (app, templates, logic, features, _perms, _logic_error)
+
+# Etykiety stanów pliku dla szablonu. Rejestrowane TUTAJ, a nie w podstawie:
+# należą do tego ekranu, a produkt, który go nie ma, nie ma po co ich znać.
+templates.env.globals["STATUS_LABELS"] = files_state.LABELS
+
+
+# ---------------- Pliki baz (DAN-27) ----------------
+# Trzy poziomy dostępu, opisane w features.ROUTES:
+#   „files"        — widzi listę i decyduje, z czego program korzysta,
+#   „files_input"  — dokłada wgrywanie i ARCHIWIZACJĘ (plik zostaje zamrożony
+#                    ze znacznikiem czasu, znika tylko z użytku),
+#   administrator  — kasowanie, przywracanie z archiwum i REGUŁY WALIDACJI.
+#
+# Kwarantanna (plik wgrany, ale odrzucony przez walidację) jest odsiewana W WARSTWIE
+# DANYCH przy `for_admin=False`. Nie filtrujemy jej tutaj ani w szablonie: gdyby
+# takie pliki dochodziły do przeglądarki, wystarczyłby podgląd źródła, żeby poznać
+# reguły — a te ma znać wyłącznie administrator.
+
+def _files_context(request: Request, error: str = "", done: str = "") -> dict:
+    is_admin = features.ADMIN in _perms(request)
+    try:
+        data = logic.files_list(for_admin=is_admin)
+    except httpx.HTTPError as e:
+        return {"files": [], "rules": {}, "is_admin": is_admin,
+                "error": _logic_error(e), "done": ""}
+    return {"files": data.get("files") or [], "rules": data.get("rules") or {},
+            "is_admin": is_admin, "error": error, "done": done}
+
+
+@app.get("/files", response_class=HTMLResponse)
+def files_view(request: Request, error: str = "", done: str = ""):
+    return templates.TemplateResponse(request, "files.html",
+                                      _files_context(request, error, done))
+
+
+def _files_redirect(error: str = "", done: str = "") -> RedirectResponse:
+    from urllib.parse import urlencode
+
+    q = urlencode({k: v for k, v in (("error", error), ("done", done)) if v})
+    return RedirectResponse(f"/files{'?' + q if q else ''}", status_code=303)
+
+
+def _who(request: Request) -> str:
+    return getattr(request.state, "user", "") or "-"
+
+
+@app.post("/files/use")
+def files_use(request: Request, path: str = Form(...), use: str = Form("")):
+    """Włącza albo odstawia bazę. Włączenie przechodzi przez bramkę walidacji
+    w warstwie danych — odmowa wraca BEZ POWODU, bo powód zdradzałby reguły."""
+    want = files_state.ACTIVE if use.strip().lower() in {"1", "true", "on", "tak"} \
+        else files_state.READY
+    try:
+        logic.files_status(path, want, by=_who(request))
+    except httpx.HTTPStatusError as e:
+        detail = _http_detail(e)
+        if features.ADMIN not in _perms(request):
+            detail = "Tego pliku nie da się teraz włączyć do użytku."
+        return _files_redirect(error=detail)
+    except httpx.HTTPError as e:
+        return _files_redirect(error=_logic_error(e))
+    return _files_redirect(done="Zapisano." if want == files_state.READY
+                           else "Plik włączony do użytku.")
+
+
+@app.post("/files/upload")
+async def files_upload(request: Request, upload: UploadFile = File(...)):
+    """Wgranie nowej bazy. Plik zostaje NIEZALEŻNIE od wyniku walidacji —
+    nie tracimy niczego, co ktoś wgrał."""
+    raw = await upload.read()
+    if not raw:
+        return _files_redirect(error="Pusty plik.")
+    try:
+        out = logic.files_upload(upload.filename or "plik.xlsx",
+                                 base64.b64encode(raw).decode("ascii"), by=_who(request))
+    except httpx.HTTPError as e:
+        return _files_redirect(error=_logic_error(e))
+    # DOKŁADNIE ten sam komunikat niezależnie od wyniku sprawdzenia. Dwa różne
+    # komunikaty były wyrocznią: wystarczyło wgrywać spreparowane pliki i czytać
+    # odpowiedź, żeby odgadnąć reguły, które ma znać wyłącznie administrator.
+    # Poprzednia treść mówiła przy tym wprost, że istnieje „administrator", który
+    # musi plik „zatwierdzić" — czyli że konto wgrywającego jest ograniczone
+    # i że plik przechodzi przez jakąś bramkę.
+    return _files_redirect(done=f"Wgrano „{out.get('name')}”.")
+
+
+@app.post("/files/archive")
+def files_archive(request: Request, path: str = Form(...)):
+    """Archiwizacja: plik ZOSTAJE, zamrożony, ze znacznikiem czasu — znika tylko
+    z użytku. To najdalej idąca operacja dostępna osobie wgrywającej dane."""
+    try:
+        logic.files_status(path, files_state.ARCHIVED, by=_who(request))
+    except httpx.HTTPError as e:
+        return _files_redirect(error=_logic_error(e))
+    return _files_redirect(done=f"Zarchiwizowano „{path}”. Plik został zachowany.")
+
+
+@app.post("/files/restore")
+def files_restore(request: Request, path: str = Form(...)):
+    try:
+        logic.files_status(path, files_state.READY, by=_who(request))
+    except httpx.HTTPError as e:
+        return _files_redirect(error=_logic_error(e))
+    return _files_redirect(done=f"Przywrócono „{path}” z archiwum.")
+
+
+@app.post("/files/delete")
+def files_delete(request: Request, path: str = Form(...)):
+    try:
+        logic.files_delete(path)
+    except httpx.HTTPError as e:
+        return _files_redirect(error=_logic_error(e))
+    return _files_redirect(done=f"Skasowano „{path}” bezpowrotnie.")
+
+
+@app.post("/files/rules")
+def files_rules(request: Request, extensions: str = Form(".xlsx"),
+                max_size_mb: float = Form(50), min_rows: int = Form(1),
+                required_columns: str = Form(""),
+                reject_duplicate_content: str = Form("")):
+    rules = {
+        "extensions": [e.strip() for e in extensions.split(",") if e.strip()],
+        "max_size_mb": max_size_mb,
+        "min_rows": min_rows,
+        "required_columns": [c.strip() for c in required_columns.split(",") if c.strip()],
+        "reject_duplicate_content": reject_duplicate_content.strip().lower()
+        in {"1", "true", "on", "tak"},
+    }
+    try:
+        logic.files_rules(rules)
+    except httpx.HTTPError as e:
+        return _files_redirect(error=_logic_error(e))
+    return _files_redirect(done="Zapisano reguły walidacji.")
+
+
+def _http_detail(e: httpx.HTTPStatusError) -> str:
+    try:
+        return str(e.response.json().get("detail") or e)
+    except Exception:                              # noqa: BLE001
+        return str(e)
+
+features.zarejestruj(
+    ekran=Feature("files", "Pliki", "Wybór plików, z których korzysta program.",
+                  "Ekrany", "/files", kolejnosc=70),
+    # Kasowanie, przywracanie i REGUŁY PRZYJMOWANIA to wyłącznie administrator —
+    # o istnieniu reguł nikt poza nim nie ma skąd wiedzieć (DAN-27).
+    trasy={("GET", "/files"): "files", ("POST", "/files/use"): "files",
+           ("POST", "/files/upload"): "files_input",
+           ("POST", "/files/archive"): "files_input",
+           ("POST", "/files/restore"): features.ADMIN,
+           ("POST", "/files/delete"): features.ADMIN,
+           ("POST", "/files/rules"): features.ADMIN},
+    zasoby={"s-files.css": "files"},
+)
+features.zarejestruj(rozszerzenie=Feature(
+    "files_input", "Wgrywanie i archiwizacja plików",
+    "Dodawanie nowych plików i wycofywanie ich z użytku (plik zostaje, zamrożony, "
+    "ze znacznikiem czasu). Kasować może wyłącznie administrator.",
+    "Rozszerzenia", kolejnosc=40))

services/presentation/app/ekrany/skompiluj.py

@@ -0,0 +1,96 @@
+"""Skompiluj: zbiorczy raport z policzonych części (PRE-23), wraz z PDF-em."""
+from __future__ import annotations
+
+from fastapi import Form, Request
+from fastapi.responses import HTMLResponse, JSONResponse, Response
+import httpx
+
+from app.features import Feature
+from app.podstawa import (features, 
+    app,
+    templates,
+    logic,
+    chartwheel_mod,
+    DEFAULT_LOCATION_LABEL,
+    default_form,
+    _perms,
+    _limit_options,
+    _build_utc,
+    _logic_error,
+)
+
+# ---------------- Skompiluj: zbiorczy raport (PRE-23) ----------------
+@app.get("/compile", response_class=HTMLResponse)
+def compile_form(request: Request):
+    return templates.TemplateResponse(
+        request, "compile.html",
+        {"result": None, "form": default_form(), "location_label": DEFAULT_LOCATION_LABEL},
+    )
+
+
+@app.post("/compile", response_class=HTMLResponse)
+def compile_build(
+    request: Request,
+    person: str = Form(""),
+    date: str = Form(...),
+    time: str = Form(...),
+    tz_offset: float = Form(0.0),
+    lat: float = Form(0.0),
+    lon: float = Form(0.0),
+    house_system: str = Form("whole_sign"),
+    house_systems: list[str] = Form([]),      # PRE-05 — porównanie domów w podsumowaniu
+    aspect_orb: float = Form(8.0),            # PRE-06 — te same ustawienia aspektów
+    aspect_luminary_bonus: float = Form(2.0),
+    aspect_minor: bool = Form(False),
+    stations: bool = Form(False),             # LOG-03 — stacje też w podsumowaniu
+    zodiac: str = Form("tropical"),
+    tables: bool = Form(False),               # LOG-23 — żywioły/faza/godziny w podsumowaniu
+    wheel_orientation: str = Form(chartwheel_mod.ASC_LEFT),   # LOG-05 — obrót koła
+):
+    """Składa raport: horoskop liczymy TU NA NOWO, a części z przeglądarki (interpretacja
+    natalna i predykcje okresowe) dokłada przeglądarka z magazynu (PRE-22/23).
+
+    Horoskop liczymy ponownie (czysta funkcja wejścia — tanio powtórzyć, bez
+    trzymania dużego wyniku w przeglądarce), ale z TYMI SAMYMI opcjami, które
+    wybrano przy horoskopie (stacje, tabele, porównanie domów) — inaczej
+    podsumowanie miałoby braki względem tego, co policzono. Opcje wędrują między
+    zakładkami przez formsync.
+    """
+    form = {"person": person, "date": date, "time": time, "tz_offset": tz_offset,
+            "lat": lat, "lon": lon, "house_system": house_system,
+            "house_systems": house_systems, "aspect_orb": aspect_orb,
+            "aspect_luminary_bonus": aspect_luminary_bonus, "aspect_minor": aspect_minor,
+            "stations": stations, "zodiac": zodiac, "tables": tables,
+            "wheel_orientation": wheel_orientation}
+    form = _limit_options(request, form)
+    ctx: dict = {"form": form, "result": None, "error": None, "moment": None}
+    try:
+        iso_utc, label = _build_utc(date, time, tz_offset)
+        ctx["moment"] = label
+        ctx["result"] = logic.positions(
+            when_utc_iso=iso_utc, lat=lat, lon=lon,
+            house_system=form["house_system"], house_systems=form["house_systems"],
+            aspect_orb=aspect_orb, aspect_luminary_bonus=aspect_luminary_bonus,
+            aspect_minor=form["aspect_minor"],
+            stations=form["stations"], zodiac=form["zodiac"], tables=form["tables"],
+        )
+        from app import chartwheel
+        ctx["wheel_svg"] = chartwheel.render(ctx["result"],
+                                            orientation=form["wheel_orientation"])
+        if "extra_charts" in _perms(request):
+            ctx["aspectarian_svg"] = chartwheel.render_aspectarian(ctx["result"])  # PRE-18
+            ctx["declination_svg"] = chartwheel.render_declination(ctx["result"])  # LOG-07
+            ctx["antiscia_svg"] = chartwheel.render_antiscia(ctx["result"])        # LOG-07
+    except (httpx.HTTPError,) as e:
+        ctx["error"] = _logic_error(e)
+    except ValueError as e:
+        ctx["error"] = f"Niepoprawne dane wejściowe: {e}"
+    return templates.TemplateResponse(request, "compile.html", ctx)
+
+
+features.zarejestruj(
+    ekran=Feature("compile", "Skompiluj", "Złożenie raportu z policzonych części.",
+                  "Ekrany", "/compile", kolejnosc=60),
+    trasy={("GET", "/compile"): "compile", ("POST", "/compile"): "compile"},
+    zasoby={"s-compile.css": "compile", "compile.js": "compile"},
+)

services/presentation/app/ekrany/sygnifikatory.py

@@ -0,0 +1,41 @@
+"""Sygnifikatory: wyszukiwarka po bazach."""
+from __future__ import annotations
+
+from fastapi import Form, Request
+from fastapi.responses import HTMLResponse
+import httpx
+
+from app.features import Feature
+from app.podstawa import (features, app, templates, logic, security, _logic_error)
+
+# ---------------- Sygnifikatory (wyszukiwarka w bazach) ----------------
+@app.get("/significators", response_class=HTMLResponse)
+def significators_form(request: Request):
+    return templates.TemplateResponse(request, "significators.html", {"result": None, "form": {}})
+
+
+@app.post("/significators", response_class=HTMLResponse)
+def significators_search(
+    request: Request,
+    query: str = Form(...),
+    field: str = Form("name"),
+    exact: bool = Form(False),
+    limit: int = Form(25),
+):
+    form = {"query": query, "field": field, "exact": exact, "limit": limit}
+    ctx: dict = {"form": form, "result": None, "error": None}
+    try:
+        ctx["result"] = logic.query(query=query, field=field, exact=exact, limit=limit)
+        # ile rekordów baz oddaliśmy — do dziennika audytowego (PRE-17), bez treści
+        security.audit_records(request, len((ctx["result"] or {}).get("rows") or []))
+    except httpx.HTTPError as e:
+        ctx["error"] = _logic_error(e)
+    return templates.TemplateResponse(request, "significators.html", ctx)
+
+features.zarejestruj(
+    ekran=Feature("significators", "Sygnifikatory", "Wyszukiwarka po bazach.",
+                  "Ekrany", "/significators", kolejnosc=50),
+    trasy={("GET", "/significators"): "significators",
+           ("POST", "/significators"): "significators"},
+    zasoby={"s-significators.css": "significators"},
+)

services/presentation/app/ekrany/synastria.py

@@ -0,0 +1,58 @@
+"""Synastria: porównanie dwóch horoskopów."""
+from __future__ import annotations
+
+from fastapi import Form, Request
+from fastapi.responses import HTMLResponse
+import httpx
+
+from app.features import Feature
+from app.podstawa import (features, app, templates, logic, _build_utc, _logic_error)
+
+# ---------------- Synastria (technika relacyjna) ----------------
+@app.get("/synastry", response_class=HTMLResponse)
+def synastry_form(request: Request):
+    # domyślne liczby, żeby pola number nie były puste (puste → błąd przy wysyłce)
+    form = {"a_tz_offset": 0, "a_lat": 0, "a_lon": 0, "b_tz_offset": 0, "b_lat": 0, "b_lon": 0,
+            "aspect_orb": 8, "aspect_luminary_bonus": 2}
+    return templates.TemplateResponse(request, "synastry.html", {"result": None, "form": form})
+
+
+@app.post("/synastry", response_class=HTMLResponse)
+def synastry_run(
+    request: Request,
+    a_person: str = Form(""), a_date: str = Form(...), a_time: str = Form(...),
+    a_tz_offset: float = Form(0.0), a_lat: float = Form(0.0), a_lon: float = Form(0.0),
+    b_person: str = Form(""), b_date: str = Form(...), b_time: str = Form(...),
+    b_tz_offset: float = Form(0.0), b_lat: float = Form(0.0), b_lon: float = Form(0.0),
+    zodiac: str = Form("tropical"),
+    aspect_orb: float = Form(8.0), aspect_luminary_bonus: float = Form(2.0),
+    aspect_minor: bool = Form(False),
+):
+    """Synastria (PRE-04): dwie osoby → aspekty między ich horoskopami."""
+    form = {"a_person": a_person, "a_date": a_date, "a_time": a_time, "a_tz_offset": a_tz_offset,
+            "a_lat": a_lat, "a_lon": a_lon, "b_person": b_person, "b_date": b_date,
+            "b_time": b_time, "b_tz_offset": b_tz_offset, "b_lat": b_lat, "b_lon": b_lon,
+            "zodiac": zodiac, "aspect_orb": aspect_orb,
+            "aspect_luminary_bonus": aspect_luminary_bonus, "aspect_minor": aspect_minor}
+    ctx: dict = {"form": form, "result": None, "error": None}
+    try:
+        iso_a, _ = _build_utc(a_date, a_time, a_tz_offset)
+        iso_b, _ = _build_utc(b_date, b_time, b_tz_offset)
+        ctx["result"] = logic.synastry(
+            {"when_utc": iso_a, "lat": a_lat, "lon": a_lon},
+            {"when_utc": iso_b, "lat": b_lat, "lon": b_lon},
+            zodiac=zodiac, aspect_orb=aspect_orb,
+            aspect_luminary_bonus=aspect_luminary_bonus, aspect_minor=aspect_minor,
+        )
+    except httpx.HTTPError as e:
+        ctx["error"] = _logic_error(e)
+    except ValueError as e:
+        ctx["error"] = f"Niepoprawne dane wejściowe: {e}"
+    return templates.TemplateResponse(request, "synastry.html", ctx)
+
+features.zarejestruj(
+    ekran=Feature("synastry", "Synastria", "Porównanie dwóch horoskopów.",
+                  "Ekrany", "/synastry", kolejnosc=40),
+    trasy={("GET", "/synastry"): "synastry", ("POST", "/synastry"): "synastry"},
+    zasoby={"s-synastry.css": "synastry"},
+)

services/presentation/app/ekrany/ustawienia.py

@@ -0,0 +1,32 @@
+"""Ustawienia: podgląd baz widocznych na udziale (DAN-15/PRE-09)."""
+from __future__ import annotations
+
+from fastapi import Request
+from fastapi.responses import HTMLResponse
+import httpx
+
+from app.features import Feature
+from app.podstawa import (features, app, templates, logic, _logic_error)
+
+# ---------------- Ustawienia: bazy na udziale (DAN-15/PRE-09) ----------------
+@app.get("/settings", response_class=HTMLResponse)
+def settings_view(request: Request):
+    """Podgląd baz dostępnych na udziale + które biorą udział w interpretacji.
+
+    Same metadane (nazwa, rozmiar, data) — bez treści baz. Przełączniki są
+    DEKLARATYWNE (`DISABLED_BASES`), bo warstwa danych nie ma trwałego zapisu:
+    udział jest read-only, a cache to emptyDir. Zapis do pliku ginąłby po
+    restarcie, po cichu włączając z powrotem wyłączoną bazę."""
+    ctx: dict = {"result": None, "error": None}
+    try:
+        ctx["result"] = logic.bases()
+    except httpx.HTTPError as e:
+        ctx["error"] = _logic_error(e)
+    return templates.TemplateResponse(request, "settings.html", ctx)
+
+features.zarejestruj(
+    ekran=Feature("settings", "Ustawienia", "Podgląd plików widocznych na udziale.",
+                  "Ekrany", "/settings", kolejnosc=80),
+    trasy={("GET", "/settings"): "settings"},
+    zasoby={"s-settings.css": "settings"},
+)

services/presentation/app/features.py

@@ -21,6 +21,8 @@ from __future__ import annotations
 
 from dataclasses import dataclass
 
+from app import rozszerzenia
+
 ADMIN = "admin"          # zakładanie kont i nadawanie uprawnień — nie do nadania z UI
 
 
@@ -31,97 +33,76 @@ class Feature:
     hint: str
     group: str
     href: str = ""          # tylko ekrany; rozszerzenia nie mają własnej zakładki
+    kolejnosc: int = 0      # pozycja w nawigacji; nie zależy od kolejności importów
 
 
-# ── ekrany (zakładki) ────────────────────────────────────────────────────
-SCREENS: tuple[Feature, ...] = (
-    Feature("chart", "Horoskop", "Pozycje, osie, domy, aspekty, kosmogram.", "Ekrany", "/"),
-    Feature("interpret", "Interpretacje", "Interpretacja natalna z baz i od modelu.", "Ekrany", "/interpret"),
-    Feature("timeline", "Kalendarz", "Predykcje na wybrany zakres dat.", "Ekrany", "/timeline"),
-    Feature("synastry", "Synastria", "Porównanie dwóch horoskopów.", "Ekrany", "/synastry"),
-    Feature("significators", "Sygnifikatory", "Wyszukiwarka po bazach interpretacyjnych.", "Ekrany", "/significators"),
-    Feature("compile", "Skompiluj", "Złożenie raportu z policzonych części.", "Ekrany", "/compile"),
-    Feature("files", "Pliki", "Wybór baz, z których korzysta program.", "Ekrany", "/files"),
-    Feature("settings", "Ustawienia", "Podgląd baz i konfiguracji modelu.", "Ekrany", "/settings"),
-)
+# ── rejestr: katalog składa się z tego, co zgłoszą ekrany ────────────────
+# Dawniej wszystkie funkcje były wypisane TUTAJ. To znaczyło, że obraz produktu,
+# który części z nich nie ma, i tak niósł ich nazwy — czyli spis funkcji, których
+# nie ma jak włączyć. Teraz ekran zgłasza siebie sam, przy imporcie swojego
+# modułu, więc katalog opisuje dokładnie ten produkt, który się zbudowało.
+#
+# `kolejnosc` jest jawna, bo o zawartości decyduje lista importów w `main.py`,
+# a kolejność importów nie może rządzić kolejnością zakładek w nawigacji.
+SCREENS: list[Feature] = []
+# Pozycje nawigacji dla uprawnień NIENADAWALNYCH — tych, których nie ma w
+# GRANTABLE, więc nie da się ich przyznać z żadnego ekranu. Osobno od SCREENS
+# i wraz z wymaganym uprawnieniem, żeby szablon nie musiał go wypowiadać: wpisane
+# w szablonie na sztywno zostawiało nazwę ekranu i martwy odsyłacz w produkcie,
+# który tego ekranu nie ma.
+NAWIGACJA_SPECJALNA: list[tuple[str, str, str, str]] = []   # (klucz, adres, etykieta, uprawnienie)
+EXTRAS: list[Feature] = []
+ALL: tuple[Feature, ...] = ()
+BY_KEY: dict[str, Feature] = {}
+GRANTABLE: frozenset[str] = frozenset()
 
-# ── rozszerzenia (poziomy złożoności wewnątrz ekranów) ───────────────────
-EXTRAS: tuple[Feature, ...] = (
-    Feature("houses_compare", "Porównanie systemów domów",
-            "Wybór systemu innego niż domyślny i zestawienie kilku obok siebie.",
-            "Rozszerzenia"),
-    Feature("extra_charts", "Wykresy dodatkowe",
-            "Aspektarian, wykres deklinacji, oś antyscji.", "Rozszerzenia"),
-    Feature("advanced_calc", "Obliczenia zaawansowane",
-            "Stacje planet, tabele żywiołów i faz, aspekty poboczne, zodiaki syderyczne.",
-            "Rozszerzenia"),
-    Feature("ai", "Generowanie tekstu przez model",
-            "Horoskopy pisane przez model językowy. UWAGA: każde użycie kosztuje.",
-            "Rozszerzenia"),
-    Feature("files_input", "Wgrywanie i archiwizacja baz",
-            "Dodawanie nowych plików baz i wycofywanie ich z użytku (plik zostaje, "
-            "zamrożony, ze znacznikiem czasu). Kasować może wyłącznie administrator.",
-            "Rozszerzenia"),
-    Feature("export", "Eksport plików",
-            "Pobieranie raportu jako PDF i wyników jako Excel.", "Rozszerzenia"),
-)
+ROUTES: dict[tuple[str, str], str | None] = {}
+STATIC: dict[str, frozenset[str] | str | None] = {}
 
-ALL: tuple[Feature, ...] = SCREENS + EXTRAS
-BY_KEY: dict[str, Feature] = {f.key: f for f in ALL}
-GRANTABLE: frozenset[str] = frozenset(BY_KEY)      # ADMIN celowo poza tym zbiorem
+
+def _przelicz() -> None:
+    global ALL, BY_KEY, GRANTABLE
+    SCREENS.sort(key=lambda f: f.kolejnosc)
+    EXTRAS.sort(key=lambda f: f.kolejnosc)
+    ALL = tuple(SCREENS) + tuple(EXTRAS)
+    BY_KEY = {f.key: f for f in ALL}
+    GRANTABLE = frozenset(BY_KEY)              # ADMIN celowo poza tym zbiorem
+
+
+def zarejestruj(*, ekran: Feature | None = None, rozszerzenie: Feature | None = None,
+                trasy: dict[tuple[str, str], str | None] | None = None,
+                zasoby: dict | None = None,
+                nawigacja: tuple[str, str, str, str] | None = None) -> None:
+    """Zgłoszenie funkcji, jej tras i jej zasobów.
+
+    Idempotentne po kluczu: `export` zgłaszają dwa ekrany (raport do PDF-a
+    i wyniki do arkusza), a wpis ma powstać raz."""
+    for pozycja, zbior in ((ekran, SCREENS), (rozszerzenie, EXTRAS)):
+        if pozycja and pozycja.key not in {f.key for f in zbior}:
+            zbior.append(pozycja)
+    if nawigacja and nawigacja[0] not in {p[0] for p in NAWIGACJA_SPECJALNA}:
+        NAWIGACJA_SPECJALNA.append(nawigacja)
+    ROUTES.update(trasy or {})
+    STATIC.update(zasoby or {})
+    _przelicz()
+
+
+# Funkcje wnoszone przez moduły opcjonalne — zgłaszane tak samo jak ekrany,
+# tylko przez neutralny most, żeby katalog nie musiał ich wymieniać z nazwy.
+for _krotka in rozszerzenia.funkcje():
+    zarejestruj(rozszerzenie=Feature(*_krotka))
+zarejestruj(trasy=rozszerzenia.trasy(), zasoby=rozszerzenia.zasoby())
 
 
 # ── mapa trasa → wymagane uprawnienie ────────────────────────────────────
 # None = dostępne każdemu zalogowanemu. Dotyczy to pomocników (geokoder, strefa
 # czasowa, health), które same w sobie NICZEGO nie zdradzają o funkcjach programu.
-ROUTES: dict[tuple[str, str], str | None] = {
-    ("GET", "/"): None,                     # korzeń przekierowuje na pierwszy dostępny ekran
-    ("POST", "/"): "chart",
-    ("GET", "/interpret"): "interpret",
-    ("POST", "/interpret"): "interpret",
-    ("GET", "/timeline"): "timeline",
-    ("POST", "/timeline"): "timeline",
-    ("GET", "/synastry"): "synastry",
-    ("POST", "/synastry"): "synastry",
-    ("GET", "/significators"): "significators",
-    ("POST", "/significators"): "significators",
-    ("GET", "/compile"): "compile",
-    ("POST", "/compile"): "compile",
-    ("POST", "/compile/pdf"): "export",
-    ("GET", "/settings"): "settings",
-    # Zarządzanie plikami baz (DAN-27). Trzy poziomy: „files" wybiera, z czego
-    # program korzysta; „files_input" dokłada wgrywanie i archiwizację;
-    # kasowanie, przywracanie i REGUŁY WALIDACJI to wyłącznie administrator —
-    # o istnieniu walidacji nikt poza nim nie ma skąd wiedzieć.
-    ("GET", "/files"): "files",
-    ("POST", "/files/use"): "files",
-    ("POST", "/files/upload"): "files_input",
-    ("POST", "/files/archive"): "files_input",
-    ("POST", "/files/restore"): ADMIN,
-    ("POST", "/files/delete"): ADMIN,
-    ("POST", "/files/rules"): ADMIN,
-    ("POST", "/horoscope/stream"): "ai",
-    ("GET", "/accounts"): ADMIN,
-    ("POST", "/accounts/create"): ADMIN,
-    ("POST", "/accounts/update"): ADMIN,
-    ("POST", "/accounts/delete"): ADMIN,
-    ("GET", "/geocode"): None,
-    ("GET", "/reverse"): None,
-    ("GET", "/timezone"): None,
-    ("GET", "/health"): None,
-    # Wylogowanie musi być dostępne dla każdego zalogowanego, niezależnie od tego,
-    # co mu przyznano — konto bez ani jednego ekranu też ma prawo wyjść.
-    ("GET", "/logowanie"): None,
-    ("POST", "/logowanie"): None,
-    ("POST", "/wyloguj"): None,
-    ("POST", "/accounts/sesje"): ADMIN,
-}
 
 
 # ── zasoby statyczne ─────────────────────────────────────────────────────
 # Skrypt i arkusz stylów są CZĘŚCIĄ funkcji, nie jej dekoracją. Nazwa pliku jest
-# zgadywalna, a treść opowiada o funkcji dokładniej niż przycisk: `models.js`
-# wymienia dostawców modeli, `compile.js` — składanie raportu. Dlatego każdy
+# zgadywalna, a treść opowiada o funkcji dokładniej niż przycisk: `compile.js`
+# zdradza składanie raportu, a `wheelzoom.js` — istnienie kosmogramu. Dlatego każdy
 # zasób przechodzi przez tę samą bramkę co ekrany.
 #
 # Wartość to ZBIÓR uprawnień, z których wystarczy JEDNO: wyszukiwarka lokalizacji
@@ -131,36 +112,6 @@ _FORMULARZE = frozenset({"chart", "interpret", "timeline", "compile"})
 _LOKALIZACJA = frozenset({"chart", "interpret", "timeline"})
 _KOLO = frozenset({"chart", "compile"})
 
-STATIC: dict[str, frozenset[str] | str | None] = {
-    # arkusze ekranów — jeden ekran, jedno uprawnienie
-    "s-chart.css": "chart",
-    "s-interpret.css": "interpret",
-    "s-timeline.css": "timeline",
-    "s-synastry.css": "synastry",
-    "s-significators.css": "significators",
-    "s-compile.css": "compile",
-    "s-files.css": "files",
-    "s-settings.css": "settings",
-    "s-accounts.css": ADMIN,
-    "x-ai.css": "ai",
-    # skrypty
-    "formsync.js": _FORMULARZE,
-    "now.js": _LOKALIZACJA,
-    "geo.js": _LOKALIZACJA,
-    "vendor/leaflet/leaflet.js": _LOKALIZACJA,
-    "vendor/leaflet/leaflet.css": _LOKALIZACJA,
-    "wheelzoom.js": _KOLO,
-    "wheeltip.js": _KOLO,
-    "copy.js": frozenset({"interpret", "timeline"}),
-    "compile.js": "compile",
-    "models.js": "ai",
-    "progress.js": "ai",
-    "natal.js": "ai",
-    "predictions.js": "ai",
-    # base.css celowo NIE MA tu wpisu: potrzebuje go ekran logowania, więc jest
-    # publiczny (PUBLIC_PATHS w security.py). Dlatego nie wolno w nim trzymać
-    # niczego, co nazywa jakąkolwiek funkcję.
-}
 
 
 def static_required(name: str) -> frozenset[str] | str | None:
@@ -192,7 +143,8 @@ def can(perms: frozenset[str], feature: frozenset[str] | str | None) -> bool:
 
 
 def screens_for(perms: frozenset[str]) -> list[Feature]:
-    """Zakładki do pokazania w nawigacji — w stałej kolejności katalogu."""
+    """Zakładki do pokazania w nawigacji — w kolejności zadeklarowanej, nie w tej,
+    w której akurat wykonały się importy."""
     return [f for f in SCREENS if f.key in perms]
 
 

services/presentation/app/house_systems.py

@@ -1,7 +1,7 @@
 """Katalog systemów domów dla warstwy prezentacji — JEDNO źródło nazw.
 
 Nazwy były zaszyte w czterech szablonach naraz (selektor na „Horoskop", selektor
-na „Skompiluj", checkboxy porównania, nagłówki tabeli). Przy trzech systemach
+w raporcie zbiorczym, checkboxy porównania, nagłówki tabeli). Przy trzech systemach
 uchodziło to na sucho; przy dziesięciu rozjazd jest kwestią czasu — wystarczy
 dopisać system w jednym miejscu i zapomnieć o trzech pozostałych.
 

services/presentation/app/moduly/__init__.py

@@ -0,0 +1,11 @@
+"""Moduły opcjonalne — każdy podkatalog to jedna odłączalna część produktu.
+
+O tym, co produkt umie, decyduje ZAWARTOŚĆ tego katalogu w obrazie. Most
+(`app.rozszerzenia`) odkrywa moduły, przechodząc po podkatalogach, i nie zna
+żadnej nazwy — gdyby znał, nazwa nieobecnego modułu i tak jechałaby do obrazu,
+w którym go nie ma.
+
+Moduł może wnieść: pozycję do katalogu funkcji, trasy, zasoby, akcje formularza,
+pola formularza, wpisy do kontekstu szablonu, własne szablony i własne statyki.
+Wszystko jest opcjonalne — most pyta o to, czego moduł nie ma, i dostaje pusto.
+"""

services/presentation/app/moduly/dodatki/__init__.py

@@ -0,0 +1,23 @@
+"""Generowanie tekstu przez model językowy — moduł CAŁKOWICIE ODŁĄCZALNY.
+
+DLACZEGO OSOBNY KATALOG, A NIE `{% if %}` W SZABLONACH. Warunek w szablonie
+wystarcza, żeby funkcji nie było WIDAĆ, ale nie żeby jej NIE BYŁO. Plik szablonu
+i tak leży w obrazie i i tak zawiera słowa opisujące funkcję — `grep` po
+kontenerze pokazuje wszystko, czego warunek nie pokazał na ekranie.
+
+Astrololo zawiera ten katalog. Astroklient — nie, i to jest jedyna różnica
+między nimi po stronie funkcji astrologicznych. Dlatego granica MUSI być
+katalogiem: co jest w środku, znika razem z nim, a co jest na zewnątrz, zostaje.
+
+ZASADA DLA KOGOŚ, KTO TU DOPISUJE. Poza tym katalogiem nie wolno napisać ani
+słowa o modelu, prompcie czy dostawcy — nawet w komentarzu, nawet zaprzeczając.
+Szablony wspólne mają neutralne gniazda (`_dodatki_*`), a plik wstawiany w
+gniazdo sam sprawdza uprawnienie. Pilnuje tego test `test_ai_tylko_w_module.py`.
+"""
+from __future__ import annotations
+
+from app.moduly.dodatki.katalog import AKCJE, FUNKCJA, TRASY, ZASOBY, katalog_dla, obsluz, pola
+from app.moduly.dodatki.trasy import zamontuj
+
+__all__ = ["AKCJE", "FUNKCJA", "TRASY", "ZASOBY", "katalog_dla", "obsluz", "pola",
+           "zamontuj"]

services/presentation/app/moduly/dodatki/katalog.py

@@ -0,0 +1,91 @@
+"""Co moduł wnosi do aplikacji: funkcję, trasy, zasoby, akcje i pola formularza.
+
+Wszystko, co gdziekolwiek indziej musiałoby paść z nazwy, jest zebrane TUTAJ.
+Reszta aplikacji zna wyłącznie neutralny most (`app.rozszerzenia`) i pyta go
+o dane, nigdy o „generowanie" czy „model".
+"""
+from __future__ import annotations
+
+from typing import Any
+
+import httpx
+from fastapi import Form, Request
+
+from app.moduly.dodatki import klient
+
+# Pozycja w katalogu funkcji — surowa krotka, żeby nie importować `features`
+# (to zamknęłoby cykl features → most → moduł → features).
+FUNKCJA: tuple[tuple[str, str, str, str], ...] = (
+    ("ai", "Generowanie tekstu przez model",
+     "Horoskopy pisane przez model językowy. UWAGA: każde użycie kosztuje.",
+     "Rozszerzenia"),
+)
+
+TRASY: dict[tuple[str, str], str] = {("POST", "/horoscope/stream"): "ai"}
+
+ZASOBY: dict[str, str] = {
+    "x-ai.css": "ai",
+    "models.js": "ai",
+    "progress.js": "ai",
+    "natal.js": "ai",
+    "predictions.js": "ai",
+}
+
+# Akcje formularza wnoszone przez moduł: nazwa → wymagane uprawnienie.
+AKCJE: dict[str, str] = {"prompt": "ai", "horoscope": "ai"}
+
+# Wstrzykiwane przez `zamontuj` z main.py — moduł nie importuje aplikacji,
+# bo to byłby cykl, a przy okazji zmusiłoby aplikację do wiedzy o module.
+_logic: Any = None
+_szablony: Any = None
+
+
+def ustaw_zaleznosci(*, logic: Any, templates: Any) -> None:
+    global _logic, _szablony
+    _logic, _szablony = logic, templates
+
+
+def pola(prompt_budget: str = Form("medium"),
+         llm_provider: str = Form(""),
+         llm_model: str = Form("")) -> dict:
+    """Pola formularza, których wspólny handler nie może wymienić w sygnaturze.
+
+    FastAPI czyta pola z sygnatury, więc zadeklarowanie ich we wspólnym handlerze
+    wpisałoby nazwy `llm_provider` i `prompt_budget` w kod, który trafia także do
+    obrazu bez tego modułu. Zależność przenosi deklarację tutaj."""
+    return {"prompt_budget": prompt_budget, "llm_provider": llm_provider,
+            "llm_model": llm_model}
+
+
+def _katalog() -> dict:
+    """Podpowiedzi modeli dla pola wyboru. Awaria logiki nie może wywrócić strony —
+    pole modelu jest tekstowe, więc bez katalogu nadal da się wpisać model ręcznie."""
+    try:
+        return klient.modele(_logic)
+    except httpx.HTTPError:
+        return {"providers": {}, "defaults": {}}
+
+
+def katalog_dla(request: Request) -> dict:
+    """Katalog modeli do kontekstu szablonu — pusty, gdy konto nie ma uprawnienia.
+
+    Katalog trafia do strony jako blok JSON, więc bez tego ograniczenia nazwy
+    dostawców, modeli i rozmiary okien kontekstu byłyby w źródle każdej strony,
+    także dla kont, które o modelach nie mają prawa wiedzieć."""
+    perms = getattr(getattr(request.state, "principal", None), "permissions", frozenset())
+    return {"llm_catalog": _katalog() if "ai" in perms else {}}
+
+
+def obsluz(akcja: str, *, profil: str, iso_utc: str, lat: float, lon: float,
+           dodatki: dict, od: str = "", do: str = "", **_reszta) -> dict | None:
+    """Wykonanie akcji modułu. None znaczy „to nie moja akcja"."""
+    if akcja not in AKCJE:
+        return None
+    metoda = klient.prompt if akcja == "prompt" else klient.horoscope
+    argumenty = {"logic": _logic, "profile": profil, "when_utc_iso": iso_utc, "lat": lat, "lon": lon,
+                 "budget": dodatki.get("prompt_budget", "medium"),
+                 "provider": dodatki.get("llm_provider", ""),
+                 "model": dodatki.get("llm_model", "")}
+    if profil == "period":
+        argumenty["from_date"], argumenty["to_date"] = od, do
+    return metoda(**argumenty)

services/presentation/app/moduly/dodatki/klient.py

@@ -0,0 +1,62 @@
+"""Rozmowa z warstwą logiczną w sprawach tego modułu.
+
+Metody nie siedzą na wspólnym kliencie, tylko tutaj: gdyby siedziały tam, ich
+nazwy (`prompt`, `horoscope`, `llm_models`) byłyby w pliku, który jedzie do
+KAŻDEGO obrazu — także tam, gdzie tego modułu nie ma. Wspólny klient daje samą
+drogę w dół (`wywolaj`, `pobierz`, `strumien`), z szyfrowaniem łącza i tokenem
+międzywarstwowym; co nią pojedzie, jest sprawą modułu.
+"""
+from __future__ import annotations
+
+from typing import Any
+
+from app.config import settings
+
+
+def prompt(logic: Any, *, profile: str, when_utc_iso: str, lat: float, lon: float,
+           budget: str = "medium", from_date: str | None = None,
+           to_date: str | None = None, provider: str | None = None,
+           model: str | None = None) -> dict[str, Any]:
+    """Gotowy prompt z wyliczeń (LOG-29/30).
+
+    `provider` jest potrzebny dla budżetu „maksymalny kontekst modelu": limit
+    znaków zależy wtedy od okna kontekstu konkretnego modelu."""
+    payload: dict[str, Any] = {
+        "profile": profile, "when_utc": when_utc_iso, "lat": lat, "lon": lon,
+        "budget": budget, "provider": provider, "model": model,
+    }
+    if from_date and to_date:
+        payload["from_date"], payload["to_date"] = from_date, to_date
+    return logic.wywolaj("/chart/prompt", payload, max(settings.http_timeout, 60.0))
+
+
+def horoscope(logic: Any, *, profile: str, when_utc_iso: str, lat: float, lon: float,
+              budget: str = "medium", provider: str | None = None,
+              model: str | None = None, from_date: str | None = None,
+              to_date: str | None = None) -> dict[str, Any]:
+    """Napisany horoskop (LOG-31). Długi timeout, bo pisanie trwa —
+    zwłaszcza na modelu lokalnym."""
+    payload: dict[str, Any] = {
+        "profile": profile, "when_utc": when_utc_iso, "lat": lat, "lon": lon,
+        "budget": budget,
+    }
+    if provider:
+        payload["provider"] = provider
+    if model:
+        payload["model"] = model
+    if from_date and to_date:
+        payload["from_date"], payload["to_date"] = from_date, to_date
+    return logic.wywolaj("/chart/horoscope", payload, max(settings.http_timeout, 300.0))
+
+
+def strumien(logic: Any, payload: dict[str, Any]):
+    """Strumień postępu pisania (NDJSON), przekazywany do przeglądarki.
+
+    Strumień niesie heartbeat, więc cisza na łączu nie zostanie wzięta
+    za zerwanie."""
+    yield from logic.strumien("/chart/horoscope/stream", payload)
+
+
+def modele(logic: Any) -> dict[str, Any]:
+    """Katalog modeli per dostawca — podpowiedzi do pola wyboru."""
+    return logic.pobierz("/llm/models")

services/presentation/app/moduly/dodatki/static/natal.js

@@ -93,5 +93,5 @@
     }
   });
 
-  window.astrololoNatal = { read: read, clear: clear, key: KEY };
+  window.kosmogramNatal = { read: read, clear: clear, key: KEY };
 })();

services/presentation/app/moduly/dodatki/static/predictions.js

@@ -146,5 +146,5 @@
   });
 
   // Udostępniamy magazyn zakładce „Skompiluj" (PRE-23) — jedno źródło prawdy.
-  window.astrololoPredictions = { read: read, remove: remove, key: KEY };
+  window.kosmogramPredictions = { read: read, remove: remove, key: KEY };
 })();

services/presentation/app/moduly/dodatki/static/x-ai.css

@@ -29,3 +29,10 @@
 .progress-log li.log-ok { color: #7fd18b; }
 .progress-log li.log-warn { color: #e0c060; }
 .progress-log li.log-err { color: #ef6b6b; }
+
+/* Generator promptu do LLM (LOG-29/30) */
+textarea.prompt { width: 100%; margin-top: .5rem; padding: .7rem .8rem; box-sizing: border-box;
+                  background: #12132a; color: var(--ink); border: 1px solid var(--line);
+                  border-radius: 10px; font-family: ui-monospace, SFMono-Regular, Menlo, monospace;
+                  font-size: .82rem; line-height: 1.45; resize: vertical; white-space: pre; }
+textarea.prompt:focus { outline: 2px solid var(--accent); outline-offset: 1px; }

services/presentation/app/moduly/dodatki/templates/_dodatki_compile_skrypty.html

@@ -0,0 +1,9 @@
+{# Wstawka modułu. Sprawdzenie uprawnienia siedzi TUTAJ, a nie w szablonie
+   wspólnym: tam byłoby nazwą funkcji wpisaną w plik, który trafia także do
+   obrazu bez tego modułu. #}
+{% if can(request, 'ai') %}
+{# Magazyny wczytujemy dla ich API odczytu. Ich własne UI samo się wyłącza —
+   każdy sprawdza, czy jego kontener jest na stronie. #}
+<script src="{{ static('natal.js') }}"></script>
+<script src="{{ static('predictions.js') }}"></script>
+{% endif %}

services/presentation/app/moduly/dodatki/templates/_dodatki_compile_style.html

@@ -0,0 +1,4 @@
+{# Wstawka modułu. Sprawdzenie uprawnienia siedzi TUTAJ, a nie w szablonie
+   wspólnym: tam byłoby nazwą funkcji wpisaną w plik, który trafia także do
+   obrazu bez tego modułu. #}
+{% if can(request, 'ai') %}<link rel="stylesheet" href="{{ static('x-ai.css') }}">{% endif %}

services/presentation/app/moduly/dodatki/templates/_dodatki_compile_wyniki.html

@@ -0,0 +1,8 @@
+{# Wstawka modułu. Sprawdzenie uprawnienia siedzi TUTAJ, a nie w szablonie
+   wspólnym: tam byłoby nazwą funkcji wpisaną w plik, który trafia także do
+   obrazu bez tego modułu. #}
+{% if can(request, 'ai') %}
+{# Części od modelu — wstawia przeglądarka z magazynu lokalnego. #}
+<div id="reportNatal"></div>
+<div id="reportPredictions"></div>
+{% endif %}

services/presentation/app/moduly/dodatki/templates/_dodatki_interpret_akcje.html

@@ -0,0 +1,7 @@
+{# Wstawka modułu. Sprawdzenie uprawnienia siedzi TUTAJ, a nie w szablonie
+   wspólnym: tam byłoby nazwą funkcji wpisaną w plik, który trafia także do
+   obrazu bez tego modułu. #}
+{% if can(request, 'ai') %}
+<button type="submit" name="action" value="prompt" class="ghost">Generuj prompt (AI)</button>
+<button type="submit" name="action" value="horoscope">Napisz horoskop (AI)</button>
+{% endif %}

services/presentation/app/moduly/dodatki/templates/_dodatki_interpret_formularz.html

@@ -0,0 +1,5 @@
+{# Wstawka modułu. Sprawdzenie uprawnienia siedzi TUTAJ, a nie w szablonie
+   wspólnym: tam byłoby nazwą funkcji wpisaną w plik, który trafia także do
+   obrazu bez tego modułu. #}
+{% if can(request, 'ai') %}{% include "_prompt_block.html" %}
+<p class="muted small" id="natalNote"></p>{% endif %}

services/presentation/app/moduly/dodatki/templates/_dodatki_interpret_skrypty.html

@@ -0,0 +1,9 @@
+{# Wstawka modułu. Sprawdzenie uprawnienia siedzi TUTAJ, a nie w szablonie
+   wspólnym: tam byłoby nazwą funkcji wpisaną w plik, który trafia także do
+   obrazu bez tego modułu. #}
+{% if can(request, 'ai') %}
+<script src="{{ static('models.js') }}"></script>
+<script src="{{ static('progress.js') }}"></script>
+{# po progress.js — nasłuchuje zdarzenia o gotowej interpretacji (PRE-23) #}
+<script src="{{ static('natal.js') }}"></script>
+{% endif %}

services/presentation/app/moduly/dodatki/templates/_dodatki_interpret_style.html

@@ -0,0 +1,4 @@
+{# Wstawka modułu. Sprawdzenie uprawnienia siedzi TUTAJ, a nie w szablonie
+   wspólnym: tam byłoby nazwą funkcji wpisaną w plik, który trafia także do
+   obrazu bez tego modułu. #}
+{% if can(request, 'ai') %}<link rel="stylesheet" href="{{ static('x-ai.css') }}">{% endif %}

services/presentation/app/moduly/dodatki/templates/_dodatki_timeline_akcje.html

@@ -0,0 +1,7 @@
+{# Wstawka modułu. Sprawdzenie uprawnienia siedzi TUTAJ, a nie w szablonie
+   wspólnym: tam byłoby nazwą funkcji wpisaną w plik, który trafia także do
+   obrazu bez tego modułu. #}
+{% if can(request, 'ai') %}
+<button type="submit" name="action" value="prompt" class="ghost">Generuj prompt (AI)</button>
+<button type="submit" name="action" value="horoscope">Napisz horoskop (AI)</button>
+{% endif %}

services/presentation/app/moduly/dodatki/templates/_dodatki_timeline_formularz.html

@@ -0,0 +1,4 @@
+{# Wstawka modułu. Sprawdzenie uprawnienia siedzi TUTAJ, a nie w szablonie
+   wspólnym: tam byłoby nazwą funkcji wpisaną w plik, który trafia także do
+   obrazu bez tego modułu. #}
+{% if can(request, 'ai') %}{% include "_prompt_block.html" %}{% endif %}

services/presentation/app/moduly/dodatki/templates/_dodatki_timeline_skrypty.html

@@ -0,0 +1,9 @@
+{# Wstawka modułu. Sprawdzenie uprawnienia siedzi TUTAJ, a nie w szablonie
+   wspólnym: tam byłoby nazwą funkcji wpisaną w plik, który trafia także do
+   obrazu bez tego modułu. #}
+{% if can(request, 'ai') %}
+<script src="{{ static('models.js') }}"></script>
+<script src="{{ static('progress.js') }}"></script>
+{# po progress.js — nasłuchuje zdarzenia, które tamten wysyła po gotowym horoskopie #}
+<script src="{{ static('predictions.js') }}"></script>
+{% endif %}

services/presentation/app/moduly/dodatki/templates/_dodatki_timeline_style.html

@@ -0,0 +1,4 @@
+{# Wstawka modułu. Sprawdzenie uprawnienia siedzi TUTAJ, a nie w szablonie
+   wspólnym: tam byłoby nazwą funkcji wpisaną w plik, który trafia także do
+   obrazu bez tego modułu. #}
+{% if can(request, 'ai') %}<link rel="stylesheet" href="{{ static('x-ai.css') }}">{% endif %}

services/presentation/app/moduly/dodatki/templates/_prompt_block.html

@@ -36,4 +36,6 @@
   sieć</strong>. Możesz najpierw obejrzeć prompt, a dopiero potem wysłać.
 </p>
 
-<div id="promptResult">{% include "_prompt_result.html" %}</div>
+{# Wspólny handler nie zna nazwy „prompt_result" — oddaje wynik pod neutralnym
+   „wynik_dodatku". Tłumaczenie nazwy należy do modułu. #}
+<div id="promptResult">{% with prompt_result = wynik_dodatku %}{% include "_prompt_result.html" %}{% endwith %}</div>

services/presentation/app/moduly/dodatki/trasy.py

@@ -0,0 +1,85 @@
+"""Trasy wnoszone przez moduł. Bez tego katalogu w obrazie nie istnieją."""
+from __future__ import annotations
+
+import json
+from typing import Any
+
+import httpx
+from fastapi import Form
+from fastapi.responses import JSONResponse, StreamingResponse
+
+from app.moduly.dodatki import katalog, klient
+
+_logic: Any = None
+_szablony: Any = None
+_buduj_utc: Any = None
+_blad: Any = None
+
+
+def zamontuj(app, *, logic: Any, templates: Any, buduj_utc: Any, blad: Any,
+             **_reszta) -> None:
+    """Podpięcie tras i przekazanie modułowi tego, czego potrzebuje.
+
+    Zależności przychodzą z zewnątrz, zamiast być importowane: moduł nie może
+    importować `app.main`, bo to cykl — a przede wszystkim dlatego, że zależność
+    ma iść w JEDNĄ stronę. Aplikacja wie o istnieniu modułów opcjonalnych
+    (przez neutralny most), moduł nie wie nic o aplikacji.
+    """
+    # `**_reszta` CELOWO: most podaje wszystkim modułom ten sam zestaw zależności,
+    # a każdy bierze z niego to, czego potrzebuje. Bez tego dołożenie zależności
+    # dla jednego modułu wywracałoby pozostałe.
+    global _logic, _szablony, _buduj_utc, _blad
+    _logic, _szablony, _buduj_utc, _blad = logic, templates, buduj_utc, blad
+    katalog.ustaw_zaleznosci(logic=logic, templates=templates)
+
+    @app.post("/horoscope/stream")
+    def horoscope_stream(                                    # noqa: ANN202
+        profile: str = Form("natal"),
+        date: str = Form(...),
+        time: str = Form(...),
+        tz_offset: float = Form(0.0),
+        lat: float = Form(0.0),
+        lon: float = Form(0.0),
+        prompt_budget: str = Form("medium"),
+        llm_provider: str = Form("local"),
+        llm_model: str = Form(""),
+        from_date: str = Form(""),
+        to_date: str = Form(""),
+    ):
+        """Przekazuje strumień postępu z logiki i DOKLEJA gotowy HTML wyniku.
+
+        Dzięki temu okno postępu wstawia dokładnie ten sam widok, który
+        wyrenderowałoby przeładowanie strony — jedno źródło prawdy dla wyglądu.
+        """
+        try:
+            iso_utc, _ = _buduj_utc(date, time, tz_offset)
+        except ValueError as e:
+            return JSONResponse({"detail": f"Niepoprawne dane wejściowe: {e}"},
+                                status_code=422)
+
+        payload: dict = {
+            "profile": profile, "when_utc": iso_utc, "lat": lat, "lon": lon,
+            "budget": prompt_budget, "provider": llm_provider, "model": llm_model,
+        }
+        if profile == "period" and from_date and to_date:
+            payload["from_date"], payload["to_date"] = from_date, to_date
+
+        def relay():
+            try:
+                for raw in klient.strumien(_logic, payload):
+                    try:
+                        event = json.loads(raw)
+                    except ValueError:
+                        continue
+                    if event.get("type") == "result":
+                        event["html"] = _szablony.get_template("_prompt_result.html").render(
+                            prompt_result=event.get("result") or {}
+                        )
+                    yield json.dumps(event, ensure_ascii=False) + "\n"
+            except httpx.HTTPError as e:
+                yield json.dumps({"type": "error", "message": _blad(e)},
+                                 ensure_ascii=False) + "\n"
+
+        return StreamingResponse(relay(), media_type="application/x-ndjson",
+                                 headers={"Cache-Control": "no-store",
+                                          "X-Accel-Buffering": "no"})

services/presentation/app/moduly/eksport/__init__.py

@@ -0,0 +1,13 @@
+"""Wynoszenie treści na zewnątrz: arkusz z wynikami i raport w PDF-ie.
+
+Moduł ODŁĄCZALNY. Jest w obrazie astrololo; w produktach, które nie mają wynosić
+treści baz poza program, nie ma go wcale — a nie ma go jak włączyć, bo nie ma
+czego. Eksport wynosi NAJWIĘCEJ treści naraz, więc „można, ale nie temu kontu"
+i „nie ma takiej możliwości" to dwie różne gwarancje.
+"""
+from __future__ import annotations
+
+from app.moduly.eksport.katalog import AKCJE, FUNKCJA, TRASY, obsluz
+from app.moduly.eksport.trasy import zamontuj
+
+__all__ = ["AKCJE", "FUNKCJA", "TRASY", "obsluz", "zamontuj"]

services/presentation/app/moduly/eksport/katalog.py

@@ -0,0 +1,47 @@
+"""Co moduł wnosi: funkcję, trasy i akcję formularza."""
+from __future__ import annotations
+
+from typing import Any
+
+from fastapi.responses import Response
+
+FUNKCJA: tuple[tuple[str, str, str, str], ...] = (
+    ("export", "Eksport plików",
+     "Pobieranie raportu jako PDF i wyników jako arkusz.", "Rozszerzenia"),
+)
+
+TRASY: dict[tuple[str, str], str] = {("POST", "/compile/pdf"): "export"}
+
+# Akcja formularza: nazwa → wymagane uprawnienie.
+AKCJE: dict[str, str] = {"export": "export"}
+
+# Wstrzykiwane przy montowaniu — moduł nie importuje aplikacji.
+_logic: Any = None
+_security: Any = None
+_licz_rekordy: Any = None
+
+
+def ustaw_zaleznosci(*, logic: Any, security: Any, licz_rekordy: Any) -> None:
+    global _logic, _security, _licz_rekordy
+    _logic, _security, _licz_rekordy = logic, security, licz_rekordy
+
+
+def obsluz(akcja: str, *, iso_utc: str = "", lat: float = 0.0, lon: float = 0.0,
+           request: Any = None, group: bool = False, **_reszta) -> Response | None:
+    # Wszystko po `akcja` ma wartość domyślną CELOWO: most woła po kolei każdy
+    # moduł, także z ekranu, który tych danych nie ma. Brakujący argument
+    # wywracałby wtedy ekran, zamiast po prostu nie pasować do akcji.
+    if akcja not in AKCJE:
+        return None
+    # Arkusz roboczy z wynikami (DAN-23/PRE-10) — pobranie pliku, nie strona.
+    from app.moduly.eksport.arkusz import report_to_xlsx
+
+    report = _logic.report(when_utc_iso=iso_utc, lat=lat, lon=lon, group=group)
+    # Eksport wynosi NAJWIĘCEJ treści baz naraz — tym bardziej ma zostawiać ślad
+    # w dzienniku (PRE-17): sama liczba rekordów, nigdy treść.
+    _security.audit_records(request, _licz_rekordy(report))
+    return Response(
+        content=report_to_xlsx(report),
+        media_type="application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+        headers={"Content-Disposition": 'attachment; filename="interpretacje.xlsx"'},
+    )

services/presentation/app/moduly/eksport/trasy.py

@@ -0,0 +1,114 @@
+"""Trasy wnoszone przez moduł. Bez tego katalogu w obrazie nie istnieją."""
+from __future__ import annotations
+
+from typing import Any
+
+import httpx
+from fastapi.responses import JSONResponse, Response
+
+from app.moduly.eksport import katalog
+
+_logic: Any = None
+_szablony: Any = None
+_buduj_utc: Any = None
+_blad: Any = None
+_kolo: Any = None
+
+
+def zamontuj(app, *, logic: Any, templates: Any, buduj_utc: Any, blad: Any,
+             security: Any = None, licz_rekordy: Any = None, kolo: Any = None,
+             **_reszta) -> None:
+    """Podpięcie trasy i przekazanie zależności. Idą z zewnątrz, bo zależność ma
+    biec w JEDNĄ stronę: aplikacja wie o modułach opcjonalnych (przez neutralny
+    most), moduł nie wie nic o aplikacji."""
+    global _logic, _szablony, _buduj_utc, _blad, _kolo
+    _logic, _szablony, _buduj_utc, _blad = logic, templates, buduj_utc, blad
+    _kolo = kolo
+    katalog.ustaw_zaleznosci(logic=logic, security=security, licz_rekordy=licz_rekordy)
+
+    # Nazwy, których używa przeniesiona trasa. `chartwheel` to czysty rysownik
+    # bez stanu, więc importujemy go wprost — wstrzykiwanie ma sens dla rzeczy
+    # związanych z aplikacją (klient, szablony), nie dla funkcji rysujących.
+    from app import chartwheel as chartwheel_mod
+
+    _build_utc = buduj_utc
+    _logic_error = blad
+
+    @app.post("/compile/pdf")
+    def compile_pdf(payload: dict):
+        """Składa raport PDF (PRE-24) — woła usługę render po szyfrowanym łączu.
+
+        Wejście z przeglądarki, bo część kawałków (interpretacja natalna i predykcje)
+        mieszkają w magazynie lokalnym. Kosmogram i tabele liczymy TU, żeby PDF
+        zawierał dokładnie to, co widać na stronie.
+
+        Kosmogram idzie w motywie DRUKU: samodzielny konwerter SVG→PDF nie zna
+        naszego arkusza, więc zmienne CSS i font glifów muszą być w samym rysunku.
+        """
+        from fastapi.responses import Response
+
+        from app.clients.render_client import RenderClient
+
+        data = payload.get("data") or {}
+        try:
+            iso_utc, label = _build_utc(
+                str(data.get("date") or ""), str(data.get("time") or ""),
+                float(data.get("tz_offset") or 0.0),
+            )
+        except (ValueError, TypeError) as e:
+            return JSONResponse({"detail": f"Niepoprawne dane wejściowe: {e}"}, status_code=422)
+
+        figures: list[dict] = []
+        warnings: list[str] = []
+        try:
+            chart = logic.positions(
+                when_utc_iso=iso_utc,
+                lat=float(data.get("lat") or 0.0), lon=float(data.get("lon") or 0.0),
+                house_system=str(data.get("house_system") or "whole_sign"),
+                house_systems=[s for s in (data.get("house_systems") or []) if s],
+                aspect_orb=float(data.get("aspect_orb") or 8.0),
+                aspect_luminary_bonus=float(data.get("aspect_luminary_bonus") or 2.0),
+                aspect_minor=bool(data.get("aspect_minor")),
+                stations=bool(data.get("stations")), tables=bool(data.get("tables")),
+                zodiac=str(data.get("zodiac") or "tropical"),
+            )
+            # Fallback systemu domów musi dojechać do PDF-a — z samego kosmogramu
+            # nie da się poznać, że podział jest z innego systemu, niż zamówiono.
+            warnings = [w for w in (chart.get("house_warnings") or []) if w]
+
+            from app import chartwheel
+
+            # Zasada: co pokazujemy na stronie, ma trafić do PDF-a. Wszystkie rysunki
+            # w motywie DRUKU — samodzielny konwerter SVG→PDF nie zna arkusza, więc
+            # zmienne CSS i font glifów muszą być wprost w rysunku.
+            for svg, caption in (
+                (chartwheel.render(chart, theme="print",
+                                  orientation=str(data.get("wheel_orientation") or chartwheel_mod.ASC_LEFT)),
+                 "Kosmogram"),
+                (chartwheel.render_aspectarian(chart, theme="print"), "Aspektarian — siatka aspektów"),
+                (chartwheel.render_declination(chart, theme="print"), "Wykres deklinacji"),
+                (chartwheel.render_antiscia(chart, theme="print"), "Oś antyscji"),
+            ):
+                if svg:
+                    figures.append({"svg": svg, "caption": caption})
+        except httpx.HTTPError as e:
+            # Brak rysunków nie może zablokować raportu — tekst jest ważniejszy.
+            data = {**data, "wheel_error": _logic_error(e)}
+
+        report = {
+            "person": payload.get("person") or "",
+            "data": {**data, "moment_utc": label},
+            "figures": figures,
+            "warnings": warnings,
+            "natal": payload.get("natal") or {},
+            "predictions": payload.get("predictions") or [],
+        }
+        try:
+            pdf = RenderClient().pdf(report)
+        except httpx.HTTPError as e:
+            return JSONResponse(
+                {"detail": f"Usługa render niedostępna albo nie złożyła PDF-a: {e}"},
+                status_code=502,
+            )
+        return Response(content=pdf, media_type="application/pdf",
+                        headers={"Content-Disposition": 'attachment; filename="raport.pdf"'})

services/presentation/app/podstawa.py

@@ -0,0 +1,284 @@
+"""Podstawa aplikacji: wspólne obiekty i pomocnicy, z których korzystają ekrany.
+
+Tu mieszka to, co ma KAŻDY produkt zbudowany z tego kodu: obiekt aplikacji,
+szablony, klient warstwy logicznej, serwowanie zasobów i garść funkcji
+pomocniczych. Ani jednej trasy ekranu — te są w `app/ekrany/*.py`, po jednym
+module na ekran, a o tym, które wchodzą, decyduje lista importów w `main.py`.
+
+Dlaczego tak: dopóki wszystko siedziało w jednym pliku, „produkt bez tego ekranu"
+znaczyło „produkt z ekranem, tylko zablokowanym". Plik i tak jechał do obrazu,
+razem z nazwami funkcji, których nie było jak włączyć.
+"""
+# build-marker: 2026-07-25 wymuszenie nowego obrazu po incydencie z tagiem :latest
+from __future__ import annotations
+
+import hashlib
+import logging
+import re
+from datetime import datetime, timedelta, timezone
+from functools import lru_cache
+from pathlib import Path
+
+from fastapi import FastAPI, HTTPException, Request
+from fastapi.responses import Response
+from fastapi.templating import Jinja2Templates
+
+
+from app import rozszerzenia
+from app import chartwheel as chartwheel_mod
+from app import features
+from app import produkt
+from app import session
+from app.house_systems import HOUSE_SYSTEMS, LIMITED as HOUSE_LIMITED, label as house_label
+
+from app import geocode, security
+from app.clients.logic_client import LogicClient
+from app.config import DEFAULT_LOCATION_LABEL, default_form
+
+# Automatyczna dokumentacja WYŁĄCZONA. /docs, /redoc i /openapi.json wypisują
+# KOMPLET tras aplikacji — czyli spis wszystkich funkcji, łącznie z tymi, o których
+# konto ograniczone nie ma prawa wiedzieć (PRE-27). Ochrona zakładek nic by nie dała,
+# gdyby obok leżał ich katalog. Znalezione testem przechodzącym po trasach aplikacji.
+app = FastAPI(title="astrololo · warstwa prezentacji",
+              docs_url=None, redoc_url=None, openapi_url=None)
+# Katalogi modułów opcjonalnych idą PRZED wspólnym: moduł może dołożyć szablon,
+# którego wspólny zestaw nie ma. Wspólne szablony wołają je przez neutralne
+# gniazda `{% include "_dodatki_*" ignore missing %}` — bez modułu gniazdo jest
+# po prostu puste, a nie „wyłączone".
+templates = Jinja2Templates(directory=[*rozszerzenia.katalog_szablonow(), "app/templates"])
+# Szczegóły awarii idą TUTAJ, nie na ekran (patrz _logic_error).
+log = logging.getLogger("astrololo.prezentacja")
+logic = LogicClient()
+security.install(app)          # logowanie + limit żądań (LOG-32)
+
+
+# ── cache-busting statyki (PRE-27) ─────────────────────────────────────────
+# Po deployu przeglądarka trzymała stare styles.css / *.js (ten sam URL → cache).
+# Doklejamy do URL-a krótki HASH TREŚCI pliku: zmieni się plik → zmieni się URL →
+# przeglądarka pobierze nowy; bez zmian URL zostaje ten sam (cache działa dalej).
+# Hash liczony raz na proces (lru_cache) — nowy pod po deployu = świeży hash.
+_STATIC_DIR = Path("app/static")
+
+
+_TYPY_ZASOBOW = {
+    ".css": "text/css; charset=utf-8",
+    ".js": "application/javascript; charset=utf-8",
+    ".svg": "image/svg+xml",
+    ".png": "image/png",
+    ".woff2": "font/woff2",
+}
+
+
+def _bez_komentarzy(tresc: str, sufiks: str) -> str:
+    """Usuwa komentarze z arkusza albo skryptu przed wysłaniem.
+
+    Komentarz w pliku statycznym jedzie do przeglądarki bajt w bajt, a te
+    komentarze opisują funkcje pełnym zdaniem po polsku — łącznie z tym, czego
+    konto ograniczone NIE widzi i kto to widzi. Zostają w repozytorium, bo tam
+    są potrzebne; do odpowiedzi nie mają po co trafiać.
+
+    Kasujemy tylko komentarze blokowe i CAŁE wiersze `//`. Komentarz na końcu
+    wiersza zostaje CELOWO: żeby go usunąć, trzeba rozpoznać, czy `//` nie jest
+    w napisie albo w wyrażeniu regularnym — a pomyłka tutaj psuje skrypt po
+    cichu. Test pilnuje słownika zakazanych słów, więc reszta by i tak wyszła.
+    """
+    tresc = re.sub(r"/\*.*?\*/", "", tresc, flags=re.S)
+    if sufiks == ".js":
+        tresc = re.sub(r"(?m)^[ \t]*//.*$\n?", "", tresc)
+    return re.sub(r"\n{3,}", "\n\n", tresc).strip() + "\n"
+
+
+@lru_cache(maxsize=None)
+def _asset_body(name: str) -> bytes | None:
+    """Treść zasobu tak, jak pójdzie na drut — albo None, gdy go nie ma."""
+    for katalog in (*rozszerzenia.katalog_zasobow(), str(_STATIC_DIR)):
+        korzen = Path(katalog).resolve()
+        sciezka = (Path(katalog) / name).resolve()
+        # Wyjście poza katalog zasobów: `..` w ścieżce albo dowiązanie na zewnątrz.
+        if korzen in sciezka.parents and sciezka.is_file():
+            break
+    else:
+        return None
+    surowe = sciezka.read_bytes()
+    sufiks = sciezka.suffix.lower()
+    # Kod obcy zostaje nietknięty: minifikowany plik potrafi mieć `//` w napisie
+    # albo w wyrażeniu regularnym, a on i tak nie mówi nic o naszym programie.
+    if sufiks in (".css", ".js") and not name.startswith("vendor/"):
+        try:
+            return _bez_komentarzy(surowe.decode("utf-8"), sufiks).encode("utf-8")
+        except UnicodeDecodeError:
+            return surowe
+    return surowe
+
+
+@lru_cache(maxsize=None)
+def _asset_version(name: str) -> str:
+    tresc = _asset_body(name)
+    # Hash liczony z treści WYSYŁANEJ, nie z pliku na dysku: inaczej zmiana
+    # samego komentarza podbijałaby adres, choć odpowiedź jest ta sama.
+    return hashlib.md5(tresc).hexdigest()[:8] if tresc is not None else "0"
+
+
+def static_url(name: str) -> str:
+    return f"/static/{name}?v={_asset_version(name)}"
+
+
+@app.get("/static/{nazwa:path}")
+def static_file(nazwa: str):
+    """Zasoby idą przez bramkę uprawnień jak każda inna trasa.
+
+    Dopóki `/static/` było w PUBLIC_PREFIXES, katalog omijał całe sprawdzanie:
+    ukrycie przycisku w szablonie nic nie dawało, bo obok leżał skrypt tej samej
+    funkcji, pod nazwą, którą wystarczyło zgadnąć. Uprawnienie zasobu sprawdza
+    middleware (features.static_required); tutaj zostaje samo wydanie pliku.
+    """
+    tresc = _asset_body(nazwa)
+    if tresc is None:
+        raise HTTPException(status_code=404)
+    return Response(
+        tresc,
+        media_type=_TYPY_ZASOBOW.get(Path(nazwa).suffix.lower(), "application/octet-stream"),
+        # Adres niesie hash treści, więc wersja pod danym adresem jest niezmienna.
+        headers={"Cache-Control": "public, max-age=31536000, immutable"},
+    )
+
+
+# Nazwa produktu z modułu, nie z szablonu: szablony są wspólne dla kilku
+# produktów, a nazwa nie.
+templates.env.globals["produkt"] = produkt.NAZWA
+templates.env.globals["static"] = static_url
+# Pozycje specjalne przefiltrowane uprawnieniem — szablon dostaje gotową listę
+# i nie musi wiedzieć, czego która wymaga.
+templates.env.globals["nav_extra"] = lambda request: [
+    (k, a, e) for k, a, e, u in features.NAWIGACJA_SPECJALNA
+    if features.can(_perms(request), u)]
+# Katalog systemów domów — jedno źródło nazw dla wszystkich szablonów.
+templates.env.globals["HOUSE_SYSTEMS"] = HOUSE_SYSTEMS
+templates.env.globals["house_label"] = house_label
+templates.env.globals["HOUSE_LIMITED"] = HOUSE_LIMITED
+templates.env.globals["WHEEL_ORIENTATIONS"] = chartwheel_mod.ORIENTATIONS
+
+
+def _perms(request: Request) -> frozenset[str]:
+    """Uprawnienia zalogowanego konta — pusty zbiór, gdy nie wiadomo kto to."""
+    who = getattr(request.state, "principal", None)
+    return who.permissions if who is not None else frozenset()
+
+
+# Szablony pytają o uprawnienia PRZEZ TE DWIE FUNKCJE, nigdy o konto wprost.
+# Dzięki temu nie da się w szablonie napisać warunku na login — a to jest
+# dokładnie ten rodzaj sprytu, który po roku zostawia kogoś z dostępem, o którym
+# nikt już nie pamięta.
+templates.env.globals["nav_screens"] = lambda request: features.screens_for(_perms(request))
+# Kto jest zalogowany i czy logowanie w ogóle działa — pod przycisk wyjścia.
+templates.env.globals["current_user"] = lambda request: getattr(request.state, "user", "") or ""
+templates.env.globals["auth_on"] = security.auth_enabled
+templates.env.globals["can"] = lambda request, key: key in _perms(request)
+# Czy to konto ma uprawnienie NIENADAWALNE — czyli takie, którego nie da się
+# przyznać z żadnego ekranu. Nazwa neutralna, bo szablon jest wspólny.
+templates.env.globals["widok_diagnostyczny"] = lambda request: features.can(
+    _perms(request), features.ADMIN)
+
+
+def _limit_options(request: Request, opts: dict) -> dict:
+    """Ścina opcje, których konto nie ma prawa użyć — PO STRONIE SERWERA.
+
+    Ukrycie pola w formularzu chroni tylko przed przypadkiem. Kto zna nazwy pól,
+    wyśle je wprost — a wtedy policzyłby funkcję, której mu nie przyznano, i to
+    jeszcze zobaczyłby ją w wyniku. Granicą jest ta funkcja, nie szablon.
+
+    Wartości zastępcze są DOMYŚLNE, nie puste: konto ograniczone ma dostać
+    działający horoskop w podstawowej postaci, a nie komunikat o braku czegoś.
+    """
+    perms = _perms(request)
+    if "advanced_calc" not in perms:
+        opts.update(stations=False, tables=False, aspect_minor=False, zodiac="tropical")
+    if "houses_compare" not in perms:
+        opts.update(house_system="whole_sign", house_systems=[],
+                    wheel_orientation=chartwheel_mod.ASC_LEFT)
+    return opts
+
+
+def _landing(request: Request) -> str | None:
+    """Pierwszy ekran dostępny dla konta — dokąd odesłać z korzenia."""
+    allowed = features.screens_for(_perms(request))
+    return allowed[0].href if allowed else None
+
+
+def _build_utc(date: str, time: str, tz_offset: float) -> tuple[str, str]:
+    """Z lokalnej daty/godziny + przesunięcia strefy → moment UTC.
+
+    Zwraca (iso_utc, etykieta_czytelna). UTC = czas lokalny − offset.
+    """
+    local = datetime.fromisoformat(f"{date}T{time}")
+    utc = (local - timedelta(hours=tz_offset)).replace(tzinfo=timezone.utc)
+    label = utc.strftime("%Y-%m-%d %H:%M UTC")
+    return utc.isoformat(), label
+
+
+# Akcja formularza → uprawnienie, którego wymaga. Akcji spoza tej mapy nie
+# ograniczamy; akcja Z mapy, na którą konto nie ma prawa, jest traktowana jak
+# NIEZNANA — czyli wraca do zachowania domyślnego ekranu.
+# Akcje własne tego ekranu plus te, które wnoszą moduły opcjonalne. Aplikacja
+# nie wypisuje ich z nazwy — gdyby wypisywała, nazwa funkcji byłaby w kodzie
+# także tam, gdzie modułu nie ma.
+_AKCJE_POD_UPRAWNIENIEM = {"export": "export", **rozszerzenia.akcje()}
+
+
+def _dozwolona_akcja(request: Request, action: str, domyslna: str) -> str:
+    """Akcja, której konto nie ma prawa użyć, zachowuje się jak literówka.
+
+    NIE zwracamy błędu ani 404: komunikat „brak uprawnień do generowania" sam
+    w sobie mówiłby, że taka funkcja istnieje (PRE-27). Ukrycie przycisku chroni
+    tylko przed przypadkiem — kto zna nazwę pola, wyśle ją wprost, i to TU musi
+    się zatrzymać."""
+    wymagane = _AKCJE_POD_UPRAWNIENIEM.get(action)
+    if wymagane and wymagane not in _perms(request):
+        return domyslna
+    return action
+
+
+def _report_records(report: dict | None) -> int:
+    """Ile rekordów baz niesie raport — do dziennika audytowego (PRE-17).
+
+    Liczymy próbki we wszystkich fasetach: to one są treścią z baz. Sama liczba,
+    nigdy treść — dziennik ma pokazywać SKALĘ dostępu, nie powielać danych."""
+    total = 0
+    for o in (report or {}).get("objects") or []:
+        for f in o.get("facets") or []:
+            total += len(f.get("samples") or [])
+    return total
+
+
+# Jedno zdanie dla wszystkich awarii — i CELOWO żadnego szczegółu.
+# Poprzednia treść wypisywała na ekran nazwę endpointu (/chart/positions), nazwę
+# podsystemu („silnik efemeryd"), nazwę gałęzi rozwojowej i — przez str(wyjątku
+# httpx) — wewnętrzny adres z portem sąsiedniej usługi. Dla konta, które ma
+# widzieć wyłącznie Pliki, to był komplet: co program liczy, że stoi za nim
+# łańcuch usług, i gdzie zapukać.
+_AWARIA = "Nie udało się teraz wykonać tej operacji. Spróbuj ponownie za chwilę."
+
+
+def _logic_error(e: Exception) -> str:
+    """Komunikat dla użytkownika. Diagnostyka idzie do dziennika, nie na ekran.
+
+    Odsiew siedzi TUTAJ, a nie w siedemnastu miejscach wywołania: gdyby zależał
+    od tego, czy ktoś pamiętał przekazać uprawnienia, prędzej czy później jedno
+    wywołanie zostałoby pominięte — i nie byłoby tego jak zauważyć.
+    """
+    log.warning("warstwa logiczna: %s: %s", type(e).__name__, e)
+    return _AWARIA
+
+
+
+
+features.zarejestruj(trasy={("GET", "/health"): None})
+
+
+@app.get("/health")
+def health() -> dict:
+    # Sama „ok" — nazwa warstwy mówiła, że warstw jest więcej i jak się nazywa.
+    # Kubernetes i compose czytają wyłącznie kod odpowiedzi.
+    return {"status": "ok"}
+
+

services/presentation/app/produkt.py

@@ -0,0 +1,12 @@
+"""Nazwa produktu — to, co widzi człowiek w tytule i nagłówku.
+
+Osobny moduł, bo szablony są WSPÓLNE dla kilku produktów, a nazwa nie. Wpisana
+w szablon na sztywno jechała z nim do każdego obrazu, który go bierze — i tak
+astroklient przedstawiał się jako astrololo, czyli mówił klientowi wprost, że
+trzyma okrojoną wersję czegoś większego, i podawał frazę do wyszukania.
+
+Produkt składający się z tego rdzenia NADPISUJE ten plik swoją nakładką.
+"""
+from __future__ import annotations
+
+NAZWA = "astrololo"

services/presentation/app/rozszerzenia.py

@@ -0,0 +1,136 @@
+"""Most do modułów opcjonalnych — CELOWO nie zna ani jednej ich nazwy.
+
+Ten plik jest w KAŻDYM obrazie, także tam, gdzie nie ma żadnego modułu. Gdyby
+wymieniał moduły z nazwy, nazwa nieobecnej funkcji i tak jechałaby do obrazu,
+w którym tej funkcji nie ma — czyli dokładnie ten ślad, którego całe wydzielanie
+ma się pozbyć. Dlatego moduły są ODKRYWANE: most przechodzi po podkatalogach
+`app/moduly/` i pyta każdy, co wnosi.
+
+Gdy nie ma żadnego, wszystkie odpowiedzi są puste, a aplikacja zachowuje się
+tak, jakby takiego pojęcia nigdy nie było — nie jak aplikacja z wyłączoną
+funkcją.
+"""
+from __future__ import annotations
+
+import importlib
+import pkgutil
+from typing import Any
+
+
+def _znalezione() -> list[Any]:
+    """Moduły obecne w tym obrazie, w kolejności alfabetycznej katalogów.
+
+    Kolejność jest stała, żeby dwa obrazy z tym samym zestawem zachowywały się
+    identycznie — inaczej wynik zależałby od kolejności odczytu katalogu."""
+    try:
+        paczka = importlib.import_module("app.moduly")
+    except ImportError:
+        return []
+    znalezione = []
+    for info in sorted(pkgutil.iter_modules(paczka.__path__), key=lambda i: i.name):
+        znalezione.append(importlib.import_module(f"app.moduly.{info.name}"))
+    return znalezione
+
+
+_MODULY = _znalezione()
+DOSTEPNE = bool(_MODULY)
+
+
+def _zbierz(nazwa: str, domyslne):
+    """Wartość atrybutu z każdego modułu, który go ma."""
+    return [getattr(m, nazwa) for m in _MODULY if hasattr(m, nazwa)] or domyslne
+
+
+def funkcje() -> tuple[tuple[str, str, str, str], ...]:
+    """Pozycje do katalogu funkcji — jako surowe krotki, nie obiekty.
+
+    Surowe, bo katalog buduje `features`, a gdyby moduł importował stamtąd klasę,
+    powstałby cykl: features → most → moduł → features."""
+    out: list[tuple[str, str, str, str]] = []
+    for wartosc in _zbierz("FUNKCJA", []):
+        out.extend(wartosc)
+    return tuple(out)
+
+
+def trasy() -> dict[tuple[str, str], str]:
+    out: dict[tuple[str, str], str] = {}
+    for wartosc in _zbierz("TRASY", []):
+        out.update(wartosc)
+    return out
+
+
+def zasoby() -> dict[str, Any]:
+    out: dict[str, Any] = {}
+    for wartosc in _zbierz("ZASOBY", []):
+        out.update(wartosc)
+    return out
+
+
+def akcje() -> dict[str, str]:
+    """Akcje formularza wnoszone przez moduły: nazwa → wymagane uprawnienie."""
+    out: dict[str, str] = {}
+    for wartosc in _zbierz("AKCJE", []):
+        out.update(wartosc)
+    return out
+
+
+def pola_formularza():
+    """Zależność FastAPI deklarująca dodatkowe pola formularza.
+
+    Pola muszą być w SYGNATURZE, żeby FastAPI je odczytało, a sygnatura wspólnego
+    handlera nie może ich wymieniać. Zależność przenosi deklarację do modułu.
+
+    Gdy pola deklaruje więcej niż jeden moduł, trzeba je złożyć — a składanie
+    sygnatur w locie to kod, który psuje się cicho. Póki nikt tego nie potrzebuje,
+    mówimy o tym wprost przy starcie, zamiast budować machinerię na zapas.
+    """
+    deklarujace = _zbierz("pola", [])
+    if not deklarujace:
+        return lambda: {}
+    if len(deklarujace) > 1:
+        raise RuntimeError(
+            "Więcej niż jeden moduł deklaruje pola formularza. Trzeba je złożyć "
+            "w jedną zależność — patrz komentarz w app/rozszerzenia.py.")
+    return deklarujace[0]
+
+
+def kontekst_szablonu(request) -> dict:
+    """Co moduły dokładają do kontekstu szablonu. Bez modułów — nic."""
+    out: dict = {}
+    for funkcja in _zbierz("katalog_dla", []):
+        out.update(funkcja(request))
+    return out
+
+
+def obsluz(akcja: str, **dane):
+    """Wykonanie akcji modułu. None = żaden się do niej nie przyznaje.
+
+    Moduł może oddać słownik (trafi do kontekstu szablonu) albo gotową
+    odpowiedź HTTP — na przykład plik do pobrania, który nie jest stroną."""
+    for funkcja in _zbierz("obsluz", []):
+        wynik = funkcja(akcja, **dane)
+        if wynik is not None:
+            return wynik
+    return None
+
+
+def zamontuj(app, **zaleznosci) -> None:
+    """Podpięcie tras modułów i przekazanie im tego, czego potrzebują."""
+    for funkcja in _zbierz("zamontuj", []):
+        funkcja(app, **zaleznosci)
+
+
+def _katalogi(nazwa: str) -> list[str]:
+    import pathlib
+
+    return [str(pathlib.Path(m.__file__).parent / nazwa) for m in _MODULY
+            if (pathlib.Path(m.__file__).parent / nazwa).is_dir()]
+
+
+def katalog_szablonow() -> list[str]:
+    """Katalogi szablonów modułów — nakładane PRZED wspólnymi."""
+    return _katalogi("templates")
+
+
+def katalog_zasobow() -> list[str]:
+    return _katalogi("static")

services/presentation/app/security.py

@@ -1,7 +1,7 @@
 """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
+na wielu ścieżkach (`/significators`, `/interpret` i dalszych), 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ę.
 
@@ -24,7 +24,7 @@ DZIENNIK AUDYTOWY (PRE-17). Każde żądanie do chronionej ścieżki zostawia wp
 kto, kiedy, jaka ścieżka, status, ile rekordów (gdy handler to poda przez
 `audit_records`). To jedyny sposób, by zauważyć POWOLNE wypompowywanie bazy przez
 osobę uprawnioną — pojedyncze zapytanie wygląda niewinnie, suma już nie.
-Świadomie NIE logujemy treści żądań, promptów ani rekordów — logi to kolejny
+Świadomie NIE logujemy treści żądań ani rekordów — logi to kolejny
 nośnik wycieku; liczby i metadane wystarczą do wykrycia nadużycia.
 
 UWAGA: bez kont ochrona jest WYŁĄCZONA (zgodność wstecz i wygoda dev). Wtedy przy

services/presentation/app/session.py

@@ -175,7 +175,7 @@ def refresh(dane: dict, *, now: float | None = None) -> str | None:
 
 
 def cookie_params(secure: bool = True) -> dict:
-    """Ustawienia ciasteczka wspólne dla ustawiania i kasowania.
+    """Parametry ciasteczka wspólne dla ustawiania i kasowania.
 
     httponly — JavaScript nie ma po co go czytać, a bez tego jeden wstrzyknięty
     skrypt wynosi sesję. samesite=strict — odcina większość ataków polegających

services/presentation/app/static/compile.js

@@ -2,8 +2,10 @@
 //
 // Raport ma trzy kawałki liczone w różnych miejscach:
 //   1. horoskop        — liczy serwer przy wysłaniu tego formularza,
-//   2. interpretacja natalna — z zakładki Interpretacje (natal.js),
-//   3. predykcje okresowe    — z zakładki Kalendarz (predictions.js).
+//   2. interpretacja natalna — z zakładki Interpretacje,
+//   3. predykcje okresowe    — z zakładki Kalendarz.
+// Kawałki 2 i 3 wnosi moduł opcjonalny. Gdy go nie ma, magazynów nie ma również
+// i czytanie ich zwraca pusto — raport składa się wtedy z samego horoskopu.
 //
 // Punkty 2 i 3 mieszkają w magazynie przeglądarki, więc to tutaj je dokładamy.
 // Odczytujemy je przez API tamtych modułów, a nie sięgając wprost do
@@ -20,11 +22,11 @@
   }
 
   function readNatal() {
-    return (window.astrololoNatal && window.astrololoNatal.read()) || null;
+    return (window.kosmogramNatal && window.kosmogramNatal.read()) || null;
   }
 
   function readPredictions() {
-    return (window.astrololoPredictions && window.astrololoPredictions.read()) || [];
+    return (window.kosmogramPredictions && window.kosmogramPredictions.read()) || [];
   }
 
   function item(ok, label, hint) {
@@ -86,7 +88,7 @@
   }
 
   // ── PDF (PRE-24) ────────────────────────────────────────────────────
-  // Części od AI mieszkają w przeglądarce, więc raport składamy TU i wysyłamy
+  // Te kawałki mieszkają w przeglądarce, więc raport składamy TU i wysyłamy
   // do serwera, który dokłada kosmogram i woła usługę render.
   function formData() {
     function v(name) {

services/presentation/app/static/formsync.js

@@ -16,14 +16,14 @@
 (function () {
   'use strict';
 
-  var KEY = 'astrololo.form.v1';
+  var KEY = 'kosmogram.form.v1';
 
   // Pola wspólne dla zakładek. Nazwa pola formularza -> jak je znaleźć.
   // `geoSearch` (nazwa miejsca) nie ma atrybutu name — szukamy po id.
   // type: brak = zwykła wartość (.value); 'check' = pojedynczy checkbox (.checked);
   // 'multi' = kilka checkboxów o tej samej nazwie (lista zaznaczonych wartości).
   // Opcje (stacje, tabele, porównanie domów) są tu, żeby wybór z „Horoskopu"
-  // wędrował na „Skompiluj" — inaczej podsumowanie liczyłoby się bez nich.
+  // wędrował na kolejny ekran — inaczej podsumowanie liczyłoby się bez nich.
   var FIELDS = [
     { key: 'person',        sel: 'input[name=person]' },
     { key: 'date',          sel: 'input[name=date]' },
@@ -122,7 +122,7 @@
 
   // 5) geo.js ustawia lat/lon z mapy poza polami formularza — po takiej zmianie
   //    też chcemy zapamiętać (zdarzenie leci z „Tu i teraz" oraz z mapy)
-  document.addEventListener('astrololo:coords', function () {
+  document.addEventListener('kosmogram:coords', function () {
     setTimeout(function () { save(collect()); }, 0);
   });
 })();

services/presentation/app/static/geo.js

@@ -2,7 +2,7 @@
 // Wpina się do formularza z polami input[name=lat] / input[name=lon]:
 //  - wpisanie nazwy/adresu/POI -> /geocode -> lista trafień -> klik ustawia lat/lon,
 //  - klik na mapie lub przeciągnięcie pineski -> ustawia lat/lon + /reverse pokazuje nazwę,
-//  - „Tu i teraz" (now.js) emituje event 'astrololo:coords' -> mapa się synchronizuje.
+//  - „Tu i teraz" (now.js) emituje event 'kosmogram:coords' -> mapa się synchronizuje.
 // Bez internetu wyszukiwarka/kafelki nie działają, ale ręczne lat/lon dalej tak.
 (function () {
   function ready(fn) {
@@ -163,7 +163,7 @@
     // zostawała w nim stara, ręcznie wpisana nazwa, więc formularz pokazywał jedno
     // miejsce, a współrzędne wskazywały już inne. reverseName pyta o nazwę punktu,
     // na który faktycznie ustawiła się mapa.
-    document.addEventListener('astrololo:coords', function () {
+    document.addEventListener('kosmogram:coords', function () {
       marker.setLatLng([curLat(), curLon()]);
       map.setView([curLat(), curLon()], Math.max(map.getZoom(), 12));
       reverseName(curLat(), curLon());

services/presentation/app/static/now.js

@@ -32,7 +32,7 @@ document.addEventListener('DOMContentLoaded', function () {
       function (pos) {
         document.querySelector('input[name=lat]').value = pos.coords.latitude.toFixed(4);
         document.querySelector('input[name=lon]').value = pos.coords.longitude.toFixed(4);
-        document.dispatchEvent(new CustomEvent('astrololo:coords'));  // zsynchronizuj mapę (geo.js)
+        document.dispatchEvent(new CustomEvent('kosmogram:coords'));  // zsynchronizuj mapę (geo.js)
         say('Lokalizacja pobrana ✓');
       },
       function (err) {

services/presentation/app/static/s-compile.css

@@ -102,7 +102,7 @@ body.wheel-zoom-open { overflow: hidden; }
 .readiness .rdy-missing { color: #e0c060; }
 .report-head { margin: 1.5rem 0 .5rem; }
 .report-head h2 { margin: 0; font-size: 1.4rem; }
-/* Treść od AI bywa długa — white-space:pre-wrap zachowuje akapity modelu,
+/* Bloki tekstu bywają długie — white-space:pre-wrap zachowuje akapity
    bez przepisywania ich na HTML. */
 .report-text { white-space: pre-wrap; background: var(--panel); border: 1px solid var(--line);
                border-radius: 10px; padding: .8rem 1rem; margin-top: .4rem; line-height: 1.6; }

services/presentation/app/static/s-interpret.css

@@ -34,9 +34,3 @@ td.retro { color: #ff9b6a; font-weight: 600; }
 .geo-pin { font-size: 20px; line-height: 24px; text-align: center; }
 /* kafelki OSM są jasne — trzymamy kontrolki czytelne na ciemnym tle */
 .leaflet-control-attribution { font-size: .68rem; }
-/* Generator promptu do LLM (LOG-29/30) */
-textarea.prompt { width: 100%; margin-top: .5rem; padding: .7rem .8rem; box-sizing: border-box;
-                  background: #12132a; color: var(--ink); border: 1px solid var(--line);
-                  border-radius: 10px; font-family: ui-monospace, SFMono-Regular, Menlo, monospace;
-                  font-size: .82rem; line-height: 1.45; resize: vertical; white-space: pre; }
-textarea.prompt:focus { outline: 2px solid var(--accent); outline-offset: 1px; }

services/presentation/app/static/s-timeline.css

@@ -31,9 +31,3 @@ td.retro { color: #ff9b6a; font-weight: 600; }
 .geo-pin { font-size: 20px; line-height: 24px; text-align: center; }
 /* kafelki OSM są jasne — trzymamy kontrolki czytelne na ciemnym tle */
 .leaflet-control-attribution { font-size: .68rem; }
-/* Generator promptu do LLM (LOG-29/30) */
-textarea.prompt { width: 100%; margin-top: .5rem; padding: .7rem .8rem; box-sizing: border-box;
-                  background: #12132a; color: var(--ink); border: 1px solid var(--line);
-                  border-radius: 10px; font-family: ui-monospace, SFMono-Regular, Menlo, monospace;
-                  font-size: .82rem; line-height: 1.45; resize: vertical; white-space: pre; }
-textarea.prompt:focus { outline: 2px solid var(--accent); outline-offset: 1px; }

services/presentation/app/static/wheelzoom.js

@@ -6,7 +6,7 @@
 // rysunku ani żadnej biblioteki.
 //
 // Podpięte globalnie i osłonięte sprawdzeniem, czy koło w ogóle jest na stronie
-// — dzięki temu zadziała też na przyszłej zakładce „Skompiluj", bez zmian tutaj.
+// — dzięki temu zadziała wszędzie, gdzie koło się pojawi, bez zmian tutaj.
 (function () {
   'use strict';
 

services/presentation/app/templates/_form_options.html

@@ -1,4 +1,4 @@
-{# Opcje obliczeń — WSPÓLNE dla „Horoskop" (/) i „Skompiluj" (/compile). Jeden plik,
+{# Opcje obliczeń — WSPÓLNE dla „Horoskop" (/) i raportu zbiorczego (/compile). Jeden plik,
    bo dodawaliśmy je już 3× w dwóch formularzach i groziło rozjechaniem (regresja
    podsumowania). Wszystkie synchronizowane między zakładkami przez formsync.js. #}
 {% if can(request, 'advanced_calc') %}

services/presentation/app/templates/_result_tables.html

@@ -1,4 +1,4 @@
-{# Tabele wyniku horoskopu — używane przez „Skompiluj" (/compile), żeby
+{# Tabele wyniku horoskopu — używane przez raportu zbiorczego (/compile), żeby
    podsumowanie pokazywało dokładnie to, co policzono (regresja 2026-07-28:
    podsumowanie miało braki). Skopiowane 1:1 z sekcji tabel na „Horoskop" (/).
    TODO: przełączyć też chart.html na ten include, żeby oba widoki nie mogły się

services/presentation/app/templates/base.html

@@ -3,7 +3,7 @@
 <head>
   <meta charset="utf-8">
   <meta name="viewport" content="width=device-width, initial-scale=1">
-  <title>astrololo · {% block title %}{% endblock %}</title>
+  <title>{{ produkt }} · {% block title %}{% endblock %}</title>
   {# Arkusz wspólny niesie WYŁĄCZNIE powłokę i logowanie — wszystko, co nazywa
      jakąkolwiek funkcję, mieszka w arkuszu tej funkcji i dokłada je `styles`.
      Inaczej jeden plik, pobierany też przed zalogowaniem, byłby spisem treści
@@ -20,7 +20,7 @@
 <body>
   <main>
     <header class="topbar">
-      <h1>astrololo</h1>
+      <h1>{{ produkt }}</h1>
       {# Zakładki WYŁĄCZNIE z uprawnień konta. Nie wyszarzamy niedostępnych —
          ich po prostu nie ma, bo sama obecność wyszarzonej pozycji mówi, że
          program umie więcej, niż pokazuje (PRE-26). #}
@@ -28,9 +28,12 @@
         {% for tab in nav_screens(request) %}
         <a href="{{ tab.href }}" class="{{ 'active' if nav_active is defined and nav_active == tab.key else '' }}">{{ tab.label }}</a>
         {% endfor %}
-        {% if can(request, 'admin') %}
-        <a href="/accounts" class="{{ 'active' if nav_active is defined and nav_active == 'accounts' else '' }}">Konta</a>
-        {% endif %}
+        {# Pozycje specjalne z REJESTRU, już przefiltrowane uprawnieniem. Wpisany
+           tu na sztywno odsyłacz zostawał w produkcie, który tego ekranu nie ma —
+           razem z nazwą ekranu i martwym adresem. #}
+        {% for klucz, adres, etykieta in nav_extra(request) %}
+        <a href="{{ adres }}" class="{{ 'active' if nav_active is defined and nav_active == klucz else '' }}">{{ etykieta }}</a>
+        {% endfor %}
         {# Wyjście na końcu paska i odsunięte: to nie jest zakładka, tylko
            czynność — pomylenie go z zakładką kosztuje przypadkowe wylogowania.
            Pokazujemy też KTO jest zalogowany, bo bez tego przycisk wyjścia jest
@@ -47,11 +50,11 @@
       </nav>
     </header>
     {% block content %}{% endblock %}
-    {# Stopka wymieniała warstwy architektury i nazywała całość „widokiem
-       testowym" — czyli mówiła, że to nie jest gotowy produkt i że za nim stoi
-       łańcuch usług. Dla konta ograniczonego program ma wyglądać na kompletny,
-       więc ten opis widzi wyłącznie administrator. #}
-    {% if can(request, 'admin') %}
+    {# Stopka wymienia warstwy architektury i nazywa całość „widokiem testowym" —
+       czyli mówi, że to nie jest gotowy produkt i że za nim stoi łańcuch usług.
+       Widzi ją wyłącznie konto z uprawnieniem nienadawalnym; dla pozostałych
+       program ma wyglądać na kompletny. #}
+    {% if widok_diagnostyczny(request) %}
     <footer class="foot">
       prezentacja → logika → dane · widok testowy
     </footer>

services/presentation/app/templates/compile.html

@@ -3,7 +3,7 @@
 {% set nav_active = "compile" %}
 
 {% block styles %}<link rel="stylesheet" href="{{ static('s-compile.css') }}">
-{% if can(request, 'ai') %}<link rel="stylesheet" href="{{ static('x-ai.css') }}">{% endif %}
+{% include "_dodatki_compile_style.html" ignore missing %}
 {% endblock %}
 {% block head_scripts %}
 <script defer src="{{ static('formsync.js') }}"></script>
@@ -12,19 +12,17 @@
 {% endblock %}
 
 {% block content %}
-{# Opis raportu zależy od tego, z czego konto może go złożyć. Wersja z AI
+{# Opis raportu zależy od tego, z czego konto może go złożyć. Wersja wymieniająca
    wymieniałaby funkcje, których część kont nie ma — a wymienienie ich w zdaniu
    jest takim samym śladem jak przycisk. #}
-{% if can(request, 'ai') %}
-<p class="sub">Składa w jedno: policzony horoskop, interpretację natalną z AI oraz wszystkie
-zapamiętane predykcje okresowe. Dane pobiera z pozostałych zakładek — nie trzeba nic przepisywać.</p>
-{% else %}
-<p class="sub">Składa policzony horoskop w jeden raport. Dane pobiera z pozostałych
-zakładek — nie trzeba nic przepisywać.</p>
-{% endif %}
+{# Jedno zdanie prawdziwe niezależnie od tego, jakie moduły są w obrazie. Wariant
+   warunkowy wymieniałby funkcję z nazwy — a zdanie opisujące funkcję jest takim
+   samym śladem jak przycisk. #}
+<p class="sub">Składa w jeden raport policzony horoskop i wszystkie zapamiętane
+części. Dane pobiera z pozostałych zakładek — nie trzeba nic przepisywać.</p>
 
 {# Gotowość materiału — wypełniana po stronie przeglądarki (compile.js), bo część
-   kawałków (AI) mieszka w magazynie lokalnym, nie na serwerze. #}
+   kawałków mieszka w magazynie lokalnym, nie na serwerze. #}
 <div id="readiness"></div>
 
 <form method="post" action="/compile">
@@ -137,18 +135,9 @@ zakładek — nie trzeba nic przepisywać.</p>
     {% if result.zodiac %}· zodiak {{ result.zodiac }}{% endif %}</div>
   {% include "_result_tables.html" %}
 
-  {% if can(request, 'ai') %}
-  {# ── 4. i 5. Części od AI — wstawia przeglądarka z magazynu ───────── #}
-  <div id="reportNatal"></div>
-  <div id="reportPredictions"></div>
-  {% endif %}
+  {% include "_dodatki_compile_wyniki.html" ignore missing %}
 {% endif %}
 
-{% if can(request, 'ai') %}
-{# Magazyny wczytujemy dla ich API odczytu. Ich własne UI samo się wyłącza —
-   każdy sprawdza, czy jego kontener jest na stronie (tu go nie ma). #}
-<script src="{{ static('natal.js') }}"></script>
-<script src="{{ static('predictions.js') }}"></script>
-{% endif %}
+{% include "_dodatki_compile_skrypty.html" ignore missing %}
 <script src="{{ static('compile.js') }}"></script>
 {% endblock %}

services/presentation/app/templates/interpret.html

@@ -3,7 +3,7 @@
 {% set nav_active = "interpret" %}
 
 {% block styles %}<link rel="stylesheet" href="{{ static('s-interpret.css') }}">
-{% if can(request, 'ai') %}<link rel="stylesheet" href="{{ static('x-ai.css') }}">{% endif %}
+{% include "_dodatki_interpret_style.html" ignore missing %}
 {% endblock %}
 {% block head_scripts %}
 <script defer src="{{ static('formsync.js') }}"></script>
@@ -45,16 +45,12 @@
   {# Cały blok generowania — budżet, dostawca, model i wynik — istnieje TYLKO
      dla kont z tym uprawnieniem. Nie ukrywamy go stylem: bez uprawnienia nie ma
      go w źródle strony, razem z katalogiem modeli, który blok wstrzykuje. #}
-  {% if can(request, 'ai') %}{% include "_prompt_block.html" %}{% endif %}
-{% if can(request, 'ai') %}<p class="muted small" id="natalNote"></p>{% endif %}
+  {% include "_dodatki_interpret_formularz.html" ignore missing %}
   <div class="actions">
     <button type="button" id="nowBtn" class="ghost">Tu i teraz</button>
     <button type="submit" name="action" value="report">Szukaj interpretacji</button>
     {% if can(request, 'export') %}<button type="submit" name="action" value="export" class="ghost" title="Pobierz dopasowania jako tabelę roboczą .xlsx — do filtrowania, sortowania i zaznaczania w Excelu (PRE-10).">Pobierz Excel</button>{% endif %}
-    {% if can(request, 'ai') %}
-    <button type="submit" name="action" value="prompt" class="ghost">Generuj prompt (AI)</button>
-    <button type="submit" name="action" value="horoscope">Napisz horoskop (AI)</button>
-    {% endif %}
+    {% include "_dodatki_interpret_akcje.html" ignore missing %}
     <span id="geoNote" class="muted small"></span>
   </div>
 </form>
@@ -111,12 +107,7 @@
 
 <script src="{{ static('now.js') }}"></script>
 <script src="{{ static('copy.js') }}"></script>
-{# Skrypty obsługujące WYŁĄCZNIE generowanie przez model. Bez uprawnienia nie ma
-   ich nawet w odsyłaczach — sam adres pliku podpowiadałby, co program potrafi. #}
-{% if can(request, 'ai') %}
-<script src="{{ static('models.js') }}"></script>
-<script src="{{ static('progress.js') }}"></script>
-{# po progress.js — nasłuchuje zdarzenia o gotowej interpretacji (PRE-23) #}
-<script src="{{ static('natal.js') }}"></script>
-{% endif %}
+{# Skrypty modułów opcjonalnych. Bez modułu w obrazie gniazdo jest puste —
+   sam adres pliku podpowiadałby, co program potrafi. #}
+{% include "_dodatki_interpret_skrypty.html" ignore missing %}
 {% endblock %}

services/presentation/app/templates/logowanie.html

@@ -3,14 +3,14 @@
 <head>
   <meta charset="utf-8">
   <meta name="viewport" content="width=device-width, initial-scale=1">
-  <title>astrololo · logowanie</title>
+  <title>{{ produkt }} · logowanie</title>
   {# Ekran logowania nie dziedziczy z base.html (nie ma paska zakładek), więc
      linkuje arkusz sam. To JEDYNY arkusz publiczny — patrz features.STATIC. #}
   <link rel="stylesheet" href="{{ static('base.css') }}">
 </head>
 <body>
   <main class="login-main">
-    <header class="topbar"><h1>astrololo</h1></header>
+    <header class="topbar"><h1>{{ produkt }}</h1></header>
 
     {% if request.query_params.get('wylogowano') %}
       <p class="done-note">Wylogowano.</p>