refactor: simplify CI/CD - remove Netlify, keep Lovable for dev

- Remove deploy-dev.yml (Netlify workflow)
- Remove netlify.toml
- Update docs: Lovable for dev, Docker for prod/local/on-premise
- Add customer on-premise deployment instructions

Author: claude

.github/workflows/deploy-dev.yml

@@ -3,41 +3,40 @@
 ## Architecture
 
 ```
-Feature Branches → dev branch → main branch
-       ↓               ↓             ↓
-   CI Tests      Deploy DEV     Build Docker Image
-                 (Netlify)      (auto push to GHCR)
-                    ↓
-              Current Supabase
-
-                    ┌─────────────────────────────┐
-                    │   Manual Release Workflow   │
-                    └─────────────────────────────┘
-                                 ↓
-                        1. Run Tests
-                                 ↓
-                        2. Run Migrations (optional)
-                                 ↓
-                        3. Deploy Edge Functions
-                                 ↓
-                        4. Build & Push Docker Image
-                                 ↓
-                        5. Create GitHub Release
+Feature Branches → main branch
+       ↓               ↓
+   CI Tests      Build Docker Image
+                 (push to GHCR)
+
+    ┌─────────────────────────────────────────────┐
+    │          Manual Release Workflow            │
+    └─────────────────────────────────────────────┘
+                         ↓
+                1. Run Tests
+                         ↓
+                2. Run Migrations (optional)
+                         ↓
+                3. Deploy Edge Functions
+                         ↓
+                4. Build & Push Docker Image
+                         ↓
+                5. Create GitHub Release
 ```
 
 ## Environments
 
-| Environment | Frontend | Database | Trigger |
+| Environment | Frontend | Database | Purpose |
 |-------------|----------|----------|---------|
-| **DEV** | Netlify | Current Supabase | Push to `dev` |
-| **PROD** | Docker Image (GHCR) | New Supabase (EU) | Manual release workflow |
+| **DEV** | Lovable | Current Supabase | Development & testing |
+| **PROD** | Docker (Hetzner) | New Supabase (EU) | Production |
+| **Local** | Docker | DEV or PROD Supabase | Local testing |
+| **On-Premise** | Docker | Customer Supabase | Customer deployments |
 
 ## Workflows
 
 | Workflow | Trigger | Purpose |
 |----------|---------|---------|
-| `ci.yml` | PRs to dev/main | Lint, type-check, build, test |
-| `deploy-dev.yml` | Push to `dev` | Auto-deploy frontend to Netlify |
+| `ci.yml` | PRs | Lint, type-check, build, test |
 | `deploy-prod.yml` | Push to `main` | Auto-build Docker image to GHCR |
 | `release.yml` | **Manual** | Full controlled release with migrations |
 
@@ -56,36 +55,17 @@ Feature Branches → dev branch → main branch
 2. Set `run_migrations: true`
 3. Set `deploy_functions: true`
 4. Click **Run workflow**
-5. **Approve** the migration step when prompted (GitHub Environment protection)
-
-### Release Steps
-```
-1. Run Tests         → Lint, type-check, build, unit tests
-2. Run Migrations    → (if enabled) supabase db push to PROD
-3. Deploy Functions  → (if enabled) Deploy Edge Functions to PROD
-4. Build Image       → Build Docker with PROD config → push to GHCR
-5. Create Release    → Tag version, generate changelog
-```
+5. **Approve** the migration step (GitHub Environment protection)
 
 ---
 
 ## GitHub Secrets
 
-### Development
 | Secret | Value |
 |--------|-------|
-| `VITE_SUPABASE_URL_DEV` | Current Supabase URL |
-| `VITE_SUPABASE_ANON_KEY_DEV` | Current Supabase anon key |
-| `SUPABASE_PROJECT_REF_DEV` | `vatgianzotsurljznsry` |
-| `NETLIFY_SITE_ID_DEV` | Netlify dev site ID |
-| `NETLIFY_AUTH_TOKEN` | Netlify personal access token |
-
-### Production
-| Secret | Value |
-|--------|-------|
-| `VITE_SUPABASE_URL_PROD` | New Supabase URL (EU region) |
-| `VITE_SUPABASE_ANON_KEY_PROD` | New Supabase anon key |
-| `SUPABASE_PROJECT_REF_PROD` | New Supabase project ref |
+| `VITE_SUPABASE_URL_PROD` | Supabase URL (EU region) |
+| `VITE_SUPABASE_ANON_KEY_PROD` | Supabase anon key |
+| `SUPABASE_PROJECT_REF_PROD` | Supabase project ref |
 | `SUPABASE_ACCESS_TOKEN` | Supabase CLI token |
 
 ---
@@ -97,17 +77,11 @@ Feature Branches → dev branch → main branch
 2. Create new project → Select **EU region** (Frankfurt)
 3. Note: project URL, anon key, project ref
 
