From 8b6ecc727d023168160ba5693b50f8c8f5c92490 Mon Sep 17 00:00:00 2001
From: migatu <mtuszowski@gmail.com>
Date: Thu, 6 Aug 2026 13:55:13 +0200
Subject: [PATCH] =?UTF-8?q?feat(domy):=20przypisanie=20do=20domu=20przez?=
 =?UTF-8?q?=20wyroczni=C4=99=20+=20poprawki=20uk=C5=82adu=20strony?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

ETAP 5, część pierwsza: assign_house pod wyrocznią (swe_house_pos).
Osobny rodzaj błędu niż same cuspy — i od razu jeden znalazł.

BŁĄD: assign_house szło ZAWSZE do przodu. Przy dużych szerokościach systemy
dzielące koła wielkie mają kolejność domów ODWRÓCONĄ (przy φ=−84,3° cusp domu I
wypada na 174,2°, a domu II na 165,3°) — co nie jest usterką, bo wyrocznia zwraca
dokładnie te same wartości. Suma przeskoków „do przodu" wychodziła 3960° zamiast
360°, czyli każdy krok obchodził koło dookoła. Planety lądowały w złych domach
dla regiomontanusa, campanusa i topocentrica: 9,7-12,5% przypadków. Błąd cichy —
wykres wyglądał bez zarzutu. Kierunek bierzemy teraz z samych cuspów.

TOPOCENTRIC MA JEDNAK GRANICĘ DZIEDZINY — korekta tego, co pisałem wcześniej.
Cuspy są poprawne wszędzie (zgodne z wyrocznią co do zera), ale powyżej koła
podbiegunowego przestają DZIELIĆ OKRĄG: cusp VII (= I + 180°) wypada przed
cuspem VI i domy nachodzą na siebie. Przypisanie planety traci wtedy sens —
co potwierdza sama wyrocznia, której swe_house_pos przeczy tam własnym cuspom
(100% zgodności do 62°, 83,9% przy 66°, ok. 50% przy 72°; regiomontanus 100%
w tych samych punktach). Odmawiamy, z jawnym fallbackiem jak Placidus i Koch.

Próg jest WYPROWADZONY z warunku „dwanaście cuspów sumuje się do 360°", nie
dobrany pod wynik testu — i wypada na kole podbiegunowym (zmierzone: 100%
podziałów do 65°, 78% w pasie 66-67°). To inny rodzaj granicy niż u Placidusa
i Kocha: tam nie istnieją same cuspy, tu istnieją, tylko nie tworzą podziału.

Framework dostał pojęcie dziedziny WĘŻSZEJ niż wyroczni (NARROWER_THAN_ORACLE),
zamiast wyjątku „bo topocentric": skoro wyrocznia przeczy sama sobie, nie może
rozstrzygać, więc tam nie porównujemy — a nasze przypisanie jest w tym obszarze
sprawdzane testem samospójności z cuspami, bez swissepha.

UKŁAD STRONY — zmierzony na żywej stronie, nie na oko:
- tabela porównania przy 13 systemach miała 14 kolumn i 1863 px, a stała
  w rodzicu bez overflow-x, więc ROZPYCHAŁA CAŁY DOKUMENT: 1713 px przy oknie
  1280 px, poziomy pasek na body. Teraz ma własny kontener przewijany
  (dokument 1265 px, nie przewija się), a numer domu jest przyklejony do lewej,
  bo inaczej po przewinięciu nie wiadomo, który to wiersz.
- przypis „* nie działa za kołem podbiegunowym" siedział WEWNĄTRZ <label>
  selektora, łamał się na dwie linie i rozciągał wiersz siatki ze 66 do 108 px,
  rozjeżdżając go z sąsiednim polem. Wyjaśnienie stoi teraz raz, przy
  checkboxach z gwiazdkami; wiersz wrócił do 66 px.
- 13 checkboxów na flexie zawijało się w poszarpane wiersze — jest siatka
  o stałej szerokości kolumny (auto-fill, więc na wąskim ekranie kolumn mniej).

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
---
 services/logic/app/engine/houses.py           | 46 ++++++++++++-
 services/logic/tests/test_houses.py           | 64 +++++++++++++++++--
 services/presentation/app/static/styles.css   | 25 ++++++++
 .../app/templates/_form_options.html          |  6 +-
 .../app/templates/_result_tables.html         |  4 ++
 .../presentation/app/templates/chart.html     |  1 -
 .../presentation/app/templates/compile.html   |  1 -
 .../presentation/tests/test_house_compare.py  | 53 +++++++++++++++
 tests/oracle/domain.py                        |  9 ++-
 tests/oracle/harness.py                       | 64 ++++++++++++++++++-
 tests/oracle/run.py                           |  5 +-
 11 files changed, 260 insertions(+), 18 deletions(-)

