fix: untrack ignored files and refresh index

.claude/settings.json

@@ -0,0 +1,5 @@
+{
+  "permissions": {
+    "defaultMode": "bypassPermissions"
+  }
+}

.cursor

@@ -0,0 +1 @@
+Subproject commit 4bdbf57d981fec151554e5a23109906fe8c7eebf

Dockerfile

@@ -0,0 +1,36 @@
+# Ghost Node — Dockerfile
+# Builds a container for worker.py (FastAPI + Playwright + scraper engine).
+# Usage: docker compose up  (see docker-compose.yml)
+
+FROM python:3.11-slim
+
+# System deps for Playwright Chromium
+RUN apt-get update && apt-get install -y \
+    wget curl gnupg ca-certificates \
+    libglib2.0-0 libnss3 libnspr4 libdbus-1-3 \
+    libatk1.0-0 libatk-bridge2.0-0 libcups2 \
+    libdrm2 libxkbcommon0 libxcomposite1 libxdamage1 \
+    libxfixes3 libxrandr2 libgbm1 libasound2 \
+    fonts-liberation libpango-1.0-0 libpangocairo-1.0-0 \
+    --no-install-recommends && rm -rf /var/lib/apt/lists/*
+
+WORKDIR /app
+
+# Install Python deps first (cached layer)
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Install Playwright + Chromium browser
+RUN playwright install chromium && playwright install-deps chromium
+
+# Copy application files
+COPY worker.py models.py database.py dashboard.html ./
+
+# Copy pre-built Next.js static output if it exists (optional)
+COPY frontend/out ./frontend/out
+
+EXPOSE 7000
+
+ENV PYTHONUNBUFFERED=1
+
+CMD ["python", "worker.py"]

README.md

@@ -9,7 +9,7 @@ Telegram C2 command, and a cyber-terminal dashboard.
 
 ```
 worker.py
-├── Thread A  — FastAPI + Dashboard (port 8000)
+├── Thread A  — FastAPI + Dashboard (port 7000)
 ├── Thread B  — Async Playwright Scraper (nuclear_engine)
 └── Thread C  — Telegram C2 Command Listener
 ```
@@ -45,7 +45,7 @@ playwright install chromium
 python worker.py
 ```
 
-Then open: **http://localhost:8000**
+Then open: **http://localhost:7000**
 
 ---
 
@@ -55,6 +55,22 @@ Then open: **http://localhost:8000**
 2. **Keywords tab** — Your top search terms are pre-seeded (RTX 4090, Tab S10, etc.).
 3. **Target Sites tab** — eBay UK and eBay US are pre-seeded with `{keyword}` templates.
 4. The engine starts automatically — watch the Dashboard for live stats.
+5. Optional resilience features — per-site visible override (`custom_visible_browser`, ignored when global `show_browser=true`) plus keyword batching with pinned “Keyword Retry Tracking” in the dashboard.
+
+---
+
+## Retry Tracking Mechanics
+
+- Per-site visibility precedence:
+  - `show_browser=true` forces visible mode for all sites and ignores per-site `custom_visible_browser`.
+  - `show_browser=false` applies per-site visibility (`custom_visible_browser=1` visible, `0` headless).
+- Keyword batching is controlled by `keyword_batch_enabled`.
+- Persistent retry state is stored in `scrape_rounds` + `scrape_round_items` with statuses:
+  `pending`, `in_progress`, `done`, `failed`.
+- Pending retries have a 4-hour window per active round; expired pending/in-progress items are marked failed.
+- The dashboard "Keyword Retry Tracking" section is sourced from `GET /api/scrape/progress`.
+  - Pinned items are pending retries with `attempt_count > 0`.
+  - Hourly warning due-state is returned as `warn_due` using `last_hour_warn_at` fallback logic (`first_pending_at`, then round start).
 
 ---
 

backend_tests/test_scrape_progress.py

@@ -0,0 +1,341 @@
+import os
+import tempfile
+import unittest
+from datetime import datetime, timedelta
+
+
+def _make_temp_sqlite_url() -> str:
+    tmp = tempfile.NamedTemporaryFile(prefix="ghostnode_", suffix=".db", delete=False)
+    path = tmp.name
+    tmp.close()
+    # SQLAlchemy on Windows expects forward slashes in sqlite URLs.
+    norm = path.replace("\\", "/")
+    return f"sqlite:///{norm}"
+
+
+_DB_URL = _make_temp_sqlite_url()
+os.environ["DATABASE_URL"] = _DB_URL
+
+
+# IMPORTANT: import app/models AFTER DATABASE_URL is set.
+from fastapi.testclient import TestClient  # noqa: E402
+
+import worker  # noqa: E402
+from database import SessionLocal  # noqa: E402
+from models import (  # noqa: E402
+    Config,
+    Keyword,
+    ScrapeRound,
+    ScrapeRoundItem,
+    TargetSite,
+    Listing,
+)
+
+
+class ScrapeProgressEndpointTests(unittest.TestCase):
+    @classmethod
+    def setUpClass(cls) -> None:
+        cls.client = TestClient(worker.app)
+
+        db = SessionLocal()
+        try:
+            # Force keyword batching mode so the endpoint returns keyword_batch_enabled=true.
+            cfg = db.query(Config).filter(Config.key == "keyword_batch_enabled").first()
+            if cfg:
+                cfg.value = "true"
+            else:
+                db.add(Config(key="keyword_batch_enabled", value="true"))
+
+            # Create dedicated keywords so assertions can match by term.
+            kw_due = Keyword(term="TEST_DUE_KEYWORD", weight=1, sort_order=999001)
+            kw_not_due = Keyword(term="TEST_RETRY_KEYWORD", weight=1, sort_order=999002)
+            kw_zero_attempt = Keyword(term="TEST_ZERO_ATTEMPT_KEYWORD", weight=1, sort_order=999003)
+            db.add_all([kw_due, kw_not_due, kw_zero_attempt])
+            db.flush()
+
+            # Use any existing seeded site (or create one if empty).
+            site = db.query(TargetSite).order_by(TargetSite.id.asc()).first()
+            if site is None:
+                site = TargetSite(
+                    name="TEST_SITE",
+                    url_template="https://example.com/?q={keyword}",
+                    search_selector="",
+                    enabled=1,
+                    max_pages=1,
+                    sort_order=0,
+                )
+                db.add(site)
+                db.flush()
+
+            now = datetime.now()
+            cls._round_started_at = now - timedelta(hours=2)
+            round_row = ScrapeRound(started_at=cls._round_started_at, status="active")
+            db.add(round_row)
+            db.flush()
+            cls._round_id = round_row.id
+
+            # Warn due: base >= 1 hour ago -> warn_due should be True.
+            due_item = ScrapeRoundItem(
+                round_id=cls._round_id,
+                site_id=site.id,
+                keyword_id=kw_due.id,
+                status="pending",
+                attempt_count=1,
+                first_pending_at=now - timedelta(minutes=90),
+                last_attempt_at=now - timedelta(minutes=10),
+                last_hour_warn_at=now - timedelta(hours=2),
+                last_error=None,
+            )
+
+            # Not due: base < 1 hour ago -> warn_due should be False.
+            retry_item = ScrapeRoundItem(
+                round_id=cls._round_id,
+                site_id=site.id,
+                keyword_id=kw_not_due.id,
+                status="pending",
+                attempt_count=2,
+                first_pending_at=now - timedelta(minutes=30),
+                last_attempt_at=now - timedelta(minutes=20),
+                last_hour_warn_at=None,
+                last_error=None,
+            )
+
+            # attempt_count == 0 must be excluded from pending_items.
+            zero_attempt_item = ScrapeRoundItem(
+                round_id=cls._round_id,
+                site_id=site.id,
+                keyword_id=kw_zero_attempt.id,
+                status="pending",
+                attempt_count=0,
+                first_pending_at=now - timedelta(hours=2),
+                last_attempt_at=None,
+                last_hour_warn_at=now - timedelta(hours=2),
+                last_error=None,
+            )
+
+            db.add_all([due_item, retry_item, zero_attempt_item])
+
+            # Seed listings for countdown-sync endpoint.
+            # (No listings are seeded by default seed_database().)
+            now2 = datetime.now()
+            listing_with_price = Listing(
+                title="TEST_LISTING_WITH_PRICE_UPDATED_AT",
+                link="https://example.com/listing-with-price-updated-at",
+                price=100.0,
+                currency="USD",
+                price_raw="$100",
+                time_left="12h",
+                time_left_mins=12.5,
+                price_updated_at=now2 - timedelta(minutes=5),
+                score=0,
+                keyword="kw",
+                site_name=site.name,
+                timestamp=now2 - timedelta(minutes=6),
+                closing_alerts_sent="[]",
+                images="[]",
+                description="",
+            )
+            listing_without_price = Listing(
+                title="TEST_LISTING_NO_PRICE_UPDATED_AT",
+                link="https://example.com/listing-no-price-updated-at",
+                price=None,
+                currency="USD",
+                price_raw="",
+                time_left="7h",
+                time_left_mins=7.0,
+                price_updated_at=None,
+                score=0,
+                keyword="kw",
+                site_name=site.name,
+                timestamp=now2 - timedelta(minutes=9),
+                closing_alerts_sent="[]",
+                images="[]",
+                description="",
+            )
+            db.add_all([listing_with_price, listing_without_price])
+            db.commit()
+
+            cls._listing_with_price_id = listing_with_price.id
+            cls._listing_without_price_id = listing_without_price.id
+            cls._last_price_update_iso = (
+                listing_with_price.price_updated_at.isoformat()
+                if listing_with_price.price_updated_at
+                else None
+            )
+
+            cls._expected_enabled_count = db.query(TargetSite).filter(TargetSite.enabled == 1).count()
+
+        finally:
+            db.close()
+
+    @classmethod
+    def tearDownClass(cls) -> None:
+        # Best-effort cleanup.
+        try:
+            # DATABASE_URL points to temp db file.
+            if _DB_URL.startswith("sqlite:///"):
+                db_path = _DB_URL.replace("sqlite:///", "", 1)
+                if db_path and os.path.exists(db_path):
+                    os.remove(db_path)
+        except Exception:
+            pass
+
+    def test_progress_returns_warn_due_and_filters_zero_attempt(self) -> None:
+        res = self.client.get("/api/scrape/progress")
+        self.assertEqual(res.status_code, 200)
+        data = res.json()
+
+        self.assertEqual(data["keyword_batch_enabled"], True)
+        self.assertIsNotNone(data["active_round"])
+        self.assertEqual(data["active_round"]["id"], self._round_id)
+
+        items = data["pending_items"]
+        # attempt_count==0 is excluded
+        self.assertEqual(len(items), 2)
+
+        kw_terms = {it["keyword_term"]: it for it in items}
+        self.assertIn("TEST_DUE_KEYWORD", kw_terms)
+        self.assertIn("TEST_RETRY_KEYWORD", kw_terms)
+        self.assertNotIn("TEST_ZERO_ATTEMPT_KEYWORD", kw_terms)
+
+        self.assertTrue(kw_terms["TEST_DUE_KEYWORD"]["warn_due"])
+        self.assertFalse(kw_terms["TEST_RETRY_KEYWORD"]["warn_due"])
+
+    def test_progress_returns_no_active_round(self) -> None:
+        # Temporarily mark the active round as finished.
+        db = SessionLocal()
+        try:
+            round_row = db.query(ScrapeRound).filter(ScrapeRound.id == self._round_id).first()
+            self.assertIsNotNone(round_row)
+            round_row.status = "finished"
+            db.flush()
+            db.commit()
+
+            res = self.client.get("/api/scrape/progress")
+            self.assertEqual(res.status_code, 200)
+            data = res.json()
+
+            self.assertIsNone(data["active_round"])
+            self.assertEqual(data["pending_items"], [])
+        finally:
+            # Restore active status so tests won't interfere if order changes.
+            try:
+                db2 = SessionLocal()
+                try:
+                    round_row = db2.query(ScrapeRound).filter(ScrapeRound.id == self._round_id).first()
+                    if round_row:
+                        round_row.status = "active"
+                        db2.flush()
+                        db2.commit()
+                finally:
+                    db2.close()
+            finally:
+                db.close()
+
+    def test_stats_endpoint_shape(self) -> None:
+        res = self.client.get("/api/stats")
+        self.assertEqual(res.status_code, 200)
+        data = res.json()
+
+        # Ensure core keys exist and types are reasonable.
+        self.assertIn("uptime_seconds", data)
+        self.assertIsInstance(data["uptime_seconds"], int)
+        self.assertIn("engine_status", data)
+        self.assertIn("total_scanned", data)
+        self.assertIn("total_alerts", data)
+        self.assertIn("last_cycle", data)
+        self.assertIn("uptime_start", data)
+
+    def test_countdown_sync_returns_time_left_mins_and_iso_timestamps(self) -> None:
+        res = self.client.get("/api/listings/countdown-sync")
+        self.assertEqual(res.status_code, 200)
+        items = res.json()
+
+        by_id = {it["id"]: it for it in items}
+        self.assertIn(self._listing_with_price_id, by_id)
+        self.assertIn(self._listing_without_price_id, by_id)
+
+        with_price = by_id[self._listing_with_price_id]
+        self.assertAlmostEqual(with_price["time_left_mins"], 12.5, places=1)
+        self.assertIsNotNone(with_price["price_updated_at"])
+        self.assertIsNotNone(with_price["timestamp"])
+
+        without_price = by_id[self._listing_without_price_id]
+        self.assertAlmostEqual(without_price["time_left_mins"], 7.0, places=1)
+        self.assertIsNone(without_price["price_updated_at"])
+        self.assertIsNotNone(without_price["timestamp"])
+
+    def test_refresh_status_returns_last_price_update_and_listing_count(self) -> None:
+        res = self.client.get("/api/listings/refresh-status")
+        self.assertEqual(res.status_code, 200)
+        data = res.json()
+
+        self.assertEqual(data["listing_count"], 2)
+        self.assertEqual(data["last_price_update"], self._last_price_update_iso)
+
+    def test_sites_endpoint_returns_int_flags(self) -> None:
+        res = self.client.get("/api/sites")
+        self.assertEqual(res.status_code, 200)
+        sites = res.json()
+        self.assertTrue(isinstance(sites, list))
+        self.assertGreater(len(sites), 0)
+
+        for s in sites:
+            # These must be numeric flags (0/1), not JSON booleans.
+            self.assertIn(s["enabled"], (0, 1))
+            self.assertIn(s["custom_visible_browser"], (0, 1))
+            self.assertIn(s["requires_login"], (0, 1))
+            self.assertIn(s["login_enabled"], (0, 1))
+
+            # Ensure types are not JSON booleans.
+            self.assertIs(type(s["enabled"]), int)
+            self.assertIs(type(s["custom_visible_browser"]), int)
+            self.assertIs(type(s["requires_login"]), int)
+            self.assertIs(type(s["login_enabled"]), int)
+
+    def test_enabled_count_matches_db(self) -> None:
+        res = self.client.get("/api/sites/enabled-count")
+        self.assertEqual(res.status_code, 200)
+        data = res.json()
+        self.assertEqual(data["count"], self._expected_enabled_count)
+
+    def test_config_get_returns_flat_string_dict(self) -> None:
+        res = self.client.get("/api/config")
+        self.assertEqual(res.status_code, 200)
+        data = res.json()
+
+        self.assertIsInstance(data, dict)
+        self.assertNotIsInstance(data, list)
+
+        # Seeded by seed_database(); value must be a string.
+        self.assertIn("keyword_batch_enabled", data)
+        self.assertIsInstance(data["keyword_batch_enabled"], str)
+
+    def test_config_post_upserts_flat_dict_values_as_strings(self) -> None:
+        key_a = "__TEST_CFG_A"
+        key_b = "__TEST_CFG_B"
+
+        res = self.client.post(
+            "/api/config",
+            json={key_a: "1", key_b: "abc"},
+        )
+        self.assertEqual(res.status_code, 200)
+        body = res.json()
+        self.assertEqual(body["status"], "saved")
+        self.assertIn(key_a, body["keys"])
+        self.assertIn(key_b, body["keys"])
+
+        after = self.client.get("/api/config").json()
+        self.assertEqual(after[key_a], "1")
+        self.assertEqual(after[key_b], "abc")
+
+        # Upsert (update existing key).
+        res2 = self.client.post("/api/config", json={key_a: "2"})
+        self.assertEqual(res2.status_code, 200)
+
+        after2 = self.client.get("/api/config").json()
+        self.assertEqual(after2[key_a], "2")
+
+if __name__ == "__main__":
+    unittest.main()
+

check_config.ps1

@@ -1,3 +1,3 @@
-$resp = (Invoke-WebRequest -Uri 'http://localhost:8000/api/config' -UseBasicParsing).Content | ConvertFrom-Json
+$resp = (Invoke-WebRequest -Uri 'http://localhost:7000/api/config' -UseBasicParsing).Content | ConvertFrom-Json
 $keys = @('scoring_enabled','scrape_window_enabled','boost_interval_mins','ai_filter_enabled')
 $resp | Where-Object { $_.key -in $keys } | ConvertTo-Json

docker-compose.yml

@@ -0,0 +1,75 @@
+# Ghost Node — Docker Compose
+# One-command startup: docker compose up -d
+#
+# Services:
+#   ghostnode  — FastAPI + Playwright scraper (port 7000)
+#   postgres   — PostgreSQL 16 database
+#   redis      — Redis 7 cache + pub/sub
+#
+# First run: docker compose up --build
+# Stop:      docker compose down
+# Logs:      docker compose logs -f ghostnode
+# Shell:     docker compose exec ghostnode bash
+
+services:
+
+  ghostnode:
+    build: .
+    container_name: ghostnode
+    restart: unless-stopped
+    ports:
+      - "7000:7000"
+    environment:
+      # PostgreSQL — replaces SQLite when set
+      DATABASE_URL: postgresql://ghostnode:ghostnode@postgres:5432/ghostnode
+      # Redis — enables cache + pub/sub
+      REDIS_URL: redis://redis:6379/0
+      # Optional: pass Telegram token here instead of via Settings UI
+      # TELEGRAM_TOKEN: ""
+    depends_on:
+      postgres:
+        condition: service_healthy
+      redis:
+        condition: service_healthy
+    volumes:
+      # Persist browser session cookies between restarts
+      - ghostnode_sessions:/app/sessions
+    shm_size: 512mb   # Chromium needs shared memory
+
+  postgres:
+    image: postgres:16-alpine
+    container_name: ghostnode_postgres
+    restart: unless-stopped
+    environment:
+      POSTGRES_DB: ghostnode
+      POSTGRES_USER: ghostnode
+      POSTGRES_PASSWORD: ghostnode
+    volumes:
+      - postgres_data:/var/lib/postgresql/data
+    healthcheck:
+      test: ["CMD-SHELL", "pg_isready -U ghostnode -d ghostnode"]
+      interval: 5s
+      timeout: 5s
+      retries: 10
+    ports:
+      - "5432:5432"   # expose for local tools (pgAdmin, DBeaver)
+
+  redis:
+    image: redis:7-alpine
+    container_name: ghostnode_redis
+    restart: unless-stopped
+    command: redis-server --appendonly yes --maxmemory 128mb --maxmemory-policy allkeys-lru
+    volumes:
+      - redis_data:/data
+    healthcheck:
+      test: ["CMD", "redis-cli", "ping"]
+      interval: 5s
+      timeout: 3s
+      retries: 10
+    ports:
+      - "6379:6379"   # expose for local Redis clients
+
+volumes:
+  postgres_data:
+  redis_data:
+  ghostnode_sessions:

docs/AI_WEB_BRIEF.md

@@ -173,8 +173,14 @@ Use these as bullet points / feature cards.
    - Telegram bot, Discord webhook, Gmail email integration.
    - Multi‑interval closing alerts (e.g. 60, 30, 10, 5 minutes before close).
 
-6. **Redis & Docker‑ready architecture (roadmap / partially implemented)**
-   - Designed to support Redis cache/queue and Docker Compose deployment.
+6. **Keyword batching & retry tracking (with per-site visibility override)**
+  - Processes multiple keywords per site in parallel tabs and keeps (site, keyword) progress across cycles via `scrape_round_items`.
+  - Uses `scrape_rounds` + `scrape_round_items` statuses (`pending`, `in_progress`, `done`, `failed`) with a 4-hour retry window per active round.
+  - Dashboard pins “Keyword Retry Tracking” for pending retries, including hourly warnings and a 4-hour retry window.
+  - `show_browser=true` forces visible mode for all sites and ignores per-site `custom_visible_browser`; `show_browser=false` applies per-site visibility.
+  - Dashboard source of truth is `GET /api/scrape/progress`; hourly `warn_due` uses `last_hour_warn_at` fallback logic (`first_pending_at`, then round start).
+7. **Redis & Docker‑ready architecture (roadmap / partially implemented)**
+  - Designed to support Redis cache/queue and Docker Compose deployment.
 
 ---
 

docs/CLAUDE.md

@@ -2,7 +2,7 @@
 
 > **Read this first at the start of every session.**
 > This file is the single source of truth for project context, architecture, and rules.
-> Last updated: 2026-03-12 (Session 20b — /legacy routing fix, MD restructure)
+> Last updated: 2026-03-18 (Session 33 — per-site visible browser override + keyword batching progress tracking)
 
 ---
 
@@ -11,8 +11,8 @@
 - **Version:** v2.7 | **Status:** ✅ Fully operational — 21/21 tests passing
 - **Frontend:** Next.js (React 19 + Tailwind v4) — static build at `frontend/out/`, served by FastAPI
 - **Last session:** 27 (2026-03-13) — Premium frontend redesign: ambient background, glassmorphism, gradient glow cards, Framer Motion animations, badge system
-- **Next priority:** Redis Cache Layer → Docker Compose → Lot Description Extraction
-- **URLs:** `http://localhost:8000` (React UI) | `http://localhost:8000/legacy` (old HTML dashboard)
+- **Next priority:** Frontend polish → Docker testing → vLLM production inference
+- **URLs:** `http://localhost:7000` (React UI) | `http://localhost:7000/legacy` (old HTML dashboard)
 
 ---
 
@@ -28,9 +28,9 @@
 7. **ARCHIVE.md** — sessions 1–14. Do NOT load at session start. Open only if asked about old history.
 
 ### How to Run the Program
-1. `python worker.py` — starts all 5 threads, FastAPI on port 8000
-2. Visit `http://localhost:8000` — new React dashboard
-3. Visit `http://localhost:8000/legacy` — old HTML dashboard (always available as fallback)
+1. `python worker.py` — starts all 5 threads, FastAPI on port 7000
+2. Visit `http://localhost:7000` — new React dashboard
+3. Visit `http://localhost:7000/legacy` — old HTML dashboard (always available as fallback)
 4. To build/test frontend: use Node.js (default installer path `C:\Program Files\nodejs\` — usually on PATH). If using portable Node instead, set PATH first:
    - PowerShell: `$env:PATH = "C:\Program Files\nodejs;$env:PATH"` (installer) or `$env:PATH = "C:\Users\Abbas\AppData\Local\nodejs-portable\node-v22.14.0-win-x64;$env:PATH"` (portable)
    - Bash: `export PATH="/c/Program Files/nodejs:$PATH"` or portable path as before
@@ -92,7 +92,7 @@ You are the **lead developer** continuing Ghost Node. Abbas is the project owner
 
 ```
 worker.py
-├── Thread A  — FastAPI + Dashboard (port 8000) — 42 REST endpoints
+├── Thread A  — FastAPI + Dashboard (port 7000) — 42 REST endpoints
 ├── Thread B  — nuclear_engine() — Async Playwright scraper loop (N8 window + boost)
 ├── Thread C  — telegram_c2_loop() — polls getUpdates every 3s
 ├── Thread D  — price_refresh_loop() — revisits lot URLs every 5min
@@ -148,13 +148,15 @@ Listing:      id, title, price (Float), currency, price_raw, time_left, time_lef
               price_updated_at, link (unique), score, keyword, site_name, timestamp,
               ai_match (Integer: 1=match, 0=rejected, NULL=not analysed), ai_reason (String 200),
               location (String 200), price_usd (Float), closing_alerts_sent (Text — JSON list),
-              images (Text — JSON array of image URLs, 0–10; NULL if none found)
+              images (Text — JSON array of image URLs, 0–10; NULL if none found),
+              description (Text — full lot description from detail page, max 1500 chars; NULL if not extracted)
 Keyword:      id, term (unique), weight (score multiplier), ai_target (Text — natural-language filter),
               min_price (Float), max_price (Float), sort_order (Integer)
 Config:       id, key (unique), value
 TargetSite:   id, name, url_template, search_selector, enabled (int 0/1), max_pages,
               last_error, error_count, consecutive_failures, last_success_at, cooldown_until,
-              requires_login, login_url, login_check_selector, login_enabled, sort_order (Integer)
+              requires_login, login_url, login_check_selector, login_enabled, sort_order (Integer),
+              custom_visible_browser (Integer 0/1 — visible override when global show_browser=false)
 SiteSelectors: id, site_id (unique FK), container_sel, title_sel, price_sel, time_sel, link_sel,
               next_page_sel, confidence (Float 0-100), container_count, title_rate, price_rate,
               provider (groq|ollama), generated_at, last_tested_at, stale (Bool), notes (Text)
@@ -162,6 +164,11 @@ ScoringRule:  id, signal (String 100), delta (Integer — positive=boost, negati
               category (String 50 — "positive"|"negative"|"custom"), notes (Text)
               Seeded from hardcoded lists on first startup. calculate_attribute_score() queries this table.
               Bypassed entirely when scoring_enabled=false (AI-first mode).
+
+ScrapeRound:      id, started_at, finished_at, status (active|finished)
+ScrapeRoundItem:  round_id, site_id, keyword_id, status (pending|in_progress|done|failed),
+                  attempt_count, first_pending_at, last_attempt_at, last_error,
+                  last_hour_warn_at
 ```
 
 ---
@@ -175,7 +182,8 @@ ScoringRule:  id, signal (String 100), delta (Integer — positive=boost, negati
 | `timer` | Seconds between scrape cycles (default 120) |
 | `browser_choice` | `auto` \| `edge` \| `yandex` \| `chrome` \| `brave` \| `chromium` |
 | `incognito_mode` | `true` \| `false` |
-| `show_browser` | `true` \| `false` |
+| `show_browser` | `true` \| `false` — when `show_browser=true`, visible mode is forced for all sites and per-site `custom_visible_browser` is ignored |
+| `keyword_batch_enabled` | `true` \| `false` — enables per-site keyword batching + persistent retry tracking |
 | `delay_launch` | Seconds after browser opens |
 | `delay_site_open` | Seconds after homepage loads |
 | `delay_post_search` | Seconds after results page loads |
@@ -210,7 +218,7 @@ ScoringRule:  id, signal (String 100), delta (Integer — positive=boost, negati
 
 ---
 
-## All 42 API Endpoints
+## All API Endpoints
 
 | Method | Path | Purpose |
 |---|---|---|
@@ -249,9 +257,11 @@ ScoringRule:  id, signal (String 100), delta (Integer — positive=boost, negati
 | GET | `/api/export/csv` | Download all listings as CSV |
 | GET | `/api/export/json` | Download all listings as JSON |
 | GET | `/api/export/html` | Download cyberpunk HTML report |
+| GET | `/api/redis/status` | Redis connectivity check + cached stats hash |
 | GET | `/api/debug/db` | Raw DB dump for diagnostics |
 | GET | `/api/backup/download` | Download timestamped `.db` backup |
 | POST | `/api/backup/restore` | Upload `.db` file to restore |
+| GET | `/api/scrape/progress` | Source of truth for dashboard "Keyword Retry Tracking": pinned pending retries (`attempt_count>0`), counts, round deadline timing, and hourly `warn_due` derived from `last_hour_warn_at` fallback logic |
 | GET | `/api/scoring-rules` | All scoring rules (N6) |
 | POST | `/api/scoring-rules` | Add rule `{signal, delta, notes}` (N6) |
 | PUT | `/api/scoring-rules/{id}` | Update rule signal/delta/notes (N6) |

docs/GHOST_NODE_TECHNOLOGY_BLUEPRINT.md

@@ -659,7 +659,8 @@ If I were the AI CEO of Ghost Node, given full autonomy, here is every feature I
 25. **Monitoring Stack** — Prometheus + Grafana for system metrics (CPU, memory, scrape times, error rates).
 26. **S3/MinIO Image Storage** — store scraped lot images locally or in cloud object storage instead of just URLs.
 27. **WebSocket Real-Time** — replace polling with WebSocket connections for instant UI updates when new lots are captured.
-28. **Rate Limit Engine** — intelligent per-site rate limiting that backs off when CAPTCHAs appear and speeds up when sites are quiet.
+28. **Rate Limit Engine** — intelligent per-site rate limiting that backs off when CAPTCHAs appear and speeds up when sites are quiet, with resilient recovery via per-site visibility override and per-keyword retry tracking.
+29. **Current retry-tracking baseline (already implemented)** — `show_browser=true` forces visible mode for all sites and ignores per-site `custom_visible_browser`; keyword batching uses `keyword_batch_enabled` + `scrape_rounds`/`scrape_round_items` (`pending|in_progress|done|failed`) with a 4-hour retry window; dashboard pinned "Keyword Retry Tracking" is sourced from `GET /api/scrape/progress`, where hourly `warn_due` uses `last_hour_warn_at` fallback logic (`first_pending_at`, then round start).
 
 ---
 

docs/MD_UPDATE_PLAYBOOK.md

@@ -0,0 +1,163 @@
+# Ghost Node — MD Update Playbook
+
+## Purpose
+This file is a reusable, copy-paste workflow for the task:
+- Deep semantic audit of **every** `*.md` file in the repo (no exceptions)
+- Update **only** the Markdown files that are missing or contradicting current program behavior
+- Keep edits minimal, accuracy-first, and safe
+
+Use this when you want to avoid manually re-verifying documentation for “browser visibility override” and “keyword batching + retry tracking” mechanics.
+
+---
+
+## Mechanics that this playbook must cover
+### Per-site browser visibility override
+- `TargetSite.custom_visible_browser` (0/1)
+- Precedence rule:
+  - When global `show_browser=true`, visible mode is forced for all sites
+  - In that case, per-site `custom_visible_browser` is ignored
+  - When global `show_browser=false`, a site becomes visible only if `custom_visible_browser=1`
+
+### Keyword batching + persistent retry tracking
+- `keyword_batch_enabled`
+- `scrape_rounds` and `scrape_round_items`
+- `ScrapeRoundItem` statuses: `pending | in_progress | done | failed`
+- Pending retry window: **4 hours**
+- Hourly warning bookkeeping:
+  - `last_hour_warn_at`
+  - dashboard “due” logic (doc must not contradict UI)
+
+### Dashboard behavior
+- Pinned/section UI named **“Keyword Retry Tracking”**
+- Pinned content is sourced from:
+  - `GET /api/scrape/progress`
+
+---
+
+## Strict editing constraints
+1. Only edit Markdown files (`*.md`).
+2. Do NOT change any code files.
+3. Do NOT “regenerate from scratch”.
+4. Only edit files when the semantic audit finds missing or contradictory content.
+5. Prefer minimal wording changes (small patch, keep structure).
+6. Use a verification pass by searching for required terms/endpoint names.
+
+---
+
+## Required output format (when you run this job)
+1. **Doc audit findings**
+   - For each `*.md` file:
+     - `OK` if already correct
+     - otherwise 1–3 bullets describing what was missing or wrong
+2. **Approval gate**
+   - Ask for approval before applying edits:
+     - “Reply `YES` to apply the listed changes”
+3. **Applied edits** (only after approval)
+   - For each modified file, include small excerpt(s) of the updated sections
+4. **Verification checklist**
+   - Confirm these terms/behaviors are present and consistent in modified files:
+     - `custom_visible_browser`
+     - `show_browser=true` precedence vs per-site override
+     - `keyword_batch_enabled`
+     - `scrape_round_items`
+     - “Keyword Retry Tracking”
+     - `GET /api/scrape/progress`
+
+---
+
+## Copy-paste prompt (TEXT)
+You are a documentation editor for the Ghost Node repo. I only want updates to Markdown files (`*.md`) and ONLY when the Markdown is missing or contradicting current program behavior.
+
+### Goal
+Perform a deep semantic audit across **all Markdown files in the repo** and update ONLY the MD files that are missing relevant documentation for the latest mechanics:
+- Per-site browser visibility override: `TargetSite.custom_visible_browser` (0/1)
+- Precedence rule: **global `show_browser=true` forces visible mode for all sites** and **ignores** per-site `custom_visible_browser`
+- Keyword batching + persistent retry tracking across cycles:
+  - `keyword_batch_enabled`
+  - `scrape_rounds`, `scrape_round_items`
+  - pending/in_progress/done/failed keyword items
+  - 4-hour retry window for pending items
+  - hourly warnings bookkeeping (`last_hour_warn_at`, `warn_due`)
+- Dashboard behavior:
+  - there is a pinned/section UI named **“Keyword Retry Tracking”**
+  - pinned content is sourced from **`GET /api/scrape/progress`**
+
+### Strict rules
+1. Enumerate every `*.md` file in the repo recursively and check for relevance.
+2. If a given MD file already contains correct info, do not change it.
+3. If it is missing sections about the mechanics above, add short accurate documentation.
+4. If it contains outdated/contradicting text, update the wording to match current behavior.
+5. Do not “regenerate from scratch”. Use minimal edits.
+6. Do not edit code files. Only `*.md`.
+7. After completing edits, update only the affected MD files.
+8. After edits, run a verification pass using keyword searches to confirm:
+   - `custom_visible_browser`
+   - `show_browser=true` precedence vs per-site override
+   - `keyword_batch_enabled`
+   - `scrape_round_items`
+   - “Keyword Retry Tracking”
+   - `GET /api/scrape/progress`
+
+### Output format
+1. First, list “Doc audit findings”:
+   - For each changed file: what was missing or wrong (1–3 bullets)
+   - For each unchanged file that was checked but already correct: mention “OK”
+2. Second, list “Applied edits”:
+   - For each modified file: show the updated section as a small excerpt
+3. Third, list “Verification checklist”:
+   - confirm that all key terms/behaviors appear where expected.
+
+### Work constraints
+- Prefer reading authoritative docs first (`docs/CLAUDE.md`, `docs/PROGRESS.md`, `docs/MEMORY.md`).
+- Only read `worker.py` sections if needed to resolve ambiguity.
+- Only proceed with edits after identifying which MD files are actually missing/incorrect.
+
+---
+
+## Copy-paste prompt (JSON)
+```json
+{
+  "task": "Deep semantic audit and minimal update of ALL Markdown docs for Ghost Node",
+  "scope": {
+    "include_glob": ["**/*.md"],
+    "no_exceptions": true
+  },
+  "edits": {
+    "allowed_file_types": ["*.md"],
+    "disallowed": ["any code files", "non-markdown files"],
+    "minimal_changes": true,
+    "no_regeneration_from_scratch": true,
+    "only_change_when_needed": true,
+    "do_not_touch_correct_files": true
+  },
+  "mechanics_semantic_targets": [
+    "TargetSite.custom_visible_browser (0/1) per-site visibility override",
+    "Precedence: global show_browser=true forces visible mode for all sites and ignores custom_visible_browser",
+    "keyword_batch_enabled config behavior",
+    "scrape_rounds + scrape_round_items persistent retry tracking",
+    "ScrapeRoundItem statuses: pending/in_progress/done/failed",
+    "Retry window: 4-hour limit for pending keyword retries",
+    "Hourly warnings: last_hour_warn_at and warn_due logic documented",
+    "Dashboard pinned UI: 'Keyword Retry Tracking' sourced from GET /api/scrape/progress"
+  ],
+  "approval_gate": {
+    "required_before_edits": true,
+    "approval_keyword": "YES"
+  },
+  "verification_must_appear_in_modified_files": [
+    "custom_visible_browser",
+    "show_browser=true precedence",
+    "keyword_batch_enabled",
+    "scrape_round_items",
+    "Keyword Retry Tracking",
+    "GET /api/scrape/progress"
+  ],
+  "required_output_format": [
+    "Doc audit findings (OK vs missing/wrong)",
+    "Ask for approval",
+    "Applied edits (small excerpts only)",
+    "Verification checklist"
+  ]
+}
+```
+

docs/MEMORY.md

@@ -17,7 +17,7 @@
 - Ghost Node International Auction Sniper v2.7
 - Owner: Abbas, Baghdad, Iraq
 - Path: `C:\Users\Abbas\Documents\Downloads\ClaudeAuction2\`
-- Backend: Python FastAPI (worker.py, 5000+ lines), port 8000
+- Backend: Python FastAPI (worker.py, 5000+ lines), port 7000
 - NOT a git repository
 
 ---
@@ -33,7 +33,7 @@
 
 ### Key Architecture Decisions
 - SSE route disabled for static build (`app/api/stream/route.ts.disabled`)
-- All API files use `http://localhost:8000` as BASE (full URL, not relative)
+- All API files use `http://localhost:7000` as BASE (full URL, not relative)
 - FastAPI serves Next.js static build when `frontend/out/` exists
 - `if _frontend_out.exists():` guard is safe — `dashboard.html` still works without out/ dir
 - **SPA routing**: `app.mount("/_next", ...)` for assets only + `@app.get("/{full_path:path}")` catch-all for SPA routing. Never use `app.mount("/", StaticFiles(html=True))` — it shadows all explicit routes
