Connector Issues75 open

## How to reproduce

1. Start the backend:
   ```
   docker compose up backend postgres redis -d
   ```

2. Open a Python shell:
   ```
   docker compose exec backend python
   ```

3. Run the connector directly:
   ```python
   from app.core.database import SessionLocal
   from app.services.connectors import search_discovery
   from app.models.models import IngestionJob
   import uuid
   db = SessionLocal()
   job = IngestionJob(id=str(uuid.uuid4()), connector_name='debug', status='running')
   db.add(job); db.commit()
   result = search_discovery.run_connector(
       db=db, job=job,
       category_slug='wedding-venue',
       city='Bern',
       country='CH',
       state=None,
       max_pages=1,
   )
   print(result)
   ```

4. Or fetch the raw page directly:
   ```python
   import httpx
   headers = {'User-Agent': 'Mozilla/5.0 (compatible; WedAPI-Crawler/1.0)'}
   r = httpx.get('https://html.duckduckgo.com/html/?q=hochzeitslocation+Bern&kl=de-de', headers=headers, follow_redirects=True, timeout=15)
   print(r.status_code, len(r.text))
   # Inspect r.text to check if site structure changed
   ```

## What to check
- Zero reason recorded: no_vendor_objects_extracted: fetched 1 pages, parser found 0 objects
- Compare the current HTML/JSON structure against the connector's selectors
- Check the snapshot attached to this issue (if available) for the actual response
- Update the connector's CSS selectors, URL patterns, or JSON paths accordingly
- Re-run the scope to verify: `make crawl` or use the Admin → Crawl Runs → Run now button

## How to reproduce

1. Start the backend:
   ```
   docker compose up backend postgres redis -d
   ```

2. Open a Python shell:
   ```
   docker compose exec backend python
   ```

3. Run the connector directly:
   ```python
   from app.core.database import SessionLocal
   from app.services.connectors import weddyplace
   from app.models.models import IngestionJob
   import uuid
   db = SessionLocal()
   job = IngestionJob(id=str(uuid.uuid4()), connector_name='debug', status='running')
   db.add(job); db.commit()
   result = weddyplace.run_connector(
       db=db, job=job,
       category_slug='wedding-venue',
       city='Bern',
       country='CH',
       state=None,
       max_pages=1,
   )
   print(result)
   ```

4. Or fetch the raw page directly:
   ```python
   import httpx
   headers = {'User-Agent': 'Mozilla/5.0 (compatible; WedAPI-Crawler/1.0)'}
   r = httpx.get('https://html.duckduckgo.com/html/?q=site%3Aweddyplace.com%2Fde+hochzeitslocation+Bern&kl=de-de', headers=headers, follow_redirects=True, timeout=15)
   print(r.status_code, len(r.text))
   # Inspect r.text to check if site structure changed
   ```

## What to check
- Zero reason recorded: no_vendor_objects_extracted: fetched 1 pages, parser found 0 objects
- Compare the current HTML/JSON structure against the connector's selectors
- Check the snapshot attached to this issue (if available) for the actual response
- Update the connector's CSS selectors, URL patterns, or JSON paths accordingly
- Re-run the scope to verify: `make crawl` or use the Admin → Crawl Runs → Run now button

## How to reproduce

1. Start the backend:
   ```
   docker compose up backend postgres redis -d
   ```

2. Open a Python shell:
   ```
   docker compose exec backend python
   ```

3. Run the connector directly:
   ```python
   from app.core.database import SessionLocal
   from app.services.connectors import search_discovery
   from app.models.models import IngestionJob
   import uuid
   db = SessionLocal()
   job = IngestionJob(id=str(uuid.uuid4()), connector_name='debug', status='running')
   db.add(job); db.commit()
   result = search_discovery.run_connector(
       db=db, job=job,
       category_slug='wedding-venue',
       city='Zurich',
       country='CH',
       state=None,
       max_pages=1,
   )
   print(result)
   ```

4. Or fetch the raw page directly:
   ```python
   import httpx
   headers = {'User-Agent': 'Mozilla/5.0 (compatible; WedAPI-Crawler/1.0)'}
   r = httpx.get('https://html.duckduckgo.com/html/?q=hochzeitslocation+Zurich&kl=de-de', headers=headers, follow_redirects=True, timeout=15)
   print(r.status_code, len(r.text))
   # Inspect r.text to check if site structure changed
   ```

## What to check
- Zero reason recorded: no_vendor_objects_extracted: fetched 1 pages, parser found 0 objects
- Compare the current HTML/JSON structure against the connector's selectors
- Check the snapshot attached to this issue (if available) for the actual response
- Update the connector's CSS selectors, URL patterns, or JSON paths accordingly
- Re-run the scope to verify: `make crawl` or use the Admin → Crawl Runs → Run now button

## How to reproduce

1. Start the backend:
   ```
   docker compose up backend postgres redis -d
   ```

2. Open a Python shell:
   ```
   docker compose exec backend python
   ```

3. Run the connector directly:
   ```python
   from app.core.database import SessionLocal
   from app.services.connectors import weddyplace
   from app.models.models import IngestionJob
   import uuid
   db = SessionLocal()
   job = IngestionJob(id=str(uuid.uuid4()), connector_name='debug', status='running')
   db.add(job); db.commit()
   result = weddyplace.run_connector(
       db=db, job=job,
       category_slug='wedding-venue',
       city='Zurich',
       country='CH',
       state=None,
       max_pages=1,
   )
   print(result)
   ```

4. Or fetch the raw page directly:
   ```python
   import httpx
   headers = {'User-Agent': 'Mozilla/5.0 (compatible; WedAPI-Crawler/1.0)'}
   r = httpx.get('https://html.duckduckgo.com/html/?q=site%3Aweddyplace.com%2Fde+hochzeitslocation+Zurich&kl=de-de', headers=headers, follow_redirects=True, timeout=15)
   print(r.status_code, len(r.text))
   # Inspect r.text to check if site structure changed
   ```

## What to check
- Zero reason recorded: no_vendor_objects_extracted: fetched 1 pages, parser found 0 objects
- Compare the current HTML/JSON structure against the connector's selectors
- Check the snapshot attached to this issue (if available) for the actual response
- Update the connector's CSS selectors, URL patterns, or JSON paths accordingly
- Re-run the scope to verify: `make crawl` or use the Admin → Crawl Runs → Run now button

## How to reproduce

1. Start the backend:
   ```
   docker compose up backend postgres redis -d
   ```

2. Open a Python shell:
   ```
   docker compose exec backend python
   ```

3. Run the connector directly:
   ```python
   from app.core.database import SessionLocal
   from app.services.connectors import search_discovery
   from app.models.models import IngestionJob
   import uuid
   db = SessionLocal()
   job = IngestionJob(id=str(uuid.uuid4()), connector_name='debug', status='running')
   db.add(job); db.commit()
   result = search_discovery.run_connector(
       db=db, job=job,
       category_slug='wedding-photographer',
       city='Zurich',
       country='CH',
       state=None,
       max_pages=1,
   )
   print(result)
   ```

4. Or fetch the raw page directly:
   ```python
   import httpx
   headers = {'User-Agent': 'Mozilla/5.0 (compatible; WedAPI-Crawler/1.0)'}
   r = httpx.get('https://html.duckduckgo.com/html/?q=hochzeitsfotograf+Zurich&kl=de-de', headers=headers, follow_redirects=True, timeout=15)
   print(r.status_code, len(r.text))
   # Inspect r.text to check if site structure changed
   ```

## What to check
- Zero reason recorded: no_vendor_objects_extracted: fetched 1 pages, parser found 0 objects
- Compare the current HTML/JSON structure against the connector's selectors
- Check the snapshot attached to this issue (if available) for the actual response
- Update the connector's CSS selectors, URL patterns, or JSON paths accordingly
- Re-run the scope to verify: `make crawl` or use the Admin → Crawl Runs → Run now button

## How to reproduce

1. Start the backend:
   ```
   docker compose up backend postgres redis -d
   ```

2. Open a Python shell:
   ```
   docker compose exec backend python
   ```

3. Run the connector directly:
   ```python
   from app.core.database import SessionLocal
   from app.services.connectors import weddyplace
   from app.models.models import IngestionJob
   import uuid
   db = SessionLocal()
   job = IngestionJob(id=str(uuid.uuid4()), connector_name='debug', status='running')
   db.add(job); db.commit()
   result = weddyplace.run_connector(
       db=db, job=job,
       category_slug='wedding-photographer',
       city='Zurich',
       country='CH',
       state=None,
       max_pages=1,
   )
   print(result)
   ```

4. Or fetch the raw page directly:
   ```python
   import httpx
   headers = {'User-Agent': 'Mozilla/5.0 (compatible; WedAPI-Crawler/1.0)'}
   r = httpx.get('https://html.duckduckgo.com/html/?q=site%3Aweddyplace.com%2Fde+hochzeitsfotograf+Zurich&kl=de-de', headers=headers, follow_redirects=True, timeout=15)
   print(r.status_code, len(r.text))
   # Inspect r.text to check if site structure changed
   ```

## What to check
- Zero reason recorded: no_vendor_objects_extracted: fetched 1 pages, parser found 0 objects
- Compare the current HTML/JSON structure against the connector's selectors
- Check the snapshot attached to this issue (if available) for the actual response
- Update the connector's CSS selectors, URL patterns, or JSON paths accordingly
- Re-run the scope to verify: `make crawl` or use the Admin → Crawl Runs → Run now button

## How to reproduce

1. Start the backend:
   ```
   docker compose up backend postgres redis -d
   ```

2. Open a Python shell:
   ```
   docker compose exec backend python
   ```

3. Run the connector directly:
   ```python
   from app.core.database import SessionLocal
   from app.services.connectors import search_discovery
   from app.models.models import IngestionJob
   import uuid
   db = SessionLocal()
   job = IngestionJob(id=str(uuid.uuid4()), connector_name='debug', status='running')
   db.add(job); db.commit()
   result = search_discovery.run_connector(
       db=db, job=job,
       category_slug='wedding-dj',
       city='Vienna',
       country='AT',
       state=None,
       max_pages=1,
   )
   print(result)
   ```

4. Or fetch the raw page directly:
   ```python
   import httpx
   headers = {'User-Agent': 'Mozilla/5.0 (compatible; WedAPI-Crawler/1.0)'}
   r = httpx.get('https://html.duckduckgo.com/html/?q=hochzeits+dj+Vienna&kl=de-de', headers=headers, follow_redirects=True, timeout=15)
   print(r.status_code, len(r.text))
   # Inspect r.text to check if site structure changed
   ```

## What to check
- Zero reason recorded: no_vendor_objects_extracted: fetched 1 pages, parser found 0 objects
- Compare the current HTML/JSON structure against the connector's selectors
- Check the snapshot attached to this issue (if available) for the actual response
- Update the connector's CSS selectors, URL patterns, or JSON paths accordingly
- Re-run the scope to verify: `make crawl` or use the Admin → Crawl Runs → Run now button

## How to reproduce

1. Start the backend:
   ```
   docker compose up backend postgres redis -d
   ```

2. Open a Python shell:
   ```
   docker compose exec backend python
   ```

3. Run the connector directly:
   ```python
   from app.core.database import SessionLocal
   from app.services.connectors import eventpeppers
   from app.models.models import IngestionJob
   import uuid
   db = SessionLocal()
   job = IngestionJob(id=str(uuid.uuid4()), connector_name='debug', status='running')
   db.add(job); db.commit()
   result = eventpeppers.run_connector(
       db=db, job=job,
       category_slug='wedding-dj',
       city='Vienna',
       country='AT',
       state=None,
       max_pages=1,
   )
   print(result)
   ```

4. Or fetch the raw page directly:
   ```python
   import httpx
   headers = {'User-Agent': 'Mozilla/5.0 (compatible; WedAPI-Crawler/1.0)'}
   r = httpx.get('https://html.duckduckgo.com/html/?q=site%3Aeventpeppers.com%2Fde+hochzeits+dj+Vienna&kl=de-de', headers=headers, follow_redirects=True, timeout=15)
   print(r.status_code, len(r.text))
   # Inspect r.text to check if site structure changed
   ```

## What to check
- Zero reason recorded: no_vendor_objects_extracted: fetched 1 pages, parser found 0 objects
- Compare the current HTML/JSON structure against the connector's selectors
- Check the snapshot attached to this issue (if available) for the actual response
- Update the connector's CSS selectors, URL patterns, or JSON paths accordingly
- Re-run the scope to verify: `make crawl` or use the Admin → Crawl Runs → Run now button

## How to reproduce

1. Start the backend:
   ```
   docker compose up backend postgres redis -d
   ```

2. Open a Python shell:
   ```
   docker compose exec backend python
   ```

3. Run the connector directly:
   ```python
   from app.core.database import SessionLocal
   from app.services.connectors import weddyplace
   from app.models.models import IngestionJob
   import uuid
   db = SessionLocal()
   job = IngestionJob(id=str(uuid.uuid4()), connector_name='debug', status='running')
   db.add(job); db.commit()
   result = weddyplace.run_connector(
       db=db, job=job,
       category_slug='wedding-dj',
       city='Vienna',
       country='AT',
       state=None,
       max_pages=1,
   )
   print(result)
   ```

4. Or fetch the raw page directly:
   ```python
   import httpx
   headers = {'User-Agent': 'Mozilla/5.0 (compatible; WedAPI-Crawler/1.0)'}
   r = httpx.get('https://html.duckduckgo.com/html/?q=site%3Aweddyplace.com%2Fde+hochzeits+dj+Vienna&kl=de-de', headers=headers, follow_redirects=True, timeout=15)
   print(r.status_code, len(r.text))
   # Inspect r.text to check if site structure changed
   ```

## What to check
- Zero reason recorded: no_vendor_objects_extracted: fetched 1 pages, parser found 0 objects
- Compare the current HTML/JSON structure against the connector's selectors
- Check the snapshot attached to this issue (if available) for the actual response
- Update the connector's CSS selectors, URL patterns, or JSON paths accordingly
- Re-run the scope to verify: `make crawl` or use the Admin → Crawl Runs → Run now button

## How to reproduce

1. Start the backend:
   ```
   docker compose up backend postgres redis -d
   ```

2. Open a Python shell:
   ```
   docker compose exec backend python
   ```

3. Run the connector directly:
   ```python
   from app.core.database import SessionLocal
   from app.services.connectors import search_discovery
   from app.models.models import IngestionJob
   import uuid
   db = SessionLocal()
   job = IngestionJob(id=str(uuid.uuid4()), connector_name='debug', status='running')
   db.add(job); db.commit()
   result = search_discovery.run_connector(
       db=db, job=job,
       category_slug='wedding-venue',
       city='Salzburg',
       country='AT',
       state=None,
       max_pages=1,
   )
   print(result)
   ```

