Ranking siły (LOG-21) + grupowanie identycznych opisów + geolokalizacja

Punktacja siły (LOG-21):
- scoring.py: siła fasety z sygnałów obliczalnych (typ fasety, rodzaj aspektu,
  ciasnota orbu). Konfigurowalne wagi. Hook na przyszłość: kolumny countas*/level*
  z SIGNIFICATORS KEY (obecnie puste).
- aspekty niosą orb+allowed; fasety dostają "score"; ranking faset malejąco.

Grupowanie:
- opcja group: zwija próbki po opisie (ten sam efekt = jedna grupa z listą
  sygnifikatorów i licznikiem). Checkbox "grupuj identyczne opisy" w /interpret.

Geolokalizacja (bajer):
- "Tu i teraz" (widok Horoskop i Interpretacje) uzupełnia lat/lon z przeglądarki
  (navigator.geolocation; wymaga zgody, https/localhost).

Zweryfikowano na realnym main_base.xlsx: ranking sensowny (ciasna opozycja z
Saturn 9.59 > szeroka koniunkcja z Moon 6.25 > znak/dom 5.0); grupowanie zwija
powtórzone opisy. 41 testów przechodzi.

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

services/logic/README.md

@@ -6,9 +6,8 @@ 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/positions` → `{when_utc, lat, lon, house_system?}` → pełny horoskop: pozycje (LOG-01) + osie i domy (LOG-05) + aspekty główne (LOG-06). `house_system`: `whole_sign` (dom.) / `equal` / `porphyry`.
-- `POST /chart/report` → `{when_utc, lat, lon, limit?}` → wynik obliczeń wyszukany w bazie: z pozycji + domów generuje sygnifikatory (fasety: planeta w znaku i w domu) i zwraca pasujące interpretacje z warstwy danych (zalążek LOG-16/18/19)
+- `POST /chart/report` → `{when_utc, lat, lon, limit?}` → wynik obliczeń wyszukany w bazie: fasety sygnifikatorów **w znaku / w domu / w aspekcie**, z rozwinięciem skrótów, odsiewaniem duplikatów (ten sam sygnifikator i opis), rankingiem siły (LOG-21) oraz opcją group (grupowanie identycznych opisów)
-- `POST /chart/positions` → `{when_utc, lat, lon, house_system?}` → pełny horoskop: pozycje (LOG-01) + osie i domy (LOG-05). `house_system`: `whole_sign` (dom.) / `equal` / `porphyry`.
 - `POST /chart/compare` → jak wyżej → raport różnic dwóch silników (LOG-26; wymaga silnika B)
 - `GET /health` (sprawdza też warstwę bazodanową)
 

services/logic/app/engine/aspects.py

@@ -0,0 +1,59 @@
+"""Aspekty — kąty między obiektami (LOG-06, wersja: aspekty główne).
+
+Czysta matematyka na policzonych długościach ekliptycznych. Dla każdej pary
+obiektów sprawdzamy, czy ich separacja kątowa mieści się w orbie któregoś z
+aspektów głównych. Applying/separating (aplikacja/separacja) — na później.
+
+Tokeny bazy (z SIGNIFICATORS KEY): [conj, [sex, [sq, [tri, [opp.
+"""
+from __future__ import annotations
+
+MAJOR = {
+    "conjunction": 0.0,
+    "sextile": 60.0,
+    "square": 90.0,
+    "trine": 120.0,
+    "opposition": 180.0,
+}
+DB_TOKEN = {
+    "conjunction": "[conj", "sextile": "[sex", "square": "[sq",
+    "trine": "[tri", "opposition": "[opp",
+}
+PL_NAME = {
+    "conjunction": "koniunkcja", "sextile": "sekstyl", "square": "kwadratura",
+    "trine": "trygon", "opposition": "opozycja",
+}
+LUMINARIES = {"Sun", "Moon"}
+DEFAULT_ORB = 8.0
+LUMINARY_BONUS = 2.0
+
+
+def separation(a: float, b: float) -> float:
+    """Najmniejsza separacja kątowa [0,180]."""
+    d = abs(a - b) % 360.0
+    return min(d, 360.0 - d)
+
+
+def find_aspects(
+    positions: list[dict], orb: float = DEFAULT_ORB, luminary_bonus: float = LUMINARY_BONUS
+) -> list[dict]:
+    """positions: dicty z 'name' i 'decimal' (długość). Zwraca listę aspektów."""
+    out: list[dict] = []
+    n = len(positions)
+    for i in range(n):
+        for j in range(i + 1, n):
+            a, b = positions[i], positions[j]
+            la, lb = a.get("decimal"), b.get("decimal")
+            if la is None or lb is None:
+                continue
+            sep = separation(float(la), float(lb))
+            allowed = orb + (luminary_bonus if (a["name"] in LUMINARIES or b["name"] in LUMINARIES) else 0.0)
+            for asp, angle in MAJOR.items():
+                dev = abs(sep - angle)
+                if dev <= allowed:
+                    out.append({
+                        "obj1": a["name"], "obj2": b["name"],
+                        "aspect": asp, "orb": round(dev, 2), "allowed": round(allowed, 2),
+                    })
+                    break  # jedna para = jeden aspekt
+    return out

services/logic/app/engine/chart.py

@@ -22,8 +22,11 @@ def _fmt(name: str, lon: float) -> dict:
 
 
 def build_chart(engine: EphemerisEngine, moment: ChartMoment, house_system: str = H.WHOLE_SIGN) -> dict:
+    from app.engine.aspects import find_aspects
+
     positions = engine.positions(moment)
     result: dict = {"engine": engine.name, "positions": [p.as_dict() for p in positions]}
+    result["aspects"] = find_aspects(result["positions"])  # aspekty (LOG-06)
 
     if not hasattr(engine, "sidereal"):
         return result

services/logic/app/main.py

@@ -83,21 +83,25 @@ class ReportRequest(BaseModel):
     lat: float = 0.0
     lon: float = 0.0
     limit: int = 5000
+    group: bool = False          # grupowanie identycznych opisów
 
 
 @app.post("/chart/report")
 def chart_report(req: ReportRequest) -> dict:
-    """Wynik obliczeń szukany w bazie: z pozycji + domów generuje sygnifikatory
+    """Wynik obliczeń szukany w bazie: z pozycji + domów + aspektów generuje
-    (fasety znak/dom) i pyta warstwę danych o pasujące interpretacje."""
+    sygnifikatory (fasety znak/dom/aspekt) i pyta warstwę danych o interpretacje."""
     from app.engine.chart import build_chart
     from app.engine.models import ChartMoment
     from app.significators import build_report
 
     engine = get_engine()
     moment = ChartMoment(when_utc=req.when_utc, lat=req.lat, lon=req.lon)
-    chart = build_chart(engine, moment)     # pozycje z numerami domów
+    chart = build_chart(engine, moment)     # pozycje z domami + aspekty
     try:
-        report = build_report(chart["positions"], DataClient(), per_object_limit=req.limit)
+        report = build_report(
+            chart["positions"], DataClient(),
+            aspects=chart.get("aspects"), 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}"}
     return {"engine": engine.name, **report}

services/logic/app/scoring.py

@@ -0,0 +1,32 @@
+"""Punktacja siły trafień — do rankingowania faset (zalążek LOG-21).
+
+v1 liczy siłę z sygnałów OBLICZALNYCH:
+- typ fasety (aspekt zwykle mocniejszy od znaku/domu),
+- rodzaj aspektu (koniunkcja/opozycja mocniejsze od sekstyla),
+- ciasnota orbu (im bliżej dokładności, tym mocniej).
+
+Wszystko konfigurowalne. HOOK NA PRZYSZŁOŚĆ: gdy w SIGNIFICATORS KEY zostaną
+wypełnione kolumny `countas*`/`level*`, można je tu domieszać per sygnifikator.
+"""
+from __future__ import annotations
+
+# bazowe wagi faset (łatwe do strojenia)
+FACET_BASE = {"sign": 5.0, "house": 5.0, "aspect": 6.0}
+
+# względna siła aspektów głównych
+ASPECT_WEIGHT = {
+    "conjunction": 1.0, "opposition": 0.95, "square": 0.85,
+    "trine": 0.85, "sextile": 0.65,
+}
+
+
+def score_facet(facet: dict) -> float:
+    """Siła fasety w skali ~0–12. Deterministyczna, konfigurowalna."""
+    base = FACET_BASE.get(facet.get("type"), 1.0)
+    if facet.get("type") == "aspect":
+        weight = ASPECT_WEIGHT.get(facet.get("aspect"), 0.7)
+        orb = facet.get("orb")
+        allowed = facet.get("allowed") or 10.0
+        tight = max(0.0, 1.0 - orb / allowed) if orb is not None and allowed else 0.0
+        return round(base * weight * (1.0 + tight), 2)
+    return round(base, 2)

services/logic/app/significators.py

@@ -15,6 +15,7 @@ from typing import Any, Protocol
 
 from app.abbreviations import expand
 from app.engine.formats import SIGN_ABBR, SIGNS
+from app.scoring import score_facet
 
 PLANET_ABBR = {
     "Sun": "Su", "Moon": "Mo", "Mercury": "Me", "Venus": "Ve", "Mars": "Ma",
@@ -57,27 +58,69 @@ def _ordinal(n: int) -> str:
     return f"{n}{suffix}"
 
 
-def _facet_samples(rows: list[dict], token: str, limit: int = 4) -> list[dict]:
+def _norm(s: str) -> str:
-    """Rekordy, których sygnifikator zawiera token — bez szumu."""
+    """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 "")
+        sig = str(r.get("significator") or "").strip()
-        if tok not in sig.lower():
+        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 _group_by_effect(samples: list[dict]) -> list[dict]:
+    """Grupuje próbki po opisie: ten sam efekt = jedna grupa z listą sygnifikatorów."""
+    groups: dict[str, dict] = {}
+    order: list[str] = []
+    for s in samples:
+        key = _norm(s["effect"])
+        g = groups.get(key)
+        if g is None:
+            g = {"effect": s["effect"], "count": 0, "significators": []}
+            groups[key] = g
+            order.append(key)
+        g["count"] += 1
+        g["significators"].append(s["expanded"])
+    result = [groups[k] for k in order]
+    result.sort(key=lambda g: g["count"], reverse=True)
+    return result
+
+
+def build_report(
+    positions: list[dict],
+    data: DataSource,
+    aspects: 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: jedno zapytanie o token planety, potem faseta „w znaku"
+    Dla każdego obiektu fasety: „w znaku", „w domu" oraz „w aspekcie" (dla każdego
-    i „w domu" (jeśli dom policzony).
+    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 +141,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 +150,37 @@ 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}",
+                "aspect": asp["aspect"], "orb": asp.get("orb"), "allowed": asp.get("allowed"),
+                "count": len(asp_samples), "samples": asp_samples,
+            })
+
+        # punktacja siły (LOG-21), opcjonalne grupowanie po opisie, ranking faset
+        for f in facets:
+            f["score"] = score_facet(f)
+            if group:
+                f["groups"] = _group_by_effect(f["samples"])
+        facets.sort(key=lambda f: f["score"], reverse=True)
+
         items.append({
             "object": name,
             "sign": sign,

services/logic/tests/test_aspects.py

@@ -0,0 +1,35 @@
+"""Testy aspektów (LOG-06) — czysta matematyka."""
+from app.engine.aspects import find_aspects, separation
+
+
+def test_separation_wraparound():
+    assert separation(10, 350) == 20
+    assert separation(0, 180) == 180
+    assert separation(0, 90) == 90
+
+
+def test_conjunction_and_opposition():
+    pos = [
+        {"name": "Sun", "decimal": 10.0},
+        {"name": "Moon", "decimal": 12.0},   # 2° od Słońca -> koniunkcja
+        {"name": "Mars", "decimal": 190.0},  # 180° od Słońca -> opozycja
+    ]
+    pairs = {(a["obj1"], a["obj2"], a["aspect"]) for a in find_aspects(pos)}
+    assert ("Sun", "Moon", "conjunction") in pairs
+    assert ("Sun", "Mars", "opposition") in pairs
+
+
+def test_orb_limit_excludes_wide():
+    pos = [{"name": "Mercury", "decimal": 0.0}, {"name": "Venus", "decimal": 100.0}]
+    assert find_aspects(pos, orb=8.0, luminary_bonus=0.0) == []
+
+
+def test_luminary_bonus_widens_orb():
+    # 99.5° -> 9.5° od kwadratury; z bonusem luminarza (8+2) mieści się
+    pos = [{"name": "Sun", "decimal": 0.0}, {"name": "Saturn", "decimal": 99.5}]
+    assert any(a["aspect"] == "square" for a in find_aspects(pos))
+
+
+def test_one_aspect_per_pair():
+    pos = [{"name": "Sun", "decimal": 0.0}, {"name": "Moon", "decimal": 2.0}]
+    assert len(find_aspects(pos)) == 1

services/logic/tests/test_scoring.py

@@ -0,0 +1,20 @@
+"""Testy punktacji siły faset (LOG-21)."""
+from app.scoring import score_facet
+
+
+def test_sign_and_house_base():
+    assert score_facet({"type": "sign"}) == 5.0
+    assert score_facet({"type": "house"}) == 5.0
+
+
+def test_tighter_aspect_scores_higher():
+    tight = score_facet({"type": "aspect", "aspect": "conjunction", "orb": 0.0, "allowed": 10.0})
+    loose = score_facet({"type": "aspect", "aspect": "conjunction", "orb": 9.0, "allowed": 10.0})
+    assert tight > loose
+    assert tight == 12.0     # 6.0 * 1.0 * (1 + 1)
+
+
+def test_conjunction_beats_sextile_at_same_orb():
+    conj = score_facet({"type": "aspect", "aspect": "conjunction", "orb": 2.0, "allowed": 10.0})
+    sext = score_facet({"type": "aspect", "aspect": "sextile", "orb": 2.0, "allowed": 10.0})
+    assert conj > sext

services/logic/tests/test_significators.py

@@ -38,6 +38,51 @@ def test_no_house_facet_when_house_missing():
     assert "sign" in types and "house" not in types
 
 
+def test_dedup_by_significator_and_effect():
+    positions = [{"name": "Moon", "sign": "Taurus", "direction": "D", "house": 11}]
+    data = FakeData({"[Mo": [
+        {"significator": "[Mo in 11th H.", "actioneffect": "efekt"},
+        {"significator": "[Mo in 11th H.", "actioneffect": "efekt"},        # duplikat (sig+opis)
+        {"significator": "[Mo in 11th H.", "actioneffect": "inny efekt"},   # ten sam sig, inny opis
+    ]})
+    facets = {f["type"]: f for f in build_report(positions, data)["objects"][0]["facets"]}
+    assert facets["house"]["count"] == 2   # duplikat odsiany, różny opis zostaje
+
+
+def test_aspect_facet():
+    positions = [
+        {"name": "Sun", "sign": "Taurus", "direction": "D", "house": 11},
+        {"name": "Moon", "sign": "Taurus", "direction": "D", "house": 11},
+    ]
+    aspects = [{"obj1": "Sun", "obj2": "Moon", "aspect": "conjunction", "orb": 2.0}]
+    data = FakeData({"[Su": [{"significator": "[Su [conj [Mo", "actioneffect": "złączeni"}]})
+    sun = build_report(positions, data, aspects=aspects)["objects"][0]
+    asp = [f for f in sun["facets"] if f["type"] == "aspect"]
+    assert asp and asp[0]["count"] == 1 and "Moon" in asp[0]["label"]
+
+
+def test_grouping_by_effect():
+    positions = [{"name": "Mars", "sign": "Scorpio", "direction": "Rx", "house": 5}]
+    data = FakeData({"[Ma": [
+        {"significator": "[Ma in 5th H.", "actioneffect": "miscarriage"},
+        {"significator": "[Sa in 5th H.", "actioneffect": "miscarriage"},   # inny sig, ten sam opis
+        {"significator": "[Ma in 5th H.", "actioneffect": "fever"},
+    ]})
+    house = [f for f in build_report(positions, data, group=True)["objects"][0]["facets"]
+             if f["type"] == "house"][0]
+    groups = {g["effect"]: g for g in house["groups"]}
+    assert groups["miscarriage"]["count"] == 2
+    assert len(groups["miscarriage"]["significators"]) == 2
+    assert "score" in house
+
+
+def test_facets_carry_score():
+    positions = [{"name": "Sun", "sign": "Taurus", "direction": "D", "house": 11}]
+    data = FakeData({"[Su": [{"significator": "[Su in [Tau", "actioneffect": "e"}]})
+    facets = build_report(positions, data)["objects"][0]["facets"]
+    assert all("score" in f for f in facets)
+
+
 def test_ordinal():
     assert _ordinal(1) == "1st" and _ordinal(2) == "2nd" and _ordinal(3) == "3rd"
     assert _ordinal(4) == "4th" and _ordinal(11) == "11th" and _ordinal(12) == "12th"

services/presentation/app/clients/logic_client.py

@@ -44,9 +44,11 @@ class LogicClient:
             r.raise_for_status()
             return r.json()
 
-    def report(self, when_utc_iso: str, lat: float, lon: float, limit: int = 5000) -> dict[str, Any]:
+    def report(
+        self, when_utc_iso: str, lat: float, lon: float, limit: int = 5000, group: bool = False
+    ) -> dict[str, Any]:
         """Sygnifikatory z obliczeń szukane w bazie — woła logic /chart/report."""
-        payload = {"when_utc": when_utc_iso, "lat": lat, "lon": lon, "limit": limit}
+        payload = {"when_utc": when_utc_iso, "lat": lat, "lon": lon, "limit": limit, "group": group}
         with httpx.Client(timeout=max(settings.http_timeout, 30.0)) as client:
             r = client.post(f"{self.base_url}/chart/report", json=payload)
             r.raise_for_status()

services/presentation/app/main.py

@@ -114,13 +114,15 @@ def interpret_run(
     tz_offset: float = Form(0.0),
     lat: float = Form(0.0),
     lon: float = Form(0.0),
+    group: bool = Form(False),
 ):
-    form = {"date": date, "time": time, "tz_offset": tz_offset, "lat": lat, "lon": lon}
+    form = {"date": date, "time": time, "tz_offset": tz_offset,
+            "lat": lat, "lon": lon, "group": group}
     ctx: dict = {"form": form, "result": None, "error": None, "moment": None}
     try:
         iso_utc, label = _build_utc(date, time, tz_offset)
         ctx["moment"] = label
-        ctx["result"] = logic.report(when_utc_iso=iso_utc, lat=lat, lon=lon)
+        ctx["result"] = logic.report(when_utc_iso=iso_utc, lat=lat, lon=lon, group=group)
     except httpx.HTTPError as e:
         ctx["error"] = _logic_error(e)
     except ValueError as e:

services/presentation/app/static/styles.css

@@ -61,4 +61,6 @@ tr:last-child td { border-bottom: none; }
 .samples td.nowrap { color: var(--accent); padding-right: 1rem; }
 .facet { margin: .4rem 0 .6rem 1rem; }
 .facet-head { color: var(--ink); font-size: .9rem; }
+.badge { display: inline-block; font-size: .72rem; padding: .05rem .4rem; border-radius: 6px;
+         background: #2a2d4a; color: var(--accent); margin-left: .3rem; }
 .samples td.sig { color: var(--accent); padding-right: 1rem; cursor: help; }

services/presentation/app/templates/chart.html

@@ -83,6 +83,18 @@
     </tbody>
   </table>
 
+  {% if result.aspects %}
+  <div class="meta">Aspekty główne ({{ result.aspects | length }})</div>
+  <table class="angles">
+    <thead><tr><th>Obiekt 1</th><th>Aspekt</th><th>Obiekt 2</th><th>Orb</th></tr></thead>
+    <tbody>
+      {% for a in result.aspects %}
+        <tr><td>{{ a.obj1 }}</td><td>{{ a.aspect }}</td><td>{{ a.obj2 }}</td><td class="mono">{{ '%.2f'|format(a.orb) }}°</td></tr>
+      {% endfor %}
+    </tbody>
+  </table>
+  {% endif %}
+
   {% if result.cusps %}
   <details class="loc">
     <summary>Cusps domów ({{ result.house_system }})</summary>
@@ -107,6 +119,13 @@
       d.getFullYear() + '-' + pad(d.getMonth() + 1) + '-' + pad(d.getDate());
     document.querySelector('input[name=time]').value = pad(d.getHours()) + ':' + pad(d.getMinutes());
     document.querySelector('input[name=tz_offset]').value = (-d.getTimezoneOffset() / 60);
+    // bajer: lokalizacja z przeglądarki (wymaga zgody; działa na https/localhost)
+    if (navigator.geolocation) {
+      navigator.geolocation.getCurrentPosition(function (pos) {
+        document.querySelector('input[name=lat]').value = pos.coords.latitude.toFixed(4);
+        document.querySelector('input[name=lon]').value = pos.coords.longitude.toFixed(4);
+      });
+    }
   });
 </script>
 {% endblock %}

services/presentation/app/templates/interpret.html

@@ -23,6 +23,9 @@
       <input type="number" name="lon" step="0.0001" value="{{ form.lon if form.lon is not none else 0 }}">
     </label>
   </div>
+  <div class="opts">
+    <label><input type="checkbox" name="group" value="true" {{ 'checked' if form.group else '' }}> grupuj identyczne opisy</label>
+  </div>
   <div class="actions">
     <button type="button" id="nowBtn" class="ghost">Tu i teraz</button>
     <button type="submit">Szukaj interpretacji</button>
@@ -51,8 +54,20 @@
       {% for f in o.facets %}
         <div class="facet">
           <div class="facet-head">{{ f.label }} — <strong>{{ f.count }}</strong> dopasowań
+            <span class="badge" title="siła (LOG-21)">siła {{ f.score }}</span>
             <span class="muted small">[{{ f.token }}]</span></div>
-          {% if f.samples %}
+          {% if f.groups %}
+            <table class="samples">
+              <tbody>
+                {% for g in f.groups %}
+                  <tr>
+                    <td>{{ g.effect }}{% if g.count > 1 %} <span class="badge">×{{ g.count }}</span>{% endif %}</td>
+                    <td class="sig small">{{ g.significators | join('; ') }}</td>
+                  </tr>
+                {% endfor %}
+              </tbody>
+            </table>
+          {% elif f.samples %}
             <table class="samples">
               <tbody>
                 {% for s in f.samples %}
@@ -75,6 +90,13 @@
       d.getFullYear() + '-' + pad(d.getMonth() + 1) + '-' + pad(d.getDate());
     document.querySelector('input[name=time]').value = pad(d.getHours()) + ':' + pad(d.getMinutes());
     document.querySelector('input[name=tz_offset]').value = (-d.getTimezoneOffset() / 60);
+    // bajer: lokalizacja z przeglądarki (wymaga zgody; działa na https/localhost)
+    if (navigator.geolocation) {
+      navigator.geolocation.getCurrentPosition(function (pos) {
+        document.querySelector('input[name=lat]').value = pos.coords.latitude.toFixed(4);
+        document.querySelector('input[name=lon]').value = pos.coords.longitude.toFixed(4);
+      });
+    }
   });
 </script>
 {% endblock %}