@@ -87,7 +87,7 @@ frontend/
 ### Common Commands
 ```bash
 # Start backend
-python worker.py                          # port 8000
+python worker.py                          # port 7000
 
 # Frontend build (from project root)
 export PATH="..." && npm run build --prefix frontend
@@ -109,6 +109,9 @@ export PATH="..." && cd frontend && npx vitest run && npm run build
 - **JS in f-strings**: Use backtick template literals, never apostrophes — breaks Python f-string parsing
 - **`db.flush()` before `db.commit()`**: SQLite WAL locking requires this
 - **`calculate_attribute_score()` opens own DB session** — don't call inside an already-open session loop
+- **Keyword batching retry warnings**: the dashboard pins only retry candidates with `attempt_count > 0` via `/api/scrape/progress` (queued-but-never-attempted items stay hidden until first failure).
+- **Per-site visible override precedence**: `show_browser=true` forces visible mode for all sites and ignores per-site `custom_visible_browser`; `show_browser=false` applies per-site visibility.
+- **Retry-tracking state model**: `scrape_round_items` moves through `pending | in_progress | done | failed`; each active round has a 4-hour retry window, and `/api/scrape/progress` computes hourly `warn_due` from `last_hour_warn_at` fallback logic (`first_pending_at`, then round start).
 - **`closing_alerts_sent`**: JSON list — always `json.loads` + append, never overwrite
 
 ### FastAPI Routing
@@ -130,10 +133,33 @@ export PATH="..." && cd frontend && npx vitest run && npm run build
 
 ---
 
+## Redis Layer (added Session 32)
+
+- Enabled via `REDIS_URL` env var — app runs unchanged without it (graceful fallback)
+- `_redis_publish("new_listing", {...})` fires on every alert; channel: `ghostnode:events`
+- `_redis_set_stats(_stats)` — call after every meaningful `_stats` write (cycle end, pause, resume, running)
+- `GET /api/redis/status` — connectivity check + cached stats hash
+- Install locally: `pip install redis` (auto-installed in Docker)
+
+## N18 — Lot Description (added Session 32)
+
+- `JS_DETAIL_TEXT` runs on the already-open detail page (same visit as images — zero extra HTTP cost)
+- `description` column: `Text`, max 1500 chars, nullable — in `Listing` ORM + `_migrate_schema()` for both SQLite and PostgreSQL
+- `_build_ai_prompt(title, ai_target, description="")` — description appended as `Lot description:` block when non-empty
+- `_ai_analyze(title, ai_target, description="")` — forwards to prompt builder
+- Re-analysis: after detail fetch, `ai_match=1` listings with `ai_target` are re-evaluated with description; verdict updated in DB
+
+## Docker (added Session 32)
+
+- `Dockerfile` — Python 3.11-slim + Playwright Chromium; serves port 7000
+- `docker-compose.yml` — ghostnode + postgres:16-alpine + redis:7-alpine; health checks before app starts
+- `DATABASE_URL` + `REDIS_URL` wired in compose env
+- `shm_size: 512mb` on ghostnode service — Chromium requires shared memory
+
 ## Pending Work (Priority Order)
 
-1. **Redis Cache Layer** — replace in-memory Python dicts; survives restarts; pub/sub for live dashboard
-2. **Docker Compose** — one-command startup with PostgreSQL + Redis
-3. **Lot Description Extraction** — AI only sees title; detail page descriptions → better AI-first accuracy. Needs `JS_DETAIL_TEXT` + `description` column on Listing + pass to `_ai_analyze()`
+1. **Docker Testing** — run `docker compose up --build`; verify PostgreSQL migration, Redis pub/sub, Playwright headless in container
+2. **Frontend: show description** — add `description` field to `ListingDetailPanel` (already in `to_dict()`, just needs UI)
+3. **vLLM production inference** — replace Groq free tier for production scale
 
 

docs/New Text Document.md

@@ -242,9 +242,14 @@ Use these as bullet points / feature cards.
 
    - Multi‑interval closing alerts (e.g. 60, 30, 10, 5 minutes before close).
 
-6. **Redis & Docker‑ready architecture (roadmap / partially implemented)**
-
-   - Designed to support Redis cache/queue and Docker Compose deployment.
+6. **Keyword batching & retry tracking (with per-site visibility override)**
+  - Processes multiple keywords per site in parallel tabs and keeps (site, keyword) progress across cycles via `scrape_round_items`.
+  - Uses `scrape_rounds` + `scrape_round_items` statuses (`pending`, `in_progress`, `done`, `failed`) with a 4-hour retry window per active round.
+  - Dashboard pins “Keyword Retry Tracking” for pending retries, including hourly warnings and a 4-hour retry window.
+  - `show_browser=true` forces visible mode for all sites and ignores per-site `custom_visible_browser`; `show_browser=false` applies per-site visibility.
+  - Dashboard source of truth is `GET /api/scrape/progress`; hourly `warn_due` uses `last_hour_warn_at` fallback logic (`first_pending_at`, then round start).
+7. **Redis & Docker‑ready architecture (roadmap / partially implemented)**
+  - Designed to support Redis cache/queue and Docker Compose deployment.
 
 ---
 

docs/PROGRESS.md

@@ -17,27 +17,248 @@
 
 - **Version:** v2.7
 - **Status:** ✅ Fully operational — 21/21 tests passing
-- **Last session:** 31 (2026-03-13) — Fixed Framer Motion SSR opacity:0 bug across all components (LandingPage hero, dashboard, StatsGrid, RecentListings, EngineConsole, ActivityLog, ListingRow, ListingsTable, ListingDetailPanel, 4 page routes). All above-the-fold elements now render visible in static HTML (opacity:1, only transforms animate). Below-fold scroll-triggered sections intentionally keep opacity:0 for scroll animations. 21/21 tests passing.
+- **Last session:** 52 (2026-03-19) — wording normalization pass for mechanics docs (canonical phrasing alignment).
+- **Previous session:** 44 (2026-03-19) — clean-room marketing landing rebuild (new `LandingPageV3` + OG image).
+- **Previous session:** 39 (2026-03-19) — added `/api/listings/refresh-status` contract test (Option A baseline).
+- **Previous session:** 38 (2026-03-19) — added backend contract tests for `/api/stats` and `/api/listings/countdown-sync`.
+- **Previous session:** 34 (2026-03-18) — added `docs/MD_UPDATE_PLAYBOOK.md` playbook for deep semantic Markdown audits + minimal targeted MD edits workflow.
+- **Previous session:** 33 (2026-03-18) — per-site visible browser override + keyword batching progress tracking + hourly retry warnings. See details below.
+- **Previous session:** 32 (2026-03-18) — Redis cache layer, Docker Compose, lot description extraction (N18). See details below.
+- **Previous session:** 31 (2026-03-13) — Fixed Framer Motion SSR opacity:0 bug across all components (LandingPage hero, dashboard, StatsGrid, RecentListings, EngineConsole, ActivityLog, ListingRow, ListingsTable, ListingDetailPanel, 4 page routes). All above-the-fold elements now render visible in static HTML (opacity:1, only transforms animate). Below-fold scroll-triggered sections intentionally keep opacity:0 for scroll animations. 21/21 tests passing.
 - **Previous session:** 30 (2026-03-13) — Full marketing landing page built from AI_WEB_BRIEF.md (Hero, Platform Strip, 6-feature grid, How It Works 4-step flow, Who It's For personas, FAQ accordion, Footer CTA + site footer). Light/dark theme toggle added (ThemeToggle.tsx, localStorage-persistent, vivid lavender-ivory light palette via data-theme attribute). globals.css extended with complete [data-theme="light"] overrides for all g-* classes. 21/21 tests passing.
 - **Previous session:** 29 (2026-03-13) — Master dashboard "Mission Control" rebuilt: RecentListings (polls /api/listings every 10s), EngineConsole (status orb + controls + site health, polls /api/sites every 25s), enhanced ActivityLog (tracks engine state transitions), StatsGrid updated (keywords prop replaces engine card), utils.ts extended (formatUptime, formatMins, formatPrice, timeAgo). 21/21 tests passing.
 - **worker.py:** 5,000+ lines (definitive — ahead of all exports)
 - **frontend/:** Next.js 16 + React 19 + TypeScript + Tailwind v4 — static build in `frontend/out/` (1.8MB). `node_modules/` is 553MB build tooling — safe to delete, run `npm install` to restore.
 - **models.py:** ~420 lines
-- **Serving:** `http://localhost:8000` (React UI) | `http://localhost:8000/legacy` (HTML fallback)
+- **Serving:** `http://localhost:7000` (React UI) | `http://localhost:7000/legacy` (HTML fallback)
 
 ---
 
+## 🟢 Session 52 — 2026-03-19
+
+**Canonical wording normalization (Markdown only)**
+- Ran a minimal wording-only pass on already-touched docs so mechanics phrasing is consistent across files.
+- Standardized the same canonical statements for:
+  - `show_browser=true` precedence vs per-site `custom_visible_browser`
+  - `keyword_batch_enabled` + `scrape_rounds`/`scrape_round_items` statuses (`pending`, `in_progress`, `done`, `failed`) and 4-hour window
+  - Dashboard "Keyword Retry Tracking" source `GET /api/scrape/progress` with hourly `warn_due` from `last_hour_warn_at` fallback logic
+
+## 🟢 Session 51 — 2026-03-19
+
+**Deep Markdown mechanics audit and alignment**
+- Audited all repo `*.md` files and applied minimal edits only where mechanics were missing/unclear.
+- Updated docs to consistently reflect:
+  - `custom_visible_browser` behavior and `show_browser=true` precedence.
+  - `keyword_batch_enabled` + `scrape_rounds`/`scrape_round_items` status flow (`pending`, `in_progress`, `done`, `failed`).
+  - 4-hour retry window, hourly warning bookkeeping (`last_hour_warn_at`), and `warn_due`.
+  - Dashboard "Keyword Retry Tracking" source endpoint: `GET /api/scrape/progress`.
+
+## 🟢 Session 42 — 2026-03-19
+
+:**Premium UX/UI: Landing page rewrite**
+- Added `frontend/components/landing/LandingPageV2.tsx` with a richer premium layout (neon particle canvas, interactive console preview, improved Features / How-it-works / Developer / Pricing / FAQ sections).
+- Switched `frontend/app/page.tsx` to render `LandingPageV2`.
+- Verified: `cd frontend && npx vitest run` and `npm run build --prefix frontend`.
+
+## 🟢 Session 43 — 2026-03-19
+
+:**Marketing UX cleanup: remove old landing**
+- Deleted `frontend/components/landing/LandingPage.tsx` (unused now) so the marketing site is not based on the previous landing design.
+- Re-ran `cd frontend && npx vitest run` and `npm run build` to confirm everything still passes.
+
+## 🟢 Session 44 — 2026-03-19
+
+:**Clean-room marketing rebuild (LandingPageV3 + OG)**
+- Deleted `frontend/out/` and regenerated the Next.js static export.
+- Added `frontend/components/landing/LandingPageV3.tsx` (shadcn + motion + lucide) and switched `frontend/app/page.tsx` to render it.
+- Added missing landing shadcn primitives (`button`, `card`, `accordion`, `badge`, `separator`).
+- Added `frontend/app/opengraph-image.tsx` (Satori via `next/og`).
+- Verified: `http://localhost:7000/` and `http://localhost:7000/legacy` return `200`.
+
+## 🟢 Session 45 — 2026-03-19
+
+**Full-app shell redesign pass (all routes)**
+- Rebuilt the shared top chrome so every route has a clearly new look without changing API wiring:
+  - `frontend/components/layout/Header.tsx`
+  - `frontend/components/layout/Nav.tsx`
+  - `frontend/components/layout/StatusBar.tsx`
+- New shell direction: thicker glass layers, stronger typography hierarchy, capsule nav tabs, route-wide control rail styling, and cardized telemetry status tiles.
+- Kept all engine controls and route paths intact (`pause`, `resume`, `restart`, `kill`, and all nav route links).
+- Verified: `cd frontend && npx vitest run` and `npm run build` both pass (same known static-export/metadata warnings only).
+
+## 🟢 Session 46 — 2026-03-19
+
+**Total visual wipe phase (hard reset baseline)**
+- Replaced `frontend/app/globals.css` with a minimal baseline (`tailwind` imports + basic box-model/body reset), removing all prior custom visual system layers (`g-*`, glass, gradients, neon, theme-specific utility classes).
+- Flattened visual-heavy components to plain functional markup:
+  - `frontend/components/dashboard/StatsGrid.tsx`
+  - `frontend/components/listings/ListingsTable.tsx`
+  - `frontend/components/keywords/KeywordRow.tsx`
+- Kept core behavior and wiring intact (data hooks, actions, filters, exports, delete flows, detail panel opening).
+- Verified: `cd frontend && npm run build` passes. Lint has one non-blocking warning in `KeywordRow.tsx` from `dnd-kit` inline transform style usage.
+
+## 🟢 Session 47 — 2026-03-19
+
+**Total visual wipe phase (remaining shared/UI surfaces)**
+- Flattened remaining visual-heavy components to plain functional markup:
+  - `frontend/components/sites/SiteCard.tsx`
+  - `frontend/components/sites/SitesTable.tsx`
+  - `frontend/components/listings/ListingCard.tsx`
+  - `frontend/components/listings/ListingDetailPanel.tsx`
+  - `frontend/components/ai-log/AILogCard.tsx`
+  - `frontend/components/ai-log/AILogFeed.tsx`
+  - `frontend/components/layout/Header.tsx`
+  - `frontend/components/layout/Nav.tsx`
+  - `frontend/components/layout/StatusBar.tsx`
+- Removed old class-driven visual styling from these files while preserving core interactions (drag reorder, toggles, adapt trigger, engine actions, AI log polling/filtering, listing detail open/close).
+- Verified: `cd frontend && npx vitest run && npm run build` passes (same known Next.js warnings only). One non-blocking linter warning remains from required `dnd-kit` inline transform style in `SiteCard.tsx`.
+
+## 🟢 Session 48 — 2026-03-19
+
+**Final `g-*` cleanup sweep (active app surfaces)**
+- Replaced remaining active visual-heavy files with plain functional markup and removed `g-*` usage from active routes/components:
+  - `frontend/components/dashboard/EngineConsole.tsx`
+  - `frontend/components/dashboard/RecentListings.tsx`
+  - `frontend/components/dashboard/ActivityLog.tsx`
+  - `frontend/components/keywords/KeywordCard.tsx`
+  - `frontend/components/keywords/KeywordsTable.tsx`
+  - `frontend/components/keywords/ScoringRulesPanel.tsx`
+  - `frontend/components/listings/ImageGallery.tsx`
+  - `frontend/components/layout/ThemeToggle.tsx`
+  - `frontend/app/settings/page.tsx`
+- Preserved key behavior (polling, engine controls, retry tracking, drag reorder, scoring CRUD, backup/restore, AI log/config interactions).
+- Updated minimal test expectations indirectly through component text compatibility (no test file edits in this pass).
+- Verified: `cd frontend && npx vitest run && npm run build` passes (same known Next.js static-export warnings only).
+
+## 🟢 Session 49 — 2026-03-19
+
+**Lint cleanup finalization (ImageGallery)**
+- Removed inline-style usage from `frontend/components/listings/ImageGallery.tsx` and converted to class-based styling (`fixed` overlay/panel/image sizing + strip layout), including replacing runtime display toggle with class toggling.
+- Resolved final class lint recommendation (`z-[100]` → `z-100`).
+- Verified: `cd frontend && npx vitest run && npm run build` passes; `ImageGallery.tsx` lints clean.
+
+## 🟢 Session 50 — 2026-03-19
+
+**100% wipe completion pass**
+- Neutralized final leftover old-visual components with plain implementations:
+  - `frontend/components/sites/SiteRow.tsx`
+  - `frontend/components/listings/ListingRow.tsx`
+  - `frontend/components/layout/AmbientBackground.tsx`
+- Confirmed no `g-*` class tokens remain in active frontend codebase outside non-app hidden tooling (`frontend/.cursor/...`).
+- Final verification passed: `cd frontend && npx vitest run && npm run build`.
+
+## 🟢 Session 35 — 2026-03-19
+
+**Option A baseline: pinned retry tracking contract tests**
+- Added `frontend/__tests__/EngineConsole.test.tsx` to validate the pinned “Keyword Retry Tracking” panel contract via mocked `/api/sites` + `/api/scrape/progress`.
+- Updated `frontend/vitest.config.ts` so Vitest runs only `frontend/__tests__` (avoids picking up Cursor harness `.cursor/tests`).
+- Verified: `cd frontend && npx vitest run` + `npm run build --prefix frontend`.
+
+## 🟢 Session 36 — 2026-03-19
+
+**Option A baseline: scrape-progress endpoint contract tests**
+- Added `backend_tests/test_scrape_progress.py` to seed a temp SQLite DB and verify `GET /api/scrape/progress` output (`keyword_batch_enabled`, `active_round`, `pending_items`, and `warn_due` logic).
+- Verified: `python -m unittest discover -s backend_tests -p 'test_*.py'`.
+- Re-verified: `cd frontend && npx vitest run` remained green.
+
+## 🟢 Session 37 — 2026-03-19
+
+**Option A baseline: UI limiting behavior**
+- Updated `frontend/__tests__/EngineConsole.test.tsx` with a new case that mocks 10 pending items and asserts:
+  - only the first 8 keyword terms render
+  - the UI shows `Showing first 8 of 10`.
+- Verified: `cd frontend && npx vitest run`.
+
+## 🟢 Session 38 — 2026-03-19
+
+**Option A baseline: API contract tests for dashboard**
+- Extended `backend_tests/test_scrape_progress.py` with:
+  - `/api/stats` response shape assertions
+  - `/api/listings/countdown-sync` values + ISO timestamp fields based on seeded `Listing` rows.
+- Verified: `python -m unittest discover -s backend_tests -p 'test_*.py'` and frontend `vitest` remained green.
+
+## 🟢 Session 39 — 2026-03-19
+
+**Option A baseline: `/api/listings/refresh-status` contract test**
+- Extended `backend_tests/test_scrape_progress.py` with assertions for:
+  - `GET /api/listings/refresh-status` returns `last_price_update` ISO string and `listing_count`.
+- Verified: `python -m unittest discover -s backend_tests -p 'test_*.py'` + frontend `vitest`.
+
+## 🟢 Session 40 — 2026-03-19
+
+**Option A baseline: `/api/sites` numeric flags contract**
+- Added backend contract assertions in `backend_tests/test_scrape_progress.py` verifying `enabled`, `custom_visible_browser`, `requires_login`, `login_enabled` are returned as integer `0/1` (not JSON booleans).
+- Fixed `models.py` `TargetSite.to_dict()` to emit `0/1` integers for those flag fields.
+- Verified: backend unittests + frontend `vitest` remain green.
+
+## 🟢 Session 41 — 2026-03-19
+
+**Option A baseline: `/api/config` contract tests (Settings page)**
+- Added backend contract assertions in `backend_tests/test_scrape_progress.py` for:
+  - `GET /api/config` returning a flat `{key: value}` object with string values
+  - `POST /api/config` upserting values as strings and returning `{status, keys}`
+- Verified: backend unittests and frontend `vitest` remained green.
+
+## 🟢 Session 34 — 2026-03-18
+
+**MD Update Playbook (repeatable doc job)**
+- Added `docs/MD_UPDATE_PLAYBOOK.md` with:
+  - deep semantic audit workflow for all `*.md` files
+  - exact mechanics checklist for per-site visibility override and keyword batching + retry tracking
+  - reusable prompt (TEXT + JSON) with approval gate + verification checklist
+
+## 🟢 Session 33 — 2026-03-18
+
+**Per-site Visible/Custom Browser Override**
+- Added `TargetSite.custom_visible_browser` (0/1).
+- Global `show_browser=true` forces visible mode for all sites.
+- When `show_browser=false`, a site becomes visible only if `custom_visible_browser=1`.
+
+**Keyword Batching + Persistent Progress Tracking**
+- Added config `keyword_batch_enabled` (default `false`).
+- Introduced `scrape_rounds` + `scrape_round_items` to track per-(site, keyword) status across cycles.
+- Engine batches at most `max_tabs_per_site` keyword attempts per site per cycle/round.
+- Failures mark items `pending` and keep retrying until the round’s 4-hour retry window expires.
+
+**Hourly Retry Warnings + Live Dashboard**
+- Hourly bookkeeping updates `scrape_round_items.last_hour_warn_at`.
+- Added API: `GET /api/scrape/progress` for the dashboard to render pinned “Keyword Retry Tracking”.
+
+## 🟢 Session 32 — 2026-03-18
+
+**Redis Cache Layer (Priority 1 — DONE)**
+- Added `_init_redis()`, `_redis_set_stats()`, `_redis_publish()`, `_redis_cache_set/get()` helpers in worker.py
+- Graceful write-through: app runs unchanged when `REDIS_URL` not set
+- Stats synced to Redis on cycle complete, engine pause/resume, engine running
+- `new_listing` pub/sub event published on every alert
+- New endpoint: `GET /api/redis/status` — connectivity check + cached stats
+- Redis channel: `ghostnode:events`, stats key: `ghostnode:stats`
+
+**Docker Compose (Priority 2 — DONE)**
+- `Dockerfile` — Python 3.11-slim + Playwright Chromium + all deps, serves on port 8000
+- `docker-compose.yml` — 3 services: ghostnode, postgres:16-alpine, redis:7-alpine
+- Auto health checks on Postgres + Redis before ghostnode starts
+- One-command: `docker compose up --build`
+- Volumes: `postgres_data`, `redis_data`, `ghostnode_sessions`
+
+**Lot Description Extraction / N18 (Priority 3 — DONE)**
+- `JS_DETAIL_TEXT` — 4-layer JS extractor: JSON-LD → OG meta → known selectors → largest `<p>` block
+- `description (Text)` column added to `Listing` ORM + migration in `_migrate_schema()` for SQLite + PostgreSQL
+- `_fetch_listing_images_batch()` now evaluates `JS_DETAIL_TEXT` on every detail page visit (zero extra network cost — same page already open for images)
+- `_build_ai_prompt()` and `_ai_analyze()` updated to accept optional `description` param
+- Re-analysis: listings that passed AI on title alone (`ai_match=1`) are re-evaluated with description after detail fetch
+- `to_dict()` on `Listing` now includes `description` field
+
 ## 🟡 Pending Features — Priority Queue
 
-### Priority 1 — Redis Cache Layer
-Replace in-memory Python dicts with Redis. Survives restarts. Enables pub/sub for live dashboard. Price cache, rate limits, job queue.
+### Priority 1 — Frontend Polish
+Badge system refinement, animation tuning, show `description` in ListingDetailPanel.
 
-### Priority 2 — Docker Compose
-`docker-compose.yml` with worker.py + PostgreSQL + Redis. One-command startup anywhere.
+### Priority 2 — Docker Testing
+Test the docker-compose stack end-to-end. Verify PostgreSQL migration, Redis pub/sub, Playwright in container.
 
-### Priority 3 — Lot Description Extraction
-AI currently only sees lot **title**. Detail pages have full descriptions. Extends AI-first accuracy dramatically.
-**How:** `JS_DETAIL_TEXT` extractor on detail pages + new `description (Text)` column on `Listing` + pass to `_ai_analyze()`
+### Priority 3 — vLLM Production Inference
+Replace Groq rate-limited free tier with self-hosted vLLM on rented GPU for production scale.
 
 ### Priority 4 — Frontend Visual Polish
 Session 27: Full premium redesign — ambient animated gradient background (3 floating orbs + dot grid), glassmorphism shell (backdrop-blur + saturate), gradient glow cards (`g-card-glow` with animated border), Framer Motion staggered card/row/page animations, gradient text headings, badge system (green/amber/red/blue/purple/neutral), gradient underline active nav with glow, status pill with live pulse dot + aura shadow. New CSS prefix: `g-*` (e.g. `bg-g-base`, `text-g-green`). All 21 tests + build passing.

docs/superpowers/plans/2026-03-11-frontend-migration.md

@@ -2061,11 +2061,12 @@ function ConfidenceBadge({ siteId }: { siteId: number }) {
   return <span className={cn('text-xs font-mono', color)}>{sel.confidence}%{sel.stale ? ' ⚠' : ''}</span>
 }
 