diff --git a/services/logic/app/engine/houses.py b/services/logic/app/engine/houses.py
index 52e728d..1915df5 100644
--- a/services/logic/app/engine/houses.py
+++ b/services/logic/app/engine/houses.py
@@ -321,6 +321,22 @@ def _cusps_topocentric(ramc: float, eps: float, lat: float,
     Kusi, by liczyć to jak Regiomontanusa z podmienioną szerokością — daje wynik
     bliski, ale nie równy (kilka sekund łuku); wyrocznia rozstrzygnęła na rzecz
     konstrukcji „ascendent pod biegunem"."""
+    # Cuspy topocentrica są poprawne na CAŁEJ dziedzinie (zgodne z wyrocznią co do
+    # zera), ale powyżej koła podbiegunowego przestają DZIELIĆ OKRĄG: domy nachodzą
+    # na siebie, bo cusp VII (= I + 180°) wypada przed cuspem VI. Przypisanie planety
+    # do domu traci wtedy sens — co potwierdza sama wyrocznia, której swe_house_pos
+    # przeczy tam własnym cuspom (100% zgodności do 62°, 83,9% przy 66°, ok. 50%
+    # przy 72°). Odmawiamy, zamiast zwracać liczbę bez znaczenia.
+    #
+    # To INNY rodzaj granicy niż u Placidusa i Kocha: tam nie istnieją same cuspy,
+    # tu istnieją, tylko nie tworzą podziału. Próg jest wyprowadzony z warunku
+    # „dwanaście cuspów sumuje się do 360°", nie dobrany pod wynik testu — i wypada
+    # na kole podbiegunowym (zmierzone: 100% podziałów do 65°, 78% w pasie 66-67°).
+    if abs(lat) >= polar_circle(eps):
+        raise HouseSystemUndefined(
+            f"φ={lat:.4f}° powyżej koła podbiegunowego ({polar_circle(eps):.4f}° dla "
+            f"ε={eps:.4f}°): cuspy topocentryczne przestają dzielić okrąg, "
+            f"domy nachodzą na siebie")
     er, tan_lat = math.radians(eps), math.tan(math.radians(lat))
     epole = _ecliptic_pole(er)
     # Gdy MC górujące rozjeżdża się z matematycznym (za kołem podbiegunowym),
@@ -534,14 +550,38 @@ def cusps_detailed(ramc: float, eps: float, lat: float, system: str) -> CuspSet:
                        FALLBACK_SYSTEM, system, str(e))
 
 
+def _runs_forward(cusp_list: list[float]) -> bool:
+    """Czy domy biegną w stronę rosnących długości ekliptycznych.
+
+    Zwykle tak — ale NIE ZAWSZE. Przy dużych szerokościach systemy dzielące koła
+    wielkie (regiomontanus, campanus, topocentric) mają kolejność ODWRÓCONĄ:
+    przy φ = −84,3° cusp domu I wypada na 174,2°, a domu II na 165,3°. To nie
+    jest błąd — wyrocznia zwraca dokładnie te same wartości.
+
+    Rozstrzygamy sumą przeskoków „do przodu": dwanaście cuspów dzieli okrąg, więc
+    idąc we WŁAŚCIWĄ stronę zsumują się do 360°. Idąc pod prąd każdy przeskok
+    obchodzi koło dookoła i suma wychodzi 11 × 360° = 3960°."""
+    total = sum((cusp_list[(i + 1) % 12] - cusp_list[i]) % 360.0 for i in range(12))
+    return abs(total - 360.0) < abs(total - 3960.0)
+
+
 def assign_house(lon: float, cusp_list: list[float]) -> int:
