Deploy to Hugging Face

.gitattributes

@@ -0,0 +1,5 @@
+*.ttf filter=lfs diff=lfs merge=lfs -text
+*.png filter=lfs diff=lfs merge=lfs -text
+*.jpg filter=lfs diff=lfs merge=lfs -text
+*.ico filter=lfs diff=lfs merge=lfs -text
+*.pdf filter=lfs diff=lfs merge=lfs -text

.github/workflows/ci.yml

@@ -0,0 +1,273 @@
+##
+## .github/workflows/ci.yml — GrantForge AI CI/CD
+##
+## Uruchamia się przy:
+##   - push na 'main' (deploy do Render)
+##   - PR do 'main' (testy + lint bez deploy)
+##
+## Kroki:
+##   1. Lint (ruff) + type check (mypy)
+##   2. Testy jednostkowe (pytest)
+##   3. DeepEval RAG faithfulness (tylko main)
+##   4. Build Docker image + push do ghcr.io
+##   5. Trigger deploy na Render.com (webhook)
+##
+
+name: CI/CD — GrantForge AI
+
+on:
+  push:
+    branches: [main, staging]
+  pull_request:
+    branches: [main, staging]
+
+env:
+  PYTHON_VERSION: "3.11.9"
+  REGISTRY: ghcr.io
+  IMAGE_NAME: ${{ github.repository }}/grantforge-api
+  LANGCHAIN_TRACING_V2: "true"
+  LANGCHAIN_PROJECT: "grantforge-production"
+
+jobs:
+  # ─────────────────────────────────────────────────────────────────────────────
+  # JOB 1: Lint + Type Check
+  # ─────────────────────────────────────────────────────────────────────────────
+  lint:
+    name: 🔍 Lint & Type Check
+    runs-on: ubuntu-latest
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Set up Python ${{ env.PYTHON_VERSION }}
+        uses: actions/setup-python@v5
+        with:
+          python-version: ${{ env.PYTHON_VERSION }}
+          cache: pip
+          cache-dependency-path: backend/requirements.txt
+
+      - name: Install lint tools
+        run: pip install ruff mypy
+
+      - name: Ruff lint (backend)
+        run: python -m ruff check backend/ --select E,W,F --ignore E501,E402,W291,W293,F841,E722,E701,E712,E731,E741,F811,F401,F541
+
+      - name: Mypy type check (core modules)
+        run: |
+          cd backend
+          mypy core/ --ignore-missing-imports --no-strict-optional || true
+
+  # ─────────────────────────────────────────────────────────────────────────────
+  # JOB 2: Backend Tests
+  # ─────────────────────────────────────────────────────────────────────────────
+  test-backend:
+    name: 🧪 Backend Tests (pytest)
+    runs-on: ubuntu-latest
+    needs: lint
+
+    env:
+      GOOGLE_API_KEY: ${{ secrets.GOOGLE_API_KEY }}
+      BIELIK_MODE: disabled
+      DATABASE_URL: sqlite:///./test.db
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Set up Python ${{ env.PYTHON_VERSION }}
+        uses: actions/setup-python@v5
+        with:
+          python-version: ${{ env.PYTHON_VERSION }}
+          cache: pip
+          cache-dependency-path: backend/requirements.txt
+
+      - name: Install backend dependencies
+        run: |
+          sudo apt-get update && sudo apt-get install -y libcairo2-dev pkg-config python3-dev
+          cd backend
+          pip install --upgrade pip
+          pip uninstall -y pinecone-plugin-inference
+          pip install -r requirements.txt
+          pip install pytest pytest-asyncio httpx
+
+      - name: Run unit tests with coverage
+        run: |
+          cd backend
+          python -m pytest tests/ -v --tb=short -x \
+            --ignore=tests/test_deepeval_rag.py \
+            --cov=endpoints --cov-report=term-missing --cov-fail-under=50 \
+            2>&1 | tail -50
+
+      - name: Check API server imports
+        run: |
+          cd backend
+          python -c "import server; print('✅ server.py OK')"
+
+  # ─────────────────────────────────────────────────────────────────────────────
+  # JOB 3: DeepEval RAG Quality (tylko na push do main)
+  # ─────────────────────────────────────────────────────────────────────────────
+  deepeval:
+    name: 🎯 DeepEval RAG Faithfulness
+    runs-on: ubuntu-latest
+    needs: test-backend
+    if: github.event_name == 'push' && github.ref == 'refs/heads/main'
+    continue-on-error: true  # Nie blokuje deploy przy braku Pinecone key
+
+    env:
+      GOOGLE_API_KEY: ${{ secrets.GOOGLE_API_KEY }}
+      PINECONE_API_KEY: ${{ secrets.PINECONE_API_KEY }}
+      PINECONE_INDEX_NAME: ${{ secrets.PINECONE_INDEX_NAME }}
+      LANGCHAIN_API_KEY: ${{ secrets.LANGCHAIN_API_KEY }}
+      LANGCHAIN_TRACING_V2: "true"
+      LANGCHAIN_PROJECT: grantforge-ci
+      BIELIK_MODE: disabled
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Set up Python ${{ env.PYTHON_VERSION }}
+        uses: actions/setup-python@v5
+        with:
+          python-version: ${{ env.PYTHON_VERSION }}
+          cache: pip
+          cache-dependency-path: backend/requirements.txt
+
+      - name: Install dependencies + DeepEval
+        run: |
+          sudo apt-get update && sudo apt-get install -y libcairo2-dev pkg-config python3-dev
+          cd backend
+          pip install --upgrade pip
+          pip uninstall -y pinecone-plugin-inference
+          pip install -r requirements.txt deepeval
+
+      - name: Run DeepEval RAG tests
+        run: |
+          cd backend
+          python scripts/run_eval.py || true
+        # 'true' — nie blokuje deploy przy niskim quality score (tylko raport)
+
+  # ─────────────────────────────────────────────────────────────────────────────
+  # JOB 4: Frontend Build Check
+  # ─────────────────────────────────────────────────────────────────────────────
+  build-frontend:
+    name: 🏗️ Frontend Build (Vite)
+    runs-on: ubuntu-latest
+    needs: lint
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Set up Node.js
+        uses: actions/setup-node@v4
+        with:
+          node-version: "20"
+
+      - name: Install dependencies
+        run: |
+          cd frontend-react
+          rm -rf node_modules package-lock.json
+          npm install
+
+      - name: TypeScript check
+        run: |
+          cd frontend-react
+          npx tsc --noEmit || true
+
+      - name: Build
+        run: |
+          cd frontend-react
+          npm run build
+        env:
+          VITE_CLERK_PUBLISHABLE_KEY: ${{ secrets.VITE_CLERK_PUBLISHABLE_KEY }}
+          VITE_STRIPE_PRICE_ID_PRO: ${{ secrets.VITE_STRIPE_PRICE_ID_PRO }}
+          VITE_API_URL: "/api"
+          VITE_APP_VERSION: "1.3.0"
+
+
+
+  # ─────────────────────────────────────────────────────────────────────────────
+  # JOB 5: Docker Build + Push (tylko main)
+  # ─────────────────────────────────────────────────────────────────────────────
+  docker:
+    name: 🐳 Docker Build & Push
+    runs-on: ubuntu-latest
+    needs: [test-backend, build-frontend]
+    if: github.event_name == 'push' && github.ref == 'refs/heads/main'
+    permissions:
+      contents: read
+      packages: write
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Log in to GitHub Container Registry
+        uses: docker/login-action@v3
+        with:
+          registry: ${{ env.REGISTRY }}
+          username: ${{ github.actor }}
+          password: ${{ secrets.GITHUB_TOKEN }}
+
+      - name: Set up Docker Buildx
+        uses: docker/setup-buildx-action@v3
+
+      - name: Extract metadata
+        id: meta
+        uses: docker/metadata-action@v5
+        with:
+          images: ${{ env.REGISTRY }}/${{ env.IMAGE_NAME }}
+          tags: |
+            type=sha,prefix=sha-,format=short
+            type=raw,value=latest
+
+      - name: Build and push Docker image
+        uses: docker/build-push-action@v5
+        with:
+          context: .
+          file: ./Dockerfile
+          push: true
+          tags: ${{ steps.meta.outputs.tags }}
+          labels: ${{ steps.meta.outputs.labels }}
+          cache-from: type=gha
+          cache-to: type=gha,mode=max
+
+  # ─────────────────────────────────────────────────────────────────────────────
+  # JOB 6: Deploy do Hugging Face Spaces (tylko main)
+  # ─────────────────────────────────────────────────────────────────────────────
+  deploy-huggingface:
+    name: 🚀 Deploy to Hugging Face
+    runs-on: ubuntu-latest
+    needs: [docker]  # deepeval jest continue-on-error, nie blokuje deploy
+    if: github.event_name == 'push' && github.ref == 'refs/heads/main'
+
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+
+      - name: Push to Hugging Face Spaces
+        env:
+          HF_TOKEN: ${{ secrets.HF_TOKEN }}
+        run: |
+          git config --global user.email "bot@grantforge.ai"
+          git config --global user.name "GrantForge Bot"
+          
+          # Usuwamy starą historię, aby pozbyć się starych blobów binarnych
+          rm -rf .git
+          git init -b main
+          
+          # Konfigurujemy Git LFS dla plików binarnych (wymóg Hugging Face)
+          git lfs install
+          echo "*.ttf filter=lfs diff=lfs merge=lfs -text" > .gitattributes
+          echo "*.png filter=lfs diff=lfs merge=lfs -text" >> .gitattributes
+          echo "*.jpg filter=lfs diff=lfs merge=lfs -text" >> .gitattributes
+          echo "*.ico filter=lfs diff=lfs merge=lfs -text" >> .gitattributes
+          echo "*.pdf filter=lfs diff=lfs merge=lfs -text" >> .gitattributes
+          
+          # Tworzymy nowy, czysty commit z całą aplikacją
+          git add .gitattributes
+          git add .
+          git commit -m "Deploy to Hugging Face"
+          
+          # Wypychamy na HF (wypchnie również obiekty LFS)
+          git remote add huggingface https://Bogdan555:${HF_TOKEN}@huggingface.co/spaces/Bogdan555/grantforge-api
+          git push -f huggingface main
+

.pre-commit-config.yaml

@@ -0,0 +1,15 @@
+repos:
+  - repo: https://github.com/astral-sh/ruff-pre-commit
+    rev: v0.4.4
+    hooks:
+      - id: ruff
+        args: [ --fix ]
+      - id: ruff-format
+  - repo: local
+    hooks:
+      - id: pre-push-tests
+        name: Run Backend Pytest
+        entry: bash scripts/pre_push_tests.sh
+        language: system
+        stages: [pre-push]
+        pass_filenames: false

.python-version

@@ -0,0 +1 @@
+3.11

DEPLOYMENT.md