-export default function SiteRow({ site }: { site: TargetSite }) {
+export default function SiteRow({ site, globalShowBrowser }: { site: TargetSite; globalShowBrowser?: boolean | null }) {
   const { attributes, listeners, setNodeRef, transform, transition } = useSortable({ id: site.id })
   const updateSite = useUpdateSite()
   const deleteSite = useDeleteSite()
   const adaptSite = useAdaptSite()
+  const globalShowBrowserOn = globalShowBrowser === true
 
   const style = { transform: CSS.Transform.toString(transform), transition }
 
@@ -2077,12 +2078,30 @@ export default function SiteRow({ site }: { site: TargetSite }) {
       <td className="p-2"><HealthBadge site={site} /></td>
       <td className="p-2"><ConfidenceBadge siteId={site.id} /></td>
       <td className="p-2">
-        <label className="flex items-center gap-1 cursor-pointer">
-          <input type="checkbox" checked={site.enabled === 1}
-            onChange={(e) => updateSite.mutate({ id: site.id, data: { enabled: e.target.checked ? 1 : 0 } })}
-            className="accent-ghost-accent" />
-          <span className="font-mono text-xs text-ghost-dim">{site.enabled ? 'ON' : 'OFF'}</span>
-        </label>
+        <div className="flex items-center gap-3">
+          <label className="flex items-center gap-1 cursor-pointer">
+            <input type="checkbox" checked={site.enabled === 1}
+              onChange={(e) => updateSite.mutate({ id: site.id, data: { enabled: e.target.checked ? 1 : 0 } })}
+              className="accent-ghost-accent" />
+            <span className="font-mono text-xs text-ghost-dim">{site.enabled ? 'ON' : 'OFF'}</span>
+          </label>
+
+          {/* Per-site visible override:
+              - If global `show_browser=true`, it forces visible for all sites.
+              - Otherwise, `custom_visible_browser=1` enables visible mode for this site only. */}
+          <label className="flex items-center gap-1 cursor-pointer select-none"
+            title={globalShowBrowserOn ? 'Global show_browser=true is enabled so per-site override is ignored.' : 'Overrides global show_browser for this site.'}
+            style={{ opacity: globalShowBrowserOn ? 0.45 : 1, cursor: globalShowBrowserOn ? 'not-allowed' : 'pointer' }}
+          >
+            <input
+              type="checkbox"
+              checked={site.custom_visible_browser === 1}
+              disabled={globalShowBrowserOn}
+              onChange={() => updateSite.mutate({ id: site.id, data: { custom_visible_browser: site.custom_visible_browser ? 0 : 1 } })}
+            />
+            <span className="font-mono text-xs text-ghost-dim">{site.custom_visible_browser ? 'Visible' : 'Headless'}</span>
+          </label>
+        </div>
       </td>
       <td className="p-2">
         <button onClick={() => adaptSite.mutate(site.id)} disabled={adaptSite.isPending}
@@ -2101,14 +2120,23 @@ export default function SiteRow({ site }: { site: TargetSite }) {
 
 ```tsx
 'use client'
+import { useEffect, useState } from 'react'
 import { DndContext, closestCenter, type DragEndEvent } from '@dnd-kit/core'
 import { SortableContext, verticalListSortingStrategy } from '@dnd-kit/sortable'
 import SiteRow from './SiteRow'
 import { useSites, useReorderSites } from '@/hooks/useSites'
+import { fetchConfig } from '@/lib/api/config'
 
 export default function SitesTable() {
   const { data: sites, isLoading } = useSites()
   const reorder = useReorderSites()
+  const [globalShowBrowser, setGlobalShowBrowser] = useState<boolean | null>(null)
+
+  useEffect(() => {
+    fetchConfig()
+      .then((cfg) => setGlobalShowBrowser(String(cfg.show_browser ?? '').toLowerCase() === 'true'))
+      .catch(() => setGlobalShowBrowser(null))
+  }, [])
 
   const handleDragEnd = ({ active, over }: DragEndEvent) => {
     if (!over || active.id === over.id || !sites) return
@@ -2138,7 +2166,7 @@ export default function SitesTable() {
             </tr>
           </thead>
           <tbody>
-            {(sites ?? []).map((s) => <SiteRow key={s.id} site={s} />)}
+            {(sites ?? []).map((s) => <SiteRow key={s.id} site={s} globalShowBrowser={globalShowBrowser} />)}
           </tbody>
         </table>
       </SortableContext>
@@ -2324,6 +2352,7 @@ export default function SettingsPage() {
         <Field label="Browser"             k="browser_choice" cfg={config} onChange={updateKey} />
         <Field label="Humanize level"      k="humanize_level" cfg={config} onChange={updateKey} />
         <Field label="Show browser"        k="show_browser"   cfg={config} onChange={updateKey} />
+        <Field label="Keyword batching"  k="keyword_batch_enabled" cfg={config} onChange={updateKey} />
       </Section>
 
       {/* Alerts */}

frontend/.cursor

@@ -0,0 +1 @@
+Subproject commit 4bdbf57d981fec151554e5a23109906fe8c7eebf

frontend/README.md

@@ -33,4 +33,4 @@ You can check out [the Next.js GitHub repository](https://github.com/vercel/next
 
 The easiest way to deploy your Next.js app is to use the [Vercel Platform](https://vercel.com/new?utm_medium=default-template&filter=next.js&utm_source=create-next-app&utm_campaign=create-next-app-readme) from the creators of Next.js.
 
-Check out our [Next.js deployment documentation](https://nextjs.org/docs/app/building-your-application/deploying) for more details.
+Check out our [Next.js deployment documentation](https://nextjs.org/docs/app/building-your-development/deploying) for more details.

frontend/__tests__/ListingRow.test.tsx

@@ -1,33 +0,0 @@
-import { describe, it, expect, vi } from 'vitest'
-import { render, screen } from '@testing-library/react'
-import ListingRow from '../components/listings/ListingRow'
-import type { Listing } from '../lib/types'
-
-const mockListing: Listing = {
-  id: 1, title: 'RTX 4090 Gaming GPU', price: 299.99, currency: 'USD',
-  price_raw: '$299.99', price_usd: 299.99, time_left: '2h 30m',
-  time_left_mins: 150, link: 'https://example.com/lot/1', score: 30,
-  keyword: 'RTX 4090', site_name: 'eBay UK', timestamp: '2026-03-11T10:00:00',
-  price_updated_at: null, ai_match: 1, ai_reason: 'Matches RTX GPU target',
-  location: 'London, UK', images: ['https://example.com/img1.jpg'],
-  closing_alerts_sent: [],
-}
-
-vi.mock('../hooks/useCountdown', () => ({ useCountdown: () => () => 150 }))
-
-describe('ListingRow', () => {
-  it('renders title', () => {
-    render(<table><tbody><ListingRow listing={mockListing} onSelect={vi.fn()} /></tbody></table>)
-    expect(screen.getByText(/RTX 4090 Gaming GPU/)).toBeTruthy()
-  })
-
-  it('shows AI match badge', () => {
-    render(<table><tbody><ListingRow listing={mockListing} onSelect={vi.fn()} /></tbody></table>)
-    expect(screen.getByTitle(/AI match/i)).toBeTruthy()
-  })
-
-  it('shows score in gold', () => {
-    render(<table><tbody><ListingRow listing={mockListing} onSelect={vi.fn()} /></tbody></table>)
-    expect(screen.getByText('30')).toBeTruthy()
-  })
-})

frontend/__tests__/StatsGrid.test.tsx

@@ -1,13 +0,0 @@
-import { describe, it, expect } from 'vitest'
-import { render, screen } from '@testing-library/react'
-import StatsGrid from '../components/dashboard/StatsGrid'
-
-describe('StatsGrid', () => {
-  it('renders all four stat cards', () => {
-    render(<StatsGrid scanned={42} alerts={3} keywords={5} uptime="1h 2m" />)
-    expect(screen.getByText('42')).toBeTruthy()
-    expect(screen.getByText('3')).toBeTruthy()
-    expect(screen.getByText('5')).toBeTruthy()
-    expect(screen.getByText('1h 2m')).toBeTruthy()
-  })
-})

frontend/__tests__/StatusBar.test.tsx

@@ -1,38 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from 'vitest'
-import { render, screen } from '@testing-library/react'
-import { useEngineStore } from '../store/engineStore'
-import StatusBar from '../components/layout/StatusBar'
-
-// useSSE does nothing in tests
-vi.mock('../hooks/useSSE', () => ({ useSSE: () => {} }))
-
-describe('StatusBar', () => {
-  beforeEach(() => {
-    useEngineStore.setState({
-      status: 'Running',
-      uptime_seconds: 3661,
-      total_scanned: 99,
-      total_alerts: 5,
-      last_cycle: 'Never',
-      isOffline: false,
-      setStats: vi.fn(),
-      setOffline: vi.fn(),
-    })
-  })
-
-  it('shows engine status', () => {
-    render(<StatusBar />)
-    expect(screen.getByText(/RUNNING/i)).toBeTruthy()
-  })
-
-  it('formats uptime correctly', () => {
-    render(<StatusBar />)
-    expect(screen.getByText(/1h 1m/i)).toBeTruthy()
-  })
-
-  it('shows offline banner when isOffline', () => {
-    useEngineStore.setState({ isOffline: true } as any)
-    render(<StatusBar />)
-    expect(screen.getByText(/OFFLINE/i)).toBeTruthy()
-  })
-})

frontend/__tests__/engineStore.test.ts

@@ -1,38 +0,0 @@
-import { describe, it, expect, beforeEach } from 'vitest'
-import { useEngineStore } from '../store/engineStore'
-
-describe('engineStore', () => {
-  beforeEach(() => {
-    useEngineStore.setState({
-      status: 'Idle',
-      uptime_seconds: 0,
-      total_scanned: 0,
-      total_alerts: 0,
-      last_cycle: 'Never',
-      isOffline: false,
-    })
-  })
-
-  it('initial state is Idle', () => {
-    expect(useEngineStore.getState().status).toBe('Idle')
-  })
-
-  it('setStats updates all fields', () => {
-    useEngineStore.getState().setStats({
-      engine_status: 'Running',
-      uptime_seconds: 120,
-      total_scanned: 42,
-      total_alerts: 3,
-      last_cycle: '2026-03-11T10:00:00',
-      uptime_start: Date.now() / 1000,
-    })
-    const s = useEngineStore.getState()
-    expect(s.status).toBe('Running')
-    expect(s.total_scanned).toBe(42)
-  })
-
-  it('setOffline marks isOffline true', () => {
-    useEngineStore.getState().setOffline(true)
-    expect(useEngineStore.getState().isOffline).toBe(true)
-  })
-})

frontend/__tests__/listings-api.test.ts

@@ -1,22 +0,0 @@
-import { describe, it, expect } from 'vitest'
-import { parseListingResponse } from '../lib/api/listings'
-
-describe('parseListingResponse', () => {
-  it('parses images JSON string to array', () => {
-    const raw = { images: '["http://a.com/1.jpg","http://a.com/2.jpg"]', closing_alerts_sent: '[]' }
-    const result = parseListingResponse(raw as any)
-    expect(result.images).toEqual(['http://a.com/1.jpg', 'http://a.com/2.jpg'])
-  })
-
-  it('handles null images as empty array', () => {
-    const raw = { images: null, closing_alerts_sent: '[]' }
-    const result = parseListingResponse(raw as any)
-    expect(result.images).toEqual([])
-  })
-
-  it('parses closing_alerts_sent to number array', () => {
-    const raw = { images: '[]', closing_alerts_sent: '[60,30,10]' }
-    const result = parseListingResponse(raw as any)
-    expect(result.closing_alerts_sent).toEqual([60, 30, 10])
-  })
-})

frontend/__tests__/theme.test.ts

@@ -1,14 +0,0 @@
-import { describe, it, expect } from 'vitest'
-import { readFileSync } from 'fs'
-import { join } from 'path'
-
-describe('Ghost Node theme', () => {
-  it('globals.css defines ghost accent color', () => {
-    const css = readFileSync(join(process.cwd(), 'app/globals.css'), 'utf-8')
-    expect(css).toContain('#00e87b')
-  })
-  it('globals.css defines ghost bg color', () => {
-    const css = readFileSync(join(process.cwd(), 'app/globals.css'), 'utf-8')
-    expect(css).toContain('#050510')
-  })
-})

frontend/__tests__/types.test.ts

@@ -1,17 +0,0 @@
-import { describe, it, expectTypeOf } from 'vitest'
-import type { Listing, Keyword, TargetSite, Stats, Config, SiteSelectors } from '../lib/types'
-
-describe('Types', () => {
-  it('Listing has parsed images as string array', () => {
-    expectTypeOf<Listing['images']>().toEqualTypeOf<string[]>()
-  })
-  it('Listing has closing_alerts_sent as number array', () => {
-    expectTypeOf<Listing['closing_alerts_sent']>().toEqualTypeOf<number[]>()
-  })
-  it('TargetSite enabled is 0|1 not boolean', () => {
-    expectTypeOf<TargetSite['enabled']>().toEqualTypeOf<0 | 1>()
-  })
-  it('Stats engine_status is string union', () => {
-    expectTypeOf<Stats['engine_status']>().toEqualTypeOf<'Idle' | 'Running' | 'Paused'>()
-  })
-})

frontend/__tests__/useCountdown.test.ts

@@ -1,34 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from 'vitest'
-import { renderHook, act } from '@testing-library/react'
-import { useCountdown } from '../hooks/useCountdown'
-
-vi.mock('../lib/api/listings', () => ({
-  fetchCountdownSync: vi.fn().mockResolvedValue([
-    { id: 1, time_left_mins: 30 },
-    { id: 2, time_left_mins: 5 },
-  ]),
-}))
-
-describe('useCountdown', () => {
-  beforeEach(() => {
-    vi.clearAllMocks()
-  })
-
-  it('returns null for unknown id before sync', () => {
-    const { result } = renderHook(() => useCountdown())
-    expect(result.current(999)).toBeNull()
-  })
-
-  it('returns mins for known id after sync', async () => {
-    const { result } = renderHook(() => useCountdown())
-
-    await act(async () => {
-      // Wait for the initial fetch to complete
-      await new Promise(resolve => setTimeout(resolve, 50))
-    })
-
-    const mins = result.current(1)
-    expect(mins).not.toBeNull()
-    expect(mins).toBeCloseTo(30, 0)
-  })
-})

frontend/app/ai-log/page.tsx

@@ -1,15 +0,0 @@
-'use client'
-import { motion } from 'framer-motion'
-import AILogFeed from '@/components/ai-log/AILogFeed'
-
-export default function AILogPage() {
-  return (
-    <div className="space-y-5">
-      <motion.div initial={{ opacity: 1, y: -8 }} animate={{ opacity: 1, y: 0 }} transition={{ duration: 0.4 }}>
-        <h1 className="g-page-title">AI Log</h1>
-        <p className="g-page-sub">Live AI filter decisions and responses</p>
-      </motion.div>
-      <AILogFeed />
-    </div>
-  )
-}

frontend/app/api/stream/route.ts.disabled

@@ -1,37 +0,0 @@
-export const dynamic = 'force-dynamic'
-
-export async function GET() {
-  const encoder = new TextEncoder()
-
-  const stream = new ReadableStream({
-    async start(controller) {
-      const send = (data: object) => {
-        controller.enqueue(encoder.encode(`data: ${JSON.stringify(data)}\n\n`))
-      }
-
-      // Poll FastAPI stats every 3s and push to browser
-      while (true) {
-        try {
-          const res = await fetch('http://localhost:8000/api/stats', {
-            signal: AbortSignal.timeout(2000),
-          })
-          if (res.ok) {
-            const stats = await res.json()
-            send({ type: 'stats', payload: stats })
-          }
-        } catch {
-          send({ type: 'offline' })
-        }
-        await new Promise((r) => setTimeout(r, 3000))
-      }
-    },
-  })
-
-  return new Response(stream, {
-    headers: {
-      'Content-Type': 'text/event-stream',
-      'Cache-Control': 'no-cache',
-      Connection: 'keep-alive',
-    },
-  })
-}

frontend/app/dashboard/page.tsx

@@ -1,154 +0,0 @@
-'use client'
-import { useEffect, useState } from 'react'
-import { motion } from 'framer-motion'
-import { useEngineStore } from '@/store/engineStore'
-import { formatUptime } from '@/lib/utils'
-import StatsGrid from '@/components/dashboard/StatsGrid'
-import RecentListings from '@/components/dashboard/RecentListings'
-import EngineConsole from '@/components/dashboard/EngineConsole'
-import ActivityLog from '@/components/dashboard/ActivityLog'
-
-const BASE = 'http://localhost:8000'
-
-/* ── Live clock ──────────────────────────────────────────────── */
-function LiveClock() {
-  const [tick, setTick] = useState('')
-
-  useEffect(() => {
-    const fmt = () =>
-      new Date().toLocaleTimeString([], {
-        hour: '2-digit',
-        minute: '2-digit',
-        second: '2-digit',
-      })
-    setTick(fmt())
-    const id = setInterval(() => setTick(fmt()), 1000)
-    return () => clearInterval(id)
-  }, [])
-
-  return (
-    <span className="text-[12px] font-mono text-g-faint/60 tabular-nums tracking-widest select-none">
-      {tick}
-    </span>
-  )
-}
-
-/* ── Connection badge ────────────────────────────────────────── */
-function ConnectionBadge({ offline }: { offline: boolean }) {
-  return (
-    <div
-      className={`inline-flex items-center gap-1.5 px-2.5 py-1 rounded-full border text-[10px] font-bold tracking-wide transition-all duration-500 ${
-        offline
-          ? 'bg-g-red/8 border-g-red/20 text-g-red'
-          : 'bg-g-green/8 border-g-green/15 text-g-green'
-      }`}
-    >
-      <span
-        className="w-1.5 h-1.5 rounded-full"
-        style={{
-          background: offline ? '#f43f5e' : '#00e87b',
-          boxShadow: offline ? '0 0 6px #f43f5e80' : '0 0 6px #00e87b80',
-          animation: offline ? undefined : 'pulse-ring 2s ease-out infinite',
-        }}
-      />
-      {offline ? 'OFFLINE' : 'LIVE'}
-    </div>
-  )
-}
-
-/* ── Divider strip ───────────────────────────────────────────── */
-function SectionLabel({ children }: { children: React.ReactNode }) {
-  return (
-    <div className="flex items-center gap-3">
-      <span className="text-[10px] font-bold uppercase tracking-[0.16em] text-g-faint/70 whitespace-nowrap">
-        {children}
-      </span>
-      <div className="flex-1 h-px bg-gradient-to-r from-g-border/60 to-transparent" />
-    </div>
-  )
-}
-
-/* ── Main ────────────────────────────────────────────────────── */
-export default function DashboardPage() {
-  const { status, uptime_seconds, total_scanned, total_alerts, isOffline } = useEngineStore()
-
-  const [keywordCount, setKeywordCount] = useState(0)
-
-  useEffect(() => {
-    fetch(`${BASE}/api/keywords`)
-      .then(r => r.json())
-      .then(d => { if (Array.isArray(d)) setKeywordCount(d.length) })
-      .catch(() => {})
-  }, [])
-
-  return (
-    <div className="space-y-8">
-
-      {/* ── Page header ──────────────────────────────────────── */}
-      <motion.div
-        initial={{ opacity: 1, y: -10 }}
-        animate={{ opacity: 1, y: 0 }}
-        transition={{ duration: 0.45, ease: [0.22, 1, 0.36, 1] }}
-        className="flex items-end justify-between"
-      >
-        <div className="space-y-1">
-          <div className="flex items-center gap-3">
-            <h1 className="text-[22px] font-extrabold tracking-[-0.04em] leading-none bg-gradient-to-r from-g-text to-g-muted bg-clip-text text-transparent">
-              Mission Control
-            </h1>
-            <ConnectionBadge offline={isOffline} />
-          </div>
-          <p className="text-[12px] text-g-faint font-medium">
-            Auction intelligence engine · Ghost Node v2.7
-          </p>
-        </div>
-
-        <div className="flex items-center gap-4">
-          <LiveClock />
-          {/* Quick export shortcut */}
-          <a
-            href={`${BASE}/api/export/csv`}
-            target="_blank"
-            rel="noopener noreferrer"
-            className="g-btn h-8 px-3 text-[11px] gap-1.5"
-            title="Export all listings as CSV"
-          >
-            <svg width="11" height="11" viewBox="0 0 24 24" fill="none" stroke="currentColor" strokeWidth="2.5" strokeLinecap="round" strokeLinejoin="round">
-              <path d="M21 15v4a2 2 0 0 1-2 2H5a2 2 0 0 1-2-2v-4"/><polyline points="7 10 12 15 17 10"/><line x1="12" y1="15" x2="12" y2="3"/>
-            </svg>
-            Export
-          </a>
-        </div>
-      </motion.div>
-
-      {/* ── Glow divider ─────────────────────────────────────── */}
-      <div className="glow-line" />
-
-      {/* ── Stats strip ──────────────────────────────────────── */}
-      <section>
-        <StatsGrid
-          scanned={total_scanned}
-          alerts={total_alerts}
-          keywords={keywordCount}
-          uptime={formatUptime(uptime_seconds)}
-        />
-      </section>
-
-      {/* ── Main grid ────────────────────────────────────────── */}
-      <section className="space-y-3">
-        <SectionLabel>Live Feed</SectionLabel>
-        <div className="grid grid-cols-1 xl:grid-cols-[1fr_360px] gap-5">
-          <RecentListings />
-          <EngineConsole />
-        </div>
-      </section>
-
-      {/* ── Activity log ─────────────────────────────────────── */}
-      <section className="space-y-3">
-        <SectionLabel>Activity Log</SectionLabel>
-        <ActivityLog />
-      </section>
-
-    </div>
-  )
-}

frontend/app/globals.css

@@ -1,608 +0,0 @@
-@import "tailwindcss";
-@import "tw-animate-css";
-@import "shadcn/tailwind.css";
-
-@custom-variant dark (&:is(.dark *));
-
-@theme {
-  --color-g-base:    #050510;
-  --color-g-surface: #0a0f1e;
-  --color-g-panel:   #0f1629;
-  --color-g-raised:  #141c35;
-  --color-g-border:  #1a2444;
-  --color-g-line:    #1f2f55;
-
-  --color-g-text:    #f0f4ff;
-  --color-g-muted:   #8896b8;
-  --color-g-faint:   #3d4f78;
-
-  --color-g-green:   #00e87b;
-  --color-g-green2:  #00c966;
-  --color-g-emerald: #10b981;
-  --color-g-cyan:    #06b6d4;
-  --color-g-amber:   #fbbf24;
-  --color-g-red:     #f43f5e;
-  --color-g-blue:    #3b82f6;
-  --color-g-purple:  #a78bfa;
-  --color-g-pink:    #ec4899;
-
-  --font-sans: var(--font-jakarta), system-ui, -apple-system, sans-serif;
-  --font-mono: var(--font-jetbrains), ui-monospace, 'Fira Code', monospace;
-}
-
-* { box-sizing: border-box; margin: 0; padding: 0; }
-html { scroll-behavior: smooth; }
-
-body {
-  background: var(--color-g-base, #050510);
-  color: var(--color-g-text, #f0f4ff);
-  font-family: var(--font-sans);
-  -webkit-font-smoothing: antialiased;
-  -moz-osx-font-smoothing: grayscale;
-  overflow-x: hidden;
-  transition: background 0.3s ease, color 0.3s ease;
-}
-
-::selection { background: rgba(0, 232, 123, 0.15); color: #f0f4ff; }
-::-webkit-scrollbar { width: 5px; height: 5px; }
-::-webkit-scrollbar-track { background: transparent; }
-::-webkit-scrollbar-thumb { background: #1a2444; border-radius: 99px; }
-::-webkit-scrollbar-thumb:hover { background: #1f2f55; }
-*:focus-visible { outline: 2px solid rgba(0, 232, 123, 0.4); outline-offset: 2px; }
-
-/* ── Ambient gradient keyframes ────────────────────────────── */
-@keyframes float-orb {
-  0%, 100% { transform: translate(0, 0) scale(1); }
-  25% { transform: translate(30px, -50px) scale(1.1); }
-  50% { transform: translate(-20px, 20px) scale(0.95); }
-  75% { transform: translate(50px, 30px) scale(1.05); }
-}
-@keyframes glow-pulse {
-  0%, 100% { opacity: 0.5; }
-  50% { opacity: 1; }
-}
-@keyframes shimmer {
-  0% { background-position: -200% 0; }
-  100% { background-position: 200% 0; }
-}
-@keyframes gradient-flow {
-  0% { background-position: 0% 50%; }
-  50% { background-position: 100% 50%; }
-  100% { background-position: 0% 50%; }
-}
-@keyframes fade-in-up {
-  from { opacity: 0; transform: translateY(12px); }
-  to { opacity: 1; transform: translateY(0); }
-}
-@keyframes pulse-ring {
-  0% { box-shadow: 0 0 0 0 rgba(0, 232, 123, 0.4); }
-  70% { box-shadow: 0 0 0 6px rgba(0, 232, 123, 0); }
-  100% { box-shadow: 0 0 0 0 rgba(0, 232, 123, 0); }
-}
-@keyframes border-glow {
-  0%, 100% { border-color: rgba(0, 232, 123, 0.15); }
-  50% { border-color: rgba(0, 232, 123, 0.35); }
-}
-@keyframes count-up { from { opacity: 0; transform: translateY(8px); } to { opacity: 1; transform: translateY(0); } }
-@keyframes slide-in-right { from { transform: translateX(100%); opacity: 0; } to { transform: translateX(0); opacity: 1; } }
-
-@layer components {
-  /* ── Glass ───────────────────────────────────────────────── */
-  .glass {
-    background: rgba(10, 15, 30, 0.7);
-    backdrop-filter: blur(20px) saturate(180%);
-    -webkit-backdrop-filter: blur(20px) saturate(180%);
-    border: 1px solid rgba(255, 255, 255, 0.04);
-  }
-  .glass-strong {
-    background: rgba(15, 22, 41, 0.85);
-    backdrop-filter: blur(40px) saturate(200%);
-    -webkit-backdrop-filter: blur(40px) saturate(200%);
-    border: 1px solid rgba(255, 255, 255, 0.06);
-  }
-
-  /* ── Cards ───────────────────────────────────────────────── */
-  .g-card {
-    position: relative;
-    background: linear-gradient(135deg, rgba(15, 22, 41, 0.8) 0%, rgba(10, 15, 30, 0.9) 100%);
-    border: 1px solid rgba(26, 36, 68, 0.6);
-    border-radius: 16px;
-    overflow: hidden;
-    transition: border-color 0.3s, box-shadow 0.3s, transform 0.3s;
-  }
-  .g-card::before {
-    content: '';
-    position: absolute;
-    inset: 0;
-    background: linear-gradient(135deg, rgba(255,255,255,0.03) 0%, transparent 50%);
-    pointer-events: none;
-    border-radius: inherit;
-  }
-  .g-card:hover {
-    border-color: rgba(0, 232, 123, 0.15);
-    box-shadow: 0 8px 32px rgba(0, 0, 0, 0.3), 0 0 0 1px rgba(0, 232, 123, 0.05);
-    transform: translateY(-1px);
-  }
-
-  .g-card-glow {
-    position: relative;
-    background: linear-gradient(135deg, rgba(15, 22, 41, 0.8) 0%, rgba(10, 15, 30, 0.9) 100%);
-    border: 1px solid rgba(0, 232, 123, 0.12);
-    border-radius: 16px;
-    overflow: hidden;
-    transition: all 0.3s;
-    animation: border-glow 4s ease-in-out infinite;
-  }
-  .g-card-glow::before {
-    content: '';
-    position: absolute;
-    inset: -1px;
-    background: linear-gradient(135deg, rgba(0,232,123,0.1) 0%, transparent 40%, rgba(6,182,212,0.05) 100%);
-    border-radius: inherit;
-    pointer-events: none;
-    z-index: 0;
-  }
-  .g-card-glow:hover {
-    border-color: rgba(0, 232, 123, 0.25);
-    box-shadow: 0 0 30px rgba(0, 232, 123, 0.08), 0 8px 32px rgba(0, 0, 0, 0.4);
-    transform: translateY(-2px);
-  }
-
-  /* ── Inputs ──────────────────────────────────────────────── */
-  .g-input {
-    background: rgba(10, 15, 30, 0.6);
-    border: 1px solid rgba(26, 36, 68, 0.8);
-    border-radius: 10px;
-    color: #f0f4ff;
-    font-size: 0.875rem;
-    padding: 0.5rem 0.875rem;
-    transition: all 0.2s ease;
-    outline: none;
-    width: 100%;
-  }
-  .g-input::placeholder { color: #3d4f78; }
-  .g-input:focus {
-    border-color: rgba(0, 232, 123, 0.4);
-    box-shadow: 0 0 0 3px rgba(0, 232, 123, 0.08), 0 0 20px rgba(0, 232, 123, 0.05);
-    background: rgba(10, 15, 30, 0.8);
-  }
-
-  /* ── Buttons ─────────────────────────────────────────────── */
-  .g-btn {
-    display: inline-flex; align-items: center; gap: 0.375rem;
-    padding: 0.5rem 1rem; border-radius: 10px;
-    font-size: 0.8125rem; font-weight: 500; letter-spacing: -0.01em;
-    transition: all 0.2s ease; cursor: pointer; white-space: nowrap;
-    border: 1px solid rgba(26, 36, 68, 0.8);
-    background: rgba(15, 22, 41, 0.6);
-    color: #8896b8;
-  }
-  .g-btn:hover {
-    background: rgba(20, 28, 53, 0.9);
-    border-color: rgba(31, 47, 85, 0.9);
-    color: #f0f4ff;
-    transform: translateY(-1px);
-    box-shadow: 0 4px 16px rgba(0, 0, 0, 0.4);
-  }
-  .g-btn:active { transform: translateY(0); box-shadow: none; }
-
-  .g-btn-primary {
-    display: inline-flex; align-items: center; gap: 0.375rem;
-    padding: 0.5rem 1rem; border-radius: 10px;
-    font-size: 0.8125rem; font-weight: 600; letter-spacing: -0.01em;
-    transition: all 0.2s ease; cursor: pointer; white-space: nowrap;
-    border: 1px solid rgba(0, 232, 123, 0.3);
-    background: linear-gradient(135deg, rgba(0, 232, 123, 0.15) 0%, rgba(6, 182, 212, 0.1) 100%);
-    color: #00e87b;
-  }
-  .g-btn-primary:hover {
-    background: linear-gradient(135deg, rgba(0, 232, 123, 0.25) 0%, rgba(6, 182, 212, 0.15) 100%);
-    border-color: rgba(0, 232, 123, 0.5);
-    box-shadow: 0 0 24px rgba(0, 232, 123, 0.15), 0 4px 16px rgba(0, 0, 0, 0.3);
-    transform: translateY(-1px);
-  }
-
-  .g-btn-danger {
-    display: inline-flex; align-items: center; gap: 0.375rem;
-    padding: 0.5rem 1rem; border-radius: 10px;
-    font-size: 0.8125rem; font-weight: 600; letter-spacing: -0.01em;
-    transition: all 0.2s ease; cursor: pointer; white-space: nowrap;
-    border: 1px solid rgba(244, 63, 94, 0.3);
-    background: linear-gradient(135deg, rgba(244, 63, 94, 0.1) 0%, rgba(236, 72, 153, 0.05) 100%);
-    color: #f43f5e;
-  }
-  .g-btn-danger:hover {
-    background: linear-gradient(135deg, rgba(244, 63, 94, 0.2) 0%, rgba(236, 72, 153, 0.1) 100%);
-    border-color: rgba(244, 63, 94, 0.5);
-    box-shadow: 0 0 24px rgba(244, 63, 94, 0.12), 0 4px 16px rgba(0, 0, 0, 0.3);
-    transform: translateY(-1px);
-  }
-
-  /* ── Table ───────────────────────────────────────────────── */
-  .g-table { width: 100%; border-collapse: separate; border-spacing: 0; font-size: 0.875rem; }
-  .g-table thead tr { background: rgba(20, 28, 53, 0.5); }
-  .g-table thead th {
-    padding: 0.75rem 1rem; text-align: left;
-    font-size: 0.6875rem; font-weight: 600; letter-spacing: 0.06em;
-    text-transform: uppercase; color: #3d4f78;
-    border-bottom: 1px solid rgba(26, 36, 68, 0.6);
-  }
-  .g-table tbody tr {
-    border-bottom: 1px solid rgba(26, 36, 68, 0.3);
-    transition: all 0.15s ease;
-  }
-  .g-table tbody tr:last-child { border-bottom: none; }
-  .g-table tbody tr:hover {
-    background: linear-gradient(90deg, rgba(0, 232, 123, 0.03) 0%, rgba(6, 182, 212, 0.02) 100%);
-  }
-  .g-table tbody td { padding: 0.875rem 1rem; vertical-align: middle; }
-
-  /* ── Badges ──────────────────────────────────────────────── */
-  .g-badge {
-    display: inline-flex; align-items: center; gap: 0.3rem;
-    padding: 0.1875rem 0.5625rem; border-radius: 99px;
-    font-size: 0.6875rem; font-weight: 600; letter-spacing: 0.02em;
-  }
-  .g-badge-green  { background: rgba(0,232,123,0.1);  border: 1px solid rgba(0,232,123,0.2);  color: #00e87b; }
-  .g-badge-amber  { background: rgba(251,191,36,0.1); border: 1px solid rgba(251,191,36,0.2); color: #fbbf24; }
-  .g-badge-red    { background: rgba(244,63,94,0.1);  border: 1px solid rgba(244,63,94,0.2);  color: #f43f5e; }
-  .g-badge-blue   { background: rgba(59,130,246,0.1); border: 1px solid rgba(59,130,246,0.2); color: #3b82f6; }
-  .g-badge-purple { background: rgba(167,139,250,0.08); border: 1px solid rgba(167,139,250,0.15); color: #a78bfa; }
-  .g-badge-neutral { background: rgba(136,150,184,0.06); border: 1px solid rgba(136,150,184,0.12); color: #8896b8; }
-
-  /* ── Gradient text ───────────────────────────────────────── */
-  .gradient-text {
-    background: linear-gradient(135deg, #f0f4ff 0%, #8896b8 100%);
-    -webkit-background-clip: text; -webkit-text-fill-color: transparent; background-clip: text;
-  }
-  .gradient-accent {
-    background: linear-gradient(135deg, #00e87b 0%, #06b6d4 100%);
-    -webkit-background-clip: text; -webkit-text-fill-color: transparent; background-clip: text;
-  }
-
-  /* ── Stat ─────────────────────────────────────────────────── */
-  .g-stat-num {
-    font-size: 2rem; font-weight: 800; letter-spacing: -0.05em;
-    line-height: 1; font-variant-numeric: tabular-nums;
-    animation: count-up 0.6s ease-out;
-  }
-
-  /* ── Divider ─────────────────────────────────────────────── */
-  .g-divider { height: 1px; background: linear-gradient(90deg, transparent, #1a2444 30%, #1a2444 70%, transparent); }
-
-  /* ── Pulse dot ───────────────────────────────────────────── */
-  .g-pulse-dot {
-    width: 8px; height: 8px; border-radius: 50%; background: #00e87b;
-    box-shadow: 0 0 8px rgba(0,232,123,0.6);
-    animation: pulse-ring 2s ease-out infinite;
-  }
-
-  /* ── Page heading ────────────────────────────────────────── */
-  .g-page-title {
-    font-size: 1.5rem; font-weight: 800; letter-spacing: -0.04em;
-    background: linear-gradient(135deg, #f0f4ff 0%, #8896b8 80%);
-    -webkit-background-clip: text; -webkit-text-fill-color: transparent; background-clip: text;
-  }
-  .g-page-sub { font-size: 0.8125rem; color: #3d4f78; margin-top: 0.25rem; }
-
-  /* ── Glow line ───────────────────────────────────────────── */
-  .glow-line {
-    height: 1px;
-    background: linear-gradient(90deg, transparent, rgba(0,232,123,0.4), rgba(6,182,212,0.3), transparent);
-  }
-
-  /* ── Shimmer effect ──────────────────────────────────────── */
-  .shimmer {
-    background: linear-gradient(90deg, transparent 0%, rgba(255,255,255,0.04) 50%, transparent 100%);
-    background-size: 200% 100%;
-    animation: shimmer 3s ease-in-out infinite;
-  }
-
-  /* ── Animated stagger ────────────────────────────────────── */
-  .animate-in { animation: fade-in-up 0.4s ease-out both; }
-
-  /* ── Backward compat aliases ─────────────────────────────── */
-  .card-panel { position: relative; background: linear-gradient(135deg, rgba(15,22,41,0.8), rgba(10,15,30,0.9)); border: 1px solid rgba(26,36,68,0.6); border-radius: 16px; overflow: hidden; }
-  .btn-ghost { display:inline-flex;align-items:center;gap:.375rem;padding:.5rem 1rem;border-radius:10px;font-size:.8125rem;font-weight:500;transition:all .2s;cursor:pointer;border:1px solid rgba(26,36,68,.8);background:rgba(15,22,41,.6);color:#8896b8; }
-  .btn-ghost:hover { background:rgba(20,28,53,.9);border-color:rgba(31,47,85,.9);color:#f0f4ff;transform:translateY(-1px);box-shadow:0 4px 16px rgba(0,0,0,.4); }
-  .btn-danger { display:inline-flex;align-items:center;gap:.375rem;padding:.5rem 1rem;border-radius:10px;font-size:.8125rem;font-weight:600;transition:all .2s;cursor:pointer;border:1px solid rgba(244,63,94,.3);background:linear-gradient(135deg,rgba(244,63,94,.1),rgba(236,72,153,.05));color:#f43f5e; }
-  .btn-danger:hover { background:linear-gradient(135deg,rgba(244,63,94,.2),rgba(236,72,153,.1));border-color:rgba(244,63,94,.5);transform:translateY(-1px); }
-  .page-title { font-size:1.5rem;font-weight:800;letter-spacing:-.04em;background:linear-gradient(135deg,#f0f4ff,#8896b8 80%);-webkit-background-clip:text;-webkit-text-fill-color:transparent;background-clip:text; }
-  .page-subtitle { font-size:.8125rem;color:#3d4f78;margin-top:.25rem; }
-}
-
-:root {
-  --background:    oklch(1 0 0);
-  --foreground:    oklch(0.145 0 0);
-  --card:    oklch(1 0 0);
-  --card-foreground:    oklch(0.145 0 0);
-  --popover:    oklch(1 0 0);
-  --popover-foreground:    oklch(0.145 0 0);
-  --primary:    oklch(0.205 0 0);
-  --primary-foreground:    oklch(0.985 0 0);
-  --secondary:    oklch(0.97 0 0);
-  --secondary-foreground:    oklch(0.205 0 0);
-  --muted:    oklch(0.97 0 0);
-  --muted-foreground:    oklch(0.556 0 0);
-  --accent:    oklch(0.97 0 0);
-  --accent-foreground:    oklch(0.205 0 0);
-  --destructive:    oklch(0.577 0.245 27.325);
-  --border:    oklch(0.922 0 0);
-  --input:    oklch(0.922 0 0);
-  --ring:    oklch(0.708 0 0);
-  --chart-1:    oklch(0.809 0.105 251.813);
-  --chart-2:    oklch(0.623 0.214 259.815);
-  --chart-3:    oklch(0.546 0.245 262.881);
-  --chart-4:    oklch(0.488 0.243 264.376);
-  --chart-5:    oklch(0.424 0.199 265.638);
-  --radius:    0.625rem;
-  --sidebar:    oklch(0.985 0 0);
-  --sidebar-foreground:    oklch(0.145 0 0);
-  --sidebar-primary:    oklch(0.205 0 0);
-  --sidebar-primary-foreground:    oklch(0.985 0 0);
-  --sidebar-accent:    oklch(0.97 0 0);
-  --sidebar-accent-foreground:    oklch(0.205 0 0);
-  --sidebar-border:    oklch(0.922 0 0);
-  --sidebar-ring:    oklch(0.708 0 0);
-}
-
-.dark {
-  --background:    oklch(0.145 0 0);
-  --foreground:    oklch(0.985 0 0);
-  --card:    oklch(0.205 0 0);
-  --card-foreground:    oklch(0.985 0 0);
-  --popover:    oklch(0.205 0 0);
-  --popover-foreground:    oklch(0.985 0 0);
-  --primary:    oklch(0.922 0 0);
-  --primary-foreground:    oklch(0.205 0 0);
-  --secondary:    oklch(0.269 0 0);
-  --secondary-foreground:    oklch(0.985 0 0);
-  --muted:    oklch(0.269 0 0);
-  --muted-foreground:    oklch(0.708 0 0);
-  --accent:    oklch(0.269 0 0);
-  --accent-foreground:    oklch(0.985 0 0);
-  --destructive:    oklch(0.704 0.191 22.216);
-  --border:    oklch(1 0 0 / 10%);
-  --input:    oklch(1 0 0 / 15%);
-  --ring:    oklch(0.556 0 0);
-  --chart-1:    oklch(0.809 0.105 251.813);
-  --chart-2:    oklch(0.623 0.214 259.815);
-  --chart-3:    oklch(0.546 0.245 262.881);
-  --chart-4:    oklch(0.488 0.243 264.376);
-  --chart-5:    oklch(0.424 0.199 265.638);
-  --sidebar:    oklch(0.205 0 0);
-  --sidebar-foreground:    oklch(0.985 0 0);
-  --sidebar-primary:    oklch(0.488 0.243 264.376);
-  --sidebar-primary-foreground:    oklch(0.985 0 0);
-  --sidebar-accent:    oklch(0.269 0 0);
-  --sidebar-accent-foreground:    oklch(0.985 0 0);
-  --sidebar-border:    oklch(1 0 0 / 10%);
-  --sidebar-ring:    oklch(0.556 0 0);
-}
-
-@theme inline {
-  --font-sans:    var(--font-sans);
-  --color-sidebar-ring:    var(--sidebar-ring);
-  --color-sidebar-border:    var(--sidebar-border);
-  --color-sidebar-accent-foreground:    var(--sidebar-accent-foreground);
-  --color-sidebar-accent:    var(--sidebar-accent);
-  --color-sidebar-primary-foreground:    var(--sidebar-primary-foreground);
-  --color-sidebar-primary:    var(--sidebar-primary);
-  --color-sidebar-foreground:    var(--sidebar-foreground);
-  --color-sidebar:    var(--sidebar);
-  --color-chart-5:    var(--chart-5);
-  --color-chart-4:    var(--chart-4);
-  --color-chart-3:    var(--chart-3);
-  --color-chart-2:    var(--chart-2);
-  --color-chart-1:    var(--chart-1);
-  --color-ring:    var(--ring);
-  --color-input:    var(--input);
-  --color-border:    var(--border);
-  --color-destructive:    var(--destructive);
-  --color-accent-foreground:    var(--accent-foreground);
-  --color-accent:    var(--accent);
-  --color-muted-foreground:    var(--muted-foreground);
-  --color-muted:    var(--muted);
-  --color-secondary-foreground:    var(--secondary-foreground);
-  --color-secondary:    var(--secondary);
-  --color-primary-foreground:    var(--primary-foreground);
-  --color-primary:    var(--primary);
-  --color-popover-foreground:    var(--popover-foreground);
-  --color-popover:    var(--popover);
-  --color-card-foreground:    var(--card-foreground);
-  --color-card:    var(--card);
-  --color-foreground:    var(--foreground);
-  --color-background:    var(--background);
-  --radius-sm:    calc(var(--radius) * 0.6);
-  --radius-md:    calc(var(--radius) * 0.8);
-  --radius-lg:    var(--radius);
-  --radius-xl:    calc(var(--radius) * 1.4);
-  --radius-2xl:    calc(var(--radius) * 1.8);
-  --radius-3xl:    calc(var(--radius) * 2.2);
-  --radius-4xl:    calc(var(--radius) * 2.6);
-}
-
-@layer base {
-  * {
-    @apply border-border outline-ring/50;
-  }
-  body {
-    @apply bg-background text-foreground;
-  }
-  html {
-    @apply font-sans;
-  }
-}
-
-/* ═══════════════════════════════════════════════════════════════
-   LIGHT MODE — Vivid lavender-ivory palette
-   Activated by: document.documentElement.setAttribute('data-theme','light')
-   ═══════════════════════════════════════════════════════════════ */
-[data-theme="light"] {
-  --color-g-base:    #faf8ff;
-  --color-g-surface: #f0e8ff;
-  --color-g-panel:   #e5d8ff;
-  --color-g-raised:  #d8c8ff;
-  --color-g-border:  #c0aef0;
-  --color-g-line:    #a898e0;
-
-  --color-g-text:    #120e38;
-  --color-g-muted:   #4a4278;
-  --color-g-faint:   #9088c0;
-
-  --color-g-green:   #009a50;
-  --color-g-green2:  #007a3e;
-  --color-g-emerald: #048555;
-  --color-g-cyan:    #0078a0;
-  --color-g-amber:   #b86e00;
-  --color-g-red:     #c4223e;
-  --color-g-blue:    #1a55c0;
-  --color-g-purple:  #5820c0;
-  --color-g-pink:    #b01870;
-}
-
-[data-theme="light"] body {
-  background: #faf8ff;
-  color: #120e38;
-}
-
-[data-theme="light"] ::selection {
-  background: rgba(88, 32, 192, 0.12);
-  color: #120e38;
-}
-
-[data-theme="light"] ::-webkit-scrollbar-thumb {
-  background: #c0aef0;
-}
-
-[data-theme="light"] .glass {
-  background: rgba(240, 232, 255, 0.75);
-  backdrop-filter: blur(20px) saturate(180%);
-  -webkit-backdrop-filter: blur(20px) saturate(180%);
-  border: 1px solid rgba(192, 174, 240, 0.5);
-}
-
-[data-theme="light"] .glass-strong {
-  background: rgba(229, 216, 255, 0.88);
-  backdrop-filter: blur(40px) saturate(200%);
-  -webkit-backdrop-filter: blur(40px) saturate(200%);
-  border: 1px solid rgba(192, 174, 240, 0.6);
-}
-
-[data-theme="light"] .g-card {
-  background: linear-gradient(135deg, rgba(240, 232, 255, 0.9) 0%, rgba(250, 248, 255, 0.95) 100%);
-  border: 1px solid rgba(192, 174, 240, 0.5);
-}
-
-[data-theme="light"] .g-card::before {
-  background: linear-gradient(135deg, rgba(255,255,255,0.5) 0%, transparent 50%);
-}
-
-[data-theme="light"] .g-card:hover {
-  border-color: rgba(0, 154, 80, 0.3);
-  box-shadow: 0 8px 32px rgba(88, 32, 192, 0.08), 0 0 0 1px rgba(0, 154, 80, 0.08);
-}
-
-[data-theme="light"] .g-card-glow {
-  background: linear-gradient(135deg, rgba(240, 232, 255, 0.9) 0%, rgba(250, 248, 255, 0.95) 100%);
-  border: 1px solid rgba(0, 154, 80, 0.2);
-  animation: none;
-}
-
-[data-theme="light"] .g-card-glow::before {
-  background: linear-gradient(135deg, rgba(0,154,80,0.05) 0%, transparent 40%, rgba(0,120,160,0.03) 100%);
-}
-
-[data-theme="light"] .g-card-glow:hover {
-  border-color: rgba(0, 154, 80, 0.4);
-  box-shadow: 0 0 30px rgba(0, 154, 80, 0.06), 0 8px 32px rgba(88, 32, 192, 0.08);
-}
-
-[data-theme="light"] .g-input {
-  background: rgba(250, 248, 255, 0.8);
-  border-color: rgba(192, 174, 240, 0.7);
-  color: #120e38;
-}
-
-[data-theme="light"] .g-input::placeholder { color: #9088c0; }
-
-[data-theme="light"] .g-input:focus {
-  border-color: rgba(0, 154, 80, 0.5);
-  box-shadow: 0 0 0 3px rgba(0, 154, 80, 0.08);
-  background: rgba(255, 255, 255, 0.9);
-}
-
-[data-theme="light"] .g-btn {
-  background: rgba(240, 232, 255, 0.7);
-  border-color: rgba(192, 174, 240, 0.7);
-  color: #4a4278;
-}
-
-[data-theme="light"] .g-btn:hover {
-  background: rgba(229, 216, 255, 0.9);
-  border-color: rgba(168, 152, 224, 0.9);
-  color: #120e38;
-}
-
-[data-theme="light"] .g-btn-primary {
-  background: linear-gradient(135deg, rgba(0, 154, 80, 0.12) 0%, rgba(0, 120, 160, 0.08) 100%);
-  border-color: rgba(0, 154, 80, 0.35);
-  color: #007a3e;
-}
-
-[data-theme="light"] .g-btn-primary:hover {
-  background: linear-gradient(135deg, rgba(0, 154, 80, 0.22) 0%, rgba(0, 120, 160, 0.12) 100%);
-  border-color: rgba(0, 154, 80, 0.55);
-  box-shadow: 0 0 24px rgba(0, 154, 80, 0.12), 0 4px 16px rgba(88, 32, 192, 0.08);
-}
-
-[data-theme="light"] .g-btn-danger {
-  background: linear-gradient(135deg, rgba(196, 34, 62, 0.08) 0%, rgba(176, 24, 112, 0.04) 100%);
-  border-color: rgba(196, 34, 62, 0.3);
-  color: #c4223e;
-}
-
-[data-theme="light"] .g-table thead tr { background: rgba(216, 200, 255, 0.4); }
-
-[data-theme="light"] .g-table tbody tr:hover {
-  background: linear-gradient(90deg, rgba(0, 154, 80, 0.03) 0%, rgba(0, 120, 160, 0.02) 100%);
-}
-
-[data-theme="light"] .g-badge-green  { background: rgba(0,154,80,0.08);  border-color: rgba(0,154,80,0.2);  color: #007a3e; }
-[data-theme="light"] .g-badge-amber  { background: rgba(184,110,0,0.08); border-color: rgba(184,110,0,0.2); color: #b86e00; }
-[data-theme="light"] .g-badge-red    { background: rgba(196,34,62,0.08); border-color: rgba(196,34,62,0.2); color: #c4223e; }
-[data-theme="light"] .g-badge-blue   { background: rgba(26,85,192,0.08); border-color: rgba(26,85,192,0.2); color: #1a55c0; }
-[data-theme="light"] .g-badge-purple { background: rgba(88,32,192,0.06); border-color: rgba(88,32,192,0.15); color: #5820c0; }
-[data-theme="light"] .g-badge-neutral { background: rgba(74,66,120,0.06); border-color: rgba(74,66,120,0.12); color: #4a4278; }
-
-[data-theme="light"] .gradient-text {
-  background: linear-gradient(135deg, #120e38 0%, #4a4278 100%);
-  -webkit-background-clip: text; -webkit-text-fill-color: transparent; background-clip: text;
-}
-
-[data-theme="light"] .gradient-accent {
-  background: linear-gradient(135deg, #009a50 0%, #0078a0 100%);
-  -webkit-background-clip: text; -webkit-text-fill-color: transparent; background-clip: text;
-}
-
-[data-theme="light"] .g-page-title {
-  background: linear-gradient(135deg, #120e38 0%, #4a4278 80%);
-  -webkit-background-clip: text; -webkit-text-fill-color: transparent; background-clip: text;
-}
-
-[data-theme="light"] .g-divider { background: linear-gradient(90deg, transparent, #c0aef0 30%, #c0aef0 70%, transparent); }
-
-[data-theme="light"] .g-pulse-dot { background: #009a50; box-shadow: 0 0 8px rgba(0,154,80,0.5); }
-
-[data-theme="light"] .glow-line {
-  background: linear-gradient(90deg, transparent, rgba(0,154,80,0.35), rgba(0,120,160,0.25), transparent);
-}
-
-[data-theme="light"] .shimmer {
-  background: linear-gradient(90deg, transparent 0%, rgba(88,32,192,0.04) 50%, transparent 100%);
-  background-size: 200% 100%;
-}
-
-[data-theme="light"] .g-stat-num { color: #120e38; }
-
-[data-theme="light"] .g-page-sub { color: #9088c0; }

frontend/app/keywords/page.tsx

@@ -1,18 +0,0 @@
-'use client'
-import { motion } from 'framer-motion'
-import KeywordsTable from '@/components/keywords/KeywordsTable'
-import ScoringRulesPanel from '@/components/keywords/ScoringRulesPanel'
-
-export default function KeywordsPage() {
-  return (
-    <div className="space-y-7">
-      <motion.div initial={{ opacity: 1, y: -8 }} animate={{ opacity: 1, y: 0 }} transition={{ duration: 0.4 }}>
-        <h1 className="g-page-title">Targets</h1>
-        <p className="g-page-sub">Search labels and AI descriptions — AI accepts or rejects lots per target</p>
-      </motion.div>
-      <KeywordsTable />
-      <div className="glow-line" />
-      <ScoringRulesPanel />
-    </div>
-  )
-}

frontend/app/layout.tsx

@@ -1,42 +0,0 @@
-import type { Metadata } from 'next'
-import { Plus_Jakarta_Sans, JetBrains_Mono, Geist } from 'next/font/google'
-import './globals.css'
-import Providers from './providers'
-import Header from '@/components/layout/Header'
-import Nav from '@/components/layout/Nav'
-import StatusBar from '@/components/layout/StatusBar'
-import AmbientBackground from '@/components/layout/AmbientBackground'
-import { cn } from "@/lib/utils";
-
-const geist = Geist({subsets:['latin'],variable:'--font-sans'});
-
-const jakarta = Plus_Jakarta_Sans({
-  subsets: ['latin'],
-  variable: '--font-jakarta',
-  weight: ['400', '500', '600', '700', '800'],
-})
-const mono = JetBrains_Mono({ subsets: ['latin'], variable: '--font-jetbrains' })
-
-export const metadata: Metadata = {
-  title: 'Ghost Node — Auction Sniper',
-}
-
-export default function RootLayout({ children }: { children: React.ReactNode }) {
-  return (
-    <html lang="en" className={cn(jakarta.variable, mono.variable, "font-sans", geist.variable)}>
-      <body className="bg-g-base text-g-text min-h-screen antialiased">
-        <Providers>
-          <AmbientBackground />
-          <Header />
-          <StatusBar />
-          <Nav />
-          <main className="relative px-6 py-8">
-            <div className="mx-auto max-w-[1400px]">
-              {children}
-            </div>
-          </main>
-        </Providers>
-      </body>
-    </html>
-  )
-}

frontend/app/listings/page.tsx

@@ -1,15 +0,0 @@
-'use client'
-import { motion } from 'framer-motion'
-import ListingsTable from '@/components/listings/ListingsTable'
-
-export default function ListingsPage() {
-  return (
-    <div className="space-y-5">
-      <motion.div initial={{ opacity: 1, y: -8 }} animate={{ opacity: 1, y: 0 }} transition={{ duration: 0.4 }}>
-        <h1 className="g-page-title">Listings</h1>
-        <p className="g-page-sub">Captured lots from all target sites</p>
-      </motion.div>
-      <ListingsTable />
-    </div>
-  )
-}

frontend/app/page.tsx

@@ -1,5 +0,0 @@
-import LandingPage from '@/components/landing/LandingPage'
-
-export default function Home() {
-  return <LandingPage />
-}

frontend/app/providers.tsx

@@ -1,10 +0,0 @@
-'use client'
-import { QueryClient, QueryClientProvider } from '@tanstack/react-query'
-import { useState } from 'react'
-
-export default function Providers({ children }: { children: React.ReactNode }) {
-  const [client] = useState(() => new QueryClient({
-    defaultOptions: { queries: { staleTime: 5000, retry: 1 } },
-  }))
-  return <QueryClientProvider client={client}>{children}</QueryClientProvider>
-}

frontend/app/settings/page.tsx

@@ -1,174 +0,0 @@
-'use client'
-import { useEffect, useState } from 'react'
-import { fetchConfig, saveConfig } from '@/lib/api/config'
-import { testTelegram, downloadBackup, restoreBackup } from '@/lib/api/system'
-import { useSettingsStore } from '@/store/settingsStore'
-
-const Field = ({
-  label, k, cfg, onChange, type = 'text', mono = false,
-}: {
-  label: string; k: string; cfg: Record<string, string>;
-  onChange: (k: string, v: string) => void; type?: string; mono?: boolean
-}) => (
-  <div className="flex items-center gap-4">
-    <label className="text-xs text-g-faint w-52 shrink-0 leading-snug">{label}</label>
-    <input
-      type={type}
-      value={cfg[k] ?? ''}
-      onChange={(e) => onChange(k, e.target.value)}
-      className={`g-input h-8 text-sm flex-1 ${mono ? 'font-mono' : ''}`}
-    />
-  </div>
-)
-
-const Section = ({ title, children }: { title: string; children: React.ReactNode }) => (
-  <div className="g-card overflow-hidden">
-    <div className="px-5 py-3 border-b border-g-border/50">
-      <h2 className="text-xs font-semibold uppercase tracking-widest text-g-faint">{title}</h2>
-    </div>
-    <div className="p-5 space-y-3.5">
-      {children}
-    </div>
-  </div>
-)
-
-export default function SettingsPage() {
-  const { config, loaded, setConfig, updateKey } = useSettingsStore()
-  const [saving, setSaving] = useState(false)
-  const [msg, setMsg] = useState('')
-
-  useEffect(() => {
-    if (!loaded) fetchConfig().then(setConfig).catch(() => setConfig({}))
-  }, [loaded, setConfig])
-
-  const save = async () => {
-    setSaving(true)
-    try { await saveConfig(config); setMsg('Saved.') }
-    catch { setMsg('Save failed.') }
-    setSaving(false)
-    setTimeout(() => setMsg(''), 3000)
-  }
-
-  const handleRestore = async (e: React.ChangeEvent<HTMLInputElement>) => {
-    const file = e.target.files?.[0]
-    if (!file) return
-    if (!confirm('Restore this backup? Current data will be replaced.')) return
-    try { await restoreBackup(file); setMsg('Restored. Restart engine.') }
-    catch { setMsg('Restore failed.') }
-  }
-
-  if (!loaded) return (
-    <div className="flex items-center gap-2 text-xs text-g-faint">
-      <span className="w-1.5 h-1.5 rounded-full bg-g-faint animate-pulse" />
-      Loading settings…
-    </div>
-  )
-
-  return (
-    <div className="space-y-6 max-w-2xl">
-      <div>
-        <h1 className="g-page-title">Settings</h1>
-        <p className="g-page-sub">Engine and alert configuration</p>
-      </div>
-
-      <Section title="Telegram">
-        <Field label="Bot token"  k="telegram_token"   cfg={config} onChange={updateKey} mono />
-        <Field label="Chat ID"    k="telegram_chat_id" cfg={config} onChange={updateKey} mono />
-        <button onClick={async () => {
-          try { await testTelegram(); setMsg('Telegram OK!') }
-          catch { setMsg('Telegram failed.') }
-        }} className="g-btn text-xs">
-          Send test message
-        </button>
-      </Section>
-
-      <Section title="Engine">
-        <Field label="Scrape interval (s)"         k="timer"                 cfg={config} onChange={updateKey} type="number" />
-        <Field label="Browser"                     k="browser_choice"        cfg={config} onChange={updateKey} />
-        <Field label="Humanize level"              k="humanize_level"        cfg={config} onChange={updateKey} />
-        <Field label="Show browser (true/false)"   k="show_browser"          cfg={config} onChange={updateKey} />
-        <Field label="Incognito mode"              k="incognito_mode"        cfg={config} onChange={updateKey} />
-        <Field label="Delay launch (s)"            k="delay_launch"          cfg={config} onChange={updateKey} type="number" />
-        <Field label="Delay post-search (s)"       k="delay_post_search"     cfg={config} onChange={updateKey} type="number" />
-        <Field label="Scrape window enabled"       k="scrape_window_enabled" cfg={config} onChange={updateKey} />
-        <Field label="Window start hour (0–23)"    k="scrape_start_hour"     cfg={config} onChange={updateKey} type="number" />
-        <Field label="Window end hour (0–23)"      k="scrape_end_hour"       cfg={config} onChange={updateKey} type="number" />
-        <Field label="Boost interval (min)"        k="boost_interval_mins"   cfg={config} onChange={updateKey} type="number" />
-      </Section>
-
-      <Section title="Alerts">
-        <Field label="Alert channels (telegram,discord,email)" k="alert_channels"         cfg={config} onChange={updateKey} />
-        <Field label="Discord webhook"                         k="discord_webhook"        cfg={config} onChange={updateKey} />
-        <Field label="Gmail address"                           k="gmail_address"          cfg={config} onChange={updateKey} />
-        <Field label="Gmail app password"                      k="gmail_app_password"     cfg={config} onChange={updateKey} type="password" mono />
-        <Field label="Email to"                                k="email_to"               cfg={config} onChange={updateKey} />
-        <Field label="Closing alerts (true/false)"             k="closing_alert_enabled"  cfg={config} onChange={updateKey} />
-        <Field label="Alert schedule (min, e.g. 60,30,10)"    k="closing_alert_schedule" cfg={config} onChange={updateKey} />
-      </Section>
-
-      <Section title="Currency">
-        <Field label="Display currency (blank = raw)"  k="display_currency" cfg={config} onChange={updateKey} />
-      </Section>
-
-      <Section title="Proxy">
-        <Field label="Proxy enabled (true/false)" k="proxy_enabled" cfg={config} onChange={updateKey} />
-        <div className="flex items-start gap-4">
-          <label className="text-xs text-g-faint w-52 shrink-0 pt-1.5">Proxy list</label>
-          <textarea
-            value={config['proxy_list'] ?? ''}
-            onChange={(e) => updateKey('proxy_list', e.target.value)}
-            rows={3}
-            placeholder={"http://proxy1:8080\nsocks5://proxy2:1080"}
-            className="g-input text-sm font-mono resize-none flex-1"
-          />
-        </div>
-      </Section>
-
-      <Section title="CAPTCHA">
-        <Field label="Solver (2captcha / capsolver)" k="captcha_solver"  cfg={config} onChange={updateKey} />
-        <Field label="API key"                       k="captcha_api_key" cfg={config} onChange={updateKey} type="password" mono />
-      </Section>
-
-      <Section title="AI Filter">
-        <Field label="AI enabled (true/false)"  k="ai_filter_enabled"  cfg={config} onChange={updateKey} />
-        <Field label="AI provider (groq/ollama)" k="ai_provider"       cfg={config} onChange={updateKey} />
-        <Field label="AI model"                 k="ai_model"           cfg={config} onChange={updateKey} mono />
-        <Field label="Groq API key"             k="ai_api_key"         cfg={config} onChange={updateKey} type="password" mono />
-        <Field label="Ollama URL"               k="ai_base_url"        cfg={config} onChange={updateKey} />
-        <Field label="AI debug (true/false)"    k="ai_debug"           cfg={config} onChange={updateKey} />
-        <Field label="Auto-adapt (true/false)"  k="auto_adapt_enabled" cfg={config} onChange={updateKey} />
-      </Section>
-
-      <Section title="Database">
-        <Field label="DB URL (blank = SQLite)"           k="db_url"                   cfg={config} onChange={updateKey} mono />
-        <Field label="Auto-disable after N failures (0 = never)" k="site_auto_disable_after" cfg={config} onChange={updateKey} type="number" />
-      </Section>
-
-      <Section title="Backup & Restore">
-        <div className="flex gap-2">
-          <button onClick={downloadBackup} className="g-btn text-xs">Download backup</button>
-          <label className="g-btn text-xs cursor-pointer">
-            Restore backup
-            <input type="file" accept=".db" onChange={handleRestore} className="hidden" />
-          </label>
-        </div>
-      </Section>
-
-      {/* Save bar */}
-      <div className="flex gap-3 items-center pt-2">
-        <button
-          onClick={save}
-          disabled={saving}
-          className="g-btn-primary text-sm px-5 disabled:opacity-50"
-        >
-          {saving ? 'Saving…' : 'Save settings'}
-        </button>
-        {msg && (
-          <span className={`text-xs ${msg.includes('fail') || msg.includes('fail') ? 'text-g-red' : 'text-g-green'}`}>
-            {msg}
-          </span>
-        )}
-      </div>
-    </div>
-  )
-}

frontend/app/sites/page.tsx

@@ -1,15 +0,0 @@
-'use client'
-import { motion } from 'framer-motion'
-import SitesTable from '@/components/sites/SitesTable'
-
-export default function SitesPage() {
-  return (
-    <div className="space-y-5">
-      <motion.div initial={{ opacity: 1, y: -8 }} animate={{ opacity: 1, y: 0 }} transition={{ duration: 0.4 }}>
-        <h1 className="g-page-title">Sites</h1>
-        <p className="g-page-sub">Auction sources and health status</p>
-      </motion.div>
-      <SitesTable />
-    </div>
-  )
-}

frontend/components/ai-log/AILogCard.tsx

@@ -1,123 +0,0 @@
-'use client'
-import { useState } from 'react'
-import { cn } from '@/lib/utils'
-
-interface RawEntry {
-  id: number
-  ts: string
-  call_type: string
-  direction: string
-  provider?: string
-  model?: string
-  content?: string
-  title?: string
-  site?: string
-  tokens_prompt?: number
-  tokens_completion?: number
-  verdict?: string
-  status_code?: number
-}
-
-export default function AILogCard({ entry }: { entry: RawEntry }) {
-  const [expanded, setExpanded] = useState(false)
-
-  const isRequest  = entry.direction === 'request'
-  const isResponse = entry.direction === 'response'
-  const isError    = entry.direction === 'error'
-  const isMatch    = entry.verdict === 'YES'
-  const isReject   = entry.verdict === 'NO'
-
-  const totalTokens = (entry.tokens_prompt ?? 0) + (entry.tokens_completion ?? 0)
-
-  return (
-    <div className={cn(
-      'rounded-lg border text-sm transition-colors',
-      isError    ? 'border-g-red/20 bg-g-red/4'    :
-      isMatch    ? 'border-g-green/20 bg-g-green/4' :
-      isReject   ? 'border-g-line'                   :
-                   'border-g-border/60',
-    )}>
-      {/* Header */}
-      <div className="flex items-center justify-between gap-3 flex-wrap px-3.5 py-2.5">
-        <div className="flex items-center gap-2 flex-wrap">
-          {/* Direction badge */}
-          <span className={cn(
-            'g-badge',
-            isRequest  ? 'g-badge-neutral' :
-            isResponse ? (isMatch ? 'g-badge-green' : isReject ? 'g-badge-red' : 'g-badge-neutral') :
-                         'g-badge-red'
-          )}>
-            {isRequest ? '→ Prompt' : isResponse ? '← Response' : '⚠ Error'}
-          </span>
-          <span className="g-badge g-badge-neutral">{entry.call_type}</span>
-          {entry.provider && <span className="text-xs text-g-faint">{entry.provider}</span>}
-          {entry.model && (
-            <span className="text-xs text-g-faint truncate max-w-[160px]">{entry.model}</span>
-          )}
-        </div>
-        <span className="text-[11px] text-g-faint tabular-nums shrink-0">
-          {new Date(entry.ts).toLocaleTimeString()}
-        </span>
-      </div>
-
-      {/* Lot info */}
-      {(entry.title || entry.site) && (
-        <div className="px-3.5 pb-2 flex items-center gap-2 flex-wrap">
-          {entry.title && (
-            <span className="text-xs text-g-text leading-relaxed">
-              {entry.title.length > 72 ? entry.title.slice(0, 72) + '…' : entry.title}
-            </span>
-          )}
-          {entry.site && <span className="text-xs text-g-faint">· {entry.site}</span>}
-        </div>
-      )}
-
-      {/* Verdict */}
-      {isResponse && entry.verdict && (
-        <div className={cn(
-          'px-3.5 pb-2 flex items-center gap-1.5 text-xs font-medium',
-          isMatch ? 'text-g-green' : 'text-g-red'
-        )}>
-          <span className={cn('w-1.5 h-1.5 rounded-full flex-shrink-0', isMatch ? 'bg-g-green' : 'bg-g-red')} />
-          {isMatch ? 'Match — lot accepted' : 'Reject — lot filtered out'}
-        </div>
-      )}
-
-      {/* Expandable content */}
-      {entry.content && (
-        <div className="px-3.5 pb-3">
-          <pre className={cn(
-            'whitespace-pre-wrap break-words text-[11px] leading-relaxed font-mono',
-            'bg-g-base/80 border border-g-border/40 p-3 rounded-md',
-            isRequest ? 'text-g-faint' : 'text-g-muted',
-            !expanded && 'max-h-20 overflow-hidden',
-          )}>
-            {entry.content}
-          </pre>
-          {entry.content.length > 180 && (
-            <button
-              onClick={() => setExpanded(!expanded)}
-              className="text-g-faint hover:text-g-muted text-[11px] mt-1 transition-colors"
-            >
-              {expanded ? '▲ Collapse' : `▼ Expand (${entry.content.length} chars)`}
-            </button>
-          )}
-        </div>
-      )}
-
-      {/* Token counts */}
-      {(entry.tokens_prompt != null || entry.tokens_completion != null) && (
-        <div className="px-3.5 pb-2.5 flex items-center gap-2 text-[11px] text-g-faint">
-          <span className="g-badge g-badge-neutral">
-            {entry.tokens_prompt ?? '?'} + {entry.tokens_completion ?? '?'} = {totalTokens} tokens
-          </span>
-        </div>
-      )}
-
-      {/* Error */}
-      {isError && entry.status_code && (
-        <div className="px-3.5 pb-2 text-xs text-g-red font-mono">HTTP {entry.status_code}</div>
-      )}
-    </div>
-  )
-}

frontend/components/ai-log/AILogFeed.tsx

@@ -1,113 +0,0 @@
-'use client'
-import { useState, useEffect, useCallback } from 'react'
-import AILogCard from './AILogCard'
-import { fetchAILog, clearAILog } from '@/lib/api/ai'
-import { cn } from '@/lib/utils'
-
-type Filter = 'ALL' | 'FILTER' | 'ADAPT' | 'ERRORS'
-
-const LABELS: Record<Filter, string> = {
-  ALL: 'All', FILTER: 'Filter calls', ADAPT: 'Adapt calls', ERRORS: 'Errors',
-}
-
-export default function AILogFeed() {
-  const [entries,  setEntries]  = useState<any[]>([])
-  const [debugOn,  setDebugOn]  = useState<boolean | null>(null)
-  const [total,    setTotal]    = useState(0)
-  const [filter,   setFilter]   = useState<Filter>('ALL')
-  const [search,   setSearch]   = useState('')
-
-  const load = useCallback(async () => {
-    try {
-      const data = await fetchAILog(200)
-      setEntries(Array.isArray(data.entries) ? data.entries : [])
-      setDebugOn(data.debug_enabled ?? null)
-      setTotal(data.total_in_buffer ?? 0)
-    } catch {}
-  }, [])
-
-  useEffect(() => {
-    load()
-    const t = setInterval(load, 5000)
-    return () => clearInterval(t)
-  }, [load])
-
-  const filtered = entries.filter((e) => {
-    if (filter === 'FILTER' && e.call_type !== 'filter') return false
-    if (filter === 'ADAPT'  && e.call_type !== 'adapt')  return false
-    if (filter === 'ERRORS' && e.direction !== 'error')  return false
-    if (search && !JSON.stringify(e).toLowerCase().includes(search.toLowerCase())) return false
-    return true
-  })
-
-  return (
-    <div className="space-y-4">
-      {/* Toolbar */}
-      <div className="flex gap-2 flex-wrap items-center">
-        {(['ALL', 'FILTER', 'ADAPT', 'ERRORS'] as Filter[]).map((f) => (
-          <button
-            key={f}
-            onClick={() => setFilter(f)}
-            className={cn(
-              'g-btn text-xs h-8',
-              filter === f && '!border-g-green/40 !text-g-green !bg-g-green/8'
-            )}
-          >
-            {LABELS[f]}
-          </button>
-        ))}
-        <div className="relative ml-auto">
-          <span className="absolute left-2.5 top-1/2 -translate-y-1/2 text-g-faint text-xs">⌕</span>
-          <input
-            value={search}
-            onChange={(e) => setSearch(e.target.value)}
-            placeholder="Search log…"
-            className="g-input h-8 pl-7 text-xs w-44"
-          />
-        </div>
-        <button onClick={load}  className="g-btn text-xs h-8">Refresh</button>
-        <button
-          onClick={async () => { await clearAILog(); setEntries([]); setTotal(0) }}
-          className="g-btn-danger text-xs h-8"
-        >
-          Clear
-        </button>
-      </div>
-
-      {/* Status strip */}
-      <div className="flex items-center gap-4 text-xs text-g-faint">
-        {debugOn === false && (
-          <span className="flex items-center gap-1.5 text-g-amber">
-            <span className="w-1.5 h-1.5 rounded-full bg-g-amber flex-shrink-0" />
-            AI Debug is off — enable it in Settings → AI Filter to capture logs
-          </span>
-        )}
-        {debugOn === true && (
-          <span className="flex items-center gap-1.5 text-g-green">
-            <span className="w-1.5 h-1.5 rounded-full bg-g-green animate-pulse flex-shrink-0" />
-            AI Debug on
-          </span>
-        )}
-        {total > 0 && <span>{total} entries · showing {filtered.length}</span>}
-      </div>
-
-      {/* Entries */}
-      <div className="g-card overflow-hidden">
-        <div className="max-h-[72vh] overflow-y-auto p-4 space-y-2">
-          {filtered.length === 0 ? (
-            <div className="flex flex-col items-center justify-center py-14 text-g-faint gap-2">
-              <span className="text-3xl opacity-20">◎</span>
-              <p className="text-sm">
-                {debugOn === false
-                  ? 'Enable AI Debug in Settings to start capturing logs'
-                  : 'No AI log entries'}
-              </p>
-            </div>
-          ) : (
-            [...filtered].reverse().map((e) => <AILogCard key={e.id} entry={e} />)
-          )}
-        </div>
-      </div>
-    </div>
-  )
-}

frontend/components/dashboard/ActivityLog.tsx

@@ -1,165 +0,0 @@
-'use client'
-import { useEffect, useRef, useState, useCallback } from 'react'
-import { motion, AnimatePresence } from 'framer-motion'
-import { useEngineStore } from '@/store/engineStore'
-
-interface LogEntry {
-  id: number
-  time: string
-  msg: string
-  level: 'info' | 'success' | 'warn' | 'error'
-}
-
-let _counter = 1
-
-function makeEntry(msg: string, level: LogEntry['level'] = 'info'): LogEntry {
-  return { id: _counter++, time: new Date().toLocaleTimeString(), msg, level }
-}
-
-const LEVEL_STYLES: Record<LogEntry['level'], string> = {
-  info:    'text-g-muted',
-  success: 'text-g-green',
-  warn:    'text-g-amber',
-  error:   'text-g-red',
-}
-
-const LEVEL_DOT: Record<LogEntry['level'], string> = {
-  info:    'bg-g-faint/40',
-  success: 'bg-g-green',
-  warn:    'bg-g-amber',
-  error:   'bg-g-red',
-}
-
-export default function ActivityLog() {
-  const [entries, setEntries] = useState<LogEntry[]>(() => [
-    makeEntry('Ghost Node dashboard initialised.', 'success'),
-  ])
-  const [filter, setFilter]   = useState('')
-  const bottomRef = useRef<HTMLDivElement>(null)
-
-  const { status, last_cycle, total_alerts } = useEngineStore()
-
-  const prevStatus   = useRef<string | null>(null)
-  const prevCycle    = useRef<string | null>(null)
-  const prevAlerts   = useRef<number>(-1)
-
-  const push = useCallback((msg: string, level: LogEntry['level'] = 'info') => {
-    setEntries(prev => [...prev.slice(-199), makeEntry(msg, level)])
-  }, [])
-
-  // Track engine status transitions
-  useEffect(() => {
-    if (prevStatus.current === null) { prevStatus.current = status; return }
-    if (prevStatus.current === status) return
-    if (status === 'Running')      push('Engine started.', 'success')
-    else if (status === 'Paused')  push('Engine paused.', 'warn')
-    else if (status === 'Idle')    push('Engine stopped.', 'warn')
-    prevStatus.current = status
-  }, [status, push])
-
-  // Track scan cycles
-  useEffect(() => {
-    if (prevCycle.current === null) { prevCycle.current = last_cycle; return }
-    if (prevCycle.current === last_cycle) return
-    if (last_cycle && last_cycle !== 'Never') {
-      push('Scan cycle completed.', 'info')
-    }
-    prevCycle.current = last_cycle
-  }, [last_cycle, push])
-
-  // Track new alerts
-  useEffect(() => {
-    if (prevAlerts.current === -1) { prevAlerts.current = total_alerts; return }
-    if (total_alerts > prevAlerts.current) {
-      const delta = total_alerts - prevAlerts.current
-      push(`${delta} new alert${delta > 1 ? 's' : ''} fired!`, 'success')
-    }
-    prevAlerts.current = total_alerts
-  }, [total_alerts, push])
-
-  // Auto-scroll to bottom
-  useEffect(() => {
-    bottomRef.current?.scrollIntoView({ behavior: 'smooth' })
-  }, [entries])
-
-  const filtered = filter
-    ? entries.filter(e => e.msg.toLowerCase().includes(filter.toLowerCase()))
-    : entries
-
-  return (
-    <motion.div
-      initial={{ opacity: 1, y: 12 }}
-      animate={{ opacity: 1, y: 0 }}
-      transition={{ delay: 0.2, duration: 0.4, ease: [0.22, 1, 0.36, 1] }}
-      className="g-card overflow-hidden"
-    >
-      {/* ── Header ── */}
-      <div className="flex items-center gap-3 px-5 py-3.5 border-b border-g-border/40">
-        <div className="flex items-center gap-2.5">
-          <span className="g-pulse-dot" />
-          <span className="text-sm font-bold text-g-text tracking-tight">Activity Log</span>
-        </div>
-        <span className="text-[10px] text-g-faint font-mono tabular-nums">
-          {entries.length} events
-        </span>
-
-        <div className="ml-auto flex items-center gap-2">
-          <input
-            value={filter}
-            onChange={e => setFilter(e.target.value)}
-            placeholder="Filter events…"
-            className="g-input w-36 h-7 text-[11px] py-0 px-2.5"
-          />
-          <button
-            onClick={() => bottomRef.current?.scrollIntoView({ behavior: 'smooth' })}
-            className="g-btn h-7 px-2 text-xs"
-            title="Scroll to bottom"
-          >
-            <svg width="10" height="10" viewBox="0 0 24 24" fill="none" stroke="currentColor" strokeWidth="2.5" strokeLinecap="round" strokeLinejoin="round">
-              <line x1="12" y1="5" x2="12" y2="19"/><polyline points="19 12 12 19 5 12"/>
-            </svg>
-          </button>
-          <button
-            onClick={() => setEntries([])}
-            className="g-btn h-7 px-2.5 text-xs hover:!text-g-red hover:!border-g-red/30"
-          >
-            Clear
-          </button>
-        </div>
-      </div>
-
-      {/* ── Body ── */}
-      <div className="h-48 overflow-y-auto p-4 font-mono">
-        {filtered.length === 0 ? (
-          <p className="text-g-faint/30 text-[11px] text-center py-8">No events</p>
-        ) : (
-          <AnimatePresence mode="popLayout" initial={false}>
-            {filtered.map(e => (
-              <motion.div
-                key={e.id}
-                initial={{ opacity: 1, x: -6 }}
-                animate={{ opacity: 1, x: 0 }}
-                exit={{ opacity: 0, height: 0 }}
-                transition={{ duration: 0.2 }}
-                className="flex items-start gap-3 py-1.5 group"
-              >
-                <span className="shrink-0 text-[10px] text-g-faint/40 pt-px tabular-nums leading-relaxed">
-                  {e.time}
-                </span>
-                <span
-                  className={`w-1 h-1 rounded-full mt-1.5 shrink-0 ${LEVEL_DOT[e.level]}`}
-                />
-                <span
-                  className={`text-[11px] leading-relaxed transition-opacity group-hover:opacity-100 opacity-80 ${LEVEL_STYLES[e.level]}`}
-                >
-                  {e.msg}
-                </span>
-              </motion.div>
-            ))}
-          </AnimatePresence>
-        )}
-        <div ref={bottomRef} />
-      </div>
-    </motion.div>
-  )
-}

frontend/components/dashboard/EngineConsole.tsx

@@ -1,297 +0,0 @@
-'use client'
-import { useEffect, useState, useRef, useCallback } from 'react'
-import { motion } from 'framer-motion'
-import { cn, formatUptime, timeAgo } from '@/lib/utils'
-import { useEngineStore } from '@/store/engineStore'
-import {
-  pauseEngine,
-  resumeEngine,
-  restartEngine,
-  killEngine,
-} from '@/lib/api/engine'
-import type { TargetSite } from '@/lib/types'
-
-const BASE = 'http://localhost:8000'
-const SITE_POLL_MS = 25_000
-
-function StatusOrb({ status }: { status: 'Running' | 'Paused' | 'Idle' }) {
-  const map = {
-    Running: { color: '#00e87b', label: 'Running', shadow: 'rgba(0,232,123,0.5)' },
-    Paused:  { color: '#fbbf24', label: 'Paused',  shadow: 'rgba(251,191,36,0.5)' },
-    Idle:    { color: '#3d4f78', label: 'Idle',    shadow: 'rgba(61,79,120,0.3)'  },
-  }
-  const m = map[status] ?? map.Idle
-
-  return (
-    <div className="flex items-center gap-2.5">
-      {/* Pulsing dot + aura */}
-      <div className="relative flex items-center justify-center">
-        {status === 'Running' && (
-          <span
-            className="absolute inline-flex rounded-full opacity-60"
-            style={{
-              width: 20, height: 20,
-              background: m.color,
-              filter: 'blur(6px)',
-              animation: 'glow-pulse 2s ease-in-out infinite',
-            }}
-          />
-        )}
-        <span
-          className="relative inline-flex rounded-full"
-          style={{
-            width: 10, height: 10,
-            background: m.color,
-            boxShadow: `0 0 10px ${m.shadow}`,
-            animation: status === 'Running' ? 'pulse-ring 2s ease-out infinite' : undefined,
-          }}
-        />
-      </div>
-      <span
-        className="text-[13px] font-bold tracking-tight"
-        style={{ color: m.color }}
-      >
-        {m.label}
-      </span>
-    </div>
-  )
-}
-
-interface CtrlBtn {
-  label: string
-  icon: React.ReactNode
-  onClick: () => void
-  variant: 'default' | 'danger'
-  disabled?: boolean
-}
-
-function ControlButton({ label, icon, onClick, variant, disabled }: CtrlBtn) {
-  const [busy, setBusy] = useState(false)
-
-  const handle = async () => {
-    if (busy || disabled) return
-    setBusy(true)
-    try { await onClick() } finally {
-      setTimeout(() => setBusy(false), 1500)
-    }
-  }
-
-  return (
-    <motion.button
-      whileHover={!disabled ? { scale: 1.03, y: -1 } : undefined}
-      whileTap={!disabled ? { scale: 0.96 } : undefined}
-      onClick={handle}
-      disabled={disabled || busy}
-      className={cn(
-        'flex items-center justify-center gap-1.5 rounded-xl text-[11px] font-semibold px-3 py-2.5 transition-all duration-200',
-        'border disabled:opacity-40 disabled:cursor-not-allowed',
-        variant === 'danger'
-          ? 'border-g-red/25 bg-g-red/8 text-g-red hover:bg-g-red/15 hover:border-g-red/40 hover:shadow-[0_0_20px_rgba(244,63,94,0.12)]'
-          : 'border-g-border/60 bg-g-raised/60 text-g-muted hover:text-g-text hover:border-g-line hover:bg-g-raised hover:shadow-[0_4px_16px_rgba(0,0,0,0.4)]',
-      )}
-    >
-      {busy ? (
-        <svg
-          className="animate-spin shrink-0"
-          width="11" height="11" viewBox="0 0 24 24"
-          fill="none" stroke="currentColor" strokeWidth="2.5"
-        >
-          <path d="M21 12a9 9 0 1 1-6.219-8.56"/>
-        </svg>
-      ) : icon}
-      {label}
-    </motion.button>
-  )
-}
-
-function SiteRow({ site }: { site: TargetSite }) {
-  const isEnabled = site.enabled === 1
-  const isCooling = site.cooldown_until ? new Date(site.cooldown_until) > new Date() : false
-  const hasError = site.consecutive_failures > 0
-
-  let statusColor = '#3d4f78'
-  let statusLabel = 'Disabled'
-  if (isEnabled && isCooling) { statusColor = '#fbbf24'; statusLabel = 'Cooldown' }
-  else if (isEnabled && hasError) { statusColor = '#f43f5e'; statusLabel = `${site.consecutive_failures}x fail` }
-  else if (isEnabled) { statusColor = '#00e87b'; statusLabel = 'Active' }
-
-  return (
-    <div className="flex items-center gap-2.5 py-2 px-4 border-b border-g-border/15 last:border-0 group">
-      <span
-        className="w-1.5 h-1.5 rounded-full shrink-0 transition-all"
-        style={{
-          background: statusColor,
-          boxShadow: isEnabled && !isCooling && !hasError ? `0 0 5px ${statusColor}80` : undefined,
-        }}
-      />
-      <span className="flex-1 text-[11px] text-g-muted group-hover:text-g-text transition-colors truncate font-medium">
-        {site.name}
-      </span>
-      <span
-        className="text-[10px] font-semibold shrink-0 tabular-nums"
-        style={{ color: statusColor }}
-      >
-        {statusLabel}
-      </span>
-    </div>
-  )
-}
-
-export default function EngineConsole() {
-  const { status, uptime_seconds, total_scanned, last_cycle, isOffline } = useEngineStore()
-  const [sites, setSites] = useState<TargetSite[]>([])
-  const [cycleAgo, setCycleAgo] = useState('—')
-  const aliveRef = useRef(true)
-
-  const fetchSites = useCallback(async () => {
-    try {
-      const res = await fetch(`${BASE}/api/sites`)
-      const data: TargetSite[] = await res.json()
-      if (aliveRef.current) setSites(Array.isArray(data) ? data : [])
-    } catch { /* silent */ }
-  }, [])
-
-  useEffect(() => {
-    aliveRef.current = true
-    fetchSites()
-    const id = setInterval(fetchSites, SITE_POLL_MS)
-    return () => { aliveRef.current = false; clearInterval(id) }
-  }, [fetchSites])
-
-  // Live relative timestamp
-  useEffect(() => {
-    const tick = () => setCycleAgo(timeAgo(last_cycle === 'Never' ? null : last_cycle))
-    tick()
-    const id = setInterval(tick, 5000)
-    return () => clearInterval(id)
-  }, [last_cycle])
-
-  const isRunning = status === 'Running'
-  const isPaused  = status === 'Paused'
-  const enabledCount = sites.filter(s => s.enabled === 1).length
-
-  const controls: CtrlBtn[] = [
-    {
-      label: 'Pause',
-      variant: 'default',
-      disabled: !isRunning,
-      onClick: () => pauseEngine(),
-      icon: (
-        <svg width="11" height="11" viewBox="0 0 24 24" fill="none" stroke="currentColor" strokeWidth="2.5" strokeLinecap="round" strokeLinejoin="round">
-          <rect x="6" y="4" width="4" height="16"/><rect x="14" y="4" width="4" height="16"/>
-        </svg>
-      ),
-    },
-    {
-      label: 'Resume',
-      variant: 'default',
-      disabled: !isPaused,
-      onClick: () => resumeEngine(),
-      icon: (
-        <svg width="11" height="11" viewBox="0 0 24 24" fill="none" stroke="currentColor" strokeWidth="2.5" strokeLinecap="round" strokeLinejoin="round">
-          <polygon points="5 3 19 12 5 21 5 3"/>
-        </svg>
-      ),
-    },
-    {
-      label: 'Restart',
-      variant: 'default',
-      disabled: false,
-      onClick: () => restartEngine(),
-      icon: (
-        <svg width="11" height="11" viewBox="0 0 24 24" fill="none" stroke="currentColor" strokeWidth="2.5" strokeLinecap="round" strokeLinejoin="round">
-          <polyline points="1 4 1 10 7 10"/><path d="M3.51 15a9 9 0 1 0 .49-3.51"/>
-        </svg>
-      ),
-    },
-    {
-      label: 'Kill',
-      variant: 'danger',
-      disabled: false,
-      onClick: () => killEngine(),
-      icon: (
-        <svg width="11" height="11" viewBox="0 0 24 24" fill="none" stroke="currentColor" strokeWidth="2.5" strokeLinecap="round" strokeLinejoin="round">
-          <line x1="18" y1="6" x2="6" y2="18"/><line x1="6" y1="6" x2="18" y2="18"/>
-        </svg>
-      ),
-    },
-  ]
-
-  return (
-    <motion.div
-      initial={{ opacity: 1, x: 12 }}
-      animate={{ opacity: 1, x: 0 }}
-      transition={{ delay: 0.2, duration: 0.5, ease: [0.22, 1, 0.36, 1] }}
-      className="g-card flex flex-col overflow-hidden"
-    >
-      {/* ── Status Hero ── */}
-      <div className="px-5 pt-5 pb-4 border-b border-g-border/40 space-y-4">
-        <div className="flex items-center justify-between">
-          <span className="text-[10px] font-bold uppercase tracking-[0.14em] text-g-faint">
-            Engine Status
-          </span>
-          {isOffline && (
-            <span className="g-badge g-badge-red text-[9px]">OFFLINE</span>
-          )}
-        </div>
-
-        {/* Big status */}
-        <StatusOrb status={status} />
-
-        {/* Telemetry strip */}
-        <div className="grid grid-cols-2 gap-3">
-          <div className="bg-g-raised/50 rounded-xl p-3 border border-g-border/30">
-            <p className="text-[9px] uppercase tracking-widest text-g-faint font-bold mb-1">Uptime</p>
-            <p className="text-sm font-bold text-g-text tabular-nums font-mono">
-              {formatUptime(uptime_seconds)}
-            </p>
-          </div>
-          <div className="bg-g-raised/50 rounded-xl p-3 border border-g-border/30">
-            <p className="text-[9px] uppercase tracking-widest text-g-faint font-bold mb-1">Last Scan</p>
-            <p className="text-sm font-bold text-g-text tabular-nums font-mono">
-              {cycleAgo}
-            </p>
-          </div>
-          <div className="bg-g-raised/50 rounded-xl p-3 border border-g-border/30 col-span-2">
-            <p className="text-[9px] uppercase tracking-widest text-g-faint font-bold mb-1">Lots Scanned</p>
-            <p className="text-sm font-bold text-g-text tabular-nums font-mono">
-              {total_scanned.toLocaleString()}
-            </p>
-          </div>
-        </div>
-      </div>
-
-      {/* ── Controls ── */}
-      <div className="px-5 py-4 border-b border-g-border/40 space-y-2.5">
-        <span className="text-[10px] font-bold uppercase tracking-[0.14em] text-g-faint block">
-          Controls
-        </span>
-        <div className="grid grid-cols-2 gap-2">
-          {controls.map(btn => (
-            <ControlButton key={btn.label} {...btn} />
-          ))}
-        </div>
-      </div>
-
-      {/* ── Site Health ── */}
-      <div className="flex flex-col flex-1 min-h-0">
-        <div className="flex items-center gap-2 px-4 py-2.5 border-b border-g-border/25">
-          <span className="text-[10px] font-bold uppercase tracking-[0.14em] text-g-faint">
-            Sites
-          </span>
-          <span className="text-[10px] text-g-faint/50 font-mono ml-auto">
-            {enabledCount}/{sites.length} active
-          </span>
-        </div>
-
-        <div className="flex-1 overflow-y-auto" style={{ maxHeight: 200 }}>
-          {sites.length === 0 ? (
-            <p className="text-[11px] text-g-faint/40 text-center py-6">No sites configured</p>
-          ) : (
-            sites.map(s => <SiteRow key={s.id} site={s} />)
-          )}
-        </div>
-      </div>
-    </motion.div>
-  )
-}

frontend/components/dashboard/RecentListings.tsx

@@ -1,276 +0,0 @@
-'use client'
-import { useEffect, useState, useRef, useCallback } from 'react'
-import { motion, AnimatePresence } from 'framer-motion'
-import { cn, formatPrice, formatMins } from '@/lib/utils'
-import type { Listing } from '@/lib/types'
-import { fetchListings } from '@/lib/api/listings'
-
-const REFRESH_MS = 10_000
-
-function UrgencyBadge({ mins }: { mins: number | null }) {
-  if (mins === null) return <span className="text-[10px] text-g-faint font-mono">—</span>
-
-  const isUrgent = mins <= 60
-  const isWarning = mins > 60 && mins <= 180
-
-  if (isUrgent) {
-    return (
-      <span className="inline-flex items-center gap-1 text-[10px] font-bold text-g-red tabular-nums">
-        <span
-          className="w-1.5 h-1.5 rounded-full bg-g-red shrink-0"
-          style={{ animation: 'pulse-ring 1.5s ease-out infinite', boxShadow: '0 0 6px #f43f5e' }}
-        />
-        {formatMins(mins)}
-      </span>
-    )
-  }
-  if (isWarning) {
-    return (
-      <span className="inline-flex items-center gap-1 text-[10px] font-semibold text-g-amber tabular-nums">
-        <span className="w-1.5 h-1.5 rounded-full bg-g-amber/60 shrink-0" />
-        {formatMins(mins)}
-      </span>
-    )
-  }
-  return (
-    <span className="text-[10px] text-g-faint/70 font-mono tabular-nums">
-      {formatMins(mins)}
-    </span>
-  )
-}
-
-function AiBadge({ match }: { match: 1 | 0 | null }) {
-  if (match === 1)
-    return <span className="g-badge g-badge-green text-[9px] tracking-wide">✓ AI</span>
-  if (match === 0)
-    return <span className="g-badge g-badge-red text-[9px] tracking-wide">✗ AI</span>
-  return null
-}
-
-function ScorePill({ score }: { score: number }) {
-  const color =
-    score >= 50
-      ? 'text-g-green'
-      : score >= 20
-      ? 'text-g-amber'
-      : score >= 0
-      ? 'text-g-muted'
-      : 'text-g-red'
-  return (
-    <span className={cn('text-[11px] font-bold tabular-nums font-mono', color)}>
-      {score > 0 ? `+${score}` : score}
-    </span>
-  )
-}
-
-function Thumbnail({ src }: { src: string | undefined }) {
-  const [err, setErr] = useState(false)
-
-  if (!src || err) {
-    return (
-      <div className="w-9 h-9 rounded-lg bg-g-raised border border-g-border/40 flex items-center justify-center shrink-0">
-        <svg width="14" height="14" viewBox="0 0 24 24" fill="none" stroke="#3d4f78" strokeWidth="2" strokeLinecap="round" strokeLinejoin="round">
-          <rect x="3" y="3" width="18" height="18" rx="2"/><circle cx="8.5" cy="8.5" r="1.5"/><polyline points="21 15 16 10 5 21"/>
-        </svg>
-      </div>
-    )
-  }
-
-  return (
-    // eslint-disable-next-line @next/next/no-img-element
-    <img
-      src={src}
-      alt=""
-      onError={() => setErr(true)}
-      className="w-9 h-9 rounded-lg object-cover shrink-0 border border-g-border/30 bg-g-raised"
-      loading="lazy"
-    />
-  )
-}
-
-export default function RecentListings() {
-  const [listings, setListings] = useState<Listing[]>([])
-  const [loading, setLoading] = useState(true)
-  const [lastRefresh, setLastRefresh] = useState<Date | null>(null)
-  const alive = useRef(true)
-
-  const refresh = useCallback(async () => {
-    try {
-      const data = await fetchListings(10)
-      if (alive.current) {
-        setListings(data)
-        setLastRefresh(new Date())
-        setLoading(false)
-      }
-    } catch {
-      if (alive.current) setLoading(false)
-    }
-  }, [])
-
-  useEffect(() => {
-    alive.current = true
-    refresh()
-    const id = setInterval(refresh, REFRESH_MS)
-    return () => {
-      alive.current = false
-      clearInterval(id)
-    }
-  }, [refresh])
-
-  return (
-    <motion.div
-      initial={{ opacity: 1, y: 12 }}
-      animate={{ opacity: 1, y: 0 }}
-      transition={{ delay: 0.1, duration: 0.5, ease: [0.22, 1, 0.36, 1] }}
-      className="g-card flex flex-col overflow-hidden"
-    >
-      {/* ── Header ── */}
-      <div className="flex items-center gap-3 px-5 py-3.5 border-b border-g-border/40 shrink-0">
-        <div className="flex items-center gap-2.5">
-          <span className="g-pulse-dot" />
-          <span className="text-sm font-bold text-g-text tracking-tight">Recent Captures</span>
-        </div>
-        <span className="text-[10px] text-g-faint tabular-nums font-mono">
-          {listings.length} lots
-        </span>
-        <div className="ml-auto flex items-center gap-2">
-          {lastRefresh && (
-            <span className="text-[10px] text-g-faint/50 font-mono hidden sm:block">
-              {lastRefresh.toLocaleTimeString([], { hour: '2-digit', minute: '2-digit', second: '2-digit' })}
-            </span>
-          )}
-          <button
-            onClick={refresh}
-            className="g-btn h-7 px-2.5 text-xs gap-1.5"
-            title="Refresh now"
-          >
-            <svg width="10" height="10" viewBox="0 0 24 24" fill="none" stroke="currentColor" strokeWidth="2.5" strokeLinecap="round" strokeLinejoin="round">
-              <polyline points="1 4 1 10 7 10"/><path d="M3.51 15a9 9 0 1 0 .49-3.51"/>
-            </svg>
-            Refresh
-          </button>
-        </div>
-      </div>
-
-      {/* ── Body ── */}
-      <div className="flex-1 overflow-y-auto min-h-0" style={{ maxHeight: 440 }}>
-        {loading ? (
-          <div className="space-y-0">
-            {Array.from({ length: 6 }).map((_, i) => (
-              <div key={i} className="flex items-center gap-3 px-5 py-3 border-b border-g-border/20 last:border-0">
-                <div className="w-9 h-9 rounded-lg bg-g-raised shrink-0 shimmer" />
-                <div className="flex-1 space-y-1.5">
-                  <div className="h-3 bg-g-raised rounded shimmer w-3/4" />
-                  <div className="h-2.5 bg-g-raised rounded shimmer w-1/3" />
-                </div>
-                <div className="h-3 w-12 bg-g-raised rounded shimmer" />
-              </div>
-            ))}
-          </div>
-        ) : listings.length === 0 ? (
-          <div className="flex flex-col items-center justify-center py-16 gap-4">
-            <div className="w-14 h-14 rounded-2xl bg-g-raised border border-g-border/40 flex items-center justify-center">
-              <svg width="22" height="22" viewBox="0 0 24 24" fill="none" stroke="#3d4f78" strokeWidth="1.5" strokeLinecap="round" strokeLinejoin="round">
-                <circle cx="11" cy="11" r="8"/><path d="m21 21-4.35-4.35"/>
-              </svg>
-            </div>
-            <div className="text-center">
-              <p className="text-sm text-g-muted font-medium">No lots captured yet</p>
-              <p className="text-xs text-g-faint mt-1">Start the engine to begin scanning</p>
-            </div>
-          </div>
-        ) : (
-          <AnimatePresence mode="popLayout" initial={false}>
-            {listings.map((lot, i) => (
-              <motion.a
-                key={lot.id}
-                href={lot.link}
-                target="_blank"
-                rel="noopener noreferrer"
-                initial={{ opacity: 1, x: -8 }}
-                animate={{ opacity: 1, x: 0 }}
-                exit={{ opacity: 0, x: 8, height: 0 }}
-                transition={{ delay: i * 0.03, duration: 0.3 }}
-                className="group flex items-center gap-3 px-5 py-3 border-b border-g-border/20 last:border-0 hover:bg-g-raised/50 transition-colors duration-150 cursor-pointer"
-              >
-                {/* Thumbnail */}
-                <Thumbnail src={lot.images?.[0]} />
-
-                {/* Title + meta */}
-                <div className="flex-1 min-w-0 space-y-0.5">
-                  <p
-                    className="text-[12px] font-medium text-g-text group-hover:text-g-green transition-colors leading-snug line-clamp-1"
-                    title={lot.title}
-                  >
-                    {lot.title}
-                  </p>
-                  <div className="flex items-center gap-2 flex-wrap">
-                    <span className="text-[10px] text-g-faint bg-g-raised px-1.5 py-0.5 rounded font-medium border border-g-border/30">
-                      {lot.site_name}
-                    </span>
-                    <span className="text-[10px] text-g-faint/60 font-mono">
-                      #{lot.keyword}
-                    </span>
-                    <AiBadge match={lot.ai_match} />
-                  </div>
-                </div>
-
-                {/* Price */}
-                <div className="text-right shrink-0 min-w-[64px]">
-                  <p className="text-[13px] font-bold text-g-text tabular-nums leading-none">
-                    {formatPrice(lot.price, lot.currency, lot.price_usd)}
-                  </p>
-                  {lot.price_usd && lot.currency !== 'USD' && (
-                    <p className="text-[10px] text-g-faint/50 tabular-nums mt-0.5">
-                      ${lot.price_usd.toFixed(0)} USD
-                    </p>
-                  )}
-                </div>
-
-                {/* Time left */}
-                <div className="shrink-0 w-[52px] text-right">
-                  <UrgencyBadge mins={lot.time_left_mins} />
-                </div>
-
-                {/* Score */}
-                <div className="shrink-0 w-[36px] text-right">
-                  <ScorePill score={lot.score} />
-                </div>
-
-                {/* Open arrow — visible on hover */}
-                <div className="shrink-0 w-4 flex items-center justify-end">
-                  <svg
-                    width="11" height="11"
-                    viewBox="0 0 24 24" fill="none" stroke="currentColor"
-                    strokeWidth="2.5" strokeLinecap="round" strokeLinejoin="round"
-                    className="text-g-faint/30 group-hover:text-g-green transition-colors"
-                  >
-                    <polyline points="9 18 15 12 9 6"/>
-                  </svg>
-                </div>
-              </motion.a>
-            ))}
-          </AnimatePresence>
-        )}
-      </div>
-
-      {/* ── Footer ── */}
-      {listings.length > 0 && (
-        <div className="px-5 py-2.5 border-t border-g-border/30 flex items-center justify-between shrink-0 bg-g-base/30">
-          <span className="text-[10px] text-g-faint/50">
-            Refreshes every {REFRESH_MS / 1000}s
-          </span>
-          <a
-            href="/listings"
-            className="text-[10px] text-g-muted hover:text-g-green transition-colors font-semibold flex items-center gap-1"
-          >
-            View all listings
-            <svg width="9" height="9" viewBox="0 0 24 24" fill="none" stroke="currentColor" strokeWidth="2.5" strokeLinecap="round" strokeLinejoin="round">
-              <polyline points="9 18 15 12 9 6"/>
-            </svg>
-          </a>
-        </div>
-      )}
-    </motion.div>
-  )
-}

frontend/components/dashboard/StatsGrid.tsx

@@ -1,146 +0,0 @@
-'use client'
-import { motion } from 'framer-motion'
-import { cn } from '@/lib/utils'
-
-interface Props {
-  scanned: number
-  alerts: number
-  keywords: number
-  uptime: string
-}
-
-const CARDS = [
-  {
-    id: 'scanned',
-    label: 'Lots Scanned',
-    sub: 'Processed this session',
-    gradFrom: '#00e87b',
-    gradTo: '#06b6d4',
-    icon: (
-      <svg width="14" height="14" viewBox="0 0 24 24" fill="none" stroke="currentColor" strokeWidth="2.5" strokeLinecap="round" strokeLinejoin="round">
-        <circle cx="11" cy="11" r="8"/><path d="m21 21-4.35-4.35"/>
-      </svg>
-    ),
-  },
-  {
-    id: 'alerts',
-    label: 'Alerts Fired',
-    sub: 'Qualifying matches',
-    gradFrom: '#fbbf24',
-    gradTo: '#f59e0b',
-    icon: (
-      <svg width="14" height="14" viewBox="0 0 24 24" fill="none" stroke="currentColor" strokeWidth="2.5" strokeLinecap="round" strokeLinejoin="round">
-        <path d="M18 8A6 6 0 0 0 6 8c0 7-3 9-3 9h18s-3-2-3-9"/><path d="M13.73 21a2 2 0 0 1-3.46 0"/>
-      </svg>
-    ),
-  },
-  {
-    id: 'keywords',
-    label: 'Active Targets',
-    sub: 'Keyword strategies',
-    gradFrom: '#a78bfa',
-    gradTo: '#3b82f6',
-    icon: (
-      <svg width="14" height="14" viewBox="0 0 24 24" fill="none" stroke="currentColor" strokeWidth="2.5" strokeLinecap="round" strokeLinejoin="round">
-        <path d="M20.59 13.41l-7.17 7.17a2 2 0 0 1-2.83 0L2 12V2h10l8.59 8.59a2 2 0 0 1 0 2.82z"/><line x1="7" y1="7" x2="7.01" y2="7"/>
-      </svg>
-    ),
-  },
-  {
-    id: 'uptime',
-    label: 'Engine Uptime',
-    sub: 'Continuous runtime',
-    gradFrom: '#3b82f6',
-    gradTo: '#06b6d4',
-    icon: (
-      <svg width="14" height="14" viewBox="0 0 24 24" fill="none" stroke="currentColor" strokeWidth="2.5" strokeLinecap="round" strokeLinejoin="round">
-        <circle cx="12" cy="12" r="10"/><polyline points="12 6 12 12 16 14"/>
-      </svg>
-    ),
-  },
-]
-
-export default function StatsGrid({ scanned, alerts, keywords, uptime }: Props) {
-  const values: Record<string, string | number> = {
-    scanned: String(scanned),
-    alerts: alerts,
-    keywords: keywords,
-    uptime: uptime,
-  }
-
-  return (
-    <div className="grid grid-cols-2 xl:grid-cols-4 gap-4">
-      {CARDS.map((card, i) => {
-        const val = values[card.id]
-        const isAlert = card.id === 'alerts' && alerts > 0
-        const accentColor = isAlert ? card.gradFrom : undefined
-
-        return (
-          <motion.div
-            key={card.id}
-      initial={{ opacity: 1, y: 18, scale: 0.97 }}
-      animate={{ opacity: 1, y: 0, scale: 1 }}
-            transition={{ duration: 0.55, delay: i * 0.07, ease: [0.22, 1, 0.36, 1] }}
-            className="g-card-glow p-5 flex flex-col gap-3.5 group cursor-default select-none"
-          >
-            {/* Top row: label + icon */}
-            <div className="relative z-10 flex items-start justify-between gap-2">
-              <span className="text-[10px] font-bold uppercase tracking-[0.14em] text-g-faint leading-none mt-0.5">
-                {card.label}
-              </span>
-              <div
-                className="shrink-0 w-7 h-7 rounded-lg flex items-center justify-center transition-all duration-300 group-hover:scale-110"
-                style={{
-                  background: `linear-gradient(135deg, ${card.gradFrom}18, ${card.gradTo}10)`,
-                  border: `1px solid ${card.gradFrom}25`,
-                  color: card.gradFrom,
-                  boxShadow: `0 0 12px ${card.gradFrom}15`,
-                }}
-              >
-                {card.icon}
-              </div>
-            </div>
-
-            {/* Value */}
-            <div className="relative z-10">
-              <span
-                className={cn(
-                  'g-stat-num transition-colors duration-300',
-                  isAlert ? 'text-g-amber' : 'text-g-text',
-                )}
-                style={accentColor ? {} : {}}
-              >
-                {val}
-              </span>
-            </div>
-
-            {/* Sub */}
-            <p className="relative z-10 text-[10px] text-g-faint/50 leading-none font-medium">
-              {card.sub}
-            </p>
-
-            {/* Bottom gradient line */}
-            <div
-              className="absolute bottom-0 left-0 right-0 h-px opacity-20 group-hover:opacity-40 transition-opacity"
-              style={{
-                background: `linear-gradient(90deg, transparent, ${card.gradFrom}80, ${card.gradTo}50, transparent)`,
-              }}
-            />
-
-            {/* Alert pulse ring for alerts card when active */}
-            {isAlert && (
-              <div
-                className="absolute top-4 right-4 w-1.5 h-1.5 rounded-full"
-                style={{
-                  background: card.gradFrom,
-                  boxShadow: `0 0 6px ${card.gradFrom}`,
-                  animation: 'pulse-ring 2s ease-out infinite',
-                }}
-              />
-            )}
-          </motion.div>
-        )
-      })}
-    </div>
-  )
-}

frontend/components/keywords/KeywordRow.tsx

@@ -1,114 +0,0 @@
-'use client'
-import { useState } from 'react'
-import { useSortable } from '@dnd-kit/sortable'
-import { CSS } from '@dnd-kit/utilities'
-import { useUpdateKeyword, useDeleteKeyword } from '@/hooks/useKeywords'
-import type { Keyword } from '@/lib/types'
-
-interface Props { keyword: Keyword }
-
-export default function KeywordRow({ keyword }: Props) {
-  const { attributes, listeners, setNodeRef, transform, transition } = useSortable({ id: keyword.id })
-  const updateKw = useUpdateKeyword()
-  const deleteKw = useDeleteKeyword()
-  const [editTerm,   setEditTerm]   = useState(false)
-  const [editWeight, setEditWeight] = useState(false)
-  const [termVal,    setTermVal]    = useState(keyword.term)
-  const [weightVal,  setWeightVal]  = useState(String(keyword.weight))
-
-  const saveTerm   = () => { updateKw.mutate({ id: keyword.id, data: { term: termVal } });         setEditTerm(false) }
-  const saveWeight = () => { updateKw.mutate({ id: keyword.id, data: { weight: parseFloat(weightVal) } }); setEditWeight(false) }
-
-  const style = { transform: CSS.Transform.toString(transform), transition }
-
-  return (
-    <tr ref={setNodeRef} style={style} className="group">
-      {/* Drag handle */}
-      <td className="w-8">
-        <span
-          {...attributes} {...listeners}
-          className="cursor-grab text-g-faint/30 hover:text-g-faint transition-colors select-none"
-          title="Drag to reorder"
-        >
-          ⋮⋮
-        </span>
-      </td>
-
-      {/* Term */}
-      <td>
-        {editTerm ? (
-          <input
-            autoFocus
-            value={termVal}
-            onChange={(e) => setTermVal(e.target.value)}
-            onBlur={saveTerm}
-            onKeyDown={(e) => e.key === 'Enter' && saveTerm()}
-            className="g-input h-7 text-sm py-0 w-full"
-          />
-        ) : (
-          <button
-            onClick={() => setEditTerm(true)}
-            className="text-sm font-medium text-g-text hover:text-g-green transition-colors text-left"
-          >
-            {keyword.term}
-          </button>
-        )}
-      </td>
-
-      {/* Weight */}
-      <td className="text-center">
-        {editWeight ? (
-          <input
-            autoFocus
-            type="number"
-            step="0.1"
-            value={weightVal}
-            onChange={(e) => setWeightVal(e.target.value)}
-            onBlur={saveWeight}
-            onKeyDown={(e) => e.key === 'Enter' && saveWeight()}
-            className="g-input h-7 text-sm py-0 w-16 text-center font-mono"
-          />
-        ) : (
-          <button
-            onClick={() => setEditWeight(true)}
-            className="font-mono text-sm text-g-amber hover:text-g-green transition-colors font-semibold"
-          >
-            {keyword.weight}×
-          </button>
-        )}
-      </td>
-
-      {/* AI description */}
-      <td>
-        {keyword.ai_target ? (
-          <span className="text-xs text-g-muted">
-            {keyword.ai_target.length > 48 ? keyword.ai_target.slice(0, 48) + '…' : keyword.ai_target}
-          </span>
-        ) : (
-          <span className="text-xs text-g-faint italic">Not set</span>
-        )}
-      </td>
-
-      {/* Price range */}
-      <td>
-        {(keyword.min_price || keyword.max_price) ? (
-          <span className="text-xs font-mono text-g-muted">
-            {[keyword.min_price ? `≥$${keyword.min_price}` : '', keyword.max_price ? `≤$${keyword.max_price}` : ''].filter(Boolean).join(' ')}
-          </span>
-        ) : (
-          <span className="text-xs text-g-faint">—</span>
-        )}
-      </td>
-
-      {/* Delete */}
-      <td className="w-10 text-right">
-        <button
-          onClick={() => { if (confirm(`Delete "${keyword.term}"?`)) deleteKw.mutate(keyword.id) }}
-          className="text-g-faint hover:text-g-red transition-colors text-xs opacity-0 group-hover:opacity-100"
-        >
-          ✕
-        </button>
-      </td>
-    </tr>
-  )
-}

frontend/components/keywords/KeywordsTable.tsx

@@ -1,135 +0,0 @@
-'use client'
-import { useState } from 'react'
-import { DndContext, closestCenter, type DragEndEvent } from '@dnd-kit/core'
-import { SortableContext, verticalListSortingStrategy } from '@dnd-kit/sortable'
-import KeywordRow from './KeywordRow'
-import { useKeywords, useAddKeyword, useReorderKeywords } from '@/hooks/useKeywords'
-
-export default function KeywordsTable() {
-  const { data: keywords, isLoading } = useKeywords()
-  const addKw   = useAddKeyword()
-  const reorder = useReorderKeywords()
-  const [newTerm,   setNewTerm]   = useState('')
-  const [newWeight, setNewWeight] = useState('1')
-  const [batchText, setBatchText] = useState('')
-  const [showBatch, setShowBatch] = useState(false)
-
-  const handleDragEnd = ({ active, over }: DragEndEvent) => {
-    if (!over || active.id === over.id || !keywords) return
-    const ids = keywords.map((k) => k.id)
-    const from = ids.indexOf(Number(active.id))
-    const to   = ids.indexOf(Number(over.id))
-    const newOrder = [...ids]
-    newOrder.splice(to, 0, newOrder.splice(from, 1)[0])
-    reorder.mutate(newOrder)
-  }
-
-  const handleBatchImport = () => {
-    const lines = batchText.split('\n').map((l) => l.trim()).filter(Boolean)
-    lines.forEach((line) => {
-      const [term, weight] = line.split(':')
-      addKw.mutate({ term: term.trim(), weight: parseFloat(weight || '1') })
-    })
-    setBatchText('')
-    setShowBatch(false)
-  }
-
-  if (isLoading) return (
-    <div className="g-card p-5 space-y-3">
-      {Array.from({ length: 4 }).map((_, i) => (
-        <div key={i} className="h-10 bg-g-raised rounded-lg animate-pulse" style={{ opacity: 1 - i * 0.2 }} />
-      ))}
-    </div>
-  )
-
-  return (
-    <div className="space-y-4">
-      {/* Add new */}
-      <div className="g-card p-4">
-        <p className="text-xs text-g-faint mb-3 leading-relaxed">
-          Each target is a search label sent to auction sites.
-          Set an <span className="text-g-green">AI Description</span> on each target to filter lot titles semantically.
-        </p>
-        <div className="flex gap-2 flex-wrap">
-          <input
-            value={newTerm}
-            onChange={(e) => setNewTerm(e.target.value)}
-            onKeyDown={(e) => e.key === 'Enter' && newTerm.trim() && (addKw.mutate({ term: newTerm, weight: parseFloat(newWeight) }), setNewTerm(''), setNewWeight('1'))}
-            placeholder="Search term…"
-            className="g-input h-9 flex-1 min-w-44 text-sm"
-          />
-          <input
-            value={newWeight}
-            onChange={(e) => setNewWeight(e.target.value)}
-            type="number" step="0.1"
-            placeholder="Weight"
-            className="g-input h-9 w-24 text-sm font-mono"
-          />
-          <button
-            onClick={() => {
-              if (newTerm.trim()) {
-                addKw.mutate({ term: newTerm, weight: parseFloat(newWeight) })
-                setNewTerm('')
-                setNewWeight('1')
-              }
-            }}
-            className="g-btn-primary h-9 text-sm px-4"
-          >
-            + Add
-          </button>
-          <button
-            onClick={() => setShowBatch(!showBatch)}
-            className="g-btn h-9 text-sm"
-          >
-            Batch
-          </button>
-        </div>
-
-        {showBatch && (
-          <div className="mt-3 space-y-2 pt-3 border-t border-g-border/40">
-            <p className="text-xs text-g-faint">One target per line. Format: <code className="text-g-muted">laptop:2</code></p>
-            <textarea
-              value={batchText}
-              onChange={(e) => setBatchText(e.target.value)}
-              placeholder={"laptop:2\nRTX 4090:3\niPhone 15"}
-              rows={4}
-              className="g-input text-sm font-mono resize-none"
-            />
-            <button onClick={handleBatchImport} className="g-btn-primary text-sm">Import all</button>
-          </div>
-        )}
-      </div>
-
-      {/* Table */}
-      <div className="g-card overflow-hidden">
-        <DndContext collisionDetection={closestCenter} onDragEnd={handleDragEnd}>
-          <SortableContext items={(keywords ?? []).map((k) => k.id)} strategy={verticalListSortingStrategy}>
-            <div className="overflow-x-auto">
-              <table className="g-table">
-                <thead>
-                  <tr>
-                    <th className="w-8"></th>
-                    <th>Target label</th>
-                    <th className="text-center">Weight</th>
-                    <th>AI description</th>
-                    <th>Price filter</th>
-                    <th className="w-10"></th>
-                  </tr>
-                </thead>
-                <tbody>
-                  {(keywords ?? []).map((kw) => <KeywordRow key={kw.id} keyword={kw} />)}
-                </tbody>
-              </table>
-              {!(keywords ?? []).length && (
-                <div className="flex flex-col items-center justify-center py-12 text-g-faint gap-2">
-                  <span className="text-3xl opacity-20">⌖</span>
-                  <p className="text-sm">No targets yet — add one above</p>
-                </div>
-              )}
-            </div>
-          </SortableContext>
-        </DndContext>
-      </div>
-    </div>
-  )
-}

frontend/components/keywords/ScoringRulesPanel.tsx

@@ -1,205 +0,0 @@
-'use client'
-import { useState, useEffect } from 'react'
-import { useQuery, useMutation, useQueryClient } from '@tanstack/react-query'
-import type { ScoringRule } from '@/lib/types'
-import { fetchScoringRules, createScoringRule, updateScoringRule, deleteScoringRule } from '@/lib/api/scoring-rules'
-import { fetchConfig, saveConfig } from '@/lib/api/config'
-import { cn } from '@/lib/utils'
-
-export default function ScoringRulesPanel() {
-  const qc = useQueryClient()
-  const { data: rules = [], isLoading } = useQuery<ScoringRule[]>({
-    queryKey: ['scoring-rules'],
-    queryFn: fetchScoringRules,
-  })
-
-  const [scoringEnabled, setScoringEnabled] = useState(true)
-  const [toggleLoading, setToggleLoading]   = useState(false)
-
-  useEffect(() => {
-    fetchConfig().then(cfg => {
-      setScoringEnabled((cfg['scoring_enabled'] ?? 'true') !== 'false')
-    })
-  }, [])
-
-  const handleScoringToggle = async () => {
-    setToggleLoading(true)
-    const newVal = !scoringEnabled
-    await saveConfig({ scoring_enabled: String(newVal) })
-    setScoringEnabled(newVal)
-    setToggleLoading(false)
-  }
-
-  const [newSignal, setNewSignal] = useState('')
-  const [newDelta,  setNewDelta]  = useState('')
-  const [newNotes,  setNewNotes]  = useState('')
-  const [error,     setError]     = useState('')
-  const [editId,       setEditId]       = useState<number | null>(null)
-  const [editSignal,   setEditSignal]   = useState('')
-  const [editDelta,    setEditDelta]    = useState('')
-
-  const invalidate = () => qc.invalidateQueries({ queryKey: ['scoring-rules'] })
-
-  const createMut = useMutation({
-    mutationFn: () => createScoringRule(newSignal.trim(), parseInt(newDelta), newNotes.trim() || undefined),
-    onSuccess: () => { setNewSignal(''); setNewDelta(''); setNewNotes(''); setError(''); invalidate() },
-    onError: (e: Error) => setError(e.message),
-  })
-  const updateMut = useMutation({
-    mutationFn: () => updateScoringRule(editId!, { signal: editSignal.trim(), delta: parseInt(editDelta) }),
-    onSuccess: () => { setEditId(null); invalidate() },
-  })
-  const deleteMut = useMutation({
-    mutationFn: (id: number) => deleteScoringRule(id),
-    onSuccess: invalidate,
-  })
-
-  const positives = rules.filter(r => r.delta > 0)
-  const negatives = rules.filter(r => r.delta < 0)
-
-  return (
-    <div className="space-y-4">
-      {/* Header */}
-      <div className="flex items-start justify-between gap-4">
-        <div>
-          <h2 className="text-sm font-semibold text-g-text">Scoring Rules</h2>
-          <p className="text-xs text-g-faint mt-0.5">Token signals that boost (+) or penalise (−) lot scores</p>
-        </div>
-        <div className="flex items-center gap-2 shrink-0">
-          <span className="text-xs text-g-faint">Scoring</span>
-          <button
-            onClick={handleScoringToggle}
-            disabled={toggleLoading}
-            className={cn(
-              'g-btn text-xs h-7',
-              scoringEnabled && '!border-g-green/40 !text-g-green !bg-g-green/8'
-            )}
-          >
-            {scoringEnabled ? 'On' : 'Off'}
-          </button>
-        </div>
-      </div>
-
-      {/* AI-first banner */}
-      {!scoringEnabled && (
-        <div className="g-card border-g-green/20 bg-g-green/4 px-4 py-3 text-xs text-g-green space-y-1">
-          <div className="font-semibold">AI-first mode active</div>
-          <div className="text-g-muted leading-relaxed">
-            Score signals are disabled. The AI description on each target is the sole judge.
-            Set an AI Description on every target and enable AI Filter in Settings.
-          </div>
-        </div>
-      )}
-
-      <div className={cn(scoringEnabled ? '' : 'opacity-40 pointer-events-none select-none', 'space-y-4')}>
-        {/* Add new */}
-        <form
-          className="g-card p-4 flex gap-2 flex-wrap items-end"
-          onSubmit={e => { e.preventDefault(); if (newSignal && newDelta) createMut.mutate() }}
-        >
-          <div className="space-y-1">
-            <label className="text-[10px] uppercase tracking-widest text-g-faint">Signal</label>
-            <input className="g-input h-8 w-32 text-sm" placeholder="RTX" value={newSignal} onChange={e => setNewSignal(e.target.value)} />
-          </div>
-          <div className="space-y-1">
-            <label className="text-[10px] uppercase tracking-widest text-g-faint">Delta</label>
-            <input type="number" className="g-input h-8 w-20 text-sm font-mono" placeholder="+10" value={newDelta} onChange={e => setNewDelta(e.target.value)} />
-          </div>
-          <div className="space-y-1 flex-1 min-w-36">
-            <label className="text-[10px] uppercase tracking-widest text-g-faint">Notes</label>
-            <input className="g-input h-8 text-sm" placeholder="GPU keyword" value={newNotes} onChange={e => setNewNotes(e.target.value)} />
-          </div>
-          <button
-            type="submit"
-            disabled={!newSignal || !newDelta || createMut.isPending}
-            className="g-btn-primary h-8 text-xs disabled:opacity-40"
-          >
-            + Add rule
-          </button>
-          {error && <span className="text-xs text-g-red w-full">{error}</span>}
-        </form>
-
-        {isLoading && <p className="text-xs text-g-faint">Loading…</p>}
-
-        {/* Rules tables */}
-        {positives.length > 0 && (
-          <div className="g-card overflow-hidden">
-            <div className="px-4 py-2.5 border-b border-g-border/50 flex items-center gap-2">
-              <span className="w-1.5 h-1.5 rounded-full bg-g-green" />
-              <span className="text-xs font-medium text-g-green uppercase tracking-wider">Boosts</span>
-            </div>
-            <table className="g-table">
-              <thead><tr><th>Signal</th><th>Delta</th><th>Notes</th><th className="w-10"></th></tr></thead>
-              <tbody>
-                {positives.map(r => (
-                  <RuleRow key={r.id} rule={r} editId={editId} editSignal={editSignal} editDelta={editDelta}
-                    setEditId={setEditId} setEditSignal={setEditSignal} setEditDelta={setEditDelta}
-                    onSave={() => updateMut.mutate()} onDelete={() => deleteMut.mutate(r.id)} />
-                ))}
-              </tbody>
-            </table>
-          </div>
-        )}
-
-        {negatives.length > 0 && (
-          <div className="g-card overflow-hidden">
-            <div className="px-4 py-2.5 border-b border-g-border/50 flex items-center gap-2">
-              <span className="w-1.5 h-1.5 rounded-full bg-g-red" />
-              <span className="text-xs font-medium text-g-red uppercase tracking-wider">Penalties</span>
-            </div>
-            <table className="g-table">
-              <thead><tr><th>Signal</th><th>Delta</th><th>Notes</th><th className="w-10"></th></tr></thead>
-              <tbody>
-                {negatives.map(r => (
-                  <RuleRow key={r.id} rule={r} editId={editId} editSignal={editSignal} editDelta={editDelta}
-                    setEditId={setEditId} setEditSignal={setEditSignal} setEditDelta={setEditDelta}
-                    onSave={() => updateMut.mutate()} onDelete={() => deleteMut.mutate(r.id)} />
-                ))}
-              </tbody>
-            </table>
-          </div>
-        )}
-      </div>
-    </div>
-  )
-}
-
-function RuleRow({ rule, editId, editSignal, editDelta, setEditId, setEditSignal, setEditDelta, onSave, onDelete }: {
-  rule: ScoringRule; editId: number | null
-  editSignal: string; editDelta: string
-  setEditId: (id: number | null) => void; setEditSignal: (s: string) => void; setEditDelta: (s: string) => void
-  onSave: () => void; onDelete: () => void
-}) {
-  const isEditing = editId === rule.id
-  if (isEditing) return (
-    <tr>
-      <td><input className="g-input h-7 text-sm w-28" value={editSignal} onChange={e => setEditSignal(e.target.value)} /></td>
-      <td><input type="number" className="g-input h-7 text-sm font-mono w-16" value={editDelta} onChange={e => setEditDelta(e.target.value)} /></td>
-      <td className="text-xs text-g-faint">{rule.notes || '—'}</td>
-      <td className="flex gap-2 items-center">
-        <button onClick={onSave} className="g-btn text-xs h-7">Save</button>
-        <button onClick={() => setEditId(null)} className="text-g-faint hover:text-g-text text-xs">×</button>
-      </td>
-    </tr>
-  )
-  return (
-    <tr className="group">
-      <td>
-        <button className="text-sm text-g-text hover:text-g-green transition-colors font-medium"
-          onClick={() => { setEditId(rule.id); setEditSignal(rule.signal); setEditDelta(String(rule.delta)) }}>
-          {rule.signal}
-        </button>
-      </td>
-      <td>
-        <span className={cn('font-mono text-sm font-bold', rule.delta > 0 ? 'text-g-green' : 'text-g-red')}>
-          {rule.delta > 0 ? '+' : ''}{rule.delta}
-        </span>
-      </td>
-      <td className="text-xs text-g-faint">{rule.notes || '—'}</td>
-      <td>
-        <button onClick={onDelete}
-          className="text-g-faint hover:text-g-red transition-colors text-xs opacity-0 group-hover:opacity-100">✕</button>
-      </td>
-    </tr>
-  )
-}

frontend/components/landing/LandingPage.tsx

@@ -1,666 +0,0 @@
-'use client'
-import { useState, useRef } from 'react'
-import Link from 'next/link'
-import { motion, AnimatePresence, useInView } from 'framer-motion'
-import {
-  Globe, Brain, Shield, Zap, BarChart3, Lock,
-  ArrowRight, ChevronDown, ChevronUp,
-  Target, Users, Gem, CheckCircle2,
-  Terminal, Play, Cpu,
-} from 'lucide-react'
-
-/* ─── FEATURES ──────────────────────────────────────────────────── */
-const FEATURES = [
-  {
-    icon: Globe,
-    title: 'Multi-Site Coverage',
-    desc: 'Watches eBay, HiBid, ShopGoodwill, and 12+ more simultaneously. Add any new site in seconds with AI-generated selectors.',
-    accent: '#06b6d4',
-  },
-  {
-    icon: Brain,
-    title: 'AI-First Filtering',
-    desc: 'Write in plain English what a perfect lot looks like. The AI reads every title and decides match or reject — with a clear reason.',
-    accent: '#a78bfa',
-  },
-  {
-    icon: Shield,
-    title: 'Stealth Engine',
-    desc: '30+ fingerprint patches, Bezier mouse curves, human typing rhythms. Auction sites see a person, not a bot.',
-    accent: '#00e87b',
-  },
-  {
-    icon: Zap,
-    title: 'Instant Alerts',
-    desc: 'Telegram, Discord, and Gmail in real time. Multi-interval closing alerts at 60, 30, 10, 5 minutes before the hammer falls.',
-    accent: '#fbbf24',
-  },
-  {
-    icon: BarChart3,
-    title: 'Smart Scoring',
-    desc: 'Database-backed heuristic rules boost or penalise every lot. Fully editable. Or disable entirely for pure AI mode.',
-    accent: '#3b82f6',
-  },
-  {
-    icon: Lock,
-    title: 'Privacy-First',
-    desc: 'Runs entirely on your machine. SQLite or PostgreSQL. Your hunting intelligence stays yours — no cloud fees, no data leaks.',
-    accent: '#f43f5e',
-  },
-]
-
-/* ─── STEPS ─────────────────────────────────────────────────────── */
-const STEPS = [
-  { n: '01', title: 'Add Targets', desc: 'Define keywords and tell the AI what a good lot looks like in plain English.', color: '#00e87b' },
-  { n: '02', title: 'Engine Runs', desc: 'Stealth browsers scan every site on a schedule. You do nothing.', color: '#06b6d4' },
-  { n: '03', title: 'AI Filters', desc: 'Every lot is read and scored. Junk is rejected. Only good matches continue.', color: '#a78bfa' },
-  { n: '04', title: 'You Win', desc: 'Instant alerts fire. You bid on the original site. You capture deals others miss.', color: '#fbbf24' },
-]
-
-/* ─── AUDIENCE ──────────────────────────────────────────────────── */
-const AUDIENCE = [
-  { icon: Target, title: 'Power Buyers & Flippers', desc: 'See every under-priced lot before competitors do. Never miss a liquidation deal again.', accent: '#00e87b' },
-  { icon: Gem, title: 'Collectors & Deal Hunters', desc: 'AI precision — only lots that match your exact criteria. Zero noise, zero manual browsing.', accent: '#a78bfa' },
-  { icon: Users, title: 'Teams & Agencies', desc: 'Monitor multiple platforms and regions without dedicating staff hours to manual searching.', accent: '#06b6d4' },
-]
-
-/* ─── FAQ ───────────────────────────────────────────────────────── */
-const FAQ = [
-  { q: 'Does Ghost Node place bids for me?', a: 'No. Ghost Node is a pure intelligence layer — it monitors, filters, scores, and alerts you. You place bids yourself on the original site. This keeps you in full control.' },
-  { q: 'Which auction sites are supported?', a: 'eBay UK, eBay US, HiBid, and ShopGoodwill work out of the box. 12 more sites (Invaluable, BidSpotter, Catawiki, LiveAuctioneers, and more) are ready to configure. Any new site can be added with AI-generated selectors.' },
-  { q: 'How does the AI filter work?', a: 'Per keyword, you write a natural-language description — e.g. "actual Samsung tablet device, not cases or accessories". The AI reads every lot title and returns match/reject plus a human-readable reason you can review.' },
-  { q: 'Is this allowed by auction sites?', a: "Ghost Node behaves exactly like a human browser: slow scrolling, randomised mouse movement, realistic typing. You are solely responsible for each platform's terms of service." },
-  { q: 'Will it run 24/7?', a: 'Yes — Ghost Node runs as a background Python process with a configurable scrape window or continuously. Failed sites auto-enter cooldown and retry. The engine is self-healing.' },
-]
-
-/* ─── FAKE LOTS ─────────────────────────────────────────────────── */
-const LOTS = [
-  { time: '02:14', title: 'Samsung Galaxy Tab S10 FE 256GB', site: 'eBay UK', price: '£89', ok: true, score: '+74' },
-  { time: '02:11', title: 'Apple iPad Pro 12.9" M2 128GB', site: 'HiBid', price: '$210', ok: true, score: '+88' },
-  { time: '02:08', title: 'iPad protective case lot ×12', site: 'ShopGoodwill', price: '$14', ok: false, score: '−22' },
-  { time: '02:05', title: 'Microsoft Surface Pro 9 i5 16GB', site: 'eBay US', price: '$380', ok: true, score: '+61' },
-  { time: '02:01', title: 'Lenovo ThinkPad X1 Carbon Gen 11', site: 'HiBid', price: '$445', ok: true, score: '+55' },
-]
-
-/* ─── SMALL COMPONENTS ──────────────────────────────────────────── */
-
-function GradientText({ children, from = '#00e87b', via = '#06b6d4', to = '#a78bfa' }: {
-  children: React.ReactNode; from?: string; via?: string; to?: string
-}) {
-  return (
-    <span style={{
-      background: `linear-gradient(135deg, ${from} 0%, ${via} 50%, ${to} 100%)`,
-      WebkitBackgroundClip: 'text',
-      WebkitTextFillColor: 'transparent',
-      backgroundClip: 'text',
-      backgroundSize: '200%',
-      animation: 'gradient-flow 5s ease infinite',
-      display: 'inline',
-    }}>
-      {children}
-    </span>
-  )
-}
-
-function GlowOrbs() {
-  return (
-    <div className="absolute inset-0 overflow-hidden pointer-events-none" aria-hidden="true">
-      <div className="absolute top-[-10%] left-[10%] w-[700px] h-[700px] rounded-full opacity-[0.12]"
-        style={{ background: 'radial-gradient(circle, #00e87b 0%, transparent 65%)', filter: 'blur(80px)', animation: 'float-orb 24s ease-in-out infinite' }} />
-      <div className="absolute top-[30%] right-[-10%] w-[600px] h-[600px] rounded-full opacity-[0.10]"
-        style={{ background: 'radial-gradient(circle, #a78bfa 0%, transparent 65%)', filter: 'blur(80px)', animation: 'float-orb 30s ease-in-out infinite reverse' }} />
-      <div className="absolute bottom-[-10%] left-[40%] w-[500px] h-[500px] rounded-full opacity-[0.08]"
-        style={{ background: 'radial-gradient(circle, #06b6d4 0%, transparent 65%)', filter: 'blur(70px)', animation: 'float-orb 20s ease-in-out infinite 4s' }} />
-    </div>
-  )
-}
-
-function LiveTerminal() {
-  return (
-    <div
-      className="relative rounded-3xl overflow-hidden"
-      style={{
-        background: 'linear-gradient(145deg, rgba(10,15,30,0.97), rgba(5,5,16,0.99))',
-        border: '1px solid rgba(0,232,123,0.15)',
-        boxShadow: '0 0 80px rgba(0,232,123,0.07), 0 60px 120px rgba(0,0,0,0.6)',
-        transform: 'perspective(1000px) rotateY(-3deg) rotateX(2deg)',
-      }}
-    >
-      {/* Top glow line */}
-      <div className="absolute top-0 inset-x-0 h-px bg-gradient-to-r from-transparent via-g-green/50 to-transparent" />
-
-      {/* Window chrome */}
-      <div className="flex items-center justify-between px-5 py-3.5 border-b border-g-border/20 bg-g-raised/10">
-        <div className="flex items-center gap-2">
-          <span className="w-3 h-3 rounded-full bg-[#ff5f56]" />
-          <span className="w-3 h-3 rounded-full bg-[#ffbd2e]" />
-          <span className="w-3 h-3 rounded-full bg-[#27c93f]" />
-          <span className="ml-3 text-[11px] text-g-faint/60 font-mono">ghost-node · engine · live</span>
-        </div>
-        <div className="flex items-center gap-1.5">
-          <span className="w-2 h-2 rounded-full bg-g-green"
-            style={{ boxShadow: '0 0 8px #00e87b', animation: 'pulse-ring 2s ease-out infinite' }} />
-          <span className="text-[10px] text-g-green font-black tracking-widest font-mono">SCANNING</span>
-        </div>
-      </div>
-
-      {/* Status bar */}
-      <div className="flex items-center gap-4 px-5 py-2 bg-g-green/3 border-b border-g-border/10">
-        <div className="flex items-center gap-1.5 text-[10px] text-g-green font-mono">
-          <Cpu size={10} />
-          <span>Engine Active</span>
-        </div>
-        <div className="text-[10px] text-g-faint/50 font-mono">3 keywords · 4 sites · cycle 2min</div>
-      </div>
-
-      {/* Table header */}
-      <div className="grid grid-cols-[54px_1fr_80px_58px_40px] gap-2 px-5 py-2 bg-g-raised/15">
-        {['TIME', 'LOT TITLE', 'SITE', 'PRICE', 'AI'].map(h => (
-          <span key={h} className="text-[9px] font-black uppercase tracking-[0.15em] text-g-faint/40">{h}</span>
-        ))}
-      </div>
-
-      {/* Rows */}
-      {LOTS.map((lot, i) => (
-        <motion.div
-          key={i}
-          initial={{ opacity: 1, x: -8 }}
-          animate={{ opacity: 1, x: 0 }}
-          transition={{ delay: 0.5 + i * 0.14 }}
-          className={`grid grid-cols-[54px_1fr_80px_58px_40px] gap-2 px-5 py-3 border-b border-g-border/8 last:border-0 group transition-all duration-200 ${i === 0 ? 'bg-g-green/4' : 'hover:bg-g-raised/20'}`}
-        >
-          <span className="text-[10px] text-g-faint/40 font-mono tabular-nums">{lot.time}</span>
-          <span className={`text-[11px] font-semibold truncate transition-colors ${i === 0 ? 'text-g-green' : 'text-g-text group-hover:text-g-green'}`}>
-            {lot.title}
-          </span>
-          <span className="text-[10px] text-g-muted/80 truncate">{lot.site}</span>
-          <span className="text-[12px] font-black text-g-text font-mono tabular-nums">{lot.price}</span>
-          <span className={`text-[12px] font-black ${lot.ok ? 'text-g-green' : 'text-g-red'}`}>
-            {lot.ok ? '✓' : '✗'}
-          </span>
-        </motion.div>
-      ))}
-
-      {/* Prompt */}
-      <div className="flex items-center gap-2 px-5 py-3.5">
-        <Terminal size={12} className="text-g-green" />
-        <span className="text-[10px] text-g-green font-mono">ghost@node ~ $</span>
-        <span className="w-2 h-4 bg-g-green rounded-[1px]"
-          style={{ animation: 'glow-pulse 1s ease-in-out infinite' }} />
-      </div>
-    </div>
-  )
-}
-
-function FaqItem({ q, a }: { q: string; a: string }) {
-  const [open, setOpen] = useState(false)
-  return (
-    <motion.div
-      whileHover={{ y: -1 }}
-      transition={{ duration: 0.15 }}
-      className="g-card cursor-pointer overflow-hidden"
-      onClick={() => setOpen(o => !o)}
-    >
-      <div className="flex items-start justify-between gap-4 px-6 py-5">
-        <p className="text-[14px] font-semibold text-g-text leading-snug">{q}</p>
-        <motion.span
-          animate={{ rotate: open ? 180 : 0 }}
-          transition={{ duration: 0.2 }}
-          className="shrink-0 mt-0.5 text-g-faint"
-        >
-          {open ? <ChevronUp size={16} /> : <ChevronDown size={16} />}
-        </motion.span>
-      </div>
-      <AnimatePresence initial={false}>
-        {open && (
-          <motion.div
-            initial={{ height: 0 }}
-            animate={{ height: 'auto' }}
-            exit={{ height: 0 }}
-            transition={{ duration: 0.22, ease: 'easeInOut' }}
-            className="overflow-hidden"
-          >
-            <p className="px-6 pb-5 text-[13px] text-g-muted leading-relaxed border-t border-g-border/20 pt-4">
-              {a}
-            </p>
-          </motion.div>
-        )}
-      </AnimatePresence>
-    </motion.div>
-  )
-}
-
-/* ─── MAIN PAGE ─────────────────────────────────────────────────── */
-
-export default function LandingPage() {
-  const featRef = useRef(null)
-  const stepsRef = useRef(null)
-  const audRef = useRef(null)
-  const featIn = useInView(featRef, { once: true, margin: '-60px' })
-  const stepsIn = useInView(stepsRef, { once: true, margin: '-60px' })
-  const audIn = useInView(audRef, { once: true, margin: '-60px' })
-
-  return (
-    <div className="-mt-8 -mx-6 overflow-x-hidden">
-
-      {/* ══ HERO ════════════════════════════════════════════════════ */}
-      <section className="relative min-h-screen flex items-center px-6 xl:px-20">
-        <GlowOrbs />
-
-        {/* Dot grid */}
-        <div className="absolute inset-0 opacity-[0.025]"
-          style={{ backgroundImage: 'radial-gradient(circle, #8896b8 1px, transparent 1px)', backgroundSize: '28px 28px' }} />
-
-        <div className="relative z-10 w-full max-w-[1400px] mx-auto py-24">
-          <div className="grid grid-cols-1 lg:grid-cols-[1fr_500px] gap-16 xl:gap-24 items-center">
-
-            {/* LEFT: copy */}
-            <div className="space-y-8 max-w-2xl">
-
-              {/* Badge */}
-              <motion.div
-                initial={{ opacity: 1, y: 16 }}
-                animate={{ opacity: 1, y: 0 }}
-                transition={{ duration: 0.5 }}
-                className="inline-flex items-center gap-2.5 px-4 py-2 rounded-full bg-g-green/6 border border-g-green/20 w-fit"
-              >
-                <span className="w-2 h-2 rounded-full bg-g-green shrink-0"
-                  style={{ boxShadow: '0 0 8px #00e87b', animation: 'pulse-ring 2s ease-out infinite' }} />
-                <span className="text-[11px] font-black text-g-green tracking-[0.12em] uppercase">
-                  Ghost Node v2.7 · System Active
-                </span>
-              </motion.div>
-
-              {/* H1 */}
-              <motion.div
-                initial={{ opacity: 1, y: 24 }}
-                animate={{ opacity: 1, y: 0 }}
-                transition={{ delay: 0.06, duration: 0.6, ease: [0.22, 1, 0.36, 1] }}
-              >
-                <h1 className="text-[54px] md:text-[68px] xl:text-[82px] font-black tracking-[-0.05em] leading-[0.9]">
-                  <span className="text-g-text block">The Auction</span>
-                  <span className="text-g-text block">Sniper That</span>
-                  <GradientText>Never Sleeps.</GradientText>
-                </h1>
-              </motion.div>
-
-              {/* Subtitle */}
-              <motion.p
-                initial={{ opacity: 1, y: 16 }}
-                animate={{ opacity: 1, y: 0 }}
-                transition={{ delay: 0.14, duration: 0.5 }}
-                className="text-[18px] text-g-muted leading-relaxed max-w-[500px] font-light"
-              >
-                Ghost Node monitors dozens of auction sites in real time, scores every lot with AI,
-                and alerts you the moment a real deal appears — before anyone else sees it.
-              </motion.p>
-
-              {/* CTAs */}
-              <motion.div
-                initial={{ opacity: 1, y: 12 }}
-                animate={{ opacity: 1, y: 0 }}
-                transition={{ delay: 0.22, duration: 0.4 }}
-                className="flex flex-wrap items-center gap-4"
-              >
-                <Link href="/dashboard">
-                  <motion.button
-                    whileHover={{ scale: 1.04, y: -2 }}
-                    whileTap={{ scale: 0.96 }}
-                    className="inline-flex items-center gap-2.5 h-13 px-8 rounded-2xl font-bold text-[15px] text-black cursor-pointer"
-                    style={{
-                      height: 52,
-                      background: 'linear-gradient(135deg, #00e87b, #06b6d4)',
-                      boxShadow: '0 0 40px rgba(0,232,123,0.35), 0 8px 32px rgba(0,0,0,0.4)',
-                    }}
-                  >
-                    <Play size={15} />
-                    Enter Dashboard
-                  </motion.button>
-                </Link>
-                <a href="#how-it-works">
-                  <motion.button
-                    whileHover={{ scale: 1.04, y: -1 }}
-                    whileTap={{ scale: 0.96 }}
-                    className="g-btn inline-flex items-center gap-2"
-                    style={{ height: 52, paddingLeft: '1.75rem', paddingRight: '1.75rem', fontSize: 15 }}
-                  >
-                    How It Works
-                    <ArrowRight size={14} />
-                  </motion.button>
-                </a>
-              </motion.div>
-
-              {/* Stats */}
-              <motion.div
-                initial={{ opacity: 1 }}
-                animate={{ opacity: 1 }}
-                transition={{ delay: 0.3 }}
-                className="flex flex-wrap gap-x-8 gap-y-3 pt-2"
-              >
-                {[
-                  { v: '12+', l: 'Auction sites' },
-                  { v: '42', l: 'API endpoints' },
-                  { v: '30+', l: 'Stealth patches' },
-                  { v: '∞', l: 'Lots monitored' },
-                ].map(s => (
-                  <div key={s.l} className="flex flex-col">
-                    <span className="text-[22px] font-black text-g-text leading-none tabular-nums">{s.v}</span>
-                    <span className="text-[11px] text-g-faint mt-1 font-medium">{s.l}</span>
-                  </div>
-                ))}
-              </motion.div>
-            </div>
-
-            {/* RIGHT: terminal */}
-            <motion.div
-              initial={{ opacity: 1, x: 24, scale: 0.97 }}
-              animate={{ opacity: 1, x: 0, scale: 1 }}
-              transition={{ delay: 0.2, duration: 0.7, ease: [0.22, 1, 0.36, 1] }}
-              className="hidden lg:block"
-            >
-              <LiveTerminal />
-            </motion.div>
-          </div>
-        </div>
-      </section>
-
-      {/* ══ PLATFORM STRIP ══════════════════════════════════════════ */}
-      <div className="relative border-y border-g-border/25 bg-g-surface/15 py-5 overflow-hidden">
-        <div className="flex flex-wrap items-center justify-center gap-8 px-8">
-          {['eBay UK', 'eBay US', 'HiBid', 'ShopGoodwill', 'Invaluable', 'BidSpotter', 'Catawiki', 'LiveAuctioneers', 'Proxibid', '+ more'].map(s => (
-            <span key={s} className="text-[11px] font-bold text-g-faint/40 tracking-[0.2em] uppercase">{s}</span>
-          ))}
-        </div>
-      </div>
-
-      {/* ══ FEATURES ════════════════════════════════════════════════ */}
-      <section ref={featRef} className="px-6 xl:px-20 py-32">
-        <div className="max-w-[1400px] mx-auto space-y-16">
-
-          <div className="text-center space-y-4 max-w-3xl mx-auto">
-            <motion.p
-              initial={{ opacity: 1 }}
-              animate={featIn ? { opacity: 1 } : { opacity: 1 }}
-              className="text-[11px] font-black uppercase tracking-[0.2em] text-g-green"
-            >
-              Capabilities
-            </motion.p>
-            <motion.h2
-              initial={{ opacity: 1, y: 20 }}
-              animate={featIn ? { opacity: 1, y: 0 } : { opacity: 1, y: 20 }}
-              transition={{ duration: 0.5 }}
-              className="text-[42px] md:text-[52px] font-black tracking-[-0.04em] text-g-text leading-tight"
-            >
-              The{' '}
-              <GradientText from="#00e87b" via="#06b6d4" to="#a78bfa">Intelligence Layer</GradientText>
-            </motion.h2>
-            <motion.p
-              initial={{ opacity: 1, y: 10 }}
-              animate={featIn ? { opacity: 1, y: 0 } : { opacity: 1, y: 10 }}
-              transition={{ delay: 0.08, duration: 0.4 }}
-              className="text-[16px] text-g-muted leading-relaxed"
-            >
-              Built for serious buyers who can't monitor every auction site manually — and won't settle for noise.
-            </motion.p>
-          </div>
-
-          <div className="grid grid-cols-1 md:grid-cols-2 xl:grid-cols-3 gap-5">
-            {FEATURES.map((f, i) => (
-              <motion.div
-                key={f.title}
-                initial={{ opacity: 0, y: 32 }}
-                animate={featIn ? { opacity: 1, y: 0 } : {}}
-                transition={{ delay: 0.06 + i * 0.09, duration: 0.55, ease: [0.22, 1, 0.36, 1] }}
-                whileHover={{ y: -4, scale: 1.01 }}
-                className="relative p-7 rounded-3xl overflow-hidden cursor-default group"
-                style={{
-                  background: `linear-gradient(145deg, rgba(15,22,41,0.85), rgba(10,15,30,0.92))`,
-                  border: `1px solid rgba(255,255,255,0.05)`,
-                  boxShadow: '0 8px 40px rgba(0,0,0,0.3)',
-                  transition: 'all 0.3s ease',
-                }}
-              >
-                {/* Hover glow */}
-                <div className="absolute inset-0 opacity-0 group-hover:opacity-100 transition-opacity duration-300 pointer-events-none rounded-3xl"
-                  style={{ background: `radial-gradient(ellipse at 30% 30%, ${f.accent}08, transparent 70%)` }} />
-
-                {/* Icon */}
-                <div className="relative z-10 w-14 h-14 rounded-2xl mb-6 flex items-center justify-center transition-transform duration-300 group-hover:scale-110"
-                  style={{
-                    background: `linear-gradient(135deg, ${f.accent}20, ${f.accent}08)`,
-                    border: `1px solid ${f.accent}25`,
-                    boxShadow: `0 0 24px ${f.accent}12`,
-                  }}>
-                  <f.icon size={22} color={f.accent} strokeWidth={1.75} />
-                </div>
-
-                <div className="relative z-10 space-y-2">
-                  <h3 className="text-[16px] font-bold text-g-text group-hover:text-white transition-colors">{f.title}</h3>
-                  <p className="text-[13px] text-g-muted leading-relaxed">{f.desc}</p>
-                </div>
-
-                {/* Bottom accent */}
-                <div className="absolute bottom-0 left-0 right-0 h-[2px] opacity-0 group-hover:opacity-100 transition-opacity duration-300"
-                  style={{ background: `linear-gradient(90deg, transparent, ${f.accent}60, transparent)` }} />
-              </motion.div>
-            ))}
-          </div>
-        </div>
-      </section>
-
-      {/* ══ HOW IT WORKS ════════════════════════════════════════════ */}
-      <section id="how-it-works" ref={stepsRef}
-        className="relative px-6 xl:px-20 py-28 border-y border-g-border/20 overflow-hidden"
-        style={{ background: 'linear-gradient(180deg, rgba(10,15,30,0.3) 0%, rgba(5,5,16,0.5) 100%)' }}>
-
-        <div className="max-w-[1400px] mx-auto space-y-16">
-          <div className="text-center space-y-4">
-            <p className="text-[11px] font-black uppercase tracking-[0.2em] text-g-cyan">Process</p>
-            <h2 className="text-[42px] md:text-[52px] font-black tracking-[-0.04em] text-g-text">
-              How It Works
-            </h2>
-            <p className="text-[16px] text-g-muted leading-relaxed max-w-xl mx-auto">
-              Four automated steps. You configure. Ghost Node does the rest.
-            </p>
-          </div>
-
-          <div className="relative grid grid-cols-1 sm:grid-cols-2 xl:grid-cols-4 gap-6">
-            {/* Connector line */}
-            <div className="hidden xl:block absolute top-14 left-[12%] right-[12%] h-px"
-              style={{ background: 'linear-gradient(90deg, #00e87b20, #06b6d430, #a78bfa30, #fbbf2420)' }} />
-
-            {STEPS.map((step, i) => (
-              <motion.div
-                key={step.n}
-                initial={{ opacity: 0, y: 28 }}
-                animate={stepsIn ? { opacity: 1, y: 0 } : {}}
-                transition={{ delay: i * 0.12, duration: 0.55, ease: [0.22, 1, 0.36, 1] }}
-                className="relative flex flex-col items-center text-center gap-5 group z-10"
-              >
-                {/* Number box */}
-                <motion.div
-                  whileHover={{ scale: 1.06, rotate: 2 }}
-                  transition={{ duration: 0.2 }}
-                  className="relative w-28 h-28 rounded-3xl flex items-center justify-center"
-                  style={{
-                    background: 'linear-gradient(145deg, rgba(15,22,41,0.95), rgba(8,12,24,0.98))',
-                    border: `1px solid ${step.color}30`,
-                    boxShadow: `0 0 50px ${step.color}10, 0 16px 40px rgba(0,0,0,0.5)`,
-                  }}
-                >
-                  <span className="text-[36px] font-black"
-                    style={{
-                      background: `linear-gradient(135deg, ${step.color}, ${step.color}60)`,
-                      WebkitBackgroundClip: 'text',
-                      WebkitTextFillColor: 'transparent',
-                      backgroundClip: 'text',
-                    }}>{step.n}</span>
-                  {/* Connector dot */}
-                  <div className="absolute -right-[5px] top-1/2 -translate-y-1/2 w-3 h-3 rounded-full hidden xl:block"
-                    style={{ background: step.color, boxShadow: `0 0 10px ${step.color}` }} />
-                </motion.div>
-
-                <div className="space-y-2">
-                  <h3 className="text-[16px] font-bold text-g-text">{step.title}</h3>
-                  <p className="text-[12px] text-g-muted leading-relaxed max-w-[200px] mx-auto">{step.desc}</p>
-                </div>
-              </motion.div>
-            ))}
-          </div>
-        </div>
-      </section>
-
-      {/* ══ WHO IT'S FOR ════════════════════════════════════════════ */}
-      <section ref={audRef} className="px-6 xl:px-20 py-32">
-        <div className="max-w-[1400px] mx-auto space-y-16">
-          <div className="text-center space-y-4">
-            <p className="text-[11px] font-black uppercase tracking-[0.2em] text-g-purple">Audience</p>
-            <h2 className="text-[42px] md:text-[52px] font-black tracking-[-0.04em] text-g-text">Who It's For</h2>
-          </div>
-
-          <div className="grid grid-cols-1 md:grid-cols-3 gap-6">
-            {AUDIENCE.map((a, i) => (
-              <motion.div
-                key={a.title}
-                initial={{ opacity: 0, y: 28 }}
-                animate={audIn ? { opacity: 1, y: 0 } : {}}
-                transition={{ delay: i * 0.12, duration: 0.55 }}
-                whileHover={{ y: -6, scale: 1.02 }}
-                className="relative p-8 rounded-3xl overflow-hidden group cursor-default text-center"
-                style={{
-                  background: 'linear-gradient(145deg, rgba(15,22,41,0.85), rgba(10,15,30,0.92))',
-                  border: `1px solid ${a.accent}20`,
-                  boxShadow: `0 0 60px ${a.accent}06, 0 16px 48px rgba(0,0,0,0.4)`,
-                  transition: 'all 0.3s ease',
-                }}
-              >
-                <div className="absolute inset-0 opacity-0 group-hover:opacity-100 transition-opacity duration-300 pointer-events-none"
-                  style={{ background: `radial-gradient(ellipse at 50% 0%, ${a.accent}08, transparent 60%)` }} />
-
-                <div className="relative z-10 flex flex-col items-center gap-6">
-                  <div className="w-16 h-16 rounded-2xl flex items-center justify-center transition-transform duration-300 group-hover:scale-110"
-                    style={{
-                      background: `linear-gradient(135deg, ${a.accent}20, ${a.accent}08)`,
-                      border: `1px solid ${a.accent}25`,
-                      boxShadow: `0 0 30px ${a.accent}10`,
-                    }}>
-                    <a.icon size={24} color={a.accent} strokeWidth={1.75} />
-                  </div>
-                  <div className="space-y-2">
-                    <h3 className="text-[17px] font-bold text-g-text group-hover:text-white transition-colors">{a.title}</h3>
-                    <p className="text-[13px] text-g-muted leading-relaxed">{a.desc}</p>
-                  </div>
-                </div>
-              </motion.div>
-            ))}
-          </div>
-        </div>
-      </section>
-
-      {/* ══ FAQ ═════════════════════════════════════════════════════ */}
-      <section className="px-6 xl:px-20 py-24 border-t border-g-border/20">
-        <div className="max-w-3xl mx-auto space-y-10">
-          <div className="text-center space-y-4">
-            <p className="text-[11px] font-black uppercase tracking-[0.2em] text-g-amber">FAQ</p>
-            <h2 className="text-[42px] font-black tracking-[-0.04em] text-g-text">Common Questions</h2>
-          </div>
-          <div className="space-y-3">
-            {FAQ.map(item => <FaqItem key={item.q} {...item} />)}
-          </div>
-        </div>
-      </section>
-
-      {/* ══ CTA ═════════════════════════════════════════════════════ */}
-      <section className="px-6 xl:px-20 pb-24">
-        <div className="max-w-[1400px] mx-auto">
-          <div className="relative rounded-3xl overflow-hidden py-24 text-center space-y-8"
-            style={{
-              background: 'linear-gradient(135deg, rgba(0,232,123,0.06) 0%, rgba(6,182,212,0.04) 50%, rgba(167,139,250,0.06) 100%)',
-              border: '1px solid rgba(0,232,123,0.12)',
-              boxShadow: '0 0 80px rgba(0,232,123,0.05), inset 0 1px 0 rgba(255,255,255,0.04)',
-            }}>
-            {/* BG orb */}
-            <div className="absolute inset-0 flex items-center justify-center pointer-events-none">
-              <div className="w-[600px] h-[300px] rounded-full opacity-20"
-                style={{ background: 'radial-gradient(ellipse, rgba(0,232,123,0.3) 0%, transparent 70%)', filter: 'blur(60px)' }} />
-            </div>
-
-            <div className="relative z-10 space-y-8">
-              <p className="text-[11px] font-black uppercase tracking-[0.2em] text-g-green">Ready?</p>
-
-              <h2 className="text-[52px] md:text-[68px] font-black tracking-[-0.05em] leading-none">
-                <span className="text-g-text">Start </span>
-                <GradientText>Hunting.</GradientText>
-              </h2>
-
-              <p className="text-[17px] text-g-muted max-w-md mx-auto leading-relaxed">
-                Configure your first target, launch the engine, and let Ghost Node handle the watching.
-              </p>
-
-              <div className="flex flex-wrap items-center justify-center gap-4 pt-2">
-                <Link href="/dashboard">
-                  <motion.button
-                    whileHover={{ scale: 1.06, y: -3 }}
-                    whileTap={{ scale: 0.96 }}
-                    className="inline-flex items-center gap-3 rounded-2xl font-black text-black cursor-pointer"
-                    style={{
-                      height: 56,
-                      paddingLeft: '2.5rem',
-                      paddingRight: '2.5rem',
-                      fontSize: 16,
-                      background: 'linear-gradient(135deg, #00e87b, #06b6d4)',
-                      boxShadow: '0 0 50px rgba(0,232,123,0.4), 0 8px 32px rgba(0,0,0,0.4)',
-                    }}
-                  >
-                    <CheckCircle2 size={18} />
-                    Enter Dashboard
-                  </motion.button>
-                </Link>
-                <Link href="/settings">
-                  <motion.button
-                    whileHover={{ scale: 1.04, y: -1 }}
-                    whileTap={{ scale: 0.96 }}
-                    className="g-btn inline-flex items-center gap-2"
-                    style={{ height: 56, paddingLeft: '2rem', paddingRight: '2rem', fontSize: 15 }}
-                  >
-                    Configure Engine
-                    <ArrowRight size={14} />
-                  </motion.button>
-                </Link>
-              </div>
-
-              <p className="text-[12px] text-g-faint/50 pt-2">
-                Runs entirely on your machine · No cloud fees · No subscriptions
-              </p>
-            </div>
-          </div>
-        </div>
-      </section>
-
-      {/* ══ FOOTER ══════════════════════════════════════════════════ */}
-      <footer className="border-t border-g-border/25 px-6 xl:px-20 py-10">
-        <div className="max-w-[1400px] mx-auto flex flex-col sm:flex-row items-center justify-between gap-5">
-          <div className="flex items-center gap-3">
-            <div className="w-9 h-9 rounded-xl flex items-center justify-center"
-              style={{ background: 'linear-gradient(135deg, rgba(0,232,123,0.2), rgba(6,182,212,0.1))', border: '1px solid rgba(0,232,123,0.2)' }}>
-              <span className="text-g-green font-black text-sm">G</span>
-            </div>
-            <div>
-              <p className="text-[14px] font-bold text-g-text leading-none">Ghost Node</p>
-              <p className="text-[10px] text-g-faint mt-1 tracking-[0.12em] uppercase">Auction Sniper · v2.7</p>
-            </div>
-          </div>
-          <p className="text-[12px] text-g-faint/45 text-center">
-            Built by Abbas · Auction intelligence for serious buyers
-          </p>
-          <div className="flex items-center gap-5">
-            {[['Dashboard', '/dashboard'], ['Listings', '/listings'], ['Settings', '/settings'], ['Legacy', '/legacy']].map(([l, h]) => (
-              <a key={l} href={h} className="text-[12px] text-g-faint/60 hover:text-g-green transition-colors font-medium">{l}</a>
-            ))}
-          </div>
-        </div>
-      </footer>
-
-    </div>
-  )
-}

frontend/components/layout/AmbientBackground.tsx

@@ -1,42 +0,0 @@
-'use client'
-
-export default function AmbientBackground() {
-  return (
-    <div className="fixed inset-0 -z-10 overflow-hidden pointer-events-none" aria-hidden>
-      {/* Main gradient orbs */}
-      <div
-        className="absolute -top-[40%] -left-[20%] w-[70vw] h-[70vw] rounded-full opacity-[0.035]"
-        style={{
-          background: 'radial-gradient(circle, #00e87b 0%, transparent 70%)',
-          animation: 'float-orb 20s ease-in-out infinite',
-        }}
-      />
-      <div
-        className="absolute -bottom-[30%] -right-[20%] w-[60vw] h-[60vw] rounded-full opacity-[0.025]"
-        style={{
-          background: 'radial-gradient(circle, #06b6d4 0%, transparent 70%)',
-          animation: 'float-orb 25s ease-in-out infinite reverse',
-        }}
-      />
-      <div
-        className="absolute top-[40%] left-[50%] w-[40vw] h-[40vw] rounded-full opacity-[0.02]"
-        style={{
-          background: 'radial-gradient(circle, #a78bfa 0%, transparent 70%)',
-          animation: 'float-orb 30s ease-in-out infinite 5s',
-        }}
-      />
-
-      {/* Dot grid pattern */}
-      <div
-        className="absolute inset-0 opacity-[0.03]"
-        style={{
-          backgroundImage: 'radial-gradient(circle, #8896b8 1px, transparent 1px)',
-          backgroundSize: '32px 32px',
-        }}
-      />
-
-      {/* Top gradient line */}
-      <div className="absolute top-0 inset-x-0 h-px bg-gradient-to-r from-transparent via-g-green/20 to-transparent" />
-    </div>
-  )
-}

frontend/components/layout/Header.tsx

@@ -1,75 +0,0 @@
-'use client'
-
-import Link from 'next/link'
-import { useEngineStore } from '@/store/engineStore'
-import { cn } from '@/lib/utils'
-import ThemeToggle from '@/components/layout/ThemeToggle'
-
-export default function Header() {
-  const status = useEngineStore((s) => s.status)
-  const call = (path: string) => fetch(`/api/engine/${path}`, { method: 'POST' })
-
-  const isRunning = status === 'Running'
-  const isPaused  = status === 'Paused'
-
-  return (
-    <header className="glass-strong sticky top-0 z-40">
-      {/* Gradient border at bottom */}
-      <div className="absolute bottom-0 inset-x-0 h-px bg-gradient-to-r from-transparent via-g-green/30 to-transparent" />
-
-      <div className="flex items-center justify-between px-6 h-[56px]">
-        {/* Brand */}
-        <Link href="/" className="flex items-center gap-3.5 group cursor-pointer">
-          <div className="relative">
-            <div className="flex h-9 w-9 items-center justify-center rounded-xl bg-gradient-to-br from-g-green/25 to-g-cyan/15 border border-g-green/20 group-hover:border-g-green/40 transition-colors">
-              <span className="font-extrabold text-g-green text-sm leading-none">G</span>
-            </div>
-            {/* Glow behind logo */}
-            <div className="absolute inset-0 rounded-xl bg-g-green/10 blur-lg -z-10 group-hover:bg-g-green/20 transition-colors" />
-          </div>
-          <div className="flex flex-col">
-            <span className="text-[15px] font-bold text-g-text tracking-tight leading-none group-hover:text-g-green transition-colors">
-              Ghost Node
-            </span>
-            <span className="text-[10px] text-g-faint leading-none mt-1 tracking-[0.15em] uppercase">
-              Auction Sniper · v2.7
-            </span>
-          </div>
-        </Link>
-
-        {/* Controls */}
-        <div className="flex items-center gap-2.5">
-          {/* Status pill */}
-          <div className={cn(
-            'flex items-center gap-2 px-3.5 py-1.5 rounded-full text-xs font-semibold mr-1 border transition-all duration-300',
-            isRunning
-              ? 'bg-g-green/8 border-g-green/20 text-g-green shadow-[0_0_16px_rgba(0,232,123,0.08)]'
-              : isPaused
-                ? 'bg-g-amber/8 border-g-amber/20 text-g-amber'
-                : 'bg-g-faint/10 border-g-border text-g-muted'
-          )}>
-            <span className={cn(
-              'w-2 h-2 rounded-full transition-all duration-300',
-              isRunning
-                ? 'bg-g-green shadow-[0_0_8px_rgba(0,232,123,0.8)] animate-pulse'
-                : isPaused ? 'bg-g-amber' : 'bg-g-faint'
-            )} />
-            {status}
-          </div>
-
-          <button onClick={() => call('pause')}   className="g-btn text-xs h-8">Pause</button>
-          <button onClick={() => call('resume')}  className="g-btn text-xs h-8">Resume</button>
-          <button onClick={() => call('restart')} className="g-btn text-xs h-8">Restart</button>
-          <button
-            onClick={() => { if (confirm('Kill the engine?')) call('kill') }}
-            className="g-btn-danger text-xs h-8"
-          >
-            Kill
-          </button>
-          <div className="w-px h-5 bg-g-border/50 mx-0.5" />
-          <ThemeToggle />
-        </div>
-      </div>
-    </header>
-  )
-}

frontend/components/layout/Nav.tsx

@@ -1,52 +0,0 @@
-'use client'
-import Link from 'next/link'
-import { usePathname } from 'next/navigation'
-import { cn } from '@/lib/utils'
-
-const TABS = [
-  { href: '/dashboard', label: 'Dashboard',  icon: '◈' },
-  { href: '/listings',  label: 'Listings',   icon: '≡' },
-  { href: '/keywords',  label: 'Targets',    icon: '⌖' },
-  { href: '/sites',     label: 'Sites',      icon: '⬡' },
-  { href: '/settings',  label: 'Settings',   icon: '⚙' },
-  { href: '/ai-log',    label: 'AI Log',     icon: '◎' },
-]
-
-export default function Nav() {
-  const pathname = usePathname()
-  return (
-    <nav className="glass sticky top-[56px] z-30">
-      <div className="absolute bottom-0 inset-x-0 h-px bg-gradient-to-r from-transparent via-g-border to-transparent" />
-      <div className="flex gap-0.5 px-6 overflow-x-auto scrollbar-none">
-        {TABS.map((tab) => {
-          const active = pathname === tab.href || pathname.startsWith(tab.href + '/')
-          return (
-            <Link
-              key={tab.href}
-              href={tab.href}
-              className={cn(
-                'relative flex items-center gap-1.5 px-4 py-3 text-[13px] font-semibold whitespace-nowrap transition-all duration-200',
-                active
-                  ? 'text-g-green'
-                  : 'text-g-faint hover:text-g-muted'
-              )}
-            >
-              <span className={cn(
-                'text-[11px] transition-all duration-200',
-                active ? 'text-g-green opacity-100' : 'text-g-faint opacity-50'
-              )}>
-                {tab.icon}
-              </span>
-              {tab.label}
-
-              {/* Active indicator — glowing underline */}
-              {active && (
-                <span className="absolute bottom-0 inset-x-2 h-[2px] rounded-full bg-gradient-to-r from-g-green to-g-cyan shadow-[0_0_8px_rgba(0,232,123,0.5)]" />
-              )}
-            </Link>
-          )
-        })}
-      </div>
-    </nav>
-  )
-}

frontend/components/layout/StatusBar.tsx

@@ -1,47 +0,0 @@
-'use client'
-import { useEngineStore } from '@/store/engineStore'
-import { useSSE } from '@/hooks/useSSE'
-import { formatUptime, cn } from '@/lib/utils'
-
-export default function StatusBar() {
-  useSSE()
-  const { status, uptime_seconds, total_scanned, total_alerts, isOffline } = useEngineStore()
-
-  if (isOffline) {
-    return (
-      <div className="flex items-center gap-2 bg-g-red/5 border-b border-g-red/15 px-6 py-1.5 text-xs text-g-red">
-        <span className="w-2 h-2 rounded-full bg-g-red animate-pulse flex-shrink-0" />
-        Engine offline — cannot reach server
-      </div>
-    )
-  }
-
-  const isRunning = status === 'Running'
-  const isPaused  = status === 'Paused'
-
-  return (
-    <div className="flex items-center gap-6 bg-g-base/60 backdrop-blur-sm border-b border-g-border/30 px-6 py-1.5 text-xs text-g-faint">
-      <Stat
-        dot={isRunning ? 'bg-g-green shadow-[0_0_4px_rgba(0,232,123,0.6)] animate-pulse' : isPaused ? 'bg-g-amber' : 'bg-g-faint'}
-        label="Engine"
-        value={status}
-        valueClass={isRunning ? 'text-g-green' : isPaused ? 'text-g-amber' : 'text-g-muted'}
-      />
-      <Stat label="Uptime"  value={formatUptime(uptime_seconds)} valueClass="text-g-muted" />
-      <Stat label="Scanned" value={String(total_scanned)} valueClass="text-g-text font-semibold" />
-      <Stat label="Alerts"  value={String(total_alerts)}  valueClass={total_alerts > 0 ? 'text-g-amber font-semibold' : 'text-g-muted'} />
-    </div>
-  )
-}
-
-function Stat({ label, value, valueClass = 'text-g-muted', dot }: {
-  label: string; value: string; valueClass?: string; dot?: string
-}) {
-  return (
-    <span className="flex items-center gap-1.5">
-      {dot && <span className={cn('w-1.5 h-1.5 rounded-full flex-shrink-0', dot)} />}
-      <span className="text-g-faint/70">{label}</span>
-      <span className={cn('font-medium tabular-nums', valueClass)}>{value}</span>
-    </span>
-  )
-}

frontend/components/layout/ThemeToggle.tsx

@@ -1,82 +0,0 @@
-'use client'
-import { useEffect, useState } from 'react'
-import { motion, AnimatePresence } from 'framer-motion'
-
-export type Theme = 'dark' | 'light'
-
-const STORAGE_KEY = 'ghost-theme'
-
-export function useTheme(): [Theme, () => void] {
-  const [theme, setTheme] = useState<Theme>('dark')
-
-  useEffect(() => {
-    const stored = (localStorage.getItem(STORAGE_KEY) as Theme | null) ?? 'dark'
-    setTheme(stored)
-    document.documentElement.setAttribute('data-theme', stored)
-  }, [])
-
-  const toggle = () => {
-    const next: Theme = theme === 'dark' ? 'light' : 'dark'
-    setTheme(next)
-    document.documentElement.setAttribute('data-theme', next)
-    localStorage.setItem(STORAGE_KEY, next)
-  }
-
-  return [theme, toggle]
-}
-
-export default function ThemeToggle() {
-  const [theme, toggle] = useTheme()
-  const isLight = theme === 'light'
-
-  return (
-    <motion.button
-      onClick={toggle}
-      whileHover={{ scale: 1.08 }}
-      whileTap={{ scale: 0.90 }}
-      className="relative g-btn h-8 w-8 px-0 flex items-center justify-center overflow-hidden"
-      title={`Switch to ${isLight ? 'dark' : 'light'} mode`}
-      aria-label={`Switch to ${isLight ? 'dark' : 'light'} mode`}
-    >
-      <AnimatePresence mode="wait" initial={false}>
-        {isLight ? (
-          /* Moon — switch to dark */
-          <motion.svg
-            key="moon"
-            initial={{ rotate: -90, opacity: 0, scale: 0.5 }}
-            animate={{ rotate: 0, opacity: 1, scale: 1 }}
-            exit={{ rotate: 90, opacity: 0, scale: 0.5 }}
-            transition={{ duration: 0.2 }}
-            width="14" height="14" viewBox="0 0 24 24"
-            fill="none" stroke="currentColor" strokeWidth="2"
-            strokeLinecap="round" strokeLinejoin="round"
-          >
-            <path d="M21 12.79A9 9 0 1 1 11.21 3 7 7 0 0 0 21 12.79z" />
-          </motion.svg>
-        ) : (
-          /* Sun — switch to light */
-          <motion.svg
-            key="sun"
-            initial={{ rotate: 90, opacity: 0, scale: 0.5 }}
-            animate={{ rotate: 0, opacity: 1, scale: 1 }}
-            exit={{ rotate: -90, opacity: 0, scale: 0.5 }}
-            transition={{ duration: 0.2 }}
-            width="14" height="14" viewBox="0 0 24 24"
-            fill="none" stroke="currentColor" strokeWidth="2"
-            strokeLinecap="round" strokeLinejoin="round"
-          >
-            <circle cx="12" cy="12" r="5" />
-            <line x1="12" y1="1" x2="12" y2="3" />
-            <line x1="12" y1="21" x2="12" y2="23" />
-            <line x1="4.22" y1="4.22" x2="5.64" y2="5.64" />
-            <line x1="18.36" y1="18.36" x2="19.78" y2="19.78" />
-            <line x1="1" y1="12" x2="3" y2="12" />
-            <line x1="21" y1="12" x2="23" y2="12" />
-            <line x1="4.22" y1="19.78" x2="5.64" y2="18.36" />
-            <line x1="18.36" y1="5.64" x2="19.78" y2="4.22" />
-          </motion.svg>
-        )}
-      </AnimatePresence>
-    </motion.button>
-  )
-}

frontend/components/listings/ImageGallery.tsx

@@ -1,193 +0,0 @@
-'use client'
-import { useState, useEffect } from 'react'
-import { createPortal } from 'react-dom'
-import Image from 'next/image'
-
-export default function ImageGallery({ images }: { images: string[] }) {
-  // activeIdx = which thumbnail is highlighted in the strip
-  const [activeIdx, setActiveIdx] = useState(0)
-  // lightboxIdx = null means closed; a number = open at that image
-  const [lightboxIdx, setLightboxIdx] = useState<number | null>(null)
-  // portal guard: document.body only available client-side
-  const [mounted, setMounted] = useState(false)
-
-  useEffect(() => { setMounted(true) }, [])
-
-  // Keyboard navigation for lightbox (←  →  Esc)
-  useEffect(() => {
-    if (lightboxIdx === null) return
-    const handler = (e: KeyboardEvent) => {
-      if (e.key === 'ArrowLeft')  lbGo((lightboxIdx - 1 + images.length) % images.length)
-      if (e.key === 'ArrowRight') lbGo((lightboxIdx + 1) % images.length)
-      if (e.key === 'Escape')     setLightboxIdx(null)
-    }
-    window.addEventListener('keydown', handler)
-    return () => window.removeEventListener('keydown', handler)
-  }, [lightboxIdx, images.length]) // eslint-disable-line react-hooks/exhaustive-deps
-
-  if (!images.length) return null
-
-  // Navigate lightbox AND keep strip highlight in sync
-  const lbGo = (idx: number) => { setLightboxIdx(idx); setActiveIdx(idx) }
-
-  // Strip-only prev/next (highlight moves, lightbox stays closed)
-  const stripPrev = (e: React.MouseEvent) => {
-    e.stopPropagation()
-    setActiveIdx(i => (i - 1 + images.length) % images.length)
-  }
-  const stripNext = (e: React.MouseEvent) => {
-    e.stopPropagation()
-    setActiveIdx(i => (i + 1) % images.length)
-  }
-
-  // Lightbox arrow handlers
-  const lbPrev = (e: React.MouseEvent) => {
-    e.stopPropagation()
-    if (lightboxIdx !== null) lbGo((lightboxIdx - 1 + images.length) % images.length)
-  }
-  const lbNext = (e: React.MouseEvent) => {
-    e.stopPropagation()
-    if (lightboxIdx !== null) lbGo((lightboxIdx + 1) % images.length)
-  }
-
-  // ── Lightbox portal ──────────────────────────────────────────────────────
-  // Rendered via createPortal so it escapes the panel's z-50 stacking context.
-  // Sized & positioned identically to the detail panel (w-96 h-full fixed right-0 top-0).
-  const lightbox = lightboxIdx !== null && mounted
-    ? createPortal(
-        // Semi-transparent backdrop — clicking it closes the lightbox
-        <div
-          className="fixed inset-0 z-[100] flex items-stretch justify-end"
-          style={{ background: 'rgba(0,0,0,0.5)' }}
-          onClick={() => setLightboxIdx(null)}
-        >
-          {/* Inner panel — same w-96 as the detail panel */}
-          <div
-            className="h-full w-96 border-l border-ghost-accent flex flex-col"
-            style={{ background: 'var(--color-ghost-bg)' }}
-            onClick={e => e.stopPropagation()}
-          >
-            {/* Header */}
-            <div className="flex items-center justify-between px-4 py-3 border-b border-ghost-border shrink-0">
-              <span className="font-mono text-ghost-dim text-xs tracking-widest">
-                IMAGE {lightboxIdx + 1} / {images.length}
-              </span>
-              <button
-                onClick={() => setLightboxIdx(null)}
-                className="text-ghost-dim hover:text-ghost-danger font-mono text-xs transition-colors"
-              >
-                ✕ CLOSE
-              </button>
-            </div>
-
-            {/* Full-size image */}
-            <div className="flex-1 flex items-center justify-center p-4 overflow-hidden">
-              {/* eslint-disable-next-line @next/next/no-img-element */}
-              <img
-                src={images[lightboxIdx]}
-                alt={`Lot image ${lightboxIdx + 1}`}
-                className="max-w-full max-h-full object-contain rounded"
-              />
-            </div>
-
-            {/* Footer — arrows + dot indicators */}
-            {images.length > 1 && (
-              <div className="flex items-center justify-between px-4 py-3 border-t border-ghost-border shrink-0">
-                <button
-                  onClick={lbPrev}
-                  className="font-mono text-ghost-accent hover:text-ghost-text text-sm transition-colors px-2 py-1"
-                >
-                  ‹ PREV
-                </button>
-
-                {/* Dot indicators — click to jump */}
-                <div className="flex gap-1.5 items-center">
-                  {images.map((_, i) => (
-                    <button
-                      key={i}
-                      onClick={() => lbGo(i)}
-                      className={`rounded-full transition-all ${
-                        i === lightboxIdx
-                          ? 'w-3 h-3 bg-ghost-accent'
-                          : 'w-2 h-2 bg-ghost-border hover:bg-ghost-dim'
-                      }`}
-                    />
-                  ))}
-                </div>
-
-                <button
-                  onClick={lbNext}
-                  className="font-mono text-ghost-accent hover:text-ghost-text text-sm transition-colors px-2 py-1"
-                >
-                  NEXT ›
-                </button>
-              </div>
-            )}
-          </div>
-        </div>,
-        document.body
-      )
-    : null
-
-  // ── Thumbnail strip ──────────────────────────────────────────────────────
-  return (
-    <>
-      <div>
-        <div className="text-ghost-dim text-xs font-mono mb-2">LOT IMAGES</div>
-
-        {/* Strip: ‹ [thumbnails] › */}
-        <div className="flex items-center gap-1">
-          {images.length > 1 && (
-            <button
-              onClick={stripPrev}
-              title="Previous image"
-              className="text-ghost-dim hover:text-ghost-accent font-mono text-xl leading-none px-0.5 shrink-0 transition-colors"
-            >
-              ‹
-            </button>
-          )}
-
-          <div className="flex gap-2 overflow-x-auto flex-1 pb-1">
-            {images.map((src, i) => (
-              <button
-                key={i}
-                onClick={() => { setActiveIdx(i); setLightboxIdx(i) }}
-                title={`Open image ${i + 1}`}
-                className={`shrink-0 rounded transition-all border-2 ${
-                  i === activeIdx
-                    ? 'border-ghost-accent scale-105'
-                    : 'border-ghost-border hover:border-ghost-dim'
-                }`}
-              >
-                <Image
-                  src={src}
-                  alt={`Lot image ${i + 1}`}
-                  width={100}
-                  height={80}
-                  className="object-cover rounded"
-                  onError={e => {
-                    const parent = e.currentTarget.parentElement
-                    if (parent) parent.style.display = 'none'
-                  }}
-                />
-              </button>
-            ))}
-          </div>
-
-          {images.length > 1 && (
-            <button
-              onClick={stripNext}
-              title="Next image"
-              className="text-ghost-dim hover:text-ghost-accent font-mono text-xl leading-none px-0.5 shrink-0 transition-colors"
-            >
-              ›
-            </button>
-          )}
-        </div>
-      </div>
-
-      {/* Lightbox rendered at document.body via portal */}
-      {lightbox}
-    </>
-  )
-}

frontend/components/listings/ListingDetailPanel.tsx

@@ -1,92 +0,0 @@
-'use client'
-import { motion, AnimatePresence } from 'framer-motion'
-import ImageGallery from './ImageGallery'
-import type { Listing } from '@/lib/types'
-
-interface Props { listing: Listing | null; onClose: () => void }
-
-export default function ListingDetailPanel({ listing, onClose }: Props) {
-  return (
-    <AnimatePresence>
-      {listing && (
-        <>
-          <motion.div
-            initial={{ opacity: 1 }} animate={{ opacity: 1 }} exit={{ opacity: 0 }}
-            onClick={onClose}
-            className="fixed inset-0 bg-black/60 backdrop-blur-md z-40"
-          />
-          <motion.div
-            initial={{ x: '100%', opacity: 0 }}
-            animate={{ x: 0, opacity: 1 }}
-            exit={{ x: '100%', opacity: 0 }}
-            transition={{ type: 'spring', damping: 30, stiffness: 260 }}
-            className="fixed right-0 top-0 h-full w-[32rem] glass-strong z-50 overflow-y-auto shadow-2xl shadow-black/60"
-          >
-            {/* Gradient accent at top */}
-            <div className="h-px bg-gradient-to-r from-g-green/50 via-g-cyan/40 to-transparent" />
-
-            <div className="sticky top-0 flex items-center justify-between px-6 py-4 border-b border-g-border/30 glass-strong z-10">
-              <span className="text-[10px] font-bold text-g-faint uppercase tracking-[0.15em]">Lot Detail</span>
-              <button onClick={onClose} className="g-btn h-7 px-3 text-xs">✕ Close</button>
-            </div>
-
-            <div className="p-6 space-y-6">
-              <div>
-                <h2 className="text-g-text font-bold text-base leading-snug">{listing.title}</h2>
-                <div className="flex items-center gap-2 mt-3 flex-wrap">
-                  <span className="g-badge g-badge-neutral">{listing.site_name}</span>
-                  <span className="g-badge g-badge-blue">{listing.keyword}</span>
-                  {listing.ai_match === 1 && <span className="g-badge g-badge-green">AI Match</span>}
-                  {listing.ai_match === 0 && <span className="g-badge g-badge-red">AI Rejected</span>}
-                </div>
-              </div>
-
-              <div className="grid grid-cols-2 gap-3">
-                <div className="g-card-glow p-4">
-                  <p className="text-[10px] uppercase tracking-[0.12em] text-g-faint mb-2">Price</p>
-                  <p className="font-mono text-xl font-extrabold text-g-amber">{listing.price_raw || '—'}</p>
-                </div>
-                <div className="g-card-glow p-4">
-                  <p className="text-[10px] uppercase tracking-[0.12em] text-g-faint mb-2">Score</p>
-                  <p className="font-mono text-xl font-extrabold text-g-text">{listing.score}</p>
-                </div>
-              </div>
-
-              <div className="g-card divide-y divide-g-border/30">
-                <MetaRow label="Location" value={listing.location || '—'} />
-                <MetaRow label="Captured" value={new Date(listing.timestamp).toLocaleString()} />
-                {listing.ai_reason && (
-                  <MetaRow label="AI reason" value={listing.ai_reason}
-                    valueClass={listing.ai_match === 1 ? 'text-g-green' : 'text-g-red'} />
-                )}
-              </div>
-
-              {listing.images?.length > 0 && (
-                <div>
-                  <p className="text-[10px] uppercase tracking-[0.12em] text-g-faint mb-3">Images</p>
-                  <ImageGallery images={listing.images} />
-                </div>
-              )}
-
-              <a href={listing.link} target="_blank" rel="noopener noreferrer"
-                className="g-btn-primary w-full justify-center text-sm py-3 !rounded-xl font-semibold">
-                Open lot →
-              </a>
-            </div>
-          </motion.div>
-        </>
-      )}
-    </AnimatePresence>
-  )
-}
-
-function MetaRow({ label, value, valueClass = 'text-g-muted' }: {
-  label: string; value: string; valueClass?: string
-}) {
-  return (
-    <div className="flex gap-4 px-4 py-3">
-      <span className="text-xs text-g-faint/60 w-20 flex-shrink-0">{label}</span>
-      <span className={`text-xs leading-relaxed ${valueClass}`}>{value}</span>
-    </div>
-  )
-}

frontend/components/listings/ListingRow.tsx

@@ -1,105 +0,0 @@
-'use client'
-import Image from 'next/image'
-import { motion } from 'framer-motion'
-import { useCountdown } from '@/hooks/useCountdown'
-import { cn } from '@/lib/utils'
-import type { Listing } from '@/lib/types'
-
-function formatMins(mins: number | null): string {
-  if (mins === null) return '—'
-  if (mins < 1) return '<1m'
-  const d = Math.floor(mins / 1440)
-  const h = Math.floor((mins % 1440) / 60)
-  const m = Math.floor(mins % 60)
-  return [d && `${d}d`, h && `${h}h`, `${m}m`].filter(Boolean).join(' ')
-}
-
-const AiBadge = ({ match }: { match: 1 | 0 | null }) => {
-  if (match === 1) return <span title="AI match" className="g-badge g-badge-green"><span className="w-1 h-1 rounded-full bg-g-green shadow-[0_0_4px_rgba(0,232,123,0.6)]" />Match</span>
-  if (match === 0) return <span title="AI rejected" className="g-badge g-badge-red"><span className="w-1 h-1 rounded-full bg-g-red" />Skip</span>
-  return <span className="text-g-faint text-xs">—</span>
-}
-
-interface Props { listing: Listing; onSelect: (l: Listing) => void }
-
-export default function ListingRow({ listing, onSelect }: Props) {
-  const getTime = useCountdown()
-  const mins = getTime(listing.id) ?? listing.time_left_mins
-  const isUrgent = mins !== null && mins < 60
-
-  return (
-    <motion.tr
-      initial={{ opacity: 1, y: -6 }}
-      animate={{ opacity: 1, y: 0 }}
-      transition={{ duration: 0.3 }}
-      className={cn(
-        'transition-all duration-200',
-        listing.ai_match === 0 && 'opacity-40'
-      )}
-    >
-      <td className="w-16">
-        {listing.images[0] ? (
-          <div className="relative w-11 h-11 rounded-xl overflow-hidden bg-g-raised ring-1 ring-g-border/50 group/img">
-            <Image
-              src={listing.images[0]} alt={listing.title}
-              width={44} height={44}
-              className="object-cover w-full h-full transition-transform duration-300 group-hover/img:scale-110"
-              onError={(e) => { e.currentTarget.style.display = 'none' }}
-            />
-          </div>
-        ) : (
-          <div className="w-11 h-11 bg-gradient-to-br from-g-raised to-g-panel rounded-xl ring-1 ring-g-border/30 flex items-center justify-center">
-            <span className="text-g-faint/30 text-xs">—</span>
-          </div>
-        )}
-      </td>
-
-      <td>
-        <button
-          onClick={() => onSelect(listing)}
-          className="text-left text-g-text hover:text-g-green transition-all duration-200 block text-sm font-medium leading-snug group/title"
-        >
-          <span className="group-hover/title:underline decoration-g-green/30 underline-offset-2">
-            {listing.title.length > 64 ? listing.title.slice(0, 64) + '…' : listing.title}
-          </span>
-        </button>
-        <div className="flex items-center gap-1.5 mt-1">
-          {listing.location && <span className="text-[11px] text-g-faint/60">{listing.location}</span>}
-          {listing.location && <span className="text-g-faint/20 text-[8px]">·</span>}
-          <span className="text-[11px] text-g-faint/60">{listing.site_name}</span>
-        </div>
-      </td>
-
-      <td>
-        <span className="font-mono text-sm font-semibold tabular-nums text-g-amber">
-          {listing.price_raw || '—'}
-        </span>
-      </td>
-
-      <td>
-        <div className="flex items-center gap-1.5">
-          <span className={cn(
-            'font-mono text-sm tabular-nums',
-            isUrgent ? 'text-g-red font-bold' : 'text-g-muted'
-          )}>
-            {formatMins(mins)}
-          </span>
-          {isUrgent && <span className="g-badge g-badge-red text-[10px] py-0 animate-pulse">Live</span>}
-        </div>
-      </td>
-
-      <td className="text-center">
-        <span className={cn(
-          'font-mono text-sm font-bold tabular-nums',
-          listing.score >= 20 ? 'text-g-green' :
-          listing.score >= 10 ? 'text-g-amber' : 'text-g-muted'
-        )}>
-          {listing.score}
-        </span>
-      </td>
-
-      <td><span className="g-badge g-badge-blue text-[11px]">{listing.keyword}</span></td>
-      <td className="text-center"><AiBadge match={listing.ai_match} /></td>
-    </motion.tr>
-  )
-}

frontend/components/listings/ListingsTable.tsx

@@ -1,94 +0,0 @@
-'use client'
-import { useState } from 'react'
-import { motion } from 'framer-motion'
-import ListingRow from './ListingRow'
-import ListingDetailPanel from './ListingDetailPanel'
-import { useListings, useDeleteAllListings } from '@/hooks/useListings'
-import { getExportUrl } from '@/lib/api/listings'
-import type { Listing } from '@/lib/types'
-
-export default function ListingsTable() {
-  const { data: listings, isLoading, isError } = useListings()
-  const deleteAll = useDeleteAllListings()
-  const [selected, setSelected] = useState<Listing | null>(null)
-  const [search, setSearch] = useState('')
-
-  if (isLoading) return <SkeletonTable />
-  if (isError)   return <ErrorBanner />
-
-  const filtered = search
-    ? (listings ?? []).filter((l) =>
-        l.title.toLowerCase().includes(search.toLowerCase()) ||
-        l.keyword.toLowerCase().includes(search.toLowerCase())
-      )
-    : (listings ?? [])
-
-  return (
-    <>
-      <motion.div
-        initial={{ opacity: 1, y: -12 }}
-        animate={{ opacity: 1, y: 0 }}
-        transition={{ duration: 0.4 }}
-        className="g-card"
-      >
-        {/* Toolbar */}
-        <div className="flex gap-3 items-center flex-wrap px-5 py-4 border-b border-g-border/40">
-          <div className="relative">
-            <span className="absolute left-3 top-1/2 -translate-y-1/2 text-g-faint/40 text-xs">⌕</span>
-            <input
-              value={search} onChange={(e) => setSearch(e.target.value)}
-              placeholder="Search listings…"
-              className="g-input pl-7 w-56 h-9 text-sm"
-            />
-          </div>
-          <span className="text-xs text-g-faint tabular-nums">{filtered.length} <span className="text-g-faint/50">lots</span></span>
-          <div className="ml-auto flex gap-2">
-            <button onClick={() => window.open(getExportUrl('csv'))}  className="g-btn text-xs">Export CSV</button>
-            <button onClick={() => window.open(getExportUrl('json'))} className="g-btn text-xs">Export JSON</button>
-            <button onClick={() => { if (confirm('Clear all?')) deleteAll.mutate() }} className="g-btn-danger text-xs">Clear all</button>
-          </div>
-        </div>
-
-        {/* Table */}
-        <div className="overflow-x-auto">
-          <table className="g-table">
-            <thead><tr>
-              <th className="w-16"></th><th>Title</th><th>Price</th>
-              <th>Time left</th><th className="text-center">Score</th>
-              <th>Keyword</th><th className="text-center">AI</th>
-            </tr></thead>
-            <tbody>
-              {filtered.map((l) => <ListingRow key={l.id} listing={l} onSelect={setSelected} />)}
-            </tbody>
-          </table>
-          {!filtered.length && (
-            <div className="flex flex-col items-center justify-center py-20 text-g-faint gap-3">
-              <div className="w-16 h-16 rounded-2xl bg-gradient-to-br from-g-raised to-g-panel flex items-center justify-center border border-g-border/30">
-                <span className="text-2xl opacity-30">≡</span>
-              </div>
-              <p className="text-sm font-medium">No listings captured yet</p>
-              <p className="text-xs text-g-faint/50">Start the engine and add target sites</p>
-            </div>
-          )}
-        </div>
-      </motion.div>
-      <ListingDetailPanel listing={selected} onClose={() => setSelected(null)} />
-    </>
-  )
-}
-
-const SkeletonTable = () => (
-  <div className="g-card p-5 space-y-3">
-    {Array.from({ length: 6 }).map((_, i) => (
-      <div key={i} style={{ opacity: 1 - i * 0.15, animationDelay: `${i * 0.1}s` }}
-        className="h-14 bg-gradient-to-r from-g-raised/60 to-g-panel/30 rounded-xl animate-pulse" />
-    ))}
-  </div>
-)
-
-const ErrorBanner = () => (
-  <div className="g-card border-g-red/20 p-5 text-g-red text-sm flex items-center gap-2">
-    <span className="w-2 h-2 rounded-full bg-g-red animate-pulse" />
-    Engine offline — cannot reach server
-  </div>
-)

frontend/components/sites/SiteRow.tsx

@@ -1,112 +0,0 @@
-'use client'
-import { useState, useRef } from 'react'
-import { useSortable } from '@dnd-kit/sortable'
-import { CSS } from '@dnd-kit/utilities'
-import { useUpdateSite, useDeleteSite, useAdaptSite, useSiteSelectors } from '@/hooks/useSites'
-import { useQueryClient } from '@tanstack/react-query'
-import type { TargetSite } from '@/lib/types'
-import { cn } from '@/lib/utils'
-
-function HealthBadge({ site }: { site: TargetSite }) {
-  const inCooldown = site.cooldown_until && new Date(site.cooldown_until) > new Date()
-  if (inCooldown) return <span className="g-badge g-badge-amber">Cooldown</span>
-  if (site.consecutive_failures > 2) return <span className="g-badge g-badge-red">{site.error_count} errors</span>
-  return <span className="g-badge g-badge-green">OK</span>
-}
-
-function ConfidenceBadge({ siteId }: { siteId: number }) {
-  const { data: sel } = useSiteSelectors(siteId)
-  if (!sel) return <span className="text-g-faint text-xs">—</span>
-  const cls = sel.confidence >= 70 ? 'g-badge-green' : sel.confidence >= 40 ? 'g-badge-amber' : 'g-badge-red'
-  return (
-    <span className={`g-badge ${cls}`}>
-      {sel.confidence}%{sel.stale ? ' ⚠' : ''}
-    </span>
-  )
-}
-
-const ADAPT_POLL_DELAY = 45_000
-
-export default function SiteRow({ site }: { site: TargetSite }) {
-  const { attributes, listeners, setNodeRef, transform, transition } = useSortable({ id: site.id })
-  const updateSiteMut = useUpdateSite()
-  const deleteSiteMut = useDeleteSite()
-  const adaptSiteMut  = useAdaptSite()
-  const qc            = useQueryClient()
-  const [adapting, setAdapting] = useState(false)
-  const timerRef = useRef<ReturnType<typeof setTimeout> | null>(null)
-
-  const handleAdapt = () => {
-    adaptSiteMut.mutate(site.id, {
-      onSuccess: () => {
-        setAdapting(true)
-        if (timerRef.current) clearTimeout(timerRef.current)
-        timerRef.current = setTimeout(() => {
-          setAdapting(false)
-          qc.invalidateQueries({ queryKey: ['selectors', site.id] })
-        }, ADAPT_POLL_DELAY)
-      },
-    })
-  }
-
-  const style = { transform: CSS.Transform.toString(transform), transition }
-  const isAdapting = adaptSiteMut.isPending || adapting
-
-  return (
-    <tr ref={setNodeRef} style={style} className="group">
-      <td className="w-8">
-        <span
-          {...attributes} {...listeners}
-          className="cursor-grab text-g-faint/30 hover:text-g-faint transition-colors select-none"
-        >
-          ⋮⋮
-        </span>
-      </td>
-      <td>
-        <span className="text-sm font-medium text-g-text">{site.name}</span>
-      </td>
-      <td>
-        <span className="text-xs font-mono text-g-faint truncate max-w-xs block">{site.url_template}</span>
-      </td>
-      <td><HealthBadge site={site} /></td>
-      <td><ConfidenceBadge siteId={site.id} /></td>
-      <td>
-        <label className="flex items-center gap-2 cursor-pointer w-fit">
-          <div
-            onClick={() => updateSiteMut.mutate({ id: site.id, data: { enabled: site.enabled ? 0 : 1 } })}
-            className={cn(
-              'relative w-8 h-4 rounded-full transition-colors duration-200 cursor-pointer flex-shrink-0',
-              site.enabled ? 'bg-g-green/30 border border-g-green/40' : 'bg-g-raised border border-g-border'
-            )}
-          >
-            <span className={cn(
-              'absolute top-0.5 w-3 h-3 rounded-full transition-transform duration-200 shadow-sm',
-              site.enabled ? 'left-[18px] bg-g-green' : 'left-0.5 bg-g-faint'
-            )} />
-          </div>
-          <span className="text-xs text-g-faint">{site.enabled ? 'On' : 'Off'}</span>
-        </label>
-      </td>
-      <td>
-        <div className="flex items-center gap-2">
-          <button
-            onClick={handleAdapt}
-            disabled={isAdapting}
-            className={cn(
-              'g-btn text-xs h-7',
-              isAdapting && 'opacity-60 cursor-not-allowed'
-            )}
-          >
-            {isAdapting ? 'Adapting…' : 'Adapt AI'}
-          </button>
-          <button
-            onClick={() => { if (confirm(`Delete "${site.name}"?`)) deleteSiteMut.mutate(site.id) }}
-            className="text-g-faint hover:text-g-red transition-colors text-xs opacity-0 group-hover:opacity-100"
-          >
-            ✕
-          </button>
-        </div>
-      </td>
-    </tr>
-  )
-}

frontend/components/sites/SitesTable.tsx

@@ -1,54 +0,0 @@
-'use client'
-import { DndContext, closestCenter, type DragEndEvent } from '@dnd-kit/core'
-import { SortableContext, verticalListSortingStrategy } from '@dnd-kit/sortable'
-import SiteRow from './SiteRow'
-import { useSites, useReorderSites } from '@/hooks/useSites'
-
-export default function SitesTable() {
-  const { data: sites } = useSites()
-  const reorder = useReorderSites()
-
-  const handleDragEnd = ({ active, over }: DragEndEvent) => {
-    if (!over || active.id === over.id || !sites) return
-    const ids = sites.map((s) => s.id)
-    const from = ids.indexOf(Number(active.id))
-    const to   = ids.indexOf(Number(over.id))
-    const newOrder = [...ids]
-    newOrder.splice(to, 0, newOrder.splice(from, 1)[0])
-    reorder.mutate(newOrder)
-  }
-
-  return (
-    <div className="g-card overflow-hidden">
-      <DndContext collisionDetection={closestCenter} onDragEnd={handleDragEnd}>
-        <SortableContext items={(sites ?? []).map((s) => s.id)} strategy={verticalListSortingStrategy}>
-          <div className="overflow-x-auto">
-            <table className="g-table">
-              <thead>
-                <tr>
-                  <th className="w-8"></th>
-                  <th>Name</th>
-                  <th>URL template</th>
-                  <th>Health</th>
-                  <th>AI confidence</th>
-                  <th>Enabled</th>
-                  <th>Actions</th>
-                </tr>
-              </thead>
-              <tbody>
-                {(sites ?? []).map((s) => <SiteRow key={s.id} site={s} />)}
-              </tbody>
-            </table>
-            {!(sites ?? []).length && (
-              <div className="flex flex-col items-center justify-center py-14 text-g-faint gap-2">
-                <span className="text-3xl opacity-20">⬡</span>
-                <p className="text-sm">No sites added yet</p>
-                <p className="text-xs opacity-60">Add a site below to start scraping</p>
-              </div>
-            )}
-          </div>
-        </SortableContext>
-      </DndContext>
-    </div>
-  )
-}

frontend/components/ui/background-beams.tsx

@@ -1,141 +0,0 @@
-"use client";
-import React from "react";
-import { motion } from "motion/react";
-import { cn } from "@/lib/utils";
-
-export const BackgroundBeams = React.memo(
-  ({ className }: { className?: string }) => {
-    const paths = [
-      "M-380 -189C-380 -189 -312 216 152 343C616 470 684 875 684 875",
-      "M-373 -197C-373 -197 -305 208 159 335C623 462 691 867 691 867",
-      "M-366 -205C-366 -205 -298 200 166 327C630 454 698 859 698 859",
-      "M-359 -213C-359 -213 -291 192 173 319C637 446 705 851 705 851",
-      "M-352 -221C-352 -221 -284 184 180 311C644 438 712 843 712 843",
-      "M-345 -229C-345 -229 -277 176 187 303C651 430 719 835 719 835",
-      "M-338 -237C-338 -237 -270 168 194 295C658 422 726 827 726 827",
-      "M-331 -245C-331 -245 -263 160 201 287C665 414 733 819 733 819",
-      "M-324 -253C-324 -253 -256 152 208 279C672 406 740 811 740 811",
-      "M-317 -261C-317 -261 -249 144 215 271C679 398 747 803 747 803",
-      "M-310 -269C-310 -269 -242 136 222 263C686 390 754 795 754 795",
-      "M-303 -277C-303 -277 -235 128 229 255C693 382 761 787 761 787",
-      "M-296 -285C-296 -285 -228 120 236 247C700 374 768 779 768 779",
-      "M-289 -293C-289 -293 -221 112 243 239C707 366 775 771 775 771",
-      "M-282 -301C-282 -301 -214 104 250 231C714 358 782 763 782 763",
-      "M-275 -309C-275 -309 -207 96 257 223C721 350 789 755 789 755",
-      "M-268 -317C-268 -317 -200 88 264 215C728 342 796 747 796 747",
-      "M-261 -325C-261 -325 -193 80 271 207C735 334 803 739 803 739",
-      "M-254 -333C-254 -333 -186 72 278 199C742 326 810 731 810 731",
-      "M-247 -341C-247 -341 -179 64 285 191C749 318 817 723 817 723",
-      "M-240 -349C-240 -349 -172 56 292 183C756 310 824 715 824 715",
-      "M-233 -357C-233 -357 -165 48 299 175C763 302 831 707 831 707",
-      "M-226 -365C-226 -365 -158 40 306 167C770 294 838 699 838 699",
-      "M-219 -373C-219 -373 -151 32 313 159C777 286 845 691 845 691",
-      "M-212 -381C-212 -381 -144 24 320 151C784 278 852 683 852 683",
-      "M-205 -389C-205 -389 -137 16 327 143C791 270 859 675 859 675",
-      "M-198 -397C-198 -397 -130 8 334 135C798 262 866 667 866 667",
-      "M-191 -405C-191 -405 -123 0 341 127C805 254 873 659 873 659",
-      "M-184 -413C-184 -413 -116 -8 348 119C812 246 880 651 880 651",
-      "M-177 -421C-177 -421 -109 -16 355 111C819 238 887 643 887 643",
-      "M-170 -429C-170 -429 -102 -24 362 103C826 230 894 635 894 635",
-      "M-163 -437C-163 -437 -95 -32 369 95C833 222 901 627 901 627",
-      "M-156 -445C-156 -445 -88 -40 376 87C840 214 908 619 908 619",
-      "M-149 -453C-149 -453 -81 -48 383 79C847 206 915 611 915 611",
-      "M-142 -461C-142 -461 -74 -56 390 71C854 198 922 603 922 603",
-      "M-135 -469C-135 -469 -67 -64 397 63C861 190 929 595 929 595",
-      "M-128 -477C-128 -477 -60 -72 404 55C868 182 936 587 936 587",
-      "M-121 -485C-121 -485 -53 -80 411 47C875 174 943 579 943 579",
-      "M-114 -493C-114 -493 -46 -88 418 39C882 166 950 571 950 571",
-      "M-107 -501C-107 -501 -39 -96 425 31C889 158 957 563 957 563",
-      "M-100 -509C-100 -509 -32 -104 432 23C896 150 964 555 964 555",
-      "M-93 -517C-93 -517 -25 -112 439 15C903 142 971 547 971 547",
-      "M-86 -525C-86 -525 -18 -120 446 7C910 134 978 539 978 539",
-      "M-79 -533C-79 -533 -11 -128 453 -1C917 126 985 531 985 531",
-      "M-72 -541C-72 -541 -4 -136 460 -9C924 118 992 523 992 523",
-      "M-65 -549C-65 -549 3 -144 467 -17C931 110 999 515 999 515",
-      "M-58 -557C-58 -557 10 -152 474 -25C938 102 1006 507 1006 507",
-      "M-51 -565C-51 -565 17 -160 481 -33C945 94 1013 499 1013 499",
-      "M-44 -573C-44 -573 24 -168 488 -41C952 86 1020 491 1020 491",
-      "M-37 -581C-37 -581 31 -176 495 -49C959 78 1027 483 1027 483",
-    ];
-    return (
-      <div
-        className={cn(
-          "absolute inset-0 flex h-full w-full items-center justify-center [mask-repeat:no-repeat] [mask-size:40px]",
-          className,
-        )}
-      >
-        <svg
-          className="pointer-events-none absolute z-0 h-full w-full"
-          width="100%"
-          height="100%"
-          viewBox="0 0 696 316"
-          fill="none"
-          xmlns="http://www.w3.org/2000/svg"
-        >
-          <path
-            d="M-380 -189C-380 -189 -312 216 152 343C616 470 684 875 684 875M-373 -197C-373 -197 -305 208 159 335C623 462 691 867 691 867M-366 -205C-366 -205 -298 200 166 327C630 454 698 859 698 859M-359 -213C-359 -213 -291 192 173 319C637 446 705 851 705 851M-352 -221C-352 -221 -284 184 180 311C644 438 712 843 712 843M-345 -229C-345 -229 -277 176 187 303C651 430 719 835 719 835M-338 -237C-338 -237 -270 168 194 295C658 422 726 827 726 827M-331 -245C-331 -245 -263 160 201 287C665 414 733 819 733 819M-324 -253C-324 -253 -256 152 208 279C672 406 740 811 740 811M-317 -261C-317 -261 -249 144 215 271C679 398 747 803 747 803M-310 -269C-310 -269 -242 136 222 263C686 390 754 795 754 795M-303 -277C-303 -277 -235 128 229 255C693 382 761 787 761 787M-296 -285C-296 -285 -228 120 236 247C700 374 768 779 768 779M-289 -293C-289 -293 -221 112 243 239C707 366 775 771 775 771M-282 -301C-282 -301 -214 104 250 231C714 358 782 763 782 763M-275 -309C-275 -309 -207 96 257 223C721 350 789 755 789 755M-268 -317C-268 -317 -200 88 264 215C728 342 796 747 796 747M-261 -325C-261 -325 -193 80 271 207C735 334 803 739 803 739M-254 -333C-254 -333 -186 72 278 199C742 326 810 731 810 731M-247 -341C-247 -341 -179 64 285 191C749 318 817 723 817 723M-240 -349C-240 -349 -172 56 292 183C756 310 824 715 824 715M-233 -357C-233 -357 -165 48 299 175C763 302 831 707 831 707M-226 -365C-226 -365 -158 40 306 167C770 294 838 699 838 699M-219 -373C-219 -373 -151 32 313 159C777 286 845 691 845 691M-212 -381C-212 -381 -144 24 320 151C784 278 852 683 852 683M-205 -389C-205 -389 -137 16 327 143C791 270 859 675 859 675M-198 -397C-198 -397 -130 8 334 135C798 262 866 667 866 667M-191 -405C-191 -405 -123 0 341 127C805 254 873 659 873 659M-184 -413C-184 -413 -116 -8 348 119C812 246 880 651 880 651M-177 -421C-177 -421 -109 -16 355 111C819 238 887 643 887 643M-170 -429C-170 -429 -102 -24 362 103C826 230 894 635 894 635M-163 -437C-163 -437 -95 -32 369 95C833 222 901 627 901 627M-156 -445C-156 -445 -88 -40 376 87C840 214 908 619 908 619M-149 -453C-149 -453 -81 -48 383 79C847 206 915 611 915 611M-142 -461C-142 -461 -74 -56 390 71C854 198 922 603 922 603M-135 -469C-135 -469 -67 -64 397 63C861 190 929 595 929 595M-128 -477C-128 -477 -60 -72 404 55C868 182 936 587 936 587M-121 -485C-121 -485 -53 -80 411 47C875 174 943 579 943 579M-114 -493C-114 -493 -46 -88 418 39C882 166 950 571 950 571M-107 -501C-107 -501 -39 -96 425 31C889 158 957 563 957 563M-100 -509C-100 -509 -32 -104 432 23C896 150 964 555 964 555M-93 -517C-93 -517 -25 -112 439 15C903 142 971 547 971 547M-86 -525C-86 -525 -18 -120 446 7C910 134 978 539 978 539M-79 -533C-79 -533 -11 -128 453 -1C917 126 985 531 985 531M-72 -541C-72 -541 -4 -136 460 -9C924 118 992 523 992 523M-65 -549C-65 -549 3 -144 467 -17C931 110 999 515 999 515M-58 -557C-58 -557 10 -152 474 -25C938 102 1006 507 1006 507M-51 -565C-51 -565 17 -160 481 -33C945 94 1013 499 1013 499M-44 -573C-44 -573 24 -168 488 -41C952 86 1020 491 1020 491M-37 -581C-37 -581 31 -176 495 -49C959 78 1027 483 1027 483M-30 -589C-30 -589 38 -184 502 -57C966 70 1034 475 1034 475M-23 -597C-23 -597 45 -192 509 -65C973 62 1041 467 1041 467M-16 -605C-16 -605 52 -200 516 -73C980 54 1048 459 1048 459M-9 -613C-9 -613 59 -208 523 -81C987 46 1055 451 1055 451M-2 -621C-2 -621 66 -216 530 -89C994 38 1062 443 1062 443M5 -629C5 -629 73 -224 537 -97C1001 30 1069 435 1069 435M12 -637C12 -637 80 -232 544 -105C1008 22 1076 427 1076 427M19 -645C19 -645 87 -240 551 -113C1015 14 1083 419 1083 419"
-            stroke="url(#paint0_radial_242_278)"
-            strokeOpacity="0.05"
-            strokeWidth="0.5"
-          ></path>
-
-          {paths.map((path, index) => (
-            <motion.path
-              key={`path-` + index}
-              d={path}
-              stroke={`url(#linearGradient-${index})`}
-              strokeOpacity="0.4"
-              strokeWidth="0.5"
-            ></motion.path>
-          ))}
-          <defs>
-            {paths.map((path, index) => (
-              <motion.linearGradient
-                id={`linearGradient-${index}`}
-                key={`gradient-${index}`}
-                initial={{
-                  x1: "0%",
-                  x2: "0%",
-                  y1: "0%",
-                  y2: "0%",
-                }}
-                animate={{
-                  x1: ["0%", "100%"],
-                  x2: ["0%", "95%"],
-                  y1: ["0%", "100%"],
-                  y2: ["0%", `${93 + Math.random() * 8}%`],
-                }}
-                transition={{
-                  duration: Math.random() * 10 + 10,
-                  ease: "easeInOut",
-                  repeat: Infinity,
-                  delay: Math.random() * 10,
-                }}
-              >
-                <stop stopColor="#18CCFC" stopOpacity="0"></stop>
-                <stop stopColor="#18CCFC"></stop>
-                <stop offset="32.5%" stopColor="#6344F5"></stop>
-                <stop offset="100%" stopColor="#AE48FF" stopOpacity="0"></stop>
-              </motion.linearGradient>
-            ))}
-
-            <radialGradient
-              id="paint0_radial_242_278"
-              cx="0"
-              cy="0"
-              r="1"
-              gradientUnits="userSpaceOnUse"
-              gradientTransform="translate(352 34) rotate(90) scale(555 1560.62)"
-            >
-              <stop offset="0.0666667" stopColor="#d4d4d4"></stop>
-              <stop offset="0.243243" stopColor="#d4d4d4"></stop>
-              <stop offset="0.43594" stopColor="white" stopOpacity="0"></stop>
-            </radialGradient>
-          </defs>
-        </svg>
-      </div>
-    );
-  },
-);
-
-BackgroundBeams.displayName = "BackgroundBeams";