-    """Numer domu (1..12), w którym leży dana długość ekliptyczna."""
+    """Numer domu (1..12), w którym leży dana długość ekliptyczna.
+
+    Kierunek liczenia bierzemy z samych cuspów. Zaszycie „zawsze do przodu"
+    dawało przy |φ| powyżej koła podbiegunowego złe domy dla regiomontanusa,
+    campanusa i topocentrica — mimo cuspów zgodnych z wyrocznią co do zera.
+    Błąd był CICHY: wykres wyglądał poprawnie, tylko planety siedziały gdzie
+    indziej. Sprawdzane wobec swe_house_pos (tests/oracle)."""
     lon = norm360(lon)
+    forward = _runs_forward(cusp_list)
     for i in range(12):
         start = cusp_list[i]
         end = cusp_list[(i + 1) % 12]
-        span = (end - start) % 360.0
-        offset = (lon - start) % 360.0
+        if forward:
+            span, offset = (end - start) % 360.0, (lon - start) % 360.0
+        else:
+            span, offset = (start - end) % 360.0, (start - lon) % 360.0
         if offset < span:
             return i + 1
     return 12
diff --git a/services/logic/tests/test_houses.py b/services/logic/tests/test_houses.py
index 6e492af..18f805f 100644
--- a/services/logic/tests/test_houses.py
+++ b/services/logic/tests/test_houses.py
@@ -213,7 +213,7 @@ def test_topocentric_cusps_stay_in_order_between_mc_and_ascendant():
     def d(a, b):
         return H.norm360(b - a)
 
-    for lat in (-89.9, -79.55, -67.18, 0.0, 50.06, 73.69, 80.66, 89.9):
+    for lat in (-66.0, -50.0, -20.0, 0.0, 20.0, 50.06, 66.0):
         c = H.cusps_for(129.2387, 23.4393, lat, "topocentric")
         mc, c11, c12, asc = c[9], c[10], c[11], c[0]
         forward = d(mc, c11) + d(c11, c12) + d(c12, asc)
@@ -223,13 +223,23 @@ def test_topocentric_cusps_stay_in_order_between_mc_and_ascendant():
             f"φ={lat}: MC={mc:.3f} 11={c11:.3f} 12={c12:.3f} Asc={asc:.3f} nie po kolei"
 
 
-def test_topocentric_needs_no_domain_limit():
-    """W przeciwieństwie do Placidusa/Kocha topocentric liczy się WSZĘDZIE —
-    nie ma tu granicy dziedziny do wyprowadzenia, więc nie wolno jej udawać."""
-    for lat in (0.0, 66.5, 69.65, 89.9, -89.9):
+def test_topocentric_refuses_where_its_houses_stop_partitioning_the_circle():
+    """Topocentric ma granicę INNEGO rodzaju niż Placidus i Koch.
+
+    Same cuspy są poprawne wszędzie (zgodne z wyrocznią co do zera), ale powyżej
+    koła podbiegunowego przestają dzielić okrąg — cusp VII (= I + 180°) wypada
+    przed cuspem VI i domy nachodzą na siebie. Przypisanie planety do domu traci
+    wtedy sens, więc odmawiamy zamiast zwracać liczbę bez znaczenia.
+
+    Próg jest WYPROWADZONY z warunku „dwanaście cuspów sumuje się do 360°",
+    a nie dobrany pod wynik testu — i wypada na kole podbiegunowym."""
+    for lat in (0.0, 50.06, 66.0):
         assert len(H.cusps_for(100.0, 23.4393, lat, "topocentric")) == 12
+    for lat in (69.65, 89.9, -89.9):
+        with pytest.raises(H.HouseSystemUndefined):
+            H.cusps_for(100.0, 23.4393, lat, "topocentric")
     cs = H.cusps_detailed(100.0, 23.4393, 89.9, "topocentric")
-    assert not cs.is_fallback and cs.notice is None
+    assert cs.is_fallback and cs.notice and "topocentric" in cs.notice
 
 
 def test_whole_sign_aries_ignores_the_ascendant():
@@ -294,3 +304,45 @@ def test_true_obliquity_stays_in_a_sane_band_across_the_date_range():
     for year in (1600, 1900, 2000, 2100):
         t = ts.from_datetime(datetime(year, 6, 1, tzinfo=timezone.utc))
         assert 23.2 < true_obliquity(t) < 23.8, year