4. Or fetch the raw page directly:
   ```python
   import httpx
   headers = {'User-Agent': 'Mozilla/5.0 (compatible; WedAPI-Crawler/1.0)'}
   r = httpx.get('https://html.duckduckgo.com/html/?q=hochzeitslocation+Salzburg&kl=de-de', headers=headers, follow_redirects=True, timeout=15)
   print(r.status_code, len(r.text))
   # Inspect r.text to check if site structure changed
   ```

## What to check
- Zero reason recorded: no_vendor_objects_extracted: fetched 1 pages, parser found 0 objects
- Compare the current HTML/JSON structure against the connector's selectors
- Check the snapshot attached to this issue (if available) for the actual response
- Update the connector's CSS selectors, URL patterns, or JSON paths accordingly
- Re-run the scope to verify: `make crawl` or use the Admin → Crawl Runs → Run now button

## How to reproduce

1. Start the backend:
   ```
   docker compose up backend postgres redis -d
   ```

2. Open a Python shell:
   ```
   docker compose exec backend python
   ```

3. Run the connector directly:
   ```python
   from app.core.database import SessionLocal
   from app.services.connectors import weddyplace
   from app.models.models import IngestionJob
   import uuid
   db = SessionLocal()
   job = IngestionJob(id=str(uuid.uuid4()), connector_name='debug', status='running')
   db.add(job); db.commit()
   result = weddyplace.run_connector(
       db=db, job=job,
       category_slug='wedding-venue',
       city='Salzburg',
       country='AT',
       state=None,
       max_pages=1,
   )
   print(result)
   ```

4. Or fetch the raw page directly:
   ```python
   import httpx
   headers = {'User-Agent': 'Mozilla/5.0 (compatible; WedAPI-Crawler/1.0)'}
   r = httpx.get('https://html.duckduckgo.com/html/?q=site%3Aweddyplace.com%2Fde+hochzeitslocation+Salzburg&kl=de-de', headers=headers, follow_redirects=True, timeout=15)
   print(r.status_code, len(r.text))
   # Inspect r.text to check if site structure changed
   ```

## What to check
- Zero reason recorded: no_vendor_objects_extracted: fetched 1 pages, parser found 0 objects
- Compare the current HTML/JSON structure against the connector's selectors
- Check the snapshot attached to this issue (if available) for the actual response
- Update the connector's CSS selectors, URL patterns, or JSON paths accordingly
- Re-run the scope to verify: `make crawl` or use the Admin → Crawl Runs → Run now button

## How to reproduce

1. Start the backend:
   ```
   docker compose up backend postgres redis -d
   ```

2. Open a Python shell:
   ```
   docker compose exec backend python
   ```

3. Run the connector directly:
   ```python
   from app.core.database import SessionLocal
   from app.services.connectors import search_discovery
   from app.models.models import IngestionJob
   import uuid
   db = SessionLocal()
   job = IngestionJob(id=str(uuid.uuid4()), connector_name='debug', status='running')
   db.add(job); db.commit()
   result = search_discovery.run_connector(
       db=db, job=job,
       category_slug='wedding-photographer',
       city='Graz',
       country='AT',
       state=None,
       max_pages=1,
   )
   print(result)
   ```

4. Or fetch the raw page directly:
   ```python
   import httpx
   headers = {'User-Agent': 'Mozilla/5.0 (compatible; WedAPI-Crawler/1.0)'}
   r = httpx.get('https://html.duckduckgo.com/html/?q=hochzeitsfotograf+Graz&kl=de-de', headers=headers, follow_redirects=True, timeout=15)
   print(r.status_code, len(r.text))
   # Inspect r.text to check if site structure changed
   ```

## What to check
- Zero reason recorded: no_vendor_objects_extracted: fetched 1 pages, parser found 0 objects
- Compare the current HTML/JSON structure against the connector's selectors
- Check the snapshot attached to this issue (if available) for the actual response
- Update the connector's CSS selectors, URL patterns, or JSON paths accordingly
- Re-run the scope to verify: `make crawl` or use the Admin → Crawl Runs → Run now button

## How to reproduce

1. Start the backend:
   ```
   docker compose up backend postgres redis -d
   ```

2. Open a Python shell:
   ```
   docker compose exec backend python
   ```

3. Run the connector directly:
   ```python
   from app.core.database import SessionLocal
   from app.services.connectors import weddyplace
   from app.models.models import IngestionJob
   import uuid
   db = SessionLocal()
   job = IngestionJob(id=str(uuid.uuid4()), connector_name='debug', status='running')
   db.add(job); db.commit()
   result = weddyplace.run_connector(
       db=db, job=job,
       category_slug='wedding-photographer',
       city='Graz',
       country='AT',
       state=None,
       max_pages=1,
   )
   print(result)
   ```

4. Or fetch the raw page directly:
   ```python
   import httpx
   headers = {'User-Agent': 'Mozilla/5.0 (compatible; WedAPI-Crawler/1.0)'}
   r = httpx.get('https://html.duckduckgo.com/html/?q=site%3Aweddyplace.com%2Fde+hochzeitsfotograf+Graz&kl=de-de', headers=headers, follow_redirects=True, timeout=15)
   print(r.status_code, len(r.text))
   # Inspect r.text to check if site structure changed
   ```

## What to check
- Zero reason recorded: no_vendor_objects_extracted: fetched 1 pages, parser found 0 objects
- Compare the current HTML/JSON structure against the connector's selectors
- Check the snapshot attached to this issue (if available) for the actual response
- Update the connector's CSS selectors, URL patterns, or JSON paths accordingly
- Re-run the scope to verify: `make crawl` or use the Admin → Crawl Runs → Run now button

## How to reproduce

1. Start the backend:
   ```
   docker compose up backend postgres redis -d
   ```

2. Open a Python shell:
   ```
   docker compose exec backend python
   ```

3. Run the connector directly:
   ```python
   from app.core.database import SessionLocal
   from app.services.connectors import search_discovery
   from app.models.models import IngestionJob
   import uuid
   db = SessionLocal()
   job = IngestionJob(id=str(uuid.uuid4()), connector_name='debug', status='running')
   db.add(job); db.commit()
   result = search_discovery.run_connector(
       db=db, job=job,
       category_slug='wedding-dj',
       city='Frankfurt',
       country='DE',
       state=None,
       max_pages=1,
   )
   print(result)
   ```

4. Or fetch the raw page directly:
   ```python
   import httpx
   headers = {'User-Agent': 'Mozilla/5.0 (compatible; WedAPI-Crawler/1.0)'}
   r = httpx.get('https://html.duckduckgo.com/html/?q=hochzeits+dj+Frankfurt&kl=de-de', headers=headers, follow_redirects=True, timeout=15)
   print(r.status_code, len(r.text))
   # Inspect r.text to check if site structure changed
   ```

## What to check
- Zero reason recorded: no_vendor_objects_extracted: fetched 1 pages, parser found 0 objects
- Compare the current HTML/JSON structure against the connector's selectors
- Check the snapshot attached to this issue (if available) for the actual response
- Update the connector's CSS selectors, URL patterns, or JSON paths accordingly
- Re-run the scope to verify: `make crawl` or use the Admin → Crawl Runs → Run now button

## How to reproduce

1. Start the backend:
   ```
   docker compose up backend postgres redis -d
   ```

2. Open a Python shell:
   ```
   docker compose exec backend python
   ```

3. Run the connector directly:
   ```python
   from app.core.database import SessionLocal
   from app.services.connectors import eventpeppers
   from app.models.models import IngestionJob
   import uuid
   db = SessionLocal()
   job = IngestionJob(id=str(uuid.uuid4()), connector_name='debug', status='running')
   db.add(job); db.commit()
   result = eventpeppers.run_connector(
       db=db, job=job,
       category_slug='wedding-dj',
       city='Frankfurt',
       country='DE',
       state=None,
       max_pages=1,
   )
   print(result)
   ```

4. Or fetch the raw page directly:
   ```python
   import httpx
   headers = {'User-Agent': 'Mozilla/5.0 (compatible; WedAPI-Crawler/1.0)'}
   r = httpx.get('https://html.duckduckgo.com/html/?q=site%3Aeventpeppers.com%2Fde+hochzeits+dj+Frankfurt&kl=de-de', headers=headers, follow_redirects=True, timeout=15)
   print(r.status_code, len(r.text))
   # Inspect r.text to check if site structure changed
   ```

## What to check
- Zero reason recorded: no_vendor_objects_extracted: fetched 1 pages, parser found 0 objects
- Compare the current HTML/JSON structure against the connector's selectors
- Check the snapshot attached to this issue (if available) for the actual response
- Update the connector's CSS selectors, URL patterns, or JSON paths accordingly
- Re-run the scope to verify: `make crawl` or use the Admin → Crawl Runs → Run now button

## How to reproduce

1. Start the backend:
   ```
   docker compose up backend postgres redis -d
   ```

2. Open a Python shell:
   ```
   docker compose exec backend python
   ```

3. Run the connector directly:
   ```python
   from app.core.database import SessionLocal
   from app.services.connectors import weddyplace
   from app.models.models import IngestionJob
   import uuid
   db = SessionLocal()
   job = IngestionJob(id=str(uuid.uuid4()), connector_name='debug', status='running')
   db.add(job); db.commit()
   result = weddyplace.run_connector(
       db=db, job=job,
       category_slug='wedding-dj',
       city='Frankfurt',
       country='DE',
       state=None,
       max_pages=1,
   )
   print(result)
   ```

4. Or fetch the raw page directly:
   ```python
   import httpx
   headers = {'User-Agent': 'Mozilla/5.0 (compatible; WedAPI-Crawler/1.0)'}
   r = httpx.get('https://html.duckduckgo.com/html/?q=site%3Aweddyplace.com%2Fde+hochzeits+dj+Frankfurt&kl=de-de', headers=headers, follow_redirects=True, timeout=15)
   print(r.status_code, len(r.text))
   # Inspect r.text to check if site structure changed
   ```

## What to check
- Zero reason recorded: no_vendor_objects_extracted: fetched 1 pages, parser found 0 objects
- Compare the current HTML/JSON structure against the connector's selectors
- Check the snapshot attached to this issue (if available) for the actual response
- Update the connector's CSS selectors, URL patterns, or JSON paths accordingly
- Re-run the scope to verify: `make crawl` or use the Admin → Crawl Runs → Run now button

## How to reproduce

1. Start the backend:
   ```
   docker compose up backend postgres redis -d
   ```

2. Open a Python shell:
   ```
   docker compose exec backend python
   ```

3. Run the connector directly:
   ```python
   from app.core.database import SessionLocal
   from app.services.connectors import search_discovery
   from app.models.models import IngestionJob
   import uuid
   db = SessionLocal()
   job = IngestionJob(id=str(uuid.uuid4()), connector_name='debug', status='running')
   db.add(job); db.commit()
   result = search_discovery.run_connector(
       db=db, job=job,
       category_slug='wedding-dj',
       city='Cologne',
       country='DE',
       state=None,
       max_pages=1,
   )
   print(result)
   ```

4. Or fetch the raw page directly:
   ```python
   import httpx
   headers = {'User-Agent': 'Mozilla/5.0 (compatible; WedAPI-Crawler/1.0)'}
   r = httpx.get('https://html.duckduckgo.com/html/?q=hochzeits+dj+Cologne&kl=de-de', headers=headers, follow_redirects=True, timeout=15)
   print(r.status_code, len(r.text))
   # Inspect r.text to check if site structure changed
   ```

## What to check
- Zero reason recorded: no_vendor_objects_extracted: fetched 1 pages, parser found 0 objects
- Compare the current HTML/JSON structure against the connector's selectors
- Check the snapshot attached to this issue (if available) for the actual response
- Update the connector's CSS selectors, URL patterns, or JSON paths accordingly
- Re-run the scope to verify: `make crawl` or use the Admin → Crawl Runs → Run now button

## How to reproduce

1. Start the backend:
   ```
   docker compose up backend postgres redis -d
   ```

2. Open a Python shell:
   ```
   docker compose exec backend python
   ```

3. Run the connector directly:
   ```python
   from app.core.database import SessionLocal
   from app.services.connectors import eventpeppers
   from app.models.models import IngestionJob
   import uuid
   db = SessionLocal()
   job = IngestionJob(id=str(uuid.uuid4()), connector_name='debug', status='running')
   db.add(job); db.commit()
   result = eventpeppers.run_connector(
       db=db, job=job,
       category_slug='wedding-dj',
       city='Cologne',
       country='DE',
       state=None,
       max_pages=1,
   )
   print(result)
   ```

4. Or fetch the raw page directly:
   ```python
   import httpx
   headers = {'User-Agent': 'Mozilla/5.0 (compatible; WedAPI-Crawler/1.0)'}
   r = httpx.get('https://html.duckduckgo.com/html/?q=site%3Aeventpeppers.com%2Fde+hochzeits+dj+Cologne&kl=de-de', headers=headers, follow_redirects=True, timeout=15)
   print(r.status_code, len(r.text))
   # Inspect r.text to check if site structure changed
   ```

## What to check
- Zero reason recorded: no_vendor_objects_extracted: fetched 1 pages, parser found 0 objects
- Compare the current HTML/JSON structure against the connector's selectors
- Check the snapshot attached to this issue (if available) for the actual response
- Update the connector's CSS selectors, URL patterns, or JSON paths accordingly
- Re-run the scope to verify: `make crawl` or use the Admin → Crawl Runs → Run now button

## How to reproduce

1. Start the backend:
   ```
   docker compose up backend postgres redis -d
   ```

2. Open a Python shell:
   ```
   docker compose exec backend python
   ```

3. Run the connector directly:
   ```python
   from app.core.database import SessionLocal
   from app.services.connectors import weddyplace
   from app.models.models import IngestionJob
   import uuid
   db = SessionLocal()
   job = IngestionJob(id=str(uuid.uuid4()), connector_name='debug', status='running')
   db.add(job); db.commit()
   result = weddyplace.run_connector(
       db=db, job=job,
       category_slug='wedding-dj',
       city='Cologne',
       country='DE',
       state=None,
       max_pages=1,
   )
   print(result)
   ```

4. Or fetch the raw page directly:
   ```python
   import httpx
   headers = {'User-Agent': 'Mozilla/5.0 (compatible; WedAPI-Crawler/1.0)'}
   r = httpx.get('https://html.duckduckgo.com/html/?q=site%3Aweddyplace.com%2Fde+hochzeits+dj+Cologne&kl=de-de', headers=headers, follow_redirects=True, timeout=15)
   print(r.status_code, len(r.text))
   # Inspect r.text to check if site structure changed
   ```

