Bogatsze sygnifikatory: faseta "w domu" obok "w znaku" (LOG-15/16)

Most horoskop -> sygnifikatory generuje teraz dla każdego obiektu dwie fasety:
- "w znaku": planeta + token znaku ([Su + [Tau)
- "w domu":  planeta + token domu ([Su + 11th H.) — używa domów z LOG-05

- significators.build_report: przyjmuje pozycje z build_chart (z numerami domów),
  generuje fasety znak/dom, filtruje szum. Ordinal helper (1st..12th).
- /chart/report: używa build_chart (pozycje z domami).
- Prezentacja /interpret: render faset (znak/dom) per obiekt.

Aspekty ([conj/[sq/[opp) na później — wymagają policzenia aspektów (LOG-06).

Zweryfikowano na realnym main_base.xlsx (53969 wierszy), 30.04.1984:
Mars w 5. domu 10 dopasowań ("[Sa or [Ma in the 5th H." -> "abortion/miscarriage"),
Neptune w 7. domu 6, Uranus w 6. domu 4. 7 testów przechodzi.

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

services/logic/app/significators.py

@@ -1,24 +1,25 @@
 """Most: policzony horoskop → tokeny sygnifikatorów → wyszukiwanie w bazie.
 
-Pierwsza wersja (LOG-16/18/19 w zalążku): z pozycji obiektów generujemy tokeny w
-składni bazy (np. Słońce w Byku → planeta `[Su`, znak `[Tau`), pytamy warstwę
-danych o rekordy zawierające token planety, a następnie zawężamy do tych, które
-wspominają też jej znak („planeta w swoim znaku"). To realizuje przepływ „wynik
-obliczeń szukany w pliku".
+Zalążek LOG-15/16: z pozycji obiektów (wraz z domami) generujemy tokeny w składni
+bazy i wyszukujemy pasujące rekordy. Dla każdego obiektu tworzymy kilka **faset**:
+- „w znaku"  — planeta + token znaku (`[Su` + `[Tau`)
+- „w domu"   — planeta + token domu (`[Su` + `11th H.`)
+Aspekty (`[conj`,`[sq`,`[opp`) wymagają policzenia aspektów (LOG-06) — na później.
 
-Format skrótów odczytany z realnej bazy (Encyclopaedia of Medical Astrology):
-planety `[Su`,`[Mo`,…; znaki `[Ari`,`[Tau`,…; np. `[Su affl. in [Vir`.
+Format skrótów odczytany z realnej bazy: planety `[Su`,`[Mo`,…; znaki
+`[Ari`,`[Tau`,…; domy `12th H.`; np. `[Sa [conj [Su in 6th H.`.
 """
 from __future__ import annotations
 
 from typing import Any, Protocol
 
-from app.engine.formats import SIGN_ABBR, sign_index
+from app.engine.formats import SIGN_ABBR, SIGNS
 
 PLANET_ABBR = {
     "Sun": "Su", "Moon": "Mo", "Mercury": "Me", "Venus": "Ve", "Mars": "Ma",
     "Jupiter": "Ju", "Saturn": "Sa", "Uranus": "Ur", "Neptune": "Ne", "Pluto": "Pl",
 }
+SIGN_TO_ABBR = dict(zip(SIGNS, SIGN_ABBR))
 
 
 class DataSource(Protocol):
@@ -45,16 +46,42 @@ def _is_noise(sig: str, effect: str) -> bool:
     )
 
 
-def build_report(positions, data: DataSource, per_object_limit: int = 60) -> dict:
-    """Dla każdego obiektu: wyszukaj sygnifikatory planety i zawęź do jej znaku."""
+def _ordinal(n: int) -> str:
+    if 10 <= n % 100 <= 20:
+        suffix = "th"
+    else:
+        suffix = {1: "st", 2: "nd", 3: "rd"}.get(n % 10, "th")
+    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."""
+    out: list[dict] = []
+    tok = token.lower()
+    for r in rows:
+        sig = str(r.get("significator") or "")
+        if tok not in sig.lower():
+            continue
+        eff = _effect(r)
+        if _is_noise(sig, eff):
+            continue
+        out.append({"significator": sig.strip(), "effect": eff})
+    return out
+
+
+def build_report(positions: list[dict], data: DataSource, 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).
+    """
     items: list[dict] = []
     provider = None
     for p in positions:
-        if p.name not in PLANET_ABBR:
+        name = p.get("name")
+        if name not in PLANET_ABBR:
             continue
-        planet_tok = "[" + PLANET_ABBR[p.name]
-        sign_tok = "[" + SIGN_ABBR[sign_index(p.longitude)]
-
+        planet_tok = "[" + PLANET_ABBR[name]
         raw = data.search(
             key="significator",
             value=planet_tok,
@@ -65,24 +92,31 @@ def build_report(positions, data: DataSource, per_object_limit: int = 60) -> dic
         provider = raw.get("provider", provider)
         rows = raw.get("rows", [])
 
-        samples: list[dict] = []
-        for r in rows:
-            sig = str(r.get("significator") or "")
-            if sign_tok.lower() not in sig.lower():
-                continue
-            eff = _effect(r)
-            if _is_noise(sig, eff):
-                continue
-            samples.append({"significator": sig.strip(), "effect": eff})
+        facets: list[dict] = []
+        sign = p.get("sign")
+        sign_tok = "[" + SIGN_TO_ABBR.get(sign, "")
+        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,
+        })
+
+        house = p.get("house")
+        if house:
+            ordn = _ordinal(int(house))
+            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,
+            })
 
         items.append({
-            "object": p.name,
-            "sign": p.sign,
-            "direction": p.direction,
+            "object": name,
+            "sign": sign,
+            "house": house,
+            "direction": p.get("direction"),
             "planet_token": planet_tok,
-            "sign_token": sign_tok,
             "planet_total": raw.get("total", 0),
-            "in_sign_count": len(samples),
-            "samples": samples[:5],
+            "facets": facets,
         })
     return {"provider": provider, "objects": items}