frontend/hooks/useCountdown.ts

@@ -1,30 +0,0 @@
-'use client'
-import { useEffect, useRef, useCallback, useState } from 'react'
-import { fetchCountdownSync } from '@/lib/api/listings'
-
-export function useCountdown() {
-  const offsets = useRef<Record<number, number>>({})
-  const syncedAt = useRef<number>(Date.now())
-  const [, forceRender] = useState(0)
-
-  useEffect(() => {
-    const sync = async () => {
-      try {
-        const data = await fetchCountdownSync()
-        data.forEach(({ id, time_left_mins }) => { offsets.current[id] = time_left_mins })
-        syncedAt.current = Date.now()
-      } catch {}
-    }
-
-    sync()
-    const syncInterval = setInterval(sync, 60_000)
-    const tickInterval = setInterval(() => forceRender((n) => n + 1), 1_000)
-    return () => { clearInterval(syncInterval); clearInterval(tickInterval) }
-  }, [])
-
-  return useCallback((id: number): number | null => {
-    if (!(id in offsets.current)) return null
-    const elapsed = (Date.now() - syncedAt.current) / 60_000
-    return Math.max(0, offsets.current[id] - elapsed)
-  }, [])
-}

frontend/hooks/useKeywords.ts

@@ -1,32 +0,0 @@
-import { useQuery, useMutation, useQueryClient } from '@tanstack/react-query'
-import { fetchKeywords, addKeyword, updateKeyword, deleteKeyword, reorderKeywords } from '@/lib/api/keywords'
-
-const KEY = ['keywords']
-
-export const useKeywords = () => useQuery({ queryKey: KEY, queryFn: fetchKeywords })
-
-export const useAddKeyword = () => {
-  const qc = useQueryClient()
-  return useMutation({
-    mutationFn: ({ term, weight }: { term: string; weight: number }) => addKeyword(term, weight),
-    onSuccess: () => qc.invalidateQueries({ queryKey: KEY })
-  })
-}
-
-export const useUpdateKeyword = () => {
-  const qc = useQueryClient()
-  return useMutation({
-    mutationFn: ({ id, data }: { id: number; data: Parameters<typeof updateKeyword>[1] }) => updateKeyword(id, data),
-    onSuccess: () => qc.invalidateQueries({ queryKey: KEY })
-  })
-}
-
-export const useDeleteKeyword = () => {
-  const qc = useQueryClient()
-  return useMutation({ mutationFn: deleteKeyword, onSuccess: () => qc.invalidateQueries({ queryKey: KEY }) })
-}
-
-export const useReorderKeywords = () => {
-  const qc = useQueryClient()
-  return useMutation({ mutationFn: reorderKeywords, onSuccess: () => qc.invalidateQueries({ queryKey: KEY }) })
-}

