Silnik efemeryd: EngineProvider + SkyfieldEngine + harness porównawczy

Pierwszy increment implementacji warstwy logicznej (ścieżka A).

LOG-24: interfejs EphemerisEngine z dwoma backendami — SkyfieldEngine
  (własny, permisywny: Skyfield MIT + dane JPL public domain) oraz
  RemoteEngine (klient izolowanej usługi swisseph). Fabryka + leniwa
  inicjalizacja; endpointy /chart/positions i /chart/compare.
LOG-01: pozycje obiektów (długość/szerokość ekliptyczna, prędkość,
  kierunek, formaty: w znaku / absolutny / dziesiętny).
LOG-25/28: harness porównawczy (compare.py) z progami tolerancji oraz
  wspólny kontrakt parzystości; pełen zestaw testów.
LOG-27: services/engine-swisseph — osobna, opcjonalna usługa AGPL
  (pyswisseph, tryb Moshiera), licencjonowana osobno, w compose pod
  profilem "comparison"; nie wchodzi do zamkniętego produktu.

Walidacja: SkyfieldEngine zgadza się ze Swiss Ephemeris co do ~1" dla
wszystkich 10 obiektów na horoskopie referencyjnym (30.04.1984, Warszawa);
12 testów przechodzi (silnik B pomijany gdy nieskonfigurowany).

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

.gitignore

@@ -10,6 +10,10 @@ services/data/.cache/
 *.parquet
 *.db
 
