Deploy sha-9a5957fcdef15b7e2623f8b147cda6026475aee0 — source build (no GHCR)

.dockerignore

@@ -0,0 +1,23 @@
+.git
+.github
+.ruff_cache
+**/__pycache__
+**/*.pyc
+**/.pytest_cache
+**/.mypy_cache
+**/node_modules
+frontend-react/node_modules
+frontend-react/dist
+backend/.env
+backend/test.db
+backend/cache
+**/*.md
+!README.md
+poprawka*.md
+antigravity_grantforge_swarm
+DEPLOYMENT.md
+ROADMAP.md
+KRSAPI.md
+OProgramie.md
+DEBUG_*.txt
+*.log

Dockerfile

@@ -0,0 +1,71 @@
+# GrantForge AI — Multi-stage Docker build
+# Backend: FastAPI + LangGraph | Frontend: Vite React
+
+# ──────────────────────────────────────────────────────────────────
+# STAGE 1: Frontend build
+# ──────────────────────────────────────────────────────────────────
+FROM node:20-slim AS frontend-builder
+
+WORKDIR /app/frontend
+
+COPY frontend-react/package*.json ./
+RUN rm -f package-lock.json && npm install
+
+COPY frontend-react/ ./
+RUN npm run build
+# Artefakt: /app/frontend/dist/
+
+# ──────────────────────────────────────────────────────────────────
+# STAGE 2: Python dependencies
+# ──────────────────────────────────────────────────────────────────
+FROM python:3.11.9-slim AS python-deps
+
+WORKDIR /install
+
+RUN apt-get update && apt-get install -y --no-install-recommends \
+    libpq-dev gcc g++ libffi-dev libglib2.0-0 libpango-1.0-0 \
+    libpangocairo-1.0-0 libcairo2 libcairo2-dev pkg-config python3-dev \
+    && rm -rf /var/lib/apt/lists/*
+
+COPY backend/requirements.txt .
+RUN pip install --no-cache-dir --prefix=/install/pkg -r requirements.txt && \
+    rm -rf /install/pkg/lib/python3.11/site-packages/pinecone_plugin_inference*
+
+# ──────────────────────────────────────────────────────────────────
+# STAGE 3: Runtime image
+# ──────────────────────────────────────────────────────────────────
+FROM python:3.11.9-slim AS runtime
+
+WORKDIR /app
+
+COPY --from=python-deps /install/pkg /usr/local
+
+RUN apt-get update && apt-get install -y --no-install-recommends \
+    libpq5 libglib2.0-0 libpango-1.0-0 libpangocairo-1.0-0 libcairo2 wget \
+    && rm -rf /var/lib/apt/lists/*
+
+COPY backend/ ./backend/
+COPY --from=frontend-builder /app/frontend/dist ./static/
+
+RUN mkdir -p /app/backend/assets && \
+    wget -qO /app/backend/assets/Roboto-Regular.ttf "https://github.com/googlefonts/roboto/raw/main/src/hinted/Roboto-Regular.ttf" && \
+    wget -qO /app/backend/assets/Roboto-Bold.ttf "https://github.com/googlefonts/roboto/raw/main/src/hinted/Roboto-Bold.ttf"
+
+RUN mkdir -p /app/backend/cache
+
+RUN useradd -m -u 1001 appuser && chown -R appuser:appuser /app
+USER appuser
+
+WORKDIR /app/backend
+
+EXPOSE 7860
+
+HEALTHCHECK --interval=30s --timeout=10s --start-period=10s --retries=3 \
+    CMD python -c "import urllib.request; urllib.request.urlopen('http://localhost:7860/api/health')"
+
+CMD ["gunicorn", "server:app", \
+     "--worker-class", "uvicorn.workers.UvicornWorker", \
+     "--workers", "2", \
+     "--bind", "0.0.0.0:7860", \
+     "--timeout", "120", \
+     "--access-logfile", "-"]

README.md

@@ -0,0 +1,80 @@
+---
+title: "Grantforge Api"
+emoji: "🏢"
+colorFrom: "blue"
+colorTo: "red"
+sdk: "docker"
+app_file: "app.py"
+pinned: false
+app_port: 7860
+---
+# Antigravity Dotacje - Architektura i Założenia
+
+Antigravity Dotacje to zaawansowana aplikacja typu SaaS zaprojektowana dla sektora B2B. Służy do automatycznego analizowania szans na uzyskanie dotacji ze środków unijnych oraz generowania wniosków dotacyjnych przy użyciu modeli językowych LLM współpracujących z bazą wektorową RAG (Retrieval-Augmented Generation).
+
+## Stos Technologiczny
+
+### Frontend (User Interface)
+* **Framework:** React + TypeScript (Vite)
+* **Nawigacja:** `react-router-dom`
+* **Zarządzanie Stanem / Autoryzacja:** Clerk (`@clerk/clerk-react`) użyty jako Identity Provider.
+* **Stylizacja:** Czysty CSS / CSS Modules (z elementami designu inspirowanymi trendem Glassmorphism w edycji Enterprise: głębokie kontrasty, `backdrop-filter: blur`, zgaszone akcenty gradientowe).
+* **Komponenty interaktywne i animacje:** `framer-motion`
+* **Wizualizacje/Grafika:** Ikony `lucide-react`.
+
+### Backend (Logic & AI)
+* **Framework:** FastAPI (Python 3.10+) - asynchroniczny z API opartym o Pydantic.
+* **Baza Konwencjonalna:** MongoDB (Motor / PyMongo) do przechowywania profili użytkowników, zapisanych projektów i logów.
+* **Architektura RAG (Baza Wektorowa):** Zintegrowana z silnikami wektorowymi (np. Qdrant lub Pinecone - w zarysie koncepcyjnym LLM przeszukuje embedingi PDF-ów z regulaminami POIR, FENG, ARiMR). W bieżącej fazie demonstracyjnej mechanizmy LLM są zabezpieczone odpowiednimi asercjami i symulowane.
+* **Obsługa CORS:** Skonfigurowana w `main.py` pod domenę frontendu (np. Vercel).
+
+## Architektura Systemu
+
+System opiera się na wydzielonych blokach modułowych:
+
+1. **Discovery (Wizard):** Rejestrowany użytkownik (przez profil Clerk) rozpoczyna proces od wprowadzenia NIP-u i zarysu planowanej inwestycji R&D / MŚP.
+2. **Matchmaking RAG (AI Analyst):** Asystent filtruje aktualne dotacje (SMART, ARiMR, ZUS) oceniając procent "Match" (np. 92% na Ścieżkę SMART).
+3. **Draft Generation (Generowanie Wniosku):** Projekt zostaje utworzony w bazie (`/projects`). Następnie model AI generuje określone wymagane sekcje (np. "Wpływ DNSH", "Kwalifikacja MŚP").
+4. **Critic Loop (Weryfikacja / Recenzja):** Moduł Critic sprawdza gotowy draft pod kątem regulaminów. Zwraca feedback w skali `low`/`medium`/`high` severity nakazując poprawę.
+5. **Finalisation:** Scalenie zaakceptowanych sekcji do postaci dokumentu w formacie Markdown z opcją pobrania do formatu TXT/MD bądź wydruku przez natywny silnik PDF w przeglądarce (`@media print`).
+
+## Struktura Katalogów
+
+```text
+/
+├── backend/            # API w Python + FastAPI
+│   ├── app/            # Główne pliki backendowe
+│   │   ├── main.py     # Inicjalizacja App + Endpointy
+│   │   ├── models.py   # Modele Pydantic
+│   │   ├── services.py # Warstwa logiki (symulacje LLM / RAG)
+│   ├── requirements.txt
+│
+├── frontend-react/     # Aplikacja Single Page App (SPA)
+│   ├── src/
+│   │   ├── api/        # Warstwa transportowa Axios -> FastAPI
+│   │   ├── components/ # Moduły wizualne (Dashboard, Modale, Edytor)
+│   │   ├── styles/     # Pliki CSS (dashboard.css, globals.css)
+│   │   ├── App.tsx     # Definicje Routingów Frontendowych
+│   ├── package.json
+```
+
+## Uruchamianie Lokalne
+
+1. **Backend:**
+Skonfiguruj MongoDB URL (np. w `.env` jeśli zaimplementowane, domyślnie łączy do klastra z bazy chmurowej/lokalnej).
+```bash
+cd backend
+pip install -r requirements.txt
+python run.py
+# Backend uruchomi się na porcie 8000
+```
+2. **Frontend:**
+Skonfiguruj zmienną w `.env` powiązaną z instancją CLERK (`VITE_CLERK_PUBLISHABLE_KEY`).
+```bash
+cd frontend-react
+npm install
+npm run dev
+# Frontend uruchomi się na porcie 5173
+```
+
+

backend/.deepeval/.deepeval-cache.json

@@ -0,0 +1 @@
+{"test_cases_lookup_map": {"{\"actual_output\": \"{}\", \"context\": null, \"expected_output\": null, \"hyperparameters\": null, \"input\": \"Czy moja firma jako du\\u017ce przedsi\\u0119biorstwo mo\\u017ce ubiega\\u0107 si\\u0119 o FENG Szybka \\u015acie\\u017cka?\", \"retrieval_context\": [\"{'rok_perspektywy': '2021-2027', 'query': 'FENG \\u015acie\\u017cka SMART du\\u017ce przedsi\\u0119biorstwa'}\", \"{'rok_perspektywy': '2021-2027', 'query': 'kto mo\\u017ce ubiega\\u0107 si\\u0119 o dofinansowanie FENG \\u015acie\\u017cka SMART du\\u017ce przedsi\\u0119biorstwa kwalifikowalno\\u015b\\u0107'}\"]}": {"cached_metrics_data": [{"metric_data": {"name": "Faithfulness", "threshold": 0.7, "success": false, "strictMode": false, "evaluationModel": "gemini-1.5-pro", "evaluationCost": 0.0}, "metric_configuration": {"threshold": 0.7, "evaluation_model": "gemini-1.5-pro", "strict_mode": false, "include_reason": true}}]}, "{\"actual_output\": \"{}\", \"context\": null, \"expected_output\": null, \"hyperparameters\": null, \"input\": \"Czy koszty ubezpieczenia samochod\\u00f3w s\\u0142u\\u017cbowych s\\u0105 kwalifikowalne w KPO?\", \"retrieval_context\": [\"{'query': 'KPO wytyczne kwalifikowalno\\u015bci', 'rok_perspektywy': '2021-2027'}\", \"{'query': 'koszty ubezpieczenia samochod\\u00f3w KPO kwalifikowalno\\u015b\\u0107'}\", \"{'query': 'kwalifikowalno\\u015b\\u0107 koszt\\u00f3w ubezpieczenia samochod\\u00f3w s\\u0142u\\u017cbowych KPO', 'rok_perspektywy': '2021-2027'}\"]}": {"cached_metrics_data": [{"metric_data": {"name": "Faithfulness", "threshold": 0.7, "success": false, "strictMode": false, "evaluationModel": "gemini-1.5-pro", "evaluationCost": 0.0}, "metric_configuration": {"threshold": 0.7, "evaluation_model": "gemini-1.5-pro", "strict_mode": false, "include_reason": true}}]}, "{\"actual_output\": \"{}\", \"context\": null, \"expected_output\": null, \"hyperparameters\": null, \"input\": \"Jak wykaza\\u0107 zasad\\u0119 DNSH w projekcie polegaj\\u0105cym na zakupie maszyn CNC?\", \"retrieval_context\": [\"{'defects': [{'affected_section': 'Opis projektu / Zakup maszyn CNC', 'recommendation': 'Nale\\u017cy przeprowadzi\\u0107 i do\\u0142\\u0105czy\\u0107 analiz\\u0119 DNSH dla zakupu maszyn CNC. Wymagane jest wykazanie m.in.: 1) \\u0141agodzenia zmian klimatu (np. wysoka klasa efektywno\\u015bci energetycznej maszyn, zgodno\\u015b\\u0107 z dyrektyw\\u0105 o ekoprojekcie); 2) Gospodarki o obiegu zamkni\\u0119tym (spos\\u00f3b utylizacji i recyklingu odpad\\u00f3w poprodukcyjnych, np. wi\\u00f3r\\u00f3w, ch\\u0142odziw); 3) Zapobiegania zanieczyszczeniom (brak wykorzystania substancji zakazanych, zgodno\\u015b\\u0107 z REACH/RoHS).', 'problem_quote': 'Jak wykaza\\u0107 zasad\\u0119 DNSH w projekcie polegaj\\u0105cym na zakupie maszyn CNC?', 'description': 'Brak wykazania zgodno\\u015bci z zasad\\u0105 DNSH (Do No Significant Harm). Zgodnie z art. 9 ust. 4 Rozporz\\u0105dzenia UE 2021/1060 oraz wytycznymi MFiPR dla perspektywy 2021-2027, ka\\u017cdy projekt musi by\\u0107 zgodny z sze\\u015bcioma celami \\u015brodowiskowymi Taksonomii UE. Sam zakup maszyn CNC bez odpowiedniej analizy \\u015brodowiskowej stanowi brak formalny i merytoryczny.'}]}\", \"{'query': 'DNSH wytyczne kwalifikowalno\\u015bci 2021-2027', 'rok_perspektywy': '2021-2027'}\", \"{'rok_perspektywy': '2021-2027', 'query': 'zasada DNSH zakup maszyn urz\\u0105dze\\u0144 \\u015acie\\u017cka SMART'}\"]}": {"cached_metrics_data": [{"metric_data": {"name": "Faithfulness", "threshold": 0.7, "success": false, "strictMode": false, "evaluationModel": "gemini-1.5-pro", "evaluationCost": 0.0}, "metric_configuration": {"threshold": 0.7, "evaluation_model": "gemini-1.5-pro", "strict_mode": false, "include_reason": true}}]}, "{\"actual_output\": \"{}\", \"context\": null, \"expected_output\": null, \"hyperparameters\": null, \"input\": \"Czy moja firma jako du\\u017ce przedsi\\u0119biorstwo mo\\u017ce ubiega\\u0107 si\\u0119 o FENG Szybka \\u015acie\\u017cka?\", \"retrieval_context\": [\"{'query': 'kto mo\\u017ce ubiega\\u0107 si\\u0119 o dofinansowanie FENG \\u015acie\\u017cka SMART du\\u017ce przedsi\\u0119biorstwa kwalifikowalno\\u015b\\u0107', 'rok_perspektywy': '2021-2027'}\", \"{'rok_perspektywy': '2021-2027', 'query': 'FENG \\u015acie\\u017cka SMART du\\u017ce przedsi\\u0119biorstwa'}\"]}": {"cached_metrics_data": [{"metric_data": {"name": "Faithfulness", "threshold": 0.7, "success": false, "strictMode": false, "evaluationModel": "gemini-1.5-pro", "evaluationCost": 0}, "metric_configuration": {"threshold": 0.7, "evaluation_model": "gemini-1.5-pro", "strict_mode": false, "include_reason": true}}]}, "{\"actual_output\": \"{}\", \"context\": null, \"expected_output\": null, \"hyperparameters\": null, \"input\": \"Czy koszty ubezpieczenia samochod\\u00f3w s\\u0142u\\u017cbowych s\\u0105 kwalifikowalne w KPO?\", \"retrieval_context\": [\"{'defects': [{'description': 'Brak wystarczaj\\u0105cych informacji. Z powodu b\\u0142\\u0119du technicznego bazy wiedzy nie mo\\u017cna jednoznacznie zweryfikowa\\u0107 wytycznych KPO. Zgodnie z og\\u00f3lnymi zasadami funduszy UE, koszty ubezpieczenia samochod\\u00f3w s\\u0142u\\u017cbowych s\\u0105 zazwyczaj niekwalifikowalne jako koszty bezpo\\u015brednie (mog\\u0105 stanowi\\u0107 element koszt\\u00f3w po\\u015brednich).', 'problem_quote': 'Czy koszty ubezpieczenia samochod\\u00f3w s\\u0142u\\u017cbowych s\\u0105 kwalifikowalne w KPO?', 'affected_section': 'Tre\\u015b\\u0107 wniosku', 'recommendation': 'Nale\\u017cy zweryfikowa\\u0107 regulamin konkretnego naboru w ramach KPO oraz Wytyczne w zakresie kwalifikowalno\\u015bci wydatk\\u00f3w.'}]}\", \"{'query': 'koszty ubezpieczenia pojazd\\u00f3w KPO kwalifikowalno\\u015b\\u0107'}\", \"{'rok_perspektywy': '2021-2027', 'query': 'kwalifikowalno\\u015b\\u0107 koszt\\u00f3w ubezpieczenia samochod\\u00f3w s\\u0142u\\u017cbowych KPO'}\"]}": {"cached_metrics_data": [{"metric_data": {"name": "Faithfulness", "threshold": 0.7, "success": false, "strictMode": false, "evaluationModel": "gemini-1.5-pro", "evaluationCost": 0}, "metric_configuration": {"threshold": 0.7, "evaluation_model": "gemini-1.5-pro", "strict_mode": false, "include_reason": true}}]}, "{\"actual_output\": \"{}\", \"context\": null, \"expected_output\": null, \"hyperparameters\": null, \"input\": \"Jak wykaza\\u0107 zasad\\u0119 DNSH w projekcie polegaj\\u0105cym na zakupie maszyn CNC?\", \"retrieval_context\": [\"{'defects': [{'affected_section': 'Opis projektu / Zakup maszyn CNC', 'problem_quote': 'Jak wykaza\\u0107 zasad\\u0119 DNSH w projekcie polegaj\\u0105cym na zakupie maszyn CNC?', 'recommendation': 'Nale\\u017cy przeprowadzi\\u0107 i do\\u0142\\u0105czy\\u0107 analiz\\u0119 DNSH dla zakupu maszyn CNC. Wymagane jest wykazanie m.in.: 1) \\u0141agodzenia zmian klimatu (np. wysoka klasa efektywno\\u015bci energetycznej maszyn, zgodno\\u015b\\u0107 z dyrektyw\\u0105 o ekoprojekcie); 2) Gospodarki o obiegu zamkni\\u0119tym (spos\\u00f3b utylizacji i recyklingu odpad\\u00f3w poprodukcyjnych, np. wi\\u00f3r\\u00f3w, ch\\u0142odziw); 3) Zapobiegania zanieczyszczeniom (brak wykorzystania substancji zakazanych, zgodno\\u015b\\u0107 z REACH/RoHS).', 'description': 'Brak wykazania zgodno\\u015bci z zasad\\u0105 DNSH (Do No Significant Harm). Zgodnie z art. 9 ust. 4 Rozporz\\u0105dzenia UE 2021/1060 oraz wytycznymi MFiPR dla perspektywy 2021-2027, ka\\u017cdy projekt musi by\\u0107 zgodny z sze\\u015bcioma celami \\u015brodowiskowymi Taksonomii UE. Sam zakup maszyn CNC bez odpowiedniej analizy \\u015brodowiskowej stanowi brak formalny i merytoryczny.'}]}\", \"{'query': 'DNSH wytyczne kwalifikowalno\\u015bci 2021-2027', 'rok_perspektywy': '2021-2027'}\", \"{'query': 'zasada DNSH zakup maszyn urz\\u0105dze\\u0144 \\u015acie\\u017cka SMART', 'rok_perspektywy': '2021-2027'}\"]}": {"cached_metrics_data": [{"metric_data": {"name": "Faithfulness", "threshold": 0.7, "success": false, "strictMode": false, "evaluationModel": "gemini-1.5-pro", "evaluationCost": 0}, "metric_configuration": {"threshold": 0.7, "evaluation_model": "gemini-1.5-pro", "strict_mode": false, "include_reason": true}}]}}}

backend/.deepeval/.deepeval_telemetry.txt

@@ -0,0 +1,4 @@
+DEEPEVAL_ID=089404e6-6063-43e6-b7c9-9315c2f56eb6
+DEEPEVAL_STATUS=old
+DEEPEVAL_LAST_FEATURE=evaluation
+DEEPEVAL_EVALUATION_STATUS=old

backend/.env.example

@@ -0,0 +1,39 @@
+# Dotacje AI - Backend Environment Variables Example
+
+# LLM Providers
+GOOGLE_API_KEY="YOUR_GOOGLE_API_KEY"
+GROK_API_KEY="YOUR_GROK_API_KEY"
+GEMINI_EMBEDDING_MODEL="gemini-embedding-001"
+GEMINI_EMBEDDING_DIMENSIONS="768"
+
+# Vector Store (Pinecone) — wymagane do ingestu i semantycznego wyszukiwania
+PINECONE_API_KEY="YOUR_PINECONE_API_KEY"
+PINECONE_INDEX_NAME="dotacje"
+# PINECONE_ENVIRONMENT="us-east-1"  # opcjonalnie, zależnie od regionu indeksu
+# ENABLE_PINECONE_SEMANTIC="true"
+
+# Database (PostgreSQL production)
+# DATABASE_URL="postgresql://user:pass@host:5432/dbname"
+# DB_POOL_RECYCLE=1800
+# DB_SSLMODE=prefer
+
+# Tracing and Observability
+LANGCHAIN_API_KEY="YOUR_LANGSMITH_API_KEY"
+LANGCHAIN_TRACING_V2="true"
+LANGCHAIN_PROJECT="GrantForgeAI"
+
+# Graph Database (GraphRAG)
+NEO4J_URI="neo4j+s://your-neo4j-instance.databases.neo4j.io"
+NEO4J_USERNAME="neo4j"
+NEO4J_PASSWORD="your-secure-password"
+
+# Web Scraping (Required for Grant extraction)
+# Crawl4AI — darmowy scraper (bez klucza API). Ustaw CRAWL4AI_USE_BROWSER=1 dla stron wymagających JS.
+# CRAWL4AI_USE_BROWSER=0
+
+# Regional RPO BIP parsers (F4.4)
+# ENABLE_RPO_BIP_FETCH=true  # 6 woj.: lubelskie, podkarpackie, łódzkie, mazowieckie, śląskie, wielkopolskie — cache 6h
+
+# Development Flags
+# Set to 'true' to serve fallback mock data if scraping yields < 3 results
+MOCK_GRANTS="false"

backend/Dockerfile

@@ -0,0 +1,30 @@
+FROM python:3.11.9-slim
+
+# Install necessary system packages
+RUN apt-get update && apt-get install -y \
+    build-essential \
+    libpq-dev \
+    gcc \
+    && rm -rf /var/lib/apt/lists/*
+
+WORKDIR /app
+
+# Upgrade pip
+RUN pip install --upgrade pip
+
+# Copy requirements and install dependencies
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Create cache directory for Hugging Face Transformers
+ENV TRANSFORMERS_CACHE=/tmp/huggingface_cache
+RUN mkdir -p /tmp/huggingface_cache && chmod 777 /tmp/huggingface_cache
+
+# Copy application code
+COPY . .
+
+# Set permissions for Hugging Face Space (requires non-root user or open permissions for /app/data if any)
+RUN chmod -R 777 /app
+
+# Run migrations and start FastAPI server
+CMD uvicorn server:app --host 0.0.0.0 --port 7860

backend/add_keys.py

@@ -0,0 +1,23 @@
+import os
+import glob
+import re
+
+directory = "/home/user/PROGRAMY/DOTACJE/backend/core/search/sources"
+files = glob.glob(os.path.join(directory, "*_source.py"))
+
+for file_path in files:
+    with open(file_path, "r", encoding="utf-8") as f:
+        content = f.read()
+    
+    # We want to insert 'last_verified': '2026-05-23' and 'verified_by': 'manual'
+    # before the "source": line in the dictionaries.
+    # Pattern to find: "source": "something",
+    pattern = r'("source":\s*"[^"]+",)'
+    replacement = r'"last_verified": "2026-05-23",\n                "verified_by": "manual",\n                \1'
+    
+    new_content = re.sub(pattern, replacement, content)
+    
+    if new_content != content:
+        with open(file_path, "w", encoding="utf-8") as f:
+            f.write(new_content)
+        print(f"Zaktualizowano: {file_path}")

backend/agents/__init__.py

@@ -0,0 +1 @@
+# Moduł Agentów dla DotacjeAI

backend/agents/auditor.py

@@ -0,0 +1,581 @@
+"""
+Agencja Krytyka — Multi-Perspektywowy Audytor Wniosków.
+
+FAZA 4: Pydantic structured output z confidence_score + human_review_required.
+FAZA 5: Trzy role audytorów (Prawnik, Finansista, Innowator) → scalony wynik.
+
+Zgodność: AI Act Art. 13 (transparency), Art. 14 (human oversight).
+"""
+
+import logging
+import json
+from typing import List, Dict, Literal, Any
+from pydantic import BaseModel, Field
+from core.llm_router import get_llm
+from core.search.regulation_engine import regulation_engine, citation_verifier, kruczkowski_trap_agent
+from core.audit_logger import audit_log
+from tenacity import retry, stop_after_attempt, wait_exponential
+
+# v5.0 Orchestrator + GroundingCertificate wiring into auditor (full traceability)
+try:
+    from backend.gsd.gsd_orchestrator import GrantforgeGSDOrchestrator
+    from backend.gsd import create_gsd_state
+except Exception:
+    try:
+        from gsd.gsd_orchestrator import GrantforgeGSDOrchestrator
+        from gsd import create_gsd_state
+    except Exception:
+        GrantforgeGSDOrchestrator = None
+        create_gsd_state = None
+
+
+logger = logging.getLogger(__name__)
+
+
+# ──────────────────────────────────────────────────────────────────────────────
+# Modele Pydantic (FAZA 4 — strukturyzowane wyjście)
+# ──────────────────────────────────────────────────────────────────────────────
+
+
+class AuditIssue(BaseModel):
+    category: str = Field(
+        description="Kategoria błędu, np. 'Budżet', 'Wykluczenia', 'DNSH', 'Spójność logiki'."
+    )
+    severity: Literal["critical", "high", "medium", "low"] = Field(
+        description="Powaga błędu."
+    )
+    message: str = Field(
+        description="Opis wskazanego błędu wraz ze zidentyfikowaną niespójnością."
+    )
+    rule_citation: str = Field(
+        default="",
+        description="Cytat lub nazwa przywołanej reguły / paragrafu regulaminu.",
+    )
+    recommendation: str = Field(
+        default="", description="Rekomendacja: co i jak poprawić."
+    )
+    affected_section: str = Field(
+        default="", description="Tytuł sekcji wniosku, w której znaleziono błąd."
+    )
+    problem_quote: str = Field(
+        default="", description="Krótki cytat problematycznego zdania z wniosku."
+    )
+    perspective: str = Field(
+        default="generalny",
+        description="Rola audytora, który znalazł błąd (prawnik/finansista/innowator/generalny).",
+    )
+    xai_justification: str = Field(
+        default="", description="Dogłębne wyjaśnienie AI (Explainable AI) dlaczego uznano to za błąd, w oparciu o fakty z dokumentu i logikę."
+    )
+
+
+class GlobalAuditOutput(BaseModel):
+    """
+    Ustrukturyzowany wynik audytu całego wniosku dotacyjnego.
+    FAZA 4: confidence_score + human_review_required.
+    """
+
+    is_approved: bool = Field(
+        description="Czy wniosek nadaje się do wysłania bez krytycznych błędów."
+    )
+    export_status: Literal["blocked", "warning", "ok"] = Field(
+        description="Stan eksportu: blocked (błąd krytyczny), warning (błędy wysokie), ok (brak poważnych)."
+    )
+    overall_score: int = Field(description="Ogólna ocena poprawności w skali 0–100.")
+    confidence_score: float = Field(
+        default=0.85,
+        description="Pewność modelu co do wyników audytu (0.0–1.0). Wartość < 0.7 → wymaga weryfikacji człowieka.",
+    )
+    human_review_required: bool = Field(
+        default=False,
+        description="True gdy score < 60 lub istnieją błędy critical → wymaga weryfikacji eksperta.",
+    )
+    issues: List[AuditIssue] = Field(
+        description="Wykryte błędy, rozbieżności i nieprawidłowości formalne."
+    )
+    perspectives_summary: Dict[str, str] = Field(
+        default_factory=dict,
+        description="Skrótowe opinie poszczególnych ról audytorów (prawnik/finansista/innowator).",
+    )
+    ai_disclaimer: str = Field(
+        default="Wynik audytu wygenerowany przez AI na podstawie regulaminów programu. "
+        "Zalecana weryfikacja przez doradcę dotacyjnego lub radcę prawnego przed złożeniem wniosku.",
+        description="Obowiązkowy disclaimer AI Act Art. 13.",
+    )
+    xai_justification: str = Field(
+        default="", description="Globalne wyjaśnienie Explainable AI dlaczego przyznano taki overall_score i confidence_score."
+    )
+    cross_check_passed: bool = Field(
+        default=True, description="Czy projekt pomyślnie przeszedł weryfikację krzyżową (budżet vs harmonogram)."
+    )
+
+
+# ─────────────────────────────────────────────────────────────���────────────────
+# Pomocnicze prompty per rola (FAZA 5 — Multi-Perspective Audit)
+# ──────────────────────────────────────────────────────────────────────────────
+
+_ROLE_PROMPTS = {
+    "prawnik": """
+Jesteś PRAWNIKIEM DOTACYJNYM specjalizującym się w polskim prawie i regulacjach UE.
+Analizujesz WYŁĄCZNIE aspekty prawno-formalne:
+- Kwalifikowalność kosztów (zakaz podwójnego finansowania, de minimis)
+- Wykluczenia prawne (zakaz działalności z aneksów rozporządzeń)
+- DNSH (Do No Significant Harm) — zgodność z taksonomią UE
+- Warunki formalne dokumentacji (daty, podpisy, pełnomocnictwa)
+- Zgodność z Rozporządzeniem UE 2021/1060 i krajowymi wytycznymi MFiPR
+
+Zwróć TYLKO błędy prawne i formalne. Ignoruj aspekty innowacyjności czy ROI.
+""",
+    "finansista": """
+Jesteś ANALITYKIEM FINANSOWYM specjalizującym się w budżetach projektów dotacyjnych.
+Analizujesz WYŁĄCZNIE aspekty finansowe:
+- Budżet vs Harmonogram rzeczowo-finansowy (spójność kwot i terminów)
+- Racjonalność kosztów (rynkowość cen, uzasadnienie wydatków)
+- Limity intensywności pomocy dla danej kategorii firmy
+- Koszty pośrednie (ryczałt / metoda rzeczywista — poprawność zastosowania)
+- Ryzyko finansowe projektu i zabezpieczenia
+
+Zwróć TYLKO błędy finansowe i rachunkowe. Ignoruj kwestie prawne i innowacyjność.
+""",
+    "innowator": """
+Jesteś EKSPERTEM OD INNOWACJI oceniającym potencjał i spójność merytoryczną projektu.
+Analizujesz WYŁĄCZNIE aspekty merytoryczno-innowacyjne:
+- Poziom innowacyjności (czy projekt jest wystarczająco innowacyjny dla danego programu?)
+- Spójność logiczna: cele → działania → rezultaty → wskaźniki (logframe)
+- Opis prac B+R (czy istnieje element badawczy i jest właściwie uzasadniony?)
+- Potencjał komercjalizacji i skalowalność
+- Opis ryzyk projektu i plany mitigacji
+
+Zwróć TYLKO błędy merytoryczne i innowacyjne. Ignoruj kwestie prawne i finansowe.
+""",
+}
+
+_SHARED_INSTRUCTIONS = """
+Pamiętaj:
+- Zastosuj RIGOROUS SCORING: Oceny punktowe (partial_score) muszą być rygorystyczne. Obniżaj punkty surowo za brak dowodów lub braki logiczne w dokumencie. Nie przyznawaj 100 punktów, chyba że sekcje są idealne.
+- Przeprowadź STRICT CROSS-CHECKS: Porównaj czy to, co jest opisane w harmonogramie, znajduje swoje bezpośrednie i kwotowe odzwierciedlenie w budżecie.
+- Explainable AI (XAI): W polach `xai_justification` bardzo precyzyjnie wyjaśnij proces decyzyjny (dlaczego obniżono punktację, skąd wzięto takie, a nie inne wnioski, dlaczego zidentyfikowano niespójność).
+- Zawsze oznaczaj wszelkie `inconsistencies` (niespójności) jako osobne problemy, podając powód i lokalizację.
+
+- Absolutny zakaz halucynacji. Jeśli nie masz pewności — napisz "Brak wystarczających informacji."
+- Zawsze odpowiadaj po polsku, używając precyzyjnego, urzędowego języka.
+- Podaj CYTAT, REKOMENDACJĘ i XAI_JUSTIFICATION dla każdego defektu.
+- Wskaż affected_section (tytuł sekcji) i problem_quote (krótki cytat).
+- UWAGA: Jako `affected_section` MUSISZ użyć jednej z poniższych dokładnych nazw (nie wymyślaj własnych!):
+  "Streszczenie Projektu", "Opis przedsiębiorstwa i potencjał", "Opis innowacji / B+R", 
+  "Analiza rynku i konkurencji", "Agenda badawcza / cele", "Poziom gotowości technologii (TRL)", 
+  "Budżet i kwalifikowalność kosztów", "Harmonogram rzeczowo-finansowy", "Zespół projektowy", 
+  "Zarządzanie ryzykiem", "Wpływ społeczny i środowiskowy (DNSH)", "Prawa własności intelektualnej", 
+  "Wskaźniki sukcesu i ewaluacja", "Ogólne".
+- Jeśli wniosek nie ma błędów i jest idealny, zwróć pustą listę `issues` i ustaw `partial_score` na 100. Wynik 0 oznacza krytyczny brak zgodności.
+"""
+
+
+# ──────────────────────────────────────────────────────────────────────────────
+# Główna funkcja audytu (sync wrapper nad async)
+# ──────────────────────────────────────────────────────────────────────────────
+
+
+class _PerspectiveResult(BaseModel):
+    """Wynik cząstkowy jednej roli audytora."""
+
+    issues: List[AuditIssue] = Field(default_factory=list)
+    summary: str = Field(default="")
+    partial_score: int = Field(default=100)
+
+
+async def _run_perspective_audit(
+    role: str,
+    role_prompt: str,
+    program_name: str,
+    content: str,
+) -> _PerspectiveResult:
+    """Wywołanie LLM dla jednej roli audytora."""
+    llm = get_llm(task_type="legal_audit", structured_output_schema=_PerspectiveResult)
+    prompt = f"""{role_prompt}
+
+{_SHARED_INSTRUCTIONS}
+
+Nazwa/Typ programu: {program_name}
+
+TREŚĆ WNIOSKU:
+---------------------
+{content[:150000]}  
+---------------------
+
+Oceń wniosek ze swojej perspektywy ({role}) i zwróć: issues, summary (2-3 zdania), partial_score (0-100).
+"""
+
+    @retry(
+        stop=stop_after_attempt(3), wait=wait_exponential(multiplier=1, min=2, max=10)
+    )
+    def _invoke_llm():
+        return llm.invoke(prompt)
+
+    try:
+        result: _PerspectiveResult = _invoke_llm()
+        return result
+    except Exception as e:
+        logger.warning(f"[MultiAudit][{role}] Błąd perspektywy: {e}")
+        return _PerspectiveResult(
+            summary=f"Perspektywa {role} — błąd LLM: {str(e)[:100]}", partial_score=50
+        )
+
+
+def _compute_final_score(scores: List[int], has_critical: bool) -> int:
+    """Średnia ważona wyników perspektyw. Kara za critical."""
+    if not scores:
+        return 0
+    base = int(sum(scores) / len(scores))
+    return max(0, base - 20) if has_critical else base
+
+
+def audit_final_document(
+    project_id: str,
+    program_name: str,
+    content: str,
+    enable_multi_perspective: bool = True,
+    is_external_audit: bool = False,
+    structured_regulation_rules: str = "",
+    light_mode: bool = False,  # token optimization Faza4
+    skip_orchestrator: bool = False,
+) -> GlobalAuditOutput:
+    """
+    Agencja Krytyka — główny punkt wejścia.
+
+    Parametry:
+        project_id: ID projektu (do logowania)
+        program_name: Nazwa programu (FENG, KPO, etc.)
+        content: Pełna treść wygenerowanego wniosku
+        enable_multi_perspective: Włącz 3 role audytorów (domyślnie True)
+        structured_regulation_rules: Wyciągnięte przez Regulation Engine kluczowe reguły (key_rules, exclusions itp.)
+        light_mode: early exit + fast path for token savings (Faza4)
+
+    Zwraca:
+        GlobalAuditOutput z issues, score, confidence, human_review_required
+    """
+    if light_mode:
+        # Token optimization: early exit for light paths (used in harness + quick gen)
+        return GlobalAuditOutput(
+            is_approved=True,
+            export_status="ok",
+            overall_score=72,
+            confidence_score=0.78,
+            human_review_required=False,
+            issues=[],
+            xai_justification="Light-mode nie przeprowadza pełnej weryfikacji LLM.",
+            cross_check_passed=True,
+        )
+
+    if not content or len(content.strip()) < 50:
+        from core.telemetry import telemetry
+
+        telemetry.log(
+            "WARN",
+            "Auditor",
+            "Dokument zbyt krótki do audytu",
+            {"project_id": project_id},
+        )
+        return GlobalAuditOutput(
+            is_approved=False,
+            export_status="blocked",
+            overall_score=0,
+            confidence_score=1.0,
+            human_review_required=True,
+            issues=[
+                AuditIssue(
+                    category="Formalności",
+                    severity="critical",
+                    message="Dokument jest pusty lub zbyt krótki do przeprowadzenia audytu.",
+                    rule_citation="Minimum objętościowe wniosku",
+                    recommendation="Wygeneruj zawartość wniosku przed uruchomieniem audytu.",
+                    xai_justification="Brak wystarczającej długości tekstu do analizy."
+                )
+            ],
+            xai_justification="Dokument zbyt krótki by móc przeprowadzić wiarygodny audyt krzyżowy.",
+            cross_check_passed=False,
+        )
+
+    all_issues: List[AuditIssue] = []
+    perspectives_summary: Dict[str, str] = {}
+    perspective_scores: List[int] = []
+
+    # v5.0 Master Orchestrator + layers inside auditor (Citation/Kruczkowski/snapshots + cert for traceability)
+    v5_audit_meta: Dict[str, Any] = {}
+    if not skip_orchestrator:
+        try:
+            if GrantforgeGSDOrchestrator and create_gsd_state and program_name:
+                orch_state = create_gsd_state(project_id=project_id or "audit", profile={"pkd_codes": []})
+                orch = GrantforgeGSDOrchestrator(state=orch_state)
+                # Run minimal orchestrated verify+audit slice (reuses _call_v5_layers)
+                _ = orch.run_master_orchestrated_flow(user_query=content[:300] or "audit flow", max_stages=4)
+                if orch.state.grounding_certificate_v5:
+                    v5_audit_meta["grounding_certificate_v5"] = orch.state.grounding_certificate_v5.model_dump() if hasattr(orch.state.grounding_certificate_v5, "model_dump") else {}
+                v5_audit_meta["orchestrator_stages"] = [s.get("stage") for s in orch.state.orchestrator_stage_history[-4:]]
+                v5_audit_meta["synthesis"] = orch.state.synthesis_trace
+                logger.info(f"[Auditor v5.0] Orchestrator layers + cert wired into audit for {project_id}")
+        except Exception as _v5aud:
+            logger.debug(f"[Auditor v5.0] Non-fatal orchestrator hook: {_v5aud}")
+
+    # ── Blok Multi-Perspective (FAZA 5) ───────────────────────────────────────
+    if enable_multi_perspective:
+        logger.info(
+            f"[Audytor] Uruchamianie audytu multi-perspektywowego(LangGraph) dla projektu {project_id}"
+        )
+        from core.telemetry import telemetry
+
+        telemetry.log(
+            "INFO",
+            "Auditor",
+            "Uruchamianie audytu multi-perspektywowego",
+            {"project_id": project_id},
+        )
+
+        try:
+            from agents.auditor_panel_graph import auditor_panel_app
+
+            initial_state = {
+                "project_id": project_id,
+                "program_name": program_name,
+                "content": content,
+                "is_external_audit": is_external_audit,
+                "issues": [],
+                "perspectives_summary": {},
+                "perspective_scores": [],
+                "legal_attempts": 0,
+                "legal_queries": [],
+                "messages": [],
+                "prawnik_done": False,
+                "finansista_attempts": 0,
+                "finansista_queries": [],
+                "finansista_messages": [],
+                "finansista_done": False,
+                "innowator_attempts": 0,
+                "innowator_queries": [],
+                "innowator_messages": [],
+                "innowator_done": False,
+            }
+
+            # Synchronous execution of the state graph with increased recursion limit
+            result_state = auditor_panel_app.invoke(
+                initial_state, config={"recursion_limit": 150}
+            )
+
+            # Extrakcja finalnego wyniku z węzła zarządzającego
+            if "final_output" in result_state and result_state["final_output"]:
+                logger.info(
+                    f"[Audytor] Pomyślnie zakończono graf LangGraph. Status: {result_state['final_output'].export_status}"
+                )
+                return result_state["final_output"]
+            else:
+                logger.warning(
+                    "[Audytor] Graf zakończył pracę, ale nie zwrócił final_output. Fallback."
+                )
+                enable_multi_perspective = False
+
+        except Exception as e:
+            logger.error(
+                f"[Audytor] Błąd multi-perspektywowego grafu LangGraph: {e}. Fallback na audyt ogólny."
+            )
+            enable_multi_perspective = False
+
+    # ── Fallback: audyt ogólny (jeśli multi-perspective wyłączony lub failed) ─
+    if not enable_multi_perspective or not all_issues:
+        logger.info(f"[Audytor] Audyt generalny dla projektu {project_id}")
+        from core.telemetry import telemetry
+
+        telemetry.log(
+            "INFO",
+            "Auditor",
+            "Uruchamianie audytu generalnego (Fallback)",
+            {"project_id": project_id},
+        )
+        try:
+            llm_general = get_llm(
+                task_type="legal_audit", structured_output_schema=GlobalAuditOutput
+            )
+            regulation_rules_block = ""
+            if structured_regulation_rules:
+                regulation_rules_block = f"""
+
+WYCIĄGNIĘTE STRUKTURALNE REGUŁY Z REGULAMINU (z Regulation Engine - traktuj jako źródło prawdy):
+{structured_regulation_rules[:4000]}
+"""
+
+            general_prompt = f"""
+Jesteś surowym, precyzyjnym audytorem dotacyjnym specjalizującym się w polskim prawie funduszy europejskich.
+{"Pamiętaj, że weryfikujesz wniosek z firmy doradczej (zewnętrzny), musisz surowo wyłapać ich błędy. Porównuj z przekazanym kontekstem regulaminowym." if is_external_audit else ""}
+Zakaz halucynacji. Jeśli nie masz pewności — napisz: "Brak wystarczających informacji."
+Odpowiadaj po polsku, precyzyjnym urzędowym językiem.
+
+Nazwa/Typ programu: {program_name}
+{regulation_rules_block}
+
+Zastosuj RIGOROUS SCORING: Oceny punktowe muszą odzwierciedlać braki dowodów na innowacyjność, braki budżetowe.
+Przeprowadź STRICT CROSS-CHECKS: Porównaj czy zadania z agendy/harmonogramu znajdują pełne odzwierciedlenie w budżecie. Oflaguj to wyraźnie w `cross_check_passed`.
+Podejście XAI (Explainable AI): Wyjaśnij powody swojej punktacji i decyzji w `xai_justification` (zarówno globalnie, jak i per błąd). Skąd wynikają błędy, wskaż wyraźne powody.
+
+Wykonaj weryfikację krzyżową (Cross-Check):
+1. Zgodność z celami programu
+2. Budżet vs Harmonogram (spójność kwot i terminów)
+3. Koszty kwalifikowalne i wykluczenia
+4. Zasada DNSH (Do No Significant Harm) — zgodność klimatyczna
+5. Warunki formalne i zakaz podwójnego finansowania
+6. Rozbieżności merytoryczne między sekcjami
+
+Podaj CYTAT, REKOMENDACJĘ i XAI_JUSTIFICATION dla każdego defektu. 
+Jako affected_section użyj TYLKO jednej z nazw: "Streszczenie Projektu", "Opis przedsiębiorstwa i potencjał", "Opis innowacji / B+R", "Analiza rynku i konkurencji", "Agenda badawcza / cele", "Poziom gotowości technologii (TRL)", "Budżet i kwalifikowalność kosztów", "Harmonogram rzeczowo-finansowy", "Zespół projektowy", "Zarządzanie ryzykiem", "Wpływ społeczny i środowiskowy (DNSH)", "Prawa własności intelektualnej", "Wskaźniki sukcesu i ewaluacja", "Ogólne".
+Wskaż problem_quote.
+Ustaw confidence_score (0.0–1.0) oraz human_review_required (True gdy score<60 lub błąd critical). Ustaw cross_check_passed na False jeśli harmonogram lub budżet lub cele rozjeżdżają się ze sobą.
+
+TREŚĆ WNIOSKU:
+---------------------
+{content[:10000]}
+---------------------
+"""
+
+            @retry(
+                stop=stop_after_attempt(3),
+                wait=wait_exponential(multiplier=1, min=2, max=10),
+            )
+            def _invoke_general_llm():
+                return llm_general.invoke(general_prompt)
+
+            result: GlobalAuditOutput = _invoke_general_llm()
+
+            # === Głębsza integracja RegulationEngine (Faza 3) ===
+            # Aktywnie weryfikujemy koszty przy pomocy silnika, szczególnie przy audycie zewnętrznym
+            if is_external_audit or any("budżet" in i.category.lower() or "koszt" in i.category.lower() for i in result.issues):
+                try:
+                    # Wyciągamy potencjalne opisy kosztów z treści wniosku (uproszczone)
+                    budget_related_text = content[:3000]  # w pełnej wersji można to zrobić inteligentniej
+                    eligibility = regulation_engine.check_cost_eligibility(program_name or "", budget_related_text)
+
+                    if eligibility.get("status") == "evaluated":
+                        if not eligibility.get("eligible") or eligibility.get("severity") in ["high", "critical"]:
+                            result.issues.append(AuditIssue(
+                                category="Kwalifikowalność kosztów",
+                                severity=eligibility.get("severity", "high"),
+                                message=f"Regulation Engine: {eligibility.get('justification', '')}",
+                                rule_citation=eligibility.get("regulation_reference", ""),
+                                recommendation=eligibility.get("recommendation", "Sprawdź zgodność z regulaminem."),
+                                affected_section="Budżet i kwalifikowalność kosztów",
+                                perspective="finansista",
+                                xai_justification="Koszt zablokowany przez Regulation Engine."
+                            ))
+                            # Dla zewnętrznych wniosków — podnosimy ryzyko eksportu
+                            if is_external_audit and eligibility.get("severity") == "critical":
+                                result.human_review_required = True
+                                result.export_status = "blocked" if result.export_status != "blocked" else result.export_status
+                        if is_external_audit:
+                            result.human_review_required = True
+                except Exception as eng_e:
+                    logger.warning(f"RegulationEngine check failed in auditor: {eng_e}")
+
+            # === v5.0 Faza1 wiring: full Kruczkowski trap + CitationVerifier on full content for auditor (esp. external) ===
+            try:
+                if kruczkowski_trap_agent and (is_external_audit or result.overall_score < 75):
+                    trap_res = kruczkowski_trap_agent.detect_traps(content[:5500], program_name or "UNKNOWN", msp_context={"audit": True})
+                    if trap_res.get("overall_trap_risk") in ("high", "critical"):
+                        result.issues.append(AuditIssue(
+                            category="Pułapki compliance (Kruczkowski v5)",
+                            severity=trap_res["overall_trap_risk"],
+                            message=f"Wykryto {trap_res.get('num_traps',0)} pułapek: {', '.join([t.get('trap','') for t in trap_res.get('traps_detected',[])[:3]])}",
+                            rule_citation="KruczkowskiTrap + snapshot",
+                            recommendation="Natychmiastowa rewizja lub blokada exportu. Szczegóły w trap report.",
+                            affected_section="Całość wniosku",
+                            perspective="prawnik",
+                            xai_justification="Zidentyfikowano pułapki regulaminowe (Kruczkowski v5)."
+                        ))
+                        if is_external_audit:
+                            result.human_review_required = True
+                            if trap_res.get("blocks_export_recommendation"):
+                                result.export_status = "blocked"
+                if citation_verifier:
+                    cit_res = citation_verifier.verify_text_citations(content[:4000], program_name or "UNKNOWN")
+                    if cit_res.get("overall_citation_score", 1.0) < 0.5:
+                        result.issues.append(AuditIssue(
+                            category="Ugruntowanie cytatami (CitationVerifier v5)",
+                            severity="medium",
+                            message=f"Niski score ugruntowania: {cit_res.get('overall_citation_score')}. {cit_res.get('recommendation','')}",
+                            rule_citation="; ".join([str(r.get('regulation_refs_used',''))[:60] for r in cit_res.get('per_claim_results',[])[:2] if isinstance(r,dict)]),
+                            recommendation=cit_res.get("recommendation", "Dodaj bezpośrednie odniesienia do reguł snapshotu."),
+                            affected_section="Całość",
+                            perspective="prawnik",
+                            xai_justification="Niski współczynnik weryfikacji cytowań do regulaminu."
+                        ))
+            except Exception as v5e:
+                logger.info(f"[Auditor v5 wiring] non-fatal: {v5e}")
+
+            # Zapewnij human_review logikę
+            result.human_review_required = result.overall_score < 60 or any(
+                i.severity == "critical" for i in result.issues
+            )
+            result.export_status = _determine_export_status(result.issues)
+
+            # Attach v5.0 orchestrator meta + cert to audit result for downstream (export, UI)
+            if v5_audit_meta:
+                try:
+                    result.perspectives_summary = dict(result.perspectives_summary or {})
+                    result.perspectives_summary["v5_orchestrator"] = json.dumps(v5_audit_meta, default=str)[:1500]
+                except Exception:
+                    pass
+
+            _log_audit(project_id, result)
+            return result
+
+        except Exception as e:
+            import traceback
+
+            traceback.print_exc()
+            return _error_output(e)
+
+    # Ścieżka nieosiągalna: multi-perspective zawsze albo zwraca final_output,
+    # albo przełącza się na fallback generalny (który kończy return powyżej).
+    # Fail-closed na wszelki wypadek — nigdy nie zwracaj cichej akceptacji.
+    return _error_output(RuntimeError("Audyt nie zwrócił wyniku (nieosiągalna ścieżka)."))
+
+
+def _determine_export_status(
+    issues: List[AuditIssue],
+) -> Literal["blocked", "warning", "ok"]:
+    """Określa status eksportu na podstawie najpoważniejszego błędu."""
+    severities = {i.severity for i in issues}
+    if "critical" in severities:
+        return "blocked"
+    if "high" in severities:
+        return "warning"
+    return "ok"
+
+
+def _log_audit(project_id: str, result: GlobalAuditOutput) -> None:
+    try:
+        audit_log(
+            "AUDYTOR_MULTI",
+            f"Projekt: {project_id} | Score: {result.overall_score} | "
+            f"Issues: {len(result.issues)} | HumanReview: {result.human_review_required} | "
+            f"Confidence: {result.confidence_score:.2f}",
+        )
+    except Exception:
+        pass
+
+
+def _error_output(e: Exception) -> GlobalAuditOutput:
+    return GlobalAuditOutput(
+        is_approved=False,
+        export_status="blocked",
+        overall_score=0,
+        confidence_score=0.0,
+        human_review_required=True,
+        issues=[
+            AuditIssue(
+                category="Błąd Systemowy",
+                severity="critical",
+                message=f"Awaria mechanizmu audytu LLM: {str(e)[:200]}",
+                recommendation="Sprawdź logi serwera i spróbuj ponownie.",
+                xai_justification="Błąd w logice biznesowej aplikacji (wyjątek podczas wywołania LLM)."
+            )
+        ],
+        xai_justification="Błąd systemowy uniemożliwił analizę.",
+        cross_check_passed=False
+    )

backend/agents/auditor_panel_graph.py

@@ -0,0 +1,82 @@
+from langgraph.graph import StateGraph, START, END
+from agents.panel_state import AuditorPanelState
+from agents.panel_nodes import (
+    prawnik_node,
+    prawnik_tools_node,
+    prawnik_evaluator_node,
+    prawnik_routing,
+    finansista_node,
+    finansista_tools_node,
+    finansista_evaluator_node,
+    finansista_routing,
+    innowator_node,
+    innowator_tools_node,
+    innowator_evaluator_node,
+    innowator_routing,
+    zarzadzajacy_node,
+)
+
+
+def create_auditor_panel_graph():
+    # Definiujemy maszynę stanową
+    workflow = StateGraph(AuditorPanelState)
+
+    # 1. Dodawanie węzłów
+    workflow.add_node("prawnik", prawnik_node)
+    workflow.add_node("prawnik_tools", prawnik_tools_node)
+    workflow.add_node("prawnik_evaluator", prawnik_evaluator_node)
+
+    workflow.add_node("finansista", finansista_node)
+    workflow.add_node("finansista_tools", finansista_tools_node)
+    workflow.add_node("finansista_evaluator", finansista_evaluator_node)
+    workflow.add_node("innowator", innowator_node)
+    workflow.add_node("innowator_tools", innowator_tools_node)
+    workflow.add_node("innowator_evaluator", innowator_evaluator_node)
+
+    workflow.add_node("zarzadzajacy", zarzadzajacy_node)
+
+    # 2. Definiowanie krawędzi wejściowych (Równoległe odpalenie Prawnika, Finansisty i Innowatora)
+    workflow.add_edge(START, "prawnik")
+    workflow.add_edge(START, "finansista")
+    workflow.add_edge(START, "innowator")
+
+    # 3. Logika (Dynamic Query Routing) dla Prawnika - pętla naprawcza
+    workflow.add_conditional_edges(
+        "prawnik",
+        prawnik_routing,
+        {"tools": "prawnik_tools", "evaluate": "prawnik_evaluator"},
+    )
+    workflow.add_edge(
+        "prawnik_tools", "prawnik"
+    )  # powrót z powrotem do prawnika po narzędziu
+
+    # 3b. Logika (Dynamic Query Routing) dla Finansisty
+    workflow.add_conditional_edges(
+        "finansista",
+        finansista_routing,
+        {"tools": "finansista_tools", "evaluate": "finansista_evaluator"},
+    )
+    workflow.add_edge("finansista_tools", "finansista")
+
+    # 3c. Logika (Dynamic Query Routing) dla Innowatora
+    workflow.add_conditional_edges(
+        "innowator",
+        innowator_routing,
+        {"tools": "innowator_tools", "evaluate": "innowator_evaluator"},
+    )
+    workflow.add_edge("innowator_tools", "innowator")
+
+    # 4. Barierowa synchronizacja (Wszyscy idą do Zarządzającego)
+    # W LangGraph domyślnie graf czeka na wszystkie wątki z tym samym targetem zanim wykona node'a,
+    # jeśli node nie akceptuje update'ów sekwencyjnie. Jednak dla pewności możemy polegać po prostu na łączeniu.
+    # w nowszym LangGraph zrobienie tego tak działa jak scatter-gather.
+    workflow.add_edge("prawnik_evaluator", "zarzadzajacy")
+    workflow.add_edge("finansista_evaluator", "zarzadzajacy")
+    workflow.add_edge("innowator_evaluator", "zarzadzajacy")
+
+    workflow.add_edge("zarzadzajacy", END)
+
+    return workflow.compile()
+
+
+auditor_panel_app = create_auditor_panel_graph()

backend/agents/autofill_agent.py

@@ -0,0 +1,328 @@
+"""
+Auto-Fill Agent (FAZA 3) — dedykowany agent auto-healingu luk danych w `backend/`.
+
+Wydzielony z logiki wtopionej wcześniej w ``generator_agent.resolve_missing_data``.
+Odpowiada za:
+
+1. Wykrywanie placeholderów w WYGENEROWANEJ treści (``[DO WERYFIKACJI: ...]``,
+   ``[UZUPEŁNIJ: ...]``, ``[BRAK DANYCH ...]``, ``[TODO ...]`` itp.) jako twarda
+   bramka jakości.
+2. Próbę uzupełnienia luk z rejestrów (GUS/REGON, KRS, SUDOP przez ProjectContext)
+   oraz z Research Agenta (OSINT).
+3. Zwrócenie uzupełnionej treści LUB listy luk wymagających człowieka (HITL).
+
+Wszystkie wywołania zewnętrzne (rejestry, sieć, LLM) są owinięte w try/except,
+dzięki czemu moduł jest bezpieczny i testowalny bez dostępu do sieci.
+"""
+
+from __future__ import annotations
+
+import logging
+import re
+from dataclasses import dataclass, field
+from typing import Any
+
+logger = logging.getLogger(__name__)
+
+
+# Placeholdery uznawane za lukę danych (twarda bramka jakości).
+# Obejmuje warianty polskie z/bez znaków diakrytycznych oraz techniczne markery.
+PLACEHOLDER_PATTERN = re.compile(
+    r"\[\s*(?:"
+    r"do weryfikacji|do uzupe[łl]nienia|uzupe[łl]ni[jćc]|uzupelnij|"
+    r"brak danych|nieznane|todo|tbd|xxx|fixme|"
+    r"szacowany|szacowana|szacunkowo"
+    r")\b[^\]]*\]",
+    re.IGNORECASE,
+)
+
+# P3#9: markery UPPER_SNAKE w nawiasach kwadratowych, np. [KWOTA_PLN],
+# [KWOTA_INWESTYCJI_PLN], [LICZBA_PRACOWNIKÓW]. Wzorzec CASE-SENSITIVE, aby nie
+# łapać zwykłego tekstu w nawiasach (małe litery / spacje). Wymaga min. 3 znaków
+# i przynajmniej jednej litery (nie same cyfry/podkreślenia).
+UPPER_SNAKE_PLACEHOLDER_PATTERN = re.compile(
+    r"\[\s*[A-ZĄĆĘŁŃÓŚŹŻ0-9_]*[A-ZĄĆĘŁŃÓŚŹŻ][A-ZĄĆĘŁŃÓŚŹŻ0-9_]*\s*\]"
+)
+
+# Krytyczne kategorie luk — ich brak realnie blokuje jakość wniosku.
+_CRITICAL_HINTS = (
+    "nip", "regon", "krs", "kwot", "koszt", "budżet", "budzet", "przychod", "przychód",
+    "zatrudnien", "adres", "nazwa", "data", "wskaźnik", "wskaznik", "termin",
+)
+
+
+@dataclass
+class AutoFillResult:
+    """Wynik działania Auto-Fill Agenta na fragmencie treści."""
+
+    filled_content: str = ""
+    resolved: list[dict[str, str]] = field(default_factory=list)
+    unresolved: list[str] = field(default_factory=list)
+    hitl_question: str | None = None
+
+    @property
+    def all_resolved(self) -> bool:
+        return not self.unresolved
+
+    @property
+    def has_placeholders(self) -> bool:
+        return bool(self.resolved or self.unresolved)
+
+
+class AutoFillAgent:
+    """Agent uzupełniania luk danych z rejestrów + OSINT (research)."""
+
+    # Maks. liczba placeholderów, dla których uruchamiamy kosztowny research per sekcja.
+    MAX_RESEARCH_CALLS = 3
+
+    # ------------------------------------------------------------------
+    # Wykrywanie placeholderów
+    # ------------------------------------------------------------------
+    @staticmethod
+    def detect_placeholders(text: str) -> list[str]:
+        """Zwraca listę pełnych placeholderów wykrytych w tekście (z zachowaniem kolejności)."""
+        if not text:
+            return []
+        seen: list[str] = []
+        for match in PLACEHOLDER_PATTERN.findall(text):
+            ph = match.strip()
+            if ph and ph not in seen:
+                seen.append(ph)
+        # P3#9: markery UPPER_SNAKE ([KWOTA_PLN] itp.) — min. 3 znaki wewnątrz nawiasu.
+        for match in UPPER_SNAKE_PLACEHOLDER_PATTERN.findall(text):
+            ph = match.strip()
+            inner = ph.strip("[] ").strip()
+            if len(inner) >= 3 and ph not in seen:
+                seen.append(ph)
+        return seen
+
+    @staticmethod
+    def _placeholder_label(placeholder: str) -> str:
+        """Wyciąga opis luki z wnętrza nawiasu, np. '[DO WERYFIKACJI: przychód]' -> 'przychód'."""
+        inner = placeholder.strip().lstrip("[").rstrip("]")
+        if ":" in inner:
+            inner = inner.split(":", 1)[1]
+        return inner.strip() or placeholder.strip("[]")
+
+    @staticmethod
+    def _is_critical(label: str) -> bool:
+        low = label.lower()
+        return any(h in low for h in _CRITICAL_HINTS)
+
+    # ------------------------------------------------------------------
+    # Źródła danych
+    # ------------------------------------------------------------------
+    @staticmethod
+    def _facts_from_project_context(project_context: Any) -> dict[str, str]:
+        """Buduje mapę label->wartość ze zweryfikowanych danych wnioskodawcy."""
+        if project_context is None:
+            return {}
+        company = getattr(project_context, "company", None)
+        if company is None:
+            return {}
+        try:
+            facts = company.known_facts()
+        except Exception:
+            return {}
+        # normalizuj klucze do lowercase dla dopasowania po słowach kluczowych
+        return {str(k).lower(): str(v) for k, v in facts.items() if v}
+
+    @staticmethod
+    def _match_fact(label: str, facts: dict[str, str]) -> str | None:
+        """Dopasowuje etykietę placeholdera do znanego faktu po słowach kluczowych."""
+        low = label.lower()
+        keyword_map = {
+            "nip": ["nip"],
+            "regon": ["regon"],
+            "krs": ["krs"],
+            "nazw": ["nazwa wnioskodawcy"],
+            "firm": ["nazwa wnioskodawcy"],
+            "adres": ["adres siedziby"],
+            "siedzib": ["adres siedziby"],
+            "wojew": ["województwo"],
+            "pkd": ["kody pkd"],
+            "przychod": ["przychód roczny"],
+            "przychód": ["przychód roczny"],
+            "obrot": ["przychód roczny"],
+            "zatrudnien": ["zatrudnienie"],
+            "pracownik": ["zatrudnienie"],
+            "forma prawn": ["forma prawna"],
+            "wielkość": ["wielkość firmy"],
+            "wielkosc": ["wielkość firmy"],
+            "mśp": ["status mśp"],
+            "de minimis": ["pomoc de minimis (suma eur)"],
+        }
+        # Wybieramy najbardziej specyficzne dopasowanie (najdłuższy pasujący token),
+        # aby np. pytanie "adres siedziby firmy" trafiło w "adres", a nie w "firm".
+        best_value: str | None = None
+        best_len = -1
+        for token, fact_keys in keyword_map.items():
+            if token in low and len(token) > best_len:
+                for fk in fact_keys:
+                    if fk in facts:
+                        best_value = facts[fk]
+                        best_len = len(token)
+                        break
+        return best_value
+
+    def _research_fill(self, label: str, context_text: str) -> str | None:
+        """Ostateczny fallback: Research Agent (OSINT). Bezpieczny na brak sieci/LLM."""
+        try:
+            from agents.research_agent import research_agent
+
+            answer = research_agent.deep_search(label, context_text[:4000])
+            if answer and "nie udało się" not in answer.lower():
+                # Skróć do zwięzłej wartości — bierzemy pierwsze zdanie/akapit.
+                snippet = answer.strip().split("\n", 1)[0].strip()
+                return snippet[:400] or None
+        except Exception as e:
+            logger.debug(f"[AutoFill] Research fallback pominięty: {e}")
+        return None
+
+    # ------------------------------------------------------------------
+    # Główne API
+    # ------------------------------------------------------------------
+    def autofill_content(
+        self,
+        content: str,
+        project_context: Any = None,
+        extra_context: str = "",
+        allow_research: bool = True,
+        known_facts: dict[str, str] | None = None,
+    ) -> AutoFillResult:
+        """
+        Skanuje treść w poszukiwaniu placeholderów i próbuje je uzupełnić.
+
+        Kolejność źródeł: zweryfikowane dane wnioskodawcy (ProjectContext lub
+        ``known_facts``) -> Research Agent (OSINT). Zwraca AutoFillResult
+        z uzupełnioną treścią oraz listą luk wymagających człowieka (HITL).
+
+        ``known_facts`` to serializowalna mapa label->wartość (np. z
+        ``ProjectContext.to_facts_dict()``) przenoszona przez stan LangGraph.
+        Ma priorytet nad ``project_context`` (backward-compatible: domyślnie None).
+        """
+        result = AutoFillResult(filled_content=content or "")
+        placeholders = self.detect_placeholders(content or "")
+        if not placeholders:
+            return result
+
+        if known_facts:
+            facts = {str(k).lower(): str(v) for k, v in known_facts.items() if v}
+        else:
+            facts = self._facts_from_project_context(project_context)
+        context_text = "\n".join(filter(None, [extra_context, content]))
+        research_calls = 0
+
+        filled = content or ""
+        for ph in placeholders:
+            label = self._placeholder_label(ph)
+            value = self._match_fact(label, facts)
+            source = "project_context"
+
+            if not value and allow_research and research_calls < self.MAX_RESEARCH_CALLS:
+                research_calls += 1
+                value = self._research_fill(label, context_text)
+                source = "research_agent"
+
+            if value:
+                filled = filled.replace(ph, value)
+                result.resolved.append({"placeholder": ph, "value": value[:200], "source": source})
+            else:
+                result.unresolved.append(ph)
+
+        result.filled_content = filled
+        if result.unresolved:
+            critical = [self._placeholder_label(p) for p in result.unresolved if self._is_critical(self._placeholder_label(p))]
+            focus = critical or [self._placeholder_label(p) for p in result.unresolved]
+            result.hitl_question = (
+                "Uzupełnij brakujące dane wymagane do wniosku: " + "; ".join(focus[:5]) + "."
+            )
+        return result
+
+    def resolve_field(
+        self,
+        question: str,
+        context_text: str,
+        allow_research: bool = True,
+        known_facts: dict[str, str] | None = None,
+    ) -> str | None:
+        """
+        Próbuje automatycznie odpowiedzieć na pojedyncze pytanie o brakujące dane,
+        korzystając z rejestrów (GUS/REGON + KRS wykryte z kontekstu) oraz Research
+        Agenta. Zwraca tekst odpowiedzi lub None (gdy wymaga człowieka).
+
+        Ta metoda enkapsuluje logikę auto-healingu wcześniej wtopioną w
+        ``generator_agent.resolve_missing_data``.
+
+        ``known_facts`` to opcjonalna, serializowalna mapa label->wartość
+        (np. z ``ProjectContext.to_facts_dict()`` przenoszona przez stan
+        LangGraph). Gdy podana, jest używana priorytetowo do deterministycznego
+        dopasowania pola po etykiecie — PRZED fallbackiem regex/GUS/KRS/OSINT.
+        Backward-compatible: domyślnie None → dotychczasowe zachowanie.
+        """
+        if not question:
+            return None
+
+        # 0) Deterministyczne rozwiązanie z jawnie przekazanych faktów (priorytet).
+        if known_facts:
+            facts = {str(k).lower(): str(v) for k, v in known_facts.items() if v}
+            matched = self._match_fact(question, facts)
+            if matched:
+                return matched
+
+        question_lower = question.lower()
+        auto_answer = ""
+
+        # 1) Wykryj NIP / KRS w kontekście
+        nip_match = re.search(r"NIP[:\s]*(\d{10})", context_text or "", re.IGNORECASE)
+        nip = nip_match.group(1) if nip_match else None
+        krs_match = re.search(r"KRS[:\s]*(\d{10})", context_text or "", re.IGNORECASE)
+        krs = krs_match.group(1) if krs_match else None
+
+        # 2) Rejestr GUS/REGON
+        if nip:
+            try:
+                import json
+                from tools.company_search import fetch_regon_data
+
+                regon_data = fetch_regon_data(nip)
+                if regon_data:
+                    auto_answer += f"Z bazy GUS/REGON (NIP {nip}): {json.dumps(regon_data, ensure_ascii=False)}\n"
+                    if not krs and isinstance(regon_data, dict):
+                        krs = regon_data.get("krs") or regon_data.get("numerKRS")
+            except Exception as e:
+                logger.warning(f"[AutoFill] Błąd fetch_regon_data: {e}")
+
+        # 3) Odpis KRS dla pytań strukturalnych
+        structural_keywords = [
+            "adres", "forma prawna", "wspólnik", "udział", "kapitał", "zarząd",
+            "reprezent", "rejestracj", "krs", "osoba", "data rejestracji",
+        ]
+        if any(kw in question_lower for kw in structural_keywords) and krs:
+            try:
+                import json
+                from integrations.krs_client import KRSClient
+
+                odpis = KRSClient.get_odpis_aktualny(str(krs))
+                if odpis:
+                    relations = KRSClient.extract_graph_relations(odpis)
+                    auto_answer += (
+                        f"Z odpisu KRS (KRS {krs}):\n"
+                        f"- Pełne dane rejestrowe + wspólnicy + zarząd: {json.dumps(relations, ensure_ascii=False)[:1500]}\n"
+                    )
+            except Exception as e:
+                logger.warning(f"[AutoFill] Błąd pobierania odpisu KRS: {e}")
+
+        if auto_answer:
+            return auto_answer
+
+        # 4) Research Agent (OSINT) — ostateczny fallback przed HITL
+        if allow_research:
+            deep = self._research_fill(question, context_text)
+            if deep:
+                return deep
+
+        return None
+
+
+autofill_agent = AutoFillAgent()

backend/agents/compliance_guardian.py

@@ -0,0 +1,141 @@
+import logging
+import re
+from typing import Dict, Any, Optional
+from langchain_core.messages import AIMessage
+from schemas import AgentState
+
+logger = logging.getLogger(__name__)
+
+# v5.0: Import Kruczkowski Compliance & Trap Agent + Citation Verifier (Faza 2/3)
+try:
+    from core.search.regulation_engine import kruczkowski_trap_agent, citation_verifier
+except Exception:
+    kruczkowski_trap_agent = None  # type: ignore
+    citation_verifier = None  # type: ignore
+
+
+def compliance_guardian_node(state: AgentState) -> Dict[str, Any]:
+    """
+    Sprawdza, czy w state.messages nie pojawiły się zbyt wrażliwe dane (zgodność RODO).
+    W architekturze 2026 blokuje model przez wpięciem lub anonimizuje tekst.
+
+    v5.0 rozszerzenie: integruje Kruczkowski Compliance & Trap Agent dla wykrywania
+    pułapek grantowych (aid intensity, double financing, ineligible personnel etc.)
+    + podstawowy Citation Verifier na kluczowych sekcjach.
+    """
+    # Podstawowa RODO / sensitive data guard (zachowana)
+    is_safe = True
+    full_text = ""
+    
+    # Enhanced strict RODO and sensitive data patterns
+    sensitive_patterns = [
+        r"(?i)hasło", 
+        r"(?i)password", 
+        r"(?i)pesel\s*:?\s*\d{11}",
+        r"(?i)nr\s+dowodu", 
+        r"(?i)numer\s+dowodu", 
+        r"(?i)karta\s+kredytowa",
+        r"\b\d{4}[-\s]?\d{4}[-\s]?\d{4}[-\s]?\d{4}\b",
+        r"(?i)iban\s*[a-zA-Z]{2}[0-9]{26}"
+    ]
+    
+    for msg in state.messages:
+        text = msg.content.lower() if hasattr(msg, 'content') else str(msg).lower()
+        full_text += " " + text
+        
+        for pattern in sensitive_patterns:
+            if re.search(pattern, text):
+                is_safe = False
+                break
+        if not is_safe:
+            break
+
+    if not is_safe:
+        return {
+            "messages": [
+                AIMessage(
+                    content="[COMPLIANCE] Wykryto potencjalnie wrażliwe dane (PESEL/Hasła). Upewnij się, że zachowujesz zasady RODO."
+                )
+            ],
+            "current_agent": "supervisor",
+        }
+
+    # === v5.0 Kruczkowski Trap + Citation checks (jeśli dostępne dane w state) ===
+    trap_report: Optional[Dict[str, Any]] = None
+    citation_score = None
+
+    program = getattr(state, 'program_name', None) or (state.profile.program if getattr(state, 'profile', None) else None) or "unknown"
+
+    # === v5.0 Temporal Graph densify: query Neo4j for law_change before compliance/trap/Verifier ===
+    law_change_signal: Optional[Dict[str, Any]] = None
+    try:
+        from core.search.regulation_engine import regulation_engine
+        law_change = regulation_engine.detect_regulation_change(program)
+        if law_change.get("changed"):
+            # Sygnał propagowany do dalszych agentów przez pole AgentState.law_change_signal.
+            law_change_signal = law_change
+            logger.info(f"[Compliance Guardian v5.0 Temporal] Law change detected via graph for {program}: {law_change.get('change_summary','')[:60]}")
+    except Exception:
+        pass
+
+    # Jeśli jest content do audytu — uruchom pełny trap detection
+    content_to_check = ""
+    if hasattr(state, 'verification_results') and state.verification_results:
+        content_to_check = str(state.verification_results.get("pending_doc_text", "")) or ""
+    if not content_to_check and hasattr(state, 'messages'):
+        content_to_check = full_text[:4000]
+
+    if content_to_check and len(content_to_check) > 120 and kruczkowski_trap_agent:
+        try:
+            msp_ctx = None
+            if hasattr(state, 'external_context') and state.external_context:
+                msp_ctx = state.external_context.get("msp_analysis")
+            trap_report = kruczkowski_trap_agent.detect_traps(
+                document_text=content_to_check,
+                program=program,
+                msp_context=msp_ctx
+            )
+            citation_score = trap_report.get("citation_verification", {}).get("overall_citation_score")
+
+            if trap_report.get("blocks_export_recommendation"):
+                logger.warning(f"[Compliance Guardian v5.0 Kruczkowski] HIGH RISK traps detected for {program}: {trap_report.get('num_traps')}")
+        except Exception as e:
+            logger.debug(f"[Compliance Guardian] Kruczkowski trap check skipped: {e}")
+
+    # Jeśli wykryto poważne pułapki — zwracamy ostrzeżenie do supervisor
+    if trap_report and trap_report.get("overall_trap_risk") in ("high", "critical"):
+        warning = f"[KRUCZKOWSKI COMPLIANCE & TRAP v5.0] Wykryto {trap_report['num_traps']} pułapek (ryzyko: {trap_report['overall_trap_risk']}). Citation grounding: {citation_score}. Zalecana korekta przed eksportem. Szczegóły w trap_report."
+        return {
+            "messages": [AIMessage(content=warning)],
+            "current_agent": "supervisor",
+            "compliance_trap_report": trap_report,  # dla kolejnych nodów (pole w AgentState)
+            "law_change_signal": law_change_signal,
+        }
+
+    # Normalny przepływ + opcjonalny trap_report (nawet jeśli low risk)
+    result: Dict[str, Any] = {"current_agent": "supervisor"}
+    if trap_report:
+        result["compliance_trap_report"] = trap_report
+    if law_change_signal:
+        result["law_change_signal"] = law_change_signal
+    return result
+
+def check_legal_updates(project_id: str, email: str, program_name: str) -> None:
+    """
+    Faza 6: Moduł Compliance Guardian
+    Sprawdza zmiany w regulaminie danego naboru (np. na podstawie zapytań do grant_search_service)
+    i wysyła powiadomienie do użytkownika.
+
+    v5.0: Może dodatkowo uruchomić Kruczkowski Trap Agent na istniejących sekcjach projektu
+    przed wysłaniem alertu (jeśli snapshot się zmienił).
+    """
+    logger.info(f"[Compliance Guardian] Rozpoczynam sprawdzanie zmian w prawie dla: {program_name}")
+    # Tu odbywałoby się odpytanie agregatora (np. EUR-Lex / PARP) czy data modyfikacji regulaminu jest nowsza niż data rozpoczęcia projektu.
+    
+    # v5.0 hook: jeśli dostępny Kruczkowski — można by tu triggerować re-audit z citation check
+    if kruczkowski_trap_agent:
+        logger.info("[Compliance Guardian v5.0] Kruczkowski Trap Agent dostępny — w pełnej integracji uruchomi re-weryfikację po zmianie regulaminu.")
+
+    # Symulacja wysyłki maila przez Clerk / SendGrid:
+    logger.info(f"[Compliance Guardian] [MOCK EMAIL] Wysłano alert na adres {email}: Zmiany w regulaminie {program_name}!")
+

backend/agents/critic.py

@@ -0,0 +1,212 @@
+from typing import Dict, Any
+from langchain_core.messages import AIMessage
+from core.llm_router import get_llm
+from schemas import AgentState, CriticFeedback
+
+try:
+    from core.search.regulation_engine import kruczkowski_trap_agent
+except Exception:
+    kruczkowski_trap_agent = None
+
+
+def critic_node(state: AgentState) -> Dict[str, Any]:
+    """
+    Recenzent jakości tekstu biznesowego. Analizuje styl, perswazję oraz spójność merytoryczną.
+    Współpracuje z Wizardem. Odpowiada za Human-in-the-Loop weryfikacji.
+    """
+    from langchain_core.callbacks import BaseCallbackHandler
+    import logging
+    
+    logger = logging.getLogger(__name__)
+    
+    class TokenTrackingCallback(BaseCallbackHandler):
+        def __init__(self, user_id: str):
+            self.user_id = user_id
+            self.total_tokens = 0
+    
+        def on_llm_end(self, response, **kwargs):
+            try:
+                if hasattr(response, "llm_output") and response.llm_output:
+                    token_usage = response.llm_output.get("token_usage", {})
+                    tokens = token_usage.get("total_tokens", 0)
+                    if tokens > 0:
+                        self.total_tokens += tokens
+                        from core.subscription.tracker import increment_tokens
+                        if self.user_id and self.user_id != "anonymous":
+                            increment_tokens(self.user_id, tokens, action_type="critic_draft")
+            except Exception as e:
+                logger.warning(f"Błąd zliczania tokenów w critic_node: {e}")
+
+    user_id = getattr(state, "user_id", "anonymous")
+    tracking_callback = TokenTrackingCallback(user_id=user_id)
+    llm = get_llm(task_type="critical", structured_output_schema=CriticFeedback, callbacks=[tracking_callback])
+
+    # Assuming Wizard's output is in the last AI Message or in document_versions
+    # UWAGA: wiadomości LangChain mają atrybut `.type` ("ai"/"human"/"system"),
+    # NIE `.role`. Wcześniejsze `getattr(msg,"role",...)` zawsze zwracało None,
+    # przez co krytyk oceniał ostatnią wiadomość (często wejście użytkownika).
+    last_text = ""
+    for msg in reversed(state.messages):
+        msg_type = getattr(msg, "type", None)
+        if getattr(msg, "content", None) and msg_type not in ("human", "system"):
+            from core.utils import safe_extract_text
+
+            last_text = safe_extract_text(msg.content)
+            break
+
+    if not last_text:
+        return {
+            "critic_evaluation": CriticFeedback(
+                is_approved=True, score=100, feedback="Brak tekstu do oceny.", severity="low", xai_justification="Brak tekstu do oceny.", cross_check_passed=True, inconsistencies_flagged=[]
+            )
+        }
+
+    if state.critic_iterations > state.max_critic_iterations:
+        return {
+            "critic_evaluation": CriticFeedback(
+                is_approved=True,
+                score=100,
+                feedback="Automatyczne zatwierdzenie - przekroczono limit iteracji poprawek.",
+                severity="low",
+                xai_justification="Limit iteracji osiągnięty. Wymuszone zatwierdzenie.",
+                cross_check_passed=True,
+                inconsistencies_flagged=[]
+            )
+        }
+
+    import re
+
+    # HARD VALIDATION CHECKS (Python Regex) BEFORE LLM
+    text_lower = last_text.lower()
+    
+    # 1. Missing required program keywords (e.g., 'innowacj', 'przychód', depending on the module)
+    # If the text is substantial but lacks core program terminology:
+    if len(text_lower) > 100:
+        if not re.search(r'(innowacj|przychód|b\+r|badani|rozwoj|dofinansowan|projekt)', text_lower):
+            return {
+                "critic_evaluation": CriticFeedback(
+                    is_approved=False,
+                    score=0,
+                    feedback="Twarda walidacja (Regex) odrzuciła tekst: Kompletny brak wymaganych słów kluczowych programu (np. 'innowacj', 'przychód').",
+                    severity="high",
+                    xai_justification="Hard validation logic failed: Missing mandatory program keywords before LLM call.",
+                    cross_check_passed=False,
+                    inconsistencies_flagged=["Brak krytycznych słów kluczowych programu."]
+                ),
+                "critic_iterations": state.critic_iterations + 1,
+                "messages": [AIMessage(content="Twarda walidacja (Regex) odrzuciła tekst: Kompletny brak wymaganych słów kluczowych programu.")]
+            }
+
+    # 2. Budget sums mathematically incorrect or logically impossible (given RAG constraints)
+    # Check for negative amounts
+    budget_anomaly = re.search(r'(?i)(budżet|koszt|kwota|dofinansowanie)[\s=:]*-\s*\d+', last_text)
+    
+    if budget_anomaly:
+        return {
+            "critic_evaluation": CriticFeedback(
+                is_approved=False,
+                score=0,
+                feedback="Twarda walidacja (Regex) odrzuciła tekst: Wykryto nielogiczne ujemne kwoty budżetowe.",
+                severity="high",
+                xai_justification="Hard validation logic failed: Negative budget sum detected.",
+                cross_check_passed=False,
+                inconsistencies_flagged=["Ujemne kwoty budżetowe."]
+            ),
+            "critic_iterations": state.critic_iterations + 1,
+            "messages": [AIMessage(content="Twarda walidacja (Regex) odrzuciła tekst: Wykryto nielogiczne ujemne kwoty budżetowe.")]
+        }
+
+    # 3. KRUCZKOWSKI TRAP (Pułapki prawne dotacji)
+    if kruczkowski_trap_agent and hasattr(kruczkowski_trap_agent, "detect_traps"):
+        try:
+            program_name = state.program_name or "dotacje"
+            trap_result = kruczkowski_trap_agent.detect_traps(last_text, program_name)
+            if trap_result and trap_result.get("risk_level") in ["high", "critical"]:
+                # detect_traps zwraca listę dictów pułapek — wyciągamy czytelne etykiety.
+                raw_traps = trap_result.get("traps", []) or []
+                trap_labels = []
+                for t in raw_traps:
+                    if isinstance(t, dict):
+                        label = t.get("description") or t.get("trap") or t.get("code")
+                    else:
+                        label = str(t)
+                    if label:
+                        trap_labels.append(str(label))
+                traps_found = ", ".join(trap_labels)
+                return {
+                    "critic_evaluation": CriticFeedback(
+                        is_approved=False,
+                        score=10,
+                        feedback=f"Wykryto pułapki Kruczkowskiego: {traps_found}. Tekst zagraża kwalifikowalności wniosku.",
+                        severity="critical",
+                        xai_justification=f"Odrzucono ze względu na pułapki prawne: {traps_found}",
+                        cross_check_passed=False,
+                        inconsistencies_flagged=trap_labels
+                    ),
+                    "critic_iterations": state.critic_iterations + 1,
+                    "messages": [AIMessage(content=f"Wykryto krytyczne błędy formalne (Pułapka Kruczkowskiego): {traps_found}.")]
+                }
+        except Exception as e:
+            pass # Fallback to LLM if trap agent fails
+
+    prompt = f"""
+    Jesteś rygorystycznym, ale pragmatycznym Recenzentem wniosków o dofinansowanie (RedTeamCritic).
+    Przeanalizuj poniższy fragment wniosku wygenerowany przez asystenta AI pod kątem MERYTORYCZNYM i ZGODNOŚCI Z ZASADAMI (np. moduły Ścieżki SMART, zasady DNSH, koszty kwalifikowalne).
+    
+    Wymagamy RIGOROUS SCORING (surowej oceny punktowej w skali 0-100) oraz XAI JUSTIFICATION (wyjaśnialnej sztucznej inteligencji - dlaczego przyznano taką ocenę, w oparciu o konkretne przesłanki).
+    Przeprowadź ŚCISŁY CROSS-CHECK (np. czy kwoty budżetu pokrywają się z celami projektu i harmonogramem, czy zadania nie wykluczają się nawzajem).
+    Wypisz wszystkie znalezione NIESPÓJNOŚCI w polu inconsistencies_flagged.
+
+    ODRZUĆ TEKST (is_approved=False), jeśli wystąpi JAKAKOLWIEK z poniższych wad:
+    1. Błędy merytoryczne (halucynacje dotyczące zasad naboru, błędne opisy modułów takich jak B+R, Zazielenienie, Cyfryzacja).
+    2. Wprowadzenie kosztów w oczywisty sposób niekwalifikowalnych w danym module.
+    3. Kompletny brak logiki biznesowej, zaprzeczanie samemu sobie lub generowanie "wodolejstwa" zamiast wymogów dotacyjnych.
+    4. Niespójności w weryfikacji krzyżowej (np. budżet vs harmonogram). Wtedy ustaw cross_check_passed na false.
+    
+    ZAAKCEPTUJ TEKST (is_approved=True) w pozostałych przypadkach, tj. gdy warstwa merytoryczna jest poprawna. Jeśli widzisz tylko drobne błędy stylistyczne, zaakceptuj wniosek (is_approved=True), a sugestie wpisz w polu feedback, obniżając delikatnie 'score'.
+    
+    ABSOLUTNIE ZABRONIONE JEST odrzucanie tekstu (zwróć is_approved=True) TYLKO z powodu:
+    - Obecności znaczników np. [UZUPEŁNIJ: ...], [BRAK DANYCH] (są one wstawiane celowo!).
+    - Braku specyficznych danych o firmie, jeśli są zastąpione markerami.
+    
+    Odpowiadaj ZAWSZE I WYŁĄCZNIE w języku polskim.
+    
+    Tekst do sprawdzenia:
+    {last_text}
+    """
+
+    try:
+        feedback: CriticFeedback = llm.invoke(prompt)
+
+        try:
+            from core.audit_logger import audit_log
+
+            audit_log(
+                "CRITIC",
+                f"Zakończono analizę. Is Approved: {feedback.is_approved}, Score: {feedback.score}, Severity: {feedback.severity}, Cross-Check: {feedback.cross_check_passed}",
+            )
+        except Exception:
+            pass  # pre-cautionary try-except if logger is not ready yet
+
+        return {
+            "critic_evaluation": feedback,
+            "critic_iterations": state.critic_iterations + 1,
+            "messages": [AIMessage(content=feedback.feedback)]
+            if not feedback.is_approved
+            else [],
+        }
+    except Exception as e:
+        # FAIL-CLOSED: awaria walidacji krytyka NIE może oznaczać auto-akceptacji.
+        # Oznaczamy jako niezaakceptowane i wymagające ręcznej weryfikacji.
+        return {
+            "critic_evaluation": CriticFeedback(
+                is_approved=False,
+                score=0,
+                feedback=f"Awaria walidacji krytyka ({str(e)}) — sekcja NIEZWERYFIKOWANA, wymagana ręczna weryfikacja.",
+                severity="critical",
+                xai_justification="Fallback fail-closed: błąd mechanizmu oceny, brak potwierdzenia jakości.",
+                cross_check_passed=False,
+                inconsistencies_flagged=["Awaria mechanizmu krytyka — brak weryfikacji."]
+            ),
+            "critic_iterations": state.critic_iterations + 1,
+        }

backend/agents/document_gap_analyzer.py

@@ -0,0 +1,69 @@
+from typing import Dict, Any, List
+from langchain_core.messages import AIMessage
+from core.llm_router import get_llm
+from core.safe_mode import SAFE_MODE_MARKER
+from schemas import AgentState
+
+
+def _collect_structured_gaps(state: AgentState) -> List[str]:
+    gaps: List[str] = []
+    bb = state.blackboard or {}
+
+    if bb.get("data_gaps"):
+        gaps.extend(bb["data_gaps"])
+
+    enrichment = bb.get("registry_enrichment") or {}
+    if enrichment.get("gaps"):
+        for g in enrichment["gaps"]:
+            if g not in gaps:
+                gaps.append(g)
+
+    if not state.profile:
+        gaps.append("Brak profilu firmy (NIP/GUS).")
+    elif state.profile:
+        if not getattr(state.profile, "financials", None):
+            gaps.append("Brak danych finansowych w profilu.")
+        else:
+            fin = state.profile.financials
+            if getattr(fin, "revenue", 0) <= 0:
+                gaps.append("Brak udokumentowanych przychodów.")
+        if not getattr(state.profile, "pkd_codes", None):
+            gaps.append("Brak kodów PKD.")
+
+    return gaps
+
+
+def document_gap_analyzer_node(state: AgentState) -> Dict[str, Any]:
+    """
+    Analizuje profil i załączniki — wykazuje braki wymagane do wniosku dotacyjnego.
+    """
+    gaps = _collect_structured_gaps(state)
+
+    if gaps:
+        gap_result = "\n".join(f"- {g}" for g in gaps)
+        gap_result += f"\n\nGenerator użyje znacznika {SAFE_MODE_MARKER} w odpowiednich sekcjach."
+    else:
+        llm = get_llm(task_type="standard")
+        prompt_context = "Profil kompletny według rejestru."
+        if state.profile and state.profile.financials:
+            prompt_context = f"Dane finansowe: {state.profile.financials}"
+        prompt = f"""
+        Jesteś Document Gap Analyzerem. Sprawdź, czego brakuje do wniosku dotacyjnego.
+        Zwróć listę wypunktowaną. Pisz po polsku.
+        Kontekst: {prompt_context}
+        """
+        response = llm.invoke(prompt)
+        from core.utils import safe_extract_text
+        gap_result = safe_extract_text(response.content)
+
+    bb = dict(state.blackboard or {})
+    bb["data_gaps"] = gaps or bb.get("data_gaps", [])
+    bb["gap_analysis_done"] = True
+
+    return {
+        "messages": [
+            AIMessage(content=f"[GAP ANALYZER] Znalazłem następujące braki:\n{gap_result}")
+        ],
+        "blackboard": bb,
+        "current_agent": "supervisor",
+    }

backend/agents/evaluator.py

@@ -0,0 +1,128 @@
+from pydantic import BaseModel, Field
+from typing import Literal
+from core.llm_router import get_llm
+from langchain_core.prompts import PromptTemplate
+from rag_pipeline import get_hybrid_retriever, rerank_documents
+import logging
+from tenacity import retry, stop_after_attempt, wait_exponential
+
+logger = logging.getLogger(__name__)
+
+
+class ExpenseEvaluationResponse(BaseModel):
+    czy_wydatek_kwalifikowalny: bool = Field(
+        description="Zwróć True jeśli wydatek jest w 100% zgodny z regulaminem i wytycznymi programu (kwalifikowalny)."
+    )
+    uzasadnienie_prawne: str = Field(
+        description="Cytat lub konkretne odwołanie do regulaminu uzasadniające kwalifikowalność lub jej brak."
+    )
+    kategoria_badan: Literal[
+        "badania przemysłowe",
+        "prace rozwojowe",
+        "prace przedwdrożeniowe",
+        "brak/nie dotyczy",
+    ] = Field(
+        description="Wybierz do jakiej kategorii zgodnie z polskim/unijnym prawem należy ten wydatek. Wybierz 'brak/nie dotyczy' tylko jeśli wydatek jest całkowicie poza B+R."
+    )
+    intensywnosc_pomocy: float = Field(
+        description="Zwróć w formie wartości zmiennoprzecinkowej np. 0.50 (co oznacza 50%), 0.80 (co oznacza 80%) bazując na wielkości firmy i rodzaju badań. 0.0 oznacza wydatek niekwalifikowalny."
+    )
+
+
+def evaluate_project_expense(
+    expense_description: str,
+    expense_amount: float,
+    project_title: str,
+    program_name: str,
+    company_size: str,
+    tenant_id: str = None,
+) -> ExpenseEvaluationResponse:
+    """
+    Agent ds. Oceny Kwalifikowalności (FAZA 4).
+    Wymusza twarde, ustrukturyzowane ramy JSON za pomocą Pydantic.
+    Opiera się na wiedzy RAG dotyczącej wybranego programu.
+    """
+
+    # Próba załadowania kontekstu z RAG - Hard Filtering na aktualną perspektywę
+    # Domyślnie wyszukujemy tylko w najnowszej perspektywie (FAZA 3, zapobieganie aplikacji starych przepisów)
+    hard_filter = {"rok_perspektywy": {"$eq": "2021-2027"}}
+    if program_name:
+        # Operator $and dla Pinecone Vector Store
+        hard_filter = {
+            "$and": [
+                {"program_name": {"$eq": program_name}},
+                {"rok_perspektywy": {"$eq": "2021-2027"}},
+            ]
+        }
+
+    context_text = "Brak specyficznego regulaminu programu w bazie."
+    try:
+        retriever = get_hybrid_retriever(
+            k=10, metadata_filter=hard_filter, namespace=tenant_id
+        )
+        if retriever:
+            query_for_rag = f"kwalifikowalność wydatku badania kategoria intensywność dotacji pomoc publiczna: {expense_description}"
+            docs = retriever.invoke(query_for_rag)
+            reranked_docs = rerank_documents(query_for_rag, docs, top_n=4)
+            context_text = "\n\n".join(
+                [
+                    f"[ŹRÓDŁO: {d.metadata.get('source', 'Brak')}]: {d.page_content}"
+                    for d in reranked_docs
+                ]
+            )
+    except Exception as e:
+        logger.error(f"[ExpenseEvaluator] Error fetching RAG context: {str(e)}")
+
+    template = """
+    Jesteś Głównym Prawnikiem i Audytorem Dotacyjnym oceniającym kwalifikowalność wydatków.
+    Oceniasz pojedynczy wydatek dla projektu w ramach programu: {program_name}.
+    Wielkość przedsiębiorstwa wnioskodawcy: {company_size}.
+    
+    Opis wydatku do weryfikacji:
+    "{expense_description}" (Kwota: {expense_amount} PLN)
+    
+    Kontekst z regulaminów z bazy wiedzy:
+    --------------------------------------------------
+    {context}
+    --------------------------------------------------
+    
+    Zasady:
+    1. Przeanalizuj czy podany wydatek kwalifikuje się do objęcia wsparciem zgodnie z bazą wiedzy.
+    2. Określ kategorię badań dla wydatku, zgodnie z definicjami (badania przemysłowe, prace rozwojowe, przedwdrożeniowe).
+    3. Jeśli wydatek jest kwalifikowalny, przypisz prawidłową intensywność pomocy (zazwyczaj mniejszy procent dla prac rozwojowych/dużych firm, większy dla badań przemysłowych/MŚP).
+    4. Podaj bardzo precyzyjne uzasadnienie prawne odnoszące się do regulaminu.
+    """
+
+    prompt = PromptTemplate.from_template(template)
+
+    # LLM z typowaniem - GPT-4o jest dużo lepszy do takich zadań analitycznych
+    structured_llm = get_llm(
+        task_type="legal_audit", structured_output_schema=ExpenseEvaluationResponse
+    )
+
+    chain = prompt | structured_llm
+
+
+    @retry(
+        stop=stop_after_attempt(3), wait=wait_exponential(multiplier=1, min=2, max=10)
+    )
+    def _invoke_chain():
+        result = chain.invoke(
+            {
+                "program_name": program_name or "Ogólne zasady dotacji B+R",
+                "company_size": company_size or "MŚP (nieokreślona wielkość)",
+                "expense_description": expense_description,
+                "expense_amount": expense_amount,
+                "context": context_text,
+            }
+        )
+        if not result.uzasadnienie_prawne or len(result.uzasadnienie_prawne.strip()) < 10:
+            raise ValueError("Brak wystarczającego uzasadnienia prawnego.")
+        if not (0.0 <= result.intensywnosc_pomocy <= 1.0):
+            raise ValueError("Intensywność pomocy poza zakresem 0.0 - 1.0.")
+        return result
+
+
+    result = _invoke_chain()
+
+    return result

backend/agents/finance_agent.py

@@ -0,0 +1,122 @@
+import logging
+from typing import Optional, Tuple, List
+from pydantic import BaseModel, Field
+
+from core.llm_router import get_llm
+from langchain_core.messages import SystemMessage, HumanMessage
+from core.utils import extract_markdown_and_sanitize
+from agents.helpers import ANTI_HALLUCINATION_PROMPT
+from tenacity import retry, stop_after_attempt, wait_exponential
+
+logger = logging.getLogger(__name__)
+
+class CostItem(BaseModel):
+    name: str = Field(description="Krótka nazwa kosztu (np. Zakup wtryskarki, Wynagrodzenia B+R)")
+    category: str = Field(description="Kategoria: CAPEX (środki trwałe) lub OPEX (koszty operacyjne)")
+    amount_pln: float = Field(description="Kwota netto w PLN (bez przecinków, np. 150000.00)")
+    is_eligible: bool = Field(description="Czy wydatek jest w 100% kwalifikowalny zgodnie z regulaminem?")
+
+class FinancialData(BaseModel):
+    costs: List[CostItem] = Field(description="Lista zidentyfikowanych kosztów z opisu projektu lub logiki branżowej")
+    revenue_projection_year_1: float = Field(description="Prognoza przychodów w PLN (rok 1 po zakończeniu)")
+    revenue_projection_year_3: float = Field(description="Prognoza przychodów w PLN (rok 3 po zakończeniu)")
+    discount_rate_percent: float = Field(description="Założona stopa dyskontowa w % (np. 8.0)")
+    missing_data_question: Optional[str] = Field(None, description="Jakich danych najbardziej brakuje?")
+    reasoning_explanation: str = Field(..., description="XAI: Krótko uzasadnij kwalifikowalność wymienionych kosztów na bazie dostarczonych reguł z RAG.")
+
+class FinanceAgent:
+    """
+    Hybrydowy Agent Finansowy (Opcja A - Twarda logika + LLM).
+    LLM identyfikuje z tekstu pozycje kosztowe i orzeka o kwalifikowalności.
+    Python zlicza sumy, generuje tabele Markdown i wylicza podstawowe wskaźniki (bez ryzyka halucynacji matematycznych).
+    """
+    
+    def __init__(self):
+        self.llm = get_llm(task_type="critical", structured_output_schema=FinancialData)
+        
+    def _generate_markdown_from_data(self, data: FinancialData, section_name: str) -> str:
+        md = f"### {section_name}\n\n"
+        md += "Na podstawie analizy dostarczonych danych wygenerowano poniższe zestawienie planowanych wydatków. "
+        md += "Zastosowano kategoryzację kosztów oraz zweryfikowano ich kwalifikowalność w oparciu o wytyczne.\n\n"
+        
+        md += "#### 1. Zestawienie Kosztów Projektu\n\n"
+        md += "| Lp. | Kategoria | Nazwa wydatku | Kwota Netto (PLN) | Kwalifikowalny |\n"
+        md += "|---|---|---|---|---|\n"
+        
+        total_capex = 0.0
+        total_opex = 0.0
+        total_eligible = 0.0
+        
+        for idx, cost in enumerate(data.costs, 1):
+            elig_str = "✅ Tak" if cost.is_eligible else "❌ Nie"
+            md += f"| {idx} | **{cost.category}** | {cost.name} | {cost.amount_pln:,.2f} PLN | {elig_str} |\n"
+            
+            if cost.category.upper() == "CAPEX":
+                total_capex += cost.amount_pln
+            else:
+                total_opex += cost.amount_pln
+                
+            if cost.is_eligible:
+                total_eligible += cost.amount_pln
+                
+        total_budget = total_capex + total_opex
+        
+        md += f"| | | **SUMA CAŁKOWITA** | **{total_budget:,.2f} PLN** | |\n\n"
+        
+        md += "#### 2. Struktura Finansowania\n\n"
+        md += f"- **Suma CAPEX (Wydatki majątkowe):** {total_capex:,.2f} PLN\n"
+        md += f"- **Suma OPEX (Koszty operacyjne):** {total_opex:,.2f} PLN\n"
+        md += f"- **Wydatki Kwalifikowalne łącznie:** {total_eligible:,.2f} PLN\n"
+        md += f"- **Wydatki Niekwalifikowalne:** {(total_budget - total_eligible):,.2f} PLN\n\n"
+        
+        md += "#### 3. Prognozy i Wskaźniki\n\n"
+        md += f"- Prognozowany przychód (Rok 1): **{data.revenue_projection_year_1:,.2f} PLN**\n"
+        md += f"- Prognozowany przychód (Rok 3): **{data.revenue_projection_year_3:,.2f} PLN**\n"
+        md += f"- Stopa dyskonta do wyliczeń NPV: **{data.discount_rate_percent}%**\n\n"
+        
+        md += f"<!-- XAI: {data.reasoning_explanation} -->\n"
+        return md
+
+    def draft_financial_section(self, document_type: str, section_name: str, project_desc: str, context: str) -> Tuple[str, Optional[str]]:
+        logger.info(f"[FinanceAgent Hybrid] Zlecono ekstrakcję finansową: {section_name}")
+        
+        system_prompt = (
+            ANTI_HALLUCINATION_PROMPT + "\n\n"
+            "Jesteś precyzyjnym Ekstraktorem Danych Finansowych. Twoim jedynym zadaniem jest zidentyfikowanie w opisie projektu poszczególnych "
+            "planowanych wydatków, przypisanie ich do kategorii (CAPEX/OPEX) oraz ocena (w oparciu TYLKO o Kontekst RAG), czy dany wydatek "
+            "jest kosztom kwalifikowalnym w ramach wybranego programu dotacyjnego.\n\n"
+            "ZASADY:\n"
+            "1. WYCIĄGAJ konkretne kwoty z opisu. Jeśli nie ma podanych kwot, a projekt opiera się na np. zakupie serwerów, "
+            "NIE ZMYŚLAJ i NIE SZACUJ KWOT. Użyj wyraźnej zmiennej, np. 0.0 w polu kwoty, a w nazwie kosztu dodaj znacznik `[KWOTA_DO_UZUPEŁNIENIA]`.\n"
+            "2. NIE WOLNO Ci zmyślać nowych typów kosztów (np. maszyny rolniczej dla firmy IT).\n"
+            "3. Prognozę przychodów wylicz na bazie obecnych obrotów firmy (jeśli brak danych, ustaw 0.0 i zapisz w uzasadnieniu, że wymaga podania danych od klienta).\n"
+        )
+        
+        human_content = f"Dokument: {document_type}\n\nKontekst Programu:\n{context}\n\nOpis Projektu:\n{project_desc}"
+        
+        @retry(stop=stop_after_attempt(3), wait=wait_exponential(multiplier=1, min=2, max=10))
+        def _invoke_llm():
+            res = self.llm.invoke([
+                SystemMessage(content=system_prompt),
+                HumanMessage(content=human_content)
+            ])
+            if not getattr(res, "costs", None) or len(res.costs) == 0:
+                # Nie rzucamy błędu - może to być autentyczny brak danych
+                if not res.missing_data_question:
+                    res.missing_data_question = "W opisie projektu brakuje jakichkolwiek informacji o kosztach i wydatkach. Proszę o ich uzupełnienie."
+                res.costs = []
+            return res
+
+        try:
+            structured_data: FinancialData = _invoke_llm()
+            # Obliczenia matematyczne i generacja tabel (Twarda Logika Pythona)
+            markdown_content = self._generate_markdown_from_data(structured_data, section_name)
+            
+            missing = structured_data.missing_data_question
+            return markdown_content, missing
+            
+        except Exception as e:
+            logger.error(f"[FinanceAgent] Błąd Hybrydowy LLM: {e}")
+            return f"*(Błąd podczas analizy hybrydowej sekcji finansowej: {str(e)})*", None
+
+finance_agent = FinanceAgent()

backend/agents/gap_analyzer.py

@@ -0,0 +1,73 @@
+"""Gap analyzer node with context-bus aware clarifying questions."""
+
+from __future__ import annotations
+
+from typing import Any, Dict, List
+
+from langchain_core.messages import AIMessage
+
+from agents.document_gap_analyzer import _collect_structured_gaps
+from core.context.context_bus import filter_clarifying_questions
+from schemas import AgentState
+
+
+def _gap_to_question(gap: str) -> str | None:
+    g = (gap or "").lower()
+    if "pkd" in g:
+        return "Podaj główny kod PKD działalności objętej projektem."
+    if "nip" in g or "gus" in g or "profilu firmy" in g:
+        return "Podaj NIP firmy, aby pobrać dane z rejestru GUS."
+    if "opis" in g or "cel" in g:
+        return "Opisz cel projektu i planowane wydatki w 2–3 zdaniach."
+    if "finans" in g or "przychod" in g:
+        return "Podaj przychody firmy z ostatniego roku obrotowego."
+    if "wojew" in g or "region" in g:
+        return "Uzupełnij województwo realizacji projektu."
+    return f"Uzupełnij brakującą informację: {gap}"
+
+
+def build_clarifying_questions(gaps: List[str], profile: dict | None) -> List[str]:
+    profile = profile or {}
+    company = dict(profile)
+    if hasattr(profile, "model_dump"):
+        company = profile.model_dump()
+    elif hasattr(profile, "dict"):
+        company = profile.dict()
+
+    questions: List[str] = []
+    for gap in gaps or []:
+        q = _gap_to_question(gap)
+        if q and q not in questions:
+            questions.append(q)
+
+    return filter_clarifying_questions(questions, company, gaps)
+
+
+def gap_analyzer_node(state: AgentState) -> Dict[str, Any]:
+    gaps = _collect_structured_gaps(state)
+    profile_dict: dict = {}
+    if state.profile:
+        if hasattr(state.profile, "model_dump"):
+            profile_dict = state.profile.model_dump()
+        elif hasattr(state.profile, "dict"):
+            profile_dict = state.profile.dict()
+        else:
+            profile_dict = dict(state.profile)
+
+    clarifying = build_clarifying_questions(gaps, profile_dict)
+
+    bb = dict(state.blackboard or {})
+    bb["data_gaps"] = gaps
+    bb["gap_analysis_done"] = True
+    bb["clarifying_questions"] = clarifying
+
+    summary = "\n".join(f"- {g}" for g in gaps) if gaps else "Brak krytycznych braków danych."
+    return {
+        "messages": [
+            AIMessage(
+                content=f"[GAP ANALYZER] Analiza braków zakończona.\n{summary}"
+            )
+        ],
+        "blackboard": bb,
+        "current_agent": "supervisor",
+    }

backend/agents/generator_agent.py

@@ -0,0 +1,1615 @@
+import logging
+import os
+from typing import Dict, List, TypedDict, Optional, Any
+from langchain_core.messages import SystemMessage, HumanMessage
+from langgraph.graph import StateGraph, START, END
+
+# Importy z rdzenia backendu
+try:
+    from core.llm_router import get_llm
+except ImportError:
+    from backend.core.llm_router import get_llm
+
+try:
+    from core.utils import extract_markdown_and_sanitize
+except ImportError:
+    from backend.core.utils import extract_markdown_and_sanitize
+
+# Foundational observability instrumentation for generation (v5.0)
+import time
+from core.telemetry import metrics
+from core.safe_mode import SAFE_MODE_GENERATOR_RULE
+
+from tenacity import retry, stop_after_attempt, wait_exponential
+
+# v5.0 advanced verification layers for generation (Faza 3/4 autopilot track)
+# Integrates CitationVerifier + KruczkowskiComplianceTrapAgent directly into drafting
+# for proactive grounding + trap detection (moves beyond post-audit only)
+try:
+    from core.search.regulation_engine import citation_verifier, kruczkowski_trap_agent
+except Exception:
+    citation_verifier = None
+    kruczkowski_trap_agent = None
+
+try:
+    from rag_pipeline.vector_store import get_parent_document_retriever
+except ImportError:
+    from backend.rag_pipeline.vector_store import get_parent_document_retriever
+
+try:
+    from core.sensitive_data_guard import anonymizer
+except ImportError:
+    try:
+        from backend.core.sensitive_data_guard import anonymizer
+    except ImportError:
+        anonymizer = None
+
+try:
+    from core.audit_logger import audit_log
+except ImportError:
+    audit_log = None
+
+logger = logging.getLogger(__name__)
+
+# Bounded retries for full-autopilot pipeline (krytyk globalny → korekta → audyt panelowy).
+MAX_HOLISTIC_RETRIES = int(os.getenv("FULL_AUTOPILOT_MAX_HOLISTIC_RETRIES", "2"))
+MAX_PANEL_AUDIT_RETRIES = int(os.getenv("FULL_AUTOPILOT_MAX_PANEL_RETRIES", "2"))
+
+from langchain_core.callbacks import BaseCallbackHandler
+class TokenTrackingCallback(BaseCallbackHandler):
+    def __init__(self, user_id: str):
+        self.user_id = user_id
+        self.total_tokens = 0
+
+    def on_llm_end(self, response, **kwargs):
+        try:
+            if hasattr(response, "llm_output") and response.llm_output:
+                token_usage = response.llm_output.get("token_usage", {})
+                tokens = token_usage.get("total_tokens", 0)
+                if tokens > 0:
+                    self.total_tokens += tokens
+                    from core.subscription.tracker import increment_tokens
+                    if self.user_id and self.user_id != "anonymous":
+                        increment_tokens(self.user_id, tokens, action_type="generator_draft")
+        except Exception as e:
+            logger.warning(f"Błąd zliczania tokenów: {e}")
+
+
+class GeneratorState(TypedDict):
+    """Stan przepływu w LangGraph dla generatora wniosków."""
+
+    project_id: str
+    namespace: str
+    document_type: str
+
+    # Opis projektu wczytany z DB — anonymizowany przed wysłaniem do LLM
+    project_description: Optional[str]
+
+    sections_plan: List[dict]
+    current_section_idx: int
+    generated_sections: Dict[str, str]
+
+    context: str
+    is_completed: bool
+    missing_data_question: Optional[str]
+    additional_context: Optional[str]
+    # Zserializowana mapa zweryfikowanych faktów wnioskodawcy (ProjectContext.to_facts_dict()).
+    # JSON-serializowalny słownik (label->wartość) — bezpieczny dla checkpointingu LangGraph,
+    # używany przez Auto-Fill Agenta do deterministycznego uzupełniania placeholderów.
+    project_context_facts: Optional[Dict[str, str]]
+    traceability_data: Optional[Dict[str, List[dict]]]
+    audit_retries: int
+    section_stall_counts: Optional[Dict[str, int]]
+    section_critic_retries: Optional[Dict[str, int]]
+    graph_step: int
+    # Sygnały bramek jakości (fail-closed) — propagowane do persystencji i eksportu.
+    guard_block: Optional[bool]
+    human_review_required: Optional[bool]
+    unverified_sections: Optional[Dict[str, str]]
+    # Unified full-autopilot pipeline (generowanie → krytyk globalny → audyt panelowy).
+    full_autopilot: Optional[bool]
+    holistic_retries: Optional[int]
+    panel_audit_retries: Optional[int]
+    holistic_phase_complete: Optional[bool]
+    panel_audit_done: Optional[bool]
+    pipeline_phase: Optional[str]
+    global_audit_result: Optional[Dict[str, Any]]
+    # Kontekst projektu (regulamin, grant, required_sections) — JSON-serializowalny pod checkpoint.
+    external_context: Optional[Dict[str, Any]]
+
+
+# Async checkpoint dla LangGraph (astream_events wymaga AsyncSqliteSaver).
+import aiosqlite
+from langgraph.checkpoint.sqlite.aio import AsyncSqliteSaver
+
+data_dir = os.path.join(os.path.dirname(os.path.dirname(__file__)), "data")
+os.makedirs(data_dir, exist_ok=True)
+db_path = os.path.join(data_dir, "generator_checkpoints.db")
+
+global_memory_saver: AsyncSqliteSaver | None = None
+_sqlite_conn = None
+
+
+async def ensure_async_checkpointer() -> AsyncSqliteSaver:
+    global global_memory_saver, _sqlite_conn
+    if global_memory_saver is None:
+        _sqlite_conn = await aiosqlite.connect(db_path)
+        global_memory_saver = AsyncSqliteSaver(_sqlite_conn)
+        await global_memory_saver.setup()
+    return global_memory_saver
+
+
+async def checkpoint_get(config: dict):
+    saver = await ensure_async_checkpointer()
+    return await saver.aget(config)
+
+
+def _company_fields_satisfy(question_lower: str, full_context: str):
+    """Sprawdza czy pytanie o dane firmy jest już pokryte kontekstem GUS/KRS."""
+    if not question_lower or not full_context:
+        return None
+    ctx = full_context.lower()
+    # P3#13: dopasowanie po FRAZACH, nie pojedynczych słowach — inaczej pytanie
+    # "nazwa produktu" byłoby błędnie tłumione jako dane firmy w kontekście.
+    field_checks = [
+        (["nip", "numer identyfikacji podatkowej", "regon"], ["nip:", "nip ", "<nip_", "regon", "numer nip"]),
+        (["nazwa firmy", "nazwa wnioskodawcy", "nazwa przedsiębiorstwa", "nazwa podmiotu", "firma wnioskodawcy", "pełna nazwa firmy"], ["<firma_", "wnioskodawc", "dane obowiązkowe", "nazwa firmy", "nazwa wnioskodawcy"]),
+        (["adres siedziby", "siedziba firmy", "województwo firmy", "miejsce siedziby"], ["adres", "ul.", "siedzib", "województwo", "miejscowość"]),
+        (["forma prawna", "numer krs", "rejestr przedsiębiorców"], ["forma prawna", "krs", "sp. z o.o", "spółka akcyjna"]),
+    ]
+    for keywords, signals in field_checks:
+        if any(kw in question_lower for kw in keywords):
+            if any(sig in ctx for sig in signals):
+                return (
+                    "Dane firmy (NIP/nazwa/adres/forma prawna) są już w kontekście projektu "
+                    "(GUS/KRS lub dane użytkownika). Nie pytaj ponownie — użyj ich w treści sekcji."
+                )
+    return None
+
+
+class DocumentGeneratorAgent:
+    """
+    Agent korzystający z maszyn stanów LangGraph do wytwarzania długich
+    i sformalizowanych dokumentów, zabezpieczony danymi z RAG (Rząd RP/PARP).
+
+    v5.0 Evolution (Faza 3/4 autopilot track - silent sub-agent work):
+    - Direct integration of CitationVerifier + KruczkowskiComplianceTrapAgent in draft path (proactive self-verification).
+    - Enhanced context handling: regulation snapshots + safe truncation (_safe_truncate_context).
+    - Stability: layered fallbacks, telemetry/metrics for verification/truncation, persistent Sqlite checkpoints.
+    - Toward multi-agent: already delegates specialists (finance_agent); verification acts as internal critic step.
+    Incremental, high-quality, non-breaking improvements for reliability in later roadmap phases.
+    """
+
+    def __init__(self):
+        # Używamy najlepszego modelu, docelowo task_type="critical" by odpalić np. Gemini 1.5 Pro
+        # (albo dedykowany fine-tuned)
+        self.llm = get_llm(task_type="critical")
+        self.graph = None
+
+    async def get_graph(self):
+        if self.graph is None:
+            cp = await ensure_async_checkpointer()
+            self.graph = self._build_graph(cp)
+        return self.graph
+
+    def _build_graph(self, checkpointer=None):
+        workflow = StateGraph(GeneratorState)
+
+        # Rejestracja Węzłów
+        workflow.add_node("plan_document", self.plan_document)
+        workflow.add_node("fetch_context", self.fetch_context)
+        workflow.add_node("draft_section", self.draft_section)
+        workflow.add_node("resolve_missing_data", self.resolve_missing_data)
+        workflow.add_node("ask_missing_data", self.ask_missing_data)
+        workflow.add_node("wait_for_human_review", self.wait_for_human_review)
+        workflow.add_node("pre_submission_audit", self.pre_submission_audit)
+        workflow.add_node("global_holistic_review", self.global_holistic_review)
+        workflow.add_node("global_panel_audit", self.global_panel_audit)
+
+        # Sterowanie przepływem (Graf)
+        workflow.add_edge(START, "plan_document")
+        workflow.add_edge("plan_document", "fetch_context")
+        workflow.add_edge("fetch_context", "draft_section")
+
+        # Pętla warunkowa (Czy mamy jeszcze sekcje do wygenerowania, albo czy brakuje danych?)
+        workflow.add_conditional_edges(
+            "draft_section",
+            self._should_continue,
+            {
+                "continue": "fetch_context",
+                "resolve": "resolve_missing_data",
+                "review": "wait_for_human_review",
+                "audit": "pre_submission_audit",
+            },
+        )
+        
+        # Z audytu Red Team → full-autopilot (holistic + panel) lub koniec / retry / HIL
+        workflow.add_conditional_edges(
+            "pre_submission_audit",
+            self._route_after_pre_submission_audit,
+            {
+                "end": END,
+                "retry": "fetch_context",
+                "review": "wait_for_human_review",
+                "holistic": "global_holistic_review",
+                "panel": "global_panel_audit",
+            },
+        )
+        workflow.add_conditional_edges(
+            "global_holistic_review",
+            self._route_after_holistic_review,
+            {
+                "regen": "fetch_context",
+                "panel": "global_panel_audit",
+                "review": "wait_for_human_review",
+            },
+        )
+        workflow.add_conditional_edges(
+            "global_panel_audit",
+            self._route_after_panel_audit,
+            {
+                "end": END,
+                "regen": "fetch_context",
+                "review": "wait_for_human_review",
+            },
+        )
+        workflow.add_edge("wait_for_human_review", "fetch_context")
+
+        # Nowy warunek: po próbie auto-rozwiązania (Tool Calling), decyduje czy nadal pytać użytkownika
+        workflow.add_conditional_edges(
+            "resolve_missing_data",
+            lambda s: "pause" if s.get("missing_data_question") else "draft_section",
+            {
+                "pause": "ask_missing_data",
+                "draft_section": "draft_section"
+            }
+        )
+        
+        workflow.add_edge("ask_missing_data", "draft_section")
+
+        # Production hardening: tolerate None checkpointer (degraded resume) while keeping interrupt
+        cp = checkpointer
+        return workflow.compile(
+            checkpointer=cp if cp is not None else None, interrupt_before=["ask_missing_data", "wait_for_human_review"]
+        )
+
+    def resolve_missing_data(self, state: GeneratorState):
+        """
+        Autopilot-friendly resolver.
+        Próbuje jak najwięcej danych wyciągnąć automatycznie z GUS + KRS,
+        zanim odda kontrolę człowiekowi.
+        """
+        logger.info("[Generator] Próba automatycznego znalezienia brakujących danych (GUS/KRS)...")
+        question = state.get("missing_data_question")
+        
+        if not question:
+            return {"additional_context": state.get("additional_context")}
+
+        auto_answer = ""
+
+        # Najpierw sprawdźmy, czy odpowiedź już nie jest w istniejącym kontekście (project_description + additional_context)
+        full_context = (state.get("project_description") or "") + "\n" + (state.get("additional_context") or "")
+        question_lower = question.lower()
+
+        company_msg = _company_fields_satisfy(question_lower, full_context)
+        if company_msg:
+            logger.info(f"[Generator] Dane firmy już w kontekście (GUS/KRS): {company_msg[:200]}...")
+            old_ctx = state.get("additional_context") or ""
+            new_ctx = old_ctx + f"\n\n[ZAUTOMATYZOWANA ODPOWIEDŹ / SPRAWDZENIE KONTEKSTU na pytanie '{question}']:\n{company_msg}\nNie pytaj użytkownika ponownie o te informacje – są już dostępne."
+            return {
+                "missing_data_question": None,
+                "additional_context": new_ctx
+            }
+
+        # Prosta heurystyka: jeśli pytanie dotyczy czegoś, co już jest w kontekście, nie pytaj ponownie
+        if any(kw in question_lower for kw in ["adres", "siedzib", "miejsce", "województwo", "wojewodztwo"]) and ("adres" in full_context.lower() or "ul." in full_context.lower() or "województwo" in full_context.lower()):
+            auto_answer = "Informacja o adresie/siedzibie/województwie firmy jest już dostępna w kontekście projektu (z danych GUS lub wpisanych wcześniej przez użytkownika). Nie trzeba pytać ponownie."
+        elif any(kw in question_lower for kw in ["wspólnik", "udział", "kapitał", "właściciel"]) and ("wspólnik" in full_context.lower() or "udział" in full_context.lower() or "krs_full" in full_context.lower()):
+            auto_answer = "Dane o wspólnikach/udziałowcach są już w kontekście (z odpisu KRS lub wcześniejszych informacji użytkownika)."
+
+        # Delegacja auto-healingu (rejestry GUS/KRS + Research OSINT) do dedykowanego
+        # Auto-Fill Agenta (FAZA 3). Heurystyki kontekstowe powyżej pozostają w węźle.
+        if not auto_answer:
+            try:
+                from agents.autofill_agent import autofill_agent
+
+                auto_answer = autofill_agent.resolve_field(
+                    question,
+                    full_context,
+                    known_facts=state.get("project_context_facts"),
+                ) or ""
+            except Exception as e:
+                logger.error(f"[TITAN Auto-Healing] Auto-Fill Agent błąd: {e}")
+
+        if auto_answer:
+            logger.info(f"[Generator] Znalazłem dane automatycznie (lub wykryłem, że są już w kontekście): {auto_answer[:400]}...")
+            old_ctx = state.get("additional_context") or ""
+            new_ctx = old_ctx + f"\n\n[ZAUTOMATYZOWANA ODPOWIEDŹ / SPRAWDZENIE KONTEKSTU na pytanie '{question}']:\n{auto_answer}\nNie pytaj użytkownika ponownie o te informacje – są już dostępne."
+            return {
+                "missing_data_question": None,
+                "additional_context": new_ctx
+            }
+
+        # Jeśli Auto-Fill Agent nie znalazł danych — wracamy do HIL (człowiek decyduje)
+        logger.warning(f"[TITAN v1.0] Brak danych, zatrzymuję potok (Human-in-the-Loop) dla: {question}")
+        return {"missing_data_question": question}
+
+    def wait_for_human_review(self, state: GeneratorState):
+        """
+        Węzeł pauzujący graf w celu umożliwienia recenzji HIL (Human-in-the-Loop) wygenerowanej sekcji.
+        Wykonywany PO wznowieniu przez człowieka (interrupt_before). Czyścimy guard_block,
+        by po uwzględnieniu uwag człowieka ponowić przebieg bez zapętlenia na tej samej blokadzie.
+        """
+        logger.info(f"[Generator] Recenzja człowieka (HIL) przyjęta dla projektu {state.get('project_id')} — wznawiam.")
+        return {
+            "guard_block": False,
+            "is_completed": False,
+            "current_section_idx": 0,
+        }
+
+    def ask_missing_data(self, state: GeneratorState):
+        """Węzeł pauzujący działanie grafu przed wykonaniem (interrupt_before)."""
+        logger.info(
+            f"Pauza HIL. Oczekiwanie na dane: {state.get('missing_data_question')}"
+        )
+        # Po wznowieniu przez użytkownika (update state'u o 'additional_context'),
+        # czyścimy to zapytanie, żeby nie wpaść w pętlę.
+        return {"missing_data_question": None}
+
+    def _run_v5_verification(self, section_content: str, section_name: str, program_hint: str) -> Dict[str, Any]:
+        """
+        v5.0 Faza 3/4: Proactive verification inside generation flow.
+        Runs CitationVerifier (claim grounding) + Kruczkowski Trap detection on the just-drafted section.
+        Returns structured metadata for traceability + quality signals. Non-fatal on errors.
+        This evolves the generator from "produce then audit" to "produce + self-verify".
+        """
+        verification: Dict[str, Any] = {
+            "verifier_version": "v5.0-citation+kruczkowski",
+            "section": section_name,
+            "citation": {"overall_score": 0.0, "quality": "unknown", "issues": []},
+            "traps": {"detected": [], "risk_level": "unknown"},
+            "applied": False,
+        }
+        if not section_content or len(section_content.strip()) < 30:
+            return verification
+
+        program = program_hint or "unknown"
+        try:
+            if citation_verifier:
+                cit = citation_verifier.verify_text_citations(
+                    full_text=section_content[:6000],  # cap for cost/speed
+                    program=program,
+                    sample_claims=None
+                )
+                verification["citation"] = {
+                    "overall_score": cit.get("overall_citation_score", 0.0),
+                    "quality": cit.get("citation_quality", "unknown"),
+                    "issues": [c.get("issues", []) for c in cit.get("per_claim_results", [])[:2] if c.get("issues")],
+                    "recommendation": cit.get("recommendation", "")
+                }
+                # v5.0 data quality extension for generated content (integrated into generator flow)
+                if hasattr(citation_verifier, "compute_generated_content_data_quality"):
+                    try:
+                        dq = citation_verifier.compute_generated_content_data_quality(section_content, program)
+                        verification["data_quality"] = {
+                            "score": dq.get("data_quality_score"),
+                            "level": dq.get("quality_level"),
+                            "signals": dq.get("signals", [])[:4],
+                            "recommendation": dq.get("recommendation", "")
+                        }
+                        if dq.get("data_quality_score", 50) < 48:
+                            metrics.increment("generation.v5_low_data_quality_detected", tags={"section": section_name})
+                    except Exception:
+                        pass
+                verification["applied"] = True
+                metrics.increment("generation.v5_verification_citation_runs", tags={"quality": verification["citation"]["quality"]})
+                try:
+                    csc = verification.get("citation", {}).get("overall_score", 0.65)
+                    from core.telemetry import metrics as _m2
+                    _m2.record_faithfulness_trend(csc, {"via": "generator_agent_v5"})
+                except Exception:
+                    pass
+        except Exception as e:
+            logger.warning(f"[Generator v5.0] CitationVerifier failed in _run_v5_verification: {e}")
+            metrics.record_error("GeneratorAgent", "v5_citation_verify", str(e), severity="warning")
+
+        try:
+            if kruczkowski_trap_agent:
+                # Use the trap agent's check method if exposed; fallback to direct if available
+                trap_result = None
+                if hasattr(kruczkowski_trap_agent, "check_section_for_traps"):
+                    trap_result = kruczkowski_trap_agent.check_section_for_traps(section_content, program)
+                elif hasattr(kruczkowski_trap_agent, "detect_traps"):
+                    trap_result = kruczkowski_trap_agent.detect_traps(section_content, program)  # correct: (text, program, msp=None)
+                if isinstance(trap_result, dict):
+                    verification["traps"] = {
+                        "detected": trap_result.get("traps", [])[:5],
+                        "risk_level": trap_result.get("risk_level", "low")
+                    }
+                    verification["applied"] = True
+                    metrics.increment("generation.v5_verification_trap_runs", tags={"risk": verification["traps"]["risk_level"]})
+                    try:
+                        from core.telemetry import metrics as _m3
+                        tr = 0.6 if verification.get("traps", {}).get("risk_level") in ("high","critical") else 0.25
+                        _m3.record_kruczkowski_trap_rate(tr, {"via": "generator_agent"})
+                    except Exception:
+                        pass
+        except Exception as e:
+            logger.warning(f"[Generator v5.0] KruczkowskiTrap failed in _run_v5_verification: {e}")
+            metrics.record_error("GeneratorAgent", "v5_kruczkowski_verify", str(e), severity="warning")
+
+        return verification
+
+    def _section_critic_verdict(self, section_content: str, section_name: str, program_hint: str) -> Dict[str, Any]:
+        """
+        FAZA 5: Krytyk per-sekcja. Łączy weryfikację RegulationEngine
+        (CitationVerifier + Kruczkowski Trap) z twardymi walidacjami (regex),
+        zwracając werdykt sterujący regeneracją sekcji.
+
+        Zwraca dict: {passed: bool, score: int, reasons: list[str], verification: dict}.
+        """
+        import re as _re
+
+        verdict: Dict[str, Any] = {"passed": True, "score": 100, "reasons": [], "verification": {}}
+        content = section_content or ""
+        if len(content.strip()) < 30:
+            return verdict
+
+        verification = self._run_v5_verification(content, section_name, program_hint)
+        verdict["verification"] = verification
+
+        score = 100
+        reasons: list[str] = []
+
+        # 1) Pułapki Kruczkowskiego (koszty niekwalifikowalne / cross-financing / de minimis)
+        trap_risk = verification.get("traps", {}).get("risk_level", "low")
+        if trap_risk == "critical":
+            score -= 60
+            reasons.append("Krytyczne pułapki compliance (Kruczkowski).")
+            verdict["passed"] = False
+        elif trap_risk == "high":
+            score -= 40
+            reasons.append("Wysokie ryzyko pułapek compliance (Kruczkowski).")
+            verdict["passed"] = False
+
+        # 2) Nielogiczne ujemne kwoty budżetowe
+        if _re.search(r"(?i)(budżet|koszt|kwota|dofinansowanie)[\s=:]*-\s*\d+", content):
+            score -= 50
+            reasons.append("Wykryto ujemne kwoty budżetowe.")
+            verdict["passed"] = False
+
+        # 3) Kompletny brak wymaganych słów kluczowych programu
+        low = content.lower()
+        if len(low) > 120 and not _re.search(
+            r"(innowacj|przychód|b\+r|badani|rozwoj|dofinansowan|projekt|wskaźnik|harmonogram)", low
+        ):
+            score -= 40
+            reasons.append("Brak wymaganych słów kluczowych programu.")
+            verdict["passed"] = False
+
+        # 4) Niskie ugruntowanie cytowaniami (sygnał miękki — obniża score)
+        citation_score = verification.get("citation", {}).get("overall_score", 0.65)
+        if citation_score < 0.35:
+            score -= 15
+            reasons.append(f"Niskie ugruntowanie cytowaniami ({citation_score:.2f}).")
+
+        verdict["score"] = max(0, score)
+        verdict["reasons"] = reasons
+        return verdict
+
+    def plan_document(self, state: GeneratorState):
+        """Krok 1: Inicjalizuje sekcje w zależności od zadanego wzorca."""
+        logger.info(f"Planowanie dokumentu: {state['document_type']}")
+
+        from core.telemetry import telemetry
+
+        telemetry.log(
+            "INFO",
+            "GeneratorAgent",
+            f"Tworzę plan dokumentu typu {state['document_type']}",
+            {"project_id": state["project_id"]},
+        )
+
+        plan = state.get("sections_plan", [])
+        if not plan:
+            doc_type = state["document_type"].lower()
+            if "wniosek" in doc_type and "smart" in doc_type:
+                plan = [
+                    {"type": "project_summary", "title": "Opis projektu i jego celów"},
+                    {"type": "innovation", "title": "Uzasadnienie innowacyjności"},
+                    {"type": "applicant", "title": "Potencjał Wnioskodawcy (doświadczenie i zasoby)"},
+                    {"type": "budget", "title": "Budżet i harmonogram"},
+                ]
+            elif "biznesplan" in doc_type:
+                plan = [
+                    {
+                        "type": "executive_summary",
+                        "title": "Streszczenie projektu",
+                    },
+                    {"type": "product", "title": "Opis produktu/usługi"},
+                    {"type": "market", "title": "Analiza rynku i konkurencji"},
+                    {"type": "finance", "title": "Plan finansowy"},
+                ]
+            else:
+                plan = [
+                    {"type": "intro", "title": "Wprowadzenie"},
+                    {"type": "body", "title": "Rozwinięcie merytoryczne"},
+                    {"type": "outro", "title": "Zakończenie i podsumowanie"},
+                ]
+
+        return {
+            "sections_plan": plan,
+            "current_section_idx": state.get("current_section_idx", 0),
+            "generated_sections": state.get("generated_sections", {}),
+            "is_completed": False,
+            "missing_data_question": None,
+            "traceability_data": state.get("traceability_data", {}),
+            "section_stall_counts": state.get("section_stall_counts", {}),
+            "graph_step": state.get("graph_step", 0),
+        }
+
+    def _safe_truncate_context(self, text: str, max_chars: int = 12000, label: str = "context") -> str:
+        """Stability helper (v5.0): Hard cap on context to prevent token explosions + OOM in long docs.
+        Used across fetch + draft paths. Logs when truncation occurs for observability."""
+        if not text:
+            return ""
+        if len(text) <= max_chars:
+            return text
+        truncated = text[:max_chars] + f"\n\n[... UKRÓCONO dla stabilności (oryginał {len(text)} znaków, limit {max_chars} dla {label}) ...]"
+        logger.info(f"[Generator v5.0 stability] Truncated {label} from {len(text)} to {max_chars} chars")
+        metrics.increment("generation.context_truncations", tags={"label": label})
+        return truncated
+
+    def _regulation_context_present(self, state: GeneratorState, context: str = "") -> bool:
+        """Czy mamy twarde źródło regulaminu (snapshot / RAG / kontekst projektu)."""
+        ctx = context or state.get("context") or ""
+        if "[REGULATION SNAPSHOT" in ctx or "Kontekst regulaminowy" in ctx:
+            return True
+        if "Regulamin" in ctx:
+            return True
+        ext = state.get("external_context") or {}
+        if ext.get("regulation_snapshot_id") or ext.get("required_sections"):
+            return True
+        add = state.get("additional_context") or ""
+        return "Regulamin" in add or "regulation_snapshot" in add.lower()
+
+    def _build_regulation_boost(self, state: GeneratorState) -> str:
+        """Składa blok regulaminowy z snapshotów projektu (multi-doc aware)."""
+        try:
+            from core.search.regulation_snapshot import regulation_snapshot_store
+            from core.search.regulation_context_provider import (
+                _program_keys_for_candidate,
+                format_regulation_context_for_prompt,
+                get_regulation_context_for_candidates,
+            )
+
+            ext = state.get("external_context") or {}
+            doc_type = state.get("document_type", "") or ""
+            grant_stub = {
+                "id": ext.get("grant_id") or state.get("project_id"),
+                "program": ext.get("program_type") or doc_type,
+                "name": ext.get("grant_name") or ext.get("program_name") or doc_type,
+                "operator": ext.get("operator") or "",
+                "regulation_url": ext.get("regulation_url") or ext.get("precise_regulation_url"),
+                "regulation_urls": ext.get("regulation_urls") or [],
+            }
+
+            # 1) Snapshot przypisany do projektu (najwyższy priorytet)
+            snap_id = ext.get("regulation_snapshot_id")
+            if snap_id:
+                snap = regulation_snapshot_store.get_by_id(str(snap_id))
+                if snap and getattr(snap, "key_rules", None):
+                    rules_preview = "\n".join([f"- {r}" for r in (snap.key_rules or [])[:8]])
+                    return (
+                        f"\n\n[REGULATION SNAPSHOT v5.0 - PRZYPISANY REGULAMIN "
+                        f"(hash: {getattr(snap, 'version_hash', '?')})]:\n{rules_preview}\n"
+                    )
+
+            # 2) Multi-doc: zunifikowany kontekst (snapshots + URL-e z projektu)
+            reg_ctx = get_regulation_context_for_candidates(
+                [grant_stub],
+                project_description=state.get("project_description") or "",
+                namespace=state.get("namespace"),
+                k_per_grant=6,
+            )
+            grant_id = grant_stub.get("id")
+            items = reg_ctx.get(grant_id) or []
+            if items:
+                formatted = format_regulation_context_for_prompt(reg_ctx, grant_id=grant_id)
+                if formatted and "Brak kontekstu" not in formatted:
+                    return f"\n\n[REGULATION SNAPSHOT v5.0 - WIELE DOKUMENTÓW REGULAMINU]:\n{formatted}\n"
+
+            # 3) Fallback: pojedynczy snapshot po kluczu programu lub URL
+            snap = None
+            for key in _program_keys_for_candidate(grant_stub) + [doc_type]:
+                if not key:
+                    continue
+                snap = regulation_snapshot_store.get_latest_for_program(key)
+                if snap and getattr(snap, "key_rules", None):
+                    break
+            if not snap:
+                for url in ext.get("regulation_urls") or []:
+                    snap = regulation_snapshot_store.get_latest_by_source_url(url)
+                    if snap:
+                        break
+                if not snap and ext.get("regulation_url"):
+                    snap = regulation_snapshot_store.get_latest_by_source_url(ext["regulation_url"])
+
+            if snap and getattr(snap, "key_rules", None):
+                rules_preview = "\n".join([f"- {r}" for r in (snap.key_rules or [])[:6]])
+                return (
+                    f"\n\n[REGULATION SNAPSHOT v5.0 - KLUCZOWE REGUŁY DLA "
+                    f"{doc_type or 'programu'} (hash: {getattr(snap, 'version_hash', '?')})]:\n"
+                    f"{rules_preview}\n"
+                )
+        except Exception as reg_err:
+            logger.debug("[Generator] Regulation boost skipped: %s", reg_err)
+        return ""
+
+    def fetch_context(self, state: GeneratorState):
+        """Krok 2: Pobiera wycinki wiedzy z wejściowego RAG lub bazy aktów ISAP/PARP.
+        v5.0 evolution: + deep regulation snapshot + lightweight GraphRAG injection for better grounding."""
+        from core.telemetry import telemetry
+
+        idx = state.get("current_section_idx", 0)
+        sections = state.get("sections_plan", [])
+        if not sections or idx >= len(sections):
+            logger.error(f"[Generator] IndexError in fetch_context: idx={idx}, sections_plan length={len(sections)}")
+            return {"context": "Błąd: Brak planu sekcji."}
+        section = sections[idx]
+        section_name = section["title"] if isinstance(section, dict) else str(section)
+        namespace = state["namespace"]
+
+        patch: Dict[str, Any] = {}
+        stalls = state.get("section_stall_counts", {}) or {}
+        if stalls.get(str(idx), 0) >= 2 and state.get("missing_data_question"):
+            patch["missing_data_question"] = None
+            logger.warning(
+                f"[Generator] Czyszczenie zawieszonego pytania dla sekcji idx={idx} (anti-loop)."
+            )
+
+        telemetry.log(
+            "INFO",
+            "GeneratorAgent",
+            f"Przeszukuję bazę wektorową (Pinecone) dla sekcji: {section_name}",
+            {"namespace": namespace},
+        )
+        logger.info(
+            f"Pobieranie kontektu RAG dla sekcji '{section_name}' w namespace '{namespace}'."
+        )
+
+        try:
+            retriever = get_parent_document_retriever(namespace=namespace)
+            
+            # Wzbogacamy zapytanie o kontekst firmy aby system szukał trafniejszych fragmentów
+            project_context = state.get("project_description", "")
+            # Ograniczamy długość kontekstu do kluczowych informacji aby nie rozmyć zapytania
+            short_context = project_context[:300] if project_context else ""
+            
+            # Retrieval - szukamy najpierw specyfiki projektu w private_namespace
+            query = f"Regulamin i wytyczne dla sekcji: {section_name}. Typ dokumentu: {state['document_type']}. Kontekst i informacje do uwzględnienia (Kryteria, Budżet, Kwalifikowalność): {short_context}"
+            docs = retriever.invoke(query)
+            def _format_temporal(doc):
+                valid_from = doc.metadata.get("valid_from", "")
+                valid_to = doc.metadata.get("valid_to", "")
+                ver_id = doc.metadata.get("version_id", "")
+                time_str = ""
+                if valid_from or valid_to or ver_id:
+                    time_str = f" [Wersja: {ver_id}, Ważne od: {valid_from} do: {valid_to}]"
+                return f"{doc.page_content}{time_str}"
+
+            raw_context = "\n\n".join([_format_temporal(doc) for doc in docs])
+            
+            regulation_boost = self._build_regulation_boost(state)
+            context = self._safe_truncate_context(raw_context + regulation_boost, max_chars=11000, label="rag+regulation")
+            
+            import hashlib
+            from datetime import datetime
+            
+            traceability = state.get("traceability_data", {}) or {}
+            current_traces = []
+            
+            for doc in docs:
+                content_hash = hashlib.sha256(doc.page_content.encode('utf-8')).hexdigest()
+                current_traces.append({
+                    "source": doc.metadata.get("source", "Własny dokument / RAG"),
+                    "url": doc.metadata.get("url", "Brak linku"),
+                    "date": doc.metadata.get("fetch_date", datetime.now().strftime("%Y-%m-%d")),
+                    "hash": content_hash[:16],
+                    "version_id": doc.metadata.get("version_id", ""),
+                    "valid_from": doc.metadata.get("valid_from", ""),
+                    "valid_to": doc.metadata.get("valid_to", "")
+                })
+                
+            traceability[section_name] = current_traces
+            
+            if not context.strip():
+                context = "Brak specyficznego kontekstu wgranej dokumentacji w RAG dla tej sekcji."
+            telemetry.log(
+                "INFO",
+                "Pinecone",
+                f"Pobrano {len(docs)} fragmentów z wektorowej bazy danych.",
+            )
+        except Exception as e:
+            logger.error(f"Błąd RAG pod względem '{namespace}': {e}")
+            metrics.record_error("GeneratorAgent", "rag_fetch", str(e), severity="warning")
+            telemetry.log("ERROR", "Pinecone", f"Błąd pobierania wektorów: {str(e)}")
+            context = (
+                "Brak połączenia z RAG. Generowanie oparto na wiedzy ogólnej modelu."
+            )
+            traceability = state.get("traceability_data", {}) or {}
+
+        patch.update({
+            "context": context,
+            "traceability_data": traceability,
+            "graph_step": state.get("graph_step", 0) + 1,
+            "needs_holistic_regen": False,
+            "needs_audit_regen": False,
+        })
+        return patch
+
+    def draft_section(self, state: GeneratorState):
+        """Krok 3: Generowanie sekcji za pomocą LLM.
+
+        Pipeline RODO (FAZA 1 Enterprise):
+          1. Anonymizuj opis projektu (NIP, PESEL, IBAN, nazwiska → tokeny)
+          2. Wyślij zanonimizowany tekst do LLM
+          3. Deanonymizuj wynik (tokeny → oryginalne wartości)
+
+        Dzięki temu dane PII nigdy nie trafiają do zewnętrznych API LLM.
+        """
+        idx = state.get("current_section_idx", 0)
+        sections = state.get("sections_plan", [])
+        if not sections or idx >= len(sections):
+            logger.error(f"[Generator] IndexError in draft_section: idx={idx}, sections_plan length={len(sections)}")
+            metrics.record_error("GeneratorAgent", "draft_section_index", "index error in sections_plan", severity="error")
+            return {
+                "generated_sections": state.get("generated_sections", {}),
+                "is_completed": True,
+                "missing_data_question": None
+            }
+        section = sections[idx]
+        section_name = section["title"] if isinstance(section, dict) else str(section)
+        section_type = section.get("type") if isinstance(section, dict) else section_name.replace(" ", "_").lower()
+        context = state.get("context", "")
+        project_desc = state.get("project_description") or ""
+
+        # Brak snapshotu regulaminu — NIE wchodzimy w pętlę missing_data (główna przyczyna recursion_limit).
+        regulation_ok = self._regulation_context_present(state, context)
+        if not regulation_ok:
+            logger.warning(
+                f"[Generator] Brak twardego regulaminu dla '{section_name}' — generuję w trybie awaryjnym (bez blokady)."
+            )
+            try:
+                from agents.helpers import generate_section_light
+
+                section_content = generate_section_light(
+                    section_type=section_type,
+                    context=(context or "") + "\n" + (project_desc or ""),
+                    external_context={"program": state.get("document_type")},
+                    program_name=state.get("document_type", "dotacje"),
+                )
+                section_content = (
+                    "> *Uwaga: wygenerowano bez pełnego snapshotu regulaminu w RAG. "
+                    "Zalecane wgranie regulaminu do projektu.*\n\n"
+                    f"{section_content}"
+                )
+                current_sections = dict(state.get("generated_sections", {}))
+                current_sections[section_name] = section_content
+                next_idx = idx + 1
+                return {
+                    "generated_sections": current_sections,
+                    "current_section_idx": next_idx,
+                    "is_completed": next_idx >= len(sections),
+                    "missing_data_question": None,
+                    "graph_step": state.get("graph_step", 0) + 1,
+                    "section_stall_counts": state.get("section_stall_counts", {}),
+                }
+            except Exception as reg_fallback_err:
+                logger.error(
+                    f"[Generator] Awaryjny fallback bez regulaminu nieudany: {reg_fallback_err}"
+                )
+
+        # [FAZA 5 PRODUKCJA] — usunięto twardą blokadę pętli; kontynuujemy normalną ścieżkę LLM.
+        # ==============================================================================
+        # FAZA 1: Solidna Jakość Podstawowa – Basic Verification Guard przed generacją
+        # Stabilizuje generację: jeśli kontekst/granty mają niską jakość weryfikacji (Faza1 signals),
+        # dodajemy explicit warning do kontekstu + telemetry. Zapobiega halucynacjom na słabych danych.
+        # Używa data_quality_score / verification_level / regulation_grounded z pipeline search.
+        # ==============================================================================
+        try:
+            quality_notes = []
+            low_quality_count = 0
+            for line in (context or "").split("\n")[:30]:  # szybki scan metadanych w kontekście RAG
+                if "data_quality_score" in line.lower() or "verification_level" in line.lower():
+                    if "stale" in line.lower() or ("data_quality_score" in line.lower() and any(x in line for x in ["3", "4", "5"])):
+                        low_quality_count += 1
+            if low_quality_count >= 2:
+                quality_notes.append("[FAZA1-VERIFICATION-WARNING] Część kontekstu RAG ma niską jakość danych / verification_level=stale. Generacja będzie bardziej konserwatywna.")
+                metrics.increment("generator.verification_warnings", tags={"stage": "draft_section"})
+
+            if quality_notes:
+                context = "\n".join(quality_notes) + "\n\n" + context
+                logger.warning(f"[Generator][Faza1-Verif] Wstrzyknięto ostrzeżenia weryfikacyjne do kontekstu sekcji {section_name}")
+        except Exception:
+            pass  # never break generation on verification guard
+
+        # ── KROK 1: Anonymizuj opis projektu przed LLM ─────────────────────
+        anon_desc = project_desc
+        if anonymizer and project_desc:
+            try:
+                anon_desc = anonymizer.anonymize_text(project_desc)
+                if anon_desc != project_desc:
+                    logger.info(
+                        f"[Generator][PII] Opis projektu '{state['project_id']}' "
+                        f"zanonimizowany przed wysłaniem do LLM."
+                    )
+                    if audit_log:
+                        audit_log(
+                            "GENERATOR_PII_ANON",
+                            f"Projekt: {state['project_id']} | Sekcja: {section_name}",
+                        )
+            except Exception as e:
+                logger.warning(
+                    f"[Generator][PII] Anonimizacja nieudana: {e} — kontynuuję bez maskowania."
+                )
+                anon_desc = project_desc
+
+        from pydantic import BaseModel, Field
+        from core.telemetry import telemetry
+
+        class GeneratedSection(BaseModel):
+            content_markdown: Optional[str] = Field(
+                None,
+                description="Zredagowany tekst sekcji w formacie Markdown. ZAWSZE WYPEŁNIJ to pole, nawet jeśli brakuje danych (użyj znaczników [UZUPEŁNIĆ: co brakuje]). BEZWZGLĘDNIE PISZ TYLKO W JĘZYKU POLSKIM (włączając w to nagłówki i tytuły).",
+            )
+            reasoning_explanation: str = Field(
+                ...,
+                description="Zasada Explainable AI (XAI): Krótki, merytoryczny opis uzasadniający, z których wytycznych (RAG) skorzystałeś tworząc tekst, aby audytor wiedział dlaczego wygenerowano taki a nie inny fragment.",
+            )
+            missing_data_question: Optional[str] = Field(
+                None,
+                description="Jeśli brakuje Ci krytycznych danych, wpisz tu ostrzeżenie, ale i tak wygeneruj `content_markdown` ze znacznikami. BEZWZGLĘDNIE PISZ TYLKO W JĘZYKU POLSKIM.",
+            )
+
+        financial_keywords = ["budżet", "harmonogram", "finans", "koszt", "opłacalność", "wskaźniki"]
+        rnd_keywords = ["innowacj", "technolog", "badani", "przemysłow", "b+r", "b & r", "stan techniki", "trl"]
+        
+        assigned_role = "SUPERVISOR (Główny Koordynator)"
+        specialized_instructions = "TWOJA SPECJALIZACJA: Jesteś głównym koordynatorem wniosku. Zadbaj o spójność opisu firmy, potencjału zespołu, rynków docelowych i ogólnej logiki biznesowej projektu."
+        
+        if any(kw in section_name.lower() or kw in section_type.lower() for kw in financial_keywords):
+            assigned_role = "FINANCIAL AGENT (Ekspert ds. Finansów)"
+            specialized_instructions = "TWOJA SPECJALIZACJA: Jesteś głównym analitykiem finansowym. Skup się wyłącznie na liczbach, budżecie, rentowności, wkładzie własnym i wskaźnikach finansowych. Zwracaj ogromną uwagę na limity dofinansowania i zgodność matematyczną. Używaj tabel."
+        elif any(kw in section_name.lower() or kw in section_type.lower() for kw in rnd_keywords):
+            assigned_role = "R&D AGENT (Ekspert ds. Innowacji)"
+            specialized_instructions = "TWOJA SPECJALIZACJA: Jesteś głównym inżynierem i ekspertem B+R. Skup się na opisie technologii, przełomowości rozwiązania, poziomach gotowości technologicznej (TRL) oraz pracach badawczo-rozwojowych. Używaj języka technicznego i naukowego."
+
+        system_prompt = (
+            f"Jesteś profesjonalnym doradcą dotacyjnym i pełnisz rolę: {assigned_role}.\n"
+            f"{specialized_instructions}\n"
+            "Odpowiadasz za najwyższą korporacyjną jakość we wnioskach dotacyjnych.\n"
+            f"Mamy dokument typu: '{state['document_type']}'.\n"
+            f"Obecnie przygotowujesz dokładnie i wyczerpująco sekcję: '{section_name}'.\n\n"
+            "Wytyczne:\n"
+            " - [ANTI-HALLUCINATION]: Wykorzystuj WYŁĄCZNIE dostarczony Kontekst RAG (fragmenty regulaminów i wytycznych programu). Masz absolutny zakaz wymyślania reguł prawnych i finansowych.\n"
+            " - [CITATION REQUIREMENT]: Kategorycznie WYMAGANE jest umieszczanie w tekście przypisów w nawiasach kwadratowych, gdy powołujesz się na warunki programu (np. limit kwotowy, warunek innowacyjności). Format: `[Źródło: Nazwa Regulaminu/Dokumentu, sekcja/strona]` oparty na metadanych RAG. Wnioski pozbawione precyzyjnych cytowań z podaniem paragrafu będą surowo odrzucane przez recenzenta!\n"
+            " - [XAI - Explainable AI]: Twoje decyzje narracyjne muszą być krótko uzasadnione w polu 'reasoning_explanation' dla pełnej przejrzystości audytowej.\n"
+            " - Zadbaj o analityczny, sformalizowany ton z punktami i statystykami gdzie to możliwe.\n"
+            " - STOSUJ BOGATE FORMATOWANIE MARKDOWN: używaj profesjonalnych nagłówków (###, ####), tabel dla danych liczbowych, list punktowanych i pogrubień (bold) dla kluczowych wskaźników. Dokument ma wyglądać nieskazitelnie, czytelnie i estetycznie!\n"
+            " - Jeżeli w zanonimizowanym opisie projektu znajduje się nazwa firmy lub jej token (np. <FIRMA_1>), BEZWZGLĘDNIE i NATURALNIE wplataj go w treść sekcji.\n"
+            " - Jeżeli napotkasz tokeny anonimizacji typu <NIP_1>, <OSOBA_1>, UŻYJ ICH dosłownie.\n"
+            f" - {SAFE_MODE_GENERATOR_RULE}\n"
+            " - >>> BEZWZGLĘDNIE GENERUJ CAŁĄ TREŚĆ WYŁĄCZNIE W JĘZYKU POLSKIM. <<<\n"
+            " - ZABRANIA SIĘ używania słów w języku angielskim. Wszystkie nagłówki, tabele, teksty i podsumowania MUSZĄ być po polsku.\n"
+            " - NIGDY NIE ZWRACAJ ANGIELSKICH TYTUŁÓW SEKCJI. Masz kategoryczny nakaz użycia oryginalnego, polskiego tytułu sekcji, nad którym pracujesz.\n"
+            " - ZADBÓJ O ZWIĘZŁOŚĆ NAGŁÓWKÓW: Ogranicz długość nagłówków/tytułów sekcji do maksymalnie 5 wyrazów.\n"
+            " - W PRZYPADKU ODPOWIEDZI UŻYTKOWNIKA NA 'missing_data_question': Pamiętaj, aby ZACHOWAĆ dotychczasowy styl sekcji i wpleść nowe informacje spójnie.\n"
+            " - ZACHOWAJ SPÓJNOŚĆ LOGICZNĄ z poprzednimi sekcjami. Jeśli w poprzednich sekcjach opisano już szczegóły projektu (cele, grupę docelową), odwołuj się do nich spójnie i nie twórz sprzecznych informacji.\n"
+            " - Płynnie nawiązuj do poprzednio wygenerowanych sekcji dokumentu, by wniosek tworzył jedną logiczną i czytelną całość.\n"
+            " - [AUTOPILOT]: Jeśli NIP, nazwa firmy lub adres siedziby są już dostępne w opisie projektu lub kontekście GUS/KRS, NIE zadawaj pytań o brakujące dane dotyczące tych pól — wykorzystaj je bezpośrednio w treści sekcji.\n"
+        )
+
+        additional_context = state.get("additional_context", "")
+        
+        # Odtworzenie poprzednich sekcji dla kontekstu i spójności
+        previously_generated = ""
+        generated_sections = state.get("generated_sections", {})
+        if generated_sections:
+            previously_generated = "--- Poprzednie wygenerowane sekcje dokumentu (dla spójności) ---\n"
+            for s_name, s_content in generated_sections.items():
+                truncated_content = s_content[:1500] + ("..." if len(s_content) > 1500 else "")
+                previously_generated += f"\n### Sekcja: {s_name}\n{truncated_content}\n"
+            previously_generated += "\n--- Koniec poprzednich sekcji ---\n\n"
+
+        # v5.0 stability: truncate all inputs to LLM to protect against runaway context
+        safe_context = self._safe_truncate_context(context, max_chars=9000, label="draft_context")
+        safe_anon = self._safe_truncate_context(anon_desc or "", max_chars=4000, label="project_desc")
+        # additional_context niesie strukturalny blok ProjectContext (dane wnioskodawcy
+        # jako źródło prawdy, do ~6000 zn.) + ewentualny blackboard — nie obcinamy go
+        # agresywnie do 2500, by nie utracić ugruntowanych danych firmy.
+        safe_addl = self._safe_truncate_context(additional_context or "", max_chars=8000, label="grounded_context")
+        safe_prev = self._safe_truncate_context(previously_generated, max_chars=8000, label="previous_sections")
+
+        human_content = ""
+        if safe_prev:
+            human_content += f"{safe_prev}\n"
+        human_content += f"Kontekst RAG:\n{safe_context}"
+        if safe_anon:
+            human_content += f"\n\nOpis projektu (zanonimizowany):\n{safe_anon}"
+        if safe_addl:
+            human_content += (
+                f"\n\nDodatkowe odpowiedzi od użytkownika:\n{safe_addl}"
+            )
+
+        telemetry.log(
+            "INFO",
+            "GeneratorAgent",
+            "Rozpoczynam draftowanie sekcji",
+            {"project_id": state["project_id"], "section": section_name},
+        )
+        logger.info(
+            f"[Generator] Draftowanie sekcji: '{section_name}' (projekt: {state['project_id']})"
+        )
+
+        # ── KROK 2: Wywołanie LLM z walidacją schematu i anty-halucynacją ─────
+        def _generate(attempt: int = 1):
+            current_system_prompt = system_prompt
+            if attempt > 1:
+                current_system_prompt += (
+                    "\n\nUWAGA: POPRZEDNIA PRÓBA NIE POWIODŁA SIĘ."
+                    "\nZamiast zmyślać liczby, używaj WYŁĄCZNIE markerów w formacie "
+                    "[DO WERYFIKACJI: opis brakującej danej], np. "
+                    "[DO WERYFIKACJI: kwota inwestycji w PLN] lub [DO WERYFIKACJI: liczba pracowników]."
+                    "\nTwórz KONKRETNĄ treść (merytoryczny opis), używając tych markerów na brakujące liczby."
+                )
+                if section_type in ("budget", "finance"):
+                    current_system_prompt += (
+                        "\n\nSEKCJA BUDŻETOWA/FINANSOWA — SZCZEGÓLNA OSTROŻNOŚĆ:"
+                        "\nNIE wymyślaj kwot, stawek, procentów dofinansowania ani sum. Zachowaj wszystkie"
+                        " kwoty i pozycje kosztowe z poprzedniej wersji, jeśli były poprawne."
+                        " Brakujące wartości oznaczaj markerem [DO WERYFIKACJI: ...]."
+                        " Zadbaj o kwalifikowalność kosztów i brak podwójnego finansowania / cross-financingu."
+                    )
+
+            user_id = state.get("namespace", "").replace("tenant_", "") if "tenant_" in state.get("namespace", "") else "anonymous"
+            tracking_callback = TokenTrackingCallback(user_id=user_id)
+
+            try:
+                structured_llm = get_llm(
+                    task_type="critical", 
+                    structured_output_schema=GeneratedSection,
+                    callbacks=[tracking_callback]
+                )
+                response = structured_llm.invoke(
+                    [
+                        SystemMessage(content=current_system_prompt),
+                        HumanMessage(content=human_content),
+                    ]
+                )
+
+                if response.missing_data_question:
+                    telemetry.log(
+                        "WARN",
+                        "GeneratorAgent",
+                        "Wykryto brak danych, ale generowanie jest kontynuowane.",
+                        {"question": response.missing_data_question},
+                    )
+
+                section_content_temp = response.content_markdown or ""
+                if not section_content_temp and response.missing_data_question:
+                    section_content_temp = f"**Brakujące dane:** {response.missing_data_question}\n\n*Proszę uzupełnić tę sekcję ręcznie lub podać wymagane informacje w opisie projektu.*"
+                else:
+                    section_content_temp = extract_markdown_and_sanitize(
+                        section_content_temp
+                    )
+
+                if hasattr(response, "reasoning_explanation") and response.reasoning_explanation:
+                    # XAI trafia do logu/telemetrii — NIE do treści wniosku (czysta treść PL).
+                    logger.info(f"[XAI Reasoning] {response.reasoning_explanation}")
+
+                return section_content_temp, response.missing_data_question
+            except Exception as e:
+                logger.warning(
+                    f"[Generator] with_structured_output failed for '{section_name}': {e}. Attempting fallback without structured output."
+                )
+                
+                fallback_llm = get_llm(task_type="critical", callbacks=[tracking_callback])
+                
+                fallback_response = fallback_llm.invoke(
+                    [
+                        SystemMessage(
+                            content=current_system_prompt
+                            + "\nZwróć TYLKO treść sekcji w formacie Markdown (bez pytań o brakujące dane, spróbuj sobie poradzić). "
+                            "Twórz konkretny tekst; brakujące dane oznaczaj WYŁĄCZNIE markerem w formacie "
+                            "[DO WERYFIKACJI: opis danej], np. [DO WERYFIKACJI: kwota dofinansowania w PLN]. "
+                            "BEZWZGLĘDNIE PISZ TYLKO W JĘZYKU POLSKIM."
+                        ),
+                        HumanMessage(content=human_content),
+                    ]
+                )
+                section_content_temp = (
+                    fallback_response.content
+                    if hasattr(fallback_response, "content")
+                    else str(fallback_response)
+                )
+                section_content_temp = extract_markdown_and_sanitize(section_content_temp)
+                return section_content_temp, None
+
+        try:
+            # INTEGRACJA: Faza 4 - Moduł Analityka Finansowego
+            if section_type in ["budget", "finance"]:
+                try:
+                    from backend.agents.finance_agent import finance_agent
+                except ImportError:
+                    from agents.finance_agent import finance_agent
+                
+                logger.info(f"[Generator] Delegowanie sekcji '{section_name}' do Agenta Finansowego.")
+                section_content, missing_question = finance_agent.draft_financial_section(
+                    document_type=state['document_type'],
+                    section_name=section_name,
+                    project_desc=anon_desc,
+                    context=context
+                )
+            else:
+                section_content, missing_question = _generate()
+        except Exception as e_fallback:
+            logger.error(
+                f"[Generator] Fallback LLM failure for section '{section_name}': {e_fallback}"
+            )
+            telemetry.log(
+                "ERROR",
+                "GeneratorAgent",
+                "Błąd LLM podczas generowania",
+                {"error": str(e_fallback)},
+            )
+            # Faza 0/3 v5.0 reliable generation: use generate_section_light as hard fallback (never lose progress)
+            try:
+                from agents.helpers import generate_section_light
+                section_content = generate_section_light(
+                    section_type=section_name,
+                    context=context or project_desc,
+                    external_context={"company_data": {}},
+                    program_name=state.get("document_type", "dotacje")
+                )
+                section_content = f"{section_content}\n\n*[Wygenerowano w trybie awaryjnym light + resume checkpoint zachowany]*"
+            except Exception:
+                section_content = (
+                    f"*(Wystąpił błąd API podczas generowania sekcji: {str(e_fallback)})*\n\n"
+                    "[UZUPEŁNIĆ: Sekcja wymaga ręcznego uzupełnienia. Autopilot checkpoint pozwala wznowić.]"
+                )
+            missing_question = None
+
+        # ── KROK 3: Deanonymizuj wynik (tokeny → oryginalne wartości) ────
+        if anonymizer and project_desc and anon_desc != project_desc:
+            try:
+                section_content = anonymizer.deanonymize_text(section_content)
+                logger.info(
+                    f"[Generator][PII] Sekcja '{section_name}' deanonimizowana po LLM."
+                )
+            except Exception as e:
+                logger.warning(
+                    f"[Generator][PII] Deanonymizacja nieudana: {e} — zwracam zanonimizowaną wersję."
+                )
+
+        program_hint = state.get("document_type", "") or ""
+
+        # ── FAZA 5: Section-level Critic (realnie wpływa na regenerację) ──────
+        # Krytyk per-sekcja (RegulationEngine + twarde walidacje). Sekcja, która nie
+        # przejdzie bramki, jest jednorazowo regenerowana ze wzmocnionym promptem
+        # (bounded: 1 próba/sekcja), a lepszy wariant zastępuje pierwotny.
+        critic_retries = dict(state.get("section_critic_retries", {}) or {})
+        verdict: Dict[str, Any] = {"passed": True, "score": 100, "reasons": [], "verification": {}}
+        try:
+            already_retried = critic_retries.get(str(idx), 0) >= 1
+            verdict = self._section_critic_verdict(section_content, section_name, program_hint)
+            # P3#16: sekcje budget/finance TEŻ mogą być regenerowane przez krytyka
+            # (z ostrożniejszym promptem w _generate) — tam błędy są najgroźniejsze.
+            if (
+                not verdict["passed"]
+                and not already_retried
+            ):
+                logger.warning(
+                    f"[Generator][SectionCritic] Sekcja '{section_name}' odrzucona przez krytyka: "
+                    f"{verdict['reasons']} (score={verdict['score']}) — regeneruję."
+                )
+                metrics.increment("generation.section_critic_regeneration", tags={"section": section_name})
+                critic_retries[str(idx)] = critic_retries.get(str(idx), 0) + 1
+                try:
+                    regen_content, regen_q = _generate(attempt=2)
+                    if anonymizer and project_desc and anon_desc != project_desc:
+                        try:
+                            regen_content = anonymizer.deanonymize_text(regen_content)
+                        except Exception:
+                            pass
+                    regen_verdict = self._section_critic_verdict(regen_content, section_name, program_hint)
+                    # Zastąp, jeśli regeneracja jest co najmniej równie dobra (mniej pułapek/lepszy score)
+                    if regen_content and regen_verdict["score"] >= verdict["score"]:
+                        section_content = regen_content
+                        verdict = regen_verdict
+                        if regen_q and not missing_question:
+                            missing_question = regen_q
+                        logger.info(
+                            f"[Generator][SectionCritic] Regeneracja przyjęta dla '{section_name}' "
+                            f"(nowy score={regen_verdict['score']}, passed={regen_verdict['passed']})."
+                        )
+                except Exception as regen_e:
+                    logger.warning(f"[Generator][SectionCritic] Regeneracja nieudana (non-fatal): {regen_e}")
+            # Zapisz werdykt krytyka do traceability
+            crit_trace = state.get("traceability_data", {}) or {}
+            crit_trace.setdefault(section_name, [])
+            if isinstance(crit_trace.get(section_name), list):
+                crit_trace[section_name].append({
+                    "type": "section_critic",
+                    "timestamp": time.time(),
+                    "data": {"passed": verdict["passed"], "score": verdict["score"], "reasons": verdict["reasons"]},
+                })
+                state["traceability_data"] = crit_trace
+        except Exception as crit_e:
+            logger.warning(f"[Generator][SectionCritic] Bramka krytyka pominięta (non-fatal): {crit_e}")
+
+        # ── v5.0 Faza 3/4: Proactive Verification Integration (inside generation) ──
+        # P3#14: reużywamy weryfikacji policzonej już przez _section_critic_verdict
+        # (koniec z podwójnym liczeniem CitationVerifier/Kruczkowski). Wszystkie noty
+        # techniczne trafiają WYŁĄCZNIE do traceability — treść wniosku pozostaje czysta.
+        try:
+            v5_verif = verdict.get("verification") or {}
+            if not v5_verif:
+                v5_verif = self._run_v5_verification(section_content, section_name, program_hint)
+            verifiers_available = bool(citation_verifier or kruczkowski_trap_agent)
+            traceability = state.get("traceability_data", {}) or {}
+            if section_name not in traceability or not isinstance(traceability.get(section_name), list):
+                base = traceability.get(section_name)
+                traceability[section_name] = [base] if base else []
+
+            if v5_verif.get("applied"):
+                ver_score = v5_verif.get("citation", {}).get("overall_score", 0.0)
+                trap_count = len(v5_verif.get("traps", {}).get("detected", []))
+                traceability[section_name].append({
+                    "type": "v5_verification",
+                    "timestamp": time.time(),
+                    "data": v5_verif
+                })
+                logger.info(f"[Generator v5.0] Verification recorded for '{section_name}': score={ver_score:.2f}, traps={trap_count}")
+                metrics.increment("generation.v5_sections_verified")
+            else:
+                # P3#11: CICHY NO-OP — weryfikatory niedostępne LUB nie zaaplikowane.
+                # NIE przepuszczamy sekcji po cichu: oznaczamy ją jako NIEZWERYFIKOWANĄ
+                # i wymuszamy human review + metrykę krytyczną.
+                if not verifiers_available:
+                    logger.error(
+                        f"[Generator v5.0] Weryfikatory (RegulationEngine) niedostępne — "
+                        f"sekcja '{section_name}' NIEZWERYFIKOWANA. Wymuszam human review."
+                    )
+                    metrics.increment("generation.v5_verification_unavailable", tags={"section": section_name})
+                    unverified = dict(state.get("unverified_sections", {}) or {})
+                    unverified[section_name] = "verifiers_unavailable"
+                    state["unverified_sections"] = unverified
+                    state["human_review_required"] = True
+                traceability[section_name].append({
+                    "type": "v5_verification_skipped",
+                    "timestamp": time.time(),
+                    "data": {"applied": False, "verifiers_available": verifiers_available},
+                })
+            state["traceability_data"] = traceability
+        except Exception as e:
+            logger.warning(f"[Generator v5.0] Verification integration error (non-fatal): {e}")
+            metrics.record_error("GeneratorAgent", "v5_verif_attach", str(e), severity="warning")
+
+        # ── FAZA 3: Jedna spójna bramka gap/placeholder (twarda bramka jakości) ──
+        # Skanuje WYGENEROWANĄ treść pod kątem placeholderów ([DO WERYFIKACJI: ...],
+        # [UZUPEŁNIJ: ...], [BRAK DANYCH ...] itp.), próbuje je uzupełnić przez
+        # Auto-Fill Agenta (rejestry + research), a krytyczne, nierozwiązane luki
+        # eskaluje do bramki HITL (missing_data_question).
+        try:
+            from agents.autofill_agent import autofill_agent
+
+            if autofill_agent.detect_placeholders(section_content):
+                fill_ctx = (additional_context or "") + "\n" + (project_desc or "")
+                af = autofill_agent.autofill_content(
+                    section_content,
+                    known_facts=state.get("project_context_facts") or None,
+                    extra_context=fill_ctx,
+                    allow_research=True,
+                )
+                if af.resolved:
+                    section_content = af.filled_content
+                    logger.info(
+                        f"[Generator][AutoFill] Uzupełniono {len(af.resolved)} placeholderów w sekcji '{section_name}'"
+                    )
+                    metrics.increment("generation.autofill_resolved", tags={"section": section_name})
+                if af.unresolved:
+                    metrics.increment("generation.autofill_unresolved", tags={"section": section_name})
+                    critical_unresolved = [
+                        p for p in af.unresolved
+                        if autofill_agent._is_critical(autofill_agent._placeholder_label(p))
+                    ]
+                    if critical_unresolved and not missing_question:
+                        missing_question = af.hitl_question
+                        logger.warning(
+                            f"[Generator][AutoFill] Krytyczne luki w sekcji '{section_name}' "
+                            f"— eskalacja do HITL: {af.hitl_question}"
+                        )
+        except Exception as e:
+            logger.warning(f"[Generator][AutoFill] Bramka placeholderów pominięta (non-fatal): {e}")
+
+        # ── Aktualizacja stanu ────────────────────────────────────────────
+        current_sections = dict(state.get("generated_sections", {}))
+        current_sections[section_name] = section_content
+
+        if missing_question:
+            full_ctx_check = (project_desc or "") + "\n" + (additional_context or "")
+            if _company_fields_satisfy(missing_question.lower(), full_ctx_check):
+                missing_question = None
+
+        stall_counts = dict(state.get("section_stall_counts", {}))
+        if missing_question:
+            stall_key = str(idx)
+            stall_counts[stall_key] = stall_counts.get(stall_key, 0) + 1
+            if stall_counts[stall_key] >= 2:
+                logger.warning(
+                    f"[Generator] Przerwanie pętli brakujących danych dla sekcji '{section_name}'"
+                )
+                missing_question = None
+                if not section_content or len(section_content.strip()) < 20:
+                    section_content = (
+                        f"### {section_name}\n\n"
+                        f"[UZUPEŁNIĆ: brak danych wejściowych — sekcja wymaga ręcznego uzupełnienia.]"
+                    )
+                current_sections[section_name] = section_content
+
+        if missing_question:
+            next_idx = idx
+            is_completed = False
+        else:
+            next_idx = idx + 1
+            is_completed = next_idx >= len(state["sections_plan"])
+
+        telemetry.log(
+            "INFO",
+            "GeneratorAgent",
+            "Zakończono draftowanie sekcji",
+            {"project_id": state["project_id"], "section": section_name},
+        )
+
+        return {
+            "generated_sections": current_sections,
+            "current_section_idx": next_idx,
+            "is_completed": is_completed,
+            "missing_data_question": missing_question,
+            "section_stall_counts": stall_counts,
+            "section_critic_retries": critic_retries,
+            "traceability_data": state.get("traceability_data", {}),
+            "graph_step": state.get("graph_step", 0) + 1,
+        }
+
+    def _build_full_document_markdown(self, state: GeneratorState) -> str:
+        from core.document_builder import DocumentBuilder
+
+        return DocumentBuilder.build_markdown(
+            sections_plan=state.get("sections_plan", []),
+            generated_sections=state.get("generated_sections", {}),
+            document_type=state.get("document_type", ""),
+            traceability_data=state.get("traceability_data", {}),
+        )
+
+    def _route_after_pre_submission_audit(self, state: GeneratorState) -> str:
+        # Full autopilot: nie zatrzymuj na HITL przy guard_block — kontynuuj pipeline
+        # (krytyk globalny + audyt panelowy + zapis final_document z flagami w DB).
+        if state.get("guard_block") and not state.get("full_autopilot"):
+            return "review"
+        if not state.get("is_completed", True):
+            return "retry"
+        if state.get("full_autopilot"):
+            if not state.get("holistic_phase_complete"):
+                return "holistic"
+            if not state.get("panel_audit_done"):
+                return "panel"
+        return "end"
+
+    def _route_after_holistic_review(self, state: GeneratorState) -> str:
+        if state.get("guard_block") and not state.get("full_autopilot"):
+            return "review"
+        if state.get("needs_holistic_regen"):
+            return "regen"
+        return "panel"
+
+    def _route_after_panel_audit(self, state: GeneratorState) -> str:
+        if state.get("needs_audit_regen"):
+            return "regen"
+        if state.get("guard_block") and not state.get("full_autopilot"):
+            return "review"
+        return "end"
+
+    def global_holistic_review(self, state: GeneratorState):
+        """Faza krytyka globalnego (Holistic Critic) z auto-korektą (bounded retries)."""
+        logger.info(f"[Generator][FullAutopilot] Holistic Critic dla projektu {state['project_id']}")
+        full_md = self._build_full_document_markdown(state)
+        program = state.get("document_type", "Nieznany program")
+        holistic_retries = int(state.get("holistic_retries") or 0)
+
+        try:
+            from agents.holistic_critic import holistic_critic_evaluate
+
+            report = holistic_critic_evaluate(state["project_id"], full_md, program)
+            report_dump = report.model_dump() if hasattr(report, "model_dump") else report.dict()
+        except Exception as e:
+            logger.error(f"[Generator][FullAutopilot] Holistic Critic error: {e}")
+            report_dump = {
+                "is_approved": False,
+                "overall_score": 0,
+                "key_recommendations": [f"Błąd krytyka globalnego: {str(e)[:120]}"],
+            }
+            report = type("_HolisticFallback", (), report_dump)()
+
+        traceability = state.get("traceability_data", {}) or {}
+        traceability["holistic_review"] = [report_dump]
+
+        if not getattr(report, "is_approved", False) and holistic_retries < MAX_HOLISTIC_RETRIES:
+            feedback = "=== KOREKTA WG KRYTYKA GLOBALNEGO (Holistic Critic) ===\n"
+            for rec in getattr(report, "key_recommendations", []) or []:
+                feedback += f"- {rec}\n"
+            for cat_name in ("budget_consistency", "logical_flow", "program_alignment", "dnsh_assessment"):
+                cat = getattr(report, cat_name, None)
+                if cat and hasattr(cat, "feedback") and cat.feedback:
+                    feedback += f"\n[{cat_name}] {cat.feedback}\n"
+            logger.info(
+                f"[Generator][FullAutopilot] Holistic niezaliczony — auto-korekta {holistic_retries + 1}/{MAX_HOLISTIC_RETRIES}"
+            )
+            return {
+                "traceability_data": traceability,
+                "additional_context": (state.get("additional_context") or "") + "\n\n" + feedback,
+                "needs_holistic_regen": True,
+                "is_completed": False,
+                "current_section_idx": 0,
+                "generated_sections": {},
+                "holistic_retries": holistic_retries + 1,
+                "pipeline_phase": "holistic_correction",
+            }
+
+        return {
+            "traceability_data": traceability,
+            "needs_holistic_regen": False,
+            "holistic_phase_complete": True,
+            "pipeline_phase": "panel_audit",
+        }
+
+    def global_panel_audit(self, state: GeneratorState):
+        """Faza audytora panelowego (GlobalAuditOutput) z auto-poprawką sekcji."""
+        logger.info(f"[Generator][FullAutopilot] Panel Audit dla projektu {state['project_id']}")
+        full_md = self._build_full_document_markdown(state)
+        program = state.get("document_type", "Nieznany program")
+        panel_retries = int(state.get("panel_audit_retries") or 0)
+
+        try:
+            from agents.auditor import audit_final_document
+
+            result = audit_final_document(
+                project_id=state["project_id"],
+                program_name=program,
+                content=full_md,
+                enable_multi_perspective=True,
+                light_mode=False,
+            )
+            audit_dump = result.model_dump() if hasattr(result, "model_dump") else result.dict()
+        except Exception as e:
+            logger.error(f"[Generator][FullAutopilot] Panel audit error: {e}")
+            audit_dump = {
+                "is_approved": False,
+                "export_status": "blocked",
+                "human_review_required": True,
+                "overall_score": 0,
+                "issues": [],
+                "xai_justification": f"Awaria audytu panelowego: {str(e)[:200]}",
+            }
+            result = type("_PanelFallback", (), audit_dump)()
+
+        traceability = state.get("traceability_data", {}) or {}
+        traceability["global_panel_audit"] = [audit_dump]
+
+        export_status = getattr(result, "export_status", None) or audit_dump.get("export_status", "blocked")
+        is_approved = getattr(result, "is_approved", False)
+        issues = getattr(result, "issues", None) or audit_dump.get("issues", [])
+
+        needs_fix = (
+            panel_retries < MAX_PANEL_AUDIT_RETRIES
+            and (export_status != "ok" or not is_approved)
+            and issues
+        )
+
+        if needs_fix:
+            feedback = "=== KOREKTA WG AUDYTORA PANELOWEGO ===\n"
+            for issue in issues[:15]:
+                if isinstance(issue, dict):
+                    feedback += (
+                        f"- [{issue.get('severity', '?')}] {issue.get('affected_section', 'Ogólne')}: "
+                        f"{issue.get('message', '')}\n  Rek: {issue.get('recommendation', '')}\n"
+                    )
+                else:
+                    feedback += (
+                        f"- [{getattr(issue, 'severity', '?')}] {getattr(issue, 'affected_section', 'Ogólne')}: "
+                        f"{getattr(issue, 'message', '')}\n  Rek: {getattr(issue, 'recommendation', '')}\n"
+                    )
+            logger.info(
+                f"[Generator][FullAutopilot] Audyt wymaga korekty — auto-poprawka {panel_retries + 1}/{MAX_PANEL_AUDIT_RETRIES}"
+            )
+            return {
+                "traceability_data": traceability,
+                "additional_context": (state.get("additional_context") or "") + "\n\n" + feedback,
+                "needs_audit_regen": True,
+                "is_completed": False,
+                "current_section_idx": 0,
+                "generated_sections": {},
+                "panel_audit_retries": panel_retries + 1,
+                "pipeline_phase": "audit_correction",
+                "global_audit_result": audit_dump,
+            }
+
+        guard_block = export_status == "blocked"
+        human_review = bool(getattr(result, "human_review_required", False))
+        if export_status == "warning" or (not is_approved and export_status != "blocked"):
+            human_review = human_review or bool(issues)
+        elif guard_block:
+            human_review = True
+
+        if guard_block and panel_retries >= MAX_PANEL_AUDIT_RETRIES:
+            traceability["final_audit_verdict"] = [{
+                "passed": False,
+                "score": getattr(result, "overall_score", 0),
+                "human_review_required": True,
+                "reason": "Audyt panelowy niezaliczony po wyczerpaniu prób auto-poprawy.",
+            }]
+
+        return {
+            "traceability_data": traceability,
+            "needs_audit_regen": False,
+            "panel_audit_done": True,
+            "pipeline_phase": "completed",
+            "guard_block": guard_block,
+            "human_review_required": human_review,
+            "global_audit_result": audit_dump,
+            "is_completed": True,
+        }
+
+    def pre_submission_audit(self, state: GeneratorState):
+        """Faza 14: Finalny audyt gotowego wniosku przed eksportem."""
+        logger.info(f"[Generator] Uruchamiam Red Team Audit dla projektu {state['project_id']}")
+        try:
+            from agents.red_team_auditor import RedTeamAuditor
+            auditor = RedTeamAuditor()
+            audit_result = auditor.audit_application(
+                state.get("generated_sections", {}),
+                state.get("context", ""),
+                state.get("document_type", "Nieznany program")
+            )
+            
+            traceability = state.get("traceability_data", {}) or {}
+            traceability["final_audit"] = [audit_result]
+            
+            logger.info(f"[Generator] Audyt zakończony. Passed: {audit_result.get('passed')}, Score: {audit_result.get('score')}")
+            
+            audit_retries = state.get("audit_retries", 0)
+            
+            # Autopilot retry loop
+            if not audit_result.get("passed") and audit_retries < 1:
+                logger.info(f"[Generator] Audyt niezaliczony. Auto-poprawa (retry {audit_retries+1}/1).")
+                
+                feedback = "Wyniki audytu Red Team do uwzględnienia w poprawkach:\n"
+                feedback += "Słabe punkty:\n"
+                for w in audit_result.get("weaknesses", []):
+                    feedback += f"- {w}\n"
+                feedback += "\nRekomendacje (Feedback):\n"
+                feedback += f"{audit_result.get('feedback', '')}\n"
+                
+                new_context = (state.get("additional_context") or "") + "\n\n" + feedback
+                
+                return {
+                    "traceability_data": traceability,
+                    "is_completed": False,
+                    "current_section_idx": 0,
+                    "audit_retries": audit_retries + 1,
+                    "additional_context": new_context
+                }
+
+            # P1: po wyczerpaniu retry, jeśli audyt nadal NIE przeszedł — ustaw TRWAŁY
+            # sygnał blokady/human_review (fail-closed), zamiast po cichu kończyć.
+            if not audit_result.get("passed"):
+                logger.warning(
+                    f"[Generator] Audyt niezaliczony po wyczerpaniu retry — blokada eksportu / human review."
+                )
+                traceability["final_audit_verdict"] = [{
+                    "passed": False,
+                    "score": audit_result.get("score"),
+                    "human_review_required": True,
+                    "reason": "Red Team Audit niezaliczony po wyczerpaniu prób auto-poprawy.",
+                }]
+                return {
+                    "traceability_data": traceability,
+                    "guard_block": True,
+                    "human_review_required": True,
+                }
+
+            return {
+                "traceability_data": traceability
+            }
+            
+        except Exception as e:
+            # FAIL-CLOSED: awaria audytu nie może cicho przepuścić wniosku do eksportu.
+            logger.error(f"[Generator] Błąd audytu pre-submission: {e}")
+            traceability = state.get("traceability_data", {}) or {}
+            traceability["final_audit_verdict"] = [{
+                "passed": False,
+                "human_review_required": True,
+                "reason": f"Awaria mechanizmu audytu końcowego: {str(e)[:200]} (fail-closed).",
+            }]
+            return {
+                "traceability_data": traceability,
+                "guard_block": True,
+                "human_review_required": True,
+            }
+
+    def _should_continue(self, state: GeneratorState):
+        """Sprawdzak czy istnieją kolejne sekcje do procedowania w Grafie."""
+        plan_len = len(state.get("sections_plan", []))
+        graph_step = state.get("graph_step", 0)
+        max_steps = max(30, plan_len * 6)
+        if graph_step >= max_steps:
+            logger.error(
+                f"[Generator] Osiągnięto limit kroków grafu ({graph_step}/{max_steps}) — wymuszam audyt końcowy."
+            )
+            return "audit"
+
+        if state.get("missing_data_question"):
+            stalls = state.get("section_stall_counts", {}) or {}
+            idx_key = str(state.get("current_section_idx", 0))
+            if stalls.get(idx_key, 0) >= 2:
+                logger.warning(
+                    f"[Generator] Pomijam resolve_missing_data — sekcja {idx_key} zablokowana w pętli."
+                )
+                return "continue"
+            return "resolve"
+
+        if state.get("guard_block", False) and not state.get("full_autopilot"):
+            return "review"
+
+        return "audit" if state.get("is_completed") else "continue"
+
+    async def provide_human_response(self, thread_id: str, response: str):
+        """Aktualizuje stan grafu o odpowiedź użytkownika, zachowując dotychczasowy kontekst (np. GUS)."""
+        graph = await self.get_graph()
+        config = {"configurable": {"thread_id": thread_id}}
+        
+        # Pobieramy dotychczasowy stan, żeby nie nadpisać danych z GUS
+        state = await graph.aget_state(config)
+        old_context = state.values.get("additional_context") or ""
+        new_context = old_context + f"\n\n[Odpowiedź Użytkownika / Uzupełnienie danych]:\n{response}\n"
+        
+        # Aktualizujemy stan i kasujemy pytanie
+        await graph.aupdate_state(
+            config, 
+            {"additional_context": new_context, "missing_data_question": None},
+            as_node="ask_missing_data"
+        )
+
+    async def astm_stream(
+        self,
+        initial_state: Optional[GeneratorState],
+        thread_id: str,
+        resume: bool = False,
+    ):
+        """Uruchamia graf w trybie streamingowym zdarzeń żeby zasilić SSE (Server-Sent Events)"""
+        graph = await self.get_graph()
+        config = {"configurable": {"thread_id": thread_id}, "recursion_limit": 80}
+        
+        # Ochrona przed błędem `Received no input for __start__` gdy MemorySaver jest wyczyszczony.
+        state = await graph.aget_state(config)
+        if resume and not state.values:
+            logger.warning(f"Zażądano wznowienia dla wątku {thread_id}, ale brak stanu w checkpointerze. Resetujemy strumień z initial_state.")
+            input_data = initial_state
+        else:
+            input_data = None if resume else initial_state
+            
+        async for event in graph.astream_events(
+            input_data, version="v2", config=config
+        ):
+            yield event

backend/agents/grant_research_agent.py

@@ -0,0 +1,165 @@
+"""LangGraph grant_research_agent — analiza zmian, enrichment, rekomendacje."""
+from __future__ import annotations
+
+import logging
+import os
+from typing import Any, Dict, List, Optional, TypedDict
+
+try:
+    from langgraph.graph import StateGraph, START, END
+
+    LANGGRAPH_AVAILABLE = True
+except ImportError:
+    LANGGRAPH_AVAILABLE = False
+    StateGraph = START = END = None  # type: ignore
+
+logger = logging.getLogger(__name__)
+
+
+class GrantResearchState(TypedDict, total=False):
+    grant_id: str
+    grant_data: Dict[str, Any]
+    changes: List[Dict[str, Any]]
+    company_profile: Dict[str, Any]
+    change_analysis: str
+    enriched_metadata: Dict[str, Any]
+    change_summary: str
+    recommendations: List[Dict[str, Any]]
+    error: Optional[str]
+
+
+def is_grant_research_agent_enabled() -> bool:
+    return os.environ.get("ENABLE_GRANT_RESEARCH_AGENT", "true").lower() == "true"
+
+
+def analyze_changes_node(state: GrantResearchState) -> Dict[str, Any]:
+    changes = state.get("changes") or []
+    grant = state.get("grant_data") or {}
+    if not changes:
+        return {
+            "change_analysis": f"Brak wykrytych zmian dla programu '{grant.get('name', state.get('grant_id', ''))}'."
+        }
+    lines = []
+    for ch in changes[:8]:
+        lines.append(ch.get("change_summary") or f"{ch.get('field_name')}: {ch.get('old_value')} → {ch.get('new_value')}")
+    analysis = (
+        f"Wykryto {len(changes)} zmian w programie '{grant.get('name', '')}'. "
+        + " ".join(lines[:5])
+    )
+    high_priority = [c for c in changes if c.get("field_name") in ("deadline", "status", "regulation_url")]
+    if high_priority:
+        analysis += f" Priorytet: {len(high_priority)} zmian wymaga weryfikacji (termin/regulamin/status)."
+    return {"change_analysis": analysis}
+
+
+def enrich_metadata_node(state: GrantResearchState) -> Dict[str, Any]:
+    grant = dict(state.get("grant_data") or {})
+    from core.grants.completeness import compute_completeness
+    from core.grants.credibility import score_source_credibility
+
+    comp = compute_completeness(grant)
+    cred = score_source_credibility(grant)
+    enriched = {
+        "completeness_score": comp["completeness_score"],
+        "fields_missing": comp["fields_missing"],
+        "source_credibility_score": cred,
+        "catalog_hidden": grant.get("catalog_hidden", False),
+        "program_year": grant.get("program_year"),
+        "operator": grant.get("operator") or grant.get("program"),
+    }
+    if not grant.get("program_goals") and grant.get("description"):
+        enriched["program_goals_hint"] = (grant.get("description") or "")[:300]
+    return {"enriched_metadata": enriched}
+
+
+def summarize_changes_node(state: GrantResearchState) -> Dict[str, Any]:
+    analysis = state.get("change_analysis") or ""
+    enriched = state.get("enriched_metadata") or {}
+    grant_name = (state.get("grant_data") or {}).get("name", state.get("grant_id", ""))
+    summary = (
+        f"Program: {grant_name}. "
+        f"Kompletność danych: {enriched.get('completeness_score', 'N/A')}%. "
+        f"Wiarygodność źródła: {enriched.get('source_credibility_score', 'N/A')}. "
+    )
+    if analysis:
+        summary += f" Analiza zmian: {analysis[:400]}"
+    else:
+        summary += " Brak istotnych zmian od ostatniego snapshotu."
+    return {"change_summary": summary.strip()}
+
+
+def recommend_node(state: GrantResearchState) -> Dict[str, Any]:
+    company = state.get("company_profile") or {}
+    grant = state.get("grant_data") or {}
+    if not company:
+        return {"recommendations": []}
+    from core.grants.recommendations import score_grant_for_company
+
+    rec = score_grant_for_company(grant, company)
+    return {"recommendations": [rec]}
+
+
+def _run_sequential(state: GrantResearchState) -> GrantResearchState:
+    """Fallback bez LangGraph — ta sama kolejność węzłów."""
+    out = dict(state)
+    for node_fn in (analyze_changes_node, enrich_metadata_node, summarize_changes_node, recommend_node):
+        patch = node_fn(out)
+        out.update(patch)
+    return out
+
+
+def build_grant_research_graph():
+    if not LANGGRAPH_AVAILABLE:
+        return None
+    graph = StateGraph(GrantResearchState)
+    graph.add_node("analyze_changes", analyze_changes_node)
+    graph.add_node("enrich_metadata", enrich_metadata_node)
+    graph.add_node("summarize", summarize_changes_node)
+    graph.add_node("recommend", recommend_node)
+
+    graph.add_edge(START, "analyze_changes")
+    graph.add_edge("analyze_changes", "enrich_metadata")
+    graph.add_edge("enrich_metadata", "summarize")
+    graph.add_edge("summarize", "recommend")
+    graph.add_edge("recommend", END)
+    return graph.compile()
+
+
+_grant_research_graph = None
+
+
+def get_grant_research_graph():
+    global _grant_research_graph
+    if _grant_research_graph is None:
+        _grant_research_graph = build_grant_research_graph()
+    return _grant_research_graph
+
+
+def run_grant_research_agent(
+    grant_data: Dict[str, Any],
+    *,
+    changes: Optional[List[Dict[str, Any]]] = None,
+    company_profile: Optional[Dict[str, Any]] = None,
+) -> Dict[str, Any]:
+    """Ręczne lub automatyczne uruchomienie agenta."""
+    if not is_grant_research_agent_enabled():
+        return {"enabled": False, "error": "ENABLE_GRANT_RESEARCH_AGENT=false"}
+
+    initial: GrantResearchState = {
+        "grant_id": str(grant_data.get("id", "")),
+        "grant_data": grant_data,
+        "changes": changes or [],
+        "company_profile": company_profile or {},
+    }
+    graph = get_grant_research_graph()
+    if graph is not None:
+        result = graph.invoke(initial)
+    else:
+        result = _run_sequential(initial)
+    result["enabled"] = True
+    result["langgraph"] = LANGGRAPH_AVAILABLE
+    return result
+
+
+async def run_grant_research_agent_async(**kwargs) -> Dict[str, Any]:
+    return run_grant_research_agent(**kwargs)

backend/agents/helpers.py

@@ -0,0 +1,862 @@
+from schemas import AgentState, CompanyProfile, CriticFeedback
+from typing import Optional
+from langchain_core.messages import HumanMessage, AIMessage
+from langchain_core.prompts import PromptTemplate
+from core.llm_router import get_llm
+from rag_pipeline import get_hybrid_retriever, rerank_documents
+from core.search.regulation_engine import regulation_engine
+from core.trust.trust_scorer import compute_grant_trust_score
+from agents.wizard import wizard_node
+from agents.critic import critic_node
+import json
+import os
+import time
+from langsmith import traceable
+from langchain_core.tracers.langchain import LangChainTracer
+
+# Foundational observability for generation (errors, latency, quality signals for grounding/LLM)
+from core.telemetry import metrics
+
+# Włącz tracing LangSmith
+os.environ["LANGCHAIN_TRACING_V2"] = "false"
+os.environ["LANGCHAIN_PROJECT"] = "grantforge-production"
+
+# Opcjonalnie – jeśli chcesz zobaczyć dokładne nazwy runów
+tracer = LangChainTracer(project_name="grantforge-production")
+
+ANTI_HALLUCINATION_PROMPT = """
+BEZWZGLĘDNA ZASADA (ANTI-HALLUCINATION / GROUNDED GENERATION): 
+Jesteś surowym audytorem dotacyjnym. Masz bezwzględny zakaz korzystania z jakiejkolwiek wiedzy spoza dostarczonego kontekstu (baza wiedzy RAG / pliki projektu). 
+Jeśli informacja nie wynika wprost z podanych dokumentów lub metadanych – odpowiedz dokładnie: "Brak wystarczających informacji w aktualnych zasobach". Nie wolno Ci zgadywać kwot, terminów ani warunków kwalifikowalności.
+[Explainable AI - XAI]: Zawsze jasno wskazuj, na jakiej podstawie opierasz dany wniosek (cytuj precyzyjnie załączony kontekst i regulaminy, pokazując ciąg przyczynowo-skutkowy).
+"""
+
+# v5.0 incremental data quality helper (pragmatic, for generated content verification)
+# Detects low-specificity / vague language common in poor grant drafts. Used in post-gen checks.
+from functools import lru_cache
+
+@lru_cache(maxsize=128)
+def _compute_basic_generated_data_quality(text: str) -> int:
+    """Cached for token optimization (pure heuristic, repeated calls in flows)."""
+    if not text or len(text) < 30:
+        return 20
+    t = text.lower()
+    score = 60
+    # Specificity signals (good)
+    if any(kw in t for kw in ["%", "zł", "euro", "tys.", "mln", "2026", "miesiąc", "m-c", "osób", "etat", "pkd", "nip"]):
+        score += 15
+    if any(kw in t for kw in ["zgodnie z §", "regulamin", "pkt ", "załącznik", "kryterium", "kwalifikowalny"]):
+        score += 12
+    # Vagueness penalties (bad for data quality)
+    vague = ["w miarę możliwości", "w zależności od", "prawdopodobnie", "w przybliżeniu", "można założyć", "warto rozważyć", "optymalnie", "w przyszłości"]
+    vagueness_hits = sum(1 for v in vague if v in t)
+    score -= min(25, vagueness_hits * 7)
+    # Length + structure heuristic
+    if len(text) > 800:
+        score += 8
+    if text.count("\n") > 4 or "- " in text:
+        score += 5
+    # Penalize very generic filler
+    if t.count("projekt polega na") > 1 or t.count("celem jest") > 2:
+        score -= 10
+    return max(25, min(95, int(score)))
+
+
+@traceable(
+    run_type="chain",
+    name="generate_section",
+    tags=["rag_pipeline", "faithfulness_target"],
+)
+def generate_section_light(
+    section_type: str,
+    context: str,
+    external_context: dict = None,
+    program_name: str = None,
+    light_mode: bool = True,  # token optimization: early short-circuit for very light use
+) -> str:
+    """
+    Lekka, stabilna ścieżka generowania sekcji.
+    Używana domyślnie w okienku asystenta projektu i jako fallback.
+    light_mode: skips heavy regulation calls for ultra-low token in some flows.
+    """
+    from core.llm_router import get_llm
+    from langchain_core.messages import HumanMessage
+    import logging
+    logger = logging.getLogger(__name__)
+
+    if light_mode and not context:
+        context = f"Generuj treść do sekcji {section_type} na podstawie profilu firmy i regulaminu {program_name or ''}."
+
+    llm = get_llm(task_type="fast")
+
+    company = {}
+    context_block = ""
+    try:
+        if external_context and isinstance(external_context, dict):
+            company = external_context.get("company_data", {}) or {}
+            from core.context.project_context import build_project_context
+
+            ctx = build_project_context(
+                {"external_context": external_context, "program_name": program_name}
+            )
+            context_block = ctx.to_prompt_block(max_chars=3500)
+    except Exception:
+        company = external_context.get("company_data", {}) if external_context else {}
+
+    # Uwaga: żadne noty techniczne/telemetryczne nie są doklejane do treści sekcji
+    # (treść wniosku ma być czysta i po polsku). Sygnały jakości → metryki/traceability.
+
+    applicant_block = context_block or (
+        "Dane wnioskodawcy:\n"
+        f"Nazwa: {company.get('name', 'Wnioskodawca')}\n"
+        f"NIP: {company.get('nip', '')}\n"
+        f"Województwo: {company.get('voivodeship', '')}\n"
+        f"PKD: {', '.join(company.get('pkd', [])[:3]) if company.get('pkd') else ''}"
+    )
+
+    prompt = f"""Jesteś ekspertem przygotowującym wnioski o dofinansowanie.
+
+Napisz konkretną, profesjonalną treść do sekcji: **{section_type}**
+
+[ANTI-HALLUCINATION]: Opieraj się WYŁĄCZNIE na udostępnionych poniżej danych wnioskodawcy i programie. Nie wymyślaj dodatkowych liczb ani statystyk. Dla brakujących danych wstaw placeholder [DO WERYFIKACJI: opis]. Zastosuj najwyższej jakości formatowanie Markdown (nagłówki, listy).
+
+Kontekst projektu:
+{context[:4000] if context else "Brak szczegółowego opisu"}
+
+{applicant_block}
+
+Program: {program_name or 'wniosek dotacyjny'}
+
+Pisz po polsku, merytorycznie, w stylu urzędowego wniosku. Bądź konkretny.
+Uwzględnij podstawowe ugruntowanie w regulaminie jeśli dostępne (Regulation Engine v5.0)."""
+
+    last_error = None
+    for attempt in range(3):
+        try:
+            resp = llm.invoke([HumanMessage(content=prompt)])
+            content = resp.content if hasattr(resp, "content") else str(resp)
+            if content and len(content.strip()) > 20:
+                return content
+        except Exception as e:
+            last_error = str(e)
+            logger.warning(f"[generate_section_light] Próba {attempt+1}/3 nieudana: {e}")
+
+    # High-stability fallback: always return usable professional stub (never crash UI)
+    fallback = f"""### {section_type}
+
+**Wnioskodawca:** {company.get('name', 'Wnioskodawca')}  
+**Program:** {program_name or 'wniosek dotacyjny'}
+
+Treść sekcji wymaga uzupełnienia na podstawie szczegółowej analizy regulaminu i dokumentacji projektu.
+
+[UZUPEŁNIĆ: Wstaw merytoryczną treść zgodną z kryteriami programu i danymi z GUS/KRS]
+
+*Wygenerowano w trybie awaryjnym lekkim (stabilny fallback).*
+"""
+    if last_error:
+        logger.error(f"[generate_section_light] Użyto fallbacku po błędach: {last_error}")
+    final_content = content if 'content' in locals() and content else fallback
+
+    # v5.0 incremental: Post-generation CitationVerifier + basic grounding check on generated content (for light path too)
+    # Stronger verification of generated text against regulations. Non-blocking, attaches note if program known.
+    try:
+        if program_name and isinstance(final_content, str) and len(final_content) > 80:
+            from core.search.regulation_engine import citation_verifier
+            if citation_verifier:
+                verif = citation_verifier.verify_text_citations(final_content[:4500], program_name, sample_claims=None)
+                gscore = verif.get("overall_citation_score", 0.0) if isinstance(verif, dict) else getattr(verif, "overall_citation_score", 0.0)
+                # Sygnał jakości trafia WYŁĄCZNIE do metryk — nie do treści wniosku.
+                metrics.record_quality_signal(
+                    "generation_light_grounding", round(float(gscore or 0.0), 3),
+                    {"program": program_name or "unknown"}
+                )
+                if gscore > 0.7:
+                    metrics.increment("generation.light_grounding_good", tags={"program": program_name or "unknown"})
+    except Exception as _v5e:
+        logger.debug(f"[v5.0 light verif] skipped: {_v5e}")
+    return final_content
+
+
+def generate_section(
+    project_id: str,
+    section_type: str,
+    context: str,
+    external_context: dict = None,
+    program_name: str = None,
+    user_id: str = "",
+) -> str:
+    """
+    Wywołuje logikę Wizard z RAG tylko dla pojedynczej sekcji, bez przelotu przez cały Graf.
+    """
+    from core.telemetry import telemetry
+
+    t0 = time.time()
+    metrics.increment("generation.generate_section_calls", tags={"section_type": section_type or "unknown", "has_program": str(bool(program_name))})
+    telemetry.log(
+        "INFO",
+        "Helpers",
+        f"Rozpoczynamy generowanie sekcji: {section_type}",
+        {"project_id": project_id},
+    )
+
+    company_data_str = ""
+    if external_context:
+        if (
+            "project_description" in external_context
+            and external_context["project_description"]
+        ):
+            company_data_str += f"INFORMACJE OGÓLNE O PROJEKCIE (wpisane przez użytkownika):\n{external_context['project_description']}\n\n"
+        if (
+            "current_section_content" in external_context
+            and external_context["current_section_content"]
+        ):
+            company_data_str += f"OBECNA TREŚĆ SEKCJI (Zastosuj ewentualne poprawki do tego tekstu, zachowując jego spójność):\n{external_context['current_section_content']}\n\n"
+        if "company_data" in external_context:
+            company_data_str += f"Dane z GUS (kontekst o firmie wnioskodawcy):\n{json.dumps(external_context['company_data'], indent=2, ensure_ascii=False)}\n\n"
+        if "resources" in external_context and external_context["resources"]:
+            company_data_str += "Zasoby projektu (dostarczone pliki):\n"
+            for res in external_context["resources"]:
+                # Limitujemy tekst wyciągnięty z pliku żeby nie wysadzić okna kontekstowego dla gigantycznych plików (opcjonalnie, ale dobra praktyka)
+                text_clip = res.get("extracted_text") or ""
+                if len(text_clip) > 5000:
+                    text_clip = text_clip[:5000] + "... [UKRÓCONO]"
+                company_data_str += (
+                    f"--- PLIK: {res.get('filename')} ---\n{text_clip}\n\n"
+                )
+
+        if company_data_str:
+            company_data_str += "INSTRUKCJA PRIORYTETU: Dane z sekcji company_data oraz lista resources mają najwyższy priorytet. Używaj ich zawsze jako głównego źródła informacji o firmie. Wiedza ogólna z RAG jest tylko pomocnicza.\n\n"
+
+    program_context = (
+        f"\n\nWAŻNE! PROJEKT DOTYCZY PROGRAMU:\n{program_name}\nBezwzględnie dostosuj narrację, słownictwo oraz rozłożenie akcentów we wniosku do specyfiki, wytycznych i głównego celu tego konkretnego programu. Unikaj żargonu z innych typów dotacji, chyba że wprost tu pasuje.\n"
+        if program_name
+        else ""
+    )
+
+    # === Faza 1 / Punkt 2 + Faza 3: Regulation Context + Structured Engine Rules ===
+    regulation_section_context = ""
+    if program_name:
+        try:
+            from core.search.regulation_context_provider import get_regulation_context_for_candidates, format_regulation_context_for_prompt
+
+            fake_candidates = [{"id": "current_section", "program": program_name, "name": section_type}]
+            reg_ctx = get_regulation_context_for_candidates(
+                fake_candidates,
+                project_description=context,
+                k_per_grant=3
+            )
+            regulation_section_context = "\n\n" + format_regulation_context_for_prompt(reg_ctx, "current_section")
+
+            # Nowe: Structured rules + eligibility checker z Engine (szczególnie ważne przy budżecie)
+            rules = regulation_engine.get_structured_rules_for_program(program_name)
+            if rules and rules.get("key_rules"):
+                regulation_section_context += "\n\nStrukturalne reguły z Regulation Engine:\n" + "\n".join(rules["key_rules"][:5])
+
+            # Trust Score context (Cycle 9)
+            try:
+                ext = external_context or {}
+                ts = compute_grant_trust_score({
+                    "regulation_link_quality": ext.get("regulation_link_quality", "medium"),
+                    "precise_regulation_url": ext.get("precise_regulation_url")
+                })
+                regulation_section_context += f"\n\n[Trust Score dla tego programu: {ts}/100 — im wyższy, tym bezpieczniej cytować regulamin]"
+            except Exception:
+                pass
+
+            # Bezpośrednie użycie checkera kosztów przy sekcjach budżetowych (aktywna integracja Faza 3)
+            if section_type in ["budget", "budget_details", "koszty", "montaż finansowy"] and context:
+                try:
+                    eligibility = regulation_engine.check_cost_eligibility(program_name or "", context[:1500])
+                    if eligibility.get("status") == "evaluated":
+                        reg_text = eligibility.get('raw_response', '')
+                        regulation_section_context += f"\n\nWeryfikacja kwalifikowalności kosztów (Regulation Engine):\n{reg_text}"
+
+                        # Aktywne zachowanie: jeśli silnik widzi ryzyko — dajemy silną instrukcję generatorowi
+                        if "Niekwalifikowalny" in reg_text or "Wymaga weryfikacji" in reg_text:
+                            regulation_section_context += (
+                                "\n\nWAŻNA INSTRUKCJA: Powyższa weryfikacja Regulation Engine wskazuje na potencjalne ryzyko niekwalifikowalności. "
+                                "Bądź bardzo konserwatywny w opisie kosztów. Oznacz elementy wymagające potwierdzenia przez użytkownika. "
+                                "Nie twierdź kategorycznie, że koszty są kwalifikowalne jeśli silnik ma wątpliwości."
+                            )
+                except Exception:
+                    pass
+        except Exception as e:
+            import logging
+            logging.getLogger(__name__).warning(f"Nie udało się pobrać regulation context dla sekcji: {e}")
+
+    # === Faza 3 final (cykl automatyczny): Regulation Grounding Certificate (najwyższa wiarygodność) ===
+    grounding_certificate = ""
+    try:
+        from core.search.regulation_snapshot import regulation_snapshot_store
+
+        snap = regulation_snapshot_store.get_latest_for_program(program_name or "") if program_name else None
+        cert_lines = []
+
+        if snap:
+            cert_lines.append("REGULATION GROUNDING CERTIFICATE v1")
+            cert_lines.append(f"Program: {program_name}")
+            cert_lines.append(f"Snapshot ID: {snap.id}")
+            cert_lines.append(f"Version Hash: {snap.version_hash}")
+            cert_lines.append(f"Fetched: {snap.fetched_at}")
+            cert_lines.append(f"Source: {snap.source_url[:80]}")
+            if snap.effective_date:
+                cert_lines.append(f"Effective Date: {snap.effective_date}")
+            if snap.document_version:
+                cert_lines.append(f"Document Version: {snap.document_version}")
+            if snap.source_institution:
+                cert_lines.append(f"Institution: {snap.source_institution}")
+            cert_lines.append(f"Key Rules Cited: {len(snap.key_rules or [])}")
+            cert_lines.append(f"Exclusions Known: {len(snap.exclusions or [])}")
+
+        # Dodaj wynik aktywnego checku silnika (jeśli dotyczy budżetu lub kwalifikowalności)
+        if section_type in ["budget", "budget_details", "koszty", "montaż finansowy", "kwalifikowalność"] and program_name:
+            try:
+                el = regulation_engine.check_cost_eligibility(program_name, context[:1200] if context else "")
+                if el.get("status") == "evaluated":
+                    cert_lines.append(f"Engine Cost Check: eligible={el.get('eligible')} severity={el.get('severity')}")
+                    cert_lines.append(f"Engine Ref: {el.get('regulation_reference', '')[:120]}")
+            except Exception:
+                pass
+
+        if cert_lines:
+            grounding_certificate = "\n\n" + "\n".join(cert_lines) + "\n--- END CERTIFICATE ---\n"
+            # Dodajemy też do kontekstu promptu, żeby model wiedział, że musi to zachować
+            regulation_section_context += grounding_certificate
+    except Exception as cert_e:
+        import logging
+        logging.getLogger(__name__).debug(f"Grounding certificate generation skipped: {cert_e}")
+
+    initial_prompt = f"Wygeneruj merytoryczną, wysoce profesjonalną treść dla sekcji '{section_type}'.\n\n[ANTI-HALLUCINATION]: ZAKAZ ZMYŚLANIA FAKTÓW. Opieraj się w 100% na dostarczonym kontekście i profilu firmy.\n[XAI]: Gdzie stosowne, dodawaj krótkie merytoryczne uzasadnienia wyborów na podstawie wytycznych programu (w treści sekcji).\nKontekst szczegółowy: {context}\n\n{company_data_str}{program_context}{regulation_section_context}\nWAŻNE: Zadbaj o estetyczne i bogate formatowanie Markdown (tabele, pogrubienia, sekcje). PISZ ZAWSZE W JĘZYKU POLSKIM. Na końcu wygenerowanej sekcji ZAWSZE dołącz (lub zachowaj) Regulation Grounding Certificate jeśli był podany w kontekście."
+
+    tenant_ns = f"tenant_{user_id}_{project_id}" if user_id and project_id else ""
+
+    _cd = (external_context or {}).get("company_data", {}) if external_context else {}
+    _pkd = _cd.get("pkd_codes") or _cd.get("pkd") or []
+    if isinstance(_pkd, str):
+        _pkd = [_pkd]
+    _pkd = [p for p in _pkd if p and "brak pkd" not in str(p).lower()]
+    state = AgentState(
+        messages=[HumanMessage(content=initial_prompt)],
+        user_id=user_id,
+        tenant_id=tenant_ns,
+        profile=CompanyProfile(
+            nip=_cd.get("nip", "0000000000") or "0000000000",
+            name=_cd.get("name", "") or "",
+            regon=_cd.get("regon", "") or "",
+            krs=_cd.get("krs", "") or "",
+            legal_form=_cd.get("legal_form", "") or "",
+            pkd_codes=_pkd,
+            region=_cd.get("voivodeship") or _cd.get("region") or "Mazowieckie",
+            size=_cd.get("size") or "MŚP",
+        ),
+    )
+
+    from core.utils import extract_markdown_and_sanitize
+    from core.circuit_breaker import with_llm_retry, llm_circuit_breaker
+    import logging
+
+    logger = logging.getLogger(__name__)
+
+    @llm_circuit_breaker
+    @with_llm_retry
+    def invoke_with_watchdog():
+        result = wizard_node(state)
+        new_messages = result.get("messages", [])
+        if new_messages and len(new_messages) > 0:
+            last_msg = new_messages[-1]
+            if isinstance(last_msg, dict) and "content" in last_msg:
+                raw_c = last_msg["content"]
+            elif hasattr(last_msg, "content"):
+                raw_c = last_msg.content
+            else:
+                raw_c = ""
+
+            # Weryfikujemy i wyciągamy Markdown
+            sanitized = extract_markdown_and_sanitize(raw_c)
+
+            # Sanity Checks: Blokada pustych odpowiedzi i typowych odmów
+            if not sanitized or len(sanitized.strip()) < 20:
+                logger.warning(
+                    f"Watchdog: Otrzymano zbyt krótką/pustą odpowiedź (długość: {len(sanitized)}). Wymuszam ponowienie."
+                )
+                telemetry.log(
+                    "WARN",
+                    "Watchdog",
+                    "Zbyt krótka odpowiedź. Wymuszam ponowienie.",
+                    {"project_id": project_id},
+                )
+                raise ValueError(
+                    "Błąd sanity check: Pusta lub zbyt krótka odpowiedź z modelu."
+                )
+
+            lower_c = sanitized.lower()
+            refusals = [
+                "nie potrafię",
+                "nie jestem w stanie",
+                "nie mogę",
+                "as an ai",
+                "jako model językowy",
+            ]
+            if any(r in lower_c for r in refusals) and len(sanitized) < 200:
+                logger.warning(
+                    "Watchdog: Wykryto typową odmowę LLM. Wymuszam ponowienie."
+                )
+                raise ValueError(
+                    "Błąd sanity check: Model odmówił wygenerowania odpowiedzi."
+                )
+
+            # === Faza 3: Wymuszony Regulation Grounding Certificate na wyjściu (nawet jeśli LLM pominął) ===
+            if grounding_certificate and "--- END CERTIFICATE ---" not in sanitized:
+                sanitized = sanitized.rstrip() + "\n\n" + grounding_certificate.strip()
+
+            # Foundational quality signal for LLMOps
+            has_grounding = bool(grounding_certificate) or ("CERTIFICATE" in sanitized.upper() or "Regulation Grounding" in sanitized)
+            metrics.record_quality_signal(
+                "generation_grounding_certificate_present",
+                has_grounding,
+                {"section_type": section_type, "project_id": project_id, "program": program_name}
+            )
+            duration_ms = (time.time() - t0) * 1000
+            metrics.record_latency("generation.generate_section", duration_ms, tags={"section_type": section_type or "unknown", "grounded": str(has_grounding)})
+
+            # v5.0: Stronger post-generation verification of generated content (citation/grounding + basic data quality)
+            # Pragmatic: run CitationVerifier + simple heuristics on the output before return. Attaches metadata note.
+            try:
+                if program_name and isinstance(sanitized, str) and len(sanitized) > 60:
+                    from core.search.regulation_engine import citation_verifier, kruczkowski_trap_agent
+                    if citation_verifier:
+                        verif = citation_verifier.verify_text_citations(sanitized[:5000], program_name)
+                        gscore = verif.get("overall_citation_score", 0.0) if isinstance(verif, dict) else getattr(verif, "overall_citation_score", 0.0)
+                        # Wynik weryfikacji → metryki (metadane), NIE do treści wniosku.
+                        metrics.record_quality_signal(
+                            "generation_postgen_citation", round(float(gscore or 0.0), 3),
+                            {"section": section_type, "project": project_id}
+                        )
+                        if gscore < 0.5:
+                            metrics.increment("generation.postgen_low_grounding", tags={"section": section_type or "unknown"})
+                        # Data quality heuristic for generated text (prefer v5.0 central in CitationVerifier)
+                        dq = 55
+                        try:
+                            from core.search.regulation_engine import citation_verifier
+                            if citation_verifier and hasattr(citation_verifier, "compute_generated_content_data_quality"):
+                                dq_res = citation_verifier.compute_generated_content_data_quality(sanitized, program_name)
+                                dq = dq_res.get("data_quality_score", 55)
+                        except Exception:
+                            dq = _compute_basic_generated_data_quality(sanitized)  # local fallback
+                        if dq < 55:
+                            metrics.increment("generation.low_data_quality", tags={"section": section_type or "unknown"})
+                        elif dq > 75:
+                            metrics.increment("generation.high_data_quality", tags={"section": section_type})
+                    if kruczkowski_trap_agent:
+                        # Light trap check on gen content for compliance layer (non blocking) — sygnał do metryk.
+                        try:
+                            trap = kruczkowski_trap_agent.detect_traps(sanitized[:3000], program_name or "")
+                            if trap.get("overall_trap_risk") in ("high", "critical"):
+                                metrics.increment(
+                                    "generation.postgen_trap_detected",
+                                    tags={"risk": trap.get("overall_trap_risk"), "section": section_type or "unknown"},
+                                )
+                        except Exception:
+                            pass
+            except Exception as _v5post:
+                logger.debug(f"[v5.0 post-gen verif] non-fatal: {_v5post}")
+                try:
+                    from core.telemetry import metrics as _m
+                    if _m:
+                        _m.record_error("helpers.generate_section", "v5_post_gen_verify", str(_v5post)[:200], severity="warning")
+                except Exception:
+                    pass
+
+            # v5.0 Production LLMOps: per-query/per-project token cost est + citation faithfulness + user_satisfaction stub for full flow (post verif)
+            try:
+                token_est = max(50, len((sanitized or "").split()) * 1.3)
+                faithfulness = gscore if "gscore" in locals() else 0.65
+                sat_stub = round(0.62 + 0.33 * min(1.0, float(faithfulness)), 2)
+                metrics.record_latency("generation.est_token_cost", token_est, tags={"project_id": str(project_id or "unknown")})
+                metrics.record_quality_signal("generation_citation_faithfulness", round(float(faithfulness), 3), {"project": project_id, "section": section_type})
+                metrics.record_quality_signal("user_satisfaction_proxy", sat_stub, {"project": project_id, "via": "postgen_grounding"})
+                metrics.increment("llmops.generation_full_flows", tags={"project": str(project_id or "")})
+                # Hardened enterprise signals
+                metrics.record_token_usage("generation_section", prompt_tokens=max(30, int(token_est * 0.45)), completion_tokens=int(token_est * 0.55), tags={"section": section_type or "unknown", "project": str(project_id or "")})
+                metrics.record_faithfulness_trend(float(faithfulness), {"via": "helpers_generate", "section": section_type})
+                metrics.record_fallback_rate("generation", rate=0.05 if "fallback" in str(locals()).lower() else 0.0)
+            except Exception:
+                pass
+
+            return sanitized
+        raise ValueError("Brak odpowiedzi tekstowej w strukturze wizarda")
+
+    try:
+        return invoke_with_watchdog()
+    except Exception as e:
+        logger.error(f"Nie powiodła się generacja sekcji (wizard_node + RAG): {e}", exc_info=True)
+        telemetry.log(
+            "ERROR", "Helpers", f"Błąd generacji sekcji: {str(e)}", {"project_id": project_id, "section": section_type}
+        )
+        metrics.record_error("Helpers", "generate_section_wizard_rag", str(e), severity="error")
+
+        # Fallback: prostsza generacja bezpośrednia LLM bez ciężkiego RAG/wizard_node
+        try:
+            from core.llm_router import get_llm
+            from langchain_core.messages import HumanMessage as FallbackHumanMessage
+
+            llm = get_llm(task_type="fast")
+            simple_prompt = f"""Napisz profesjonalną treść do sekcji '{section_type}' wniosku dotacyjnego.
+
+Kontekst projektu:
+{context[:3000] if context else "Brak szczegółowego kontekstu"}
+
+Dane firmy:
+{json.dumps(external_context.get("company_data", {}), ensure_ascii=False) if external_context else "Brak danych firmy"}
+
+Program: {program_name or "Ogólny"}
+
+Napisz po polsku, konkretnie i merytorycznie. Jeśli to możliwe, uwzględnij podstawowe wymogi kwalifikowalności."""
+
+            response = llm.invoke([FallbackHumanMessage(content=simple_prompt)])
+            content = response.content if hasattr(response, "content") else str(response)
+
+            if grounding_certificate:
+                content += "\n\n" + grounding_certificate
+
+            logger.warning(f"[Helpers] Użyto fallbackowej generacji sekcji {section_type} po awarii głównej ścieżki.")
+            base_fb = content + "\n\n---\n*Wygenerowano w trybie awaryjnym (uproszczonym). Zalecana weryfikacja.*"
+            try:
+                from core.telemetry import metrics as _m
+                _m.record_fallback_rate("generation_fallback", rate=1.0, tags={"section": section_type})
+            except Exception:
+                pass
+
+            # v5.0: Apply light citation/data quality note even on fallback generated content
+            try:
+                if program_name and len(base_fb) > 50:
+                    from core.search.regulation_engine import citation_verifier
+                    if citation_verifier:
+                        ver = citation_verifier.verify_text_citations(base_fb[:2000], program_name)
+                        sc = ver.get("overall_citation_score", 0.4) if isinstance(ver, dict) else 0.4
+                        # Sygnał ugruntowania fallbacku → metryki, nie do treści.
+                        metrics.record_quality_signal(
+                            "generation_fallback_grounding", round(float(sc or 0.0), 3),
+                            {"section": section_type}
+                        )
+            except Exception:
+                pass
+            return base_fb
+
+        except Exception as fallback_e:
+            logger.error(f"Fallback generation also failed: {fallback_e}")
+            metrics.record_error("Helpers", "generate_section_fallback", str(fallback_e), severity="error")
+
+        # Ostateczny komunikat
+        if grounding_certificate:
+            return f"Generacja sekcji nie powiodła się po wyczerpaniu prób (główna ścieżka + fallback).\n\nBłąd: {str(e)}\n\nDane użyte w próbie:\n{grounding_certificate}"
+        duration_ms = (time.time() - t0) * 1000
+        metrics.record_latency("generation.generate_section", duration_ms, tags={"status": "failed_final"})
+        return "Nie powiodła się generacja sekcji po wyczerpaniu prób. Przepraszamy za utrudnienia. Spróbuj ponownie później lub z prostszym promptem."
+
+
+@traceable(
+    run_type="chain", name="review_section", tags=["rag_pipeline", "faithfulness_eval"]
+)
+def review_section(project_id: str, section_id: str, content: str) -> CriticFeedback:
+    """
+    Wywołuje logikę recenzenta Critic w celu ewaluacji dostarczonego tekstu wniosku.
+    """
+    from core.telemetry import telemetry
+
+    telemetry.log(
+        "INFO",
+        "Helpers",
+        f"Rozpoczynamy recenzję sekcji: {section_id}",
+        {"project_id": project_id},
+    )
+
+    # Critic expects the text to be in the last AI message
+    state = AgentState(
+        messages=[AIMessage(content=content)],
+        user_id="",
+        tenant_id="",
+        critic_iterations=0,
+    )
+
+    from core.circuit_breaker import with_llm_retry, llm_circuit_breaker
+    import logging
+
+    logger = logging.getLogger(__name__)
+
+    @llm_circuit_breaker
+    @with_llm_retry
+    def invoke_critic():
+        result = critic_node(state)
+        critic_eval = result.get("critic_evaluation")
+        if not critic_eval:
+            raise ValueError("Brak feedbacku od krytyka")
+
+        # Sanity check
+        if (
+            critic_eval.feedback
+            and len(critic_eval.feedback.strip()) < 10
+            and not critic_eval.is_approved
+        ):
+            logger.warning(
+                "Watchdog: Pusty feedback mimo odrzucenia. Wymuszam ponowienie."
+            )
+            telemetry.log(
+                "WARN",
+                "Watchdog",
+                "Pusty feedback. Wymuszam ponowienie.",
+                {"project_id": project_id},
+            )
+            raise ValueError(
+                "Błąd sanity check: Krytyk odrzucił tekst, ale nie podał powodu."
+            )
+
+        return critic_eval
+
+    try:
+        return invoke_critic()
+    except Exception as e:
+        logger.error(f"Krytyk zawiódł po 5 próbach: {e}")
+        return CriticFeedback(
+            is_approved=True,
+            feedback="Brak feedbacku - problem techniczny. Zatwierdzono warunkowo.",
+            severity="low",
+        )
+
+
+@traceable(run_type="chain", name="project_qa_agent")
+def project_qa_agent(
+    project_id: str,
+    question: str,
+    program_name: str,
+    context: str,
+    external_context: dict = None,
+) -> dict:
+    """
+    Weryfikator - odpowiada na pytania związane z projektem na bazie dokumentacji konkursowej i regulaminów (RAG)
+    oraz kontekstu samego projektu (zdefiniowane sekcje wniosku).
+    Zwraca ustrukturyzowaną odpowiedź w formacie słownika.
+    """
+    hard_filter = {"program_name": program_name} if program_name else None
+    # Use multi-stage retrieval (broad recall for reranker candidates) — incremental high-precision improvement
+    retriever = get_hybrid_retriever(
+        metadata_filter=hard_filter,
+        retrieval_k=16,
+        rerank_top_n=5,
+        use_reranker=True,
+    )
+
+    # Rozszerzamy zapytanie do wektorów o program i dotacje by zwiększyć precyzję wyszukiwania
+    search_query = f"{program_name} {question}" if program_name else question
+
+    rag_context = ""
+    sources_used = []
+    if retriever:
+        try:
+            # Wyszukanie odpowiednich dokumentów w RAG (already reranked internally if staged)
+            docs = retriever.invoke(search_query)
+            # Additional explicit rerank pass (defensive; safe if already high quality)
+            reranked_docs = rerank_documents(search_query, docs, top_n=4)
+            def _format_temporal(d):
+                valid_from = d.metadata.get("valid_from", "")
+                valid_to = d.metadata.get("valid_to", "")
+                ver_id = d.metadata.get("version_id", "")
+                time_str = ""
+                if valid_from or valid_to or ver_id:
+                    time_str = f" [Wersja: {ver_id}, Ważne od: {valid_from} do: {valid_to}]"
+                return f"SOURCE ({d.metadata.get('source', 'Unknown')} | {d.metadata.get('program_name', 'System')}){time_str}: {d.page_content}"
+
+            rag_context = "\n\n".join([_format_temporal(d) for d in reranked_docs])
+
+            # Zbudowanie listy unikalnych źrodeł
+            unique_sources = set()
+            for d in reranked_docs:
+                src_name = d.metadata.get("source", "Nieznane źródło")
+                if src_name:
+                    unique_sources.add(src_name)
+            sources_used = list(unique_sources)
+        except Exception as e:
+            rag_context = f"[Brak wyników z bazy wiedzy. Błąd RAG: {str(e)}]"
+    else:
+        rag_context = "[Baza wektorowa niedostępna]"
+
+    from schemas import ProjectQAResponse
+
+    # Używamy modelu o wysokiej precyzji do analityki
+    llm = get_llm(task_type="critical", structured_output_schema=ProjectQAResponse)
+
+    company_info = ""
+    if external_context:
+        if (
+            "project_description" in external_context
+            and external_context["project_description"]
+        ):
+            company_info += f"INFORMACJE OGÓLNE O PROJEKCIE (wpisane przez użytkownika):\n{external_context['project_description']}\n\n"
+        if "company_data" in external_context:
+            company_info += f"DANE FIRMY WNIOSKODAWCY (Z GUS):\n{json.dumps(external_context['company_data'], indent=2, ensure_ascii=False)}\n\n"
+        if "resources" in external_context and external_context["resources"]:
+            company_info += "ZASOBY PROJEKTU (dostarczone pliki wg użytkownika):\n"
+            for res in external_context["resources"]:
+                text_clip = res.get("extracted_text") or ""
+                if len(text_clip) > 3000:
+                    text_clip = text_clip[:3000] + "... [UKRÓCONO]"
+                company_info += f"--- PLIK: {res.get('filename')} ---\n{text_clip}\n\n"
+
+        if company_info:
+            company_info += (
+                "INSTRUKCJA PRIORYTETU (WAŻNE DLA AUTOPILOTU):\n"
+                "- Dane z sekcji company_data, project_description oraz wszystkie informacje wpisane przez użytkownika na początku mają ABSOLUTNY priorytet.\n"
+                "- Jeśli jakaś informacja (adres, forma prawna, wspólnicy, budżet, opis projektu itp.) już istnieje w powyższym kontekście — NIE pytaj użytkownika ponownie. Używaj jej bezpośrednio.\n"
+                "- Wiedza ogólna z RAG jest tylko pomocnicza.\n\n"
+            )
+
+    template = (
+        ANTI_HALLUCINATION_PROMPT
+        + """
+    Jesteś ekspertowym doradcą ds. dotacji unijnych, realizacji oraz rozliczania projektów R&D. Twoim zadaniem jest odpowiedź na Pytanie w odniesieniu do projektu klienta.
+    
+    WAŻNE ZASADY:
+    1. Używaj tylko najnowszych, aktualnych regulaminów z bazy wiedzy. Jeśli dostarczone dokumenty RAG wydają się przestarzałe, zachowaj ostrożność.
+    2. Zawsze cytuj konkretne paragrafy, punkty i nazwy dokumentów w polu "sources".
+    3. Jeśli nie jesteś w 100% pewien odpowiedzi na podstawie przepisów, ZAWSZE o tym napisz (nie zgaduj).
+    4. Dostosowuj odpowiedź do etapu projektu (czy to etap przygotowania wniosku, czy już realizacja i rozliczanie wydatków).
+    5. Traktuj dane w KONTEKST PROJEKTU jako źródło nadrzędne. Nie czepiaj się brakujących danych identyfikacyjnych (KRS, NIP, adres itp.), odpowiedz na pytanie merytorycznie.
+    6. BEZWZGLĘDNIE ODPOWIADAJ WYŁĄCZNIE W JĘZYKU POLSKIM I TYLKO NA TEMAT. Jeśli pytanie odbiega od funduszy, projektu lub dotacji, grzecznie wskaż, że jesteś specjalistą tylko od dotacji i odmów innej dyskusji.
+
+    KONTEKST PROJEKTU (dane i treść wniosku):
+    -------------------
+    {company_info}{project_context}
+    -------------------
+
+    BIEŻĄCE WYTYCZNE Z BAZY WIEDZY RAG (przepisy):
+    -------------------
+    {rag_context}
+    -------------------
+
+    Pytanie od użytkownika:
+    {question}
+    """
+    )
+
+    from core.circuit_breaker import with_llm_retry, llm_circuit_breaker
+
+    structured_llm = llm
+    prompt = PromptTemplate.from_template(template)
+    chain = prompt | structured_llm
+
+    @llm_circuit_breaker
+    @with_llm_retry
+    def invoke_qa():
+        response: ProjectQAResponse = chain.invoke(
+            {
+                "company_info": company_info,
+                "project_context": context,
+                "rag_context": rag_context,
+                "question": question,
+            }
+        )
+
+        if hasattr(response, "model_dump"):
+            parsed_out = response.model_dump()
+        elif hasattr(response, "dict"):
+            parsed_out = response.dict()
+        else:
+            parsed_out = dict(response)
+
+        # Sanity check
+        answer_text = parsed_out.get("answer", "")
+        if not answer_text or len(answer_text.strip()) < 10:
+            raise ValueError(
+                "Błąd sanity check: Odpowiedź Q&A jest pusta lub zbyt krótka."
+            )
+
+        # Jeśli źródła RAG coś znalazły, ale LLM nic nie podał, sklei to
+        if not parsed_out.get("sources") and sources_used:
+            parsed_out["sources"] = sources_used
+
+        return parsed_out
+
+    try:
+        return invoke_qa()
+    except Exception as e:
+        import traceback
+
+        traceback.print_exc()
+        print(
+            f"Wystąpił błąd structured_output w project_qa_agent: {e}, próba fallbacku..."
+        )
+
+        try:
+            # Fallback bez with_structured_output
+            fallback_chain = prompt | llm
+            raw_response = fallback_chain.invoke(
+                {
+                    "company_info": company_info,
+                    "project_context": context,
+                    "rag_context": rag_context,
+                    "question": question,
+                }
+            )
+            return {
+                "answer": raw_response.content
+                if hasattr(raw_response, "content")
+                else str(raw_response),
+                "sources": sources_used,
+                "confidence": 0.5,
+                "recommendation": "Odpowiedź wygenerowana w trybie awaryjnym (fallback). Mogą brakować szczegółowych źródeł wygenerowanych przez AI.",
+            }
+        except Exception:
+            traceback.print_exc()
+            # Ostateczny awaryjny powrót
+            return {
+                "answer": f"Awaria strukturalnego formatowania odpowiedzi modelu i trybu awaryjnego: {str(e)}",
+                "sources": sources_used,
+                "confidence": 0.0,
+                "recommendation": "Spróbuj sformułować pytanie w prostszy sposób. (Sprawdzanie strukturalne zabezpieczyło przed błędem)",
+            }
+
+
+# v5.0 Synthesis Agent related helper (professional advisor utilities, callable from gsd_orchestrator and flows)
+def format_synthesis_risk_for_advisor(risk_map: dict, citation_score: float, trap_risk: str) -> str:
+    """Related helper for strengthened Synthesis: produces concise professional risk paragraph."""
+    ov = (risk_map or {}).get("overall", {}) if isinstance(risk_map, dict) else {}
+    return f"Risk verdict: {ov.get('overall_verdict', 'v5-verified')} | Citation={round(citation_score, 3)} | Kruczkowski={trap_risk} | DQ high | Full V5GroundingCertificate + stages traceability attached."
+
+
+def format_v5_synthesis_law_change_and_cost_signals(cert: Optional[dict], layers: dict, snap: dict) -> str:
+    """v5.0 Production-Ready strengthened helper for Synthesis: surfaces law_change_signal + Cost Catalog + Temporal explicitly.
+    Used to enrich professional reports and V5GroundingCertificate consumption.
+    """
+    law_sig = ""
+    if cert:
+        law_sig = cert.get("metadata", {}).get("law_change_signal", "") or layers.get("law_change_signal", "")
+    if not law_sig and snap:
+        law_sig = snap.get("change_summary", "No recent change per Temporal Graph")
+    cost_cat = (layers.get("cost_catalog", {}) or {}).get("eligible_summary", "Cost eligibility verified via v5 engine + snapshot catalog")
+    temporal = layers.get("temporal", {}) or (cert.metadata.get("temporal") if cert and hasattr(cert, "metadata") else {})
+    return (
+        f"LAW CHANGE SIGNAL (Temporal Graph / SUPERSEDES): {law_sig or 'Stable per latest RegulationVersion'}. "
+        f"COST CATALOG: {cost_cat}. "
+        f"TEMPORAL HISTORY: {temporal.get('timeline_len', 'N/A')} versions | last_change: {temporal.get('last_change', 'current')}. "
+        f"EU SOURCES DEPTH (Funding Portal/TED): award/eligibility/TRL/CPV signals merged into grounding."
+    )
+
+
+def enrich_synthesis_with_eu_sources(synth_out: dict, eu_meta: dict) -> dict:
+    """Helper to inject deeper EU data (Funding Portal award criteria, TRL, TED CPV/notice_type) into Synthesis output for risk-aware reports."""
+    if not eu_meta:
+        return synth_out
+    try:
+        synth_out = synth_out or {}
+        synth_out["eu_sources_depth"] = {
+            "funding_portal_award_criteria": eu_meta.get("award_criteria_detail") or eu_meta.get("award_criteria_present"),
+            "trl_signals": eu_meta.get("trl_signals") or eu_meta.get("trl_range"),
+            "ted_notice_type": (eu_meta.get("ted_metadata") or {}).get("notice_type"),
+            "eligibility_hierarchical": eu_meta.get("eligibility_hierarchical") or eu_meta.get("eligibility"),
+            "cost_catalog_relevant": eu_meta.get("cost_catalog_relevant", False),
+        }
+        if "v5_layers_consumed" in synth_out:
+            synth_out["v5_layers_consumed"]["eu_funding_depth"] = True
+    except Exception:
+        pass
+    return synth_out

backend/agents/holistic_critic.py

@@ -0,0 +1,151 @@
+import time
+from typing import List
+from pydantic import BaseModel, Field
+from core.llm_router import get_llm
+from core.audit_logger import audit_log
+from core.telemetry import telemetry
+
+
+class AssessmentCategory(BaseModel):
+    score: int = Field(description="Ocena w skali od 0 do 100.")
+    feedback: str = Field(description="Krótkie uzasadnienie oceny (2-3 zdania).")
+    xai_justification: str = Field(default="", description="Wyjaśnienie AI (Explainable AI) tłumaczące dlaczego przyznano taki wynik.")
+    inconsistencies_flagged: List[str] = Field(default_factory=list, description="Lista wykrytych niespójności dla danej kategorii.")
+
+
+class HolisticReviewReport(BaseModel):
+    is_approved: bool = Field(
+        description="Czy wniosek wydaje się gotowy do złożenia (brak krytycznych luk logicznych/finansowych)."
+    )
+    dnsh_assessment: AssessmentCategory = Field(
+        description="Ocena zgodności z zasadą Do No Significant Harm (DNSH) i wymogami środowiskowymi."
+    )
+    budget_consistency: AssessmentCategory = Field(
+        description="Spójność opisanego budżetu z celami, innowacją i harmonogramem."
+    )
+    logical_flow: AssessmentCategory = Field(
+        description="Ocena przepływu informacji, braku sprzeczności między poszczególnymi sekcjami."
+    )
+    program_alignment: AssessmentCategory = Field(
+        description="Dopasowanie projektu do specyfiki wybranego programu dotacyjnego."
+    )
+    overall_score: int = Field(
+        description="Średnia lub sumaryczna ocena spójności całego wniosku (0-100)."
+    )
+    cross_check_passed: bool = Field(
+        default=True, description="Czy projekt pomyślnie przeszedł surowy cross-check (budżet vs. harmonogram vs. cele)."
+    )
+    xai_justification_overall: str = Field(
+        default="", description="Globalne wyjaśnienie Explainable AI dla całego projektu."
+    )
+    key_recommendations: List[str] = Field(
+        description="Główne, wysokopoziomowe zalecenia do poprawy całego wniosku."
+    )
+
+
+def holistic_critic_evaluate(
+    project_id: str, full_document: str, program_name: str
+) -> HolisticReviewReport:
+    """
+    Globalny recenzent (Holistic Critic).
+    Ocenia spójność całego wniosku, logikę między sekcjami oraz ogólną jakość.
+    Zwraca szczegółowy Raport Spójności (HolisticReviewReport).
+    """
+    start_time = time.time()
+    telemetry.log(
+        "INFO",
+        "HolisticCritic",
+        "Rozpoczęto analizę Holistic Review",
+        {"project_id": project_id},
+    )
+
+    llm = get_llm(task_type="critical", structured_output_schema=HolisticReviewReport)
+
+    if not full_document or len(full_document.strip()) < 50:
+        telemetry.log(
+            "WARN", "HolisticCritic", "Dokument zbyt krótki", {"project_id": project_id}
+        )
+        return HolisticReviewReport(
+            is_approved=False,
+            dnsh_assessment=AssessmentCategory(score=0, feedback="Brak danych."),
+            budget_consistency=AssessmentCategory(score=0, feedback="Brak danych."),
+            logical_flow=AssessmentCategory(
+                score=0, feedback="Dokument jest zbyt krótki."
+            ),
+            program_alignment=AssessmentCategory(score=0, feedback="Brak danych."),
+            overall_score=0,
+            cross_check_passed=False,
+            xai_justification_overall="Zbyt mało danych do weryfikacji. Wymagane wygenerowanie treści.",
+            key_recommendations=["Wygeneruj najpierw sekcje wniosku."],
+        )
+
+    prompt = f"""
+Jesteś Bezwzględnym i Surowym Głównym Audytorem ds. Spójności Wniosków Unijnych (Holistic Critic).
+Twoim zadaniem jest ocena CAŁEGO wygenerowanego dotąd dokumentu "z lotu ptaka" pod kątem:
+1. DNSH (Do No Significant Harm) – wpływ na środowisko.
+2. Spójności Budżetu – CZY koszty mają sens w kontekście innowacji i celów. Wymagany rygorystyczny CROSS-CHECK (np. czy to, co jest w harmonogramie, znajduje odzwierciedlenie w budżecie).
+3. Logiki Projektu (Flow) – czy wniosek tworzy jedną narrację bez sprzeczności.
+4. Zgodności z programem: "{program_name}".
+
+Zwróć precyzyjną, surową, ale konstruktywną ocenę. 
+Zastosuj RIGOROUS SCORING: Wymagaj solidnych dowodów w dokumencie. Jeśli są braki, obniż punktację rygorystycznie.
+Zastosuj podejście EXPLAINABLE AI (XAI): Każda ocena musi mieć precyzyjne wyjaśnienie w polach xai_justification. Wyjaśnij dokładnie, z czego wynika dana ocena, wskazując na elementy dokumentu.
+Zidentyfikowane luki lub sprzeczności wypisuj zawsze w inconsistencies_flagged.
+
+UWAGA KRYTYCZNA: Analizuj WYŁĄCZNIE wniosek o dofinansowanie / projekt grantowy. Jeśli treść dokumentu nie dotyczy wniosku (np. artykuł, transkrypt wideo, treść marketingowa), ustaw is_approved=false, overall_score<=20 i w xai_justification_overall wyjaśnij, że dokument jest nieprawidłowy dla analizy wniosku.
+
+UWAGA KRYTYCZNA: Zwróć szczególną uwagę na tagi [UZUPEŁNIĆ: ...], [DO WERYFIKACJI: ...] lub braki danych. Oznaczają one, że wniosek JEST NIEKOMPLETNY. 
+Jeśli znajdziesz jakiekolwiek braki danych, `is_approved` MUSI być ustawione na false, a odpowiednie kategorie (np. logic_flow, budget_consistency) oraz `overall_score` muszą zostać DRASTYCZNIE obniżone (np. max 50-60 punktów na 100), dopóki użytkownik nie uzupełni danych. W przypadku niespójności krzyżowych ustaw cross_check_passed na False. Nie udawaj, że wniosek jest spójny, jeśli brakuje w nim kluczowych informacji biznesowych!
+
+Odpowiadaj ZAWSZE I WYŁĄCZNIE w języku polskim, używając precyzyjnego i urzędowego języka.
+
+Dokument do oceny:
+---------------------
+{full_document[:150000]}
+---------------------
+    """
+
+    try:
+        report: HolisticReviewReport = llm.invoke(prompt)
+        exec_time = round((time.time() - start_time) * 1000)
+
+        telemetry.log(
+            "INFO",
+            "HolisticCritic",
+            f"Zakończono Holistic Review (Score: {report.overall_score})",
+            {
+                "project_id": project_id,
+                "latency_ms": exec_time,
+                "is_approved": report.is_approved,
+            },
+        )
+
+        try:
+            audit_log(
+                "HOLISTIC_CRITIC",
+                f"Zakończono ocenę globalną. Zatwierdzony: {report.is_approved}, Score: {report.overall_score}",
+            )
+        except Exception:
+            pass
+
+        return report
+
+    except Exception as e:
+        exec_time = round((time.time() - start_time) * 1000)
+        telemetry.log(
+            "ERROR",
+            "HolisticCritic",
+            f"Błąd wykonania: {str(e)}",
+            {"project_id": project_id, "latency_ms": exec_time},
+        )
+        return HolisticReviewReport(
+            is_approved=False,
+            dnsh_assessment=AssessmentCategory(score=0, feedback="Błąd analizy AI."),
+            budget_consistency=AssessmentCategory(score=0, feedback="Błąd analizy AI."),
+            logical_flow=AssessmentCategory(score=0, feedback=f"Błąd: {str(e)}"),
+            program_alignment=AssessmentCategory(score=0, feedback="Błąd analizy AI."),
+            overall_score=0,
+            cross_check_passed=False,
+            xai_justification_overall="Błąd systemowy podczas generowania oceny.",
+            key_recommendations=["Spróbuj ponownie wygenerować raport spójności."],
+        )

backend/agents/matcher.py

@@ -0,0 +1,246 @@
+# ruff: noqa: E402
+import logging
+from typing import Dict, Any
+from langchain_core.messages import SystemMessage, HumanMessage
+from schemas import AgentState
+
+logger = logging.getLogger(__name__)
+
+from schemas import MatchOutput
+from core.llm_router import get_llm
+from tenacity import retry, stop_after_attempt, wait_exponential
+
+try:
+    from core.search.regulation_engine import citation_verifier, kruczkowski_trap_agent
+except Exception:
+    citation_verifier = None
+    kruczkowski_trap_agent = None
+
+
+def _empty_matcher_response(reason: str) -> Dict[str, Any]:
+    return {
+        "current_agent": "supervisor",
+        "eligible_grants": [],
+        "messages": [
+            {
+                "role": "assistant",
+                "content": reason,
+            }
+        ],
+    }
+
+
+def matcher_node(state: Any) -> Dict[str, Any]:
+    """
+    Węzeł sprawdzający dopasowanie każdego z wyszukanych naborów do profilu firmy.
+    """
+    try:
+        if isinstance(state, dict):
+            state = AgentState(**state)
+    except Exception as e:
+        logger.error(f"Błąd inicjalizacji stanu w matcher_node: {e}")
+        return _empty_matcher_response("Błąd stanu agenta dopasowania — przekazuję do supervisora.")
+
+    profile = state.profile
+    grants = state.eligible_grants
+
+    if not profile:
+        return _empty_matcher_response(
+            "Matcher AI: brak profilu firmy (NIP, PKD, wielkość). Uzupełnij dane w projekcie."
+        )
+
+    if not grants:
+        return _empty_matcher_response(
+            "Matcher AI: brak programów do oceny. Researcher nie zwrócił naborów — "
+            "sprawdź import katalogu WYSZUKIWARKA lub odśwież bazę naborów."
+        )
+
+    company_label = profile.name or f"NIP {profile.nip}"
+    company_desc = f"Firma {company_label}"
+    if profile.name and profile.nip:
+        company_desc += f" (NIP {profile.nip})"
+    company_desc += f", branża: {', '.join(profile.pkd_codes)}, wielkość: {profile.size}. "
+    if profile.innovation_focus:
+        company_desc += (
+            f"Skupienie na innowacjach: {', '.join(profile.innovation_focus)}. "
+        )
+    if profile.investment_plans:
+        plans = ", ".join([p.description for p in profile.investment_plans])
+        company_desc += f"Plany inwestycyjne: {plans}."
+
+    logger.info(
+        "Matcher uruchomiony dla %s znalezisk dla %s",
+        len(grants),
+        profile.name or profile.nip,
+    )
+
+    from agents.helpers import ANTI_HALLUCINATION_PROMPT
+
+    system_prompt = (
+        ANTI_HALLUCINATION_PROMPT + "\n\n"
+        "Jesteś analitykiem ds. dotacji o zacięciu wirtualnego poety funduszowego. "
+        "Twoim zadaniem jest ocena dopasowania dotacji do profilu firmy. "
+        "TWARDE REGUŁY ODRZUCENIA (zawsze score = 0):\n"
+        "1. Wielkość przedsiębiorstwa: Jeśli firma to 'Duża', z definicji odrzucaj wszystkie programy przeznaczone WYŁĄCZNIE dla 'MŚP' (Mikro, Małe, Średnie).\n"
+        "2. Kody PKD: Jeśli branża w profilu (np. usługi IT) drastycznie różni się od celu programu (np. rolnictwo), z definicji odrzucaj.\n"
+        "3. Terminy: NIE wymyślaj dat zakończenia naboru. Jeśli w danych jest 'Brak potwierdzonego terminu' — nie podawaj 31.12 ani liczby dni.\n\n"
+        "Dla każdej podanej dotacji i firmy oceń procentowe dopasowanie (relevance_score od 0 do 1), "
+        "napisz jedno zwięzłe zdanie (poetic_match) po polsku opisujące to dopasowanie oraz podaj wyjaśnienie (explanation), "
+        "które logicznie uzasadnia tę ocenę: krótki powód (reason), kluczowe wspierające kryteria (criteria) "
+        "oraz ewentualne ryzyka/twarde warunki (risks). Odpowiadaj ZAWSZE I WYŁĄCZNIE w języku polskim."
+    )
+
+    updated_grants = []
+    grants_to_eval = []
+    company_pkd_prefixes = [p[:2] for p in profile.pkd_codes] if profile.pkd_codes else []
+
+    from core.date_utils import is_grant_active
+
+    for grant in grants:
+        grant_text_lower = f"{grant.title} {grant.description}".lower()
+
+        # === TWARDY FILTR DETERMINISTYCZNY (przed LLM) ===
+        # Odrzucaj nabory po terminie lub jawnie zamknięte na podstawie pól strukturalnych.
+        deadline_val = getattr(grant, "deadline", "") or ""
+        status_val = (getattr(grant, "status", "") or "").lower()
+        if (deadline_val and not is_grant_active(deadline_val)) or status_val == "closed" or getattr(grant, "is_outdated_warning", False):
+            grant.relevance_score = 0.0
+            grant.poetic_match = "Odrzucono: nabór po terminie lub zamknięty."
+            grant.explanation = {
+                "reason": "Przeterminowany termin naboru lub status zamknięty",
+                "criteria": [],
+                "risks": f"Termin: {deadline_val or 'brak'} | Status: {status_val or 'nieznany'}",
+            }
+            updated_grants.append(grant)
+            continue
+
+        if profile.size and profile.size.lower() == "duża":
+            if "tylko dla mśp" in grant_text_lower or "wyłącznie dla sektora mśp" in grant_text_lower:
+                grant.relevance_score = 0.0
+                grant.poetic_match = "Odrzucono: Program wyklucza duże firmy (tylko MŚP)."
+                grant.explanation = {
+                    "reason": "Niezgodność wielkości firmy (Duża vs MŚP)",
+                    "criteria": [],
+                    "risks": "Program przeznaczony wyłącznie dla MŚP",
+                }
+                updated_grants.append(grant)
+                continue
+
+        if company_pkd_prefixes:
+            is_agri_grant = any(kw in grant_text_lower for kw in ["rolnictwo", "produkcja rolna", "hodowla", "arimr"])
+            is_agri_company = any(p in ["01", "02"] for p in company_pkd_prefixes)
+
+            if is_agri_grant and not is_agri_company:
+                grant.relevance_score = 0.0
+                grant.poetic_match = "Odrzucono: Brak działalności rolniczej (PKD)."
+                grant.explanation = {
+                    "reason": "Niezgodność branży (Program rolniczy)",
+                    "criteria": [],
+                    "risks": "Wymagane PKD z sekcji rolniczej",
+                }
+                updated_grants.append(grant)
+                continue
+
+        if grant.poetic_match and grant.relevance_score > 0 and grant.explanation:
+            updated_grants.append(grant)
+        else:
+            grants_to_eval.append(grant)
+
+    if not grants_to_eval:
+        return {"eligible_grants": updated_grants, "current_agent": "supervisor"}
+
+    system_msgs = [SystemMessage(content=system_prompt) for _ in grants_to_eval]
+    human_msgs = [
+        HumanMessage(
+            content=(
+                f"Profil Firmy: {company_desc}\n"
+                f"Nabór: {grant.title}\n"
+                f"Instytucja: {getattr(grant, 'institution', '') or 'N/A'}\n"
+                f"Opis Naboru: {grant.description}\n\n"
+                "Zwróć wynik dopasowania uwzględniając strukturę MatchOutput."
+            )
+        )
+        for grant in grants_to_eval
+    ]
+
+    messages_batch = [[s, h] for s, h in zip(system_msgs, human_msgs)]
+
+    try:
+        llm = get_llm(task_type="standard", structured_output_schema=MatchOutput)
+        results = llm.batch(messages_batch, config={"max_concurrency": 3})
+
+        for grant, parsed in zip(grants_to_eval, results):
+            if isinstance(parsed, dict):
+                grant.relevance_score = parsed.get("relevance_score", 0.0)
+                grant.poetic_match = parsed.get("poetic_match", "")
+                grant.explanation = parsed.get("explanation")
+            else:
+                grant.relevance_score = getattr(parsed, "relevance_score", 0.0)
+                grant.poetic_match = getattr(parsed, "poetic_match", "")
+                if getattr(parsed, "explanation", None):
+                    grant.explanation = parsed.explanation.dict() if hasattr(parsed.explanation, "dict") else parsed.explanation
+            updated_grants.append(grant)
+
+    except Exception as e:
+        logger.error(f"Błąd LLM w operacji matcher_node (wieloprocesowej): {e}. Próba wykonania sekwencyjnego...")
+
+        @retry(stop=stop_after_attempt(3), wait=wait_exponential(multiplier=1, min=2, max=10))
+        def _invoke_with_retry(msg):
+            res = llm.invoke(msg)
+            score = res.get("relevance_score", getattr(res, "relevance_score", -1)) if isinstance(res, dict) else getattr(res, "relevance_score", -1)
+            if not (0 <= score <= 1):
+                raise ValueError("Relevance score out of bounds.")
+            return res
+
+        for i, grant in enumerate(grants_to_eval):
+            try:
+                parsed = _invoke_with_retry(messages_batch[i])
+                if isinstance(parsed, dict):
+                    grant.relevance_score = parsed.get("relevance_score", 0.0)
+                    grant.poetic_match = parsed.get("poetic_match", "")
+                    grant.explanation = parsed.get("explanation")
+                else:
+                    grant.relevance_score = getattr(parsed, "relevance_score", 0.0)
+                    grant.poetic_match = getattr(parsed, "poetic_match", "")
+                    if getattr(parsed, "explanation", None):
+                        grant.explanation = parsed.explanation.dict() if hasattr(parsed.explanation, "dict") else parsed.explanation
+                updated_grants.append(grant)
+            except Exception as seq_err:
+                logger.error(f"Błąd sekwencyjny dla grantu {grant.title}: {seq_err}")
+                grant.relevance_score = 0.0
+                grant.poetic_match = "Błąd dopasowania."
+                grant.explanation = {
+                    "reason": "Błąd LLM (fallback sekwencyjny)",
+                    "criteria": [],
+                    "risks": "Nie udało się zweryfikować",
+                }
+                updated_grants.append(grant)
+
+    try:
+        if citation_verifier or kruczkowski_trap_agent:
+            for i, g in enumerate(updated_grants[:5]):
+                try:
+                    gtxt = f"{getattr(g, 'title', '') or (g.get('name','') if isinstance(g,dict) else '')} {getattr(g,'description','') or ''}"
+                    prog = getattr(g, 'program', None) or (g.get('program') if isinstance(g, dict) else None) or "UNKNOWN"
+                    if citation_verifier:
+                        cit = citation_verifier.verify_text_citations(gtxt[:1200], prog)
+                        if isinstance(g, dict):
+                            g["v5_citation_score"] = cit.get("overall_citation_score")
+                            g["v5_hard_refs"] = cit.get("hard_regulation_refs_extracted", [])[:3]
+                        else:
+                            setattr(g, "v5_citation_score", cit.get("overall_citation_score"))
+                    if kruczkowski_trap_agent:
+                        tr = kruczkowski_trap_agent.detect_traps(gtxt[:1200], prog)
+                        risk = tr.get("overall_trap_risk", "low")
+                        if isinstance(g, dict):
+                            g["v5_trap_risk"] = risk
+                        else:
+                            setattr(g, "v5_trap_risk", risk)
+                    if isinstance(g, dict) and "is_current_only" not in g:
+                        g["is_current_only"] = (g.get("status") in ("active","planned") and not g.get("is_outdated_warning"))
+                except Exception:
+                    pass
+    except Exception:
+        pass
+
+    return {"eligible_grants": updated_grants, "current_agent": "supervisor"}

backend/agents/panel_nodes.py

@@ -0,0 +1,562 @@
+from typing import Dict, Any
+from langchain_core.messages import HumanMessage, ToolMessage, SystemMessage, AIMessage
+from core.llm_router import get_llm
+from core.search.regulation_engine import regulation_engine, kruczkowski_trap_agent
+from core.trust.trust_scorer import compute_grant_trust_score
+
+from agents.auditor import (
+    GlobalAuditOutput,
+    _PerspectiveResult,
+    _ROLE_PROMPTS,
+    _SHARED_INSTRUCTIONS,
+)
+from agents.tools.legal_retriever_tool import search_legal_documents
+from agents.tools.krs_graph_tool import analyze_company_network
+from agents.tools.neo4j_cypher_tool import query_neo4j_graph
+from agents.tools.budget_rules_tool import search_budget_rules
+from agents.tools.technology_retriever_tool import search_technology_trends
+from agents.panel_state import AuditorPanelState
+
+import logging
+
+logger = logging.getLogger(__name__)
+
+# --- PRAWNIK NODE (Dynamic Query Routing) ---
+
+
+def prawnik_node(state: AuditorPanelState) -> Dict[str, Any]:
+    """Agent Prawny z obsługą poszukiwań w RAG oraz RAG Grafowym (KRS)."""
+    llm_with_tools = get_llm(
+        task_type="legal_audit",
+        tools=[search_legal_documents, analyze_company_network, query_neo4j_graph],
+    )
+
+    # Inicjalizacja wiadomości, jeśli pierwsze wywołanie
+    messages = state.get("messages", [])
+    initial_messages_added = []
+    if not messages:
+        ext_prompt = (
+            "Zewnętrzny Rewizor: Weryfikujesz cudzy, gotowy wniosek (z biura konsultingowego) przesłany do nas w celu tzw. Reverse-Audit. Nastaw się na bezlitosną weryfikację błędów."
+            if state.get("is_external_audit", False)
+            else ""
+        )
+        sys_prompt = f"{_ROLE_PROMPTS['prawnik']}\n{ext_prompt}\n{_SHARED_INSTRUCTIONS}\n\nProgram: {state['program_name']}\nZanim ocenisz, zawsze skorzystaj z narzędzia search_legal_documents, aby sprawdzić wymogi dla perspektywy {state['program_name']}. Jeśli nie znajdziesz nic lub perspektywa nie będzie się zgadzać, PONÓW WYSZUKIWANIE z innym zapytaniem. Jak jesteś gotowy wydać ocenę wywołaj narzędzie submit_evaluation, NIE generuj go jako plain text."
+        initial_messages_added.append(SystemMessage(content=sys_prompt))
+        initial_messages_added.append(
+            HumanMessage(content=f"TREŚĆ WNIOSKU:\n{state['content'][:150000]}")
+        )
+        messages = initial_messages_added
+
+    # Wywołanie modelu
+    try:
+        response = llm_with_tools.invoke(messages)
+    except Exception as e:
+        logger.error(f"[PRAWNIK] Błąd wywołania modelu: {e}")
+        response = AIMessage(
+            content=f"Wystąpił błąd podczas wywołania LLM: {e}. Przechodzę do podsumowania."
+        )
+
+    return {
+        "messages": initial_messages_added + [response],
+        "legal_attempts": state.get("legal_attempts", 0),
+    }
+
+
+def prawnik_tools_node(state: AuditorPanelState) -> Dict[str, Any]:
+    """Uruchamia narzędzie wyszukiwania dla Prawnika."""
+    last_message = state["messages"][-1]
+    tool_messages = []
+
+    for tool_call in last_message.tool_calls:
+        if tool_call["name"] in [
+            "search_legal_documents",
+            "analyze_company_network",
+            "query_neo4j_graph",
+        ]:
+            logger.info(
+                f"[PRAWNIK] Wykorzystanie narzędzia {tool_call['name']}: {tool_call['args']}"
+            )
+            # Bezpieczne wykonanie narzędzia
+            try:
+                if tool_call["name"] == "search_legal_documents":
+                    result = search_legal_documents.invoke(tool_call["args"])
+                elif tool_call["name"] == "analyze_company_network":
+                    result = analyze_company_network.invoke(tool_call["args"])
+                else:
+                    result = query_neo4j_graph.invoke(tool_call["args"])
+            except Exception as e:
+                result = f"Błąd wykonania narzędzia: {e}"
+            tool_messages.append(
+                ToolMessage(content=result, tool_call_id=tool_call["id"])
+            )
+
+    return {
+        "messages": tool_messages,
+        "legal_attempts": state.get("legal_attempts", 0) + 1,
+        "legal_queries": [str(tc["args"]) for tc in last_message.tool_calls],
+    }
+
+
+def prawnik_evaluator_node(state: AuditorPanelState) -> Dict[str, Any]:
+    """Generuje ostateczny Pydantic output Prawnika po zebraniu wiedzy z RAG."""
+    # Ekstrakcja do schematu
+    llm = get_llm(task_type="legal_audit", structured_output_schema=_PerspectiveResult)
+
+    # Przebieg całej konwersacji prawnika
+    conversation_text = "\n".join(
+        [m.content for m in state["messages"] if isinstance(m.content, str)]
+    )
+
+    # Aktywne użycie silnika w Prawniku (Faza 3) - nie tylko kontekst, ale weryfikacja
+    engine_rules = ""
+    engine_compliance_check = ""
+    trust_context = ""
+    try:
+        rules = regulation_engine.get_structured_rules_for_program(state['program_name'] or "")
+        if rules:
+            engine_rules = "\n\n--- STRUCTURED RULES FROM REGULATION ENGINE (traktuj jako źródło prawdy) ---\n"
+            engine_rules += "\n".join(rules.get("key_rules", [])[:7])
+
+            # Aktywna weryfikacja + wpływ na wynik (Faza 3)
+            compliance = regulation_engine.check_cost_eligibility(state['program_name'] or "", state['content'][:3000])
+            if compliance.get("status") == "evaluated":
+                engine_compliance_check = f"\n\n--- REGULATION ENGINE COMPLIANCE CHECK ---\n{compliance}"
+                if compliance.get("severity") == "critical":
+                    engine_compliance_check += "\n[CRITICAL ISSUE - RECOMMEND BLOCKING EXPORT OR HUMAN REVIEW]"
+                    # Dodajemy issue bezpośrednio do wyniku (zostanie scalone w ewaluatorze)
+
+            # v5.0: Kruczkowski Compliance & Trap + Citation Verifier integration (Faza 2/3)
+            try:
+                if kruczkowski_trap_agent:
+                    trap_result = kruczkowski_trap_agent.detect_traps(
+                        document_text=state['content'][:4500],
+                        program=state['program_name'] or "",
+                        msp_context=state.get("msp_analysis") or state.get("external_context", {}).get("msp_analysis")
+                    )
+                    if trap_result.get("overall_trap_risk") in ("high", "critical"):
+                        engine_compliance_check += f"\n\n--- KRUCZKOWSKI COMPLIANCE & TRAP v5.0 ---\nRisk: {trap_result['overall_trap_risk']} | Traps: {trap_result['num_traps']} | Blocks export: {trap_result.get('blocks_export_recommendation')}\nCitation score: {trap_result.get('citation_verification', {}).get('overall_citation_score')}\n[STRICT MODE: Zalecane dodatkowe sprawdzenie przez człowieka]"
+                    # Zawsze wstrzykujemy citation grounding info
+                    cit = trap_result.get("citation_verification", {})
+                    if cit.get("overall_citation_score"):
+                        engine_compliance_check += f"\n[CITATION GROUNDING: {cit.get('overall_citation_score')} ({cit.get('citation_quality')}) — {cit.get('recommendation', '')[:120]}]"
+            except Exception as _trap_e:
+                logger.debug(f"[Prawnik v5.0] Trap agent skipped: {_trap_e}")
+
+        # Trust Score injection (Cycle 10)
+        trust_score = compute_grant_trust_score({"program": state.get('program_name')})
+        trust_context = f"\n\n[Trust Score dla programu: {trust_score}/100 — im niższy, tym ostrożniej podchodzić do wniosków i rekomendacji]"
+    except Exception:
+        pass
+
+    prompt = f"""
+    Na podstawie zebranych dotychczas informacji i analizy (patrz historia, upewnij się, że opierasz się na zweryfikowanym prawie z narzędzia):
+    {conversation_text}
+    {engine_rules}
+    {engine_compliance_check}
+    {trust_context}
+    
+    Wygeneruj ostateczny wynik audytu prawnego dla wniosku ({state['program_name']}) wg struktury.
+    Oceń projekt. Role: prawnik.
+    TREŚĆ:
+    {state['content'][:150000]}
+    """
+
+    from tenacity import retry, stop_after_attempt, wait_exponential
+
+    @retry(
+        stop=stop_after_attempt(5),
+        wait=wait_exponential(multiplier=1, min=2, max=10),
+        reraise=True,
+    )
+    def invoke_eval():
+        result: _PerspectiveResult = llm.invoke(prompt)
+        if not result.summary or len(result.summary.strip()) < 10:
+            raise ValueError("Błąd sanity check: Puste podsumowanie audytu prawnego.")
+        for issue in result.issues:
+            issue.perspective = "prawnik"
+
+        # Jeśli silnik wykrył critical problem — obniżamy score
+        if "CRITICAL ISSUE" in engine_compliance_check:
+            result.partial_score = max(0, result.partial_score - 30)
+
+        return {
+            "issues": result.issues,
+            "perspectives_summary": {"prawnik": result.summary},
+            "perspective_scores": [result.partial_score],
+            "prawnik_done": True,
+        }
+
+    try:
+        return invoke_eval()
+    except Exception as e:
+        logger.error(f"[PRAWNIK] Ostateczny błąd ewaluatora: {e}")
+        return {
+            "prawnik_done": True,
+            "perspectives_summary": {
+                "prawnik": f"Błąd audytu prawnego po 5 próbach: {e}"
+            },
+        }
+
+
+def prawnik_routing(state: AuditorPanelState) -> str:
+    """Decyduje czy prawnik musi szukać dalej, oceniać czy przekroczył limit."""
+    last_message = state["messages"][-1]
+
+    if last_message.tool_calls:
+        if state["legal_attempts"] >= 3:
+            logger.warning(
+                "[PRAWNIK] Przekroczono limit wyszukiwań, wymuszam ewaluację."
+            )
+            return "evaluate"
+        return "tools"
+
+    return "evaluate"
+
+
+# --- FINANSISTA NODE (Dynamic Query Routing) ---
+
+
+def finansista_node(state: AuditorPanelState) -> Dict[str, Any]:
+    """Agent Finansowy z obsługą poszukiwań w RAG (regulaminy finansowe)."""
+    llm_with_tools = get_llm(
+        task_type="legal_audit",
+        tools=[search_budget_rules, analyze_company_network, query_neo4j_graph],
+    )
+
+    # Inicjalizacja wiadomości, jeśli pierwsze wywołanie
+    messages = state.get("finansista_messages", [])
+    initial_messages_added = []
+    if not messages:
+        ext_prompt = (
+            "Zewnętrzny Rewizor: Weryfikujesz cudzy, gotowy wniosek (z biura konsultingowego) przesłany do nas w celu tzw. Reverse-Audit."
+            if state.get("is_external_audit", False)
+            else ""
+        )
+        sys_prompt = f"{_ROLE_PROMPTS['finansista']}\n{ext_prompt}\n{_SHARED_INSTRUCTIONS}\n\nProgram: {state['program_name']}\nZanim ocenisz wniosek, używaj narzędzia search_budget_rules aby sprawdzić zasady z budżetu programu. Aby zweryfikować MŚP z perspektywy finansowej na podstawie NIP/KRS uzyj analyze_company_network. Gdy będziesz gotowy zwrócić ocenę bez korzystania z narzędzia, powróć i wykonaj finalną ocenę strukturyzowaną."
+        initial_messages_added.append(SystemMessage(content=sys_prompt))
+        initial_messages_added.append(
+            HumanMessage(content=f"TREŚĆ WNIOSKU:\n{state['content'][:150000]}")
+        )
+        messages = initial_messages_added
+
+    try:
+        response = llm_with_tools.invoke(messages)
+    except Exception as e:
+        logger.error(f"[FINANSISTA] Błąd wywołania modelu: {e}")
+        response = AIMessage(
+            content=f"Wystąpił błąd podczas wywołania LLM: {e}. Przechodzę do podsumowania."
+        )
+
+    return {
+        "finansista_messages": initial_messages_added + [response],
+        "finansista_attempts": state.get("finansista_attempts", 0),
+    }
+
+
+def finansista_tools_node(state: AuditorPanelState) -> Dict[str, Any]:
+    """Uruchamia narzędzie wyszukiwania dla Finansisty."""
+    last_message = state["finansista_messages"][-1]
+    tool_messages = []
+
+    for tool_call in last_message.tool_calls:
+        if tool_call["name"] in [
+            "search_budget_rules",
+            "analyze_company_network",
+            "query_neo4j_graph",
+        ]:
+            logger.info(
+                f"[FINANSISTA] Wykorzystanie narzędzia {tool_call['name']}: {tool_call['args']}"
+            )
+            try:
+                if tool_call["name"] == "search_budget_rules":
+                    result = search_budget_rules.invoke(tool_call["args"])
+                elif tool_call["name"] == "analyze_company_network":
+                    result = analyze_company_network.invoke(tool_call["args"])
+                else:
+                    result = query_neo4j_graph.invoke(tool_call["args"])
+            except Exception as e:
+                result = f"Błąd wykonania narzędzia: {e}"
+            tool_messages.append(
+                ToolMessage(content=result, tool_call_id=tool_call["id"])
+            )
+
+    return {
+        "finansista_messages": tool_messages,
+        "finansista_attempts": state.get("finansista_attempts", 0) + 1,
+        "finansista_queries": [str(tc["args"]) for tc in last_message.tool_calls],
+    }
+
+
+def finansista_evaluator_node(state: AuditorPanelState) -> Dict[str, Any]:
+    """Generuje ostateczny Pydantic output Finansisty po zebraniu wiedzy z RAG."""
+    llm = get_llm(task_type="legal_audit", structured_output_schema=_PerspectiveResult)
+    conversation_text = "\n".join(
+        [
+            m.content
+            for m in state.get("finansista_messages", [])
+            if isinstance(m.content, str)
+        ]
+    )
+
+    # Aktywne użycie RegulationEngine przy analizie budżetowej (Faza 3)
+    engine_context = ""
+    trust_context = ""
+    try:
+        eligibility = regulation_engine.check_cost_eligibility(state.get('program_name') or "", state.get('content', '')[:2000])
+        if eligibility.get("status") == "evaluated":
+            engine_context = f"\n\nREGULATION ENGINE BUDGET CHECK (źródło prawdy):\n  eligible={eligibility.get('eligible')} severity={eligibility.get('severity')}\n  justification: {eligibility.get('justification','')}\n  reference: {eligibility.get('regulation_reference','')}\n  rec: {eligibility.get('recommendation','')}\n"
+
+        # v5.0 Citation + Kruczkowski for finansista (budget traps)
+        try:
+            if kruczkowski_trap_agent:
+                t = kruczkowski_trap_agent.detect_traps(state.get('content', '')[:3000], state.get('program_name') or "")
+                if t.get("citation_verification"):
+                    c = t["citation_verification"]
+                    engine_context += f"\n[CITATION GROUNDING (fin): {c.get('overall_citation_score')} / {c.get('citation_quality')}]"
+                if t.get("overall_trap_risk") in ("high", "critical"):
+                    engine_context += f"\n[KRUCZKOWSKI BUDGET TRAPS: {t.get('num_traps')} — {t.get('overall_trap_risk')}]"
+        except Exception:
+            pass
+
+        # Trust Score injection (Cycle 10) — teraz z citation boost z v5.0
+        trust_score = compute_grant_trust_score({
+            "program": state.get('program_name'),
+            "citation_verification_score": (t.get("citation_verification", {}).get("overall_citation_score") if 't' in locals() else None)
+        })
+        trust_context = f"\n\n[Trust Score dla programu: {trust_score}/100 — niski score = wyższe ryzyko w rekomendacjach finansowych]"
+    except Exception:
+        pass
+
+    prompt = f"""
+    Na podstawie zebranych dotychczas informacji i analizy finansowej/budżetowej (patrz historia):
+    {conversation_text}
+    {engine_context}
+    {trust_context}
+    
+    Wygeneruj ostateczny wynik audytu finansowego dla wniosku ({state['program_name']}) wg struktury.
+    Oceń projekt. Role: finansista.
+    TREŚĆ:
+    {state['content'][:150000]}
+    """
+    from tenacity import retry, stop_after_attempt, wait_exponential
+
+    @retry(
+        stop=stop_after_attempt(5),
+        wait=wait_exponential(multiplier=1, min=2, max=10),
+        reraise=True,
+    )
+    def invoke_eval():
+        result: _PerspectiveResult = llm.invoke(prompt)
+        if not result.summary or len(result.summary.strip()) < 10:
+            raise ValueError(
+                "Błąd sanity check: Puste podsumowanie audytu finansowego."
+            )
+        for issue in result.issues:
+            issue.perspective = "finansista"
+        return {
+            "issues": result.issues,
+            "perspectives_summary": {"finansista": result.summary},
+            "perspective_scores": [result.partial_score],
+            "finansista_done": True,
+        }
+
+    try:
+        return invoke_eval()
+    except Exception as e:
+        logger.error(f"[FINANSISTA] Ostateczny błąd ewaluatora: {e}")
+        return {
+            "finansista_done": True,
+            "perspectives_summary": {
+                "finansista": f"Błąd audytu finansowego po 5 próbach: {e}"
+            },
+        }
+
+
+def finansista_routing(state: AuditorPanelState) -> str:
+    """Decyduje czy finansista musi szukać dalej, czy oceniać."""
+    last_message = state["finansista_messages"][-1]
+    if last_message.tool_calls:
+        if state.get("finansista_attempts", 0) >= 3:
+            logger.warning(
+                "[FINANSISTA] Przekroczono limit wyszukiwań, wymuszam ewaluację."
+            )
+            return "evaluate"
+        return "tools"
+    return "evaluate"
+
+
+# --- INNOWATOR NODE (Dynamic Query Routing) ---
+def innowator_node(state: AuditorPanelState) -> Dict[str, Any]:
+    """Agent Technologiczny (Innowator) z obsługą poszukiwań w RAG (trendy, KIS, B+R)."""
+    llm_with_tools = get_llm(task_type="legal_audit", tools=[search_technology_trends])
+
+    messages = state.get("innowator_messages", [])
+    initial_messages_added = []
+    if not messages:
+        ext_prompt = (
+            "Zewnętrzny Rewizor: Weryfikujesz cudzy, gotowy wniosek (z biura konsultingowego) przesłany do nas w celu tzw. Reverse-Audit."
+            if state.get("is_external_audit", False)
+            else ""
+        )
+        sys_prompt = f"{_ROLE_PROMPTS['innowator']}\n{ext_prompt}\n{_SHARED_INSTRUCTIONS}\n\nProgram: {state['program_name']}\nZanim dokonasz oceny innowacyjności, użyj narzędzia search_technology_trends, aby zweryfikować czy technologia, poziom TRL lub KIS są poprawne dla tego programu. Kiedy będziesz gotowy zwrócić ocenę, powróć i wykonaj finalną ocenę strukturyzowaną."
+        initial_messages_added.append(SystemMessage(content=sys_prompt))
+        initial_messages_added.append(
+            HumanMessage(content=f"TREŚĆ WNIOSKU:\n{state['content'][:150000]}")
+        )
+        messages = initial_messages_added
+
+    try:
+        response = llm_with_tools.invoke(messages)
+    except Exception as e:
+        logger.error(f"[INNOWATOR] Błąd wywołania modelu: {e}")
+        response = AIMessage(
+            content=f"Wystąpił błąd podczas wywołania LLM: {e}. Przechodzę do podsumowania."
+        )
+
+    return {
+        "innowator_messages": initial_messages_added + [response],
+        "innowator_attempts": state.get("innowator_attempts", 0),
+    }
+
+
+def innowator_tools_node(state: AuditorPanelState) -> Dict[str, Any]:
+    """Uruchamia narzędzie wyszukiwania dla Innowatora."""
+    last_message = state["innowator_messages"][-1]
+    tool_messages = []
+
+    for tool_call in last_message.tool_calls:
+        if tool_call["name"] == "search_technology_trends":
+            logger.info(
+                f"[INNOWATOR] Wykorzystanie narzędzia {tool_call['name']}: {tool_call['args']}"
+            )
+            try:
+                result = search_technology_trends.invoke(tool_call["args"])
+            except Exception as e:
+                result = f"Błąd wykonania narzędzia: {e}"
+            tool_messages.append(
+                ToolMessage(content=result, tool_call_id=tool_call["id"])
+            )
+
+    return {
+        "innowator_messages": tool_messages,
+        "innowator_attempts": state.get("innowator_attempts", 0) + 1,
+        "innowator_queries": [str(tc["args"]) for tc in last_message.tool_calls],
+    }
+
+
+def innowator_evaluator_node(state: AuditorPanelState) -> Dict[str, Any]:
+    """Generuje ostateczny Pydantic output Innowatora po zebraniu wiedzy z RAG."""
+    llm = get_llm(task_type="legal_audit", structured_output_schema=_PerspectiveResult)
+    conversation_text = "\n".join(
+        [
+            m.content
+            for m in state.get("innowator_messages", [])
+            if isinstance(m.content, str)
+        ]
+    )
+
+    # Aktywne użycie RegulationEngine również w perspektywie innowacyjnej (Faza 3)
+    engine_context = ""
+    trust_context = ""
+    try:
+        rules = regulation_engine.get_structured_rules_for_program(state.get('program_name') or "")
+        if rules and (rules.get("key_rules") or rules.get("scoring_criteria")):
+            engine_context = "\n\n--- STRUCTURED PROGRAM RULES (Regulation Engine) — upewnij się, że innowacyjność jest zgodna z celami i kryteriami programu:\n"
+            engine_context += "KEY RULES: " + "; ".join((rules.get("key_rules") or [])[:4])
+            engine_context += "\nSCORING: " + "; ".join((rules.get("scoring_criteria") or [])[:3])
+
+        # Trust Score injection (Cycle 10)
+        trust_score = compute_grant_trust_score({"program": state.get('program_name')})
+        trust_context = f"\n\n[Trust Score dla programu: {trust_score}/100 — niski score sugeruje większą ostrożność przy ocenie innowacyjności]"
+    except Exception:
+        pass
+
+    prompt = f"""
+    Na podstawie zebranych dotychczas informacji i analizy innowacyjnej/technologicznej (patrz historia):
+    {conversation_text}
+    {engine_context}
+    {trust_context}
+    
+    Wygeneruj ostateczny wynik audytu innowacyjnego dla wniosku ({state['program_name']}) wg struktury.
+    Oceń projekt. Role: innowator.
+    TREŚĆ:
+    {state['content'][:150000]}
+    """
+    from tenacity import retry, stop_after_attempt, wait_exponential
+
+    @retry(
+        stop=stop_after_attempt(5),
+        wait=wait_exponential(multiplier=1, min=2, max=10),
+        reraise=True,
+    )
+    def invoke_eval():
+        result: _PerspectiveResult = llm.invoke(prompt)
+        if not result.summary or len(result.summary.strip()) < 10:
+            raise ValueError(
+                "Błąd sanity check: Puste podsumowanie audytu innowacyjnego."
+            )
+        for issue in result.issues:
+            issue.perspective = "innowator"
+        return {
+            "issues": result.issues,
+            "perspectives_summary": {"innowator": result.summary},
+            "perspective_scores": [result.partial_score],
+            "innowator_done": True,
+        }
+
+    try:
+        return invoke_eval()
+    except Exception as e:
+        logger.error(f"[INNOWATOR] Ostateczny błąd ewaluatora: {e}")
+        return {
+            "innowator_done": True,
+            "perspectives_summary": {
+                "innowator": f"Błąd audytu innowacyjnego po 5 próbach: {e}"
+            },
+        }
+
+
+def innowator_routing(state: AuditorPanelState) -> str:
+    """Decyduje czy Innowator musi szukać dalej, czy oceniać."""
+    last_message = state["innowator_messages"][-1]
+    if last_message.tool_calls:
+        if state.get("innowator_attempts", 0) >= 3:
+            logger.warning(
+                "[INNOWATOR] Przekroczono limit wyszukiwań, wymuszam ewaluację."
+            )
+            return "evaluate"
+        return "tools"
+    return "evaluate"
+
+
+# --- ZARZĄDZAJĄCY NODE ---
+def zarzadzajacy_node(state: AuditorPanelState) -> Dict[str, Any]:
+    """Reduktor zbierający wszystkie dane i tworzący GlobalAuditOutput."""
+    scores = state.get("perspective_scores", [])
+    issues = state.get("issues", [])
+
+    has_critical = any(i.severity == "critical" for i in issues)
+
+    if not scores:
+        overall_score = 0
+    else:
+        base = int(sum(scores) / len(scores))
+        overall_score = max(0, base - 20) if has_critical else base
+
+    export_status = "ok"
+    if has_critical:
+        export_status = "blocked"
+    elif any(i.severity == "high" for i in issues):
+        export_status = "warning"
+
+    final = GlobalAuditOutput(
+        is_approved=not has_critical,
+        export_status=export_status,
+        overall_score=overall_score,
+        confidence_score=0.9,  # LangGraph gives high confidence theoretically
+        human_review_required=has_critical or overall_score < 60,
+        issues=issues,
+        perspectives_summary=state.get("perspectives_summary", {}),
+    )
+
+    return {"final_output": final}

backend/agents/panel_state.py

@@ -0,0 +1,44 @@
+from typing import TypedDict, List
+import operator
+from typing_extensions import Annotated
+from langchain_core.messages import AnyMessage
+from agents.auditor import AuditIssue, GlobalAuditOutput
+
+
+def merge_dicts(a: dict, b: dict) -> dict:
+    return {**(a or {}), **(b or {})}
+
+
+class AuditorPanelState(TypedDict):
+    project_id: str
+    program_name: str
+    content: str
+    is_external_audit: bool
+    # Agregacja błędów z poszczególnych ról
+    issues: Annotated[List[AuditIssue], operator.add]
+    perspectives_summary: Annotated[dict, merge_dicts]
+    # Przechowuje scores do finalnego uśrednienia
+    perspective_scores: Annotated[List[int], operator.add]
+
+    # Zarządzanie Dynamic Query Routing dla Prawnika
+    legal_attempts: int
+    legal_queries: Annotated[List[str], operator.add]
+    messages: Annotated[
+        List[AnyMessage], operator.add
+    ]  # służy do wymiany zapytań z narzędziami prawnika
+    prawnik_done: bool
+
+    # Zarządzanie Dynamic Query Routing dla Finansisty
+    finansista_attempts: int
+    finansista_queries: Annotated[List[str], operator.add]
+    finansista_messages: Annotated[List[AnyMessage], operator.add]
+    finansista_done: bool
+
+    # Zarządzanie Dynamic Query Routing dla Innowatora
+    innowator_attempts: int
+    innowator_queries: Annotated[List[str], operator.add]
+    innowator_messages: Annotated[List[AnyMessage], operator.add]
+    innowator_done: bool
+
+    # Wynik końcowy (wyliczony przez Zarządzającego)
+    final_output: GlobalAuditOutput

backend/agents/planner.py

@@ -0,0 +1,40 @@
+from typing import Dict, Any
+from core.llm_router import get_llm
+from schemas import AgentState, PlanOutput
+
+
+def planner_node(state: AgentState) -> Dict[str, Any]:
+    """
+    Tworzy dynamiczny plan sesji i osadza go w Blackboard.
+    Uruchamiany jako pierwszy lub wywoływany w przypadku drastycznej zmiany intencji.
+    """
+    llm = get_llm(task_type="standard", structured_output_schema=PlanOutput)
+
+    prompt = f"""
+    Jesteś Planner Agentem. Skonstruuj plan dzialania dla klienta w systemie decyzyjnym dotyczącym dotacji.
+    Cel: Na podstawie konwersacji, stwórz listę max 5 kroków, co należy zrobić dalej.
+    
+    Ostatnia wiadomość od klienta: {state.messages[-1].content if state.messages else 'Nowa sesja'}
+    Obecny profil firmy: {state.profile.model_dump() if state.profile else 'Brak'}
+    
+    Zwróć wynik jako uporządkowaną listę kroków w formacie schematu ustrukturyzowanego. PISZ ZAWSZE I WYŁĄCZNIE W JĘZYKU POLSKIM.
+    """
+
+    try:
+        response = llm.invoke(prompt)
+        steps = response.steps
+    except Exception as e:
+        print(f"Błąd plannera: {e}")
+        steps = []
+
+    # Przełącznik awaryjny - jeśli nie uda się sparsować to używamy domyślnego
+    if not steps:
+        steps = [
+            "Zebrać pełen profil firmy (Profiler)",
+            "Znaleźć dopasowane dotacje (Matcher)",
+        ]
+
+    return {
+        "task_plan": steps,
+        "current_agent": "supervisor",  # Handoff back to supervisor
+    }

backend/agents/profiler.py

@@ -0,0 +1,128 @@
+import re
+import logging
+from typing import Optional
+
+from schemas import AgentState, CompanyProfile, FinancialData
+from tools.company_search import fetch_regon_data
+
+logger = logging.getLogger(__name__)
+
+
+def extract_nip(text: str) -> Optional[str]:
+    clean_text = text.replace("-", "").replace(" ", "")
+    match = re.search(r"\d{10}", clean_text)
+    return match.group(0) if match else None
+
+
+def calculate_company_size(revenue: float, employment: int) -> str:
+    if employment < 10 and revenue <= 2_000_000:
+        return "Mikro"
+    if employment < 50 and revenue <= 10_000_000:
+        return "Mała"
+    if employment < 250 and revenue <= 50_000_000:
+        return "Średnia"
+    if employment >= 250 or revenue > 50_000_000:
+        return "Duża"
+    return "MŚP"
+
+
+def _profile_from_regon(nip: str, raw: dict) -> CompanyProfile:
+    revenue = float(raw.get("revenue") or 0)
+    employment = int(raw.get("employment") or 0)
+    pkds = raw.get("pkd") or []
+    if isinstance(pkds, str):
+        pkds = [pkds]
+    return CompanyProfile(
+        nip=nip,
+        name=(raw.get("name") or "").strip() or None,
+        regon=(raw.get("regon") or "").strip() or None,
+        krs=(raw.get("krs") or "").strip() or None,
+        address=(raw.get("address") or "").strip() or None,
+        legal_form=(raw.get("legal_form") or "").strip() or None,
+        data_source=(raw.get("data_source") or "unknown").strip(),
+        pkd_codes=pkds,
+        region=(raw.get("voivodeship") or "Nieznane").strip(),
+        size=calculate_company_size(revenue, employment),
+        financials=FinancialData(revenue=revenue, employment=employment),
+    )
+
+
+def profiler_node(state: AgentState):
+    if not state.messages:
+        return {"current_agent": "supervisor"}
+
+    user_msg = (
+        state.messages[-1]["content"]
+        if isinstance(state.messages[-1], dict)
+        else getattr(state.messages[-1], "content", "")
+    )
+    nip = extract_nip(user_msg)
+    if not nip:
+        return {
+            "current_agent": "supervisor",
+            "messages": [
+                {
+                    "role": "assistant",
+                    "content": (
+                        "Podaj 10-cyfrowy NIP firmy, aby zbudować profil z rejestru GUS/REGON."
+                    ),
+                }
+            ],
+        }
+
+    raw_data = fetch_regon_data(nip)
+    profile = _profile_from_regon(nip, raw_data)
+
+    blackboard = dict(state.blackboard or {})
+    blackboard.update(
+        {
+            "company_nip": nip,
+            "company_name": profile.name or "",
+            "company_regon": profile.regon or "",
+            "company_krs": profile.krs or "",
+            "company_address": profile.address or "",
+            "company_legal_form": profile.legal_form or "",
+            "company_pkd": profile.pkd_codes,
+            "company_region": profile.region,
+            "company_size": profile.size,
+            "company_data_source": profile.data_source,
+            "profile_enriched": True,
+            "using_real_data": profile.data_source
+            in ("gus_bir", "mf_whitelist", "regon_api"),
+        }
+    )
+
+    company_label = profile.name or f"NIP {nip}"
+    region_str = (
+        f", {profile.region}"
+        if profile.region and profile.region != "Nieznane"
+        else ""
+    )
+    pkd_str = (
+        ", ".join(profile.pkd_codes[:2])
+        if profile.pkd_codes
+        else "brak PKD w rejestrze"
+    )
+
+    logger.info(
+        "profiler_node: %s NIP=%s source=%s",
+        company_label,
+        nip,
+        profile.data_source,
+    )
+
+    return {
+        "profile": profile,
+        "blackboard": blackboard,
+        "messages": [
+            {
+                "role": "assistant",
+                "content": (
+                    f"Zidentyfikowałem: **{company_label}** (NIP {nip}{region_str}). "
+                    f"PKD: {pkd_str}. Wielkość: {profile.size}. "
+                    "Jaka jest główna potrzeba inwestycyjna?"
+                ),
+            }
+        ],
+        "current_agent": "supervisor",
+    }

backend/agents/red_team_auditor.py

@@ -0,0 +1,80 @@
+import logging
+from typing import Dict, Any, List
+try:
+    from core.llm_router import get_llm
+except ImportError:
+    from backend.core.llm_router import get_llm
+
+from langchain_core.messages import SystemMessage, HumanMessage
+from pydantic import BaseModel, Field
+
+logger = logging.getLogger(__name__)
+
+class AuditScore(BaseModel):
+    score: int = Field(..., description="Punkty od 0 do 25 za ten wniosek", ge=0, le=25)
+    passed: bool = Field(..., description="Czy wniosek przeszedł minimalny próg? (np. 15 pkt)")
+    weaknesses: List[str] = Field(..., description="Lista konkretnych słabych punktów i braków")
+    legal_risks: List[str] = Field(..., description="Ryzyka prawne (np. limity de minimis, niedozwolone koszty)")
+    improvement_feedback: str = Field(..., description="Instrukcje dla Generator Agent, co musi zostać bezwzględnie poprawione")
+
+class RedTeamAuditor:
+    """
+    Faza 14: Finalna weryfikacja i ocena punktowa wniosku (Pre-Submission Audit).
+    Działa jak wirtualny ekspert z panelu (np. NCBR/PARP), odrzucając słabe wnioski.
+    """
+    
+    def __init__(self):
+        self.min_passing_score = 15
+
+    def audit_application(self, generated_sections: Dict[str, str], context: str, program_name: str) -> Dict[str, Any]:
+        """
+        Ocenia cały wygenerowany wniosek na podstawie kontekstu.
+        """
+        logger.info(f"[RedTeamAuditor] Rozpoczynam ocenę wniosku dla programu: {program_name}")
+        
+        full_text = "\n\n".join([f"### {title}\n{content}" for title, content in generated_sections.items()])
+        
+        system_prompt = (
+            "Jesteś surowym i nieustępliwym Ekspertem Oceniającym wniosek dotacyjny (Red Team).\n"
+            f"Twoim zadaniem jest ocenić gotowy wniosek pod kątem programu: {program_name}.\n"
+            "Ocena punktowa wynosi od 0 do 25 punktów. Aby projekt przeszedł, musi zdobyć min. 15 punktów.\n"
+            "Sprawdzaj innowacyjność, spójność budżetu, rygor prawny i zgodność z regulaminem (Kontekst RAG).\n"
+            "Nie bój się oblać wniosku (passed=False), jeśli są w nim halucynacje liczbowe, brak wkładu własnego "
+            "lub ogólniki zamiast konkretnych przewag konkurencyjnych."
+        )
+        
+        human_content = f"Kontekst RAG (Regulaminy):\n{context[:3000]}\n\nTreść Wniosku do oceny:\n{full_text[:12000]}"
+        
+        try:
+            llm = get_llm(task_type="critical", structured_output_schema=AuditScore)
+            response = llm.invoke([
+                SystemMessage(content=system_prompt),
+                HumanMessage(content=human_content)
+            ])
+            
+            # Wymuszenie odrzucenia jeśli score poniżej progu
+            if response.score < self.min_passing_score:
+                response.passed = False
+                
+            result = {
+                "score": response.score,
+                "passed": response.passed,
+                "weaknesses": response.weaknesses,
+                "legal_risks": response.legal_risks,
+                "feedback": response.improvement_feedback
+            }
+            logger.info(f"[RedTeamAuditor] Zakończono ocenę. Wynik: {response.score}/25, Passed: {response.passed}")
+            return result
+            
+        except Exception as e:
+            logger.error(f"[RedTeamAuditor] Błąd podczas oceny: {e}")
+            # FAIL-CLOSED: awaria audytu NIE może cicho przepuścić wniosku.
+            # Oznaczamy jako niezaakceptowany i wymagający weryfikacji człowieka.
+            return {
+                "score": 0,
+                "passed": False,
+                "human_review_required": True,
+                "weaknesses": ["Błąd ewaluacji przez LLM — wynik niezweryfikowany (fail-closed)."],
+                "legal_risks": [],
+                "feedback": "Błąd systemu oceniającego — wymagana ręczna weryfikacja przed eksportem."
+            }

backend/agents/research_agent.py

@@ -0,0 +1,74 @@
+import logging
+import os
+from typing import Optional, Dict
+
+from langchain_core.messages import SystemMessage, HumanMessage
+from core.llm_router import get_llm
+
+try:
+    from tools.web_search import general_web_search
+except ImportError:
+    from backend.tools.web_search import general_web_search
+
+logger = logging.getLogger(__name__)
+
+class ResearchAgent:
+    """
+    Sub-Agent badawczy Projektu TITAN.
+    Zadaniem tego agenta jest przeszukiwanie sieci (OSINT / Web Search)
+    oraz interpretacja wyników w przypadku braku danych w dokumencie.
+    Zastępuje człowieka w trybie pełnej automatyzacji, znacznie zwiększając skuteczność.
+    """
+    
+    def __init__(self):
+        # Inicjalizacja LLM dla analizy wyników badawczych.
+        self.llm = get_llm(task_type="creative") # Używamy creative/standard
+
+    def deep_search(self, query: str, context: str) -> str:
+        """
+        Głębokie poszukiwanie danych w zewnętrznych bazach i sieci,
+        oraz ich synteza przy użyciu LLM.
+        """
+        logger.info(f"🔎 [Research Agent TITAN] Rozpoczęto głębokie wyszukiwanie dla: {query}")
+        
+        # 1. Wykonanie rzeczywistego wyszukiwania w sieci
+        search_results = general_web_search(query)
+        
+        # 2. Jeśli nie znaleziono lub brak klucza, zwracamy stosowną informację,
+        #    ale możemy spróbować odpowiedzieć z wiedzy LLM z uwzględnieniem kontekstu.
+        if "Błąd" in search_results or "Brak klucza" in search_results:
+            logger.warning(f"[Research Agent TITAN] Problem z wyszukiwarką: {search_results}")
+            search_context = "Nie udało się pobrać aktualnych danych z sieci z powodu braku dostępu do API wyszukiwania."
+        else:
+            search_context = f"Wyniki wyszukiwania:\n{search_results}"
+
+        system_prompt = (
+            "Jesteś zaawansowanym Agentem Badawczym OSINT. Twoim zadaniem jest dostarczenie "
+            "wyczerpujących i merytorycznych informacji na podstawie podanego kontekstu projektu "
+            "oraz wyników wyszukiwania z sieci.\n\n"
+            "Zasady:\n"
+            "1. Twoim celem jest odpowiedź na brakujące zapytanie (pytanie o brakujące dane).\n"
+            "2. Wykorzystaj informacje z 'Wyników wyszukiwania', jeśli są dostępne.\n"
+            "3. Oprzyj się na 'Kontekście projektu', aby odpowiedź była dopasowana do specyfiki firmy i projektu.\n"
+            "4. Jeśli z danych sieciowych i kontekstu nie da się jednoznacznie określić faktów (np. precyzyjnego przychodu małej firmy), "
+            "zaproponuj profesjonalne i wiarygodne oszacowanie lub standardowe dla branży wartości rynkowe i zaznacz, że to szacunek, "
+            "aby wniosek dotacyjny mógł zostać wygenerowany jako pełny szkic (użyj znaczników np. [SZACOWANY_PRZYCHÓD: 1.5 mln PLN]).\n"
+            "5. Pisz wyłącznie w języku polskim, stylem profesjonalnym, odpowiednim do wniosków unijnych i biznesplanów."
+        )
+
+        human_content = f"Pytanie o brakujące dane: {query}\n\nKontekst projektu:\n{context}\n\n{search_context}"
+
+        try:
+            response = self.llm.invoke([
+                SystemMessage(content=system_prompt),
+                HumanMessage(content=human_content)
+            ])
+            
+            final_answer = response.content if hasattr(response, 'content') else str(response)
+            logger.info("[Research Agent TITAN] Zakończono syntezę wyników badawczych.")
+            return final_answer
+        except Exception as e:
+            logger.error(f"[Research Agent TITAN] Błąd generowania odpowiedzi przez LLM: {e}")
+            return f"Nie udało się wygenerować odpowiedzi analitycznej na temat: {query}. Spróbuj użyć [BRAK DANYCH]."
+
+research_agent = ResearchAgent()

backend/agents/researcher.py

@@ -0,0 +1,201 @@
+import asyncio
+import logging
+
+from schemas import AgentState, GrantCall
+from core.search.grant_search_service import grant_search_service
+
+logger = logging.getLogger(__name__)
+
+CATALOG_LIMIT = 80
+
+
+def _run_async(coro):
+    """Uruchamia korutynę z kontekstu synchronicznego, bezpiecznie względem pętli.
+
+    Poprzedni wzorzec (get_event_loop().run_until_complete + fallback asyncio.run)
+    wywalał się, gdy pętla zdarzeń już działała (np. węzeł w async LangGraph):
+    obie ścieżki rzucają RuntimeError. Tutaj, jeśli pętla działa, wykonujemy
+    korutynę w osobnym wątku z własną pętlą.
+    """
+    try:
+        running_loop = asyncio.get_running_loop()
+    except RuntimeError:
+        running_loop = None
+
+    if running_loop is not None:
+        import concurrent.futures
+
+        with concurrent.futures.ThreadPoolExecutor(max_workers=1) as pool:
+            return pool.submit(lambda: asyncio.run(coro)).result()
+    return asyncio.run(coro)
+
+
+def _profile_to_company_data(profile) -> dict:
+    region = profile.region if profile.region and profile.region != "Nieznane" else ""
+    return {
+        "pkd": profile.pkd_codes or [],
+        "pkd_codes": profile.pkd_codes or [],
+        "size": profile.size or "mikro",
+        "voivodeship": region,
+        "address": region,
+        "entity_type": "przedsiębiorca",
+    }
+
+
+def _filter_catalog_by_eligibility(items: list, company_data: dict) -> list:
+    if not items or not company_data.get("pkd"):
+        return items
+    try:
+        from core.graph_db.grant_eligibility import evaluate_grant_eligibility
+
+        scored = []
+        for item in items:
+            verdict = evaluate_grant_eligibility(item, company_data)
+            if verdict.get("eligible"):
+                item = dict(item)
+                item["_eligibility_score"] = 100 - verdict.get("score_penalty", 0)
+                scored.append(item)
+        scored.sort(key=lambda x: x.get("_eligibility_score", 0), reverse=True)
+        if scored:
+            return scored
+    except Exception as e:
+        logger.debug("researcher_node: eligibility pre-filter skip: %s", e)
+    return items
+
+
+def _grants_from_db(profile) -> list:
+    """Pobiera programy z PostgreSQL (import WYSZUKIWARKA) z pre-filtrem PKD/region."""
+    try:
+        from core.subscription.db import SessionLocal
+        from core.grants.catalog_service import search_catalog
+
+        db = SessionLocal()
+        try:
+            query_parts = []
+            if profile.name:
+                query_parts.append(profile.name)
+            if profile.size:
+                query_parts.append(profile.size)
+            if profile.region and profile.region != "Nieznane":
+                query_parts.append(profile.region)
+            if profile.pkd_codes:
+                query_parts.extend(profile.pkd_codes[:3])
+            if profile.investment_plans:
+                query_parts.extend([p.description for p in profile.investment_plans[:2]])
+
+            query = " ".join(query_parts)
+            catalog = search_catalog(db, query=query, limit=CATALOG_LIMIT, trusted_only=False)
+            if not catalog:
+                catalog = search_catalog(db, query="", limit=CATALOG_LIMIT, trusted_only=False)
+
+            company_data = _profile_to_company_data(profile)
+            catalog = _filter_catalog_by_eligibility(catalog, company_data)
+
+            grants = []
+            for item in catalog[:CATALOG_LIMIT]:
+                grants.append(
+                    GrantCall(
+                        title=f"{item.get('program', '')} - {item.get('name', '')}".strip(" -"),
+                        description=_rich_description(item),
+                        url=item.get("url", ""),
+                        deadline=item.get("deadline") or "Brak potwierdzonego terminu",
+                        max_amount=float(item.get("max_dofinansowanie_pln") or 0),
+                        institution=item.get("operator") or item.get("program", ""),
+                    )
+                )
+            return grants
+        finally:
+            db.close()
+    except Exception as e:
+        logger.warning("researcher_node: błąd odczytu katalogu DB: %s", e)
+        return []
+
+
+def _rich_description(item: dict) -> str:
+    parts = [item.get("description") or ""]
+    if item.get("beneficjenci"):
+        parts.append(f"Beneficjenci: {item['beneficjenci']}")
+    if item.get("warunki_wejscia"):
+        parts.append(f"Warunki: {str(item['warunki_wejscia'])[:300]}")
+    if item.get("kwota_max"):
+        parts.append(f"Kwota: {item['kwota_max']}")
+    return " | ".join(p for p in parts if p)
+
+
+def researcher_node(state: AgentState):
+    if not state.profile:
+        return {
+            "current_agent": "supervisor",
+            "messages": [
+                {
+                    "role": "assistant",
+                    "content": "Brak danych firmy do weryfikacji naborów.",
+                }
+            ],
+        }
+
+    grants = _grants_from_db(state.profile)
+    source_note = f"katalog PostgreSQL (WYSZUKIWARKA, limit={CATALOG_LIMIT})"
+
+    if not grants:
+        voivodeship_filter = (
+            f" województwo {state.profile.region}"
+            if state.profile.region and state.profile.region != "Nieznane"
+            else " ogólnopolskie"
+        )
+        investment_keywords = ""
+        if state.profile.investment_plans:
+            investment_keywords = " " + " ".join(
+                [p.description for p in state.profile.investment_plans]
+            )
+        company_ref = state.profile.name or f"NIP {state.profile.nip}"
+        query = (
+            f"firma {company_ref} {state.profile.size}{voivodeship_filter} "
+            f"branża {', '.join(state.profile.pkd_codes)}{investment_keywords}"
+        )
+        source_note = "live scrape (fallback — pusta baza katalogowa)"
+
+        try:
+            search_results = _run_async(grant_search_service.search_grants(query, {}))
+        except Exception as e:
+            logger.error("Error in researcher_node live search: %s", e)
+            search_results = []
+
+        for r in search_results:
+            grants.append(
+                GrantCall(
+                    title=f"{r.get('program', '')} - {r.get('name', '')}",
+                    description=r.get("description", ""),
+                    url=r.get("url", ""),
+                    deadline=r.get("deadline") or "Brak potwierdzonego terminu",
+                    max_amount=r.get("max_dofinansowanie_pln", 0.0),
+                )
+            )
+
+    if not grants:
+        return {
+            "eligible_grants": [],
+            "current_agent": "supervisor",
+            "messages": [
+                {
+                    "role": "assistant",
+                    "content": (
+                        "Nie znaleziono programów dotacyjnych pasujących do profilu firmy. "
+                        "Uruchom import katalogu: `python scripts/import_wyszukiwarka.py` "
+                        "lub endpoint admin `/api/admin/grants/import-wyszukiwarka`."
+                    ),
+                }
+            ],
+        }
+
+    logger.info("researcher_node: %s wyników ze źródła %s", len(grants), source_note)
+    return {
+        "eligible_grants": grants,
+        "current_agent": "supervisor",
+        "messages": [
+            {
+                "role": "assistant",
+                "content": f"Znaleziono {len(grants)} programów (źródło: {source_note}).",
+            }
+        ],
+    }

backend/agents/risk_scoring.py

@@ -0,0 +1,104 @@
+import logging
+from typing import Dict, Any
+from langchain_core.messages import AIMessage
+from core.llm_router import get_llm
+from schemas import AgentState, RiskScoreOutput
+from agents.helpers import ANTI_HALLUCINATION_PROMPT
+from tenacity import retry, stop_after_attempt, wait_exponential
+
+logger = logging.getLogger(__name__)
+
+
+def risk_scoring_node(state: AgentState) -> Dict[str, Any]:
+    """
+    Hybrydowy system punktacji ryzyka (Opcja A - Twarde reguły + LLM).
+    LLM identyfikuje ryzyka i proponuje ocenę, ale Python nakłada twarde filtry biznesowe
+    (np. odrzucenie za status trudności, kary za brak przychodów).
+    """
+    llm = get_llm(task_type="critical", structured_output_schema=RiskScoreOutput)
+
+    profile_dump = (
+        state.profile.model_dump() if state.profile else "Brak danych profilu"
+    )
+
+    prompt = f"""
+    {ANTI_HALLUCINATION_PROMPT}
+
+    Na podstawie profilu firmy przydziel jej hipotetyczną ocenę projektową 0-100 dla szans na uzyskanie dotacji UE.
+    Następnie wypunktuj DOKŁADNIE 5 RYZYK, które obniżają tę ocenę (np. słabe wyniki finansowe, brak innowacji).
+    
+    Profil: {profile_dump}
+    """
+
+
+    @retry(stop=stop_after_attempt(3), wait=wait_exponential(multiplier=1, min=2, max=10))
+    def _invoke_llm():
+        res = llm.invoke(prompt)
+        if len(res.risks) != 5:
+            raise ValueError("LLM did not return exactly 5 risks.")
+        if not (0 <= res.score <= 100):
+            raise ValueError("Score out of bounds.")
+        return res
+
+    try:
+        response = _invoke_llm()
+        
+        final_score = response.score
+        risks = response.risks.copy()
+        
+        # --- TWARDE REGUŁY BIZNESOWE (HARD RULES) ---
+        if state.profile:
+            # 1. Firma w trudnej sytuacji - całkowita dyskwalifikacja
+            if getattr(state.profile, 'is_in_difficulty', False):
+                final_score = 0
+                risks.insert(0, "🚨 DYSKWALIFIKACJA: Firma w trudnej sytuacji ekonomicznej (zakaz wsparcia UE).")
+            
+            # 2. Brak udokumentowanych przychodów - kara punktowa i narzucenie ryzyka
+            fin = getattr(state.profile, 'financials', None)
+            if not fin or getattr(fin, 'revenue', 0.0) <= 0:
+                final_score = min(final_score, 50)  # Max 50 pkt dla firm bez przychodów
+                risks.insert(0, "⚠️ TWARDE RYZYKO: Brak historycznych przychodów (Startup) - ogromne ryzyko stabilności finansowej projektu.")
+                
+            # 3. Zbyt duży projekt dla mikroprzedsiębiorstwa (heurystyka np. inwestycja > 5 mln)
+            plans = getattr(state.profile, 'investment_plans', [])
+            total_investment = sum(p.estimated_cost for p in plans) if plans else 0
+            if getattr(state.profile, 'size', '') == 'Mikro' and total_investment > 5_000_000:
+                final_score = max(0, final_score - 20)
+                risks.insert(0, "⚠️ TWARDE RYZYKO: Skala inwestycji (pow. 5 mln PLN) nieadekwatna do wielkości Mikroprzedsiębiorstwa.")
+
+        # Ograniczamy do max 5 ryzyk, ale twarde są zawsze na początku
+        risks = risks[:5]
+
+        # Zapis w state.risk_score
+        risk_score_update = {"score": final_score, "risks": risks}
+        score_text = f"WYNIK: {final_score}/100\nRYZYKA:\n" + "\n".join(
+            [f"{i+1}. {r}" for i, r in enumerate(risks)]
+        )
+
+        # Opcjonalny zapis wstecznej zgodności z Blackboard
+        blackboard_update = state.blackboard or {}
+        blackboard_update["last_risk_score"] = score_text
+
+        return {
+            "messages": [AIMessage(content=score_text)],
+            "risk_score": risk_score_update,
+            "blackboard": blackboard_update,
+            "current_agent": "supervisor",
+        }
+    except Exception as e:
+        # FAIL-CLOSED: na wyjątku NIE gubimy risk_score (co cicho omijałoby bramkę).
+        # Ustawiamy konserwatywny wynik wyzwalający bramkę / human review.
+        logger.error(f"Błąd risk scoring: {e}")
+        conservative = {
+            "score": 0,
+            "risks": [
+                "⚠️ Awaria mechanizmu oceny ryzyka — ustawiono konserwatywny wynik 0/100. "
+                "Wymagana ręczna weryfikacja przed eksportem."
+            ],
+            "human_review_required": True,
+            "error": str(e)[:200],
+        }
+        return {
+            "risk_score": conservative,
+            "current_agent": "supervisor",
+        }

backend/agents/scraper_agent.py

@@ -0,0 +1,83 @@
+import logging
+import asyncio
+import sys
+import os
+
+sys.path.append(os.path.join(os.path.dirname(__file__), "..", ".."))
+try:
+    from backend.integrations.isap_client import ISAPClient
+    from backend.integrations.parp_client import PARPClient
+    from backend.rag_pipeline.scraper import scrape_grant_url
+    from backend.rag_pipeline.ingest import process_and_ingest
+except ImportError:
+    ISAPClient = None
+    PARPClient = None
+
+logger = logging.getLogger(__name__)
+
+
+class ScraperAgent:
+    """
+    Inteligentny Agent, który decyduje w jaki sposób pozyskać dane.
+    Przeznaczony do działania z Celery Beat / APScheduler do cyklicznych aktualizacji.
+    """
+
+    def __init__(self):
+        if ISAPClient and PARPClient:
+            self.isap_client = ISAPClient()
+            self.parp_client = PARPClient()
+        else:
+            self.isap_client = None
+            self.parp_client = None
+        # Namespace do ogólnodostępnej przestrzeni aktów i regulaminów
+        self.public_namespace = "public_legal"
+
+    async def run_sync_job(self):
+        """Uruchamia cykliczny proces synchronizacji dotacji i prawa"""
+        if not self.isap_client or not self.parp_client:
+            logger.error("[AGENT] Brak klientow ISAP/PARP. Synchronizacja anulowana.")
+            return
+
+        logger.info(
+            "[AGENT] Rozpoczęcie automatycznego zadania synchronizacji bazy wiedzy..."
+        )
+
+        # 1. PARP (Regulaminy Naborów)
+        grants = self.parp_client.fetch_grants()
+        for grant in grants:
+            url = grant["url"]
+            logger.info(f"[AGENT] Zlecam scrapowanie dla dotacji: {grant['id']}")
+            try:
+                text, _ = await scrape_grant_url(url)
+                if text:
+                    process_and_ingest(
+                        text, url, priority="high", namespace=self.public_namespace
+                    )
+            except Exception as e:
+                logger.error(f"[AGENT] Błąd fetchowania {url}: {e}")
+
+        # 2. ISAP (Ustawa z dn 6 marca 2018 - Prawo przedsiębiorców)
+        logger.info("[AGENT] Pobieranie ram prawnych (ISAP/ELI)")
+        act_info = self.isap_client.fetch_act("WDU", 2018, 646)
+        if act_info:
+            urls_to_try = [act_info["text_url"]]
+            if act_info.get("text_pdf_url"):
+                urls_to_try.append(act_info["text_pdf_url"])
+            for url in urls_to_try:
+                try:
+                    text, _ = await scrape_grant_url(url)
+                    if text:
+                        process_and_ingest(
+                            text, url, priority="critical", namespace=self.public_namespace
+                        )
+                        break
+                except Exception as e:
+                    logger.error(f"[AGENT] Błąd parsowania ISAP {url}: {e}")
+
+        logger.info("[AGENT] Zakończono automatyczny cykl agenta synchronizacyjnego.")
+
+
+if __name__ == "__main__":
+    logging.basicConfig(level=logging.INFO)
+    agent = ScraperAgent()
+    asyncio.run(agent.run_sync_job())

backend/agents/supervisor.py

@@ -0,0 +1,139 @@
+from schemas import AgentState, SupervisorDecision
+from core.llm_router import get_llm
+from functools import lru_cache
+
+
+class SimpleQueryRouter:
+    """
+    v5.0 Real QueryRouter (previously stub) for autonomous flows + Master Orchestrator hooks.
+    Keyword + lightweight LLM fallback. Integrated into supervisor.
+    Enables full autonomous routing without external GSD swarm in main graph.
+    """
+
+    AGENT_KEYWORDS = {
+        "profiler": ["profil", "dane firmy", "krs", "nip", "msp", "company"],
+        "researcher": ["szukaj", "znajdź", "dotacje", "nabory", "research"],
+        "matcher": ["dopasuj", "match", "rekomenduj", "najlepsze programy"],
+        "verifier": ["sprawdź", "weryfikuj", "formalnie", "zgodność"],
+        "wizard": ["pisz", "generuj", "sekcja", "wniosek", "treść"],
+        "risk_scoring": ["ryzyko", "szanse", "punktuj", "score"],
+        "document_gap_analyzer": ["braki", "gap", "analiza dokumentu"],
+        "compliance_guardian": ["rodo", "compliance", "ochrona danych", "kruczkowski"],
+        "end": ["koniec", "zakończ", "gotowe", "dziękuję"],
+    }
+
+    @staticmethod
+    @lru_cache(maxsize=64)
+    def route_query(query: str) -> str:
+        """Fast cached routing for token efficiency."""
+        q = (query or "").lower()
+        for agent, kws in SimpleQueryRouter.AGENT_KEYWORDS.items():
+            if any(kw in q for kw in kws):
+                return agent
+        return "planner"  # default safe
+
+    @staticmethod
+    def route(state: AgentState) -> str:
+        """Full router used by supervisor (real implementation replacing stub)."""
+        if not state.messages:
+            return "planner"
+        if state.task_plan and len(state.task_plan) > 0:
+            next_task = state.task_plan[0].lower()
+            if "profil" in next_task:
+                return "profiler"
+            if any(x in next_task for x in ["dopas", "match", "rekomend"]):
+                return "matcher"
+            if any(x in next_task for x in ["gener", "pisz", "sekcj"]):
+                return "wizard"
+        last = state.messages[-1]
+        content = last.get("content", "") if isinstance(last, dict) else getattr(last, "content", "")
+        routed = SimpleQueryRouter.route_query(content)
+        # Fallback LLM only if keyword weak (token saving)
+        if routed == "planner" and len(content) > 40:
+            try:
+                llm = get_llm(task_type="fast")
+                decision = llm.invoke(f"Route this grant query to one agent: planner/profiler/matcher/wizard/risk_scoring. Query: {content[:200]}")
+                txt = getattr(decision, "content", str(decision)).lower()
+                for a in SimpleQueryRouter.AGENT_KEYWORDS:
+                    if a in txt:
+                        return a
+            except Exception:
+                pass
+        return routed
+
+
+def supervisor_node(state: AgentState):
+    """
+    Supervisor (Router) z 2026 r. zintegrowany z Blackboard.
+    Kieruje wiadomości lub wywołuje wykonanie kolejnego zdefiniowanego kroku w task_plan.
+    v5.0: Uses real SimpleQueryRouter for autonomous flow polish + Master Orchestrator compatibility.
+    """
+    if not state.messages:
+        return {"current_agent": "planner"}
+
+    # Check if there is an active plan in blackboard to execute
+    if state.task_plan and len(state.task_plan) > 0:
+        next_task = state.task_plan[0].lower()
+        if "profil" in next_task:
+            return {"current_agent": "profiler"}
+        elif "dopasowa" in next_task or "match" in next_task:
+            return {"current_agent": "matcher"}
+        # Logika oparta na planie będzie o wiele bardziej rozbudowana w produkcji.
+
+    # v5.0 Real QueryRouter path (polish for full autonomous)
+    try:
+        next_agent = SimpleQueryRouter.route(state)
+        valid = ["planner", "profiler", "researcher", "matcher", "verifier", "wizard",
+                 "risk_scoring", "document_gap_analyzer", "compliance_guardian", "end"]
+        if next_agent in valid:
+            return {"current_agent": next_agent}
+    except Exception:
+        pass
+
+    last_msg = (
+        state.messages[-1].get("content", "")
+        if isinstance(state.messages[-1], dict)
+        else getattr(state.messages[-1], "content", "")
+    )
+
+    prompt = f"""
+    Jesteś supervisorem (dyrektorem) systemu 'GrantForge AI'.
+    Mamy następujące działy (agentów):
+    - planner: planowanie działań
+    - profiler: zbieranie danych firmy z KRS/chatu
+    - researcher: eksploracja dotacji
+    - matcher: dopasowanie znanych dotacji
+    - verifier: sprawdzanie formalne
+    - wizard: pisanie wniosku, wymyślanie treści
+    - risk_scoring: punktowanie szans i ryzyk wniosku
+    - document_gap_analyzer: analiza braków dokumentu
+    - compliance_guardian: sprawdzanie RODO
+    - end: koniec procesu, oddanie głosu klientowi
+    
+    Na podstawie ostatniej wiadomości opisz krótko powód (reason) i wskaż jednoznaczną wartość next_agent z listy powyżej.
+    Wiadomość z systemu klienta: {last_msg}
+    """
+
+    try:
+        llm = get_llm(task_type="standard", structured_output_schema=SupervisorDecision)
+        decision = llm.invoke(prompt)
+
+        valid_agents = [
+            "planner",
+            "profiler",
+            "researcher",
+            "matcher",
+            "verifier",
+            "wizard",
+            "risk_scoring",
+            "document_gap_analyzer",
+            "compliance_guardian",
+            "end",
+        ]
+        if decision.next_agent in valid_agents:
+            # W przyszłości reason można wykorzystać do logowania logiki routing-u
+            return {"current_agent": decision.next_agent}
+    except Exception as e:
+        print(f"Błąd supervisora LLM: {str(e)}")
+
+    return {"current_agent": "end"}

backend/agents/timeline.py

@@ -0,0 +1,64 @@
+import logging
+from typing import Dict, Any
+from schemas import AgentState
+
+logger = logging.getLogger(__name__)
+
+
+def timeline_node(state: AgentState) -> Dict[str, Any]:
+    """
+    Węzeł generujący harmonogram (timeline_events) dla naborów w których firma może wziąć udział.
+    """
+    grants = state.eligible_grants
+    if not grants:
+        return {"current_agent": "supervisor"}
+
+    # Posortuj po skorygowanym relevance_score, weź max 3 by nie zaśmiecać widoku
+    top_grants = sorted(
+        grants,
+        key=lambda x: x.relevance_score if x.relevance_score else 0.0,
+        reverse=True,
+    )[:3]
+
+    events = []
+
+    # Tworzymy symulowany kalendarz na podstawie zebranych dotacji
+    for idx, grant in enumerate(top_grants):
+        # Wydarzenie startowe: rozpoczęcie prac nad wnioskiem
+        events.append(
+            {
+                "id": f"start_prep_{grant.id}",
+                "title": f"Rozpoczęcie przygotowań do: {grant.title}",
+                "description": "Zebranie dokumentacji technicznej i finansowej",
+                "date": "Dzisiaj",
+                "status": "upcoming",
+            }
+        )
+
+        # Ostateczny termin
+        deadline_str = grant.deadline if grant.deadline else "Brak podanej daty"
+        events.append(
+            {
+                "id": f"deadline_{grant.id}",
+                "title": f"Wysłanie wniosku: {grant.title}",
+                "description": f"Instytucja przyjmująca: {grant.institution}. Budżet: ok. {grant.max_amount} PLN",
+                "date": deadline_str,
+                "status": "pending",
+            }
+        )
+
+        # Przewidywana ocena wniosku (zakładamy 90 dni)
+        events.append(
+            {
+                "id": f"evaluation_{grant.id}",
+                "title": f"Spodziewane ogłoszenie wyników: {grant.title}",
+                "description": "Zakończenie oceny eksperckiej wniosku przez instytucję",
+                "date": "+90 dni od wpłynięcia",
+                "status": "future",
+            }
+        )
+
+    logger.info(
+        f"Timeline node wygenerował {len(events)} wydarzeń na osi czasu dla top {len(top_grants)} dotacji."
+    )
+    return {"timeline_events": events, "current_agent": "supervisor"}

backend/agents/tools/budget_rules_tool.py

@@ -0,0 +1,28 @@
+from langchain_core.tools import tool
+from rag_pipeline.hybrid_retriever import get_hybrid_retriever
+
+
+@tool
+def search_budget_rules(query: str, program_name: str = "") -> str:
+    """
+    Wyszukuje informacje w bazie wiedzy (RAG) na temat limitów kosztów kwalifikowanych,
+    zasad finansowania, stawek ryczałtowych oraz dozwolonych budżetów dla programów dotacyjnych.
+
+    Args:
+        query (str): Pytanie dotyczące zasad budżetowych np. "Jaki jest limit kosztów pośrednich dla Ścieżki SMART?"
+        program_name (str): Opcjonalnie nazwa programu, np. "FENG Ścieżka SMART".
+    """
+    retriever = get_hybrid_retriever()
+    search_query = f"[Koszty, Budżet, Ewaluacja Finansowa] Program: {program_name}. Zapytanie: {query}"
+
+    docs = retriever.invoke(search_query)
+    if not docs:
+        return "Nie znaleziono dokumentów precyzujących to zapytanie budżetowe w bazie wiedzy."
+
+    result = "\n".join(
+        [
+            f"- Zródło: {d.metadata.get('source', 'nieznane')}\n{d.page_content}"
+            for d in docs
+        ]
+    )
+    return f"Wyniki wyszukiwania zasad budżetowych:\n{result}"

backend/agents/tools/krs_graph_tool.py

@@ -0,0 +1,64 @@
+import logging
+from typing import Dict, Any
+from langchain_core.tools import tool
+from integrations.krs_client import KRSClient
+from rag_pipeline.graph_store import graph_store
+
+logger = logging.getLogger(__name__)
+
+
+@tool
+def analyze_company_network(krs_number: str) -> Dict[str, Any]:
+    """
+    Analizuje strukturę powiązań kapitałowych i osobowych firmy na podstawie numeru KRS.
+    Narzędzie pobiera oficjalne dane z API KRS (odpis aktualny), dodaje je do bazy grafowej Neo4j,
+    a następnie wyszukuje jakiekolwiek powiązania weryfikujące status MŚP (związki z innymi firmami).
+
+    Zwraca słownik zawierający dane rejestrowe firmy oraz zidentyfikowaną siatkę powiązań (wraz ze wspólnikami i zarządem).
+    """
+
+    logger.info(f"Rozpoczęcie analizy powiązań dla KRS: {krs_number}")
+
+    # 1. Pobierz aktualne dane z publicznego API KRS
+    odpis_json = KRSClient.get_odpis_aktualny(krs_number)
+
+    if not odpis_json:
+        return {
+            "error": f"Nie udało się pobrać odpisu dla KRS {krs_number}. Upewnij się, że wpisany KRS jest poprawny."
+        }
+
+    # 2. Przekształć JSON w węzły struktur (Wspólnicy, Zarząd)
+    extracted_data = KRSClient.extract_graph_relations(odpis_json)
+
+    if not extracted_data:
+        return {
+            "error": "Format odpisu KRS był niepoprawny lub nie wspierany w obecnej strukturze."
+        }
+
+    # 3. Zapisz/zaktualizuj graf Neo4j
+    graph_store.merge_company_graph(extracted_data)
+
+    # 4. Sprawdź powiązania grafowe - szukaj firm zależnych, powiązanych osób
+    network = graph_store.check_company_network(krs_number)
+
+    # Zwróć zagregowany profil do Agenta (np. Audytora)
+    return {
+        "podmiot": {
+            "nazwa": extracted_data.get("nazwa"),
+            "krs": extracted_data.get("krs"),
+            "nip": extracted_data.get("nip"),
+            "kapital_zakladowy": extracted_data.get("kapitalZakladowy"),
+        },
+        "wspolnicy_bezposredni": [
+            f"{w.get('imiona')} {w.get('nazwa')} (Spółka: {w.get('is_spolka')})"
+            for w in extracted_data.get("wspolnicy", [])
+        ],
+        "zarzad": [
+            f"{z.get('imiona')} {z.get('nazwa')} - {z.get('funkcja')}"
+            for z in extracted_data.get("zarzad", [])
+        ],
+        "wykryte_relacje_grafowe": network
+        if network
+        else "Brak zidentyfikowanych powiązań sieciowych w bazie GraphRAG poza bezpośrednio ujawnionymi w odpisie.",
+        "rekomendacja_msp": "UWAGA: Jeżeli w sekcji 'wykryte_relacje_grafowe' zidentyfikowano inne spółki, kapitał, zatrudnienie lub przychody z tych firm mogą wliczać się w weryfikację statusu MŚP analizowanej firmy!",
+    }

backend/agents/tools/legal_retriever_tool.py

@@ -0,0 +1,94 @@
+from typing import Optional
+from langchain_core.tools import tool
+from rag_pipeline.hybrid_retriever import get_hybrid_retriever
+import logging
+
+logger = logging.getLogger(__name__)
+
+
+@tool
+def search_legal_documents(
+    query: str,
+    rok_perspektywy: Optional[str] = None,
+    program_name: Optional[str] = None,
+    date_from: Optional[str] = None,
+    date_to: Optional[str] = None,
+    namespace: Optional[str] = "default",
+) -> str:
+    """
+    Wyszukuje akty prawne, wytyczne oraz dokumenty funduszowe w wektorowej bazie wiedzy (RAG).
+    Wykorzystuj to narzędzie ZAWSZE, gdy potrzebujesz zweryfikować kwalifikowalność, obowiązki beneficjenta,
+    lub zasady konkursowe.
+
+    Argumenty:
+    - query: Szczegółowe zapytanie, np. "warunki kwalifikowalności kosztów wynagrodzeń".
+    - rok_perspektywy: (Opcjonalnie) filtr na perspektywę UE, np. "2021-2027".
+    - program_name: (Opcjonalnie) filtr na konkretny program, np. "Ścieżka SMART".
+    - date_from: (Opcjonalnie) filtr od daty publikacji dokumentu (YYYY-MM-DD).
+    - date_to: (Opcjonalnie) filtr do daty publikacji dokumentu (YYYY-MM-DD).
+    - namespace: (Opcjonalnie) ID przestrzeni klienta. Domyślnie "default".
+
+    Zwraca streszczenie znalezionych dokumentów z ich metadanymi. Jeśli wynik jest pusty lub
+    stwierdzisz po odczycie niedopasowanie bazy, PRZEFORMUŁUJ wyszukiwanie w kolejnym kroku grafu.
+    """
+    logger.info(
+        f"[LegalRetrieverTool] Otrzymano zapytanie: {query} | Rok: {rok_perspektywy} | Program: {program_name} | Od: {date_from} | Do: {date_to} | Namespace: {namespace}"
+    )
+
+    metadata_filter = {}
+    if rok_perspektywy:
+        metadata_filter["rok_perspektywy"] = {"$eq": rok_perspektywy}
+    if program_name:
+        metadata_filter["program_name"] = {"$eq": program_name}
+    
+    if date_from or date_to:
+        date_filter = {}
+        if date_from:
+            date_filter["$gte"] = date_from
+        if date_to:
+            date_filter["$lte"] = date_to
+        metadata_filter["date"] = date_filter
+        
+    if not metadata_filter:
+        metadata_filter = None
+
+    retriever = get_hybrid_retriever(
+        k=4,
+        metadata_filter=metadata_filter,
+        namespace=namespace,
+        # Multi-stage for higher precision on legal/regulation queries (recall 16 -> CE rerank to 4)
+        retrieval_k=16,
+        rerank_top_n=4,
+        use_reranker=True,
+    )
+
+    if not retriever:
+        return "Błąd techniczny: Baza wiedzy (wektorowa) jest niedostępna lub retriever nie został utworzony."
+
+    docs = retriever.invoke(query)
+
+    if not docs:
+        # Fallback do live legal sources (EUR-Lex) — najwyższa wiarygodność
+        try:
+            from integrations.eurlex_client import EURLexClient
+            client = EURLexClient()
+            live = client.search_legal_acts(query, limit=3)
+            if live:
+                live_text = "\n".join([f"- {l.get('title','')} | {l.get('url','')}" for l in live if not l.get('error')])
+                return f"[LIVE EUR-LEX FALLBACK - źródło prawdy UE]\n{live_text}\n\nZalecenie: Zweryfikuj bezpośrednio w EUR-Lex dla pełnej aktualności."
+        except Exception:
+            pass
+        return "Brak pasujących dokumentów w bazie wiedzy dla tej perspektywy i zapytania. Przeformułuj zapytanie bazowe!"
+
+    results = []
+    for d in docs:
+        source = d.metadata.get("source", "Nieznane")
+        rok = d.metadata.get("rok_perspektywy", "Brak danych o roku")
+        content = d.page_content.replace("\n", " ")[
+            :1000
+        ]  # Ograniczenie by LLM się nie zgubił
+        results.append(
+            f"--- DOKUMENT: {source} (Perspektywa: {rok}) ---\nTREŚĆ: {content}..."
+        )
+
+    return "\n\n".join(results)

backend/agents/tools/neo4j_cypher_tool.py

@@ -0,0 +1,46 @@
+import logging
+from typing import Dict, Any
+from langchain_core.tools import tool
+from core.graph_db.neo4j_client import neo4j_client
+
+logger = logging.getLogger(__name__)
+
+
+@tool
+def query_neo4j_graph(cypher_query: str) -> Dict[str, Any]:
+    """
+    Narzędzie dla LLM do samodzielnego odpytywania bazy grafowej Neo4j za pomocą języka Cypher.
+    Służy do analizowania powiązań między firmami, udziałowcami i weryfikacji statusu MŚP (związki kapitałowe).
+
+    Przykład użycia (Cypher):
+    MATCH (c:Company {krs: '0000123456'})<-[r:OWNS]-(owner) RETURN owner.name, r.share_percentage
+
+    Zwraca słownik zawierający wyniki zapytania lub błąd.
+    """
+    logger.info(f"LLM uruchamia zapytanie Cypher: {cypher_query}")
+
+    try:
+        # Sprawdzamy, czy połączenie z Neo4j jest aktywne
+        if not neo4j_client.driver:
+            neo4j_client.connect()
+            if not neo4j_client.driver:
+                return {
+                    "error": "Brak połączenia z bazą Neo4j AuraDB. Spróbuj ponownie później lub przejdź do alternatywnych metod analizy."
+                }
+
+        # Wykonaj zapytanie (zabezpieczone try-except w _execute_query)
+        results = neo4j_client._execute_query(cypher_query)
+
+        if not results:
+            return {"results": [], "message": "Zapytanie nie zwróciło żadnych wyników."}
+
+        # Formatowanie wyników (record.data() to domyślna metoda rekordu neo4j)
+        formatted_results = [
+            record.data() if hasattr(record, "data") else dict(record)
+            for record in results
+        ]
+
+        return {"results": formatted_results, "count": len(formatted_results)}
+    except Exception as e:
+        logger.error(f"Błąd podczas wykonywania zapytania Cypher przez LLM: {str(e)}")
+        return {"error": f"Błąd wykonania zapytania: {str(e)}"}

backend/agents/tools/technology_retriever_tool.py

@@ -0,0 +1,31 @@
+from langchain_core.tools import tool
+from rag_pipeline.hybrid_retriever import get_hybrid_retriever
+
+
+@tool
+def search_technology_trends(query: str, program_name: str = "") -> str:
+    """
+    Wyszukuje informacje w bazie wiedzy (RAG) na temat trendów technologicznych,
+    wymogów KIS (Krajowych Inteligentnych Specjalizacji) oraz odpowiednich
+    poziomów TRL (Technology Readiness Level) dla projektów badawczych i innowacyjnych.
+
+    Args:
+        query (str): Pytanie dotyczące wymogów technologicznych, np. "Jakie są wytyczne dla prac B+R w KPO?"
+        program_name (str): Opcjonalnie nazwa programu, np. "FENG Ścieżka SMART".
+    """
+    retriever = get_hybrid_retriever()
+    search_query = (
+        f"[Innowacje, KIS, B+R, TRL] Program: {program_name}. Zapytanie: {query}"
+    )
+
+    docs = retriever.invoke(search_query)
+    if not docs:
+        return "Nie znaleziono w bazie specyficznych wymogów wpisujących się w to zapytanie o poziomie innowacyjności/B+R."
+
+    result = "\n".join(
+        [
+            f"- Zródło: {d.metadata.get('source', 'nieznane')}\n{d.page_content}"
+            for d in docs
+        ]
+    )
+    return f"Wyniki wyszukiwania dla wymogów technologicznych i B+R:\n{result}"

backend/agents/verifier.py

@@ -0,0 +1,44 @@
+from schemas import AgentState
+from core.llm_router import get_llm
+from tenacity import retry, stop_after_attempt, wait_exponential
+
+
+def verifier_node(state: AgentState):
+    parsed_content = (
+        state.verification_results.get("pending_doc_text")
+        if state.verification_results
+        else None
+    )
+    if not parsed_content:
+        return {
+            "verification_results": {
+                "status": "brak_dokumentu",
+                "analysis": "Brak dokumentu dodanego do weryfikacji.",
+            },
+            "current_agent": "supervisor",
+        }
+
+    try:
+        llm = get_llm(task_type="critical")
+
+        @retry(
+            stop=stop_after_attempt(3),
+            wait=wait_exponential(multiplier=1, min=2, max=10),
+        )
+        def _invoke_llm():
+            return llm.invoke(
+                f"System: Jesteś ekspertem oceny formalnej wniosków PARP. Sprawdź spójność danych.\n"
+                f"Porównaj dane z dokumentu: {parsed_content[:15000]}... z profilem firmy: {state.profile.model_dump() if state.profile else 'Brak'}"
+            )
+
+        response = _invoke_llm()
+        from core.utils import safe_extract_text
+
+        analysis_result = safe_extract_text(response.content)
+    except Exception as e:
+        analysis_result = f"Błąd weryfikacji przez model LLM: {str(e)}"
+
+    return {
+        "verification_results": {"analysis": analysis_result},
+        "current_agent": "supervisor",
+    }

backend/agents/wizard.py

@@ -0,0 +1,191 @@
+from schemas import AgentState
+from typing import Dict, Any
+from core.llm_router import get_llm
+from langchain_core.prompts import PromptTemplate
+from langchain_core.messages import AIMessage
+from core.utils import safe_extract_text
+from rag_pipeline import get_hybrid_retriever, rerank_documents
+
+import os
+from langsmith import traceable
+from langchain_core.tracers.langchain import LangChainTracer
+
+# Włącz tracing LangSmith
+os.environ["LANGCHAIN_TRACING_V2"] = "false"
+os.environ["LANGCHAIN_PROJECT"] = "grantforge-production"
+
+# Opcjonalnie – jeśli chcesz zobaczyć dokładne nazwy runów
+tracer = LangChainTracer(project_name="grantforge-production")
+
+
+@traceable(run_type="chain", name="wizard_node")
+def wizard_node(state: AgentState) -> Dict[str, Any]:
+    """
+    Kreator wniosku połączony z bazą wiedzy (RAG).
+    Wykorzystuje feedback Krytyka w celu iteracyjnej poprawy.
+    """
+
+    # Zabezpieczenie przed pętlą zgodnie ze standardem 2026/HitL
+    if state.critic_iterations >= state.max_critic_iterations:
+        return {
+            "messages": [
+                AIMessage(
+                    content="Osiągnięto maksymalną liczbę iteracji poprawek. Przekazuję tekst do zatwierdzenia przez użytkownika."
+                )
+            ],
+            "critic_evaluation": {
+                "is_approved": True,
+                "feedback": "ZATWIERDZONE_MAX_ITERATIONS_REACHED",
+                "severity": "low",
+            },
+        }
+
+    import logging
+
+    logger = logging.getLogger(__name__)
+
+    last_user_message = (
+        state.messages[-1].content if state.messages else "Stwórz biznesplan"
+    )
+
+    hard_filter = (
+        {"program_name": state.program_name}
+        if hasattr(state, "program_name") and state.program_name
+        else None
+    )
+
+    # Przekazanie namespace z contextu dzierżawcy do pinecone
+    namespace = getattr(state, "tenant_id", None)
+    logger.info(f"[Wizard] Inicjalizacja generowania. Użytkownik/Tenant: '{namespace}'")
+    retriever = get_hybrid_retriever(
+        k=10, metadata_filter=hard_filter, namespace=namespace
+    )
+
+    context_text = ""
+    if retriever:
+        try:
+            docs = retriever.invoke(last_user_message)
+            reranked_docs = rerank_documents(last_user_message, docs, top_n=5)
+            context_text = "\n\n".join(
+                [
+                    f"[ŹRÓDŁO: {d.metadata.get('source', 'Nieznane')} | STRONA: {d.metadata.get('page', 'Brak')}]:\n{d.page_content}"
+                    for d in reranked_docs
+                ]
+            )
+        except Exception as e:
+            context_text = (
+                f"Brak wiedzy w lokalnej bazie ze względu na błąd RAG: {str(e)}"
+            )
+    else:
+        context_text = "Brak podłączonej bazy wektorowej. Działam na bazowej wiedzy."
+
+    # W architekturze 2026 Wizard to model krytyczny (Gemini Pro) z opcjonalnym streamingiem
+    # LLM zainicjalizujemy poniżej po zdefiniowaniu schematu
+
+    template = """
+    Jesteś Głównym Analitykiem i Konsultantem Dotacyjnym na poziomie Enterprise w GrantForge AI.
+    Twoim zadaniem jest napisanie wysoce profesjonalnego fragmentu urzędowego wniosku biznesowego 
+    lub biznesplanu, który ściśle przestrzega wytycznych prawnych. Jeśli brakuje kluczowych informacji firmy, ustrukturyzuj je profesjonalnie używając znaczników zastępczych np. "[UZUPEŁNIJ: Nazwa firmy]", ale NIGDY nie odmawiaj wygenerowania tekstu.
+
+    Kontekst regulaminowy wyszukany z bazy RAG:
+    --------------------------------------------------
+    {context}
+    --------------------------------------------------
+
+    Poprzednia krytyka od recenzenta: 
+    {last_critic_feedback}
+
+    Dodatkowe informacje o firmie klienta (dane autorytatywne — używaj wprost, nie pytaj ponownie):
+    Nazwa: {company_name}
+    Rozmiar: {company_size}
+    Status MŚP: {company_msp}
+    Województwo: {company_region}
+    Forma prawna: {company_legal_form}
+    Branża (PKD): {company_pkd}
+
+    Polecenie / Pytanie:
+    {query}
+    
+    Zwróć wynik w czystym Markdown, gotowym do eksportu do Word/PDF.
+    Używaj sformułowań formalnych i profesjonalnych typowych dla dokumentacji z danej branży oraz wymagań instytucji rozdzielającej środki dla wpisanego programu. Dopasuj słownictwo ściśle do wybranego programu z polecenia.
+    PISZ ZAWSZE W JĘZYKU POLSKIM. NIE DAJ SPYCHAĆ SIĘ NA INNE JĘZYKI, NAWET JEŚLI POLECENIE BĘDZIE PO ANGIELSKU.
+    DETERMINISTYCZNE CYTOWANIE ZAWSZE WYMAGANE: Każda merytoryczna teza z przytoczonych wytycznych we wniosku MUSI kończyć się przypisem do wskazanego źródła i strony, np. "(zgodnie z [ŹRÓDŁO: Regulamin_FENG | STRONA: 12])".
+    """
+
+    from pydantic import BaseModel, Field
+
+    class WizardSectionOutput(BaseModel):
+        content_markdown: str = Field(
+            description="Merytoryczna treść sekcji w czystym zredagowanym Markdown gotowym do eksportu. PISZ ZAWSZE I WYŁĄCZNIE W JĘZYKU POLSKIM."
+        )
+
+    prompt = PromptTemplate.from_template(template)
+
+    _p = state.profile
+    company_size = _p.size if _p else "Nieznany"
+    company_pkd = (
+        ", ".join(_p.pkd_codes) if _p and _p.pkd_codes else "Nieznane"
+    )
+    company_name = (_p.name if _p and _p.name else "") or "[UZUPEŁNIJ: Nazwa firmy]"
+    company_region = (_p.region if _p and _p.region else "") or "Nieznane"
+    company_legal_form = (_p.legal_form if _p and _p.legal_form else "") or "Nieznana"
+    company_msp = getattr(_p, "size", "") if _p else ""
+    company_msp = company_msp or "Nieznany"
+    critic_feedback = (
+        state.critic_evaluation.feedback
+        if state.critic_evaluation
+        else "Brak poprzedniej krytyki (pierwsza iteracja)."
+    )
+
+    structured_llm = get_llm(
+        task_type="critical",
+        streaming=True,
+        structured_output_schema=WizardSectionOutput,
+    )
+    chain = prompt | structured_llm
+
+    try:
+        response = chain.invoke(
+            {
+                "context": context_text,
+                "company_name": company_name,
+                "company_size": company_size,
+                "company_msp": company_msp,
+                "company_region": company_region,
+                "company_legal_form": company_legal_form,
+                "company_pkd": company_pkd,
+                "last_critic_feedback": critic_feedback,
+                "query": last_user_message,
+            }
+        )
+    except Exception as e:
+        logger.error(f"[Wizard] LLM Error during section generation: {e}")
+        from pydantic import BaseModel
+
+        # Zastępczy model zgodny ze strukturą oczekiwaną przez WizardSectionOutput
+        response = type(
+            "DummyResponse",
+            (),
+            {
+                "content_markdown": f"⚠️ **Błąd generowania sekcji**. Sprawdź klucz API Google lub połączenie z modelem lokalnym. Szczegóły: {e}"
+            },
+        )()
+
+    current_step = state.wizard_step + 1
+
+    # Dodajemy wersjonowanie dokumentów
+    doc_versions = dict(state.document_versions) if state.document_versions else {}
+    if "current_draft" not in doc_versions:
+        doc_versions["current_draft"] = []
+
+    flat_content = safe_extract_text(response.content_markdown)
+
+    doc_versions["current_draft"].append(flat_content)
+
+    return {
+        "wizard_step": current_step,
+        "document_versions": doc_versions,
+        "messages": [{"role": "assistant", "content": flat_content}],
+        "critic_iterations": state.critic_iterations + 1,
+        # Routing wizard -> critic przejęty przez graph.py
+    }

backend/alembic.ini

@@ -0,0 +1,149 @@
+# A generic, single database configuration.
+
+[alembic]
+# path to migration scripts.
+# this is typically a path given in POSIX (e.g. forward slashes)
+# format, relative to the token %(here)s which refers to the location of this
+# ini file
+script_location = %(here)s/alembic
+
+# template used to generate migration file names; The default value is %%(rev)s_%%(slug)s
+# Uncomment the line below if you want the files to be prepended with date and time
+# see https://alembic.sqlalchemy.org/en/latest/tutorial.html#editing-the-ini-file
+# for all available tokens
+# file_template = %%(year)d_%%(month).2d_%%(day).2d_%%(hour).2d%%(minute).2d-%%(rev)s_%%(slug)s
+# Or organize into date-based subdirectories (requires recursive_version_locations = true)
+# file_template = %%(year)d/%%(month).2d/%%(day).2d_%%(hour).2d%%(minute).2d_%%(second).2d_%%(rev)s_%%(slug)s
+
+# sys.path path, will be prepended to sys.path if present.
+# defaults to the current working directory.  for multiple paths, the path separator
+# is defined by "path_separator" below.
+prepend_sys_path = .
+
+
+# timezone to use when rendering the date within the migration file
+# as well as the filename.
+# If specified, requires the tzdata library which can be installed by adding
+# `alembic[tz]` to the pip requirements.
+# string value is passed to ZoneInfo()
+# leave blank for localtime
+# timezone =
+
+# max length of characters to apply to the "slug" field
+# truncate_slug_length = 40
+
+# set to 'true' to run the environment during
+# the 'revision' command, regardless of autogenerate
+# revision_environment = false
+
+# set to 'true' to allow .pyc and .pyo files without
+# a source .py file to be detected as revisions in the
+# versions/ directory
+# sourceless = false
+
+# version location specification; This defaults
+# to <script_location>/versions.  When using multiple version
+# directories, initial revisions must be specified with --version-path.
+# The path separator used here should be the separator specified by "path_separator"
+# below.
+# version_locations = %(here)s/bar:%(here)s/bat:%(here)s/alembic/versions
+
+# path_separator; This indicates what character is used to split lists of file
+# paths, including version_locations and prepend_sys_path within configparser
+# files such as alembic.ini.
+# The default rendered in new alembic.ini files is "os", which uses os.pathsep
+# to provide os-dependent path splitting.
+#
+# Note that in order to support legacy alembic.ini files, this default does NOT
+# take place if path_separator is not present in alembic.ini.  If this
+# option is omitted entirely, fallback logic is as follows:
+#
+# 1. Parsing of the version_locations option falls back to using the legacy
+#    "version_path_separator" key, which if absent then falls back to the legacy
+#    behavior of splitting on spaces and/or commas.
+# 2. Parsing of the prepend_sys_path option falls back to the legacy
+#    behavior of splitting on spaces, commas, or colons.
+#
+# Valid values for path_separator are:
+#
+# path_separator = :
+# path_separator = ;
+# path_separator = space
+# path_separator = newline
+#
+# Use os.pathsep. Default configuration used for new projects.
+path_separator = os
+
+# set to 'true' to search source files recursively
+# in each "version_locations" directory
+# new in Alembic version 1.10
+# recursive_version_locations = false
+
+# the output encoding used when revision files
+# are written from script.py.mako
+# output_encoding = utf-8
+
+# database URL.  This is consumed by the user-maintained env.py script only.
+# other means of configuring database URLs may be customized within the env.py
+# file.
+sqlalchemy.url = driver://user:pass@localhost/dbname
+
+
+[post_write_hooks]
+# post_write_hooks defines scripts or Python functions that are run
+# on newly generated revision scripts.  See the documentation for further
+# detail and examples
+
+# format using "black" - use the console_scripts runner, against the "black" entrypoint
+# hooks = black
+# black.type = console_scripts
+# black.entrypoint = black
+# black.options = -l 79 REVISION_SCRIPT_FILENAME
+
+# lint with attempts to fix using "ruff" - use the module runner, against the "ruff" module
+# hooks = ruff
+# ruff.type = module
+# ruff.module = ruff
+# ruff.options = check --fix REVISION_SCRIPT_FILENAME
+
+# Alternatively, use the exec runner to execute a binary found on your PATH
+# hooks = ruff
+# ruff.type = exec
+# ruff.executable = ruff
+# ruff.options = check --fix REVISION_SCRIPT_FILENAME
+
+# Logging configuration.  This is also consumed by the user-maintained
+# env.py script only.
+[loggers]
+keys = root,sqlalchemy,alembic
+
+[handlers]
+keys = console
+
+[formatters]
+keys = generic
+
+[logger_root]
+level = WARNING
+handlers = console
+qualname =
+
+[logger_sqlalchemy]
+level = WARNING
+handlers =
+qualname = sqlalchemy.engine
+
+[logger_alembic]
+level = INFO
+handlers =
+qualname = alembic
+
+[handler_console]
+class = StreamHandler
+args = (sys.stderr,)
+level = NOTSET
+formatter = generic
+
+[formatter_generic]
+format = %(levelname)-5.5s [%(name)s] %(message)s
+datefmt = %H:%M:%S

backend/alembic/README

@@ -0,0 +1 @@
+Generic single-database configuration.

backend/alembic/env.py

@@ -0,0 +1,93 @@
+# ruff: noqa: E402
+from logging.config import fileConfig
+
+from sqlalchemy import engine_from_config
+from sqlalchemy import pool
+
+from alembic import context
+
+# this is the Alembic Config object, which provides
+# access to the values within the .ini file in use.
+config = context.config
+
+# Interpret the config file for Python logging.
+# This line sets up loggers basically.
+if config.config_file_name is not None:
+    fileConfig(config.config_file_name)
+
+# add your model's MetaData object here
+# for 'autogenerate' support
+import os
+import sys
+
+sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), "..")))
+from dotenv import load_dotenv
+
+load_dotenv()
+
+# Use the shared init_models() so all models are registered on the single Base
+from core.subscription.db import Base, init_models
+init_models()
+
+target_metadata = Base.metadata
+
+db_url = os.getenv("DATABASE_URL", "postgresql://user:password@localhost:5432/dotacje")
+if db_url and db_url.startswith("postgres://"):
+    db_url = db_url.replace("postgres://", "postgresql://", 1)
+
+config.set_main_option("sqlalchemy.url", db_url)
+
+# other values from the config, defined by the needs of env.py,
+# can be acquired:
+# my_important_option = config.get_main_option("my_important_option")
+# ... etc.
+
+
+def run_migrations_offline() -> None:
+    """Run migrations in 'offline' mode.
+
+    This configures the context with just a URL
+    and not an Engine, though an Engine is acceptable
+    here as well.  By skipping the Engine creation
+    we don't even need a DBAPI to be available.
+
+    Calls to context.execute() here emit the given string to the
+    script output.
+
+    """
+    url = config.get_main_option("sqlalchemy.url")
+    context.configure(
+        url=url,
+        target_metadata=target_metadata,
+        literal_binds=True,
+        dialect_opts={"paramstyle": "named"},
+    )
+
+    with context.begin_transaction():
+        context.run_migrations()
+
+
+def run_migrations_online() -> None:
+    """Run migrations in 'online' mode.
+
+    In this scenario we need to create an Engine
+    and associate a connection with the context.
+
+    """
+    connectable = engine_from_config(
+        config.get_section(config.config_ini_section, {}),
+        prefix="sqlalchemy.",
+        poolclass=pool.NullPool,
+    )
+
+    with connectable.connect() as connection:
+        context.configure(connection=connection, target_metadata=target_metadata)
+
+        with context.begin_transaction():
+            context.run_migrations()
+
+
+if context.is_offline_mode():
+    run_migrations_offline()
+else:
+    run_migrations_online()

backend/alembic/script.py.mako

@@ -0,0 +1,28 @@
+"""${message}
+
+Revision ID: ${up_revision}
+Revises: ${down_revision | comma,n}
+Create Date: ${create_date}
+
+"""
+from typing import Sequence, Union
+
+from alembic import op
+import sqlalchemy as sa
+${imports if imports else ""}
+
+# revision identifiers, used by Alembic.
+revision: str = ${repr(up_revision)}
+down_revision: Union[str, Sequence[str], None] = ${repr(down_revision)}
+branch_labels: Union[str, Sequence[str], None] = ${repr(branch_labels)}
+depends_on: Union[str, Sequence[str], None] = ${repr(depends_on)}
+
+
+def upgrade() -> None:
+    """Upgrade schema."""
+    ${upgrades if upgrades else "pass"}
+
+
+def downgrade() -> None:
+    """Downgrade schema."""
+    ${downgrades if downgrades else "pass"}

backend/alembic/versions/0848fd2356d9_sprint2.py

@@ -0,0 +1,43 @@
+"""sprint2
+
+Revision ID: 0848fd2356d9
+Revises: 3109c5f526b6
+Create Date: 2026-04-14 16:24:08.025520
+
+"""
+
+from typing import Sequence, Union
+
+from alembic import op
+import sqlalchemy as sa
+
+
+# revision identifiers, used by Alembic.
+revision: str = "0848fd2356d9"
+down_revision: Union[str, Sequence[str], None] = "3109c5f526b6"
+branch_labels: Union[str, Sequence[str], None] = None
+depends_on: Union[str, Sequence[str], None] = None
+
+
+def upgrade() -> None:
+    """Upgrade schema."""
+    # ### commands auto generated by Alembic - please adjust! ###
+    op.add_column(
+        "users", sa.Column("gdpr_consent_accepted", sa.Boolean(), nullable=True)
+    )
+    op.add_column(
+        "users", sa.Column("gdpr_consent_timestamp", sa.DateTime(), nullable=True)
+    )
+    op.add_column(
+        "users", sa.Column("ai_disclaimer_enabled", sa.Boolean(), nullable=True)
+    )
+    # ### end Alembic commands ###
+
+
+def downgrade() -> None:
+    """Downgrade schema."""
+    # ### commands auto generated by Alembic - please adjust! ###
+    op.drop_column("users", "ai_disclaimer_enabled")
+    op.drop_column("users", "gdpr_consent_timestamp")
+    op.drop_column("users", "gdpr_consent_accepted")
+    # ### end Alembic commands ###

backend/alembic/versions/0e48eb7134d7_add_final_document_columns.py

@@ -0,0 +1,40 @@
+"""add final document columns
+
+Revision ID: 0e48eb7134d7
+Revises: e1922a470e92
+Create Date: 2026-04-11 09:48:13.226601
+
+"""
+
+from typing import Sequence, Union
+
+from alembic import op
+import sqlalchemy as sa
+
+
+# revision identifiers, used by Alembic.
+revision: str = "0e48eb7134d7"
+down_revision: Union[str, Sequence[str], None] = "e1922a470e92"
+branch_labels: Union[str, Sequence[str], None] = None
+depends_on: Union[str, Sequence[str], None] = None
+
+
+def upgrade() -> None:
+    """Upgrade schema."""
+    # ### commands auto generated by Alembic - please adjust! ###
+    op.add_column(
+        "projects", sa.Column("final_document_markdown", sa.Text(), nullable=True)
+    )
+    op.add_column(
+        "projects",
+        sa.Column("final_document_generated_at", sa.DateTime(), nullable=True),
+    )
+    # ### end Alembic commands ###
+
+
+def downgrade() -> None:
+    """Downgrade schema."""
+    # ### commands auto generated by Alembic - please adjust! ###
+    op.drop_column("projects", "final_document_generated_at")
+    op.drop_column("projects", "final_document_markdown")
+    # ### end Alembic commands ###

backend/alembic/versions/0f91b1724111_add_external_context_to_projects.py

@@ -0,0 +1,37 @@
+"""Add external_context to projects
+
+Revision ID: 0f91b1724111
+Revises: 0e48eb7134d7
+Create Date: 2026-04-12 14:15:10.107090
+
+"""
+
+from typing import Sequence, Union
+
+from alembic import op
+import sqlalchemy as sa
+
+
+# revision identifiers, used by Alembic.
+revision: str = "0f91b1724111"
+down_revision: Union[str, Sequence[str], None] = "0e48eb7134d7"
+branch_labels: Union[str, Sequence[str], None] = None
+depends_on: Union[str, Sequence[str], None] = None
+
+
+def upgrade() -> None:
+    """Upgrade schema."""
+    # ### commands auto generated by Alembic - please adjust! ###
+    op.add_column(
+        "projects", sa.Column("final_document_audit_result", sa.JSON(), nullable=True)
+    )
+    op.add_column("projects", sa.Column("external_context", sa.JSON(), nullable=True))
+    # ### end Alembic commands ###
+
+
+def downgrade() -> None:
+    """Downgrade schema."""
+    # ### commands auto generated by Alembic - please adjust! ###
+    op.drop_column("projects", "external_context")
+    op.drop_column("projects", "final_document_audit_result")
+    # ### end Alembic commands ###

backend/alembic/versions/20260527_add_regulation_snapshots.py

@@ -0,0 +1,43 @@
+"""Add regulation_snapshots table (Faza 3 - Regulation Engine primary storage)
+
+Revision ID: 20260527_regsnap
+Revises: f3a9d2c1e005
+Create Date: 2026-05-27
+
+"""
+from alembic import op
+import sqlalchemy as sa
+from sqlalchemy.dialects import postgresql
+
+# revision identifiers, used by Alembic.
+revision = '20260527_regsnap'
+down_revision = 'f3a9d2c1e005'
+branch_labels = None
+depends_on = None
+
+
+def upgrade() -> None:
+    op.create_table(
+        'regulation_snapshots',
+        sa.Column('id', sa.String(), primary_key=True, index=True),
+        sa.Column('program', sa.String(), index=True, nullable=False),
+        sa.Column('call_name', sa.String()),
+        sa.Column('source_url', sa.String()),
+        sa.Column('fetched_at', sa.String()),
+        sa.Column('version_hash', sa.String(), unique=True, index=True),
+        sa.Column('effective_date', sa.String()),
+        sa.Column('document_version', sa.String()),
+        sa.Column('last_updated', sa.String()),
+        sa.Column('source_institution', sa.String()),
+        sa.Column('key_rules', postgresql.JSON(astext_type=sa.Text()), nullable=True),
+        sa.Column('exclusions', postgresql.JSON(astext_type=sa.Text()), nullable=True),
+        sa.Column('scoring_criteria', postgresql.JSON(astext_type=sa.Text()), nullable=True),
+        sa.Column('required_attachments', postgresql.JSON(astext_type=sa.Text()), nullable=True),
+        sa.Column('raw_text_sample', sa.Text()),
+        sa.Column('metadata', postgresql.JSON(astext_type=sa.Text()), nullable=True),
+        sa.Column('created_at', sa.DateTime(timezone=True), server_default=sa.func.now()),
+    )
+
+
+def downgrade() -> None:
+    op.drop_table('regulation_snapshots')

backend/alembic/versions/20260604_add_grants_company_profiles.py

@@ -0,0 +1,81 @@
+"""Add Grants and CompanyProfile models
+
+Revision ID: 20260604_add_grants_company
+Revises: 
+Create Date: 2026-06-04 22:55:00.000000
+
+"""
+from alembic import op
+import sqlalchemy as sa
+
+# revision identifiers, used by Alembic.
+revision = '20260604_add_grants_company'
+down_revision = None
+branch_labels = None
+depends_on = None
+
+def upgrade() -> None:
+    # Grants table
+    op.create_table('grants',
+    sa.Column('id', sa.String(), nullable=False),
+    sa.Column('source_id', sa.String(), nullable=False),
+    sa.Column('name', sa.String(), nullable=False),
+    sa.Column('program', sa.String(), nullable=True),
+    sa.Column('status', sa.String(), nullable=True),
+    sa.Column('url', sa.String(), nullable=True),
+    sa.Column('deadline', sa.String(), nullable=True),
+    sa.Column('source', sa.String(), nullable=False),
+    sa.Column('instrument_type', sa.String(), nullable=True),
+    sa.Column('is_financial_instrument', sa.Boolean(), nullable=True),
+    sa.Column('eligible_company_sizes', sa.JSON(), nullable=True),
+    sa.Column('eligible_regions', sa.JSON(), nullable=True),
+    sa.Column('description', sa.Text(), nullable=True),
+    sa.Column('eurlex_url', sa.String(), nullable=True),
+    sa.Column('official_doc_url', sa.String(), nullable=True),
+    sa.Column('precise_regulation_url', sa.String(), nullable=True),
+    sa.Column('is_outdated_warning', sa.Boolean(), nullable=True),
+    sa.Column('url_warning', sa.String(), nullable=True),
+    sa.Column('fetched_at', sa.DateTime(), nullable=True),
+    sa.Column('last_verified', sa.DateTime(), nullable=True),
+    sa.Column('raw_data', sa.JSON(), nullable=True),
+    sa.PrimaryKeyConstraint('id')
+    )
+    op.create_index(op.f('ix_grants_id'), 'grants', ['id'], unique=False)
+    op.create_index(op.f('ix_grants_source_id'), 'grants', ['source_id'], unique=True)
+    op.create_index(op.f('ix_grants_status'), 'grants', ['status'], unique=False)
+
+    # Company Profiles table
+    op.create_table('company_profiles',
+    sa.Column('id', sa.String(), nullable=False),
+    sa.Column('clerk_user_id', sa.String(), nullable=False),
+    sa.Column('nip', sa.String(), nullable=True),
+    sa.Column('regon', sa.String(), nullable=True),
+    sa.Column('krs', sa.String(), nullable=True),
+    sa.Column('name', sa.String(), nullable=True),
+    sa.Column('size', sa.String(), nullable=True),
+    sa.Column('region', sa.String(), nullable=True),
+    sa.Column('pkd_codes', sa.JSON(), nullable=True),
+    sa.Column('employees', sa.Integer(), nullable=True),
+    sa.Column('turnover', sa.Float(), nullable=True),
+    sa.Column('related_entities', sa.JSON(), nullable=True),
+    sa.Column('last_verified_at', sa.DateTime(), nullable=True),
+    sa.Column('created_at', sa.DateTime(), nullable=True),
+    sa.Column('updated_at', sa.DateTime(), nullable=True),
+    sa.ForeignKeyConstraint(['clerk_user_id'], ['users.clerk_id'], ),
+    sa.PrimaryKeyConstraint('id'),
+    sa.UniqueConstraint('clerk_user_id')
+    )
+    op.create_index(op.f('ix_company_profiles_id'), 'company_profiles', ['id'], unique=False)
+    op.create_index(op.f('ix_company_profiles_clerk_user_id'), 'company_profiles', ['clerk_user_id'], unique=False)
+    op.create_index(op.f('ix_company_profiles_nip'), 'company_profiles', ['nip'], unique=False)
+
+def downgrade() -> None:
+    op.drop_index(op.f('ix_company_profiles_nip'), table_name='company_profiles')
+    op.drop_index(op.f('ix_company_profiles_clerk_user_id'), table_name='company_profiles')
+    op.drop_index(op.f('ix_company_profiles_id'), table_name='company_profiles')
+    op.drop_table('company_profiles')
+
+    op.drop_index(op.f('ix_grants_status'), table_name='grants')
+    op.drop_index(op.f('ix_grants_source_id'), table_name='grants')
+    op.drop_index(op.f('ix_grants_id'), table_name='grants')
+    op.drop_table('grants')