## What to check
- Zero reason recorded: no_vendor_objects_extracted: fetched 1 pages, parser found 0 objects
- Compare the current HTML/JSON structure against the connector's selectors
- Check the snapshot attached to this issue (if available) for the actual response
- Update the connector's CSS selectors, URL patterns, or JSON paths accordingly
- Re-run the scope to verify: `make crawl` or use the Admin → Crawl Runs → Run now button

## How to reproduce

1. Start the backend:
   ```
   docker compose up backend postgres redis -d
   ```

2. Open a Python shell:
   ```
   docker compose exec backend python
   ```

3. Run the connector directly:
   ```python
   from app.core.database import SessionLocal
   from app.services.connectors import search_discovery
   from app.models.models import IngestionJob
   import uuid
   db = SessionLocal()
   job = IngestionJob(id=str(uuid.uuid4()), connector_name='debug', status='running')
   db.add(job); db.commit()
   result = search_discovery.run_connector(
       db=db, job=job,
       category_slug='wedding-venue',
       city='Vienna',
       country='AT',
       state=None,
       max_pages=1,
   )
   print(result)
   ```

4. Or fetch the raw page directly:
   ```python
   import httpx
   headers = {'User-Agent': 'Mozilla/5.0 (compatible; WedAPI-Crawler/1.0)'}
   r = httpx.get('https://html.duckduckgo.com/html/?q=hochzeitslocation+Vienna&kl=de-de', headers=headers, follow_redirects=True, timeout=15)
   print(r.status_code, len(r.text))
   # Inspect r.text to check if site structure changed
   ```

## What to check
- Zero reason recorded: no_vendor_objects_extracted: fetched 1 pages, parser found 0 objects
- Compare the current HTML/JSON structure against the connector's selectors
- Check the snapshot attached to this issue (if available) for the actual response
- Update the connector's CSS selectors, URL patterns, or JSON paths accordingly
- Re-run the scope to verify: `make crawl` or use the Admin → Crawl Runs → Run now button

## How to reproduce

1. Start the backend:
   ```
   docker compose up backend postgres redis -d
   ```

2. Open a Python shell:
   ```
   docker compose exec backend python
   ```

3. Run the connector directly:
   ```python
   from app.core.database import SessionLocal
   from app.services.connectors import weddyplace
   from app.models.models import IngestionJob
   import uuid
   db = SessionLocal()
   job = IngestionJob(id=str(uuid.uuid4()), connector_name='debug', status='running')
   db.add(job); db.commit()
   result = weddyplace.run_connector(
       db=db, job=job,
       category_slug='wedding-venue',
       city='Vienna',
       country='AT',
       state=None,
       max_pages=1,
   )
   print(result)
   ```

4. Or fetch the raw page directly:
   ```python
   import httpx
   headers = {'User-Agent': 'Mozilla/5.0 (compatible; WedAPI-Crawler/1.0)'}
   r = httpx.get('https://html.duckduckgo.com/html/?q=site%3Aweddyplace.com%2Fde+hochzeitslocation+Vienna&kl=de-de', headers=headers, follow_redirects=True, timeout=15)
   print(r.status_code, len(r.text))
   # Inspect r.text to check if site structure changed
   ```

## What to check
- Zero reason recorded: no_vendor_objects_extracted: fetched 1 pages, parser found 0 objects
- Compare the current HTML/JSON structure against the connector's selectors
- Check the snapshot attached to this issue (if available) for the actual response
- Update the connector's CSS selectors, URL patterns, or JSON paths accordingly
- Re-run the scope to verify: `make crawl` or use the Admin → Crawl Runs → Run now button

## How to reproduce

1. Start the backend:
   ```
   docker compose up backend postgres redis -d
   ```

2. Open a Python shell:
   ```
   docker compose exec backend python
   ```

3. Run the connector directly:
   ```python
   from app.core.database import SessionLocal
   from app.services.connectors import search_discovery
   from app.models.models import IngestionJob
   import uuid
   db = SessionLocal()
   job = IngestionJob(id=str(uuid.uuid4()), connector_name='debug', status='running')
   db.add(job); db.commit()
   result = search_discovery.run_connector(
       db=db, job=job,
       category_slug='wedding-photographer',
       city='Vienna',
       country='AT',
       state=None,
       max_pages=1,
   )
   print(result)
   ```

4. Or fetch the raw page directly:
   ```python
   import httpx
   headers = {'User-Agent': 'Mozilla/5.0 (compatible; WedAPI-Crawler/1.0)'}
   r = httpx.get('https://html.duckduckgo.com/html/?q=hochzeitsfotograf+Vienna&kl=de-de', headers=headers, follow_redirects=True, timeout=15)
   print(r.status_code, len(r.text))
   # Inspect r.text to check if site structure changed
   ```

## What to check
- Zero reason recorded: no_vendor_objects_extracted: fetched 1 pages, parser found 0 objects
- Compare the current HTML/JSON structure against the connector's selectors
- Check the snapshot attached to this issue (if available) for the actual response
- Update the connector's CSS selectors, URL patterns, or JSON paths accordingly
- Re-run the scope to verify: `make crawl` or use the Admin → Crawl Runs → Run now button

## How to reproduce

1. Start the backend:
   ```
   docker compose up backend postgres redis -d
   ```

2. Open a Python shell:
   ```
   docker compose exec backend python
   ```

3. Run the connector directly:
   ```python
   from app.core.database import SessionLocal
   from app.services.connectors import weddyplace
   from app.models.models import IngestionJob
   import uuid
   db = SessionLocal()
   job = IngestionJob(id=str(uuid.uuid4()), connector_name='debug', status='running')
   db.add(job); db.commit()
   result = weddyplace.run_connector(
       db=db, job=job,
       category_slug='wedding-photographer',
       city='Vienna',
       country='AT',
       state=None,
       max_pages=1,
   )
   print(result)
   ```

4. Or fetch the raw page directly:
   ```python
   import httpx
   headers = {'User-Agent': 'Mozilla/5.0 (compatible; WedAPI-Crawler/1.0)'}
   r = httpx.get('https://html.duckduckgo.com/html/?q=site%3Aweddyplace.com%2Fde+hochzeitsfotograf+Vienna&kl=de-de', headers=headers, follow_redirects=True, timeout=15)
   print(r.status_code, len(r.text))
   # Inspect r.text to check if site structure changed
   ```

## What to check
- Zero reason recorded: no_vendor_objects_extracted: fetched 1 pages, parser found 0 objects
- Compare the current HTML/JSON structure against the connector's selectors
- Check the snapshot attached to this issue (if available) for the actual response
- Update the connector's CSS selectors, URL patterns, or JSON paths accordingly
- Re-run the scope to verify: `make crawl` or use the Admin → Crawl Runs → Run now button

## How to reproduce

1. Start the backend:
   ```
   docker compose up backend postgres redis -d
   ```

2. Open a Python shell:
   ```
   docker compose exec backend python
   ```

3. Run the connector directly:
   ```python
   from app.core.database import SessionLocal
   from app.services.connectors import search_discovery
   from app.models.models import IngestionJob
   import uuid
   db = SessionLocal()
   job = IngestionJob(id=str(uuid.uuid4()), connector_name='debug', status='running')
   db.add(job); db.commit()
   result = search_discovery.run_connector(
       db=db, job=job,
       category_slug='wedding-venue',
       city='Nuremberg',
       country='DE',
       state='Bavaria',
       max_pages=1,
   )
   print(result)
   ```

4. Or fetch the raw page directly:
   ```python
   import httpx
   headers = {'User-Agent': 'Mozilla/5.0 (compatible; WedAPI-Crawler/1.0)'}
   r = httpx.get('https://html.duckduckgo.com/html/?q=hochzeitslocation+Nuremberg&kl=de-de', headers=headers, follow_redirects=True, timeout=15)
   print(r.status_code, len(r.text))
   # Inspect r.text to check if site structure changed
   ```

## What to check
- Zero reason recorded: no_vendor_objects_extracted: fetched 1 pages, parser found 0 objects
- Compare the current HTML/JSON structure against the connector's selectors
- Check the snapshot attached to this issue (if available) for the actual response
- Update the connector's CSS selectors, URL patterns, or JSON paths accordingly
- Re-run the scope to verify: `make crawl` or use the Admin → Crawl Runs → Run now button

## How to reproduce

1. Start the backend:
   ```
   docker compose up backend postgres redis -d
   ```

2. Open a Python shell:
   ```
   docker compose exec backend python
   ```

3. Run the connector directly:
   ```python
   from app.core.database import SessionLocal
   from app.services.connectors import weddyplace
   from app.models.models import IngestionJob
   import uuid
   db = SessionLocal()
   job = IngestionJob(id=str(uuid.uuid4()), connector_name='debug', status='running')
   db.add(job); db.commit()
   result = weddyplace.run_connector(
       db=db, job=job,
       category_slug='wedding-venue',
       city='Nuremberg',
       country='DE',
       state='Bavaria',
       max_pages=1,
   )
   print(result)
   ```

4. Or fetch the raw page directly:
   ```python
   import httpx
   headers = {'User-Agent': 'Mozilla/5.0 (compatible; WedAPI-Crawler/1.0)'}
   r = httpx.get('https://html.duckduckgo.com/html/?q=site%3Aweddyplace.com%2Fde+hochzeitslocation+Nuremberg&kl=de-de', headers=headers, follow_redirects=True, timeout=15)
   print(r.status_code, len(r.text))
   # Inspect r.text to check if site structure changed
   ```

## What to check
- Zero reason recorded: no_vendor_objects_extracted: fetched 1 pages, parser found 0 objects
- Compare the current HTML/JSON structure against the connector's selectors
- Check the snapshot attached to this issue (if available) for the actual response
- Update the connector's CSS selectors, URL patterns, or JSON paths accordingly
- Re-run the scope to verify: `make crawl` or use the Admin → Crawl Runs → Run now button

## How to reproduce

1. Start the backend:
   ```
   docker compose up backend postgres redis -d
   ```

2. Open a Python shell:
   ```
   docker compose exec backend python
   ```

3. Run the connector directly:
   ```python
   from app.core.database import SessionLocal
   from app.services.connectors import bavariawedding
   from app.models.models import IngestionJob
   import uuid
   db = SessionLocal()
   job = IngestionJob(id=str(uuid.uuid4()), connector_name='debug', status='running')
   db.add(job); db.commit()
   result = bavariawedding.run_connector(
       db=db, job=job,
       category_slug='wedding-venue',
       city='Nuremberg',
       country='DE',
       state='Bavaria',
       max_pages=1,
   )
   print(result)
   ```

4. Or fetch the raw page directly:
   ```python
   import httpx
   headers = {'User-Agent': 'Mozilla/5.0 (compatible; WedAPI-Crawler/1.0)'}
   r = httpx.get('https://www.bavariawedding.de/hochzeitslocations/nuremberg/', headers=headers, follow_redirects=True, timeout=15)
   print(r.status_code, len(r.text))
   # Inspect r.text to check if site structure changed
   ```

## What to check
- Zero reason recorded: http_errors: 1/1 pages failed
- Compare the current HTML/JSON structure against the connector's selectors
- Check the snapshot attached to this issue (if available) for the actual response
- Update the connector's CSS selectors, URL patterns, or JSON paths accordingly
- Re-run the scope to verify: `make crawl` or use the Admin → Crawl Runs → Run now button

## How to reproduce

1. Start the backend:
   ```
   docker compose up backend postgres redis -d
   ```

2. Open a Python shell:
   ```
   docker compose exec backend python
   ```

3. Run the connector directly:
   ```python
   from app.core.database import SessionLocal
   from app.services.connectors import search_discovery
   from app.models.models import IngestionJob
   import uuid
   db = SessionLocal()
   job = IngestionJob(id=str(uuid.uuid4()), connector_name='debug', status='running')
   db.add(job); db.commit()
   result = search_discovery.run_connector(
       db=db, job=job,
       category_slug='wedding-venue',
       city='Stuttgart',
       country='DE',
       state=None,
       max_pages=1,
   )
   print(result)
   ```

4. Or fetch the raw page directly:
   ```python
   import httpx
   headers = {'User-Agent': 'Mozilla/5.0 (compatible; WedAPI-Crawler/1.0)'}
   r = httpx.get('https://html.duckduckgo.com/html/?q=hochzeitslocation+Stuttgart&kl=de-de', headers=headers, follow_redirects=True, timeout=15)
   print(r.status_code, len(r.text))
   # Inspect r.text to check if site structure changed
   ```

## What to check
- Zero reason recorded: no_vendor_objects_extracted: fetched 1 pages, parser found 0 objects
- Compare the current HTML/JSON structure against the connector's selectors
- Check the snapshot attached to this issue (if available) for the actual response
- Update the connector's CSS selectors, URL patterns, or JSON paths accordingly
- Re-run the scope to verify: `make crawl` or use the Admin → Crawl Runs → Run now button

## How to reproduce

1. Start the backend:
   ```
   docker compose up backend postgres redis -d
   ```

2. Open a Python shell:
   ```
   docker compose exec backend python
   ```

3. Run the connector directly:
   ```python
   from app.core.database import SessionLocal
   from app.services.connectors import weddyplace
   from app.models.models import IngestionJob
   import uuid
   db = SessionLocal()
   job = IngestionJob(id=str(uuid.uuid4()), connector_name='debug', status='running')
   db.add(job); db.commit()
   result = weddyplace.run_connector(
       db=db, job=job,
       category_slug='wedding-venue',
       city='Stuttgart',
       country='DE',
       state=None,
       max_pages=1,
   )
   print(result)
   ```

4. Or fetch the raw page directly:
   ```python
   import httpx
   headers = {'User-Agent': 'Mozilla/5.0 (compatible; WedAPI-Crawler/1.0)'}
   r = httpx.get('https://html.duckduckgo.com/html/?q=site%3Aweddyplace.com%2Fde+hochzeitslocation+Stuttgart&kl=de-de', headers=headers, follow_redirects=True, timeout=15)
   print(r.status_code, len(r.text))
   # Inspect r.text to check if site structure changed
   ```

## What to check
- Zero reason recorded: no_vendor_objects_extracted: fetched 1 pages, parser found 0 objects
- Compare the current HTML/JSON structure against the connector's selectors
- Check the snapshot attached to this issue (if available) for the actual response
- Update the connector's CSS selectors, URL patterns, or JSON paths accordingly
- Re-run the scope to verify: `make crawl` or use the Admin → Crawl Runs → Run now button

## How to reproduce

1. Start the backend:
   ```
   docker compose up backend postgres redis -d
   ```

