Merge origin/master do PRE-16: naprawa regresji strumienia postepu

Konflikt w logic_client.py::positions() rozwiazany biorac OBIE zmiany:
routing przez szyfrowane _post() (PRE-16) + dluzszy timeout takze dla tables
(LOG-23) — warunek (stations or tables).

Wazniejsza rzecz, ktora scalenie ujawnilo: okno postepu (#19/#22) i szyfrowanie
lacz (#21) powstaly na rownoleglych galeziach, ktore sie nie widzialy. Po
zejsciu razem strumien horoskopu szedl SUROWYM httpx, z pominieciem szyfrowania.
Przy wlaczonym LINK_ENCRYPTION_REQUIRED serwer odrzucalby to zadanie (400), a
nawet bez wymagania odpowiedz wracalaby jako nieczytelne ramki — okno postepu
przestaloby dzialac na produkcji.

Naprawa:
- nowy link_crypto.stream_lines(): strumieniowe POST przez szyfrowane lacze;
  pieczetuje zadanie i odszyfrowuje odpowiedz ramka po ramce, sklejajac bufor bo
  granice ramek nie pokrywaja sie z granicami linii NDJSON. Dostarczanie na zywo
  zachowane. Bez klucza — jak dotad (dev).
- horoscope_stream() w kliencie idzie teraz przez stream_lines zamiast surowego
  client.stream.
- fail-closed takze dla strumienia: bez klucza przy wymaganym szyfrowaniu klient
  nie wysyla NIC (wczesniej cialo — dane urodzenia — szloby w eter, dopiero potem
  serwer odmawial). Ujednolica kontrakt z call().

Weryfikacja e2e na prawdziwym uvicornie z podsluchem gniazda: z kluczem strumien
dziala (5 etapow + result, na zywo), na kablu ZERO tresci bazy (grep=0; jedyne
'horoscope' to sciezka URL w naglowku, ktory z zalozenia jest jawny); bez klucza
klient zatrzymuje sie przed wyslaniem.

Testy: +4 na stream_lines (round-trip, sciezka jawna, fail-closed serwera i
klienta), niezmiennik strukturalny rozszerzony o stream_lines jako droge w dol
(sprawdzone celowym zepsuciem — czerwienieje). Calosc: logika 234 passed /
1 skipped, prezentacja 25 passed.

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

services/logic/app/main.py

@@ -44,6 +44,7 @@ class PositionsRequest(BaseModel):
     objects: list[str] | None = None
     house_system: str = "whole_sign"   # whole_sign | equal | porphyry
     stations: bool = False             # licz stacje (LOG-03; wolniejsze — root-findy)
+    tables: bool = False               # tabele dodatkowe (LOG-23; szuka wschodu/zachodu)
     zodiac: str = "tropical"           # LOG-04: tropical | sidereal_{lahiri,fagan_bradley,krishnamurti} | draconic
 
 
@@ -75,6 +76,10 @@ def chart_positions(req: PositionsRequest) -> dict:
             st = find_stations(engine, moment, p["name"])
             if st:
                 p["stations"] = st
+    if req.tables:
+        from app.engine.tables import build_tables
+
+        chart["tables"] = build_tables(engine, moment, chart)
     return chart
 
 
@@ -268,6 +273,72 @@ def chart_horoscope(req: HoroscopeRequest) -> dict:
     return out
 
 
+@app.post("/chart/horoscope/stream")
+def chart_horoscope_stream(req: HoroscopeRequest):
+    """To samo co /chart/horoscope, ale strumieniuje POSTĘP w trakcie pracy.
+
+    Pisanie horoskopu trwa minutami — bez sygnału aplikacja wygląda na zawieszoną.
+    Strumień (NDJSON, jedna linia = jedno zdarzenie) niesie RZECZYWISTE etapy:
+    budowę promptu, limity modelu i każdą turę generowania. Ostatnie zdarzenie
+    (`result`) ma identyczny kształt co odpowiedź zwykłego endpointu.
+    """
+    from fastapi.responses import StreamingResponse
+
+    from app.progress import stream
+
+    def work(emit) -> dict:
+        from app.llm.base import LLMError
+        from app.llm.factory import build_provider
+        from app.llm.limits import plan
+
+        emit({"type": "stage", "message": "Liczę horoskop i szukam wskazań w bazach…"})
+        out = chart_prompt(req)
+        st = out.get("stats", {})
+        emit({"type": "stage", "message":
+              f"Prompt gotowy: {st.get('chars', 0)} znaków, "
+              f"wskazań {st.get('included', 0)}"
+              + (f", pominięto {st['omitted']}" if st.get("omitted") else "")})
+        if out.get("data_error"):
+            emit({"type": "warn", "message": out["data_error"]})
+
+        try:
+            provider = build_provider(req.provider, req.model)
+            emit({"type": "stage", "message":
+                  f"Dostawca: {provider.name}, model: {provider.model}"
+                  + ("" if not provider.leaves_lan else " — dane opuszczają sieć")})
+
+            emit({"type": "stage", "message": "Liczę tokeny promptu…"})
+            prompt_tokens = provider.count_tokens(out["prompt"])
+            budget = plan(provider.name, provider.model, prompt_tokens, req.max_tokens)
+            out["token_plan"] = budget
+            emit({"type": "stage", "message":
+                  f"Prompt {prompt_tokens} tok. · okno modelu {budget['context_window']} · "
+                  f"na odpowiedź {budget['max_output']}"})
+            for warning in budget["warnings"]:
+                emit({"type": "warn", "message": warning})
+            if budget["warnings"]:
+                out["warnings"] = budget["warnings"]
+            if not budget["fits"]:
+                out["llm_error"] = " ".join(budget["warnings"])
+                return out
+
+            result = provider.generate(out["prompt"], budget["max_output"], on_event=emit)
+        except LLMError as e:
+            emit({"type": "warn", "message": f"Model zawiódł: {e}"})
+            out["llm_error"] = str(e)
+            return out
+
+        out.update(horoscope=result.text, provider=result.provider, model=result.model,
+                   leaves_lan=result.leaves_lan, usage=result.usage)
+        return out
+
+    return StreamingResponse(
+        stream(work),
+        media_type="application/x-ndjson",
+        headers={"Cache-Control": "no-store", "X-Accel-Buffering": "no"},
+    )
+
+
 @app.get("/llm/models")
 def llm_models() -> dict:
     """Podpowiedzi modeli per dostawca — UI buduje z tego listę wyboru.