frontend/hooks/useListings.ts

@@ -1,26 +0,0 @@
-import { useQuery, useMutation, useQueryClient } from '@tanstack/react-query'
-import { fetchListings, deleteListing, deleteAllListings } from '@/lib/api/listings'
-
-export function useListings(limit = 100) {
-  return useQuery({
-    queryKey: ['listings', limit],
-    queryFn: () => fetchListings(limit),
-    refetchInterval: 10_000,
-  })
-}
-
-export function useDeleteListing() {
-  const qc = useQueryClient()
-  return useMutation({
-    mutationFn: deleteListing,
-    onSuccess: () => qc.invalidateQueries({ queryKey: ['listings'] }),
-  })
-}
-
-export function useDeleteAllListings() {
-  const qc = useQueryClient()
-  return useMutation({
-    mutationFn: deleteAllListings,
-    onSuccess: () => qc.invalidateQueries({ queryKey: ['listings'] }),
-  })
-}

frontend/hooks/useSSE.ts

@@ -1,37 +0,0 @@
-'use client'
-import { useEffect } from 'react'
-import { useEngineStore } from '@/store/engineStore'
-
-// SSE is disabled in the static build — replaced with plain HTTP polling.
-// EventSource('/api/stream') would always fail (404) since there is no
-// streaming route in the FastAPI-served static build, causing permanent
-// ENGINE OFFLINE display. Polling /api/stats every 5s works in all modes.
-const BASE = 'http://localhost:8000'
-
-export function useSSE() {
-  const setStats  = useEngineStore((s) => s.setStats)
-  const setOffline = useEngineStore((s) => s.setOffline)
-
-  useEffect(() => {
-    let alive = true
-
-    const poll = async () => {
-      try {
-        const res = await fetch(`${BASE}/api/stats`)
-        if (!res.ok) throw new Error('not ok')
-        const data = await res.json()
-        if (alive) setStats(data)   // also clears isOffline via store
-      } catch {
-        if (alive) setOffline(true)
-      }
-    }
-
-    poll()                              // immediate on mount
-    const id = setInterval(poll, 5000)  // then every 5 s
-
-    return () => {
-      alive = false
-      clearInterval(id)
-    }
-  }, [setStats, setOffline])
-}