2. Open a Python shell:
   ```
   docker compose exec backend python
   ```

3. Run the connector directly:
   ```python
   from app.core.database import SessionLocal
   from app.services.connectors import search_discovery
   from app.models.models import IngestionJob
   import uuid
   db = SessionLocal()
   job = IngestionJob(id=str(uuid.uuid4()), connector_name='debug', status='running')
   db.add(job); db.commit()
   result = search_discovery.run_connector(
       db=db, job=job,
       category_slug='wedding-venue',
       city='Frankfurt',
       country='DE',
       state=None,
       max_pages=1,
   )
   print(result)
   ```

4. Or fetch the raw page directly:
   ```python
   import httpx
   headers = {'User-Agent': 'Mozilla/5.0 (compatible; WedAPI-Crawler/1.0)'}
   r = httpx.get('https://html.duckduckgo.com/html/?q=hochzeitslocation+Frankfurt&kl=de-de', headers=headers, follow_redirects=True, timeout=15)
   print(r.status_code, len(r.text))
   # Inspect r.text to check if site structure changed
   ```

## What to check
- Zero reason recorded: no_vendor_objects_extracted: fetched 1 pages, parser found 0 objects
- Compare the current HTML/JSON structure against the connector's selectors
- Check the snapshot attached to this issue (if available) for the actual response
- Update the connector's CSS selectors, URL patterns, or JSON paths accordingly
- Re-run the scope to verify: `make crawl` or use the Admin → Crawl Runs → Run now button

## How to reproduce

1. Start the backend:
   ```
   docker compose up backend postgres redis -d
   ```

2. Open a Python shell:
   ```
   docker compose exec backend python
   ```

3. Run the connector directly:
   ```python
   from app.core.database import SessionLocal
   from app.services.connectors import weddyplace
   from app.models.models import IngestionJob
   import uuid
   db = SessionLocal()
   job = IngestionJob(id=str(uuid.uuid4()), connector_name='debug', status='running')
   db.add(job); db.commit()
   result = weddyplace.run_connector(
       db=db, job=job,
       category_slug='wedding-venue',
       city='Frankfurt',
       country='DE',
       state=None,
       max_pages=1,
   )
   print(result)
   ```

4. Or fetch the raw page directly:
   ```python
   import httpx
   headers = {'User-Agent': 'Mozilla/5.0 (compatible; WedAPI-Crawler/1.0)'}
   r = httpx.get('https://html.duckduckgo.com/html/?q=site%3Aweddyplace.com%2Fde+hochzeitslocation+Frankfurt&kl=de-de', headers=headers, follow_redirects=True, timeout=15)
   print(r.status_code, len(r.text))
   # Inspect r.text to check if site structure changed
   ```

## What to check
- Zero reason recorded: no_vendor_objects_extracted: fetched 1 pages, parser found 0 objects
- Compare the current HTML/JSON structure against the connector's selectors
- Check the snapshot attached to this issue (if available) for the actual response
- Update the connector's CSS selectors, URL patterns, or JSON paths accordingly
- Re-run the scope to verify: `make crawl` or use the Admin → Crawl Runs → Run now button

## How to reproduce

1. Start the backend:
   ```
   docker compose up backend postgres redis -d
   ```

2. Open a Python shell:
   ```
   docker compose exec backend python
   ```

3. Run the connector directly:
   ```python
   from app.core.database import SessionLocal
   from app.services.connectors import search_discovery
   from app.models.models import IngestionJob
   import uuid
   db = SessionLocal()
   job = IngestionJob(id=str(uuid.uuid4()), connector_name='debug', status='running')
   db.add(job); db.commit()
   result = search_discovery.run_connector(
       db=db, job=job,
       category_slug='wedding-venue',
       city='Cologne',
       country='DE',
       state=None,
       max_pages=1,
   )
   print(result)
   ```

4. Or fetch the raw page directly:
   ```python
   import httpx
   headers = {'User-Agent': 'Mozilla/5.0 (compatible; WedAPI-Crawler/1.0)'}
   r = httpx.get('https://html.duckduckgo.com/html/?q=hochzeitslocation+Cologne&kl=de-de', headers=headers, follow_redirects=True, timeout=15)
   print(r.status_code, len(r.text))
   # Inspect r.text to check if site structure changed
   ```

## What to check
- Zero reason recorded: no_vendor_objects_extracted: fetched 1 pages, parser found 0 objects
- Compare the current HTML/JSON structure against the connector's selectors
- Check the snapshot attached to this issue (if available) for the actual response
- Update the connector's CSS selectors, URL patterns, or JSON paths accordingly
- Re-run the scope to verify: `make crawl` or use the Admin → Crawl Runs → Run now button

## How to reproduce

1. Start the backend:
   ```
   docker compose up backend postgres redis -d
   ```

2. Open a Python shell:
   ```
   docker compose exec backend python
   ```

3. Run the connector directly:
   ```python
   from app.core.database import SessionLocal
   from app.services.connectors import weddyplace
   from app.models.models import IngestionJob
   import uuid
   db = SessionLocal()
   job = IngestionJob(id=str(uuid.uuid4()), connector_name='debug', status='running')
   db.add(job); db.commit()
   result = weddyplace.run_connector(
       db=db, job=job,
       category_slug='wedding-venue',
       city='Cologne',
       country='DE',
       state=None,
       max_pages=1,
   )
   print(result)
   ```

4. Or fetch the raw page directly:
   ```python
   import httpx
   headers = {'User-Agent': 'Mozilla/5.0 (compatible; WedAPI-Crawler/1.0)'}
   r = httpx.get('https://html.duckduckgo.com/html/?q=site%3Aweddyplace.com%2Fde+hochzeitslocation+Cologne&kl=de-de', headers=headers, follow_redirects=True, timeout=15)
   print(r.status_code, len(r.text))
   # Inspect r.text to check if site structure changed
   ```

## What to check
- Zero reason recorded: no_vendor_objects_extracted: fetched 1 pages, parser found 0 objects
- Compare the current HTML/JSON structure against the connector's selectors
- Check the snapshot attached to this issue (if available) for the actual response
- Update the connector's CSS selectors, URL patterns, or JSON paths accordingly
- Re-run the scope to verify: `make crawl` or use the Admin → Crawl Runs → Run now button

## How to reproduce

1. Start the backend:
   ```
   docker compose up backend postgres redis -d
   ```

2. Open a Python shell:
   ```
   docker compose exec backend python
   ```

3. Run the connector directly:
   ```python
   from app.core.database import SessionLocal
   from app.services.connectors import search_discovery
   from app.models.models import IngestionJob
   import uuid
   db = SessionLocal()
   job = IngestionJob(id=str(uuid.uuid4()), connector_name='debug', status='running')
   db.add(job); db.commit()
   result = search_discovery.run_connector(
       db=db, job=job,
       category_slug='wedding-photographer',
       city='Nuremberg',
       country='DE',
       state='Bavaria',
       max_pages=1,
   )
   print(result)
   ```

4. Or fetch the raw page directly:
   ```python
   import httpx
   headers = {'User-Agent': 'Mozilla/5.0 (compatible; WedAPI-Crawler/1.0)'}
   r = httpx.get('https://html.duckduckgo.com/html/?q=hochzeitsfotograf+Nuremberg&kl=de-de', headers=headers, follow_redirects=True, timeout=15)
   print(r.status_code, len(r.text))
   # Inspect r.text to check if site structure changed
   ```

## What to check
- Zero reason recorded: no_vendor_objects_extracted: fetched 1 pages, parser found 0 objects
- Compare the current HTML/JSON structure against the connector's selectors
- Check the snapshot attached to this issue (if available) for the actual response
- Update the connector's CSS selectors, URL patterns, or JSON paths accordingly
- Re-run the scope to verify: `make crawl` or use the Admin → Crawl Runs → Run now button

## How to reproduce

1. Start the backend:
   ```
   docker compose up backend postgres redis -d
   ```

2. Open a Python shell:
   ```
   docker compose exec backend python
   ```

3. Run the connector directly:
   ```python
   from app.core.database import SessionLocal
   from app.services.connectors import weddyplace
   from app.models.models import IngestionJob
   import uuid
   db = SessionLocal()
   job = IngestionJob(id=str(uuid.uuid4()), connector_name='debug', status='running')
   db.add(job); db.commit()
   result = weddyplace.run_connector(
       db=db, job=job,
       category_slug='wedding-photographer',
       city='Nuremberg',
       country='DE',
       state='Bavaria',
       max_pages=1,
   )
   print(result)
   ```

4. Or fetch the raw page directly:
   ```python
   import httpx
   headers = {'User-Agent': 'Mozilla/5.0 (compatible; WedAPI-Crawler/1.0)'}
   r = httpx.get('https://html.duckduckgo.com/html/?q=site%3Aweddyplace.com%2Fde+hochzeitsfotograf+Nuremberg&kl=de-de', headers=headers, follow_redirects=True, timeout=15)
   print(r.status_code, len(r.text))
   # Inspect r.text to check if site structure changed
   ```

## What to check
- Zero reason recorded: no_vendor_objects_extracted: fetched 1 pages, parser found 0 objects
- Compare the current HTML/JSON structure against the connector's selectors
- Check the snapshot attached to this issue (if available) for the actual response
- Update the connector's CSS selectors, URL patterns, or JSON paths accordingly
- Re-run the scope to verify: `make crawl` or use the Admin → Crawl Runs → Run now button

## How to reproduce

1. Start the backend:
   ```
   docker compose up backend postgres redis -d
   ```

2. Open a Python shell:
   ```
   docker compose exec backend python
   ```

3. Run the connector directly:
   ```python
   from app.core.database import SessionLocal
   from app.services.connectors import bavariawedding
   from app.models.models import IngestionJob
   import uuid
   db = SessionLocal()
   job = IngestionJob(id=str(uuid.uuid4()), connector_name='debug', status='running')
   db.add(job); db.commit()
   result = bavariawedding.run_connector(
       db=db, job=job,
       category_slug='wedding-photographer',
       city='Nuremberg',
       country='DE',
       state='Bavaria',
       max_pages=1,
   )
   print(result)
   ```

4. Or fetch the raw page directly:
   ```python
   import httpx
   headers = {'User-Agent': 'Mozilla/5.0 (compatible; WedAPI-Crawler/1.0)'}
   r = httpx.get('https://www.bavariawedding.de/hochzeitsfotografen/nuremberg/', headers=headers, follow_redirects=True, timeout=15)
   print(r.status_code, len(r.text))
   # Inspect r.text to check if site structure changed
   ```

## What to check
- Zero reason recorded: http_errors: 1/1 pages failed
- Compare the current HTML/JSON structure against the connector's selectors
- Check the snapshot attached to this issue (if available) for the actual response
- Update the connector's CSS selectors, URL patterns, or JSON paths accordingly
- Re-run the scope to verify: `make crawl` or use the Admin → Crawl Runs → Run now button

## How to reproduce

1. Start the backend:
   ```
   docker compose up backend postgres redis -d
   ```

2. Open a Python shell:
   ```
   docker compose exec backend python
   ```

3. Run the connector directly:
   ```python
   from app.core.database import SessionLocal
   from app.services.connectors import search_discovery
   from app.models.models import IngestionJob
   import uuid
   db = SessionLocal()
   job = IngestionJob(id=str(uuid.uuid4()), connector_name='debug', status='running')
   db.add(job); db.commit()
   result = search_discovery.run_connector(
       db=db, job=job,
       category_slug='wedding-photographer',
       city='Stuttgart',
       country='DE',
       state=None,
       max_pages=1,
   )
   print(result)
   ```

4. Or fetch the raw page directly:
   ```python
   import httpx
   headers = {'User-Agent': 'Mozilla/5.0 (compatible; WedAPI-Crawler/1.0)'}
   r = httpx.get('https://html.duckduckgo.com/html/?q=hochzeitsfotograf+Stuttgart&kl=de-de', headers=headers, follow_redirects=True, timeout=15)
   print(r.status_code, len(r.text))
   # Inspect r.text to check if site structure changed
   ```

## What to check
- Zero reason recorded: no_vendor_objects_extracted: fetched 1 pages, parser found 0 objects
- Compare the current HTML/JSON structure against the connector's selectors
- Check the snapshot attached to this issue (if available) for the actual response
- Update the connector's CSS selectors, URL patterns, or JSON paths accordingly
- Re-run the scope to verify: `make crawl` or use the Admin → Crawl Runs → Run now button

## How to reproduce

1. Start the backend:
   ```
   docker compose up backend postgres redis -d
   ```

2. Open a Python shell:
   ```
   docker compose exec backend python
   ```

3. Run the connector directly:
   ```python
   from app.core.database import SessionLocal
   from app.services.connectors import weddyplace
   from app.models.models import IngestionJob
   import uuid
   db = SessionLocal()
   job = IngestionJob(id=str(uuid.uuid4()), connector_name='debug', status='running')
   db.add(job); db.commit()
   result = weddyplace.run_connector(
       db=db, job=job,
       category_slug='wedding-photographer',
       city='Stuttgart',
       country='DE',
       state=None,
       max_pages=1,
   )
   print(result)
   ```

4. Or fetch the raw page directly:
   ```python
   import httpx
   headers = {'User-Agent': 'Mozilla/5.0 (compatible; WedAPI-Crawler/1.0)'}
   r = httpx.get('https://html.duckduckgo.com/html/?q=site%3Aweddyplace.com%2Fde+hochzeitsfotograf+Stuttgart&kl=de-de', headers=headers, follow_redirects=True, timeout=15)
   print(r.status_code, len(r.text))
   # Inspect r.text to check if site structure changed
   ```

## What to check
- Zero reason recorded: no_vendor_objects_extracted: fetched 1 pages, parser found 0 objects
- Compare the current HTML/JSON structure against the connector's selectors
- Check the snapshot attached to this issue (if available) for the actual response
- Update the connector's CSS selectors, URL patterns, or JSON paths accordingly
- Re-run the scope to verify: `make crawl` or use the Admin → Crawl Runs → Run now button

## How to reproduce

1. Start the backend:
   ```
   docker compose up backend postgres redis -d
   ```

2. Open a Python shell:
   ```
   docker compose exec backend python
   ```

3. Run the connector directly:
   ```python
   from app.core.database import SessionLocal
   from app.services.connectors import search_discovery
   from app.models.models import IngestionJob
   import uuid
   db = SessionLocal()
   job = IngestionJob(id=str(uuid.uuid4()), connector_name='debug', status='running')
   db.add(job); db.commit()
   result = search_discovery.run_connector(
       db=db, job=job,
       category_slug='wedding-photographer',
       city='Frankfurt',
       country='DE',
       state=None,
       max_pages=1,
   )
   print(result)
   ```

