Deploy sha-565ad85979610064f6d1c18ab3b6404357d61073 — 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,69 @@
+---
+title: GrantForge API
+emoji: 🏢
+colorFrom: blue
+colorTo: red
+sdk: docker
+app_port: 7860
+pinned: false
+---
+
+# GrantForge AI (DotacjeAI)
+
+> **Hugging Face Space** — `sdk: docker`, port **7860** (Gunicorn → FastAPI `backend/server:app`).  
+> Nie usuwaj bloku YAML powyżej — bez niego Space zgłasza *config error*.
+
+Platforma B2B: **katalog naborów** (aktualne, z kontrolą linków i regulaminów) → **dopasowanie do firmy** → **generacja wniosku** → **audyt / quality loop** → **eksport PDF/DOCX**.
+
+## Szybki start
+
+| Warstwa | Stack |
+|---------|--------|
+| Frontend | React + TypeScript (Vite), Clerk, Vercel |
+| Backend | FastAPI, PostgreSQL, Neo4j, Pinecone/RAG, HF Space |
+| AI | Router Gemini / xAI, LangGraph autopilot |
+
+```bash
+# Backend
+cd backend && pip install -r requirements.txt
+# ustaw .env (DB, Clerk, LLM keys) — patrz DEPLOYMENT.md
+uvicorn server:app --reload --port 8000
+
+# Frontend
+cd frontend-react && npm install && npm run dev
+```
+
+## Dokumentacja użytkownika i testów
+
+| Plik | Opis |
+|------|------|
+| [docs/PLAN_ECOSYSTEM_2026_IMPLEMENTATION.md](docs/PLAN_ECOSYSTEM_2026_IMPLEMENTATION.md) | **Roadmap ekosystemu 2026** (eligibility → strategy → tax → instruments) |
+| [docs/PLAN_INSTRUMENT_FIRST_PIPELINE.md](docs/PLAN_INSTRUMENT_FIRST_PIPELINE.md) | Warstwa instrument-first (schema, readiness) |
+| [docs/USER_GUIDE.md](docs/USER_GUIDE.md) | Instrukcja obsługi |
+| [docs/TEST_PATH_NEW_ENTITY.md](docs/TEST_PATH_NEW_ENTITY.md) | **Pełna ścieżka testowa** nowego podmiotu |
+| [docs/agents/ROLE_MAP.md](docs/agents/ROLE_MAP.md) | Role GSD → `backend/agents` |
+| [backend/gsd/README.md](backend/gsd/README.md) | Orkiestracja GSD (jednolity runtime) |
+| [docs/CREDIBILITY_PIPELINE.md](docs/CREDIBILITY_PIPELINE.md) | Wiarygodność firm i naborów |
+| [docs/workflow-reports/GRANT_SYSTEM_RESCUE.md](docs/workflow-reports/GRANT_SYSTEM_RESCUE.md) | Raport naprawy katalogu/jakości |
+| [DEPLOYMENT.md](DEPLOYMENT.md) | Deploy |
+
+**GSD / swarm:** cała logika w `backend/gsd/` + `backend/agents/`. Folder `antigravity_grantforge_swarm/` to tylko re-export (deprecated).
+
+W aplikacji: **O programie** (`/about`), **Pomoc** (`/help`), **Beta** (`/beta`).
+
+## Jakość katalogu naborów (skrót)
+
+- Domyślnie `require_certainty=true` — bez starych/martwych programów i bez śmieciowych linków.
+- Regulamin ≠ RODO/privacy/listing; RAG nie wektoryzuje strony naboru zamiast regulaminu.
+- Import WYSZUKIWARKA + verify URL + close grantów poza snapshotem.
+- Quality loop: celowana korekta sekcji (checklist, cytowania), soft-export z grounding.
+
+## Testy
+
+```bash
+cd backend && python3 -m pytest tests/ -q --ignore=tests/test_deepeval_rag.py
+```
+
+## Licencja / kontakt
+
+Użycie produkcyjne zgodnie z regulaminem aplikacji i polityką prywatności w UI.

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,143 @@
+# Dotacje AI - Backend Environment Variables Example
+
+# LLM Providers
+GOOGLE_API_KEY="YOUR_GOOGLE_API_KEY"
+# xAI / Grok (HF Space Secret: XAI_API_KEY) — fallback gdy Gemini 403/billing/dunning
+XAI_API_KEY="YOUR_XAI_API_KEY"
+GROK_API_KEY="YOUR_GROK_API_KEY"
+# XAI_MODEL="grok-4.3"
+# XAI_BASE_URL="https://api.x.ai/v1"
+# Kolejność providerów (primary,fallback).
+# Na Hugging Face Spaces: ustaw PREFER_XAI=true LUB LLM_PRIMARY=xai żeby od razu
+# iść na Grok i pominąć nieudane próby Gemini (szybszy generate-full przy 403/billing).
+# LLM_FALLBACK_ORDER=gemini,xai
+# LLM_PRIMARY=xai
+# PREFER_XAI=false
+# GEMINI_HEALTH_PROBE=true
+GEMINI_EMBEDDING_MODEL="gemini-embedding-001"
+GEMINI_EMBEDDING_DIMENSIONS="768"
+# EMBEDDINGS_PROVIDER=auto  # auto | hash (hash gdy Gemini embeddings 403)
+
+# 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 / Hugging Face Spaces)
+# Local docker-compose: postgresql://user:password@localhost:5432/dotacje
+# Managed / HF Spaces (Aiven, Neon, Supabase, Render): ALWAYS use SSL —
+# DATABASE_URL="postgresql://user:pass@host:5432/dbname?sslmode=require"
+# Or omit ?sslmode= and set:
+# DB_SSLMODE=require
+# Remote hosts default to sslmode=require; localhost defaults to prefer.
+# HF: set secrets in Space Settings → Variables (repo .env is NOT deployed).
+# Neon → Aiven: docs/MIGRATION_NEON_TO_AIVEN.md
+# DB_POOL_RECYCLE=1800
+
+# Tracing and Observability
+LANGCHAIN_API_KEY="YOUR_LANGSMITH_API_KEY"
+LANGCHAIN_TRACING_V2="true"
+LANGCHAIN_PROJECT="GrantForgeAI"
+# Frontend (Vercel): optional Sentry browser DSN — omit to skip init (ErrorBoundary still works)
+# VITE_SENTRY_DSN="https://...@o....ingest.sentry.io/..."
+# VITE_POSTHOG_KEY="phc_..."
+# VITE_CLERK_PUBLISHABLE_KEY="pk_..."
+# VITE_API_URL="https://your-api.example.com/api"
+
+# 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"
+
+# ── Auth / Clerk (P0 security) ──────────────────────────────────────────────
+# Required in production (HF Spaces Secrets) — fail-closed without these:
+# CLERK_ISSUER="https://YOUR_INSTANCE.clerk.accounts.dev"
+# Or pin JWKS directly (preferred if custom domain):
+# CLERK_JWKS_URL="https://YOUR_INSTANCE.clerk.accounts.dev/.well-known/jwks.json"
+# Optional JWT audience check (enable when Clerk JWT template sets aud):
+# CLERK_AUDIENCE="grantforge-api"
+# Clerk webhook signing secret (Dashboard → Webhooks → Signing Secret):
+# CLERK_WEBHOOK_SECRET="whsec_..."
+# Without it, POST /api/webhooks/clerk returns 500 (fail-closed). Startup logs a warning.
+# Dev-only backdoor (NEVER set on HF production):
+# ENV=dev
+# ALLOW_DEV_TOKEN=true
+# Internal seed endpoint (admin JWT required; also blocked in prod unless):
+# ALLOW_INTERNAL_SEED=true
+# Explicit frontend origins for CORS (comma-separated); FRONTEND_URL also added:
+# CORS_ORIGINS="https://grantforge-ai.vercel.app,https://grantforge.pl"
+# FRONTEND_URL="https://grantforge-ai.vercel.app"
+
+# ── Multi-worker SSE tickets (generator stream) ──────────────────────────────
+# Optional Redis; otherwise SQLite file under TMPDIR is used (multi-worker safe).
+# REDIS_URL=redis://localhost:6379/0
+# TICKET_REDIS_URL=redis://localhost:6379/1
+# STREAM_TICKET_TTL_SECONDS=90
+# TICKET_STORE_PATH=/tmp
+
+# ── Company registries (enrichment) ──────────────────────────────────────────
+# GUS_API_KEY=                    # BIR1.1 production key (20 chars)
+# CEIDG_API_KEY=                  # dane.biznes.gov.pl CEIDG v2
+# CEIDG_API_BASE=https://dane.biznes.gov.pl/api/ceidg/v2
+# CEIDG_DISABLED=false
+# SUDOP_API_BASE=https://api-sudop.uokik.gov.pl/sudop-api/1.0.0
+# SUDOP_DISABLED=false
+# BizRaport financial control — official API /api/dane (never commit real credentials)
+# BIZRAPORT_EMAIL=your@email.pl
+# BIZRAPORT_PASSWORD=
+# BIZRAPORT_BASE_URL=https://api.bizraport.pl
+# BIZRAPORT_ROZSZERZ_POLACZENIA=false
+# BIZRAPORT_API_URL=https://your-proxy.example/bizraport/{nip}
+# BIZRAPORT_API_KEY=
+# BIZRAPORT_DISABLED=false
+# BIZRAPORT_TIMEOUT=12
+
+# ── Grant Pulse (phases A–D) ─────────────────────────────────────────────────
+# ENABLE_PULSE_WORKER=true          # process ResearchJob + eurlex batch in scheduler
+# DISABLE_PULSE_WORKER=false
+# PULSE_WORKER_MAX_JOBS=25
+# PULSE_NEW_DAYS=14                 # "new" window
+# PULSE_CLOSING_DAYS=30             # "closing" window
+# ENABLE_DEADLINE_BACKFILL=true     # enqueue/persist missing deadlines from text
+# DOC_INTEL_MIN_CHARS=120           # HTML thinner than this → Crawl4AI fallback
+# ENABLE_STEALTH_FETCH=true         # curl_cffi Chrome fingerprint (PARP/BGK/WAF)
+# STEALTH_IMPERSONATE=chrome        # chrome|chrome120|chrome124|chrome131
+# STEALTH_TIMEOUT=30
+# STEALTH_DOMAINS=parp.gov.pl,bgk.pl,ncbr.gov.pl
+# SSL_RELAXED_DOMAINS=wfosigw.pl,zus.pl   # PDF/HTML TLS verify=False after primary fail
+# FLAKY_FETCH_DOMAINS=funduszeeuropejskie.gov.pl
+# FLAKY_FETCH_TIMEOUT=45
+# FLAKY_PREFER_CACHE=true
+# FLAKY_CACHE_ONLY=false                 # true = skip live scrape for flaky domains
+# ENABLE_LIVE_RESEARCH=true         # detect_grant_changes (false on HF free by default)
+# ENABLE_EURLEX_BATCH=true          # batch CELEX/DU grounding (legal-ID only, never free-text)
+# ENABLE_EURLEX_NETWORK=false       # true = live EUR-Lex SPARQL (off for CI/HF)
+# ENABLE_LAW_WATCH=true
+# ENABLE_STRATEGY_CASCADE=true      # strategy recommend cascade 2026 (default on); false → paths still returned, cascade_enforced=false
+# ENABLE_ELIGIBILITY_SPINE=true     # eligibility spine gates for readiness (default on)
+# ENABLE_TAX_PATHS=true             # tax checklist attach on tax_psi_ulgi (default on)
+# ENABLE_BK2021=false               # BK2021 B2B stub (default OFF); ON = draft alert only, never live scrape
+
+# LAW_WATCHLIST_JSON=[{"program":"FENG","url":"https://..."}]
+# LAW_WATCHLIST_PATH=/path/to/watchlist.json
+# CLERK_WEBHOOK_SECRET=whsec_...    # required for Clerk webhooks (fail-closed without)
+# GUS_API_KEY=                      # BIR 1.1 company lookup (prod)
+# REDIS_URL=                        # multi-worker SSE tickets (falls back to SQLite)
+# ADMIN_EMAIL=bogmaz1@gmail.com     # Nexus Control allowlist (or ADMIN_EMAILS=a@x,b@y)
+# ADMIN_USER_IDS=user_xxx           # Clerk user ids (comma-separated)
+# ADMIN_CLERK_IDS=                  # alias of ADMIN_USER_IDS
+# CLERK_SECRET_KEY=                 # optional: enrich admin check from Clerk user API
+# GENERATOR_STREAM_TICKET_TTL=1800  # SSE ticket lifetime (seconds) for autopilot stream
+# STREAM_TICKET_TTL_SECONDS=90      # default for other short-lived tickets

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,352 @@
+"""
+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 os
+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",
+)
+
+
+def _research_allowed_by_env() -> bool:
+    try:
+        from agents.research_agent import is_titan_research_enabled, titan_research_max_calls
+
+        return is_titan_research_enabled() and titan_research_max_calls() > 0
+    except Exception:
+        return os.environ.get("ENABLE_TITAN_RESEARCH", "true").lower() in ("1", "true", "yes")
+
+
+@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.
+    # HF free tier: default 1 (override via TITAN_RESEARCH_MAX_CALLS).
+    @property
+    def MAX_RESEARCH_CALLS(self) -> int:
+        try:
+            from agents.research_agent import titan_research_max_calls
+
+            return titan_research_max_calls()
+        except Exception:
+            try:
+                return max(0, int(os.environ.get("TITAN_RESEARCH_MAX_CALLS", "1")))
+            except (TypeError, ValueError):
+                return 1
+
+    # ------------------------------------------------------------------
+    # 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). Soft-fail — nigdy nie zabija workera."""
+        if not _research_allowed_by_env():
+            logger.info("[AutoFill] Research TITAN wyłączony/env — pomijam (soft-fail)")
+            return None
+        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.warning(f"[AutoFill] Research soft-fail (non-fatal): {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_allowed_by_env() 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) — soft-fail; nie blokuj/HITL zabijaniem workera
+        if allow_research and _research_allowed_by_env():
+            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/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,871 @@
+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).
+"""
+
+# Enrich with GSD constitutional guard when package is available (no behavior regression if missing)
+try:
+    from gsd.prompts.global_rules_prompts import ANTI_HALLUCINATION_GUARD as _GSD_AH
+
+    if _GSD_AH and _GSD_AH.strip() not in ANTI_HALLUCINATION_PROMPT:
+        ANTI_HALLUCINATION_PROMPT = ANTI_HALLUCINATION_PROMPT.rstrip() + "\n\n" + _GSD_AH.strip()
+except Exception:
+    pass
+
+# 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,99 @@
+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__)
+
+
+def is_titan_research_enabled() -> bool:
+    """HF free-tier guard: disable/limit Research Agent TITAN under memory pressure."""
+    return os.environ.get("ENABLE_TITAN_RESEARCH", "true").lower() in ("1", "true", "yes")
+
+
+def titan_research_max_calls() -> int:
+    try:
+        return max(0, int(os.environ.get("TITAN_RESEARCH_MAX_CALLS", "1")))
+    except (TypeError, ValueError):
+        return 1
+
+
+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.
+        Soft-fail: nigdy nie zabija workera — zwraca pusty string przy błędzie/disable.
+        """
+        if not is_titan_research_enabled() or titan_research_max_calls() <= 0:
+            logger.info(
+                "[Research Agent TITAN] Wyłączony (ENABLE_TITAN_RESEARCH / MAX_CALLS) — soft-fail"
+            )
+            return ""
+
+        logger.info(f"🔎 [Research Agent TITAN] Rozpoczęto głębokie wyszukiwanie dla: {query}")
+        
+        try:
+            # 1. Wykonanie rzeczywistego wyszukiwania w sieci (bez live scrape URL-i)
+            search_results = general_web_search(query)
+        except Exception as e:
+            logger.warning(f"[Research Agent TITAN] Soft-fail web search: {e}")
+            return ""
+        
+        # 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.\n"
+            "6. NIE wymyślaj ani nie cytuj URL-i typu example.com / placeholder — tylko realne źródła z wynikó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.warning(f"[Research Agent TITAN] Soft-fail LLM: {e}")
+            return ""
+
+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,115 @@
+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:
+    try:
+        from integrations.isap_client import ISAPClient
+        from integrations.parp_client import PARPClient
+        from rag_pipeline.scraper import scrape_grant_url
+        from rag_pipeline.ingest import process_and_ingest
+    except ImportError:
+        ISAPClient = None
+        PARPClient = None
+        scrape_grant_url = None
+        process_and_ingest = 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 prawnych (ISAP/EUR-Lex) — NIE dla naborów
+        self.public_namespace = "public_legal"
+        # Nabory / harmonogramy → grants catalog (nie public_legal)
+        self.grants_namespace = "grants_catalog"
+
+    async def run_sync_job(self):
+        """Uruchamia cykliczny proces synchronizacji dotacji i prawa"""
+        if not self.isap_client or not self.parp_client or not scrape_grant_url:
+            logger.error("[AGENT] Brak klientow ISAP/PARP. Synchronizacja anulowana.")
+            return
+
+        logger.info(
+            "[AGENT] Rozpoczęcie automatycznego cyklu synchronizacji bazy wiedzy..."
+        )
+
+        # 1. PARP (Regulaminy Naborów) — Imperva: scrape często pusty → JSON fallback
+        # JSON fallback = wspólny blob z WyszukiwarkaImport → NIE wektoryzuj do public_legal
+        # i NIE ingestuj 4× tego samego pliku per grant key.
+        from rag_pipeline.ingest import is_parp_json_fallback_text
+
+        grants = self.parp_client.fetch_grants()
+        parp_live_ingested = False
+        parp_fallback_seen = False
+        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 not text:
+                    continue
+                if is_parp_json_fallback_text(text):
+                    parp_fallback_seen = True
+                    # DB import (WyszukiwarkaImport) already covers catalog — skip Pinecone
+                    continue
+                process_and_ingest(
+                    text, url, priority="high", namespace=self.grants_namespace
+                )
+                parp_live_ingested = True
+            except Exception as e:
+                logger.error(f"[AGENT] Błąd fetchowania {url}: {e}")
+
+        if parp_fallback_seen and not parp_live_ingested:
+            logger.info(
+                "[AGENT] PARP scrape pusty — skip Pinecone dla dotacje-latest.json "
+                "(katalog pokryty przez WyszukiwarkaImport)"
+            )
+        elif not parp_live_ingested and not parp_fallback_seen:
+            logger.warning(
+                "[AGENT] PARP: brak zawartości ze scrape i z JSON fallback"
+            )
+
+        # 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/agents/world_class_advisor.py