frontend/hooks/useSites.ts

@@ -1,34 +0,0 @@
-import { useQuery, useMutation, useQueryClient } from '@tanstack/react-query'
-import { fetchSites, updateSite, deleteSite, reorderSites, adaptSite, fetchSiteSelectors } from '@/lib/api/sites'
-import type { TargetSite } from '@/lib/types'
-
-const KEY = ['sites']
-
-export const useSites = () => useQuery({ queryKey: KEY, queryFn: fetchSites })
-export const useSiteSelectors = (id: number) => useQuery({ queryKey: ['selectors', id], queryFn: () => fetchSiteSelectors(id), staleTime: 30_000 })
-
-export const useUpdateSite = () => {
-  const qc = useQueryClient()
-  return useMutation({
-    mutationFn: ({ id, data }: { id: number; data: Partial<TargetSite> }) => updateSite(id, data),
-    onSuccess: () => qc.invalidateQueries({ queryKey: KEY })
-  })
-}
-
-export const useDeleteSite = () => {
-  const qc = useQueryClient()
-  return useMutation({ mutationFn: deleteSite, onSuccess: () => qc.invalidateQueries({ queryKey: KEY }) })
-}
-
-export const useReorderSites = () => {
-  const qc = useQueryClient()
-  return useMutation({ mutationFn: reorderSites, onSuccess: () => qc.invalidateQueries({ queryKey: KEY }) })
-}
-
-export const useAdaptSite = () => {
-  const qc = useQueryClient()
-  return useMutation({
-    mutationFn: adaptSite,
-    onSuccess: (_, id) => qc.invalidateQueries({ queryKey: ['selectors', id] })
-  })
-}

