Aspekty (LOG-06) + faseta aspektu, dedup i dopieszczenie wyników

Aspekty:
- engine/aspects.py: aspekty główne (conj/sex/sq/tri/opp) z orbami
  (bonus dla luminarzy), separacja z obsługą zawinięcia. Applying/sep na później.
- build_chart zwraca listę aspektów; /chart/positions je udostępnia;
  widok Horoskop pokazuje tabelę aspektów.

Bogatsze sygnifikatory:
- trzecia faseta "w aspekcie": dla każdego aspektu głównego obiektu filtruje
  rekordy po tokenie aspektu + drugiej planety ([conj + [Mo). Cookbook
  komplet: znak + dom + aspekt.

Dopieszczenie wyników:
- ODSIEWANIE DUPLIKATÓW: duplikat = ten sam sygnifikator ORAZ ten sam opis
  (po normalizacji). Dedup wewnątrz fasety, działa też na wynikach z wielu baz.
- _facet_samples przyjmuje wiele tokenów (AND); dedup + istniejące odsiewanie szumu.

Zweryfikowano na realnym main_base.xlsx (30.04.1984): 16 aspektów zgodnych z
astro.com (Sun conj Moon 9.59°, Sun opp Saturn 3.17°); faseta aspektu daje
bogate trafienia (Sun koniunkcja z Moon 84, opozycja z Saturn 43); dedup obniżył
duplikaty (Sun w znaku 46->44). 36 testów przechodzi.

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

services/logic/app/significators.py

@@ -57,27 +57,50 @@ def _ordinal(n: int) -> str:
     return f"{n}{suffix}"
 
 
-def _facet_samples(rows: list[dict], token: str, limit: int = 4) -> list[dict]:
-    """Rekordy, których sygnifikator zawiera token — bez szumu."""
+def _norm(s: str) -> str:
+    """Normalizacja do porównań duplikatów: bez skrajnych spacji, jedna spacja, lower."""
+    return " ".join(str(s).strip().lower().split())
+
+
+def _facet_samples(rows: list[dict], tokens: list[str]) -> list[dict]:
+    """Rekordy, których sygnifikator zawiera WSZYSTKIE tokeny — bez szumu i bez duplikatów.
+
+    Duplikat = ten sam sygnifikator ORAZ ten sam opis (po normalizacji). Dedup
+    działa na zagregowanym wyniku, więc odsiewa też powtórki między wieloma bazami.
+    """
+    toks = [t.lower() for t in tokens if t]
     out: list[dict] = []
-    tok = token.lower()
+    seen: set[tuple[str, str]] = set()
     for r in rows:
-        sig = str(r.get("significator") or "")
-        if tok not in sig.lower():
+        sig = str(r.get("significator") or "").strip()
+        low = sig.lower()
+        if not all(t in low for t in toks):
             continue
         eff = _effect(r)
         if _is_noise(sig, eff):
             continue
-        out.append({"significator": sig.strip(), "expanded": expand(sig.strip()), "effect": eff})
+        key = (_norm(sig), _norm(eff))
+        if key in seen:
+            continue
+        seen.add(key)
+        out.append({"significator": sig, "expanded": expand(sig), "effect": eff})
     return out
 
 
-def build_report(positions: list[dict], data: DataSource, per_object_limit: int = 5000) -> dict:
+def build_report(
+    positions: list[dict],
+    data: DataSource,
+    aspects: list[dict] | None = None,
+    per_object_limit: int = 5000,
+) -> dict:
     """positions: pozycje z build_chart (name, sign, direction, house).
 
-    Dla każdego obiektu: jedno zapytanie o token planety, potem faseta „w znaku"
-    i „w domu" (jeśli dom policzony).
+    Dla każdego obiektu fasety: „w znaku", „w domu" oraz „w aspekcie" (dla każdego
+    aspektu głównego z listy `aspects`, jeśli w bazie są dopasowania). 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
+
     items: list[dict] = []
     provider = None
     for p in positions:
@@ -98,7 +121,7 @@ def build_report(positions: list[dict], data: DataSource, per_object_limit: int
         facets: list[dict] = []
         sign = p.get("sign")
         sign_tok = "[" + SIGN_TO_ABBR.get(sign, "")
-        sign_samples = _facet_samples(rows, sign_tok)
+        sign_samples = _facet_samples(rows, [sign_tok])
         facets.append({
             "type": "sign", "label": f"w znaku {sign}", "token": sign_tok,
             "count": len(sign_samples), "samples": sign_samples,
@@ -107,12 +130,29 @@ def build_report(positions: list[dict], data: DataSource, per_object_limit: int
         house = p.get("house")
         if house:
             ordn = _ordinal(int(house))
-            house_samples = _facet_samples(rows, f"{ordn} h")   # matcuje '12th H.'
+            house_samples = _facet_samples(rows, [f"{ordn} h"])   # matcuje '12th H.'
             facets.append({
                 "type": "house", "label": f"w {ordn} domu", "token": f"{ordn} H.",
                 "count": len(house_samples), "samples": house_samples,
             })
 
+        for asp in (aspects or []):
+            if name not in (asp.get("obj1"), asp.get("obj2")):
+                continue
+            other = asp["obj2"] if asp["obj1"] == name else asp["obj1"]
+            asp_tok = ASP_TOKEN.get(asp["aspect"])
+            if other not in PLANET_ABBR or not asp_tok:
+                continue
+            other_tok = "[" + PLANET_ABBR[other]
+            asp_samples = _facet_samples(rows, [asp_tok, other_tok])
+            if not asp_samples:                       # pokazujemy tylko aspekty z trafieniami
+                continue
+            facets.append({
+                "type": "aspect", "label": f"{ASP_NAME[asp['aspect']]} z {other}",
+                "token": f"{asp_tok} + {other_tok}",
+                "count": len(asp_samples), "samples": asp_samples,
+            })
+
         items.append({
             "object": name,
             "sign": sign,