4. Or fetch the raw page directly:
   ```python
   import httpx
   headers = {'User-Agent': 'Mozilla/5.0 (compatible; WedAPI-Crawler/1.0)'}
   r = httpx.get('https://html.duckduckgo.com/html/?q=hochzeitsfotograf+Frankfurt&kl=de-de', headers=headers, follow_redirects=True, timeout=15)
   print(r.status_code, len(r.text))
   # Inspect r.text to check if site structure changed
   ```

## What to check
- Zero reason recorded: no_vendor_objects_extracted: fetched 1 pages, parser found 0 objects
- Compare the current HTML/JSON structure against the connector's selectors
- Check the snapshot attached to this issue (if available) for the actual response
- Update the connector's CSS selectors, URL patterns, or JSON paths accordingly
- Re-run the scope to verify: `make crawl` or use the Admin → Crawl Runs → Run now button

## How to reproduce

1. Start the backend:
   ```
   docker compose up backend postgres redis -d
   ```

2. Open a Python shell:
   ```
   docker compose exec backend python
   ```

3. Run the connector directly:
   ```python
   from app.core.database import SessionLocal
   from app.services.connectors import weddyplace
   from app.models.models import IngestionJob
   import uuid
   db = SessionLocal()
   job = IngestionJob(id=str(uuid.uuid4()), connector_name='debug', status='running')
   db.add(job); db.commit()
   result = weddyplace.run_connector(
       db=db, job=job,
       category_slug='wedding-photographer',
       city='Frankfurt',
       country='DE',
       state=None,
       max_pages=1,
   )
   print(result)
   ```

4. Or fetch the raw page directly:
   ```python
   import httpx
   headers = {'User-Agent': 'Mozilla/5.0 (compatible; WedAPI-Crawler/1.0)'}
   r = httpx.get('https://html.duckduckgo.com/html/?q=site%3Aweddyplace.com%2Fde+hochzeitsfotograf+Frankfurt&kl=de-de', headers=headers, follow_redirects=True, timeout=15)
   print(r.status_code, len(r.text))
   # Inspect r.text to check if site structure changed
   ```

## What to check
- Zero reason recorded: no_vendor_objects_extracted: fetched 1 pages, parser found 0 objects
- Compare the current HTML/JSON structure against the connector's selectors
- Check the snapshot attached to this issue (if available) for the actual response
- Update the connector's CSS selectors, URL patterns, or JSON paths accordingly
- Re-run the scope to verify: `make crawl` or use the Admin → Crawl Runs → Run now button

## How to reproduce

1. Start the backend:
   ```
   docker compose up backend postgres redis -d
   ```

2. Open a Python shell:
   ```
   docker compose exec backend python
   ```

3. Run the connector directly:
   ```python
   from app.core.database import SessionLocal
   from app.services.connectors import search_discovery
   from app.models.models import IngestionJob
   import uuid
   db = SessionLocal()
   job = IngestionJob(id=str(uuid.uuid4()), connector_name='debug', status='running')
   db.add(job); db.commit()
   result = search_discovery.run_connector(
       db=db, job=job,
       category_slug='wedding-photographer',
       city='Cologne',
       country='DE',
       state=None,
       max_pages=1,
   )
   print(result)
   ```

4. Or fetch the raw page directly:
   ```python
   import httpx
   headers = {'User-Agent': 'Mozilla/5.0 (compatible; WedAPI-Crawler/1.0)'}
   r = httpx.get('https://html.duckduckgo.com/html/?q=hochzeitsfotograf+Cologne&kl=de-de', headers=headers, follow_redirects=True, timeout=15)
   print(r.status_code, len(r.text))
   # Inspect r.text to check if site structure changed
   ```

## What to check
- Zero reason recorded: no_vendor_objects_extracted: fetched 1 pages, parser found 0 objects
- Compare the current HTML/JSON structure against the connector's selectors
- Check the snapshot attached to this issue (if available) for the actual response
- Update the connector's CSS selectors, URL patterns, or JSON paths accordingly
- Re-run the scope to verify: `make crawl` or use the Admin → Crawl Runs → Run now button

## How to reproduce

1. Start the backend:
   ```
   docker compose up backend postgres redis -d
   ```

2. Open a Python shell:
   ```
   docker compose exec backend python
   ```

3. Run the connector directly:
   ```python
   from app.core.database import SessionLocal
   from app.services.connectors import weddyplace
   from app.models.models import IngestionJob
   import uuid
   db = SessionLocal()
   job = IngestionJob(id=str(uuid.uuid4()), connector_name='debug', status='running')
   db.add(job); db.commit()
   result = weddyplace.run_connector(
       db=db, job=job,
       category_slug='wedding-photographer',
       city='Cologne',
       country='DE',
       state=None,
       max_pages=1,
   )
   print(result)
   ```

4. Or fetch the raw page directly:
   ```python
   import httpx
   headers = {'User-Agent': 'Mozilla/5.0 (compatible; WedAPI-Crawler/1.0)'}
   r = httpx.get('https://html.duckduckgo.com/html/?q=site%3Aweddyplace.com%2Fde+hochzeitsfotograf+Cologne&kl=de-de', headers=headers, follow_redirects=True, timeout=15)
   print(r.status_code, len(r.text))
   # Inspect r.text to check if site structure changed
   ```

## What to check
- Zero reason recorded: no_vendor_objects_extracted: fetched 1 pages, parser found 0 objects
- Compare the current HTML/JSON structure against the connector's selectors
- Check the snapshot attached to this issue (if available) for the actual response
- Update the connector's CSS selectors, URL patterns, or JSON paths accordingly
- Re-run the scope to verify: `make crawl` or use the Admin → Crawl Runs → Run now button

## How to reproduce

1. Start the backend:
   ```
   docker compose up backend postgres redis -d
   ```

2. Open a Python shell:
   ```
   docker compose exec backend python
   ```

3. Run the connector directly:
   ```python
   from app.core.database import SessionLocal
   from app.services.connectors import search_discovery
   from app.models.models import IngestionJob
   import uuid
   db = SessionLocal()
   job = IngestionJob(id=str(uuid.uuid4()), connector_name='debug', status='running')
   db.add(job); db.commit()
   result = search_discovery.run_connector(
       db=db, job=job,
       category_slug='wedding-band',
       city='Hamburg',
       country='DE',
       state=None,
       max_pages=1,
   )
   print(result)
   ```

4. Or fetch the raw page directly:
   ```python
   import httpx
   headers = {'User-Agent': 'Mozilla/5.0 (compatible; WedAPI-Crawler/1.0)'}
   r = httpx.get('https://html.duckduckgo.com/html/?q=hochzeitsband+Hamburg&kl=de-de', headers=headers, follow_redirects=True, timeout=15)
   print(r.status_code, len(r.text))
   # Inspect r.text to check if site structure changed
   ```

## What to check
- Zero reason recorded: no_vendor_objects_extracted: fetched 1 pages, parser found 0 objects
- Compare the current HTML/JSON structure against the connector's selectors
- Check the snapshot attached to this issue (if available) for the actual response
- Update the connector's CSS selectors, URL patterns, or JSON paths accordingly
- Re-run the scope to verify: `make crawl` or use the Admin → Crawl Runs → Run now button

## How to reproduce

1. Start the backend:
   ```
   docker compose up backend postgres redis -d
   ```

2. Open a Python shell:
   ```
   docker compose exec backend python
   ```

3. Run the connector directly:
   ```python
   from app.core.database import SessionLocal
   from app.services.connectors import eventpeppers
   from app.models.models import IngestionJob
   import uuid
   db = SessionLocal()
   job = IngestionJob(id=str(uuid.uuid4()), connector_name='debug', status='running')
   db.add(job); db.commit()
   result = eventpeppers.run_connector(
       db=db, job=job,
       category_slug='wedding-band',
       city='Hamburg',
       country='DE',
       state=None,
       max_pages=1,
   )
   print(result)
   ```

4. Or fetch the raw page directly:
   ```python
   import httpx
   headers = {'User-Agent': 'Mozilla/5.0 (compatible; WedAPI-Crawler/1.0)'}
   r = httpx.get('https://html.duckduckgo.com/html/?q=site%3Aeventpeppers.com%2Fde+hochzeitsband+Hamburg&kl=de-de', headers=headers, follow_redirects=True, timeout=15)
   print(r.status_code, len(r.text))
   # Inspect r.text to check if site structure changed
   ```

## What to check
- Zero reason recorded: no_vendor_objects_extracted: fetched 1 pages, parser found 0 objects
- Compare the current HTML/JSON structure against the connector's selectors
- Check the snapshot attached to this issue (if available) for the actual response
- Update the connector's CSS selectors, URL patterns, or JSON paths accordingly
- Re-run the scope to verify: `make crawl` or use the Admin → Crawl Runs → Run now button

## How to reproduce

1. Start the backend:
   ```
   docker compose up backend postgres redis -d
   ```

2. Open a Python shell:
   ```
   docker compose exec backend python
   ```

3. Run the connector directly:
   ```python
   from app.core.database import SessionLocal
   from app.services.connectors import weddyplace
   from app.models.models import IngestionJob
   import uuid
   db = SessionLocal()
   job = IngestionJob(id=str(uuid.uuid4()), connector_name='debug', status='running')
   db.add(job); db.commit()
   result = weddyplace.run_connector(
       db=db, job=job,
       category_slug='wedding-band',
       city='Hamburg',
       country='DE',
       state=None,
       max_pages=1,
   )
   print(result)
   ```

4. Or fetch the raw page directly:
   ```python
   import httpx
   headers = {'User-Agent': 'Mozilla/5.0 (compatible; WedAPI-Crawler/1.0)'}
   r = httpx.get('https://html.duckduckgo.com/html/?q=site%3Aweddyplace.com%2Fde+hochzeitsband+Hamburg&kl=de-de', headers=headers, follow_redirects=True, timeout=15)
   print(r.status_code, len(r.text))
   # Inspect r.text to check if site structure changed
   ```

## What to check
- Zero reason recorded: no_vendor_objects_extracted: fetched 1 pages, parser found 0 objects
- Compare the current HTML/JSON structure against the connector's selectors
- Check the snapshot attached to this issue (if available) for the actual response
- Update the connector's CSS selectors, URL patterns, or JSON paths accordingly
- Re-run the scope to verify: `make crawl` or use the Admin → Crawl Runs → Run now button

## How to reproduce

1. Start the backend:
   ```
   docker compose up backend postgres redis -d
   ```

2. Open a Python shell:
   ```
   docker compose exec backend python
   ```

3. Run the connector directly:
   ```python
   from app.core.database import SessionLocal
   from app.services.connectors import search_discovery
   from app.models.models import IngestionJob
   import uuid
   db = SessionLocal()
   job = IngestionJob(id=str(uuid.uuid4()), connector_name='debug', status='running')
   db.add(job); db.commit()
   result = search_discovery.run_connector(
       db=db, job=job,
       category_slug='wedding-band',
       city='Berlin',
       country='DE',
       state=None,
       max_pages=1,
   )
   print(result)
   ```

4. Or fetch the raw page directly:
   ```python
   import httpx
   headers = {'User-Agent': 'Mozilla/5.0 (compatible; WedAPI-Crawler/1.0)'}
   r = httpx.get('https://html.duckduckgo.com/html/?q=hochzeitsband+Berlin&kl=de-de', headers=headers, follow_redirects=True, timeout=15)
   print(r.status_code, len(r.text))
   # Inspect r.text to check if site structure changed
   ```

## What to check
- Zero reason recorded: no_vendor_objects_extracted: fetched 1 pages, parser found 0 objects
- Compare the current HTML/JSON structure against the connector's selectors
- Check the snapshot attached to this issue (if available) for the actual response
- Update the connector's CSS selectors, URL patterns, or JSON paths accordingly
- Re-run the scope to verify: `make crawl` or use the Admin → Crawl Runs → Run now button

## How to reproduce

1. Start the backend:
   ```
   docker compose up backend postgres redis -d
   ```

2. Open a Python shell:
   ```
   docker compose exec backend python
   ```

3. Run the connector directly:
   ```python
   from app.core.database import SessionLocal
   from app.services.connectors import eventpeppers
   from app.models.models import IngestionJob
   import uuid
   db = SessionLocal()
   job = IngestionJob(id=str(uuid.uuid4()), connector_name='debug', status='running')
   db.add(job); db.commit()
   result = eventpeppers.run_connector(
       db=db, job=job,
       category_slug='wedding-band',
       city='Berlin',
       country='DE',
       state=None,
       max_pages=1,
   )
   print(result)
   ```

4. Or fetch the raw page directly:
   ```python
   import httpx
   headers = {'User-Agent': 'Mozilla/5.0 (compatible; WedAPI-Crawler/1.0)'}
   r = httpx.get('https://html.duckduckgo.com/html/?q=site%3Aeventpeppers.com%2Fde+hochzeitsband+Berlin&kl=de-de', headers=headers, follow_redirects=True, timeout=15)
   print(r.status_code, len(r.text))
   # Inspect r.text to check if site structure changed
   ```

## What to check
- Zero reason recorded: no_vendor_objects_extracted: fetched 1 pages, parser found 0 objects
- Compare the current HTML/JSON structure against the connector's selectors
- Check the snapshot attached to this issue (if available) for the actual response
- Update the connector's CSS selectors, URL patterns, or JSON paths accordingly
- Re-run the scope to verify: `make crawl` or use the Admin → Crawl Runs → Run now button

## How to reproduce

1. Start the backend:
   ```
   docker compose up backend postgres redis -d
   ```

2. Open a Python shell:
   ```
   docker compose exec backend python
   ```

3. Run the connector directly:
   ```python
   from app.core.database import SessionLocal
   from app.services.connectors import weddyplace
   from app.models.models import IngestionJob
   import uuid
   db = SessionLocal()
   job = IngestionJob(id=str(uuid.uuid4()), connector_name='debug', status='running')
   db.add(job); db.commit()
   result = weddyplace.run_connector(
       db=db, job=job,
       category_slug='wedding-band',
       city='Berlin',
       country='DE',
       state=None,
       max_pages=1,
   )
   print(result)
   ```

4. Or fetch the raw page directly:
   ```python
   import httpx
   headers = {'User-Agent': 'Mozilla/5.0 (compatible; WedAPI-Crawler/1.0)'}
   r = httpx.get('https://html.duckduckgo.com/html/?q=site%3Aweddyplace.com%2Fde+hochzeitsband+Berlin&kl=de-de', headers=headers, follow_redirects=True, timeout=15)
   print(r.status_code, len(r.text))
   # Inspect r.text to check if site structure changed
   ```