frontend/lib/api/ai.ts

@@ -1,20 +0,0 @@
-const BASE = 'http://localhost:8000'
-
-export const testAI = async (title: string, ai_target: string) => {
-  const res = await fetch(`${BASE}/api/ai/test`, {
-    method: 'POST', headers: { 'Content-Type': 'application/json' },
-    body: JSON.stringify({ title, ai_target }),
-  })
-  if (!res.ok) throw new Error('AI test failed')
-  return res.json() as Promise<{ verdict: string; reason: string }>
-}
-
-export const fetchAILog = async (limit = 50, since_id = 0) => {
-  const res = await fetch(`${BASE}/api/ai/debug/log?limit=${limit}&since_id=${since_id}`)
-  if (!res.ok) throw new Error('Failed to fetch AI log')
-  return res.json()
-}
-
-export const clearAILog = async () => {
-  await fetch(`${BASE}/api/ai/debug/log`, { method: 'DELETE' })
-}

frontend/lib/api/config.ts

@@ -1,18 +0,0 @@
-const BASE = 'http://localhost:8000'
-
-// GET /api/config returns a flat dict {key: value} — return it directly.
-export const fetchConfig = async (): Promise<Record<string, string>> => {
-  const res = await fetch(`${BASE}/api/config`)
-  if (!res.ok) throw new Error('Failed to fetch config')
-  return res.json()
-}
-
-// POST /api/config expects a flat dict {key: value} — send data directly.
-export const saveConfig = async (data: Record<string, string>): Promise<void> => {
-  const res = await fetch(`${BASE}/api/config`, {
-    method: 'POST',
-    headers: { 'Content-Type': 'application/json' },
-    body: JSON.stringify(data),
-  })
-  if (!res.ok) throw new Error('Failed to save config')
-}