-### 2. Create Netlify Dev Site
-1. Go to [netlify.com](https://netlify.com)
-2. Create site for dev environment
-3. Get site ID and personal access token
-
-### 3. Configure GitHub
+### 2. Configure GitHub
 1. Add secrets: Settings → Secrets → Actions
 2. Create Environment "production" with required reviewers
-3. Create `dev` branch from `main`
 
-### 4. Initial Production Migration
+### 3. Initial Production Migration
 ```bash
 supabase link --project-ref YOUR_PROD_PROJECT_REF
 supabase db push
@@ -117,35 +91,117 @@ supabase db push
 
 ## Docker Image
 
-### Available at GHCR
+### Pull from GHCR
 ```bash
 # Latest
 docker pull ghcr.io/sheetmetalconnect/eryxon-flow:latest
 
 # Specific version
 docker pull ghcr.io/sheetmetalconnect/eryxon-flow:1.0.0
+```
 
-# By commit SHA
-docker pull ghcr.io/sheetmetalconnect/eryxon-flow:abc1234
+### Run Locally (for testing)
+```bash
+docker run -p 8080:80 ghcr.io/sheetmetalconnect/eryxon-flow:latest
+# Open http://localhost:8080
 ```
 
-### Run Anywhere
+### Build Locally (custom Supabase)
 ```bash
-docker run -d -p 80:80 ghcr.io/sheetmetalconnect/eryxon-flow:latest
+docker build -t eryxon-flow \
+  --build-arg VITE_SUPABASE_URL=https://your-project.supabase.co \
+  --build-arg VITE_SUPABASE_PUBLISHABLE_KEY=your-anon-key .
+
+docker run -p 8080:80 eryxon-flow
 ```
 
 ---
 
-## Future: Hetzner Deployment
+## Hetzner Production Deployment
 
-When ready, add deploy step to `release.yml`:
+### 1. Create Server
+1. [Hetzner Cloud Console](https://console.hetzner.cloud)
+2. Create server: Ubuntu 24.04, CX22 (~€4/mo), EU region
+3. Add SSH key
+
+### 2. Server Setup
+```bash
+ssh root@YOUR_SERVER_IP
+
+# Install Docker
+curl -fsSL https://get.docker.com | sh
+
+# Create app directory
+mkdir -p /opt/eryxon-flow
+cd /opt/eryxon-flow
+
+# Login to GHCR
+docker login ghcr.io -u YOUR_GITHUB_USERNAME
+
+# Create docker-compose.yml
+cat > docker-compose.yml << 'EOF'
+services:
+  app:
+    image: ghcr.io/sheetmetalconnect/eryxon-flow:latest
+    container_name: eryxon-flow
+    restart: unless-stopped
+    expose:
+      - "80"
+
+  caddy:
+    image: caddy:alpine
+    container_name: caddy
+    restart: unless-stopped
+    ports:
+      - "80:80"
+      - "443:443"
+    volumes:
+      - ./Caddyfile:/etc/caddy/Caddyfile:ro
+      - caddy_data:/data
+
+volumes:
+  caddy_data:
+EOF
+
+# Create Caddyfile
+cat > Caddyfile << 'EOF'
+app.yourdomain.com {
+    reverse_proxy app:80
+}
+EOF
+
+# Start
+docker compose up -d
+```
 
-1. Create Hetzner server (CX22, ~€4/mo, EU)
-2. Install Docker on server
-3. Add secrets: `HETZNER_HOST`, `HETZNER_USERNAME`, `HETZNER_SSH_KEY`
-4. Use prepared files:
-   - `docker-compose.prod.yml` - With Caddy SSL
-   - `Caddyfile` - Reverse proxy
+### 3. DNS
+Point `app.yourdomain.com` → Server IP. Caddy handles SSL automatically.
+
+### 4. Update Production
+```bash
+cd /opt/eryxon-flow
+docker compose pull
+docker compose up -d --remove-orphans
+```
+
+---
+
+## Customer On-Premise Deployment
+
+Same Docker image, customer provides their own Supabase:
+
+```bash
+# Build with customer's Supabase
+docker build -t eryxon-flow-customer \
+  --build-arg VITE_SUPABASE_URL=https://customer-project.supabase.co \
+  --build-arg VITE_SUPABASE_PUBLISHABLE_KEY=customer-anon-key .
+
+# Or use docker-compose with env vars
+cat > .env << EOF
+SUPABASE_URL=https://customer-project.supabase.co
+SUPABASE_ANON_KEY=customer-anon-key
+EOF
+```
 
 ---
 
@@ -154,30 +210,27 @@ When ready, add deploy step to `release.yml`:
 ```
 .github/workflows/
   ci.yml              # PR checks
-  deploy-dev.yml      # Dev → Netlify (auto)
   deploy-prod.yml     # Main → Docker image (auto)
   release.yml         # Manual release with migrations
 Dockerfile            # Multi-stage build
 nginx.conf            # SPA routing
 docker-compose.yml    # Simple deployment
 docker-compose.prod.yml # With Caddy SSL
 Caddyfile             # Caddy config
-netlify.toml          # Netlify config
 ```
 
 ---
 
 ## Developer Workflow
 
 ```bash
-# Daily development
-git checkout dev && git pull
-git checkout -b feature/my-feature
-# ... work ...
-git push -u origin feature/my-feature
-# Create PR → CI runs → Merge → Auto-deploys to Netlify DEV
-
-# Ready for production
-# Create PR: dev → main → Merge → Auto-builds Docker image
-# Then: Actions → Release → Run workflow (choose options)
+# Development (use Lovable)
+# Push to GitHub → Lovable auto-syncs
+
+# Ready for production release
+# Actions → Release → Run workflow
+# Docker image built and pushed to GHCR
+
+# Deploy to Hetzner
+ssh root@server "cd /opt/eryxon-flow && docker compose pull && docker compose up -d"
 ```