## What to check
- Zero reason recorded: no_vendor_objects_extracted: fetched 1 pages, parser found 0 objects
- Compare the current HTML/JSON structure against the connector's selectors
- Check the snapshot attached to this issue (if available) for the actual response
- Update the connector's CSS selectors, URL patterns, or JSON paths accordingly
- Re-run the scope to verify: `make crawl` or use the Admin → Crawl Runs → Run now button

## How to reproduce

1. Start the backend:
   ```
   docker compose up backend postgres redis -d
   ```

2. Open a Python shell:
   ```
   docker compose exec backend python
   ```

3. Run the connector directly:
   ```python
   from app.core.database import SessionLocal
   from app.services.connectors import search_discovery
   from app.models.models import IngestionJob
   import uuid
   db = SessionLocal()
   job = IngestionJob(id=str(uuid.uuid4()), connector_name='debug', status='running')
   db.add(job); db.commit()
   result = search_discovery.run_connector(
       db=db, job=job,
       category_slug='wedding-band',
       city='Munich',
       country='DE',
       state='Bavaria',
       max_pages=1,
   )
   print(result)
   ```

4. Or fetch the raw page directly:
   ```python
   import httpx
   headers = {'User-Agent': 'Mozilla/5.0 (compatible; WedAPI-Crawler/1.0)'}
   r = httpx.get('https://html.duckduckgo.com/html/?q=hochzeitsband+Munich&kl=de-de', headers=headers, follow_redirects=True, timeout=15)
   print(r.status_code, len(r.text))
   # Inspect r.text to check if site structure changed
   ```

## What to check
- Zero reason recorded: no_vendor_objects_extracted: fetched 1 pages, parser found 0 objects
- Compare the current HTML/JSON structure against the connector's selectors
- Check the snapshot attached to this issue (if available) for the actual response
- Update the connector's CSS selectors, URL patterns, or JSON paths accordingly
- Re-run the scope to verify: `make crawl` or use the Admin → Crawl Runs → Run now button

## How to reproduce

1. Start the backend:
   ```
   docker compose up backend postgres redis -d
   ```

2. Open a Python shell:
   ```
   docker compose exec backend python
   ```

3. Run the connector directly:
   ```python
   from app.core.database import SessionLocal
   from app.services.connectors import eventpeppers
   from app.models.models import IngestionJob
   import uuid
   db = SessionLocal()
   job = IngestionJob(id=str(uuid.uuid4()), connector_name='debug', status='running')
   db.add(job); db.commit()
   result = eventpeppers.run_connector(
       db=db, job=job,
       category_slug='wedding-band',
       city='Munich',
       country='DE',
       state='Bavaria',
       max_pages=1,
   )
   print(result)
   ```

4. Or fetch the raw page directly:
   ```python
   import httpx
   headers = {'User-Agent': 'Mozilla/5.0 (compatible; WedAPI-Crawler/1.0)'}
   r = httpx.get('https://html.duckduckgo.com/html/?q=site%3Aeventpeppers.com%2Fde+hochzeitsband+Munich&kl=de-de', headers=headers, follow_redirects=True, timeout=15)
   print(r.status_code, len(r.text))
   # Inspect r.text to check if site structure changed
   ```

## What to check
- Zero reason recorded: no_vendor_objects_extracted: fetched 1 pages, parser found 0 objects
- Compare the current HTML/JSON structure against the connector's selectors
- Check the snapshot attached to this issue (if available) for the actual response
- Update the connector's CSS selectors, URL patterns, or JSON paths accordingly
- Re-run the scope to verify: `make crawl` or use the Admin → Crawl Runs → Run now button

## How to reproduce

1. Start the backend:
   ```
   docker compose up backend postgres redis -d
   ```

2. Open a Python shell:
   ```
   docker compose exec backend python
   ```

3. Run the connector directly:
   ```python
   from app.core.database import SessionLocal
   from app.services.connectors import weddyplace
   from app.models.models import IngestionJob
   import uuid
   db = SessionLocal()
   job = IngestionJob(id=str(uuid.uuid4()), connector_name='debug', status='running')
   db.add(job); db.commit()
   result = weddyplace.run_connector(
       db=db, job=job,
       category_slug='wedding-band',
       city='Munich',
       country='DE',
       state='Bavaria',
       max_pages=1,
   )
   print(result)
   ```

4. Or fetch the raw page directly:
   ```python
   import httpx
   headers = {'User-Agent': 'Mozilla/5.0 (compatible; WedAPI-Crawler/1.0)'}
   r = httpx.get('https://html.duckduckgo.com/html/?q=site%3Aweddyplace.com%2Fde+hochzeitsband+Munich&kl=de-de', headers=headers, follow_redirects=True, timeout=15)
   print(r.status_code, len(r.text))
   # Inspect r.text to check if site structure changed
   ```

## What to check
- Zero reason recorded: no_vendor_objects_extracted: fetched 1 pages, parser found 0 objects
- Compare the current HTML/JSON structure against the connector's selectors
- Check the snapshot attached to this issue (if available) for the actual response
- Update the connector's CSS selectors, URL patterns, or JSON paths accordingly
- Re-run the scope to verify: `make crawl` or use the Admin → Crawl Runs → Run now button

## How to reproduce

1. Start the backend:
   ```
   docker compose up backend postgres redis -d
   ```

2. Open a Python shell:
   ```
   docker compose exec backend python
   ```

3. Run the connector directly:
   ```python
   from app.core.database import SessionLocal
   from app.services.connectors import bavariawedding
   from app.models.models import IngestionJob
   import uuid
   db = SessionLocal()
   job = IngestionJob(id=str(uuid.uuid4()), connector_name='debug', status='running')
   db.add(job); db.commit()
   result = bavariawedding.run_connector(
       db=db, job=job,
       category_slug='wedding-band',
       city='Munich',
       country='DE',
       state='Bavaria',
       max_pages=1,
   )
   print(result)
   ```

4. Or fetch the raw page directly:
   ```python
   import httpx
   headers = {'User-Agent': 'Mozilla/5.0 (compatible; WedAPI-Crawler/1.0)'}
   r = httpx.get('https://www.bavariawedding.de/djs-bands/munich/', headers=headers, follow_redirects=True, timeout=15)
   print(r.status_code, len(r.text))
   # Inspect r.text to check if site structure changed
   ```

## What to check
- Zero reason recorded: http_errors: 1/1 pages failed
- Compare the current HTML/JSON structure against the connector's selectors
- Check the snapshot attached to this issue (if available) for the actual response
- Update the connector's CSS selectors, URL patterns, or JSON paths accordingly
- Re-run the scope to verify: `make crawl` or use the Admin → Crawl Runs → Run now button

## How to reproduce

1. Start the backend:
   ```
   docker compose up backend postgres redis -d
   ```

2. Open a Python shell:
   ```
   docker compose exec backend python
   ```

3. Run the connector directly:
   ```python
   from app.core.database import SessionLocal
   from app.services.connectors import search_discovery
   from app.models.models import IngestionJob
   import uuid
   db = SessionLocal()
   job = IngestionJob(id=str(uuid.uuid4()), connector_name='debug', status='running')
   db.add(job); db.commit()
   result = search_discovery.run_connector(
       db=db, job=job,
       category_slug='wedding-dj',
       city='Hamburg',
       country='DE',
       state=None,
       max_pages=1,
   )
   print(result)
   ```

4. Or fetch the raw page directly:
   ```python
   import httpx
   headers = {'User-Agent': 'Mozilla/5.0 (compatible; WedAPI-Crawler/1.0)'}
   r = httpx.get('https://html.duckduckgo.com/html/?q=hochzeits+dj+Hamburg&kl=de-de', headers=headers, follow_redirects=True, timeout=15)
   print(r.status_code, len(r.text))
   # Inspect r.text to check if site structure changed
   ```

## What to check
- Zero reason recorded: no_vendor_objects_extracted: fetched 1 pages, parser found 0 objects
- Compare the current HTML/JSON structure against the connector's selectors
- Check the snapshot attached to this issue (if available) for the actual response
- Update the connector's CSS selectors, URL patterns, or JSON paths accordingly
- Re-run the scope to verify: `make crawl` or use the Admin → Crawl Runs → Run now button

## How to reproduce

1. Start the backend:
   ```
   docker compose up backend postgres redis -d
   ```

2. Open a Python shell:
   ```
   docker compose exec backend python
   ```

3. Run the connector directly:
   ```python
   from app.core.database import SessionLocal
   from app.services.connectors import eventpeppers
   from app.models.models import IngestionJob
   import uuid
   db = SessionLocal()
   job = IngestionJob(id=str(uuid.uuid4()), connector_name='debug', status='running')
   db.add(job); db.commit()
   result = eventpeppers.run_connector(
       db=db, job=job,
       category_slug='wedding-dj',
       city='Hamburg',
       country='DE',
       state=None,
       max_pages=1,
   )
   print(result)
   ```

4. Or fetch the raw page directly:
   ```python
   import httpx
   headers = {'User-Agent': 'Mozilla/5.0 (compatible; WedAPI-Crawler/1.0)'}
   r = httpx.get('https://html.duckduckgo.com/html/?q=site%3Aeventpeppers.com%2Fde+hochzeits+dj+Hamburg&kl=de-de', headers=headers, follow_redirects=True, timeout=15)
   print(r.status_code, len(r.text))
   # Inspect r.text to check if site structure changed
   ```

## What to check
- Zero reason recorded: no_vendor_objects_extracted: fetched 1 pages, parser found 0 objects
- Compare the current HTML/JSON structure against the connector's selectors
- Check the snapshot attached to this issue (if available) for the actual response
- Update the connector's CSS selectors, URL patterns, or JSON paths accordingly
- Re-run the scope to verify: `make crawl` or use the Admin → Crawl Runs → Run now button

## How to reproduce

1. Start the backend:
   ```
   docker compose up backend postgres redis -d
   ```

2. Open a Python shell:
   ```
   docker compose exec backend python
   ```

3. Run the connector directly:
   ```python
   from app.core.database import SessionLocal
   from app.services.connectors import weddyplace
   from app.models.models import IngestionJob
   import uuid
   db = SessionLocal()
   job = IngestionJob(id=str(uuid.uuid4()), connector_name='debug', status='running')
   db.add(job); db.commit()
   result = weddyplace.run_connector(
       db=db, job=job,
       category_slug='wedding-dj',
       city='Hamburg',
       country='DE',
       state=None,
       max_pages=1,
   )
   print(result)
   ```

4. Or fetch the raw page directly:
   ```python
   import httpx
   headers = {'User-Agent': 'Mozilla/5.0 (compatible; WedAPI-Crawler/1.0)'}
   r = httpx.get('https://html.duckduckgo.com/html/?q=site%3Aweddyplace.com%2Fde+hochzeits+dj+Hamburg&kl=de-de', headers=headers, follow_redirects=True, timeout=15)
   print(r.status_code, len(r.text))
   # Inspect r.text to check if site structure changed
   ```

## What to check
- Zero reason recorded: no_vendor_objects_extracted: fetched 1 pages, parser found 0 objects
- Compare the current HTML/JSON structure against the connector's selectors
- Check the snapshot attached to this issue (if available) for the actual response
- Update the connector's CSS selectors, URL patterns, or JSON paths accordingly
- Re-run the scope to verify: `make crawl` or use the Admin → Crawl Runs → Run now button

## How to reproduce

1. Start the backend:
   ```
   docker compose up backend postgres redis -d
   ```

2. Open a Python shell:
   ```
   docker compose exec backend python
   ```

3. Run the connector directly:
   ```python
   from app.core.database import SessionLocal
   from app.services.connectors import search_discovery
   from app.models.models import IngestionJob
   import uuid
   db = SessionLocal()
   job = IngestionJob(id=str(uuid.uuid4()), connector_name='debug', status='running')
   db.add(job); db.commit()
   result = search_discovery.run_connector(
       db=db, job=job,
       category_slug='wedding-dj',
       city='Berlin',
       country='DE',
       state=None,
       max_pages=1,
   )
   print(result)
   ```

4. Or fetch the raw page directly:
   ```python
   import httpx
   headers = {'User-Agent': 'Mozilla/5.0 (compatible; WedAPI-Crawler/1.0)'}
   r = httpx.get('https://html.duckduckgo.com/html/?q=hochzeits+dj+Berlin&kl=de-de', headers=headers, follow_redirects=True, timeout=15)
   print(r.status_code, len(r.text))
   # Inspect r.text to check if site structure changed
   ```

## What to check
- Zero reason recorded: no_vendor_objects_extracted: fetched 1 pages, parser found 0 objects
- Compare the current HTML/JSON structure against the connector's selectors
- Check the snapshot attached to this issue (if available) for the actual response
- Update the connector's CSS selectors, URL patterns, or JSON paths accordingly
- Re-run the scope to verify: `make crawl` or use the Admin → Crawl Runs → Run now button

## How to reproduce

1. Start the backend:
   ```
   docker compose up backend postgres redis -d
   ```

2. Open a Python shell:
   ```
   docker compose exec backend python
   ```

3. Run the connector directly:
   ```python
   from app.core.database import SessionLocal
   from app.services.connectors import eventpeppers
   from app.models.models import IngestionJob
   import uuid
   db = SessionLocal()
   job = IngestionJob(id=str(uuid.uuid4()), connector_name='debug', status='running')
   db.add(job); db.commit()
   result = eventpeppers.run_connector(
       db=db, job=job,
       category_slug='wedding-dj',
       city='Berlin',
       country='DE',
       state=None,
       max_pages=1,
   )
   print(result)
   ```

4. Or fetch the raw page directly:
   ```python
   import httpx
   headers = {'User-Agent': 'Mozilla/5.0 (compatible; WedAPI-Crawler/1.0)'}
   r = httpx.get('https://html.duckduckgo.com/html/?q=site%3Aeventpeppers.com%2Fde+hochzeits+dj+Berlin&kl=de-de', headers=headers, follow_redirects=True, timeout=15)
   print(r.status_code, len(r.text))
   # Inspect r.text to check if site structure changed
   ```

## What to check
- Zero reason recorded: no_vendor_objects_extracted: fetched 1 pages, parser found 0 objects
- Compare the current HTML/JSON structure against the connector's selectors
- Check the snapshot attached to this issue (if available) for the actual response
- Update the connector's CSS selectors, URL patterns, or JSON paths accordingly
- Re-run the scope to verify: `make crawl` or use the Admin → Crawl Runs → Run now button

## How to reproduce

1. Start the backend:
   ```
   docker compose up backend postgres redis -d
   ```

2. Open a Python shell:
   ```
   docker compose exec backend python
   ```