+
+
+# ── przypisanie obiektu do domu ──────────────────────────────────────────
+
+REVERSED = (108.456, 23.4393, -84.324)      # tu domy biegną WSTECZ
+
+
+def test_cusps_can_run_backwards_at_extreme_latitudes():
+    """Nie jest to błąd, tylko własność tych systemów — wyrocznia zwraca to samo.
+    Test istnieje po to, żeby nikt tego „nie naprawił"."""
+    ramc, eps, lat = REVERSED
+    c = H.cusps_for(ramc, eps, lat, "regiomontanus")
+    assert c[1] < c[0] and c[2] < c[1], "kolejność miała być odwrócona"
+    assert not H._runs_forward(c)
+    assert H._runs_forward(H.cusps_for(ramc, eps, 50.0, "regiomontanus"))
+
+
+@pytest.mark.parametrize("system", H.SYSTEMS)
+def test_every_point_lands_in_exactly_one_house(system):
+    """Cuspy dzielą okrąg bez luk i bez zakładek, więc każdy punkt ma dokładnie
+    jeden dom, a cusp trafia do domu, który zaczyna. Sprawdzian SAMOSPÓJNOŚCI —
+    działa bez swissepha, także tam, gdzie sama wyrocznia przeczy sobie
+    (topocentric powyżej koła podbiegunowego)."""
+    for ramc, eps, lat in (REVERSED, (100.0, 23.4393, 50.06), (210.33, 23.4393, 72.675)):
+        try:
+            cusps = H.cusps_for(ramc, eps, lat, system)
+        except H.HouseSystemUndefined:
+            continue
+        for i, cusp in enumerate(cusps):
+            assert H.assign_house(cusp, cusps) == i + 1, f"{system}: cusp {i+1}"
+        seen = {H.assign_house(lon / 4.0, cusps) for lon in range(0, 1440)}
+        assert seen == set(range(1, 13)), f"{system}: puste albo zdublowane domy {sorted(seen)}"
+
+
+def test_assign_house_follows_the_cusps_not_a_fixed_direction():
+    """Regresja: zaszyte „zawsze do przodu" dawało przy |φ| za kołem podbiegunowym
+    złe domy dla systemów dzielących koła wielkie — mimo cuspów zgodnych
+    z wyrocznią co do zera. Błąd był cichy: wykres wyglądał poprawnie."""
+    ramc, eps, lat = REVERSED
+    cusps = H.cusps_for(ramc, eps, lat, "regiomontanus")
+    # 1,7822° leży między cuspem 6 (4,458°) a 7 (354,228°) — patrząc WSTECZ
+    assert H.assign_house(1.7822, cusps) == 6
diff --git a/services/presentation/app/static/styles.css b/services/presentation/app/static/styles.css
index e2ff58d..7da19f8 100644
--- a/services/presentation/app/static/styles.css
+++ b/services/presentation/app/static/styles.css
@@ -91,6 +91,16 @@ input, select, button {
 button { background: var(--accent); color: #fff; border: none; cursor: pointer; padding-inline: 1.25rem; }
 button:hover { filter: brightness(1.1); }
 .opts { display: flex; gap: 1.5rem; margin-top: .75rem; color: var(--muted); align-items: center; }
+
+/* Lista systemów domów urosła z 3 do 13 pozycji. Na flexie zawijały się w cztery
+   poszarpane wiersze o różnej długości; siatka o stałej szerokości kolumny ustawia
+   nazwy w pionie i daje się przeczytać wzrokiem. auto-fill, więc na wąskim ekranie
+   kolumn jest po prostu mniej. */
+.opts.systems { display: grid; grid-template-columns: repeat(auto-fill, minmax(11.5rem, 1fr));
+                gap: .35rem 1rem; align-items: start; }
+.opts.systems > .opts-label { grid-column: 1 / -1; margin-bottom: .1rem; }
+.opts.systems label { display: flex; align-items: center; gap: .35rem; }
+.opts .hint { font-style: normal; opacity: .75; }
 .opts input[type=number] { width: 5rem; }
 .meta { color: var(--muted); margin: 1.5rem 0 .5rem; font-size: .9rem; }
 
@@ -108,6 +118,21 @@ button:hover { filter: brightness(1.1); }
 .error { background: #3a1320; border: 1px solid #6a2233; color: #ffb3c0; padding: .75rem 1rem; border-radius: 8px; margin-top: 1.5rem; }
 .empty { color: var(--muted); }
 table { width: 100%; border-collapse: collapse; margin-top: .5rem; background: var(--panel); border-radius: 12px; overflow: hidden; }
+
+/* Tabela porównania systemów domów ma tyle kolumn, ile zaznaczono systemów —
+   przy komplecie trzynastu robi się 1520 px i ROZPYCHAŁA CAŁĄ STRONĘ (dokument
+   1713 px przy oknie 1280 px, poziomy pasek przewijania na body). Przewijać ma
+   się sama tabela, nigdy strona. */
+.table-scroll { overflow-x: auto; margin-top: .5rem; border-radius: 12px; }
+.table-scroll > table { margin-top: 0; border-radius: 0; }
+.table-scroll th, .table-scroll td { white-space: nowrap; }
+
+/* Numer domu przyklejony do lewej krawędzi: bez tego po przewinięciu w prawo
+   nie wiadomo, który to wiersz. */
+.table-scroll th:first-child, .table-scroll td:first-child {
+  position: sticky; left: 0; background: var(--panel); z-index: 1;
+  box-shadow: 1px 0 0 var(--line);
+}
 th, td { text-align: left; padding: .6rem .8rem; border-bottom: 1px solid var(--line); }
 th { color: var(--accent); font-size: .8rem; text-transform: uppercase; letter-spacing: .5px; }
 tr:last-child td { border-bottom: none; }
diff --git a/services/presentation/app/templates/_form_options.html b/services/presentation/app/templates/_form_options.html
index c49d8ce..91816ba 100644
--- a/services/presentation/app/templates/_form_options.html
+++ b/services/presentation/app/templates/_form_options.html
@@ -7,9 +7,11 @@
   <label><input type="checkbox" name="tables" value="true" {{ 'checked' if form.tables else '' }}>
     tabele dodatkowe: żywioły, faza Księżyca, godziny planetarne (wolniejsze)</label>
 </div>
-<div class="opts" title="Domy dzielą to samo niebo inaczej. Zaznacz kilka, by porównać kuspy obok siebie (PRE-05). Kosmogram rysuje system wybrany wyżej.">
+<div class="opts systems" title="Domy dzielą to samo niebo inaczej. Zaznacz kilka, by porównać kuspy obok siebie (PRE-05). Kosmogram rysuje system wybrany wyżej.">
   {% set chosen = form.house_systems or [] %}
-  <span class="muted small">Porównaj systemy domów:</span>
+  <span class="muted small opts-label">Porównaj systemy domów
+    <em class="hint">— gwiazdka: nie działa za kołem podbiegunowym (ok. 66,5°); tam policzymy Porphyry i wyraźnie o tym napiszemy</em>
+  </span>
   {% for value, name in HOUSE_SYSTEMS %}
   <label><input type="checkbox" name="house_systems" value="{{ value }}" {{ 'checked' if value in chosen else '' }}> {{ name }}{{ ' *' if value in HOUSE_LIMITED else '' }}</label>
   {% endfor %}
diff --git a/services/presentation/app/templates/_result_tables.html b/services/presentation/app/templates/_result_tables.html
index 3b6143a..10f156e 100644
--- a/services/presentation/app/templates/_result_tables.html
+++ b/services/presentation/app/templates/_result_tables.html
@@ -29,6 +29,9 @@
 {# Porównanie systemów domów (PRE-05) — te same osie, inny podział na domy #}
 {% if result.house_systems and result.house_systems | length > 1 %}
 <div class="meta" title="Osie (Asc/MC) są wspólne — różni się podział na domy. Kosmogram rysuje pierwszy z listy.">Porównanie systemów domów ({{ result.house_systems | length }})</div>
+{# Przy komplecie systemów tabela jest szersza niż okno — przewija się SAMA,
+   zamiast rozpychać stronę (numer domu zostaje przyklejony do lewej). #}
+<div class="table-scroll">
 <table class="angles">
   <thead><tr><th>Dom</th>{% for hs in result.house_systems %}<th>{{ house_label(hs.system) }}</th>{% endfor %}</tr></thead>
   <tbody>
@@ -41,6 +44,7 @@
     {% endfor %}
   </tbody>
 </table>
+</div>
 {% endif %}
 
 <table>
diff --git a/services/presentation/app/templates/chart.html b/services/presentation/app/templates/chart.html
index 620bfbb..677d49a 100644
--- a/services/presentation/app/templates/chart.html
+++ b/services/presentation/app/templates/chart.html
@@ -38,7 +38,6 @@
         <option value="{{ value }}" {{ 'selected' if hs == value else '' }}>{{ name }}{{ ' *' if value in HOUSE_LIMITED else '' }}</option>
         {% endfor %}
       </select>
-      <span class="muted small" title="Placidus i Koch dzielą łuk dobowy, który powyżej koła podbiegunowego (ok. 66,5°) nie istnieje — dla takich miejsc policzymy Porphyry i wyraźnie o tym napiszemy.">* nie działa za kołem podbiegunowym</span>
     </label>
     <label>Zodiak
       <select name="zodiac">
diff --git a/services/presentation/app/templates/compile.html b/services/presentation/app/templates/compile.html
index 5fb7096..0cf4592 100644
--- a/services/presentation/app/templates/compile.html
+++ b/services/presentation/app/templates/compile.html
@@ -43,7 +43,6 @@ zapamiętane predykcje okresowe. Dane pobiera z pozostałych zakładek — nie t
         <option value="{{ value }}" {{ 'selected' if hs == value else '' }}>{{ name }}{{ ' *' if value in HOUSE_LIMITED else '' }}</option>
         {% endfor %}
       </select>
-      <span class="muted small" title="Placidus i Koch dzielą łuk dobowy, który powyżej koła podbiegunowego (ok. 66,5°) nie istnieje — dla takich miejsc policzymy Porphyry i wyraźnie o tym napiszemy.">* nie działa za kołem podbiegunowym</span>
     </label>
     <label>Zodiak
       <select name="zodiac">
diff --git a/services/presentation/tests/test_house_compare.py b/services/presentation/tests/test_house_compare.py
index 108761f..69ecc2a 100644
--- a/services/presentation/tests/test_house_compare.py
+++ b/services/presentation/tests/test_house_compare.py
@@ -154,3 +154,56 @@ def test_wheel_orientation_reaches_the_renderer(monkeypatch, orientation):
     r = c.post("/", data={**FORM, "wheel_orientation": orientation})
     assert r.status_code == 200, r.text[:400]
     assert f'value="{orientation}" checked' in r.text
+
+
+# ── układ strony przy komplecie systemów ────────────────────────────────
+# Regresja z pomiaru na żywej stronie: przy 13 zaznaczonych systemach tabela
+# porównania miała 14 kolumn i 1863 px szerokości, a że stała w rodzicu bez
+# overflow-x, ROZPYCHAŁA CAŁY DOKUMENT — 1713 px przy oknie 1280 px, czyli
+# poziomy pasek przewijania na body i rozjechany układ.
+
+CSS = (APP / "static" / "styles.css").read_text(encoding="utf-8")
+
+
+def test_comparison_table_scrolls_instead_of_widening_the_page():
+    """Tabela ma własny kontener przewijany — przewija się ona, nie strona."""
+    html = _render("_result_tables.html", result={
+        "house_systems": [{"system": v, "cusps": [
+            {"sign_glyph": "♈", "in_sign": "0°00'00''"} for _ in range(12)]}
+            for v, _ in HOUSE_SYSTEMS],
+        "house_warnings": []})
+    assert '<div class="table-scroll">' in html
+    before = html.index('class="table-scroll"')
+    assert html.index("<table", before) < html.index("</div>", before), \
+        "tabela musi być WEWNĄTRZ kontenera przewijanego"
+
+
+def test_scroll_container_actually_clips_and_pins_the_house_number():
+    """Sam znacznik nie wystarczy — reguła musi istnieć w arkuszu.
+
+    Geometrii nie da się sprawdzić bez przeglądarki, więc sprawdzamy kontrakt:
+    kontener przewija się w poziomie, a pierwsza kolumna zostaje przyklejona
+    (bez tego po przewinięciu w prawo nie wiadomo, który to dom)."""
+    assert ".table-scroll { overflow-x: auto;" in CSS
+    assert ".table-scroll th:first-child, .table-scroll td:first-child {" in CSS
+    assert "position: sticky" in CSS
+
+
+def test_system_checkboxes_use_a_grid_not_a_ragged_flex_wrap():
+    """13 pozycji na flexie zawijało się w poszarpane wiersze o różnej długości."""
+    html = _render("_form_options.html", form={})
+    assert 'class="opts systems"' in html
+    assert ".opts.systems { display: grid;" in CSS
+
+
+def test_polar_circle_note_is_explained_once_next_to_the_asterisks():
+    """Przypis siedział WEWNĄTRZ <label> selektora i łamał się na dwie linie,
+    przez co wiersz siatki rósł z 66 do 108 px i rozjeżdżał się z sąsiednim
+    polem. Wyjaśnienie stoi teraz raz, przy checkboxach z gwiazdkami."""
+    opts = _render("_form_options.html", form={})
+    assert "kołem podbiegunowym" in opts
+    for name in ("chart.html", "compile.html"):
+        tpl = (APP / "templates" / name).read_text(encoding="utf-8")
+        select = tpl[tpl.index("<select name=\"house_system\""):]
+        assert "podbiegunow" not in select[:select.index("</label>")], \
+            f"{name}: przypis wrócił do etykiety selektora"
diff --git a/tests/oracle/domain.py b/tests/oracle/domain.py
index c759060..ace1c70 100644
--- a/tests/oracle/domain.py
+++ b/tests/oracle/domain.py
@@ -29,6 +29,13 @@ JD_J2000 = 2_451_545.0    # punkt odniesienia — środek dziedziny
 # Systemy oparte na łuku dobowym: tracą definicję za kołem podbiegunowym.
 DIURNAL_ARC_SYSTEMS = frozenset({"placidus", "koch"})
 
+# Systemy, w których NASZA dziedzina jest WĘŻSZA niż wyroczni — świadomie, nie przez
+# rozjazd. Topocentric: swisseph zwraca powyżej koła podbiegunowego cuspy, które nie
+# dzielą okręgu (domy nachodzą na siebie), i sam sobie tam przeczy — swe_house_pos
+# nie zgadza się z jego własnymi cuspami. Wolimy odmówić niż podać liczbę bez
+# znaczenia, więc harness ma tego NIE zgłaszać jako niezgodności dziedziny.
+NARROWER_THAN_ORACLE = frozenset({"topocentric"})
+
 # Jak blisko granicy stawiamy wartości brzegowe (po obu stronach).
 EPSILON_NUDGE = 0.01
 
@@ -65,7 +72,7 @@ def in_domain(system: str, lat: float, jd: float) -> bool:
     (i same bieguny, gdzie degeneruje się cała geometria)."""
     if abs(lat) >= 90.0:
         return False
-    if system in DIURNAL_ARC_SYSTEMS:
+    if system in DIURNAL_ARC_SYSTEMS or system in NARROWER_THAN_ORACLE:
         return abs(lat) < polar_circle(jd)
     return True
 
diff --git a/tests/oracle/harness.py b/tests/oracle/harness.py
index 3329205..3615296 100644
--- a/tests/oracle/harness.py
+++ b/tests/oracle/harness.py
@@ -16,11 +16,12 @@ do ścieżki produkcyjnej ani do zależności produktu — izolacja z LOG-27 zos
 """
 from __future__ import annotations
 
+import random
 from dataclasses import dataclass, field
 
 import swisseph as swe
 
-from domain import Case, in_domain, obliquity
+from domain import NARROWER_THAN_ORACLE, Case, in_domain, obliquity
 
 # Litery systemów w Swiss Ephemeris.
 SWE_CODE = {
@@ -110,12 +111,16 @@ def compare_system(system: str, cases: list[Case]) -> Result:
 
         # Zgodność co do DZIEDZINY: jeśli wyrocznia odmawia, a my uważamy, że
         # liczymy — nasza detekcja granicy jest zepsuta (albo odwrotnie).
-        if (theirs is None) != (not ours_in_domain):
+        # Węższa dziedzina po naszej stronie jest świadoma (patrz NARROWER_THAN_ORACLE),
+        # więc nie jest rozjazdem. Odwrotność — my liczymy, wyrocznia odmawia — nadal jest.
+        narrower_on_purpose = (system in NARROWER_THAN_ORACLE
+                               and theirs is not None and not ours_in_domain)
+        if not narrower_on_purpose and (theirs is None) != (not ours_in_domain):
             r.domain_mismatch.append(
                 f"{c.key()} [{c.label}] — my:{'w dziedzinie' if ours_in_domain else 'poza'}, "
                 f"wyrocznia:{'odmawia' if theirs is None else 'liczy'}")
             continue
-        if theirs is None:
+        if theirs is None or not ours_in_domain:
             r.skipped_out_of_domain += 1
             continue
 
@@ -155,6 +160,59 @@ def histogram(devs: list[float]) -> str:
     return "\n".join(out)
 
 
+# Ile punktów ekliptyki sprawdzamy na jeden zestaw (RAMC, ε, φ).
+_PROBES_PER_CASE = 6
+
+
+def compare_house_assignment(system: str, cases: list[Case]) -> Result:
+    """Nasze przypisanie obiektu do domu vs swe_house_pos.
+
+    To OSOBNA funkcja od liczenia cuspów i osobny rodzaj błędu: cuspy mogą się
+    zgadzać co do zera, a planeta i tak wylądować w złym domu. Tak właśnie było —
+    przy |φ| powyżej koła podbiegunowego systemy dzielące koła wielkie mają
+    kolejność domów ODWRÓCONĄ, a nasze assign_house szło zawsze do przodu.
+
+    WYROCZNIA MA TU GRANICĘ WIARYGODNOŚCI. Dla topocentrica swe_house_pos
+    przestaje być zgodne z WŁASNYMI cuspami swissepha powyżej koła podbiegunowego
+    (zmierzone: 100% zgodności do 62°, 83,9% przy 66°, ok. 50% przy 72°; dla
+    regiomontanusa w tych samych punktach 100%). Skoro wyrocznia przeczy sama
+    sobie, nie może rozstrzygać — nie porównujemy tam, zamiast dopisywać wyjątek
+    „bo topocentric". Nasze przypisanie jest w tym obszarze sprawdzane inaczej:
+    testem samospójności z cuspami (services/logic/tests/test_houses.py).
+    """
+    from app.engine.houses import assign_house, cusps_for, polar_circle
+
+    r = Result(system=f"dom:{system}")
+    rng = random.Random(20260806)
+    for c in cases:
+        eps = obliquity(c.jd)
+        if system == "topocentric" and abs(c.lat) >= polar_circle(eps):
+            r.skipped_out_of_domain += 1
+            continue
+        try:
+            ours_cusps = cusps_for(c.ramc, eps, c.lat, system)
+        except Exception:
+            r.skipped_out_of_domain += 1
+            continue
+        for _ in range(_PROBES_PER_CASE):
+            lon = rng.uniform(0.0, 360.0)
+            try:
+                theirs = int(swe.house_pos(c.ramc % 360.0, c.lat, eps,
+                                           (lon, 0.0), SWE_CODE[system]))
+            except Exception:
+                r.skipped_out_of_domain += 1
+                continue
+            r.checked += 1
+            ours = assign_house(lon, ours_cusps)
+            if ours != theirs:
+                r.over_tolerance += 1
+                r.max_dev = max(r.max_dev, float(abs(ours - theirs)))
+                if len(r.domain_mismatch) < 5:
+                    r.domain_mismatch.append(
+                        f"{c.key()} lon={lon:.4f} — nasz dom {ours}, wyrocznia {theirs}")
+    return r
+
+
 def format_report(results: list[Result], seed: int | None = None) -> str:
     lines = ["", "=" * 78,
              "ZGODNOŚĆ Z WYROCZNIĄ (Swiss Ephemeris) — domy astrologiczne",
diff --git a/tests/oracle/run.py b/tests/oracle/run.py
index 445a7c3..53454f2 100644
--- a/tests/oracle/run.py
+++ b/tests/oracle/run.py
@@ -22,7 +22,8 @@ sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
 
 from domain import boundary_cases, interior_cases, random_cases  # noqa: E402
 from harness import (  # noqa: E402
-    SWE_CODE, compare_asc_mc, compare_system, format_report,
+    SWE_CODE, compare_asc_mc, compare_house_assignment, compare_system,
+    format_report,
 )
 
 # Systemy do sprawdzenia. Rośnie wraz z implementacją kolejnych (Etap 1 i 2) —
@@ -57,6 +58,8 @@ def main() -> int:
 
     results = [compare_asc_mc(cases)]
     results += [compare_system(s, cases) for s in systems]
+    # Przypisanie obiektu do domu — osobny rodzaj błędu niż same cuspy.
+    results += [compare_house_assignment(s, cases) for s in systems]
 
     print(f"\nprzypadków wejściowych: {len(cases)}  (tryb: {args.mode})")
     print(format_report(results, seed=seed_note))