feat(logic): aspekty pozazodiakalne — antyscja i paralele deklinacji (LOG-07)

Aspekty głowne (LOG-06) mierzą kąt wzdłuż ekliptyki. LOG-07 dokłada dwa rodzaje
powiązań, które klasyczna astrologia liczy naprawdę, nie na oko:

- PARALELA/KONTRPARALELA DEKLINACJI — dwa ciała na tej samej („parallel") lub
  przeciwnej („contraparallel") deklinacji działają jak koniunkcja/opozycja,
  mimo że wzdłuż ekliptyki mogą stać gdziekolwiek. Deklinacja liczona PEŁNYM
  wzorem (z szerokością ekliptyczną — istotne dla Księżyca i planet schodzących
  z ekliptyki), przez to_equatorial z LOG-04. Orb konfigurowalny (domyślnie 1°,
  ciasno — to kontakty punktowe).
- ANTYSCJA/KONTRANTYSCJA — odbicie długości względem osi przesileń (0° Raka –
  0° Koziorożca) albo równonocy (0° Barana – 0° Wagi).

Liczone na współrzędnych TROPIKALNYCH of-date, bo deklinacja jest fizyczna
(równikowa, niezależna od zodiaku), a antyscja z definicji tropikalna — jej oś to
kardynalne punkty zodiaku tropikalnego. Dlatego PRZED przesunięciem na zodiak
syderyczny/draconiczny.

Dodatkowo: flaga „out of bounds" (|deklinacja| > nachylenie ekliptyki — ciało
poza zakresem Słońca) i kolumna deklinacji przy każdej pozycji.

Integracja z bazą: baza interpretacyjna ZNA paralele pod frazą „P. Dec.", więc
generujemy fasetkę paraleli (trafia też do promptu LLM). PUŁAPKA: samo „Dec." w
bazie to często DEKANAT („3rd Dec. of [Gem"), więc szukamy dokładnie „P. Dec." —
inaczej sypnęłoby fałszywymi trafieniami. Kontrparaleli i antyscji baza nie
opisuje osobnym znacznikiem, więc zostają obliczeniem display-only.

Pary z RIGID_PAIRS (węzły) odsiane: SN = NN+180° na ekliptyce → deklinacja
ZAWSZE przeciwna, czyli definicyjna kontrparalela bez informacji.

Walidacja wobec faktów NIEZALEŻNYCH od kodu:
- deklinacja Słońca 30.04.1984 = +14.88° wobec ~+14.9° z almanachu,
- antyscja to arytmetyka odbicia: inwolucja i pary znaków (Rak↔Bliźnięta,
  Baran↔Panna) sprawdzone na piechotę,
- węzły faktycznie mają przeciwną deklinację i są odsiane,
- deklinacja niezależna od zodiaku (tropikalny == syderyczny co do 1e-6°),
- realna baza: mechanizm paraleli znajduje wpisy „P. Dec." i odsiewa dekanaty
  (z 33 wpisów „P. Dec." 5 ma niepusty efekt — głównie „[conj or P. Dec.").

UI: kolumna deklinacji (+znacznik OOB), tabela paraleli/kontrparaleli i tabela
antyscji na ekranie Horoskop.

Testy: 15 nowych (out_of_zodiac) + 2 (fasetka paraleli vs pułapka dekanatu).
Całość: logika 251 passed / 1 skipped, prezentacja 25 passed. Render szablonu
sprawdzony osobno (bez błędu Jinja, wszystkie sekcje obecne).

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

services/logic/app/engine/chart.py

@@ -37,12 +37,33 @@ def _shift_pos(pdict: dict, off: float) -> None:
 def build_chart(engine: EphemerisEngine, moment: ChartMoment, house_system: str = H.WHOLE_SIGN,
                 lots_method: str = "degree", zodiac: str = Z.TROPICAL) -> dict:
     from app.engine.aspects import find_aspects
+    from app.engine.houses import mean_obliquity
+    from app.engine.out_of_zodiac import (
+        declination,
+        find_antiscia,
+        find_declination_aspects,
+        is_out_of_bounds,
+    )
 
     positions = engine.positions(moment)
     result: dict = {"engine": engine.name, "positions": [p.as_dict() for p in positions]}
     # aspekty liczymy PRZED zmianą zodiaku — kąty między obiektami są niezmiennicze
     result["aspects"] = find_aspects(result["positions"])  # aspekty (LOG-06)
 
+    # Aspekty pozazodiakalne (LOG-07): deklinacja i antyscja liczone na
+    # współrzędnych TROPIKALNYCH of-date — deklinacja jest fizyczna (równikowa),
+    # a antyscja z definicji tropikalna. Dlatego PRZED przesunięciem na zodiak,
+    # z surowych długości/szerokości silnika.
+    eps = mean_obliquity(Z.julian_day(moment.when_utc))
+    result["obliquity"] = round(eps, 6)
+    for pdict, obj in zip(result["positions"], positions):
+        dec = declination(obj.longitude, obj.latitude, eps)
+        pdict["declination"] = round(dec, 4)
+        if is_out_of_bounds(dec, eps):
+            pdict["out_of_bounds"] = True
+    result["parallels"] = find_declination_aspects(result["positions"])
+    result["antiscia"] = find_antiscia(result["positions"])
+
     # offset zodiaku (LOG-04): syderyczny = ayanamsa, draconic = długość węzła
     node_lon = next((p.longitude for p in positions if p.name == "North Node"), None)
     off = Z.offset(zodiac, Z.julian_day(moment.when_utc), node_lon)

services/logic/app/engine/out_of_zodiac.py

@@ -0,0 +1,140 @@
+"""Aspekty pozazodiakalne (LOG-07): paralele deklinacji i antyscja.
+
+Aspekty głowne (LOG-06) mierzą kąt wzdłuż EKLIPTYKI. Ale dwa ciała mogą być
+powiązane też inaczej — a te powiązania klasyczna astrologia liczy naprawdę,
+nie na oko:
+
+* **Paralela / kontrparalela deklinacji.** Deklinacja to „szerokość" na równiku
+  niebieskim — jak daleko na północ/południe od równika stoi ciało. Dwa ciała na
+  tej samej deklinacji (parallel) działają jak koniunkcja, na przeciwnej
+  (kontrparalela) — jak opozycja, mimo że wzdłuż ekliptyki mogą być gdziekolwiek.
+  Baza interpretacyjna zna to zjawisko pod skrótem „P. Dec.".
+
+* **Antyscja / kontrantyscja.** Odbicie punktu względem osi przesileń
+  (0° Raka – 0° Koziorożca). Dwa punkty w antyscji są równo odległe od tej osi —
+  „dzielą" tę samą długość dnia. Kontrantyscja to odbicie względem osi
+  równonocy (0° Barana – 0° Wagi).
+
+Wszystko liczymy na współrzędnych TROPIKALNYCH of-date, bo:
+  - deklinacja jest wielkością fizyczną (równikową), niezależną od wyboru zodiaku;
+  - antyscja jest z definicji tropikalna — jej oś to punkty przesileń, czyli
+    kardynalne punkty zodiaku tropikalnego.
+Dlatego moduł bierze surowe długości/szerokości z silnika, a nie etykiety po
+przesunięciu na zodiak syderyczny/draconiczny.
+"""
+from __future__ import annotations
+
+from app.engine.aspects import LUMINARIES, RIGID_PAIRS, separation
+from app.engine.formats import norm360
+from app.engine.zodiac import to_equatorial
+
+# Orby — konfigurowalne (wymóg LOG-07). Paralele i antyscja są klasycznie CIASNE:
+# to kontakty „punktowe", więc szeroki orb produkowałby fałszywe trafienia.
+DECL_ORB = 1.0        # ° deklinacji dla paraleli/kontrparaleli
+ANTISCIA_ORB = 1.0    # ° długości dla antyscji/kontrantyscji
+LUMINARY_BONUS = 0.0  # świadomie 0 — te kontakty trzymamy ciasno; do podniesienia w API
+
+
+def _is_rigid(name_a: str, name_b: str) -> bool:
+    return frozenset({name_a, name_b}) in RIGID_PAIRS
+
+
+def declination(lon: float, lat: float, eps: float) -> float:
+    """Deklinacja [−90, 90]° z długości i szerokości ekliptycznej (pełny wzór,
+    z szerokością — istotne dla Księżyca i planet, które schodzą z ekliptyki)."""
+    _, dec = to_equatorial(lon, lat, eps)
+    return dec
+
+
+def is_out_of_bounds(dec: float, eps: float) -> bool:
+    """Deklinacja poza zakresem Słońca (|dec| > nachylenie ekliptyki).
+
+    „Out of bounds" — ciało zaszło dalej na północ/południe, niż Słońce kiedykolwiek
+    potrafi. Astrologicznie czytane jako działanie „poza normą", stąd wart odnotowania."""
+    return abs(dec) > eps
+
+
+def antiscion(lon: float) -> float:
+    """Odbicie długości względem osi przesileń (0° Raka – 0° Koziorożca)."""
+    return norm360(180.0 - lon)
+
+
+def contra_antiscion(lon: float) -> float:
+    """Odbicie długości względem osi równonocy (0° Barana – 0° Wagi)."""
+    return norm360(-lon)
+
+
+def _allowed(orb: float, name_a: str, name_b: str, bonus: float) -> float:
+    if bonus and (name_a in LUMINARIES or name_b in LUMINARIES):
+        return orb + bonus
+    return orb
+
+
+def find_declination_aspects(
+    bodies: list[dict], orb: float = DECL_ORB, luminary_bonus: float = LUMINARY_BONUS
+) -> list[dict]:
+    """bodies: dicty z 'name' i 'declination' (°).
+
+    Zwraca paralele (ta sama deklinacja) i kontrparalele (przeciwna). Pary z
+    RIGID_PAIRS pomijane — np. węzły są z definicji zawsze w kontrparaleli
+    (SN = NN+180 na ekliptyce → deklinacja przeciwna), co nie niesie informacji.
+    """
+    out: list[dict] = []
+    n = len(bodies)
+    for i in range(n):
+        for j in range(i + 1, n):
+            a, b = bodies[i], bodies[j]
+            if _is_rigid(a["name"], b["name"]):
+                continue
+            da, db = a.get("declination"), b.get("declination")
+            if da is None or db is None:
+                continue
+            da, db = float(da), float(db)
+            allowed = _allowed(orb, a["name"], b["name"], luminary_bonus)
+            parallel_dev = abs(da - db)
+            contra_dev = abs(da + db)
+            # ciało może wpaść tylko w jeden z dwóch — bierzemy ciaśniejszy
+            if parallel_dev <= allowed and parallel_dev <= contra_dev:
+                out.append(_row("parallel", a, b, parallel_dev, allowed, da, db))
+            elif contra_dev <= allowed:
+                out.append(_row("contraparallel", a, b, contra_dev, allowed, da, db))
+    return out
+
+
+def find_antiscia(
+    bodies: list[dict], orb: float = ANTISCIA_ORB, luminary_bonus: float = LUMINARY_BONUS
+) -> list[dict]:
+    """bodies: dicty z 'name' i 'decimal' (długość tropikalna of-date, °).
+
+    Zwraca antyscje (odbicie względem osi przesileń) i kontrantyscje (osi równonocy).
+    """
+    out: list[dict] = []
+    n = len(bodies)
+    for i in range(n):
+        for j in range(i + 1, n):
+            a, b = bodies[i], bodies[j]
+            if _is_rigid(a["name"], b["name"]):
+                continue
+            la, lb = a.get("decimal"), b.get("decimal")
+            if la is None or lb is None:
+                continue
+            la, lb = float(la), float(lb)
+            allowed = _allowed(orb, a["name"], b["name"], luminary_bonus)
+            anti_dev = separation(la, antiscion(lb))
+            contra_dev = separation(la, contra_antiscion(lb))
+            if anti_dev <= allowed and anti_dev <= contra_dev:
+                out.append(_row("antiscion", a, b, anti_dev, allowed))
+            elif contra_dev <= allowed:
+                out.append(_row("contra_antiscion", a, b, contra_dev, allowed))
+    return out
+
+
+def _row(kind: str, a: dict, b: dict, dev: float, allowed: float,
+         dec_a: float | None = None, dec_b: float | None = None) -> dict:
+    row = {
+        "obj1": a["name"], "obj2": b["name"],
+        "type": kind, "orb": round(dev, 3), "allowed": round(allowed, 3),
+    }
+    if dec_a is not None:
+        row["dec1"], row["dec2"] = round(dec_a, 3), round(dec_b, 3)
+    return row

services/logic/app/main.py

@@ -124,7 +124,8 @@ def chart_report(req: ReportRequest) -> dict:
     try:
         report = build_report(
             chart["positions"], DataClient(),
-            aspects=chart.get("aspects"), per_object_limit=req.limit, group=req.group,
+            aspects=chart.get("aspects"), parallels=chart.get("parallels"),
+            per_object_limit=req.limit, group=req.group,
         )
     except httpx.HTTPError as e:
         return {"engine": engine.name, "objects": [], "data_error": f"Warstwa danych niedostępna: {e}"}
@@ -188,7 +189,8 @@ def chart_prompt(req: PromptRequest) -> dict:
             try:
                 report = build_report(
                     chart["positions"], DataClient(),
-                    aspects=chart.get("aspects"), per_object_limit=req.limit,
+                    aspects=chart.get("aspects"), parallels=chart.get("parallels"),
+                    per_object_limit=req.limit,
                 )
             except httpx.HTTPError as e:
                 data_error = f"Warstwa danych niedostępna: {e}"

services/logic/app/significators.py

@@ -114,17 +114,24 @@ def build_report(
     positions: list[dict],
     data: DataSource,
     aspects: list[dict] | None = None,
+    parallels: list[dict] | None = None,
     per_object_limit: int = 5000,
     group: bool = False,
 ) -> dict:
     """positions: pozycje z build_chart (name, sign, direction, house).
 
-    Dla każdego obiektu fasety: „w znaku", „w domu" oraz „w aspekcie" (dla każdego
+    Dla każdego obiektu fasety: „w znaku", „w domu", „w aspekcie" (dla każdego
-    aspektu głównego z listy `aspects`, jeśli w bazie są dopasowania). Duplikaty
+    aspektu głównego z listy `aspects`) oraz „paralela deklinacji" (dla paraleli
-    (ten sam sygnifikator i opis) są odsiewane wewnątrz każdej fasety.
+    z listy `parallels` — LOG-07). Duplikaty (ten sam sygnifikator i opis) są
+    odsiewane wewnątrz każdej fasety.
     """
     from app.engine.aspects import DB_TOKEN as ASP_TOKEN, PL_NAME as ASP_NAME
 
+    # W bazie paralela deklinacji zapisana jest jako fraza „P. Dec." (nie token [).
+    # UWAGA: samo „Dec." w bazie to CZĘSTO dekanat („3rd Dec. of [Gem"), więc
+    # szukamy dokładnie „P. Dec.", inaczej sypnęłoby fałszywymi trafieniami.
+    PARALLEL_MARK = "P. Dec."
+
     items: list[dict] = []
     provider = None
     for p in positions:
@@ -180,6 +187,25 @@ def build_report(
                 "count": len(asp_samples), "samples": asp_samples,
             })
 
+        # paralele deklinacji (LOG-07) — baza zna je jako „P. Dec.". Tylko `parallel`:
+        # kontrparaleli i antyscji baza nie opisuje osobnym znacznikiem.
+        for par in (parallels or []):
+            if par.get("type") != "parallel" or name not in (par.get("obj1"), par.get("obj2")):
+                continue
+            other = par["obj2"] if par["obj1"] == name else par["obj1"]
+            if other not in PLANET_ABBR:
+                continue
+            other_tok = "[" + PLANET_ABBR[other]
+            par_samples = _facet_samples(rows, [PARALLEL_MARK, other_tok])
+            if not par_samples:                       # pokazujemy tylko z trafieniami
+                continue
+            facets.append({
+                "type": "parallel", "label": f"paralela deklinacji z {other}",
+                "token": f"{PARALLEL_MARK} + {other_tok}",
+                "orb": par.get("orb"), "allowed": par.get("allowed"),
+                "count": len(par_samples), "samples": par_samples,
+            })
+
         # punktacja siły (LOG-21), opcjonalne grupowanie po opisie, ranking faset
         for f in facets:
             f["score"] = score_facet(f)

services/logic/tests/test_out_of_zodiac.py

@@ -0,0 +1,157 @@
+"""Aspekty pozazodiakalne — paralele deklinacji i antyscja (LOG-07).
+
+Walidacja wobec faktów NIEZALEŻNYCH od naszego kodu:
+  * deklinacja Słońca 30.04.1984 ≈ +14.9° (almanach; Słońce w ~10° Byka, koniec
+    kwietnia, deklinacja rośnie ku przesileniu letniemu),
+  * antyscja to czysta arytmetyka odbicia względem osi przesileń — pary znaków
+    (Rak↔Bliźnięta, Baran↔Panna) i inwolucja dają się sprawdzić na piechotę,
+  * węzły są z definicji w kontrparaleli (SN = NN+180° na ekliptyce → deklinacja
+    przeciwna), więc muszą być odsiane jako kontakt bez informacji.
+"""
+from datetime import datetime, timezone
+
+import pytest
+
+from app.engine.chart import build_chart
+from app.engine.models import ChartMoment
+from app.engine.out_of_zodiac import (
+    antiscion,
+    contra_antiscion,
+    declination,
+    find_antiscia,
+    find_declination_aspects,
+    is_out_of_bounds,
+)
+
+
+@pytest.fixture(scope="module")
+def krakow():
+    return ChartMoment(when_utc=datetime(1984, 4, 30, 9, 20, tzinfo=timezone.utc),
+                       lat=50.0647, lon=19.9450)
+
+
+@pytest.fixture(scope="module")
+def chart(own_engine, krakow):
+    return build_chart(own_engine, krakow)
+
+
+# ----------------------------------------------------------------- deklinacja
+
+def test_sun_declination_matches_almanac(chart):
+    """Deklinacja Słońca 30.04.1984 ≈ +14.9° (wartość z almanachu)."""
+    sun = next(p for p in chart["positions"] if p["name"] == "Sun")
+    assert 14.6 < sun["declination"] < 15.1
+
+
+def test_declination_uses_latitude_not_only_longitude():
+    """Pełny wzór: przy tej samej długości różna szerokość → różna deklinacja.
+    Gdyby liczyć z samej długości (β=0), obie wyszłyby identyczne."""
+    eps = 23.44
+    on_ecliptic = declination(60.0, 0.0, eps)      # β = 0
+    above = declination(60.0, 5.0, eps)            # 5° na północ od ekliptyki
+    assert abs(above - on_ecliptic) > 3.0          # szerokość realnie zmienia deklinację
+
+
+def test_obliquity_is_reasonable_for_1984(chart):
+    assert 23.43 < chart["obliquity"] < 23.45
+
+
+def test_out_of_bounds_flag():
+    eps = 23.44
+    assert is_out_of_bounds(24.0, eps) is True     # poza zakresem Słońca
+    assert is_out_of_bounds(20.0, eps) is False
+    assert is_out_of_bounds(-24.5, eps) is True    # także na południe
+
+
+# --------------------------------------------------------------- antyscja (wzór)
+
+def test_antiscion_is_reflection_across_solstitial_axis():
+    assert antiscion(0.0) == pytest.approx(180.0)      # 0° Barana → 0° Wagi
+    assert antiscion(105.0) == pytest.approx(75.0)     # 15° Raka → 15° Bliźniąt
+    assert antiscion(90.0) == pytest.approx(90.0)      # 0° Raka leży NA osi
+
+
+def test_antiscion_is_an_involution():
+    for lon in (12.3, 88.0, 200.5, 359.9):
+        assert antiscion(antiscion(lon)) == pytest.approx(lon)
+
+
+def test_contra_antiscion_across_equinoctial_axis():
+    assert contra_antiscion(0.0) == pytest.approx(0.0)     # 0° Barana leży NA osi
+    assert contra_antiscion(30.0) == pytest.approx(330.0)  # 0° Byka → 0° Ryb (odbicie)
+
+
+def test_sign_pairs_are_classic():
+    """Antyscja parami znaków: Baran↔Panna, Byk↔Lew, Bliźnięta↔Rak."""
+    # 5° Barana (5°) → 175° = 25° Panny
+    assert antiscion(5.0) == pytest.approx(175.0)
+    # 10° Byka (40°) → 140° = 20° Lwa
+    assert antiscion(40.0) == pytest.approx(140.0)
+
+
+# --------------------------------------------------- wykrywanie paraleli/antyscji
+
+def test_parallel_and_contraparallel_detection():
+    bodies = [
+        {"name": "A", "declination": 12.0},
+        {"name": "B", "declination": 12.4},    # paralela z A (0.4°)
+        {"name": "C", "declination": -11.6},   # kontrparalela z A (|12-11.6|=0.4)
+        {"name": "D", "declination": 5.0},     # nic (daleko)
+    ]
+    res = {(r["obj1"], r["obj2"]): r for r in find_declination_aspects(bodies, orb=1.0)}
+    assert res[("A", "B")]["type"] == "parallel"
+    assert res[("A", "C")]["type"] == "contraparallel"
+    assert ("A", "D") not in res
+
+
+def test_orb_is_configurable():
+    bodies = [{"name": "A", "declination": 10.0}, {"name": "B", "declination": 11.5}]
+    assert find_declination_aspects(bodies, orb=1.0) == []       # 1.5° > 1.0°
+    assert len(find_declination_aspects(bodies, orb=2.0)) == 1   # mieści się
+
+
+def test_nodes_definitional_contraparallel_is_filtered(chart):
+    """SN = NN+180° na ekliptyce → deklinacja przeciwna ZAWSZE. To kontakt bez
+    informacji, więc pary NN/SN nie może być w wynikach."""
+    decl = {p["name"]: p["declination"] for p in chart["positions"]}
+    # najpierw potwierdzamy, że deklinacje faktycznie są przeciwne
+    assert decl["North Node"] == pytest.approx(-decl["South Node"], abs=0.05)
+    # a mimo to para NN/SN nie pojawia się na liście paraleli
+    pairs = {frozenset((r["obj1"], r["obj2"])) for r in chart["parallels"]}
+    assert frozenset(("North Node", "South Node")) not in pairs
+
+
+def test_antiscia_detection_with_constructed_longitudes():
+    # A na 40°, B na 138° → antyscja A leży na 140°, więc B jest 2° od niej
+    bodies = [{"name": "A", "decimal": 40.0}, {"name": "B", "decimal": 138.0}]
+    assert find_antiscia(bodies, orb=1.0) == []                  # 2° > 1°
+    hit = find_antiscia(bodies, orb=3.0)
+    assert len(hit) == 1 and hit[0]["type"] == "antiscion"
+
+
+def test_contra_antiscion_detection():
+    # A na 40°, kontrantyscja A = 320°; B na 320.5° → kontrantyscja w orbie
+    bodies = [{"name": "A", "decimal": 40.0}, {"name": "B", "decimal": 320.5}]
+    hit = find_antiscia(bodies, orb=1.0)
+    assert len(hit) == 1 and hit[0]["type"] == "contra_antiscion"
+
+
+# ------------------------------------------------------ spójność z build_chart
+
+def test_chart_exposes_parallels_and_antiscia(chart):
+    assert "parallels" in chart and "antiscia" in chart
+    assert "obliquity" in chart
+    # znany, ciasny kontakt z tego horoskopu: Uran ~paralela~ Neptun (mid-80s)
+    un = next((r for r in chart["parallels"]
+               if {r["obj1"], r["obj2"]} == {"Uranus", "Neptune"}), None)
+    assert un is not None and un["type"] == "parallel"
+
+
+def test_declination_is_zodiac_independent(own_engine, krakow):
+    """Deklinacja jest fizyczna — nie zmienia się z wyborem zodiaku."""
+    tropical = build_chart(own_engine, krakow, zodiac="tropical")
+    sidereal = build_chart(own_engine, krakow, zodiac="sidereal_lahiri")
+    dt = {p["name"]: p["declination"] for p in tropical["positions"]}
+    ds = {p["name"]: p["declination"] for p in sidereal["positions"]}
+    for name in dt:
+        assert dt[name] == pytest.approx(ds[name], abs=1e-6)

services/logic/tests/test_significators.py

@@ -61,6 +61,42 @@ def test_aspect_facet():
     assert asp and asp[0]["count"] == 1 and "Moon" in asp[0]["label"]
 
 
+def test_parallel_facet_hits_db_and_avoids_decanate_trap():
+    """Paralela deklinacji (LOG-07): baza zna ją jako „P. Dec.". Pułapka: samo
+    „Dec." to często DEKANAT („3rd Dec. of [Gem"), który NIE może wpaść do paraleli."""
+    positions = [
+        {"name": "Mercury", "sign": "Taurus", "direction": "D", "house": 3},
+        {"name": "Saturn", "sign": "Scorpio", "direction": "Rx", "house": 9},
+    ]
+    parallels = [{"obj1": "Mercury", "obj2": "Saturn", "type": "parallel",
+                  "orb": 0.3, "allowed": 1.0}]
+    data = FakeData({"[Me": [
+        {"significator": "[Me at B. in P. Dec. [Sa and [Ma", "actioneffect": "dyscyplina umysłu"},
+        {"significator": "3rd Dec. of [Gem on Asc.", "actioneffect": "TO DEKANAT, nie paralela"},
+        {"significator": "[Me [conj [Sa", "actioneffect": "inny aspekt, nie paralela"},
+    ]})
+    par = [f for f in build_report(positions, data, parallels=parallels)["objects"][0]["facets"]
+           if f["type"] == "parallel"]
+    assert par and par[0]["count"] == 1
+    assert "Saturn" in par[0]["label"]
+    assert all("Dec. of" not in s["significator"] for s in par[0]["samples"]), "dekanat przeciekł"
+
+
+def test_contraparallel_gets_no_db_facet():
+    """Baza nie ma osobnego znacznika dla kontrparaleli — nie zmyślamy fasety."""
+    positions = [
+        {"name": "Mercury", "sign": "Taurus", "direction": "D", "house": 3},
+        {"name": "Saturn", "sign": "Scorpio", "direction": "Rx", "house": 9},
+    ]
+    parallels = [{"obj1": "Mercury", "obj2": "Saturn", "type": "contraparallel",
+                  "orb": 0.3, "allowed": 1.0}]
+    data = FakeData({"[Me": [
+        {"significator": "[Me at B. in P. Dec. [Sa", "actioneffect": "paralela, nie kontr-"},
+    ]})
+    types = [f["type"] for f in build_report(positions, data, parallels=parallels)["objects"][0]["facets"]]
+    assert "parallel" not in types
+
+
 def test_grouping_by_effect():
     positions = [{"name": "Mars", "sign": "Scorpio", "direction": "Rx", "house": 5}]
     data = FakeData({"[Ma": [

services/presentation/app/templates/chart.html

@@ -87,6 +87,7 @@
     <thead>
       <tr>
         <th>Obiekt</th><th>Znak</th><th>W znaku</th><th>Dom</th><th>Kier.</th><th>Prędkość °/d</th>
+        <th title="Deklinacja — odległość od równika niebieskiego. OOB = poza zakresem Słońca">Dekl.</th>
       </tr>
     </thead>
     <tbody>
@@ -98,6 +99,7 @@
           <td>{{ p.house if p.house is defined else '—' }}</td>
           <td class="{{ 'retro' if p.direction == 'Rx' else '' }}">{{ p.direction }}</td>
           <td class="mono">{{ '%+.4f' | format(p.speed) }}</td>
+          <td class="mono">{% if p.declination is defined %}{{ '%+.2f°' | format(p.declination) }}{% if p.out_of_bounds %} <span class="badge" title="Out of bounds — deklinacja poza zakresem Słońca">OOB</span>{% endif %}{% else %}—{% endif %}</td>
         </tr>
       {% endfor %}
     </tbody>
@@ -144,6 +146,42 @@
   </table>
   {% endif %}
 
+  {# Aspekty pozazodiakalne (LOG-07): paralele deklinacji i antyscja #}
+  {% if result.parallels %}
+  <div class="meta" title="Ciała na tej samej (paralela) lub przeciwnej (kontrparalela) deklinacji — działają jak koniunkcja / opozycja poza ekliptyką">Paralele deklinacji ({{ result.parallels | length }})</div>
+  <table class="angles">
+    <thead><tr><th>Obiekt 1</th><th>Rodzaj</th><th>Obiekt 2</th><th>Orb</th><th>Dekl.</th></tr></thead>
+    <tbody>
+      {% for r in result.parallels %}
+        <tr>
+          <td>{{ r.obj1 }}</td>
+          <td>{{ 'paralela' if r.type == 'parallel' else 'kontrparalela' }}</td>
+          <td>{{ r.obj2 }}</td>
+          <td class="mono">{{ '%.2f'|format(r.orb) }}°</td>
+          <td class="mono">{{ '%+.2f'|format(r.dec1) }} / {{ '%+.2f'|format(r.dec2) }}</td>
+        </tr>
+      {% endfor %}
+    </tbody>
+  </table>
+  {% endif %}
+
+  {% if result.antiscia %}
+  <div class="meta" title="Odbicie względem osi przesileń (antyscja) lub równonocy (kontrantyscja) — punkty „dzielące” tę samą długość dnia">Antyscja ({{ result.antiscia | length }})</div>
+  <table class="angles">
+    <thead><tr><th>Obiekt 1</th><th>Rodzaj</th><th>Obiekt 2</th><th>Orb</th></tr></thead>
+    <tbody>
+      {% for r in result.antiscia %}
+        <tr>
+          <td>{{ r.obj1 }}</td>
+          <td>{{ 'antyscja' if r.type == 'antiscion' else 'kontrantyscja' }}</td>
+          <td>{{ r.obj2 }}</td>
+          <td class="mono">{{ '%.2f'|format(r.orb) }}°</td>
+        </tr>
+      {% endfor %}
+    </tbody>
+  </table>
+  {% endif %}
+
   {% if result.tables %}
     {% set tb = result.tables %}
     <div class="meta">Tabele dodatkowe (LOG-23)</div>