3. Run the connector directly:
   ```python
   from app.core.database import SessionLocal
   from app.services.connectors import weddyplace
   from app.models.models import IngestionJob
   import uuid
   db = SessionLocal()
   job = IngestionJob(id=str(uuid.uuid4()), connector_name='debug', status='running')
   db.add(job); db.commit()
   result = weddyplace.run_connector(
       db=db, job=job,
       category_slug='wedding-dj',
       city='Berlin',
       country='DE',
       state=None,
       max_pages=1,
   )
   print(result)
   ```

4. Or fetch the raw page directly:
   ```python
   import httpx
   headers = {'User-Agent': 'Mozilla/5.0 (compatible; WedAPI-Crawler/1.0)'}
   r = httpx.get('https://html.duckduckgo.com/html/?q=site%3Aweddyplace.com%2Fde+hochzeits+dj+Berlin&kl=de-de', headers=headers, follow_redirects=True, timeout=15)
   print(r.status_code, len(r.text))
   # Inspect r.text to check if site structure changed
   ```

## What to check
- Zero reason recorded: no_vendor_objects_extracted: fetched 1 pages, parser found 0 objects
- Compare the current HTML/JSON structure against the connector's selectors
- Check the snapshot attached to this issue (if available) for the actual response
- Update the connector's CSS selectors, URL patterns, or JSON paths accordingly
- Re-run the scope to verify: `make crawl` or use the Admin → Crawl Runs → Run now button

## How to reproduce

1. Start the backend:
   ```
   docker compose up backend postgres redis -d
   ```

2. Open a Python shell:
   ```
   docker compose exec backend python
   ```

3. Run the connector directly:
   ```python
   from app.core.database import SessionLocal
   from app.services.connectors import search_discovery
   from app.models.models import IngestionJob
   import uuid
   db = SessionLocal()
   job = IngestionJob(id=str(uuid.uuid4()), connector_name='debug', status='running')
   db.add(job); db.commit()
   result = search_discovery.run_connector(
       db=db, job=job,
       category_slug='wedding-dj',
       city='Munich',
       country='DE',
       state='Bavaria',
       max_pages=1,
   )
   print(result)
   ```

4. Or fetch the raw page directly:
   ```python
   import httpx
   headers = {'User-Agent': 'Mozilla/5.0 (compatible; WedAPI-Crawler/1.0)'}
   r = httpx.get('https://html.duckduckgo.com/html/?q=hochzeits+dj+Munich&kl=de-de', headers=headers, follow_redirects=True, timeout=15)
   print(r.status_code, len(r.text))
   # Inspect r.text to check if site structure changed
   ```

## What to check
- Zero reason recorded: no_vendor_objects_extracted: fetched 1 pages, parser found 0 objects
- Compare the current HTML/JSON structure against the connector's selectors
- Check the snapshot attached to this issue (if available) for the actual response
- Update the connector's CSS selectors, URL patterns, or JSON paths accordingly
- Re-run the scope to verify: `make crawl` or use the Admin → Crawl Runs → Run now button

## How to reproduce

1. Start the backend:
   ```
   docker compose up backend postgres redis -d
   ```

2. Open a Python shell:
   ```
   docker compose exec backend python
   ```

3. Run the connector directly:
   ```python
   from app.core.database import SessionLocal
   from app.services.connectors import eventpeppers
   from app.models.models import IngestionJob
   import uuid
   db = SessionLocal()
   job = IngestionJob(id=str(uuid.uuid4()), connector_name='debug', status='running')
   db.add(job); db.commit()
   result = eventpeppers.run_connector(
       db=db, job=job,
       category_slug='wedding-dj',
       city='Munich',
       country='DE',
       state='Bavaria',
       max_pages=1,
   )
   print(result)
   ```

4. Or fetch the raw page directly:
   ```python
   import httpx
   headers = {'User-Agent': 'Mozilla/5.0 (compatible; WedAPI-Crawler/1.0)'}
   r = httpx.get('https://html.duckduckgo.com/html/?q=site%3Aeventpeppers.com%2Fde+hochzeits+dj+Munich&kl=de-de', headers=headers, follow_redirects=True, timeout=15)
   print(r.status_code, len(r.text))
   # Inspect r.text to check if site structure changed
   ```

## What to check
- Zero reason recorded: no_vendor_objects_extracted: fetched 1 pages, parser found 0 objects
- Compare the current HTML/JSON structure against the connector's selectors
- Check the snapshot attached to this issue (if available) for the actual response
- Update the connector's CSS selectors, URL patterns, or JSON paths accordingly
- Re-run the scope to verify: `make crawl` or use the Admin → Crawl Runs → Run now button

## How to reproduce

1. Start the backend:
   ```
   docker compose up backend postgres redis -d
   ```

2. Open a Python shell:
   ```
   docker compose exec backend python
   ```

3. Run the connector directly:
   ```python
   from app.core.database import SessionLocal
   from app.services.connectors import weddyplace
   from app.models.models import IngestionJob
   import uuid
   db = SessionLocal()
   job = IngestionJob(id=str(uuid.uuid4()), connector_name='debug', status='running')
   db.add(job); db.commit()
   result = weddyplace.run_connector(
       db=db, job=job,
       category_slug='wedding-dj',
       city='Munich',
       country='DE',
       state='Bavaria',
       max_pages=1,
   )
   print(result)
   ```

4. Or fetch the raw page directly:
   ```python
   import httpx
   headers = {'User-Agent': 'Mozilla/5.0 (compatible; WedAPI-Crawler/1.0)'}
   r = httpx.get('https://html.duckduckgo.com/html/?q=site%3Aweddyplace.com%2Fde+hochzeits+dj+Munich&kl=de-de', headers=headers, follow_redirects=True, timeout=15)
   print(r.status_code, len(r.text))
   # Inspect r.text to check if site structure changed
   ```

## What to check
- Zero reason recorded: no_vendor_objects_extracted: fetched 1 pages, parser found 0 objects
- Compare the current HTML/JSON structure against the connector's selectors
- Check the snapshot attached to this issue (if available) for the actual response
- Update the connector's CSS selectors, URL patterns, or JSON paths accordingly
- Re-run the scope to verify: `make crawl` or use the Admin → Crawl Runs → Run now button

## How to reproduce

1. Start the backend:
   ```
   docker compose up backend postgres redis -d
   ```

2. Open a Python shell:
   ```
   docker compose exec backend python
   ```

3. Run the connector directly:
   ```python
   from app.core.database import SessionLocal
   from app.services.connectors import bavariawedding
   from app.models.models import IngestionJob
   import uuid
   db = SessionLocal()
   job = IngestionJob(id=str(uuid.uuid4()), connector_name='debug', status='running')
   db.add(job); db.commit()
   result = bavariawedding.run_connector(
       db=db, job=job,
       category_slug='wedding-dj',
       city='Munich',
       country='DE',
       state='Bavaria',
       max_pages=1,
   )
   print(result)
   ```

4. Or fetch the raw page directly:
   ```python
   import httpx
   headers = {'User-Agent': 'Mozilla/5.0 (compatible; WedAPI-Crawler/1.0)'}
   r = httpx.get('https://www.bavariawedding.de/djs-bands/munich/', headers=headers, follow_redirects=True, timeout=15)
   print(r.status_code, len(r.text))
   # Inspect r.text to check if site structure changed
   ```

## What to check
- Zero reason recorded: http_errors: 1/1 pages failed
- Compare the current HTML/JSON structure against the connector's selectors
- Check the snapshot attached to this issue (if available) for the actual response
- Update the connector's CSS selectors, URL patterns, or JSON paths accordingly
- Re-run the scope to verify: `make crawl` or use the Admin → Crawl Runs → Run now button

## How to reproduce

1. Start the backend:
   ```
   docker compose up backend postgres redis -d
   ```

2. Open a Python shell:
   ```
   docker compose exec backend python
   ```

3. Run the connector directly:
   ```python
   from app.core.database import SessionLocal
   from app.services.connectors import search_discovery
   from app.models.models import IngestionJob
   import uuid
   db = SessionLocal()
   job = IngestionJob(id=str(uuid.uuid4()), connector_name='debug', status='running')
   db.add(job); db.commit()
   result = search_discovery.run_connector(
       db=db, job=job,
       category_slug='wedding-venue',
       city='Hamburg',
       country='DE',
       state=None,
       max_pages=1,
   )
   print(result)
   ```

4. Or fetch the raw page directly:
   ```python
   import httpx
   headers = {'User-Agent': 'Mozilla/5.0 (compatible; WedAPI-Crawler/1.0)'}
   r = httpx.get('https://html.duckduckgo.com/html/?q=hochzeitslocation+Hamburg&kl=de-de', headers=headers, follow_redirects=True, timeout=15)
   print(r.status_code, len(r.text))
   # Inspect r.text to check if site structure changed
   ```

## What to check
- Zero reason recorded: no_vendor_objects_extracted: fetched 1 pages, parser found 0 objects
- Compare the current HTML/JSON structure against the connector's selectors
- Check the snapshot attached to this issue (if available) for the actual response
- Update the connector's CSS selectors, URL patterns, or JSON paths accordingly
- Re-run the scope to verify: `make crawl` or use the Admin → Crawl Runs → Run now button

## How to reproduce

1. Start the backend:
   ```
   docker compose up backend postgres redis -d
   ```

2. Open a Python shell:
   ```
   docker compose exec backend python
   ```

3. Run the connector directly:
   ```python
   from app.core.database import SessionLocal
   from app.services.connectors import weddyplace
   from app.models.models import IngestionJob
   import uuid
   db = SessionLocal()
   job = IngestionJob(id=str(uuid.uuid4()), connector_name='debug', status='running')
   db.add(job); db.commit()
   result = weddyplace.run_connector(
       db=db, job=job,
       category_slug='wedding-venue',
       city='Hamburg',
       country='DE',
       state=None,
       max_pages=1,
   )
   print(result)
   ```

4. Or fetch the raw page directly:
   ```python
   import httpx
   headers = {'User-Agent': 'Mozilla/5.0 (compatible; WedAPI-Crawler/1.0)'}
   r = httpx.get('https://html.duckduckgo.com/html/?q=site%3Aweddyplace.com%2Fde+hochzeitslocation+Hamburg&kl=de-de', headers=headers, follow_redirects=True, timeout=15)
   print(r.status_code, len(r.text))
   # Inspect r.text to check if site structure changed
   ```

## What to check
- Zero reason recorded: no_vendor_objects_extracted: fetched 1 pages, parser found 0 objects
- Compare the current HTML/JSON structure against the connector's selectors
- Check the snapshot attached to this issue (if available) for the actual response
- Update the connector's CSS selectors, URL patterns, or JSON paths accordingly
- Re-run the scope to verify: `make crawl` or use the Admin → Crawl Runs → Run now button

## How to reproduce

1. Start the backend:
   ```
   docker compose up backend postgres redis -d
   ```

2. Open a Python shell:
   ```
   docker compose exec backend python
   ```

3. Run the connector directly:
   ```python
   from app.core.database import SessionLocal
   from app.services.connectors import search_discovery
   from app.models.models import IngestionJob
   import uuid
   db = SessionLocal()
   job = IngestionJob(id=str(uuid.uuid4()), connector_name='debug', status='running')
   db.add(job); db.commit()
   result = search_discovery.run_connector(
       db=db, job=job,
       category_slug='wedding-venue',
       city='Berlin',
       country='DE',
       state=None,
       max_pages=1,
   )
   print(result)
   ```

4. Or fetch the raw page directly:
   ```python
   import httpx
   headers = {'User-Agent': 'Mozilla/5.0 (compatible; WedAPI-Crawler/1.0)'}
   r = httpx.get('https://html.duckduckgo.com/html/?q=hochzeitslocation+Berlin&kl=de-de', headers=headers, follow_redirects=True, timeout=15)
   print(r.status_code, len(r.text))
   # Inspect r.text to check if site structure changed
   ```

## What to check
- Zero reason recorded: no_vendor_objects_extracted: fetched 1 pages, parser found 0 objects
- Compare the current HTML/JSON structure against the connector's selectors
- Check the snapshot attached to this issue (if available) for the actual response
- Update the connector's CSS selectors, URL patterns, or JSON paths accordingly
- Re-run the scope to verify: `make crawl` or use the Admin → Crawl Runs → Run now button

## How to reproduce

1. Start the backend:
   ```
   docker compose up backend postgres redis -d
   ```

2. Open a Python shell:
   ```
   docker compose exec backend python
   ```

3. Run the connector directly:
   ```python
   from app.core.database import SessionLocal
   from app.services.connectors import weddyplace
   from app.models.models import IngestionJob
   import uuid
   db = SessionLocal()
   job = IngestionJob(id=str(uuid.uuid4()), connector_name='debug', status='running')
   db.add(job); db.commit()
   result = weddyplace.run_connector(
       db=db, job=job,
       category_slug='wedding-venue',
       city='Berlin',
       country='DE',
       state=None,
       max_pages=1,
   )
   print(result)
   ```

4. Or fetch the raw page directly:
   ```python
   import httpx
   headers = {'User-Agent': 'Mozilla/5.0 (compatible; WedAPI-Crawler/1.0)'}
   r = httpx.get('https://html.duckduckgo.com/html/?q=site%3Aweddyplace.com%2Fde+hochzeitslocation+Berlin&kl=de-de', headers=headers, follow_redirects=True, timeout=15)
   print(r.status_code, len(r.text))
   # Inspect r.text to check if site structure changed
   ```

## What to check
- Zero reason recorded: no_vendor_objects_extracted: fetched 1 pages, parser found 0 objects
- Compare the current HTML/JSON structure against the connector's selectors
- Check the snapshot attached to this issue (if available) for the actual response
- Update the connector's CSS selectors, URL patterns, or JSON paths accordingly
- Re-run the scope to verify: `make crawl` or use the Admin → Crawl Runs → Run now button

## How to reproduce

1. Start the backend:
   ```
   docker compose up backend postgres redis -d
   ```

2. Open a Python shell:
   ```
   docker compose exec backend python
   ```

3. Run the connector directly:
   ```python
   from app.core.database import SessionLocal
   from app.services.connectors import search_discovery
   from app.models.models import IngestionJob
   import uuid
   db = SessionLocal()
   job = IngestionJob(id=str(uuid.uuid4()), connector_name='debug', status='running')
   db.add(job); db.commit()
   result = search_discovery.run_connector(
       db=db, job=job,
       category_slug='wedding-venue',
       city='Munich',
       country='DE',
       state='Bavaria',
       max_pages=1,
   )
   print(result)
   ```