@@ -0,0 +1,202 @@
+# 🚀 Deployment Guide — GrantForge AI Enterprise (v1.3.0)
+
+> **Sprint 9 — Instrukcja produkcyjna**  
+> Aktualizacja: kwiecień 2026 | Stack: Render.com + PostgreSQL + GitHub Actions CI/CD
+
+---
+
+## Architektura Deploymentu
+
+```
+GitHub (main) → GitHub Actions CI/CD → Render.com
+                                      ├── grantforge-api   (FastAPI + Gunicorn)
+                                      ├── grantforge-frontend (React SPA)
+                                      └── grantforge-db    (PostgreSQL 16)
+```
+
+---
+
+## KROK 1: GitHub Repository Secrets
+
+Przejdź do: `GitHub → Settings → Secrets and variables → Actions`
+
+### Wymagane Secrets (CI/CD + Deploy):
+
+| Secret Name | Skąd wziąć | Ważny? |
+|---|---|---|
+| `GOOGLE_API_KEY` | [Google AI Studio](https://aistudio.google.com/app/apikey) | ✅ Wymagany |
+| `VITE_CLERK_PUBLISHABLE_KEY` | Clerk Dashboard → API Keys → Publishable Key | ✅ Wymagany |
+| `RENDER_DEPLOY_HOOK_BACKEND` | Render → API service → Settings → Deploy Hook | ✅ Wymagany |
+| `RENDER_DEPLOY_HOOK_FRONTEND` | Render → Static service → Settings → Deploy Hook | ✅ Wymagany |
+| `PINECONE_API_KEY` | [Pinecone Console](https://app.pinecone.io) | RAG optional |
+| `PINECONE_INDEX_NAME` | Pinecone Console → Index name | RAG optional |
+| `LANGCHAIN_API_KEY` | [LangSmith](https://smith.langchain.com) → Settings | Monitoring |
+
+### Jak dodać secret:
+```
+GitHub repo → Settings → Secrets → Actions → New repository secret
+```
+
+#### Render Deploy Hook (backend):
+1. Render Dashboard → `grantforge-api` → Settings
+2. Scroll do sekcji **Deploy Hooks**
+3. Kliknij **Add Deploy Hook** → Nazwa: `ci-deploy`
+4. Skopiuj URL (format: `https://api.render.com/deploy/srv-xxx?key=yyy`)
+5. Zapisz jako secret `RENDER_DEPLOY_HOOK_BACKEND`
+
+#### Render Deploy Hook (frontend):
+1. Render Dashboard → `grantforge-frontend` → Settings
+2. Kliknij **Add Deploy Hook** → Nazwa: `ci-frontend`
+3. Skopiuj URL → Zapisz jako `RENDER_DEPLOY_HOOK_FRONTEND`
+
+---
+
+## KROK 2: Render → Environment Variables
+
+Przejdź do: `Render → grantforge-api → Environment`
+
+Ustaw następujące zmienne (kliknij **Add Environment Variable** dla każdej):
+
+```bash
+# ── LLM ─────────────────────────────
+GOOGLE_API_KEY=           # Klucz Google Gemini
+BIELIK_MODE=disabled      # disabled / huggingface / ollama
+
+# ── Autentykacja Clerk ───────────────
+CLERK_SECRET_KEY=         # sk_live_... (Clerk Dashboard → API Keys)
+CLERK_PUBLISHABLE_KEY=    # pk_live_... (Clerk Dashboard → API Keys)
+
+# ── RAG / Pinecone ───────────────────
+PINECONE_API_KEY=         # Opcjonalne — bez tego RAG działa lokalnie
+PINECONE_INDEX_NAME=      # Nazwa indeksu
+PINECONE_ENVIRONMENT=     # Np. "gcp-starter"
+
+# ── LangSmith (monitoring) ───────────
+LANGCHAIN_API_KEY=        # ls_... ze smith.langchain.com
+LANGCHAIN_TRACING_V2=true
+LANGCHAIN_PROJECT=grantforge-production
+
+# ── Stripe (płatności) ───────────────
+STRIPE_SECRET_KEY=        # sk_live_...
+STRIPE_WEBHOOK_SECRET=    # whsec_...
+STRIPE_PRICE_ID_PRO=      # price_...
+
+# ── Dysk danych ──────────────────────
+UPLOAD_DIR=/data/uploads
+VECTOR_STORE_DIR=/data/vector_store
+LLAMAPARSE_CACHE_DIR=/data/llamaparse_cache
+```
+
+> **Uwaga:** `DATABASE_URL` jest automatycznie wstrzyknięty przez Render Blueprint z bloku `databases`.
+
+---
+
+## KROK 3: Pierwsza Migracja Bazy Danych
+
+Po pierwszym deploymencie na Render, uruchom one-off job alembic:
+
+1. Render → `grantforge-api` → **Shell** (lub: one-off command)
+2. Wpisz:
+   ```bash
+   alembic upgrade head
+   ```
+3. Sprawdź czy tabele zostały stworzone (w tym `project_documents` z Sprint 8).
+
+### Lokalnie (przed deploy):
+```bash
+cd backend
+alembic upgrade head
+```
+
+Jeśli błąd — sprawdź `DATABASE_URL` w `.env`.
+
+---
+
+## KROK 4: Weryfikacja po Deploy
+
+Po uruchomieniu, zweryfikuj każdy endpoint:
+
+```bash
+# 1. Health check (podstawowy)
+curl https://grantforge-api.onrender.com/api/health
+
+# Oczekiwana odpowiedź:
+# {"status": "ok", "db": "connected", "version": "1.3.0", ...}
+
+# 2. Sprawdź czy upload PDF działa
+curl -X POST https://grantforge-api.onrender.com/api/projects/TEST_PROJECT_ID/documents \
+  -F "file=@test.pdf"
+# Oczekiwane: 202 Accepted
+
+# 3. Sprawdź listę dokumentów z kwotą
+curl https://grantforge-api.onrender.com/api/projects/TEST_PROJECT_ID/documents
+# Oczekiwane: {"documents": [], "quota": {"current": 0, "limit": 3, "plan": "free", "can_upload": true}}
+
+# 4. Sprawdź nabory
+curl https://grantforge-api.onrender.com/api/grants/nabory
+# Oczekiwane: {"total": N, "sources": [...]}
+```
+
+---
+
+## KROK 5: CI/CD — Pierwszy Push
+
+Po skonfigurowaniu secrets, każdy push na `main` uruchomi pipeline:
+
+```bash
+git add -A
+git commit -m "chore: Sprint 9 — upload limits + E2E tests"
+git push origin main
+```
+
+Pipeline (`.github/workflows/ci.yml`):
+1. 🔍 **Lint & Type Check** (ruff + mypy)
+2. 🧪 **Backend Tests** (pytest)
+3. 🎯 **DeepEval RAG** (tylko main)
+4. 🏗️ **Frontend Build** (Vite)
+5. 🐳 **Docker Build & Push** (ghcr.io)
+6. 🚀 **Deploy to Render** (webhook)
+
+Monitor pipeline: `GitHub → Actions → CI/CD — GrantForge AI`
+
+---
+
+## Limity Upload PDF (Sprint 9)
+
+| Plan | Max pliki/projekt | Hard limit |
+|---|---|---|
+| Free | 3 PDF | 10 PDF |
+| Pro | 50 PDF | 10 PDF |
+| Enterprise | 50 PDF | 10 PDF |
+
+> Hard limit (10) jest bezwzględny — dotyczy wszystkich planów.  
+> Soft limit jest egzekwowany przez `_check_upload_limits()` w `endpoints/documents.py`.
+
+---
+
+## Troubleshooting
+
+### Backend nie startuje
+```bash
+# Sprawdź logi Render → Logs
+# Najczęstszy błąd: brak DATABASE_URL lub import error
+```
+
+### Alembic error: "Can't locate revision"
+```bash
+cd backend
+alembic stamp head  # jeśli tabele już istnieją
+alembic upgrade head
+```
+
+### Upload 429 Too Many Requests
+Użytkownik osiągnął limit planu. Opcje:
+1. Usuń stary dokument w zakładce "Dokumenty RAG"
+2. Przejdź na plan Pro (`/cennik`)
+
+### RAG nie indeksuje (status: error)
+Sprawdź w Render Shell:
+```bash
+# W logach szukaj [RAG Upload] ❌
+# Najprawdopodobniejsza przyczyna: Pinecone key / pusty PDF
+```

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", "-"]

KRSAPI.md

@@ -0,0 +1,57 @@
+Otwarte API Krajowego Rejestru Sądowego
+Jak korzystać?
+Otwarte API KRS udostępnia dane z Krajowego Rejestru Sądowego w postaci RESTFull API.
+Zakres informacyjny udostępnianych danych odpowiada odpisom z KRS, zupełnemu i aktualnemu.
+Dodatkowo dostępna jest usługa informująca o wprowadzonych zmianach do rejestru we wskazanym dniu.
+Usługi udostępniono pod wskazanymi poniżej adresami z podaniem parametrów niezbędnych przy wywołaniu poszczególnych usług.
+Usługi
+GET - Pobranie odpisu aktualnego
+https://api-krs.ms.gov.pl/api/krs/OdpisAktualny/{krs}?rejestr={rejestr}&format=json
+Parametry:
+{krs} – numer podmiotu w rejestrze KRS
+{rejestr} – P – przedsiębiorców, S-stowarzyszeń
+{format} – json (bez względu na wpisany parametr zawsze zwrócony zostanie obiekt w postaci JSON)
+Usługa zwraca następujące statusy:
+200 – OK
+404 – podmiot nie znaleziony
+5xx – błąd usługi
+Zwracany model:
+Semantyczny JSON odpowiedni dla formy prawnej
+GET - Pobranie odpisu pełnego
+https://api-krs.ms.gov.pl/api/krs/OdpisPelny/{krs}?rejestr={rejestr}&format=json
+Parametry:
+{krs} – numer podmiotu w rejestrze KRS
+{rejestr} – P – przedsiębiorców, S-stowarzyszeń
+{format} – json (bez względu na wpisany parametr zawsze zwrócony zostanie obiekt w postaci JSON)
+Usługa zwraca następujące statusy:
+200 – OK
+404 – podmiot nie znaleziony
+5xx – błąd usługi
+Zwracany model:
+Semantyczny JSON odpowiedni dla formy prawnej
+GET - Pobranie historii zmian - biuletyn godzinowy
+https://api-krs.ms.gov.pl/api/Krs/BiuletynGodzinowy/{dzien}?godzinaOd={godzinaOd}&godzinaDo={godzinaDo}
+Parametry:
+{dzien} – dzień, późniejszy niż 2021-12-08
+{godzinaOd} – godzina początkowa biuletynu, w formacie 24-godzinnym (GG, od 00 do 23)
+{godzinaDo} – godzina końcowa biuletynu w formacie 24-godzinnym (GG, od 00 do 23)
+Usługa zwraca następujące statusy:
+200 – OK
+404 – podmiot nie znaleziony
+5xx – błąd usługi
+Zwracany model:
+Tablica łańcuchów tekstowych [ string, string, …, string ]
+GET - Pobranie historii zmian - biuletyn dzienny
+https://api-krs.ms.gov.pl/api/Krs/Biuletyn/{dzien}?
+Parametry:
+{dzien} - dzień, późniejszy niż 2021-12-08
+Usługa zwraca następujące statusy:
+200 - OK
+404 - podmiot nie znaleziony
+5xx - błąd usługi
+Zwracany model:
+Tablica łańcuchów tekstowych [ string, string, …, string ]
+Przepisy dotyczące API
+Art. 4b ust. 2 ustawy z dnia 20 sierpnia 1997 r. o Krajowym Rejestrze Sądowym (tj.: Dz. U. z 2021 r., poz. 112 ze zm.), w związku z art. 24 ust. 1 ustawy z dnia 11 sierpnia 2021 r. o otwartych danych i ponownym wykorzystywaniu informacji sektora publicznego (Dz. U. z 2021 r., poz. 1641).
+
+Rozporządzenie Parlamentu Europejskiego i Rady (UE) 2016/679 z dnia 27 kwietnia 2016 r. w sprawie ochrony osób fizycznych w związku z przetwarzaniem danych osobowych i w sprawie swobodnego przepływu takich danych oraz uchylenia dyrektywy 95/46/WE (ogólne rozporządzenie o ochronie danych) (Dz. Urz. UE L 119 z 04.05.2016 ze zm.).

OProgramie.md

@@ -0,0 +1,34 @@
+DotacjeAI
+Witamy w DotacjeAI – Twoim wirtualnym asystencie i inteligentnym biurze doradztwa dotacyjnego. Nasza platforma wykorzystuje zaawansowane modele sztucznej 
+inteligencji, aby zautomatyzować, przyspieszyć i ułatwić proces ubiegania się o fundusze publiczne (m.in. z programów PARP, NCBR oraz funduszy europejskich).
+
+Niniejszy dokument wyjaśni kluczowe kwestie związane z bezpieczeństwem Twoich danych, wiarygodnością systemu i aspektami prawnymi.
+
+1: Twoje bezpieczeństwo, wiarygodność i prawo
+Zanim rozpoczniesz pracę, upewnij się, że znasz zasady funkcjonowania naszej platformy. Została ona zaprojektowana z myślą o najwyższych standardach 
+bezpieczeństwa (zgodnie z unijną zasadą Privacy by Design).
+
+1.1. Transparentność i AI Act
+Zgodnie z wymogami unijnego Aktu o Sztucznej Inteligencji (AI Act), informujemy, że korzystając z platformy, wchodzisz w interakcję z systemem sztucznej 
+inteligencji. DotacjeAI pełni rolę Twojego wirtualnego asystenta i doradcy wspomagającego proces analityczny oraz redakcyjny.
+
+1.2. Zasada "Human-in-the-loop" (Człowiek w centrum decyzji)
+Platforma maksymalnie upraszcza tworzenie wniosków i weryfikuje je pod kątem formalnym, jednak ostatecznym autorem dokumentacji i podmiotem odpowiedzialnym 
+za przesłane w niej informacje pozostajesz Ty (Wnioskodawca). Zgodnie z polskim prawem, aplikacja nie ponosi odpowiedzialności za ewentualne odrzucenie wniosku 
+przez instytucję oceniającą. Przed wyeksportowaniem i wysłaniem wniosku masz obowiązek uważnie przeczytać, zweryfikować ze stanem faktycznym swojego 
+przedsiębiorstwa i zatwierdzić każdą wygenerowaną sekcję.
+
+1.3. Ochrona Danych i Tajemnica Przedsiębiorstwa (RODO)
+Rozumiemy, że we wnioskach dotacyjnych zawierasz najbardziej wrażliwe informacje o innowacjach, finansach i strategiach biznesowych.
+
+Ścisła izolacja: Twoje dane są w pełni separowane od innych użytkowników dzięki dedykowanej strukturze przestrzeni danych.
+
+Brak uczenia modeli publicznych: Twoje projekty, budżety i know-how nigdy nie są wykorzystywane do trenowania ogólnodostępnych modeli AI.
+
+Szyfrowanie i Standardy: Przetwarzanie danych opiera się na bezpiecznym protokole szyfrowania TLS 1.3. Posiadasz pełne "prawo do bycia zapomnianym" – w 
+każdej chwili możesz trwale usunąć swoje dane z naszych serwerów.
+
+1.4. Wiarygodność i eliminacja "halucynacji" AI
+Powszechnie dostępne czaty sztucznej inteligencji potrafią czasem zmyślać fakty. Skutecznie wyeliminowaliśmy to zjawisko. DotacjeAI korzysta z nowoczesnej 
+architektury RAG (Retrieval-Augmented Generation). Oznacza to, że system w czasie rzeczywistym czerpie wiedzę wyłącznie z najnowszych, oficjalnych dokumentów 
+urzędowych (regulaminy naborów, przewodniki kwalifikowalności kosztów, wytyczne środowiskowe DNSH), opierając każdą sugestię na precyzyjnym kontekście prawnym.

Podsumowanie Dotacja AI.md

@@ -0,0 +1,42 @@
+1. Email poprawić na bogmaz1@gmail.com w sekcji  zgłoś błąd
+2. W sekcji zgłoś błąd lista rozwijana moduł/zakładka ma białe tło tak jak litery - nmi widać opcji wyboru. Zmiana kontrastu. 
+3. Wysłanie w sekcji zgłoś błąd tylko w rzeczywistych przypadkach. 
+4. Interaktywny samouczek nie działa 
+5. Zaawnasowana telemetria nie działa na rzeczywistych danych w Nexus control w zakładce przegląd. 
+6. Zakładka telemetria do sprawdzenia czy logi funkcjonują prawidłowo
+7. Do czego służy przycisk streaming w zakłdce telemetria? Jak tego używać. 
+8. W zakładce narzędzia jest Całościowa ocena krytyczna. Jak to wykorzystujemy i skąd wziać numer UUID docelowego projektu do oceny. Czy to wogóle działa. 
+9. W zakładce narzędzia - Jak używać Synchronizacja bazy docelowej? do czego to służy i kiedy to wykorzystywać? Czy to wogóle działa?
+10. W zakłdce narzędzia jest wyczyść cache - do czego służy i kiedy wykorzystujemy?
+11. W zakładce narzędzia jest sprawdź sieć - za każdym razem neo4j jest warning. Czy ta funkcja działa? Jak zweryfikować poprawność działania?
+12. Ekran ustawienia - zarządzaj podmiotami powinno być rzeczywieste dalej jest mockup. Zarządzaj nie dział oraz Dodaj nową firmę z GUS też nie działa. 
+13. Ekran ustawienia Subskrypcja - PRzycisk zmień plan nie działa. Trzeba poprawić na wybór planu na razie bez ustawienia fiansowania. 
+14. Ekran ustawienia Bezpieczeństwo - nie działa konfiguracja dwuetapowa, nie działa wyloguj inne urządzeni. Konto i dostęp - przycisk ma zbyt ciemny napis i nie widać napisu wyloguj. 
+15. Eran ustawienia Preferencje - brak możliwości języka angielskiego. Powiadomienia email też nie działają. 
+16. Ekran pomoc - nieaktualne dane. Muszą zostać wpisane prawdziwe i rozwinięte informacje. 
+17. Informacje o programie też musza zostać zaktualizowane
+18. Czy ekran aktywne nabory wyświetla wszystkie możliwe z każdego źródła czy tylko wybrane. Jak są weryfikowane. DO sprawdzenia. 
+19. Ekran aktywne nabory - fitlry wyboru programu i firmy tekst biały jest na białym tle. NIe widać co jest napisane dopiero po najechaniu. 
+20. Linki do programów w aktywnych naborach są nieprawidłowe. Tracimy na wiarygodności. Skoro są aktywne nabory to linki muszą być aktywne. 
+21. Ekran aktywne nabory - do weryfiokacji czy dane odnośnie kwot, procent dofinansowania, jaka firma, zakres regionalny, ilość dni czy to wszyskto jest prawidłowe. 
+22. Ekran moje projektu. Jak kafelku projektu nie jest rzeczywisty postęp wniosku. Zawsze jest 20%. 
+23. Ekran wniosku Pasujace nabory - nie działa funkcja Matcher AI - okienko jest przesunięte w prawo. Do poprawy i weryfikacji poprawności działania. 
+24. Ekran podsumowanie projektu - status jest zawsze na szic. Sprawdź czy jest poprawnie. 
+25. Generowanie plików. Wszystkie funkcje generowania plików są do weryfikacja. pdf z podziałem na 3 szablony, docx z podziałem na 3 szablony. Czy się różnia od siebie. 
+26. Nie można zapisywać w historia wersji - zapis obecny stan
+27. Czy sekcje wniosku muszą być po angielsku ? Czy na wygenerowanym dokumencie też musi być po angielsku ? Jest to polski program i niech będzie po polsku. 
+28. DOkumenty RAG - czy wgrane dokumenty są prawidłowo weryfikowane ?
+29. Czy wyszukiwarka programów wyszukuje prawidłowe informacje w dobrych źródłach. Jaka jest pewności skuteczności tego wyszukiwania ? Czy można temu zaufać ? Jak to można rozbudować dla spójności i prawidłwego działania. 
+30. Czy werfykacje odbywają się na dobrych źródłach ? Czy program korzysta ze źródeł prawnych uni europejskiej jak eurlex? jakie są skuteczne metody weryfikacji? 
+31. Czy audyt odbywa się prawidłowo i z dobrymi mechanizmami ?
+32. Czy raport spójności jest prawidłowy i pewny. 
+33. Wyszukiwanie źródeł, dokumentów, danych. Sprawdź zgodność z założeniamii poprawność wyszukiwania.Na jakiej postawie możemy to skontrolować.
+34. Czy wszystkie możliwe źródła pozyskania dotacji zostały  uwzględnione ? Czy agecni są przygotowanie dla każdego typu dotacji?
+35. Czy wszystkie dostępne dokumenty związane z dotacją z głównych źródeł są wystarczające czy potrzebne są dane z EURlex?
+36. CZy potrzebne jest wykazenie źródeł z których korzysta program.
+
+
+
+
+
+

README.md

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

antigravity_grantforge_swarm/CONSTITUTION.md

@@ -0,0 +1,118 @@
+# KONSTYTUCJA SYSTEMU GRANTFORGE AI (GSD)
+
+**Wersja:** 1.0  
+**Data:** Maj 2026  
+**Status:** Obowiązująca dla wszystkich agentów i procesów
+
+---
+
+## PREAMBUŁA
+
+Grantforge AI istnieje, aby pomagać polskim przedsiębiorcom w uzyskiwaniu dotacji unijnych w sposób **uczciwy, rzetelny i zgodny z prawem**.
+
+Nie jesteśmy "fabryką wniosków". Jesteśmy **cyfrowym doradcą**, który chroni firmę przed odrzuceniem, korektami finansowymi i problemami prawnymi w przyszłości.
+
+Wszystko, co generujemy, podlega tej Konstytucji.
+
+---
+
+## ARTYKUŁ I — ZASADY NACZELNE
+
+### 1. Prawda regulaminowa ponad wszystko
+- **Nigdy nie halucynujemy** zapisów regulaminu naboru.
+- Każde twierdzenie o "kwalifikowalności" musi być poparte **konkretnym paragrafem** regulaminu lub wytycznych.
+- Jeśli nie jesteśmy pewni — piszemy wprost: "wymaga potwierdzenia z instytucją" lub "ryzyko interpretacyjne".
+
+### 2. Traceability (śledzalność) jako fundament
+- Każda sekcja wniosku musi mieć **źródło**:
+  - regulamin naboru (z linkiem / numerem),
+  - dane firmy z KRS / CEIDG / wywiadowni,
+  - oświadczenie użytkownika.
+- W finalnym dokumencie generujemy **"Świadectwo Ugruntowania"** (Grounding Certificate).
+
+### 3. Spójność krzyżowa (Cross-Section Consistency)
+- Budżet musi być spójny z Harmonogramem Rzeczowo-Finansowym.
+- Zadania muszą wynikać z Opisu Projektu.
+- Wskaźniki muszą być realistyczne i mierzalne.
+- **Audytor** zawsze sprawdza te relacje przed zatwierdzeniem.
+
+### 4. Ochrona przed nadmiernym optymizmem (Anti-Overpromising)
+- Nie obiecujemy wyników, których firma nie jest w stanie realnie osiągnąć.
+- Nie zawyżamy wskaźników tylko po to, żeby "lepiej wyglądało".
+- Preferujemy **konserwatywne, ale wiarygodne** sformułowania.
+
+### 5. MŚP / MSP / Duże Przedsiębiorstwo — zero oszustwa
+- Status MŚP jest weryfikowany przez `graphrag_msp_agent` (struktura własności, powiązania).
+- Jeśli firma jest "na granicy" — oznaczamy jako **ryzyko** i wymagamy potwierdzenia.
+
+### 6. DNSH i Zielona Transformacja
+- Każda inwestycja musi być oceniona pod kątem **Do No Significant Harm**.
+- Jeśli projekt ma negatywny wpływ na środowisko — nie ukrywamy tego. Szukamy rozwiązań łagodzących lub alternatyw.
+
+### 7. Pomoc publiczna i kumulacja
+- Zawsze sprawdzamy **de minimis**, **pomoc regionalną**, **kumulację** z innymi wsparciami.
+- Ostrzegamy przed ryzykiem przekroczenia limitów.
+
+---
+
+## ARTYKUŁ II — PROCES DECYZYJNY AGENTÓW
+
+### Zasada "Najpierw Ugruntowanie"
+Zanim agent wygeneruje jakikolwiek tekst dla sekcji wniosku, **musi** najpierw:
+1. Pobrać relevantne fragmenty regulaminu (RAG + GraphRAG).
+2. Zidentyfikować dokładne kryteria oceny.
+3. Sprawdzić, czy firma spełnia warunki formalne.
+
+### Zasada "Pytaj o Potwierdzenie" (Human-in-the-Loop)
+Zawsze wymagamy potwierdzenia użytkownika przed:
+- Złożeniem ostatecznej wersji wniosku do instytucji
+- Wprowadzeniem zmian w budżecie powyżej X%
+- Zmianą statusu MŚP / powiązań kapitałowych
+- Zatwierdzeniem wersji, która dostała ocenę "medium" lub "high" od Audytora
+
+### Zasada "Zero Ukrytych Założeń"
+W każdej generowanej sekcji agent musi jawnie zapisać:
+- Jakie założenia przyjął
+- Jakie ryzyka widzi
+- Co wymaga dalszego potwierdzenia od użytkownika
+
+---
+
+## ARTYKUŁ III — AUDYT I JAKOŚĆ
+
+### Obowiązkowy Audyt Holistyczny
+Przed wygenerowaniem finalnego dokumentu **zawsze** uruchamiamy `auditor_agent` + `legal_verifier_agent`.
+
+Audyt sprawdza minimum:
+- Spójność budżet–harmonogram–zadania
+- Zgodność z DNSH i zasadami horyzontalnymi
+- Kompletność wymaganych załączników
+- Realizm wskaźników i kamieni milowych
+- Ryzyka prawne (pomoc publiczna, RODO, KSH)
+
+### Świadectwo Zgodności
+Każdy wniosek, który przechodzi pełny proces GSD, otrzymuje **"Świadectwo Zgodności Grantforge v1.0"** — dokument zawierający:
+- Wynik audytu (z ocenami per kategoria)
+- Listę źródeł regulaminowych użytych w każdej sekcji
+- Podpis cyfrowy / hash łańcucha audytu
+
+---
+
+## ARTYKUŁ IV — ZAKAZY BEZWZGLĘDNE
+
+1. **Nie wolno** generować treści, które sugerują, że firma spełnia kryteria, których nie spełnia.
+2. **Nie wolno** kopiować fragmentów regulaminu bez podania źródła i daty obowiązywania.
+3. **Nie wolno** obiecywać "100% szans na uzyskanie dotacji".
+4. **Nie wolno** ignorować negatywnych sygnałów z Audytora (nawet jeśli użytkownik naciska).
+5. **Nie wolno** używać danych finansowych firmy bez weryfikacji lub z oświadczeniem "dane szacunkowe".
+
+---
+
+**Podpis Konstytucji**
+
+Ta Konstytucja jest wiążąca dla:
+- Wszystkich agentów w `antigravity_grantforge_swarm/`
+- Wszystkich promptów i narzędzi
+- Każdego człowieka współpracującego z systemem Grantforge
+
+Zmiany w Konstytucji wymagają wersji i daty oraz zgody zespołu Antigravity.

antigravity_grantforge_swarm/README.md

@@ -0,0 +1,91 @@
+# Antigravity Grantforge Swarm — GSD (Grantforge Spec-Driven Development)
+
+**Wersja:** 1.0  
+**Data:** Maj 2026  
+**Status:** Metodyka + Warstwa Orkiestracji
+
+---
+
+## Misja
+
+Zbudować **najbardziej wiarygodny, audytowalny i zgodny z regulacjami system generowania wniosków dotacyjnych** w Polsce.
+
+Grantforge AI nie ma "halucynować" regulaminów. Każde zdanie we wniosku musi być **ugruntowane** (grounded) w:
+- aktualnym regulaminie naboru,
+- faktach o firmie (KRS + dane użytkownika),
+- zasadzie DNSH / MŚP / pomocy publicznej.
+
+---
+
+## Filozofia GSD (Grantforge Spec-Driven)
+
+Zamiast jednego "mega-agenta", używamy **specjalistycznego roju** (swarm), gdzie każdy agent ma:
+- Jasno zdefiniowaną odpowiedzialność
+- Własny zestaw narzędzi i retrieverów
+- Surowe reguły konstytucyjne (anti-hallucination, traceability)
+- Obowiązek logowania uzasadnienia każdej decyzji
+
+**Zasada nadrzędna:**
+> "Lepszy wniosek niekompletny i uczciwy niż wniosek piękny, ale niezgodny z regulaminem."
+
+---
+
+## Architektura Warstwy
+
+```
+antigravity_grantforge_swarm/
+├── orchestrator.py          # Główny GSD Supervisor (faza + blackboard + routing)
+├── state.py                 # GrantforgeSwarmState (rozszerza AgentState)
+├── config.py
+├── main.py                  # Entry point (CLI / API)
+├── prompts/
+│   └── global_rules_prompts.py   # Konstytucja + reguły domenowe
+├── tools/
+│   └── grantforge_tools.py       # RAG, Neo4j GraphRAG, KRS, Export, EUR-Lex
+└── agents/
+    ├── wizard_clarifier_agent.py      # Wyjaśnianie potrzeb + profil firmy
+    ├── advanced_matcher_agent.py      # Zaawansowane dopasowanie + explainability
+    ├── rag_ingestion_agent.py         # Ingestion i odświeżanie bazy wiedzy
+    ├── graphrag_msp_agent.py          # Analiza struktury własności (MSP/SME)
+    ├── generator_agent.py             # Generowanie sekcji z twardym groundingiem
+    ├── auditor_agent.py               # Audyt holistyczny (cross-section)
+    ├── autofix_agent.py               # Propozycje poprawek na podstawie audytu
+    ├── legal_verifier_agent.py        # Pomoc publiczna, DNSH, RODO, formalności
+    ├── validator_agent.py             # Walidacja scoringowa i kryteriów
+    └── exporter_agent.py              # Finalny dokument + ślad audytu
+```
+
+---
+
+## Jak ta warstwa współpracuje z istniejącym kodem?
+
+Ta warstwa (`antigravity_grantforge_swarm`) jest **wyższą warstwą orkiestracji** (GSD Orchestrator).
+
+- Wywołuje / koordynuje istniejące agenty z `backend/agents/` (supervisor, wizard, matcher, auditor, critic itd.)
+- Dodaje **konstytucyjne reguły**, **fazy GSD**, **obowiązkowy ślad audytu** i **specjalistyczne narzędzia**.
+- Może działać zarówno jako osobny proces, jak i być importowana przez FastAPI.
+
+---
+
+## Uruchomienie
+
+```bash
+cd /home/user/PROGRAMY/DOTACJE/antigravity_grantforge_swarm
+python main.py --project-id xxx --mode full-swarm
+```
+
+Lub przez API (planowane).
+
+---
+
+## Kolejne kroki (roadmap)
+
+- [ ] Pełna implementacja wszystkich 10 agentów GSD
+- [ ] Integracja z istniejącym LangGraph supervisor
+- [ ] Dodanie `CONSTITUTION.md` + `SWARM.md` + `WORKFLOWS/`
+- [ ] Automatyczne generowanie "Świadectwa Zgodności Wniosku"
+- [ ] Wsparcie dla GraphRAG + Voyage rerank + Pinecone (opcjonalnie)
+
+---
+
+**Autorzy metodyki:** Antigravity + Grok (GSD 2026)

antigravity_grantforge_swarm/SWARM.md

@@ -0,0 +1,174 @@
+# GRANTFORGE SWARM — Specjalistyczne Role Agentów (GSD)
+
+**Wersja:** 1.0  
+**Data:** Maj 2026
+
+---
+
+## Filozofia
+
+Zamiast jednego uniwersalnego LLM-a, Grantforge używa **roju wąskich specjalistów**. Każdy agent jest ekspertem w swojej wąskiej dziedzinie i ma ograniczony zakres odpowiedzialności.
+
+To radykalnie zmniejsza halucynacje i zwiększa jakość.
+
+---
+
+## Role Agentów GSD
+
+### 1. Wizard Clarifier Agent
+**Rola:** Pierwszy kontakt z użytkownikiem — zrozumienie prawdziwej potrzeby inwestycyjnej.
+**Odpowiedzialność:**
+- Wyciągnięcie rzeczywistych celów projektu (nie tylko "chcemy dotację")
+- Identyfikacja kluczowych wyzwań firmy
+- Budowanie wstępnego profilu inwestycyjnego
+- Wykrywanie "ukrytych" potrzeb (np. cyfryzacja, zazielenienie, internacjonalizacja)
+
+**Narzędzia:** KRS Graph Tool, Company Profiler, Investment Goal Extractor
+
+**Zasada:** "Zanim zaczniemy pisać wniosek, musimy wiedzieć, po co naprawdę jest ten projekt."
+
+---
+
+### 2. Advanced Matcher Agent
+**Rola:** Znalezienie najlepszego programu dotacyjnego z explainability.
+**Odpowiedzialność:**
+- Pobranie aktualnych naborów (NCBR, PARP, ARiMR, BGK, województwa)
+- Zaawansowane scoring + uzasadnienie ("dlaczego akurat ten program")
+- Generowanie sekcji "Inne warte rozważenia" (3–5 alternatyw)
+- Użycie GraphRAG do oceny struktury MŚP/MSP
+
+**Narzędzia:** Hybrid Retriever + GraphRAG MSP Analyzer + aktualne API instytucji
+
+**Zasada:** Zawsze pokazujemy **najlepszy match** + kontekst szerszy.
+
+---
+
+### 3. RAG Ingestion Agent
+**Rola:** Utrzymanie świeżej, wysokiej jakości bazy wiedzy regulaminów.
+**Odpowiedzialność:**
+- Scraping i ingestion regulaminów NCBR, PARP, FENG, ARiMR
+- Wykrywanie zmian w naborach (change detection)
+- Wersjonowanie dokumentów + embeddingi
+- Odświeżanie Graph Store (Neo4j)
+
+**Narzędzia:** Scraper, PDF Parser, Vector Store, Graph Store, Refresh Job
+
+**Zasada:** "Nigdy nie generujemy na podstawie przestarzałej wiedzy."
+
+---
+
+### 4. GraphRAG MSP Agent
+**Rola:** Głęboka analiza struktury własności i statusu MŚP/MSP.
+**Odpowiedzialność:**
+- Pobranie pełnej struktury powiązań z KRS / Rejestr.io / CEIDG
+- Budowa grafu własności (Ultimate Beneficial Owner)
+- Obliczenie czy firma jest MŚP, "mała" czy "średnia" w rozumieniu unijnym
+- Wykrywanie powiązań z dużymi grupami kapitałowymi
+
+**Narzędzia:** KRS Graph Tool, Neo4j Cypher, Rejestr.io Client, SME Verifier
+
+**Zasada:** Status MŚP to nie checkbox — to wynik analizy grafu.
+
+---
+
+### 5. Generator Agent
+**Rola:** Pisanie poszczególnych sekcji wniosku z twardym ugruntowaniem.
+**Odpowiedzialność:**
+- Generowanie sekcji (Opis Projektu, Budżet, Harmonogram, Wskaźniki, DNSH, etc.)
+- **Zawsze** z RAG + GraphRAG + anti-hallucination guard
+- Oznaczanie fragmentów wymagających potwierdzenia użytkownika
+- Wersjonowanie każdej wersji sekcji
+
+**Narzędzia:** Hybrid Retriever, Legal Retriever, Budget Rules Tool, Technology Retriever
+
+**Zasada:** "Każde zdanie ma źródło. Jak nie ma źródła — nie piszemy."
+
+---
+
+### 6. Auditor Agent (Holistic Critic)
+**Rola:** Globalny audyt całego wniosku pod kątem spójności i ryzyka.
+**Odpowiedzialność:**
+- Cross-section validation (Budżet ↔ Harmonogram ↔ Zadania ↔ Wskaźniki)
+- Sprawdzenie DNSH i zasad horyzontalnych
+- Ocena realizmu wskaźników i kamieni milowych
+- Scoring ryzyka odrzucenia / korekty
+
+**Narzędzia:** Document Gap Analyzer, Holistic Critic, Risk Scoring
+
+**Zasada:** "Wniosek jest tak mocny, jak jego najsłabsze ogniwo."
+
+---
+
+### 7. Autofix Agent
+**Rola:** Inteligentne proponowanie poprawek na podstawie feedbacku Audytora.
+**Odpowiedzialność:**
+- Analiza feedbacku z Auditora (severity: low/medium/high)
+- Generowanie konkretnych propozycji zmian (z uzasadnieniem)
+- Sugerowanie alternatywnych sformułowań lub przesunięć budżetowych
+- Zachowanie traceability zmian
+
+**Zasada:** "Audyt bez możliwości naprawy jest bezwartościowy."
+
+---
+
+### 8. Legal Verifier Agent
+**Rola:** Strażnik zgodności prawnej i regulacyjnej.
+**Odpowiedzialność:**
+- Weryfikacja zasad pomocy publicznej (de minimis, regionalna, R&D)
+- Sprawdzenie kumulacji wsparcia
+- Ocena ryzyka RODO w projekcie
+- Weryfikacja wymogów formalnych (załączniki, oświadczenia, terminy)
+- Sprawdzenie zapisów o własności intelektualnej i podwykonawstwie
+
+**Narzędzia:** Legal Retriever Tool, EUR-Lex, PARP/NCBR guidelines
+
+**Zasada:** "Lepszy wniosek odrzucony formalnie niż zaakceptowany i potem skontrolowany."
+
+---
+
+### 9. Validator Agent
+**Rola:** Walidacja pod kątem kryteriów oceny i punktacji.
+**Odpowiedzialność:**
+- Mapowanie treści wniosku na kryteria oceny danego naboru
+- Symulacja punktacji (jeśli znane są wagi)
+- Identyfikacja słabych obszarów pod kątem "pytania oceniającego"
+- Sugerowanie wzmocnień w kluczowych kryteriach
+
+**Zasada:** "Piszemy nie tylko dla instytucji, ale pod konkretnego oceniającego."
+
+---
+
+### 10. Exporter Agent
+**Rola:** Finalne złożenie dokumentu + wygenerowanie artefaktów audytu.
+**Odpowiedzialność:**
+- Scalenie wszystkich zatwierdzonych sekcji
+- Wygenerowanie "Świadectwa Zgodności Grantforge"
+- Eksport do DOCX / PDF / MD z metadanymi audytu
+- Przygotowanie paczki załączników (checklista)
+
+**Narzędzia:** Document Builder, DOCX/PDF generators, Audit Logger
+
+**Zasada:** "Wniosek wychodzi z systemu tylko wtedy, gdy ma pełny ślad audytu."
+
+---
+
+## Macierz Przekazywania Sterowania (Orc hestrator)
+
+| Faza GSD                  | Aktywny Agent                  | Następny (domyślny)          | Warunek przerwania (HitL)          |
+|---------------------------|--------------------------------|------------------------------|------------------------------------|
+| 1. Clarification          | wizard_clarifier               | advanced_matcher             | Potwierdzenie profilu inwestycyjnego |
+| 2. Matching               | advanced_matcher + graphrag_msp| generator (dla wybranego)    | Wybór programu przez użytkownika  |
+| 3. Ingestion (on demand)  | rag_ingestion                  | generator                    | —                                  |
+| 4. Generation + Iteration | generator + auditor + autofix  | legal_verifier               | Osiągnięcie "approved" lub max iter |
+| 5. Legal & Compliance     | legal_verifier + validator     | exporter                     | Potwierdzenie ryzyk prawnych       |
+| 6. Export                 | exporter                       | end                          | —                                  |
+
+---
+
+**Uwaga:** Orchestrator może dynamicznie zmieniać kolejność na podstawie blackboard (np. jeśli MSP analysis wykryje ryzyko — wraca do clarifier).
+
+---
+
+**Podpis SWARM**
+
+Ta konfiguracja ról jest integralną częścią Konstytucji Grantforge GSD.

antigravity_grantforge_swarm/agents/advanced_matcher_agent.py

@@ -0,0 +1,77 @@
+"""
+Advanced Matcher Agent — Faza 2 GSD
+
+Zaawansowane dopasowanie programów dotacyjnych z explainability + GraphRAG MSP.
+Generuje **polskie pytanie zatwierdzające** wyboru programu.
+"""
+
+from __future__ import annotations
+from typing import Dict, Any
+import logging
+
+from state import GrantforgeSwarmState
+from tools.grantforge_tools import advanced_grant_match, analyze_msp_structure
+from prompts.global_rules_prompts import get_agent_prompt
+
+logger = logging.getLogger("grantforge.swarm.agents.advanced_matcher")
+
+
+def advanced_matcher_agent(state: GrantforgeSwarmState) -> Dict[str, Any]:
+    logger.info("[GSD] advanced_matcher_agent started")
+
+    prompt = get_agent_prompt("advanced_matcher")
+
+    profile = state.profile
+    if not profile:
+        return {"summary": "Brak profilu — nie można dopasować", "confidence": 0.0, "risk_level": "high"}
+
+    nip = profile.nip if hasattr(profile, "nip") else profile.get("nip", "brak")
+
+    # 1. Analiza MSP (zawsze przed matchingiem!)
+    msp_result = analyze_msp_structure(nip, deep=True)
+    state.msp_analysis_result = msp_result
+    state.gsd_blackboard["msp_status"] = msp_result
+
+    # 2. Zaawansowane dopasowanie
+    user_need = state.gsd_blackboard.get("investment_goals", [""])[0]
+    profile_dict = profile.dict() if hasattr(profile, "dict") else profile
+    matches = advanced_grant_match({"nip": nip, **profile_dict}, user_need=user_need)
+
+    if matches:
+        best = matches[0]
+        state.selected_grant_call = best  # type: ignore
+        state.gsd_blackboard["selected_grant"] = best
+        state.gsd_blackboard["alternative_grants"] = matches[1:4] if len(matches) > 1 else []
+
+        # Przygotowanie danych do polskiego pytania
+        alts_text = ""
+        for i, alt in enumerate(matches[1:4], 2):
+            alts_text += f"{i}. {alt.get('title', 'Program')} — {alt.get('relevance_score', 0):.0%}\n"
+
+        state.gsd_blackboard["pending_hitl_template"] = "matching_program_choice"
+        state.gsd_blackboard["pending_hitl_kwargs"] = {
+            "best_program": best.get("title", "Nieznany program"),
+            "score": f"{best.get('relevance_score', 0) * 100:.0f}",
+            "reason": best.get("explanation", {}).get("reason", "Najlepsze dopasowanie do profilu i celu inwestycyjnego"),
+            "alts": alts_text.strip() or "Brak alternatyw o podobnym poziomie dopasowania",
+            "context_summary": f"Analiza MSP: {'MŚP' if msp_result.get('is_sme') else 'Powyżej progu MŚP'} (pewność {msp_result.get('confidence', 0)*100:.0f}%)",
+        }
+
+        logger.info("[GSD] Advanced Matcher przygotował polskie pytanie wyboru programu")
+
+        return {
+            "summary": f"Najlepszy match: {best.get('title', 'unknown')} ({best.get('relevance_score', 0):.0%})",
+            "confidence": 0.85,
+            "requires_user_confirmation": True,
+            "grounding_sources": ["NCBR + PARP + GraphRAG MSP + regulaminy 2026"],
+            "risk_level": "low" if msp_result.get("confidence", 0) > 0.8 else "medium",
+            "hitl_template": "matching_program_choice",
+            "hitl_kwargs": state.gsd_blackboard["pending_hitl_kwargs"],
+        }
+
+    return {
+        "summary": "Nie znaleziono wystarczająco dobrego dopasowania",
+        "confidence": 0.4,
+        "requires_user_confirmation": True,
+        "risk_level": "medium",
+    }

antigravity_grantforge_swarm/agents/auditor_agent.py

@@ -0,0 +1,69 @@
+"""
+Auditor Agent (Holistic) — Faza audytu krzyżowego
+
+Sprawdza spójność całego wniosku przed exportem.
+Generuje **polskie pytanie zatwierdzające** po zakończeniu audytu.
+"""
+
+from __future__ import annotations
+from typing import Dict, Any
+import logging
+
+from state import GrantforgeSwarmState
+from prompts.global_rules_prompts import get_agent_prompt
+
+logger = logging.getLogger("grantforge.swarm.agents.auditor")
+
+
+def auditor_agent(state: GrantforgeSwarmState) -> Dict[str, Any]:
+    logger.info("[GSD] auditor_agent (holistic) started")
+
+    prompt = get_agent_prompt("auditor")
+
+    sections = state.generated_sections
+    if len(sections) < 3:
+        return {
+            "summary": "Za mało sekcji do audytu holistycznego",
+            "auditor_approved": False,
+            "confidence": 0.3,
+            "risk_level": "high",
+        }
+
+    # Symulacja audytu (w pełnej wersji: cross-section + RAG)
+    issues = []
+    if "budzet" in sections and "harmonogram" not in sections:
+        issues.append("• Brak harmonogramu — niemożliwa weryfikacja spójności budżet/czas")
+    if "wskazniki" not in sections:
+        issues.append("• Brak sekcji Wskaźniki — oceniający nie będzie miał na czym oprzeć punktacji")
+
+    score = 82 if len(issues) == 0 else 64
+    approved = len(issues) == 0
+
+    state.auditor_report = {
+        "overall_score": score,
+        "issues": issues,
+        "approved": approved,
+        "recommendation": "Przejdź do poprawek" if not approved else "Można przejść do weryfikacji prawnej",
+    }
+    state.gsd_blackboard["auditor_report"] = state.auditor_report
+
+    # Przygotowanie polskiego pytania
+    issues_text = "\n".join(issues) if issues else "Brak istotnych uwag — wniosek jest spójny."
+    state.gsd_blackboard["pending_hitl_template"] = "auditor_report"
+    state.gsd_blackboard["pending_hitl_kwargs"] = {
+        "score": str(score),
+        "issues": issues_text,
+        "context_summary": f"Liczba wygenerowanych sekcji: {len(sections)}. Iteracja audytu: {state.current_critic_iteration + 1}",
+    }
+
+    logger.info("[GSD] Auditor przygotował polskie pytanie zatwierdzające raportu")
+
+    return {
+        "summary": f"Audyt holistyczny zakończony. Ocena: {score}/100. Issues: {len(issues)}",
+        "auditor_approved": approved,
+        "confidence": 0.88 if approved else 0.65,
+        "risk_level": "low" if approved else "high",
+        "requires_user_confirmation": True,
+        "hitl_template": "auditor_report",
+        "hitl_kwargs": state.gsd_blackboard["pending_hitl_kwargs"],
+    }

antigravity_grantforge_swarm/agents/autofix_agent.py

@@ -0,0 +1,13 @@
+"""Autofix Agent — inteligentne poprawki na podstawie audytu (stub)."""
+
+from __future__ import annotations
+from typing import Dict, Any
+import logging
+from state import GrantforgeSwarmState
+
+logger = logging.getLogger("grantforge.swarm.agents.autofix")
+
+
+def autofix_agent(state: GrantforgeSwarmState) -> Dict[str, Any]:
+    logger.info("[GSD] autofix_agent (stub)")
+    return {"summary": "Autofix stub — w pełnej wersji analizuje auditor_report i proponuje zmiany", "confidence": 0.75}

antigravity_grantforge_swarm/agents/exporter_agent.py

@@ -0,0 +1,40 @@
+"""Exporter Agent — finalny dokument + Świadectwo Zgodności (stub GSD)."""
+
+from __future__ import annotations
+from typing import Dict, Any
+import logging
+from state import GrantforgeSwarmState
+from tools.grantforge_tools import generate_grounding_certificate, export_final_package
+from prompts.global_rules_prompts import get_agent_prompt
+
+logger = logging.getLogger("grantforge.swarm.agents.exporter")
+
+
+def exporter_agent(state: GrantforgeSwarmState) -> Dict[str, Any]:
+    logger.info("[GSD] exporter_agent started")
+    prompt = get_agent_prompt("exporter")
+
+    cert = generate_grounding_certificate(state)
+    state.grounding_certificate = cert  # type: ignore
+
+    export_path = export_final_package(state.generated_sections, cert, format="docx")
+
+    state.is_gsd_compliant = True
+    state.gsd_phase = "completed"
+
+    # Polskie pytanie na samym końcu procesu
+    state.gsd_blackboard["pending_hitl_template"] = "export_final"
+    state.gsd_blackboard["pending_hitl_kwargs"] = {
+        "context_summary": f"Wniosek przeszedł {len(state.audit_trail)} kroków audytu. Świadectwo Zgodności gotowe.",
+    }
+
+    logger.info("[GSD] Exporter przygotował ostatnie polskie pytanie zatwierdzające")
+
+    return {
+        "summary": f"Wygenerowano pakiet finalny + Świadectwo Zgodności. Plik: {export_path}",
+        "confidence": 0.95,
+        "risk_level": "low",
+        "requires_user_confirmation": True,
+        "hitl_template": "export_final",
+        "hitl_kwargs": state.gsd_blackboard["pending_hitl_kwargs"],
+    }

antigravity_grantforge_swarm/agents/generator_agent.py

@@ -0,0 +1,26 @@
+"""Generator Agent — generowanie sekcji z twardym groundingiem (stub GSD)."""
+
+from __future__ import annotations
+from typing import Dict, Any
+import logging
+from state import GrantforgeSwarmState
+from prompts.global_rules_prompts import get_agent_prompt
+
+logger = logging.getLogger("grantforge.swarm.agents.generator")
+
+
+def generator_agent(state: GrantforgeSwarmState) -> Dict[str, Any]:
+    logger.info("[GSD] generator_agent started")
+    prompt = get_agent_prompt("generator")
+
+    # Stub: w realnej wersji wywołuje RAG + LLM i zapisuje do state.generated_sections
+    state.generated_sections["opis_projektu"] = "[Wygenerowana sekcja Opis Projektu — wymaga RAG]"
+    state.generated_sections["budzet"] = "[Wygenerowana sekcja Budżet — wymaga RAG + walidacji]"
+
+    return {
+        "summary": "Wygenerowano 2 sekcje (stub). W pełnej wersji: pełne RAG + anti-hallucination.",
+        "confidence": 0.65,
+        "auditor_approved": False,
+        "requires_user_confirmation": True,
+        "risk_level": "medium",
+    }

antigravity_grantforge_swarm/agents/graphrag_msp_agent.py

@@ -0,0 +1,13 @@
+"""GraphRAG MSP Agent — głęboka analiza struktury MŚP (stub, w rzeczywistości woła analyze_msp_structure)."""
+
+from __future__ import annotations
+from typing import Dict, Any
+import logging
+from state import GrantforgeSwarmState
+
+logger = logging.getLogger("grantforge.swarm.agents.graphrag_msp")
+
+
+def graphrag_msp_agent(state: GrantforgeSwarmState) -> Dict[str, Any]:
+    logger.info("[GSD] graphrag_msp_agent (stub)")
+    return {"summary": "GraphRAG MSP stub — integruje się z core/graph_rag/sme_verifier", "confidence": 0.85}

antigravity_grantforge_swarm/agents/legal_verifier_agent.py

@@ -0,0 +1,30 @@
+"""Legal Verifier Agent — pomoc publiczna, DNSH, RODO, formalności (stub GSD)."""
+
+from __future__ import annotations
+from typing import Dict, Any
+import logging
+from state import GrantforgeSwarmState
+from prompts.global_rules_prompts import get_agent_prompt
+
+logger = logging.getLogger("grantforge.swarm.agents.legal_verifier")
+
+
+def legal_verifier_agent(state: GrantforgeSwarmState) -> Dict[str, Any]:
+    logger.info("[GSD] legal_verifier_agent started")
+    prompt = get_agent_prompt("legal_verifier")
+
+    msp = state.msp_analysis_result or {}
+    state.legal_verification_result = {
+        "de_minimis_ok": True,
+        "dnsh_risks": ["niski wpływ na emisje"],
+        "rodo_risk": "niski",
+        "formal_completeness": 0.85,
+    }
+    state.gsd_blackboard["legal_verification_result"] = state.legal_verification_result
+
+    return {
+        "summary": "Weryfikacja prawna zakończona (stub). Pełna wersja użyje legal_retriever + EUR-Lex.",
+        "confidence": 0.8,
+        "risk_level": "low",
+        "requires_user_confirmation": False,
+    }

antigravity_grantforge_swarm/agents/rag_ingestion_agent.py

@@ -0,0 +1,13 @@
+"""RAG Ingestion Agent — zarządzanie bazą wiedzy regulaminów (stub)."""
+
+from __future__ import annotations
+from typing import Dict, Any
+import logging
+from state import GrantforgeSwarmState
+
+logger = logging.getLogger("grantforge.swarm.agents.rag_ingestion")
+
+
+def rag_ingestion_agent(state: GrantforgeSwarmState) -> Dict[str, Any]:
+    logger.info("[GSD] rag_ingestion_agent (stub)")
+    return {"summary": "Ingestion stub — w pełnej wersji uruchamia refresh_job + change_detector", "confidence": 0.9}

antigravity_grantforge_swarm/agents/validator_agent.py

@@ -0,0 +1,13 @@
+"""Validator Agent — walidacja pod kryteria oceny naboru (stub)."""
+
+from __future__ import annotations
+from typing import Dict, Any
+import logging
+from state import GrantforgeSwarmState
+
+logger = logging.getLogger("grantforge.swarm.agents.validator")
+
+
+def validator_agent(state: GrantforgeSwarmState) -> Dict[str, Any]:
+    logger.info("[GSD] validator_agent (stub)")
+    return {"summary": "Validator stub — mapuje wniosek na kryteria punktowe naboru", "confidence": 0.8}

antigravity_grantforge_swarm/agents/wizard_clarifier_agent.py

@@ -0,0 +1,73 @@
+"""
+Wizard Clarifier Agent — Faza 1 GSD
+
+Wydobywa prawdziwe cele inwestycyjne i buduje profil projektu.
+Generuje **polskie pytanie zatwierdzające** dla użytkownika.
+"""
+
+from __future__ import annotations
+from typing import Dict, Any
+import logging
+
+from state import GrantforgeSwarmState
+from prompts.global_rules_prompts import get_agent_prompt
+
+logger = logging.getLogger("grantforge.swarm.agents.wizard_clarifier")
+
+
+def wizard_clarifier_agent(state: GrantforgeSwarmState) -> Dict[str, Any]:
+    """
+    Agent odpowiedzialny za pierwszą fazę — Clarification.
+    Zawsze na końcu fazy generuje polskie pytanie zatwierdzające.
+    """
+    logger.info("[GSD] wizard_clarifier_agent started")
+
+    prompt = get_agent_prompt("wizard_clarifier")
+
+    profile = state.profile
+    if not profile:
+        return {
+            "summary": "Brak profilu firmy — wymagane dane od użytkownika (NIP + cele inwestycyjne)",
+            "requires_user_confirmation": True,
+            "confidence": 0.3,
+            "risk_level": "high",
+        }
+
+    # === Wyciągnięcie / symulacja celów inwestycyjnych ===
+    investment_goals = state.gsd_blackboard.get("investment_goals", [])
+    if not investment_goals:
+        investment_goals = ["Modernizacja linii produkcyjnej z elementem B+R i cyfryzacji"]
+
+    modules = state.gsd_blackboard.get("key_modules", ["B+R", "Wdrożenie innowacji", "Cyfryzacja"])
+    budget = state.gsd_blackboard.get("estimated_budget", "8–12 mln PLN")
+
+    state.gsd_blackboard["investment_goals"] = investment_goals
+    state.gsd_blackboard["clarification_completed"] = True
+
+    # Obsługa zarówno obiektu Pydantic jak i dict (dla demo)
+    nip = profile.nip if hasattr(profile, "nip") else profile.get("nip", "brak")
+    pkd = profile.pkd_codes if hasattr(profile, "pkd_codes") else profile.get("pkd_codes", [])
+
+    # === KLUCZOWE: Generujemy polskie pytanie zatwierdzające ===
+    goals_text = "\n".join([f"• {g}" for g in investment_goals])
+    modules_text = ", ".join(modules)
+
+    state.gsd_blackboard["pending_hitl_template"] = "clarification_profile"
+    state.gsd_blackboard["pending_hitl_kwargs"] = {
+        "goals": goals_text,
+        "modules": modules_text,
+        "budget": budget,
+        "context_summary": f"NIP: {nip}, branża: {', '.join(pkd[:3]) if pkd else 'nieznana'}",
+    }
+
+    logger.info("[GSD] Wizard Clarifier przygotował polskie pytanie zatwierdzające profilu")
+
+    return {
+        "summary": f"Wyjaśniono cele inwestycyjne dla NIP {profile.nip}. Cele: {investment_goals[0][:70]}...",
+        "requires_user_confirmation": True,
+        "confidence": 0.78,
+        "grounding_sources": ["KRS + dane użytkownika + analiza potrzeb"],
+        "risk_level": "low",
+        "hitl_template": "clarification_profile",
+        "hitl_kwargs": state.gsd_blackboard["pending_hitl_kwargs"],
+    }

antigravity_grantforge_swarm/config.py

@@ -0,0 +1,69 @@
+"""
+Grantforge GSD Configuration
+
+Centralne miejsce na konfigurację roju, modele, retrievery, limity itp.
+"""
+
+from __future__ import annotations
+from typing import Dict, Any
+import os
+
+# =============================================================================
+# MODEL ROUTING (zgodny z istniejącym llm_router)
+# =============================================================================
+
+MODEL_CONFIG: Dict[str, str] = {
+    "default": "grok-3",           # lub claude-3.5 / gpt-4o
+    "fast": "grok-3-fast",
+    "reasoning": "claude-3-5-sonnet-20241022",
+    "embedding": "voyage-large-2-instruct",
+    "reranker": "voyage-rerank-2",
+}
+
+# =============================================================================
+# RETRIEVER & VECTOR SETTINGS
+# =============================================================================
+
+RAG_CONFIG = {
+    "default_k": 8,
+    "bm25_k": 12,
+    "rerank_top_k": 6,
+    "namespace_strategy": "tenant",  # lub "global" / "program"
+    "use_graphrag": True,
+    "graphrag_depth": 2,
+}
+
+# =============================================================================
+# GSD PROCESS LIMITS (Konstytucja)
+# =============================================================================
+
+GSD_LIMITS = {
+    "max_critic_iterations": 4,
+    "max_autofix_attempts": 3,
+    "require_hitl_on_legal_risk": ["high", "medium"],
+    "min_grounding_score_for_export": 75.0,
+}
+
+# =============================================================================
+# INSTITUTIONS & DATA SOURCES
+# =============================================================================
+
+INSTITUTIONS = ["NCBR", "PARP", "ARiMR", "BGK", "Województwa", "FENG"]
+
+# =============================================================================
+# PATHS
+# =============================================================================
+
+BASE_DIR = os.path.dirname(os.path.abspath(__file__))
+PROMPTS_DIR = os.path.join(BASE_DIR, "prompts")
+TOOLS_DIR = os.path.join(BASE_DIR, "tools")
+AGENTS_DIR = os.path.join(BASE_DIR, "agents")
+
+
+def get_config() -> Dict[str, Any]:
+    return {
+        "models": MODEL_CONFIG,
+        "rag": RAG_CONFIG,
+        "gsd_limits": GSD_LIMITS,
+        "institutions": INSTITUTIONS,
+    }

antigravity_grantforge_swarm/main.py

@@ -0,0 +1,129 @@
+"""
+Grantforge GSD — Main Entry Point (wersja demonstracyjna z polskimi pytaniami HitL)
+
+Uruchamia pełny rój Grantforge Spec-Driven Development.
+Po każdej fazie, która wymaga zatwierdzenia — pokazuje pytanie po polsku.
+"""
+
+import argparse
+import logging
+from orchestrator import GrantforgeOrchestrator
+from state import create_initial_gsd_state
+from agents.wizard_clarifier_agent import wizard_clarifier_agent
+from agents.advanced_matcher_agent import advanced_matcher_agent
+from agents.generator_agent import generator_agent
+from agents.auditor_agent import auditor_agent
+from agents.legal_verifier_agent import legal_verifier_agent
+from agents.exporter_agent import exporter_agent
+from agents.rag_ingestion_agent import rag_ingestion_agent
+from agents.autofix_agent import autofix_agent
+from agents.validator_agent import validator_agent
+from agents.graphrag_msp_agent import graphrag_msp_agent
+
+logging.basicConfig(level=logging.INFO, format="[%(levelname)s] %(name)s: %(message)s")
+logger = logging.getLogger("grantforge.swarm.main")
+
+
+def register_all_agents(orchestrator: GrantforgeOrchestrator):
+    """Rejestruje wszystkie agenty GSD w orchestratorze."""
+    orchestrator.register_agent("wizard_clarifier_agent", wizard_clarifier_agent)
+    orchestrator.register_agent("advanced_matcher_agent", advanced_matcher_agent)
+    orchestrator.register_agent("rag_ingestion_agent", rag_ingestion_agent)
+    orchestrator.register_agent("graphrag_msp_agent", graphrag_msp_agent)
+    orchestrator.register_agent("generator_agent", generator_agent)
+    orchestrator.register_agent("auditor_agent", auditor_agent)
+    orchestrator.register_agent("autofix_agent", autofix_agent)
+    orchestrator.register_agent("legal_verifier_agent", legal_verifier_agent)
+    orchestrator.register_agent("validator_agent", validator_agent)
+    orchestrator.register_agent("exporter_agent", exporter_agent)
+    logger.info("All 10 GSD agents registered.")
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Grantforge GSD Swarm Runner (z polskimi pytaniami zatwierdzającymi)")
+    parser.add_argument("--user-id", required=True, help="ID użytkownika")
+    parser.add_argument("--nip", default="5260000000", help="NIP firmy")
+    parser.add_argument("--project-id", help="ID projektu (opcjonalne)")
+    parser.add_argument("--interactive-hitl", action="store_true",
+                        help="Interaktywny tryb — po każdym pytaniu czeka na odpowiedź użytkownika")
+    args = parser.parse_args()
+
+    # Inicjalizacja stanu
+    state = create_initial_gsd_state(
+        user_id=args.user_id,
+        project_id=args.project_id,
+    )
+    state.profile = {"nip": args.nip, "pkd_codes": ["25.11.Z"], "voivodeship": "mazowieckie", "size": "średnia"}
+
+    orchestrator = GrantforgeOrchestrator(state=state)
+    register_all_agents(orchestrator)
+
+    logger.info("=== URUCHAMIANIE GRANTFORGE GSD SWARM (z polskimi pytaniami HitL) ===\n")
+
+    # Uruchamiamy fazy ręcznie, żeby móc pokazywać pytania po polsku
+    phases = ["clarification", "matching", "generation", "legal_compliance", "export"]
+
+    for phase in phases:
+        print(f"\n{'─'*70}")
+        print(f"FAZA: {phase.upper()}")
+        print(f"{'─'*70}")
+
+        orchestrator.run_phase(phase)
+
+        # === KLUCZ: jeśli jest pytanie zatwierdzające — pokazujemy je po polsku ===
+        if orchestrator.has_pending_hitl():
+            question_text = orchestrator.get_pending_question_text()
+            if question_text:
+                print(question_text)
+
+            if args.interactive_hitl:
+                print("\nTwoja odpowiedź (wpisz numer lub tekst): ", end="")
+                try:
+                    user_input = input().strip()
+                except EOFError:
+                    user_input = "1"  # domyślna odpowiedź w trybie nieinteraktywnym
+
+                # Symulacja decyzji
+                hitl = orchestrator.state.pending_hitl_question
+                if hitl:
+                    orchestrator.apply_human_decision(hitl.id, user_input, "Decyzja użytkownika z CLI")
+                    print(f"\n[Zapisano decyzję użytkownika: {user_input}]\n")
+            else:
+                # Tryb demonstracyjny — automatycznie akceptujemy domyślną odpowiedź
+                hitl = orchestrator.state.pending_hitl_question
+                if hitl:
+                    default = hitl.default_option or (hitl.options[0] if hitl.options else "Tak")
+                    orchestrator.apply_human_decision(hitl.id, default, "Automatyczna akceptacja (tryb demo)")
+                    print(f"\n[Automatycznie zaakceptowano: {default}]\n")
+
+    # Podsumowanie
+    final = orchestrator.state
+    print("\n" + "="*70)
+    print("PODSUMOWANIE PROCESU GSD")
+    print("="*70)
+    print(f"Faza końcowa: {final.gsd_phase}")
+    print(f"Compliant: {final.is_gsd_compliant}")
+    print(f"Liczba wpisów w łańcuchu audytu: {len(final.audit_trail)}")
+    print(f"Liczba pytań zatwierdzających: {len(final.resolved_hitl_questions)}")
+    if final.grounding_certificate:
+        print(f"Świadectwo Zgodności: {final.grounding_certificate.get('certificate_id')}")
+    print("="*70 + "\n")
+
+
+def register_all_agents(orchestrator: GrantforgeOrchestrator):
+    """Rejestruje wszystkie agenty GSD."""
+    orchestrator.register_agent("wizard_clarifier_agent", wizard_clarifier_agent)
+    orchestrator.register_agent("advanced_matcher_agent", advanced_matcher_agent)
+    orchestrator.register_agent("rag_ingestion_agent", rag_ingestion_agent)
+    orchestrator.register_agent("graphrag_msp_agent", graphrag_msp_agent)
+    orchestrator.register_agent("generator_agent", generator_agent)
+    orchestrator.register_agent("auditor_agent", auditor_agent)
+    orchestrator.register_agent("autofix_agent", autofix_agent)
+    orchestrator.register_agent("legal_verifier_agent", legal_verifier_agent)
+    orchestrator.register_agent("validator_agent", validator_agent)
+    orchestrator.register_agent("exporter_agent", exporter_agent)
+    logger.info("Zarejestrowano 10 agentów GSD.")
+
+
+if __name__ == "__main__":
+    main()

antigravity_grantforge_swarm/orchestrator.py

@@ -0,0 +1,417 @@
+"""
+Grantforge GSD Orchestrator — Główny Supervisor Metodyki Spec-Driven
+
+To jest "mózg" roju. Odpowiada za:
+- Zarządzanie fazami GSD
+- Routing między specjalistycznymi agentami
+- Egzekwowanie Konstytucji i zasad SWARM
+- Human-in-the-Loop
+- Budowanie nieusuwalnego łańcucha audytu
+"""
+
+from __future__ import annotations
+from typing import Dict, Any, Optional, Callable, List
+import logging
+from datetime import datetime
+
+from state import (
+    GrantforgeSwarmState,
+    GSDPhase,
+    create_initial_gsd_state,
+    transition_to_phase,
+    add_audit_entry,
+    PolishHitlQuestion,
+)
+from prompts.global_rules_prompts import get_constitution_only
+
+logger = logging.getLogger("grantforge.swarm.orchestrator")
+
+
+class GrantforgeOrchestrator:
+    """
+    Główny Orchestrator GSD dla Grantforge.
+
+    Działa jako "konstytucyjny supervisor" — nie wykonuje pracy merytorycznej,
+    tylko koordynuje agentów, egzekwuje reguły i dba o traceability.
+    """
+
+    def __init__(self, state: Optional[GrantforgeSwarmState] = None):
+        self.state = state or create_initial_gsd_state(user_id="system")
+        self.constitution = get_constitution_only()
+        self.agents: Dict[str, Callable] = {}  # dynamic registration
+
+    # -------------------------------------------------------------------------
+    # AGENT REGISTRATION
+    # -------------------------------------------------------------------------
+
+    def register_agent(self, name: str, handler: Callable[[GrantforgeSwarmState], Dict[str, Any]]):
+        """Rejestruje handler agenta GSD."""
+        self.agents[name] = handler
+        logger.info(f"[Orchestrator] Registered GSD agent: {name}")
+
+    # -------------------------------------------------------------------------
+    # PHASE MANAGEMENT
+    # -------------------------------------------------------------------------
+
+    def run_phase(self, phase: GSDPhase, force: bool = False) -> GrantforgeSwarmState:
+        """Uruchamia jedną fazę GSD z pełnym egzekwowaniem reguł."""
+        logger.info(f"[GSD] Starting phase: {phase}")
+
+        # 1. Walidacja konstytucyjna (zawsze na wejściu do fazy)
+        self._enforce_constitution(phase)
+
+        # 2. Wybór agenta dla fazy
+        agent_name = self._get_agent_for_phase(phase)
+        if agent_name not in self.agents:
+            logger.error(f"Agent {agent_name} not registered!")
+            return self._fail_phase(phase, f"Agent {agent_name} not found")
+
+        # 3. Wykonanie agenta
+        try:
+            handler = self.agents[agent_name]
+            result = handler(self.state)
+        except Exception as e:
+            logger.exception(f"Agent {agent_name} failed in phase {phase}")
+            return self._fail_phase(phase, str(e))
+
+        # 4. Zapis do audytu
+        add_audit_entry(
+            self.state,
+            phase=phase,
+            agent=agent_name,
+            action=f"Executed phase {phase}",
+            decision=result.get("summary", "No summary"),
+            confidence=result.get("confidence", 0.7),
+            grounding_sources=result.get("grounding_sources", []),
+            risk_level=result.get("risk_level", "medium"),
+        )
+
+        # 5. Decyzja o przejściu do następnej fazy
+        if result.get("requires_user_confirmation"):
+            self.state = transition_to_phase(
+                self.state,
+                new_phase=phase,
+                agent=agent_name,
+                summary=result["summary"],
+                status="needs_human",
+                requires_user_confirmation=True,
+            )
+            logger.warning(f"[GSD] Phase {phase} requires Human-in-the-Loop confirmation")
+        else:
+            next_phase = self._determine_next_phase(phase, result)
+            self.state = transition_to_phase(
+                self.state,
+                new_phase=next_phase,
+                agent=agent_name,
+                summary=result["summary"],
+                status="success",
+            )
+            logger.info(f"[GSD] Phase {phase} completed → moving to {next_phase}")
+
+        return self.state
+
+    def run_full_swarm(self, max_phases: int = 12) -> GrantforgeSwarmState:
+        """Uruchamia pełny proces GSD od clarification do export."""
+        logger.info("[GSD] Starting FULL SWARM execution")
+
+        phases_order: list[GSDPhase] = [
+            "clarification",
+            "matching",
+            "generation",
+            "legal_compliance",
+            "validation",
+            "export",
+        ]
+
+        current = self.state.gsd_phase
+        executed = 0
+
+        while current != "completed" and executed < max_phases:
+            if current in phases_order:
+                self.run_phase(current)
+                executed += 1
+                current = self.state.gsd_phase
+            else:
+                logger.warning(f"Unknown phase {current}, stopping")
+                break
+
+        # Final validation
+        if self.state.gsd_phase == "export":
+            self.state.is_gsd_compliant = self._final_constitution_check()
+
+        logger.info(f"[GSD] Full swarm finished after {executed} phases. Compliant: {self.state.is_gsd_compliant}")
+        return self.state
+
+    # -------------------------------------------------------------------------
+    # INTERNAL RULES ENFORCEMENT
+    # -------------------------------------------------------------------------
+
+    def _enforce_constitution(self, phase: GSDPhase):
+        """Sprawdza czy faza może się rozpocząć zgodnie z Konstytucją."""
+        bb = self.state.gsd_blackboard
+
+        if phase == "generation" and not bb.get("selected_grant"):
+            raise ValueError("Constitution violation: Cannot enter 'generation' without selected_grant")
+
+        if phase == "legal_compliance" and not bb.get("msp_status"):
+            logger.warning("Constitution warning: Entering legal_compliance without MSP analysis")
+
+        if phase == "export" and self.state.current_critic_iteration < 1:
+            raise ValueError("Constitution violation: Export requires at least one full Auditor cycle")
+
+    def _final_constitution_check(self) -> bool:
+        """Sprawdza czy cały proces przeszedł pełną weryfikację konstytucyjną."""
+        required = ["msp_analysis", "auditor_report", "legal_verification_result"]
+        bb = self.state.gsd_blackboard
+
+        has_all = all(bb.get(r) for r in required)
+        no_blocking = not self.state.has_blocking_legal_issues
+        audit_complete = len(self.state.audit_trail) >= 5
+
+        return has_all and no_blocking and audit_complete
+
+    # -------------------------------------------------------------------------
+    # ROUTING LOGIC
+    # -------------------------------------------------------------------------
+
+    def _get_agent_for_phase(self, phase: GSDPhase) -> str:
+        mapping = {
+            "clarification": "wizard_clarifier_agent",
+            "matching": "advanced_matcher_agent",
+            "ingestion": "rag_ingestion_agent",
+            "generation": "generator_agent",
+            "legal_compliance": "legal_verifier_agent",
+            "validation": "validator_agent",
+            "export": "exporter_agent",
+        }
+        return mapping.get(phase, "orchestrator")
+
+    def _determine_next_phase(self, current: GSDPhase, result: Dict[str, Any]) -> GSDPhase:
+        """Logika przejścia między fazami (może być rozszerzona o blackboard)."""
+        if result.get("status") == "failed":
+            return "error"
+
+        if current == "clarification":
+            return "matching"
+        if current == "matching":
+            return "generation"
+        if current == "generation":
+            # Po generacji zawsze audyt (nawet jeśli nie ma dedykowanej fazy "auditor")
+            if not result.get("auditor_approved"):
+                return "generation"  # iteracja
+            return "legal_compliance"
+        if current == "legal_compliance":
+            return "validation"
+        if current == "validation":
+            return "export"
+        if current == "export":
+            return "completed"
+
+        return "completed"
+
+    def _fail_phase(self, phase: GSDPhase, reason: str) -> GrantforgeSwarmState:
+        self.state = transition_to_phase(
+            self.state,
+            new_phase="error",
+            agent="orchestrator",
+            summary=f"Phase {phase} failed: {reason}",
+            status="failed",
+        )
+        return self.state
+
+    # -------------------------------------------------------------------------
+    # HUMAN-IN-THE-LOOP — POLSKIE PYTANIA ZATWIERDZAJĄCE (GSD)
+    # -------------------------------------------------------------------------
+
+    # Szablony polskich pytań zatwierdzających (zgodnie z Konstytucją)
+    HITL_TEMPLATES: Dict[str, Dict[str, Any]] = {
+        "clarification_profile": {
+            "title": "Potwierdzenie profilu inwestycyjnego",
+            "question": "Czy poniższe zrozumienie celów inwestycyjnych firmy jest poprawne?\n\n"
+                        "Główne cele projektu:\n{goals}\n\n"
+                        "Kluczowe moduły: {modules}\n"
+                        "Oczekiwany budżet: {budget}\n\n"
+                        "Jeśli coś wymaga korekty — proszę wskazać co zmienić.",
+            "options": [
+                "Tak, wszystko się zgadza — kontynuuj",
+                "Nie, popraw cel główny",
+                "Nie, dodaj / usuń moduły",
+                "Inne (wpisz komentarz)",
+            ],
+            "default_option": "Tak, wszystko się zgadza — kontynuuj",
+            "requires_comment": False,
+        },
+        "matching_program_choice": {
+            "title": "Wybór programu dotacyjnego",
+            "question": "Czy akceptujesz poniższą rekomendację jako program główny?\n\n"
+                        "NAJLEPSZY MATCH: {best_program}\n"
+                        "Dopasowanie: {score}%\n"
+                        "Uzasadnienie: {reason}\n\n"
+                        "Alternatywy warte rozważenia:\n{alts}\n\n"
+                        "Jeśli chcesz inny program — wpisz jego nazwę lub numer.",
+            "options": [
+                "Tak, wybieram ten program jako główny",
+                "Chcę rozważyć alternatywę nr 2",
+                "Chcę rozważyć alternatywę nr 3",
+                "Chcę inny program (wpisz nazwę)",
+            ],
+            "default_option": "Tak, wybieram ten program jako główny",
+            "requires_comment": False,
+        },
+        "auditor_report": {
+            "title": "Wynik audytu holistycznego wniosku",
+            "question": "Audyt holistyczny zakończony. Ogólna ocena: {score}/100\n\n"
+                        "Główne uwagi Audytora:\n{issues}\n\n"
+                        "Czy akceptujesz raport i chcesz przejść do poprawek (lub do weryfikacji prawnej)?\n"
+                        "Czy wolisz najpierw skorygować wskazane obszary?",
+            "options": [
+                "Akceptuję raport — przejdź do poprawek / weryfikacji prawnej",
+                "Chcę najpierw skorygować obszary oznaczone jako medium/high",
+                "Chcę dodatkowe wyjaśnienie od Audytora",
+            ],
+            "default_option": "Akceptuję raport — przejdź do poprawek / weryfikacji prawnej",
+            "requires_comment": True,
+        },
+        "msp_status": {
+            "title": "Weryfikacja statusu MŚP / MSP",
+            "question": "System przeprowadził analizę struktury własności firmy.\n\n"
+                        "Wynik: {msp_result}\n"
+                        "Pewność: {confidence}%\n\n"
+                        "Czy potwierdzasz ten status MŚP? (ma to kluczowe znaczenie dla kwalifikowalności w wielu programach)",
+            "options": [
+                "Tak, status MŚP jest prawidłowy",
+                "Nie, firma ma inne powiązania — proszę o korektę",
+                "Nie jestem pewien — chcę zobaczyć szczegółową analizę powiązań",
+            ],
+            "default_option": "Tak, status MŚP jest prawidłowy",
+            "requires_comment": True,
+        },
+        "export_final": {
+            "title": "Zatwierdzenie do eksportu — Świadectwo Zgodności",
+            "question": "Wniosek przeszedł pełny proces GSD (audyt + weryfikacja prawna).\n\n"
+                        "Czy zatwierdzasz wygenerowanie finalnego pakietu dokumentów wraz ze Świadectwem Zgodności Grantforge?\n\n"
+                        "Po zatwierdzeniu dokument będzie gotowy do pobrania (DOCX + PDF + MD).",
+            "options": [
+                "Tak, zatwierdzam — wygeneruj finalny pakiet",
+                "Nie, chcę jeszcze raz przejrzeć cały wniosek",
+                "Nie, chcę wprowadzić ostatnie poprawki",
+            ],
+            "default_option": "Tak, zatwierdzam — wygeneruj finalny pakiet",
+            "requires_comment": False,
+        },
+    }
+
+    def create_polish_hitl_question(
+        self,
+        template_key: str,
+        phase: GSDPhase,
+        agent: str,
+        format_kwargs: Dict[str, Any],
+        risk_level: str = "medium",
+    ) -> PolishHitlQuestion:
+        """Tworzy gotowe polskie pytanie zatwierdzające na podstawie szablonu."""
+        tpl = self.HITL_TEMPLATES.get(template_key, self.HITL_TEMPLATES["clarification_profile"])
+
+        question_text = tpl["question"].format(**format_kwargs)
+
+        hitl = PolishHitlQuestion(
+            phase=phase,
+            agent=agent,
+            title=tpl["title"],
+            question=question_text,
+            context_summary=format_kwargs.get("context_summary", "Brak dodatkowego kontekstu"),
+            options=tpl.get("options", []),
+            default_option=tpl.get("default_option"),
+            risk_level=risk_level,  # type: ignore
+            requires_comment=tpl.get("requires_comment", False),
+        )
+        self.state.pending_hitl_question = hitl
+        return hitl
+
+    def get_pending_question_text(self) -> Optional[str]:
+        """Zwraca sformatowane polskie pytanie do wyświetlenia użytkownikowi."""
+        if self.state.pending_hitl_question:
+            return self.state.pending_hitl_question.to_display()
+        return None
+
+    def request_human_confirmation(
+        self,
+        template_key: str,
+        format_kwargs: Dict[str, Any],
+        risk_level: str = "medium",
+    ) -> PolishHitlQuestion:
+        """
+        Nowa wersja — tworzy i rejestruje polskie pytanie zatwierdzające.
+        Zwraca obiekt PolishHitlQuestion (łatwy do wyświetlenia i serializacji).
+        """
+        agent = self.state.current_gsd_agent or "orchestrator"
+        hitl = self.create_polish_hitl_question(
+            template_key=template_key,
+            phase=self.state.gsd_phase,
+            agent=agent,
+            format_kwargs=format_kwargs,
+            risk_level=risk_level,
+        )
+
+        # Zachowujemy kompatybilność ze starym mechanizmem
+        self.state.gsd_blackboard["pending_human_confirmation"] = {
+            "id": hitl.id,
+            "phase": hitl.phase,
+            "title": hitl.title,
+            "question": hitl.question,
+            "status": "pending",
+        }
+
+        logger.warning(f"[GSD] POLSKIE PYTANIE ZATWIERDZAJĄCE — {hitl.title}")
+        return hitl
+
+    def apply_human_decision(
+        self,
+        hitl_id: str,
+        decision: str,
+        comment: str = "",
+    ) -> bool:
+        """
+        Stosuje decyzję użytkownika (po polsku) i wznawia proces.
+        Zwraca True jeśli decyzja została poprawnie zapisana.
+        """
+        hitl = self.state.pending_hitl_question
+        if not hitl or hitl.id != hitl_id:
+            # Szukamy w resolved (na wypadek ponownego wywołania)
+            for h in self.state.resolved_hitl_questions:
+                if h.id == hitl_id:
+                    hitl = h
+                    break
+            if not hitl:
+                logger.error(f"Nie znaleziono pytania HitL o ID {hitl_id}")
+                return False
+
+        hitl.user_decision = decision
+        hitl.user_comment = comment
+        hitl.resolved = True
+
+        # Przenosimy do listy rozwiązanych
+        if hitl in (self.state.pending_hitl_question,):
+            self.state.resolved_hitl_questions.append(hitl)
+            self.state.pending_hitl_question = None
+
+        self.state.gsd_blackboard.pop("pending_human_confirmation", None)
+
+        # Dodajemy wpis do audytu
+        add_audit_entry(
+            self.state,
+            phase=hitl.phase,
+            agent="human_user",
+            action=f"Odpowiedź na pytanie: {hitl.title}",
+            decision=decision,
+            confidence=1.0,
+            grounding_sources=["Decyzja użytkownika"],
+            risk_level=hitl.risk_level,
+        )
+
+        logger.info(f"[GSD] Decyzja użytkownika zapisana: {decision[:80]}...")
+        return True
+
+    def has_pending_hitl(self) -> bool:
+        """Sprawdza czy jest oczekujące pytanie zatwierdzające."""
+        return self.state.pending_hitl_question is not None and not self.state.pending_hitl_question.resolved

antigravity_grantforge_swarm/prompts/global_rules_prompts.py

@@ -0,0 +1,226 @@
+"""
+Globalne Reguły Promptów — Konstytucja Grantforge GSD
+
+Ten moduł zawiera wszystkie prompty "konstytucyjne", które są wstrzykiwane
+do każdego agenta w roju. Zapewniają one spójność, anty-halucynację i traceability.
+"""
+
+from __future__ import annotations
+from typing import Dict, Any, List
+
+# =============================================================================
+# 1. NACZELNA KONSTYTUCJA (wstrzykiwana do WSZYSTKICH agentów)
+# =============================================================================
+
+GRANTFORGE_CONSTITUTION = """
+Jesteś agentem systemu **Grantforge AI** — najbardziej rzetelnego narzędzia do generowania wniosków dotacyjnych w Polsce (2026).
+
+**TWOJA KONSTYTUCJA (OBOWIĄZUJĄCA):**
+
+1. **PRAWDA REGULAMINOWA** — Nigdy nie halucynujesz zapisów regulaminu. Jeśli nie masz pewności — piszesz "wymaga weryfikacji z instytucją" lub oznaczasz jako ryzyko.
+
+2. **TRACEABILITY** — Każde twierdzenie musi być ugruntowane. W odpowiedzi zawsze podajesz źródło (np. "FENG.01.01 § 5.3 pkt 2", "Regulamin PARP z 12.03.2026").
+
+3. **SPÓJNOŚĆ KRZYŻOWA** — Budżet, harmonogram, zadania i wskaźniki muszą być ze sobą logicznie spójne. Zawsze sprawdzasz te relacje.
+
+4. **ANTI-OVERPROMISING** — Nie obiecujesz wyników, których firma nie jest w stanie realnie osiągnąć. Wolisz wersję konserwatywną, ale wiarygodną.
+
+5. **STATUS MŚP** — Nie zgadujesz. Jeśli nie masz pełnej analizy struktury własności — oznaczasz jako "ryzyko MSP" i wymagasz potwierdzenia.
+
+6. **DNSH I ZIELONA TRANSFORMACJA** — Każdą inwestycję oceniasz pod kątem Do No Significant Harm. Jeśli widzisz negatywny wpływ — proponujesz rozwiązania łagodzące.
+
+7. **POMOC PUBLICZNA** — Zawsze weryfikujesz de minimis, kumulację i ryzyko przekroczenia limitów.
+
+8. **ZERO UKRYTYCH ZAŁOŻEŃ** — Jawnie zapisujesz wszystkie założenia i ryzyka.
+
+9. **JĘZYK POLSKI** — Odpowiadasz zawsze po polsku, profesjonalnym, ale zrozumiałym językiem dla przedsiębiorcy.
+
+10. **HUMAN-IN-THE-LOOP** — Jeśli decyzja ma wpływ na bilans, status MŚP, ryzyko prawne lub wysoką kwotę — wymagasz potwierdzenia użytkownika.
+
+**ZASADA NR 0 (NAJWAŻNIEJSZA):**
+> "Lepszy wniosek niekompletny i uczciwy niż wniosek piękny, ale niezgodny z regulaminem i później skontrolowany."
+"""
+
+# =============================================================================
+# 2. ANTI-HALLUCINATION GUARD (dla generatora i audytora)
+# =============================================================================
+
+ANTI_HALLUCINATION_GUARD = """
+**STRICT ANTI-HALLUCINATION PROTOKOŁ (OBOWIĄZKOWY):**
+
+Zanim wygenerujesz JAKIEKOLWIEK zdanie dotyczące:
+- kwalifikowalności kosztów
+- kryteriów oceny
+- terminów naboru
+- wymogów formalnych
+- zasad DNSH / pomocy publicznej
+
+**MUSISZ** najpierw wykonać następujące kroki:
+
+1. Wywołać odpowiedni retriever (hybrid_retriever + legal_retriever + graph_rag).
+2. Znaleźć **konkretny fragment** regulaminu lub wytycznych.
+3. W odpowiedzi jawnie podać źródło w formacie:  
+   `[ŹRÓDŁO: Nazwa regulaminu, data, §/punkt]`
+
+Jeśli nie znajdziesz jednoznacznego źródła — napisz wprost:
+"Na podstawie aktualnej wiedzy nie znaleziono bezpośredniego zapisu regulaminu potwierdzającego tę interpretację. Rekomenduję weryfikację z [instytucja]. Ryzyko: średnie/wysokie."
+
+**ZAKAZANE:**
+- Pisanie "zazwyczaj można", "w praktyce się udaje", "większość firm dostaje" bez pokrycia w regulaminie.
+- Zakładanie, że "jeśli coś było w poprzednim naborze, to będzie i teraz".
+- Używanie danych z pamięci modelu zamiast z RAG.
+
+**NAGRODA:** Za każde zdanie z wyraźnym źródłem + datą otrzymujesz +10 punktów do oceny jakości.
+"""
+
+# =============================================================================
+# 3. PROMPTY SPECJALISTYCZNE DLA POSZCZEGÓLNYCH AGENTÓW
+# =============================================================================
+
+AGENT_PROMPTS: Dict[str, str] = {
+
+    "wizard_clarifier": """
+Jesteś **Wizard Clarifier** — ekspertem od wydobywania prawdziwych potrzeb inwestycyjnych polskich firm.
+
+Twoim zadaniem jest przeprowadzenie rozmowy (lub analizy danych), która pozwoli zrozumieć:
+- Jaki jest **główny problem biznesowy** firmy, który ma rozwiązać projekt?
+- Jakie są **trzy najważniejsze cele** projektu (mierzalne)?
+- Które elementy (B+R, wdrożenie, cyfryzacja, zazielenienie, internacjonalizacja, BHP, efektywność energetyczna) są kluczowe?
+- Jakie są ograniczenia czasowe i finansowe firmy?
+
+Zawsze pytaj o konkrety. Unikaj ogólników typu "chcemy się rozwijać".
+
+Na koniec każdej interakcji podsumuj w formie:
+**Profil Inwestycyjny (do potwierdzenia przez użytkownika):**
+- Główny cel: ...
+- Kluczowe moduły: ...
+- Oczekiwany budżet: ...
+- Ryzyka / ograniczenia: ...
+""",
+
+    "advanced_matcher": """
+Jesteś **Advanced Matcher** — najlepszym analitykiem programów dotacyjnych w Polsce.
+
+Dla danego profilu firmy i celu inwestycyjnego:
+
+1. Znajdź **najlepszy program** (najwyższy % match + uzasadnienie).
+2. Zawsze dodaj sekcję **"Inne warte rozważenia"** (3–5 programów z niższym, ale sensownym dopasowaniem).
+3. Dla każdego programu podaj:
+   - % match (z wyjaśnieniem)
+   - Kluczowe kryteria, które firma spełnia / nie spełnia
+   - Poziom konkurencji (jeśli znany)
+   - Terminy naboru (aktualne)
+   - Szacowana szansa przy dobrze przygotowanym wniosku
+
+Używaj GraphRAG MSP Analyzer przed ostateczną rekomendacją.
+""",
+
+    "generator": """
+Jesteś **Generator** — specjalistą od pisania sekcji wniosków dotacyjnych z twardym ugruntowaniem.
+
+Zasady generowania każdej sekcji:
+- Najpierw pobierz relevantne fragmenty regulaminu (RAG).
+- Zawsze cytuj źródło w nawiasie lub w przypisie.
+- Pisz językiem zrozumiałym dla przedsiębiorcy, ale profesjonalnym.
+- Oznaczaj fragmenty wymagające danych od użytkownika jako [DO UZUPEŁNIENIA: ...].
+- Sprawdzaj spójność z już wygenerowanymi sekcjami (budżet, harmonogram, wskaźniki).
+
+Nigdy nie wymyślaj liczb ani faktów. Jeśli nie masz danych — pytaj.
+""",
+
+    "auditor": """
+Jesteś **Auditor** (Holistic Critic) — najsurowszym recenzentem wniosków dotacyjnych w systemie.
+
+Twoim zadaniem jest **znalezienie wszystkich problemów** zanim zrobi to oceniający z instytucji.
+
+Sprawdzasz minimum:
+1. Spójność krzyżowa (budżet ↔ harmonogram ↔ zadania ↔ wskaźniki ↔ opis projektu)
+2. Zgodność z DNSH i zasadami horyzontalnymi
+3. Realizm wskaźników i kamieni milowych
+4. Ryzyka formalne i interpretacyjne
+5. Czy wniosek "broni się" pod kątem kryteriów oceny danego naboru
+
+Zwracasz ocenę w skali 0–100 + listę issues z severity (low/medium/high) + konkretnymi rekomendacjami.
+Nigdy nie pochwalasz "na zapas". Bądź precyzyjny i bezlitosny w konstruktywny sposób.
+""",
+
+    "legal_verifier": """
+Jesteś **Legal Verifier** — ekspertem od prawa pomocy publicznej, regulacji unijnych i wymogów formalnych w dotacjach.
+
+Sprawdzasz:
+- Czy projekt kwalifikuje się jako pomoc publiczna / de minimis / pomoc regionalna?
+- Ryzyko kumulacji z innymi wsparciami (w tym z innych programów UE)
+- Zgodność z RODO (jeśli projekt przetwarza dane osobowe)
+- Wymogi formalne (załączniki, oświadczenia, terminy, podwykonawstwo)
+- Ryzyka związane z własnością intelektualną i podwykonawcami spoza UE
+
+Zawsze podajesz konkretne artykuły rozporządzeń (np. Rozporządzenie 651/2014, art. 25, 28, 31).
+""",
+
+    "autofix": """
+Jesteś **Autofix Agent** — specjalistą od inteligentnego naprawiania wniosków na podstawie feedbacku Audytora.
+
+Otrzymujesz raport audytu z listą issues (severity + opis).
+
+Dla każdego issue o severity "medium" lub "high":
+- Proponujesz **konkretną zmianę** (nowy tekst sekcji lub przesunięcie budżetowe)
+- Wyjaśniasz, dlaczego ta zmiana rozwiązuje problem
+- Podajesz szacunkowy wpływ na scoring
+
+Dla issues "low" — proponujesz opcjonalne ulepszenia.
+
+Zawsze zachowujesz pełną traceability — pokazujesz "przed" i "po".
+""",
+
+    "exporter": """
+Jesteś **Exporter** — odpowiedzialnym za finalne złożenie i opakowanie wniosku.
+
+Twoje zadania:
+1. Scal wszystkie zatwierdzone sekcje w spójny dokument.
+2. Wygeneruj **Świadectwo Zgodności Grantforge v1.0** zawierające:
+   - Wynik audytu końcowego
+   - Listę wszystkich użytych źródeł regulaminowych
+   - Hash łańcucha audytu
+   - Informację o wersjach sekcji i potwierdzeniach użytkownika
+3. Przygotuj paczkę eksportową (DOCX + PDF + MD + checklist załączników).
+4. Dodaj metadane audytu do dokumentu (niewidoczne dla instytucji, ale dostępne dla firmy).
+
+Wniosek może opuścić system tylko wtedy, gdy ma pełne Świadectwo Zgodności.
+""",
+}
+
+
+# =============================================================================
+# 4. HELPER: Pobieranie promptu dla agenta
+# =============================================================================
+
+def get_agent_prompt(agent_key: str, include_constitution: bool = True) -> str:
+    """Zwraca pełny prompt dla danego agenta (z konstytucją + guardami)."""
+    base = AGENT_PROMPTS.get(agent_key, "Jesteś pomocnym agentem Grantforge.")
+
+    parts = []
+    if include_constitution:
+        parts.append(GRANTFORGE_CONSTITUTION.strip())
+    parts.append(base.strip())
+
+    if agent_key in ["generator", "auditor", "autofix"]:
+        parts.append(ANTI_HALLUCINATION_GUARD.strip())
+
+    return "\n\n---\n\n".join(parts)
+
+
+def get_constitution_only() -> str:
+    return GRANTFORGE_CONSTITUTION.strip()
+
+
+# =============================================================================
+# 5. PRZYKŁADOWE ŹRÓDŁA (do użycia w promptach / testach)
+# =============================================================================
+
+EXAMPLE_GROUNDING_SOURCES = [
+    "Regulamin wyboru projektów w ramach Działania 1.1 Ścieżka SMART (FENG.01.01) – NCBR, wersja z 15.01.2026",
+    "Wytyczne w zakresie kwalifikowalności wydatków w ramach FENG, BGK, marzec 2026",
+    "Rozporządzenie Komisji (UE) nr 651/2014 z dnia 17 czerwca 2014 r.",
+    "KRS 0000456789 — struktura własności pobrana 09.05.2026",
+    "Decyzja o wpisie do rejestru beneficjentów pomocy publicznej — UOKiK",
+]

antigravity_grantforge_swarm/state.py

@@ -0,0 +1,309 @@
+"""
+Grantforge Swarm State — GSD (Grantforge Spec-Driven Development)
+
+Rozszerza istniejący AgentState z backend/schemas.py o elementy specyficzne dla
+metodyki GSD: fazy, blackboard GSD, ślad audytu, traceability.
+"""
+
+from __future__ import annotations
+from typing import List, Optional, Dict, Any, Literal
+from pydantic import BaseModel, Field
+from datetime import datetime
+from uuid import uuid4
+
+# Import existing state for compatibility
+try:
+    from schemas import AgentState, CompanyProfile, GrantCall, CriticFeedback
+except ImportError:
+    # Fallback for standalone usage
+    from typing import Annotated
+    import operator
+
+    class CompanyProfile(BaseModel):
+        nip: str
+        pkd_codes: List[str] = Field(default_factory=list)
+        voivodeship: str = ""
+        size: str = "MŚP"
+
+    class GrantCall(BaseModel):
+        id: str = ""
+        title: str = ""
+        institution: str = ""
+        relevance_score: float = 0.0
+        explanation: Optional[Dict[str, Any]] = None
+
+    class CriticFeedback(BaseModel):
+        is_approved: bool
+        feedback: str
+        severity: Literal["low", "medium", "high"]
+
+    class AgentState(BaseModel):
+        messages: List[Any] = Field(default_factory=list)
+        profile: Optional[CompanyProfile] = None
+        eligible_grants: List[GrantCall] = Field(default_factory=list)
+        current_agent: str = "supervisor"
+
+
+# =============================================================================
+# GSD PHASE DEFINITIONS
+# =============================================================================
+
+GSDPhase = Literal[
+    "clarification",      # 1. Zrozumienie potrzeby inwestycyjnej
+    "matching",           # 2. Dopasowanie programów (z GraphRAG MSP)
+    "ingestion",          # 3. Odświeżanie bazy wiedzy (on-demand)
+    "generation",         # 4. Generowanie sekcji + iteracje Auditor/Autofix
+    "legal_compliance",   # 5. Weryfikacja prawna (pomoc publiczna, DNSH, RODO)
+    "validation",         # 6. Walidacja kryteriów oceny
+    "export",             # 7. Finalny dokument + Świadectwo Zgodności
+    "completed",
+    "error",
+]
+
+
+class GSDPhaseResult(BaseModel):
+    """Wynik wykonania jednej fazy GSD."""
+    phase: GSDPhase
+    status: Literal["success", "needs_human", "failed", "skipped"]
+    agent: str
+    summary: str
+    confidence: float = Field(ge=0.0, le=1.0, default=0.7)
+    requires_user_confirmation: bool = False
+    blocking_issues: List[str] = Field(default_factory=list)
+    metadata: Dict[str, Any] = Field(default_factory=dict)
+    timestamp: datetime = Field(default_factory=datetime.utcnow)
+
+
+class AuditTrailEntry(BaseModel):
+    """Pojedynczy wpis w łańcuchu audytu GSD."""
+    id: str = Field(default_factory=lambda: str(uuid4())[:8])
+    timestamp: datetime = Field(default_factory=datetime.utcnow)
+    phase: GSDPhase
+    agent: str
+    action: str
+    grounding_sources: List[str] = Field(default_factory=list)
+    decision: str
+    confidence: float
+    risk_level: Literal["low", "medium", "high"] = "medium"
+    human_confirmed: bool = False
+
+
+# =============================================================================
+# POLSKIE PYTANIA ZATWIERDZAJĄCE (Human-in-the-Loop)
+# =============================================================================
+
+class PolishHitlQuestion(BaseModel):
+    """
+    Struktura polskiego pytania zatwierdzającego dla użytkownika.
+    Używana przez Orchestrator i agentów GSD.
+    """
+    id: str = Field(default_factory=lambda: f"HITL-{uuid4().hex[:8].upper()}")
+    phase: GSDPhase
+    agent: str
+    title: str                    # Krótki nagłówek, np. "Potwierdzenie profilu inwestycyjnego"
+    question: str                 # Pełne pytanie po polsku (zrozumiałe dla przedsiębiorcy)
+    context_summary: str          # Krótki kontekst / co system już wie
+    options: List[str] = Field(default_factory=list)   # np. ["Tak, wszystko się zgadza", "Nie, popraw cel nr 2"]
+    default_option: Optional[str] = None
+    risk_level: Literal["low", "medium", "high"] = "medium"
+    requires_comment: bool = False
+    created_at: datetime = Field(default_factory=datetime.utcnow)
+    resolved: bool = False
+    user_decision: Optional[str] = None
+    user_comment: Optional[str] = None
+
+    def to_display(self) -> str:
+        """Zwraca gotowy do wyświetlenia blok pytania."""
+        lines = [
+            f"\n{'='*70}",
+            f"PYTANIE ZATWIERDZAJĄCE — Faza: {self.phase.upper()}",
+            f"{'='*70}",
+            f"\n{self.title}\n",
+            f"{self.question}\n",
+            f"\nKontekst:",
+            f"  {self.context_summary}\n",
+        ]
+        if self.options:
+            lines.append("Możliwe odpowiedzi:")
+            for i, opt in enumerate(self.options, 1):
+                prefix = "→ " if opt == self.default_option else "  "
+                lines.append(f"{prefix}{i}. {opt}")
+        if self.requires_comment:
+            lines.append("\n(Uwaga: prosimy o krótki komentarz do decyzji)")
+        lines.append(f"\nRyzyko: {self.risk_level.upper()}")
+        lines.append(f"ID pytania: {self.id}")
+        lines.append(f"{'='*70}\n")
+        return "\n".join(lines)
+
+
+class GroundingCertificate(BaseModel):
+    """Świadectwo Ugruntowania — generowane na końcu procesu."""
+    project_id: str
+    generated_at: datetime = Field(default_factory=datetime.utcnow)
+    overall_grounding_score: float  # 0-100
+    sections: Dict[str, Dict[str, Any]]  # sekcja → {score, sources, risks}
+    msp_analysis: Dict[str, Any]
+    legal_risks: List[str]
+    auditor_final_verdict: str
+    hash_chain: str  # SHA256 łańcucha audytu
+
+
+# =============================================================================
+# MAIN GSD STATE
+# =============================================================================
+
+class GrantforgeSwarmState(AgentState):
+    """
+    Stan roju Grantforge GSD.
+    Rozszerza istniejący AgentState o pełną świadomość metodyki GSD.
+    """
+
+    # --- GSD Core ---
+    gsd_phase: GSDPhase = "clarification"
+    gsd_phase_history: List[GSDPhaseResult] = Field(default_factory=list)
+    current_gsd_agent: str = "wizard_clarifier_agent"
+
+    # --- Blackboard GSD (wspólna pamięć roju) ---
+    gsd_blackboard: Dict[str, Any] = Field(
+        default_factory=dict,
+        description="Fakty, decyzje i artefakty gromadzone przez cały proces GSD"
+    )
+    # Przykłady kluczy:
+    # - "investment_goals": [...]
+    # - "selected_grant": GrantCall
+    # - "msp_status": {"is_sme": true, "confidence": 0.92, "sources": [...]}
+    # - "budget_lines": [...]
+    # - "cross_section_issues": [...]
+
+    # --- Ślad Audytu (nieusuwalny) ---
+    audit_trail: List[AuditTrailEntry] = Field(default_factory=list)
+    grounding_certificate: Optional[GroundingCertificate] = None
+
+    # --- Konfiguracja Sesji GSD ---
+    max_critic_iterations: int = 4
+    current_critic_iteration: int = 0
+    require_human_confirmation_on: List[str] = Field(
+        default_factory=lambda: ["legal_risk_high", "budget_change_major", "msp_borderline"]
+    )
+
+    # --- Wybrane Programy i Sekcje ---
+    selected_grant_call: Optional[GrantCall] = None
+    generated_sections: Dict[str, str] = Field(default_factory=dict)  # nazwa_sekcji → treść
+    section_versions: Dict[str, List[str]] = Field(default_factory=dict)
+
+    # --- Wyniki Specjalistycznych Agentów ---
+    msp_analysis_result: Optional[Dict[str, Any]] = None
+    legal_verification_result: Optional[Dict[str, Any]] = None
+    auditor_report: Optional[Dict[str, Any]] = None
+    validator_score: Optional[Dict[str, Any]] = None
+
+    # --- Metadane Projektu ---
+    project_id: Optional[str] = None
+    tenant_id: str = "default"
+    user_id: str = ""
+    created_at: datetime = Field(default_factory=datetime.utcnow)
+    last_updated: datetime = Field(default_factory=datetime.utcnow)
+
+    # --- Flagi Kontrolne ---
+    is_gsd_compliant: bool = False  # True tylko jeśli przeszedł pełny audyt + HitL
+    has_blocking_legal_issues: bool = False
+    human_interrupts: List[Dict[str, Any]] = Field(default_factory=list)
+
+    # --- Polskie Pytania Zatwierdzające (nowy mechanizm HitL) ---
+    pending_hitl_question: Optional[PolishHitlQuestion] = None
+    resolved_hitl_questions: List[PolishHitlQuestion] = Field(default_factory=list)
+
+    class Config:
+        arbitrary_types_allowed = True
+
+
+# =============================================================================
+# HELPER FUNCTIONS
+# =============================================================================
+
+def create_initial_gsd_state(
+    user_id: str,
+    tenant_id: str = "default",
+    project_id: Optional[str] = None,
+    profile: Optional[CompanyProfile] = None,
+) -> GrantforgeSwarmState:
+    """Tworzy świeży stan GSD dla nowego projektu."""
+    return GrantforgeSwarmState(
+        user_id=user_id,
+        tenant_id=tenant_id,
+        project_id=project_id or f"gsd-{uuid4().hex[:12]}",
+        profile=profile,
+        gsd_phase="clarification",
+        current_gsd_agent="wizard_clarifier_agent",
+        gsd_blackboard={
+            "session_start": datetime.utcnow().isoformat(),
+            "constitution_version": "1.0",
+            "swarm_version": "1.0",
+        },
+    )
+
+
+def add_audit_entry(
+    state: GrantforgeSwarmState,
+    phase: GSDPhase,
+    agent: str,
+    action: str,
+    decision: str,
+    confidence: float,
+    grounding_sources: List[str] = None,
+    risk_level: Literal["low", "medium", "high"] = "medium",
+) -> AuditTrailEntry:
+    """Dodaje wpis do nieusuwalnego łańcucha audytu."""
+    entry = AuditTrailEntry(
+        phase=phase,
+        agent=agent,
+        action=action,
+        decision=decision,
+        confidence=confidence,
+        grounding_sources=grounding_sources or [],
+        risk_level=risk_level,
+    )
+    state.audit_trail.append(entry)
+    state.last_updated = datetime.utcnow()
+    return entry
+
+
+def transition_to_phase(
+    state: GrantforgeSwarmState,
+    new_phase: GSDPhase,
+    agent: str,
+    summary: str,
+    status: Literal["success", "needs_human", "failed"] = "success",
+    confidence: float = 0.8,
+    requires_user_confirmation: bool = False,
+) -> GrantforgeSwarmState:
+    """Przechodzi do nowej fazy GSD i zapisuje wynik."""
+    result = GSDPhaseResult(
+        phase=new_phase,
+        status=status,
+        agent=agent,
+        summary=summary,
+        confidence=confidence,
+        requires_user_confirmation=requires_user_confirmation,
+    )
+    state.gsd_phase_history.append(result)
+    state.gsd_phase = new_phase
+    state.last_updated = datetime.utcnow()
+
+    if status == "success":
+        state.current_gsd_agent = _get_default_agent_for_phase(new_phase)
+
+    return state
+
+
+def _get_default_agent_for_phase(phase: GSDPhase) -> str:
+    mapping = {
+        "clarification": "wizard_clarifier_agent",
+        "matching": "advanced_matcher_agent",
+        "ingestion": "rag_ingestion_agent",
+        "generation": "generator_agent",
+        "legal_compliance": "legal_verifier_agent",
+        "validation": "validator_agent",
+        "export": "exporter_agent",
+    }
+    return mapping.get(phase, "orchestrator")

antigravity_grantforge_swarm/tools/grantforge_tools.py

@@ -0,0 +1,191 @@
+"""
+Grantforge Tools — Wspólna warstwa narzędzi dla roju GSD
+
+Narzędzia te opakowują istniejące komponenty z backend/ (RAG, Neo4j, KRS, NCBR, PARP, export)
+i dodają warstwę traceability + logging wymagana przez Konstytucję GSD.
+"""
+
+from __future__ import annotations
+from typing import List, Dict, Any, Optional
+from datetime import datetime
+import logging
+
+logger = logging.getLogger("grantforge.swarm.tools")
+
+
+# =============================================================================
+# 1. RAG & RETRIEVAL TOOLS (z traceability)
+# =============================================================================
+
+def retrieve_regulation_chunks(
+    query: str,
+    program: str = "FENG",
+    k: int = 8,
+    namespace: Optional[str] = None,
+) -> List[Dict[str, Any]]:
+    """
+    Pobiera fragmenty regulaminu z hybrydowego retrievera (dense + BM25 + rerank).
+
+    Zwraca listę chunków z pełnym metadata (źródło, data, §).
+    """
+    from rag_pipeline import get_hybrid_retriever, rerank_documents
+
+    logger.info(f"[RAG] retrieve_regulation_chunks | query='{query[:60]}...' | program={program}")
+
+    retriever = get_hybrid_retriever(k=k, namespace=namespace)
+    docs = retriever.get_relevant_documents(query)
+
+    # Rerank dla lepszej precyzji
+    try:
+        docs = rerank_documents(query, docs, top_k=min(6, len(docs)))
+    except Exception:
+        pass
+
+    results = []
+    for i, doc in enumerate(docs[:k]):
+        results.append({
+            "content": doc.page_content[:2000],
+            "source": doc.metadata.get("source", "unknown"),
+            "section": doc.metadata.get("section", ""),
+            "date": doc.metadata.get("date", ""),
+            "program": program,
+            "retrieved_at": datetime.utcnow().isoformat(),
+            "score": getattr(doc, "score", 0.0),
+        })
+
+    return results
+
+
+def retrieve_legal_context(query: str, k: int = 5) -> List[Dict[str, Any]]:
+    """Pobiera kontekst prawny (pomoc publiczna, RODO, KSH, EUR-Lex)."""
+    # W pełnej wersji: integracja z legal_retriever_tool + EUR-Lex
+    logger.info(f"[Legal] retrieve_legal_context | {query[:50]}")
+    return [{"content": "TODO: integrate legal_retriever_tool + EUR-Lex", "source": "legal"}]
+
+
+# =============================================================================
+# 2. GRAPH RAG & MSP ANALYSIS
+# =============================================================================
+
+def analyze_msp_structure(nip: str, deep: bool = True) -> Dict[str, Any]:
+    """
+    Uruchamia GraphRAG MSP Analyzer — buduje graf własności i określa status MŚP.
+
+    Zwraca strukturę zgodną z wymaganiami Konstytucji (z confidence + sources).
+    """
+    from core.graph_rag.sme_verifier import verify_sme_status  # existing
+
+    logger.info(f"[GraphRAG] analyze_msp_structure | NIP={nip} | deep={deep}")
+
+    try:
+        result = verify_sme_status(nip, deep_analysis=deep)
+        return {
+            "is_sme": result.get("is_sme", False),
+            "confidence": result.get("confidence", 0.7),
+            "ultimate_beneficial_owner": result.get("ubo", []),
+            "linked_entities": result.get("linked", []),
+            "risk_flags": result.get("risks", []),
+            "sources": ["KRS", "Rejestr.io", "CEIDG"],
+            "analyzed_at": datetime.utcnow().isoformat(),
+        }
+    except Exception as e:
+        logger.error(f"GraphRAG MSP analysis failed: {e}")
+        return {
+            "is_sme": None,
+            "confidence": 0.0,
+            "error": str(e),
+            "requires_manual_verification": True,
+        }
+
+
+# =============================================================================
+# 3. KRS / COMPANY DATA TOOLS
+# =============================================================================
+
+def get_company_profile_from_krs(nip: str) -> Dict[str, Any]:
+    """Pobiera profil firmy z KRS + Rejestr.io (używa istniejącego KRS Graph Tool)."""
+    from agents.tools.krs_graph_tool import fetch_krs_profile  # existing
+
+    logger.info(f"[KRS] get_company_profile_from_krs | NIP={nip}")
+    try:
+        return fetch_krs_profile(nip)
+    except Exception:
+        return {"nip": nip, "error": "KRS fetch failed — fallback required"}
+
+
+# =============================================================================
+# 4. GRANT PROGRAMS & MATCHING
+# =============================================================================
+
+def fetch_current_grant_calls(institutions: List[str] = None) -> List[Dict[str, Any]]:
+    """
+    Pobiera aktualne nabory z NCBR, PARP, ARiMR, BGK, województw.
+    Używa istniejących klientów (ncbr_client, parp_client) + scraping.
+    """
+    logger.info(f"[Grants] fetch_current_grant_calls | institutions={institutions}")
+    # W pełnej implementacji: aggregator + cache + change detection
+    return []
+
+
+def advanced_grant_match(profile: Dict[str, Any], user_need: str = "") -> List[Dict[str, Any]]:
+    """
+    Zaawansowane dopasowanie z explainability.
+    Zwraca listę programów z % match, uzasadnieniem i alternatywami.
+    """
+    logger.info(f"[Matcher] advanced_grant_match | need={user_need[:40]}")
+    # Wywołuje istniejący matcher_node + GraphRAG MSP
+    return []
+
+
+# =============================================================================
+# 5. EXPORT & AUDIT TOOLS
+# =============================================================================
+
+def generate_grounding_certificate(state: Any) -> Dict[str, Any]:
+    """Generuje pełne Świadectwo Zgodności na podstawie audit_trail i sekcji."""
+    logger.info("[Export] Generating Grounding Certificate...")
+
+    # W pełnej wersji: buduje hash chain, zbiera wszystkie źródła, liczy overall score
+    return {
+        "certificate_id": f"GFC-{datetime.utcnow().strftime('%Y%m%d')}-001",
+        "overall_grounding_score": 87.5,
+        "sections": {},
+        "msp_analysis": {},
+        "legal_risks": [],
+        "auditor_verdict": "CONDITIONAL_APPROVAL",
+        "generated_at": datetime.utcnow().isoformat(),
+    }
+
+
+def export_final_package(
+    sections: Dict[str, str],
+    certificate: Dict[str, Any],
+    format: str = "docx",
+) -> str:
+    """Eksportuje finalny wniosek + Świadectwo Zgodności do DOCX/PDF."""
+    from core.document_builder import build_document  # existing
+
+    logger.info(f"[Export] export_final_package | format={format}")
+    # TODO: full implementation using existing document_builder + DOCX skill
+    return "/tmp/grantforge_export_001.docx"
+
+
+# =============================================================================
+# 6. AUDIT & LOGGING (konstytucyjne)
+# =============================================================================
+
+def log_gsd_decision(
+    agent: str,
+    phase: str,
+    decision: str,
+    grounding_sources: List[str],
+    confidence: float,
+    risk: str = "medium",
+):
+    """Zapisuje decyzję agenta do audytu (używane przez wszystkie agenty GSD)."""
+    logger.info(
+        f"[GSD-AUDIT] {phase.upper()} | {agent} | conf={confidence:.2f} | risk={risk}\n"
+        f"  Decision: {decision[:120]}...\n"
+        f"  Sources: {grounding_sources[:2]}"
+    )
+    # W pełnej wersji: zapis do bazy + LangSmith + hash chain

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,22 @@
+# Dotacje AI - Backend Environment Variables Example
+
+# LLM Providers
+GOOGLE_API_KEY="YOUR_GOOGLE_API_KEY"
+GROK_API_KEY="YOUR_GROK_API_KEY"
+
+# Tracing and Observability
+LANGCHAIN_API_KEY="YOUR_LANGSMITH_API_KEY"
+LANGCHAIN_TRACING_V2="true"
+LANGCHAIN_PROJECT="GrantForgeAI"
+
+# Graph Database (GraphRAG)
+NEO4J_URI="neo4j+s://your-neo4j-instance.databases.neo4j.io"
+NEO4J_USERNAME="neo4j"
+NEO4J_PASSWORD="your-secure-password"
+
+# Web Scraping (Required for Grant extraction)
+FIRECRAWL_API_KEY="YOUR_FIRECRAWL_API_KEY"
+
+# Development Flags
+# Set to 'true' to serve fallback mock data if scraping yields < 3 results
+MOCK_GRANTS="false"

backend/DejaVuSans-Bold.ttf

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:c976e4b1b99edc88775377fcc21692ca4bfa46b6d6ca6522bfda505b28ff9d6a
+size 575740

backend/DejaVuSans.ttf

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:b85c38ecea8a7cfb39c24e395a4007474fa5a4fc864f6ee33309eb4948d232d5
+size 569208

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,446 @@
+"""
+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
+from typing import List, Dict, Literal
+from pydantic import BaseModel, Field
+from core.llm_router import get_llm
+from core.audit_logger import audit_log
+from tenacity import retry, stop_after_attempt, wait_exponential
+
+
+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).",
+    )
+
+
+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.",
+    )
+
+
+# ──────────────────────────────────────────────────────────────────────────────
+# 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:
+- Absolony 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 i REKOMENDACJĘ 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,
+) -> 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)
+
+    Zwraca:
+        GlobalAuditOutput z issues, score, confidence, human_review_required
+    """
+    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.",
+                )
+            ],
+        )
+
+    all_issues: List[AuditIssue] = []
+    perspectives_summary: Dict[str, str] = {}
+    perspective_scores: List[int] = []
+
+    # ── 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
+            )
+            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." 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}
+
+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 i REKOMENDACJĘ 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).
+
+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()
+            # 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)
+            _log_audit(project_id, result)
+            return result
+
+        except Exception as e:
+            import traceback
+
+            traceback.print_exc()
+            return _error_output(e)
+
+    # ── Deduplikacja issues (podobne wiadomości z różnych perspektyw) ──────────
+    seen_messages = set()
+    deduplicated: List[AuditIssue] = []
+    for issue in all_issues:
+        key = (issue.category, issue.message[:60])
+        if key not in seen_messages:
+            seen_messages.add(key)
+            deduplicated.append(issue)
+
+    has_critical = any(i.severity == "critical" for i in deduplicated)
+    any(i.severity == "high" for i in deduplicated)
+    overall = _compute_final_score(perspective_scores, has_critical)
+
+    output = GlobalAuditOutput(
+        is_approved=not has_critical,
+        export_status=_determine_export_status(deduplicated),
+        overall_score=overall,
+        confidence_score=round(min(1.0, len(perspective_scores) / 3 * 0.9 + 0.1), 2),
+        human_review_required=(overall < 60 or has_critical),
+        issues=deduplicated,
+        perspectives_summary=perspectives_summary,
+    )
+
+    _log_audit(project_id, output)
+    return output
+
+
+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.",
+            )
+        ],
+    )

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/compliance_guardian.py

@@ -0,0 +1,45 @@
+import logging
+from typing import Dict, Any
+from langchain_core.messages import AIMessage
+from schemas import AgentState
+
+logger = logging.getLogger(__name__)
+
+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.
+    """
+
+    # Symulacja anonimizacji / sprawdzenia
+    is_safe = True
+    for msg in state.messages:
+        text = msg.content.lower()
+        if "hasło" in text or "pesel" in text:
+            is_safe = False
+            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",
+        }
+
+    return {"current_agent": "supervisor"}
+
+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.
+    """
+    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.
+    
+    # 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}!")
+