frontend/lib/api/engine.ts

@@ -1,7 +0,0 @@
-const BASE = 'http://localhost:8000'
-const call = (path: string) => fetch(`${BASE}/api/engine/${path}`, { method: 'POST' })
-
-export const pauseEngine   = () => call('pause')
-export const resumeEngine  = () => call('resume')
-export const restartEngine = () => call('restart')
-export const killEngine    = () => call('kill')

frontend/lib/api/keywords.ts

@@ -1,38 +0,0 @@
-import type { Keyword } from '@/lib/types'
-const BASE = 'http://localhost:8000'
-
-export const fetchKeywords = async (): Promise<Keyword[]> => {
-  const res = await fetch(`${BASE}/api/keywords`)
-  if (!res.ok) throw new Error('Failed to fetch keywords')
-  return res.json()
-}
-
-export const addKeyword = async (term: string, weight = 1): Promise<Keyword> => {
-  const res = await fetch(`${BASE}/api/keywords`, {
-    method: 'POST', headers: { 'Content-Type': 'application/json' },
-    body: JSON.stringify({ term, weight }),
-  })
-  if (!res.ok) throw new Error('Failed to add keyword')
-  return res.json()
-}
-
-export const updateKeyword = async (id: number, data: Partial<Pick<Keyword, 'term' | 'weight' | 'ai_target' | 'min_price' | 'max_price'>>): Promise<void> => {
-  const res = await fetch(`${BASE}/api/keywords/${id}`, {
-    method: 'PUT', headers: { 'Content-Type': 'application/json' },
-    body: JSON.stringify(data),
-  })
-  if (!res.ok) throw new Error('Failed to update keyword')
-}
-
-export const deleteKeyword = async (id: number): Promise<void> => {
-  const res = await fetch(`${BASE}/api/keywords/${id}`, { method: 'DELETE' })
-  if (!res.ok) throw new Error('Failed to delete keyword')
-}
-
-export const reorderKeywords = async (order: number[]): Promise<void> => {
-  const res = await fetch(`${BASE}/api/keywords/reorder`, {
-    method: 'POST', headers: { 'Content-Type': 'application/json' },
-    body: JSON.stringify({ order }),
-  })
-  if (!res.ok) throw new Error('Failed to reorder')
-}

frontend/lib/api/listings.ts

@@ -1,43 +0,0 @@
-import type { Listing } from '@/lib/types'
-
-const BASE = 'http://localhost:8000/api'
-
-type RawListing = Omit<Listing, 'images' | 'closing_alerts_sent'> & {
-  images: string | null
-  closing_alerts_sent: string | null
-}
-
-export function parseListingResponse(raw: RawListing): Listing {
-  return {
-    ...raw,
-    images: raw.images ? JSON.parse(raw.images) : [],
-    closing_alerts_sent: raw.closing_alerts_sent ? JSON.parse(raw.closing_alerts_sent) : [],
-  }
-}
-
-export async function fetchListings(limit = 100): Promise<Listing[]> {
-  const res = await fetch(`${BASE}/listings?limit=${limit}`)
-  if (!res.ok) throw new Error('Failed to fetch listings')
-  const data: RawListing[] = await res.json()
-  return data.map(parseListingResponse)
-}
-
-export async function deleteListing(id: number): Promise<void> {
-  const res = await fetch(`${BASE}/listings/${id}`, { method: 'DELETE' })
-  if (!res.ok) throw new Error('Failed to delete listing')
-}
-
-export async function deleteAllListings(): Promise<void> {
-  const res = await fetch(`${BASE}/listings`, { method: 'DELETE' })
-  if (!res.ok) throw new Error('Failed to clear listings')
-}
-
-export async function fetchCountdownSync(): Promise<Array<{ id: number; time_left_mins: number }>> {
-  const res = await fetch(`${BASE}/listings/countdown-sync`)
-  if (!res.ok) throw new Error('Failed to sync countdown')
-  return res.json()
-}
-
-// Export endpoints — trigger as browser download, not fetch
-export const getExportUrl = (format: 'csv' | 'json' | 'html') =>
-  `${BASE}/export/${format}`

frontend/lib/api/scoring-rules.ts

@@ -1,44 +0,0 @@
-import type { ScoringRule } from '@/lib/types'
-
-const BASE = 'http://localhost:8000/api'
-
-export async function fetchScoringRules(): Promise<ScoringRule[]> {
-  const res = await fetch(`${BASE}/scoring-rules`)
-  if (!res.ok) throw new Error('Failed to fetch scoring rules')
-  return res.json()
-}
-
-export async function createScoringRule(
-  signal: string,
-  delta: number,
-  notes?: string,
-): Promise<ScoringRule> {
-  const res = await fetch(`${BASE}/scoring-rules`, {
-    method: 'POST',
-    headers: { 'Content-Type': 'application/json' },
-    body: JSON.stringify({ signal, delta, notes }),
-  })
-  if (!res.ok) {
-    const err = await res.json().catch(() => ({}))
-    throw new Error(err.error || 'Failed to create rule')
-  }
-  return res.json()
-}
-
-export async function updateScoringRule(
-  id: number,
-  patch: Partial<Pick<ScoringRule, 'signal' | 'delta' | 'notes'>>,
-): Promise<ScoringRule> {
-  const res = await fetch(`${BASE}/scoring-rules/${id}`, {
-    method: 'PUT',
-    headers: { 'Content-Type': 'application/json' },
-    body: JSON.stringify(patch),
-  })
-  if (!res.ok) throw new Error('Failed to update rule')
-  return res.json()
-}
-
-export async function deleteScoringRule(id: number): Promise<void> {
-  const res = await fetch(`${BASE}/scoring-rules/${id}`, { method: 'DELETE' })
-  if (!res.ok) throw new Error('Failed to delete rule')
-}

frontend/lib/api/sites.ts

@@ -1,45 +0,0 @@
-import type { TargetSite, SiteSelectors } from '@/lib/types'
-const BASE = 'http://localhost:8000'
-
-export const fetchSites = async (): Promise<TargetSite[]> => {
-  const res = await fetch(`${BASE}/api/sites`)
-  if (!res.ok) throw new Error('Failed to fetch sites')
-  return res.json()
-}
-
-export const addSite = async (data: Partial<TargetSite>): Promise<TargetSite> => {
-  const res = await fetch(`${BASE}/api/sites`, { method: 'POST', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify(data) })
-  if (!res.ok) throw new Error('Failed to add site')
-  return res.json()
-}
-
-export const updateSite = async (id: number, data: Partial<TargetSite>): Promise<void> => {
-  const res = await fetch(`${BASE}/api/sites/${id}`, { method: 'PUT', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify(data) })
-  if (!res.ok) throw new Error('Failed to update site')
-}
-
-export const deleteSite = async (id: number): Promise<void> => {
-  const res = await fetch(`${BASE}/api/sites/${id}`, { method: 'DELETE' })
-  if (!res.ok) throw new Error('Failed to delete site')
-}
-
-export const reorderSites = async (order: number[]): Promise<void> => {
-  const res = await fetch(`${BASE}/api/sites/reorder`, { method: 'POST', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify({ order }) })
-  if (!res.ok) throw new Error('Failed to reorder sites')
-}
-
-export const adaptSite = async (id: number): Promise<void> => {
-  const res = await fetch(`${BASE}/api/sites/${id}/adapt`, { method: 'POST' })
-  if (!res.ok) throw new Error('Adapt failed')
-}
-
-export const fetchSiteSelectors = async (id: number): Promise<SiteSelectors | null> => {
-  const res = await fetch(`${BASE}/api/sites/${id}/selectors`)
-  if (res.status === 404) return null
-  if (!res.ok) throw new Error('Failed to fetch selectors')
-  return res.json()
-}
-
-export const deleteSiteSelectors = async (id: number): Promise<void> => {
-  await fetch(`${BASE}/api/sites/${id}/selectors`, { method: 'DELETE' })
-}

frontend/lib/api/system.ts

@@ -1,17 +0,0 @@
-const BASE = 'http://localhost:8000'
-
-export const testTelegram = async (): Promise<{ status: string }> => {
-  const res = await fetch(`${BASE}/api/telegram/test`, { method: 'POST' })
-  if (!res.ok) throw new Error('Telegram test failed')
-  return res.json()
-}
-
-// File downloads — use window.open, not fetch
-export const downloadBackup = () => window.open(`${BASE}/api/backup/download`)
-
-export const restoreBackup = async (file: File): Promise<void> => {
-  const form = new FormData()
-  form.append('file', file)
-  const res = await fetch(`${BASE}/api/backup/restore`, { method: 'POST', body: form })
-  if (!res.ok) throw new Error('Restore failed')
-}

frontend/lib/types.ts

@@ -1,86 +0,0 @@
-export interface Listing {
-  id: number
-  title: string
-  price: number | null
-  currency: string
-  price_raw: string
-  price_usd: number | null
-  time_left: string
-  time_left_mins: number | null
-  link: string
-  score: number
-  keyword: string
-  site_name: string
-  timestamp: string
-  price_updated_at: string | null
-  ai_match: 1 | 0 | null
-  ai_reason: string | null
-  location: string | null
-  images: string[]              // parsed from JSON string at API layer
-  closing_alerts_sent: number[] // parsed from JSON string at API layer
-}
-
-export interface Keyword {
-  id: number
-  term: string
-  weight: number
-  ai_target: string | null
-  min_price: number | null
-  max_price: number | null
-  sort_order: number
-}
-
-export interface TargetSite {
-  id: number
-  name: string
-  url_template: string
-  search_selector: string
-  enabled: 0 | 1
-  max_pages: number
-  last_error: string | null
-  error_count: number
-  consecutive_failures: number
-  last_success_at: string | null
-  cooldown_until: string | null
-  requires_login: 0 | 1
-  login_url: string | null
-  login_check_selector: string | null
-  login_enabled: 0 | 1
-  sort_order: number
-}
-
-export interface SiteSelectors {
-  site_id: number
-  confidence: number
-  container_sel: string | null
-  title_sel: string | null
-  price_sel: string | null
-  time_sel: string | null
-  link_sel: string | null
-  next_page_sel: string | null
-  stale: boolean
-  provider: 'groq' | 'ollama' | null
-  generated_at: string | null
-}
-
-export interface Stats {
-  total_scanned: number
-  total_alerts: number
-  last_cycle: string
-  engine_status: 'Idle' | 'Running' | 'Paused'
-  uptime_start: number
-  uptime_seconds: number
-}
-
-export interface Config {
-  key: string
-  value: string
-}
-
-export interface ScoringRule {
-  id: number
-  signal: string
-  delta: number       // positive = boost, negative = penalty
-  category: 'positive' | 'negative' | 'custom'
-  notes: string
-}

frontend/lib/utils.ts

@@ -1,45 +0,0 @@
-import { clsx, type ClassValue } from "clsx"
-import { twMerge } from "tailwind-merge"
-
-export function cn(...inputs: ClassValue[]) {
-  return twMerge(clsx(inputs))
-}
-
-export function formatUptime(seconds: number): string {
-  const h = Math.floor(seconds / 3600)
-  const m = Math.floor((seconds % 3600) / 60)
-  if (h === 0) return `${m}m`
-  return `${h}h ${m}m`
-}
-
-export function formatMins(mins: number | null): string {
-  if (mins === null) return '—'
-  if (mins < 1) return '<1m'
-  const d = Math.floor(mins / 1440)
-  const h = Math.floor((mins % 1440) / 60)
-  const m = Math.floor(mins % 60)
-  const parts: string[] = []
-  if (d) parts.push(`${d}d`)
-  if (h) parts.push(`${h}h`)
-  parts.push(`${m}m`)
-  return parts.join(' ')
-}
-
-export function formatPrice(price: number | null, currency: string, priceUsd: number | null): string {
-  if (price === null) return '—'
-  const sym: Record<string, string> = {
-    USD: '$', GBP: '£', EUR: '€', JPY: '¥', CAD: 'CA$', AUD: 'A$',
-  }
-  const s = sym[currency] ?? currency + ' '
-  return `${s}${price % 1 === 0 ? price.toLocaleString() : price.toFixed(2)}`
-}
-
-export function timeAgo(isoString: string | null): string {
-  if (!isoString) return 'never'
-  const diff = Math.floor((Date.now() - new Date(isoString).getTime()) / 1000)
-  if (diff < 10) return 'just now'
-  if (diff < 60) return `${diff}s ago`
-  if (diff < 3600) return `${Math.floor(diff / 60)}m ago`
-  if (diff < 86400) return `${Math.floor(diff / 3600)}h ago`
-  return `${Math.floor(diff / 86400)}d ago`
-}

frontend/out/__next.__PAGE__.txt

@@ -1,6 +0,0 @@
-1:"$Sreact.fragment"
-2:I[22612,["/_next/static/chunks/f6c940a452dd3dee.js","/_next/static/chunks/91a2481ea586968a.js","/_next/static/chunks/b40235c9485dbf9a.js","/_next/static/chunks/7b3555f666de0ce2.js"],"default"]
-3:I[97367,["/_next/static/chunks/ff1a16fafef87110.js","/_next/static/chunks/d2be314c3ece3fbe.js"],"OutletBoundary"]
-4:"$Sreact.suspense"
-0:{"buildId":"gDQd4Qw7W4pjnupMrm0GS","rsc":["$","$1","c",{"children":[["$","$L2",null,{}],[["$","script","script-0",{"src":"/_next/static/chunks/7b3555f666de0ce2.js","async":true}]],["$","$L3",null,{"children":["$","$4",null,{"name":"Next.MetadataOutlet","children":"$@5"}]}]]}],"loading":null,"isPartial":false}
-5:null

frontend/out/__next._full.txt

@@ -1,23 +0,0 @@
-1:"$Sreact.fragment"
-2:I[96923,["/_next/static/chunks/f6c940a452dd3dee.js","/_next/static/chunks/91a2481ea586968a.js","/_next/static/chunks/b40235c9485dbf9a.js"],"default"]
-3:I[94313,["/_next/static/chunks/f6c940a452dd3dee.js","/_next/static/chunks/91a2481ea586968a.js","/_next/static/chunks/b40235c9485dbf9a.js"],"default"]
-4:I[93983,["/_next/static/chunks/f6c940a452dd3dee.js","/_next/static/chunks/91a2481ea586968a.js","/_next/static/chunks/b40235c9485dbf9a.js"],"default"]
-5:I[3802,["/_next/static/chunks/f6c940a452dd3dee.js","/_next/static/chunks/91a2481ea586968a.js","/_next/static/chunks/b40235c9485dbf9a.js"],"default"]
-6:I[34172,["/_next/static/chunks/f6c940a452dd3dee.js","/_next/static/chunks/91a2481ea586968a.js","/_next/static/chunks/b40235c9485dbf9a.js"],"default"]
-7:I[39756,["/_next/static/chunks/ff1a16fafef87110.js","/_next/static/chunks/d2be314c3ece3fbe.js"],"default"]
-8:I[37457,["/_next/static/chunks/ff1a16fafef87110.js","/_next/static/chunks/d2be314c3ece3fbe.js"],"default"]
-9:I[22612,["/_next/static/chunks/f6c940a452dd3dee.js","/_next/static/chunks/91a2481ea586968a.js","/_next/static/chunks/b40235c9485dbf9a.js","/_next/static/chunks/7b3555f666de0ce2.js"],"default"]
-a:I[97367,["/_next/static/chunks/ff1a16fafef87110.js","/_next/static/chunks/d2be314c3ece3fbe.js"],"OutletBoundary"]
-b:"$Sreact.suspense"
-d:I[97367,["/_next/static/chunks/ff1a16fafef87110.js","/_next/static/chunks/d2be314c3ece3fbe.js"],"ViewportBoundary"]
-f:I[97367,["/_next/static/chunks/ff1a16fafef87110.js","/_next/static/chunks/d2be314c3ece3fbe.js"],"MetadataBoundary"]
-11:I[68027,[],"default"]
-:HL["/_next/static/chunks/d98b6e292e3c6ff3.css","style"]
-:HL["/_next/static/media/70bc3e132a0a741e-s.p.15008bfb.woff2","font",{"crossOrigin":"","type":"font/woff2"}]
-:HL["/_next/static/media/caa3a2e1cccd8315-s.p.853070df.woff2","font",{"crossOrigin":"","type":"font/woff2"}]
-:HL["/_next/static/media/fba5a26ea33df6a3-s.p.1bbdebe6.woff2","font",{"crossOrigin":"","type":"font/woff2"}]
-0:{"P":null,"b":"gDQd4Qw7W4pjnupMrm0GS","c":["",""],"q":"","i":false,"f":[[["",{"children":["__PAGE__",{}]},"$undefined","$undefined",true],[["$","$1","c",{"children":[[["$","link","0",{"rel":"stylesheet","href":"/_next/static/chunks/d98b6e292e3c6ff3.css","precedence":"next","crossOrigin":"$undefined","nonce":"$undefined"}],["$","script","script-0",{"src":"/_next/static/chunks/f6c940a452dd3dee.js","async":true,"nonce":"$undefined"}],["$","script","script-1",{"src":"/_next/static/chunks/91a2481ea586968a.js","async":true,"nonce":"$undefined"}],["$","script","script-2",{"src":"/_next/static/chunks/b40235c9485dbf9a.js","async":true,"nonce":"$undefined"}]],["$","html",null,{"lang":"en","className":"plus_jakarta_sans_9d745193-module__Fxzc9a__variable jetbrains_mono_82c618bd-module__kTeI0q__variable font-sans geist_da832ead-module__aN_Ytq__variable","children":["$","body",null,{"className":"bg-g-base text-g-text min-h-screen antialiased","children":["$","$L2",null,{"children":[["$","$L3",null,{}],["$","$L4",null,{}],["$","$L5",null,{}],["$","$L6",null,{}],["$","main",null,{"className":"relative px-6 py-8","children":["$","div",null,{"className":"mx-auto max-w-[1400px]","children":["$","$L7",null,{"parallelRouterKey":"children","error":"$undefined","errorStyles":"$undefined","errorScripts":"$undefined","template":["$","$L8",null,{}],"templateStyles":"$undefined","templateScripts":"$undefined","notFound":[[["$","title",null,{"children":"404: This page could not be found."}],["$","div",null,{"style":{"fontFamily":"system-ui,\"Segoe UI\",Roboto,Helvetica,Arial,sans-serif,\"Apple Color Emoji\",\"Segoe UI Emoji\"","height":"100vh","textAlign":"center","display":"flex","flexDirection":"column","alignItems":"center","justifyContent":"center"},"children":["$","div",null,{"children":[["$","style",null,{"dangerouslySetInnerHTML":{"__html":"body{color:#000;background:#fff;margin:0}.next-error-h1{border-right:1px solid rgba(0,0,0,.3)}@media (prefers-color-scheme:dark){body{color:#fff;background:#000}.next-error-h1{border-right:1px solid rgba(255,255,255,.3)}}"}}],["$","h1",null,{"className":"next-error-h1","style":{"display":"inline-block","margin":"0 20px 0 0","padding":"0 23px 0 0","fontSize":24,"fontWeight":500,"verticalAlign":"top","lineHeight":"49px"},"children":404}],["$","div",null,{"style":{"display":"inline-block"},"children":["$","h2",null,{"style":{"fontSize":14,"fontWeight":400,"lineHeight":"49px","margin":0},"children":"This page could not be found."}]}]]}]}]],[]],"forbidden":"$undefined","unauthorized":"$undefined"}]}]}]]}]}]}]]}],{"children":[["$","$1","c",{"children":[["$","$L9",null,{}],[["$","script","script-0",{"src":"/_next/static/chunks/7b3555f666de0ce2.js","async":true,"nonce":"$undefined"}]],["$","$La",null,{"children":["$","$b",null,{"name":"Next.MetadataOutlet","children":"$@c"}]}]]}],{},null,false,false]},null,false,false],["$","$1","h",{"children":[null,["$","$Ld",null,{"children":"$Le"}],["$","div",null,{"hidden":true,"children":["$","$Lf",null,{"children":["$","$b",null,{"name":"Next.Metadata","children":"$L10"}]}]}],["$","meta",null,{"name":"next-size-adjust","content":""}]]}],false]],"m":"$undefined","G":["$11",[]],"S":true}
-e:[["$","meta","0",{"charSet":"utf-8"}],["$","meta","1",{"name":"viewport","content":"width=device-width, initial-scale=1"}]]
-12:I[27201,["/_next/static/chunks/ff1a16fafef87110.js","/_next/static/chunks/d2be314c3ece3fbe.js"],"IconMark"]
-c:null
-10:[["$","title","0",{"children":"Ghost Node — Auction Sniper"}],["$","link","1",{"rel":"icon","href":"/favicon.ico?favicon.0b3bf435.ico","sizes":"256x256","type":"image/x-icon"}],["$","$L12","2",{}]]

frontend/out/__next._head.txt

@@ -1,6 +0,0 @@
-1:"$Sreact.fragment"
-2:I[97367,["/_next/static/chunks/ff1a16fafef87110.js","/_next/static/chunks/d2be314c3ece3fbe.js"],"ViewportBoundary"]
-3:I[97367,["/_next/static/chunks/ff1a16fafef87110.js","/_next/static/chunks/d2be314c3ece3fbe.js"],"MetadataBoundary"]
-4:"$Sreact.suspense"
-5:I[27201,["/_next/static/chunks/ff1a16fafef87110.js","/_next/static/chunks/d2be314c3ece3fbe.js"],"IconMark"]
-0:{"buildId":"gDQd4Qw7W4pjnupMrm0GS","rsc":["$","$1","h",{"children":[null,["$","$L2",null,{"children":[["$","meta","0",{"charSet":"utf-8"}],["$","meta","1",{"name":"viewport","content":"width=device-width, initial-scale=1"}]]}],["$","div",null,{"hidden":true,"children":["$","$L3",null,{"children":["$","$4",null,{"name":"Next.Metadata","children":[["$","title","0",{"children":"Ghost Node — Auction Sniper"}],["$","link","1",{"rel":"icon","href":"/favicon.ico?favicon.0b3bf435.ico","sizes":"256x256","type":"image/x-icon"}],["$","$L5","2",{}]]}]}]}],["$","meta",null,{"name":"next-size-adjust","content":""}]]}],"loading":null,"isPartial":false}

frontend/out/__next._index.txt

@@ -1,10 +0,0 @@
-1:"$Sreact.fragment"
-2:I[96923,["/_next/static/chunks/f6c940a452dd3dee.js","/_next/static/chunks/91a2481ea586968a.js","/_next/static/chunks/b40235c9485dbf9a.js"],"default"]
-3:I[94313,["/_next/static/chunks/f6c940a452dd3dee.js","/_next/static/chunks/91a2481ea586968a.js","/_next/static/chunks/b40235c9485dbf9a.js"],"default"]
-4:I[93983,["/_next/static/chunks/f6c940a452dd3dee.js","/_next/static/chunks/91a2481ea586968a.js","/_next/static/chunks/b40235c9485dbf9a.js"],"default"]
-5:I[3802,["/_next/static/chunks/f6c940a452dd3dee.js","/_next/static/chunks/91a2481ea586968a.js","/_next/static/chunks/b40235c9485dbf9a.js"],"default"]
-6:I[34172,["/_next/static/chunks/f6c940a452dd3dee.js","/_next/static/chunks/91a2481ea586968a.js","/_next/static/chunks/b40235c9485dbf9a.js"],"default"]
-7:I[39756,["/_next/static/chunks/ff1a16fafef87110.js","/_next/static/chunks/d2be314c3ece3fbe.js"],"default"]
-8:I[37457,["/_next/static/chunks/ff1a16fafef87110.js","/_next/static/chunks/d2be314c3ece3fbe.js"],"default"]
-:HL["/_next/static/chunks/d98b6e292e3c6ff3.css","style"]
-0:{"buildId":"gDQd4Qw7W4pjnupMrm0GS","rsc":["$","$1","c",{"children":[[["$","link","0",{"rel":"stylesheet","href":"/_next/static/chunks/d98b6e292e3c6ff3.css","precedence":"next"}],["$","script","script-0",{"src":"/_next/static/chunks/f6c940a452dd3dee.js","async":true}],["$","script","script-1",{"src":"/_next/static/chunks/91a2481ea586968a.js","async":true}],["$","script","script-2",{"src":"/_next/static/chunks/b40235c9485dbf9a.js","async":true}]],["$","html",null,{"lang":"en","className":"plus_jakarta_sans_9d745193-module__Fxzc9a__variable jetbrains_mono_82c618bd-module__kTeI0q__variable font-sans geist_da832ead-module__aN_Ytq__variable","children":["$","body",null,{"className":"bg-g-base text-g-text min-h-screen antialiased","children":["$","$L2",null,{"children":[["$","$L3",null,{}],["$","$L4",null,{}],["$","$L5",null,{}],["$","$L6",null,{}],["$","main",null,{"className":"relative px-6 py-8","children":["$","div",null,{"className":"mx-auto max-w-[1400px]","children":["$","$L7",null,{"parallelRouterKey":"children","template":["$","$L8",null,{}],"notFound":[[["$","title",null,{"children":"404: This page could not be found."}],["$","div",null,{"style":{"fontFamily":"system-ui,\"Segoe UI\",Roboto,Helvetica,Arial,sans-serif,\"Apple Color Emoji\",\"Segoe UI Emoji\"","height":"100vh","textAlign":"center","display":"flex","flexDirection":"column","alignItems":"center","justifyContent":"center"},"children":["$","div",null,{"children":[["$","style",null,{"dangerouslySetInnerHTML":{"__html":"body{color:#000;background:#fff;margin:0}.next-error-h1{border-right:1px solid rgba(0,0,0,.3)}@media (prefers-color-scheme:dark){body{color:#fff;background:#000}.next-error-h1{border-right:1px solid rgba(255,255,255,.3)}}"}}],["$","h1",null,{"className":"next-error-h1","style":{"display":"inline-block","margin":"0 20px 0 0","padding":"0 23px 0 0","fontSize":24,"fontWeight":500,"verticalAlign":"top","lineHeight":"49px"},"children":404}],["$","div",null,{"style":{"display":"inline-block"},"children":["$","h2",null,{"style":{"fontSize":14,"fontWeight":400,"lineHeight":"49px","margin":0},"children":"This page could not be found."}]}]]}]}]],[]]}]}]}]]}]}]}]]}],"loading":null,"isPartial":false}

frontend/out/__next._tree.txt

@@ -1,5 +0,0 @@
-:HL["/_next/static/chunks/d98b6e292e3c6ff3.css","style"]
-:HL["/_next/static/media/70bc3e132a0a741e-s.p.15008bfb.woff2","font",{"crossOrigin":"","type":"font/woff2"}]
-:HL["/_next/static/media/caa3a2e1cccd8315-s.p.853070df.woff2","font",{"crossOrigin":"","type":"font/woff2"}]
-:HL["/_next/static/media/fba5a26ea33df6a3-s.p.1bbdebe6.woff2","font",{"crossOrigin":"","type":"font/woff2"}]
-0:{"buildId":"gDQd4Qw7W4pjnupMrm0GS","tree":{"name":"","paramType":null,"paramKey":"","hasRuntimePrefetch":false,"slots":{"children":{"name":"__PAGE__","paramType":null,"paramKey":"__PAGE__","hasRuntimePrefetch":false,"slots":null,"isRootLayout":false}},"isRootLayout":true},"staleTime":300}