4. Or fetch the raw page directly:
   ```python
   import httpx
   headers = {'User-Agent': 'Mozilla/5.0 (compatible; WedAPI-Crawler/1.0)'}
   r = httpx.get('https://html.duckduckgo.com/html/?q=hochzeitslocation+Munich&kl=de-de', headers=headers, follow_redirects=True, timeout=15)
   print(r.status_code, len(r.text))
   # Inspect r.text to check if site structure changed
   ```

## What to check
- Zero reason recorded: no_vendor_objects_extracted: fetched 1 pages, parser found 0 objects
- Compare the current HTML/JSON structure against the connector's selectors
- Check the snapshot attached to this issue (if available) for the actual response
- Update the connector's CSS selectors, URL patterns, or JSON paths accordingly
- Re-run the scope to verify: `make crawl` or use the Admin → Crawl Runs → Run now button

## How to reproduce

1. Start the backend:
   ```
   docker compose up backend postgres redis -d
   ```

2. Open a Python shell:
   ```
   docker compose exec backend python
   ```

3. Run the connector directly:
   ```python
   from app.core.database import SessionLocal
   from app.services.connectors import weddyplace
   from app.models.models import IngestionJob
   import uuid
   db = SessionLocal()
   job = IngestionJob(id=str(uuid.uuid4()), connector_name='debug', status='running')
   db.add(job); db.commit()
   result = weddyplace.run_connector(
       db=db, job=job,
       category_slug='wedding-venue',
       city='Munich',
       country='DE',
       state='Bavaria',
       max_pages=1,
   )
   print(result)
   ```

4. Or fetch the raw page directly:
   ```python
   import httpx
   headers = {'User-Agent': 'Mozilla/5.0 (compatible; WedAPI-Crawler/1.0)'}
   r = httpx.get('https://html.duckduckgo.com/html/?q=site%3Aweddyplace.com%2Fde+hochzeitslocation+Munich&kl=de-de', headers=headers, follow_redirects=True, timeout=15)
   print(r.status_code, len(r.text))
   # Inspect r.text to check if site structure changed
   ```

## What to check
- Zero reason recorded: no_vendor_objects_extracted: fetched 1 pages, parser found 0 objects
- Compare the current HTML/JSON structure against the connector's selectors
- Check the snapshot attached to this issue (if available) for the actual response
- Update the connector's CSS selectors, URL patterns, or JSON paths accordingly
- Re-run the scope to verify: `make crawl` or use the Admin → Crawl Runs → Run now button

## How to reproduce

1. Start the backend:
   ```
   docker compose up backend postgres redis -d
   ```

2. Open a Python shell:
   ```
   docker compose exec backend python
   ```

3. Run the connector directly:
   ```python
   from app.core.database import SessionLocal
   from app.services.connectors import bavariawedding
   from app.models.models import IngestionJob
   import uuid
   db = SessionLocal()
   job = IngestionJob(id=str(uuid.uuid4()), connector_name='debug', status='running')
   db.add(job); db.commit()
   result = bavariawedding.run_connector(
       db=db, job=job,
       category_slug='wedding-venue',
       city='Munich',
       country='DE',
       state='Bavaria',
       max_pages=1,
   )
   print(result)
   ```

4. Or fetch the raw page directly:
   ```python
   import httpx
   headers = {'User-Agent': 'Mozilla/5.0 (compatible; WedAPI-Crawler/1.0)'}
   r = httpx.get('https://www.bavariawedding.de/hochzeitslocations/munich/', headers=headers, follow_redirects=True, timeout=15)
   print(r.status_code, len(r.text))
   # Inspect r.text to check if site structure changed
   ```

## What to check
- Zero reason recorded: http_errors: 1/1 pages failed
- Compare the current HTML/JSON structure against the connector's selectors
- Check the snapshot attached to this issue (if available) for the actual response
- Update the connector's CSS selectors, URL patterns, or JSON paths accordingly
- Re-run the scope to verify: `make crawl` or use the Admin → Crawl Runs → Run now button

## How to reproduce

1. Start the backend:
   ```
   docker compose up backend postgres redis -d
   ```

2. Open a Python shell:
   ```
   docker compose exec backend python
   ```

3. Run the connector directly:
   ```python
   from app.core.database import SessionLocal
   from app.services.connectors import search_discovery
   from app.models.models import IngestionJob
   import uuid
   db = SessionLocal()
   job = IngestionJob(id=str(uuid.uuid4()), connector_name='debug', status='running')
   db.add(job); db.commit()
   result = search_discovery.run_connector(
       db=db, job=job,
       category_slug='wedding-photographer',
       city='Hamburg',
       country='DE',
       state=None,
       max_pages=1,
   )
   print(result)
   ```

4. Or fetch the raw page directly:
   ```python
   import httpx
   headers = {'User-Agent': 'Mozilla/5.0 (compatible; WedAPI-Crawler/1.0)'}
   r = httpx.get('https://html.duckduckgo.com/html/?q=hochzeitsfotograf+Hamburg&kl=de-de', headers=headers, follow_redirects=True, timeout=15)
   print(r.status_code, len(r.text))
   # Inspect r.text to check if site structure changed
   ```

## What to check
- Zero reason recorded: no_vendor_objects_extracted: fetched 1 pages, parser found 0 objects
- Compare the current HTML/JSON structure against the connector's selectors
- Check the snapshot attached to this issue (if available) for the actual response
- Update the connector's CSS selectors, URL patterns, or JSON paths accordingly
- Re-run the scope to verify: `make crawl` or use the Admin → Crawl Runs → Run now button

## How to reproduce

1. Start the backend:
   ```
   docker compose up backend postgres redis -d
   ```

2. Open a Python shell:
   ```
   docker compose exec backend python
   ```

3. Run the connector directly:
   ```python
   from app.core.database import SessionLocal
   from app.services.connectors import weddyplace
   from app.models.models import IngestionJob
   import uuid
   db = SessionLocal()
   job = IngestionJob(id=str(uuid.uuid4()), connector_name='debug', status='running')
   db.add(job); db.commit()
   result = weddyplace.run_connector(
       db=db, job=job,
       category_slug='wedding-photographer',
       city='Hamburg',
       country='DE',
       state=None,
       max_pages=1,
   )
   print(result)
   ```

4. Or fetch the raw page directly:
   ```python
   import httpx
   headers = {'User-Agent': 'Mozilla/5.0 (compatible; WedAPI-Crawler/1.0)'}
   r = httpx.get('https://html.duckduckgo.com/html/?q=site%3Aweddyplace.com%2Fde+hochzeitsfotograf+Hamburg&kl=de-de', headers=headers, follow_redirects=True, timeout=15)
   print(r.status_code, len(r.text))
   # Inspect r.text to check if site structure changed
   ```

## What to check
- Zero reason recorded: no_vendor_objects_extracted: fetched 1 pages, parser found 0 objects
- Compare the current HTML/JSON structure against the connector's selectors
- Check the snapshot attached to this issue (if available) for the actual response
- Update the connector's CSS selectors, URL patterns, or JSON paths accordingly
- Re-run the scope to verify: `make crawl` or use the Admin → Crawl Runs → Run now button

## How to reproduce

1. Start the backend:
   ```
   docker compose up backend postgres redis -d
   ```

2. Open a Python shell:
   ```
   docker compose exec backend python
   ```

3. Run the connector directly:
   ```python
   from app.core.database import SessionLocal
   from app.services.connectors import search_discovery
   from app.models.models import IngestionJob
   import uuid
   db = SessionLocal()
   job = IngestionJob(id=str(uuid.uuid4()), connector_name='debug', status='running')
   db.add(job); db.commit()
   result = search_discovery.run_connector(
       db=db, job=job,
       category_slug='wedding-photographer',
       city='Berlin',
       country='DE',
       state=None,
       max_pages=1,
   )
   print(result)
   ```

4. Or fetch the raw page directly:
   ```python
   import httpx
   headers = {'User-Agent': 'Mozilla/5.0 (compatible; WedAPI-Crawler/1.0)'}
   r = httpx.get('https://html.duckduckgo.com/html/?q=hochzeitsfotograf+Berlin&kl=de-de', headers=headers, follow_redirects=True, timeout=15)
   print(r.status_code, len(r.text))
   # Inspect r.text to check if site structure changed
   ```

## What to check
- Zero reason recorded: no_vendor_objects_extracted: fetched 1 pages, parser found 0 objects
- Compare the current HTML/JSON structure against the connector's selectors
- Check the snapshot attached to this issue (if available) for the actual response
- Update the connector's CSS selectors, URL patterns, or JSON paths accordingly
- Re-run the scope to verify: `make crawl` or use the Admin → Crawl Runs → Run now button

## How to reproduce

1. Start the backend:
   ```
   docker compose up backend postgres redis -d
   ```

2. Open a Python shell:
   ```
   docker compose exec backend python
   ```

3. Run the connector directly:
   ```python
   from app.core.database import SessionLocal
   from app.services.connectors import weddyplace
   from app.models.models import IngestionJob
   import uuid
   db = SessionLocal()
   job = IngestionJob(id=str(uuid.uuid4()), connector_name='debug', status='running')
   db.add(job); db.commit()
   result = weddyplace.run_connector(
       db=db, job=job,
       category_slug='wedding-photographer',
       city='Berlin',
       country='DE',
       state=None,
       max_pages=1,
   )
   print(result)
   ```

4. Or fetch the raw page directly:
   ```python
   import httpx
   headers = {'User-Agent': 'Mozilla/5.0 (compatible; WedAPI-Crawler/1.0)'}
   r = httpx.get('https://html.duckduckgo.com/html/?q=site%3Aweddyplace.com%2Fde+hochzeitsfotograf+Berlin&kl=de-de', headers=headers, follow_redirects=True, timeout=15)
   print(r.status_code, len(r.text))
   # Inspect r.text to check if site structure changed
   ```

## What to check
- Zero reason recorded: no_vendor_objects_extracted: fetched 1 pages, parser found 0 objects
- Compare the current HTML/JSON structure against the connector's selectors
- Check the snapshot attached to this issue (if available) for the actual response
- Update the connector's CSS selectors, URL patterns, or JSON paths accordingly
- Re-run the scope to verify: `make crawl` or use the Admin → Crawl Runs → Run now button

## How to reproduce

1. Start the backend:
   ```
   docker compose up backend postgres redis -d
   ```

2. Open a Python shell:
   ```
   docker compose exec backend python
   ```

3. Run the connector directly:
   ```python
   from app.core.database import SessionLocal
   from app.services.connectors import search_discovery
   from app.models.models import IngestionJob
   import uuid
   db = SessionLocal()
   job = IngestionJob(id=str(uuid.uuid4()), connector_name='debug', status='running')
   db.add(job); db.commit()
   result = search_discovery.run_connector(
       db=db, job=job,
       category_slug='wedding-photographer',
       city='Munich',
       country='DE',
       state='Bavaria',
       max_pages=1,
   )
   print(result)
   ```

4. Or fetch the raw page directly:
   ```python
   import httpx
   headers = {'User-Agent': 'Mozilla/5.0 (compatible; WedAPI-Crawler/1.0)'}
   r = httpx.get('https://html.duckduckgo.com/html/?q=hochzeitsfotograf+Munich&kl=de-de', headers=headers, follow_redirects=True, timeout=15)
   print(r.status_code, len(r.text))
   # Inspect r.text to check if site structure changed
   ```

## What to check
- Zero reason recorded: no_vendor_objects_extracted: fetched 1 pages, parser found 0 objects
- Compare the current HTML/JSON structure against the connector's selectors
- Check the snapshot attached to this issue (if available) for the actual response
- Update the connector's CSS selectors, URL patterns, or JSON paths accordingly
- Re-run the scope to verify: `make crawl` or use the Admin → Crawl Runs → Run now button

## How to reproduce

1. Start the backend:
   ```
   docker compose up backend postgres redis -d
   ```

2. Open a Python shell:
   ```
   docker compose exec backend python
   ```

3. Run the connector directly:
   ```python
   from app.core.database import SessionLocal
   from app.services.connectors import weddyplace
   from app.models.models import IngestionJob
   import uuid
   db = SessionLocal()
   job = IngestionJob(id=str(uuid.uuid4()), connector_name='debug', status='running')
   db.add(job); db.commit()
   result = weddyplace.run_connector(
       db=db, job=job,
       category_slug='wedding-photographer',
       city='Munich',
       country='DE',
       state='Bavaria',
       max_pages=1,
   )
   print(result)
   ```

4. Or fetch the raw page directly:
   ```python
   import httpx
   headers = {'User-Agent': 'Mozilla/5.0 (compatible; WedAPI-Crawler/1.0)'}
   r = httpx.get('https://html.duckduckgo.com/html/?q=site%3Aweddyplace.com%2Fde+hochzeitsfotograf+Munich&kl=de-de', headers=headers, follow_redirects=True, timeout=15)
   print(r.status_code, len(r.text))
   # Inspect r.text to check if site structure changed
   ```

## What to check
- Zero reason recorded: no_vendor_objects_extracted: fetched 1 pages, parser found 0 objects
- Compare the current HTML/JSON structure against the connector's selectors
- Check the snapshot attached to this issue (if available) for the actual response
- Update the connector's CSS selectors, URL patterns, or JSON paths accordingly
- Re-run the scope to verify: `make crawl` or use the Admin → Crawl Runs → Run now button

## How to reproduce

1. Start the backend:
   ```
   docker compose up backend postgres redis -d
   ```

2. Open a Python shell:
   ```
   docker compose exec backend python
   ```

3. Run the connector directly:
   ```python
   from app.core.database import SessionLocal
   from app.services.connectors import bavariawedding
   from app.models.models import IngestionJob
   import uuid
   db = SessionLocal()
   job = IngestionJob(id=str(uuid.uuid4()), connector_name='debug', status='running')
   db.add(job); db.commit()
   result = bavariawedding.run_connector(
       db=db, job=job,
       category_slug='wedding-photographer',
       city='Munich',
       country='DE',
       state='Bavaria',
       max_pages=1,
   )
   print(result)
   ```

4. Or fetch the raw page directly:
   ```python
   import httpx
   headers = {'User-Agent': 'Mozilla/5.0 (compatible; WedAPI-Crawler/1.0)'}
   r = httpx.get('https://www.bavariawedding.de/hochzeitsfotografen/munich/', headers=headers, follow_redirects=True, timeout=15)
   print(r.status_code, len(r.text))
   # Inspect r.text to check if site structure changed
   ```

## What to check
- Zero reason recorded: http_errors: 1/1 pages failed
- Compare the current HTML/JSON structure against the connector's selectors
- Check the snapshot attached to this issue (if available) for the actual response
- Update the connector's CSS selectors, URL patterns, or JSON paths accordingly
- Re-run the scope to verify: `make crawl` or use the Admin → Crawl Runs → Run now button