+# Cache efemeryd silnika własnego (pobierane jądra JPL, regenerowalne)
+services/logic/.ephemeris/
+*.bsp
+
 # Dane wejściowe (duże pliki Excela trzymane poza repo)
 services/data/data_files/*.xlsx
 !services/data/data_files/.gitkeep

docker-compose.yml

@@ -16,11 +16,23 @@ services:
     build: ./services/logic
     environment:
       DATA_URL: http://data:8002
+      EPHEMERIS_ENGINE: own            # silnik własny (permisywny) — domyślny
+      # adres silnika B (AGPL) używany tylko w trybie porównawczym (profil comparison)
+      ENGINE_SWISSEPH_URL: http://engine-swisseph:8003
     depends_on:
       - data
     ports:
       - "8001:8001"
 
+  # Silnik B (AGPL) — OPCJONALNY, izolowany. Startuje tylko z profilem "comparison":
+  #   docker compose --profile comparison up
+  # Nie wchodzi do domyślnego (zamkniętego) produktu — patrz services/engine-swisseph/LICENSE.
+  engine-swisseph:
+    build: ./services/engine-swisseph
+    profiles: ["comparison"]
+    ports:
+      - "8003:8003"
+
   presentation:
     build: ./services/presentation
     environment:

docs/architektura-dwoch-silnikow.md

@@ -0,0 +1,84 @@
+# Architektura dwóch silników (warstwa logiczna)
+
+Dokument roboczy. Decyzja: warstwa logiczna ma **dwie wymienne implementacje silnika obliczeń** — jedną **własną/permisywną** (ścieżka A) i jedną **opartą o AGPL** (ścieżka C, Swiss Ephemeris) — żeby od pierwszego dnia mieć **wbudowany framework porównań i walidacji**. Warstwy **prezentacji i danych pozostają wspólne i pojedyncze**; rozdwaja się wyłącznie silnik wewnątrz warstwy logicznej.
+
+---
+
+## 1. Schemat
+
+```
+            (jedna)                         (jedna, ale 2 silniki)                (jedna)
+┌──────────────────────┐        ┌─────────────────────────────────────┐        ┌──────────────────────┐
+│      PREZENTACJA      │ ─────▶ │             LOGIKA                  │ ─────▶ │        DANE          │
+│   (bez zmian)         │ ◀───── │   EngineProvider (interfejs)        │ ◀───── │   (bez zmian)        │
+└──────────────────────┘        │     ├── EngineA: własny (permisywny)│        └──────────────────────┘
+                                 │     │     Skyfield/Moshier — in-proc │
+                                 │     └── EngineB: swisseph (AGPL)     │
+                                 │           ⇢ OSOBNY proces/usługa     │
+                                 │     Komparator (dual-run + raport)   │
+                                 └─────────────────────────────────────┘
+                                                   │
+                                                   ⇢ (granica sieciowa/IPC)
+                                       ┌─────────────────────────────────┐
+                                       │  engine-swisseph (AGPL, OSOBNO)  │
+                                       │  pyswisseph / Swiss Ephemeris    │
+                                       └─────────────────────────────────┘
+```
+
+Prezentacja i dane „widzą" tylko interfejs `EngineProvider` — **nie wiedzą, który silnik liczy** (engine‑agnostic). To ta sama zasada modułowości co `DataProvider` w warstwie danych.
+
+---
+
+## 2. Po co dwa silniki
+
+1. **Wyrocznia walidacyjna od dnia zero.** Każdy wynik EngineA możemy natychmiast porównać z EngineB (Swiss Ephemeris = de‑facto standard). Bezcenne przy budowie własnego silnika od zera (primary directions, domy, węzły/Lilith).
+2. **Framework porównań.** Tryb „policz oboma i pokaż różnice" — do testów regresyjnych (CI) i do podglądu side‑by‑side w UI.
+3. **Bezpieczeństwo decyzji.** Gdyby własny silnik gdzieś odstawał, widać to od razu, a nie po miesiącach.
+
+---
+
+## 3. Izolacja licencyjna (warunek konieczny) ⚠️
+
+EngineB jest **AGPL**, więc nie może być wlinkowany w permisywny produkt. Rozwiązanie zgodne z naszą architekturą (osobne usługi jak warstwa danych):
+
+- **EngineB = osobny proces/usługa `engine-swisseph`**, wołany przez **granicę sieciową/IPC** (HTTP). Brak linkowania = brak „zarażenia" copyleftem reszty.
+- **Produkt zamknięty (dystrybucja/hosting):** prezentacja + logika(**EngineA**) + dane. **Bez** EngineB. Zero AGPL.
+- **Profil porównawczy/dev/CI:** dodatkowo uruchamiamy usługę `engine-swisseph` (AGPL, sama w sobie zgodna z AGPL — to w zasadzie cienkie API na pyswisseph). Używana wewnętrznie do porównań, nie wystawiana użytkownikom produktu.
+- **Konfiguracja** decyduje, czy EngineB jest w ogóle dostępny (`ENGINE_B_URL` ustawione lub nie).
+
+Efekt: pełny framework porównań **bez** narażania kodu i danych produktu na obowiązki AGPL (patrz `przeglad-bibliotek-i-licencji.md` oraz analiza zakresu AGPL względem baz danych).
+
+---
+
+## 4. Jak działa porównanie (dual‑run)
+
+1. To samo wejście (dane horoskopu + ustawienia) trafia do EngineA i EngineB.
+2. Komparator zestawia wyniki: pozycje obiektów, cusps domów, aspekty, daty technik.
+3. Różnice liczone z **progami tolerancji per wielkość** (np. długość ekliptyczna ≤ 1″, cusp ≤ 1″, data zdarzenia ≤ 1 min); przekroczenia oflagowane.
+4. Raport: (a) jako asercje w **CI** (regresja), (b) jako **podgląd side‑by‑side** w prezentacji na żądanie.
+
+---
+
+## 5. Wpływ na warstwy i mapowanie na wymagania
+
+| Warstwa | Zmiana |
+|---|---|
+| Prezentacja | brak (opcjonalnie: widok porównawczy side‑by‑side) |
+| Dane | brak |
+| **Logika** | `EngineProvider` + 2 backendy (EngineA in‑proc, EngineB jako klient usługi AGPL) + komparator |
+| **Nowa usługa** | `engine-swisseph` (AGPL, osobno, opcjonalna) |
+
+Wymagania (arkusz „Warstwa logiczna"):
+- **LOG‑24** — interfejs `EngineProvider` z **dwoma** backendami (zrewidowane).
+- **LOG‑25** — framework walidacyjno‑porównawczy (zrewidowane).
+- **LOG‑26** — tryb dual‑run + raport różnic (nowe).
+- **LOG‑27** — izolacja licencyjna silnika AGPL jako osobnej usługi (nowe).
+- **LOG‑28** — kontrakt parzystości silników: identyczny interfejs, te same testy (nowe).
+
+---
+
+## 6. Implikacje wdrożeniowe
+
+- **Dwa profile `docker-compose`:** `proprietary` (prezentacja+logika+dane, EngineA) i `comparison` (dodaje `engine-swisseph`).
+- **Testy kontraktowe** uruchamiane na obu silnikach (ten sam zestaw → gwarancja parzystości interfejsu).
+- **Decyzja A vs B na produkcji** pozostaje po stronie A; B nigdy nie trafia do dystrybucji zamkniętej — służy jako wzorzec i narzędzie QA.

docs/przeglad-bibliotek-i-licencji.md

@@ -0,0 +1,110 @@
+# Przegląd istniejących rozwiązań + analiza licencji
+
+Dokument roboczy. Przegląd bibliotek i programów, które mogą być przydatne dla projektu **astrololo**, ze szczególnym naciskiem na **licencje i ryzyko praw autorskich** (zgodnie z prośbą). Stan: czerwiec 2026.
+
+> ⚠️ **Najważniejszy wniosek (TL;DR).** Branżowy standard obliczeń — **Swiss Ephemeris** — oraz **wszystkie** popularne biblioteki astrologiczne, które na nim bazują (pyswisseph, kerykeion, immanuel, flatlib, swisseph-wasm), są objęte licencją **AGPL‑3.0 albo płatną licencją komercyjną**. AGPL wymusza udostępnienie **całego kodu źródłowego aplikacji** — i to także wtedy, gdy aplikacja jest tylko udostępniana przez sieć (SaaS / API / hosting online, o którym mowa w notatkach). Dla produktu zamkniętego z unikalnymi bazami kolaboratora oznacza to albo (a) zakup licencji komercyjnej Swiss Ephemeris, albo (b) zbudowanie warstwy obliczeń na permisywnym fundamencie (Skyfield MIT + dane NASA JPL = public domain) i samodzielną implementację części astrologicznej. Szczegóły i rekomendacja: sekcja 6.
+
+Legenda ryzyka: 🟢 permisywne (MIT/BSD/PD) · 🟡 wymaga uwagi/atrybucji · 🔴 copyleft/AGPL — ryzykowne dla produktu zamkniętego.
+
+---
+
+## 1. Silniki efemeryd / obliczenia astronomiczne (fundament warstwy logicznej)
+
+| Rozwiązanie | Co robi | Licencja | Komentarz / ryzyko |
+|---|---|---|---|
+| **Swiss Ephemeris** (C, Astrodienst — `aloistr/swisseph`) | De‑facto standard: pozycje obiektów, domy, aspekty, gwiazdy stałe, lots — pełna astrologia, najwyższa dokładność | **Dual: AGPL‑3.0 LUB komercyjna** (CHF 750 za pierwszą licencję + CHF 400 za każdą kolejną; ważna 99 lat) | 🔴 AGPL: użycie w usłudze sieciowej = obowiązek otwarcia całego kodu. Licencja komercyjna zdejmuje copyleft z **silnika**, ale wrappery językowe (poniżej) mają **własne** licencje — trzeba je sprawdzić osobno. Decyzję trzeba podjąć **przed** dystrybucją/uruchomieniem usługi. |
+| **pyswisseph** (`astrorigin/pyswisseph`) | Wrapper Pythona do Swiss Ephemeris | **AGPL‑3.0** | 🔴 To prawdopodobnie „kalkulator z GitHuba", o którym wiesz. Sam wrapper jest AGPL niezależnie od licencji silnika. |
+| **swisseph‑wasm** (`prolaxu/swisseph-wasm`) | Swiss Ephemeris skompilowany do WebAssembly (JS) | dziedziczy po Swiss Ephemeris (**AGPL/komercyjna**) | 🔴 Ta sama pułapka AGPL, tyle że w przeglądarce. |
+| **Skyfield** (`skyfielders/python-skyfield`) | Czysto astronomiczne pozycje planet (research‑grade), oparte o dane NASA JPL | **MIT** | 🟢 Permisywne, idealne dla produktu zamkniętego. **ALE**: tylko astronomia — **nie liczy domów, aspektów, lots ani technik**. Warstwę astrologiczną trzeba dopisać samemu. |
+| **Dane NASA JPL DE440 / DE441** | Współrzędne efemeryd (Chebyshev), źródło dla Skyfielda | Dane rządu USA — **faktycznie public domain**, swobodnie dystrybuowane | 🟢 Permisywny fundament danych. DE440: lata 1550–2650; DE441: −13200 do +17191. |
+| **Moshier ephemeris** (Steve Moshier, `moshier.net`) | Semi‑analityczna teoria, ~0,1″ dokładności, bez plików danych | **Public domain** | 🟢 Wolny od jakichkolwiek zobowiązań. Mniej dokładny niż JPL, ale dla astrologii w zupełności wystarcza. Istnieje też reimplementacja JS (`0xStarcat/Moshier-Ephemeris-JS`, MIT). |
+| **Astropy** | Astronomia ogólna (układy współrzędnych, czas) | **BSD‑3** | 🟢 Permisywne; pomocnicze (czas, transformacje), nie astrologia. |
+
+---
+
+## 2. Biblioteki astrologiczne wyższego poziomu (domy, aspekty, lots, techniki)
+
+| Rozwiązanie | Co robi | Licencja | Komentarz / ryzyko |
+|---|---|---|---|
+| **kerykeion** (`g-battaglia/kerykeion`) | Nowoczesna, utrzymywana: pozycje, domy, aspekty, wykresy SVG, synastria/tranzyty/composite | **AGPL‑3.0** | 🔴 Wymaga otwarcia projektu. Autor oferuje hostowane **Astrologer API** (REST) — korzystanie z niego **nie** narzuca copyleft na Twój kod (ale to usługa zewnętrzna, płatna, wysyłasz dane na zewnątrz). |
+| **immanuel** (`theriftlab/immanuel-python`) | Dane czytelne dla człowieka + JSON, wzorowane na astro.com / Astro Gold; na pyswisseph | **GPL‑3.0+** | 🔴 GPL (sieciowo łagodniejsze niż AGPL, ale wciąż copyleft); ciągnie AGPL‑owy pyswisseph. |
+| **flatlib** (`flatangle/flatlib`) | Astrologia tradycyjna (domy, aspekty, godności) | **kod własny: MIT** 🟢, ale **zależy od Swiss Ephemeris** 🔴 | 🟡→🔴 Sam kod flatlib jest permisywny (MIT), lecz obliczenia robi Swiss Ephemeris — więc realnie obowiązuje Cię AGPL/komercyjna SE. Słabo utrzymywane. Dobra **referencja** projektowa. |
+| **libephemeris** (`g-battaglia/libephemeris`) | API zgodne z pyswisseph, ale liczy Skyfieldem (NASA); 25 systemów domów, weryfikowane względem pyswisseph | **AGPL‑3.0** | 🔴 Ciekawe technicznie (permisywny fundament: Skyfield+JPL), ale autor wybrał AGPL → i tak copyleft. Można potraktować jako **wzorzec**, jak dołożyć domy do Skyfielda. |
+
+---
+
+## 3. JavaScript / front‑end (jeśli warstwa prezentacji będzie webowa)
+
+| Rozwiązanie | Co robi | Licencja | Komentarz / ryzyko |
+|---|---|---|---|
+| **CircularNatalHoroscopeJS** (`0xStarcat/...`) | Liczy natalny wykres (Asc/MC, domy, tropikalny/syderyczny) — **na Moshierze, bez Swiss Ephemeris** | **MIT** | 🟢 Rzadki przypadek: obliczenia astrologiczne bez „skażenia" AGPL. Dobry wzorzec/komponent dla JS. |
+| **AstroChart** (`Kibo/AstroChart`) | Renderowanie kosmogramu (SVG) — tylko rysowanie, bez efemeryd | open‑source (zweryfikować plik LICENSE) | 🟡 Brak obliczeń = brak ryzyka efemeryd. Sprawdzić dokładnie licencję przed użyciem. |
+| **swisseph‑wasm** | (jak w sekcji 1) | AGPL/komercyjna | 🔴 |
+
+---
+
+## 4. Geolokalizacja i strefy czasowe (dla pola „miejscowość → timezone → Asc/MC")
+
+Notatki opisują obliczenie strefy czasowej z większej miejscowości, potem przeliczenie dla dokładnej lokalizacji. Przydatne:
+
+| Rozwiązanie | Co robi | Licencja | Komentarz / ryzyko |
+|---|---|---|---|
+| **timezonefinder** (`jannikmi/timezonefinder`) | Strefa czasowa z lat/long, offline | **kod: MIT** 🟢 / **dane: ODbL** 🟡 | 🟡 Dane (timezone‑boundary‑builder, ODbL) — przy dystrybucji bazy wymagana atrybucja i klauzula share‑alike **dla samej bazy** (nie dla Twojego kodu). |
+| **GeoNames** (baza miejscowości) | Miejscowości + współrzędne + strefy (do dropdowna lokalizacji) | **CC‑BY 4.0** | 🟡 Wolne, ale **wymaga atrybucji** „GeoNames". Idealne do tabeli miejscowości z notatek. |
+| **IANA tz database (tzdata)** | Reguły stref i czasu letniego (DST) | **Public domain** | 🟢 W Pythonie przez `zoneinfo` (stdlib) — bez zależności. |
+
+---
+
+## 5. Pełne programy referencyjne (do nauki algorytmów, nie do kopiowania kodu)
+
+| Program | Licencja | Komentarz / ryzyko |
+|---|---|---|
+| **Astrolog** (Walter Pullen, `astrolog.org`) | **GPL‑2.0+** (od wersji 6.00) | 🔴 do kopiowania kodu (GPL), ale **bezcenny jako referencja** algorytmów (domy, dyrekcje, techniki). Opcjonalnie używa Swiss Ephemeris. Można czytać i uczyć się metod, nie wklejać kodu do produktu zamkniętego. |
+| **Maitreya / Morinus** (open‑source) | GPL (zweryfikować) | 🟡 Jw. — referencja, nie źródło kodu do zamkniętego produktu. |
+
+---
+
+## 6. Strategia licencyjna — trzy ścieżki (z rekomendacją)
+
+Wybór zależy od jednej decyzji z arkusza wymagań (**Q‑01**: produkt zamknięty/hostowany czy nie) i **Q‑07** (SQL/architektura). Przy założeniu **produktu zamkniętego z prywatnymi bazami** (co wynika z notatek — hosting online, własność kolaboratora):
+
+**Ścieżka A — permisywna, „zbuduj sam" 🟢 (rekomendowana long‑term)**
+Skyfield (MIT) + dane JPL DE440 (public domain) lub Moshier (PD) do pozycji; domy/aspekty/lots/dyrekcje implementujemy sami (wzorując się na Astrologu i libephemeris — czytając, nie kopiując).
+- ➕ Pełna swoboda licencyjna, produkt może być zamknięty i hostowany.
+- ➖ Najwięcej pracy w warstwie logicznej (ale dokładnie tę warstwę i tak projektujemy modułowo).
+
+**Ścieżka B — Swiss Ephemeris na licencji komercyjnej 🟡 (najszybsza „pełna dokładność")**
+Kupujemy licencję komercyjną SE (CHF 750) i wołamy silnik C bezpośrednio (z cienkim własnym wrapperem, by ominąć AGPL‑owy pyswisseph).
+- ➕ Od razu komplet funkcji i najwyższa dokładność; produkt zamknięty OK.
+- ➖ Koszt + formalności licencyjne; trzeba uważać, żeby nie wciągnąć AGPL‑owych wrapperów.
+
+**Ścieżka C — AGPL „na całość" 🔴 (tylko jeśli produkt może być otwarty)**
+kerykeion/immanuel/flatlib+pyswisseph — najszybszy development.
+- ➕ Gotowiec, mało kodu.
+- ➖ Wymusza **otwarcie całej aplikacji** (w tym kodu obsługującego prywatne bazy). Przy hostingu online (AGPL!) praktycznie wykluczone dla tego projektu.
+
+**Ścieżka D — hostowane API (np. Astrologer API)** jako uzupełnienie: korzystanie z REST nie narzuca copyleft, ale to zależność zewnętrzna, koszt, prywatność danych urodzeniowych i może nie pokrywać egzotycznych technik (firdaria, zodiacal releasing, warianty primary directions).
+
+> **Rekomendacja:** zarezerwować w architekturze warstwy logicznej **interfejs silnika efemeryd** (jak `DataProvider` w warstwie danych), tak by dało się podmienić backend: `MoshierEngine` / `SkyfieldEngine` (ścieżka A) ↔ `SwissEphCommercialEngine` (ścieżka B). Wtedy decyzję A vs B można podjąć później bez przepisywania logiki.
+
+---
+
+## 7. Osobna kwestia: prawa autorskie do TREŚCI baz (to NIE są licencje software!)
+
+To dotyczy zawartości baz interpretacji, nie kodu — i jest tu realne ryzyko do rozważenia:
+
+- **Bazy kolaboratora.** Jeśli to **oryginalna twórczość** współpracownika, to on jest dysponentem praw — potrzebne jasne ustalenie (umowa/licencja) na wykorzystanie ich w produkcie. To załatwia sprawę po stronie tych danych.
+- **Źródła z opublikowanych książek.** Przykładowy plik „The Encyclopaedia of Medical Astrology" to **wydana książka** (H. L. Cornell, 1933). Cyfrowy przedruk obszernych opisów interpretacyjnych z chronionego dzieła = **ryzyko naruszenia praw autorskich**, niezależnie od licencji oprogramowania. Status zależy od jurysdykcji i daty (część dawnych dzieł może być już w domenie publicznej — wymaga sprawdzenia per tytuł).
+- **Fakt vs. twórczość.** Krótkie formuły sygnifikatorów (np. „Ma Ari = …") to raczej **fakty/metoda** — trudniej objąć je prawem autorskim. Natomiast rozbudowana **proza interpretacyjna** (kolumna Effect) jest chroniona jako utwór.
+- **Zalecenie:** dla każdej bazy odnotować **proweniencję** (autor/źródło/status praw) — najlepiej jako kolumnę/metadane w warstwie danych (pasuje do `book-#per-txt`, `author`, `lang` z notatek). Oddzielić materiał: własny kolaboratora / public domain / cytowany za zgodą / wymagający usunięcia.
+
+---
+
+## Źródła
+- [Swiss Ephemeris — licencja (astro.com)](https://www.astro.com/swisseph/swephinfo_e.htm) · [LICENSE](https://www.astro.com/ftp/swisseph/LICENSE) · [repo `aloistr/swisseph`](https://github.com/aloistr/swisseph)
+- [pyswisseph (`astrorigin/pyswisseph`)](https://github.com/astrorigin/pyswisseph)
+- [kerykeion (PyPI)](https://pypi.org/project/kerykeion/) · [immanuel (PyPI)](https://pypi.org/project/immanuel/) · [flatlib LICENSE (MIT)](https://raw.githubusercontent.com/flatangle/flatlib/master/LICENSE)
+- [Skyfield (PyPI, MIT)](https://pypi.org/project/skyfield/) · [libephemeris (`g-battaglia/libephemeris`)](https://github.com/g-battaglia/libephemeris)
+- [NASA JPL DE440/DE441](https://ssd.jpl.nasa.gov/doc/de440_de441.html) · [Moshier ephemeris](http://www.moshier.net/) · [Moshier‑Ephemeris‑JS](https://github.com/0xStarcat/Moshier-Ephemeris-JS)
+- [CircularNatalHoroscopeJS](https://github.com/0xStarcat/CircularNatalHoroscopeJS) · [AstroChart (`Kibo/AstroChart`)](https://github.com/Kibo/AstroChart) · [swisseph‑wasm](https://github.com/prolaxu/swisseph-wasm)
+- [timezonefinder (PyPI, MIT)](https://pypi.org/project/timezonefinder/) · [Astrolog (Wikipedia)](https://en.wikipedia.org/wiki/Astrolog)

docs/warstwa-logiczna-analiza.md

@@ -0,0 +1,174 @@
+# Warstwa logiczna — analiza, rozwinięcie wymagań i przypisanie rozwiązań
+
+Dokument roboczy. Rozwinięcie 24 wymagań warstwy logicznej (LOG‑01…LOG‑24 z `astrololo_wymagania.xlsx`) wraz z: przypisaniem gotowych **permisywnych** rozwiązań, oceną złożoności implementacji **od zera** (bo idziemy **ścieżką A**) oraz wskazaniem, gdzie narzędzia AGPL/komercyjne (B/C) służą jako **referencja i walidacja**. Stan: czerwiec 2026.
+
+---
+
+## 0. Założenia ścieżki A
+
+**Fundament permisywny (co dostajemy „za darmo"):**
+- **Skyfield** (MIT) + dane **NASA JPL DE440/DE441** (public domain) → geocentryczne pozycje planet i Księżyca, RA/Dec, długość/szerokość ekliptyczna, prędkości, wschody/zachody, wyszukiwanie zdarzeń (stacje, powroty, syzygia).
+- **pyerfa / ERFA** (BSD; pochodna IAU SOFA) → precesja, nutacja, czas gwiazdowy (LST), nachylenie ekliptyki (obliquity) — prymitywy potrzebne do osi (Asc/MC) i ayanams.
+- **Katalog Hipparcos** (ESA, swobodnie dostępny; ładuje go Skyfield) → gwiazdy stałe.
+- **Lark / pyparsing** (MIT) → infrastruktura parsera składni sygnifikatorów.
+- **numpy / pandas** (BSD) → cała matematyka i tabele.
+
+Wniosek: **~70–80% astronomicznego fundamentu jest pokryte permisywnie**. Sami budujemy **warstwę astrologiczną** (domy, dyrekcje, techniki, parser, dopasowanie) — a jej algorytmy/wzory są **wiedzą publiczną** (opisane w literaturze astronomicznej i astrologicznej), więc **nie podlegają prawu autorskiemu** — chronione są tylko konkretne implementacje kodu. Czytamy więc Astrolog/Morinus/dokumentację Swiss Ephemeris, by **zrozumieć metodę**, a piszemy **własny** kod permisywny.
+
+**Rola ścieżek B/C (Swiss Ephemeris, Morinus, astro.com):**
+1. **Wyrocznia walidacyjna** — nasz silnik porównujemy liczbowo (do łuku sekundy) z SE/astro.com. Użycie pyswisseph **w samych testach/CI** (nie dystrybuowane, nie wystawiane użytkownikom przez sieć) **nie uruchamia obowiązków AGPL** — to legalne i bardzo przydatne.
+2. **Dane referencyjne** — tabele kontrolne (np. dla profekcji, primary directions) do testów regresyjnych.
+3. **Porównanie funkcjonalne** — które warianty technik liczy „konkurencja".
+
+Skala złożoności (implementacja od zera): **Trywialna · Niska · Średnia · Wysoka · Bardzo wysoka (XL)**.
+
+---
+
+## 1. Macierz zbiorcza
+
+| ID | Wymaganie | Gotowe permisywne (ścieżka A) | Złożoność od zera | Rola B/C |
+|----|-----------|-------------------------------|-------------------|----------|
+| LOG‑01 | Pozycje obiektów | **Skyfield** (komplet) | Niska | walidacja pozycji |
+| LOG‑02 | Taksonomia obiektów | Skyfield (planety, Księżyc), Hipparcos (gwiazdy) | **Wysoka** (true Node/Lilith, gwiazdy) | walidacja węzłów/Lilith |
+| LOG‑03 | Kierunek i stacje | Skyfield (find_discrete) | Średnia | walidacja dat stacji |
+| LOG‑04 | Systemy zodiaku / ayanamsy | Skyfield (tropikalny, RA), pyerfa (precesja) | Średnia | walidacja ayanams |
+| LOG‑05 | Systemy domów (wiele) | pyerfa (LST, obliquity); reszta własna | **Wysoka** | walidacja cusps (kluczowa) |
+| LOG‑06 | Aspekty + orby | własne (czysta matematyka) | Niska | walidacja list aspektów |
+| LOG‑07 | Aspekty pozazodiakalne | Skyfield (deklinacja) | Niska | walidacja |
+| LOG‑08 | Lots | własne (arytmetyka + DSL formuł) | Niska–Średnia | porównanie wartości |
+| LOG‑09 | **Primary Directions** | brak permisywnego | **Bardzo wysoka (XL)** | **krytyczna** (Morinus) |
+| LOG‑10 | Profekcje | własne (arytmetyka + tabele władców) | Niska–Średnia | tabela kontrolna |
+| LOG‑11 | Zod. Releasing / Firdaria / Decennials | brak permisywnego | Średnia (table‑driven) | walidacja sekwencji |
+| LOG‑12 | Returns (Solar/Lunar) | Skyfield (root‑finding) | Niska–Średnia | walidacja czasu powrotu |
+| LOG‑13 | Ascensional Times | pyerfa/własne (oblique ascension) | Średnia | tabela kontrolna |
+| LOG‑14 | Zbiorcza tabela dat | własne (orkiestracja) | Średnia | — |
+| LOG‑15 | **Parser sygnifikatorów** | Lark/pyparsing (infrastruktura) | **Wysoka** (unikalne IP) | brak referencji |
+| LOG‑16 | Precompute „atomów" | własne | Średnia | — |
+| LOG‑17 | Interpretacja „asp"/„asp±" | własne (config + LOG‑06) | Niska–Średnia | — |
+| LOG‑18 | Warstwy 1A/1B | własne (orkiestracja ↔ warstwa danych) | Średnia | — |
+| LOG‑19 | Wypis interpretacji 2B | własne (↔ DataProvider) | Średnia | — |
+| LOG‑20 | Kolumny sygnif. + „no of hits" | własne | Niska–Średnia | — |
+| LOG‑21 | Scoring siły efektu | własne (rule/data‑driven) | Średnia | — |
+| LOG‑22 | Konwersja tekst ↔ symbol | własne (tablice z notes3) | Niska | — |
+| LOG‑23 | Pozostałe wyliczenia | Skyfield (zdarzenia) | Niska | walidacja |
+| LOG‑24 | Abstrakcja silnika efemeryd | architektura | Niska | — |
+
+**Tylko 3 pozycje są naprawdę trudne:** LOG‑09 (primary directions, XL), LOG‑05 (pełny zestaw domów, Wysoka), LOG‑15 (parser — Wysoka, ale to nasze unikalne IP, więc gotowca i tak nie ma). Reszta jest Niska/Średnia, w dużej części pokryta przez Skyfield.
+
+---
+
+## 2. Rozwinięcia pogrupowane
+
+### Grupa A — Fundament astronomiczny (LOG‑01, 02, 03, 24)
+
+**LOG‑01 · Pozycje obiektów.**
+*Rozwinięcie:* długość i szerokość ekliptyczna (of‑date), prędkość (różniczkowanie pozycji), kierunek; formaty: DMS w znaku (Tau 28°12'57''), absolutne 0–360°, dziesiętne. *Ścieżka A:* Skyfield daje to wprost (`ecliptic_latlon`, prędkość z dwóch chwil). Formatowanie/podział na znaki = trywialne. *Złożoność: Niska.* *B/C:* porównać długości z astro.com do ~0,1″.
+
+**LOG‑02 · Taksonomia obiektów.**
+*Rozwinięcie:* światła+planety (Skyfield 🟢), planety nowożytne (🟢), gwiazdy stałe (precesja+ruch własny — Hipparcos w Skyfield, 🟢 średnia), obiekty wirtualne:
+- **Węzły księżycowe** — *mean* (wzór analityczny, Niska) i *true/osculating* (z wektora stanu Księżyca → elementy oskulacyjne → węzeł wstępujący; **Średnia–Wysoka**).
+- **Lilith (Black Moon = apogeum Księżyca)** — *mean* (Niska–Średnia) i *true* (oskulacyjne apogeum; **Wysoka** — tu implementacje notorycznie się różnią, walidacja względem SE obowiązkowa).
+- **Osie (Asc/MC → Dsc/IC)** — patrz LOG‑05.
+*Złożoność całości: Wysoka* (przez gwiazdy + true Node/Lilith; reszta Niska). *B/C:* SE jako wzorzec dla true Node/Lilith (różne definicje!).
+
+**LOG‑03 · Kierunek i stacje.**
+*Rozwinięcie:* znak prędkości → D/Rx; stacja = przejście prędkości przez 0 (SD vs SR z przyspieszenia); „dni od stacji ścisłej" + flaga <7 dni; „stacja umowna" jako konfigurowalny próg % ruchu typowego. *Ścieżka A:* Skyfield `find_discrete`/`find_maxima` znajduje momenty stacji; średnie prędkości precompute. *Złożoność: Średnia.* *B/C:* daty stacji z SE.
+
+**LOG‑24 · Abstrakcja silnika.**
+*Rozwinięcie:* interfejs `EphemerisEngine` z implementacjami `SkyfieldEngine` (główna, MIT+JPL), `MoshierEngine` (fallback w pełni public‑domain, bez plików danych) oraz — opcjonalnie po decyzji — `SwissEphCommercialEngine`. *Złożoność: Niska* (architektura, analogicznie do `DataProvider`). To wymaganie **spina ścieżki A/B** bez przepisywania logiki.
+
+### Grupa B — Układy odniesienia (LOG‑04, 05)
+
+**LOG‑04 · Systemy zodiaku / ayanamsy.**
+*Rozwinięcie:* tropikalny (domyślny, 🟢), syderyczny = tropikalny − ayanamsa(t) (Lahiri, Fagan‑Bradley… ~40 w SE; my zaczynamy od kilku + tabela rozszerzalna), draconic = tropikalny − długość NN (🟢 po LOG‑02), RA (Skyfield daje wprost). *Ścieżka A:* precesja z pyerfa; ayanamsy to znane stałe odniesienia + tempo precesji. *Złożoność: Średnia* (głównie tabela ayanams). *B/C:* wartości ayanams z SE.
+
+**LOG‑05 · Systemy domów (wiele, równolegle).** ⚠️ najcięższa matematyka astronomiczna.
+*Rozwinięcie:*
+- Whole Sign / Equal (Asc/MC) / Porphyry → **Niska** (trywialne podziały).
+- Placidus, Koch, Regiomontanus, Campanus, Topocentric, Alcabitus, Meridian, Morinus, Vehlow → znane wzory trygonometrii sferycznej, każdy **Średnia**, w komplecie **Wysoka** (przypadki brzegowe na wysokich szerokościach — Placidus/Koch nieokreślone za kołem podbiegunowym).
+*Ścieżka A:* Asc/MC z LST (pyerfa) + obliquity + szerokość geo (standardowe wzory). `libephemeris` (AGPL) dowodzi, że pełny zestaw 25 systemów **da się** policzyć na Skyfieldzie — czytamy go jako dowód wykonalności, ale piszemy własny kod. *Złożoność: Wysoka.* *B/C:* **walidacja cusps krytyczna** — tu kryją się błędy, szczególnie na dużych szerokościach.
+
+### Grupa C — Aspekty (LOG‑06, 07)
+
+**LOG‑06 · Aspekty + orby.**
+*Rozwinięcie:* separacja kątowa vs kąt aspektu ± orb; aplikacja/separacja z różnicy prędkości; schematy orbów (domyślne, bonus dla luminarzy, fixed, ±%, per‑planeta/szkoła); aspekt „przez znak" vs „przez stopień"; major/minor/harmonic. *Ścieżka A:* czysta matematyka na policzonych długościach — **żadna biblioteka nie jest potrzebna**. *Złożoność: Niska–Średnia* (szerokość konfiguracji, nie trudność algorytmu). *B/C:* listy aspektów z astro.com do testów.
+
+**LOG‑07 · Aspekty pozazodiakalne.**
+*Rozwinięcie:* parallel/contraparallel (po deklinacji — Skyfield 🟢), antiscia/contra‑antiscia (lustro względem osi przesileń — arytmetyka). *Złożoność: Niska.*
+
+### Grupa D — Lots (LOG‑08)
+
+**LOG‑08 · Lots.**
+*Rozwinięcie:* silnik formuł `Lot = C + A − B` z odwracaniem dzień/noc (sekta); By Degree (domyślnie) i By Sign; 7 Hermetic Lots; cały znak działa jak Lot. *Ścieżka A:* mały DSL/parser formuł + ewaluacja na policzonych pozycjach. *Złożoność: Niska–Średnia* (logika sekty prosta; trudność tkwi w **tożsamości/wariantach** Lots — to kuracja danych, nie obliczenia; patrz Q‑03). *B/C:* porównanie wartości stopni.
+
+### Grupa E — Techniki predykcyjne (LOG‑09…14)
+
+**LOG‑09 · Primary Directions.** ⚠️ **najtrudniejsze (XL).**
+*Rozwinięcie:* łuk dyrekcji (semi‑arc/Placidean, Regiomontanus, …) między sygnifikatorem a promisorem w ruchu dobowym; klucz łuk→czas (Ptolemeusz/Naibod/Cardan/Solar arc); direct/converse; mundo/zodiacal; z szerokością/bez. ~160 wariantów — robimy 5–8 (Q‑02), framework rozszerzalny. *Ścieżka A:* brak gotowca permisywnego — **w całości własna trygonometria sferyczna** + obsługa wariantów. *Złożoność: Bardzo wysoka.* *B/C:* **Morinus (GPL) słynie z dokładnych primary directions** — kluczowa wyrocznia; uwaga: nawet komercyjne programy różnią się w wariantach (do udokumentowania, który wariant odwzorowujemy).
+
+**LOG‑10 · Profekcje.**
+*Rozwinięcie:* annual (Asc +1 znak/rok, mod 12), monthly/daily, continuous (klucz, domyślnie 30°/rok), Lord of Year, Lord of Orb (kolejność chaldejska, mod 84/12). *Ścieżka A:* arytmetyka dat + tabele władców domicilnych — **bez bibliotek**. *Złożoność: Niska* (annual) *– Średnia* (continuous + Lord of Orb). *B/C:* tabela kontrolna (jak ta w notes3).
+
+**LOG‑11 · Zodiacal Releasing / Firdaria / Decennials.**
+*Rozwinięcie:* deterministyczne sekwencje okresów z tabel hellenistycznych/perskich (ZR: długości okresów Valensa + „loosing of the bond"; Firdaria: stałe sekwencje diurnal/nocturnal z podokresami; Decennials: kolejność planetarna). *Ścieżka A:* logika sekwencjonowania na tabelach — algorytmy publiczne, niepodlegające prawu autorskiemu. *Złożoność: Średnia.* *B/C:* walidacja sekwencji z SE/Astrolog.
+
+**LOG‑12 · Returns (Solar/Lunar).**
+*Rozwinięcie:* root‑finding momentu powrotu Słońca/Księżyca do długości natalnej; 2 warianty (osobny horoskop vs tranzyt do natalu); monthly revolutions (Słońce + n×30°). *Ścieżka A:* Skyfield znajduje moment (🟢), reszta = ponowne użycie LOG‑01…06. *Złożoność: Niska–Średnia.* *B/C:* czas powrotu z astro.com.
+
+**LOG‑13 · Ascensional Times.**
+*Rozwinięcie:* oblique ascension znaków wg szerokości (różnica ascensjonalna z RA) → lata życia; sumy i ułamki dla dodatkowych dat. Częściowo data‑driven (tabela DAN‑07). *Ścieżka A:* wzory powiązane z LOG‑05 (trygonometria sferyczna) + pyerfa. *Złożoność: Średnia.*
+
+**LOG‑14 · Zbiorcza tabela dat z technik.**
+*Rozwinięcie:* uruchom wszystkie techniki w zakresie czasu → jedna datowana tabela (`technique | significator | start | exact | end`), sortowanie, deduplikacja, daty dokładne (wspólny root‑finding z LOG‑12). *Ścieżka A:* orkiestracja/glue. *Złożoność: Średnia.*
+
+### Grupa F — Parser sygnifikatorów i dopasowanie (LOG‑15…20) — **rdzeń unikalnego IP**
+
+**LOG‑15 · Parser składni „Significator".** ⚠️ **Wysoka — i tak nie ma gotowca.**
+*Rozwinięcie:* gramatyka skrótów (obiekty, znaki, żywioły, jakości, domy, aspekty+cel, retro/combust/waxing/heliacal, opcje A/B, warunki, „r‑Asc", whole sign+orb); 7 poziomów złożoności — od poziomu „obiekt" po sygnifikatory opisowe/niejasne (poziomy 5–7 mogą wymagać fallbacku człowiek/AI). *Ścieżka A:* tokenizer + gramatyka PEG (Lark, MIT) + słownik SIGNIFICATORS KEY (warstwa danych) jako mapa znaczeń tokenów. *Złożoność: Wysoka* — tu idzie najwięcej oryginalnej inżynierii; to **wartość intelektualna projektu**. *B/C:* brak — nie istnieje zewnętrzny parser tej składni.
+
+**LOG‑16 · Precompute „atomów" obecnych w horoskopie.**
+*Rozwinięcie:* wygeneruj zbiór wszystkich cząstek prawdziwych dla danego horoskopu (Ma Ari, Ma fire, Ma h2, Ma opp Sa, r‑Asc Ari…); dopasowanie rekordu bazy = przynależność do zbioru. Zależy od LOG‑01…08 (policzony horoskop) + LOG‑15 (słownik). *Złożoność: Średnia* (generacja kombinatoryczna + indeks; wrażliwe wydajnościowo — łączy się z DAN‑22).
+
+**LOG‑17 · Interpretacja „asp"/„asp+"/„asp‑"/„asp malefic".**
+*Rozwinięcie:* rozwinięcie wg konfigurowalnej tabeli pomocniczej (jakie aspekty, orby, active) + LOG‑06. *Złożoność: Niska–Średnia.*
+
+**LOG‑18/19/20 · Dopasowanie i wypis.**
+*Rozwinięcie:* silnik dopasowania: atomy → zapytanie do **warstwy danych (nasz DataProvider!)** → złożenie outputu: 1A (natal, unikalny), 1B (predykcyjne z datami), 2B (wypis interpretacji tylko dla obecnych rekordów), 2 kolumny sygnifikatora (z bazy / as‑is‑in‑chart), „no of hits" (1/2/3/…/?/2+?). To **styk warstwy logicznej z danych** — pasuje do istniejącej architektury. *Złożoność: Średnia.*
+
+### Grupa G — Scoring, symbole, pozostałe (LOG‑21, 22, 23)
+
+**LOG‑21 · Scoring siły efektu.**
+*Rozwinięcie:* punktacja wg tabel relacyjnych (np. „no air" poziomy */**/***), punkty za domniemaną prawdziwość w syntezie; logika indywidualna (nie zawsze rzadkość = siła). *Ścieżka A:* silnik reguł na danych (tabele relacyjne — warstwa danych). *Złożoność: Średnia*, otwarte (autor przygotuje punktację indywidualnie).
+
+**LOG‑22 · Konwersja tekst ↔ symbol.**
+*Rozwinięcie:* dwukierunkowe mapowanie z tablic Unicode (kompletne w notes3); przechowywanie tekstem, wyświetlanie symbolami; tylko „text" Unicode, nigdy emoji; ℞ dla retro. *Złożoność: Niska* (tablice lookup). Ligatury vs 2 kolumny — patrz Q‑05 (prezentacja).
+
+**LOG‑23 · Pozostałe wyliczenia.**
+*Rozwinięcie:* tally żywiołów/jakości (trywialne), planetary day & hours (wschód/zachód ze Skyfielda + podział na 12 godzin dnia/nocy + władcy chaldejscy), stopnie krytyczne/wrażliwe (lookup), faza Księżyca (elongacja Su‑Mo), syzygia prenatalna (root‑find ostatniej pełni/nowiu przed urodzeniem), divisional (12th/9th parts — arytmetyka). *Ścieżka A:* Skyfield obsługuje zdarzenia astronomiczne. *Złożoność: Niska* (lokalnie Niska–Średnia).
+
+---
+
+## 3. Proponowana kolejność budowy (fazy)
+
+1. **Fundament (MVP silnika):** LOG‑24 (interfejs) → LOG‑01 → LOG‑02 (bez gwiazd/true‑Lilith) → LOG‑04 (tropikalny+RA) → LOG‑06/07 → LOG‑05 (Whole/Equal/Porphyry+Placidus) → LOG‑23 (podstawy). *Tu Skyfield daje ogromny skok.*
+2. **Astrologia rdzenia:** LOG‑08 (Lots) → LOG‑15 (parser) → LOG‑16 → LOG‑18/19/20 (dopasowanie ↔ warstwa danych). *Tu powstaje unikalna wartość i pełny przepływ „horoskop → interpretacje".*
+3. **Predykcja prosta:** LOG‑10 (profekcje) → LOG‑12 (returns) → LOG‑14 (agregacja) → LOG‑11 (time‑lordy) → LOG‑13.
+4. **Predykcja trudna i dopieszczenie:** LOG‑09 (primary directions, XL) → LOG‑02 dokończenie (gwiazdy, true Node/Lilith) → LOG‑04 (ayanamsy) → LOG‑21 (scoring) → LOG‑05 (pełny zestaw domów).
+
+Logika: najpierw to, co Skyfield daje tanio i co odblokowuje przepływ end‑to‑end; najtrudniejsze (primary directions, pełne domy) na koniec, gdy mamy już solidną wyrocznię walidacyjną.
+
+---
+
+## 4. Stos technologiczny (permisywny) i walidacja
+
+**Produkcyjne (ścieżka A):** Skyfield (MIT), pyerfa (BSD), dane JPL DE440 (PD) lub Moshier (PD), Lark (MIT), numpy/pandas (BSD). Zero copyleft → produkt może być zamknięty i hostowany.
+
+**Tylko dev/test (B/C jako wyrocznia — NIE w produkcie, NIE wystawiane przez sieć):** pyswisseph (AGPL) i Morinus (GPL) do porównań liczbowych w testach regresyjnych. To legalne, bo nie dystrybuujemy ich i nie udostępniamy użytkownikom — AGPL/GPL nie zostają uruchomione.
+
+**Wymaganie pochodne (do dopisania w arkuszu):** **LOG‑25 — harness walidacyjny**: zestaw testów porównujących nasz silnik z SE/astro.com/Morinus na bazie znanych horoskopów (np. przykład z notes3: 30.04.1984, Warszawa), z progami tolerancji per wielkość. To nasza polisa ubezpieczeniowa przy budowie od zera.
+
+---
+
+## 5. Wniosek
+
+Ścieżka A jest **w pełni wykonalna**. Skyfield + pyerfa + JPL/Moshier zdejmują z nas całą trudną astronomię (pozycje, zdarzenia, czas gwiazdowy, precesja). Realny ciężar własnej implementacji to **trzy obszary**: primary directions (XL), pełny zestaw domów (Wysoka) i parser sygnifikatorów (Wysoka — ale unikalny, gotowca i tak nie ma). Wszystkie pozostałe wymagania są Niskie/Średnie. Narzędzia AGPL/komercyjne zostają jako **wyrocznia walidacyjna i dane referencyjne** — używane legalnie poza produktem.

services/engine-swisseph/Dockerfile

@@ -0,0 +1,10 @@
+FROM python:3.12-slim
+
+WORKDIR /app
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+
+COPY . .
+
+EXPOSE 8003
+CMD ["uvicorn", "app.main:app", "--host", "0.0.0.0", "--port", "8003"]

services/engine-swisseph/LICENSE

@@ -0,0 +1,19 @@
+Ten komponent (services/engine-swisseph) jest licencjonowany na warunkach
+GNU AFFERO GENERAL PUBLIC LICENSE wersja 3 (AGPL-3.0-or-later).
+
+Powód: linkuje bibliotekę pyswisseph / Swiss Ephemeris (Astrodienst AG), która
+jest udostępniana na zasadzie podwójnego licencjonowania: AGPL-3.0 ALBO płatna
+licencja komercyjna. Wybierając wariant AGPL, ten komponent również jest AGPL.
+
+WAŻNE — IZOLACJA: ten komponent jest celowo wydzielony jako osobny proces/usługa
+i komunikuje się z resztą systemu wyłącznie przez HTTP. Pozostałe komponenty
+projektu (warstwa prezentacji, warstwa logiczna z silnikiem własnym, warstwa
+danych) NIE są dziełem pochodnym tego komponentu ani Swiss Ephemeris i pozostają
+na licencji permisywnej. Ten komponent NIE wchodzi do dystrybucji zamkniętego
+produktu — służy jako wyrocznia walidacyjna / tryb porównawczy (dev/CI).
+
+Pełny tekst licencji AGPL-3.0: https://www.gnu.org/licenses/agpl-3.0.txt
+
+Alternatywa: zamiast wariantu AGPL można nabyć komercyjną licencję Swiss
+Ephemeris od Astrodienst AG — wówczas warunki tego komponentu należy dostosować
+do tej licencji.

services/engine-swisseph/README.md

@@ -0,0 +1,24 @@
+# engine-swisseph (silnik B — AGPL, izolowany)
+
+Osobna, **opcjonalna** usługa będąca drugim silnikiem efemeryd (LOG‑27). Liczy
+pozycje przez **pyswisseph / Swiss Ephemeris** i służy jako **wyrocznia
+walidacyjna / tryb porównawczy** (LOG‑25/26) dla naszego silnika własnego.
+
+## ⚠️ Licencja
+Ten komponent jest **AGPL‑3.0** (bo linkuje Swiss Ephemeris) — patrz [LICENSE](LICENSE).
+Jest **wydzielony jako osobny proces** i wołany przez HTTP, więc nie „zaraża"
+permisywnej reszty systemu. **Nie wchodzi do dystrybucji zamkniętego produktu.**
+
+## API
+- `POST /positions` → `{when_utc, lat, lon, objects?}` → pozycje (ten sam kształt co silnik własny)
+- `GET /health`
+
+Tryb Moshiera (`FLG_MOSEPH`) — bez plików efemeryd, zero konfiguracji.
+
+## Uruchomienie (tylko profil porównawczy / dev / CI)
+```bash
+pip install -r requirements.txt
+uvicorn app.main:app --port 8003
+```
+Następnie w warstwie logicznej ustaw `ENGINE_SWISSEPH_URL=http://localhost:8003`,
+aby włączyć silnik B (tryb dual-run i testy kontraktowe silnika B).

services/engine-swisseph/app/main.py

@@ -0,0 +1,65 @@
+"""engine-swisseph — IZOLOWANA usługa silnika B (AGPL).
+
+UWAGA LICENCYJNA: ta usługa linkuje pyswisseph / Swiss Ephemeris, więc jest
+objęta **AGPL-3.0** i jest licencjonowana osobno (patrz ./LICENSE). Jest celowo
+wydzielona jako osobny proces i wołana przez HTTP — dzięki temu permisywny
+produkt (prezentacja + logika z silnikiem własnym + dane) NIE jest linkowany z
+kodem AGPL i nie podlega jego obowiązkom (LOG-27).
+
+Rola: wyrocznia walidacyjna / tryb porównawczy (LOG-25/26). Nie wchodzi do
+dystrybucji zamkniętej — uruchamiana tylko w profilu porównawczym/dev/CI.
+
+Udostępnia ten sam kontrakt co RemoteEngine po stronie warstwy logicznej.
+"""
+from __future__ import annotations
+
+from datetime import datetime
+
+from fastapi import FastAPI
+from pydantic import BaseModel
+
+import swisseph as swe
+
+app = FastAPI(title="astrololo · engine-swisseph (AGPL, izolowany)")
+
+# Tryb Moshiera: bez plików efemeryd, w pełni samowystarczalny (~0,1\" dokładności).
+_FLAGS = swe.FLG_MOSEPH | swe.FLG_SPEED
+
+_PLANETS = {
+    "Sun": swe.SUN, "Moon": swe.MOON, "Mercury": swe.MERCURY, "Venus": swe.VENUS,
+    "Mars": swe.MARS, "Jupiter": swe.JUPITER, "Saturn": swe.SATURN,
+    "Uranus": swe.URANUS, "Neptune": swe.NEPTUNE, "Pluto": swe.PLUTO,
+}
+DEFAULT_OBJECTS = list(_PLANETS)
+
+
+class PositionsRequest(BaseModel):
+    when_utc: datetime
+    lat: float = 0.0
+    lon: float = 0.0
+    objects: list[str] | None = None
+
+
+@app.post("/positions")
+def positions(req: PositionsRequest) -> dict:
+    d = req.when_utc
+    ut_hours = d.hour + d.minute / 60.0 + d.second / 3600.0
+    jd = swe.julday(d.year, d.month, d.day, ut_hours)  # czas uniwersalny
+
+    rows = []
+    for name in (req.objects or DEFAULT_OBJECTS):
+        xx, _retflag = swe.calc_ut(jd, _PLANETS[name], _FLAGS)
+        lon, lat, _dist, lon_speed = xx[0], xx[1], xx[2], xx[3]
+        rows.append({
+            "name": name,
+            "longitude": lon % 360.0,
+            "latitude": lat,
+            "speed": lon_speed,
+            "retrograde": lon_speed < 0,
+        })
+    return {"engine": "swisseph", "positions": rows}
+
+
+@app.get("/health")
+def health() -> dict:
+    return {"engine": "swisseph", "status": "ok", "mode": "moshier", "license": "AGPL-3.0"}

services/engine-swisseph/requirements.txt

@@ -0,0 +1,6 @@
+# UWAGA: pyswisseph (Swiss Ephemeris) jest na licencji AGPL-3.0 — dlatego ta
+# usługa jest wydzielona i licencjonowana osobno (patrz LICENSE). Nie instaluj
+# tego w obrazie permisywnego produktu.
+fastapi>=0.115
+uvicorn[standard]>=0.34
+pyswisseph>=2.10

services/logic/README.md

@@ -6,8 +6,26 @@ i nie w bazie.
 
 ## API
 - `POST /api/query` → `QueryRequest` → `QueryResponse`
+- `POST /chart/positions` → `{when_utc, lat, lon, objects?}` → pozycje obiektów (LOG-01)
+- `POST /chart/compare` → jak wyżej → raport różnic dwóch silników (LOG-26; wymaga silnika B)
 - `GET /health` (sprawdza też warstwę bazodanową)
 
+## Silnik efemeryd (LOG-24, „wymienny silnik liczący")
+W `app/engine/` żyje pluggable silnik za interfejsem `EphemerisEngine`:
+- **`SkyfieldEngine`** — własny, permisywny (Skyfield MIT + dane JPL public domain). Domyślny.
+- **`RemoteEngine`** — klient OSOBNEJ, izolowanej usługi `engine-swisseph` (AGPL), używany tylko w trybie porównawczym.
+
+Wybór: `EPHEMERIS_ENGINE=own|swisseph`. Silnik B włącza się przez `ENGINE_SWISSEPH_URL`.
+
+Walidacja (LOG-25/28): `app/engine/compare.py` zestawia oba silniki z progiem tolerancji;
+ten sam kontrakt parzystości obowiązuje każdy silnik. Nasz `SkyfieldEngine` zgadza się
+ze Swiss Ephemeris **co do ~1″** na horoskopie referencyjnym (patrz `tests/`).
+
+```bash
+pip install -r requirements-dev.txt
+PYTHONPATH=. pytest tests -q            # silnik B pomijany, jeśli ENGINE_SWISSEPH_URL nieustawiony
+```
+
 ## Zależności w dół
 Zna wyłącznie `DATA_URL` (adres warstwy bazodanowej) i jej kontrakt `/search`.
 Nie wie, czy pod spodem jest Excel czy SQL.

services/logic/app/engine/base.py

@@ -0,0 +1,24 @@
+"""Interfejs silnika efemeryd (LOG-24).
+
+To jest „wymienny silnik liczący". Dziś realizują go: SkyfieldEngine (własny,
+permisywny, in-process) i RemoteEngine (klient izolowanej usługi swisseph, AGPL).
+Warstwa logiczna woła tylko ten interfejs — nie wie, który silnik liczy.
+"""
+from __future__ import annotations
+
+from abc import ABC, abstractmethod
+
+from app.engine.models import ChartMoment, ObjectPosition
+
+
+class EphemerisEngine(ABC):
+    name: str = "base"
+
+    @abstractmethod
+    def positions(
+        self, moment: ChartMoment, objects: list[str] | None = None
+    ) -> list[ObjectPosition]:
+        """Pozycje obiektów dla danego momentu (LOG-01). None = zestaw domyślny."""
+
+    def health(self) -> dict:
+        return {"engine": self.name, "status": "ok"}

services/logic/app/engine/compare.py

@@ -0,0 +1,104 @@
+"""Harness walidacyjno-porównawczy (LOG-25) i kontrakt parzystości (LOG-28).
+
+`compare_positions` zestawia wyniki dwóch silników z progami tolerancji per
+wielkość i flaguje rozbieżności — używane w testach regresyjnych (CI) i w trybie
+dual-run na żądanie (LOG-26).
+
+`check_engine_contract` to wspólny kontrakt, który MUSI spełnić każdy silnik —
+ten sam test uruchamiamy dla EngineA i EngineB (LOG-28).
+"""
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+
+from app.engine.base import EphemerisEngine
+from app.engine.models import DEFAULT_OBJECTS, ChartMoment, ObjectPosition
+
+
+def angular_delta(a: float, b: float) -> float:
+    """Najmniejsza różnica kątów w stopniach (z obsługą zawinięcia 0/360)."""
+    return ((a - b + 180.0) % 360.0) - 180.0
+
+
+@dataclass
+class ObjectDiff:
+    name: str
+    lon_a: float
+    lon_b: float
+    delta_arcsec: float        # różnica długości w sekundach łuku
+    lat_delta: float
+    speed_sign_mismatch: bool
+    over_tolerance: bool
+
+
+@dataclass
+class CompareReport:
+    lon_tol_arcsec: float
+    diffs: list[ObjectDiff] = field(default_factory=list)
+
+    @property
+    def ok(self) -> bool:
+        return not any(d.over_tolerance or d.speed_sign_mismatch for d in self.diffs)
+
+    @property
+    def max_arcsec(self) -> float:
+        return max((abs(d.delta_arcsec) for d in self.diffs), default=0.0)
+
+    def summary(self) -> dict:
+        return {
+            "ok": self.ok,
+            "objects": len(self.diffs),
+            "max_arcsec": round(self.max_arcsec, 2),
+            "tolerance_arcsec": self.lon_tol_arcsec,
+            "flagged": [d.name for d in self.diffs if d.over_tolerance or d.speed_sign_mismatch],
+        }
+
+
+def compare_positions(
+    a: list[ObjectPosition],
+    b: list[ObjectPosition],
+    lon_tol_arcsec: float = 120.0,
+) -> CompareReport:
+    by_b = {p.name: p for p in b}
+    report = CompareReport(lon_tol_arcsec=lon_tol_arcsec)
+    for pa in a:
+        pb = by_b.get(pa.name)
+        if pb is None:
+            continue
+        d_arcsec = angular_delta(pa.longitude, pb.longitude) * 3600.0
+        report.diffs.append(
+            ObjectDiff(
+                name=pa.name,
+                lon_a=pa.longitude,
+                lon_b=pb.longitude,
+                delta_arcsec=d_arcsec,
+                lat_delta=pa.latitude - pb.latitude,
+                speed_sign_mismatch=(pa.retrograde != pb.retrograde),
+                over_tolerance=abs(d_arcsec) > lon_tol_arcsec,
+            )
+        )
+    return report
+
+
+def compare_engines(
+    engine_a: EphemerisEngine,
+    engine_b: EphemerisEngine,
+    moment: ChartMoment,
+    lon_tol_arcsec: float = 120.0,
+) -> CompareReport:
+    return compare_positions(
+        engine_a.positions(moment), engine_b.positions(moment), lon_tol_arcsec
+    )
+
+
+def check_engine_contract(engine: EphemerisEngine, moment: ChartMoment) -> None:
+    """Kontrakt parzystości (LOG-28). Rzuca AssertionError przy naruszeniu."""
+    positions = engine.positions(moment)
+    names = {p.name for p in positions}
+    assert set(DEFAULT_OBJECTS) <= names, f"brakuje obiektów: {set(DEFAULT_OBJECTS) - names}"
+    for p in positions:
+        assert 0.0 <= p.longitude < 360.0, f"{p.name}: długość poza zakresem ({p.longitude})"
+        assert -90.0 <= p.latitude <= 90.0, f"{p.name}: szerokość poza zakresem ({p.latitude})"
+        assert p.retrograde in (True, False)
+        d = p.as_dict()
+        assert d["sign"] and d["in_sign"], f"{p.name}: brak formatów"

services/logic/app/engine/factory.py

@@ -0,0 +1,30 @@
+"""Fabryka silników (LOG-24) — jedyne miejsce znające konkretne implementacje.
+
+EPHEMERIS_ENGINE = own (domyślnie, permisywny Skyfield) | swisseph (zdalny AGPL).
+`available_engines()` zwraca to, co da się dziś uruchomić — używane przez
+harness porównawczy i testy parzystości.
+"""
+from __future__ import annotations
+
+import os
+
+from app.engine.base import EphemerisEngine
+
+
+def build_engine(name: str | None = None) -> EphemerisEngine:
+    name = (name or os.getenv("EPHEMERIS_ENGINE", "own")).lower()
+    if name in ("swisseph", "remote", "b"):
+        from app.engine.remote_engine import RemoteEngine
+
+        return RemoteEngine()
+    from app.engine.skyfield_engine import SkyfieldEngine
+
+    return SkyfieldEngine()
+
+
+def available_engines() -> dict[str, EphemerisEngine]:
+    """Silniki gotowe do użycia teraz (own zawsze; swisseph jeśli skonfigurowany)."""
+    engines: dict[str, EphemerisEngine] = {"own": build_engine("own")}
+    if os.getenv("ENGINE_SWISSEPH_URL"):
+        engines["swisseph"] = build_engine("swisseph")
+    return engines

services/logic/app/engine/formats.py

@@ -0,0 +1,52 @@
+"""Formatowanie długości ekliptycznej (LOG-01: kilka zapisów).
+
+Astrolog myśli w stopniach/minutach/sekundach w znaku, Excel woli dziesiętne,
+a część technik używa pozycji absolutnej 0–360°. Tu są czyste, bezstanowe
+funkcje konwersji — bez zależności od jakiegokolwiek silnika.
+"""
+from __future__ import annotations
+
+SIGNS = [
+    "Aries", "Taurus", "Gemini", "Cancer", "Leo", "Virgo",
+    "Libra", "Scorpio", "Sagittarius", "Capricorn", "Aquarius", "Pisces",
+]
+SIGN_ABBR = ["Ari", "Tau", "Gem", "Can", "Leo", "Vir",
+             "Lib", "Sco", "Sag", "Cap", "Aqu", "Pis"]
+
+
+def norm360(lon: float) -> float:
+    return lon % 360.0
+
+
+def sign_index(lon: float) -> int:
+    """0 = Aries … 11 = Pisces."""
+    return int(norm360(lon) // 30)
+
+
+def _dms(deg: float) -> tuple[int, int, int]:
+    """Rozkład stopni (>=0) na (°, ', ") z poprawnym przeniesieniem zaokrąglenia."""
+    total = round(deg * 3600)
+    d, rem = divmod(total, 3600)
+    m, s = divmod(rem, 60)
+    return d, m, s
+
+
+def in_sign(lon: float) -> str:
+    """Np. 'Tau 28°12'57\"' — pozycja w znaku."""
+    lon = norm360(lon)
+    idx = sign_index(lon)
+    d, m, s = _dms(lon - idx * 30)
+    if d >= 30:  # zaokrąglenie przekroczyło granicę znaku
+        idx = (idx + 1) % 12
+        d -= 30
+    return f"{SIGN_ABBR[idx]} {d}°{m:02d}'{s:02d}\""
+
+
+def absolute(lon: float) -> str:
+    """Np. '58°12'57\"' — pozycja absolutna 0–360°."""
+    d, m, s = _dms(norm360(lon))
+    return f"{d}°{m:02d}'{s:02d}\""
+
+
+def decimal(lon: float, places: int = 6) -> float:
+    return round(norm360(lon), places)

services/logic/app/engine/models.py

@@ -0,0 +1,64 @@
+"""Modele domenowe silnika efemeryd — wspólny kontrakt dla KAŻDEGO silnika.
+
+To jest część LOG-28 (parzystość): każdy silnik (własny Skyfield czy zdalny
+swisseph) przyjmuje `ChartMoment` i zwraca listę `ObjectPosition` w identycznym
+kształcie i jednostkach. Dzięki temu wyniki są bezpośrednio porównywalne, a
+prezentacja/dane nie wiedzą, który silnik liczył.
+"""
+from __future__ import annotations
+
+from dataclasses import dataclass
+from datetime import datetime
+from typing import Any
+
+from app.engine import formats
+
+# kanoniczny zestaw i kolejność obiektów (LOG-02: światła + 7 klasycznych + 3 nowożytne)
+DEFAULT_OBJECTS = [
+    "Sun", "Moon", "Mercury", "Venus", "Mars",
+    "Jupiter", "Saturn", "Uranus", "Neptune", "Pluto",
+]
+
+
+@dataclass(frozen=True)
+class ChartMoment:
+    """Wejście silnika: moment w UTC + lokalizacja geograficzna.
+
+    Pozycje obiektów zależą tylko od czasu (geocentrycznie); szerokość/długość
+    geograficzna będą potrzebne dopiero przy osiach i domach (LOG-05).
+    """
+
+    when_utc: datetime          # musi być świadome strefy (UTC)
+    lat: float = 0.0            # szerokość geograficzna, + na północ
+    lon: float = 0.0           # długość geograficzna, + na wschód
+
+
+@dataclass(frozen=True)
+class ObjectPosition:
+    """Wynik dla jednego obiektu — surowe wartości w jednostkach SI astrologii."""
+
+    name: str
+    longitude: float            # długość ekliptyczna 0–360° (tropikalna, of-date)
+    latitude: float             # szerokość ekliptyczna (°)
+    speed: float                # prędkość w długości (°/dobę)
+    retrograde: bool
+
+    @property
+    def sign(self) -> str:
+        return formats.SIGNS[formats.sign_index(self.longitude)]
+
+    @property
+    def direction(self) -> str:
+        return "Rx" if self.retrograde else "D"
+
+    def as_dict(self) -> dict[str, Any]:
+        return {
+            "name": self.name,
+            "sign": self.sign,
+            "in_sign": formats.in_sign(self.longitude),
+            "absolute": formats.absolute(self.longitude),
+            "decimal": formats.decimal(self.longitude),
+            "latitude": round(self.latitude, 6),
+            "speed": round(self.speed, 6),
+            "direction": self.direction,
+        }

services/logic/app/engine/remote_engine.py

@@ -0,0 +1,62 @@
+"""RemoteEngine — klient izolowanej usługi silnika (LOG-24 backend nr 2, LOG-27).
+
+Realizuje ten sam interfejs co SkyfieldEngine, ale liczenie deleguje przez HTTP
+do OSOBNEJ usługi `engine-swisseph` (AGPL). Dzięki granicy sieciowej kod AGPL
+nigdy nie jest linkowany do permisywnego produktu — patrz services/engine-swisseph.
+
+Używany tylko, gdy skonfigurowano ENGINE_SWISSEPH_URL (tryb porównawczy/dev/CI).
+"""
+from __future__ import annotations
+
+import os
+
+import httpx
+
+from app.engine.base import EphemerisEngine
+from app.engine.formats import norm360
+from app.engine.models import DEFAULT_OBJECTS, ChartMoment, ObjectPosition
+
+
+class RemoteEngine(EphemerisEngine):
+    name = "swisseph"
+
+    def __init__(self, base_url: str | None = None, timeout: float = 15.0) -> None:
+        self.base_url = (base_url or os.getenv("ENGINE_SWISSEPH_URL", "")).rstrip("/")
+        self.timeout = timeout
+
+    def positions(
+        self, moment: ChartMoment, objects: list[str] | None = None
+    ) -> list[ObjectPosition]:
+        if not self.base_url:
+            raise RuntimeError("ENGINE_SWISSEPH_URL nie ustawiony — silnik B niedostępny")
+        payload = {
+            "when_utc": moment.when_utc.isoformat(),
+            "lat": moment.lat,
+            "lon": moment.lon,
+            "objects": objects or DEFAULT_OBJECTS,
+        }
+        with httpx.Client(timeout=self.timeout) as client:
+            r = client.post(f"{self.base_url}/positions", json=payload)
+            r.raise_for_status()
+            rows = r.json()["positions"]
+        return [
+            ObjectPosition(
+                name=row["name"],
+                longitude=norm360(row["longitude"]),
+                latitude=row["latitude"],
+                speed=row["speed"],
+                retrograde=row["retrograde"],
+            )
+            for row in rows
+        ]
+
+    def health(self) -> dict:
+        if not self.base_url:
+            return {"engine": self.name, "status": "disabled"}
+        try:
+            with httpx.Client(timeout=self.timeout) as client:
+                r = client.get(f"{self.base_url}/health")
+                r.raise_for_status()
+                return {"engine": self.name, "status": "ok", "remote": r.json()}
+        except httpx.HTTPError as e:
+            return {"engine": self.name, "status": "down", "error": str(e)}

services/logic/app/engine/skyfield_engine.py

@@ -0,0 +1,92 @@
+"""SkyfieldEngine — własny, permisywny silnik (LOG-01).
+
+Ścieżka A: Skyfield (MIT) + efemerydy JPL (public domain). Liczy geocentryczne
+pozycje pozorne (apparent) i rzutuje je na ekliptykę daty → długość tropikalna,
+szerokość, prędkość i kierunek. Brak zależności AGPL.
+
+Prędkość liczymy numerycznie (różnica długości po małym kroku czasu) — wystarcza
+do kierunku (D/Rx) i do wykrywania stacji w LOG-03.
+"""
+from __future__ import annotations
+
+import os
+from datetime import timedelta
+from functools import lru_cache
+
+from app.engine.base import EphemerisEngine
+from app.engine.formats import norm360
+from app.engine.models import DEFAULT_OBJECTS, ChartMoment, ObjectPosition
+
+# nazwa obiektu -> cel w jądrze efemeryd (de421 ma centra Merkurego/Wenus,
+# dla pozostałych planet używamy barycentrów — różnica nieistotna astrologicznie)
+_TARGETS = {
+    "Sun": "sun",
+    "Moon": "moon",
+    "Mercury": "mercury",
+    "Venus": "venus",
+    "Mars": "mars barycenter",
+    "Jupiter": "jupiter barycenter",
+    "Saturn": "saturn barycenter",
+    "Uranus": "uranus barycenter",
+    "Neptune": "neptune barycenter",
+    "Pluto": "pluto barycenter",
+}
+
+
+@lru_cache(maxsize=4)
+def _load(kernel: str, data_dir: str):
+    """Wczytuje skalę czasu i jądro efemeryd raz (kosztowne) i cache'uje."""
+    from skyfield.api import Loader
+
+    load = Loader(data_dir)
+    ts = load.timescale()
+    eph = load(kernel)
+    return ts, eph, eph["earth"]
+
+
+class SkyfieldEngine(EphemerisEngine):
+    name = "skyfield"
+
+    def __init__(self, kernel: str | None = None, data_dir: str | None = None) -> None:
+        self.kernel = kernel or os.getenv("EPHEMERIS_KERNEL", "de421.bsp")
+        self.data_dir = data_dir or os.getenv(
+            "EPHEMERIS_DIR", os.path.join(os.path.dirname(__file__), "..", "..", ".ephemeris")
+        )
+        os.makedirs(self.data_dir, exist_ok=True)
+        self.ts, self.eph, self.earth = _load(self.kernel, os.path.abspath(self.data_dir))
+
+    def _ecliptic_lon_lat(self, target, t):
+        astrometric = self.earth.at(t).observe(target).apparent()
+        lat, lon, _dist = astrometric.ecliptic_latlon(epoch="date")
+        return lon.degrees, lat.degrees
+
+    def positions(
+        self, moment: ChartMoment, objects: list[str] | None = None
+    ) -> list[ObjectPosition]:
+        names = objects or DEFAULT_OBJECTS
+        t = self.ts.from_datetime(moment.when_utc)
+        dt = timedelta(hours=1)
+        t2 = self.ts.from_datetime(moment.when_utc + dt)
+
+        out: list[ObjectPosition] = []
+        for name in names:
+            target = self.eph[_TARGETS[name]]
+            lon, lat = self._ecliptic_lon_lat(target, t)
+            lon2, _ = self._ecliptic_lon_lat(target, t2)
+            # prędkość °/dobę z poprawką na przejście przez 0°/360°
+            step = ((lon2 - lon + 180.0) % 360.0) - 180.0
+            speed = step * 24.0
+            # rzutowanie na czysty float — Skyfield zwraca numpy.float64
+            out.append(
+                ObjectPosition(
+                    name=name,
+                    longitude=float(norm360(lon)),
+                    latitude=float(lat),
+                    speed=float(speed),
+                    retrograde=bool(speed < 0),
+                )
+            )
+        return out
+
+    def health(self) -> dict:
+        return {"engine": self.name, "status": "ok", "kernel": self.kernel}

services/logic/app/main.py

@@ -6,8 +6,11 @@ Nie serwuje HTML, nie czyta plików/baz — tylko reguły i pośrednictwo.
 """
 from __future__ import annotations
 
+from datetime import datetime
+
 import httpx
 from fastapi import FastAPI, HTTPException
+from pydantic import BaseModel
 
 from app.clients.data_client import DataClient
 from app.models import QueryRequest, QueryResponse
@@ -16,6 +19,25 @@ from app.service import QueryService
 app = FastAPI(title="astrololo · warstwa logiczna")
 service = QueryService()
 
+# --- silnik efemeryd (LOG-24): budowany leniwie, by nie wymagać Skyfielda do startu ---
+_engine = None
+
+
+def get_engine():
+    global _engine
+    if _engine is None:
+        from app.engine.factory import build_engine
+
+        _engine = build_engine()
+    return _engine
+
+
+class PositionsRequest(BaseModel):
+    when_utc: datetime           # moment w UTC (świadomy strefy)
+    lat: float = 0.0
+    lon: float = 0.0
+    objects: list[str] | None = None
+
 
 @app.post("/api/query", response_model=QueryResponse)
 def query(req: QueryRequest) -> QueryResponse:
@@ -25,6 +47,36 @@ def query(req: QueryRequest) -> QueryResponse:
         raise HTTPException(status_code=502, detail=f"Warstwa bazodanowa niedostępna: {e}")
 
 
+@app.post("/chart/positions")
+def chart_positions(req: PositionsRequest) -> dict:
+    """Pozycje obiektów dla danego momentu (LOG-01), liczone aktywnym silnikiem."""
+    from app.engine.models import ChartMoment
+
+    engine = get_engine()
+    moment = ChartMoment(when_utc=req.when_utc, lat=req.lat, lon=req.lon)
+    positions = engine.positions(moment, req.objects)
+    return {"engine": engine.name, "positions": [p.as_dict() for p in positions]}
+
+
+@app.post("/chart/compare")
+def chart_compare(req: PositionsRequest) -> dict:
+    """Tryb dwu-silnikowy (LOG-26): policz oboma silnikami i zwróć raport różnic.
+
+    Wymaga skonfigurowanego ENGINE_SWISSEPH_URL (silnik B). W przeciwnym razie
+    zwraca informację, że porównanie jest niedostępne.
+    """
+    from app.engine.compare import compare_engines
+    from app.engine.factory import build_engine
+    from app.engine.models import ChartMoment
+
+    moment = ChartMoment(when_utc=req.when_utc, lat=req.lat, lon=req.lon)
+    try:
+        report = compare_engines(build_engine("own"), build_engine("swisseph"), moment)
+    except (RuntimeError, httpx.HTTPError) as e:
+        raise HTTPException(status_code=503, detail=f"Silnik B niedostępny: {e}")
+    return report.summary()
+
+
 @app.get("/health")
 def health() -> dict:
     info = {"status": "ok", "layer": "logic"}

services/logic/requirements-dev.txt

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

services/logic/requirements.txt

@@ -2,3 +2,5 @@ fastapi>=0.115
 uvicorn[standard]>=0.34
 httpx>=0.28
 pydantic>=2.10
+# Silnik własny (ścieżka A, permisywny): Skyfield (MIT) + dane JPL (public domain)
+skyfield>=1.49

services/logic/tests/conftest.py

@@ -0,0 +1,31 @@
+"""Wspólne fixture'y testów silnika.
+
+Horoskop referencyjny = przykład z notatek projektu (notes3): 30.04.1984,
+09:35 CEST = 07:35 UTC, Warszawa. Pozycje znane z astro.com/Swiss Ephemeris
+służą jako wyrocznia (LOG-25).
+"""
+from __future__ import annotations
+
+import datetime as dt
+
+import pytest
+
+from app.engine.models import ChartMoment
+
+REFERENCE_UTC = dt.datetime(1984, 4, 30, 7, 35, 0, tzinfo=dt.timezone.utc)
+
+
+@pytest.fixture(scope="session")
+def reference_moment() -> ChartMoment:
+    return ChartMoment(when_utc=REFERENCE_UTC, lat=52.2333, lon=21.0167)
+
+
+@pytest.fixture(scope="session")
+def own_engine():
+    pytest.importorskip("skyfield")
+    from app.engine.skyfield_engine import SkyfieldEngine
+
+    try:
+        return SkyfieldEngine()
+    except Exception as e:  # brak efemeryd / brak sieci
+        pytest.skip(f"Nie można wczytać efemeryd: {e}")

services/logic/tests/test_compare.py

@@ -0,0 +1,35 @@
+"""Testy harnessu porównawczego (LOG-25) — bez efemeryd."""
+from app.engine.compare import compare_positions
+from app.engine.models import ObjectPosition
+
+
+def test_identical_positions_have_zero_diff():
+    a = [ObjectPosition("Sun", 40.0, 0.0, 0.95, False)]
+    report = compare_positions(a, a, lon_tol_arcsec=1.0)
+    assert report.ok
+    assert report.max_arcsec == 0.0
+
+
+def test_offset_beyond_tolerance_is_flagged():
+    a = [ObjectPosition("Sun", 40.0, 0.0, 0.95, False)]
+    b = [ObjectPosition("Sun", 40.1, 0.0, 0.95, False)]   # 0.1° = 360"
+    report = compare_positions(a, b, lon_tol_arcsec=120.0)
+    assert not report.ok
+    assert report.diffs[0].over_tolerance
+    assert abs(abs(report.diffs[0].delta_arcsec) - 360.0) < 1.0
+
+
+def test_retrograde_mismatch_is_flagged():
+    a = [ObjectPosition("Mars", 234.0, 0.0, -0.2, True)]
+    b = [ObjectPosition("Mars", 234.0, 0.0, 0.2, False)]
+    report = compare_positions(a, b, lon_tol_arcsec=120.0)
+    assert not report.ok
+    assert report.diffs[0].speed_sign_mismatch
+
+
+def test_wraparound_delta_is_small():
+    a = [ObjectPosition("Sun", 359.99, 0.0, 1.0, False)]
+    b = [ObjectPosition("Sun", 0.01, 0.0, 1.0, False)]
+    report = compare_positions(a, b, lon_tol_arcsec=120.0)
+    assert report.ok                       # 0.02° ≈ 72" < 120"
+    assert abs(report.diffs[0].delta_arcsec) < 80.0

services/logic/tests/test_engine_contract.py

@@ -0,0 +1,25 @@
+"""Kontrakt parzystości silników (LOG-28).
+
+Ten sam test musi przejść dla KAŻDEGO silnika. Dziś uruchamiamy go dla silnika
+własnego; gdy skonfigurowany jest ENGINE_SWISSEPH_URL, ten sam kontrakt sprawdza
+też silnik B.
+"""
+import os
+
+import pytest
+
+from app.engine.compare import check_engine_contract
+
+
+def test_own_engine_contract(own_engine, reference_moment):
+    check_engine_contract(own_engine, reference_moment)
+
+
+@pytest.mark.skipif(
+    not os.getenv("ENGINE_SWISSEPH_URL"),
+    reason="silnik B (swisseph) nieskonfigurowany — pomijam",
+)
+def test_swisseph_engine_contract(reference_moment):
+    from app.engine.remote_engine import RemoteEngine
+
+    check_engine_contract(RemoteEngine(), reference_moment)

services/logic/tests/test_formats.py

@@ -0,0 +1,28 @@
+"""Testy formatowania (czyste, bez efemeryd)."""
+from app.engine import formats
+
+
+def test_sign_index():
+    assert formats.sign_index(0) == 0          # Aries
+    assert formats.sign_index(35) == 1         # Taurus
+    assert formats.sign_index(359.9) == 11     # Pisces
+
+
+def test_in_sign_basic():
+    # 40°08'21" absolutnie = Taurus 10°08'21"
+    assert formats.in_sign(40.139166) == "Tau 10°08'21\""
+
+
+def test_absolute():
+    assert formats.absolute(40.139166) == "40°08'21\""
+
+
+def test_wraparound_and_norm():
+    assert formats.norm360(370.0) == 10.0
+    assert formats.norm360(-1.0) == 359.0
+
+
+def test_rounding_carry_into_next_sign():
+    # tuż przy granicy znaku zaokrąglenie nie może dać "30°"
+    s = formats.in_sign(59.99999)
+    assert s.startswith("Gem 0°") or s.startswith("Tau 29°59")

services/logic/tests/test_skyfield_reference.py

@@ -0,0 +1,44 @@
+"""Walidacja silnika własnego względem wyroczni (LOG-01 + LOG-25).
+
+Porównujemy pozycje policzone Skyfieldem ze znanymi wartościami Swiss Ephemeris
+(astro.com) dla horoskopu referencyjnego. To dokładnie mechanizm LOG-25 — tyle
+że wyrocznią są tu zapisane wcześniej wartości referencyjne zamiast żywej usługi
+swisseph. Tolerancja 2' (120") z zapasem na różnicę barycentrum/centrum planety.
+"""
+from app.engine.compare import compare_positions
+from app.engine.models import ObjectPosition
+
+# obiekt -> (długość absolutna w stopniach, retrogradacja) — Swiss Ephemeris / astro.com
+REFERENCE = {
+    "Sun": (40.139167, False),       # Tau 10°08'21"
+    "Moon": (30.551389, False),      # Tau 0°33'05"
+    "Mercury": (27.383889, True),    # Ari 27°23'02" Rx
+    "Venus": (27.676944, False),     # Ari 27°40'37"
+    "Mars": (234.541111, True),      # Sco 24°32'28" Rx
+    "Jupiter": (282.961667, True),   # Cap 12°57'42" Rx
+    "Saturn": (223.310833, True),    # Sco 13°18'39" Rx
+    "Uranus": (252.813333, True),    # Sag 12°48'48" Rx
+    "Neptune": (271.220833, True),   # Cap 1°13'15" Rx
+    "Pluto": (210.478889, True),     # Sco 0°28'44" Rx
+}
+
+TOLERANCE_ARCSEC = 120.0
+
+
+def _reference_positions():
+    return [
+        ObjectPosition(name, lon, 0.0, (-1.0 if retro else 1.0), retro)
+        for name, (lon, retro) in REFERENCE.items()
+    ]
+
+
+def test_positions_match_swisseph_reference(own_engine, reference_moment):
+    got = own_engine.positions(reference_moment)
+    report = compare_positions(got, _reference_positions(), lon_tol_arcsec=TOLERANCE_ARCSEC)
+    assert report.ok, report.summary()
+
+
+def test_retrograde_flags_match(own_engine, reference_moment):
+    got = {p.name: p for p in own_engine.positions(reference_moment)}
+    for name, (_lon, retro) in REFERENCE.items():
+        assert got[name].retrograde == retro, f"{name}: kierunek niezgodny"