@@ -0,0 +1,628 @@
+"""
+World-class regulation-grounded advisor (pure evaluation path).
+
+Checks application content against a structured advisor brief without requiring
+a live LLM — suitable for unit tests and as a hard gate before soft-pass export.
+"""
+from __future__ import annotations
+
+import re
+from dataclasses import asdict, dataclass, field
+from typing import Any, Dict, List, Optional, Sequence
+
+
+@dataclass
+class AdvisorFinding:
+    code: str
+    severity: str  # critical | major | minor | info
+    message: str
+    category: str  # program_alignment | missing_required | quality | grounding
+    section: str = ""
+    blocking: bool = False
+
+    def to_dict(self) -> Dict[str, Any]:
+        return asdict(self)
+
+
+@dataclass
+class AdvisorReport:
+    passed: bool
+    score: int
+    grounding_mode: str
+    regulation_grounded_pass: bool
+    findings: List[AdvisorFinding] = field(default_factory=list)
+    blockers: List[str] = field(default_factory=list)
+    covered_sections: List[str] = field(default_factory=list)
+    missing_sections: List[str] = field(default_factory=list)
+    missing_attachments_mentioned: List[str] = field(default_factory=list)
+    attention_addressed: List[str] = field(default_factory=list)
+    attention_open: List[str] = field(default_factory=list)
+    brief_usable: bool = False
+    summary: str = ""
+
+    def to_dict(self) -> Dict[str, Any]:
+        d = asdict(self)
+        d["findings"] = [f if isinstance(f, dict) else f.to_dict() for f in self.findings]
+        return d
+
+
+def _norm(s: str) -> str:
+    return re.sub(r"\s+", " ", (s or "").lower().strip())
+
+
+# Generic tokens that must NOT count as rule hits (corporate fluff matches these)
+_RULE_STOPWORDS = frozenset(
+    {
+        "wnioskodawca",
+        "beneficjent",
+        "projekt",
+        "projekty",
+        "musi",
+        "muszą",
+        "powinien",
+        "powinna",
+        "posiadać",
+        "posiada",
+        "status",
+        "oraz",
+        "przez",
+        "który",
+        "która",
+        "które",
+        "zgodnie",
+        "zawierać",
+        "zawiera",
+        "następujące",
+        "elementy",
+        "wymagane",
+        "wymagany",
+        "opis",
+        "treść",
+        "sekcja",
+        "program",
+        "naboru",
+        "regulamin",
+        "sprawdź",
+        "potwierdź",
+        "udokumentuj",
+        "przygotuj",
+        "zweryfikuj",
+        "uwzględnij",
+        "punkt",
+        "uwagi",
+        "minimum",
+        "wynosi",
+        "kosztów",
+        "koszty",
+        "koszt",
+        "zasada",
+        "spełniać",
+        "spełnia",
+    }
+)
+
+# Domain signals that, if present in brief, must appear in the application
+_CORE_SIGNAL_GROUPS: List[tuple[str, tuple[str, ...]]] = [
+    ("mśp", ("mśp", "msp", "mikroprzedsiębior", "małe przedsiębior", "średnie przedsiębior", "mikro firma")),
+    ("dnsh", ("dnsh", "do no significant harm", "significant harm", "wpływ na środowisko", "wpływ środowisk")),
+    ("wkład_własny", ("wkład własny", "wklad wlasny", "finansowanie własne", "finansowanie wlasne")),
+    ("de_minimis", ("de minimis", "pomoc publiczna", "pomocy publicznej")),
+    ("trl", ("trl", "gotowości technologicz", "gotowosci technologicz")),
+    ("niekwalifikowalne", ("niekwalifikow", "koszty niekwalifikowalne")),
+]
+
+
+def _blob_from_sections(sections: Optional[Dict[str, str]], document_text: str = "") -> str:
+    parts: List[str] = []
+    if document_text:
+        parts.append(document_text)
+    if sections:
+        for title, body in sections.items():
+            parts.append(f"## {title}\n{body or ''}")
+    return "\n".join(parts)
+
+
+def _section_present(required: str, sections: Dict[str, str], blob: str) -> bool:
+    """True if required section has meaningful content under a matching title."""
+    nr = _norm(required)
+    if not nr:
+        return True
+    # Direct title match with substantial body only (no free-text weak match)
+    for title, body in (sections or {}).items():
+        nt = _norm(title)
+        if nr in nt or nt in nr or difflib_ratio(nr, nt) >= 0.55:
+            if body and len(body.strip()) >= 80 and "[UZUPEŁNIĆ" not in body:
+                return True
+    return False
+
+
+def difflib_ratio(a: str, b: str) -> float:
+    import difflib
+
+    return difflib.SequenceMatcher(None, a, b).ratio()
+
+
+def _distinctive_terms_from_rule(rule: str) -> List[str]:
+    """
+    Extract distinctive multi-token phrases / domain terms from a rule.
+    Drops stopwords so 'Projekt musi…' alone never counts as alignment.
+    """
+    n = _norm(rule)
+    terms: List[str] = []
+    # Prefer known domain multi-word / acronyms first
+    for _name, variants in _CORE_SIGNAL_GROUPS:
+        for v in variants:
+            if v in n:
+                terms.append(v)
+    # Multi-word chunks of 2–3 content words
+    words = re.findall(r"[a-ząćęłńóśźż0-9%]{3,}", n)
+    content = [w for w in words if w not in _RULE_STOPWORDS and len(w) >= 4]
+    for i in range(len(content) - 1):
+        bigram = f"{content[i]} {content[i + 1]}"
+        if bigram not in terms:
+            terms.append(bigram)
+    # Long single tokens (≥7) that aren't stopwords — acronyms like mśp already handled
+    for w in content:
+        if len(w) >= 7 and w not in terms and w not in _RULE_STOPWORDS:
+            terms.append(w)
+    return terms[:12]
+
+
+def rule_is_addressed(rule: str, blob: str) -> bool:
+    """True only when distinctive signal(s) from the rule appear in application text."""
+    b = _norm(blob)
+    if not b or not rule:
+        return False
+    terms = _distinctive_terms_from_rule(rule)
+    if not terms:
+        # No distinctive content in rule → cannot claim hit from fluff
+        return False
+    # Need at least one multi-word term OR two distinct single-domain hits
+    multi = [t for t in terms if " " in t or any(t in g[1] for g in _CORE_SIGNAL_GROUPS)]
+    hits = [t for t in terms if t in b]
+    if not hits:
+        return False
+    if any(t in b for t in multi):
+        return True
+    # Single long distinctive tokens: require ≥2 different hits for generic rules
+    single_hits = [t for t in hits if " " not in t and len(t) >= 7]
+    return len(set(single_hits)) >= 2 or (len(single_hits) >= 1 and any(t in b for t in multi))
+
+
+def core_signals_required_by_brief(brief: Dict[str, Any]) -> List[str]:
+    """Which core domain signals appear in brief (rules + attention + eligibility)."""
+    blob = " ".join(
+        [
+            " ".join(str(x) for x in (brief.get("key_rules") or [])),
+            " ".join(str(x) for x in (brief.get("attention_points") or [])),
+            " ".join(str(x) for x in (brief.get("eligibility_signals") or [])),
+            " ".join(str(x) for x in (brief.get("funding_limits") or [])),
+        ]
+    )
+    n = _norm(blob)
+    required: List[str] = []
+    for name, variants in _CORE_SIGNAL_GROUPS:
+        if any(v in n for v in variants):
+            required.append(name)
+    return required
+
+
+def core_signal_present(name: str, blob: str) -> bool:
+    b = _norm(blob)
+    for gname, variants in _CORE_SIGNAL_GROUPS:
+        if gname == name:
+            return any(v in b for v in variants)
+    return False
+
+
+def _attention_is_critical(point: str) -> bool:
+    p = _norm(point)
+    critical_markers = (
+        "dnsh",
+        "środowisk",
+        "srodowisk",
+        "mśp",
+        "msp",
+        "wkład",
+        "własn",
+        "wlasn",
+        "de minimis",
+        "pomoc publiczn",
+        "trl",
+        "niekwalifikow",
+    )
+    return any(m in p for m in critical_markers)
+
+
+def _attention_addressed(point: str, blob: str) -> bool:
+    p = _norm(point)
+    b = _norm(blob)
+    keywords: List[str] = []
+    if "dnsh" in p or "środowisk" in p or "srodowisk" in p:
+        keywords = ["dnsh", "do no significant harm", "wpływ na środowisko", "wpływ środowisk", "środowisk", "srodowisk"]
+    elif "mśp" in p or "msp" in p:
+        keywords = ["mśp", "msp", "mikroprzedsiębior", "małe przedsiębior", "średnie przedsiębior"]
+    elif "wkład" in p or "własn" in p or "wlasn" in p:
+        keywords = ["wkład własny", "wklad wlasny", "finansowanie własne", "finansowanie wlasne"]
+    elif "de minimis" in p or "pomoc publiczn" in p:
+        keywords = ["de minimis", "pomoc publiczna", "pomocy publicznej"]
+    elif "trl" in p:
+        keywords = ["trl", "gotowości technologicz", "gotowosci technologicz"]
+    elif "załącznik" in p or "zalacznik" in p:
+        keywords = ["załącznik", "zalacznik", "oświadczenie", "oswiadczenie"]
+    elif "niekwalifikow" in p:
+        keywords = ["niekwalifikow", "koszty niekwalifikowalne"]
+    else:
+        # Require multi-token distinctive match, not lone stopwords
+        keywords = _distinctive_terms_from_rule(point)[:4]
+    if not keywords:
+        return False
+    return any(k in b for k in keywords)
+
+
+def evaluate_application(
+    *,
+    document_text: str = "",
+    sections: Optional[Dict[str, str]] = None,
+    brief: Optional[Dict[str, Any]] = None,
+    grounding_mode: str = "regulation",
+    min_score: int = 70,
+    min_section_chars: int = 80,
+) -> AdvisorReport:
+    """
+    Evaluate application against regulation-derived brief.
+
+    structure_only / blocked / blind modes never yield regulation_grounded_pass=True.
+    """
+    brief = brief if isinstance(brief, dict) else {}
+    sections = sections if isinstance(sections, dict) else {}
+    mode = (grounding_mode or "regulation").lower().strip()
+    blob = _blob_from_sections(sections, document_text)
+    findings: List[AdvisorFinding] = []
+    score = 100
+
+    # --- Grounding hard rules ---
+    if mode in ("structure_only", "blocked", "blind"):
+        findings.append(
+            AdvisorFinding(
+                code="GROUNDING_NOT_REGULATION",
+                severity="critical",
+                message=(
+                    f"Tryb {mode}: ocena nie może zakończyć się regulation-grounded pass. "
+                    "Brak ugruntowania w regulaminie naboru."
+                ),
+                category="grounding",
+                blocking=True,
+            )
+        )
+        score -= 40
+
+    usable = bool(brief.get("usable")) if "usable" in brief else (
+        bool(brief.get("key_rules") or brief.get("required_sections") or brief.get("required_attachments"))
+    )
+    if mode == "regulation" and not usable and not (
+        brief.get("key_rules") or brief.get("required_sections")
+    ):
+        findings.append(
+            AdvisorFinding(
+                code="BRIEF_EMPTY",
+                severity="critical",
+                message="Brief doradcy pusty — brak reguł/sekcji z regulaminu. Nie można ugruntować oceny.",
+                category="grounding",
+                blocking=True,
+            )
+        )
+        score -= 35
+
+    # --- Instrument mismatch (Eurogranty vs SMART modules etc.) ---
+    try:
+        from core.projects.instrument_profile import (
+            detect_instrument_mismatch,
+            resolve_program_type,
+        )
+
+        prog_type = str(
+            brief.get("program_type")
+            or (brief.get("instrument_program_type") if isinstance(brief, dict) else "")
+            or ""
+        )
+        # Allow caller to pass via document_text meta later; also scan section titles
+        mismatch = detect_instrument_mismatch(
+            program_type=prog_type or resolve_program_type(program_name=str(brief.get("name") or "")),
+            document_text=blob,
+            section_titles=list(sections.keys()),
+        )
+        if mismatch.get("mismatch"):
+            for msg in mismatch.get("findings") or []:
+                findings.append(
+                    AdvisorFinding(
+                        code="INSTRUMENT_MISMATCH",
+                        severity="critical",
+                        message=msg,
+                        category="program_alignment",
+                        blocking=bool(mismatch.get("blocking")),
+                    )
+                )
+            score -= int(mismatch.get("score_penalty") or 0)
+    except Exception:
+        pass
+
+    # --- Required sections (program alignment + missing elements) ---
+    required_sections = list(brief.get("required_sections") or [])
+    covered: List[str] = []
+    missing: List[str] = []
+    for req in required_sections:
+        if _section_present(req, sections, blob):
+            covered.append(req)
+        else:
+            missing.append(req)
+            findings.append(
+                AdvisorFinding(
+                    code="MISSING_REQUIRED_SECTION",
+                    severity="critical",
+                    message=f"Brak wymaganej sekcji/treści: {req}",
+                    category="missing_required",
+                    section=req,
+                    blocking=True,
+                )
+            )
+            score -= 12
+
+    # --- Key rules: distinctive multi-token / domain coverage (no fluff hits) ---
+    rules = list(brief.get("key_rules") or [])
+    rules_hit = 0
+    rules_checked = rules[:12]
+    for rule in rules_checked:
+        if rule_is_addressed(rule, blob):
+            rules_hit += 1
+    if rules_checked and mode == "regulation":
+        rule_ratio = rules_hit / max(len(rules_checked), 1)
+        if rule_ratio < 0.5:
+            findings.append(
+                AdvisorFinding(
+                    code="WEAK_RULE_ALIGNMENT",
+                    severity="critical" if rule_ratio < 0.35 else "major",
+                    message=(
+                        f"Słabe dopasowanie do reguł regulaminu "
+                        f"({rules_hit}/{len(rules_checked)} reguł z distinctive signals w treści)."
+                    ),
+                    category="program_alignment",
+                    blocking=rule_ratio < 0.5,
+                )
+            )
+            score -= 25 if rule_ratio < 0.35 else 12
+        elif rule_ratio >= 0.7:
+            score = min(100, score + 5)
+
+    # --- Core domain signals required by brief must appear in application ---
+    if mode == "regulation":
+        for sig in core_signals_required_by_brief(brief):
+            if not core_signal_present(sig, blob):
+                findings.append(
+                    AdvisorFinding(
+                        code="MISSING_CORE_SIGNAL",
+                        severity="critical",
+                        message=f"Brak kluczowego sygnału regulaminu w treści wniosku: {sig}",
+                        category="program_alignment",
+                        blocking=True,
+                    )
+                )
+                score -= 15
+
+    # --- Attachments mentioned when brief requires them ---
+    missing_att: List[str] = []
+    for att in list(brief.get("required_attachments") or [])[:10]:
+        na = _norm(att)[:40]
+        if na and na[:12] not in _norm(blob):
+            # Also check generic "załącznik" coverage
+            if "załącznik" not in _norm(blob) and "zalacznik" not in _norm(blob):
+                missing_att.append(att)
+                findings.append(
+                    AdvisorFinding(
+                        code="ATTACHMENT_NOT_ADDRESSED",
+                        severity="major",
+                        message=f"Brak odniesienia do wymaganego załącznika: {att}",
+                        category="missing_required",
+                        blocking=False,
+                    )
+                )
+                score -= 4
+
+    # --- Attention points (critical ones block regulation pass) ---
+    attention = list(brief.get("attention_points") or [])
+    addressed: List[str] = []
+    open_pts: List[str] = []
+    for pt in attention:
+        if _attention_addressed(pt, blob):
+            addressed.append(pt)
+        else:
+            open_pts.append(pt)
+            critical = _attention_is_critical(pt)
+            findings.append(
+                AdvisorFinding(
+                    code="ATTENTION_OPEN",
+                    severity="critical" if critical else "minor",
+                    message=f"Punkt uwagi regulaminu niezaadresowany: {pt}",
+                    category="quality",
+                    blocking=critical,
+                )
+            )
+            score -= 12 if critical else 3
+
+    # --- Critical quality / readiness (empty/short sections) ---
+    short_sections = 0
+    for title, body in sections.items():
+        body = body or ""
+        if len(body.strip()) < min_section_chars or "[UZUPEŁNIĆ" in body:
+            short_sections += 1
+            findings.append(
+                AdvisorFinding(
+                    code="SECTION_TOO_THIN",
+                    severity="major",
+                    message=f"Sekcja zbyt krótka lub niekompletna: {title}",
+                    category="quality",
+                    section=title,
+                    blocking=len(body.strip()) < 20,
+                )
+            )
+            score -= 6
+    if not sections and len(blob.strip()) < 120:
+        findings.append(
+            AdvisorFinding(
+                code="DOCUMENT_EMPTY",
+                severity="critical",
+                message="Dokument wniosku pusty lub zbyt krótki.",
+                category="quality",
+                blocking=True,
+            )
+        )
+        score -= 40
+
+    score = max(0, min(100, score))
+    blockers = [f.message for f in findings if f.blocking]
+    critical = [f for f in findings if f.severity == "critical"]
+
+    # Explicit: never soft-pass structure_only / blind / blocked as regulation-grounded
+    if mode in ("structure_only", "blocked", "blind"):
+        regulation_grounded_pass = False
+    else:
+        regulation_grounded_pass = (
+            mode == "regulation"
+            and usable
+            and score >= min_score
+            and not blockers
+            and len(critical) == 0
+        )
+
+    if mode == "regulation":
+        passed = regulation_grounded_pass
+    elif mode == "structure_only":
+        # Structural readiness only — never regulation_grounded_pass
+        passed = (
+            len(blob.strip()) >= 200
+            and short_sections == 0
+            and score >= max(40, min_score - 25)
+            and not any(f.code == "DOCUMENT_EMPTY" for f in findings)
+        )
+    else:
+        passed = False
+
+    summary_bits = [
+        f"score={score}",
+        f"mode={mode}",
+        f"missing_sections={len(missing)}",
+        f"blockers={len(blockers)}",
+        f"regulation_grounded_pass={regulation_grounded_pass}",
+    ]
+    return AdvisorReport(
+        passed=passed,
+        score=score,
+        grounding_mode=mode,
+        regulation_grounded_pass=regulation_grounded_pass,
+        findings=findings,
+        blockers=blockers,
+        covered_sections=covered,
+        missing_sections=missing,
+        missing_attachments_mentioned=missing_att,
+        attention_addressed=addressed,
+        attention_open=open_pts,
+        brief_usable=usable,
+        summary="; ".join(summary_bits),
+    )
+
+
+def advisor_findings_to_rewrite_targets(
+    report: AdvisorReport | Dict[str, Any],
+    plan_titles: Sequence[str],
+) -> Dict[str, List[str]]:
+    """Map advisor findings onto quality_loop section targets."""
+    from core.generation.quality_loop import section_title_match
+
+    if isinstance(report, AdvisorReport):
+        findings = report.findings
+        missing = report.missing_sections
+    else:
+        findings = report.get("findings") or []
+        missing = report.get("missing_sections") or []
+
+    targets: Dict[str, List[str]] = {}
+    for req in missing:
+        matched = section_title_match(str(req), plan_titles)
+        note = f"[world_class_advisor] Uzupełnij wymaganą treść regulaminu: {req}"
+        if matched:
+            targets.setdefault(matched, []).append(note)
+        elif plan_titles:
+            targets.setdefault(list(plan_titles)[0], []).append(note)
+
+    for f in findings:
+        if isinstance(f, AdvisorFinding):
+            code, msg, section, sev = f.code, f.message, f.section, f.severity
+        elif isinstance(f, dict):
+            code = f.get("code") or "FINDING"
+            msg = f.get("message") or ""
+            section = f.get("section") or ""
+            sev = f.get("severity") or "major"
+        else:
+            continue
+        if code in ("GROUNDING_NOT_REGULATION", "BRIEF_EMPTY"):
+            # global note on all titles (limited later by pick)
+            for t in plan_titles:
+                targets.setdefault(t, []).append(f"[world_class_advisor|{sev}] {msg}")
+            break
+        matched = section_title_match(section, plan_titles) if section else None
+        line = f"[world_class_advisor|{sev}|{code}] {msg}"
+        if matched:
+            targets.setdefault(matched, []).append(line)
+        elif plan_titles and sev == "critical":
+            # Global alignment/core-signal issues: attach to budget/alignment-like titles if any,
+            # never blindly rewrite the first healthy section (e.g. full Wstęp).
+            if code in ("WEAK_RULE_ALIGNMENT", "MISSING_CORE_SIGNAL"):
+                domain_keys = ("budżet", "budzet", "finans", "koszt", "opis", "innowacj", "dopasow")
+                hit_any = False
+                for t in plan_titles:
+                    nt = _norm(t)
+                    if any(k in nt for k in domain_keys):
+                        targets.setdefault(t, []).append(line)
+                        hit_any = True
+                if not hit_any:
+                    # last resort: last plan title (often budget/closing), not first intro
+                    targets.setdefault(list(plan_titles)[-1], []).append(line)
+            else:
+                targets.setdefault(list(plan_titles)[0], []).append(line)
+    return targets
+
+
+def evaluate_from_generator_state(state: Dict[str, Any]) -> AdvisorReport:
+    """Convenience: build brief + sections from generator/external_context state."""
+    ext = state.get("external_context") if isinstance(state.get("external_context"), dict) else {}
+    generated = state.get("generated_sections") if isinstance(state.get("generated_sections"), dict) else {}
+    mode = str(ext.get("grounding_mode") or state.get("grounding_mode") or "regulation").lower()
+    brief = dict(ext.get("advisor_brief") or {}) if isinstance(ext.get("advisor_brief"), dict) else {}
+    if not brief:
+        brief = {
+            "key_rules": list(ext.get("regulation_key_rules") or ext.get("key_rules") or []),
+            "required_sections": list(ext.get("required_sections") or []),
+            "required_attachments": list(ext.get("required_attachments") or []),
+            "attention_points": list(ext.get("attention_points") or []),
+        }
+        brief["usable"] = bool(
+            brief["key_rules"] or brief["required_sections"] or brief["required_attachments"]
+        )
+    # Instrument family for mismatch detection
+    try:
+        from core.projects.instrument_profile import resolve_program_type
+
+        brief["program_type"] = resolve_program_type(
+            program_type=str(ext.get("instrument_program_type") or ext.get("program_type") or ""),
+            program_name=str(ext.get("program_name") or ext.get("grant_name") or ""),
+            grant_id=str(ext.get("grant_id") or ""),
+        )
+        brief["name"] = str(ext.get("program_name") or ext.get("grant_name") or "")
+    except Exception:
+        pass
+    return evaluate_application(
+        sections=generated,
+        document_text=state.get("full_document") or "",
+        brief=brief,
+        grounding_mode=mode,
+    )

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')